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

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

生物技术

开发平台：

C/C++

ncbi_connutil.c：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: ncbi_connutil.c,v $
  4.  * PRODUCTION Revision 1000.3  2004/04/12 17:06:12  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [CATCHUP_003] Dev-tree R6.64
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: ncbi_connutil.c,v 1000.3 2004/04/12 17:06:12 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, Anton Lavrentiev
  36.  *
  37.  * File Description:
  38.  *   Auxiliary API, mostly CONN-, URL-, and MIME-related
  39.  *   (see in "ncbi_connutil.h" for more details).
  40.  *
  41.  */
  43. #include "ncbi_ansi_ext.h"
  44. #include "ncbi_priv.h"
  45. #include <connect/ncbi_connutil.h>
  46. #include <ctype.h>
  47. #include <errno.h>
  48. #include <stdlib.h>
  51. static const char* s_GetValue(const char* service, const char* param,
  52.                               char* value, size_t value_size,
  53.                               const char* def_value)
  54. {
  55.     char        key[250];
  56.     char*       sec;
  57.     const char* val;
  59.     if (!param  ||  !value  ||  value_size <= 0)
  60.         return 0;
  61.     *value = '';
  63.     if (service  &&  *service) {
  64.         /* Service-specific inquiry */
  65.         if (strlen(service) + 1 + sizeof(DEF_CONN_REG_SECTION) +
  66.             strlen(param) + 1 > sizeof(key))
  67.             return 0;
  68.         /* First, environment search for 'service_CONN_param' */
  69.         sprintf(key, "%s_" DEF_CONN_REG_SECTION "_%s", service, param);
  70.         strupr(key);
  71.         if ((val = getenv(key)) != 0)
  72.             return strncpy0(value, val, value_size - 1);
  73.         /* Next, search for 'CONN_param' in '[service]' registry section */
  74.         sprintf(key, DEF_CONN_REG_SECTION "_%s", param);
  75.         sec = key + strlen(key) + 1;
  76.         strupr(key);
  77.         strcpy(sec, service);
  78.         strupr(sec);
  79.         CORE_REG_GET(sec, key, value, value_size, 0);
  80.         if (*value)
  81.             return value;
  82.     } else {
  83.         /* Common case. Form 'CONN_param' */
  84.         if (sizeof(DEF_CONN_REG_SECTION) + strlen(param) + 1 > sizeof(key))
  85.             return 0;
  86.         sprintf(key, DEF_CONN_REG_SECTION "_%s", param);
  87.         strupr(key);
  88.     }
  90.     /* Environment search for 'CONN_param' */
  91.     if ((val = getenv(key)) != 0)
  92.         return strncpy0(value, val, value_size - 1);
  94.     /* Last resort: Search for 'param' in default registry section */
  95.     strcpy(key, param);
  96.     strupr(key);
  97.     CORE_REG_GET(DEF_CONN_REG_SECTION, key, value, value_size, def_value);
  99.     return value;
  100. }
  103. /***********************************************************************
  104.  *  EXTERNAL
  105.  ***********************************************************************/
  108. extern SConnNetInfo* ConnNetInfo_Create(const char* service)
  109. {
  110. #define REG_VALUE(name, value, def_value) 
  111.     s_GetValue(service, name, value, sizeof(value), def_value)
  113.     SConnNetInfo* info = (SConnNetInfo*) malloc(sizeof(*info) +
  114.                                                 (service  &&  *service
  115.                                                  ? strlen(service) + 1 : 0));
  116.     /* aux. storage for the string-to-int conversions, etc. */
  117.     char   str[32];
  118.     int    val;
  119.     double dbl;
  120.     char*  s;
  122.     if (!info)
  123.         return 0/*failure*/;
  125.     /* client host */
  126.     if (!SOCK_gethostbyaddr(0, info->client_host, sizeof(info->client_host)))
  127.         SOCK_gethostname(info->client_host, sizeof(info->client_host));
  129.     /* dispatcher host name */
  130.     REG_VALUE(REG_CONN_HOST, info->host, DEF_CONN_HOST);
  132.     /* dispatcher port number */
  133.     REG_VALUE(REG_CONN_PORT, str, 0);
  134.     val = atoi(str);
  135.     info->port = (unsigned short)(val > 0 ? val : DEF_CONN_PORT);
  137.     /* service path */
  138.     REG_VALUE(REG_CONN_PATH, info->path, DEF_CONN_PATH);
  140.     /* service args */
  141.     REG_VALUE(REG_CONN_ARGS, info->args, DEF_CONN_ARGS);
  143.     /* request method */
  144.     REG_VALUE(REG_CONN_REQ_METHOD, str, DEF_CONN_REQ_METHOD);
  145.     if (!*str  ||  strcasecmp(str, "ANY") == 0)
  146.         info->req_method = eReqMethod_Any;
  147.     else if (strcasecmp(str, "POST") == 0)
  148.         info->req_method = eReqMethod_Post;
  149.     else if (strcasecmp(str, "GET") == 0)
  150.         info->req_method = eReqMethod_Get;
  152.     /* connection timeout */
  153.     REG_VALUE(REG_CONN_TIMEOUT, str, 0);
  154.     if (strlen(str) > 2  &&  strncasecmp(str, "infinite", strlen(str)) == 0) {
  155.         info->timeout = 0;
  156.     } else {
  157.         info->timeout = &info->tmo;
  158.         dbl = atof(str);
  159.         if (dbl <= 0.0)
  160.             dbl = DEF_CONN_TIMEOUT;
  161.         info->timeout->sec  = (unsigned int) dbl;
  162.         info->timeout->usec = (unsigned int)
  163.             ((dbl - info->timeout->sec) * 1000000);
  164.     }
  166.     /* max. # of attempts to establish connection */
  167.     REG_VALUE(REG_CONN_MAX_TRY, str, 0);
  168.     val = atoi(str);
  169.     info->max_try = (unsigned short)(val > 0 ? val : DEF_CONN_MAX_TRY);
  171.     /* HTTP proxy server? */
  172.     REG_VALUE(REG_CONN_HTTP_PROXY_HOST, info->http_proxy_host,
  173.               DEF_CONN_HTTP_PROXY_HOST);
  174.     if (*info->http_proxy_host) {
  175.         /* yes, use the specified HTTP proxy server */
  176.         REG_VALUE(REG_CONN_HTTP_PROXY_PORT, str, 0);
  177.         val = atoi(str);
  178.         info->http_proxy_port = (unsigned short)
  179.             (val > 0 ? val : DEF_CONN_HTTP_PROXY_PORT);
  180.     } else
  181.         info->http_proxy_port = DEF_CONN_HTTP_PROXY_PORT;
  183.     /* non-transparent CERN-like firewall proxy server? */
  184.     REG_VALUE(REG_CONN_PROXY_HOST, info->proxy_host, DEF_CONN_PROXY_HOST);
  186.     /* turn on debug printout? */
  187.     REG_VALUE(REG_CONN_DEBUG_PRINTOUT, str, DEF_CONN_DEBUG_PRINTOUT);
  188.     if (*str  &&
  189.         (strcmp(str, "1") == 0  ||
  190.          strcasecmp(str, "true") == 0  ||
  191.          strcasecmp(str, "yes" ) == 0  ||
  192.          strcasecmp(str, "some") == 0)) {
  193.         info->debug_printout = eDebugPrintout_Some;
  194.     } else if (*str  &&
  195.                (strcasecmp(str, "data") == 0  ||
  196.                 strcasecmp(str, "all" ) == 0)) {
  197.         info->debug_printout = eDebugPrintout_Data;
  198.     } else
  199.         info->debug_printout = eDebugPrintout_None;
  201.     /* stateless client? */
  202.     REG_VALUE(REG_CONN_STATELESS, str, DEF_CONN_STATELESS);
  203.     info->stateless = (*str  &&
  204.                        (strcmp(str, "1") == 0  ||
  205.                         strcasecmp(str, "true") == 0  ||
  206.                         strcasecmp(str, "yes" ) == 0));
  208.     /* firewall mode? */
  209.     REG_VALUE(REG_CONN_FIREWALL, str, DEF_CONN_FIREWALL);
  210.     info->firewall = (*str  &&
  211.                       (strcmp(str, "1") == 0  ||
  212.                        strcasecmp(str, "true") == 0  ||
  213.                        strcasecmp(str, "yes" ) == 0));
  215.     /* prohibit the use of local load balancer? */
  216.     REG_VALUE(REG_CONN_LB_DISABLE, str, DEF_CONN_LB_DISABLE);
  217.     info->lb_disable = (*str  &&
  218.                         (strcmp(str, "1") == 0  ||
  219.                          strcasecmp(str, "true") == 0  ||
  220.                          strcasecmp(str, "yes" ) == 0));
  222.     /* has no user header yet... */
  223.     info->http_user_header = 0;
  224.     /* not adjusted yet... */
  225.     info->http_proxy_adjusted = 0/*false*/;
  226.     /* store service name for which this structure has been created */
  227.     if (service  &&  *service) {
  228.         s = (char*) info + sizeof(*info);
  229.         strcpy(s, service);
  230.     } else
  231.         s = 0;
  232.     info->service = s;
  234.     /* done */
  235.     return info;
  236. #undef REG_VALUE
  237. }
  240. extern int/*bool*/ ConnNetInfo_AdjustForHttpProxy(SConnNetInfo* info)
  241. {
  242.     if (info->http_proxy_adjusted  ||  !*info->http_proxy_host)
  243.         return 0/*false*/;
  245.     if (strlen(info->host) + strlen(info->path) + 16 > sizeof(info->path)) {
  246.         CORE_LOG(eLOG_Error,
  247.                  "[ConnNetInfo_AdjustForHttpProxy]  Adjusted path too long");
  248.         assert(0);
  249.         return 0/*false*/;
  250.     }
  252.     {{
  253.         char x_path[sizeof(info->path)];
  254.         sprintf(x_path, "http://%s:%hu%s%s", info->host, info->port,
  255.                 *info->path == '/' ? "" : "/", info->path);
  256.         assert(strlen(x_path) < sizeof(x_path));
  257.         strcpy(info->path, x_path);
  258.     }}
  260.     assert(sizeof(info->host) >= sizeof(info->http_proxy_host));
  261.     strncpy0(info->host, info->http_proxy_host, sizeof(info->host) - 1);
  262.     info->port = info->http_proxy_port;
  263.     info->http_proxy_adjusted = 1/*true*/;
  264.     return 1/*true*/;
  265. }
  268. extern int/*bool*/ ConnNetInfo_ParseURL(SConnNetInfo* info, const char* url)
  269. {
  270.     const char *s, *a;
  271.     char* p;
  273.     if (info->http_proxy_adjusted) {
  274.         /* undo proxy adjustment */
  275.         SConnNetInfo* temp = ConnNetInfo_Create(info->service);
  276.         if (!ConnNetInfo_ParseURL(temp, info->path)) {
  277.             ConnNetInfo_Destroy(temp);
  278.             return 0/*failure*/;
  279.         }
  280.         memcpy(info->host, temp->host, sizeof(info->host));
  281.         info->port = temp->port;
  282.         memcpy(info->path, temp->path, sizeof(info->path));
  283.         ConnNetInfo_Destroy(temp);
  284.         info->http_proxy_adjusted = 0/*false*/;
  285.     }
  287.     /* host & port first [both optional] */
  288.     if ((s = strstr(url, "://")) != 0) {
  289.         const char* h = s + 3; /* host starts here */
  291.         if (strncasecmp(url, "http://", 7) != 0)
  292.             return 0/*failure*/;
  293.         if (!(s = strchr(h, '/')))
  294.             s = h + strlen(h);
  295.         /* host ends at "a" */
  296.         if ((a = strchr(h, ':')) != 0 && a < s) {
  297.             unsigned short port;
  298.             int n;
  300.             if (sscanf(a, ":%hu%n", &port, &n) < 1 || a + n != s)
  301.                 return 0/*failure*/;
  302.             info->port = port;
  303.         } else
  304.             a = s;
  305.         if ((size_t)(a - h) < sizeof(info->host)) {
  306.             memcpy(info->host, h, (size_t)(a - h));
  307.             info->host[(size_t)(a - h)] = '';
  308.         } else {
  309.             memcpy(info->host, h, sizeof(info->host) - 1);
  310.             info->host[sizeof(info->host) - 1] = '';
  311.         }
  312.     } else
  313.         s = url;
  315.     /* arguments */
  316.     if ((a = strchr(s, '?')) != 0)
  317.         strncpy0(info->args, a + 1, sizeof(info->args) - 1);
  318.     else
  319.         a = s + strlen(s);
  321.     /* path (NB: can be relative) */
  322.     if (s != url || *s == '/' || !(p = strrchr(info->path, '/'))) {
  323.         /* absolute path */
  324.         p = info->path;
  325.         if (!*s) {
  326.             s = "/";   /* in case of an empty path we take the root '/' */
  327.             a = s + 1;
  328.         }
  329.     } else
  330.         p++;
  331.     if ((size_t)(a - s) < sizeof(info->path) - (size_t)(p - info->path)) {
  332.         memcpy(p, s, (size_t)(a - s));
  333.         p[(size_t)(a - s)] = '';
  334.     } else {
  335.         memcpy(p, s, sizeof(info->path) - (size_t)(p - info->path) - 1);
  336.         info->path[sizeof(info->path) - 1] = '';
  337.     }
  339.     return 1/*success*/;
  340. }
  343. extern int/*bool*/ ConnNetInfo_SetUserHeader(SConnNetInfo* info,
  344.                                       const char*   user_header)
  345. {
  346.     if (info->http_user_header)
  347.         free((void*) info->http_user_header);
  348.     if (user_header && *user_header) {
  349.         info->http_user_header = strdup(user_header);
  350.         return info->http_user_header ? 1/*success*/ : 0/*failure*/;
  351.     } else
  352.         info->http_user_header = 0;
  353.     return 1/*success*/;
  354. }
  357. extern int/*bool*/ ConnNetInfo_AppendUserHeader(SConnNetInfo* info,
  358.                                                 const char*   user_header)
  359. {
  360.     size_t oldlen, newlen;
  361.     char* new_header;
  363.     if (!info->http_user_header || !(oldlen = strlen(info->http_user_header)))
  364.         return ConnNetInfo_SetUserHeader(info, user_header);
  366.     if (!user_header || !(newlen = strlen(user_header)))
  367.         return 1/*success*/;
  369.     new_header = (char*)
  370.         realloc((void*) info->http_user_header, oldlen + newlen + 1);
  371.     if (!new_header)
  372.         return 0/*failure*/;
  374.     memcpy(&new_header[oldlen], user_header, newlen + 1);
  375.     info->http_user_header = new_header;
  376.     return 1/*success*/;
  377. }
  380. typedef enum {
  381.     eUserHeaderOp_Delete,
  382.     eUserHeaderOp_Extend,
  383.     eUserHeaderOp_Override
  384. } EUserHeaderOp;
  387. static int/*bool*/ s_ModifyUserHeader(SConnNetInfo* info,
  388.                                       const char*   user_header,
  389.                                       EUserHeaderOp op)
  390. {
  391.     int/*bool*/ retval;
  392.     char*  new_header;
  393.     size_t newlinelen;
  394.     size_t newhdrlen;
  395.     char*  newline;
  396.     size_t hdrlen;
  397.     char*  hdr;
  399.     if (!user_header || !(newhdrlen = strlen(user_header)))
  400.         return 1/*success*/;
  402.     if (!(hdr = (char*) info->http_user_header) || !(hdrlen = strlen(hdr))) {
  403.         if (op == eUserHeaderOp_Delete)
  404.             return 1/*success*/;
  405.         if (!hdr && !(hdr = strdup("")))
  406.             return 0/*failure*/;
  407.         hdrlen = 0;
  408.     }
  410.     if (op != eUserHeaderOp_Delete) {
  411.         if (!(new_header = (char*) malloc(newhdrlen + 1)))
  412.             return 0/*failure*/;
  413.         memcpy(new_header, user_header, newhdrlen + 1);
  414.     } else
  415.         new_header = (char*) user_header; /* we actually won't modify it! */
  417.     retval = 1/*assume best: success*/;
  418.     for (newline = new_header; *newline; newline += newlinelen) {
  419.         char*  eol = strchr(newline, 'n');
  420.         char*  eot = strchr(newline,  ':');
  421.         int/*bool*/ used = 0;
  422.         size_t newtaglen;
  423.         char*  newtagval;
  424.         size_t linelen;
  425.         char*  line;
  426.         size_t len;
  427.         size_t l;
  429.         newlinelen = (size_t)
  430.             (eol ? eol - newline + 1 : new_header + newhdrlen - newline);
  431.         if (!eot || eot >= newline + newlinelen ||
  432.             !(newtaglen = (size_t)(eot - newline)))
  433.             continue;
  435.         newtagval = newline + newtaglen + 1;
  436.         while (newtagval < newline + newlinelen) {
  437.             if (isspace((unsigned char)(*newtagval)))
  438.                 newtagval++;
  439.             else
  440.                 break;
  441.         }
  442.         switch (op) {
  443.         case eUserHeaderOp_Delete:
  444.             len = 0;
  445.             break;
  446.         case eUserHeaderOp_Extend:
  447.             len = newlinelen - (size_t)(newtagval - newline);
  448.             break;
  449.         case eUserHeaderOp_Override:
  450.             len = newtagval < newline + newlinelen ? newlinelen : 0;
  451.             break;
  452.         default:
  453.             assert(0);
  454.             retval = 0/*failure*/;
  455.             len = 0;
  456.             break;
  457.         }
  459.         for (line = hdr; *line; line += linelen) {
  460.             size_t taglen;
  462.             eol = strchr(line, 'n');
  463.             eot = strchr(line,  ':');
  465.             linelen = (size_t)(eol ? eol - line + 1 : hdr + hdrlen - line);
  466.             if (!eot || eot >= line + linelen)
  467.                 continue;
  469.             taglen = (size_t)(eot - line);
  470.             if (newtaglen != taglen || strncasecmp(newline, line, taglen) != 0)
  471.                 continue;
  473.             if (op == eUserHeaderOp_Extend) {
  474.                 l = linelen + len;
  475.                 if (len && linelen > 1 && line[linelen - 2] == 'r')
  476.                     --l;
  477.             } else
  478.                 l = len;
  479.             if (l != linelen) {
  480.                 size_t off  = (size_t)(line - hdr);
  481.                 if (l > linelen) {
  482.                     char* temp = (char*)realloc(hdr, hdrlen + l - linelen + 1);
  483.                     if (!temp) {
  484.                         retval = 0/*failure*/;
  485.                         continue;
  486.                     }
  487.                     hdr  = temp;
  488.                     line = temp + off;
  489.                 }
  490.                 hdrlen -= linelen;
  491.                 memmove(line + l, line + linelen, hdrlen - off + 1);
  492.                 hdrlen += l;
  493.             }
  495.             if (len) {
  496.                 if (op == eUserHeaderOp_Extend) {
  497.                     char* s = &line[l - len - 1];
  498.                     *s++ = ' ';
  499.                     memcpy(s, newtagval, len);
  500.                 } else
  501.                     memcpy(line, newline, len);
  502.                 linelen = l;
  503.                 used = 1;
  504.             }
  505.         }
  507.         if (op == eUserHeaderOp_Delete)
  508.             continue;
  510.         if (used || !len) {
  511.             memmove(newline, newline + newlinelen,
  512.                     newhdrlen - (size_t)(newline-new_header) - newlinelen + 1);
  513.             newhdrlen -= newlinelen;
  514.             newlinelen = 0;
  515.         }
  516.     }
  518.     info->http_user_header = hdr;
  519.     if (op != eUserHeaderOp_Delete) {
  520.         if (!ConnNetInfo_AppendUserHeader(info, new_header))
  521.             retval = 0/*failure*/;
  522.         free(new_header);
  523.     }
  524.     return retval;
  525. }
  528. extern int/*bool*/ ConnNetInfo_OverrideUserHeader(SConnNetInfo* info,
  529.                                                   const char*   header)
  530. {
  531.     return s_ModifyUserHeader(info, header, eUserHeaderOp_Override);
  532. }
  535. extern void ConnNetInfo_DeleteUserHeader(SConnNetInfo* info,
  536.                                          const char*   header)
  537. {
  538.     verify(s_ModifyUserHeader(info, header, eUserHeaderOp_Delete));
  539. }
  542. extern int/*bool*/ ConnNetInfo_ExtendUserHeader(SConnNetInfo* info,
  543.                                                 const char*   header)
  544. {
  545.     return s_ModifyUserHeader(info, header, eUserHeaderOp_Extend);
  546. }
  549. extern int/*bool*/ ConnNetInfo_AppendArg(SConnNetInfo* info,
  550.                                          const char*   arg,
  551.                                          const char*   val)
  552. {
  553.     const char* amp = "&";
  555.     if (!arg || !*arg)
  556.         return 1/*success*/;
  557.     if (!info->args[0])
  558.         amp = "";
  559.     if (strlen(info->args) + strlen(amp) + strlen(arg) +
  560.         (val ? 1 + strlen(val) : 0) >= sizeof(info->args))
  561.         return 0/*failure*/;
  562.     strcat(info->args, amp);
  563.     strcat(info->args, arg);
  564.     if (!val || !*val)
  565.         return 1/*success*/;
  566.     strcat(info->args, "=");
  567.     strcat(info->args, val);
  568.     return 1/*success*/;
  569. }
  572. extern int/*bool*/ ConnNetInfo_PrependArg(SConnNetInfo* info,
  573.                                           const char*   arg,
  574.                                           const char*   val)
  575. {
  576.     char amp = '&';
  577.     size_t off;
  579.     if (!arg || !*arg)
  580.         return 1/*success*/;
  581.     if (!info->args[0])
  582.         amp = '';
  583.     off = strlen(arg) + (val && *val ? 1 + strlen(val) : 0) + (amp ? 1 : 0);
  584.     if (off + strlen(info->args) >= sizeof(info->args))
  585.         return 0/*failure*/;
  586.     if (amp)
  587.         memmove(&info->args[off], info->args, strlen(info->args) + 1);
  588.     strcpy(info->args, arg);
  589.     if (val && *val) {
  590.         strcat(info->args, "=");
  591.         strcat(info->args, val);
  592.     }
  593.     if (amp)
  594.         info->args[off - 1] = amp;
  595.     return 1/*success*/;
  596. }
  599. extern void ConnNetInfo_DeleteArg(SConnNetInfo* info,
  600.                                   const char*   arg)
  601. {
  602.     size_t argnamelen;
  603.     size_t arglen;
  604.     char*  a;
  606.     if (!arg || !(argnamelen = strcspn(arg, "=&")))
  607.         return;
  608.     for (a = info->args; *a; a += arglen) {
  609.         if (*a == '&')
  610.             a++;
  611.         arglen = strcspn(a, "&");
  612.         if (arglen < argnamelen || strncmp(a, arg, argnamelen) != 0 ||
  613.             (a[argnamelen] && a[argnamelen] != '=' && a[argnamelen] != '&'))
  614.             continue;
  615.         if (a[arglen]) {
  616.             arglen++;     /* for intermediary args, eat '&' separator, too */
  617.             memmove(a, a + arglen, strlen(a + arglen) + 1);
  618.         } else if (a != info->args) {
  619.             *--a = '';  /* last argument in a list: remove trailing '&' */
  620.         } else {
  621.             *a = '';    /* last and the only argument removed */
  622.         }
  623.         arglen = 0;
  624.     }
  625. }
  628. extern int/*bool*/ ConnNetInfo_PreOverrideArg(SConnNetInfo* info,
  629.                                               const char*   arg,
  630.                                               const char*   val)
  631. {
  632.     if (!arg || !*arg)
  633.         return 1/*success*/;
  634.     ConnNetInfo_DeleteArg(info, arg);
  635.     return ConnNetInfo_PrependArg(info, arg, val);
  636. }
  639. extern int/*bool*/ ConnNetInfo_PostOverrideArg(SConnNetInfo* info,
  640.                                                const char*   arg,
  641.                                                const char*   val)
  642. {
  643.     if (!arg || !*arg)
  644.         return 1/*success*/;
  645.     ConnNetInfo_DeleteArg(info, arg);
  646.     return ConnNetInfo_AppendArg(info, arg, val);
  647. }
  650. extern SConnNetInfo* ConnNetInfo_Clone(const SConnNetInfo* info)
  651. {
  652.     SConnNetInfo* x_info;
  653.     if (!info)
  654.         return 0;
  656.     x_info = (SConnNetInfo*) malloc(sizeof(SConnNetInfo) +
  657.                                     (info->service
  658.                                      ? strlen(info->service) + 1 : 0));
  659.     *x_info = *info;
  660.     if (info->timeout  &&  info->timeout != kDefaultTimeout) {
  661.         x_info->tmo     = *info->timeout;
  662.         x_info->timeout = &x_info->tmo;
  663.     }
  664.     if (info->service) {
  665.         char* s = (char*) x_info + sizeof(*x_info);
  666.         strcpy(s, info->service);
  667.         x_info->service = s;
  668.     }
  669.     x_info->http_user_header = 0;
  670.     ConnNetInfo_SetUserHeader(x_info, info->http_user_header);
  671.     return x_info;
  672. }
  675. static void s_SaveString(char* s, const char* name, const char* str) {
  676.     sprintf(s + strlen(s), "%-16.16s: %s%s%sn", name,
  677.             str ? """ : "", str ? str : "NULL", str ? """ : "");
  678. }
  679. static void s_SaveULong(char* s, const char* name, unsigned long lll) {
  680.     sprintf(s + strlen(s), "%-16.16s: %lun", name, lll);
  681. }
  682. static void s_SaveBool(char* s, const char* name, int/*bool*/ bbb) {
  683.     sprintf(s + strlen(s), "%-16.16s: %sn", name, bbb ? "TRUE" : "FALSE");
  684. }
  686. extern void ConnNetInfo_Log(const SConnNetInfo* info, LOG lg)
  687. {
  688.     char* s;
  690.     if (!lg)
  691.         return;
  693.     if (!info) {
  694.         LOG_Write(lg, eLOG_Trace, 0, 0, 0, "ConnNetInfo_Log: NULL info");
  695.         return;
  696.     }
  698.     if (!(s = (char*) malloc(sizeof(*info) + 4096 +
  699.                              (info->service ? strlen(info->service) : 0) +
  700.                              (info->http_user_header
  701.                               ? strlen(info->http_user_header) : 0)))) {
  702.         LOG_WRITE(lg, eLOG_Error, "ConnNetInfo_Log: Cannot alloc temp buffer");
  703.         return;
  704.     }
  706.     strcpy(s, "ConnNetInfo_Logn"
  707.            "#################### [BEGIN] SConnNetInfo:n");
  708.     s_SaveString    (s, "service",         info->service);
  709.     s_SaveString    (s, "client_host",     info->client_host);
  710.     s_SaveString    (s, "host",            info->host);
  711.     s_SaveULong     (s, "port",            info->port);
  712.     s_SaveString    (s, "path",            info->path);
  713.     s_SaveString    (s, "args",            info->args);
  714.     s_SaveString    (s, "req_method",     (info->req_method == eReqMethod_Any
  715.                                            ? DEF_CONN_REQ_METHOD
  716.                                            : (info->req_method
  717.                                               == eReqMethod_Get
  718.                                               ? "GET"
  719.                                               : (info->req_method
  720.                                                  == eReqMethod_Post
  721.                                                  ? "POST" : "Unknown"))));
  722.     if (info->timeout) {
  723.         s_SaveULong (s, "timeout(sec)",    info->timeout->sec);
  724.         s_SaveULong (s, "timeout(usec)",   info->timeout->usec);
  725.     } else
  726.         s_SaveString(s, "timeout",         "infinite");
  727.     s_SaveULong     (s, "max_try",         info->max_try);
  728.     s_SaveString    (s, "http_proxy_host", info->http_proxy_host);
  729.     s_SaveULong     (s, "http_proxy_port", info->http_proxy_port);
  730.     s_SaveString    (s, "proxy_host",      info->proxy_host);
  731.     s_SaveString    (s, "debug_printout", (info->debug_printout
  732.                                            == eDebugPrintout_None
  733.                                            ? "NONE"
  734.                                            : (info->debug_printout
  735.                                               == eDebugPrintout_Some
  736.                                               ? "SOME"
  737.                                               : (info->debug_printout
  738.                                                  == eDebugPrintout_Data
  739.                                                  ? "DATA" : "Unknown"))));
  740.     s_SaveBool      (s, "stateless",       info->stateless);
  741.     s_SaveBool      (s, "firewall",        info->firewall);
  742.     s_SaveBool      (s, "lb_disable",      info->lb_disable);
  743.     s_SaveString    (s, "user_header",     info->http_user_header);
  744.     s_SaveBool      (s, "proxy_adjusted",  info->http_proxy_adjusted);
  745.     strcat(s, "#################### [END] SConnNetInfon");
  747.     LOG_Write(lg, eLOG_Trace, 0, 0, 0, s);
  748.     free(s);
  749. }
  752. extern void ConnNetInfo_Destroy(SConnNetInfo* info)
  753. {
  754.     if (!info)
  755.         return;
  756.     ConnNetInfo_SetUserHeader(info, 0);
  757.     free(info);
  758. }
  761. extern SOCK URL_Connect
  762. (const char*     host,
  763.  unsigned short  port,
  764.  const char*     path,
  765.  const char*     args,
  766.  EReqMethod      req_method,
  767.  size_t          content_length,
  768.  const STimeout* c_timeout,
  769.  const STimeout* rw_timeout,
  770.  const char*     user_hdr,
  771.  int/*bool*/     encode_args,
  772.  ESwitch         log)
  773. {
  774.     static const char X_REQ_Q[] = "?";
  775.     static const char X_REQ_E[] = " HTTP/1.0rn";
  776.     static const char X_HOST[]  = "Host: ";
  778.     EIO_Status  st;
  779.     BUF         buf;
  780.     SOCK        sock;
  781.     char*       header;
  782.     char        buffer[80];
  783.     size_t      headersize;
  784.     const char* x_args = 0;
  785.     const char* x_req_r; /* "POST "/"GET " */
  787.     /* check the args */
  788.     if (!host  ||  !*host  ||  !port  ||  !path  ||  !*path  ||
  789.         (user_hdr  &&  *user_hdr  &&  user_hdr[strlen(user_hdr)-1] != 'n')) {
  790.         CORE_LOG(eLOG_Error, "[URL_Connect]  Bad arguments");
  791.         assert(0);
  792.         return 0/*error*/;
  793.     }
  795.     switch (req_method) {
  796.     case eReqMethod_Any:
  797.         x_req_r = DEF_CONN_REQ_METHOD " ";
  798.         break;
  799.     case eReqMethod_Post:
  800.         x_req_r = "POST ";
  801.         break;
  802.     case eReqMethod_Get:
  803.         x_req_r = "GET ";
  804.         break;
  805.     default:
  806.         CORE_LOGF(eLOG_Error, ("[URL_Connect]  Unrecognized request method"
  807.                                " (%d)", (int) req_method));
  808.         assert(0);
  809.         return 0/*error*/;
  810.     }
  811.     if (content_length  &&  strcasecmp(x_req_r, "GET ") == 0) {
  812.         CORE_LOG(eLOG_Warning,
  813.                  "[URL_Connect]  Content length ignored with GET");
  814.         content_length = 0;
  815.     }
  817.     /* URL-encode "args", if any specified */
  818.     if (args  &&  *args) {
  819.         size_t src_size = strlen(args);
  820.         if ( encode_args ) {
  821.             size_t dst_size = 3 * src_size;
  822.             size_t src_read, dst_written;
  823.             char* xx_args = (char*) malloc(dst_size + 1);
  824.             if (!xx_args)
  825.                 return 0/*failure: no memory*/;
  826.             URL_Encode(args,    src_size, &src_read,
  827.                        xx_args, dst_size, &dst_written);
  828.             xx_args[dst_written] = '';
  829.             assert(src_read == src_size);
  830.             x_args = xx_args;
  831.         } else
  832.             x_args = args;
  833.     }
  835.     buf = 0;
  836.     errno = 0;
  837.     /* compose HTTP header */
  838.     if (/* {POST|GET} <path>?<args> HTTP/1.0rn */
  839.         !BUF_Write(&buf, x_req_r, strlen(x_req_r))            ||
  840.         !BUF_Write(&buf, path,    strlen(path))               ||
  841.         (x_args
  842.          &&  (!BUF_Write(&buf, X_REQ_Q, sizeof(X_REQ_Q) - 1)  ||
  843.               !BUF_Write(&buf, x_args,  strlen(x_args))))     ||
  844.         !BUF_Write(&buf,       X_REQ_E, sizeof(X_REQ_E) - 1)  ||
  846.         /* Host: hostrn */
  847.         !BUF_Write(&buf, X_HOST, sizeof(X_HOST) - 1)          ||
  848.         !BUF_Write(&buf, host,   strlen(host))                ||
  849.         !BUF_Write(&buf, "rn", 2)                           ||
  851.         /* <user_header> */
  852.         (user_hdr
  853.          &&  !BUF_Write(&buf, user_hdr, strlen(user_hdr)))    ||
  855.         /* Content-Length: <content_length>rnrn */
  856.         (req_method != eReqMethod_Get
  857.          &&  (sprintf(buffer, "Content-Length: %lurn",
  858.                       (unsigned long) content_length) <= 0    ||
  859.               !BUF_Write(&buf, buffer, strlen(buffer))))      ||
  861.         !BUF_Write(&buf, "rn", 2)) {
  862.         CORE_LOGF(eLOG_Error, ("[URL_Connect]  Error composing HTTP header for"
  863.                                " %s:%hu%s%s", host, port, errno ? ": " : "",
  864.                                errno ? strerror(errno) : ""));
  865.         BUF_Destroy(buf);
  866.         if (x_args  &&  x_args != args)
  867.             free((void*) x_args);
  868.         return 0/*error*/;
  869.     }
  870.     if (x_args  &&  x_args != args)
  871.         free((void*) x_args);
  873.     if (!(header = (char*) malloc(headersize = BUF_Size(buf))) ||
  874.         BUF_Read(buf, header, headersize) != headersize) {
  875.         CORE_LOGF(eLOG_Error, ("[URL_Connect]  Error storing HTTP header for"
  876.                                " %s:%hu: %s", host, port,
  877.                                errno ? strerror(errno) : "Unknown error"));
  878.         if (header)
  879.             free(header);
  880.         BUF_Destroy(buf);
  881.         return 0/*error*/;
  882.     }
  883.     BUF_Destroy(buf);
  885.     /* connect to HTTPD */
  886.     st = SOCK_CreateEx(host, port, c_timeout, &sock, header, headersize, log);
  887.     free(header);
  888.     if (st != eIO_Success) {
  889.         CORE_LOGF(eLOG_Error,
  890.                   ("[URL_Connect]  Socket connect to %s:%hu failed: %s",
  891.                    host, port, IO_StatusStr(st)));
  892.         return 0/*error*/;
  893.     }
  895.     /* setup I/O timeout for the connection */
  896.     if (SOCK_SetTimeout(sock, eIO_ReadWrite, rw_timeout) != eIO_Success) {
  897.         CORE_LOG(eLOG_Error, "[URL_Connect]  Cannot set connection timeout");
  898.         SOCK_Close(sock);
  899.         return 0/*error*/;
  900.     }
  902.     /* success */
  903.     return sock;
  904. }
  907. /* Code for the "*_StripToPattern()" functions
  908.  */
  909. typedef EIO_Status (*FDoIO)
  910.      (void*     stream,
  911.       void*     buf,
  912.       size_t    size,
  913.       size_t*   n_read,
  914.       EIO_Event what     /* eIO_Read | eIO_Write (to pushback) */
  915.       );
  917. static EIO_Status s_StripToPattern
  918. (void*       stream,
  919.  FDoIO       io_func,
  920.  const void* pattern,
  921.  size_t      pattern_size,
  922.  BUF*        buf,
  923.  size_t*     n_discarded)
  924. {
  925.     EIO_Status status;
  926.     char*      buffer;
  927.     size_t     buffer_size;
  928.     size_t     n_read = 0;
  930.     /* check args */
  931.     if ( n_discarded )
  932.         *n_discarded = 0;
  933.     if (!stream  ||  (pattern != 0) != (pattern_size != 0))
  934.         return eIO_InvalidArg;
  936.     /* allocate a temporary read buffer */
  937.     buffer_size = 2 * pattern_size;
  938.     if (buffer_size < 4096)
  939.         buffer_size = 4096;
  940.     if ( !(buffer = (char*) malloc(buffer_size)) )
  941.         return eIO_Unknown;
  943.     if ( !pattern ) {
  944.         /* read/discard until EOF */
  945.         do {
  946.             status = io_func(stream, buffer, buffer_size, &n_read, eIO_Read);
  947.             if ( buf )
  948.                 BUF_Write(buf, buffer, n_read);
  949.             if ( n_discarded )
  950.                 *n_discarded += n_read;
  951.         } while (status == eIO_Success);
  952.     } else {
  953.         for (;;) {
  954.             /* read; search for the pattern; store the discarded data */
  955.             size_t x_read, n_stored;
  957.             assert(n_read < pattern_size);
  958.             status = io_func(stream, buffer + n_read, buffer_size - n_read,
  959.                              &x_read, eIO_Read);
  960.             if ( !x_read ) {
  961.                 assert(status != eIO_Success);
  962.                 break; /*error*/
  963.             }
  964.             n_stored = n_read + x_read;
  966.             if (n_stored >= pattern_size) {
  967.                 /* search for the pattern */
  968.                 size_t n_check = n_stored - pattern_size + 1;
  969.                 const char* b;
  970.                 for (b = buffer;  n_check;  b++, n_check--) {
  971.                     if (*b != *((const char*) pattern))
  972.                         continue;
  973.                     if (memcmp(b, pattern, pattern_size) == 0)
  974.                         break; /*found*/
  975.                 }
  976.                 /* pattern found */
  977.                 if ( n_check ) {
  978.                     size_t x_discarded = (size_t)(b - buffer) + pattern_size;
  979.                     if ( buf )
  980.                         BUF_Write(buf, buffer + n_read, x_discarded - n_read);
  981.                     if ( n_discarded )
  982.                         *n_discarded += x_discarded;
  983.                     /* return unused portion to the stream */
  984.                     status = io_func(stream, buffer + x_discarded,
  985.                                      n_stored - x_discarded, 0, eIO_Write);
  986.                     break; /*finished*/
  987.                 }
  988.             }
  990.             /* pattern not found yet */
  991.             if ( buf )
  992.                 BUF_Write(buf, buffer + n_read, x_read);
  993.             if ( n_discarded )
  994.                 *n_discarded += x_read;
  995.             n_read = n_stored;
  997.             if (n_read > pattern_size) {
  998.                 size_t n_cut = n_read - pattern_size + 1;
  999.                 n_read = pattern_size - 1;
  1000.                 memmove(buffer, buffer + n_cut, n_read);
  1001.             }
  1002.         }
  1003.     }
  1005.     /* cleanup & exit */
  1006.     free(buffer);
  1007.     return status;
  1008. }
  1011. static EIO_Status s_CONN_IO
  1012. (void*     stream,
  1013.  void*     buf,
  1014.  size_t    size,
  1015.  size_t*   n_read,
  1016.  EIO_Event what)
  1017. {
  1018.     switch (what) {
  1019.     case eIO_Read:
  1020.         return CONN_Read((CONN) stream, buf, size, n_read, eIO_ReadPlain);
  1021.     case eIO_Write:
  1022.         assert(stream);
  1023.         return CONN_PushBack((CONN) stream, buf, size);
  1024.     default:
  1025.         break;
  1026.     }
  1027.     return eIO_InvalidArg;
  1028. }
  1030. extern EIO_Status CONN_StripToPattern
  1031. (CONN        conn,
  1032.  const void* pattern,
  1033.  size_t      pattern_size,
  1034.  BUF*        buf,
  1035.  size_t*     n_discarded)
  1036. {
  1037.     return s_StripToPattern
  1038.         (conn, s_CONN_IO, pattern, pattern_size, buf, n_discarded);
  1039. }
  1042. static EIO_Status s_SOCK_IO
  1043. (void*     stream,
  1044.  void*     buf,
  1045.  size_t    size,
  1046.  size_t*   n_read,
  1047.  EIO_Event what)
  1048. {
  1049.     switch (what) {
  1050.     case eIO_Read:
  1051.         return SOCK_Read((SOCK) stream, buf, size, n_read, eIO_ReadPlain);
  1052.     case eIO_Write:
  1053.         return SOCK_PushBack((SOCK) stream, buf, size);
  1054.     default:
  1055.         break;
  1056.     }
  1057.     return eIO_InvalidArg;
  1058. }
  1060. extern EIO_Status SOCK_StripToPattern
  1061. (SOCK        sock,
  1062.  const void* pattern,
  1063.  size_t      pattern_size,
  1064.  BUF*        buf,
  1065.  size_t*     n_discarded)
  1066. {
  1067.     return s_StripToPattern
  1068.         (sock, s_SOCK_IO, pattern, pattern_size, buf, n_discarded);
  1069. }
  1072. static EIO_Status s_BUF_IO
  1073. (void*     stream,
  1074.  void*     buf,
  1075.  size_t    size,
  1076.  size_t*   n_read,
  1077.  EIO_Event what)
  1078. {
  1079.     switch (what) {
  1080.     case eIO_Read:
  1081.         *n_read = BUF_Read((BUF) stream, buf, size);
  1082.         return *n_read ? eIO_Success : eIO_Closed;
  1083.     case eIO_Write:
  1084.         assert(stream);
  1085.         return BUF_PushBack((BUF*) &stream, buf, size)
  1086.             ? eIO_Success : eIO_Unknown;
  1087.     default:
  1088.         break;
  1089.     }
  1090.     return eIO_InvalidArg;
  1091. }
  1093. extern EIO_Status BUF_StripToPattern
  1094. (BUF         buffer,
  1095.  const void* pattern,
  1096.  size_t      pattern_size,
  1097.  BUF*        buf,
  1098.  size_t*     n_discarded)
  1099. {
  1100.     return s_StripToPattern
  1101.         (buffer, s_BUF_IO, pattern, pattern_size, buf, n_discarded);
  1102. }
  1105. /* Return integer (0..15) corresponding to the "ch" as a hex digit
  1106.  * Return -1 on error
  1107.  */
  1108. static int s_HexChar(char ch)
  1109. {
  1110.     if ('0' <= ch  &&  ch <= '9')
  1111.         return ch - '0';
  1112.     if ('a' <= ch  &&  ch <= 'f')
  1113.         return 10 + (ch - 'a');
  1114.     if ('A' <= ch  &&  ch <= 'F')
  1115.         return 10 + (ch - 'A');
  1116.     return -1;
  1117. }
  1119. /* The URL-encoding table
  1120.  */
  1121. static const char s_Encode[256][4] = {
  1122.     "%00", "%01", "%02", "%03", "%04", "%05", "%06", "%07",
  1123.     "%08", "%09", "%0A", "%0B", "%0C", "%0D", "%0E", "%0F",
  1124.     "%10", "%11", "%12", "%13", "%14", "%15", "%16", "%17",
  1125.     "%18", "%19", "%1A", "%1B", "%1C", "%1D", "%1E", "%1F",
  1126.     "+",   "!",   "%22", "%23", "$",   "%25", "%26", "'",
  1127.     "(",   ")",   "*",   "%2B", ",",   "-",   ".",   "%2F",
  1128.     "0",   "1",   "2",   "3",   "4",   "5",   "6",   "7",
  1129.     "8",   "9",   "%3A", "%3B", "%3C", "%3D", "%3E", "%3F",
  1130.     "%40", "A",   "B",   "C",   "D",   "E",   "F",   "G",
  1131.     "H",   "I",   "J",   "K",   "L",   "M",   "N",   "O",
  1132.     "P",   "Q",   "R",   "S",   "T",   "U",   "V",   "W",
  1133.     "X",   "Y",   "Z",   "%5B", "%5C", "%5D", "%5E", "_",
  1134.     "%60", "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",   "%7B", "%7C", "%7D", "%7E", "%7F",
  1138.     "%80", "%81", "%82", "%83", "%84", "%85", "%86", "%87",
  1139.     "%88", "%89", "%8A", "%8B", "%8C", "%8D", "%8E", "%8F",
  1140.     "%90", "%91", "%92", "%93", "%94", "%95", "%96", "%97",
  1141.     "%98", "%99", "%9A", "%9B", "%9C", "%9D", "%9E", "%9F",
  1142.     "%A0", "%A1", "%A2", "%A3", "%A4", "%A5", "%A6", "%A7",
  1143.     "%A8", "%A9", "%AA", "%AB", "%AC", "%AD", "%AE", "%AF",
  1144.     "%B0", "%B1", "%B2", "%B3", "%B4", "%B5", "%B6", "%B7",
  1145.     "%B8", "%B9", "%BA", "%BB", "%BC", "%BD", "%BE", "%BF",
  1146.     "%C0", "%C1", "%C2", "%C3", "%C4", "%C5", "%C6", "%C7",
  1147.     "%C8", "%C9", "%CA", "%CB", "%CC", "%CD", "%CE", "%CF",
  1148.     "%D0", "%D1", "%D2", "%D3", "%D4", "%D5", "%D6", "%D7",
  1149.     "%D8", "%D9", "%DA", "%DB", "%DC", "%DD", "%DE", "%DF",
  1150.     "%E0", "%E1", "%E2", "%E3", "%E4", "%E5", "%E6", "%E7",
  1151.     "%E8", "%E9", "%EA", "%EB", "%EC", "%ED", "%EE", "%EF",
  1152.     "%F0", "%F1", "%F2", "%F3", "%F4", "%F5", "%F6", "%F7",
  1153.     "%F8", "%F9", "%FA", "%FB", "%FC", "%FD", "%FE", "%FF"
  1154. };
  1155. #define VALID_URL_SYMBOL(ch)  (s_Encode[(unsigned char)ch][0] != '%')
  1158. extern int/*bool*/ URL_DecodeEx
  1159. (const void* src_buf,
  1160.  size_t      src_size,
  1161.  size_t*     src_read,
  1162.  void*       dst_buf,
  1163.  size_t      dst_size,
  1164.  size_t*     dst_written,
  1165.  const char* allow_symbols)
  1166. {
  1167.     unsigned char* src = (unsigned char*) src_buf;
  1168.     unsigned char* dst = (unsigned char*) dst_buf;
  1170.     *src_read    = 0;
  1171.     *dst_written = 0;
  1172.     if (!src_size  ||  !dst_size)
  1173.         return 1/*true*/;
  1175.     for ( ;  *src_read != src_size  &&  *dst_written != dst_size;
  1176.           (*src_read)++, (*dst_written)++, src++, dst++) {
  1177.         switch ( *src ) {
  1178.         case '%': {
  1179.             int i1, i2;
  1180.             if (*src_read + 2 > src_size)
  1181.                 return 1/*true*/;
  1182.             if ((i1 = s_HexChar(*(++src))) == -1)
  1183.                 return *dst_written ? 1/*true*/ : 0/*false*/;
  1184.             if (*src_read + 3 > src_size)
  1185.                 return 1/*true*/;
  1186.             if ((i2 = s_HexChar(*(++src))) == -1)
  1187.                 return *dst_written ? 1/*true*/ : 0/*false*/;
  1189.             *dst = (unsigned char)((i1 << 4) + i2);
  1190.             *src_read += 2;
  1191.             break;
  1192.         }
  1193.         case '+': {
  1194.             *dst = ' ';
  1195.             break;
  1196.         }
  1197.         default: {
  1198.             if (VALID_URL_SYMBOL(*src)  ||
  1199.                 (allow_symbols  &&  strchr(allow_symbols, *src)))
  1200.                 *dst = *src;
  1201.             else
  1202.                 return *dst_written ? 1/*true*/ : 0/*false*/;
  1203.         }
  1204.         }/*switch*/
  1205.     }
  1207.     assert(src == (unsigned char*) src_buf + *src_read   );
  1208.     assert(dst == (unsigned char*) dst_buf + *dst_written);
  1209.     return 1/*true*/;
  1210. }
  1213. extern int/*bool*/ URL_Decode
  1214. (const void* src_buf,
  1215.  size_t      src_size,
  1216.  size_t*     src_read,
  1217.  void*       dst_buf,
  1218.  size_t      dst_size,
  1219.  size_t*     dst_written)
  1220. {
  1221.     return URL_DecodeEx
  1222.         (src_buf, src_size, src_read, dst_buf, dst_size, dst_written, 0);
  1223. }
  1226. extern void URL_Encode
  1227. (const void* src_buf,
  1228.  size_t      src_size,
  1229.  size_t*     src_read,
  1230.  void*       dst_buf,
  1231.  size_t      dst_size,
  1232.  size_t*     dst_written)
  1233. {
  1234.     unsigned char* src = (unsigned char*) src_buf;
  1235.     unsigned char* dst = (unsigned char*) dst_buf;
  1237.     *src_read    = 0;
  1238.     *dst_written = 0;
  1239.     if (!src_size  ||  !dst_size)
  1240.         return;
  1242.     for ( ;  *src_read != src_size  &&  *dst_written != dst_size;
  1243.           (*src_read)++, (*dst_written)++, src++, dst++) {
  1244.         const char* subst = s_Encode[*src];
  1245.         if (*subst != '%') {
  1246.             *dst = *subst;
  1247.         } else if (*dst_written < dst_size - 2) {
  1248.             *dst = '%';
  1249.             *(++dst) = *(++subst);
  1250.             *(++dst) = *(++subst);
  1251.             *dst_written += 2;
  1252.         } else {
  1253.             return;
  1254.         }
  1255.     }
  1256.     assert(src == (unsigned char*) src_buf + *src_read   );
  1257.     assert(dst == (unsigned char*) dst_buf + *dst_written);
  1258. }
  1262. /****************************************************************************
  1263.  * NCBI-specific MIME content type and sub-types
  1264.  */
  1266. static const char* s_MIME_Type[eMIME_T_Unknown+1] = {
  1267.     "x-ncbi-data",
  1268.     "text",
  1269.     "application",
  1270.     "unknown"
  1271. };
  1273. static const char* s_MIME_SubType[eMIME_Unknown+1] = {
  1274.     "x-dispatch",
  1275.     "x-asn-text",
  1276.     "x-asn-binary",
  1277.     "x-fasta",
  1278.     "x-www-form",
  1279.     "html",
  1280.     "plain",
  1281.     "xml",
  1282.     "xml+soap",
  1283.     "x-unknown"
  1284. };
  1286. static const char* s_MIME_Encoding[eENCOD_Unknown+1] = {
  1287.     "",
  1288.     "urlencoded",
  1289.     "encoded"
  1290. };
  1293. extern char* MIME_ComposeContentTypeEx
  1294. (EMIME_Type     type,
  1295.  EMIME_SubType  subtype,
  1296.  EMIME_Encoding encoding,
  1297.  char*          buf,
  1298.  size_t         buflen)
  1299. {
  1300.     static const char s_ContentType[] = "Content-Type: ";
  1301.     const char*       x_Type          = s_MIME_Type    [(int) type];
  1302.     const char*       x_SubType       = s_MIME_SubType [(int) subtype];
  1303.     const char*       x_Encoding      = s_MIME_Encoding[(int) encoding];
  1304.     char              x_buf[MAX_CONTENT_TYPE_LEN];
  1306.     if ( *x_Encoding ) {
  1307.         assert(sizeof(s_ContentType) + strlen(x_Type) + strlen(x_SubType)
  1308.                + strlen(x_Encoding) + 4 < MAX_CONTENT_TYPE_LEN);
  1309.         sprintf(x_buf, "%s%s/%s-%srn",
  1310.                 s_ContentType, x_Type, x_SubType, x_Encoding);
  1311.     } else {
  1312.         assert(sizeof(s_ContentType) + strlen(x_Type) + strlen(x_SubType)
  1313.                + 3 < MAX_CONTENT_TYPE_LEN);
  1314.         sprintf(x_buf, "%s%s/%srn", s_ContentType, x_Type, x_SubType);
  1315.     }
  1317.     assert(strlen(x_buf) < sizeof(x_buf));
  1318.     assert(strlen(x_buf) < buflen);
  1319.     strncpy0(buf, x_buf, buflen - 1);
  1320.     return buf;
  1321. }
  1324. extern char* MIME_ComposeContentType
  1325. (EMIME_SubType  subtype,
  1326.  EMIME_Encoding encoding,
  1327.  char*          buf,
  1328.  size_t         buflen)
  1329. {
  1330.     return MIME_ComposeContentTypeEx(eMIME_T_NcbiData,
  1331.                                      subtype, encoding, buf, buflen);
  1332. }
  1335. extern int/*bool*/ MIME_ParseContentTypeEx
  1336. (const char*     str,
  1337.  EMIME_Type*     type,
  1338.  EMIME_SubType*  subtype,
  1339.  EMIME_Encoding* encoding)
  1340. {
  1341.     char* x_buf;
  1342.     char* x_type;
  1343.     char* x_subtype;
  1344.     int   i;
  1346.     if ( type )
  1347.         *type = eMIME_T_Unknown;
  1348.     if ( subtype )
  1349.         *subtype = eMIME_Unknown;
  1350.     if ( encoding )
  1351.         *encoding = eENCOD_Unknown;
  1353.     if (!str  ||  !*str)
  1354.         return 0/*false*/;
  1356.     {{
  1357.         size_t x_size = strlen(str) + 1;
  1358.         x_buf  = (char*) malloc(2 * x_size);
  1359.         x_type = x_buf  + x_size;
  1360.     }}
  1362.     strcpy(x_buf, str);
  1363.     strlwr(x_buf);
  1365.     if ((sscanf(x_buf, " content-type: %s ", x_type) != 1  &&
  1366.          sscanf(x_buf, " %s ", x_type) != 1)  ||
  1367.         (x_subtype = strchr(x_type, '/')) == 0) {
  1368.         free(x_buf);
  1369.         return 0/*false*/;
  1370.     }
  1371.     *x_subtype++ = '';
  1373.     if ( type ) {
  1374.         for (i = 0;  i < (int) eMIME_T_Unknown;  i++) {
  1375.             if ( !strcmp(x_type, s_MIME_Type[i]) ) {
  1376.                 *type = (EMIME_Type) i;
  1377.                 break;
  1378.             }
  1379.         }
  1380.     }
  1382.     for (i = 0;  i < (int) eENCOD_Unknown;  i++) {
  1383.         char* x_encoding = strstr(x_subtype, s_MIME_Encoding[i]);
  1384.         if (x_encoding  &&  *x_encoding  &&
  1385.             x_encoding != x_subtype  &&  *(x_encoding - 1) == '-'  &&
  1386.             strcmp(x_encoding, s_MIME_Encoding[i]) == 0) {
  1387.             if ( encoding ) {
  1388.                 *encoding = (EMIME_Encoding) i;
  1389.             }
  1390.             *(x_encoding - 1) = '';
  1391.             break;
  1392.         }
  1393.     }
  1394.     if (encoding  &&  *encoding == eENCOD_Unknown)
  1395.         *encoding = eENCOD_None;
  1397.     if ( subtype ) {
  1398.         for (i = 0;  i < (int) eMIME_Unknown;  i++) {
  1399.             if ( !strcmp(x_subtype, s_MIME_SubType[i]) ) {
  1400.                 *subtype = (EMIME_SubType) i;
  1401.                 break;
  1402.             }
  1403.         }
  1404.     }
  1406.     free(x_buf);
  1407.     return 1/*true*/;
  1408. }
  1411. extern int/*bool*/ MIME_ParseContentType
  1412. (const char*     str,
  1413.  EMIME_SubType*  subtype,
  1414.  EMIME_Encoding* encoding)
  1415. {
  1416.     EMIME_Type type;
  1417.     if ( !MIME_ParseContentTypeEx(str, &type, subtype, encoding) )
  1418.         return 0/*false*/;
  1420.     if (type != eMIME_T_NcbiData) {
  1421.         if ( subtype )
  1422.             *subtype  = eMIME_Unknown;
  1423.         if ( encoding )
  1424.             *encoding = eENCOD_Unknown;
  1425.         return 0/*false*/;
  1426.     }
  1428.     return 1/*true*/;
  1429. }
  1433. /****************************************************************************
  1434.  * Reading and writing [host][:port] addresses
  1435.  */
  1437. extern const char* StringToHostPort(const char*     str,
  1438.                                     unsigned int*   host,
  1439.                                     unsigned short* port)
  1440. {
  1441.     unsigned short p;
  1442.     unsigned int h;
  1443.     char abuf[256];
  1444.     const char* s;
  1445.     size_t alen;
  1446.     int n = 0;
  1448.     *host = 0;
  1449.     *port = 0;
  1450.     for (s = str; *s; s++) {
  1451.         if (isspace((unsigned char)(*s)) || *s == ':')
  1452.             break;
  1453.     }
  1454.     if ((alen = (size_t)(s - str)) > sizeof(abuf) - 1)
  1455.         return str;
  1456.     if (alen) {
  1457.         strncpy0(abuf, str, alen);
  1458.         if (!(h = SOCK_gethostbyname(abuf)))
  1459.             return str;
  1460.     } else
  1461.         h = 0;
  1462.     if (*s == ':') {
  1463.         if (sscanf(++s, "%hu%n", &p, &n) < 1 ||
  1464.             (s[n] && !isspace((unsigned char) s[n])))
  1465.             return alen ? 0 : str;
  1466.     } else
  1467.         p = 0;
  1468.     *host = h;
  1469.     *port = p;
  1470.     return s + n;
  1471. }
  1474. extern size_t HostPortToString(unsigned int   host,
  1475.                                unsigned short port,
  1476.                                char*          buf,
  1477.                                size_t         buflen)
  1478. {
  1479.     char   x_buf[16/*sizeof("255.255.255.255")*/ + 8/*:port*/];
  1480.     size_t n;
  1482.     if (!buf || !buflen)
  1483.         return 0;
  1484.     if (!host)
  1485.         *x_buf = 0;
  1486.     else if (SOCK_ntoa(host, x_buf, sizeof(x_buf)) != 0) {
  1487.         *buf = 0;
  1488.         return 0;
  1489.     }
  1490.     n = strlen(x_buf);
  1491.     if (port || !host)
  1492.         n += sprintf(x_buf + n, ":%hu", port);
  1493.     assert(n < sizeof(x_buf));
  1494.     if (n >= buflen)
  1495.         n = buflen - 1;
  1496.     memcpy(buf, x_buf, n);
  1497.     buf[n] = 0;
  1498.     return n;
  1499. }
  1502. /*
  1503.  * --------------------------------------------------------------------------
  1504.  * $Log: ncbi_connutil.c,v $
  1505.  * Revision 1000.3  2004/04/12 17:06:12  gouriano
  1506.  * PRODUCTION: UPGRADED [CATCHUP_003] Dev-tree R6.64
  1507.  *
  1508.  * Revision 6.64  2004/04/06 19:25:56  lavr
  1509.  * Fix ConnNetInfo_DeleteArg() to remove arg's trailing '&'
  1510.  *
  1511.  * Revision 6.63  2004/01/14 18:52:39  lavr
  1512.  * Recognize eMIME_XmlSoap and corresponding text representation "xml+soap"
  1513.  *
  1514.  * Revision 6.62  2004/01/07 19:23:29  lavr
  1515.  * "xml" added as a MIME subtype
  1516.  *
  1517.  * Revision 6.61  2003/11/12 17:46:12  lavr
  1518.  * HostPortToString() changed to be a little more efficient
  1519.  *
  1520.  * Revision 6.60  2003/08/27 16:27:37  lavr
  1521.  * Add "Host:" tag to be able to take advantage of Apache VHosts
  1522.  *
  1523.  * Revision 6.59  2003/08/25 14:44:43  lavr
  1524.  * Employ new k..Timeout constants
  1525.  * URL_Connect():  get rid of one avoidable malloc()
  1526.  * User header manipulation routines:  factor out some arithmetics for speed
  1527.  *
  1528.  * Revision 6.58  2003/05/31 05:13:38  lavr
  1529.  * Replace bitwise XOR with inequality [of the same effect]
  1530.  *
  1531.  * Revision 6.57  2003/05/20 21:25:24  lavr
  1532.  * Limit SConnNetInfo::max_try by reasonable "short" value
  1533.  *
  1534.  * Revision 6.56  2003/05/19 16:44:45  lavr
  1535.  * Minor style adjustements
  1536.  *
  1537.  * Revision 6.55  2003/05/14 03:51:54  lavr
  1538.  * URL_Connect() rewritten to submit HTTP header as SOCK's initial buffer
  1539.  *
  1540.  * Revision 6.54  2003/04/30 17:02:11  lavr
  1541.  * Name collision resolved in ConnNetInfo_ParseURL()
  1542.  *
  1543.  * Revision 6.53  2003/03/06 21:55:31  lavr
  1544.  * s_ModifyUserHeader(): Heed uninitted usage warning
  1545.  * HostPortToString():   Do not append :0 (for zero port) if host is not empty
  1546.  *
  1547.  * Revision 6.52  2003/02/28 14:47:41  lavr
  1548.  * Bugfix: proper bool -> eIO_Status conversion in s_BUF_IO()
  1549.  *
  1550.  * Revision 6.51  2003/01/31 21:17:04  lavr
  1551.  * More robust search for sheme in URL
  1552.  *
  1553.  * Revision 6.50  2003/01/17 19:44:46  lavr
  1554.  * Reduce dependencies
  1555.  *
  1556.  * Revision 6.49  2003/01/15 19:52:25  lavr
  1557.  * *_StripToPattern() calls modified to use Read/PushBack instead of Peek/Read
  1558.  *
  1559.  * Revision 6.48  2002/12/13 21:19:13  lavr
  1560.  * Separate header tag values with spaces as most commonly required (rfc1945)
  1561.  *
  1562.  * Revision 6.47  2002/12/10 17:34:15  lavr
  1563.  * Remove errno decoding on failed connect in URL_Connect()
  1564.  *
  1565.  * Revision 6.46  2002/12/05 21:43:31  lavr
  1566.  * Fix in assignment and compare in URL_Connect()
  1567.  *
  1568.  * Revision 6.45  2002/12/04 16:50:47  lavr
  1569.  * Use SOCK_CreateEx() in URL_Connect()
  1570.  *
  1571.  * Revision 6.44  2002/11/19 19:19:57  lavr
  1572.  * +ConnNetInfo_ExtendUserHeader()
  1573.  *
  1574.  * Revision 6.43  2002/11/13 19:54:13  lavr
  1575.  * ConnNetInfo_DeleteArg(): fix initial argument calculation size
  1576.  *
  1577.  * Revision 6.42  2002/11/12 05:50:33  lavr
  1578.  * Modify client host name discovery
  1579.  *
  1580.  * Revision 6.41  2002/11/01 20:13:50  lavr
  1581.  * Remove MAXHOSTNAMELEN and MAX_IP_ADDR_LEN macros
  1582.  *
  1583.  * Revision 6.40  2002/10/28 15:42:38  lavr
  1584.  * Use "ncbi_ansi_ext.h" privately and use strncpy0()
  1585.  *
  1586.  * Revision 6.39  2002/10/21 18:30:59  lavr
  1587.  * +ConnNetInfo_AppendArg()
  1588.  * +ConnNetInfo_PrependArg()
  1589.  * +ConnNetInfo_DeleteArg()
  1590.  * +ConnNetInfo_PreOverrideArg()
  1591.  * +ConnNetInfo_PostOverrideArg()
  1592.  *
  1593.  * Revision 6.38  2002/10/11 19:42:06  lavr
  1594.  * +ConnNetInfo_AppendUserHeader()
  1595.  * +ConnNetInfo_OverrideUserHeader()
  1596.  * +ConnNetInfo_DeleteUserHeader()
  1597.  *
  1598.  * Revision 6.37  2002/09/24 18:08:34  lavr
  1599.  * Avoid compiler warning in positioning on first but one array element
  1600.  *
  1601.  * Revision 6.36  2002/08/12 15:12:01  lavr
  1602.  * Use persistent SOCK_Write()
  1603.  *
  1604.  * Revision 6.35  2002/08/07 16:32:47  lavr
  1605.  * Changed EIO_ReadMethod enums accordingly; log moved to end
  1606.  *
  1607.  * Revision 6.34  2002/05/06 19:12:57  lavr
  1608.  * -ConnNetInfo_Print(); +ConnNetInfo_Log()
  1609.  * Addition: *_StripToPattern() now can strip until EOF (or error)
  1610.  *
  1611.  * Revision 6.33  2002/04/26 16:31:41  lavr
  1612.  * Add more space between functions to separate them better
  1613.  *
  1614.  * Revision 6.32  2002/04/13 06:36:36  lavr
  1615.  * Fix for empty path parsing in HTTP URL
  1616.  *
  1617.  * Revision 6.31  2002/03/19 22:13:09  lavr
  1618.  * Minor tweak in recognizing "infinite" (and part) as a special timeout
  1619.  *
  1620.  * Revision 6.30  2002/03/11 21:53:18  lavr
  1621.  * Recognize ALL in CONN_DEBUG_PRINTOUT; bugfix for '//' in proxy adjustement
  1622.  *
  1623.  * Revision 6.29  2002/02/20 19:12:17  lavr
  1624.  * Swapped eENCOD_Url and eENCOD_None; eENCOD_Unknown introduced
  1625.  *
  1626.  * Revision 6.28  2002/02/08 22:22:17  lavr
  1627.  * BUGFIX: sizeof(info) -> sizeof(*info) in ConnNetInfo_Create()
  1628.  *
  1629.  * Revision 6.27  2002/01/30 20:14:48  lavr
  1630.  * URL_Connect(): Print error code in some failure messages
  1631.  *
  1632.  * Revision 6.26  2002/01/28 20:21:46  lavr
  1633.  * Do not store "" as a user_header
  1634.  *
  1635.  * Revision 6.25  2001/12/30 19:40:32  lavr
  1636.  * +ConnNetInfo_ParseURL()
  1637.  * Added recordkeeping of service name for which the info was created
  1638.  *
  1639.  * Revision 6.24  2001/12/04 15:56:28  lavr
  1640.  * Use strdup() instead of explicit strcpy(malloc(...), ...)
  1641.  *
  1642.  * Revision 6.23  2001/09/24 20:27:00  lavr
  1643.  * Message corrected: "Adjusted path too long"
  1644.  *
  1645.  * Revision 6.22  2001/09/10 21:14:58  lavr
  1646.  * Added functions: StringToHostPort()
  1647.  *                  HostPortToString()
  1648.  *
  1649.  * Revision 6.21  2001/05/31 21:30:57  vakatov
  1650.  * MIME_ParseContentTypeEx() -- a more accurate parsing
  1651.  *
  1652.  * Revision 6.20  2001/05/29 21:15:43  vakatov
  1653.  * + eMIME_Plain
  1654.  *
  1655.  * Revision 6.19  2001/04/24 21:29:43  lavr
  1656.  * Special text value "infinite" accepted as infinite timeout from environment
  1657.  *
  1658.  * Revision 6.18  2001/03/26 18:37:09  lavr
  1659.  * #include <ctype.h> not used, removed
  1660.  *
  1661.  * Revision 6.17  2001/03/02 20:08:05  lavr
  1662.  * Typo fixed
  1663.  *
  1664.  * Revision 6.16  2001/01/25 16:58:33  lavr
  1665.  * ConnNetInfo_SetUserHeader now used throughout to set/reset http_user_header
  1666.  *
  1667.  * Revision 6.15  2001/01/23 23:06:18  lavr
  1668.  * SConnNetInfo.debug_printout converted from boolean to enum
  1669.  * BUF_StripToPattern() introduced
  1670.  *
  1671.  * Revision 6.14  2001/01/12 00:01:27  lavr
  1672.  * CONN_PROXY_HOST was forgotten to init in ConnNetInfo_Create
  1673.  *
  1674.  * Revision 6.13  2001/01/11 23:07:08  lavr
  1675.  * ConnNetInfo_Print() prints user-header 'as is'; pretty-printing undone
  1676.  *
  1677.  * Revision 6.12  2001/01/08 23:46:27  lavr
  1678.  * REQUEST_METHOD -> REQ_METHOD to be consistent with SConnNetInfo
  1679.  *
  1680.  * Revision 6.11  2001/01/08 22:35:56  lavr
  1681.  * Client-Mode removed; replaced by 2 separate boolean fields:
  1682.  * stateless and firewall
  1683.  *
  1684.  * Revision 6.10  2000/12/29 17:54:11  lavr
  1685.  * NCBID stuff removed; ConnNetInfo_SetUserHeader added;
  1686.  * modifications to ConnNetInfo_Print output.
  1687.  *
  1688.  * Revision 6.9  2000/11/07 23:23:18  vakatov
  1689.  * In-sync with the C Toolkit "connutil.c:R6.15", "connutil.h:R6.13"
  1690.  * (with "eMIME_Dispatch" added).
  1691.  *
  1692.  * Revision 6.8  2000/10/20 17:08:40  lavr
  1693.  * All keys capitalized for registry access
  1694.  * Search for some keywords made case insensitive
  1695.  *
  1696.  * Revision 6.7  2000/10/11 22:29:44  lavr
  1697.  * Forgotten blank added after {GET|POST} request in URL_Connect
  1698.  *
  1699.  * Revision 6.6  2000/10/05 22:35:24  lavr
  1700.  * SConnNetInfo modified to contain 'client_mode' instead of just
  1701.  * 'firewall' boolean
  1702.  *
  1703.  * Revision 6.5  2000/09/27 19:37:40  lavr
  1704.  * ncbi_ansi_ext.h included
  1705.  *
  1706.  * Revision 6.4  2000/09/26 22:01:33  lavr
  1707.  * Registry entries changed, HTTP request method added
  1708.  *
  1709.  * Revision 6.3  2000/04/21 19:42:35  vakatov
  1710.  * Several minor typo/bugs fixed
  1711.  *
  1712.  * Revision 6.2  2000/03/29 16:36:09  vakatov
  1713.  * MIME_ParseContentType() -- a fix
  1714.  *
  1715.  * Revision 6.1  2000/03/24 22:53:34  vakatov
  1716.  * Initial revision
  1717.  *
  1718.  * ==========================================================================
  1719.  */