375 lines
12 KiB
C++
375 lines
12 KiB
C++
|
|
#include "robot_xmlrpcpp/XmlRpcServerConnection.h"
|
|
|
|
#include "robot_xmlrpcpp/XmlRpcSocket.h"
|
|
#include "robot_xmlrpcpp/XmlRpc.h"
|
|
#ifndef MAKEDEPEND
|
|
# include <stdio.h>
|
|
# include <stdlib.h>
|
|
#include <cstring> // cho strncmp
|
|
#include <strings.h> // cho strncasecmp
|
|
|
|
#endif
|
|
|
|
using namespace robot::XmlRpc;
|
|
|
|
// Static data
|
|
const char XmlRpcServerConnection::METHODNAME_TAG[] = "<methodName>";
|
|
const char XmlRpcServerConnection::PARAMS_TAG[] = "<params>";
|
|
const char XmlRpcServerConnection::PARAMS_ETAG[] = "</params>";
|
|
const char XmlRpcServerConnection::PARAM_TAG[] = "<param>";
|
|
const char XmlRpcServerConnection::PARAM_ETAG[] = "</param>";
|
|
|
|
const std::string XmlRpcServerConnection::SYSTEM_MULTICALL = "system.multicall";
|
|
const std::string XmlRpcServerConnection::METHODNAME = "methodName";
|
|
const std::string XmlRpcServerConnection::PARAMS = "params";
|
|
|
|
const std::string XmlRpcServerConnection::FAULTCODE = "faultCode";
|
|
const std::string XmlRpcServerConnection::FAULTSTRING = "faultString";
|
|
|
|
|
|
|
|
// The server delegates handling client requests to a serverConnection object.
|
|
XmlRpcServerConnection::XmlRpcServerConnection(int fd, XmlRpcServer* server, bool deleteOnClose /*= false*/) :
|
|
XmlRpcSource(fd, deleteOnClose)
|
|
{
|
|
XmlRpcUtil::log(2,"XmlRpcServerConnection: new socket %d.", fd);
|
|
_server = server;
|
|
_connectionState = READ_HEADER;
|
|
_keepAlive = true;
|
|
}
|
|
|
|
|
|
XmlRpcServerConnection::~XmlRpcServerConnection()
|
|
{
|
|
XmlRpcUtil::log(4,"XmlRpcServerConnection dtor.");
|
|
_server->removeConnection(this);
|
|
}
|
|
|
|
|
|
// Handle input on the server socket by accepting the connection
|
|
// and reading the rpc request. Return true to continue to monitor
|
|
// the socket for events, false to remove it from the dispatcher.
|
|
unsigned
|
|
XmlRpcServerConnection::handleEvent(unsigned /*eventType*/)
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
bool
|
|
XmlRpcServerConnection::readHeader()
|
|
{
|
|
// 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
|
|
}
|
|
|
|
bool
|
|
XmlRpcServerConnection::readRequest()
|
|
{
|
|
// 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
|
|
}
|
|
|
|
|
|
bool
|
|
XmlRpcServerConnection::writeResponse()
|
|
{
|
|
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
|
|
}
|
|
|
|
// Run the method, generate _response string
|
|
void
|
|
XmlRpcServerConnection::executeRequest()
|
|
{
|
|
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());
|
|
}
|
|
}
|
|
|
|
// Parse the method name and the argument values from the request.
|
|
std::string
|
|
XmlRpcServerConnection::parseRequest(XmlRpcValue& params)
|
|
{
|
|
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;
|
|
}
|
|
|
|
// Execute a named method with the specified params.
|
|
bool
|
|
XmlRpcServerConnection::executeMethod(const std::string& methodName,
|
|
XmlRpcValue& params, XmlRpcValue& result)
|
|
{
|
|
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;
|
|
}
|
|
|
|
// Execute multiple calls and return the results in an array.
|
|
bool
|
|
XmlRpcServerConnection::executeMulticall(const std::string& methodName,
|
|
XmlRpcValue& params, XmlRpcValue& result)
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
// Create a response from results xml
|
|
void
|
|
XmlRpcServerConnection::generateResponse(std::string const& resultXml)
|
|
{
|
|
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());
|
|
}
|
|
|
|
// Prepend http headers
|
|
std::string
|
|
XmlRpcServerConnection::generateHeader(std::string const& body)
|
|
{
|
|
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", (int)body.size());
|
|
|
|
return header + buffLen;
|
|
}
|
|
|
|
|
|
void
|
|
XmlRpcServerConnection::generateFaultResponse(std::string const& errorMsg, int errorCode)
|
|
{
|
|
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;
|
|
}
|
|
|