(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.29 and 1.42

version 1.29, 2003/06/14 19:25:38 version 1.42, 2003/10/15 10:58:25
Line 57 
Line 57 
 #include "HTTPAcceptor.h" #include "HTTPAcceptor.h"
 #include "HTTPConnection.h" #include "HTTPConnection.h"
 #include "Tracer.h" #include "Tracer.h"
   #include <Pegasus/Common/MessageLoader.h> //l10n
   
   #ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM
   #include "OS400ConvertChar.h"
   #endif
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
Line 93 
Line 98 
  
 #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
    size_t address_size;    size_t address_size;
 #elif defined(PEGASUS_PLATFORM_AIX_RS_IBMCXX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)  #elif defined(PEGASUS_PLATFORM_AIX_RS_IBMCXX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || (defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC) && !defined(SUNOS_5_6))
    socklen_t address_size;    socklen_t address_size;
 #else #else
    int address_size;    int address_size;
Line 205 
Line 210 
  
 void HTTPAcceptor::bind() void HTTPAcceptor::bind()
 { {
    if (_rep)     if (_rep){
       throw BindFailedException("HTTPAcceptor already bound");          //l10n
         //throw BindFailedException("HTTPAcceptor already bound");
   
         MessageLoaderParms parms("Common.HTTPAcceptor.ALREADY_BOUND",
                                  "HTTPAcceptor already bound");
   
         throw BindFailedException(parms);
      }
  
    _rep = new HTTPAcceptorRep(_localConnection);    _rep = new HTTPAcceptorRep(_localConnection);
  
Line 235 
Line 247 
            AF_UNIX;            AF_UNIX;
        strcpy(reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path,        strcpy(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
          AtoE(reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path);
   #endif
        ::unlink(reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path);        ::unlink(reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path);
 #else #else
        PEGASUS_ASSERT(false);        PEGASUS_ASSERT(false);
Line 265 
Line 280 
    {    {
       delete _rep;       delete _rep;
       _rep = 0;       _rep = 0;
       throw BindFailedException("Failed to create socket");        //l10n
         //throw BindFailedException("Failed to create socket");
         MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_CREATE_SOCKET",
                                  "Failed to create socket");
         throw BindFailedException(parms);
    }    }
  
  
Line 303 
Line 322 
       Socket::close(_rep->socket);       Socket::close(_rep->socket);
       delete _rep;       delete _rep;
       _rep = 0;       _rep = 0;
       throw BindFailedException("Failed to set socket option");        //l10n
         //throw BindFailedException("Failed to set socket option");
         MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_SET_SOCKET_OPTION",
                                  "Failed to set socket option");
         throw BindFailedException(parms);
    }    }
  
    // Bind socket to port:    // Bind socket to port:
Line 313 
Line 336 
       Socket::close(_rep->socket);       Socket::close(_rep->socket);
       delete _rep;       delete _rep;
       _rep = 0;       _rep = 0;
       throw BindFailedException("Failed to bind socket");        //l10n
         //throw BindFailedException("Failed to bind socket");
         MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_BIND_SOCKET",
                                  "Failed to bind socket");
         throw BindFailedException(parms);
    }    }
  
    // Set up listening on the given socket:    // Set up listening on the given socket:
Line 325 
Line 352 
       Socket::close(_rep->socket);       Socket::close(_rep->socket);
       delete _rep;       delete _rep;
       _rep = 0;       _rep = 0;
       throw BindFailedException("Failed to bind socket");        //l10n
         //throw BindFailedException("Failed to bind socket");
         MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_BIND_SOCKET",
                                  "Failed to bind socket");
         throw BindFailedException(parms);
    }    }
  
    // Register to receive SocketMessages on this socket:    // Register to receive SocketMessages on this socket:
Line 339 
Line 370 
       Socket::close(_rep->socket);       Socket::close(_rep->socket);
       delete _rep;       delete _rep;
       _rep = 0;       _rep = 0;
       throw BindFailedException("Failed to solicit socket messaeges");        //l10n
         //throw BindFailedException("Failed to solicit socket messaeges");
         MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_SOLICIT_SOCKET_MESSAGES",
                                  "Failed to solicit socket messaeges");
         throw BindFailedException(parms);
    }    }
 } }
  
