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.24.2.2 and 1.61

version 1.24.2.2, 2002/10/30 21:20:03

version 1.61, 2005/02/15 01:28:51

Line 1

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

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

// The Open Group, Tivoli Systems

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

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

Line 32

// Modified By:

// Jenny Yu, Hewlett-Packard Company (jenny_yu@hp.com)

// Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)

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

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

Line 38

Line 50

#include <windows.h>

#else

# include <cctype>

# include <unistd.h>

# include <cstdlib>

# include <errno.h>

# include <fcntl.h>

Line 47

Line 58

# include <arpa/inet.h>

# include <sys/socket.h>

# ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

# include <unistd.h>

# include <sys/un.h>

# endif

#endif

Line 56

Line 68

#include "HTTPAcceptor.h"

#include "HTTPConnection.h"

#include "Tracer.h"

#include <Pegasus/Common/MessageLoader.h> //l10n

#ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM

#include "OS400ConvertChar.h"

#endif

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

static int MAX_CONNECTION_QUEUE_LENGTH = -1;

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

// HTTPAcceptorRep

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

struct HTTPAcceptorRep

class HTTPAcceptorRep

{

public:

HTTPAcceptorRep(Boolean local)

{

if (local)

{

#ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

struct sockaddr_un address;

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

address_size = sizeof(struct sockaddr_un);

#else

PEGASUS_ASSERT(false);

#endif

}

else

{

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

address_size = sizeof(struct sockaddr_in);

}

struct sockaddr* address;

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

#else

struct sockaddr_in address;

int address_size;

#endif

Mutex _connection_mut;

Line 86

Line 129

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

HTTPAcceptor::HTTPAcceptor(Monitor* monitor, MessageQueue* outputMessageQueue)

HTTPAcceptor::HTTPAcceptor(Monitor* monitor,

: Base(PEGASUS_QUEUENAME_HTTPACCEPTOR),

MessageQueue* outputMessageQueue,

_monitor(monitor), _outputMessageQueue(outputMessageQueue),

Boolean localConnection,

_rep(0), _sslcontext(NULL), _entry_index(-1)

Uint32 portNumber,

{

SSLContext * sslcontext,

Boolean exportConnection,

_inet_address[0] = 0x00;

ReadWriteSem* sslContextObjectLock)

Socket::initializeInterface();

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

}

_monitor(monitor),

_outputMessageQueue(outputMessageQueue),

HTTPAcceptor::HTTPAcceptor(Monitor* monitor, MessageQueue* outputMessageQueue,

SSLContext * sslcontext)

: Base(PEGASUS_QUEUENAME_HTTPACCEPTOR),

_monitor(monitor), _outputMessageQueue(outputMessageQueue),

_rep(0),

_entry_index(-1),

_localConnection(localConnection),

_portNumber(portNumber),

_sslcontext(sslcontext),

_entry_index(-1)

_exportConnection(exportConnection),

_sslContextObjectLock(sslContextObjectLock)

{

_inet_address[0] = 0x00;

Socket::initializeInterface();

Platforms interpret the value of MAX_CONNECTION_QUEUE_LENGTH 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 prevent clients from

being dropped. Instead of hard coding the 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.

//To engage runtime backlog queue length: uncomment the following block AND comment out the line MAX_CONNECTION_QUEUE_LENGTH = 15

if(MAX_CONNECTION_QUEUE_LENGTH == -1){

#ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM

#pragma convert(37)

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

EtoA(env);

#pragma convert(0)

#else

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

#endif

if(!env){

MAX_CONNECTION_QUEUE_LENGTH = 15;

}else{

char *end = NULL;

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

if(*end)

MAX_CONNECTION_QUEUE_LENGTH = 15;

cout << " MAX_CONNECTION_QUEUE_LENGTH = " << MAX_CONNECTION_QUEUE_LENGTH << endl;

}

MAX_CONNECTION_QUEUE_LENGTH = 15;

HTTPAcceptor::HTTPAcceptor(Monitor* monitor, MessageQueue* outputMessageQueue,

SSLContext * sslcontext,

char *inet_address)

: Base(PEGASUS_QUEUENAME_HTTPACCEPTOR),

_monitor(monitor), _outputMessageQueue(outputMessageQueue),

_rep(0),

_sslcontext(sslcontext),

_entry_index(-1)

{

strncpy(_inet_address, inet_address, 16);

_inet_address[16] = 0x00;

Socket::initializeInterface();

}

HTTPAcceptor::~HTTPAcceptor()

{

unbind();

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

Socket::uninitializeInterface();

}

Line 149

Line 213

else

{

// ATTN! this can't happen!

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

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

}

break;

Line 159

Line 225

CloseConnectionMessage* closeConnectionMessage

= (CloseConnectionMessage*)message;

_rep->_connection_mut.lock(pegasus_thread_self());

AutoMutex autoMut(_rep->_connection_mut);

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

{

Line 171

Line 237

_monitor->unsolicitSocketMessages(socket);

_rep->connections.remove(i);

delete connection;

PEGASUS_STD(cout) << "Closing HTTP Connection; Current Connection Table Size: " <<

_rep->connections.size() << PEGASUS_STD(endl);

break;

}

_rep->_connection_mut.unlock();

break;

}

default:

// ATTN: need unexpected message error!

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

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

break;

};

Line 193

Line 260

Message* message = dequeue();

if (!message)

{

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

"HTTPAcceptor::handleEnqueue(): No message on queue.");

return;

}

handleEnqueue(message);

}

