VXIinetResult SBinetChannel::staticWrite(/* [IN]  */ VXIinetInterface*      pThis,                            /* [OUT] */ const VXIbyte*   pBuffer,                            /* [IN]  */ VXIulong         nBuflen,                            /* [OUT] */ VXIulong*        pnWritten,                            /* [IN]  */ VXIinetStream*   pStream      ) {   SBinetChannel* chan = static_cast<SBinetChannel*>(pThis);   if (!chan)   {     return (VXIinet_RESULT_INVALID_ARGUMENT);   }    VXIinetResult rc = VXIinet_RESULT_SUCCESS;   SBinetLogFunc apiTrace(chan->GetLog(),                          chan->GetDiagBase() + MODULE_SBINET_API_TAGID,                          L"SBinetChannel::Write", (int *) &rc,                          L"entering: 0x%p, 0x%p, %lu, 0x%p, 0x%p",                          pThis, pBuffer, nBuflen, pnWritten, pStream);    if (pStream == NULL)   {     chan->Error(200, L"%s%s", L"Operation", L"Write");     return (rc = VXIinet_RESULT_INVALID_ARGUMENT);   }    rc = (pStream->Write)(pBuffer, nBuflen, pnWritten);    if ((rc != VXIinet_RESULT_SUCCESS) &&       (rc != VXIinet_RESULT_WOULD_BLOCK))   {     chan->Error(207,L"%s%d",L"rc",rc);   }    return rc; }  /*  * Call Channel method  */ VXIinetResult SBinetChannel::staticSetCookieJar( /* [IN]  */ VXIinetInterface*      pThis,                                    /* [IN]  */ const VXIVector*       pJar ) {   SBinetChannel* chan = static_cast<SBinetChannel*>(pThis);   if (!chan)   {     return (VXIinet_RESULT_INVALID_ARGUMENT);   }    VXIinetResult rc = VXIinet_RESULT_SUCCESS;   SBinetLogFunc apiTrace (chan->GetLog(), chan->GetDiagBase() + 			  MODULE_SBINET_API_TAGID, 			  L"SBinetChannel::SetCookieJar", (int *) &rc, 			  L"entering: 0x%p, 0x%p", pThis, pJar);    rc = chan->setCookieJar(pJar);   if (rc != VXIinet_RESULT_SUCCESS) {     chan->Error(208,L"%s%d",L"rc",rc);   }   return (rc); }  /*  * Call Channel method  */ VXIinetResult SBinetChannel::staticGetCookieJar( /* [IN]  */ VXIinetInterface*      pThis,                                    /* [OUT] */ VXIVector**            ppJar,                                    /* [OUT] */ VXIbool*               pfChanged   ) {   SBinetChannel* chan = static_cast<SBinetChannel*>(pThis);   if (!chan)   {     return (VXIinet_RESULT_INVALID_ARGUMENT);   }    VXIinetResult rc = VXIinet_RESULT_SUCCESS;   SBinetLogFunc apiTrace (chan->GetLog(), chan->GetDiagBase() + 			  MODULE_SBINET_API_TAGID, 			  L"SBinetChannel::GetCookieJar", (int *) &rc, 			  L"entering: 0x%p, 0x%p, 0x%p", pThis, ppJar, 			  pfChanged);    rc = chan->getCookieJar(ppJar,pfChanged);   if (rc != VXIinet_RESULT_SUCCESS)   {     chan->Error(209, L"%s%d", L"rc", rc);   }   return (rc); }   // Init class at startup VXIinetResult SBinetChannel::init(const VXIMap *configParams, const SWIutilLogger *logger) {   // User agent   const VXIchar *userAgent = SBinetUtils::getString(configParams, SBINET_USER_AGENT_NAME);    if (!userAgent || !*userAgent)   {     // Have to parse the user agent name #ifdef OPENVXI      userAgent = OSBINET_USER_AGENT_NAME_DEFAULT; #else      userAgent = SBINET_USER_AGENT_NAME_DEFAULT; #endif   }   if (!_userAgent)     _userAgent = new SBinetNString(userAgent);   else     _userAgent->operator=(userAgent);    // Proxy rules.   const VXIValue * tmp = VXIMapGetProperty(configParams, SBINET_PROXY_RULES);   if (tmp != NULL && VXIValueGetType(tmp) == VALUE_VECTOR)   {     const VXIVector *proxyRules = (const VXIVector *) tmp;     VXIunsigned n = VXIVectorLength(proxyRules);     for (VXIunsigned i = 0; i < n; i++)     {       tmp = VXIVectorGetElement(proxyRules, i);       if (tmp != NULL && VXIValueGetType(tmp) == VALUE_STRING)       {         SBinetNString rule = VXIStringCStr((const VXIString *) tmp);         SBinetProxyMatcher *p = SBinetProxyMatcher::createMatcher(rule.c_str(), logger);         if (p != NULL)         {           _proxyMatcherList.addLast(p);         }       }     }   }    // Extension rules   if (! _extensionRulesMutex)     VXItrdMutexCreate(&_extensionRulesMutex);    if (VXItrdMutexLock(_extensionRulesMutex) == VXItrd_RESULT_SUCCESS)   {     if (_extensionRules)       VXIMapDestroy(&_extensionRules);      const VXIValue *tmp = VXIMapGetProperty(configParams, SBINET_EXTENSION_RULES);     const VXIMap *extensionRules = NULL;     if (tmp != NULL && VXIValueGetType(tmp) == VALUE_MAP)       extensionRules = (const VXIMap *) tmp;      if (extensionRules)       _extensionRules = VXIMapClone(extensionRules);     else       _extensionRules = NULL;      VXItrdMutexUnlock(_extensionRulesMutex);   }    VXIint32 itmp;    // page load time out.   itmp = SBINET_PAGE_LOADING_TIMEOUT_DEFAULT;   SBinetUtils::getInteger(configParams, SBINET_PAGE_LOADING_TIMEOUT, itmp);   setPageLoadTimeout(itmp);    // freshness fraction   VXIflt32 ftmp = (VXIflt32) SBINET_FRESHNESS_FRACTION_DEFAULT;   SBinetUtils::getFloat(configParams, SBINET_FRESHNESS_FRACTION, ftmp);   setFreshnessFraction(ftmp);    // freshness lifetime   itmp = SBINET_FRESHNESS_LIFETIME_DEFAULT;   SBinetUtils::getInteger(configParams, SBINET_FRESHNESS_LIFETIME, itmp);   setFreshnessLifetime((time_t) itmp);    // max lifetime   itmp = SBINET_MAX_LIFETIME_DEFAULT;   SBinetUtils::getInteger(configParams, SBINET_MAX_LIFETIME, itmp);   setMaxLifetime((time_t) itmp);    // post continue timeout.   itmp = SBINET_POST_CONTINUE_TIMEOUT_DEFAULT;   SBinetUtils::getInteger(configParams, SBINET_POST_CONTINUE_TIMEOUT, itmp);   setPostContinueTimeout(itmp);    const VXIchar* defaultMimeType = SBinetUtils::getString(configParams, SBINET_DEFAULT_MIME_TYPE);   if (!defaultMimeType)     defaultMimeType = L"application/octet-stream";    if (!_defaultMimeType)     _defaultMimeType = new SBinetString(defaultMimeType);   else     _defaultMimeType->operator=(defaultMimeType);    itmp = 1;   SBinetUtils::getInteger(configParams, SBINET_PERSISTENT_CONNECTIONS, itmp);   setUsePersistentConnections(itmp != 0);    if (SBinetSSLsocket::initialize() == 0)     return VXIinet_RESULT_SUCCESS;   else     return VXIinet_RESULT_PLATFORM_ERROR; }   // Shutdown class void SBinetChannel::shutdown() {   delete _userAgent;   _userAgent = NULL;    if (VXItrdMutexLock(_extensionRulesMutex) == VXItrd_RESULT_SUCCESS)   {     if (_extensionRules)       VXIMapDestroy(&_extensionRules);      VXItrdMutexUnlock(_extensionRulesMutex);     VXItrdMutexDestroy(&_extensionRulesMutex);   }    SBinetSSLsocket::shutdown(); }   void SBinetChannel::addExtensionRule(const VXIchar* ext, 				     const VXIchar* mimeType) {   if (! mimeType) return;    if (VXItrdMutexLock(_extensionRulesMutex) == VXItrd_RESULT_SUCCESS) {     if (! _extensionRules)       _extensionRules = VXIMapCreate();      if (_extensionRules)       VXIMapSetProperty(_extensionRules, ext, 			(VXIValue *) VXIStringCreate(mimeType));     VXItrdMutexUnlock(_extensionRulesMutex);   } }   const VXIchar *SBinetChannel::mapExtension(const VXIchar* ext) {   if (ext == NULL) return NULL;    const VXIchar *ret = NULL;   if (VXItrdMutexLock(_extensionRulesMutex) == VXItrd_RESULT_SUCCESS) {     if (_extensionRules)       ret = SBinetUtils::getString(_extensionRules, ext);     VXItrdMutexUnlock(_extensionRulesMutex);   }    return ret; }  const char *SBinetChannel::getUserAgent() {   return _userAgent ? _userAgent->c_str() : ""; }  const VXIchar *SBinetChannel::getDefaultMimeType() {   return _defaultMimeType ? _defaultMimeType->c_str() : L""; }  VXIlogResult SBinetChannel::echoStreamWrite(const void *buffer, size_t buflen) {   VXIlogResult rc = VXIlog_RESULT_SUCCESS;    VXIulong totWritten = 0;   while ((rc == VXIlog_RESULT_SUCCESS) && (totWritten < buflen)) {     VXIulong nWritten = 0;     rc = _pVXILog->ContentWrite(_pVXILog,                                 reinterpret_cast<const VXIbyte *>(buffer) + totWritten,                                 buflen - totWritten, &nWritten, _echoStream);     totWritten += nWritten;   }    return rc; }  // void SBinetChannel::eraseCookie(SBinetChannel::CookieList::iterator &vi) // { // #if defined(__GNUC__) && ((__GNUC__ <= 2) || (__GLIBCPP__ <= 20011023)) || (_decunix_) //   // Old STL has erase return void //   CookieList::iterator vi2 = vi; //   vi2++; //   _cookieList.erase (vi); //   vi = vi2; // #else //   // ISO C++ standard has erase return an iterator to the next //   // item //   vi = _cookieList.erase (vi); // #endif // }  void SBinetChannel::setUsePersistentConnections(bool flag) {   _usePersistentConnections = flag; }  bool SBinetChannel::getUsePersistentConnections() {   return _usePersistentConnections; }  bool SBinetChannel::setPageLoadTimeout(VXIint32 timeout) {   if (timeout <= 0)     return false;    _pageLoadTimeout = timeout;   return true; }   VXIint32 SBinetChannel::getPageLoadTimeout() {   return _pageLoadTimeout; }  bool SBinetChannel::setPostContinueTimeout(VXIint32 timeout) {   if (timeout <= 0)     return false;    _postContinueTimeout = timeout;   return true; }   VXIint32 SBinetChannel::getPostContinueTimeout() {   return _postContinueTimeout; }  time_t SBinetChannel::getFreshnessLifetime() {   return _freshnessLifetime; }  bool SBinetChannel::setFreshnessLifetime(time_t freshnessLifetime) {   if (freshnessLifetime >= (time_t) 0)   {     _freshnessLifetime = freshnessLifetime;     return true;   }   return false; }  double SBinetChannel::getFreshnessFraction() {   return _freshnessFraction; }  bool SBinetChannel::setFreshnessFraction(double freshnessFraction) {   if (freshnessFraction >= 0.0 && freshnessFraction <= 1.0)   {     _freshnessFraction = freshnessFraction;     return true;   }   return false; }  time_t SBinetChannel::getMaxLifetime() {   return _maxLifetime; }  bool SBinetChannel::setMaxLifetime(time_t maxLifetime) {   if (maxLifetime >= (time_t) 0)   {     _maxLifetime = maxLifetime;     return true;   }   return false; }  SBinetProxyMatcher *SBinetChannel::getProxyMatcher(const char *domain,                                                    const char *path) {   SWIList::Iterator iter(_proxyMatcherList);    while (iter.hasNext())   {     SBinetProxyMatcher *p = static_cast<SBinetProxyMatcher *>(iter.next());     if (p->matches(domain, path))     {       return p;     }   }    return NULL; }  SBinetHttpConnection *SBinetChannel::getHttpConnection(const SBinetURL *url,                                                        const VXIMap *properties) {   VXIint32 newConnection = !getUsePersistentConnections();    const char *hostname = url->getNHost();   const char *path = url->getNPath();    int port = url->getPort();    SBinetUtils::getInteger(properties, INET_NEW_CONNECTION, newConnection);    const SBinetProxyMatcher *proxyMatcher = getProxyMatcher(hostname, path);    const char *proxyServer = NULL;   if (proxyMatcher != NULL)     proxyServer = proxyMatcher->getProxyServer();    // Ignore empty proxy server.   if (proxyServer && !*proxyServer)     proxyServer = NULL;    bool usesProxy;   if (proxyServer)   {     hostname = proxyServer;     port = proxyMatcher->getProxyPort();     usesProxy = true;   }   else     usesProxy = false;    SWIipAddress remoteAddress(hostname, port, this);    // FIXME: This code should be protected by a Mutex once we have the cleaning   // thread   SBinetHttpConnection *conn = (SBinetHttpConnection *) _connectionMap.remove(remoteAddress);    if (newConnection && conn)   {     delete conn;     conn = NULL;   }   // FIXME: End of code section that should be protected.    if (!conn)   {     char buf[10];     sprintf(buf, "%d", _connectionCount++);     conn = new SBinetHttpConnection(url->getProtocol(), remoteAddress,                                     usesProxy, this, buf);   }    return conn; }  void SBinetChannel::putHttpConnection(SBinetHttpConnection *connection) {   // Ideally, we should check whether we own the connection.    // FIXME: This code should be protected by a Mutex once we have the cleaning  thread   const SWIipAddress *addr = connection->getRemoteAddress();    SBinetHttpConnection *oldconn = (SBinetHttpConnection *)     _connectionMap.putValue(*addr, connection);   // FIXME: End of code section that should be protected.    delete oldconn; }  void SBinetChannel::closeHttpConnections() {   // Iterate saved connections and dispose of them all   SWIHashMap::Iterator it(_connectionMap);   while (it.hasNext()) {     const SBinetHttpConnection *conn = static_cast<const SBinetHttpConnection*>(it.next()->getValue());     delete conn;   } }