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.99.2.2 and 1.116

version 1.99.2.2, 2007/06/12 09:31:58

version 1.116, 2008/02/26 19:15:05

Line 44

#include "Tracer.h"

#include <Pegasus/Common/MessageLoader.h>

#ifdef PEGASUS_OS_PASE

# include <as400_protos.h>

# include <Pegasus/Common/PaseCcsid.h>

#endif

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

static int MAX_CONNECTION_QUEUE_LENGTH = -1;

static int _maxConnectionQueueLength = -1;

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

Line 94

Line 99

~HTTPAcceptorRep()

{

closeSocket();

delete address;

}

void closeSocket()

{

Socket::close(socket);

}

struct sockaddr* address;

SocketLength address_size;

Line 126

Line 138

_connectionType(connectionType),

_portNumber(portNumber),

_sslcontext(sslcontext),

_sslContextObjectLock(sslContextObjectLock)

_sslContextObjectLock(sslContextObjectLock),

_idleConnectionTimeoutSeconds(0)

{

_localConnection = connectionType == LOCAL_CONNECTION;

Socket::initializeInterface();

Platforms interpret the value of MAX_CONNECTION_QUEUE_LENGTH

Platforms interpret the value of _maxConnectionQueueLength

differently. Some platforms interpret the value literally, while

others multiply a fudge factor. When the server is under stress from

multiple clients with multiple requests, toggling this number may

Line 140

Line 152

value, we allow an environment variable to be set which specifies a

number greater than the maximum concurrent client connections

possible. If this environment var is not specified, then

MAX_CONNECTION_QUEUE_LENGTH = 15.

_maxConnectionQueueLength = 15.

//To engage runtime backlog queue length: uncomment the following block AND

//comment out the line MAX_CONNECTION_QUEUE_LENGTH = 15

//comment out the line _maxConnectionQueueLength = 15

if (MAX_CONNECTION_QUEUE_LENGTH == -1)

if (_maxConnectionQueueLength == -1)

{

const char* env = getenv("PEGASUS_MAX_BACKLOG_CONNECTION_QUEUE");

if (!env)

{

MAX_CONNECTION_QUEUE_LENGTH = 15;

_maxConnectionQueueLength = 15;

}

else

{

char* end = NULL;

MAX_CONNECTION_QUEUE_LENGTH = strtol(env, &end, 10);

_maxConnectionQueueLength = strtol(env, &end, 10);

if (*end)

MAX_CONNECTION_QUEUE_LENGTH = 15;

_maxConnectionQueueLength = 15;

cout << " MAX_CONNECTION_QUEUE_LENGTH = " <<

cout << " _maxConnectionQueueLength = " <<

MAX_CONNECTION_QUEUE_LENGTH << endl;

_maxConnectionQueueLength << endl;

}

MAX_CONNECTION_QUEUE_LENGTH = 15;

#ifdef PEGASUS_WMIMAPPER

//The WMI Mapper can be used as a proxy to multiple WMI Servers.

//If a client application simultaneously initiates connections

//to many Windows systems, many of these connections may be routed

//to a single WMI Mapper. A larger _maxConnectionQueueLength

//value is required to allow these connections to be initiated

//successfully.

_maxConnectionQueueLength = 40;

#else

_maxConnectionQueueLength = 15;

#endif

}

HTTPAcceptor::~HTTPAcceptor()

Line 280

Line 302

void HTTPAcceptor::_bind()

{

#ifdef PEGASUS_OS_PASE

// bind need ccsid is 819

int orig_ccsid;

orig_ccsid = _SETCCSID(-1);

if (orig_ccsid == -1)

{

PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

String("HTTPAcceptor::_bind: Can not get current PASE CCSID."));

orig_ccsid = 1208;

}

PaseCcsid ccsid(819, orig_ccsid);

#endif

PEGASUS_ASSERT(_rep != 0);

// Create address:

memset(_rep->address, 0, _rep->address_size);

if (_localConnection)

if (_connectionType == LOCAL_CONNECTION)

{

#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

// Make sure the local domain socket can be owned by the cimserver

// user. Otherwise, the bind may fail with a vague "bind failed"

// error.

if (System::exists(PEGASUS_LOCAL_DOMAIN_SOCKET_PATH))

{

if (!System::removeFile(PEGASUS_LOCAL_DOMAIN_SOCKET_PATH))

{

throw CannotRemoveFile(PEGASUS_LOCAL_DOMAIN_SOCKET_PATH);

}

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

AF_UNIX;

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

PEGASUS_LOCAL_DOMAIN_SOCKET_PATH);

::unlink(

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

#else

PEGASUS_ASSERT(false);

#endif

Line 324

Line 370

// Create socket:

if (_localConnection)

if (_connectionType == LOCAL_CONNECTION)

{

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

}

Line 350

Line 396

MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_CREATE_SOCKET",

"Failed to create socket");

PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor::_bind _rep->socket < 0");

"HTTPAcceptor::_bind: createSocket() _rep->socket failed");

throw BindFailedException(parms);

}

