1 /*
2 +----------------------------------------------------------------------+
3 | Copyright (c) The PHP Group |
4 +----------------------------------------------------------------------+
5 | This source file is subject to version 3.01 of the PHP license, |
6 | that is bundled with this package in the file LICENSE, and is |
7 | available through the world-wide-web at the following url: |
8 | http://www.php.net/license/3_01.txt |
9 | If you did not receive a copy of the PHP license and are unable to |
10 | obtain it through the world-wide-web, please send a note to |
11 | license@php.net so we can mail you a copy immediately. |
12 +----------------------------------------------------------------------+
13 | Authors: Brad Lafountain <rodif_bl@yahoo.com> |
14 | Shane Caraveo <shane@caraveo.com> |
15 | Dmitry Stogov <dmitry@php.net> |
16 +----------------------------------------------------------------------+
17 */
18
19 #include <time.h>
20
21 #include "php_soap.h"
22 #include "ext/libxml/php_libxml.h"
23 #include "ext/standard/base64.h"
24 #include <libxml/parserInternals.h>
25 #include "zend_strtod.h"
26 #include "zend_interfaces.h"
27
28 /* zval type decode */
29 static zval *to_zval_double(zval* ret, encodeTypePtr type, xmlNodePtr data);
30 static zval *to_zval_long(zval* ret, encodeTypePtr type, xmlNodePtr data);
31 static zval *to_zval_bool(zval* ret, encodeTypePtr type, xmlNodePtr data);
32 static zval *to_zval_string(zval* ret, encodeTypePtr type, xmlNodePtr data);
33 static zval *to_zval_stringr(zval* ret, encodeTypePtr type, xmlNodePtr data);
34 static zval *to_zval_stringc(zval* ret, encodeTypePtr type, xmlNodePtr data);
35 static zval *to_zval_map(zval* ret, encodeTypePtr type, xmlNodePtr data);
36 static zval *to_zval_null(zval* ret, encodeTypePtr type, xmlNodePtr data);
37 static zval *to_zval_base64(zval* ret, encodeTypePtr type, xmlNodePtr data);
38 static zval *to_zval_hexbin(zval* ret, encodeTypePtr type, xmlNodePtr data);
39
40 static xmlNodePtr to_xml_long(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
41 static xmlNodePtr to_xml_double(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
42 static xmlNodePtr to_xml_bool(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
43
44 /* String encode */
45 static xmlNodePtr to_xml_string(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
46 static xmlNodePtr to_xml_base64(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
47 static xmlNodePtr to_xml_hexbin(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
48
49 /* Null encode */
50 static xmlNodePtr to_xml_null(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
51
52 /* Array encode */
53 static xmlNodePtr guess_array_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
54 static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
55
56 static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent);
57 static xmlNodePtr to_xml_list1(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent);
58
59 /* Datetime encode/decode */
60 static xmlNodePtr to_xml_datetime_ex(encodeTypePtr type, zval *data, char *format, int style, xmlNodePtr parent);
61 static xmlNodePtr to_xml_datetime(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
62 static xmlNodePtr to_xml_time(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
63 static xmlNodePtr to_xml_date(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
64 static xmlNodePtr to_xml_gyearmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
65 static xmlNodePtr to_xml_gyear(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
66 static xmlNodePtr to_xml_gmonthday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
67 static xmlNodePtr to_xml_gday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
68 static xmlNodePtr to_xml_gmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
69 static xmlNodePtr to_xml_duration(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
70
71 static zval *to_zval_object(zval *ret, encodeTypePtr type, xmlNodePtr data);
72 static zval *to_zval_array(zval *ret, encodeTypePtr type, xmlNodePtr data);
73
74 static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
75 static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
76
77 static zval *to_zval_any(zval *ret, encodeTypePtr type, xmlNodePtr data);
78 static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
79
80 /* Try and guess for non-wsdl clients and servers */
81 static zval *guess_zval_convert(zval *ret, encodeTypePtr type, xmlNodePtr data);
82 static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
83
84 static int is_map(zval *array);
85 static encodePtr get_array_type(xmlNodePtr node, zval *array, smart_str *out_type);
86
87 static xmlNodePtr check_and_resolve_href(xmlNodePtr data);
88
89 static void set_ns_prop(xmlNodePtr node, char *ns, char *name, char *val);
90 static void set_xsi_nil(xmlNodePtr node);
91 static void set_xsi_type(xmlNodePtr node, char *type);
92
93 static void get_type_str(xmlNodePtr node, const char* ns, const char* type, smart_str* ret);
94 static void set_ns_and_type_ex(xmlNodePtr node, char *ns, char *type);
95
96 static void set_ns_and_type(xmlNodePtr node, encodeTypePtr type);
97
98 #define FIND_XML_NULL(xml,zval) \
99 { \
100 xmlAttrPtr null; \
101 if (!xml) { \
102 ZVAL_NULL(zval); \
103 return zval; \
104 } \
105 if (xml->properties) { \
106 null = get_attribute(xml->properties, "nil"); \
107 if (null) { \
108 ZVAL_NULL(zval); \
109 return zval; \
110 } \
111 } \
112 }
113
114 #define CHECK_XML_NULL(xml) \
115 { \
116 xmlAttrPtr null; \
117 if (!xml) { \
118 ZVAL_NULL(ret); \
119 return ret; \
120 } \
121 if (xml->properties) { \
122 null = get_attribute(xml->properties, "nil"); \
123 if (null) { \
124 ZVAL_NULL(ret); \
125 return ret; \
126 } \
127 } \
128 }
129
130 #define FIND_ZVAL_NULL(zval, xml, style) \
131 { \
132 if (!zval || Z_TYPE_P(zval) == IS_NULL) { \
133 if (style == SOAP_ENCODED) {\
134 set_xsi_nil(xml); \
135 } \
136 return xml; \
137 } \
138 }
139
140 const encode defaultEncoding[] = {
141 {{UNKNOWN_TYPE, NULL, NULL, NULL, NULL}, guess_zval_convert, guess_xml_convert},
142
143 {{IS_NULL, "nil", XSI_NAMESPACE, NULL, NULL}, to_zval_null, to_xml_null},
144 {{IS_STRING, XSD_STRING_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_string, to_xml_string},
145 {{IS_LONG, XSD_INT_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
146 {{IS_DOUBLE, XSD_FLOAT_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_double, to_xml_double},
147 {{IS_FALSE, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_bool, to_xml_bool},
148 {{IS_TRUE, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_bool, to_xml_bool},
149 {{IS_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_1_ENC_NAMESPACE, NULL, NULL}, to_zval_array, guess_array_map},
150 {{IS_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_1_ENC_NAMESPACE, NULL, NULL}, to_zval_object, to_xml_object},
151 {{IS_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_2_ENC_NAMESPACE, NULL, NULL}, to_zval_array, guess_array_map},
152 {{IS_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_2_ENC_NAMESPACE, NULL, NULL}, to_zval_object, to_xml_object},
153
154 {{XSD_STRING, XSD_STRING_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_string, to_xml_string},
155 {{XSD_BOOLEAN, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_bool, to_xml_bool},
156 {{XSD_DECIMAL, XSD_DECIMAL_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
157 {{XSD_FLOAT, XSD_FLOAT_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_double, to_xml_double},
158 {{XSD_DOUBLE, XSD_DOUBLE_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_double, to_xml_double},
159
160 {{XSD_DATETIME, XSD_DATETIME_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_datetime},
161 {{XSD_TIME, XSD_TIME_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_time},
162 {{XSD_DATE, XSD_DATE_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_date},
163 {{XSD_GYEARMONTH, XSD_GYEARMONTH_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_gyearmonth},
164 {{XSD_GYEAR, XSD_GYEAR_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_gyear},
165 {{XSD_GMONTHDAY, XSD_GMONTHDAY_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_gmonthday},
166 {{XSD_GDAY, XSD_GDAY_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_gday},
167 {{XSD_GMONTH, XSD_GMONTH_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_gmonth},
168 {{XSD_DURATION, XSD_DURATION_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_duration},
169
170 {{XSD_HEXBINARY, XSD_HEXBINARY_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_hexbin, to_xml_hexbin},
171 {{XSD_BASE64BINARY, XSD_BASE64BINARY_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_base64, to_xml_base64},
172
173 {{XSD_LONG, XSD_LONG_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
174 {{XSD_INT, XSD_INT_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
175 {{XSD_SHORT, XSD_SHORT_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
176 {{XSD_BYTE, XSD_BYTE_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
177 {{XSD_NONPOSITIVEINTEGER, XSD_NONPOSITIVEINTEGER_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
178 {{XSD_POSITIVEINTEGER, XSD_POSITIVEINTEGER_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
179 {{XSD_NONNEGATIVEINTEGER, XSD_NONNEGATIVEINTEGER_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
180 {{XSD_NEGATIVEINTEGER, XSD_NEGATIVEINTEGER_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
181 {{XSD_UNSIGNEDBYTE, XSD_UNSIGNEDBYTE_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
182 {{XSD_UNSIGNEDSHORT, XSD_UNSIGNEDSHORT_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
183 {{XSD_UNSIGNEDINT, XSD_UNSIGNEDINT_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
184 {{XSD_UNSIGNEDLONG, XSD_UNSIGNEDLONG_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
185 {{XSD_INTEGER, XSD_INTEGER_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
186
187 {{XSD_ANYTYPE, XSD_ANYTYPE_STRING, XSD_NAMESPACE, NULL, NULL}, guess_zval_convert, guess_xml_convert},
188 {{XSD_UR_TYPE, XSD_UR_TYPE_STRING, XSD_NAMESPACE, NULL, NULL}, guess_zval_convert, guess_xml_convert},
189 {{XSD_ANYURI, XSD_ANYURI_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
190 {{XSD_QNAME, XSD_QNAME_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
191 {{XSD_NOTATION, XSD_NOTATION_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
192 {{XSD_NORMALIZEDSTRING, XSD_NORMALIZEDSTRING_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringr, to_xml_string},
193 {{XSD_TOKEN, XSD_TOKEN_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
194 {{XSD_LANGUAGE, XSD_LANGUAGE_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
195 {{XSD_NMTOKEN, XSD_NMTOKEN_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
196 {{XSD_NMTOKENS, XSD_NMTOKENS_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_list1},
197 {{XSD_NAME, XSD_NAME_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
198 {{XSD_NCNAME, XSD_NCNAME_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
199 {{XSD_ID, XSD_ID_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
200 {{XSD_IDREF, XSD_IDREF_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
201 {{XSD_IDREFS, XSD_IDREFS_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_list1},
202 {{XSD_ENTITY, XSD_ENTITY_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
203 {{XSD_ENTITIES, XSD_ENTITIES_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_list1},
204
205 {{APACHE_MAP, APACHE_MAP_STRING, APACHE_NAMESPACE, NULL, NULL}, to_zval_map, to_xml_map},
206
207 {{SOAP_ENC_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_1_ENC_NAMESPACE, NULL, NULL}, to_zval_object, to_xml_object},
208 {{SOAP_ENC_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_1_ENC_NAMESPACE, NULL, NULL}, to_zval_array, to_xml_array},
209 {{SOAP_ENC_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_2_ENC_NAMESPACE, NULL, NULL}, to_zval_object, to_xml_object},
210 {{SOAP_ENC_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_2_ENC_NAMESPACE, NULL, NULL}, to_zval_array, to_xml_array},
211
212 /* support some of the 1999 data types */
213 {{XSD_STRING, XSD_STRING_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_string, to_xml_string},
214 {{XSD_BOOLEAN, XSD_BOOLEAN_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_bool, to_xml_bool},
215 {{XSD_DECIMAL, XSD_DECIMAL_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
216 {{XSD_FLOAT, XSD_FLOAT_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_double, to_xml_double},
217 {{XSD_DOUBLE, XSD_DOUBLE_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_double, to_xml_double},
218
219 {{XSD_LONG, XSD_LONG_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
220 {{XSD_INT, XSD_INT_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
221 {{XSD_SHORT, XSD_SHORT_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
222 {{XSD_BYTE, XSD_BYTE_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
223 {{XSD_1999_TIMEINSTANT, XSD_1999_TIMEINSTANT_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
224
225 {{XSD_ANYXML, "<anyXML>", "<anyXML>", NULL, NULL}, to_zval_any, to_xml_any},
226
227 {{END_KNOWN_TYPES, NULL, NULL, NULL, NULL}, guess_zval_convert, guess_xml_convert}
228 };
229
230 int numDefaultEncodings = sizeof(defaultEncoding)/sizeof(encode);
231
232
whiteSpace_replace(xmlChar * str)233 void whiteSpace_replace(xmlChar* str)
234 {
235 while (*str != '\0') {
236 if (*str == '\x9' || *str == '\xA' || *str == '\xD') {
237 *str = ' ';
238 }
239 str++;
240 }
241 }
242
whiteSpace_collapse(xmlChar * str)243 void whiteSpace_collapse(xmlChar* str)
244 {
245 xmlChar *pos;
246 xmlChar old;
247
248 pos = str;
249 whiteSpace_replace(str);
250 while (*str == ' ') {
251 str++;
252 }
253 old = '\0';
254 while (*str != '\0') {
255 if (*str != ' ' || old != ' ') {
256 *pos = *str;
257 pos++;
258 }
259 old = *str;
260 str++;
261 }
262 if (old == ' ') {
263 --pos;
264 }
265 *pos = '\0';
266 }
267
find_encoder_by_type_name(sdlPtr sdl,const char * type)268 static encodePtr find_encoder_by_type_name(sdlPtr sdl, const char *type)
269 {
270 if (sdl && sdl->encoders) {
271 encodePtr enc;
272
273 ZEND_HASH_FOREACH_PTR(sdl->encoders, enc) {
274 if (strcmp(enc->details.type_str, type) == 0) {
275 return enc;
276 }
277 } ZEND_HASH_FOREACH_END();
278 }
279 return NULL;
280 }
281
soap_check_zval_ref(zval * data,xmlNodePtr node)282 static zend_bool soap_check_zval_ref(zval *data, xmlNodePtr node) {
283 xmlNodePtr node_ptr;
284
285 if (SOAP_GLOBAL(ref_map)) {
286 if (Z_TYPE_P(data) == IS_OBJECT) {
287 data = (zval*)Z_OBJ_P(data);
288 }
289 if ((node_ptr = zend_hash_index_find_ptr(SOAP_GLOBAL(ref_map), (zend_ulong)data)) != NULL) {
290 xmlAttrPtr attr = node_ptr->properties;
291 char *id;
292 smart_str prefix = {0};
293
294 if (node_ptr == node) {
295 return 0;
296 }
297 if (SOAP_GLOBAL(soap_version) == SOAP_1_1) {
298 while (1) {
299 attr = get_attribute(attr, "id");
300 if (attr == NULL || attr->ns == NULL) {
301 break;
302 }
303 attr = attr->next;
304 }
305 if (attr) {
306 id = (char*)attr->children->content;
307 smart_str_appendc(&prefix, '#');
308 smart_str_appends(&prefix, id);
309 smart_str_0(&prefix);
310 id = ZSTR_VAL(prefix.s);
311 } else {
312 SOAP_GLOBAL(cur_uniq_ref)++;
313 smart_str_appendl(&prefix, "#ref", 4);
314 smart_str_append_long(&prefix, SOAP_GLOBAL(cur_uniq_ref));
315 smart_str_0(&prefix);
316 id = ZSTR_VAL(prefix.s);
317 xmlSetProp(node_ptr, BAD_CAST("id"), BAD_CAST(id+1));
318 }
319 xmlSetProp(node, BAD_CAST("href"), BAD_CAST(id));
320 } else {
321 attr = get_attribute_ex(attr, "id", SOAP_1_2_ENC_NAMESPACE);
322 if (attr) {
323 id = (char*)attr->children->content;
324 smart_str_appendc(&prefix, '#');
325 smart_str_appends(&prefix, id);
326 smart_str_0(&prefix);
327 id = ZSTR_VAL(prefix.s);
328 } else {
329 SOAP_GLOBAL(cur_uniq_ref)++;
330 smart_str_appendl(&prefix, "#ref", 4);
331 smart_str_append_long(&prefix, SOAP_GLOBAL(cur_uniq_ref));
332 smart_str_0(&prefix);
333 id = ZSTR_VAL(prefix.s);
334 set_ns_prop(node_ptr, SOAP_1_2_ENC_NAMESPACE, "id", id+1);
335 }
336 set_ns_prop(node, SOAP_1_2_ENC_NAMESPACE, "ref", id);
337 }
338 smart_str_free(&prefix);
339 return 1;
340 } else {
341 zend_hash_index_update_ptr(SOAP_GLOBAL(ref_map), (zend_ulong)data, node);
342 }
343 }
344 return 0;
345 }
346
soap_check_xml_ref(zval * data,xmlNodePtr node)347 static zend_bool soap_check_xml_ref(zval *data, xmlNodePtr node)
348 {
349 zval *data_ptr;
350
351 if (SOAP_GLOBAL(ref_map)) {
352 if ((data_ptr = zend_hash_index_find(SOAP_GLOBAL(ref_map), (zend_ulong)node)) != NULL) {
353 if (!Z_REFCOUNTED_P(data) ||
354 !Z_REFCOUNTED_P(data_ptr) ||
355 Z_COUNTED_P(data) != Z_COUNTED_P(data_ptr)) {
356 zval_ptr_dtor(data);
357 ZVAL_COPY(data, data_ptr);
358 return 1;
359 }
360 }
361 }
362 return 0;
363 }
364
soap_add_xml_ref(zval * data,xmlNodePtr node)365 static void soap_add_xml_ref(zval *data, xmlNodePtr node)
366 {
367 if (SOAP_GLOBAL(ref_map)) {
368 zend_hash_index_update(SOAP_GLOBAL(ref_map), (zend_ulong)node, data);
369 }
370 }
371
master_to_xml_int(encodePtr encode,zval * data,int style,xmlNodePtr parent,int check_class_map)372 static xmlNodePtr master_to_xml_int(encodePtr encode, zval *data, int style, xmlNodePtr parent, int check_class_map)
373 {
374 xmlNodePtr node = NULL;
375 int add_type = 0;
376
377 if (data) {
378 ZVAL_DEREF(data);
379 }
380
381 /* Special handling of class SoapVar */
382 if (data &&
383 Z_TYPE_P(data) == IS_OBJECT &&
384 Z_OBJCE_P(data) == soap_var_class_entry) {
385 zval *ztype, *zdata, *zns, *zstype, *zname, *znamens;
386 encodePtr enc = NULL;
387 HashTable *ht = Z_OBJPROP_P(data);
388
389 if ((ztype = zend_hash_str_find_deref(ht, "enc_type", sizeof("enc_type")-1)) == NULL ||
390 Z_TYPE_P(ztype) != IS_LONG) {
391 soap_error0(E_ERROR, "Encoding: SoapVar has no 'enc_type' property");
392 }
393
394 if ((zstype = zend_hash_str_find_deref(ht, "enc_stype", sizeof("enc_stype")-1)) != NULL &&
395 Z_TYPE_P(zstype) == IS_STRING) {
396 if ((zns = zend_hash_str_find_deref(ht, "enc_ns", sizeof("enc_ns")-1)) != NULL &&
397 Z_TYPE_P(zns) == IS_STRING) {
398 enc = get_encoder(SOAP_GLOBAL(sdl), Z_STRVAL_P(zns), Z_STRVAL_P(zstype));
399 } else {
400 zns = NULL;
401 enc = get_encoder_ex(SOAP_GLOBAL(sdl), Z_STRVAL_P(zstype), Z_STRLEN_P(zstype));
402 }
403 if (enc == NULL && SOAP_GLOBAL(typemap)) {
404 smart_str nscat = {0};
405
406 if (zns != NULL) {
407 smart_str_appendl(&nscat, Z_STRVAL_P(zns), Z_STRLEN_P(zns));
408 smart_str_appendc(&nscat, ':');
409 }
410 smart_str_appendl(&nscat, Z_STRVAL_P(zstype), Z_STRLEN_P(zstype));
411 smart_str_0(&nscat);
412 enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s);
413 smart_str_free(&nscat);
414 }
415 }
416 if (enc == NULL) {
417 enc = get_conversion(Z_LVAL_P(ztype));
418 }
419 if (enc == NULL) {
420 enc = encode;
421 }
422
423 zdata = zend_hash_str_find_deref(ht, "enc_value", sizeof("enc_value")-1);
424 node = master_to_xml(enc, zdata, style, parent);
425
426 if (style == SOAP_ENCODED || (SOAP_GLOBAL(sdl) && encode != enc)) {
427 if ((zstype = zend_hash_str_find_deref(ht, "enc_stype", sizeof("enc_stype")-1)) != NULL &&
428 Z_TYPE_P(zstype) == IS_STRING) {
429 if ((zns = zend_hash_str_find_deref(ht, "enc_ns", sizeof("enc_ns")-1)) != NULL &&
430 Z_TYPE_P(zns) == IS_STRING) {
431 set_ns_and_type_ex(node, Z_STRVAL_P(zns), Z_STRVAL_P(zstype));
432 } else {
433 set_ns_and_type_ex(node, NULL, Z_STRVAL_P(zstype));
434 }
435 }
436 }
437
438 if ((zname = zend_hash_str_find_deref(ht, "enc_name", sizeof("enc_name")-1)) != NULL &&
439 Z_TYPE_P(zname) == IS_STRING) {
440 xmlNodeSetName(node, BAD_CAST(Z_STRVAL_P(zname)));
441 }
442 if ((znamens = zend_hash_str_find_deref(ht, "enc_namens", sizeof("enc_namens")-1)) != NULL &&
443 Z_TYPE_P(znamens) == IS_STRING) {
444 xmlNsPtr nsp = encode_add_ns(node, Z_STRVAL_P(znamens));
445 xmlSetNs(node, nsp);
446 }
447 } else {
448 if (check_class_map && SOAP_GLOBAL(class_map) && data &&
449 Z_TYPE_P(data) == IS_OBJECT &&
450 !GC_IS_RECURSIVE(Z_OBJPROP_P(data))) {
451 zend_class_entry *ce = Z_OBJCE_P(data);
452 zval *tmp;
453 zend_string *type_name;
454
455 ZEND_HASH_FOREACH_STR_KEY_VAL(SOAP_GLOBAL(class_map), type_name, tmp) {
456 ZVAL_DEREF(tmp);
457 if (Z_TYPE_P(tmp) == IS_STRING &&
458 ZSTR_LEN(ce->name) == Z_STRLEN_P(tmp) &&
459 zend_binary_strncasecmp(ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), Z_STRVAL_P(tmp), ZSTR_LEN(ce->name), ZSTR_LEN(ce->name)) == 0 &&
460 type_name) {
461
462 /* TODO: namespace isn't stored */
463 encodePtr enc = NULL;
464 if (SOAP_GLOBAL(sdl)) {
465 enc = get_encoder(SOAP_GLOBAL(sdl), SOAP_GLOBAL(sdl)->target_ns, ZSTR_VAL(type_name));
466 if (!enc) {
467 enc = find_encoder_by_type_name(SOAP_GLOBAL(sdl), ZSTR_VAL(type_name));
468 }
469 }
470 if (enc) {
471 if (encode != enc && style == SOAP_LITERAL) {
472 add_type = 1;
473 }
474 encode = enc;
475 }
476 break;
477 }
478 } ZEND_HASH_FOREACH_END();
479 }
480
481 if (encode == NULL) {
482 encode = get_conversion(UNKNOWN_TYPE);
483 }
484 if (SOAP_GLOBAL(typemap) && encode->details.type_str) {
485 smart_str nscat = {0};
486 encodePtr new_enc;
487
488 if (encode->details.ns) {
489 smart_str_appends(&nscat, encode->details.ns);
490 smart_str_appendc(&nscat, ':');
491 }
492 smart_str_appends(&nscat, encode->details.type_str);
493 smart_str_0(&nscat);
494 if ((new_enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s)) != NULL) {
495 encode = new_enc;
496 }
497 smart_str_free(&nscat);
498 }
499 if (encode->to_xml) {
500 node = encode->to_xml(&encode->details, data, style, parent);
501 if (add_type) {
502 set_ns_and_type(node, &encode->details);
503 }
504 }
505 }
506 return node;
507 }
508
master_to_xml(encodePtr encode,zval * data,int style,xmlNodePtr parent)509 xmlNodePtr master_to_xml(encodePtr encode, zval *data, int style, xmlNodePtr parent)
510 {
511 return master_to_xml_int(encode, data, style, parent, 1);
512 }
513
master_to_zval_int(zval * ret,encodePtr encode,xmlNodePtr data)514 static zval *master_to_zval_int(zval *ret, encodePtr encode, xmlNodePtr data)
515 {
516 if (SOAP_GLOBAL(typemap)) {
517 if (encode->details.type_str) {
518 smart_str nscat = {0};
519 encodePtr new_enc;
520
521 if (encode->details.ns) {
522 smart_str_appends(&nscat, encode->details.ns);
523 smart_str_appendc(&nscat, ':');
524 }
525 smart_str_appends(&nscat, encode->details.type_str);
526 smart_str_0(&nscat);
527 if ((new_enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s)) != NULL) {
528 encode = new_enc;
529 }
530 smart_str_free(&nscat);
531 } else {
532 xmlAttrPtr type_attr = get_attribute_ex(data->properties,"type", XSI_NAMESPACE);
533
534 if (type_attr != NULL) {
535 encodePtr new_enc;
536 xmlNsPtr nsptr;
537 char *ns, *cptype;
538 smart_str nscat = {0};
539
540 parse_namespace(type_attr->children->content, &cptype, &ns);
541 nsptr = xmlSearchNs(data->doc, data, BAD_CAST(ns));
542 if (nsptr != NULL) {
543 smart_str_appends(&nscat, (char*)nsptr->href);
544 smart_str_appendc(&nscat, ':');
545 }
546 smart_str_appends(&nscat, cptype);
547 smart_str_0(&nscat);
548 efree(cptype);
549 if (ns) {efree(ns);}
550 if ((new_enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s)) != NULL) {
551 encode = new_enc;
552 }
553 smart_str_free(&nscat);
554 }
555 }
556 }
557 if (encode->to_zval) {
558 ret = encode->to_zval(ret, &encode->details, data);
559 }
560 return ret;
561 }
562
master_to_zval(zval * ret,encodePtr encode,xmlNodePtr data)563 zval *master_to_zval(zval *ret, encodePtr encode, xmlNodePtr data)
564 {
565 data = check_and_resolve_href(data);
566
567 if (encode == NULL) {
568 encode = get_conversion(UNKNOWN_TYPE);
569 } else {
570 /* Use xsi:type if it is defined */
571 xmlAttrPtr type_attr = get_attribute_ex(data->properties,"type", XSI_NAMESPACE);
572
573 if (type_attr != NULL) {
574 encodePtr enc = get_encoder_from_prefix(SOAP_GLOBAL(sdl), data, type_attr->children->content);
575
576 if (enc != NULL && enc != encode) {
577 encodePtr tmp = enc;
578 while (tmp &&
579 tmp->details.sdl_type != NULL &&
580 tmp->details.sdl_type->kind != XSD_TYPEKIND_COMPLEX) {
581 if (enc == tmp->details.sdl_type->encode ||
582 tmp == tmp->details.sdl_type->encode) {
583 enc = NULL;
584 break;
585 }
586 tmp = tmp->details.sdl_type->encode;
587 }
588 if (enc != NULL) {
589 encode = enc;
590 }
591 }
592 }
593 }
594 return master_to_zval_int(ret, encode, data);
595 }
596
to_xml_user(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)597 xmlNodePtr to_xml_user(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
598 {
599 xmlNodePtr ret = NULL;
600 zval return_value;
601
602 if (type && type->map && Z_TYPE(type->map->to_xml) != IS_UNDEF) {
603 ZVAL_NULL(&return_value);
604
605 if (call_user_function(NULL, NULL, &type->map->to_xml, &return_value, 1, data) == FAILURE) {
606 soap_error0(E_ERROR, "Encoding: Error calling to_xml callback");
607 }
608 if (Z_TYPE(return_value) == IS_STRING) {
609 xmlDocPtr doc = soap_xmlParseMemory(Z_STRVAL(return_value), Z_STRLEN(return_value));
610 if (doc && doc->children) {
611 ret = xmlDocCopyNode(doc->children, parent->doc, 1);
612 }
613 xmlFreeDoc(doc);
614 }
615
616 zval_ptr_dtor(&return_value);
617 }
618 if (!ret) {
619 ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
620 }
621 xmlAddChild(parent, ret);
622 if (style == SOAP_ENCODED) {
623 set_ns_and_type(ret, type);
624 }
625 return ret;
626 }
627
to_zval_user(zval * ret,encodeTypePtr type,xmlNodePtr node)628 zval *to_zval_user(zval *ret, encodeTypePtr type, xmlNodePtr node)
629 {
630 if (type && type->map && Z_TYPE(type->map->to_zval) != IS_UNDEF) {
631 xmlBufferPtr buf;
632 zval data;
633 xmlNodePtr copy;
634
635 copy = xmlCopyNode(node, 1);
636 buf = xmlBufferCreate();
637 xmlNodeDump(buf, NULL, copy, 0, 0);
638 ZVAL_STRING(&data, (char*)xmlBufferContent(buf));
639 xmlBufferFree(buf);
640 xmlFreeNode(copy);
641
642 if (call_user_function(NULL, NULL, &type->map->to_zval, ret, 1, &data) == FAILURE) {
643 soap_error0(E_ERROR, "Encoding: Error calling from_xml callback");
644 } else if (EG(exception)) {
645 ZVAL_NULL(ret);
646 }
647 zval_ptr_dtor(&data);
648 } else {
649 ZVAL_NULL(ret);
650 }
651 return ret;
652 }
653
654 /* TODO: get rid of "bogus".. ither by passing in the already created xmlnode or passing in the node name */
655 /* String encode/decode */
to_zval_string(zval * ret,encodeTypePtr type,xmlNodePtr data)656 static zval *to_zval_string(zval *ret, encodeTypePtr type, xmlNodePtr data)
657 {
658 ZVAL_NULL(ret);
659 FIND_XML_NULL(data, ret);
660 if (data && data->children) {
661 if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
662 if (SOAP_GLOBAL(encoding) != NULL) {
663 xmlBufferPtr in = xmlBufferCreateStatic(data->children->content, xmlStrlen(data->children->content));
664 xmlBufferPtr out = xmlBufferCreate();
665 int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);
666
667 if (n >= 0) {
668 ZVAL_STRING(ret, (char*)xmlBufferContent(out));
669 } else {
670 ZVAL_STRING(ret, (char*)data->children->content);
671 }
672 xmlBufferFree(out);
673 xmlBufferFree(in);
674 } else {
675 ZVAL_STRING(ret, (char*)data->children->content);
676 }
677 } else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
678 ZVAL_STRING(ret, (char*)data->children->content);
679 } else {
680 soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
681 }
682 } else {
683 ZVAL_EMPTY_STRING(ret);
684 }
685 return ret;
686 }
687
to_zval_stringr(zval * ret,encodeTypePtr type,xmlNodePtr data)688 static zval *to_zval_stringr(zval *ret, encodeTypePtr type, xmlNodePtr data)
689 {
690 ZVAL_NULL(ret);
691 FIND_XML_NULL(data, ret);
692 if (data && data->children) {
693 if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
694 whiteSpace_replace(data->children->content);
695 if (SOAP_GLOBAL(encoding) != NULL) {
696 xmlBufferPtr in = xmlBufferCreateStatic(data->children->content, xmlStrlen(data->children->content));
697 xmlBufferPtr out = xmlBufferCreate();
698 int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);
699
700 if (n >= 0) {
701 ZVAL_STRING(ret, (char*)xmlBufferContent(out));
702 } else {
703 ZVAL_STRING(ret, (char*)data->children->content);
704 }
705 xmlBufferFree(out);
706 xmlBufferFree(in);
707 } else {
708 ZVAL_STRING(ret, (char*)data->children->content);
709 }
710 } else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
711 ZVAL_STRING(ret, (char*)data->children->content);
712 } else {
713 soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
714 }
715 } else {
716 ZVAL_EMPTY_STRING(ret);
717 }
718 return ret;
719 }
720
to_zval_stringc(zval * ret,encodeTypePtr type,xmlNodePtr data)721 static zval *to_zval_stringc(zval *ret, encodeTypePtr type, xmlNodePtr data)
722 {
723 ZVAL_NULL(ret);
724 FIND_XML_NULL(data, ret);
725 if (data && data->children) {
726 if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
727 whiteSpace_collapse(data->children->content);
728 if (SOAP_GLOBAL(encoding) != NULL) {
729 xmlBufferPtr in = xmlBufferCreateStatic(data->children->content, xmlStrlen(data->children->content));
730 xmlBufferPtr out = xmlBufferCreate();
731 int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);
732
733 if (n >= 0) {
734 ZVAL_STRING(ret, (char*)xmlBufferContent(out));
735 } else {
736 ZVAL_STRING(ret, (char*)data->children->content);
737 }
738 xmlBufferFree(out);
739 xmlBufferFree(in);
740 } else {
741 ZVAL_STRING(ret, (char*)data->children->content);
742 }
743 } else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
744 ZVAL_STRING(ret, (char*)data->children->content);
745 } else {
746 soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
747 }
748 } else {
749 ZVAL_EMPTY_STRING(ret);
750 }
751 return ret;
752 }
753
to_zval_base64(zval * ret,encodeTypePtr type,xmlNodePtr data)754 static zval *to_zval_base64(zval *ret, encodeTypePtr type, xmlNodePtr data)
755 {
756 zend_string *str;
757
758 ZVAL_NULL(ret);
759 FIND_XML_NULL(data, ret);
760 if (data && data->children) {
761 if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
762 whiteSpace_collapse(data->children->content);
763 str = php_base64_decode(data->children->content, strlen((char*)data->children->content));
764 if (!str) {
765 soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
766 }
767 ZVAL_STR(ret, str);
768 } else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
769 str = php_base64_decode(data->children->content, strlen((char*)data->children->content));
770 if (!str) {
771 soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
772 }
773 ZVAL_STR(ret, str);
774 } else {
775 soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
776 }
777 } else {
778 ZVAL_EMPTY_STRING(ret);
779 }
780 return ret;
781 }
782
to_zval_hexbin(zval * ret,encodeTypePtr type,xmlNodePtr data)783 static zval *to_zval_hexbin(zval *ret, encodeTypePtr type, xmlNodePtr data)
784 {
785 zend_string *str;
786 size_t i, j;
787 unsigned char c;
788
789 ZVAL_NULL(ret);
790 FIND_XML_NULL(data, ret);
791 if (data && data->children) {
792 if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
793 whiteSpace_collapse(data->children->content);
794 } else if (data->children->type != XML_CDATA_SECTION_NODE || data->children->next != NULL) {
795 soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
796 return ret;
797 }
798 str = zend_string_alloc(strlen((char*)data->children->content) / 2, 0);
799 for (i = j = 0; i < ZSTR_LEN(str); i++) {
800 c = data->children->content[j++];
801 if (c >= '0' && c <= '9') {
802 ZSTR_VAL(str)[i] = (c - '0') << 4;
803 } else if (c >= 'a' && c <= 'f') {
804 ZSTR_VAL(str)[i] = (c - 'a' + 10) << 4;
805 } else if (c >= 'A' && c <= 'F') {
806 ZSTR_VAL(str)[i] = (c - 'A' + 10) << 4;
807 } else {
808 soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
809 }
810 c = data->children->content[j++];
811 if (c >= '0' && c <= '9') {
812 ZSTR_VAL(str)[i] |= c - '0';
813 } else if (c >= 'a' && c <= 'f') {
814 ZSTR_VAL(str)[i] |= c - 'a' + 10;
815 } else if (c >= 'A' && c <= 'F') {
816 ZSTR_VAL(str)[i] |= c - 'A' + 10;
817 } else {
818 soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
819 }
820 }
821 ZSTR_VAL(str)[ZSTR_LEN(str)] = '\0';
822 ZVAL_NEW_STR(ret, str);
823 } else {
824 ZVAL_EMPTY_STRING(ret);
825 }
826 return ret;
827 }
828
to_xml_string(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)829 static xmlNodePtr to_xml_string(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
830 {
831 xmlNodePtr ret, text;
832 char *str;
833 int new_len;
834
835 ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
836 xmlAddChild(parent, ret);
837 FIND_ZVAL_NULL(data, ret, style);
838
839 if (Z_TYPE_P(data) == IS_STRING) {
840 str = estrndup(Z_STRVAL_P(data), Z_STRLEN_P(data));
841 new_len = Z_STRLEN_P(data);
842 } else {
843 zend_string *tmp = zval_get_string_func(data);
844 str = estrndup(ZSTR_VAL(tmp), ZSTR_LEN(tmp));
845 new_len = ZSTR_LEN(tmp);
846 zend_string_release_ex(tmp, 0);
847 }
848
849 if (SOAP_GLOBAL(encoding) != NULL) {
850 xmlBufferPtr in = xmlBufferCreateStatic(str, new_len);
851 xmlBufferPtr out = xmlBufferCreate();
852 int n = xmlCharEncInFunc(SOAP_GLOBAL(encoding), out, in);
853
854 if (n >= 0) {
855 efree(str);
856 str = estrdup((char*)xmlBufferContent(out));
857 new_len = n;
858 }
859 xmlBufferFree(out);
860 xmlBufferFree(in);
861 }
862
863 if (!php_libxml_xmlCheckUTF8(BAD_CAST(str))) {
864 char *err = emalloc(new_len + 8);
865 char c;
866 int i;
867
868 memcpy(err, str, new_len+1);
869 for (i = 0; (c = err[i++]);) {
870 if ((c & 0x80) == 0) {
871 } else if ((c & 0xe0) == 0xc0) {
872 if ((err[i] & 0xc0) != 0x80) {
873 break;
874 }
875 i++;
876 } else if ((c & 0xf0) == 0xe0) {
877 if ((err[i] & 0xc0) != 0x80 || (err[i+1] & 0xc0) != 0x80) {
878 break;
879 }
880 i += 2;
881 } else if ((c & 0xf8) == 0xf0) {
882 if ((err[i] & 0xc0) != 0x80 || (err[i+1] & 0xc0) != 0x80 || (err[i+2] & 0xc0) != 0x80) {
883 break;
884 }
885 i += 3;
886 } else {
887 break;
888 }
889 }
890 if (c) {
891 err[i-1] = '\\';
892 err[i++] = 'x';
893 err[i++] = ((unsigned char)c >> 4) + ((((unsigned char)c >> 4) > 9) ? ('a' - 10) : '0');
894 err[i++] = (c & 15) + (((c & 15) > 9) ? ('a' - 10) : '0');
895 err[i++] = '.';
896 err[i++] = '.';
897 err[i++] = '.';
898 err[i++] = 0;
899 }
900
901 soap_error1(E_ERROR, "Encoding: string '%s' is not a valid utf-8 string", err);
902 }
903
904 text = xmlNewTextLen(BAD_CAST(str), new_len);
905 xmlAddChild(ret, text);
906 efree(str);
907
908 if (style == SOAP_ENCODED) {
909 set_ns_and_type(ret, type);
910 }
911 return ret;
912 }
913
to_xml_base64(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)914 static xmlNodePtr to_xml_base64(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
915 {
916 xmlNodePtr ret, text;
917 zend_string *str;
918
919 ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
920 xmlAddChild(parent, ret);
921 FIND_ZVAL_NULL(data, ret, style);
922
923 if (Z_TYPE_P(data) == IS_STRING) {
924 str = php_base64_encode((unsigned char*)Z_STRVAL_P(data), Z_STRLEN_P(data));
925 } else {
926 zend_string *tmp = zval_get_string_func(data);
927 str = php_base64_encode((unsigned char*) ZSTR_VAL(tmp), ZSTR_LEN(tmp));
928 zend_string_release_ex(tmp, 0);
929 }
930
931 text = xmlNewTextLen(BAD_CAST(ZSTR_VAL(str)), ZSTR_LEN(str));
932 xmlAddChild(ret, text);
933 zend_string_release_ex(str, 0);
934
935 if (style == SOAP_ENCODED) {
936 set_ns_and_type(ret, type);
937 }
938 return ret;
939 }
940
to_xml_hexbin(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)941 static xmlNodePtr to_xml_hexbin(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
942 {
943 static const char hexconvtab[] = "0123456789ABCDEF";
944 xmlNodePtr ret, text;
945 unsigned char *str;
946 zval tmp;
947 size_t i, j;
948
949 ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
950 xmlAddChild(parent, ret);
951 FIND_ZVAL_NULL(data, ret, style);
952
953 if (Z_TYPE_P(data) != IS_STRING) {
954 ZVAL_STR(&tmp, zval_get_string_func(data));
955 data = &tmp;
956 }
957 str = (unsigned char *) safe_emalloc(Z_STRLEN_P(data) * 2, sizeof(char), 1);
958
959 for (i = j = 0; i < Z_STRLEN_P(data); i++) {
960 str[j++] = hexconvtab[((unsigned char)Z_STRVAL_P(data)[i]) >> 4];
961 str[j++] = hexconvtab[((unsigned char)Z_STRVAL_P(data)[i]) & 15];
962 }
963 str[j] = '\0';
964
965 text = xmlNewTextLen(str, Z_STRLEN_P(data) * 2 * sizeof(char));
966 xmlAddChild(ret, text);
967 efree(str);
968 if (data == &tmp) {
969 zval_ptr_dtor_str(&tmp);
970 }
971
972 if (style == SOAP_ENCODED) {
973 set_ns_and_type(ret, type);
974 }
975 return ret;
976 }
977
to_zval_double(zval * ret,encodeTypePtr type,xmlNodePtr data)978 static zval *to_zval_double(zval *ret, encodeTypePtr type, xmlNodePtr data)
979 {
980 ZVAL_NULL(ret);
981 FIND_XML_NULL(data, ret);
982
983 if (data && data->children) {
984 if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
985 zend_long lval;
986 double dval;
987
988 whiteSpace_collapse(data->children->content);
989 switch (is_numeric_string((char*)data->children->content, strlen((char*)data->children->content), &lval, &dval, 0)) {
990 case IS_LONG:
991 ZVAL_DOUBLE(ret, lval);
992 break;
993 case IS_DOUBLE:
994 ZVAL_DOUBLE(ret, dval);
995 break;
996 default:
997 if (strncasecmp((char*)data->children->content, "NaN", sizeof("NaN")-1) == 0) {
998 ZVAL_DOUBLE(ret, php_get_nan());
999 } else if (strncasecmp((char*)data->children->content, "INF", sizeof("INF")-1) == 0) {
1000 ZVAL_DOUBLE(ret, php_get_inf());
1001 } else if (strncasecmp((char*)data->children->content, "-INF", sizeof("-INF")-1) == 0) {
1002 ZVAL_DOUBLE(ret, -php_get_inf());
1003 } else {
1004 soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
1005 }
1006 }
1007 } else {
1008 soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
1009 }
1010 } else {
1011 ZVAL_NULL(ret);
1012 }
1013 return ret;
1014 }
1015
to_zval_long(zval * ret,encodeTypePtr type,xmlNodePtr data)1016 static zval *to_zval_long(zval *ret, encodeTypePtr type, xmlNodePtr data)
1017 {
1018 ZVAL_NULL(ret);
1019 FIND_XML_NULL(data, ret);
1020
1021 if (data && data->children) {
1022 if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
1023 zend_long lval;
1024 double dval;
1025
1026 whiteSpace_collapse(data->children->content);
1027 errno = 0;
1028
1029 switch (is_numeric_string((char*)data->children->content, strlen((char*)data->children->content), &lval, &dval, 0)) {
1030 case IS_LONG:
1031 ZVAL_LONG(ret, lval);
1032 break;
1033 case IS_DOUBLE:
1034 ZVAL_DOUBLE(ret, dval);
1035 break;
1036 default:
1037 soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
1038 }
1039 } else {
1040 soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
1041 }
1042 } else {
1043 ZVAL_NULL(ret);
1044 }
1045 return ret;
1046 }
1047
to_xml_long(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)1048 static xmlNodePtr to_xml_long(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
1049 {
1050 xmlNodePtr ret;
1051
1052 ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1053 xmlAddChild(parent, ret);
1054 FIND_ZVAL_NULL(data, ret, style);
1055
1056 if (Z_TYPE_P(data) == IS_DOUBLE) {
1057 char s[256];
1058
1059 snprintf(s, sizeof(s), "%0.0F",floor(Z_DVAL_P(data)));
1060 xmlNodeSetContent(ret, BAD_CAST(s));
1061 } else {
1062 zend_string *str = zend_long_to_str(zval_get_long(data));
1063 xmlNodeSetContentLen(ret, BAD_CAST(ZSTR_VAL(str)), ZSTR_LEN(str));
1064 zend_string_release_ex(str, 0);
1065 }
1066
1067 if (style == SOAP_ENCODED) {
1068 set_ns_and_type(ret, type);
1069 }
1070 return ret;
1071 }
1072
to_xml_double(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)1073 static xmlNodePtr to_xml_double(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
1074 {
1075 xmlNodePtr ret;
1076 zval tmp;
1077 char *str;
1078
1079 ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1080 xmlAddChild(parent, ret);
1081 FIND_ZVAL_NULL(data, ret, style);
1082
1083 ZVAL_DOUBLE(&tmp, zval_get_double(data));
1084
1085 str = (char *) safe_emalloc(EG(precision) >= 0 ? EG(precision) : 17, 1, MAX_LENGTH_OF_DOUBLE + 1);
1086 php_gcvt(Z_DVAL(tmp), EG(precision), '.', 'E', str);
1087 xmlNodeSetContentLen(ret, BAD_CAST(str), strlen(str));
1088 efree(str);
1089
1090 if (style == SOAP_ENCODED) {
1091 set_ns_and_type(ret, type);
1092 }
1093 return ret;
1094 }
1095
to_zval_bool(zval * ret,encodeTypePtr type,xmlNodePtr data)1096 static zval *to_zval_bool(zval *ret, encodeTypePtr type, xmlNodePtr data)
1097 {
1098 ZVAL_NULL(ret);
1099 FIND_XML_NULL(data, ret);
1100
1101 if (data && data->children) {
1102 if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
1103 whiteSpace_collapse(data->children->content);
1104 if (stricmp((char*)data->children->content, "true") == 0 ||
1105 stricmp((char*)data->children->content, "t") == 0 ||
1106 strcmp((char*)data->children->content, "1") == 0) {
1107 ZVAL_TRUE(ret);
1108 } else if (stricmp((char*)data->children->content, "false") == 0 ||
1109 stricmp((char*)data->children->content, "f") == 0 ||
1110 strcmp((char*)data->children->content, "0") == 0) {
1111 ZVAL_FALSE(ret);
1112 } else {
1113 ZVAL_STRING(ret, (char*)data->children->content);
1114 convert_to_boolean(ret);
1115 }
1116 } else {
1117 soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
1118 }
1119 } else {
1120 ZVAL_NULL(ret);
1121 }
1122 return ret;
1123 }
1124
to_xml_bool(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)1125 static xmlNodePtr to_xml_bool(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
1126 {
1127 xmlNodePtr ret;
1128
1129 ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1130 xmlAddChild(parent, ret);
1131 FIND_ZVAL_NULL(data, ret, style);
1132
1133 if (zend_is_true(data)) {
1134 xmlNodeSetContent(ret, BAD_CAST("true"));
1135 } else {
1136 xmlNodeSetContent(ret, BAD_CAST("false"));
1137 }
1138
1139 if (style == SOAP_ENCODED) {
1140 set_ns_and_type(ret, type);
1141 }
1142 return ret;
1143 }
1144
1145 /* Null encode/decode */
to_zval_null(zval * ret,encodeTypePtr type,xmlNodePtr data)1146 static zval *to_zval_null(zval *ret, encodeTypePtr type, xmlNodePtr data)
1147 {
1148 ZVAL_NULL(ret);
1149 return ret;
1150 }
1151
to_xml_null(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)1152 static xmlNodePtr to_xml_null(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
1153 {
1154 xmlNodePtr ret;
1155
1156 ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1157 xmlAddChild(parent, ret);
1158 if (style == SOAP_ENCODED) {
1159 set_xsi_nil(ret);
1160 }
1161 return ret;
1162 }
1163
set_zval_property(zval * object,char * name,zval * val)1164 static void set_zval_property(zval* object, char* name, zval* val)
1165 {
1166 zend_update_property(Z_OBJCE_P(object), Z_OBJ_P(object), name, strlen(name), val);
1167 Z_TRY_DELREF_P(val);
1168 }
1169
get_zval_property(zval * object,char * name,zval * rv)1170 static zval* get_zval_property(zval* object, char* name, zval *rv)
1171 {
1172 if (Z_TYPE_P(object) == IS_OBJECT) {
1173 zval *data = zend_read_property(Z_OBJCE_P(object), Z_OBJ_P(object), name, strlen(name), 1, rv);
1174 if (data == &EG(uninitialized_zval)) {
1175 return NULL;
1176 }
1177 ZVAL_DEREF(data);
1178 return data;
1179 } else if (Z_TYPE_P(object) == IS_ARRAY) {
1180 return zend_hash_str_find_deref(Z_ARRVAL_P(object), name, strlen(name));
1181 }
1182 return NULL;
1183 }
1184
unset_zval_property(zval * object,char * name)1185 static void unset_zval_property(zval* object, char* name)
1186 {
1187 if (Z_TYPE_P(object) == IS_OBJECT) {
1188 zend_unset_property(Z_OBJCE_P(object), Z_OBJ_P(object), name, strlen(name));
1189 } else if (Z_TYPE_P(object) == IS_ARRAY) {
1190 zend_hash_str_del(Z_ARRVAL_P(object), name, strlen(name));
1191 }
1192 }
1193
model_to_zval_any(zval * ret,xmlNodePtr node)1194 static void model_to_zval_any(zval *ret, xmlNodePtr node)
1195 {
1196 zval rv, arr, val, keepVal;
1197 zval* any = NULL;
1198 char* name = NULL;
1199
1200 while (node != NULL) {
1201 if (get_zval_property(ret, (char*)node->name, &rv) == NULL) {
1202
1203 ZVAL_NULL(&val);
1204 master_to_zval(&val, get_conversion(XSD_ANYXML), node);
1205
1206 if (any && Z_TYPE_P(any) != IS_ARRAY) {
1207 /* Convert into array */
1208 array_init(&arr);
1209 if (name) {
1210 add_assoc_zval(&arr, name, any);
1211 } else {
1212 add_next_index_zval(&arr, any);
1213 }
1214 any = &arr;
1215 }
1216
1217 if (Z_TYPE(val) == IS_STRING && *Z_STRVAL(val) == '<') {
1218 name = NULL;
1219 while (node->next != NULL) {
1220 zval val2;
1221
1222 ZVAL_NULL(&val2);
1223 master_to_zval(&val2, get_conversion(XSD_ANYXML), node->next);
1224 if (Z_TYPE(val2) != IS_STRING || *Z_STRVAL(val) != '<') {
1225 Z_TRY_DELREF(val2);
1226 break;
1227 }
1228 concat_function(&val, &val, &val2);
1229 zval_ptr_dtor(&val2);
1230 node = node->next;
1231 }
1232 } else {
1233 name = (char*)node->name;
1234 }
1235
1236 if (any == NULL) {
1237 if (name) {
1238 /* Convert into array */
1239 array_init(&arr);
1240 add_assoc_zval(&arr, name, &val);
1241 any = &arr;
1242 name = NULL;
1243 } else {
1244 ZVAL_COPY_VALUE(&keepVal, &val);
1245 any = &keepVal;
1246 }
1247 } else {
1248 /* Add array element */
1249 if (name) {
1250 zval *el;
1251 if ((el = zend_hash_str_find(Z_ARRVAL_P(any), name, strlen(name))) != NULL) {
1252 if (Z_TYPE_P(el) != IS_ARRAY) {
1253 /* Convert into array */
1254 array_init(&arr);
1255 add_next_index_zval(&arr, el);
1256 el = &arr;
1257 }
1258 add_next_index_zval(el, &val);
1259 } else {
1260 add_assoc_zval(any, name, &val);
1261 }
1262 } else {
1263 add_next_index_zval(any, &val);
1264 }
1265 name = NULL;
1266 }
1267 }
1268 node = node->next;
1269 }
1270 if (any) {
1271 set_zval_property(ret, name ? name : "any", any);
1272 }
1273 }
1274
model_to_zval_object(zval * ret,sdlContentModelPtr model,xmlNodePtr data,sdlPtr sdl)1275 static void model_to_zval_object(zval *ret, sdlContentModelPtr model, xmlNodePtr data, sdlPtr sdl)
1276 {
1277 switch (model->kind) {
1278 case XSD_CONTENT_ELEMENT:
1279 if (model->u.element->name) {
1280 xmlNodePtr node = get_node(data->children, model->u.element->name);
1281
1282 if (node) {
1283 zval val;
1284 xmlNodePtr r_node;
1285
1286 ZVAL_NULL(&val);
1287 r_node = check_and_resolve_href(node);
1288 if (r_node && r_node->children && r_node->children->content) {
1289 if (model->u.element->fixed && strcmp(model->u.element->fixed, (char*)r_node->children->content) != 0) {
1290 soap_error3(E_ERROR, "Encoding: Element '%s' has fixed value '%s' (value '%s' is not allowed)", model->u.element->name, model->u.element->fixed, r_node->children->content);
1291 }
1292 master_to_zval(&val, model->u.element->encode, r_node);
1293 } else if (model->u.element->fixed) {
1294 xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1295 xmlNodeSetContent(dummy, BAD_CAST(model->u.element->fixed));
1296 master_to_zval(&val, model->u.element->encode, dummy);
1297 xmlFreeNode(dummy);
1298 } else if (model->u.element->def && !model->u.element->nillable) {
1299 xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1300 xmlNodeSetContent(dummy, BAD_CAST(model->u.element->def));
1301 master_to_zval(&val, model->u.element->encode, dummy);
1302 xmlFreeNode(dummy);
1303 } else {
1304 master_to_zval(&val, model->u.element->encode, r_node);
1305 }
1306 if ((node = get_node(node->next, model->u.element->name)) != NULL) {
1307 zval array;
1308
1309 array_init(&array);
1310 add_next_index_zval(&array, &val);
1311 do {
1312 ZVAL_NULL(&val);
1313 if (node && node->children && node->children->content) {
1314 if (model->u.element->fixed && strcmp(model->u.element->fixed, (char*)node->children->content) != 0) {
1315 soap_error3(E_ERROR, "Encoding: Element '%s' has fixed value '%s' (value '%s' is not allowed)", model->u.element->name, model->u.element->fixed, node->children->content);
1316 }
1317 master_to_zval(&val, model->u.element->encode, node);
1318 } else if (model->u.element->fixed) {
1319 xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1320 xmlNodeSetContent(dummy, BAD_CAST(model->u.element->fixed));
1321 master_to_zval(&val, model->u.element->encode, dummy);
1322 xmlFreeNode(dummy);
1323 } else if (model->u.element->def && !model->u.element->nillable) {
1324 xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1325 xmlNodeSetContent(dummy, BAD_CAST(model->u.element->def));
1326 master_to_zval(&val, model->u.element->encode, dummy);
1327 xmlFreeNode(dummy);
1328 } else {
1329 master_to_zval(&val, model->u.element->encode, node);
1330 }
1331 add_next_index_zval(&array, &val);
1332 } while ((node = get_node(node->next, model->u.element->name)) != NULL);
1333 ZVAL_COPY_VALUE(&val, &array);
1334 } else if ((Z_TYPE(val) != IS_NULL || !model->u.element->nillable) &&
1335 (SOAP_GLOBAL(features) & SOAP_SINGLE_ELEMENT_ARRAYS) &&
1336 (model->max_occurs == -1 || model->max_occurs > 1)) {
1337 zval array;
1338
1339 array_init(&array);
1340 add_next_index_zval(&array, &val);
1341 ZVAL_COPY_VALUE(&val, &array);
1342 }
1343 set_zval_property(ret, model->u.element->name, &val);
1344 }
1345 }
1346 break;
1347 case XSD_CONTENT_ALL:
1348 case XSD_CONTENT_SEQUENCE:
1349 case XSD_CONTENT_CHOICE: {
1350 sdlContentModelPtr tmp;
1351 sdlContentModelPtr any = NULL;
1352
1353 ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
1354 if (tmp->kind == XSD_CONTENT_ANY) {
1355 any = tmp;
1356 } else {
1357 model_to_zval_object(ret, tmp, data, sdl);
1358 }
1359 } ZEND_HASH_FOREACH_END();
1360 if (any) {
1361 model_to_zval_any(ret, data->children);
1362 }
1363 break;
1364 }
1365 case XSD_CONTENT_GROUP:
1366 model_to_zval_object(ret, model->u.group->model, data, sdl);
1367 break;
1368 default:
1369 break;
1370 }
1371 }
1372
1373 /* Struct encode/decode */
to_zval_object_ex(zval * ret,encodeTypePtr type,xmlNodePtr data,zend_class_entry * pce)1374 static zval *to_zval_object_ex(zval *ret, encodeTypePtr type, xmlNodePtr data, zend_class_entry *pce)
1375 {
1376 xmlNodePtr trav;
1377 sdlPtr sdl;
1378 sdlTypePtr sdlType = type->sdl_type;
1379 zend_class_entry *ce = ZEND_STANDARD_CLASS_DEF_PTR;
1380 zval *redo_any = NULL, rv, arr;
1381
1382 if (pce) {
1383 ce = pce;
1384 } else if (SOAP_GLOBAL(class_map) && type->type_str) {
1385 zval *classname;
1386 zend_class_entry *tmp;
1387
1388 if ((classname = zend_hash_str_find_deref(SOAP_GLOBAL(class_map), type->type_str, strlen(type->type_str))) != NULL &&
1389 Z_TYPE_P(classname) == IS_STRING &&
1390 (tmp = zend_fetch_class(Z_STR_P(classname), ZEND_FETCH_CLASS_AUTO)) != NULL) {
1391 ce = tmp;
1392 }
1393 }
1394 sdl = SOAP_GLOBAL(sdl);
1395 if (sdlType) {
1396 if (sdlType->kind == XSD_TYPEKIND_RESTRICTION &&
1397 sdlType->encode && type != &sdlType->encode->details) {
1398 encodePtr enc;
1399
1400 enc = sdlType->encode;
1401 while (enc && enc->details.sdl_type &&
1402 enc->details.sdl_type->kind != XSD_TYPEKIND_SIMPLE &&
1403 enc->details.sdl_type->kind != XSD_TYPEKIND_LIST &&
1404 enc->details.sdl_type->kind != XSD_TYPEKIND_UNION) {
1405 enc = enc->details.sdl_type->encode;
1406 }
1407 if (enc) {
1408 zval base;
1409
1410 ZVAL_NULL(ret);
1411 if (soap_check_xml_ref(ret, data)) {
1412 return ret;
1413 }
1414
1415 object_init_ex(ret, ce);
1416 master_to_zval_int(&base, enc, data);
1417 set_zval_property(ret, "_", &base);
1418 } else {
1419 ZVAL_NULL(ret);
1420 FIND_XML_NULL(data, ret);
1421 if (soap_check_xml_ref(ret, data)) {
1422 return ret;
1423 }
1424 object_init_ex(ret, ce);
1425 soap_add_xml_ref(ret, data);
1426 }
1427 } else if (sdlType->kind == XSD_TYPEKIND_EXTENSION &&
1428 sdlType->encode &&
1429 type != &sdlType->encode->details) {
1430 if (sdlType->encode->details.sdl_type &&
1431 sdlType->encode->details.sdl_type->kind != XSD_TYPEKIND_SIMPLE &&
1432 sdlType->encode->details.sdl_type->kind != XSD_TYPEKIND_LIST &&
1433 sdlType->encode->details.sdl_type->kind != XSD_TYPEKIND_UNION) {
1434
1435 CHECK_XML_NULL(data);
1436 if (soap_check_xml_ref(ret, data)) {
1437 return ret;
1438 }
1439
1440 if (ce != ZEND_STANDARD_CLASS_DEF_PTR &&
1441 sdlType->encode->to_zval == sdl_guess_convert_zval &&
1442 sdlType->encode->details.sdl_type != NULL &&
1443 (sdlType->encode->details.sdl_type->kind == XSD_TYPEKIND_COMPLEX ||
1444 sdlType->encode->details.sdl_type->kind == XSD_TYPEKIND_RESTRICTION ||
1445 sdlType->encode->details.sdl_type->kind == XSD_TYPEKIND_EXTENSION) &&
1446 (sdlType->encode->details.sdl_type->encode == NULL ||
1447 (sdlType->encode->details.sdl_type->encode->details.type != IS_ARRAY &&
1448 sdlType->encode->details.sdl_type->encode->details.type != SOAP_ENC_ARRAY))) {
1449 to_zval_object_ex(ret, &sdlType->encode->details, data, ce);
1450 } else {
1451 master_to_zval_int(ret, sdlType->encode, data);
1452 }
1453
1454 soap_add_xml_ref(ret, data);
1455
1456 redo_any = get_zval_property(ret, "any", &rv);
1457 if (Z_TYPE_P(ret) == IS_OBJECT && ce != ZEND_STANDARD_CLASS_DEF_PTR) {
1458 zend_object *zobj = Z_OBJ_P(ret);
1459 zobj->ce = ce;
1460 }
1461 } else {
1462 zval base;
1463
1464 ZVAL_NULL(ret);
1465 if (soap_check_xml_ref(ret, data)) {
1466 return ret;
1467 }
1468
1469 object_init_ex(ret, ce);
1470 soap_add_xml_ref(ret, data);
1471 master_to_zval_int(&base, sdlType->encode, data);
1472 set_zval_property(ret, "_", &base);
1473 }
1474 } else {
1475 ZVAL_NULL(ret);
1476 FIND_XML_NULL(data, ret);
1477 if (soap_check_xml_ref(ret, data)) {
1478 return ret;
1479 }
1480 object_init_ex(ret, ce);
1481 soap_add_xml_ref(ret, data);
1482 }
1483 if (sdlType->model) {
1484 model_to_zval_object(ret, sdlType->model, data, sdl);
1485 if (redo_any) {
1486 if (!get_zval_property(ret, "any", &rv)) {
1487 model_to_zval_any(ret, data->children);
1488 soap_add_xml_ref(ret, data);
1489 } else {
1490 unset_zval_property(ret, "any");
1491 }
1492 }
1493 }
1494 if (sdlType->attributes) {
1495 sdlAttributePtr attr;
1496
1497 ZEND_HASH_FOREACH_PTR(sdlType->attributes, attr) {
1498 if (attr->name) {
1499 xmlAttrPtr val = get_attribute(data->properties, attr->name);
1500 char *str_val = NULL;
1501
1502 if (val && val->children && val->children->content) {
1503 str_val = (char*)val->children->content;
1504 if (attr->fixed && strcmp(attr->fixed, str_val) != 0) {
1505 soap_error3(E_ERROR, "Encoding: Attribute '%s' has fixed value '%s' (value '%s' is not allowed)", attr->name, attr->fixed, str_val);
1506 }
1507 } else if (attr->fixed) {
1508 str_val = attr->fixed;
1509 } else if (attr->def) {
1510 str_val = attr->def;
1511 }
1512 if (str_val) {
1513 xmlNodePtr dummy, text;
1514 zval data;
1515
1516 dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1517 text = xmlNewText(BAD_CAST(str_val));
1518 xmlAddChild(dummy, text);
1519 ZVAL_NULL(&data);
1520 /* TODO: There are other places using dummy nodes -- generalize? */
1521 zend_try {
1522 master_to_zval(&data, attr->encode, dummy);
1523 } zend_catch {
1524 xmlFreeNode(dummy);
1525 zend_bailout();
1526 } zend_end_try();
1527 xmlFreeNode(dummy);
1528 set_zval_property(ret, attr->name, &data);
1529 }
1530 }
1531 } ZEND_HASH_FOREACH_END();
1532 }
1533 } else {
1534 ZVAL_NULL(ret);
1535 FIND_XML_NULL(data, ret);
1536 if (soap_check_xml_ref(ret, data)) {
1537 return ret;
1538 }
1539
1540 object_init_ex(ret, ce);
1541 soap_add_xml_ref(ret, data);
1542 trav = data->children;
1543
1544 while (trav != NULL) {
1545 if (trav->type == XML_ELEMENT_NODE) {
1546 zval tmpVal, rv;
1547 zval *prop;
1548
1549 ZVAL_NULL(&tmpVal);
1550 master_to_zval(&tmpVal, NULL, trav);
1551
1552 prop = get_zval_property(ret, (char*)trav->name, &rv);
1553 if (!prop) {
1554 if (!trav->next || !get_node(trav->next, (char*)trav->name)) {
1555 set_zval_property(ret, (char*)trav->name, &tmpVal);
1556 } else {
1557 zval arr;
1558
1559 array_init(&arr);
1560 add_next_index_zval(&arr, &tmpVal);
1561 set_zval_property(ret, (char*)trav->name, &arr);
1562 }
1563 } else {
1564 /* Property already exist - make array */
1565 if (Z_TYPE_P(prop) != IS_ARRAY) {
1566 /* Convert into array */
1567 array_init(&arr);
1568 Z_ADDREF_P(prop);
1569 add_next_index_zval(&arr, prop);
1570 set_zval_property(ret, (char*)trav->name, &arr);
1571 prop = &arr;
1572 }
1573 /* Add array element */
1574 add_next_index_zval(prop, &tmpVal);
1575 }
1576 }
1577 trav = trav->next;
1578 }
1579 }
1580 return ret;
1581 }
1582
to_zval_object(zval * ret,encodeTypePtr type,xmlNodePtr data)1583 static zval *to_zval_object(zval *ret, encodeTypePtr type, xmlNodePtr data)
1584 {
1585 return to_zval_object_ex(ret, type, data, NULL);
1586 }
1587
1588
model_to_xml_object(xmlNodePtr node,sdlContentModelPtr model,zval * object,int style,int strict)1589 static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval *object, int style, int strict)
1590 {
1591 switch (model->kind) {
1592 case XSD_CONTENT_ELEMENT: {
1593 zval *data;
1594 xmlNodePtr property;
1595 encodePtr enc;
1596 zval rv;
1597
1598 data = get_zval_property(object, model->u.element->name, &rv);
1599 if (data &&
1600 Z_TYPE_P(data) == IS_NULL &&
1601 !model->u.element->nillable &&
1602 model->min_occurs > 0 &&
1603 !strict) {
1604 return 0;
1605 }
1606 if (data) {
1607 enc = model->u.element->encode;
1608 if ((model->max_occurs == -1 || model->max_occurs > 1) &&
1609 Z_TYPE_P(data) == IS_ARRAY &&
1610 !is_map(data)) {
1611 HashTable *ht = Z_ARRVAL_P(data);
1612 zval *val;
1613
1614 ZEND_HASH_FOREACH_VAL(ht, val) {
1615 ZVAL_DEREF(val);
1616 if (Z_TYPE_P(val) == IS_NULL && model->u.element->nillable) {
1617 property = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1618 xmlAddChild(node, property);
1619 set_xsi_nil(property);
1620 } else {
1621 property = master_to_xml(enc, val, style, node);
1622 if (property->children && property->children->content &&
1623 model->u.element->fixed && strcmp(model->u.element->fixed, (char*)property->children->content) != 0) {
1624 soap_error3(E_ERROR, "Encoding: Element '%s' has fixed value '%s' (value '%s' is not allowed)", model->u.element->name, model->u.element->fixed, property->children->content);
1625 }
1626 }
1627 xmlNodeSetName(property, BAD_CAST(model->u.element->name));
1628 if (style == SOAP_LITERAL &&
1629 model->u.element->namens &&
1630 model->u.element->form == XSD_FORM_QUALIFIED) {
1631 xmlNsPtr nsp = encode_add_ns(property, model->u.element->namens);
1632 xmlSetNs(property, nsp);
1633 }
1634 } ZEND_HASH_FOREACH_END();
1635 } else {
1636 if (Z_TYPE_P(data) == IS_NULL && model->u.element->nillable) {
1637 property = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1638 xmlAddChild(node, property);
1639 set_xsi_nil(property);
1640 } else if (Z_TYPE_P(data) == IS_NULL && model->min_occurs == 0) {
1641 return 1;
1642 } else {
1643 property = master_to_xml(enc, data, style, node);
1644 if (property->children && property->children->content &&
1645 model->u.element->fixed && strcmp(model->u.element->fixed, (char*)property->children->content) != 0) {
1646 soap_error3(E_ERROR, "Encoding: Element '%s' has fixed value '%s' (value '%s' is not allowed)", model->u.element->name, model->u.element->fixed, property->children->content);
1647 }
1648 }
1649 xmlNodeSetName(property, BAD_CAST(model->u.element->name));
1650 if (style == SOAP_LITERAL &&
1651 model->u.element->namens &&
1652 model->u.element->form == XSD_FORM_QUALIFIED) {
1653 xmlNsPtr nsp = encode_add_ns(property, model->u.element->namens);
1654 xmlSetNs(property, nsp);
1655 }
1656 }
1657 return 1;
1658 } else if (strict && model->u.element->nillable && model->min_occurs > 0) {
1659 property = xmlNewNode(NULL, BAD_CAST(model->u.element->name));
1660 xmlAddChild(node, property);
1661 set_xsi_nil(property);
1662 if (style == SOAP_LITERAL &&
1663 model->u.element->namens &&
1664 model->u.element->form == XSD_FORM_QUALIFIED) {
1665 xmlNsPtr nsp = encode_add_ns(property, model->u.element->namens);
1666 xmlSetNs(property, nsp);
1667 }
1668 return 1;
1669 } else if (model->min_occurs == 0) {
1670 return 2;
1671 } else {
1672 if (strict) {
1673 soap_error1(E_ERROR, "Encoding: object has no '%s' property", model->u.element->name);
1674 }
1675 return 0;
1676 }
1677 break;
1678 }
1679 case XSD_CONTENT_ANY: {
1680 zval *data;
1681 encodePtr enc;
1682 zval rv;
1683
1684 data = get_zval_property(object, "any", &rv);
1685 if (data) {
1686 enc = get_conversion(XSD_ANYXML);
1687 if ((model->max_occurs == -1 || model->max_occurs > 1) &&
1688 Z_TYPE_P(data) == IS_ARRAY &&
1689 !is_map(data)) {
1690 HashTable *ht = Z_ARRVAL_P(data);
1691 zval *val;
1692
1693 ZEND_HASH_FOREACH_VAL(ht, val) {
1694 master_to_xml(enc, val, style, node);
1695 } ZEND_HASH_FOREACH_END();
1696 } else {
1697 master_to_xml(enc, data, style, node);
1698 }
1699 return 1;
1700 } else if (model->min_occurs == 0) {
1701 return 2;
1702 } else {
1703 if (strict) {
1704 soap_error0(E_ERROR, "Encoding: object has no 'any' property");
1705 }
1706 return 0;
1707 }
1708 break;
1709 }
1710 case XSD_CONTENT_SEQUENCE:
1711 case XSD_CONTENT_ALL: {
1712 sdlContentModelPtr tmp;
1713
1714 ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
1715 if (!model_to_xml_object(node, tmp, object, style, strict && (tmp->min_occurs > 0))) {
1716 if (!strict || tmp->min_occurs > 0) {
1717 return 0;
1718 }
1719 }
1720 strict = 1;
1721 } ZEND_HASH_FOREACH_END();
1722 return 1;
1723 }
1724 case XSD_CONTENT_CHOICE: {
1725 sdlContentModelPtr tmp;
1726 int ret = 0;
1727
1728 ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
1729 int tmp_ret = model_to_xml_object(node, tmp, object, style, 0);
1730 if (tmp_ret == 1) {
1731 return 1;
1732 } else if (tmp_ret != 0) {
1733 ret = 1;
1734 }
1735 } ZEND_HASH_FOREACH_END();
1736 return ret;
1737 }
1738 case XSD_CONTENT_GROUP: {
1739 return model_to_xml_object(node, model->u.group->model, object, style, strict && model->min_occurs > 0);
1740 }
1741 default:
1742 break;
1743 }
1744 return 1;
1745 }
1746
model_array_element(sdlContentModelPtr model)1747 static sdlTypePtr model_array_element(sdlContentModelPtr model)
1748 {
1749 switch (model->kind) {
1750 case XSD_CONTENT_ELEMENT: {
1751 if (model->max_occurs == -1 || model->max_occurs > 1) {
1752 return model->u.element;
1753 } else {
1754 return NULL;
1755 }
1756 }
1757 case XSD_CONTENT_SEQUENCE:
1758 case XSD_CONTENT_ALL:
1759 case XSD_CONTENT_CHOICE: {
1760 sdlContentModelPtr tmp;
1761
1762 if (zend_hash_num_elements(model->u.content) != 1) {
1763 return NULL;
1764 }
1765 ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
1766 return model_array_element(tmp);
1767 } ZEND_HASH_FOREACH_END();
1768 }
1769 case XSD_CONTENT_GROUP: {
1770 return model_array_element(model->u.group->model);
1771 }
1772 default:
1773 break;
1774 }
1775 return NULL;
1776 }
1777
to_xml_object(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)1778 static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
1779 {
1780 xmlNodePtr xmlParam;
1781 HashTable *prop = NULL;
1782 sdlTypePtr sdlType = type->sdl_type;
1783
1784 if (!data || Z_TYPE_P(data) == IS_NULL) {
1785 xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1786 xmlAddChild(parent, xmlParam);
1787 if (style == SOAP_ENCODED) {
1788 set_xsi_nil(xmlParam);
1789 set_ns_and_type(xmlParam, type);
1790 }
1791 return xmlParam;
1792 }
1793
1794 if (Z_TYPE_P(data) == IS_OBJECT) {
1795 prop = Z_OBJPROP_P(data);
1796 } else if (Z_TYPE_P(data) == IS_ARRAY) {
1797 prop = Z_ARRVAL_P(data);
1798 }
1799
1800 if (sdlType) {
1801 if (sdlType->kind == XSD_TYPEKIND_RESTRICTION &&
1802 sdlType->encode && type != &sdlType->encode->details) {
1803 encodePtr enc;
1804
1805 enc = sdlType->encode;
1806 while (enc && enc->details.sdl_type &&
1807 enc->details.sdl_type->kind != XSD_TYPEKIND_SIMPLE &&
1808 enc->details.sdl_type->kind != XSD_TYPEKIND_LIST &&
1809 enc->details.sdl_type->kind != XSD_TYPEKIND_UNION) {
1810 enc = enc->details.sdl_type->encode;
1811 }
1812 if (enc) {
1813 zval rv;
1814 zval *tmp = get_zval_property(data, "_", &rv);
1815 if (tmp) {
1816 xmlParam = master_to_xml(enc, tmp, style, parent);
1817 } else if (prop == NULL) {
1818 xmlParam = master_to_xml(enc, data, style, parent);
1819 } else {
1820 xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1821 xmlAddChild(parent, xmlParam);
1822 }
1823 } else {
1824 xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1825 xmlAddChild(parent, xmlParam);
1826 }
1827 } else if (sdlType->kind == XSD_TYPEKIND_EXTENSION &&
1828 sdlType->encode && type != &sdlType->encode->details) {
1829 if (sdlType->encode->details.sdl_type &&
1830 sdlType->encode->details.sdl_type->kind != XSD_TYPEKIND_SIMPLE &&
1831 sdlType->encode->details.sdl_type->kind != XSD_TYPEKIND_LIST &&
1832 sdlType->encode->details.sdl_type->kind != XSD_TYPEKIND_UNION) {
1833
1834 if (prop) { GC_TRY_PROTECT_RECURSION(prop); }
1835 xmlParam = master_to_xml(sdlType->encode, data, style, parent);
1836 if (prop) { GC_TRY_UNPROTECT_RECURSION(prop); }
1837 } else {
1838 zval rv;
1839 zval *tmp = get_zval_property(data, "_", &rv);
1840
1841 if (tmp) {
1842 xmlParam = master_to_xml(sdlType->encode, tmp, style, parent);
1843 } else if (prop == NULL) {
1844 xmlParam = master_to_xml(sdlType->encode, data, style, parent);
1845 } else {
1846 xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1847 xmlAddChild(parent, xmlParam);
1848 }
1849 }
1850 } else {
1851 xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1852 xmlAddChild(parent, xmlParam);
1853 }
1854
1855 if (soap_check_zval_ref(data, xmlParam)) {
1856 return xmlParam;
1857 }
1858 if (prop != NULL) {
1859 sdlTypePtr array_el;
1860
1861 if (Z_TYPE_P(data) == IS_ARRAY &&
1862 !is_map(data) &&
1863 sdlType->attributes == NULL &&
1864 sdlType->model != NULL &&
1865 (array_el = model_array_element(sdlType->model)) != NULL) {
1866 zval *val;
1867
1868 ZEND_HASH_FOREACH_VAL(prop, val) {
1869 xmlNodePtr property;
1870 ZVAL_DEREF(val);
1871 if (Z_TYPE_P(val) == IS_NULL && array_el->nillable) {
1872 property = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1873 xmlAddChild(xmlParam, property);
1874 set_xsi_nil(property);
1875 } else {
1876 property = master_to_xml(array_el->encode, val, style, xmlParam);
1877 }
1878 xmlNodeSetName(property, BAD_CAST(array_el->name));
1879 if (style == SOAP_LITERAL &&
1880 array_el->namens &&
1881 array_el->form == XSD_FORM_QUALIFIED) {
1882 xmlNsPtr nsp = encode_add_ns(property, array_el->namens);
1883 xmlSetNs(property, nsp);
1884 }
1885 } ZEND_HASH_FOREACH_END();
1886 } else if (sdlType->model) {
1887 model_to_xml_object(xmlParam, sdlType->model, data, style, 1);
1888 }
1889 if (sdlType->attributes) {
1890 sdlAttributePtr attr;
1891 zval *zattr, rv;
1892
1893 ZEND_HASH_FOREACH_PTR(sdlType->attributes, attr) {
1894 if (attr->name) {
1895 zattr = get_zval_property(data, attr->name, &rv);
1896 if (zattr) {
1897 xmlNodePtr dummy;
1898
1899 dummy = master_to_xml(attr->encode, zattr, SOAP_LITERAL, xmlParam);
1900 if (dummy->children && dummy->children->content) {
1901 if (attr->fixed && strcmp(attr->fixed, (char*)dummy->children->content) != 0) {
1902 soap_error3(E_ERROR, "Encoding: Attribute '%s' has fixed value '%s' (value '%s' is not allowed)", attr->name, attr->fixed, dummy->children->content);
1903 }
1904 /* we need to handle xml: namespace specially, since it is
1905 an implicit schema. Otherwise, use form.
1906 */
1907 if (attr->namens &&
1908 (!strncmp(attr->namens, XML_NAMESPACE, sizeof(XML_NAMESPACE)) ||
1909 attr->form == XSD_FORM_QUALIFIED)) {
1910 xmlNsPtr nsp = encode_add_ns(xmlParam, attr->namens);
1911
1912 xmlSetNsProp(xmlParam, nsp, BAD_CAST(attr->name), dummy->children->content);
1913 } else {
1914 xmlSetProp(xmlParam, BAD_CAST(attr->name), dummy->children->content);
1915 }
1916 }
1917 xmlUnlinkNode(dummy);
1918 xmlFreeNode(dummy);
1919 }
1920 }
1921 } ZEND_HASH_FOREACH_END();
1922 }
1923 }
1924 if (style == SOAP_ENCODED) {
1925 set_ns_and_type(xmlParam, type);
1926 }
1927 } else {
1928 xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
1929 xmlAddChild(parent, xmlParam);
1930
1931 if (soap_check_zval_ref(data, xmlParam)) {
1932 return xmlParam;
1933 }
1934 if (prop != NULL) {
1935 zval *zprop;
1936 zend_string *str_key;
1937 xmlNodePtr property;
1938
1939 ZEND_HASH_FOREACH_STR_KEY_VAL_IND(prop, str_key, zprop) {
1940 ZVAL_DEREF(zprop);
1941 property = master_to_xml(get_conversion(Z_TYPE_P(zprop)), zprop, style, xmlParam);
1942
1943 if (str_key) {
1944 const char *prop_name;
1945
1946 if (Z_TYPE_P(data) == IS_OBJECT) {
1947 const char *class_name;
1948
1949 zend_unmangle_property_name(str_key, &class_name, &prop_name);
1950 } else {
1951 prop_name = ZSTR_VAL(str_key);
1952 }
1953 if (prop_name) {
1954 xmlNodeSetName(property, BAD_CAST(prop_name));
1955 }
1956 }
1957 } ZEND_HASH_FOREACH_END();
1958 }
1959 if (style == SOAP_ENCODED) {
1960 set_ns_and_type(xmlParam, type);
1961 }
1962 }
1963 return xmlParam;
1964 }
1965
1966 /* Array encode/decode */
guess_array_map(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)1967 static xmlNodePtr guess_array_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
1968 {
1969 encodePtr enc = NULL;
1970
1971 if (data && Z_TYPE_P(data) == IS_ARRAY) {
1972 if (is_map(data)) {
1973 enc = get_conversion(APACHE_MAP);
1974 } else {
1975 enc = get_conversion(SOAP_ENC_ARRAY);
1976 }
1977 }
1978 if (!enc) {
1979 enc = get_conversion(IS_NULL);
1980 }
1981
1982 return master_to_xml(enc, data, style, parent);
1983 }
1984
calc_dimension_12(const char * str)1985 static int calc_dimension_12(const char* str)
1986 {
1987 int i = 0, flag = 0;
1988 while (*str != '\0' && (*str < '0' || *str > '9') && (*str != '*')) {
1989 str++;
1990 }
1991 if (*str == '*') {
1992 i++;
1993 str++;
1994 }
1995 while (*str != '\0') {
1996 if (*str >= '0' && *str <= '9') {
1997 if (flag == 0) {
1998 i++;
1999 flag = 1;
2000 }
2001 } else if (*str == '*') {
2002 soap_error0(E_ERROR, "Encoding: '*' may only be first arraySize value in list");
2003 } else {
2004 flag = 0;
2005 }
2006 str++;
2007 }
2008 return i;
2009 }
2010
get_position_12(int dimension,const char * str)2011 static int* get_position_12(int dimension, const char* str)
2012 {
2013 int *pos;
2014 int i = -1, flag = 0;
2015
2016 pos = safe_emalloc(sizeof(int), dimension, 0);
2017 memset(pos,0,sizeof(int)*dimension);
2018 while (*str != '\0' && (*str < '0' || *str > '9') && (*str != '*')) {
2019 str++;
2020 }
2021 if (*str == '*') {
2022 str++;
2023 i++;
2024 }
2025 while (*str != '\0') {
2026 if (*str >= '0' && *str <= '9') {
2027 if (flag == 0) {
2028 i++;
2029 flag = 1;
2030 }
2031 pos[i] = (pos[i]*10)+(*str-'0');
2032 } else if (*str == '*') {
2033 soap_error0(E_ERROR, "Encoding: '*' may only be first arraySize value in list");
2034 } else {
2035 flag = 0;
2036 }
2037 str++;
2038 }
2039 return pos;
2040 }
2041
calc_dimension(const char * str)2042 static int calc_dimension(const char* str)
2043 {
2044 int i = 1;
2045 while (*str != ']' && *str != '\0') {
2046 if (*str == ',') {
2047 i++;
2048 }
2049 str++;
2050 }
2051 return i;
2052 }
2053
get_position_ex(int dimension,const char * str,int ** pos)2054 static void get_position_ex(int dimension, const char* str, int** pos)
2055 {
2056 int i = 0;
2057
2058 memset(*pos,0,sizeof(int)*dimension);
2059 while (*str != ']' && *str != '\0' && i < dimension) {
2060 if (*str >= '0' && *str <= '9') {
2061 (*pos)[i] = ((*pos)[i]*10)+(*str-'0');
2062 } else if (*str == ',') {
2063 i++;
2064 }
2065 str++;
2066 }
2067 }
2068
get_position(int dimension,const char * str)2069 static int* get_position(int dimension, const char* str)
2070 {
2071 int *pos;
2072
2073 pos = safe_emalloc(sizeof(int), dimension, 0);
2074 get_position_ex(dimension, str, &pos);
2075 return pos;
2076 }
2077
add_xml_array_elements(xmlNodePtr xmlParam,sdlTypePtr type,encodePtr enc,xmlNsPtr ns,int dimension,int * dims,zval * data,int style)2078 static void add_xml_array_elements(xmlNodePtr xmlParam,
2079 sdlTypePtr type,
2080 encodePtr enc,
2081 xmlNsPtr ns,
2082 int dimension ,
2083 int* dims,
2084 zval* data,
2085 int style
2086 )
2087 {
2088 int j = 0;
2089 zval *zdata;
2090 xmlNodePtr xparam;
2091
2092 if (data && Z_TYPE_P(data) == IS_ARRAY) {
2093 ZEND_HASH_FOREACH_VAL_IND(Z_ARRVAL_P(data), zdata) {
2094 if (j >= dims[0]) {
2095 break;
2096 }
2097 ZVAL_DEREF(zdata);
2098 if (dimension == 1) {
2099 if (enc == NULL) {
2100 xparam = master_to_xml(get_conversion(Z_TYPE_P(zdata)), zdata, style, xmlParam);
2101 } else {
2102 xparam = master_to_xml(enc, zdata, style, xmlParam);
2103 }
2104
2105 if (type) {
2106 xmlNodeSetName(xparam, BAD_CAST(type->name));
2107 } else if (style == SOAP_LITERAL && enc && enc->details.type_str) {
2108 xmlNodeSetName(xparam, BAD_CAST(enc->details.type_str));
2109 xmlSetNs(xparam, ns);
2110 } else {
2111 xmlNodeSetName(xparam, BAD_CAST("item"));
2112 }
2113 } else {
2114 add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, zdata, style);
2115 }
2116 j++;
2117 } ZEND_HASH_FOREACH_END();
2118
2119 if (dimension == 1) {
2120 while (j < dims[0]) {
2121 xparam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
2122 xmlAddChild(xmlParam, xparam);
2123
2124 if (type) {
2125 xmlNodeSetName(xparam, BAD_CAST(type->name));
2126 } else if (style == SOAP_LITERAL && enc && enc->details.type_str) {
2127 xmlNodeSetName(xparam, BAD_CAST(enc->details.type_str));
2128 xmlSetNs(xparam, ns);
2129 } else {
2130 xmlNodeSetName(xparam, BAD_CAST("item"));
2131 }
2132
2133 j++;
2134 }
2135 } else {
2136 while (j < dims[0]) {
2137 add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, NULL, style);
2138 j++;
2139 }
2140 }
2141 } else {
2142 for (j=0; j<dims[0]; j++) {
2143 if (dimension == 1) {
2144 xmlNodePtr xparam;
2145
2146 xparam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
2147 xmlAddChild(xmlParam, xparam);
2148 if (type) {
2149 xmlNodeSetName(xparam, BAD_CAST(type->name));
2150 } else if (style == SOAP_LITERAL && enc && enc->details.type_str) {
2151 xmlNodeSetName(xparam, BAD_CAST(enc->details.type_str));
2152 xmlSetNs(xparam, ns);
2153 } else {
2154 xmlNodeSetName(xparam, BAD_CAST("item"));
2155 }
2156 } else {
2157 add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, NULL, style);
2158 }
2159 }
2160 }
2161 }
2162
to_xml_array(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)2163 static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
2164 {
2165 sdlTypePtr sdl_type = type->sdl_type;
2166 sdlTypePtr element_type = NULL;
2167 smart_str array_type = {0}, array_size = {0};
2168 int i;
2169 xmlNodePtr xmlParam;
2170 encodePtr enc = NULL;
2171 int dimension = 1;
2172 int* dims;
2173 int soap_version;
2174 zval array_copy;
2175
2176 ZVAL_UNDEF(&array_copy);
2177 soap_version = SOAP_GLOBAL(soap_version);
2178
2179 xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
2180 xmlAddChild(parent, xmlParam);
2181
2182 if (!data || Z_TYPE_P(data) == IS_NULL) {
2183 if (style == SOAP_ENCODED) {
2184 set_xsi_nil(xmlParam);
2185 if (SOAP_GLOBAL(features) & SOAP_USE_XSI_ARRAY_TYPE) {
2186 set_ns_and_type_ex(xmlParam, (soap_version == SOAP_1_1) ? SOAP_1_1_ENC_NAMESPACE : SOAP_1_2_ENC_NAMESPACE, "Array");
2187 } else {
2188 set_ns_and_type(xmlParam, type);
2189 }
2190 }
2191 return xmlParam;
2192 }
2193
2194 if (Z_TYPE_P(data) == IS_OBJECT && instanceof_function(Z_OBJCE_P(data), zend_ce_traversable)) {
2195 zend_object_iterator *iter;
2196 zend_class_entry *ce = Z_OBJCE_P(data);
2197 zval *val;
2198
2199 array_init(&array_copy);
2200
2201 iter = ce->get_iterator(ce, data, 0);
2202
2203 if (EG(exception)) {
2204 goto iterator_done;
2205 }
2206
2207 if (iter->funcs->rewind) {
2208 iter->funcs->rewind(iter);
2209 if (EG(exception)) {
2210 goto iterator_done;
2211 }
2212 }
2213
2214 while (iter->funcs->valid(iter) == SUCCESS) {
2215 if (EG(exception)) {
2216 goto iterator_done;
2217 }
2218
2219 val = iter->funcs->get_current_data(iter);
2220 if (EG(exception)) {
2221 goto iterator_done;
2222 }
2223 if (iter->funcs->get_current_key) {
2224 zval key;
2225 iter->funcs->get_current_key(iter, &key);
2226 if (EG(exception)) {
2227 goto iterator_done;
2228 }
2229 array_set_zval_key(Z_ARRVAL(array_copy), &key, val);
2230 zval_ptr_dtor(val);
2231 zval_ptr_dtor(&key);
2232 } else {
2233 add_next_index_zval(&array_copy, val);
2234 }
2235 Z_TRY_ADDREF_P(val);
2236
2237 iter->funcs->move_forward(iter);
2238 if (EG(exception)) {
2239 goto iterator_done;
2240 }
2241 }
2242 iterator_done:
2243 OBJ_RELEASE(&iter->std);
2244 if (EG(exception)) {
2245 zval_ptr_dtor(&array_copy);
2246 ZVAL_UNDEF(&array_copy);
2247 } else {
2248 data = &array_copy;
2249 }
2250 }
2251
2252 if (Z_TYPE_P(data) == IS_ARRAY) {
2253 sdlAttributePtr arrayType;
2254 sdlExtraAttributePtr ext;
2255 sdlTypePtr elementType;
2256
2257 i = zend_hash_num_elements(Z_ARRVAL_P(data));
2258
2259 if (sdl_type &&
2260 sdl_type->attributes &&
2261 (arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType",
2262 sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType")-1)) != NULL &&
2263 arrayType->extraAttributes &&
2264 (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType")-1)) != NULL) {
2265
2266 char *value, *end;
2267 zval *el;
2268
2269 value = estrdup(ext->val);
2270 end = strrchr(value,'[');
2271 if (end) {
2272 *end = '\0';
2273 end++;
2274 dimension = calc_dimension(end);
2275 }
2276 if (ext->ns != NULL) {
2277 enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, value);
2278 get_type_str(xmlParam, ext->ns, value, &array_type);
2279 } else {
2280 smart_str_appends(&array_type, value);
2281 }
2282
2283 dims = safe_emalloc(sizeof(int), dimension, 0);
2284 dims[0] = i;
2285 el = data;
2286 for (i = 1; i < dimension; i++) {
2287 if (el != NULL && Z_TYPE_P(el) == IS_ARRAY &&
2288 zend_hash_num_elements(Z_ARRVAL_P(el)) > 0) {
2289 ZEND_HASH_FOREACH_VAL_IND(Z_ARRVAL_P(el), el) {
2290 break;
2291 } ZEND_HASH_FOREACH_END();
2292 ZVAL_DEREF(el);
2293 if (Z_TYPE_P(el) == IS_ARRAY) {
2294 dims[i] = zend_hash_num_elements(Z_ARRVAL_P(el));
2295 } else {
2296 dims[i] = 0;
2297 }
2298 }
2299 }
2300
2301 smart_str_append_long(&array_size, dims[0]);
2302 for (i=1; i<dimension; i++) {
2303 smart_str_appendc(&array_size, ',');
2304 smart_str_append_long(&array_size, dims[i]);
2305 }
2306
2307 efree(value);
2308
2309 } else if (sdl_type &&
2310 sdl_type->attributes &&
2311 (arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType",
2312 sizeof(SOAP_1_2_ENC_NAMESPACE":itemType")-1)) != NULL &&
2313 arrayType->extraAttributes &&
2314 (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":itemType")-1)) != NULL) {
2315 if (ext->ns != NULL) {
2316 enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, ext->val);
2317 get_type_str(xmlParam, ext->ns, ext->val, &array_type);
2318 } else {
2319 smart_str_appends(&array_type, ext->val);
2320 }
2321 if ((arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
2322 sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL &&
2323 arrayType->extraAttributes &&
2324 (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize")-1)) != NULL) {
2325 dimension = calc_dimension_12(ext->val);
2326 dims = get_position_12(dimension, ext->val);
2327 if (dims[0] == 0) {dims[0] = i;}
2328
2329 smart_str_append_long(&array_size, dims[0]);
2330 for (i=1; i<dimension; i++) {
2331 smart_str_appendc(&array_size, ',');
2332 smart_str_append_long(&array_size, dims[i]);
2333 }
2334 } else {
2335 dims = emalloc(sizeof(int));
2336 *dims = 0;
2337 smart_str_append_long(&array_size, i);
2338 }
2339 } else if (sdl_type &&
2340 sdl_type->attributes &&
2341 (arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
2342 sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL &&
2343 arrayType->extraAttributes &&
2344 (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraySize")-1)) != NULL) {
2345 dimension = calc_dimension_12(ext->val);
2346 dims = get_position_12(dimension, ext->val);
2347 if (dims[0] == 0) {dims[0] = i;}
2348
2349 smart_str_append_long(&array_size, dims[0]);
2350 for (i=1; i<dimension; i++) {
2351 smart_str_appendc(&array_size, ',');
2352 smart_str_append_long(&array_size, dims[i]);
2353 }
2354
2355 if (sdl_type && sdl_type->elements &&
2356 zend_hash_num_elements(sdl_type->elements) == 1 &&
2357 (zend_hash_internal_pointer_reset(sdl_type->elements),
2358 (elementType = zend_hash_get_current_data_ptr(sdl_type->elements)) != NULL) &&
2359 elementType->encode && elementType->encode->details.type_str) {
2360 element_type = elementType;
2361 enc = elementType->encode;
2362 get_type_str(xmlParam, elementType->encode->details.ns, elementType->encode->details.type_str, &array_type);
2363 } else {
2364 enc = get_array_type(xmlParam, data, &array_type);
2365 }
2366 } else if (sdl_type && sdl_type->elements &&
2367 zend_hash_num_elements(sdl_type->elements) == 1 &&
2368 (zend_hash_internal_pointer_reset(sdl_type->elements),
2369 (elementType = zend_hash_get_current_data_ptr(sdl_type->elements)) != NULL) &&
2370 elementType->encode && elementType->encode->details.type_str) {
2371
2372 element_type = elementType;
2373 enc = elementType->encode;
2374 get_type_str(xmlParam, elementType->encode->details.ns, elementType->encode->details.type_str, &array_type);
2375
2376 smart_str_append_long(&array_size, i);
2377
2378 dims = safe_emalloc(sizeof(int), dimension, 0);
2379 dims[0] = i;
2380 } else {
2381
2382 enc = get_array_type(xmlParam, data, &array_type);
2383 smart_str_append_long(&array_size, i);
2384 dims = safe_emalloc(sizeof(int), dimension, 0);
2385 dims[0] = i;
2386 }
2387
2388 if (style == SOAP_ENCODED) {
2389 if (soap_version == SOAP_1_1) {
2390 smart_str_0(&array_type);
2391 if (strcmp(ZSTR_VAL(array_type.s),"xsd:anyType") == 0) {
2392 smart_str_free(&array_type);
2393 smart_str_appendl(&array_type,"xsd:ur-type",sizeof("xsd:ur-type")-1);
2394 }
2395 smart_str_appendc(&array_type, '[');
2396 smart_str_append_smart_str(&array_type, &array_size);
2397 smart_str_appendc(&array_type, ']');
2398 smart_str_0(&array_type);
2399 set_ns_prop(xmlParam, SOAP_1_1_ENC_NAMESPACE, "arrayType", ZSTR_VAL(array_type.s));
2400 } else {
2401 size_t i = 0;
2402 while (i < ZSTR_LEN(array_size.s)) {
2403 if (ZSTR_VAL(array_size.s)[i] == ',') {ZSTR_VAL(array_size.s)[i] = ' ';}
2404 ++i;
2405 }
2406 smart_str_0(&array_type);
2407 smart_str_0(&array_size);
2408 set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "itemType", ZSTR_VAL(array_type.s));
2409 set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "arraySize", ZSTR_VAL(array_size.s));
2410 }
2411 }
2412 smart_str_free(&array_type);
2413 smart_str_free(&array_size);
2414
2415 add_xml_array_elements(xmlParam, element_type, enc, enc?encode_add_ns(xmlParam,enc->details.ns):NULL, dimension, dims, data, style);
2416 efree(dims);
2417 }
2418 if (style == SOAP_ENCODED) {
2419 if (SOAP_GLOBAL(features) & SOAP_USE_XSI_ARRAY_TYPE) {
2420 set_ns_and_type_ex(xmlParam, (soap_version == SOAP_1_1) ? SOAP_1_1_ENC_NAMESPACE : SOAP_1_2_ENC_NAMESPACE, "Array");
2421 } else {
2422 set_ns_and_type(xmlParam, type);
2423 }
2424 }
2425
2426 zval_ptr_dtor(&array_copy);
2427
2428 return xmlParam;
2429 }
2430
to_zval_array(zval * ret,encodeTypePtr type,xmlNodePtr data)2431 static zval *to_zval_array(zval *ret, encodeTypePtr type, xmlNodePtr data)
2432 {
2433 xmlNodePtr trav;
2434 encodePtr enc = NULL;
2435 int dimension = 1;
2436 int* dims = NULL;
2437 int* pos = NULL;
2438 xmlAttrPtr attr;
2439 sdlAttributePtr arrayType;
2440 sdlExtraAttributePtr ext;
2441 sdlTypePtr elementType;
2442
2443 ZVAL_NULL(ret);
2444 FIND_XML_NULL(data, ret);
2445
2446 if (data &&
2447 (attr = get_attribute(data->properties,"arrayType")) &&
2448 attr->children && attr->children->content) {
2449 char *type, *end, *ns;
2450 xmlNsPtr nsptr;
2451
2452 parse_namespace(attr->children->content, &type, &ns);
2453 nsptr = xmlSearchNs(attr->doc, attr->parent, BAD_CAST(ns));
2454
2455 end = strrchr(type,'[');
2456 if (end) {
2457 *end = '\0';
2458 dimension = calc_dimension(end+1);
2459 dims = get_position(dimension, end+1);
2460 }
2461 if (nsptr != NULL) {
2462 enc = get_encoder(SOAP_GLOBAL(sdl), (char*)nsptr->href, type);
2463 }
2464 efree(type);
2465 if (ns) {efree(ns);}
2466
2467 } else if ((attr = get_attribute(data->properties,"itemType")) &&
2468 attr->children &&
2469 attr->children->content) {
2470 char *type, *ns;
2471 xmlNsPtr nsptr;
2472
2473 parse_namespace(attr->children->content, &type, &ns);
2474 nsptr = xmlSearchNs(attr->doc, attr->parent, BAD_CAST(ns));
2475 if (nsptr != NULL) {
2476 enc = get_encoder(SOAP_GLOBAL(sdl), (char*)nsptr->href, type);
2477 }
2478 efree(type);
2479 if (ns) {efree(ns);}
2480
2481 if ((attr = get_attribute(data->properties,"arraySize")) &&
2482 attr->children && attr->children->content) {
2483 dimension = calc_dimension_12((char*)attr->children->content);
2484 dims = get_position_12(dimension, (char*)attr->children->content);
2485 } else {
2486 dims = emalloc(sizeof(int));
2487 *dims = 0;
2488 }
2489
2490 } else if ((attr = get_attribute(data->properties,"arraySize")) &&
2491 attr->children && attr->children->content) {
2492
2493 dimension = calc_dimension_12((char*)attr->children->content);
2494 dims = get_position_12(dimension, (char*)attr->children->content);
2495
2496 } else if (type->sdl_type != NULL &&
2497 type->sdl_type->attributes != NULL &&
2498 (arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType",
2499 sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType")-1)) != NULL &&
2500 arrayType->extraAttributes &&
2501 (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType")-1)) != NULL) {
2502 char *type, *end;
2503
2504 type = estrdup(ext->val);
2505 end = strrchr(type,'[');
2506 if (end) {
2507 *end = '\0';
2508 }
2509 if (ext->ns != NULL) {
2510 enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, type);
2511 }
2512 efree(type);
2513
2514 dims = emalloc(sizeof(int));
2515 *dims = 0;
2516
2517 } else if (type->sdl_type != NULL &&
2518 type->sdl_type->attributes != NULL &&
2519 (arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType",
2520 sizeof(SOAP_1_2_ENC_NAMESPACE":itemType")-1)) != NULL &&
2521 arrayType->extraAttributes &&
2522 (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":itemType")-1)) != NULL) {
2523
2524 if (ext->ns != NULL) {
2525 enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, ext->val);
2526 }
2527
2528 if ((arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
2529 sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL &&
2530 arrayType->extraAttributes &&
2531 (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize")-1)) != NULL) {
2532 dimension = calc_dimension_12(ext->val);
2533 dims = get_position_12(dimension, ext->val);
2534 } else {
2535 dims = emalloc(sizeof(int));
2536 *dims = 0;
2537 }
2538 } else if (type->sdl_type != NULL &&
2539 type->sdl_type->attributes != NULL &&
2540 (arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
2541 sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL &&
2542 arrayType->extraAttributes &&
2543 (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize")-1)) != NULL) {
2544
2545 dimension = calc_dimension_12(ext->val);
2546 dims = get_position_12(dimension, ext->val);
2547 if (type->sdl_type && type->sdl_type->elements &&
2548 zend_hash_num_elements(type->sdl_type->elements) == 1 &&
2549 (zend_hash_internal_pointer_reset(type->sdl_type->elements),
2550 (elementType = zend_hash_get_current_data_ptr(type->sdl_type->elements)) != NULL) &&
2551 elementType->encode) {
2552 enc = elementType->encode;
2553 }
2554 } else if (type->sdl_type && type->sdl_type->elements &&
2555 zend_hash_num_elements(type->sdl_type->elements) == 1 &&
2556 (zend_hash_internal_pointer_reset(type->sdl_type->elements),
2557 (elementType = zend_hash_get_current_data_ptr(type->sdl_type->elements)) != NULL) &&
2558 elementType->encode) {
2559 enc = elementType->encode;
2560 }
2561 if (dims == NULL) {
2562 dimension = 1;
2563 dims = emalloc(sizeof(int));
2564 *dims = 0;
2565 }
2566 pos = safe_emalloc(sizeof(int), dimension, 0);
2567 memset(pos,0,sizeof(int)*dimension);
2568 if (data &&
2569 (attr = get_attribute(data->properties,"offset")) &&
2570 attr->children && attr->children->content) {
2571 char* tmp = strrchr((char*)attr->children->content,'[');
2572
2573 if (tmp == NULL) {
2574 tmp = (char*)attr->children->content;
2575 }
2576 get_position_ex(dimension, tmp, &pos);
2577 }
2578
2579 array_init(ret);
2580 trav = data->children;
2581 while (trav) {
2582 if (trav->type == XML_ELEMENT_NODE) {
2583 int i;
2584 zval tmpVal, *ar;
2585 xmlAttrPtr position = get_attribute(trav->properties,"position");
2586
2587 ZVAL_NULL(&tmpVal);
2588 master_to_zval(&tmpVal, enc, trav);
2589 if (position != NULL && position->children && position->children->content) {
2590 char* tmp = strrchr((char*)position->children->content, '[');
2591 if (tmp == NULL) {
2592 tmp = (char*)position->children->content;
2593 }
2594 get_position_ex(dimension, tmp, &pos);
2595 }
2596
2597 /* Get/Create intermediate arrays for multidimensional arrays */
2598 i = 0;
2599 ar = ret;
2600 while (i < dimension-1) {
2601 zval* ar2;
2602 if ((ar2 = zend_hash_index_find(Z_ARRVAL_P(ar), pos[i])) != NULL) {
2603 ar = ar2;
2604 } else {
2605 zval tmpAr;
2606 array_init(&tmpAr);
2607 ar = zend_hash_index_update(Z_ARRVAL_P(ar), pos[i], &tmpAr);
2608 }
2609 i++;
2610 }
2611 zend_hash_index_update(Z_ARRVAL_P(ar), pos[i], &tmpVal);
2612
2613 /* Increment position */
2614 i = dimension;
2615 while (i > 0) {
2616 i--;
2617 pos[i]++;
2618 if (pos[i] >= dims[i]) {
2619 if (i > 0) {
2620 pos[i] = 0;
2621 } else {
2622 /* TODO: Array index overflow */
2623 }
2624 } else {
2625 break;
2626 }
2627 }
2628 }
2629 trav = trav->next;
2630 }
2631 efree(dims);
2632 efree(pos);
2633 return ret;
2634 }
2635
2636 /* Map encode/decode */
to_xml_map(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)2637 static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
2638 {
2639 zval *temp_data;
2640 zend_string *key_val;
2641 zend_ulong int_val;
2642 xmlNodePtr xmlParam;
2643 xmlNodePtr xparam, item;
2644 xmlNodePtr key;
2645
2646 xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
2647 xmlAddChild(parent, xmlParam);
2648 FIND_ZVAL_NULL(data, xmlParam, style);
2649
2650 if (Z_TYPE_P(data) == IS_ARRAY) {
2651 ZEND_HASH_FOREACH_KEY_VAL_IND(Z_ARRVAL_P(data), int_val, key_val, temp_data) {
2652 item = xmlNewNode(NULL, BAD_CAST("item"));
2653 xmlAddChild(xmlParam, item);
2654 key = xmlNewNode(NULL, BAD_CAST("key"));
2655 xmlAddChild(item,key);
2656 if (key_val) {
2657 if (style == SOAP_ENCODED) {
2658 set_xsi_type(key, "xsd:string");
2659 }
2660 xmlNodeSetContent(key, BAD_CAST(ZSTR_VAL(key_val)));
2661 } else {
2662 smart_str tmp = {0};
2663 smart_str_append_long(&tmp, int_val);
2664 smart_str_0(&tmp);
2665
2666 if (style == SOAP_ENCODED) {
2667 set_xsi_type(key, "xsd:int");
2668 }
2669 xmlNodeSetContentLen(key, BAD_CAST(ZSTR_VAL(tmp.s)), ZSTR_LEN(tmp.s));
2670
2671 smart_str_free(&tmp);
2672 }
2673
2674 ZVAL_DEREF(temp_data);
2675 xparam = master_to_xml(get_conversion(Z_TYPE_P(temp_data)), temp_data, style, item);
2676 xmlNodeSetName(xparam, BAD_CAST("value"));
2677 } ZEND_HASH_FOREACH_END();
2678 }
2679 if (style == SOAP_ENCODED) {
2680 set_ns_and_type(xmlParam, type);
2681 }
2682
2683 return xmlParam;
2684 }
2685
to_zval_map(zval * ret,encodeTypePtr type,xmlNodePtr data)2686 static zval *to_zval_map(zval *ret, encodeTypePtr type, xmlNodePtr data)
2687 {
2688 zval key, value;
2689 xmlNodePtr trav, item, xmlKey, xmlValue;
2690
2691 ZVAL_NULL(ret);
2692 FIND_XML_NULL(data, ret);
2693
2694 if (data && data->children) {
2695 array_init(ret);
2696 trav = data->children;
2697
2698 trav = data->children;
2699 FOREACHNODE(trav, "item", item) {
2700 xmlKey = get_node(item->children, "key");
2701 if (!xmlKey) {
2702 soap_error0(E_ERROR, "Encoding: Can't decode apache map, missing key");
2703 }
2704
2705 xmlValue = get_node(item->children, "value");
2706 if (!xmlKey) {
2707 soap_error0(E_ERROR, "Encoding: Can't decode apache map, missing value");
2708 }
2709
2710 ZVAL_NULL(&key);
2711 master_to_zval(&key, NULL, xmlKey);
2712 ZVAL_NULL(&value);
2713 master_to_zval(&value, NULL, xmlValue);
2714
2715 if (Z_TYPE(key) == IS_STRING) {
2716 zend_symtable_update(Z_ARRVAL_P(ret), Z_STR(key), &value);
2717 } else if (Z_TYPE(key) == IS_LONG) {
2718 zend_hash_index_update(Z_ARRVAL_P(ret), Z_LVAL(key), &value);
2719 } else {
2720 soap_error0(E_ERROR, "Encoding: Can't decode apache map, only Strings or Longs are allowed as keys");
2721 }
2722 zval_ptr_dtor(&key);
2723 }
2724 ENDFOREACH(trav);
2725 } else {
2726 ZVAL_NULL(ret);
2727 }
2728 return ret;
2729 }
2730
2731 /* Unknown encode/decode */
guess_xml_convert(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)2732 static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
2733 {
2734 encodePtr enc;
2735 xmlNodePtr ret;
2736
2737 if (data) {
2738 enc = get_conversion(Z_TYPE_P(data));
2739 } else {
2740 enc = get_conversion(IS_NULL);
2741 }
2742 ret = master_to_xml_int(enc, data, style, parent, 0);
2743 /*
2744 if (style == SOAP_LITERAL && SOAP_GLOBAL(sdl)) {
2745 set_ns_and_type(ret, &enc->details);
2746 }
2747 */
2748 return ret;
2749 }
2750
guess_zval_convert(zval * ret,encodeTypePtr type,xmlNodePtr data)2751 static zval *guess_zval_convert(zval *ret, encodeTypePtr type, xmlNodePtr data)
2752 {
2753 encodePtr enc = NULL;
2754 xmlAttrPtr tmpattr;
2755 xmlChar *type_name = NULL;
2756
2757 data = check_and_resolve_href(data);
2758
2759 if (data == NULL) {
2760 enc = get_conversion(IS_NULL);
2761 } else if (data->properties && get_attribute_ex(data->properties, "nil", XSI_NAMESPACE)) {
2762 enc = get_conversion(IS_NULL);
2763 } else {
2764 tmpattr = get_attribute_ex(data->properties,"type", XSI_NAMESPACE);
2765 if (tmpattr != NULL) {
2766 type_name = tmpattr->children->content;
2767 enc = get_encoder_from_prefix(SOAP_GLOBAL(sdl), data, tmpattr->children->content);
2768 if (enc && type == &enc->details) {
2769 enc = NULL;
2770 }
2771 if (enc != NULL) {
2772 encodePtr tmp = enc;
2773 while (tmp &&
2774 tmp->details.sdl_type != NULL &&
2775 tmp->details.sdl_type->kind != XSD_TYPEKIND_COMPLEX) {
2776 if (enc == tmp->details.sdl_type->encode ||
2777 tmp == tmp->details.sdl_type->encode) {
2778 enc = NULL;
2779 break;
2780 }
2781 tmp = tmp->details.sdl_type->encode;
2782 }
2783 }
2784 }
2785
2786 if (enc == NULL) {
2787 /* Didn't have a type, totally guess here */
2788 /* Logic: has children = IS_OBJECT else IS_STRING */
2789 xmlNodePtr trav;
2790
2791 if (get_attribute(data->properties, "arrayType") ||
2792 get_attribute(data->properties, "itemType") ||
2793 get_attribute(data->properties, "arraySize")) {
2794 enc = get_conversion(SOAP_ENC_ARRAY);
2795 } else {
2796 enc = get_conversion(XSD_STRING);
2797 trav = data->children;
2798 while (trav != NULL) {
2799 if (trav->type == XML_ELEMENT_NODE) {
2800 enc = get_conversion(SOAP_ENC_OBJECT);
2801 break;
2802 }
2803 trav = trav->next;
2804 }
2805 }
2806 }
2807 }
2808 master_to_zval_int(ret, enc, data);
2809 if (SOAP_GLOBAL(sdl) && type_name && enc->details.sdl_type) {
2810 zval soapvar;
2811 char *ns, *cptype;
2812 xmlNsPtr nsptr;
2813
2814 object_init_ex(&soapvar, soap_var_class_entry);
2815 add_property_long(&soapvar, "enc_type", enc->details.type);
2816 Z_TRY_DELREF_P(ret);
2817 add_property_zval(&soapvar, "enc_value", ret);
2818 parse_namespace(type_name, &cptype, &ns);
2819 nsptr = xmlSearchNs(data->doc, data, BAD_CAST(ns));
2820 add_property_string(&soapvar, "enc_stype", cptype);
2821 if (nsptr) {
2822 add_property_string(&soapvar, "enc_ns", (char*)nsptr->href);
2823 }
2824 efree(cptype);
2825 if (ns) {efree(ns);}
2826 ZVAL_COPY_VALUE(ret, &soapvar);
2827 }
2828 return ret;
2829 }
2830
2831 /* Time encode/decode */
to_xml_datetime_ex(encodeTypePtr type,zval * data,char * format,int style,xmlNodePtr parent)2832 static xmlNodePtr to_xml_datetime_ex(encodeTypePtr type, zval *data, char *format, int style, xmlNodePtr parent)
2833 {
2834 /* logic hacked from ext/standard/datetime.c */
2835 struct tm *ta, tmbuf;
2836 time_t timestamp;
2837 int max_reallocs = 5;
2838 size_t buf_len=64, real_len;
2839 char *buf;
2840 char tzbuf[8];
2841
2842 xmlNodePtr xmlParam;
2843
2844 xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
2845 xmlAddChild(parent, xmlParam);
2846 FIND_ZVAL_NULL(data, xmlParam, style);
2847
2848 if (Z_TYPE_P(data) == IS_LONG) {
2849 timestamp = Z_LVAL_P(data);
2850 ta = php_localtime_r(×tamp, &tmbuf);
2851 /*ta = php_gmtime_r(×tamp, &tmbuf);*/
2852 if (!ta) {
2853 soap_error1(E_ERROR, "Encoding: Invalid timestamp " ZEND_LONG_FMT, Z_LVAL_P(data));
2854 }
2855
2856 buf = (char *) emalloc(buf_len);
2857 while ((real_len = strftime(buf, buf_len, format, ta)) == buf_len || real_len == 0) {
2858 buf_len *= 2;
2859 buf = (char *) erealloc(buf, buf_len);
2860 if (!--max_reallocs) break;
2861 }
2862
2863 /* Time zone support */
2864 #ifdef HAVE_STRUCT_TM_TM_GMTOFF
2865 snprintf(tzbuf, sizeof(tzbuf), "%c%02ld:%02ld",
2866 (ta->tm_gmtoff < 0) ? '-' : '+',
2867 labs(ta->tm_gmtoff / 3600), labs( (ta->tm_gmtoff % 3600) / 60 ));
2868 #else
2869 # if defined(__CYGWIN__) || (defined(PHP_WIN32) && defined(_MSC_VER) && _MSC_VER >= 1900)
2870 snprintf(tzbuf, sizeof(tzbuf), "%c%02d:%02d", ((ta->tm_isdst ? _timezone - 3600:_timezone)>0)?'-':'+', abs((ta->tm_isdst ? _timezone - 3600 : _timezone) / 3600), abs(((ta->tm_isdst ? _timezone - 3600 : _timezone) % 3600) / 60));
2871 # else
2872 snprintf(tzbuf, sizeof(tzbuf), "%c%02d:%02d", ((ta->tm_isdst ? timezone - 3600:timezone)>0)?'-':'+', abs((ta->tm_isdst ? timezone - 3600 : timezone) / 3600), abs(((ta->tm_isdst ? timezone - 3600 : timezone) % 3600) / 60));
2873 # endif
2874 #endif
2875 if (strcmp(tzbuf,"+00:00") == 0) {
2876 strcpy(tzbuf,"Z");
2877 real_len++;
2878 } else {
2879 real_len += 6;
2880 }
2881 if (real_len >= buf_len) {
2882 buf = (char *) erealloc(buf, real_len+1);
2883 }
2884 strcat(buf, tzbuf);
2885
2886 xmlNodeSetContent(xmlParam, BAD_CAST(buf));
2887 efree(buf);
2888 } else if (Z_TYPE_P(data) == IS_STRING) {
2889 xmlNodeSetContentLen(xmlParam, BAD_CAST(Z_STRVAL_P(data)), Z_STRLEN_P(data));
2890 }
2891
2892 if (style == SOAP_ENCODED) {
2893 set_ns_and_type(xmlParam, type);
2894 }
2895 return xmlParam;
2896 }
2897
to_xml_duration(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)2898 static xmlNodePtr to_xml_duration(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
2899 {
2900 /* TODO: '-'?P([0-9]+Y)?([0-9]+M)?([0-9]+D)?T([0-9]+H)?([0-9]+M)?([0-9]+S)? */
2901 return to_xml_string(type, data, style, parent);
2902 }
2903
to_xml_datetime(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)2904 static xmlNodePtr to_xml_datetime(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
2905 {
2906 return to_xml_datetime_ex(type, data, "%Y-%m-%dT%H:%M:%S", style, parent);
2907 }
2908
to_xml_time(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)2909 static xmlNodePtr to_xml_time(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
2910 {
2911 /* TODO: microsecconds */
2912 return to_xml_datetime_ex(type, data, "%H:%M:%S", style, parent);
2913 }
2914
to_xml_date(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)2915 static xmlNodePtr to_xml_date(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
2916 {
2917 return to_xml_datetime_ex(type, data, "%Y-%m-%d", style, parent);
2918 }
2919
to_xml_gyearmonth(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)2920 static xmlNodePtr to_xml_gyearmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
2921 {
2922 return to_xml_datetime_ex(type, data, "%Y-%m", style, parent);
2923 }
2924
to_xml_gyear(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)2925 static xmlNodePtr to_xml_gyear(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
2926 {
2927 return to_xml_datetime_ex(type, data, "%Y", style, parent);
2928 }
2929
to_xml_gmonthday(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)2930 static xmlNodePtr to_xml_gmonthday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
2931 {
2932 return to_xml_datetime_ex(type, data, "--%m-%d", style, parent);
2933 }
2934
to_xml_gday(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)2935 static xmlNodePtr to_xml_gday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
2936 {
2937 return to_xml_datetime_ex(type, data, "---%d", style, parent);
2938 }
2939
to_xml_gmonth(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)2940 static xmlNodePtr to_xml_gmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
2941 {
2942 return to_xml_datetime_ex(type, data, "--%m--", style, parent);
2943 }
2944
to_zval_list(zval * ret,encodeTypePtr enc,xmlNodePtr data)2945 static zval* to_zval_list(zval *ret, encodeTypePtr enc, xmlNodePtr data) {
2946 /*FIXME*/
2947 return to_zval_stringc(ret, enc, data);
2948 }
2949
to_xml_list(encodeTypePtr enc,zval * data,int style,xmlNodePtr parent)2950 static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent) {
2951 xmlNodePtr ret;
2952 encodePtr list_enc = NULL;
2953
2954 if (enc->sdl_type && enc->sdl_type->kind == XSD_TYPEKIND_LIST && enc->sdl_type->elements) {
2955 sdlTypePtr type;
2956
2957 ZEND_HASH_FOREACH_PTR(enc->sdl_type->elements, type) {
2958 list_enc = type->encode;
2959 break;
2960 } ZEND_HASH_FOREACH_END();
2961 }
2962
2963 ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
2964 xmlAddChild(parent, ret);
2965 FIND_ZVAL_NULL(data, ret, style);
2966 if (Z_TYPE_P(data) == IS_ARRAY) {
2967 zval *tmp;
2968 smart_str list = {0};
2969 HashTable *ht = Z_ARRVAL_P(data);
2970
2971 ZEND_HASH_FOREACH_VAL(ht, tmp) {
2972 xmlNodePtr dummy = master_to_xml(list_enc, tmp, SOAP_LITERAL, ret);
2973 if (dummy && dummy->children && dummy->children->content) {
2974 if (list.s && ZSTR_LEN(list.s) != 0) {
2975 smart_str_appendc(&list, ' ');
2976 }
2977 smart_str_appends(&list, (char*)dummy->children->content);
2978 } else {
2979 soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
2980 }
2981 xmlUnlinkNode(dummy);
2982 xmlFreeNode(dummy);
2983 } ZEND_HASH_FOREACH_END();
2984 smart_str_0(&list);
2985 if (list.s) {
2986 xmlNodeSetContentLen(ret, BAD_CAST(ZSTR_VAL(list.s)), ZSTR_LEN(list.s));
2987 } else {
2988 xmlNodeSetContentLen(ret, BAD_CAST(""), 0);
2989 }
2990 smart_str_free(&list);
2991 } else {
2992 zval tmp;
2993 char *str, *start, *next;
2994 smart_str list = {0};
2995
2996 if (Z_TYPE_P(data) != IS_STRING) {
2997 ZVAL_STR(&tmp, zval_get_string_func(data));
2998 data = &tmp;
2999 }
3000 str = estrndup(Z_STRVAL_P(data), Z_STRLEN_P(data));
3001 whiteSpace_collapse(BAD_CAST(str));
3002 start = str;
3003 while (start != NULL && *start != '\0') {
3004 xmlNodePtr dummy;
3005 zval dummy_zval;
3006
3007 next = strchr(start,' ');
3008 if (next != NULL) {
3009 *next = '\0';
3010 next++;
3011 }
3012 ZVAL_STRING(&dummy_zval, start);
3013 dummy = master_to_xml(list_enc, &dummy_zval, SOAP_LITERAL, ret);
3014 zval_ptr_dtor(&dummy_zval);
3015 if (dummy && dummy->children && dummy->children->content) {
3016 if (list.s && ZSTR_LEN(list.s) != 0) {
3017 smart_str_appendc(&list, ' ');
3018 }
3019 smart_str_appends(&list, (char*)dummy->children->content);
3020 } else {
3021 soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
3022 }
3023 xmlUnlinkNode(dummy);
3024 xmlFreeNode(dummy);
3025
3026 start = next;
3027 }
3028 smart_str_0(&list);
3029 if (list.s) {
3030 xmlNodeSetContentLen(ret, BAD_CAST(ZSTR_VAL(list.s)), ZSTR_LEN(list.s));
3031 } else {
3032 xmlNodeSetContentLen(ret, BAD_CAST(""), 0);
3033 }
3034 smart_str_free(&list);
3035 efree(str);
3036 if (data == &tmp) {
3037 zval_ptr_dtor_str(&tmp);
3038 }
3039 }
3040 return ret;
3041 }
3042
to_xml_list1(encodeTypePtr enc,zval * data,int style,xmlNodePtr parent)3043 static xmlNodePtr to_xml_list1(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent) {
3044 /*FIXME: minLength=1 */
3045 return to_xml_list(enc,data,style, parent);
3046 }
3047
to_zval_union(zval * ret,encodeTypePtr enc,xmlNodePtr data)3048 static zval* to_zval_union(zval *ret, encodeTypePtr enc, xmlNodePtr data) {
3049 /*FIXME*/
3050 return to_zval_list(ret, enc, data);
3051 }
3052
to_xml_union(encodeTypePtr enc,zval * data,int style,xmlNodePtr parent)3053 static xmlNodePtr to_xml_union(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent) {
3054 /*FIXME*/
3055 return to_xml_list(enc,data,style, parent);
3056 }
3057
to_zval_any(zval * ret,encodeTypePtr type,xmlNodePtr data)3058 static zval *to_zval_any(zval *ret, encodeTypePtr type, xmlNodePtr data)
3059 {
3060 xmlBufferPtr buf;
3061
3062 if (SOAP_GLOBAL(sdl) && SOAP_GLOBAL(sdl)->elements && data->name) {
3063 smart_str nscat = {0};
3064 sdlTypePtr sdl_type;
3065
3066 if (data->ns && data->ns->href) {
3067 smart_str_appends(&nscat, (char*)data->ns->href);
3068 smart_str_appendc(&nscat, ':');
3069 }
3070 smart_str_appends(&nscat, (char*)data->name);
3071 smart_str_0(&nscat);
3072
3073 if ((sdl_type = zend_hash_find_ptr(SOAP_GLOBAL(sdl)->elements, nscat.s)) != NULL &&
3074 sdl_type->encode) {
3075 smart_str_free(&nscat);
3076 return master_to_zval_int(ret, sdl_type->encode, data);
3077 }
3078 smart_str_free(&nscat);
3079 }
3080
3081 buf = xmlBufferCreate();
3082 xmlNodeDump(buf, NULL, data, 0, 0);
3083 ZVAL_STRING(ret, (char*)xmlBufferContent(buf));
3084 xmlBufferFree(buf);
3085 return ret;
3086 }
3087
to_xml_any(encodeTypePtr type,zval * data,int style,xmlNodePtr parent)3088 static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
3089 {
3090 xmlNodePtr ret = NULL;
3091
3092 if (Z_TYPE_P(data) == IS_ARRAY) {
3093 zval *el;
3094 encodePtr enc = get_conversion(XSD_ANYXML);
3095 zend_string *name;
3096
3097 ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(data), name, el) {
3098 ret = master_to_xml(enc, el, style, parent);
3099 if (ret &&
3100 ret->name != xmlStringTextNoenc) {
3101 xmlNodeSetName(ret, BAD_CAST(ZSTR_VAL(name)));
3102 }
3103 } ZEND_HASH_FOREACH_END();
3104 return ret;
3105 }
3106 if (Z_TYPE_P(data) == IS_STRING) {
3107 ret = xmlNewTextLen(BAD_CAST(Z_STRVAL_P(data)), Z_STRLEN_P(data));
3108 } else {
3109 zend_string *tmp = zval_get_string_func(data);
3110 ret = xmlNewTextLen(BAD_CAST(ZSTR_VAL(tmp)), ZSTR_LEN(tmp));
3111 zend_string_release_ex(tmp, 0);
3112 }
3113
3114 ret->name = xmlStringTextNoenc;
3115 ret->parent = parent;
3116 ret->doc = parent->doc;
3117 ret->prev = parent->last;
3118 ret->next = NULL;
3119 if (parent->last) {
3120 parent->last->next = ret;
3121 } else {
3122 parent->children = ret;
3123 }
3124 parent->last = ret;
3125
3126 return ret;
3127 }
3128
sdl_guess_convert_zval(zval * ret,encodeTypePtr enc,xmlNodePtr data)3129 zval *sdl_guess_convert_zval(zval *ret, encodeTypePtr enc, xmlNodePtr data)
3130 {
3131 sdlTypePtr type;
3132
3133 type = enc->sdl_type;
3134 if (type == NULL) {
3135 return guess_zval_convert(ret, enc, data);
3136 }
3137 /*FIXME: restriction support
3138 if (type && type->restrictions &&
3139 data && data->children && data->children->content) {
3140 if (type->restrictions->whiteSpace && type->restrictions->whiteSpace->value) {
3141 if (strcmp(type->restrictions->whiteSpace->value,"replace") == 0) {
3142 whiteSpace_replace(data->children->content);
3143 } else if (strcmp(type->restrictions->whiteSpace->value,"collapse") == 0) {
3144 whiteSpace_collapse(data->children->content);
3145 }
3146 }
3147 if (type->restrictions->enumeration) {
3148 if (!zend_hash_exists(type->restrictions->enumeration,data->children->content,strlen(data->children->content)+1)) {
3149 soap_error1(E_WARNING, "Encoding: Restriction: invalid enumeration value \"%s\"", data->children->content);
3150 }
3151 }
3152 if (type->restrictions->minLength &&
3153 strlen(data->children->content) < type->restrictions->minLength->value) {
3154 soap_error0(E_WARNING, "Encoding: Restriction: length less than 'minLength'");
3155 }
3156 if (type->restrictions->maxLength &&
3157 strlen(data->children->content) > type->restrictions->maxLength->value) {
3158 soap_error0(E_WARNING, "Encoding: Restriction: length greater than 'maxLength'");
3159 }
3160 if (type->restrictions->length &&
3161 strlen(data->children->content) != type->restrictions->length->value) {
3162 soap_error0(E_WARNING, "Encoding: Restriction: length is not equal to 'length'");
3163 }
3164 }
3165 */
3166 switch (type->kind) {
3167 case XSD_TYPEKIND_SIMPLE:
3168 if (type->encode && enc != &type->encode->details) {
3169 return master_to_zval_int(ret, type->encode, data);
3170 } else {
3171 return guess_zval_convert(ret, enc, data);
3172 }
3173 break;
3174 case XSD_TYPEKIND_LIST:
3175 return to_zval_list(ret, enc, data);
3176 case XSD_TYPEKIND_UNION:
3177 return to_zval_union(ret, enc, data);
3178 case XSD_TYPEKIND_COMPLEX:
3179 case XSD_TYPEKIND_RESTRICTION:
3180 case XSD_TYPEKIND_EXTENSION:
3181 if (type->encode &&
3182 (type->encode->details.type == IS_ARRAY ||
3183 type->encode->details.type == SOAP_ENC_ARRAY)) {
3184 return to_zval_array(ret, enc, data);
3185 }
3186 return to_zval_object(ret, enc, data);
3187 default:
3188 soap_error0(E_ERROR, "Encoding: Internal Error");
3189 return guess_zval_convert(ret, enc, data);
3190 }
3191 }
3192
sdl_guess_convert_xml(encodeTypePtr enc,zval * data,int style,xmlNodePtr parent)3193 xmlNodePtr sdl_guess_convert_xml(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent)
3194 {
3195 sdlTypePtr type;
3196 xmlNodePtr ret = NULL;
3197
3198 type = enc->sdl_type;
3199
3200 if (type == NULL) {
3201 ret = guess_xml_convert(enc, data, style, parent);
3202 if (style == SOAP_ENCODED) {
3203 set_ns_and_type(ret, enc);
3204 }
3205 return ret;
3206 }
3207 /*FIXME: restriction support
3208 if (type) {
3209 if (type->restrictions && Z_TYPE_P(data) == IS_STRING) {
3210 if (type->restrictions->enumeration) {
3211 if (!zend_hash_exists(type->restrictions->enumeration,Z_STRVAL_P(data),Z_STRLEN_P(data)+1)) {
3212 soap_error1(E_WARNING, "Encoding: Restriction: invalid enumeration value \"%s\".", Z_STRVAL_P(data));
3213 }
3214 }
3215 if (type->restrictions->minLength &&
3216 Z_STRLEN_P(data) < type->restrictions->minLength->value) {
3217 soap_error0(E_WARNING, "Encoding: Restriction: length less than 'minLength'");
3218 }
3219 if (type->restrictions->maxLength &&
3220 Z_STRLEN_P(data) > type->restrictions->maxLength->value) {
3221 soap_error0(E_WARNING, "Encoding: Restriction: length greater than 'maxLength'");
3222 }
3223 if (type->restrictions->length &&
3224 Z_STRLEN_P(data) != type->restrictions->length->value) {
3225 soap_error0(E_WARNING, "Encoding: Restriction: length is not equal to 'length'");
3226 }
3227 }
3228 }
3229 */
3230 switch(type->kind) {
3231 case XSD_TYPEKIND_SIMPLE:
3232 if (type->encode && enc != &type->encode->details) {
3233 ret = master_to_xml(type->encode, data, style, parent);
3234 } else {
3235 ret = guess_xml_convert(enc, data, style, parent);
3236 }
3237 break;
3238 case XSD_TYPEKIND_LIST:
3239 ret = to_xml_list(enc, data, style, parent);
3240 break;
3241 case XSD_TYPEKIND_UNION:
3242 ret = to_xml_union(enc, data, style, parent);
3243 break;
3244 case XSD_TYPEKIND_COMPLEX:
3245 case XSD_TYPEKIND_RESTRICTION:
3246 case XSD_TYPEKIND_EXTENSION:
3247 if (type->encode &&
3248 (type->encode->details.type == IS_ARRAY ||
3249 type->encode->details.type == SOAP_ENC_ARRAY)) {
3250 return to_xml_array(enc, data, style, parent);
3251 } else {
3252 return to_xml_object(enc, data, style, parent);
3253 }
3254 break;
3255 default:
3256 soap_error0(E_ERROR, "Encoding: Internal Error");
3257 break;
3258 }
3259 if (style == SOAP_ENCODED) {
3260 set_ns_and_type(ret, enc);
3261 }
3262 return ret;
3263 }
3264
check_and_resolve_href(xmlNodePtr data)3265 static xmlNodePtr check_and_resolve_href(xmlNodePtr data)
3266 {
3267 if (data && data->properties) {
3268 xmlAttrPtr href;
3269
3270 href = data->properties;
3271 while (1) {
3272 href = get_attribute(href, "href");
3273 if (href == NULL || href->ns == NULL) {break;}
3274 href = href->next;
3275 }
3276 if (href) {
3277 /* Internal href try and find node */
3278 if (href->children->content[0] == '#') {
3279 xmlNodePtr ret = get_node_with_attribute_recursive(data->doc->children, NULL, "id", (char*)&href->children->content[1]);
3280 if (!ret) {
3281 soap_error1(E_ERROR, "Encoding: Unresolved reference '%s'", href->children->content);
3282 }
3283 return ret;
3284 } else {
3285 /* TODO: External href....? */
3286 soap_error1(E_ERROR, "Encoding: External reference '%s'", href->children->content);
3287 }
3288 }
3289 /* SOAP 1.2 enc:id enc:ref */
3290 href = get_attribute_ex(data->properties, "ref", SOAP_1_2_ENC_NAMESPACE);
3291 if (href) {
3292 xmlChar* id;
3293 xmlNodePtr ret;
3294
3295 if (href->children->content[0] == '#') {
3296 id = href->children->content+1;
3297 } else {
3298 id = href->children->content;
3299 }
3300 ret = get_node_with_attribute_recursive_ex(data->doc->children, NULL, NULL, "id", (char*)id, SOAP_1_2_ENC_NAMESPACE);
3301 if (!ret) {
3302 soap_error1(E_ERROR, "Encoding: Unresolved reference '%s'", href->children->content);
3303 } else if (ret == data) {
3304 soap_error1(E_ERROR, "Encoding: Violation of id and ref information items '%s'", href->children->content);
3305 }
3306 return ret;
3307 }
3308 }
3309 return data;
3310 }
3311
set_ns_and_type(xmlNodePtr node,encodeTypePtr type)3312 static void set_ns_and_type(xmlNodePtr node, encodeTypePtr type)
3313 {
3314 set_ns_and_type_ex(node, type->ns, type->type_str);
3315 }
3316
set_ns_and_type_ex(xmlNodePtr node,char * ns,char * type)3317 static void set_ns_and_type_ex(xmlNodePtr node, char *ns, char *type)
3318 {
3319 smart_str nstype = {0};
3320 get_type_str(node, ns, type, &nstype);
3321 set_xsi_type(node, ZSTR_VAL(nstype.s));
3322 smart_str_free(&nstype);
3323 }
3324
xmlSearchNsPrefixByHref(xmlDocPtr doc,xmlNodePtr node,const xmlChar * href)3325 static xmlNsPtr xmlSearchNsPrefixByHref(xmlDocPtr doc, xmlNodePtr node, const xmlChar * href)
3326 {
3327 xmlNsPtr cur;
3328 xmlNodePtr orig = node;
3329
3330 while (node) {
3331 if (node->type == XML_ENTITY_REF_NODE ||
3332 node->type == XML_ENTITY_NODE ||
3333 node->type == XML_ENTITY_DECL) {
3334 return NULL;
3335 }
3336 if (node->type == XML_ELEMENT_NODE) {
3337 cur = node->nsDef;
3338 while (cur != NULL) {
3339 if (cur->prefix && cur->href && xmlStrEqual(cur->href, href)) {
3340 if (xmlSearchNs(doc, node, cur->prefix) == cur) {
3341 return cur;
3342 }
3343 }
3344 cur = cur->next;
3345 }
3346 if (orig != node) {
3347 cur = node->ns;
3348 if (cur != NULL) {
3349 if (cur->prefix && cur->href && xmlStrEqual(cur->href, href)) {
3350 if (xmlSearchNs(doc, node, cur->prefix) == cur) {
3351 return cur;
3352 }
3353 }
3354 }
3355 }
3356 }
3357 node = node->parent;
3358 }
3359 return NULL;
3360 }
3361
encode_add_ns(xmlNodePtr node,const char * ns)3362 xmlNsPtr encode_add_ns(xmlNodePtr node, const char* ns)
3363 {
3364 xmlNsPtr xmlns;
3365
3366 if (ns == NULL) {
3367 return NULL;
3368 }
3369
3370 xmlns = xmlSearchNsByHref(node->doc, node, BAD_CAST(ns));
3371 if (xmlns != NULL && xmlns->prefix == NULL) {
3372 xmlns = xmlSearchNsPrefixByHref(node->doc, node, BAD_CAST(ns));
3373 }
3374 if (xmlns == NULL) {
3375 xmlChar* prefix;
3376
3377 if ((prefix = zend_hash_str_find_ptr(&SOAP_GLOBAL(defEncNs), (char*)ns, strlen(ns))) != NULL) {
3378 xmlns = xmlNewNs(node->doc->children, BAD_CAST(ns), prefix);
3379 } else {
3380 smart_str prefix = {0};
3381 int num = ++SOAP_GLOBAL(cur_uniq_ns);
3382 xmlChar *enc_ns;
3383
3384 while (1) {
3385 smart_str_appendl(&prefix, "ns", 2);
3386 smart_str_append_long(&prefix, num);
3387 smart_str_0(&prefix);
3388 if (xmlSearchNs(node->doc, node, BAD_CAST(ZSTR_VAL(prefix.s))) == NULL) {
3389 break;
3390 }
3391 smart_str_free(&prefix);
3392 prefix.s = NULL;
3393 num = ++SOAP_GLOBAL(cur_uniq_ns);
3394 }
3395
3396 enc_ns = xmlEncodeSpecialChars(node->doc, BAD_CAST(ns));
3397 xmlns = xmlNewNs(node->doc->children, enc_ns, BAD_CAST(prefix.s ? ZSTR_VAL(prefix.s) : ""));
3398 xmlFree(enc_ns);
3399 smart_str_free(&prefix);
3400 }
3401 }
3402 return xmlns;
3403 }
3404
set_ns_prop(xmlNodePtr node,char * ns,char * name,char * val)3405 static void set_ns_prop(xmlNodePtr node, char *ns, char *name, char *val)
3406 {
3407 xmlSetNsProp(node, encode_add_ns(node, ns), BAD_CAST(name), BAD_CAST(val));
3408 }
3409
set_xsi_nil(xmlNodePtr node)3410 static void set_xsi_nil(xmlNodePtr node)
3411 {
3412 set_ns_prop(node, XSI_NAMESPACE, "nil", "true");
3413 }
3414
set_xsi_type(xmlNodePtr node,char * type)3415 static void set_xsi_type(xmlNodePtr node, char *type)
3416 {
3417 set_ns_prop(node, XSI_NAMESPACE, "type", type);
3418 }
3419
encode_reset_ns()3420 void encode_reset_ns()
3421 {
3422 SOAP_GLOBAL(cur_uniq_ns) = 0;
3423 SOAP_GLOBAL(cur_uniq_ref) = 0;
3424 if (SOAP_GLOBAL(ref_map)) {
3425 zend_hash_destroy(SOAP_GLOBAL(ref_map));
3426 } else {
3427 SOAP_GLOBAL(ref_map) = emalloc(sizeof(HashTable));
3428 }
3429 zend_hash_init(SOAP_GLOBAL(ref_map), 0, NULL, NULL, 0);
3430 }
3431
encode_finish()3432 void encode_finish()
3433 {
3434 SOAP_GLOBAL(cur_uniq_ns) = 0;
3435 SOAP_GLOBAL(cur_uniq_ref) = 0;
3436 if (SOAP_GLOBAL(ref_map)) {
3437 zend_hash_destroy(SOAP_GLOBAL(ref_map));
3438 efree(SOAP_GLOBAL(ref_map));
3439 SOAP_GLOBAL(ref_map) = NULL;
3440 }
3441 }
3442
get_conversion(int encode)3443 encodePtr get_conversion(int encode)
3444 {
3445 encodePtr enc;
3446
3447 if ((enc = zend_hash_index_find_ptr(&SOAP_GLOBAL(defEncIndex), encode)) == NULL) {
3448 soap_error0(E_ERROR, "Encoding: Cannot find encoding");
3449 return NULL;
3450 } else {
3451 return enc;
3452 }
3453 }
3454
is_map(zval * array)3455 static int is_map(zval *array)
3456 {
3457 zend_ulong index;
3458 zend_string *key;
3459 zend_ulong i = 0;
3460
3461 if (HT_IS_PACKED(Z_ARRVAL_P(array)) && HT_IS_WITHOUT_HOLES(Z_ARRVAL_P(array))) {
3462 return FALSE;
3463 }
3464
3465 ZEND_HASH_FOREACH_KEY(Z_ARRVAL_P(array), index, key) {
3466 if (key || index != i) {
3467 return TRUE;
3468 }
3469 i++;
3470 } ZEND_HASH_FOREACH_END();
3471 return FALSE;
3472 }
3473
get_array_type(xmlNodePtr node,zval * array,smart_str * type)3474 static encodePtr get_array_type(xmlNodePtr node, zval *array, smart_str *type)
3475 {
3476 HashTable *ht;
3477 int i, cur_type, prev_type, different;
3478 zval *tmp;
3479 char *prev_stype = NULL, *cur_stype = NULL, *prev_ns = NULL, *cur_ns = NULL;
3480
3481 if (!array || Z_TYPE_P(array) != IS_ARRAY) {
3482 smart_str_appendl(type, "xsd:anyType", sizeof("xsd:anyType")-1);
3483 return get_conversion(XSD_ANYTYPE);
3484 }
3485
3486 i = 0;
3487 different = FALSE;
3488 cur_type = prev_type = 0;
3489 ht = Z_ARRVAL_P(array);
3490
3491 ZEND_HASH_FOREACH_VAL_IND(ht, tmp) {
3492 ZVAL_DEREF(tmp);
3493 if (Z_TYPE_P(tmp) == IS_OBJECT &&
3494 Z_OBJCE_P(tmp) == soap_var_class_entry) {
3495 zval *ztype;
3496
3497 if ((ztype = zend_hash_str_find_deref(Z_OBJPROP_P(tmp), "enc_type", sizeof("enc_type")-1)) == NULL ||
3498 Z_TYPE_P(ztype) != IS_LONG) {
3499 soap_error0(E_ERROR, "Encoding: SoapVar has no 'enc_type' property");
3500 }
3501 cur_type = Z_LVAL_P(ztype);
3502
3503 if ((ztype = zend_hash_str_find_deref(Z_OBJPROP_P(tmp), "enc_stype", sizeof("enc_stype")-1)) != NULL &&
3504 Z_TYPE_P(ztype) == IS_STRING) {
3505 cur_stype = Z_STRVAL_P(ztype);
3506 } else {
3507 cur_stype = NULL;
3508 }
3509
3510 if ((ztype = zend_hash_str_find_deref(Z_OBJPROP_P(tmp), "enc_ns", sizeof("enc_ns")-1)) != NULL &&
3511 Z_TYPE_P(ztype) == IS_STRING) {
3512 cur_ns = Z_STRVAL_P(ztype);
3513 } else {
3514 cur_ns = NULL;
3515 }
3516
3517 } else if (Z_TYPE_P(tmp) == IS_ARRAY && is_map(tmp)) {
3518 cur_type = APACHE_MAP;
3519 cur_stype = NULL;
3520 cur_ns = NULL;
3521 } else {
3522 cur_type = Z_TYPE_P(tmp);
3523 cur_stype = NULL;
3524 cur_ns = NULL;
3525 }
3526
3527 if (i > 0) {
3528 if ((cur_type != prev_type) ||
3529 (cur_stype != NULL && prev_stype != NULL && strcmp(cur_stype,prev_stype) != 0) ||
3530 (cur_stype == NULL && cur_stype != prev_stype) ||
3531 (cur_ns != NULL && prev_ns != NULL && strcmp(cur_ns,prev_ns) != 0) ||
3532 (cur_ns == NULL && cur_ns != prev_ns)) {
3533 different = TRUE;
3534 break;
3535 }
3536 }
3537
3538 prev_type = cur_type;
3539 prev_stype = cur_stype;
3540 prev_ns = cur_ns;
3541 i++;
3542 } ZEND_HASH_FOREACH_END();
3543
3544 if (different || i == 0) {
3545 smart_str_appendl(type, "xsd:anyType", sizeof("xsd:anyType")-1);
3546 return get_conversion(XSD_ANYTYPE);
3547 } else {
3548 encodePtr enc;
3549
3550 if (cur_stype != NULL) {
3551 smart_str array_type = {0};
3552
3553 if (cur_ns) {
3554 xmlNsPtr ns = encode_add_ns(node, cur_ns);
3555
3556 smart_str_appends(type, (char*)ns->prefix);
3557 smart_str_appendc(type, ':');
3558 smart_str_appends(&array_type, cur_ns);
3559 smart_str_appendc(&array_type, ':');
3560 }
3561 smart_str_appends(type, cur_stype);
3562 smart_str_0(type);
3563 smart_str_appends(&array_type, cur_stype);
3564 smart_str_0(&array_type);
3565
3566 enc = get_encoder_ex(SOAP_GLOBAL(sdl), ZSTR_VAL(array_type.s), ZSTR_LEN(array_type.s));
3567 smart_str_free(&array_type);
3568 return enc;
3569 } else {
3570 enc = get_conversion(cur_type);
3571 get_type_str(node, enc->details.ns, enc->details.type_str, type);
3572 return enc;
3573 }
3574 }
3575 return NULL;
3576 }
3577
get_type_str(xmlNodePtr node,const char * ns,const char * type,smart_str * ret)3578 static void get_type_str(xmlNodePtr node, const char* ns, const char* type, smart_str* ret)
3579 {
3580
3581 if (ns) {
3582 xmlNsPtr xmlns;
3583 if (SOAP_GLOBAL(soap_version) == SOAP_1_2 &&
3584 strcmp(ns,SOAP_1_1_ENC_NAMESPACE) == 0) {
3585 ns = SOAP_1_2_ENC_NAMESPACE;
3586 } else if (SOAP_GLOBAL(soap_version) == SOAP_1_1 &&
3587 strcmp(ns,SOAP_1_2_ENC_NAMESPACE) == 0) {
3588 ns = SOAP_1_1_ENC_NAMESPACE;
3589 }
3590 xmlns = encode_add_ns(node, ns);
3591 smart_str_appends(ret, (char*)xmlns->prefix);
3592 smart_str_appendc(ret, ':');
3593 }
3594 smart_str_appendl(ret, type, strlen(type));
3595 smart_str_0(ret);
3596 }
3597
delete_mapping(void * data)3598 static void delete_mapping(void *data)
3599 {
3600 soapMappingPtr map = (soapMappingPtr)data;
3601
3602 zval_ptr_dtor(&map->to_xml);
3603 zval_ptr_dtor(&map->to_zval);
3604 efree(map);
3605 }
3606
delete_encoder(zval * zv)3607 void delete_encoder(zval *zv)
3608 {
3609 encodePtr t = Z_PTR_P(zv);
3610 if (t->details.ns) {
3611 efree(t->details.ns);
3612 }
3613 if (t->details.type_str) {
3614 efree(t->details.type_str);
3615 }
3616 if (t->details.map) {
3617 delete_mapping(t->details.map);
3618 }
3619 efree(t);
3620 }
3621
delete_encoder_persistent(zval * zv)3622 void delete_encoder_persistent(zval *zv)
3623 {
3624 encodePtr t = Z_PTR_P(zv);
3625 if (t->details.ns) {
3626 free(t->details.ns);
3627 }
3628 if (t->details.type_str) {
3629 free(t->details.type_str);
3630 }
3631 /* we should never have mapping in persistent encoder */
3632 assert(t->details.map == NULL);
3633 free(t);
3634 }
3635