Find file
Fetching contributors…
Cannot retrieve contributors at this time
3653 lines (3267 sloc) 110 KB
/*
+----------------------------------------------------------------------+
| PHP Version 7 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2016 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$ */
#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(zval* ret, encodeTypePtr type, xmlNodePtr data);
static zval *to_zval_long(zval* ret, encodeTypePtr type, xmlNodePtr data);
static zval *to_zval_bool(zval* ret, encodeTypePtr type, xmlNodePtr data);
static zval *to_zval_string(zval* ret, encodeTypePtr type, xmlNodePtr data);
static zval *to_zval_stringr(zval* ret, encodeTypePtr type, xmlNodePtr data);
static zval *to_zval_stringc(zval* ret, encodeTypePtr type, xmlNodePtr data);
static zval *to_zval_map(zval* ret, encodeTypePtr type, xmlNodePtr data);
static zval *to_zval_null(zval* ret, encodeTypePtr type, xmlNodePtr data);
static zval *to_zval_base64(zval* ret, encodeTypePtr type, xmlNodePtr data);
static zval *to_zval_hexbin(zval* ret, 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(zval *ret, encodeTypePtr type, xmlNodePtr data);
static zval *to_zval_array(zval *ret, 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(zval *ret, 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(zval *ret, 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);
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 CHECK_XML_NULL(xml) \
{ \
xmlAttrPtr null; \
if (!xml) { \
ZVAL_NULL(ret); \
return ret; \
} \
if (xml->properties) { \
null = get_attribute(xml->properties, "nil"); \
if (null) { \
ZVAL_NULL(ret); \
return ret; \
} \
} \
}
#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, NULL}, guess_zval_convert, guess_xml_convert},
{{IS_NULL, "nil", XSI_NAMESPACE, NULL, NULL}, to_zval_null, to_xml_null},
{{IS_STRING, XSD_STRING_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_string, to_xml_string},
{{IS_LONG, XSD_INT_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{IS_DOUBLE, XSD_FLOAT_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_double, to_xml_double},
{{IS_FALSE, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_bool, to_xml_bool},
{{IS_TRUE, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_bool, to_xml_bool},
{{IS_CONSTANT, XSD_STRING_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_string, to_xml_string},
{{IS_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_1_ENC_NAMESPACE, NULL, NULL}, to_zval_array, guess_array_map},
{{IS_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_1_ENC_NAMESPACE, NULL, NULL}, to_zval_object, to_xml_object},
{{IS_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_2_ENC_NAMESPACE, NULL, NULL}, to_zval_array, guess_array_map},
{{IS_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_2_ENC_NAMESPACE, NULL, NULL}, to_zval_object, to_xml_object},
{{XSD_STRING, XSD_STRING_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_string, to_xml_string},
{{XSD_BOOLEAN, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_bool, to_xml_bool},
{{XSD_DECIMAL, XSD_DECIMAL_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
{{XSD_FLOAT, XSD_FLOAT_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_double, to_xml_double},
{{XSD_DOUBLE, XSD_DOUBLE_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_double, to_xml_double},
{{XSD_DATETIME, XSD_DATETIME_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_datetime},
{{XSD_TIME, XSD_TIME_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_time},
{{XSD_DATE, XSD_DATE_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_date},
{{XSD_GYEARMONTH, XSD_GYEARMONTH_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_gyearmonth},
{{XSD_GYEAR, XSD_GYEAR_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_gyear},
{{XSD_GMONTHDAY, XSD_GMONTHDAY_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_gmonthday},
{{XSD_GDAY, XSD_GDAY_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_gday},
{{XSD_GMONTH, XSD_GMONTH_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_gmonth},
{{XSD_DURATION, XSD_DURATION_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_duration},
{{XSD_HEXBINARY, XSD_HEXBINARY_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_hexbin, to_xml_hexbin},
{{XSD_BASE64BINARY, XSD_BASE64BINARY_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_base64, to_xml_base64},
{{XSD_LONG, XSD_LONG_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{XSD_INT, XSD_INT_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{XSD_SHORT, XSD_SHORT_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{XSD_BYTE, XSD_BYTE_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{XSD_NONPOSITIVEINTEGER, XSD_NONPOSITIVEINTEGER_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{XSD_POSITIVEINTEGER, XSD_POSITIVEINTEGER_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{XSD_NONNEGATIVEINTEGER, XSD_NONNEGATIVEINTEGER_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{XSD_NEGATIVEINTEGER, XSD_NEGATIVEINTEGER_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{XSD_UNSIGNEDBYTE, XSD_UNSIGNEDBYTE_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{XSD_UNSIGNEDSHORT, XSD_UNSIGNEDSHORT_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{XSD_UNSIGNEDINT, XSD_UNSIGNEDINT_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{XSD_UNSIGNEDLONG, XSD_UNSIGNEDLONG_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{XSD_INTEGER, XSD_INTEGER_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{XSD_ANYTYPE, XSD_ANYTYPE_STRING, XSD_NAMESPACE, NULL, NULL}, guess_zval_convert, guess_xml_convert},
{{XSD_UR_TYPE, XSD_UR_TYPE_STRING, XSD_NAMESPACE, NULL, NULL}, guess_zval_convert, guess_xml_convert},
{{XSD_ANYURI, XSD_ANYURI_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
{{XSD_QNAME, XSD_QNAME_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
{{XSD_NOTATION, XSD_NOTATION_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
{{XSD_NORMALIZEDSTRING, XSD_NORMALIZEDSTRING_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringr, to_xml_string},
{{XSD_TOKEN, XSD_TOKEN_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
{{XSD_LANGUAGE, XSD_LANGUAGE_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
{{XSD_NMTOKEN, XSD_NMTOKEN_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
{{XSD_NMTOKENS, XSD_NMTOKENS_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_list1},
{{XSD_NAME, XSD_NAME_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
{{XSD_NCNAME, XSD_NCNAME_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
{{XSD_ID, XSD_ID_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
{{XSD_IDREF, XSD_IDREF_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
{{XSD_IDREFS, XSD_IDREFS_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_list1},
{{XSD_ENTITY, XSD_ENTITY_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
{{XSD_ENTITIES, XSD_ENTITIES_STRING, XSD_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_list1},
{{APACHE_MAP, APACHE_MAP_STRING, APACHE_NAMESPACE, NULL, NULL}, to_zval_map, to_xml_map},
{{SOAP_ENC_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_1_ENC_NAMESPACE, NULL, NULL}, to_zval_object, to_xml_object},
{{SOAP_ENC_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_1_ENC_NAMESPACE, NULL, NULL}, to_zval_array, to_xml_array},
{{SOAP_ENC_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_2_ENC_NAMESPACE, NULL, NULL}, to_zval_object, to_xml_object},
{{SOAP_ENC_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_2_ENC_NAMESPACE, NULL, NULL}, to_zval_array, to_xml_array},
/* support some of the 1999 data types */
{{XSD_STRING, XSD_STRING_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_string, to_xml_string},
{{XSD_BOOLEAN, XSD_BOOLEAN_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_bool, to_xml_bool},
{{XSD_DECIMAL, XSD_DECIMAL_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
{{XSD_FLOAT, XSD_FLOAT_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_double, to_xml_double},
{{XSD_DOUBLE, XSD_DOUBLE_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_double, to_xml_double},
{{XSD_LONG, XSD_LONG_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{XSD_INT, XSD_INT_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{XSD_SHORT, XSD_SHORT_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{XSD_BYTE, XSD_BYTE_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_long, to_xml_long},
{{XSD_1999_TIMEINSTANT, XSD_1999_TIMEINSTANT_STRING, XSD_1999_NAMESPACE, NULL, NULL}, to_zval_stringc, to_xml_string},
{{XSD_ANYXML, "<anyXML>", "<anyXML>", NULL, NULL}, to_zval_any, to_xml_any},
{{END_KNOWN_TYPES, NULL, 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) {
encodePtr enc;
ZEND_HASH_FOREACH_PTR(sdl->encoders, enc) {
if (strcmp(enc->details.type_str, type) == 0) {
return enc;
}
} ZEND_HASH_FOREACH_END();
}
return NULL;
}
static zend_bool soap_check_zval_ref(zval *data, xmlNodePtr node) {
xmlNodePtr node_ptr;
if (SOAP_GLOBAL(ref_map)) {
if (Z_TYPE_P(data) == IS_OBJECT) {
data = (zval*)Z_OBJ_P(data);
}
if ((node_ptr = zend_hash_index_find_ptr(SOAP_GLOBAL(ref_map), (zend_ulong)data)) != NULL) {
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 = ZSTR_VAL(prefix.s);
} 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 = ZSTR_VAL(prefix.s);
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 = ZSTR_VAL(prefix.s);
} 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 = ZSTR_VAL(prefix.s);
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_ptr(SOAP_GLOBAL(ref_map), (zend_ulong)data, node);
}
}
return 0;
}
static zend_bool soap_check_xml_ref(zval *data, xmlNodePtr node)
{
zval *data_ptr;
if (SOAP_GLOBAL(ref_map)) {
if ((data_ptr = zend_hash_index_find(SOAP_GLOBAL(ref_map), (zend_ulong)node)) != NULL) {
if (!Z_REFCOUNTED_P(data) ||
!Z_REFCOUNTED_P(data_ptr) ||
Z_COUNTED_P(data) != Z_COUNTED_P(data_ptr)) {
zval_ptr_dtor(data);
ZVAL_COPY(data, data_ptr);
return 1;
}
}
}
return 0;
}
static void soap_add_xml_ref(zval *data, xmlNodePtr node)
{
if (SOAP_GLOBAL(ref_map)) {
zend_hash_index_update(SOAP_GLOBAL(ref_map), (zend_ulong)node, data);
}
}
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;
/* 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 ((ztype = zend_hash_str_find(ht, "enc_type", sizeof("enc_type")-1)) == NULL ||
Z_TYPE_P(ztype) != IS_LONG) {
soap_error0(E_ERROR, "Encoding: SoapVar has no 'enc_type' property");
}
if ((zstype = zend_hash_str_find(ht, "enc_stype", sizeof("enc_stype")-1)) != NULL &&
Z_TYPE_P(zstype) == IS_STRING) {
if ((zns = zend_hash_str_find(ht, "enc_ns", sizeof("enc_ns")-1)) != NULL &&
Z_TYPE_P(zns) == IS_STRING) {
enc = get_encoder(SOAP_GLOBAL(sdl), Z_STRVAL_P(zns), Z_STRVAL_P(zstype));
} else {
zns = NULL;
enc = get_encoder_ex(SOAP_GLOBAL(sdl), Z_STRVAL_P(zstype), Z_STRLEN_P(zstype));
}
if (enc == NULL && SOAP_GLOBAL(typemap)) {
smart_str nscat = {0};
if (zns != NULL) {
smart_str_appendl(&nscat, Z_STRVAL_P(zns), Z_STRLEN_P(zns));
smart_str_appendc(&nscat, ':');
}
smart_str_appendl(&nscat, Z_STRVAL_P(zstype), Z_STRLEN_P(zstype));
smart_str_0(&nscat);
enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s);
smart_str_free(&nscat);
}
}
if (enc == NULL) {
enc = get_conversion(Z_LVAL_P(ztype));
}
if (enc == NULL) {
enc = encode;
}
zdata = zend_hash_str_find(ht, "enc_value", sizeof("enc_value")-1);
node = master_to_xml(enc, zdata, style, parent);
if (style == SOAP_ENCODED || (SOAP_GLOBAL(sdl) && encode != enc)) {
if ((zstype = zend_hash_str_find(ht, "enc_stype", sizeof("enc_stype")-1)) != NULL &&
Z_TYPE_P(zstype) == IS_STRING) {
if ((zns = zend_hash_str_find(ht, "enc_ns", sizeof("enc_ns")-1)) != NULL &&
Z_TYPE_P(zns) == IS_STRING) {
set_ns_and_type_ex(node, Z_STRVAL_P(zns), Z_STRVAL_P(zstype));
} else {
set_ns_and_type_ex(node, NULL, Z_STRVAL_P(zstype));
}
}
}
if ((zname = zend_hash_str_find(ht, "enc_name", sizeof("enc_name")-1)) != NULL &&
Z_TYPE_P(zname) == IS_STRING) {
xmlNodeSetName(node, BAD_CAST(Z_STRVAL_P(zname)));
}
if ((znamens = zend_hash_str_find(ht, "enc_namens", sizeof("enc_namens")-1)) != NULL &&
Z_TYPE_P(znamens) == IS_STRING) {
xmlNsPtr nsp = encode_add_ns(node, Z_STRVAL_P(znamens));
xmlSetNs(node, nsp);
}
} else {
if (check_class_map && SOAP_GLOBAL(class_map) && data &&
Z_TYPE_P(data) == IS_OBJECT &&
!ZEND_HASH_GET_APPLY_COUNT(Z_OBJPROP_P(data))) {
zend_class_entry *ce = Z_OBJCE_P(data);
zval *tmp;
zend_string *type_name;
ZEND_HASH_FOREACH_STR_KEY_VAL(SOAP_GLOBAL(class_map), type_name, tmp) {
if (Z_TYPE_P(tmp) == IS_STRING &&
ZSTR_LEN(ce->name) == Z_STRLEN_P(tmp) &&
zend_binary_strncasecmp(ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), Z_STRVAL_P(tmp), ZSTR_LEN(ce->name), ZSTR_LEN(ce->name)) == 0 &&
type_name) {
/* TODO: namespace isn't stored */
encodePtr enc = NULL;
if (SOAP_GLOBAL(sdl)) {
enc = get_encoder(SOAP_GLOBAL(sdl), SOAP_GLOBAL(sdl)->target_ns, ZSTR_VAL(type_name));
if (!enc) {
enc = find_encoder_by_type_name(SOAP_GLOBAL(sdl), ZSTR_VAL(type_name));
}
}
if (enc) {
if (encode != enc && style == SOAP_LITERAL) {
add_type = 1;
}
encode = enc;
}
break;
}
} ZEND_HASH_FOREACH_END();
}
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 ((new_enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s)) != NULL) {
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(zval *ret, encodePtr encode, xmlNodePtr data)
{
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 ((new_enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s)) != NULL) {
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 ((new_enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s)) != NULL) {
encode = new_enc;
}
smart_str_free(&nscat);
}
}
}
if (encode->to_zval) {
ret = encode->to_zval(ret, &encode->details, data);
}
return ret;
}
zval *master_to_zval(zval *ret, encodePtr encode, xmlNodePtr data)
{
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(ret, encode, data);
}
xmlNodePtr to_xml_user(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
{
xmlNodePtr ret = NULL;
zval return_value;
if (type && type->map && Z_TYPE(type->map->to_xml) != IS_UNDEF) {
ZVAL_NULL(&return_value);
if (call_user_function(EG(function_table), NULL, &type->map->to_xml, &return_value, 1, data) == FAILURE) {
soap_error0(E_ERROR, "Encoding: Error calling to_xml callback");
}
if (Z_TYPE(return_value) == IS_STRING) {
xmlDocPtr doc = soap_xmlParseMemory(Z_STRVAL(return_value), Z_STRLEN(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(zval *ret, encodeTypePtr type, xmlNodePtr node)
{
if (type && type->map && Z_TYPE(type->map->to_zval) != IS_UNDEF) {
xmlBufferPtr buf;
zval data;
xmlNodePtr copy;
copy = xmlCopyNode(node, 1);
buf = xmlBufferCreate();
xmlNodeDump(buf, NULL, copy, 0, 0);
ZVAL_STRING(&data, (char*)xmlBufferContent(buf));
xmlBufferFree(buf);
xmlFreeNode(copy);
if (call_user_function(EG(function_table), NULL, &type->map->to_zval, ret, 1, &data) == FAILURE) {
soap_error0(E_ERROR, "Encoding: Error calling from_xml callback");
} else if (EG(exception)) {
ZVAL_NULL(ret);
}
zval_ptr_dtor(&data);
} else {
ZVAL_NULL(ret);
}
return ret;
}
/* 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(zval *ret, encodeTypePtr type, xmlNodePtr data)
{
ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (data && data->children) {
if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
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));
} else {
ZVAL_STRING(ret, (char*)data->children->content);
}
xmlBufferFree(out);
xmlBufferFree(in);
} else {
ZVAL_STRING(ret, (char*)data->children->content);
}
} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
ZVAL_STRING(ret, (char*)data->children->content);
} else {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
}
} else {
ZVAL_EMPTY_STRING(ret);
}
return ret;
}
static zval *to_zval_stringr(zval *ret, encodeTypePtr type, xmlNodePtr data)
{
ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (data && data->children) {
if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
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));
} else {
ZVAL_STRING(ret, (char*)data->children->content);
}
xmlBufferFree(out);
xmlBufferFree(in);
} else {
ZVAL_STRING(ret, (char*)data->children->content);
}
} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
ZVAL_STRING(ret, (char*)data->children->content);
} else {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
}
} else {
ZVAL_EMPTY_STRING(ret);
}
return ret;
}
static zval *to_zval_stringc(zval *ret, encodeTypePtr type, xmlNodePtr data)
{
ZVAL_NULL(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 (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));
} else {
ZVAL_STRING(ret, (char*)data->children->content);
}
xmlBufferFree(out);
xmlBufferFree(in);
} else {
ZVAL_STRING(ret, (char*)data->children->content);
}
} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
ZVAL_STRING(ret, (char*)data->children->content);
} else {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
}
} else {
ZVAL_EMPTY_STRING(ret);
}
return ret;
}
static zval *to_zval_base64(zval *ret, encodeTypePtr type, xmlNodePtr data)
{
zend_string *str;
ZVAL_NULL(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 = php_base64_decode(data->children->content, strlen((char*)data->children->content));
if (!str) {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
}
ZVAL_STR(ret, str);
} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
str = php_base64_decode(data->children->content, strlen((char*)data->children->content));
if (!str) {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
}
ZVAL_STR(ret, str);
} else {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
}
} else {
ZVAL_EMPTY_STRING(ret);
}
return ret;
}
static zval *to_zval_hexbin(zval *ret, encodeTypePtr type, xmlNodePtr data)
{
zend_string *str;
size_t i, j;
unsigned char c;
ZVAL_NULL(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 = zend_string_alloc(strlen((char*)data->children->content) / 2, 0);
for (i = j = 0; i < ZSTR_LEN(str); i++) {
c = data->children->content[j++];
if (c >= '0' && c <= '9') {
ZSTR_VAL(str)[i] = (c - '0') << 4;
} else if (c >= 'a' && c <= 'f') {
ZSTR_VAL(str)[i] = (c - 'a' + 10) << 4;
} else if (c >= 'A' && c <= 'F') {
ZSTR_VAL(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') {
ZSTR_VAL(str)[i] |= c - '0';
} else if (c >= 'a' && c <= 'f') {
ZSTR_VAL(str)[i] |= c - 'a' + 10;
} else if (c >= 'A' && c <= 'F') {
ZSTR_VAL(str)[i] |= c - 'A' + 10;
} else {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
}
}
ZSTR_VAL(str)[ZSTR_LEN(str)] = '\0';
ZVAL_NEW_STR(ret, str);
} 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;
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 {
zend_string *tmp = zval_get_string(data);
str = estrndup(ZSTR_VAL(tmp), ZSTR_LEN(tmp));
new_len = ZSTR_LEN(tmp);
zend_string_release(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;
zend_string *str;
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));
} else {
zend_string *tmp = zval_get_string(data);
str = php_base64_encode((unsigned char*) ZSTR_VAL(tmp), ZSTR_LEN(tmp));
zend_string_release(tmp);
}
text = xmlNewTextLen(BAD_CAST(ZSTR_VAL(str)), ZSTR_LEN(str));
xmlAddChild(ret, text);
zend_string_release(str);
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;
size_t i, j;
ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(parent, ret);
FIND_ZVAL_NULL(data, ret, style);
if (Z_TYPE_P(data) != IS_STRING) {
ZVAL_STR(&tmp, zval_get_string(data));
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(zval *ret, encodeTypePtr type, xmlNodePtr data)
{
ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (data && data->children) {
if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
zend_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:
ZVAL_DOUBLE(ret, lval);
break;
case IS_DOUBLE:
ZVAL_DOUBLE(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(zval *ret, encodeTypePtr type, xmlNodePtr data)
{
ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (data && data->children) {
if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
zend_long lval;
double dval;
whiteSpace_collapse(data->children->content);
errno = 0;
switch (is_numeric_string((char*)data->children->content, strlen((char*)data->children->content), &lval, &dval, 0)) {
case IS_LONG:
ZVAL_LONG(ret, lval);
break;
case IS_DOUBLE:
ZVAL_DOUBLE(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 {
zend_string *str = zend_long_to_str(zval_get_long(data));
xmlNodeSetContentLen(ret, BAD_CAST(ZSTR_VAL(str)), ZSTR_LEN(str));
zend_string_release(str);
}
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;
ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(parent, ret);
FIND_ZVAL_NULL(data, ret, style);
ZVAL_DOUBLE(&tmp, zval_get_double(data));
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(zval *ret, encodeTypePtr type, xmlNodePtr data)
{
ZVAL_NULL(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_TRUE(ret);
} else if (stricmp((char*)data->children->content, "false") == 0 ||
stricmp((char*)data->children->content, "f") == 0 ||
strcmp((char*)data->children->content, "0") == 0) {
ZVAL_FALSE(ret);
} else {
ZVAL_STRING(ret, (char*)data->children->content);
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(zval *ret, encodeTypePtr type, xmlNodePtr data)
{
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)
{
zend_update_property(Z_OBJCE_P(object), object, name, strlen(name), val);
if (Z_REFCOUNTED_P(val)) Z_DELREF_P(val);
}
static zval* get_zval_property(zval* object, char* name, zval *rv)
{
if (Z_TYPE_P(object) == IS_OBJECT) {
zval member;
zval *data;
zend_class_entry *old_scope;
ZVAL_STRING(&member, name);
old_scope = EG(fake_scope);
EG(fake_scope) = Z_OBJCE_P(object);
data = Z_OBJ_HT_P(object)->read_property(object, &member, BP_VAR_IS, NULL, rv);
if (data == &EG(uninitialized_zval)) {
/* Hack for bug #32455 */
zend_property_info *property_info;
property_info = zend_get_property_info(Z_OBJCE_P(object), Z_STR(member), 1);
EG(fake_scope) = old_scope;
if (property_info != ZEND_WRONG_PROPERTY_INFO && property_info &&
zend_hash_exists(Z_OBJPROP_P(object), property_info->name)) {
zval_ptr_dtor(&member);
return data;
}
zval_ptr_dtor(&member);
return NULL;
}
zval_ptr_dtor(&member);
EG(fake_scope) = old_scope;
return data;
} else if (Z_TYPE_P(object) == IS_ARRAY) {
zval *data_ptr;
if ((data_ptr = zend_hash_str_find(Z_ARRVAL_P(object), name, strlen(name))) != NULL) {
return data_ptr;
}
}
return NULL;
}
static void unset_zval_property(zval* object, char* name)
{
if (Z_TYPE_P(object) == IS_OBJECT) {
zval member;
zend_class_entry *old_scope;
ZVAL_STRING(&member, name);
old_scope = EG(fake_scope);
EG(fake_scope) = Z_OBJCE_P(object);
Z_OBJ_HT_P(object)->unset_property(object, &member, NULL);
EG(fake_scope) = old_scope;
zval_ptr_dtor(&member);
} else if (Z_TYPE_P(object) == IS_ARRAY) {
zend_hash_str_del(Z_ARRVAL_P(object), name, strlen(name));
}
}
static void model_to_zval_any(zval *ret, xmlNodePtr node)
{
zval rv, arr, val;
zval* any = NULL;
char* name = NULL;
while (node != NULL) {
if (get_zval_property(ret, (char*)node->name, &rv) == NULL) {
ZVAL_NULL(&val);
master_to_zval(&val, get_conversion(XSD_ANYXML), node);
if (any && Z_TYPE_P(any) != IS_ARRAY) {
/* Convert into array */
array_init(&arr);
if (name) {
add_assoc_zval(&arr, name, any);
} else {
add_next_index_zval(&arr, any);
}
any = &arr;
}
if (Z_TYPE(val) == IS_STRING && *Z_STRVAL(val) == '<') {
name = NULL;
while (node->next != NULL) {
zval val2;
ZVAL_NULL(&val2);
master_to_zval(&val2, get_conversion(XSD_ANYXML), node->next);
if (Z_TYPE(val2) != IS_STRING || *Z_STRVAL(val) != '<') {
break;
}
concat_function(&val, &val, &val2);
zval_ptr_dtor(&val2);
node = node->next;
}
} else {
name = (char*)node->name;
}
if (any == NULL) {
if (name) {
/* Convert into array */
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 ((el = zend_hash_str_find(Z_ARRVAL_P(any), name, strlen(name))) != NULL) {
if (Z_TYPE_P(el) != IS_ARRAY) {
/* Convert into array */
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);
}
}
static void model_to_zval_object(zval *ret, sdlContentModelPtr model, xmlNodePtr data, sdlPtr sdl)
{
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;
ZVAL_NULL(&val);
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);
}
master_to_zval(&val, 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));
master_to_zval(&val, 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));
master_to_zval(&val, model->u.element->encode, dummy);
xmlFreeNode(dummy);
} else {
master_to_zval(&val, model->u.element->encode, r_node);
}
if ((node = get_node(node->next, model->u.element->name)) != NULL) {
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);
}
master_to_zval(&val, 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));
master_to_zval(&val, 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));
master_to_zval(&val, model->u.element->encode, dummy);
xmlFreeNode(dummy);
} else {
master_to_zval(&val, model->u.element->encode, node);
}
add_next_index_zval(&array, &val);
} while ((node = get_node(node->next, model->u.element->name)) != NULL);
ZVAL_COPY_VALUE(&val, &array);
} else if ((Z_TYPE(val) != IS_NULL || !model->u.element->nillable) &&
(SOAP_GLOBAL(features) & SOAP_SINGLE_ELEMENT_ARRAYS) &&
(model->max_occurs == -1 || model->max_occurs > 1)) {
zval array;
array_init(&array);
add_next_index_zval(&array, &val);
ZVAL_COPY_VALUE(&val, &array);
}
set_zval_property(ret, model->u.element->name, &val);
}
}
break;
case XSD_CONTENT_ALL:
case XSD_CONTENT_SEQUENCE:
case XSD_CONTENT_CHOICE: {
sdlContentModelPtr tmp;
sdlContentModelPtr any = NULL;
ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
if (tmp->kind == XSD_CONTENT_ANY) {
any = tmp;
} else {
model_to_zval_object(ret, tmp, data, sdl);
}
} ZEND_HASH_FOREACH_END();
if (any) {
model_to_zval_any(ret, data->children);
}
break;
}
case XSD_CONTENT_GROUP:
model_to_zval_object(ret, model->u.group->model, data, sdl);
break;
default:
break;
}
}
/* Struct encode/decode */
static zval *to_zval_object_ex(zval *ret, encodeTypePtr type, xmlNodePtr data, zend_class_entry *pce)
{
xmlNodePtr trav;
sdlPtr sdl;
sdlTypePtr sdlType = type->sdl_type;
zend_class_entry *ce = ZEND_STANDARD_CLASS_DEF_PTR;
zval *redo_any = NULL, rv, arr;
if (pce) {
ce = pce;
} else if (SOAP_GLOBAL(class_map) && type->type_str) {
zval *classname;
zend_class_entry *tmp;
if ((classname = zend_hash_str_find(SOAP_GLOBAL(class_map), type->type_str, strlen(type->type_str))) != NULL &&
Z_TYPE_P(classname) == IS_STRING &&
(tmp = zend_fetch_class(Z_STR_P(classname), ZEND_FETCH_CLASS_AUTO)) != 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;
ZVAL_NULL(ret);
if (soap_check_xml_ref(ret, data)) {
return ret;
}
object_init_ex(ret, ce);
master_to_zval_int(&base, enc, data);
set_zval_property(ret, "_", &base);
} else {
ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (soap_check_xml_ref(ret, data)) {
return ret;
}
object_init_ex(ret, ce);
soap_add_xml_ref(ret, data);
}
} 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) {
CHECK_XML_NULL(data);
if (soap_check_xml_ref(ret, data)) {
return ret;
}
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_type->kind == XSD_TYPEKIND_COMPLEX ||
sdlType->encode->details.sdl_type->kind == XSD_TYPEKIND_RESTRICTION ||
sdlType->encode->details.sdl_type->kind == XSD_TYPEKIND_EXTENSION) &&
(sdlType->encode->details.sdl_type->encode == NULL ||
(sdlType->encode->details.sdl_type->encode->details.type != IS_ARRAY &&
sdlType->encode->details.sdl_type->encode->details.type != SOAP_ENC_ARRAY))) {
to_zval_object_ex(ret, &sdlType->encode->details, data, ce);
} else {
master_to_zval_int(ret, sdlType->encode, data);
}
soap_add_xml_ref(ret, data);
redo_any = get_zval_property(ret, "any", &rv);
if (Z_TYPE_P(ret) == IS_OBJECT && ce != ZEND_STANDARD_CLASS_DEF_PTR) {
zend_object *zobj = Z_OBJ_P(ret);
zobj->ce = ce;
}
} else {
zval base;
ZVAL_NULL(ret);
if (soap_check_xml_ref(ret, data)) {
return ret;
}
object_init_ex(ret, ce);
soap_add_xml_ref(ret, data);
master_to_zval_int(&base, sdlType->encode, data);
set_zval_property(ret, "_", &base);
}
} else {
ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (soap_check_xml_ref(ret, data)) {
return ret;
}
object_init_ex(ret, ce);
soap_add_xml_ref(ret, data);
}
if (sdlType->model) {
model_to_zval_object(ret, sdlType->model, data, sdl);
if (redo_any) {
if (!get_zval_property(ret, "any", &rv)) {
model_to_zval_any(ret, data->children);
soap_add_xml_ref(ret, data);
} else {
unset_zval_property(ret, "any");
}
}
}
if (sdlType->attributes) {
sdlAttributePtr attr;
ZEND_HASH_FOREACH_PTR(sdlType->attributes, attr) {
if (attr->name) {
xmlAttrPtr val = get_attribute(data->properties, attr->name);
char *str_val = NULL;
if (val && val->children && val->children->content) {
str_val = (char*)val->children->content;
if (attr->fixed && strcmp(attr->fixed, str_val) != 0) {
soap_error3(E_ERROR, "Encoding: Attribute '%s' has fixed value '%s' (value '%s' is not allowed)", attr->name, attr->fixed, str_val);
}
} else if (attr->fixed) {
str_val = attr->fixed;
} else if (attr->def) {
str_val = attr->def;
}
if (str_val) {
xmlNodePtr dummy, text;
zval data;
dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
text = xmlNewText(BAD_CAST(str_val));
xmlAddChild(dummy, text);
ZVAL_NULL(&data);
master_to_zval(&data, attr->encode, dummy);
xmlFreeNode(dummy);
set_zval_property(ret, attr->name, &data);
}
}
} ZEND_HASH_FOREACH_END();
}
} else {
ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (soap_check_xml_ref(ret, data)) {
return ret;
}
object_init_ex(ret, ce);
soap_add_xml_ref(ret, data);
trav = data->children;
while (trav != NULL) {
if (trav->type == XML_ELEMENT_NODE) {
zval tmpVal, rv;
zval *prop;
ZVAL_NULL(&tmpVal);
master_to_zval(&tmpVal, NULL, trav);
prop = get_zval_property(ret, (char*)trav->name, &rv);
if (!prop) {
if (!trav->next || !get_node(trav->next, (char*)trav->name)) {
set_zval_property(ret, (char*)trav->name, &tmpVal);
} else {
zval arr;
array_init(&arr);
add_next_index_zval(&arr, &tmpVal);
set_zval_property(ret, (char*)trav->name, &arr);
}
} else {
/* Property already exist - make array */
if (Z_TYPE_P(prop) != IS_ARRAY) {
/* Convert into array */
array_init(&arr);
Z_ADDREF_P(prop);
add_next_index_zval(&arr, prop);
set_zval_property(ret, (char*)trav->name, &arr);
prop = &arr;
}
/* Add array element */
add_next_index_zval(prop, &tmpVal);
}
}
trav = trav->next;
}
}
return ret;
}
static zval *to_zval_object(zval *ret, encodeTypePtr type, xmlNodePtr data)
{
return to_zval_object_ex(ret, type, data, NULL);
}
static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval *object, int style, int strict)
{
switch (model->kind) {
case XSD_CONTENT_ELEMENT: {
zval *data;
xmlNodePtr property;
encodePtr enc;
zval rv;
data = get_zval_property(object, model->u.element->name, &rv);
if (data &&
Z_TYPE_P(data) == IS_NULL &&
!model->u.element->nillable &&
model->min_occurs > 0 &&
!strict) {
return 0;
}
if (data) {
enc = model->u.element->encode;
if ((model->max_occurs == -1 || model->max_occurs > 1) &&
Z_TYPE_P(data) == IS_ARRAY &&
!is_map(data)) {
HashTable *ht = Z_ARRVAL_P(data);
zval *val;
ZEND_HASH_FOREACH_VAL(ht, val) {
if (Z_TYPE_P(val) == IS_NULL && model->u.element->nillable) {
property = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(node, property);
set_xsi_nil(property);
} else {
property = master_to_xml(enc, val, style, node);
if (property->children && property->children->content &&
model->u.element->fixed && strcmp(model->u.element->fixed, (char*)property->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, property->children->content);
}
}
xmlNodeSetName(property, BAD_CAST(model->u.element->name));
if (style == SOAP_LITERAL &&
model->u.element->namens &&
model->u.element->form == XSD_FORM_QUALIFIED) {
xmlNsPtr nsp = encode_add_ns(property, model->u.element->namens);
xmlSetNs(property, nsp);
}
} ZEND_HASH_FOREACH_END();
} else {
if (Z_TYPE_P(data) == IS_NULL && model->u.element->nillable) {
property = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(node, property);
set_xsi_nil(property);
} else if (Z_TYPE_P(data) == IS_NULL && model->min_occurs == 0) {
return 1;
} else {
property = master_to_xml(enc, data, style, node);
if (property->children && property->children->content &&
model->u.element->fixed && strcmp(model->u.element->fixed, (char*)property->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, property->children->content);
}
}
xmlNodeSetName(property, BAD_CAST(model->u.element->name));
if (style == SOAP_LITERAL &&
model->u.element->namens &&
model->u.element->form == XSD_FORM_QUALIFIED) {
xmlNsPtr nsp = encode_add_ns(property, model->u.element->namens);
xmlSetNs(property, nsp);
}
}
return 1;
} else if (strict && model->u.element->nillable && model->min_occurs > 0) {
property = xmlNewNode(NULL, BAD_CAST(model->u.element->name));
xmlAddChild(node, property);
set_xsi_nil(property);
if (style == SOAP_LITERAL &&
model->u.element->namens &&
model->u.element->form == XSD_FORM_QUALIFIED) {
xmlNsPtr nsp = encode_add_ns(property, model->u.element->namens);
xmlSetNs(property, nsp);
}
return 1;
} else if (model->min_occurs == 0) {
return 2;
} else {
if (strict) {
soap_error1(E_ERROR, "Encoding: object has no '%s' property", model->u.element->name);
}
return 0;
}
break;
}
case XSD_CONTENT_ANY: {
zval *data;
encodePtr enc;
zval rv;
data = get_zval_property(object, "any", &rv);
if (data) {
enc = get_conversion(XSD_ANYXML);
if ((model->max_occurs == -1 || model->max_occurs > 1) &&
Z_TYPE_P(data) == IS_ARRAY &&
!is_map(data)) {
HashTable *ht = Z_ARRVAL_P(data);
zval *val;
ZEND_HASH_FOREACH_VAL(ht, val) {
master_to_xml(enc, val, style, node);
} ZEND_HASH_FOREACH_END();
} else {
master_to_xml(enc, data, style, node);
}
return 1;
} else if (model->min_occurs == 0) {
return 2;
} else {
if (strict) {
soap_error0(E_ERROR, "Encoding: object has no 'any' property");
}
return 0;
}
break;
}
case XSD_CONTENT_SEQUENCE:
case XSD_CONTENT_ALL: {
sdlContentModelPtr tmp;
ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
if (!model_to_xml_object(node, tmp, object, style, strict && (tmp->min_occurs > 0))) {
if (!strict || tmp->min_occurs > 0) {
return 0;
}
}
strict = 1;
} ZEND_HASH_FOREACH_END();
return 1;
}
case XSD_CONTENT_CHOICE: {
sdlContentModelPtr tmp;
int ret = 0;
ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
int tmp_ret = model_to_xml_object(node, tmp, object, style, 0);
if (tmp_ret == 1) {
return 1;
} else if (tmp_ret != 0) {
ret = 1;
}
} ZEND_HASH_FOREACH_END();
return ret;
}
case XSD_CONTENT_GROUP: {
return model_to_xml_object(node, model->u.group->model, object, style, strict && model->min_occurs > 0);
}
default:
break;
}
return 1;
}
static sdlTypePtr model_array_element(sdlContentModelPtr model)
{
switch (model->kind) {
case XSD_CONTENT_ELEMENT: {
if (model->max_occurs == -1 || model->max_occurs > 1) {
return model->u.element;
} else {
return NULL;
}
}
case XSD_CONTENT_SEQUENCE:
case XSD_CONTENT_ALL:
case XSD_CONTENT_CHOICE: {
sdlContentModelPtr tmp;
if (zend_hash_num_elements(model->u.content) != 1) {
return NULL;
}
ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
return model_array_element(tmp);
} ZEND_HASH_FOREACH_END();
}
case XSD_CONTENT_GROUP: {
return model_array_element(model->u.group->model);
}
default:
break;
}
return NULL;
}
static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
{
xmlNodePtr xmlParam;
HashTable *prop = NULL;
sdlTypePtr sdlType = type->sdl_type;
if (!data || Z_TYPE_P(data) == IS_NULL) {
xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(parent, xmlParam);
if (style == SOAP_ENCODED) {
set_xsi_nil(xmlParam);
set_ns_and_type(xmlParam, type);
}
return xmlParam;
}
if (Z_TYPE_P(data) == IS_OBJECT) {
prop = Z_OBJPROP_P(data);
} else if (Z_TYPE_P(data) == IS_ARRAY) {
prop = Z_ARRVAL_P(data);
}
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 rv;
zval *tmp = get_zval_property(data, "_", &rv);
if (tmp) {
xmlParam = master_to_xml(enc, tmp, style, parent);
} else if (prop == NULL) {
xmlParam = master_to_xml(enc, data, style, parent);
} else {
xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(parent, xmlParam);
}
} else {
xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(parent, xmlParam);
}
} 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 (prop) ZEND_HASH_INC_APPLY_COUNT(prop);
xmlParam = master_to_xml(sdlType->encode, data, style, parent);
if (prop) ZEND_HASH_DEC_APPLY_COUNT(prop);
} else {
zval rv;
zval *tmp = get_zval_property(data, "_", &rv);
if (tmp) {
xmlParam = master_to_xml(sdlType->encode, tmp, style, parent);
} else if (prop == NULL) {
xmlParam = master_to_xml(sdlType->encode, data, style, parent);
} else {
xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(parent, xmlParam);
}
}
} else {
xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(parent, xmlParam);
}
if (soap_check_zval_ref(data, xmlParam)) {
return xmlParam;
}
if (prop != NULL) {
sdlTypePtr array_el;
if (Z_TYPE_P(data) == IS_ARRAY &&
!is_map(data) &&
sdlType->attributes == NULL &&
sdlType->model != NULL &&
(array_el = model_array_element(sdlType->model)) != NULL) {
zval *val;
ZEND_HASH_FOREACH_VAL(prop, val) {
xmlNodePtr property;
if (Z_TYPE_P(val) == IS_NULL && array_el->nillable) {
property = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(xmlParam, property);
set_xsi_nil(property);
} else {
property = master_to_xml(array_el->encode, val, style, xmlParam);
}
xmlNodeSetName(property, BAD_CAST(array_el->name));
if (style == SOAP_LITERAL &&
array_el->namens &&
array_el->form == XSD_FORM_QUALIFIED) {
xmlNsPtr nsp = encode_add_ns(property, array_el->namens);
xmlSetNs(property, nsp);
}
} ZEND_HASH_FOREACH_END();
} else if (sdlType->model) {
model_to_xml_object(xmlParam, sdlType->model, data, style, 1);
}
if (sdlType->attributes) {
sdlAttributePtr attr;
zval *zattr, rv;
ZEND_HASH_FOREACH_PTR(sdlType->attributes, attr) {
if (attr->name) {
zattr = get_zval_property(data, attr->name, &rv);
if (zattr) {
xmlNodePtr dummy;
dummy = master_to_xml(attr->encode, zattr, SOAP_LITERAL, xmlParam);
if (dummy->children && dummy->children->content) {
if (attr->fixed && strcmp(attr->fixed, (char*)dummy->children->content) != 0) {
soap_error3(E_ERROR, "Encoding: Attribute '%s' has fixed value '%s' (value '%s' is not allowed)", attr->name, attr->fixed, dummy->children->content);
}
/* we need to handle xml: namespace specially, since it is
an implicit schema. Otherwise, use form.
*/
if (attr->namens &&
(!strncmp(attr->namens, XML_NAMESPACE, sizeof(XML_NAMESPACE)) ||
attr->form == XSD_FORM_QUALIFIED)) {
xmlNsPtr nsp = encode_add_ns(xmlParam, attr->namens);
xmlSetNsProp(xmlParam, nsp, BAD_CAST(attr->name), dummy->children->content);
} else {
xmlSetProp(xmlParam, BAD_CAST(attr->name), dummy->children->content);
}
}
xmlUnlinkNode(dummy);
xmlFreeNode(dummy);
}
}
} ZEND_HASH_FOREACH_END();
}
}
if (style == SOAP_ENCODED) {
set_ns_and_type(xmlParam, type);
}
} else {
xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(parent, xmlParam);
if (soap_check_zval_ref(data, xmlParam)) {
return xmlParam;
}
if (prop != NULL) {
zval *zprop;
zend_string *str_key;
xmlNodePtr property;
ZEND_HASH_FOREACH_STR_KEY_VAL_IND(prop, str_key, zprop) {
property = master_to_xml(get_conversion(Z_TYPE_P(zprop)), zprop, style, xmlParam);
if (str_key) {
const char *prop_name;
if (Z_TYPE_P(data) == IS_OBJECT) {
const char *class_name;
zend_unmangle_property_name(str_key, &class_name, &prop_name);
} else {
prop_name = ZSTR_VAL(str_key);
}
if (prop_name) {
xmlNodeSetName(property, BAD_CAST(prop_name));
}
}
} ZEND_HASH_FOREACH_END();
}
if (style == SOAP_ENCODED) {
set_ns_and_type(xmlParam, type);
}
}
return xmlParam;
}
/* Array encode/decode */
static xmlNodePtr guess_array_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
{
encodePtr enc = NULL;
if (data && Z_TYPE_P(data) == IS_ARRAY) {
if (is_map(data)) {
enc = get_conversion(APACHE_MAP);
} else {
enc = get_conversion(SOAP_ENC_ARRAY);
}
}
if (!enc) {
enc = get_conversion(IS_NULL);
}
return master_to_xml(enc, data, style, parent);
}
static int calc_dimension_12(const char* str)
{
int i = 0, flag = 0;
while (*str != '\0' && (*str < '0' || *str > '9') && (*str != '*')) {
str++;
}
if (*str == '*') {
i++;
str++;
}
while (*str != '\0') {
if (*str >= '0' && *str <= '9') {
if (flag == 0) {
i++;
flag = 1;
}
} else if (*str == '*') {
soap_error0(E_ERROR, "Encoding: '*' may only be first arraySize value in list");
} else {
flag = 0;
}
str++;
}
return i;
}
static int* get_position_12(int dimension, const char* str)
{
int *pos;
int i = -1, flag = 0;
pos = safe_emalloc(sizeof(int), dimension, 0);
memset(pos,0,sizeof(int)*dimension);
while (*str != '\0' && (*str < '0' || *str > '9') && (*str != '*')) {
str++;
}
if (*str == '*') {
str++;
i++;
}
while (*str != '\0') {
if (*str >= '0' && *str <= '9') {
if (flag == 0) {
i++;
flag = 1;
}
pos[i] = (pos[i]*10)+(*str-'0');
} else if (*str == '*') {
soap_error0(E_ERROR, "Encoding: '*' may only be first arraySize value in list");
} else {
flag = 0;
}
str++;
}
return pos;
}
static int calc_dimension(const char* str)
{
int i = 1;
while (*str != ']' && *str != '\0') {
if (*str == ',') {
i++;
}
str++;
}
return i;
}
static void get_position_ex(int dimension, const char* str, int** pos)
{
int i = 0;
memset(*pos,0,sizeof(int)*dimension);
while (*str != ']' && *str != '\0' && i < dimension) {
if (*str >= '0' && *str <= '9') {
(*pos)[i] = ((*pos)[i]*10)+(*str-'0');
} else if (*str == ',') {
i++;
}
str++;
}
}
static int* get_position(int dimension, const char* str)
{
int *pos;
pos = safe_emalloc(sizeof(int), dimension, 0);
get_position_ex(dimension, str, &pos);
return pos;
}
static void add_xml_array_elements(xmlNodePtr xmlParam,
sdlTypePtr type,
encodePtr enc,
xmlNsPtr ns,
int dimension ,
int* dims,
zval* data,
int style
)
{
int j = 0;
zval *zdata;
xmlNodePtr xparam;
if (data && Z_TYPE_P(data) == IS_ARRAY) {
ZEND_HASH_FOREACH_VAL_IND(Z_ARRVAL_P(data), zdata) {
if (j >= dims[0]) {
break;
}
if (dimension == 1) {
if (enc == NULL) {
xparam = master_to_xml(get_conversion(Z_TYPE_P(zdata)), zdata, style, xmlParam);
} else {
xparam = master_to_xml(enc, zdata, style, xmlParam);
}
if (type) {
xmlNodeSetName(xparam, BAD_CAST(type->name));
} else if (style == SOAP_LITERAL && enc && enc->details.type_str) {
xmlNodeSetName(xparam, BAD_CAST(enc->details.type_str));
xmlSetNs(xparam, ns);
} else {
xmlNodeSetName(xparam, BAD_CAST("item"));
}
} else {
add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, zdata, style);
}
j++;
} ZEND_HASH_FOREACH_END();
if (dimension == 1) {
while (j < dims[0]) {
xparam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(xmlParam, xparam);
if (type) {
xmlNodeSetName(xparam, BAD_CAST(type->name));
} else if (style == SOAP_LITERAL && enc && enc->details.type_str) {
xmlNodeSetName(xparam, BAD_CAST(enc->details.type_str));
xmlSetNs(xparam, ns);
} else {
xmlNodeSetName(xparam, BAD_CAST("item"));
}
j++;
}
} else {
while (j < dims[0]) {
add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, NULL, style);
j++;
}
}
} else {
for (j=0; j<dims[0]; j++) {
if (dimension == 1) {
xmlNodePtr xparam;
xparam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(xmlParam, xparam);
if (type) {
xmlNodeSetName(xparam, BAD_CAST(type->name));
} else if (style == SOAP_LITERAL && enc && enc->details.type_str) {
xmlNodeSetName(xparam, BAD_CAST(enc->details.type_str));
xmlSetNs(xparam, ns);
} else {
xmlNodeSetName(xparam, BAD_CAST("item"));
}
} else {
add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, NULL, style);
}
}
}
}
static inline int array_num_elements(HashTable* ht)
{
if (ht->nNumUsed &&
Z_TYPE(ht->arData[ht->nNumUsed-1].val) != IS_UNDEF &&
ht->arData[ht->nNumUsed-1].key == NULL) {
return ht->arData[ht->nNumUsed-1].h - 1;
}
return 0;
}
static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
{
sdlTypePtr sdl_type = type->sdl_type;
sdlTypePtr element_type = NULL;
smart_str array_type = {0}, array_size = {0};
int i;
xmlNodePtr xmlParam;
encodePtr enc = NULL;
int dimension = 1;
int* dims;
int soap_version;
zval array_copy;
ZVAL_UNDEF(&array_copy);
soap_version = SOAP_GLOBAL(soap_version);
xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(parent, xmlParam);
if (!data || Z_TYPE_P(data) == IS_NULL) {
if (style == SOAP_ENCODED) {
set_xsi_nil(xmlParam);
if (SOAP_GLOBAL(features) & SOAP_USE_XSI_ARRAY_TYPE) {
set_ns_and_type_ex(xmlParam, (soap_version == SOAP_1_1) ? SOAP_1_1_ENC_NAMESPACE : SOAP_1_2_ENC_NAMESPACE, "Array");
} else {
set_ns_and_type(xmlParam, type);
}
}
return xmlParam;
}
if (Z_TYPE_P(data) == IS_OBJECT && instanceof_function(Z_OBJCE_P(data), zend_ce_traversable)) {
zend_object_iterator *iter;
zend_class_entry *ce = Z_OBJCE_P(data);
zval *val;
array_init(&array_copy);
iter = ce->get_iterator(ce, data, 0);
if (EG(exception)) {
goto iterator_done;
}
if (iter->funcs->rewind) {
iter->funcs->rewind(iter);
if (EG(exception)) {
goto iterator_done;
}
}
while (iter->funcs->valid(iter) == SUCCESS) {
if (EG(exception)) {
goto iterator_done;
}
val = iter->funcs->get_current_data(iter);
if (EG(exception)) {
goto iterator_done;
}
if (iter->funcs->get_current_key) {
zval key;
iter->funcs->get_current_key(iter, &key);
if (EG(exception)) {
goto iterator_done;
}
array_set_zval_key(Z_ARRVAL(array_copy), &key, val);
zval_ptr_dtor(val);
zval_dtor(&key);
} else {
add_next_index_zval(&array_copy, val);
}
Z_ADDREF_P(val);
iter->funcs->move_forward(iter);
if (EG(exception)) {
goto iterator_done;
}
}
iterator_done:
OBJ_RELEASE(&iter->std);
if (EG(exception)) {
zval_ptr_dtor(&array_copy);
ZVAL_UNDEF(&array_copy);
} else {
data = &array_copy;
}
}
if (Z_TYPE_P(data) == IS_ARRAY) {
sdlAttributePtr arrayType;
sdlExtraAttributePtr ext;
sdlTypePtr elementType;
i = zend_hash_num_elements(Z_ARRVAL_P(data));
if (sdl_type &&
sdl_type->attributes &&
(arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType",
sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType")-1)) != NULL &&
arrayType->extraAttributes &&
(ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType")-1)) != NULL) {
char *value, *end;
zval *el;
value = estrdup(ext->val);
end = strrchr(value,'[');
if (end) {
*end = '\0';
end++;
dimension = calc_dimension(end);
}
if (ext->ns != NULL) {
enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, value);
get_type_str(xmlParam, ext->ns, value, &array_type);
} else {
smart_str_appends(&array_type, value);
}
dims = safe_emalloc(sizeof(int), dimension, 0);
dims[0] = i;
el = data;
for (i = 1; i < dimension; i++) {
if (el != NULL && Z_TYPE_P(el) == IS_ARRAY &&
zend_hash_num_elements(Z_ARRVAL_P(el)) > 0) {
ZEND_HASH_FOREACH_VAL_IND(Z_ARRVAL_P(el), el) {
break;
} ZEND_HASH_FOREACH_END();
if (Z_TYPE_P(el) == IS_ARRAY) {
dims[i] = zend_hash_num_elements(Z_ARRVAL_P(el));
} else {
dims[i] = 0;
}
}
}
smart_str_append_long(&array_size, dims[0]);
for (i=1; i<dimension; i++) {
smart_str_appendc(&array_size, ',');
smart_str_append_long(&array_size, dims[i]);
}
efree(value);
} else if (sdl_type &&
sdl_type->attributes &&
(arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType",
sizeof(SOAP_1_2_ENC_NAMESPACE":itemType")-1)) != NULL &&
arrayType->extraAttributes &&
(ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":itemType")-1)) != NULL) {
if (ext->ns != NULL) {
enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, ext->val);
get_type_str(xmlParam, ext->ns, ext->val, &array_type);
} else {
smart_str_appends(&array_type, ext->val);
}
if ((arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL &&
arrayType->extraAttributes &&
(ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize")-1)) != NULL) {
dimension = calc_dimension_12(ext->val);
dims = get_position_12(dimension, ext->val);
if (dims[0] == 0) {dims[0] = i;}
smart_str_append_long(&array_size, dims[0]);
for (i=1; i<dimension; i++) {
smart_str_appendc(&array_size, ',');
smart_str_append_long(&array_size, dims[i]);
}
} else {
dims = emalloc(sizeof(int));
*dims = 0;
smart_str_append_long(&array_size, i);
}
} else if (sdl_type &&
sdl_type->attributes &&
(arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL &&
arrayType->extraAttributes &&
(ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraySize")-1)) != NULL) {
dimension = calc_dimension_12(ext->val);
dims = get_position_12(dimension, ext->val);
if (dims[0] == 0) {dims[0] = i;}
smart_str_append_long(&array_size, dims[0]);
for (i=1; i<dimension; i++) {
smart_str_appendc(&array_size, ',');
smart_str_append_long(&array_size, dims[i]);
}
if (sdl_type && sdl_type->elements &&
zend_hash_num_elements(sdl_type->elements) == 1 &&
(zend_hash_internal_pointer_reset(sdl_type->elements),
(elementType = zend_hash_get_current_data_ptr(sdl_type->elements)) != NULL) &&
elementType->encode && elementType->encode->details.type_str) {
element_type = elementType;
enc = elementType->encode;
get_type_str(xmlParam, elementType->encode->details.ns, elementType->encode->details.type_str, &array_type);
} else {
enc = get_array_type(xmlParam, data, &array_type);
}
} else if (sdl_type && sdl_type->elements &&
zend_hash_num_elements(sdl_type->elements) == 1 &&
(zend_hash_internal_pointer_reset(sdl_type->elements),
(elementType = zend_hash_get_current_data_ptr(sdl_type->elements)) != NULL) &&
elementType->encode && elementType->encode->details.type_str) {
element_type = elementType;
enc = elementType->encode;
get_type_str(xmlParam, elementType->encode->details.ns, elementType->encode->details.type_str, &array_type);
smart_str_append_long(&array_size, i);
dims = safe_emalloc(sizeof(int), dimension, 0);
dims[0] = i;
} else {
enc = get_array_type(xmlParam, data, &array_type);
smart_str_append_long(&array_size, i);
dims = safe_emalloc(sizeof(int), dimension, 0);
dims[0] = i;
}
if (style == SOAP_ENCODED) {
if (soap_version == SOAP_1_1) {
smart_str_0(&array_type);
if (strcmp(ZSTR_VAL(array_type.s),"xsd:anyType") == 0) {
smart_str_free(&array_type);
smart_str_appendl(&array_type,"xsd:ur-type",sizeof("xsd:ur-type")-1);
}
smart_str_appendc(&array_type, '[');
smart_str_append_smart_str(&array_type, &array_size);
smart_str_appendc(&array_type, ']');
smart_str_0(&array_type);
set_ns_prop(xmlParam, SOAP_1_1_ENC_NAMESPACE, "arrayType", ZSTR_VAL(array_type.s));
} else {
size_t i = 0;
while (i < ZSTR_LEN(array_size.s)) {
if (ZSTR_VAL(array_size.s)[i] == ',') {ZSTR_VAL(array_size.s)[i] = ' ';}
++i;
}
smart_str_0(&array_type);
smart_str_0(&array_size);
set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "itemType", ZSTR_VAL(array_type.s));
set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "arraySize", ZSTR_VAL(array_size.s));
}
}
smart_str_free(&array_type);
smart_str_free(&array_size);
add_xml_array_elements(xmlParam, element_type, enc, enc?encode_add_ns(xmlParam,enc->details.ns):NULL, dimension, dims, data, style);
efree(dims);
}
if (style == SOAP_ENCODED) {
if (SOAP_GLOBAL(features) & SOAP_USE_XSI_ARRAY_TYPE) {
set_ns_and_type_ex(xmlParam, (soap_version == SOAP_1_1) ? SOAP_1_1_ENC_NAMESPACE : SOAP_1_2_ENC_NAMESPACE, "Array");
} else {
set_ns_and_type(xmlParam, type);
}
}
zval_ptr_dtor(&array_copy);
return xmlParam;
}
static zval *to_zval_array(zval *ret, encodeTypePtr type, xmlNodePtr data)
{
xmlNodePtr trav;
encodePtr enc = NULL;
int dimension = 1;
int* dims = NULL;
int* pos = NULL;
xmlAttrPtr attr;
sdlAttributePtr arrayType;
sdlExtraAttributePtr ext;
sdlTypePtr elementType;
ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (data &&
(attr = get_attribute(data->properties,"arrayType")) &&
attr->children && attr->children->content) {
char *type, *end, *ns;
xmlNsPtr nsptr;
parse_namespace(attr->children->content, &type, &ns);
nsptr = xmlSearchNs(attr->doc, attr->parent, BAD_CAST(ns));
end = strrchr(type,'[');
if (end) {
*end = '\0';
dimension = calc_dimension(end+1);
dims = get_position(dimension, end+1);
}
if (nsptr != NULL) {
enc = get_encoder(SOAP_GLOBAL(sdl), (char*)nsptr->href, type);
}
efree(type);
if (ns) {efree(ns);}
} else if ((attr = get_attribute(data->properties,"itemType")) &&
attr->children &&
attr->children->content) {
char *type, *ns;
xmlNsPtr nsptr;
parse_namespace(attr->children->content, &type, &ns);
nsptr = xmlSearchNs(attr->doc, attr->parent, BAD_CAST(ns));
if (nsptr != NULL) {
enc = get_encoder(SOAP_GLOBAL(sdl), (char*)nsptr->href, type);
}
efree(type);
if (ns) {efree(ns);}
if ((attr = get_attribute(data->properties,"arraySize")) &&
attr->children && attr->children->content) {
dimension = calc_dimension_12((char*)attr->children->content);
dims = get_position_12(dimension, (char*)attr->children->content);
} else {
dims = emalloc(sizeof(int));
*dims = 0;
}
} else if ((attr = get_attribute(data->properties,"arraySize")) &&
attr->children && attr->children->content) {
dimension = calc_dimension_12((char*)attr->children->content);
dims = get_position_12(dimension, (char*)attr->children->content);
} else if (type->sdl_type != NULL &&
type->sdl_type->attributes != NULL &&
(arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType",
sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType")-1)) != NULL &&
arrayType->extraAttributes &&
(ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType")-1)) != NULL) {
char *type, *end;
type = estrdup(ext->val);
end = strrchr(type,'[');
if (end) {
*end = '\0';
}
if (ext->ns != NULL) {
enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, type);
}
efree(type);
dims = emalloc(sizeof(int));
*dims = 0;
} else if (type->sdl_type != NULL &&
type->sdl_type->attributes != NULL &&
(arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType",
sizeof(SOAP_1_2_ENC_NAMESPACE":itemType")-1)) != NULL &&
arrayType->extraAttributes &&
(ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":itemType")-1)) != NULL) {
if (ext->ns != NULL) {
enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, ext->val);
}
if ((arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL &&
arrayType->extraAttributes &&
(ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize")-1)) != NULL) {
dimension = calc_dimension_12(ext->val);
dims = get_position_12(dimension, ext->val);
} else {
dims = emalloc(sizeof(int));
*dims = 0;
}
} else if (type->sdl_type != NULL &&
type->sdl_type->attributes != NULL &&
(arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL &&
arrayType->extraAttributes &&
(ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize")-1)) != NULL) {
dimension = calc_dimension_12(ext->val);
dims = get_position_12(dimension, ext->val);
if (type->sdl_type && type->sdl_type->elements &&
zend_hash_num_elements(type->sdl_type->elements) == 1 &&
(zend_hash_internal_pointer_reset(type->sdl_type->elements),
(elementType = zend_hash_get_current_data_ptr(type->sdl_type->elements)) != NULL) &&
elementType->encode) {
enc = elementType->encode;
}
} else if (type->sdl_type && type->sdl_type->elements &&
zend_hash_num_elements(type->sdl_type->elements) == 1 &&
(zend_hash_internal_pointer_reset(type->sdl_type->elements),
(elementType = zend_hash_get_current_data_ptr(type->sdl_type->elements)) != NULL) &&
elementType->encode) {
enc = elementType->encode;
}
if (dims == NULL) {
dimension = 1;
dims = emalloc(sizeof(int));
*dims = 0;
}
pos = safe_emalloc(sizeof(int), dimension, 0);
memset(pos,0,sizeof(int)*dimension);
if (data &&
(attr = get_attribute(data->properties,"offset")) &&
attr->children && attr->children->content) {
char* tmp = strrchr((char*)attr->children->content,'[');
if (tmp == NULL) {
tmp = (char*)attr->children->content;
}
get_position_ex(dimension, tmp, &pos);
}
array_init(ret);
trav = data->children;
while (trav) {
if (trav->type == XML_ELEMENT_NODE) {
int i;
zval tmpVal, *ar;
xmlAttrPtr position = get_attribute(trav->properties,"position");
ZVAL_NULL(&tmpVal);
master_to_zval(&tmpVal, enc, trav);
if (position != NULL && position->children && position->children->content) {
char* tmp = strrchr((char*)position->children->content, '[');
if (tmp == NULL) {
tmp = (char*)position->children->content;
}
get_position_ex(dimension, tmp, &pos);
}
/* Get/Create intermediate arrays for multidimensional arrays */
i = 0;
ar = ret;
while (i < dimension-1) {
zval* ar2;
if ((ar2 = zend_hash_index_find(Z_ARRVAL_P(ar), pos[i])) != NULL) {
ar = ar2;
} else {
zval tmpAr;
array_init(&tmpAr);
ar = zend_hash_index_update(Z_ARRVAL_P(ar), pos[i], &tmpAr);
}
i++;
}
zend_hash_index_update(Z_ARRVAL_P(ar), pos[i], &tmpVal);
/* Increment position */
i = dimension;
while (i > 0) {
i--;
pos[i]++;
if (pos[i] >= dims[i]) {
if (i > 0) {
pos[i] = 0;
} else {
/* TODO: Array index overflow */
}
} else {
break;
}
}
}
trav = trav->next;
}
efree(dims);
efree(pos);
return ret;
}
/* Map encode/decode */
static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
{
zval *temp_data;
zend_string *key_val;
zend_ulong int_val;
xmlNodePtr xmlParam;
xmlNodePtr xparam, item;
xmlNodePtr key;
xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(parent, xmlParam);
FIND_ZVAL_NULL(data, xmlParam, style);
if (Z_TYPE_P(data) == IS_ARRAY) {
ZEND_HASH_FOREACH_KEY_VAL_IND(Z_ARRVAL_P(data), int_val, key_val, temp_data) {
item = xmlNewNode(NULL, BAD_CAST("item"));
xmlAddChild(xmlParam, item);
key = xmlNewNode(NULL, BAD_CAST("key"));
xmlAddChild(item,key);
if (key_val) {
if (style == SOAP_ENCODED) {
set_xsi_type(key, "xsd:string");
}
xmlNodeSetContent(key, BAD_CAST(ZSTR_VAL(key_val)));
} else {
smart_str tmp = {0};
smart_str_append_long(&tmp, int_val);
smart_str_0(&tmp);
if (style == SOAP_ENCODED) {
set_xsi_type(key, "xsd:int");
}
xmlNodeSetContentLen(key, BAD_CAST(ZSTR_VAL(tmp.s)), ZSTR_LEN(tmp.s));
smart_str_free(&tmp);
}
xparam = master_to_xml(get_conversion(Z_TYPE_P(temp_data)), temp_data, style, item);
xmlNodeSetName(xparam, BAD_CAST("value"));
} ZEND_HASH_FOREACH_END();
}
if (style == SOAP_ENCODED) {
set_ns_and_type(xmlParam, type);
}
return xmlParam;
}
static zval *to_zval_map(zval *ret, encodeTypePtr type, xmlNodePtr data)
{
zval key, value;
xmlNodePtr trav, item, xmlKey, xmlValue;
ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (data && data->children) {
array_init(ret);
trav = data->children;
trav = data->children;
FOREACHNODE(trav, "item", item) {
xmlKey = get_node(item->children, "key");
if (!xmlKey) {
soap_error0(E_ERROR, "Encoding: Can't decode apache map, missing key");
}
xmlValue = get_node(item->children, "value");
if (!xmlKey) {
soap_error0(E_ERROR, "Encoding: Can't decode apache map, missing value");
}
ZVAL_NULL(&key);
master_to_zval(&key, NULL, xmlKey);
ZVAL_NULL(&value);
master_to_zval(&value, NULL, xmlValue);
if (Z_TYPE(key) == IS_STRING) {
zend_symtable_update(Z_ARRVAL_P(ret), Z_STR(key), &value);
} else if (Z_TYPE(key) == IS_LONG) {
zend_hash_index_update(Z_ARRVAL_P(ret), Z_LVAL(key), &value);
} else {
soap_error0(E_ERROR, "Encoding: Can't decode apache map, only Strings or Longs are allowd as keys");
}
zval_ptr_dtor(&key);
}
ENDFOREACH(trav);
} else {
ZVAL_NULL(ret);
}
return ret;
}
/* Unknown encode/decode */
static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
{
encodePtr enc;
xmlNodePtr ret;
if (data) {
enc = get_conversion(Z_TYPE_P(data));
} else {
enc = get_conversion(IS_NULL);
}
ret = master_to_xml_int(enc, data, style, parent, 0);
/*
if (style == SOAP_LITERAL && SOAP_GLOBAL(sdl)) {
set_ns_and_type(ret, &enc->details);
}
*/
return ret;
}
static zval *guess_zval_convert(zval *ret, encodeTypePtr type, xmlNodePtr data)
{
encodePtr enc = NULL;
xmlAttrPtr tmpattr;
xmlChar *type_name = NULL;
data = check_and_resolve_href(data);
if (data == NULL) {
enc = get_conversion(IS_NULL);
} else if (data->properties && get_attribute_ex(data->properties, "nil", XSI_NAMESPACE)) {
enc = get_conversion(IS_NULL);
} else {
tmpattr = get_attribute_ex(data->properties,"type", XSI_NAMESPACE);
if (tmpattr != NULL) {
type_name = tmpattr->children->content;
enc = get_encoder_from_prefix(SOAP_GLOBAL(sdl), data, tmpattr->children->content);
if (enc && type == &enc->details) {
enc = NULL;
}
if (enc != NULL) {
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) {
/* Didn't have a type, totally guess here */
/* Logic: has children = IS_OBJECT else IS_STRING */
xmlNodePtr trav;
if (get_attribute(data->properties, "arrayType") ||
get_attribute(data->properties, "itemType") ||
get_attribute(data->properties, "arraySize")) {
enc = get_conversion(SOAP_ENC_ARRAY);
} else {
enc = get_conversion(XSD_STRING);
trav = data->children;
while (trav != NULL) {
if (trav->type == XML_ELEMENT_NODE) {
enc = get_conversion(SOAP_ENC_OBJECT);
break;
}
trav = trav->next;
}
}
}
}
master_to_zval_int(ret, enc, data);
if (SOAP_GLOBAL(sdl) && type_name && enc->details.sdl_type) {
zval soapvar;
char *ns, *cptype;
xmlNsPtr nsptr;
object_init_ex(&soapvar, soap_var_class_entry);
add_property_long(&soapvar, "enc_type", enc->details.type);
Z_DELREF_P(ret);
add_property_zval(&soapvar, "enc_value", ret);
parse_namespace(type_name, &cptype, &ns);
nsptr = xmlSearchNs(data->doc, data, BAD_CAST(ns));
add_property_string(&soapvar, "enc_stype", cptype);
if (nsptr) {
add_property_string(&soapvar, "enc_ns", (char*)nsptr->href);
}
efree(cptype);
if (ns) {efree(ns);}
ZVAL_COPY_VALUE(ret, &soapvar);
}
return ret;
}
/* Time encode/decode */
static xmlNodePtr to_xml_datetime_ex(encodeTypePtr type, zval *data, char *format, int style, xmlNodePtr parent)
{
/* logic hacked from ext/standard/datetime.c */
struct tm *ta, tmbuf;
time_t timestamp;
int max_reallocs = 5;
size_t buf_len=64, real_len;
char *buf;
char tzbuf[8];
xmlNodePtr xmlParam;
xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(parent, xmlParam);
FIND_ZVAL_NULL(data, xmlParam, style);
if (Z_TYPE_P(data) == IS_LONG) {
timestamp = Z_LVAL_P(data);
ta = php_localtime_r(&timestamp, &tmbuf);
/*ta = php_gmtime_r(&timestamp, &tmbuf);*/
if (!ta) {
soap_error1(E_ERROR, "Encoding: Invalid timestamp " ZEND_LONG_FMT, Z_LVAL_P(data));
}
buf = (char *) emalloc(buf_len);
while ((real_len = strftime(buf, buf_len, format, ta)) == buf_len || real_len == 0) {
buf_len *= 2;
buf = (char *) erealloc(buf, buf_len);
if (!--max_reallocs) break;
}
/* Time zone support */
#ifdef HAVE_TM_GMTOFF
snprintf(tzbuf, sizeof(tzbuf), "%c%02d:%02d", (ta->tm_gmtoff < 0) ? '-' : '+', abs(ta->tm_gmtoff / 3600), abs( (ta->tm_gmtoff % 3600) / 60 ));
#else
# if defined(__CYGWIN__) || defined(NETWARE) || (defined(PHP_WIN32) && defined(_MSC_VER) && _MSC_VER >= 1900)
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));
# else
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));
# endif
#endif
if (strcmp(tzbuf,"+00:00") == 0) {
strcpy(tzbuf,"Z");
real_len++;
} else {
real_len += 6;
}
if (real_len >= buf_len) {
buf = (char *) erealloc(buf, real_len+1);
}
strcat(buf, tzbuf);
xmlNodeSetContent(xmlParam, BAD_CAST(buf));
efree(buf);
} else if (Z_TYPE_P(data) == IS_STRING) {
xmlNodeSetContentLen(xmlParam, BAD_CAST(Z_STRVAL_P(data)), Z_STRLEN_P(data));
}
if (style == SOAP_ENCODED) {
set_ns_and_type(xmlParam, type);
}
return xmlParam;
}
static xmlNodePtr to_xml_duration(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
{
/* TODO: '-'?P([0-9]+Y)?([0-9]+M)?([0-9]+D)?T([0-9]+H)?([0-9]+M)?([0-9]+S)? */
return to_xml_string(type, data, style, parent);
}
static xmlNodePtr to_xml_datetime(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
{
return to_xml_datetime_ex(type, data, "%Y-%m-%dT%H:%M:%S", style, parent);
}
static xmlNodePtr to_xml_time(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
{
/* TODO: microsecconds */
return to_xml_datetime_ex(type, data, "%H:%M:%S", style, parent);
}
static xmlNodePtr to_xml_date(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
{
return to_xml_datetime_ex(type, data, "%Y-%m-%d", style, parent);
}
static xmlNodePtr to_xml_gyearmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
{
return to_xml_datetime_ex(type, data, "%Y-%m", style, parent);
}
static xmlNodePtr to_xml_gyear(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
{
return to_xml_datetime_ex(type, data, "%Y", style, parent);
}
static xmlNodePtr to_xml_gmonthday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
{
return to_xml_datetime_ex(type, data, "--%m-%d", style, parent);
}
static xmlNodePtr to_xml_gday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
{
return to_xml_datetime_ex(type, data, "---%d", style, parent);
}
static xmlNodePtr to_xml_gmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
{
return to_xml_datetime_ex(type, data, "--%m--", style, parent);
}
static zval* to_zval_list(zval *ret, encodeTypePtr enc, xmlNodePtr data) {
/*FIXME*/
return to_zval_stringc(ret, enc, data);
}
static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent) {
xmlNodePtr ret;
encodePtr list_enc = NULL;
if (enc->sdl_type && enc->sdl_type->kind == XSD_TYPEKIND_LIST && enc->sdl_type->elements) {
sdlTypePtr type;
ZEND_HASH_FOREACH_PTR(enc->sdl_type->elements, type) {
list_enc = type->encode;
break;
} ZEND_HASH_FOREACH_END();
}
ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(parent, ret);
FIND_ZVAL_NULL(data, ret, style);
if (Z_TYPE_P(data) == IS_ARRAY) {
zval *tmp;
smart_str list = {0};
HashTable *ht = Z_ARRVAL_P(data);
ZEND_HASH_FOREACH_VAL(ht, tmp) {
xmlNodePtr dummy = master_to_xml(list_enc, tmp, SOAP_LITERAL, ret);
if (dummy && dummy->children && dummy->children->content) {
if (list.s && ZSTR_LEN(list.s) != 0) {
smart_str_appendc(&list, ' ');
}
smart_str_appends(&list, (char*)dummy->children->content);
} else {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
}
xmlUnlinkNode(dummy);
xmlFreeNode(dummy);
} ZEND_HASH_FOREACH_END();
smart_str_0(&list);
if (list.s) {
xmlNodeSetContentLen(ret, BAD_CAST(ZSTR_VAL(list.s)), ZSTR_LEN(list.s));
} else {
xmlNodeSetContentLen(ret, BAD_CAST(""), 0);
}
smart_str_free(&list);
} else {
zval tmp;
char *str, *start, *next;
smart_str list = {0};
if (Z_TYPE_P(data) != IS_STRING) {
ZVAL_STR(&tmp, zval_get_string(data));
data = &tmp;
}
str = estrndup(Z_STRVAL_P(data), Z_STRLEN_P(data));
whiteSpace_collapse(BAD_CAST(str));
start = str;
while (start != NULL && *start != '\0') {
xmlNodePtr dummy;
zval dummy_zval;
next = strchr(start,' ');
if (next != NULL) {
*next = '\0';
next++;
}
ZVAL_STRING(&dummy_zval, start);
dummy = master_to_xml(list_enc, &dummy_zval, SOAP_LITERAL, ret);
zval_ptr_dtor(&dummy_zval);
if (dummy && dummy->children && dummy->children->content) {
if (list.s && ZSTR_LEN(list.s) != 0) {
smart_str_appendc(&list, ' ');
}
smart_str_appends(&list, (char*)dummy->children->content);
} else {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
}
xmlUnlinkNode(dummy);
xmlFreeNode(dummy);
start = next;
}
smart_str_0(&list);
if (list.s) {
xmlNodeSetContentLen(ret, BAD_CAST(ZSTR_VAL(list.s)), ZSTR_LEN(list.s));
} else {
xmlNodeSetContentLen(ret, BAD_CAST(""), 0);
}
smart_str_free(&list);
efree(str);
if (data == &tmp) {zval_dtor(&tmp);}
}
return ret;
}
static xmlNodePtr to_xml_list1(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent) {
/*FIXME: minLength=1 */
return to_xml_list(enc,data,style, parent);
}
static zval* to_zval_union(zval *ret, encodeTypePtr enc, xmlNodePtr data) {
/*FIXME*/
return to_zval_list(ret, enc, data);
}
static xmlNodePtr to_xml_union(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent) {
/*FIXME*/
return to_xml_list(enc,data,style, parent);
}
static zval *to_zval_any(zval *ret, encodeTypePtr type, xmlNodePtr data)
{
xmlBufferPtr buf;
if (SOAP_GLOBAL(sdl) && SOAP_GLOBAL(sdl)->elements && data->name) {
smart_str nscat = {0};
sdlTypePtr sdl_type;
if (data->ns && data->ns->href) {
smart_str_appends(&nscat, (char*)data->ns->href);
smart_str_appendc(&nscat, ':');
}
smart_str_appends(&nscat, (char*)data->name);
smart_str_0(&nscat);
if ((sdl_type = zend_hash_find_ptr(SOAP_GLOBAL(sdl)->elements, nscat.s)) != NULL &&
sdl_type->encode) {
smart_str_free(&nscat);
return master_to_zval_int(ret, sdl_type->encode, data);
}
smart_str_free(&nscat);
}
buf = xmlBufferCreate();
xmlNodeDump(buf, NULL, data, 0, 0);
ZVAL_STRING(ret, (char*)xmlBufferContent(buf));
xmlBufferFree(buf);
return ret;
}
static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
{
xmlNodePtr ret = NULL;
if (Z_TYPE_P(data) == IS_ARRAY) {
zval *el;
encodePtr enc = get_conversion(XSD_ANYXML);
zend_string *name;
ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(data), name, el) {
ret = master_to_xml(enc, el, style, parent);
if (ret &&
ret->name != xmlStringTextNoenc) {
xmlNodeSetName(ret, BAD_CAST(ZSTR_VAL(name)));
}
} ZEND_HASH_FOREACH_END();
return ret;
}
if (Z_TYPE_P(data) == IS_STRING) {
ret = xmlNewTextLen(BAD_CAST(Z_STRVAL_P(data)), Z_STRLEN_P(data));
} else {
zend_string *tmp = zval_get_string(data);
ret = xmlNewTextLen(BAD_CAST(ZSTR_VAL(tmp)), ZSTR_LEN(tmp));
zend_string_release(tmp);
}
ret->name = xmlStringTextNoenc;
ret->parent = parent;
ret->doc = parent->doc;
ret->prev = parent->last;
ret->next = NULL;
if (parent->last) {
parent->last->next = ret;
} else {
parent->children = ret;
}
parent->last = ret;
return ret;
}
zval *sdl_guess_convert_zval(zval *ret, encodeTypePtr enc, xmlNodePtr data)
{
sdlTypePtr type;
type = enc->sdl_type;
if (type == NULL) {
return guess_zval_convert(ret, enc, data);
}
/*FIXME: restriction support
if (type && type->restrictions &&
data && data->children && data->children->content) {
if (type->restrictions->whiteSpace && type->restrictions->whiteSpace->value) {
if (strcmp(type->restrictions->whiteSpace->value,"replace") == 0) {
whiteSpace_replace(data->children->content);
} else if (strcmp(type->restrictions->whiteSpace->value,"collapse") == 0) {
whiteSpace_collapse(data->children->content);
}
}
if (type->restrictions->enumeration) {
if (!zend_hash_exists(type->restrictions->enumeration,data->children->content,strlen(data->children->content)+1)) {
soap_error1(E_WARNING, "Encoding: Restriction: invalid enumeration value \"%s\"", data->children->content);
}
}
if (type->restrictions->minLength &&
strlen(data->children->content) < type->restrictions->minLength->value) {
soap_error0(E_WARNING, "Encoding: Restriction: length less than 'minLength'");
}
if (type->restrictions->maxLength &&
strlen(data->children->content) > type->restrictions->maxLength->value) {
soap_error0(E_WARNING, "Encoding: Restriction: length greater than 'maxLength'");
}
if (type->restrictions->length &&
strlen(data->children->content) != type->restrictions->length->value) {
soap_error0(E_WARNING, "Encoding: Restriction: length is not equal to 'length'");
}
}
*/
switch (type->kind) {
case XSD_TYPEKIND_SIMPLE:
if (type->encode && enc != &type->encode->details) {
return master_to_zval_int(ret, type->encode, data);
} else {
return guess_zval_convert(ret, enc, data);
}
break;
case XSD_TYPEKIND_LIST:
return to_zval_list(ret, enc, data);
case XSD_TYPEKIND_UNION:
return to_zval_union(ret, enc, data);
case XSD_TYPEKIND_COMPLEX:
case XSD_TYPEKIND_RESTRICTION:
case XSD_TYPEKIND_EXTENSION:
if (type->encode &&
(type->encode->details.type == IS_ARRAY ||
type->encode->details.type == SOAP_ENC_ARRAY)) {
return to_zval_array(ret, enc, data);
}
return to_zval_object(ret, enc, data);
default:
soap_error0(E_ERROR, "Encoding: Internal Error");
return guess_zval_convert(ret, enc, data);
}
}
xmlNodePtr sdl_guess_convert_xml(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent)
{
sdlTypePtr type;
xmlNodePtr ret = NULL;
type = enc->sdl_type;
if (type == NULL) {
ret = guess_xml_convert(enc, data, style, parent);
if (style == SOAP_ENCODED) {
set_ns_and_type(ret, enc);
}
return ret;
}
/*FIXME: restriction support
if (type) {
if (type->restrictions && Z_TYPE_P(data) == IS_STRING) {
if (type->restrictions->enumeration) {
if (!zend_hash_exists(type->restrictions->enumeration,Z_STRVAL_P(data),Z_STRLEN_P(data)+1)) {
soap_error1(E_WARNING, "Encoding: Restriction: invalid enumeration value \"%s\".", Z_STRVAL_P(data));
}
}
if (type->restrictions->minLength &&
Z_STRLEN_P(data) < type->restrictions->minLength->value) {
soap_error0(E_WARNING, "Encoding: Restriction: length less than 'minLength'");
}
if (type->restrictions->maxLength &&
Z_STRLEN_P(data) > type->restrictions->maxLength->value) {
soap_error0(E_WARNING, "Encoding: Restriction: length greater than 'maxLength'");
}
if (type->restrictions->length &&
Z_STRLEN_P(data) != type->restrictions->length->value) {
soap_error0(E_WARNING, "Encoding: Restriction: length is not equal to 'length'");
}
}
}
*/
switch(type->kind) {
case XSD_TYPEKIND_SIMPLE:
if (type->encode && enc != &type->encode->details) {
ret = master_to_xml(type->encode, data, style, parent);