Annotation of embedaddon/libpdel/http/servlet/http_servlet_xmlrpc.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: * Copyright (c) 2001-2002 Packet Design, LLC.
! 4: * All rights reserved.
! 5: *
! 6: * Subject to the following obligations and disclaimer of warranty,
! 7: * use and redistribution of this software, in source or object code
! 8: * forms, with or without modifications are expressly permitted by
! 9: * Packet Design; provided, however, that:
! 10: *
! 11: * (i) Any and all reproductions of the source or object code
! 12: * must include the copyright notice above and the following
! 13: * disclaimer of warranties; and
! 14: * (ii) No rights are granted, in any manner or form, to use
! 15: * Packet Design trademarks, including the mark "PACKET DESIGN"
! 16: * on advertising, endorsements, or otherwise except as such
! 17: * appears in the above copyright notice or in the software.
! 18: *
! 19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
! 20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
! 21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
! 22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
! 23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
! 24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
! 25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
! 26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
! 27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
! 28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
! 29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
! 30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
! 31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
! 32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
! 33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
! 35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
! 36: * THE POSSIBILITY OF SUCH DAMAGE.
! 37: *
! 38: * Author: Archie Cobbs <archie@freebsd.org>
! 39: */
! 40:
! 41: #include <sys/types.h>
! 42: #include <sys/param.h>
! 43: #include <sys/stat.h>
! 44:
! 45: #include <netinet/in_systm.h>
! 46: #include <netinet/in.h>
! 47:
! 48: #include <stdlib.h>
! 49: #include <stdio.h>
! 50: #include <string.h>
! 51: #include <stdarg.h>
! 52: #include <syslog.h>
! 53: #include <errno.h>
! 54: #include <assert.h>
! 55:
! 56: #include <openssl/ssl.h>
! 57:
! 58: #include "structs/structs.h"
! 59: #include "structs/type/array.h"
! 60: #include "structs/type/struct.h"
! 61: #include "structs/type/union.h"
! 62: #include "structs/xml.h"
! 63: #include "structs/xmlrpc.h"
! 64:
! 65: #include "http/http_defs.h"
! 66: #include "http/http_server.h"
! 67: #include "http/http_servlet.h"
! 68: #include "http/servlet/xml.h"
! 69: #include "http/servlet/xmlrpc.h"
! 70: #include "util/typed_mem.h"
! 71:
! 72: #define MEM_TYPE "http_servlet_xmlrpc"
! 73:
! 74: #define BOGUS_RTYPE ((const struct structs_type *)0x1832f0ad)
! 75:
! 76: struct xmlrpc_state {
! 77: struct http_servlet *servlet; /* servlet */
! 78: struct http_servlet_xmlrpc_method *methods; /* methods */
! 79: void *arg;
! 80: void (*destroy)(void *);
! 81: http_logger_t *logger;
! 82: };
! 83:
! 84: /* Internal functions */
! 85: static http_servlet_run_t http_servlet_xmlrpc_run;
! 86: static http_servlet_destroy_t http_servlet_xmlrpc_destroy;
! 87:
! 88: static struct http_servlet_xmlrpc_method *http_servlet_xmlrpc_copy_methods(
! 89: const struct http_servlet_xmlrpc_method *methods);
! 90: static void http_servlet_xmlrpc_free_methods(
! 91: struct http_servlet_xmlrpc_method *methods);
! 92:
! 93: static http_servlet_xml_handler_t http_servlet_xmlrpc_handler;
! 94:
! 95: /*
! 96: * Create a new http_servlet_xmlrpc servlet.
! 97: */
! 98: struct http_servlet *
! 99: http_servlet_xmlrpc_create(const struct http_servlet_xmlrpc_info *info,
! 100: void *arg, void (*destroy)(void *))
! 101: {
! 102: struct http_servlet_xml_info xinfo;
! 103: struct http_servlet *servlet;
! 104: struct xmlrpc_state *state;
! 105:
! 106: /* Create servlet */
! 107: if ((servlet = MALLOC(MEM_TYPE, sizeof(*servlet))) == NULL)
! 108: return (NULL);
! 109: memset(servlet, 0, sizeof(*servlet));
! 110: servlet->run = http_servlet_xmlrpc_run;
! 111: servlet->destroy = http_servlet_xmlrpc_destroy;
! 112:
! 113: /* Create servlet state structure */
! 114: if ((state = MALLOC(MEM_TYPE, sizeof(*state))) == NULL)
! 115: goto fail;
! 116: memset(state, 0, sizeof(*state));
! 117: state->arg = arg;
! 118: state->destroy = destroy;
! 119: state->logger = info->logger;
! 120:
! 121: /* Copy method list */
! 122: if ((state->methods
! 123: = http_servlet_xmlrpc_copy_methods(info->methods)) == NULL)
! 124: goto fail;
! 125:
! 126: /* Set up info for the more general http_servlet_xml servlet */
! 127: memset(&xinfo, 0, sizeof(xinfo));
! 128: xinfo.handler = http_servlet_xmlrpc_handler;
! 129: xinfo.ptag = XML_RPC_REQUEST_TAG;
! 130: xinfo.ptype = &structs_type_xmlrpc_request;
! 131: xinfo.rtag = XML_RPC_REPLY_TAG;
! 132: xinfo.rtype = &structs_type_xmlrpc_response;
! 133: xinfo.allow_post = 1;
! 134: xinfo.allow_get = 0;
! 135: xinfo.logger = info->logger;
! 136: xinfo.flags = STRUCTS_XML_FULL;
! 137:
! 138: /* Create "inner" XML servlet using 'xinfo' */
! 139: if ((state->servlet = http_servlet_xml_create(&xinfo,
! 140: state, NULL)) == NULL)
! 141: goto fail;
! 142:
! 143: /* Done */
! 144: servlet->arg = state;
! 145: return (servlet);
! 146:
! 147: fail:
! 148: /* Clean up after failure */
! 149: if (state != NULL) {
! 150: if (state->methods != NULL)
! 151: http_servlet_xmlrpc_free_methods(state->methods);
! 152: FREE(MEM_TYPE, state);
! 153: }
! 154: FREE(MEM_TYPE, servlet);
! 155: return (NULL);
! 156: }
! 157:
! 158: static int
! 159: http_servlet_xmlrpc_run(struct http_servlet *servlet,
! 160: struct http_request *req, struct http_response *resp)
! 161: {
! 162: struct xmlrpc_state *const state = servlet->arg;
! 163:
! 164: return ((*state->servlet->run)(state->servlet, req, resp));
! 165: }
! 166:
! 167: static void
! 168: http_servlet_xmlrpc_destroy(struct http_servlet *servlet)
! 169: {
! 170: struct xmlrpc_state *const state = servlet->arg;
! 171:
! 172: /* Destroy 'inner' servlet */
! 173: http_server_destroy_servlet(&state->servlet);
! 174:
! 175: /* Destroy 'outer' servlet */
! 176: if (state->destroy != NULL)
! 177: (*state->destroy)(state->arg);
! 178: http_servlet_xmlrpc_free_methods(state->methods);
! 179: FREE(MEM_TYPE, state);
! 180: FREE(MEM_TYPE, servlet);
! 181: }
! 182:
! 183: /*
! 184: * Our "wrapper" handler that converts an XML-RPC request/reply
! 185: * into a more normal request/reply.
! 186: */
! 187: static void *
! 188: http_servlet_xmlrpc_handler(void *arg, struct http_request *req,
! 189: const void *payload, const char *pattrs, char **rattrsp,
! 190: const char *mtype)
! 191: {
! 192: const struct xmlrpc_state *const state = arg;
! 193: const struct structs_type *const xrept = &structs_type_xmlrpc_response;
! 194: const struct http_servlet_xmlrpc_method *method;
! 195: const struct xmlrpc_request *const xreq = payload; /* XML-RPC request */
! 196: void **params = NULL; /* parameter list for handler */
! 197: void *reply = NULL; /* reply returned by handler */
! 198: struct xmlrpc_response_union *xreply = NULL; /* XML-RPC reply */
! 199: const struct structs_type *rtype = NULL;/* handlers' reply type */
! 200: void *ret = NULL; /* this func's return value */
! 201: int faulted = 0; /* handler returned fault */
! 202: char *errbuf = NULL; /* error message, if any */
! 203: int exploded_params = 0; /* exploded parameters */
! 204: int exploded_response = 0; /* exploded response */
! 205: int errno_save; /* saved errno value */
! 206: u_int i;
! 207:
! 208: /* Find method */
! 209: for (method = state->methods; method->name != NULL
! 210: && *method->name != '\0'
! 211: && strcmp(method->name, xreq->methodName) != 0; method++);
! 212: if (method->name == NULL) {
! 213: ASPRINTF(TYPED_MEM_TEMP, &errbuf,
! 214: "method name \"%s\" not recognized", xreq->methodName);
! 215: if (errbuf == NULL)
! 216: goto fail;
! 217: (*state->logger)(LOG_ERR, "XML-RPC: %s", errbuf);
! 218: errno = ENOSYS;
! 219: goto null_reply;
! 220: }
! 221: exploded_params = (method->ptypes == NULL);
! 222:
! 223: /* Check number of arguments */
! 224: if (xreq->params.length < method->min_params
! 225: || xreq->params.length > method->max_params) {
! 226: ASPRINTF(TYPED_MEM_TEMP, &errbuf,
! 227: "%d parameter(s) present for method \"%s\" which takes"
! 228: " between %u and %u parameter(s)", xreq->params.length,
! 229: xreq->methodName, method->min_params, method->max_params);
! 230: if (errbuf == NULL)
! 231: goto fail;
! 232: (*state->logger)(LOG_ERR, "XML-RPC: %s", errbuf);
! 233: errno = EINVAL;
! 234: goto null_reply;
! 235: }
! 236:
! 237: /* Get parameters from the XML-RPC request */
! 238: if ((params = MALLOC(TYPED_MEM_TEMP,
! 239: xreq->params.length * sizeof(*params))) == NULL)
! 240: goto null_reply;
! 241: memset(params, 0, xreq->params.length * sizeof(*params));
! 242: for (i = 0; i < xreq->params.length; i++) {
! 243: char ebuf[256];
! 244:
! 245: /* Optionally leave parameter list "exploded" */
! 246: if (exploded_params) {
! 247: params[i] = &xreq->params.elems[i].value;
! 248: continue;
! 249: }
! 250:
! 251: /* "Compact" this parameter using structs_xmlrpc2struct() */
! 252: if ((params[i] = MALLOC(TYPED_MEM_TEMP,
! 253: method->ptypes[i]->size)) == NULL)
! 254: break;
! 255: if (structs_init(method->ptypes[i], NULL, params[i]) == -1) {
! 256: FREE(TYPED_MEM_TEMP, params[i]);
! 257: params[i] = NULL;
! 258: break;
! 259: }
! 260: if (structs_xmlrpc2struct(&structs_type_xmlrpc_value,
! 261: &xreq->params.elems[i].value, NULL, method->ptypes[i],
! 262: params[i], NULL, ebuf, sizeof(ebuf)) == -1) {
! 263: errno_save = errno;
! 264: ASPRINTF(TYPED_MEM_TEMP, &errbuf, "parameter #%d of"
! 265: " method \"%s\" has an invalid type or value: %s",
! 266: i + 1, xreq->methodName, ebuf);
! 267: if (errbuf == NULL)
! 268: goto fail;
! 269: (*state->logger)(LOG_ERR, "XML-RPC: %s", errbuf);
! 270: errno = errno_save;
! 271: break;
! 272: }
! 273: }
! 274: if (i < xreq->params.length)
! 275: goto null_reply;
! 276:
! 277: /* Invoke our simplified handler */
! 278: rtype = BOGUS_RTYPE;
! 279: reply = (*method->handler)(state->arg, xreq->methodName, req,
! 280: xreq->params.length, (const void **)params, TYPED_MEM_TEMP,
! 281: &rtype, &faulted);
! 282: if (reply == NULL) {
! 283: errno_save = errno;
! 284: (*state->logger)(LOG_ERR,
! 285: "XML-RPC: handler for \"%s\" failed: %s",
! 286: xreq->methodName, strerror(errno));
! 287: errno = errno_save;
! 288: goto null_reply;
! 289: }
! 290:
! 291: /* Sanity check returned reply type */
! 292: if (rtype == BOGUS_RTYPE) {
! 293: ASPRINTF(TYPED_MEM_TEMP, &errbuf, "handler didn't set 'rtype'");
! 294: if (errbuf == NULL)
! 295: goto fail;
! 296: (*state->logger)(LOG_ERR, "XML-RPC: handler for"
! 297: " \"%s\" failed: %s", xreq->methodName, errbuf);
! 298: errno = ECONNABORTED;
! 299: goto null_reply;
! 300: }
! 301: if (faulted && rtype != &structs_type_xmlrpc_compact_fault) {
! 302: ASPRINTF(TYPED_MEM_TEMP, &errbuf, "handler returned a fault"
! 303: " but didn't set 'rtype' to"
! 304: " &structs_type_xmlrpc_compact_fault");
! 305: if (errbuf == NULL)
! 306: goto fail;
! 307: (*state->logger)(LOG_ERR, "XML-RPC: handler for"
! 308: " \"%s\" failed: %s", xreq->methodName, errbuf);
! 309: errno = ECONNABORTED;
! 310: goto null_reply;
! 311: }
! 312:
! 313: /* Check for "exploded" return value */
! 314: if (rtype == NULL) {
! 315: rtype = &structs_type_xmlrpc_value;
! 316: exploded_response = 1;
! 317: }
! 318:
! 319: null_reply:
! 320: /* Save errno (used to create the fault when/if reply == NULL) */
! 321: errno_save = errno;
! 322:
! 323: /* Create the XML-RPC reply */
! 324: if ((xreply = MALLOC(mtype, sizeof(*xreply))) == NULL)
! 325: goto fail;
! 326: if (structs_init(xrept, NULL, xreply) == -1) {
! 327: FREE(mtype, xreply);
! 328: xreply = NULL;
! 329: goto fail;
! 330: }
! 331:
! 332: /* If handler returned NULL, create a fault structure using errno */
! 333: if (reply == NULL) {
! 334: struct xmlrpc_compact_fault *fault;
! 335:
! 336: /* Create an initialize fault structure from error string */
! 337: if ((fault = MALLOC(TYPED_MEM_TEMP, sizeof(*fault))) == NULL)
! 338: goto fail;
! 339: if (structs_init(&structs_type_xmlrpc_compact_fault,
! 340: NULL, fault) == -1) {
! 341: FREE(TYPED_MEM_TEMP, fault);
! 342: goto fail;
! 343: }
! 344: fault->faultCode = errno;
! 345: if (structs_set_string(&structs_type_xmlrpc_compact_fault,
! 346: "faultString", errbuf != NULL ? errbuf :
! 347: strerror(errno_save), fault, NULL, 0) == -1)
! 348: ; /* too bad, just ignore error */
! 349:
! 350: /* Now pretend like handler() itself returned the fault */
! 351: reply = fault;
! 352: rtype = &structs_type_xmlrpc_compact_fault;
! 353: faulted = 1;
! 354: }
! 355:
! 356: /* Set fault if error, otherwise set reply as XML-RPC reply parameter */
! 357: if (faulted) {
! 358: if (structs_struct2xmlrpc(rtype, reply,
! 359: NULL, xrept, xreply, "fault.value") == -1)
! 360: goto fail;
! 361: } else {
! 362: if (structs_array_insert(xrept, "params", 0, xreply) == -1)
! 363: goto fail;
! 364: if (exploded_response) {
! 365: if (structs_set(xrept, reply,
! 366: "params.0.value", xreply) == -1)
! 367: goto fail;
! 368: } else if (structs_struct2xmlrpc(rtype, reply, NULL,
! 369: xrept, xreply, "params.0.value") == -1)
! 370: goto fail;
! 371: }
! 372:
! 373: /* Done, so return reply */
! 374: ret = xreply;
! 375: xreply = NULL;
! 376:
! 377: fail:
! 378: /* Cleanup and exit */
! 379: errno_save = errno;
! 380: if (params != NULL) {
! 381: if (!exploded_params) {
! 382: for (i = 0; i < xreq->params.length; i++) {
! 383: if (params[i] != NULL) {
! 384: structs_free(method->ptypes[i],
! 385: NULL, params[i]);
! 386: FREE(TYPED_MEM_TEMP, params[i]);
! 387: }
! 388: }
! 389: }
! 390: FREE(TYPED_MEM_TEMP, params);
! 391: }
! 392: if (reply != NULL) {
! 393: structs_free(rtype, NULL, reply);
! 394: FREE(TYPED_MEM_TEMP, reply);
! 395: }
! 396: if (xreply != NULL) {
! 397: structs_free(xrept, NULL, xreply);
! 398: FREE(mtype, xreply);
! 399: }
! 400: if (errbuf != NULL)
! 401: FREE(TYPED_MEM_TEMP, errbuf);
! 402: errno = errno_save;
! 403: return (ret);
! 404: }
! 405:
! 406: /*
! 407: * Copy an XML-RPC method list
! 408: */
! 409: static struct http_servlet_xmlrpc_method *
! 410: http_servlet_xmlrpc_copy_methods(
! 411: const struct http_servlet_xmlrpc_method *const methods)
! 412: {
! 413: const struct http_servlet_xmlrpc_method *method;
! 414: struct http_servlet_xmlrpc_method *mcopy;
! 415: int num;
! 416: int i;
! 417:
! 418: /* Count the number of methods */
! 419: for (num = 0, method = methods; method->name != NULL; num++, method++);
! 420:
! 421: /* Allocate an array */
! 422: if ((mcopy = MALLOC(MEM_TYPE, (num + 1) * sizeof(*mcopy))) == NULL)
! 423: return (NULL);
! 424: memset(mcopy, 0, (num + 1) * sizeof(*mcopy));
! 425:
! 426: /* Make a 'deep' copy (except for structs types XXX) */
! 427: for (i = 0; i < num; i++) {
! 428: const struct http_servlet_xmlrpc_method *const orig
! 429: = &methods[i];
! 430: struct http_servlet_xmlrpc_method *const copy = &mcopy[i];
! 431:
! 432: /* Copy all except the malloc'd stuff */
! 433: *copy = *orig;
! 434: copy->name = NULL;
! 435: copy->ptypes = NULL;
! 436:
! 437: /* Copy types array */
! 438: if (orig->ptypes != NULL) {
! 439: if ((copy->ptypes = MALLOC(MEM_TYPE, copy->max_params
! 440: * sizeof(*copy->ptypes))) == NULL) {
! 441: http_servlet_xmlrpc_free_methods(mcopy);
! 442: return (NULL);
! 443: }
! 444: memcpy(copy->ptypes, orig->ptypes,
! 445: copy->max_params * sizeof(*copy->ptypes));
! 446: }
! 447:
! 448: /* Copy name */
! 449: if ((copy->name = STRDUP(MEM_TYPE, orig->name)) == NULL) {
! 450: FREE(MEM_TYPE, copy->ptypes);
! 451: http_servlet_xmlrpc_free_methods(mcopy);
! 452: return (NULL);
! 453: }
! 454: }
! 455:
! 456: /* Done */
! 457: return (mcopy);
! 458: }
! 459:
! 460: static void
! 461: http_servlet_xmlrpc_free_methods(struct http_servlet_xmlrpc_method *methods)
! 462: {
! 463: const struct http_servlet_xmlrpc_method *method;
! 464: int i;
! 465:
! 466: for (i = 0, method = methods; method->name != NULL; i++, method++) {
! 467: FREE(MEM_TYPE, (char *)method->name);
! 468: FREE(MEM_TYPE, method->ptypes);
! 469: }
! 470: FREE(MEM_TYPE, methods);
! 471: }
! 472:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to http_servlet_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 / libpdel / http / servlet