(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.81.8.5 and 1.88.6.1

version 1.81.8.5, 2006/06/12 18:26:50 version 1.88.6.1, 2006/11/03 05:04:20
Line 29 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  
 //  
 // Modified By:  
 //          Jenny Yu, Hewlett-Packard Company (jenny_yu@hp.com)  
 //          Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)  
 //          Dave Rosckes (rosckes@us.ibm.com)  
 //          Denise Eckstein (denise.eckstein@hp.com)  
 //          Alagaraja Ramasubramanian (alags_raj@in.ibm.com) for Bug#1090  
 //          Amit Arora, IBM (amita@in.ibm.com) for Bug#2541  
 //          Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)  
 //          Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)  
 //          Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#2065  
 //          David Dillard, Symantec Corp. (david_dillard@symantec.com)  
 //          John Alex, IBM (johnalex@us.ibm.com) for Bug#3312  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "Config.h" #include "Config.h"
 #include "Constants.h" #include "Constants.h"
 #include <iostream> #include <iostream>
 #include "Socket.h"  
   
 #ifdef PEGASUS_OS_TYPE_WINDOWS  
 #include <windows.h>  
 #else  
 # include <cctype>  
 # include <cstdlib>  
 # include <errno.h>  
 # include <fcntl.h>  
 # include <netdb.h>  
 # include <netinet/in.h>  
 # include <netinet/tcp.h>  
 # include <arpa/inet.h>  
 # include <sys/socket.h>  
 # ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET  
 # include <unistd.h>  
 #  include <sys/un.h>  
 # endif  
 #endif  
  
   #include "Network.h"
 #include "Socket.h" #include "Socket.h"
 #include "TLS.h" #include "TLS.h"
 #include "HTTPAcceptor.h" #include "HTTPAcceptor.h"
Line 77 
Line 44 
 #include <Pegasus/Common/MessageLoader.h> //l10n #include <Pegasus/Common/MessageLoader.h> //l10n
  
 #ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM #ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM
 #include "OS400ConvertChar.h"  #include "EBCDIC_OS400.h"
 #endif #endif
  
  
Line 102 
Line 69 
         if (local)         if (local)
         {         {
 #ifndef PEGASUS_OS_TYPE_WINDOWS #ifndef PEGASUS_OS_TYPE_WINDOWS
 #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET  
  
   #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
             address = reinterpret_cast<struct sockaddr*>(new struct sockaddr_un);             address = reinterpret_cast<struct sockaddr*>(new struct sockaddr_un);
             address_size = sizeof(struct sockaddr_un);             address_size = sizeof(struct sockaddr_un);
 #else #else
             PEGASUS_ASSERT(false);             PEGASUS_ASSERT(false);
 #endif #endif
   
 #endif #endif
         }         }
         else         else
Line 124 
Line 90 
     }     }
     struct sockaddr* address;     struct sockaddr* address;
  
     PEGASUS_SOCKLEN_T address_size;      SocketLength address_size;
     Mutex _connection_mut;     Mutex _connection_mut;
  
     PEGASUS_SOCKET socket;      SocketHandle socket;
 #ifdef PEGASUS_OS_TYPE_WINDOWS  // Added for NamedPipe implementation for windows
   #if defined PEGASUS_OS_TYPE_WINDOWS && !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET)
     NamedPipeServer* namedPipeServer;     NamedPipeServer* namedPipeServer;
 #endif #endif
     Array<HTTPConnection*> connections;  
  /*  
 #ifdef PEGASUS_OS_TYPE_WINDOWS  
       // This method creates and connects to a named pipe  
     void createNamedPipe();  
     NamedPipeServer* namedPipeServer;  
     void _acceptNamedPipeConnection(NamedPipeMessage* namedPipeMessage);  
 #endif  
 */  
   
  
       Array<HTTPConnection*> connections;
 }; };
  
 //------------------------------------------------------------------------------  
 //  
 // _setTCPNoDelay()  
 //  
 //------------------------------------------------------------------------------  
   
 inline void _setTCPNoDelay(PEGASUS_SOCKET socket)  
 {  
     // This function disables "Nagle's Algorithm" also known as "the TCP delay  
     // algorithm", which causes read operations to obtain whatever data is  
     // already in the input queue and then wait a little longer to see if  
     // more data arrives. This algorithm optimizes the case in which data is  
     // sent in only one direction but severely impairs performance of round  
     // trip servers. Disabling TCP delay is a standard technique for round  
     // trip servers.  
   
    int opt = 1;  
    setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, (char*)&opt, sizeof(opt));  
 }  
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
Line 175 
Line 114 
                            Boolean localConnection,                            Boolean localConnection,
                            Uint32 portNumber,                            Uint32 portNumber,
                            SSLContext * sslcontext,                            SSLContext * sslcontext,
                            Boolean exportConnection,  
                            ReadWriteSem* sslContextObjectLock)                            ReadWriteSem* sslContextObjectLock)
    : Base(PEGASUS_QUEUENAME_HTTPACCEPTOR),  // ATTN: Need unique names?    : Base(PEGASUS_QUEUENAME_HTTPACCEPTOR),  // ATTN: Need unique names?
      _monitor(monitor),      _monitor(monitor),