Line 352 
Line 387 
    if (_rep)    if (_rep)
    {    {
       // unregister the socket       // unregister the socket
       _monitor->unsolicitSocketMessages(_rep->socket);  
         // ATTN - comment out - see CIMServer::stopClientConnection()
         //_monitor->unsolicitSocketMessages(_rep->socket);
  
       // close the socket       // close the socket
       Socket::close(_rep->socket);       Socket::close(_rep->socket);
Line 448 
Line 485 
    struct sockaddr* accept_address;    struct sockaddr* accept_address;
 #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
    size_t address_size;    size_t address_size;
 #elif defined(PEGASUS_PLATFORM_AIX_RS_IBMCXX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)  #elif defined(PEGASUS_PLATFORM_AIX_RS_IBMCXX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || (defined(PEGASUS_OS_SOLARIS) && !defined(SUNOS_5_6))
    socklen_t address_size;    socklen_t address_size;
 #else #else
    int address_size;    int address_size;
Line 475 
Line 512 
  
    if (socket < 0)    if (socket < 0)
    {    {
   
        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 529 
Line 567 
           SocketMessage::READ | SocketMessage::EXCEPTION,           SocketMessage::READ | SocketMessage::EXCEPTION,
           connection->getQueueId(), Monitor::CONNECTION)) )           connection->getQueueId(), Monitor::CONNECTION)) )
    {    {
         // ATTN-DE-P2-2003100503::TODO::Need to enhance code to return
         // an error message to Client application.
         Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
             "HTTPAcceptor::_acceptConnection. Attempt to allocate entry in _entries table failed.");
       delete connection;       delete connection;
       Socket::close(socket);       Socket::close(socket);
         return;
    }    }
  
    // Save the socket for cleanup later:    // Save the socket for cleanup later:
