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