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