pegasus/src/Pegasus/Common/HTTPAcceptor.cpp - diff

Return to HTTPAcceptor.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/HTTPAcceptor.cpp between version 1.52.2.2 and 1.81.8.4

version 1.52.2.2, 2005/02/18 23:59:17

version 1.81.8.4, 2006/06/10 21:54:05

Line 1

//%2004////////////////////////////////////////////////////////////////////////

//%2006////////////////////////////////////////////////////////////////////////

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

Line 6

// IBM Corp.; EMC Corporation, The Open Group.

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; Symantec Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 33

Line 37

// 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

//%/////////////////////////////////////////////////////////////////////////////

Line 41

Line 51

#include <iostream>

#include "Socket.h"

#ifdef PEGASUS_PLATFORM_WIN32_IX86_MSVC

#ifdef PEGASUS_OS_TYPE_WINDOWS

#include <windows.h>

#else

# include <cctype>

Line 50

Line 60

# include <fcntl.h>

# include <netdb.h>

# include <netinet/in.h>

# include <netinet/tcp.h>

# include <arpa/inet.h>

# include <sys/socket.h>

# ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

# ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

# include <unistd.h>

# include <sys/un.h>

# endif

Line 69

Line 80

#include "OS400ConvertChar.h"

#endif

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

static int MAX_CONNECTION_QUEUE_LENGTH = -1;

////////////////////////////////////////////////////////////////////////////////

Line 89

Line 101

{

if (local)

{

#ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

#ifndef PEGASUS_OS_TYPE_WINDOWS

#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

address = reinterpret_cast<struct sockaddr*>(new struct sockaddr_un);

address_size = sizeof(struct sockaddr_un);

#else

PEGASUS_ASSERT(false);

#endif

}

else

{

Line 102

Line 118

address_size = sizeof(struct sockaddr_in);

}

~HTTPAcceptorRep()

{

delete address;

}

struct sockaddr* address;

#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)

PEGASUS_SOCKLEN_T address_size;

size_t address_size;

#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;

#else

int address_size;

#endif

Mutex _connection_mut;

Sint32 socket;

PEGASUS_SOCKET socket;

#ifdef PEGASUS_OS_TYPE_WINDOWS

NamedPipeServer* namedPipeServer;

#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

};

//------------------------------------------------------------------------------

// _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));

}

////////////////////////////////////////////////////////////////////////////////

// HTTPAcceptor

Line 129

Line 175

Boolean localConnection,

Uint32 portNumber,

SSLContext * sslcontext,

Boolean exportConnection)

Boolean exportConnection,

ReadWriteSem* sslContextObjectLock)

: Base(PEGASUS_QUEUENAME_HTTPACCEPTOR), // ATTN: Need unique names?

_monitor(monitor),

_outputMessageQueue(outputMessageQueue),

Line 138

Line 185

_localConnection(localConnection),

_portNumber(portNumber),

_sslcontext(sslcontext),

_exportConnection(exportConnection)

_exportConnection(exportConnection),

_sslContextObjectLock(sslContextObjectLock)

