(file) Return to HTTPAcceptor.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/HTTPAcceptor.cpp between version 1.100.4.1 and 1.106.2.7

version 1.100.4.1, 2007/06/25 19:51:13 version 1.106.2.7, 2008/01/30 11:59:01
Line 44 
Line 44 
 #include "Tracer.h" #include "Tracer.h"
 #include <Pegasus/Common/MessageLoader.h> #include <Pegasus/Common/MessageLoader.h>
  
   #ifdef PEGASUS_OS_PASE
   # include <as400_protos.h>
   # include <Pegasus/Common/PaseCcsid.h>
   #endif
   
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
  
 static int MAX_CONNECTION_QUEUE_LENGTH = -1;  static int _maxConnectionQueueLength = -1;
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
Line 126 
Line 131 
      _connectionType(connectionType),      _connectionType(connectionType),
      _portNumber(portNumber),      _portNumber(portNumber),
      _sslcontext(sslcontext),      _sslcontext(sslcontext),
      _sslContextObjectLock(sslContextObjectLock)       _sslContextObjectLock(sslContextObjectLock),
        _idleConnectionTimeoutSeconds(0)
 { {
    Socket::initializeInterface();    Socket::initializeInterface();
  
    /*    /*
         Platforms interpret the value of MAX_CONNECTION_QUEUE_LENGTH          Platforms interpret the value of _maxConnectionQueueLength
         differently.  Some platforms interpret the value literally, while         differently.  Some platforms interpret the value literally, while
         others multiply a fudge factor. When the server is under stress from         others multiply a fudge factor. When the server is under stress from
         multiple clients with multiple requests, toggling this number may         multiple clients with multiple requests, toggling this number may
Line 139 
Line 145 
         value, we allow an environment variable to be set which specifies a         value, we allow an environment variable to be set which specifies a
         number greater than the maximum concurrent client connections         number greater than the maximum concurrent client connections
         possible.  If this environment var is not specified, then         possible.  If this environment var is not specified, then
         MAX_CONNECTION_QUEUE_LENGTH = 15.          _maxConnectionQueueLength = 15.
    */    */
  
 //To engage runtime backlog queue length: uncomment the following block AND //To engage runtime backlog queue length: uncomment the following block AND
 //comment out the line MAX_CONNECTION_QUEUE_LENGTH = 15  //comment out the line _maxConnectionQueueLength = 15
  
 /* /*
     if (MAX_CONNECTION_QUEUE_LENGTH == -1)      if (_maxConnectionQueueLength == -1)
     {     {
         const char* env = getenv("PEGASUS_MAX_BACKLOG_CONNECTION_QUEUE");         const char* env = getenv("PEGASUS_MAX_BACKLOG_CONNECTION_QUEUE");
         if (!env)         if (!env)
         {         {
             MAX_CONNECTION_QUEUE_LENGTH = 15;              _maxConnectionQueueLength = 15;
         }         }
         else         else
         {         {
             char* end = NULL;             char* end = NULL;
             MAX_CONNECTION_QUEUE_LENGTH = strtol(env, &end, 10);              _maxConnectionQueueLength = strtol(env, &end, 10);
             if (*end)             if (*end)
                 MAX_CONNECTION_QUEUE_LENGTH = 15;                  _maxConnectionQueueLength = 15;
             cout << " MAX_CONNECTION_QUEUE_LENGTH = " <<              cout << " _maxConnectionQueueLength = " <<
                 MAX_CONNECTION_QUEUE_LENGTH << endl;                  _maxConnectionQueueLength << endl;
         }         }
     }     }
 */ */
     MAX_CONNECTION_QUEUE_LENGTH = 15;  #ifdef PEGASUS_WMIMAPPER
       //The WMI Mapper can be used as a proxy to multiple WMI Servers.
       //If a client application simultaneously initiates connections
       //to many Windows systems, many of these connections may be routed
       //to a single WMI Mapper. A larger _maxConnectionQueueLength
       //value is required to allow these connections to be initiated
       //successfully.
       _maxConnectionQueueLength = 40;
   #else
       _maxConnectionQueueLength = 15;
   #endif
 } }
  
 HTTPAcceptor::~HTTPAcceptor() HTTPAcceptor::~HTTPAcceptor()