void HTTPAcceptor::bind(Uint32 portNumber)

void HTTPAcceptor::bind()

{

if (_rep)

if (_rep){

throw BindFailedException("HTTPAcceptor already bound");

//l10n

//throw BindFailedException("HTTPAcceptor already bound");

_rep = new HTTPAcceptorRep;

MessageLoaderParms parms("Common.HTTPAcceptor.ALREADY_BOUND",

"HTTPAcceptor already bound");

_portNumber = portNumber;

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

"HTTPAcceptor::bind: HTTPAcceptor already bound.");

throw BindFailedException(parms);

}

_rep = new HTTPAcceptorRep(_localConnection);

// bind address

_bind();

Line 224

Line 302

// Create address:

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

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

if (_localConnection)

{

#ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

_rep->address.sun_family = AF_UNIX;

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

strcpy(_rep->address.sun_path, "/var/opt/wbem/cimxml.socket");

AF_UNIX;

::unlink(_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);

#else

if(_inet_address[0] != 0x00)

PEGASUS_ASSERT(false);

{

#endif

_rep->address.sin_addr.s_addr = inet_addr(_inet_address);

cout << "binding to " << _inet_address << endl;

}

else

{

_rep->address.sin_addr.s_addr = INADDR_ANY;

reinterpret_cast<struct sockaddr_in*>(_rep->address)->sin_addr.s_addr =

INADDR_ANY;

reinterpret_cast<struct sockaddr_in*>(_rep->address)->sin_family =

AF_INET;

reinterpret_cast<struct sockaddr_in*>(_rep->address)->sin_port =

htons(_portNumber);

}

_rep->address.sin_family = AF_INET;

_rep->address.sin_port = htons(_portNumber);

#endif

// Create socket:

#ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

if (_localConnection)

{

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

#else

}

else

{

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

#endif

}

if (_rep->socket < 0)

{

delete _rep;

_rep = 0;

throw BindFailedException("Failed to create socket");

//l10n

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

MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_CREATE_SOCKET",

"Failed to create socket");

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

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

throw BindFailedException(parms);

}

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

int sock_flags;

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

{

PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor::_bind: fcntl(F_GETFD) failed");

}

else

{

sock_flags |= FD_CLOEXEC;

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

{

PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor::_bind: fcntl(F_SETFD) failed");

}

#endif

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

Line 271

Line 385

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

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

{

Socket::close(_rep->socket);

delete _rep;

_rep = 0;

throw BindFailedException("Failed to set socket option");

//l10n

//throw BindFailedException("Failed to set socket option");

MessageLoaderParms parms("Common.HTTPAcceptor.FAILED_SET_SOCKET_OPTION",

"Failed to set socket option");

PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor::_bind: Failed to set socket option.");

throw BindFailedException(parms);

}

// Bind socket to port:

if (::bind(_rep->socket,

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

reinterpret_cast<struct sockaddr*>(&_rep->address),

sizeof(_rep->address)) < 0)

{

Socket::close(_rep->socket);

delete _rep;

_rep = 0;

throw BindFailedException("Failed to bind socket");

//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 bind socket.");

throw BindFailedException(parms);

}

// 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 (_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 = 5;

//int const MAX_CONNECTION_QUEUE_LENGTH = 15;

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

{

Socket::close(_rep->socket);

delete _rep;

_rep = 0;

throw BindFailedException("Failed to bind socket");

//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 bind socket(1).");

throw BindFailedException(parms);

}

// Register to receive SocketMessages on this socket:

Line 311

Line 467

Socket::close(_rep->socket);

delete _rep;

_rep = 0;

throw BindFailedException("Failed to solicit socket messaeges");

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

}

Line 324

Line 486

if (_rep)

{

// unregister the socket

_monitor->unsolicitSocketMessages(_rep->socket);

// ATTN - comment out - see CIMServer::stopClientConnection()

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

// close the socket

Socket::close(_rep->socket);

}