{

Socket::initializeInterface();

Line 180

Line 228

HTTPAcceptor::~HTTPAcceptor()

{

destroyConnections();

unbind();

// ATTN: Is this correct in a multi-HTTPAcceptor server?

Socket::uninitializeInterface();

Line 190

Line 239

if (! message)

return;

PEGASUS_ASSERT(_rep != 0);

switch (message->getType())

{

case SOCKET_MESSAGE:

Line 199

Line 249

// If this is a connection request:

if (socketMessage->socket == _rep->socket &&

socketMessage->events | SocketMessage::READ)

socketMessage->events & SocketMessage::READ)

{

_acceptConnection();

}

Line 212

Line 262

break;

}

#ifdef PEGASUS_OS_TYPE_WINDOWS

case NAMEDPIPE_MESSAGE:

{

NamedPipeMessage* namedPipeMessage = (NamedPipeMessage*)message;

// If this is a connection request:

if (((namedPipeMessage->namedPipe.getPipe()) == ( _rep->namedPipeServer->getPipe())) &&

(namedPipeMessage->events & NamedPipeMessage::READ))

{

_acceptNamedPipeConnection();

}

else

{

// ATTN! this can't happen!

Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor::handleEnqueue: Invalid NAMEDPIPE_MESSAGE received.");

}

break;

}

#endif

// may Need to close connection for Named Pipe too.....??

case CLOSE_CONNECTION_MESSAGE:

{

CloseConnectionMessage* closeConnectionMessage

Line 223

Line 296

for (Uint32 i = 0, n = _rep->connections.size(); i < n; i++)

{

HTTPConnection* connection = _rep->connections[i];

Sint32 socket = connection->getSocket();

PEGASUS_SOCKET socket = connection->getSocket();

if (socket == closeConnectionMessage->socket)

{

Line 287

Line 360

/**

_bind - creates a new server socket and bind socket to the port address.

If PEGASUS_LOCAL_DOMAIN_SOCKET is defined, the port number is ignored and

If PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET is not defined, the port number is ignored and

a domain socket is bound.

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);

// 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));

#endif

PEGASUS_STD(cout) << "in HTTPAcceptor::_bind After memset" << PEGASUS_STD(endl);

if (_localConnection)

{

#ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

#ifdef PEGASUS_OS_TYPE_WINDOWS

PEGASUS_STD(cout) << "in HTTPAcceptor::_bind before calling _createNamedPipe() " << PEGASUS_STD(endl);

// _rep->createNamedPipe();

_createNamedPipe();

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;

// #else

#endif

#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_family =

AF_UNIX;

strcpy(reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path,

Line 331

Line 432

else

{

_rep->socket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);

_setTCPNoDelay(_rep->socket);

}

if (_rep->socket < 0)

Line 349

Line 452

// set the close-on-exec bit for this file handle.

// any unix that forks needs this bit set.

#ifndef PEGASUS_PLATFORM_WIN32_IX86_MSVC

#if !defined PEGASUS_OS_TYPE_WINDOWS && !defined(PEGASUS_OS_VMS)

int sock_flags;

if( (sock_flags = fcntl(_rep->socket, F_GETFD, 0)) < 0)

{

Line 390

Line 493

throw BindFailedException(parms);

}

// Bind socket to port:

if (::bind(_rep->socket, _rep->address, _rep->address_size) < 0)

{

Socket::close(_rep->socket);

Line 406

Line 511

throw BindFailedException(parms);

}

// Get the actual port value used if the caller specified a port value of 0.

if ( _portNumber == 0 )

{

sockaddr_in buf;

PEGASUS_SOCKLEN_T bufSize = sizeof(buf);

if ( getsockname(_rep->socket, reinterpret_cast<sockaddr *>(&buf), &bufSize) == 0 )

{

_portNumber = ntohs(buf.sin_port);

}

// Change permissions on Linux local domain socket to allow writes by others.

#if defined(PEGASUS_LOCAL_DOMAIN_SOCKET) && defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)

#if !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET) && defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)

if (_localConnection)

{

if (::chmod( PEGASUS_LOCAL_DOMAIN_SOCKET_PATH,

Line 468

Line 588

"HTTPAcceptor::_bind: Failed to solicit socket messages(2).");

throw BindFailedException(parms);

}

PEGASUS_STD(cout) << "in HTTPAcceptor::_bind at the End" << PEGASUS_STD(endl);

}

/**

Line 485

Line 607

// close the socket

Socket::close(_rep->socket);

// Unlink Local Domain Socket Bug# 3312

if (_localConnection)

{

#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

PEG_TRACE_STRING(TRC_HTTP, Tracer::LEVEL2,

"HTTPAcceptor::closeConnectionSocket Unlinking local connection." );

::unlink(

reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path);

#else

PEGASUS_ASSERT(false);

#endif

}

else

{

Line 512

Line 647

/**

getOutstandingRequestCount - returns the number of outstanding requests.

Uint32 HTTPAcceptor::getOutstandingRequestCount()

Uint32 HTTPAcceptor::getOutstandingRequestCount() const

{

Uint32 count = 0;

if (_rep)

{

AutoMutex autoMut(_rep->_connection_mut);

if (_rep->connections.size() > 0)

{

HTTPConnection* connection = _rep->connections[0];

count = connection->getRequestCount();

}

return count;

}

/**

getPortNumber - returns the port number used for the connection

Uint32 HTTPAcceptor::getPortNumber() const

{

return _portNumber;

}

void HTTPAcceptor::unbind()

{

if (_rep)

{

_portNumber = 0;

Socket::close(_rep->socket);

if (_localConnection)

{

#ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

::unlink(

reinterpret_cast<struct sockaddr_un*>(_rep->address)->sun_path);

#else

Line 554

Line 700

void HTTPAcceptor::destroyConnections()

{

if (_rep)

{

// For each connection created by this object:

AutoMutex autoMut(_rep->_connection_mut);

for (Uint32 i = 0, n = _rep->connections.size(); i < n; i++)

{

HTTPConnection* connection = _rep->connections[i];

Sint32 socket = connection->getSocket();

PEGASUS_SOCKET socket = connection->getSocket();

// Unsolicit SocketMessages:

Line 570

Line 716

// Destroy the connection (causing it to close):

while (connection->refcount.value()) { }

while (connection->refcount.get()) { }

delete connection;

}

_rep->connections.clear();

}

void HTTPAcceptor::_acceptConnection()

Line 590

Line 736

// Accept the connection (populate the address):

struct sockaddr* accept_address;

#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)

PEGASUS_SOCKLEN_T address_size;

size_t address_size;

#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;

#else

int address_size;

#endif

if (_localConnection)

{

#ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

accept_address = reinterpret_cast<struct sockaddr*>(new struct sockaddr_un);

address_size = sizeof(struct sockaddr_un);

#else

Line 613

Line 753

address_size = sizeof(struct sockaddr_in);

}

Sint32 socket = accept(_rep->socket, accept_address, &address_size);

PEGASUS_SOCKET socket = accept(_rep->socket, accept_address, &address_size);

delete accept_address;

Line 630

Line 770

}

// set the close on exec flag

#ifndef PEGASUS_PLATFORM_WIN32_IX86_MSVC

#if !defined(PEGASUS_OS_TYPE_WINDOWS) && !defined(PEGASUS_OS_VMS)

int sock_flags;

if( (sock_flags = fcntl(socket, F_GETFD, 0)) < 0)

{

Line 649

Line 789

#endif

Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER, 0,

"HTTPAcceptor - accept() success. Socket: $1"

"HTTPAcceptor - accept() success. Socket: $1" ,socket));

,socket);

// Create a new conection and add it to the connection list:

AutoPtr<MP_Socket> mp_socket(new MP_Socket(

socket, _sslcontext, _sslContextObjectLock, _exportConnection));

AutoPtr<MP_Socket> mp_socket(new MP_Socket(socket, _sslcontext, _exportConnection));

// Perform the SSL handshake, if applicable. Make the socket non-blocking

if (mp_socket->accept() < 0)

// 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();

mp_socket->enableBlocking();

if (socketAcceptStatus < 0)

{

PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor: SSL_accept() failed");

Line 664

Line 811

return;

}

// Create a new connection and add it to the connection list:

HTTPConnection* connection = new HTTPConnection(_monitor, mp_socket,

this, static_cast<MessageQueue *>(_outputMessageQueue), _exportConnection);

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->solicitSocketMessages(

socket,

connection->getSocket(),

SocketMessage::READ | SocketMessage::EXCEPTION,

connection->getQueueId(), Monitor::CONNECTION)) )

{

Line 684

Line 840

return;

}

mp_socket.release();

// Save the socket for cleanup later:

connection->_entry_index = index;

AutoMutex autoMut(_rep->_connection_mut);

_rep->connections.append(connection);

}

AsyncDQueue<pegasus_acceptor> pegasus_acceptor::acceptors(true, 0);

#ifdef PEGASUS_OS_TYPE_WINDOWS

void HTTPAcceptor::_createNamedPipe()

void pegasus_acceptor::close_all_acceptors(void)

{

try

{

pegasus_acceptor* temp = acceptors.remove_first();

PEGASUS_STD(cout) << "in HTTPAcceptor::_createNamedPipe() at the begining" << PEGASUS_STD(endl);

while(temp)

{

delete temp;

temp = acceptors.remove_first();

}

catch(...)

{

}

_rep->namedPipeServer = new NamedPipeServer("\\\\.\\pipe\\MyNamedPipe");

PEGASUS_STD(cout) << "in HTTPAcceptor::_createNamedPipe() after calling the pipe server constructor" << PEGASUS_STD(endl);

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();

// Register to receive Messages on Connection pipe:

try {

acceptors.insert_first(this);

}

catch(...){

}

pegasus_acceptor::~pegasus_acceptor(void)

if ( -1 == ( _entry_index = _monitor->solicitPipeMessages(

{

*_rep->namedPipeServer,

unbind();

NamedPipeMessage::READ | NamedPipeMessage::EXCEPTION,

Socket::uninitializeInterface();

getQueueId(),

try {

Monitor::ACCEPTOR)))

acceptors.remove(this);

}

catch(...){

}

void pegasus_acceptor::bind()

{

::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_SOCKLEN_SIZE addr_size;

PEGASUS_STD(cout) << "in HTTPAcceptor::_createNamedPipe() _monitor->solicitSocketMessages failed" << PEGASUS_STD(endl);

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;

pegasus_socket temp(&sf, _sslcontext);

#else

bsd_socket_factory sf;

pegasus_socket temp(&sf);

#endif

_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

PEGASUS_STD(cout) << "in HTTPAcceptor::_createNamedPipe() at the end" << PEGASUS_STD(endl);

return;

_listener.listen(5);

// third step: add this listening socket to the monitor

_monitor->tickle();

_monitor->add_entry(_listener, LISTEN, this, this);

}

#endif

/** Unbind from the given port.

#ifdef PEGASUS_OS_TYPE_WINDOWS

void HTTPAcceptor::_acceptNamedPipeConnection()

void pegasus_acceptor::unbind()

{

// remove the socket from the monitor

PEGASUS_ASSERT(_rep != 0);

_monitor->remove_entry((Sint32)_listener);

// close the socket

if (!_rep)

_listener.close();

return;

}

cout <<"In HTTPAcceptor::_acceptNamedPipeConnection " << endl;

/** Close the connection socket.

// shouldnt we be using the private var....

// _namedPipeServer->accept()

void pegasus_acceptor::closeConnectionSocket()

{

unbind();

}

NamedPipeServerEndPiont nPSEndPoint = _rep->namedPipeServer->accept();

// Registerpe to receive Messages on Connection pipe:

/** Reopen the connection socket.

cout << " In _acceptNamedPipeConnection -- after calling namedPipeServer->accept()" << endl;

void pegasus_acceptor::reopenConnectionSocket()

{

bind();

}

HTTPConnection* connection = new HTTPConnection(_monitor, nPSEndPoint,

this, static_cast<MessageQueue *>(_outputMessageQueue), _exportConnection);

/** Returns the number of outstanding requests

/* NOT SURE WHAT TO DO HERE ....

if (socketAcceptStatus == 0)

Uint32 pegasus_acceptor::getOutstandingRequestCount()

{

return _monitor->getOutstandingRequestCount();

PEG_TRACE_STRING(TRC_HTTP, Tracer::LEVEL2,

"HTTPAcceptor: SSL_accept() pending");

connection->_acceptPending = true;

}

Boolean pegasus_acceptor::operator ==(const pegasus_acceptor& pa)

{

if(this == &pa)

return true;

return false;

}

Boolean pegasus_acceptor::operator ==(void* pa)

// Solicit events on this new connection's socket:

{

int index;

if((void*)this == pa)

return true;

return false;

}

cout << endl << connection->getNamedPipe().getName() << " has a this as a QueueID " <<

connection->getQueueId() << endl;

pegasus_acceptor* pegasus_acceptor::find_acceptor(Boolean local, Uint32 port)

if (-1 == (index = _monitor->solicitPipeMessages(

connection->getNamedPipe(),

NamedPipeMessage::READ | NamedPipeMessage::EXCEPTION,

connection->getQueueId(), Monitor::ACCEPTOR)) )

{

pegasus_acceptor* temp = 0;

// ATTN-DE-P2-2003100503::TODO::Need to enhance code to return

// an error message to Client application.

try {

Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,

acceptors.try_lock(pegasus_thread_self());

"HTTPAcceptor::_acceptPipeConnection: Attempt to allocate entry in _entries table failed.");

temp = acceptors.next(temp);

delete connection;

while(temp){

// May have to close the PIPE here...

if( local == true ){

//Socket::close(socket);

if(temp->_localConnection){

return;

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;

// Save the socket for cleanup later:

connection->_entry_index = index;

void pegasus_acceptor::accept_dispatch(monitor_2_entry *entry)

AutoMutex autoMut(_rep->_connection_mut);

{

_rep->connections.append(connection);

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

PEGASUS_STD(cout)

entry->set_dispatch ((void*)connection);

<< "in HTTPAcceptor::_acceptNamedPipeConnection() at the end" << PEGASUS_STD(endl);

monitor_2::insert_connection(connection);

}

#endif

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.52.2.2
changed lines
	Added in v.1.81.8.4

No CVS admin address has been configured