Line 185 
Line 123 
      _localConnection(localConnection),      _localConnection(localConnection),
      _portNumber(portNumber),      _portNumber(portNumber),
      _sslcontext(sslcontext),      _sslcontext(sslcontext),
      _exportConnection(exportConnection),  
      _sslContextObjectLock(sslContextObjectLock)      _sslContextObjectLock(sslContextObjectLock)
 { {
    Socket::initializeInterface();    Socket::initializeInterface();
Line 262 
Line 199 
  
          break;          break;
       }       }
  #ifdef PEGASUS_OS_TYPE_WINDOWS  
   // Added for NamedPipe implementation for windows
   #if defined PEGASUS_OS_TYPE_WINDOWS && !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET)
       case NAMEDPIPE_MESSAGE:       case NAMEDPIPE_MESSAGE:
       {       {
          NamedPipeMessage* namedPipeMessage = (NamedPipeMessage*)message;          NamedPipeMessage* namedPipeMessage = (NamedPipeMessage*)message;
Line 278 
Line 217 
             Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,             Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
               "HTTPAcceptor::handleEnqueue: Invalid NAMEDPIPE_MESSAGE received.");               "HTTPAcceptor::handleEnqueue: Invalid NAMEDPIPE_MESSAGE received.");
          }          }
   
          break;          break;
   
       }       }
 #endif #endif
      // may Need to close connection for Named Pipe too.....??  
      case CLOSE_CONNECTION_MESSAGE:      case CLOSE_CONNECTION_MESSAGE:
       {       {
      CloseConnectionMessage* closeConnectionMessage      CloseConnectionMessage* closeConnectionMessage
Line 294 
Line 231 
      for (Uint32 i = 0, n = _rep->connections.size(); i < n; i++)      for (Uint32 i = 0, n = _rep->connections.size(); i < n; i++)
      {      {
         HTTPConnection* connection = _rep->connections[i];         HTTPConnection* connection = _rep->connections[i];
         PEGASUS_SOCKET socket = connection->getSocket();  // Added for NamedPipe implementation for windows
   #if defined PEGASUS_OS_TYPE_WINDOWS && !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET)
                   if(!connection->isNamedPipeConnection())
                   {
   #endif
   
                       SocketHandle socket = connection->getSocket();
  
         if (socket == closeConnectionMessage->socket)         if (socket == closeConnectionMessage->socket)
         {         {
Line 303 
Line 246 
                delete connection;                delete connection;
            break;            break;
         }         }
   // Added for NamedPipe implementation for windows
   #if defined PEGASUS_OS_TYPE_WINDOWS && !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET)
                   }
                   else
                   {
                       NamedPipe namedPipe = connection->getNamedPipe();
                       //NamedPipeMessage* namedPipeMessage = (NamedPipeMessage*)message;
   
                       if (namedPipe.getPipe() == closeConnectionMessage->namedPipe.getPipe())
                       {
                           _monitor->unsolicitPipeMessages(namedPipe);
                           _rep->connections.remove(i);
                           delete connection;
                           break;
                       }
                   }
   #endif
   
      }      }
  
      break;      break;
Line 363 
Line 324 
 */ */
 void HTTPAcceptor::_bind() void HTTPAcceptor::_bind()
 { {
     PEGASUS_STD(cout) << "in HTTPAcceptor::_bind at the begining" << PEGASUS_STD(endl);  
     PEGASUS_STD(cout) << "in HTTPAcceptor::_bind before ASSERT" << PEGASUS_STD(endl);  
  
    PEGASUS_ASSERT(_rep != 0);    PEGASUS_ASSERT(_rep != 0);
    // Create address:    // Create address:
  
    PEGASUS_STD(cout) << "in HTTPAcceptor::_bind before memset" << PEGASUS_STD(endl);  #if defined PEGASUS_OS_TYPE_WINDOWS
   
   
 #ifdef PEGASUS_OS_TYPE_WINDOWS  
    if (!_localConnection)    if (!_localConnection)
    {    {
   #endif
   
        memset(_rep->address, 0, sizeof(*_rep->address));        memset(_rep->address, 0, sizeof(*_rep->address));
   #if defined PEGASUS_OS_TYPE_WINDOWS
    }    }
 #else  
    memset(_rep->address, 0, sizeof(*_rep->address));  
 #endif #endif
   
    PEGASUS_STD(cout) << "in HTTPAcceptor::_bind After memset" << PEGASUS_STD(endl);  
   
   
    if (_localConnection)    if (_localConnection)
    {    {
   // Added for NamedPipe implementation for windows
 #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
   
 #ifdef PEGASUS_OS_TYPE_WINDOWS #ifdef PEGASUS_OS_TYPE_WINDOWS
        PEGASUS_STD(cout)  #  ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG
            << "in HTTPAcceptor::_bind before calling _createNamedPipe() "         {
              AutoMutex automut(Monitor::_cout_mut);
              PEGASUS_STD(cout) << "in HTTPAcceptor::_bind before calling _createNamedPipe() "
            << PEGASUS_STD(endl);            << PEGASUS_STD(endl);
      // _rep->createNamedPipe();         }
   #  endif
        _createNamedPipe();        _createNamedPipe();
   # ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG
          {
              AutoMutex automut(Monitor::_cout_mut);
        PEGASUS_STD(cout) << "in HTTPAcceptor::_bind after calling _createNamedPipe() " << PEGASUS_STD(endl);        PEGASUS_STD(cout) << "in HTTPAcceptor::_bind after calling _createNamedPipe() " << PEGASUS_STD(endl);
          }
   # endif
        return;        return;
 #else  # else // Other than Windows platform
   
        reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_family =        reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_family =
            AF_UNIX;            AF_UNIX;
        strcpy(         strcpy(reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path,
            reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path,  
            PEGASUS_LOCAL_DOMAIN_SOCKET_PATH);            PEGASUS_LOCAL_DOMAIN_SOCKET_PATH);
   
 #ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM #ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM
        AtoE(reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path);        AtoE(reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path);
 #endif #endif
        ::unlink(reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path);        ::unlink(reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path);
 #endif #endif
   
 #else #else
        PEGASUS_ASSERT(false);        PEGASUS_ASSERT(false);
 #endif #endif
Line 424 
Line 383 
    }    }
  
    // Create socket:    // Create socket:
   
    if (_localConnection)    if (_localConnection)
    {    {
        _rep->socket = socket(AF_UNIX, SOCK_STREAM, 0);         _rep->socket = Socket::createSocket(AF_UNIX, SOCK_STREAM, 0);
    }    }
    else    else
    {    {
        _rep->socket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);         _rep->socket = Socket::createSocket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
  
        _setTCPNoDelay(_rep->socket);  
    }    }
  
    if (_rep->socket < 0)    if (_rep->socket < 0)
Line 517 
Line 476 
    if ( _portNumber == 0 )    if ( _portNumber == 0 )
    {    {
       sockaddr_in buf;       sockaddr_in buf;
       PEGASUS_SOCKLEN_T bufSize = sizeof(buf);        SocketLength bufSize = sizeof(buf);
       if ( getsockname(_rep->socket, reinterpret_cast<sockaddr *>(&buf), &bufSize) == 0 )       if ( getsockname(_rep->socket, reinterpret_cast<sockaddr *>(&buf), &bufSize) == 0 )
       {       {
           _portNumber = ntohs(buf.sin_port);           _portNumber = ntohs(buf.sin_port);
Line 587 
Line 546 
                   "HTTPAcceptor::_bind: Failed to solicit socket messages(2).");                   "HTTPAcceptor::_bind: Failed to solicit socket messages(2).");
       throw BindFailedException(parms);       throw BindFailedException(parms);
    }    }
    PEGASUS_STD(cout) << "in HTTPAcceptor::_bind at the End" << PEGASUS_STD(endl);  
   
 } }
  
 /** /**
Line 645 
Line 602 
    }    }
 } }
  
   
   /**
      reconnectConnectionSocket - creates a new server socket.
   */
   void HTTPAcceptor::reconnectConnectionSocket()
   {
      if (_rep)
      {
         // unregister the socket
         _monitor->unsolicitSocketMessages(_rep->socket);
         // close the socket
         Socket::close(_rep->socket);
         // Unlink Local Domain Socket Bug# 3312
         if (_localConnection)
         {
   
   #ifndef PEGASUS_OS_TYPE_WINDOWS && !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET)
             PEG_TRACE_STRING(TRC_HTTP, Tracer::LEVEL2,
                           "HTTPAcceptor::reconnectConnectionSocket Unlinking local connection." );
            ::unlink(
                reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path);
   #else
            PEGASUS_ASSERT(false);
   #endif
   
         }
         // open the socket
         _bind();
      }
      else
      {
         PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
                           "HTTPAcceptor::reconnectConnectionSocket failure _rep is null." );
      }
   }
   
 /** /**
    getOutstandingRequestCount - returns the number of outstanding requests.    getOutstandingRequestCount - returns the number of outstanding requests.
 */ */
Line 672 
Line 665 
     return _portNumber;     return _portNumber;
 } }
  
   void HTTPAcceptor::setSocketWriteTimeout(Uint32 socketWriteTimeout)
   {
       _socketWriteTimeout = socketWriteTimeout;
   }
   
 void HTTPAcceptor::unbind() void HTTPAcceptor::unbind()
 { {
    if (_rep)    if (_rep)
Line 683 
Line 681 
       {       {
 #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
 #ifndef PEGASUS_OS_TYPE_WINDOWS #ifndef PEGASUS_OS_TYPE_WINDOWS
   
          ::unlink(          ::unlink(
              reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path);              reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path);
 #endif #endif
Line 691 
Line 688 
          PEGASUS_ASSERT(false);          PEGASUS_ASSERT(false);
 #endif #endif
       }       }
   #if defined PEGASUS_OS_TYPE_WINDOWS && !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET)
        if (!_localConnection)
        {
   #endif
       delete _rep;       delete _rep;
   #if defined PEGASUS_OS_TYPE_WINDOWS && !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET)
        }
   #endif
       _rep = 0;       _rep = 0;
    }    }
    else    else
