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.53 and 1.72

version 1.53, 2005/01/13 15:08:51

version 1.72, 2005/08/19 00:24:32

Line 1

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

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

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

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

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

Line 34

Line 36

// 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, VERITAS Software Corp.

// (david.dillard@veritas.com)

// John Alex, IBM (johnalex@us.ibm.com) for Bug#3312

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

Line 53

Line 61

# include <netinet/in.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 82

PEGASUS_NAMESPACE_BEGIN

// Determine the correct type to use for the length passed to getsockname().

// The default is to use the 'socklen_t'.

#if defined(PEGASUS_OS_TYPE_WINDOWS) || defined(PEGASUS_OS_OS400)

#define PEGASUS_SOCKLEN_T int

#endif

#if defined(PEGASUS_OS_HPUX) && !defined(_XOPEN_SOURCE_EXTENDED)

#define PEGASUS_SOCKLEN_T int

#endif

#if defined(PEGASUS_OS_VMS) || defined(PEGASUS_OS_ZOS)

#define PEGASUS_SOCKLEN_T unsigned

#endif

#ifndef PEGASUS_SOCKLEN_T

#define PEGASUS_SOCKLEN_T socklen_t

#endif

static int MAX_CONNECTION_QUEUE_LENGTH = -1;

Line 90

Line 121

{

if (local)

{

#ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

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

address_size = sizeof(struct sockaddr_un);

#else

Line 103

Line 134

address_size = sizeof(struct sockaddr_in);

}

~HTTPAcceptorRep()

{

delete address;

}

struct sockaddr* address;

#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)

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

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;

Line 130

Line 164

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 139

Line 174

_localConnection(localConnection),

_portNumber(portNumber),

_sslcontext(sslcontext),

_exportConnection(exportConnection)

_exportConnection(exportConnection),

_sslContextObjectLock(sslContextObjectLock)

{

Socket::initializeInterface();

Line 181

Line 217

HTTPAcceptor::~HTTPAcceptor()

{

destroyConnections();

unbind();

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

Socket::uninitializeInterface();

Line 191

Line 228

if (! message)

return;

PEGASUS_ASSERT(_rep != 0);

switch (message->getType())

{

case SOCKET_MESSAGE:

Line 200

Line 238

// If this is a connection request:

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

socketMessage->events | SocketMessage::READ)

socketMessage->events & SocketMessage::READ)

{

_acceptConnection();

}

Line 288

Line 326

/**

_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_ASSERT(_rep != 0);

// Create address:

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

if (_localConnection)

{

#ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

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

Line 389

// 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_PLATFORM_WIN32_IX86_MSVC && !defined(PEGASUS_OS_VMS)

int sock_flags;

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

{

Line 391

Line 430

throw BindFailedException(parms);

}

// Bind socket to port:

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

{

Socket::close(_rep->socket);

Line 407

Line 448

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_DISABLE_LOCAL_DOMAIN_SOCKET) && defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)

if (_localConnection)

{

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

delete _rep;

_rep = 0;

//l10n

//throw BindFailedException("Failed to bind socket");

MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_BIND_SOCKET",

"Failed to bind socket");

PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor::_bind: Failed to set domain socket permissions.");

throw BindFailedException(parms);

}

#endif

// Set up listening on the given socket:

//int const MAX_CONNECTION_QUEUE_LENGTH = 15;

Line 461

Line 542

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

Line 582

/**

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 530

Line 635

void HTTPAcceptor::destroyConnections()

{

if (_rep)

{

// For each connection created by this object:

AutoMutex autoMut(_rep->_connection_mut);

Line 551

Line 656

}

_rep->connections.clear();

}

void HTTPAcceptor::_acceptConnection()

Line 566

Line 671

// Accept the connection (populate the address):

struct sockaddr* accept_address;

#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)

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

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;

Line 576

Line 681

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 606

Line 711

}

// set the close on exec flag

#ifndef PEGASUS_PLATFORM_WIN32_IX86_MSVC

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

int sock_flags;

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

{

Line 629

Line 734

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

,socket);

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

AutoPtr<MP_Socket> mp_socket(new MP_Socket(

socket, _sslcontext, _sslContextObjectLock, _exportConnection));

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

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

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

if (socketAcceptStatus < 0)

if (mp_socket->accept() < 0)

{

PEG_TRACE_STRING(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,

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 663

Line 786

connection->_entry_index = index;

AutoMutex autoMut(_rep->_connection_mut);

_rep->connections.append(connection);

}

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;

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

_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

Legend:

Removed from v.1.53
changed lines
	Added in v.1.72

No CVS admin address has been configured