XmlRpc::XmlRpcServerConnection Class Reference

A class to handle XML RPC requests from a particular client. More...

#include <XmlRpcServerConnection.h>

Inheritance diagram for XmlRpc::XmlRpcServerConnection:

Public Member Functions
	XmlRpcServerConnection (int fd, XmlRpcServer *server, bool deleteOnClose=false)
	Constructor.
virtual	~XmlRpcServerConnection ()
	Destructor.
virtual unsigned	handleEvent (unsigned eventType)
Public Member Functions inherited from XmlRpc::XmlRpcSource
	XmlRpcSource (int fd=-1, bool deleteOnClose=false)
virtual	~XmlRpcSource ()
	Destructor.
int	getfd () const
	Return the file descriptor being monitored.
void	setfd (int fd)
	Specify the file descriptor to monitor.
bool	getKeepOpen () const
	Return whether the file descriptor should be kept open if it is no longer monitored.
void	setKeepOpen (bool b=true)
	Specify whether the file descriptor should be kept open if it is no longer monitored.
virtual void	close ()

Static Public Attributes
static const char	METHODNAME_TAG [] = "<methodName>"
static const char	PARAMS_TAG [] = "<params>"
static const char	PARAMS_ETAG [] = "</params>"
static const char	PARAM_TAG [] = "<param>"
static const char	PARAM_ETAG [] = "</param>"
static const std::string	SYSTEM_MULTICALL = "system.multicall"
static const std::string	METHODNAME = "methodName"
static const std::string	PARAMS = "params"
static const std::string	FAULTCODE = "faultCode"
static const std::string	FAULTSTRING = "faultString"

Protected Types
enum	ServerConnectionState { READ_HEADER , READ_REQUEST , WRITE_RESPONSE }

Protected Member Functions
bool	readHeader ()
bool	readRequest ()
bool	writeResponse ()
virtual void	executeRequest ()
std::string	parseRequest (XmlRpcValue &params)
bool	executeMethod (const std::string &methodName, XmlRpcValue &params, XmlRpcValue &result)
bool	executeMulticall (const std::string &methodName, XmlRpcValue &params, XmlRpcValue &result)
void	generateResponse (std::string const &resultXml)
void	generateFaultResponse (std::string const &msg, int errorCode=-1)
std::string	generateHeader (std::string const &body)

Protected Attributes
XmlRpcServer *	_server
ServerConnectionState	_connectionState
std::string	_header
int	_contentLength
std::string	_request
std::string	_response
int	_bytesWritten
bool	_keepAlive

Detailed Description

A class to handle XML RPC requests from a particular client.

Definition at line 24 of file XmlRpcServerConnection.h.

Member Enumeration Documentation

ServerConnectionState

enum XmlRpc::XmlRpcServerConnection::ServerConnectionState

protected

Enumerator
READ_HEADER
READ_REQUEST
WRITE_RESPONSE

Definition at line 78 of file XmlRpcServerConnection.h.

{ READ_HEADER, READ_REQUEST, WRITE_RESPONSE };

Constructor & Destructor Documentation

XmlRpcServerConnection()

XmlRpcServerConnection::XmlRpcServerConnection	(	int	fd,
		XmlRpcServer *	server,
		bool	deleteOnClose = false )

Constructor.

Definition at line 29 of file XmlRpcServerConnection.cpp.

    : XmlRpcSource( fd, deleteOnClose ) {
  XmlRpcUtil::log( 2, "XmlRpcServerConnection: new socket %d.", fd );
  _server          = server;
  _connectionState = READ_HEADER;
  _keepAlive       = true;
}

~XmlRpcServerConnection()

XmlRpcServerConnection::~XmlRpcServerConnection ( )

virtual

Destructor.

Definition at line 38 of file XmlRpcServerConnection.cpp.

                                                {
  XmlRpcUtil::log( 4, "XmlRpcServerConnection dtor." );
  _server->removeConnection( this );
}

Member Function Documentation

executeMethod()

bool XmlRpcServerConnection::executeMethod ( const std::string & methodName, XmlRpcValue & params, XmlRpcValue & result )

protected

Definition at line 257 of file XmlRpcServerConnection.cpp.

                                                                  {
  XmlRpcServerMethod* method = _server->findMethod( methodName );
 
  if ( !method ) return false;
 
  method->execute( params, result );
 
  // Ensure a valid result value
  if ( !result.valid() ) result = std::string();
 
  return true;
}

