+++ /dev/null
-/*
- 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: xmlrpc.c,v $
- * 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
- *******/
-
-
-#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 "expat.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 int date_from_ISO8601 (const char *text, time_t * value) {
- struct tm tm;
- int n;
- int i;
- char buf[18];
-
- if (strchr (text, '-')) {
- char *p = (char *) text, *p2 = buf;
- while (p && *p) {
- if (*p != '-') {
- *p2 = *p;
- p2++;
- }
- p++;
- }
- text = buf;
- }
-
-
- tm.tm_isdst = -1;
-
- if(strlen(text) < 17) {
- return -1;
- }
-
- n = 1000;
- tm.tm_year = 0;
- for(i = 0; i < 4; i++) {
- tm.tm_year += (text[i]-'0')*n;
- n /= 10;
- }
- n = 10;
- tm.tm_mon = 0;
- for(i = 0; i < 2; 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++) {
- tm.tm_mday += (text[i+6]-'0')*n;
- n /= 10;
- }
-
- n = 10;
- tm.tm_hour = 0;
- for(i = 0; i < 2; i++) {
- tm.tm_hour += (text[i+9]-'0')*n;
- n /= 10;
- }
-
- n = 10;
- tm.tm_min = 0;
- for(i = 0; i < 2; i++) {
- tm.tm_min += (text[i+12]-'0')*n;
- n /= 10;
- }
-
- n = 10;
- tm.tm_sec = 0;
- for(i = 0; i < 2; i++) {
- tm.tm_sec += (text[i+15]-'0')*n;
- n /= 10;
- }
-
- tm.tm_year -= 1900;
-
- *value = mktime(&tm);
-
- return 0;
-
-}
-
-static int date_to_ISO8601 (time_t value, char *buf, int length) {
- struct tm *tm;
- tm = localtime(&value);
-#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:%S", 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_nil:
- 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]) {
- simplestring_clear(&value->str);
- simplestring_add(&value->str, 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) {
- date_from_ISO8601(s, &time_val);
- XMLRPC_SetValueDateTime(value, time_val);
- }
- }
-}
-
-/*******/
-
-/****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_nil:
- return "nil";
- 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 *
-************************/
git://git.onelab.eu / plcapi.git / blobdiff