Annotation of embedaddon/php/ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c, revision 1.1.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: #ifdef _WIN32
34: #include "xmlrpc_win32.h"
35: #endif
36: #include <string.h>
37: #include <stdlib.h>
38: #include "xml_to_dandarpc.h"
39: #include "base64.h"
40:
41: /* list of tokens used in vocab */
42: #define ELEM_METHODCALL "methodCall"
43: #define ELEM_METHODNAME "methodName"
44: #define ELEM_METHODRESPONSE "methodResponse"
45: #define ELEM_ROOT "simpleRPC"
46:
47: #define ATTR_ARRAY "array"
48: #define ATTR_BASE64 "base64"
49: #define ATTR_BOOLEAN "boolean"
50: #define ATTR_DATETIME "dateTime.iso8601"
51: #define ATTR_DOUBLE "double"
52: #define ATTR_ID "id"
53: #define ATTR_INT "int"
54: #define ATTR_MIXED "mixed"
55: #define ATTR_SCALAR "scalar"
56: #define ATTR_STRING "string"
57: #define ATTR_STRUCT "struct"
58: #define ATTR_TYPE "type"
59: #define ATTR_VECTOR "vector"
60: #define ATTR_VERSION "version"
61:
62: #define VAL_VERSION_0_9 "0.9"
63:
64:
65: XMLRPC_VALUE xml_element_to_DANDARPC_REQUEST_worker(XMLRPC_REQUEST request, XMLRPC_VALUE xCurrent, xml_element* el) {
66: if(!xCurrent) {
67: xCurrent = XMLRPC_CreateValueEmpty();
68: }
69:
70: if(el->name) {
71: const char* id = NULL;
72: const char* type = NULL;
73: xml_element_attr* attr_iter = Q_Head(&el->attrs);
74:
75: while(attr_iter) {
76: if(!strcmp(attr_iter->key, ATTR_ID)) {
77: id = attr_iter->val;
78: }
79: if(!strcmp(attr_iter->key, ATTR_TYPE)) {
80: type = attr_iter->val;
81: }
82: attr_iter = Q_Next(&el->attrs);
83: }
84:
85: if(id) {
86: XMLRPC_SetValueID_Case(xCurrent, id, 0, xmlrpc_case_exact);
87: }
88:
89: if(!strcmp(el->name, ATTR_SCALAR)) {
90: if(!type || !strcmp(type, ATTR_STRING)) {
91: XMLRPC_SetValueString(xCurrent, el->text.str, el->text.len);
92: }
93: else if(!strcmp(type, ATTR_INT)) {
94: XMLRPC_SetValueInt(xCurrent, atoi(el->text.str));
95: }
96: else if(!strcmp(type, ATTR_BOOLEAN)) {
97: XMLRPC_SetValueBoolean(xCurrent, atoi(el->text.str));
98: }
99: else if(!strcmp(type, ATTR_DOUBLE)) {
100: XMLRPC_SetValueDouble(xCurrent, atof(el->text.str));
101: }
102: else if(!strcmp(type, ATTR_DATETIME)) {
103: XMLRPC_SetValueDateTime_ISO8601(xCurrent, el->text.str);
104: }
105: else if(!strcmp(type, ATTR_BASE64)) {
106: struct buffer_st buf;
107: base64_decode_xmlrpc(&buf, el->text.str, el->text.len);
108: XMLRPC_SetValueBase64(xCurrent, buf.data, buf.offset);
109: buffer_delete(&buf);
110: }
111: }
112: else if(!strcmp(el->name, ATTR_VECTOR)) {
113: xml_element* iter = (xml_element*)Q_Head(&el->children);
114:
115: if(!type || !strcmp(type, ATTR_MIXED)) {
116: XMLRPC_SetIsVector(xCurrent, xmlrpc_vector_mixed);
117: }
118: else if(!strcmp(type, ATTR_ARRAY)) {
119: XMLRPC_SetIsVector(xCurrent, xmlrpc_vector_array);
120: }
121: else if(!strcmp(type, ATTR_STRUCT)) {
122: XMLRPC_SetIsVector(xCurrent, xmlrpc_vector_struct);
123: }
124: while( iter ) {
125: XMLRPC_VALUE xNext = XMLRPC_CreateValueEmpty();
126: xml_element_to_DANDARPC_REQUEST_worker(request, xNext, iter);
127: XMLRPC_AddValueToVector(xCurrent, xNext);
128: iter = (xml_element*)Q_Next(&el->children);
129: }
130: }
131: else {
132: xml_element* iter = (xml_element*)Q_Head(&el->children);
133: while( iter ) {
134: xml_element_to_DANDARPC_REQUEST_worker(request, xCurrent, iter);
135: iter = (xml_element*)Q_Next(&el->children);
136: }
137:
138: if(!strcmp(el->name, ELEM_METHODCALL)) {
139: if(request) {
140: XMLRPC_RequestSetRequestType(request, xmlrpc_request_call);
141: }
142: }
143: else if(!strcmp(el->name, ELEM_METHODRESPONSE)) {
144: if(request) {
145: XMLRPC_RequestSetRequestType(request, xmlrpc_request_response);
146: }
147: }
148: else if(!strcmp(el->name, ELEM_METHODNAME)) {
149: if(request) {
150: XMLRPC_RequestSetMethodName(request, el->text.str);
151: }
152: }
153: }
154: }
155: return xCurrent;
156: }
157:
158: XMLRPC_VALUE xml_element_to_DANDARPC_VALUE(xml_element* el)
159: {
160: return xml_element_to_DANDARPC_REQUEST_worker(NULL, NULL, el);
161: }
162:
163: XMLRPC_VALUE xml_element_to_DANDARPC_REQUEST(XMLRPC_REQUEST request, xml_element* el)
164: {
165: if(request) {
166: return XMLRPC_RequestSetData(request, xml_element_to_DANDARPC_REQUEST_worker(request, NULL, el));
167: }
168: return NULL;
169: }
170:
171: xml_element* DANDARPC_to_xml_element_worker(XMLRPC_REQUEST request, XMLRPC_VALUE node) {
172: #define BUF_SIZE 512
173: xml_element* root = NULL;
174: if(node) {
175: char buf[BUF_SIZE];
176: const char* id = XMLRPC_GetValueID(node);
177: XMLRPC_VALUE_TYPE type = XMLRPC_GetValueType(node);
178: XMLRPC_REQUEST_OUTPUT_OPTIONS output = XMLRPC_RequestGetOutputOptions(request);
179: int bNoAddType = (type == xmlrpc_string && request && output && output->xml_elem_opts.verbosity == xml_elem_no_white_space);
180: xml_element* elem_val = xml_elem_new();
181: const char* pAttrType = NULL;
182:
183: xml_element_attr* attr_type = bNoAddType ? NULL : malloc(sizeof(xml_element_attr));
184:
185: if(attr_type) {
186: attr_type->key = strdup(ATTR_TYPE);
187: attr_type->val = 0;
188: Q_PushTail(&elem_val->attrs, attr_type);
189: }
190:
191: elem_val->name = (type == xmlrpc_vector) ? strdup(ATTR_VECTOR) : strdup(ATTR_SCALAR);
192:
193: if(id && *id) {
194: xml_element_attr* attr_id = malloc(sizeof(xml_element_attr));
195: if(attr_id) {
196: attr_id->key = strdup(ATTR_ID);
197: attr_id->val = strdup(id);
198: Q_PushTail(&elem_val->attrs, attr_id);
199: }
200: }
201:
202: switch(type) {
203: case xmlrpc_string:
204: pAttrType = ATTR_STRING;
205: simplestring_addn(&elem_val->text, XMLRPC_GetValueString(node), XMLRPC_GetValueStringLen(node));
206: break;
207: case xmlrpc_int:
208: pAttrType = ATTR_INT;
209: snprintf(buf, BUF_SIZE, "%i", XMLRPC_GetValueInt(node));
210: simplestring_add(&elem_val->text, buf);
211: break;
212: case xmlrpc_boolean:
213: pAttrType = ATTR_BOOLEAN;
214: snprintf(buf, BUF_SIZE, "%i", XMLRPC_GetValueBoolean(node));
215: simplestring_add(&elem_val->text, buf);
216: break;
217: case xmlrpc_double:
218: pAttrType = ATTR_DOUBLE;
219: snprintf(buf, BUF_SIZE, "%f", XMLRPC_GetValueDouble(node));
220: simplestring_add(&elem_val->text, buf);
221: break;
222: case xmlrpc_datetime:
223: pAttrType = ATTR_DATETIME;
224: simplestring_add(&elem_val->text, XMLRPC_GetValueDateTime_ISO8601(node));
225: break;
226: case xmlrpc_base64:
227: {
228: struct buffer_st buf;
229: pAttrType = ATTR_BASE64;
230: base64_encode_xmlrpc(&buf, XMLRPC_GetValueBase64(node), XMLRPC_GetValueStringLen(node));
231: simplestring_addn(&elem_val->text, buf.data, buf.offset );
232: buffer_delete(&buf);
233: }
234: break;
235: case xmlrpc_vector:
236: {
237: XMLRPC_VECTOR_TYPE my_type = XMLRPC_GetVectorType(node);
238: XMLRPC_VALUE xIter = XMLRPC_VectorRewind(node);
239:
240: switch(my_type) {
241: case xmlrpc_vector_array:
242: pAttrType = ATTR_ARRAY;
243: break;
244: case xmlrpc_vector_mixed:
245: pAttrType = ATTR_MIXED;
246: break;
247: case xmlrpc_vector_struct:
248: pAttrType = ATTR_STRUCT;
249: break;
250: default:
251: break;
252: }
253:
254: /* recurse through sub-elements */
255: while( xIter ) {
256: xml_element* next_el = DANDARPC_to_xml_element_worker(request, xIter);
257: if(next_el) {
258: Q_PushTail(&elem_val->children, next_el);
259: }
260: xIter = XMLRPC_VectorNext(node);
261: }
262: }
263: break;
264: default:
265: break;
266: }
267: if(pAttrType && attr_type && !bNoAddType) {
268: attr_type->val = strdup(pAttrType);
269: }
270: root = elem_val;
271: }
272: return root;
273: }
274:
275: xml_element* DANDARPC_VALUE_to_xml_element(XMLRPC_VALUE node) {
276: return DANDARPC_to_xml_element_worker(NULL, node);
277: }
278:
279: xml_element* DANDARPC_REQUEST_to_xml_element(XMLRPC_REQUEST request) {
280: xml_element* wrapper = NULL;
281: xml_element* root = NULL;
282: if(request) {
283: XMLRPC_REQUEST_TYPE request_type = XMLRPC_RequestGetRequestType(request);
284: const char* pStr = NULL;
285: xml_element_attr* version = malloc(sizeof(xml_element_attr));
286: version->key = strdup(ATTR_VERSION);
287: version->val = strdup(VAL_VERSION_0_9);
288:
289: wrapper = xml_elem_new();
290:
291: if(request_type == xmlrpc_request_response) {
292: pStr = ELEM_METHODRESPONSE;
293: }
294: else if(request_type == xmlrpc_request_call) {
295: pStr = ELEM_METHODCALL;
296: }
297: if(pStr) {
298: wrapper->name = strdup(pStr);
299: }
300:
301: root = xml_elem_new();
302: root->name = strdup(ELEM_ROOT);
303: Q_PushTail(&root->attrs, version);
304: Q_PushTail(&root->children, wrapper);
305:
306: pStr = XMLRPC_RequestGetMethodName(request);
307:
308: if(pStr) {
309: xml_element* method = xml_elem_new();
310: method->name = strdup(ELEM_METHODNAME);
311: simplestring_add(&method->text, pStr);
312: Q_PushTail(&wrapper->children, method);
313: }
314: Q_PushTail(&wrapper->children,
315: DANDARPC_to_xml_element_worker(request, XMLRPC_RequestGetData(request)));
316: }
317: return root;
318: }
319:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xml_to_dandarpc.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