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.58 and 1.81.8.12

version 1.58, 2005/02/06 21:13:14

version 1.81.8.12, 2006/10/18 04:24:42

Line 1

//%2005////////////////////////////////////////////////////////////////////////

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

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

Line 8

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

Line 40

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

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 55

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 74

Line 81

#include "OS400ConvertChar.h"

#endif

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

static int MAX_CONNECTION_QUEUE_LENGTH = -1;

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

Line 94

Line 102

{

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 107

Line 120

address_size = sizeof(struct sockaddr_in);

}

~HTTPAcceptorRep()

{

delete address;

}

struct sockaddr* address;

#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_VMS)

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;

// Added for NamedPipe implementation for windows

#if defined PEGASUS_OS_TYPE_WINDOWS && !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET)

NamedPipeServer* namedPipeServer;

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

}

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

// HTTPAcceptor

Line 134

Line 169

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 143

Line 179

_localConnection(localConnection),

_portNumber(portNumber),

_sslcontext(sslcontext),

_exportConnection(exportConnection)

_exportConnection(exportConnection),

_sslContextObjectLock(sslContextObjectLock)

{

Socket::initializeInterface();

Line 185

Line 222

HTTPAcceptor::~HTTPAcceptor()

{

destroyConnections();

unbind();

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

Socket::uninitializeInterface();

Line 195

Line 233

if (! message)

return;

PEGASUS_ASSERT(_rep != 0);

switch (message->getType())

{

case SOCKET_MESSAGE:

Line 204

Line 243

// If this is a connection request:

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

socketMessage->events | SocketMessage::READ)

socketMessage->events & SocketMessage::READ)

{

_acceptConnection();

}

Line 218

Line 257

break;

}

// Added for NamedPipe implementation for windows

#if defined PEGASUS_OS_TYPE_WINDOWS && !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET)

case NAMEDPIPE_MESSAGE:

