?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Busybox: Upgrade to 1.21.1 (stable). lsof active.
[tomato.git] / release / src / router / php / ext / wddx / wddx.c
blob967da6a4904287463817c5890e2b713471495c3e
1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 5 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1997-2013 The PHP Group |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 3.01 of the PHP license, |
8 | that is bundled with this package in the file LICENSE, and is |
9 | available through the world-wide-web at the following url: |
10 | http://www.php.net/license/3_01.txt |
11 | If you did not receive a copy of the PHP license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@php.net so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Author: Andrei Zmievski <andrei@php.net> |
16 +----------------------------------------------------------------------+
17 */
18
19 /* $Id$ */
20
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #endif
24
25 #include "php.h"
26
27 #if HAVE_WDDX
28
29 #include "ext/xml/expat_compat.h"
30 #include "php_wddx.h"
31 #include "php_wddx_api.h"
32
33 #define PHP_XML_INTERNAL
34 #include "ext/xml/php_xml.h"
35 #include "ext/standard/php_incomplete_class.h"
36 #include "ext/standard/base64.h"
37 #include "ext/standard/info.h"
38 #include "ext/standard/php_smart_str.h"
39 #include "ext/standard/html.h"
40 #include "ext/standard/php_string.h"
41 #include "ext/date/php_date.h"
42 #include "zend_globals.h"
43
44 #define WDDX_BUF_LEN 256
45 #define PHP_CLASS_NAME_VAR "php_class_name"
46
47 #define EL_ARRAY "array"
48 #define EL_BINARY "binary"
49 #define EL_BOOLEAN "boolean"
50 #define EL_CHAR "char"
51 #define EL_CHAR_CODE "code"
52 #define EL_NULL "null"
53 #define EL_NUMBER "number"
54 #define EL_PACKET "wddxPacket"
55 #define EL_STRING "string"
56 #define EL_STRUCT "struct"
57 #define EL_VALUE "value"
58 #define EL_VAR "var"
59 #define EL_NAME "name"
60 #define EL_VERSION "version"
61 #define EL_RECORDSET "recordset"
62 #define EL_FIELD "field"
63 #define EL_DATETIME "dateTime"
64
65 #define php_wddx_deserialize(a,b) \
66 php_wddx_deserialize_ex((a)->value.str.val, (a)->value.str.len, (b))
67
68 #define SET_STACK_VARNAME \
69 if (stack->varname) { \
70 ent.varname = estrdup(stack->varname); \
71 efree(stack->varname); \
72 stack->varname = NULL; \
73 } else \
74 ent.varname = NULL; \
75
76 static int le_wddx;
77
78 typedef struct {
79 zval *data;
80 enum {
81 ST_ARRAY,
82 ST_BOOLEAN,
83 ST_NULL,
84 ST_NUMBER,
85 ST_STRING,
86 ST_BINARY,
87 ST_STRUCT,
88 ST_RECORDSET,
89 ST_FIELD,
90 ST_DATETIME
91 } type;
92 char *varname;
93 } st_entry;
94
95 typedef struct {
96 int top, max;
97 char *varname;
98 zend_bool done;
99 void **elements;
100 } wddx_stack;
101
102
103 static void php_wddx_process_data(void *user_data, const XML_Char *s, int len);
104
105 /* {{{ arginfo */
106 ZEND_BEGIN_ARG_INFO_EX(arginfo_wddx_serialize_value, 0, 0, 1)
107 ZEND_ARG_INFO(0, var)
108 ZEND_ARG_INFO(0, comment)
109 ZEND_END_ARG_INFO()
110
111 ZEND_BEGIN_ARG_INFO_EX(arginfo_wddx_serialize_vars, 0, 0, 1)
112 ZEND_ARG_INFO(0, var_name)
113 ZEND_ARG_INFO(0, ...)
114 ZEND_END_ARG_INFO()
115
116 ZEND_BEGIN_ARG_INFO_EX(arginfo_wddx_serialize_start, 0, 0, 0)
117 ZEND_ARG_INFO(0, comment)
118 ZEND_END_ARG_INFO()
119
120 ZEND_BEGIN_ARG_INFO_EX(arginfo_wddx_packet_end, 0, 0, 1)
121 ZEND_ARG_INFO(0, packet_id)
122 ZEND_END_ARG_INFO()
123
124 ZEND_BEGIN_ARG_INFO_EX(arginfo_wddx_add_vars, 0, 0, 2)
125 ZEND_ARG_INFO(0, packet_id)
126 ZEND_ARG_INFO(0, var_name)
127 ZEND_ARG_INFO(0, ...)
128 ZEND_END_ARG_INFO()
129
130 ZEND_BEGIN_ARG_INFO_EX(arginfo_wddx_deserialize, 0, 0, 1)
131 ZEND_ARG_INFO(0, packet)
132 ZEND_END_ARG_INFO()
133 /* }}} */
134
135 /* {{{ wddx_functions[]
136 */
137 const zend_function_entry wddx_functions[] = {
138 PHP_FE(wddx_serialize_value, arginfo_wddx_serialize_value)
139 PHP_FE(wddx_serialize_vars, arginfo_wddx_serialize_vars)
140 PHP_FE(wddx_packet_start, arginfo_wddx_serialize_start)
141 PHP_FE(wddx_packet_end, arginfo_wddx_packet_end)
142 PHP_FE(wddx_add_vars, arginfo_wddx_add_vars)
143 PHP_FE(wddx_deserialize, arginfo_wddx_deserialize)
144 PHP_FE_END
145 };
146 /* }}} */
147
148 PHP_MINIT_FUNCTION(wddx);
149 PHP_MINFO_FUNCTION(wddx);
150
151 /* {{{ dynamically loadable module stuff */
152 #ifdef COMPILE_DL_WDDX
153 ZEND_GET_MODULE(wddx)
154 #endif /* COMPILE_DL_WDDX */
155 /* }}} */
156
157 /* {{{ wddx_module_entry
158 */
159 zend_module_entry wddx_module_entry = {
160 STANDARD_MODULE_HEADER,
161 "wddx",
162 wddx_functions,
163 PHP_MINIT(wddx),
164 NULL,
165 NULL,
166 NULL,
167 PHP_MINFO(wddx),
168 NO_VERSION_YET,
169 STANDARD_MODULE_PROPERTIES
170 };
171 /* }}} */
172
173 /* {{{ wddx_stack_init
174 */
175 static int wddx_stack_init(wddx_stack *stack)
176 {
177 stack->top = 0;
178 stack->elements = (void **) safe_emalloc(sizeof(void **), STACK_BLOCK_SIZE, 0);
179 stack->max = STACK_BLOCK_SIZE;
180 stack->varname = NULL;
181 stack->done = 0;
182
183 return SUCCESS;
184 }
185 /* }}} */
186
187 /* {{{ wddx_stack_push
188 */
189 static int wddx_stack_push(wddx_stack *stack, void *element, int size)
190 {
191 if (stack->top >= stack->max) { /* we need to allocate more memory */
192 stack->elements = (void **) erealloc(stack->elements,
193 (sizeof(void **) * (stack->max += STACK_BLOCK_SIZE)));
194 }
195 stack->elements[stack->top] = (void *) emalloc(size);
196 memcpy(stack->elements[stack->top], element, size);
197 return stack->top++;
198 }
199 /* }}} */
200
201 /* {{{ wddx_stack_top
202 */
203 static int wddx_stack_top(wddx_stack *stack, void **element)
204 {
205 if (stack->top > 0) {
206 *element = stack->elements[stack->top - 1];
207 return SUCCESS;
208 } else {
209 *element = NULL;
210 return FAILURE;
211 }
212 }
213 /* }}} */
214
215 /* {{{ wddx_stack_is_empty
216 */
217 static int wddx_stack_is_empty(wddx_stack *stack)
218 {
219 if (stack->top == 0) {
220 return 1;
221 } else {
222 return 0;
223 }
224 }
225 /* }}} */
226
227 /* {{{ wddx_stack_destroy
228 */
229 static int wddx_stack_destroy(wddx_stack *stack)
230 {
231 register int i;
232
233 if (stack->elements) {
234 for (i = 0; i < stack->top; i++) {
235 if (((st_entry *)stack->elements[i])->data) {
236 zval_ptr_dtor(&((st_entry *)stack->elements[i])->data);
237 }
238 if (((st_entry *)stack->elements[i])->varname) {
239 efree(((st_entry *)stack->elements[i])->varname);
240 }
241 efree(stack->elements[i]);
242 }
243 efree(stack->elements);
244 }
245 return SUCCESS;
246 }
247 /* }}} */
248
249 /* {{{ release_wddx_packet_rsrc
250 */
251 static void release_wddx_packet_rsrc(zend_rsrc_list_entry *rsrc TSRMLS_DC)
252 {
253 smart_str *str = (smart_str *)rsrc->ptr;
254 smart_str_free(str);
255 efree(str);
256 }
257 /* }}} */
258
259 #include "ext/session/php_session.h"
260
261 #if HAVE_PHP_SESSION && !defined(COMPILE_DL_SESSION)
262 /* {{{ PS_SERIALIZER_ENCODE_FUNC
263 */
264 PS_SERIALIZER_ENCODE_FUNC(wddx)
265 {
266 wddx_packet *packet;
267 PS_ENCODE_VARS;
268
269 packet = php_wddx_constructor();
270
271 php_wddx_packet_start(packet, NULL, 0);
272 php_wddx_add_chunk_static(packet, WDDX_STRUCT_S);
273
274 PS_ENCODE_LOOP(
275 php_wddx_serialize_var(packet, *struc, key, key_length TSRMLS_CC);
276 );
277
278 php_wddx_add_chunk_static(packet, WDDX_STRUCT_E);
279 php_wddx_packet_end(packet);
280 *newstr = php_wddx_gather(packet);
281 php_wddx_destructor(packet);
282
283 if (newlen) {
284 *newlen = strlen(*newstr);
285 }
286
287 return SUCCESS;
288 }
289 /* }}} */
290
291 /* {{{ PS_SERIALIZER_DECODE_FUNC
292 */
293 PS_SERIALIZER_DECODE_FUNC(wddx)
294 {
295 zval *retval;
296 zval **ent;
297 char *key;
298 uint key_length;
299 char tmp[128];
300 ulong idx;
301 int hash_type;
302 int ret;
303
304 if (vallen == 0) {
305 return SUCCESS;
306 }
307
308 MAKE_STD_ZVAL(retval);
309
310 if ((ret = php_wddx_deserialize_ex((char *)val, vallen, retval)) == SUCCESS) {
311
312 for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(retval));
313 zend_hash_get_current_data(Z_ARRVAL_P(retval), (void **) &ent) == SUCCESS;
314 zend_hash_move_forward(Z_ARRVAL_P(retval))) {
315 hash_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(retval), &key, &key_length, &idx, 0, NULL);
316
317 switch (hash_type) {
318 case HASH_KEY_IS_LONG:
319 key_length = slprintf(tmp, sizeof(tmp), "%ld", idx) + 1;
320 key = tmp;
321 /* fallthru */
322 case HASH_KEY_IS_STRING:
323 php_set_session_var(key, key_length-1, *ent, NULL TSRMLS_CC);
324 PS_ADD_VAR(key);
325 }
326 }
327 }
328
329 zval_ptr_dtor(&retval);
330
331 return ret;
332 }
333 /* }}} */
334 #endif
335
336 /* {{{ PHP_MINIT_FUNCTION
337 */
338 PHP_MINIT_FUNCTION(wddx)
339 {
340 le_wddx = zend_register_list_destructors_ex(release_wddx_packet_rsrc, NULL, "wddx", module_number);
341
342 #if HAVE_PHP_SESSION && !defined(COMPILE_DL_SESSION)
343 php_session_register_serializer("wddx",
344 PS_SERIALIZER_ENCODE_NAME(wddx),
345 PS_SERIALIZER_DECODE_NAME(wddx));
346 #endif
347
348 return SUCCESS;
349 }
350 /* }}} */
351
352 /* {{{ PHP_MINFO_FUNCTION
353 */
354 PHP_MINFO_FUNCTION(wddx)
355 {
356 php_info_print_table_start();
357 #if HAVE_PHP_SESSION && !defined(COMPILE_DL_SESSION)
358 php_info_print_table_header(2, "WDDX Support", "enabled" );
359 php_info_print_table_row(2, "WDDX Session Serializer", "enabled" );
360 #else
361 php_info_print_table_row(2, "WDDX Support", "enabled" );
362 #endif
363 php_info_print_table_end();
364 }
365 /* }}} */
366
367 /* {{{ php_wddx_packet_start
368 */
369 void php_wddx_packet_start(wddx_packet *packet, char *comment, int comment_len)
370 {
371 php_wddx_add_chunk_static(packet, WDDX_PACKET_S);
372 if (comment) {
373 php_wddx_add_chunk_static(packet, WDDX_HEADER_S);
374 php_wddx_add_chunk_static(packet, WDDX_COMMENT_S);
375 php_wddx_add_chunk_ex(packet, comment, comment_len);
376 php_wddx_add_chunk_static(packet, WDDX_COMMENT_E);
377 php_wddx_add_chunk_static(packet, WDDX_HEADER_E);
378 } else {
379 php_wddx_add_chunk_static(packet, WDDX_HEADER);
380 }
381 php_wddx_add_chunk_static(packet, WDDX_DATA_S);
382 }
383 /* }}} */
384
385 /* {{{ php_wddx_packet_end
386 */
387 void php_wddx_packet_end(wddx_packet *packet)
388 {
389 php_wddx_add_chunk_static(packet, WDDX_DATA_E);
390 php_wddx_add_chunk_static(packet, WDDX_PACKET_E);
391 }
392 /* }}} */
393
394 #define FLUSH_BUF() \
395 if (l > 0) { \
396 php_wddx_add_chunk_ex(packet, buf, l); \
397 l = 0; \
398 }
399
400 /* {{{ php_wddx_serialize_string
401 */
402 static void php_wddx_serialize_string(wddx_packet *packet, zval *var TSRMLS_DC)
403 {
404 php_wddx_add_chunk_static(packet, WDDX_STRING_S);
405
406 if (Z_STRLEN_P(var) > 0) {
407 char *buf;
408 int buf_len;
409
410 buf = php_escape_html_entities(Z_STRVAL_P(var), Z_STRLEN_P(var), &buf_len, 0, ENT_QUOTES, NULL TSRMLS_CC);
411
412 php_wddx_add_chunk_ex(packet, buf, buf_len);
413
414 efree(buf);
415 }
416 php_wddx_add_chunk_static(packet, WDDX_STRING_E);
417 }
418 /* }}} */
419
420 /* {{{ php_wddx_serialize_number
421 */
422 static void php_wddx_serialize_number(wddx_packet *packet, zval *var)
423 {
424 char tmp_buf[WDDX_BUF_LEN];
425 zval tmp;
426
427 tmp = *var;
428 zval_copy_ctor(&tmp);
429 convert_to_string(&tmp);
430 snprintf(tmp_buf, sizeof(tmp_buf), WDDX_NUMBER, Z_STRVAL(tmp));
431 zval_dtor(&tmp);
432
433 php_wddx_add_chunk(packet, tmp_buf);
434 }
435 /* }}} */
436
437 /* {{{ php_wddx_serialize_boolean
438 */
439 static void php_wddx_serialize_boolean(wddx_packet *packet, zval *var)
440 {
441 php_wddx_add_chunk(packet, Z_LVAL_P(var) ? WDDX_BOOLEAN_TRUE : WDDX_BOOLEAN_FALSE);
442 }
443 /* }}} */
444
445 /* {{{ php_wddx_serialize_unset
446 */
447 static void php_wddx_serialize_unset(wddx_packet *packet)
448 {
449 php_wddx_add_chunk_static(packet, WDDX_NULL);
450 }
451 /* }}} */
452
453 /* {{{ php_wddx_serialize_object
454 */
455 static void php_wddx_serialize_object(wddx_packet *packet, zval *obj)
456 {
457 /* OBJECTS_FIXME */
458 zval **ent, *fname, **varname;
459 zval *retval = NULL;
460 const char *key;
461 ulong idx;
462 char tmp_buf[WDDX_BUF_LEN];
463 HashTable *objhash, *sleephash;
464 TSRMLS_FETCH();
465
466 MAKE_STD_ZVAL(fname);
467 ZVAL_STRING(fname, "__sleep", 1);
468
469 /*
470 * We try to call __sleep() method on object. It's supposed to return an
471 * array of property names to be serialized.
472 */
473 if (call_user_function_ex(CG(function_table), &obj, fname, &retval, 0, 0, 1, NULL TSRMLS_CC) == SUCCESS) {
474 if (retval && (sleephash = HASH_OF(retval))) {
475 PHP_CLASS_ATTRIBUTES;
476
477 PHP_SET_CLASS_ATTRIBUTES(obj);
478
479 php_wddx_add_chunk_static(packet, WDDX_STRUCT_S);
480 snprintf(tmp_buf, WDDX_BUF_LEN, WDDX_VAR_S, PHP_CLASS_NAME_VAR);
481 php_wddx_add_chunk(packet, tmp_buf);
482 php_wddx_add_chunk_static(packet, WDDX_STRING_S);
483 php_wddx_add_chunk_ex(packet, class_name, name_len);
484 php_wddx_add_chunk_static(packet, WDDX_STRING_E);
485 php_wddx_add_chunk_static(packet, WDDX_VAR_E);
486
487 PHP_CLEANUP_CLASS_ATTRIBUTES();
488
489 objhash = HASH_OF(obj);
490
491 for (zend_hash_internal_pointer_reset(sleephash);
492 zend_hash_get_current_data(sleephash, (void **)&varname) == SUCCESS;
493 zend_hash_move_forward(sleephash)) {
494 if (Z_TYPE_PP(varname) != IS_STRING) {
495 php_error_docref(NULL TSRMLS_CC, E_NOTICE, "__sleep should return an array only containing the names of instance-variables to serialize.");
496 continue;
497 }
498
499 if (zend_hash_find(objhash, Z_STRVAL_PP(varname), Z_STRLEN_PP(varname)+1, (void **)&ent) == SUCCESS) {
500 php_wddx_serialize_var(packet, *ent, Z_STRVAL_PP(varname), Z_STRLEN_PP(varname) TSRMLS_CC);
501 }
502 }
503
504 php_wddx_add_chunk_static(packet, WDDX_STRUCT_E);
505 }
506 } else {
507 uint key_len;
508
509 PHP_CLASS_ATTRIBUTES;
510
511 PHP_SET_CLASS_ATTRIBUTES(obj);
512
513 php_wddx_add_chunk_static(packet, WDDX_STRUCT_S);
514 snprintf(tmp_buf, WDDX_BUF_LEN, WDDX_VAR_S, PHP_CLASS_NAME_VAR);
515 php_wddx_add_chunk(packet, tmp_buf);
516 php_wddx_add_chunk_static(packet, WDDX_STRING_S);
517 php_wddx_add_chunk_ex(packet, class_name, name_len);
518 php_wddx_add_chunk_static(packet, WDDX_STRING_E);
519 php_wddx_add_chunk_static(packet, WDDX_VAR_E);
520
521 PHP_CLEANUP_CLASS_ATTRIBUTES();
522
523 objhash = HASH_OF(obj);
524 for (zend_hash_internal_pointer_reset(objhash);
525 zend_hash_get_current_data(objhash, (void**)&ent) == SUCCESS;
526 zend_hash_move_forward(objhash)) {
527 if (*ent == obj) {
528 continue;
529 }
530
531 if (zend_hash_get_current_key_ex(objhash, &key, &key_len, &idx, 0, NULL) == HASH_KEY_IS_STRING) {
532 const char *class_name, *prop_name;
533
534 zend_unmangle_property_name(key, key_len-1, &class_name, &prop_name);
535 php_wddx_serialize_var(packet, *ent, prop_name, strlen(prop_name)+1 TSRMLS_CC);
536 } else {
537 key_len = slprintf(tmp_buf, sizeof(tmp_buf), "%ld", idx);
538 php_wddx_serialize_var(packet, *ent, tmp_buf, key_len TSRMLS_CC);
539 }
540 }
541 php_wddx_add_chunk_static(packet, WDDX_STRUCT_E);
542 }
543
544 zval_dtor(fname);
545 FREE_ZVAL(fname);
546
547 if (retval) {
548 zval_ptr_dtor(&retval);
549 }
550 }
551 /* }}} */
552
553 /* {{{ php_wddx_serialize_array
554 */
555 static void php_wddx_serialize_array(wddx_packet *packet, zval *arr)
556 {
557 zval **ent;
558 char *key;
559 uint key_len;
560 int is_struct = 0, ent_type;
561 ulong idx;
562 HashTable *target_hash;
563 char tmp_buf[WDDX_BUF_LEN];
564 ulong ind = 0;
565 int type;
566 TSRMLS_FETCH();
567
568 target_hash = HASH_OF(arr);
569
570 for (zend_hash_internal_pointer_reset(target_hash);
571 zend_hash_get_current_data(target_hash, (void**)&ent) == SUCCESS;
572 zend_hash_move_forward(target_hash)) {
573
574 type = zend_hash_get_current_key(target_hash, &key, &idx, 0);
575
576 if (type == HASH_KEY_IS_STRING) {
577 is_struct = 1;
578 break;
579 }
580
581 if (idx != ind) {
582 is_struct = 1;
583 break;
584 }
585
586 ind++;
587 }
588
589 if (is_struct) {
590 php_wddx_add_chunk_static(packet, WDDX_STRUCT_S);
591 } else {
592 snprintf(tmp_buf, sizeof(tmp_buf), WDDX_ARRAY_S, zend_hash_num_elements(target_hash));
593 php_wddx_add_chunk(packet, tmp_buf);
594 }
595
596 for (zend_hash_internal_pointer_reset(target_hash);
597 zend_hash_get_current_data(target_hash, (void**)&ent) == SUCCESS;
598 zend_hash_move_forward(target_hash)) {
599 if (*ent == arr) {
600 continue;
601 }
602
603 if (is_struct) {
604 ent_type = zend_hash_get_current_key_ex(target_hash, &key, &key_len, &idx, 0, NULL);
605
606 if (ent_type == HASH_KEY_IS_STRING) {
607 php_wddx_serialize_var(packet, *ent, key, key_len TSRMLS_CC);
608 } else {
609 key_len = slprintf(tmp_buf, sizeof(tmp_buf), "%ld", idx);
610 php_wddx_serialize_var(packet, *ent, tmp_buf, key_len TSRMLS_CC);
611 }
612 } else {
613 php_wddx_serialize_var(packet, *ent, NULL, 0 TSRMLS_CC);
614 }
615 }
616
617 if (is_struct) {
618 php_wddx_add_chunk_static(packet, WDDX_STRUCT_E);
619 } else {
620 php_wddx_add_chunk_static(packet, WDDX_ARRAY_E);
621 }
622 }
623 /* }}} */
624
625 /* {{{ php_wddx_serialize_var
626 */
627 void php_wddx_serialize_var(wddx_packet *packet, zval *var, char *name, int name_len TSRMLS_DC)
628 {
629 char *tmp_buf;
630 char *name_esc;
631 int name_esc_len;
632 HashTable *ht;
633
634 if (name) {
635 name_esc = php_escape_html_entities(name, name_len, &name_esc_len, 0, ENT_QUOTES, NULL TSRMLS_CC);
636 tmp_buf = emalloc(name_esc_len + sizeof(WDDX_VAR_S));
637 snprintf(tmp_buf, name_esc_len + sizeof(WDDX_VAR_S), WDDX_VAR_S, name_esc);
638 php_wddx_add_chunk(packet, tmp_buf);
639 efree(tmp_buf);
640 efree(name_esc);
641 }
642
643 switch(Z_TYPE_P(var)) {
644 case IS_STRING:
645 php_wddx_serialize_string(packet, var TSRMLS_CC);
646 break;
647
648 case IS_LONG:
649 case IS_DOUBLE:
650 php_wddx_serialize_number(packet, var);
651 break;
652
653 case IS_BOOL:
654 php_wddx_serialize_boolean(packet, var);
655 break;
656
657 case IS_NULL:
658 php_wddx_serialize_unset(packet);
659 break;
660
661 case IS_ARRAY:
662 ht = Z_ARRVAL_P(var);
663 if (ht->nApplyCount > 1) {
664 php_error_docref(NULL TSRMLS_CC, E_RECOVERABLE_ERROR, "WDDX doesn't support circular references");
665 return;
666 }
667 ht->nApplyCount++;
668 php_wddx_serialize_array(packet, var);
669 ht->nApplyCount--;
670 break;
671
672 case IS_OBJECT:
673 ht = Z_OBJPROP_P(var);
674 if (ht->nApplyCount > 1) {
675 php_error_docref(NULL TSRMLS_CC, E_RECOVERABLE_ERROR, "WDDX doesn't support circular references");
676 return;
677 }
678 ht->nApplyCount++;
679 php_wddx_serialize_object(packet, var);
680 ht->nApplyCount--;
681 break;
682 }
683
684 if (name) {
685 php_wddx_add_chunk_static(packet, WDDX_VAR_E);
686 }
687 }
688 /* }}} */
689
690 /* {{{ php_wddx_add_var
691 */
692 static void php_wddx_add_var(wddx_packet *packet, zval *name_var)
693 {
694 zval **val;
695 HashTable *target_hash;
696 TSRMLS_FETCH();
697
698 if (Z_TYPE_P(name_var) == IS_STRING) {
699 if (!EG(active_symbol_table)) {
700 zend_rebuild_symbol_table(TSRMLS_C);
701 }
702 if (zend_hash_find(EG(active_symbol_table), Z_STRVAL_P(name_var),
703 Z_STRLEN_P(name_var)+1, (void**)&val) != FAILURE) {
704 php_wddx_serialize_var(packet, *val, Z_STRVAL_P(name_var), Z_STRLEN_P(name_var) TSRMLS_CC);
705 }
706 } else if (Z_TYPE_P(name_var) == IS_ARRAY || Z_TYPE_P(name_var) == IS_OBJECT) {
707 int is_array = Z_TYPE_P(name_var) == IS_ARRAY;
708
709 target_hash = HASH_OF(name_var);
710
711 if (is_array && target_hash->nApplyCount > 1) {
712 php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected");
713 return;
714 }
715
716 zend_hash_internal_pointer_reset(target_hash);
717
718 while(zend_hash_get_current_data(target_hash, (void**)&val) == SUCCESS) {
719 if (is_array) {
720 target_hash->nApplyCount++;
721 }
722
723 php_wddx_add_var(packet, *val);
724
725 if (is_array) {
726 target_hash->nApplyCount--;
727 }
728 zend_hash_move_forward(target_hash);
729 }
730 }
731 }
732 /* }}} */
733
734 /* {{{ php_wddx_push_element
735 */
736 static void php_wddx_push_element(void *user_data, const XML_Char *name, const XML_Char **atts)
737 {
738 st_entry ent;
739 wddx_stack *stack = (wddx_stack *)user_data;
740
741 if (!strcmp(name, EL_PACKET)) {
742 int i;
743
744 if (atts) for (i=0; atts[i]; i++) {
745 if (!strcmp(atts[i], EL_VERSION)) {
746 /* nothing for now */
747 }
748 }
749 } else if (!strcmp(name, EL_STRING)) {
750 ent.type = ST_STRING;
751 SET_STACK_VARNAME;
752
753 ALLOC_ZVAL(ent.data);
754 INIT_PZVAL(ent.data);
755 Z_TYPE_P(ent.data) = IS_STRING;
756 Z_STRVAL_P(ent.data) = STR_EMPTY_ALLOC();
757 Z_STRLEN_P(ent.data) = 0;
758 wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
759 } else if (!strcmp(name, EL_BINARY)) {
760 ent.type = ST_BINARY;
761 SET_STACK_VARNAME;
762
763 ALLOC_ZVAL(ent.data);
764 INIT_PZVAL(ent.data);
765 Z_TYPE_P(ent.data) = IS_STRING;
766 Z_STRVAL_P(ent.data) = STR_EMPTY_ALLOC();
767 Z_STRLEN_P(ent.data) = 0;
768 wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
769 } else if (!strcmp(name, EL_CHAR)) {
770 int i;
771
772 if (atts) for (i = 0; atts[i]; i++) {
773 if (!strcmp(atts[i], EL_CHAR_CODE) && atts[++i] && atts[i][0]) {
774 char tmp_buf[2];
775
776 snprintf(tmp_buf, sizeof(tmp_buf), "%c", (char)strtol(atts[i], NULL, 16));
777 php_wddx_process_data(user_data, tmp_buf, strlen(tmp_buf));
778 break;
779 }
780 }
781 } else if (!strcmp(name, EL_NUMBER)) {
782 ent.type = ST_NUMBER;
783 SET_STACK_VARNAME;
784
785 ALLOC_ZVAL(ent.data);
786 INIT_PZVAL(ent.data);
787 Z_TYPE_P(ent.data) = IS_LONG;
788 Z_LVAL_P(ent.data) = 0;
789 wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
790 } else if (!strcmp(name, EL_BOOLEAN)) {
791 int i;
792
793 if (atts) for (i = 0; atts[i]; i++) {
794 if (!strcmp(atts[i], EL_VALUE) && atts[++i] && atts[i][0]) {
795 ent.type = ST_BOOLEAN;
796 SET_STACK_VARNAME;
797
798 ALLOC_ZVAL(ent.data);
799 INIT_PZVAL(ent.data);
800 Z_TYPE_P(ent.data) = IS_BOOL;
801 wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
802 php_wddx_process_data(user_data, atts[i], strlen(atts[i]));
803 break;
804 }
805 }
806 } else if (!strcmp(name, EL_NULL)) {
807 ent.type = ST_NULL;
808 SET_STACK_VARNAME;
809
810 ALLOC_ZVAL(ent.data);
811 INIT_PZVAL(ent.data);
812 ZVAL_NULL(ent.data);
813
814 wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
815 } else if (!strcmp(name, EL_ARRAY)) {
816 ent.type = ST_ARRAY;
817 SET_STACK_VARNAME;
818
819 ALLOC_ZVAL(ent.data);
820 array_init(ent.data);
821 INIT_PZVAL(ent.data);
822 wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
823 } else if (!strcmp(name, EL_STRUCT)) {
824 ent.type = ST_STRUCT;
825 SET_STACK_VARNAME;
826
827 ALLOC_ZVAL(ent.data);
828 array_init(ent.data);
829 INIT_PZVAL(ent.data);
830 wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
831 } else if (!strcmp(name, EL_VAR)) {
832 int i;
833
834 if (atts) for (i = 0; atts[i]; i++) {
835 if (!strcmp(atts[i], EL_NAME) && atts[++i] && atts[i][0]) {
836 stack->varname = estrdup(atts[i]);
837 break;
838 }
839 }
840 } else if (!strcmp(name, EL_RECORDSET)) {
841 int i;
842
843 ent.type = ST_RECORDSET;
844 SET_STACK_VARNAME;
845 MAKE_STD_ZVAL(ent.data);
846 array_init(ent.data);
847
848 if (atts) for (i = 0; atts[i]; i++) {
849 if (!strcmp(atts[i], "fieldNames") && atts[++i] && atts[i][0]) {
850 zval *tmp;
851 char *key;
852 char *p1, *p2, *endp;
853
854 endp = (char *)atts[i] + strlen(atts[i]);
855 p1 = (char *)atts[i];
856 while ((p2 = php_memnstr(p1, ",", sizeof(",")-1, endp)) != NULL) {
857 key = estrndup(p1, p2 - p1);
858 MAKE_STD_ZVAL(tmp);
859 array_init(tmp);
860 add_assoc_zval_ex(ent.data, key, p2 - p1 + 1, tmp);
861 p1 = p2 + sizeof(",")-1;
862 efree(key);
863 }
864
865 if (p1 <= endp) {
866 MAKE_STD_ZVAL(tmp);
867 array_init(tmp);
868 add_assoc_zval_ex(ent.data, p1, endp - p1 + 1, tmp);
869 }
870
871 break;
872 }
873 }
874
875 wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
876 } else if (!strcmp(name, EL_FIELD)) {
877 int i;
878 st_entry ent;
879
880 ent.type = ST_FIELD;
881 ent.varname = NULL;
882 ent.data = NULL;
883
884 if (atts) for (i = 0; atts[i]; i++) {
885 if (!strcmp(atts[i], EL_NAME) && atts[++i] && atts[i][0]) {
886 st_entry *recordset;
887 zval **field;
888
889 if (wddx_stack_top(stack, (void**)&recordset) == SUCCESS &&
890 recordset->type == ST_RECORDSET &&
891 zend_hash_find(Z_ARRVAL_P(recordset->data), (char*)atts[i], strlen(atts[i])+1, (void**)&field) == SUCCESS) {
892 ent.data = *field;
893 }
894
895 break;
896 }
897 }
898
899 wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
900 } else if (!strcmp(name, EL_DATETIME)) {
901 ent.type = ST_DATETIME;
902 SET_STACK_VARNAME;
903
904 ALLOC_ZVAL(ent.data);
905 INIT_PZVAL(ent.data);
906 Z_TYPE_P(ent.data) = IS_LONG;
907 wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
908 }
909 }
910 /* }}} */
911
912 /* {{{ php_wddx_pop_element
913 */
914 static void php_wddx_pop_element(void *user_data, const XML_Char *name)
915 {
916 st_entry *ent1, *ent2;
917 wddx_stack *stack = (wddx_stack *)user_data;
918 HashTable *target_hash;
919 zend_class_entry **pce;
920 zval *obj;
921 zval *tmp;
922 TSRMLS_FETCH();
923
924 /* OBJECTS_FIXME */
925 if (stack->top == 0) {
926 return;
927 }
928
929 if (!strcmp(name, EL_STRING) || !strcmp(name, EL_NUMBER) ||
930 !strcmp(name, EL_BOOLEAN) || !strcmp(name, EL_NULL) ||
931 !strcmp(name, EL_ARRAY) || !strcmp(name, EL_STRUCT) ||
932 !strcmp(name, EL_RECORDSET) || !strcmp(name, EL_BINARY) ||
933 !strcmp(name, EL_DATETIME)) {
934 wddx_stack_top(stack, (void**)&ent1);
935
936 if (!strcmp(name, EL_BINARY)) {
937 int new_len=0;
938 unsigned char *new_str;
939
940 new_str = php_base64_decode(Z_STRVAL_P(ent1->data), Z_STRLEN_P(ent1->data), &new_len);
941 STR_FREE(Z_STRVAL_P(ent1->data));
942 Z_STRVAL_P(ent1->data) = new_str;
943 Z_STRLEN_P(ent1->data) = new_len;
944 }
945
946 /* Call __wakeup() method on the object. */
947 if (Z_TYPE_P(ent1->data) == IS_OBJECT) {
948 zval *fname, *retval = NULL;
949
950 MAKE_STD_ZVAL(fname);
951 ZVAL_STRING(fname, "__wakeup", 1);
952
953 call_user_function_ex(NULL, &ent1->data, fname, &retval, 0, 0, 0, NULL TSRMLS_CC);
954
955 zval_dtor(fname);
956 FREE_ZVAL(fname);
957 if (retval) {
958 zval_ptr_dtor(&retval);
959 }
960 }
961
962 if (stack->top > 1) {
963 stack->top--;
964 wddx_stack_top(stack, (void**)&ent2);
965
966 /* if non-existent field */
967 if (ent2->type == ST_FIELD && ent2->data == NULL) {
968 zval_ptr_dtor(&ent1->data);
969 efree(ent1);
970 return;
971 }
972
973 if (Z_TYPE_P(ent2->data) == IS_ARRAY || Z_TYPE_P(ent2->data) == IS_OBJECT) {
974 target_hash = HASH_OF(ent2->data);
975
976 if (ent1->varname) {
977 if (!strcmp(ent1->varname, PHP_CLASS_NAME_VAR) &&
978 Z_TYPE_P(ent1->data) == IS_STRING && Z_STRLEN_P(ent1->data)) {
979 zend_bool incomplete_class = 0;
980
981 zend_str_tolower(Z_STRVAL_P(ent1->data), Z_STRLEN_P(ent1->data));
982 if (zend_hash_find(EG(class_table), Z_STRVAL_P(ent1->data),
983 Z_STRLEN_P(ent1->data)+1, (void **) &pce)==FAILURE) {
984 incomplete_class = 1;
985 pce = &PHP_IC_ENTRY;
986 }
987
988 /* Initialize target object */
989 MAKE_STD_ZVAL(obj);
990 object_init_ex(obj, *pce);
991
992 /* Merge current hashtable with object's default properties */
993 zend_hash_merge(Z_OBJPROP_P(obj),
994 Z_ARRVAL_P(ent2->data),
995 (void (*)(void *)) zval_add_ref,
996 (void *) &tmp, sizeof(zval *), 0);
997
998 if (incomplete_class) {
999 php_store_class_name(obj, Z_STRVAL_P(ent1->data), Z_STRLEN_P(ent1->data));
1000 }
1001
1002 /* Clean up old array entry */
1003 zval_ptr_dtor(&ent2->data);
1004
1005 /* Set stack entry to point to the newly created object */
1006 ent2->data = obj;
1007
1008 /* Clean up class name var entry */
1009 zval_ptr_dtor(&ent1->data);
1010 } else if (Z_TYPE_P(ent2->data) == IS_OBJECT) {
1011 zend_class_entry *old_scope = EG(scope);
1012
1013 EG(scope) = Z_OBJCE_P(ent2->data);
1014 Z_DELREF_P(ent1->data);
1015 add_property_zval(ent2->data, ent1->varname, ent1->data);
1016 EG(scope) = old_scope;
1017 } else {
1018 zend_symtable_update(target_hash, ent1->varname, strlen(ent1->varname)+1, &ent1->data, sizeof(zval *), NULL);
1019 }
1020 efree(ent1->varname);
1021 } else {
1022 zend_hash_next_index_insert(target_hash, &ent1->data, sizeof(zval *), NULL);
1023 }
1024 }
1025 efree(ent1);
1026 } else {
1027 stack->done = 1;
1028 }
1029 } else if (!strcmp(name, EL_VAR) && stack->varname) {
1030 efree(stack->varname);
1031 } else if (!strcmp(name, EL_FIELD)) {
1032 st_entry *ent;
1033 wddx_stack_top(stack, (void **)&ent);
1034 efree(ent);
1035 stack->top--;
1036 }
1037 }
1038 /* }}} */
1039
1040 /* {{{ php_wddx_process_data
1041 */
1042 static void php_wddx_process_data(void *user_data, const XML_Char *s, int len)
1043 {
1044 st_entry *ent;
1045 wddx_stack *stack = (wddx_stack *)user_data;
1046 TSRMLS_FETCH();
1047
1048 if (!wddx_stack_is_empty(stack) && !stack->done) {
1049 wddx_stack_top(stack, (void**)&ent);
1050 switch (Z_TYPE_P(ent)) {
1051 case ST_STRING:
1052 if (Z_STRLEN_P(ent->data) == 0) {
1053 STR_FREE(Z_STRVAL_P(ent->data));
1054 Z_STRVAL_P(ent->data) = estrndup(s, len);
1055 Z_STRLEN_P(ent->data) = len;
1056 } else {
1057 Z_STRVAL_P(ent->data) = erealloc(Z_STRVAL_P(ent->data), Z_STRLEN_P(ent->data) + len + 1);
1058 memcpy(Z_STRVAL_P(ent->data) + Z_STRLEN_P(ent->data), s, len);
1059 Z_STRLEN_P(ent->data) += len;
1060 Z_STRVAL_P(ent->data)[Z_STRLEN_P(ent->data)] = '\0';
1061 }
1062 break;
1063
1064 case ST_BINARY:
1065 if (Z_STRLEN_P(ent->data) == 0) {
1066 STR_FREE(Z_STRVAL_P(ent->data));
1067 Z_STRVAL_P(ent->data) = estrndup(s, len + 1);
1068 } else {
1069 Z_STRVAL_P(ent->data) = erealloc(Z_STRVAL_P(ent->data), Z_STRLEN_P(ent->data) + len + 1);
1070 memcpy(Z_STRVAL_P(ent->data) + Z_STRLEN_P(ent->data), s, len);
1071 }
1072 Z_STRLEN_P(ent->data) += len;
1073 Z_STRVAL_P(ent->data)[Z_STRLEN_P(ent->data)] = '\0';
1074 break;
1075
1076 case ST_NUMBER:
1077 Z_TYPE_P(ent->data) = IS_STRING;
1078 Z_STRLEN_P(ent->data) = len;
1079 Z_STRVAL_P(ent->data) = estrndup(s, len);
1080 convert_scalar_to_number(ent->data TSRMLS_CC);
1081 break;
1082
1083 case ST_BOOLEAN:
1084 if (!strcmp(s, "true")) {
1085 Z_LVAL_P(ent->data) = 1;
1086 } else if (!strcmp(s, "false")) {
1087 Z_LVAL_P(ent->data) = 0;
1088 } else {
1089 stack->top--;
1090 zval_ptr_dtor(&ent->data);
1091 if (ent->varname)
1092 efree(ent->varname);
1093 efree(ent);
1094 }
1095 break;
1096
1097 case ST_DATETIME: {
1098 char *tmp;
1099
1100 tmp = emalloc(len + 1);
1101 memcpy(tmp, s, len);
1102 tmp[len] = '\0';
1103
1104 Z_LVAL_P(ent->data) = php_parse_date(tmp, NULL);
1105 /* date out of range < 1969 or > 2038 */
1106 if (Z_LVAL_P(ent->data) == -1) {
1107 Z_TYPE_P(ent->data) = IS_STRING;
1108 Z_STRLEN_P(ent->data) = len;
1109 Z_STRVAL_P(ent->data) = estrndup(s, len);
1110 }
1111 efree(tmp);
1112 }
1113 break;
1114
1115 default:
1116 break;
1117 }
1118 }
1119 }
1120 /* }}} */
1121
1122 /* {{{ php_wddx_deserialize_ex
1123 */
1124 int php_wddx_deserialize_ex(char *value, int vallen, zval *return_value)
1125 {
1126 wddx_stack stack;
1127 XML_Parser parser;
1128 st_entry *ent;
1129 int retval;
1130
1131 wddx_stack_init(&stack);
1132 parser = XML_ParserCreate("UTF-8");
1133
1134 XML_SetUserData(parser, &stack);
1135 XML_SetElementHandler(parser, php_wddx_push_element, php_wddx_pop_element);
1136 XML_SetCharacterDataHandler(parser, php_wddx_process_data);
1137
1138 XML_Parse(parser, value, vallen, 1);
1139
1140 XML_ParserFree(parser);
1141
1142 if (stack.top == 1) {
1143 wddx_stack_top(&stack, (void**)&ent);
1144 *return_value = *(ent->data);
1145 zval_copy_ctor(return_value);
1146 retval = SUCCESS;
1147 } else {
1148 retval = FAILURE;
1149 }
1150
1151 wddx_stack_destroy(&stack);
1152
1153 return retval;
1154 }
1155 /* }}} */
1156
1157 /* {{{ proto string wddx_serialize_value(mixed var [, string comment])
1158 Creates a new packet and serializes the given value */
1159 PHP_FUNCTION(wddx_serialize_value)
1160 {
1161 zval *var;
1162 char *comment = NULL;
1163 int comment_len = 0;
1164 wddx_packet *packet;
1165
1166 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|s", &var, &comment, &comment_len) == FAILURE) {
1167 return;
1168 }
1169
1170 packet = php_wddx_constructor();
1171
1172 php_wddx_packet_start(packet, comment, comment_len);
1173 php_wddx_serialize_var(packet, var, NULL, 0 TSRMLS_CC);
1174 php_wddx_packet_end(packet);
1175
1176 ZVAL_STRINGL(return_value, packet->c, packet->len, 1);
1177 smart_str_free(packet);
1178 efree(packet);
1179 }
1180 /* }}} */
1181
1182 /* {{{ proto string wddx_serialize_vars(mixed var_name [, mixed ...])
1183 Creates a new packet and serializes given variables into a struct */
1184 PHP_FUNCTION(wddx_serialize_vars)
1185 {
1186 int num_args, i;
1187 wddx_packet *packet;
1188 zval ***args = NULL;
1189
1190 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &num_args) == FAILURE) {
1191 return;
1192 }
1193
1194 packet = php_wddx_constructor();
1195
1196 php_wddx_packet_start(packet, NULL, 0);
1197 php_wddx_add_chunk_static(packet, WDDX_STRUCT_S);
1198
1199 for (i=0; i<num_args; i++) {
1200 if (Z_TYPE_PP(args[i]) != IS_ARRAY && Z_TYPE_PP(args[i]) != IS_OBJECT) {
1201 convert_to_string_ex(args[i]);
1202 }
1203 php_wddx_add_var(packet, *args[i]);
1204 }
1205
1206 php_wddx_add_chunk_static(packet, WDDX_STRUCT_E);
1207 php_wddx_packet_end(packet);
1208
1209 efree(args);
1210
1211 ZVAL_STRINGL(return_value, packet->c, packet->len, 1);
1212 smart_str_free(packet);
1213 efree(packet);
1214 }
1215 /* }}} */
1216
1217 /* {{{ php_wddx_constructor
1218 */
1219 wddx_packet *php_wddx_constructor(void)
1220 {
1221 smart_str *packet;
1222
1223 packet = (smart_str *)emalloc(sizeof(smart_str));
1224 packet->c = NULL;
1225
1226 return packet;
1227 }
1228 /* }}} */
1229
1230 /* {{{ php_wddx_destructor
1231 */
1232 void php_wddx_destructor(wddx_packet *packet)
1233 {
1234 smart_str_free(packet);
1235 efree(packet);
1236 }
1237 /* }}} */
1238
1239 /* {{{ proto resource wddx_packet_start([string comment])
1240 Starts a WDDX packet with optional comment and returns the packet id */
1241 PHP_FUNCTION(wddx_packet_start)
1242 {
1243 char *comment = NULL;
1244 int comment_len = 0;
1245 wddx_packet *packet;
1246
1247 comment = NULL;
1248
1249 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &comment, &comment_len) == FAILURE) {
1250 return;
1251 }
1252
1253 packet = php_wddx_constructor();
1254
1255 php_wddx_packet_start(packet, comment, comment_len);
1256 php_wddx_add_chunk_static(packet, WDDX_STRUCT_S);
1257
1258 ZEND_REGISTER_RESOURCE(return_value, packet, le_wddx);
1259 }
1260 /* }}} */
1261
1262 /* {{{ proto string wddx_packet_end(resource packet_id)
1263 Ends specified WDDX packet and returns the string containing the packet */
1264 PHP_FUNCTION(wddx_packet_end)
1265 {
1266 zval *packet_id;
1267 wddx_packet *packet = NULL;
1268
1269 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &packet_id) == FAILURE) {
1270 return;
1271 }
1272
1273 ZEND_FETCH_RESOURCE(packet, wddx_packet *, &packet_id, -1, "WDDX packet ID", le_wddx);
1274
1275 php_wddx_add_chunk_static(packet, WDDX_STRUCT_E);
1276
1277 php_wddx_packet_end(packet);
1278
1279 ZVAL_STRINGL(return_value, packet->c, packet->len, 1);
1280
1281 zend_list_delete(Z_LVAL_P(packet_id));
1282 }
1283 /* }}} */
1284
1285 /* {{{ proto int wddx_add_vars(resource packet_id, mixed var_names [, mixed ...])
1286 Serializes given variables and adds them to packet given by packet_id */
1287 PHP_FUNCTION(wddx_add_vars)
1288 {
1289 int num_args, i;
1290 zval ***args = NULL;
1291 zval *packet_id;
1292 wddx_packet *packet = NULL;
1293
1294 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r+", &packet_id, &args, &num_args) == FAILURE) {
1295 return;
1296 }
1297
1298 if (!ZEND_FETCH_RESOURCE_NO_RETURN(packet, wddx_packet *, &packet_id, -1, "WDDX packet ID", le_wddx)) {
1299 efree(args);
1300 RETURN_FALSE;
1301 }
1302
1303 if (!packet) {
1304 efree(args);
1305 RETURN_FALSE;
1306 }
1307
1308 for (i=0; i<num_args; i++) {
1309 if (Z_TYPE_PP(args[i]) != IS_ARRAY && Z_TYPE_PP(args[i]) != IS_OBJECT) {
1310 convert_to_string_ex(args[i]);
1311 }
1312 php_wddx_add_var(packet, (*args[i]));
1313 }
1314
1315 efree(args);
1316 RETURN_TRUE;
1317 }
1318 /* }}} */
1319
1320 /* {{{ proto mixed wddx_deserialize(mixed packet)
1321 Deserializes given packet and returns a PHP value */
1322 PHP_FUNCTION(wddx_deserialize)
1323 {
1324 zval *packet;
1325 char *payload;
1326 int payload_len;
1327 php_stream *stream = NULL;
1328
1329 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &packet) == FAILURE) {
1330 return;
1331 }
1332
1333 if (Z_TYPE_P(packet) == IS_STRING) {
1334 payload = Z_STRVAL_P(packet);
1335 payload_len = Z_STRLEN_P(packet);
1336 } else if (Z_TYPE_P(packet) == IS_RESOURCE) {
1337 php_stream_from_zval(stream, &packet);
1338 if (stream) {
1339 payload_len = php_stream_copy_to_mem(stream, &payload, PHP_STREAM_COPY_ALL, 0);
1340 }
1341 } else {
1342 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Expecting parameter 1 to be a string or a stream");
1343 return;
1344 }
1345
1346 if (payload_len == 0) {
1347 return;
1348 }
1349
1350 php_wddx_deserialize_ex(payload, payload_len, return_value);
1351
1352 if (stream) {
1353 pefree(payload, 0);
1354 }
1355 }
1356 /* }}} */
1357
1358 #endif /* HAVE_LIBEXPAT */
1359
1360 /*
1361 * Local variables:
1362 * tab-width: 4
1363 * c-basic-offset: 4
1364 * End:
1365 * vim600: sw=4 ts=4 fdm=marker
1366 * vim<600: sw=4 ts=4
1367 */
Tomato firmware and modifications.