Line 712 
Line 715 
      for (Uint32 i = 0, n = _rep->connections.size(); i < n; i++)      for (Uint32 i = 0, n = _rep->connections.size(); i < n; i++)
      {      {
         HTTPConnection* connection = _rep->connections[i];         HTTPConnection* connection = _rep->connections[i];
         PEGASUS_SOCKET socket = connection->getSocket();  // Added for NamedPipe implementation for windows
   #if defined PEGASUS_OS_TYPE_WINDOWS && !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET)
           if(!connection->isNamedPipeConnection())
           {
   #endif
           SocketHandle socket = connection->getSocket();
  
         // Unsolicit SocketMessages:         // Unsolicit SocketMessages:
  
         _monitor->unsolicitSocketMessages(socket);         _monitor->unsolicitSocketMessages(socket);
  
   // Added for NamedPipe implementation for windows
         // Destroy the connection (causing it to close):         // Destroy the connection (causing it to close):
   #if defined PEGASUS_OS_TYPE_WINDOWS && !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET)
           }
           else
           {
               NamedPipe namedPipe = connection->getNamedPipe();
               _monitor->unsolicitPipeMessages(namedPipe);
           }
   #endif
         while (connection->refcount.get()) { }         while (connection->refcount.get()) { }
         delete connection;         delete connection;
      }      }
