/hphp/runtime/ext/soap/encoding.cpp
C++ | 3387 lines | 3002 code | 264 blank | 121 comment | 1044 complexity | bc0bc2ca297648bf6f5ac1fc937780d3 MD5 | raw file
Possible License(s): LGPL-2.1, BSD-2-Clause, BSD-3-Clause, MPL-2.0-no-copyleft-exception, MIT, LGPL-2.0, Apache-2.0
- /*
- +----------------------------------------------------------------------+
- | HipHop for PHP |
- +----------------------------------------------------------------------+
- | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com) |
- | Copyright (c) 1997-2010 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. |
- +----------------------------------------------------------------------+
- */
- #include "hphp/runtime/ext/soap/encoding.h"
- #include <cstdlib>
- #include <map>
- #include <memory>
- #include <folly/Conv.h>
- #include "hphp/runtime/ext/soap/ext_soap.h"
- #include "hphp/runtime/ext/soap/soap.h"
- #include "hphp/runtime/ext/string/ext_string.h"
- #include "hphp/runtime/base/array-init.h"
- #include "hphp/runtime/base/array-iterator.h"
- #include "hphp/runtime/base/zend-functions.h"
- #include "hphp/runtime/base/comparisons.h"
- #include "hphp/runtime/base/string-buffer.h"
- #include "hphp/runtime/base/string-util.h"
- #include "hphp/runtime/base/type-array.h"
- #include "hphp/runtime/vm/native-data.h"
- namespace HPHP {
- ///////////////////////////////////////////////////////////////////////////////
- using std::string;
- using std::abs;
- bool php_libxml_xmlCheckUTF8(const unsigned char *s) {
- int i;
- unsigned char c;
- for (i = 0; (c = s[i++]);) {
- if ((c & 0x80) == 0) {
- } else if ((c & 0xe0) == 0xc0) {
- if ((s[i++] & 0xc0) != 0x80) {
- return false;
- }
- } else if ((c & 0xf0) == 0xe0) {
- if ((s[i++] & 0xc0) != 0x80 || (s[i++] & 0xc0) != 0x80) {
- return false;
- }
- } else if ((c & 0xf8) == 0xf0) {
- if ((s[i++] & 0xc0) != 0x80 || (s[i++] & 0xc0) != 0x80 ||
- (s[i++] & 0xc0) != 0x80) {
- return false;
- }
- } else {
- return false;
- }
- }
- return true;
- }
- static int zend_strnlen(const char* s, int maxlen) {
- int len = 0;
- while (*s++ && maxlen--) len++;
- return len;
- }
- static bool zend_unmangle_property_name(const char *mangled_property, int len,
- const char **class_name,
- const char **prop_name) {
- int class_name_len;
- *class_name = nullptr;
- if (mangled_property[0]!=0) {
- *prop_name = mangled_property;
- return true;
- }
- if (len < 3 || mangled_property[1]==0) {
- raise_warning("Illegal member variable name");
- *prop_name = mangled_property;
- return false;
- }
- class_name_len = zend_strnlen(mangled_property+1, --len - 1) + 1;
- if (class_name_len >= len || mangled_property[class_name_len]!=0) {
- raise_warning("Corrupt member variable name");
- *prop_name = mangled_property;
- return false;
- }
- *class_name = mangled_property+1;
- *prop_name = (*class_name)+class_name_len;
- return true;
- }
- ///////////////////////////////////////////////////////////////////////////////
- static Variant to_zval_double (encodeType* type, xmlNodePtr data);
- static Variant to_zval_long (encodeType* type, xmlNodePtr data);
- static Variant to_zval_bool (encodeType* type, xmlNodePtr data);
- static Variant to_zval_string (encodeType* type, xmlNodePtr data);
- static Variant to_zval_stringr (encodeType* type, xmlNodePtr data);
- static Variant to_zval_stringc (encodeType* type, xmlNodePtr data);
- static Variant to_zval_map (encodeType* type, xmlNodePtr data);
- static Variant to_zval_null (encodeType* type, xmlNodePtr data);
- static Variant to_zval_base64 (encodeType* type, xmlNodePtr data);
- static Variant to_zval_hexbin (encodeType* type, xmlNodePtr data);
- static xmlNodePtr to_xml_long
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_double
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_bool
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- /* String encode */
- static xmlNodePtr to_xml_string
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_base64
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_hexbin
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- /* Null encode */
- static xmlNodePtr to_xml_null
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- /* Array encode */
- static xmlNodePtr guess_array_map
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_map
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_list
- (encodeType* enc, const Variant& data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_list1
- (encodeType* enc, const Variant& data, int style, xmlNodePtr parent);
- /* Datetime encode/decode */
- static xmlNodePtr to_xml_datetime_ex
- (encodeType* type, const Variant& data, const char *format, int style,
- xmlNodePtr parent);
- static xmlNodePtr to_xml_datetime
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_time
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_date
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_gyearmonth
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_gyear
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_gmonthday
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_gday
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_gmonth
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_duration
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static Variant to_zval_object(encodeType* type, xmlNodePtr data);
- static Variant to_zval_array(encodeType* type, xmlNodePtr data);
- static xmlNodePtr to_xml_object
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static xmlNodePtr to_xml_array
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static Variant to_zval_any
- (encodeType* type, xmlNodePtr data);
- static xmlNodePtr to_xml_any
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- /* Try and guess for non-wsdl clients and servers */
- static Variant guess_zval_convert
- (encodeType* type, xmlNodePtr data);
- static xmlNodePtr guess_xml_convert
- (encodeType* type, const Variant& data, int style, xmlNodePtr parent);
- static encodePtr get_array_type
- (xmlNodePtr node, const Variant& array, string &out_type);
- static xmlNodePtr check_and_resolve_href(xmlNodePtr data);
- static void set_ns_prop(xmlNodePtr node, const char *ns, const char *name,
- const char *val);
- static void set_xsi_nil(xmlNodePtr node);
- static void set_xsi_type(xmlNodePtr node, const char *type);
- static void get_type_str
- (xmlNodePtr node, const char* ns, const char* type, string &ret);
- static void set_ns_and_type_ex(xmlNodePtr node, const char *ns,
- const char *type);
- static void set_ns_and_type(xmlNodePtr node, encodeType* type);
- #define FIND_XML_NULL(xml, v) \
- { \
- if (!xml) { \
- v = init_null(); \
- return v; \
- } \
- if (xml->properties) { \
- xmlAttrPtr n = get_attribute(xml->properties, "nil"); \
- if (n) { \
- v = init_null(); \
- return v; \
- } \
- } \
- }
- #define CHECK_XML_NULL(xml) \
- { \
- if (!xml) { \
- return uninit_null(); \
- } \
- if (xml->properties) { \
- xmlAttrPtr n = get_attribute(xml->properties, "nil"); \
- if (n) { \
- return uninit_null(); \
- } \
- } \
- }
- #define FIND_ZVAL_NULL(v, xml, style) \
- { \
- if (v.isNull()) { \
- if (style == SOAP_ENCODED) { \
- set_xsi_nil(xml); \
- } \
- return xml; \
- } \
- }
- ///////////////////////////////////////////////////////////////////////////////
- encodeStatic s_defaultEncoding[] = {
- {UNKNOWN_TYPE, "", "", guess_zval_convert, guess_xml_convert},
- {SOAP_ENC_NULL_DT, SOAP_ENC_NULL_DT_STRING, XSI_NAMESPACE,
- to_zval_null, to_xml_null},
- {XSD_STRING, XSD_STRING_STRING, XSD_NAMESPACE,
- to_zval_string, to_xml_string},
- {XSD_BOOLEAN, XSD_BOOLEAN_STRING, XSD_NAMESPACE,
- to_zval_bool, to_xml_bool},
- {XSD_DECIMAL, XSD_DECIMAL_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_string},
- {XSD_FLOAT, XSD_FLOAT_STRING, XSD_NAMESPACE,
- to_zval_double, to_xml_double},
- {XSD_DOUBLE, XSD_DOUBLE_STRING, XSD_NAMESPACE,
- to_zval_double, to_xml_double},
- {XSD_DATETIME, XSD_DATETIME_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_datetime},
- {XSD_TIME, XSD_TIME_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_time},
- {XSD_DATE, XSD_DATE_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_date},
- {XSD_GYEARMONTH, XSD_GYEARMONTH_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_gyearmonth},
- {XSD_GYEAR, XSD_GYEAR_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_gyear},
- {XSD_GMONTHDAY, XSD_GMONTHDAY_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_gmonthday},
- {XSD_GDAY, XSD_GDAY_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_gday},
- {XSD_GMONTH, XSD_GMONTH_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_gmonth},
- {XSD_DURATION, XSD_DURATION_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_duration},
- {XSD_HEXBINARY, XSD_HEXBINARY_STRING, XSD_NAMESPACE,
- to_zval_hexbin, to_xml_hexbin},
- {XSD_BASE64BINARY, XSD_BASE64BINARY_STRING, XSD_NAMESPACE,
- to_zval_base64, to_xml_base64},
- {XSD_LONG, XSD_LONG_STRING, XSD_NAMESPACE,
- to_zval_long, to_xml_long},
- {XSD_INT, XSD_INT_STRING, XSD_NAMESPACE,
- to_zval_long, to_xml_long},
- {XSD_SHORT, XSD_SHORT_STRING, XSD_NAMESPACE,
- to_zval_long, to_xml_long},
- {XSD_BYTE, XSD_BYTE_STRING, XSD_NAMESPACE,
- to_zval_long, to_xml_long},
- {XSD_NONPOSITIVEINTEGER,XSD_NONPOSITIVEINTEGER_STRING,XSD_NAMESPACE,
- to_zval_long, to_xml_long},
- {XSD_POSITIVEINTEGER, XSD_POSITIVEINTEGER_STRING, XSD_NAMESPACE,
- to_zval_long, to_xml_long},
- {XSD_NONNEGATIVEINTEGER,XSD_NONNEGATIVEINTEGER_STRING,XSD_NAMESPACE,
- to_zval_long, to_xml_long},
- {XSD_NEGATIVEINTEGER, XSD_NEGATIVEINTEGER_STRING, XSD_NAMESPACE,
- to_zval_long, to_xml_long},
- {XSD_UNSIGNEDBYTE, XSD_UNSIGNEDBYTE_STRING, XSD_NAMESPACE,
- to_zval_long, to_xml_long},
- {XSD_UNSIGNEDSHORT, XSD_UNSIGNEDSHORT_STRING, XSD_NAMESPACE,
- to_zval_long, to_xml_long},
- {XSD_UNSIGNEDINT, XSD_UNSIGNEDINT_STRING, XSD_NAMESPACE,
- to_zval_long, to_xml_long},
- {XSD_UNSIGNEDLONG, XSD_UNSIGNEDLONG_STRING, XSD_NAMESPACE,
- to_zval_long, to_xml_long},
- {XSD_INTEGER, XSD_INTEGER_STRING, XSD_NAMESPACE,
- to_zval_long, to_xml_long},
- {XSD_ANYTYPE, XSD_ANYTYPE_STRING, XSD_NAMESPACE,
- guess_zval_convert, guess_xml_convert},
- {XSD_UR_TYPE, XSD_UR_TYPE_STRING, XSD_NAMESPACE,
- guess_zval_convert, guess_xml_convert},
- {XSD_ANYURI, XSD_ANYURI_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_string},
- {XSD_QNAME, XSD_QNAME_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_string},
- {XSD_NOTATION, XSD_NOTATION_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_string},
- {XSD_NORMALIZEDSTRING, XSD_NORMALIZEDSTRING_STRING, XSD_NAMESPACE,
- to_zval_stringr, to_xml_string},
- {XSD_TOKEN, XSD_TOKEN_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_string},
- {XSD_LANGUAGE, XSD_LANGUAGE_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_string},
- {XSD_NMTOKEN, XSD_NMTOKEN_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_string},
- {XSD_NMTOKENS, XSD_NMTOKENS_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_list1},
- {XSD_NAME, XSD_NAME_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_string},
- {XSD_NCNAME, XSD_NCNAME_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_string},
- {XSD_ID, XSD_ID_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_string},
- {XSD_IDREF, XSD_IDREF_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_string},
- {XSD_IDREFS, XSD_IDREFS_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_list1},
- {XSD_ENTITY, XSD_ENTITY_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_string},
- {XSD_ENTITIES, XSD_ENTITIES_STRING, XSD_NAMESPACE,
- to_zval_stringc, to_xml_list1},
- {APACHE_MAP, APACHE_MAP_STRING, APACHE_NAMESPACE,
- to_zval_map, to_xml_map},
- {SOAP_ENC_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_1_ENC_NAMESPACE,
- to_zval_object, to_xml_object},
- {SOAP_ENC_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_1_ENC_NAMESPACE,
- to_zval_array, to_xml_array},
- {SOAP_ENC_ARRAY_DT, SOAP_ENC_ARRAY_DT_STRING, SOAP_1_1_ENC_NAMESPACE,
- to_zval_array, guess_array_map},
- {SOAP_ENC_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_2_ENC_NAMESPACE,
- to_zval_object, to_xml_object},
- {SOAP_ENC_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_2_ENC_NAMESPACE,
- to_zval_array, to_xml_array},
- {SOAP_ENC_ARRAY_DT, SOAP_ENC_ARRAY_DT_STRING, SOAP_1_2_ENC_NAMESPACE,
- to_zval_array, guess_array_map},
- {SOAP_ENC_INT_DT, SOAP_ENC_INT_DT_STRING, XSD_NAMESPACE,
- to_zval_long, to_xml_long},
- {SOAP_ENC_DOUBLE_DT, SOAP_ENC_DOUBLE_DT_STRING, XSD_NAMESPACE,
- to_zval_double, to_xml_double},
- /* support some of the 1999 data types */
- {XSD_STRING, XSD_STRING_STRING, XSD_1999_NAMESPACE,
- to_zval_string, to_xml_string},
- {XSD_BOOLEAN, XSD_BOOLEAN_STRING, XSD_1999_NAMESPACE,
- to_zval_bool, to_xml_bool},
- {XSD_DECIMAL, XSD_DECIMAL_STRING, XSD_1999_NAMESPACE,
- to_zval_stringc, to_xml_string},
- {XSD_FLOAT, XSD_FLOAT_STRING, XSD_1999_NAMESPACE,
- to_zval_double, to_xml_double},
- {XSD_DOUBLE, XSD_DOUBLE_STRING, XSD_1999_NAMESPACE,
- to_zval_double, to_xml_double},
- {XSD_LONG, XSD_LONG_STRING, XSD_1999_NAMESPACE,
- to_zval_long, to_xml_long},
- {XSD_INT, XSD_INT_STRING, XSD_1999_NAMESPACE,
- to_zval_long, to_xml_long},
- {XSD_SHORT, XSD_SHORT_STRING, XSD_1999_NAMESPACE,
- to_zval_long, to_xml_long},
- {XSD_BYTE, XSD_BYTE_STRING, XSD_1999_NAMESPACE,
- to_zval_long, to_xml_long},
- {XSD_1999_TIMEINSTANT,XSD_1999_TIMEINSTANT_STRING,XSD_1999_NAMESPACE,
- to_zval_stringc, to_xml_string},
- {XSD_ANYXML, "<anyXML>", "<anyXML>", to_zval_any, to_xml_any},
- {END_KNOWN_TYPES, nullptr, nullptr, guess_zval_convert, guess_xml_convert},
- };
- ///////////////////////////////////////////////////////////////////////////////
- static string get_full_typename(const char *ns, const char *type) {
- string nscat;
- if (ns && *ns) {
- nscat = ns;
- nscat += ':';
- }
- if (type) {
- nscat += type;
- }
- return nscat;
- }
- static encodePtr get_typemap_type(const char *ns, const char *type) {
- USE_SOAP_GLOBAL;
- std::string nscat = get_full_typename(ns, type);
- if (SOAP_GLOBAL(typemap)) {
- encodeMap::const_iterator iter = SOAP_GLOBAL(typemap)->find(nscat);
- if (iter != SOAP_GLOBAL(typemap)->end()) {
- return iter->second;
- }
- }
- return encodePtr();
- }
- 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(sdl *sdl, const char *type) {
- if (sdl) {
- for (const auto& e : sdl->encoders) {
- if (strcmp(e.second->details.type_str.c_str(), type) == 0) {
- return e.second;
- }
- }
- }
- return encodePtr();
- }
- static bool soap_check_zval_ref(const Variant& data, xmlNodePtr node) {
- USE_SOAP_GLOBAL;
- HeapObject* hash = nullptr;
- if (data.isObject()) {
- hash = data.getObjectData();
- }
- if (hash) {
- auto& node_map = SOAP_GLOBAL(node_map);
- auto node_ptr = folly::get_default(node_map, hash);
- if (node_ptr) {
- if (node_ptr == node) {
- return false;
- }
- xmlNodeSetName(node, node_ptr->name);
- xmlSetNs(node, node_ptr->ns);
- xmlAttrPtr attr = node_ptr->properties;
- const char *id;
- std::string prefix;
- if (SOAP_GLOBAL(soap_version) == SOAP_1_1) {
- while (1) {
- attr = get_attribute(attr, "id");
- if (attr == nullptr || attr->ns == nullptr) {
- break;
- }
- attr = attr->next;
- }
- if (attr) {
- prefix = '#';
- prefix += (char*)attr->children->content;
- id = prefix.c_str();
- } else {
- SOAP_GLOBAL(cur_uniq_ref)++;
- prefix = "#ref";
- prefix += folly::to<string>(SOAP_GLOBAL(cur_uniq_ref));
- id = prefix.c_str();
- 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) {
- prefix = '#';
- prefix += (char*)attr->children->content;
- id = prefix.c_str();
- } else {
- SOAP_GLOBAL(cur_uniq_ref)++;
- prefix = "#ref";
- prefix += folly::to<string>(SOAP_GLOBAL(cur_uniq_ref));
- id = prefix.c_str();
- set_ns_prop(node_ptr, SOAP_1_2_ENC_NAMESPACE, "id", id+1);
- }
- set_ns_prop(node, SOAP_1_2_ENC_NAMESPACE, "ref", id);
- }
- return true;
- }
- node_map.emplace(hash, node);
- }
- return false;
- }
- static bool soap_check_xml_ref(Variant& data, xmlNodePtr node) {
- USE_SOAP_GLOBAL;
- auto& ref_map = SOAP_GLOBAL(ref_map);
- auto const it = ref_map.find(node);
- if (it != ref_map.end()) {
- auto const& data2 = it->second;
- if (!data.isObject() ||
- !data2.isObject() ||
- data.getObjectData() != data2.getObjectData()) {
- data = data2;
- return true;
- }
- }
- return false;
- }
- static void soap_add_xml_ref(Variant& data, xmlNodePtr node) {
- USE_SOAP_GLOBAL;
- auto& ref_map = SOAP_GLOBAL(ref_map);
- ref_map.emplace(node, data);
- }
- static xmlNodePtr master_to_xml_int(encodePtr encode, const Variant& data, int style,
- xmlNodePtr parent, bool check_class_map) {
- USE_SOAP_GLOBAL;
- xmlNodePtr node = nullptr;
- bool add_type = false;
- /* Special handling of class SoapVar */
- if (data.isObject() && data.toObject().instanceof(SoapVar::getClass())) {
- auto dobj = data.toObject().get();
- auto enc_stype = SoapVar::getEncSType(dobj);
- auto enc_ns = SoapVar::getEncNS(dobj);
- encodePtr enc = nullptr;
- if (!enc_stype.isNull()) {
- enc = enc_ns.empty()
- ? get_encoder_ex(SOAP_GLOBAL(sdl), enc_stype.c_str())
- : get_encoder(SOAP_GLOBAL(sdl), enc_ns.c_str(), enc_stype.c_str());
- if (!enc && SOAP_GLOBAL(typemap)) {
- enc = get_typemap_type(enc_ns.c_str(), enc_stype.c_str());
- }
- }
- if (!enc) {
- auto enc_type = SoapVar::getEncType(dobj);
- enc = get_conversion(enc_type);
- }
- if (!enc) {
- enc = encode;
- }
- auto enc_value = SoapVar::getEncValue(dobj);
- node = master_to_xml(enc, enc_value, style, parent);
- if (style == SOAP_ENCODED || (SOAP_GLOBAL(sdl) && encode != enc)) {
- if (!enc_stype.empty()) {
- set_ns_and_type_ex(node, enc_ns.c_str(), enc_stype.c_str());
- }
- }
- auto enc_name = SoapVar::getEncName(dobj);
- if (!enc_name.empty()) {
- xmlNodeSetName(node, BAD_CAST(enc_name.c_str()));
- }
- auto enc_namens = SoapVar::getEncNameNS(dobj);
- if (!enc_namens.empty()) {
- xmlNsPtr nsp = encode_add_ns(node, enc_namens.data());
- xmlSetNs(node, nsp);
- }
- } else {
- if (check_class_map && !SOAP_GLOBAL(classmap).empty() &&
- data.isObject()) {
- auto clsname = data.toObject()->getClassName();
- for (ArrayIter iter(SOAP_GLOBAL(classmap)); iter; ++iter) {
- if (same(iter.second(), clsname)) {
- /* TODO: namespace isn't stored */
- encodePtr enc = nullptr;
- if (SOAP_GLOBAL(sdl)) {
- enc = get_encoder(SOAP_GLOBAL(sdl),
- SOAP_GLOBAL(sdl)->target_ns.c_str(),
- iter.first().toString().data());
- if (!enc) {
- enc = find_encoder_by_type_name(SOAP_GLOBAL(sdl),
- iter.first().toString().data());
- }
- }
- if (enc) {
- if (encode != enc && style == SOAP_LITERAL) {
- add_type = true;
- }
- encode = enc;
- }
- break;
- }
- }
- }
- if (encode == nullptr) {
- encode = get_conversion(UNKNOWN_TYPE);
- }
- if (SOAP_GLOBAL(typemap) && !encode->details.type_str.empty()) {
- encodePtr enc = get_typemap_type(encode->details.ns.c_str(),
- encode->details.type_str.c_str());
- if (enc) encode = enc;
- }
- 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, const Variant& data, int style,
- xmlNodePtr parent) {
- return master_to_xml_int(encode, data, style, parent, true);
- }
- static Variant master_to_zval_int(encodePtr encode, xmlNodePtr data) {
- USE_SOAP_GLOBAL;
- Variant ret;
- if (SOAP_GLOBAL(typemap)) {
- if (!encode->details.type_str.empty()) {
- encodePtr enc = get_typemap_type(encode->details.ns.c_str(),
- encode->details.type_str.c_str());
- if (enc) encode = enc;
- } else {
- xmlAttrPtr type_attr = get_attribute_ex(data->properties, "type",
- XSI_NAMESPACE);
- if (type_attr) {
- std::string ns, cptype;
- parse_namespace(type_attr->children->content, cptype, ns);
- xmlNsPtr nsptr = xmlSearchNs(data->doc, data, NS_STRING(ns));
- string nscat;
- if (nsptr) {
- nscat = (char*)nsptr->href;
- nscat += ':';
- }
- nscat += cptype.data();
- encodeMap::const_iterator iter = SOAP_GLOBAL(typemap)->find(nscat);
- if (iter != SOAP_GLOBAL(typemap)->end()) {
- encode = iter->second;
- }
- }
- }
- }
- if (encode->to_zval) {
- ret = encode->to_zval(&encode->details, data);
- }
- return ret;
- }
- Variant master_to_zval(encodePtr encode, xmlNodePtr data) {
- USE_SOAP_GLOBAL;
- data = check_and_resolve_href(data);
- if (encode == nullptr) {
- 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) {
- encodePtr enc = get_encoder_from_prefix(SOAP_GLOBAL(sdl), data,
- type_attr->children->content);
- if (enc && enc != encode) {
- encodePtr tmp = enc;
- while (tmp && tmp->details.sdl_type &&
- tmp->details.sdl_type->kind != XSD_TYPEKIND_COMPLEX) {
- if (enc == tmp->details.sdl_type->encode ||
- tmp == tmp->details.sdl_type->encode) {
- enc.reset();
- break;
- }
- tmp = tmp->details.sdl_type->encode;
- }
- if (enc) {
- encode = enc;
- }
- }
- }
- }
- return master_to_zval_int(encode, data);
- }
- xmlNodePtr to_xml_user(encodeType* type, const Variant& data, int style,
- xmlNodePtr parent) {
- xmlNodePtr ret = nullptr;
- if (type && type->map && !type->map->to_xml.isNull()) {
- Variant return_value = vm_call_user_func(type->map->to_xml,
- make_vec_array(data));
- if (return_value.isString()) {
- String sdoc = return_value.toString();
- xmlDocPtr doc = soap_xmlParseMemory(sdoc.data(), sdoc.size());
- if (doc && doc->children) {
- ret = xmlDocCopyNode(doc->children, parent->doc, 1);
- }
- xmlFreeDoc(doc);
- }
- }
- if (!ret) {
- ret = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- }
- xmlAddChild(parent, ret);
- if (style == SOAP_ENCODED) {
- set_ns_and_type(ret, type);
- }
- return ret;
- }
- Variant to_zval_user(encodeType* type, xmlNodePtr node) {
- Variant return_value;
- if (type && type->map && !type->map->to_zval.isNull()) {
- xmlNodePtr copy = xmlCopyNode(node, 1);
- xmlBufferPtr buf = xmlBufferCreate();
- xmlNodeDump(buf, nullptr, copy, 0, 0);
- String data((char*)xmlBufferContent(buf), CopyString);
- xmlBufferFree(buf);
- xmlFreeNode(copy);
- return_value = vm_call_user_func(type->map->to_zval,
- make_vec_array(data));
- }
- return return_value;
- }
- /* TODO: get rid of "bogus".. ither by passing in the already created xmlnode
- or passing in the node name */
- /* String encode/decode */
- static Variant to_zval_string(encodeType* /*type*/, xmlNodePtr data) {
- USE_SOAP_GLOBAL;
- Variant ret;
- FIND_XML_NULL(data, ret);
- if (data && data->children) {
- if (data->children->type == XML_TEXT_NODE &&
- data->children->next == nullptr) {
- if (SOAP_GLOBAL(encoding) != nullptr) {
- xmlBufferPtr in =
- xmlBufferCreateStatic(data->children->content,
- xmlStrlen(data->children->content));
- xmlBufferPtr out = xmlBufferCreate();
- int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);
- if (n >= 0) {
- ret = String((char*)xmlBufferContent(out), CopyString);
- } else {
- ret = String((char*)data->children->content, CopyString);
- }
- xmlBufferFree(out);
- xmlBufferFree(in);
- } else {
- ret = String((char*)data->children->content, CopyString);
- }
- } else if (data->children->type == XML_CDATA_SECTION_NODE &&
- data->children->next == nullptr) {
- ret = String((char*)data->children->content, CopyString);
- } else {
- throw SoapException("Encoding: Violation of encoding rules");
- }
- } else {
- ret = empty_string_variant();
- }
- return ret;
- }
- static Variant to_zval_stringr(encodeType* /*type*/, xmlNodePtr data) {
- USE_SOAP_GLOBAL;
- Variant ret;
- FIND_XML_NULL(data, ret);
- if (data && data->children) {
- if (data->children->type == XML_TEXT_NODE &&
- data->children->next == nullptr) {
- whiteSpace_replace(data->children->content);
- if (SOAP_GLOBAL(encoding) != nullptr) {
- xmlBufferPtr in =
- xmlBufferCreateStatic(data->children->content,
- xmlStrlen(data->children->content));
- xmlBufferPtr out = xmlBufferCreate();
- int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);
- if (n >= 0) {
- ret = String((char*)xmlBufferContent(out), CopyString);
- } else {
- ret = String((char*)data->children->content, CopyString);
- }
- xmlBufferFree(out);
- xmlBufferFree(in);
- } else {
- ret = String((char*)data->children->content, CopyString);
- }
- } else if (data->children->type == XML_CDATA_SECTION_NODE &&
- data->children->next == nullptr) {
- ret = String((char*)data->children->content, CopyString);
- } else {
- throw SoapException("Encoding: Violation of encoding rules");
- }
- } else {
- ret = empty_string_variant();
- }
- return ret;
- }
- static Variant to_zval_stringc(encodeType* /*type*/, xmlNodePtr data) {
- USE_SOAP_GLOBAL;
- Variant ret;
- FIND_XML_NULL(data, ret);
- if (data && data->children) {
- if (data->children->type == XML_TEXT_NODE &&
- data->children->next == nullptr) {
- whiteSpace_collapse(data->children->content);
- if (SOAP_GLOBAL(encoding) != nullptr) {
- xmlBufferPtr in =
- xmlBufferCreateStatic(data->children->content,
- xmlStrlen(data->children->content));
- xmlBufferPtr out = xmlBufferCreate();
- int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);
- if (n >= 0) {
- ret = String((char*)xmlBufferContent(out), CopyString);
- } else {
- ret = String((char*)data->children->content, CopyString);
- }
- xmlBufferFree(out);
- xmlBufferFree(in);
- } else {
- ret = String((char*)data->children->content, CopyString);
- }
- } else if (data->children->type == XML_CDATA_SECTION_NODE &&
- data->children->next == nullptr) {
- ret = String((char*)data->children->content, CopyString);
- } else {
- throw SoapException("Encoding: Violation of encoding rules");
- }
- } else {
- ret = empty_string_variant();
- }
- return ret;
- }
- static Variant to_zval_base64(encodeType* /*type*/, xmlNodePtr data) {
- Variant ret;
- FIND_XML_NULL(data, ret);
- if (data && data->children) {
- if (data->children->type == XML_TEXT_NODE &&
- data->children->next == nullptr) {
- whiteSpace_collapse(data->children->content);
- String str =
- StringUtil::Base64Decode(String((const char*)data->children->content));
- if (str.isNull()) {
- throw SoapException("Encoding: Violation of encoding rules");
- }
- ret = str;
- } else if (data->children->type == XML_CDATA_SECTION_NODE &&
- data->children->next == nullptr) {
- String str =
- StringUtil::Base64Decode(String((const char*)data->children->content));
- if (str.isNull()) {
- throw SoapException("Encoding: Violation of encoding rules");
- }
- ret = str;
- } else {
- throw SoapException("Encoding: Violation of encoding rules");
- }
- } else {
- ret = empty_string_variant();
- }
- return ret;
- }
- static Variant to_zval_hexbin(encodeType* /*type*/, xmlNodePtr data) {
- Variant ret;
- FIND_XML_NULL(data, ret);
- if (data && data->children) {
- if (data->children->type == XML_TEXT_NODE &&
- data->children->next == nullptr) {
- whiteSpace_collapse(data->children->content);
- } else if (data->children->type != XML_CDATA_SECTION_NODE ||
- data->children->next != nullptr) {
- throw SoapException("Encoding: Violation of encoding rules");
- }
- auto const str =
- HHVM_FN(hex2bin)(String((const char*)data->children->content)).toString();
- if (str.isNull()) {
- throw SoapException("Encoding: Violation of encoding rules");
- }
- ret = str;
- } else {
- ret = empty_string_variant();
- }
- return ret;
- }
- static
- xmlNodePtr to_xml_string(encodeType* type, const Variant& data, int style,
- xmlNodePtr parent) {
- USE_SOAP_GLOBAL;
- xmlNodePtr ret = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(parent, ret);
- FIND_ZVAL_NULL(data, ret, style);
- String str = data.toString();
- if (SOAP_GLOBAL(encoding) != nullptr) {
- xmlBufferPtr in = xmlBufferCreateStatic((void*)str.data(), str.size());
- xmlBufferPtr out = xmlBufferCreate();
- int n = xmlCharEncInFunc(SOAP_GLOBAL(encoding), out, in);
- if (n >= 0) {
- str = String((char*)xmlBufferContent(out), n, CopyString);
- }
- xmlBufferFree(out);
- xmlBufferFree(in);
- }
- if (!php_libxml_xmlCheckUTF8(BAD_CAST(str.data()))) {
- char *err = (char*)req::malloc_noptrs(str.size() + 8);
- char c;
- memcpy(err, str.data(), str.size() + 1);
- int i = 0;
- while ((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;
- }
- std::string serr = err;
- req::free(err);
- throw SoapException("Encoding: string '%s' is not a valid utf-8 string",
- serr.c_str());
- }
- xmlNodePtr text = xmlNewTextLen(BAD_CAST(str.data()), str.size());
- xmlAddChild(ret, text);
- if (style == SOAP_ENCODED) {
- set_ns_and_type(ret, type);
- }
- return ret;
- }
- static
- xmlNodePtr to_xml_base64(encodeType* type, const Variant& data, int style,
- xmlNodePtr parent) {
- xmlNodePtr ret = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(parent, ret);
- FIND_ZVAL_NULL(data, ret, style);
- String str = StringUtil::Base64Encode(data.toString());
- xmlAddChild(ret, xmlNewTextLen(BAD_CAST(str.data()), str.size()));
- if (style == SOAP_ENCODED) {
- set_ns_and_type(ret, type);
- }
- return ret;
- }
- static
- xmlNodePtr to_xml_hexbin(encodeType* type, const Variant& data, int style,
- xmlNodePtr parent) {
- xmlNodePtr ret = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(parent, ret);
- FIND_ZVAL_NULL(data, ret, style);
- String str = HHVM_FN(bin2hex)(data.toString());
- xmlAddChild(ret, xmlNewTextLen(BAD_CAST(str.data()), str.size()));
- if (style == SOAP_ENCODED) {
- set_ns_and_type(ret, type);
- }
- return ret;
- }
- static Variant to_zval_double(encodeType* /*type*/, xmlNodePtr data) {
- Variant ret;
- FIND_XML_NULL(data, ret);
- if (data && data->children) {
- if (data->children->type == XML_TEXT_NODE &&
- data->children->next == nullptr) {
- int64_t lval; double dval;
- whiteSpace_collapse(data->children->content);
- String content((char*)data->children->content, CopyString);
- auto dt = is_numeric_string((const char *)data->children->content,
- data->children->content ?
- strlen((char*)data->children->content) : 0,
- &lval, &dval, 0);
- if (isIntType(dt)) {
- ret = lval;
- } else if (isDoubleType(dt)) {
- ret = dval;
- } else {
- if (data->children->content) {
- if (strcasecmp((const char *)data->children->content, "NaN") == 0) {
- ret = atof("nan");
- } else if (strcasecmp((const char *)data->children->content, "INF")
- == 0) {
- ret = atof("inf");
- } else if (strcasecmp((const char *)data->children->content, "-INF")
- == 0) {
- ret = -atof("inf");
- } else {
- throw SoapException("Encoding: Violation of encoding rules");
- }
- } else {
- throw SoapException("Encoding: Violation of encoding rules");
- }
- }
- } else {
- throw SoapException("Encoding: Violation of encoding rules");
- }
- }
- return ret;
- }
- static Variant to_zval_long(encodeType* /*type*/, xmlNodePtr data) {
- Variant ret;
- FIND_XML_NULL(data, ret);
- if (data && data->children) {
- if (data->children->type == XML_TEXT_NODE &&
- data->children->next == nullptr) {
- int64_t lval; double dval;
- whiteSpace_collapse(data->children->content);
- auto dt = is_numeric_string((const char *)data->children->content,
- data->children->content ?
- strlen((char*)data->children->content) : 0,
- &lval, &dval, 0);
- if (isIntType(dt)) {
- ret = (int64_t)lval;
- } else if (isDoubleType(dt)) {
- ret = dval;
- } else {
- throw SoapException("Encoding: Violation of encoding rules");
- }
- } else {
- throw SoapException("Encoding: Violation of encoding rules");
- }
- }
- return ret;
- }
- static xmlNodePtr to_xml_long(encodeType* type, const Variant& data, int style,
- xmlNodePtr parent) {
- xmlNodePtr ret = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(parent, ret);
- FIND_ZVAL_NULL(data, ret, style);
- if (data.isDouble()) {
- char s[256];
- snprintf(s, sizeof(s), "%0.0F", floor(data.toDouble()));
- xmlNodeSetContent(ret, BAD_CAST(s));
- } else {
- Variant d = data.toInt64();
- String sd = d.toString();
- xmlNodeSetContentLen(ret, BAD_CAST(sd.data()), sd.size());
- }
- if (style == SOAP_ENCODED) {
- set_ns_and_type(ret, type);
- }
- return ret;
- }
- static
- xmlNodePtr to_xml_double(encodeType* type, const Variant& data, int style,
- xmlNodePtr parent) {
- xmlNodePtr ret = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(parent, ret);
- FIND_ZVAL_NULL(data, ret, style);
- Variant d = data.toDouble();
- String sd = d.toString();
- xmlNodeSetContentLen(ret, BAD_CAST(sd.data()), sd.size());
- if (style == SOAP_ENCODED) {
- set_ns_and_type(ret, type);
- }
- return ret;
- }
- static Variant to_zval_bool(encodeType* /*type*/, xmlNodePtr data) {
- Variant ret;
- FIND_XML_NULL(data, ret);
- if (data && data->children) {
- if (data->children->type == XML_TEXT_NODE &&
- data->children->next == nullptr) {
- whiteSpace_collapse(data->children->content);
- const char *content = (const char *)data->children->content;
- if (strcasecmp((char*)content, "true") == 0 ||
- strcasecmp((char*)content, "t") == 0 ||
- strcmp((char*)content, "1") == 0) {
- ret = true;
- } else if (strcasecmp((char*)content, "false") == 0 ||
- strcasecmp((char*)content, "f") == 0 ||
- strcmp((char*)content, "0") == 0) {
- ret = false;
- } else {
- ret = String((char*)content, CopyString).toBoolean();
- }
- } else {
- throw SoapException("Encoding: Violation of encoding rules");
- }
- }
- return ret;
- }
- static xmlNodePtr to_xml_bool(encodeType* type, const Variant& data, int style,
- xmlNodePtr parent) {
- xmlNodePtr ret = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(parent, ret);
- FIND_ZVAL_NULL(data, ret, style);
- if (data.toBoolean()) {
- 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 Variant to_zval_null(encodeType* /*type*/, xmlNodePtr /*data*/) {
- return init_null();
- }
- static xmlNodePtr to_xml_null(encodeType* /*type*/, const Variant& /*data*/,
- int style, xmlNodePtr parent) {
- xmlNodePtr ret = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(parent, ret);
- if (style == SOAP_ENCODED) {
- set_xsi_nil(ret);
- }
- return ret;
- }
- namespace {
- // Returns Uninit for a missing property. May also return Uninit for properties
- // on objects that haven't yet been initialized.
- TypedValue get_property(const Variant &object, const char* name) {
- String sname(name);
- if (object.isObject()) {
- auto const obj = object.toObject();
- auto const lval = obj->getPropIgnoreAccessibility(sname.get());
- return lval ? lval.tv() : make_tv<KindOfUninit>();
- } else if (object.isArray()) {
- return object.asCArrRef()->get(sname.get());
- }
- return make_tv<KindOfUninit>();
- }
- }
- const StaticString
- s_any("any"),
- s__("_");
- static void model_to_zval_any(Variant &ret, xmlNodePtr node) {
- const char* name = nullptr;
- Variant any;
- while (node != nullptr) {
- auto const prop = get_property(ret, (const char *)node->name);
- if (type(prop) == KindOfUninit) {
- Variant val = master_to_zval(get_conversion(XSD_ANYXML), node);
- if (!any.isNull() && !any.isArray()) {
- Array arr = Array::Create();
- if (name) {
- arr.set(String(name, CopyString), any);
- } else {
- arr.append(any);
- }
- any = arr;
- }
- if (val.isString() && val.toString().charAt(0) == '<') {
- name = nullptr;
- while (node->next != nullptr) {
- Variant val2 = master_to_zval(get_conversion(XSD_ANYXML),
- node->next);
- if (!val2.isString()) {
- break;
- }
- concat_assign(val.asTypedValue(), val2.toString());
- node = node->next;
- }
- } else {
- name = (const char*)node->name;
- }
- if (any.isNull()) {
- if (name) {
- Array arr = Array::Create();
- arr.set(String(name, CopyString), val);
- any = arr;
- name = nullptr;
- } else {
- any = val;
- }
- } else {
- /* Add array element */
- if (name) {
- String name_str(name);
- if (any.asArrRef().exists(name_str)) {
- auto const el = any.asArrRef().lval(name_str);
- if (!isArrayLikeType(el.type())) {
- /* Convert into array */
- Array arr = Array::Create();
- arr.append(el.tv());
- tvSet(make_array_like_tv(arr.get()), el);
- }
- asArrRef(el).append(val);
- } else {
- any.asArrRef().set(name_str, val);
- }
- } else {
- any.asArrRef().append(val);
- }
- name = nullptr;
- }
- }
- node = node->next;
- }
- if (any.toBoolean()) {
- if (name) {
- ret.toObject()->o_set(String(name), any);
- } else {
- ret.toObject()->setProp(nullptr, s_any.get(), *any.asTypedValue());
- }
- }
- }
- static void model_to_zval_object(Variant &ret, sdlContentModelPtr model,
- xmlNodePtr data, sdl *sdl) {
- USE_SOAP_GLOBAL;
- switch (model->kind) {
- case XSD_CONTENT_ELEMENT:
- if (!model->u_element->name.empty()) {
- xmlNodePtr node = get_node(data->children,
- (char*)model->u_element->name.c_str());
- if (node) {
- Variant val;
- xmlNodePtr r_node = check_and_resolve_href(node);
- if (r_node && r_node->children && r_node->children->content) {
- if (!model->u_element->fixed.empty() &&
- model->u_element->fixed != (char*)r_node->children->content) {
- throw SoapException("Encoding: Element '%s' has fixed value '%s' "
- "(value '%s' is not allowed)",
- model->u_element->name.c_str(),
- model->u_element->fixed.c_str(),
- r_node->children->content);
- }
- val = master_to_zval(model->u_element->encode, r_node);
- } else if (!model->u_element->fixed.empty()) {
- xmlNodePtr dummy = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlNodeSetContent(dummy, BAD_CAST(model->u_element->fixed.c_str()));
- val = master_to_zval(model->u_element->encode, dummy);
- xmlFreeNode(dummy);
- } else if (!model->u_element->def.empty() &&
- !model->u_element->nillable) {
- xmlNodePtr dummy = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlNodeSetContent(dummy,
- BAD_CAST(model->u_element->def.c_str()));
- val = master_to_zval(model->u_element->encode, dummy);
- xmlFreeNode(dummy);
- } else {
- val = master_to_zval(model->u_element->encode, r_node);
- }
- if ((node = get_node(node->next,
- (char*)model->u_element->name.c_str())) != nullptr) {
- Array array = Array::Create();
- array.append(val);
- do {
- if (node && node->children && node->children->content) {
- if (!model->u_element->fixed.empty() &&
- model->u_element->fixed != (char*)node->children->content) {
- throw SoapException("Encoding: Element '%s' has fixed value "
- "'%s' (value '%s' is not allowed)",
- model->u_element->name.c_str(),
- model->u_element->fixed.c_str(),
- node->children->content);
- }
- val = master_to_zval(model->u_element->encode, node);
- } else if (!model->u_element->fixed.empty()) {
- xmlNodePtr dummy = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlNodeSetContent(dummy,
- BAD_CAST(model->u_element->fixed.c_str()));
- val = master_to_zval(model->u_element->encode, dummy);
- xmlFreeNode(dummy);
- } else if (!model->u_element->def.empty() &&
- !model->u_element->nillable) {
- xmlNodePtr dummy = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlNodeSetContent(dummy,
- BAD_CAST(model->u_element->def.c_str()));
- val = master_to_zval(model->u_element->encode, dummy);
- xmlFreeNode(dummy);
- } else {
- val = master_to_zval(model->u_element->encode, node);
- }
- array.append(val);
- } while ((node = get_node
- (node->next,
- (char*)model->u_element->name.c_str())) != nullptr);
- val = array;
- } else if ((!val.isNull() || !model->u_element->nillable) &&
- (SOAP_GLOBAL(features) & SOAP_SINGLE_ELEMENT_ARRAYS) &&
- (model->max_occurs == -1 || model->max_occurs > 1)) {
- Array array = Array::Create();
- array.append(val);
- val = array;
- }
- ret.toObject()->o_set(String(model->u_element->name), val);
- }
- }
- break;
- case XSD_CONTENT_ALL:
- case XSD_CONTENT_SEQUENCE:
- case XSD_CONTENT_CHOICE: {
- sdlContentModelPtr any;
- for (unsigned int i = 0; i < model->u_content.size(); i++) {
- sdlContentModelPtr content = model->u_content[i];
- if (content->kind == XSD_CONTENT_ANY) {
- any = content;
- } else {
- model_to_zval_object(ret, content, data, sdl);
- }
- }
- 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 Variant to_zval_object_ex(encodeType* etype, xmlNodePtr data,
- const char *pce) {
- USE_SOAP_GLOBAL;
- const char *ce = "stdClass";
- String clsname;
- if (pce) {
- ce = pce;
- } else if (!SOAP_GLOBAL(classmap).empty() && !etype->type_str.empty()) {
- String type_str(etype->type_str);
- if (SOAP_GLOBAL(classmap).exists(type_str)) {
- clsname = SOAP_GLOBAL(classmap)[type_str].toString();
- ce = clsname.data();
- }
- }
- Variant ret;
- bool redo_any = false;
- sdlType *sdlType = etype->sdl_type;
- sdl *sdl = SOAP_GLOBAL(sdl);
- if (sdlType) {
- if (sdlType->kind == XSD_TYPEKIND_RESTRICTION &&
- sdlType->encode && etype != &sdlType->encode->details) {
- encodePtr 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) {
- if (soap_check_xml_ref(ret, data)) {
- return ret;
- }
- ret = create_object(ce, Array());
- ret.toObject()->setProp(nullptr, s__.get(),
- *master_to_zval_int(enc, data).asTypedValue());
- } else {
- FIND_XML_NULL(data, ret);
- if (soap_check_xml_ref(ret, data)) {
- return ret;
- }
- ret = create_object(ce, Array());
- soap_add_xml_ref(ret, data);
- }
- } else if (sdlType->kind == XSD_TYPEKIND_EXTENSION &&
- sdlType->encode &&
- etype != &sdlType->encode->details) {
- encodeType &details = sdlType->encode->details;
- if (details.sdl_type &&
- details.sdl_type->kind != XSD_TYPEKIND_SIMPLE &&
- details.sdl_type->kind != XSD_TYPEKIND_LIST &&
- details.sdl_type->kind != XSD_TYPEKIND_UNION) {
- CHECK_XML_NULL(data)
- if (soap_check_xml_ref(ret, data)) {
- return ret;
- }
- if (strcasecmp(ce, "stdClass") != 0 &&
- sdlType->encode->to_zval == sdl_guess_convert_zval &&
- details.sdl_type != nullptr &&
- (details.sdl_type->kind == XSD_TYPEKIND_COMPLEX ||
- details.sdl_type->kind == XSD_TYPEKIND_RESTRICTION ||
- details.sdl_type->kind == XSD_TYPEKIND_EXTENSION) &&
- (details.sdl_type->encode == nullptr ||
- !isSoapArrayType(details.sdl_type->encode->details.type))) {
- ret = to_zval_object_ex(&sdlType->encode->details, data, ce);
- } else {
- ret = master_to_zval_int(sdlType->encode, data);
- }
- soap_add_xml_ref(ret, data);
- redo_any = type(get_property(ret, "any")) != KindOfUninit;
- } else {
- if (soap_check_xml_ref(ret, data)) {
- return ret;
- }
- ret = create_object(ce, Array());
- soap_add_xml_ref(ret, data);
- ret.toObject()->setProp(
- nullptr,
- s__.get(),
- *master_to_zval_int(sdlType->encode, data).asTypedValue()
- );
- }
- } else {
- FIND_XML_NULL(data, ret);
- if (soap_check_xml_ref(ret, data)) {
- return ret;
- }
- ret = create_object(ce, Array());
- soap_add_xml_ref(ret, data);
- }
- if (sdlType->model) {
- if (redo_any) {
- ret.toObject()->unsetProp(nullptr, s_any.get());
- soap_add_xml_ref(ret, data);
- }
- model_to_zval_object(ret, sdlType->model, data, sdl);
- if (redo_any) {
- model_to_zval_any(ret, data->children);
- }
- }
- if (!sdlType->attributes.empty()) {
- for (sdlAttributeMap::const_iterator iter = sdlType->attributes.begin();
- iter != sdlType->attributes.end(); ++iter) {
- sdlAttributePtr attr = iter->second;
- if (!attr->name.empty()) {
- xmlAttrPtr val = get_attribute(data->properties,
- (char*)attr->name.c_str());
- const char *str_val = nullptr;
- if (val && val->children && val->children->content) {
- str_val = (char*)val->children->content;
- if (!attr->fixed.empty() && attr->fixed != str_val) {
- throw SoapException("Encoding: Attribute '%s' has fixed value"
- " '%s' (value '%s' is not allowed)",
- attr->name.c_str(), attr->fixed.c_str(),
- str_val);
- }
- } else if (!attr->fixed.empty()) {
- str_val = attr->fixed.c_str();
- } else if (!attr->def.empty()) {
- str_val = attr->def.c_str();
- }
- if (str_val) {
- xmlNodePtr dummy = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlNodePtr text = xmlNewText(BAD_CAST(str_val));
- xmlAddChild(dummy, text);
- Variant data = master_to_zval(attr->encode, dummy);
- xmlFreeNode(dummy);
- ret.toObject()->o_set(String(attr->name), data);
- }
- }
- }
- }
- } else {
- FIND_XML_NULL(data, ret);
- if (soap_check_xml_ref(ret, data)) {
- return ret;
- }
- ret = create_object(ce, Array());
- soap_add_xml_ref(ret, data);
- xmlNodePtr trav = data->children;
- auto obj = ret.asObjRef();
- while (trav != nullptr) {
- if (trav->type == XML_ELEMENT_NODE) {
- Variant tmpVal = master_to_zval(encodePtr(), trav);
- auto const propName = (char*)trav->name;
- // $prop = $ret->{$propName}
- auto const name = String(propName, CopyString);
- auto const prop = obj->getPropIgnoreAccessibility(name.get());
- if (!prop.is_set() || prop.type() == KindOfUninit) {
- if (!trav->next || !get_node(trav->next, propName)) {
- obj->o_set(name, tmpVal);
- } else {
- VArrayInit arr{1};
- arr.append(tmpVal);
- obj->o_set(name, arr.toArray());
- }
- } else {
- if (!isArrayType(prop.type())) {
- /* Convert into array */
- VArrayInit arr{2};
- arr.append(prop.tv());
- arr.append(tmpVal);
- obj->o_set(name, arr.toArray());
- } else {
- asArrRef(prop).append(tmpVal);
- }
- }
- }
- trav = trav->next;
- }
- }
- return ret;
- }
- static Variant to_zval_object(encodeType* type, xmlNodePtr data) {
- return to_zval_object_ex(type, data, nullptr);
- }
- static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model,
- Variant &object, int style, int strict) {
- switch (model->kind) {
- case XSD_CONTENT_ELEMENT: {
- xmlNodePtr property;
- encodePtr enc;
- auto const data = get_property(object, model->u_element->name.c_str());
- if (type(data) != KindOfUninit) {
- if (type(data) == KindOfNull &&
- !model->u_element->nillable && model->min_occurs > 0 && !strict) {
- return 0;
- }
- enc = model->u_element->encode;
- if ((model->max_occurs == -1 || model->max_occurs > 1) &&
- isArrayType(type(data)) &&
- val(data).parr->isVectorData()) {
- for (ArrayIter iter(val(data).parr); iter; ++iter) {
- Variant val = iter.second();
- if (val.isNull() && model->u_element->nillable) {
- property = xmlNewNode(nullptr, 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.empty() &&
- model->u_element->fixed != (char*)property->children->content) {
- throw SoapException("Encoding: Element '%s' has fixed value "
- "'%s' (value '%s' is not allowed)",
- model->u_element->name.c_str(),
- model->u_element->fixed.c_str(),
- property->children->content);
- }
- }
- xmlNodeSetName(property, BAD_CAST(model->u_element->name.c_str()));
- if (style == SOAP_LITERAL &&
- !model->u_element->namens.empty() &&
- model->u_element->form == XSD_FORM_QUALIFIED) {
- xmlNsPtr nsp = encode_add_ns(property,
- model->u_element->namens.c_str());
- xmlSetNs(property, nsp);
- }
- }
- } else {
- if (type(data) == KindOfNull && model->u_element->nillable) {
- property = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(node, property);
- set_xsi_nil(property);
- } else if (type(data) == KindOfNull && model->min_occurs == 0) {
- return 1;
- } else {
- property = master_to_xml(enc, tvAsCVarRef(data), style, node);
- if (property->children && property->children->content &&
- !model->u_element->fixed.empty() &&
- model->u_element->fixed != (char*)property->children->content) {
- throw SoapException("Encoding: Element '%s' has fixed value '%s' "
- "(value '%s' is not allowed)",
- model->u_element->name.c_str(),
- model->u_element->fixed.c_str(),
- property->children->content);
- }
- }
- xmlNodeSetName(property, BAD_CAST(model->u_element->name.c_str()));
- if (style == SOAP_LITERAL &&
- !model->u_element->namens.empty() &&
- model->u_element->form == XSD_FORM_QUALIFIED) {
- xmlNsPtr nsp = encode_add_ns(property,
- model->u_element->namens.c_str());
- xmlSetNs(property, nsp);
- }
- }
- return 1;
- } else if (strict && model->u_element->nillable && model->min_occurs > 0) {
- property = xmlNewNode(nullptr, BAD_CAST(model->u_element->name.c_str()));
- xmlAddChild(node, property);
- set_xsi_nil(property);
- if (style == SOAP_LITERAL &&
- model->u_element->form == XSD_FORM_QUALIFIED) {
- xmlNsPtr nsp = encode_add_ns(property,
- model->u_element->namens.c_str());
- xmlSetNs(property, nsp);
- }
- return 1;
- } else if (model->min_occurs == 0) {
- return 2;
- } else {
- if (strict) {
- throw SoapException("Encoding: object hasn't '%s' property",
- model->u_element->name.c_str());
- }
- return 0;
- }
- break;
- }
- case XSD_CONTENT_ANY: {
- encodePtr enc;
- auto const data = get_property(object, "any");
- if (type(data) != KindOfUninit) {
- enc = get_conversion(XSD_ANYXML);
- if ((model->max_occurs == -1 || model->max_occurs > 1) &&
- isArrayType(type(data)) &&
- val(data).parr->isVectorData()) {
- for (ArrayIter iter(val(data).parr); iter; ++iter) {
- master_to_xml(enc, iter.second(), style, node);
- }
- } else {
- master_to_xml(enc, tvAsCVarRef(data), style, node);
- }
- return 1;
- } else if (model->min_occurs == 0) {
- return 2;
- } else {
- if (strict) {
- throw SoapException( "Encoding: object hasn't 'any' property");
- }
- return 0;
- }
- break;
- }
- case XSD_CONTENT_SEQUENCE:
- case XSD_CONTENT_ALL:
- for (unsigned int i = 0; i < model->u_content.size(); i++) {
- sdlContentModelPtr tmp = model->u_content[i];
- if (!model_to_xml_object(node,tmp,object,style,tmp->min_occurs > 0) &&
- tmp->min_occurs > 0) {
- return 0;
- }
- }
- return 1;
- case XSD_CONTENT_CHOICE: {
- int ret = 0;
- for (unsigned int i = 0; i < model->u_content.size(); i++) {
- sdlContentModelPtr tmp = model->u_content[i];
- 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;
- }
- }
- return ret;
- }
- case XSD_CONTENT_GROUP:
- return model_to_xml_object(node, model->u_group->model, object, style,
- 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 sdlTypePtr(model->u_element, [] (const void*) {});
- } else {
- return sdlTypePtr();
- }
- }
- case XSD_CONTENT_SEQUENCE:
- case XSD_CONTENT_ALL:
- case XSD_CONTENT_CHOICE: {
- if (model->u_content.size() != 1) {
- return sdlTypePtr();
- }
- return model_array_element(model->u_content[0]);
- }
- case XSD_CONTENT_GROUP:
- return model_array_element(model->u_group->model);
- default:
- break;
- }
- return sdlTypePtr();
- }
- static
- xmlNodePtr to_xml_object(encodeType* type, const Variant& data_, int style,
- xmlNodePtr parent) {
- xmlNodePtr xmlParam;
- sdlType *sdlType = type->sdl_type;
- Variant data = data_;
- if (data.isNull()) {
- xmlParam = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(parent, xmlParam);
- if (style == SOAP_ENCODED) {
- set_xsi_nil(xmlParam);
- set_ns_and_type(xmlParam, type);
- }
- return xmlParam;
- }
- Array prop;
- if (data.isObject() || data.isArray()) {
- prop = data.toArray();
- }
- if (sdlType) {
- if (sdlType->kind == XSD_TYPEKIND_RESTRICTION &&
- sdlType->encode && type != &sdlType->encode->details) {
- encodePtr 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) {
- auto const tmp = get_property(data, "_");
- if (tmp.m_type != KindOfUninit) {
- xmlParam = master_to_xml(enc, tvAsCVarRef(tmp), style, parent);
- } else if (prop.isNull()) {
- xmlParam = master_to_xml(enc, data, style, parent);
- } else {
- xmlParam = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(parent, xmlParam);
- }
- } else {
- xmlParam = xmlNewNode(nullptr, 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) {
- xmlParam = master_to_xml_int(sdlType->encode, data, style,
- parent, false);
- } else {
- auto const enc = sdlType->encode;
- auto const tmp = get_property(data, "_");
- if (tmp.m_type != KindOfUninit) {
- xmlParam = master_to_xml(enc, tvAsCVarRef(tmp), style, parent);
- } else if (prop.isNull()) {
- xmlParam = master_to_xml(enc, data, style, parent);
- } else {
- xmlParam = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(parent, xmlParam);
- }
- }
- } else {
- xmlParam = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(parent, xmlParam);
- }
- if (soap_check_zval_ref(data, xmlParam)) {
- return xmlParam;
- }
- if (!prop.isNull()) {
- sdlTypePtr array_el;
- if (data.isArray() && data.toArray()->isVectorData() &&
- sdlType->attributes.empty() && sdlType->model != nullptr &&
- (array_el = model_array_element(sdlType->model)) != nullptr) {
- for (ArrayIter iter(prop); iter; ++iter) {
- Variant val = iter.second();
- xmlNodePtr property;
- if (val.isNull() && array_el->nillable) {
- property = xmlNewNode(nullptr, 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.c_str()));
- if (style == SOAP_LITERAL && !array_el->namens.empty() &&
- array_el->form == XSD_FORM_QUALIFIED) {
- xmlNsPtr nsp = encode_add_ns(property, array_el->namens.c_str());
- xmlSetNs(property, nsp);
- }
- }
- } else if (sdlType->model) {
- model_to_xml_object(xmlParam, sdlType->model, data, style, 1);
- }
- if (!sdlType->attributes.empty()) {
- for (auto const& iter : sdlType->attributes) {
- sdlAttributePtr attr = iter.second;
- if (!attr->name.empty()) {
- auto const rattr = get_property(data, attr->name.c_str());
- if (rattr.m_type != KindOfUninit) {
- xmlNodePtr dummy = master_to_xml(attr->encode, tvAsCVarRef(rattr),
- SOAP_LITERAL, xmlParam);
- if (dummy->children && dummy->children->content) {
- if (!attr->fixed.empty() &&
- attr->fixed != (char*)dummy->children->content) {
- throw SoapException("Encoding: Attribute '%s' has fixed "
- "value '%s' (value '%s' is not allowed)",
- attr->name.c_str(), attr->fixed.c_str(),
- dummy->children->content);
- }
- /* we need to handle xml: namespace specially, since it is
- an implicit schema. Otherwise, use form. */
- if (!strncmp(attr->namens.c_str(), XML_NAMESPACE,
- sizeof(XML_NAMESPACE)) ||
- attr->form == XSD_FORM_QUALIFIED) {
- xmlNsPtr nsp = encode_add_ns(xmlParam, attr->namens.c_str());
- xmlSetNsProp(xmlParam, nsp, BAD_CAST(attr->name.c_str()),
- dummy->children->content);
- } else {
- xmlSetProp(xmlParam, BAD_CAST(attr->name.c_str()),
- dummy->children->content);
- }
- }
- xmlUnlinkNode(dummy);
- xmlFreeNode(dummy);
- }
- }
- }
- }
- }
- if (style == SOAP_ENCODED) {
- set_ns_and_type(xmlParam, type);
- }
- } else {
- xmlParam = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(parent, xmlParam);
- if (soap_check_zval_ref(data, xmlParam)) {
- return xmlParam;
- }
- if (!prop.isNull()) {
- for (ArrayIter iter(prop); iter; ++iter) {
- Variant key = iter.first();
- Variant zprop = iter.second();
- xmlNodePtr property = master_to_xml(
- get_conversion(dataTypeToSoap(zprop.getType())),
- zprop, style, xmlParam);
- if (key.isString()) {
- String skey = key.toString();
- const char *prop_name;
- if (data.isObject()) {
- const char *class_name;
- zend_unmangle_property_name(skey.data(), skey.size(),
- &class_name, &prop_name);
- } else {
- prop_name = skey.data();
- }
- if (prop_name) {
- xmlNodeSetName(property, BAD_CAST(prop_name));
- }
- }
- }
- }
- if (style == SOAP_ENCODED) {
- set_ns_and_type(xmlParam, type);
- }
- }
- return xmlParam;
- }
- /* Array encode/decode */
- static xmlNodePtr guess_array_map(encodeType* /*type*/, const Variant& data,
- int style, xmlNodePtr parent) {
- encodePtr enc;
- if (data.isArray()) {
- if (!data.toArray()->isVectorData()) {
- enc = get_conversion(APACHE_MAP);
- } else {
- enc = get_conversion(SOAP_ENC_ARRAY);
- }
- }
- if (!enc) {
- enc = get_conversion(dataTypeToSoap(KindOfNull));
- }
- 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 == '*') {
- throw SoapException("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 = (int*)req::calloc_noptrs(dimension, sizeof(int));
- 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 == '*') {
- throw SoapException("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 = (int*)req::malloc_noptrs(sizeof(int) * dimension);
- 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,
- const Variant& data,
- int style) {
- if (data.isArray()) {
- Array arr = data.toArray();
- ArrayIter iter(arr);
- for (int j=0; j<dims[0]; j++) {
- Variant zdata = iter.second(); ++iter;
- if (dimension == 1) {
- xmlNodePtr xparam;
- if (!zdata.isNull()) {
- if (enc == nullptr) {
- xparam = master_to_xml(
- get_conversion(dataTypeToSoap(zdata.getType())), zdata,
- style, xmlParam
- );
- } else {
- xparam = master_to_xml(enc, zdata, style, xmlParam);
- }
- } else {
- xparam = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(xmlParam, xparam);
- }
- if (type) {
- xmlNodeSetName(xparam, BAD_CAST(type->name.c_str()));
- } else if (style == SOAP_LITERAL && enc &&
- !enc->details.type_str.empty()) {
- xmlNodeSetName(xparam, BAD_CAST(enc->details.type_str.c_str()));
- xmlSetNs(xparam, ns);
- } else {
- xmlNodeSetName(xparam, BAD_CAST("item"));
- }
- } else {
- if (!zdata.isNull()) {
- add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1,
- zdata, style);
- } else {
- add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1,
- uninit_null(), style);
- }
- }
- }
- } else {
- for (int j=0; j<dims[0]; j++) {
- if (dimension == 1) {
- xmlNodePtr xparam;
- xparam = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(xmlParam, xparam);
- if (type) {
- xmlNodeSetName(xparam, BAD_CAST(type->name.c_str()));
- } else if (style == SOAP_LITERAL && enc &&
- !enc->details.type_str.empty()) {
- xmlNodeSetName(xparam, BAD_CAST(enc->details.type_str.c_str()));
- xmlSetNs(xparam, ns);
- } else {
- xmlNodeSetName(xparam, BAD_CAST("item"));
- }
- } else {
- add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1,
- uninit_null(), style);
- }
- }
- }
- }
- static std::shared_ptr<sdlExtraAttribute>
- get_extra_attributes(sdlType *sdl_type,
- const char *type,
- const char *wsdl_type) {
- if (sdl_type) {
- sdlAttributeMap::const_iterator iterAttributes =
- sdl_type->attributes.find(type);
- if (iterAttributes != sdl_type->attributes.end()) {
- sdlExtraAttributeMap::const_iterator iterExtraAttributes =
- iterAttributes->second->extraAttributes.find(wsdl_type);
- if (iterExtraAttributes !=
- iterAttributes->second->extraAttributes.end()) {
- return iterExtraAttributes->second;
- }
- }
- }
- return std::shared_ptr<sdlExtraAttribute>();
- }
- static
- xmlNodePtr to_xml_array(encodeType* type, const Variant& data_, int style,
- xmlNodePtr parent) {
- USE_SOAP_GLOBAL;
- sdlType *sdl_type = type->sdl_type;
- sdlTypePtr element_type;
- std::string array_type, array_size;
- int i;
- xmlNodePtr xmlParam;
- encodePtr enc;
- int dimension = 1;
- int* dims = nullptr;
- int soap_version;
- Variant array_copy;
- Variant data = data_;
- soap_version = SOAP_GLOBAL(soap_version);
- xmlParam = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(parent, xmlParam);
- if (data.isNull()) {
- 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 (data.isObject() &&
- data.toObject().instanceof(SystemLib::s_HH_IteratorClass)) {
- array_copy = Array::Create();
- for (ArrayIter iter(data.toObject().get()); iter; ++iter) {
- if (!iter.first().isNull() && iter.first().isString()) {
- array_copy.asArrRef().set(iter.first(), iter.second());
- } else {
- array_copy.asArrRef().append(iter.second());
- }
- }
- data = array_copy;
- }
- if (data.isArray()) {
- std::shared_ptr<sdlExtraAttribute> ext;
- sdlTypeMap::const_iterator iterElements;
- sdlAttributeMap::const_iterator iterAttributes;
- sdlExtraAttributeMap::const_iterator iterExtraAttributes;
- sdlTypePtr elementType;
- i = data.toArray().size();
- if ((ext = get_extra_attributes(sdl_type,
- SOAP_1_1_ENC_NAMESPACE":arrayType",
- WSDL_NAMESPACE":arrayType"))) {
- String value(ext->val);
- char *end = const_cast<char*>(strrchr(value.data(), '['));
- if (end) {
- *end = '\0';
- end++;
- dimension = calc_dimension(end);
- }
- if (!ext->ns.empty()) {
- enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns.c_str(), value.data());
- get_type_str(xmlParam, ext->ns.c_str(), value.data(), array_type);
- } else {
- array_type += value.data();
- }
- dims = (int*)req::malloc_noptrs(sizeof(int) * dimension);
- dims[0] = i;
- Array el = data.toArray();
- for (i = 1; i < dimension; i++) {
- if (!el.empty()) {
- ArrayIter iter(el);
- Variant tmp = iter.second();
- if (tmp.isArray()) {
- dims[i] = tmp.toArray().size();
- } else {
- dims[i] = 0;
- }
- }
- }
- array_size += folly::to<string>(dims[0]);
- for (i=1; i<dimension; i++) {
- array_size += ',';
- array_size += folly::to<string>(dims[i]);
- }
- } else if ((ext = get_extra_attributes
- (sdl_type,
- SOAP_1_2_ENC_NAMESPACE":itemType",
- WSDL_NAMESPACE":itemType"))) {
- if (!ext->ns.empty()) {
- enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns.c_str(), ext->val.c_str());
- get_type_str(xmlParam, ext->ns.c_str(), ext->val.c_str(), array_type);
- } else {
- array_type += ext->val;
- }
- if ((iterAttributes =
- sdl_type->attributes.find(SOAP_1_2_ENC_NAMESPACE":arraySize")) !=
- sdl_type->attributes.end()) {
- if ((iterExtraAttributes =
- iterAttributes->second->extraAttributes.find
- (WSDL_NAMESPACE":arraySize")) !=
- iterAttributes->second->extraAttributes.end()) {
- auto ext = iterExtraAttributes->second;
- dimension = calc_dimension_12(ext->val.c_str());
- dims = get_position_12(dimension, ext->val.c_str());
- if (dims[0] == 0) {dims[0] = i;}
- array_size += folly::to<string>(dims[0]);
- for (i=1; i<dimension; i++) {
- array_size += ',';
- array_size += folly::to<string>(dims[i]);
- }
- }
- } else {
- dims = (int*)req::malloc_noptrs(sizeof(int));
- *dims = 0;
- array_size += folly::to<string>(i);
- }
- } else if ((ext = get_extra_attributes
- (sdl_type,
- SOAP_1_2_ENC_NAMESPACE":arraySize",
- WSDL_NAMESPACE":arraySize"))) {
- dimension = calc_dimension_12(ext->val.c_str());
- dims = get_position_12(dimension, ext->val.c_str());
- if (dims[0] == 0) {dims[0] = i;}
- array_size += folly::to<string>(dims[0]);
- for (i=1; i<dimension; i++) {
- array_size += ',';
- array_size += folly::to<string>(dims[i]);
- }
- if (sdl_type && sdl_type->elements.size() == 1 &&
- (elementType = sdl_type->elements[0]) != nullptr &&
- elementType->encode &&
- !elementType->encode->details.type_str.empty()) {
- elementType = sdl_type->elements[0];
- element_type = elementType;
- enc = elementType->encode;
- get_type_str(xmlParam, elementType->encode->details.ns.c_str(),
- elementType->encode->details.type_str.c_str(),
- array_type);
- } else {
- enc = get_array_type(xmlParam, data, array_type);
- }
- } else if
- (sdl_type && sdl_type->elements.size() == 1 &&
- (elementType = sdl_type->elements[0]) != nullptr &&
- elementType->encode &&
- !elementType->encode->details.type_str.empty()) {
- element_type = elementType;
- enc = elementType->encode;
- get_type_str(xmlParam, elementType->encode->details.ns.c_str(),
- elementType->encode->details.type_str.c_str(), array_type);
- array_size += folly::to<string>(i);
- dims = (int*)req::malloc_noptrs(sizeof(int) * dimension);
- dims[0] = i;
- } else {
- enc = get_array_type(xmlParam, data, array_type);
- array_size += folly::to<string>(i);
- dims = (int*)req::malloc_noptrs(sizeof(int) * dimension);
- dims[0] = i;
- }
- if (style == SOAP_ENCODED) {
- if (soap_version == SOAP_1_1) {
- if (array_type == "xsd:anyType") {
- array_type = "xsd:ur-type";
- }
- array_type += '[';
- array_type += array_size;
- array_type += ']';
- set_ns_prop(xmlParam, SOAP_1_1_ENC_NAMESPACE, "arrayType",
- array_type.c_str());
- } else {
- string replaced;
- replaced.reserve(array_size.size());
- for (int i2 = 0; i2 < (int)array_size.size(); i2++) {
- char ch = array_size[i2];
- if (ch == ',') {
- replaced += ' ';
- } else {
- replaced += ch;
- }
- }
- set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "itemType",
- array_type.c_str());
- set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "arraySize",
- replaced.c_str());
- }
- }
- add_xml_array_elements(xmlParam, element_type, enc,
- enc ? encode_add_ns(xmlParam,
- enc->details.ns.c_str()) : nullptr,
- dimension, dims, data, style);
- req::free(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);
- }
- }
- return xmlParam;
- }
- static Variant to_zval_array(encodeType* type, xmlNodePtr data) {
- USE_SOAP_GLOBAL;
- Variant ret;
- xmlNodePtr trav;
- encodePtr enc;
- int dimension = 1;
- int* dims = nullptr;
- int* pos = nullptr;
- xmlAttrPtr attr;
- sdl *sdl;
- sdlAttributePtr arrayType;
- std::shared_ptr<sdlExtraAttribute> ext;
- sdlTypePtr elementType;
- FIND_XML_NULL(data, ret);
- sdl = SOAP_GLOBAL(sdl);
- if (data &&
- (attr = get_attribute(data->properties,"arrayType")) &&
- attr->children && attr->children->content) {
- xmlNsPtr nsptr;
- string type, ns;
- parse_namespace(attr->children->content, type, ns);
- nsptr = xmlSearchNs(attr->doc, attr->parent, NS_STRING(ns));
- String stype(type);
- char *end = const_cast<char*>(strrchr(stype.data(), '['));
- if (end) {
- *end = '\0';
- dimension = calc_dimension(end+1);
- dims = get_position(dimension, end+1);
- }
- if (nsptr != nullptr) {
- enc = get_encoder(sdl, (char*)nsptr->href, stype.data());
- }
- } else if ((attr = get_attribute(data->properties,"itemType")) &&
- attr->children &&
- attr->children->content) {
- string type, ns;
- parse_namespace(attr->children->content, type, ns);
- xmlNsPtr nsptr;
- nsptr = xmlSearchNs(attr->doc, attr->parent, NS_STRING(ns));
- if (nsptr != nullptr) {
- enc = get_encoder(sdl, (char*)nsptr->href, type.data());
- }
- 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 = (int*)req::malloc_noptrs(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 ((ext = get_extra_attributes
- (type->sdl_type,
- SOAP_1_1_ENC_NAMESPACE":arrayType",
- WSDL_NAMESPACE":arrayType"))) {
- String type(ext->val);
- char *end = const_cast<char*>(strrchr(type.data(), '['));
- if (end) {
- *end = '\0';
- }
- if (!ext->ns.empty()) {
- enc = get_encoder(sdl, ext->ns.c_str(), type.data());
- }
- dims = (int*)req::malloc_noptrs(sizeof(int));
- *dims = 0;
- } else if ((ext = get_extra_attributes
- (type->sdl_type,
- SOAP_1_2_ENC_NAMESPACE":itemType",
- WSDL_NAMESPACE":itemType"))) {
- if (!ext->ns.empty()) {
- enc = get_encoder(sdl, ext->ns.c_str(), ext->val.c_str());
- }
- if ((ext = get_extra_attributes
- (type->sdl_type,
- SOAP_1_2_ENC_NAMESPACE":arraySize",
- WSDL_NAMESPACE":arraySize"))) {
- dimension = calc_dimension_12(ext->val.c_str());
- dims = get_position_12(dimension, ext->val.c_str());
- } else {
- dims = (int*)req::malloc_noptrs(sizeof(int));
- *dims = 0;
- }
- } else if ((ext = get_extra_attributes
- (type->sdl_type,
- SOAP_1_2_ENC_NAMESPACE":arraySize",
- WSDL_NAMESPACE":arraySize"))) {
- dimension = calc_dimension_12(ext->val.c_str());
- dims = get_position_12(dimension, ext->val.c_str());
- if (type->sdl_type && type->sdl_type->elements.size() == 1 &&
- (elementType = type->sdl_type->elements[0]) != nullptr &&
- elementType->encode) {
- enc = elementType->encode;
- }
- } else if (type->sdl_type && type->sdl_type->elements.size() == 1 &&
- (elementType = type->sdl_type->elements[0]) != nullptr &&
- elementType->encode) {
- enc = elementType->encode;
- }
- if (dims == nullptr) {
- dimension = 1;
- dims = (int*)req::malloc_noptrs(sizeof(int));
- *dims = 0;
- }
- pos = (int*)req::calloc_noptrs(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 == nullptr) {
- tmp = (char*)attr->children->content;
- }
- get_position_ex(dimension, tmp, &pos);
- }
- ret = Array::Create();
- trav = data->children;
- while (trav) {
- if (trav->type == XML_ELEMENT_NODE) {
- int i;
- xmlAttrPtr position = get_attribute(trav->properties,"position");
- Variant tmpVal = master_to_zval(enc, trav);
- if (position != nullptr && position->children &&
- position->children->content) {
- char* tmp = strrchr((char*)position->children->content, '[');
- if (tmp == nullptr) {
- tmp = (char*)position->children->content;
- }
- get_position_ex(dimension, tmp, &pos);
- }
- /* Get/Create intermediate arrays for multidimensional arrays */
- i = 0;
- tv_lval ar = ret.asTypedValue();
- while (i < dimension-1) {
- auto& arr = asArrRef(ar);
- if (!arr.exists(pos[i])) {
- arr.set(pos[i], Array::Create());
- }
- ar = arr.lval(pos[i]);
- i++;
- }
- asArrRef(ar).set(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;
- }
- req::free(dims);
- req::free(pos);
- return ret;
- }
- /* Map encode/decode */
- static xmlNodePtr to_xml_map(encodeType* type, const Variant& data, int style,
- xmlNodePtr parent) {
- xmlNodePtr xmlParam;
- int i;
- xmlParam = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(parent, xmlParam);
- FIND_ZVAL_NULL(data, xmlParam, style);
- if (data.isArray()) {
- Array arr = data.toArray();
- i = arr.size();
- ArrayIter iter(arr);
- for (;i > 0;i--) {
- xmlNodePtr xparam, item;
- xmlNodePtr key;
- Variant temp_key = iter.first();
- Variant temp_data = iter.second();
- ++iter;
- item = xmlNewNode(nullptr, BAD_CAST("item"));
- xmlAddChild(xmlParam, item);
- key = xmlNewNode(nullptr, BAD_CAST("key"));
- xmlAddChild(item,key);
- if (temp_key.isString()) {
- if (style == SOAP_ENCODED) {
- set_xsi_type(key, "xsd:string");
- }
- xmlNodeSetContent(key, BAD_CAST(temp_key.toString().data()));
- } else {
- if (style == SOAP_ENCODED) {
- set_xsi_type(key, "xsd:int");
- }
- String skey = temp_key.toString();
- xmlNodeSetContentLen(key, BAD_CAST(skey.data()), skey.size());
- }
- xparam = master_to_xml(
- get_conversion(dataTypeToSoap(temp_data.getType())),
- temp_data, style, item
- );
- xmlNodeSetName(xparam, BAD_CAST("value"));
- }
- }
- if (style == SOAP_ENCODED) {
- set_ns_and_type(xmlParam, type);
- }
- return xmlParam;
- }
- static Variant to_zval_map(encodeType* /*type*/, xmlNodePtr data) {
- Variant key, value;
- Array ret;
- xmlNodePtr trav, item, xmlKey, xmlValue;
- FIND_XML_NULL(data, ret);
- if (data && data->children) {
- trav = data->children;
- FOREACHNODE(trav, "item", item) {
- xmlKey = get_node(item->children, "key");
- if (!xmlKey) {
- throw SoapException( "Encoding: Can't decode map, missing key");
- }
- xmlValue = get_node(item->children, "value");
- if (!xmlKey) {
- throw SoapException( "Encoding: Can't decode map, missing value");
- }
- key = master_to_zval(encodePtr(), xmlKey);
- value = master_to_zval(encodePtr(), xmlValue);
- if (key.isString() || key.isInteger()) {
- ret.set(key, value);
- } else {
- throw SoapException( "Encoding: Can't decode map, only Strings or "
- "Longs are allowd as keys");
- }
- }
- ENDFOREACH(trav);
- }
- return ret;
- }
- /* Unknown encode/decode */
- static xmlNodePtr guess_xml_convert(encodeType* /*type*/, const Variant& data,
- int style, xmlNodePtr parent) {
- encodePtr enc = get_conversion(dataTypeToSoap(data.getType()));
- xmlNodePtr ret = master_to_xml_int(enc, data, style, parent, false);
- /*
- if (style == SOAP_LITERAL && SOAP_GLOBAL(sdl)) {
- set_ns_and_type(ret, &enc->details);
- }
- */
- return ret;
- }
- static Variant guess_zval_convert(encodeType* type, xmlNodePtr data) {
- USE_SOAP_GLOBAL;
- encodePtr enc;
- xmlAttrPtr tmpattr;
- xmlChar *type_name = nullptr;
- Variant ret;
- data = check_and_resolve_href(data);
- if (data == nullptr) {
- enc = get_conversion(dataTypeToSoap(KindOfNull));
- } else if (data->properties &&
- get_attribute_ex(data->properties, "nil", XSI_NAMESPACE)) {
- enc = get_conversion(dataTypeToSoap(KindOfNull));
- } else {
- tmpattr = get_attribute_ex(data->properties,"type", XSI_NAMESPACE);
- if (tmpattr != nullptr) {
- type_name = tmpattr->children->content;
- enc = get_encoder_from_prefix(SOAP_GLOBAL(sdl), data,
- tmpattr->children->content);
- if (enc && type == &enc->details) {
- enc.reset();
- }
- if (enc) {
- encodePtr tmp = enc;
- while (tmp && tmp->details.sdl_type != nullptr &&
- tmp->details.sdl_type->kind != XSD_TYPEKIND_COMPLEX) {
- if (enc == tmp->details.sdl_type->encode ||
- tmp == tmp->details.sdl_type->encode) {
- enc.reset();
- break;
- }
- tmp = tmp->details.sdl_type->encode;
- }
- }
- }
- if (!enc) {
- /* 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 != nullptr) {
- if (trav->type == XML_ELEMENT_NODE) {
- enc = get_conversion(SOAP_ENC_OBJECT);
- break;
- }
- trav = trav->next;
- }
- }
- }
- }
- ret = master_to_zval_int(enc, data);
- if (SOAP_GLOBAL(sdl) && type_name && enc->details.sdl_type) {
- Object obj{SoapVar::getClass()};
- SoapVar::setEncType(obj.get(), enc->details.type);
- SoapVar::setEncValue(obj.get(), ret);
- string ns, cptype;
- parse_namespace(type_name, cptype, ns);
- xmlNsPtr nsptr = xmlSearchNs(data->doc, data, NS_STRING(ns));
- SoapVar::setEncSType(obj.get(), cptype);
- if (nsptr) {
- SoapVar::setEncNS(obj.get(), String((char*)nsptr->href, CopyString));
- }
- ret = std::move(obj);
- }
- return ret;
- }
- /* Time encode/decode */
- static xmlNodePtr to_xml_datetime_ex(encodeType* type, const Variant& data,
- const 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 = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(parent, xmlParam);
- FIND_ZVAL_NULL(data, xmlParam, style);
- if (data.isInteger()) {
- timestamp = data.toInt64();
- ta = localtime_r(×tamp, &tmbuf);
- /*ta = php_gmtime_r(×tamp, &tmbuf);*/
- buf = (char *)req::malloc_noptrs(buf_len);
- while ((real_len = strftime(buf, buf_len, format, ta)) == buf_len ||
- real_len == 0) {
- buf_len *= 2;
- buf = (char *)req::realloc_noptrs(buf, buf_len);
- if (!--max_reallocs) break;
- }
- #ifndef _MSC_VER
- /* Time zone support */
- snprintf(tzbuf, sizeof(tzbuf), "%c%02d:%02d",
- (ta->tm_gmtoff < 0) ? '-' : '+', (int)abs(ta->tm_gmtoff / 3600),
- (int)abs( (ta->tm_gmtoff % 3600) / 60 ));
- if (strcmp(tzbuf,"+00:00") == 0) {
- strcpy(tzbuf,"Z");
- real_len++;
- } else {
- real_len += 6;
- }
- #endif
- if (real_len >= buf_len) {
- buf = (char *)req::realloc_noptrs(buf, real_len+1);
- }
- strncat(buf, tzbuf, real_len);
- xmlNodeSetContent(xmlParam, BAD_CAST(buf));
- req::free(buf);
- } else if (data.isString()) {
- String sdata = data.toString();
- xmlNodeSetContentLen(xmlParam, BAD_CAST(sdata.data()), sdata.size());
- }
- if (style == SOAP_ENCODED) {
- set_ns_and_type(xmlParam, type);
- }
- return xmlParam;
- }
- static
- xmlNodePtr to_xml_duration(encodeType* type, const Variant& 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(encodeType* type, const Variant& 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(encodeType* type, const Variant& data, int style,
- xmlNodePtr parent) {
- /* TODO: microsecconds */
- return to_xml_datetime_ex(type, data, "%H:%M:%S", style, parent);
- }
- static xmlNodePtr to_xml_date(encodeType* type, const Variant& data, int style,
- xmlNodePtr parent) {
- return to_xml_datetime_ex(type, data, "%Y-%m-%d", style, parent);
- }
- static xmlNodePtr to_xml_gyearmonth(encodeType* type, const Variant& data,
- int style, xmlNodePtr parent) {
- return to_xml_datetime_ex(type, data, "%Y-%m", style, parent);
- }
- static xmlNodePtr to_xml_gyear(encodeType* type, const Variant& data, int style,
- xmlNodePtr parent) {
- return to_xml_datetime_ex(type, data, "%Y", style, parent);
- }
- static
- xmlNodePtr to_xml_gmonthday(encodeType* type, const Variant& data, int style,
- xmlNodePtr parent) {
- return to_xml_datetime_ex(type, data, "--%m-%d", style, parent);
- }
- static xmlNodePtr to_xml_gday(encodeType* type, const Variant& data, int style,
- xmlNodePtr parent) {
- return to_xml_datetime_ex(type, data, "---%d", style, parent);
- }
- static
- xmlNodePtr to_xml_gmonth(encodeType* type, const Variant& data, int style,
- xmlNodePtr parent) {
- return to_xml_datetime_ex(type, data, "--%m--", style, parent);
- }
- static Variant to_zval_list(encodeType* enc, xmlNodePtr data) {
- /*FIXME*/
- return to_zval_stringc(enc, data);
- }
- static xmlNodePtr to_xml_list(encodeType* enc, const Variant& data, int style,
- xmlNodePtr parent) {
- encodePtr list_enc;
- if (enc->sdl_type && enc->sdl_type->kind == XSD_TYPEKIND_LIST &&
- !enc->sdl_type->elements.empty()) {
- list_enc = enc->sdl_type->elements[0]->encode;
- }
- xmlNodePtr ret = xmlNewNode(nullptr, BAD_CAST("BOGUS"));
- xmlAddChild(parent, ret);
- FIND_ZVAL_NULL(data, ret, style);
- if (data.isArray()) {
- Variant tmp;
- string list;
- Array ht = data.toArray();
- for (ArrayIter iter(ht); iter; ++iter) {
- xmlNodePtr dummy = master_to_xml(list_enc, tmp, SOAP_LITERAL, ret);
- if (dummy && dummy->children && dummy->children->content) {
- if (!list.empty()) {
- list += ' ';
- }
- list += (char*)dummy->children->content;
- } else {
- throw SoapException("Encoding: Violation of encoding rules");
- }
- xmlUnlinkNode(dummy);
- xmlFreeNode(dummy);
- }
- xmlNodeSetContentLen(ret, BAD_CAST(list.c_str()), list.size());
- } else {
- String sdata = data.toString();
- char *str = req::strndup(sdata.data(), sdata.size());
- whiteSpace_collapse(BAD_CAST(str));
- char *start = str;
- char *next;
- string list;
- while (start != nullptr && *start != '\0') {
- xmlNodePtr dummy;
- Variant dummy_zval;
- next = strchr(start,' ');
- if (next != nullptr) {
- *next = '\0';
- next++;
- }
- dummy_zval = String(start);
- dummy = master_to_xml(list_enc, dummy_zval, SOAP_LITERAL, ret);
- if (dummy && dummy->children && dummy->children->content) {
- if (!list.empty()) {
- list += ' ';
- }
- list += (char*)dummy->children->content;
- } else {
- throw SoapException("Encoding: Violation of encoding rules");
- }
- xmlUnlinkNode(dummy);
- xmlFreeNode(dummy);
- start = next;
- }
- xmlNodeSetContentLen(ret, BAD_CAST(list.c_str()), list.size());
- req::free(str);
- }
- return ret;
- }
- static xmlNodePtr to_xml_list1(encodeType* enc, const Variant& data, int style,
- xmlNodePtr parent) {
- /*FIXME: minLength=1 */
- return to_xml_list(enc,data,style, parent);
- }
- static Variant to_zval_union(encodeType* enc, xmlNodePtr data) {
- /*FIXME*/
- return to_zval_list(enc, data);
- }
- static xmlNodePtr to_xml_union(encodeType* enc, const Variant& data, int style,
- xmlNodePtr parent) {
- /*FIXME*/
- return to_xml_list(enc,data,style, parent);
- }
- static Variant to_zval_any(encodeType* /*type*/, xmlNodePtr data) {
- USE_SOAP_GLOBAL;
- xmlBufferPtr buf;
- Variant ret;
- if (SOAP_GLOBAL(sdl) && !SOAP_GLOBAL(sdl)->elements.empty() && data->name) {
- string nscat;
- if (data->ns && data->ns->href) {
- nscat += (char*)data->ns->href;
- nscat += ':';
- }
- nscat += (char*)data->name;
- sdlTypeMap::const_iterator iter = SOAP_GLOBAL(sdl)->elements.find(nscat);
- if (iter != SOAP_GLOBAL(sdl)->elements.end() && iter->second->encode) {
- return master_to_zval_int(iter->second->encode, data);
- }
- }
- buf = xmlBufferCreate();
- xmlNodeDump(buf, nullptr, data, 0, 0);
- ret = String((char*)xmlBufferContent(buf), CopyString);
- xmlBufferFree(buf);
- return ret;
- }
- static xmlNodePtr to_xml_any(encodeType* /*type*/, const Variant& data,
- int style, xmlNodePtr parent) {
- xmlNodePtr ret = nullptr;
- if (data.isArray()) {
- encodePtr enc = get_conversion(XSD_ANYXML);
- Array arr = data.toArray();
- for (ArrayIter iter(arr); iter; ++iter) {
- ret = master_to_xml(enc, iter.second(), style, parent);
- if (ret && ret->name != xmlStringTextNoenc &&
- iter.first().isString()) {
- xmlNodeSetName(ret, BAD_CAST(iter.first().toString().data()));
- }
- }
- return ret;
- }
- String sdata = data.toString();
- ret = xmlNewTextLen(BAD_CAST(sdata.data()), sdata.size());
- ret->name = xmlStringTextNoenc;
- ret->parent = parent;
- ret->doc = parent->doc;
- ret->prev = parent->last;
- ret->next = nullptr;
- if (parent->last) {
- parent->last->next = ret;
- } else {
- parent->children = ret;
- }
- parent->last = ret;
- return ret;
- }
- Variant sdl_guess_convert_zval(encodeType* enc, xmlNodePtr data) {
- sdlType *type;
- type = enc->sdl_type;
- if (type == nullptr) {
- return guess_zval_convert(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(type->encode, data);
- } else {
- return guess_zval_convert(enc, data);
- }
- break;
- case XSD_TYPEKIND_LIST:
- return to_zval_list(enc, data);
- case XSD_TYPEKIND_UNION:
- return to_zval_union(enc, data);
- case XSD_TYPEKIND_COMPLEX:
- case XSD_TYPEKIND_RESTRICTION:
- case XSD_TYPEKIND_EXTENSION:
- if (type->encode && isSoapArrayType(type->encode->details.type)) {
- return to_zval_array(enc, data);
- }
- return to_zval_object(enc, data);
- default:
- throw SoapException("Encoding: Internal Error");
- }
- return guess_zval_convert(enc, data);
- }
- xmlNodePtr sdl_guess_convert_xml(encodeType* enc, const Variant& data,
- int style, xmlNodePtr parent) {
- sdlType *type;
- xmlNodePtr ret = nullptr;
- type = enc->sdl_type;
- if (type == nullptr) {
- 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);
- } else {
- ret = guess_xml_convert(enc, data, style, parent);
- }
- break;
- case XSD_TYPEKIND_LIST:
- ret = to_xml_list(enc, data, style, parent);
- break;
- case XSD_TYPEKIND_UNION:
- ret = to_xml_union(enc, data, style, parent);
- break;
- case XSD_TYPEKIND_COMPLEX:
- case XSD_TYPEKIND_RESTRICTION:
- case XSD_TYPEKIND_EXTENSION:
- if (type->encode && isSoapArrayType(type->encode->details.type)) {
- return to_xml_array(enc, data, style, parent);
- } else {
- return to_xml_object(enc, data, style, parent);
- }
- break;
- default:
- throw SoapException("Encoding: Internal Error");
- break;
- }
- if (style == SOAP_ENCODED) {
- set_ns_and_type(ret, enc);
- }
- return ret;
- }
- static xmlNodePtr check_and_resolve_href(xmlNodePtr data) {
- if (data && data->properties) {
- xmlAttrPtr href;
- href = data->properties;
- while (1) {
- href = get_attribute(href, "href");
- if (href == nullptr || href->ns == nullptr) {break;}
- href = href->next;
- }
- if (href) {
- /* Internal href try and find node */
- if (href->children->content[0] == '#') {
- xmlNodePtr ret = get_node_with_attribute_recursive
- (data->doc->children, nullptr, "id",
- (char*)&href->children->content[1]);
- if (!ret) {
- throw SoapException("Encoding: Unresolved reference '%s'",
- href->children->content);
- }
- return ret;
- } else {
- /* TODO: External href....? */
- throw SoapException("Encoding: External reference '%s'",
- href->children->content);
- }
- }
- /* SOAP 1.2 enc:id enc:ref */
- href = get_attribute_ex(data->properties, "ref", SOAP_1_2_ENC_NAMESPACE);
- if (href) {
- xmlChar* id;
- xmlNodePtr ret;
- if (href->children->content[0] == '#') {
- id = href->children->content+1;
- } else {
- id = href->children->content;
- }
- ret = get_node_with_attribute_recursive_ex
- (data->doc->children, nullptr, nullptr, "id", (char*)id,
- SOAP_1_2_ENC_NAMESPACE);
- if (!ret) {
- throw SoapException("Encoding: Unresolved reference '%s'",
- href->children->content);
- } else if (ret == data) {
- throw SoapException("Encoding: Violation of id and ref information "
- "items '%s'", href->children->content);
- }
- return ret;
- }
- }
- return data;
- }
- static void set_ns_and_type(xmlNodePtr node, encodeType* type) {
- set_ns_and_type_ex(node, type->ns.c_str(), type->type_str.c_str());
- }
- static void set_ns_and_type_ex(xmlNodePtr node, const char *ns,
- const char *type) {
- string nstype;
- get_type_str(node, ns, type, nstype);
- set_xsi_type(node, nstype.c_str());
- }
- static xmlNsPtr xmlSearchNsPrefixByHref(xmlDocPtr doc, xmlNodePtr node,
- const xmlChar * href) {
- xmlNsPtr cur;
- xmlNodePtr orig = node;
- while (node) {
- if (node->type == XML_ENTITY_REF_NODE ||
- node->type == XML_ENTITY_NODE ||
- node->type == XML_ENTITY_DECL) {
- return nullptr;
- }
- if (node->type == XML_ELEMENT_NODE) {
- cur = node->nsDef;
- while (cur != nullptr) {
- if (cur->prefix && cur->href && xmlStrEqual(cur->href, href)) {
- if (xmlSearchNs(doc, node, cur->prefix) == cur) {
- return cur;
- }
- }
- cur = cur->next;
- }
- if (orig != node) {
- cur = node->ns;
- if (cur != nullptr) {
- if (cur->prefix && cur->href && xmlStrEqual(cur->href, href)) {
- if (xmlSearchNs(doc, node, cur->prefix) == cur) {
- return cur;
- }
- }
- }
- }
- }
- node = node->parent;
- }
- return nullptr;
- }
- xmlNsPtr encode_add_ns(xmlNodePtr node, const char* ns) {
- USE_SOAP_GLOBAL;
- xmlNsPtr xmlns;
- if (ns == nullptr || ns[0] == '\0') {
- return nullptr;
- }
- xmlns = xmlSearchNsByHref(node->doc, node, BAD_CAST(ns));
- if (xmlns != nullptr && xmlns->prefix == nullptr) {
- xmlns = xmlSearchNsPrefixByHref(node->doc, node, BAD_CAST(ns));
- }
- if (xmlns == nullptr) {
- std::map<string, string>::const_iterator iter =
- SOAP_GLOBAL(defEncNs).find(ns);
- if (iter != SOAP_GLOBAL(defEncNs).end()) {
- xmlns = xmlNewNs(node->doc->children, BAD_CAST(ns),
- (xmlChar*)iter->second.c_str());
- } else {
- int num = ++SOAP_GLOBAL(cur_uniq_ns);
- string prefix;
- while (1) {
- prefix = "ns";
- prefix += folly::to<string>(num);
- if (xmlSearchNs(node->doc, node, BAD_CAST(prefix.c_str())) == nullptr) {
- break;
- }
- num = ++SOAP_GLOBAL(cur_uniq_ns);
- }
- xmlns = xmlNewNs(node->doc->children, BAD_CAST(ns),
- BAD_CAST(prefix.c_str()));
- }
- }
- return xmlns;
- }
- static void set_ns_prop(xmlNodePtr node, const char *ns, const char *name,
- const char *val) {
- xmlSetNsProp(node, encode_add_ns(node, ns), BAD_CAST(name), BAD_CAST(val));
- }
- static void set_xsi_nil(xmlNodePtr node) {
- set_ns_prop(node, XSI_NAMESPACE, "nil", "true");
- }
- static void set_xsi_type(xmlNodePtr node, const char *type) {
- set_ns_prop(node, XSI_NAMESPACE, "type", type);
- }
- void encode_reset_ns() {
- USE_SOAP_GLOBAL;
- SOAP_GLOBAL(cur_uniq_ns) = 0;
- SOAP_GLOBAL(cur_uniq_ref) = 0;
- SOAP_GLOBAL(ref_map).clear();
- SOAP_GLOBAL(node_map).clear();
- }
- void encode_finish() {
- USE_SOAP_GLOBAL;
- SOAP_GLOBAL(cur_uniq_ns) = 0;
- SOAP_GLOBAL(cur_uniq_ref) = 0;
- SOAP_GLOBAL(ref_map).clear();
- SOAP_GLOBAL(node_map).clear();
- }
- encodePtr get_conversion(int encode) {
- USE_SOAP_GLOBAL;
- std::map<int, encodePtr>::const_iterator iter =
- SOAP_GLOBAL(defEncIndex).find(encode);
- if (iter != SOAP_GLOBAL(defEncIndex).end()) {
- return iter->second;
- }
- throw SoapException( "Encoding: Cannot find encoding");
- }
- static encodePtr get_array_type(xmlNodePtr node, const Variant& array,
- string &type) {
- USE_SOAP_GLOBAL;
- int i, count, cur_type, prev_type;
- bool different;
- const char *prev_stype = nullptr, *cur_stype = nullptr, *prev_ns = nullptr,
- *cur_ns = nullptr;
- if (!array.isArray()) {
- type += "xsd:anyType";
- return get_conversion(XSD_ANYTYPE);
- }
- Array ht = array.toArray();
- different = false;
- cur_type = prev_type = 0;
- count = ht.size();
- ArrayIter iter(ht);
- for (i = 0;i < count;i++) {
- Variant tmp = iter.second();
- if (tmp.isObject() && tmp.toObject().instanceof(SoapVar::getClass())) {
- auto svobj = tmp.toObject().get();
- cur_type = SoapVar::getEncType(svobj);
- auto enc_stype = SoapVar::getEncSType(svobj);
- if (!enc_stype.empty()) {
- cur_stype = enc_stype.c_str();
- } else {
- cur_stype = nullptr;
- }
- auto enc_ns = SoapVar::getEncNS(svobj);
- if (!enc_ns.empty()) {
- cur_ns = enc_ns.c_str();
- } else {
- cur_ns = nullptr;
- }
- } else if (tmp.isArray() && !tmp.toArray()->isVectorData()) {
- cur_type = APACHE_MAP;
- cur_stype = nullptr;
- cur_ns = nullptr;
- } else {
- cur_type = dataTypeToSoap(tmp.getType());
- cur_stype = nullptr;
- cur_ns = nullptr;
- }
- if (i > 0) {
- if ((cur_type != prev_type) ||
- (cur_stype && prev_stype &&
- strcmp(cur_stype,prev_stype) != 0) ||
- (!cur_stype && cur_stype != prev_stype) ||
- (cur_ns && prev_ns && strcmp(cur_ns,prev_ns)) ||
- (!cur_ns && cur_ns != prev_ns)) {
- different = true;
- break;
- }
- }
- prev_type = cur_type;
- prev_stype = cur_stype;
- prev_ns = cur_ns;
- ++iter;
- }
- if (different || count == 0) {
- type += "xsd:anyType";
- return get_conversion(XSD_ANYTYPE);
- }
- encodePtr enc;
- if (cur_stype) {
- string array_type;
- if (cur_ns) {
- xmlNsPtr ns = encode_add_ns(node,cur_ns);
- type += (char*)ns->prefix;
- type += ':';
- array_type += cur_ns;
- array_type += ':';
- }
- type += cur_stype;
- array_type += cur_stype;
- enc = get_encoder_ex(SOAP_GLOBAL(sdl), array_type);
- } else {
- enc = get_conversion(cur_type);
- get_type_str(node, enc->details.ns.c_str(),
- enc->details.type_str.c_str(), type);
- }
- return enc;
- }
- static void get_type_str(xmlNodePtr node, const char* ns, const char* type,
- string &ret) {
- USE_SOAP_GLOBAL;
- if (ns) {
- xmlNsPtr xmlns;
- if (SOAP_GLOBAL(soap_version) == SOAP_1_2 &&
- strcmp(ns,SOAP_1_1_ENC_NAMESPACE) == 0) {
- ns = SOAP_1_2_ENC_NAMESPACE;
- } else if (SOAP_GLOBAL(soap_version) == SOAP_1_1 &&
- strcmp(ns,SOAP_1_2_ENC_NAMESPACE) == 0) {
- ns = SOAP_1_1_ENC_NAMESPACE;
- }
- xmlns = encode_add_ns(node,ns);
- ret += (char*)xmlns->prefix;
- ret += ':';
- }
- ret += type;
- }
- ///////////////////////////////////////////////////////////////////////////////
- }