Line 279 
Line 295 
 */ */
 void HTTPAcceptor::_bind() void HTTPAcceptor::_bind()
 { {
   #ifdef PEGASUS_OS_PASE
       // bind need ccsid is 819
       int orig_ccsid;
       orig_ccsid = _SETCCSID(-1);
       if (orig_ccsid == -1)
       {
           PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
               String("HTTPAcceptor::_bind: Can not get current PASE CCSID."));
           orig_ccsid = 1208;
       }
       PaseCcsid ccsid(819, orig_ccsid);
   #endif
   
     PEGASUS_ASSERT(_rep != 0);     PEGASUS_ASSERT(_rep != 0);
     // Create address:     // Create address:
     memset(_rep->address, 0, _rep->address_size);     memset(_rep->address, 0, _rep->address_size);
Line 364 
Line 393 
         throw BindFailedException(parms);         throw BindFailedException(parms);
     }     }
  
       Socket::disableBlocking(_rep->socket);
  
 // set the close-on-exec bit for this file handle. // set the close-on-exec bit for this file handle.
 // any unix that forks needs this bit set. // any unix that forks needs this bit set.
Line 467 
Line 497 
  
     // Set up listening on the given socket:     // Set up listening on the given socket:
  
     //int const MAX_CONNECTION_QUEUE_LENGTH = 15;      //int const _maxConnectionQueueLength = 15;
  
     if (listen(_rep->socket, MAX_CONNECTION_QUEUE_LENGTH) < 0)      if (listen(_rep->socket, _maxConnectionQueueLength) < 0)
     {     {
         Socket::close(_rep->socket);         Socket::close(_rep->socket);
         delete _rep;         delete _rep;
Line 597 
Line 627 
     if (_rep)     if (_rep)
     {     {
         AutoMutex autoMut(_rep->_connection_mut);         AutoMutex autoMut(_rep->_connection_mut);
         if (_rep->connections.size() > 0)          for (Uint32 i = 0, n = _rep->connections.size(); i < n; i++)
         {         {
             HTTPConnection* connection = _rep->connections[0];              HTTPConnection* connection = _rep->connections[i];
             count = connection->getRequestCount();              if (connection->isResponsePending())
               {
                   count++;
               }
         }         }
     }     }
     return count;     return count;
Line 620 
Line 653 
     _socketWriteTimeout = socketWriteTimeout;     _socketWriteTimeout = socketWriteTimeout;
 } }
  
   void HTTPAcceptor::setIdleConnectionTimeout(Uint32 idleConnectionTimeoutSeconds)
   {
       _idleConnectionTimeoutSeconds = idleConnectionTimeoutSeconds;
   }
   
 void HTTPAcceptor::unbind() void HTTPAcceptor::unbind()
 { {
     if (_rep)     if (_rep)
Line 708 
Line 746 
 #endif #endif
     }     }
  
     SocketHandle socket;      // It is not necessary to handle EINTR errors from this accept() call.
 #ifdef PEGASUS_OS_TYPE_WINDOWS      // An EINTR error should not occur on a non-blocking socket.  If the
     socket = accept(_rep->socket, accept_address, &address_size);      // listen socket is blocking and EINTR occurs, the new socket connection
 #else      // is not accepted here.
     while (  
         ((socket = accept(_rep->socket, accept_address, &address_size)) == -1)      // EAGAIN errors are also not handled here.  An EAGAIN error should not
         && (errno == EINTR))      // occur after select() indicates that the listen socket is available for
         ;      // reading.  If the accept() fails with an EAGAIN error code, a new
 #endif      // connection is not accepted here.
   
       SocketHandle socket = accept(_rep->socket, accept_address, &address_size);
  
     if (socket == PEGASUS_SOCKET_ERROR)     if (socket == PEGASUS_SOCKET_ERROR)
     {     {
Line 741 
Line 781 
             "HTTPAcceptor: accept() failed");             "HTTPAcceptor: accept() failed");
         return;         return;
     }     }
   #ifndef PEGASUS_OS_TYPE_WINDOWS
       // We need to ensure that the socket number is not higher than
       // what fits into FD_SETSIZE, because we else won't be able to select on it
       // and won't ever communicate correct on that socket.
       if (socket >= FD_SETSIZE)
       {
           // the remote connection is invalid, destroy client address.
           delete accept_address;
   
           Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
               "HTTPAcceptor out of available sockets. "
                   "Closing connection to the new client.");
   
           PEG_TRACE(
               (TRC_DISCARDED_DATA,
                Tracer::LEVEL2,
                "accept() returned too large socket number %d.",
                socket));
   
           // close the connection
           Socket::close(socket);
           return;
       }
   #endif
  
     String ipAddress;     String ipAddress;
  
