#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"

static zval *to_zval_double(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);

static zval *to_zval_long(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);

static zval *to_zval_bool(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);

static zval *to_zval_string(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);

static zval *to_zval_stringr(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);

static zval *to_zval_stringc(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);

static zval *to_zval_map(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);

static zval *to_zval_null(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);

static zval *to_zval_base64(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);

static zval *to_zval_hexbin(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);

static xmlNodePtr to_xml_long(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_double(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_bool(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_string(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_base64(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_hexbin(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_null(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr guess_array_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_list1(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_datetime_ex(encodeTypePtr type, zval *data, char *format, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_datetime(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_time(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_date(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_gyearmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_gyear(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_gmonthday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_gday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_gmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_duration(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static zval *to_zval_object(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);

static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);

static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static zval *to_zval_any(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);

static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static zval *guess_zval_convert(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);

static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);

static int is_map(zval *array);

static encodePtr get_array_type(xmlNodePtr node, zval *array, smart_str *out_type TSRMLS_DC);

static xmlNodePtr check_and_resolve_href(xmlNodePtr data);

static void set_ns_prop(xmlNodePtr node, char *ns, char *name, char *val);

static void set_xsi_nil(xmlNodePtr node);

static void set_xsi_type(xmlNodePtr node, char *type);

static void get_type_str(xmlNodePtr node, const char* ns, const char* type, smart_str* ret);

static void set_ns_and_type_ex(xmlNodePtr node, char *ns, char *type);

static void set_ns_and_type(xmlNodePtr node, encodeTypePtr type);

#define FIND_XML_NULL(xml,zval) \

{ \

xmlAttrPtr null; \

if (!xml) { \

ZVAL_NULL(zval); \

return zval; \

} \

if (xml->properties) { \

null = get_attribute(xml->properties, "nil"); \

if (null) { \

ZVAL_NULL(zval); \

return zval; \

} \

} \

}

#define CHECK_XML_NULL(xml) \

{ \

xmlAttrPtr null; \

if (!xml) { \

zval *ret; \

ALLOC_INIT_ZVAL(ret); \

ZVAL_NULL(ret); \

return ret; \

} \

if (xml->properties) { \

null = get_attribute(xml->properties, "nil"); \

if (null) { \

zval *ret; \

ALLOC_INIT_ZVAL(ret); \

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}, guess_zval_convert, guess_xml_convert},

{{IS_NULL, "nil", XSI_NAMESPACE, NULL}, to_zval_null, to_xml_null},

{{IS_STRING, XSD_STRING_STRING, XSD_NAMESPACE, NULL}, to_zval_string, to_xml_string},

{{IS_LONG, XSD_INT_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{IS_DOUBLE, XSD_FLOAT_STRING, XSD_NAMESPACE, NULL}, to_zval_double, to_xml_double},

{{IS_BOOL, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL}, to_zval_bool, to_xml_bool},

{{IS_CONSTANT, XSD_STRING_STRING, XSD_NAMESPACE, NULL}, to_zval_string, to_xml_string},

{{IS_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_1_ENC_NAMESPACE, NULL}, to_zval_array, guess_array_map},

{{IS_CONSTANT_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_1_ENC_NAMESPACE, NULL}, to_zval_array, to_xml_array},

{{IS_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_1_ENC_NAMESPACE, NULL}, to_zval_object, to_xml_object},

{{IS_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_2_ENC_NAMESPACE, NULL}, to_zval_array, guess_array_map},

{{IS_CONSTANT_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_2_ENC_NAMESPACE, NULL}, to_zval_array, to_xml_array},

{{IS_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_2_ENC_NAMESPACE, NULL}, to_zval_object, to_xml_object},

{{XSD_STRING, XSD_STRING_STRING, XSD_NAMESPACE, NULL}, to_zval_string, to_xml_string},

{{XSD_BOOLEAN, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL}, to_zval_bool, to_xml_bool},

{{XSD_DECIMAL, XSD_DECIMAL_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},

{{XSD_FLOAT, XSD_FLOAT_STRING, XSD_NAMESPACE, NULL}, to_zval_double, to_xml_double},

{{XSD_DOUBLE, XSD_DOUBLE_STRING, XSD_NAMESPACE, NULL}, to_zval_double, to_xml_double},

{{XSD_DATETIME, XSD_DATETIME_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_datetime},

{{XSD_TIME, XSD_TIME_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_time},

{{XSD_DATE, XSD_DATE_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_date},

{{XSD_GYEARMONTH, XSD_GYEARMONTH_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_gyearmonth},

{{XSD_GYEAR, XSD_GYEAR_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_gyear},

{{XSD_GMONTHDAY, XSD_GMONTHDAY_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_gmonthday},

{{XSD_GDAY, XSD_GDAY_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_gday},

{{XSD_GMONTH, XSD_GMONTH_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_gmonth},

{{XSD_DURATION, XSD_DURATION_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_duration},

{{XSD_HEXBINARY, XSD_HEXBINARY_STRING, XSD_NAMESPACE, NULL}, to_zval_hexbin, to_xml_hexbin},

{{XSD_BASE64BINARY, XSD_BASE64BINARY_STRING, XSD_NAMESPACE, NULL}, to_zval_base64, to_xml_base64},

{{XSD_LONG, XSD_LONG_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{XSD_INT, XSD_INT_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{XSD_SHORT, XSD_SHORT_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{XSD_BYTE, XSD_BYTE_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{XSD_NONPOSITIVEINTEGER, XSD_NONPOSITIVEINTEGER_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{XSD_POSITIVEINTEGER, XSD_POSITIVEINTEGER_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{XSD_NONNEGATIVEINTEGER, XSD_NONNEGATIVEINTEGER_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{XSD_NEGATIVEINTEGER, XSD_NEGATIVEINTEGER_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{XSD_UNSIGNEDBYTE, XSD_UNSIGNEDBYTE_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{XSD_UNSIGNEDSHORT, XSD_UNSIGNEDSHORT_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{XSD_UNSIGNEDINT, XSD_UNSIGNEDINT_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{XSD_UNSIGNEDLONG, XSD_UNSIGNEDLONG_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{XSD_INTEGER, XSD_INTEGER_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{XSD_ANYTYPE, XSD_ANYTYPE_STRING, XSD_NAMESPACE, NULL}, guess_zval_convert, guess_xml_convert},

{{XSD_UR_TYPE, XSD_UR_TYPE_STRING, XSD_NAMESPACE, NULL}, guess_zval_convert, guess_xml_convert},

{{XSD_ANYURI, XSD_ANYURI_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},

{{XSD_QNAME, XSD_QNAME_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},

{{XSD_NOTATION, XSD_NOTATION_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},

{{XSD_NORMALIZEDSTRING, XSD_NORMALIZEDSTRING_STRING, XSD_NAMESPACE, NULL}, to_zval_stringr, to_xml_string},

{{XSD_TOKEN, XSD_TOKEN_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},

{{XSD_LANGUAGE, XSD_LANGUAGE_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},

{{XSD_NMTOKEN, XSD_NMTOKEN_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},

{{XSD_NMTOKENS, XSD_NMTOKENS_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_list1},

{{XSD_NAME, XSD_NAME_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},

{{XSD_NCNAME, XSD_NCNAME_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},

{{XSD_ID, XSD_ID_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},

{{XSD_IDREF, XSD_IDREF_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},

{{XSD_IDREFS, XSD_IDREFS_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_list1},

{{XSD_ENTITY, XSD_ENTITY_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},

{{XSD_ENTITIES, XSD_ENTITIES_STRING, XSD_NAMESPACE, NULL}, to_zval_stringc, to_xml_list1},

{{APACHE_MAP, APACHE_MAP_STRING, APACHE_NAMESPACE, NULL}, to_zval_map, to_xml_map},

{{SOAP_ENC_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_1_ENC_NAMESPACE, NULL}, to_zval_object, to_xml_object},

{{SOAP_ENC_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_1_ENC_NAMESPACE, NULL}, to_zval_array, to_xml_array},

{{SOAP_ENC_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_2_ENC_NAMESPACE, NULL}, to_zval_object, to_xml_object},

{{SOAP_ENC_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_2_ENC_NAMESPACE, NULL}, to_zval_array, to_xml_array},

/* support some of the 1999 data types */

{{XSD_STRING, XSD_STRING_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_string, to_xml_string},

{{XSD_BOOLEAN, XSD_BOOLEAN_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_bool, to_xml_bool},

{{XSD_DECIMAL, XSD_DECIMAL_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},

{{XSD_FLOAT, XSD_FLOAT_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_double, to_xml_double},

{{XSD_DOUBLE, XSD_DOUBLE_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_double, to_xml_double},

{{XSD_LONG, XSD_LONG_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{XSD_INT, XSD_INT_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{XSD_SHORT, XSD_SHORT_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{XSD_BYTE, XSD_BYTE_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_long, to_xml_long},

{{XSD_1999_TIMEINSTANT, XSD_1999_TIMEINSTANT_STRING, XSD_1999_NAMESPACE, NULL}, to_zval_stringc, to_xml_string},

{{XSD_ANYXML, "<anyXML>", "<anyXML>", NULL}, to_zval_any, to_xml_any},

{{END_KNOWN_TYPES, NULL, NULL, NULL}, guess_zval_convert, guess_xml_convert}

};

int numDefaultEncodings = sizeof(defaultEncoding)/sizeof(encode);

void whiteSpace_replace(xmlChar* str)

{

while (*str != '\0') {

if (*str == '\x9' || *str == '\xA' || *str == '\xD') {

*str = ' ';

}

str++;

}

}

void whiteSpace_collapse(xmlChar* str)

{

xmlChar *pos;

xmlChar old;

pos = str;

whiteSpace_replace(str);

while (*str == ' ') {

str++;

}

old = '\0';

while (*str != '\0') {

if (*str != ' ' || old != ' ') {

*pos = *str;

pos++;

}

old = *str;

str++;

}

if (old == ' ') {

--pos;

}

*pos = '\0';

}

static encodePtr find_encoder_by_type_name(sdlPtr sdl, const char *type)

{

if (sdl && sdl->encoders) {

HashPosition pos;

encodePtr *enc;

for (zend_hash_internal_pointer_reset_ex(sdl->encoders, &pos);

zend_hash_get_current_data_ex(sdl->encoders, (void **) &enc, &pos) == SUCCESS;

zend_hash_move_forward_ex(sdl->encoders, &pos)) {

if (strcmp((*enc)->details.type_str, type) == 0) {

return *enc;

}

}

}

return NULL;

}

static zend_bool soap_check_zval_ref(zval *data, xmlNodePtr node TSRMLS_DC) {

xmlNodePtr *node_ptr;

if (SOAP_GLOBAL(ref_map)) {

if (Z_TYPE_P(data) == IS_OBJECT) {

data = (zval*)zend_objects_get_address(data TSRMLS_CC);

}

if (zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)data, (void**)&node_ptr) == SUCCESS) {

xmlAttrPtr attr = (*node_ptr)->properties;

char *id;

smart_str prefix = {0};

if (*node_ptr == node) {

return 0;

}

xmlNodeSetName(node, (*node_ptr)->name);

xmlSetNs(node, (*node_ptr)->ns);

if (SOAP_GLOBAL(soap_version) == SOAP_1_1) {

while (1) {

attr = get_attribute(attr, "id");

if (attr == NULL || attr->ns == NULL) {

break;

}

attr = attr->next;

}

if (attr) {

id = (char*)attr->children->content;

smart_str_appendc(&prefix, '#');

smart_str_appends(&prefix, id);

smart_str_0(&prefix);

id = prefix.c;

} else {

SOAP_GLOBAL(cur_uniq_ref)++;

smart_str_appendl(&prefix, "#ref", 4);

smart_str_append_long(&prefix, SOAP_GLOBAL(cur_uniq_ref));

smart_str_0(&prefix);

id = prefix.c;

xmlSetProp((*node_ptr), BAD_CAST("id"), BAD_CAST(id+1));

}

xmlSetProp(node, BAD_CAST("href"), BAD_CAST(id));

} else {

attr = get_attribute_ex(attr, "id", SOAP_1_2_ENC_NAMESPACE);

if (attr) {

id = (char*)attr->children->content;

smart_str_appendc(&prefix, '#');

smart_str_appends(&prefix, id);

smart_str_0(&prefix);

id = prefix.c;

} else {

SOAP_GLOBAL(cur_uniq_ref)++;

smart_str_appendl(&prefix, "#ref", 4);

smart_str_append_long(&prefix, SOAP_GLOBAL(cur_uniq_ref));

smart_str_0(&prefix);

id = prefix.c;

set_ns_prop((*node_ptr), SOAP_1_2_ENC_NAMESPACE, "id", id+1);

}

set_ns_prop(node, SOAP_1_2_ENC_NAMESPACE, "ref", id);

}

smart_str_free(&prefix);

return 1;

} else {

zend_hash_index_update(SOAP_GLOBAL(ref_map), (ulong)data, (void**)&node, sizeof(xmlNodePtr), NULL);

}

}

return 0;

}

static zval* soap_find_xml_ref(xmlNodePtr node TSRMLS_DC)

{

zval **data_ptr;

if (SOAP_GLOBAL(ref_map) &&

zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)node, (void**)&data_ptr) == SUCCESS) {

Z_SET_ISREF_PP(data_ptr);

Z_ADDREF_PP(data_ptr);

return *data_ptr;

}

return NULL;

}

static zend_bool soap_check_xml_ref(zval **data, xmlNodePtr node TSRMLS_DC)

{

zval **data_ptr;

if (SOAP_GLOBAL(ref_map)) {

if (zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)node, (void**)&data_ptr) == SUCCESS) {

if (*data != *data_ptr) {

zval_ptr_dtor(data);

*data = *data_ptr;

Z_SET_ISREF_PP(data);

Z_ADDREF_PP(data);

return 1;

}

} else {

zend_hash_index_update(SOAP_GLOBAL(ref_map), (ulong)node, (void**)data, sizeof(zval*), NULL);

}

}

return 0;

}

static xmlNodePtr master_to_xml_int(encodePtr encode, zval *data, int style, xmlNodePtr parent, int check_class_map TSRMLS_DC)

{

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 (zend_hash_find(ht, "enc_type", sizeof("enc_type"), (void **)&ztype) == FAILURE) {

soap_error0(E_ERROR, "Encoding: SoapVar has no 'enc_type' property");

}

if (zend_hash_find(ht, "enc_stype", sizeof("enc_stype"), (void **)&zstype) == SUCCESS) {

if (zend_hash_find(ht, "enc_ns", sizeof("enc_ns"), (void **)&zns) == SUCCESS) {

enc = get_encoder(SOAP_GLOBAL(sdl), Z_STRVAL_PP(zns), Z_STRVAL_PP(zstype));

} else {

zns = NULL;

enc = get_encoder_ex(SOAP_GLOBAL(sdl), Z_STRVAL_PP(zstype), Z_STRLEN_PP(zstype));

}

if (enc == NULL && SOAP_GLOBAL(typemap)) {

encodePtr *new_enc;

smart_str nscat = {0};

if (zns != NULL) {

smart_str_appendl(&nscat, Z_STRVAL_PP(zns), Z_STRLEN_PP(zns));

smart_str_appendc(&nscat, ':');

}

smart_str_appendl(&nscat, Z_STRVAL_PP(zstype), Z_STRLEN_PP(zstype));

smart_str_0(&nscat);

if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) {

enc = *new_enc;

}

smart_str_free(&nscat);

}

}

if (enc == NULL) {

enc = get_conversion(Z_LVAL_P(*ztype));

}

if (enc == NULL) {

enc = encode;

}

if (zend_hash_find(ht, "enc_value", sizeof("enc_value"), (void **)&zdata) == FAILURE) {

node = master_to_xml(enc, NULL, style, parent TSRMLS_CC);

} else {

node = master_to_xml(enc, *zdata, style, parent TSRMLS_CC);

}

if (style == SOAP_ENCODED || (SOAP_GLOBAL(sdl) && encode != enc)) {

if (zend_hash_find(ht, "enc_stype", sizeof("enc_stype"), (void **)&zstype) == SUCCESS) {

if (zend_hash_find(ht, "enc_ns", sizeof("enc_ns"), (void **)&zns) == SUCCESS) {

set_ns_and_type_ex(node, Z_STRVAL_PP(zns), Z_STRVAL_PP(zstype));

} else {

set_ns_and_type_ex(node, NULL, Z_STRVAL_PP(zstype));

}

}

}

if (zend_hash_find(ht, "enc_name", sizeof("enc_name"), (void **)&zname) == SUCCESS) {

xmlNodeSetName(node, BAD_CAST(Z_STRVAL_PP(zname)));

}

if (zend_hash_find(ht, "enc_namens", sizeof("enc_namens"), (void **)&znamens) == SUCCESS) {

xmlNsPtr nsp = encode_add_ns(node, Z_STRVAL_PP(znamens));

xmlSetNs(node, nsp);

}

} else {

if (check_class_map && SOAP_GLOBAL(class_map) && data &&

Z_TYPE_P(data) == IS_OBJECT &&

!Z_OBJPROP_P(data)->nApplyCount) {

zend_class_entry *ce = Z_OBJCE_P(data);

HashPosition pos;

zval **tmp;

char *type_name = NULL;

uint type_len;

ulong idx;

for (zend_hash_internal_pointer_reset_ex(SOAP_GLOBAL(class_map), &pos);

zend_hash_get_current_data_ex(SOAP_GLOBAL(class_map), (void **) &tmp, &pos) == SUCCESS;

zend_hash_move_forward_ex(SOAP_GLOBAL(class_map), &pos)) {

if (Z_TYPE_PP(tmp) == IS_STRING &&

ce->name_length == Z_STRLEN_PP(tmp) &&

zend_binary_strncasecmp(ce->name, ce->name_length, Z_STRVAL_PP(tmp), ce->name_length, ce->name_length) == 0 &&

zend_hash_get_current_key_ex(SOAP_GLOBAL(class_map), &type_name, &type_len, &idx, 0, &pos) == HASH_KEY_IS_STRING) {

/* TODO: namespace isn't stored */

encodePtr enc = NULL;

if (SOAP_GLOBAL(sdl)) {

enc = get_encoder(SOAP_GLOBAL(sdl), SOAP_GLOBAL(sdl)->target_ns, type_name);

if (!enc) {

enc = find_encoder_by_type_name(SOAP_GLOBAL(sdl), type_name);

}

}

if (enc) {

if (encode != enc && style == SOAP_LITERAL) {

add_type = 1;

}

encode = enc;

}

break;

}

}

}

if (encode == NULL) {

encode = get_conversion(UNKNOWN_TYPE);

}

if (SOAP_GLOBAL(typemap) && encode->details.type_str) {

smart_str nscat = {0};

encodePtr *new_enc;

if (encode->details.ns) {

smart_str_appends(&nscat, encode->details.ns);

smart_str_appendc(&nscat, ':');

}

smart_str_appends(&nscat, encode->details.type_str);

smart_str_0(&nscat);

if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) {

encode = *new_enc;

}

smart_str_free(&nscat);

}

if (encode->to_xml) {

node = encode->to_xml(&encode->details, data, style, parent TSRMLS_CC);

if (add_type) {

set_ns_and_type(node, &encode->details);

}

}

}

return node;

}

xmlNodePtr master_to_xml(encodePtr encode, zval *data, int style, xmlNodePtr parent TSRMLS_DC)

{

return master_to_xml_int(encode, data, style, parent, 1 TSRMLS_CC);

}

static zval *master_to_zval_int(encodePtr encode, xmlNodePtr data TSRMLS_DC)

{

zval *ret = NULL;

if (SOAP_GLOBAL(typemap)) {

if (encode->details.type_str) {

smart_str nscat = {0};

encodePtr *new_enc;

if (encode->details.ns) {

smart_str_appends(&nscat, encode->details.ns);

smart_str_appendc(&nscat, ':');

}

smart_str_appends(&nscat, encode->details.type_str);

smart_str_0(&nscat);

if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) {

encode = *new_enc;

}

smart_str_free(&nscat);

} else {

xmlAttrPtr type_attr = get_attribute_ex(data->properties,"type", XSI_NAMESPACE);

if (type_attr != NULL) {

encodePtr *new_enc;

xmlNsPtr nsptr;

char *ns, *cptype;

smart_str nscat = {0};

parse_namespace(type_attr->children->content, &cptype, &ns);

nsptr = xmlSearchNs(data->doc, data, BAD_CAST(ns));

if (nsptr != NULL) {

smart_str_appends(&nscat, (char*)nsptr->href);

smart_str_appendc(&nscat, ':');

}

smart_str_appends(&nscat, cptype);

smart_str_0(&nscat);

efree(cptype);

if (ns) {efree(ns);}

if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) {

encode = *new_enc;

}

smart_str_free(&nscat);

}

}

}

if (encode->to_zval) {

ret = encode->to_zval(&encode->details, data TSRMLS_CC);

}

return ret;

}

zval *master_to_zval(encodePtr encode, xmlNodePtr data TSRMLS_DC)

{

data = check_and_resolve_href(data);

if (encode == NULL) {

encode = get_conversion(UNKNOWN_TYPE);

} else {

/* Use xsi:type if it is defined */

xmlAttrPtr type_attr = get_attribute_ex(data->properties,"type", XSI_NAMESPACE);

if (type_attr != NULL) {

encodePtr enc = get_encoder_from_prefix(SOAP_GLOBAL(sdl), data, type_attr->children->content);

if (enc != NULL && enc != encode) {

encodePtr tmp = enc;

while (tmp &&

tmp->details.sdl_type != NULL &&

tmp->details.sdl_type->kind != XSD_TYPEKIND_COMPLEX) {

if (enc == tmp->details.sdl_type->encode ||

tmp == tmp->details.sdl_type->encode) {

enc = NULL;

break;

}

tmp = tmp->details.sdl_type->encode;

}

if (enc != NULL) {

encode = enc;

}

}

}

}

return master_to_zval_int(encode, data TSRMLS_CC);

}

xmlNodePtr to_xml_user(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)

{

xmlNodePtr ret = NULL;

zval *return_value;

if (type && type->map && type->map->to_xml) {

MAKE_STD_ZVAL(return_value);

if (call_user_function(EG(function_table), NULL, type->map->to_xml, return_value, 1, &data TSRMLS_CC) == FAILURE) {

soap_error0(E_ERROR, "Encoding: Error calling to_xml callback");

}

if (Z_TYPE_P(return_value) == IS_STRING) {

xmlDocPtr doc = soap_xmlParseMemory(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value));

if (doc && doc->children) {

ret = xmlDocCopyNode(doc->children, parent->doc, 1);

}

xmlFreeDoc(doc);

}

zval_ptr_dtor(&return_value);

}

if (!ret) {

ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));

}

xmlAddChild(parent, ret);

if (style == SOAP_ENCODED) {

set_ns_and_type(ret, type);

}

return ret;

}

zval *to_zval_user(encodeTypePtr type, xmlNodePtr node TSRMLS_DC)

{

zval *return_value;

if (type && type->map && type->map->to_zval) {

xmlBufferPtr buf;

zval *data;

xmlNodePtr copy;

copy = xmlCopyNode(node, 1);

buf = xmlBufferCreate();

xmlNodeDump(buf, NULL, copy, 0, 0);

MAKE_STD_ZVAL(data);

ZVAL_STRING(data, (char*)xmlBufferContent(buf), 1);

xmlBufferFree(buf);

xmlFreeNode(copy);

ALLOC_INIT_ZVAL(return_value);

if (call_user_function(EG(function_table), NULL, type->map->to_zval, return_value, 1, &data TSRMLS_CC) == FAILURE) {

soap_error0(E_ERROR, "Encoding: Error calling from_xml callback");

}

zval_ptr_dtor(&data);

} else {

ALLOC_INIT_ZVAL(return_value);

}

return return_value;

}

static zval *to_zval_string(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)

{

zval *ret;

MAKE_STD_ZVAL(ret);

FIND_XML_NULL(data, ret);

if (data && data->children) {

if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {

if (SOAP_GLOBAL(encoding) != NULL) {

xmlBufferPtr in = xmlBufferCreateStatic(data->children->content, xmlStrlen(data->children->content));

xmlBufferPtr out = xmlBufferCreate();

int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);

if (n >= 0) {

ZVAL_STRING(ret, (char*)xmlBufferContent(out), 1);

} else {

ZVAL_STRING(ret, (char*)data->children->content, 1);

}

xmlBufferFree(out);

xmlBufferFree(in);

} else {

ZVAL_STRING(ret, (char*)data->children->content, 1);

}

} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {

ZVAL_STRING(ret, (char*)data->children->content, 1);

} else {

soap_error0(E_ERROR, "Encoding: Violation of encoding rules");

}

} else {

ZVAL_EMPTY_STRING(ret);

}

return ret;

}

static zval *to_zval_stringr(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)

{

zval *ret;

MAKE_STD_ZVAL(ret);

FIND_XML_NULL(data, ret);

if (data && data->children) {

if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {

whiteSpace_replace(data->children->content);

if (SOAP_GLOBAL(encoding) != NULL) {

xmlBufferPtr in = xmlBufferCreateStatic(data->children->content, xmlStrlen(data->children->content));

xmlBufferPtr out = xmlBufferCreate();

int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);

if (n >= 0) {

ZVAL_STRING(ret, (char*)xmlBufferContent(out), 1);

} else {

ZVAL_STRING(ret, (char*)data->children->content, 1);

}

xmlBufferFree(out);

xmlBufferFree(in);

} else {

ZVAL_STRING(ret, (char*)data->children->content, 1);

}

} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {

ZVAL_STRING(ret, (char*)data->children->content, 1);

} else {

soap_error0(E_ERROR, "Encoding: Violation of encoding rules");

}

} else {

ZVAL_EMPTY_STRING(ret);

}

return ret;

}

static zval *to_zval_stringc(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)

{

zval *ret;

MAKE_STD_ZVAL(ret);

FIND_XML_NULL(data, ret);

if (data && data->children) {

if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {

whiteSpace_collapse(data->children->content);

if (SOAP_GLOBAL(encoding) != NULL) {

xmlBufferPtr in = xmlBufferCreateStatic(data->children->content, xmlStrlen(data->children->content));

xmlBufferPtr out = xmlBufferCreate();

int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);

if (n >= 0) {

ZVAL_STRING(ret, (char*)xmlBufferContent(out), 1);

} else {

ZVAL_STRING(ret, (char*)data->children->content, 1);

}

xmlBufferFree(out);

xmlBufferFree(in);

} else {

ZVAL_STRING(ret, (char*)data->children->content, 1);

}

} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {

ZVAL_STRING(ret, (char*)data->children->content, 1);

} else {

soap_error0(E_ERROR, "Encoding: Violation of encoding rules");

}

} else {

ZVAL_EMPTY_STRING(ret);

}

return ret;

}

static zval *to_zval_base64(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)

{

zval *ret;

char *str;

int str_len;

MAKE_STD_ZVAL(ret);

FIND_XML_NULL(data, ret);

if (data && data->children) {

if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {

whiteSpace_collapse(data->children->content);

str = (char*)php_base64_decode(data->children->content, strlen((char*)data->children->content), &str_len);

if (!str) {

soap_error0(E_ERROR, "Encoding: Violation of encoding rules");

}

ZVAL_STRINGL(ret, str, str_len, 0);

} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {

str = (char*)php_base64_decode(data->children->content, strlen((char*)data->children->content), &str_len);

if (!str) {

soap_error0(E_ERROR, "Encoding: Violation of encoding rules");

}

ZVAL_STRINGL(ret, str, str_len, 0);

} else {

soap_error0(E_ERROR, "Encoding: Violation of encoding rules");

}

} else {

ZVAL_EMPTY_STRING(ret);

}

return ret;

}

static zval *to_zval_hexbin(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)

{

zval *ret;

unsigned char *str;

int str_len, i, j;

unsigned char c;

MAKE_STD_ZVAL(ret);

FIND_XML_NULL(data, ret);

if (data && data->children) {

if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {

whiteSpace_collapse(data->children->content);

} else if (data->children->type != XML_CDATA_SECTION_NODE || data->children->next != NULL) {

soap_error0(E_ERROR, "Encoding: Violation of encoding rules");

return ret;

}

str_len = strlen((char*)data->children->content) / 2;

str = emalloc(str_len+1);

for (i = j = 0; i < str_len; i++) {

c = data->children->content[j++];

if (c >= '0' && c <= '9') {

str[i] = (c - '0') << 4;

} else if (c >= 'a' && c <= 'f') {

str[i] = (c - 'a' + 10) << 4;

} else if (c >= 'A' && c <= 'F') {

str[i] = (c - 'A' + 10) << 4;

} else {

soap_error0(E_ERROR, "Encoding: Violation of encoding rules");

}

c = data->children->content[j++];

if (c >= '0' && c <= '9') {

str[i] |= c - '0';

} else if (c >= 'a' && c <= 'f') {

str[i] |= c - 'a' + 10;

} else if (c >= 'A' && c <= 'F') {

str[i] |= c - 'A' + 10;

} else {

soap_error0(E_ERROR, "Encoding: Violation of encoding rules");

}

}

str[str_len] = '\0';

ZVAL_STRINGL(ret, (char*)str, str_len, 0);

} else {

ZVAL_EMPTY_STRING(ret);

}

return ret;

}

static xmlNodePtr to_xml_string(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)

{

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 {

zval tmp = *data;

zval_copy_ctor(&tmp);

convert_to_string(&tmp);

str = estrndup(Z_STRVAL(tmp), Z_STRLEN(tmp));

new_len = Z_STRLEN(tmp);

zval_dtor(&tmp);

}

if (SOAP_GLOBAL(encoding) != NULL) {

xmlBufferPtr in = xmlBufferCreateStatic(str, new_len);

xmlBufferPtr out = xmlBufferCreate();

int n = xmlCharEncInFunc(SOAP_GLOBAL(encoding), out, in);

if (n >= 0) {

efree(str);

str = estrdup((char*)xmlBufferContent(out));

new_len = n;

}

xmlBufferFree(out);

xmlBufferFree(in);

}

if (!php_libxml_xmlCheckUTF8(BAD_CAST(str))) {

char *err = emalloc(new_len + 8);

char c;

int i;

memcpy(err, str, new_len+1);

for (i = 0; (c = err[i++]);) {

if ((c & 0x80) == 0) {

} else if ((c & 0xe0) == 0xc0) {

if ((err[i] & 0xc0) != 0x80) {

break;

}

i++;

} else if ((c & 0xf0) == 0xe0) {

if ((err[i] & 0xc0) != 0x80 || (err[i+1] & 0xc0) != 0x80) {

break;

}

i += 2;

} else if ((c & 0xf8) == 0xf0) {

if ((err[i] & 0xc0) != 0x80 || (err[i+1] & 0xc0) != 0x80 || (err[i+2] & 0xc0) != 0x80) {

break;

}

i += 3;

} else {

break;

}

}

if (c) {

err[i-1] = '\\';

err[i++] = 'x';

err[i++] = ((unsigned char)c >> 4) + ((((unsigned char)c >> 4) > 9) ? ('a' - 10) : '0');

err[i++] = (c & 15) + (((c & 15) > 9) ? ('a' - 10) : '0');

err[i++] = '.';

err[i++] = '.';

err[i++] = '.';

err[i++] = 0;

}

soap_error1(E_ERROR, "Encoding: string '%s' is not a valid utf-8 string", err);

}

text = xmlNewTextLen(BAD_CAST(str), new_len);

xmlAddChild(ret, text);

efree(str);

if (style == SOAP_ENCODED) {

set_ns_and_type(ret, type);

}

return ret;

}

static xmlNodePtr to_xml_base64(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)

{

xmlNodePtr ret, text;

unsigned char *str;

int str_len;

ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));

xmlAddChild(parent, ret);

FIND_ZVAL_NULL(data, ret, style);

if (Z_TYPE_P(data) == IS_STRING) {