1 /*
2 This file is part of, or distributed with, libXMLRPC - a C library for
3 xml-encoded function calls.
4
5 Author: Dan Libby (dan@libby.com)
6 Epinions.com may be contacted at feedback@epinions-inc.com
7 */
8
9 /*
10 Copyright 2001 Epinions, Inc.
11
12 Subject to the following 3 conditions, Epinions, Inc. permits you, free
13 of charge, to (a) use, copy, distribute, modify, perform and display this
14 software and associated documentation files (the "Software"), and (b)
15 permit others to whom the Software is furnished to do so as well.
16
17 1) The above copyright notice and this permission notice shall be included
18 without modification in all copies or substantial portions of the
19 Software.
20
21 2) THE SOFTWARE IS PROVIDED "AS IS", WITHOUT ANY WARRANTY OR CONDITION OF
22 ANY KIND, EXPRESS, IMPLIED OR STATUTORY, INCLUDING WITHOUT LIMITATION ANY
23 IMPLIED WARRANTIES OF ACCURACY, MERCHANTABILITY, FITNESS FOR A PARTICULAR
24 PURPOSE OR NONINFRINGEMENT.
25
26 3) IN NO EVENT SHALL EPINIONS, INC. BE LIABLE FOR ANY DIRECT, INDIRECT,
27 SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT
28 OF OR IN CONNECTION WITH THE SOFTWARE (HOWEVER ARISING, INCLUDING
29 NEGLIGENCE), EVEN IF EPINIONS, INC. IS AWARE OF THE POSSIBILITY OF SUCH
30 DAMAGES.
31
32 */
33
34 /* auto-generated portions of this file are also subject to the php license */
35
36 /*
37 +----------------------------------------------------------------------+
38 | PHP Version 7 |
39 +----------------------------------------------------------------------+
40 | Copyright (c) 1997-2017 The PHP Group |
41 +----------------------------------------------------------------------+
42 | This source file is subject to version 3.01 of the PHP license, |
43 | that is bundled with this package in the file LICENSE, and is |
44 | available through the world-wide-web at the following url: |
45 | http://www.php.net/license/3_01.txt |
46 | If you did not receive a copy of the PHP license and are unable to |
47 | obtain it through the world-wide-web, please send a note to |
48 | license@php.net so we can mail you a copy immediately. |
49 +----------------------------------------------------------------------+
50 | Author: Dan Libby |
51 +----------------------------------------------------------------------+
52 */
53
54 /* $Id$ */
55
56 /**********************************************************************
57 * BUGS: *
58 * - when calling a php user function, there appears to be no way to *
59 * distinguish between a return value of null, and no return value *
60 * at all. The xml serialization layer(s) will then return a value *
61 * of null, when the right thing may be no value at all. (SOAP) *
62 **********************************************************************/
63
64 #ifdef HAVE_CONFIG_H
65 #include "config.h"
66 #endif
67
68 #include "php.h"
69 #include "ext/standard/info.h"
70 #include "ext/standard/php_string.h"
71 #include "ext/date/php_date.h"
72 #include "php_ini.h"
73 #include "php_xmlrpc.h"
74 #include "xmlrpc.h"
75
76 static int le_xmlrpc_server;
77
78 /* {{{ arginfo */
79 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_encode, 0, 0, 1)
80 ZEND_ARG_INFO(0, value)
81 ZEND_END_ARG_INFO()
82
83 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_decode, 0, 0, 1)
84 ZEND_ARG_INFO(0, value)
85 ZEND_ARG_INFO(0, encoding)
86 ZEND_END_ARG_INFO()
87
88 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_decode_request, 0, 0, 2)
89 ZEND_ARG_INFO(0, xml)
90 ZEND_ARG_INFO(1, method)
91 ZEND_ARG_INFO(0, encoding)
92 ZEND_END_ARG_INFO()
93
94 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_encode_request, 0, 0, 2)
95 ZEND_ARG_INFO(0, method)
96 ZEND_ARG_INFO(0, params)
97 ZEND_ARG_INFO(0, output_options)
98 ZEND_END_ARG_INFO()
99
100 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_set_type, 0, 0, 2)
101 ZEND_ARG_INFO(1, value)
102 ZEND_ARG_INFO(0, type)
103 ZEND_END_ARG_INFO()
104
105 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_is_fault, 0, 0, 1)
106 ZEND_ARG_INFO(0, arg)
107 ZEND_END_ARG_INFO()
108
109 ZEND_BEGIN_ARG_INFO(arginfo_xmlrpc_server_create, 0)
110 ZEND_END_ARG_INFO()
111
112 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_server_destroy, 0, 0, 1)
113 ZEND_ARG_INFO(0, server)
114 ZEND_END_ARG_INFO()
115
116 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_server_register_method, 0, 0, 3)
117 ZEND_ARG_INFO(0, server)
118 ZEND_ARG_INFO(0, method_name)
119 ZEND_ARG_INFO(0, function)
120 ZEND_END_ARG_INFO()
121
122 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_server_call_method, 0, 0, 3)
123 ZEND_ARG_INFO(0, server)
124 ZEND_ARG_INFO(0, xml)
125 ZEND_ARG_INFO(0, user_data)
126 ZEND_ARG_INFO(0, output_options)
127 ZEND_END_ARG_INFO()
128
129 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_parse_method_descriptions, 0, 0, 1)
130 ZEND_ARG_INFO(0, xml)
131 ZEND_END_ARG_INFO()
132
133 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_server_add_introspection_data, 0, 0, 2)
134 ZEND_ARG_INFO(0, server)
135 ZEND_ARG_INFO(0, desc)
136 ZEND_END_ARG_INFO()
137
138 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_server_register_introspection_callback, 0, 0, 2)
139 ZEND_ARG_INFO(0, server)
140 ZEND_ARG_INFO(0, function)
141 ZEND_END_ARG_INFO()
142 /* }}} */
143
144 const zend_function_entry xmlrpc_functions[] = {
145 PHP_FE(xmlrpc_encode, arginfo_xmlrpc_encode)
146 PHP_FE(xmlrpc_decode, arginfo_xmlrpc_decode)
147 PHP_FE(xmlrpc_decode_request, arginfo_xmlrpc_decode_request)
148 PHP_FE(xmlrpc_encode_request, arginfo_xmlrpc_encode_request)
149 PHP_FE(xmlrpc_get_type, arginfo_xmlrpc_encode)
150 PHP_FE(xmlrpc_set_type, arginfo_xmlrpc_set_type)
151 PHP_FE(xmlrpc_is_fault, arginfo_xmlrpc_is_fault)
152 PHP_FE(xmlrpc_server_create, arginfo_xmlrpc_server_create)
153 PHP_FE(xmlrpc_server_destroy, arginfo_xmlrpc_server_destroy)
154 PHP_FE(xmlrpc_server_register_method, arginfo_xmlrpc_server_register_method)
155 PHP_FE(xmlrpc_server_call_method, arginfo_xmlrpc_server_call_method)
156 PHP_FE(xmlrpc_parse_method_descriptions, arginfo_xmlrpc_parse_method_descriptions)
157 PHP_FE(xmlrpc_server_add_introspection_data, arginfo_xmlrpc_server_add_introspection_data)
158 PHP_FE(xmlrpc_server_register_introspection_callback, arginfo_xmlrpc_server_register_introspection_callback)
159 PHP_FE_END
160 };
161
162 zend_module_entry xmlrpc_module_entry = {
163 STANDARD_MODULE_HEADER,
164 "xmlrpc",
165 xmlrpc_functions,
166 PHP_MINIT(xmlrpc),
167 NULL,
168 NULL,
169 NULL,
170 PHP_MINFO(xmlrpc),
171 PHP_XMLRPC_VERSION,
172 STANDARD_MODULE_PROPERTIES
173 };
174
175 #ifdef COMPILE_DL_XMLRPC
176 ZEND_GET_MODULE(xmlrpc)
177 #endif
178
179 /*******************************
180 * local structures and defines *
181 *******************************/
182
183 /* per server data */
184 typedef struct _xmlrpc_server_data {
185 zval method_map;
186 zval introspection_map;
187 XMLRPC_SERVER server_ptr;
188 } xmlrpc_server_data;
189
190
191 /* how to format output */
192 typedef struct _php_output_options {
193 int b_php_out;
194 int b_auto_version;
195 STRUCT_XMLRPC_REQUEST_OUTPUT_OPTIONS xmlrpc_out;
196 } php_output_options;
197
198 /* data passed to C callback */
199 typedef struct _xmlrpc_callback_data {
200 zval xmlrpc_method;
201 zval php_function;
202 zval caller_params;
203 zval return_data;
204 xmlrpc_server_data* server;
205 char php_executed;
206 } xmlrpc_callback_data;
207
208 /* output options */
209 #define OUTPUT_TYPE_KEY "output_type"
210 #define OUTPUT_TYPE_KEY_LEN (sizeof(OUTPUT_TYPE_KEY) - 1)
211 #define OUTPUT_TYPE_VALUE_PHP "php"
212 #define OUTPUT_TYPE_VALUE_XML "xml"
213
214 #define VERBOSITY_KEY "verbosity"
215 #define VERBOSITY_KEY_LEN (sizeof(VERBOSITY_KEY) - 1)
216 #define VERBOSITY_VALUE_NO_WHITE_SPACE "no_white_space"
217 #define VERBOSITY_VALUE_NEWLINES_ONLY "newlines_only"
218 #define VERBOSITY_VALUE_PRETTY "pretty"
219
220 #define ESCAPING_KEY "escaping"
221 #define ESCAPING_KEY_LEN (sizeof(ESCAPING_KEY) - 1)
222 #define ESCAPING_VALUE_CDATA "cdata"
223 #define ESCAPING_VALUE_NON_ASCII "non-ascii"
224 #define ESCAPING_VALUE_NON_PRINT "non-print"
225 #define ESCAPING_VALUE_MARKUP "markup"
226
227 #define VERSION_KEY "version"
228 #define VERSION_KEY_LEN (sizeof(VERSION_KEY) - 1)
229 #define VERSION_VALUE_SIMPLE "simple"
230 #define VERSION_VALUE_XMLRPC "xmlrpc"
231 #define VERSION_VALUE_SOAP11 "soap 1.1"
232 #define VERSION_VALUE_AUTO "auto"
233
234 #define ENCODING_KEY "encoding"
235 #define ENCODING_KEY_LEN (sizeof(ENCODING_KEY) - 1)
236 #define ENCODING_DEFAULT "iso-8859-1"
237
238 /* value types */
239 #define OBJECT_TYPE_ATTR "xmlrpc_type"
240 #define OBJECT_VALUE_ATTR "scalar"
241 #define OBJECT_VALUE_TS_ATTR "timestamp"
242
243 /* faults */
244 #define FAULT_CODE "faultCode"
245 #define FAULT_CODE_LEN (sizeof(FAULT_CODE) - 1)
246 #define FAULT_STRING "faultString"
247 #define FAULT_STRING_LEN (sizeof(FAULT_STRING) - 1)
248
249 /***********************
250 * forward declarations *
251 ***********************/
252 XMLRPC_VALUE_TYPE get_zval_xmlrpc_type(zval* value, zval* newvalue);
253 static void php_xmlrpc_introspection_callback(XMLRPC_SERVER server, void* data);
254 int sset_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE type);
255 void decode_request_worker(char *xml_in, int xml_in_len, char *encoding_in, zval* method_name_out, zval *retval);
256 const char* xmlrpc_type_as_str(XMLRPC_VALUE_TYPE type, XMLRPC_VECTOR_TYPE vtype);
257 XMLRPC_VALUE_TYPE xmlrpc_str_as_type(const char* str);
258 XMLRPC_VECTOR_TYPE xmlrpc_str_as_vector_type(const char* str);
259 int set_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE type);
260
261 /*********************
262 * startup / shutdown *
263 *********************/
264
destroy_server_data(xmlrpc_server_data * server)265 static void destroy_server_data(xmlrpc_server_data *server)
266 {
267 if (server) {
268 XMLRPC_ServerDestroy(server->server_ptr);
269
270 zval_ptr_dtor(&server->method_map);
271 zval_ptr_dtor(&server->introspection_map);
272
273 efree(server);
274 }
275 }
276
277 /* called when server is being destructed. either when xmlrpc_server_destroy
278 * is called, or when request ends. */
xmlrpc_server_destructor(zend_resource * rsrc)279 static void xmlrpc_server_destructor(zend_resource *rsrc)
280 {
281 if (rsrc && rsrc->ptr) {
282 rsrc->gc.refcount++;
283 destroy_server_data((xmlrpc_server_data*) rsrc->ptr);
284 rsrc->gc.refcount--;
285 }
286 }
287
288 /* module init */
PHP_MINIT_FUNCTION(xmlrpc)289 PHP_MINIT_FUNCTION(xmlrpc)
290 {
291 le_xmlrpc_server = zend_register_list_destructors_ex(xmlrpc_server_destructor, NULL, "xmlrpc server", module_number);
292
293 return SUCCESS;
294 }
295
296 /* display info in phpinfo() */
PHP_MINFO_FUNCTION(xmlrpc)297 PHP_MINFO_FUNCTION(xmlrpc)
298 {
299 php_info_print_table_start();
300 php_info_print_table_row(2, "core library version", XMLRPC_GetVersionString());
301 php_info_print_table_row(2, "php extension version", PHP_XMLRPC_VERSION);
302 php_info_print_table_row(2, "author", "Dan Libby");
303 php_info_print_table_row(2, "homepage", "http://xmlrpc-epi.sourceforge.net");
304 php_info_print_table_row(2, "open sourced by", "Epinions.com");
305 php_info_print_table_end();
306 }
307
308 /*******************
309 * random utilities *
310 *******************/
311
312 /* Utility functions for adding data types to arrays, with or without key (assoc, non-assoc).
313 * Could easily be further generalized to work with objects.
314 */
315 #if 0
316 static int add_long(zval* list, char* id, int num) {
317 if(id) return add_assoc_long(list, id, num);
318 else return add_next_index_long(list, num);
319 }
320
321 static int add_double(zval* list, char* id, double num) {
322 if(id) return add_assoc_double(list, id, num);
323 else return add_next_index_double(list, num);
324 }
325
326 static int add_string(zval* list, char* id, char* string) {
327 if(id) return add_assoc_string(list, id, string);
328 else return add_next_index_string(list, string);
329 }
330
331 static int add_stringl(zval* list, char* id, char* string, uint length) {
332 if(id) return add_assoc_stringl(list, id, string, length);
333 else return add_next_index_stringl(list, string, length);
334 }
335
336 #endif
337
add_zval(zval * list,const char * id,zval * val)338 static void add_zval(zval* list, const char* id, zval* val)
339 {
340 if (list && val) {
341 if (id) {
342 int id_len = strlen(id);
343 if (!(id_len > 1 && id[0] == '0') && is_numeric_string((char *)id, id_len, NULL, NULL, 0) == IS_LONG) {
344 long index = strtol(id, NULL, 0);
345 zend_hash_index_update(Z_ARRVAL_P(list), index, val);
346 } else {
347 zend_hash_str_update(Z_ARRVAL_P(list), (char*)id, strlen(id), val);
348 }
349 } else {
350 zend_hash_next_index_insert(Z_ARRVAL_P(list), val);
351 }
352 }
353 }
354
355 /*************************
356 * input / output options *
357 *************************/
358
359 /* parse an array (user input) into output options suitable for use by xmlrpc engine
360 * and determine whether to return data as xml or php vars */
set_output_options(php_output_options * options,zval * output_opts)361 static void set_output_options(php_output_options* options, zval* output_opts)
362 {
363 if (options) {
364 /* defaults */
365 options->b_php_out = 0;
366 options->b_auto_version = 1;
367 options->xmlrpc_out.version = xmlrpc_version_1_0;
368 options->xmlrpc_out.xml_elem_opts.encoding = ENCODING_DEFAULT;
369 options->xmlrpc_out.xml_elem_opts.verbosity = xml_elem_pretty;
370 options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_markup_escaping | xml_elem_non_ascii_escaping | xml_elem_non_print_escaping;
371
372 if (output_opts && Z_TYPE_P(output_opts) == IS_ARRAY) {
373 zval* val;
374
375 /* type of output (xml/php) */
376 if ((val = zend_hash_str_find(Z_ARRVAL_P(output_opts), OUTPUT_TYPE_KEY, OUTPUT_TYPE_KEY_LEN)) != NULL) {
377 if (Z_TYPE_P(val) == IS_STRING) {
378 if (!strcmp(Z_STRVAL_P(val), OUTPUT_TYPE_VALUE_PHP)) {
379 options->b_php_out = 1;
380 } else if (!strcmp(Z_STRVAL_P(val), OUTPUT_TYPE_VALUE_XML)) {
381 options->b_php_out = 0;
382 }
383 }
384 }
385
386 /* verbosity of generated xml */
387 if ((val = zend_hash_str_find(Z_ARRVAL_P(output_opts), VERBOSITY_KEY, VERBOSITY_KEY_LEN)) != NULL) {
388 if (Z_TYPE_P(val) == IS_STRING) {
389 if (!strcmp(Z_STRVAL_P(val), VERBOSITY_VALUE_NO_WHITE_SPACE)) {
390 options->xmlrpc_out.xml_elem_opts.verbosity = xml_elem_no_white_space;
391 } else if (!strcmp(Z_STRVAL_P(val), VERBOSITY_VALUE_NEWLINES_ONLY)) {
392 options->xmlrpc_out.xml_elem_opts.verbosity = xml_elem_newlines_only;
393 } else if (!strcmp(Z_STRVAL_P(val), VERBOSITY_VALUE_PRETTY)) {
394 options->xmlrpc_out.xml_elem_opts.verbosity = xml_elem_pretty;
395 }
396 }
397 }
398
399 /* version of xml to output */
400 if ((val = zend_hash_str_find(Z_ARRVAL_P(output_opts), VERSION_KEY, VERSION_KEY_LEN)) != NULL) {
401 if (Z_TYPE_P(val) == IS_STRING) {
402 options->b_auto_version = 0;
403 if (!strcmp(Z_STRVAL_P(val), VERSION_VALUE_XMLRPC)) {
404 options->xmlrpc_out.version = xmlrpc_version_1_0;
405 } else if (!strcmp(Z_STRVAL_P(val), VERSION_VALUE_SIMPLE)) {
406 options->xmlrpc_out.version = xmlrpc_version_simple;
407 } else if (!strcmp(Z_STRVAL_P(val), VERSION_VALUE_SOAP11)) {
408 options->xmlrpc_out.version = xmlrpc_version_soap_1_1;
409 } else { /* if(!strcmp(Z_STRVAL_P(val), VERSION_VALUE_AUTO)) { */
410 options->b_auto_version = 1;
411 }
412 }
413
414 }
415
416 /* encoding code set */
417 if ((val = zend_hash_str_find(Z_ARRVAL_P(output_opts), ENCODING_KEY, ENCODING_KEY_LEN)) != NULL) {
418 if (Z_TYPE_P(val) == IS_STRING) {
419 options->xmlrpc_out.xml_elem_opts.encoding = estrdup(Z_STRVAL_P(val));
420 }
421 }
422
423 /* escaping options */
424 if ((val = zend_hash_str_find(Z_ARRVAL_P(output_opts), ESCAPING_KEY, ESCAPING_KEY_LEN)) != NULL) {
425 /* multiple values allowed. check if array */
426 if (Z_TYPE_P(val) == IS_ARRAY) {
427 zval* iter_val;
428
429 options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_no_escaping;
430
431 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(val), iter_val) {
432 if (Z_TYPE_P(iter_val) == IS_STRING && Z_STRVAL_P(iter_val)) {
433 if (!strcmp(Z_STRVAL_P(iter_val), ESCAPING_VALUE_CDATA)) {
434 options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_cdata_escaping;
435 } else if (!strcmp(Z_STRVAL_P(iter_val), ESCAPING_VALUE_NON_ASCII)) {
436 options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_non_ascii_escaping;
437 } else if (!strcmp(Z_STRVAL_P(iter_val), ESCAPING_VALUE_NON_PRINT)) {
438 options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_non_print_escaping;
439 } else if (!strcmp(Z_STRVAL_P(iter_val), ESCAPING_VALUE_MARKUP)) {
440 options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_markup_escaping;
441 }
442 }
443 } ZEND_HASH_FOREACH_END();
444 /* else, check for single value */
445 } else if (Z_TYPE_P(val) == IS_STRING) {
446 if (!strcmp(Z_STRVAL_P(val), ESCAPING_VALUE_CDATA)) {
447 options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_cdata_escaping;
448 } else if (!strcmp(Z_STRVAL_P(val), ESCAPING_VALUE_NON_ASCII)) {
449 options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_non_ascii_escaping;
450 } else if (!strcmp(Z_STRVAL_P(val), ESCAPING_VALUE_NON_PRINT)) {
451 options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_non_print_escaping;
452 } else if (!strcmp(Z_STRVAL_P(val), ESCAPING_VALUE_MARKUP)) {
453 options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_markup_escaping;
454 }
455 }
456 }
457 }
458 }
459 }
460
461
462 /******************
463 * encode / decode *
464 ******************/
465
466 /* php arrays have no distinction between array and struct types.
467 * they even allow mixed. Thus, we determine the type by iterating
468 * through the entire array and figuring out each element.
469 * room for some optimation here if we stop after a specific # of elements.
470 */
determine_vector_type(HashTable * ht)471 static XMLRPC_VECTOR_TYPE determine_vector_type (HashTable *ht)
472 {
473 int bArray = 0, bStruct = 0, bMixed = 0;
474 zend_ulong num_index, last_num = 0;
475 zend_string* my_key;
476
477 ZEND_HASH_FOREACH_KEY(ht, num_index, my_key) {
478 if (my_key == NULL) {
479 if (bStruct) {
480 bMixed = 1;
481 break;
482 } else if (last_num > 0 && last_num != num_index-1) {
483 bStruct = 1;
484 break;
485 }
486 bArray = 1;
487 last_num = num_index;
488 } else {
489 if (bArray) {
490 bMixed = 1;
491 break;
492 }
493 bStruct = 1;
494 }
495 } ZEND_HASH_FOREACH_END();
496 return bMixed ? xmlrpc_vector_mixed : (bStruct ? xmlrpc_vector_struct : xmlrpc_vector_array);
497 }
498
499 /* recursively convert php values into xmlrpc values */
PHP_to_XMLRPC_worker(const char * key,zval * in_val,int depth)500 static XMLRPC_VALUE PHP_to_XMLRPC_worker (const char* key, zval* in_val, int depth)
501 {
502 XMLRPC_VALUE xReturn = NULL;
503
504 if (in_val) {
505 zval val;
506 XMLRPC_VALUE_TYPE type;
507
508 ZVAL_UNDEF(&val);
509 type = get_zval_xmlrpc_type(in_val, &val);
510
511 if (!Z_ISUNDEF(val)) {
512 switch (type) {
513 case xmlrpc_base64:
514 if (Z_TYPE(val) == IS_NULL) {
515 xReturn = XMLRPC_CreateValueEmpty();
516 XMLRPC_SetValueID(xReturn, key, 0);
517 } else {
518 if (Z_TYPE(val) != IS_STRING) {
519 zval newvalue;
520 ZVAL_DUP(&newvalue, &val);
521 convert_to_string(&newvalue);
522 xReturn = XMLRPC_CreateValueBase64(key, Z_STRVAL(newvalue), Z_STRLEN(newvalue));
523 zval_dtor(&newvalue);
524 } else {
525 xReturn = XMLRPC_CreateValueBase64(key, Z_STRVAL(val), Z_STRLEN(val));
526 }
527 }
528 break;
529 case xmlrpc_datetime:
530 convert_to_string(&val);
531 xReturn = XMLRPC_CreateValueDateTime_ISO8601(key, Z_STRVAL(val));
532 break;
533 case xmlrpc_boolean:
534 convert_to_boolean(&val);
535 xReturn = XMLRPC_CreateValueBoolean(key, Z_TYPE(val) == IS_TRUE);
536 break;
537 case xmlrpc_int:
538 ZVAL_LONG(&val, zval_get_long(&val));
539 xReturn = XMLRPC_CreateValueInt(key, Z_LVAL(val));
540 break;
541 case xmlrpc_double:
542 convert_to_double(&val);
543 xReturn = XMLRPC_CreateValueDouble(key, Z_DVAL(val));
544 break;
545 case xmlrpc_string:
546 convert_to_string(&val);
547 xReturn = XMLRPC_CreateValueString(key, Z_STRVAL(val), Z_STRLEN(val));
548 break;
549 case xmlrpc_vector:
550 {
551 zend_ulong num_index;
552 zval* pIter;
553 zend_string* my_key;
554 HashTable *ht = NULL;
555 zval val_arr;
556 XMLRPC_VECTOR_TYPE vtype;
557
558 ht = HASH_OF(&val);
559 if (ht && ht->u.v.nApplyCount > 1) {
560 php_error_docref(NULL, E_ERROR, "XML-RPC doesn't support circular references");
561 return NULL;
562 }
563
564 ZVAL_COPY(&val_arr, &val);
565 convert_to_array(&val_arr);
566
567 vtype = determine_vector_type(Z_ARRVAL(val_arr));
568 xReturn = XMLRPC_CreateVector(key, vtype);
569
570 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL(val_arr), num_index, my_key, pIter) {
571 ZVAL_DEREF(pIter);
572 ht = HASH_OF(pIter);
573 if (ht) {
574 ht->u.v.nApplyCount++;
575 }
576 if (my_key == NULL) {
577 char *num_str = NULL;
578
579 if (vtype != xmlrpc_vector_array) {
580 spprintf(&num_str, 0, "%ld", num_index);
581 }
582
583 XMLRPC_AddValueToVector(xReturn, PHP_to_XMLRPC_worker(num_str, pIter, depth++));
584 if (num_str) {
585 efree(num_str);
586 }
587 } else {
588 XMLRPC_AddValueToVector(xReturn, PHP_to_XMLRPC_worker(ZSTR_VAL(my_key), pIter, depth++));
589 }
590 if (ht) {
591 ht->u.v.nApplyCount--;
592 }
593 } ZEND_HASH_FOREACH_END();
594 zval_ptr_dtor(&val_arr);
595 }
596 break;
597 default:
598 break;
599 }
600 }
601 }
602 return xReturn;
603 }
604
PHP_to_XMLRPC(zval * root_val)605 static XMLRPC_VALUE PHP_to_XMLRPC(zval* root_val)
606 {
607 return PHP_to_XMLRPC_worker(NULL, root_val, 0);
608 }
609
610 /* recursively convert xmlrpc values into php values */
XMLRPC_to_PHP(XMLRPC_VALUE el,zval * elem)611 static void XMLRPC_to_PHP(XMLRPC_VALUE el, zval *elem)
612 {
613 const char* pStr;
614
615 if (el) {
616 XMLRPC_VALUE_TYPE type = XMLRPC_GetValueType(el);
617
618 switch (type) {
619 case xmlrpc_empty:
620 ZVAL_NULL(elem);
621 break;
622 case xmlrpc_string:
623 pStr = XMLRPC_GetValueString(el);
624 if (pStr) {
625 ZVAL_STRINGL(elem, pStr, XMLRPC_GetValueStringLen(el));
626 }
627 break;
628 case xmlrpc_int:
629 ZVAL_LONG(elem, XMLRPC_GetValueInt(el));
630 break;
631 case xmlrpc_boolean:
632 ZVAL_BOOL(elem, XMLRPC_GetValueBoolean(el));
633 break;
634 case xmlrpc_double:
635 ZVAL_DOUBLE(elem, XMLRPC_GetValueDouble(el));
636 break;
637 case xmlrpc_datetime:
638 ZVAL_STRINGL(elem, XMLRPC_GetValueDateTime_ISO8601(el), XMLRPC_GetValueStringLen(el));
639 break;
640 case xmlrpc_base64:
641 pStr = XMLRPC_GetValueBase64(el);
642 if (pStr) {
643 ZVAL_STRINGL(elem, pStr, XMLRPC_GetValueStringLen(el));
644 }
645 break;
646 case xmlrpc_vector:
647 array_init(elem);
648 {
649 XMLRPC_VALUE xIter = XMLRPC_VectorRewind(el);
650
651 while( xIter ) {
652 zval val;
653 ZVAL_UNDEF(&val);
654 XMLRPC_to_PHP(xIter, &val);
655 if (!Z_ISUNDEF(val)) {
656 add_zval(elem, XMLRPC_GetValueID(xIter), &val);
657 }
658 xIter = XMLRPC_VectorNext(el);
659 }
660 }
661 break;
662 default:
663 break;
664 }
665 set_zval_xmlrpc_type(elem, type);
666 }
667 }
668
669 /* {{{ proto string xmlrpc_encode_request(string method, mixed params [, array output_options])
670 Generates XML for a method request */
PHP_FUNCTION(xmlrpc_encode_request)671 PHP_FUNCTION(xmlrpc_encode_request)
672 {
673 XMLRPC_REQUEST xRequest = NULL;
674 char *outBuf;
675 zval *vals, *out_opts = NULL;
676 char *method = NULL;
677 size_t method_len;
678 php_output_options out;
679
680 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s!z|a", &method, &method_len, &vals, &out_opts) == FAILURE) {
681 return;
682 }
683
684 set_output_options(&out, out_opts ? out_opts : 0);
685
686 if (USED_RET()) {
687 xRequest = XMLRPC_RequestNew();
688
689 if (xRequest) {
690 XMLRPC_RequestSetOutputOptions(xRequest, &out.xmlrpc_out);
691 if (method == NULL) {
692 XMLRPC_RequestSetRequestType(xRequest, xmlrpc_request_response);
693 } else {
694 XMLRPC_RequestSetMethodName(xRequest, method);
695 XMLRPC_RequestSetRequestType(xRequest, xmlrpc_request_call);
696 }
697 if (Z_TYPE_P(vals) != IS_NULL) {
698 XMLRPC_RequestSetData(xRequest, PHP_to_XMLRPC(vals));
699 }
700
701 outBuf = XMLRPC_REQUEST_ToXML(xRequest, 0);
702 if (outBuf) {
703 RETVAL_STRING(outBuf);
704 free(outBuf);
705 }
706 XMLRPC_RequestFree(xRequest, 1);
707 }
708 }
709
710 if (strcmp(out.xmlrpc_out.xml_elem_opts.encoding, ENCODING_DEFAULT) != 0) {
711 efree((char *)out.xmlrpc_out.xml_elem_opts.encoding);
712 }
713 }
714 /* }}} */
715
716 /* {{{ proto string xmlrpc_encode(mixed value)
717 Generates XML for a PHP value */
PHP_FUNCTION(xmlrpc_encode)718 PHP_FUNCTION(xmlrpc_encode)
719 {
720 XMLRPC_VALUE xOut = NULL;
721 zval *arg1;
722 char *outBuf;
723
724 if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &arg1) == FAILURE) {
725 return;
726 }
727
728 if (USED_RET()) {
729 /* convert native php type to xmlrpc type */
730 xOut = PHP_to_XMLRPC(arg1);
731
732 /* generate raw xml from xmlrpc data */
733 outBuf = XMLRPC_VALUE_ToXML(xOut, 0);
734
735 if (xOut) {
736 if (outBuf) {
737 RETVAL_STRING(outBuf);
738 free(outBuf);
739 }
740 /* cleanup */
741 XMLRPC_CleanupValue(xOut);
742 }
743 }
744 }
745 /* }}} */
746
decode_request_worker(char * xml_in,int xml_in_len,char * encoding_in,zval * method_name_out,zval * retval)747 void decode_request_worker(char *xml_in, int xml_in_len, char *encoding_in, zval* method_name_out, zval *retval) /* {{{ */
748 {
749 XMLRPC_REQUEST response;
750 STRUCT_XMLRPC_REQUEST_INPUT_OPTIONS opts = {{0}};
751 const char *method_name;
752 opts.xml_elem_opts.encoding = encoding_in ? utf8_get_encoding_id_from_string(encoding_in) : ENCODING_DEFAULT;
753
754 /* generate XMLRPC_REQUEST from raw xml */
755 response = XMLRPC_REQUEST_FromXML(xml_in, xml_in_len, &opts);
756 if (response) {
757 ZVAL_NULL(retval);
758 /* convert xmlrpc data to native php types */
759 XMLRPC_to_PHP(XMLRPC_RequestGetData(response), retval);
760
761 if (XMLRPC_RequestGetRequestType(response) == xmlrpc_request_call) {
762 if (method_name_out) {
763 method_name = XMLRPC_RequestGetMethodName(response);
764 if (method_name) {
765 zval_ptr_dtor(method_name_out);
766 ZVAL_STRING(method_name_out, method_name);
767 } else {
768 zval_ptr_dtor(retval);
769 ZVAL_NULL(retval);
770 }
771 }
772 }
773
774 /* dust, sweep, and mop */
775 XMLRPC_RequestFree(response, 1);
776 }
777 }
778 /* }}} */
779
780 /* {{{ proto array xmlrpc_decode_request(string xml, string& method [, string encoding])
781 Decodes XML into native PHP types */
PHP_FUNCTION(xmlrpc_decode_request)782 PHP_FUNCTION(xmlrpc_decode_request)
783 {
784 char *xml, *encoding = NULL;
785 zval *method;
786 size_t xml_len, encoding_len = 0;
787
788 if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/|s", &xml, &xml_len, &method, &encoding, &encoding_len) == FAILURE) {
789 return;
790 }
791
792 if (USED_RET()) {
793 decode_request_worker(xml, xml_len, encoding_len ? encoding : NULL, method, return_value);
794 }
795 }
796 /* }}} */
797
798 /* {{{ proto array xmlrpc_decode(string xml [, string encoding])
799 Decodes XML into native PHP types */
PHP_FUNCTION(xmlrpc_decode)800 PHP_FUNCTION(xmlrpc_decode)
801 {
802 char *arg1, *arg2 = NULL;
803 size_t arg1_len, arg2_len = 0;
804
805 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", &arg1, &arg1_len, &arg2, &arg2_len) == FAILURE) {
806 return;
807 }
808
809 if (USED_RET()) {
810 decode_request_worker(arg1, arg1_len, arg2_len ? arg2 : NULL, NULL, return_value);
811 }
812 }
813 /* }}} */
814
815 /*************************
816 * server related methods *
817 *************************/
818
819 /* {{{ proto resource xmlrpc_server_create(void)
820 Creates an xmlrpc server */
PHP_FUNCTION(xmlrpc_server_create)821 PHP_FUNCTION(xmlrpc_server_create)
822 {
823 if (zend_parse_parameters_none() == FAILURE) {
824 return;
825 }
826
827 if (USED_RET()) {
828 xmlrpc_server_data *server = emalloc(sizeof(xmlrpc_server_data));
829
830 /* allocate server data. free'd in destroy_server_data() */
831 array_init(&server->method_map);
832 array_init(&server->introspection_map);
833 server->server_ptr = XMLRPC_ServerCreate();
834
835 XMLRPC_ServerRegisterIntrospectionCallback(server->server_ptr, php_xmlrpc_introspection_callback);
836
837 /* store for later use */
838 RETURN_RES(zend_register_resource(server, le_xmlrpc_server));
839 }
840 }
841 /* }}} */
842
843 /* {{{ proto int xmlrpc_server_destroy(resource server)
844 Destroys server resources */
PHP_FUNCTION(xmlrpc_server_destroy)845 PHP_FUNCTION(xmlrpc_server_destroy)
846 {
847 zval *arg1;
848 int bSuccess = FAILURE;
849 xmlrpc_server_data *server;
850
851 if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &arg1) == FAILURE) {
852 return;
853 }
854
855 if ((server = (xmlrpc_server_data *)zend_fetch_resource(Z_RES_P(arg1), "xmlrpc server", le_xmlrpc_server)) == NULL) {
856 RETURN_FALSE;
857 }
858
859 bSuccess = zend_list_close(Z_RES_P(arg1));
860 /* called by hashtable destructor
861 * destroy_server_data(server);
862 */
863 RETURN_BOOL(bSuccess == SUCCESS);
864 }
865 /* }}} */
866
867 /* called by xmlrpc C engine as method handler for all registered methods.
868 * it then calls the corresponding PHP function to handle the method.
869 */
php_xmlrpc_callback(XMLRPC_SERVER server,XMLRPC_REQUEST xRequest,void * data)870 static XMLRPC_VALUE php_xmlrpc_callback(XMLRPC_SERVER server, XMLRPC_REQUEST xRequest, void* data) /* {{{ */
871 {
872 xmlrpc_callback_data* pData = (xmlrpc_callback_data*)data;
873 zval* php_function;
874 zval xmlrpc_params;
875 zval callback_params[3];
876
877 zval_ptr_dtor(&pData->xmlrpc_method);
878 zval_ptr_dtor(&pData->return_data);
879
880 /* convert xmlrpc to native php types */
881 ZVAL_STRING(&pData->xmlrpc_method, XMLRPC_RequestGetMethodName(xRequest));
882 XMLRPC_to_PHP(XMLRPC_RequestGetData(xRequest), &xmlrpc_params);
883
884 /* check if the called method has been previous registered */
885 if ((php_function = zend_hash_find(Z_ARRVAL(pData->server->method_map), Z_STR(pData->xmlrpc_method))) != NULL) {
886 ZVAL_COPY_VALUE(&pData->php_function, php_function);
887 }
888
889 /* setup data hoojum */
890 ZVAL_COPY_VALUE(&callback_params[0], &pData->xmlrpc_method);
891 ZVAL_COPY_VALUE(&callback_params[1], &xmlrpc_params);
892 ZVAL_COPY_VALUE(&callback_params[2], &pData->caller_params);
893
894 /* Use same C function for all methods */
895
896 /* php func prototype: function user_func($method_name, $xmlrpc_params, $user_params) */
897 call_user_function(CG(function_table), NULL, &pData->php_function, &pData->return_data, 3, callback_params);
898
899 pData->php_executed = 1;
900
901 zval_ptr_dtor(&xmlrpc_params);
902
903 return PHP_to_XMLRPC(&pData->return_data);
904 }
905 /* }}} */
906
907 /* called by the C server when it first receives an introspection request. We pass this on to
908 * our PHP listeners, if any
909 */
php_xmlrpc_introspection_callback(XMLRPC_SERVER server,void * data)910 static void php_xmlrpc_introspection_callback(XMLRPC_SERVER server, void* data) /* {{{ */
911 {
912 zval retval, *php_function;
913 zval callback_params[1];
914 zend_string *php_function_name;
915 xmlrpc_callback_data* pData = (xmlrpc_callback_data*)data;
916
917 /* setup data hoojum */
918 ZVAL_COPY_VALUE(&callback_params[0], &pData->caller_params);
919
920 ZEND_HASH_FOREACH_VAL(Z_ARRVAL(pData->server->introspection_map), php_function) {
921 if (zend_is_callable(php_function, 0, &php_function_name)) {
922 /* php func prototype: function string user_func($user_params) */
923 if (call_user_function(CG(function_table), NULL, php_function, &retval, 1, callback_params) == SUCCESS) {
924 XMLRPC_VALUE xData;
925 STRUCT_XMLRPC_ERROR err = {0};
926
927 /* return value should be a string */
928 convert_to_string(&retval);
929
930 xData = XMLRPC_IntrospectionCreateDescription(Z_STRVAL(retval), &err);
931
932 if (xData) {
933 if (!XMLRPC_ServerAddIntrospectionData(server, xData)) {
934 php_error_docref(NULL, E_WARNING, "Unable to add introspection data returned from %s(), improper element structure", ZSTR_VAL(php_function_name));
935 }
936 XMLRPC_CleanupValue(xData);
937 } else {
938 /* could not create description */
939 if (err.xml_elem_error.parser_code) {
940 php_error_docref(NULL, E_WARNING, "xml parse error: [line %ld, column %ld, message: %s] Unable to add introspection data returned from %s()",
941 err.xml_elem_error.column, err.xml_elem_error.line, err.xml_elem_error.parser_error, ZSTR_VAL(php_function_name));
942 } else {
943 php_error_docref(NULL, E_WARNING, "Unable to add introspection data returned from %s()", ZSTR_VAL(php_function_name));
944 }
945 }
946 zval_ptr_dtor(&retval);
947 } else {
948 /* user func failed */
949 php_error_docref(NULL, E_WARNING, "Error calling user introspection callback: %s()", ZSTR_VAL(php_function_name));
950 }
951 } else {
952 php_error_docref(NULL, E_WARNING, "Invalid callback '%s' passed", ZSTR_VAL(php_function_name));
953 }
954 zend_string_release(php_function_name);
955 } ZEND_HASH_FOREACH_END();
956
957 /* so we don't call the same callbacks ever again */
958 zend_hash_clean(Z_ARRVAL(pData->server->introspection_map));
959 }
960 /* }}} */
961
962 /* {{{ proto bool xmlrpc_server_register_method(resource server, string method_name, string function)
963 Register a PHP function to handle method matching method_name */
PHP_FUNCTION(xmlrpc_server_register_method)964 PHP_FUNCTION(xmlrpc_server_register_method)
965 {
966 char *method_key;
967 size_t method_key_len;
968 zval *handle, *method_name;
969 xmlrpc_server_data* server;
970
971 if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsz", &handle, &method_key, &method_key_len, &method_name) == FAILURE) {
972 return;
973 }
974
975 if ((server = (xmlrpc_server_data *)zend_fetch_resource(Z_RES_P(handle), "xmlrpc server", le_xmlrpc_server)) == NULL) {
976 RETURN_FALSE;
977 }
978
979 /* register with C engine. every method just calls our standard callback,
980 * and it then dispatches to php as necessary
981 */
982 if (XMLRPC_ServerRegisterMethod(server->server_ptr, method_key, php_xmlrpc_callback)) {
983 /* save for later use */
984
985 if (Z_REFCOUNTED_P(method_name)) {
986 Z_ADDREF_P(method_name);
987 }
988 /* register our php method */
989 add_zval(&server->method_map, method_key, method_name);
990
991 RETURN_TRUE;
992 }
993 }
994 /* }}} */
995
996 /* {{{ proto bool xmlrpc_server_register_introspection_callback(resource server, string function)
997 Register a PHP function to generate documentation */
PHP_FUNCTION(xmlrpc_server_register_introspection_callback)998 PHP_FUNCTION(xmlrpc_server_register_introspection_callback)
999 {
1000 zval *method_name, *handle;
1001 xmlrpc_server_data* server;
1002
1003 if (zend_parse_parameters(ZEND_NUM_ARGS(), "rz", &handle, &method_name) == FAILURE) {
1004 return;
1005 }
1006
1007 if ((server = (xmlrpc_server_data *)zend_fetch_resource(Z_RES_P(handle), "xmlrpc server", le_xmlrpc_server)) == NULL) {
1008 RETURN_FALSE;
1009 }
1010
1011 if (Z_REFCOUNTED_P(method_name)) {
1012 Z_ADDREF_P(method_name);
1013 }
1014 /* register our php method */
1015 add_zval(&server->introspection_map, NULL, method_name);
1016
1017 RETURN_TRUE;
1018 }
1019 /* }}} */
1020
1021 /* this function is itchin for a re-write */
1022
1023 /* {{{ proto mixed xmlrpc_server_call_method(resource server, string xml, mixed user_data [, array output_options])
1024 Parses XML requests and call methods */
PHP_FUNCTION(xmlrpc_server_call_method)1025 PHP_FUNCTION(xmlrpc_server_call_method)
1026 {
1027 XMLRPC_REQUEST xRequest;
1028 xmlrpc_callback_data data;
1029 STRUCT_XMLRPC_REQUEST_INPUT_OPTIONS input_opts;
1030 xmlrpc_server_data* server;
1031 zval *caller_params, *handle, *output_opts = NULL;
1032 char *rawxml;
1033 size_t rawxml_len;
1034 php_output_options out;
1035 int argc = ZEND_NUM_ARGS();
1036
1037 if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsz|a", &handle, &rawxml, &rawxml_len, &caller_params, &output_opts) != SUCCESS) {
1038 return;
1039 }
1040 /* user output options */
1041 if (argc == 3) {
1042 set_output_options(&out, NULL);
1043 } else {
1044 set_output_options(&out, output_opts);
1045 }
1046
1047 if ((server = (xmlrpc_server_data *)zend_fetch_resource(Z_RES_P(handle), "xmlrpc server", le_xmlrpc_server)) == NULL) {
1048 RETURN_FALSE;
1049 }
1050
1051 /* HACK: use output encoding for now */
1052 input_opts.xml_elem_opts.encoding = utf8_get_encoding_id_from_string(out.xmlrpc_out.xml_elem_opts.encoding);
1053
1054 /* generate an XMLRPC_REQUEST from the raw xml input */
1055 xRequest = XMLRPC_REQUEST_FromXML(rawxml, rawxml_len, &input_opts);
1056
1057 if (xRequest) {
1058 const char* methodname = XMLRPC_RequestGetMethodName(xRequest);
1059 XMLRPC_VALUE xAnswer = NULL;
1060 ZVAL_NULL(&data.xmlrpc_method); /* init. very important. spent a frustrating day finding this out. */
1061 ZVAL_NULL(&data.return_data);
1062 ZVAL_NULL(&data.return_data); /* in case value is never init'd, we don't dtor to think it is a string or something */
1063 ZVAL_NULL(&data.xmlrpc_method);
1064
1065 /* setup some data to pass to the callback function */
1066 ZVAL_COPY_VALUE(&data.caller_params, caller_params);
1067 data.php_executed = 0;
1068 data.server = server;
1069
1070 /* We could just call the php method directly ourselves at this point, but we do this
1071 * with a C callback in case the xmlrpc library ever implements some cool usage stats,
1072 * or somesuch.
1073 */
1074 xAnswer = XMLRPC_ServerCallMethod(server->server_ptr, xRequest, &data);
1075 if (xAnswer && out.b_php_out) {
1076 XMLRPC_to_PHP(xAnswer, &data.return_data);
1077 } else if (data.php_executed && !out.b_php_out && !xAnswer) {
1078 xAnswer = PHP_to_XMLRPC(&data.return_data);
1079 }
1080
1081 /* should we return data as xml? */
1082 if (!out.b_php_out) {
1083 XMLRPC_REQUEST xResponse = XMLRPC_RequestNew();
1084 if (xResponse) {
1085 char *outBuf = 0;
1086 int buf_len = 0;
1087
1088 /* automagically determine output serialization type from request type */
1089 if (out.b_auto_version) {
1090 XMLRPC_REQUEST_OUTPUT_OPTIONS opts = XMLRPC_RequestGetOutputOptions(xRequest);
1091 if (opts) {
1092 out.xmlrpc_out.version = opts->version;
1093 }
1094 }
1095 /* set some required request hoojum */
1096 XMLRPC_RequestSetOutputOptions(xResponse, &out.xmlrpc_out);
1097 XMLRPC_RequestSetRequestType(xResponse, xmlrpc_request_response);
1098 XMLRPC_RequestSetData(xResponse, xAnswer);
1099 XMLRPC_RequestSetMethodName(xResponse, methodname);
1100
1101 /* generate xml */
1102 outBuf = XMLRPC_REQUEST_ToXML(xResponse, &buf_len);
1103 if (outBuf) {
1104 RETVAL_STRINGL(outBuf, buf_len);
1105 free(outBuf);
1106 }
1107 /* cleanup after ourselves. what a sty! */
1108 XMLRPC_RequestFree(xResponse, 0);
1109 }
1110 } else { /* or as native php types? */
1111 ZVAL_COPY(return_value, &data.return_data);
1112 }
1113
1114 /* cleanup after ourselves. what a sty! */
1115 zval_ptr_dtor(&data.xmlrpc_method);
1116 zval_ptr_dtor(&data.return_data);
1117
1118 if (xAnswer) {
1119 XMLRPC_CleanupValue(xAnswer);
1120 }
1121
1122 XMLRPC_RequestFree(xRequest, 1);
1123 }
1124 }
1125 /* }}} */
1126
1127 /* {{{ proto int xmlrpc_server_add_introspection_data(resource server, array desc)
1128 Adds introspection documentation */
PHP_FUNCTION(xmlrpc_server_add_introspection_data)1129 PHP_FUNCTION(xmlrpc_server_add_introspection_data)
1130 {
1131 zval *handle, *desc;
1132 xmlrpc_server_data* server;
1133 XMLRPC_VALUE xDesc;
1134
1135 if (zend_parse_parameters(ZEND_NUM_ARGS(), "ra", &handle, &desc) == FAILURE) {
1136 return;
1137 }
1138
1139 if ((server = (xmlrpc_server_data *)zend_fetch_resource(Z_RES_P(handle), "xmlrpc server", le_xmlrpc_server)) == NULL) {
1140 RETURN_FALSE;
1141 }
1142
1143 xDesc = PHP_to_XMLRPC(desc);
1144 if (xDesc) {
1145 int retval = XMLRPC_ServerAddIntrospectionData(server->server_ptr, xDesc);
1146 XMLRPC_CleanupValue(xDesc);
1147 RETURN_LONG(retval);
1148 }
1149 RETURN_LONG(0);
1150 }
1151 /* }}} */
1152
1153 /* {{{ proto array xmlrpc_parse_method_descriptions(string xml)
1154 Decodes XML into a list of method descriptions */
PHP_FUNCTION(xmlrpc_parse_method_descriptions)1155 PHP_FUNCTION(xmlrpc_parse_method_descriptions)
1156 {
1157 char *arg1;
1158 size_t arg1_len;
1159
1160 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &arg1, &arg1_len) == FAILURE) {
1161 return;
1162 }
1163
1164 if (USED_RET()) {
1165 STRUCT_XMLRPC_ERROR err = {0};
1166 XMLRPC_VALUE xVal = XMLRPC_IntrospectionCreateDescription(arg1, &err);
1167 if (xVal) {
1168 XMLRPC_to_PHP(xVal, return_value);
1169 /* dust, sweep, and mop */
1170 XMLRPC_CleanupValue(xVal);
1171 } else {
1172 /* could not create description */
1173 if (err.xml_elem_error.parser_code) {
1174 php_error_docref(NULL, E_WARNING, "xml parse error: [line %ld, column %ld, message: %s] Unable to create introspection data",
1175 err.xml_elem_error.column, err.xml_elem_error.line, err.xml_elem_error.parser_error);
1176 } else {
1177 php_error_docref(NULL, E_WARNING, "Invalid xml structure. Unable to create introspection data");
1178 }
1179
1180 php_error_docref(NULL, E_WARNING, "xml parse error. no method description created");
1181 }
1182 }
1183 }
1184 /* }}} */
1185
1186 /************
1187 * type data *
1188 ************/
1189
1190 #define XMLRPC_TYPE_COUNT 9
1191 #define XMLRPC_VECTOR_TYPE_COUNT 4
1192 #define TYPE_STR_MAP_SIZE (XMLRPC_TYPE_COUNT + XMLRPC_VECTOR_TYPE_COUNT)
1193
1194 /* return a string matching a given xmlrpc type */
get_type_str_mapping(void)1195 static const char** get_type_str_mapping(void) /* {{{ */
1196 {
1197 static const char* str_mapping[TYPE_STR_MAP_SIZE];
1198 static int first = 1;
1199 if (first) {
1200 /* warning. do not add/delete without changing size define */
1201 str_mapping[xmlrpc_none] = "none";
1202 str_mapping[xmlrpc_empty] = "empty";
1203 str_mapping[xmlrpc_base64] = "base64";
1204 str_mapping[xmlrpc_boolean] = "boolean";
1205 str_mapping[xmlrpc_datetime] = "datetime";
1206 str_mapping[xmlrpc_double] = "double";
1207 str_mapping[xmlrpc_int] = "int";
1208 str_mapping[xmlrpc_string] = "string";
1209 str_mapping[xmlrpc_vector] = "vector";
1210 str_mapping[XMLRPC_TYPE_COUNT + xmlrpc_vector_none] = "none";
1211 str_mapping[XMLRPC_TYPE_COUNT + xmlrpc_vector_array] = "array";
1212 str_mapping[XMLRPC_TYPE_COUNT + xmlrpc_vector_mixed] = "mixed";
1213 str_mapping[XMLRPC_TYPE_COUNT + xmlrpc_vector_struct] = "struct";
1214 first = 0;
1215 }
1216 return (const char**)str_mapping;
1217 }
1218 /* }}} */
1219
1220 /* map an xmlrpc type to a string */
xmlrpc_type_as_str(XMLRPC_VALUE_TYPE type,XMLRPC_VECTOR_TYPE vtype)1221 const char* xmlrpc_type_as_str(XMLRPC_VALUE_TYPE type, XMLRPC_VECTOR_TYPE vtype) /* {{{ */
1222 {
1223 const char** str_mapping = get_type_str_mapping();
1224
1225 if (vtype == xmlrpc_vector_none) {
1226 return str_mapping[type];
1227 } else {
1228 return str_mapping[XMLRPC_TYPE_COUNT + vtype];
1229 }
1230 }
1231 /* }}} */
1232
1233 /* map a string to an xmlrpc type */
xmlrpc_str_as_type(const char * str)1234 XMLRPC_VALUE_TYPE xmlrpc_str_as_type(const char* str) /* {{{ */
1235 {
1236 const char** str_mapping = get_type_str_mapping();
1237 int i;
1238
1239 if (str) {
1240 for (i = 0; i < XMLRPC_TYPE_COUNT; i++) {
1241 if (!strcmp(str_mapping[i], str)) {
1242 return (XMLRPC_VALUE_TYPE) i;
1243 }
1244 }
1245 }
1246 return xmlrpc_none;
1247 }
1248 /* }}} */
1249
1250 /* map a string to an xmlrpc vector type */
xmlrpc_str_as_vector_type(const char * str)1251 XMLRPC_VECTOR_TYPE xmlrpc_str_as_vector_type(const char* str) /* {{{ */
1252 {
1253 const char** str_mapping = get_type_str_mapping();
1254 int i;
1255
1256 if (str) {
1257 for (i = XMLRPC_TYPE_COUNT; i < TYPE_STR_MAP_SIZE; i++) {
1258 if (!strcmp(str_mapping[i], str)) {
1259 return (XMLRPC_VECTOR_TYPE) (i - XMLRPC_TYPE_COUNT);
1260 }
1261 }
1262 }
1263 return xmlrpc_none;
1264 }
1265 /* }}} */
1266
1267 /* set a given value to a particular type.
1268 * note: this only works on strings, and only for date and base64,
1269 * which do not have native php types. black magic lies herein.
1270 */
set_zval_xmlrpc_type(zval * value,XMLRPC_VALUE_TYPE newtype)1271 int set_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE newtype) /* {{{ */
1272 {
1273 int bSuccess = FAILURE;
1274
1275 /* we only really care about strings because they can represent
1276 * base64 and datetime. all other types have corresponding php types
1277 */
1278 if (Z_TYPE_P(value) == IS_STRING) {
1279 if (newtype == xmlrpc_base64 || newtype == xmlrpc_datetime) {
1280 const char* typestr = xmlrpc_type_as_str(newtype, xmlrpc_vector_none);
1281 zval type;
1282
1283 ZVAL_STRING(&type, typestr);
1284
1285 if (newtype == xmlrpc_datetime) {
1286 XMLRPC_VALUE v = XMLRPC_CreateValueDateTime_ISO8601(NULL, Z_STRVAL_P(value));
1287 if (v) {
1288 time_t timestamp = (time_t) php_parse_date((char *)XMLRPC_GetValueDateTime_ISO8601(v), NULL);
1289 if (timestamp != -1) {
1290 zval ztimestamp;
1291
1292 ZVAL_LONG(&ztimestamp, timestamp);
1293
1294 convert_to_object(value);
1295 if (zend_hash_str_update(Z_OBJPROP_P(value), OBJECT_TYPE_ATTR, sizeof(OBJECT_TYPE_ATTR) - 1, &type)) {
1296 bSuccess = (zend_hash_str_update(Z_OBJPROP_P(value), OBJECT_VALUE_TS_ATTR, sizeof(OBJECT_VALUE_TS_ATTR) - 1, &ztimestamp) != NULL)? SUCCESS : FAILURE;
1297 }
1298 } else {
1299 zval_ptr_dtor(&type);
1300 }
1301 XMLRPC_CleanupValue(v);
1302 } else {
1303 zval_ptr_dtor(&type);
1304 }
1305 } else {
1306 convert_to_object(value);
1307 bSuccess = (zend_hash_str_update(Z_OBJPROP_P(value), OBJECT_TYPE_ATTR, sizeof(OBJECT_TYPE_ATTR) - 1, &type) != NULL)? SUCCESS : FAILURE;
1308 }
1309 }
1310 }
1311
1312 return bSuccess;
1313 }
1314 /* }}} */
1315
1316 /* return xmlrpc type of a php value */
get_zval_xmlrpc_type(zval * value,zval * newvalue)1317 XMLRPC_VALUE_TYPE get_zval_xmlrpc_type(zval* value, zval* newvalue) /* {{{ */
1318 {
1319 XMLRPC_VALUE_TYPE type = xmlrpc_none;
1320
1321 if (value) {
1322 switch (Z_TYPE_P(value)) {
1323 case IS_NULL:
1324 type = xmlrpc_base64;
1325 break;
1326 #ifndef BOOL_AS_LONG
1327
1328 /* Right thing to do, but it breaks some legacy code. */
1329 case IS_TRUE:
1330 case IS_FALSE:
1331 type = xmlrpc_boolean;
1332 break;
1333 #else
1334 case IS_BOOL:
1335 #endif
1336 case IS_LONG:
1337 case IS_RESOURCE:
1338 type = xmlrpc_int;
1339 break;
1340 case IS_DOUBLE:
1341 type = xmlrpc_double;
1342 break;
1343 case IS_CONSTANT:
1344 type = xmlrpc_string;
1345 break;
1346 case IS_STRING:
1347 type = xmlrpc_string;
1348 break;
1349 case IS_ARRAY:
1350 type = xmlrpc_vector;
1351 break;
1352 case IS_OBJECT:
1353 {
1354 zval* attr;
1355 type = xmlrpc_vector;
1356
1357 if ((attr = zend_hash_str_find_ind(Z_OBJPROP_P(value), OBJECT_TYPE_ATTR, sizeof(OBJECT_TYPE_ATTR) - 1)) != NULL) {
1358 if (Z_TYPE_P(attr) == IS_STRING) {
1359 type = xmlrpc_str_as_type(Z_STRVAL_P(attr));
1360 }
1361 }
1362 break;
1363 }
1364 }
1365
1366 /* if requested, return an unmolested (magic removed) copy of the value */
1367 if (newvalue) {
1368 zval* val;
1369
1370 if ((type == xmlrpc_base64 && Z_TYPE_P(value) == IS_OBJECT) || type == xmlrpc_datetime) {
1371 if ((val = zend_hash_str_find_ind(Z_OBJPROP_P(value), OBJECT_VALUE_ATTR, sizeof(OBJECT_VALUE_ATTR) - 1)) != NULL) {
1372 ZVAL_COPY_VALUE(newvalue, val);
1373 }
1374 } else {
1375 ZVAL_COPY_VALUE(newvalue, value);
1376 }
1377 }
1378 }
1379
1380 return type;
1381 }
1382 /* }}} */
1383
1384 /* {{{ proto bool xmlrpc_set_type(string value, string type)
1385 Sets xmlrpc type, base64 or datetime, for a PHP string value */
PHP_FUNCTION(xmlrpc_set_type)1386 PHP_FUNCTION(xmlrpc_set_type)
1387 {
1388 zval *arg;
1389 char *type;
1390 size_t type_len;
1391 XMLRPC_VALUE_TYPE vtype;
1392
1393 if (zend_parse_parameters(ZEND_NUM_ARGS(), "z/s", &arg, &type, &type_len) == FAILURE) {
1394 return;
1395 }
1396
1397 vtype = xmlrpc_str_as_type(type);
1398 if (vtype != xmlrpc_none) {
1399 if (set_zval_xmlrpc_type(arg, vtype) == SUCCESS) {
1400 RETURN_TRUE;
1401 }
1402 } else {
1403 zend_error(E_WARNING,"invalid type '%s' passed to xmlrpc_set_type()", type);
1404 }
1405 RETURN_FALSE;
1406 }
1407 /* }}} */
1408
1409 /* {{{ proto string xmlrpc_get_type(mixed value)
1410 Gets xmlrpc type for a PHP value. Especially useful for base64 and datetime strings */
PHP_FUNCTION(xmlrpc_get_type)1411 PHP_FUNCTION(xmlrpc_get_type)
1412 {
1413 zval *arg;
1414 XMLRPC_VALUE_TYPE type;
1415 XMLRPC_VECTOR_TYPE vtype = xmlrpc_vector_none;
1416
1417 if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &arg) == FAILURE) {
1418 return;
1419 }
1420
1421 type = get_zval_xmlrpc_type(arg, 0);
1422 if (type == xmlrpc_vector) {
1423 vtype = determine_vector_type((Z_TYPE_P(arg) == IS_OBJECT) ? Z_OBJPROP_P(arg) : Z_ARRVAL_P(arg));
1424 }
1425
1426 RETURN_STRING((char*) xmlrpc_type_as_str(type, vtype));
1427 }
1428 /* }}} */
1429
1430 /* {{{ proto bool xmlrpc_is_fault(array arg)
1431 Determines if an array value represents an XMLRPC fault. */
PHP_FUNCTION(xmlrpc_is_fault)1432 PHP_FUNCTION(xmlrpc_is_fault)
1433 {
1434 zval *arg;
1435
1436 if (zend_parse_parameters(ZEND_NUM_ARGS(), "a", &arg) == FAILURE) {
1437 return;
1438 }
1439
1440 /* The "correct" way to do this would be to call the xmlrpc
1441 * library XMLRPC_ValueIsFault() func. However, doing that
1442 * would require us to create an xmlrpc value from the php
1443 * array, which is rather expensive, especially if it was
1444 * a big array. Thus, we resort to this not so clever hackery.
1445 */
1446 if (zend_hash_str_exists(Z_ARRVAL_P(arg), FAULT_CODE, FAULT_CODE_LEN) &&
1447 zend_hash_str_exists(Z_ARRVAL_P(arg), FAULT_STRING, FAULT_STRING_LEN)) {
1448 RETURN_TRUE;
1449 }
1450
1451 RETURN_FALSE;
1452 }
1453 /* }}} */
1454
1455 /*
1456 * Local variables:
1457 * tab-width: 4
1458 * c-basic-offset: 4
1459 * End:
1460 */
1461
1462
