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 */
6
7
8 /*-**********************************************************************
9 * TODO: *
10 * - [SOAP-ENC:position] read sparse arrays (and write?) *
11 * - [SOAP-ENC:offset] read partially transmitted arrays (and write?) *
12 * - read "flattened" multi-dimensional arrays. (don't bother writing) *
13 * *
14 * BUGS: *
15 * - does not read schema. thus only knows soap pre-defined types. *
16 * - references (probably) do not work. untested. *
17 * - does not expose SOAP-ENV:Header to application at all. *
18 * - does not use namespaces correctly, thus: *
19 * - namespaces are hard-coded in comparison tokens *
20 * - if a sender uses another namespace identifer, it will break *
21 ************************************************************************/
22
23
24 static const char rcsid[] = "#(@) $Id:";
25
26 #ifdef _WIN32
27 #include "xmlrpc_win32.h"
28 #endif
29 #include <string.h>
30 #include <stdlib.h>
31 #include "xml_to_soap.h"
32 #include "base64.h"
33
34 /* list of tokens used in vocab */
35 #define TOKEN_ANY "xsd:ur-type"
36 #define TOKEN_ARRAY "SOAP-ENC:Array"
37 #define TOKEN_ARRAY_TYPE "SOAP-ENC:arrayType"
38 #define TOKEN_BASE64 "SOAP-ENC:base64"
39 #define TOKEN_BOOLEAN "xsd:boolean"
40 #define TOKEN_DATETIME "xsd:timeInstant"
41 #define TOKEN_DOUBLE "xsd:double"
42 #define TOKEN_FLOAT "xsd:float"
43 #define TOKEN_ID "id"
44 #define TOKEN_INT "xsd:int"
45 #define TOKEN_NULL "xsi:null"
46 #define TOKEN_STRING "xsd:string"
47 #define TOKEN_STRUCT "xsd:struct"
48 #define TOKEN_TYPE "xsi:type"
49 #define TOKEN_FAULT "SOAP-ENV:Fault"
50 #define TOKEN_MUSTUNDERSTAND "SOAP-ENV:mustUnderstand"
51 #define TOKEN_ACTOR "SOAP-ENV:actor"
52 #define TOKEN_ACTOR_NEXT "http://schemas.xmlsoap.org/soap/actor/next"
53
54 #define TOKEN_XMLRPC_FAULTCODE "faultCode"
55 #define TOKEN_XMLRPC_FAULTSTRING "faultString"
56 #define TOKEN_SOAP_FAULTCODE "faultcode"
57 #define TOKEN_SOAP_FAULTSTRING "faultstring"
58 #define TOKEN_SOAP_FAULTDETAILS "details"
59 #define TOKEN_SOAP_FAULTACTOR "actor"
60
61
62 /* determine if a string represents a soap type, as used in element names */
is_soap_type(const char * soap_type)63 static inline int is_soap_type(const char* soap_type) {
64 return(strstr(soap_type, "SOAP-ENC:") || strstr(soap_type, "xsd:")) ? 1 : 0;
65 }
66
67 /* utility func to generate a new attribute. possibly should be in xml_element.c?? */
new_attr(const char * key,const char * val)68 static xml_element_attr* new_attr(const char* key, const char* val) {
69 xml_element_attr* attr = malloc(sizeof(xml_element_attr));
70 if (attr) {
71 attr->key = key ? strdup(key) : NULL;
72 attr->val = val ? strdup(val) : NULL;
73 }
74 return attr;
75 }
76
77 struct array_info {
78 char kids_type[128];
79 unsigned long size;
80 /* ... ? */
81 };
82
83
84 /* parses soap arrayType attribute to generate an array_info structure.
85 * TODO: should deal with sparse, flattened, & multi-dimensional arrays
86 */
parse_array_type_info(const char * array_type)87 static struct array_info* parse_array_type_info(const char* array_type) {
88 struct array_info* ai = NULL;
89 if (array_type) {
90 ai = (struct array_info*)calloc(1, sizeof(struct array_info));
91 if (ai) {
92 char buf[128], *p;
93 snprintf(buf, sizeof(buf), "%s", array_type);
94 p = strchr(buf, '[');
95 if (p) {
96 *p = 0;
97 }
98 strcpy(ai->kids_type, buf);
99 }
100 }
101 return ai;
102 }
103
104 /* performs heuristics on an xmlrpc_vector_array to determine
105 * appropriate soap arrayType string.
106 */
get_array_soap_type(XMLRPC_VALUE node)107 static const char* get_array_soap_type(XMLRPC_VALUE node) {
108 XMLRPC_VALUE_TYPE_EASY type = xmlrpc_type_none;
109
110 XMLRPC_VALUE xIter = XMLRPC_VectorRewind(node);
111 int loopCount = 0;
112 const char* soapType = TOKEN_ANY;
113
114 type = XMLRPC_GetValueTypeEasy(xIter);
115 xIter = XMLRPC_VectorNext(node);
116
117 while (xIter) {
118 /* 50 seems like a decent # of loops. That will likely
119 * cover most cases. Any more and we start to sacrifice
120 * performance.
121 */
122 if ( (XMLRPC_GetValueTypeEasy(xIter) != type) || loopCount >= 50) {
123 type = xmlrpc_type_none;
124 break;
125 }
126 loopCount ++;
127
128 xIter = XMLRPC_VectorNext(node);
129 }
130 switch (type) {
131 case xmlrpc_type_none:
132 soapType = TOKEN_ANY;
133 break;
134 case xmlrpc_type_empty:
135 soapType = TOKEN_NULL;
136 break;
137 case xmlrpc_type_int:
138 soapType = TOKEN_INT;
139 break;
140 case xmlrpc_type_double:
141 soapType = TOKEN_DOUBLE;
142 break;
143 case xmlrpc_type_boolean:
144 soapType = TOKEN_BOOLEAN;
145 break;
146 case xmlrpc_type_string:
147 soapType = TOKEN_STRING;
148 break;
149 case xmlrpc_type_base64:
150 soapType = TOKEN_BASE64;
151 break;
152 case xmlrpc_type_datetime:
153 soapType = TOKEN_DATETIME;
154 break;
155 case xmlrpc_type_struct:
156 soapType = TOKEN_STRUCT;
157 break;
158 case xmlrpc_type_array:
159 soapType = TOKEN_ARRAY;
160 break;
161 case xmlrpc_type_mixed:
162 soapType = TOKEN_STRUCT;
163 break;
164 }
165 return soapType;
166 }
167
168 /* determines whether a node is a fault or not, and of which type:
169 * 0 = not a fault,
170 * 1 = xmlrpc style fault
171 * 2 = soap style fault.
172 */
get_fault_type(XMLRPC_VALUE node)173 static inline int get_fault_type(XMLRPC_VALUE node) {
174 if (XMLRPC_VectorGetValueWithID(node, TOKEN_XMLRPC_FAULTCODE) &&
175 XMLRPC_VectorGetValueWithID(node, TOKEN_XMLRPC_FAULTSTRING)) {
176 return 1;
177 }
178 else if (XMLRPC_VectorGetValueWithID(node, TOKEN_SOAP_FAULTCODE) &&
179 XMLRPC_VectorGetValueWithID(node, TOKEN_SOAP_FAULTSTRING)) {
180 return 2;
181 }
182 return 0;
183 }
184
185 /* input: an XMLRPC_VALUE representing a fault struct in xml-rpc style.
186 * output: an XMLRPC_VALUE representing a fault struct in soap style,
187 * with xmlrpc codes mapped to soap codes, and all other values preserved.
188 * note that the returned value is a completely new value, and must be freed.
189 * the input value is untouched.
190 */
gen_fault_xmlrpc(XMLRPC_VALUE node,xml_element * el_target)191 static XMLRPC_VALUE gen_fault_xmlrpc(XMLRPC_VALUE node, xml_element* el_target) {
192 XMLRPC_VALUE xDup = XMLRPC_DupValueNew(node);
193 XMLRPC_VALUE xCode = XMLRPC_VectorGetValueWithID(xDup, TOKEN_XMLRPC_FAULTCODE);
194 XMLRPC_VALUE xStr = XMLRPC_VectorGetValueWithID(xDup, TOKEN_XMLRPC_FAULTSTRING);
195
196 XMLRPC_SetValueID(xCode, TOKEN_SOAP_FAULTCODE, 0);
197 XMLRPC_SetValueID(xStr, TOKEN_SOAP_FAULTSTRING, 0);
198
199 /* rough mapping of xmlrpc fault codes to soap codes */
200 switch (XMLRPC_GetValueInt(xCode)) {
201 case -32700: /* "parse error. not well formed", */
202 case -32701: /* "parse error. unsupported encoding" */
203 case -32702: /* "parse error. invalid character for encoding" */
204 case -32600: /* "server error. invalid xml-rpc. not conforming to spec." */
205 case -32601: /* "server error. requested method not found" */
206 case -32602: /* "server error. invalid method parameters" */
207 XMLRPC_SetValueString(xCode, "SOAP-ENV:Client", 0);
208 break;
209 case -32603: /* "server error. internal xml-rpc error" */
210 case -32500: /* "application error" */
211 case -32400: /* "system error" */
212 case -32300: /* "transport error */
213 XMLRPC_SetValueString(xCode, "SOAP-ENV:Server", 0);
214 break;
215 }
216 return xDup;
217 }
218
219 /* returns a new XMLRPC_VALUE representing a soap fault, comprised of a struct with four keys. */
gen_soap_fault(const char * fault_code,const char * fault_string,const char * actor,const char * details)220 static XMLRPC_VALUE gen_soap_fault(const char* fault_code, const char* fault_string,
221 const char* actor, const char* details) {
222 XMLRPC_VALUE xReturn = XMLRPC_CreateVector(TOKEN_FAULT, xmlrpc_vector_struct);
223 XMLRPC_AddValuesToVector(xReturn,
224 XMLRPC_CreateValueString(TOKEN_SOAP_FAULTCODE, fault_code, 0),
225 XMLRPC_CreateValueString(TOKEN_SOAP_FAULTSTRING, fault_string, 0),
226 XMLRPC_CreateValueString(TOKEN_SOAP_FAULTACTOR, actor, 0),
227 XMLRPC_CreateValueString(TOKEN_SOAP_FAULTDETAILS, details, 0),
228 NULL);
229 return xReturn;
230 }
231
232 /* translates xml soap dom to native data structures. recursive. */
xml_element_to_SOAP_REQUEST_worker(XMLRPC_REQUEST request,XMLRPC_VALUE xParent,struct array_info * parent_array,XMLRPC_VALUE xCurrent,xml_element * el,int depth)233 XMLRPC_VALUE xml_element_to_SOAP_REQUEST_worker(XMLRPC_REQUEST request,
234 XMLRPC_VALUE xParent,
235 struct array_info* parent_array,
236 XMLRPC_VALUE xCurrent,
237 xml_element* el,
238 int depth) {
239 XMLRPC_REQUEST_TYPE rtype = xmlrpc_request_none;
240
241 /* no current element on first call */
242 if (!xCurrent) {
243 xCurrent = XMLRPC_CreateValueEmpty();
244 }
245
246 /* increment recursion depth guage */
247 depth ++;
248
249 /* safety first. must have a valid element */
250 if (el && el->name) {
251 const char* id = NULL;
252 const char* type = NULL, *arrayType=NULL, *actor = NULL;
253 xml_element_attr* attr_iter = Q_Head(&el->attrs);
254 int b_must_understand = 0;
255
256 /* in soap, types may be specified in either element name -or- with xsi:type attribute. */
257 if (is_soap_type(el->name)) {
258 type = el->name;
259 }
260 /* if our parent node, by definition a vector, is not an array, then
261 our element name must be our key identifier. */
262 else if (XMLRPC_GetVectorType(xParent) != xmlrpc_vector_array) {
263 id = el->name;
264 if(!strcmp(id, "item")) {
265 }
266 }
267
268 /* iterate through element attributes, pick out useful stuff. */
269 while (attr_iter) {
270 /* element's type */
271 if (!strcmp(attr_iter->key, TOKEN_TYPE)) {
272 type = attr_iter->val;
273 }
274 /* array type */
275 else if (!strcmp(attr_iter->key, TOKEN_ARRAY_TYPE)) {
276 arrayType = attr_iter->val;
277 }
278 /* must understand, sometimes present in headers. */
279 else if (!strcmp(attr_iter->key, TOKEN_MUSTUNDERSTAND)) {
280 b_must_understand = strchr(attr_iter->val, '1') ? 1 : 0;
281 }
282 /* actor, used in conjunction with must understand. */
283 else if (!strcmp(attr_iter->key, TOKEN_ACTOR)) {
284 actor = attr_iter->val;
285 }
286 attr_iter = Q_Next(&el->attrs);
287 }
288
289 /* check if caller says we must understand something in a header. */
290 if (b_must_understand) {
291 /* is must understand actually indended for us?
292 BUG: spec says we should also determine if actor is our URL, but
293 we do not have that information. */
294 if (!actor || !strcmp(actor, TOKEN_ACTOR_NEXT)) {
295 /* TODO: implement callbacks or other mechanism for applications
296 to "understand" these headers. For now, we just bail if we
297 get a mustUnderstand header intended for us. */
298 XMLRPC_RequestSetError(request,
299 gen_soap_fault("SOAP-ENV:MustUnderstand",
300 "SOAP Must Understand Error",
301 "", ""));
302 return xCurrent;
303 }
304 }
305
306 /* set id (key) if one was found. */
307 if (id) {
308 XMLRPC_SetValueID_Case(xCurrent, id, 0, xmlrpc_case_exact);
309 }
310
311 /* according to soap spec,
312 depth 1 = Envelope, 2 = Header, Body & Fault, 3 = methodcall or response. */
313 if (depth == 3) {
314 const char* methodname = el->name;
315 char* p = NULL;
316
317 /* BUG: we determine request or response type using presence of "Response" in element name.
318 According to spec, this is only recommended, not required. Apparently, implementations
319 are supposed to know the type of action based on state, which strikes me as a bit lame.
320 Anyway, we don't have that state info, thus we use Response as a heuristic. */
321 rtype =
322 #ifdef strcasestr
323 strcasestr(el->name, "response") ? xmlrpc_request_response : xmlrpc_request_call;
324 #else
325 strstr(el->name, "esponse") ? xmlrpc_request_response : xmlrpc_request_call;
326 #endif
327 XMLRPC_RequestSetRequestType(request, rtype);
328
329 /* Get methodname. strip xml namespace crap. */
330 p = strchr(el->name, ':');
331 if (p) {
332 methodname = p + 1;
333 }
334 if (rtype == xmlrpc_request_call) {
335 XMLRPC_RequestSetMethodName(request, methodname);
336 }
337 }
338
339
340 /* Next, we begin to convert actual values. if no children, then must be a scalar value. */
341 if (!Q_Size(&el->children)) {
342 if (!type && parent_array && parent_array->kids_type[0]) {
343 type = parent_array->kids_type;
344 }
345 if (!type || !strcmp(type, TOKEN_STRING)) {
346 XMLRPC_SetValueString(xCurrent, el->text.str, el->text.len);
347 }
348 else if (!strcmp(type, TOKEN_INT)) {
349 XMLRPC_SetValueInt(xCurrent, atoi(el->text.str));
350 }
351 else if (!strcmp(type, TOKEN_BOOLEAN)) {
352 XMLRPC_SetValueBoolean(xCurrent, atoi(el->text.str));
353 }
354 else if (!strcmp(type, TOKEN_DOUBLE) ||
355 !strcmp(type, TOKEN_FLOAT)) {
356 XMLRPC_SetValueDouble(xCurrent, atof(el->text.str));
357 }
358 else if (!strcmp(type, TOKEN_NULL)) {
359 /* already an empty val. do nothing. */
360 }
361 else if (!strcmp(type, TOKEN_DATETIME)) {
362 XMLRPC_SetValueDateTime_ISO8601(xCurrent, el->text.str);
363 }
364 else if (!strcmp(type, TOKEN_BASE64)) {
365 struct buffer_st buf;
366 base64_decode_xmlrpc(&buf, el->text.str, el->text.len);
367 XMLRPC_SetValueBase64(xCurrent, buf.data, buf.offset);
368 buffer_delete(&buf);
369 }
370 }
371 /* Element has children, thus a vector, or "compound type" in soap-speak. */
372 else {
373 struct array_info* ai = NULL;
374 xml_element* iter = (xml_element*)Q_Head(&el->children);
375
376 if (!type || !strcmp(type, TOKEN_STRUCT)) {
377 XMLRPC_SetIsVector(xCurrent, xmlrpc_vector_struct);
378 }
379 else if (!strcmp(type, TOKEN_ARRAY) || arrayType != NULL) {
380 /* determine magic associated with soap array type.
381 this is passed down as we recurse, so our children have access to the info. */
382 ai = parse_array_type_info(arrayType); /* alloc'ed ai free'd below. */
383 XMLRPC_SetIsVector(xCurrent, xmlrpc_vector_array);
384 }
385 else {
386 /* mixed is probably closest thing we have to compound type. */
387 XMLRPC_SetIsVector(xCurrent, xmlrpc_vector_mixed);
388 }
389 /* Recurse, adding values as we go. Check for error during recursion
390 and if found, bail. this short-circuits us out of the recursion. */
391 while ( iter && !XMLRPC_RequestGetError(request) ) {
392 XMLRPC_VALUE xNext = NULL;
393 /* top level elements don't actually represent values, so we just pass the
394 current value along until we are deep enough. */
395 if ( depth <= 2 ||
396 (rtype == xmlrpc_request_response && depth <= 3) ) {
397 xml_element_to_SOAP_REQUEST_worker(request, NULL, ai, xCurrent, iter, depth);
398 }
399 /* ready to do some actual de-serialization. create a new empty value and
400 pass that along to be init'd, then add it to our current vector. */
401 else {
402 xNext = XMLRPC_CreateValueEmpty();
403 xml_element_to_SOAP_REQUEST_worker(request, xCurrent, ai, xNext, iter, depth);
404 XMLRPC_AddValueToVector(xCurrent, xNext);
405 }
406 iter = (xml_element*)Q_Next(&el->children);
407 }
408 /* cleanup */
409 if (ai) {
410 free(ai);
411 }
412 }
413 }
414 return xCurrent;
415 }
416
417 /* Convert soap xml dom to XMLRPC_VALUE, sans request info. untested. */
xml_element_to_SOAP_VALUE(xml_element * el)418 XMLRPC_VALUE xml_element_to_SOAP_VALUE(xml_element* el)
419 {
420 return xml_element_to_SOAP_REQUEST_worker(NULL, NULL, NULL, NULL, el, 0);
421 }
422
423 /* Convert soap xml dom to XMLRPC_REQUEST */
xml_element_to_SOAP_REQUEST(XMLRPC_REQUEST request,xml_element * el)424 XMLRPC_VALUE xml_element_to_SOAP_REQUEST(XMLRPC_REQUEST request, xml_element* el)
425 {
426 if (request) {
427 return XMLRPC_RequestSetData(request, xml_element_to_SOAP_REQUEST_worker(request, NULL, NULL, NULL, el, 0));
428 }
429 return NULL;
430 }
431
432
433 /* translates data structures to soap/xml. recursive */
SOAP_to_xml_element_worker(XMLRPC_REQUEST request,XMLRPC_VALUE node)434 xml_element* SOAP_to_xml_element_worker(XMLRPC_REQUEST request, XMLRPC_VALUE node) {
435 #define BUF_SIZE 128
436 xml_element* elem_val = NULL;
437 if (node) {
438 int bFreeNode = 0; /* sometimes we may need to free 'node' variable */
439 char buf[BUF_SIZE];
440 XMLRPC_VALUE_TYPE_EASY type = XMLRPC_GetValueTypeEasy(node);
441 char* pName = NULL, *pAttrType = NULL;
442
443 /* create our return value element */
444 elem_val = xml_elem_new();
445
446 switch (type) {
447 case xmlrpc_type_struct:
448 case xmlrpc_type_mixed:
449 case xmlrpc_type_array:
450 if (type == xmlrpc_type_array) {
451 /* array's are _very_ special in soap.
452 TODO: Should handle sparse/partial arrays here. */
453
454 /* determine soap array type. */
455 const char* type = get_array_soap_type(node);
456 xml_element_attr* attr_array_type = NULL;
457
458 /* specify array kids type and array size. */
459 snprintf(buf, sizeof(buf), "%s[%i]", type, XMLRPC_VectorSize(node));
460 attr_array_type = new_attr(TOKEN_ARRAY_TYPE, buf);
461
462 Q_PushTail(&elem_val->attrs, attr_array_type);
463
464 pAttrType = TOKEN_ARRAY;
465 }
466 /* check for fault, which is a rather special case.
467 (can't these people design anything consistent/simple/elegant?) */
468 else if (type == xmlrpc_type_struct) {
469 int fault_type = get_fault_type(node);
470 if (fault_type) {
471 if (fault_type == 1) {
472 /* gen fault from xmlrpc style fault codes
473 notice that we get a new node, which must be freed herein. */
474 node = gen_fault_xmlrpc(node, elem_val);
475 bFreeNode = 1;
476 }
477 pName = TOKEN_FAULT;
478 }
479 }
480
481 {
482 /* recurse through sub-elements */
483 XMLRPC_VALUE xIter = XMLRPC_VectorRewind(node);
484 while ( xIter ) {
485 xml_element* next_el = SOAP_to_xml_element_worker(request, xIter);
486 if (next_el) {
487 Q_PushTail(&elem_val->children, next_el);
488 }
489 xIter = XMLRPC_VectorNext(node);
490 }
491 }
492
493 break;
494
495 /* handle scalar types */
496 case xmlrpc_type_empty:
497 pAttrType = TOKEN_NULL;
498 break;
499 case xmlrpc_type_string:
500 pAttrType = TOKEN_STRING;
501 simplestring_addn(&elem_val->text, XMLRPC_GetValueString(node), XMLRPC_GetValueStringLen(node));
502 break;
503 case xmlrpc_type_int:
504 pAttrType = TOKEN_INT;
505 snprintf(buf, BUF_SIZE, "%i", XMLRPC_GetValueInt(node));
506 simplestring_add(&elem_val->text, buf);
507 break;
508 case xmlrpc_type_boolean:
509 pAttrType = TOKEN_BOOLEAN;
510 snprintf(buf, BUF_SIZE, "%i", XMLRPC_GetValueBoolean(node));
511 simplestring_add(&elem_val->text, buf);
512 break;
513 case xmlrpc_type_double:
514 pAttrType = TOKEN_DOUBLE;
515 snprintf(buf, BUF_SIZE, "%f", XMLRPC_GetValueDouble(node));
516 simplestring_add(&elem_val->text, buf);
517 break;
518 case xmlrpc_type_datetime:
519 {
520 time_t tt = XMLRPC_GetValueDateTime(node);
521 struct tm *tm = localtime (&tt);
522 pAttrType = TOKEN_DATETIME;
523 if(strftime (buf, BUF_SIZE, "%Y-%m-%dT%H:%M:%SZ", tm)) {
524 simplestring_add(&elem_val->text, buf);
525 }
526 }
527 break;
528 case xmlrpc_type_base64:
529 {
530 struct buffer_st buf;
531 pAttrType = TOKEN_BASE64;
532 base64_encode_xmlrpc(&buf, XMLRPC_GetValueBase64(node), XMLRPC_GetValueStringLen(node));
533 simplestring_addn(&elem_val->text, buf.data, buf.offset );
534 buffer_delete(&buf);
535 }
536 break;
537 break;
538 default:
539 break;
540 }
541
542 /* determining element's name is a bit tricky, due to soap semantics. */
543 if (!pName) {
544 /* if the value's type is known... */
545 if (pAttrType) {
546 /* see if it has an id (key). If so, use that as name, and type as an attribute. */
547 pName = (char*)XMLRPC_GetValueID(node);
548 if (pName) {
549 Q_PushTail(&elem_val->attrs, new_attr(TOKEN_TYPE, pAttrType));
550 }
551
552 /* otherwise, use the type as the name. */
553 else {
554 pName = pAttrType;
555 }
556 }
557 /* if the value's type is not known... (a rare case?) */
558 else {
559 /* see if it has an id (key). otherwise, default to generic "item" */
560 pName = (char*)XMLRPC_GetValueID(node);
561 if (!pName) {
562 pName = "item";
563 }
564 }
565 }
566 elem_val->name = strdup(pName);
567
568 /* cleanup */
569 if (bFreeNode) {
570 XMLRPC_CleanupValue(node);
571 }
572 }
573 return elem_val;
574 }
575
576 /* convert XMLRPC_VALUE to soap xml dom. untested. */
SOAP_VALUE_to_xml_element(XMLRPC_VALUE node)577 xml_element* SOAP_VALUE_to_xml_element(XMLRPC_VALUE node) {
578 return SOAP_to_xml_element_worker(NULL, node);
579 }
580
581 /* convert XMLRPC_REQUEST to soap xml dom. */
SOAP_REQUEST_to_xml_element(XMLRPC_REQUEST request)582 xml_element* SOAP_REQUEST_to_xml_element(XMLRPC_REQUEST request) {
583 xml_element* root = xml_elem_new();
584
585 /* safety first. */
586 if (root) {
587 xml_element* body = xml_elem_new();
588 root->name = strdup("SOAP-ENV:Envelope");
589
590 /* silly namespace stuff */
591 Q_PushTail(&root->attrs, new_attr("xmlns:SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/"));
592 Q_PushTail(&root->attrs, new_attr("xmlns:xsi", "http://www.w3.org/1999/XMLSchema-instance"));
593 Q_PushTail(&root->attrs, new_attr("xmlns:xsd", "http://www.w3.org/1999/XMLSchema"));
594 Q_PushTail(&root->attrs, new_attr("xmlns:SOAP-ENC", "http://schemas.xmlsoap.org/soap/encoding/"));
595 Q_PushTail(&root->attrs, new_attr("xmlns:si", "http://soapinterop.org/xsd"));
596 Q_PushTail(&root->attrs, new_attr("xmlns:ns6", "http://testuri.org"));
597 Q_PushTail(&root->attrs, new_attr("SOAP-ENV:encodingStyle", "http://schemas.xmlsoap.org/soap/encoding/"));
598
599 /* Q_PushHead(&root->attrs, new_attr("xmlns:ks", "http://kitchen.sink.org/soap/everything/under/sun"));
600 JUST KIDDING!! :-) ----> ------------------------------------------------- */
601
602 if (body) {
603 /* go ahead and serialize first... */
604 xml_element* el_serialized =
605 SOAP_to_xml_element_worker(request,
606 XMLRPC_RequestGetData(request));
607
608 /* check for fault, in which case, there is no intermediate element */
609 if (el_serialized && !strcmp(el_serialized->name, TOKEN_FAULT)) {
610 Q_PushTail(&body->children, el_serialized);
611 }
612 /* usual case: not a fault. Add Response element in between. */
613 else {
614 xml_element* rpc = xml_elem_new();
615
616 if (rpc) {
617 const char* methodname = XMLRPC_RequestGetMethodName(request);
618 XMLRPC_REQUEST_TYPE rtype = XMLRPC_RequestGetRequestType(request);
619
620 /* if we are making a request, we want to use the methodname as is. */
621 if (rtype == xmlrpc_request_call) {
622 if (methodname) {
623 rpc->name = strdup(methodname);
624 }
625 }
626 /* if it's a response, we append "Response". Also, given xmlrpc-epi
627 API/architecture, it's likely that we don't have a methodname for
628 the response, so we have to check that. */
629 else {
630 char buf[128];
631 snprintf(buf, sizeof(buf), "%s%s",
632 methodname ? methodname : "",
633 "Response");
634
635 rpc->name = strdup(buf);
636 }
637
638 /* add serialized data to method call/response.
639 add method call/response to body element */
640 if (rpc->name) {
641 if(el_serialized) {
642 if(Q_Size(&el_serialized->children) && rtype == xmlrpc_request_call) {
643 xml_element* iter = (xml_element*)Q_Head(&el_serialized->children);
644 while(iter) {
645 Q_PushTail(&rpc->children, iter);
646 iter = (xml_element*)Q_Next(&el_serialized->children);
647 }
648 xml_elem_free_non_recurse(el_serialized);
649 }
650 else {
651 Q_PushTail(&rpc->children, el_serialized);
652 }
653 }
654
655 Q_PushTail(&body->children, rpc);
656 }
657 else {
658 /* no method name?!
659 TODO: fault here...? */
660 }
661 }
662 }
663 body->name = strdup("SOAP-ENV:Body");
664 Q_PushTail(&root->children, body);
665 }
666 }
667
668 return root;
669 }
670
671