{

NamedPipeMessage* namedPipeMessage = (NamedPipeMessage*)message;

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 228

Line 288

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

{

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

Sint32 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

PEGASUS_SOCKET socket = connection->getSocket();

if (socket == closeConnectionMessage->socket)

{

Line 237

Line 302

delete connection;

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;

Line 292

Line 374

/**

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

{

#ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG

{

AutoMutex automut(Monitor::_cout_mut);

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

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

}

#endif

PEGASUS_ASSERT(_rep != 0);

// Create address:

#ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG

{

AutoMutex automut(Monitor::_cout_mut);

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

}

#endif

#if defined PEGASUS_OS_TYPE_WINDOWS

if (!_localConnection)

{

#endif

memset(_rep->address, 0, sizeof(*_rep->address));

#if defined PEGASUS_OS_TYPE_WINDOWS

}

#endif

#ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG

{

AutoMutex automut(Monitor::_cout_mut);

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

}

#endif

if (_localConnection)

{

#ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

// Added for NamedPipe implementation for windows

#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

# ifdef PEGASUS_OS_TYPE_WINDOWS

# ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG

{

AutoMutex automut(Monitor::_cout_mut);

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

<< PEGASUS_STD(endl);

}

# endif

_createNamedPipe();

# ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG

{

AutoMutex automut(Monitor::_cout_mut);

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

}

# endif

return;

# else // Other than Windows platform

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

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

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

# endif

#else

PEGASUS_ASSERT(false);

#endif

Line 328

Line 461

}

// Create socket:

if (_localConnection)

{

_rep->socket = socket(AF_UNIX, SOCK_STREAM, 0);

Line 336

Line 468

else

{

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

_setTCPNoDelay(_rep->socket);

}

if (_rep->socket < 0)

Line 354

Line 488

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

// any unix that forks needs this bit set.

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

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

int sock_flags;

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

{

Line 372

Line 506

}

#endif

// Set the socket option SO_REUSEADDR to reuse the socket address so

// that we can rebind to a new socket using the same address when we

Line 395

Line 528

throw BindFailedException(parms);

}

// Bind socket to port:

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

{

Socket::close(_rep->socket);

Line 412

Line 546

}

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

Line 584

#endif

// Set up listening on the given socket:

//int const MAX_CONNECTION_QUEUE_LENGTH = 15;

if (listen(_rep->socket, MAX_CONNECTION_QUEUE_LENGTH) < 0)

Line 473

Line 619

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

throw BindFailedException(parms);

}

#ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG

{

AutoMutex automut(Monitor::_cout_mut);

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

}

#endif

}

/**

Line 490

Line 643

// close the socket

Socket::close(_rep->socket);

// Unlink Local Domain Socket Bug# 3312

if (_localConnection)

{

#ifndef PEGASUS_OS_TYPE_WINDOWS

# 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

#endif

}

else

{

Line 517

Line 685

/**

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

# ifndef PEGASUS_OS_TYPE_WINDOWS

::unlink(

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

# endif

#else

PEGASUS_ASSERT(false);

#endif

Line 559

Line 741

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

// Added for NamedPipe implementation for windows

#if defined PEGASUS_OS_TYPE_WINDOWS && !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET)

if(!connection->isNamedPipeConnection())

{

#endif

PEGASUS_SOCKET socket = connection->getSocket();

// Unsolicit SocketMessages:

_monitor->unsolicitSocketMessages(socket);

// Added for NamedPipe implementation for windows

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

#if defined PEGASUS_OS_TYPE_WINDOWS && !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET)

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

}

else

{

NamedPipe namedPipe = connection->getNamedPipe();

_monitor->unsolicitPipeMessages(namedPipe);

}

#endif

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

delete connection;

}

_rep->connections.clear();

}

void HTTPAcceptor::_acceptConnection()

Line 593

Line 788

return;

// Accept the connection (populate the address):

struct sockaddr* accept_address;

#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_VMS)

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_OS_TYPE_WINDOWS

# ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

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

address_size = sizeof(struct sockaddr_un);

#else

PEGASUS_ASSERT(false);

#endif

}

else

{

Line 618

Line 808

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 635

Line 825

}

// set the close on exec flag

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

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

int sock_flags;

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

{

Line 654

Line 844

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

Line 866

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;

Line 693

Line 899

connection->_entry_index = index;

AutoMutex autoMut(_rep->_connection_mut);

_rep->connections.append(connection);

}

// Added for NamedPipe implementation for windows

#if defined PEGASUS_OS_TYPE_WINDOWS && !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET)

void HTTPAcceptor::_createNamedPipe()

{

#ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG

{

AutoMutex automut(Monitor::_cout_mut);

PEGASUS_STD(cout) << "Entering HTTPAcceptor::_createNamedPipe()." << PEGASUS_STD(endl);

}

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

}

{

AutoMutex automut(Monitor::_cout_mut);

cout << "Named pipe...in _createNamedPipe..." << _rep->namedPipeServer->getPipe() << endl;

}

#endif

// Register to receive Messages on Connection pipe:

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

*_rep->namedPipeServer,

NamedPipeMessage::READ | NamedPipeMessage::EXCEPTION,

getQueueId(),

Monitor::ACCEPTOR)))

{

::CloseHandle(_rep->namedPipeServer->getPipe());

delete _rep;

_rep = 0;

//l10n

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 pipe messages(2).");

throw BindFailedException(parms);

#ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG

{

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

}

#endif

return;

}

void HTTPAcceptor::_acceptNamedPipeConnection()

{

PEGASUS_ASSERT(_rep != 0);

if (!_rep)

return;

#ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG

{

AutoMutex automut(Monitor::_cout_mut);

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

}

#endif

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

// Register to receive Messages on Connection pipe:

#ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG

{

AutoMutex automut(Monitor::_cout_mut);

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

}

#endif

HTTPConnection* connection = new HTTPConnection(_monitor, nPSEndPoint,

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

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

int index;

#ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG

{

AutoMutex automut(Monitor::_cout_mut);

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

connection->getQueueId() << endl;

}

#endif

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

connection->getNamedPipe(),

NamedPipeMessage::READ | NamedPipeMessage::EXCEPTION,

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

{

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

return;

}

// Save the socket for cleanup later:

connection->_entry_index = index;

AutoMutex autoMut(_rep->_connection_mut);

_rep->connections.append(connection);

#ifdef PEGASUS_LOCALDOMAINSOCKET_DEBUG

{

AutoMutex automut(Monitor::_cout_mut);

PEGASUS_STD(cout)

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

}

#endif

}

#endif

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.58
changed lines
	Added in v.1.81.8.12

No CVS admin address has been configured