(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.116 and 1.134

version 1.116, 2008/02/26 19:15:05 version 1.134, 2012/09/05 11:10:33
Line 1 
Line 1 
 //%2006////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development  // Licensed to The Open Group (TOG) under one or more contributor license
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.  // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;  // this work for additional information regarding copyright ownership.
 // IBM Corp.; EMC Corporation, The Open Group.  // Each contributor licenses this file to you under the OpenPegasus Open
 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;  // Source License; you may not use this file except in compliance with the
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.  // License.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;  //
 // EMC Corporation; VERITAS Software Corporation; The Open Group.  // Permission is hereby granted, free of charge, to any person obtaining a
 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;  // copy of this software and associated documentation files (the "Software"),
 // EMC Corporation; Symantec Corporation; The Open Group.  // to deal in the Software without restriction, including without limitation
 //  // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // Permission is hereby granted, free of charge, to any person obtaining a copy  // and/or sell copies of the Software, and to permit persons to whom the
 // of this software and associated documentation files (the "Software"), to  // Software is furnished to do so, subject to the following conditions:
 // deal in the Software without restriction, including without limitation the  //
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  // The above copyright notice and this permission notice shall be included
 // sell copies of the Software, and to permit persons to whom the Software is  // in all copies or substantial portions of the Software.
 // furnished to do so, subject to the following conditions:  //
 //  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT  // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR  // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT  // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN  // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION  
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  
 // //
 //==============================================================================  //////////////////////////////////////////////////////////////////////////
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 56 
Line 54 
  
 static int _maxConnectionQueueLength = -1; static int _maxConnectionQueueLength = -1;
  
   Uint32 HTTPAcceptor::_socketWriteTimeout =
       PEGASUS_DEFAULT_SOCKETWRITE_TIMEOUT_SECONDS;
   
   #ifndef PEGASUS_INTEGERS_BOUNDARY_ALIGNED
   Mutex HTTPAcceptor::_socketWriteTimeoutMutex;
   #endif
   
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
 // HTTPAcceptorRep // HTTPAcceptorRep
Line 129 
Line 134 
                            Uint16 connectionType,                            Uint16 connectionType,
                            Uint32 portNumber,                            Uint32 portNumber,
                            SSLContext * sslcontext,                            SSLContext * sslcontext,
                            ReadWriteSem* sslContextObjectLock)                             ReadWriteSem* sslContextObjectLock,
                              HostAddress *listenOn)
    : Base(PEGASUS_QUEUENAME_HTTPACCEPTOR),  // ATTN: Need unique names?    : Base(PEGASUS_QUEUENAME_HTTPACCEPTOR),  // ATTN: Need unique names?
      _monitor(monitor),      _monitor(monitor),
      _outputMessageQueue(outputMessageQueue),      _outputMessageQueue(outputMessageQueue),
