mirror of
https://github.com/signalwire/freeswitch.git
synced 2025-04-22 11:19:52 +00:00
3abb7730b2
git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@3772 d0543943-73ff-0310-b7d9-9358b9ac24b2
808 lines
17 KiB
C++
808 lines
17 KiB
C++
/*****************************************************************************
|
|
xmlrpc_value.cpp
|
|
******************************************************************************
|
|
This module provides services for dealwith XML-RPC values. Each type
|
|
of XML-RPC value is a C++ class. An object represents a particular
|
|
XML-RPC value.
|
|
|
|
Everything is based on the C services in libxmlrpc.
|
|
|
|
We could make things more efficient by using the internal interfaces
|
|
via xmlrpc_int.h. We could make them even more efficient by dumping
|
|
libxmlrpc altogether for some or all of these services.
|
|
|
|
An xmlrpc_c::value object is really just a handle for a C xmlrpc_value
|
|
object. You're not supposed to make a pointer to an xmlrpc_c::value
|
|
object, but rather copy the object around.
|
|
|
|
Because the C xmlrpc_value object does reference counting, it
|
|
disappears automatically when the last handle does. To go pure C++,
|
|
we'd have to have a C++ object for the value itself and a separate
|
|
handle object, like Boost's shared_ptr<>.
|
|
|
|
The C++ is designed so that the user never sees the C interface at
|
|
all. Unfortunately, the user can see it if he wants because some
|
|
class members had to be declared public so that other components of
|
|
the library could see them, but the user is not supposed to access
|
|
those members.
|
|
|
|
*****************************************************************************/
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
#include <time.h>
|
|
|
|
#include "xmlrpc-c/girerr.hpp"
|
|
using girerr::error;
|
|
#include "xmlrpc-c/base.h"
|
|
#include "xmlrpc-c/base_int.h"
|
|
#include "xmlrpc-c/base.hpp"
|
|
|
|
using namespace std;
|
|
|
|
namespace {
|
|
|
|
class cDatetimeValueWrapper {
|
|
public:
|
|
xmlrpc_value * valueP;
|
|
|
|
cDatetimeValueWrapper(time_t const cppvalue) {
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
this->valueP = xmlrpc_datetime_new_sec(&env, cppvalue);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
}
|
|
~cDatetimeValueWrapper() {
|
|
xmlrpc_DECREF(this->valueP);
|
|
}
|
|
};
|
|
|
|
|
|
class cStringWrapper {
|
|
public:
|
|
const char * str;
|
|
size_t length;
|
|
cStringWrapper(xmlrpc_value * valueP) {
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
xmlrpc_read_string_lp(&env, valueP, &length, &str);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
}
|
|
~cStringWrapper() {
|
|
free((char*)str);
|
|
}
|
|
};
|
|
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
namespace xmlrpc_c {
|
|
|
|
value::value() {
|
|
this->cValueP = NULL;
|
|
}
|
|
|
|
|
|
|
|
value::value(xmlrpc_value * const valueP) { // default constructor
|
|
|
|
this->instantiate(valueP);
|
|
}
|
|
|
|
|
|
|
|
value::value(xmlrpc_c::value const& value) { // copy constructor
|
|
this->cValueP = value.cValue();
|
|
}
|
|
|
|
|
|
|
|
xmlrpc_c::value&
|
|
value::operator=(xmlrpc_c::value const& value) {
|
|
|
|
if (this->cValueP != NULL)
|
|
throw(error("Assigning to already instantiated xmlrpc_c::value"));
|
|
|
|
this->cValueP = value.cValue();
|
|
return *this; // The result of the (a = b) expression
|
|
}
|
|
|
|
|
|
|
|
value::~value() {
|
|
if (this->cValueP) {
|
|
xmlrpc_DECREF(this->cValueP);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void
|
|
value::instantiate(xmlrpc_value * const valueP) {
|
|
|
|
xmlrpc_INCREF(valueP);
|
|
this->cValueP = valueP;
|
|
}
|
|
|
|
|
|
|
|
xmlrpc_value *
|
|
value::cValue() const {
|
|
|
|
if (this->cValueP) {
|
|
xmlrpc_INCREF(this->cValueP); // For Caller
|
|
}
|
|
return this->cValueP;
|
|
}
|
|
|
|
|
|
|
|
void
|
|
value::appendToCArray(xmlrpc_value * const arrayP) const {
|
|
/*----------------------------------------------------------------------------
|
|
Append this value to the C array 'arrayP'.
|
|
----------------------------------------------------------------------------*/
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
xmlrpc_array_append_item(&env, arrayP, this->cValueP);
|
|
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
}
|
|
|
|
|
|
|
|
void
|
|
value::addToCStruct(xmlrpc_value * const structP,
|
|
string const key) const {
|
|
/*----------------------------------------------------------------------------
|
|
Add this value to the C array 'arrayP' with key 'key'.
|
|
----------------------------------------------------------------------------*/
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
xmlrpc_struct_set_value_n(&env, structP,
|
|
key.c_str(), key.length(),
|
|
this->cValueP);
|
|
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
}
|
|
|
|
|
|
|
|
value::type_t
|
|
value::type() const {
|
|
/* You'd think we could just cast from xmlrpc_type to
|
|
value:type_t, but Gcc warns if we do that. So we have to do this
|
|
even messier union nonsense.
|
|
*/
|
|
union {
|
|
xmlrpc_type x;
|
|
value::type_t y;
|
|
} u;
|
|
|
|
u.x = xmlrpc_value_type(this->cValueP);
|
|
|
|
return u.y;
|
|
}
|
|
|
|
|
|
|
|
value_int::value_int(int const cppvalue) {
|
|
|
|
class cWrapper {
|
|
public:
|
|
xmlrpc_value * valueP;
|
|
|
|
cWrapper(int const cppvalue) {
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
this->valueP = xmlrpc_int_new(&env, cppvalue);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
}
|
|
~cWrapper() {
|
|
xmlrpc_DECREF(this->valueP);
|
|
}
|
|
};
|
|
|
|
cWrapper wrapper(cppvalue);
|
|
|
|
this->instantiate(wrapper.valueP);
|
|
}
|
|
|
|
|
|
|
|
value_int::value_int(xmlrpc_c::value const baseValue) {
|
|
|
|
if (baseValue.type() != xmlrpc_c::value::TYPE_INT)
|
|
throw(error("Not integer type. See type() method"));
|
|
else {
|
|
this->instantiate(baseValue.cValueP);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
value_int::operator int() const {
|
|
|
|
int retval;
|
|
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
xmlrpc_read_int(&env, this->cValueP, &retval);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
|
|
value_double::value_double(double const cppvalue) {
|
|
|
|
class cWrapper {
|
|
public:
|
|
xmlrpc_value * valueP;
|
|
|
|
cWrapper(double const cppvalue) {
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
this->valueP = xmlrpc_double_new(&env, cppvalue);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
}
|
|
~cWrapper() {
|
|
xmlrpc_DECREF(this->valueP);
|
|
}
|
|
};
|
|
|
|
this->instantiate(cWrapper(cppvalue).valueP);
|
|
}
|
|
|
|
|
|
|
|
value_double::value_double(xmlrpc_c::value const baseValue) {
|
|
|
|
if (baseValue.type() != xmlrpc_c::value::TYPE_DOUBLE)
|
|
throw(error("Not double type. See type() method"));
|
|
else {
|
|
this->instantiate(baseValue.cValueP);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
value_double::operator double() const {
|
|
|
|
double retval;
|
|
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
xmlrpc_read_double(&env, this->cValueP, &retval);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
|
|
value_boolean::value_boolean(bool const cppvalue) {
|
|
|
|
class cWrapper {
|
|
public:
|
|
xmlrpc_value * valueP;
|
|
|
|
cWrapper(xmlrpc_bool const cppvalue) {
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
this->valueP = xmlrpc_bool_new(&env, cppvalue);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
}
|
|
~cWrapper() {
|
|
xmlrpc_DECREF(this->valueP);
|
|
}
|
|
};
|
|
|
|
cWrapper wrapper(cppvalue);
|
|
|
|
this->instantiate(wrapper.valueP);
|
|
}
|
|
|
|
|
|
|
|
value_boolean::operator bool() const {
|
|
|
|
xmlrpc_bool retval;
|
|
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
xmlrpc_read_bool(&env, this->cValueP, &retval);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
|
|
return (bool)retval;
|
|
}
|
|
|
|
|
|
|
|
value_boolean::value_boolean(xmlrpc_c::value const baseValue) {
|
|
|
|
if (baseValue.type() != xmlrpc_c::value::TYPE_BOOLEAN)
|
|
throw(error("Not boolean type. See type() method"));
|
|
else {
|
|
this->instantiate(baseValue.cValueP);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
value_datetime::value_datetime(string const cppvalue) {
|
|
|
|
class cWrapper {
|
|
public:
|
|
xmlrpc_value * valueP;
|
|
|
|
cWrapper(string const cppvalue) {
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
this->valueP = xmlrpc_datetime_new_str(&env, cppvalue.c_str());
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
}
|
|
~cWrapper() {
|
|
xmlrpc_DECREF(this->valueP);
|
|
}
|
|
};
|
|
|
|
cWrapper wrapper(cppvalue);
|
|
|
|
this->instantiate(wrapper.valueP);
|
|
}
|
|
|
|
|
|
|
|
value_datetime::value_datetime(time_t const cppvalue) {
|
|
|
|
cDatetimeValueWrapper wrapper(cppvalue);
|
|
|
|
this->instantiate(wrapper.valueP);
|
|
}
|
|
|
|
|
|
|
|
value_datetime::value_datetime(struct timeval const& cppvalue) {
|
|
|
|
cDatetimeValueWrapper wrapper(cppvalue.tv_sec);
|
|
|
|
this->instantiate(wrapper.valueP);
|
|
}
|
|
|
|
|
|
|
|
value_datetime::value_datetime(struct timespec const& cppvalue) {
|
|
|
|
cDatetimeValueWrapper wrapper(cppvalue.tv_sec);
|
|
|
|
this->instantiate(wrapper.valueP);
|
|
}
|
|
|
|
|
|
|
|
value_datetime::value_datetime(xmlrpc_c::value const baseValue) {
|
|
|
|
if (baseValue.type() != xmlrpc_c::value::TYPE_DATETIME)
|
|
throw(error("Not datetime type. See type() method"));
|
|
else {
|
|
this->instantiate(baseValue.cValueP);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
value_datetime::operator time_t() const {
|
|
|
|
time_t retval;
|
|
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
xmlrpc_read_datetime_sec(&env, this->cValueP, &retval);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
|
|
value_string::value_string(string const& cppvalue) {
|
|
|
|
class cWrapper {
|
|
public:
|
|
xmlrpc_value * valueP;
|
|
|
|
cWrapper(string const cppvalue) {
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
this->valueP = xmlrpc_string_new(&env, cppvalue.c_str());
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
}
|
|
~cWrapper() {
|
|
xmlrpc_DECREF(this->valueP);
|
|
}
|
|
};
|
|
|
|
cWrapper wrapper(cppvalue);
|
|
|
|
this->instantiate(wrapper.valueP);
|
|
}
|
|
|
|
|
|
|
|
value_string::value_string(xmlrpc_c::value const baseValue) {
|
|
|
|
if (baseValue.type() != xmlrpc_c::value::TYPE_STRING)
|
|
throw(error("Not string type. See type() method"));
|
|
else {
|
|
this->instantiate(baseValue.cValueP);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
value_string::operator string() const {
|
|
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
cStringWrapper adapter(this->cValueP);
|
|
|
|
return string(adapter.str, adapter.length);
|
|
}
|
|
|
|
|
|
|
|
value_bytestring::value_bytestring(
|
|
vector<unsigned char> const& cppvalue) {
|
|
|
|
class cWrapper {
|
|
public:
|
|
xmlrpc_value * valueP;
|
|
|
|
cWrapper(vector<unsigned char> const& cppvalue) {
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
this->valueP =
|
|
xmlrpc_base64_new(&env, cppvalue.size(), &cppvalue[0]);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
}
|
|
~cWrapper() {
|
|
xmlrpc_DECREF(this->valueP);
|
|
}
|
|
};
|
|
|
|
cWrapper wrapper(cppvalue);
|
|
|
|
this->instantiate(wrapper.valueP);
|
|
}
|
|
|
|
|
|
|
|
vector<unsigned char>
|
|
value_bytestring::vectorUcharValue() const {
|
|
|
|
class cWrapper {
|
|
public:
|
|
const unsigned char * contents;
|
|
size_t length;
|
|
|
|
cWrapper(xmlrpc_value * const valueP) {
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
xmlrpc_read_base64(&env, valueP, &length, &contents);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
}
|
|
~cWrapper() {
|
|
free((void*)contents);
|
|
}
|
|
};
|
|
|
|
cWrapper wrapper(this->cValueP);
|
|
|
|
return vector<unsigned char>(&wrapper.contents[0],
|
|
&wrapper.contents[wrapper.length]);
|
|
}
|
|
|
|
|
|
|
|
size_t
|
|
value_bytestring::length() const {
|
|
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
size_t length;
|
|
xmlrpc_read_base64_size(&env, this->cValueP, &length);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
|
|
return length;
|
|
}
|
|
|
|
|
|
|
|
value_bytestring::value_bytestring(xmlrpc_c::value const baseValue) {
|
|
|
|
if (baseValue.type() != xmlrpc_c::value::TYPE_BYTESTRING)
|
|
throw(error("Not byte string type. See type() method"));
|
|
else {
|
|
this->instantiate(baseValue.cValueP);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
value_array::value_array(vector<xmlrpc_c::value> const& cppvalue) {
|
|
|
|
class cWrapper {
|
|
public:
|
|
xmlrpc_value * valueP;
|
|
|
|
cWrapper() {
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
this->valueP = xmlrpc_array_new(&env);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
}
|
|
~cWrapper() {
|
|
xmlrpc_DECREF(this->valueP);
|
|
}
|
|
};
|
|
|
|
cWrapper wrapper;
|
|
|
|
vector<xmlrpc_c::value>::const_iterator i;
|
|
for (i = cppvalue.begin(); i != cppvalue.end(); ++i)
|
|
i->appendToCArray(wrapper.valueP);
|
|
|
|
this->instantiate(wrapper.valueP);
|
|
}
|
|
|
|
|
|
|
|
value_array::value_array(xmlrpc_c::value const baseValue) {
|
|
|
|
if (baseValue.type() != xmlrpc_c::value::TYPE_ARRAY)
|
|
throw(error("Not array type. See type() method"));
|
|
else {
|
|
this->instantiate(baseValue.cValueP);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
vector<xmlrpc_c::value>
|
|
value_array::vectorValueValue() const {
|
|
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
unsigned int arraySize;
|
|
|
|
arraySize = xmlrpc_array_size(&env, this->cValueP);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
|
|
vector<xmlrpc_c::value> retval(arraySize);
|
|
|
|
for (unsigned int i = 0; i < arraySize; ++i) {
|
|
|
|
class cWrapper {
|
|
public:
|
|
xmlrpc_value * valueP;
|
|
|
|
cWrapper(xmlrpc_value * const arrayP,
|
|
unsigned int const index) {
|
|
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
xmlrpc_array_read_item(&env, arrayP, index, &valueP);
|
|
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
}
|
|
~cWrapper() {
|
|
xmlrpc_DECREF(valueP);
|
|
}
|
|
};
|
|
|
|
cWrapper wrapper(this->cValueP, i);
|
|
|
|
retval[i].instantiate(wrapper.valueP);
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
|
|
size_t
|
|
value_array::size() const {
|
|
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
unsigned int arraySize;
|
|
|
|
arraySize = xmlrpc_array_size(&env, this->cValueP);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
|
|
return arraySize;
|
|
}
|
|
|
|
|
|
|
|
value_struct::value_struct(
|
|
map<string, xmlrpc_c::value> const &cppvalue) {
|
|
|
|
class cWrapper {
|
|
public:
|
|
xmlrpc_value * valueP;
|
|
|
|
cWrapper() {
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
this->valueP = xmlrpc_struct_new(&env);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
}
|
|
~cWrapper() {
|
|
xmlrpc_DECREF(this->valueP);
|
|
}
|
|
};
|
|
|
|
cWrapper wrapper;
|
|
|
|
map<string, xmlrpc_c::value>::const_iterator i;
|
|
for (i = cppvalue.begin(); i != cppvalue.end(); ++i) {
|
|
xmlrpc_c::value mapvalue(i->second);
|
|
string mapkey(i->first);
|
|
mapvalue.addToCStruct(wrapper.valueP, mapkey);
|
|
}
|
|
|
|
this->instantiate(wrapper.valueP);
|
|
}
|
|
|
|
|
|
|
|
value_struct::value_struct(xmlrpc_c::value const baseValue) {
|
|
|
|
if (baseValue.type() != xmlrpc_c::value::TYPE_STRUCT)
|
|
throw(error("Not struct type. See type() method"));
|
|
else {
|
|
this->instantiate(baseValue.cValueP);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
value_struct::operator map<string, xmlrpc_c::value>() const {
|
|
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
unsigned int structSize;
|
|
|
|
structSize = xmlrpc_struct_size(&env, this->cValueP);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
|
|
map<string, xmlrpc_c::value> retval;
|
|
|
|
for (unsigned int i = 0; i < structSize; ++i) {
|
|
class cMemberWrapper {
|
|
public:
|
|
xmlrpc_value * keyP;
|
|
xmlrpc_value * valueP;
|
|
|
|
cMemberWrapper(xmlrpc_value * const structP,
|
|
unsigned int const index) {
|
|
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
xmlrpc_struct_read_member(&env, structP, index,
|
|
&keyP, &valueP);
|
|
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
}
|
|
~cMemberWrapper() {
|
|
xmlrpc_DECREF(keyP);
|
|
xmlrpc_DECREF(valueP);
|
|
}
|
|
};
|
|
|
|
cMemberWrapper memberWrapper(this->cValueP, i);
|
|
|
|
cStringWrapper keyWrapper(memberWrapper.keyP);
|
|
|
|
string const key(keyWrapper.str, keyWrapper.length);
|
|
|
|
retval[key] = xmlrpc_c::value(memberWrapper.valueP);
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
|
|
value_nil::value_nil() {
|
|
|
|
class cWrapper {
|
|
public:
|
|
xmlrpc_value * valueP;
|
|
|
|
cWrapper() {
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
|
|
this->valueP = xmlrpc_nil_new(&env);
|
|
if (env.fault_occurred)
|
|
throw(error(env.fault_string));
|
|
}
|
|
~cWrapper() {
|
|
xmlrpc_DECREF(this->valueP);
|
|
}
|
|
};
|
|
|
|
cWrapper wrapper;
|
|
|
|
this->instantiate(wrapper.valueP);
|
|
}
|
|
|
|
|
|
|
|
value_nil::value_nil(xmlrpc_c::value const baseValue) {
|
|
|
|
if (baseValue.type() != xmlrpc_c::value::TYPE_NIL)
|
|
throw(error("Not nil type. See type() method"));
|
|
else {
|
|
this->instantiate(baseValue.cValueP);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
} // namespace
|
|
|