Annotation of embedaddon/libpdel/structs/structs_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 <net/ethernet.h>
! 43:
! 44: #include <stdlib.h>
! 45: #include <stddef.h>
! 46: #include <stdio.h>
! 47: #include <stdarg.h>
! 48: #include <assert.h>
! 49: #include <ctype.h>
! 50: #include <syslog.h>
! 51: #include <string.h>
! 52: #include <errno.h>
! 53:
! 54: #include "structs/structs.h"
! 55: #include "structs/type/array.h"
! 56: #include "structs/type/struct.h"
! 57: #include "structs/type/union.h"
! 58: #include "structs/type/string.h"
! 59: #include "structs/type/float.h"
! 60: #include "structs/type/boolean.h"
! 61: #include "structs/type/data.h"
! 62: #include "structs/type/time.h"
! 63: #include "structs/type/int.h"
! 64: #include "structs/xml.h"
! 65: #include "structs/xmlrpc.h"
! 66: #include "util/typed_mem.h"
! 67:
! 68: /************************************************************************
! 69: string
! 70: ************************************************************************/
! 71:
! 72: static const struct structs_type string_type
! 73: = STRUCTS_STRING_TYPE("xmlrpc_string", 0);
! 74:
! 75: /************************************************************************
! 76: base64
! 77: ************************************************************************/
! 78:
! 79: static const struct structs_type base64_type
! 80: = STRUCTS_DATA_TYPE(NULL, "xmlrpc_base64");
! 81:
! 82: /************************************************************************
! 83: array data
! 84: ************************************************************************/
! 85:
! 86: static const struct structs_type array_data_type
! 87: = STRUCTS_ARRAY_TYPE(&structs_type_xmlrpc_value,
! 88: "xmlrpc_array", "value");
! 89:
! 90: /************************************************************************
! 91: array
! 92: ************************************************************************/
! 93:
! 94: static const struct structs_field array_fields[] = {
! 95: STRUCTS_STRUCT_FIELD(xmlrpc_array, data, &array_data_type),
! 96: STRUCTS_STRUCT_FIELD_END
! 97: };
! 98: const struct structs_type structs_type_xmlrpc_array
! 99: = STRUCTS_STRUCT_TYPE(xmlrpc_array, &array_fields);
! 100:
! 101: /************************************************************************
! 102: member
! 103: ************************************************************************/
! 104:
! 105: static const struct structs_field member_fields[] = {
! 106: STRUCTS_STRUCT_FIELD(xmlrpc_member, name, &string_type),
! 107: STRUCTS_STRUCT_FIELD(xmlrpc_member, value, &structs_type_xmlrpc_value),
! 108: STRUCTS_STRUCT_FIELD_END
! 109: };
! 110: const struct structs_type structs_type_xmlrpc_member
! 111: = STRUCTS_STRUCT_TYPE(xmlrpc_member, &member_fields);
! 112:
! 113: /************************************************************************
! 114: struct
! 115: ************************************************************************/
! 116:
! 117: const struct structs_type structs_type_xmlrpc_struct
! 118: = STRUCTS_ARRAY_TYPE(&structs_type_xmlrpc_member,
! 119: "xmlrpc_struct", "member");
! 120:
! 121: /************************************************************************
! 122: value
! 123: ************************************************************************/
! 124:
! 125: static const struct structs_ufield value_fields[] = {
! 126: STRUCTS_UNION_FIELD(string, &string_type),
! 127: STRUCTS_UNION_FIELD(i4, &structs_type_int32),
! 128: STRUCTS_UNION_FIELD(int, &structs_type_int32),
! 129: STRUCTS_UNION_FIELD(boolean, &structs_type_boolean_char_01),
! 130: STRUCTS_UNION_FIELD(double, &structs_type_double),
! 131: STRUCTS_UNION_FIELD(dateTime.iso8601, &structs_type_time_iso8601),
! 132: STRUCTS_UNION_FIELD(base64, &base64_type),
! 133: STRUCTS_UNION_FIELD(struct, &structs_type_xmlrpc_struct),
! 134: STRUCTS_UNION_FIELD(array, &structs_type_xmlrpc_array),
! 135: STRUCTS_UNION_FIELD_END
! 136: };
! 137: const struct structs_type structs_type_xmlrpc_value
! 138: = STRUCTS_UNION_TYPE(xmlrpc_value, &value_fields);
! 139:
! 140: /************************************************************************
! 141: param
! 142: ************************************************************************/
! 143:
! 144: static const struct structs_field param_fields[] = {
! 145: STRUCTS_STRUCT_FIELD(xmlrpc_param, value, &structs_type_xmlrpc_value),
! 146: STRUCTS_STRUCT_FIELD_END
! 147: };
! 148: static const struct structs_type param_type
! 149: = STRUCTS_STRUCT_TYPE(xmlrpc_param, ¶m_fields);
! 150:
! 151: /************************************************************************
! 152: params
! 153: ************************************************************************/
! 154:
! 155: static const struct structs_type params_type
! 156: = STRUCTS_ARRAY_TYPE(¶m_type, "xmlrpc_params", "param");
! 157:
! 158: /************************************************************************
! 159: fault
! 160: ************************************************************************/
! 161:
! 162: static const struct structs_field fault_fields[] = {
! 163: STRUCTS_STRUCT_FIELD(xmlrpc_fault, value, &structs_type_xmlrpc_value),
! 164: STRUCTS_STRUCT_FIELD_END
! 165: };
! 166: const struct structs_type structs_type_xmlrpc_fault
! 167: = STRUCTS_STRUCT_TYPE(xmlrpc_fault, &fault_fields);
! 168:
! 169: /************************************************************************
! 170: request
! 171: ************************************************************************/
! 172:
! 173: static const struct structs_field request_fields[] = {
! 174: STRUCTS_STRUCT_FIELD(xmlrpc_request, methodName, &string_type),
! 175: STRUCTS_STRUCT_FIELD(xmlrpc_request, params, ¶ms_type),
! 176: STRUCTS_STRUCT_FIELD_END
! 177: };
! 178: const struct structs_type structs_type_xmlrpc_request
! 179: = STRUCTS_STRUCT_TYPE(xmlrpc_request, &request_fields);
! 180:
! 181: /************************************************************************
! 182: response
! 183: ************************************************************************/
! 184:
! 185: static const struct structs_ufield response_fields[] = {
! 186: STRUCTS_UNION_FIELD(params, ¶ms_type),
! 187: STRUCTS_UNION_FIELD(fault, &structs_type_xmlrpc_fault),
! 188: STRUCTS_UNION_FIELD_END
! 189: };
! 190: const struct structs_type structs_type_xmlrpc_response
! 191: = STRUCTS_UNION_TYPE(xmlrpc_response, &response_fields);
! 192:
! 193: /************************************************************************
! 194: fault (compact form)
! 195: ************************************************************************/
! 196:
! 197: static const struct structs_type fault_string_type
! 198: = STRUCTS_STRING_TYPE("xmlrpc_fault_string", 0);
! 199:
! 200: static const struct structs_field compact_fault_fields[] = {
! 201: STRUCTS_STRUCT_FIELD(xmlrpc_compact_fault,
! 202: faultCode, &structs_type_int32),
! 203: STRUCTS_STRUCT_FIELD(xmlrpc_compact_fault,
! 204: faultString, &fault_string_type),
! 205: STRUCTS_STRUCT_FIELD_END
! 206: };
! 207: const struct structs_type structs_type_xmlrpc_compact_fault
! 208: = STRUCTS_STRUCT_TYPE(xmlrpc_compact_fault, &compact_fault_fields);
! 209:
! 210: /************************************************************************
! 211: FUNCTIONS
! 212: ************************************************************************/
! 213:
! 214: /*
! 215: * Create an XML-RPC request structure with the given parameters.
! 216: */
! 217: struct xmlrpc_request *
! 218: structs_xmlrpc_build_request(const char *mtype, const char *methodName,
! 219: u_int nparams, const struct structs_type **types, const void **datas)
! 220: {
! 221: const struct structs_type *const xtype = &structs_type_xmlrpc_request;
! 222: struct xmlrpc_request *xreq;
! 223: u_int i;
! 224:
! 225: /* Create new XML-RPC request structure */
! 226: if ((xreq = MALLOC(mtype, sizeof(*xreq))) == NULL)
! 227: return (NULL);
! 228: if (structs_init(xtype, NULL, xreq) == -1) {
! 229: FREE(mtype, xreq);
! 230: return (NULL);
! 231: }
! 232:
! 233: /* Set method name */
! 234: if (structs_set_string(xtype,
! 235: "methodName", methodName, xreq, NULL, 0) == -1)
! 236: goto fail;
! 237:
! 238: /* Copy parameters into request */
! 239: for (i = 0; i < nparams; i++) {
! 240: const void *const data = datas[i];
! 241: char xname[32];
! 242:
! 243: /* Add another element to params array */
! 244: if (structs_array_insert(xtype, "params", i, xreq) == -1)
! 245: goto fail;
! 246: snprintf(xname, sizeof(xname), "params.%u.value", i);
! 247:
! 248: /* Explode parameter unless already exploded */
! 249: if (types != NULL) {
! 250: if (structs_struct2xmlrpc(types[i], data, NULL,
! 251: xtype, xreq, xname) == -1)
! 252: goto fail;
! 253: } else {
! 254: if (structs_set(&structs_type_xmlrpc_value,
! 255: data, xname, xreq) == -1)
! 256: goto fail;
! 257: }
! 258: }
! 259:
! 260: /* Done */
! 261: return (xreq);
! 262:
! 263: fail:
! 264: structs_free(xtype, NULL, xreq);
! 265: FREE(mtype, xreq);
! 266: return (NULL);
! 267: }
! 268:
! 269: /*
! 270: * Create an XML-RPC response structure with the given return value.
! 271: */
! 272: struct xmlrpc_response_union *
! 273: structs_xmlrpc_build_response(const char *mtype,
! 274: const struct structs_type *type, const void *data)
! 275: {
! 276: const struct structs_type *const xtype = &structs_type_xmlrpc_response;
! 277: struct xmlrpc_response_union *xrep;
! 278:
! 279: /* Create new XML-RPC response structure */
! 280: if ((xrep = MALLOC(mtype, sizeof(*xrep))) == NULL)
! 281: return (NULL);
! 282: if (structs_init(xtype, NULL, xrep) == -1) {
! 283: FREE(mtype, xrep);
! 284: return (NULL);
! 285: }
! 286:
! 287: /* Add a single parameter */
! 288: if (structs_array_insert(xtype, "params", 0, xrep) == -1)
! 289: goto fail;
! 290:
! 291: /* Copy parameter, optionally compacting it */
! 292: if (type != NULL) {
! 293: if (structs_struct2xmlrpc(type, data,
! 294: NULL, xtype, xrep, "params.0.value") == -1)
! 295: goto fail;
! 296: } else {
! 297: if (structs_set(&structs_type_xmlrpc_value,
! 298: data, "params.0.value", xrep) == -1)
! 299: goto fail;
! 300: }
! 301:
! 302: /* Done */
! 303: return (xrep);
! 304:
! 305: fail:
! 306: structs_free(xtype, NULL, xrep);
! 307: FREE(mtype, xrep);
! 308: return (NULL);
! 309: }
! 310:
! 311: /*
! 312: * Create an XML-RPC fault response structure with the given fault.
! 313: */
! 314: struct xmlrpc_response_union *
! 315: structs_xmlrpc_build_fault_response(const char *mtype,
! 316: const struct xmlrpc_compact_fault *fault)
! 317: {
! 318: const struct structs_type *const xtype = &structs_type_xmlrpc_response;
! 319: struct xmlrpc_response_union *xrep;
! 320:
! 321: /* Create new XML-RPC response structure */
! 322: if ((xrep = MALLOC(mtype, sizeof(*xrep))) == NULL)
! 323: return (NULL);
! 324: if (structs_init(xtype, NULL, xrep) == -1) {
! 325: FREE(mtype, xrep);
! 326: return (NULL);
! 327: }
! 328:
! 329: /* Set fault */
! 330: if (structs_struct2xmlrpc(&structs_type_xmlrpc_compact_fault,
! 331: fault, NULL, xtype, xrep, "fault.value") == -1)
! 332: goto fail;
! 333:
! 334: /* Done */
! 335: return (xrep);
! 336:
! 337: fail:
! 338: structs_free(xtype, NULL, xrep);
! 339: FREE(mtype, xrep);
! 340: return (NULL);
! 341: }
! 342:
! 343: /*
! 344: * Copy the contents of a normal structure into an XML-RPC "value" structure.
! 345: */
! 346: int
! 347: structs_struct2xmlrpc(const struct structs_type *type,
! 348: const void *data, const char *sname,
! 349: const struct structs_type *xtype, void *xdata, const char *xname)
! 350: {
! 351:
! 352: /* Find source and dest data */
! 353: if ((type = structs_find(type, sname, (void **)&data, 0)) == NULL)
! 354: return (-1);
! 355: if ((xtype = structs_find(xtype, xname, &xdata, 1)) == NULL)
! 356: return (-1);
! 357:
! 358: /* Destination type must always be an XML-RPC value */
! 359: if (xtype != &structs_type_xmlrpc_value) {
! 360: errno = EINVAL;
! 361: return (-1);
! 362: }
! 363:
! 364: /* Dereference through pointer(s) */
! 365: while (type->tclass == STRUCTS_TYPE_POINTER) {
! 366: type = type->args[0].v;
! 367: data = *((void **)data);
! 368: }
! 369:
! 370: switch (type->tclass) {
! 371: case STRUCTS_TYPE_PRIMITIVE:
! 372: {
! 373: const char *xprim;
! 374: char *s;
! 375:
! 376: /* Get corresponding XML-RPC primitive type */
! 377: if (type == &structs_type_int32
! 378: || (sizeof(int) == 4 && type == &structs_type_int))
! 379: xprim = "i4";
! 380: else if (strcmp(type->name, "float") == 0
! 381: || strcmp(type->name, "double") == 0)
! 382: xprim = "double";
! 383: else if (strcmp(type->name, "boolean") == 0)
! 384: xprim = "boolean";
! 385: else if (type == &structs_type_time_iso8601)
! 386: xprim = "dateTime.iso8601";
! 387: else if (strcmp(type->name, "data") == 0
! 388: && type->args[0].v == NULL) /* XXX same charmap */
! 389: xprim = "base64";
! 390: else
! 391: xprim = "string";
! 392:
! 393: /* Get primitive value as a string */
! 394: if ((s = structs_get_string(type,
! 395: NULL, data, TYPED_MEM_TEMP)) == NULL)
! 396: return (-1);
! 397:
! 398: /* Set primitive value as a string */
! 399: if (structs_set_string(xtype,
! 400: xprim, s, xdata, NULL, 0) == -1) {
! 401: FREE(TYPED_MEM_TEMP, s);
! 402: return (-1);
! 403: }
! 404: FREE(TYPED_MEM_TEMP, s);
! 405: break;
! 406: }
! 407: case STRUCTS_TYPE_ARRAY:
! 408: {
! 409: const struct structs_type *const etype = type->args[0].v;
! 410: const struct structs_array *const ary = data;
! 411: u_int i;
! 412:
! 413: /* Reset destination value to be an empty array */
! 414: if (structs_array_reset(xtype, "array.data", xdata) == -1)
! 415: return (-1);
! 416:
! 417: /* Copy over each element in the array */
! 418: for (i = 0; i < ary->length; i++) {
! 419: char buf[32];
! 420:
! 421: /* Add a new element to the dest array */
! 422: if (structs_array_insert(xtype,
! 423: "array.data", i, xdata) == -1)
! 424: return (-1);
! 425:
! 426: /* Set its value */
! 427: snprintf(buf, sizeof(buf), "array.data.%u", i);
! 428: if (structs_struct2xmlrpc(etype,
! 429: (char *)ary->elems + (i * etype->size), NULL,
! 430: xtype, xdata, buf) == -1)
! 431: return (-1);
! 432: }
! 433: break;
! 434: }
! 435: case STRUCTS_TYPE_FIXEDARRAY:
! 436: {
! 437: const struct structs_type *const etype = type->args[0].v;
! 438: const u_int length = type->args[2].i;
! 439: u_int i;
! 440:
! 441: /* Reset destination value to be an empty array */
! 442: if (structs_array_reset(xtype, "array.data", xdata) == -1)
! 443: return (-1);
! 444:
! 445: /* Copy over each element in the array */
! 446: for (i = 0; i < length; i++) {
! 447: char buf[32];
! 448:
! 449: /* Add a new element to the dest array */
! 450: if (structs_array_insert(xtype,
! 451: "array.data", i, xdata) == -1)
! 452: return (-1);
! 453:
! 454: /* Set its value */
! 455: snprintf(buf, sizeof(buf), "array.data.%u", i);
! 456: if (structs_struct2xmlrpc(etype,
! 457: (char *)data + (i * etype->size), NULL,
! 458: xtype, xdata, buf) == -1)
! 459: return (-1);
! 460: }
! 461: break;
! 462: }
! 463: case STRUCTS_TYPE_STRUCTURE:
! 464: {
! 465: const struct structs_field *field = type->args[0].v;
! 466: u_int i;
! 467:
! 468: /* Reset destination value to be an empty struct,
! 469: which really means just an empty array of members. */
! 470: if (structs_array_reset(xtype, "struct", xdata) == -1)
! 471: return (-1);
! 472:
! 473: /* Copy over each field in the structure to the member array */
! 474: for (i = 0; field->name != NULL; i++, field++) {
! 475: char buf[32];
! 476:
! 477: /* Add a new element to the member array */
! 478: if (structs_array_insert(xtype,
! 479: "struct", i, xdata) == -1)
! 480: return (-1);
! 481:
! 482: /* Set the new member's name */
! 483: snprintf(buf, sizeof(buf), "struct.%u.name", i);
! 484: if (structs_set_string(xtype,
! 485: buf, field->name, xdata, NULL, 0) == -1)
! 486: return (-1);
! 487:
! 488: /* Set the new member's value */
! 489: snprintf(buf, sizeof(buf), "struct.%u.value", i);
! 490: if (structs_struct2xmlrpc(field->type,
! 491: (char *)data + field->offset, NULL,
! 492: xtype, xdata, buf) == -1)
! 493: return (-1);
! 494: }
! 495: break;
! 496: }
! 497: case STRUCTS_TYPE_UNION:
! 498: {
! 499: const struct structs_ufield *const fields = type->args[0].v;
! 500: const struct structs_union *const un = data;
! 501: const struct structs_ufield *field;
! 502:
! 503: /* Reset destination value to be an empty struct,
! 504: which really means just an empty array of members. */
! 505: if (structs_array_reset(xtype, "struct", xdata) == -1)
! 506: return (-1);
! 507:
! 508: /* Find field */
! 509: for (field = fields; field->name != NULL
! 510: && strcmp(un->field_name, field->name) != 0; field++);
! 511: if (field->name == NULL) {
! 512: assert(0);
! 513: errno = EINVAL;
! 514: return (-1);
! 515: }
! 516:
! 517: /* Add a new element to the member array */
! 518: if (structs_array_insert(xtype, "struct", 0, xdata) == -1)
! 519: return (-1);
! 520:
! 521: /* Set the new member's name */
! 522: if (structs_set_string(xtype, "struct.0.name",
! 523: field->name, xdata, NULL, 0) == -1)
! 524: return (-1);
! 525:
! 526: /* Set the new member's value */
! 527: if (structs_struct2xmlrpc(field->type,
! 528: un->un, NULL, xtype, xdata, "struct.0.value") == -1)
! 529: return (-1);
! 530: break;
! 531: }
! 532: default:
! 533: assert(0);
! 534: return (-1);
! 535: }
! 536: return (0);
! 537: }
! 538:
! 539: /*
! 540: * Copy the contents of an XML-RPC "value" structure into a normal structure.
! 541: */
! 542: int
! 543: structs_xmlrpc2struct(const struct structs_type *xtype, const void *xdata,
! 544: const char *xname, const struct structs_type *type,
! 545: void *data, const char *sname, char *ebuf, size_t emax)
! 546: {
! 547: const struct structs_union *xun;
! 548:
! 549: /* Safety */
! 550: snprintf(ebuf, emax, "Unknown error");
! 551:
! 552: /* Find source and dest data */
! 553: if ((xtype = structs_find(xtype, xname, (void **)&xdata, 0)) == NULL)
! 554: goto fail_errno;
! 555: if ((type = structs_find(type, sname, &data, 1)) == NULL)
! 556: goto fail_errno;
! 557:
! 558: /* Source type must always be an XML-RPC value */
! 559: if (xtype != &structs_type_xmlrpc_value) {
! 560: snprintf(ebuf, emax, "xtype != &structs_type_xmlrpc_value");
! 561: errno = EINVAL;
! 562: return (-1);
! 563: }
! 564: assert (xtype->tclass == STRUCTS_TYPE_UNION);
! 565:
! 566: /* Dereference through pointer(s) */
! 567: while (type->tclass == STRUCTS_TYPE_POINTER) {
! 568: type = type->args[0].v;
! 569: data = *((void **)data);
! 570: }
! 571:
! 572: /* Get union info */
! 573: xun = xdata;
! 574:
! 575: /* Check which union field is in use and transfer accordingly */
! 576: if (strcmp(xun->field_name, "i4") == 0
! 577: || strcmp(xun->field_name, "int") == 0
! 578: || strcmp(xun->field_name, "boolean") == 0
! 579: || strcmp(xun->field_name, "double") == 0
! 580: || strcmp(xun->field_name, "string") == 0
! 581: || strcmp(xun->field_name, "dateTime.iso8601") == 0
! 582: || strcmp(xun->field_name, "base64") == 0) {
! 583: const char *xfname = xun->field_name;
! 584: char *s;
! 585:
! 586: if ((s = structs_get_string(xtype,
! 587: xfname, xdata, TYPED_MEM_TEMP)) == NULL)
! 588: goto fail_errno;
! 589: if (structs_set_string(type, NULL, s, data, ebuf, emax) == -1) {
! 590: FREE(TYPED_MEM_TEMP, s);
! 591: return (-1);
! 592: }
! 593: FREE(TYPED_MEM_TEMP, s);
! 594: } else if (strcmp(xun->field_name, "struct") == 0) {
! 595: int is_struct;
! 596: u_int len;
! 597: u_int i;
! 598:
! 599: /* Check destination type */
! 600: if (type->tclass != STRUCTS_TYPE_STRUCTURE
! 601: && type->tclass != STRUCTS_TYPE_UNION) {
! 602: snprintf(ebuf, emax, "can't convert XML-RPC struct");
! 603: errno = EINVAL;
! 604: return (-1);
! 605: }
! 606: is_struct = (type->tclass == STRUCTS_TYPE_STRUCTURE);
! 607:
! 608: /* Copy structure members */
! 609: if ((len = structs_array_length(xtype, "struct", xdata)) == -1)
! 610: goto fail_errno;
! 611: for (i = 0; i < len; i++) {
! 612: const struct structs_type *ftype = type;
! 613: void *fdata = data;
! 614: char buf[32];
! 615: char *mname;
! 616:
! 617: /* Get member field name */
! 618: snprintf(buf, sizeof(buf), "struct.%u.name", i);
! 619: if ((mname = structs_get_string(xtype,
! 620: buf, xdata, TYPED_MEM_TEMP)) == NULL)
! 621: goto fail_errno;
! 622:
! 623: /* Find field in struct or union */
! 624: if ((ftype = structs_find(type,
! 625: mname, &fdata, 1)) == NULL) {
! 626: if (errno != ENOENT) {
! 627: FREE(TYPED_MEM_TEMP, mname);
! 628: goto fail_errno;
! 629: }
! 630: snprintf(ebuf, emax, "unknown %s field \"%s\"",
! 631: is_struct ? "struct" : "union", mname);
! 632: FREE(TYPED_MEM_TEMP, mname);
! 633: errno = ENOENT;
! 634: return (-1);
! 635: }
! 636: FREE(TYPED_MEM_TEMP, mname);
! 637:
! 638: /* Copy over value */
! 639: snprintf(buf, sizeof(buf), "struct.%u.value", i);
! 640: if (structs_xmlrpc2struct(xtype, xdata, buf,
! 641: ftype, fdata, NULL, ebuf, emax) == -1)
! 642: return (-1);
! 643: }
! 644: } else if (strcmp(xun->field_name, "array") == 0) {
! 645: const struct structs_type *const etype = type->args[0].v;
! 646: struct structs_array *const ary = data;
! 647: const u_int length = type->args[2].i; /* if fixedarray */
! 648: const struct structs_type *xatype;
! 649: const struct structs_array *xary;
! 650: int fixed;
! 651: u_int i;
! 652:
! 653: /* Check destination type */
! 654: if (type->tclass != STRUCTS_TYPE_ARRAY
! 655: && type->tclass != STRUCTS_TYPE_FIXEDARRAY) {
! 656: snprintf(ebuf, emax, "can't convert XML-RPC array");
! 657: errno = EINVAL;
! 658: return (-1);
! 659: }
! 660: fixed = (type->tclass == STRUCTS_TYPE_FIXEDARRAY);
! 661:
! 662: /* Dig for the actual source array */
! 663: xary = xdata;
! 664: if ((xatype = structs_find(xtype,
! 665: "array.data", (void **)&xary, 0)) == NULL)
! 666: goto fail_errno;
! 667:
! 668: /* Reset destination array */
! 669: if (structs_reset(type, NULL, data) == -1)
! 670: goto fail_errno;
! 671:
! 672: /* Check length for fixed arrays */
! 673: if (fixed && xary->length > length) {
! 674: snprintf(ebuf, emax, "XML-RPC array is too long");
! 675: errno = EDOM;
! 676: return (-1);
! 677: }
! 678:
! 679: /* Copy over each element in the array */
! 680: for (i = 0; i < xary->length; i++) {
! 681: char buf[32];
! 682: void *elem;
! 683:
! 684: /* Add/set new element in the dest array */
! 685: if (fixed)
! 686: elem = (char *)data + (i * etype->size);
! 687: else {
! 688: if (structs_array_insert(type,
! 689: NULL, i, data) == -1)
! 690: goto fail_errno;
! 691: elem = (char *)ary->elems + (i * etype->size);
! 692: }
! 693:
! 694: /* Set its value */
! 695: snprintf(buf, sizeof(buf), "%u", i);
! 696: if (structs_xmlrpc2struct(xatype, xary, buf, etype,
! 697: elem, NULL, ebuf, emax) == -1)
! 698: return (-1);
! 699: }
! 700: } else {
! 701: snprintf(ebuf, emax, "unsupported XML-RPC type \"%s\"",
! 702: xun->field_name);
! 703: errno = EINVAL;
! 704: return (-1);
! 705: }
! 706:
! 707: /* Done */
! 708: return (0);
! 709:
! 710: fail_errno:
! 711: /* Return with error */
! 712: snprintf(ebuf, emax, "%s", strerror(errno));
! 713: return (-1);
! 714: }
! 715:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to structs_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 / structs