Referenced by executeMulticall(), and executeRequest().

executeMulticall()

bool XmlRpcServerConnection::executeMulticall ( const std::string & methodName, XmlRpcValue & params, XmlRpcValue & result )

protected

Definition at line 272 of file XmlRpcServerConnection.cpp.

                                                                                          {
  if ( methodName != SYSTEM_MULTICALL ) return false;
 
  // There ought to be 1 parameter, an array of structs
  if ( params.size() != 1 || params[0].getType() != XmlRpcValue::TypeArray )
    throw XmlRpcException( SYSTEM_MULTICALL + ": Invalid argument (expected an array)" );
 
  int nc = params[0].size();
  result.setSize( nc );
 
  for ( int i = 0; i < nc; ++i )
  {
 
    if ( !params[0][i].hasMember( METHODNAME ) || !params[0][i].hasMember( PARAMS ) )
    {
      result[i][FAULTCODE] = -1;
      result[i][FAULTSTRING] =
          SYSTEM_MULTICALL +
          ": Invalid argument (expected a struct with members methodName and params)";
      continue;
    }
 
    const std::string& methodName   = params[0][i][METHODNAME];
    XmlRpcValue&       methodParams = params[0][i][PARAMS];
 
    XmlRpcValue resultValue;
    resultValue.setSize( 1 );
    try
    {
      if ( !executeMethod( methodName, methodParams, resultValue[0] ) &&
           !executeMulticall( methodName, params, resultValue[0] ) )
      {
        result[i][FAULTCODE]   = -1;
        result[i][FAULTSTRING] = methodName + ": unknown method name";
      }
      else result[i] = resultValue;
 
    } catch ( const XmlRpcException& fault )
    {
      result[i][FAULTCODE]   = fault.getCode();
      result[i][FAULTSTRING] = fault.getMessage();
    }
  }
 
  return true;
}

Referenced by executeMulticall(), and executeRequest().

executeRequest()

void XmlRpcServerConnection::executeRequest ( )

protectedvirtual

Definition at line 213 of file XmlRpcServerConnection.cpp.

                                            {
  XmlRpcValue params, resultValue;
  std::string methodName = parseRequest( params );
  XmlRpcUtil::log( 2, "XmlRpcServerConnection::executeRequest: server calling method '%s'",
                   methodName.c_str() );
 
  try
  {
 
    if ( !executeMethod( methodName, params, resultValue ) &&
         !executeMulticall( methodName, params, resultValue ) )
      generateFaultResponse( methodName + ": unknown method name" );
    else generateResponse( resultValue.toXml() );
 
  } catch ( const XmlRpcException& fault )
  {
    XmlRpcUtil::log( 2, "XmlRpcServerConnection::executeRequest: fault %s.",
                     fault.getMessage().c_str() );
    generateFaultResponse( fault.getMessage(), fault.getCode() );
  }
}

Referenced by writeResponse().

generateFaultResponse()

void XmlRpcServerConnection::generateFaultResponse ( std::string const & msg, int errorCode = -1 )

protected

Definition at line 348 of file XmlRpcServerConnection.cpp.

                                                                                   {
  const char RESPONSE_1[] = "<?xml version=\"1.0\"?>\r\n"
                            "<methodResponse><fault>\r\n\t";
  const char RESPONSE_2[] = "\r\n</fault></methodResponse>\r\n";
 
  XmlRpcValue faultStruct;
  faultStruct[FAULTCODE]   = errorCode;
  faultStruct[FAULTSTRING] = errorMsg;
  std::string body         = RESPONSE_1 + faultStruct.toXml() + RESPONSE_2;
  std::string header       = generateHeader( body );
 
  _response = header + body;
}

Referenced by executeRequest().

generateHeader()

std::string XmlRpcServerConnection::generateHeader ( std::string const & body )

protected

Definition at line 334 of file XmlRpcServerConnection.cpp.

                                                                        {
  std::string header = "HTTP/1.1 200 OK\r\n"
                       "Server: ";
  header += XMLRPC_VERSION;
  header += "\r\n"
            "Content-Type: text/xml\r\n"
            "Content-length: ";
 
  char buffLen[40];
  sprintf( buffLen, "%d\r\n\r\n", body.size() );
 
  return header + buffLen;
}

