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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
SBinetHttpStream.cpp
资源名称：openvxi-3.4.zip　[点击查看]
上传用户：xqtpzdz
上传日期：2022-05-21
资源大小：1764k
文件大小：52k
源码类别：

xml/soap/webservice

开发平台：

Visual C++

SBinetHttpStream.cpp：源码内容
  2. /****************License************************************************
  3.  * Vocalocity OpenVXI
  4.  * Copyright (C) 2004-2005 by Vocalocity, Inc. All Rights Reserved.
  5.  * This program is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU General Public License
  7.  * as published by the Free Software Foundation; either version 2
  8.  * of the License, or (at your option) any later version.
  9.  *  
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  * Vocalocity, the Vocalocity logo, and VocalOS are trademarks or 
  19.  * registered trademarks of Vocalocity, Inc. 
  20.  * OpenVXI is a trademark of Scansoft, Inc. and used under license 
  21.  * by Vocalocity.
  22.  ***********************************************************************/
  24. #ifndef _SB_USE_STD_NAMESPACE
  25. #define _SB_USE_STD_NAMESPACE
  26. #endif
  28. #ifdef WIN32
  30. #ifndef UNICODE
  31. #define UNICODE
  32. #endif
  33. #ifndef _UNICODE
  34. #define _UNICODE
  35. #endif
  37. #ifndef WIN32_LEAN_AND_MEAN
  38. #define WIN32_LEAN_AND_MEAN
  39. #endif
  40. #include <windows.h>
  41. #endif
  43. #include <sys/timeb.h>                  // for _ftime( )/ftime( )
  44. #include <stdio.h>                      // for sprintf
  46. #include "VXIvalue.h"
  47. #include "VXIinet.h"
  48. #include "VXItrd.h"
  50. #include "SBinetLog.h"
  51. #include "SBinetURL.h"
  52. #include "SBinetHttpStream.hpp"
  53. #include "SBinetChannel.h"
  54. #include "SBinetHttpConnection.hpp"
  55. #include "SBinetValidator.h"
  56. #include "SBinetCookie.h"
  57. #include "SBinetUtils.hpp"
  58. #include "SWITimeWatch.hpp"
  60. #include "util_date.h"
  61. #include "ap_ctype.h"
  62. #include "HttpUtils.hpp"
  63. #include <SWIsocket.hpp>
  64. #include <SWIdataOutputStream.hpp>
  65. #include <SWIbufferedInputStream.hpp>
  66. #include <SWIbufferedOutputStream.hpp>
  68. #include <list>
  69. typedef std::basic_string<VXIchar> inetstring;
  71. #define HTTP_UNDEFINED -1234  /* No HTTP error code yet */
  73. #define READ_CHUNK_SIZE 128 * 1024 // Read from socket in 128 Kb chunks
  75. SBinetHttpStream::SBinetHttpStream(SBinetURL* url,
  76.                                    SubmitMethod method,
  77.                                    SBinetChannel* ch,
  78.                                    SBinetValidator* cacheValidator,
  79.                                    VXIlogInterface *log,
  80.                                    VXIunsigned diagLogBase):
  81.   SBinetStoppableStream(url, SBinetStream_HTTP, log, diagLogBase),
  82.   _HttpStatus(HTTP_UNDEFINED), _leftToRead(~0), _chunked(false),
  83.   _method(method), _channel(ch), _connection(NULL),
  84.   _inputStream(NULL), _outputStream(NULL), _closeConnection(TRUE),
  85.   _validator(NULL), _cacheValidator(cacheValidator), _connectionAborted(FALSE)
  86. {}
  88. SBinetHttpStream::~SBinetHttpStream()
  89. {
  90.   delete _validator;
  91.   Close();
  92. }
  94. VXIinetResult SBinetHttpStream::initSocket(SubmitMethod method,
  95.                                            const VXIMap *properties,
  96.                                            VXIMap *streamInfo)
  97. {
  98.   _connection = _channel->getHttpConnection(_url, properties);
  100.   if (_connection == NULL)
  101.   {
  102.     Error(262, L"%s%s", L"URL", _url->getAbsolute());
  103.     return VXIinet_RESULT_FETCH_ERROR;
  104.   }
  106.   SWITimeWatch timeWatch;
  107.   timeWatch.start();
  109.   switch (_connection->connect(getDelay()))
  110.   {
  111.    case SWIstream::TIMED_OUT:
  112.      Error(241, NULL);
  113.      return VXIinet_RESULT_FETCH_TIMEOUT;
  114.      break;
  115.    case SWIstream::SUCCESS:
  116.      break;
  117.    default:
  118.      Error(244, L"%s%s", L"URL", _url->getAbsolute());
  119.      return VXIinet_RESULT_FETCH_ERROR;
  120.   }
  122.   _inputStream = _connection->getInputStream();
  123.   _outputStream = _connection->getOutputStream();
  125.   Diag(MODULE_SBINET_TIMING_TAGID, L"SBinetHttpStream::initSocket",
  126.        L"%i msecs, Connect to socket", timeWatch.getElapsed());
  128.   writeDebugTimeStamp();
  130.   if (method == SBinetHttpStream::GET_METHOD)
  131.     _channel->writeString(_outputStream, "GET ");
  132.   else
  133.     _channel->writeString(_outputStream, "POST ");
  135.   if (_connection->usesProxy())
  136.     _channel->writeString(_outputStream, _url->getNAbsolute());
  137.   else
  138.     _channel->writeString(_outputStream, _url->getNPath());
  140.   _channel->writeString(_outputStream, " HTTP/1.1" CRLF);
  141.   _channel->writeString(_outputStream, "Accept: */*" CRLF);
  143.   // Write HOST header.
  144.   _channel->writeString(_outputStream, "Host: ");
  145.   _channel->writeString(_outputStream, _url->getNHost());
  146.   int defaultPort = _url->getProtocol() == SBinetURL::HTTP_PROTOCOL ? 80 : 443;
  147.   int port = _url->getPort();
  149.   if (port != defaultPort)
  150.   {
  151.     _channel->writeString(_outputStream, ":");
  152.     _channel->writeInt(_outputStream, port);
  153.   }
  154.   _channel->writeString(_outputStream, CRLF);
  156.   // Write USER-AGENT header.
  157.   _channel->writeString(_outputStream, "User-Agent: ");
  158.   _channel->writeString(_outputStream, _channel->getUserAgent());
  159.   _channel->writeString(_outputStream, CRLF);
  161.   // Write REFERER header.
  162.   SBinetNString baseUrl = _url->getNBase();
  163.   if (baseUrl.length() > 0)
  164.   {
  165.     // Cut query arguments, if present
  166.     VXIunsigned queryArgsSeparator = baseUrl.find('?');
  167.     if (queryArgsSeparator < baseUrl.length())
  168.       baseUrl.resize(queryArgsSeparator);
  170.     if (baseUrl.length() > 0)
  171.     {
  172.       _channel->writeString(_outputStream, "Referer: ");
  173.       _channel->writeString(_outputStream, baseUrl.c_str());
  174.       _channel->writeString(_outputStream, CRLF);
  175.     }
  176.   }
  178.   SBinetUtils::getInteger(properties, INET_CLOSE_CONNECTION, _closeConnection);
  180.   if (_closeConnection)
  181.   {
  182.     _channel->writeString(_outputStream, "Connection: close" CRLF);
  183.   }
  185.   VXIint32 maxAge = -1;
  186.   VXIint32 maxStale = -1;
  188.   getCacheInfo(properties, maxAge, maxStale);
  190.   if (maxAge != -1)
  191.   {
  192.     _channel->writeString(_outputStream, "Cache-Control: max-age=");
  193.     _channel->writeInt(_outputStream, maxAge);
  194.     _channel->writeString(_outputStream, CRLF);
  195.   }
  197.   if (maxStale != -1)
  198.   {
  199.     _channel->writeString(_outputStream, "Cache-Control: max-stale=");
  200.     _channel->writeInt(_outputStream, maxStale);
  201.     _channel->writeString(_outputStream, CRLF);
  202.   }
  204.   time_t lastModified = (time_t) -1;
  205.   SBinetNString etag;
  207.   if (_cacheValidator)
  208.   {
  209.     // Otherwise, use the validator that was stored in the cache, if any.
  210.     lastModified = _cacheValidator->getLastModified();
  211.     const VXIchar* eTagStr = _cacheValidator->getETAG();
  212.     if (eTagStr)
  213.       etag = eTagStr;
  214.   }
  216.   if ((method == SBinetHttpStream::GET_METHOD) && (lastModified != (time_t) -1))
  217.   {
  218.     char lastModStr[32];
  219.     ap_gm_timestr_822(lastModStr, lastModified);
  220.     _channel->writeString(_outputStream, "If-Modified-Since: ");
  221.     _channel->writeString(_outputStream, lastModStr);
  222.     _channel->writeString(_outputStream, CRLF);
  223.   }
  225.   if (etag.length() > 0 && etag[0])     
  226.   {
  227.     _channel->writeString(_outputStream, "If-None-Match: ");
  228.     _channel->writeString(_outputStream, etag.c_str());
  229.     _channel->writeString(_outputStream, CRLF);
  230.   }
  232.   if (_channel->cookiesEnabled())
  233.   {
  234.     _channel->collectCookies(_outputStream, _url->getNHost(), _url->getNPath());
  235.   }
  237.   return VXIinet_RESULT_SUCCESS;
  238. }
  240. VXIinetResult SBinetHttpStream::flushAndCheckConnection()
  241. {
  242.   VXIinetResult rc = VXIinet_RESULT_SUCCESS;
  243.   SWIstream::Result src = _outputStream->flush();
  244.   switch( src ) {
  245.     case SWIstream::SUCCESS:
  246.       break;
  247.     case SWIstream::CONNECTION_ABORTED:
  248.     case SWIstream::CONNECTION_RESET:
  249.       _connectionAborted = TRUE;
  250.       // If the server reset the connection 
  251.       // due to keepalive timeout, connection timeout, etc.
  252.       // then retry the connection again without output the error
  253.       // intentional fall through        
  254.     default:
  255.       Diag(MODULE_SBINET_CONNECTION_TAGID, L"SBinetHttpStream::doGet",
  256.            L"_outputStream->flush() error = %d, connection %s", 
  257.            src, (_connectionAborted ? L"aborted" : L"error"));     
  258.       rc = VXIinet_RESULT_IO_ERROR;
  259.   }  
  260.   return rc;
  261. }
  263. VXIinetResult SBinetHttpStream::doGet(VXIint32 flags,
  264.                                       const VXIMap *properties,
  265.                                       VXIMap *streamInfo)
  267. {
  268.   VXIinetResult rc = VXIinet_RESULT_SUCCESS;
  270.   try
  271.   {
  272.     rc = initSocket(GET_METHOD, properties, streamInfo);
  273.     if (rc != VXIinet_RESULT_SUCCESS)
  274.       return rc;
  276.     _channel->writeString(_outputStream, CRLF);
  278.     rc = flushAndCheckConnection();
  279.     
  280.   }
  281.   catch (std::exception& e)
  282.   {
  283.     // An error occurred sending data over the socket.  Abort the connection and
  284.     // try again.
  285.     if (strcmp(e.what(), "CONNECTION_ABORTED") == 0)
  286.       _connectionAborted = TRUE;
  287.     rc = VXIinet_RESULT_IO_ERROR;
  288.     Diag(MODULE_SBINET_CONNECTION_TAGID, L"SBinetHttpStream::doGet",
  289.          L"initSocket caught exception return error = %d, connection aborted", rc);     
  290.   }
  292.   return rc;
  293. }
  295. /*
  296.  * POST simple form data. Don't know how to combine Form data and audio in multipart POST
  297.  */
  298. VXIinetResult SBinetHttpStream::doPost(VXIint32 flags,
  299.                                        const VXIMap *properties,
  300.                                        VXIMap *streamInfo)
  301. {
  302.   const VXIMap *queryArgs =
  303.     (const VXIMap *)VXIMapGetProperty(properties, INET_URL_QUERY_ARGS);
  305.   SBinetNString queryArgsStr;
  306.   VXIint argsLen;
  308.   EncodingType encodingType = getEncodingType(properties);
  309.   const char *encodingStr;
  311.   if (encodingType == TYPE_MULTIPART)
  312.   {
  313.     encodingStr = SB_MULTIPART;
  314.     queryArgsStr = _url->queryArgsToMultipart(queryArgs);
  315.     argsLen = queryArgsStr.length();
  316.     Diag(MODULE_SBINET_STREAM_TAGID, L"SBinetHttpStream::doPost",
  317.          L"Performing multipart POST, data size %i", argsLen);
  318.   }
  319.   else
  320.   {
  321.     encodingStr = SB_URLENCODED;
  322.     queryArgsStr = _url->queryArgsToNString(queryArgs);
  323.     argsLen = queryArgsStr.length();
  324.     Diag(MODULE_SBINET_STREAM_TAGID, L"SBinetHttpStream::doPost",
  325.          L"Performing URL-encoded POST, data size %i", argsLen);
  326.   }
  328.   VXIinetResult rc = VXIinet_RESULT_SUCCESS;
  329.   
  330.   try
  331.   {
  332.     rc = initSocket(POST_METHOD, properties, streamInfo);
  333.     if (rc != VXIinet_RESULT_SUCCESS)
  334.       return rc;
  336.     _channel->writeString(_outputStream, "Expect: 100-continue" CRLF);
  338.     _channel->writeString(_outputStream, "Content-Length: ");
  339.     _channel->writeInt(_outputStream, argsLen);
  340.     _channel->writeString(_outputStream, CRLF);
  342.     _channel->writeString(_outputStream, "Content-Type: ");
  343.     _channel->writeString(_outputStream, encodingStr);
  344.     _channel->writeString(_outputStream, CRLF CRLF);
  346.     rc = flushAndCheckConnection();
  347.     if( rc != VXIinet_RESULT_SUCCESS ) 
  348.       return rc;
  350.     // Wait for input stream to be ready.  If time-out, just send data anyway.
  351.     // If we don't time out, we should be able to get an HTTP_CONTINUE.
  352.     VXIint32 continueTimeout = SBinetChannel::getPostContinueTimeout();
  353.     int maxDelay = getDelay();
  354.     if (continueTimeout < 0 ||
  355.         (maxDelay >=0 && continueTimeout > maxDelay))
  356.       continueTimeout = maxDelay;
  357.     
  358.     SWIstream::Result src = _inputStream->waitReady(continueTimeout);
  359.     switch (src)
  360.     {
  361.      case SWIstream::SUCCESS:
  362.        // Read the HTTP_CONTINUE header
  363.        if ((rc = getHeaderInfo(streamInfo)) != VXIinet_RESULT_SUCCESS)
  364.          return rc;
  366.        if (_HttpStatus != SBinetHttpUtils::HTTP_CONTINUE) {
  367.          Diag(MODULE_SBINET_CONNECTION_TAGID, L"SBinetHttpStream::doPost",
  368.               L"%s%d", L"waitReady epxected HTTP_CONTINUE but got status ", _HttpStatus);     
  369.          return VXIinet_RESULT_FETCH_ERROR;
  370.        }
  371.        
  372.        break;
  373.      case SWIstream::TIMED_OUT:
  374.        // We still have to send the body of the message.  This is done
  375.        // after the switch anyway so we do nothing.
  376.        break;
  377.      default:
  378.       Diag(MODULE_SBINET_CONNECTION_TAGID, L"SBinetHttpStream::doPost",
  379.            L"%s%d", L"waitReady returned IO ERROR ", src);     
  380.        // I/O error on the stream.  Just return an error.
  381.        return VXIinet_RESULT_FETCH_ERROR;
  382.     }
  384.     if (encodingType == TYPE_MULTIPART)
  385.     {
  386.       _channel->writeData(_outputStream, queryArgsStr.data(), argsLen);
  387.     }
  388.     else
  389.     {
  390.       _channel->writeString(_outputStream, queryArgsStr.c_str());
  391.     }
  393.     rc = flushAndCheckConnection();
  394.     if( rc != VXIinet_RESULT_SUCCESS )
  395.       return rc;
  396.   }
  397.   catch (std::exception& e)
  398.   {
  399.     // An error occurred sending data over the socket.  Abort the connection and
  400.     // try again.
  401.     Diag(MODULE_SBINET_CONNECTION_TAGID, L"SBinetHttpStream::doPost",
  402.          L"%s", L"exception caught returned IO ERROR for retry");     
  403.     if( strcmp(e.what(), "CONNECTION_ABORTED") == 0 )
  404.       _connectionAborted = TRUE;
  405.     return VXIinet_RESULT_IO_ERROR;
  406.   }
  408.   return rc;
  409. }
  411. bool SBinetHttpStream::handleRedirect(VXIMap *streamInfo)
  412. {
  413.   const VXIchar *location;
  415.   switch (_HttpStatus)
  416.   {
  417.     case SBinetHttpUtils::HTTP_SEE_OTHER:
  418.      // This return code implies that we change a POST into a GET.
  419.      _method = GET_METHOD;
  420.      // no break: intentional
  422.    case SBinetHttpUtils::HTTP_MULTIPLE_CHOICES:
  423.    case SBinetHttpUtils::HTTP_PERM_REDIRECT:
  424.    case SBinetHttpUtils::HTTP_FOUND:
  425.    case SBinetHttpUtils::HTTP_TEMP_REDIRECT:
  426.      location = SBinetUtils::getString(streamInfo, L"Location");
  427.      if (location == NULL || !*location)
  428.      {
  429.        Error(247, L"%s%s", L"URL", _url->getAbsolute());
  430.        return false;
  431.      }
  433.      if (_url->parse(location, _url->getAbsolute()) != VXIinet_RESULT_SUCCESS)
  434.      {
  435.        Error(248, L"%s%s%s%s", L"URL", _url->getAbsolute(),
  436.              L"Location", location);
  437.        return false;
  438.      }
  440.      return true;
  441.      break;
  442.    default:
  443.      return false;
  444.   }
  445. }
  447. // stupid function required because the people who designed VXIMap, in their
  448. // great wisdom, did not include a VXIMapClear function or the ability for the
  449. // iterator to delete the current entry.
  450. static void clearMap(VXIMap *streamInfo)
  451. {
  452. #if (VXI_CURRENT_VERSION >= 0x00030000)
  453.   VXIMapClear(streamInfo);
  454. #else
  455.   std::list<inetstring> keys;
  456.   const VXIchar *key = NULL;
  457.   const VXIValue *value = NULL;
  458.   int i = 0;
  459.   VXIMapIterator *mapIterator = VXIMapGetFirstProperty(streamInfo,
  460.                                                        &key,
  461.                                                        &value );
  462.   do
  463.   {
  464.     if (key != NULL)
  465.     {
  466.       keys.push_back(key);
  467.     }
  468.   }
  469.   while (VXIMapGetNextProperty(mapIterator, &key, &value) == VXIvalue_RESULT_SUCCESS);
  470.   VXIMapIteratorDestroy(&mapIterator);
  471.   while (!keys.empty())
  472.   {
  473.     VXIMapDeleteProperty(streamInfo, keys.front().c_str());
  474.     keys.pop_front();
  475.   }
  476. #endif  
  477. }
  480. VXIinetResult
  481. SBinetHttpStream::Open(VXIint32                  flags,
  482.        const VXIMap             *properties,
  483.        VXIMap                   *streamInfo)
  484. {
  485.   VXIinetResult rc = VXIinet_RESULT_SUCCESS;
  487.   // Make a copy in case of redirect.
  488.   SBinetString initialUrl = _url->getAbsolute();
  490.   const int maxRetry    = 5;
  491.   int nbRetry           = 0;
  492.   const int maxRedirect = 5;
  493.   int nbRedirect        = 0;
  494.   time_t requestTime = (time_t) -1;
  496.   // If reconnection happens, attempt to retry up to maxRetry
  497.   for (; nbRetry < maxRetry; )
  498.   {
  499.     // Set up request
  500.     rc = VXIinet_RESULT_NON_FATAL_ERROR;
  501.     _HttpStatus = HTTP_UNDEFINED;
  502.     requestTime = time(NULL);
  503.     _chunked = false;
  504.     _leftToRead = ~0;
  505.     _closeConnection = !SBinetChannel::getUsePersistentConnections();
  506.     _connectionAborted = FALSE;
  508.     if (_method == GET_METHOD)
  509.       rc = doGet(flags, properties, streamInfo);
  510.     else if (_method == POST_METHOD)
  511.       rc = doPost(flags, properties, streamInfo);
  513.     if ((rc != VXIinet_RESULT_SUCCESS) ||
  514.        ((rc = getHeaderInfo(streamInfo)) != VXIinet_RESULT_SUCCESS))
  515.     {      
  516.       if (_connectionAborted)
  517.       {
  518.         _closeConnection = TRUE;
  519.         // If the connection was reset by the HTTP server, create a new
  520.         // connection and try again.
  521.         Diag(MODULE_SBINET_CONNECTION_TAGID, L"SBinetHttpStream::Open",
  522.              L"%s%s%d", (_method == GET_METHOD ? L"GET" : L"POST"), 
  523.              L" method: connection is aborted, retry ", nbRetry);     
  524.         Close();
  525.         ++nbRetry;
  526.         continue;
  527.       }
  528.       else
  529.       {
  530.         Diag(MODULE_SBINET_CONNECTION_TAGID, L"SBinetHttpStream::Open",
  531.              L"%s%d", L"(no retry) getHeaderInfo returned error: ", rc); 
  532.         _closeConnection = TRUE;
  533.         break;
  534.       }      
  535.     }       
  536.        
  537.     // Avoid race condition on 100-Continue time-out.  If we got a CONTINUE
  538.     // from previous call to getHeaderInfo, we need to get it again.
  539.     if (_HttpStatus == SBinetHttpUtils::HTTP_CONTINUE &&
  540.         (rc = getHeaderInfo(streamInfo)) != VXIinet_RESULT_SUCCESS)
  541.     {
  542.       Diag(MODULE_SBINET_CONNECTION_TAGID, L"SBinetHttpStream::Open",
  543.            L"%s", L"Unexpected HTTP_CONTINUE"); 
  544.       _closeConnection = TRUE;
  545.       break;
  546.     }
  548.     if (_HttpStatus >= 300 && _HttpStatus <= 399 &&
  549.         handleRedirect(streamInfo))
  550.     {
  551.       // perform a reset on the stream.
  552.       Close();
  553.       if (++nbRedirect > maxRedirect)
  554.       {
  555.         Error(229, L"%s%s", L"URL", initialUrl.c_str());
  556.         return VXIinet_RESULT_FETCH_ERROR;
  557.       }
  558.       // Clear the streamInfo map to avoid previous fetch attribute to remain
  559.       // in the map.
  560.       if (streamInfo != NULL)
  561.         clearMap(streamInfo);
  562.         
  563.       // if redirect happens, reset retry value
  564.       nbRetry = 0;
  565.     }
  566.     else
  567.       break;
  568.   }
  570.   if (streamInfo != NULL && _HttpStatus >= 100 && _HttpStatus <= 999)
  571.   {
  572.     VXIMapSetProperty(streamInfo, INET_INFO_HTTP_STATUS,
  573.                       (VXIValue*) VXIIntegerCreate(_HttpStatus));
  575.     // Set HTTP data source information   
  576.     VXIMapSetProperty(streamInfo, INET_INFO_DATA_SOURCE, 
  577.                      (VXIValue*) VXIIntegerCreate(INET_DATA_SOURCE_HTTP));
  578.   }
  580.   switch (_HttpStatus)
  581.   {
  582.    case SBinetHttpUtils::HTTP_OK:
  583.      if (streamInfo != NULL)
  584.      {
  585.        processHeaderInfo(streamInfo);
  586.        setValidatorInfo(streamInfo, requestTime);
  587.      }
  588.      rc = VXIinet_RESULT_SUCCESS;
  589.      break;
  590.    case SBinetHttpUtils::HTTP_NOT_MODIFIED:
  591.      if (streamInfo != NULL) setValidatorInfo(streamInfo, requestTime, (VXIulong) -1);
  592.      Close();
  593.      rc = VXIinet_RESULT_NOT_MODIFIED;
  594.      break;
  595.    default:
  596.      Close();
  598.      // Map the HTTP error code
  599.      if (_HttpStatus != HTTP_UNDEFINED)
  600.      {
  601.        const VXIchar *errorDesc;
  602.        rc = MapError(_HttpStatus, &errorDesc);
  603.        Error(219, L"%s%s%s%s%s%d%s%s", L"URL", initialUrl.c_str(),
  604.              L"Method", (_method == GET_METHOD) ? L"GET" : L"POST",
  605.              L"HTTPStatus", _HttpStatus, L"HTTPStatusDescription", errorDesc);
  606.      }
  607.      else
  608.      {
  609.        Error(217, L"%s%s", L"URL", initialUrl.c_str());
  610.        if (rc == VXIinet_RESULT_SUCCESS)
  611.          rc = VXIinet_RESULT_NON_FATAL_ERROR;
  612.      }
  613.      break;
  614.   }
  616.   return rc;
  617. }
  620. VXIinetResult SBinetHttpStream::Close()
  621. {
  622.   if (_connection != NULL)
  623.   {
  624.     if (_closeConnection)
  625.       delete _connection;
  626.     else
  627.     {
  628.       // First make sure there is nothing left in the body.
  629.       VXIinetResult rc = skipBody();
  630.       if (rc == VXIinet_RESULT_SUCCESS)
  631.         _channel->putHttpConnection(_connection);
  632.       else
  633.         delete _connection;
  634.     }
  636.     _connection = NULL;
  637.     _inputStream = NULL;
  638.     _outputStream = NULL;
  639.   }
  641.   return(VXIinet_RESULT_SUCCESS);
  642. }
  645. VXIinetResult SBinetHttpStream::skipBody()
  646. {
  647.   // These HTTP status code do not allow for a body.
  648.   if (_HttpStatus == SBinetHttpUtils::HTTP_NOT_MODIFIED ||
  649.       _HttpStatus == SBinetHttpUtils::HTTP_NO_DATA  ||
  650.       (_HttpStatus >= 100 && _HttpStatus <= 199))
  651.     return VXIinet_RESULT_SUCCESS;
  653.   VXIinetResult rc;
  654.   VXIbyte buffer[1024];
  656.   while ((rc = Read(buffer, sizeof(buffer), NULL)) == VXIinet_RESULT_SUCCESS);
  657.   if (rc == VXIinet_RESULT_END_OF_STREAM)
  658.     rc = VXIinet_RESULT_SUCCESS;
  660.   return rc;
  661. }
  663. SBinetHttpStream::EncodingType SBinetHttpStream::getEncodingType(const VXIMap *properties)
  664. {
  665.   SBinetHttpStream::EncodingType encodingType = TYPE_URL_ENCODED;
  667.   // Get the submit MIME type from the properties, if defined
  668.   const VXIchar *strType =
  669.     SBinetUtils::getString(properties, INET_SUBMIT_MIME_TYPE);
  671.   if (strType && *strType)
  672.   {
  673.     // If DEFAULT ever changes, this code will need to be updated
  674.     if (::wcscmp(strType, INET_SUBMIT_MIME_TYPE_DEFAULT) == 0)
  675.       encodingType = TYPE_URL_ENCODED;
  676.     else if (::wcscmp(strType, L"multipart/form-data") == 0)
  677.       encodingType = TYPE_MULTIPART;
  678.     else
  679.       Error(304, L"%s%s%s%s%s%s", L"URL", _url->getAbsolute(),
  680.             L"EncodingType", strType,
  681.             L"DefaultType", INET_SUBMIT_MIME_TYPE_DEFAULT);
  682.   }
  684.   return encodingType;
  685. }
  687. VXIinetResult SBinetHttpStream::getStatus()
  688. {
  689.   _HttpStatus = HTTP_UNDEFINED;
  691.   VXIinetResult rc = waitStreamReady();
  692.   if (rc != VXIinet_RESULT_SUCCESS)
  693.     return rc;
  695.   writeDebugTimeStamp();
  697.   // The HTTP status line should have the following syntax:
  698.   // HTTP/x.x yyy msg CRLF
  699.   //
  700.   // This is buggy if we ever see an HTTP/1.xx in the future
  701.   SWIdataOutputStream line;
  702.   const char *c_line = NULL;
  704.   SWIstream::Result src = _channel->readLine(_inputStream, &line);
  705.   if (src >= 0)
  706.   {
  707.     if (ap_checkmask(c_line = line.getString(), "HTTP/#.# ###*"))
  708.     {
  709.       _HttpStatus = atoi(&c_line[9]);
  710.       int version = (c_line[5] - '0') * 10 + (c_line[7] - '0');
  711.       if (version < 11) _closeConnection = TRUE;
  712.     }
  713.     else
  714.     {
  715.       Error(249, L"%s%s", L"URL", _url->getAbsolute());
  716.     }
  717.   }
  718.   // A return value of END_OF_FILE means the connection was gracefully closed.
  719.   // A return value of CONNECTION_ABORTED means the connection was aborted
  720.   // because of a time out or some other problem.
  721.   else if ((src == SWIstream::CONNECTION_ABORTED) || (src == SWIstream::END_OF_FILE))
  722.   {
  723.     // Return immediately and do not check the _HttpStatus since
  724.     // we don't want to print errors for nothing.
  725.     _connectionAborted = true;
  726.     return VXIinet_RESULT_NON_FATAL_ERROR;
  727.   }
  728.   else
  729.   {
  730.     Error(249, L"%s%s", L"URL", _url->getAbsolute());
  731.   }
  733.   if (_HttpStatus < 100 || _HttpStatus > 999)
  734.   {
  735.     if (_HttpStatus != HTTP_UNDEFINED)
  736.     {
  737.       Error(219, L"%s%s%s%s%s%d",
  738.             L"URL", _url->getAbsolute(),
  739.             L"Method", _method == GET_METHOD ? L"GET" : L"POST",
  740.             L"HTTPStatus", _HttpStatus);
  741.     }
  742.     else
  743.     {
  744.       Error(221, L"%s%s", L"URL", _url->getAbsolute());
  745.     }
  746.     rc = VXIinet_RESULT_NON_FATAL_ERROR;
  747.   }
  749.   return rc;
  750. }
  752. enum HandlerValueType
  753. {
  754.   HANDLER_INT = 0x01,
  755.   HANDLER_DATE = 0x02,
  756.   HANDLER_STRING = 0x04,
  757.   HANDLER_CONTENT = 0x08,
  758.   HANDLER_LIST = 0x10
  759. };
  762. // Currently doing a linear search because of case-insenstivity of
  763. // comparisons.  If the number of entries in this array increases, we should
  764. // consider using a hash implementation instead.
  765. SBinetHttpStream::HeaderInfo SBinetHttpStream::headerInfoMap[] =
  766. {
  767.   { "Age", NULL, HANDLER_INT, NULL },
  768.   { "Cache-Control", NULL, HANDLER_STRING | HANDLER_LIST, NULL },
  769.   { "Content-Length", INET_INFO_SIZE_BYTES, HANDLER_INT, contentLengthHandler },
  770.   { "Content-Type", INET_INFO_MIME_TYPE, HANDLER_STRING, NULL },
  771.   { "Connection", NULL, HANDLER_STRING, connectionHandler },
  772.   { "Date", NULL, HANDLER_DATE, NULL },
  773.   { "ETag", NULL, HANDLER_STRING, NULL },
  774.   { "Expires", NULL, HANDLER_DATE, NULL },
  775.   { "Last-Modified", NULL, HANDLER_DATE, NULL },
  776.   { "Location", NULL, HANDLER_STRING, NULL },
  777.   { "Pragma", NULL, HANDLER_STRING, NULL },
  778.   { "Set-Cookie", NULL, HANDLER_STRING, setCookieHandler },
  779.   { "Set-Cookie2", NULL, HANDLER_STRING, setCookie2Handler },
  780.   { "Transfer-Encoding", NULL, HANDLER_STRING, transferEncodingHandler},
  781.   { NULL, NULL, 0, NULL }
  782. };
  784. void SBinetHttpStream::setCookieHandler(HeaderInfo *headerInfo,
  785.                                         const char *value,
  786.                                         SBinetHttpStream *httpStream,
  787.                                         VXIMap *streamInfo)
  788. {
  789.   if (!httpStream->_channel->cookiesEnabled())
  790.     return;
  792.   const char *p = value;
  794.   while (p != NULL && *p)
  795.   {
  796.     SBinetCookie *cookie = SBinetCookie::parse(httpStream->_url, p, httpStream);
  797.     if (cookie != NULL)
  798.     {
  799.       httpStream->_channel->updateCookie(cookie);
  800.     }
  801.   }
  802.   httpStream->Diag(MODULE_SBINET_STREAM_TAGID,
  803.                    L"SBinetHttpStream::setCookieHandler",
  804.                    L"Set-Cookie: %S", value);
  805. }
  807. void SBinetHttpStream::setCookie2Handler(HeaderInfo *headerInfo,
  808.                                          const char *value,
  809.                                          SBinetHttpStream *httpStream,
  810.                                          VXIMap *streamInfo)
  811. {
  812.   if (!httpStream->_channel->cookiesEnabled())
  813.     return;
  815.   httpStream->Diag(MODULE_SBINET_STREAM_TAGID,
  816.                    L"SBinetHttpStream::setCookie2Handler",
  817.                    L"Not Supported: "Set-Cookie2: %S"", value);
  818. }
  820. void SBinetHttpStream::contentLengthHandler(HeaderInfo *headerInfo,
  821.                                             const char *value,
  822.                                             SBinetHttpStream *httpStream,
  823.                                             VXIMap *streamInfo)
  824. {
  825.   // Ignore content-length if stream is chunked.
  826.   if (!httpStream->_chunked)
  827.   {
  828.     httpStream->_leftToRead = atoi(value);
  829.   }
  830. }
  832. void SBinetHttpStream::connectionHandler(HeaderInfo *headerInfo,
  833.                                          const char *value,
  834.                                          SBinetHttpStream *httpStream,
  835.                                          VXIMap *streamInfo)
  836. {
  837.   SBinetNString attrib;
  839.   for (;;)
  840.   {
  841.     if ((value = SBinetHttpUtils::getValue(value, attrib)) == NULL)
  842.     {
  843.       httpStream->Diag(MODULE_SBINET_STREAM_TAGID,
  844.                        L"SBinetHttpStream::connectionHandler",
  845.                        L"Could not get attribute.");
  846.       break;
  847.     }
  849.     if ((value = SBinetHttpUtils::expectChar(value, ",")) == NULL)
  850.     {
  851.       httpStream->Diag(MODULE_SBINET_STREAM_TAGID,
  852.                        L"SBinetHttpStream::connectionHandler",
  853.                        L"Expecting ','.");
  854.       break;
  855.     }
  857.     if (::strcasecmp(attrib.c_str(), "close") == 0)
  858.     {
  859.       httpStream->_closeConnection = TRUE;
  860.     }
  862.     // Skip comma, or if at end of string, stop parsing.
  863.     if (*value)
  864.       value++;
  865.     else
  866.       break;
  867.   }
  868. }
  870. void SBinetHttpStream::transferEncodingHandler(HeaderInfo *headerInfo,
  871.                                                const char *value,
  872.                                                SBinetHttpStream *httpStream,
  873.                                                VXIMap *streamInfo)
  874. {
  875.   SBinetNString encoding;
  877.   for (;;)
  878.   {
  879.     if ((value = SBinetHttpUtils::getValue(value, encoding)) == NULL)
  880.     {
  881.       httpStream->Diag(MODULE_SBINET_STREAM_TAGID,
  882.                        L"SBinetHttpStream::transferEncodingHandler",
  883.                        L"Could not get encoding.");
  884.       break;
  885.     }
  887.     if ((value = SBinetHttpUtils::expectChar(value, ",")) == NULL)
  888.     {
  889.       httpStream->Diag(MODULE_SBINET_STREAM_TAGID,
  890.                        L"SBinetHttpStream::transferEncodingHandler",
  891.                        L"Expecting ','.");
  892.       break;
  893.     }
  895.     if (::strcasecmp(encoding.c_str(), "chunked") == 0)
  896.     {
  897.       httpStream->_chunked = true;
  898.       httpStream->_leftToRead = 0;
  899.     }
  901.     // Skip comma, or if at end of string, stop parsing.
  902.     if (*value)
  903.       value++;
  904.     else
  905.       break;
  906.   }
  907. }
  909. void SBinetHttpStream::defaultHeaderHandler(HeaderInfo *headerInfo,
  910.                                             const char *value,
  911.                                             SBinetHttpStream *httpStream,
  912.                                             VXIMap *streamInfo)
  913. {
  914.   VXIValue* vxi_value = NULL;
  915.   bool listF = (headerInfo->value_type & HANDLER_LIST) == HANDLER_LIST;
  916.   int value_type = headerInfo->value_type & ~HANDLER_LIST;
  917.   const VXIchar *property = NULL;
  918.   SBinetString *propTmp = NULL;
  920.   if (headerInfo->inet_property != NULL)
  921.   {
  922.     property = headerInfo->inet_property;
  923.   }
  924.   else
  925.   {
  926.     propTmp = new SBinetString(headerInfo->header);
  927.     property = propTmp->c_str();
  928.   }
  930.   switch (value_type)
  931.   {
  932.    case HANDLER_INT:
  933.      vxi_value = (VXIValue *) VXIIntegerCreate(atoi(value));
  934.      break;
  935.    case HANDLER_STRING:
  936.      if (listF)
  937.      {
  938.        const VXIchar *v = SBinetUtils::getString(streamInfo, property);
  939.        if (v != NULL)
  940.        {
  941.          SBinetString tmp = v;
  942.          tmp += L", ";
  943.          tmp += value;
  944.          vxi_value = (VXIValue *) VXIStringCreate(tmp.c_str());
  945.        }
  946.      }
  947.      if (vxi_value == NULL)
  948.      {
  949.        vxi_value = (VXIValue *) VXIStringCreate(SBinetString(value).c_str());
  950.      }
  951.      break;
  952.    case HANDLER_DATE:
  953.      {
  954.        // FIXME: Portability issue. This code assumes that a time_t can be
  955.        // stored in a VXIint32 without losing any information.  Two possible
  956.        // options: extend VXIValue with a VXILong type or use VXIContent.
  957.        time_t timestamp = ap_parseHTTPdate(value);
  958.        vxi_value = (VXIValue *) VXIIntegerCreate(timestamp);
  959.      }
  960.      break;
  961.    case HANDLER_CONTENT:
  962.      if (listF)
  963.      {
  964.        const char *content;
  965.        VXIulong contentLength;
  967.        if (SBinetUtils::getContent(streamInfo, property, content, contentLength))
  968.        {
  969.          SBinetNString tmp = content;
  970.          tmp += ", ";
  971.          tmp += value;
  972.          vxi_value = (VXIValue *) SBinetUtils::createContent(tmp.c_str());
  973.        }
  974.      }
  975.      if (vxi_value == NULL)
  976.      {
  977.        vxi_value = (VXIValue *) SBinetUtils::createContent(value);
  978.      }
  979.      break;
  980.    default:
  981.      break;
  982.   }
  984.   if (vxi_value != NULL)
  985.   {
  986.     VXIMapSetProperty(streamInfo, property, vxi_value);
  987.   }
  988.   else
  989.   {
  990.     httpStream->Diag(MODULE_SBINET_STREAM_TAGID,
  991.                      L"SBinetHttpStream::defaultHeaderHandler",
  992.                      L"Could not create VXI value, header: <%S>, value: <%S>",
  993.                      headerInfo->header,
  994.                      value);
  995.   }
  997.   delete propTmp;
  998. }
  1000. SBinetHttpStream::HeaderInfo *SBinetHttpStream::findHeaderInfo(const char *header)
  1001. {
  1002.   for (int i = 0; headerInfoMap[i].header != NULL; i++)
  1003.   {
  1004.     if (::strcasecmp(headerInfoMap[i].header, header) == 0)
  1005.     {
  1006.       return &headerInfoMap[i];
  1007.     }
  1008.   }
  1010.   return NULL;
  1011. }
  1013. void SBinetHttpStream::processHeader(const char *header,
  1014.                                      const char *value,
  1015.                                      VXIMap* streamInfo)
  1016. {
  1017.   HeaderInfo *headerInfo = findHeaderInfo(header);
  1019.   // If it is not found, we ignore it.
  1020.   if (headerInfo == NULL) return;
  1022.   HeaderHandler handler = headerInfo->handler;
  1023.   if (handler == NULL) handler = defaultHeaderHandler;
  1025.   (*handler)(headerInfo, value, this, streamInfo);
  1026. }
  1028. static const unsigned long BREAK_AT_INITIAL_NEWLINE = 0x01;
  1029. static const unsigned long CONTINUE_AT_NEWLINE = 0x02;
  1031. int SBinetHttpStream::getValue(char *&value, unsigned long mask)
  1032. {
  1033.   char c;
  1034.   bool done = false;
  1036.   // skip white spaces.
  1037.   for (;;)
  1038.   {
  1039.     if ((c = _channel->readChar(_inputStream)) < 0)
  1040.       return -8;
  1042.     if (!ap_isspace(c))
  1043.       break;
  1045.     switch (c)
  1046.     {
  1047.      case 'r':
  1048.        if ((c = _channel->readChar(_inputStream)) != 'n')
  1049.          return -5;
  1050.        // no break: intentional
  1052.      case 'n':
  1053.        if (mask & BREAK_AT_INITIAL_NEWLINE)
  1054.        {
  1055.          if ((c = _inputStream->peek()) < 0) return -6;
  1056.          if (!ap_isspace(c)) done = true;
  1057.        }
  1059.        if (done)
  1060.        {
  1061.          value = new char[2];
  1062.          *value = '';
  1063.          Diag(MODULE_SBINET_STREAM_TAGID,
  1064.               L"SBinetHttpStream::getValue",
  1065.               L"value = '%S'", value);
  1066.          return 0;
  1067.        }
  1068.        break;
  1070.      default:
  1071.        break;
  1072.     }
  1073.   }
  1075.   int len = 0;
  1076.   int bufSize = 32;
  1077.   value = new char[bufSize];
  1079.   for (;;)
  1080.   {
  1081.     if (len == bufSize)
  1082.     {
  1083.       int newBufSize = (bufSize << 1);
  1084.       char *new_value = ::strncpy(new char[newBufSize], value, bufSize);
  1085.       delete [] value;
  1086.       value = new_value;
  1087.       bufSize = newBufSize;
  1088.     }
  1090.     if (c == 'r')
  1091.     {
  1092.       if ((c = _channel->readChar(_inputStream)) != 'n')
  1093.         break;
  1094.     }
  1096.     // We need to verify if the value continues on the next line.
  1097.     if (c == 'n')
  1098.     {
  1099.       if (mask & CONTINUE_AT_NEWLINE)
  1100.       {
  1101.         if ((c = _inputStream->peek()) < 0)
  1102.           break;
  1104.         if (!ap_isspace(c) || c == 'r' || c == 'n')
  1105.           done = true;
  1106.       }
  1107.       else
  1108.         done = true;
  1110.       if (done)
  1111.       {
  1112.         // remove trailing blanks and terminate string.
  1113.         while (len > 0 && ap_isspace(value[len-1])) len--;
  1114.         value[len] = '';
  1115.         Diag(MODULE_SBINET_STREAM_TAGID,
  1116.              L"SBinetHttpStream::getValue",
  1117.              L"value = '%S'", value);
  1118.         return 0;
  1119.       }
  1120.     }
  1122.     value[len++] = c;
  1124.     if ((c = _channel->readChar(_inputStream)) < 0)
  1125.       break;
  1126.   }
  1128.   // If we get here, we got an error parsing the line.
  1129.   delete [] value;
  1130.   value = NULL;
  1131.   return -7;
  1132. }
  1134. int SBinetHttpStream::getHeader(char *&header, char delimiter)
  1135. {
  1136.   int c;
  1138.   if ((c = _channel->readChar(_inputStream)) < 0)
  1139.     return -1;
  1141.   // Check for end of headers.
  1142.   if (c == 'r')
  1143.   {
  1144.     if ((c = _channel->readChar(_inputStream)) != 'n')
  1145.       return -2;
  1146.     return 1;
  1147.   }
  1149.   if (c == 'n') return 2;
  1151.   if (ap_isspace(c) || c == (unsigned char) delimiter)
  1152.     return -3;
  1154.   int len = 0;
  1155.   int bufSize = 32;
  1156.   header = new char[bufSize];
  1158.   for (;;)
  1159.   {
  1160.     if (len == bufSize)
  1161.     {
  1162.       int newBufSize = bufSize << 1;
  1163.       char *new_header = ::strncpy(new char[newBufSize], header, bufSize);
  1164.       delete [] header;
  1165.       header = new_header;
  1166.       bufSize = newBufSize;
  1167.     }
  1168.     if (c == (unsigned char) delimiter)
  1169.     {
  1170.       header[len++] = '';
  1171.       Diag(MODULE_SBINET_STREAM_TAGID,
  1172.            L"SBinetHttpStream::getHeader",
  1173.            L"header = '%S'", header);
  1174.       return 0;
  1175.     }
  1176.     header[len++] = c;
  1178.     if ((c = _channel->readChar(_inputStream)) < 0 || ap_isspace(c))
  1179.       break;
  1180.   }
  1182.   delete [] header;
  1183.   header = NULL;
  1184.   return -4;
  1185. }
  1187. int SBinetHttpStream::getHeaderValue(char *&header, char *&value)
  1188. {
  1189.   int rc = getHeader(header, ':');
  1191.   if (rc == 0)
  1192.   {
  1193.     rc = getValue(value, CONTINUE_AT_NEWLINE | BREAK_AT_INITIAL_NEWLINE);
  1194.     if (rc != 0)
  1195.     {
  1196.       Error(250, NULL);
  1197.       delete [] header;
  1198.       header = NULL;
  1199.     }
  1200.   }
  1201.   else if (rc < 0)
  1202.     Error(250, NULL);
  1204.   return rc;
  1205. }
  1207. VXIinetResult SBinetHttpStream::parseHeaders(VXIMap* streamInfo)
  1208. {
  1209.   char *header = NULL;
  1210.   char *value  = NULL;
  1211.   VXIinetResult rc1;
  1212.   int rc2;
  1214.   while (((rc1 = waitStreamReady()) == VXIinet_RESULT_SUCCESS) &&
  1215.          ((rc2 = getHeaderValue(header, value)) == 0))
  1216.   {
  1217.     if (streamInfo) processHeader(header, value, streamInfo);
  1218.     delete [] header;
  1219.     delete [] value;
  1220.   }
  1222.   if (rc1 == VXIinet_RESULT_SUCCESS && rc2 < 0)
  1223.   {
  1224.     Diag(MODULE_SBINET_STREAM_TAGID,
  1225.          L"SBinetHttpStream::parseHeaders",
  1226.          L"Error in parsing header line: URL = <%s>, METHOD = %s, rc2 = %d",
  1227.          _url->getAbsolute(),
  1228.          _method == GET_METHOD ? L"GET" : L"POST",
  1229.          rc2);
  1230.     rc1 = VXIinet_RESULT_NON_FATAL_ERROR;
  1231.   }
  1232.   return rc1;
  1233. }
  1236. void SBinetHttpStream::processHeaderInfo(VXIMap *streamInfo)
  1237. {
  1238.   // Extract the content-length to find out how many bytes are left to be
  1239.   // read from the stream.  If the stream is chunked, ignore
  1240.   // content-length from the server.  If we don't have the content, we
  1241.   // have to set the property to 0.
  1242.   VXIulong contentSize = (_chunked || _leftToRead == ~0) ? 0 : _leftToRead;
  1243.   VXIMapSetProperty(streamInfo, INET_INFO_SIZE_BYTES,
  1244.                     (VXIValue *) VXIIntegerCreate((int) contentSize));
  1246.   const VXIchar *tmp = _url->getAbsolute();
  1247.   if (tmp != NULL)
  1248.   {
  1249.     Diag(MODULE_SBINET_STREAM_TAGID,
  1250.          L"SBinetHttpStream::processHeaderInfo", L"%s%s",
  1251.          L"absolute", tmp);
  1252.     VXIMapSetProperty(streamInfo,
  1253.                       INET_INFO_ABSOLUTE_NAME,
  1254.                       (VXIValue*)VXIStringCreate(tmp));
  1255.   }
  1257.   const VXIString *contentType =
  1258.     (const VXIString *) VXIMapGetProperty(streamInfo, INET_INFO_MIME_TYPE);
  1260.   tmp = contentType != NULL ? VXIStringCStr(contentType) : NULL;
  1262.   if (!tmp || !*tmp
  1263.       || ::wcscmp(tmp, _channel->getDefaultMimeType()) == 0)
  1264.   {
  1265.     VXIString *newContentType = _url->getContentTypeFromUrl();
  1266.     if (newContentType != NULL)
  1267.     {
  1268.       Error (300, L"%s%s%s%s",
  1269.              L"URL", _url->getAbsolute(),
  1270.              L"mime-type", VXIStringCStr(newContentType));
  1271.     }
  1272.     else
  1273.     {
  1274.       newContentType = VXIStringCreate(_channel->getDefaultMimeType());
  1275.       Error (301, L"%s%s", L"URL", _url->getAbsolute());
  1276.     }
  1277.     VXIMapSetProperty(streamInfo, INET_INFO_MIME_TYPE,
  1278.       (VXIValue *) newContentType);
  1279.   }
  1280. }
  1283. void SBinetHttpStream::setValidatorInfo(VXIMap *streamInfo, time_t requestTime)
  1284. {
  1285.   _validator = new SBinetValidator(GetLog(), GetDiagBase());
  1287.   if (_validator->Create(_url->getAbsolute(), requestTime, streamInfo) == VXIinet_RESULT_SUCCESS)
  1288.   {
  1289.     SBinetUtils::setValidatorInfo(streamInfo, _validator);
  1290.   }
  1291. }
  1293. void SBinetHttpStream::setValidatorInfo(VXIMap *streamInfo, time_t requestTime, const VXIulong sizeBytes)
  1294. {
  1295.   _validator = new SBinetValidator(GetLog(), GetDiagBase());
  1297.   if (_validator->Create(_url->getAbsolute(), sizeBytes, requestTime, streamInfo) == VXIinet_RESULT_SUCCESS)
  1298.   {
  1299.     SBinetUtils::setValidatorInfo(streamInfo, _validator);
  1300.   }
  1301. }
  1303. VXIinetResult SBinetHttpStream::getHeaderInfo(VXIMap* streamInfo)
  1304. {
  1305.   SWITimeWatch timeWatch;
  1306.   timeWatch.start();
  1308.   VXIinetResult rc = getStatus();
  1309.   Diag(MODULE_SBINET_TIMING_TAGID, L"SBinetHttpStream::getStatus",
  1310.        L"%i msecs, Wait for HTTP response", timeWatch.getElapsed());
  1312.   if (rc == VXIinet_RESULT_SUCCESS)
  1313.   {
  1314.     rc = parseHeaders(streamInfo);
  1315.   }
  1317.   Diag(MODULE_SBINET_STREAM_TAGID, L"SBinetHttpStream::getHeaderInfo",
  1318.        L"rc = %d, HttpStatus = %d", rc, _HttpStatus);
  1319.   return rc;
  1320. }
  1322. VXIinetResult SBinetHttpStream::getChunkSize(VXIulong& chunk_size)
  1323. {
  1324.   // Read next chunk size.
  1325.   char *chunk_size_str;
  1327.   if (getValue(chunk_size_str, 0) < 0)
  1328.   {
  1329.     Error(245, L"%s%s", L"URL", _url->getAbsolute());
  1330.     return VXIinet_RESULT_FETCH_ERROR;
  1331.   }
  1333.   VXIinetResult rc = VXIinet_RESULT_SUCCESS;
  1334.   bool parseError = false;
  1335.   char *endParse;
  1336.   chunk_size = (VXIulong) strtol(chunk_size_str, &endParse, 16);
  1338.   // If we did not parse a single character, this is an error.
  1339.   if (endParse == chunk_size_str)
  1340.   {
  1341.     parseError = true;
  1342.   }
  1343.   else if (*endParse)
  1344.   {
  1345.     // We did not stop parsing at the end of the string.  If the only
  1346.     // remaining characters are whitespace, this is not an error.
  1347.     while (*endParse && ap_isspace(*endParse));
  1349.     // This is not really an eror as there might be a chunk extension that we
  1350.     // currently ignore.
  1351.     //
  1352.     //if (*endParse) parseError = true;
  1353.   }
  1355.   if (parseError)
  1356.   {
  1357.     // Either an empty string to parse or stopped at non hexadecimal
  1358.     // character.
  1359.     Error(246, L"%s%s%s%S", L"URL", _url->getAbsolute(),
  1360.           L"ChunkSize", chunk_size_str);
  1361.     rc = VXIinet_RESULT_FETCH_ERROR;
  1362.   }
  1364.   delete [] chunk_size_str;
  1365.   return rc;
  1366. }
  1368. static SWIstream::Result inetToStream(VXIinetResult rc)
  1369. {
  1370.   switch (rc)
  1371.   {
  1372.    case VXIinet_RESULT_SUCCESS:
  1373.      return SWIstream::SUCCESS;
  1374.    case VXIinet_RESULT_FETCH_TIMEOUT:
  1375.      return SWIstream::TIMED_OUT;
  1376.    default:
  1377.      return SWIstream::READ_ERROR;
  1378.   }
  1379. }
  1381. int SBinetHttpStream::readChunked(VXIbyte *buffer,
  1382.                                   VXIulong buflen)
  1383. {
  1384.   // Note.  This is not fully compliant as it does not parse chunk extension.
  1385.   // The trailer is parsed but no action is taken.
  1386.   VXIinetResult rc = VXIinet_RESULT_SUCCESS;
  1388.   if (_leftToRead == ~0) return 0;
  1390.   int totalRead = 0;
  1392.   for (;;)
  1393.   {
  1394.     if (_leftToRead == 0)
  1395.     {
  1396.       if ((rc = waitStreamReady()) != VXIinet_RESULT_SUCCESS)
  1397.         return ::inetToStream(rc);
  1399.       if ((rc = getChunkSize(_leftToRead)) != VXIinet_RESULT_SUCCESS)
  1400.         return SWIstream::READ_ERROR;
  1402.       if (_leftToRead == 0)
  1403.       {
  1404.         parseHeaders(NULL);
  1405.         _leftToRead = ~0;
  1406.         break;
  1407.       }
  1408.     }
  1410.     if (buflen == 0) break;
  1412.     VXIulong toRead = (buflen > _leftToRead ? _leftToRead : buflen);
  1414.     VXIulong nbRead = 0;
  1415.     while (toRead > 0)
  1416.     {
  1417.       if ((rc = waitStreamReady()) != VXIinet_RESULT_SUCCESS)
  1418.         return ::inetToStream(rc);
  1420.       int count = _channel->readData(_inputStream, &buffer[nbRead], toRead);
  1422.       // Read error.
  1423.       if (count == 0) count = SWIstream::WOULD_BLOCK;
  1424.       if (count < 0) return count;
  1426.       nbRead += count;
  1427.       toRead -= count;
  1428.     }
  1430.     _leftToRead -= nbRead;
  1431.     totalRead += nbRead;
  1432.     buffer += nbRead;
  1433.     buflen -= nbRead;
  1434.   }
  1436.   return totalRead;
  1437. }
  1439. int SBinetHttpStream::readNormal(VXIbyte *buffer, VXIulong buflen)
  1440. {
  1441.   int totalRead = 0;
  1443.   if (_leftToRead == 0) return totalRead;
  1445.   VXIulong toRead = (buflen > _leftToRead) ? _leftToRead : buflen;
  1447.   VXIulong nbRead = 0;
  1448.   while (toRead > 0)
  1449.   {
  1450.     // Check if fetch timeout has expired
  1451.     VXIinetResult rc = waitStreamReady();
  1452.     if (rc != VXIinet_RESULT_SUCCESS)
  1453.       return inetToStream(rc);
  1455.     int count = _channel->readData(_inputStream, &buffer[nbRead], toRead);
  1457.     // This is not an error if we get END OF FILE.
  1458.     if (count == SWIstream::END_OF_FILE)
  1459.     {
  1460.       _closeConnection = TRUE;
  1461.       _leftToRead = 0;
  1462.       break;
  1463.     }
  1465.     // Read error.
  1466.     if (count == 0) count = SWIstream::WOULD_BLOCK;
  1467.     if (count < 0) return count;
  1469.     nbRead += count;
  1470.     toRead -= count;
  1471.   }
  1473.   totalRead += nbRead;
  1474.   _leftToRead -= nbRead;
  1475.   return totalRead;
  1476. }
  1480. VXIinetResult SBinetHttpStream::Read(VXIbyte *buffer,
  1481.                                      VXIulong buflen,
  1482.                                      VXIulong *nread)
  1483. {
  1484.   VXIinetResult rc = VXIinet_RESULT_SUCCESS;
  1486.   int nbRead;
  1488.   if (_chunked)
  1489.     nbRead = readChunked(buffer, buflen);
  1490.   else
  1491.     nbRead = readNormal(buffer, buflen);
  1493.   if (nbRead >= 0)
  1494.   {
  1495.     if (nread != NULL) *nread = nbRead;
  1496.     if (((unsigned int) nbRead) < buflen ||
  1497.         (!_chunked && _leftToRead == 0))
  1498.       rc = VXIinet_RESULT_END_OF_STREAM;
  1499.   }
  1500.   else
  1501.   {
  1502.     _closeConnection = TRUE;
  1504.     switch (nbRead)
  1505.     {
  1506.      case SWIstream::END_OF_FILE:
  1507.        rc = VXIinet_RESULT_END_OF_STREAM;
  1508.        break;
  1509.      case SWIstream::WOULD_BLOCK:
  1510.        rc = VXIinet_RESULT_WOULD_BLOCK;
  1511.        break;
  1512.      case SWIstream::TIMED_OUT:
  1513.        rc = VXIinet_RESULT_FETCH_TIMEOUT;
  1514.        break;
  1515.      default:
  1516.        rc = VXIinet_RESULT_IO_ERROR;
  1517.     }
  1518.   }
  1519.   return rc;
  1520. }
  1523. VXIinetResult
  1524. SBinetHttpStream::MapError(int ht_error, const VXIchar **errorDesc)
  1525. {
  1526.   VXIinetResult rc;
  1528.   switch(ht_error)
  1529.   {
  1530.    case SBinetHttpUtils::HTTP_NO_ACCESS: /* Unauthorized */
  1531.       *errorDesc = L"Unauthorized";
  1532.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1533.    case SBinetHttpUtils::HTTP_FORBIDDEN: /* Access forbidden */
  1534.       *errorDesc = L"Access forbidden";
  1535.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1536.    case SBinetHttpUtils::HTTP_NOT_ACCEPTABLE:/* Not Acceptable */
  1537.       *errorDesc = L"Not Acceptable";
  1538.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1539.    case SBinetHttpUtils::HTTP_NO_PROXY_ACCESS:    /* Proxy Authentication Failed */
  1540.       *errorDesc = L"Proxy Authentication Failed";
  1541.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1542.    case SBinetHttpUtils::HTTP_CONFLICT:    /* Conflict */
  1543.       *errorDesc = L"Conflict";
  1544.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1545.    case SBinetHttpUtils::HTTP_LENGTH_REQUIRED:    /* Length required */
  1546.       *errorDesc = L"Length required";
  1547.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1548.    case SBinetHttpUtils::HTTP_PRECONDITION_FAILED:    /* Precondition failed */
  1549.       *errorDesc = L"Precondition failed";
  1550.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1551.    case SBinetHttpUtils::HTTP_TOO_BIG:    /* Request entity too large */
  1552.       *errorDesc = L"Request entity too large";
  1553.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1554.    case SBinetHttpUtils::HTTP_URI_TOO_BIG:    /* Request-URI too long */
  1555.       *errorDesc = L"Request-URI too long";
  1556.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1557.    case SBinetHttpUtils::HTTP_UNSUPPORTED:    /* Unsupported */
  1558.       *errorDesc = L"Unsupported";
  1559.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1560.    case SBinetHttpUtils::HTTP_BAD_RANGE:    /* Request Range not satisfiable */
  1561.       *errorDesc = L"Request Range not satisfiable";
  1562.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1563.    case SBinetHttpUtils::HTTP_EXPECTATION_FAILED:    /* Expectation Failed */
  1564.       *errorDesc = L"Expectation Failed";
  1565.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1566.    case SBinetHttpUtils::HTTP_REAUTH:    /* Reauthentication required */
  1567.       *errorDesc = L"Reauthentication required";
  1568.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1569.    case SBinetHttpUtils::HTTP_PROXY_REAUTH:    /* Proxy Reauthentication required */
  1570.       *errorDesc = L"Proxy Reauthentication required";
  1571.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1573.    case SBinetHttpUtils::HTTP_SERVER_ERROR: /* Internal server error */
  1574.       *errorDesc = L"Internal server error";
  1575.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1576.    case SBinetHttpUtils::HTTP_NOT_IMPLEMENTED: /* Not implemented (server error) */
  1577.       *errorDesc = L"Not implemented (server error)";
  1578.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1579.    case SBinetHttpUtils::HTTP_BAD_GATEWAY: /* Bad gateway (server error) */
  1580.       *errorDesc = L"Bad gateway (server error)";
  1581.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1582.    case SBinetHttpUtils::HTTP_RETRY: /* Service not available (server error) */
  1583.       *errorDesc = L"Service not available (server error)";
  1584.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1585.    case SBinetHttpUtils::HTTP_GATEWAY_TIMEOUT: /* Gateway timeout (server error) */
  1586.       *errorDesc = L"Gateway timeout (server error)";
  1587.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1588.    case SBinetHttpUtils::HTTP_BAD_VERSION: /* Bad protocol version (server error) */
  1589.       *errorDesc = L"Bad protocol version (server error)";
  1590.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1591.    case SBinetHttpUtils::HTTP_NO_PARTIAL_UPDATE: /* Partial update not implemented (server error) */
  1592.       *errorDesc = L"Partial update not implemented (server error)";
  1593.       rc = VXIinet_RESULT_FETCH_ERROR; break;
  1595.     case SBinetHttpUtils::HTTP_INTERNAL:    /* Weird -- should never happen. */
  1596.       *errorDesc = L"Internal error";
  1597.       rc = VXIinet_RESULT_NON_FATAL_ERROR; break;
  1599.    case  SBinetHttpUtils::HTTP_WOULD_BLOCK:    /* If we are in a select */
  1600.       *errorDesc = L"Would block; not an error";
  1601.       rc = VXIinet_RESULT_WOULD_BLOCK; break;
  1603.    case SBinetHttpUtils::HTTP_INTERRUPTED:    /* Note the negative value! */
  1604.       *errorDesc = L"Interrupted; not an error";
  1605.       rc = VXIinet_RESULT_SUCCESS; break;
  1606.    case SBinetHttpUtils::HTTP_PAUSE:    /* If we want to pause a stream */
  1607.       *errorDesc = L"Stream paused; not an error";
  1608.       rc = VXIinet_RESULT_SUCCESS; break;
  1609.    case SBinetHttpUtils::HTTP_RECOVER_PIPE:    /* Recover pipe line */
  1610.       *errorDesc = L"Recover pipe line; not an error";
  1611.       rc = VXIinet_RESULT_SUCCESS; break;
  1613.    case SBinetHttpUtils::HTTP_TIMEOUT:    /* Connection timeout */
  1614.       *errorDesc = L"Connection timeout";
  1615.       rc = VXIinet_RESULT_FETCH_TIMEOUT; break;
  1617.    case SBinetHttpUtils::HTTP_NOT_FOUND: /* Not found */
  1618.       *errorDesc = L"Not found";
  1619.       rc = VXIinet_RESULT_NOT_FOUND; break;
  1620.    case SBinetHttpUtils::HTTP_METHOD_NOT_ALLOWED: /* Method not allowed */
  1621.       *errorDesc = L"Method not allowed";
  1622.       rc = VXIinet_RESULT_NON_FATAL_ERROR; break;
  1623.    case SBinetHttpUtils::HTTP_NO_HOST:    /* Can't locate host */
  1624.       *errorDesc = L"Can't locate host";
  1625.       rc = VXIinet_RESULT_NOT_FOUND; break;
  1627.     /* These should not be errors */
  1628.     case SBinetHttpUtils::HTTP_MULTIPLE_CHOICES:
  1629.       *errorDesc = L"Multiple choices";
  1630.       rc = VXIinet_RESULT_NOT_FOUND; break;
  1631.     case SBinetHttpUtils::HTTP_PERM_REDIRECT:
  1632.       *errorDesc = L"Permanent redirection";
  1633.       rc = VXIinet_RESULT_NOT_FOUND; break;
  1634.     case SBinetHttpUtils::HTTP_SEE_OTHER:
  1635.       *errorDesc = L"See other";
  1636.       rc = VXIinet_RESULT_NOT_FOUND; break;
  1637.     case SBinetHttpUtils::HTTP_USE_PROXY:
  1638.       *errorDesc = L"Use Proxy";
  1639.       rc = VXIinet_RESULT_NOT_FOUND; break;
  1640.     case SBinetHttpUtils::HTTP_PROXY_REDIRECT:
  1641.       *errorDesc = L"Proxy Redirect";
  1642.       rc = VXIinet_RESULT_NOT_FOUND; break;
  1643.     case SBinetHttpUtils::HTTP_TEMP_REDIRECT:
  1644.       *errorDesc = L"Temporary Redirect";
  1645.       rc = VXIinet_RESULT_NOT_FOUND; break;
  1646.     case SBinetHttpUtils::HTTP_FOUND:
  1647.       *errorDesc = L"Found";
  1648.       rc = VXIinet_RESULT_NON_FATAL_ERROR; break;
  1650.     default: {
  1651.       switch (ht_error / 100) {
  1652.       case 1: // informational, shouldn't fail due to this!
  1653. *errorDesc = L"Unknown informational status";
  1654. break;
  1655.       case 2: // successful, shouldn't fail due to this!
  1656. *errorDesc = L"Unknown success status";
  1657. break;
  1658.       case 3: // redirection
  1659. *errorDesc = L"Unknown redirection error";
  1660. break;
  1661.       case 4: // client error
  1662. *errorDesc = L"Unknown client error";
  1663. break;
  1664.       case 5: // server error
  1665. *errorDesc = L"Unknown server error";
  1666. break;
  1667.       default:
  1668. *errorDesc = L"Unknown HTTP status code";
  1669.       }
  1670.       rc = VXIinet_RESULT_NON_FATAL_ERROR;
  1671.     }
  1672.   }
  1674.   return rc;
  1675. }
  1677. VXIinetResult SBinetHttpStream::Write(const VXIbyte*   pBuffer,
  1678.                                       VXIulong         nBuflen,
  1679.                                       VXIulong*        pnWritten)
  1680. {
  1681.   return VXIinet_RESULT_UNSUPPORTED;
  1682. }
  1684. VXIinetResult SBinetHttpStream::waitStreamReady()
  1685. {
  1686.   int delay = getDelay();
  1688.   if (delay == 0) {
  1689.     SWITimeStamp tstamp;
  1690.     getTimeOut(&tstamp);
  1691.     Diag(MODULE_SBINET_CONNECTION_TAGID, L"SBinetHttpStream::waitStreamReady",
  1692.        L"%s%d", L"TimeOut occured, delay value ",tstamp.getAddedDelay());    
  1693.     Error(236, L"%s%d", L"waitStreamReady delay", delay);        
  1694.     return VXIinet_RESULT_FETCH_TIMEOUT;
  1695.   }
  1696.   
  1697.   switch (_inputStream->waitReady(delay))
  1698.   {
  1699.    case SWIstream::SUCCESS:
  1700.      return VXIinet_RESULT_SUCCESS;
  1701.      //no break: intentional
  1702.    case SWIstream::TIMED_OUT:
  1703.      Diag(MODULE_SBINET_CONNECTION_TAGID, L"SBinetHttpStream::waitStreamReady",
  1704.           L"%s%d", L"TimeOut occured for waitReady, delay value ", delay);     
  1705.      Error(236, L"%s%s", L"inputStream->waitReady", L"timeout");        
  1706.      return VXIinet_RESULT_FETCH_TIMEOUT;
  1707.      //no break: intentional
  1708.    default:
  1709.      Error(240, NULL);
  1710.      return VXIinet_RESULT_FETCH_ERROR;
  1711.   }
  1712. }
  1714. void SBinetHttpStream::writeDebugTimeStamp()
  1715. {
  1716.   // construct debug string
  1717.   char buffer[1400]; // total bytes needed + extra bytes
  1718.   char connId[200];
  1719.   char timeStamp[40];  
  1721.   // fill with NULL terminator chars
  1722.   memset(buffer, 0, 1400 * sizeof(char));   
  1723.   memset(connId, 0, 200 * sizeof(char));
  1724.   memset(timeStamp, 0, 40 * sizeof(char));  
  1725.   
  1726.   // we are sure the buffer is large enough since timeStamp's length is 40
  1727.   // connection id's is 200 and the buffer itself is 1400
  1728.   SBinetUtils::getTimeStampMsecStr(timeStamp);
  1729.   strncpy(connId, _connection->getId(), 200);
  1730.   sprintf(buffer, "%s, conn = %s, URL = ", timeStamp, connId);  
  1731.   // sprintf will automatically put  to output string, we can
  1732.   // safely call strlen() here.  Also, restrict the abs. uri to 1024 bytes
  1733.   strncpy(&buffer[strlen(buffer)], _url->getNAbsolute(), 1024);  
  1734.   // sprintf(buffer, "%s, URL = %s, conn = %s", timeStamp, absUri, connId);
  1735.   // send debug string          
  1736.   _channel->writeDebugString(CRLF "@ ");
  1737.   _channel->writeDebugString(buffer);
  1738.   _channel->writeDebugString(CRLF);
  1739. }