Annotation of embedaddon/php/ext/xmlrpc/libxmlrpc/xml_to_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: xml_to_xmlrpc.c 242949 2007-09-26 15:44:16Z cvs2svn $";
! 35:
! 36: #include "php.h"
! 37: #include "main/snprintf.h"
! 38: #ifdef _WIN32
! 39: #include "xmlrpc_win32.h"
! 40: #endif
! 41: #include <string.h>
! 42: #include <stdlib.h>
! 43: #include "xml_to_xmlrpc.h"
! 44: #include "base64.h"
! 45:
! 46: /* list of tokens used in vocab */
! 47: #define ELEM_ARRAY "array"
! 48: #define ELEM_BASE64 "base64"
! 49: #define ELEM_BOOLEAN "boolean"
! 50: #define ELEM_DATA "data"
! 51: #define ELEM_DATETIME "dateTime.iso8601"
! 52: #define ELEM_DOUBLE "double"
! 53: #define ELEM_FAULT "fault"
! 54: #define ELEM_FAULTCODE "faultCode"
! 55: #define ELEM_FAULTSTRING "faultString"
! 56: #define ELEM_I4 "i4"
! 57: #define ELEM_INT "int"
! 58: #define ELEM_MEMBER "member"
! 59: #define ELEM_METHODCALL "methodCall"
! 60: #define ELEM_METHODNAME "methodName"
! 61: #define ELEM_METHODRESPONSE "methodResponse"
! 62: #define ELEM_NAME "name"
! 63: #define ELEM_PARAM "param"
! 64: #define ELEM_PARAMS "params"
! 65: #define ELEM_STRING "string"
! 66: #define ELEM_STRUCT "struct"
! 67: #define ELEM_VALUE "value"
! 68:
! 69:
! 70: XMLRPC_VALUE xml_element_to_XMLRPC_REQUEST_worker(XMLRPC_REQUEST request, XMLRPC_VALUE parent_vector, XMLRPC_VALUE current_val, xml_element* el) {
! 71: if (!current_val) {
! 72: /* This should only be the case for the first element */
! 73: current_val = XMLRPC_CreateValueEmpty();
! 74: }
! 75:
! 76: if (el->name) {
! 77:
! 78: /* first, deal with the crazy/stupid fault format */
! 79: if (!strcmp(el->name, ELEM_FAULT)) {
! 80: xml_element* fault_value = (xml_element*)Q_Head(&el->children);
! 81: XMLRPC_SetIsVector(current_val, xmlrpc_vector_struct);
! 82:
! 83: if(fault_value) {
! 84: xml_element* fault_struct = (xml_element*)Q_Head(&fault_value->children);
! 85: if(fault_struct) {
! 86: xml_element* iter = (xml_element*)Q_Head(&fault_struct->children);
! 87:
! 88: while (iter) {
! 89: XMLRPC_VALUE xNextVal = XMLRPC_CreateValueEmpty();
! 90: xml_element_to_XMLRPC_REQUEST_worker(request, current_val, xNextVal, iter);
! 91: XMLRPC_AddValueToVector(current_val, xNextVal);
! 92: iter = (xml_element*)Q_Next(&fault_struct->children);
! 93: }
! 94: }
! 95: }
! 96: }
! 97: else if (!strcmp(el->name, ELEM_DATA) /* should be ELEM_ARRAY, but there is an extra level. weird */
! 98: || (!strcmp(el->name, ELEM_PARAMS) &&
! 99: (XMLRPC_RequestGetRequestType(request) == xmlrpc_request_call)) ) { /* this "PARAMS" concept is silly. dave?! */
! 100: xml_element* iter = (xml_element*)Q_Head(&el->children);
! 101: XMLRPC_SetIsVector(current_val, xmlrpc_vector_array);
! 102:
! 103: while (iter) {
! 104: XMLRPC_VALUE xNextVal = XMLRPC_CreateValueEmpty();
! 105: xml_element_to_XMLRPC_REQUEST_worker(request, current_val, xNextVal, iter);
! 106: XMLRPC_AddValueToVector(current_val, xNextVal);
! 107: iter = (xml_element*)Q_Next(&el->children);
! 108: }
! 109: }
! 110: else if (!strcmp(el->name, ELEM_STRUCT)) {
! 111: xml_element* iter = (xml_element*)Q_Head(&el->children);
! 112: XMLRPC_SetIsVector(current_val, xmlrpc_vector_struct);
! 113:
! 114: while ( iter ) {
! 115: XMLRPC_VALUE xNextVal = XMLRPC_CreateValueEmpty();
! 116: xml_element_to_XMLRPC_REQUEST_worker(request, current_val, xNextVal, iter);
! 117: XMLRPC_AddValueToVector(current_val, xNextVal);
! 118: iter = (xml_element*)Q_Next(&el->children);
! 119: }
! 120: }
! 121: else if (!strcmp(el->name, ELEM_STRING) ||
! 122: (!strcmp(el->name, ELEM_VALUE) && Q_Size(&el->children) == 0)) {
! 123: XMLRPC_SetValueString(current_val, el->text.str, el->text.len);
! 124: }
! 125: else if (!strcmp(el->name, ELEM_NAME)) {
! 126: XMLRPC_SetValueID_Case(current_val, el->text.str, 0, xmlrpc_case_exact);
! 127: }
! 128: else if (!strcmp(el->name, ELEM_INT) || !strcmp(el->name, ELEM_I4)) {
! 129: XMLRPC_SetValueInt(current_val, atoi(el->text.str));
! 130: }
! 131: else if (!strcmp(el->name, ELEM_BOOLEAN)) {
! 132: XMLRPC_SetValueBoolean(current_val, atoi(el->text.str));
! 133: }
! 134: else if (!strcmp(el->name, ELEM_DOUBLE)) {
! 135: XMLRPC_SetValueDouble(current_val, atof(el->text.str));
! 136: }
! 137: else if (!strcmp(el->name, ELEM_DATETIME)) {
! 138: XMLRPC_SetValueDateTime_ISO8601(current_val, el->text.str);
! 139: }
! 140: else if (!strcmp(el->name, ELEM_BASE64)) {
! 141: struct buffer_st buf;
! 142: base64_decode_xmlrpc(&buf, el->text.str, el->text.len);
! 143: XMLRPC_SetValueBase64(current_val, buf.data, buf.offset);
! 144: buffer_delete(&buf);
! 145: }
! 146: else {
! 147: xml_element* iter;
! 148:
! 149: if (!strcmp(el->name, ELEM_METHODCALL)) {
! 150: if (request) {
! 151: XMLRPC_RequestSetRequestType(request, xmlrpc_request_call);
! 152: }
! 153: }
! 154: else if (!strcmp(el->name, ELEM_METHODRESPONSE)) {
! 155: if (request) {
! 156: XMLRPC_RequestSetRequestType(request, xmlrpc_request_response);
! 157: }
! 158: }
! 159: else if (!strcmp(el->name, ELEM_METHODNAME)) {
! 160: if (request) {
! 161: XMLRPC_RequestSetMethodName(request, el->text.str);
! 162: }
! 163: }
! 164:
! 165: iter = (xml_element*)Q_Head(&el->children);
! 166: while ( iter ) {
! 167: xml_element_to_XMLRPC_REQUEST_worker(request, parent_vector,
! 168: current_val, iter);
! 169: iter = (xml_element*)Q_Next(&el->children);
! 170: }
! 171: }
! 172: }
! 173: return current_val;
! 174: }
! 175:
! 176: XMLRPC_VALUE xml_element_to_XMLRPC_VALUE(xml_element* el)
! 177: {
! 178: return xml_element_to_XMLRPC_REQUEST_worker(NULL, NULL, NULL, el);
! 179: }
! 180:
! 181: XMLRPC_VALUE xml_element_to_XMLRPC_REQUEST(XMLRPC_REQUEST request, xml_element* el)
! 182: {
! 183: if (request) {
! 184: return XMLRPC_RequestSetData(request, xml_element_to_XMLRPC_REQUEST_worker(request, NULL, NULL, el));
! 185: }
! 186: return NULL;
! 187: }
! 188:
! 189: xml_element* XMLRPC_to_xml_element_worker(XMLRPC_VALUE current_vector, XMLRPC_VALUE node,
! 190: XMLRPC_REQUEST_TYPE request_type, int depth) {
! 191: #define BUF_SIZE 512
! 192: xml_element* root = NULL;
! 193: if (node) {
! 194: char buf[BUF_SIZE];
! 195: XMLRPC_VALUE_TYPE type = XMLRPC_GetValueType(node);
! 196: XMLRPC_VECTOR_TYPE vtype = XMLRPC_GetVectorType(node);
! 197: xml_element* elem_val = xml_elem_new();
! 198:
! 199: /* special case for when root element is not an array */
! 200: if (depth == 0 &&
! 201: !(type == xmlrpc_vector &&
! 202: vtype == xmlrpc_vector_array &&
! 203: request_type == xmlrpc_request_call) ) {
! 204: int bIsFault = (vtype == xmlrpc_vector_struct && XMLRPC_VectorGetValueWithID(node, ELEM_FAULTCODE));
! 205:
! 206: xml_element* next_el = XMLRPC_to_xml_element_worker(NULL, node, request_type, depth + 1);
! 207: if (next_el) {
! 208: Q_PushTail(&elem_val->children, next_el);
! 209: }
! 210: elem_val->name = strdup(bIsFault ? ELEM_FAULT : ELEM_PARAMS);
! 211: }
! 212: else {
! 213: switch (type) {
! 214: case xmlrpc_empty: /* treat null value as empty string in xmlrpc. */
! 215: case xmlrpc_string:
! 216: elem_val->name = strdup(ELEM_STRING);
! 217: simplestring_addn(&elem_val->text, XMLRPC_GetValueString(node), XMLRPC_GetValueStringLen(node));
! 218: break;
! 219: case xmlrpc_int:
! 220: elem_val->name = strdup(ELEM_INT);
! 221: snprintf(buf, BUF_SIZE, "%i", XMLRPC_GetValueInt(node));
! 222: simplestring_add(&elem_val->text, buf);
! 223: break;
! 224: case xmlrpc_boolean:
! 225: elem_val->name = strdup(ELEM_BOOLEAN);
! 226: snprintf(buf, BUF_SIZE, "%i", XMLRPC_GetValueBoolean(node));
! 227: simplestring_add(&elem_val->text, buf);
! 228: break;
! 229: case xmlrpc_double:
! 230: {
! 231: TSRMLS_FETCH();
! 232: elem_val->name = strdup(ELEM_DOUBLE);
! 233: ap_php_snprintf(buf, BUF_SIZE, "%.*G", (int) EG(precision), XMLRPC_GetValueDouble(node));
! 234: simplestring_add(&elem_val->text, buf);
! 235: }
! 236: break;
! 237: case xmlrpc_datetime:
! 238: elem_val->name = strdup(ELEM_DATETIME);
! 239: simplestring_add(&elem_val->text, XMLRPC_GetValueDateTime_ISO8601(node));
! 240: break;
! 241: case xmlrpc_base64:
! 242: {
! 243: struct buffer_st buf;
! 244: elem_val->name = strdup(ELEM_BASE64);
! 245: base64_encode_xmlrpc(&buf, XMLRPC_GetValueBase64(node), XMLRPC_GetValueStringLen(node));
! 246: simplestring_addn(&elem_val->text, buf.data, buf.offset );
! 247: buffer_delete(&buf);
! 248: }
! 249: break;
! 250: case xmlrpc_vector:
! 251: {
! 252: XMLRPC_VECTOR_TYPE my_type = XMLRPC_GetVectorType(node);
! 253: XMLRPC_VALUE xIter = XMLRPC_VectorRewind(node);
! 254: xml_element* root_vector_elem = elem_val;
! 255:
! 256: switch (my_type) {
! 257: case xmlrpc_vector_array:
! 258: {
! 259: if(depth == 0) {
! 260: elem_val->name = strdup(ELEM_PARAMS);
! 261: }
! 262: else {
! 263: /* Hi my name is Dave and I like to make things as confusing
! 264: * as possible, thus I will throw in this 'data' element
! 265: * where it absolutely does not belong just so that people
! 266: * cannot code arrays and structs in a similar and straight
! 267: * forward manner. Have a good day.
! 268: *
! 269: * GRRRRRRRRR!
! 270: */
! 271: xml_element* data = xml_elem_new();
! 272: data->name = strdup(ELEM_DATA);
! 273:
! 274: elem_val->name = strdup(ELEM_ARRAY);
! 275: Q_PushTail(&elem_val->children, data);
! 276: root_vector_elem = data;
! 277: }
! 278: }
! 279: break;
! 280: case xmlrpc_vector_mixed: /* not officially supported */
! 281: case xmlrpc_vector_struct:
! 282: elem_val->name = strdup(ELEM_STRUCT);
! 283: break;
! 284: default:
! 285: break;
! 286: }
! 287:
! 288: /* recurse through sub-elements */
! 289: while ( xIter ) {
! 290: xml_element* next_el = XMLRPC_to_xml_element_worker(node, xIter, request_type, depth + 1);
! 291: if (next_el) {
! 292: Q_PushTail(&root_vector_elem->children, next_el);
! 293: }
! 294: xIter = XMLRPC_VectorNext(node);
! 295: }
! 296: }
! 297: break;
! 298: default:
! 299: break;
! 300: }
! 301: }
! 302:
! 303: {
! 304: XMLRPC_VECTOR_TYPE vtype = XMLRPC_GetVectorType(current_vector);
! 305:
! 306: if (depth == 1) {
! 307: xml_element* value = xml_elem_new();
! 308: value->name = strdup(ELEM_VALUE);
! 309:
! 310: /* yet another hack for the "fault" crap */
! 311: if (XMLRPC_VectorGetValueWithID(node, ELEM_FAULTCODE)) {
! 312: root = value;
! 313: }
! 314: else {
! 315: xml_element* param = xml_elem_new();
! 316: param->name = strdup(ELEM_PARAM);
! 317:
! 318: Q_PushTail(¶m->children, value);
! 319:
! 320: root = param;
! 321: }
! 322: Q_PushTail(&value->children, elem_val);
! 323: }
! 324: else if (vtype == xmlrpc_vector_struct || vtype == xmlrpc_vector_mixed) {
! 325: xml_element* member = xml_elem_new();
! 326: xml_element* name = xml_elem_new();
! 327: xml_element* value = xml_elem_new();
! 328:
! 329: member->name = strdup(ELEM_MEMBER);
! 330: name->name = strdup(ELEM_NAME);
! 331: value->name = strdup(ELEM_VALUE);
! 332:
! 333: simplestring_add(&name->text, XMLRPC_GetValueID(node));
! 334:
! 335: Q_PushTail(&member->children, name);
! 336: Q_PushTail(&member->children, value);
! 337: Q_PushTail(&value->children, elem_val);
! 338:
! 339: root = member;
! 340: }
! 341: else if (vtype == xmlrpc_vector_array) {
! 342: xml_element* value = xml_elem_new();
! 343:
! 344: value->name = strdup(ELEM_VALUE);
! 345:
! 346: Q_PushTail(&value->children, elem_val);
! 347:
! 348: root = value;
! 349: }
! 350: else if (vtype == xmlrpc_vector_none) {
! 351: /* no parent. non-op */
! 352: root = elem_val;
! 353: }
! 354: else {
! 355: xml_element* value = xml_elem_new();
! 356:
! 357: value->name = strdup(ELEM_VALUE);
! 358:
! 359: Q_PushTail(&value->children, elem_val);
! 360:
! 361: root = value;
! 362: }
! 363: }
! 364: }
! 365: return root;
! 366: }
! 367:
! 368: xml_element* XMLRPC_VALUE_to_xml_element(XMLRPC_VALUE node) {
! 369: return XMLRPC_to_xml_element_worker(NULL, node, xmlrpc_request_none, 0);
! 370: }
! 371:
! 372: xml_element* XMLRPC_REQUEST_to_xml_element(XMLRPC_REQUEST request) {
! 373: xml_element* wrapper = NULL;
! 374: if (request) {
! 375: const char* pStr = NULL;
! 376: XMLRPC_REQUEST_TYPE request_type = XMLRPC_RequestGetRequestType(request);
! 377: XMLRPC_VALUE xParams = XMLRPC_RequestGetData(request);
! 378:
! 379: wrapper = xml_elem_new();
! 380:
! 381: if (request_type == xmlrpc_request_call) {
! 382: pStr = ELEM_METHODCALL;
! 383: }
! 384: else if (request_type == xmlrpc_request_response) {
! 385: pStr = ELEM_METHODRESPONSE;
! 386: }
! 387: if (pStr) {
! 388: wrapper->name = strdup(pStr);
! 389: }
! 390:
! 391: if(request_type == xmlrpc_request_call) {
! 392: pStr = XMLRPC_RequestGetMethodName(request);
! 393:
! 394: if (pStr) {
! 395: xml_element* method = xml_elem_new();
! 396: method->name = strdup(ELEM_METHODNAME);
! 397: simplestring_add(&method->text, pStr);
! 398: Q_PushTail(&wrapper->children, method);
! 399: }
! 400: }
! 401: if (xParams) {
! 402: Q_PushTail(&wrapper->children,
! 403: XMLRPC_to_xml_element_worker(NULL, XMLRPC_RequestGetData(request), XMLRPC_RequestGetRequestType(request), 0));
! 404: }
! 405: else {
! 406: /* Despite the spec, the xml-rpc list folk want me to send an empty params element */
! 407: xml_element* params = xml_elem_new();
! 408: params->name = strdup(ELEM_PARAMS);
! 409: Q_PushTail(&wrapper->children, params);
! 410: }
! 411: }
! 412: return wrapper;
! 413: }
! 414:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xml_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