Line 540 
Line 583 
    _rep->_connection_mut.unlock();    _rep->_connection_mut.unlock();
 } }
  
   AsyncDQueue<pegasus_acceptor> pegasus_acceptor::acceptors(true, 0);
   
   void pegasus_acceptor::close_all_acceptors(void)
   {
      try
      {
         pegasus_acceptor* temp = acceptors.remove_first();
         while(temp)
         {
            delete temp;
            temp = acceptors.remove_first();
         }
      }
      catch(...)
      {
      }
   
   }
   
   
   
   pegasus_acceptor::pegasus_acceptor(monitor_2* monitor,
                                      MessageQueue* outputMessageQueue,
                                      Boolean localConnection,
                                      Uint32 portNumber,
                                      SSLContext* sslcontext)
     : _monitor(monitor), _outputMessageQueue(outputMessageQueue),
       _localConnection(localConnection), _portNumber(portNumber),
       _sslcontext(sslcontext), connections(true, 0)
   {
   
        Socket::initializeInterface();
        try {
          acceptors.insert_first(this);
        }
        catch(...){
        }
   
   }
   
   pegasus_acceptor::~pegasus_acceptor(void)
   {
      unbind();
      Socket::uninitializeInterface();
      try {
        acceptors.remove(this);
      }
      catch(...){
      }
   
   }
   
   
   void pegasus_acceptor::bind()
   {
   
     PEGASUS_SOCKLEN_SIZE addr_size;
     struct sockaddr *addr;
     struct sockaddr_in addr_in;
   # ifdef PEGASUS_LOCAL_DOMAIN_SOCKET
     struct sockaddr_un addr_un;
   #endif
   
     memset(&addr_in, 0, sizeof(addr_in));
     addr_in.sin_addr.s_addr = INADDR_ANY;
     addr_in.sin_family = AF_INET;
     addr_in.sin_port = htons(_portNumber);
     addr = (struct sockaddr*) &addr_in;
     addr_size = sizeof(addr_in);
   
     // first step: determine which kind of socket factory to initialize,
     // then create the socket and bind it to an address
     if(_localConnection == true){
   #ifdef PEGASUS_LOCAL_DOMAIN_SOCKET
       unix_socket_factory sf;
       pegasus_socket temp(&sf);
       _listener = temp;
   
       memset(&addr_un, 0, sizeof(addr_un));
       addr_un.sun_family = AF_UNIX;
       strcpy(addr_un.sun_path, PEGASUS_LOCAL_DOMAIN_SOCKET_PATH);
   #ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM
       AtoE(addr_un.sun_path);
   #endif
       addr = (struct sockaddr*) &addr_un;
       addr_size = sizeof(addr_un);
       _listener.socket(AF_UNIX, SOCK_STREAM, 0);
   #else
       bsd_socket_factory sf;
       pegasus_socket temp(&sf);
       _listener = temp;
       _listener.socket(AF_UNIX, SOCK_STREAM, 0);
   #endif
     }
     else if( _sslcontext != 0 ) {
   #ifdef PEGASUS_HAS_SSL
       ssl_socket_factory sf;
   #else
       bsd_socket_factory sf;
   #endif
       pegasus_socket temp(&sf);
       _listener = temp;
       _listener.socket(PF_INET, SOCK_STREAM, 0);
     }
     else {
       bsd_socket_factory sf;
       pegasus_socket temp(&sf);
       _listener = temp;
       _listener.socket(PF_INET, SOCK_STREAM, 0);
     }
   
     _listener.bind((struct sockaddr*)addr, addr_size);
   
     // second step: listen on the socket
   
     _listener.listen(5);
   
     // third step: add this listening socket to the monitor
   
      _monitor->tickle();
      _monitor->add_entry(_listener, LISTEN, this, this);
   }
   
   
   /** Unbind from the given port.
    */
   void pegasus_acceptor::unbind()
   {
     // remove the socket from the monitor
     _monitor->remove_entry((Sint32)_listener);
   
     // close the socket
     _listener.close();
   }
   
   
         /** Close the connection socket.
          */
   void pegasus_acceptor::closeConnectionSocket()
   {
     unbind();
   }
   
   
         /** Reopen the connection socket.
          */
   void pegasus_acceptor::reopenConnectionSocket()
   {
     bind();
   }
   
   
     /** Returns the number of outstanding requests
      */
   Uint32 pegasus_acceptor::getOutstandingRequestCount()
   {
     return _monitor->getOutstandingRequestCount();
   }
   
   Boolean pegasus_acceptor::operator ==(const pegasus_acceptor& pa)
   {
     if(this == &pa)
       return true;
     return false;
   }
   
   Boolean pegasus_acceptor::operator ==(void* pa)
   {
     if((void*)this == pa)
       return true;
     return false;
   }
   
   
   pegasus_acceptor* pegasus_acceptor::find_acceptor(Boolean local, Uint32 port)
   {
     pegasus_acceptor* temp = 0;
   
     try {
       acceptors.try_lock(pegasus_thread_self());
       temp = acceptors.next(temp);
       while(temp){
         if( local == true ){
           if(temp->_localConnection){
             acceptors.unlock();
             return temp;
           }
         }
         if(temp->_localConnection == local && temp->_portNumber ==port){
           acceptors.unlock();
           return temp;
         }
         temp = acceptors.next(temp);
       }
       acceptors.unlock();
     }
     catch(...){
     }
     return temp;
   }
   
   class m2e_rep;
   
   void pegasus_acceptor::accept_dispatch(monitor_2_entry *entry)
   {
     pegasus_acceptor* myself = (pegasus_acceptor*)entry->get_accept();
   
     HTTPConnection2* connection = new HTTPConnection2(entry->_rep->psock, myself->_outputMessageQueue);
   
     // set the entry's dispatch parameter to point to the connection object
     entry->set_dispatch ((void*)connection);
   
     monitor_2::insert_connection(connection);
   
   }
   
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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