This source file includes following definitions.
- xml_element_to_DANDARPC_REQUEST_worker
- xml_element_to_DANDARPC_VALUE
- xml_element_to_DANDARPC_REQUEST
- DANDARPC_to_xml_element_worker
- DANDARPC_VALUE_to_xml_element
- DANDARPC_REQUEST_to_xml_element
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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
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
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