/hphp/runtime/ext/soap/encoding.cpp

/*
   +----------------------------------------------------------------------+
   | 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(&timestamp, &tmbuf);
    /*ta = php_gmtime_r(&timestamp, &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;
}

///////////////////////////////////////////////////////////////////////////////
}