Referenced by generateFaultResponse(), and generateResponse().

generateResponse()

void XmlRpcServerConnection::generateResponse ( std::string const & resultXml )

protected

Definition at line 321 of file XmlRpcServerConnection.cpp.

                                                                          {
  const char RESPONSE_1[] = "<?xml version=\"1.0\"?>\r\n"
                            "<methodResponse><params><param>\r\n\t";
  const char RESPONSE_2[] = "\r\n</param></params></methodResponse>\r\n";
 
  std::string body   = RESPONSE_1 + resultXml + RESPONSE_2;
  std::string header = generateHeader( body );
 
  _response = header + body;
  XmlRpcUtil::log( 5, "XmlRpcServerConnection::generateResponse:\n%s\n", _response.c_str() );
}

Referenced by executeRequest().

handleEvent()

unsigned XmlRpcServerConnection::handleEvent ( unsigned eventType )

virtual

Handle IO on the client connection socket.

Parameters

eventType

Type of IO event that occurred.

See also

XmlRpcDispatch::EventType.

Implements XmlRpc::XmlRpcSource.

Definition at line 46 of file XmlRpcServerConnection.cpp.

                                                         {
  if ( _connectionState == READ_HEADER )
    if ( !readHeader() ) return 0;
 
  if ( _connectionState == READ_REQUEST )
    if ( !readRequest() ) return 0;
 
  if ( _connectionState == WRITE_RESPONSE )
    if ( !writeResponse() ) return 0;
 
  return ( _connectionState == WRITE_RESPONSE ) ? XmlRpcDispatch::WritableEvent
                                                : XmlRpcDispatch::ReadableEvent;
}

parseRequest()

std::string XmlRpcServerConnection::parseRequest ( XmlRpcValue & params )

protected

Definition at line 236 of file XmlRpcServerConnection.cpp.

                                                                    {
  int offset = 0; // Number of chars parsed from the request
 
  std::string methodName = XmlRpcUtil::parseTag( METHODNAME_TAG, _request, &offset );
 
  if ( methodName.size() > 0 && XmlRpcUtil::findTag( PARAMS_TAG, _request, &offset ) )
  {
    int nArgs = 0;
    while ( XmlRpcUtil::nextTagIs( PARAM_TAG, _request, &offset ) )
    {
      params[nArgs++] = XmlRpcValue( _request, &offset );
      (void)XmlRpcUtil::nextTagIs( PARAM_ETAG, _request, &offset );
    }
 
    (void)XmlRpcUtil::nextTagIs( PARAMS_ETAG, _request, &offset );
  }
 
  return methodName;
}

Referenced by executeRequest().

readHeader()

bool XmlRpcServerConnection::readHeader ( )

protected