Socket::disableBlocking(_rep->socket);

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

// any unix that forks needs this bit set.

Line 386

Line 433

if (setsockopt(_rep->socket, SOL_SOCKET, SO_REUSEADDR,

(char *)&opt, sizeof(opt)) < 0)

{

Socket::close(_rep->socket);

delete _rep;

_rep = 0;

MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_SET_SOCKET_OPTION",

Line 402

Line 448

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

{

Socket::close(_rep->socket);

MessageLoaderParms parms(

"Common.HTTPAcceptor.FAILED_BIND_SOCKET_DETAIL",

"Failed to bind socket on port $0: $1.",

_portNumber, PEGASUS_SYSTEM_NETWORK_ERRORMSG_NLS);

delete _rep;

_rep = 0;

MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_BIND_SOCKET",

"Failed to bind socket");

PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor::_bind: Failed to bind socket.");

throw BindFailedException(parms);

Line 435

Line 483

#if !defined(PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET) && \

(defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || \

defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM))

if (_localConnection)

if (_connectionType == LOCAL_CONNECTION)

{

if (::chmod(PEGASUS_LOCAL_DOMAIN_SOCKET_PATH,

S_IRUSR | S_IWUSR | S_IXUSR |

S_IRGRP | S_IWGRP | S_IXGRP |

S_IROTH | S_IWOTH | S_IXOTH ) < 0 )

{

Socket::close(_rep->socket);

MessageLoaderParms parms(

"Common.HTTPAcceptor.FAILED_SET_LDS_FILE_OPTION",

"Failed to set permission on local domain socket {0}: {1}.",

PEGASUS_LOCAL_DOMAIN_SOCKET_PATH,

PEGASUS_SYSTEM_ERRORMSG_NLS );

delete _rep;

_rep = 0;

MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_BIND_SOCKET",

"Failed to bind socket");

PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor::_bind: Failed to set domain socket "

"permissions.");

Line 457

Line 508

// Set up listening on the given socket:

//int const MAX_CONNECTION_QUEUE_LENGTH = 15;

//int const _maxConnectionQueueLength = 15;

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

if (::listen(_rep->socket, _maxConnectionQueueLength) < 0)

{

Socket::close(_rep->socket);

MessageLoaderParms parms(

"Common.HTTPAcceptor.FAILED_LISTEN_SOCKET",

"Failed to listen on socket {0}: {1}.",

(int)_rep->socket,PEGASUS_SYSTEM_NETWORK_ERRORMSG_NLS );

delete _rep;

_rep = 0;

MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_BIND_SOCKET",

"Failed to bind socket");

PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor::_bind: Failed to bind socket(1).");

throw BindFailedException(parms);

Line 477

Line 530

_rep->socket,

SocketMessage::READ | SocketMessage::EXCEPTION,

getQueueId(),

Monitor::ACCEPTOR)))

MonitorEntry::TYPE_ACCEPTOR)))