Line 734 
Line 750 
  
    PEGASUS_ASSERT(_rep != 0);    PEGASUS_ASSERT(_rep != 0);
  
    if (!_rep)  
       return;  
   
    // Accept the connection (populate the address):    // Accept the connection (populate the address):
  
    struct sockaddr* accept_address;    struct sockaddr* accept_address;
    PEGASUS_SOCKLEN_T address_size;     SocketLength address_size;
  
    if (_localConnection)    if (_localConnection)
    {    {
Line 759 
Line 772 
        address_size = sizeof(struct sockaddr_in);        address_size = sizeof(struct sockaddr_in);
    }    }
  
    PEGASUS_SOCKET socket = accept(_rep->socket, accept_address, &address_size);     SocketHandle socket = accept(_rep->socket, accept_address, &address_size);
  
      if (socket == PEGASUS_SOCKET_ERROR)
      {
          // the remote connection is invalid, destroy client address.
    delete accept_address;    delete accept_address;
  
    if (socket < 0)         // TCPIP is down reconnect this acceptor
          if(getSocketError() == PEGASUS_NETWORK_TCPIP_STOPPED)
    {    {
  
              PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
                       "Socket has an IO error. TCP/IP down. Try to reconnect." );
   
              reconnectConnectionSocket();
   
              return;
          }
        Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,        Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
            "HTTPAcceptor - accept() failure.  errno: $0"            "HTTPAcceptor - accept() failure.  errno: $0"
            ,errno);            ,errno);