Line 139 
Line 145 
      _portNumber(portNumber),      _portNumber(portNumber),
      _sslcontext(sslcontext),      _sslcontext(sslcontext),
      _sslContextObjectLock(sslContextObjectLock),      _sslContextObjectLock(sslContextObjectLock),
      _idleConnectionTimeoutSeconds(0)      _listenAddress(listenOn)
 { {
      PEGASUS_ASSERT(!_sslcontext == !_sslContextObjectLock);
    Socket::initializeInterface();    Socket::initializeInterface();
  
    /*    /*
Line 211 
Line 218 
             SocketMessage* socketMessage = (SocketMessage*)message;             SocketMessage* socketMessage = (SocketMessage*)message;
  
             // If this is a connection request:             // If this is a connection request:
               PEGASUS_ASSERT(socketMessage->socket == _rep->socket);
   
               PEGASUS_ASSERT(socketMessage->events & SocketMessage::READ);
  
             if (socketMessage->socket == _rep->socket &&  
                 socketMessage->events & SocketMessage::READ)  
             {  
                 _acceptConnection();                 _acceptConnection();
             }  
             else  
             {  
                 // ATTN! this can't happen!  
                 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,  
                     "HTTPAcceptor::handleEnqueue: Invalid SOCKET_MESSAGE "  
                         "received.");  
            }  
  
            break;            break;
        }        }
Line 253 
Line 252 
        }        }
  
        default:        default:
            // ATTN: need unexpected message error!             PEGASUS_ASSERT(false);
            PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,  
                "HTTPAcceptor::handleEnqueue: Invalid MESSAGE received.");  
            break;            break;
     }     }
  
Line 266 
Line 263 
 void HTTPAcceptor::handleEnqueue() void HTTPAcceptor::handleEnqueue()
 { {
     Message* message = dequeue();     Message* message = dequeue();
   
     if (!message)  
     {  
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,  
             "HTTPAcceptor::handleEnqueue(): No message on queue.");  
         return;  
     }  
   
     handleEnqueue(message);     handleEnqueue(message);
 } }
  
Line 283 
Line 272 
     {     {
         MessageLoaderParms parms("Common.HTTPAcceptor.ALREADY_BOUND",         MessageLoaderParms parms("Common.HTTPAcceptor.ALREADY_BOUND",
             "HTTPAcceptor already bound");             "HTTPAcceptor already bound");
   
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,  
             "HTTPAcceptor::bind: HTTPAcceptor already bound.");  
         throw BindFailedException(parms);         throw BindFailedException(parms);
     }     }
  
Line 295 
Line 281 
     _bind();     _bind();
 } }
  
   
 /** /**
     _bind - creates a new server socket and bind socket to the port address.     _bind - creates a new server socket and bind socket to the port address.
     If PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET is not defined, the port number is     If PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET is not defined, the port number is
Line 303 
Line 290 
 void HTTPAcceptor::_bind() void HTTPAcceptor::_bind()
 { {
 #ifdef PEGASUS_OS_PASE #ifdef PEGASUS_OS_PASE
     // bind need ccsid is 819      AutoPtr<PaseCcsid> ccsid;
     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 #endif
  
     PEGASUS_ASSERT(_rep != 0);     PEGASUS_ASSERT(_rep != 0);
Line 327 
Line 305 
         // user.  Otherwise, the bind may fail with a vague "bind failed"         // user.  Otherwise, the bind may fail with a vague "bind failed"
         // error.         // error.
         //         //
   #ifdef PEGASUS_OS_PASE
           // PASE domain socket needs ccsid 819
           int orig_ccsid;
           orig_ccsid = _SETCCSID(-1);
           if (orig_ccsid == -1)
           {
               PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                       "HTTPAcceptor::_bind: Can not get current PASE CCSID.");
               orig_ccsid = 1208;
           }
           ccsid.reset(new PaseCcsid(819, orig_ccsid));
   #endif
         if (System::exists(PEGASUS_LOCAL_DOMAIN_SOCKET_PATH))         if (System::exists(PEGASUS_LOCAL_DOMAIN_SOCKET_PATH))
         {         {
             if (!System::removeFile(PEGASUS_LOCAL_DOMAIN_SOCKET_PATH))             if (!System::removeFile(PEGASUS_LOCAL_DOMAIN_SOCKET_PATH))
Line 346 
Line 336 
 #ifdef PEGASUS_ENABLE_IPV6 #ifdef PEGASUS_ENABLE_IPV6
     else if (_connectionType == IPV6_CONNECTION)     else if (_connectionType == IPV6_CONNECTION)
     {     {
           if(_listenAddress)
           {
               String hostAdd = _listenAddress->getHost();
               CString ip = hostAdd.getCString();
   
               struct sockaddr_in6 in6addr;
               memset(&in6addr, 0, sizeof(sockaddr_in6));
               if(_listenAddress ->isHostAddLinkLocal())
               {
                   HostAddress::convertTextToBinary(AF_INET6,
                   (const char*)ip,
                   &in6addr.sin6_addr);
                   reinterpret_cast<struct sockaddr_in6*>(
                       _rep->address)->sin6_addr = in6addr.sin6_addr;
                   reinterpret_cast<struct sockaddr_in6*>(
                       _rep->address)->sin6_scope_id =
                           _listenAddress->getScopeID();
               }
               else
               {
                   HostAddress::convertTextToBinary(AF_INET6,
                   (const char*)ip,
                   &in6addr.sin6_addr);
                   reinterpret_cast<struct sockaddr_in6*>(
                       _rep->address)->sin6_addr = in6addr.sin6_addr;
               }
           }
           else
           {
         reinterpret_cast<struct sockaddr_in6*>(_rep->address)->sin6_addr =         reinterpret_cast<struct sockaddr_in6*>(_rep->address)->sin6_addr =
             in6addr_any;             in6addr_any;
           }
         reinterpret_cast<struct sockaddr_in6*>(_rep->address)->sin6_family =         reinterpret_cast<struct sockaddr_in6*>(_rep->address)->sin6_family =
             AF_INET6;             AF_INET6;
         reinterpret_cast<struct sockaddr_in6*>(_rep->address)->sin6_port =         reinterpret_cast<struct sockaddr_in6*>(_rep->address)->sin6_port =
Line 356 
Line 376 
 #endif #endif
     else if(_connectionType == IPV4_CONNECTION)     else if(_connectionType == IPV4_CONNECTION)
     {     {
         reinterpret_cast<struct sockaddr_in*>(_rep->address)->sin_addr.s_addr =          if(_listenAddress)
             INADDR_ANY;          {
               String hostAdd = _listenAddress->getHost();
               CString ip = hostAdd.getCString();
               struct sockaddr_in addrs;
               HostAddress::convertTextToBinary(
                   AF_INET,
                   (const char*)ip,
                   &addrs.sin_addr);
               reinterpret_cast<struct sockaddr_in*>(
                   _rep->address)->sin_addr.s_addr = addrs.sin_addr.s_addr;
           }
           else
           {
               reinterpret_cast<struct sockaddr_in*>(
               _rep->address)->sin_addr.s_addr = INADDR_ANY;
           }
         reinterpret_cast<struct sockaddr_in*>(_rep->address)->sin_family =         reinterpret_cast<struct sockaddr_in*>(_rep->address)->sin_family =
             AF_INET;             AF_INET;
         reinterpret_cast<struct sockaddr_in*>(_rep->address)->sin_port =         reinterpret_cast<struct sockaddr_in*>(_rep->address)->sin_port =
Line 395 
Line 430 
         _rep = 0;         _rep = 0;
         MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_CREATE_SOCKET",         MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_CREATE_SOCKET",
             "Failed to create socket");             "Failed to create socket");
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,  
             "HTTPAcceptor::_bind:  createSocket() _rep->socket failed");  
         throw BindFailedException(parms);         throw BindFailedException(parms);
     }     }
  
Line 408 
Line 441 
     int sock_flags;     int sock_flags;
     if ((sock_flags = fcntl(_rep->socket, F_GETFD, 0)) < 0)     if ((sock_flags = fcntl(_rep->socket, F_GETFD, 0)) < 0)
     {     {
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,          PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
             "HTTPAcceptor::_bind: fcntl(F_GETFD) failed");             "HTTPAcceptor::_bind: fcntl(F_GETFD) failed");
     }     }
     else     else
Line 416 
Line 449 
         sock_flags |= FD_CLOEXEC;         sock_flags |= FD_CLOEXEC;
         if (fcntl(_rep->socket, F_SETFD, sock_flags) < 0)         if (fcntl(_rep->socket, F_SETFD, sock_flags) < 0)
         {         {
             PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,              PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                 "HTTPAcceptor::_bind: fcntl(F_SETFD) failed");                 "HTTPAcceptor::_bind: fcntl(F_SETFD) failed");
         }         }
     }     }
Line 437 
Line 470 
         _rep = 0;         _rep = 0;
         MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_SET_SOCKET_OPTION",         MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_SET_SOCKET_OPTION",
             "Failed to set socket option");             "Failed to set socket option");
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,  
             "HTTPAcceptor::_bind: Failed to set socket option.");  
         throw BindFailedException(parms);         throw BindFailedException(parms);
     }     }
  
Line 455 
Line 486 
  
         delete _rep;         delete _rep;
         _rep = 0;         _rep = 0;
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,  
             "HTTPAcceptor::_bind: Failed to bind socket.");  
         throw BindFailedException(parms);         throw BindFailedException(parms);
     }     }
  
Line 482 
Line 511 
     //     //
 #if !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET) && \ #if !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET) && \
      (defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || \      (defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || \
       defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM))        defined(PEGASUS_OS_ZOS) || \
         defined(PEGASUS_OS_PASE))
     if (_connectionType == LOCAL_CONNECTION)     if (_connectionType == LOCAL_CONNECTION)
     {     {
         if (::chmod(PEGASUS_LOCAL_DOMAIN_SOCKET_PATH,         if (::chmod(PEGASUS_LOCAL_DOMAIN_SOCKET_PATH,
Line 492 
Line 522 
         {         {
             MessageLoaderParms parms(             MessageLoaderParms parms(
                 "Common.HTTPAcceptor.FAILED_SET_LDS_FILE_OPTION",                 "Common.HTTPAcceptor.FAILED_SET_LDS_FILE_OPTION",
                 "Failed to set permission on local domain socket {0}: {1}.",                  "Failed to set permission on local domain socket $0: $1.",
                 PEGASUS_LOCAL_DOMAIN_SOCKET_PATH,                 PEGASUS_LOCAL_DOMAIN_SOCKET_PATH,
                 PEGASUS_SYSTEM_ERRORMSG_NLS );                 PEGASUS_SYSTEM_ERRORMSG_NLS );
  
             delete _rep;             delete _rep;
             _rep = 0;             _rep = 0;
             PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,  
                 "HTTPAcceptor::_bind: Failed to set domain socket "  
                     "permissions.");  
             throw BindFailedException(parms);             throw BindFailedException(parms);
         }         }
     }     }
Line 514 
Line 541 
     {     {
         MessageLoaderParms parms(         MessageLoaderParms parms(
             "Common.HTTPAcceptor.FAILED_LISTEN_SOCKET",             "Common.HTTPAcceptor.FAILED_LISTEN_SOCKET",
             "Failed to listen on socket {0}: {1}.",              "Failed to listen on socket $0: $1.",
             (int)_rep->socket,PEGASUS_SYSTEM_NETWORK_ERRORMSG_NLS );             (int)_rep->socket,PEGASUS_SYSTEM_NETWORK_ERRORMSG_NLS );
  
         delete _rep;         delete _rep;
         _rep = 0;         _rep = 0;
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,  
             "HTTPAcceptor::_bind: Failed to bind socket(1).");  
         throw BindFailedException(parms);         throw BindFailedException(parms);
     }     }
  
Line 537 
Line 562 
         MessageLoaderParms parms(         MessageLoaderParms parms(
             "Common.HTTPAcceptor.FAILED_SOLICIT_SOCKET_MESSAGES",             "Common.HTTPAcceptor.FAILED_SOLICIT_SOCKET_MESSAGES",
             "Failed to solicit socket messaeges");             "Failed to solicit socket messaeges");
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,  
             "HTTPAcceptor::_bind: Failed to solicit socket messages(2).");  
         throw BindFailedException(parms);         throw BindFailedException(parms);
     }     }
 } }
Line 562 
Line 585 
         if (_connectionType == LOCAL_CONNECTION)         if (_connectionType == LOCAL_CONNECTION)
         {         {
 #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
             PEG_TRACE_CSTRING(TRC_HTTP, Tracer::LEVEL2,              PEG_TRACE_CSTRING(TRC_HTTP, Tracer::LEVEL3,
                 "HTTPAcceptor::closeConnectionSocket Unlinking local "                 "HTTPAcceptor::closeConnectionSocket Unlinking local "
                     "connection.");                     "connection.");
             ::unlink(             ::unlink(
                 reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path);                      reinterpret_cast<struct sockaddr_un*>
                           (_rep->address)->sun_path);
 #else #else
             PEGASUS_ASSERT(false);             PEGASUS_ASSERT(false);
 #endif #endif
Line 574 
Line 598 
     }     }
     else     else
     {     {
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,          PEG_TRACE_CSTRING(TRC_HTTP, Tracer::LEVEL2,
             "HTTPAcceptor::closeConnectionSocket failure _rep is null.");             "HTTPAcceptor::closeConnectionSocket failure _rep is null.");
     }     }
 } }
Line 590 
Line 614 
     }     }
     else     else
     {     {
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,          PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
             "HTTPAcceptor::reopenConnectionSocket failure _rep is null.");             "HTTPAcceptor::reopenConnectionSocket failure _rep is null.");
     }     }
 } }
Line 611 
Line 635 
         if (_connectionType == LOCAL_CONNECTION)         if (_connectionType == LOCAL_CONNECTION)
         {         {
 #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
             PEG_TRACE_CSTRING(TRC_HTTP, Tracer::LEVEL2,              PEG_TRACE_CSTRING(TRC_HTTP, Tracer::LEVEL3,
                 "HTTPAcceptor::reconnectConnectionSocket Unlinking local "                 "HTTPAcceptor::reconnectConnectionSocket Unlinking local "
                     "connection." );                     "connection." );
             ::unlink(             ::unlink(
                 reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path);                      reinterpret_cast<struct sockaddr_un*>(
                           _rep->address)->sun_path);
 #else #else
             PEGASUS_ASSERT(false);             PEGASUS_ASSERT(false);
 #endif #endif
Line 625 
Line 650 
     }     }
     else     else
     {     {
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,          PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
             "HTTPAcceptor::reconnectConnectionSocket failure _rep is null.");             "HTTPAcceptor::reconnectConnectionSocket failure _rep is null.");
     }     }
 } }
Line 662 
Line 687 
  
 void HTTPAcceptor::setSocketWriteTimeout(Uint32 socketWriteTimeout) void HTTPAcceptor::setSocketWriteTimeout(Uint32 socketWriteTimeout)
 { {
   #ifndef PEGASUS_INTEGERS_BOUNDARY_ALIGNED
       AutoMutex lock(_socketWriteTimeoutMutex);
   #endif
     _socketWriteTimeout = socketWriteTimeout;     _socketWriteTimeout = socketWriteTimeout;
 } }
  
 void HTTPAcceptor::setIdleConnectionTimeout(Uint32 idleConnectionTimeoutSeconds)  
 {  
     _idleConnectionTimeoutSeconds = idleConnectionTimeoutSeconds;  
 }  
   
 void HTTPAcceptor::unbind() void HTTPAcceptor::unbind()
 { {
     if (_rep)     if (_rep)
Line 681 
Line 704 
         {         {
 #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
             ::unlink(             ::unlink(
                 reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path);                      reinterpret_cast<struct sockaddr_un*>
                       (_rep->address)->sun_path);
 #else #else
             PEGASUS_ASSERT(false);             PEGASUS_ASSERT(false);
 #endif #endif
Line 692 
Line 716 
     }     }
     else     else
     {     {
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,          PEG_TRACE_CSTRING(TRC_HTTP, Tracer::LEVEL1,
             "HTTPAcceptor::unbind failure _rep is null." );             "HTTPAcceptor::unbind failure _rep is null." );
     }     }
 } }
Line 778 
Line 802 
         // TCPIP is down reconnect this acceptor         // TCPIP is down reconnect this acceptor
         if (getSocketError() == PEGASUS_NETWORK_TCPIP_STOPPED)         if (getSocketError() == PEGASUS_NETWORK_TCPIP_STOPPED)
         {         {
             PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,              PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                 "Socket has an IO error. TCP/IP down. Try to reconnect.");                 "Socket has an IO error. TCP/IP down. Try to reconnect.");
  
             reconnectConnectionSocket();             reconnectConnectionSocket();
  
             return;             return;
         }         }
           PEG_TRACE((
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,              TRC_DISCARDED_DATA,
             "HTTPAcceptor - accept() failure.  errno: $0", errno);              Tracer::LEVEL1,
               "HTTPAcceptor: accept() failed.  errno: %u",
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,              errno));
             "HTTPAcceptor: accept() failed");  
         return;         return;
     }     }
  
Line 806 
Line 829 
         // the remote connection is invalid, destroy client address.         // the remote connection is invalid, destroy client address.
         delete accept_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(         PEG_TRACE(
             (TRC_DISCARDED_DATA,             (TRC_DISCARDED_DATA,
              Tracer::LEVEL2,               Tracer::LEVEL1,
              "accept() returned too large socket number %d.",               "HTTPAcceptor out of available sockets."
                    "accept() returned too large socket number %u."
                    "Closing connection to the new client.",
              socket));              socket));
  
         return;         return;
Line 830 
Line 851 
     {     {
 #ifdef PEGASUS_ENABLE_IPV6 #ifdef PEGASUS_ENABLE_IPV6
         char ipBuffer[PEGASUS_INET6_ADDRSTR_LEN];         char ipBuffer[PEGASUS_INET6_ADDRSTR_LEN];
         int rc;          if (System::getNameInfo(accept_address,
         if ((rc = System::getNameInfo(accept_address,  
                 address_size,                 address_size,
                 ipBuffer,                 ipBuffer,
                 PEGASUS_INET6_ADDRSTR_LEN,                 PEGASUS_INET6_ADDRSTR_LEN,
                 0,                 0,
                 0,                 0,
                 NI_NUMERICHOST)))                  NI_NUMERICHOST))
         {         {
             Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,  
                 "HTTPAcceptor - getnameinfo() failure.  rc: $0", rc);  
   
             PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,  
                 "HTTPAcceptor: getnameinfo() failed");  
             delete accept_address;             delete accept_address;
             return;             return;
         }         }
Line 865 
Line 880 
     int sock_flags;     int sock_flags;
     if ((sock_flags = fcntl(socket, F_GETFD, 0)) < 0)     if ((sock_flags = fcntl(socket, F_GETFD, 0)) < 0)
     {     {
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,          PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
             "HTTPAcceptor: fcntl(F_GETFD) failed");             "HTTPAcceptor: fcntl(F_GETFD) failed");
     }     }
     else     else
Line 873 
Line 888 
         sock_flags |= FD_CLOEXEC;         sock_flags |= FD_CLOEXEC;
         if (fcntl(socket, F_SETFD, sock_flags) < 0)         if (fcntl(socket, F_SETFD, sock_flags) < 0)
         {         {
             PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,              PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                 "HTTPAcceptor: fcntl(F_SETFD) failed");                 "HTTPAcceptor: fcntl(F_SETFD) failed");
         }         }
     }     }
 #endif #endif
  
  
     PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER, 0,      PEG_TRACE((
         "HTTPAcceptor - accept() success.  Socket: $1" ,socket));          TRC_HTTP,
           Tracer::LEVEL3,
           "HTTPAcceptor - accept() success.  Socket: %u",
           socket));
  
     SharedPtr<MP_Socket> mp_socket(new MP_Socket(     SharedPtr<MP_Socket> mp_socket(new MP_Socket(
         socket, _sslcontext, _sslContextObjectLock, ipAddress));         socket, _sslcontext, _sslContextObjectLock, ipAddress));
Line 889 
Line 907 
     socketPtr.release();     socketPtr.release();
  
     mp_socket->disableBlocking();     mp_socket->disableBlocking();
   
       {
   #ifndef PEGASUS_INTEGERS_BOUNDARY_ALIGNED
           AutoMutex lock(_socketWriteTimeoutMutex);
   #endif
     mp_socket->setSocketWriteTimeout(_socketWriteTimeout);     mp_socket->setSocketWriteTimeout(_socketWriteTimeout);
       }
  
     // Perform the SSL handshake, if applicable.     // Perform the SSL handshake, if applicable.
  
Line 897 
Line 921 
  
     if (socketAcceptStatus < 0)     if (socketAcceptStatus < 0)
     {     {
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,          PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
             "HTTPAcceptor: SSL_accept() failed");             "HTTPAcceptor: SSL_accept() failed");
         return;         return;
     }     }
Line 909 
Line 933 
         mp_socket,         mp_socket,
         ipAddress,         ipAddress,
         this,         this,
         static_cast<MessageQueue *>(_outputMessageQueue)));          _outputMessageQueue));
  
     if (_idleConnectionTimeoutSeconds)      if (HTTPConnection::getIdleConnectionTimeout())
     {     {
         connection->_idleConnectionTimeoutSeconds =  
             _idleConnectionTimeoutSeconds;  
         Time::gettimeofday(&connection->_idleStartTime);         Time::gettimeofday(&connection->_idleStartTime);
     }     }
  
     if (socketAcceptStatus == 0)     if (socketAcceptStatus == 0)
     {     {
         PEG_TRACE_CSTRING(TRC_HTTP, Tracer::LEVEL2,          PEG_TRACE_CSTRING(TRC_HTTP, Tracer::LEVEL1,
             "HTTPAcceptor: SSL_accept() pending");             "HTTPAcceptor: SSL_accept() pending");
         connection->_acceptPending = true;         connection->_acceptPending = true;
         Time::gettimeofday(&connection->_acceptPendingStartTime);         Time::gettimeofday(&connection->_acceptPendingStartTime);
Line 934 
Line 956 
             SocketMessage::READ | SocketMessage::EXCEPTION,             SocketMessage::READ | SocketMessage::EXCEPTION,
             connection->getQueueId(), MonitorEntry::TYPE_CONNECTION)) )             connection->getQueueId(), MonitorEntry::TYPE_CONNECTION)) )
     {     {
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,          PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
             "HTTPAcceptor::_acceptConnection: Attempt to allocate entry in "             "HTTPAcceptor::_acceptConnection: Attempt to allocate entry in "
                 "_entries table failed.");                 "_entries table failed.");
         return;         return;

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