Line 753 
Line 817 
 #ifdef PEGASUS_ENABLE_IPV6 #ifdef PEGASUS_ENABLE_IPV6
         char ipBuffer[PEGASUS_INET6_ADDRSTR_LEN];         char ipBuffer[PEGASUS_INET6_ADDRSTR_LEN];
         int rc;         int rc;
         while ((rc = getnameinfo(accept_address, address_size, ipBuffer,          if ((rc = System::getNameInfo(accept_address,
             PEGASUS_INET6_ADDRSTR_LEN, 0, 0, NI_NUMERICHOST)) == EAI_AGAIN)                  address_size,
             ;                  ipBuffer,
         if (rc)                  PEGASUS_INET6_ADDRSTR_LEN,
                   0,
                   0,
                   NI_NUMERICHOST)))
         {         {
             Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,             Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
                 "HTTPAcceptor - getnameinfo() failure.  rc: $0", rc);                 "HTTPAcceptor - getnameinfo() failure.  rc: $0", rc);
Line 806 
Line 873 
     SharedPtr<MP_Socket> mp_socket(new MP_Socket(     SharedPtr<MP_Socket> mp_socket(new MP_Socket(
         socket, _sslcontext, _sslContextObjectLock, ipAddress));         socket, _sslcontext, _sslContextObjectLock, ipAddress));
  
       mp_socket->disableBlocking();
     mp_socket->setSocketWriteTimeout(_socketWriteTimeout);     mp_socket->setSocketWriteTimeout(_socketWriteTimeout);
  
     // Perform the SSL handshake, if applicable.  Make the socket non-blocking      // Perform the SSL handshake, if applicable.
     // for this operation so we can send it back to the Monitor's select() loop  
     // if it takes a while.  
  
     mp_socket->disableBlocking();  
     Sint32 socketAcceptStatus = mp_socket->accept();     Sint32 socketAcceptStatus = mp_socket->accept();
     mp_socket->enableBlocking();  
  
     if (socketAcceptStatus < 0)     if (socketAcceptStatus < 0)
     {     {
Line 829 
Line 893 
     HTTPConnection* connection = new HTTPConnection(_monitor, mp_socket,     HTTPConnection* connection = new HTTPConnection(_monitor, mp_socket,
         ipAddress, this, static_cast<MessageQueue *>(_outputMessageQueue));         ipAddress, this, static_cast<MessageQueue *>(_outputMessageQueue));
  
       if (_idleConnectionTimeoutSeconds)
       {
           connection->_idleConnectionTimeoutSeconds =
               _idleConnectionTimeoutSeconds;
           Time::gettimeofday(&connection->_idleStartTime);
       }
   
     if (socketAcceptStatus == 0)     if (socketAcceptStatus == 0)
     {     {
         PEG_TRACE_CSTRING(TRC_HTTP, Tracer::LEVEL2,         PEG_TRACE_CSTRING(TRC_HTTP, Tracer::LEVEL2,
             "HTTPAcceptor: SSL_accept() pending");             "HTTPAcceptor: SSL_accept() pending");
         connection->_acceptPending = true;         connection->_acceptPending = true;
           Time::gettimeofday(&connection->_acceptPendingStartTime);
     }     }
  
     // Solicit events on this new connection's socket:     // Solicit events on this new connection's socket:

Legend:
Removed from v.1.100.4.1  
changed lines
  Added in v.1.106.2.7
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2