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