开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
ncbicgi.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：47k
源码类别：

生物技术

开发平台：

C/C++

ncbicgi.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: ncbicgi.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 18:39:19  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.76
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: ncbicgi.cpp,v 1000.2 2004/06/01 18:39:19 gouriano Exp $
  11. * ===========================================================================
  12. *
  13. *                            PUBLIC DOMAIN NOTICE
  14. *               National Center for Biotechnology Information
  15. *
  16. *  This software/database is a "United States Government Work" under the
  17. *  terms of the United States Copyright Act.  It was written as part of
  18. *  the author's official duties as a United States Government employee and
  19. *  thus cannot be copyrighted.  This software/database is freely available
  20. *  to the public for use. The National Library of Medicine and the U.S.
  21. *  Government have not placed any restriction on its use or reproduction.
  22. *
  23. *  Although all reasonable efforts have been taken to ensure the accuracy
  24. *  and reliability of the software and data, the NLM and the U.S.
  25. *  Government do not and cannot warrant the performance or results that
  26. *  may be obtained by using this software or data. The NLM and the U.S.
  27. *  Government disclaim all warranties, express or implied, including
  28. *  warranties of performance, merchantability or fitness for any particular
  29. *  purpose.
  30. *
  31. *  Please cite the author in any work or product based on this material.
  32. *
  33. * ===========================================================================
  34. *
  35. * Author:  Denis Vakatov
  36. *
  37. * File Description:
  38. *   NCBI C++ CGI API:
  39. *      CCgiCookie    -- one CGI cookie
  40. *      CCgiCookies   -- set of CGI cookies
  41. *      CCgiRequest   -- full CGI request
  42. */
  44. #include <ncbi_pch.hpp>
  45. #include <corelib/ncbienv.hpp>
  46. #include <corelib/ncbitime.hpp>
  47. #include <cgi/cgi_exception.hpp>
  48. #include <cgi/ncbicgi.hpp>
  49. #include <stdio.h>
  50. #include <time.h>
  51. #ifdef HAVE_UNISTD_H
  52. #  include <unistd.h>
  53. #else
  54. #  define STDIN_FILENO 0
  55. #endif
  57. // Mac OS has unistd.h, but STDIN_FILENO is not defined
  58. #ifdef NCBI_OS_MAC
  59. #  define STDIN_FILENO 0
  60. #endif
  62. BEGIN_NCBI_SCOPE
  66. ///////////////////////////////////////////////////////
  67. //  CCgiCookie::
  68. //
  70. // auxiliary zero "tm" struct
  71. const tm kZeroTime = { 0,0,0,0,0,0,0,0,0 };
  72. inline bool s_ZeroTime(const tm& date) {
  73.     return (::memcmp(&date, &kZeroTime, sizeof(tm)) == 0);
  74. }
  77. CCgiCookie::CCgiCookie(const CCgiCookie& cookie)
  78.     : m_Name(cookie.m_Name),
  79.       m_Value(cookie.m_Value),
  80.       m_Domain(cookie.m_Domain),
  81.       m_Path(cookie.m_Path)
  82. {
  83.     m_Expires = cookie.m_Expires;
  84.     m_Secure  = cookie.m_Secure;
  85. }
  88. CCgiCookie::CCgiCookie(const string& name,   const string& value,
  89.                        const string& domain, const string& path)
  90. {
  91.     if ( name.empty() )
  92.         throw invalid_argument("Empty cookie name");
  93.     x_CheckField(name, " ;,=");
  94.     m_Name = name;
  96.     SetDomain(domain);
  97.     SetPath(path);
  98.     SetValue(value);
  99.     m_Expires = kZeroTime;
  100.     m_Secure = false;
  101. }
  104. void CCgiCookie::Reset(void)
  105. {
  106.     m_Value.erase();
  107.     m_Domain.erase();
  108.     m_Path.erase();
  109.     m_Expires = kZeroTime;
  110.     m_Secure = false;
  111. }
  114. void CCgiCookie::CopyAttributes(const CCgiCookie& cookie)
  115. {
  116.     if (&cookie == this)
  117.         return;
  119.     m_Value   = cookie.m_Value;
  120.     m_Domain  = cookie.m_Domain;
  121.     m_Path    = cookie.m_Path;
  122.     m_Expires = cookie.m_Expires;
  123.     m_Secure  = cookie.m_Secure;
  124. }
  127. string CCgiCookie::GetExpDate(void) const
  128. {
  129.     if ( s_ZeroTime(m_Expires) )
  130.         return kEmptyStr;
  132.     char str[30];
  133.     if ( !::strftime(str, sizeof(str),
  134.                      "%a, %d %b %Y %H:%M:%S GMT", &m_Expires) ) {
  135.         NCBI_THROW(CCgiErrnoException, eErrno,
  136.                    "CCgiCookie::GetExpDate() -- strftime() failed");
  137.     }
  138.     return string(str);
  139. }
  142. bool CCgiCookie::GetExpDate(tm* exp_date) const
  143. {
  144.     if ( !exp_date )
  145.         throw invalid_argument("Null cookie exp.date");
  146.     if ( s_ZeroTime(m_Expires) )
  147.         return false;
  148.     *exp_date = m_Expires;
  149.     return true;
  150. }
  153. CNcbiOstream& CCgiCookie::Write(CNcbiOstream& os) const
  154. {
  155.     os << "Set-Cookie: ";
  157.     os << m_Name.c_str() << '=';
  158.     if ( !m_Value.empty() )
  159.         os << m_Value.c_str();
  161.     if ( !m_Domain.empty() )
  162.         os << "; domain="  << m_Domain.c_str();
  163.     if ( !m_Path.empty() )
  164.         os << "; path="    << m_Path.c_str();
  165.     string x_ExpDate = GetExpDate();
  166.     if ( !x_ExpDate.empty() )
  167.         os << "; expires=" << x_ExpDate.c_str();
  168.     if ( m_Secure )
  169.         os << "; secure";
  171.     os << HTTP_EOL;
  172.     return os;
  173. }
  176. // Check if the cookie field is valid
  177. void CCgiCookie::x_CheckField(const string& str, const char* banned_symbols)
  178. {
  179.     if (banned_symbols  &&  str.find_first_of(banned_symbols) != NPOS) {
  180.         throw invalid_argument("CCgiCookie::CheckValidCookieField() [1]");
  181.     }
  183.     for (const char* s = str.c_str();  *s;  s++) {
  184.         if ( !isprint(*s) )
  185.             throw invalid_argument("CCgiCookie::CheckValidCookieField() [2]");
  186.     }
  187. }
  190. static bool s_CookieLess
  191. (const string& name1, const string& domain1, const string& path1,
  192.  const string& name2, const string& domain2, const string& path2)
  193. {
  194.     PNocase nocase_less;
  195.     bool x_less;
  197.     x_less = nocase_less(name1, name2);
  198.     if (x_less  ||  nocase_less(name2, name1))
  199.         return x_less;
  201.     x_less = nocase_less(domain1, domain2);
  202.     if (x_less  ||  nocase_less(domain2, domain1))
  203.         return x_less;
  205.     if ( path1.empty() )
  206.         return !path2.empty();
  207.     if ( path2.empty() )
  208.         return false;
  209.     return (path1.compare(path2) > 0);
  210. }
  213. bool CCgiCookie::operator< (const CCgiCookie& cookie)
  214.     const
  215. {
  216.     return s_CookieLess(m_Name, m_Domain, m_Path,
  217.                         cookie.m_Name, cookie.m_Domain, cookie.m_Path);
  218. }
  221. void CCgiCookie::SetExpTime(const CTime& exp_time)
  222. {
  223.     _ASSERT(exp_time.IsGmtTime());
  225.     m_Expires.tm_sec   = exp_time.Second();
  226.     m_Expires.tm_min   = exp_time.Minute();
  227.     m_Expires.tm_hour  = exp_time.Hour();
  228.     m_Expires.tm_mday  = exp_time.Day();
  229.     m_Expires.tm_mon   = exp_time.Month()-1;
  230.     m_Expires.tm_wday  = exp_time.DayOfWeek();
  231.     m_Expires.tm_year  = exp_time.Year()-1900;
  232.     m_Expires.tm_isdst = -1;
  233. }
  236. ///////////////////////////////////////////////////////
  237. //  CCgiCookies::
  238. //
  240. CCgiCookie* CCgiCookies::Add(const string& name,    const string& value,
  241.                              const string& domain , const string& path)
  242. {
  243.     CCgiCookie* ck = Find(name, domain, path);
  244.     if ( ck ) {  // override existing CCgiCookie
  245.         ck->SetValue(value);
  246.     } else {  // create new CCgiCookie and add it
  247.         ck = new CCgiCookie(name, value);
  248.         ck->SetDomain(domain);
  249.         ck->SetPath(path);
  250.         _VERIFY( m_Cookies.insert(ck).second );
  251.     }
  252.     return ck;
  253. }
  256. CCgiCookie* CCgiCookies::Add(const CCgiCookie& cookie)
  257. {
  258.     CCgiCookie* ck = Find
  259.         (cookie.GetName(), cookie.GetDomain(), cookie.GetPath());
  260.     if ( ck ) {  // override existing CCgiCookie
  261.         ck->CopyAttributes(cookie);
  262.     } else {  // create new CCgiCookie and add it
  263.         ck = new CCgiCookie(cookie);
  264.         _VERIFY( m_Cookies.insert(ck).second );
  265.     }
  266.     return ck;
  267. }
  270. void CCgiCookies::Add(const CCgiCookies& cookies)
  271. {
  272.     ITERATE (TSet, cookie, cookies.m_Cookies) {
  273.         Add(**cookie);
  274.     }
  275. }
  278. void CCgiCookies::Add(const string& str)
  279. {
  280.     SIZE_TYPE pos;
  281.     for (pos = str.find_first_not_of(" tn"); ; ){
  282.         SIZE_TYPE pos_beg = str.find_first_not_of(' ', pos);
  283.         if (pos_beg == NPOS)
  284.             return; // done
  286.         SIZE_TYPE pos_mid = str.find_first_of("=;rn", pos_beg);
  287.         if (pos_mid == NPOS) {
  288.             Add(str.substr(pos_beg), kEmptyStr);
  289.             return; // done
  290.         }
  291.         if (str[pos_mid] != '=') {
  292.             Add(str.substr(pos_beg, pos_mid-pos_beg), kEmptyStr);
  293.             if (str[pos_mid] != ';'  ||  ++pos_mid == str.length())
  294.                 return; // done
  295.             pos = pos_mid;
  296.             continue;
  297.         }
  299.         SIZE_TYPE pos_end = str.find_first_of(';', pos_mid);
  300.         if (pos_end != NPOS) {
  301.             pos = pos_end + 1;
  302.             pos_end--;
  303.         } else {
  304.             pos_end = str.find_last_not_of(" tn", str.length());
  305.             if (pos_end == NPOS)
  306.                 break; // error
  307.             pos = NPOS; // about to finish
  308.         }
  310.         Add(str.substr(pos_beg, pos_mid-pos_beg),
  311.             str.substr(pos_mid+1, pos_end-pos_mid));
  312.     }
  313.     NCBI_THROW2(CCgiParseException, eCookie,
  314.                 "Invalid cookie string: `" + str + "'", pos);
  315. }
  318. CNcbiOstream& CCgiCookies::Write(CNcbiOstream& os)
  319.     const
  320. {
  321.     ITERATE (TSet, cookie, m_Cookies) {
  322.         os << **cookie;
  323.     }
  324.     return os;
  325. }
  328. CCgiCookie* CCgiCookies::Find
  329. (const string& name, const string& domain, const string& path)
  330. {
  331.     TCIter iter = m_Cookies.begin();
  332.     while (iter != m_Cookies.end()  &&
  333.            s_CookieLess((*iter)->GetName(), (*iter)->GetDomain(),
  334.                         (*iter)->GetPath(), name, domain, path)) {
  335.         iter++;
  336.     }
  338.     // find exact match
  339.     if (iter != m_Cookies.end()  &&
  340.         !s_CookieLess(name, domain, path, (*iter)->GetName(),
  341.                       (*iter)->GetDomain(), (*iter)->GetPath())) {
  342.         _ASSERT( AStrEquiv(name, (*iter)->GetName(), PNocase()) );
  343.         _ASSERT( AStrEquiv(domain, (*iter)->GetDomain(), PNocase()) );
  344.         _ASSERT( path.compare((*iter)->GetPath()) == 0 );
  345.         return *iter;
  346.     }
  347.     return 0;
  348. }
  351. const CCgiCookie* CCgiCookies::Find
  352. (const string& name, const string& domain, const string& path)
  353.     const
  354. {
  355.     return const_cast<CCgiCookies*>(this)->Find(name, domain, path);
  356. }
  359. CCgiCookie* CCgiCookies::Find(const string& name, TRange* range)
  360. {
  361.     PNocase nocase_less;
  363.     // find the first match
  364.     TIter beg = m_Cookies.begin();
  365.     while (beg != m_Cookies.end()  &&  nocase_less((*beg)->GetName(), name))
  366.         beg++;
  368.     // get this first match only
  369.     if ( !range ) {
  370.         return (beg != m_Cookies.end()  &&
  371.                 !nocase_less(name, (*beg)->GetName())) ? *beg : 0;
  372.     }
  374.     // get the range of equal names
  375.     TIter end = beg;
  376.     while (end != m_Cookies.end()  &&
  377.            !nocase_less(name, (*end)->GetName()))
  378.         end++;
  379.     range->first  = beg;
  380.     range->second = end;
  381.     return (beg == end) ? 0 : *beg;
  382. }
  385. const CCgiCookie* CCgiCookies::Find(const string& name, TCRange* range)
  386.     const
  387. {
  388.     CCgiCookies& nonconst_This = const_cast<CCgiCookies&>(*this);
  389.     if ( range ) {
  390.         TRange x_range;
  391.         const CCgiCookie* ck = nonconst_This.Find(name, &x_range);
  392.         range->first  = x_range.first;
  393.         range->second = x_range.second;
  394.         return ck;
  395.     } else {
  396.         return nonconst_This.Find(name, 0);
  397.     }
  398. }
  401. bool CCgiCookies::Remove(CCgiCookie* cookie, bool destroy)
  402. {
  403.     if (!cookie  ||  m_Cookies.erase(cookie) == 0)
  404.         return false;
  405.     if ( destroy )
  406.         delete cookie;
  407.     return true;
  408. }
  411. size_t CCgiCookies::Remove(TRange& range, bool destroy)
  412. {
  413.     size_t count = 0;
  414.     for (TIter iter = range.first;  iter != range.second;  iter++, count++) {
  415.         if ( destroy )
  416.             delete *iter;
  417.     }
  418.     m_Cookies.erase(range.first, range.second);
  419.     return count;
  420. }
  423. void CCgiCookies::Clear(void)
  424. {
  425.     ITERATE (TSet, cookie, m_Cookies) {
  426.         delete *cookie;
  427.     }
  428.     m_Cookies.clear();
  429. }
  433. ///////////////////////////////////////////////////////
  434. //  CCgiRequest
  435. //
  437. // Standard property names
  438. static const string s_PropName[eCgi_NProperties + 1] = {
  439.     "SERVER_SOFTWARE",
  440.     "SERVER_NAME",
  441.     "GATEWAY_INTERFACE",
  442.     "SERVER_PROTOCOL",
  443.     "SERVER_PORT",
  445.     "REMOTE_HOST",
  446.     "REMOTE_ADDR",
  448.     "CONTENT_TYPE",
  449.     "CONTENT_LENGTH",
  451.     "REQUEST_METHOD",
  452.     "PATH_INFO",
  453.     "PATH_TRANSLATED",
  454.     "SCRIPT_NAME",
  455.     "QUERY_STRING",
  457.     "AUTH_TYPE",
  458.     "REMOTE_USER",
  459.     "REMOTE_IDENT",
  461.     "HTTP_ACCEPT",
  462.     "HTTP_COOKIE",
  463.     "HTTP_IF_MODIFIED_SINCE",
  464.     "HTTP_REFERER",
  465.     "HTTP_USER_AGENT",
  467.     ""  // eCgi_NProperties
  468. };
  471. const string& CCgiRequest::GetPropertyName(ECgiProp prop)
  472. {
  473.     if ((long) prop < 0  ||  (long) eCgi_NProperties <= (long) prop) {
  474.         _TROUBLE;
  475.         throw logic_error("CCgiRequest::GetPropertyName(BadPropIdx)");
  476.     }
  477.     return s_PropName[prop];
  478. }
  481. // Return integer (0..15) corresponding to the "ch" as a hex digit
  482. // Return -1 on error
  483. static int s_HexChar(char ch) THROWS_NONE
  484. {
  485.     if ('0' <= ch  &&  ch <= '9')
  486.         return ch - '0';
  487.     if ('a' <= ch  &&  ch <= 'f')
  488.         return 10 + (ch - 'a');
  489.     if ('A' <= ch  &&  ch <= 'F')
  490.         return 10 + (ch - 'A');
  491.     return -1;
  492. }
  495. // URL-decode string "str" into itself
  496. // Return 0 on success;  otherwise, return 1-based error position
  497. static SIZE_TYPE s_URL_Decode(string& str)
  498. {
  499.     SIZE_TYPE len = str.length();
  500.     if ( !len )
  501.         return 0;
  503.     SIZE_TYPE p = 0;
  504.     for (SIZE_TYPE pos = 0;  pos < len;  p++) {
  505.         switch ( str[pos] ) {
  506.         case '%': {
  507.             if (pos + 2 > len)
  508.                 return (pos + 1);
  509.             int i1 = s_HexChar(str[pos+1]);
  510.             if (i1 < 0  ||  15 < i1)
  511.                 return (pos + 2);
  512.             int i2 = s_HexChar(str[pos+2]);
  513.             if (i2 < 0  ||  15 < i2)
  514.                 return (pos + 3);
  515.             str[p] = s_HexChar(str[pos+1]) * 16 + s_HexChar(str[pos+2]);
  516.             pos += 3;
  517.             break;
  518.         }
  519.         case '+': {
  520.             str[p] = ' ';
  521.             pos++;
  522.             break;
  523.         }
  524.         default:
  525.             str[p] = str[pos++];
  526.         }
  527.     }
  529.     if (p < len) {
  530.         str[p] = '';
  531.         str.resize(p);
  532.     }
  534.     return 0;
  535. }
  538. // Add another entry to the container of entries
  539. void s_AddEntry(TCgiEntries& entries, const string& name,
  540.                 const string& value, unsigned int position,
  541.                 const string& filename = kEmptyStr)
  542. {
  543.     entries.insert(TCgiEntries::value_type
  544.                    (name, CCgiEntry(value, filename, position)));
  545. }
  548. // Parse ISINDEX-like query string into "indexes" XOR "entries" --
  549. // whichever is not null
  550. // Return 0 on success;  return 1-based error position otherwise
  551. static SIZE_TYPE s_ParseIsIndex(const string& str,
  552.                                 TCgiIndexes* indexes, TCgiEntries* entries)
  553. {
  554.     _ASSERT( !indexes != !entries );
  556.     SIZE_TYPE len = str.length();
  557.     if ( !len )
  558.         return 0;
  560.     // No '=' and spaces must present in the parsed string
  561.     SIZE_TYPE err_pos = str.find_first_of("=& trn");
  562.     if (err_pos != NPOS)
  563.         return err_pos + 1;
  565.     // Parse into indexes
  566.     unsigned int num = 1;
  567.     for (SIZE_TYPE beg = 0;  beg < len;  ) {
  568.         // parse and URL-decode ISINDEX name
  569.         SIZE_TYPE end = str.find_first_of('+', beg);
  570.         if (end == beg  ||  end == len-1)
  571.             return end + 1;  // error
  572.         if (end == NPOS)
  573.             end = len;
  575.         string name = str.substr(beg, end - beg);
  576.         if ((err_pos = s_URL_Decode(name)) != 0)
  577.             return beg + err_pos;  // error
  579.         // store
  580.         if ( indexes ) {
  581.             indexes->push_back(name);
  582.         } else {
  583.             s_AddEntry(*entries, name, kEmptyStr, num++);
  584.         }
  586.         // continue
  587.         beg = end + 1;
  588.     }
  589.     return 0;
  590. }
  593. // Guess if "str" is ISINDEX- or FORM-like, then fill out
  594. // "entries" XOR "indexes";  if "indexes_as_entries" is "true" then
  595. // interprete indexes as FORM-like entries(with empty value) and so
  596. // put them to "entries"
  597. static void s_ParseQuery(const string& str,
  598.                          TCgiEntries&  entries,
  599.                          TCgiIndexes&  indexes,
  600.                          bool          indexes_as_entries)
  601. {
  602.     if (str.find_first_of("=&") == NPOS) { // ISINDEX
  603.         SIZE_TYPE err_pos = indexes_as_entries ?
  604.             s_ParseIsIndex(str, 0, &entries) :
  605.             s_ParseIsIndex(str, &indexes, 0);
  606.         if (err_pos != 0)
  607.             NCBI_THROW2(CCgiParseException, eIndex,
  608.                         "Init CCgiRequest::ParseISINDEX("" +
  609.                         str + """, err_pos);
  610.     } else {  // regular(FORM) entries
  611.         SIZE_TYPE err_pos = CCgiRequest::ParseEntries(str, entries);
  612.         if (err_pos != 0)
  613.             NCBI_THROW2(CCgiParseException, eEntry,
  614.                         "Init CCgiRequest::ParseFORM("" +
  615.                         str + "")", err_pos);
  616.     }
  617. }
  620. static string s_FindAttribute(const string& str, const string& name,
  621.                               SIZE_TYPE start, SIZE_TYPE end,
  622.                               bool required)
  623. {
  624.     SIZE_TYPE att_pos = str.find("; " + name + "="", start);
  625.     if (att_pos == NPOS  ||  att_pos >= end) {
  626.         if (required) {
  627.             NCBI_THROW2(CCgiParseException, eAttribute,
  628.                         "s_FindAttribute: missing " + name + " in "
  629.                         + str.substr(start, end - start),
  630.                         start);
  631.         } else {
  632.             return kEmptyStr;
  633.         }
  634.     }
  635.     SIZE_TYPE att_start = att_pos + name.size() + 4;
  636.     SIZE_TYPE att_end   = str.find('"', att_start);
  637.     if (att_end == NPOS  ||  att_end >= end) {
  638.         NCBI_THROW2(CCgiParseException, eFormat,
  639.                     "s_FindAttribute: malformatted " + name + " in "
  640.                     + str.substr(att_pos, end - att_pos),
  641.                     att_start);
  642.     }
  643.     return str.substr(att_start, att_end - att_start);
  644. }
  647. static void s_ParseMultipartEntries(const string& boundary,
  648.                                     const string& str,
  649.                                     TCgiEntries&  entries)
  650. {
  651.     const string    s_Me("s_ParseMultipartEntries");
  652.     const string    s_Eol(HTTP_EOL);
  653.     const SIZE_TYPE eol_size = s_Eol.size();
  655.     SIZE_TYPE    pos           = 0;
  656.     SIZE_TYPE    boundary_size = boundary.size();
  657.     SIZE_TYPE    end_pos;
  658.     unsigned int num           = 1;
  660.     if (NStr::Compare(str, 0, boundary_size + eol_size, boundary + s_Eol)
  661.         != 0) {
  662.         if (NStr::StartsWith(str, boundary + "--")) {
  663.             // potential corner case: no actual data
  664.             return;
  665.         }
  666.         NCBI_THROW2(CCgiParseException, eEntry,
  667.                     s_Me + ": input does not start with boundary line "
  668.                     + boundary,
  669.                     0);
  670.     }
  672.     {{
  673.         SIZE_TYPE tail_size = boundary_size + eol_size + 2;
  674.         SIZE_TYPE tail_start = str.find(s_Eol + boundary + "--");
  675.         if (tail_start == NPOS) {
  676.             NCBI_THROW2(CCgiParseException, eEntry,
  677.                         s_Me + ": input does not contain trailing boundary "
  678.                         + boundary + "--",
  679.                         0);
  680.         }
  681.         end_pos = tail_start + tail_size;
  682.     }}
  684.     pos += boundary_size + eol_size;
  685.     while (pos < end_pos) {
  686.         SIZE_TYPE next_boundary = str.find(s_Eol + boundary, pos);
  687.         _ASSERT(next_boundary != NPOS);
  688.         string name, filename;
  689.         bool found = false;
  690.         for (;;) {
  691.             SIZE_TYPE bol_pos = pos, eol_pos = str.find(s_Eol, pos);
  692.             _ASSERT(eol_pos != NPOS);
  693.             if (pos == eol_pos) {
  694.                 // blank -- end of headers
  695.                 pos += eol_size;
  696.                 break;
  697.             }
  698.             pos = str.find(':', bol_pos);
  699.             if (pos == NPOS  ||  pos >= eol_pos) {
  700.                 NCBI_THROW2(CCgiParseException, eEntry,
  701.                             s_Me + ": no colon in header "
  702.                             + str.substr(bol_pos, eol_pos - bol_pos),
  703.                             bol_pos);
  704.             }
  705.             if (NStr::CompareNocase(str, bol_pos, pos - bol_pos,
  706.                                     "Content-Disposition") != 0) {
  707.                 ERR_POST(Warning << s_Me << ": ignoring unrecognized header "
  708.                          + str.substr(bol_pos, eol_pos - bol_pos));
  709.                 pos = eol_pos + eol_size;
  710.                 continue;
  711.             }
  712.             if (NStr::CompareNocase(str, pos, 13, ": form-data; ") != 0) {
  713.                 NCBI_THROW2(CCgiParseException, eEntry,
  714.                             s_Me + ": bad Content-Disposition header "
  715.                             + str.substr(bol_pos, eol_pos - bol_pos),
  716.                             pos);
  717.             }
  718.             pos += 11;
  719.             name     = s_FindAttribute(str, "name",     pos, eol_pos, true);
  720.             filename = s_FindAttribute(str, "filename", pos, eol_pos, false);
  721.             found = true;
  722.             pos = eol_pos + eol_size;
  723.         }
  724.         if (!found) {
  725.             NCBI_THROW2(CCgiParseException, eEntry,
  726.                         s_Me + ": missing Content-Disposition header", pos);
  727.         }
  728.         s_AddEntry(entries, name, str.substr(pos, next_boundary - pos),
  729.                    num++, filename);
  730.         pos = next_boundary + 2*eol_size + boundary_size;
  731.     }
  732. }
  735. static void s_ParsePostQuery(const string& content_type, const string& str,
  736.                              TCgiEntries& entries)
  737. {
  738.     if (content_type.empty()  ||
  739.         content_type == "application/x-www-form-urlencoded") {
  740.         // remove trailing end of line 'r' and/or 'n'
  741.         // (this can happen if Content-Length: was not specified)
  742.         SIZE_TYPE err_pos;
  743.         SIZE_TYPE eol = str.find_first_of("rn");
  744.         if (eol != NPOS) {
  745.             err_pos = CCgiRequest::ParseEntries(str.substr(0, eol), entries);
  746.         } else {
  747.             err_pos = CCgiRequest::ParseEntries(str, entries);
  748.         }
  749.         if ( err_pos != 0 ) {
  750.             NCBI_THROW2(CCgiParseException, eEntry,
  751.                         "Init CCgiRequest::ParseFORM("" +
  752.                         str + "")", err_pos);
  753.         }
  754.         return;
  755.     }
  757.     if ( NStr::StartsWith(content_type, "multipart/form-data") ) {
  758.         string start = "boundary=";
  759.         SIZE_TYPE pos = content_type.find(start);
  760.         if ( pos == NPOS )
  761.             NCBI_THROW2(CCgiParseException, eEntry,
  762.                         "CCgiRequest::ParsePostQuery("" +
  763.                         content_type + ""): no boundary field", 0);
  764.         s_ParseMultipartEntries("--" + content_type.substr(pos + start.size()),
  765.                                 str, entries);
  766.         return;
  767.     }
  769.     // The caller function thinks that s_ParsePostQuery() knows how to parse
  770.     // this content type, but s_ParsePostQuery() apparently cannot do it...
  771.     _TROUBLE;
  772. }
  775. CCgiRequest::~CCgiRequest(void)
  776. {
  777.     SetInputStream(0);
  778. }
  781. CCgiRequest::CCgiRequest
  782. (const CNcbiArguments*   args,
  783.  const CNcbiEnvironment* env,
  784.  CNcbiIstream*           istr,
  785.  TFlags                  flags,
  786.  int                     ifd,
  787.  size_t                  errbuf_size)
  788.     : m_Env(0),
  789.       m_ErrBufSize(errbuf_size)
  790. {
  791.     x_Init(args, env, istr, flags, ifd);
  792. }
  795. CCgiRequest::CCgiRequest
  796. (int                argc,
  797.  const char* const* argv,
  798.  const char* const* envp,
  799.  CNcbiIstream*      istr,
  800.  TFlags             flags,
  801.  int                ifd,
  802.  size_t             errbuf_size)
  803.     : m_Env(0),
  804.       m_ErrBufSize(errbuf_size)
  805. {
  806.     CNcbiArguments args(argc, argv);
  808.     CNcbiEnvironment* env = new CNcbiEnvironment(envp);
  809.     flags |= fOwnEnvironment;
  811.     x_Init(&args, env, istr, flags, ifd);
  812. }
  815. void CCgiRequest::x_Init
  816. (const CNcbiArguments*   args,
  817.  const CNcbiEnvironment* env,
  818.  CNcbiIstream*           istr,
  819.  TFlags                  flags,
  820.  int                     ifd)
  821. {
  822.     // Setup environment variables
  823.     _ASSERT( !m_Env );
  824.     m_Env = env;
  825.     if ( !m_Env ) {
  826.         // create a dummy environment, if is not specified
  827.         m_OwnEnv.reset(new CNcbiEnvironment);
  828.         m_Env = m_OwnEnv.get();
  829.     } else if ((flags & fOwnEnvironment) != 0) {
  830.         // take ownership over the passed environment object
  831.         m_OwnEnv.reset(const_cast<CNcbiEnvironment*>(m_Env));
  832.     }
  834.     // Cache "standard" properties
  835.     for (size_t prop = 0;  prop < (size_t) eCgi_NProperties;  prop++) {
  836.         x_GetPropertyByName(GetPropertyName((ECgiProp) prop));
  837.     }
  839.     // Compose cookies
  840.     m_Cookies.Add(GetProperty(eCgi_HttpCookie));
  842.     // Parse entries or indexes from "$QUERY_STRING" or cmd.-line args
  843.     {{
  844.         const string* query_string = 0;
  845.         if ( GetProperty(eCgi_RequestMethod).empty() ) {
  846.             // special case: "$REQUEST_METHOD" undefined, so use cmd.-line args
  847.             if (args  &&  args->Size() > 1)
  848.                 query_string = &(*args)[1];
  849.         }
  850.         else if ( !(flags & fIgnoreQueryString) ) {
  851.             // regular case -- read from "$QUERY_STRING"
  852.             query_string = &GetProperty(eCgi_QueryString);
  853.         }
  855.         if ( query_string ) {
  856.             s_ParseQuery(*query_string, m_Entries, m_Indexes,
  857.                          (flags & fIndexesNotEntries) == 0);
  858.         }
  859.     }}
  861.     // POST method?
  862.     if ( AStrEquiv(GetProperty(eCgi_RequestMethod), "POST", PNocase()) ) {
  863.         if ( !istr ) {
  864.             istr = &NcbiCin;  // default input stream
  865.             ifd = STDIN_FILENO;
  866.         }
  868.         const string& content_type = GetProperty(eCgi_ContentType);
  869.         if ((flags & fDoNotParseContent) == 0  &&
  870.             (content_type.empty()  ||
  871.              content_type == "application/x-www-form-urlencoded"  ||
  872.              NStr::StartsWith(content_type, "multipart/form-data"))) {
  873.             // Automagically retrieve and parse content into entries
  874.             string str;
  875.             size_t len = GetContentLength();
  876.             if (len == kContentLengthUnknown) {
  877.                 // read data until end of file
  878.                 for (;;) {
  879.                     char buffer[1024];
  880.                     istr->read(buffer, sizeof(buffer));
  881.                     size_t count = istr->gcount();
  882.                     if ( count == 0 ) {
  883.                         if ( istr->eof() ) {
  884.                             break; // end of data
  885.                         }
  886.                         else {
  887.                             THROW1_TRACE(runtime_error, "
  888. CCgiRequest::x_Init() -- error in reading POST content: read fault");
  889.                         }
  890.                     }
  891.                     str.append(buffer, count);
  892.                 }
  893.             }
  894.             else {
  895.                 str.resize(len);
  896.                 for (size_t pos = 0;  pos < len;  ) {
  897.                     size_t rlen = len - pos;
  898.                     istr->read(&str[pos], rlen);
  899.                     size_t count = istr->gcount();
  900.                     if ( count == 0 ) {
  901.                         str.resize(pos);
  902.                         if ( istr->eof() ) {
  903.                             string err = "
  904. CCgiRequest::x_Init() -- error in reading POST content: unexpected EOF";
  905.                             string pos_str("(pos=");
  906.                             pos_str.append(NStr::UIntToString(pos));
  907.                             pos_str.append("; content_length=");
  908.                             pos_str.append(NStr::UIntToString(len));
  909.                             pos_str.append("):n");
  911.                             if (m_ErrBufSize  &&  pos) {
  912.                                 pos_str.append(NStr::PrintableString(str),
  913.                                                0, min(m_ErrBufSize, pos));
  914.                                 if (m_ErrBufSize < pos) {
  915.                                     pos_str.append("n[truncated...]");
  916.                                 }
  917.                             }
  918.                             err.append(pos_str);
  919.                             THROW1_TRACE(runtime_error, err);
  920.                         }
  921.                         else {
  922.                             THROW1_TRACE(runtime_error, "
  923. CCgiRequest::x_Init() -- error in reading POST content: read fault");
  924.                         }
  925.                     }
  926.                     pos += count;
  927.                 }
  928.             }
  929.             // parse query from the POST content
  930.             s_ParsePostQuery(content_type, str, m_Entries);
  931.             m_Input    = 0;
  932.             m_InputFD = -1;
  933.         }
  934.         else {
  935.             // Let the user to retrieve and parse the content
  936.             m_Input    = istr;
  937.             m_InputFD  = ifd;
  938.             m_OwnInput = false;
  939.         }
  940.     } else {
  941.         m_Input   = 0;
  942.         m_InputFD = -1;
  943.     }
  945.     // Check for an IMAGEMAP input entry like: "Command.x=5&Command.y=3" and
  946.     // put them with empty string key for better access
  947.     if (m_Entries.find(kEmptyStr) != m_Entries.end()) {
  948.         // there is already empty name key
  949.         ERR_POST("empty key name:  we will not check for IMAGE names");
  950.         return;
  951.     }
  952.     string image_name;
  953.     ITERATE (TCgiEntries, i, m_Entries) {
  954.         const string& entry = i->first;
  956.         // check for our case ("*.x")
  957.         if ( !NStr::EndsWith(entry, ".x") )
  958.             continue;
  960.         // get base name of IMAGE, check for the presence of ".y" part
  961.         string name = entry.substr(0, entry.size() - 2);
  962.         if (m_Entries.find(name + ".y") == m_Entries.end())
  963.             continue;
  965.         // it is a correct IMAGE name
  966.         if ( !image_name.empty() ) {
  967.             ERR_POST("duplicated IMAGE name: "" << image_name <<
  968.                      "" and "" << name << """);
  969.             return;
  970.         }
  971.         image_name = name;
  972.     }
  973.     s_AddEntry(m_Entries,   kEmptyStr, image_name, 0);
  974. }
  977. const string& CCgiRequest::x_GetPropertyByName(const string& name) const
  978. {
  979.     return m_Env->Get(name);
  980. }
  983. const string& CCgiRequest::GetProperty(ECgiProp property) const
  984. {
  985.     return x_GetPropertyByName(GetPropertyName(property));
  986. }
  989. const string& CCgiRequest::GetRandomProperty(const string& key, bool http)
  990.     const
  991. {
  992.     if ( http ) {
  993.         return x_GetPropertyByName("HTTP_" + key);
  994.     } else {
  995.         return x_GetPropertyByName(key);
  996.     }
  997. }
  1000. const CCgiEntry& CCgiRequest::GetEntry(const string& name, bool* is_found)
  1001.     const
  1002. {
  1003.     static const CCgiEntry kEmptyEntry(kEmptyStr);
  1004.     TCgiEntriesCI it = GetEntries().find(name);
  1005.     bool x_found = (it != GetEntries().end());
  1006.     if ( is_found ) {
  1007.         *is_found = x_found;
  1008.     }
  1009.     return x_found ? it->second : kEmptyEntry;
  1010. }
  1013. const size_t CCgiRequest::kContentLengthUnknown = (size_t)(-1);
  1016. size_t CCgiRequest::GetContentLength(void) const
  1017. {
  1018.     const string& str = GetProperty(eCgi_ContentLength);
  1019.     if ( str.empty() ) {
  1020.         return kContentLengthUnknown;
  1021.     }
  1022.     return (size_t) NStr::StringToUInt(str);
  1023. }
  1026. void CCgiRequest::SetInputStream(CNcbiIstream* is, bool own, int fd)
  1027. {
  1028.     if (m_Input  &&  m_OwnInput  &&  is != m_Input) {
  1029.         delete m_Input;
  1030.     }
  1031.     m_Input    = is;
  1032.     m_InputFD  = fd;
  1033.     m_OwnInput = own;
  1034. }
  1037. SIZE_TYPE CCgiRequest::ParseEntries(const string& str, TCgiEntries& entries)
  1038. {
  1039.     SIZE_TYPE len = str.length();
  1040.     if ( !len )
  1041.         return 0;
  1043.     // If no '=' present in the parsed string then try to parse it as ISINDEX
  1044.     if (str.find_first_of("&=") == NPOS)
  1045.         return s_ParseIsIndex(str, 0, &entries);
  1047.     // No spaces are allowed in the parsed string
  1048.     SIZE_TYPE err_pos = str.find_first_of(" trn");
  1049.     if (err_pos != NPOS)
  1050.         return err_pos + 1;
  1052.     // Parse into entries
  1053.     unsigned int num = 1;
  1054.     for (SIZE_TYPE beg = 0;  beg < len;  ) {
  1055.         // ignore 1st ampersand (it is just a temp. slack to some biz. clients)
  1056.         if (beg == 0  &&  str[0] == '&') {
  1057.             beg = 1;
  1058.             continue;
  1059.         }
  1061.         // kludge for the sake of some older browsers, which fail to decode
  1062.         // "&amp;" within hrefs.
  1063.         if ( !NStr::CompareNocase(str, beg, 4, "amp;") ) {
  1064.             beg += 4;
  1065.         }
  1067.         // parse and URL-decode name
  1068.         SIZE_TYPE mid = str.find_first_of("=&", beg);
  1069.         if (mid == beg  ||
  1070.             (mid != NPOS  &&  str[mid] == '&'  &&  mid == len-1))
  1071.             return mid + 1;  // error
  1072.         if (mid == NPOS)
  1073.             mid = len;
  1075.         string name = str.substr(beg, mid - beg);
  1076.         if ((err_pos = s_URL_Decode(name)) != 0)
  1077.             return beg + err_pos;  // error
  1079.         // parse and URL-decode value(if any)
  1080.         string value;
  1081.         if (str[mid] == '=') { // has a value
  1082.             mid++;
  1083.             SIZE_TYPE end = str.find_first_of(" &", mid);
  1084.             if (end != NPOS  &&  (str[end] != '&'  ||  end == len-1))
  1085.                 return end + 1;  // error
  1086.             if (end == NPOS)
  1087.                 end = len;
  1089.             value = str.substr(mid, end - mid);
  1090.             if ((err_pos = s_URL_Decode(value)) != 0)
  1091.                 return mid + err_pos;  // error
  1093.             beg = end + 1;
  1094.         } else {  // has no value
  1095.             beg = mid + 1;
  1096.         }
  1098.         // store the name-value pair
  1099.         s_AddEntry(entries, name, value, num++);
  1100.     }
  1101.     return 0;
  1102. }
  1105. SIZE_TYPE CCgiRequest::ParseIndexes(const string& str, TCgiIndexes& indexes)
  1106. {
  1107.     return s_ParseIsIndex(str, &indexes, 0);
  1108. }
  1112. extern string URL_DecodeString(const string& str)
  1113. {
  1114.     string    x_str = str;
  1115.     SIZE_TYPE err_pos = s_URL_Decode(x_str);
  1116.     if (err_pos != 0)
  1117.         NCBI_THROW2(CCgiParseException, eFormat,
  1118.                     "URL_DecodeString(<badly_formatted_str>)",err_pos);
  1119.     return x_str;
  1120. }
  1123. extern string URL_EncodeString(const string& str, EUrlEncode encode_mark_chars)
  1124. {
  1125.     static const char s_Encode[256][4] = {
  1126.         "%00", "%01", "%02", "%03", "%04", "%05", "%06", "%07",
  1127.         "%08", "%09", "%0A", "%0B", "%0C", "%0D", "%0E", "%0F",
  1128.         "%10", "%11", "%12", "%13", "%14", "%15", "%16", "%17",
  1129.         "%18", "%19", "%1A", "%1B", "%1C", "%1D", "%1E", "%1F",
  1130.         "+",   "!",   "%22", "%23", "$",   "%25", "%26", "'",
  1131.         "(",   ")",   "*",   "%2B", ",",   "-",   ".",   "%2F",
  1132.         "0",   "1",   "2",   "3",   "4",   "5",   "6",   "7",
  1133.         "8",   "9",   "%3A", "%3B", "%3C", "%3D", "%3E", "%3F",
  1134.         "%40", "A",   "B",   "C",   "D",   "E",   "F",   "G",
  1135.         "H",   "I",   "J",   "K",   "L",   "M",   "N",   "O",
  1136.         "P",   "Q",   "R",   "S",   "T",   "U",   "V",   "W",
  1137.         "X",   "Y",   "Z",   "%5B", "%5C", "%5D", "%5E", "_",
  1138.         "%60", "a",   "b",   "c",   "d",   "e",   "f",   "g",
  1139.         "h",   "i",   "j",   "k",   "l",   "m",   "n",   "o",
  1140.         "p",   "q",   "r",   "s",   "t",   "u",   "v",   "w",
  1141.         "x",   "y",   "z",   "%7B", "%7C", "%7D", "%7E", "%7F",
  1142.         "%80", "%81", "%82", "%83", "%84", "%85", "%86", "%87",
  1143.         "%88", "%89", "%8A", "%8B", "%8C", "%8D", "%8E", "%8F",
  1144.         "%90", "%91", "%92", "%93", "%94", "%95", "%96", "%97",
  1145.         "%98", "%99", "%9A", "%9B", "%9C", "%9D", "%9E", "%9F",
  1146.         "%A0", "%A1", "%A2", "%A3", "%A4", "%A5", "%A6", "%A7",
  1147.         "%A8", "%A9", "%AA", "%AB", "%AC", "%AD", "%AE", "%AF",
  1148.         "%B0", "%B1", "%B2", "%B3", "%B4", "%B5", "%B6", "%B7",
  1149.         "%B8", "%B9", "%BA", "%BB", "%BC", "%BD", "%BE", "%BF",
  1150.         "%C0", "%C1", "%C2", "%C3", "%C4", "%C5", "%C6", "%C7",
  1151.         "%C8", "%C9", "%CA", "%CB", "%CC", "%CD", "%CE", "%CF",
  1152.         "%D0", "%D1", "%D2", "%D3", "%D4", "%D5", "%D6", "%D7",
  1153.         "%D8", "%D9", "%DA", "%DB", "%DC", "%DD", "%DE", "%DF",
  1154.         "%E0", "%E1", "%E2", "%E3", "%E4", "%E5", "%E6", "%E7",
  1155.         "%E8", "%E9", "%EA", "%EB", "%EC", "%ED", "%EE", "%EF",
  1156.         "%F0", "%F1", "%F2", "%F3", "%F4", "%F5", "%F6", "%F7",
  1157.         "%F8", "%F9", "%FA", "%FB", "%FC", "%FD", "%FE", "%FF"
  1158.     };
  1160.     static const char s_EncodeMarkChars[256][4] = {
  1161.         "%00", "%01", "%02", "%03", "%04", "%05", "%06", "%07",
  1162.         "%08", "%09", "%0A", "%0B", "%0C", "%0D", "%0E", "%0F",
  1163.         "%10", "%11", "%12", "%13", "%14", "%15", "%16", "%17",
  1164.         "%18", "%19", "%1A", "%1B", "%1C", "%1D", "%1E", "%1F",
  1165.         "+",   "%21", "%22", "%23", "%24", "%25", "%26", "%27",
  1166.         "%28", "%29", "%2A", "%2B", "%2C", "%2D", "%2E", "%2F",
  1167.         "0",   "1",   "2",   "3",   "4",   "5",   "6",   "7",
  1168.         "8",   "9",   "%3A", "%3B", "%3C", "%3D", "%3E", "%3F",
  1169.         "%40", "A",   "B",   "C",   "D",   "E",   "F",   "G",
  1170.         "H",   "I",   "J",   "K",   "L",   "M",   "N",   "O",
  1171.         "P",   "Q",   "R",   "S",   "T",   "U",   "V",   "W",
  1172.         "X",   "Y",   "Z",   "%5B", "%5C", "%5D", "%5E", "%5F",
  1173.         "%60", "a",   "b",   "c",   "d",   "e",   "f",   "g",
  1174.         "h",   "i",   "j",   "k",   "l",   "m",   "n",   "o",
  1175.         "p",   "q",   "r",   "s",   "t",   "u",   "v",   "w",
  1176.         "x",   "y",   "z",   "%7B", "%7C", "%7D", "%7E", "%7F",
  1177.         "%80", "%81", "%82", "%83", "%84", "%85", "%86", "%87",
  1178.         "%88", "%89", "%8A", "%8B", "%8C", "%8D", "%8E", "%8F",
  1179.         "%90", "%91", "%92", "%93", "%94", "%95", "%96", "%97",
  1180.         "%98", "%99", "%9A", "%9B", "%9C", "%9D", "%9E", "%9F",
  1181.         "%A0", "%A1", "%A2", "%A3", "%A4", "%A5", "%A6", "%A7",
  1182.         "%A8", "%A9", "%AA", "%AB", "%AC", "%AD", "%AE", "%AF",
  1183.         "%B0", "%B1", "%B2", "%B3", "%B4", "%B5", "%B6", "%B7",
  1184.         "%B8", "%B9", "%BA", "%BB", "%BC", "%BD", "%BE", "%BF",
  1185.         "%C0", "%C1", "%C2", "%C3", "%C4", "%C5", "%C6", "%C7",
  1186.         "%C8", "%C9", "%CA", "%CB", "%CC", "%CD", "%CE", "%CF",
  1187.         "%D0", "%D1", "%D2", "%D3", "%D4", "%D5", "%D6", "%D7",
  1188.         "%D8", "%D9", "%DA", "%DB", "%DC", "%DD", "%DE", "%DF",
  1189.         "%E0", "%E1", "%E2", "%E3", "%E4", "%E5", "%E6", "%E7",
  1190.         "%E8", "%E9", "%EA", "%EB", "%EC", "%ED", "%EE", "%EF",
  1191.         "%F0", "%F1", "%F2", "%F3", "%F4", "%F5", "%F6", "%F7",
  1192.         "%F8", "%F9", "%FA", "%FB", "%FC", "%FD", "%FE", "%FF"
  1193.     };
  1195.     string url_str;
  1197.     SIZE_TYPE len = str.length();
  1198.     if ( !len )
  1199.         return url_str;
  1201.     const char (*encode_table)[4] =
  1202.         encode_mark_chars == eUrlEncode_SkipMarkChars
  1203.         ? s_Encode : s_EncodeMarkChars;
  1205.     SIZE_TYPE pos;
  1206.     SIZE_TYPE url_len = len;
  1207.     const unsigned char* cstr = (const unsigned char*)str.c_str();
  1208.     for (pos = 0;  pos < len;  pos++) {
  1209.         if (encode_table[cstr[pos]][0] == '%')
  1210.             url_len += 2;
  1211.     }
  1212.     url_str.reserve(url_len + 1);
  1213.     url_str.resize(url_len);
  1215.     SIZE_TYPE p = 0;
  1216.     for (pos = 0;  pos < len;  pos++, p++) {
  1217.         const char* subst = encode_table[cstr[pos]];
  1218.         if (*subst != '%') {
  1219.             url_str[p] = *subst;
  1220.         } else {
  1221.             url_str[  p] = '%';
  1222.             url_str[++p] = *(++subst);
  1223.             url_str[++p] = *(++subst);
  1224.         }
  1225.     }
  1227.     _ASSERT( p == url_len );
  1228.     url_str[url_len] = '';
  1229.     return url_str;
  1230. }
  1233. END_NCBI_SCOPE
  1237. /*
  1238. * ===========================================================================
  1239. * $Log: ncbicgi.cpp,v $
  1240. * Revision 1000.2  2004/06/01 18:39:19  gouriano
  1241. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.76
  1242. *
  1243. * Revision 1.76  2004/05/17 20:56:50  gorelenk
  1244. * Added include of PCH ncbi_pch.hpp
  1245. *
  1246. * Revision 1.75  2003/11/24 18:14:58  ucko
  1247. * CCgiRequest::ParseEntries: Swallow "amp;" (case-insensitive) after &
  1248. * for the sake of some older browsers that misparse HREF attributes.
  1249. *
  1250. * Revision 1.74  2003/10/15 17:06:02  ucko
  1251. * CCgiRequest::x_Init: truncate str properly in the case of unexpected EOF.
  1252. *
  1253. * Revision 1.73  2003/08/20 19:41:34  ucko
  1254. * CCgiRequest::ParseEntries: handle unencoded = signs in values.
  1255. *
  1256. * Revision 1.72  2003/07/14 20:28:46  vakatov
  1257. * CCgiCookie::GetExpDate() -- date format to conform with RFC1123
  1258. *
  1259. * Revision 1.71  2003/07/08 19:04:12  ivanov
  1260. * Added optional parameter to the URL_Encode() to enable mark charactres
  1261. * encoding
  1262. *
  1263. * Revision 1.70  2003/06/04 00:22:53  ucko
  1264. * Improve diagnostics in CCgiRequest::x_Init.
  1265. *
  1266. * Revision 1.69  2003/04/16 21:48:19  vakatov
  1267. * Slightly improved logging format, and some minor coding style fixes.
  1268. *
  1269. * Revision 1.68  2003/03/12 16:10:23  kuznets
  1270. * iterate -> ITERATE
  1271. *
  1272. * Revision 1.67  2003/03/11 19:17:31  kuznets
  1273. * Improved error diagnostics in CCgiRequest
  1274. *
  1275. * Revision 1.66  2003/02/24 20:01:54  gouriano
  1276. * use template-based exceptions instead of errno and parse exceptions
  1277. *
  1278. * Revision 1.65  2003/02/19 17:50:47  kuznets
  1279. * Added function AddExpTime to CCgiCookie class
  1280. *
  1281. * Revision 1.64  2002/09/17 19:57:50  ucko
  1282. * Add position field to CGI entries; minor reformatting.
  1283. *
  1284. * Revision 1.63  2002/08/08 19:26:04  ucko
  1285. * When parsing multipart forms, allow (but ignore) data after the
  1286. * trailing boundary.
  1287. *
  1288. * Revision 1.62  2002/07/19 14:50:23  ucko
  1289. * Substitute NStr::Compare for uses of string::compare added in last revision.
  1290. *
  1291. * Revision 1.61  2002/07/18 21:15:24  ucko
  1292. * Rewrite multipart/form-data parser; the old line-by-line approach was
  1293. * somewhat clumsy and inefficient.
  1294. *
  1295. * Revision 1.60  2002/07/18 20:18:09  lebedev
  1296. * NCBI_OS_MAC: STDIN_FILENO define added
  1297. *
  1298. * Revision 1.59  2002/07/17 17:02:26  ucko
  1299. * Reinstate more lost changes from R1.56.
  1300. *
  1301. * Revision 1.58  2002/07/11 17:39:56  gouriano
  1302. * corrected wrong merge of v1.56 and v1.57
  1303. *
  1304. * Revision 1.57  2002/07/11 14:22:59  gouriano
  1305. * exceptions replaced by CNcbiException-type ones
  1306. *
  1307. * Revision 1.56  2002/07/10 18:40:21  ucko
  1308. * Made CCgiEntry-based functions the only version; kept "Ex" names as
  1309. * temporary synonyms, to go away in a few days.
  1310. *
  1311. * Revision 1.55  2002/07/05 20:45:46  ucko
  1312. * Add a couple of missing calls to the extended version of s_AddEntry.
  1313. *
  1314. * Revision 1.54  2002/07/03 20:24:31  ucko
  1315. * Extend to support learning uploaded files' names; move CVS logs to end.
  1316. *
  1317. * Revision 1.53  2002/04/26 21:18:31  lavr
  1318. * Do not enforce the last line of the form to have HTTP_EOL (but just EOF)
  1319. *
  1320. * Revision 1.52  2002/01/10 23:48:55  vakatov
  1321. * s_ParseMultipartEntries() -- allow for empty parts
  1322. *
  1323. * Revision 1.51  2001/12/06 00:19:55  vakatov
  1324. * CCgiRequest::ParseEntries() -- allow leading '&' in the query string (temp.)
  1325. *
  1326. * Revision 1.50  2001/10/04 18:17:53  ucko
  1327. * Accept additional query parameters for more flexible diagnostics.
  1328. * Support checking the readiness of CGI input and output streams.
  1329. *
  1330. * Revision 1.49  2001/06/19 20:08:30  vakatov
  1331. * CCgiRequest::{Set,Get}InputStream()  -- to provide safe access to the
  1332. * requests' content body
  1333. *
  1334. * Revision 1.48  2001/06/13 21:04:37  vakatov
  1335. * Formal improvements and general beautifications of the CGI lib sources.
  1336. *
  1337. * Revision 1.47  2001/05/17 15:01:49  lavr
  1338. * Typos corrected
  1339. *
  1340. * Revision 1.46  2001/02/02 20:55:13  vakatov
  1341. * CCgiRequest::GetEntry() -- "const"
  1342. *
  1343. * Revision 1.45  2001/01/30 23:17:31  vakatov
  1344. * + CCgiRequest::GetEntry()
  1345. *
  1346. * Revision 1.44  2000/11/01 20:36:31  vasilche
  1347. * Added HTTP_EOL string macro.
  1348. *
  1349. * Revision 1.43  2000/06/26 16:34:27  vakatov
  1350. * CCgiCookies::Add(const string&) -- maimed to workaround MS IE bug
  1351. * (it sent empty cookies w/o "=" in versions prior to 5.5)
  1352. *
  1353. * Revision 1.42  2000/05/04 16:29:12  vakatov
  1354. * s_ParsePostQuery():  do not throw on an unknown Content-Type
  1355. *
  1356. * Revision 1.41  2000/05/02 16:10:07  vasilche
  1357. * CGI: Fixed URL parsing when Content-Length header is missing.
  1358. *
  1359. * Revision 1.40  2000/05/01 16:58:18  vasilche
  1360. * Allow missing Content-Length and Content-Type headers.
  1361. *
  1362. * Revision 1.39  2000/02/15 19:25:33  vakatov
  1363. * CCgiRequest::ParseEntries() -- fixed UMR
  1364. *
  1365. * Revision 1.38  2000/02/01 22:19:57  vakatov
  1366. * CCgiRequest::GetRandomProperty() -- allow to retrieve value of
  1367. * properties whose names are not prefixed by "HTTP_" (optional).
  1368. * Get rid of the aux.methods GetServerPort() and GetRemoteAddr() which
  1369. * are obviously not widely used (but add to the volume of API).
  1370. *
  1371. * Revision 1.37  2000/02/01 16:53:29  vakatov
  1372. * CCgiRequest::x_Init() -- parse "$QUERY_STRING"(or cmd.-line arg) even
  1373. * in the case of "POST" method, in order to catch possible "ACTION" args.
  1374. *
  1375. * Revision 1.36  2000/01/20 17:52:07  vakatov
  1376. * Two CCgiRequest:: constructors:  one using raw "argc", "argv", "envp",
  1377. * and another using auxiliary classes "CNcbiArguments" and "CNcbiEnvironment".
  1378. * + constructor flag CCgiRequest::fOwnEnvironment to take ownership over
  1379. * the passed "CNcbiEnvironment" object.
  1380. *
  1381. * Revision 1.35  1999/12/30 22:11:17  vakatov
  1382. * CCgiCookie::GetExpDate() -- use a more standard time string format.
  1383. * CCgiCookie::CCgiCookie() -- check the validity of passed cookie attributes
  1384. *
  1385. * Revision 1.34  1999/11/22 19:07:47  vakatov
  1386. * CCgiRequest::CCgiRequest() -- check for the NULL "query_string"
  1387. *
  1388. * Revision 1.33  1999/11/02 22:15:50  vakatov
  1389. * const CCgiCookie* CCgiCookies::Find() -- forgot to cast to non-const "this"
  1390. *
  1391. * Revision 1.32  1999/11/02 20:35:42  vakatov
  1392. * Redesigned of CCgiCookie and CCgiCookies to make them closer to the
  1393. * cookie standard, smarter, and easier in use
  1394. *
  1395. * Revision 1.31  1999/06/21 16:04:17  vakatov
  1396. * CCgiRequest::CCgiRequest() -- the last(optional) arg is of type
  1397. * "TFlags" rather than the former "bool"
  1398. *
  1399. * Revision 1.30  1999/05/11 03:11:51  vakatov
  1400. * Moved the CGI API(along with the relevant tests) from "corelib/" to "cgi/"
  1401. *
  1402. * Revision 1.29  1999/05/04 16:14:45  vasilche
  1403. * Fixed problems with program environment.
  1404. * Added class CNcbiEnvironment for cached access to C environment.
  1405. *
  1406. * Revision 1.28  1999/05/04 00:03:12  vakatov
  1407. * Removed the redundant severity arg from macro ERR_POST()
  1408. *
  1409. * Revision 1.27  1999/05/03 20:32:29  vakatov
  1410. * Use the (newly introduced) macro from <corelib/ncbidbg.h>:
  1411. *   RETHROW_TRACE,
  1412. *   THROW0_TRACE(exception_class),
  1413. *   THROW1_TRACE(exception_class, exception_arg),
  1414. *   THROW_TRACE(exception_class, exception_args)
  1415. * instead of the former (now obsolete) macro _TRACE_THROW.
  1416. *
  1417. * Revision 1.26  1999/04/30 19:21:03  vakatov
  1418. * Added more details and more control on the diagnostics
  1419. * See #ERR_POST, EDiagPostFlag, and ***DiagPostFlag()
  1420. *
  1421. * Revision 1.25  1999/04/28 16:54:42  vasilche
  1422. * Implemented stream input processing for FastCGI applications.
  1423. * Fixed POST request parsing
  1424. *
  1425. * Revision 1.24  1999/04/14 21:01:22  vakatov
  1426. * s_HexChar():  get rid of "::tolower()"
  1427. *
  1428. * Revision 1.23  1999/04/14 20:11:56  vakatov
  1429. * + <stdio.h>
  1430. * Changed all "str.compare(...)" to "NStr::Compare(str, ...)"
  1431. *
  1432. * Revision 1.22  1999/04/14 17:28:58  vasilche
  1433. * Added parsing of CGI parameters from IMAGE input tag like "cmd.x=1&cmd.y=2"
  1434. * As a result special parameter is added with empty name: "=cmd"
  1435. *
  1436. * Revision 1.21  1999/03/01 21:02:22  vasilche
  1437. * Added parsing of 'form-data' requests.
  1438. *
  1439. * Revision 1.20  1999/01/07 22:03:42  vakatov
  1440. * s_URL_Decode():  typo fixed
  1441. *
  1442. * Revision 1.19  1999/01/07 21:15:22  vakatov
  1443. * Changed prototypes for URL_DecodeString() and URL_EncodeString()
  1444. *
  1445. * Revision 1.18  1999/01/07 20:06:04  vakatov
  1446. * + URL_DecodeString()
  1447. * + URL_EncodeString()
  1448. *
  1449. * Revision 1.17  1998/12/28 17:56:36  vakatov
  1450. * New CVS and development tree structure for the NCBI C++ projects
  1451. *
  1452. * Revision 1.16  1998/12/04 23:38:35  vakatov
  1453. * Workaround SunPro's "buggy const"(see "BW_01")
  1454. * Renamed "CCgiCookies::Erase()" method to "...Clear()"
  1455. *
  1456. * Revision 1.15  1998/12/01 00:27:19  vakatov
  1457. * Made CCgiRequest::ParseEntries() to read ISINDEX data, too.
  1458. * Got rid of now redundant CCgiRequest::ParseIndexesAsEntries()
  1459. *
  1460. * Revision 1.14  1998/11/30 21:23:19  vakatov
  1461. * CCgiRequest:: - by default, interprete ISINDEX data as regular FORM entries
  1462. * + CCgiRequest::ParseIndexesAsEntries()
  1463. * Allow FORM entry in format "name1&name2....." (no '=' necessary after name)
  1464. *
  1465. * Revision 1.13  1998/11/27 20:55:21  vakatov
  1466. * CCgiRequest::  made the input stream arg. be optional(std.input by default)
  1467. *
  1468. * Revision 1.12  1998/11/27 19:44:34  vakatov
  1469. * CCgiRequest::  Engage cmd.-line args if "$REQUEST_METHOD" is undefined
  1470. *
  1471. * Revision 1.11  1998/11/27 15:54:05  vakatov
  1472. * Cosmetics in the ParseEntries() diagnostics
  1473. *
  1474. * Revision 1.10  1998/11/26 00:29:53  vakatov
  1475. * Finished NCBI CGI API;  successfully tested on MSVC++ and SunPro C++ 5.0
  1476. *
  1477. * Revision 1.9  1998/11/24 23:07:30  vakatov
  1478. * Draft(almost untested) version of CCgiRequest API
  1479. *
  1480. * Revision 1.8  1998/11/24 21:31:32  vakatov
  1481. * Updated with the ISINDEX-related code for CCgiRequest::
  1482. * TCgiEntries, ParseIndexes(), GetIndexes(), etc.
  1483. *
  1484. * Revision 1.7  1998/11/24 17:52:17  vakatov
  1485. * Starting to implement CCgiRequest::
  1486. * Fully implemented CCgiRequest::ParseEntries() static function
  1487. *
  1488. * Revision 1.6  1998/11/20 22:36:40  vakatov
  1489. * Added destructor to CCgiCookies:: class
  1490. * + Save the works on CCgiRequest:: class in a "compilable" state
  1491. *
  1492. * Revision 1.4  1998/11/19 23:41:12  vakatov
  1493. * Tested version of "CCgiCookie::" and "CCgiCookies::"
  1494. *
  1495. * Revision 1.3  1998/11/19 20:02:51  vakatov
  1496. * Logic typo:  actually, the cookie string does not contain "Cookie: "
  1497. *
  1498. * Revision 1.2  1998/11/19 19:50:03  vakatov
  1499. * Implemented "CCgiCookies::"
  1500. * Slightly changed "CCgiCookie::" API
  1501. *
  1502. * Revision 1.1  1998/11/18 21:47:53  vakatov
  1503. * Draft version of CCgiCookie::
  1504. * ==========================================================================
  1505. */