Line 775 
Line 799 
       return;       return;
    }    }
  
      String ipAddress;
   
      if (_localConnection)
      {
          ipAddress = "localhost";
      }
      else
      {
          unsigned char* sa = reinterpret_cast<unsigned char*>(
              &reinterpret_cast<struct sockaddr_in*>(
                  accept_address)->sin_addr.s_addr);
          char ipBuffer[32];
          sprintf(ipBuffer, "%u.%u.%u.%u", sa[0], sa[1], sa[2], sa[3]);
          ipAddress = ipBuffer;
      }
   
      delete accept_address;
   
 // set the close on exec flag // set the close on exec flag
 #if !defined(PEGASUS_OS_TYPE_WINDOWS) && !defined(PEGASUS_OS_VMS) #if !defined(PEGASUS_OS_TYPE_WINDOWS) && !defined(PEGASUS_OS_VMS)
    int sock_flags;    int sock_flags;
Line 799 
Line 841 
        "HTTPAcceptor - accept() success.  Socket: $1" ,socket));        "HTTPAcceptor - accept() success.  Socket: $1" ,socket));
  
    AutoPtr<MP_Socket> mp_socket(new MP_Socket(    AutoPtr<MP_Socket> mp_socket(new MP_Socket(
        socket, _sslcontext, _sslContextObjectLock, _exportConnection));         socket, _sslcontext, _sslContextObjectLock));
   
      mp_socket->setSocketWriteTimeout(_socketWriteTimeout);
  
    // Perform the SSL handshake, if applicable.  Make the socket non-blocking    // Perform the SSL handshake, if applicable.  Make the socket non-blocking
    // for this operation so we can send it back to the Monitor's select() loop    // for this operation so we can send it back to the Monitor's select() loop
