/ext/soap/php_encoding.c
C | 3772 lines | 3250 code | 398 blank | 124 comment | 1283 complexity | 86b7d113740c1890487e1431a8153e13 MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, LGPL-2.1, BSD-3-Clause
Large files files are truncated, but you can click here to view the full file
- /*
- +----------------------------------------------------------------------+
- | PHP Version 5 |
- +----------------------------------------------------------------------+
- | Copyright (c) 1997-2011 The PHP Group |
- +----------------------------------------------------------------------+
- | This source file is subject to version 3.01 of the PHP license, |
- | that is bundled with this package in the file LICENSE, and is |
- | available through the world-wide-web at the following url: |
- | http://www.php.net/license/3_01.txt |
- | If you did not receive a copy of the PHP license and are unable to |
- | obtain it through the world-wide-web, please send a note to |
- | license@php.net so we can mail you a copy immediately. |
- +----------------------------------------------------------------------+
- | Authors: Brad Lafountain <rodif_bl@yahoo.com> |
- | Shane Caraveo <shane@caraveo.com> |
- | Dmitry Stogov <dmitry@zend.com> |
- +----------------------------------------------------------------------+
- */
- /* $Id: php_encoding.c 306939 2011-01-01 02:19:59Z felipe $ */
- #include <time.h>
- #include "php_soap.h"
- #include "ext/libxml/php_libxml.h"
- #include "ext/standard/base64.h"
- #include <libxml/parserInternals.h>
- #include "zend_strtod.h"
- #include "zend_interfaces.h"
- /* zval type decode */
- static zval *to_zval_double(encodeTypePtr type, xmlNodePtr data);
- static zval *to_zval_long(encodeTypePtr type, xmlNodePtr data);
- static zval *to_zval_bool(encodeTypePtr type, xmlNodePtr data);
- static zval *to_zval_string(encodeTypePtr type, xmlNodePtr data);
- static zval *to_zval_stringr(encodeTypePtr type, xmlNodePtr data);
- static zval *to_zval_stringc(encodeTypePtr type, xmlNodePtr data);
- static zval *to_zval_map(encodeTypePtr type, xmlNodePtr data);
- static zval *to_zval_null(encodeTypePtr type, xmlNodePtr data);
- static zval *to_zval_base64(encodeTypePtr type, xmlNodePtr data);
- static zval *to_zval_hexbin(encodeTypePtr type, xmlNodePtr data);
- static xmlNodePtr to_xml_long(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_double(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_bool(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- /* String encode */
- static xmlNodePtr to_xml_string(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_base64(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_hexbin(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- /* Null encode */
- static xmlNodePtr to_xml_null(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- /* Array encode */
- static xmlNodePtr guess_array_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_list1(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent);
- /* Datetime encode/decode */
- static xmlNodePtr to_xml_datetime_ex(encodeTypePtr type, zval *data, char *format, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_datetime(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_time(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_date(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_gyearmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_gyear(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_gmonthday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_gday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_gmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_duration(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static zval *to_zval_object(encodeTypePtr type, xmlNodePtr data);
- static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data);
- static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static zval *to_zval_any(encodeTypePtr type, xmlNodePtr data);
- static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- /* Try and guess for non-wsdl clients and servers */
- static zval *guess_zval_convert(encodeTypePtr type, xmlNodePtr data);
- static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
- static int is_map(zval *array);
- static encodePtr get_array_type(xmlNodePtr node, zval *array, smart_str *out_type TSRMLS_DC);
- static xmlNodePtr check_and_resolve_href(xmlNodePtr data);
- static void set_ns_prop(xmlNodePtr node, char *ns, char *name, char *val);
- static void set_xsi_nil(xmlNodePtr node);
- static void set_xsi_type(xmlNodePtr node, char *type);
- static void get_type_str(xmlNodePtr node, const char* ns, const char* type, smart_str* ret);
- static void set_ns_and_type_ex(xmlNodePtr node, char *ns, char *type);
- static void set_ns_and_type(xmlNodePtr node, encodeTypePtr type);
- #define FIND_XML_NULL(xml,zval) \
- { \
- xmlAttrPtr null; \
- if (!xml) { \
- ZVAL_NULL(zval); \
- return zval; \
- } \
- if (xml->properties) { \
- null = get_attribute(xml->properties, "nil"); \
- if (null) { \
- ZVAL_NULL(zval); \
- return zval; \
- } \
- } \
- }
- #define FIND_ZVAL_NULL(zval, xml, style) \
- { \
- if (!zval || Z_TYPE_P(zval) == IS_NULL) { \
- if (style == SOAP_ENCODED) {\
- set_xsi_nil(xml); \
- } \
- return xml; \
- } \
- }
- encode defaultEncoding[] = {
- {{UNKNOWN_TYPE, NULL, NULL, NULL}, guess_zval_convert, guess_xml_convert},
- {{IS_NULL, "nil", XSI_NAMESPACE, NULL}, to_zval_null, to_xml_null},
- {{IS_STRING, XSD_STRING_STRING, XSD_NAMESPACE, NULL}, to_zval_string, to_xml_string},
- {{IS_LONG, XSD_INT_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{IS_DOUBLE, XSD_FLOAT_STRING, XSD_NAMESPACE, NULL}, to_zval_double, to_xml_double},
- {{IS_BOOL, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL}, to_zval_bool, to_xml_bool},
- {{IS_CONSTANT, XSD_STRING_STRING, XSD_NAMESPACE, NULL}, to_zval_string, to_xml_string},
- {{IS_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_1_ENC_NAMESPACE, NULL}, to_zval_array, guess_array_map},
- {{IS_CONSTANT_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_1_ENC_NAMESPACE, NULL}, to_zval_array, to_xml_array},
- {{IS_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_1_ENC_NAMESPACE, NULL}, to_zval_object, to_xml_object},
- {{IS_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_2_ENC_NAMESPACE, NULL}, to_zval_array, guess_array_map},
- {{IS_CONSTANT_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_2_ENC_NAMESPACE, NULL}, to_zval_array, to_xml_array},
- {{IS_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_2_ENC_NAMESPACE, NULL}, to_zval_object, to_xml_object},
- {{XSD_STRING, XSD_STRING_STRING, XSD_NAMESPACE, NULL}, to_zval_string, to_xml_string},
- {{XSD_BOOLEAN, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL}, to_zval_bool, to_xml_bool},
- {{XSD_DECIMAL, XSD_DECIMAL_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},
- {{XSD_FLOAT, XSD_FLOAT_STRING, XSD_NAMESPACE, NULL}, to_zval_double, to_xml_double},
- {{XSD_DOUBLE, XSD_DOUBLE_STRING, XSD_NAMESPACE, NULL}, to_zval_double, to_xml_double},
- {{XSD_DATETIME, XSD_DATETIME_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_datetime},
- {{XSD_TIME, XSD_TIME_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_time},
- {{XSD_DATE, XSD_DATE_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_date},
- {{XSD_GYEARMONTH, XSD_GYEARMONTH_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_gyearmonth},
- {{XSD_GYEAR, XSD_GYEAR_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_gyear},
- {{XSD_GMONTHDAY, XSD_GMONTHDAY_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_gmonthday},
- {{XSD_GDAY, XSD_GDAY_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_gday},
- {{XSD_GMONTH, XSD_GMONTH_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_gmonth},
- {{XSD_DURATION, XSD_DURATION_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_duration},
- {{XSD_HEXBINARY, XSD_HEXBINARY_STRING, XSD_NAMESPACE, NULL}, to_zval_hexbin, to_xml_hexbin},
- {{XSD_BASE64BINARY, XSD_BASE64BINARY_STRING, XSD_NAMESPACE, NULL}, to_zval_base64, to_xml_base64},
- {{XSD_LONG, XSD_LONG_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{XSD_INT, XSD_INT_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{XSD_SHORT, XSD_SHORT_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{XSD_BYTE, XSD_BYTE_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{XSD_NONPOSITIVEINTEGER, XSD_NONPOSITIVEINTEGER_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{XSD_POSITIVEINTEGER, XSD_POSITIVEINTEGER_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{XSD_NONNEGATIVEINTEGER, XSD_NONNEGATIVEINTEGER_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{XSD_NEGATIVEINTEGER, XSD_NEGATIVEINTEGER_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{XSD_UNSIGNEDBYTE, XSD_UNSIGNEDBYTE_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{XSD_UNSIGNEDSHORT, XSD_UNSIGNEDSHORT_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{XSD_UNSIGNEDINT, XSD_UNSIGNEDINT_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{XSD_UNSIGNEDLONG, XSD_UNSIGNEDLONG_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{XSD_INTEGER, XSD_INTEGER_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{XSD_ANYTYPE, XSD_ANYTYPE_STRING, XSD_NAMESPACE, NULL}, guess_zval_convert, guess_xml_convert},
- {{XSD_UR_TYPE, XSD_UR_TYPE_STRING, XSD_NAMESPACE, NULL}, guess_zval_convert, guess_xml_convert},
- {{XSD_ANYURI, XSD_ANYURI_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},
- {{XSD_QNAME, XSD_QNAME_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},
- {{XSD_NOTATION, XSD_NOTATION_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},
- {{XSD_NORMALIZEDSTRING, XSD_NORMALIZEDSTRING_STRING, XSD_NAMESPACE, NULL}, to_zval_stringr, to_xml_string},
- {{XSD_TOKEN, XSD_TOKEN_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},
- {{XSD_LANGUAGE, XSD_LANGUAGE_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},
- {{XSD_NMTOKEN, XSD_NMTOKEN_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},
- {{XSD_NMTOKENS, XSD_NMTOKENS_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_list1},
- {{XSD_NAME, XSD_NAME_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},
- {{XSD_NCNAME, XSD_NCNAME_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},
- {{XSD_ID, XSD_ID_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},
- {{XSD_IDREF, XSD_IDREF_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},
- {{XSD_IDREFS, XSD_IDREFS_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_list1},
- {{XSD_ENTITY, XSD_ENTITY_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},
- {{XSD_ENTITIES, XSD_ENTITIES_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_list1},
- {{APACHE_MAP, APACHE_MAP_STRING, APACHE_NAMESPACE, NULL}, to_zval_map, to_xml_map},
- {{SOAP_ENC_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_1_ENC_NAMESPACE, NULL}, to_zval_object, to_xml_object},
- {{SOAP_ENC_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_1_ENC_NAMESPACE, NULL}, to_zval_array, to_xml_array},
- {{SOAP_ENC_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_2_ENC_NAMESPACE, NULL}, to_zval_object, to_xml_object},
- {{SOAP_ENC_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_2_ENC_NAMESPACE, NULL}, to_zval_array, to_xml_array},
- /* support some of the 1999 data types */
- {{XSD_STRING, XSD_STRING_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_string, to_xml_string},
- {{XSD_BOOLEAN, XSD_BOOLEAN_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_bool, to_xml_bool},
- {{XSD_DECIMAL, XSD_DECIMAL_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},
- {{XSD_FLOAT, XSD_FLOAT_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_double, to_xml_double},
- {{XSD_DOUBLE, XSD_DOUBLE_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_double, to_xml_double},
- {{XSD_LONG, XSD_LONG_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{XSD_INT, XSD_INT_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{XSD_SHORT, XSD_SHORT_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{XSD_BYTE, XSD_BYTE_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_long, to_xml_long},
- {{XSD_1999_TIMEINSTANT, XSD_1999_TIMEINSTANT_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},
- {{XSD_ANYXML, "<anyXML>", "<anyXML>", NULL}, to_zval_any, to_xml_any},
- {{END_KNOWN_TYPES, NULL, NULL, NULL}, guess_zval_convert, guess_xml_convert}
- };
- int numDefaultEncodings = sizeof(defaultEncoding)/sizeof(encode);
- void whiteSpace_replace(xmlChar* str)
- {
- while (*str != '\0') {
- if (*str == '\x9' || *str == '\xA' || *str == '\xD') {
- *str = ' ';
- }
- str++;
- }
- }
- void whiteSpace_collapse(xmlChar* str)
- {
- xmlChar *pos;
- xmlChar old;
- pos = str;
- whiteSpace_replace(str);
- while (*str == ' ') {
- str++;
- }
- old = '\0';
- while (*str != '\0') {
- if (*str != ' ' || old != ' ') {
- *pos = *str;
- pos++;
- }
- old = *str;
- str++;
- }
- if (old == ' ') {
- --pos;
- }
- *pos = '\0';
- }
- static encodePtr find_encoder_by_type_name(sdlPtr sdl, const char *type)
- {
- if (sdl && sdl->encoders) {
- HashPosition pos;
- encodePtr *enc;
- for (zend_hash_internal_pointer_reset_ex(sdl->encoders, &pos);
- zend_hash_get_current_data_ex(sdl->encoders, (void **) &enc, &pos) == SUCCESS;
- zend_hash_move_forward_ex(sdl->encoders, &pos)) {
- if (strcmp((*enc)->details.type_str, type) == 0) {
- return *enc;
- }
- }
- }
- return NULL;
- }
- static zend_bool soap_check_zval_ref(zval *data, xmlNodePtr node TSRMLS_DC) {
- xmlNodePtr *node_ptr;
- if (SOAP_GLOBAL(ref_map)) {
- if (Z_TYPE_P(data) == IS_OBJECT) {
- data = (zval*)zend_objects_get_address(data TSRMLS_CC);
- }
- if (zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)data, (void**)&node_ptr) == SUCCESS) {
- xmlAttrPtr attr = (*node_ptr)->properties;
- char *id;
- smart_str prefix = {0};
- if (*node_ptr == node) {
- return 0;
- }
- xmlNodeSetName(node, (*node_ptr)->name);
- xmlSetNs(node, (*node_ptr)->ns);
- if (SOAP_GLOBAL(soap_version) == SOAP_1_1) {
- while (1) {
- attr = get_attribute(attr, "id");
- if (attr == NULL || attr->ns == NULL) {
- break;
- }
- attr = attr->next;
- }
- if (attr) {
- id = (char*)attr->children->content;
- smart_str_appendc(&prefix, '#');
- smart_str_appends(&prefix, id);
- smart_str_0(&prefix);
- id = prefix.c;
- } else {
- SOAP_GLOBAL(cur_uniq_ref)++;
- smart_str_appendl(&prefix, "#ref", 4);
- smart_str_append_long(&prefix, SOAP_GLOBAL(cur_uniq_ref));
- smart_str_0(&prefix);
- id = prefix.c;
- xmlSetProp((*node_ptr), BAD_CAST("id"), BAD_CAST(id+1));
- }
- xmlSetProp(node, BAD_CAST("href"), BAD_CAST(id));
- } else {
- attr = get_attribute_ex(attr, "id", SOAP_1_2_ENC_NAMESPACE);
- if (attr) {
- id = (char*)attr->children->content;
- smart_str_appendc(&prefix, '#');
- smart_str_appends(&prefix, id);
- smart_str_0(&prefix);
- id = prefix.c;
- } else {
- SOAP_GLOBAL(cur_uniq_ref)++;
- smart_str_appendl(&prefix, "#ref", 4);
- smart_str_append_long(&prefix, SOAP_GLOBAL(cur_uniq_ref));
- smart_str_0(&prefix);
- id = prefix.c;
- set_ns_prop((*node_ptr), SOAP_1_2_ENC_NAMESPACE, "id", id+1);
- }
- set_ns_prop(node, SOAP_1_2_ENC_NAMESPACE, "ref", id);
- }
- smart_str_free(&prefix);
- return 1;
- } else {
- zend_hash_index_update(SOAP_GLOBAL(ref_map), (ulong)data, (void**)&node, sizeof(xmlNodePtr), NULL);
- }
- }
- return 0;
- }
- static zend_bool soap_check_xml_ref(zval **data, xmlNodePtr node TSRMLS_DC)
- {
- zval **data_ptr;
- if (SOAP_GLOBAL(ref_map)) {
- if (zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)node, (void**)&data_ptr) == SUCCESS) {
- if (*data != *data_ptr) {
- zval_ptr_dtor(data);
- *data = *data_ptr;
- Z_SET_ISREF_PP(data);
- Z_ADDREF_PP(data);
- return 1;
- }
- } else {
- zend_hash_index_update(SOAP_GLOBAL(ref_map), (ulong)node, (void**)data, sizeof(zval*), NULL);
- }
- }
- return 0;
- }
- static xmlNodePtr master_to_xml_int(encodePtr encode, zval *data, int style, xmlNodePtr parent, int check_class_map)
- {
- xmlNodePtr node = NULL;
- int add_type = 0;
- TSRMLS_FETCH();
- /* Special handling of class SoapVar */
- if (data &&
- Z_TYPE_P(data) == IS_OBJECT &&
- Z_OBJCE_P(data) == soap_var_class_entry) {
- zval **ztype, **zdata, **zns, **zstype, **zname, **znamens;
- encodePtr enc = NULL;
- HashTable *ht = Z_OBJPROP_P(data);
- if (zend_hash_find(ht, "enc_type", sizeof("enc_type"), (void **)&ztype) == FAILURE) {
- soap_error0(E_ERROR, "Encoding: SoapVar has no 'enc_type' property");
- }
- if (zend_hash_find(ht, "enc_stype", sizeof("enc_stype"), (void **)&zstype) == SUCCESS) {
- if (zend_hash_find(ht, "enc_ns", sizeof("enc_ns"), (void **)&zns) == SUCCESS) {
- enc = get_encoder(SOAP_GLOBAL(sdl), Z_STRVAL_PP(zns), Z_STRVAL_PP(zstype));
- } else {
- zns = NULL;
- enc = get_encoder_ex(SOAP_GLOBAL(sdl), Z_STRVAL_PP(zstype), Z_STRLEN_PP(zstype));
- }
- if (enc == NULL && SOAP_GLOBAL(typemap)) {
- encodePtr *new_enc;
- smart_str nscat = {0};
- if (zns != NULL) {
- smart_str_appendl(&nscat, Z_STRVAL_PP(zns), Z_STRLEN_PP(zns));
- smart_str_appendc(&nscat, ':');
- }
- smart_str_appendl(&nscat, Z_STRVAL_PP(zstype), Z_STRLEN_PP(zstype));
- smart_str_0(&nscat);
- if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) {
- enc = *new_enc;
- }
- smart_str_free(&nscat);
- }
- }
- if (enc == NULL) {
- enc = get_conversion(Z_LVAL_P(*ztype));
- }
- if (enc == NULL) {
- enc = encode;
- }
- if (zend_hash_find(ht, "enc_value", sizeof("enc_value"), (void **)&zdata) == FAILURE) {
- node = master_to_xml(enc, NULL, style, parent);
- } else {
- node = master_to_xml(enc, *zdata, style, parent);
- }
- if (style == SOAP_ENCODED || (SOAP_GLOBAL(sdl) && encode != enc)) {
- if (zend_hash_find(ht, "enc_stype", sizeof("enc_stype"), (void **)&zstype) == SUCCESS) {
- if (zend_hash_find(ht, "enc_ns", sizeof("enc_ns"), (void **)&zns) == SUCCESS) {
- set_ns_and_type_ex(node, Z_STRVAL_PP(zns), Z_STRVAL_PP(zstype));
- } else {
- set_ns_and_type_ex(node, NULL, Z_STRVAL_PP(zstype));
- }
- }
- }
- if (zend_hash_find(ht, "enc_name", sizeof("enc_name"), (void **)&zname) == SUCCESS) {
- xmlNodeSetName(node, BAD_CAST(Z_STRVAL_PP(zname)));
- }
- if (zend_hash_find(ht, "enc_namens", sizeof("enc_namens"), (void **)&znamens) == SUCCESS) {
- xmlNsPtr nsp = encode_add_ns(node, Z_STRVAL_PP(znamens));
- xmlSetNs(node, nsp);
- }
- } else {
- if (check_class_map && SOAP_GLOBAL(class_map) && data &&
- Z_TYPE_P(data) == IS_OBJECT &&
- !Z_OBJPROP_P(data)->nApplyCount) {
- zend_class_entry *ce = Z_OBJCE_P(data);
- HashPosition pos;
- zval **tmp;
- char *type_name = NULL;
- uint type_len;
- ulong idx;
- for (zend_hash_internal_pointer_reset_ex(SOAP_GLOBAL(class_map), &pos);
- zend_hash_get_current_data_ex(SOAP_GLOBAL(class_map), (void **) &tmp, &pos) == SUCCESS;
- zend_hash_move_forward_ex(SOAP_GLOBAL(class_map), &pos)) {
- if (Z_TYPE_PP(tmp) == IS_STRING &&
- ce->name_length == Z_STRLEN_PP(tmp) &&
- zend_binary_strncasecmp(ce->name, ce->name_length, Z_STRVAL_PP(tmp), ce->name_length, ce->name_length) == 0 &&
- zend_hash_get_current_key_ex(SOAP_GLOBAL(class_map), &type_name, &type_len, &idx, 0, &pos) == HASH_KEY_IS_STRING) {
- /* TODO: namespace isn't stored */
- encodePtr enc = NULL;
- if (SOAP_GLOBAL(sdl)) {
- enc = get_encoder(SOAP_GLOBAL(sdl), SOAP_GLOBAL(sdl)->target_ns, type_name);
- if (!enc) {
- enc = find_encoder_by_type_name(SOAP_GLOBAL(sdl), type_name);
- }
- }
- if (enc) {
- if (encode != enc && style == SOAP_LITERAL) {
- add_type = 1;
- }
- encode = enc;
- }
- break;
- }
- }
- }
- if (encode == NULL) {
- encode = get_conversion(UNKNOWN_TYPE);
- }
- if (SOAP_GLOBAL(typemap) && encode->details.type_str) {
- smart_str nscat = {0};
- encodePtr *new_enc;
- if (encode->details.ns) {
- smart_str_appends(&nscat, encode->details.ns);
- smart_str_appendc(&nscat, ':');
- }
- smart_str_appends(&nscat, encode->details.type_str);
- smart_str_0(&nscat);
- if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) {
- encode = *new_enc;
- }
- smart_str_free(&nscat);
- }
- if (encode->to_xml) {
- node = encode->to_xml(&encode->details, data, style, parent);
- if (add_type) {
- set_ns_and_type(node, &encode->details);
- }
- }
- }
- return node;
- }
- xmlNodePtr master_to_xml(encodePtr encode, zval *data, int style, xmlNodePtr parent)
- {
- return master_to_xml_int(encode, data, style, parent, 1);
- }
- static zval *master_to_zval_int(encodePtr encode, xmlNodePtr data)
- {
- zval *ret = NULL;
- TSRMLS_FETCH();
- if (SOAP_GLOBAL(typemap)) {
- if (encode->details.type_str) {
- smart_str nscat = {0};
- encodePtr *new_enc;
- if (encode->details.ns) {
- smart_str_appends(&nscat, encode->details.ns);
- smart_str_appendc(&nscat, ':');
- }
- smart_str_appends(&nscat, encode->details.type_str);
- smart_str_0(&nscat);
- if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) {
- encode = *new_enc;
- }
- smart_str_free(&nscat);
- } else {
- xmlAttrPtr type_attr = get_attribute_ex(data->properties,"type", XSI_NAMESPACE);
- if (type_attr != NULL) {
- encodePtr *new_enc;
- xmlNsPtr nsptr;
- char *ns, *cptype;
- smart_str nscat = {0};
- parse_namespace(type_attr->children->content, &cptype, &ns);
- nsptr = xmlSearchNs(data->doc, data, BAD_CAST(ns));
- if (nsptr != NULL) {
- smart_str_appends(&nscat, (char*)nsptr->href);
- smart_str_appendc(&nscat, ':');
- }
- smart_str_appends(&nscat, cptype);
- smart_str_0(&nscat);
- efree(cptype);
- if (ns) {efree(ns);}
- if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) {
- encode = *new_enc;
- }
- smart_str_free(&nscat);
- }
- }
- }
- if (encode->to_zval) {
- ret = encode->to_zval(&encode->details, data);
- }
- return ret;
- }
- zval *master_to_zval(encodePtr encode, xmlNodePtr data)
- {
- TSRMLS_FETCH();
- data = check_and_resolve_href(data);
- if (encode == NULL) {
- encode = get_conversion(UNKNOWN_TYPE);
- } else {
- /* Use xsi:type if it is defined */
- xmlAttrPtr type_attr = get_attribute_ex(data->properties,"type", XSI_NAMESPACE);
- if (type_attr != NULL) {
- encodePtr enc = get_encoder_from_prefix(SOAP_GLOBAL(sdl), data, type_attr->children->content);
- if (enc != NULL && enc != encode) {
- encodePtr tmp = enc;
- while (tmp &&
- tmp->details.sdl_type != NULL &&
- tmp->details.sdl_type->kind != XSD_TYPEKIND_COMPLEX) {
- if (enc == tmp->details.sdl_type->encode ||
- tmp == tmp->details.sdl_type->encode) {
- enc = NULL;
- break;
- }
- tmp = tmp->details.sdl_type->encode;
- }
- if (enc != NULL) {
- encode = enc;
- }
- }
- }
- }
- return master_to_zval_int(encode, data);
- }
- xmlNodePtr to_xml_user(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
- {
- xmlNodePtr ret = NULL;
- zval *return_value;
- TSRMLS_FETCH();
- if (type && type->map && type->map->to_xml) {
- MAKE_STD_ZVAL(return_value);
- if (call_user_function(EG(function_table), NULL, type->map->to_xml, return_value, 1, &data TSRMLS_CC) == FAILURE) {
- soap_error0(E_ERROR, "Encoding: Error calling to_xml callback");
- }
- if (Z_TYPE_P(return_value) == IS_STRING) {
- xmlDocPtr doc = soap_xmlParseMemory(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value));
- if (doc && doc->children) {
- ret = xmlDocCopyNode(doc->children, parent->doc, 1);
- }
- xmlFreeDoc(doc);
- }
- zval_ptr_dtor(&return_value);
- }
- if (!ret) {
- ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
- }
- xmlAddChild(parent, ret);
- if (style == SOAP_ENCODED) {
- set_ns_and_type(ret, type);
- }
- return ret;
- }
- zval *to_zval_user(encodeTypePtr type, xmlNodePtr node)
- {
- zval *return_value;
- TSRMLS_FETCH();
- if (type && type->map && type->map->to_zval) {
- xmlBufferPtr buf;
- zval *data;
- xmlNodePtr copy;
- copy = xmlCopyNode(node, 1);
- buf = xmlBufferCreate();
- xmlNodeDump(buf, NULL, copy, 0, 0);
- MAKE_STD_ZVAL(data);
- ZVAL_STRING(data, (char*)xmlBufferContent(buf), 1);
- xmlBufferFree(buf);
- xmlFreeNode(copy);
- ALLOC_INIT_ZVAL(return_value);
-
- if (call_user_function(EG(function_table), NULL, type->map->to_zval, return_value, 1, &data TSRMLS_CC) == FAILURE) {
- soap_error0(E_ERROR, "Encoding: Error calling from_xml callback");
- }
- zval_ptr_dtor(&data);
- } else {
- ALLOC_INIT_ZVAL(return_value);
- }
- return return_value;
- }
- /* TODO: get rid of "bogus".. ither by passing in the already created xmlnode or passing in the node name */
- /* String encode/decode */
- static zval *to_zval_string(encodeTypePtr type, xmlNodePtr data)
- {
- zval *ret;
- MAKE_STD_ZVAL(ret);
- FIND_XML_NULL(data, ret);
- if (data && data->children) {
- if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
- TSRMLS_FETCH();
- if (SOAP_GLOBAL(encoding) != NULL) {
- xmlBufferPtr in = xmlBufferCreateStatic(data->children->content, xmlStrlen(data->children->content));
- xmlBufferPtr out = xmlBufferCreate();
- int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);
- if (n >= 0) {
- ZVAL_STRING(ret, (char*)xmlBufferContent(out), 1);
- } else {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
- }
- xmlBufferFree(out);
- xmlBufferFree(in);
- } else {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
- }
- } else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
- } else {
- soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
- }
- } else {
- ZVAL_EMPTY_STRING(ret);
- }
- return ret;
- }
- static zval *to_zval_stringr(encodeTypePtr type, xmlNodePtr data)
- {
- zval *ret;
- MAKE_STD_ZVAL(ret);
- FIND_XML_NULL(data, ret);
- if (data && data->children) {
- if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
- TSRMLS_FETCH();
- whiteSpace_replace(data->children->content);
- if (SOAP_GLOBAL(encoding) != NULL) {
- xmlBufferPtr in = xmlBufferCreateStatic(data->children->content, xmlStrlen(data->children->content));
- xmlBufferPtr out = xmlBufferCreate();
- int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);
- if (n >= 0) {
- ZVAL_STRING(ret, (char*)xmlBufferContent(out), 1);
- } else {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
- }
- xmlBufferFree(out);
- xmlBufferFree(in);
- } else {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
- }
- } else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
- } else {
- soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
- }
- } else {
- ZVAL_EMPTY_STRING(ret);
- }
- return ret;
- }
- static zval *to_zval_stringc(encodeTypePtr type, xmlNodePtr data)
- {
- zval *ret;
- MAKE_STD_ZVAL(ret);
- FIND_XML_NULL(data, ret);
- if (data && data->children) {
- if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
- TSRMLS_FETCH();
- whiteSpace_collapse(data->children->content);
- if (SOAP_GLOBAL(encoding) != NULL) {
- xmlBufferPtr in = xmlBufferCreateStatic(data->children->content, xmlStrlen(data->children->content));
- xmlBufferPtr out = xmlBufferCreate();
- int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);
- if (n >= 0) {
- ZVAL_STRING(ret, (char*)xmlBufferContent(out), 1);
- } else {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
- }
- xmlBufferFree(out);
- xmlBufferFree(in);
- } else {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
- }
- } else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
- } else {
- soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
- }
- } else {
- ZVAL_EMPTY_STRING(ret);
- }
- return ret;
- }
- static zval *to_zval_base64(encodeTypePtr type, xmlNodePtr data)
- {
- zval *ret;
- char *str;
- int str_len;
- MAKE_STD_ZVAL(ret);
- FIND_XML_NULL(data, ret);
- if (data && data->children) {
- if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
- whiteSpace_collapse(data->children->content);
- str = (char*)php_base64_decode(data->children->content, strlen((char*)data->children->content), &str_len);
- if (!str) {
- soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
- }
- ZVAL_STRINGL(ret, str, str_len, 0);
- } else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
- str = (char*)php_base64_decode(data->children->content, strlen((char*)data->children->content), &str_len);
- if (!str) {
- soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
- }
- ZVAL_STRINGL(ret, str, str_len, 0);
- } else {
- soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
- }
- } else {
- ZVAL_EMPTY_STRING(ret);
- }
- return ret;
- }
- static zval *to_zval_hexbin(encodeTypePtr type, xmlNodePtr data)
- {
- zval *ret;
- unsigned char *str;
- int str_len, i, j;
- unsigned char c;
- MAKE_STD_ZVAL(ret);
- FIND_XML_NULL(data, ret);
- if (data && data->children) {
- if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
- whiteSpace_collapse(data->children->content);
- } else if (data->children->type != XML_CDATA_SECTION_NODE || data->children->next != NULL) {
- soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
- return ret;
- }
- str_len = strlen((char*)data->children->content) / 2;
- str = emalloc(str_len+1);
- for (i = j = 0; i < str_len; i++) {
- c = data->children->content[j++];
- if (c >= '0' && c <= '9') {
- str[i] = (c - '0') << 4;
- } else if (c >= 'a' && c <= 'f') {
- str[i] = (c - 'a' + 10) << 4;
- } else if (c >= 'A' && c <= 'F') {
- str[i] = (c - 'A' + 10) << 4;
- } else {
- soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
- }
- c = data->children->content[j++];
- if (c >= '0' && c <= '9') {
- str[i] |= c - '0';
- } else if (c >= 'a' && c <= 'f') {
- str[i] |= c - 'a' + 10;
- } else if (c >= 'A' && c <= 'F') {
- str[i] |= c - 'A' + 10;
- } else {
- soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
- }
- }
- str[str_len] = '\0';
- ZVAL_STRINGL(ret, (char*)str, str_len, 0);
- } else {
- ZVAL_EMPTY_STRING(ret);
- }
- return ret;
- }
- static xmlNodePtr to_xml_string(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
- {
- xmlNodePtr ret, text;
- char *str;
- int new_len;
- TSRMLS_FETCH();
- ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
- xmlAddChild(parent, ret);
- FIND_ZVAL_NULL(data, ret, style);
- if (Z_TYPE_P(data) == IS_STRING) {
- str = estrndup(Z_STRVAL_P(data), Z_STRLEN_P(data));
- new_len = Z_STRLEN_P(data);
- } else {
- zval tmp = *data;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- str = estrndup(Z_STRVAL(tmp), Z_STRLEN(tmp));
- new_len = Z_STRLEN(tmp);
- zval_dtor(&tmp);
- }
- if (SOAP_GLOBAL(encoding) != NULL) {
- xmlBufferPtr in = xmlBufferCreateStatic(str, new_len);
- xmlBufferPtr out = xmlBufferCreate();
- int n = xmlCharEncInFunc(SOAP_GLOBAL(encoding), out, in);
- if (n >= 0) {
- efree(str);
- str = estrdup((char*)xmlBufferContent(out));
- new_len = n;
- }
- xmlBufferFree(out);
- xmlBufferFree(in);
- }
- if (!php_libxml_xmlCheckUTF8(BAD_CAST(str))) {
- char *err = emalloc(new_len + 8);
- char c;
- int i;
-
- memcpy(err, str, new_len+1);
- for (i = 0; (c = err[i++]);) {
- if ((c & 0x80) == 0) {
- } else if ((c & 0xe0) == 0xc0) {
- if ((err[i] & 0xc0) != 0x80) {
- break;
- }
- i++;
- } else if ((c & 0xf0) == 0xe0) {
- if ((err[i] & 0xc0) != 0x80 || (err[i+1] & 0xc0) != 0x80) {
- break;
- }
- i += 2;
- } else if ((c & 0xf8) == 0xf0) {
- if ((err[i] & 0xc0) != 0x80 || (err[i+1] & 0xc0) != 0x80 || (err[i+2] & 0xc0) != 0x80) {
- break;
- }
- i += 3;
- } else {
- break;
- }
- }
- if (c) {
- err[i-1] = '\\';
- err[i++] = 'x';
- err[i++] = ((unsigned char)c >> 4) + ((((unsigned char)c >> 4) > 9) ? ('a' - 10) : '0');
- err[i++] = (c & 15) + (((c & 15) > 9) ? ('a' - 10) : '0');
- err[i++] = '.';
- err[i++] = '.';
- err[i++] = '.';
- err[i++] = 0;
- }
- soap_error1(E_ERROR, "Encoding: string '%s' is not a valid utf-8 string", err);
- }
- text = xmlNewTextLen(BAD_CAST(str), new_len);
- xmlAddChild(ret, text);
- efree(str);
- if (style == SOAP_ENCODED) {
- set_ns_and_type(ret, type);
- }
- return ret;
- }
- static xmlNodePtr to_xml_base64(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
- {
- xmlNodePtr ret, text;
- unsigned char *str;
- int str_len;
- ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
- xmlAddChild(parent, ret);
- FIND_ZVAL_NULL(data, ret, style);
- if (Z_TYPE_P(data) == IS_STRING) {
- str = php_base64_encode((unsigned char*)Z_STRVAL_P(data), Z_STRLEN_P(data), &str_len);
- text = xmlNewTextLen(str, str_len);
- xmlAddChild(ret, text);
- efree(str);
- } else {
- zval tmp = *data;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- str = php_base64_encode((unsigned char*)Z_STRVAL(tmp), Z_STRLEN(tmp), &str_len);
- text = xmlNewTextLen(str, str_len);
- xmlAddChild(ret, text);
- efree(str);
- zval_dtor(&tmp);
- }
- if (style == SOAP_ENCODED) {
- set_ns_and_type(ret, type);
- }
- return ret;
- }
- static xmlNodePtr to_xml_hexbin(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
- {
- static char hexconvtab[] = "0123456789ABCDEF";
- xmlNodePtr ret, text;
- unsigned char *str;
- zval tmp;
- int i, j;
- ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
- xmlAddChild(parent, ret);
- FIND_ZVAL_NULL(data, ret, style);
- if (Z_TYPE_P(data) != IS_STRING) {
- tmp = *data;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- data = &tmp;
- }
- str = (unsigned char *) safe_emalloc(Z_STRLEN_P(data) * 2, sizeof(char), 1);
- for (i = j = 0; i < Z_STRLEN_P(data); i++) {
- str[j++] = hexconvtab[((unsigned char)Z_STRVAL_P(data)[i]) >> 4];
- str[j++] = hexconvtab[((unsigned char)Z_STRVAL_P(data)[i]) & 15];
- }
- str[j] = '\0';
- text = xmlNewTextLen(str, Z_STRLEN_P(data) * 2 * sizeof(char));
- xmlAddChild(ret, text);
- efree(str);
- if (data == &tmp) {
- zval_dtor(&tmp);
- }
- if (style == SOAP_ENCODED) {
- set_ns_and_type(ret, type);
- }
- return ret;
- }
- static zval *to_zval_double(encodeTypePtr type, xmlNodePtr data)
- {
- zval *ret;
- MAKE_STD_ZVAL(ret);
- FIND_XML_NULL(data, ret);
- if (data && data->children) {
- if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
- long lval;
- double dval;
- whiteSpace_collapse(data->children->content);
- switch (is_numeric_string((char*)data->children->content, strlen((char*)data->children->content), &lval, &dval, 0)) {
- case IS_LONG:
- Z_TYPE_P(ret) = IS_DOUBLE;
- Z_DVAL_P(ret) = lval;
- break;
- case IS_DOUBLE:
- Z_TYPE_P(ret) = IS_DOUBLE;
- Z_DVAL_P(ret) = dval;
- break;
- default:
- if (strncasecmp((char*)data->children->content, "NaN", sizeof("NaN")-1) == 0) {
- ZVAL_DOUBLE(ret, php_get_nan());
- } else if (strncasecmp((char*)data->children->content, "INF", sizeof("INF")-1) == 0) {
- ZVAL_DOUBLE(ret, php_get_inf());
- } else if (strncasecmp((char*)data->children->content, "-INF", sizeof("-INF")-1) == 0) {
- ZVAL_DOUBLE(ret, -php_get_inf());
- } else {
- soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
- }
- }
- } else {
- soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
- }
- } else {
- ZVAL_NULL(ret);
- }
- return ret;
- }
- static zval *to_zval_long(encodeTypePtr type, xmlNodePtr data)
- {
- zval *ret;
- MAKE_STD_ZVAL(ret);
- FIND_XML_NULL(data, ret);
- if (data && data->children) {
- if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
- long lval;
- double dval;
- whiteSpace_collapse(data->children->content);
- errno = 0;
- switch ((Z_TYPE_P(ret) = is_numeric_string((char*)data->children->content, strlen((char*)data->children->content), &lval, &dval, 0))) {
- case IS_LONG:
- Z_LVAL_P(ret) = lval;
- break;
- case IS_DOUBLE:
- Z_DVAL_P(ret) = dval;
- break;
- default:
- soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
- }
- } else {
- soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
- }
- } else {
- ZVAL_NULL(ret);
- }
- return ret;
- }
- static xmlNodePtr to_xml_long(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
- {
- xmlNodePtr ret;
- ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
- xmlAddChild(parent, ret);
- FIND_ZVAL_NULL(data, ret, style);
- if (Z_TYPE_P(data) == IS_DOUBLE) {
- char s[256];
- snprintf(s, sizeof(s), "%0.0F",floor(Z_DVAL_P(data)));
- xmlNodeSetContent(ret, BAD_CAST(s));
- } else {
- zval tmp = *data;
- zval_copy_ctor(&tmp);
- if (Z_TYPE(tmp) != IS_LONG) {
- convert_to_long(&tmp);
- }
- convert_to_string(&tmp);
- xmlNodeSetContentLen(ret, BAD_CAST(Z_STRVAL(tmp)), Z_STRLEN(tmp));
- zval_dtor(&tmp);
- }
- if (style == SOAP_ENCODED) {
- set_ns_and_type(ret, type);
- }
- return ret;
- }
- static xmlNodePtr to_xml_double(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
- {
- xmlNodePtr ret;
- zval tmp;
- char *str;
- TSRMLS_FETCH();
- ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
- xmlAddChild(parent, ret);
- FIND_ZVAL_NULL(data, ret, style);
- tmp = *data;
- if (Z_TYPE(tmp) != IS_DOUBLE) {
- zval_copy_ctor(&tmp);
- convert_to_double(&tmp);
- }
-
- str = (char *) safe_emalloc(EG(precision), 1, MAX_LENGTH_OF_DOUBLE + 1);
- php_gcvt(Z_DVAL(tmp), EG(precision), '.', 'E', str);
- xmlNodeSetContentLen(ret, BAD_CAST(str), strlen(str));
- efree(str);
- if (style == SOAP_ENCODED) {
- set_ns_and_type(ret, type);
- }
- return ret;
- }
- static zval *to_zval_bool(encodeTypePtr type, xmlNodePtr data)
- {
- zval *ret;
- MAKE_STD_ZVAL(ret);
- FIND_XML_NULL(data, ret);
- if (data && data->children) {
- if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
- whiteSpace_collapse(data->children->content);
- if (stricmp((char*)data->children->content, "true") == 0 ||
- stricmp((char*)data->children->content, "t") == 0 ||
- strcmp((char*)data->children->content, "1") == 0) {
- ZVAL_BOOL(ret, 1);
- } else if (stricmp((char*)data->children->content, "false") == 0 ||
- stricmp((char*)data->children->content, "f") == 0 ||
- strcmp((char*)data->children->content, "0") == 0) {
- ZVAL_BOOL(ret, 0);
- } else {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
- convert_to_boolean(ret);
- }
- } else {
- soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
- }
- } else {
- ZVAL_NULL(ret);
- }
- return ret;
- }
- static xmlNodePtr to_xml_bool(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
- {
- xmlNodePtr ret;
- ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
- xmlAddChild(parent, ret);
- FIND_ZVAL_NULL(data, ret, style);
- if (zend_is_true(data)) {
- xmlNodeSetContent(ret, BAD_CAST("true"));
- } else {
- xmlNodeSetContent(ret, BAD_CAST("false"));
- }
- if (style == SOAP_ENCODED) {
- set_ns_and_type(ret, type);
- }
- return ret;
- }
- /* Null encode/decode */
- static zval *to_zval_null(encodeTypePtr type, xmlNodePtr data)
- {
- zval *ret;
- MAKE_STD_ZVAL(ret);
- ZVAL_NULL(ret);
- return ret;
- }
- static xmlNodePtr to_xml_null(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
- {
- xmlNodePtr ret;
- ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
- xmlAddChild(parent, ret);
- if (style == SOAP_ENCODED) {
- set_xsi_nil(ret);
- }
- return ret;
- }
- static void set_zval_property(zval* object, char* name, zval* val TSRMLS_DC)
- {
- zend_class_entry *old_scope;
- old_scope = EG(scope);
- EG(scope) = Z_OBJCE_P(object);
- #ifdef ZEND_ENGINE_2
- Z_DELREF_P(val);
- #endif
- add_property_zval(object, name, val);
- EG(scope) = old_scope;
- }
- static zval* get_zval_property(zval* object, char* name TSRMLS_DC)
- {
- if (Z_TYPE_P(object) == IS_OBJECT) {
- zval member;
- zval *data;
- zend_class_entry *old_scope;
- INIT_PZVAL(&member);
- ZVAL_STRING(&member, name, 0);
- old_scope = EG(scope);
- EG(scope) = Z_OBJCE_P(object);
- data = Z_OBJ_HT_P(object)->read_property(object, &member, BP_VAR_IS TSRMLS_CC);
- if (data == EG(uninitialized_zval_ptr)) {
- /* Hack for bug #32455 */
- zend_property_info *property_info;
- property_info = zend_get_property_info(Z_OBJCE_P(object), &member, 1 TSRMLS_CC);
- EG(scope) = old_scope;
- if (property_info && zend_hash_quick_exists(Z_OBJPROP_P(object), property_info->name, property_info->name_length+1, property_info->h)) {
- return data;
- }
- return NULL;
- }
- EG(scope) = old_scope;
- return data;
- } else if (Z_TYPE_P(object) == IS_ARRAY) {
- zval **data_ptr;
- if (zend_hash_find(Z_ARRVAL_P(object), name, strlen(name)+1, (void**)&data_ptr) == SUCCESS) {
- return *data_ptr;
- }
- }
- return NULL;
- }
- static void unset_zval_property(zval* object, char* name TSRMLS_DC)
- {
- if (Z_TYPE_P(object) == IS_OBJECT) {
- zval member;
- zend_class_entry *old_scope;
- INIT_PZVAL(&member);
- ZVAL_STRING(&member, name, 0);
- old_scope = EG(scope);
- EG(scope) = Z_OBJCE_P(object);
- Z_OBJ_HT_P(object)->unset_property(object, &member TSRMLS_CC);
- EG(scope) = old_scope;
- } else if (Z_TYPE_P(object) == IS_ARRAY) {
- zend_hash_del(Z_ARRVAL_P(object), name, strlen(name)+1);
- }
- }
- static void model_to_zval_any(zval *ret, xmlNodePtr node TSRMLS_DC)
- {
- zval* any = NULL;
- char* name = NULL;
- while (node != NULL) {
- if (get_zval_property(ret, (char*)node->name TSRMLS_CC) == NULL) {
- zval* val = master_to_zval(get_conversion(XSD_ANYXML), node);
-
- if (any && Z_TYPE_P(any) != IS_ARRAY) {
- /* Convert into array */
- zval *arr;
- MAKE_STD_ZVAL(arr);
- array_init(arr);
- if (name) {
- add_assoc_zval(arr, name, any);
- } else {
- add_next_index_zval(arr, any);
- }
- any = arr;
- }
- if (Z_TYPE_P(val) == IS_STRING && *Z_STRVAL_P(val) == '<') {
- name = NULL;
- while (node->next != NULL) {
- zval* val2 = master_to_zval(get_conversion(XSD_ANYXML), node->next);
- if (Z_TYPE_P(val2) != IS_STRING || *Z_STRVAL_P(val) != '<') {
- break;
- }
- add_string_to_string(val, val, val2);
- zval_ptr_dtor(&val2);
- node = node->next;
- }
- } else {
- name = (char*)node->name;
- }
- if (any == NULL) {
- if (name) {
- /* Convert into array */
- zval *arr;
- MAKE_STD_ZVAL(arr);
- array_init(arr);
- add_assoc_zval(arr, name, val);
- any = arr;
- name = NULL;
- } else {
- any = val;
- }
- } else {
- /* Add array element */
- if (name) {
- zval **el;
- if (zend_hash_find(Z_ARRVAL_P(any), name, strlen(name)+1, (void**)&el) == SUCCESS) {
- if (Z_TYPE_PP(el) != IS_ARRAY) {
- /* Convert into array */
- zval *arr;
-
- MAKE_STD_ZVAL(arr);
- array_init(arr);
- add_next_index_zval(arr, *el);
- *el = arr;
- }
- add_next_index_zval(*el, val);
- } else {
- add_assoc_zval(any, name, val);
- }
- } else {
- add_next_index_zval(any, val);
- }
- name = NULL;
- }
- }
- node = node->next;
- }
- if (any) {
- set_zval_property(ret, name ? name : "any", any TSRMLS_CC);
- }
- }
- static void model_to_zval_object(zval *ret, sdlContentModelPtr model, xmlNodePtr data, sdlPtr sdl TSRMLS_DC)
- {
- switch (model->kind) {
- case XSD_CONTENT_ELEMENT:
- if (model->u.element->name) {
- xmlNodePtr node = get_node(data->children, model->u.element->name);
- if (node) {
- zval *val;
- xmlNodePtr r_node;
- r_node = check_and_resolve_href(node);
- if (r_node && r_node->children && r_node->children->content) {
- if (model->u.element->fixed && strcmp(model->u.element->fixed, (char*)r_node->children->content) != 0) {
- 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);
- }
- val = master_to_zval(model->u.element->encode, r_node);
- } else if (model->u.element->fixed) {
- xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
- xmlNodeSetContent(dummy, BAD_CAST(model->u.element->fixed));
- val = master_to_zval(model->u.element->encode, dummy);
- xmlFreeNode(dummy);
- } else if (model->u.element->def && !model->u.element->nillable) {
- xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
- xmlNodeSetContent(dummy, BAD_CAST(model->u.element->def));
- val = master_to_zval(model->u.element->encode, dummy);
- xmlFreeNode(dummy);
- } else {
- val = master_to_zval(model->u.element->encode, r_node);
- }
- if ((node = get_node(node->next, model->u.element->name)) != NULL) {
- zval *array;
- MAKE_STD_ZVAL(array);
- array_init(array);
- add_next_index_zval(array, val);
- do {
- if (node && node->children && node->children->content) {
- if (model->u.element->fixed && strcmp(model->u.element->fixed, (char*)node->children->content) != 0) {
- 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);
- }
- val = master_to_zval(model->u.element->encode, node);
- } else if (model->u.element->fixed) {
- xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
- xmlNodeSetContent(dummy, BAD_CAST(model->u.element->fixed));
- val = master_to_zval(model->u.element->encode, dummy);
- xmlFreeNode(dummy);
- } else if (model->u.element->def && !model->u.element->nillable) {
- xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
- xmlNodeSetContent(dummy, BAD_CAST(model->u.element->def));
- val = master_to_zval(model->u.element->encode, dummy);
- xmlFreeNode(dummy);
- } else {
- val = master_to_zval(model->u.element->encode, node);
- }
- add_next_index_zval(array, val);
- } while ((node = get_node(node->next, model->u.element->name)) != NULL);
- val = array;
- } else if ((Z_TYPE_P(val) != IS_NULL || !model->u.element->nillable) &&
- (SOAP_GLOBAL(features) & SOAP_SINGLE_ELEMENT_ARRAYS) &&
- (model->max_occurs == -1 || model->max_occurs > 1)) {
- zval *array;
- MAKE_STD_ZVAL(array);
- array_init(array);
- add_next_index_zval(array, val);
- val = array;
- }
- set_zval_property(ret, model->u.element->name, val TSRMLS_CC);
- }
- }
- break;
- case XSD_CONTENT_ALL:
- case XSD_CONTENT_SEQUENCE:
- case XSD_CONTENT_CHOICE: {
- sdlContentModelPtr *tmp;
- HashPosition pos;
- sdlContentModelPtr any = NULL;
- zend_hash_internal_pointer_reset_ex(model->u.content, &pos);
- while (zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos) == SUCCESS) {
- if ((*tmp)->kind == XSD_CONTENT_ANY) {
- any = *tmp;
- } else {
- model_to_zval_object(ret, *tmp, data, sdl TSRMLS_CC);
- }
- zend_hash_move_forward_ex(model->u.content, &pos);
- }
- if (any) {
- model_to_zval_any(ret, data->children TSRMLS_CC);
- }
- break;
- }
- case XSD_CONTENT_GROUP:
- model_to_zval_object(ret, model->u.group->model, data, sdl TSRMLS_CC);
- break;
- default:
- break;
- }
- }
- /* Struct encode/decode */
- static zval *to_zval_object_ex(encodeTypePtr type, xmlNodePtr data, zend_class_entry *pce)
- {
- zval *ret;
- xmlNodePtr trav;
- sdlPtr sdl;
- sdlTypePtr sdlType = type->sdl_type;
- zend_class_entry *ce = ZEND_STANDARD_CLASS_DEF_PTR;
- zval *redo_any = NULL;
- TSRMLS_FETCH();
- if (pce) {
- ce = pce;
- } else if (SOAP_GLOBAL(class_map) && type->type_str) {
- zval **classname;
- zend_class_entry *tmp;
- if (zend_hash_find(SOAP_GLOBAL(class_map), type->type_str, strlen(type->type_str)+1, (void**)&classname) == SUCCESS &&
- Z_TYPE_PP(classname) == IS_STRING &&
- (tmp = zend_fetch_class(Z_STRVAL_PP(classname), Z_STRLEN_PP(classname), ZEND_FETCH_CLASS_AUTO TSRMLS_CC)) != NULL) {
- ce = tmp;
- }
- }
- sdl = SOAP_GLOBAL(sdl);
- if (sdlType) {
- if (sdlType->kind == XSD_TYPEKIND_RESTRICTION &&
- sdlType->encode && type != &sdlType->encode->details) {
- encodePtr enc;
- enc = sdlType->encode;
- while (enc && enc->details.sdl_type &&
- enc->details.sdl_type->kind != XSD_TYPEKIND_SIMPLE &&
- enc->details.sdl_type->kind != XSD_TYPEKIND_LIST &&
- enc->details.sdl_type->kind != XSD_TYPEKIND_UNION) {
- enc = enc->details.sdl_type->encode;
- }
- if (enc) {
- zval *base;
- ALLOC_INIT_ZVAL(ret);
- if (soap_check_xml_ref(&ret, data TSRMLS_CC)) {
- return ret;
- }
- object_init_ex(ret, ce);
- base = master_to_zval_int(enc, data);
- set_zval_property(ret, "_", base TSRMLS_CC);
- } else {
- ALLOC_INIT_ZVAL(ret);
- FIND_XML_NULL(data, ret);
- if (soap_check_xml_ref(&ret, data TSRMLS_CC)) {
- return ret;
- }
- object_init_ex(ret, ce);
- }
- } else if (sdlType->kind == XSD_TYPEKIND_EXTENSION &&
- sdlType->encode &&
- type != &sdlType->encode->details) {
- if (sdlType->encode->details.sdl_type &&
- sdlType->encode->details.sdl_type->kind != XSD_TYPEKIND_SIMPLE &&
- sdlType->encode->details.sdl_type->kind != XSD_TYPEKIND_LIST &&
- sdlType->encode->details.sdl_type->kind != XSD_TYPEKIND_UNION) {
- if (ce != ZEND_STANDARD_CLASS_DEF_PTR &&
- sdlType->encode->to_zval == sdl_guess_convert_zval &&
- sdlType->encode->details.sdl_type != NULL &&
- (sdlType->encode->details.sdl_ty…
Large files files are truncated, but you can click here to view the full file