Definition at line 60 of file XmlRpcServerConnection.cpp.

                                        {
  // Read available data
  bool eof;
  if ( !XmlRpcSocket::nbRead( this->getfd(), _header, &eof ) )
  {
    // Its only an error if we already have read some data
    if ( _header.length() > 0 )
      XmlRpcUtil::error(
          "XmlRpcServerConnection::readHeader: error while reading header (%s).",
          XmlRpcSocket::getErrorMsg().c_str() );
    return false;
  }
 
  XmlRpcUtil::log( 4, "XmlRpcServerConnection::readHeader: read %d bytes.", _header.length() );
  char* hp = (char*)_header.c_str(); // Start of header
  char* ep = hp + _header.length();  // End of string
  char* bp = 0;                      // Start of body
  char* lp = 0;                      // Start of content-length value
  char* kp = 0;                      // Start of connection value
 
  for ( char* cp = hp; ( bp == 0 ) && ( cp < ep ); ++cp )
  {
    if ( ( ep - cp > 16 ) && ( strncasecmp( cp, "Content-length: ", 16 ) == 0 ) ) lp = cp + 16;
    else if ( ( ep - cp > 12 ) && ( strncasecmp( cp, "Connection: ", 12 ) == 0 ) )
      kp = cp + 12;
    else if ( ( ep - cp > 4 ) && ( strncmp( cp, "\r\n\r\n", 4 ) == 0 ) ) bp = cp + 4;
    else if ( ( ep - cp > 2 ) && ( strncmp( cp, "\n\n", 2 ) == 0 ) ) bp = cp + 2;
  }
 
  // If we haven't gotten the entire header yet, return (keep reading)
  if ( bp == 0 )
  {
    // EOF in the middle of a request is an error, otherwise its ok
    if ( eof )
    {
      XmlRpcUtil::log( 4, "XmlRpcServerConnection::readHeader: EOF" );
      if ( _header.length() > 0 )
        XmlRpcUtil::error( "XmlRpcServerConnection::readHeader: EOF while reading header" );
      return false; // Either way we close the connection
    }
 
    return true; // Keep reading
  }
 
  // Decode content length
  if ( lp == 0 )
  {
    XmlRpcUtil::error( "XmlRpcServerConnection::readHeader: No Content-length specified" );
    return false; // We could try to figure it out by parsing as we read, but for now...
  }
 
  _contentLength = atoi( lp );
  if ( _contentLength <= 0 )
  {
    XmlRpcUtil::error(
        "XmlRpcServerConnection::readHeader: Invalid Content-length specified (%d).",
        _contentLength );
    return false;
  }
 
  XmlRpcUtil::log( 3, "XmlRpcServerConnection::readHeader: specified content length is %d.",
                   _contentLength );
 
  // Otherwise copy non-header data to request buffer and set state to read request.
  _request = bp;
 
  // Parse out any interesting bits from the header (HTTP version, connection)
  _keepAlive = true;
  if ( _header.find( "HTTP/1.0" ) != std::string::npos )
  {
    if ( kp == 0 || strncasecmp( kp, "keep-alive", 10 ) != 0 )
      _keepAlive = false; // Default for HTTP 1.0 is to close the connection
  }
  else
  {
    if ( kp != 0 && strncasecmp( kp, "close", 5 ) == 0 ) _keepAlive = false;
  }
  XmlRpcUtil::log( 3, "KeepAlive: %d", _keepAlive );
 
  _header          = "";
  _connectionState = READ_REQUEST;
  return true; // Continue monitoring this source
}

Referenced by handleEvent().

readRequest()

bool XmlRpcServerConnection::readRequest ( )

protected

Definition at line 144 of file XmlRpcServerConnection.cpp.

                                         {
  // If we dont have the entire request yet, read available data
  if ( int( _request.length() ) < _contentLength )
  {
    bool eof;
    if ( !XmlRpcSocket::nbRead( this->getfd(), _request, &eof ) )
    {
      XmlRpcUtil::error( "XmlRpcServerConnection::readRequest: read error (%s).",
                         XmlRpcSocket::getErrorMsg().c_str() );
      return false;
    }
 
    // If we haven't gotten the entire request yet, return (keep reading)
    if ( int( _request.length() ) < _contentLength )
    {
      if ( eof )
      {
        XmlRpcUtil::error( "XmlRpcServerConnection::readRequest: EOF while reading request" );
        return false; // Either way we close the connection
      }
      return true;
    }
  }
 
  // Otherwise, parse and dispatch the request
  XmlRpcUtil::log( 3, "XmlRpcServerConnection::readRequest read %d bytes.",
                   _request.length() );
  // XmlRpcUtil::log(5, "XmlRpcServerConnection::readRequest:\n%s\n", _request.c_str());
 
  _connectionState = WRITE_RESPONSE;
 
  return true; // Continue monitoring this source
}

Referenced by handleEvent().

writeResponse()

bool XmlRpcServerConnection::writeResponse ( )

protected

Definition at line 178 of file XmlRpcServerConnection.cpp.

                                           {
  if ( _response.length() == 0 )
  {
    executeRequest();
    _bytesWritten = 0;
    if ( _response.length() == 0 )
    {
      XmlRpcUtil::error( "XmlRpcServerConnection::writeResponse: empty response." );
      return false;
    }
  }
 
  // Try to write the response
  if ( !XmlRpcSocket::nbWrite( this->getfd(), _response, &_bytesWritten ) )
  {
    XmlRpcUtil::error( "XmlRpcServerConnection::writeResponse: write error (%s).",
                       XmlRpcSocket::getErrorMsg().c_str() );
    return false;
  }
  XmlRpcUtil::log( 3, "XmlRpcServerConnection::writeResponse: wrote %d of %d bytes.",
                   _bytesWritten, _response.length() );
 
  // Prepare to read the next request
  if ( _bytesWritten == int( _response.length() ) )
  {
    _header          = "";
    _request         = "";
    _response        = "";
    _connectionState = READ_HEADER;
  }
 
  return _keepAlive; // Continue monitoring this source if true
}