Line 820 
Line 864 
    // Create a new connection and add it to the connection list:    // Create a new connection and add it to the connection list:
  
    HTTPConnection* connection = new HTTPConnection(_monitor, mp_socket,    HTTPConnection* connection = new HTTPConnection(_monitor, mp_socket,
        this, static_cast<MessageQueue *>(_outputMessageQueue), _exportConnection);         ipAddress, this, static_cast<MessageQueue *>(_outputMessageQueue));
  
    if (socketAcceptStatus == 0)    if (socketAcceptStatus == 0)
    {    {
Line 851 
Line 895 
    AutoMutex autoMut(_rep->_connection_mut);    AutoMutex autoMut(_rep->_connection_mut);
    _rep->connections.append(connection);    _rep->connections.append(connection);
 } }
   // Added for NamedPipe implementation for windows
 #ifdef PEGASUS_OS_TYPE_WINDOWS  #if defined PEGASUS_OS_TYPE_WINDOWS && !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET)
 void HTTPAcceptor::_createNamedPipe() void HTTPAcceptor::_createNamedPipe()
 { {
   #ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG
       {
           AutoMutex automut(Monitor::_cout_mut);
     PEGASUS_STD(cout) << "Entering  HTTPAcceptor::_createNamedPipe()." << PEGASUS_STD(endl);     PEGASUS_STD(cout) << "Entering  HTTPAcceptor::_createNamedPipe()." << PEGASUS_STD(endl);
       }
     _rep->namedPipeServer = new NamedPipeServer("\\\\.\\pipe\\MyNamedPipe");  #endif
       _rep->namedPipeServer = new NamedPipeServer(PEGASUS_NAMEDPIPE_PATH);
   #ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG
       {
           AutoMutex automut(Monitor::_cout_mut);
     PEGASUS_STD(cout) << "in HTTPAcceptor::_createNamedPipe() after calling the pipe server constructor" << PEGASUS_STD(endl);     PEGASUS_STD(cout) << "in HTTPAcceptor::_createNamedPipe() after calling the pipe server constructor" << PEGASUS_STD(endl);
       }
  
       {
           AutoMutex automut(Monitor::_cout_mut);
     cout << "Named pipe...in _createNamedPipe..." << _rep->namedPipeServer->getPipe() << endl;     cout << "Named pipe...in _createNamedPipe..." << _rep->namedPipeServer->getPipe() << endl;
       }
   #endif
     // Register to receive Messages on Connection pipe:     // Register to receive Messages on Connection pipe:
  
    if ( -1 == ( _entry_index = _monitor->solicitPipeMessages(    if ( -1 == ( _entry_index = _monitor->solicitPipeMessages(
Line 875 
Line 929 
        delete _rep;        delete _rep;
        _rep = 0;        _rep = 0;
        //l10n        //l10n
        //throw BindFailedException("Failed to solicit socket messaeges");  
        MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_SOLICIT_SOCKET_MESSAGES",        MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_SOLICIT_SOCKET_MESSAGES",
                     "Failed to solicit socket messaeges");                     "Failed to solicit socket messaeges");
        PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,        PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
                    "HTTPAcceptor::_bind: Failed to solicit socket messages(2).");                     "HTTPAcceptor::_bind: Failed to solicit pipe messages(2).");
        throw BindFailedException(parms);        throw BindFailedException(parms);
   #ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG
        PEGASUS_STD(cout) << "in HTTPAcceptor::_createNamedPipe() _monitor->solicitSocketMessages failed" << PEGASUS_STD(endl);         {
              AutoMutex automut(Monitor::_cout_mut); //added
              PEGASUS_STD(cout) << "in HTTPAcceptor::_createNamedPipe() _monitor->solicitSocketMessages failed"
                                << PEGASUS_STD(endl);
    }    }
   #endif
      }
   #ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG
      {
          AutoMutex automut(Monitor::_cout_mut);
    PEGASUS_STD(cout) << "Leaving  HTTPAcceptor::_createNamedPipe()." << PEGASUS_STD(endl);    PEGASUS_STD(cout) << "Leaving  HTTPAcceptor::_createNamedPipe()." << PEGASUS_STD(endl);
    return;  
   
 } }
 #endif #endif
      return;
   }
  
   
 #ifdef PEGASUS_OS_TYPE_WINDOWS  
 void HTTPAcceptor::_acceptNamedPipeConnection() void HTTPAcceptor::_acceptNamedPipeConnection()
 { {
     PEGASUS_ASSERT(_rep != 0);     PEGASUS_ASSERT(_rep != 0);
  
     if (!_rep)     if (!_rep)
        return;        return;
   #ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG
       {
           AutoMutex automut(Monitor::_cout_mut);
     cout <<"In HTTPAcceptor::_acceptNamedPipeConnection " << endl;     cout <<"In HTTPAcceptor::_acceptNamedPipeConnection " << endl;
       }
   #endif
  
    // shouldnt we be using the private var....  
      //                 _namedPipeServer->accept()  
  
     NamedPipeServerEndPiont nPSEndPoint = _rep->namedPipeServer->accept();     NamedPipeServerEndPiont nPSEndPoint = _rep->namedPipeServer->accept();
     // Registerpe to receive Messages on Connection pipe:      // Register to receive Messages on Connection pipe:
   #ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG
     cout << " In _acceptNamedPipeConnection -- after calling namedPipeServer->accept()" << endl;  
   
     HTTPConnection* connection = new HTTPConnection(_monitor, nPSEndPoint,  
         this, static_cast<MessageQueue *>(_outputMessageQueue), _exportConnection);  
   
     /*  NOT SURE WHAT TO DO HERE  ....  
     if (socketAcceptStatus == 0)  
     {     {
         PEG_TRACE_STRING(TRC_HTTP, Tracer::LEVEL2,          AutoMutex automut(Monitor::_cout_mut);
             "HTTPAcceptor: SSL_accept() pending");          cout << " In _acceptNamedPipeConnection -- after calling namedPipeServer->accept()" << endl;
         connection->_acceptPending = true;  
     }     }
   #endif
     */      HTTPConnection* connection = new HTTPConnection(_monitor, nPSEndPoint,
           this, static_cast<MessageQueue *>(_outputMessageQueue),false);
  
     // Solicit events on this new connection's socket:     // Solicit events on this new connection's socket:
     int index;     int index;
   #ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG
       {
           AutoMutex automut(Monitor::_cout_mut);
     cout << endl << connection->getNamedPipe().getName() << " has a this as a QueueID " <<     cout << endl << connection->getNamedPipe().getName() << " has a this as a QueueID " <<
          connection->getQueueId() << endl;          connection->getQueueId() << endl;
       }
   #endif
     if (-1 ==  (index = _monitor->solicitPipeMessages(     if (-1 ==  (index = _monitor->solicitPipeMessages(
        connection->getNamedPipe(),        connection->getNamedPipe(),
        NamedPipeMessage::READ | NamedPipeMessage::EXCEPTION,        NamedPipeMessage::READ | NamedPipeMessage::EXCEPTION,
Line 940 
Line 995 
        Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,        Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
            "HTTPAcceptor::_acceptPipeConnection: Attempt to allocate entry in _entries table failed.");            "HTTPAcceptor::_acceptPipeConnection: Attempt to allocate entry in _entries table failed.");
        delete connection;        delete connection;
        //  May have to close the PIPE here...  
        //Socket::close(socket);  
        return;        return;
     }     }
  
Line 949 
Line 1002 
     connection->_entry_index = index;     connection->_entry_index = index;
     AutoMutex autoMut(_rep->_connection_mut);     AutoMutex autoMut(_rep->_connection_mut);
     _rep->connections.append(connection);     _rep->connections.append(connection);
   #ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG
     {
         AutoMutex automut(Monitor::_cout_mut);
   PEGASUS_STD(cout)   PEGASUS_STD(cout)
        << "in HTTPAcceptor::_acceptNamedPipeConnection() at the end" << PEGASUS_STD(endl);        << "in HTTPAcceptor::_acceptNamedPipeConnection() at the end" << PEGASUS_STD(endl);
     }
   #endif
 } }
 #endif #endif
  

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