/usr/include/xmlrpcpp/XmlRpcClient.h is in libxmlrpcpp-dev 1.13.5+ds1-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 | #ifndef _XMLRPCCLIENT_H_
#define _XMLRPCCLIENT_H_
//
// XmlRpc++ Copyright (c) 2002-2003 by Chris Morley
//
#if defined(_MSC_VER)
# pragma warning(disable:4786) // identifier was truncated in debug info
#endif
#ifndef MAKEDEPEND
# include <string>
#endif
#include "xmlrpcpp/XmlRpcDispatch.h"
#include "xmlrpcpp/XmlRpcSource.h"
#include "xmlrpcpp/XmlRpcDecl.h"
namespace XmlRpc {
// Arguments and results are represented by XmlRpcValues
class XmlRpcValue;
//! A class to send XML RPC requests to a server and return the results.
class XMLRPCPP_DECL XmlRpcClient : public XmlRpcSource {
public:
// Static data
static const char REQUEST_BEGIN[];
static const char REQUEST_END_METHODNAME[];
static const char PARAMS_TAG[];
static const char PARAMS_ETAG[];
static const char PARAM_TAG[];
static const char PARAM_ETAG[];
static const char REQUEST_END[];
// Result tags
static const char METHODRESPONSE_TAG[];
static const char FAULT_TAG[];
//! Construct a client to connect to the server at the specified host:port address
//! @param host The name of the remote machine hosting the server
//! @param port The port on the remote machine where the server is listening
//! @param uri An optional string to be sent as the URI in the HTTP GET header
XmlRpcClient(const char* host, int port, const char* uri=0);
//! Destructor
virtual ~XmlRpcClient();
//! Execute the named procedure on the remote server.
//! @param method The name of the remote procedure to execute
//! @param params An array of the arguments for the method
//! @param result The result value to be returned to the client
//! @return true if the request was sent and a result received
//! (although the result might be a fault).
//!
//! 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.
bool execute(const char* method, XmlRpcValue const& params, XmlRpcValue& result);
bool executeNonBlock(const char* method, XmlRpcValue const& params);
bool executeCheckDone(XmlRpcValue& result);
//! Returns true if the result of the last execute() was a fault response.
bool isFault() const { return _isFault; }
// XmlRpcSource interface implementation
//! Close the connection
virtual void close();
//! Handle server responses. Called by the event dispatcher during execute.
//! @param eventType The type of event that occurred.
//! @see XmlRpcDispatch::EventType
virtual unsigned handleEvent(unsigned eventType);
protected:
// Execution processing helpers
virtual bool doConnect();
virtual bool setupConnection();
virtual bool generateRequest(const char* method, XmlRpcValue const& params);
virtual std::string generateHeader(std::string const& body);
virtual bool writeRequest();
virtual bool readHeader();
virtual bool readResponse();
virtual bool parseResponse(XmlRpcValue& result);
// Possible IO states for the connection
enum ClientConnectionState { NO_CONNECTION, CONNECTING, WRITE_REQUEST, READ_HEADER, READ_RESPONSE, IDLE };
ClientConnectionState _connectionState;
// Server location
std::string _host;
std::string _uri;
int _port;
public:
const std::string &getHost() { return _host; }
const std::string &getUri() { return _uri; }
int getPort() const { return _port; }
// The xml-encoded request, http header of response, and response xml
std::string _request;
std::string _header;
std::string _response;
// Number of times the client has attempted to send the request
int _sendAttempts;
// Number of bytes of the request that have been written to the socket so far
int _bytesWritten;
// True if we are currently executing a request. If you want to multithread,
// each thread should have its own client.
bool _executing;
// True if the server closed the connection
bool _eof;
// True if a fault response was returned by the server
bool _isFault;
// Number of bytes expected in the response body (parsed from response header)
int _contentLength;
// Event dispatcher
XmlRpcDispatch _disp;
}; // class XmlRpcClient
} // namespace XmlRpc
#endif // _XMLRPCCLIENT_H_
|