else

{

PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor::closeConnectionSocket failure _rep is null." );

}

/**

Line 340

Line 509

{

_bind();

}

else

{

PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor::reopenConnectionSocket failure _rep is null." );

}

/**

Line 349

Line 523

{

Uint32 count = 0;

_rep->_connection_mut.lock(pegasus_thread_self());

AutoMutex autoMut(_rep->_connection_mut);

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

{

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

count = connection->getRequestCount();

}

_rep->_connection_mut.unlock();

return count;

}

void HTTPAcceptor::unbind()

Line 365

Line 538

if (_rep)

{

Socket::close(_rep->socket);

if (_localConnection)

{

#ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

::unlink(

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

#else

PEGASUS_ASSERT(false);

#endif

}

delete _rep;

_rep = 0;

}

else

{

PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor::unbind failure _rep is null." );

}

void HTTPAcceptor::destroyConnections()

{

// For each connection created by this object:

_rep->_connection_mut.lock(pegasus_thread_self());

AutoMutex autoMut(_rep->_connection_mut);

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

{

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

Line 391

Line 582

}

_rep->connections.clear();

_rep->_connection_mut.unlock();

}

void HTTPAcceptor::_acceptConnection()

Line 405

Line 596

// Accept the connection (populate the address):

sockaddr_in address;

struct sockaddr* accept_address;

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

size_t address_size;

#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_PLATFORM_AIX_RS_IBMCXX)

#elif defined(PEGASUS_PLATFORM_AIX_RS_IBMCXX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || (defined(PEGASUS_OS_SOLARIS) && !defined(SUNOS_5_6))

size_t n = sizeof(address);

socklen_t address_size;

#else

int n = sizeof(address);

int address_size;

#endif

if (_localConnection)

#if defined(PEGASUS_PLATFORM_LINUX_IX86_GNU) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)

{

Sint32 socket = accept(

#ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

_rep->socket, (struct sockaddr*)&address, (socklen_t *)&n);

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

address_size = sizeof(struct sockaddr_un);

#else

Sint32 socket = accept(_rep->socket, reinterpret_cast<struct sockaddr*>(&address), &n);

PEGASUS_ASSERT(false);

#endif

}

else

{

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

address_size = sizeof(struct sockaddr_in);

}

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

delete accept_address;

if (socket < 0)

{

PEG_TRACE_STRING(TRC_HTTP, Tracer::LEVEL2,

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

"HTTPAcceptor - accept() failure. errno: $0"

,errno);

PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor: accept() failed");

return;

}

#if defined(PEGASUS_PLATFORM_LINUX_IX86_GNU) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)

if( _inet_address[0] != 0x00)

// set the close on exec flag

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

int sock_flags;

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

{

if( 1023 < htons(address.sin_port) )

PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor: fcntl(F_GETFD) failed");

}

else

{

shutdown(socket, 2);

sock_flags |= FD_CLOEXEC;

Socket::close(socket);

if (fcntl(socket, F_SETFD, sock_flags) < 0)

return;

{

PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor: fcntl(F_SETFD) failed");

}

#endif

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

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

,socket);

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

MP_Socket * mp_socket = new MP_Socket(socket, _sslcontext);

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

if (mp_socket->accept() < 0)

Sint32 retVal;

if (_sslcontext)

{

PEG_TRACE_STRING(TRC_HTTP, Tracer::LEVEL2,

// For SSL connections, obtain read lock to SSLContext object before

// calling the accept() method of MP_Socket.

ReadLock rlock(*_sslContextObjectLock);

retVal = mp_socket->accept();

}

else

{

retVal = mp_socket->accept();

}

if (retVal < 0)

{

PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"HTTPAcceptor: SSL_accept() failed");

mp_socket->close();

return;

}

HTTPConnection* connection = new HTTPConnection(

HTTPConnection* connection = new HTTPConnection(_monitor, mp_socket,

_monitor, mp_socket, this, static_cast<MessageQueue *>(_outputMessageQueue));

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

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

int index;

if (! (index = _monitor->solicitSocketMessages(

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

socket,

connection->getSocket(),

SocketMessage::READ | SocketMessage::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::_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;

_rep->_connection_mut.lock(pegasus_thread_self());

AutoMutex autoMut(_rep->_connection_mut);

_rep->connections.append(connection);

_rep->_connection_mut.unlock();

PEGASUS_STD(cout) << "Creating new HTTP Connection; Current Connection Table Size: " <<

_rep->connections.size() << " entries" << endl;

}

Legend:

Removed from v.1.24.2.2
changed lines
	Added in v.1.61

No CVS admin address has been configured