diff options
Diffstat (limited to 'ext/xmlrpc/libxmlrpc/xmlrpc.c')
| -rw-r--r-- | ext/xmlrpc/libxmlrpc/xmlrpc.c | 3006 |
1 files changed, 3006 insertions, 0 deletions
diff --git a/ext/xmlrpc/libxmlrpc/xmlrpc.c b/ext/xmlrpc/libxmlrpc/xmlrpc.c new file mode 100644 index 0000000..ec2321b --- /dev/null +++ b/ext/xmlrpc/libxmlrpc/xmlrpc.c @@ -0,0 +1,3006 @@ +/* + This file is part of libXMLRPC - a C library for xml-encoded function calls. + + Author: Dan Libby (dan@libby.com) + Epinions.com may be contacted at feedback@epinions-inc.com +*/ + +/* + Copyright 2000 Epinions, Inc. + + Subject to the following 3 conditions, Epinions, Inc. permits you, free + of charge, to (a) use, copy, distribute, modify, perform and display this + software and associated documentation files (the "Software"), and (b) + permit others to whom the Software is furnished to do so as well. + + 1) The above copyright notice and this permission notice shall be included + without modification in all copies or substantial portions of the + Software. + + 2) THE SOFTWARE IS PROVIDED "AS IS", WITHOUT ANY WARRANTY OR CONDITION OF + ANY KIND, EXPRESS, IMPLIED OR STATUTORY, INCLUDING WITHOUT LIMITATION ANY + IMPLIED WARRANTIES OF ACCURACY, MERCHANTABILITY, FITNESS FOR A PARTICULAR + PURPOSE OR NONINFRINGEMENT. + + 3) IN NO EVENT SHALL EPINIONS, INC. BE LIABLE FOR ANY DIRECT, INDIRECT, + SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT + OF OR IN CONNECTION WITH THE SOFTWARE (HOWEVER ARISING, INCLUDING + NEGLIGENCE), EVEN IF EPINIONS, INC. IS AWARE OF THE POSSIBILITY OF SUCH + DAMAGES. + +*/ + + +static const char rcsid[] = "#(@) $Id$"; + + +/****h* ABOUT/xmlrpc + * NAME + * XMLRPC_VALUE + * AUTHOR + * Dan Libby, aka danda (dan@libby.com) + * CREATION DATE + * 9/1999 - 10/2000 + * HISTORY + * $Log$ + * Revision 1.8.4.3.2.1 2008/09/10 00:07:44 felipe + * MFH: + * - Merged fix from SF project (Import Jeff Lawsons patches for XML datetime bug fixes) + * Fixed bugs: + * #45226 (xmlrpc_set_type() segfaults with valid ISO8601 date string) + * #18916 (xmlrpc_set_type() "not working") + * + * Revision 1.8.4.3 2007/09/18 19:49:53 iliaa + * + * Fixed bug #42189 (xmlrpc_set_type() crashes php on invalid datetime + * values). + * + * Revision 1.8.4.2 2007/06/07 09:07:36 tony2001 + * MFH: php_localtime_r() checks + * + * Revision 1.8.4.1 2006/11/30 16:38:37 iliaa + * last set of zts fixes + * + * Revision 1.8 2005/03/28 00:07:24 edink + * Reshufle includes to make it compile on windows + * + * Revision 1.7 2005/03/26 03:13:58 sniper + * - Made it possible to build ext/xmlrpc with libxml2 + * + * Revision 1.6 2004/04/27 17:33:59 iliaa + * Removed C++ style comments. + * + * Revision 1.5 2003/12/16 21:00:21 sniper + * Fix some compile warnings (patch by Joe Orton) + * + * Revision 1.4 2002/07/05 04:43:53 danda + * merged in updates from SF project. bring php repository up to date with xmlrpc-epi version 0.51 + * + * Revision 1.22 2002/03/09 23:15:44 danda + * add fault interrogation funcs + * + * Revision 1.21 2002/03/09 22:27:41 danda + * win32 build patches contributed by Jeff Lawson + * + * Revision 1.20 2002/02/13 20:58:50 danda + * patch to make source more windows friendly, contributed by Jeff Lawson + * + * Revision 1.19 2001/10/12 23:25:54 danda + * default to writing xmlrpc + * + * Revision 1.18 2001/09/29 21:58:05 danda + * adding cvs log to history section + * + * 10/15/2000 -- danda -- adding robodoc documentation + * 08/2000 -- danda -- PHP C extension that uses XMLRPC + * 08/2000 -- danda -- support for two vocabularies: danda-rpc and xml-rpc + * 09/1999 -- danda -- Initial API, before I even knew of standard XMLRPC vocab. Response only. + * 07/2000 -- danda -- wrote new implementation to be compatible with xmlrpc standard and + * incorporated some ideas from ensor, most notably the separation of + * xml dom from xmlrpc api. + * 06/2000 -- danda -- played with expat-ensor from www.ensor.org. Cool, but some flaws. + * TODO + * PORTABILITY + * Coded on RedHat Linux 6.2. Builds on Solaris x86. Should build on just + * about anything with minor mods. + * NOTES + * Welcome to XMLRPC. For more info on the specification and history, see + * http://www.xmlrpc.org. + * + * This code aims to be a full-featured C implementation of XMLRPC. It does not + * have any networking code. Rather, it is intended to be plugged into apps + * or libraries with existing networking facilities, eg PHP, apache, perl, mozilla, + * home-brew application servers, etc. + * + * Usage Paradigm: + * The user of this library will typically be implementing either an XMLRPC server, + * an XMLRPC client, or both. The client will use the library to build an in-memory + * representation of a request, and then serialize (encode) that request into XML. The + * client will then send the XML to the server via external mechanism. The server will + * de-serialize the XML back into an binary representation, call the appropriate registered + * method -- thereby generating a response. The response will be serialized into XML and + * sent back to the client. The client will de-serialize it into memory, and can + * iterate through the results via API. + * + * Both the request and the response may consist of arbitrarily long, arbitrarily nested + * values. The values may be one of several types, as defined by XMLRPC_VALUE_TYPE. + * + * Features and Architecture: + * - The XML parsing (xml_element.c) is completely independent of the XMLRPC api. In fact, + * it can be used as a standalone dom implementation. + * - Because of this, the same XMLRPC data can be serialized into multiple xml vocabularies. + * It is simply a matter of writing a transport. So far, two transports have been defined. + * The default xmlrpc vocab (xml_to_xmlrpc.c), and simple-rpc (xml_to_dandarpc.c) which is + * proprietary, but imho more readable, and nice for proprietary legacy reasons. + * - Various output options, including: xml escaping via CDATA or entity, case folding, + * vocab version, and character encoding. + * - One to One mapping between C structures and actual values, unlike ensor which forces + * one to understand the arcana of the xmlrpc vocab. + * - support for mixed indexed/keyed vector types, making it more compatible with + * languages such as PHP. + * - quite speedy compared to implementations written in interpreted languages. Also, uses + * intelligent string handling, so not many strlen() calls, etc. + * - comprehensive API for manipulation of values + *******/ + +#include "ext/xml/expat_compat.h" +#include "main/php_reentrancy.h" +#ifdef _WIN32 +#include "xmlrpc_win32.h" +#endif +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <stdarg.h> +#include <time.h> +#include <ctype.h> + +#include "queue.h" +#include "xmlrpc.h" +#include "base64.h" + +#include "xml_to_xmlrpc.h" +#include "xml_to_dandarpc.h" +#include "xml_to_soap.h" +#include "xml_element.h" +#include "xmlrpc_private.h" +#include "xmlrpc_introspection_private.h" +#include "system_methods_private.h" + + + +/*-********************* +* Begin Time Functions * +***********************/ + +static time_t mkgmtime(struct tm *tm) +{ + static const int mdays[12] = {0,31,59,90,120,151,181,212,243,273,304,334}; + + return ((((((tm->tm_year - 70) * 365) + mdays[tm->tm_mon] + tm->tm_mday-1 + + (tm->tm_year-68-1+(tm->tm_mon>=2))/4) * 24) + tm->tm_hour) * 60 + + tm->tm_min) * 60 + tm->tm_sec; +} + +static int date_from_ISO8601 (const char *text, time_t * value) { + struct tm tm; + int n; + int i; + char buf[30]; + + + if (strchr (text, '-')) { + char *p = (char *) text, *p2 = buf; + while (p && *p) { + if (*p != '-') { + *p2 = *p; + p2++; + if (p2-buf >= sizeof(buf)) { + return -1; + } + } + p++; + } + text = buf; + } + + + tm.tm_isdst = -1; + +#define XMLRPC_IS_NUMBER(x) if (x < '0' || x > '9') return -1; + + n = 1000; + tm.tm_year = 0; + for(i = 0; i < 4; i++) { + XMLRPC_IS_NUMBER(text[i]) + tm.tm_year += (text[i]-'0')*n; + n /= 10; + } + n = 10; + tm.tm_mon = 0; + for(i = 0; i < 2; i++) { + XMLRPC_IS_NUMBER(text[i]) + tm.tm_mon += (text[i+4]-'0')*n; + n /= 10; + } + tm.tm_mon --; + + n = 10; + tm.tm_mday = 0; + for(i = 0; i < 2; i++) { + XMLRPC_IS_NUMBER(text[i]) + tm.tm_mday += (text[i+6]-'0')*n; + n /= 10; + } + + n = 10; + tm.tm_hour = 0; + for(i = 0; i < 2; i++) { + XMLRPC_IS_NUMBER(text[i]) + tm.tm_hour += (text[i+9]-'0')*n; + n /= 10; + } + + n = 10; + tm.tm_min = 0; + for(i = 0; i < 2; i++) { + XMLRPC_IS_NUMBER(text[i]) + tm.tm_min += (text[i+12]-'0')*n; + n /= 10; + } + + n = 10; + tm.tm_sec = 0; + for(i = 0; i < 2; i++) { + XMLRPC_IS_NUMBER(text[i]) + tm.tm_sec += (text[i+15]-'0')*n; + n /= 10; + } + + tm.tm_year -= 1900; + + *value = mkgmtime(&tm); + + return 0; + +} + +static int date_to_ISO8601 (time_t value, char *buf, int length) { + struct tm *tm, tmbuf; + tm = php_gmtime_r(&value, &tmbuf); + if (!tm) { + return 0; + } +#if 0 /* TODO: soap seems to favor this method. xmlrpc the latter. */ + return strftime (buf, length, "%Y-%m-%dT%H:%M:%SZ", tm); +#else + return strftime(buf, length, "%Y%m%dT%H:%M:%SZ", tm); +#endif +} + +/*-******************* +* End Time Functions * +*********************/ + + +/*-*************************** +* Begin XMLRPC_REQUEST funcs * +*****************************/ + +/****f* REQUEST/XMLRPC_RequestNew + * NAME + * XMLRPC_RequestNew + * SYNOPSIS + * XMLRPC_REQUEST XMLRPC_RequestNew() + * FUNCTION + * Creates a new XMLRPC_Request data struct + * INPUTS + * none + * SEE ALSO + * XMLRPC_RequestFree () + * SOURCE + */ +XMLRPC_REQUEST XMLRPC_RequestNew() { + XMLRPC_REQUEST xRequest = calloc(1, sizeof(STRUCT_XMLRPC_REQUEST)); + if(xRequest) { + simplestring_init(&xRequest->methodName); + } + return xRequest; +} + +/*******/ + +/****f* REQUEST/XMLRPC_RequestFree + * NAME + * XMLRPC_RequestFree + * SYNOPSIS + * void XMLRPC_RequestFree(XMLRPC_REQUEST request, int bFreeIO) + * FUNCTION + * Free XMLRPC Request and all sub-values + * INPUTS + * request -- previously allocated request struct + * bFreeIO -- 1 = also free request value data, if any, 0 = ignore. + * SEE ALSO + * XMLRPC_RequestNew () + * XMLRPC_CleanupValue () + * SOURCE + */ +void XMLRPC_RequestFree(XMLRPC_REQUEST request, int bFreeIO) { + if(request) { + simplestring_free(&request->methodName); + + if(request->io && bFreeIO) { + XMLRPC_CleanupValue(request->io); + } + if(request->error) { + XMLRPC_CleanupValue(request->error); + } + my_free(request); + } +} + +/*******/ + +/* Set Method Name to call */ +/****f* REQUEST/XMLRPC_RequestSetMethodName + * NAME + * XMLRPC_RequestSetMethodName + * SYNOPSIS + * const char* XMLRPC_RequestSetMethodName(XMLRPC_REQUEST request, const char* methodName) + * FUNCTION + * Set name of method to call with this request. + * INPUTS + * request -- previously allocated request struct + * methodName -- name of method + * SEE ALSO + * XMLRPC_RequestNew () + * XMLRPC_RequestGetMethodName () + * XMLRPC_RequestFree () + * SOURCE + */ +const char* XMLRPC_RequestSetMethodName(XMLRPC_REQUEST request, const char* methodName) { + if(request) { + simplestring_clear(&request->methodName); + simplestring_add(&request->methodName, methodName); + return request->methodName.str; + } + return NULL; +} + +/*******/ + +/****f* REQUEST/XMLRPC_RequestGetMethodName + * NAME + * XMLRPC_RequestGetMethodName + * SYNOPSIS + * const char* XMLRPC_RequestGetMethodName(XMLRPC_REQUEST request) + * FUNCTION + * Get name of method called by this request + * INPUTS + * request -- previously allocated request struct + * SEE ALSO + * XMLRPC_RequestNew () + * XMLRPC_RequestSetMethodName () + * XMLRPC_RequestFree () + * SOURCE + */ +const char* XMLRPC_RequestGetMethodName(XMLRPC_REQUEST request) { + return request ? request->methodName.str : NULL; +} + +/*******/ + +/****f* REQUEST/XMLRPC_RequestSetRequestType + * NAME + * XMLRPC_RequestSetRequestType + * SYNOPSIS + * XMLRPC_REQUEST_TYPE XMLRPC_RequestSetRequestType(XMLRPC_REQUEST request, XMLRPC_REQUEST_TYPE type) + * FUNCTION + * A request struct may be allocated by a caller or by xmlrpc + * in response to a request. This allows setting the + * request type. + * INPUTS + * request -- previously allocated request struct + * type -- request type [xmlrpc_method_call | xmlrpc_method_response] + * SEE ALSO + * XMLRPC_RequestNew () + * XMLRPC_RequestGetRequestType () + * XMLRPC_RequestFree () + * XMLRPC_REQUEST_TYPE + * SOURCE + */ +XMLRPC_REQUEST_TYPE XMLRPC_RequestSetRequestType (XMLRPC_REQUEST request, + XMLRPC_REQUEST_TYPE type) { + if(request) { + request->request_type = type; + return request->request_type; + } + return xmlrpc_request_none; +} + +/*******/ + +/****f* REQUEST/XMLRPC_RequestGetRequestType + * NAME + * XMLRPC_RequestGetRequestType + * SYNOPSIS + * XMLRPC_REQUEST_TYPE XMLRPC_RequestGetRequestType(XMLRPC_REQUEST request) + * FUNCTION + * A request struct may be allocated by a caller or by xmlrpc + * in response to a request. This allows setting the + * request type. + * INPUTS + * request -- previously allocated request struct + * RESULT + * type -- request type [xmlrpc_method_call | xmlrpc_method_response] + * SEE ALSO + * XMLRPC_RequestNew () + * XMLRPC_RequestSetRequestType () + * XMLRPC_RequestFree () + * XMLRPC_REQUEST_TYPE + * SOURCE + */ +XMLRPC_REQUEST_TYPE XMLRPC_RequestGetRequestType(XMLRPC_REQUEST request) { + return request ? request->request_type : xmlrpc_request_none; +} + +/*******/ + + +/****f* REQUEST/XMLRPC_RequestSetData + * NAME + * XMLRPC_RequestSetData + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_RequestSetData(XMLRPC_REQUEST request, XMLRPC_VALUE data) + * FUNCTION + * Associates a block of xmlrpc data with the request. The + * data is *not* copied. A pointer is kept. The caller + * should be careful not to doubly free the data value, + * which may optionally be free'd by XMLRPC_RequestFree(). + * INPUTS + * request -- previously allocated request struct + * data -- previously allocated data struct + * RESULT + * XMLRPC_VALUE -- pointer to value stored, or NULL + * SEE ALSO + * XMLRPC_RequestNew () + * XMLRPC_RequestGetData () + * XMLRPC_RequestFree () + * XMLRPC_REQUEST + * XMLRPC_VALUE + * SOURCE + */ +XMLRPC_VALUE XMLRPC_RequestSetData(XMLRPC_REQUEST request, XMLRPC_VALUE data) { + if(request && data) { + if (request->io) { + XMLRPC_CleanupValue (request->io); + } + request->io = XMLRPC_CopyValue(data); + return request->io; + } + return NULL; +} + +/*******/ + +/****f* REQUEST/XMLRPC_RequestGetData + * NAME + * XMLRPC_RequestGetData + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_RequestGetData(XMLRPC_REQUEST request) + * FUNCTION + * Returns data associated with request, if any. + * INPUTS + * request -- previously allocated request struct + * RESULT + * XMLRPC_VALUE -- pointer to value stored, or NULL + * SEE ALSO + * XMLRPC_RequestNew () + * XMLRPC_RequestSetData () + * XMLRPC_RequestFree () + * XMLRPC_REQUEST + * XMLRPC_VALUE + * SOURCE + */ +XMLRPC_VALUE XMLRPC_RequestGetData(XMLRPC_REQUEST request) { + return request ? request->io : NULL; +} + +/*******/ + +/****f* REQUEST/XMLRPC_RequestSetError + * NAME + * XMLRPC_RequestSetError + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_RequestSetError(XMLRPC_REQUEST request, XMLRPC_VALUE error) + * FUNCTION + * Associates a block of xmlrpc data, representing an error + * condition, with the request. + * INPUTS + * request -- previously allocated request struct + * error -- previously allocated error code or struct + * RESULT + * XMLRPC_VALUE -- pointer to value stored, or NULL + * NOTES + * This is a private function for usage by internals only. + * SEE ALSO + * XMLRPC_RequestGetError () + * SOURCE + */ +XMLRPC_VALUE XMLRPC_RequestSetError (XMLRPC_REQUEST request, XMLRPC_VALUE error) { + if (request && error) { + if (request->error) { + XMLRPC_CleanupValue (request->error); + } + request->error = XMLRPC_CopyValue (error); + return request->error; + } + return NULL; +} + +/*******/ + +/****f* REQUEST/XMLRPC_RequestGetError + * NAME + * XMLRPC_RequestGetError + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_RequestGetError(XMLRPC_REQUEST request) + * FUNCTION + * Returns error data associated with request, if any. + * INPUTS + * request -- previously allocated request struct + * RESULT + * XMLRPC_VALUE -- pointer to error value stored, or NULL + * NOTES + * This is a private function for usage by internals only. + * SEE ALSO + * XMLRPC_RequestSetError () + * XMLRPC_RequestFree () + * SOURCE + */ +XMLRPC_VALUE XMLRPC_RequestGetError (XMLRPC_REQUEST request) { + return request ? request->error : NULL; +} + +/*******/ + + +/****f* REQUEST/XMLRPC_RequestSetOutputOptions + * NAME + * XMLRPC_RequestSetOutputOptions + * SYNOPSIS + * XMLRPC_REQUEST_OUTPUT_OPTIONS XMLRPC_RequestSetOutputOptions(XMLRPC_REQUEST request, XMLRPC_REQUEST_OUTPUT_OPTIONS output) + * FUNCTION + * Sets output options used for generating XML. The output struct + * is copied, and may be freed by the caller. + * INPUTS + * request -- previously allocated request struct + * output -- output options struct initialized by caller + * RESULT + * XMLRPC_REQUEST_OUTPUT_OPTIONS -- pointer to value stored, or NULL + * SEE ALSO + * XMLRPC_RequestNew () + * XMLRPC_RequestGetOutputOptions () + * XMLRPC_RequestFree () + * XMLRPC_REQUEST + * XMLRPC_REQUEST_OUTPUT_OPTIONS + * SOURCE + */ +XMLRPC_REQUEST_OUTPUT_OPTIONS XMLRPC_RequestSetOutputOptions(XMLRPC_REQUEST request, XMLRPC_REQUEST_OUTPUT_OPTIONS output) { + if(request && output) { + memcpy (&request->output, output, + sizeof (STRUCT_XMLRPC_REQUEST_OUTPUT_OPTIONS)); + return &request->output; + } + return NULL; +} + +/*******/ + + +/****f* REQUEST/XMLRPC_RequestGetOutputOptions + * NAME + * XMLRPC_RequestGetOutputOptions + * SYNOPSIS + * XMLRPC_REQUEST_OUTPUT_OPTIONS XMLRPC_RequestGetOutputOptions(XMLRPC_REQUEST request) + * FUNCTION + * Gets a pointer to output options used for generating XML. + * INPUTS + * request -- previously allocated request struct + * RESULT + * XMLRPC_REQUEST_OUTPUT_OPTIONS -- pointer to options stored, or NULL + * SEE ALSO + * XMLRPC_RequestNew () + * XMLRPC_RequestSetOutputOptions () + * XMLRPC_RequestFree () + * XMLRPC_REQUEST + * XMLRPC_REQUEST_OUTPUT_OPTIONS + * SOURCE + */ +XMLRPC_REQUEST_OUTPUT_OPTIONS XMLRPC_RequestGetOutputOptions(XMLRPC_REQUEST request) { + return request ? &request->output : NULL; +} + +/*******/ + +/*-************************* +* End XMLRPC_REQUEST funcs * +***************************/ + + +/*-*************************** +* Begin Serializiation funcs * +*****************************/ + +/****f* SERIALIZE/XMLRPC_VALUE_ToXML + * NAME + * XMLRPC_VALUE_ToXML + * SYNOPSIS + * char* XMLRPC_VALUE_ToXML(XMLRPC_VALUE val) + * FUNCTION + * encode XMLRPC_VALUE into XML buffer. Note that the generated + * buffer will not contain a methodCall. + * INPUTS + * val -- previously allocated XMLRPC_VALUE + * buf_len -- length of returned buffer, if not null + * RESULT + * char* -- newly allocated buffer containing XML. + * It is the caller's responsibility to free it. + * SEE ALSO + * XMLRPC_REQUEST_ToXML () + * XMLRPC_VALUE_FromXML () + * XMLRPC_Free () + * XMLRPC_VALUE + * SOURCE + */ +char* XMLRPC_VALUE_ToXML(XMLRPC_VALUE val, int* buf_len) { + xml_element *root_elem = XMLRPC_VALUE_to_xml_element(val); + char* pRet = NULL; + + if(root_elem) { + pRet = xml_elem_serialize_to_string(root_elem, NULL, buf_len); + xml_elem_free(root_elem); + } + return pRet; +} + +/*******/ + +/****f* SERIALIZE/XMLRPC_REQUEST_ToXML + * NAME + * XMLRPC_REQUEST_ToXML + * SYNOPSIS + * char* XMLRPC_REQUEST_ToXML(XMLRPC_REQUEST request) + * FUNCTION + * encode XMLRPC_REQUEST into XML buffer + * INPUTS + * request -- previously allocated XMLRPC_REQUEST + * buf_len -- size of returned buf, if not null + * RESULT + * char* -- newly allocated buffer containing XML. + * It is the caller's responsibility to free it. + * SEE ALSO + * XMLRPC_REQUEST_ToXML () + * XMLRPC_REQUEST_FromXML () + * XMLRPC_Free () + * XMLRPC_VALUE_ToXML () + * XMLRPC_REQUEST + * SOURCE + */ +char* XMLRPC_REQUEST_ToXML(XMLRPC_REQUEST request, int* buf_len) { + char* pRet = NULL; + if (request) { + xml_element *root_elem = NULL; + if (request->output.version == xmlrpc_version_simple) { + root_elem = DANDARPC_REQUEST_to_xml_element (request); + } + else if (request->output.version == xmlrpc_version_1_0 || + request->output.version == xmlrpc_version_none) { + root_elem = XMLRPC_REQUEST_to_xml_element (request); + } + else if (request->output.version == xmlrpc_version_soap_1_1) { + root_elem = SOAP_REQUEST_to_xml_element (request); + } + + if(root_elem) { + pRet = + xml_elem_serialize_to_string (root_elem, + &request->output.xml_elem_opts, + buf_len); + xml_elem_free(root_elem); + } + } + return pRet; +} + +/*******/ + +/****f* SERIALIZE/XMLRPC_VALUE_FromXML + * NAME + * XMLRPC_VALUE_FromXML + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_VALUE_FromXML(const char* in_buf, int le + * FUNCTION + * Retrieve XMLRPC_VALUE from XML buffer. Note that this will + * ignore any methodCall. See XMLRPC_REQUEST_FromXML + * INPUTS + * in_buf -- character buffer containing XML + * len -- length of buffer + * RESULT + * XMLRPC_VALUE -- newly allocated data, or NULL if error. Should + * be free'd by caller. + * SEE ALSO + * XMLRPC_VALUE_ToXML () + * XMLRPC_REQUEST_FromXML () + * XMLRPC_VALUE + * SOURCE + */ +XMLRPC_VALUE XMLRPC_VALUE_FromXML (const char *in_buf, int len, XMLRPC_REQUEST_INPUT_OPTIONS in_options) { + XMLRPC_VALUE xResponse = NULL; + XMLRPC_REQUEST req = XMLRPC_REQUEST_FromXML(in_buf, len, in_options); + + if(req) { + xResponse = req->io; + XMLRPC_RequestFree(req, 0); + } + return xResponse; +} + +/*******/ + +/* map parser errors to standard xml-rpc errors */ +static XMLRPC_VALUE map_expat_errors(XML_ELEM_ERROR error) { + XMLRPC_VALUE xReturn = NULL; + if(error) { + XMLRPC_ERROR_CODE code; + char buf[1024]; + snprintf(buf, sizeof(buf), + "error occurred at line %ld, column %ld, byte index %ld", + error->line, error->column, error->byte_index); + + /* expat specific errors */ + switch(error->parser_code) { + case XML_ERROR_UNKNOWN_ENCODING: + code = xmlrpc_error_parse_unknown_encoding; + break; + case XML_ERROR_INCORRECT_ENCODING: + code = xmlrpc_error_parse_bad_encoding; + break; + default: + code = xmlrpc_error_parse_xml_syntax; + break; + } + xReturn = XMLRPC_UtilityCreateFault(code, buf); + } + return xReturn; +} + +/****f* SERIALIZE/XMLRPC_REQUEST_FromXML + * NAME + * XMLRPC_REQUEST_FromXML + * SYNOPSIS + * XMLRPC_REQUEST XMLRPC_REQUEST_FromXML(const char* in_buf, int le + * FUNCTION + * Retrieve XMLRPC_REQUEST from XML buffer + * INPUTS + * in_buf -- character buffer containing XML + * len -- length of buffer + * RESULT + * XMLRPC_REQUEST -- newly allocated data, or NULL if error. Should + * be free'd by caller. + * SEE ALSO + * XMLRPC_REQUEST_ToXML () + * XMLRPC_VALUE_FromXML () + * XMLRPC_REQUEST + * SOURCE + */ +XMLRPC_REQUEST XMLRPC_REQUEST_FromXML (const char *in_buf, int len, + XMLRPC_REQUEST_INPUT_OPTIONS in_options) { + XMLRPC_REQUEST request = XMLRPC_RequestNew(); + STRUCT_XML_ELEM_ERROR error = {0}; + + if(request) { + xml_element *root_elem = + xml_elem_parse_buf (in_buf, len, + (in_options ? &in_options->xml_elem_opts : NULL), + &error); + + if(root_elem) { + if(!strcmp(root_elem->name, "simpleRPC")) { + request->output.version = xmlrpc_version_simple; + xml_element_to_DANDARPC_REQUEST(request, root_elem); + } + else if (!strcmp (root_elem->name, "SOAP-ENV:Envelope")) { + request->output.version = xmlrpc_version_soap_1_1; + xml_element_to_SOAP_REQUEST (request, root_elem); + } + else { + request->output.version = xmlrpc_version_1_0; + xml_element_to_XMLRPC_REQUEST(request, root_elem); + } + xml_elem_free(root_elem); + } + else { + if(error.parser_error) { + XMLRPC_RequestSetError (request, map_expat_errors (&error)); + } + } + } + + return request; +} + +/*******/ + +/*-************************ +* End Serialization Funcs * +**************************/ + + + +/****f* VALUE/XMLRPC_CreateValueEmpty + * NAME + * XMLRPC_CreateValueEmpty + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_CreateValueEmpty () + * FUNCTION + * Create an XML value to be used/modified elsewhere. + * INPUTS + * RESULT + * XMLRPC_VALUE. The new value, or NULL on failure. + * SEE ALSO + * XMLRPC_CleanupValue () + * XMLRPC_VALUE + * SOURCE + */ +XMLRPC_VALUE XMLRPC_CreateValueEmpty() { + XMLRPC_VALUE v = calloc(1, sizeof(STRUCT_XMLRPC_VALUE)); + if(v) { +#ifdef XMLRPC_DEBUG_REFCOUNT + printf ("calloc'd 0x%x\n", v); +#endif + v->type = xmlrpc_empty; + simplestring_init(&v->id); + simplestring_init(&v->str); + } + return v; +} + +/*******/ + +/****f* VALUE/XMLRPC_SetValueID_Case + * NAME + * XMLRPC_SetValueID_Case + * SYNOPSIS + * const char *XMLRPC_SetValueID_Case(XMLRPC_VALUE value, const char* id, int len, XMLRPC_CASE id_case) + * FUNCTION + * Assign an ID (key) to an XMLRPC value. + * INPUTS + * value The xml value who's ID we will set. + * id The desired new id. + * len length of id string if known, or 0 if unknown. + * id_case one of XMLRPC_CASE + * RESULT + * const char* pointer to the newly allocated id string, or NULL + * SEE ALSO + * XMLRPC_SetValueID () + * XMLRPC_GetValueID () + * XMLRPC_VALUE + * XMLRPC_CASE + * SOURCE + */ +const char *XMLRPC_SetValueID_Case(XMLRPC_VALUE value, const char* id, int len, XMLRPC_CASE id_case) { + const char* pRetval = NULL; + if(value) { + if(id) { + simplestring_clear(&value->id); + (len > 0) ? simplestring_addn(&value->id, id, len) : + simplestring_add(&value->id, id); + + /* upper or lower case string in place if required. could be a seperate func. */ + if(id_case == xmlrpc_case_lower || id_case == xmlrpc_case_upper) { + int i; + for(i = 0; i < value->id.len; i++) { + value->id.str[i] = + (id_case == + xmlrpc_case_lower) ? tolower (value->id. + str[i]) : toupper (value-> + id. + str[i]); + } + } + + pRetval = value->id.str; + +#ifdef XMLRPC_DEBUG_REFCOUNT + printf("set value id: %s\n", pRetval); +#endif + } + } + + return pRetval; +} + +/*******/ + + +/****f* VALUE/XMLRPC_SetValueString + * NAME + * XMLRPC_SetValueString + * SYNOPSIS + * const char *XMLRPC_SetValueString(XMLRPC_VALUE value, const char* val, int len) + * FUNCTION + * Assign a string value to an XMLRPC_VALUE, and set it to type xmlrpc_string + * INPUTS + * value The xml value who's ID we will set. + * val The desired new string val. + * len length of val string if known, or 0 if unknown. + * RESULT + * const char* pointer to the newly allocated value string, or NULL + * SEE ALSO + * XMLRPC_GetValueString () + * XMLRPC_VALUE + * XMLRPC_VALUE_TYPE + * SOURCE + */ +const char *XMLRPC_SetValueString(XMLRPC_VALUE value, const char* val, int len) { + char *pRetval = NULL; + if(value && val) { + simplestring_clear(&value->str); + (len > 0) ? simplestring_addn(&value->str, val, len) : + simplestring_add(&value->str, val); + value->type = xmlrpc_string; + pRetval = (char *)value->str.str; + } + + return pRetval; +} + +/*******/ + +/****f* VALUE/XMLRPC_SetValueInt + * NAME + * XMLRPC_SetValueInt + * SYNOPSIS + * void XMLRPC_SetValueInt(XMLRPC_VALUE value, int val) + * FUNCTION + * Assign an int value to an XMLRPC_VALUE, and set it to type xmlrpc_int + * INPUTS + * value The xml value who's ID we will set. + * val The desired new integer value + * RESULT + * SEE ALSO + * XMLRPC_GetValueInt () + * XMLRPC_VALUE + * XMLRPC_VALUE_TYPE + * SOURCE + */ +void XMLRPC_SetValueInt(XMLRPC_VALUE value, int val) { + if(value) { + value->type = xmlrpc_int; + value->i = val; + } +} + +/*******/ + +/****f* VALUE/XMLRPC_SetValueBoolean + * NAME + * XMLRPC_SetValueBoolean + * SYNOPSIS + * void XMLRPC_SetValueBoolean(XMLRPC_VALUE value, int val) + * FUNCTION + * Assign a boolean value to an XMLRPC_VALUE, and set it to type xmlrpc_boolean + * INPUTS + * value The xml value who's value we will set. + * val The desired new boolean value. [0 | 1] + * RESULT + * SEE ALSO + * XMLRPC_GetValueBoolean () + * XMLRPC_VALUE + * XMLRPC_VALUE_TYPE + * SOURCE + */ +void XMLRPC_SetValueBoolean(XMLRPC_VALUE value, int val) { + if(value) { + value->type = xmlrpc_boolean; + value->i = val ? 1 : 0; + } +} + +/*******/ + + +/****f* VECTOR/XMLRPC_SetIsVector + * NAME + * XMLRPC_SetIsVector + * SYNOPSIS + * int XMLRPC_SetIsVector(XMLRPC_VALUE value, XMLRPC_VECTOR_TYPE type) + * FUNCTION + * Set the XMLRPC_VALUE to be a vector (list) type. The vector may be one of + * [xmlrpc_array | xmlrpc_struct | xmlrpc_mixed]. An array has only index values. + * A struct has key/val pairs. Mixed allows both index and key/val combinations. + * INPUTS + * value The xml value who's vector type we will set + * type New type of vector as enumerated by XMLRPC_VECTOR_TYPE + * RESULT + * int 1 if successful, 0 otherwise + * SEE ALSO + * XMLRPC_GetValueType () + * XMLRPC_GetVectorType () + * XMLRPC_VALUE + * XMLRPC_VECTOR_TYPE + * XMLRPC_VALUE_TYPE + * SOURCE + */ +int XMLRPC_SetIsVector(XMLRPC_VALUE value, XMLRPC_VECTOR_TYPE type) { + int bSuccess = 0; + + if (value) { + /* we can change the type so long as nothing is currently stored. */ + if(value->type == xmlrpc_vector) { + if(value->v) { + if(!Q_Size(value->v->q)) { + value->v->type = type; + } + } + } + else { + value->v = calloc(1, sizeof(STRUCT_XMLRPC_VECTOR)); + if(value->v) { + value->v->q = (queue*)malloc(sizeof(queue)); + if(value->v->q) { + Q_Init(value->v->q); + value->v->type = type; + value->type = xmlrpc_vector; + bSuccess = 1; + } + } + } + } + + return bSuccess; +} + +/*******/ + +/****f* VECTOR/XMLRPC_CreateVector + * NAME + * XMLRPC_CreateVector + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_CreateVector(const char* id, XMLRPC_VECTOR_TYPE type) + * FUNCTION + * Create a new vector and optionally set an id. + * INPUTS + * id The id of the vector, or NULL + * type New type of vector as enumerated by XMLRPC_VECTOR_TYPE + * RESULT + * XMLRPC_VALUE The new vector, or NULL on failure. + * SEE ALSO + * XMLRPC_CreateValueEmpty () + * XMLRPC_SetIsVector () + * XMLRPC_GetValueType () + * XMLRPC_GetVectorType () + * XMLRPC_VALUE + * XMLRPC_VECTOR_TYPE + * XMLRPC_VALUE_TYPE + * SOURCE + */ +XMLRPC_VALUE XMLRPC_CreateVector(const char* id, XMLRPC_VECTOR_TYPE type) { + XMLRPC_VALUE val = NULL; + + val = XMLRPC_CreateValueEmpty(); + if(val) { + if(XMLRPC_SetIsVector(val, type)) { + if(id) { + const char *pSVI = NULL; + + pSVI = XMLRPC_SetValueID(val, id, 0); + if(NULL == pSVI) { + val = NULL; + } + } + } + else { + val = NULL; + } + } + return val; +} + +/*******/ + + +/* Not yet implemented. + * + * This should use a hash to determine if a given target id has already + * been appended. + * + * Alternately, it could walk the entire vector, but that could be quite + * slow for very large lists. + */ +static int isDuplicateEntry(XMLRPC_VALUE target, XMLRPC_VALUE source) { + return 0; +} + +/****f* VECTOR/XMLRPC_AddValueToVector + * NAME + * XMLRPC_AddValueToVector + * SYNOPSIS + * int XMLRPC_AddValueToVector(XMLRPC_VALUE target, XMLRPC_VALUE source) + * FUNCTION + * Add (append) an existing XMLRPC_VALUE to a vector. + * INPUTS + * target The target vector + * source The source value to append + * RESULT + * int 1 if successful, else 0 + * SEE ALSO + * XMLRPC_AddValuesToVector () + * XMLRPC_VectorGetValueWithID_Case () + * XMLRPC_VALUE + * NOTES + * The function will fail and return 0 if an attempt is made to add + * a value with an ID into a vector of type xmlrpc_vector_array. Such + * values can only be added to xmlrpc_vector_struct. + * SOURCE + */ +int XMLRPC_AddValueToVector(XMLRPC_VALUE target, XMLRPC_VALUE source) { + if(target && source) { + if(target->type == xmlrpc_vector && target->v && + target->v->q && target->v->type != xmlrpc_vector_none) { + + /* guard against putting value of unknown type into vector */ + switch(source->type) { + case xmlrpc_empty: + case xmlrpc_base64: + case xmlrpc_boolean: + case xmlrpc_datetime: + case xmlrpc_double: + case xmlrpc_int: + case xmlrpc_string: + case xmlrpc_vector: + /* Guard against putting a key/val pair into an array vector */ + if( !(source->id.len && target->v->type == xmlrpc_vector_array) ) { + if (isDuplicateEntry (target, source) + || Q_PushTail (target->v->q, XMLRPC_CopyValue (source))) { + return 1; + } + } + else { + /* fprintf (stderr, + "xmlrpc: attempted to add key/val pair to vector of type array\n"); */ + } + break; + default: + /* fprintf (stderr, + "xmlrpc: attempted to add value of unknown type to vector\n"); */ + break; + } + } + } + return 0; +} + +/*******/ + + +/****f* VECTOR/XMLRPC_AddValuesToVector + * NAME + * XMLRPC_AddValuesToVector + * SYNOPSIS + * XMLRPC_AddValuesToVector ( target, val1, val2, val3, val(n), 0 ) + * XMLRPC_AddValuesToVector( XMLRPC_VALUE, ... ) + * FUNCTION + * Add (append) a series of existing XMLRPC_VALUE to a vector. + * INPUTS + * target The target vector + * ... The source value(s) to append. The last item *must* be 0. + * RESULT + * int 1 if successful, else 0 + * SEE ALSO + * XMLRPC_AddValuesToVector () + * XMLRPC_VectorGetValueWithID_Case () + * XMLRPC_VALUE + * NOTES + * This function may actually return failure after it has already modified + * or added items to target. You can not trust the state of target + * if this function returns failure. + * SOURCE + */ +int XMLRPC_AddValuesToVector(XMLRPC_VALUE target, ...) { + int iRetval = 0; + + if(target) { + if(target->type == xmlrpc_vector) { + XMLRPC_VALUE v = NULL; + va_list vl; + + va_start(vl, target); + + do { + v = va_arg(vl, XMLRPC_VALUE); + if(v) { + if(!XMLRPC_AddValueToVector(target, v)) { + iRetval = 0; + break; + } + } + } + while (v); + + va_end(vl); + + if(NULL == v) { + iRetval = 1; + } + } + } + return iRetval; +} + +/*******/ + + +/****f* VECTOR/XMLRPC_VectorGetValueWithID_Case + * NAME + * XMLRPC_VectorGetValueWithID_Case + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_VectorGetValueWithID_Case(XMLRPC_VALUE vector, const char* id, XMLRPC_CASE_COMPARISON id_case) + * FUNCTION + * Get value from vector matching id (key) + * INPUTS + * vector The source vector + * id The key to find + * id_case Rule for how to match key + * RESULT + * int 1 if successful, else 0 + * SEE ALSO + * XMLRPC_SetValueID_Case () + * XMLRPC_VALUE + * XMLRPC_CASE_COMPARISON + * SOURCE + */ +XMLRPC_VALUE XMLRPC_VectorGetValueWithID_Case (XMLRPC_VALUE vector, const char *id, + XMLRPC_CASE_COMPARISON id_case) { + if(vector && vector->v && vector->v->q) { + q_iter qi = Q_Iter_Head_F(vector->v->q); + + while(qi) { + XMLRPC_VALUE xIter = Q_Iter_Get_F(qi); + if(xIter && xIter->id.str) { + if(id_case == xmlrpc_case_sensitive) { + if(!strcmp(xIter->id.str, id)) { + return xIter; + } + } + else if(id_case == xmlrpc_case_insensitive) { + if(!strcasecmp(xIter->id.str, id)) { + return xIter; + } + } + } + qi = Q_Iter_Next_F(qi); + } + } + return NULL; +} + +/*******/ + + +int XMLRPC_VectorRemoveValue(XMLRPC_VALUE vector, XMLRPC_VALUE value) { + if(vector && vector->v && vector->v->q && value) { + q_iter qi = Q_Iter_Head_F(vector->v->q); + + while(qi) { + XMLRPC_VALUE xIter = Q_Iter_Get_F(qi); + if(xIter == value) { + XMLRPC_CleanupValue(xIter); + Q_Iter_Del(vector->v->q, qi); + return 1; + } + qi = Q_Iter_Next_F(qi); + } + } + return 0; +} + + +/****f* VALUE/XMLRPC_CreateValueString + * NAME + * XMLRPC_CreateValueString + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_CreateValueString(const char* id, const char* val, int len) + * FUNCTION + * Create an XMLRPC_VALUE, and assign a string to it + * INPUTS + * id The id of the value, or NULL + * val The desired new string val. + * len length of val string if known, or 0 if unknown. + * RESULT + * newly allocated XMLRPC_VALUE, or NULL + * SEE ALSO + * XMLRPC_GetValueString () + * XMLRPC_CreateValueEmpty () + * XMLRPC_VALUE + * XMLRPC_VALUE_TYPE + * SOURCE + */ +XMLRPC_VALUE XMLRPC_CreateValueString(const char* id, const char* val, int len) { + XMLRPC_VALUE value = NULL; + if(val) { + value = XMLRPC_CreateValueEmpty(); + if(value) { + XMLRPC_SetValueString(value, val, len); + if(id) { + XMLRPC_SetValueID(value, id, 0); + } + } + } + return value; +} + +/*******/ + +/****f* VALUE/XMLRPC_CreateValueInt + * NAME + * XMLRPC_CreateValueInt + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_CreateValueInt(const char* id, int i) + * FUNCTION + * Create an XMLRPC_VALUE, and assign an int to it + * INPUTS + * id The id of the value, or NULL + * i The desired new int val. + * RESULT + * newly allocated XMLRPC_VALUE, or NULL + * SEE ALSO + * XMLRPC_GetValueInt () + * XMLRPC_CreateValueEmpty () + * XMLRPC_VALUE + * XMLRPC_VALUE_TYPE + * SOURCE + */ +XMLRPC_VALUE XMLRPC_CreateValueInt(const char* id, int i) { + XMLRPC_VALUE val = XMLRPC_CreateValueEmpty(); + if(val) { + XMLRPC_SetValueInt(val, i); + if(id) { + XMLRPC_SetValueID(val, id, 0); + } + } + return val; +} + +/*******/ + +/****f* VALUE/XMLRPC_CreateValueBoolean + * NAME + * XMLRPC_CreateValueBoolean + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_CreateValueBoolean(const char* id, int i) + * FUNCTION + * Create an XMLRPC_VALUE, and assign an int to it + * INPUTS + * id The id of the value, or NULL + * i The desired new int val. + * RESULT + * newly allocated XMLRPC_VALUE, or NULL + * SEE ALSO + * XMLRPC_GetValueBoolean () + * XMLRPC_CreateValueEmpty () + * XMLRPC_VALUE + * XMLRPC_VALUE_TYPE + * SOURCE + */ +XMLRPC_VALUE XMLRPC_CreateValueBoolean(const char* id, int i) { + XMLRPC_VALUE val = XMLRPC_CreateValueEmpty(); + if(val) { + XMLRPC_SetValueBoolean(val, i); + if(id) { + XMLRPC_SetValueID(val, id, 0); + } + } + return val; +} + +/*******/ + + +/****f* VALUE/XMLRPC_CleanupValue + * NAME + * XMLRPC_CleanupValue + * SYNOPSIS + * void XMLRPC_CleanupValue(XMLRPC_VALUE value) + * FUNCTION + * Frees all memory allocated for an XMLRPC_VALUE and any of its children (if a vector) + * INPUTS + * value The id of the value to be cleaned up. + * RESULT + * void + * NOTES + * Normally this function will be called for the topmost vector, thus free-ing + * all children. If a child of a vector is free'd first, results are undefined. + * Failure to call this function *will* cause memory leaks. + * + * Also, this function is implemented using reference counting. Thus a value + * may be added and freed from multiple parents so long as a reference is added + * first using XMLRPC_CopyValue() + * SEE ALSO + * XMLRPC_RequestFree () + * XMLRPC_CreateValueEmpty () + * XMLRPC_CopyValue() + * XMLRPC_VALUE + * SOURCE + */ +void XMLRPC_CleanupValue(XMLRPC_VALUE value) { + if(value) { + if(value->iRefCount > 0) { + value->iRefCount --; + } + +#ifdef XMLRPC_DEBUG_REFCOUNT + if(value->id.str) { + printf ("decremented refcount of %s, now %i\n", value->id.str, + value->iRefCount); + } + else { + printf ("decremented refcount of 0x%x, now %i\n", value, + value->iRefCount); + } +#endif + + if(value->type == xmlrpc_vector) { + if(value->v) { + if(value->iRefCount == 0) { + XMLRPC_VALUE cur = (XMLRPC_VALUE)Q_Head(value->v->q); + while( cur ) { + XMLRPC_CleanupValue(cur); + + /* Make sure some idiot didn't include a vector as a child of itself + * and thus it would have already free'd these. + */ + if(value->v && value->v->q) { + cur = Q_Next(value->v->q); + } + else { + break; + } + } + + Q_Destroy(value->v->q); + my_free(value->v->q); + my_free(value->v); + } + } + } + + + if(value->iRefCount == 0) { + + /* guard against freeing invalid types */ + switch(value->type) { + case xmlrpc_empty: + case xmlrpc_base64: + case xmlrpc_boolean: + case xmlrpc_datetime: + case xmlrpc_double: + case xmlrpc_int: + case xmlrpc_string: + case xmlrpc_vector: +#ifdef XMLRPC_DEBUG_REFCOUNT + if(value->id.str) { + printf("free'd %s\n", value->id.str); + } + else { + printf("free'd 0x%x\n", value); + } +#endif + simplestring_free(&value->id); + simplestring_free(&value->str); + + memset(value, 0, sizeof(STRUCT_XMLRPC_VALUE)); + my_free(value); + break; + default: + /* fprintf (stderr, + "xmlrpc: attempted to free value of invalid type\n"); */ + break; + } + } + } +} + +/*******/ + + +/****f* VALUE/XMLRPC_SetValueDateTime + * NAME + * XMLRPC_SetValueDateTime + * SYNOPSIS + * void XMLRPC_SetValueDateTime(XMLRPC_VALUE value, time_t time) + * FUNCTION + * Assign time value to XMLRPC_VALUE + * INPUTS + * value The target XMLRPC_VALUE + * time The desired new unix time value (time_t) + * RESULT + * void + * SEE ALSO + * XMLRPC_GetValueDateTime () + * XMLRPC_SetValueDateTime_ISO8601 () + * XMLRPC_CreateValueDateTime () + * XMLRPC_VALUE + * SOURCE + */ +void XMLRPC_SetValueDateTime(XMLRPC_VALUE value, time_t time) { + if(value) { + char timeBuf[30]; + value->type = xmlrpc_datetime; + value->i = time; + + timeBuf[0] = 0; + + date_to_ISO8601(time, timeBuf, sizeof(timeBuf)); + + if(timeBuf[0]) { + XMLRPC_SetValueDateTime_ISO8601 (value, timeBuf); + } + } +} + +/*******/ + +/****f* VALUE/XMLRPC_CopyValue + * NAME + * XMLRPC_CopyValue + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_CopyValue(XMLRPC_VALUE value) + * FUNCTION + * Make a copy (reference) of an XMLRPC_VALUE + * INPUTS + * value The target XMLRPC_VALUE + * RESULT + * XMLRPC_VALUE -- address of the copy + * SEE ALSO + * XMLRPC_CleanupValue () + * XMLRPC_DupValueNew () + * NOTES + * This function is implemented via reference counting, so the + * returned value is going to be the same as the passed in value. + * The value must be freed the same number of times it is copied + * or there will be a memory leak. + * SOURCE + */ +XMLRPC_VALUE XMLRPC_CopyValue(XMLRPC_VALUE value) { + if(value) { + value->iRefCount ++; +#ifdef XMLRPC_DEBUG_REFCOUNT + if(value->id.str) { + printf ("incremented refcount of %s, now %i\n", value->id.str, + value->iRefCount); + } + else { + printf ("incremented refcount of 0x%x, now %i\n", value, + value->iRefCount); + } +#endif + } + return value; +} + +/*******/ + + +/****f* VALUE/XMLRPC_DupValueNew + * NAME + * XMLRPC_DupValueNew + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_DupValueNew(XMLRPC_VALUE value) + * FUNCTION + * Make a duplicate (non reference) of an XMLRPC_VALUE with newly allocated mem. + * INPUTS + * value The source XMLRPC_VALUE to duplicate + * RESULT + * XMLRPC_VALUE -- address of the duplicate value + * SEE ALSO + * XMLRPC_CleanupValue () + * XMLRPC_CopyValue () + * NOTES + * Use this when function when you need to modify the contents of + * the copied value seperately from the original. + * + * this function is recursive, thus the value and all of its children + * (if any) will be duplicated. + * SOURCE + */ +XMLRPC_VALUE XMLRPC_DupValueNew (XMLRPC_VALUE xSource) { + XMLRPC_VALUE xReturn = NULL; + if (xSource) { + xReturn = XMLRPC_CreateValueEmpty (); + if (xSource->id.len) { + XMLRPC_SetValueID (xReturn, xSource->id.str, xSource->id.len); + } + + switch (xSource->type) { + case xmlrpc_int: + case xmlrpc_boolean: + XMLRPC_SetValueInt (xReturn, xSource->i); + break; + case xmlrpc_string: + case xmlrpc_base64: + XMLRPC_SetValueString (xReturn, xSource->str.str, xSource->str.len); + break; + case xmlrpc_datetime: + XMLRPC_SetValueDateTime (xReturn, xSource->i); + break; + case xmlrpc_double: + XMLRPC_SetValueDouble (xReturn, xSource->d); + break; + case xmlrpc_vector: + { + q_iter qi = Q_Iter_Head_F (xSource->v->q); + XMLRPC_SetIsVector (xReturn, xSource->v->type); + + while (qi) { + XMLRPC_VALUE xIter = Q_Iter_Get_F (qi); + XMLRPC_AddValueToVector (xReturn, XMLRPC_DupValueNew (xIter)); + qi = Q_Iter_Next_F (qi); + } + } + break; + default: + break; + } + } + return xReturn; +} + +/*******/ + + + +/****f* VALUE/XMLRPC_CreateValueDateTime + * NAME + * XMLRPC_CreateValueDateTime + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_CreateValueDateTime(const char* id, time_t time) + * FUNCTION + * Create new datetime value from time_t + * INPUTS + * id id of the new value, or NULL + * time The desired unix time value (time_t) + * RESULT + * void + * SEE ALSO + * XMLRPC_GetValueDateTime () + * XMLRPC_SetValueDateTime () + * XMLRPC_CreateValueDateTime_ISO8601 () + * XMLRPC_VALUE + * SOURCE + */ +XMLRPC_VALUE XMLRPC_CreateValueDateTime(const char* id, time_t time) { + XMLRPC_VALUE val = XMLRPC_CreateValueEmpty(); + if(val) { + XMLRPC_SetValueDateTime(val, time); + if(id) { + XMLRPC_SetValueID(val, id, 0); + } + } + return val; +} + +/*******/ + + +/****f* VALUE/XMLRPC_SetValueDateTime_ISO8601 + * NAME + * XMLRPC_SetValueDateTime_ISO8601 + * SYNOPSIS + * void XMLRPC_SetValueDateTime_ISO8601(XMLRPC_VALUE value, const char* s) + * FUNCTION + * Set datetime value from IS08601 encoded string + * INPUTS + * value The target XMLRPC_VALUE + * s The desired new time value + * RESULT + * void + * BUGS + * This function currently attempts to convert the time string to a valid unix time + * value before passing it. Behavior when the string is invalid or out of range + * is not well defined, but will probably result in Jan 1, 1970 (0) being passed. + * SEE ALSO + * XMLRPC_GetValueDateTime_ISO8601 () + * XMLRPC_CreateValueDateTime_ISO8601 () + * XMLRPC_CreateValueDateTime () + * XMLRPC_VALUE + * SOURCE + */ +void XMLRPC_SetValueDateTime_ISO8601(XMLRPC_VALUE value, const char* s) { + if(value) { + time_t time_val = 0; + if(s) { + value->type = xmlrpc_datetime; + date_from_ISO8601(s, &time_val); + value->i = time_val; + simplestring_clear(&value->str); + simplestring_add(&value->str, s); + } + } +} + +/*******/ + +/****f* VALUE/XMLRPC_CreateValueDateTime_ISO8601 + * NAME + * XMLRPC_CreateValueDateTime_ISO8601 + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_CreateValueDateTime_ISO8601(const char* id, const char *s) + * FUNCTION + * Create datetime value from IS08601 encoded string + * INPUTS + * id The id of the new value, or NULL + * s The desired new time value + * RESULT + * newly allocated XMLRPC_VALUE, or NULL if no value created. + * BUGS + * See XMLRPC_SetValueDateTime_ISO8601 () + * SEE ALSO + * XMLRPC_GetValueDateTime_ISO8601 () + * XMLRPC_SetValueDateTime_ISO8601 () + * XMLRPC_CreateValueDateTime () + * XMLRPC_VALUE + * SOURCE + */ +XMLRPC_VALUE XMLRPC_CreateValueDateTime_ISO8601(const char* id, const char *s) { + XMLRPC_VALUE val = XMLRPC_CreateValueEmpty(); + if(val) { + XMLRPC_SetValueDateTime_ISO8601(val, s); + if(id) { + XMLRPC_SetValueID(val, id, 0); + } + } + return val; +} + +/*******/ + + +/****f* VALUE/XMLRPC_SetValueBase64 + * NAME + * XMLRPC_SetValueBase64 + * SYNOPSIS + * void XMLRPC_SetValueBase64(XMLRPC_VALUE value, const char* s, int len) + * FUNCTION + * Set base64 value. Base64 is useful for transferring binary data, such as an image. + * INPUTS + * value The target XMLRPC_VALUE + * s The desired new binary value + * len The length of s, or NULL. If buffer is not null terminated, len *must* be passed. + * RESULT + * void + * NOTES + * Data is set/stored/retrieved as passed in, but is base64 encoded for XML transfer, and + * decoded on the other side. This is transparent to the caller. + * SEE ALSO + * XMLRPC_GetValueBase64 () + * XMLRPC_CreateValueBase64 () + * XMLRPC_VALUE + * SOURCE + */ +void XMLRPC_SetValueBase64(XMLRPC_VALUE value, const char* s, int len) { + if(value && s) { + simplestring_clear(&value->str); + (len > 0) ? simplestring_addn(&value->str, s, len) : + simplestring_add(&value->str, s); + value->type = xmlrpc_base64; + } +} + +/*******/ + + +/****f* VALUE/XMLRPC_CreateValueBase64 + * NAME + * XMLRPC_CreateValueBase64 + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_CreateValueBase64(const char* id, const char* s, int len) + * FUNCTION + * Create base64 value. Base64 is useful for transferring binary data, such as an image. + * INPUTS + * id id of the new value, or NULL + * s The desired new binary value + * len The length of s, or NULL. If buffer is not null terminated, len *must* be passed. + * RESULT + * newly allocated XMLRPC_VALUE, or NULL if error + * NOTES + * See XMLRPC_SetValueBase64 () + * SEE ALSO + * XMLRPC_GetValueBase64 () + * XMLRPC_SetValueBase64 () + * XMLRPC_VALUE + * SOURCE + */ +XMLRPC_VALUE XMLRPC_CreateValueBase64(const char* id, const char* s, int len) { + XMLRPC_VALUE val = XMLRPC_CreateValueEmpty(); + if(val) { + XMLRPC_SetValueBase64(val, s, len); + if(id) { + XMLRPC_SetValueID(val, id, 0); + } + } + return val; +} + +/*******/ + +/****f* VALUE/XMLRPC_SetValueDouble + * NAME + * XMLRPC_SetValueDouble + * SYNOPSIS + * void XMLRPC_SetValueDouble(XMLRPC_VALUE value, double val) + * FUNCTION + * Set double (floating point) value. + * INPUTS + * value The target XMLRPC_VALUE + * val The desired new double value + * RESULT + * void + * SEE ALSO + * XMLRPC_GetValueDouble () + * XMLRPC_CreateValueDouble () + * XMLRPC_VALUE + * SOURCE + */ +void XMLRPC_SetValueDouble(XMLRPC_VALUE value, double val) { + if(value) { + value->type = xmlrpc_double; + value->d = val; + } +} + +/*******/ + +/****f* VALUE/XMLRPC_CreateValueDouble + * NAME + * XMLRPC_CreateValueDouble + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_CreateValueDouble(const char* id, double d) + * FUNCTION + * Create double (floating point) value. + * INPUTS + * id id of the newly created value, or NULL + * d The desired new double value + * RESULT + * void + * SEE ALSO + * XMLRPC_GetValueDouble () + * XMLRPC_CreateValueDouble () + * XMLRPC_VALUE + * SOURCE + */ +XMLRPC_VALUE XMLRPC_CreateValueDouble(const char* id, double d) { + XMLRPC_VALUE val = XMLRPC_CreateValueEmpty(); + if(val) { + XMLRPC_SetValueDouble(val, d); + if(id) { + XMLRPC_SetValueID(val, id, 0); + } + } + return val; +} + +/*******/ + +/****f* VALUE/XMLRPC_GetValueString + * NAME + * XMLRPC_GetValueString + * SYNOPSIS + * const char* XMLRPC_GetValueString(XMLRPC_VALUE value) + * FUNCTION + * retrieve string value + * INPUTS + * value source XMLRPC_VALUE of type xmlrpc_string + * RESULT + * void + * SEE ALSO + * XMLRPC_SetValueString () + * XMLRPC_GetValueType () + * XMLRPC_VALUE + * SOURCE + */ +const char* XMLRPC_GetValueString(XMLRPC_VALUE value) { + return ((value && value->type == xmlrpc_string) ? value->str.str : 0); +} + +/*******/ + +/****f* VALUE/XMLRPC_GetValueStringLen + * NAME + * XMLRPC_GetValueStringLen + * SYNOPSIS + * int XMLRPC_GetValueStringLen(XMLRPC_VALUE value) + * FUNCTION + * determine length of string value + * INPUTS + * value XMLRPC_VALUE of type xmlrpc_string + * RESULT + * length of string, or 0 + * NOTES + * SEE ALSO + * XMLRPC_SetValueString () + * XMLRPC_GetValueString () + * SOURCE + */ +int XMLRPC_GetValueStringLen(XMLRPC_VALUE value) { + return ((value) ? value->str.len : 0); +} + +/*******/ + +/****f* VALUE/XMLRPC_GetValueInt + * NAME + * XMLRPC_GetValueInt + * SYNOPSIS + * int XMLRPC_GetValueInt(XMLRPC_VALUE value) + * FUNCTION + * retrieve integer value. + * INPUTS + * value XMLRPC_VALUE of type xmlrpc_int + * RESULT + * integer value or 0 if value is not valid int + * NOTES + * use XMLRPC_GetValueType () to be sure if 0 is real return value or not + * SEE ALSO + * XMLRPC_SetValueInt () + * XMLRPC_CreateValueInt () + * SOURCE + */ +int XMLRPC_GetValueInt(XMLRPC_VALUE value) { + return ((value && value->type == xmlrpc_int) ? value->i : 0); +} + +/*******/ + +/****f* VALUE/XMLRPC_GetValueBoolean + * NAME + * XMLRPC_GetValueBoolean + * SYNOPSIS + * int XMLRPC_GetValueBoolean(XMLRPC_VALUE value) + * FUNCTION + * retrieve boolean value. + * INPUTS + * XMLRPC_VALUE of type xmlrpc_boolean + * RESULT + * boolean value or 0 if value is not valid boolean + * NOTES + * use XMLRPC_GetValueType() to be sure if 0 is real value or not + * SEE ALSO + * XMLRPC_SetValueBoolean () + * XMLRPC_CreateValueBoolean () + * SOURCE + */ +int XMLRPC_GetValueBoolean(XMLRPC_VALUE value) { + return ((value && value->type == xmlrpc_boolean) ? value->i : 0); +} + +/*******/ + +/****f* VALUE/XMLRPC_GetValueDouble + * NAME + * XMLRPC_GetValueDouble + * SYNOPSIS + * double XMLRPC_GetValueDouble(XMLRPC_VALUE value) + * FUNCTION + * retrieve double value + * INPUTS + * XMLRPC_VALUE of type xmlrpc_double + * RESULT + * double value or 0 if value is not valid double. + * NOTES + * use XMLRPC_GetValueType() to be sure if 0 is real value or not + * SEE ALSO + * XMLRPC_SetValueDouble () + * XMLRPC_CreateValueDouble () + * SOURCE + */ +double XMLRPC_GetValueDouble(XMLRPC_VALUE value) { + return ((value && value->type == xmlrpc_double) ? value->d : 0); +} + +/*******/ + +/****f* VALUE/XMLRPC_GetValueBase64 + * NAME + * XMLRPC_GetValueBase64 + * SYNOPSIS + * const char* XMLRPC_GetValueBase64(XMLRPC_VALUE value) + * FUNCTION + * retrieve binary value + * INPUTS + * XMLRPC_VALUE of type xmlrpc_base64 + * RESULT + * pointer to binary value or 0 if value is not valid. + * SEE ALSO + * XMLRPC_SetValueBase64 () + * XMLRPC_CreateValueBase64 () + * NOTES + * Call XMLRPC_GetValueStringLen() to retrieve real length of binary data. strlen() + * will not be accurate, as returned data may contain embedded nulls. + * SOURCE + */ +const char* XMLRPC_GetValueBase64(XMLRPC_VALUE value) { + return ((value && value->type == xmlrpc_base64) ? value->str.str : 0); +} + +/*******/ + +/****f* VALUE/XMLRPC_GetValueDateTime + * NAME + * XMLRPC_GetValueDateTime + * SYNOPSIS + * time_t XMLRPC_GetValueDateTime(XMLRPC_VALUE value) + * FUNCTION + * retrieve time_t value + * INPUTS + * XMLRPC_VALUE of type xmlrpc_datetime + * RESULT + * time_t value or 0 if value is not valid datetime. + * NOTES + * use XMLRPC_GetValueType() to be sure if 0 is real value or not + * SEE ALSO + * XMLRPC_SetValueDateTime () + * XMLRPC_GetValueDateTime_ISO8601 () + * XMLRPC_CreateValueDateTime () + * SOURCE + */ +time_t XMLRPC_GetValueDateTime(XMLRPC_VALUE value) { + return (time_t)((value && value->type == xmlrpc_datetime) ? value->i : 0); +} + +/*******/ + +/****f* VALUE/XMLRPC_GetValueDateTime_IOS8601 + * NAME + * XMLRPC_GetValueDateTime_IOS8601 + * SYNOPSIS + * const char* XMLRPC_GetValueDateTime_IOS8601(XMLRPC_VALUE value) + * FUNCTION + * retrieve ISO8601 formatted time value + * INPUTS + * XMLRPC_VALUE of type xmlrpc_datetime + * RESULT + * const char* value or 0 if value is not valid datetime. + * SEE ALSO + * XMLRPC_SetValueDateTime_IOS8601 () + * XMLRPC_GetValueDateTime () + * XMLRPC_CreateValueDateTime_IOS8601 () + * SOURCE + */ +const char* XMLRPC_GetValueDateTime_ISO8601(XMLRPC_VALUE value) { + return ((value && value->type == xmlrpc_datetime) ? value->str.str : 0); +} + +/*******/ + +/* Get ID (key) of value or NULL */ +/****f* VALUE/XMLRPC_GetValueID + * NAME + * XMLRPC_GetValueID + * SYNOPSIS + * const char* XMLRPC_GetValueID(XMLRPC_VALUE value) + * FUNCTION + * retrieve id (key) of value + * INPUTS + * XMLRPC_VALUE of any type + * RESULT + * const char* pointer to id of value, or NULL + * NOTES + * SEE ALSO + * XMLRPC_SetValueID() + * XMLRPC_CreateValueEmpty() + * SOURCE + */ +const char* XMLRPC_GetValueID(XMLRPC_VALUE value) { + return (const char*)((value && value->id.len) ? value->id.str : 0); +} + +/*******/ + + +/****f* VECTOR/XMLRPC_VectorSize + * NAME + * XMLRPC_VectorSize + * SYNOPSIS + * int XMLRPC_VectorSize(XMLRPC_VALUE value) + * FUNCTION + * retrieve size of vector + * INPUTS + * XMLRPC_VALUE of type xmlrpc_vector + * RESULT + * count of items in vector + * NOTES + * This is a cheap operation even on large vectors. Vector size is + * maintained by queue during add/remove ops. + * SEE ALSO + * XMLRPC_AddValueToVector () + * SOURCE + */ +int XMLRPC_VectorSize(XMLRPC_VALUE value) { + int size = 0; + if(value && value->type == xmlrpc_vector && value->v) { + size = Q_Size(value->v->q); + } + return size; +} + +/*******/ + +/****f* VECTOR/XMLRPC_VectorRewind + * NAME + * XMLRPC_VectorRewind + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_VectorRewind(XMLRPC_VALUE value) + * FUNCTION + * reset vector to first item + * INPUTS + * XMLRPC_VALUE of type xmlrpc_vector + * RESULT + * first XMLRPC_VALUE in list, or NULL if empty or error. + * NOTES + * Be careful to rewind any vector passed in to you if you expect to + * iterate through the entire list. + * SEE ALSO + * XMLRPC_VectorNext () + * SOURCE + */ +XMLRPC_VALUE XMLRPC_VectorRewind(XMLRPC_VALUE value) { + XMLRPC_VALUE xReturn = NULL; + if(value && value->type == xmlrpc_vector && value->v) { + xReturn = (XMLRPC_VALUE)Q_Head(value->v->q); + } + return xReturn; +} + +/*******/ + +/****f* VECTOR/XMLRPC_VectorNext + * NAME + * XMLRPC_VectorNext + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_VectorNext(XMLRPC_VALUE value) + * FUNCTION + * Iterate vector to next item in list. + * INPUTS + * XMLRPC_VALUE of type xmlrpc_vector + * RESULT + * Next XMLRPC_VALUE in vector, or NULL if at end. + * NOTES + * SEE ALSO + * XMLRPC_VectorRewind () + * SOURCE + */ +XMLRPC_VALUE XMLRPC_VectorNext(XMLRPC_VALUE value) { + XMLRPC_VALUE xReturn = NULL; + if(value && value->type == xmlrpc_vector && value->v) { + xReturn = (XMLRPC_VALUE)Q_Next(value->v->q); + } + return xReturn; +} + +/*******/ + +/****f* VALUE/XMLRPC_GetValueType + * NAME + * XMLRPC_GetValueType + * SYNOPSIS + * XMLRPC_VALUE_TYPE XMLRPC_GetValueType(XMLRPC_VALUE value) + * FUNCTION + * determine data type of the XMLRPC_VALUE + * INPUTS + * XMLRPC_VALUE target of query + * RESULT + * data type of value as enumerated by XMLRPC_VALUE_TYPE + * NOTES + * all values are of type xmlrpc_empty until set. + * Deprecated for public use. See XMLRPC_GetValueTypeEasy + * SEE ALSO + * XMLRPC_SetValue* + * XMLRPC_CreateValue* + * XMLRPC_Append* + * XMLRPC_GetValueTypeEasy () + * SOURCE + */ +XMLRPC_VALUE_TYPE XMLRPC_GetValueType(XMLRPC_VALUE value) { + return value ? value->type : xmlrpc_empty; +} + +/*******/ + +/* Vector type accessor */ +/****f* VALUE/XMLRPC_GetVectorType + * NAME + * XMLRPC_GetVectorType + * SYNOPSIS + * XMLRPC_VECTOR_TYPE XMLRPC_GetVectorType(XMLRPC_VALUE value) + * FUNCTION + * determine vector type of the XMLRPC_VALUE + * INPUTS + * XMLRPC_VALUE of type xmlrpc_vector + * RESULT + * vector type of value as enumerated by XMLRPC_VECTOR_TYPE. + * xmlrpc_none if not a value. + * NOTES + * xmlrpc_none is returned if value is not a vector + * Deprecated for public use. See XMLRPC_GetValueTypeEasy + * SEE ALSO + * XMLRPC_SetIsVector () + * XMLRPC_GetValueType () + * XMLRPC_GetValueTypeEasy () + * SOURCE + */ +XMLRPC_VECTOR_TYPE XMLRPC_GetVectorType(XMLRPC_VALUE value) { + return(value && value->v) ? value->v->type : xmlrpc_none; +} + +/*******/ + +/****f* VALUE/XMLRPC_GetValueTypeEasy + * NAME + * XMLRPC_GetValueTypeEasy + * SYNOPSIS + * XMLRPC_VALUE_TYPE_EASY XMLRPC_GetValueTypeEasy(XMLRPC_VALUE value) + * FUNCTION + * determine data type of the XMLRPC_VALUE. includes vector types. + * INPUTS + * XMLRPC_VALUE target of query + * RESULT + * data type of value as enumerated by XMLRPC_VALUE_TYPE_EASY + * xmlrpc_type_none if not a value. + * NOTES + * all values are of type xmlrpc_type_empty until set. + * SEE ALSO + * XMLRPC_SetValue* + * XMLRPC_CreateValue* + * XMLRPC_Append* + * SOURCE + */ +XMLRPC_VALUE_TYPE_EASY XMLRPC_GetValueTypeEasy (XMLRPC_VALUE value) { + if (value) { + switch (value->type) { + case xmlrpc_vector: + switch (value->v->type) { + case xmlrpc_vector_none: + return xmlrpc_type_none; + case xmlrpc_vector_struct: + return xmlrpc_type_struct; + case xmlrpc_vector_mixed: + return xmlrpc_type_mixed; + case xmlrpc_vector_array: + return xmlrpc_type_array; + } + default: + /* evil cast, but we know they are the same */ + return(XMLRPC_VALUE_TYPE_EASY) value->type; + } + } + return xmlrpc_none; +} + +/*******/ + + + +/*-******************* +* Begin Server Funcs * +*********************/ + + +/****f* VALUE/XMLRPC_ServerCreate + * NAME + * XMLRPC_ServerCreate + * SYNOPSIS + * XMLRPC_SERVER XMLRPC_ServerCreate() + * FUNCTION + * Allocate/Init XMLRPC Server Resources. + * INPUTS + * none + * RESULT + * newly allocated XMLRPC_SERVER + * NOTES + * SEE ALSO + * XMLRPC_ServerDestroy () + * XMLRPC_GetGlobalServer () + * SOURCE + */ +XMLRPC_SERVER XMLRPC_ServerCreate() { + XMLRPC_SERVER server = calloc(1, sizeof(STRUCT_XMLRPC_SERVER)); + if(server) { + Q_Init(&server->methodlist); + Q_Init(&server->docslist); + + /* register system methods */ + xsm_register(server); + } + return server; +} + +/*******/ + +/* Return global server. Not locking! Not Thread Safe! */ +/****f* VALUE/XMLRPC_GetGlobalServer + * NAME + * XMLRPC_GetGlobalServer + * SYNOPSIS + * XMLRPC_SERVER XMLRPC_GetGlobalServer() + * FUNCTION + * Allocates a global (process-wide) server, or returns pointer if pre-existing. + * INPUTS + * none + * RESULT + * pointer to global server, or 0 if error. + * NOTES + * ***WARNING*** This function is not thread safe. It is included only for the very lazy. + * Multi-threaded programs that use this may experience problems. + * BUGS + * There is currently no way to cleanup the global server gracefully. + * SEE ALSO + * XMLRPC_ServerCreate () + * SOURCE + */ +XMLRPC_SERVER XMLRPC_GetGlobalServer() { + static XMLRPC_SERVER xsServer = 0; + if(!xsServer) { + xsServer = XMLRPC_ServerCreate(); + } + return xsServer; +} + +/*******/ + +/****f* VALUE/XMLRPC_ServerDestroy + * NAME + * XMLRPC_ServerDestroy + * SYNOPSIS + * void XMLRPC_ServerDestroy(XMLRPC_SERVER server) + * FUNCTION + * Free Server Resources + * INPUTS + * server The server to be free'd + * RESULT + * void + * NOTES + * This frees the server struct and any methods that have been added. + * SEE ALSO + * XMLRPC_ServerCreate () + * SOURCE + */ +void XMLRPC_ServerDestroy(XMLRPC_SERVER server) { + if(server) { + doc_method* dm = Q_Head(&server->docslist); + server_method* sm = Q_Head(&server->methodlist); + while( dm ) { + my_free(dm); + dm = Q_Next(&server->docslist); + } + while( sm ) { + if(sm->name) { + my_free(sm->name); + } + if(sm->desc) { + XMLRPC_CleanupValue(sm->desc); + } + my_free(sm); + sm = Q_Next(&server->methodlist); + } + if(server->xIntrospection) { + XMLRPC_CleanupValue(server->xIntrospection); + } + + Q_Destroy(&server->methodlist); + Q_Destroy(&server->docslist); + my_free(server); + } +} + +/*******/ + + +/****f* VALUE/XMLRPC_ServerRegisterMethod + * NAME + * XMLRPC_ServerRegisterMethod + * SYNOPSIS + * void XMLRPC_ServerRegisterMethod(XMLRPC_SERVER server, const char *name, XMLRPC_Callback cb) + * FUNCTION + * Register new XMLRPC method with server + * INPUTS + * server The XMLRPC_SERVER to register the method with + * name public name of the method + * cb C function that implements the method + * RESULT + * int - 1 if success, else 0 + * NOTES + * A C function must be registered for every "method" that the server recognizes. The + * method name is equivalent to <methodCall><name> method name </name></methodCall> in the + * XML syntax. + * SEE ALSO + * XMLRPC_ServerFindMethod () + * XMLRPC_ServerCallMethod () + * SOURCE + */ +int XMLRPC_ServerRegisterMethod(XMLRPC_SERVER server, const char *name, XMLRPC_Callback cb) { + if(server && name && cb) { + + server_method* sm = malloc(sizeof(server_method)); + + if(sm) { + sm->name = strdup(name); + sm->method = cb; + sm->desc = NULL; + + return Q_PushTail(&server->methodlist, sm); + } + } + return 0; +} + +/*******/ + +server_method* find_method(XMLRPC_SERVER server, const char* name) { + server_method* sm; + + q_iter qi = Q_Iter_Head_F(&server->methodlist); + + while( qi ) { + sm = Q_Iter_Get_F(qi); + if(sm && !strcmp(sm->name, name)) { + return sm; + } + qi = Q_Iter_Next_F(qi); + } + return NULL; +} + + +const char* type_to_str(XMLRPC_VALUE_TYPE type, XMLRPC_VECTOR_TYPE vtype) { + switch(type) { + case xmlrpc_none: + return "none"; + case xmlrpc_empty: + return "empty"; + case xmlrpc_base64: + return "base64"; + case xmlrpc_boolean: + return "boolean"; + case xmlrpc_datetime: + return "datetime"; + case xmlrpc_double: + return "double"; + case xmlrpc_int: + return "int"; + case xmlrpc_string: + return "string"; + case xmlrpc_vector: + switch(vtype) { + case xmlrpc_vector_none: + return "none"; + case xmlrpc_vector_array: + return "array"; + case xmlrpc_vector_mixed: + return "mixed vector (struct)"; + case xmlrpc_vector_struct: + return "struct"; + } + } + return "unknown"; +} + +/****f* VALUE/XMLRPC_ServerFindMethod + * NAME + * XMLRPC_ServerFindMethod + * SYNOPSIS + * XMLRPC_Callback XMLRPC_ServerFindMethod(XMLRPC_SERVER server, const char* callName) + * FUNCTION + * retrieve C callback associated with a given method name. + * INPUTS + * server The XMLRPC_SERVER the method is registered with + * callName the method to find + * RESULT + * previously registered XMLRPC_Callback, or NULL + * NOTES + * Typically, this is used to determine if a requested method exists, without actually calling it. + * SEE ALSO + * XMLRPC_ServerCallMethod () + * XMLRPC_ServerRegisterMethod () + * SOURCE + */ +XMLRPC_Callback XMLRPC_ServerFindMethod(XMLRPC_SERVER server, const char* callName) { + if(server && callName) { + q_iter qi = Q_Iter_Head_F(&server->methodlist); + while( qi ) { + server_method* sm = Q_Iter_Get_F(qi); + if(sm && !strcmp(sm->name, callName)) { + return sm->method; + } + qi = Q_Iter_Next_F(qi); + } + } + return NULL; +} + +/*******/ + + +/* Call method specified in request */ +/****f* VALUE/XMLRPC_ServerCallMethod + * NAME + * XMLRPC_ServerCallMethod + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_ServerCallMethod(XMLRPC_SERVER server, XMLRPC_REQUEST request, void* userData) + * FUNCTION + * + * INPUTS + * server The XMLRPC_SERVER the method is registered with + * request the request to handle + * userData any additional data to pass to the C callback, or NULL + * RESULT + * XMLRPC_VALUE allocated by the callback, or NULL + * NOTES + * It is typically the caller's responsibility to free the returned value. + * + * Often the caller will want to serialize the result as XML, via + * XMLRPC_VALUE_To_XML () or XMLRPC_REQUEST_To_XML () + * SEE ALSO + * XMLRPC_ServerFindMethod () + * XMLRPC_ServerRegisterMethod () + * XMLRPC_CleanupValue () + * SOURCE + */ +XMLRPC_VALUE XMLRPC_ServerCallMethod(XMLRPC_SERVER server, XMLRPC_REQUEST request, void* userData) { + XMLRPC_VALUE xReturn = NULL; + + /* check for error set during request parsing / generation */ + if(request && request->error) { + xReturn = XMLRPC_CopyValue(request->error); + } + else if (server && request) { + XMLRPC_Callback cb = + XMLRPC_ServerFindMethod (server, request->methodName.str); + if(cb) { + xReturn = cb(server, request, userData); + } + else { + xReturn = + XMLRPC_UtilityCreateFault (xmlrpc_error_unknown_method, + request->methodName.str); + } + } + return xReturn; +} + +/*******/ + +/*-***************** +* End server funcs * +*******************/ + + +/*-*********************************** +* Begin XMLRPC General Options funcs * +*************************************/ + +/* For options used by XMLRPC_VALUE funcs that otherwise do not have + * parameters for options. Kind of gross. :( + */ +typedef struct _xmlrpc_options { + XMLRPC_CASE id_case; + XMLRPC_CASE_COMPARISON id_case_compare; +} +STRUCT_XMLRPC_OPTIONS, *XMLRPC_OPTIONS; + +static XMLRPC_OPTIONS XMLRPC_GetDefaultOptions() { + static STRUCT_XMLRPC_OPTIONS options = { + xmlrpc_case_exact, + xmlrpc_case_sensitive + }; + return &options; +} + +/****f* VALUE/XMLRPC_GetDefaultIdCase + * NAME + * XMLRPC_GetDefaultIdCase + * SYNOPSIS + * XMLRPC_CASE XMLRPC_GetDefaultIdCase() + * FUNCTION + * Gets default case options used by XMLRPC_VALUE funcs + * INPUTS + * none + * RESULT + * XMLRPC_CASE + * BUGS + * Nasty and gross. Should be server specific, but that requires changing all + * the XMLRPC_VALUE api's. + * SEE ALSO + * XMLRPC_SetDefaultIdCase () + * SOURCE + */ +XMLRPC_CASE XMLRPC_GetDefaultIdCase() { + XMLRPC_OPTIONS options = XMLRPC_GetDefaultOptions(); + return options->id_case; +} + +/*******/ + +/****f* VALUE/XMLRPC_SetDefaultIdCase + * NAME + * XMLRPC_SetDefaultIdCase + * SYNOPSIS + * XMLRPC_CASE XMLRPC_SetDefaultIdCase(XMLRPC_CASE id_case) + * FUNCTION + * Sets default case options used by XMLRPC_VALUE funcs + * INPUTS + * id_case case options as enumerated by XMLRPC_CASE + * RESULT + * XMLRPC_CASE -- newly set option + * BUGS + * Nasty and gross. Should be server specific, but that requires changing all + * the XMLRPC_VALUE api's. + * SEE ALSO + * XMLRPC_GetDefaultIdCase () + * SOURCE + */ +XMLRPC_CASE XMLRPC_SetDefaultIdCase(XMLRPC_CASE id_case) { + XMLRPC_OPTIONS options = XMLRPC_GetDefaultOptions(); + options->id_case = id_case; + return options->id_case; +} + +/*******/ + +/****f* VALUE/XMLRPC_GetDefaultIdCaseComparison + * NAME + * XMLRPC_GetDefaultIdCaseComparison + * SYNOPSIS + * XMLRPC_CASE XMLRPC_GetDefaultIdCaseComparison( ) + * FUNCTION + * Gets default case comparison options used by XMLRPC_VALUE funcs + * INPUTS + * none + * RESULT + * XMLRPC_CASE_COMPARISON default + * BUGS + * Nasty and gross. Should be server specific, but that requires changing all + * the XMLRPC_VALUE api's. + * SEE ALSO + * XMLRPC_SetDefaultIdCaseComparison () + * SOURCE + */ +XMLRPC_CASE_COMPARISON XMLRPC_GetDefaultIdCaseComparison() { + XMLRPC_OPTIONS options = XMLRPC_GetDefaultOptions(); + return options->id_case_compare; +} + +/*******/ + +/****f* VALUE/XMLRPC_SetDefaultIdCaseComparison + * NAME + * XMLRPC_SetDefaultIdCaseComparison + * SYNOPSIS + * XMLRPC_CASE XMLRPC_SetDefaultIdCaseComparison( XMLRPC_CASE_COMPARISON id_case_compare ) + * FUNCTION + * Gets default case comparison options used by XMLRPC_VALUE funcs + * INPUTS + * id_case_compare case comparison rule to set as default + * RESULT + * XMLRPC_CASE_COMPARISON newly set default + * BUGS + * Nasty and gross. Should be server specific, but that requires changing all + * the XMLRPC_VALUE api's. + * SEE ALSO + * XMLRPC_GetDefaultIdCaseComparison () + * SOURCE + */ +XMLRPC_CASE_COMPARISON XMLRPC_SetDefaultIdCaseComparison(XMLRPC_CASE_COMPARISON id_case_compare) { + XMLRPC_OPTIONS options = XMLRPC_GetDefaultOptions(); + options->id_case_compare = id_case_compare; + return options->id_case_compare; +} + +/*******/ + +/*-********************************* +* End XMLRPC General Options funcs * +***********************************/ + + +/*-****************** +* Fault API funcs * +********************/ + +/****f* UTILITY/XMLRPC_UtilityCreateFault + * NAME + * XMLRPC_UtilityCreateFault + * SYNOPSIS + * XMLRPC_VALUE XMLRPC_UtilityCreateFault( int fault_code, const char* fault_string ) + * FUNCTION + * generates a struct containing a string member with id "faultString" and an int member + * with id "faultCode". When using the xmlrpc xml serialization, these will be translated + * to <fault><value><struct>... format. + * INPUTS + * fault_code application specific error code. can be 0. + * fault_string application specific error string. cannot be null. + * RESULT + * XMLRPC_VALUE a newly created struct vector representing the error, or null on error. + * NOTES + * This is a utility function. xmlrpc "faults" are not directly represented in this xmlrpc + * API or data structures. It is the author's view, that this API is intended for simple + * data types, and a "fault" is a complex data type consisting of multiple simple data + * types. This function is provided for convenience only, the same result could be + * achieved directly by the application. + * + * This function now supports some "standardized" fault codes, as specified at. + * http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php. + * If one of these fault codes is received, the description string will automatically + * be prefixed with a standard error string and 2 newlines. + * + * The actual transformation between this complex type and the xml "<fault>" element takes + * place in the xmlrpc to xml serialization layer. This step is not performed when using the + * simplerpc serialization, meaning that there will be no "<fault>" element in that + * serialization. There will simply be a standard struct with 2 child elements. + * imho, the "<fault>" element is unnecessary and/or out of place as part of the standard API. + * + * SOURCE + */ +XMLRPC_VALUE XMLRPC_UtilityCreateFault(int fault_code, const char* fault_string) { + XMLRPC_VALUE xOutput = NULL; + + char* string = NULL; + simplestring description; + simplestring_init(&description); + + switch (fault_code) { + case xmlrpc_error_parse_xml_syntax: + string = xmlrpc_error_parse_xml_syntax_str; + break; + case xmlrpc_error_parse_unknown_encoding: + string = xmlrpc_error_parse_unknown_encoding_str; + break; + case xmlrpc_error_parse_bad_encoding: + string = xmlrpc_error_parse_bad_encoding_str; + break; + case xmlrpc_error_invalid_xmlrpc: + string = xmlrpc_error_invalid_xmlrpc_str; + break; + case xmlrpc_error_unknown_method: + string = xmlrpc_error_unknown_method_str; + break; + case xmlrpc_error_invalid_params: + string = xmlrpc_error_invalid_params_str; + break; + case xmlrpc_error_internal_server: + string = xmlrpc_error_internal_server_str; + break; + case xmlrpc_error_application: + string = xmlrpc_error_application_str; + break; + case xmlrpc_error_system: + string = xmlrpc_error_system_str; + break; + case xmlrpc_error_transport: + string = xmlrpc_error_transport_str; + break; + } + + simplestring_add(&description, string); + + if(string && fault_string) { + simplestring_add(&description, "\n\n"); + } + simplestring_add(&description, fault_string); + + + if(description.len) { + xOutput = XMLRPC_CreateVector(NULL, xmlrpc_vector_struct); + + XMLRPC_VectorAppendString (xOutput, "faultString", description.str, + description.len); + XMLRPC_VectorAppendInt(xOutput, "faultCode", fault_code); + } + + simplestring_free(&description); + + return xOutput; +} + +/*******/ + + +/****f* FAULT/XMLRPC_ValueIsFault + * NAME + * XMLRPC_ValueIsFault + * SYNOPSIS + * int XMLRPC_ValueIsFault (XMLRPC_VALUE value) + * FUNCTION + * Determines if a value encapsulates a fault "object" + * INPUTS + * value any XMLRPC_VALUE + * RESULT + * 1 if it is a fault, else 0 + * SEE ALSO + * XMLRPC_ResponseIsFault () + * SOURCE + */ +int XMLRPC_ValueIsFault (XMLRPC_VALUE value) { + if( XMLRPC_VectorGetValueWithID(value, "faultCode") && + XMLRPC_VectorGetValueWithID(value, "faultString") ) { + return 1; + } + return 0; +} +/*******/ + + +/****f* FAULT/XMLRPC_ResponseIsFault + * NAME + * XMLRPC_ResponseIsFault + * SYNOPSIS + * int XMLRPC_ResponseIsFault (XMLRPC_REQUEST response) + * FUNCTION + * Determines if a response contains an encapsulated fault "object" + * INPUTS + * value any XMLRPC_REQUEST. typically of type xmlrpc_request_response + * RESULT + * 1 if it contains a fault, else 0 + * SEE ALSO + * XMLRPC_ValueIsFault () + * SOURCE + */ +int XMLRPC_ResponseIsFault(XMLRPC_REQUEST response) { + return XMLRPC_ValueIsFault( XMLRPC_RequestGetData(response) ); +} + +/*******/ + +/****f* FAULT/XMLRPC_GetValueFaultCode + * NAME + * XMLRPC_GetValueFaultCode + * SYNOPSIS + * int XMLRPC_GetValueFaultCode (XMLRPC_VALUE value) + * FUNCTION + * returns fault code from a struct, if any + * INPUTS + * value XMLRPC_VALUE of type xmlrpc_vector_struct. + * RESULT + * fault code, else 0. + * BUGS + * impossible to distinguish faultCode == 0 from faultCode not present. + * SEE ALSO + * XMLRPC_GetResponseFaultCode () + * SOURCE + */ +int XMLRPC_GetValueFaultCode (XMLRPC_VALUE value) { + return XMLRPC_VectorGetIntWithID(value, "faultCode"); +} + +/*******/ + +/****f* FAULT/XMLRPC_GetResponseFaultCode + * NAME + * XMLRPC_GetResponseFaultCode + * SYNOPSIS + * int XMLRPC_GetResponseFaultCode(XMLRPC_REQUEST response) + * FUNCTION + * returns fault code from a response, if any + * INPUTS + * response XMLRPC_REQUEST. typically of type xmlrpc_request_response. + * RESULT + * fault code, else 0. + * BUGS + * impossible to distinguish faultCode == 0 from faultCode not present. + * SEE ALSO + * XMLRPC_GetValueFaultCode () + * SOURCE + */ +int XMLRPC_GetResponseFaultCode(XMLRPC_REQUEST response) { + return XMLRPC_GetValueFaultCode( XMLRPC_RequestGetData(response) ); +} + +/*******/ + + +/****f* FAULT/XMLRPC_GetValueFaultString + * NAME + * XMLRPC_GetValueFaultString + * SYNOPSIS + * const char* XMLRPC_GetValueFaultString (XMLRPC_VALUE value) + * FUNCTION + * returns fault string from a struct, if any + * INPUTS + * value XMLRPC_VALUE of type xmlrpc_vector_struct. + * RESULT + * fault string, else 0. + * SEE ALSO + * XMLRPC_GetResponseFaultString () + * SOURCE + */ +const char* XMLRPC_GetValueFaultString (XMLRPC_VALUE value) { + return XMLRPC_VectorGetStringWithID(value, "faultString"); +} + +/*******/ + +/****f* FAULT/XMLRPC_GetResponseFaultString + * NAME + * XMLRPC_GetResponseFaultString + * SYNOPSIS + * const char* XMLRPC_GetResponseFaultString (XMLRPC_REQUEST response) + * FUNCTION + * returns fault string from a response, if any + * INPUTS + * response XMLRPC_REQUEST. typically of type xmlrpc_request_response. + * RESULT + * fault string, else 0. + * SEE ALSO + * XMLRPC_GetValueFaultString () + * SOURCE + */ +const char* XMLRPC_GetResponseFaultString (XMLRPC_REQUEST response) { + return XMLRPC_GetValueFaultString( XMLRPC_RequestGetData(response) ); +} + +/*******/ + + +/*-****************** +* Utility API funcs * +********************/ + + +/****f* UTILITY/XMLRPC_Free + * NAME + * XMLRPC_Free + * SYNOPSIS + * void XMLRPC_Free(void* mem) + * FUNCTION + * frees a block of memory allocated by xmlrpc. + * INPUTS + * mem memory to free + * RESULT + * void + * NOTES + * Useful for OS's where memory must be free'd + * in the same library in which it is allocated. + * SOURCE + */ +void XMLRPC_Free(void* mem) { + my_free(mem); +} + +/*******/ + + +/****f* UTILITY/XMLRPC_GetVersionString + * NAME + * XMLRPC_GetVersionString + * SYNOPSIS + * const char* XMLRPC_GetVersionString() + * FUNCTION + * returns library version string + * INPUTS + * + * RESULT + * const char* + * NOTES + * SOURCE + */ +const char* XMLRPC_GetVersionString() { + return XMLRPC_VERSION_STR; +} + +/*******/ + + +/*-********************** +* End Utility API funcs * +************************/ |