(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.1 and 1.81.8.2

version 1.81.8.1, 2006/06/01 01:53:01 version 1.81.8.2, 2006/06/02 21:14:03
Line 101 
Line 101 
     {     {
         if (local)         if (local)
         {         {
   #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
         }         }
         else         else
         {         {
Line 124 
Line 128 
     Mutex _connection_mut;     Mutex _connection_mut;
  
     PEGASUS_SOCKET socket;     PEGASUS_SOCKET socket;
   #ifdef PEGASUS_OS_TYPE_WINDOWS
       NamedPipeServer* namedPipeServer;
   #endif
     Array<HTTPConnection*> connections;     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
   */
  
  
 }; };
Line 247 
Line 262 
  
          break;          break;
       }       }
    #ifdef PEGASUS_OS_TYPE_WINDOWS
       case NAMEDPIPE_MESSAGE:       case NAMEDPIPE_MESSAGE:
       {       {
           NamedPipeMessage* namedPipeMessage = (NamedPipeMessage*)message;           NamedPipeMessage* namedPipeMessage = (NamedPipeMessage*)message;
  
          // If this is a connection request:          // If this is a connection request:
  
          /*if (socketMessage->socket == _rep->socket &&           //if ((namedPipeMessage->namedPipe.getPipe() ==  *_rep->namedPipeServer.getPipe()) &&
              socketMessage->events & SocketMessage::READ)           //   (namedPipeMessage->events & NamedPipeMessage::READ))
          {          {
              _acceptConnection();               _acceptNamedPipeConnection();
          }          }
          else           /*else
          {          {
             // ATTN! this can't happen!             // ATTN! this can't happen!
             Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,             Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
               "HTTPAcceptor::handleEnqueue: Invalid SOCKET_MESSAGE received.");                "HTTPAcceptor::handleEnqueue: Invalid NAMEDPIPE_MESSAGE received.");
          }  */           }
          //NOTE:: Need to work on duplication of the above code for namedPipes           */
   
          _acceptNamedPipeConnection(namedPipeMessage);  
   
          break;          break;
  
       }       }
   #endif
        // may Need to close connection for Named Pipe too.....??
       case CLOSE_CONNECTION_MESSAGE:       case CLOSE_CONNECTION_MESSAGE:
       {       {
      CloseConnectionMessage* closeConnectionMessage      CloseConnectionMessage* closeConnectionMessage
Line 352 
Line 366 
 void HTTPAcceptor::_bind() void HTTPAcceptor::_bind()
 { {
     PEGASUS_STD(cout) << "in HTTPAcceptor::_bind at the begining" << PEGASUS_STD(endl);     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);
   
   
   #ifdef PEGASUS_OS_TYPE_WINDOWS
      if (!_localConnection)
      {
          memset(_rep->address, 0, sizeof(*_rep->address));
      }
   #else
    memset(_rep->address, 0, sizeof(*_rep->address));    memset(_rep->address, 0, sizeof(*_rep->address));
   #endif
  
  //the way this is now (not in ifdef) it will cause non-local connections to fail     PEGASUS_STD(cout) << "in HTTPAcceptor::_bind After memset" << PEGASUS_STD(endl);
 //#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET //this is not the right place for the block of code  
                                              // not sure right now where it should go  
      if (_localConnection)
      {
   
   #ifdef PEGASUS_OS_TYPE_WINDOWS
    PEGASUS_STD(cout) << "in HTTPAcceptor::_bind before calling _createNamedPipe() " << PEGASUS_STD(endl);    PEGASUS_STD(cout) << "in HTTPAcceptor::_bind before calling _createNamedPipe() " << PEGASUS_STD(endl);
          // _rep->createNamedPipe();
        _createNamedPipe();        _createNamedPipe();
        PEGASUS_STD(cout) << "in HTTPAcceptor::_bind after calling _createNamedPipe() " << PEGASUS_STD(endl);        PEGASUS_STD(cout) << "in HTTPAcceptor::_bind after calling _createNamedPipe() " << PEGASUS_STD(endl);
   // Not sure if we need to continue to bind non local domain sockets in windows.....
        return;        return;
  //#endif  // #else
   #endif
  
    if (_localConnection)  
    {  
 #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
   
         reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_family =         reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_family =
            AF_UNIX;            AF_UNIX;
        strcpy(reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path,        strcpy(reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path,
Line 558 
Line 588 
                   "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 814 
Line 846 
    _rep->connections.append(connection);    _rep->connections.append(connection);
 } }
  
   #ifdef PEGASUS_OS_TYPE_WINDOWS
 void HTTPAcceptor::_createNamedPipe() void HTTPAcceptor::_createNamedPipe()
 { {
     PEGASUS_STD(cout) << "in HTTPAcceptor::_createNamedPipe() at the begining" << PEGASUS_STD(endl);     PEGASUS_STD(cout) << "in HTTPAcceptor::_createNamedPipe() at the begining" << PEGASUS_STD(endl);
  
     _namedPipeServer = new NamedPipeServer("\\\\.\\pipe\\MyNamedPipe");      _rep->namedPipeServer = new NamedPipeServer("\\\\.\\pipe\\MyNamedPipe");
     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);
  
  
Line 826 
Line 859 
     // 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(
       *_namedPipeServer,        *_rep->namedPipeServer,
       SocketMessage::READ | SocketMessage::EXCEPTION,        NamedPipeMessage::READ | NamedPipeMessage::EXCEPTION,
       getQueueId(),       getQueueId(),
       Monitor::ACCEPTOR)))       Monitor::ACCEPTOR)))
    {    {
          ::CloseHandle(_rep->namedPipeServer->getPipe());
          delete _rep;
          _rep = 0;
          //l10n
          //throw BindFailedException("Failed to solicit socket messaeges");
          MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_SOLICIT_SOCKET_MESSAGES",
                       "Failed to solicit socket messaeges");
          PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
                      "HTTPAcceptor::_bind: Failed to solicit socket messages(2).");
          throw BindFailedException(parms);
   
        PEGASUS_STD(cout) << "in HTTPAcceptor::_createNamedPipe() _monitor->solicitSocketMessages failed" << PEGASUS_STD(endl);        PEGASUS_STD(cout) << "in HTTPAcceptor::_createNamedPipe() _monitor->solicitSocketMessages failed" << PEGASUS_STD(endl);
  
    }    }
