src/parsec/disk-image/parsec/parsec-benchmark/pkgs/tools/cmake/src/Utilities/cmxmlrpc/XmlRpcCpp.cpp - public/gem5-resources - Git at Google

 // Copyright (C) 2001 by Eric Kidd. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions
 // are met:
 // 1. Redistributions of source code must retain the above copyright
 //    notice, this list of conditions and the following disclaimer.
 // 2. Redistributions in binary form must reproduce the above copyright
 //    notice, this list of conditions and the following disclaimer in the
 //    documentation and/or other materials provided with the distribution.
 // 3. The name of the author may not be used to endorse or promote products
 //    derived from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 // ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 // OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 // SUCH DAMAGE.


 #include "XmlRpcCpp.h"


 //=========================================================================
 //  XmlRpcFault Methods
 //=========================================================================

 XmlRpcFault::XmlRpcFault (const XmlRpcFault &fault) {
     xmlrpc_env_init(&mFault);
     xmlrpc_env_set_fault(&mFault,
                          fault.mFault.fault_code,
                          fault.mFault.fault_string);
 }

 XmlRpcFault::XmlRpcFault (const int faultCode, const string faultString) {
     xmlrpc_env_init(&mFault);
     xmlrpc_env_set_fault(&mFault, faultCode,
                          const_cast<char*>(faultString.c_str()));
 }

 XmlRpcFault::XmlRpcFault (const xmlrpc_env *env) {
     if (!env->fault_string)
         throw XmlRpcFault(XMLRPC_INTERNAL_ERROR,
                           "Tried to create empty fault");
     xmlrpc_env_init(&mFault);
     xmlrpc_env_set_fault(&mFault, env->fault_code,
                          const_cast<char*>(env->fault_string));
 }

 XmlRpcFault::~XmlRpcFault (void) {
     xmlrpc_env_clean(&mFault);
 }

 string XmlRpcFault::getFaultString (void) const {
     XMLRPC_ASSERT(mFault.fault_occurred);
     return string(mFault.fault_string);
 }


 //=========================================================================
 //  XmlRpcEnv Methods
 //=========================================================================

 XmlRpcEnv::XmlRpcEnv (const XmlRpcEnv &env) {
     xmlrpc_env_init(&mEnv);
     if (env.hasFaultOccurred())
         xmlrpc_env_set_fault(&mEnv,
                              env.mEnv.fault_code,
                              env.mEnv.fault_string);
 }

 XmlRpcFault XmlRpcEnv::getFault (void) const {
     return XmlRpcFault(&mEnv);
 }

 void XmlRpcEnv::throwMe (void) const {
     throw XmlRpcFault(&mEnv);
 }


 //=========================================================================
 //  XmlRpcValue Methods
 //=========================================================================

 // If the user doesn't tell us what kind of value to create, use
 // a false boolean value as the default.
 XmlRpcValue::XmlRpcValue (void) {
     XmlRpcEnv env;
     mValue = xmlrpc_build_value(env, "b", (xmlrpc_bool) 0);
     env.throwIfFaultOccurred();
 }

 XmlRpcValue XmlRpcValue::makeInt (const XmlRpcValue::int32 i) {
     XmlRpcEnv env;
     xmlrpc_value *value = xmlrpc_build_value(env, "i", i);
     env.throwIfFaultOccurred();
     return XmlRpcValue(value, CONSUME_REFERENCE);
 }

 XmlRpcValue XmlRpcValue::makeBool (const bool b) {
     XmlRpcEnv env;
     xmlrpc_value *value = xmlrpc_build_value(env, "b", (xmlrpc_bool) b);
     env.throwIfFaultOccurred();
     return XmlRpcValue(value, CONSUME_REFERENCE);
 }

 XmlRpcValue XmlRpcValue::makeDouble (const double d) {
     XmlRpcEnv env;
     xmlrpc_value *value = xmlrpc_build_value(env, "d", d);
     env.throwIfFaultOccurred();
     return XmlRpcValue(value, CONSUME_REFERENCE);
 }

 XmlRpcValue XmlRpcValue::makeDateTime (const string& dateTime) {
     XmlRpcEnv env;
     xmlrpc_value *value;
     const char *data = dateTime.c_str(); // Make sure we're not using wchar_t.
     value = xmlrpc_build_value(env, "8", data);
     env.throwIfFaultOccurred();
     return XmlRpcValue(value, CONSUME_REFERENCE);
 }

 XmlRpcValue XmlRpcValue::makeString (const string& str) {
     XmlRpcEnv env;
     const char *data = str.data();      // Make sure we're not using wchar_t.
     size_t size = str.size();
     xmlrpc_value *value = xmlrpc_build_value(env, "s#", data, size);
     env.throwIfFaultOccurred();
     return XmlRpcValue(value, CONSUME_REFERENCE);
 }

 XmlRpcValue XmlRpcValue::makeString (const char *const str) {
     XmlRpcEnv env;
     xmlrpc_value *value = xmlrpc_build_value(env, "s", str);
     env.throwIfFaultOccurred();
     return XmlRpcValue(value, CONSUME_REFERENCE);
 }

 XmlRpcValue XmlRpcValue::makeString (const char *const str, size_t len) {
     XmlRpcEnv env;
     xmlrpc_value *value = xmlrpc_build_value(env, "s#", str, len);
     env.throwIfFaultOccurred();
     return XmlRpcValue(value, CONSUME_REFERENCE);
 }

 XmlRpcValue XmlRpcValue::makeArray (void) {
     XmlRpcEnv env;
     xmlrpc_value *value = xmlrpc_build_value(env, "()");
     env.throwIfFaultOccurred();
     return XmlRpcValue(value, CONSUME_REFERENCE);
 }

 XmlRpcValue XmlRpcValue::makeStruct (void) {
     XmlRpcEnv env;
     xmlrpc_value *value = xmlrpc_struct_new(env);
     env.throwIfFaultOccurred();
     return XmlRpcValue(value, CONSUME_REFERENCE);
 }

 XmlRpcValue XmlRpcValue::makeBase64 (const unsigned char *const data,
                                      size_t len)
 {
     XmlRpcEnv env;
     xmlrpc_value *value = xmlrpc_build_value(env, "6", data, len);
     env.throwIfFaultOccurred();
     return XmlRpcValue(value, CONSUME_REFERENCE);
 }

 XmlRpcValue::int32 XmlRpcValue::getInt (void) const {
     XmlRpcEnv env;
     XmlRpcValue::int32 result;
     xmlrpc_parse_value(env, mValue, "i", &result);
     env.throwIfFaultOccurred();
     return result;
 }

 bool XmlRpcValue::getBool (void) const {
     XmlRpcEnv env;
     xmlrpc_bool result;
     xmlrpc_parse_value(env, mValue, "b", &result);
     env.throwIfFaultOccurred();
     return result;
 }

 double XmlRpcValue::getDouble (void) const {
     XmlRpcEnv env;
     double result;
     xmlrpc_parse_value(env, mValue, "d", &result);
     env.throwIfFaultOccurred();
     return result;
 }

 string XmlRpcValue::getRawDateTime (void) const {
     XmlRpcEnv env;
     char *result;
     xmlrpc_parse_value(env, mValue, "8", &result);
     env.throwIfFaultOccurred();
     return string(result);
 }

 string XmlRpcValue::getString (void) const {
     XmlRpcEnv env;
     char *result;
     size_t result_len;
     xmlrpc_parse_value(env, mValue, "s#", &result, &result_len);
     env.throwIfFaultOccurred();
     return string(result, result_len);

 }

 XmlRpcValue XmlRpcValue::getArray (void) const {
     XmlRpcEnv env;
     xmlrpc_value *result;
     xmlrpc_parse_value(env, mValue, "A", &result);
     env.throwIfFaultOccurred();
     return XmlRpcValue(result);
 }

 XmlRpcValue XmlRpcValue::getStruct (void) const {
     XmlRpcEnv env;
     xmlrpc_value *result;
     xmlrpc_parse_value(env, mValue, "S", &result);
     env.throwIfFaultOccurred();
     return XmlRpcValue(result);
 }

 void XmlRpcValue::getBase64 (const unsigned char *& out_data,
                              size_t& out_len) const
 {
     XmlRpcEnv env;
     xmlrpc_parse_value(env, mValue, "6", &out_data, &out_len);
     env.throwIfFaultOccurred();
 }

 size_t XmlRpcValue::arraySize (void) const {
     XmlRpcEnv env;
     size_t result = xmlrpc_array_size(env, mValue);
     env.throwIfFaultOccurred();
     return result;
 }

 void XmlRpcValue::arrayAppendItem (const XmlRpcValue& value) {
     XmlRpcEnv env;
     xmlrpc_array_append_item(env, mValue, value.borrowReference());
     env.throwIfFaultOccurred();
 }

 XmlRpcValue XmlRpcValue::arrayGetItem (int index) const {
     XmlRpcEnv env;
     xmlrpc_value *result = xmlrpc_array_get_item(env, mValue, index);
     env.throwIfFaultOccurred();
     return XmlRpcValue(result);
 }

 size_t XmlRpcValue::structSize (void) const {
     XmlRpcEnv env;
     size_t result = xmlrpc_struct_size(env, mValue);
     env.throwIfFaultOccurred();
     return result;
 }

 bool XmlRpcValue::structHasKey (const string& key) const {
     XmlRpcEnv env;
     const char *keystr = key.data();
     size_t keylen = key.size();
     bool result = xmlrpc_struct_has_key_n(env, mValue,
                                           const_cast<char*>(keystr), keylen);
     env.throwIfFaultOccurred();
     return result;
 }

 XmlRpcValue XmlRpcValue::structGetValue (const string& key) const {
     XmlRpcEnv env;
     const char *keystr = key.data();
     size_t keylen = key.size();
     xmlrpc_value *result =
         xmlrpc_struct_get_value_n(env, mValue,
                                   const_cast<char*>(keystr), keylen);
     env.throwIfFaultOccurred();
     return XmlRpcValue(result);
 }

 void XmlRpcValue::structSetValue (const string& key, const XmlRpcValue& value)
 {
     XmlRpcEnv env;
     const char *keystr = key.data();
     size_t keylen = key.size();
     xmlrpc_struct_set_value_n(env, mValue, (char*) keystr, keylen,
                               value.borrowReference());
     env.throwIfFaultOccurred();
 }

 void XmlRpcValue::structGetKeyAndValue (const int index,
                                         string& out_key,
                                         XmlRpcValue& out_value) const
 {
     XmlRpcEnv env;

     xmlrpc_value *key, *value;
     xmlrpc_struct_get_key_and_value(env, mValue, index, &key, &value);
     env.throwIfFaultOccurred();

     out_key = XmlRpcValue(key).getString();
     out_value = XmlRpcValue(value);
 }

 XmlRpcGenSrv& XmlRpcGenSrv::addMethod (const string& name,
                                                         xmlrpc_method method,
                                                         void *data)
 {
     XmlRpcEnv env;

         xmlrpc_registry_add_method (env, mRegistry, NULL,
                                 name.c_str (),
                                 method, data);

     env.throwIfFaultOccurred ();
         return (*this);
 }

 XmlRpcGenSrv& XmlRpcGenSrv::addMethod (const string& name,
                         xmlrpc_method method,
                         void* data,
                         const string& signature,
                         const string& help)
 {
     XmlRpcEnv env;

         xmlrpc_registry_add_method_w_doc (env, mRegistry, NULL,
                                 name.c_str (),
                                 method, data,
                                 signature.c_str (),
                                 help.c_str ());

     env.throwIfFaultOccurred ();
         return (*this);
 }

 xmlrpc_mem_block* XmlRpcGenSrv::alloc (XmlRpcEnv& env, const string& body) const
 {
         xmlrpc_mem_block*       result = NULL;
         char*                           contents;

         result          = xmlrpc_mem_block_new (env, body.length ());
         env.throwIfFaultOccurred ();

         contents        = XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, result);

         memcpy (contents, body.c_str (), body.length ());
         return result;
 }

 string XmlRpcGenSrv::handle (const string& body) const
 {
         XmlRpcEnv env;
         string result;
         xmlrpc_mem_block*       input = NULL, * output = NULL;
         char* input_data, * output_data;
         size_t input_size, output_size;

         if (body.length () > xmlrpc_limit_get (XMLRPC_XML_SIZE_LIMIT_ID))
                 throw XmlRpcFault (XMLRPC_LIMIT_EXCEEDED_ERROR, "XML-RPC request too large");

         input   = alloc (env, body);
         input_data = XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, input);
         input_size = XMLRPC_TYPED_MEM_BLOCK_SIZE(char, input);

         output  = xmlrpc_registry_process_call (env, mRegistry, NULL,
                         input_data, input_size);

         if (output)
         {
         output_data = XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, output);
                 output_size = XMLRPC_TYPED_MEM_BLOCK_SIZE(char, output);

                 result.assign (output_data, output_size);
                 xmlrpc_mem_block_free (output);
         }

         xmlrpc_mem_block_free (input);
         if (!result.length ())
                 throw XmlRpcFault (env);

         return result;
 }
	// Copyright (C) 2001 by Eric Kidd. All rights reserved.
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions
	// are met:
	// 1. Redistributions of source code must retain the above copyright
	// notice, this list of conditions and the following disclaimer.
	// 2. Redistributions in binary form must reproduce the above copyright
	// notice, this list of conditions and the following disclaimer in the
	// documentation and/or other materials provided with the distribution.
	// 3. The name of the author may not be used to endorse or promote products
	// derived from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
	// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	// ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
	// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	// SUCH DAMAGE.


	#include "XmlRpcCpp.h"


	//=========================================================================
	// XmlRpcFault Methods
	//=========================================================================

	XmlRpcFault::XmlRpcFault (const XmlRpcFault &fault) {
	xmlrpc_env_init(&mFault);
	xmlrpc_env_set_fault(&mFault,
	fault.mFault.fault_code,
	fault.mFault.fault_string);
	}

	XmlRpcFault::XmlRpcFault (const int faultCode, const string faultString) {
	xmlrpc_env_init(&mFault);
	xmlrpc_env_set_fault(&mFault, faultCode,
	const_cast<char*>(faultString.c_str()));
	}

	XmlRpcFault::XmlRpcFault (const xmlrpc_env *env) {
	if (!env->fault_string)
	throw XmlRpcFault(XMLRPC_INTERNAL_ERROR,
	"Tried to create empty fault");
	xmlrpc_env_init(&mFault);
	xmlrpc_env_set_fault(&mFault, env->fault_code,
	const_cast<char*>(env->fault_string));
	}

	XmlRpcFault::~XmlRpcFault (void) {
	xmlrpc_env_clean(&mFault);
	}

	string XmlRpcFault::getFaultString (void) const {
	XMLRPC_ASSERT(mFault.fault_occurred);
	return string(mFault.fault_string);
	}


	//=========================================================================
	// XmlRpcEnv Methods
	//=========================================================================

	XmlRpcEnv::XmlRpcEnv (const XmlRpcEnv &env) {
	xmlrpc_env_init(&mEnv);
	if (env.hasFaultOccurred())
	xmlrpc_env_set_fault(&mEnv,
	env.mEnv.fault_code,
	env.mEnv.fault_string);
	}

	XmlRpcFault XmlRpcEnv::getFault (void) const {
	return XmlRpcFault(&mEnv);
	}

	void XmlRpcEnv::throwMe (void) const {
	throw XmlRpcFault(&mEnv);
	}


	//=========================================================================
	// XmlRpcValue Methods
	//=========================================================================

	// If the user doesn't tell us what kind of value to create, use
	// a false boolean value as the default.
	XmlRpcValue::XmlRpcValue (void) {
	XmlRpcEnv env;
	mValue = xmlrpc_build_value(env, "b", (xmlrpc_bool) 0);
	env.throwIfFaultOccurred();
	}

	XmlRpcValue XmlRpcValue::makeInt (const XmlRpcValue::int32 i) {
	XmlRpcEnv env;
	xmlrpc_value *value = xmlrpc_build_value(env, "i", i);
	env.throwIfFaultOccurred();
	return XmlRpcValue(value, CONSUME_REFERENCE);
	}

	XmlRpcValue XmlRpcValue::makeBool (const bool b) {
	XmlRpcEnv env;
	xmlrpc_value *value = xmlrpc_build_value(env, "b", (xmlrpc_bool) b);
	env.throwIfFaultOccurred();
	return XmlRpcValue(value, CONSUME_REFERENCE);
	}

	XmlRpcValue XmlRpcValue::makeDouble (const double d) {
	XmlRpcEnv env;
	xmlrpc_value *value = xmlrpc_build_value(env, "d", d);
	env.throwIfFaultOccurred();
	return XmlRpcValue(value, CONSUME_REFERENCE);
	}

	XmlRpcValue XmlRpcValue::makeDateTime (const string& dateTime) {
	XmlRpcEnv env;
	xmlrpc_value *value;
	const char *data = dateTime.c_str(); // Make sure we're not using wchar_t.
	value = xmlrpc_build_value(env, "8", data);
	env.throwIfFaultOccurred();
	return XmlRpcValue(value, CONSUME_REFERENCE);
	}

	XmlRpcValue XmlRpcValue::makeString (const string& str) {
	XmlRpcEnv env;
	const char *data = str.data(); // Make sure we're not using wchar_t.
	size_t size = str.size();
	xmlrpc_value *value = xmlrpc_build_value(env, "s#", data, size);
	env.throwIfFaultOccurred();
	return XmlRpcValue(value, CONSUME_REFERENCE);
	}

	XmlRpcValue XmlRpcValue::makeString (const char *const str) {
	XmlRpcEnv env;
	xmlrpc_value *value = xmlrpc_build_value(env, "s", str);
	env.throwIfFaultOccurred();
	return XmlRpcValue(value, CONSUME_REFERENCE);
	}

	XmlRpcValue XmlRpcValue::makeString (const char *const str, size_t len) {
	XmlRpcEnv env;
	xmlrpc_value *value = xmlrpc_build_value(env, "s#", str, len);
	env.throwIfFaultOccurred();
	return XmlRpcValue(value, CONSUME_REFERENCE);
	}

	XmlRpcValue XmlRpcValue::makeArray (void) {
	XmlRpcEnv env;
	xmlrpc_value *value = xmlrpc_build_value(env, "()");
	env.throwIfFaultOccurred();
	return XmlRpcValue(value, CONSUME_REFERENCE);
	}

	XmlRpcValue XmlRpcValue::makeStruct (void) {
	XmlRpcEnv env;
	xmlrpc_value *value = xmlrpc_struct_new(env);
	env.throwIfFaultOccurred();
	return XmlRpcValue(value, CONSUME_REFERENCE);
	}

	XmlRpcValue XmlRpcValue::makeBase64 (const unsigned char *const data,
	size_t len)
	{
	XmlRpcEnv env;
	xmlrpc_value *value = xmlrpc_build_value(env, "6", data, len);
	env.throwIfFaultOccurred();
	return XmlRpcValue(value, CONSUME_REFERENCE);
	}

	XmlRpcValue::int32 XmlRpcValue::getInt (void) const {
	XmlRpcEnv env;
	XmlRpcValue::int32 result;
	xmlrpc_parse_value(env, mValue, "i", &result);
	env.throwIfFaultOccurred();
	return result;
	}

	bool XmlRpcValue::getBool (void) const {
	XmlRpcEnv env;
	xmlrpc_bool result;
	xmlrpc_parse_value(env, mValue, "b", &result);
	env.throwIfFaultOccurred();
	return result;
	}

	double XmlRpcValue::getDouble (void) const {
	XmlRpcEnv env;
	double result;
	xmlrpc_parse_value(env, mValue, "d", &result);
	env.throwIfFaultOccurred();
	return result;
	}

	string XmlRpcValue::getRawDateTime (void) const {
	XmlRpcEnv env;
	char *result;
	xmlrpc_parse_value(env, mValue, "8", &result);
	env.throwIfFaultOccurred();
	return string(result);
	}

	string XmlRpcValue::getString (void) const {
	XmlRpcEnv env;
	char *result;
	size_t result_len;
	xmlrpc_parse_value(env, mValue, "s#", &result, &result_len);
	env.throwIfFaultOccurred();
	return string(result, result_len);

	}

	XmlRpcValue XmlRpcValue::getArray (void) const {
	XmlRpcEnv env;
	xmlrpc_value *result;
	xmlrpc_parse_value(env, mValue, "A", &result);
	env.throwIfFaultOccurred();
	return XmlRpcValue(result);
	}

	XmlRpcValue XmlRpcValue::getStruct (void) const {
	XmlRpcEnv env;
	xmlrpc_value *result;
	xmlrpc_parse_value(env, mValue, "S", &result);
	env.throwIfFaultOccurred();
	return XmlRpcValue(result);
	}

	void XmlRpcValue::getBase64 (const unsigned char *& out_data,
	size_t& out_len) const
	{
	XmlRpcEnv env;
	xmlrpc_parse_value(env, mValue, "6", &out_data, &out_len);
	env.throwIfFaultOccurred();
	}

	size_t XmlRpcValue::arraySize (void) const {
	XmlRpcEnv env;
	size_t result = xmlrpc_array_size(env, mValue);
	env.throwIfFaultOccurred();
	return result;
	}

	void XmlRpcValue::arrayAppendItem (const XmlRpcValue& value) {
	XmlRpcEnv env;
	xmlrpc_array_append_item(env, mValue, value.borrowReference());
	env.throwIfFaultOccurred();
	}

	XmlRpcValue XmlRpcValue::arrayGetItem (int index) const {
	XmlRpcEnv env;
	xmlrpc_value *result = xmlrpc_array_get_item(env, mValue, index);
	env.throwIfFaultOccurred();
	return XmlRpcValue(result);
	}

	size_t XmlRpcValue::structSize (void) const {
	XmlRpcEnv env;
	size_t result = xmlrpc_struct_size(env, mValue);
	env.throwIfFaultOccurred();
	return result;
	}

	bool XmlRpcValue::structHasKey (const string& key) const {
	XmlRpcEnv env;
	const char *keystr = key.data();
	size_t keylen = key.size();
	bool result = xmlrpc_struct_has_key_n(env, mValue,
	const_cast<char*>(keystr), keylen);
	env.throwIfFaultOccurred();
	return result;
	}

	XmlRpcValue XmlRpcValue::structGetValue (const string& key) const {
	XmlRpcEnv env;
	const char *keystr = key.data();
	size_t keylen = key.size();
	xmlrpc_value *result =
	xmlrpc_struct_get_value_n(env, mValue,
	const_cast<char*>(keystr), keylen);
	env.throwIfFaultOccurred();
	return XmlRpcValue(result);
	}

	void XmlRpcValue::structSetValue (const string& key, const XmlRpcValue& value)
	{
	XmlRpcEnv env;
	const char *keystr = key.data();
	size_t keylen = key.size();
	xmlrpc_struct_set_value_n(env, mValue, (char*) keystr, keylen,
	value.borrowReference());
	env.throwIfFaultOccurred();
	}

	void XmlRpcValue::structGetKeyAndValue (const int index,
	string& out_key,
	XmlRpcValue& out_value) const
	{
	XmlRpcEnv env;

	xmlrpc_value key, value;
	xmlrpc_struct_get_key_and_value(env, mValue, index, &key, &value);
	env.throwIfFaultOccurred();

	out_key = XmlRpcValue(key).getString();
	out_value = XmlRpcValue(value);
	}

	XmlRpcGenSrv& XmlRpcGenSrv::addMethod (const string& name,
	xmlrpc_method method,
	void *data)
	{
	XmlRpcEnv env;

	xmlrpc_registry_add_method (env, mRegistry, NULL,
	name.c_str (),
	method, data);

	env.throwIfFaultOccurred ();
	return (*this);
	}

	XmlRpcGenSrv& XmlRpcGenSrv::addMethod (const string& name,
	xmlrpc_method method,
	void* data,
	const string& signature,
	const string& help)
	{
	XmlRpcEnv env;

	xmlrpc_registry_add_method_w_doc (env, mRegistry, NULL,
	name.c_str (),
	method, data,
	signature.c_str (),
	help.c_str ());

	env.throwIfFaultOccurred ();
	return (*this);
	}

	xmlrpc_mem_block* XmlRpcGenSrv::alloc (XmlRpcEnv& env, const string& body) const
	{
	xmlrpc_mem_block* result = NULL;
	char* contents;

	result = xmlrpc_mem_block_new (env, body.length ());
	env.throwIfFaultOccurred ();

	contents = XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, result);

	memcpy (contents, body.c_str (), body.length ());
	return result;
	}

	string XmlRpcGenSrv::handle (const string& body) const
	{
	XmlRpcEnv env;
	string result;
	xmlrpc_mem_block* input = NULL, * output = NULL;
	char* input_data, * output_data;
	size_t input_size, output_size;

	if (body.length () > xmlrpc_limit_get (XMLRPC_XML_SIZE_LIMIT_ID))
	throw XmlRpcFault (XMLRPC_LIMIT_EXCEEDED_ERROR, "XML-RPC request too large");

	input = alloc (env, body);
	input_data = XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, input);
	input_size = XMLRPC_TYPED_MEM_BLOCK_SIZE(char, input);

	output = xmlrpc_registry_process_call (env, mRegistry, NULL,
	input_data, input_size);

	if (output)
	{
	output_data = XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, output);
	output_size = XMLRPC_TYPED_MEM_BLOCK_SIZE(char, output);

	result.assign (output_data, output_size);
	xmlrpc_mem_block_free (output);
	}

	xmlrpc_mem_block_free (input);
	if (!result.length ())
	throw XmlRpcFault (env);

	return result;
	}