Annotation of embedaddon/php/ext/xmlrpc/libxmlrpc/xmlrpc.c, revision 1.1
1.1 ! misho 1: /*
! 2: This file is part of libXMLRPC - a C library for xml-encoded function calls.
! 3:
! 4: Author: Dan Libby (dan@libby.com)
! 5: Epinions.com may be contacted at feedback@epinions-inc.com
! 6: */
! 7:
! 8: /*
! 9: Copyright 2000 Epinions, Inc.
! 10:
! 11: Subject to the following 3 conditions, Epinions, Inc. permits you, free
! 12: of charge, to (a) use, copy, distribute, modify, perform and display this
! 13: software and associated documentation files (the "Software"), and (b)
! 14: permit others to whom the Software is furnished to do so as well.
! 15:
! 16: 1) The above copyright notice and this permission notice shall be included
! 17: without modification in all copies or substantial portions of the
! 18: Software.
! 19:
! 20: 2) THE SOFTWARE IS PROVIDED "AS IS", WITHOUT ANY WARRANTY OR CONDITION OF
! 21: ANY KIND, EXPRESS, IMPLIED OR STATUTORY, INCLUDING WITHOUT LIMITATION ANY
! 22: IMPLIED WARRANTIES OF ACCURACY, MERCHANTABILITY, FITNESS FOR A PARTICULAR
! 23: PURPOSE OR NONINFRINGEMENT.
! 24:
! 25: 3) IN NO EVENT SHALL EPINIONS, INC. BE LIABLE FOR ANY DIRECT, INDIRECT,
! 26: SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT
! 27: OF OR IN CONNECTION WITH THE SOFTWARE (HOWEVER ARISING, INCLUDING
! 28: NEGLIGENCE), EVEN IF EPINIONS, INC. IS AWARE OF THE POSSIBILITY OF SUCH
! 29: DAMAGES.
! 30:
! 31: */
! 32:
! 33:
! 34: static const char rcsid[] = "#(@) $Id: xmlrpc.c 270900 2008-12-09 17:22:12Z iliaa $";
! 35:
! 36:
! 37: /****h* ABOUT/xmlrpc
! 38: * NAME
! 39: * XMLRPC_VALUE
! 40: * AUTHOR
! 41: * Dan Libby, aka danda (dan@libby.com)
! 42: * CREATION DATE
! 43: * 9/1999 - 10/2000
! 44: * HISTORY
! 45: * $Log$
! 46: * Revision 1.8.4.3.2.1 2008/09/10 00:07:44 felipe
! 47: * MFH:
! 48: * - Merged fix from SF project (Import Jeff Lawsons patches for XML datetime bug fixes)
! 49: * Fixed bugs:
! 50: * #45226 (xmlrpc_set_type() segfaults with valid ISO8601 date string)
! 51: * #18916 (xmlrpc_set_type() "not working")
! 52: *
! 53: * Revision 1.8.4.3 2007/09/18 19:49:53 iliaa
! 54: *
! 55: * Fixed bug #42189 (xmlrpc_set_type() crashes php on invalid datetime
! 56: * values).
! 57: *
! 58: * Revision 1.8.4.2 2007/06/07 09:07:36 tony2001
! 59: * MFH: php_localtime_r() checks
! 60: *
! 61: * Revision 1.8.4.1 2006/11/30 16:38:37 iliaa
! 62: * last set of zts fixes
! 63: *
! 64: * Revision 1.8 2005/03/28 00:07:24 edink
! 65: * Reshufle includes to make it compile on windows
! 66: *
! 67: * Revision 1.7 2005/03/26 03:13:58 sniper
! 68: * - Made it possible to build ext/xmlrpc with libxml2
! 69: *
! 70: * Revision 1.6 2004/04/27 17:33:59 iliaa
! 71: * Removed C++ style comments.
! 72: *
! 73: * Revision 1.5 2003/12/16 21:00:21 sniper
! 74: * Fix some compile warnings (patch by Joe Orton)
! 75: *
! 76: * Revision 1.4 2002/07/05 04:43:53 danda
! 77: * merged in updates from SF project. bring php repository up to date with xmlrpc-epi version 0.51
! 78: *
! 79: * Revision 1.22 2002/03/09 23:15:44 danda
! 80: * add fault interrogation funcs
! 81: *
! 82: * Revision 1.21 2002/03/09 22:27:41 danda
! 83: * win32 build patches contributed by Jeff Lawson
! 84: *
! 85: * Revision 1.20 2002/02/13 20:58:50 danda
! 86: * patch to make source more windows friendly, contributed by Jeff Lawson
! 87: *
! 88: * Revision 1.19 2001/10/12 23:25:54 danda
! 89: * default to writing xmlrpc
! 90: *
! 91: * Revision 1.18 2001/09/29 21:58:05 danda
! 92: * adding cvs log to history section
! 93: *
! 94: * 10/15/2000 -- danda -- adding robodoc documentation
! 95: * 08/2000 -- danda -- PHP C extension that uses XMLRPC
! 96: * 08/2000 -- danda -- support for two vocabularies: danda-rpc and xml-rpc
! 97: * 09/1999 -- danda -- Initial API, before I even knew of standard XMLRPC vocab. Response only.
! 98: * 07/2000 -- danda -- wrote new implementation to be compatible with xmlrpc standard and
! 99: * incorporated some ideas from ensor, most notably the separation of
! 100: * xml dom from xmlrpc api.
! 101: * 06/2000 -- danda -- played with expat-ensor from www.ensor.org. Cool, but some flaws.
! 102: * TODO
! 103: * PORTABILITY
! 104: * Coded on RedHat Linux 6.2. Builds on Solaris x86. Should build on just
! 105: * about anything with minor mods.
! 106: * NOTES
! 107: * Welcome to XMLRPC. For more info on the specification and history, see
! 108: * http://www.xmlrpc.org.
! 109: *
! 110: * This code aims to be a full-featured C implementation of XMLRPC. It does not
! 111: * have any networking code. Rather, it is intended to be plugged into apps
! 112: * or libraries with existing networking facilities, eg PHP, apache, perl, mozilla,
! 113: * home-brew application servers, etc.
! 114: *
! 115: * Usage Paradigm:
! 116: * The user of this library will typically be implementing either an XMLRPC server,
! 117: * an XMLRPC client, or both. The client will use the library to build an in-memory
! 118: * representation of a request, and then serialize (encode) that request into XML. The
! 119: * client will then send the XML to the server via external mechanism. The server will
! 120: * de-serialize the XML back into an binary representation, call the appropriate registered
! 121: * method -- thereby generating a response. The response will be serialized into XML and
! 122: * sent back to the client. The client will de-serialize it into memory, and can
! 123: * iterate through the results via API.
! 124: *
! 125: * Both the request and the response may consist of arbitrarily long, arbitrarily nested
! 126: * values. The values may be one of several types, as defined by XMLRPC_VALUE_TYPE.
! 127: *
! 128: * Features and Architecture:
! 129: * - The XML parsing (xml_element.c) is completely independent of the XMLRPC api. In fact,
! 130: * it can be used as a standalone dom implementation.
! 131: * - Because of this, the same XMLRPC data can be serialized into multiple xml vocabularies.
! 132: * It is simply a matter of writing a transport. So far, two transports have been defined.
! 133: * The default xmlrpc vocab (xml_to_xmlrpc.c), and simple-rpc (xml_to_dandarpc.c) which is
! 134: * proprietary, but imho more readable, and nice for proprietary legacy reasons.
! 135: * - Various output options, including: xml escaping via CDATA or entity, case folding,
! 136: * vocab version, and character encoding.
! 137: * - One to One mapping between C structures and actual values, unlike ensor which forces
! 138: * one to understand the arcana of the xmlrpc vocab.
! 139: * - support for mixed indexed/keyed vector types, making it more compatible with
! 140: * languages such as PHP.
! 141: * - quite speedy compared to implementations written in interpreted languages. Also, uses
! 142: * intelligent string handling, so not many strlen() calls, etc.
! 143: * - comprehensive API for manipulation of values
! 144: *******/
! 145:
! 146: #include "ext/xml/expat_compat.h"
! 147: #include "main/php_reentrancy.h"
! 148: #ifdef _WIN32
! 149: #include "xmlrpc_win32.h"
! 150: #endif
! 151: #include <stdio.h>
! 152: #include <stdlib.h>
! 153: #include <string.h>
! 154: #include <stdarg.h>
! 155: #include <time.h>
! 156: #include <ctype.h>
! 157:
! 158: #include "queue.h"
! 159: #include "xmlrpc.h"
! 160: #include "base64.h"
! 161:
! 162: #include "xml_to_xmlrpc.h"
! 163: #include "xml_to_dandarpc.h"
! 164: #include "xml_to_soap.h"
! 165: #include "xml_element.h"
! 166: #include "xmlrpc_private.h"
! 167: #include "xmlrpc_introspection_private.h"
! 168: #include "system_methods_private.h"
! 169:
! 170:
! 171:
! 172: /*-*********************
! 173: * Begin Time Functions *
! 174: ***********************/
! 175:
! 176: static time_t mkgmtime(struct tm *tm)
! 177: {
! 178: static const int mdays[12] = {0,31,59,90,120,151,181,212,243,273,304,334};
! 179:
! 180: return ((((((tm->tm_year - 70) * 365) + mdays[tm->tm_mon] + tm->tm_mday-1 +
! 181: (tm->tm_year-68-1+(tm->tm_mon>=2))/4) * 24) + tm->tm_hour) * 60 +
! 182: tm->tm_min) * 60 + tm->tm_sec;
! 183: }
! 184:
! 185: static int date_from_ISO8601 (const char *text, time_t * value) {
! 186: struct tm tm;
! 187: int n;
! 188: int i;
! 189: char buf[30];
! 190:
! 191:
! 192: if (strchr (text, '-')) {
! 193: char *p = (char *) text, *p2 = buf;
! 194: while (p && *p) {
! 195: if (*p != '-') {
! 196: *p2 = *p;
! 197: p2++;
! 198: if (p2-buf >= sizeof(buf)) {
! 199: return -1;
! 200: }
! 201: }
! 202: p++;
! 203: }
! 204: text = buf;
! 205: }
! 206:
! 207:
! 208: tm.tm_isdst = -1;
! 209:
! 210: #define XMLRPC_IS_NUMBER(x) if (x < '0' || x > '9') return -1;
! 211:
! 212: n = 1000;
! 213: tm.tm_year = 0;
! 214: for(i = 0; i < 4; i++) {
! 215: XMLRPC_IS_NUMBER(text[i])
! 216: tm.tm_year += (text[i]-'0')*n;
! 217: n /= 10;
! 218: }
! 219: n = 10;
! 220: tm.tm_mon = 0;
! 221: for(i = 0; i < 2; i++) {
! 222: XMLRPC_IS_NUMBER(text[i])
! 223: tm.tm_mon += (text[i+4]-'0')*n;
! 224: n /= 10;
! 225: }
! 226: tm.tm_mon --;
! 227:
! 228: n = 10;
! 229: tm.tm_mday = 0;
! 230: for(i = 0; i < 2; i++) {
! 231: XMLRPC_IS_NUMBER(text[i])
! 232: tm.tm_mday += (text[i+6]-'0')*n;
! 233: n /= 10;
! 234: }
! 235:
! 236: n = 10;
! 237: tm.tm_hour = 0;
! 238: for(i = 0; i < 2; i++) {
! 239: XMLRPC_IS_NUMBER(text[i])
! 240: tm.tm_hour += (text[i+9]-'0')*n;
! 241: n /= 10;
! 242: }
! 243:
! 244: n = 10;
! 245: tm.tm_min = 0;
! 246: for(i = 0; i < 2; i++) {
! 247: XMLRPC_IS_NUMBER(text[i])
! 248: tm.tm_min += (text[i+12]-'0')*n;
! 249: n /= 10;
! 250: }
! 251:
! 252: n = 10;
! 253: tm.tm_sec = 0;
! 254: for(i = 0; i < 2; i++) {
! 255: XMLRPC_IS_NUMBER(text[i])
! 256: tm.tm_sec += (text[i+15]-'0')*n;
! 257: n /= 10;
! 258: }
! 259:
! 260: tm.tm_year -= 1900;
! 261:
! 262: *value = mkgmtime(&tm);
! 263:
! 264: return 0;
! 265:
! 266: }
! 267:
! 268: static int date_to_ISO8601 (time_t value, char *buf, int length) {
! 269: struct tm *tm, tmbuf;
! 270: tm = php_gmtime_r(&value, &tmbuf);
! 271: if (!tm) {
! 272: return 0;
! 273: }
! 274: #if 0 /* TODO: soap seems to favor this method. xmlrpc the latter. */
! 275: return strftime (buf, length, "%Y-%m-%dT%H:%M:%SZ", tm);
! 276: #else
! 277: return strftime(buf, length, "%Y%m%dT%H:%M:%SZ", tm);
! 278: #endif
! 279: }
! 280:
! 281: /*-*******************
! 282: * End Time Functions *
! 283: *********************/
! 284:
! 285:
! 286: /*-***************************
! 287: * Begin XMLRPC_REQUEST funcs *
! 288: *****************************/
! 289:
! 290: /****f* REQUEST/XMLRPC_RequestNew
! 291: * NAME
! 292: * XMLRPC_RequestNew
! 293: * SYNOPSIS
! 294: * XMLRPC_REQUEST XMLRPC_RequestNew()
! 295: * FUNCTION
! 296: * Creates a new XMLRPC_Request data struct
! 297: * INPUTS
! 298: * none
! 299: * SEE ALSO
! 300: * XMLRPC_RequestFree ()
! 301: * SOURCE
! 302: */
! 303: XMLRPC_REQUEST XMLRPC_RequestNew() {
! 304: XMLRPC_REQUEST xRequest = calloc(1, sizeof(STRUCT_XMLRPC_REQUEST));
! 305: if(xRequest) {
! 306: simplestring_init(&xRequest->methodName);
! 307: }
! 308: return xRequest;
! 309: }
! 310:
! 311: /*******/
! 312:
! 313: /****f* REQUEST/XMLRPC_RequestFree
! 314: * NAME
! 315: * XMLRPC_RequestFree
! 316: * SYNOPSIS
! 317: * void XMLRPC_RequestFree(XMLRPC_REQUEST request, int bFreeIO)
! 318: * FUNCTION
! 319: * Free XMLRPC Request and all sub-values
! 320: * INPUTS
! 321: * request -- previously allocated request struct
! 322: * bFreeIO -- 1 = also free request value data, if any, 0 = ignore.
! 323: * SEE ALSO
! 324: * XMLRPC_RequestNew ()
! 325: * XMLRPC_CleanupValue ()
! 326: * SOURCE
! 327: */
! 328: void XMLRPC_RequestFree(XMLRPC_REQUEST request, int bFreeIO) {
! 329: if(request) {
! 330: simplestring_free(&request->methodName);
! 331:
! 332: if(request->io && bFreeIO) {
! 333: XMLRPC_CleanupValue(request->io);
! 334: }
! 335: if(request->error) {
! 336: XMLRPC_CleanupValue(request->error);
! 337: }
! 338: my_free(request);
! 339: }
! 340: }
! 341:
! 342: /*******/
! 343:
! 344: /* Set Method Name to call */
! 345: /****f* REQUEST/XMLRPC_RequestSetMethodName
! 346: * NAME
! 347: * XMLRPC_RequestSetMethodName
! 348: * SYNOPSIS
! 349: * const char* XMLRPC_RequestSetMethodName(XMLRPC_REQUEST request, const char* methodName)
! 350: * FUNCTION
! 351: * Set name of method to call with this request.
! 352: * INPUTS
! 353: * request -- previously allocated request struct
! 354: * methodName -- name of method
! 355: * SEE ALSO
! 356: * XMLRPC_RequestNew ()
! 357: * XMLRPC_RequestGetMethodName ()
! 358: * XMLRPC_RequestFree ()
! 359: * SOURCE
! 360: */
! 361: const char* XMLRPC_RequestSetMethodName(XMLRPC_REQUEST request, const char* methodName) {
! 362: if(request) {
! 363: simplestring_clear(&request->methodName);
! 364: simplestring_add(&request->methodName, methodName);
! 365: return request->methodName.str;
! 366: }
! 367: return NULL;
! 368: }
! 369:
! 370: /*******/
! 371:
! 372: /****f* REQUEST/XMLRPC_RequestGetMethodName
! 373: * NAME
! 374: * XMLRPC_RequestGetMethodName
! 375: * SYNOPSIS
! 376: * const char* XMLRPC_RequestGetMethodName(XMLRPC_REQUEST request)
! 377: * FUNCTION
! 378: * Get name of method called by this request
! 379: * INPUTS
! 380: * request -- previously allocated request struct
! 381: * SEE ALSO
! 382: * XMLRPC_RequestNew ()
! 383: * XMLRPC_RequestSetMethodName ()
! 384: * XMLRPC_RequestFree ()
! 385: * SOURCE
! 386: */
! 387: const char* XMLRPC_RequestGetMethodName(XMLRPC_REQUEST request) {
! 388: return request ? request->methodName.str : NULL;
! 389: }
! 390:
! 391: /*******/
! 392:
! 393: /****f* REQUEST/XMLRPC_RequestSetRequestType
! 394: * NAME
! 395: * XMLRPC_RequestSetRequestType
! 396: * SYNOPSIS
! 397: * XMLRPC_REQUEST_TYPE XMLRPC_RequestSetRequestType(XMLRPC_REQUEST request, XMLRPC_REQUEST_TYPE type)
! 398: * FUNCTION
! 399: * A request struct may be allocated by a caller or by xmlrpc
! 400: * in response to a request. This allows setting the
! 401: * request type.
! 402: * INPUTS
! 403: * request -- previously allocated request struct
! 404: * type -- request type [xmlrpc_method_call | xmlrpc_method_response]
! 405: * SEE ALSO
! 406: * XMLRPC_RequestNew ()
! 407: * XMLRPC_RequestGetRequestType ()
! 408: * XMLRPC_RequestFree ()
! 409: * XMLRPC_REQUEST_TYPE
! 410: * SOURCE
! 411: */
! 412: XMLRPC_REQUEST_TYPE XMLRPC_RequestSetRequestType (XMLRPC_REQUEST request,
! 413: XMLRPC_REQUEST_TYPE type) {
! 414: if(request) {
! 415: request->request_type = type;
! 416: return request->request_type;
! 417: }
! 418: return xmlrpc_request_none;
! 419: }
! 420:
! 421: /*******/
! 422:
! 423: /****f* REQUEST/XMLRPC_RequestGetRequestType
! 424: * NAME
! 425: * XMLRPC_RequestGetRequestType
! 426: * SYNOPSIS
! 427: * XMLRPC_REQUEST_TYPE XMLRPC_RequestGetRequestType(XMLRPC_REQUEST request)
! 428: * FUNCTION
! 429: * A request struct may be allocated by a caller or by xmlrpc
! 430: * in response to a request. This allows setting the
! 431: * request type.
! 432: * INPUTS
! 433: * request -- previously allocated request struct
! 434: * RESULT
! 435: * type -- request type [xmlrpc_method_call | xmlrpc_method_response]
! 436: * SEE ALSO
! 437: * XMLRPC_RequestNew ()
! 438: * XMLRPC_RequestSetRequestType ()
! 439: * XMLRPC_RequestFree ()
! 440: * XMLRPC_REQUEST_TYPE
! 441: * SOURCE
! 442: */
! 443: XMLRPC_REQUEST_TYPE XMLRPC_RequestGetRequestType(XMLRPC_REQUEST request) {
! 444: return request ? request->request_type : xmlrpc_request_none;
! 445: }
! 446:
! 447: /*******/
! 448:
! 449:
! 450: /****f* REQUEST/XMLRPC_RequestSetData
! 451: * NAME
! 452: * XMLRPC_RequestSetData
! 453: * SYNOPSIS
! 454: * XMLRPC_VALUE XMLRPC_RequestSetData(XMLRPC_REQUEST request, XMLRPC_VALUE data)
! 455: * FUNCTION
! 456: * Associates a block of xmlrpc data with the request. The
! 457: * data is *not* copied. A pointer is kept. The caller
! 458: * should be careful not to doubly free the data value,
! 459: * which may optionally be free'd by XMLRPC_RequestFree().
! 460: * INPUTS
! 461: * request -- previously allocated request struct
! 462: * data -- previously allocated data struct
! 463: * RESULT
! 464: * XMLRPC_VALUE -- pointer to value stored, or NULL
! 465: * SEE ALSO
! 466: * XMLRPC_RequestNew ()
! 467: * XMLRPC_RequestGetData ()
! 468: * XMLRPC_RequestFree ()
! 469: * XMLRPC_REQUEST
! 470: * XMLRPC_VALUE
! 471: * SOURCE
! 472: */
! 473: XMLRPC_VALUE XMLRPC_RequestSetData(XMLRPC_REQUEST request, XMLRPC_VALUE data) {
! 474: if(request && data) {
! 475: if (request->io) {
! 476: XMLRPC_CleanupValue (request->io);
! 477: }
! 478: request->io = XMLRPC_CopyValue(data);
! 479: return request->io;
! 480: }
! 481: return NULL;
! 482: }
! 483:
! 484: /*******/
! 485:
! 486: /****f* REQUEST/XMLRPC_RequestGetData
! 487: * NAME
! 488: * XMLRPC_RequestGetData
! 489: * SYNOPSIS
! 490: * XMLRPC_VALUE XMLRPC_RequestGetData(XMLRPC_REQUEST request)
! 491: * FUNCTION
! 492: * Returns data associated with request, if any.
! 493: * INPUTS
! 494: * request -- previously allocated request struct
! 495: * RESULT
! 496: * XMLRPC_VALUE -- pointer to value stored, or NULL
! 497: * SEE ALSO
! 498: * XMLRPC_RequestNew ()
! 499: * XMLRPC_RequestSetData ()
! 500: * XMLRPC_RequestFree ()
! 501: * XMLRPC_REQUEST
! 502: * XMLRPC_VALUE
! 503: * SOURCE
! 504: */
! 505: XMLRPC_VALUE XMLRPC_RequestGetData(XMLRPC_REQUEST request) {
! 506: return request ? request->io : NULL;
! 507: }
! 508:
! 509: /*******/
! 510:
! 511: /****f* REQUEST/XMLRPC_RequestSetError
! 512: * NAME
! 513: * XMLRPC_RequestSetError
! 514: * SYNOPSIS
! 515: * XMLRPC_VALUE XMLRPC_RequestSetError(XMLRPC_REQUEST request, XMLRPC_VALUE error)
! 516: * FUNCTION
! 517: * Associates a block of xmlrpc data, representing an error
! 518: * condition, with the request.
! 519: * INPUTS
! 520: * request -- previously allocated request struct
! 521: * error -- previously allocated error code or struct
! 522: * RESULT
! 523: * XMLRPC_VALUE -- pointer to value stored, or NULL
! 524: * NOTES
! 525: * This is a private function for usage by internals only.
! 526: * SEE ALSO
! 527: * XMLRPC_RequestGetError ()
! 528: * SOURCE
! 529: */
! 530: XMLRPC_VALUE XMLRPC_RequestSetError (XMLRPC_REQUEST request, XMLRPC_VALUE error) {
! 531: if (request && error) {
! 532: if (request->error) {
! 533: XMLRPC_CleanupValue (request->error);
! 534: }
! 535: request->error = XMLRPC_CopyValue (error);
! 536: return request->error;
! 537: }
! 538: return NULL;
! 539: }
! 540:
! 541: /*******/
! 542:
! 543: /****f* REQUEST/XMLRPC_RequestGetError
! 544: * NAME
! 545: * XMLRPC_RequestGetError
! 546: * SYNOPSIS
! 547: * XMLRPC_VALUE XMLRPC_RequestGetError(XMLRPC_REQUEST request)
! 548: * FUNCTION
! 549: * Returns error data associated with request, if any.
! 550: * INPUTS
! 551: * request -- previously allocated request struct
! 552: * RESULT
! 553: * XMLRPC_VALUE -- pointer to error value stored, or NULL
! 554: * NOTES
! 555: * This is a private function for usage by internals only.
! 556: * SEE ALSO
! 557: * XMLRPC_RequestSetError ()
! 558: * XMLRPC_RequestFree ()
! 559: * SOURCE
! 560: */
! 561: XMLRPC_VALUE XMLRPC_RequestGetError (XMLRPC_REQUEST request) {
! 562: return request ? request->error : NULL;
! 563: }
! 564:
! 565: /*******/
! 566:
! 567:
! 568: /****f* REQUEST/XMLRPC_RequestSetOutputOptions
! 569: * NAME
! 570: * XMLRPC_RequestSetOutputOptions
! 571: * SYNOPSIS
! 572: * XMLRPC_REQUEST_OUTPUT_OPTIONS XMLRPC_RequestSetOutputOptions(XMLRPC_REQUEST request, XMLRPC_REQUEST_OUTPUT_OPTIONS output)
! 573: * FUNCTION
! 574: * Sets output options used for generating XML. The output struct
! 575: * is copied, and may be freed by the caller.
! 576: * INPUTS
! 577: * request -- previously allocated request struct
! 578: * output -- output options struct initialized by caller
! 579: * RESULT
! 580: * XMLRPC_REQUEST_OUTPUT_OPTIONS -- pointer to value stored, or NULL
! 581: * SEE ALSO
! 582: * XMLRPC_RequestNew ()
! 583: * XMLRPC_RequestGetOutputOptions ()
! 584: * XMLRPC_RequestFree ()
! 585: * XMLRPC_REQUEST
! 586: * XMLRPC_REQUEST_OUTPUT_OPTIONS
! 587: * SOURCE
! 588: */
! 589: XMLRPC_REQUEST_OUTPUT_OPTIONS XMLRPC_RequestSetOutputOptions(XMLRPC_REQUEST request, XMLRPC_REQUEST_OUTPUT_OPTIONS output) {
! 590: if(request && output) {
! 591: memcpy (&request->output, output,
! 592: sizeof (STRUCT_XMLRPC_REQUEST_OUTPUT_OPTIONS));
! 593: return &request->output;
! 594: }
! 595: return NULL;
! 596: }
! 597:
! 598: /*******/
! 599:
! 600:
! 601: /****f* REQUEST/XMLRPC_RequestGetOutputOptions
! 602: * NAME
! 603: * XMLRPC_RequestGetOutputOptions
! 604: * SYNOPSIS
! 605: * XMLRPC_REQUEST_OUTPUT_OPTIONS XMLRPC_RequestGetOutputOptions(XMLRPC_REQUEST request)
! 606: * FUNCTION
! 607: * Gets a pointer to output options used for generating XML.
! 608: * INPUTS
! 609: * request -- previously allocated request struct
! 610: * RESULT
! 611: * XMLRPC_REQUEST_OUTPUT_OPTIONS -- pointer to options stored, or NULL
! 612: * SEE ALSO
! 613: * XMLRPC_RequestNew ()
! 614: * XMLRPC_RequestSetOutputOptions ()
! 615: * XMLRPC_RequestFree ()
! 616: * XMLRPC_REQUEST
! 617: * XMLRPC_REQUEST_OUTPUT_OPTIONS
! 618: * SOURCE
! 619: */
! 620: XMLRPC_REQUEST_OUTPUT_OPTIONS XMLRPC_RequestGetOutputOptions(XMLRPC_REQUEST request) {
! 621: return request ? &request->output : NULL;
! 622: }
! 623:
! 624: /*******/
! 625:
! 626: /*-*************************
! 627: * End XMLRPC_REQUEST funcs *
! 628: ***************************/
! 629:
! 630:
! 631: /*-***************************
! 632: * Begin Serializiation funcs *
! 633: *****************************/
! 634:
! 635: /****f* SERIALIZE/XMLRPC_VALUE_ToXML
! 636: * NAME
! 637: * XMLRPC_VALUE_ToXML
! 638: * SYNOPSIS
! 639: * char* XMLRPC_VALUE_ToXML(XMLRPC_VALUE val)
! 640: * FUNCTION
! 641: * encode XMLRPC_VALUE into XML buffer. Note that the generated
! 642: * buffer will not contain a methodCall.
! 643: * INPUTS
! 644: * val -- previously allocated XMLRPC_VALUE
! 645: * buf_len -- length of returned buffer, if not null
! 646: * RESULT
! 647: * char* -- newly allocated buffer containing XML.
! 648: * It is the caller's responsibility to free it.
! 649: * SEE ALSO
! 650: * XMLRPC_REQUEST_ToXML ()
! 651: * XMLRPC_VALUE_FromXML ()
! 652: * XMLRPC_Free ()
! 653: * XMLRPC_VALUE
! 654: * SOURCE
! 655: */
! 656: char* XMLRPC_VALUE_ToXML(XMLRPC_VALUE val, int* buf_len) {
! 657: xml_element *root_elem = XMLRPC_VALUE_to_xml_element(val);
! 658: char* pRet = NULL;
! 659:
! 660: if(root_elem) {
! 661: pRet = xml_elem_serialize_to_string(root_elem, NULL, buf_len);
! 662: xml_elem_free(root_elem);
! 663: }
! 664: return pRet;
! 665: }
! 666:
! 667: /*******/
! 668:
! 669: /****f* SERIALIZE/XMLRPC_REQUEST_ToXML
! 670: * NAME
! 671: * XMLRPC_REQUEST_ToXML
! 672: * SYNOPSIS
! 673: * char* XMLRPC_REQUEST_ToXML(XMLRPC_REQUEST request)
! 674: * FUNCTION
! 675: * encode XMLRPC_REQUEST into XML buffer
! 676: * INPUTS
! 677: * request -- previously allocated XMLRPC_REQUEST
! 678: * buf_len -- size of returned buf, if not null
! 679: * RESULT
! 680: * char* -- newly allocated buffer containing XML.
! 681: * It is the caller's responsibility to free it.
! 682: * SEE ALSO
! 683: * XMLRPC_REQUEST_ToXML ()
! 684: * XMLRPC_REQUEST_FromXML ()
! 685: * XMLRPC_Free ()
! 686: * XMLRPC_VALUE_ToXML ()
! 687: * XMLRPC_REQUEST
! 688: * SOURCE
! 689: */
! 690: char* XMLRPC_REQUEST_ToXML(XMLRPC_REQUEST request, int* buf_len) {
! 691: char* pRet = NULL;
! 692: if (request) {
! 693: xml_element *root_elem = NULL;
! 694: if (request->output.version == xmlrpc_version_simple) {
! 695: root_elem = DANDARPC_REQUEST_to_xml_element (request);
! 696: }
! 697: else if (request->output.version == xmlrpc_version_1_0 ||
! 698: request->output.version == xmlrpc_version_none) {
! 699: root_elem = XMLRPC_REQUEST_to_xml_element (request);
! 700: }
! 701: else if (request->output.version == xmlrpc_version_soap_1_1) {
! 702: root_elem = SOAP_REQUEST_to_xml_element (request);
! 703: }
! 704:
! 705: if(root_elem) {
! 706: pRet =
! 707: xml_elem_serialize_to_string (root_elem,
! 708: &request->output.xml_elem_opts,
! 709: buf_len);
! 710: xml_elem_free(root_elem);
! 711: }
! 712: }
! 713: return pRet;
! 714: }
! 715:
! 716: /*******/
! 717:
! 718: /****f* SERIALIZE/XMLRPC_VALUE_FromXML
! 719: * NAME
! 720: * XMLRPC_VALUE_FromXML
! 721: * SYNOPSIS
! 722: * XMLRPC_VALUE XMLRPC_VALUE_FromXML(const char* in_buf, int le
! 723: * FUNCTION
! 724: * Retrieve XMLRPC_VALUE from XML buffer. Note that this will
! 725: * ignore any methodCall. See XMLRPC_REQUEST_FromXML
! 726: * INPUTS
! 727: * in_buf -- character buffer containing XML
! 728: * len -- length of buffer
! 729: * RESULT
! 730: * XMLRPC_VALUE -- newly allocated data, or NULL if error. Should
! 731: * be free'd by caller.
! 732: * SEE ALSO
! 733: * XMLRPC_VALUE_ToXML ()
! 734: * XMLRPC_REQUEST_FromXML ()
! 735: * XMLRPC_VALUE
! 736: * SOURCE
! 737: */
! 738: XMLRPC_VALUE XMLRPC_VALUE_FromXML (const char *in_buf, int len, XMLRPC_REQUEST_INPUT_OPTIONS in_options) {
! 739: XMLRPC_VALUE xResponse = NULL;
! 740: XMLRPC_REQUEST req = XMLRPC_REQUEST_FromXML(in_buf, len, in_options);
! 741:
! 742: if(req) {
! 743: xResponse = req->io;
! 744: XMLRPC_RequestFree(req, 0);
! 745: }
! 746: return xResponse;
! 747: }
! 748:
! 749: /*******/
! 750:
! 751: /* map parser errors to standard xml-rpc errors */
! 752: static XMLRPC_VALUE map_expat_errors(XML_ELEM_ERROR error) {
! 753: XMLRPC_VALUE xReturn = NULL;
! 754: if(error) {
! 755: XMLRPC_ERROR_CODE code;
! 756: char buf[1024];
! 757: snprintf(buf, sizeof(buf),
! 758: "error occurred at line %ld, column %ld, byte index %ld",
! 759: error->line, error->column, error->byte_index);
! 760:
! 761: /* expat specific errors */
! 762: switch(error->parser_code) {
! 763: case XML_ERROR_UNKNOWN_ENCODING:
! 764: code = xmlrpc_error_parse_unknown_encoding;
! 765: break;
! 766: case XML_ERROR_INCORRECT_ENCODING:
! 767: code = xmlrpc_error_parse_bad_encoding;
! 768: break;
! 769: default:
! 770: code = xmlrpc_error_parse_xml_syntax;
! 771: break;
! 772: }
! 773: xReturn = XMLRPC_UtilityCreateFault(code, buf);
! 774: }
! 775: return xReturn;
! 776: }
! 777:
! 778: /****f* SERIALIZE/XMLRPC_REQUEST_FromXML
! 779: * NAME
! 780: * XMLRPC_REQUEST_FromXML
! 781: * SYNOPSIS
! 782: * XMLRPC_REQUEST XMLRPC_REQUEST_FromXML(const char* in_buf, int le
! 783: * FUNCTION
! 784: * Retrieve XMLRPC_REQUEST from XML buffer
! 785: * INPUTS
! 786: * in_buf -- character buffer containing XML
! 787: * len -- length of buffer
! 788: * RESULT
! 789: * XMLRPC_REQUEST -- newly allocated data, or NULL if error. Should
! 790: * be free'd by caller.
! 791: * SEE ALSO
! 792: * XMLRPC_REQUEST_ToXML ()
! 793: * XMLRPC_VALUE_FromXML ()
! 794: * XMLRPC_REQUEST
! 795: * SOURCE
! 796: */
! 797: XMLRPC_REQUEST XMLRPC_REQUEST_FromXML (const char *in_buf, int len,
! 798: XMLRPC_REQUEST_INPUT_OPTIONS in_options) {
! 799: XMLRPC_REQUEST request = XMLRPC_RequestNew();
! 800: STRUCT_XML_ELEM_ERROR error = {0};
! 801:
! 802: if(request) {
! 803: xml_element *root_elem =
! 804: xml_elem_parse_buf (in_buf, len,
! 805: (in_options ? &in_options->xml_elem_opts : NULL),
! 806: &error);
! 807:
! 808: if(root_elem) {
! 809: if(!strcmp(root_elem->name, "simpleRPC")) {
! 810: request->output.version = xmlrpc_version_simple;
! 811: xml_element_to_DANDARPC_REQUEST(request, root_elem);
! 812: }
! 813: else if (!strcmp (root_elem->name, "SOAP-ENV:Envelope")) {
! 814: request->output.version = xmlrpc_version_soap_1_1;
! 815: xml_element_to_SOAP_REQUEST (request, root_elem);
! 816: }
! 817: else {
! 818: request->output.version = xmlrpc_version_1_0;
! 819: xml_element_to_XMLRPC_REQUEST(request, root_elem);
! 820: }
! 821: xml_elem_free(root_elem);
! 822: }
! 823: else {
! 824: if(error.parser_error) {
! 825: XMLRPC_RequestSetError (request, map_expat_errors (&error));
! 826: }
! 827: }
! 828: }
! 829:
! 830: return request;
! 831: }
! 832:
! 833: /*******/
! 834:
! 835: /*-************************
! 836: * End Serialization Funcs *
! 837: **************************/
! 838:
! 839:
! 840:
! 841: /****f* VALUE/XMLRPC_CreateValueEmpty
! 842: * NAME
! 843: * XMLRPC_CreateValueEmpty
! 844: * SYNOPSIS
! 845: * XMLRPC_VALUE XMLRPC_CreateValueEmpty ()
! 846: * FUNCTION
! 847: * Create an XML value to be used/modified elsewhere.
! 848: * INPUTS
! 849: * RESULT
! 850: * XMLRPC_VALUE. The new value, or NULL on failure.
! 851: * SEE ALSO
! 852: * XMLRPC_CleanupValue ()
! 853: * XMLRPC_VALUE
! 854: * SOURCE
! 855: */
! 856: XMLRPC_VALUE XMLRPC_CreateValueEmpty() {
! 857: XMLRPC_VALUE v = calloc(1, sizeof(STRUCT_XMLRPC_VALUE));
! 858: if(v) {
! 859: #ifdef XMLRPC_DEBUG_REFCOUNT
! 860: printf ("calloc'd 0x%x\n", v);
! 861: #endif
! 862: v->type = xmlrpc_empty;
! 863: simplestring_init(&v->id);
! 864: simplestring_init(&v->str);
! 865: }
! 866: return v;
! 867: }
! 868:
! 869: /*******/
! 870:
! 871: /****f* VALUE/XMLRPC_SetValueID_Case
! 872: * NAME
! 873: * XMLRPC_SetValueID_Case
! 874: * SYNOPSIS
! 875: * const char *XMLRPC_SetValueID_Case(XMLRPC_VALUE value, const char* id, int len, XMLRPC_CASE id_case)
! 876: * FUNCTION
! 877: * Assign an ID (key) to an XMLRPC value.
! 878: * INPUTS
! 879: * value The xml value who's ID we will set.
! 880: * id The desired new id.
! 881: * len length of id string if known, or 0 if unknown.
! 882: * id_case one of XMLRPC_CASE
! 883: * RESULT
! 884: * const char* pointer to the newly allocated id string, or NULL
! 885: * SEE ALSO
! 886: * XMLRPC_SetValueID ()
! 887: * XMLRPC_GetValueID ()
! 888: * XMLRPC_VALUE
! 889: * XMLRPC_CASE
! 890: * SOURCE
! 891: */
! 892: const char *XMLRPC_SetValueID_Case(XMLRPC_VALUE value, const char* id, int len, XMLRPC_CASE id_case) {
! 893: const char* pRetval = NULL;
! 894: if(value) {
! 895: if(id) {
! 896: simplestring_clear(&value->id);
! 897: (len > 0) ? simplestring_addn(&value->id, id, len) :
! 898: simplestring_add(&value->id, id);
! 899:
! 900: /* upper or lower case string in place if required. could be a seperate func. */
! 901: if(id_case == xmlrpc_case_lower || id_case == xmlrpc_case_upper) {
! 902: int i;
! 903: for(i = 0; i < value->id.len; i++) {
! 904: value->id.str[i] =
! 905: (id_case ==
! 906: xmlrpc_case_lower) ? tolower (value->id.
! 907: str[i]) : toupper (value->
! 908: id.
! 909: str[i]);
! 910: }
! 911: }
! 912:
! 913: pRetval = value->id.str;
! 914:
! 915: #ifdef XMLRPC_DEBUG_REFCOUNT
! 916: printf("set value id: %s\n", pRetval);
! 917: #endif
! 918: }
! 919: }
! 920:
! 921: return pRetval;
! 922: }
! 923:
! 924: /*******/
! 925:
! 926:
! 927: /****f* VALUE/XMLRPC_SetValueString
! 928: * NAME
! 929: * XMLRPC_SetValueString
! 930: * SYNOPSIS
! 931: * const char *XMLRPC_SetValueString(XMLRPC_VALUE value, const char* val, int len)
! 932: * FUNCTION
! 933: * Assign a string value to an XMLRPC_VALUE, and set it to type xmlrpc_string
! 934: * INPUTS
! 935: * value The xml value who's ID we will set.
! 936: * val The desired new string val.
! 937: * len length of val string if known, or 0 if unknown.
! 938: * RESULT
! 939: * const char* pointer to the newly allocated value string, or NULL
! 940: * SEE ALSO
! 941: * XMLRPC_GetValueString ()
! 942: * XMLRPC_VALUE
! 943: * XMLRPC_VALUE_TYPE
! 944: * SOURCE
! 945: */
! 946: const char *XMLRPC_SetValueString(XMLRPC_VALUE value, const char* val, int len) {
! 947: char *pRetval = NULL;
! 948: if(value && val) {
! 949: simplestring_clear(&value->str);
! 950: (len > 0) ? simplestring_addn(&value->str, val, len) :
! 951: simplestring_add(&value->str, val);
! 952: value->type = xmlrpc_string;
! 953: pRetval = (char *)value->str.str;
! 954: }
! 955:
! 956: return pRetval;
! 957: }
! 958:
! 959: /*******/
! 960:
! 961: /****f* VALUE/XMLRPC_SetValueInt
! 962: * NAME
! 963: * XMLRPC_SetValueInt
! 964: * SYNOPSIS
! 965: * void XMLRPC_SetValueInt(XMLRPC_VALUE value, int val)
! 966: * FUNCTION
! 967: * Assign an int value to an XMLRPC_VALUE, and set it to type xmlrpc_int
! 968: * INPUTS
! 969: * value The xml value who's ID we will set.
! 970: * val The desired new integer value
! 971: * RESULT
! 972: * SEE ALSO
! 973: * XMLRPC_GetValueInt ()
! 974: * XMLRPC_VALUE
! 975: * XMLRPC_VALUE_TYPE
! 976: * SOURCE
! 977: */
! 978: void XMLRPC_SetValueInt(XMLRPC_VALUE value, int val) {
! 979: if(value) {
! 980: value->type = xmlrpc_int;
! 981: value->i = val;
! 982: }
! 983: }
! 984:
! 985: /*******/
! 986:
! 987: /****f* VALUE/XMLRPC_SetValueBoolean
! 988: * NAME
! 989: * XMLRPC_SetValueBoolean
! 990: * SYNOPSIS
! 991: * void XMLRPC_SetValueBoolean(XMLRPC_VALUE value, int val)
! 992: * FUNCTION
! 993: * Assign a boolean value to an XMLRPC_VALUE, and set it to type xmlrpc_boolean
! 994: * INPUTS
! 995: * value The xml value who's value we will set.
! 996: * val The desired new boolean value. [0 | 1]
! 997: * RESULT
! 998: * SEE ALSO
! 999: * XMLRPC_GetValueBoolean ()
! 1000: * XMLRPC_VALUE
! 1001: * XMLRPC_VALUE_TYPE
! 1002: * SOURCE
! 1003: */
! 1004: void XMLRPC_SetValueBoolean(XMLRPC_VALUE value, int val) {
! 1005: if(value) {
! 1006: value->type = xmlrpc_boolean;
! 1007: value->i = val ? 1 : 0;
! 1008: }
! 1009: }
! 1010:
! 1011: /*******/
! 1012:
! 1013:
! 1014: /****f* VECTOR/XMLRPC_SetIsVector
! 1015: * NAME
! 1016: * XMLRPC_SetIsVector
! 1017: * SYNOPSIS
! 1018: * int XMLRPC_SetIsVector(XMLRPC_VALUE value, XMLRPC_VECTOR_TYPE type)
! 1019: * FUNCTION
! 1020: * Set the XMLRPC_VALUE to be a vector (list) type. The vector may be one of
! 1021: * [xmlrpc_array | xmlrpc_struct | xmlrpc_mixed]. An array has only index values.
! 1022: * A struct has key/val pairs. Mixed allows both index and key/val combinations.
! 1023: * INPUTS
! 1024: * value The xml value who's vector type we will set
! 1025: * type New type of vector as enumerated by XMLRPC_VECTOR_TYPE
! 1026: * RESULT
! 1027: * int 1 if successful, 0 otherwise
! 1028: * SEE ALSO
! 1029: * XMLRPC_GetValueType ()
! 1030: * XMLRPC_GetVectorType ()
! 1031: * XMLRPC_VALUE
! 1032: * XMLRPC_VECTOR_TYPE
! 1033: * XMLRPC_VALUE_TYPE
! 1034: * SOURCE
! 1035: */
! 1036: int XMLRPC_SetIsVector(XMLRPC_VALUE value, XMLRPC_VECTOR_TYPE type) {
! 1037: int bSuccess = 0;
! 1038:
! 1039: if (value) {
! 1040: /* we can change the type so long as nothing is currently stored. */
! 1041: if(value->type == xmlrpc_vector) {
! 1042: if(value->v) {
! 1043: if(!Q_Size(value->v->q)) {
! 1044: value->v->type = type;
! 1045: }
! 1046: }
! 1047: }
! 1048: else {
! 1049: value->v = calloc(1, sizeof(STRUCT_XMLRPC_VECTOR));
! 1050: if(value->v) {
! 1051: value->v->q = (queue*)malloc(sizeof(queue));
! 1052: if(value->v->q) {
! 1053: Q_Init(value->v->q);
! 1054: value->v->type = type;
! 1055: value->type = xmlrpc_vector;
! 1056: bSuccess = 1;
! 1057: }
! 1058: }
! 1059: }
! 1060: }
! 1061:
! 1062: return bSuccess;
! 1063: }
! 1064:
! 1065: /*******/
! 1066:
! 1067: /****f* VECTOR/XMLRPC_CreateVector
! 1068: * NAME
! 1069: * XMLRPC_CreateVector
! 1070: * SYNOPSIS
! 1071: * XMLRPC_VALUE XMLRPC_CreateVector(const char* id, XMLRPC_VECTOR_TYPE type)
! 1072: * FUNCTION
! 1073: * Create a new vector and optionally set an id.
! 1074: * INPUTS
! 1075: * id The id of the vector, or NULL
! 1076: * type New type of vector as enumerated by XMLRPC_VECTOR_TYPE
! 1077: * RESULT
! 1078: * XMLRPC_VALUE The new vector, or NULL on failure.
! 1079: * SEE ALSO
! 1080: * XMLRPC_CreateValueEmpty ()
! 1081: * XMLRPC_SetIsVector ()
! 1082: * XMLRPC_GetValueType ()
! 1083: * XMLRPC_GetVectorType ()
! 1084: * XMLRPC_VALUE
! 1085: * XMLRPC_VECTOR_TYPE
! 1086: * XMLRPC_VALUE_TYPE
! 1087: * SOURCE
! 1088: */
! 1089: XMLRPC_VALUE XMLRPC_CreateVector(const char* id, XMLRPC_VECTOR_TYPE type) {
! 1090: XMLRPC_VALUE val = NULL;
! 1091:
! 1092: val = XMLRPC_CreateValueEmpty();
! 1093: if(val) {
! 1094: if(XMLRPC_SetIsVector(val, type)) {
! 1095: if(id) {
! 1096: const char *pSVI = NULL;
! 1097:
! 1098: pSVI = XMLRPC_SetValueID(val, id, 0);
! 1099: if(NULL == pSVI) {
! 1100: val = NULL;
! 1101: }
! 1102: }
! 1103: }
! 1104: else {
! 1105: val = NULL;
! 1106: }
! 1107: }
! 1108: return val;
! 1109: }
! 1110:
! 1111: /*******/
! 1112:
! 1113:
! 1114: /* Not yet implemented.
! 1115: *
! 1116: * This should use a hash to determine if a given target id has already
! 1117: * been appended.
! 1118: *
! 1119: * Alternately, it could walk the entire vector, but that could be quite
! 1120: * slow for very large lists.
! 1121: */
! 1122: static int isDuplicateEntry(XMLRPC_VALUE target, XMLRPC_VALUE source) {
! 1123: return 0;
! 1124: }
! 1125:
! 1126: /****f* VECTOR/XMLRPC_AddValueToVector
! 1127: * NAME
! 1128: * XMLRPC_AddValueToVector
! 1129: * SYNOPSIS
! 1130: * int XMLRPC_AddValueToVector(XMLRPC_VALUE target, XMLRPC_VALUE source)
! 1131: * FUNCTION
! 1132: * Add (append) an existing XMLRPC_VALUE to a vector.
! 1133: * INPUTS
! 1134: * target The target vector
! 1135: * source The source value to append
! 1136: * RESULT
! 1137: * int 1 if successful, else 0
! 1138: * SEE ALSO
! 1139: * XMLRPC_AddValuesToVector ()
! 1140: * XMLRPC_VectorGetValueWithID_Case ()
! 1141: * XMLRPC_VALUE
! 1142: * NOTES
! 1143: * The function will fail and return 0 if an attempt is made to add
! 1144: * a value with an ID into a vector of type xmlrpc_vector_array. Such
! 1145: * values can only be added to xmlrpc_vector_struct.
! 1146: * SOURCE
! 1147: */
! 1148: int XMLRPC_AddValueToVector(XMLRPC_VALUE target, XMLRPC_VALUE source) {
! 1149: if(target && source) {
! 1150: if(target->type == xmlrpc_vector && target->v &&
! 1151: target->v->q && target->v->type != xmlrpc_vector_none) {
! 1152:
! 1153: /* guard against putting value of unknown type into vector */
! 1154: switch(source->type) {
! 1155: case xmlrpc_empty:
! 1156: case xmlrpc_base64:
! 1157: case xmlrpc_boolean:
! 1158: case xmlrpc_datetime:
! 1159: case xmlrpc_double:
! 1160: case xmlrpc_int:
! 1161: case xmlrpc_string:
! 1162: case xmlrpc_vector:
! 1163: /* Guard against putting a key/val pair into an array vector */
! 1164: if( !(source->id.len && target->v->type == xmlrpc_vector_array) ) {
! 1165: if (isDuplicateEntry (target, source)
! 1166: || Q_PushTail (target->v->q, XMLRPC_CopyValue (source))) {
! 1167: return 1;
! 1168: }
! 1169: }
! 1170: else {
! 1171: /* fprintf (stderr,
! 1172: "xmlrpc: attempted to add key/val pair to vector of type array\n"); */
! 1173: }
! 1174: break;
! 1175: default:
! 1176: /* fprintf (stderr,
! 1177: "xmlrpc: attempted to add value of unknown type to vector\n"); */
! 1178: break;
! 1179: }
! 1180: }
! 1181: }
! 1182: return 0;
! 1183: }
! 1184:
! 1185: /*******/
! 1186:
! 1187:
! 1188: /****f* VECTOR/XMLRPC_AddValuesToVector
! 1189: * NAME
! 1190: * XMLRPC_AddValuesToVector
! 1191: * SYNOPSIS
! 1192: * XMLRPC_AddValuesToVector ( target, val1, val2, val3, val(n), 0 )
! 1193: * XMLRPC_AddValuesToVector( XMLRPC_VALUE, ... )
! 1194: * FUNCTION
! 1195: * Add (append) a series of existing XMLRPC_VALUE to a vector.
! 1196: * INPUTS
! 1197: * target The target vector
! 1198: * ... The source value(s) to append. The last item *must* be 0.
! 1199: * RESULT
! 1200: * int 1 if successful, else 0
! 1201: * SEE ALSO
! 1202: * XMLRPC_AddValuesToVector ()
! 1203: * XMLRPC_VectorGetValueWithID_Case ()
! 1204: * XMLRPC_VALUE
! 1205: * NOTES
! 1206: * This function may actually return failure after it has already modified
! 1207: * or added items to target. You can not trust the state of target
! 1208: * if this function returns failure.
! 1209: * SOURCE
! 1210: */
! 1211: int XMLRPC_AddValuesToVector(XMLRPC_VALUE target, ...) {
! 1212: int iRetval = 0;
! 1213:
! 1214: if(target) {
! 1215: if(target->type == xmlrpc_vector) {
! 1216: XMLRPC_VALUE v = NULL;
! 1217: va_list vl;
! 1218:
! 1219: va_start(vl, target);
! 1220:
! 1221: do {
! 1222: v = va_arg(vl, XMLRPC_VALUE);
! 1223: if(v) {
! 1224: if(!XMLRPC_AddValueToVector(target, v)) {
! 1225: iRetval = 0;
! 1226: break;
! 1227: }
! 1228: }
! 1229: }
! 1230: while (v);
! 1231:
! 1232: va_end(vl);
! 1233:
! 1234: if(NULL == v) {
! 1235: iRetval = 1;
! 1236: }
! 1237: }
! 1238: }
! 1239: return iRetval;
! 1240: }
! 1241:
! 1242: /*******/
! 1243:
! 1244:
! 1245: /****f* VECTOR/XMLRPC_VectorGetValueWithID_Case
! 1246: * NAME
! 1247: * XMLRPC_VectorGetValueWithID_Case
! 1248: * SYNOPSIS
! 1249: * XMLRPC_VALUE XMLRPC_VectorGetValueWithID_Case(XMLRPC_VALUE vector, const char* id, XMLRPC_CASE_COMPARISON id_case)
! 1250: * FUNCTION
! 1251: * Get value from vector matching id (key)
! 1252: * INPUTS
! 1253: * vector The source vector
! 1254: * id The key to find
! 1255: * id_case Rule for how to match key
! 1256: * RESULT
! 1257: * int 1 if successful, else 0
! 1258: * SEE ALSO
! 1259: * XMLRPC_SetValueID_Case ()
! 1260: * XMLRPC_VALUE
! 1261: * XMLRPC_CASE_COMPARISON
! 1262: * SOURCE
! 1263: */
! 1264: XMLRPC_VALUE XMLRPC_VectorGetValueWithID_Case (XMLRPC_VALUE vector, const char *id,
! 1265: XMLRPC_CASE_COMPARISON id_case) {
! 1266: if(vector && vector->v && vector->v->q) {
! 1267: q_iter qi = Q_Iter_Head_F(vector->v->q);
! 1268:
! 1269: while(qi) {
! 1270: XMLRPC_VALUE xIter = Q_Iter_Get_F(qi);
! 1271: if(xIter && xIter->id.str) {
! 1272: if(id_case == xmlrpc_case_sensitive) {
! 1273: if(!strcmp(xIter->id.str, id)) {
! 1274: return xIter;
! 1275: }
! 1276: }
! 1277: else if(id_case == xmlrpc_case_insensitive) {
! 1278: if(!strcasecmp(xIter->id.str, id)) {
! 1279: return xIter;
! 1280: }
! 1281: }
! 1282: }
! 1283: qi = Q_Iter_Next_F(qi);
! 1284: }
! 1285: }
! 1286: return NULL;
! 1287: }
! 1288:
! 1289: /*******/
! 1290:
! 1291:
! 1292: int XMLRPC_VectorRemoveValue(XMLRPC_VALUE vector, XMLRPC_VALUE value) {
! 1293: if(vector && vector->v && vector->v->q && value) {
! 1294: q_iter qi = Q_Iter_Head_F(vector->v->q);
! 1295:
! 1296: while(qi) {
! 1297: XMLRPC_VALUE xIter = Q_Iter_Get_F(qi);
! 1298: if(xIter == value) {
! 1299: XMLRPC_CleanupValue(xIter);
! 1300: Q_Iter_Del(vector->v->q, qi);
! 1301: return 1;
! 1302: }
! 1303: qi = Q_Iter_Next_F(qi);
! 1304: }
! 1305: }
! 1306: return 0;
! 1307: }
! 1308:
! 1309:
! 1310: /****f* VALUE/XMLRPC_CreateValueString
! 1311: * NAME
! 1312: * XMLRPC_CreateValueString
! 1313: * SYNOPSIS
! 1314: * XMLRPC_VALUE XMLRPC_CreateValueString(const char* id, const char* val, int len)
! 1315: * FUNCTION
! 1316: * Create an XMLRPC_VALUE, and assign a string to it
! 1317: * INPUTS
! 1318: * id The id of the value, or NULL
! 1319: * val The desired new string val.
! 1320: * len length of val string if known, or 0 if unknown.
! 1321: * RESULT
! 1322: * newly allocated XMLRPC_VALUE, or NULL
! 1323: * SEE ALSO
! 1324: * XMLRPC_GetValueString ()
! 1325: * XMLRPC_CreateValueEmpty ()
! 1326: * XMLRPC_VALUE
! 1327: * XMLRPC_VALUE_TYPE
! 1328: * SOURCE
! 1329: */
! 1330: XMLRPC_VALUE XMLRPC_CreateValueString(const char* id, const char* val, int len) {
! 1331: XMLRPC_VALUE value = NULL;
! 1332: if(val) {
! 1333: value = XMLRPC_CreateValueEmpty();
! 1334: if(value) {
! 1335: XMLRPC_SetValueString(value, val, len);
! 1336: if(id) {
! 1337: XMLRPC_SetValueID(value, id, 0);
! 1338: }
! 1339: }
! 1340: }
! 1341: return value;
! 1342: }
! 1343:
! 1344: /*******/
! 1345:
! 1346: /****f* VALUE/XMLRPC_CreateValueInt
! 1347: * NAME
! 1348: * XMLRPC_CreateValueInt
! 1349: * SYNOPSIS
! 1350: * XMLRPC_VALUE XMLRPC_CreateValueInt(const char* id, int i)
! 1351: * FUNCTION
! 1352: * Create an XMLRPC_VALUE, and assign an int to it
! 1353: * INPUTS
! 1354: * id The id of the value, or NULL
! 1355: * i The desired new int val.
! 1356: * RESULT
! 1357: * newly allocated XMLRPC_VALUE, or NULL
! 1358: * SEE ALSO
! 1359: * XMLRPC_GetValueInt ()
! 1360: * XMLRPC_CreateValueEmpty ()
! 1361: * XMLRPC_VALUE
! 1362: * XMLRPC_VALUE_TYPE
! 1363: * SOURCE
! 1364: */
! 1365: XMLRPC_VALUE XMLRPC_CreateValueInt(const char* id, int i) {
! 1366: XMLRPC_VALUE val = XMLRPC_CreateValueEmpty();
! 1367: if(val) {
! 1368: XMLRPC_SetValueInt(val, i);
! 1369: if(id) {
! 1370: XMLRPC_SetValueID(val, id, 0);
! 1371: }
! 1372: }
! 1373: return val;
! 1374: }
! 1375:
! 1376: /*******/
! 1377:
! 1378: /****f* VALUE/XMLRPC_CreateValueBoolean
! 1379: * NAME
! 1380: * XMLRPC_CreateValueBoolean
! 1381: * SYNOPSIS
! 1382: * XMLRPC_VALUE XMLRPC_CreateValueBoolean(const char* id, int i)
! 1383: * FUNCTION
! 1384: * Create an XMLRPC_VALUE, and assign an int to it
! 1385: * INPUTS
! 1386: * id The id of the value, or NULL
! 1387: * i The desired new int val.
! 1388: * RESULT
! 1389: * newly allocated XMLRPC_VALUE, or NULL
! 1390: * SEE ALSO
! 1391: * XMLRPC_GetValueBoolean ()
! 1392: * XMLRPC_CreateValueEmpty ()
! 1393: * XMLRPC_VALUE
! 1394: * XMLRPC_VALUE_TYPE
! 1395: * SOURCE
! 1396: */
! 1397: XMLRPC_VALUE XMLRPC_CreateValueBoolean(const char* id, int i) {
! 1398: XMLRPC_VALUE val = XMLRPC_CreateValueEmpty();
! 1399: if(val) {
! 1400: XMLRPC_SetValueBoolean(val, i);
! 1401: if(id) {
! 1402: XMLRPC_SetValueID(val, id, 0);
! 1403: }
! 1404: }
! 1405: return val;
! 1406: }
! 1407:
! 1408: /*******/
! 1409:
! 1410:
! 1411: /****f* VALUE/XMLRPC_CleanupValue
! 1412: * NAME
! 1413: * XMLRPC_CleanupValue
! 1414: * SYNOPSIS
! 1415: * void XMLRPC_CleanupValue(XMLRPC_VALUE value)
! 1416: * FUNCTION
! 1417: * Frees all memory allocated for an XMLRPC_VALUE and any of its children (if a vector)
! 1418: * INPUTS
! 1419: * value The id of the value to be cleaned up.
! 1420: * RESULT
! 1421: * void
! 1422: * NOTES
! 1423: * Normally this function will be called for the topmost vector, thus free-ing
! 1424: * all children. If a child of a vector is free'd first, results are undefined.
! 1425: * Failure to call this function *will* cause memory leaks.
! 1426: *
! 1427: * Also, this function is implemented using reference counting. Thus a value
! 1428: * may be added and freed from multiple parents so long as a reference is added
! 1429: * first using XMLRPC_CopyValue()
! 1430: * SEE ALSO
! 1431: * XMLRPC_RequestFree ()
! 1432: * XMLRPC_CreateValueEmpty ()
! 1433: * XMLRPC_CopyValue()
! 1434: * XMLRPC_VALUE
! 1435: * SOURCE
! 1436: */
! 1437: void XMLRPC_CleanupValue(XMLRPC_VALUE value) {
! 1438: if(value) {
! 1439: if(value->iRefCount > 0) {
! 1440: value->iRefCount --;
! 1441: }
! 1442:
! 1443: #ifdef XMLRPC_DEBUG_REFCOUNT
! 1444: if(value->id.str) {
! 1445: printf ("decremented refcount of %s, now %i\n", value->id.str,
! 1446: value->iRefCount);
! 1447: }
! 1448: else {
! 1449: printf ("decremented refcount of 0x%x, now %i\n", value,
! 1450: value->iRefCount);
! 1451: }
! 1452: #endif
! 1453:
! 1454: if(value->type == xmlrpc_vector) {
! 1455: if(value->v) {
! 1456: if(value->iRefCount == 0) {
! 1457: XMLRPC_VALUE cur = (XMLRPC_VALUE)Q_Head(value->v->q);
! 1458: while( cur ) {
! 1459: XMLRPC_CleanupValue(cur);
! 1460:
! 1461: /* Make sure some idiot didn't include a vector as a child of itself
! 1462: * and thus it would have already free'd these.
! 1463: */
! 1464: if(value->v && value->v->q) {
! 1465: cur = Q_Next(value->v->q);
! 1466: }
! 1467: else {
! 1468: break;
! 1469: }
! 1470: }
! 1471:
! 1472: Q_Destroy(value->v->q);
! 1473: my_free(value->v->q);
! 1474: my_free(value->v);
! 1475: }
! 1476: }
! 1477: }
! 1478:
! 1479:
! 1480: if(value->iRefCount == 0) {
! 1481:
! 1482: /* guard against freeing invalid types */
! 1483: switch(value->type) {
! 1484: case xmlrpc_empty:
! 1485: case xmlrpc_base64:
! 1486: case xmlrpc_boolean:
! 1487: case xmlrpc_datetime:
! 1488: case xmlrpc_double:
! 1489: case xmlrpc_int:
! 1490: case xmlrpc_string:
! 1491: case xmlrpc_vector:
! 1492: #ifdef XMLRPC_DEBUG_REFCOUNT
! 1493: if(value->id.str) {
! 1494: printf("free'd %s\n", value->id.str);
! 1495: }
! 1496: else {
! 1497: printf("free'd 0x%x\n", value);
! 1498: }
! 1499: #endif
! 1500: simplestring_free(&value->id);
! 1501: simplestring_free(&value->str);
! 1502:
! 1503: memset(value, 0, sizeof(STRUCT_XMLRPC_VALUE));
! 1504: my_free(value);
! 1505: break;
! 1506: default:
! 1507: /* fprintf (stderr,
! 1508: "xmlrpc: attempted to free value of invalid type\n"); */
! 1509: break;
! 1510: }
! 1511: }
! 1512: }
! 1513: }
! 1514:
! 1515: /*******/
! 1516:
! 1517:
! 1518: /****f* VALUE/XMLRPC_SetValueDateTime
! 1519: * NAME
! 1520: * XMLRPC_SetValueDateTime
! 1521: * SYNOPSIS
! 1522: * void XMLRPC_SetValueDateTime(XMLRPC_VALUE value, time_t time)
! 1523: * FUNCTION
! 1524: * Assign time value to XMLRPC_VALUE
! 1525: * INPUTS
! 1526: * value The target XMLRPC_VALUE
! 1527: * time The desired new unix time value (time_t)
! 1528: * RESULT
! 1529: * void
! 1530: * SEE ALSO
! 1531: * XMLRPC_GetValueDateTime ()
! 1532: * XMLRPC_SetValueDateTime_ISO8601 ()
! 1533: * XMLRPC_CreateValueDateTime ()
! 1534: * XMLRPC_VALUE
! 1535: * SOURCE
! 1536: */
! 1537: void XMLRPC_SetValueDateTime(XMLRPC_VALUE value, time_t time) {
! 1538: if(value) {
! 1539: char timeBuf[30];
! 1540: value->type = xmlrpc_datetime;
! 1541: value->i = time;
! 1542:
! 1543: timeBuf[0] = 0;
! 1544:
! 1545: date_to_ISO8601(time, timeBuf, sizeof(timeBuf));
! 1546:
! 1547: if(timeBuf[0]) {
! 1548: XMLRPC_SetValueDateTime_ISO8601 (value, timeBuf);
! 1549: }
! 1550: }
! 1551: }
! 1552:
! 1553: /*******/
! 1554:
! 1555: /****f* VALUE/XMLRPC_CopyValue
! 1556: * NAME
! 1557: * XMLRPC_CopyValue
! 1558: * SYNOPSIS
! 1559: * XMLRPC_VALUE XMLRPC_CopyValue(XMLRPC_VALUE value)
! 1560: * FUNCTION
! 1561: * Make a copy (reference) of an XMLRPC_VALUE
! 1562: * INPUTS
! 1563: * value The target XMLRPC_VALUE
! 1564: * RESULT
! 1565: * XMLRPC_VALUE -- address of the copy
! 1566: * SEE ALSO
! 1567: * XMLRPC_CleanupValue ()
! 1568: * XMLRPC_DupValueNew ()
! 1569: * NOTES
! 1570: * This function is implemented via reference counting, so the
! 1571: * returned value is going to be the same as the passed in value.
! 1572: * The value must be freed the same number of times it is copied
! 1573: * or there will be a memory leak.
! 1574: * SOURCE
! 1575: */
! 1576: XMLRPC_VALUE XMLRPC_CopyValue(XMLRPC_VALUE value) {
! 1577: if(value) {
! 1578: value->iRefCount ++;
! 1579: #ifdef XMLRPC_DEBUG_REFCOUNT
! 1580: if(value->id.str) {
! 1581: printf ("incremented refcount of %s, now %i\n", value->id.str,
! 1582: value->iRefCount);
! 1583: }
! 1584: else {
! 1585: printf ("incremented refcount of 0x%x, now %i\n", value,
! 1586: value->iRefCount);
! 1587: }
! 1588: #endif
! 1589: }
! 1590: return value;
! 1591: }
! 1592:
! 1593: /*******/
! 1594:
! 1595:
! 1596: /****f* VALUE/XMLRPC_DupValueNew
! 1597: * NAME
! 1598: * XMLRPC_DupValueNew
! 1599: * SYNOPSIS
! 1600: * XMLRPC_VALUE XMLRPC_DupValueNew(XMLRPC_VALUE value)
! 1601: * FUNCTION
! 1602: * Make a duplicate (non reference) of an XMLRPC_VALUE with newly allocated mem.
! 1603: * INPUTS
! 1604: * value The source XMLRPC_VALUE to duplicate
! 1605: * RESULT
! 1606: * XMLRPC_VALUE -- address of the duplicate value
! 1607: * SEE ALSO
! 1608: * XMLRPC_CleanupValue ()
! 1609: * XMLRPC_CopyValue ()
! 1610: * NOTES
! 1611: * Use this when function when you need to modify the contents of
! 1612: * the copied value seperately from the original.
! 1613: *
! 1614: * this function is recursive, thus the value and all of its children
! 1615: * (if any) will be duplicated.
! 1616: * SOURCE
! 1617: */
! 1618: XMLRPC_VALUE XMLRPC_DupValueNew (XMLRPC_VALUE xSource) {
! 1619: XMLRPC_VALUE xReturn = NULL;
! 1620: if (xSource) {
! 1621: xReturn = XMLRPC_CreateValueEmpty ();
! 1622: if (xSource->id.len) {
! 1623: XMLRPC_SetValueID (xReturn, xSource->id.str, xSource->id.len);
! 1624: }
! 1625:
! 1626: switch (xSource->type) {
! 1627: case xmlrpc_int:
! 1628: case xmlrpc_boolean:
! 1629: XMLRPC_SetValueInt (xReturn, xSource->i);
! 1630: break;
! 1631: case xmlrpc_string:
! 1632: case xmlrpc_base64:
! 1633: XMLRPC_SetValueString (xReturn, xSource->str.str, xSource->str.len);
! 1634: break;
! 1635: case xmlrpc_datetime:
! 1636: XMLRPC_SetValueDateTime (xReturn, xSource->i);
! 1637: break;
! 1638: case xmlrpc_double:
! 1639: XMLRPC_SetValueDouble (xReturn, xSource->d);
! 1640: break;
! 1641: case xmlrpc_vector:
! 1642: {
! 1643: q_iter qi = Q_Iter_Head_F (xSource->v->q);
! 1644: XMLRPC_SetIsVector (xReturn, xSource->v->type);
! 1645:
! 1646: while (qi) {
! 1647: XMLRPC_VALUE xIter = Q_Iter_Get_F (qi);
! 1648: XMLRPC_AddValueToVector (xReturn, XMLRPC_DupValueNew (xIter));
! 1649: qi = Q_Iter_Next_F (qi);
! 1650: }
! 1651: }
! 1652: break;
! 1653: default:
! 1654: break;
! 1655: }
! 1656: }
! 1657: return xReturn;
! 1658: }
! 1659:
! 1660: /*******/
! 1661:
! 1662:
! 1663:
! 1664: /****f* VALUE/XMLRPC_CreateValueDateTime
! 1665: * NAME
! 1666: * XMLRPC_CreateValueDateTime
! 1667: * SYNOPSIS
! 1668: * XMLRPC_VALUE XMLRPC_CreateValueDateTime(const char* id, time_t time)
! 1669: * FUNCTION
! 1670: * Create new datetime value from time_t
! 1671: * INPUTS
! 1672: * id id of the new value, or NULL
! 1673: * time The desired unix time value (time_t)
! 1674: * RESULT
! 1675: * void
! 1676: * SEE ALSO
! 1677: * XMLRPC_GetValueDateTime ()
! 1678: * XMLRPC_SetValueDateTime ()
! 1679: * XMLRPC_CreateValueDateTime_ISO8601 ()
! 1680: * XMLRPC_VALUE
! 1681: * SOURCE
! 1682: */
! 1683: XMLRPC_VALUE XMLRPC_CreateValueDateTime(const char* id, time_t time) {
! 1684: XMLRPC_VALUE val = XMLRPC_CreateValueEmpty();
! 1685: if(val) {
! 1686: XMLRPC_SetValueDateTime(val, time);
! 1687: if(id) {
! 1688: XMLRPC_SetValueID(val, id, 0);
! 1689: }
! 1690: }
! 1691: return val;
! 1692: }
! 1693:
! 1694: /*******/
! 1695:
! 1696:
! 1697: /****f* VALUE/XMLRPC_SetValueDateTime_ISO8601
! 1698: * NAME
! 1699: * XMLRPC_SetValueDateTime_ISO8601
! 1700: * SYNOPSIS
! 1701: * void XMLRPC_SetValueDateTime_ISO8601(XMLRPC_VALUE value, const char* s)
! 1702: * FUNCTION
! 1703: * Set datetime value from IS08601 encoded string
! 1704: * INPUTS
! 1705: * value The target XMLRPC_VALUE
! 1706: * s The desired new time value
! 1707: * RESULT
! 1708: * void
! 1709: * BUGS
! 1710: * This function currently attempts to convert the time string to a valid unix time
! 1711: * value before passing it. Behavior when the string is invalid or out of range
! 1712: * is not well defined, but will probably result in Jan 1, 1970 (0) being passed.
! 1713: * SEE ALSO
! 1714: * XMLRPC_GetValueDateTime_ISO8601 ()
! 1715: * XMLRPC_CreateValueDateTime_ISO8601 ()
! 1716: * XMLRPC_CreateValueDateTime ()
! 1717: * XMLRPC_VALUE
! 1718: * SOURCE
! 1719: */
! 1720: void XMLRPC_SetValueDateTime_ISO8601(XMLRPC_VALUE value, const char* s) {
! 1721: if(value) {
! 1722: time_t time_val = 0;
! 1723: if(s) {
! 1724: value->type = xmlrpc_datetime;
! 1725: date_from_ISO8601(s, &time_val);
! 1726: value->i = time_val;
! 1727: simplestring_clear(&value->str);
! 1728: simplestring_add(&value->str, s);
! 1729: }
! 1730: }
! 1731: }
! 1732:
! 1733: /*******/
! 1734:
! 1735: /****f* VALUE/XMLRPC_CreateValueDateTime_ISO8601
! 1736: * NAME
! 1737: * XMLRPC_CreateValueDateTime_ISO8601
! 1738: * SYNOPSIS
! 1739: * XMLRPC_VALUE XMLRPC_CreateValueDateTime_ISO8601(const char* id, const char *s)
! 1740: * FUNCTION
! 1741: * Create datetime value from IS08601 encoded string
! 1742: * INPUTS
! 1743: * id The id of the new value, or NULL
! 1744: * s The desired new time value
! 1745: * RESULT
! 1746: * newly allocated XMLRPC_VALUE, or NULL if no value created.
! 1747: * BUGS
! 1748: * See XMLRPC_SetValueDateTime_ISO8601 ()
! 1749: * SEE ALSO
! 1750: * XMLRPC_GetValueDateTime_ISO8601 ()
! 1751: * XMLRPC_SetValueDateTime_ISO8601 ()
! 1752: * XMLRPC_CreateValueDateTime ()
! 1753: * XMLRPC_VALUE
! 1754: * SOURCE
! 1755: */
! 1756: XMLRPC_VALUE XMLRPC_CreateValueDateTime_ISO8601(const char* id, const char *s) {
! 1757: XMLRPC_VALUE val = XMLRPC_CreateValueEmpty();
! 1758: if(val) {
! 1759: XMLRPC_SetValueDateTime_ISO8601(val, s);
! 1760: if(id) {
! 1761: XMLRPC_SetValueID(val, id, 0);
! 1762: }
! 1763: }
! 1764: return val;
! 1765: }
! 1766:
! 1767: /*******/
! 1768:
! 1769:
! 1770: /****f* VALUE/XMLRPC_SetValueBase64
! 1771: * NAME
! 1772: * XMLRPC_SetValueBase64
! 1773: * SYNOPSIS
! 1774: * void XMLRPC_SetValueBase64(XMLRPC_VALUE value, const char* s, int len)
! 1775: * FUNCTION
! 1776: * Set base64 value. Base64 is useful for transferring binary data, such as an image.
! 1777: * INPUTS
! 1778: * value The target XMLRPC_VALUE
! 1779: * s The desired new binary value
! 1780: * len The length of s, or NULL. If buffer is not null terminated, len *must* be passed.
! 1781: * RESULT
! 1782: * void
! 1783: * NOTES
! 1784: * Data is set/stored/retrieved as passed in, but is base64 encoded for XML transfer, and
! 1785: * decoded on the other side. This is transparent to the caller.
! 1786: * SEE ALSO
! 1787: * XMLRPC_GetValueBase64 ()
! 1788: * XMLRPC_CreateValueBase64 ()
! 1789: * XMLRPC_VALUE
! 1790: * SOURCE
! 1791: */
! 1792: void XMLRPC_SetValueBase64(XMLRPC_VALUE value, const char* s, int len) {
! 1793: if(value && s) {
! 1794: simplestring_clear(&value->str);
! 1795: (len > 0) ? simplestring_addn(&value->str, s, len) :
! 1796: simplestring_add(&value->str, s);
! 1797: value->type = xmlrpc_base64;
! 1798: }
! 1799: }
! 1800:
! 1801: /*******/
! 1802:
! 1803:
! 1804: /****f* VALUE/XMLRPC_CreateValueBase64
! 1805: * NAME
! 1806: * XMLRPC_CreateValueBase64
! 1807: * SYNOPSIS
! 1808: * XMLRPC_VALUE XMLRPC_CreateValueBase64(const char* id, const char* s, int len)
! 1809: * FUNCTION
! 1810: * Create base64 value. Base64 is useful for transferring binary data, such as an image.
! 1811: * INPUTS
! 1812: * id id of the new value, or NULL
! 1813: * s The desired new binary value
! 1814: * len The length of s, or NULL. If buffer is not null terminated, len *must* be passed.
! 1815: * RESULT
! 1816: * newly allocated XMLRPC_VALUE, or NULL if error
! 1817: * NOTES
! 1818: * See XMLRPC_SetValueBase64 ()
! 1819: * SEE ALSO
! 1820: * XMLRPC_GetValueBase64 ()
! 1821: * XMLRPC_SetValueBase64 ()
! 1822: * XMLRPC_VALUE
! 1823: * SOURCE
! 1824: */
! 1825: XMLRPC_VALUE XMLRPC_CreateValueBase64(const char* id, const char* s, int len) {
! 1826: XMLRPC_VALUE val = XMLRPC_CreateValueEmpty();
! 1827: if(val) {
! 1828: XMLRPC_SetValueBase64(val, s, len);
! 1829: if(id) {
! 1830: XMLRPC_SetValueID(val, id, 0);
! 1831: }
! 1832: }
! 1833: return val;
! 1834: }
! 1835:
! 1836: /*******/
! 1837:
! 1838: /****f* VALUE/XMLRPC_SetValueDouble
! 1839: * NAME
! 1840: * XMLRPC_SetValueDouble
! 1841: * SYNOPSIS
! 1842: * void XMLRPC_SetValueDouble(XMLRPC_VALUE value, double val)
! 1843: * FUNCTION
! 1844: * Set double (floating point) value.
! 1845: * INPUTS
! 1846: * value The target XMLRPC_VALUE
! 1847: * val The desired new double value
! 1848: * RESULT
! 1849: * void
! 1850: * SEE ALSO
! 1851: * XMLRPC_GetValueDouble ()
! 1852: * XMLRPC_CreateValueDouble ()
! 1853: * XMLRPC_VALUE
! 1854: * SOURCE
! 1855: */
! 1856: void XMLRPC_SetValueDouble(XMLRPC_VALUE value, double val) {
! 1857: if(value) {
! 1858: value->type = xmlrpc_double;
! 1859: value->d = val;
! 1860: }
! 1861: }
! 1862:
! 1863: /*******/
! 1864:
! 1865: /****f* VALUE/XMLRPC_CreateValueDouble
! 1866: * NAME
! 1867: * XMLRPC_CreateValueDouble
! 1868: * SYNOPSIS
! 1869: * XMLRPC_VALUE XMLRPC_CreateValueDouble(const char* id, double d)
! 1870: * FUNCTION
! 1871: * Create double (floating point) value.
! 1872: * INPUTS
! 1873: * id id of the newly created value, or NULL
! 1874: * d The desired new double value
! 1875: * RESULT
! 1876: * void
! 1877: * SEE ALSO
! 1878: * XMLRPC_GetValueDouble ()
! 1879: * XMLRPC_CreateValueDouble ()
! 1880: * XMLRPC_VALUE
! 1881: * SOURCE
! 1882: */
! 1883: XMLRPC_VALUE XMLRPC_CreateValueDouble(const char* id, double d) {
! 1884: XMLRPC_VALUE val = XMLRPC_CreateValueEmpty();
! 1885: if(val) {
! 1886: XMLRPC_SetValueDouble(val, d);
! 1887: if(id) {
! 1888: XMLRPC_SetValueID(val, id, 0);
! 1889: }
! 1890: }
! 1891: return val;
! 1892: }
! 1893:
! 1894: /*******/
! 1895:
! 1896: /****f* VALUE/XMLRPC_GetValueString
! 1897: * NAME
! 1898: * XMLRPC_GetValueString
! 1899: * SYNOPSIS
! 1900: * const char* XMLRPC_GetValueString(XMLRPC_VALUE value)
! 1901: * FUNCTION
! 1902: * retrieve string value
! 1903: * INPUTS
! 1904: * value source XMLRPC_VALUE of type xmlrpc_string
! 1905: * RESULT
! 1906: * void
! 1907: * SEE ALSO
! 1908: * XMLRPC_SetValueString ()
! 1909: * XMLRPC_GetValueType ()
! 1910: * XMLRPC_VALUE
! 1911: * SOURCE
! 1912: */
! 1913: const char* XMLRPC_GetValueString(XMLRPC_VALUE value) {
! 1914: return ((value && value->type == xmlrpc_string) ? value->str.str : 0);
! 1915: }
! 1916:
! 1917: /*******/
! 1918:
! 1919: /****f* VALUE/XMLRPC_GetValueStringLen
! 1920: * NAME
! 1921: * XMLRPC_GetValueStringLen
! 1922: * SYNOPSIS
! 1923: * int XMLRPC_GetValueStringLen(XMLRPC_VALUE value)
! 1924: * FUNCTION
! 1925: * determine length of string value
! 1926: * INPUTS
! 1927: * value XMLRPC_VALUE of type xmlrpc_string
! 1928: * RESULT
! 1929: * length of string, or 0
! 1930: * NOTES
! 1931: * SEE ALSO
! 1932: * XMLRPC_SetValueString ()
! 1933: * XMLRPC_GetValueString ()
! 1934: * SOURCE
! 1935: */
! 1936: int XMLRPC_GetValueStringLen(XMLRPC_VALUE value) {
! 1937: return ((value) ? value->str.len : 0);
! 1938: }
! 1939:
! 1940: /*******/
! 1941:
! 1942: /****f* VALUE/XMLRPC_GetValueInt
! 1943: * NAME
! 1944: * XMLRPC_GetValueInt
! 1945: * SYNOPSIS
! 1946: * int XMLRPC_GetValueInt(XMLRPC_VALUE value)
! 1947: * FUNCTION
! 1948: * retrieve integer value.
! 1949: * INPUTS
! 1950: * value XMLRPC_VALUE of type xmlrpc_int
! 1951: * RESULT
! 1952: * integer value or 0 if value is not valid int
! 1953: * NOTES
! 1954: * use XMLRPC_GetValueType () to be sure if 0 is real return value or not
! 1955: * SEE ALSO
! 1956: * XMLRPC_SetValueInt ()
! 1957: * XMLRPC_CreateValueInt ()
! 1958: * SOURCE
! 1959: */
! 1960: int XMLRPC_GetValueInt(XMLRPC_VALUE value) {
! 1961: return ((value && value->type == xmlrpc_int) ? value->i : 0);
! 1962: }
! 1963:
! 1964: /*******/
! 1965:
! 1966: /****f* VALUE/XMLRPC_GetValueBoolean
! 1967: * NAME
! 1968: * XMLRPC_GetValueBoolean
! 1969: * SYNOPSIS
! 1970: * int XMLRPC_GetValueBoolean(XMLRPC_VALUE value)
! 1971: * FUNCTION
! 1972: * retrieve boolean value.
! 1973: * INPUTS
! 1974: * XMLRPC_VALUE of type xmlrpc_boolean
! 1975: * RESULT
! 1976: * boolean value or 0 if value is not valid boolean
! 1977: * NOTES
! 1978: * use XMLRPC_GetValueType() to be sure if 0 is real value or not
! 1979: * SEE ALSO
! 1980: * XMLRPC_SetValueBoolean ()
! 1981: * XMLRPC_CreateValueBoolean ()
! 1982: * SOURCE
! 1983: */
! 1984: int XMLRPC_GetValueBoolean(XMLRPC_VALUE value) {
! 1985: return ((value && value->type == xmlrpc_boolean) ? value->i : 0);
! 1986: }
! 1987:
! 1988: /*******/
! 1989:
! 1990: /****f* VALUE/XMLRPC_GetValueDouble
! 1991: * NAME
! 1992: * XMLRPC_GetValueDouble
! 1993: * SYNOPSIS
! 1994: * double XMLRPC_GetValueDouble(XMLRPC_VALUE value)
! 1995: * FUNCTION
! 1996: * retrieve double value
! 1997: * INPUTS
! 1998: * XMLRPC_VALUE of type xmlrpc_double
! 1999: * RESULT
! 2000: * double value or 0 if value is not valid double.
! 2001: * NOTES
! 2002: * use XMLRPC_GetValueType() to be sure if 0 is real value or not
! 2003: * SEE ALSO
! 2004: * XMLRPC_SetValueDouble ()
! 2005: * XMLRPC_CreateValueDouble ()
! 2006: * SOURCE
! 2007: */
! 2008: double XMLRPC_GetValueDouble(XMLRPC_VALUE value) {
! 2009: return ((value && value->type == xmlrpc_double) ? value->d : 0);
! 2010: }
! 2011:
! 2012: /*******/
! 2013:
! 2014: /****f* VALUE/XMLRPC_GetValueBase64
! 2015: * NAME
! 2016: * XMLRPC_GetValueBase64
! 2017: * SYNOPSIS
! 2018: * const char* XMLRPC_GetValueBase64(XMLRPC_VALUE value)
! 2019: * FUNCTION
! 2020: * retrieve binary value
! 2021: * INPUTS
! 2022: * XMLRPC_VALUE of type xmlrpc_base64
! 2023: * RESULT
! 2024: * pointer to binary value or 0 if value is not valid.
! 2025: * SEE ALSO
! 2026: * XMLRPC_SetValueBase64 ()
! 2027: * XMLRPC_CreateValueBase64 ()
! 2028: * NOTES
! 2029: * Call XMLRPC_GetValueStringLen() to retrieve real length of binary data. strlen()
! 2030: * will not be accurate, as returned data may contain embedded nulls.
! 2031: * SOURCE
! 2032: */
! 2033: const char* XMLRPC_GetValueBase64(XMLRPC_VALUE value) {
! 2034: return ((value && value->type == xmlrpc_base64) ? value->str.str : 0);
! 2035: }
! 2036:
! 2037: /*******/
! 2038:
! 2039: /****f* VALUE/XMLRPC_GetValueDateTime
! 2040: * NAME
! 2041: * XMLRPC_GetValueDateTime
! 2042: * SYNOPSIS
! 2043: * time_t XMLRPC_GetValueDateTime(XMLRPC_VALUE value)
! 2044: * FUNCTION
! 2045: * retrieve time_t value
! 2046: * INPUTS
! 2047: * XMLRPC_VALUE of type xmlrpc_datetime
! 2048: * RESULT
! 2049: * time_t value or 0 if value is not valid datetime.
! 2050: * NOTES
! 2051: * use XMLRPC_GetValueType() to be sure if 0 is real value or not
! 2052: * SEE ALSO
! 2053: * XMLRPC_SetValueDateTime ()
! 2054: * XMLRPC_GetValueDateTime_ISO8601 ()
! 2055: * XMLRPC_CreateValueDateTime ()
! 2056: * SOURCE
! 2057: */
! 2058: time_t XMLRPC_GetValueDateTime(XMLRPC_VALUE value) {
! 2059: return (time_t)((value && value->type == xmlrpc_datetime) ? value->i : 0);
! 2060: }
! 2061:
! 2062: /*******/
! 2063:
! 2064: /****f* VALUE/XMLRPC_GetValueDateTime_IOS8601
! 2065: * NAME
! 2066: * XMLRPC_GetValueDateTime_IOS8601
! 2067: * SYNOPSIS
! 2068: * const char* XMLRPC_GetValueDateTime_IOS8601(XMLRPC_VALUE value)
! 2069: * FUNCTION
! 2070: * retrieve ISO8601 formatted time value
! 2071: * INPUTS
! 2072: * XMLRPC_VALUE of type xmlrpc_datetime
! 2073: * RESULT
! 2074: * const char* value or 0 if value is not valid datetime.
! 2075: * SEE ALSO
! 2076: * XMLRPC_SetValueDateTime_IOS8601 ()
! 2077: * XMLRPC_GetValueDateTime ()
! 2078: * XMLRPC_CreateValueDateTime_IOS8601 ()
! 2079: * SOURCE
! 2080: */
! 2081: const char* XMLRPC_GetValueDateTime_ISO8601(XMLRPC_VALUE value) {
! 2082: return ((value && value->type == xmlrpc_datetime) ? value->str.str : 0);
! 2083: }
! 2084:
! 2085: /*******/
! 2086:
! 2087: /* Get ID (key) of value or NULL */
! 2088: /****f* VALUE/XMLRPC_GetValueID
! 2089: * NAME
! 2090: * XMLRPC_GetValueID
! 2091: * SYNOPSIS
! 2092: * const char* XMLRPC_GetValueID(XMLRPC_VALUE value)
! 2093: * FUNCTION
! 2094: * retrieve id (key) of value
! 2095: * INPUTS
! 2096: * XMLRPC_VALUE of any type
! 2097: * RESULT
! 2098: * const char* pointer to id of value, or NULL
! 2099: * NOTES
! 2100: * SEE ALSO
! 2101: * XMLRPC_SetValueID()
! 2102: * XMLRPC_CreateValueEmpty()
! 2103: * SOURCE
! 2104: */
! 2105: const char* XMLRPC_GetValueID(XMLRPC_VALUE value) {
! 2106: return (const char*)((value && value->id.len) ? value->id.str : 0);
! 2107: }
! 2108:
! 2109: /*******/
! 2110:
! 2111:
! 2112: /****f* VECTOR/XMLRPC_VectorSize
! 2113: * NAME
! 2114: * XMLRPC_VectorSize
! 2115: * SYNOPSIS
! 2116: * int XMLRPC_VectorSize(XMLRPC_VALUE value)
! 2117: * FUNCTION
! 2118: * retrieve size of vector
! 2119: * INPUTS
! 2120: * XMLRPC_VALUE of type xmlrpc_vector
! 2121: * RESULT
! 2122: * count of items in vector
! 2123: * NOTES
! 2124: * This is a cheap operation even on large vectors. Vector size is
! 2125: * maintained by queue during add/remove ops.
! 2126: * SEE ALSO
! 2127: * XMLRPC_AddValueToVector ()
! 2128: * SOURCE
! 2129: */
! 2130: int XMLRPC_VectorSize(XMLRPC_VALUE value) {
! 2131: int size = 0;
! 2132: if(value && value->type == xmlrpc_vector && value->v) {
! 2133: size = Q_Size(value->v->q);
! 2134: }
! 2135: return size;
! 2136: }
! 2137:
! 2138: /*******/
! 2139:
! 2140: /****f* VECTOR/XMLRPC_VectorRewind
! 2141: * NAME
! 2142: * XMLRPC_VectorRewind
! 2143: * SYNOPSIS
! 2144: * XMLRPC_VALUE XMLRPC_VectorRewind(XMLRPC_VALUE value)
! 2145: * FUNCTION
! 2146: * reset vector to first item
! 2147: * INPUTS
! 2148: * XMLRPC_VALUE of type xmlrpc_vector
! 2149: * RESULT
! 2150: * first XMLRPC_VALUE in list, or NULL if empty or error.
! 2151: * NOTES
! 2152: * Be careful to rewind any vector passed in to you if you expect to
! 2153: * iterate through the entire list.
! 2154: * SEE ALSO
! 2155: * XMLRPC_VectorNext ()
! 2156: * SOURCE
! 2157: */
! 2158: XMLRPC_VALUE XMLRPC_VectorRewind(XMLRPC_VALUE value) {
! 2159: XMLRPC_VALUE xReturn = NULL;
! 2160: if(value && value->type == xmlrpc_vector && value->v) {
! 2161: xReturn = (XMLRPC_VALUE)Q_Head(value->v->q);
! 2162: }
! 2163: return xReturn;
! 2164: }
! 2165:
! 2166: /*******/
! 2167:
! 2168: /****f* VECTOR/XMLRPC_VectorNext
! 2169: * NAME
! 2170: * XMLRPC_VectorNext
! 2171: * SYNOPSIS
! 2172: * XMLRPC_VALUE XMLRPC_VectorNext(XMLRPC_VALUE value)
! 2173: * FUNCTION
! 2174: * Iterate vector to next item in list.
! 2175: * INPUTS
! 2176: * XMLRPC_VALUE of type xmlrpc_vector
! 2177: * RESULT
! 2178: * Next XMLRPC_VALUE in vector, or NULL if at end.
! 2179: * NOTES
! 2180: * SEE ALSO
! 2181: * XMLRPC_VectorRewind ()
! 2182: * SOURCE
! 2183: */
! 2184: XMLRPC_VALUE XMLRPC_VectorNext(XMLRPC_VALUE value) {
! 2185: XMLRPC_VALUE xReturn = NULL;
! 2186: if(value && value->type == xmlrpc_vector && value->v) {
! 2187: xReturn = (XMLRPC_VALUE)Q_Next(value->v->q);
! 2188: }
! 2189: return xReturn;
! 2190: }
! 2191:
! 2192: /*******/
! 2193:
! 2194: /****f* VALUE/XMLRPC_GetValueType
! 2195: * NAME
! 2196: * XMLRPC_GetValueType
! 2197: * SYNOPSIS
! 2198: * XMLRPC_VALUE_TYPE XMLRPC_GetValueType(XMLRPC_VALUE value)
! 2199: * FUNCTION
! 2200: * determine data type of the XMLRPC_VALUE
! 2201: * INPUTS
! 2202: * XMLRPC_VALUE target of query
! 2203: * RESULT
! 2204: * data type of value as enumerated by XMLRPC_VALUE_TYPE
! 2205: * NOTES
! 2206: * all values are of type xmlrpc_empty until set.
! 2207: * Deprecated for public use. See XMLRPC_GetValueTypeEasy
! 2208: * SEE ALSO
! 2209: * XMLRPC_SetValue*
! 2210: * XMLRPC_CreateValue*
! 2211: * XMLRPC_Append*
! 2212: * XMLRPC_GetValueTypeEasy ()
! 2213: * SOURCE
! 2214: */
! 2215: XMLRPC_VALUE_TYPE XMLRPC_GetValueType(XMLRPC_VALUE value) {
! 2216: return value ? value->type : xmlrpc_empty;
! 2217: }
! 2218:
! 2219: /*******/
! 2220:
! 2221: /* Vector type accessor */
! 2222: /****f* VALUE/XMLRPC_GetVectorType
! 2223: * NAME
! 2224: * XMLRPC_GetVectorType
! 2225: * SYNOPSIS
! 2226: * XMLRPC_VECTOR_TYPE XMLRPC_GetVectorType(XMLRPC_VALUE value)
! 2227: * FUNCTION
! 2228: * determine vector type of the XMLRPC_VALUE
! 2229: * INPUTS
! 2230: * XMLRPC_VALUE of type xmlrpc_vector
! 2231: * RESULT
! 2232: * vector type of value as enumerated by XMLRPC_VECTOR_TYPE.
! 2233: * xmlrpc_none if not a value.
! 2234: * NOTES
! 2235: * xmlrpc_none is returned if value is not a vector
! 2236: * Deprecated for public use. See XMLRPC_GetValueTypeEasy
! 2237: * SEE ALSO
! 2238: * XMLRPC_SetIsVector ()
! 2239: * XMLRPC_GetValueType ()
! 2240: * XMLRPC_GetValueTypeEasy ()
! 2241: * SOURCE
! 2242: */
! 2243: XMLRPC_VECTOR_TYPE XMLRPC_GetVectorType(XMLRPC_VALUE value) {
! 2244: return(value && value->v) ? value->v->type : xmlrpc_none;
! 2245: }
! 2246:
! 2247: /*******/
! 2248:
! 2249: /****f* VALUE/XMLRPC_GetValueTypeEasy
! 2250: * NAME
! 2251: * XMLRPC_GetValueTypeEasy
! 2252: * SYNOPSIS
! 2253: * XMLRPC_VALUE_TYPE_EASY XMLRPC_GetValueTypeEasy(XMLRPC_VALUE value)
! 2254: * FUNCTION
! 2255: * determine data type of the XMLRPC_VALUE. includes vector types.
! 2256: * INPUTS
! 2257: * XMLRPC_VALUE target of query
! 2258: * RESULT
! 2259: * data type of value as enumerated by XMLRPC_VALUE_TYPE_EASY
! 2260: * xmlrpc_type_none if not a value.
! 2261: * NOTES
! 2262: * all values are of type xmlrpc_type_empty until set.
! 2263: * SEE ALSO
! 2264: * XMLRPC_SetValue*
! 2265: * XMLRPC_CreateValue*
! 2266: * XMLRPC_Append*
! 2267: * SOURCE
! 2268: */
! 2269: XMLRPC_VALUE_TYPE_EASY XMLRPC_GetValueTypeEasy (XMLRPC_VALUE value) {
! 2270: if (value) {
! 2271: switch (value->type) {
! 2272: case xmlrpc_vector:
! 2273: switch (value->v->type) {
! 2274: case xmlrpc_vector_none:
! 2275: return xmlrpc_type_none;
! 2276: case xmlrpc_vector_struct:
! 2277: return xmlrpc_type_struct;
! 2278: case xmlrpc_vector_mixed:
! 2279: return xmlrpc_type_mixed;
! 2280: case xmlrpc_vector_array:
! 2281: return xmlrpc_type_array;
! 2282: }
! 2283: default:
! 2284: /* evil cast, but we know they are the same */
! 2285: return(XMLRPC_VALUE_TYPE_EASY) value->type;
! 2286: }
! 2287: }
! 2288: return xmlrpc_none;
! 2289: }
! 2290:
! 2291: /*******/
! 2292:
! 2293:
! 2294:
! 2295: /*-*******************
! 2296: * Begin Server Funcs *
! 2297: *********************/
! 2298:
! 2299:
! 2300: /****f* VALUE/XMLRPC_ServerCreate
! 2301: * NAME
! 2302: * XMLRPC_ServerCreate
! 2303: * SYNOPSIS
! 2304: * XMLRPC_SERVER XMLRPC_ServerCreate()
! 2305: * FUNCTION
! 2306: * Allocate/Init XMLRPC Server Resources.
! 2307: * INPUTS
! 2308: * none
! 2309: * RESULT
! 2310: * newly allocated XMLRPC_SERVER
! 2311: * NOTES
! 2312: * SEE ALSO
! 2313: * XMLRPC_ServerDestroy ()
! 2314: * XMLRPC_GetGlobalServer ()
! 2315: * SOURCE
! 2316: */
! 2317: XMLRPC_SERVER XMLRPC_ServerCreate() {
! 2318: XMLRPC_SERVER server = calloc(1, sizeof(STRUCT_XMLRPC_SERVER));
! 2319: if(server) {
! 2320: Q_Init(&server->methodlist);
! 2321: Q_Init(&server->docslist);
! 2322:
! 2323: /* register system methods */
! 2324: xsm_register(server);
! 2325: }
! 2326: return server;
! 2327: }
! 2328:
! 2329: /*******/
! 2330:
! 2331: /* Return global server. Not locking! Not Thread Safe! */
! 2332: /****f* VALUE/XMLRPC_GetGlobalServer
! 2333: * NAME
! 2334: * XMLRPC_GetGlobalServer
! 2335: * SYNOPSIS
! 2336: * XMLRPC_SERVER XMLRPC_GetGlobalServer()
! 2337: * FUNCTION
! 2338: * Allocates a global (process-wide) server, or returns pointer if pre-existing.
! 2339: * INPUTS
! 2340: * none
! 2341: * RESULT
! 2342: * pointer to global server, or 0 if error.
! 2343: * NOTES
! 2344: * ***WARNING*** This function is not thread safe. It is included only for the very lazy.
! 2345: * Multi-threaded programs that use this may experience problems.
! 2346: * BUGS
! 2347: * There is currently no way to cleanup the global server gracefully.
! 2348: * SEE ALSO
! 2349: * XMLRPC_ServerCreate ()
! 2350: * SOURCE
! 2351: */
! 2352: XMLRPC_SERVER XMLRPC_GetGlobalServer() {
! 2353: static XMLRPC_SERVER xsServer = 0;
! 2354: if(!xsServer) {
! 2355: xsServer = XMLRPC_ServerCreate();
! 2356: }
! 2357: return xsServer;
! 2358: }
! 2359:
! 2360: /*******/
! 2361:
! 2362: /****f* VALUE/XMLRPC_ServerDestroy
! 2363: * NAME
! 2364: * XMLRPC_ServerDestroy
! 2365: * SYNOPSIS
! 2366: * void XMLRPC_ServerDestroy(XMLRPC_SERVER server)
! 2367: * FUNCTION
! 2368: * Free Server Resources
! 2369: * INPUTS
! 2370: * server The server to be free'd
! 2371: * RESULT
! 2372: * void
! 2373: * NOTES
! 2374: * This frees the server struct and any methods that have been added.
! 2375: * SEE ALSO
! 2376: * XMLRPC_ServerCreate ()
! 2377: * SOURCE
! 2378: */
! 2379: void XMLRPC_ServerDestroy(XMLRPC_SERVER server) {
! 2380: if(server) {
! 2381: doc_method* dm = Q_Head(&server->docslist);
! 2382: server_method* sm = Q_Head(&server->methodlist);
! 2383: while( dm ) {
! 2384: my_free(dm);
! 2385: dm = Q_Next(&server->docslist);
! 2386: }
! 2387: while( sm ) {
! 2388: if(sm->name) {
! 2389: my_free(sm->name);
! 2390: }
! 2391: if(sm->desc) {
! 2392: XMLRPC_CleanupValue(sm->desc);
! 2393: }
! 2394: my_free(sm);
! 2395: sm = Q_Next(&server->methodlist);
! 2396: }
! 2397: if(server->xIntrospection) {
! 2398: XMLRPC_CleanupValue(server->xIntrospection);
! 2399: }
! 2400:
! 2401: Q_Destroy(&server->methodlist);
! 2402: Q_Destroy(&server->docslist);
! 2403: my_free(server);
! 2404: }
! 2405: }
! 2406:
! 2407: /*******/
! 2408:
! 2409:
! 2410: /****f* VALUE/XMLRPC_ServerRegisterMethod
! 2411: * NAME
! 2412: * XMLRPC_ServerRegisterMethod
! 2413: * SYNOPSIS
! 2414: * void XMLRPC_ServerRegisterMethod(XMLRPC_SERVER server, const char *name, XMLRPC_Callback cb)
! 2415: * FUNCTION
! 2416: * Register new XMLRPC method with server
! 2417: * INPUTS
! 2418: * server The XMLRPC_SERVER to register the method with
! 2419: * name public name of the method
! 2420: * cb C function that implements the method
! 2421: * RESULT
! 2422: * int - 1 if success, else 0
! 2423: * NOTES
! 2424: * A C function must be registered for every "method" that the server recognizes. The
! 2425: * method name is equivalent to <methodCall><name> method name </name></methodCall> in the
! 2426: * XML syntax.
! 2427: * SEE ALSO
! 2428: * XMLRPC_ServerFindMethod ()
! 2429: * XMLRPC_ServerCallMethod ()
! 2430: * SOURCE
! 2431: */
! 2432: int XMLRPC_ServerRegisterMethod(XMLRPC_SERVER server, const char *name, XMLRPC_Callback cb) {
! 2433: if(server && name && cb) {
! 2434:
! 2435: server_method* sm = malloc(sizeof(server_method));
! 2436:
! 2437: if(sm) {
! 2438: sm->name = strdup(name);
! 2439: sm->method = cb;
! 2440: sm->desc = NULL;
! 2441:
! 2442: return Q_PushTail(&server->methodlist, sm);
! 2443: }
! 2444: }
! 2445: return 0;
! 2446: }
! 2447:
! 2448: /*******/
! 2449:
! 2450: server_method* find_method(XMLRPC_SERVER server, const char* name) {
! 2451: server_method* sm;
! 2452:
! 2453: q_iter qi = Q_Iter_Head_F(&server->methodlist);
! 2454:
! 2455: while( qi ) {
! 2456: sm = Q_Iter_Get_F(qi);
! 2457: if(sm && !strcmp(sm->name, name)) {
! 2458: return sm;
! 2459: }
! 2460: qi = Q_Iter_Next_F(qi);
! 2461: }
! 2462: return NULL;
! 2463: }
! 2464:
! 2465:
! 2466: const char* type_to_str(XMLRPC_VALUE_TYPE type, XMLRPC_VECTOR_TYPE vtype) {
! 2467: switch(type) {
! 2468: case xmlrpc_none:
! 2469: return "none";
! 2470: case xmlrpc_empty:
! 2471: return "empty";
! 2472: case xmlrpc_base64:
! 2473: return "base64";
! 2474: case xmlrpc_boolean:
! 2475: return "boolean";
! 2476: case xmlrpc_datetime:
! 2477: return "datetime";
! 2478: case xmlrpc_double:
! 2479: return "double";
! 2480: case xmlrpc_int:
! 2481: return "int";
! 2482: case xmlrpc_string:
! 2483: return "string";
! 2484: case xmlrpc_vector:
! 2485: switch(vtype) {
! 2486: case xmlrpc_vector_none:
! 2487: return "none";
! 2488: case xmlrpc_vector_array:
! 2489: return "array";
! 2490: case xmlrpc_vector_mixed:
! 2491: return "mixed vector (struct)";
! 2492: case xmlrpc_vector_struct:
! 2493: return "struct";
! 2494: }
! 2495: }
! 2496: return "unknown";
! 2497: }
! 2498:
! 2499: /****f* VALUE/XMLRPC_ServerFindMethod
! 2500: * NAME
! 2501: * XMLRPC_ServerFindMethod
! 2502: * SYNOPSIS
! 2503: * XMLRPC_Callback XMLRPC_ServerFindMethod(XMLRPC_SERVER server, const char* callName)
! 2504: * FUNCTION
! 2505: * retrieve C callback associated with a given method name.
! 2506: * INPUTS
! 2507: * server The XMLRPC_SERVER the method is registered with
! 2508: * callName the method to find
! 2509: * RESULT
! 2510: * previously registered XMLRPC_Callback, or NULL
! 2511: * NOTES
! 2512: * Typically, this is used to determine if a requested method exists, without actually calling it.
! 2513: * SEE ALSO
! 2514: * XMLRPC_ServerCallMethod ()
! 2515: * XMLRPC_ServerRegisterMethod ()
! 2516: * SOURCE
! 2517: */
! 2518: XMLRPC_Callback XMLRPC_ServerFindMethod(XMLRPC_SERVER server, const char* callName) {
! 2519: if(server && callName) {
! 2520: q_iter qi = Q_Iter_Head_F(&server->methodlist);
! 2521: while( qi ) {
! 2522: server_method* sm = Q_Iter_Get_F(qi);
! 2523: if(sm && !strcmp(sm->name, callName)) {
! 2524: return sm->method;
! 2525: }
! 2526: qi = Q_Iter_Next_F(qi);
! 2527: }
! 2528: }
! 2529: return NULL;
! 2530: }
! 2531:
! 2532: /*******/
! 2533:
! 2534:
! 2535: /* Call method specified in request */
! 2536: /****f* VALUE/XMLRPC_ServerCallMethod
! 2537: * NAME
! 2538: * XMLRPC_ServerCallMethod
! 2539: * SYNOPSIS
! 2540: * XMLRPC_VALUE XMLRPC_ServerCallMethod(XMLRPC_SERVER server, XMLRPC_REQUEST request, void* userData)
! 2541: * FUNCTION
! 2542: *
! 2543: * INPUTS
! 2544: * server The XMLRPC_SERVER the method is registered with
! 2545: * request the request to handle
! 2546: * userData any additional data to pass to the C callback, or NULL
! 2547: * RESULT
! 2548: * XMLRPC_VALUE allocated by the callback, or NULL
! 2549: * NOTES
! 2550: * It is typically the caller's responsibility to free the returned value.
! 2551: *
! 2552: * Often the caller will want to serialize the result as XML, via
! 2553: * XMLRPC_VALUE_To_XML () or XMLRPC_REQUEST_To_XML ()
! 2554: * SEE ALSO
! 2555: * XMLRPC_ServerFindMethod ()
! 2556: * XMLRPC_ServerRegisterMethod ()
! 2557: * XMLRPC_CleanupValue ()
! 2558: * SOURCE
! 2559: */
! 2560: XMLRPC_VALUE XMLRPC_ServerCallMethod(XMLRPC_SERVER server, XMLRPC_REQUEST request, void* userData) {
! 2561: XMLRPC_VALUE xReturn = NULL;
! 2562:
! 2563: /* check for error set during request parsing / generation */
! 2564: if(request && request->error) {
! 2565: xReturn = XMLRPC_CopyValue(request->error);
! 2566: }
! 2567: else if (server && request) {
! 2568: XMLRPC_Callback cb =
! 2569: XMLRPC_ServerFindMethod (server, request->methodName.str);
! 2570: if(cb) {
! 2571: xReturn = cb(server, request, userData);
! 2572: }
! 2573: else {
! 2574: xReturn =
! 2575: XMLRPC_UtilityCreateFault (xmlrpc_error_unknown_method,
! 2576: request->methodName.str);
! 2577: }
! 2578: }
! 2579: return xReturn;
! 2580: }
! 2581:
! 2582: /*******/
! 2583:
! 2584: /*-*****************
! 2585: * End server funcs *
! 2586: *******************/
! 2587:
! 2588:
! 2589: /*-***********************************
! 2590: * Begin XMLRPC General Options funcs *
! 2591: *************************************/
! 2592:
! 2593: /* For options used by XMLRPC_VALUE funcs that otherwise do not have
! 2594: * parameters for options. Kind of gross. :(
! 2595: */
! 2596: typedef struct _xmlrpc_options {
! 2597: XMLRPC_CASE id_case;
! 2598: XMLRPC_CASE_COMPARISON id_case_compare;
! 2599: }
! 2600: STRUCT_XMLRPC_OPTIONS, *XMLRPC_OPTIONS;
! 2601:
! 2602: static XMLRPC_OPTIONS XMLRPC_GetDefaultOptions() {
! 2603: static STRUCT_XMLRPC_OPTIONS options = {
! 2604: xmlrpc_case_exact,
! 2605: xmlrpc_case_sensitive
! 2606: };
! 2607: return &options;
! 2608: }
! 2609:
! 2610: /****f* VALUE/XMLRPC_GetDefaultIdCase
! 2611: * NAME
! 2612: * XMLRPC_GetDefaultIdCase
! 2613: * SYNOPSIS
! 2614: * XMLRPC_CASE XMLRPC_GetDefaultIdCase()
! 2615: * FUNCTION
! 2616: * Gets default case options used by XMLRPC_VALUE funcs
! 2617: * INPUTS
! 2618: * none
! 2619: * RESULT
! 2620: * XMLRPC_CASE
! 2621: * BUGS
! 2622: * Nasty and gross. Should be server specific, but that requires changing all
! 2623: * the XMLRPC_VALUE api's.
! 2624: * SEE ALSO
! 2625: * XMLRPC_SetDefaultIdCase ()
! 2626: * SOURCE
! 2627: */
! 2628: XMLRPC_CASE XMLRPC_GetDefaultIdCase() {
! 2629: XMLRPC_OPTIONS options = XMLRPC_GetDefaultOptions();
! 2630: return options->id_case;
! 2631: }
! 2632:
! 2633: /*******/
! 2634:
! 2635: /****f* VALUE/XMLRPC_SetDefaultIdCase
! 2636: * NAME
! 2637: * XMLRPC_SetDefaultIdCase
! 2638: * SYNOPSIS
! 2639: * XMLRPC_CASE XMLRPC_SetDefaultIdCase(XMLRPC_CASE id_case)
! 2640: * FUNCTION
! 2641: * Sets default case options used by XMLRPC_VALUE funcs
! 2642: * INPUTS
! 2643: * id_case case options as enumerated by XMLRPC_CASE
! 2644: * RESULT
! 2645: * XMLRPC_CASE -- newly set option
! 2646: * BUGS
! 2647: * Nasty and gross. Should be server specific, but that requires changing all
! 2648: * the XMLRPC_VALUE api's.
! 2649: * SEE ALSO
! 2650: * XMLRPC_GetDefaultIdCase ()
! 2651: * SOURCE
! 2652: */
! 2653: XMLRPC_CASE XMLRPC_SetDefaultIdCase(XMLRPC_CASE id_case) {
! 2654: XMLRPC_OPTIONS options = XMLRPC_GetDefaultOptions();
! 2655: options->id_case = id_case;
! 2656: return options->id_case;
! 2657: }
! 2658:
! 2659: /*******/
! 2660:
! 2661: /****f* VALUE/XMLRPC_GetDefaultIdCaseComparison
! 2662: * NAME
! 2663: * XMLRPC_GetDefaultIdCaseComparison
! 2664: * SYNOPSIS
! 2665: * XMLRPC_CASE XMLRPC_GetDefaultIdCaseComparison( )
! 2666: * FUNCTION
! 2667: * Gets default case comparison options used by XMLRPC_VALUE funcs
! 2668: * INPUTS
! 2669: * none
! 2670: * RESULT
! 2671: * XMLRPC_CASE_COMPARISON default
! 2672: * BUGS
! 2673: * Nasty and gross. Should be server specific, but that requires changing all
! 2674: * the XMLRPC_VALUE api's.
! 2675: * SEE ALSO
! 2676: * XMLRPC_SetDefaultIdCaseComparison ()
! 2677: * SOURCE
! 2678: */
! 2679: XMLRPC_CASE_COMPARISON XMLRPC_GetDefaultIdCaseComparison() {
! 2680: XMLRPC_OPTIONS options = XMLRPC_GetDefaultOptions();
! 2681: return options->id_case_compare;
! 2682: }
! 2683:
! 2684: /*******/
! 2685:
! 2686: /****f* VALUE/XMLRPC_SetDefaultIdCaseComparison
! 2687: * NAME
! 2688: * XMLRPC_SetDefaultIdCaseComparison
! 2689: * SYNOPSIS
! 2690: * XMLRPC_CASE XMLRPC_SetDefaultIdCaseComparison( XMLRPC_CASE_COMPARISON id_case_compare )
! 2691: * FUNCTION
! 2692: * Gets default case comparison options used by XMLRPC_VALUE funcs
! 2693: * INPUTS
! 2694: * id_case_compare case comparison rule to set as default
! 2695: * RESULT
! 2696: * XMLRPC_CASE_COMPARISON newly set default
! 2697: * BUGS
! 2698: * Nasty and gross. Should be server specific, but that requires changing all
! 2699: * the XMLRPC_VALUE api's.
! 2700: * SEE ALSO
! 2701: * XMLRPC_GetDefaultIdCaseComparison ()
! 2702: * SOURCE
! 2703: */
! 2704: XMLRPC_CASE_COMPARISON XMLRPC_SetDefaultIdCaseComparison(XMLRPC_CASE_COMPARISON id_case_compare) {
! 2705: XMLRPC_OPTIONS options = XMLRPC_GetDefaultOptions();
! 2706: options->id_case_compare = id_case_compare;
! 2707: return options->id_case_compare;
! 2708: }
! 2709:
! 2710: /*******/
! 2711:
! 2712: /*-*********************************
! 2713: * End XMLRPC General Options funcs *
! 2714: ***********************************/
! 2715:
! 2716:
! 2717: /*-******************
! 2718: * Fault API funcs *
! 2719: ********************/
! 2720:
! 2721: /****f* UTILITY/XMLRPC_UtilityCreateFault
! 2722: * NAME
! 2723: * XMLRPC_UtilityCreateFault
! 2724: * SYNOPSIS
! 2725: * XMLRPC_VALUE XMLRPC_UtilityCreateFault( int fault_code, const char* fault_string )
! 2726: * FUNCTION
! 2727: * generates a struct containing a string member with id "faultString" and an int member
! 2728: * with id "faultCode". When using the xmlrpc xml serialization, these will be translated
! 2729: * to <fault><value><struct>... format.
! 2730: * INPUTS
! 2731: * fault_code application specific error code. can be 0.
! 2732: * fault_string application specific error string. cannot be null.
! 2733: * RESULT
! 2734: * XMLRPC_VALUE a newly created struct vector representing the error, or null on error.
! 2735: * NOTES
! 2736: * This is a utility function. xmlrpc "faults" are not directly represented in this xmlrpc
! 2737: * API or data structures. It is the author's view, that this API is intended for simple
! 2738: * data types, and a "fault" is a complex data type consisting of multiple simple data
! 2739: * types. This function is provided for convenience only, the same result could be
! 2740: * achieved directly by the application.
! 2741: *
! 2742: * This function now supports some "standardized" fault codes, as specified at.
! 2743: * http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php.
! 2744: * If one of these fault codes is received, the description string will automatically
! 2745: * be prefixed with a standard error string and 2 newlines.
! 2746: *
! 2747: * The actual transformation between this complex type and the xml "<fault>" element takes
! 2748: * place in the xmlrpc to xml serialization layer. This step is not performed when using the
! 2749: * simplerpc serialization, meaning that there will be no "<fault>" element in that
! 2750: * serialization. There will simply be a standard struct with 2 child elements.
! 2751: * imho, the "<fault>" element is unnecessary and/or out of place as part of the standard API.
! 2752: *
! 2753: * SOURCE
! 2754: */
! 2755: XMLRPC_VALUE XMLRPC_UtilityCreateFault(int fault_code, const char* fault_string) {
! 2756: XMLRPC_VALUE xOutput = NULL;
! 2757:
! 2758: char* string = NULL;
! 2759: simplestring description;
! 2760: simplestring_init(&description);
! 2761:
! 2762: switch (fault_code) {
! 2763: case xmlrpc_error_parse_xml_syntax:
! 2764: string = xmlrpc_error_parse_xml_syntax_str;
! 2765: break;
! 2766: case xmlrpc_error_parse_unknown_encoding:
! 2767: string = xmlrpc_error_parse_unknown_encoding_str;
! 2768: break;
! 2769: case xmlrpc_error_parse_bad_encoding:
! 2770: string = xmlrpc_error_parse_bad_encoding_str;
! 2771: break;
! 2772: case xmlrpc_error_invalid_xmlrpc:
! 2773: string = xmlrpc_error_invalid_xmlrpc_str;
! 2774: break;
! 2775: case xmlrpc_error_unknown_method:
! 2776: string = xmlrpc_error_unknown_method_str;
! 2777: break;
! 2778: case xmlrpc_error_invalid_params:
! 2779: string = xmlrpc_error_invalid_params_str;
! 2780: break;
! 2781: case xmlrpc_error_internal_server:
! 2782: string = xmlrpc_error_internal_server_str;
! 2783: break;
! 2784: case xmlrpc_error_application:
! 2785: string = xmlrpc_error_application_str;
! 2786: break;
! 2787: case xmlrpc_error_system:
! 2788: string = xmlrpc_error_system_str;
! 2789: break;
! 2790: case xmlrpc_error_transport:
! 2791: string = xmlrpc_error_transport_str;
! 2792: break;
! 2793: }
! 2794:
! 2795: simplestring_add(&description, string);
! 2796:
! 2797: if(string && fault_string) {
! 2798: simplestring_add(&description, "\n\n");
! 2799: }
! 2800: simplestring_add(&description, fault_string);
! 2801:
! 2802:
! 2803: if(description.len) {
! 2804: xOutput = XMLRPC_CreateVector(NULL, xmlrpc_vector_struct);
! 2805:
! 2806: XMLRPC_VectorAppendString (xOutput, "faultString", description.str,
! 2807: description.len);
! 2808: XMLRPC_VectorAppendInt(xOutput, "faultCode", fault_code);
! 2809: }
! 2810:
! 2811: simplestring_free(&description);
! 2812:
! 2813: return xOutput;
! 2814: }
! 2815:
! 2816: /*******/
! 2817:
! 2818:
! 2819: /****f* FAULT/XMLRPC_ValueIsFault
! 2820: * NAME
! 2821: * XMLRPC_ValueIsFault
! 2822: * SYNOPSIS
! 2823: * int XMLRPC_ValueIsFault (XMLRPC_VALUE value)
! 2824: * FUNCTION
! 2825: * Determines if a value encapsulates a fault "object"
! 2826: * INPUTS
! 2827: * value any XMLRPC_VALUE
! 2828: * RESULT
! 2829: * 1 if it is a fault, else 0
! 2830: * SEE ALSO
! 2831: * XMLRPC_ResponseIsFault ()
! 2832: * SOURCE
! 2833: */
! 2834: int XMLRPC_ValueIsFault (XMLRPC_VALUE value) {
! 2835: if( XMLRPC_VectorGetValueWithID(value, "faultCode") &&
! 2836: XMLRPC_VectorGetValueWithID(value, "faultString") ) {
! 2837: return 1;
! 2838: }
! 2839: return 0;
! 2840: }
! 2841: /*******/
! 2842:
! 2843:
! 2844: /****f* FAULT/XMLRPC_ResponseIsFault
! 2845: * NAME
! 2846: * XMLRPC_ResponseIsFault
! 2847: * SYNOPSIS
! 2848: * int XMLRPC_ResponseIsFault (XMLRPC_REQUEST response)
! 2849: * FUNCTION
! 2850: * Determines if a response contains an encapsulated fault "object"
! 2851: * INPUTS
! 2852: * value any XMLRPC_REQUEST. typically of type xmlrpc_request_response
! 2853: * RESULT
! 2854: * 1 if it contains a fault, else 0
! 2855: * SEE ALSO
! 2856: * XMLRPC_ValueIsFault ()
! 2857: * SOURCE
! 2858: */
! 2859: int XMLRPC_ResponseIsFault(XMLRPC_REQUEST response) {
! 2860: return XMLRPC_ValueIsFault( XMLRPC_RequestGetData(response) );
! 2861: }
! 2862:
! 2863: /*******/
! 2864:
! 2865: /****f* FAULT/XMLRPC_GetValueFaultCode
! 2866: * NAME
! 2867: * XMLRPC_GetValueFaultCode
! 2868: * SYNOPSIS
! 2869: * int XMLRPC_GetValueFaultCode (XMLRPC_VALUE value)
! 2870: * FUNCTION
! 2871: * returns fault code from a struct, if any
! 2872: * INPUTS
! 2873: * value XMLRPC_VALUE of type xmlrpc_vector_struct.
! 2874: * RESULT
! 2875: * fault code, else 0.
! 2876: * BUGS
! 2877: * impossible to distinguish faultCode == 0 from faultCode not present.
! 2878: * SEE ALSO
! 2879: * XMLRPC_GetResponseFaultCode ()
! 2880: * SOURCE
! 2881: */
! 2882: int XMLRPC_GetValueFaultCode (XMLRPC_VALUE value) {
! 2883: return XMLRPC_VectorGetIntWithID(value, "faultCode");
! 2884: }
! 2885:
! 2886: /*******/
! 2887:
! 2888: /****f* FAULT/XMLRPC_GetResponseFaultCode
! 2889: * NAME
! 2890: * XMLRPC_GetResponseFaultCode
! 2891: * SYNOPSIS
! 2892: * int XMLRPC_GetResponseFaultCode(XMLRPC_REQUEST response)
! 2893: * FUNCTION
! 2894: * returns fault code from a response, if any
! 2895: * INPUTS
! 2896: * response XMLRPC_REQUEST. typically of type xmlrpc_request_response.
! 2897: * RESULT
! 2898: * fault code, else 0.
! 2899: * BUGS
! 2900: * impossible to distinguish faultCode == 0 from faultCode not present.
! 2901: * SEE ALSO
! 2902: * XMLRPC_GetValueFaultCode ()
! 2903: * SOURCE
! 2904: */
! 2905: int XMLRPC_GetResponseFaultCode(XMLRPC_REQUEST response) {
! 2906: return XMLRPC_GetValueFaultCode( XMLRPC_RequestGetData(response) );
! 2907: }
! 2908:
! 2909: /*******/
! 2910:
! 2911:
! 2912: /****f* FAULT/XMLRPC_GetValueFaultString
! 2913: * NAME
! 2914: * XMLRPC_GetValueFaultString
! 2915: * SYNOPSIS
! 2916: * const char* XMLRPC_GetValueFaultString (XMLRPC_VALUE value)
! 2917: * FUNCTION
! 2918: * returns fault string from a struct, if any
! 2919: * INPUTS
! 2920: * value XMLRPC_VALUE of type xmlrpc_vector_struct.
! 2921: * RESULT
! 2922: * fault string, else 0.
! 2923: * SEE ALSO
! 2924: * XMLRPC_GetResponseFaultString ()
! 2925: * SOURCE
! 2926: */
! 2927: const char* XMLRPC_GetValueFaultString (XMLRPC_VALUE value) {
! 2928: return XMLRPC_VectorGetStringWithID(value, "faultString");
! 2929: }
! 2930:
! 2931: /*******/
! 2932:
! 2933: /****f* FAULT/XMLRPC_GetResponseFaultString
! 2934: * NAME
! 2935: * XMLRPC_GetResponseFaultString
! 2936: * SYNOPSIS
! 2937: * const char* XMLRPC_GetResponseFaultString (XMLRPC_REQUEST response)
! 2938: * FUNCTION
! 2939: * returns fault string from a response, if any
! 2940: * INPUTS
! 2941: * response XMLRPC_REQUEST. typically of type xmlrpc_request_response.
! 2942: * RESULT
! 2943: * fault string, else 0.
! 2944: * SEE ALSO
! 2945: * XMLRPC_GetValueFaultString ()
! 2946: * SOURCE
! 2947: */
! 2948: const char* XMLRPC_GetResponseFaultString (XMLRPC_REQUEST response) {
! 2949: return XMLRPC_GetValueFaultString( XMLRPC_RequestGetData(response) );
! 2950: }
! 2951:
! 2952: /*******/
! 2953:
! 2954:
! 2955: /*-******************
! 2956: * Utility API funcs *
! 2957: ********************/
! 2958:
! 2959:
! 2960: /****f* UTILITY/XMLRPC_Free
! 2961: * NAME
! 2962: * XMLRPC_Free
! 2963: * SYNOPSIS
! 2964: * void XMLRPC_Free(void* mem)
! 2965: * FUNCTION
! 2966: * frees a block of memory allocated by xmlrpc.
! 2967: * INPUTS
! 2968: * mem memory to free
! 2969: * RESULT
! 2970: * void
! 2971: * NOTES
! 2972: * Useful for OS's where memory must be free'd
! 2973: * in the same library in which it is allocated.
! 2974: * SOURCE
! 2975: */
! 2976: void XMLRPC_Free(void* mem) {
! 2977: my_free(mem);
! 2978: }
! 2979:
! 2980: /*******/
! 2981:
! 2982:
! 2983: /****f* UTILITY/XMLRPC_GetVersionString
! 2984: * NAME
! 2985: * XMLRPC_GetVersionString
! 2986: * SYNOPSIS
! 2987: * const char* XMLRPC_GetVersionString()
! 2988: * FUNCTION
! 2989: * returns library version string
! 2990: * INPUTS
! 2991: *
! 2992: * RESULT
! 2993: * const char*
! 2994: * NOTES
! 2995: * SOURCE
! 2996: */
! 2997: const char* XMLRPC_GetVersionString() {
! 2998: return XMLRPC_VERSION_STR;
! 2999: }
! 3000:
! 3001: /*******/
! 3002:
! 3003:
! 3004: /*-**********************
! 3005: * End Utility API funcs *
! 3006: ************************/
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xmlrpc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / xmlrpc / libxmlrpc