Referenced by handleEvent().

Member Data Documentation

_bytesWritten

int XmlRpc::XmlRpcServerConnection::_bytesWritten

protected

Definition at line 94 of file XmlRpcServerConnection.h.

Referenced by writeResponse().

_connectionState

ServerConnectionState XmlRpc::XmlRpcServerConnection::_connectionState

protected

Definition at line 79 of file XmlRpcServerConnection.h.

Referenced by handleEvent(), readHeader(), readRequest(), writeResponse(), and XmlRpcServerConnection().

_contentLength

int XmlRpc::XmlRpcServerConnection::_contentLength

protected

Definition at line 85 of file XmlRpcServerConnection.h.

Referenced by readHeader(), and readRequest().

_header

std::string XmlRpc::XmlRpcServerConnection::_header

protected

Definition at line 82 of file XmlRpcServerConnection.h.

Referenced by readHeader(), and writeResponse().

_keepAlive

bool XmlRpc::XmlRpcServerConnection::_keepAlive

protected

Definition at line 97 of file XmlRpcServerConnection.h.

Referenced by readHeader(), writeResponse(), and XmlRpcServerConnection().

_request

std::string XmlRpc::XmlRpcServerConnection::_request

protected

Definition at line 88 of file XmlRpcServerConnection.h.

Referenced by parseRequest(), readHeader(), readRequest(), and writeResponse().

_response

std::string XmlRpc::XmlRpcServerConnection::_response

protected

Definition at line 91 of file XmlRpcServerConnection.h.

Referenced by generateFaultResponse(), generateResponse(), and writeResponse().

_server

XmlRpcServer* XmlRpc::XmlRpcServerConnection::_server

protected

Definition at line 75 of file XmlRpcServerConnection.h.

Referenced by executeMethod(), XmlRpcServerConnection(), and ~XmlRpcServerConnection().

FAULTCODE

const std::string XmlRpcServerConnection::FAULTCODE = "faultCode"

static

Definition at line 37 of file XmlRpcServerConnection.h.

Referenced by executeMulticall(), and generateFaultResponse().

FAULTSTRING

const std::string XmlRpcServerConnection::FAULTSTRING = "faultString"

static

Definition at line 38 of file XmlRpcServerConnection.h.

Referenced by executeMulticall(), and generateFaultResponse().

METHODNAME

const std::string XmlRpcServerConnection::METHODNAME = "methodName"

static

Definition at line 34 of file XmlRpcServerConnection.h.

Referenced by executeMulticall().

METHODNAME_TAG

const char XmlRpcServerConnection::METHODNAME_TAG = "<methodName>"

static

Definition at line 27 of file XmlRpcServerConnection.h.

Referenced by parseRequest().

PARAM_ETAG

const char XmlRpcServerConnection::PARAM_ETAG = "</param>"

static

Definition at line 31 of file XmlRpcServerConnection.h.

Referenced by parseRequest().

PARAM_TAG

const char XmlRpcServerConnection::PARAM_TAG = "<param>"

static

Definition at line 30 of file XmlRpcServerConnection.h.

Referenced by parseRequest().

PARAMS

const std::string XmlRpcServerConnection::PARAMS = "params"

static

Definition at line 35 of file XmlRpcServerConnection.h.

Referenced by executeMulticall().

PARAMS_ETAG

const char XmlRpcServerConnection::PARAMS_ETAG = "</params>"

static

Definition at line 29 of file XmlRpcServerConnection.h.

Referenced by parseRequest().

PARAMS_TAG

const char XmlRpcServerConnection::PARAMS_TAG = "<params>"

static

Definition at line 28 of file XmlRpcServerConnection.h.

Referenced by parseRequest().

SYSTEM_MULTICALL

const std::string XmlRpcServerConnection::SYSTEM_MULTICALL = "system.multicall"

static

Definition at line 33 of file XmlRpcServerConnection.h.

Referenced by executeMulticall().

---

The documentation for this class was generated from the following files:

• XmlRpcServerConnection.h
• XmlRpcServerConnection.cpp