Line 839 
Line 883 
    return;    return;
  
 } }
   #endif
   
  
 void HTTPAcceptor::_acceptNamedPipeConnection(NamedPipeMessage* namedPipeMessage)  #ifdef PEGASUS_OS_TYPE_WINDOWS
   void HTTPAcceptor::_acceptNamedPipeConnection()
 { {
       PEGASUS_ASSERT(_rep != 0);
   
       if (!_rep)
          return;
   
     cout <<"In HTTPAcceptor::_acceptNamedPipeConnection " << endl;     cout <<"In HTTPAcceptor::_acceptNamedPipeConnection " << endl;
  
     //Here we know this a namedPipe server because on the server calles HTTPAcceptor     // shouldnt we be using the private var....
     NamedPipeServer* namedPipeServer = (NamedPipeServer *) (&namedPipeMessage->namedPipe);       //                 _namedPipeServer->accept()
   
       NamedPipeServerEndPiont nPSEndPoint = _rep->namedPipeServer->accept();
       // Registerpe to receive Messages on Connection pipe:
  
     NamedPipeServerEndPiont nPSEndPoint = namedPipeServer->accept();  
     cout << " In _acceptNamedPipeConnection -- after calling namedPipeServer->accept()" << endl;     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,
               "HTTPAcceptor: SSL_accept() pending");
           connection->_acceptPending = true;
       }
   
       */
   
       // Solicit events on this new connection's socket:
       int index;
  
       if (-1 ==  (index = _monitor->solicitPipeMessages(
          connection->getNamedPipe(),
          NamedPipeMessage::READ | NamedPipeMessage::EXCEPTION,
          connection->getQueueId(), Monitor::CONNECTION)) )
       {
          // ATTN-DE-P2-2003100503::TODO::Need to enhance code to return
          // an error message to Client application.
          Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
              "HTTPAcceptor::_acceptPipeConnection: Attempt to allocate entry in _entries table failed.");
          delete connection;
          //  May have to close the PIPE here...
          //Socket::close(socket);
          return;
 } }
  
       // Save the socket for cleanup later:
       connection->_entry_index = index;
       AutoMutex autoMut(_rep->_connection_mut);
       _rep->connections.append(connection);
   
     PEGASUS_STD(cout)
          << "in HTTPAcceptor::_acceptNamedPipeConnection() at the end" << PEGASUS_STD(endl);
   
   
   }
   #endif
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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