A class to send XML RPC requests to a server and return the results. More...
#include <XmlRpcClient.h>
Public Member Functions | |
XmlRpcClient (const char *host, int port, const char *uri=0) | |
Construct a client to connect to the server at the specified host:port address. | |
XmlRpcClient (const char *host, int port, const char *uri=0, bool ssl=false) | |
XmlRpcClient (const char *host, int port, const char *login, const char *password, const char *uri=0) | |
Construct a client to connect to the server at the specified host:port address including HTTP authentication. | |
XmlRpcClient (const char *host, int port, const char *login, const char *password, const char *uri=0, bool ssl=false) | |
virtual | ~XmlRpcClient () |
Destructor. | |
bool | execute (const char *method, XmlRpcValue const ¶ms, XmlRpcValue &result) |
Execute the named procedure on the remote server. | |
bool | isFault () const |
Returns true if the result of the last execute() was a fault response. | |
const char *const | host () const |
Return the host name of the server. | |
int | getPort () const |
Return the port. | |
const char *const | uri () const |
Return the URI. | |
virtual void | close () |
Close the connection. | |
virtual unsigned | handleEvent (unsigned eventType) |
Handle server responses. | |
Static Public Attributes | |
static const char | REQUEST_BEGIN [] = "<methodCall><methodName>" |
static const char | REQUEST_END_METHODNAME [] = "</methodName>\r\n" |
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 char | REQUEST_END [] = "</methodCall>\r\n" |
static const char | METHODRESPONSE_TAG [] = "<methodResponse>" |
static const char | FAULT_TAG [] = "<fault>" |
Protected Types | |
enum | ClientConnectionState { NO_CONNECTION, CONNECTING, WRITE_REQUEST, READ_HEADER, READ_RESPONSE, IDLE } |
Protected Member Functions | |
virtual bool | doConnect () |
virtual bool | setupConnection () |
virtual bool | generateRequest (const char *method, XmlRpcValue const ¶ms) |
virtual std::string | generateHeader (std::string const &body) |
virtual bool | writeRequest () |
virtual bool | readHeader () |
virtual bool | readResponse () |
virtual bool | parseResponse (XmlRpcValue &result) |
Protected Attributes | |
ClientConnectionState | _connectionState |
std::string | _host |
std::string | _uri |
int | _port |
std::string | _login |
std::string | _password |
std::string | _request |
std::string | _header |
std::string | _response |
int | _sendAttempts |
int | _bytesWritten |
bool | _executing |
bool | _eof |
bool | _isFault |
int | _contentLength |
XmlRpcDispatch | _disp |
A class to send XML RPC requests to a server and return the results.
Definition at line 32 of file XmlRpcClient.h.
enum XmlRpc::XmlRpcClient::ClientConnectionState [protected] |
Definition at line 112 of file XmlRpcClient.h.
{ NO_CONNECTION, CONNECTING, WRITE_REQUEST, READ_HEADER, READ_RESPONSE, IDLE };
XmlRpcClient::XmlRpcClient | ( | const char * | host, | |
int | port, | |||
const char * | uri = 0 | |||
) |
Construct a client to connect to the server at the specified host:port address.
host | The name of the remote machine hosting the server, eg "myserver.mycompany.com" | |
port | The port on the remote machine where the server is listening | |
uri | An optional string to be sent as the URI in the HTTP GET header Note that the host is not a URL, do not prepend "http://" or other protocol specifiers. |
Definition at line 37 of file XmlRpcClient.cc.
{ XmlRpcUtil::log(1, "XmlRpcClient new client: host %s, port %d.", host, port); _host = host; _port = port; if (uri && *uri) _uri = uri; else _uri = "/RPC2"; _connectionState = NO_CONNECTION; _executing = false; _eof = false; _ssl = false; _ssl_ssl = (SSL *) NULL; // Default to keeping the connection open until an explicit close is done setKeepOpen(); }
XmlRpcClient::XmlRpcClient | ( | const char * | host, | |
int | port, | |||
const char * | uri = 0 , |
|||
bool | ssl = false | |||
) |
Definition at line 55 of file XmlRpcClient.cc.
{ XmlRpcUtil::log(1, "XmlRpcClient new client: host %s, port %d.", host, port); _host = host; _port = port; if (uri && *uri) _uri = uri; else _uri = "/RPC2"; _connectionState = NO_CONNECTION; _executing = false; _eof = false; _ssl = ssl; if (!_ssl) { _ssl_ssl = (SSL *) NULL; } // Default to keeping the connection open until an explicit close is done setKeepOpen(); }
XmlRpcClient::XmlRpcClient | ( | const char * | host, | |
int | port, | |||
const char * | login, | |||
const char * | password, | |||
const char * | uri = 0 | |||
) |
Construct a client to connect to the server at the specified host:port address including HTTP authentication.
host | The name of the remote machine hosting the server | |
port | The port on the remote machine where the server is listening | |
login | The username passed to the server | |
password | The password passed to the server | |
uri | An optional string to be sent as the URI in the HTTP GET header |
Definition at line 76 of file XmlRpcClient.cc.
{ XmlRpcUtil::log(1, "XmlRpcClient new client: host %s, port %d, login %s.", host, port, login); _host = host; _port = port; if (uri) _uri = uri; else _uri = "/RPC2"; _login = login; _password = password; _connectionState = NO_CONNECTION; _executing = false; _eof = false; // Default to keeping the connection open until an explicit close is done setKeepOpen(); }
XmlRpcClient::XmlRpcClient | ( | const char * | host, | |
int | port, | |||
const char * | login, | |||
const char * | password, | |||
const char * | uri = 0 , |
|||
bool | ssl = false | |||
) |
Definition at line 99 of file XmlRpcClient.cc.
{ XmlRpcUtil::log(1, "XmlRpcClient new client: host %s, port %d, login %s.", host, port, login); _host = host; _port = port; if (uri) _uri = uri; else _uri = "/RPC2"; _login = login; _password = password; _connectionState = NO_CONNECTION; _executing = false; _eof = false; _ssl = ssl; if (!_ssl) { _ssl_ssl = (SSL *) NULL; } // Default to keeping the connection open until an explicit close is done setKeepOpen(); }
XmlRpcClient::~XmlRpcClient | ( | ) | [virtual] |
Destructor.
Definition at line 126 of file XmlRpcClient.cc.
{ XmlRpcUtil::log(1, "XmlRpcClient dtor client: host %s, port %d.", _host.c_str(), _port); if (_connectionState != NO_CONNECTION) close(); }
void XmlRpcClient::close | ( | ) | [virtual] |
Close the connection.
Reimplemented from XmlRpc::XmlRpcSource.
Definition at line 135 of file XmlRpcClient.cc.
Referenced by doConnect(), readHeader(), setupConnection(), and ~XmlRpcClient().
{ XmlRpcUtil::log(4, "XmlRpcClient::close: fd %d.", getfd()); _connectionState = NO_CONNECTION; _disp.exit(); _disp.removeSource(this); if (_ssl) { // Pre-socket shutdown XmlRpcUtil::log(4, "XmlRpcClient::close: before SSL_shutdown"); //SSL_shutdown(_ssl_ssl); XmlRpcUtil::log(4, "XmlRpcClient::close: after SSL_shutdown"); } XmlRpcSource::close(); if (_ssl) { // Post-socket shutdown XmlRpcUtil::log(4, "XmlRpcClient::close: before SSL_free(_ssl_ssl)"); //SSL_free(_ssl_ssl); XmlRpcUtil::log(4, "XmlRpcClient::close: before SSL_CTX_free(_ssl_ctx)"); //SSL_CTX_free(_ssl_ctx); XmlRpcUtil::log(4, "XmlRpcClient::close: SSL shutdown successful!"); } }
bool XmlRpcClient::doConnect | ( | ) | [protected, virtual] |
Definition at line 267 of file XmlRpcClient.cc.
Referenced by setupConnection().
{ int fd = XmlRpcSocket::getSocket(); if (fd < 0) { XmlRpcUtil::error("Error in XmlRpcClient::doConnect: Could not create socket (%s).", XmlRpcSocket::getErrorMsg().c_str()); return false; } XmlRpcUtil::log(3, "XmlRpcClient::doConnect: fd %d.", fd); this->setfd(fd); // Don't block on connect/reads/writes if ( ! XmlRpcSocket::setNonBlocking(fd)) { this->close(); XmlRpcUtil::error("Error in XmlRpcClient::doConnect: Could not set socket to non-blocking IO mode (%s).", XmlRpcSocket::getErrorMsg().c_str()); return false; } if ( ! XmlRpcSocket::connect(fd, _host, _port)) { this->close(); XmlRpcUtil::error("Error in XmlRpcClient::doConnect: Could not connect to server (%s).", XmlRpcSocket::getErrorMsg().c_str()); return false; } #ifdef USE_SSL // Perform SSL if needed if (_ssl) { SSLeay_add_ssl_algorithms(); _ssl_meth = SSLv23_client_method(); SSL_load_error_strings(); _ssl_ctx = SSL_CTX_new (_ssl_meth); _ssl_ssl = SSL_new (_ssl_ctx); SSL_set_fd (_ssl_ssl, fd); int err = SSL_connect (_ssl_ssl); } #endif return true; }
bool XmlRpcClient::execute | ( | const char * | method, | |
XmlRpcValue const & | params, | |||
XmlRpcValue & | result | |||
) |
Execute the named procedure on the remote server.
method | The name of the remote procedure to execute | |
params | An array of the arguments for the method | |
result | The result value to be returned to the client |
Currently this is a synchronous (blocking) implementation (execute does not return until it receives a response or an error). Use isFault() to determine whether the result is a fault response.
Definition at line 171 of file XmlRpcClient.cc.
{ XmlRpcUtil::log(1, "XmlRpcClient::execute: method %s (_connectionState %d).", method, _connectionState); // This is not a thread-safe operation, if you want to do multithreading, use separate // clients for each thread. If you want to protect yourself from multiple threads // accessing the same client, replace this code with a real mutex. if (_executing) return false; _executing = true; ClearFlagOnExit cf(_executing); _sendAttempts = 0; _isFault = false; if ( ! setupConnection()) return false; if ( ! generateRequest(method, params)) return false; result.clear(); double msTime = -1.0; // Process until exit is called _disp.work(msTime); if (_connectionState != IDLE || ! parseResponse(result)) return false; XmlRpcUtil::log(1, "XmlRpcClient::execute: method %s completed.", method); _response = ""; return true; }
std::string XmlRpcClient::generateHeader | ( | std::string const & | body | ) | [protected, virtual] |
Definition at line 351 of file XmlRpcClient.cc.
Referenced by generateRequest().
{ std::string header = "POST " + _uri + " HTTP/1.1\r\n" "User-Agent: "; header += XMLRPC_VERSION; header += "\r\nHost: "; header += _host; char buff[40]; sprintf(buff,":%d\r\n", _port); header += buff; if (_login.length() != 0) { // convert to base64 std::vector<char> base64data; int iostatus = 0; base64<char> encoder; std::back_insert_iterator<std::vector<char> > ins = std::back_inserter(base64data); std::string authBuf = _login + ":" + _password; encoder.put(authBuf.begin(), authBuf.end(), ins, iostatus, base64<>::crlf()); header += "Authorization: Basic "; std::string authEnc(base64data.begin(), base64data.end()); // handle pesky linefeed characters string::size_type lf; while ( (lf = authEnc.find("\r")) != string::npos ) { authEnc.erase(lf, 1); } while ( (lf = authEnc.find("\n")) != string::npos ) { authEnc.erase(lf, 1); } header += authEnc; header += "\r\n"; } header += "Content-Type: text/xml\r\nContent-length: "; sprintf(buff,"%zu\r\n\r\n", body.size()); return header + buff; }
bool XmlRpcClient::generateRequest | ( | const char * | method, | |
XmlRpcValue const & | params | |||
) | [protected, virtual] |
Definition at line 313 of file XmlRpcClient.cc.
Referenced by execute().
{ std::string body = REQUEST_BEGIN; body += methodName; body += REQUEST_END_METHODNAME; // If params is an array, each element is a separate parameter if (params.isValid()) { body += PARAMS_TAG; if (params.getType() == XmlRpcValue::TypeArray) { for (int i=0; i<params.size(); ++i) { body += PARAM_TAG; body += params[i].toXml(); body += PARAM_ETAG; } } else { body += PARAM_TAG; body += params.toXml(); body += PARAM_ETAG; } body += PARAMS_ETAG; } body += REQUEST_END; std::string header = generateHeader(body); XmlRpcUtil::log(4, "XmlRpcClient::generateRequest: header is %d bytes, content-length is %d.", header.length(), body.length()); _request = header + body; return true; }
int XmlRpc::XmlRpcClient::getPort | ( | ) | const [inline] |
unsigned XmlRpcClient::handleEvent | ( | unsigned | eventType | ) | [virtual] |
Handle server responses.
Called by the event dispatcher during execute.
eventType | The type of event that occurred. |
Implements XmlRpc::XmlRpcSource.
Definition at line 208 of file XmlRpcClient.cc.
{ if (eventType == XmlRpcDispatch::Exception) { //if (XmlRpcSocket::nonFatalError()) // return (_connectionState == WRITE_REQUEST) // ? XmlRpcDispatch::WritableEvent : XmlRpcDispatch::ReadableEvent; if (_connectionState == WRITE_REQUEST && _bytesWritten == 0) XmlRpcUtil::error("Error in XmlRpcClient::handleEvent: could not connect to server (%s).", XmlRpcSocket::getErrorMsg().c_str()); else XmlRpcUtil::error("Error in XmlRpcClient::handleEvent (state %d): %s.", _connectionState, XmlRpcSocket::getErrorMsg().c_str()); return 0; } if (_connectionState == WRITE_REQUEST) if ( ! writeRequest()) return 0; if (_connectionState == READ_HEADER) if ( ! readHeader()) return 0; if (_connectionState == READ_RESPONSE) if ( ! readResponse()) return 0; // This should probably always ask for Exception events too return (_connectionState == WRITE_REQUEST) ? XmlRpcDispatch::WritableEvent : XmlRpcDispatch::ReadableEvent; }
const char* const XmlRpc::XmlRpcClient::host | ( | ) | const [inline] |
Return the host name of the server.
Definition at line 82 of file XmlRpcClient.h.
{ return _host.c_str(); }
bool XmlRpc::XmlRpcClient::isFault | ( | ) | const [inline] |
Returns true if the result of the last execute() was a fault response.
Definition at line 79 of file XmlRpcClient.h.
{ return _isFault; }
bool XmlRpcClient::parseResponse | ( | XmlRpcValue & | result | ) | [protected, virtual] |
Definition at line 528 of file XmlRpcClient.cc.
Referenced by execute().
{ // Parse response xml into result int offset = 0; if ( ! XmlRpcUtil::findTag(METHODRESPONSE_TAG,_response,&offset)) { XmlRpcUtil::error("Error in XmlRpcClient::parseResponse: Invalid response - no methodResponse. Response:\n%s", _response.c_str()); return false; } // Expect either <params><param>... or <fault>... if ((XmlRpcUtil::nextTagIs(PARAMS_TAG,_response,&offset) && XmlRpcUtil::nextTagIs(PARAM_TAG,_response,&offset)) || (XmlRpcUtil::nextTagIs(FAULT_TAG,_response,&offset) && (_isFault = true))) { if ( ! result.fromXml(_response, &offset)) { XmlRpcUtil::error("Error in XmlRpcClient::parseResponse: Invalid response value. Response:\n%s", _response.c_str()); _response = ""; return false; } } else { XmlRpcUtil::error("Error in XmlRpcClient::parseResponse: Invalid response - no param or fault tag. Response:\n%s", _response.c_str()); _response = ""; return false; } _response = ""; return result.isValid(); }
bool XmlRpcClient::readHeader | ( | ) | [protected, virtual] |
Definition at line 426 of file XmlRpcClient.cc.
Referenced by handleEvent().
{ // Read available data if ( ! XmlRpcSocket::nbRead(this->getfd(), _header, &_eof, _ssl_ssl) || (_eof && _header.length() == 0)) { // If we haven't read any data yet and this is a keep-alive connection, the server may // have timed out, so we try one more time. if (getKeepOpen() && _header.length() == 0 && _sendAttempts++ == 0) { XmlRpcUtil::log(4, "XmlRpcClient::readHeader: re-trying connection"); XmlRpcSource::close(); _connectionState = NO_CONNECTION; _eof = false; return setupConnection(); } XmlRpcUtil::error("Error in XmlRpcClient::readHeader: error while reading header (%s) on fd %d.", XmlRpcSocket::getErrorMsg().c_str(), getfd()); return false; } XmlRpcUtil::log(4, "XmlRpcClient::readHeader: client has 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 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 > 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) { if (_eof) // EOF in the middle of a response is an error { XmlRpcUtil::error("Error in XmlRpcClient::readHeader: EOF while reading header"); return false; // Close the connection } return true; // Keep reading } // Decode content length if (lp == 0) { XmlRpcUtil::error("Error XmlRpcClient::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("Error in XmlRpcClient::readHeader: Invalid Content-length specified (%d).", _contentLength); return false; } XmlRpcUtil::log(4, "client read content length: %d", _contentLength); // Otherwise copy non-header data to response buffer and set state to read response. _response = bp; _header = ""; // should parse out any interesting bits from the header (connection, etc)... _connectionState = READ_RESPONSE; return true; // Continue monitoring this source }
bool XmlRpcClient::readResponse | ( | ) | [protected, virtual] |
Definition at line 497 of file XmlRpcClient.cc.
Referenced by handleEvent().
{ // If we dont have the entire response yet, read available data if (int(_response.length()) < _contentLength) { if ( ! XmlRpcSocket::nbRead(this->getfd(), _response, &_eof, _ssl_ssl)) { XmlRpcUtil::error("Error in XmlRpcClient::readResponse: read error (%s).",XmlRpcSocket::getErrorMsg().c_str()); return false; } // If we haven't gotten the entire _response yet, return (keep reading) if (int(_response.length()) < _contentLength) { if (_eof) { XmlRpcUtil::error("Error in XmlRpcClient::readResponse: EOF while reading response"); return false; } return true; } } // Otherwise, parse and return the result XmlRpcUtil::log(3, "XmlRpcClient::readResponse (read %d bytes)", _response.length()); XmlRpcUtil::log(5, "response:\n%s", _response.c_str()); _connectionState = IDLE; return false; // Stop monitoring this source (causes return from work) }
bool XmlRpcClient::setupConnection | ( | ) | [protected, virtual] |
Definition at line 242 of file XmlRpcClient.cc.
Referenced by execute(), and readHeader().
{ // If an error occurred last time through, or if the server closed the connection, close our end if ((_connectionState != NO_CONNECTION && _connectionState != IDLE) || _eof) close(); _eof = false; if (_connectionState == NO_CONNECTION) if (! doConnect()) return false; // Prepare to write the request _connectionState = WRITE_REQUEST; _bytesWritten = 0; // Notify the dispatcher to listen on this source (calls handleEvent when the socket is writable) _disp.removeSource(this); // Make sure nothing is left over _disp.addSource(this, XmlRpcDispatch::WritableEvent | XmlRpcDispatch::Exception); return true; }
const char* const XmlRpc::XmlRpcClient::uri | ( | ) | const [inline] |
bool XmlRpcClient::writeRequest | ( | ) | [protected, virtual] |
Definition at line 401 of file XmlRpcClient.cc.
Referenced by handleEvent().
{ if (_bytesWritten == 0) XmlRpcUtil::log(5, "XmlRpcClient::writeRequest (attempt %d):\n%s\n", _sendAttempts+1, _request.c_str()); // Try to write the request if ( ! XmlRpcSocket::nbWrite(this->getfd(), _request, &_bytesWritten, _ssl_ssl)) { XmlRpcUtil::error("Error in XmlRpcClient::writeRequest: write error (%s).",XmlRpcSocket::getErrorMsg().c_str()); return false; } XmlRpcUtil::log(3, "XmlRpcClient::writeRequest: wrote %d of %d bytes.", _bytesWritten, _request.length()); // Wait for the result if (_bytesWritten == int(_request.length())) { _header = ""; _response = ""; _connectionState = READ_HEADER; } return true; }
int XmlRpc::XmlRpcClient::_bytesWritten [protected] |
Definition at line 133 of file XmlRpcClient.h.
Referenced by handleEvent(), setupConnection(), and writeRequest().
Definition at line 113 of file XmlRpcClient.h.
Referenced by close(), execute(), handleEvent(), readHeader(), readResponse(), setupConnection(), writeRequest(), XmlRpcClient(), and ~XmlRpcClient().
int XmlRpc::XmlRpcClient::_contentLength [protected] |
Definition at line 146 of file XmlRpcClient.h.
Referenced by readHeader(), and readResponse().
XmlRpcDispatch XmlRpc::XmlRpcClient::_disp [protected] |
Definition at line 149 of file XmlRpcClient.h.
Referenced by close(), execute(), and setupConnection().
bool XmlRpc::XmlRpcClient::_eof [protected] |
Definition at line 140 of file XmlRpcClient.h.
Referenced by readHeader(), readResponse(), setupConnection(), and XmlRpcClient().
bool XmlRpc::XmlRpcClient::_executing [protected] |
Definition at line 137 of file XmlRpcClient.h.
Referenced by execute(), and XmlRpcClient().
std::string XmlRpc::XmlRpcClient::_header [protected] |
Definition at line 126 of file XmlRpcClient.h.
Referenced by readHeader(), and writeRequest().
std::string XmlRpc::XmlRpcClient::_host [protected] |
Definition at line 116 of file XmlRpcClient.h.
Referenced by doConnect(), generateHeader(), host(), XmlRpcClient(), and ~XmlRpcClient().
bool XmlRpc::XmlRpcClient::_isFault [protected] |
Definition at line 143 of file XmlRpcClient.h.
Referenced by execute(), isFault(), and parseResponse().
std::string XmlRpc::XmlRpcClient::_login [protected] |
Definition at line 121 of file XmlRpcClient.h.
Referenced by generateHeader(), and XmlRpcClient().
std::string XmlRpc::XmlRpcClient::_password [protected] |
Definition at line 122 of file XmlRpcClient.h.
Referenced by generateHeader(), and XmlRpcClient().
int XmlRpc::XmlRpcClient::_port [protected] |
Definition at line 118 of file XmlRpcClient.h.
Referenced by doConnect(), generateHeader(), getPort(), XmlRpcClient(), and ~XmlRpcClient().
std::string XmlRpc::XmlRpcClient::_request [protected] |
Definition at line 125 of file XmlRpcClient.h.
Referenced by generateRequest(), and writeRequest().
std::string XmlRpc::XmlRpcClient::_response [protected] |
Definition at line 127 of file XmlRpcClient.h.
Referenced by execute(), parseResponse(), readHeader(), readResponse(), and writeRequest().
int XmlRpc::XmlRpcClient::_sendAttempts [protected] |
Definition at line 130 of file XmlRpcClient.h.
Referenced by execute(), readHeader(), and writeRequest().
std::string XmlRpc::XmlRpcClient::_uri [protected] |
Definition at line 117 of file XmlRpcClient.h.
Referenced by generateHeader(), uri(), and XmlRpcClient().
const char XmlRpcClient::FAULT_TAG = "<fault>" [static] |
Definition at line 44 of file XmlRpcClient.h.
Referenced by parseResponse().
const char XmlRpcClient::METHODRESPONSE_TAG = "<methodResponse>" [static] |
Definition at line 43 of file XmlRpcClient.h.
Referenced by parseResponse().
const char XmlRpcClient::PARAM_ETAG = "</param>" [static] |
Definition at line 40 of file XmlRpcClient.h.
Referenced by generateRequest().
const char XmlRpcClient::PARAM_TAG = "<param>" [static] |
Definition at line 39 of file XmlRpcClient.h.
Referenced by generateRequest(), and parseResponse().
const char XmlRpcClient::PARAMS_ETAG = "</params>" [static] |
Definition at line 38 of file XmlRpcClient.h.
Referenced by generateRequest().
const char XmlRpcClient::PARAMS_TAG = "<params>" [static] |
Definition at line 37 of file XmlRpcClient.h.
Referenced by generateRequest(), and parseResponse().
const char XmlRpcClient::REQUEST_BEGIN = "<methodCall><methodName>" [static] |
Definition at line 35 of file XmlRpcClient.h.
Referenced by generateRequest().
const char XmlRpcClient::REQUEST_END = "</methodCall>\r\n" [static] |
Definition at line 41 of file XmlRpcClient.h.
Referenced by generateRequest().
const char XmlRpcClient::REQUEST_END_METHODNAME = "</methodName>\r\n" [static] |
Definition at line 36 of file XmlRpcClient.h.
Referenced by generateRequest().