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

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

生物技术

开发平台：

C/C++

ncbi_http_connector.c：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: ncbi_http_connector.c,v $
  4.  * PRODUCTION Revision 1000.3  2004/02/12 21:52:44  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [CORE_001] Dev-tree R6.63
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: ncbi_http_connector.c,v 1000.3 2004/02/12 21:52:44 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:  Anton Lavrentiev, Denis Vakatov
  36.  *
  37.  * File Description:
  38.  *   Implement CONNECTOR for the HTTP-based network connection
  39.  *
  40.  *   See in "ncbi_connector.h" for the detailed specification of the underlying
  41.  *   connector("CONNECTOR", "SConnectorTag") methods and structures.
  42.  *
  43.  */
  45. #include "ncbi_ansi_ext.h"
  46. #include "ncbi_priv.h"
  47. #include <connect/ncbi_http_connector.h>
  48. #include <ctype.h>
  49. #include <stdlib.h>
  52. /***********************************************************************
  53.  *  INTERNAL -- Auxiliary types and static functions
  54.  ***********************************************************************/
  56. /* If the connector is allowed to connect
  57.  */
  58. typedef enum {
  59.     eCC_None,
  60.     eCC_Once,
  61.     eCC_Unlimited
  62. } ECanConnect;
  65. typedef unsigned EBCanConnect;
  66. typedef unsigned TBHCC_Flags;
  69. /* All internal data necessary to perform the (re)connect and I/O
  70.  *
  71.  * The following states are defined:
  72.  *  "sock"  | "read_header" | State description
  73.  * ---------+---------------+--------------------------------------------------
  74.  *   NULL   |  <whatever>   | User "WRITE" mode: accumulate data in buffer
  75.  * non-NULL |   non-zero    | HTTP header is being read
  76.  * non-NULL |     zero      | HTTP body is being read (user "READ" mode)
  77.  * ---------+---------------+--------------------------------------------------
  78.  */
  79. typedef struct {
  80.     SConnNetInfo*        net_info;        /* network configuration parameters*/
  81.     FHttpParseHTTPHeader parse_http_hdr;  /* callback to parse HTTP reply hdr*/
  82.     FHttpAdjustNetInfo   adjust_net_info; /* for on-the-fly net_info adjust  */
  83.     FHttpAdjustCleanup   adjust_cleanup;  /* supplemental user data...       */
  84.     void*                adjust_data;     /* ...and cleanup routine          */
  86.     TBHCC_Flags          flags:10;        /* as passed to constructor        */
  87.     unsigned             reserved:1;
  88.     unsigned             error_header:1;  /* only err.HTTP header on SOME dbg*/
  89.     EBCanConnect         can_connect:2;   /* whether more conns permitted    */
  90.     unsigned             read_header:1;   /* whether reading header          */
  91.     unsigned             shut_down:1;     /* whether shut down for write     */
  92.     unsigned short       failure_count;   /* incr each failure since open    */
  94.     SOCK                 sock;         /* socket;  NULL if not in "READ" mode*/
  95.     const STimeout*      o_timeout;    /* NULL(infinite), dflt or ptr to next*/
  96.     STimeout             oo_timeout;   /* storage for (finite) open timeout  */
  97.     const STimeout*      w_timeout;    /* NULL(infinite), dflt or ptr to next*/
  98.     STimeout             ww_timeout;   /* storage for a (finite) write tmo   */
  100.     BUF                  http;         /* storage for HTTP reply header      */
  101.     BUF                  r_buf;        /* storage to accumulate input data   */
  102.     BUF                  w_buf;        /* storage to accumulate output data  */
  103.     size_t               w_len;        /* pending message body size          */
  104. } SHttpConnector;
  107. /* Try to fix connection parameters (called for an unconnected connector) */
  108. static int/*bool*/ s_Adjust(SHttpConnector* uuu,
  109.                             char**          redirect,
  110.                             int/*bool*/     drop_unread)
  111. {
  112.     assert(!uuu->sock && uuu->can_connect != eCC_None);
  113.     /* we're here because something is going wrong */
  114.     if (++uuu->failure_count >= uuu->net_info->max_try) {
  115.         if (*redirect) {
  116.             free(*redirect);
  117.             *redirect = 0;
  118.         }
  119.         if (!drop_unread && uuu->failure_count > 1) {
  120.             CORE_LOGF(eLOG_Error, ("[HTTP]  Too many failed attempts (%d),"
  121.                                    " giving up", uuu->failure_count));
  122.         }
  123.         uuu->can_connect = eCC_None;
  124.         return 0/*failure*/;
  125.     }
  126.     /* adjust info before yet another connection attempt */
  127.     if (*redirect) {
  128.         int status = ConnNetInfo_ParseURL(uuu->net_info, *redirect);
  129.         free(*redirect);
  130.         *redirect = 0;
  131.         if (!status) {
  132.             CORE_LOG(eLOG_Error, "[HTTP]  Unable to parse redirect");
  133.             uuu->can_connect = eCC_None;
  134.             return 0/*failure*/;
  135.         }
  136.     } else if (!uuu->adjust_net_info ||
  137.                uuu->adjust_net_info(uuu->net_info,
  138.                                     uuu->adjust_data,
  139.                                     uuu->failure_count) == 0) {
  140.         if (!drop_unread && uuu->failure_count > 1) {
  141.             CORE_LOGF(eLOG_Error, ("[HTTP]  Retry attempts (%d) exhausted,"
  142.                                    " giving up", uuu->failure_count));
  143.         }
  144.         uuu->can_connect = eCC_None;
  145.         return 0/*failure*/;
  146.     }
  148.     ConnNetInfo_AdjustForHttpProxy(uuu->net_info);
  150.     if (uuu->net_info->debug_printout)
  151.         ConnNetInfo_Log(uuu->net_info, CORE_GetLOG());
  152.     return 1/*success*/;
  153. }
  156. /* Unconditionally drop the connection; timeout may specify time allowance */
  157. static void s_DropConnection(SHttpConnector* uuu, const STimeout* timeout)
  158. {
  159.     size_t http_size = BUF_Size(uuu->http);
  160.     assert(uuu->sock);
  161.     if (http_size  &&  BUF_Read(uuu->http, 0, http_size) != http_size) {
  162.         CORE_LOG(eLOG_Error, "[HTTP]  Cannot discard HTTP header buffer");
  163.         assert(0);
  164.     }
  165.     SOCK_SetTimeout(uuu->sock, eIO_Close, timeout);
  166.     SOCK_Close(uuu->sock);
  167.     uuu->sock = 0;
  168. }
  171. /* Connect to the HTTP server, specified by uuu->net_info's "port:host".
  172.  * Return eIO_Success only if socket connection has succeeded and uuu->sock
  173.  * is non-zero. If unsuccessful, try to adjust uuu->net_info by s_Adjust(),
  174.  * and then re-try the connection attempt.
  175.  */
  176. static EIO_Status s_Connect(SHttpConnector* uuu, int/*bool*/ drop_unread)
  177. {
  178.     assert(!uuu->sock);
  179.     if (uuu->can_connect == eCC_None) {
  180.         CORE_LOG(eLOG_Error, "[HTTP]  Connector is no longer usable");
  181.         return eIO_Closed;
  182.     }
  184.     /* the re-try loop... */
  185.     for (;;) {
  186.         int/*bool*/ reset_user_header = 0;
  187.         char*       http_user_header = 0;
  188.         char*       null = 0;
  190.         uuu->w_len = BUF_Size(uuu->w_buf);
  191.         if (uuu->net_info->http_user_header)
  192.             http_user_header = strdup(uuu->net_info->http_user_header);
  193.         if (!uuu->net_info->http_user_header == !http_user_header) {
  194.             ConnNetInfo_ExtendUserHeader
  195.                 (uuu->net_info, "User-Agent: NCBIHttpConnector"
  196. #ifdef NCBI_CXX_TOOLKIT
  197.                  " (C++ Toolkit)"
  198. #else
  199.                  " (C Toolkit)"
  200. #endif
  201.                  "rn");
  202.             reset_user_header = 1;
  203.         }
  204.         /* connect & send HTTP header */
  205.         uuu->sock = URL_Connect
  206.             (uuu->net_info->host,       uuu->net_info->port,
  207.              uuu->net_info->path,       uuu->net_info->args,
  208.              uuu->net_info->req_method, uuu->w_len,
  209.              uuu->o_timeout,            uuu->w_timeout,
  210.              uuu->net_info->http_user_header,
  211.              (int/*bool*/) (uuu->flags & fHCC_UrlEncodeArgs),
  212.              uuu->net_info->debug_printout == eDebugPrintout_Data
  213.              ? eOn : (uuu->net_info->debug_printout == eDebugPrintout_None
  214.                       ? eOff : eDefault));
  215.         if (reset_user_header) {
  216.             ConnNetInfo_SetUserHeader(uuu->net_info, 0);
  217.             uuu->net_info->http_user_header = http_user_header;
  218.         }
  220.         if (uuu->sock) {
  221.             if (!(uuu->flags & fHCC_NoUpread))
  222.                 SOCK_SetReadOnWrite(uuu->sock, eOn);
  223.             return eIO_Success;
  224.         }
  226.         /* connection failed, no socket was created */
  227.         if (!s_Adjust(uuu, &null, drop_unread))
  228.             break;
  229.     }
  231.     return eIO_Closed;
  232. }
  235. /* Connect to the server specified by uuu->net_info, then compose and form
  236.  * relevant HTTP header, and flush the accumulated output data(uuu->w_buf)
  237.  * after the HTTP header. If connection/write unsuccessful, retry to reconnect
  238.  * and send the data again until permitted by s_Adjust().
  239.  */
  240. static EIO_Status s_ConnectAndSend(SHttpConnector* uuu,int/*bool*/ drop_unread)
  241. {
  242.     EIO_Status status;
  244.     for (;;) {
  245.         char*  null = 0;
  247.         if (!uuu->sock) {
  248.             if ((status = s_Connect(uuu, drop_unread)) != eIO_Success)
  249.                 break;
  250.             assert(uuu->sock);
  251.             uuu->read_header = 1/*true*/;
  252.             uuu->shut_down = 0/*false*/;
  253.         } else
  254.             status = eIO_Success;
  256.         if (uuu->w_len) {
  257.             size_t off = BUF_Size(uuu->w_buf) - uuu->w_len;
  259.             SOCK_SetTimeout(uuu->sock, eIO_Write, uuu->w_timeout);
  260.             do {
  261.                 char   buf[4096];
  262.                 size_t n_written;
  263.                 size_t n_write = BUF_PeekAt(uuu->w_buf, off, buf, sizeof(buf));
  264.                 status = SOCK_Write(uuu->sock, buf, n_write,
  265.                                     &n_written, eIO_WritePlain);
  266.                 if (status != eIO_Success)
  267.                     break;
  268.                 uuu->w_len -= n_written;
  269.                 off        += n_written;
  270.             } while (uuu->w_len);
  271.         } else if (!uuu->shut_down)
  272.             status = SOCK_Write(uuu->sock, 0, 0, 0, eIO_WritePlain);
  274.         if (status == eIO_Success) {
  275.             assert(uuu->w_len == 0);
  276.             if (!uuu->shut_down) {
  277.                 /* 10/07/03: While this call here is perfectly legal, it could
  278.                  * cause connection severed by a buggy CISCO load-balancer. */
  279.                 /* 10/28/03: CISCO's beta patch for their LB shows that the
  280.                  * problem has been fixed; no more 2'30" drops in connections
  281.                  * that shut down for write.  We still leave this commented
  282.                  * out to allow unpatched clients work seamlessly... */ 
  283.                 /*SOCK_Shutdown(uuu->sock, eIO_Write);*/
  284.                 uuu->shut_down = 1;
  285.             }
  286.             break;
  287.         }
  289.         if (status == eIO_Timeout &&  uuu->w_timeout  &&
  290.             !uuu->w_timeout->sec  &&  !uuu->w_timeout->usec) {
  291.             break;
  292.         }
  294.         CORE_LOGF(eLOG_Error,
  295.                   ("[HTTP]  Error writing body at offset %lu (%s)",
  296.                    (unsigned long) (BUF_Size(uuu->w_buf) - uuu->w_len),
  297.                    IO_StatusStr(status)));
  299.         /* write failed; close and try to use another server */
  300.         SOCK_Abort(uuu->sock);
  301.         s_DropConnection(uuu, 0/*no wait*/);
  302.         if (!s_Adjust(uuu, &null, drop_unread)) {
  303.             status = eIO_Closed;
  304.             break;
  305.         }
  306.     }
  308.     return status;
  309. }
  312. /* Parse HTTP header */
  313. static EIO_Status s_ReadHeader(SHttpConnector* uuu, char** redirect)
  314. {
  315.     int/*bool*/ moved = 0/*false*/;
  316.     int         server_error = 0;
  317.     int         http_status = 0;
  318.     char*       header;
  319.     size_t      size;
  321.     assert(uuu->sock && uuu->read_header);
  322.     *redirect = 0;
  323.     if (uuu->flags & fHCC_KeepHeader) {
  324.         uuu->read_header = 0;
  325.         return eIO_Success;
  326.     }
  328.     /* line by line HTTP header input */
  329.     for (;;) {
  330.         EIO_Status status;
  332.         /* do we have full header yet? */
  333.         size = BUF_Size(uuu->http);
  334.         if (!(header = (char*) malloc(size + 1))) {
  335.             CORE_LOGF(eLOG_Error, ("[HTTP]  Cannot allocate header, %lu bytes",
  336.                                    (unsigned long) size));
  337.             return eIO_Unknown;
  338.         }
  339.         verify(BUF_Peek(uuu->http, header, size) == size);
  340.         header[size] = '';
  341.         if (size >= 4  &&  strcmp(&header[size - 4], "rnrn") == 0)
  342.             break/*full header captured*/;
  343.         free(header);
  345.         status = SOCK_StripToPattern(uuu->sock, "rn", 2, &uuu->http, 0);
  346.         if (status != eIO_Success) {
  347.             const STimeout* tmo = SOCK_GetTimeout(uuu->sock, eIO_Read);
  348.             if (tmo && (tmo->sec || tmo->usec)) {
  349.                 CORE_LOGF(eLOG_Error, ("[HTTP]  Error reading header (%s)",
  350.                                        IO_StatusStr(status)));
  351.             }
  352.             return status;
  353.         }
  354.     }
  355.     uuu->read_header = 0/*false*/; /* the entire header has been read */
  356.     if (BUF_Read(uuu->http, 0, size) != size) {
  357.         CORE_LOG(eLOG_Error, "[HTTP]  Cannot discard HTTP header buffer");
  358.         assert(0);
  359.     }
  361.     /* HTTP status must come on the first line of the reply */
  362.     if (sscanf(header, " HTTP/%*d.%*d %d ", &http_status) != 1  ||
  363.         http_status < 200  ||  299 < http_status) {
  364.         server_error = http_status;
  365.         if (http_status == 301  ||  http_status == 302)
  366.             moved = 1;
  367.         else if (http_status == 403  ||  http_status == 404)
  368.             uuu->net_info->max_try = 0;
  369.     }
  371.     if ((server_error || !uuu->error_header) &&
  372.         uuu->net_info->debug_printout == eDebugPrintout_Some) {
  373.         /* HTTP header gets printed as part of data logging when
  374.            uuu->net_info->debug_printout == eDebugPrintout_Data. */
  375.         const char* header_header;
  376.         if (!server_error) 
  377.             header_header = "HTTP header";
  378.         else if (moved)
  379.             header_header = "HTTP header (moved)";
  380.         else if (!uuu->net_info->max_try)
  381.             header_header = "HTTP header (unrecoverable error)";
  382.         else
  383.             header_header = "HTTP header (server error, can retry)";
  384.         CORE_DATA(header, size, header_header);
  385.     }
  387.     if (uuu->parse_http_hdr) {
  388.         if (!(*uuu->parse_http_hdr)
  389.             (header, uuu->adjust_data, server_error))
  390.             server_error = 1;
  391.     }
  393.     if (moved) {
  394.         /* parsing "Location" pointer */
  395.         const char k_LocationTag[] = "nLocation: ";
  396.         char*      location = strstr(header, k_LocationTag);
  398.         if (location) {
  399.             char* s;
  401.             location += sizeof(k_LocationTag) - 1;
  402.             if (!(s = strchr(location, 'r')))
  403.                 *strchr(location, 'n') = 0;
  404.             else
  405.                 *s = 0;
  406.             while (*location) {
  407.                 if (isspace((unsigned char)(*location)))
  408.                     location++;
  409.                 else
  410.                     break;
  411.             }
  412.             for (s = location; *s; s++)
  413.                 if (isspace((unsigned char)(*s)))
  414.                     break;
  415.             *s = 0;
  416.             if (*location)
  417.                 *redirect = strdup(location);
  418.         }
  419.     }
  421.     if (header)
  422.         free(header);
  424.     /* skip & printout the content, if server error was flagged */
  425.     if (server_error && uuu->net_info->debug_printout == eDebugPrintout_Some) {
  426.         BUF        buf = 0;
  427.         EIO_Status status;
  428.         char*      body;
  430.         SOCK_SetTimeout(uuu->sock, eIO_Read, 0);
  431.         status = SOCK_StripToPattern(uuu->sock, 0, 0, &buf, 0);
  432.         assert(status != eIO_Success); /* because reading until EOF */
  433.         if (!(size = BUF_Size(buf))) {
  434.             CORE_LOG(eLOG_Trace, "[HTTP]  No body received with this error");
  435.         } else if ((body = (char*) malloc(size)) != 0) {
  436.             size_t n = BUF_Read(buf, body, size);
  437.             if (n != size) {
  438.                 CORE_LOGF(eLOG_Error, ("[HTTP]  Cannot read server error "
  439.                                        "body from buffer (%lu out of %lu)",
  440.                                        (unsigned long) n,
  441.                                        (unsigned long) size));
  442.             }
  443.             CORE_DATA(body, n, "HTTP server error body");
  444.             free(body);
  445.         } else {
  446.             CORE_LOGF(eLOG_Error, ("[HTTP]  Cannot allocate server error "
  447.                                    "body, %lu bytes", (unsigned long) size));
  448.         }
  449.         BUF_Destroy(buf);
  450.     }
  452.     return server_error ? eIO_Unknown : eIO_Success;
  453. }
  456. /* Prepare connector for reading. Open socket if necessary and
  457.  * make initial connect and send, re-trying if possible until success.
  458.  * Return codes:
  459.  *   eIO_Success = success, connector is ready for reading (uuu->sock != NULL);
  460.  *   eIO_Timeout = maybe (check uuu->sock) connected and no data yet available;
  461.  *   other code  = error, not connected (uuu->sock == NULL).
  462.  */
  463. static EIO_Status s_PreRead(SHttpConnector* uuu,
  464.                             const STimeout* timeout,
  465.                             int/*bool*/     drop_unread)
  466. {
  467.     char* redirect = 0;
  468.     EIO_Status status;
  470.     for (;;) {
  471.         status = s_ConnectAndSend(uuu, drop_unread);
  472.         if (!uuu->sock) {
  473.             assert(status != eIO_Success);
  474.             break;
  475.         }
  476.         if (status != eIO_Success) {
  477.             if (status != eIO_Timeout ||
  478.                 status == SOCK_Status(uuu->sock, eIO_Read)/*pending*/)
  479.                 break;
  480.         }
  482.         /* set timeout */
  483.         SOCK_SetTimeout(uuu->sock, eIO_Read, timeout);
  485.         if (!uuu->read_header)
  486.             break;
  488.         if ((status = s_ReadHeader(uuu, &redirect)) == eIO_Success) {
  489.             size_t w_size = BUF_Size(uuu->w_buf);
  490.             assert(!uuu->read_header);
  491.             /* pending output data no longer needed */
  492.             if (BUF_Read(uuu->w_buf, 0, w_size) != w_size) {
  493.                 CORE_LOG(eLOG_Error, "[HTTP]  Cannot discard output buffer");
  494.                 assert(0);
  495.             }
  496.             break;
  497.         }
  498.         /* if polling then bail out with eIO_Timeout */
  499.         if(status == eIO_Timeout && timeout && !timeout->sec && !timeout->usec)
  500.             break;
  502.         /* HTTP header read error; disconnect and try to use another server */
  503.         SOCK_Abort(uuu->sock);
  504.         s_DropConnection(uuu, 0/*no wait*/);
  505.         if (!s_Adjust(uuu, &redirect, drop_unread))
  506.             break;
  507.         assert(redirect == 0);
  508.     }
  509.     assert(redirect == 0);
  510.     return status;
  511. }
  514. /* Read non-header data from connection */
  515. static EIO_Status s_Read(SHttpConnector* uuu, void* buf,
  516.                          size_t size, size_t* n_read)
  517. {
  518.     assert(uuu->sock);
  519.     /* just read, with no URL-decoding */
  520.     if (!(uuu->flags & fHCC_UrlDecodeInput))
  521.         return SOCK_Read(uuu->sock, buf, size, n_read, eIO_ReadPlain);
  523.     /* read and URL-decode */
  524.     {{
  525.         EIO_Status status;
  526.         size_t     n_peeked, n_decoded;
  527.         size_t     peek_size = 3 * size;
  528.         void*      peek_buf  = malloc(peek_size);
  530.         /* peek the data */
  531.         status= SOCK_Read(uuu->sock,peek_buf,peek_size,&n_peeked,eIO_ReadPeek);
  532.         if (status != eIO_Success) {
  533.             *n_read = 0;
  534.             free(peek_buf);
  535.             return status;
  536.         }
  538.         /* decode, then discard the successfully decoded data from the input */
  539.         if (URL_Decode(peek_buf, n_peeked, &n_decoded, buf, size, n_read)) {
  540.             if (n_decoded) {
  541.                 size_t x_read;
  542.                 SOCK_Read(uuu->sock,peek_buf,n_decoded,&x_read,eIO_ReadPlain);
  543.                 assert(x_read == n_decoded);
  544.                 status = eIO_Success;
  545.             } else if (SOCK_Status(uuu->sock, eIO_Read) == eIO_Closed)
  546.                 /* we are at EOF, and the remaining data cannot be decoded */
  547.                 status = eIO_Unknown;
  548.         } else
  549.             status = eIO_Unknown;
  551.         if (status != eIO_Success)
  552.             CORE_LOG(eLOG_Error, "[HTTP]  Cannot URL-decode data");
  554.         free(peek_buf);
  555.         return status;
  556.     }}
  557. }
  560. /* Reset/readout input data and close socket */
  561. static EIO_Status s_Disconnect(SHttpConnector* uuu,
  562.                                int/*bool*/     drop_unread,
  563.                                const STimeout* timeout)
  564. {
  565.     EIO_Status status = eIO_Success;
  567.     if (drop_unread) {
  568.         size_t r_size = BUF_Size(uuu->r_buf);
  569.         if (r_size  &&  BUF_Read(uuu->r_buf, 0, r_size) != r_size) {
  570.             CORE_LOG(eLOG_Error, "[HTTP]  Cannot drop input buffer");
  571.             assert(0);
  572.         }
  573.     } else if ((status = s_PreRead(uuu, timeout, 0/*nodrop*/)) == eIO_Success){
  574.         do {
  575.             char     buf[4096];
  576.             size_t   x_read;
  577.             status = s_Read(uuu, buf, sizeof(buf), &x_read);
  578.             if (!BUF_Write(&uuu->r_buf, buf, x_read))
  579.                 status = eIO_Unknown;
  580.         } while (status == eIO_Success);
  581.         if (status == eIO_Closed)
  582.             status = eIO_Success;
  583.     }
  585.     if (uuu->sock) /* s_PreRead() might have dropped the connection already */
  586.         s_DropConnection(uuu, timeout);
  587.     if (uuu->can_connect == eCC_Once)
  588.         uuu->can_connect = eCC_None;
  590.     return status;
  591. }
  594. /* Send the accumulated output data(if any) to server, then close socket.
  595.  * Regardless of the flush, clear both input and output buffer.
  596.  * This function is only called to either re-open or close the connector.
  597.  */
  598. static void s_FlushAndDisconnect(SHttpConnector* uuu,
  599.                                  const STimeout* timeout,
  600.                                  int/*bool*/     close)
  601. {
  602.     size_t w_size = BUF_Size(uuu->w_buf);
  604.     /* store timeouts for later use */
  605.     if (timeout) {
  606.         uuu->oo_timeout = *timeout;
  607.         uuu->o_timeout  = &uuu->oo_timeout;
  608.         uuu->ww_timeout = *timeout;
  609.         uuu->w_timeout  = &uuu->ww_timeout;
  610.     } else {
  611.         uuu->o_timeout  = timeout;
  612.         uuu->w_timeout  = timeout;
  613.     }
  615.     if (close  &&  uuu->can_connect != eCC_None  &&  !uuu->sock  &&
  616.         ((uuu->flags & fHCC_SureFlush)  ||  BUF_Size(uuu->w_buf))) {
  617.         /* "WRITE" mode and data (or just flag) pending */
  618.         s_PreRead(uuu, timeout, 1/*drop_unread*/);
  619.     }
  620.     s_Disconnect(uuu, 1/*drop_unread*/, timeout);
  621.     assert(!uuu->sock);
  623.     /* clear pending output data, if any */
  624.     if (w_size  &&  BUF_Read(uuu->w_buf, 0, w_size) != w_size) {
  625.         CORE_LOG(eLOG_Error, "[HTTP]  Cannot drop output buffer");
  626.         assert(0);
  627.     }
  628. }
  631. /***********************************************************************
  632.  *  INTERNAL -- "s_VT_*" functions for the "virt. table" of connector methods
  633.  ***********************************************************************/
  635. #ifdef __cplusplus
  636. extern "C" {
  637. #endif /* __cplusplus */
  638.     static const char* s_VT_GetType (CONNECTOR       connector);
  639.     static char*       s_VT_Descr   (CONNECTOR       connector);
  640.     static EIO_Status  s_VT_Open    (CONNECTOR       connector,
  641.                                      const STimeout* timeout);
  642.     static EIO_Status  s_VT_Wait    (CONNECTOR       connector,
  643.                                      EIO_Event       event,
  644.                                      const STimeout* timeout);
  645.     static EIO_Status  s_VT_Write   (CONNECTOR       connector,
  646.                                      const void*     buf,
  647.                                      size_t          size,
  648.                                      size_t*         n_written,
  649.                                      const STimeout* timeout);
  650.     static EIO_Status  s_VT_Flush   (CONNECTOR       connector,
  651.                                      const STimeout* timeout);
  652.     static EIO_Status  s_VT_Read    (CONNECTOR       connector,
  653.                                      void*           buf,
  654.                                      size_t          size,
  655.                                      size_t*         n_read,
  656.                                      const STimeout* timeout);
  657.     static EIO_Status  s_VT_Status  (CONNECTOR       connector,
  658.                                      EIO_Event       dir);
  659.     static EIO_Status  s_VT_Close   (CONNECTOR       connector,
  660.                                      const STimeout* timeout);
  662.     static void        s_Setup      (SMetaConnector *meta,
  663.                                      CONNECTOR connector);
  664.     static void        s_Destroy    (CONNECTOR connector);
  665. #  ifdef IMPLEMENTED__CONN_WaitAsync
  666.     static EIO_Status s_VT_WaitAsync(CONNECTOR     connector,
  667.                                      FConnectorAsyncHandler  func,
  668.                                      SConnectorAsyncHandler* data);
  669. #  endif
  670. #ifdef __cplusplus
  671. } /* extern "C" */
  672. #endif /* __cplusplus */
  675. /*ARGSUSED*/
  676. static const char* s_VT_GetType
  677. (CONNECTOR connector)
  678. {
  679.     return "HTTP";
  680. }
  683. static char* s_VT_Descr
  684. (CONNECTOR connector)
  685. {
  686.     SHttpConnector* uuu = (SHttpConnector*) connector->handle;
  687.     size_t len = 7/*"http://"*/ + strlen(uuu->net_info->host) +
  688.         (uuu->net_info->port == 80 ? 0 : 6/*:port*/) +
  689.         strlen(uuu->net_info->path) +
  690.         (*uuu->net_info->args ? 2 + strlen(uuu->net_info->args) : 1);
  691.     char* buf = (char*) malloc(len);
  692.     if (buf) {
  693.         len = sprintf(buf, "http://%s", uuu->net_info->host);
  694.         if (uuu->net_info->port != 80)
  695.             len += sprintf(&buf[len], ":%hu", uuu->net_info->port);
  696.         sprintf(&buf[len], "%s%s%s", uuu->net_info->path,
  697.                 *uuu->net_info->args ? "&" : "", uuu->net_info->args);
  698.     }
  699.     return buf;
  700. }
  703. static EIO_Status s_VT_Open
  704. (CONNECTOR       connector,
  705.  const STimeout* timeout)
  706. {
  707.     SHttpConnector* uuu = (SHttpConnector*) connector->handle;
  709.     /* NOTE: the real connect will be performed on the first "READ", or
  710.      * "CLOSE", or on "WAIT" on read -- see in "s_ConnectAndSend()";
  711.      * we just close underlying socket and prepare to open it later */
  712.     s_FlushAndDisconnect(uuu, timeout, 0/*open*/);
  714.     /* reset the auto-reconnect feature */
  715.     uuu->can_connect = uuu->flags & fHCC_AutoReconnect
  716.         ? eCC_Unlimited : eCC_Once;
  717.     uuu->failure_count = 0;
  719.     return eIO_Success;
  720. }
  723. static EIO_Status s_VT_Wait
  724. (CONNECTOR       connector,
  725.  EIO_Event       event,
  726.  const STimeout* timeout)
  727. {
  728.     SHttpConnector* uuu = (SHttpConnector*) connector->handle;
  730.     switch (event) {
  731.     case eIO_Read:
  732.         if (uuu->can_connect == eCC_None)
  733.             return eIO_Closed;
  734.         if (!uuu->sock || uuu->read_header) {
  735.             EIO_Status status = s_PreRead(uuu, timeout, 0/*no drop unread*/);
  736.             if (status != eIO_Success || BUF_Size(uuu->r_buf))
  737.                 return status;
  738.             assert(uuu->sock);
  739.         }
  740.         return SOCK_Wait(uuu->sock, eIO_Read, timeout);
  741.     case eIO_Write:
  742.         /* Return 'Closed' if no more writes are allowed (and now - reading) */
  743.         return uuu->can_connect == eCC_None ||
  744.             (uuu->sock && uuu->can_connect == eCC_Once)
  745.             ? eIO_Closed : eIO_Success;
  746.     default:
  747.         assert(0);
  748.         return eIO_InvalidArg;
  749.     }
  750. }
  753. static EIO_Status s_VT_Write
  754. (CONNECTOR       connector,
  755.  const void*     buf,
  756.  size_t          size,
  757.  size_t*         n_written,
  758.  const STimeout* timeout)
  759. {
  760.     SHttpConnector* uuu = (SHttpConnector*) connector->handle;
  762.     /* if trying to "WRITE" after "READ" then close the socket,
  763.      * and so switch to "WRITE" mode */
  764.     if (uuu->sock) {
  765.         EIO_Status status = s_Disconnect(uuu,
  766.                                          uuu->flags & fHCC_DropUnread,
  767.                                          timeout);
  768.         if (status != eIO_Success)
  769.             return status;
  770.     }
  771.     if (uuu->can_connect == eCC_None)
  772.         return eIO_Closed; /* no more connects permitted */
  774.     /* accumulate all output in the memory buffer */
  775.     if (uuu->flags & fHCC_UrlEncodeOutput) {
  776.         /* with URL-encoding */
  777.         size_t dst_size = 3 * size;
  778.         void* dst = malloc(dst_size);
  779.         size_t dst_written;
  780.         URL_Encode(buf, size, n_written, dst, dst_size, &dst_written);
  781.         assert(*n_written == size);
  782.         if (!BUF_Write(&uuu->w_buf, dst, dst_written)) {
  783.             free(dst);
  784.             return eIO_Unknown;
  785.         }
  786.         free(dst);
  787.     } else {
  788.         /* "as is" (without URL-encoding) */
  789.         if (!BUF_Write(&uuu->w_buf, buf, size))
  790.             return eIO_Unknown;
  791.         *n_written = size;
  792.     }
  794.     /* store the write timeout */
  795.     if (timeout) {
  796.         uuu->ww_timeout = *timeout;
  797.         uuu->w_timeout  = &uuu->ww_timeout;
  798.     } else
  799.         uuu->w_timeout  = timeout;
  801.     return eIO_Success;
  802. }
  805. static EIO_Status s_VT_Flush
  806. (CONNECTOR       connector,
  807.  const STimeout* timeout)
  808. {
  809.     SHttpConnector* uuu = (SHttpConnector*) connector->handle;
  811.     /* The real flush will be performed on the first "READ" (or "CLOSE"),
  812.      * or on "WAIT". Here, we just store the write timeout, that's all...
  813.      */
  814.     if (timeout) {
  815.         uuu->ww_timeout = *timeout;
  816.         uuu->w_timeout  = &uuu->ww_timeout;
  817.     } else
  818.         uuu->w_timeout  = timeout;
  820.     return eIO_Success;
  821. }
  824. static EIO_Status s_VT_Read
  825. (CONNECTOR       connector,
  826.  void*           buf,
  827.  size_t          size,
  828.  size_t*         n_read,
  829.  const STimeout* timeout)
  830. {
  831.     SHttpConnector* uuu = (SHttpConnector*) connector->handle;
  832.     EIO_Status status = s_PreRead(uuu, timeout, 0/*no drop unread*/);
  833.     size_t x_read = BUF_Read(uuu->r_buf, buf, size);
  835.     *n_read = x_read;
  836.     if (x_read < size) {
  837.         if (status != eIO_Success)
  838.             return status;
  839.         status = s_Read(uuu, (char*) buf + x_read, size - x_read, n_read);
  840.         *n_read += x_read;
  841.     } else
  842.         status = eIO_Success;
  844.     return *n_read ? eIO_Success : status;
  845. }
  848. static EIO_Status s_VT_Status
  849. (CONNECTOR connector,
  850.  EIO_Event dir)
  851. {
  852.     SHttpConnector* uuu = (SHttpConnector*) connector->handle;
  853.     return uuu->sock ? SOCK_Status(uuu->sock, dir) :
  854.         (uuu->can_connect == eCC_None ? eIO_Closed : eIO_Success);
  855. }
  858. static EIO_Status s_VT_Close
  859. (CONNECTOR       connector,
  860.  const STimeout* timeout)
  861. {
  862.     s_FlushAndDisconnect((SHttpConnector*) connector->handle,
  863.                          timeout, 1/*close*/);
  864.     return eIO_Success;
  865. }
  868. #ifdef IMPLEMENTED__CONN_WaitAsync
  869. static EIO_Status s_VT_WaitAsync
  870. (void*                   connector,
  871.  FConnectorAsyncHandler  func,
  872.  SConnectorAsyncHandler* data)
  873. {
  874.     return eIO_NotSupported;
  875. }
  876. #endif
  879. static void s_Setup(SMetaConnector *meta, CONNECTOR connector)
  880. {
  881.     SHttpConnector* uuu = (SHttpConnector*) connector->handle;
  883.     /* initialize virtual table */
  884.     CONN_SET_METHOD(meta, get_type,   s_VT_GetType,   connector);
  885.     CONN_SET_METHOD(meta, descr,      s_VT_Descr,     connector);
  886.     CONN_SET_METHOD(meta, open,       s_VT_Open,      connector);
  887.     CONN_SET_METHOD(meta, wait,       s_VT_Wait,      connector);
  888.     CONN_SET_METHOD(meta, write,      s_VT_Write,     connector);
  889.     CONN_SET_METHOD(meta, flush,      s_VT_Flush,     connector);
  890.     CONN_SET_METHOD(meta, read,       s_VT_Read,      connector);
  891.     CONN_SET_METHOD(meta, status,     s_VT_Status,    connector);
  892.     CONN_SET_METHOD(meta, close,      s_VT_Close,     connector);
  893. #ifdef IMPLEMENTED__CONN_WaitAsync
  894.     CONN_SET_METHOD(meta, wait_async, s_VT_WaitAsync, connector);
  895. #endif
  896.     CONN_SET_DEFAULT_TIMEOUT(meta, uuu->net_info->timeout);
  897. }
  900. static void s_Destroy(CONNECTOR connector)
  901. {
  902.     SHttpConnector* uuu = (SHttpConnector*) connector->handle;
  904.     if (uuu->adjust_cleanup)
  905.         uuu->adjust_cleanup(uuu->adjust_data);
  906.     ConnNetInfo_Destroy(uuu->net_info);
  907.     BUF_Destroy(uuu->http);
  908.     BUF_Destroy(uuu->r_buf);
  909.     BUF_Destroy(uuu->w_buf);
  910.     free(uuu);
  911.     connector->handle = 0;
  912.     free(connector);
  913. }
  916. /***********************************************************************
  917.  *  EXTERNAL -- the connector's "constructor"
  918.  ***********************************************************************/
  920. extern CONNECTOR HTTP_CreateConnector
  921. (const SConnNetInfo* info,
  922.  const char*         user_header,
  923.  THCC_Flags          flags)
  924. {
  925.     SConnNetInfo *net_info;
  926.     CONNECTOR connector;
  928.     net_info = info ? ConnNetInfo_Clone(info) : ConnNetInfo_Create(0);
  929.     if (user_header)
  930.         ConnNetInfo_SetUserHeader(net_info, user_header);
  931.     connector = HTTP_CreateConnectorEx(net_info, flags, 0, 0, 0, 0);
  932.     ConnNetInfo_Destroy(net_info);
  933.     return connector;
  934. }
  937. extern CONNECTOR HTTP_CreateConnectorEx
  938. (const SConnNetInfo*  net_info,
  939.  THCC_Flags           flags,
  940.  FHttpParseHTTPHeader parse_http_hdr,
  941.  FHttpAdjustNetInfo   adjust_net_info,
  942.  void*                adjust_data,
  943.  FHttpAdjustCleanup   adjust_cleanup)
  944. {
  945.     CONNECTOR       ccc = (SConnector    *) malloc(sizeof(SConnector    ));
  946.     SHttpConnector* uuu = (SHttpConnector*) malloc(sizeof(SHttpConnector));
  948.     /* initialize internal data structure */
  949.     uuu->net_info        = net_info ?
  950.         ConnNetInfo_Clone(net_info) : ConnNetInfo_Create(0);
  951.     ConnNetInfo_AdjustForHttpProxy(uuu->net_info);
  952.     if (uuu->net_info->debug_printout)
  953.         ConnNetInfo_Log(uuu->net_info, CORE_GetLOG());
  955.     uuu->parse_http_hdr  = parse_http_hdr;
  956.     uuu->adjust_net_info = adjust_net_info;
  957.     uuu->adjust_cleanup  = adjust_cleanup;
  958.     uuu->adjust_data     = adjust_data;
  960.     uuu->flags           = flags;
  961.     if (flags & fHCC_UrlDecodeInput)
  962.         uuu->flags      &= ~fHCC_KeepHeader;
  963.     uuu->can_connect     = eCC_Once;         /* will be properly set at open */
  964.     uuu->error_header    = getenv("HTTP_ERROR_HEADER_ONLY") ? 1 : 0;
  966.     uuu->sock            = 0;
  967.     uuu->o_timeout       = kDefaultTimeout;  /* deliberately bad values --   */
  968.     uuu->w_timeout       = kDefaultTimeout;  /* will be reset prior to use   */
  969.     uuu->http            = 0;
  970.     uuu->r_buf           = 0;
  971.     uuu->w_buf           = 0;
  972.     /* there are some unintialized fields left -- they are initted later */
  974.     /* initialize connector structure */
  975.     ccc->handle  = uuu;
  976.     ccc->next    = 0;
  977.     ccc->meta    = 0;
  978.     ccc->setup   = s_Setup;
  979.     ccc->destroy = s_Destroy;
  981.     return ccc;
  982. }
  985. /*
  986.  * --------------------------------------------------------------------------
  987.  * $Log: ncbi_http_connector.c,v $
  988.  * Revision 1000.3  2004/02/12 21:52:44  gouriano
  989.  * PRODUCTION: UPGRADED [CORE_001] Dev-tree R6.63
  990.  *
  991.  * Revision 6.63  2004/02/12 16:50:02  lavr
  992.  * Heed warning about uninited variable use
  993.  *
  994.  * Revision 6.62  2003/11/26 12:57:11  lavr
  995.  * s_ReadHeader(): check header size first before looking for end-of-header
  996.  *
  997.  * Revision 6.61  2003/11/03 17:37:42  lavr
  998.  * Fix previous accidental commit and provide corrent change log info:
  999.  * 1. Added more notes about SOCK_Shutdown() being left commented out;
  1000.  * 2. Do not print HTTP error body if data trace mode set to "DATA".
  1001.  *
  1002.  * Revision 6.59  2003/10/29 14:09:08  lavr
  1003.  * Log levels and messages changed in some error reports
  1004.  *
  1005.  * Revision 6.58  2003/10/23 12:27:38  lavr
  1006.  * Do not double HTTP header when full data logging is explicitly on
  1007.  *
  1008.  * Revision 6.57  2003/10/07 20:00:10  lavr
  1009.  * Remove SOCK_Shutdown() after sending the HTTP header and request body
  1010.  *
  1011.  * Revision 6.56  2003/09/30 19:44:08  lavr
  1012.  * Fix typos in error messages
  1013.  *
  1014.  * Revision 6.55  2003/08/25 14:40:29  lavr
  1015.  * Employ new k..Timeout constants
  1016.  *
  1017.  * Revision 6.54  2003/06/09 19:52:42  lavr
  1018.  * New env.var. HTTP_ERROR_HEADER_ONLY to control header output on SOME tracing
  1019.  *
  1020.  * Revision 6.53  2003/06/04 20:58:13  lavr
  1021.  * s_Adjust() to return failure if no adjustment callback specified
  1022.  * s_VT_Status() to return eIO_Closed if connector failed/closed
  1023.  *
  1024.  * Revision 6.52  2003/05/31 05:15:15  lavr
  1025.  * Add ARGSUSED where args are meant to be unused
  1026.  *
  1027.  * Revision 6.51  2003/05/21 17:54:16  lavr
  1028.  * s_VT_Read() to return eIO_Success if some data have been read
  1029.  *
  1030.  * Revision 6.50  2003/05/20 23:54:00  lavr
  1031.  * Reinstate ConnNetInfo_Destroy() accidently deleted from s_Destroy()
  1032.  *
  1033.  * Revision 6.49  2003/05/20 21:26:40  lavr
  1034.  * Restructure SHttpConnector; add SHttpConnector::shut_down; enable to
  1035.  * call SOCK_Shutdown() again (after doing a dummy write of 0 bytes)
  1036.  *
  1037.  * Revision 6.48  2003/05/19 21:03:50  lavr
  1038.  * Remove SOCK_Shutdown() temporarily
  1039.  *
  1040.  * Revision 6.47  2003/05/19 16:48:39  lavr
  1041.  * Pending HTTP body write implemented ({0,0}-timeout tolerant)
  1042.  *
  1043.  * Revision 6.46  2003/05/14 03:57:48  lavr
  1044.  * Better logging; implementation of CONN_Description(); support of
  1045.  * {0,0} connect timeouts; bug workaround of MSVC's lame shutdown() is
  1046.  * now in ncbi_socket.c and moved away from this module
  1047.  *
  1048.  * Revision 6.45  2003/04/30 17:01:42  lavr
  1049.  * One (unnecessary) variable removed from s_ReadHeader()
  1050.  *
  1051.  * Revision 6.44  2003/02/04 22:04:11  lavr
  1052.  * Minor fix in comment
  1053.  *
  1054.  * Revision 6.43  2003/01/31 21:18:49  lavr
  1055.  * Fullfil max tries even in the absence of connection adjustment routine
  1056.  *
  1057.  * Revision 6.42  2003/01/17 19:44:46  lavr
  1058.  * Reduce dependencies
  1059.  *
  1060.  * Revision 6.41  2003/01/15 20:27:29  lavr
  1061.  * Fix breeding of NCBIHttpConnector token in User-Agent: header tag
  1062.  *
  1063.  * Revision 6.40  2003/01/10 14:51:29  lavr
  1064.  * Revert to R6.37 but properly handle drop of w_buf in s_FlushAndDisconnect()
  1065.  *
  1066.  * Revision 6.37  2002/12/13 21:19:40  lavr
  1067.  * Extend User-Agent: header tag
  1068.  *
  1069.  * Revision 6.36  2002/11/19 19:20:37  lavr
  1070.  * Server error parsing slightly changed
  1071.  *
  1072.  * Revision 6.35  2002/10/28 15:46:20  lavr
  1073.  * Use "ncbi_ansi_ext.h" privately
  1074.  *
  1075.  * Revision 6.34  2002/10/22 15:11:24  lavr
  1076.  * Zero connector's handle to crash if revisited
  1077.  *
  1078.  * Revision 6.33  2002/09/06 15:46:45  lavr
  1079.  * Few bug fixes about corner cases of I/O waiting, flushing and logging
  1080.  *
  1081.  * Revision 6.32  2002/08/12 15:12:23  lavr
  1082.  * Use persistent SOCK_Write()
  1083.  *
  1084.  * Revision 6.31  2002/08/07 16:33:04  lavr
  1085.  * Changed EIO_ReadMethod enums accordingly; log moved to end
  1086.  *
  1087.  * Revision 6.30  2002/07/25 20:20:43  lavr
  1088.  * Do not report header read error on {0, 0} timeout
  1089.  *
  1090.  * Revision 6.29  2002/07/25 13:59:35  lavr
  1091.  * More diagnostic messages added
  1092.  *
  1093.  * Revision 6.28  2002/06/19 18:08:02  lavr
  1094.  * Fixed some wrong assumptions on use of s_PreRead(); more comments added
  1095.  *
  1096.  * Revision 6.27  2002/06/10 19:51:20  lavr
  1097.  * Small prettifying
  1098.  *
  1099.  * Revision 6.26  2002/05/06 19:13:48  lavr
  1100.  * Output to stderr replaced with calls to logger
  1101.  *
  1102.  * Revision 6.25  2002/04/26 16:36:56  lavr
  1103.  * Added setting of default timeout in meta-connector's setup routine
  1104.  * Remove all checks for kDefaultTimeout: now supplied good from CONN
  1105.  *
  1106.  * Revision 6.24  2002/04/22 19:31:33  lavr
  1107.  * Reading/waiting redesigned to be more robust in case of network errors
  1108.  *
  1109.  * Revision 6.23  2002/03/22 19:52:16  lavr
  1110.  * Do not include <stdio.h>: included from ncbi_util.h or ncbi_priv.h
  1111.  *
  1112.  * Revision 6.22  2002/02/11 20:36:44  lavr
  1113.  * Use "ncbi_config.h"
  1114.  *
  1115.  * Revision 6.21  2002/02/05 22:04:12  lavr
  1116.  * Included header files rearranged
  1117.  *
  1118.  * Revision 6.20  2001/12/31 14:53:46  lavr
  1119.  * #include <connect/ncbi_ansi_ext.h> for Mac to be happy (noted by J.Kans)
  1120.  *
  1121.  * Revision 6.19  2001/12/30 20:00:00  lavr
  1122.  * Redirect on non-empty location only
  1123.  *
  1124.  * Revision 6.18  2001/12/30 19:41:07  lavr
  1125.  * Process error codes 301 and 302 (document moved) and reissue HTTP request
  1126.  *
  1127.  * Revision 6.17  2001/09/28 20:48:23  lavr
  1128.  * Comments revised; parameter (and SHttpConnector's) names adjusted
  1129.  * Retry logic moved entirely into s_Adjust()
  1130.  *
  1131.  * Revision 6.16  2001/09/10 21:15:56  lavr
  1132.  * Readability issue: FParseHTTPHdr -> FParseHTTPHeader
  1133.  *
  1134.  * Revision 6.15  2001/05/23 21:52:44  lavr
  1135.  * +fHCC_NoUpread
  1136.  *
  1137.  * Revision 6.14  2001/05/17 15:02:51  lavr
  1138.  * Typos corrected
  1139.  *
  1140.  * Revision 6.13  2001/05/08 20:26:27  lavr
  1141.  * Patches in re-try code
  1142.  *
  1143.  * Revision 6.12  2001/04/26 20:21:34  lavr
  1144.  * Reorganized and and made slightly more effective
  1145.  *
  1146.  * Revision 6.11  2001/04/24 21:41:47  lavr
  1147.  * Reorganized code to allow reconnects in case of broken connections at
  1148.  * stage of connection, sending data and receiving HTTP header. Added
  1149.  * code to pull incoming data from connection while sending - stall protection.
  1150.  *
  1151.  * Revision 6.10  2001/03/02 20:08:47  lavr
  1152.  * Typo fixed
  1153.  *
  1154.  * Revision 6.9  2001/01/25 16:53:24  lavr
  1155.  * New flag for HTTP_CreateConnectorEx: fHCC_DropUnread
  1156.  *
  1157.  * Revision 6.8  2001/01/23 23:11:20  lavr
  1158.  * Status virtual method implemented
  1159.  *
  1160.  * Revision 6.7  2001/01/11 16:38:17  lavr
  1161.  * free(connector) removed from s_Destroy function
  1162.  * (now always called from outside, in METACONN_Remove)
  1163.  *
  1164.  * Revision 6.6  2001/01/03 22:32:43  lavr
  1165.  * Redundant calls to 'adjust_info' removed
  1166.  *
  1167.  * Revision 6.5  2000/12/29 17:57:16  lavr
  1168.  * Adapted for use of new connector structure;
  1169.  * parse header callback added; some internal functions renamed.
  1170.  *
  1171.  * Revision 6.4  2000/11/15 18:52:02  vakatov
  1172.  * Call SOCK_Shutdown() after the HTTP request is sent.
  1173.  * Use SOCK_Status() instead of SOCK_Eof().
  1174.  *
  1175.  * Revision 6.3  2000/10/12 21:43:14  vakatov
  1176.  * Minor cosmetic fix...
  1177.  *
  1178.  * Revision 6.2  2000/09/26 22:02:57  lavr
  1179.  * HTTP request method added
  1180.  *
  1181.  * Revision 6.1  2000/04/21 19:41:01  vakatov
  1182.  * Initial revision
  1183.  *
  1184.  * ==========================================================================
  1185.  */