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