{

Socket::close(_rep->socket);

delete _rep;

_rep = 0;

MessageLoaderParms parms(

Line 505

Line 557

//_monitor->unsolicitSocketMessages(_rep->socket);

// close the socket

Socket::close(_rep->socket);

_rep->closeSocket();

// Unlink Local Domain Socket Bug# 3312

if (_localConnection)

if (_connectionType == LOCAL_CONNECTION)

{

#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

PEG_TRACE_CSTRING(TRC_HTTP, Tracer::LEVEL2,

Line 554

Line 606

// unregister the socket

_monitor->unsolicitSocketMessages(_rep->socket);

// close the socket

Socket::close(_rep->socket);

_rep->closeSocket();

// Unlink Local Domain Socket Bug# 3312

// Unlink Local Domain Socket

if (_localConnection)

if (_connectionType == LOCAL_CONNECTION)

{

#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

PEG_TRACE_CSTRING(TRC_HTTP, Tracer::LEVEL2,

Line 587

Line 639

if (_rep)

{

AutoMutex autoMut(_rep->_connection_mut);

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

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

{

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

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

count = connection->getRequestCount();

if (connection->isResponsePending())

{

count++;

}

return count;

Line 610

Line 665

_socketWriteTimeout = socketWriteTimeout;

}

void HTTPAcceptor::setIdleConnectionTimeout(Uint32 idleConnectionTimeoutSeconds)

{

_idleConnectionTimeoutSeconds = idleConnectionTimeoutSeconds;

}

void HTTPAcceptor::unbind()

{

if (_rep)

{

_portNumber = 0;

Socket::close(_rep->socket);

_rep->closeSocket();

if (_localConnection)

if (_connectionType == LOCAL_CONNECTION)

{

#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

::unlink(

Line 674

Line 734

struct sockaddr* accept_address;

SocketLength address_size;

if (_localConnection)

if (_connectionType == LOCAL_CONNECTION)

{

#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

accept_address =

Line 698

Line 758

#endif

}

SocketHandle socket;

// It is not necessary to handle EINTR errors from this accept() call.

#ifdef PEGASUS_OS_TYPE_WINDOWS

// An EINTR error should not occur on a non-blocking socket. If the

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

// listen socket is blocking and EINTR occurs, the new socket connection

#else

// is not accepted here.

while (

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

// EAGAIN errors are also not handled here. An EAGAIN error should not

&& (errno == EINTR))

// occur after select() indicates that the listen socket is available for

;

// reading. If the accept() fails with an EAGAIN error code, a new

#endif

// connection is not accepted here.

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

if (socket == PEGASUS_SOCKET_ERROR)

{

Line 732

Line 794

return;

}

// Use an AutoPtr to ensure the socket handle is closed on exception

AutoPtr<SocketHandle, CloseSocketHandle> socketPtr(&socket);

#ifndef PEGASUS_OS_TYPE_WINDOWS

// We need to ensure that the socket number is not higher than

// what fits into FD_SETSIZE, because we else won't be able to select on it

// and won't ever communicate correct on that socket.

if (socket >= FD_SETSIZE)

{

// the remote connection is invalid, destroy client address.

delete accept_address;

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

"HTTPAcceptor out of available sockets. "

"Closing connection to the new client.");

PEG_TRACE(

(TRC_DISCARDED_DATA,

Tracer::LEVEL2,

"accept() returned too large socket number %d.",

socket));

return;

}

#endif

String ipAddress;

if (_localConnection)

if (_connectionType == LOCAL_CONNECTION)

{

ipAddress = "localhost";

}

Line 743

Line 831

#ifdef PEGASUS_ENABLE_IPV6

char ipBuffer[PEGASUS_INET6_ADDRSTR_LEN];

int rc;

if ((rc = getnameinfo(accept_address, address_size, ipBuffer,

if ((rc = System::getNameInfo(accept_address,

PEGASUS_INET6_ADDRSTR_LEN, 0, 0, NI_NUMERICHOST)))

address_size,

ipBuffer,

PEGASUS_INET6_ADDRSTR_LEN,

NI_NUMERICHOST)))

{

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

"HTTPAcceptor - getnameinfo() failure. rc: $0", rc);

PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor: getnameinfo() failed");

delete accept_address;

return;

}

ipAddress = ipBuffer;

Line 791

Line 885

SharedPtr<MP_Socket> mp_socket(new MP_Socket(

socket, _sslcontext, _sslContextObjectLock, ipAddress));

// mp_socket now has responsibility for closing the socket handle

socketPtr.release();

mp_socket->disableBlocking();

mp_socket->setSocketWriteTimeout(_socketWriteTimeout);

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

// Perform the SSL handshake, if applicable.

// 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_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor: SSL_accept() failed");

mp_socket->close();

return;

}

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

HTTPConnection* connection = new HTTPConnection(_monitor, mp_socket,

AutoPtr<HTTPConnection> connection(new HTTPConnection(

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

_monitor,

mp_socket,

ipAddress,

this,

static_cast<MessageQueue *>(_outputMessageQueue)));

if (_idleConnectionTimeoutSeconds)

{

connection->_idleConnectionTimeoutSeconds =

_idleConnectionTimeoutSeconds;

Time::gettimeofday(&connection->_idleStartTime);

}

if (socketAcceptStatus == 0)

{

PEG_TRACE_CSTRING(TRC_HTTP, Tracer::LEVEL2,

"HTTPAcceptor: SSL_accept() pending");

connection->_acceptPending = true;

Time::gettimeofday(&connection->_acceptPendingStartTime);

}

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

Line 828

Line 932

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

connection->getSocket(),

SocketMessage::READ | SocketMessage::EXCEPTION,

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

connection->getQueueId(), MonitorEntry::TYPE_CONNECTION)) )

{

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

// an error message to Client application.

PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor::_acceptConnection: Attempt to allocate entry in "

"_entries table failed.");

delete connection;

Socket::close(socket);

return;

}

// Save the socket for cleanup later:

connection->_entry_index = index;

AutoMutex autoMut(_rep->_connection_mut);

_rep->connections.append(connection);

_rep->connections.append(connection.get());

connection.release();

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.99.2.2
changed lines
	Added in v.1.116

No CVS admin address has been configured