}
/* }}} */
+ZEND_API int add_property_str_ex(zval *arg, const char *key, uint key_len, zend_string *str TSRMLS_DC) /* {{{ */
+{
+ zval tmp;
+ zval z_key;
+
+ ZVAL_STR(&tmp, str);
+ ZVAL_STRINGL(&z_key, key, key_len);
+ Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, -1 TSRMLS_CC);
+//??? zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
+ zval_ptr_dtor(&z_key);
+ return SUCCESS;
+}
+/* }}} */
+
ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, const char *str TSRMLS_DC) /* {{{ */
{
zval tmp;
ZEND_API int add_property_bool_ex(zval *arg, const char *key, uint key_len, int b TSRMLS_DC);
ZEND_API int add_property_resource_ex(zval *arg, const char *key, uint key_len, zend_resource *r TSRMLS_DC);
ZEND_API int add_property_double_ex(zval *arg, const char *key, uint key_len, double d TSRMLS_DC);
+ZEND_API int add_property_str_ex(zval *arg, const char *key, uint key_len, zend_string *str TSRMLS_DC);
ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, const char *str TSRMLS_DC);
ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length TSRMLS_DC);
ZEND_API int add_property_zval_ex(zval *arg, const char *key, uint key_len, zval *value TSRMLS_DC);
#define add_property_bool(__arg, __key, __b) add_property_bool_ex(__arg, __key, strlen(__key), __b TSRMLS_CC)
#define add_property_resource(__arg, __key, __r) add_property_resource_ex(__arg, __key, strlen(__key), __r TSRMLS_CC)
#define add_property_double(__arg, __key, __d) add_property_double_ex(__arg, __key, strlen(__key), __d TSRMLS_CC)
+#define add_property_str(__arg, __key, __str) add_property_str_ex(__arg, __key, strlen(__key), __str TSRMLS_CC)
#define add_property_string(__arg, __key, __str) add_property_string_ex(__arg, __key, strlen(__key), __str TSRMLS_CC)
#define add_property_stringl(__arg, __key, __str, __length) add_property_stringl_ex(__arg, __key, strlen(__key), __str, __length TSRMLS_CC)
#define add_property_zval(__arg, __key, __value) add_property_zval_ex(__arg, __key, strlen(__key), __value TSRMLS_CC)
#include "zend_interfaces.h"
/* zval type decode */
-static zval *to_zval_double(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_long(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_bool(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_string(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_stringr(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_stringc(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_map(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_null(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_base64(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_hexbin(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_double(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_long(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_bool(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_string(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_stringr(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_stringc(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_map(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_null(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_base64(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_hexbin(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
static xmlNodePtr to_xml_long(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
static xmlNodePtr to_xml_double(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
static xmlNodePtr to_xml_gmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
static xmlNodePtr to_xml_duration(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
-static zval *to_zval_object(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_object(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_array(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
-static zval *to_zval_any(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_any(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
/* Try and guess for non-wsdl clients and servers */
-static zval *guess_zval_convert(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *guess_zval_convert(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
static int is_map(zval *array);
{ \
xmlAttrPtr null; \
if (!xml) { \
- zval *ret; \
- ALLOC_INIT_ZVAL(ret); \
ZVAL_NULL(ret); \
return ret; \
} \
if (xml->properties) { \
null = get_attribute(xml->properties, "nil"); \
if (null) { \
- zval *ret; \
- ALLOC_INIT_ZVAL(ret); \
ZVAL_NULL(ret); \
return ret; \
} \
{{IS_STRING, XSD_STRING_STRING, XSD_NAMESPACE, NULL}, to_zval_string, to_xml_string},
{{IS_LONG, XSD_INT_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},
{{IS_DOUBLE, XSD_FLOAT_STRING, XSD_NAMESPACE, NULL}, to_zval_double, to_xml_double},
- {{IS_BOOL, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL}, to_zval_bool, to_xml_bool},
+ {{IS_FALSE, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL}, to_zval_bool, to_xml_bool},
+ {{IS_TRUE, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL}, to_zval_bool, to_xml_bool},
{{IS_CONSTANT, XSD_STRING_STRING, XSD_NAMESPACE, NULL}, to_zval_string, to_xml_string},
{{IS_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_1_ENC_NAMESPACE, NULL}, to_zval_array, guess_array_map},
{{IS_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_1_ENC_NAMESPACE, NULL}, to_zval_object, to_xml_object},
static encodePtr find_encoder_by_type_name(sdlPtr sdl, const char *type)
{
if (sdl && sdl->encoders) {
- HashPosition pos;
- encodePtr *enc;
+ encodePtr enc;
- for (zend_hash_internal_pointer_reset_ex(sdl->encoders, &pos);
- zend_hash_get_current_data_ex(sdl->encoders, (void **) &enc, &pos) == SUCCESS;
- zend_hash_move_forward_ex(sdl->encoders, &pos)) {
- if (strcmp((*enc)->details.type_str, type) == 0) {
- return *enc;
+ ZEND_HASH_FOREACH_PTR(sdl->encoders, enc) {
+ if (strcmp(enc->details.type_str, type) == 0) {
+ return enc;
}
- }
+ } ZEND_HASH_FOREACH_END();
}
return NULL;
}
static zend_bool soap_check_zval_ref(zval *data, xmlNodePtr node TSRMLS_DC) {
- xmlNodePtr *node_ptr;
+ xmlNodePtr node_ptr;
if (SOAP_GLOBAL(ref_map)) {
if (Z_TYPE_P(data) == IS_OBJECT) {
- data = (zval*)zend_objects_get_address(data TSRMLS_CC);
+ data = (zval*)Z_OBJ_P(data);
}
- if (zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)data, (void**)&node_ptr) == SUCCESS) {
- xmlAttrPtr attr = (*node_ptr)->properties;
+ if ((node_ptr = zend_hash_index_find_ptr(SOAP_GLOBAL(ref_map), (ulong)data)) != NULL) {
+ xmlAttrPtr attr = node_ptr->properties;
char *id;
smart_str prefix = {0};
- if (*node_ptr == node) {
+ if (node_ptr == node) {
return 0;
}
- xmlNodeSetName(node, (*node_ptr)->name);
- xmlSetNs(node, (*node_ptr)->ns);
+ xmlNodeSetName(node, node_ptr->name);
+ xmlSetNs(node, node_ptr->ns);
if (SOAP_GLOBAL(soap_version) == SOAP_1_1) {
while (1) {
attr = get_attribute(attr, "id");
smart_str_appendc(&prefix, '#');
smart_str_appends(&prefix, id);
smart_str_0(&prefix);
- id = prefix.c;
+ id = prefix.s->val;
} else {
SOAP_GLOBAL(cur_uniq_ref)++;
smart_str_appendl(&prefix, "#ref", 4);
smart_str_append_long(&prefix, SOAP_GLOBAL(cur_uniq_ref));
smart_str_0(&prefix);
- id = prefix.c;
- xmlSetProp((*node_ptr), BAD_CAST("id"), BAD_CAST(id+1));
+ id = prefix.s->val;
+ xmlSetProp(node_ptr, BAD_CAST("id"), BAD_CAST(id+1));
}
xmlSetProp(node, BAD_CAST("href"), BAD_CAST(id));
} else {
smart_str_appendc(&prefix, '#');
smart_str_appends(&prefix, id);
smart_str_0(&prefix);
- id = prefix.c;
+ id = prefix.s->val;
} else {
SOAP_GLOBAL(cur_uniq_ref)++;
smart_str_appendl(&prefix, "#ref", 4);
smart_str_append_long(&prefix, SOAP_GLOBAL(cur_uniq_ref));
smart_str_0(&prefix);
- id = prefix.c;
- set_ns_prop((*node_ptr), SOAP_1_2_ENC_NAMESPACE, "id", id+1);
+ id = prefix.s->val;
+ set_ns_prop(node_ptr, SOAP_1_2_ENC_NAMESPACE, "id", id+1);
}
set_ns_prop(node, SOAP_1_2_ENC_NAMESPACE, "ref", id);
}
smart_str_free(&prefix);
return 1;
} else {
- zend_hash_index_update(SOAP_GLOBAL(ref_map), (ulong)data, (void**)&node, sizeof(xmlNodePtr), NULL);
+ zend_hash_index_update_ptr(SOAP_GLOBAL(ref_map), (ulong)data, node);
}
}
return 0;
static zval* soap_find_xml_ref(xmlNodePtr node TSRMLS_DC)
{
- zval **data_ptr;
+ zval *data_ptr;
if (SOAP_GLOBAL(ref_map) &&
- zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)node, (void**)&data_ptr) == SUCCESS) {
- Z_SET_ISREF_PP(data_ptr);
- Z_ADDREF_PP(data_ptr);
- return *data_ptr;
+ (data_ptr = zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)node)) != NULL) {
+//??? Z_SET_ISREF_PP(data_ptr);
+ SEPARATE_ZVAL_TO_MAKE_IS_REF(data_ptr);
+ Z_ADDREF_P(data_ptr);
+ return data_ptr;
}
return NULL;
}
-static zend_bool soap_check_xml_ref(zval **data, xmlNodePtr node TSRMLS_DC)
+static zend_bool soap_check_xml_ref(zval *data, xmlNodePtr node TSRMLS_DC)
{
- zval **data_ptr;
+ zval *data_ptr;
if (SOAP_GLOBAL(ref_map)) {
- if (zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)node, (void**)&data_ptr) == SUCCESS) {
- if (*data != *data_ptr) {
+ if ((data_ptr = zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)node)) != NULL) {
+ if (data != data_ptr) {
zval_ptr_dtor(data);
- *data = *data_ptr;
- Z_SET_ISREF_PP(data);
- Z_ADDREF_PP(data);
+ ZVAL_COPY_VALUE(data, data_ptr);
+//??? Z_SET_ISREF_PP(data);
+ SEPARATE_ZVAL_TO_MAKE_IS_REF(data);
+ Z_ADDREF_P(data);
return 1;
}
} else {
- zend_hash_index_update(SOAP_GLOBAL(ref_map), (ulong)node, (void**)data, sizeof(zval*), NULL);
+ zend_hash_index_update(SOAP_GLOBAL(ref_map), (ulong)node, data);
}
}
return 0;
if (data &&
Z_TYPE_P(data) == IS_OBJECT &&
Z_OBJCE_P(data) == soap_var_class_entry) {
- zval **ztype, **zdata, **zns, **zstype, **zname, **znamens;
+ zval *ztype, *zdata, *zns, *zstype, *zname, *znamens;
encodePtr enc = NULL;
HashTable *ht = Z_OBJPROP_P(data);
- if (zend_hash_find(ht, "enc_type", sizeof("enc_type"), (void **)&ztype) == FAILURE) {
+ if ((ztype = zend_hash_str_find(ht, "enc_type", sizeof("enc_type")-1)) == NULL) {
soap_error0(E_ERROR, "Encoding: SoapVar has no 'enc_type' property");
}
- if (zend_hash_find(ht, "enc_stype", sizeof("enc_stype"), (void **)&zstype) == SUCCESS) {
- if (zend_hash_find(ht, "enc_ns", sizeof("enc_ns"), (void **)&zns) == SUCCESS) {
- enc = get_encoder(SOAP_GLOBAL(sdl), Z_STRVAL_PP(zns), Z_STRVAL_PP(zstype));
+ if ((zstype = zend_hash_str_find(ht, "enc_stype", sizeof("enc_stype")-1)) != NULL) {
+ if ((zns = zend_hash_str_find(ht, "enc_ns", sizeof("enc_ns")-1)) != NULL) {
+ enc = get_encoder(SOAP_GLOBAL(sdl), Z_STRVAL_P(zns), Z_STRVAL_P(zstype));
} else {
zns = NULL;
- enc = get_encoder_ex(SOAP_GLOBAL(sdl), Z_STRVAL_PP(zstype), Z_STRLEN_PP(zstype));
+ enc = get_encoder_ex(SOAP_GLOBAL(sdl), Z_STRVAL_P(zstype), Z_STRLEN_P(zstype));
}
if (enc == NULL && SOAP_GLOBAL(typemap)) {
- encodePtr *new_enc;
smart_str nscat = {0};
if (zns != NULL) {
- smart_str_appendl(&nscat, Z_STRVAL_PP(zns), Z_STRLEN_PP(zns));
+ smart_str_appendl(&nscat, Z_STRVAL_P(zns), Z_STRLEN_P(zns));
smart_str_appendc(&nscat, ':');
}
- smart_str_appendl(&nscat, Z_STRVAL_PP(zstype), Z_STRLEN_PP(zstype));
+ smart_str_appendl(&nscat, Z_STRVAL_P(zstype), Z_STRLEN_P(zstype));
smart_str_0(&nscat);
- if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) {
- enc = *new_enc;
- }
+ enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s);
smart_str_free(&nscat);
}
}
if (enc == NULL) {
- enc = get_conversion(Z_LVAL_P(*ztype));
+ enc = get_conversion(Z_LVAL_P(ztype));
}
if (enc == NULL) {
enc = encode;
}
- if (zend_hash_find(ht, "enc_value", sizeof("enc_value"), (void **)&zdata) == FAILURE) {
- node = master_to_xml(enc, NULL, style, parent TSRMLS_CC);
- } else {
- node = master_to_xml(enc, *zdata, style, parent TSRMLS_CC);
- }
+ zdata = zend_hash_str_find(ht, "enc_value", sizeof("enc_value")-1);
+ node = master_to_xml(enc, zdata, style, parent TSRMLS_CC);
if (style == SOAP_ENCODED || (SOAP_GLOBAL(sdl) && encode != enc)) {
- if (zend_hash_find(ht, "enc_stype", sizeof("enc_stype"), (void **)&zstype) == SUCCESS) {
- if (zend_hash_find(ht, "enc_ns", sizeof("enc_ns"), (void **)&zns) == SUCCESS) {
- set_ns_and_type_ex(node, Z_STRVAL_PP(zns), Z_STRVAL_PP(zstype));
+ if ((ztype = zend_hash_str_find(ht, "enc_stype", sizeof("enc_stype")-1)) != NULL) {
+ if ((zns = zend_hash_str_find(ht, "enc_ns", sizeof("enc_ns")-1)) != NULL) {
+ set_ns_and_type_ex(node, Z_STRVAL_P(zns), Z_STRVAL_P(zstype));
} else {
- set_ns_and_type_ex(node, NULL, Z_STRVAL_PP(zstype));
+ set_ns_and_type_ex(node, NULL, Z_STRVAL_P(zstype));
}
}
}
- if (zend_hash_find(ht, "enc_name", sizeof("enc_name"), (void **)&zname) == SUCCESS) {
- xmlNodeSetName(node, BAD_CAST(Z_STRVAL_PP(zname)));
+ if ((zname = zend_hash_str_find(ht, "enc_name", sizeof("enc_name")-1)) != NULL) {
+ xmlNodeSetName(node, BAD_CAST(Z_STRVAL_P(zname)));
}
- if (zend_hash_find(ht, "enc_namens", sizeof("enc_namens"), (void **)&znamens) == SUCCESS) {
- xmlNsPtr nsp = encode_add_ns(node, Z_STRVAL_PP(znamens));
+ if ((znamens = zend_hash_str_find(ht, "enc_namens", sizeof("enc_namens")-1)) != NULL) {
+ xmlNsPtr nsp = encode_add_ns(node, Z_STRVAL_P(znamens));
xmlSetNs(node, nsp);
}
} else {
if (check_class_map && SOAP_GLOBAL(class_map) && data &&
Z_TYPE_P(data) == IS_OBJECT &&
- !Z_OBJPROP_P(data)->nApplyCount) {
+ !ZEND_HASH_GET_APPLY_COUNT(Z_OBJPROP_P(data))) {
zend_class_entry *ce = Z_OBJCE_P(data);
- HashPosition pos;
- zval **tmp;
- char *type_name = NULL;
- uint type_len;
- ulong idx;
-
- for (zend_hash_internal_pointer_reset_ex(SOAP_GLOBAL(class_map), &pos);
- zend_hash_get_current_data_ex(SOAP_GLOBAL(class_map), (void **) &tmp, &pos) == SUCCESS;
- zend_hash_move_forward_ex(SOAP_GLOBAL(class_map), &pos)) {
- if (Z_TYPE_PP(tmp) == IS_STRING &&
- ce->name_length == Z_STRLEN_PP(tmp) &&
- zend_binary_strncasecmp(ce->name, ce->name_length, Z_STRVAL_PP(tmp), ce->name_length, ce->name_length) == 0 &&
- zend_hash_get_current_key_ex(SOAP_GLOBAL(class_map), &type_name, &type_len, &idx, 0, &pos) == HASH_KEY_IS_STRING) {
+ zval *tmp;
+ zend_string *type_name;
+
+ ZEND_HASH_FOREACH_STR_KEY_VAL(SOAP_GLOBAL(class_map), type_name, tmp) {
+ if (Z_TYPE_P(tmp) == IS_STRING &&
+ ce->name->len == Z_STRLEN_P(tmp) &&
+ zend_binary_strncasecmp(ce->name->val, ce->name->len, Z_STRVAL_P(tmp), ce->name->len, ce->name->len) == 0 &&
+ type_name) {
/* TODO: namespace isn't stored */
encodePtr enc = NULL;
if (SOAP_GLOBAL(sdl)) {
- enc = get_encoder(SOAP_GLOBAL(sdl), SOAP_GLOBAL(sdl)->target_ns, type_name);
+ enc = get_encoder(SOAP_GLOBAL(sdl), SOAP_GLOBAL(sdl)->target_ns, type_name->val);
if (!enc) {
- enc = find_encoder_by_type_name(SOAP_GLOBAL(sdl), type_name);
+ enc = find_encoder_by_type_name(SOAP_GLOBAL(sdl), type_name->val);
}
}
if (enc) {
}
break;
}
- }
+ } ZEND_HASH_FOREACH_END();
}
if (encode == NULL) {
}
if (SOAP_GLOBAL(typemap) && encode->details.type_str) {
smart_str nscat = {0};
- encodePtr *new_enc;
+ encodePtr new_enc;
if (encode->details.ns) {
smart_str_appends(&nscat, encode->details.ns);
}
smart_str_appends(&nscat, encode->details.type_str);
smart_str_0(&nscat);
- if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) {
- encode = *new_enc;
+ if ((new_enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s)) != NULL) {
+ encode = new_enc;
}
smart_str_free(&nscat);
}
return master_to_xml_int(encode, data, style, parent, 1 TSRMLS_CC);
}
-static zval *master_to_zval_int(encodePtr encode, xmlNodePtr data TSRMLS_DC)
+static zval *master_to_zval_int(zval *ret, encodePtr encode, xmlNodePtr data TSRMLS_DC)
{
- zval *ret = NULL;
-
if (SOAP_GLOBAL(typemap)) {
if (encode->details.type_str) {
smart_str nscat = {0};
- encodePtr *new_enc;
+ encodePtr new_enc;
if (encode->details.ns) {
smart_str_appends(&nscat, encode->details.ns);
}
smart_str_appends(&nscat, encode->details.type_str);
smart_str_0(&nscat);
- if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) {
- encode = *new_enc;
+ if ((new_enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s)) != NULL) {
+ encode = new_enc;
}
smart_str_free(&nscat);
} else {
xmlAttrPtr type_attr = get_attribute_ex(data->properties,"type", XSI_NAMESPACE);
if (type_attr != NULL) {
- encodePtr *new_enc;
+ encodePtr new_enc;
xmlNsPtr nsptr;
char *ns, *cptype;
smart_str nscat = {0};
smart_str_0(&nscat);
efree(cptype);
if (ns) {efree(ns);}
- if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) {
- encode = *new_enc;
+ if ((new_enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s)) != NULL) {
+ encode = new_enc;
}
smart_str_free(&nscat);
}
}
}
if (encode->to_zval) {
- ret = encode->to_zval(&encode->details, data TSRMLS_CC);
+ ret = encode->to_zval(ret, &encode->details, data TSRMLS_CC);
}
return ret;
}
-zval *master_to_zval(encodePtr encode, xmlNodePtr data TSRMLS_DC)
+zval *master_to_zval(zval *ret, encodePtr encode, xmlNodePtr data TSRMLS_DC)
{
data = check_and_resolve_href(data);
}
}
}
- return master_to_zval_int(encode, data TSRMLS_CC);
+ return master_to_zval_int(ret, encode, data TSRMLS_CC);
}
xmlNodePtr to_xml_user(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
{
xmlNodePtr ret = NULL;
- zval *return_value;
+ zval return_value;
- if (type && type->map && type->map->to_xml) {
- MAKE_STD_ZVAL(return_value);
+ if (type && type->map && Z_TYPE(type->map->to_xml) != IS_UNDEF) {
+ ZVAL_NULL(&return_value);
- if (call_user_function(EG(function_table), NULL, type->map->to_xml, return_value, 1, &data TSRMLS_CC) == FAILURE) {
+ if (call_user_function(EG(function_table), NULL, &type->map->to_xml, &return_value, 1, data TSRMLS_CC) == FAILURE) {
soap_error0(E_ERROR, "Encoding: Error calling to_xml callback");
}
- if (Z_TYPE_P(return_value) == IS_STRING) {
- xmlDocPtr doc = soap_xmlParseMemory(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value));
+ if (Z_TYPE(return_value) == IS_STRING) {
+ xmlDocPtr doc = soap_xmlParseMemory(Z_STRVAL(return_value), Z_STRLEN(return_value));
if (doc && doc->children) {
ret = xmlDocCopyNode(doc->children, parent->doc, 1);
}
return ret;
}
-zval *to_zval_user(encodeTypePtr type, xmlNodePtr node TSRMLS_DC)
+zval *to_zval_user(zval *ret, encodeTypePtr type, xmlNodePtr node TSRMLS_DC)
{
- zval *return_value;
-
- if (type && type->map && type->map->to_zval) {
+ if (type && type->map && Z_TYPE(type->map->to_zval) != IS_UNDEF) {
xmlBufferPtr buf;
- zval *data;
+ zval data;
xmlNodePtr copy;
copy = xmlCopyNode(node, 1);
buf = xmlBufferCreate();
xmlNodeDump(buf, NULL, copy, 0, 0);
- MAKE_STD_ZVAL(data);
- ZVAL_STRING(data, (char*)xmlBufferContent(buf), 1);
+ ZVAL_STRING(&data, (char*)xmlBufferContent(buf));
xmlBufferFree(buf);
xmlFreeNode(copy);
- ALLOC_INIT_ZVAL(return_value);
+ ZVAL_NULL(ret);
- if (call_user_function(EG(function_table), NULL, type->map->to_zval, return_value, 1, &data TSRMLS_CC) == FAILURE) {
+ if (call_user_function(EG(function_table), NULL, &type->map->to_zval, ret, 1, &data TSRMLS_CC) == FAILURE) {
soap_error0(E_ERROR, "Encoding: Error calling from_xml callback");
}
zval_ptr_dtor(&data);
} else {
- ALLOC_INIT_ZVAL(return_value);
+ ZVAL_NULL(ret);
}
- return return_value;
+ return ret;
}
/* TODO: get rid of "bogus".. ither by passing in the already created xmlnode or passing in the node name */
/* String encode/decode */
-static zval *to_zval_string(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_string(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
{
- zval *ret;
- MAKE_STD_ZVAL(ret);
+ ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (data && data->children) {
if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);
if (n >= 0) {
- ZVAL_STRING(ret, (char*)xmlBufferContent(out), 1);
+ ZVAL_STRING(ret, (char*)xmlBufferContent(out));
} else {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
+ ZVAL_STRING(ret, (char*)data->children->content);
}
xmlBufferFree(out);
xmlBufferFree(in);
} else {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
+ ZVAL_STRING(ret, (char*)data->children->content);
}
} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
+ ZVAL_STRING(ret, (char*)data->children->content);
} else {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
}
return ret;
}
-static zval *to_zval_stringr(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_stringr(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
{
- zval *ret;
- MAKE_STD_ZVAL(ret);
+ ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (data && data->children) {
if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);
if (n >= 0) {
- ZVAL_STRING(ret, (char*)xmlBufferContent(out), 1);
+ ZVAL_STRING(ret, (char*)xmlBufferContent(out));
} else {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
+ ZVAL_STRING(ret, (char*)data->children->content);
}
xmlBufferFree(out);
xmlBufferFree(in);
} else {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
+ ZVAL_STRING(ret, (char*)data->children->content);
}
} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
+ ZVAL_STRING(ret, (char*)data->children->content);
} else {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
}
return ret;
}
-static zval *to_zval_stringc(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_stringc(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
{
- zval *ret;
- MAKE_STD_ZVAL(ret);
+ ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (data && data->children) {
if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);
if (n >= 0) {
- ZVAL_STRING(ret, (char*)xmlBufferContent(out), 1);
+ ZVAL_STRING(ret, (char*)xmlBufferContent(out));
} else {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
+ ZVAL_STRING(ret, (char*)data->children->content);
}
xmlBufferFree(out);
xmlBufferFree(in);
} else {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
+ ZVAL_STRING(ret, (char*)data->children->content);
}
} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
+ ZVAL_STRING(ret, (char*)data->children->content);
} else {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
}
return ret;
}
-static zval *to_zval_base64(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_base64(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
{
- zval *ret;
- char *str;
- int str_len;
+ zend_string *str;
- MAKE_STD_ZVAL(ret);
+ ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (data && data->children) {
if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
whiteSpace_collapse(data->children->content);
- str = (char*)php_base64_decode(data->children->content, strlen((char*)data->children->content), &str_len);
+ str = php_base64_decode(data->children->content, strlen((char*)data->children->content));
if (!str) {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
}
- ZVAL_STRINGL(ret, str, str_len, 0);
+ ZVAL_STR(ret, str);
} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
- str = (char*)php_base64_decode(data->children->content, strlen((char*)data->children->content), &str_len);
+ str = php_base64_decode(data->children->content, strlen((char*)data->children->content));
if (!str) {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
}
- ZVAL_STRINGL(ret, str, str_len, 0);
+ ZVAL_STR(ret, str);
} else {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
}
return ret;
}
-static zval *to_zval_hexbin(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_hexbin(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
{
- zval *ret;
- unsigned char *str;
- int str_len, i, j;
+ zend_string *str;
+ int i, j;
unsigned char c;
- MAKE_STD_ZVAL(ret);
+ ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (data && data->children) {
if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
return ret;
}
- str_len = strlen((char*)data->children->content) / 2;
- str = emalloc(str_len+1);
- for (i = j = 0; i < str_len; i++) {
+ str = STR_ALLOC(strlen((char*)data->children->content) / 2, 0);
+ for (i = j = 0; i < str->len; i++) {
c = data->children->content[j++];
if (c >= '0' && c <= '9') {
- str[i] = (c - '0') << 4;
+ str->val[i] = (c - '0') << 4;
} else if (c >= 'a' && c <= 'f') {
- str[i] = (c - 'a' + 10) << 4;
+ str->val[i] = (c - 'a' + 10) << 4;
} else if (c >= 'A' && c <= 'F') {
- str[i] = (c - 'A' + 10) << 4;
+ str->val[i] = (c - 'A' + 10) << 4;
} else {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
}
c = data->children->content[j++];
if (c >= '0' && c <= '9') {
- str[i] |= c - '0';
+ str->val[i] |= c - '0';
} else if (c >= 'a' && c <= 'f') {
- str[i] |= c - 'a' + 10;
+ str->val[i] |= c - 'a' + 10;
} else if (c >= 'A' && c <= 'F') {
- str[i] |= c - 'A' + 10;
+ str->val[i] |= c - 'A' + 10;
} else {
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
}
}
- str[str_len] = '\0';
- ZVAL_STRINGL(ret, (char*)str, str_len, 0);
+ str->val[str->len] = '\0';
+ ZVAL_STR(ret, str);
} else {
ZVAL_EMPTY_STRING(ret);
}
static xmlNodePtr to_xml_base64(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
{
xmlNodePtr ret, text;
- unsigned char *str;
- int str_len;
+ zend_string *str;
ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(parent, ret);
FIND_ZVAL_NULL(data, ret, style);
if (Z_TYPE_P(data) == IS_STRING) {
- str = php_base64_encode((unsigned char*)Z_STRVAL_P(data), Z_STRLEN_P(data), &str_len);
- text = xmlNewTextLen(str, str_len);
+ str = php_base64_encode((unsigned char*)Z_STRVAL_P(data), Z_STRLEN_P(data));
+ text = xmlNewTextLen(BAD_CAST(str->val), str->len);
xmlAddChild(ret, text);
- efree(str);
+ STR_RELEASE(str);
} else {
- zval tmp = *data;
-
- zval_copy_ctor(&tmp);
+ zval tmp;
+
+ ZVAL_DUP(&tmp, data);
convert_to_string(&tmp);
- str = php_base64_encode((unsigned char*)Z_STRVAL(tmp), Z_STRLEN(tmp), &str_len);
- text = xmlNewTextLen(str, str_len);
+ str = php_base64_encode((unsigned char*)Z_STRVAL(tmp), Z_STRLEN(tmp));
+ text = xmlNewTextLen(BAD_CAST(str->val), str->len);
xmlAddChild(ret, text);
- efree(str);
+ STR_RELEASE(str);
zval_dtor(&tmp);
}
return ret;
}
-static zval *to_zval_double(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_double(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
{
- zval *ret;
- MAKE_STD_ZVAL(ret);
+ ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (data && data->children) {
whiteSpace_collapse(data->children->content);
switch (is_numeric_string((char*)data->children->content, strlen((char*)data->children->content), &lval, &dval, 0)) {
case IS_LONG:
- Z_TYPE_P(ret) = IS_DOUBLE;
- Z_DVAL_P(ret) = lval;
+ ZVAL_DOUBLE(ret, lval);
break;
case IS_DOUBLE:
- Z_TYPE_P(ret) = IS_DOUBLE;
- Z_DVAL_P(ret) = dval;
+ ZVAL_DOUBLE(ret, dval);
break;
default:
if (strncasecmp((char*)data->children->content, "NaN", sizeof("NaN")-1) == 0) {
return ret;
}
-static zval *to_zval_long(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_long(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
{
- zval *ret;
- MAKE_STD_ZVAL(ret);
+ ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (data && data->children) {
whiteSpace_collapse(data->children->content);
errno = 0;
- switch ((Z_TYPE_P(ret) = is_numeric_string((char*)data->children->content, strlen((char*)data->children->content), &lval, &dval, 0))) {
+ switch (is_numeric_string((char*)data->children->content, strlen((char*)data->children->content), &lval, &dval, 0)) {
case IS_LONG:
- Z_LVAL_P(ret) = lval;
+ ZVAL_LONG(ret, lval);
break;
case IS_DOUBLE:
- Z_DVAL_P(ret) = dval;
+ ZVAL_DOUBLE(ret, dval);
break;
default:
soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
return ret;
}
-static zval *to_zval_bool(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_bool(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
{
- zval *ret;
- MAKE_STD_ZVAL(ret);
+ ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (data && data->children) {
if (stricmp((char*)data->children->content, "true") == 0 ||
stricmp((char*)data->children->content, "t") == 0 ||
strcmp((char*)data->children->content, "1") == 0) {
- ZVAL_BOOL(ret, 1);
+ ZVAL_TRUE(ret);
} else if (stricmp((char*)data->children->content, "false") == 0 ||
stricmp((char*)data->children->content, "f") == 0 ||
strcmp((char*)data->children->content, "0") == 0) {
- ZVAL_BOOL(ret, 0);
+ ZVAL_FALSE(ret);
} else {
- ZVAL_STRING(ret, (char*)data->children->content, 1);
+ ZVAL_STRING(ret, (char*)data->children->content);
convert_to_boolean(ret);
}
} else {
}
/* Null encode/decode */
-static zval *to_zval_null(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_null(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
{
- zval *ret;
- MAKE_STD_ZVAL(ret);
ZVAL_NULL(ret);
return ret;
}
EG(scope) = old_scope;
}
-static zval* get_zval_property(zval* object, char* name TSRMLS_DC)
+static zval* get_zval_property(zval* object, char* name, zval *rv TSRMLS_DC)
{
if (Z_TYPE_P(object) == IS_OBJECT) {
- zval member;
+ zval member, rv;
zval *data;
zend_class_entry *old_scope;
- INIT_PZVAL(&member);
- ZVAL_STRING(&member, name, 0);
+//??? INIT_PZVAL(&member);
+//??? ZVAL_STRING(&member, name, 0);
+ ZVAL_STRING(&member, name);
old_scope = EG(scope);
EG(scope) = Z_OBJCE_P(object);
- data = Z_OBJ_HT_P(object)->read_property(object, &member, BP_VAR_IS, 0 TSRMLS_CC);
- if (data == EG(uninitialized_zval_ptr)) {
+ data = Z_OBJ_HT_P(object)->read_property(object, &member, BP_VAR_IS, 0, &rv TSRMLS_CC);
+ if (data == &EG(uninitialized_zval)) {
/* Hack for bug #32455 */
zend_property_info *property_info;
property_info = zend_get_property_info(Z_OBJCE_P(object), &member, 1 TSRMLS_CC);
EG(scope) = old_scope;
- if (property_info && zend_hash_quick_exists(Z_OBJPROP_P(object), property_info->name, property_info->name_length+1, property_info->h)) {
+ if (property_info && zend_hash_exists(Z_OBJPROP_P(object), property_info->name)) {
return data;
}
return NULL;
EG(scope) = old_scope;
return data;
} else if (Z_TYPE_P(object) == IS_ARRAY) {
- zval **data_ptr;
+ zval *data_ptr;
- if (zend_hash_find(Z_ARRVAL_P(object), name, strlen(name)+1, (void**)&data_ptr) == SUCCESS) {
- return *data_ptr;
+ if ((data_ptr = zend_hash_str_find(Z_ARRVAL_P(object), name, strlen(name))) != NULL) {
+ return data_ptr;
}
}
- return NULL;
+ return NULL;
}
static void unset_zval_property(zval* object, char* name TSRMLS_DC)
zval member;
zend_class_entry *old_scope;
- INIT_PZVAL(&member);
- ZVAL_STRING(&member, name, 0);
+//??? INIT_PZVAL(&member);
+//??? ZVAL_STRING(&member, name, 0);
+ ZVAL_STRING(&member, name);
old_scope = EG(scope);
EG(scope) = Z_OBJCE_P(object);
Z_OBJ_HT_P(object)->unset_property(object, &member, 0 TSRMLS_CC);
EG(scope) = old_scope;
} else if (Z_TYPE_P(object) == IS_ARRAY) {
- zend_hash_del(Z_ARRVAL_P(object), name, strlen(name)+1);
+ zend_hash_str_del(Z_ARRVAL_P(object), name, strlen(name));
}
}
static void model_to_zval_any(zval *ret, xmlNodePtr node TSRMLS_DC)
{
+ zval rv, arr;
zval* any = NULL;
char* name = NULL;
while (node != NULL) {
- if (get_zval_property(ret, (char*)node->name TSRMLS_CC) == NULL) {
- zval* val = master_to_zval(get_conversion(XSD_ANYXML), node TSRMLS_CC);
+ if (get_zval_property(ret, (char*)node->name, &rv TSRMLS_CC) == NULL) {
+ zval* val = master_to_zval(ret, get_conversion(XSD_ANYXML), node TSRMLS_CC);
if (any && Z_TYPE_P(any) != IS_ARRAY) {
/* Convert into array */
- zval *arr;
-
- MAKE_STD_ZVAL(arr);
- array_init(arr);
+ array_init(&arr);
if (name) {
- add_assoc_zval(arr, name, any);
+ add_assoc_zval(&arr, name, any);
} else {
- add_next_index_zval(arr, any);
+ add_next_index_zval(&arr, any);
}
- any = arr;
+ any = &arr;
}
if (Z_TYPE_P(val) == IS_STRING && *Z_STRVAL_P(val) == '<') {
name = NULL;
while (node->next != NULL) {
- zval* val2 = master_to_zval(get_conversion(XSD_ANYXML), node->next TSRMLS_CC);
- if (Z_TYPE_P(val2) != IS_STRING || *Z_STRVAL_P(val) != '<') {
+ zval val2;
+
+ master_to_zval(&val2, get_conversion(XSD_ANYXML), node->next TSRMLS_CC);
+ if (Z_TYPE(val2) != IS_STRING || *Z_STRVAL_P(val) != '<') {
break;
}
- add_string_to_string(val, val, val2);
+ add_string_to_string(val, val, &val2);
zval_ptr_dtor(&val2);
node = node->next;
}
if (any == NULL) {
if (name) {
/* Convert into array */
- zval *arr;
-
- MAKE_STD_ZVAL(arr);
- array_init(arr);
- add_assoc_zval(arr, name, val);
- any = arr;
+ array_init(&arr);
+ add_assoc_zval(&arr, name, val);
+ any = &arr;
name = NULL;
} else {
any = val;
} else {
/* Add array element */
if (name) {
- zval **el;
- if (zend_hash_find(Z_ARRVAL_P(any), name, strlen(name)+1, (void**)&el) == SUCCESS) {
- if (Z_TYPE_PP(el) != IS_ARRAY) {
+ zval *el;
+ if ((el = zend_hash_str_find(Z_ARRVAL_P(any), name, strlen(name))) != NULL) {
+ if (Z_TYPE_P(el) != IS_ARRAY) {
/* Convert into array */
- zval *arr;
-
- MAKE_STD_ZVAL(arr);
- array_init(arr);
- add_next_index_zval(arr, *el);
- *el = arr;
+ array_init(&arr);
+ add_next_index_zval(&arr, el);
+ el = &arr;
}
- add_next_index_zval(*el, val);
+ add_next_index_zval(el, val);
} else {
add_assoc_zval(any, name, val);
}
xmlNodePtr node = get_node(data->children, model->u.element->name);
if (node) {
- zval *val;
+ zval val;
xmlNodePtr r_node;
r_node = check_and_resolve_href(node);
if (model->u.element->fixed && strcmp(model->u.element->fixed, (char*)r_node->children->content) != 0) {
soap_error3(E_ERROR, "Encoding: Element '%s' has fixed value '%s' (value '%s' is not allowed)", model->u.element->name, model->u.element->fixed, r_node->children->content);
}
- val = master_to_zval(model->u.element->encode, r_node TSRMLS_CC);
+ master_to_zval(&val, model->u.element->encode, r_node TSRMLS_CC);
} else if (model->u.element->fixed) {
xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlNodeSetContent(dummy, BAD_CAST(model->u.element->fixed));
- val = master_to_zval(model->u.element->encode, dummy TSRMLS_CC);
+ master_to_zval(&val, model->u.element->encode, dummy TSRMLS_CC);
xmlFreeNode(dummy);
} else if (model->u.element->def && !model->u.element->nillable) {
xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlNodeSetContent(dummy, BAD_CAST(model->u.element->def));
- val = master_to_zval(model->u.element->encode, dummy TSRMLS_CC);
+ master_to_zval(&val, model->u.element->encode, dummy TSRMLS_CC);
xmlFreeNode(dummy);
} else {
- val = master_to_zval(model->u.element->encode, r_node TSRMLS_CC);
+ master_to_zval(&val, model->u.element->encode, r_node TSRMLS_CC);
}
if ((node = get_node(node->next, model->u.element->name)) != NULL) {
- zval *array;
+ zval array;
- MAKE_STD_ZVAL(array);
- array_init(array);
- add_next_index_zval(array, val);
+ array_init(&array);
+ add_next_index_zval(&array, &val);
do {
if (node && node->children && node->children->content) {
if (model->u.element->fixed && strcmp(model->u.element->fixed, (char*)node->children->content) != 0) {
soap_error3(E_ERROR, "Encoding: Element '%s' has fixed value '%s' (value '%s' is not allowed)", model->u.element->name, model->u.element->fixed, node->children->content);
}
- val = master_to_zval(model->u.element->encode, node TSRMLS_CC);
+ master_to_zval(&val, model->u.element->encode, node TSRMLS_CC);
} else if (model->u.element->fixed) {
xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlNodeSetContent(dummy, BAD_CAST(model->u.element->fixed));
- val = master_to_zval(model->u.element->encode, dummy TSRMLS_CC);
+ master_to_zval(&val, model->u.element->encode, dummy TSRMLS_CC);
xmlFreeNode(dummy);
} else if (model->u.element->def && !model->u.element->nillable) {
xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlNodeSetContent(dummy, BAD_CAST(model->u.element->def));
- val = master_to_zval(model->u.element->encode, dummy TSRMLS_CC);
+ master_to_zval(&val, model->u.element->encode, dummy TSRMLS_CC);
xmlFreeNode(dummy);
} else {
- val = master_to_zval(model->u.element->encode, node TSRMLS_CC);
+ master_to_zval(&val, model->u.element->encode, node TSRMLS_CC);
}
- add_next_index_zval(array, val);
+ add_next_index_zval(&array, &val);
} while ((node = get_node(node->next, model->u.element->name)) != NULL);
- val = array;
- } else if ((Z_TYPE_P(val) != IS_NULL || !model->u.element->nillable) &&
+ ZVAL_COPY_VALUE(&val, &array);
+ } else if ((Z_TYPE(val) != IS_NULL || !model->u.element->nillable) &&
(SOAP_GLOBAL(features) & SOAP_SINGLE_ELEMENT_ARRAYS) &&
(model->max_occurs == -1 || model->max_occurs > 1)) {
- zval *array;
+ zval array;
- MAKE_STD_ZVAL(array);
- array_init(array);
- add_next_index_zval(array, val);
- val = array;
+ array_init(&array);
+ add_next_index_zval(&array, &val);
+ ZVAL_COPY_VALUE(&val, &array);
}
- set_zval_property(ret, model->u.element->name, val TSRMLS_CC);
+ set_zval_property(ret, model->u.element->name, &val TSRMLS_CC);
}
}
break;
case XSD_CONTENT_ALL:
case XSD_CONTENT_SEQUENCE:
case XSD_CONTENT_CHOICE: {
- sdlContentModelPtr *tmp;
- HashPosition pos;
+ sdlContentModelPtr tmp;
sdlContentModelPtr any = NULL;
- zend_hash_internal_pointer_reset_ex(model->u.content, &pos);
- while (zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos) == SUCCESS) {
- if ((*tmp)->kind == XSD_CONTENT_ANY) {
- any = *tmp;
+ ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
+ if (tmp->kind == XSD_CONTENT_ANY) {
+ any = tmp;
} else {
- model_to_zval_object(ret, *tmp, data, sdl TSRMLS_CC);
+ model_to_zval_object(ret, tmp, data, sdl TSRMLS_CC);
}
- zend_hash_move_forward_ex(model->u.content, &pos);
- }
+ } ZEND_HASH_FOREACH_END();
if (any) {
model_to_zval_any(ret, data->children TSRMLS_CC);
}
}
/* Struct encode/decode */
-static zval *to_zval_object_ex(encodeTypePtr type, xmlNodePtr data, zend_class_entry *pce TSRMLS_DC)
+static zval *to_zval_object_ex(zval *ret, encodeTypePtr type, xmlNodePtr data, zend_class_entry *pce TSRMLS_DC)
{
- zval *ret;
xmlNodePtr trav;
sdlPtr sdl;
sdlTypePtr sdlType = type->sdl_type;
zend_class_entry *ce = ZEND_STANDARD_CLASS_DEF_PTR;
- zval *redo_any = NULL;
+ zval *redo_any = NULL, rv, arr;
if (pce) {
ce = pce;
} else if (SOAP_GLOBAL(class_map) && type->type_str) {
- zval **classname;
+ zval *classname;
zend_class_entry *tmp;
- if (zend_hash_find(SOAP_GLOBAL(class_map), type->type_str, strlen(type->type_str)+1, (void**)&classname) == SUCCESS &&
- Z_TYPE_PP(classname) == IS_STRING &&
- (tmp = zend_fetch_class(Z_STRVAL_PP(classname), Z_STRLEN_PP(classname), ZEND_FETCH_CLASS_AUTO TSRMLS_CC)) != NULL) {
+ if ((classname = zend_hash_str_find(SOAP_GLOBAL(class_map), type->type_str, strlen(type->type_str))) != NULL &&
+ Z_TYPE_P(classname) == IS_STRING &&
+ (tmp = zend_fetch_class(Z_STR_P(classname), ZEND_FETCH_CLASS_AUTO TSRMLS_CC)) != NULL) {
ce = tmp;
}
}
enc = enc->details.sdl_type->encode;
}
if (enc) {
- zval *base;
+ zval base;
- ALLOC_INIT_ZVAL(ret);
- if (soap_check_xml_ref(&ret, data TSRMLS_CC)) {
+ ZVAL_NULL(ret);
+ if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
return ret;
}
object_init_ex(ret, ce);
- base = master_to_zval_int(enc, data TSRMLS_CC);
- set_zval_property(ret, "_", base TSRMLS_CC);
+ master_to_zval_int(&base, enc, data TSRMLS_CC);
+ set_zval_property(ret, "_", &base TSRMLS_CC);
} else {
- ALLOC_INIT_ZVAL(ret);
+ ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
- if (soap_check_xml_ref(&ret, data TSRMLS_CC)) {
+ if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
return ret;
}
object_init_ex(ret, ce);
(sdlType->encode->details.sdl_type->encode == NULL ||
(sdlType->encode->details.sdl_type->encode->details.type != IS_ARRAY &&
sdlType->encode->details.sdl_type->encode->details.type != SOAP_ENC_ARRAY))) {
- ret = to_zval_object_ex(&sdlType->encode->details, data, ce TSRMLS_CC);
+ to_zval_object_ex(ret, &sdlType->encode->details, data, ce TSRMLS_CC);
} else {
- ret = master_to_zval_int(sdlType->encode, data TSRMLS_CC);
+ master_to_zval_int(ret, sdlType->encode, data TSRMLS_CC);
}
- if (soap_check_xml_ref(&ret, data TSRMLS_CC)) {
+ if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
return ret;
}
- redo_any = get_zval_property(ret, "any" TSRMLS_CC);
+ redo_any = get_zval_property(ret, "any", &rv TSRMLS_CC);
if (Z_TYPE_P(ret) == IS_OBJECT && ce != ZEND_STANDARD_CLASS_DEF_PTR) {
- zend_object *zobj = zend_objects_get_address(ret TSRMLS_CC);
+ zend_object *zobj = Z_OBJ_P(ret);
zobj->ce = ce;
}
} else {
- zval *base;
+ zval base;
- ALLOC_INIT_ZVAL(ret);
- if (soap_check_xml_ref(&ret, data TSRMLS_CC)) {
+ ZVAL_NULL(ret);
+ if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
return ret;
}
object_init_ex(ret, ce);
- base = master_to_zval_int(sdlType->encode, data TSRMLS_CC);
- set_zval_property(ret, "_", base TSRMLS_CC);
+ master_to_zval_int(&base, sdlType->encode, data TSRMLS_CC);
+ set_zval_property(ret, "_", &base TSRMLS_CC);
}
} else {
- ALLOC_INIT_ZVAL(ret);
+ ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
- if (soap_check_xml_ref(&ret, data TSRMLS_CC)) {
+ if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
return ret;
}
object_init_ex(ret, ce);
}
model_to_zval_object(ret, sdlType->model, data, sdl TSRMLS_CC);
if (redo_any) {
- zval *tmp = get_zval_property(ret, "any" TSRMLS_CC);
+ zval *tmp = get_zval_property(ret, "any", &rv TSRMLS_CC);
if (tmp == NULL) {
model_to_zval_any(ret, data->children TSRMLS_CC);
zval_dtor(tmp);
efree(tmp);
}
- zval_ptr_dtor(&redo_any);
+ zval_ptr_dtor(redo_any);
}
}
if (sdlType->attributes) {
- sdlAttributePtr *attr;
- HashPosition pos;
+ sdlAttributePtr attr;
- zend_hash_internal_pointer_reset_ex(sdlType->attributes, &pos);
- while (zend_hash_get_current_data_ex(sdlType->attributes, (void**)&attr, &pos) == SUCCESS) {
- if ((*attr)->name) {
- xmlAttrPtr val = get_attribute(data->properties, (*attr)->name);
+ ZEND_HASH_FOREACH_PTR(sdlType->attributes, attr) {
+ if (attr->name) {
+ xmlAttrPtr val = get_attribute(data->properties, attr->name);
char *str_val = NULL;
if (val && val->children && val->children->content) {
str_val = (char*)val->children->content;
- if ((*attr)->fixed && strcmp((*attr)->fixed, str_val) != 0) {
- soap_error3(E_ERROR, "Encoding: Attribute '%s' has fixed value '%s' (value '%s' is not allowed)", (*attr)->name, (*attr)->fixed, str_val);
+ if (attr->fixed && strcmp(attr->fixed, str_val) != 0) {
+ soap_error3(E_ERROR, "Encoding: Attribute '%s' has fixed value '%s' (value '%s' is not allowed)", attr->name, attr->fixed, str_val);
}
- } else if ((*attr)->fixed) {
- str_val = (*attr)->fixed;
- } else if ((*attr)->def) {
- str_val = (*attr)->def;
+ } else if (attr->fixed) {
+ str_val = attr->fixed;
+ } else if (attr->def) {
+ str_val = attr->def;
}
if (str_val) {
xmlNodePtr dummy, text;
- zval *data;
+ zval data;
dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
text = xmlNewText(BAD_CAST(str_val));
xmlAddChild(dummy, text);
- data = master_to_zval((*attr)->encode, dummy TSRMLS_CC);
+ master_to_zval(&data, attr->encode, dummy TSRMLS_CC);
xmlFreeNode(dummy);
- set_zval_property(ret, (*attr)->name, data TSRMLS_CC);
+ set_zval_property(ret, attr->name, &data TSRMLS_CC);
}
}
- zend_hash_move_forward_ex(sdlType->attributes, &pos);
- }
+ } ZEND_HASH_FOREACH_END();
}
} else {
-
- ALLOC_INIT_ZVAL(ret);
+ ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
- if (soap_check_xml_ref(&ret, data TSRMLS_CC)) {
+ if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
return ret;
}
while (trav != NULL) {
if (trav->type == XML_ELEMENT_NODE) {
- zval *tmpVal;
+ zval tmpVal, rv;
zval *prop;
- tmpVal = master_to_zval(NULL, trav TSRMLS_CC);
+ master_to_zval(&tmpVal, NULL, trav TSRMLS_CC);
- prop = get_zval_property(ret, (char*)trav->name TSRMLS_CC);
+ prop = get_zval_property(ret, (char*)trav->name, &rv TSRMLS_CC);
if (!prop) {
if (!trav->next || !get_node(trav->next, (char*)trav->name)) {
- set_zval_property(ret, (char*)trav->name, tmpVal TSRMLS_CC);
+ set_zval_property(ret, (char*)trav->name, &tmpVal TSRMLS_CC);
} else {
- zval *arr;
+ zval arr;
- MAKE_STD_ZVAL(arr);
- array_init(arr);
- add_next_index_zval(arr, tmpVal);
- set_zval_property(ret, (char*)trav->name, arr TSRMLS_CC);
+ array_init(&arr);
+ add_next_index_zval(&arr, &tmpVal);
+ set_zval_property(ret, (char*)trav->name, &arr TSRMLS_CC);
}
} else {
/* Property already exist - make array */
if (Z_TYPE_P(prop) != IS_ARRAY) {
/* Convert into array */
- zval *arr;
-
- MAKE_STD_ZVAL(arr);
- array_init(arr);
+ array_init(&arr);
Z_ADDREF_P(prop);
- add_next_index_zval(arr, prop);
- set_zval_property(ret, (char*)trav->name, arr TSRMLS_CC);
- prop = arr;
+ add_next_index_zval(&arr, prop);
+ set_zval_property(ret, (char*)trav->name, &arr TSRMLS_CC);
+ prop = &arr;
}
/* Add array element */
- add_next_index_zval(prop, tmpVal);
+ add_next_index_zval(prop, &tmpVal);
}
}
trav = trav->next;
return ret;
}
-static zval *to_zval_object(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_object(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
{
- return to_zval_object_ex(type, data, NULL TSRMLS_CC);
+ return to_zval_object_ex(ret, type, data, NULL TSRMLS_CC);
}
zval *data;
xmlNodePtr property;
encodePtr enc;
+ zval rv;
- data = get_zval_property(object, model->u.element->name TSRMLS_CC);
+ data = get_zval_property(object, model->u.element->name, &rv TSRMLS_CC);
if (data &&
Z_TYPE_P(data) == IS_NULL &&
!model->u.element->nillable &&
Z_TYPE_P(data) == IS_ARRAY &&
!is_map(data)) {
HashTable *ht = Z_ARRVAL_P(data);
- zval **val;
+ zval *val;
- zend_hash_internal_pointer_reset(ht);
- while (zend_hash_get_current_data(ht,(void**)&val) == SUCCESS) {
- if (Z_TYPE_PP(val) == IS_NULL && model->u.element->nillable) {
+ ZEND_HASH_FOREACH_VAL(ht, val) {
+ if (Z_TYPE_P(val) == IS_NULL && model->u.element->nillable) {
property = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(node, property);
set_xsi_nil(property);
} else {
- property = master_to_xml(enc, *val, style, node TSRMLS_CC);
+ property = master_to_xml(enc, val, style, node TSRMLS_CC);
if (property->children && property->children->content &&
model->u.element->fixed && strcmp(model->u.element->fixed, (char*)property->children->content) != 0) {
soap_error3(E_ERROR, "Encoding: Element '%s' has fixed value '%s' (value '%s' is not allowed)", model->u.element->name, model->u.element->fixed, property->children->content);
xmlNsPtr nsp = encode_add_ns(property, model->u.element->namens);
xmlSetNs(property, nsp);
}
- zend_hash_move_forward(ht);
- }
+ } ZEND_HASH_FOREACH_END();
} else {
if (Z_TYPE_P(data) == IS_NULL && model->u.element->nillable) {
property = xmlNewNode(NULL, BAD_CAST("BOGUS"));
zval *data;
xmlNodePtr property;
encodePtr enc;
+ zval rv;
- data = get_zval_property(object, "any" TSRMLS_CC);
+ data = get_zval_property(object, "any", &rv TSRMLS_CC);
if (data) {
enc = get_conversion(XSD_ANYXML);
if ((model->max_occurs == -1 || model->max_occurs > 1) &&
Z_TYPE_P(data) == IS_ARRAY &&
!is_map(data)) {
HashTable *ht = Z_ARRVAL_P(data);
- zval **val;
+ zval *val;
- zend_hash_internal_pointer_reset(ht);
- while (zend_hash_get_current_data(ht,(void**)&val) == SUCCESS) {
- property = master_to_xml(enc, *val, style, node TSRMLS_CC);
- zend_hash_move_forward(ht);
- }
+ ZEND_HASH_FOREACH_VAL(ht, val) {
+ property = master_to_xml(enc, val, style, node TSRMLS_CC);
+ } ZEND_HASH_FOREACH_END();
} else {
property = master_to_xml(enc, data, style, node TSRMLS_CC);
}
}
case XSD_CONTENT_SEQUENCE:
case XSD_CONTENT_ALL: {
- sdlContentModelPtr *tmp;
- HashPosition pos;
+ sdlContentModelPtr tmp;
- zend_hash_internal_pointer_reset_ex(model->u.content, &pos);
- while (zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos) == SUCCESS) {
- if (!model_to_xml_object(node, *tmp, object, style, strict && ((*tmp)->min_occurs > 0) TSRMLS_CC)) {
- if (!strict || (*tmp)->min_occurs > 0) {
+ ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
+ if (!model_to_xml_object(node, tmp, object, style, strict && (tmp->min_occurs > 0) TSRMLS_CC)) {
+ if (!strict || tmp->min_occurs > 0) {
return 0;
}
}
strict = 1;
- zend_hash_move_forward_ex(model->u.content, &pos);
- }
+ } ZEND_HASH_FOREACH_END();
return 1;
}
case XSD_CONTENT_CHOICE: {
- sdlContentModelPtr *tmp;
- HashPosition pos;
+ sdlContentModelPtr tmp;
int ret = 0;
- zend_hash_internal_pointer_reset_ex(model->u.content, &pos);
- while (zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos) == SUCCESS) {
- int tmp_ret = model_to_xml_object(node, *tmp, object, style, 0 TSRMLS_CC);
+ ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
+ int tmp_ret = model_to_xml_object(node, tmp, object, style, 0 TSRMLS_CC);
if (tmp_ret == 1) {
return 1;
} else if (tmp_ret != 0) {
ret = 1;
}
- zend_hash_move_forward_ex(model->u.content, &pos);
- }
+ } ZEND_HASH_FOREACH_END();
return ret;
}
case XSD_CONTENT_GROUP: {
case XSD_CONTENT_SEQUENCE:
case XSD_CONTENT_ALL:
case XSD_CONTENT_CHOICE: {
- sdlContentModelPtr *tmp;
- HashPosition pos;
+ sdlContentModelPtr tmp;
if (zend_hash_num_elements(model->u.content) != 1) {
return NULL;
}
- zend_hash_internal_pointer_reset_ex(model->u.content, &pos);
- zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos);
- return model_array_element(*tmp);
+ ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
+ return model_array_element(tmp);
+ } ZEND_HASH_FOREACH_END();
}
case XSD_CONTENT_GROUP: {
return model_array_element(model->u.group->model);
enc = enc->details.sdl_type->encode;
}
if (enc) {
- zval *tmp = get_zval_property(data, "_" TSRMLS_CC);
+ zval rv;
+ zval *tmp = get_zval_property(data, "_", &rv TSRMLS_CC);
if (tmp) {
xmlParam = master_to_xml(enc, tmp, style, parent TSRMLS_CC);
} else if (prop == NULL) {
sdlType->encode->details.sdl_type->kind != XSD_TYPEKIND_LIST &&
sdlType->encode->details.sdl_type->kind != XSD_TYPEKIND_UNION) {
- if (prop) prop->nApplyCount++;
+ if (prop) ZEND_HASH_INC_APPLY_COUNT(prop);
xmlParam = master_to_xml(sdlType->encode, data, style, parent TSRMLS_CC);
- if (prop) prop->nApplyCount--;
+ if (prop) ZEND_HASH_DEC_APPLY_COUNT(prop);
} else {
- zval *tmp = get_zval_property(data, "_" TSRMLS_CC);
+ zval rv;
+ zval *tmp = get_zval_property(data, "_", &rv TSRMLS_CC);
if (tmp) {
xmlParam = master_to_xml(sdlType->encode, tmp, style, parent TSRMLS_CC);
sdlType->attributes == NULL &&
sdlType->model != NULL &&
(array_el = model_array_element(sdlType->model)) != NULL) {
- zval **val;
+ zval *val;
- zend_hash_internal_pointer_reset(prop);
- while (zend_hash_get_current_data(prop,(void**)&val) == SUCCESS) {
+ ZEND_HASH_FOREACH_VAL(prop, val) {
xmlNodePtr property;
- if (Z_TYPE_PP(val) == IS_NULL && array_el->nillable) {
+ if (Z_TYPE_P(val) == IS_NULL && array_el->nillable) {
property = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(xmlParam, property);
set_xsi_nil(property);
} else {
- property = master_to_xml(array_el->encode, *val, style, xmlParam TSRMLS_CC);
+ property = master_to_xml(array_el->encode, val, style, xmlParam TSRMLS_CC);
}
xmlNodeSetName(property, BAD_CAST(array_el->name));
if (style == SOAP_LITERAL &&
xmlNsPtr nsp = encode_add_ns(property, array_el->namens);
xmlSetNs(property, nsp);
}
- zend_hash_move_forward(prop);
- }
+ } ZEND_HASH_FOREACH_END();
} else if (sdlType->model) {
model_to_xml_object(xmlParam, sdlType->model, data, style, 1 TSRMLS_CC);
}
if (sdlType->attributes) {
- sdlAttributePtr *attr;
- zval *zattr;
- HashPosition pos;
-
- zend_hash_internal_pointer_reset_ex(sdlType->attributes, &pos);
- while (zend_hash_get_current_data_ex(sdlType->attributes, (void**)&attr, &pos) == SUCCESS) {
- if ((*attr)->name) {
- zattr = get_zval_property(data, (*attr)->name TSRMLS_CC);
+ sdlAttributePtr attr;
+ zval *zattr, rv;
+
+ ZEND_HASH_FOREACH_PTR(sdlType->attributes, attr) {
+ if (attr->name) {
+ zattr = get_zval_property(data, attr->name, &rv TSRMLS_CC);
if (zattr) {
xmlNodePtr dummy;
- dummy = master_to_xml((*attr)->encode, zattr, SOAP_LITERAL, xmlParam TSRMLS_CC);
+ dummy = master_to_xml(attr->encode, zattr, SOAP_LITERAL, xmlParam TSRMLS_CC);
if (dummy->children && dummy->children->content) {
- if ((*attr)->fixed && strcmp((*attr)->fixed, (char*)dummy->children->content) != 0) {
- soap_error3(E_ERROR, "Encoding: Attribute '%s' has fixed value '%s' (value '%s' is not allowed)", (*attr)->name, (*attr)->fixed, dummy->children->content);
+ if (attr->fixed && strcmp(attr->fixed, (char*)dummy->children->content) != 0) {
+ soap_error3(E_ERROR, "Encoding: Attribute '%s' has fixed value '%s' (value '%s' is not allowed)", attr->name, attr->fixed, dummy->children->content);
}
/* we need to handle xml: namespace specially, since it is
an implicit schema. Otherwise, use form.
*/
- if ((*attr)->namens &&
- (!strncmp((*attr)->namens, XML_NAMESPACE, sizeof(XML_NAMESPACE)) ||
- (*attr)->form == XSD_FORM_QUALIFIED)) {
- xmlNsPtr nsp = encode_add_ns(xmlParam, (*attr)->namens);
+ if (attr->namens &&
+ (!strncmp(attr->namens, XML_NAMESPACE, sizeof(XML_NAMESPACE)) ||
+ attr->form == XSD_FORM_QUALIFIED)) {
+ xmlNsPtr nsp = encode_add_ns(xmlParam, attr->namens);
- xmlSetNsProp(xmlParam, nsp, BAD_CAST((*attr)->name), dummy->children->content);
+ xmlSetNsProp(xmlParam, nsp, BAD_CAST(attr->name), dummy->children->content);
} else {
- xmlSetProp(xmlParam, BAD_CAST((*attr)->name), dummy->children->content);
+ xmlSetProp(xmlParam, BAD_CAST(attr->name), dummy->children->content);
}
}
xmlUnlinkNode(dummy);
xmlFreeNode(dummy);
}
}
- zend_hash_move_forward_ex(sdlType->attributes, &pos);
- }
+ } ZEND_HASH_FOREACH_END();
}
}
if (style == SOAP_ENCODED) {
for (;i > 0;i--) {
xmlNodePtr property;
- zval **zprop;
- char *str_key;
+ zval *zprop;
+ zend_string *str_key;
ulong index;
int key_type;
- unsigned int str_key_len;
- key_type = zend_hash_get_current_key_ex(prop, &str_key, &str_key_len, &index, FALSE, NULL);
- zend_hash_get_current_data(prop, (void **)&zprop);
+ key_type = zend_hash_get_current_key_ex(prop, &str_key, &index, FALSE, &prop->nInternalPointer);
+ zprop = zend_hash_get_current_data(prop);
- property = master_to_xml(get_conversion((*zprop)->type), (*zprop), style, xmlParam TSRMLS_CC);
+ property = master_to_xml(get_conversion(Z_TYPE_P(zprop)), zprop, style, xmlParam TSRMLS_CC);
if (key_type == HASH_KEY_IS_STRING) {
const char *prop_name;
if (Z_TYPE_P(data) == IS_OBJECT) {
const char *class_name;
- zend_unmangle_property_name(str_key, str_key_len-1, &class_name, &prop_name);
+ zend_unmangle_property_name(str_key->val, str_key->len, &class_name, &prop_name);
} else {
- prop_name = str_key;
+ prop_name = str_key->val;
}
if (prop_name) {
xmlNodeSetName(property, BAD_CAST(prop_name));
int j;
if (data && Z_TYPE_P(data) == IS_ARRAY) {
- zend_hash_internal_pointer_reset(data->value.ht);
+ zend_hash_internal_pointer_reset(Z_ARRVAL_P(data));
for (j=0; j<dims[0]; j++) {
- zval **zdata;
+ zval *zdata;
- if (zend_hash_get_current_data(data->value.ht, (void **)&zdata) != SUCCESS) {
+ if ((zdata = zend_hash_get_current_data(Z_ARRVAL_P(data))) == NULL) {
zdata = NULL;
}
if (dimension == 1) {
if (zdata) {
if (enc == NULL) {
- xparam = master_to_xml(get_conversion((*zdata)->type), (*zdata), style, xmlParam TSRMLS_CC);
+ xparam = master_to_xml(get_conversion(Z_TYPE_P(zdata)), zdata, style, xmlParam TSRMLS_CC);
} else {
- xparam = master_to_xml(enc, (*zdata), style, xmlParam TSRMLS_CC);
+ xparam = master_to_xml(enc, zdata, style, xmlParam TSRMLS_CC);
}
} else {
xparam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
}
} else {
if (zdata) {
- add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, *zdata, style TSRMLS_CC);
+ add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, zdata, style TSRMLS_CC);
} else {
add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, NULL, style TSRMLS_CC);
}
}
- zend_hash_move_forward(data->value.ht);
+ zend_hash_move_forward(Z_ARRVAL_P(data));
}
} else {
for (j=0; j<dims[0]; j++) {
static inline int array_num_elements(HashTable* ht)
{
if (ht->nNumUsed &&
- ht->arData[ht->nNumUsed-1].xData &&
- ht->arData[ht->nNumUsed-1].nKeyLength == 0) {
+ Z_TYPE(ht->arData[ht->nNumUsed-1].val) != IS_UNUSED &&
+ ht->arData[ht->nNumUsed-1].key == NULL) {
return ht->arData[ht->nNumUsed-1].h - 1;
}
int dimension = 1;
int* dims;
int soap_version;
- zval *array_copy = NULL;
+ zval array_copy;
+ ZVAL_UNDEF(&array_copy);
soap_version = SOAP_GLOBAL(soap_version);
xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
if (Z_TYPE_P(data) == IS_OBJECT && instanceof_function(Z_OBJCE_P(data), zend_ce_traversable TSRMLS_CC)) {
zend_object_iterator *iter;
zend_class_entry *ce = Z_OBJCE_P(data);
- zval **val;
+ zval *val;
- ALLOC_ZVAL(array_copy);
- INIT_PZVAL(array_copy);
- array_init(array_copy);
+ array_init(&array_copy);
iter = ce->get_iterator(ce, data, 0 TSRMLS_CC);
goto iterator_done;
}
- iter->funcs->get_current_data(iter, &val TSRMLS_CC);
+ val = iter->funcs->get_current_data(iter TSRMLS_CC);
if (EG(exception)) {
goto iterator_done;
}
if (EG(exception)) {
goto iterator_done;
}
- array_set_zval_key(Z_ARRVAL_P(array_copy), &key, *val);
+ array_set_zval_key(Z_ARRVAL(array_copy), &key, val);
zval_ptr_dtor(val);
zval_dtor(&key);
} else {
- add_next_index_zval(array_copy, *val);
+ add_next_index_zval(&array_copy, val);
}
- Z_ADDREF_PP(val);
+ Z_ADDREF_P(val);
iter->funcs->move_forward(iter TSRMLS_CC);
if (EG(exception)) {
iter->funcs->dtor(iter TSRMLS_CC);
if (EG(exception)) {
zval_ptr_dtor(&array_copy);
- array_copy = NULL;
+ ZVAL_UNDEF(&array_copy);
} else {
- data = array_copy;
+ data = &array_copy;
}
}
if (Z_TYPE_P(data) == IS_ARRAY) {
- sdlAttributePtr *arrayType;
- sdlExtraAttributePtr *ext;
+ sdlAttributePtr arrayType;
+ sdlExtraAttributePtr ext;
sdlTypePtr elementType;
i = zend_hash_num_elements(Z_ARRVAL_P(data));
if (sdl_type &&
sdl_type->attributes &&
- zend_hash_find(sdl_type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType",
- sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType"),
- (void **)&arrayType) == SUCCESS &&
- (*arrayType)->extraAttributes &&
- zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType"), (void **)&ext) == SUCCESS) {
+ (arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType",
+ sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType")-1)) != NULL &&
+ arrayType->extraAttributes &&
+ (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType")-1)) != NULL) {
char *value, *end;
- zval** el;
+ zval *el;
- value = estrdup((*ext)->val);
+ value = estrdup(ext->val);
end = strrchr(value,'[');
if (end) {
*end = '\0';
end++;
dimension = calc_dimension(end);
}
- if ((*ext)->ns != NULL) {
- enc = get_encoder(SOAP_GLOBAL(sdl), (*ext)->ns, value);
- get_type_str(xmlParam, (*ext)->ns, value, &array_type);
+ if (ext->ns != NULL) {
+ enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, value);
+ get_type_str(xmlParam, ext->ns, value, &array_type);
} else {
smart_str_appends(&array_type, value);
}
dims = safe_emalloc(sizeof(int), dimension, 0);
dims[0] = i;
- el = &data;
+ //??? el = &data;
+ el = data;
for (i = 1; i < dimension; i++) {
- if (el != NULL && Z_TYPE_PP(el) == IS_ARRAY &&
- zend_hash_num_elements(Z_ARRVAL_PP(el)) > 0) {
- zend_hash_internal_pointer_reset(Z_ARRVAL_PP(el));
- zend_hash_get_current_data(Z_ARRVAL_PP(el), (void**)&el);
- if (Z_TYPE_PP(el) == IS_ARRAY) {
- dims[i] = zend_hash_num_elements(Z_ARRVAL_PP(el));
+ if (el != NULL && Z_TYPE_P(el) == IS_ARRAY &&
+ zend_hash_num_elements(Z_ARRVAL_P(el)) > 0) {
+ zend_hash_internal_pointer_reset(Z_ARRVAL_P(el));
+ el = zend_hash_get_current_data(Z_ARRVAL_P(el));
+ if (Z_TYPE_P(el) == IS_ARRAY) {
+ dims[i] = zend_hash_num_elements(Z_ARRVAL_P(el));
} else {
dims[i] = 0;
}
} else if (sdl_type &&
sdl_type->attributes &&
- zend_hash_find(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType",
- sizeof(SOAP_1_2_ENC_NAMESPACE":itemType"),
- (void **)&arrayType) == SUCCESS &&
- (*arrayType)->extraAttributes &&
- zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":itemType"), (void **)&ext) == SUCCESS) {
- if ((*ext)->ns != NULL) {
- enc = get_encoder(SOAP_GLOBAL(sdl), (*ext)->ns, (*ext)->val);
- get_type_str(xmlParam, (*ext)->ns, (*ext)->val, &array_type);
+ (arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType",
+ sizeof(SOAP_1_2_ENC_NAMESPACE":itemType")-1)) != NULL &&
+ arrayType->extraAttributes &&
+ (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":itemType")-1)) != NULL) {
+ if (ext->ns != NULL) {
+ enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, ext->val);
+ get_type_str(xmlParam, ext->ns, ext->val, &array_type);
} else {
- smart_str_appends(&array_type, (*ext)->val);
- }
- if (zend_hash_find(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
- sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize"),
- (void **)&arrayType) == SUCCESS &&
- (*arrayType)->extraAttributes &&
- zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize"), (void **)&ext) == SUCCESS) {
- dimension = calc_dimension_12((*ext)->val);
- dims = get_position_12(dimension, (*ext)->val);
+ smart_str_appends(&array_type, ext->val);
+ }
+ if ((arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
+ sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL &&
+ arrayType->extraAttributes &&
+ (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize")-1)) != NULL) {
+ dimension = calc_dimension_12(ext->val);
+ dims = get_position_12(dimension, ext->val);
if (dims[0] == 0) {dims[0] = i;}
smart_str_append_long(&array_size, dims[0]);
}
} else if (sdl_type &&
sdl_type->attributes &&
- zend_hash_find(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
- sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize"),
- (void **)&arrayType) == SUCCESS &&
- (*arrayType)->extraAttributes &&
- zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraySize"), (void **)&ext) == SUCCESS) {
- dimension = calc_dimension_12((*ext)->val);
- dims = get_position_12(dimension, (*ext)->val);
+ (arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
+ sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL &&
+ arrayType->extraAttributes &&
+ (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraySize")-1)) != NULL) {
+ dimension = calc_dimension_12(ext->val);
+ dims = get_position_12(dimension, ext->val);
if (dims[0] == 0) {dims[0] = i;}
smart_str_append_long(&array_size, dims[0]);
if (sdl_type && sdl_type->elements &&
zend_hash_num_elements(sdl_type->elements) == 1 &&
(zend_hash_internal_pointer_reset(sdl_type->elements),
- zend_hash_get_current_data(sdl_type->elements, (void**)&elementType) == SUCCESS) &&
- (elementType = *(sdlTypePtr*)elementType) != NULL &&
+ (elementType = zend_hash_get_current_data_ptr(sdl_type->elements)) != NULL) &&
elementType->encode && elementType->encode->details.type_str) {
element_type = elementType;
enc = elementType->encode;
} else if (sdl_type && sdl_type->elements &&
zend_hash_num_elements(sdl_type->elements) == 1 &&
(zend_hash_internal_pointer_reset(sdl_type->elements),
- zend_hash_get_current_data(sdl_type->elements, (void**)&elementType) == SUCCESS) &&
- (elementType = *(sdlTypePtr*)elementType) != NULL &&
+ (elementType = zend_hash_get_current_data_ptr(sdl_type->elements)) != NULL) &&
elementType->encode && elementType->encode->details.type_str) {
element_type = elementType;
if (style == SOAP_ENCODED) {
if (soap_version == SOAP_1_1) {
smart_str_0(&array_type);
- if (strcmp(array_type.c,"xsd:anyType") == 0) {
+ if (strcmp(array_type.s->val,"xsd:anyType") == 0) {
smart_str_free(&array_type);
smart_str_appendl(&array_type,"xsd:ur-type",sizeof("xsd:ur-type")-1);
}
smart_str_append(&array_type, &array_size);
smart_str_appendc(&array_type, ']');
smart_str_0(&array_type);
- set_ns_prop(xmlParam, SOAP_1_1_ENC_NAMESPACE, "arrayType", array_type.c);
+ set_ns_prop(xmlParam, SOAP_1_1_ENC_NAMESPACE, "arrayType", array_type.s->val);
} else {
int i = 0;
- while (i < array_size.len) {
- if (array_size.c[i] == ',') {array_size.c[i] = ' ';}
+ while (i < array_size.s->len) {
+ if (array_size.s->val[i] == ',') {array_size.s->val[i] = ' ';}
++i;
}
smart_str_0(&array_type);
smart_str_0(&array_size);
- set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "itemType", array_type.c);
- set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "arraySize", array_size.c);
+ set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "itemType", array_type.s->val);
+ set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "arraySize", array_size.s->val);
}
}
smart_str_free(&array_type);
}
}
- if (array_copy) {
- zval_ptr_dtor(&array_copy);
- }
+ zval_ptr_dtor(&array_copy);
return xmlParam;
}
-static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_array(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
{
- zval *ret;
xmlNodePtr trav;
encodePtr enc = NULL;
int dimension = 1;
int* pos = NULL;
xmlAttrPtr attr;
sdlPtr sdl;
- sdlAttributePtr *arrayType;
- sdlExtraAttributePtr *ext;
+ sdlAttributePtr arrayType;
+ sdlExtraAttributePtr ext;
sdlTypePtr elementType;
- MAKE_STD_ZVAL(ret);
+ ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
sdl = SOAP_GLOBAL(sdl);
} else if (type->sdl_type != NULL &&
type->sdl_type->attributes != NULL &&
- zend_hash_find(type->sdl_type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType",
- sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType"),
- (void **)&arrayType) == SUCCESS &&
- (*arrayType)->extraAttributes &&
- zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType"), (void **)&ext) == SUCCESS) {
+ (arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType",
+ sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType")-1)) != NULL &&
+ arrayType->extraAttributes &&
+ (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType")-1)) != NULL) {
char *type, *end;
- type = estrdup((*ext)->val);
+ type = estrdup(ext->val);
end = strrchr(type,'[');
if (end) {
*end = '\0';
}
- if ((*ext)->ns != NULL) {
- enc = get_encoder(SOAP_GLOBAL(sdl), (*ext)->ns, type);
+ if (ext->ns != NULL) {
+ enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, type);
}
efree(type);
} else if (type->sdl_type != NULL &&
type->sdl_type->attributes != NULL &&
- zend_hash_find(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType",
- sizeof(SOAP_1_2_ENC_NAMESPACE":itemType"),
- (void **)&arrayType) == SUCCESS &&
- (*arrayType)->extraAttributes &&
- zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":itemType"), (void **)&ext) == SUCCESS) {
-
- if ((*ext)->ns != NULL) {
- enc = get_encoder(SOAP_GLOBAL(sdl), (*ext)->ns, (*ext)->val);
- }
-
- if (zend_hash_find(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
- sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize"),
- (void **)&arrayType) == SUCCESS &&
- (*arrayType)->extraAttributes &&
- zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize"), (void **)&ext) == SUCCESS) {
- dimension = calc_dimension_12((*ext)->val);
- dims = get_position_12(dimension, (*ext)->val);
+ (arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType",
+ sizeof(SOAP_1_2_ENC_NAMESPACE":itemType")-1)) != NULL &&
+ arrayType->extraAttributes &&
+ (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":itemType")-1)) != NULL) {
+
+ if (ext->ns != NULL) {
+ enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, ext->val);
+ }
+
+ if ((arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
+ sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL &&
+ arrayType->extraAttributes &&
+ (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize")-1)) != NULL) {
+ dimension = calc_dimension_12(ext->val);
+ dims = get_position_12(dimension, ext->val);
} else {
dims = emalloc(sizeof(int));
*dims = 0;
}
} else if (type->sdl_type != NULL &&
type->sdl_type->attributes != NULL &&
- zend_hash_find(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
- sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize"),
- (void **)&arrayType) == SUCCESS &&
- (*arrayType)->extraAttributes &&
- zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize"), (void **)&ext) == SUCCESS) {
-
- dimension = calc_dimension_12((*ext)->val);
- dims = get_position_12(dimension, (*ext)->val);
+ (arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
+ sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL &&
+ arrayType->extraAttributes &&
+ (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize")-1)) != NULL) {
+
+ dimension = calc_dimension_12(ext->val);
+ dims = get_position_12(dimension, ext->val);
if (type->sdl_type && type->sdl_type->elements &&
zend_hash_num_elements(type->sdl_type->elements) == 1 &&
(zend_hash_internal_pointer_reset(type->sdl_type->elements),
- zend_hash_get_current_data(type->sdl_type->elements, (void**)&elementType) == SUCCESS) &&
- (elementType = *(sdlTypePtr*)elementType) != NULL &&
+ (elementType = zend_hash_get_current_data_ptr(type->sdl_type->elements)) != NULL) &&
elementType->encode) {
enc = elementType->encode;
}
} else if (type->sdl_type && type->sdl_type->elements &&
zend_hash_num_elements(type->sdl_type->elements) == 1 &&
(zend_hash_internal_pointer_reset(type->sdl_type->elements),
- zend_hash_get_current_data(type->sdl_type->elements, (void**)&elementType) == SUCCESS) &&
- (elementType = *(sdlTypePtr*)elementType) != NULL &&
+ (elementType = zend_hash_get_current_data_ptr(type->sdl_type->elements)) != NULL) &&
elementType->encode) {
enc = elementType->encode;
}
while (trav) {
if (trav->type == XML_ELEMENT_NODE) {
int i;
- zval *tmpVal, *ar;
+ zval tmpVal, *ar;
xmlAttrPtr position = get_attribute(trav->properties,"position");
- tmpVal = master_to_zval(enc, trav TSRMLS_CC);
+ master_to_zval(&tmpVal, enc, trav TSRMLS_CC);
if (position != NULL && position->children && position->children->content) {
char* tmp = strrchr((char*)position->children->content, '[');
if (tmp == NULL) {
i = 0;
ar = ret;
while (i < dimension-1) {
- zval** ar2;
- if (zend_hash_index_find(Z_ARRVAL_P(ar), pos[i], (void**)&ar2) == SUCCESS) {
- ar = *ar2;
+ zval* ar2;
+ if ((ar2 = zend_hash_index_find(Z_ARRVAL_P(ar), pos[i])) != NULL) {
+ ar = ar2;
} else {
- zval *tmpAr;
- MAKE_STD_ZVAL(tmpAr);
- array_init(tmpAr);
- zend_hash_index_update(Z_ARRVAL_P(ar), pos[i], &tmpAr, sizeof(zval*), (void**)&ar2);
- ar = *ar2;
+ zval tmpAr;
+ array_init(&tmpAr);
+ ar = zend_hash_index_update(Z_ARRVAL_P(ar), pos[i], &tmpAr);
}
i++;
}
- zend_hash_index_update(Z_ARRVAL_P(ar), pos[i], &tmpVal, sizeof(zval *), NULL);
+ zend_hash_index_update(Z_ARRVAL_P(ar), pos[i], &tmpVal);
/* Increment position */
i = dimension;
if (Z_TYPE_P(data) == IS_ARRAY) {
i = zend_hash_num_elements(Z_ARRVAL_P(data));
- zend_hash_internal_pointer_reset(data->value.ht);
+ zend_hash_internal_pointer_reset(Z_ARRVAL_P(data));
for (;i > 0;i--) {
xmlNodePtr xparam, item;
xmlNodePtr key;
- zval **temp_data;
- char *key_val;
+ zval *temp_data;
+ zend_string *key_val;
ulong int_val;
- zend_hash_get_current_data(data->value.ht, (void **)&temp_data);
+ temp_data = zend_hash_get_current_data(Z_ARRVAL_P(data));
item = xmlNewNode(NULL, BAD_CAST("item"));
xmlAddChild(xmlParam, item);
key = xmlNewNode(NULL, BAD_CAST("key"));
xmlAddChild(item,key);
- if (zend_hash_get_current_key(data->value.ht, &key_val, &int_val, FALSE) == HASH_KEY_IS_STRING) {
+ if (zend_hash_get_current_key(Z_ARRVAL_P(data), &key_val, &int_val, FALSE) == HASH_KEY_IS_STRING) {
if (style == SOAP_ENCODED) {
set_xsi_type(key, "xsd:string");
}
- xmlNodeSetContent(key, BAD_CAST(key_val));
+ xmlNodeSetContent(key, BAD_CAST(key_val->val));
} else {
smart_str tmp = {0};
smart_str_append_long(&tmp, int_val);
if (style == SOAP_ENCODED) {
set_xsi_type(key, "xsd:int");
}
- xmlNodeSetContentLen(key, BAD_CAST(tmp.c), tmp.len);
+ xmlNodeSetContentLen(key, BAD_CAST(tmp.s->val), tmp.s->len);
smart_str_free(&tmp);
}
- xparam = master_to_xml(get_conversion((*temp_data)->type), (*temp_data), style, item TSRMLS_CC);
+ xparam = master_to_xml(get_conversion(Z_TYPE_P(temp_data)), temp_data, style, item TSRMLS_CC);
xmlNodeSetName(xparam, BAD_CAST("value"));
- zend_hash_move_forward(data->value.ht);
+ zend_hash_move_forward(Z_ARRVAL_P(data));
}
}
if (style == SOAP_ENCODED) {
return xmlParam;
}
-static zval *to_zval_map(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_map(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
{
- zval *ret, *key, *value;
+ zval key, value;
xmlNodePtr trav, item, xmlKey, xmlValue;
- MAKE_STD_ZVAL(ret);
+ ZVAL_NULL(ret);
FIND_XML_NULL(data, ret);
if (data && data->children) {
soap_error0(E_ERROR, "Encoding: Can't decode apache map, missing value");
}
- key = master_to_zval(NULL, xmlKey TSRMLS_CC);
- value = master_to_zval(NULL, xmlValue TSRMLS_CC);
+ master_to_zval(&key, NULL, xmlKey TSRMLS_CC);
+ master_to_zval(&value, NULL, xmlValue TSRMLS_CC);
- if (Z_TYPE_P(key) == IS_STRING) {
- zend_symtable_update(Z_ARRVAL_P(ret), Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &value, sizeof(zval *), NULL);
- } else if (Z_TYPE_P(key) == IS_LONG) {
- zend_hash_index_update(Z_ARRVAL_P(ret), Z_LVAL_P(key), &value, sizeof(zval *), NULL);
+ if (Z_TYPE(key) == IS_STRING) {
+ zend_symtable_update(Z_ARRVAL_P(ret), Z_STR(key), &value);
+ } else if (Z_TYPE(key) == IS_LONG) {
+ zend_hash_index_update(Z_ARRVAL_P(ret), Z_LVAL(key), &value);
} else {
soap_error0(E_ERROR, "Encoding: Can't decode apache map, only Strings or Longs are allowd as keys");
}
xmlNodePtr ret;
if (data) {
- enc = get_conversion(data->type);
+ enc = get_conversion(Z_TYPE_P(data));
} else {
enc = get_conversion(IS_NULL);
}
return ret;
}
-static zval *guess_zval_convert(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *guess_zval_convert(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
{
encodePtr enc = NULL;
xmlAttrPtr tmpattr;
xmlChar *type_name = NULL;
- zval *ret;
data = check_and_resolve_href(data);
}
}
}
- ret = master_to_zval_int(enc, data TSRMLS_CC);
+ master_to_zval_int(ret, enc, data TSRMLS_CC);
if (SOAP_GLOBAL(sdl) && type_name && enc->details.sdl_type) {
- zval* soapvar;
+ zval soapvar;
char *ns, *cptype;
xmlNsPtr nsptr;
- MAKE_STD_ZVAL(soapvar);
- object_init_ex(soapvar, soap_var_class_entry);
- add_property_long(soapvar, "enc_type", enc->details.type);
+ object_init_ex(&soapvar, soap_var_class_entry);
+ add_property_long(&soapvar, "enc_type", enc->details.type);
Z_DELREF_P(ret);
- add_property_zval(soapvar, "enc_value", ret);
+ add_property_zval(&soapvar, "enc_value", ret);
parse_namespace(type_name, &cptype, &ns);
nsptr = xmlSearchNs(data->doc, data, BAD_CAST(ns));
- add_property_string(soapvar, "enc_stype", cptype);
+ add_property_string(&soapvar, "enc_stype", cptype);
if (nsptr) {
- add_property_string(soapvar, "enc_ns", (char*)nsptr->href);
+ add_property_string(&soapvar, "enc_ns", (char*)nsptr->href);
}
efree(cptype);
if (ns) {efree(ns);}
- ret = soapvar;
+ ZVAL_COPY_VALUE(ret, &soapvar);
}
return ret;
}
return to_xml_datetime_ex(type, data, "--%m--", style, parent TSRMLS_CC);
}
-static zval* to_zval_list(encodeTypePtr enc, xmlNodePtr data TSRMLS_DC) {
+static zval* to_zval_list(zval *ret, encodeTypePtr enc, xmlNodePtr data TSRMLS_DC) {
/*FIXME*/
- return to_zval_stringc(enc, data TSRMLS_CC);
+ return to_zval_stringc(ret, enc, data TSRMLS_CC);
}
static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent TSRMLS_DC) {
encodePtr list_enc = NULL;
if (enc->sdl_type && enc->sdl_type->kind == XSD_TYPEKIND_LIST && enc->sdl_type->elements) {
- sdlTypePtr *type;
+ sdlTypePtr type;
- zend_hash_internal_pointer_reset(enc->sdl_type->elements);
- if (zend_hash_get_current_data(enc->sdl_type->elements, (void**)&type) == SUCCESS) {
- list_enc = (*type)->encode;
- }
+ ZEND_HASH_FOREACH_PTR(enc->sdl_type->elements, type) {
+ list_enc = type->encode;
+ break;
+ } ZEND_HASH_FOREACH_END();
}
ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
xmlAddChild(parent, ret);
FIND_ZVAL_NULL(data, ret, style);
if (Z_TYPE_P(data) == IS_ARRAY) {
- zval **tmp;
+ zval *tmp;
smart_str list = {0};
HashTable *ht = Z_ARRVAL_P(data);
- zend_hash_internal_pointer_reset(ht);
- while (zend_hash_get_current_data(ht, (void**)&tmp) == SUCCESS) {
- xmlNodePtr dummy = master_to_xml(list_enc, *tmp, SOAP_LITERAL, ret TSRMLS_CC);
+ ZEND_HASH_FOREACH_VAL(ht, tmp) {
+ xmlNodePtr dummy = master_to_xml(list_enc, tmp, SOAP_LITERAL, ret TSRMLS_CC);
if (dummy && dummy->children && dummy->children->content) {
- if (list.len != 0) {
+ if (list.s && list.s->len != 0) {
smart_str_appendc(&list, ' ');
}
smart_str_appends(&list, (char*)dummy->children->content);
}
xmlUnlinkNode(dummy);
xmlFreeNode(dummy);
- zend_hash_move_forward(ht);
- }
+ } ZEND_HASH_FOREACH_END();
smart_str_0(&list);
- xmlNodeSetContentLen(ret, BAD_CAST(list.c), list.len);
+ xmlNodeSetContentLen(ret, BAD_CAST(list.s->val), list.s->len);
smart_str_free(&list);
} else {
zval tmp = *data;
*next = '\0';
next++;
}
- ZVAL_STRING(&dummy_zval, start, 0);
+//??? ZVAL_STRING(&dummy_zval, start, 0);
+ ZVAL_STRING(&dummy_zval, start);
dummy = master_to_xml(list_enc, &dummy_zval, SOAP_LITERAL, ret TSRMLS_CC);
if (dummy && dummy->children && dummy->children->content) {
- if (list.len != 0) {
+ if (list.s && list.s->len != 0) {
smart_str_appendc(&list, ' ');
}
smart_str_appends(&list, (char*)dummy->children->content);
start = next;
}
smart_str_0(&list);
- xmlNodeSetContentLen(ret, BAD_CAST(list.c), list.len);
+ xmlNodeSetContentLen(ret, BAD_CAST(list.s->val), list.s->len);
smart_str_free(&list);
efree(str);
if (data == &tmp) {zval_dtor(&tmp);}
return to_xml_list(enc,data,style, parent TSRMLS_CC);
}
-static zval* to_zval_union(encodeTypePtr enc, xmlNodePtr data TSRMLS_DC) {
+static zval* to_zval_union(zval *ret, encodeTypePtr enc, xmlNodePtr data TSRMLS_DC) {
/*FIXME*/
- return to_zval_list(enc, data TSRMLS_CC);
+ return to_zval_list(ret, enc, data TSRMLS_CC);
}
static xmlNodePtr to_xml_union(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent TSRMLS_DC) {
return to_xml_list(enc,data,style, parent TSRMLS_CC);
}
-static zval *to_zval_any(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_any(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
{
xmlBufferPtr buf;
- zval *ret;
if (SOAP_GLOBAL(sdl) && SOAP_GLOBAL(sdl)->elements && data->name) {
smart_str nscat = {0};
- sdlTypePtr *sdl_type;
+ sdlTypePtr sdl_type;
if (data->ns && data->ns->href) {
smart_str_appends(&nscat, (char*)data->ns->href);
smart_str_appends(&nscat, (char*)data->name);
smart_str_0(&nscat);
- if (zend_hash_find(SOAP_GLOBAL(sdl)->elements, nscat.c, nscat.len+1, (void **)&sdl_type) == SUCCESS &&
- (*sdl_type)->encode) {
+ if ((sdl_type = zend_hash_find_ptr(SOAP_GLOBAL(sdl)->elements, nscat.s)) != NULL &&
+ sdl_type->encode) {
smart_str_free(&nscat);
- return master_to_zval_int((*sdl_type)->encode, data TSRMLS_CC);
+ return master_to_zval_int(ret, sdl_type->encode, data TSRMLS_CC);
}
smart_str_free(&nscat);
}
buf = xmlBufferCreate();
xmlNodeDump(buf, NULL, data, 0, 0);
- MAKE_STD_ZVAL(ret);
- ZVAL_STRING(ret, (char*)xmlBufferContent(buf), 1);
+ ZVAL_STRING(ret, (char*)xmlBufferContent(buf));
xmlBufferFree(buf);
return ret;
}
xmlNodePtr ret = NULL;
if (Z_TYPE_P(data) == IS_ARRAY) {
- HashPosition pos;
- zval **el;
+ zval *el;
encodePtr enc = get_conversion(XSD_ANYXML);
- char *name;
- uint name_len;
- ulong idx;
-
- for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(data), &pos);
- zend_hash_get_current_data_ex(Z_ARRVAL_P(data), (void **) &el, &pos) == SUCCESS;
- zend_hash_move_forward_ex(Z_ARRVAL_P(data), &pos)) {
- ret = master_to_xml(enc, *el, style, parent TSRMLS_CC);
+ zend_string *name;
+
+ ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(data), name, el) {
+ ret = master_to_xml(enc, el, style, parent TSRMLS_CC);
if (ret &&
- ret->name != xmlStringTextNoenc &&
- zend_hash_get_current_key_ex(Z_ARRVAL_P(data), &name, &name_len, &idx, 0, &pos) == HASH_KEY_IS_STRING) {
- xmlNodeSetName(ret, BAD_CAST(name));
+ ret->name != xmlStringTextNoenc) {
+ xmlNodeSetName(ret, BAD_CAST(name->val));
}
- }
+ } ZEND_HASH_FOREACH_END();
return ret;
}
if (Z_TYPE_P(data) == IS_STRING) {
return ret;
}
-zval *sdl_guess_convert_zval(encodeTypePtr enc, xmlNodePtr data TSRMLS_DC)
+zval *sdl_guess_convert_zval(zval *ret, encodeTypePtr enc, xmlNodePtr data TSRMLS_DC)
{
sdlTypePtr type;
type = enc->sdl_type;
if (type == NULL) {
- return guess_zval_convert(enc, data TSRMLS_CC);
+ return guess_zval_convert(ret, enc, data TSRMLS_CC);
}
/*FIXME: restriction support
if (type && type->restrictions &&
switch (type->kind) {
case XSD_TYPEKIND_SIMPLE:
if (type->encode && enc != &type->encode->details) {
- return master_to_zval_int(type->encode, data TSRMLS_CC);
+ return master_to_zval_int(ret, type->encode, data TSRMLS_CC);
} else {
- return guess_zval_convert(enc, data TSRMLS_CC);
+ return guess_zval_convert(ret, enc, data TSRMLS_CC);
}
break;
case XSD_TYPEKIND_LIST:
- return to_zval_list(enc, data TSRMLS_CC);
+ return to_zval_list(ret, enc, data TSRMLS_CC);
case XSD_TYPEKIND_UNION:
- return to_zval_union(enc, data TSRMLS_CC);
+ return to_zval_union(ret, enc, data TSRMLS_CC);
case XSD_TYPEKIND_COMPLEX:
case XSD_TYPEKIND_RESTRICTION:
case XSD_TYPEKIND_EXTENSION:
if (type->encode &&
(type->encode->details.type == IS_ARRAY ||
type->encode->details.type == SOAP_ENC_ARRAY)) {
- return to_zval_array(enc, data TSRMLS_CC);
+ return to_zval_array(ret, enc, data TSRMLS_CC);
}
- return to_zval_object(enc, data TSRMLS_CC);
+ return to_zval_object(ret, enc, data TSRMLS_CC);
default:
soap_error0(E_ERROR, "Encoding: Internal Error");
- return guess_zval_convert(enc, data TSRMLS_CC);
+ return guess_zval_convert(ret, enc, data TSRMLS_CC);
}
}
{
smart_str nstype = {0};
get_type_str(node, ns, type, &nstype);
- set_xsi_type(node, nstype.c);
+ set_xsi_type(node, nstype.s->val);
smart_str_free(&nstype);
}
xmlChar* prefix;
TSRMLS_FETCH();
- if (zend_hash_find(&SOAP_GLOBAL(defEncNs), (char*)ns, strlen(ns) + 1, (void **)&prefix) == SUCCESS) {
+ if ((prefix = zend_hash_str_find_ptr(&SOAP_GLOBAL(defEncNs), (char*)ns, strlen(ns))) != NULL) {
xmlns = xmlNewNs(node->doc->children, BAD_CAST(ns), prefix);
} else {
smart_str prefix = {0};
smart_str_appendl(&prefix, "ns", 2);
smart_str_append_long(&prefix, num);
smart_str_0(&prefix);
- if (xmlSearchNs(node->doc, node, BAD_CAST(prefix.c)) == NULL) {
+ if (xmlSearchNs(node->doc, node, BAD_CAST(prefix.s->val)) == NULL) {
break;
}
smart_str_free(&prefix);
- prefix.c = NULL;
- prefix.len = 0;
+ prefix.s = NULL;
num = ++SOAP_GLOBAL(cur_uniq_ns);
}
- xmlns = xmlNewNs(node->doc->children, BAD_CAST(ns), BAD_CAST(prefix.c));
+ xmlns = xmlNewNs(node->doc->children, BAD_CAST(ns), BAD_CAST(prefix.s ? prefix.s->val : ""));
smart_str_free(&prefix);
}
}
encodePtr get_conversion(int encode)
{
- encodePtr *enc = NULL;
+ encodePtr enc;
TSRMLS_FETCH();
- if (zend_hash_index_find(&SOAP_GLOBAL(defEncIndex), encode, (void **)&enc) == FAILURE) {
+ if ((enc = zend_hash_index_find_ptr(&SOAP_GLOBAL(defEncIndex), encode)) == NULL) {
soap_error0(E_ERROR, "Encoding: Cannot find encoding");
return NULL;
} else {
- return *enc;
+ return enc;
}
}
zend_hash_internal_pointer_reset(Z_ARRVAL_P(array));
for (i = 0; i < count; i++) {
- char *str_index;
+ zend_string *_str_index;
ulong num_index;
- if (zend_hash_get_current_key(Z_ARRVAL_P(array), &str_index, &num_index, 0) == HASH_KEY_IS_STRING ||
+ if (zend_hash_get_current_key(Z_ARRVAL_P(array), &_str_index, &num_index, 0) == HASH_KEY_IS_STRING ||
num_index != i) {
return TRUE;
}
{
HashTable *ht;
int i, count, cur_type, prev_type, different;
- zval **tmp;
+ zval *tmp;
char *prev_stype = NULL, *cur_stype = NULL, *prev_ns = NULL, *cur_ns = NULL;
if (!array || Z_TYPE_P(array) != IS_ARRAY) {
zend_hash_internal_pointer_reset(ht);
for (i = 0;i < count;i++) {
- zend_hash_get_current_data(ht, (void **)&tmp);
+ tmp = zend_hash_get_current_data(ht);
- if (Z_TYPE_PP(tmp) == IS_OBJECT &&
- Z_OBJCE_PP(tmp) == soap_var_class_entry) {
- zval **ztype;
+ if (Z_TYPE_P(tmp) == IS_OBJECT &&
+ Z_OBJCE_P(tmp) == soap_var_class_entry) {
+ zval *ztype;
- if (zend_hash_find(Z_OBJPROP_PP(tmp), "enc_type", sizeof("enc_type"), (void **)&ztype) == FAILURE) {
+ if ((ztype = zend_hash_str_find(Z_OBJPROP_P(tmp), "enc_type", sizeof("enc_type")-1)) == NULL) {
soap_error0(E_ERROR, "Encoding: SoapVar has no 'enc_type' property");
}
- cur_type = Z_LVAL_PP(ztype);
+ cur_type = Z_LVAL_P(ztype);
- if (zend_hash_find(Z_OBJPROP_PP(tmp), "enc_stype", sizeof("enc_stype"), (void **)&ztype) == SUCCESS) {
- cur_stype = Z_STRVAL_PP(ztype);
+ if ((ztype = zend_hash_str_find(Z_OBJPROP_P(tmp), "enc_stype", sizeof("enc_stype")-1)) != NULL) {
+ cur_stype = Z_STRVAL_P(ztype);
} else {
cur_stype = NULL;
}
- if (zend_hash_find(Z_OBJPROP_PP(tmp), "enc_ns", sizeof("enc_ns"), (void **)&ztype) == SUCCESS) {
- cur_ns = Z_STRVAL_PP(ztype);
+ if ((ztype = zend_hash_str_find(Z_OBJPROP_P(tmp), "enc_ns", sizeof("enc_ns")-1)) != NULL) {
+ cur_ns = Z_STRVAL_P(ztype);
} else {
cur_ns = NULL;
}
- } else if (Z_TYPE_PP(tmp) == IS_ARRAY && is_map(*tmp)) {
+ } else if (Z_TYPE_P(tmp) == IS_ARRAY && is_map(tmp)) {
cur_type = APACHE_MAP;
cur_stype = NULL;
cur_ns = NULL;
} else {
- cur_type = Z_TYPE_PP(tmp);
+ cur_type = Z_TYPE_P(tmp);
cur_stype = NULL;
cur_ns = NULL;
}
smart_str_appends(&array_type, cur_stype);
smart_str_0(&array_type);
- enc = get_encoder_ex(SOAP_GLOBAL(sdl), array_type.c, array_type.len);
+ enc = get_encoder_ex(SOAP_GLOBAL(sdl), array_type.s->val, array_type.s->len);
smart_str_free(&array_type);
return enc;
} else {
{
soapMappingPtr map = (soapMappingPtr)data;
- if (map->to_xml) {
- zval_ptr_dtor(&map->to_xml);
- }
- if (map->to_zval) {
- zval_ptr_dtor(&map->to_zval);
- }
+ zval_ptr_dtor(&map->to_xml);
+ zval_ptr_dtor(&map->to_zval);
efree(map);
}
-void delete_encoder(void *encode)
+void delete_encoder(zval *zv)
{
- encodePtr t = *((encodePtr*)encode);
+ encodePtr t = Z_PTR_P(zv);
if (t->details.ns) {
efree(t->details.ns);
}
efree(t);
}
-void delete_encoder_persistent(void *encode)
+void delete_encoder_persistent(zval *zv)
{
- encodePtr t = *((encodePtr*)encode);
+ encodePtr t = Z_PTR_P(zv);
if (t->details.ns) {
free(t->details.ns);
}
struct _encode {
encodeType details;
- zval *(*to_zval)(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+ zval *(*to_zval)(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
xmlNodePtr (*to_xml)(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
};
/* Master functions all encode/decode should be called thur these functions */
xmlNodePtr master_to_xml(encodePtr encode, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
-zval *master_to_zval(encodePtr encode, xmlNodePtr data TSRMLS_DC);
+zval *master_to_zval(zval *ret, encodePtr encode, xmlNodePtr data TSRMLS_DC);
/* user defined mapping */
xmlNodePtr to_xml_user(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
-zval *to_zval_user(encodeTypePtr type, xmlNodePtr node TSRMLS_DC);
+zval *to_zval_user(zval *ret, encodeTypePtr type, xmlNodePtr node TSRMLS_DC);
void whiteSpace_replace(xmlChar* str);
void whiteSpace_collapse(xmlChar* str);
xmlNodePtr sdl_guess_convert_xml(encodeTypePtr enc, zval* data, int style, xmlNodePtr parent TSRMLS_DC);
-zval *sdl_guess_convert_zval(encodeTypePtr enc, xmlNodePtr data TSRMLS_DC);
+zval *sdl_guess_convert_zval(zval *ret, encodeTypePtr enc, xmlNodePtr data TSRMLS_DC);
void encode_finish();
void encode_reset_ns();
encodePtr get_conversion(int encode);
-void delete_encoder(void *handle);
-void delete_encoder_persistent(void *handle);
+void delete_encoder(zval *zv);
+void delete_encoder_persistent(zval *zv);
extern encode defaultEncoding[];
extern int numDefaultEncodings;
/* Proxy HTTP Authentication */
int proxy_authentication(zval* this_ptr, smart_str* soap_headers TSRMLS_DC)
{
- zval **login, **password;
+ zval *login, *password;
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_proxy_login", sizeof("_proxy_login"), (void **)&login) == SUCCESS) {
- unsigned char* buf;
- int len;
+ if ((login = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_proxy_login", sizeof("_proxy_login")-1)) != NULL) {
+ zend_string *buf;
smart_str auth = {0};
- smart_str_appendl(&auth, Z_STRVAL_PP(login), Z_STRLEN_PP(login));
+ smart_str_appendl(&auth, Z_STRVAL_P(login), Z_STRLEN_P(login));
smart_str_appendc(&auth, ':');
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_proxy_password", sizeof("_proxy_password"), (void **)&password) == SUCCESS) {
- smart_str_appendl(&auth, Z_STRVAL_PP(password), Z_STRLEN_PP(password));
+ if ((password = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_proxy_password", sizeof("_proxy_password")-1)) != NULL) {
+ smart_str_appendl(&auth, Z_STRVAL_P(password), Z_STRLEN_P(password));
}
smart_str_0(&auth);
- buf = php_base64_encode((unsigned char*)auth.c, auth.len, &len);
+ buf = php_base64_encode((unsigned char*)auth.s->val, auth.s->len);
smart_str_append_const(soap_headers, "Proxy-Authorization: Basic ");
- smart_str_appendl(soap_headers, (char*)buf, len);
+ smart_str_appendl(soap_headers, (char*)buf->val, buf->len);
smart_str_append_const(soap_headers, "\r\n");
- efree(buf);
+ STR_RELEASE(buf);
smart_str_free(&auth);
return 1;
}
/* HTTP Authentication */
int basic_authentication(zval* this_ptr, smart_str* soap_headers TSRMLS_DC)
{
- zval **login, **password;
+ zval *login, *password;
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_login", sizeof("_login"), (void **)&login) == SUCCESS &&
- !zend_hash_exists(Z_OBJPROP_P(this_ptr), "_digest", sizeof("_digest"))) {
- unsigned char* buf;
- int len;
+ if ((login = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_login", sizeof("_login")-1)) != NULL &&
+ !zend_hash_str_exists(Z_OBJPROP_P(this_ptr), "_digest", sizeof("_digest")-1)) {
+ zend_string* buf;
smart_str auth = {0};
- smart_str_appendl(&auth, Z_STRVAL_PP(login), Z_STRLEN_PP(login));
+ smart_str_appendl(&auth, Z_STRVAL_P(login), Z_STRLEN_P(login));
smart_str_appendc(&auth, ':');
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_password", sizeof("_password"), (void **)&password) == SUCCESS) {
- smart_str_appendl(&auth, Z_STRVAL_PP(password), Z_STRLEN_PP(password));
+ if ((password = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_password", sizeof("_password")-1)) != NULL) {
+ smart_str_appendl(&auth, Z_STRVAL_P(password), Z_STRLEN_P(password));
}
smart_str_0(&auth);
- buf = php_base64_encode((unsigned char*)auth.c, auth.len, &len);
+ buf = php_base64_encode((unsigned char*)auth.s->val, auth.s->len);
smart_str_append_const(soap_headers, "Authorization: Basic ");
- smart_str_appendl(soap_headers, (char*)buf, len);
+ smart_str_appendl(soap_headers, (char*)buf->val, buf->len);
smart_str_append_const(soap_headers, "\r\n");
- efree(buf);
+ STR_RELEASE(buf);
smart_str_free(&auth);
return 1;
}
zend_bool has_cookies,
smart_str* soap_headers TSRMLS_DC)
{
- zval **tmp;
+ zval *tmp;
if (context &&
- php_stream_context_get_option(context, "http", "header", &tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING && Z_STRLEN_PP(tmp)) {
- char *s = Z_STRVAL_PP(tmp);
+ (tmp = php_stream_context_get_option(context, "http", "header")) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING && Z_STRLEN_P(tmp)) {
+ char *s = Z_STRVAL_P(tmp);
char *p;
int name_len;
static php_stream* http_connect(zval* this_ptr, php_url *phpurl, int use_ssl, php_stream_context *context, int *use_proxy TSRMLS_DC)
{
php_stream *stream;
- zval **proxy_host, **proxy_port, **tmp;
+ zval *proxy_host, *proxy_port, *tmp;
char *host;
char *name;
char *protocol;
struct timeval tv;
struct timeval *timeout = NULL;
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_proxy_host", sizeof("_proxy_host"), (void **) &proxy_host) == SUCCESS &&
- Z_TYPE_PP(proxy_host) == IS_STRING &&
- zend_hash_find(Z_OBJPROP_P(this_ptr), "_proxy_port", sizeof("_proxy_port"), (void **) &proxy_port) == SUCCESS &&
- Z_TYPE_PP(proxy_port) == IS_LONG) {
- host = Z_STRVAL_PP(proxy_host);
- port = Z_LVAL_PP(proxy_port);
+ if ((proxy_host = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_proxy_host", sizeof("_proxy_host")-1)) != NULL &&
+ Z_TYPE_P(proxy_host) == IS_STRING &&
+ (proxy_port = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_proxy_port", sizeof("_proxy_port")-1)) != NULL &&
+ Z_TYPE_P(proxy_port) == IS_LONG) {
+ host = Z_STRVAL_P(proxy_host);
+ port = Z_LVAL_P(proxy_port);
*use_proxy = 1;
} else {
host = phpurl->host;
port = phpurl->port;
}
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_connection_timeout", sizeof("_connection_timeout"), (void **) &tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_LONG && Z_LVAL_PP(tmp) > 0) {
- tv.tv_sec = Z_LVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_connection_timeout", sizeof("_connection_timeout")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_LONG && Z_LVAL_P(tmp) > 0) {
+ tv.tv_sec = Z_LVAL_P(tmp);
tv.tv_usec = 0;
timeout = &tv;
}
/* Changed ternary operator to an if/else so that additional comparisons can be done on the ssl_method property */
if (use_ssl && !*use_proxy) {
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_ssl_method", sizeof("_ssl_method"), (void **) &tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_LONG) {
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_ssl_method", sizeof("_ssl_method")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_LONG) {
/* uses constants declared in soap.c to determine ssl uri protocol */
- switch (Z_LVAL_PP(tmp)) {
+ switch (Z_LVAL_P(tmp)) {
case SOAP_SSL_METHOD_TLS:
protocol = "tls";
break;
smart_str_append_const(&soap_headers, "\r\n");
proxy_authentication(this_ptr, &soap_headers TSRMLS_CC);
smart_str_append_const(&soap_headers, "\r\n");
- if (php_stream_write(stream, soap_headers.c, soap_headers.len) != soap_headers.len) {
+ if (php_stream_write(stream, soap_headers.s->val, soap_headers.s->len) != soap_headers.s->len) {
php_stream_close(stream);
stream = NULL;
}
/* if a stream is created without encryption, check to see if SSL method parameter is specified and use
proper encrypyion method based on constants defined in soap.c */
int crypto_method = STREAM_CRYPTO_METHOD_SSLv23_CLIENT;
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_ssl_method", sizeof("_ssl_method"), (void **) &tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_LONG) {
- switch (Z_LVAL_PP(tmp)) {
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_ssl_method", sizeof("_ssl_method")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_LONG) {
+ switch (Z_LVAL_P(tmp)) {
case SOAP_SSL_METHOD_TLS:
crypto_method = STREAM_CRYPTO_METHOD_TLS_CLIENT;
break;
char *location,
char *soapaction,
int soap_version,
- char **buffer,
- int *buffer_len TSRMLS_DC)
+ zval *return_value TSRMLS_DC)
{
char *request;
smart_str soap_headers = {0};
int request_size, err;
php_url *phpurl = NULL;
php_stream *stream;
- zval **trace, **tmp;
+ zval *trace, *tmp;
int use_proxy = 0;
int use_ssl;
char *http_headers, *http_body, *content_type, *http_version, *cookie_itt;
request = buf;
request_size = buf_size;
/* Compress request */
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "compression", sizeof("compression"), (void **)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_LONG) {
- int level = Z_LVAL_PP(tmp) & 0x0f;
- int kind = Z_LVAL_PP(tmp) & SOAP_COMPRESSION_DEFLATE;
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "compression", sizeof("compression")-1)) != NULL && Z_TYPE_P(tmp) == IS_LONG) {
+ int level = Z_LVAL_P(tmp) & 0x0f;
+ int kind = Z_LVAL_P(tmp) & SOAP_COMPRESSION_DEFLATE;
if (level > 9) {level = 9;}
- if ((Z_LVAL_PP(tmp) & SOAP_COMPRESSION_ACCEPT) != 0) {
+ if ((Z_LVAL_P(tmp) & SOAP_COMPRESSION_ACCEPT) != 0) {
smart_str_append_const(&soap_headers_z,"Accept-Encoding: gzip, deflate\r\n");
}
if (level > 0) {
zval func;
zval retval;
- zval param1, param2, param3;
- zval *params[3];
+ zval params[3];
int n;
- params[0] = ¶m1;
- INIT_PZVAL(params[0]);
- params[1] = ¶m2;
- INIT_PZVAL(params[1]);
- params[2] = ¶m3;
- INIT_PZVAL(params[2]);
- ZVAL_STRINGL(params[0], buf, buf_size, 0);
- ZVAL_LONG(params[1], level);
+ //???ZVAL_STRINGL(params[0], buf, buf_size, 0);
+ ZVAL_STRINGL(¶ms[0], buf, buf_size);
+ ZVAL_LONG(¶ms[1], level);
if (kind == SOAP_COMPRESSION_DEFLATE) {
n = 2;
- ZVAL_STRING(&func, "gzcompress", 0);
+ //???ZVAL_STRING(&func, "gzcompress", 0);
+ ZVAL_STRING(&func, "gzcompress");
smart_str_append_const(&soap_headers_z,"Content-Encoding: deflate\r\n");
} else {
n = 3;
- ZVAL_STRING(&func, "gzencode", 0);
+ //???ZVAL_STRING(&func, "gzencode", 0);
+ ZVAL_STRING(&func, "gzencode");
smart_str_append_const(&soap_headers_z,"Content-Encoding: gzip\r\n");
- ZVAL_LONG(params[2], 0x1f);
+ ZVAL_LONG(¶ms[2], 0x1f);
}
- if (call_user_function(CG(function_table), (zval**)NULL, &func, &retval, n, params TSRMLS_CC) == SUCCESS &&
+ if (call_user_function(CG(function_table), (zval*)NULL, &func, &retval, n, params TSRMLS_CC) == SUCCESS &&
Z_TYPE(retval) == IS_STRING) {
request = Z_STRVAL(retval);
request_size = Z_STRLEN(retval);
}
}
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket"), (void **)&tmp) == SUCCESS) {
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket")-1)) != NULL) {
php_stream_from_zval_no_verify(stream,tmp);
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy"), (void **)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_LONG) {
- use_proxy = Z_LVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy")-1)) != NULL && Z_TYPE_P(tmp) == IS_LONG) {
+ use_proxy = Z_LVAL_P(tmp);
}
} else {
stream = NULL;
phpurl = php_url_parse(location);
}
- if (SUCCESS == zend_hash_find(Z_OBJPROP_P(this_ptr),
- "_stream_context", sizeof("_stream_context"), (void**)&tmp)) {
- context = php_stream_context_from_zval(*tmp, 0);
+ if (NULL != (tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr),
+ "_stream_context", sizeof("_stream_context")-1))) {
+ context = php_stream_context_from_zval(tmp, 0);
}
if (context &&
- php_stream_context_get_option(context, "http", "max_redirects", &tmp) == SUCCESS) {
- if (Z_TYPE_PP(tmp) != IS_STRING || !is_numeric_string(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), &redirect_max, NULL, 1)) {
- if (Z_TYPE_PP(tmp) == IS_LONG)
- redirect_max = Z_LVAL_PP(tmp);
+ (tmp = php_stream_context_get_option(context, "http", "max_redirects")) != NULL) {
+ if (Z_TYPE_P(tmp) != IS_STRING || !is_numeric_string(Z_STRVAL_P(tmp), Z_STRLEN_P(tmp), &redirect_max, NULL, 1)) {
+ if (Z_TYPE_P(tmp) == IS_LONG)
+ redirect_max = Z_LVAL_P(tmp);
}
}
/* Check if request to the same host */
if (stream != NULL) {
php_url *orig;
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "httpurl", sizeof("httpurl"), (void **)&tmp) == SUCCESS &&
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "httpurl", sizeof("httpurl")-1)) != NULL &&
(orig = (php_url *) zend_fetch_resource(tmp TSRMLS_CC, -1, "httpurl", NULL, 1, le_url)) != NULL &&
((use_proxy && !use_ssl) ||
(((use_ssl && orig->scheme != NULL && strcmp(orig->scheme, "https") == 0) ||
orig->port == phpurl->port))) {
} else {
php_stream_close(stream);
- zend_hash_del(Z_OBJPROP_P(this_ptr), "httpurl", sizeof("httpurl"));
- zend_hash_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket"));
- zend_hash_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy"));
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "httpurl", sizeof("httpurl")-1);
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket")-1);
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy")-1);
stream = NULL;
use_proxy = 0;
}
/* Check if keep-alive connection is still opened */
if (stream != NULL && php_stream_eof(stream)) {
php_stream_close(stream);
- zend_hash_del(Z_OBJPROP_P(this_ptr), "httpurl", sizeof("httpurl"));
- zend_hash_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket"));
- zend_hash_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy"));
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "httpurl", sizeof("httpurl")-1);
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket")-1);
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy")-1);
stream = NULL;
use_proxy = 0;
}
stream = http_connect(this_ptr, phpurl, use_ssl, context, &use_proxy TSRMLS_CC);
if (stream) {
php_stream_auto_cleanup(stream);
- add_property_resource(this_ptr, "httpsocket", php_stream_get_resource_id(stream));
+ add_property_resource(this_ptr, "httpsocket", stream->res);
add_property_long(this_ptr, "_use_proxy", use_proxy);
} else {
php_url_free(phpurl);
PG(allow_url_fopen) = old_allow_url_fopen;
if (stream) {
- zval **cookies, **login, **password;
- int ret = zend_list_insert(phpurl, le_url TSRMLS_CC);
+ zval *cookies, *login, *password;
+ zend_resource *ret = zend_register_resource(NULL, phpurl, le_url TSRMLS_CC);
add_property_resource(this_ptr, "httpurl", ret);
/*zend_list_addref(ret);*/
if (context &&
- php_stream_context_get_option(context, "http", "protocol_version", &tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_DOUBLE &&
- Z_DVAL_PP(tmp) == 1.0) {
+ (tmp = php_stream_context_get_option(context, "http", "protocol_version")) != NULL &&
+ Z_TYPE_P(tmp) == IS_DOUBLE &&
+ Z_DVAL_P(tmp) == 1.0) {
http_1_1 = 0;
} else {
http_1_1 = 1;
smart_str_append_unsigned(&soap_headers, phpurl->port);
}
if (!http_1_1 ||
- (zend_hash_find(Z_OBJPROP_P(this_ptr), "_keep_alive", sizeof("_keep_alive"), (void **)&tmp) == SUCCESS &&
- Z_LVAL_PP(tmp) == 0)) {
+ ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_keep_alive", sizeof("_keep_alive")-1)) != NULL &&
+ Z_LVAL_P(tmp) == 0)) {
smart_str_append_const(&soap_headers, "\r\n"
"Connection: close\r\n");
} else {
smart_str_append_const(&soap_headers, "\r\n"
"Connection: Keep-Alive\r\n");
}
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_user_agent", sizeof("_user_agent"), (void **)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- if (Z_STRLEN_PP(tmp) > 0) {
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_user_agent", sizeof("_user_agent")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ if (Z_STRLEN_P(tmp) > 0) {
smart_str_append_const(&soap_headers, "User-Agent: ");
- smart_str_appendl(&soap_headers, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ smart_str_appendl(&soap_headers, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
smart_str_append_const(&soap_headers, "\r\n");
}
} else if (context &&
- php_stream_context_get_option(context, "http", "user_agent", &tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- if (Z_STRLEN_PP(tmp) > 0) {
+ (tmp = php_stream_context_get_option(context, "http", "user_agent")) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ if (Z_STRLEN_P(tmp) > 0) {
smart_str_append_const(&soap_headers, "User-Agent: ");
- smart_str_appendl(&soap_headers, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ smart_str_appendl(&soap_headers, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
smart_str_append_const(&soap_headers, "\r\n");
}
} else if (FG(user_agent)) {
smart_str_append_const(&soap_headers, "\r\n");
/* HTTP Authentication */
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_login", sizeof("_login"), (void **)&login) == SUCCESS &&
- Z_TYPE_PP(login) == IS_STRING) {
- zval **digest;
+ if ((login = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_login", sizeof("_login")-1)) != NULL &&
+ Z_TYPE_P(login) == IS_STRING) {
+ zval *digest;
has_authorization = 1;
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_digest", sizeof("_digest"), (void **)&digest) == SUCCESS) {
- if (Z_TYPE_PP(digest) == IS_ARRAY) {
+ if ((digest = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_digest", sizeof("_digest")-1)) != NULL) {
+ if (Z_TYPE_P(digest) == IS_ARRAY) {
char HA1[33], HA2[33], response[33], cnonce[33], nc[9];
PHP_MD5_CTX md5ctx;
unsigned char hash[16];
PHP_MD5Final(hash, &md5ctx);
make_digest(cnonce, hash);
- if (zend_hash_find(Z_ARRVAL_PP(digest), "nc", sizeof("nc"), (void **)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_LONG) {
- Z_LVAL_PP(tmp)++;
- snprintf(nc, sizeof(nc), "%08ld", Z_LVAL_PP(tmp));
+ if ((tmp = zend_hash_str_find(Z_ARRVAL_P(digest), "nc", sizeof("nc")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_LONG) {
+ Z_LVAL_P(tmp)++;
+ snprintf(nc, sizeof(nc), "%08ld", Z_LVAL_P(tmp));
} else {
- add_assoc_long(*digest, "nc", 1);
+ add_assoc_long(digest, "nc", 1);
strcpy(nc, "00000001");
}
PHP_MD5Init(&md5ctx);
- PHP_MD5Update(&md5ctx, (unsigned char*)Z_STRVAL_PP(login), Z_STRLEN_PP(login));
+ PHP_MD5Update(&md5ctx, (unsigned char*)Z_STRVAL_P(login), Z_STRLEN_P(login));
PHP_MD5Update(&md5ctx, (unsigned char*)":", 1);
- if (zend_hash_find(Z_ARRVAL_PP(digest), "realm", sizeof("realm"), (void **)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- PHP_MD5Update(&md5ctx, (unsigned char*)Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ if ((tmp = zend_hash_str_find(Z_ARRVAL_P(digest), "realm", sizeof("realm")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ PHP_MD5Update(&md5ctx, (unsigned char*)Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
}
PHP_MD5Update(&md5ctx, (unsigned char*)":", 1);
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_password", sizeof("_password"), (void **)&password) == SUCCESS &&
- Z_TYPE_PP(password) == IS_STRING) {
- PHP_MD5Update(&md5ctx, (unsigned char*)Z_STRVAL_PP(password), Z_STRLEN_PP(password));
+ if ((password = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_password", sizeof("_password")-1)) != NULL &&
+ Z_TYPE_P(password) == IS_STRING) {
+ PHP_MD5Update(&md5ctx, (unsigned char*)Z_STRVAL_P(password), Z_STRLEN_P(password));
}
PHP_MD5Final(hash, &md5ctx);
make_digest(HA1, hash);
- if (zend_hash_find(Z_ARRVAL_PP(digest), "algorithm", sizeof("algorithm"), (void **)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING &&
- Z_STRLEN_PP(tmp) == sizeof("md5-sess")-1 &&
- stricmp(Z_STRVAL_PP(tmp), "md5-sess") == 0) {
+ if ((tmp = zend_hash_str_find(Z_ARRVAL_P(digest), "algorithm", sizeof("algorithm")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING &&
+ Z_STRLEN_P(tmp) == sizeof("md5-sess")-1 &&
+ stricmp(Z_STRVAL_P(tmp), "md5-sess") == 0) {
PHP_MD5Init(&md5ctx);
PHP_MD5Update(&md5ctx, (unsigned char*)HA1, 32);
PHP_MD5Update(&md5ctx, (unsigned char*)":", 1);
- if (zend_hash_find(Z_ARRVAL_PP(digest), "nonce", sizeof("nonce"), (void **)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- PHP_MD5Update(&md5ctx, (unsigned char*)Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ if ((tmp = zend_hash_str_find(Z_ARRVAL_P(digest), "nonce", sizeof("nonce")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ PHP_MD5Update(&md5ctx, (unsigned char*)Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
}
PHP_MD5Update(&md5ctx, (unsigned char*)":", 1);
PHP_MD5Update(&md5ctx, (unsigned char*)cnonce, 8);
PHP_MD5Init(&md5ctx);
PHP_MD5Update(&md5ctx, (unsigned char*)HA1, 32);
PHP_MD5Update(&md5ctx, (unsigned char*)":", 1);
- if (zend_hash_find(Z_ARRVAL_PP(digest), "nonce", sizeof("nonce"), (void **)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- PHP_MD5Update(&md5ctx, (unsigned char*)Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ if ((tmp = zend_hash_str_find(Z_ARRVAL_P(digest), "nonce", sizeof("nonce")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ PHP_MD5Update(&md5ctx, (unsigned char*)Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
}
PHP_MD5Update(&md5ctx, (unsigned char*)":", 1);
- if (zend_hash_find(Z_ARRVAL_PP(digest), "qop", sizeof("qop"), (void **)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
+ if ((tmp = zend_hash_str_find(Z_ARRVAL_P(digest), "qop", sizeof("qop")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
PHP_MD5Update(&md5ctx, (unsigned char*)nc, 8);
PHP_MD5Update(&md5ctx, (unsigned char*)":", 1);
PHP_MD5Update(&md5ctx, (unsigned char*)cnonce, 8);
make_digest(response, hash);
smart_str_append_const(&soap_headers, "Authorization: Digest username=\"");
- smart_str_appendl(&soap_headers, Z_STRVAL_PP(login), Z_STRLEN_PP(login));
- if (zend_hash_find(Z_ARRVAL_PP(digest), "realm", sizeof("realm"), (void **)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
+ smart_str_appendl(&soap_headers, Z_STRVAL_P(login), Z_STRLEN_P(login));
+ if ((tmp = zend_hash_str_find(Z_ARRVAL_P(digest), "realm", sizeof("realm")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
smart_str_append_const(&soap_headers, "\", realm=\"");
- smart_str_appendl(&soap_headers, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ smart_str_appendl(&soap_headers, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
}
- if (zend_hash_find(Z_ARRVAL_PP(digest), "nonce", sizeof("nonce"), (void **)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
+ if ((tmp = zend_hash_str_find(Z_ARRVAL_P(digest), "nonce", sizeof("nonce")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
smart_str_append_const(&soap_headers, "\", nonce=\"");
- smart_str_appendl(&soap_headers, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ smart_str_appendl(&soap_headers, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
}
smart_str_append_const(&soap_headers, "\", uri=\"");
if (phpurl->path) {
smart_str_appendc(&soap_headers, '#');
smart_str_appends(&soap_headers, phpurl->fragment);
}
- if (zend_hash_find(Z_ARRVAL_PP(digest), "qop", sizeof("qop"), (void **)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
+ if ((tmp = zend_hash_str_find(Z_ARRVAL_P(digest), "qop", sizeof("qop")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
/* TODO: Support for qop="auth-int" */
smart_str_append_const(&soap_headers, "\", qop=\"auth");
smart_str_append_const(&soap_headers, "\", nc=\"");
}
smart_str_append_const(&soap_headers, "\", response=\"");
smart_str_appendl(&soap_headers, response, 32);
- if (zend_hash_find(Z_ARRVAL_PP(digest), "opaque", sizeof("opaque"), (void **)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
+ if ((tmp = zend_hash_str_find(Z_ARRVAL_P(digest), "opaque", sizeof("opaque")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
smart_str_append_const(&soap_headers, "\", opaque=\"");
- smart_str_appendl(&soap_headers, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ smart_str_appendl(&soap_headers, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
}
- if (zend_hash_find(Z_ARRVAL_PP(digest), "algorithm", sizeof("algorithm"), (void **)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
+ if ((tmp = zend_hash_str_find(Z_ARRVAL_P(digest), "algorithm", sizeof("algorithm")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
smart_str_append_const(&soap_headers, "\", algorithm=\"");
- smart_str_appendl(&soap_headers, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ smart_str_appendl(&soap_headers, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
}
smart_str_append_const(&soap_headers, "\"\r\n");
}
} else {
- unsigned char* buf;
- int len;
+ zend_string *buf;
smart_str auth = {0};
- smart_str_appendl(&auth, Z_STRVAL_PP(login), Z_STRLEN_PP(login));
+ smart_str_appendl(&auth, Z_STRVAL_P(login), Z_STRLEN_P(login));
smart_str_appendc(&auth, ':');
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_password", sizeof("_password"), (void **)&password) == SUCCESS &&
- Z_TYPE_PP(password) == IS_STRING) {
- smart_str_appendl(&auth, Z_STRVAL_PP(password), Z_STRLEN_PP(password));
+ if ((password = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_password", sizeof("_password")-1)) != NULL &&
+ Z_TYPE_P(password) == IS_STRING) {
+ smart_str_appendl(&auth, Z_STRVAL_P(password), Z_STRLEN_P(password));
}
smart_str_0(&auth);
- buf = php_base64_encode((unsigned char*)auth.c, auth.len, &len);
+ buf = php_base64_encode((unsigned char*)auth.s->val, auth.s->len);
smart_str_append_const(&soap_headers, "Authorization: Basic ");
- smart_str_appendl(&soap_headers, (char*)buf, len);
+ smart_str_appendl(&soap_headers, (char*)buf->val, buf->len);
smart_str_append_const(&soap_headers, "\r\n");
- efree(buf);
+ STR_RELEASE(buf);
smart_str_free(&auth);
}
}
}
/* Send cookies along with request */
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_cookies", sizeof("_cookies"), (void **)&cookies) == SUCCESS) {
- zval **data;
- char *key;
- uint key_len;
+ if ((cookies = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_cookies", sizeof("_cookies")-1)) != NULL) {
+ zval *data;
+ zend_string *key;
int i, n;
has_cookies = 1;
- n = zend_hash_num_elements(Z_ARRVAL_PP(cookies));
+ n = zend_hash_num_elements(Z_ARRVAL_P(cookies));
if (n > 0) {
- zend_hash_internal_pointer_reset(Z_ARRVAL_PP(cookies));
+ zend_hash_internal_pointer_reset(Z_ARRVAL_P(cookies));
smart_str_append_const(&soap_headers, "Cookie: ");
for (i = 0; i < n; i++) {
- zend_hash_get_current_data(Z_ARRVAL_PP(cookies), (void **)&data);
- zend_hash_get_current_key_ex(Z_ARRVAL_PP(cookies), &key, &key_len, NULL, 0, NULL);
-
- if (Z_TYPE_PP(data) == IS_ARRAY) {
- zval** value;
-
- if (zend_hash_index_find(Z_ARRVAL_PP(data), 0, (void**)&value) == SUCCESS &&
- Z_TYPE_PP(value) == IS_STRING) {
- zval **tmp;
- if ((zend_hash_index_find(Z_ARRVAL_PP(data), 1, (void**)&tmp) == FAILURE ||
- strncmp(phpurl->path?phpurl->path:"/",Z_STRVAL_PP(tmp),Z_STRLEN_PP(tmp)) == 0) &&
- (zend_hash_index_find(Z_ARRVAL_PP(data), 2, (void**)&tmp) == FAILURE ||
- in_domain(phpurl->host,Z_STRVAL_PP(tmp))) &&
- (use_ssl || zend_hash_index_find(Z_ARRVAL_PP(data), 3, (void**)&tmp) == FAILURE)) {
- smart_str_appendl(&soap_headers, key, key_len);
+ data = zend_hash_get_current_data(Z_ARRVAL_P(cookies));
+ zend_hash_get_current_key_ex(Z_ARRVAL_P(cookies), &key, NULL, 0, NULL);
+
+ if (Z_TYPE_P(data) == IS_ARRAY) {
+ zval *value;
+
+ if ((value = zend_hash_index_find(Z_ARRVAL_P(data), 0)) != NULL &&
+ Z_TYPE_P(value) == IS_STRING) {
+ zval *tmp;
+ if (((tmp = zend_hash_index_find(Z_ARRVAL_P(data), 1)) == NULL ||
+ strncmp(phpurl->path?phpurl->path:"/",Z_STRVAL_P(tmp),Z_STRLEN_P(tmp)) == 0) &&
+ ((tmp = zend_hash_index_find(Z_ARRVAL_P(data), 2)) == NULL ||
+ in_domain(phpurl->host,Z_STRVAL_P(tmp))) &&
+ (use_ssl || (tmp = zend_hash_index_find(Z_ARRVAL_P(data), 3)) == NULL)) {
+ smart_str_appendl(&soap_headers, key->val, key->len);
smart_str_appendc(&soap_headers, '=');
- smart_str_appendl(&soap_headers, Z_STRVAL_PP(value), Z_STRLEN_PP(value));
+ smart_str_appendl(&soap_headers, Z_STRVAL_P(value), Z_STRLEN_P(value));
smart_str_appendc(&soap_headers, ';');
}
}
}
- zend_hash_move_forward(Z_ARRVAL_PP(cookies));
+ zend_hash_move_forward(Z_ARRVAL_P(cookies));
}
smart_str_append_const(&soap_headers, "\r\n");
}
smart_str_append_const(&soap_headers, "\r\n");
smart_str_0(&soap_headers);
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace"), (void **) &trace) == SUCCESS &&
- Z_LVAL_PP(trace) > 0) {
- add_property_stringl(this_ptr, "__last_request_headers", soap_headers.c, soap_headers.len);
+ if ((trace = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace")-1)) != NULL &&
+ Z_LVAL_P(trace) > 0) {
+ add_property_stringl(this_ptr, "__last_request_headers", soap_headers.s->val, soap_headers.s->len);
}
smart_str_appendl(&soap_headers, request, request_size);
smart_str_0(&soap_headers);
- err = php_stream_write(stream, soap_headers.c, soap_headers.len);
- if (err != soap_headers.len) {
+ err = php_stream_write(stream, soap_headers.s->val, soap_headers.s->len);
+ if (err != soap_headers.s->len) {
if (request != buf) {efree(request);}
php_stream_close(stream);
- zend_hash_del(Z_OBJPROP_P(this_ptr), "httpurl", sizeof("httpurl"));
- zend_hash_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket"));
- zend_hash_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy"));
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "httpurl", sizeof("httpurl")-1);
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket")-1);
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy")-1);
add_soap_fault(this_ptr, "HTTP", "Failed Sending HTTP SOAP request", NULL, NULL TSRMLS_CC);
smart_str_free(&soap_headers_z);
return FALSE;
return FALSE;
}
- if (!buffer) {
+ if (!return_value) {
php_stream_close(stream);
- zend_hash_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket"));
- zend_hash_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy"));
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket")-1);
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy")-1);
smart_str_free(&soap_headers_z);
return TRUE;
}
if (http_headers) {efree(http_headers);}
if (request != buf) {efree(request);}
php_stream_close(stream);
- zend_hash_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket"));
- zend_hash_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy"));
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket")-1);
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy")-1);
add_soap_fault(this_ptr, "HTTP", "Error Fetching http headers", NULL, NULL TSRMLS_CC);
smart_str_free(&soap_headers_z);
return FALSE;
}
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace"), (void **) &trace) == SUCCESS &&
- Z_LVAL_PP(trace) > 0) {
+ if ((trace = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace")-1)) != NULL &&
+ Z_LVAL_P(trace) > 0) {
add_property_stringl(this_ptr, "__last_response_headers", http_headers, http_header_size);
}
while (cookie_itt) {
char *end_pos, *cookie;
char *eqpos, *sempos;
- zval **cookies;
+ zval *cookies;
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_cookies", sizeof("_cookies"), (void **)&cookies) == FAILURE) {
- zval *tmp_cookies;
- MAKE_STD_ZVAL(tmp_cookies);
- array_init(tmp_cookies);
- zend_hash_update(Z_OBJPROP_P(this_ptr), "_cookies", sizeof("_cookies"), &tmp_cookies, sizeof(zval *), (void **)&cookies);
+ if ((cookies = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_cookies", sizeof("_cookies")-1)) == NULL) {
+ zval tmp_cookies;
+ array_init(&tmp_cookies);
+ cookies = zend_hash_str_update(Z_OBJPROP_P(this_ptr), "_cookies", sizeof("_cookies")-1, &tmp_cookies);
}
end_pos = strstr(cookie_itt,"\r\n");
if (eqpos != NULL && (sempos == NULL || sempos > eqpos)) {
smart_str name = {0};
int cookie_len;
- zval *zcookie;
+ zval zcookie;
if (sempos != NULL) {
cookie_len = sempos-(eqpos+1);
smart_str_appendl(&name, cookie, eqpos - cookie);
smart_str_0(&name);
- ALLOC_INIT_ZVAL(zcookie);
- array_init(zcookie);
- add_index_stringl(zcookie, 0, eqpos + 1, cookie_len);
+ array_init(&zcookie);
+ add_index_stringl(&zcookie, 0, eqpos + 1, cookie_len);
if (sempos != NULL) {
char *options = cookie + cookie_len+1;
sempos = strstr(options, ";");
if (strstr(options,"path=") == options) {
eqpos = options + sizeof("path=")-1;
- add_index_stringl(zcookie, 1, eqpos, sempos?(sempos-eqpos):strlen(eqpos));
+ add_index_stringl(&zcookie, 1, eqpos, sempos?(sempos-eqpos):strlen(eqpos));
} else if (strstr(options,"domain=") == options) {
eqpos = options + sizeof("domain=")-1;
- add_index_stringl(zcookie, 2, eqpos, sempos?(sempos-eqpos):strlen(eqpos));
+ add_index_stringl(&zcookie, 2, eqpos, sempos?(sempos-eqpos):strlen(eqpos));
} else if (strstr(options,"secure") == options) {
- add_index_bool(zcookie, 3, 1);
+ add_index_bool(&zcookie, 3, 1);
}
if (sempos != NULL) {
options = sempos+1;
}
}
}
- if (!zend_hash_index_exists(Z_ARRVAL_P(zcookie), 1)) {
+ if (!zend_hash_index_exists(Z_ARRVAL(zcookie), 1)) {
char *t = phpurl->path?phpurl->path:"/";
char *c = strrchr(t, '/');
if (c) {
- add_index_stringl(zcookie, 1, t, c-t);
+ add_index_stringl(&zcookie, 1, t, c-t);
}
}
- if (!zend_hash_index_exists(Z_ARRVAL_P(zcookie), 2)) {
- add_index_string(zcookie, 2, phpurl->host);
+ if (!zend_hash_index_exists(Z_ARRVAL(zcookie), 2)) {
+ add_index_string(&zcookie, 2, phpurl->host);
}
- add_assoc_zval_ex(*cookies, name.c, name.len+1, zcookie);
+ // TODO: avoid reallocation ???
+ add_assoc_zval_ex(cookies, name.s->val, name.s->len, &zcookie);
smart_str_free(&name);
}
if (request != buf) {efree(request);}
php_stream_close(stream);
efree(http_headers);
- zend_hash_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket"));
- zend_hash_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy"));
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket")-1);
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy")-1);
add_soap_fault(this_ptr, "HTTP", "Error Fetching http body, No Content-Length, connection closed or chunked data", NULL, NULL TSRMLS_CC);
if (http_msg) {
efree(http_msg);
if (http_close) {
php_stream_close(stream);
- zend_hash_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket"));
- zend_hash_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy"));
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket")-1);
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy")-1);
stream = NULL;
}
}
} else if (http_status == 401) {
/* Digest authentication */
- zval **digest, **login, **password;
+ zval *digest, *login, *password;
char *auth = get_http_header_value(http_headers, "WWW-Authenticate: ");
if (auth &&
strstr(auth, "Digest") == auth &&
- (zend_hash_find(Z_OBJPROP_P(this_ptr), "_digest", sizeof("_digest"), (void **)&digest) == FAILURE ||
- Z_TYPE_PP(digest) != IS_ARRAY) &&
- zend_hash_find(Z_OBJPROP_P(this_ptr), "_login", sizeof("_login"), (void **)&login) == SUCCESS &&
- Z_TYPE_PP(login) == IS_STRING &&
- zend_hash_find(Z_OBJPROP_P(this_ptr), "_password", sizeof("_password"), (void **)&password) == SUCCESS &&
- Z_TYPE_PP(password) == IS_STRING) {
+ ((digest = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_digest", sizeof("_digest")-1)) == NULL ||
+ Z_TYPE_P(digest) != IS_ARRAY) &&
+ (login = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_login", sizeof("_login")-1)) != NULL &&
+ Z_TYPE_P(login) == IS_STRING &&
+ (password = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_password", sizeof("_password")-1)) != NULL &&
+ Z_TYPE_P(password) == IS_STRING) {
char *s;
- zval *digest = NULL;
+ zval digest;
+ ZVAL_UNDEF(&digest);
s = auth + sizeof("Digest")-1;
while (*s != '\0') {
char *name, *val;
++s;
}
}
- if (digest == NULL) {
- ALLOC_INIT_ZVAL(digest);
- array_init(digest);
+ if (Z_TYPE(digest) == IS_UNDEF) {
+ array_init(&digest);
}
- add_assoc_string(digest, name, val);
+ add_assoc_string(&digest, name, val);
}
}
- if (digest != NULL) {
+ if (Z_TYPE(digest) != IS_UNDEF) {
php_url *new_url = emalloc(sizeof(php_url));
- Z_DELREF_P(digest);
- add_property_zval_ex(this_ptr, "_digest", sizeof("_digest"), digest TSRMLS_CC);
+ Z_DELREF(digest);
+ add_property_zval_ex(this_ptr, "_digest", sizeof("_digest")-1, &digest TSRMLS_CC);
*new_url = *phpurl;
if (phpurl->scheme) phpurl->scheme = estrdup(phpurl->scheme);
if (content_encoding) {
zval func;
zval retval;
- zval param;
- zval *params[1];
+ zval params[1];
if ((strcmp(content_encoding,"gzip") == 0 ||
strcmp(content_encoding,"x-gzip") == 0) &&
- zend_hash_exists(EG(function_table), "gzinflate", sizeof("gzinflate"))) {
- ZVAL_STRING(&func, "gzinflate", 0);
- params[0] = ¶m;
- ZVAL_STRINGL(params[0], http_body+10, http_body_size-10, 0);
- INIT_PZVAL(params[0]);
+ zend_hash_str_exists(EG(function_table), "gzinflate", sizeof("gzinflate")-1)) {
+ //???ZVAL_STRING(&func, "gzinflate", 0);
+ //???ZVAL_STRINGL(params[0], http_body+10, http_body_size-10, 0);
+ ZVAL_STRING(&func, "gzinflate");
+ ZVAL_STRINGL(¶ms[0], http_body+10, http_body_size-10);
} else if (strcmp(content_encoding,"deflate") == 0 &&
- zend_hash_exists(EG(function_table), "gzuncompress", sizeof("gzuncompress"))) {
- ZVAL_STRING(&func, "gzuncompress", 0);
- params[0] = ¶m;
- ZVAL_STRINGL(params[0], http_body, http_body_size, 0);
- INIT_PZVAL(params[0]);
+ zend_hash_str_exists(EG(function_table), "gzuncompress", sizeof("gzuncompress")-1)) {
+ //???ZVAL_STRING(&func, "gzuncompress", 0);
+ //???ZVAL_STRINGL(params[0], http_body, http_body_size, 0);
+ ZVAL_STRING(&func, "gzuncompress");
+ ZVAL_STRINGL(¶ms[0], http_body, http_body_size);
} else {
efree(content_encoding);
efree(http_headers);
add_soap_fault(this_ptr, "HTTP", "Unknown Content-Encoding", NULL, NULL TSRMLS_CC);
return FALSE;
}
- if (call_user_function(CG(function_table), (zval**)NULL, &func, &retval, 1, params TSRMLS_CC) == SUCCESS &&
+ if (call_user_function(CG(function_table), (zval*)NULL, &func, &retval, 1, params TSRMLS_CC) == SUCCESS &&
Z_TYPE(retval) == IS_STRING) {
efree(http_body);
- *buffer = Z_STRVAL(retval);
- *buffer_len = Z_STRLEN(retval);
+ ZVAL_COPY_VALUE(return_value, &retval);
} else {
efree(content_encoding);
efree(http_headers);
}
efree(content_encoding);
} else {
- *buffer = http_body;
- *buffer_len = http_body_size;
+ // TODO: avoid reallocation ???
+ //???*buffer = http_body;
+ //???*buffer_len = http_body_size;
+ ZVAL_STRINGL(return_value, http_body, http_body_size);
+ efree(http_body);
}
efree(http_headers);
if (http_status >= 400) {
int error = 0;
- if (*buffer_len == 0) {
+ if (Z_STRLEN_P(return_value) == 0) {
error = 1;
- } else if (*buffer_len > 0) {
+ } else if (Z_STRLEN_P(return_value) > 0) {
if (!content_type_xml) {
- char *s = *buffer;
+ char *s = Z_STRVAL_P(return_value);
while (*s != '\0' && *s < ' ') {
s++;
}
if (error) {
- efree(*buffer);
+ zval_ptr_dtor(return_value);
+ ZVAL_UNDEF(return_value);
add_soap_fault(this_ptr, "HTTP", http_msg, NULL, NULL TSRMLS_CC);
efree(http_msg);
return FALSE;
smart_str_appends(&tmp_response, headerbuf);
}
smart_str_0(&tmp_response);
- (*response) = tmp_response.c;
- (*out_size) = tmp_response.len;
+ (*response) = tmp_response.s->val;
+ (*out_size) = tmp_response.s->len;
return done;
}
/*
char *location,
char *soapaction,
int soap_version,
- char **response,
- int *response_len TSRMLS_DC);
+ zval *response TSRMLS_DC);
int proxy_authentication(zval* this_ptr, smart_str* soap_headers TSRMLS_DC);
int basic_authentication(zval* this_ptr, smart_str* soap_headers TSRMLS_DC);
/* Check if <Body> contains <Fault> element */
fault = get_node_ex(body->children,"Fault",envelope_ns);
if (fault != NULL) {
- char *faultcode = NULL, *faultstring = NULL, *faultactor = NULL;
- zval *details = NULL;
+ char *faultcode = NULL;
+ zend_string *faultstring = NULL, *faultactor = NULL;
+ zval details;
xmlNodePtr tmp;
+ ZVAL_UNDEF(&details);
if (soap_version == SOAP_1_1) {
tmp = get_node(fault->children, "faultcode");
if (tmp != NULL && tmp->children != NULL) {
tmp = get_node(fault->children, "faultstring");
if (tmp != NULL && tmp->children != NULL) {
- zval *zv = master_to_zval(get_conversion(IS_STRING), tmp TSRMLS_CC);
- faultstring = Z_STRVAL_P(zv);
- FREE_ZVAL(zv);
+ zval zv;
+ master_to_zval(&zv, get_conversion(IS_STRING), tmp TSRMLS_CC);
+ faultstring = Z_STR(zv);
}
tmp = get_node(fault->children, "faultactor");
if (tmp != NULL && tmp->children != NULL) {
- zval *zv = master_to_zval(get_conversion(IS_STRING), tmp TSRMLS_CC);
- faultactor = Z_STRVAL_P(zv);
- FREE_ZVAL(zv);
+ zval zv;
+ master_to_zval(&zv, get_conversion(IS_STRING), tmp TSRMLS_CC);
+ faultactor = Z_STR(zv);
}
tmp = get_node(fault->children, "detail");
if (tmp != NULL) {
- details = master_to_zval(NULL, tmp TSRMLS_CC);
+ master_to_zval(&details, NULL, tmp TSRMLS_CC);
}
} else {
tmp = get_node(fault->children, "Code");
/* TODO: lang attribute */
tmp = get_node(tmp->children,"Text");
if (tmp != NULL && tmp->children != NULL) {
- zval *zv = master_to_zval(get_conversion(IS_STRING), tmp TSRMLS_CC);
- faultstring = Z_STRVAL_P(zv);
- FREE_ZVAL(zv);
+ zval zv;
+ master_to_zval(&zv, get_conversion(IS_STRING), tmp TSRMLS_CC);
+ faultstring = Z_STR(zv);
}
}
tmp = get_node(fault->children,"Detail");
if (tmp != NULL) {
- details = master_to_zval(NULL, tmp TSRMLS_CC);
+ master_to_zval(&details, NULL, tmp TSRMLS_CC);
}
}
- add_soap_fault(this_ptr, faultcode, faultstring, faultactor, details TSRMLS_CC);
+ add_soap_fault(this_ptr, faultcode, faultstring->val, faultactor->val, &details TSRMLS_CC);
if (faultstring) {
- efree(faultstring);
+ STR_RELEASE(faultstring);
}
if (faultactor) {
- efree(faultactor);
+ STR_RELEASE(faultactor);
}
- if (details) {
- Z_DELREF_P(details);
+ if (Z_REFCOUNTED(details)) {
+ Z_DELREF(details);
}
xmlFreeDoc(response);
return FALSE;
if (resp != NULL) {
if (fn != NULL && fn->binding && fn->binding->bindingType == BINDING_SOAP) {
/* Function has WSDL description */
- sdlParamPtr *h_param, param = NULL;
+ sdlParamPtr param = NULL;
xmlNodePtr val = NULL;
char *name, *ns = NULL;
- zval* tmp;
+ zval tmp;
sdlSoapBindingFunctionPtr fnb = (sdlSoapBindingFunctionPtr)fn->bindingAttributes;
int res_count;
hdrs = fnb->output.headers;
if (fn->responseParameters) {
- res_count = zend_hash_num_elements(fn->responseParameters);
- zend_hash_internal_pointer_reset(fn->responseParameters);
- while (zend_hash_get_current_data(fn->responseParameters, (void **)&h_param) == SUCCESS) {
- param = (*h_param);
+ res_count = zend_hash_num_elements(fn->responseParameters);
+ ZEND_HASH_FOREACH_PTR(fn->responseParameters, param) {
if (fnb->style == SOAP_DOCUMENT) {
if (param->element) {
name = param->element->name;
if (!val) {
/* TODO: may be "nil" is not OK? */
- MAKE_STD_ZVAL(tmp);
- ZVAL_NULL(tmp);
+ ZVAL_NULL(&tmp);
/*
add_soap_fault(this_ptr, "Client", "Can't find response data", NULL, NULL TSRMLS_CC);
xmlFreeDoc(response);
} else {
/* Decoding value of parameter */
if (param != NULL) {
- tmp = master_to_zval(param->encode, val TSRMLS_CC);
+ master_to_zval(&tmp, param->encode, val TSRMLS_CC);
} else {
- tmp = master_to_zval(NULL, val TSRMLS_CC);
+ master_to_zval(&tmp, NULL, val TSRMLS_CC);
}
}
- add_assoc_zval(return_value, param->paramName, tmp);
+ add_assoc_zval(return_value, param->paramName, &tmp);
param_count++;
-
- zend_hash_move_forward(fn->responseParameters);
- }
+ } ZEND_HASH_FOREACH_END();
}
} else {
/* Function has no WSDL description */
}
if (val != NULL) {
if (!node_is_equal_ex(val,"result",RPC_SOAP12_NAMESPACE)) {
- zval *tmp;
- zval **arr;
+ zval tmp;
+ zval *arr;
- tmp = master_to_zval(NULL, val TSRMLS_CC);
+ master_to_zval(&tmp, NULL, val TSRMLS_CC);
if (val->name) {
- if (zend_hash_find(Z_ARRVAL_P(return_value), (char*)val->name, strlen((char*)val->name)+1, (void**)&arr) == SUCCESS) {
- add_next_index_zval(*arr, tmp);
+ if ((arr = zend_hash_str_find(Z_ARRVAL_P(return_value), (char*)val->name, strlen((char*)val->name))) != NULL) {
+ add_next_index_zval(arr, &tmp);
} else if (val->next && get_node(val->next, (char*)val->name)) {
- zval *arr;
+ zval arr;
- MAKE_STD_ZVAL(arr);
- array_init(arr);
- add_next_index_zval(arr, tmp);
- add_assoc_zval(return_value, (char*)val->name, arr);
+ array_init(&arr);
+ add_next_index_zval(&arr, &tmp);
+ add_assoc_zval(return_value, (char*)val->name, &arr);
} else {
- add_assoc_zval(return_value, (char*)val->name, tmp);
+ add_assoc_zval(return_value, (char*)val->name, &tmp);
}
} else {
- add_next_index_zval(return_value, tmp);
+ add_next_index_zval(return_value, &tmp);
}
++param_count;
}
zval *tmp;
zend_hash_internal_pointer_reset(Z_ARRVAL_P(return_value));
- zend_hash_get_current_data(Z_ARRVAL_P(return_value), (void**)&tmp);
- tmp = *(zval**)tmp;
- Z_ADDREF_P(tmp);
+ tmp = zend_hash_get_current_data(Z_ARRVAL_P(return_value));
+ if (Z_REFCOUNTED_P(tmp)) Z_ADDREF_P(tmp);
zval_dtor(return_value);
- *return_value = *tmp;
- FREE_ZVAL(tmp);
+ ZVAL_COPY_VALUE(return_value, tmp);
}
}
while (trav != NULL) {
if (trav->type == XML_ELEMENT_NODE) {
encodePtr enc = NULL;
- zval* val;
+ zval val;
if (hdrs) {
smart_str key = {0};
- sdlSoapBindingFunctionHeaderPtr *hdr;
+ sdlSoapBindingFunctionHeaderPtr hdr;
if (trav->ns) {
smart_str_appends(&key, (char*)trav->ns->href);
}
smart_str_appends(&key, (char*)trav->name);
smart_str_0(&key);
- if (zend_hash_find(hdrs, key.c, key.len+1, (void**)&hdr) == SUCCESS) {
- enc = (*hdr)->encode;
+ if ((hdr = zend_hash_find_ptr(hdrs, key.s)) != NULL) {
+ enc = hdr->encode;
}
smart_str_free(&key);
}
- val = master_to_zval(enc, trav TSRMLS_CC);
- add_assoc_zval(soap_headers, (char*)trav->name, val);
+ master_to_zval(&val, enc, trav TSRMLS_CC);
+ add_assoc_zval(soap_headers, (char*)trav->name, &val);
}
trav = trav->next;
}
static encodePtr create_encoder(sdlPtr sdl, sdlTypePtr cur_type, const xmlChar *ns, const xmlChar *type)
{
smart_str nscat = {0};
- encodePtr enc, *enc_ptr;
+ encodePtr enc, enc_ptr;
if (sdl->encoders == NULL) {
sdl->encoders = emalloc(sizeof(HashTable));
smart_str_appendc(&nscat, ':');
smart_str_appends(&nscat, (char*)type);
smart_str_0(&nscat);
- if (zend_hash_find(sdl->encoders, nscat.c, nscat.len + 1, (void**)&enc_ptr) == SUCCESS) {
- enc = *enc_ptr;
+ if ((enc_ptr = zend_hash_find_ptr(sdl->encoders, nscat.s)) != NULL) {
+ enc = enc_ptr;
if (enc->details.ns) {
efree(enc->details.ns);
}
enc->to_zval = sdl_guess_convert_zval;
if (enc_ptr == NULL) {
- zend_hash_update(sdl->encoders, nscat.c, nscat.len + 1, &enc, sizeof(encodePtr), NULL);
+ zend_hash_update_ptr(sdl->encoders, nscat.s, enc);
}
smart_str_free(&nscat);
return enc;
static void schema_load_file(sdlCtx *ctx, xmlAttrPtr ns, xmlChar *location, xmlAttrPtr tns, int import TSRMLS_DC) {
if (location != NULL &&
- !zend_hash_exists(&ctx->docs, (char*)location, xmlStrlen(location)+1)) {
+ !zend_hash_str_exists(&ctx->docs, (char*)location, xmlStrlen(location))) {
xmlDocPtr doc;
xmlNodePtr schema;
xmlAttrPtr new_tns;
soap_error1(E_ERROR, "Parsing Schema: can't include schema from '%s', different 'targetNamespace'", location);
}
}
- zend_hash_add(&ctx->docs, (char*)location, xmlStrlen(location)+1, (void**)&doc, sizeof(xmlDocPtr), NULL);
+ zend_hash_str_add_ptr(&ctx->docs, (char*)location, xmlStrlen(location), doc);
load_schema(ctx, schema TSRMLS_CC);
}
}
name = get_attribute(simpleType->properties, "name");
if (cur_type != NULL) {
/* Anonymous type inside <element> or <restriction> */
- sdlTypePtr newType, *ptr;
+ sdlTypePtr newType, ptr;
newType = emalloc(sizeof(sdlType));
memset(newType, 0, sizeof(sdlType));
newType->namens = estrdup(cur_type->namens);
}
- zend_hash_next_index_insert(sdl->types, &newType, sizeof(sdlTypePtr), (void **)&ptr);
+ ptr = zend_hash_next_index_insert_ptr(sdl->types, newType);
if (sdl->encoders == NULL) {
sdl->encoders = emalloc(sizeof(HashTable));
memset(cur_type->encode, 0, sizeof(encode));
cur_type->encode->details.ns = estrdup(newType->namens);
cur_type->encode->details.type_str = estrdup(newType->name);
- cur_type->encode->details.sdl_type = *ptr;
+ cur_type->encode->details.sdl_type = ptr;
cur_type->encode->to_xml = sdl_guess_convert_xml;
cur_type->encode->to_zval = sdl_guess_convert_zval;
- zend_hash_next_index_insert(sdl->encoders, &cur_type->encode, sizeof(encodePtr), NULL);
+ zend_hash_next_index_insert_ptr(sdl->encoders, cur_type->encode);
- cur_type =*ptr;
+ cur_type =ptr;
} else if (name != NULL) {
- sdlTypePtr newType, *ptr;
+ sdlTypePtr newType, ptr;
newType = emalloc(sizeof(sdlType));
memset(newType, 0, sizeof(sdlType));
newType->namens = estrdup((char*)ns->children->content);
if (cur_type == NULL) {
- zend_hash_next_index_insert(sdl->types, &newType, sizeof(sdlTypePtr), (void **)&ptr);
+ ptr = zend_hash_next_index_insert_ptr(sdl->types, newType);
} else {
if (cur_type->elements == NULL) {
cur_type->elements = emalloc(sizeof(HashTable));
zend_hash_init(cur_type->elements, 0, NULL, delete_type, 0);
}
- zend_hash_update(cur_type->elements, newType->name, strlen(newType->name)+1, &newType, sizeof(sdlTypePtr), (void **)&ptr);
+ ptr = zend_hash_str_update_ptr(cur_type->elements, newType->name, strlen(newType->name), newType);
}
- cur_type = (*ptr);
+ cur_type = ptr;
create_encoder(sdl, cur_type, ns->children->content, name->children->content);
} else {
parse_namespace(itemType->children->content, &type, &ns);
nsptr = xmlSearchNs(listType->doc, listType, BAD_CAST(ns));
if (nsptr != NULL) {
- sdlTypePtr newType, *tmp;
+ sdlTypePtr newType;
newType = emalloc(sizeof(sdlType));
memset(newType, 0, sizeof(sdlType));
cur_type->elements = emalloc(sizeof(HashTable));
zend_hash_init(cur_type->elements, 0, NULL, delete_type, 0);
}
- zend_hash_next_index_insert(cur_type->elements, &newType, sizeof(sdlTypePtr), (void **)&tmp);
+ zend_hash_next_index_insert_ptr(cur_type->elements, newType);
}
if (type) {efree(type);}
if (ns) {efree(ns);}
trav = trav->next;
}
if (trav != NULL && node_is_equal(trav,"simpleType")) {
- sdlTypePtr newType, *tmp;
+ sdlTypePtr newType;
if (itemType != NULL) {
soap_error0(E_ERROR, "Parsing Schema: element has both 'itemType' attribute and subtype");
smart_str_appendl(&anonymous, "anonymous", sizeof("anonymous")-1);
smart_str_append_long(&anonymous, zend_hash_num_elements(sdl->types));
smart_str_0(&anonymous);
- newType->name = anonymous.c;
+ // TODO: avoid reallocation ???
+ newType->name = estrndup(anonymous.s->val, anonymous.s->len);
+ smart_str_free(&anonymous);
}
newType->namens = estrdup((char*)tns->children->content);
cur_type->elements = emalloc(sizeof(HashTable));
zend_hash_init(cur_type->elements, 0, NULL, delete_type, 0);
}
- zend_hash_next_index_insert(cur_type->elements, &newType, sizeof(sdlTypePtr), (void **)&tmp);
+ zend_hash_next_index_insert_ptr(cur_type->elements, newType);
schema_simpleType(sdl, tns, trav, newType);
parse_namespace(BAD_CAST(start), &type, &ns);
nsptr = xmlSearchNs(unionType->doc, unionType, BAD_CAST(ns));
if (nsptr != NULL) {
- sdlTypePtr newType, *tmp;
+ sdlTypePtr newType;
newType = emalloc(sizeof(sdlType));
memset(newType, 0, sizeof(sdlType));
cur_type->elements = emalloc(sizeof(HashTable));
zend_hash_init(cur_type->elements, 0, NULL, delete_type, 0);
}
- zend_hash_next_index_insert(cur_type->elements, &newType, sizeof(sdlTypePtr), (void **)&tmp);
+ zend_hash_next_index_insert_ptr(cur_type->elements, newType);
}
if (type) {efree(type);}
if (ns) {efree(ns);}
}
while (trav != NULL) {
if (node_is_equal(trav,"simpleType")) {
- sdlTypePtr newType, *tmp;
+ sdlTypePtr newType;
newType = emalloc(sizeof(sdlType));
memset(newType, 0, sizeof(sdlType));
smart_str_appendl(&anonymous, "anonymous", sizeof("anonymous")-1);
smart_str_append_long(&anonymous, zend_hash_num_elements(sdl->types));
smart_str_0(&anonymous);
- newType->name = anonymous.c;
+ // TODO: avoid reallocation ???
+ newType->name = estrndup(anonymous.s->val, anonymous.s->len);
+ smart_str_free(&anonymous);
}
newType->namens = estrdup((char*)tns->children->content);
cur_type->elements = emalloc(sizeof(HashTable));
zend_hash_init(cur_type->elements, 0, NULL, delete_type, 0);
}
- zend_hash_next_index_insert(cur_type->elements, &newType, sizeof(sdlTypePtr), (void **)&tmp);
+ zend_hash_next_index_insert_ptr(cur_type->elements, newType);
schema_simpleType(sdl, tns, trav, newType);
cur_type->restrictions->enumeration = emalloc(sizeof(HashTable));
zend_hash_init(cur_type->restrictions->enumeration, 0, NULL, delete_restriction_var_char, 0);
}
- if (zend_hash_add(cur_type->restrictions->enumeration, enumval->value, strlen(enumval->value)+1, &enumval, sizeof(sdlRestrictionCharPtr), NULL) == FAILURE) {
- delete_restriction_var_char(&enumval);
+ if (zend_hash_str_add_ptr(cur_type->restrictions->enumeration, enumval->value, strlen(enumval->value), enumval) == NULL) {
+ delete_restriction_var_char_int(enumval);
}
} else {
break;
if (model == NULL) {
cur_type->model = newModel;
} else {
- zend_hash_next_index_insert(model->u.content,&newModel,sizeof(sdlContentModelPtr), NULL);
+ zend_hash_next_index_insert_ptr(model->u.content, newModel);
}
schema_min_max(all, newModel);
newModel = emalloc(sizeof(sdlContentModel));
newModel->kind = XSD_CONTENT_GROUP_REF;
- newModel->u.group_ref = estrdup(key.c);
+ newModel->u.group_ref = estrndup(key.s->val, key.s->len);
if (type) {efree(type);}
if (ns) {efree(ns);}
sdl->groups = emalloc(sizeof(HashTable));
zend_hash_init(sdl->groups, 0, NULL, delete_type, 0);
}
- if (zend_hash_add(sdl->groups, key.c, key.len+1, (void**)&newType, sizeof(sdlTypePtr), NULL) != SUCCESS) {
- soap_error1(E_ERROR, "Parsing Schema: group '%s' already defined", key.c);
+ if (zend_hash_add_ptr(sdl->groups, key.s, newType) == NULL) {
+ soap_error1(E_ERROR, "Parsing Schema: group '%s' already defined", key.s->val);
}
cur_type = newType;
if (model == NULL) {
cur_type->model = newModel;
} else {
- zend_hash_next_index_insert(model->u.content, &newModel, sizeof(sdlContentModelPtr), NULL);
+ zend_hash_next_index_insert_ptr(model->u.content, newModel);
}
} else {
soap_error0(E_ERROR, "Parsing Schema: group has no 'name' nor 'ref' attributes");
if (model == NULL) {
cur_type->model = newModel;
} else {
- zend_hash_next_index_insert(model->u.content,&newModel,sizeof(sdlContentModelPtr), NULL);
+ zend_hash_next_index_insert_ptr(model->u.content, newModel);
}
schema_min_max(choiceType, newModel);
if (model == NULL) {
cur_type->model = newModel;
} else {
- zend_hash_next_index_insert(model->u.content,&newModel,sizeof(sdlContentModelPtr), NULL);
+ zend_hash_next_index_insert_ptr(model->u.content, newModel);
}
schema_min_max(seqType, newModel);
schema_min_max(anyType, newModel);
- zend_hash_next_index_insert(model->u.content, &newModel, sizeof(sdlContentModelPtr), NULL);
+ zend_hash_next_index_insert_ptr(model->u.content, newModel);
}
return TRUE;
}
name = get_attribute(attrs, "name");
if (cur_type != NULL) {
/* Anonymous type inside <element> */
- sdlTypePtr newType, *ptr;
+ sdlTypePtr newType, ptr;
newType = emalloc(sizeof(sdlType));
memset(newType, 0, sizeof(sdlType));
newType->namens = estrdup(cur_type->namens);
}
- zend_hash_next_index_insert(sdl->types, &newType, sizeof(sdlTypePtr), (void **)&ptr);
+ ptr = zend_hash_next_index_insert_ptr(sdl->types, newType);
if (sdl->encoders == NULL) {
sdl->encoders = emalloc(sizeof(HashTable));
memset(cur_type->encode, 0, sizeof(encode));
cur_type->encode->details.ns = estrdup(newType->namens);
cur_type->encode->details.type_str = estrdup(newType->name);
- cur_type->encode->details.sdl_type = *ptr;
+ cur_type->encode->details.sdl_type = ptr;
cur_type->encode->to_xml = sdl_guess_convert_xml;
cur_type->encode->to_zval = sdl_guess_convert_zval;
- zend_hash_next_index_insert(sdl->encoders, &cur_type->encode, sizeof(encodePtr), NULL);
+ zend_hash_next_index_insert_ptr(sdl->encoders, cur_type->encode);
- cur_type =*ptr;
+ cur_type = ptr;
} else if (name) {
- sdlTypePtr newType, *ptr;
+ sdlTypePtr newType, ptr;
newType = emalloc(sizeof(sdlType));
memset(newType, 0, sizeof(sdlType));
newType->name = estrdup((char*)name->children->content);
newType->namens = estrdup((char*)ns->children->content);
- zend_hash_next_index_insert(sdl->types, &newType, sizeof(sdlTypePtr), (void **)&ptr);
+ ptr = zend_hash_next_index_insert_ptr(sdl->types, newType);
- cur_type = (*ptr);
+ cur_type = ptr;
create_encoder(sdl, cur_type, ns->children->content, name->children->content);
} else {
soap_error0(E_ERROR, "Parsing Schema: complexType has no 'name' attribute");
smart_str_0(&nscat);
if (type) {efree(type);}
if (ns) {efree(ns);}
- newType->ref = estrdup(nscat.c);
+ newType->ref = estrndup(nscat.s->val, nscat.s->len);
smart_str_free(&nscat);
} else {
newType->name = estrdup((char*)name->children->content);
}
smart_str_0(&key);
- if (zend_hash_add(addHash, key.c, key.len + 1, &newType, sizeof(sdlTypePtr), NULL) != SUCCESS) {
+ if (zend_hash_add_ptr(addHash, key.s, newType) == NULL) {
if (cur_type == NULL) {
- soap_error1(E_ERROR, "Parsing Schema: element '%s' already defined", key.c);
+ soap_error1(E_ERROR, "Parsing Schema: element '%s' already defined", key.s->val);
} else {
- zend_hash_next_index_insert(addHash, &newType, sizeof(sdlTypePtr), NULL);
+ zend_hash_next_index_insert_ptr(addHash, newType);
}
}
smart_str_free(&key);
schema_min_max(element, newModel);
- zend_hash_next_index_insert(model->u.content, &newModel, sizeof(sdlContentModelPtr), NULL);
+ zend_hash_next_index_insert_ptr(model->u.content, newModel);
}
cur_type = newType;
} else {
smart_str_appendc(&key, ':');
smart_str_appends(&key, attr_name);
smart_str_0(&key);
- newAttr->ref = estrdup(key.c);
+ newAttr->ref = estrndup(key.s->val, key.s->len);
if (attr_name) {efree(attr_name);}
if (ns) {efree(ns);}
} else {
addHash = cur_type->attributes;
}
- if (zend_hash_add(addHash, key.c, key.len + 1, &newAttr, sizeof(sdlAttributePtr), NULL) != SUCCESS) {
- soap_error1(E_ERROR, "Parsing Schema: attribute '%s' already defined", key.c);
+ if (zend_hash_add_ptr(addHash, key.s, newAttr) == NULL) {
+ soap_error1(E_ERROR, "Parsing Schema: attribute '%s' already defined", key.s->val);
}
smart_str_free(&key);
} else{
smart_str_appendc(&key2, ':');
smart_str_appends(&key2, (char*)attr->name);
smart_str_0(&key2);
- zend_hash_add(newAttr->extraAttributes, key2.c, key2.len + 1, &ext, sizeof(sdlExtraAttributePtr), NULL);
+ zend_hash_add_ptr(newAttr->extraAttributes, key2.s, ext);
smart_str_free(&key2);
}
}
if (trav != NULL) {
if (node_is_equal(trav,"simpleType")) {
sdlTypePtr dummy_type;
+ zval zv;
+
if (ref != NULL) {
soap_error0(E_ERROR, "Parsing Schema: attribute has both 'ref' attribute and subtype");
} else if (type != NULL) {
smart_str_appendl(&anonymous, "anonymous", sizeof("anonymous")-1);
smart_str_append_long(&anonymous, zend_hash_num_elements(sdl->types));
smart_str_0(&anonymous);
- dummy_type->name = anonymous.c;
+ // TODO: avoid reallocation ???
+ dummy_type->name = estrndup(anonymous.s->val, anonymous.s->len);
+ smart_str_free(&anonymous);
}
dummy_type->namens = estrdup((char*)tns->children->content);
schema_simpleType(sdl, tns, trav, dummy_type);
newAttr->encode = dummy_type->encode;
- delete_type(&dummy_type);
+ ZVAL_PTR(&zv, dummy_type);
+ delete_type(&zv);
trav = trav->next;
}
}
smart_str_appends(&key, newType->name);
smart_str_0(&key);
- if (zend_hash_add(ctx->attributeGroups, key.c, key.len + 1, &newType, sizeof(sdlTypePtr), NULL) != SUCCESS) {
- soap_error1(E_ERROR, "Parsing Schema: attributeGroup '%s' already defined", key.c);
+ if (zend_hash_add_ptr(ctx->attributeGroups, key.s, newType) == NULL) {
+ soap_error1(E_ERROR, "Parsing Schema: attributeGroup '%s' already defined", key.s->val);
}
cur_type = newType;
smart_str_free(&key);
smart_str_appendc(&key, ':');
smart_str_appends(&key, group_name);
smart_str_0(&key);
- newAttr->ref = estrdup(key.c);
+ newAttr->ref = estrndup(key.s->val, key.s->len);
if (group_name) {efree(group_name);}
if (ns) {efree(ns);}
smart_str_free(&key);
- zend_hash_next_index_insert(cur_type->attributes, &newAttr, sizeof(sdlAttributePtr), NULL);
+ zend_hash_next_index_insert_ptr(cur_type->attributes, newAttr);
cur_type = NULL;
}
} else{
return TRUE;
}
-static void copy_extra_attribute(void *attribute)
+static void copy_extra_attribute(zval *zv)
{
- sdlExtraAttributePtr *attr = (sdlExtraAttributePtr*)attribute;
sdlExtraAttributePtr new_attr;
new_attr = emalloc(sizeof(sdlExtraAttribute));
- memcpy(new_attr, *attr, sizeof(sdlExtraAttribute));
- *attr = new_attr;
+ memcpy(new_attr, Z_PTR_P(zv), sizeof(sdlExtraAttribute));
+ Z_PTR_P(zv) = new_attr;
if (new_attr->ns) {
new_attr->ns = estrdup(new_attr->ns);
}
static void* schema_find_by_ref(HashTable *ht, char *ref)
{
- void **tmp;
+ void *tmp;
- if (zend_hash_find(ht, ref, strlen(ref)+1, (void**)&tmp) == SUCCESS) {
+ if ((tmp = zend_hash_str_find_ptr(ht, ref, strlen(ref))) != NULL) {
return tmp;
} else {
ref = strrchr(ref, ':');
if (ref) {
- if (zend_hash_find(ht, ref, strlen(ref)+1, (void**)&tmp) == SUCCESS) {
+ if ((tmp = zend_hash_str_find_ptr(ht, ref, strlen(ref))) != NULL) {
return tmp;
}
}
static void schema_attribute_fixup(sdlCtx *ctx, sdlAttributePtr attr)
{
- sdlAttributePtr *tmp;
+ sdlAttributePtr tmp;
if (attr->ref != NULL) {
if (ctx->attributes != NULL) {
- tmp = (sdlAttributePtr*)schema_find_by_ref(ctx->attributes, attr->ref);
+ tmp = (sdlAttributePtr)schema_find_by_ref(ctx->attributes, attr->ref);
if (tmp) {
- schema_attribute_fixup(ctx, *tmp);
- if ((*tmp)->name != NULL && attr->name == NULL) {
- attr->name = estrdup((*tmp)->name);
+ schema_attribute_fixup(ctx, tmp);
+ if (tmp->name != NULL && attr->name == NULL) {
+ attr->name = estrdup(tmp->name);
}
- if ((*tmp)->namens != NULL && attr->namens == NULL) {
- attr->namens = estrdup((*tmp)->namens);
+ if (tmp->namens != NULL && attr->namens == NULL) {
+ attr->namens = estrdup(tmp->namens);
}
- if ((*tmp)->def != NULL && attr->def == NULL) {
- attr->def = estrdup((*tmp)->def);
+ if (tmp->def != NULL && attr->def == NULL) {
+ attr->def = estrdup(tmp->def);
}
- if ((*tmp)->fixed != NULL && attr->fixed == NULL) {
- attr->fixed = estrdup((*tmp)->fixed);
+ if (tmp->fixed != NULL && attr->fixed == NULL) {
+ attr->fixed = estrdup(tmp->fixed);
}
if (attr->form == XSD_FORM_DEFAULT) {
- attr->form = (*tmp)->form;
+ attr->form = tmp->form;
}
if (attr->use == XSD_USE_DEFAULT) {
- attr->use = (*tmp)->use;
+ attr->use = tmp->use;
}
- if ((*tmp)->extraAttributes != NULL) {
- xmlNodePtr node;
-
+ if (tmp->extraAttributes != NULL) {
attr->extraAttributes = emalloc(sizeof(HashTable));
- zend_hash_init(attr->extraAttributes, zend_hash_num_elements((*tmp)->extraAttributes), NULL, delete_extra_attribute, 0);
- zend_hash_copy(attr->extraAttributes, (*tmp)->extraAttributes, copy_extra_attribute, &node, sizeof(xmlNodePtr));
+ zend_hash_init(attr->extraAttributes, zend_hash_num_elements(tmp->extraAttributes), NULL, delete_extra_attribute, 0);
+ zend_hash_copy(attr->extraAttributes, tmp->extraAttributes, copy_extra_attribute);
}
- attr->encode = (*tmp)->encode;
+ attr->encode = tmp->encode;
}
}
if (attr->name == NULL && attr->ref != NULL) {
static void schema_attributegroup_fixup(sdlCtx *ctx, sdlAttributePtr attr, HashTable *ht)
{
- sdlTypePtr *tmp;
- sdlAttributePtr *tmp_attr;
+ sdlTypePtr tmp;
+ sdlAttributePtr tmp_attr;
if (attr->ref != NULL) {
if (ctx->attributeGroups != NULL) {
- tmp = (sdlTypePtr*)schema_find_by_ref(ctx->attributeGroups, attr->ref);
+ tmp = (sdlTypePtr)schema_find_by_ref(ctx->attributeGroups, attr->ref);
if (tmp) {
- if ((*tmp)->attributes) {
- zend_hash_internal_pointer_reset((*tmp)->attributes);
- while (zend_hash_get_current_data((*tmp)->attributes,(void**)&tmp_attr) == SUCCESS) {
- if (zend_hash_get_current_key_type((*tmp)->attributes) == HASH_KEY_IS_STRING) {
- char* key;
- uint key_len;
+ if (tmp->attributes) {
+ zend_hash_internal_pointer_reset(tmp->attributes);
+ while ((tmp_attr = zend_hash_get_current_data_ptr(tmp->attributes)) != NULL) {
+ if (zend_hash_get_current_key_type(tmp->attributes) == HASH_KEY_IS_STRING) {
+ zend_string* _key;
sdlAttributePtr newAttr;
- schema_attribute_fixup(ctx,*tmp_attr);
+ schema_attribute_fixup(ctx, tmp_attr);
newAttr = emalloc(sizeof(sdlAttribute));
- memcpy(newAttr, *tmp_attr, sizeof(sdlAttribute));
+ memcpy(newAttr, tmp_attr, sizeof(sdlAttribute));
if (newAttr->def) {newAttr->def = estrdup(newAttr->def);}
if (newAttr->fixed) {newAttr->fixed = estrdup(newAttr->fixed);}
if (newAttr->namens) {newAttr->namens = estrdup(newAttr->namens);}
if (newAttr->name) {newAttr->name = estrdup(newAttr->name);}
if (newAttr->extraAttributes) {
- xmlNodePtr node;
HashTable *ht = emalloc(sizeof(HashTable));
zend_hash_init(ht, zend_hash_num_elements(newAttr->extraAttributes), NULL, delete_extra_attribute, 0);
- zend_hash_copy(ht, newAttr->extraAttributes, copy_extra_attribute, &node, sizeof(xmlNodePtr));
+ zend_hash_copy(ht, newAttr->extraAttributes, copy_extra_attribute);
newAttr->extraAttributes = ht;
}
- zend_hash_get_current_key_ex((*tmp)->attributes, &key, &key_len, NULL, 0, NULL);
- zend_hash_add(ht, key, key_len, &newAttr, sizeof(sdlAttributePtr), NULL);
+ zend_hash_get_current_key_ex(tmp->attributes, &_key, NULL, 0, &tmp->attributes->nInternalPointer);
+ zend_hash_add_ptr(ht, _key, &newAttr);
- zend_hash_move_forward((*tmp)->attributes);
+ zend_hash_move_forward(tmp->attributes);
} else {
ulong index;
- schema_attributegroup_fixup(ctx,*tmp_attr, ht);
- zend_hash_get_current_key((*tmp)->attributes, NULL, &index, 0);
- zend_hash_index_del((*tmp)->attributes, index);
+ schema_attributegroup_fixup(ctx, tmp_attr, ht);
+ zend_hash_get_current_key(tmp->attributes, NULL, &index, 0);
+ zend_hash_index_del(tmp->attributes, index);
}
}
}
{
switch (model->kind) {
case XSD_CONTENT_GROUP_REF: {
- sdlTypePtr *tmp;
+ sdlTypePtr tmp;
- if (ctx->sdl->groups && zend_hash_find(ctx->sdl->groups, model->u.group_ref, strlen(model->u.group_ref)+1, (void**)&tmp) == SUCCESS) {
- schema_type_fixup(ctx,*tmp);
+ if (ctx->sdl->groups && (tmp = zend_hash_str_find_ptr(ctx->sdl->groups, model->u.group_ref, strlen(model->u.group_ref))) != NULL) {
+ schema_type_fixup(ctx, tmp);
efree(model->u.group_ref);
model->kind = XSD_CONTENT_GROUP;
- model->u.group = (*tmp);
+ model->u.group = tmp;
} else {
soap_error1(E_ERROR, "Parsing Schema: unresolved group 'ref' attribute '%s'", model->u.group_ref);
}
}
case XSD_CONTENT_CHOICE: {
if (model->max_occurs != 1) {
- HashPosition pos;
- sdlContentModelPtr *tmp;
-
- zend_hash_internal_pointer_reset_ex(model->u.content, &pos);
- while (zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos) == SUCCESS) {
- (*tmp)->min_occurs = 0;
- (*tmp)->max_occurs = model->max_occurs;
- zend_hash_move_forward_ex(model->u.content, &pos);
- }
+ sdlContentModelPtr tmp;
+
+ ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
+ tmp->min_occurs = 0;
+ tmp->max_occurs = model->max_occurs;
+ } ZEND_HASH_FOREACH_END();
model->kind = XSD_CONTENT_ALL;
model->min_occurs = 1;
}
case XSD_CONTENT_SEQUENCE:
case XSD_CONTENT_ALL: {
- sdlContentModelPtr *tmp;
+ sdlContentModelPtr tmp;
- zend_hash_internal_pointer_reset(model->u.content);
- while (zend_hash_get_current_data(model->u.content, (void**)&tmp) == SUCCESS) {
- schema_content_model_fixup(ctx, *tmp);
- zend_hash_move_forward(model->u.content);
- }
+ ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
+ schema_content_model_fixup(ctx, tmp);
+ } ZEND_HASH_FOREACH_END();
break;
}
default:
static void schema_type_fixup(sdlCtx *ctx, sdlTypePtr type)
{
- sdlTypePtr *tmp;
- sdlAttributePtr *attr;
+ sdlTypePtr tmp;
+ sdlAttributePtr attr;
if (type->ref != NULL) {
if (ctx->sdl->elements != NULL) {
- tmp = (sdlTypePtr*)schema_find_by_ref(ctx->sdl->elements, type->ref);
+ tmp = (sdlTypePtr)schema_find_by_ref(ctx->sdl->elements, type->ref);
if (tmp) {
- type->kind = (*tmp)->kind;
- type->encode = (*tmp)->encode;
- if ((*tmp)->nillable) {
+ type->kind = tmp->kind;
+ type->encode = tmp->encode;
+ if (tmp->nillable) {
type->nillable = 1;
}
- if ((*tmp)->fixed) {
- type->fixed = estrdup((*tmp)->fixed);
+ if (tmp->fixed) {
+ type->fixed = estrdup(tmp->fixed);
}
- if ((*tmp)->def) {
- type->def = estrdup((*tmp)->def);
+ if (tmp->def) {
+ type->def = estrdup(tmp->def);
}
- type->form = (*tmp)->form;
+ type->form = tmp->form;
} else if (strcmp(type->ref, SCHEMA_NAMESPACE ":schema") == 0) {
type->encode = get_conversion(XSD_ANYXML);
} else {
type->ref = NULL;
}
if (type->elements) {
- zend_hash_internal_pointer_reset(type->elements);
- while (zend_hash_get_current_data(type->elements,(void**)&tmp) == SUCCESS) {
- schema_type_fixup(ctx,*tmp);
- zend_hash_move_forward(type->elements);
- }
+ ZEND_HASH_FOREACH_PTR(type->elements, tmp) {
+ schema_type_fixup(ctx, tmp);
+ } ZEND_HASH_FOREACH_END();
}
if (type->model) {
schema_content_model_fixup(ctx, type->model);
}
if (type->attributes) {
- zend_hash_internal_pointer_reset(type->attributes);
- while (zend_hash_get_current_data(type->attributes,(void**)&attr) == SUCCESS) {
- if (zend_hash_get_current_key_type(type->attributes) == HASH_KEY_IS_STRING) {
- schema_attribute_fixup(ctx,*attr);
+ zend_string *str_key;
+ ulong index;
+
+ ZEND_HASH_FOREACH_KEY_PTR(type->attributes, index, str_key, attr) {
+ if (str_key) {
+ schema_attribute_fixup(ctx, attr);
zend_hash_move_forward(type->attributes);
} else {
- ulong index;
-
- schema_attributegroup_fixup(ctx,*attr,type->attributes);
- zend_hash_get_current_key(type->attributes, NULL, &index, 0);
+ schema_attributegroup_fixup(ctx, attr, type->attributes);
zend_hash_index_del(type->attributes, index);
}
- }
+ } ZEND_HASH_FOREACH_END();
}
}
void schema_pass2(sdlCtx *ctx)
{
sdlPtr sdl = ctx->sdl;
- sdlAttributePtr *attr;
- sdlTypePtr *type;
+ sdlAttributePtr attr;
+ sdlTypePtr type;
if (ctx->attributes) {
- zend_hash_internal_pointer_reset(ctx->attributes);
- while (zend_hash_get_current_data(ctx->attributes,(void**)&attr) == SUCCESS) {
- schema_attribute_fixup(ctx,*attr);
- zend_hash_move_forward(ctx->attributes);
- }
+ ZEND_HASH_FOREACH_PTR(ctx->attributes, attr) {
+ schema_attribute_fixup(ctx, attr);
+ } ZEND_HASH_FOREACH_END();
}
if (ctx->attributeGroups) {
- zend_hash_internal_pointer_reset(ctx->attributeGroups);
- while (zend_hash_get_current_data(ctx->attributeGroups,(void**)&type) == SUCCESS) {
- schema_type_fixup(ctx,*type);
- zend_hash_move_forward(ctx->attributeGroups);
- }
+ ZEND_HASH_FOREACH_PTR(ctx->attributeGroups, type) {
+ schema_type_fixup(ctx, type);
+ } ZEND_HASH_FOREACH_END();
}
if (sdl->elements) {
- zend_hash_internal_pointer_reset(sdl->elements);
- while (zend_hash_get_current_data(sdl->elements,(void**)&type) == SUCCESS) {
- schema_type_fixup(ctx,*type);
- zend_hash_move_forward(sdl->elements);
- }
+ ZEND_HASH_FOREACH_PTR(sdl->elements, type) {
+ schema_type_fixup(ctx, type);
+ } ZEND_HASH_FOREACH_END();
}
if (sdl->groups) {
- zend_hash_internal_pointer_reset(sdl->groups);
- while (zend_hash_get_current_data(sdl->groups,(void**)&type) == SUCCESS) {
- schema_type_fixup(ctx,*type);
- zend_hash_move_forward(sdl->groups);
- }
+ ZEND_HASH_FOREACH_PTR(sdl->groups, type) {
+ schema_type_fixup(ctx, type);
+ } ZEND_HASH_FOREACH_END();
}
if (sdl->types) {
- zend_hash_internal_pointer_reset(sdl->types);
- while (zend_hash_get_current_data(sdl->types,(void**)&type) == SUCCESS) {
- schema_type_fixup(ctx,*type);
- zend_hash_move_forward(sdl->types);
- }
+ ZEND_HASH_FOREACH_PTR(sdl->types, type) {
+ schema_type_fixup(ctx, type);
+ } ZEND_HASH_FOREACH_END();
}
if (ctx->attributes) {
zend_hash_destroy(ctx->attributes);
}
}
-void delete_model(void *handle)
+void delete_model(zval *zv)
{
- sdlContentModelPtr tmp = *((sdlContentModelPtr*)handle);
+ sdlContentModelPtr tmp = Z_PTR_P(zv);
switch (tmp->kind) {
case XSD_CONTENT_ELEMENT:
case XSD_CONTENT_GROUP:
efree(tmp);
}
-void delete_model_persistent(void *handle)
+static void delete_model_persistent_int(sdlContentModelPtr tmp)
{
- sdlContentModelPtr tmp = *((sdlContentModelPtr*)handle);
switch (tmp->kind) {
case XSD_CONTENT_ELEMENT:
case XSD_CONTENT_GROUP:
free(tmp);
}
-void delete_type(void *data)
+void delete_model_persistent(zval *zv)
+{
+ delete_model_persistent_int(Z_PTR_P(zv));
+}
+
+void delete_type(zval *zv)
{
- sdlTypePtr type = *((sdlTypePtr*)data);
+ sdlTypePtr type = Z_PTR_P(zv);
if (type->name) {
efree(type->name);
efree(type->attributes);
}
if (type->model) {
- delete_model((void**)&type->model);
+ zval zv;
+ ZVAL_PTR(&zv, type->model);
+ delete_model(&zv);
}
if (type->restrictions) {
- delete_restriction_var_int(&type->restrictions->minExclusive);
- delete_restriction_var_int(&type->restrictions->minInclusive);
- delete_restriction_var_int(&type->restrictions->maxExclusive);
- delete_restriction_var_int(&type->restrictions->maxInclusive);
- delete_restriction_var_int(&type->restrictions->totalDigits);
- delete_restriction_var_int(&type->restrictions->fractionDigits);
- delete_restriction_var_int(&type->restrictions->length);
- delete_restriction_var_int(&type->restrictions->minLength);
- delete_restriction_var_int(&type->restrictions->maxLength);
- delete_restriction_var_char(&type->restrictions->whiteSpace);
- delete_restriction_var_char(&type->restrictions->pattern);
+ delete_restriction_var_int(type->restrictions->minExclusive);
+ delete_restriction_var_int(type->restrictions->minInclusive);
+ delete_restriction_var_int(type->restrictions->maxExclusive);
+ delete_restriction_var_int(type->restrictions->maxInclusive);
+ delete_restriction_var_int(type->restrictions->totalDigits);
+ delete_restriction_var_int(type->restrictions->fractionDigits);
+ delete_restriction_var_int(type->restrictions->length);
+ delete_restriction_var_int(type->restrictions->minLength);
+ delete_restriction_var_int(type->restrictions->maxLength);
+ delete_restriction_var_char_int(type->restrictions->whiteSpace);
+ delete_restriction_var_char_int(type->restrictions->pattern);
if (type->restrictions->enumeration) {
zend_hash_destroy(type->restrictions->enumeration);
efree(type->restrictions->enumeration);
efree(type);
}
-void delete_type_persistent(void *data)
+void delete_type_persistent(zval *zv)
{
- sdlTypePtr type = *((sdlTypePtr*)data);
+ sdlTypePtr type = Z_PTR_P(zv);
if (type->name) {
free(type->name);
}
free(type->attributes);
}
if (type->model) {
- delete_model_persistent((void**)&type->model);
+ delete_model_persistent_int(type->model);
}
if (type->restrictions) {
- delete_restriction_var_int_persistent(&type->restrictions->minExclusive);
- delete_restriction_var_int_persistent(&type->restrictions->minInclusive);
- delete_restriction_var_int_persistent(&type->restrictions->maxExclusive);
- delete_restriction_var_int_persistent(&type->restrictions->maxInclusive);
- delete_restriction_var_int_persistent(&type->restrictions->totalDigits);
- delete_restriction_var_int_persistent(&type->restrictions->fractionDigits);
- delete_restriction_var_int_persistent(&type->restrictions->length);
- delete_restriction_var_int_persistent(&type->restrictions->minLength);
- delete_restriction_var_int_persistent(&type->restrictions->maxLength);
- delete_restriction_var_char_persistent(&type->restrictions->whiteSpace);
- delete_restriction_var_char_persistent(&type->restrictions->pattern);
+ delete_restriction_var_int_persistent(type->restrictions->minExclusive);
+ delete_restriction_var_int_persistent(type->restrictions->minInclusive);
+ delete_restriction_var_int_persistent(type->restrictions->maxExclusive);
+ delete_restriction_var_int_persistent(type->restrictions->maxInclusive);
+ delete_restriction_var_int_persistent(type->restrictions->totalDigits);
+ delete_restriction_var_int_persistent(type->restrictions->fractionDigits);
+ delete_restriction_var_int_persistent(type->restrictions->length);
+ delete_restriction_var_int_persistent(type->restrictions->minLength);
+ delete_restriction_var_int_persistent(type->restrictions->maxLength);
+ delete_restriction_var_char_persistent_int(type->restrictions->whiteSpace);
+ delete_restriction_var_char_persistent_int(type->restrictions->pattern);
if (type->restrictions->enumeration) {
zend_hash_destroy(type->restrictions->enumeration);
free(type->restrictions->enumeration);
free(type);
}
-void delete_extra_attribute(void *attribute)
+void delete_extra_attribute(zval *zv)
{
- sdlExtraAttributePtr attr = *((sdlExtraAttributePtr*)attribute);
+ sdlExtraAttributePtr attr = Z_PTR_P(zv);
if (attr->ns) {
efree(attr->ns);
efree(attr);
}
-void delete_extra_attribute_persistent(void *attribute)
+void delete_extra_attribute_persistent(zval *zv)
{
- sdlExtraAttributePtr attr = *((sdlExtraAttributePtr*)attribute);
+ sdlExtraAttributePtr attr = Z_PTR_P(zv);
if (attr->ns) {
free(attr->ns);
free(attr);
}
-void delete_attribute(void *attribute)
+void delete_attribute(zval *zv)
{
- sdlAttributePtr attr = *((sdlAttributePtr*)attribute);
+ sdlAttributePtr attr = Z_PTR_P(zv);
if (attr->def) {
efree(attr->def);
efree(attr);
}
-void delete_attribute_persistent(void *attribute)
+void delete_attribute_persistent(zval *zv)
{
- sdlAttributePtr attr = *((sdlAttributePtr*)attribute);
+ sdlAttributePtr attr = Z_PTR_P(zv);
if (attr->def) {
free(attr->def);
free(attr);
}
-void delete_restriction_var_int(void *rvi)
+void delete_restriction_var_int(sdlRestrictionIntPtr ptr)
{
- sdlRestrictionIntPtr ptr = *((sdlRestrictionIntPtr*)rvi);
if (ptr) {
efree(ptr);
}
}
-void delete_restriction_var_int_persistent(void *rvi)
+void delete_restriction_var_int_persistent(sdlRestrictionIntPtr ptr)
{
- sdlRestrictionIntPtr ptr = *((sdlRestrictionIntPtr*)rvi);
if (ptr) {
free(ptr);
}
}
-void delete_restriction_var_char(void *srvc)
+void delete_restriction_var_char_int(sdlRestrictionCharPtr ptr)
{
- sdlRestrictionCharPtr ptr = *((sdlRestrictionCharPtr*)srvc);
if (ptr) {
if (ptr->value) {
efree(ptr->value);
}
}
-void delete_restriction_var_char_persistent(void *srvc)
+void delete_restriction_var_char(zval *zv)
+{
+ delete_restriction_var_char_int(Z_PTR_P(zv));
+}
+
+void delete_restriction_var_char_persistent_int(sdlRestrictionCharPtr ptr)
{
- sdlRestrictionCharPtr ptr = *((sdlRestrictionCharPtr*)srvc);
if (ptr) {
if (ptr->value) {
free(ptr->value);
free(ptr);
}
}
+
+void delete_restriction_var_char_persistent(zval *zv)
+{
+ delete_restriction_var_char_persistent_int(Z_PTR_P(zv));
+}
int load_schema(sdlCtx *ctx, xmlNodePtr schema TSRMLS_DC);
void schema_pass2(sdlCtx *ctx);
-void delete_model(void *handle);
-void delete_model_persistent(void *handle);
-void delete_type(void *data);
-void delete_type_persistent(void *data);
-void delete_extra_attribute(void *attribute);
-void delete_extra_attribute_persistent(void *attribute);
-void delete_attribute(void *attribute);
-void delete_attribute_persistent(void *attribute);
-void delete_restriction_var_int(void *rvi);
-void delete_restriction_var_int_persistent(void *rvi);
-void delete_restriction_var_char(void *srvc);
-void delete_restriction_var_char_persistent(void *srvc);
+void delete_model(zval *zv);
+void delete_model_persistent(zval *zv);
+void delete_type(zval *zv);
+void delete_type_persistent(zval *zv);
+void delete_extra_attribute(zval *zv);
+void delete_extra_attribute_persistent(zval *zv);
+void delete_attribute(zval *zv);
+void delete_attribute_persistent(zval *zv);
+void delete_restriction_var_int(sdlRestrictionIntPtr ptr);
+void delete_restriction_var_int_persistent(sdlRestrictionIntPtr ptr);
+void delete_restriction_var_char(zval *zv);
+void delete_restriction_var_char_int(sdlRestrictionCharPtr ptr);
+void delete_restriction_var_char_persistent(zval *zv);
+void delete_restriction_var_char_persistent_int(sdlRestrictionCharPtr ptr);
#endif
# define O_BINARY 0
#endif
-static void delete_fault(void *fault);
-static void delete_fault_persistent(void *fault);
-static void delete_binding(void *binding);
-static void delete_binding_persistent(void *binding);
-static void delete_function(void *function);
-static void delete_function_persistent(void *function);
-static void delete_parameter(void *parameter);
-static void delete_parameter_persistent(void *parameter);
-static void delete_header(void *header);
-static void delete_header_persistent(void *header);
-static void delete_document(void *doc_ptr);
+static void delete_fault(zval *zv);
+static void delete_fault_persistent(zval *zv);
+static void delete_binding(zval *zv);
+static void delete_binding_persistent(zval *zv);
+static void delete_function(zval *zv);
+static void delete_function_persistent(zval *zv);
+static void delete_parameter(zval *zv);
+static void delete_parameter_persistent(zval *zv);
+static void delete_header(zval *header);
+static void delete_header_int(sdlSoapBindingFunctionHeaderPtr hdr);
+static void delete_header_persistent(zval *zv);
+static void delete_document(zval *zv);
encodePtr get_encoder_from_prefix(sdlPtr sdl, xmlNodePtr node, const xmlChar *type)
{
if (sdl->elements) {
xmlNsPtr nsptr;
char *ns, *cptype;
- sdlTypePtr *sdl_type;
+ sdlTypePtr sdl_type;
parse_namespace(type, &cptype, &ns);
nsptr = xmlSearchNs(node->doc, node, BAD_CAST(ns));
memcpy(nscat+ns_len+1, cptype, type_len);
nscat[len] = '\0';
- if (zend_hash_find(sdl->elements, nscat, len + 1, (void **)&sdl_type) == SUCCESS) {
- ret = *sdl_type;
- } else if (zend_hash_find(sdl->elements, (char*)type, type_len + 1, (void **)&sdl_type) == SUCCESS) {
- ret = *sdl_type;
+ if ((sdl_type = zend_hash_str_find_ptr(sdl->elements, nscat, len)) != NULL) {
+ ret = sdl_type;
+ } else if ((sdl_type = zend_hash_str_find_ptr(sdl->elements, (char*)type, type_len)) != NULL) {
+ ret = sdl_type;
}
efree(nscat);
} else {
- if (zend_hash_find(sdl->elements, (char*)type, xmlStrlen(type) + 1, (void **)&sdl_type) == SUCCESS) {
- ret = *sdl_type;
+ if ((sdl_type = zend_hash_str_find_ptr(sdl->elements, (char*)type, xmlStrlen(type))) != NULL) {
+ ret = sdl_type;
}
}
sdl->encoders = pemalloc(sizeof(HashTable), sdl->is_persistent);
zend_hash_init(sdl->encoders, 0, NULL, delete_encoder, sdl->is_persistent);
}
- zend_hash_update(sdl->encoders, nscat, len + 1, &new_enc, sizeof(encodePtr), NULL);
+ zend_hash_str_update_ptr(sdl->encoders, nscat, len, new_enc);
enc = new_enc;
}
}
encodePtr get_encoder_ex(sdlPtr sdl, const char *nscat, int len)
{
- encodePtr *enc;
+ encodePtr enc;
TSRMLS_FETCH();
- if (zend_hash_find(&SOAP_GLOBAL(defEnc), (char*)nscat, len + 1, (void **)&enc) == SUCCESS) {
- return (*enc);
- } else if (sdl && sdl->encoders && zend_hash_find(sdl->encoders, (char*)nscat, len + 1, (void **)&enc) == SUCCESS) {
- return (*enc);
+ if ((enc = zend_hash_str_find_ptr(&SOAP_GLOBAL(defEnc), (char*)nscat, len)) != NULL) {
+ return enc;
+ } else if (sdl && sdl->encoders && (enc = zend_hash_str_find_ptr(sdl->encoders, (char*)nscat, len)) != NULL) {
+ return enc;
}
return NULL;
}
sdlBindingPtr get_binding_from_type(sdlPtr sdl, int type)
{
- sdlBindingPtr *binding;
+ sdlBindingPtr binding;
if (sdl == NULL) {
return NULL;
}
- for (zend_hash_internal_pointer_reset(sdl->bindings);
- zend_hash_get_current_data(sdl->bindings, (void **) &binding) == SUCCESS;
- zend_hash_move_forward(sdl->bindings)) {
- if ((*binding)->bindingType == type) {
- return *binding;
+ ZEND_HASH_FOREACH_PTR(sdl->bindings, binding) {
+ if (binding->bindingType == type) {
+ return binding;
}
- }
+ } ZEND_HASH_FOREACH_END();
return NULL;
}
sdlBindingPtr get_binding_from_name(sdlPtr sdl, char *name, char *ns)
{
- sdlBindingPtr binding = NULL;
+ sdlBindingPtr binding;
smart_str key = {0};
smart_str_appends(&key, ns);
smart_str_appends(&key, name);
smart_str_0(&key);
- zend_hash_find(sdl->bindings, key.c, key.len, (void **)&binding);
+ binding = zend_hash_find_ptr(sdl->bindings, key.s);
smart_str_free(&key);
return binding;
{
char *s;
int l1, l2;
- zval *context = NULL;
- zval **header = NULL;
+ zval context;
+ zval *header = NULL;
/* check if we load xsd from the same server */
s = strstr(ctx->sdl->source, "://");
}
if (l1 != l2 || memcmp(ctx->sdl->source, uri, l1) != 0) {
/* another server. clear authentication credentals */
- context = php_libxml_switch_context(NULL TSRMLS_CC);
- php_libxml_switch_context(context TSRMLS_CC);
- if (context) {
- ctx->context = php_stream_context_from_zval(context, 1);
+ php_libxml_switch_context(NULL, &context TSRMLS_CC);
+ php_libxml_switch_context(&context, NULL TSRMLS_CC);
+ if (Z_TYPE(context) != IS_UNDEF) {
+ zval *context_ptr = &context;
+ ctx->context = php_stream_context_from_zval(context_ptr, 1);
if (ctx->context &&
- php_stream_context_get_option(ctx->context, "http", "header", &header) == SUCCESS) {
- s = strstr(Z_STRVAL_PP(header), "Authorization: Basic");
- if (s && (s == Z_STRVAL_PP(header) || *(s-1) == '\n' || *(s-1) == '\r')) {
+ (header = php_stream_context_get_option(ctx->context, "http", "header")) != NULL) {
+ s = strstr(Z_STRVAL_P(header), "Authorization: Basic");
+ if (s && (s == Z_STRVAL_P(header) || *(s-1) == '\n' || *(s-1) == '\r')) {
char *rest = strstr(s, "\r\n");
if (rest) {
zval new_header;
rest += 2;
- Z_TYPE(new_header) = IS_STRING;
- Z_STRLEN(new_header) = Z_STRLEN_PP(header) - (rest - s);
- Z_STRVAL(new_header) = emalloc(Z_STRLEN_PP(header) + 1);
- memcpy(Z_STRVAL(new_header), Z_STRVAL_PP(header), s - Z_STRVAL_PP(header));
- memcpy(Z_STRVAL(new_header) + (s - Z_STRVAL_PP(header)), rest, Z_STRLEN_PP(header) - (rest - Z_STRVAL_PP(header)) + 1);
- ctx->old_header = *header;
- Z_ADDREF_P(ctx->old_header);
+ ZVAL_STR(&new_header, STR_ALLOC(Z_STRLEN_P(header) - (rest - s), 0));
+ memcpy(Z_STRVAL(new_header), Z_STRVAL_P(header), s - Z_STRVAL_P(header));
+ memcpy(Z_STRVAL(new_header) + (s - Z_STRVAL_P(header)), rest, Z_STRLEN_P(header) - (rest - Z_STRVAL_P(header)) + 1);
+ ZVAL_COPY(&ctx->old_header, header);
php_stream_context_set_option(ctx->context, "http", "header", &new_header);
zval_dtor(&new_header);
}
void sdl_restore_uri_credentials(sdlCtx *ctx TSRMLS_DC)
{
- if (ctx->old_header) {
- php_stream_context_set_option(ctx->context, "http", "header", ctx->old_header);
+ if (Z_TYPE(ctx->old_header) != IS_UNDEF) {
+ php_stream_context_set_option(ctx->context, "http", "header", &ctx->old_header);
zval_ptr_dtor(&ctx->old_header);
- ctx->old_header = NULL;
+ ZVAL_UNDEF(&ctx->old_header);
}
ctx->context = NULL;
}
xmlNodePtr root, definitions, trav;
xmlAttrPtr targetNamespace;
- if (zend_hash_exists(&ctx->docs, struri, strlen(struri)+1)) {
+ if (zend_hash_str_exists(&ctx->docs, struri, strlen(struri))) {
return;
}
}
}
- zend_hash_add(&ctx->docs, struri, strlen(struri)+1, (void**)&wsdl, sizeof(xmlDocPtr), NULL);
+ zend_hash_str_add_ptr(&ctx->docs, struri, strlen(struri), wsdl);
root = wsdl->children;
definitions = get_node_ex(root, "definitions", WSDL_NAMESPACE);
} else if (node_is_equal(trav,"message")) {
xmlAttrPtr name = get_attribute(trav->properties, "name");
if (name && name->children && name->children->content) {
- if (zend_hash_add(&ctx->messages, (char*)name->children->content, xmlStrlen(name->children->content)+1,&trav, sizeof(xmlNodePtr), NULL) != SUCCESS) {
+ if (zend_hash_str_add_ptr(&ctx->messages, (char*)name->children->content, xmlStrlen(name->children->content), trav) == NULL) {
soap_error1(E_ERROR, "Parsing WSDL: <message> '%s' already defined", name->children->content);
}
} else {
} else if (node_is_equal(trav,"portType")) {
xmlAttrPtr name = get_attribute(trav->properties, "name");
if (name && name->children && name->children->content) {
- if (zend_hash_add(&ctx->portTypes, (char*)name->children->content, xmlStrlen(name->children->content)+1,&trav, sizeof(xmlNodePtr), NULL) != SUCCESS) {
+ if (zend_hash_str_add_ptr(&ctx->portTypes, (char*)name->children->content, xmlStrlen(name->children->content), trav) == NULL) {
soap_error1(E_ERROR, "Parsing WSDL: <portType> '%s' already defined", name->children->content);
}
} else {
} else if (node_is_equal(trav,"binding")) {
xmlAttrPtr name = get_attribute(trav->properties, "name");
if (name && name->children && name->children->content) {
- if (zend_hash_add(&ctx->bindings, (char*)name->children->content, xmlStrlen(name->children->content)+1,&trav, sizeof(xmlNodePtr), NULL) != SUCCESS) {
+ if (zend_hash_str_add_ptr(&ctx->bindings, (char*)name->children->content, xmlStrlen(name->children->content), trav) == NULL) {
soap_error1(E_ERROR, "Parsing WSDL: <binding> '%s' already defined", name->children->content);
}
} else {
} else if (node_is_equal(trav,"service")) {
xmlAttrPtr name = get_attribute(trav->properties, "name");
if (name && name->children && name->children->content) {
- if (zend_hash_add(&ctx->services, (char*)name->children->content, xmlStrlen(name->children->content)+1,&trav, sizeof(xmlNodePtr), NULL) != SUCCESS) {
+ if (zend_hash_str_add_ptr(&ctx->services, (char*)name->children->content, xmlStrlen(name->children->content), trav) == NULL) {
soap_error1(E_ERROR, "Parsing WSDL: <service> '%s' already defined", name->children->content);
}
} else {
} else {
++ctype;
}
- if (zend_hash_find(&ctx->messages, ctype, strlen(ctype)+1, (void**)&message) != SUCCESS) {
+ if ((message = zend_hash_str_find_ptr(&ctx->messages, ctype, strlen(ctype))) == NULL) {
soap_error1(E_ERROR, "Parsing WSDL: Missing <message> with name '%s'", tmp->children->content);
}
}
smart_str_appends(&key,hf->name);
smart_str_0(&key);
- if (zend_hash_add(h->headerfaults, key.c, key.len+1, (void**)&hf, sizeof(sdlSoapBindingFunctionHeaderPtr), NULL) != SUCCESS) {
- delete_header((void**)&hf);
+ if (zend_hash_add_ptr(h->headerfaults, key.s, hf) == NULL) {
+ delete_header_int(hf);
}
smart_str_free(&key);
} else if (is_wsdl_element(trav) && !node_is_equal(trav,"documentation")) {
/* Delete all parts those are not in the "parts" attribute */
zend_hash_init(&ht, 0, NULL, delete_parameter, 0);
while (*parts) {
- HashPosition pos;
- sdlParamPtr *param;
+ sdlParamPtr param;
int found = 0;
char *end;
if (*parts == '\0') break;
end = strchr(parts, ' ');
if (end) *end = '\0';
- zend_hash_internal_pointer_reset_ex(params, &pos);
- while (zend_hash_get_current_data_ex(params, (void **)¶m, &pos) != FAILURE) {
- if ((*param)->paramName &&
- strcmp(parts, (*param)->paramName) == 0) {
+ ZEND_HASH_FOREACH_PTR(params, param) {
+ if (param->paramName &&
+ strcmp(parts, param->paramName) == 0) {
sdlParamPtr x_param;
x_param = emalloc(sizeof(sdlParam));
- *x_param = **param;
- (*param)->paramName = NULL;
- zend_hash_next_index_insert(&ht, &x_param, sizeof(sdlParamPtr), NULL);
+ *x_param = *param;
+ param->paramName = NULL;
+ zend_hash_next_index_insert_ptr(&ht, x_param);
found = 1;
break;
}
- zend_hash_move_forward_ex(params, &pos);
- }
+ } ZEND_HASH_FOREACH_END();
if (!found) {
soap_error1(E_ERROR, "Parsing WSDL: Missing part '%s' in <message>", parts);
}
}
smart_str_appends(&key,h->name);
smart_str_0(&key);
- if (zend_hash_add(binding->headers, key.c, key.len+1, (void**)&h, sizeof(sdlSoapBindingFunctionHeaderPtr), NULL) != SUCCESS) {
- delete_header((void**)&h);
+ if (zend_hash_add_ptr(binding->headers, key.s, h) == NULL) {
+ delete_header_int(h);
}
smart_str_free(&key);
} else if (is_wsdl_element(trav) && !node_is_equal(trav,"documentation")) {
static HashTable* wsdl_message(sdlCtx *ctx, xmlChar* message_name)
{
- xmlNodePtr trav, part, message = NULL, *tmp;
+ xmlNodePtr trav, part, message = NULL, tmp;
HashTable* parameters = NULL;
char *ctype;
} else {
++ctype;
}
- if (zend_hash_find(&ctx->messages, ctype, strlen(ctype)+1, (void**)&tmp) != SUCCESS) {
+ if ((tmp = zend_hash_str_find_ptr(&ctx->messages, ctype, strlen(ctype))) == NULL) {
soap_error1(E_ERROR, "Parsing WSDL: Missing <message> with name '%s'", message_name);
}
- message = *tmp;
+ message = tmp;
parameters = emalloc(sizeof(HashTable));
zend_hash_init(parameters, 0, NULL, delete_parameter, 0);
}
}
- zend_hash_next_index_insert(parameters, ¶m, sizeof(sdlParamPtr), NULL);
+ zend_hash_next_index_insert_ptr(parameters, param);
trav = trav->next;
}
if (n > 0) {
zend_hash_internal_pointer_reset(&ctx.services);
for (i = 0; i < n; i++) {
- xmlNodePtr *tmp, service;
+ xmlNodePtr service, tmp;
xmlNodePtr trav, port;
int has_soap_port = 0;
- zend_hash_get_current_data(&ctx.services, (void **)&tmp);
- service = *tmp;
+ service = tmp = zend_hash_get_current_data_ptr(&ctx.services);
trav = service->children;
while (trav != NULL) {
} else {
++ctype;
}
- if (zend_hash_find(&ctx.bindings, ctype, strlen(ctype)+1, (void*)&tmp) != SUCCESS) {
+ if ((tmp = zend_hash_str_find_ptr(&ctx.bindings, ctype, strlen(ctype))) == NULL) {
soap_error1(E_ERROR, "Parsing WSDL: No <binding> element with name '%s'", ctype);
}
- binding = *tmp;
+ binding = tmp;
if (tmpbinding->bindingType == BINDING_SOAP) {
sdlSoapBindingPtr soapBinding;
} else {
++ctype;
}
- if (zend_hash_find(&ctx.portTypes, ctype, strlen(ctype)+1, (void**)&tmp) != SUCCESS) {
+ if ((tmp = zend_hash_str_find_ptr(&ctx.portTypes, ctype, strlen(ctype))) == NULL) {
soap_error1(E_ERROR, "Parsing WSDL: Missing <portType> with name '%s'", name->children->content);
}
- portType = *tmp;
+ portType = tmp;
trav2 = binding->children;
while (trav2 != NULL) {
function->faults = emalloc(sizeof(HashTable));
zend_hash_init(function->faults, 0, NULL, delete_fault, 0);
}
- if (zend_hash_add(function->faults, f->name, strlen(f->name)+1, (void**)&f, sizeof(sdlFaultPtr), NULL) != SUCCESS) {
+ if (zend_hash_str_add_ptr(function->faults, f->name, strlen(f->name), f) == NULL) {
soap_error2(E_ERROR, "Parsing WSDL: <fault> with name '%s' already defined in '%s'", f->name, op_name->children->content);
}
}
char *tmp = estrdup(function->functionName);
int len = strlen(tmp);
- if (zend_hash_add(&ctx.sdl->functions, php_strtolower(tmp, len), len+1, &function, sizeof(sdlFunctionPtr), NULL) != SUCCESS) {
- zend_hash_next_index_insert(&ctx.sdl->functions, &function, sizeof(sdlFunctionPtr), NULL);
+ if (zend_hash_str_add_ptr(&ctx.sdl->functions, php_strtolower(tmp, len), len, function) == NULL) {
+ zend_hash_next_index_insert_ptr(&ctx.sdl->functions, function);
}
efree(tmp);
if (function->requestName != NULL && strcmp(function->requestName,function->functionName) != 0) {
}
tmp = estrdup(function->requestName);
len = strlen(tmp);
- zend_hash_add(ctx.sdl->requests, php_strtolower(tmp, len), len+1, &function, sizeof(sdlFunctionPtr), NULL);
+ zend_hash_str_add_ptr(ctx.sdl->requests, php_strtolower(tmp, len), len, function);
efree(tmp);
}
}
zend_hash_init(ctx.sdl->bindings, 0, NULL, delete_binding, 0);
}
- zend_hash_add(ctx.sdl->bindings, tmpbinding->name, strlen(tmpbinding->name), &tmpbinding, sizeof(sdlBindingPtr), NULL);
+ zend_hash_str_add_ptr(ctx.sdl->bindings, tmpbinding->name, strlen(tmpbinding->name), tmpbinding);
trav= trav->next;
}
WSDL_CACHE_GET_INT(len, in);
if (len == 0) {
- zend_hash_next_index_insert(ht, &data, sizeof(void*), NULL);
+ zend_hash_next_index_insert_ptr(ht, data);
} else {
- zend_hash_add(ht, *in, len, &data, sizeof(void*), NULL);
+ zend_hash_str_add_ptr(ht, *in, len, data);
WSDL_CACHE_SKIP(len, in);
}
}
zend_hash_init(model->u.content, i, NULL, delete_model, 0);
while (i > 0) {
sdlContentModelPtr x = sdl_deserialize_model(types, elements, in);
- zend_hash_next_index_insert(model->u.content,&x,sizeof(sdlContentModelPtr),NULL);
+ zend_hash_next_index_insert_ptr(model->u.content, x);
i--;
}
break;
}
}
-static void sdl_serialize_key(HashTable *ht, smart_str *out)
+// TODO: refactor it
+static void sdl_serialize_key(zend_string *key, smart_str *out)
{
- char *key;
- uint key_len;
- ulong index;
-
- if (zend_hash_get_current_key_ex(ht, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
- WSDL_CACHE_PUT_INT(key_len, out);
- WSDL_CACHE_PUT_N(key, key_len, out);
+ if (key) {
+ WSDL_CACHE_PUT_INT(key->len, out);
+ WSDL_CACHE_PUT_N(key->val, key->len, out);
} else {
WSDL_CACHE_PUT_INT(0, out);
}
static void sdl_serialize_encoder_ref(encodePtr enc, HashTable *tmp_encoders, smart_str *out) {
if (enc) {
- int *encoder_num;
- if (zend_hash_find(tmp_encoders, (char*)&enc, sizeof(enc), (void**)&encoder_num) == SUCCESS) {
- WSDL_CACHE_PUT_INT(*encoder_num, out);
+ zval *encoder_num;
+ if ((encoder_num = zend_hash_str_find(tmp_encoders, (char*)&enc, sizeof(enc))) != 0) {
+ WSDL_CACHE_PUT_INT(Z_LVAL_P(encoder_num), out);
} else {
WSDL_CACHE_PUT_INT(0, out);
}
static void sdl_serialize_type_ref(sdlTypePtr type, HashTable *tmp_types, smart_str *out) {
if (type) {
- int *type_num;
- if (zend_hash_find(tmp_types, (char*)&type, sizeof(type), (void**)&type_num) == SUCCESS) {
- WSDL_CACHE_PUT_INT(*type_num, out);
+ zval *type_num;
+ if ((type_num = zend_hash_str_find(tmp_types, (char*)&type, sizeof(type))) != NULL) {
+ WSDL_CACHE_PUT_INT(Z_LVAL_P(type_num), out);
} else {
WSDL_CACHE_PUT_INT(0, out);
}
}
WSDL_CACHE_PUT_INT(i, out);
if (i > 0) {
- sdlExtraAttributePtr *tmp;
- zend_hash_internal_pointer_reset(attr->extraAttributes);
- while (zend_hash_get_current_data(attr->extraAttributes, (void**)&tmp) == SUCCESS) {
- sdl_serialize_key(attr->extraAttributes, out);
- sdl_serialize_string((*tmp)->ns, out);
- sdl_serialize_string((*tmp)->val, out);
- zend_hash_move_forward(attr->extraAttributes);
- }
+ sdlExtraAttributePtr tmp;
+ zend_string *key;
+
+ ZEND_HASH_FOREACH_STR_KEY_PTR(attr->extraAttributes, key, tmp) {
+ sdl_serialize_key(key, out);
+ sdl_serialize_string(tmp->ns, out);
+ sdl_serialize_string(tmp->val, out);
+ } ZEND_HASH_FOREACH_END();
}
}
case XSD_CONTENT_SEQUENCE:
case XSD_CONTENT_ALL:
case XSD_CONTENT_CHOICE: {
- sdlContentModelPtr *tmp;
+ sdlContentModelPtr tmp;
int i = zend_hash_num_elements(model->u.content);
WSDL_CACHE_PUT_INT(i, out);
- zend_hash_internal_pointer_reset(model->u.content);
- while (zend_hash_get_current_data(model->u.content, (void**)&tmp) == SUCCESS) {
- sdl_serialize_model(*tmp, tmp_types, tmp_elements, out);
- zend_hash_move_forward(model->u.content);
- }
+ ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
+ sdl_serialize_model(tmp, tmp_types, tmp_elements, out);
+ } ZEND_HASH_FOREACH_END();
}
break;
case XSD_CONTENT_GROUP_REF:
}
WSDL_CACHE_PUT_INT(i, out);
if (i > 0) {
- sdlRestrictionCharPtr *tmp;
+ sdlRestrictionCharPtr tmp;
+ zend_string *key;
- zend_hash_internal_pointer_reset(type->restrictions->enumeration);
- while (zend_hash_get_current_data(type->restrictions->enumeration, (void**)&tmp) == SUCCESS) {
- sdl_serialize_resriction_char(*tmp, out);
- sdl_serialize_key(type->restrictions->enumeration, out);
- zend_hash_move_forward(type->restrictions->enumeration);
- }
+ ZEND_HASH_FOREACH_STR_KEY_PTR(type->restrictions->enumeration, key, tmp) {
+ sdl_serialize_resriction_char(tmp, out);
+ sdl_serialize_key(key, out);
+ } ZEND_HASH_FOREACH_END();
}
} else {
WSDL_CACHE_PUT_1(0, out);
}
WSDL_CACHE_PUT_INT(i, out);
if (i > 0) {
- sdlTypePtr *tmp;
+ sdlTypePtr tmp;
+ zend_string *key;
+ zval zv;
tmp_elements = emalloc(sizeof(HashTable));
zend_hash_init(tmp_elements, i, NULL, NULL, 0);
- zend_hash_internal_pointer_reset(type->elements);
- while (zend_hash_get_current_data(type->elements, (void**)&tmp) == SUCCESS) {
- sdl_serialize_key(type->elements, out);
- sdl_serialize_type(*tmp, tmp_encoders, tmp_types, out);
- zend_hash_add(tmp_elements, (char*)tmp, sizeof(*tmp), &i, sizeof(int), NULL);
+ ZEND_HASH_FOREACH_STR_KEY_PTR(type->elements, key, tmp) {
+ sdl_serialize_key(key, out);
+ sdl_serialize_type(tmp, tmp_encoders, tmp_types, out);
+ ZVAL_LONG(&zv, i);
+ zend_hash_str_add(tmp_elements, (char*)&tmp, sizeof(tmp), &zv);
i--;
- zend_hash_move_forward(type->elements);
- }
+ } ZEND_HASH_FOREACH_END();
}
if (type->attributes) {
}
WSDL_CACHE_PUT_INT(i, out);
if (i > 0) {
- sdlAttributePtr *tmp;
- zend_hash_internal_pointer_reset(type->attributes);
- while (zend_hash_get_current_data(type->attributes, (void**)&tmp) == SUCCESS) {
- sdl_serialize_key(type->attributes, out);
- sdl_serialize_attribute(*tmp, tmp_encoders, out);
- zend_hash_move_forward(type->attributes);
- }
+ sdlAttributePtr tmp;
+ zend_string *key;
+
+ ZEND_HASH_FOREACH_STR_KEY_PTR(type->attributes, key, tmp) {
+ sdl_serialize_key(key, out);
+ sdl_serialize_attribute(tmp, tmp_encoders, out);
+ } ZEND_HASH_FOREACH_END();
}
if (type->model) {
WSDL_CACHE_PUT_1(1, out);
}
WSDL_CACHE_PUT_INT(i, out);
if (i > 0) {
- sdlParamPtr *tmp;
+ sdlParamPtr tmp;
+ zend_string *key;
- zend_hash_internal_pointer_reset(ht);
- while (zend_hash_get_current_data(ht, (void**)&tmp) == SUCCESS) {
- sdl_serialize_key(ht, out);
- sdl_serialize_string((*tmp)->paramName, out);
- WSDL_CACHE_PUT_INT((*tmp)->order, out);
- sdl_serialize_encoder_ref((*tmp)->encode, tmp_encoders, out);
- sdl_serialize_type_ref((*tmp)->element, tmp_types, out);
- zend_hash_move_forward(ht);
- }
+ ZEND_HASH_FOREACH_STR_KEY_PTR(ht, key, tmp) {
+ sdl_serialize_key(key, out);
+ sdl_serialize_string(tmp->paramName, out);
+ WSDL_CACHE_PUT_INT(tmp->order, out);
+ sdl_serialize_encoder_ref(tmp->encode, tmp_encoders, out);
+ sdl_serialize_type_ref(tmp->element, tmp_types, out);
+ } ZEND_HASH_FOREACH_END();
}
}
}
WSDL_CACHE_PUT_INT(i, out);
if (i > 0) {
- sdlSoapBindingFunctionHeaderPtr *tmp;
- zend_hash_internal_pointer_reset(body->headers);
- while (zend_hash_get_current_data(body->headers, (void**)&tmp) == SUCCESS) {
- sdl_serialize_key(body->headers, out);
- WSDL_CACHE_PUT_1((*tmp)->use, out);
- if ((*tmp)->use == SOAP_ENCODED) {
- WSDL_CACHE_PUT_1((*tmp)->encodingStyle, out);
- }
- sdl_serialize_string((*tmp)->name, out);
- sdl_serialize_string((*tmp)->ns, out);
- sdl_serialize_encoder_ref((*tmp)->encode, tmp_encoders, out);
- sdl_serialize_type_ref((*tmp)->element, tmp_types, out);
- if ((*tmp)->headerfaults) {
- j = zend_hash_num_elements((*tmp)->headerfaults);
+ sdlSoapBindingFunctionHeaderPtr tmp;
+ zend_string *key;
+
+ ZEND_HASH_FOREACH_STR_KEY_PTR(body->headers, key, tmp) {
+ sdl_serialize_key(key, out);
+ WSDL_CACHE_PUT_1(tmp->use, out);
+ if (tmp->use == SOAP_ENCODED) {
+ WSDL_CACHE_PUT_1(tmp->encodingStyle, out);
+ }
+ sdl_serialize_string(tmp->name, out);
+ sdl_serialize_string(tmp->ns, out);
+ sdl_serialize_encoder_ref(tmp->encode, tmp_encoders, out);
+ sdl_serialize_type_ref(tmp->element, tmp_types, out);
+ if (tmp->headerfaults) {
+ j = zend_hash_num_elements(tmp->headerfaults);
} else {
j = 0;
}
WSDL_CACHE_PUT_INT(j, out);
if (j > 0) {
- sdlSoapBindingFunctionHeaderPtr *tmp2;
- zend_hash_internal_pointer_reset((*tmp)->headerfaults);
- while (zend_hash_get_current_data((*tmp)->headerfaults, (void**)&tmp2) == SUCCESS) {
- sdl_serialize_key((*tmp)->headerfaults, out);
- WSDL_CACHE_PUT_1((*tmp2)->use, out);
- if ((*tmp2)->use == SOAP_ENCODED) {
- WSDL_CACHE_PUT_1((*tmp2)->encodingStyle, out);
+ sdlSoapBindingFunctionHeaderPtr tmp2;
+ zend_string *key;
+
+ ZEND_HASH_FOREACH_STR_KEY_PTR(body->headers, key, tmp2) {
+ sdl_serialize_key(key, out);
+ WSDL_CACHE_PUT_1(tmp2->use, out);
+ if (tmp2->use == SOAP_ENCODED) {
+ WSDL_CACHE_PUT_1(tmp2->encodingStyle, out);
}
- sdl_serialize_string((*tmp2)->name, out);
- sdl_serialize_string((*tmp2)->ns, out);
- sdl_serialize_encoder_ref((*tmp2)->encode, tmp_encoders, out);
- sdl_serialize_type_ref((*tmp2)->element, tmp_types, out);
- zend_hash_move_forward((*tmp)->headerfaults);
- }
+ sdl_serialize_string(tmp2->name, out);
+ sdl_serialize_string(tmp2->ns, out);
+ sdl_serialize_encoder_ref(tmp2->encode, tmp_encoders, out);
+ sdl_serialize_type_ref(tmp2->element, tmp_types, out);
+ } ZEND_HASH_FOREACH_END();
}
- zend_hash_move_forward(body->headers);
- }
+ } ZEND_HASH_FOREACH_END();
}
}
}
WSDL_CACHE_PUT_INT(i, out);
if (i > 0) {
- sdlTypePtr *tmp;
+ sdlTypePtr tmp;
+ zval zv;
- zend_hash_internal_pointer_reset(sdl->groups);
- while (zend_hash_get_current_data(sdl->groups, (void**)&tmp) == SUCCESS) {
- zend_hash_add(&tmp_types, (char*)tmp, sizeof(*tmp), (void**)&type_num, sizeof(type_num), NULL);
+ ZEND_HASH_FOREACH_PTR(sdl->groups, tmp) {
+ ZVAL_LONG(&zv, type_num);
+ zend_hash_str_add(&tmp_types, (char*)&tmp, sizeof(tmp), &zv);
++type_num;
- zend_hash_move_forward(sdl->groups);
- }
+ } ZEND_HASH_FOREACH_END();
}
if (sdl->types) {
}
WSDL_CACHE_PUT_INT(i, out);
if (i > 0) {
- sdlTypePtr *tmp;
+ sdlTypePtr tmp;
+ zval zv;
- zend_hash_internal_pointer_reset(sdl->types);
- while (zend_hash_get_current_data(sdl->types, (void**)&tmp) == SUCCESS) {
- zend_hash_add(&tmp_types, (char*)tmp, sizeof(*tmp), (void**)&type_num, sizeof(type_num), NULL);
+ ZEND_HASH_FOREACH_PTR(sdl->types, tmp) {
+ ZVAL_LONG(&zv, type_num);
+ zend_hash_str_add(&tmp_types, (char*)&tmp, sizeof(tmp), &zv);
++type_num;
- zend_hash_move_forward(sdl->types);
- }
+ } ZEND_HASH_FOREACH_END();
}
if (sdl->elements) {
}
WSDL_CACHE_PUT_INT(i, out);
if (i > 0) {
- sdlTypePtr *tmp;
+ sdlTypePtr tmp;
+ zval zv;
- zend_hash_internal_pointer_reset(sdl->elements);
- while (zend_hash_get_current_data(sdl->elements, (void**)&tmp) == SUCCESS) {
- zend_hash_add(&tmp_types, (char*)tmp, sizeof(*tmp), (void**)&type_num, sizeof(type_num), NULL);
+ ZEND_HASH_FOREACH_PTR(sdl->elements, tmp) {
+ ZVAL_LONG(&zv, type_num);
+ zend_hash_str_add(&tmp_types, (char*)&tmp, sizeof(tmp), &zv);
++type_num;
- zend_hash_move_forward(sdl->elements);
- }
+ } ZEND_HASH_FOREACH_END();
}
if (sdl->encoders) {
}
WSDL_CACHE_PUT_INT(i, out);
if (i > 0) {
- encodePtr *tmp;
+ encodePtr tmp;
+ zval zv;
- zend_hash_internal_pointer_reset(sdl->encoders);
- while (zend_hash_get_current_data(sdl->encoders, (void**)&tmp) == SUCCESS) {
- zend_hash_add(&tmp_encoders, (char*)tmp, sizeof(*tmp), (void**)&encoder_num, sizeof(encoder_num), NULL);
+ ZEND_HASH_FOREACH_PTR(sdl->encoders, tmp) {
+ ZVAL_LONG(&zv, encoder_num);
+ zend_hash_str_add(&tmp_encoders, (char*)&tmp, sizeof(tmp), &zv);
++encoder_num;
- zend_hash_move_forward(sdl->encoders);
- }
+ } ZEND_HASH_FOREACH_END();
}
enc = defaultEncoding;
while (enc->details.type != END_KNOWN_TYPES) {
- zend_hash_add(&tmp_encoders, (char*)&enc, sizeof(encodePtr), (void**)&encoder_num, sizeof(encoder_num), NULL);
+ zval zv;
+
+ ZVAL_LONG(&zv, encoder_num);
+ zend_hash_str_add(&tmp_encoders, (char*)&enc, sizeof(encodePtr), &zv);
enc++;
++encoder_num;
}
if (sdl->groups) {
- sdlTypePtr *tmp;
- zend_hash_internal_pointer_reset(sdl->groups);
- while (zend_hash_get_current_data(sdl->groups, (void**)&tmp) == SUCCESS) {
- sdl_serialize_key(sdl->groups, out);
- sdl_serialize_type(*tmp, &tmp_encoders, &tmp_types, out);
- zend_hash_move_forward(sdl->groups);
- }
+ sdlTypePtr tmp;
+ zend_string *key;
+
+ ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->groups, key, tmp) {
+ sdl_serialize_key(key, out);
+ sdl_serialize_type(tmp, &tmp_encoders, &tmp_types, out);
+ } ZEND_HASH_FOREACH_END();
}
if (sdl->types) {
- sdlTypePtr *tmp;
- zend_hash_internal_pointer_reset(sdl->types);
- while (zend_hash_get_current_data(sdl->types, (void**)&tmp) == SUCCESS) {
- sdl_serialize_key(sdl->types, out);
- sdl_serialize_type(*tmp, &tmp_encoders, &tmp_types, out);
- zend_hash_move_forward(sdl->types);
- }
+ sdlTypePtr tmp;
+ zend_string *key;
+
+ ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->types, key, tmp) {
+ sdl_serialize_key(key, out);
+ sdl_serialize_type(tmp, &tmp_encoders, &tmp_types, out);
+ } ZEND_HASH_FOREACH_END();
}
if (sdl->elements) {
- sdlTypePtr *tmp;
- zend_hash_internal_pointer_reset(sdl->elements);
- while (zend_hash_get_current_data(sdl->elements, (void**)&tmp) == SUCCESS) {
- sdl_serialize_key(sdl->elements, out);
- sdl_serialize_type(*tmp, &tmp_encoders, &tmp_types, out);
- zend_hash_move_forward(sdl->elements);
- }
+ sdlTypePtr tmp;
+ zend_string *key;
+
+ ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->elements, key, tmp) {
+ sdl_serialize_key(key, out);
+ sdl_serialize_type(tmp, &tmp_encoders, &tmp_types, out);
+ } ZEND_HASH_FOREACH_END();
}
if (sdl->encoders) {
- encodePtr *tmp;
- zend_hash_internal_pointer_reset(sdl->encoders);
- while (zend_hash_get_current_data(sdl->encoders, (void**)&tmp) == SUCCESS) {
- sdl_serialize_key(sdl->encoders, out);
- sdl_serialize_encoder(*tmp, &tmp_types, out);
- zend_hash_move_forward(sdl->encoders);
- }
+ encodePtr tmp;
+ zend_string *key;
+
+ ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->encoders, key, tmp) {
+ sdl_serialize_key(key, out);
+ sdl_serialize_encoder(tmp, &tmp_types, out);
+ } ZEND_HASH_FOREACH_END();
}
/* serialize bindings */
}
WSDL_CACHE_PUT_INT(i, out);
if (i > 0) {
- sdlBindingPtr *tmp;
+ sdlBindingPtr tmp;
int binding_num = 1;
-
- zend_hash_internal_pointer_reset(sdl->bindings);
- while (zend_hash_get_current_data(sdl->bindings, (void**)&tmp) == SUCCESS) {
- sdl_serialize_key(sdl->bindings, out);
- sdl_serialize_string((*tmp)->name, out);
- sdl_serialize_string((*tmp)->location, out);
- WSDL_CACHE_PUT_1((*tmp)->bindingType,out);
- if ((*tmp)->bindingType == BINDING_SOAP && (*tmp)->bindingAttributes != NULL) {
- sdlSoapBindingPtr binding = (sdlSoapBindingPtr)(*tmp)->bindingAttributes;
+ zval zv;
+ zend_string *key;
+
+ ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->bindings, key, tmp) {
+ sdl_serialize_key(key, out);
+ sdl_serialize_string(tmp->name, out);
+ sdl_serialize_string(tmp->location, out);
+ WSDL_CACHE_PUT_1(tmp->bindingType,out);
+ if (tmp->bindingType == BINDING_SOAP && tmp->bindingAttributes != NULL) {
+ sdlSoapBindingPtr binding = (sdlSoapBindingPtr)tmp->bindingAttributes;
WSDL_CACHE_PUT_1(binding->style, out);
WSDL_CACHE_PUT_1(binding->transport, out);
} else {
WSDL_CACHE_PUT_1(0,out);
}
- zend_hash_add(&tmp_bindings, (char*)tmp, sizeof(*tmp), (void**)&binding_num, sizeof(binding_num), NULL);
+ ZVAL_LONG(&zv, binding_num);
+ zend_hash_str_add(&tmp_bindings, (char*)&tmp, sizeof(tmp), &zv);
binding_num++;
- zend_hash_move_forward(sdl->bindings);
- }
+ } ZEND_HASH_FOREACH_END();
}
/* serialize functions */
i = zend_hash_num_elements(&sdl->functions);
WSDL_CACHE_PUT_INT(i, out);
if (i > 0) {
- sdlFunctionPtr *tmp;
- int *binding_num;
+ sdlFunctionPtr tmp;
+ zval *binding_num, zv;
int function_num = 1;
-
- zend_hash_internal_pointer_reset(&sdl->functions);
- while (zend_hash_get_current_data(&sdl->functions, (void**)&tmp) == SUCCESS) {
- sdl_serialize_key(&sdl->functions, out);
- sdl_serialize_string((*tmp)->functionName, out);
- sdl_serialize_string((*tmp)->requestName, out);
- sdl_serialize_string((*tmp)->responseName, out);
-
- if ((*tmp)->binding == NULL ||
- zend_hash_find(&tmp_bindings,(char*)&(*tmp)->binding,sizeof((*tmp)->binding), (void**)&binding_num) != SUCCESS) {
- }
- WSDL_CACHE_PUT_INT(*binding_num, out);
- if (*binding_num >= 0) {
- if ((*tmp)->binding->bindingType == BINDING_SOAP && (*tmp)->bindingAttributes != NULL) {
- sdlSoapBindingFunctionPtr binding = (sdlSoapBindingFunctionPtr)(*tmp)->bindingAttributes;
- WSDL_CACHE_PUT_1(binding->style, out);
- sdl_serialize_string(binding->soapAction, out);
- sdl_serialize_soap_body(&binding->input, &tmp_encoders, &tmp_types, out);
- sdl_serialize_soap_body(&binding->output, &tmp_encoders, &tmp_types, out);
- } else {
- WSDL_CACHE_PUT_1(0,out);
+ zend_string *key;
+
+ ZEND_HASH_FOREACH_STR_KEY_PTR(&sdl->functions, key, tmp) {
+ sdl_serialize_key(key, out);
+ sdl_serialize_string(tmp->functionName, out);
+ sdl_serialize_string(tmp->requestName, out);
+ sdl_serialize_string(tmp->responseName, out);
+
+ if (tmp->binding) {
+ binding_num = zend_hash_str_find(&tmp_bindings,(char*)&tmp->binding, sizeof(tmp->binding));
+ if (binding_num) {
+ WSDL_CACHE_PUT_INT(Z_LVAL_P(binding_num), out);
+ if (Z_LVAL_P(binding_num) >= 0) {
+ if (tmp->binding->bindingType == BINDING_SOAP && tmp->bindingAttributes != NULL) {
+ sdlSoapBindingFunctionPtr binding = (sdlSoapBindingFunctionPtr)tmp->bindingAttributes;
+ WSDL_CACHE_PUT_1(binding->style, out);
+ sdl_serialize_string(binding->soapAction, out);
+ sdl_serialize_soap_body(&binding->input, &tmp_encoders, &tmp_types, out);
+ sdl_serialize_soap_body(&binding->output, &tmp_encoders, &tmp_types, out);
+ } else {
+ WSDL_CACHE_PUT_1(0,out);
+ }
+ }
}
}
- sdl_serialize_parameters((*tmp)->requestParameters, &tmp_encoders, &tmp_types, out);
- sdl_serialize_parameters((*tmp)->responseParameters, &tmp_encoders, &tmp_types, out);
+ sdl_serialize_parameters(tmp->requestParameters, &tmp_encoders, &tmp_types, out);
+ sdl_serialize_parameters(tmp->responseParameters, &tmp_encoders, &tmp_types, out);
- if ((*tmp)->faults) {
- sdlFaultPtr *fault;
+ if (tmp->faults) {
+ sdlFaultPtr fault;
+ zend_string *key;
- WSDL_CACHE_PUT_INT(zend_hash_num_elements((*tmp)->faults), out);
+ WSDL_CACHE_PUT_INT(zend_hash_num_elements(tmp->faults), out);
- zend_hash_internal_pointer_reset((*tmp)->faults);
- while (zend_hash_get_current_data((*tmp)->faults, (void**)&fault) == SUCCESS) {
- sdl_serialize_key((*tmp)->faults, out);
- sdl_serialize_string((*fault)->name, out);
- sdl_serialize_parameters((*fault)->details, &tmp_encoders, &tmp_types, out);
- if ((*tmp)->binding->bindingType == BINDING_SOAP && (*fault)->bindingAttributes != NULL) {
- sdlSoapBindingFunctionFaultPtr binding = (sdlSoapBindingFunctionFaultPtr)(*fault)->bindingAttributes;
+ ZEND_HASH_FOREACH_STR_KEY_PTR(tmp->faults, key, fault) {
+ sdl_serialize_key(key, out);
+ sdl_serialize_string(fault->name, out);
+ sdl_serialize_parameters(fault->details, &tmp_encoders, &tmp_types, out);
+ if (tmp->binding->bindingType == BINDING_SOAP && fault->bindingAttributes != NULL) {
+ sdlSoapBindingFunctionFaultPtr binding = (sdlSoapBindingFunctionFaultPtr)fault->bindingAttributes;
WSDL_CACHE_PUT_1(binding->use, out);
if (binding->use == SOAP_ENCODED) {
WSDL_CACHE_PUT_1(binding->encodingStyle, out);
} else {
WSDL_CACHE_PUT_1(0, out);
}
- zend_hash_move_forward((*tmp)->faults);
- }
+ } ZEND_HASH_FOREACH_END();
} else {
WSDL_CACHE_PUT_INT(0, out);
}
- zend_hash_add(&tmp_functions, (char*)tmp, sizeof(*tmp), (void**)&function_num, sizeof(function_num), NULL);
+ ZVAL_LONG(&zv, function_num);
+ zend_hash_str_add(&tmp_functions, (char*)&tmp, sizeof(tmp), &zv);
function_num++;
- zend_hash_move_forward(&sdl->functions);
- }
+ } ZEND_HASH_FOREACH_END();
}
/* serialize requests */
}
WSDL_CACHE_PUT_INT(i, out);
if (i > 0) {
- sdlFunctionPtr *tmp;
- int *function_num;
+ sdlFunctionPtr tmp;
+ zval *function_num;
+ zend_string *key;
- zend_hash_internal_pointer_reset(sdl->requests);
- while (zend_hash_get_current_data(sdl->requests, (void**)&tmp) == SUCCESS) {
- if (zend_hash_find(&tmp_functions, (char*)tmp, sizeof(*tmp), (void**)&function_num) != SUCCESS) {
- }
- WSDL_CACHE_PUT_INT(*function_num, out);
- sdl_serialize_key(sdl->requests, out);
- zend_hash_move_forward(sdl->requests);
- }
+ ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->requests, key, tmp) {
+ function_num = zend_hash_str_find(&tmp_functions, (char*)&tmp, sizeof(tmp));
+ WSDL_CACHE_PUT_INT(Z_LVAL_P(function_num), out);
+ sdl_serialize_key(key, out);
+ } ZEND_HASH_FOREACH_END();
}
- php_ignore_value(write(f, buf.c, buf.len));
+ php_ignore_value(write(f, buf.s->val, buf.s->len));
close(f);
smart_str_free(&buf);
zend_hash_destroy(&tmp_functions);
}
-static void make_persistent_restriction_char(void *data)
+static void make_persistent_restriction_char_int(sdlRestrictionCharPtr *rest)
{
- sdlRestrictionCharPtr *rest = (sdlRestrictionCharPtr *)data;
sdlRestrictionCharPtr prest = NULL;
prest = malloc(sizeof(sdlRestrictionChar));
}
+static void make_persistent_restriction_char(zval *zv)
+{
+ make_persistent_restriction_char_int((sdlRestrictionCharPtr*)&Z_PTR_P(zv));
+}
+
+
static void make_persistent_sdl_type_ref(sdlTypePtr *type, HashTable *ptr_map, HashTable *bp_types)
{
- sdlTypePtr *tmp;
+ sdlTypePtr tmp;
- if (zend_hash_find(ptr_map, (char *)type, sizeof(sdlTypePtr), (void**)&tmp) == SUCCESS) {
- *type = *tmp;
+ if ((tmp = zend_hash_str_find_ptr(ptr_map, (char *)type, sizeof(sdlTypePtr))) != NULL) {
+ *type = tmp;
} else {
- zend_hash_next_index_insert(bp_types, (void*)&type, sizeof(sdlTypePtr*), NULL);
+ zend_hash_next_index_insert_ptr(bp_types, *type);
}
}
static void make_persistent_sdl_encoder_ref(encodePtr *enc, HashTable *ptr_map, HashTable *bp_encoders)
{
- encodePtr *tmp;
+ encodePtr tmp;
/* do not process defaultEncoding's here */
if ((*enc) >= defaultEncoding && (*enc) < defaultEncoding + numDefaultEncodings) {
return;
}
- if (zend_hash_find(ptr_map, (char *)enc, sizeof(encodePtr), (void**)&tmp) == SUCCESS) {
- *enc = *tmp;
+ if ((tmp = zend_hash_str_find_ptr(ptr_map, (char *)enc, sizeof(encodePtr))) != NULL) {
+ *enc = tmp;
} else {
- zend_hash_next_index_insert(bp_encoders, (void*)&enc, sizeof(encodePtr*), NULL);
+ zend_hash_next_index_insert_ptr(bp_encoders, *enc);
}
}
static HashTable* make_persistent_sdl_function_headers(HashTable *headers, HashTable *ptr_map)
{
HashTable *pheaders;
- sdlSoapBindingFunctionHeaderPtr *tmp, pheader;
- encodePtr *penc;
- sdlTypePtr *ptype;
- ulong index;
- char *key;
- uint key_len;
+ sdlSoapBindingFunctionHeaderPtr tmp, pheader;
+ encodePtr penc;
+ sdlTypePtr ptype;
+ zend_string *key;
pheaders = malloc(sizeof(HashTable));
zend_hash_init(pheaders, zend_hash_num_elements(headers), NULL, delete_header_persistent, 1);
- zend_hash_internal_pointer_reset(headers);
- while (zend_hash_get_current_data(headers, (void**)&tmp) == SUCCESS) {
+ ZEND_HASH_FOREACH_STR_KEY_PTR(headers, key, tmp) {
pheader = malloc(sizeof(sdlSoapBindingFunctionHeader));
memset(pheader, 0, sizeof(sdlSoapBindingFunctionHeader));
- *pheader = **tmp;
+ *pheader = *tmp;
if (pheader->name) {
pheader->name = strdup(pheader->name);
}
if (pheader->encode->details.sdl_type) {
- if (zend_hash_find(ptr_map, (char*)&pheader->encode, sizeof(encodePtr), (void**)&penc) == FAILURE) {
+ if ((penc = zend_hash_str_find_ptr(ptr_map, (char*)&pheader->encode, sizeof(encodePtr))) == NULL) {
assert(0);
}
- pheader->encode = *penc;
+ pheader->encode = penc;
}
if (pheader->element) {
- if (zend_hash_find(ptr_map, (char*)&pheader->element, sizeof(sdlTypePtr), (void**)&ptype) == FAILURE) {
+ if ((ptype = zend_hash_str_find_ptr(ptr_map, (char*)&pheader->element, sizeof(sdlTypePtr))) == NULL) {
assert(0);
}
- pheader->element = *ptype;
+ pheader->element = ptype;
}
if (pheader->headerfaults) {
pheader->headerfaults = make_persistent_sdl_function_headers(pheader->headerfaults, ptr_map);
}
- if (zend_hash_get_current_key_ex(headers, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
- zend_hash_add(pheaders, key, key_len, (void*)&pheader, sizeof(sdlSoapBindingFunctionHeaderPtr), NULL);
+ if (key) {
+ zend_hash_add_ptr(pheaders, key, pheader);
} else {
- zend_hash_next_index_insert(pheaders, (void*)&pheader, sizeof(sdlSoapBindingFunctionHeaderPtr), NULL);
+ zend_hash_next_index_insert_ptr(pheaders, pheader);
}
-
- zend_hash_move_forward(headers);
- }
+ } ZEND_HASH_FOREACH_END();
return pheaders;
}
static HashTable* make_persistent_sdl_parameters(HashTable *params, HashTable *ptr_map)
{
HashTable *pparams;
- sdlParamPtr *tmp, pparam;
- sdlTypePtr *ptype;
- encodePtr *penc;
- ulong index;
- char *key;
- uint key_len;
+ sdlParamPtr tmp, pparam;
+ sdlTypePtr ptype;
+ encodePtr penc;
+ zend_string *key;
pparams = malloc(sizeof(HashTable));
zend_hash_init(pparams, zend_hash_num_elements(params), NULL, delete_parameter_persistent, 1);
- zend_hash_internal_pointer_reset(params);
- while (zend_hash_get_current_data(params, (void**)&tmp) == SUCCESS) {
+ ZEND_HASH_FOREACH_STR_KEY_PTR(params, key, tmp) {
pparam = malloc(sizeof(sdlParam));
memset(pparam, 0, sizeof(sdlParam));
- *pparam = **tmp;
+ *pparam = *tmp;
if (pparam->paramName) {
pparam->paramName = strdup(pparam->paramName);
}
if (pparam->encode && pparam->encode->details.sdl_type) {
- if (zend_hash_find(ptr_map, (char*)&pparam->encode, sizeof(encodePtr), (void**)&penc) == FAILURE) {
+ if ((penc = zend_hash_str_find_ptr(ptr_map, (char*)&pparam->encode, sizeof(encodePtr))) == NULL) {
assert(0);
}
- pparam->encode = *penc;
+ pparam->encode = penc;
}
if (pparam->element) {
- if (zend_hash_find(ptr_map, (char*)&pparam->element, sizeof(sdlTypePtr), (void**)&ptype) == FAILURE) {
+ if ((ptype = zend_hash_str_find_ptr(ptr_map, (char*)&pparam->element, sizeof(sdlTypePtr))) == NULL) {
assert(0);
}
- pparam->element = *ptype;
+ pparam->element = ptype;
}
- if (zend_hash_get_current_key_ex(params, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
- zend_hash_add(pparams, key, key_len, (void*)&pparam, sizeof(sdlParamPtr), NULL);
+ if (key) {
+ zend_hash_add_ptr(pparams, key, pparam);
} else {
- zend_hash_next_index_insert(pparams, (void*)&pparam, sizeof(sdlParamPtr), NULL);
+ zend_hash_next_index_insert_ptr(pparams, pparam);
}
-
- zend_hash_move_forward(params);
- }
-
+ } ZEND_HASH_FOREACH_END();
return pparams;
}
static HashTable* make_persistent_sdl_function_faults(sdlFunctionPtr func, HashTable *faults, HashTable *ptr_map)
{
HashTable *pfaults;
- sdlFaultPtr *tmp, pfault;
- ulong index;
- char *key;
- uint key_len;
+ sdlFaultPtr tmp, pfault;
+ zend_string *key;
pfaults = malloc(sizeof(HashTable));
zend_hash_init(pfaults, zend_hash_num_elements(faults), NULL, delete_fault_persistent, 1);
- zend_hash_internal_pointer_reset(faults);
- while (zend_hash_get_current_data(faults, (void**)&tmp) == SUCCESS) {
+ ZEND_HASH_FOREACH_STR_KEY_PTR(faults, key, tmp) {
pfault = malloc(sizeof(sdlFault));
memset(pfault, 0, sizeof(sdlFault));
- *pfault = **tmp;
+ *pfault = *tmp;
if (pfault->name) {
pfault->name = strdup(pfault->name);
pfault->bindingAttributes = soap_binding;
}
- if (zend_hash_get_current_key_ex(faults, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
- zend_hash_add(pfaults, key, key_len, (void*)&pfault, sizeof(sdlParamPtr), NULL);
+ if (key) {
+ zend_hash_add_ptr(pfaults, key, pfault);
} else {
- zend_hash_next_index_insert(pfaults, (void*)&pfault, sizeof(sdlParamPtr), NULL);
+ zend_hash_next_index_insert_ptr(pfaults, pfault);
}
- zend_hash_move_forward(faults);
- }
-
+ } ZEND_HASH_FOREACH_END();
return pfaults;
}
static sdlAttributePtr make_persistent_sdl_attribute(sdlAttributePtr attr, HashTable *ptr_map, HashTable *bp_types, HashTable *bp_encoders)
{
sdlAttributePtr pattr;
- ulong index;
- char *key;
- uint key_len;
+ zend_string *key;
pattr = malloc(sizeof(sdlAttribute));
memset(pattr, 0, sizeof(sdlAttribute));
}
if (pattr->extraAttributes) {
- sdlExtraAttributePtr *tmp, pextra;
+ sdlExtraAttributePtr tmp, pextra;
pattr->extraAttributes = malloc(sizeof(HashTable));
zend_hash_init(pattr->extraAttributes, zend_hash_num_elements(attr->extraAttributes), NULL, delete_extra_attribute_persistent, 1);
- zend_hash_internal_pointer_reset(pattr->extraAttributes);
- while (zend_hash_get_current_data(attr->extraAttributes, (void**)&tmp) == SUCCESS) {
- if (zend_hash_get_current_key_ex(attr->extraAttributes, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
+ ZEND_HASH_FOREACH_STR_KEY_PTR(pattr->extraAttributes, key, tmp) {
+ if (key) {
pextra = malloc(sizeof(sdlExtraAttribute));
memset(pextra, 0, sizeof(sdlExtraAttribute));
- if ((*tmp)->ns) {
- pextra->ns = strdup((*tmp)->ns);
+ if (tmp->ns) {
+ pextra->ns = strdup(tmp->ns);
}
- if ((*tmp)->val) {
- pextra->val = strdup((*tmp)->val);
+ if (tmp->val) {
+ pextra->val = strdup(tmp->val);
}
- zend_hash_add(pattr->extraAttributes, key, key_len, (void*)&pextra, sizeof(sdlExtraAttributePtr), NULL);
+ zend_hash_add_ptr(pattr->extraAttributes, key, pextra);
}
-
- zend_hash_move_forward(attr->extraAttributes);
- }
+ } ZEND_HASH_FOREACH_END();
}
return pattr;
static sdlContentModelPtr make_persistent_sdl_model(sdlContentModelPtr model, HashTable *ptr_map, HashTable *bp_types, HashTable *bp_encoders)
{
sdlContentModelPtr pmodel;
- sdlContentModelPtr *tmp, pcontent;
+ sdlContentModelPtr tmp, pcontent;
pmodel = malloc(sizeof(sdlContentModel));
memset(pmodel, 0, sizeof(sdlContentModel));
pmodel->u.content = malloc(sizeof(HashTable));
zend_hash_init(pmodel->u.content, zend_hash_num_elements(model->u.content), NULL, delete_model_persistent, 1);
- zend_hash_internal_pointer_reset(model->u.content);
- while (zend_hash_get_current_data(model->u.content, (void**)&tmp) == SUCCESS) {
- pcontent = make_persistent_sdl_model(*tmp, ptr_map, bp_types, bp_encoders);
- zend_hash_next_index_insert(pmodel->u.content, (void*)&pcontent, sizeof(sdlContentModelPtr), NULL);
- zend_hash_move_forward(model->u.content);
- }
+ ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
+ pcontent = make_persistent_sdl_model(tmp, ptr_map, bp_types, bp_encoders);
+ zend_hash_next_index_insert_ptr(pmodel->u.content, pcontent);
+ } ZEND_HASH_FOREACH_END();
break;
case XSD_CONTENT_GROUP_REF:
static sdlTypePtr make_persistent_sdl_type(sdlTypePtr type, HashTable *ptr_map, HashTable *bp_types, HashTable *bp_encoders)
{
- ulong index;
- char *key;
- uint key_len;
+ zend_string *key;
sdlTypePtr ptype = NULL;
ptype = malloc(sizeof(sdlType));
make_persistent_restriction_int(&ptype->restrictions->maxLength);
}
if (ptype->restrictions->whiteSpace) {
- make_persistent_restriction_char(&ptype->restrictions->whiteSpace);
+ make_persistent_restriction_char_int(&ptype->restrictions->whiteSpace);
}
if (ptype->restrictions->pattern) {
- make_persistent_restriction_char(&ptype->restrictions->pattern);
+ make_persistent_restriction_char_int(&ptype->restrictions->pattern);
}
if (type->restrictions->enumeration) {
- sdlRestrictionCharPtr tmp;
-
ptype->restrictions->enumeration = malloc(sizeof(HashTable));
zend_hash_init(ptype->restrictions->enumeration, zend_hash_num_elements(type->restrictions->enumeration), NULL, delete_restriction_var_char_persistent, 1);
- zend_hash_copy(ptype->restrictions->enumeration, type->restrictions->enumeration, make_persistent_restriction_char, (void*)&tmp, sizeof(sdlRestrictionCharPtr));
+ zend_hash_copy(ptype->restrictions->enumeration, type->restrictions->enumeration, make_persistent_restriction_char);
}
}
if (ptype->elements) {
- sdlTypePtr *tmp, pelem;
+ sdlTypePtr tmp, pelem;
ptype->elements = malloc(sizeof(HashTable));
zend_hash_init(ptype->elements, zend_hash_num_elements(type->elements), NULL, delete_type_persistent, 1);
- zend_hash_internal_pointer_reset(type->elements);
- while (zend_hash_get_current_data(type->elements, (void **)&tmp) == SUCCESS) {
- pelem = make_persistent_sdl_type(*tmp, ptr_map, bp_types, bp_encoders);
- if (zend_hash_get_current_key_ex(type->elements, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
- zend_hash_add(ptype->elements, key, key_len, (void*)&pelem, sizeof(sdlTypePtr), NULL);
+ ZEND_HASH_FOREACH_STR_KEY_PTR(type->elements, key, tmp) {
+ pelem = make_persistent_sdl_type(tmp, ptr_map, bp_types, bp_encoders);
+ if (key) {
+ zend_hash_add_ptr(ptype->elements, key, pelem);
} else {
- zend_hash_next_index_insert(ptype->elements, (void*)&pelem, sizeof(sdlTypePtr), NULL);
+ zend_hash_next_index_insert_ptr(ptype->elements, pelem);
}
- zend_hash_add(ptr_map, (char*)tmp, sizeof(*tmp), (void*)&pelem, sizeof(sdlTypePtr), NULL);
- zend_hash_move_forward(type->elements);
- }
+ zend_hash_str_add_ptr(ptr_map, (char*)&tmp, sizeof(tmp), pelem);
+ } ZEND_HASH_FOREACH_END();
}
if (ptype->attributes) {
- sdlAttributePtr *tmp, pattr;
+ sdlAttributePtr tmp, pattr;
ptype->attributes = malloc(sizeof(HashTable));
zend_hash_init(ptype->attributes, zend_hash_num_elements(type->attributes), NULL, delete_attribute_persistent, 1);
- zend_hash_internal_pointer_reset(type->attributes);
- while (zend_hash_get_current_data(type->attributes, (void **)&tmp) == SUCCESS) {
- pattr = make_persistent_sdl_attribute(*tmp, ptr_map, bp_types, bp_encoders);
- if (zend_hash_get_current_key_ex(type->attributes, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
- zend_hash_add(ptype->attributes, key, key_len, (void*)&pattr, sizeof(sdlAttributePtr), NULL);
+ ZEND_HASH_FOREACH_STR_KEY_PTR(type->attributes, key, tmp) {
+ pattr = make_persistent_sdl_attribute(tmp, ptr_map, bp_types, bp_encoders);
+ if (key) {
+ zend_hash_add_ptr(ptype->attributes, key, pattr);
} else {
- zend_hash_next_index_insert(ptype->attributes, (void*)&pattr, sizeof(sdlAttributePtr), NULL);
+ zend_hash_next_index_insert_ptr(ptype->attributes, pattr);
}
- zend_hash_move_forward(type->attributes);
- }
+ } ZEND_HASH_FOREACH_END();
}
if (type->model) {
}
if (pfunc->binding) {
- sdlBindingPtr *tmp;
+ sdlBindingPtr tmp;
- if (zend_hash_find(ptr_map, (char*)&pfunc->binding, sizeof(pfunc->binding), (void**)&tmp) == FAILURE) {
+ if ((tmp = zend_hash_str_find_ptr(ptr_map, (char*)&pfunc->binding, sizeof(pfunc->binding))) == NULL) {
assert(0);
}
- pfunc->binding = *tmp;
+ pfunc->binding = tmp;
if (pfunc->binding->bindingType == BINDING_SOAP && pfunc->bindingAttributes) {
sdlSoapBindingFunctionPtr soap_binding;
sdlPtr psdl = NULL;
HashTable ptr_map;
HashTable bp_types, bp_encoders;
- ulong index;
- char *key;
- uint key_len;
+ zend_string *key;
zend_hash_init(&bp_types, 0, NULL, NULL, 0);
zend_hash_init(&bp_encoders, 0, NULL, NULL, 0);
}
if (sdl->groups) {
- sdlTypePtr *tmp;
+ sdlTypePtr tmp;
sdlTypePtr ptype;
psdl->groups = malloc(sizeof(HashTable));
zend_hash_init(psdl->groups, zend_hash_num_elements(sdl->groups), NULL, delete_type_persistent, 1);
- zend_hash_internal_pointer_reset(sdl->groups);
- while (zend_hash_get_current_data(sdl->groups, (void **)&tmp) == SUCCESS) {
- ptype = make_persistent_sdl_type(*tmp, &ptr_map, &bp_types, &bp_encoders);
- if (zend_hash_get_current_key_ex(sdl->groups, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
- zend_hash_add(psdl->groups, key, key_len, (void*)&ptype, sizeof(sdlTypePtr), NULL);
+ ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->groups, key, tmp) {
+ ptype = make_persistent_sdl_type(tmp, &ptr_map, &bp_types, &bp_encoders);
+ if (key) {
+ zend_hash_add_ptr(psdl->groups, key, ptype);
} else {
- zend_hash_next_index_insert(psdl->groups, (void*)&ptype, sizeof(sdlTypePtr), NULL);
+ zend_hash_next_index_insert_ptr(psdl->groups, ptype);
}
- zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&ptype, sizeof(sdlTypePtr), NULL);
- zend_hash_move_forward(sdl->groups);
- }
+ zend_hash_str_add_ptr(&ptr_map, (char*)&tmp, sizeof(tmp), ptype);
+ } ZEND_HASH_FOREACH_END();
}
if (sdl->types) {
- sdlTypePtr *tmp;
+ sdlTypePtr tmp;
sdlTypePtr ptype;
psdl->types = malloc(sizeof(HashTable));
zend_hash_init(psdl->types, zend_hash_num_elements(sdl->types), NULL, delete_type_persistent, 1);
- zend_hash_internal_pointer_reset(sdl->types);
- while (zend_hash_get_current_data(sdl->types, (void **)&tmp) == SUCCESS) {
- ptype = make_persistent_sdl_type(*tmp, &ptr_map, &bp_types, &bp_encoders);
- if (zend_hash_get_current_key_ex(sdl->types, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
- zend_hash_add(psdl->types, key, key_len, (void*)&ptype, sizeof(sdlTypePtr), NULL);
+ ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->types, key, tmp) {
+ ptype = make_persistent_sdl_type(tmp, &ptr_map, &bp_types, &bp_encoders);
+ if (key) {
+ zend_hash_add_ptr(psdl->types, key, ptype);
} else {
- zend_hash_next_index_insert(psdl->types, (void*)&ptype, sizeof(sdlTypePtr), NULL);
+ zend_hash_next_index_insert_ptr(psdl->types, ptype);
}
- zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&ptype, sizeof(sdlTypePtr), NULL);
- zend_hash_move_forward(sdl->types);
- }
+ zend_hash_str_add_ptr(&ptr_map, (char*)&tmp, sizeof(tmp), ptype);
+ } ZEND_HASH_FOREACH_END();
}
if (sdl->elements) {
- sdlTypePtr *tmp;
+ sdlTypePtr tmp;
sdlTypePtr ptype;
psdl->elements = malloc(sizeof(HashTable));
zend_hash_init(psdl->elements, zend_hash_num_elements(sdl->elements), NULL, delete_type_persistent, 1);
- zend_hash_internal_pointer_reset(sdl->elements);
- while (zend_hash_get_current_data(sdl->elements, (void **)&tmp) == SUCCESS) {
- ptype = make_persistent_sdl_type(*tmp, &ptr_map, &bp_types, &bp_encoders);
- if (zend_hash_get_current_key_ex(sdl->elements, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
- zend_hash_add(psdl->elements, key, key_len, (void*)&ptype, sizeof(sdlTypePtr), NULL);
+ ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->elements, key, tmp) {
+ ptype = make_persistent_sdl_type(tmp, &ptr_map, &bp_types, &bp_encoders);
+ if (key) {
+ zend_hash_add_ptr(psdl->elements, key, ptype);
} else {
- zend_hash_next_index_insert(psdl->elements, (void*)&ptype, sizeof(sdlTypePtr), NULL);
+ zend_hash_next_index_insert_ptr(psdl->elements, ptype);
}
- zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&ptype, sizeof(sdlTypePtr), NULL);
- zend_hash_move_forward(sdl->elements);
- }
+ zend_hash_str_add_ptr(&ptr_map, (char*)&tmp, sizeof(tmp), ptype);
+ } ZEND_HASH_FOREACH_END();
}
if (sdl->encoders) {
- encodePtr *tmp;
+ encodePtr tmp;
encodePtr penc;
psdl->encoders = malloc(sizeof(HashTable));
zend_hash_init(psdl->encoders, zend_hash_num_elements(sdl->encoders), NULL, delete_encoder_persistent, 1);
- zend_hash_internal_pointer_reset(sdl->encoders);
- while (zend_hash_get_current_data(sdl->encoders, (void **)&tmp) == SUCCESS) {
- penc = make_persistent_sdl_encoder(*tmp, &ptr_map, &bp_types, &bp_encoders);
- if (zend_hash_get_current_key_ex(sdl->encoders, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
- zend_hash_add(psdl->encoders, key, key_len, (void*)&penc, sizeof(encodePtr), NULL);
+ ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->encoders, key, tmp) {
+ penc = make_persistent_sdl_encoder(tmp, &ptr_map, &bp_types, &bp_encoders);
+ if (key) {
+ zend_hash_add_ptr(psdl->encoders, key, penc);
} else {
- zend_hash_next_index_insert(psdl->encoders, (void*)&penc, sizeof(encodePtr), NULL);
+ zend_hash_next_index_insert_ptr(psdl->encoders, penc);
}
- zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&penc, sizeof(encodePtr), NULL);
- zend_hash_move_forward(sdl->encoders);
- }
+ zend_hash_str_add_ptr(&ptr_map, (char*)&tmp, sizeof(tmp), penc);
+ } ZEND_HASH_FOREACH_END();
}
/* do backpatching here */
if (zend_hash_num_elements(&bp_types)) {
- sdlTypePtr **tmp, *ptype = NULL;
+ sdlTypePtr *tmp, ptype = NULL;
- zend_hash_internal_pointer_reset(&bp_types);
- while (zend_hash_get_current_data(&bp_types, (void**)&tmp) == SUCCESS) {
- if (zend_hash_find(&ptr_map, (char*)(*tmp), sizeof(**tmp), (void**)&ptype) == FAILURE) {
+ ZEND_HASH_FOREACH_PTR(&bp_types, tmp) {
+ if ((ptype = zend_hash_str_find_ptr(&ptr_map, (char*)tmp, sizeof(*tmp))) == NULL) {
assert(0);
}
- **tmp = *ptype;
- zend_hash_move_forward(&bp_types);
- }
+ *tmp = ptype;
+ } ZEND_HASH_FOREACH_END();
}
if (zend_hash_num_elements(&bp_encoders)) {
- encodePtr **tmp, *penc = NULL;
+ encodePtr *tmp, penc = NULL;
- zend_hash_internal_pointer_reset(&bp_encoders);
- while (zend_hash_get_current_data(&bp_encoders, (void**)&tmp) == SUCCESS) {
- if (zend_hash_find(&ptr_map, (char*)(*tmp), sizeof(**tmp), (void**)&penc) == FAILURE) {
+ ZEND_HASH_FOREACH_PTR(&bp_encoders, tmp) {
+ if ((penc = zend_hash_str_find_ptr(&ptr_map, (char*)tmp, sizeof(*tmp))) == NULL) {
assert(0);
}
- **tmp = *penc;
- zend_hash_move_forward(&bp_encoders);
- }
+ *tmp = penc;
+ } ZEND_HASH_FOREACH_END();
}
if (sdl->bindings) {
- sdlBindingPtr *tmp;
+ sdlBindingPtr tmp;
sdlBindingPtr pbind;
psdl->bindings = malloc(sizeof(HashTable));
zend_hash_init(psdl->bindings, zend_hash_num_elements(sdl->bindings), NULL, delete_binding_persistent, 1);
- zend_hash_internal_pointer_reset(sdl->bindings);
- while (zend_hash_get_current_data(sdl->bindings, (void **)&tmp) == SUCCESS) {
- pbind = make_persistent_sdl_binding(*tmp, &ptr_map);
- if (zend_hash_get_current_key_ex(sdl->bindings, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
- zend_hash_add(psdl->bindings, key, key_len, (void*)&pbind, sizeof(sdlBindingPtr), NULL);
+ ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->bindings, key, tmp) {
+ pbind = make_persistent_sdl_binding(tmp, &ptr_map);
+ if (key) {
+ zend_hash_add_ptr(psdl->bindings, key, pbind);
} else {
- zend_hash_next_index_insert(psdl->bindings, (void*)&pbind, sizeof(sdlBindingPtr), NULL);
+ zend_hash_next_index_insert_ptr(psdl->bindings, pbind);
}
- zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&pbind, sizeof(sdlBindingPtr), NULL);
- zend_hash_move_forward(sdl->bindings);
- }
+ zend_hash_str_add_ptr(&ptr_map, (char*)&tmp, sizeof(tmp), pbind);
+ } ZEND_HASH_FOREACH_END();
}
zend_hash_init(&psdl->functions, zend_hash_num_elements(&sdl->functions), NULL, delete_function_persistent, 1);
if (zend_hash_num_elements(&sdl->functions)) {
- sdlFunctionPtr *tmp;
+ sdlFunctionPtr tmp;
sdlFunctionPtr pfunc;
- zend_hash_internal_pointer_reset(&sdl->functions);
- while (zend_hash_get_current_data(&sdl->functions, (void **)&tmp) == SUCCESS) {
- pfunc = make_persistent_sdl_function(*tmp, &ptr_map);
- if (zend_hash_get_current_key_ex(&sdl->functions, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
- zend_hash_add(&psdl->functions, key, key_len, (void*)&pfunc, sizeof(sdlFunctionPtr), NULL);
+ ZEND_HASH_FOREACH_STR_KEY_PTR(&sdl->functions, key, tmp) {
+ pfunc = make_persistent_sdl_function(tmp, &ptr_map);
+ if (key) {
+ zend_hash_add_ptr(&psdl->functions, key, pfunc);
} else {
- zend_hash_next_index_insert(&psdl->functions, (void*)&pfunc, sizeof(sdlFunctionPtr), NULL);
+ zend_hash_next_index_insert_ptr(&psdl->functions, pfunc);
}
- zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&pfunc, sizeof(sdlFunctionPtr), NULL);
- zend_hash_move_forward(&sdl->functions);
- }
+ zend_hash_str_add_ptr(&ptr_map, (char*)&tmp, sizeof(tmp), pfunc);
+ } ZEND_HASH_FOREACH_END();
}
if (sdl->requests) {
- sdlFunctionPtr *tmp;
- sdlFunctionPtr *preq;
+ zval *zv;
+ sdlFunctionPtr tmp;
+ sdlFunctionPtr preq;
psdl->requests = malloc(sizeof(HashTable));
zend_hash_init(psdl->requests, zend_hash_num_elements(sdl->requests), NULL, NULL, 1);
- zend_hash_internal_pointer_reset(sdl->requests);
- while (zend_hash_get_current_data(sdl->requests, (void **)&tmp) == SUCCESS) {
- if (zend_hash_find(&ptr_map, (char*)tmp, sizeof(*tmp), (void**)&preq) == FAILURE) {
+ ZEND_HASH_FOREACH_STR_KEY_VAL(sdl->requests, key, zv) {
+ tmp = Z_PTR_P(zv);
+ if ((preq = zend_hash_str_find_ptr(&ptr_map, (char*)&tmp, sizeof(tmp))) == NULL) {
assert(0);
}
- *tmp = *preq;
- if (zend_hash_get_current_key_ex(sdl->requests, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
- zend_hash_add(psdl->requests, key, key_len, (void*)&preq, sizeof(sdlFunctionPtr), NULL);
+ //???
+ Z_PTR_P(zv) = preq;
+ if (key) {
+ zend_hash_add_ptr(psdl->requests, key, preq);
}
- zend_hash_move_forward(sdl->requests);
- }
+ } ZEND_HASH_FOREACH_END();
}
zend_hash_destroy(&ptr_map);
time_t time;
} sdl_cache_bucket;
-static void delete_psdl(void *data)
+static void delete_psdl_int(sdl_cache_bucket *p)
{
- sdl_cache_bucket *p = (sdl_cache_bucket*)data;
sdlPtr tmp = p->sdl;
zend_hash_destroy(&tmp->functions);
free(tmp);
}
+static void delete_psdl(zval *zv)
+{
+ delete_psdl_int(Z_PTR_P(zv));
+}
+
sdlPtr get_sdl(zval *this_ptr, char *uri, long cache_wsdl TSRMLS_DC)
{
char fn[MAXPATHLEN];
char* old_error_code = SOAP_GLOBAL(error_code);
int uri_len = 0;
php_stream_context *context=NULL;
- zval **tmp, **proxy_host, **proxy_port, *orig_context = NULL, *new_context = NULL;
+ zval *tmp, *proxy_host, *proxy_port, orig_context, new_context;
smart_str headers = {0};
char* key = NULL;
time_t t = time(0);
zend_bool has_proxy_authorization = 0;
zend_bool has_authorization = 0;
+ ZVAL_UNDEF(&orig_context);
+ ZVAL_UNDEF(&new_context);
if (strchr(uri,':') != NULL || IS_ABSOLUTE_PATH(uri, uri_len)) {
uri_len = strlen(uri);
} else if (VCWD_REALPATH(uri, fn) == NULL) {
if ((cache_wsdl & WSDL_CACHE_MEMORY) && SOAP_GLOBAL(mem_cache)) {
sdl_cache_bucket *p;
- if (SUCCESS == zend_hash_find(SOAP_GLOBAL(mem_cache), uri, uri_len+1, (void*)&p)) {
+ if (NULL != (p = zend_hash_str_find_ptr(SOAP_GLOBAL(mem_cache), uri, uri_len))) {
if (p->time < t - SOAP_GLOBAL(cache_ttl)) {
/* in-memory cache entry is expired */
- zend_hash_del(&EG(persistent_list), uri, uri_len+1);
+ zend_hash_str_del(&EG(persistent_list), uri, uri_len);
} else {
return p->sdl;
}
}
}
- if (SUCCESS == zend_hash_find(Z_OBJPROP_P(this_ptr),
- "_stream_context", sizeof("_stream_context"), (void**)&tmp)) {
- context = php_stream_context_from_zval(*tmp, 0);
+ if (NULL != (tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr),
+ "_stream_context", sizeof("_stream_context")-1))) {
+ context = php_stream_context_from_zval(tmp, 0);
} else {
context = php_stream_context_alloc(TSRMLS_C);
}
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_user_agent", sizeof("_user_agent"), (void **) &tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING && Z_STRLEN_PP(tmp) > 0) {
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_user_agent", sizeof("_user_agent")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING && Z_STRLEN_P(tmp) > 0) {
smart_str_appends(&headers, "User-Agent: ");
- smart_str_appends(&headers, Z_STRVAL_PP(tmp));
+ smart_str_appends(&headers, Z_STRVAL_P(tmp));
smart_str_appends(&headers, "\r\n");
}
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_proxy_host", sizeof("_proxy_host"), (void **) &proxy_host) == SUCCESS &&
- Z_TYPE_PP(proxy_host) == IS_STRING &&
- zend_hash_find(Z_OBJPROP_P(this_ptr), "_proxy_port", sizeof("_proxy_port"), (void **) &proxy_port) == SUCCESS &&
- Z_TYPE_PP(proxy_port) == IS_LONG) {
- zval str_port, *str_proxy;
+ if ((proxy_host = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_proxy_host", sizeof("_proxy_host")-1)) != NULL &&
+ Z_TYPE_P(proxy_host) == IS_STRING &&
+ (proxy_port = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_proxy_port", sizeof("_proxy_port")-1)) != NULL &&
+ Z_TYPE_P(proxy_port) == IS_LONG) {
+ zval str_port, str_proxy;
smart_str proxy = {0};
- str_port = **proxy_port;
- zval_copy_ctor(&str_port);
+ ZVAL_DUP(&str_port, proxy_port);
convert_to_string(&str_port);
smart_str_appends(&proxy,"tcp://");
- smart_str_appends(&proxy,Z_STRVAL_PP(proxy_host));
+ smart_str_appends(&proxy,Z_STRVAL_P(proxy_host));
smart_str_appends(&proxy,":");
smart_str_appends(&proxy,Z_STRVAL(str_port));
smart_str_0(&proxy);
zval_dtor(&str_port);
- MAKE_STD_ZVAL(str_proxy);
- ZVAL_STRING(str_proxy, proxy.c, 1);
+ ZVAL_STR(&str_proxy, STR_COPY(proxy.s));
smart_str_free(&proxy);
if (!context) {
context = php_stream_context_alloc(TSRMLS_C);
}
- php_stream_context_set_option(context, "http", "proxy", str_proxy);
+ php_stream_context_set_option(context, "http", "proxy", &str_proxy);
zval_ptr_dtor(&str_proxy);
if (uri_len < sizeof("https://")-1 ||
strncasecmp(uri, "https://", sizeof("https://")-1) != 0) {
- MAKE_STD_ZVAL(str_proxy);
- ZVAL_BOOL(str_proxy, 1);
- php_stream_context_set_option(context, "http", "request_fulluri", str_proxy);
- zval_ptr_dtor(&str_proxy);
+ ZVAL_TRUE(&str_proxy);
+ php_stream_context_set_option(context, "http", "request_fulluri", &str_proxy);
}
has_proxy_authorization = proxy_authentication(this_ptr, &headers TSRMLS_CC);
has_authorization = basic_authentication(this_ptr, &headers TSRMLS_CC);
/* Use HTTP/1.1 with "Connection: close" by default */
- if (php_stream_context_get_option(context, "http", "protocol_version", &tmp) == FAILURE) {
- zval *http_version;
- MAKE_STD_ZVAL(http_version);
- ZVAL_DOUBLE(http_version, 1.1);
- php_stream_context_set_option(context, "http", "protocol_version", http_version);
- zval_ptr_dtor(&http_version);
+ if ((tmp = php_stream_context_get_option(context, "http", "protocol_version")) == NULL) {
+ zval http_version;
+
+ ZVAL_DOUBLE(&http_version, 1.1);
+ php_stream_context_set_option(context, "http", "protocol_version", &http_version);
smart_str_appendl(&headers, "Connection: close\r\n", sizeof("Connection: close\r\n")-1);
}
- if (headers.len > 0) {
- zval *str_headers;
+ if (headers.s && headers.s->len > 0) {
+ zval str_headers;
if (!context) {
context = php_stream_context_alloc(TSRMLS_C);
}
smart_str_0(&headers);
- MAKE_STD_ZVAL(str_headers);
- ZVAL_STRING(str_headers, headers.c, 1);
- php_stream_context_set_option(context, "http", "header", str_headers);
+ ZVAL_STR(&str_headers, STR_COPY(headers.s));
+ php_stream_context_set_option(context, "http", "header", &str_headers);
smart_str_free(&headers);
zval_ptr_dtor(&str_headers);
}
if (context) {
- MAKE_STD_ZVAL(new_context);
- php_stream_context_to_zval(context, new_context);
- orig_context = php_libxml_switch_context(new_context TSRMLS_CC);
+ php_stream_context_to_zval(context, &new_context);
+ php_libxml_switch_context(&new_context, &orig_context TSRMLS_CC);
}
SOAP_GLOBAL(error_code) = "WSDL";
SOAP_GLOBAL(error_code) = old_error_code;
if (context) {
- php_libxml_switch_context(orig_context TSRMLS_CC);
+ php_libxml_switch_context(&orig_context, NULL TSRMLS_CC);
zval_ptr_dtor(&new_context);
}
SOAP_GLOBAL(cache_limit) <= zend_hash_num_elements(SOAP_GLOBAL(mem_cache))) {
/* in-memory cache overflow */
sdl_cache_bucket *q;
- HashPosition pos;
time_t latest = t;
- char *key = NULL;
- uint key_len;
- ulong idx;
+ zend_string *latest_key = NULL, *key;
- for (zend_hash_internal_pointer_reset_ex(SOAP_GLOBAL(mem_cache), &pos);
- zend_hash_get_current_data_ex(SOAP_GLOBAL(mem_cache), (void **) &q, &pos) == SUCCESS;
- zend_hash_move_forward_ex(SOAP_GLOBAL(mem_cache), &pos)) {
+ ZEND_HASH_FOREACH_STR_KEY_PTR(SOAP_GLOBAL(mem_cache), key, q) {
if (q->time < latest) {
latest = q->time;
- zend_hash_get_current_key_ex(SOAP_GLOBAL(mem_cache), &key, &key_len, &idx, 0, &pos);
+ latest_key = key;
}
- }
- if (key) {
- zend_hash_del(SOAP_GLOBAL(mem_cache), key, key_len);
+ } ZEND_HASH_FOREACH_END();
+ if (latest_key) {
+ zend_hash_del(SOAP_GLOBAL(mem_cache), latest_key);
} else {
return sdl;
}
p.time = t;
p.sdl = psdl;
- if (SUCCESS == zend_hash_update(SOAP_GLOBAL(mem_cache), uri,
- uri_len+1, (void*)&p, sizeof(sdl_cache_bucket), NULL)) {
+ if (NULL != zend_hash_str_update_mem(SOAP_GLOBAL(mem_cache), uri,
+ uri_len, &p, sizeof(sdl_cache_bucket))) {
/* remove non-persitent sdl structure */
delete_sdl_impl(sdl);
/* and replace it with persistent one */
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to register persistent entry");
/* clean up persistent sdl */
- delete_psdl(&p);
+ delete_psdl_int(&p);
/* keep non-persistent sdl and return it */
}
}
}
}
-static void delete_binding(void *data)
+static void delete_binding(zval *zv)
{
- sdlBindingPtr binding = *((sdlBindingPtr*)data);
+ sdlBindingPtr binding = Z_PTR_P(zv);
if (binding->location) {
efree(binding->location);
efree(binding);
}
-static void delete_binding_persistent(void *data)
+static void delete_binding_persistent(zval *zv)
{
- sdlBindingPtr binding = *((sdlBindingPtr*)data);
+ sdlBindingPtr binding = Z_PTR_P(zv);
if (binding->location) {
free(binding->location);
}
}
-static void delete_function(void *data)
+static void delete_function(zval *zv)
{
- sdlFunctionPtr function = *((sdlFunctionPtr*)data);
+ sdlFunctionPtr function = Z_PTR_P(zv);
if (function->functionName) {
efree(function->functionName);
efree(function);
}
-static void delete_function_persistent(void *data)
+static void delete_function_persistent(zval *zv)
{
- sdlFunctionPtr function = *((sdlFunctionPtr*)data);
+ sdlFunctionPtr function = Z_PTR_P(zv);
if (function->functionName) {
free(function->functionName);
free(function);
}
-static void delete_parameter(void *data)
+static void delete_parameter(zval *zv)
{
- sdlParamPtr param = *((sdlParamPtr*)data);
+ sdlParamPtr param = Z_PTR_P(zv);
if (param->paramName) {
efree(param->paramName);
}
efree(param);
}
-static void delete_parameter_persistent(void *data)
+static void delete_parameter_persistent(zval *zv)
{
- sdlParamPtr param = *((sdlParamPtr*)data);
+ sdlParamPtr param = Z_PTR_P(zv);
if (param->paramName) {
free(param->paramName);
}
free(param);
}
-static void delete_header(void *data)
+static void delete_header_int(sdlSoapBindingFunctionHeaderPtr hdr)
{
- sdlSoapBindingFunctionHeaderPtr hdr = *((sdlSoapBindingFunctionHeaderPtr*)data);
if (hdr->name) {
efree(hdr->name);
}
efree(hdr);
}
-static void delete_header_persistent(void *data)
+static void delete_header(zval *zv)
+{
+ delete_header_int(Z_PTR_P(zv));
+}
+
+static void delete_header_persistent(zval *zv)
{
- sdlSoapBindingFunctionHeaderPtr hdr = *((sdlSoapBindingFunctionHeaderPtr*)data);
+ sdlSoapBindingFunctionHeaderPtr hdr = Z_PTR_P(zv);
if (hdr->name) {
free(hdr->name);
}
free(hdr);
}
-static void delete_fault(void *data)
+static void delete_fault(zval *zv)
{
- sdlFaultPtr fault = *((sdlFaultPtr*)data);
+ sdlFaultPtr fault = Z_PTR_P(zv);
if (fault->name) {
efree(fault->name);
}
efree(fault);
}
-static void delete_fault_persistent(void *data)
+static void delete_fault_persistent(zval *zv)
{
- sdlFaultPtr fault = *((sdlFaultPtr*)data);
+ sdlFaultPtr fault = Z_PTR_P(zv);
if (fault->name) {
free(fault->name);
}
free(fault);
}
-static void delete_document(void *doc_ptr)
+static void delete_document(zval *zv)
{
- xmlDocPtr doc = *((xmlDocPtr*)doc_ptr);
+ xmlDocPtr doc = Z_PTR_P(zv);
xmlFreeDoc(doc);
}
HashTable *attributes; /* array of sdlAttributePtr */
HashTable *attributeGroups; /* array of sdlTypesPtr */
php_stream_context *context;
- zval *old_header;
+ zval old_header;
} sdlCtx;
struct _sdlBinding {
#include "php_packet_soap.h"
struct _soapMapping {
- zval *to_xml;
- zval *to_zval;
+ zval to_xml;
+ zval to_zval;
};
struct _soapHeader;
struct _soap_class {
zend_class_entry *ce;
- zval **argv;
+ zval *argv;
int argc;
int persistance;
} soap_class;
- zval *soap_object;
+ zval soap_object;
HashTable *typemap;
int version;
zval function_name;
int mustUnderstand;
int num_params;
- zval **parameters;
+ zval *parameters;
zval retval;
sdlSoapBindingFunctionHeaderPtr hdr;
struct _soapHeader *next;
static sdlFunctionPtr get_function(sdlPtr sdl, const char *function_name);
static sdlFunctionPtr get_doc_function(sdlPtr sdl, xmlNodePtr node);
-static sdlFunctionPtr deserialize_function_call(sdlPtr sdl, xmlDocPtr request, char* actor, zval *function_name, int *num_params, zval **parameters[], int *version, soapHeader **headers TSRMLS_DC);
+static sdlFunctionPtr deserialize_function_call(sdlPtr sdl, xmlDocPtr request, char* actor, zval *function_name, int *num_params, zval **parameters, int *version, soapHeader **headers TSRMLS_DC);
static xmlDocPtr serialize_response_call(sdlFunctionPtr function, char *function_name,char *uri,zval *ret, soapHeader *headers, int version TSRMLS_DC);
-static xmlDocPtr serialize_function_call(zval *this_ptr, sdlFunctionPtr function, char *function_name, char *uri, zval **arguments, int arg_count, int version, HashTable *soap_headers TSRMLS_DC);
+static xmlDocPtr serialize_function_call(zval *this_ptr, sdlFunctionPtr function, char *function_name, char *uri, zval *arguments, int arg_count, int version, HashTable *soap_headers TSRMLS_DC);
static xmlNodePtr serialize_parameter(sdlParamPtr param,zval *param_val,int index,char *name, int style, xmlNodePtr parent TSRMLS_DC);
static xmlNodePtr serialize_zval(zval *val, sdlParamPtr param, char *paramName, int style, xmlNodePtr parent TSRMLS_DC);
int _old_soap_version = SOAP_GLOBAL(soap_version);\
SOAP_GLOBAL(use_soap_error_handler) = 1;\
SOAP_GLOBAL(error_code) = "Server";\
- SOAP_GLOBAL(error_object) = this_ptr;
+ SOAP_GLOBAL(error_object) = getThis();
#define SOAP_SERVER_END_CODE() \
SOAP_GLOBAL(use_soap_error_handler) = _old_handler;\
zend_bool _old_in_compilation = CG(in_compilation); \
zend_bool _old_in_execution = EG(in_execution); \
zend_execute_data *_old_current_execute_data = EG(current_execute_data); \
- void **_old_stack_top = EG(argument_stack)->top; \
+ zval *_old_stack_top = EG(argument_stack)->top; \
int _bailout = 0;\
SOAP_GLOBAL(use_soap_error_handler) = 1;\
SOAP_GLOBAL(error_code) = "Client";\
- SOAP_GLOBAL(error_object) = this_ptr;\
+ SOAP_GLOBAL(error_object) = getThis();\
zend_try {
#define SOAP_CLIENT_END_CODE() \
EG(in_execution) = _old_in_execution; \
EG(current_execute_data) = _old_current_execute_data; \
if (EG(exception) == NULL || \
- Z_TYPE_P(EG(exception)) != IS_OBJECT || \
- !instanceof_function(Z_OBJCE_P(EG(exception)), soap_fault_class_entry TSRMLS_CC)) {\
+ !instanceof_function(zend_get_class_entry(EG(exception) TSRMLS_CC), soap_fault_class_entry TSRMLS_CC)) {\
_bailout = 1;\
}\
if (_old_stack_top != EG(argument_stack)->top) { \
#define FETCH_THIS_SDL(ss) \
{ \
- zval **__tmp; \
- if(FIND_SDL_PROPERTY(this_ptr,__tmp) != FAILURE) { \
+ zval *__tmp; \
+ if(FIND_SDL_PROPERTY(getThis(), __tmp) != NULL) { \
FETCH_SDL_RES(ss,__tmp); \
} else { \
ss = NULL; \
} \
}
-#define FIND_SDL_PROPERTY(ss,tmp) zend_hash_find(Z_OBJPROP_P(ss), "sdl", sizeof("sdl"), (void **)&tmp)
+#define FIND_SDL_PROPERTY(ss,tmp) (tmp = zend_hash_str_find(Z_OBJPROP_P(ss), "sdl", sizeof("sdl")-1))
#define FETCH_SDL_RES(ss,tmp) ss = (sdlPtr) zend_fetch_resource(tmp TSRMLS_CC, -1, "sdl", NULL, 1, le_sdl)
-#define FIND_TYPEMAP_PROPERTY(ss,tmp) zend_hash_find(Z_OBJPROP_P(ss), "typemap", sizeof("typemap"), (void **)&tmp)
+#define FIND_TYPEMAP_PROPERTY(ss,tmp) (tmp = zend_hash_str_find(Z_OBJPROP_P(ss), "typemap", sizeof("typemap")-1))
#define FETCH_TYPEMAP_RES(ss,tmp) ss = (HashTable*) zend_fetch_resource(tmp TSRMLS_CC, -1, "typemap", NULL, 1, le_typemap)
#define FETCH_THIS_SERVICE(ss) \
{ \
- zval **tmp; \
- if (zend_hash_find(Z_OBJPROP_P(this_ptr),"service", sizeof("service"), (void **)&tmp) != FAILURE) { \
+ zval *tmp; \
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(getThis()),"service", sizeof("service")-1)) != NULL) { \
ss = (soapServicePtr)zend_fetch_resource(tmp TSRMLS_CC, -1, "service", NULL, 1, le_service); \
} else { \
ss = NULL; \
zend_hash_init(&defEnc, 0, NULL, NULL, 1);
zend_hash_init(&defEncIndex, 0, NULL, NULL, 1);
zend_hash_init(&defEncNs, 0, NULL, NULL, 1);
- defEncNs.flags |= HASH_FLAG_BIG_DATA;
+//??? defEncNs.flags |= HASH_FLAG_BIG_DATA;
i = 0;
do {
if (defaultEncoding[i].details.ns != NULL) {
char *ns_type;
spprintf(&ns_type, 0, "%s:%s", defaultEncoding[i].details.ns, defaultEncoding[i].details.type_str);
- zend_hash_add(&defEnc, ns_type, strlen(ns_type) + 1, &enc, sizeof(encodePtr), NULL);
+ zend_hash_str_add_ptr(&defEnc, ns_type, strlen(ns_type), enc);
efree(ns_type);
} else {
- zend_hash_add(&defEnc, defaultEncoding[i].details.type_str, strlen(defaultEncoding[i].details.type_str) + 1, &enc, sizeof(encodePtr), NULL);
+ zend_hash_str_add_ptr(&defEnc, defaultEncoding[i].details.type_str, strlen(defaultEncoding[i].details.type_str), enc);
}
}
/* Index everything by number */
if (!zend_hash_index_exists(&defEncIndex, defaultEncoding[i].details.type)) {
- zend_hash_index_update(&defEncIndex, defaultEncoding[i].details.type, &enc, sizeof(encodePtr), NULL);
+ zend_hash_index_update_ptr(&defEncIndex, defaultEncoding[i].details.type, enc);
}
i++;
} while (defaultEncoding[i].details.type != END_KNOWN_TYPES);
/* hash by namespace */
- zend_hash_add(&defEncNs, XSD_1999_NAMESPACE, sizeof(XSD_1999_NAMESPACE), XSD_NS_PREFIX, sizeof(XSD_NS_PREFIX), NULL);
- zend_hash_add(&defEncNs, XSD_NAMESPACE, sizeof(XSD_NAMESPACE), XSD_NS_PREFIX, sizeof(XSD_NS_PREFIX), NULL);
- zend_hash_add(&defEncNs, XSI_NAMESPACE, sizeof(XSI_NAMESPACE), XSI_NS_PREFIX, sizeof(XSI_NS_PREFIX), NULL);
- zend_hash_add(&defEncNs, XML_NAMESPACE, sizeof(XML_NAMESPACE), XML_NS_PREFIX, sizeof(XML_NS_PREFIX), NULL);
- zend_hash_add(&defEncNs, SOAP_1_1_ENC_NAMESPACE, sizeof(SOAP_1_1_ENC_NAMESPACE), SOAP_1_1_ENC_NS_PREFIX, sizeof(SOAP_1_1_ENC_NS_PREFIX), NULL);
- zend_hash_add(&defEncNs, SOAP_1_2_ENC_NAMESPACE, sizeof(SOAP_1_2_ENC_NAMESPACE), SOAP_1_2_ENC_NS_PREFIX, sizeof(SOAP_1_2_ENC_NS_PREFIX), NULL);
+//??? change _mem into _ptr
+ zend_hash_str_add_mem(&defEncNs, XSD_1999_NAMESPACE, sizeof(XSD_1999_NAMESPACE)-1, XSD_NS_PREFIX, sizeof(XSD_NS_PREFIX));
+ zend_hash_str_add_mem(&defEncNs, XSD_NAMESPACE, sizeof(XSD_NAMESPACE)-1, XSD_NS_PREFIX, sizeof(XSD_NS_PREFIX));
+ zend_hash_str_add_mem(&defEncNs, XSI_NAMESPACE, sizeof(XSI_NAMESPACE)-1, XSI_NS_PREFIX, sizeof(XSI_NS_PREFIX));
+ zend_hash_str_add_mem(&defEncNs, XML_NAMESPACE, sizeof(XML_NAMESPACE)-1, XML_NS_PREFIX, sizeof(XML_NS_PREFIX));
+ zend_hash_str_add_mem(&defEncNs, SOAP_1_1_ENC_NAMESPACE, sizeof(SOAP_1_1_ENC_NAMESPACE)-1, SOAP_1_1_ENC_NS_PREFIX, sizeof(SOAP_1_1_ENC_NS_PREFIX));
+ zend_hash_str_add_mem(&defEncNs, SOAP_1_2_ENC_NAMESPACE, sizeof(SOAP_1_2_ENC_NAMESPACE)-1, SOAP_1_2_ENC_NS_PREFIX, sizeof(SOAP_1_2_ENC_NS_PREFIX));
}
static void php_soap_init_globals(zend_soap_globals *soap_globals TSRMLS_DC)
return SUCCESS;
}
+static void delete_sdl_res(zend_resource *res)
+{
+ delete_sdl(res->ptr);
+}
+
+static void delete_url_res(zend_resource *res)
+{
+ delete_url(res->ptr);
+}
+
+static void delete_service_res(zend_resource *res)
+{
+ delete_service(res->ptr);
+}
+
+static void delete_hashtable_res(zend_resource *res)
+{
+ delete_hashtable(res->ptr);
+}
+
PHP_MINIT_FUNCTION(soap)
{
zend_class_entry ce;
INIT_CLASS_ENTRY(ce, PHP_SOAP_HEADER_CLASSNAME, soap_header_functions);
soap_header_class_entry = zend_register_internal_class(&ce TSRMLS_CC);
- le_sdl = register_list_destructors(delete_sdl, NULL);
- le_url = register_list_destructors(delete_url, NULL);
- le_service = register_list_destructors(delete_service, NULL);
- le_typemap = register_list_destructors(delete_hashtable, NULL);
+ le_sdl = register_list_destructors(delete_sdl_res, NULL);
+ le_url = register_list_destructors(delete_url_res, NULL);
+ le_service = register_list_destructors(delete_service_res, NULL);
+ le_typemap = register_list_destructors(delete_hashtable_res, NULL);
REGISTER_LONG_CONSTANT("SOAP_1_1", SOAP_1_1, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("SOAP_1_2", SOAP_1_2, CONST_CS | CONST_PERSISTENT);
zval *data;
char *name;
int name_length;
+ zval *this_ptr;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &data, &name, &name_length) == FAILURE) {
return;
return;
}
+ this_ptr = getThis();
add_property_stringl(this_ptr, "param_name", name, name_length);
add_property_zval(this_ptr, "param_data", data);
}
char *name, *ns;
int name_len, ns_len;
zend_bool must_understand = 0;
+ zval *this_ptr;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|zbz", &ns, &ns_len, &name, &name_len, &data, &must_understand, &actor) == FAILURE) {
return;
return;
}
+ this_ptr = getThis();
add_property_stringl(this_ptr, "namespace", ns, ns_len);
add_property_stringl(this_ptr, "name", name, name_len);
if (data) {
{
char *fault_string = NULL, *fault_code = NULL, *fault_actor = NULL, *name = NULL, *fault_code_ns = NULL;
int fault_string_len, fault_actor_len = 0, name_len = 0, fault_code_len = 0;
- zval *code = NULL, *details = NULL, *headerfault = NULL;
+ zval *code = NULL, *details = NULL, *headerfault = NULL, *this_ptr;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs|s!z!s!z",
&code,
fault_code = Z_STRVAL_P(code);
fault_code_len = Z_STRLEN_P(code);
} else if (Z_TYPE_P(code) == IS_ARRAY && zend_hash_num_elements(Z_ARRVAL_P(code)) == 2) {
- zval **t_ns, **t_code;
+ zval *t_ns, *t_code;
zend_hash_internal_pointer_reset(Z_ARRVAL_P(code));
- zend_hash_get_current_data(Z_ARRVAL_P(code), (void**)&t_ns);
+ t_ns = zend_hash_get_current_data(Z_ARRVAL_P(code));
zend_hash_move_forward(Z_ARRVAL_P(code));
- zend_hash_get_current_data(Z_ARRVAL_P(code), (void**)&t_code);
- if (Z_TYPE_PP(t_ns) == IS_STRING && Z_TYPE_PP(t_code) == IS_STRING) {
- fault_code_ns = Z_STRVAL_PP(t_ns);
- fault_code = Z_STRVAL_PP(t_code);
- fault_code_len = Z_STRLEN_PP(t_code);
+ t_code = zend_hash_get_current_data(Z_ARRVAL_P(code));
+ if (Z_TYPE_P(t_ns) == IS_STRING && Z_TYPE_P(t_code) == IS_STRING) {
+ fault_code_ns = Z_STRVAL_P(t_ns);
+ fault_code = Z_STRVAL_P(t_code);
+ fault_code_len = Z_STRLEN_P(t_code);
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid fault code");
return;
name = NULL;
}
+ this_ptr = getThis();
set_soap_fault(this_ptr, fault_code_ns, fault_code, fault_string, fault_actor, details, name TSRMLS_CC);
if (headerfault != NULL) {
add_property_zval(this_ptr, "headerfault", headerfault);
SoapFault constructor */
PHP_METHOD(SoapFault, __toString)
{
- zval *faultcode, *faultstring, *file, *line, *trace;
+ zval *faultcode, *faultstring, *file, *line, trace;
char *str;
int len;
zend_fcall_info fci;
- zval fname;
+ zval *this_ptr;
if (zend_parse_parameters_none() == FAILURE) {
return;
}
+ this_ptr = getThis();
faultcode = zend_read_property(soap_fault_class_entry, this_ptr, "faultcode", sizeof("faultcode")-1, 1 TSRMLS_CC);
faultstring = zend_read_property(soap_fault_class_entry, this_ptr, "faultstring", sizeof("faultstring")-1, 1 TSRMLS_CC);
file = zend_read_property(soap_fault_class_entry, this_ptr, "file", sizeof("file")-1, 1 TSRMLS_CC);
line = zend_read_property(soap_fault_class_entry, this_ptr, "line", sizeof("line")-1, 1 TSRMLS_CC);
- ZVAL_STRINGL(&fname, "gettraceasstring", sizeof("gettraceasstring")-1, 0);
-
fci.size = sizeof(fci);
fci.function_table = &Z_OBJCE_P(getThis())->function_table;
- fci.function_name = &fname;
+ ZVAL_STRINGL(&fci.function_name, "gettraceasstring", sizeof("gettraceasstring")-1);
fci.symbol_table = NULL;
- fci.object_ptr = getThis();
- fci.retval_ptr_ptr = &trace;
+ fci.object = Z_OBJ(EG(This));
+ fci.retval = &trace;
fci.param_count = 0;
fci.params = NULL;
fci.no_separation = 1;
zend_call_function(&fci, NULL TSRMLS_CC);
+ zval_ptr_dtor(&fci.function_name);
+
len = spprintf(&str, 0, "SoapFault exception: [%s] %s in %s:%ld\nStack trace:\n%s",
Z_STRVAL_P(faultcode), Z_STRVAL_P(faultstring), Z_STRVAL_P(file), Z_LVAL_P(line),
- Z_STRLEN_P(trace) ? Z_STRVAL_P(trace) : "#0 {main}\n");
+ Z_STRLEN(trace) ? Z_STRVAL(trace) : "#0 {main}\n");
zval_ptr_dtor(&trace);
- RETURN_STRINGL(str, len, 0);
+ // TODO: avoid reallocation ???
+ RETVAL_STRINGL(str, len);
+ efree(str);
}
/* }}} */
SoapVar constructor */
PHP_METHOD(SoapVar, SoapVar)
{
- zval *data, *type;
+ zval *data, *type, *this_ptr;
char *stype = NULL, *ns = NULL, *name = NULL, *namens = NULL;
int stype_len = 0, ns_len = 0, name_len = 0, namens_len = 0;
return;
}
+ this_ptr = getThis();
if (Z_TYPE_P(type) == IS_NULL) {
add_property_long(this_ptr, "enc_type", UNKNOWN_TYPE);
} else {
}
/* }}} */
-
static HashTable* soap_create_typemap(sdlPtr sdl, HashTable *ht TSRMLS_DC)
{
- zval **tmp;
+ zval *tmp;
HashTable *ht2;
- HashPosition pos1, pos2;
HashTable *typemap = NULL;
- zend_hash_internal_pointer_reset_ex(ht, &pos1);
- while (zend_hash_get_current_data_ex(ht, (void**)&tmp, &pos1) == SUCCESS) {
+ ZEND_HASH_FOREACH_VAL(ht, tmp) {
char *type_name = NULL;
char *type_ns = NULL;
zval *to_xml = NULL;
zval *to_zval = NULL;
encodePtr enc, new_enc;
+ zend_string *name;
- if (Z_TYPE_PP(tmp) != IS_ARRAY) {
+ if (Z_TYPE_P(tmp) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Wrong 'typemap' option");
return NULL;
}
- ht2 = Z_ARRVAL_PP(tmp);
+ ht2 = Z_ARRVAL_P(tmp);
- zend_hash_internal_pointer_reset_ex(ht2, &pos2);
- while (zend_hash_get_current_data_ex(ht2, (void**)&tmp, &pos2) == SUCCESS) {
- char *name = NULL;
- unsigned int name_len;
- ulong index;
-
- zend_hash_get_current_key_ex(ht2, &name, &name_len, &index, 0, &pos2);
+ ZEND_HASH_FOREACH_STR_KEY_VAL(ht2, name, tmp) {
if (name) {
- if (name_len == sizeof("type_name") &&
- strncmp(name, "type_name", sizeof("type_name")-1) == 0) {
- if (Z_TYPE_PP(tmp) == IS_STRING) {
- type_name = Z_STRVAL_PP(tmp);
- } else if (Z_TYPE_PP(tmp) != IS_NULL) {
+ if (name->len == sizeof("type_name") &&
+ strncmp(name->val, "type_name", sizeof("type_name")-1) == 0) {
+ if (Z_TYPE_P(tmp) == IS_STRING) {
+ type_name = Z_STRVAL_P(tmp);
+ } else if (Z_TYPE_P(tmp) != IS_NULL) {
}
- } else if (name_len == sizeof("type_ns") &&
- strncmp(name, "type_ns", sizeof("type_ns")-1) == 0) {
- if (Z_TYPE_PP(tmp) == IS_STRING) {
- type_ns = Z_STRVAL_PP(tmp);
- } else if (Z_TYPE_PP(tmp) != IS_NULL) {
+ } else if (name->len == sizeof("type_ns") &&
+ strncmp(name->val, "type_ns", sizeof("type_ns")-1) == 0) {
+ if (Z_TYPE_P(tmp) == IS_STRING) {
+ type_ns = Z_STRVAL_P(tmp);
+ } else if (Z_TYPE_P(tmp) != IS_NULL) {
}
- } else if (name_len == sizeof("to_xml") &&
- strncmp(name, "to_xml", sizeof("to_xml")-1) == 0) {
- to_xml = *tmp;
- } else if (name_len == sizeof("from_xml") &&
- strncmp(name, "from_xml", sizeof("from_xml")-1) == 0) {
- to_zval = *tmp;
+ } else if (name->len == sizeof("to_xml") &&
+ strncmp(name->val, "to_xml", sizeof("to_xml")-1) == 0) {
+ to_xml = tmp;
+ } else if (name->len == sizeof("from_xml") &&
+ strncmp(name->val, "from_xml", sizeof("from_xml")-1) == 0) {
+ to_zval = tmp;
}
}
- zend_hash_move_forward_ex(ht2, &pos2);
- }
+ } ZEND_HASH_FOREACH_END();
if (type_name) {
smart_str nscat = {0};
new_enc->details.map = emalloc(sizeof(soapMapping));
memset(new_enc->details.map, 0, sizeof(soapMapping));
if (to_xml) {
- zval_add_ref(&to_xml);
- new_enc->details.map->to_xml = to_xml;
+ ZVAL_COPY(&new_enc->details.map->to_xml, to_xml);
new_enc->to_xml = to_xml_user;
- } else if (enc->details.map && enc->details.map->to_xml) {
- zval_add_ref(&enc->details.map->to_xml);
- new_enc->details.map->to_xml = enc->details.map->to_xml;
+ } else if (enc->details.map && Z_TYPE(enc->details.map->to_xml) != IS_UNDEF) {
+ ZVAL_COPY(&new_enc->details.map->to_xml, &enc->details.map->to_xml);
}
if (to_zval) {
- zval_add_ref(&to_zval);
- new_enc->details.map->to_zval = to_zval;
+ ZVAL_COPY(&new_enc->details.map->to_zval, to_zval);
new_enc->to_zval = to_zval_user;
- } else if (enc->details.map && enc->details.map->to_zval) {
- zval_add_ref(&enc->details.map->to_zval);
- new_enc->details.map->to_zval = enc->details.map->to_zval;
+ } else if (enc->details.map && Z_TYPE(enc->details.map->to_zval) != IS_UNDEF) {
+ ZVAL_COPY(&new_enc->details.map->to_zval, &enc->details.map->to_zval);
}
if (!typemap) {
typemap = emalloc(sizeof(HashTable));
}
smart_str_appends(&nscat, type_name);
smart_str_0(&nscat);
- zend_hash_update(typemap, nscat.c, nscat.len + 1, &new_enc, sizeof(encodePtr), NULL);
+ zend_hash_update_ptr(typemap, nscat.s, new_enc);
smart_str_free(&nscat);
}
- zend_hash_move_forward_ex(ht, &pos1);
- }
+ } ZEND_HASH_FOREACH_END();
return typemap;
}
{
soapServicePtr service;
zval *wsdl = NULL, *options = NULL;
- int ret;
+ zend_resource *res;
int version = SOAP_1_1;
long cache_wsdl;
HashTable *typemap_ht = NULL;
if (options != NULL) {
HashTable *ht = Z_ARRVAL_P(options);
- zval **tmp;
+ zval *tmp;
- if (zend_hash_find(ht, "soap_version", sizeof("soap_version"), (void**)&tmp) == SUCCESS) {
- if (Z_TYPE_PP(tmp) == IS_LONG &&
- (Z_LVAL_PP(tmp) == SOAP_1_1 || Z_LVAL_PP(tmp) == SOAP_1_2)) {
- version = Z_LVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(ht, "soap_version", sizeof("soap_version")-1)) != NULL) {
+ if (Z_TYPE_P(tmp) == IS_LONG &&
+ (Z_LVAL_P(tmp) == SOAP_1_1 || Z_LVAL_P(tmp) == SOAP_1_2)) {
+ version = Z_LVAL_P(tmp);
} else {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "'soap_version' option must be SOAP_1_1 or SOAP_1_2");
}
}
- if (zend_hash_find(ht, "uri", sizeof("uri"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- service->uri = estrndup(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ if ((tmp = zend_hash_str_find(ht, "uri", sizeof("uri")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ service->uri = estrndup(Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
} else if (Z_TYPE_P(wsdl) == IS_NULL) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "'uri' option is required in nonWSDL mode");
}
- if (zend_hash_find(ht, "actor", sizeof("actor"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- service->actor = estrndup(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ if ((tmp = zend_hash_str_find(ht, "actor", sizeof("actor")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ service->actor = estrndup(Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
}
- if (zend_hash_find(ht, "encoding", sizeof("encoding"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
+ if ((tmp = zend_hash_str_find(ht, "encoding", sizeof("encoding")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
xmlCharEncodingHandlerPtr encoding;
- encoding = xmlFindCharEncodingHandler(Z_STRVAL_PP(tmp));
+ encoding = xmlFindCharEncodingHandler(Z_STRVAL_P(tmp));
if (encoding == NULL) {
- php_error_docref(NULL TSRMLS_CC, E_ERROR, "Invalid 'encoding' option - '%s'", Z_STRVAL_PP(tmp));
+ php_error_docref(NULL TSRMLS_CC, E_ERROR, "Invalid 'encoding' option - '%s'", Z_STRVAL_P(tmp));
} else {
service->encoding = encoding;
}
}
- if (zend_hash_find(ht, "classmap", sizeof("classmap"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_ARRAY) {
- zval *ztmp;
-
+ if ((tmp = zend_hash_str_find(ht, "classmap", sizeof("classmap")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_ARRAY) {
ALLOC_HASHTABLE(service->class_map);
- zend_hash_init(service->class_map, zend_hash_num_elements((*tmp)->value.ht), NULL, ZVAL_PTR_DTOR, 0);
- zend_hash_copy(service->class_map, (*tmp)->value.ht, (copy_ctor_func_t) zval_add_ref, (void *) &ztmp, sizeof(zval *));
+ zend_hash_init(service->class_map, zend_hash_num_elements(Z_ARRVAL_P(tmp)), NULL, ZVAL_PTR_DTOR, 0);
+ zend_hash_copy(service->class_map, Z_ARRVAL_P(tmp), zval_add_ref);
}
- if (zend_hash_find(ht, "typemap", sizeof("typemap"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_ARRAY &&
- zend_hash_num_elements(Z_ARRVAL_PP(tmp)) > 0) {
- typemap_ht = Z_ARRVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(ht, "typemap", sizeof("typemap")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_ARRAY &&
+ zend_hash_num_elements(Z_ARRVAL_P(tmp)) > 0) {
+ typemap_ht = Z_ARRVAL_P(tmp);
}
- if (zend_hash_find(ht, "features", sizeof("features"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_LONG) {
- service->features = Z_LVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(ht, "features", sizeof("features")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_LONG) {
+ service->features = Z_LVAL_P(tmp);
}
- if (zend_hash_find(ht, "cache_wsdl", sizeof("cache_wsdl"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_LONG) {
- cache_wsdl = Z_LVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(ht, "cache_wsdl", sizeof("cache_wsdl")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_LONG) {
+ cache_wsdl = Z_LVAL_P(tmp);
}
- if (zend_hash_find(ht, "send_errors", sizeof("send_errors"), (void**)&tmp) == SUCCESS &&
- (Z_TYPE_PP(tmp) == IS_BOOL || Z_TYPE_PP(tmp) == IS_LONG)) {
- service->send_errors = Z_LVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(ht, "send_errors", sizeof("send_errors")-1)) != NULL) {
+ if (Z_TYPE_P(tmp) == IS_FALSE) {
+ service->send_errors = 0;
+ } else if (Z_TYPE_P(tmp) == IS_TRUE) {
+ service->send_errors = 1;
+ } else if (Z_TYPE_P(tmp) == IS_LONG) {
+ service->send_errors = Z_LVAL_P(tmp);
+ }
}
} else if (Z_TYPE_P(wsdl) == IS_NULL) {
zend_hash_init(service->soap_functions.ft, 0, NULL, ZVAL_PTR_DTOR, 0);
if (Z_TYPE_P(wsdl) != IS_NULL) {
- service->sdl = get_sdl(this_ptr, Z_STRVAL_P(wsdl), cache_wsdl TSRMLS_CC);
+ service->sdl = get_sdl(getThis(), Z_STRVAL_P(wsdl), cache_wsdl TSRMLS_CC);
if (service->uri == NULL) {
if (service->sdl->target_ns) {
service->uri = estrdup(service->sdl->target_ns);
service->typemap = soap_create_typemap(service->sdl, typemap_ht TSRMLS_CC);
}
- ret = zend_list_insert(service, le_service TSRMLS_CC);
- add_property_resource(this_ptr, "service", ret);
+ res = zend_register_resource(NULL, service, le_service TSRMLS_CC);
+ add_property_resource(getThis(), "service", res);
SOAP_SERVER_END_CODE();
}
PHP_METHOD(SoapServer, setClass)
{
soapServicePtr service;
- char *classname;
- zend_class_entry **ce;
-
- int classname_len, found, num_args = 0;
- zval ***argv = NULL;
+ zend_string *classname;
+ zend_class_entry *ce;
+ int num_args = 0;
+ zval *argv = NULL;
SOAP_SERVER_BEGIN_CODE();
FETCH_THIS_SERVICE(service);
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s*", &classname, &classname_len, &argv, &num_args) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S*", &classname, &argv, &num_args) == FAILURE) {
return;
}
- found = zend_lookup_class(classname, classname_len, &ce TSRMLS_CC);
+ ce = zend_lookup_class(classname TSRMLS_CC);
- if (found != FAILURE) {
+ if (ce) {
service->type = SOAP_CLASS;
- service->soap_class.ce = *ce;
+ service->soap_class.ce = ce;
service->soap_class.persistance = SOAP_PERSISTENCE_REQUEST;
service->soap_class.argc = num_args;
int i;
service->soap_class.argv = safe_emalloc(sizeof(zval), service->soap_class.argc, 0);
for (i = 0;i < service->soap_class.argc;i++) {
- service->soap_class.argv[i] = *(argv[i]);
- zval_add_ref(&service->soap_class.argv[i]);
+ ZVAL_COPY(&service->soap_class.argv[i], &argv[i]);
}
}
} else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Tried to set a non existent class (%s)", classname);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Tried to set a non existent class (%s)", classname->val);
return;
}
service->type = SOAP_OBJECT;
- MAKE_STD_ZVAL(service->soap_object);
- MAKE_COPY_ZVAL(&obj, service->soap_object);
+ ZVAL_COPY(&service->soap_object, obj);
SOAP_SERVER_END_CODE();
}
array_init(return_value);
if (service->type == SOAP_OBJECT) {
- ft = &(Z_OBJCE_P(service->soap_object)->function_table);
+ ft = &(Z_OBJCE(service->soap_object)->function_table);
} else if (service->type == SOAP_CLASS) {
ft = &service->soap_class.ce->function_table;
} else if (service->soap_functions.functions_all == TRUE) {
ft = EG(function_table);
} else if (service->soap_functions.ft != NULL) {
- zval **name;
- HashPosition pos;
+ zval *name;
- zend_hash_internal_pointer_reset_ex(service->soap_functions.ft, &pos);
- while (zend_hash_get_current_data_ex(service->soap_functions.ft, (void **)&name, &pos) != FAILURE) {
- add_next_index_string(return_value, Z_STRVAL_PP(name));
- zend_hash_move_forward_ex(service->soap_functions.ft, &pos);
- }
+ ZEND_HASH_FOREACH_VAL(service->soap_functions.ft, name) {
+ add_next_index_str(return_value, STR_COPY(Z_STR_P(name)));
+ } ZEND_HASH_FOREACH_END();
}
if (ft != NULL) {
zend_function *f;
- HashPosition pos;
- zend_hash_internal_pointer_reset_ex(ft, &pos);
- while (zend_hash_get_current_data_ex(ft, (void **)&f, &pos) != FAILURE) {
+
+ ZEND_HASH_FOREACH_PTR(ft, f) {
if ((service->type != SOAP_OBJECT && service->type != SOAP_CLASS) || (f->common.fn_flags & ZEND_ACC_PUBLIC)) {
- add_next_index_string(return_value, f->common.function_name);
+ add_next_index_str(return_value, STR_COPY(f->common.function_name));
}
- zend_hash_move_forward_ex(ft, &pos);
- }
+ } ZEND_HASH_FOREACH_END();
}
SOAP_SERVER_END_CODE();
PHP_METHOD(SoapServer, addFunction)
{
soapServicePtr service;
- zval *function_name, *function_copy;
- HashPosition pos;
+ zval *function_name, function_copy;
SOAP_SERVER_BEGIN_CODE();
/* TODO: could use zend_is_callable here */
- if (function_name->type == IS_ARRAY) {
+ if (Z_TYPE_P(function_name) == IS_ARRAY) {
if (service->type == SOAP_FUNCTIONS) {
- zval **tmp_function, *function_copy;
+ zval *tmp_function;
if (service->soap_functions.ft == NULL) {
service->soap_functions.functions_all = FALSE;
zend_hash_init(service->soap_functions.ft, zend_hash_num_elements(Z_ARRVAL_P(function_name)), NULL, ZVAL_PTR_DTOR, 0);
}
- zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(function_name), &pos);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_P(function_name), (void **)&tmp_function, &pos) != FAILURE) {
- char *key;
- int key_len;
+ ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(function_name), tmp_function) {
+ zend_string *key;
zend_function *f;
- if (Z_TYPE_PP(tmp_function) != IS_STRING) {
+ if (Z_TYPE_P(tmp_function) != IS_STRING) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Tried to add a function that isn't a string");
return;
}
- key_len = Z_STRLEN_PP(tmp_function);
- key = emalloc(key_len + 1);
- zend_str_tolower_copy(key, Z_STRVAL_PP(tmp_function), key_len);
+ key = STR_ALLOC(Z_STRLEN_P(tmp_function), 0);
+ zend_str_tolower_copy(key->val, Z_STRVAL_P(tmp_function), Z_STRLEN_P(tmp_function));
- if (zend_hash_find(EG(function_table), key, key_len+1, (void**)&f) == FAILURE) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Tried to add a non existent function '%s'", Z_STRVAL_PP(tmp_function));
+ if ((f = zend_hash_find_ptr(EG(function_table), key)) == NULL) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Tried to add a non existent function '%s'", Z_STRVAL_P(tmp_function));
return;
}
- MAKE_STD_ZVAL(function_copy);
- ZVAL_STRING(function_copy, f->common.function_name, 1);
- zend_hash_update(service->soap_functions.ft, key, key_len+1, &function_copy, sizeof(zval *), NULL);
+ ZVAL_STR(&function_copy, STR_COPY(f->common.function_name));
+ zend_hash_update(service->soap_functions.ft, key, &function_copy);
- efree(key);
- zend_hash_move_forward_ex(Z_ARRVAL_P(function_name), &pos);
- }
+ STR_RELEASE(key);
+ } ZEND_HASH_FOREACH_END();
}
- } else if (function_name->type == IS_STRING) {
- char *key;
- int key_len;
+ } else if (Z_TYPE_P(function_name) == IS_STRING) {
+ zend_string *key;
zend_function *f;
- key_len = Z_STRLEN_P(function_name);
- key = emalloc(key_len + 1);
- zend_str_tolower_copy(key, Z_STRVAL_P(function_name), key_len);
+ key = STR_ALLOC(Z_STRLEN_P(function_name), 0);
+ zend_str_tolower_copy(key->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name));
- if (zend_hash_find(EG(function_table), key, key_len+1, (void**)&f) == FAILURE) {
+ if ((f = zend_hash_find_ptr(EG(function_table), key)) == NULL) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Tried to add a non existent function '%s'", Z_STRVAL_P(function_name));
return;
}
zend_hash_init(service->soap_functions.ft, 0, NULL, ZVAL_PTR_DTOR, 0);
}
- MAKE_STD_ZVAL(function_copy);
- ZVAL_STRING(function_copy, f->common.function_name, 1);
- zend_hash_update(service->soap_functions.ft, key, key_len+1, &function_copy, sizeof(zval *), NULL);
- efree(key);
- } else if (function_name->type == IS_LONG) {
+ ZVAL_STR(&function_copy, STR_COPY(f->common.function_name));
+ zend_hash_update(service->soap_functions.ft, key, &function_copy);
+ STR_RELEASE(key);
+ } else if (Z_TYPE_P(function_name) == IS_LONG) {
if (Z_LVAL_P(function_name) == SOAP_FUNCTIONS_ALL) {
if (service->soap_functions.ft != NULL) {
zend_hash_destroy(service->soap_functions.ft);
sdlPtr old_sdl = NULL;
soapServicePtr service;
xmlDocPtr doc_request=NULL, doc_return;
- zval function_name, **params, *soap_obj, *retval;
+ zval function_name, *params, *soap_obj, retval;
char *fn_name, cont_len[30];
int num_params = 0, size, i, call_status = 0;
xmlChar *buf;
sapi_add_header(hdr, sizeof("Location: ")+strlen(service->sdl->source)-1, 1);
efree(hdr);
*/
- zval readfile, readfile_ret, *param;
-
- INIT_ZVAL(readfile);
- INIT_ZVAL(readfile_ret);
- MAKE_STD_ZVAL(param);
+ zval readfile, readfile_ret, param;
sapi_add_header("Content-Type: text/xml; charset=utf-8", sizeof("Content-Type: text/xml; charset=utf-8")-1, 1);
- ZVAL_STRING(param, service->sdl->source, 1);
- ZVAL_STRING(&readfile, "readfile", 1);
+ ZVAL_STRING(¶m, service->sdl->source);
+ ZVAL_STRING(&readfile, "readfile");
if (call_user_function(EG(function_table), NULL, &readfile, &readfile_ret, 1, ¶m TSRMLS_CC) == FAILURE) {
soap_server_fault("Server", "Couldn't find WSDL", NULL, NULL, NULL TSRMLS_CC);
}
}
}
- ALLOC_INIT_ZVAL(retval);
+ ZVAL_NULL(&retval);
if (php_output_start_default(TSRMLS_C) != SUCCESS) {
php_error_docref(NULL TSRMLS_CC, E_ERROR,"ob_start failed");
if (ZEND_NUM_ARGS() == 0) {
if (SG(request_info).request_body && 0 == php_stream_rewind(SG(request_info).request_body)) {
- zval **server_vars, **encoding;
+ zval *server_vars, *encoding;
php_stream_filter *zf = NULL;
+ zend_string *server = STR_INIT("_SERVER", sizeof("_SERVER")-1, 0);
- zend_is_auto_global("_SERVER", sizeof("_SERVER")-1 TSRMLS_CC);
- if (zend_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), (void **) &server_vars) == SUCCESS &&
- Z_TYPE_PP(server_vars) == IS_ARRAY &&
- zend_hash_find(Z_ARRVAL_PP(server_vars), "HTTP_CONTENT_ENCODING", sizeof("HTTP_CONTENT_ENCODING"), (void **) &encoding)==SUCCESS &&
- Z_TYPE_PP(encoding) == IS_STRING) {
+ zend_is_auto_global(server TSRMLS_CC);
+ if ((server_vars = zend_hash_find(&EG(symbol_table).ht, server)) != NULL &&
+ Z_TYPE_P(server_vars) == IS_ARRAY &&
+ (encoding = zend_hash_str_find(Z_ARRVAL_P(server_vars), "HTTP_CONTENT_ENCODING", sizeof("HTTP_CONTENT_ENCODING")-1)) != NULL &&
+ Z_TYPE_P(encoding) == IS_STRING) {
- if (strcmp(Z_STRVAL_PP(encoding),"gzip") == 0
- || strcmp(Z_STRVAL_PP(encoding),"x-gzip") == 0
- || strcmp(Z_STRVAL_PP(encoding),"deflate") == 0
+ if (strcmp(Z_STRVAL_P(encoding),"gzip") == 0
+ || strcmp(Z_STRVAL_P(encoding),"x-gzip") == 0
+ || strcmp(Z_STRVAL_P(encoding),"deflate") == 0
) {
zval filter_params;
- INIT_PZVAL(&filter_params);
array_init_size(&filter_params, 1);
add_assoc_long_ex(&filter_params, ZEND_STRS("window"), 0x2f); /* ANY WBITS */
php_stream_filter_append(&SG(request_info).request_body->readfilters, zf);
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING,"Can't uncompress compressed request");
+ STR_RELEASE(server);
return;
}
} else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING,"Request is compressed with unknown compression '%s'",Z_STRVAL_PP(encoding));
+ php_error_docref(NULL TSRMLS_CC, E_WARNING,"Request is compressed with unknown compression '%s'",Z_STRVAL_P(encoding));
+ STR_RELEASE(server);
return;
}
}
+ STR_RELEASE(server);
doc_request = soap_xmlParseFile("php://input" TSRMLS_CC);
xmlFreeDoc(doc_request);
if (EG(exception)) {
+ zval exception_object;
+
+ ZVAL_OBJ(&exception_object, EG(exception));
php_output_discard(TSRMLS_C);
- if (Z_TYPE_P(EG(exception)) == IS_OBJECT &&
- instanceof_function(Z_OBJCE_P(EG(exception)), soap_fault_class_entry TSRMLS_CC)) {
- soap_server_fault_ex(function, EG(exception), NULL TSRMLS_CC);
+ if (instanceof_function(Z_OBJCE(exception_object), soap_fault_class_entry TSRMLS_CC)) {
+ soap_server_fault_ex(function, &exception_object, NULL TSRMLS_CC);
}
goto fail;
}
soap_obj = NULL;
if (service->type == SOAP_OBJECT) {
- soap_obj = service->soap_object;
+ soap_obj = &service->soap_object;
function_table = &((Z_OBJCE_P(soap_obj))->function_table);
} else if (service->type == SOAP_CLASS) {
#if HAVE_PHP_SESSION && !defined(COMPILE_DL_SESSION)
/* If persistent then set soap_obj from from the previous created session (if available) */
if (service->soap_class.persistance == SOAP_PERSISTENCE_SESSION) {
- zval **tmp_soap;
+ zval *tmp_soap;
if (PS(session_status) != php_session_active &&
PS(session_status) != php_session_disabled) {
}
/* Find the soap object and assign */
- if (zend_hash_find(Z_ARRVAL_P(PS(http_session_vars)), "_bogus_session_name", sizeof("_bogus_session_name"), (void **) &tmp_soap) == SUCCESS &&
- Z_TYPE_PP(tmp_soap) == IS_OBJECT &&
- Z_OBJCE_PP(tmp_soap) == service->soap_class.ce) {
- soap_obj = *tmp_soap;
+ if ((tmp_soap = zend_hash_str_find(Z_ARRVAL(PS(http_session_vars)), "_bogus_session_name", sizeof("_bogus_session_name")-1)) != NULL &&
+ Z_TYPE_P(tmp_soap) == IS_OBJECT &&
+ Z_OBJCE_P(tmp_soap) == service->soap_class.ce) {
+ soap_obj = tmp_soap;
}
}
#endif
/* If new session or something weird happned */
if (soap_obj == NULL) {
- zval *tmp_soap;
+ zval tmp_soap;
- MAKE_STD_ZVAL(tmp_soap);
- object_init_ex(tmp_soap, service->soap_class.ce);
+ object_init_ex(&tmp_soap, service->soap_class.ce);
/* Call constructor */
- if (zend_hash_exists(&Z_OBJCE_P(tmp_soap)->function_table, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME))) {
+ if (zend_hash_str_exists(&Z_OBJCE(tmp_soap)->function_table, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1)) {
zval c_ret, constructor;
- INIT_ZVAL(c_ret);
- INIT_ZVAL(constructor);
-
- ZVAL_STRING(&constructor, ZEND_CONSTRUCTOR_FUNC_NAME, 1);
+ ZVAL_STRING(&constructor, ZEND_CONSTRUCTOR_FUNC_NAME);
if (call_user_function(NULL, &tmp_soap, &constructor, &c_ret, service->soap_class.argc, service->soap_class.argv TSRMLS_CC) == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error calling constructor");
}
if (EG(exception)) {
+ zval exception_object;
+
+ ZVAL_OBJ(&exception_object, EG(exception));
php_output_discard(TSRMLS_C);
- if (Z_TYPE_P(EG(exception)) == IS_OBJECT &&
- instanceof_function(Z_OBJCE_P(EG(exception)), soap_fault_class_entry TSRMLS_CC)) {
- soap_server_fault_ex(function, EG(exception), NULL TSRMLS_CC);
+ if (instanceof_function(Z_OBJCE(exception_object), soap_fault_class_entry TSRMLS_CC)) {
+ soap_server_fault_ex(function, &exception_object, NULL TSRMLS_CC);
}
zval_dtor(&constructor);
zval_dtor(&c_ret);
zval_dtor(&constructor);
zval_dtor(&c_ret);
} else {
- int class_name_len = strlen(service->soap_class.ce->name);
+ int class_name_len = service->soap_class.ce->name->len;
char *class_name = emalloc(class_name_len+1);
- memcpy(class_name, service->soap_class.ce->name,class_name_len+1);
- if (zend_hash_exists(&Z_OBJCE_P(tmp_soap)->function_table, php_strtolower(class_name, class_name_len), class_name_len+1)) {
+ memcpy(class_name, service->soap_class.ce->name->val, class_name_len+1);
+ if (zend_hash_str_exists(&Z_OBJCE(tmp_soap)->function_table, php_strtolower(class_name, class_name_len), class_name_len)) {
zval c_ret, constructor;
- INIT_ZVAL(c_ret);
- INIT_ZVAL(constructor);
-
- ZVAL_STRING(&constructor, service->soap_class.ce->name, 1);
+ ZVAL_STR(&constructor, STR_COPY(service->soap_class.ce->name));
if (call_user_function(NULL, &tmp_soap, &constructor, &c_ret, service->soap_class.argc, service->soap_class.argv TSRMLS_CC) == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error calling constructor");
}
if (EG(exception)) {
+ zval exception_object;
+
+ ZVAL_OBJ(&exception_object, EG(exception));
php_output_discard(TSRMLS_C);
- if (Z_TYPE_P(EG(exception)) == IS_OBJECT &&
- instanceof_function(Z_OBJCE_P(EG(exception)), soap_fault_class_entry TSRMLS_CC)) {
- soap_server_fault_ex(function, EG(exception), NULL TSRMLS_CC);
+ if (instanceof_function(Z_OBJCE(exception_object), soap_fault_class_entry TSRMLS_CC)) {
+ soap_server_fault_ex(function, &exception_object, NULL TSRMLS_CC);
}
zval_dtor(&constructor);
zval_dtor(&c_ret);
#if HAVE_PHP_SESSION && !defined(COMPILE_DL_SESSION)
/* If session then update session hash with new object */
if (service->soap_class.persistance == SOAP_PERSISTENCE_SESSION) {
- zval **tmp_soap_pp;
- if (zend_hash_update(Z_ARRVAL_P(PS(http_session_vars)), "_bogus_session_name", sizeof("_bogus_session_name"), &tmp_soap, sizeof(zval *), (void **)&tmp_soap_pp) == SUCCESS) {
- soap_obj = *tmp_soap_pp;
+ zval *tmp_soap_pp;
+ if ((tmp_soap_pp = zend_hash_str_update(Z_ARRVAL(PS(http_session_vars)), "_bogus_session_name", sizeof("_bogus_session_name")-1, &tmp_soap)) != NULL) {
+ soap_obj = tmp_soap_pp;
}
} else {
- soap_obj = tmp_soap;
+ soap_obj = &tmp_soap;
}
#else
- soap_obj = tmp_soap;
+ soap_obj = &tmp_soap;
#endif
}
}
#endif
fn_name = estrndup(Z_STRVAL(h->function_name),Z_STRLEN(h->function_name));
- if (zend_hash_exists(function_table, php_strtolower(fn_name, Z_STRLEN(h->function_name)), Z_STRLEN(h->function_name) + 1) ||
+ if (zend_hash_str_exists(function_table, php_strtolower(fn_name, Z_STRLEN(h->function_name)), Z_STRLEN(h->function_name)) ||
((service->type == SOAP_CLASS || service->type == SOAP_OBJECT) &&
- zend_hash_exists(function_table, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)))) {
+ zend_hash_str_exists(function_table, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) {
if (service->type == SOAP_CLASS || service->type == SOAP_OBJECT) {
- call_status = call_user_function(NULL, &soap_obj, &h->function_name, &h->retval, h->num_params, h->parameters TSRMLS_CC);
+ call_status = call_user_function(NULL, soap_obj, &h->function_name, &h->retval, h->num_params, h->parameters TSRMLS_CC);
} else {
call_status = call_user_function(EG(function_table), NULL, &h->function_name, &h->retval, h->num_params, h->parameters TSRMLS_CC);
}
}
if (Z_TYPE(h->retval) == IS_OBJECT &&
instanceof_function(Z_OBJCE(h->retval), soap_fault_class_entry TSRMLS_CC)) {
- zval *headerfault = NULL, **tmp;
+//??? zval *headerfault = NULL;
+ zval *tmp;
- if (zend_hash_find(Z_OBJPROP(h->retval), "headerfault", sizeof("headerfault"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) != IS_NULL) {
- headerfault = *tmp;
+ if ((tmp = zend_hash_str_find(Z_OBJPROP(h->retval), "headerfault", sizeof("headerfault")-1)) != NULL &&
+ Z_TYPE_P(tmp) != IS_NULL) {
+//??? headerfault = tmp;
}
php_output_discard(TSRMLS_C);
soap_server_fault_ex(function, &h->retval, h TSRMLS_CC);
efree(fn_name);
- if (service->type == SOAP_CLASS && soap_obj) {zval_ptr_dtor(&soap_obj);}
+ if (service->type == SOAP_CLASS && soap_obj) {zval_ptr_dtor(soap_obj);}
goto fail;
} else if (EG(exception)) {
+ zval exception_object;
+
+ ZVAL_OBJ(&exception_object, EG(exception));
php_output_discard(TSRMLS_C);
- if (Z_TYPE_P(EG(exception)) == IS_OBJECT &&
- instanceof_function(Z_OBJCE_P(EG(exception)), soap_fault_class_entry TSRMLS_CC)) {
- zval *headerfault = NULL, **tmp;
+ if (instanceof_function(Z_OBJCE(exception_object), soap_fault_class_entry TSRMLS_CC)) {
+//??? zval *headerfault = NULL;
+ zval *tmp;
- if (zend_hash_find(Z_OBJPROP_P(EG(exception)), "headerfault", sizeof("headerfault"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) != IS_NULL) {
- headerfault = *tmp;
+ if ((tmp = zend_hash_str_find(Z_OBJPROP(exception_object), "headerfault", sizeof("headerfault")-1)) != NULL &&
+ Z_TYPE_P(tmp) != IS_NULL) {
+//??? headerfault = tmp;
}
- soap_server_fault_ex(function, EG(exception), h TSRMLS_CC);
+ soap_server_fault_ex(function, &exception_object, h TSRMLS_CC);
}
efree(fn_name);
- if (service->type == SOAP_CLASS && soap_obj) {zval_ptr_dtor(&soap_obj);}
+ if (service->type == SOAP_CLASS && soap_obj) {zval_ptr_dtor(soap_obj);}
goto fail;
}
} else if (h->mustUnderstand) {
}
fn_name = estrndup(Z_STRVAL(function_name),Z_STRLEN(function_name));
- if (zend_hash_exists(function_table, php_strtolower(fn_name, Z_STRLEN(function_name)), Z_STRLEN(function_name) + 1) ||
+ if (zend_hash_str_exists(function_table, php_strtolower(fn_name, Z_STRLEN(function_name)), Z_STRLEN(function_name)) ||
((service->type == SOAP_CLASS || service->type == SOAP_OBJECT) &&
- zend_hash_exists(function_table, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)))) {
+ zend_hash_str_exists(function_table, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) {
if (service->type == SOAP_CLASS || service->type == SOAP_OBJECT) {
- call_status = call_user_function(NULL, &soap_obj, &function_name, retval, num_params, params TSRMLS_CC);
+ call_status = call_user_function(NULL, soap_obj, &function_name, &retval, num_params, params TSRMLS_CC);
if (service->type == SOAP_CLASS) {
#if HAVE_PHP_SESSION && !defined(COMPILE_DL_SESSION)
if (service->soap_class.persistance != SOAP_PERSISTENCE_SESSION) {
- zval_ptr_dtor(&soap_obj);
+ zval_ptr_dtor(soap_obj);
soap_obj = NULL;
}
#else
- zval_ptr_dtor(&soap_obj);
+ zval_ptr_dtor(soap_obj);
soap_obj = NULL;
#endif
}
} else {
- call_status = call_user_function(EG(function_table), NULL, &function_name, retval, num_params, params TSRMLS_CC);
+ call_status = call_user_function(EG(function_table), NULL, &function_name, &retval, num_params, params TSRMLS_CC);
}
} else {
php_error(E_ERROR, "Function '%s' doesn't exist", Z_STRVAL(function_name));
efree(fn_name);
if (EG(exception)) {
+ zval exception_object;
+
+ ZVAL_OBJ(&exception_object, EG(exception));
php_output_discard(TSRMLS_C);
- if (Z_TYPE_P(EG(exception)) == IS_OBJECT &&
- instanceof_function(Z_OBJCE_P(EG(exception)), soap_fault_class_entry TSRMLS_CC)) {
- soap_server_fault_ex(function, EG(exception), NULL TSRMLS_CC);
+ if (instanceof_function(Z_OBJCE(exception_object), soap_fault_class_entry TSRMLS_CC)) {
+ soap_server_fault_ex(function, &exception_object, NULL TSRMLS_CC);
}
if (service->type == SOAP_CLASS) {
#if HAVE_PHP_SESSION && !defined(COMPILE_DL_SESSION)
#else
if (soap_obj) {
#endif
- zval_ptr_dtor(&soap_obj);
+ zval_ptr_dtor(soap_obj);
}
}
goto fail;
if (call_status == SUCCESS) {
char *response_name;
- if (Z_TYPE_P(retval) == IS_OBJECT &&
- instanceof_function(Z_OBJCE_P(retval), soap_fault_class_entry TSRMLS_CC)) {
+ if (Z_TYPE(retval) == IS_OBJECT &&
+ instanceof_function(Z_OBJCE(retval), soap_fault_class_entry TSRMLS_CC)) {
php_output_discard(TSRMLS_C);
- soap_server_fault_ex(function, retval, NULL TSRMLS_CC);
+ soap_server_fault_ex(function, &retval, NULL TSRMLS_CC);
goto fail;
}
memcpy(response_name,Z_STRVAL(function_name),Z_STRLEN(function_name));
memcpy(response_name+Z_STRLEN(function_name),"Response",sizeof("Response"));
}
- doc_return = serialize_response_call(function, response_name, service->uri, retval, soap_headers, soap_version TSRMLS_CC);
+ doc_return = serialize_response_call(function, response_name, service->uri, &retval, soap_headers, soap_version TSRMLS_CC);
efree(response_name);
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Function '%s' call failed", Z_STRVAL(function_name));
}
if (EG(exception)) {
+ zval exception_object;
+
+ ZVAL_OBJ(&exception_object, EG(exception));
php_output_discard(TSRMLS_C);
- if (Z_TYPE_P(EG(exception)) == IS_OBJECT &&
- instanceof_function(Z_OBJCE_P(EG(exception)), soap_fault_class_entry TSRMLS_CC)) {
- soap_server_fault_ex(function, EG(exception), NULL TSRMLS_CC);
+ if (instanceof_function(Z_OBJCE(exception_object), soap_fault_class_entry TSRMLS_CC)) {
+ soap_server_fault_ex(function, &exception_object, NULL TSRMLS_CC);
}
if (service->type == SOAP_CLASS) {
#if HAVE_PHP_SESSION && !defined(COMPILE_DL_SESSION)
#else
if (soap_obj) {
#endif
- zval_ptr_dtor(&soap_obj);
+ zval_ptr_dtor(soap_obj);
}
}
goto fail;
char cont_len[30];
int size;
xmlDocPtr doc_return;
- zval **agent_name;
+ zval *agent_name;
int use_http_error_status = 1;
+ zend_string *server;
soap_version = SOAP_GLOBAL(soap_version);
xmlDocDumpMemory(doc_return, &buf, &size);
- zend_is_auto_global("_SERVER", sizeof("_SERVER") - 1 TSRMLS_CC);
- if (PG(http_globals)[TRACK_VARS_SERVER] &&
- zend_hash_find(PG(http_globals)[TRACK_VARS_SERVER]->value.ht, "HTTP_USER_AGENT", sizeof("HTTP_USER_AGENT"), (void **) &agent_name) == SUCCESS &&
- Z_TYPE_PP(agent_name) == IS_STRING) {
- if (strncmp(Z_STRVAL_PP(agent_name), "Shockwave Flash", sizeof("Shockwave Flash")-1) == 0) {
+ server = STR_INIT("_SERVER", sizeof("_SERVER") - 1, 0);
+ zend_is_auto_global(server TSRMLS_CC);
+ if (Z_TYPE(PG(http_globals)[TRACK_VARS_SERVER]) != IS_UNDEF &&
+ (agent_name = zend_hash_str_find(Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER]), "HTTP_USER_AGENT", sizeof("HTTP_USER_AGENT")-1)) != NULL &&
+ Z_TYPE_P(agent_name) == IS_STRING) {
+ if (strncmp(Z_STRVAL_P(agent_name), "Shockwave Flash", sizeof("Shockwave Flash")-1) == 0) {
use_http_error_status = 0;
}
}
{
zval ret;
- INIT_ZVAL(ret);
-
+ ZVAL_NULL(&ret);
set_soap_fault(&ret, NULL, code, string, actor, details, name TSRMLS_CC);
/* TODO: Which function */
soap_server_fault_ex(NULL, &ret, NULL TSRMLS_CC);
if (SOAP_GLOBAL(error_object) &&
Z_TYPE_P(SOAP_GLOBAL(error_object)) == IS_OBJECT &&
instanceof_function(Z_OBJCE_P(SOAP_GLOBAL(error_object)), soap_class_entry TSRMLS_CC)) {
- zval **tmp;
+ zval *tmp;
int use_exceptions = 0;
- if (zend_hash_find(Z_OBJPROP_P(SOAP_GLOBAL(error_object)), "_exceptions", sizeof("_exceptions"), (void **) &tmp) != SUCCESS ||
- Z_TYPE_PP(tmp) != IS_BOOL || Z_LVAL_PP(tmp) != 0) {
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(SOAP_GLOBAL(error_object)), "_exceptions", sizeof("_exceptions")-1)) == NULL ||
+ Z_TYPE_P(tmp) != IS_FALSE) {
use_exceptions = 1;
}
error_num == E_ERROR ||
error_num == E_PARSE) &&
use_exceptions) {
- zval *fault, *exception;
+ zval *fault;
char* code = SOAP_GLOBAL(error_code);
char buffer[1024];
int buffer_len;
- zval outbuf, outbuflen;
+//??? zval outbuf, outbuflen;
#ifdef va_copy
va_list argcopy;
#endif
- zend_object_store_bucket *old_objects;
+//??? zend_object_store_bucket *old_objects;
int old = PG(display_errors);
- INIT_ZVAL(outbuf);
- INIT_ZVAL(outbuflen);
+//??? INIT_ZVAL(outbuf);
+//??? INIT_ZVAL(outbuflen);
#ifdef va_copy
va_copy(argcopy, args);
buffer_len = vslprintf(buffer, sizeof(buffer)-1, format, argcopy);
code = "Client";
}
fault = add_soap_fault(SOAP_GLOBAL(error_object), code, buffer, NULL, NULL TSRMLS_CC);
- MAKE_STD_ZVAL(exception);
- MAKE_COPY_ZVAL(&fault, exception);
- zend_throw_exception_object(exception TSRMLS_CC);
+ Z_ADDREF_P(fault);
+ zend_throw_exception_object(fault TSRMLS_CC);
- old_objects = EG(objects_store).object_buckets;
- EG(objects_store).object_buckets = NULL;
+//??? old_objects = EG(objects_store).object_buckets;
+//??? EG(objects_store).object_buckets = NULL;
PG(display_errors) = 0;
SG(sapi_headers).http_status_line = NULL;
zend_try {
SG(sapi_headers).http_status_line = _old_http_status_line;
SG(sapi_headers).http_response_code = _old_http_response_code;
} zend_end_try();
- EG(objects_store).object_buckets = old_objects;
+//??? EG(objects_store).object_buckets = old_objects;
PG(display_errors) = old;
zend_bailout();
} else if (!use_exceptions ||
char* code = SOAP_GLOBAL(error_code);
char buffer[1024];
- zval *outbuf = NULL;
- zval **tmp;
+ zval outbuf;
+ zval *tmp;
soapServicePtr service;
+ ZVAL_UNDEF(&outbuf);
if (code == NULL) {
code = "Server";
}
if (SOAP_GLOBAL(error_object) &&
Z_TYPE_P(SOAP_GLOBAL(error_object)) == IS_OBJECT &&
instanceof_function(Z_OBJCE_P(SOAP_GLOBAL(error_object)), soap_server_class_entry TSRMLS_CC) &&
- zend_hash_find(Z_OBJPROP_P(SOAP_GLOBAL(error_object)), "service", sizeof("service"), (void **)&tmp) != FAILURE &&
+ (tmp = zend_hash_str_find(Z_OBJPROP_P(SOAP_GLOBAL(error_object)), "service", sizeof("service")-1)) != NULL &&
(service = (soapServicePtr)zend_fetch_resource(tmp TSRMLS_CC, -1, "service", NULL, 1, le_service)) &&
!service->send_errors) {
strcpy(buffer, "Internal Error");
int buffer_len;
zval outbuflen;
- INIT_ZVAL(outbuflen);
+//??? INIT_ZVAL(outbuflen);
#ifdef va_copy
va_copy(argcopy, args);
/* Get output buffer and send as fault detials */
if (php_output_get_length(&outbuflen TSRMLS_CC) != FAILURE && Z_LVAL(outbuflen) != 0) {
- ALLOC_INIT_ZVAL(outbuf);
- php_output_get_contents(outbuf TSRMLS_CC);
+ php_output_get_contents(&outbuf TSRMLS_CC);
}
php_output_discard(TSRMLS_C);
}
- INIT_ZVAL(fault_obj);
- set_soap_fault(&fault_obj, NULL, code, buffer, NULL, outbuf, NULL TSRMLS_CC);
+ set_soap_fault(&fault_obj, NULL, code, buffer, NULL, &outbuf, NULL TSRMLS_CC);
fault = 1;
}
long cache_wsdl;
sdlPtr sdl = NULL;
HashTable *typemap_ht = NULL;
+ zval *this_ptr = getThis();
SOAP_CLIENT_BEGIN_CODE();
if (options != NULL) {
HashTable *ht = Z_ARRVAL_P(options);
- zval **tmp;
+ zval *tmp;
if (Z_TYPE_P(wsdl) == IS_NULL) {
/* Fetching non-WSDL mode options */
- if (zend_hash_find(ht, "uri", sizeof("uri"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- add_property_stringl(this_ptr, "uri", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ if ((tmp = zend_hash_str_find(ht, "uri", sizeof("uri")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ add_property_str(this_ptr, "uri", STR_COPY(Z_STR_P(tmp)));
} else {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "'uri' option is required in nonWSDL mode");
}
- if (zend_hash_find(ht, "style", sizeof("style"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_LONG &&
- (Z_LVAL_PP(tmp) == SOAP_RPC || Z_LVAL_PP(tmp) == SOAP_DOCUMENT)) {
- add_property_long(this_ptr, "style", Z_LVAL_PP(tmp));
+ if ((tmp = zend_hash_str_find(ht, "style", sizeof("style")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_LONG &&
+ (Z_LVAL_P(tmp) == SOAP_RPC || Z_LVAL_P(tmp) == SOAP_DOCUMENT)) {
+ add_property_long(this_ptr, "style", Z_LVAL_P(tmp));
}
- if (zend_hash_find(ht, "use", sizeof("use"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_LONG &&
- (Z_LVAL_PP(tmp) == SOAP_LITERAL || Z_LVAL_PP(tmp) == SOAP_ENCODED)) {
- add_property_long(this_ptr, "use", Z_LVAL_PP(tmp));
+ if ((tmp = zend_hash_str_find(ht, "use", sizeof("use")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_LONG &&
+ (Z_LVAL_P(tmp) == SOAP_LITERAL || Z_LVAL_P(tmp) == SOAP_ENCODED)) {
+ add_property_long(this_ptr, "use", Z_LVAL_P(tmp));
}
}
- if (zend_hash_find(ht, "stream_context", sizeof("stream_context"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_RESOURCE) {
- context = php_stream_context_from_zval(*tmp, 1);
- zend_list_addref(context->rsrc_id);
+ if ((tmp = zend_hash_str_find(ht, "stream_context", sizeof("stream_context")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_RESOURCE) {
+ context = php_stream_context_from_zval(tmp, 1);
+ Z_ADDREF_P(tmp);
}
- if (zend_hash_find(ht, "location", sizeof("location"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- add_property_stringl(this_ptr, "location", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ if ((tmp = zend_hash_str_find(ht, "location", sizeof("location")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ add_property_str(this_ptr, "location", STR_COPY(Z_STR_P(tmp)));
} else if (Z_TYPE_P(wsdl) == IS_NULL) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "'location' option is required in nonWSDL mode");
}
- if (zend_hash_find(ht, "soap_version", sizeof("soap_version"), (void**)&tmp) == SUCCESS) {
- if (Z_TYPE_PP(tmp) == IS_LONG ||
- (Z_LVAL_PP(tmp) == SOAP_1_1 && Z_LVAL_PP(tmp) == SOAP_1_2)) {
- soap_version = Z_LVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(ht, "soap_version", sizeof("soap_version")-1)) != NULL) {
+ if (Z_TYPE_P(tmp) == IS_LONG ||
+ (Z_LVAL_P(tmp) == SOAP_1_1 && Z_LVAL_P(tmp) == SOAP_1_2)) {
+ soap_version = Z_LVAL_P(tmp);
}
}
- if (zend_hash_find(ht, "login", sizeof("login"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- add_property_stringl(this_ptr, "_login", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
- if (zend_hash_find(ht, "password", sizeof("password"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- add_property_stringl(this_ptr, "_password", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ if ((tmp = zend_hash_str_find(ht, "login", sizeof("login")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ add_property_str(this_ptr, "_login", STR_COPY(Z_STR_P(tmp)));
+ if ((tmp = zend_hash_str_find(ht, "password", sizeof("password")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ add_property_str(this_ptr, "_password", STR_COPY(Z_STR_P(tmp)));
}
- if (zend_hash_find(ht, "authentication", sizeof("authentication"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_LONG &&
- Z_LVAL_PP(tmp) == SOAP_AUTHENTICATION_DIGEST) {
+ if ((tmp = zend_hash_str_find(ht, "authentication", sizeof("authentication")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_LONG &&
+ Z_LVAL_P(tmp) == SOAP_AUTHENTICATION_DIGEST) {
add_property_null(this_ptr, "_digest");
}
}
- if (zend_hash_find(ht, "proxy_host", sizeof("proxy_host"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- add_property_stringl(this_ptr, "_proxy_host", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
- if (zend_hash_find(ht, "proxy_port", sizeof("proxy_port"), (void**)&tmp) == SUCCESS) {
- convert_to_long(*tmp);
- add_property_long(this_ptr, "_proxy_port", Z_LVAL_PP(tmp));
+ if ((tmp = zend_hash_str_find(ht, "proxy_host", sizeof("proxy_host")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ add_property_str(this_ptr, "_proxy_host", STR_COPY(Z_STR_P(tmp)));
+ if ((tmp = zend_hash_str_find(ht, "proxy_port", sizeof("proxy_port")-1)) != NULL) {
+ convert_to_long(tmp);
+ add_property_long(this_ptr, "_proxy_port", Z_LVAL_P(tmp));
}
- if (zend_hash_find(ht, "proxy_login", sizeof("proxy_login"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- add_property_stringl(this_ptr, "_proxy_login", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
- if (zend_hash_find(ht, "proxy_password", sizeof("proxy_password"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- add_property_stringl(this_ptr, "_proxy_password", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ if ((tmp = zend_hash_str_find(ht, "proxy_login", sizeof("proxy_login")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ add_property_str(this_ptr, "_proxy_login", STR_COPY(Z_STR_P(tmp)));
+ if ((tmp = zend_hash_str_find(ht, "proxy_password", sizeof("proxy_password")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ add_property_str(this_ptr, "_proxy_password", STR_COPY(Z_STR_P(tmp)));
}
}
}
- if (zend_hash_find(ht, "local_cert", sizeof("local_cert"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
+ if ((tmp = zend_hash_str_find(ht, "local_cert", sizeof("local_cert")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
if (!context) {
context = php_stream_context_alloc(TSRMLS_C);
}
- php_stream_context_set_option(context, "ssl", "local_cert", *tmp);
- if (zend_hash_find(ht, "passphrase", sizeof("passphrase"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- php_stream_context_set_option(context, "ssl", "passphrase", *tmp);
+ php_stream_context_set_option(context, "ssl", "local_cert", tmp);
+ if ((tmp = zend_hash_str_find(ht, "passphrase", sizeof("passphrase")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ php_stream_context_set_option(context, "ssl", "passphrase", tmp);
}
}
- if (zend_hash_find(ht, "trace", sizeof("trace"), (void**)&tmp) == SUCCESS &&
- (Z_TYPE_PP(tmp) == IS_BOOL || Z_TYPE_PP(tmp) == IS_LONG) &&
- Z_LVAL_PP(tmp) == 1) {
+ if ((tmp = zend_hash_str_find(ht, "trace", sizeof("trace")-1)) != NULL &&
+ (Z_TYPE_P(tmp) == IS_TRUE ||
+ (Z_TYPE_P(tmp) == IS_LONG && Z_LVAL_P(tmp) == 1))) {
add_property_long(this_ptr, "trace", 1);
}
- if (zend_hash_find(ht, "exceptions", sizeof("exceptions"), (void**)&tmp) == SUCCESS &&
- (Z_TYPE_PP(tmp) == IS_BOOL || Z_TYPE_PP(tmp) == IS_LONG) &&
- Z_LVAL_PP(tmp) == 0) {
+ if ((tmp = zend_hash_str_find(ht, "exceptions", sizeof("exceptions")-1)) != NULL &&
+ (Z_TYPE_P(tmp) == IS_FALSE ||
+ (Z_TYPE_P(tmp) == IS_LONG && Z_LVAL_P(tmp) == 0))) {
add_property_bool(this_ptr, "_exceptions", 0);
}
- if (zend_hash_find(ht, "compression", sizeof("compression"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_LONG &&
- zend_hash_exists(EG(function_table), "gzinflate", sizeof("gzinflate")) &&
- zend_hash_exists(EG(function_table), "gzdeflate", sizeof("gzdeflate")) &&
- zend_hash_exists(EG(function_table), "gzuncompress", sizeof("gzuncompress")) &&
- zend_hash_exists(EG(function_table), "gzcompress", sizeof("gzcompress")) &&
- zend_hash_exists(EG(function_table), "gzencode", sizeof("gzencode"))) {
- add_property_long(this_ptr, "compression", Z_LVAL_PP(tmp));
+ if ((tmp = zend_hash_str_find(ht, "compression", sizeof("compression")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_LONG &&
+ zend_hash_str_exists(EG(function_table), "gzinflate", sizeof("gzinflate")-1) &&
+ zend_hash_str_exists(EG(function_table), "gzdeflate", sizeof("gzdeflate")-1) &&
+ zend_hash_str_exists(EG(function_table), "gzuncompress", sizeof("gzuncompress")-1) &&
+ zend_hash_str_exists(EG(function_table), "gzcompress", sizeof("gzcompress")-1) &&
+ zend_hash_str_exists(EG(function_table), "gzencode", sizeof("gzencode")-1)) {
+ add_property_long(this_ptr, "compression", Z_LVAL_P(tmp));
}
- if (zend_hash_find(ht, "encoding", sizeof("encoding"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
+ if ((tmp = zend_hash_str_find(ht, "encoding", sizeof("encoding")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
xmlCharEncodingHandlerPtr encoding;
- encoding = xmlFindCharEncodingHandler(Z_STRVAL_PP(tmp));
+ encoding = xmlFindCharEncodingHandler(Z_STRVAL_P(tmp));
if (encoding == NULL) {
- php_error_docref(NULL TSRMLS_CC, E_ERROR, "Invalid 'encoding' option - '%s'", Z_STRVAL_PP(tmp));
+ php_error_docref(NULL TSRMLS_CC, E_ERROR, "Invalid 'encoding' option - '%s'", Z_STRVAL_P(tmp));
} else {
xmlCharEncCloseFunc(encoding);
- add_property_stringl(this_ptr, "_encoding", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ add_property_str(this_ptr, "_encoding", STR_COPY(Z_STR_P(tmp)));
}
}
- if (zend_hash_find(ht, "classmap", sizeof("classmap"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_ARRAY) {
- zval *class_map;
-
- MAKE_STD_ZVAL(class_map);
- MAKE_COPY_ZVAL(tmp, class_map);
- Z_DELREF_P(class_map);
-
- add_property_zval(this_ptr, "_classmap", class_map);
+ if ((tmp = zend_hash_str_find(ht, "classmap", sizeof("classmap")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_ARRAY) {
+//??? zval *class_map;
+//???
+//??? MAKE_STD_ZVAL(class_map);
+//??? MAKE_COPY_ZVAL(tmp, class_map);
+//??? Z_DELREF_P(class_map);
+//???
+ add_property_zval(this_ptr, "_classmap", tmp);
}
- if (zend_hash_find(ht, "typemap", sizeof("typemap"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_ARRAY &&
- zend_hash_num_elements(Z_ARRVAL_PP(tmp)) > 0) {
- typemap_ht = Z_ARRVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(ht, "typemap", sizeof("typemap")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_ARRAY &&
+ zend_hash_num_elements(Z_ARRVAL_P(tmp)) > 0) {
+ typemap_ht = Z_ARRVAL_P(tmp);
}
- if (zend_hash_find(ht, "features", sizeof("features"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_LONG) {
- add_property_long(this_ptr, "_features", Z_LVAL_PP(tmp));
+ if ((tmp = zend_hash_str_find(ht, "features", sizeof("features")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_LONG) {
+ add_property_long(this_ptr, "_features", Z_LVAL_P(tmp));
}
- if (zend_hash_find(ht, "connection_timeout", sizeof("connection_timeout"), (void**)&tmp) == SUCCESS) {
- convert_to_long(*tmp);
- if (Z_LVAL_PP(tmp) > 0) {
- add_property_long(this_ptr, "_connection_timeout", Z_LVAL_PP(tmp));
+ if ((tmp = zend_hash_str_find(ht, "connection_timeout", sizeof("connection_timeout")-1)) != NULL) {
+ convert_to_long(tmp);
+ if (Z_LVAL_P(tmp) > 0) {
+ add_property_long(this_ptr, "_connection_timeout", Z_LVAL_P(tmp));
}
}
if (context) {
- add_property_resource(this_ptr, "_stream_context", context->rsrc_id);
+ add_property_resource(this_ptr, "_stream_context", context->res);
}
- if (zend_hash_find(ht, "cache_wsdl", sizeof("cache_wsdl"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_LONG) {
- cache_wsdl = Z_LVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(ht, "cache_wsdl", sizeof("cache_wsdl")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_LONG) {
+ cache_wsdl = Z_LVAL_P(tmp);
}
- if (zend_hash_find(ht, "user_agent", sizeof("user_agent"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- add_property_stringl(this_ptr, "_user_agent", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ if ((tmp = zend_hash_str_find(ht, "user_agent", sizeof("user_agent")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ add_property_str(this_ptr, "_user_agent", STR_COPY(Z_STR_P(tmp)));
}
- if (zend_hash_find(ht, "keep_alive", sizeof("keep_alive"), (void**)&tmp) == SUCCESS &&
- (Z_TYPE_PP(tmp) == IS_BOOL || Z_TYPE_PP(tmp) == IS_LONG) && Z_LVAL_PP(tmp) == 0) {
+ if ((tmp = zend_hash_str_find(ht, "keep_alive", sizeof("keep_alive")-1)) != NULL &&
+ (Z_TYPE_P(tmp) == IS_FALSE ||
+ (Z_TYPE_P(tmp) == IS_LONG && Z_LVAL_P(tmp) == 0))) {
add_property_long(this_ptr, "_keep_alive", 0);
}
- if (zend_hash_find(ht, "ssl_method", sizeof("ssl_method"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_LONG) {
- add_property_long(this_ptr, "_ssl_method", Z_LVAL_PP(tmp));
+ if ((tmp = zend_hash_str_find(ht, "ssl_method", sizeof("ssl_method")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_LONG) {
+ add_property_long(this_ptr, "_ssl_method", Z_LVAL_P(tmp));
}
} else if (Z_TYPE_P(wsdl) == IS_NULL) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "'location' and 'uri' options are required in nonWSDL mode");
add_property_long(this_ptr, "_soap_version", soap_version);
if (Z_TYPE_P(wsdl) != IS_NULL) {
- int old_soap_version, ret;
+ int old_soap_version;
+ zend_resource *res;
old_soap_version = SOAP_GLOBAL(soap_version);
SOAP_GLOBAL(soap_version) = soap_version;
sdl = get_sdl(this_ptr, Z_STRVAL_P(wsdl), cache_wsdl TSRMLS_CC);
- ret = zend_list_insert(sdl, le_sdl TSRMLS_CC);
+ res = zend_register_resource(NULL, sdl, le_sdl TSRMLS_CC);
- add_property_resource(this_ptr, "sdl", ret);
+ add_property_resource(this_ptr, "sdl", res);
SOAP_GLOBAL(soap_version) = old_soap_version;
}
if (typemap_ht) {
HashTable *typemap = soap_create_typemap(sdl, typemap_ht TSRMLS_CC);
if (typemap) {
- int ret;
+ zend_resource *res;
- ret = zend_list_insert(typemap, le_typemap TSRMLS_CC);
- add_property_resource(this_ptr, "typemap", ret);
+ res = zend_register_resource(NULL, typemap, le_typemap TSRMLS_CC);
+ add_property_resource(this_ptr, "typemap", res);
}
}
SOAP_CLIENT_END_CODE();
char *buf;
int buf_size;
zval func;
- zval *params[5];
- zval **trace;
- zval **fault;
+ zval params[5];
+ zval *trace;
+ zval *fault;
- INIT_ZVAL(*response);
+ ZVAL_NULL(response);
xmlDocDumpMemory(request, (xmlChar**)&buf, &buf_size);
if (!buf) {
return FALSE;
}
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace"), (void **) &trace) == SUCCESS &&
- Z_LVAL_PP(trace) > 0) {
+ if ((trace = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace")-1)) != NULL &&
+ Z_LVAL_P(trace) > 0) {
add_property_stringl(this_ptr, "__last_request", buf, buf_size);
}
- INIT_ZVAL(func);
- ZVAL_STRINGL(&func,"__doRequest",sizeof("__doRequest")-1,0);
- ALLOC_INIT_ZVAL(params[0]);
- ZVAL_STRINGL(params[0], buf, buf_size, 1);
- ALLOC_INIT_ZVAL(params[1]);
+ ZVAL_STRINGL(&func,"__doRequest",sizeof("__doRequest")-1);
+ ZVAL_STRINGL(¶ms[0], buf, buf_size);
if (location == NULL) {
- ZVAL_NULL(params[1]);
+ ZVAL_NULL(¶ms[1]);
} else {
- ZVAL_STRING(params[1], location, 1);
+ ZVAL_STRING(¶ms[1], location);
}
- ALLOC_INIT_ZVAL(params[2]);
if (action == NULL) {
- ZVAL_NULL(params[2]);
+ ZVAL_NULL(¶ms[2]);
} else {
- ZVAL_STRING(params[2], action, 1);
+ ZVAL_STRING(¶ms[2], action);
}
- ALLOC_INIT_ZVAL(params[3]);
- ZVAL_LONG(params[3], version);
+ ZVAL_LONG(¶ms[3], version);
+ ZVAL_LONG(¶ms[4], one_way);
- ALLOC_INIT_ZVAL(params[4]);
- ZVAL_LONG(params[4], one_way);
-
- if (call_user_function(NULL, &this_ptr, &func, response, 5, params TSRMLS_CC) != SUCCESS) {
+ if (call_user_function(NULL, this_ptr, &func, response, 5, params TSRMLS_CC) != SUCCESS) {
add_soap_fault(this_ptr, "Client", "SoapClient::__doRequest() failed", NULL, NULL TSRMLS_CC);
ret = FALSE;
} else if (Z_TYPE_P(response) != IS_STRING) {
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "__soap_fault", sizeof("__soap_fault"), (void **) &fault) == FAILURE) {
+ if ((fault = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "__soap_fault", sizeof("__soap_fault")-1)) == NULL) {
add_soap_fault(this_ptr, "Client", "SoapClient::__doRequest() returned non string value", NULL, NULL TSRMLS_CC);
}
ret = FALSE;
- } else if (zend_hash_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace"), (void **) &trace) == SUCCESS &&
- Z_LVAL_PP(trace) > 0) {
- add_property_stringl(this_ptr, "__last_response", Z_STRVAL_P(response), Z_STRLEN_P(response));
+ } else if ((trace = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace")-1)) != NULL &&
+ Z_LVAL_P(trace) > 0) {
+ add_property_str(this_ptr, "__last_response", STR_COPY(Z_STR_P(response)));
}
+ zval_ptr_dtor(&func);
zval_ptr_dtor(¶ms[4]);
zval_ptr_dtor(¶ms[3]);
zval_ptr_dtor(¶ms[2]);
zval_ptr_dtor(¶ms[1]);
zval_ptr_dtor(¶ms[0]);
xmlFree(buf);
- if (ret && zend_hash_find(Z_OBJPROP_P(this_ptr), "__soap_fault", sizeof("__soap_fault"), (void **) &fault) == SUCCESS) {
+ if (ret && (fault = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "__soap_fault", sizeof("__soap_fault")-1)) != NULL) {
return FALSE;
}
return ret;
char* function,
int function_len,
int arg_count,
- zval** real_args,
+ zval* real_args,
zval* return_value,
char* location,
char* soap_action,
zval* output_headers
TSRMLS_DC)
{
- zval **tmp;
- zval **trace;
+ zval *tmp;
+ zval *trace;
sdlPtr sdl = NULL;
sdlPtr old_sdl = NULL;
sdlFunctionPtr fn;
SOAP_CLIENT_BEGIN_CODE();
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace"), (void **) &trace) == SUCCESS
- && Z_LVAL_PP(trace) > 0) {
- zend_hash_del(Z_OBJPROP_P(this_ptr), "__last_request", sizeof("__last_request"));
- zend_hash_del(Z_OBJPROP_P(this_ptr), "__last_response", sizeof("__last_response"));
+ if ((trace = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace")-1)) != NULL
+ && Z_LVAL_P(trace) > 0) {
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "__last_request", sizeof("__last_request")-1);
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "__last_response", sizeof("__last_response")-1);
}
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_soap_version", sizeof("_soap_version"), (void **) &tmp) == SUCCESS
- && Z_LVAL_PP(tmp) == SOAP_1_2) {
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_soap_version", sizeof("_soap_version")-1)) != NULL
+ && Z_LVAL_P(tmp) == SOAP_1_2) {
soap_version = SOAP_1_2;
} else {
soap_version = SOAP_1_1;
}
if (location == NULL) {
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "location", sizeof("location"),(void **) &tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- location = Z_STRVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "location", sizeof("location")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ location = Z_STRVAL_P(tmp);
}
}
- if (FIND_SDL_PROPERTY(this_ptr,tmp) != FAILURE) {
+ if (FIND_SDL_PROPERTY(this_ptr,tmp) != NULL) {
FETCH_SDL_RES(sdl,tmp);
}
- if (FIND_TYPEMAP_PROPERTY(this_ptr,tmp) != FAILURE) {
+ if (FIND_TYPEMAP_PROPERTY(this_ptr,tmp) != NULL) {
FETCH_TYPEMAP_RES(typemap,tmp);
}
old_sdl = SOAP_GLOBAL(sdl);
SOAP_GLOBAL(sdl) = sdl;
old_encoding = SOAP_GLOBAL(encoding);
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_encoding", sizeof("_encoding"), (void **) &tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- SOAP_GLOBAL(encoding) = xmlFindCharEncodingHandler(Z_STRVAL_PP(tmp));
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_encoding", sizeof("_encoding")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ SOAP_GLOBAL(encoding) = xmlFindCharEncodingHandler(Z_STRVAL_P(tmp));
} else {
SOAP_GLOBAL(encoding) = NULL;
}
old_class_map = SOAP_GLOBAL(class_map);
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_classmap", sizeof("_classmap"), (void **) &tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_ARRAY) {
- SOAP_GLOBAL(class_map) = (*tmp)->value.ht;
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_classmap", sizeof("_classmap")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_ARRAY) {
+ SOAP_GLOBAL(class_map) = Z_ARRVAL_P(tmp);
} else {
SOAP_GLOBAL(class_map) = NULL;
}
old_typemap = SOAP_GLOBAL(typemap);
SOAP_GLOBAL(typemap) = typemap;
old_features = SOAP_GLOBAL(features);
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_features", sizeof("_features"), (void **) &tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_LONG) {
- SOAP_GLOBAL(features) = Z_LVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_features", sizeof("_features")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_LONG) {
+ SOAP_GLOBAL(features) = Z_LVAL_P(tmp);
} else {
SOAP_GLOBAL(features) = 0;
}
smart_str_appends(&error,function);
smart_str_appends(&error,"\") is not a valid method for this service");
smart_str_0(&error);
- add_soap_fault(this_ptr, "Client", error.c, NULL, NULL TSRMLS_CC);
+ add_soap_fault(this_ptr, "Client", error.s->val, NULL, NULL TSRMLS_CC);
smart_str_free(&error);
}
} else {
- zval **uri;
+ zval *uri;
smart_str action = {0};
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "uri", sizeof("uri"), (void *)&uri) == FAILURE) {
+ if ((uri = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "uri", sizeof("uri")-1)) == NULL) {
add_soap_fault(this_ptr, "Client", "Error finding \"uri\" property", NULL, NULL TSRMLS_CC);
} else if (location == NULL) {
add_soap_fault(this_ptr, "Client", "Error could not find \"location\" property", NULL, NULL TSRMLS_CC);
} else {
if (call_uri == NULL) {
- call_uri = Z_STRVAL_PP(uri);
+ call_uri = Z_STRVAL_P(uri);
}
request = serialize_function_call(this_ptr, NULL, function, call_uri, real_args, arg_count, soap_version, soap_headers TSRMLS_CC);
}
smart_str_0(&action);
- ret = do_request(this_ptr, request, location, action.c, soap_version, 0, &response TSRMLS_CC);
+ ret = do_request(this_ptr, request, location, action.s->val, soap_version, 0, &response TSRMLS_CC);
smart_str_free(&action);
xmlFreeDoc(request);
}
if (!ret) {
- zval** fault;
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "__soap_fault", sizeof("__soap_fault"), (void **) &fault) == SUCCESS) {
- *return_value = **fault;
- zval_copy_ctor(return_value);
+ zval* fault;
+ if ((fault = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "__soap_fault", sizeof("__soap_fault")-1)) != NULL) {
+ ZVAL_COPY(return_value, fault);
} else {
- *return_value = *add_soap_fault(this_ptr, "Client", "Unknown Error", NULL, NULL TSRMLS_CC);
- zval_copy_ctor(return_value);
+ ZVAL_COPY(return_value, add_soap_fault(this_ptr, "Client", "Unknown Error", NULL, NULL TSRMLS_CC));
}
} else {
- zval** fault;
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "__soap_fault", sizeof("__soap_fault"), (void **) &fault) == SUCCESS) {
- *return_value = **fault;
- zval_copy_ctor(return_value);
+ zval* fault;
+ if ((fault = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "__soap_fault", sizeof("__soap_fault")-1)) != NULL) {
+ ZVAL_COPY(return_value, fault);
}
}
if (!EG(exception) &&
Z_TYPE_P(return_value) == IS_OBJECT &&
instanceof_function(Z_OBJCE_P(return_value), soap_fault_class_entry TSRMLS_CC) &&
- (zend_hash_find(Z_OBJPROP_P(this_ptr), "_exceptions", sizeof("_exceptions"), (void **) &tmp) != SUCCESS ||
- Z_TYPE_PP(tmp) != IS_BOOL || Z_LVAL_PP(tmp) != 0)) {
- zval *exception;
-
- MAKE_STD_ZVAL(exception);
- MAKE_COPY_ZVAL(&return_value, exception);
- zend_throw_exception_object(exception TSRMLS_CC);
+ ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_exceptions", sizeof("_exceptions")-1)) == NULL ||
+ Z_TYPE_P(tmp) != IS_FALSE)) {
+ Z_ADDREF_P(return_value);
+ zend_throw_exception_object(return_value TSRMLS_CC);
}
} zend_catch {
static void verify_soap_headers_array(HashTable *ht TSRMLS_DC)
{
- zval **tmp;
+ zval *tmp;
- zend_hash_internal_pointer_reset(ht);
- while (zend_hash_get_current_data(ht, (void**)&tmp) == SUCCESS) {
- if (Z_TYPE_PP(tmp) != IS_OBJECT ||
- !instanceof_function(Z_OBJCE_PP(tmp), soap_header_class_entry TSRMLS_CC)) {
+ ZEND_HASH_FOREACH_VAL(ht, tmp) {
+ if (Z_TYPE_P(tmp) != IS_OBJECT ||
+ !instanceof_function(Z_OBJCE_P(tmp), soap_header_class_entry TSRMLS_CC)) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Invalid SOAP header");
}
- zend_hash_move_forward(ht);
- }
+ } ZEND_HASH_FOREACH_END();
}
zval *headers = NULL;
zval *output_headers = NULL;
zval *args;
- zval **real_args = NULL;
- zval **param;
+ zval *real_args = NULL;
+ zval *param;
int arg_count;
- zval **tmp;
+ zval *tmp;
zend_bool free_soap_headers = 0;
-
- HashPosition pos;
+ zval *this_ptr;
+//??? HashPosition pos;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa|a!zz",
&function, &function_len, &args, &options, &headers, &output_headers) == FAILURE) {
if (options) {
HashTable *hto = Z_ARRVAL_P(options);
- if (zend_hash_find(hto, "location", sizeof("location"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- location = Z_STRVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(hto, "location", sizeof("location")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ location = Z_STRVAL_P(tmp);
}
- if (zend_hash_find(hto, "soapaction", sizeof("soapaction"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- soap_action = Z_STRVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(hto, "soapaction", sizeof("soapaction")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ soap_action = Z_STRVAL_P(tmp);
}
- if (zend_hash_find(hto, "uri", sizeof("uri"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- uri = Z_STRVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(hto, "uri", sizeof("uri")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ uri = Z_STRVAL_P(tmp);
}
}
instanceof_function(Z_OBJCE_P(headers), soap_header_class_entry TSRMLS_CC)) {
soap_headers = emalloc(sizeof(HashTable));
zend_hash_init(soap_headers, 0, NULL, ZVAL_PTR_DTOR, 0);
- zend_hash_next_index_insert(soap_headers, &headers, sizeof(zval*), NULL);
+ zend_hash_next_index_insert(soap_headers, headers);
Z_ADDREF_P(headers);
free_soap_headers = 1;
} else{
}
/* Add default headers */
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "__default_headers", sizeof("__default_headers"), (void **) &tmp)==SUCCESS) {
- HashTable *default_headers = Z_ARRVAL_P(*tmp);
+ this_ptr = getThis();
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "__default_headers", sizeof("__default_headers")-1)) != NULL) {
+ HashTable *default_headers = Z_ARRVAL_P(tmp);
if (soap_headers) {
if (!free_soap_headers) {
HashTable *t = emalloc(sizeof(HashTable));
zend_hash_init(t, 0, NULL, ZVAL_PTR_DTOR, 0);
- zend_hash_copy(t, soap_headers, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
+ zend_hash_copy(t, soap_headers, zval_add_ref);
soap_headers = t;
free_soap_headers = 1;
}
- zend_hash_internal_pointer_reset(default_headers);
- while (zend_hash_get_current_data(default_headers, (void**)&tmp) == SUCCESS) {
- Z_ADDREF_PP(tmp);
- zend_hash_next_index_insert(soap_headers, tmp, sizeof(zval *), NULL);
- zend_hash_move_forward(default_headers);
- }
+ ZEND_HASH_FOREACH_VAL(default_headers, tmp) {
+ Z_ADDREF_P(tmp);
+ zend_hash_next_index_insert(soap_headers, tmp);
+ } ZEND_HASH_FOREACH_END();
} else {
- soap_headers = Z_ARRVAL_P(*tmp);
+ soap_headers = Z_ARRVAL_P(tmp);
free_soap_headers = 0;
}
}
arg_count = zend_hash_num_elements(Z_ARRVAL_P(args));
if (arg_count > 0) {
- real_args = safe_emalloc(sizeof(zval *), arg_count, 0);
- for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(args), &pos);
- zend_hash_get_current_data_ex(Z_ARRVAL_P(args), (void **) ¶m, &pos) == SUCCESS;
- zend_hash_move_forward_ex(Z_ARRVAL_P(args), &pos)) {
- /*zval_add_ref(param);*/
- real_args[i++] = *param;
- }
+ real_args = safe_emalloc(sizeof(zval), arg_count, 0);
+ ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(args), param) {
+ /*zval_add_ref(param);*/
+ ZVAL_COPY_VALUE(&real_args[i], param);
+ i++;
+ } ZEND_HASH_FOREACH_END();
}
if (output_headers) {
array_init(output_headers);
PHP_METHOD(SoapClient, __getFunctions)
{
sdlPtr sdl;
- HashPosition pos;
FETCH_THIS_SDL(sdl);
if (sdl) {
smart_str buf = {0};
- sdlFunctionPtr *function;
+ sdlFunctionPtr function;
array_init(return_value);
- zend_hash_internal_pointer_reset_ex(&sdl->functions, &pos);
- while (zend_hash_get_current_data_ex(&sdl->functions, (void **)&function, &pos) != FAILURE) {
- function_to_string((*function), &buf);
- add_next_index_stringl(return_value, buf.c, buf.len);
- smart_str_free(&buf);
- zend_hash_move_forward_ex(&sdl->functions, &pos);
- }
+ ZEND_HASH_FOREACH_PTR(&sdl->functions, function) {
+ function_to_string(function, &buf);
+ add_next_index_str(return_value, buf.s);
+ } ZEND_HASH_FOREACH_END();
}
}
/* }}} */
PHP_METHOD(SoapClient, __getTypes)
{
sdlPtr sdl;
- HashPosition pos;
FETCH_THIS_SDL(sdl);
}
if (sdl) {
- sdlTypePtr *type;
+ sdlTypePtr type;
smart_str buf = {0};
array_init(return_value);
if (sdl->types) {
- zend_hash_internal_pointer_reset_ex(sdl->types, &pos);
- while (zend_hash_get_current_data_ex(sdl->types, (void **)&type, &pos) != FAILURE) {
- type_to_string((*type), &buf, 0);
- add_next_index_stringl(return_value, buf.c, buf.len);
- smart_str_free(&buf);
- zend_hash_move_forward_ex(sdl->types, &pos);
- }
+ ZEND_HASH_FOREACH_PTR(sdl->types, type) {
+ type_to_string(type, &buf, 0);
+ add_next_index_str(return_value, buf.s);
+ } ZEND_HASH_FOREACH_END();
}
}
}
Returns last SOAP request */
PHP_METHOD(SoapClient, __getLastRequest)
{
- zval **tmp;
+ zval *tmp;
if (zend_parse_parameters_none() == FAILURE) {
return;
}
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "__last_request", sizeof("__last_request"), (void **)&tmp) == SUCCESS) {
- RETURN_STRINGL(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(getThis()), "__last_request", sizeof("__last_request")-1)) != NULL) {
+ RETURN_STR(STR_COPY(Z_STR_P(tmp)));
}
RETURN_NULL();
}
Returns last SOAP response */
PHP_METHOD(SoapClient, __getLastResponse)
{
- zval **tmp;
+ zval *tmp;
if (zend_parse_parameters_none() == FAILURE) {
return;
}
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "__last_response", sizeof("__last_response"), (void **)&tmp) == SUCCESS) {
- RETURN_STRINGL(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(getThis()), "__last_response", sizeof("__last_response")-1)) != NULL) {
+ RETURN_STR(STR_COPY(Z_STR_P(tmp)));
}
RETURN_NULL();
}
Returns last SOAP request headers */
PHP_METHOD(SoapClient, __getLastRequestHeaders)
{
- zval **tmp;
+ zval *tmp;
if (zend_parse_parameters_none() == FAILURE) {
return;
}
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "__last_request_headers", sizeof("__last_request_headers"), (void **)&tmp) == SUCCESS) {
- RETURN_STRINGL(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(getThis()), "__last_request_headers", sizeof("__last_request_headers")-1)) != NULL) {
+ RETURN_STR(STR_COPY(Z_STR_P(tmp)));
}
RETURN_NULL();
}
Returns last SOAP response headers */
PHP_METHOD(SoapClient, __getLastResponseHeaders)
{
- zval **tmp;
+ zval *tmp;
if (zend_parse_parameters_none() == FAILURE) {
return;
}
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "__last_response_headers", sizeof("__last_response_headers"), (void **)&tmp) == SUCCESS) {
- RETURN_STRINGL(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(getThis()), "__last_response_headers", sizeof("__last_response_headers")-1)) != NULL) {
+ RETURN_STR(STR_COPY(Z_STR_P(tmp)));
}
RETURN_NULL();
}
int buf_size, location_size, action_size;
long version;
long one_way = 0;
+ zval *this_ptr = getThis();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sssl|l",
&buf, &buf_size,
one_way = 0;
}
if (one_way) {
- if (make_http_soap_request(this_ptr, buf, buf_size, location, action, version, NULL, NULL TSRMLS_CC)) {
+ if (make_http_soap_request(this_ptr, buf, buf_size, location, action, version, NULL TSRMLS_CC)) {
RETURN_EMPTY_STRING();
}
} else if (make_http_soap_request(this_ptr, buf, buf_size, location, action, version,
- &Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value) TSRMLS_CC)) {
- return_value->type = IS_STRING;
+ return_value TSRMLS_CC)) {
return;
}
RETURN_NULL();
char *name;
char *val = NULL;
int name_len, val_len = 0;
- zval **cookies;
+ zval *cookies;
+ zval *this_ptr = getThis();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &name, &name_len, &val, &val_len) == FAILURE) {
return;
}
if (val == NULL) {
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_cookies", sizeof("_cookies"), (void **)&cookies) == SUCCESS) {
- zend_hash_del(Z_ARRVAL_PP(cookies), name, name_len+1);
+ if ((cookies = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_cookies", sizeof("_cookies")-1)) != NULL) {
+ zend_hash_str_del(Z_ARRVAL_P(cookies), name, name_len);
}
} else {
- zval *zcookie;
+ zval zcookie;
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_cookies", sizeof("_cookies"), (void **)&cookies) == FAILURE) {
- zval *tmp_cookies;
+ if ((cookies = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "_cookies", sizeof("_cookies")-1)) == NULL) {
+ zval tmp_cookies;
- MAKE_STD_ZVAL(tmp_cookies);
- array_init(tmp_cookies);
- zend_hash_update(Z_OBJPROP_P(this_ptr), "_cookies", sizeof("_cookies"), &tmp_cookies, sizeof(zval *), (void **)&cookies);
+ array_init(&tmp_cookies);
+ cookies = zend_hash_str_update(Z_OBJPROP_P(this_ptr), "_cookies", sizeof("_cookies")-1, &tmp_cookies);
}
- ALLOC_INIT_ZVAL(zcookie);
- array_init(zcookie);
- add_index_stringl(zcookie, 0, val, val_len);
- add_assoc_zval_ex(*cookies, name, name_len+1, zcookie);
+ array_init(&zcookie);
+ add_index_stringl(&zcookie, 0, val, val_len);
+ add_assoc_zval_ex(cookies, name, name_len, &zcookie);
}
}
/* }}} */
PHP_METHOD(SoapClient, __setSoapHeaders)
{
zval *headers = NULL;
+ zval *this_ptr = getThis();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &headers) == FAILURE) {
return;
}
if (headers == NULL || Z_TYPE_P(headers) == IS_NULL) {
- zend_hash_del(Z_OBJPROP_P(this_ptr), "__default_headers", sizeof("__default_headers"));
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "__default_headers", sizeof("__default_headers")-1);
} else if (Z_TYPE_P(headers) == IS_ARRAY) {
zval *default_headers;
verify_soap_headers_array(Z_ARRVAL_P(headers) TSRMLS_CC);
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "__default_headers", sizeof("__default_headers"), (void **) &default_headers)==FAILURE) {
+ if ((default_headers = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "__default_headers", sizeof("__default_headers")-1)) == NULL) {
add_property_zval(this_ptr, "__default_headers", headers);
}
} else if (Z_TYPE_P(headers) == IS_OBJECT &&
instanceof_function(Z_OBJCE_P(headers), soap_header_class_entry TSRMLS_CC)) {
- zval *default_headers;
- ALLOC_INIT_ZVAL(default_headers);
- array_init(default_headers);
+ zval default_headers;
+
+ array_init(&default_headers);
Z_ADDREF_P(headers);
- add_next_index_zval(default_headers, headers);
- Z_DELREF_P(default_headers);
- add_property_zval(this_ptr, "__default_headers", default_headers);
+ add_next_index_zval(&default_headers, headers);
+ add_property_zval(this_ptr, "__default_headers", &default_headers);
+ Z_DELREF_P(&default_headers);
} else{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid SOAP header");
}
{
char *location = NULL;
int location_len = 0;
- zval **tmp;
+ zval *tmp;
+ zval *this_ptr = getThis();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &location, &location_len) == FAILURE) {
return;
}
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "location", sizeof("location"),(void **) &tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_STRING) {
- RETVAL_STRINGL(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+ if ((tmp = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "location", sizeof("location")-1)) != NULL && Z_TYPE_P(tmp) == IS_STRING) {
+ RETVAL_STR(STR_COPY(Z_STR_P(tmp)));
} else {
- RETVAL_NULL();
+ RETVAL_NULL();
}
if (location && location_len) {
add_property_stringl(this_ptr, "location", location, location_len);
} else {
- zend_hash_del(Z_OBJPROP_P(this_ptr), "location", sizeof("location"));
+ zend_hash_str_del(Z_OBJPROP_P(this_ptr), "location", sizeof("location")-1);
}
}
/* }}} */
static void clear_soap_fault(zval *obj TSRMLS_DC)
{
- if (obj != NULL && obj->type == IS_OBJECT) {
- zend_hash_del(Z_OBJPROP_P(obj), "__soap_fault", sizeof("__soap_fault"));
+ if (obj != NULL && Z_TYPE_P(obj) == IS_OBJECT) {
+ zend_hash_str_del(Z_OBJPROP_P(obj), "__soap_fault", sizeof("__soap_fault")-1);
}
}
zval* add_soap_fault(zval *obj, char *fault_code, char *fault_string, char *fault_actor, zval *fault_detail TSRMLS_DC)
{
- zval *fault;
- ALLOC_INIT_ZVAL(fault);
- set_soap_fault(fault, NULL, fault_code, fault_string, fault_actor, fault_detail, NULL TSRMLS_CC);
- Z_DELREF_P(fault);
+ zval fault;
- add_property_zval(obj, "__soap_fault", fault);
- return fault;
+ set_soap_fault(&fault, NULL, fault_code, fault_string, fault_actor, fault_detail, NULL TSRMLS_CC);
+ add_property_zval(obj, "__soap_fault", &fault);
+ Z_DELREF(fault);
+//??? FIXME
+// return &fault;
+ return NULL;
}
static void set_soap_fault(zval *obj, char *fault_code_ns, char *fault_code, char *fault_string, char *fault_actor, zval *fault_detail, char *name TSRMLS_DC)
}
}
-static void deserialize_parameters(xmlNodePtr params, sdlFunctionPtr function, int *num_params, zval ***parameters TSRMLS_DC)
+static void deserialize_parameters(xmlNodePtr params, sdlFunctionPtr function, int *num_params, zval **parameters TSRMLS_DC)
{
int cur_param = 0,num_of_params = 0;
- zval **tmp_parameters = NULL;
+ zval *tmp_parameters = NULL;
if (function != NULL) {
- sdlParamPtr *param;
+ sdlParamPtr param;
xmlNodePtr val;
int use_names = 0;
return;
}
num_of_params = zend_hash_num_elements(function->requestParameters);
- zend_hash_internal_pointer_reset(function->requestParameters);
- while (zend_hash_get_current_data(function->requestParameters, (void **)¶m) == SUCCESS) {
- if (get_node(params, (*param)->paramName) != NULL) {
+ ZEND_HASH_FOREACH_PTR(function->requestParameters, param) {
+ if (get_node(params, param->paramName) != NULL) {
use_names = 1;
}
- zend_hash_move_forward(function->requestParameters);
- }
+ } ZEND_HASH_FOREACH_END();
if (use_names) {
tmp_parameters = safe_emalloc(num_of_params, sizeof(zval *), 0);
- zend_hash_internal_pointer_reset(function->requestParameters);
- while (zend_hash_get_current_data(function->requestParameters, (void **)¶m) == SUCCESS) {
- val = get_node(params, (*param)->paramName);
+ ZEND_HASH_FOREACH_PTR(function->requestParameters, param) {
+ val = get_node(params, param->paramName);
if (!val) {
/* TODO: may be "nil" is not OK? */
- MAKE_STD_ZVAL(tmp_parameters[cur_param]);
- ZVAL_NULL(tmp_parameters[cur_param]);
+ ZVAL_NULL(&tmp_parameters[cur_param]);
} else {
- tmp_parameters[cur_param] = master_to_zval((*param)->encode, val TSRMLS_CC);
+ master_to_zval(&tmp_parameters[cur_param], param->encode, val TSRMLS_CC);
}
cur_param++;
-
- zend_hash_move_forward(function->requestParameters);
- }
- (*parameters) = tmp_parameters;
- (*num_params) = num_of_params;
+ } ZEND_HASH_FOREACH_END();
+ *parameters = tmp_parameters;
+ *num_params = num_of_params;
return;
}
}
while (trav != 0 && cur_param < num_of_params) {
if (trav->type == XML_ELEMENT_NODE) {
encodePtr enc;
- sdlParamPtr *param = NULL;
+ sdlParamPtr param = NULL;
if (function != NULL &&
- zend_hash_index_find(function->requestParameters, cur_param, (void **)¶m) == FAILURE) {
+ (param = zend_hash_index_find_ptr(function->requestParameters, cur_param)) == NULL) {
TSRMLS_FETCH();
soap_server_fault("Client", "Error cannot find parameter", NULL, NULL, NULL TSRMLS_CC);
}
if (param == NULL) {
enc = NULL;
} else {
- enc = (*param)->encode;
+ enc = param->encode;
}
- tmp_parameters[cur_param] = master_to_zval(enc, trav TSRMLS_CC);
+ master_to_zval(&tmp_parameters[cur_param], enc, trav TSRMLS_CC);
cur_param++;
}
trav = trav->next;
function = get_doc_function(sdl, func);
}
- INIT_ZVAL(*function_name);
if (function != NULL) {
- ZVAL_STRING(function_name, (char *)function->functionName, 1);
+ ZVAL_STRING(function_name, (char *)function->functionName);
} else {
- ZVAL_STRING(function_name, (char *)func->name, 1);
+ ZVAL_STRING(function_name, (char *)func->name);
}
return function;
}
-static sdlFunctionPtr deserialize_function_call(sdlPtr sdl, xmlDocPtr request, char* actor, zval *function_name, int *num_params, zval ***parameters, int *version, soapHeader **headers TSRMLS_DC)
+static sdlFunctionPtr deserialize_function_call(sdlPtr sdl, xmlDocPtr request, char* actor, zval *function_name, int *num_params, zval **parameters, int *version, soapHeader **headers TSRMLS_DC)
{
char* envelope_ns = NULL;
xmlNodePtr trav,env,head,body,func;
if (func == NULL) {
function = get_doc_function(sdl, NULL);
if (function != NULL) {
- INIT_ZVAL(*function_name);
- ZVAL_STRING(function_name, (char *)function->functionName, 1);
+ ZVAL_STRING(function_name, (char *)function->functionName);
} else {
soap_server_fault("Client", "looks like we got \"Body\" without function call", NULL, NULL, NULL TSRMLS_CC);
}
h->mustUnderstand = mustUnderstand;
h->function = find_function(sdl, hdr_func, &h->function_name);
if (!h->function && sdl && function && function->binding && function->binding->bindingType == BINDING_SOAP) {
- sdlSoapBindingFunctionHeaderPtr *hdr;
+ sdlSoapBindingFunctionHeaderPtr hdr;
sdlSoapBindingFunctionPtr fnb = (sdlSoapBindingFunctionPtr)function->bindingAttributes;
if (fnb->input.headers) {
smart_str key = {0};
}
smart_str_appendl(&key, Z_STRVAL(h->function_name), Z_STRLEN(h->function_name));
smart_str_0(&key);
- if (zend_hash_find(fnb->input.headers, key.c, key.len+1, (void**)&hdr) == SUCCESS) {
- h->hdr = *hdr;
+ if ((hdr = zend_hash_find_ptr(fnb->input.headers, key.s)) != NULL) {
+ h->hdr = hdr;
}
smart_str_free(&key);
}
}
if (h->hdr) {
h->num_params = 1;
- h->parameters = emalloc(sizeof(zval*));
- h->parameters[0] = master_to_zval(h->hdr->encode, hdr_func TSRMLS_CC);
+ h->parameters = emalloc(sizeof(zval));
+ master_to_zval(&h->parameters[0], h->hdr->encode, hdr_func TSRMLS_CC);
} else {
if (h->function && h->function->binding && h->function->binding->bindingType == BINDING_SOAP) {
sdlSoapBindingFunctionPtr fnb = (sdlSoapBindingFunctionPtr)h->function->bindingAttributes;
}
deserialize_parameters(hdr_func, h->function, &h->num_params, &h->parameters TSRMLS_CC);
}
- INIT_ZVAL(h->retval);
+ ZVAL_NULL(&h->retval);
if (last == NULL) {
*headers = h;
} else {
static void set_soap_header_attributes(xmlNodePtr h, HashTable *ht, int version)
{
- zval **tmp;
+ zval *tmp;
- if (zend_hash_find(ht, "mustUnderstand", sizeof("mustUnderstand"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_BOOL && Z_LVAL_PP(tmp)) {
+ if ((tmp = zend_hash_str_find(ht, "mustUnderstand", sizeof("mustUnderstand")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_TRUE) {
if (version == SOAP_1_1) {
xmlSetProp(h, BAD_CAST(SOAP_1_1_ENV_NS_PREFIX":mustUnderstand"), BAD_CAST("1"));
} else {
xmlSetProp(h, BAD_CAST(SOAP_1_2_ENV_NS_PREFIX":mustUnderstand"), BAD_CAST("true"));
}
}
- if (zend_hash_find(ht, "actor", sizeof("actor"), (void**)&tmp) == SUCCESS) {
- if (Z_TYPE_PP(tmp) == IS_STRING) {
+ if ((tmp = zend_hash_str_find(ht, "actor", sizeof("actor")-1)) != NULL) {
+ if (Z_TYPE_P(tmp) == IS_STRING) {
if (version == SOAP_1_1) {
- xmlSetProp(h, BAD_CAST(SOAP_1_1_ENV_NS_PREFIX":actor"), BAD_CAST(Z_STRVAL_PP(tmp)));
+ xmlSetProp(h, BAD_CAST(SOAP_1_1_ENV_NS_PREFIX":actor"), BAD_CAST(Z_STRVAL_P(tmp)));
} else {
- xmlSetProp(h, BAD_CAST(SOAP_1_2_ENV_NS_PREFIX":role"), BAD_CAST(Z_STRVAL_PP(tmp)));
+ xmlSetProp(h, BAD_CAST(SOAP_1_2_ENV_NS_PREFIX":role"), BAD_CAST(Z_STRVAL_P(tmp)));
}
- } else if (Z_TYPE_PP(tmp) == IS_LONG) {
+ } else if (Z_TYPE_P(tmp) == IS_LONG) {
if (version == SOAP_1_1) {
- if (Z_LVAL_PP(tmp) == SOAP_ACTOR_NEXT) {
+ if (Z_LVAL_P(tmp) == SOAP_ACTOR_NEXT) {
xmlSetProp(h, BAD_CAST(SOAP_1_1_ENV_NS_PREFIX":actor"), BAD_CAST(SOAP_1_1_ACTOR_NEXT));
}
} else {
- if (Z_LVAL_PP(tmp) == SOAP_ACTOR_NEXT) {
+ if (Z_LVAL_P(tmp) == SOAP_ACTOR_NEXT) {
xmlSetProp(h, BAD_CAST(SOAP_1_2_ENV_NS_PREFIX":role"), BAD_CAST(SOAP_1_2_ACTOR_NEXT));
- } else if (Z_LVAL_PP(tmp) == SOAP_ACTOR_NONE) {
+ } else if (Z_LVAL_P(tmp) == SOAP_ACTOR_NONE) {
xmlSetProp(h, BAD_CAST(SOAP_1_2_ENV_NS_PREFIX":role"), BAD_CAST(SOAP_1_2_ACTOR_NONE));
- } else if (Z_LVAL_PP(tmp) == SOAP_ACTOR_UNLIMATERECEIVER) {
+ } else if (Z_LVAL_P(tmp) == SOAP_ACTOR_UNLIMATERECEIVER) {
xmlSetProp(h, BAD_CAST(SOAP_1_2_ENV_NS_PREFIX":role"), BAD_CAST(SOAP_1_2_ACTOR_UNLIMATERECEIVER));
}
}
}
}
} else if (param_count > 1 && Z_TYPE_P(ret) == IS_ARRAY) {
- HashPosition pos;
- zval **data;
+ zval *data;
int i = 0;
+ zend_string *param_name;
+//???
+ ulong param_index = i;
- zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(ret), &pos);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_P(ret), (void **)&data, &pos) != FAILURE) {
- char *param_name = NULL;
- unsigned int param_name_len;
- ulong param_index = i;
-
- zend_hash_get_current_key_ex(Z_ARRVAL_P(ret), ¶m_name, ¶m_name_len, ¶m_index, 0, &pos);
- parameter = get_param(function, param_name, param_index, TRUE);
+ ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(ret), param_index, param_name, data) {
+ parameter = get_param(function, param_name->val, param_index, TRUE);
if (style == SOAP_RPC) {
- param = serialize_parameter(parameter, *data, i, param_name, use, method TSRMLS_CC);
+ param = serialize_parameter(parameter, data, i, param_name->val, use, method TSRMLS_CC);
} else {
- param = serialize_parameter(parameter, *data, i, param_name, use, body TSRMLS_CC);
+ param = serialize_parameter(parameter, data, i, param_name->val, use, body TSRMLS_CC);
if (function && function->binding->bindingType == BINDING_SOAP) {
if (parameter && parameter->element) {
ns = encode_add_ns(param, parameter->element->namens);
}
}
- zend_hash_move_forward_ex(Z_ARRVAL_P(ret), &pos);
i++;
- }
+ param_index = i;
+ } ZEND_HASH_FOREACH_END();
}
if (use == SOAP_ENCODED && version == SOAP_1_2 && method != NULL) {
xmlSetNsProp(method, body->ns, BAD_CAST("encodingStyle"), BAD_CAST(SOAP_1_2_ENC_NAMESPACE));
instanceof_function(Z_OBJCE_P(ret), soap_fault_class_entry TSRMLS_CC)) {
char *detail_name;
HashTable* prop;
- zval **tmp;
+ zval *tmp;
sdlFaultPtr fault = NULL;
char *fault_ns = NULL;
prop = Z_OBJPROP_P(ret);
if (headers &&
- zend_hash_find(prop, "headerfault", sizeof("headerfault"), (void**)&tmp) == SUCCESS) {
+ (tmp = zend_hash_str_find(prop, "headerfault", sizeof("headerfault")-1)) != NULL) {
encodePtr hdr_enc = NULL;
int hdr_use = SOAP_LITERAL;
- zval *hdr_ret = *tmp;
+ zval *hdr_ret = tmp;
char *hdr_ns = headers->hdr?headers->hdr->ns:NULL;
char *hdr_name = Z_STRVAL(headers->function_name);
if (Z_TYPE_P(hdr_ret) == IS_OBJECT &&
instanceof_function(Z_OBJCE_P(hdr_ret), soap_header_class_entry TSRMLS_CC)) {
HashTable* ht = Z_OBJPROP_P(hdr_ret);
- sdlSoapBindingFunctionHeaderPtr *hdr;
+ sdlSoapBindingFunctionHeaderPtr hdr;
smart_str key = {0};
- if (zend_hash_find(ht, "namespace", sizeof("namespace"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- smart_str_appendl(&key, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ if ((tmp = zend_hash_str_find(ht, "namespace", sizeof("namespace")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ smart_str_appendl(&key, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
smart_str_appendc(&key, ':');
- hdr_ns = Z_STRVAL_PP(tmp);
+ hdr_ns = Z_STRVAL_P(tmp);
}
- if (zend_hash_find(ht, "name", sizeof("name"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- smart_str_appendl(&key, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
- hdr_name = Z_STRVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(ht, "name", sizeof("name")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ smart_str_appendl(&key, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
+ hdr_name = Z_STRVAL_P(tmp);
}
smart_str_0(&key);
if (headers->hdr && headers->hdr->headerfaults &&
- zend_hash_find(headers->hdr->headerfaults, key.c, key.len+1, (void**)&hdr) == SUCCESS) {
- hdr_enc = (*hdr)->encode;
- hdr_use = (*hdr)->use;
+ (hdr = zend_hash_find_ptr(headers->hdr->headerfaults, key.s)) != NULL) {
+ hdr_enc = hdr->encode;
+ hdr_use = hdr->use;
}
smart_str_free(&key);
- if (zend_hash_find(ht, "data", sizeof("data"), (void**)&tmp) == SUCCESS) {
- hdr_ret = *tmp;
+ if ((tmp = zend_hash_str_find(ht, "data", sizeof("data")-1)) != NULL) {
+ hdr_ret = tmp;
} else {
hdr_ret = NULL;
}
body = xmlNewChild(envelope, ns, BAD_CAST("Body"), NULL);
param = xmlNewChild(body, ns, BAD_CAST("Fault"), NULL);
- if (zend_hash_find(prop, "faultcodens", sizeof("faultcodens"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_STRING) {
- fault_ns = Z_STRVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(prop, "faultcodens", sizeof("faultcodens")-1)) != NULL && Z_TYPE_P(tmp) == IS_STRING) {
+ fault_ns = Z_STRVAL_P(tmp);
}
use = SOAP_LITERAL;
- if (zend_hash_find(prop, "_name", sizeof("_name"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_STRING) {
- sdlFaultPtr *tmp_fault;
+ if ((tmp = zend_hash_str_find(prop, "_name", sizeof("_name")-1)) != NULL && Z_TYPE_P(tmp) == IS_STRING) {
+ sdlFaultPtr tmp_fault;
if (function && function->faults &&
- zend_hash_find(function->faults, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp)+1, (void**)&tmp_fault) == SUCCESS) {
- fault = *tmp_fault;
+ (tmp_fault = zend_hash_find_ptr(function->faults, Z_STR_P(tmp))) != NULL) {
+ fault = tmp_fault;
if (function->binding &&
function->binding->bindingType == BINDING_SOAP &&
fault->bindingAttributes) {
zend_hash_num_elements(function->faults) == 1) {
zend_hash_internal_pointer_reset(function->faults);
- zend_hash_get_current_data(function->faults, (void**)&fault);
- fault = *(sdlFaultPtr*)fault;
+ fault = zend_hash_get_current_data_ptr(function->faults);
if (function->binding &&
function->binding->bindingType == BINDING_SOAP &&
fault->bindingAttributes) {
sdlSoapBindingFunctionFaultPtr fb = (sdlSoapBindingFunctionFaultPtr)fault->bindingAttributes;
use = fb->use;
if (fault_ns == NULL) {
- fault_ns = fb->ns;
+ fault_ns = fb->ns;
}
}
}
sdlParamPtr sparam;
zend_hash_internal_pointer_reset(fault->details);
- zend_hash_get_current_data(fault->details, (void**)&sparam);
- sparam = *(sdlParamPtr*)sparam;
+ sparam = zend_hash_get_current_data_ptr(fault->details);
if (sparam->element) {
fault_ns = sparam->element->namens;
}
}
if (version == SOAP_1_1) {
- if (zend_hash_find(prop, "faultcode", sizeof("faultcode"), (void**)&tmp) == SUCCESS) {
- size_t new_len;
+ if ((tmp = zend_hash_str_find(prop, "faultcode", sizeof("faultcode")-1)) != NULL) {
xmlNodePtr node = xmlNewNode(NULL, BAD_CAST("faultcode"));
- char *str = php_escape_html_entities((unsigned char*)Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), &new_len, 0, 0, NULL TSRMLS_CC);
+ zend_string *str = php_escape_html_entities((unsigned char*)Z_STRVAL_P(tmp), Z_STRLEN_P(tmp), 0, 0, NULL TSRMLS_CC);
xmlAddChild(param, node);
if (fault_ns) {
xmlNsPtr nsptr = encode_add_ns(node, fault_ns);
- xmlChar *code = xmlBuildQName(BAD_CAST(str), nsptr->prefix, NULL, 0);
+ xmlChar *code = xmlBuildQName(BAD_CAST(str->val), nsptr->prefix, NULL, 0);
xmlNodeSetContent(node, code);
xmlFree(code);
} else {
- xmlNodeSetContentLen(node, BAD_CAST(str), (int)new_len);
+ xmlNodeSetContentLen(node, BAD_CAST(str->val), (int)str->len);
}
- efree(str);
+ STR_RELEASE(str);
}
- if (zend_hash_find(prop, "faultstring", sizeof("faultstring"), (void**)&tmp) == SUCCESS) {
- xmlNodePtr node = master_to_xml(get_conversion(IS_STRING), *tmp, SOAP_LITERAL, param TSRMLS_CC);
+ if ((tmp = zend_hash_str_find(prop, "faultstring", sizeof("faultstring")-1)) != NULL) {
+ xmlNodePtr node = master_to_xml(get_conversion(IS_STRING), tmp, SOAP_LITERAL, param TSRMLS_CC);
xmlNodeSetName(node, BAD_CAST("faultstring"));
}
- if (zend_hash_find(prop, "faultactor", sizeof("faultactor"), (void**)&tmp) == SUCCESS) {
- xmlNodePtr node = master_to_xml(get_conversion(IS_STRING), *tmp, SOAP_LITERAL, param TSRMLS_CC);
+ if ((tmp = zend_hash_str_find(prop, "faultactor", sizeof("faultactor")-1)) != NULL) {
+ xmlNodePtr node = master_to_xml(get_conversion(IS_STRING), tmp, SOAP_LITERAL, param TSRMLS_CC);
xmlNodeSetName(node, BAD_CAST("faultactor"));
}
detail_name = "detail";
} else {
- if (zend_hash_find(prop, "faultcode", sizeof("faultcode"), (void**)&tmp) == SUCCESS) {
- size_t new_len;
+ if ((tmp = zend_hash_str_find(prop, "faultcode", sizeof("faultcode")-1)) != NULL) {
xmlNodePtr node = xmlNewChild(param, ns, BAD_CAST("Code"), NULL);
- char *str = php_escape_html_entities((unsigned char*)Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), &new_len, 0, 0, NULL TSRMLS_CC);
+ zend_string *str = php_escape_html_entities((unsigned char*)Z_STRVAL_P(tmp), Z_STRLEN_P(tmp), 0, 0, NULL TSRMLS_CC);
node = xmlNewChild(node, ns, BAD_CAST("Value"), NULL);
if (fault_ns) {
xmlNsPtr nsptr = encode_add_ns(node, fault_ns);
- xmlChar *code = xmlBuildQName(BAD_CAST(str), nsptr->prefix, NULL, 0);
+ xmlChar *code = xmlBuildQName(BAD_CAST(str->val), nsptr->prefix, NULL, 0);
xmlNodeSetContent(node, code);
xmlFree(code);
} else {
- xmlNodeSetContentLen(node, BAD_CAST(str), (int)new_len);
+ xmlNodeSetContentLen(node, BAD_CAST(str->val), (int)str->len);
}
- efree(str);
+ STR_RELEASE(str);
}
- if (zend_hash_find(prop, "faultstring", sizeof("faultstring"), (void**)&tmp) == SUCCESS) {
+ if ((tmp = zend_hash_str_find(prop, "faultstring", sizeof("faultstring")-1)) != NULL) {
xmlNodePtr node = xmlNewChild(param, ns, BAD_CAST("Reason"), NULL);
- node = master_to_xml(get_conversion(IS_STRING), *tmp, SOAP_LITERAL, node TSRMLS_CC);
+ node = master_to_xml(get_conversion(IS_STRING), tmp, SOAP_LITERAL, node TSRMLS_CC);
xmlNodeSetName(node, BAD_CAST("Text"));
xmlSetNs(node, ns);
}
sdlParamPtr sparam;
xmlNodePtr x;
- if (zend_hash_find(prop, "detail", sizeof("detail"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) != IS_NULL) {
- detail = *tmp;
+ if ((tmp = zend_hash_str_find(prop, "detail", sizeof("detail")-1)) != NULL &&
+ Z_TYPE_P(tmp) != IS_NULL) {
+ detail = tmp;
}
node = xmlNewNode(NULL, BAD_CAST(detail_name));
xmlAddChild(param, node);
zend_hash_internal_pointer_reset(fault->details);
- zend_hash_get_current_data(fault->details, (void**)&sparam);
- sparam = *(sdlParamPtr*)sparam;
+ sparam = zend_hash_get_current_data_ptr(fault->details);
if (detail &&
Z_TYPE_P(detail) == IS_OBJECT &&
sparam->element &&
zend_hash_num_elements(Z_OBJPROP_P(detail)) == 1 &&
- zend_hash_find(Z_OBJPROP_P(detail), sparam->element->name, strlen(sparam->element->name)+1, (void**)&tmp) == SUCCESS) {
- detail = *tmp;
+ (tmp = zend_hash_str_find(Z_OBJPROP_P(detail), sparam->element->name, strlen(sparam->element->name))) != NULL) {
+ detail = tmp;
}
x = serialize_parameter(sparam, detail, 1, NULL, use, node TSRMLS_CC);
if (use == SOAP_ENCODED && version == SOAP_1_2) {
xmlSetNsProp(x, envelope->ns, BAD_CAST("encodingStyle"), BAD_CAST(SOAP_1_2_ENC_NAMESPACE));
}
- } else if (zend_hash_find(prop, "detail", sizeof("detail"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) != IS_NULL) {
- serialize_zval(*tmp, NULL, detail_name, use, param TSRMLS_CC);
+ } else if ((tmp = zend_hash_str_find(prop, "detail", sizeof("detail")-1)) != NULL &&
+ Z_TYPE_P(tmp) != IS_NULL) {
+ serialize_zval(tmp, NULL, detail_name, use, param TSRMLS_CC);
}
} else {
if (Z_TYPE(h->retval) == IS_OBJECT &&
instanceof_function(Z_OBJCE(h->retval), soap_header_class_entry TSRMLS_CC)) {
- zval **tmp;
- sdlSoapBindingFunctionHeaderPtr *hdr;
+ zval *tmp;
+ sdlSoapBindingFunctionHeaderPtr hdr;
smart_str key = {0};
ht = Z_OBJPROP(h->retval);
- if (zend_hash_find(ht, "namespace", sizeof("namespace"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- smart_str_appendl(&key, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ if ((tmp = zend_hash_str_find(ht, "namespace", sizeof("namespace")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ smart_str_appendl(&key, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
smart_str_appendc(&key, ':');
- hdr_ns = Z_STRVAL_PP(tmp);
+ hdr_ns = Z_STRVAL_P(tmp);
}
- if (zend_hash_find(ht, "name", sizeof("name"), (void**)&tmp) == SUCCESS &&
- Z_TYPE_PP(tmp) == IS_STRING) {
- smart_str_appendl(&key, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
- hdr_name = Z_STRVAL_PP(tmp);
+ if ((tmp = zend_hash_str_find(ht, "name", sizeof("name")-1)) != NULL &&
+ Z_TYPE_P(tmp) == IS_STRING) {
+ smart_str_appendl(&key, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
+ hdr_name = Z_STRVAL_P(tmp);
}
smart_str_0(&key);
if (function && function->binding && function->binding->bindingType == BINDING_SOAP) {
sdlSoapBindingFunctionPtr fnb = (sdlSoapBindingFunctionPtr)function->bindingAttributes;
if (fnb->output.headers &&
- zend_hash_find(fnb->output.headers, key.c, key.len+1, (void**)&hdr) == SUCCESS) {
- hdr_enc = (*hdr)->encode;
- hdr_use = (*hdr)->use;
+ (hdr = zend_hash_find_ptr(fnb->output.headers, key.s)) != NULL) {
+ hdr_enc = hdr->encode;
+ hdr_use = hdr->use;
}
}
smart_str_free(&key);
- if (zend_hash_find(ht, "data", sizeof("data"), (void**)&tmp) == SUCCESS) {
- hdr_ret = *tmp;
+ if ((tmp = zend_hash_str_find(ht, "data", sizeof("data")-1)) != NULL) {
+ hdr_ret = tmp;
} else {
hdr_ret = NULL;
}
return doc;
}
-static xmlDocPtr serialize_function_call(zval *this_ptr, sdlFunctionPtr function, char *function_name, char *uri, zval **arguments, int arg_count, int version, HashTable *soap_headers TSRMLS_DC)
+static xmlDocPtr serialize_function_call(zval *this_ptr, sdlFunctionPtr function, char *function_name, char *uri, zval *arguments, int arg_count, int version, HashTable *soap_headers TSRMLS_DC)
{
xmlDoc *doc;
xmlNodePtr envelope = NULL, body, method = NULL, head = NULL;
xmlNsPtr ns = NULL;
- zval **zstyle, **zuse;
+ zval *zstyle, *zuse;
int i, style, use;
HashTable *hdrs = NULL;
}
}
} else {
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "style", sizeof("style"), (void **)&zstyle) == SUCCESS) {
- style = Z_LVAL_PP(zstyle);
+ if ((zstyle = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "style", sizeof("style")-1)) != NULL) {
+ style = Z_LVAL_P(zstyle);
} else {
style = SOAP_RPC;
}
method = body;
}
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "use", sizeof("use"), (void **)&zuse) == SUCCESS &&
- Z_LVAL_PP(zuse) == SOAP_LITERAL) {
+ if ((zuse = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "use", sizeof("use")-1)) != NULL &&
+ Z_LVAL_P(zuse) == SOAP_LITERAL) {
use = SOAP_LITERAL;
} else {
use = SOAP_ENCODED;
sdlParamPtr parameter = get_param(function, NULL, i, FALSE);
if (style == SOAP_RPC) {
- param = serialize_parameter(parameter, arguments[i], i, NULL, use, method TSRMLS_CC);
+ param = serialize_parameter(parameter, &arguments[i], i, NULL, use, method TSRMLS_CC);
} else if (style == SOAP_DOCUMENT) {
- param = serialize_parameter(parameter, arguments[i], i, NULL, use, body TSRMLS_CC);
+ param = serialize_parameter(parameter, &arguments[i], i, NULL, use, body TSRMLS_CC);
if (function && function->binding->bindingType == BINDING_SOAP) {
if (parameter && parameter->element) {
ns = encode_add_ns(param, parameter->element->namens);
}
if (head) {
- zval** header;
+ zval* header;
- zend_hash_internal_pointer_reset(soap_headers);
- while (zend_hash_get_current_data(soap_headers,(void**)&header) == SUCCESS) {
- HashTable *ht = Z_OBJPROP_PP(header);
- zval **name, **ns, **tmp;
+ ZEND_HASH_FOREACH_VAL(soap_headers, header) {
+ HashTable *ht = Z_OBJPROP_P(header);
+ zval *name, *ns, *tmp;
- if (zend_hash_find(ht, "name", sizeof("name"), (void**)&name) == SUCCESS &&
- Z_TYPE_PP(name) == IS_STRING &&
- zend_hash_find(ht, "namespace", sizeof("namespace"), (void**)&ns) == SUCCESS &&
- Z_TYPE_PP(ns) == IS_STRING) {
+ if ((name = zend_hash_str_find(ht, "name", sizeof("name")-1)) != NULL &&
+ Z_TYPE_P(name) == IS_STRING &&
+ (ns = zend_hash_str_find(ht, "namespace", sizeof("namespace")-1)) != NULL &&
+ Z_TYPE_P(ns) == IS_STRING) {
xmlNodePtr h;
xmlNsPtr nsptr;
int hdr_use = SOAP_LITERAL;
if (hdrs) {
smart_str key = {0};
- sdlSoapBindingFunctionHeaderPtr *hdr;
+ sdlSoapBindingFunctionHeaderPtr hdr;
- smart_str_appendl(&key, Z_STRVAL_PP(ns), Z_STRLEN_PP(ns));
+ smart_str_appendl(&key, Z_STRVAL_P(ns), Z_STRLEN_P(ns));
smart_str_appendc(&key, ':');
- smart_str_appendl(&key, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
+ smart_str_appendl(&key, Z_STRVAL_P(name), Z_STRLEN_P(name));
smart_str_0(&key);
- if (zend_hash_find(hdrs, key.c, key.len+1,(void**)&hdr) == SUCCESS) {
- hdr_use = (*hdr)->use;
- enc = (*hdr)->encode;
+ if ((hdr = zend_hash_find_ptr(hdrs, key.s)) != NULL) {
+ hdr_use = hdr->use;
+ enc = hdr->encode;
if (hdr_use == SOAP_ENCODED) {
use = SOAP_ENCODED;
}
smart_str_free(&key);
}
- if (zend_hash_find(ht, "data", sizeof("data"), (void**)&tmp) == SUCCESS) {
- h = master_to_xml(enc, *tmp, hdr_use, head TSRMLS_CC);
- xmlNodeSetName(h, BAD_CAST(Z_STRVAL_PP(name)));
+ if ((tmp = zend_hash_str_find(ht, "data", sizeof("data")-1)) != NULL) {
+ h = master_to_xml(enc, tmp, hdr_use, head TSRMLS_CC);
+ xmlNodeSetName(h, BAD_CAST(Z_STRVAL_P(name)));
} else {
- h = xmlNewNode(NULL, BAD_CAST(Z_STRVAL_PP(name)));
+ h = xmlNewNode(NULL, BAD_CAST(Z_STRVAL_P(name)));
xmlAddChild(head, h);
}
- nsptr = encode_add_ns(h, Z_STRVAL_PP(ns));
+ nsptr = encode_add_ns(h, Z_STRVAL_P(ns));
xmlSetNs(h, nsptr);
set_soap_header_attributes(h, ht, version);
}
- zend_hash_move_forward(soap_headers);
- }
+ } ZEND_HASH_FOREACH_END();
}
if (use == SOAP_ENCODED) {
if (param_val &&
Z_TYPE_P(param_val) == IS_OBJECT &&
Z_OBJCE_P(param_val) == soap_param_class_entry) {
- zval **param_name;
- zval **param_data;
+ zval *param_name;
+ zval *param_data;
- if (zend_hash_find(Z_OBJPROP_P(param_val), "param_name", sizeof("param_name"), (void **)¶m_name) == SUCCESS &&
- zend_hash_find(Z_OBJPROP_P(param_val), "param_data", sizeof("param_data"), (void **)¶m_data) == SUCCESS) {
- param_val = *param_data;
- name = Z_STRVAL_PP(param_name);
+ if ((param_name = zend_hash_str_find(Z_OBJPROP_P(param_val), "param_name", sizeof("param_name")-1)) != NULL &&
+ (param_data = zend_hash_str_find(Z_OBJPROP_P(param_val), "param_data", sizeof("param_data")-1)) != NULL) {
+ param_val = param_data;
+ name = Z_STRVAL_P(param_name);
}
}
if (val == NULL) {
if (param->element) {
if (param->element->fixed) {
- ZVAL_STRING(&defval, param->element->fixed, 0);
+ //??? val has to be freed
+ ZVAL_STRING(&defval, param->element->fixed);
val = &defval;
} else if (param->element->def && !param->element->nillable) {
- ZVAL_STRING(&defval, param->element->def, 0);
+ //??? val has to be freed
+ ZVAL_STRING(&defval, param->element->def);
val = &defval;
}
}
static sdlParamPtr get_param(sdlFunctionPtr function, char *param_name, int index, int response)
{
- sdlParamPtr *tmp;
+ sdlParamPtr tmp;
HashTable *ht;
if (function == NULL) {
}
if (param_name != NULL) {
- if (zend_hash_find(ht, param_name, strlen(param_name), (void **)&tmp) != FAILURE) {
- return *tmp;
+ if ((tmp = zend_hash_str_find_ptr(ht, param_name, strlen(param_name))) != NULL) {
+ return tmp;
} else {
- HashPosition pos;
-
- zend_hash_internal_pointer_reset_ex(ht, &pos);
- while (zend_hash_get_current_data_ex(ht, (void **)&tmp, &pos) != FAILURE) {
- if ((*tmp)->paramName && strcmp(param_name, (*tmp)->paramName) == 0) {
- return *tmp;
+ ZEND_HASH_FOREACH_PTR(ht, tmp) {
+ if (tmp->paramName && strcmp(param_name, tmp->paramName) == 0) {
+ return tmp;
}
- zend_hash_move_forward_ex(ht, &pos);
- }
+ } ZEND_HASH_FOREACH_END();
}
} else {
- if (zend_hash_index_find(ht, index, (void **)&tmp) != FAILURE) {
- return (*tmp);
+ if ((tmp = zend_hash_index_find_ptr(ht, index)) != NULL) {
+ return tmp;
}
}
return NULL;
static sdlFunctionPtr get_function(sdlPtr sdl, const char *function_name)
{
- sdlFunctionPtr *tmp;
+ sdlFunctionPtr tmp;
int len = strlen(function_name);
char *str = estrndup(function_name,len);
php_strtolower(str,len);
if (sdl != NULL) {
- if (zend_hash_find(&sdl->functions, str, len+1, (void **)&tmp) != FAILURE) {
+ if ((tmp = zend_hash_str_find_ptr(&sdl->functions, str, len)) != NULL) {
efree(str);
- return (*tmp);
- } else if (sdl->requests != NULL && zend_hash_find(sdl->requests, str, len+1, (void **)&tmp) != FAILURE) {
+ return tmp;
+ } else if (sdl->requests != NULL && (tmp = zend_hash_str_find_ptr(sdl->requests, str, len)) != NULL) {
efree(str);
- return (*tmp);
+ return tmp;
}
}
efree(str);
static sdlFunctionPtr get_doc_function(sdlPtr sdl, xmlNodePtr params)
{
if (sdl) {
- sdlFunctionPtr *tmp;
- sdlParamPtr *param;
+ sdlFunctionPtr tmp;
+ sdlParamPtr param;
- zend_hash_internal_pointer_reset(&sdl->functions);
- while (zend_hash_get_current_data(&sdl->functions, (void**)&tmp) == SUCCESS) {
- if ((*tmp)->binding && (*tmp)->binding->bindingType == BINDING_SOAP) {
- sdlSoapBindingFunctionPtr fnb = (sdlSoapBindingFunctionPtr)(*tmp)->bindingAttributes;
+ ZEND_HASH_FOREACH_PTR(&sdl->functions, tmp) {
+ if (tmp->binding && tmp->binding->bindingType == BINDING_SOAP) {
+ sdlSoapBindingFunctionPtr fnb = (sdlSoapBindingFunctionPtr)tmp->bindingAttributes;
if (fnb->style == SOAP_DOCUMENT) {
if (params == NULL) {
- if ((*tmp)->requestParameters == NULL ||
- zend_hash_num_elements((*tmp)->requestParameters) == 0) {
- return *tmp;
+ if (tmp->requestParameters == NULL ||
+ zend_hash_num_elements(tmp->requestParameters) == 0) {
+ return tmp;
}
- } else if ((*tmp)->requestParameters != NULL &&
- zend_hash_num_elements((*tmp)->requestParameters) > 0) {
+ } else if (tmp->requestParameters != NULL &&
+ zend_hash_num_elements(tmp->requestParameters) > 0) {
int ok = 1;
xmlNodePtr node = params;
- zend_hash_internal_pointer_reset((*tmp)->requestParameters);
- while (zend_hash_get_current_data((*tmp)->requestParameters, (void**)¶m) == SUCCESS) {
- if ((*param)->element) {
- if (strcmp((*param)->element->name, (char*)node->name) != 0) {
+ ZEND_HASH_FOREACH_PTR(tmp->requestParameters, param) {
+ if (param->element) {
+ if (strcmp(param->element->name, (char*)node->name) != 0) {
ok = 0;
break;
}
- if ((*param)->element->namens != NULL && node->ns != NULL) {
- if (strcmp((*param)->element->namens, (char*)node->ns->href) != 0) {
+ if (param->element->namens != NULL && node->ns != NULL) {
+ if (strcmp(param->element->namens, (char*)node->ns->href) != 0) {
ok = 0;
break;
}
- } else if ((void*)(*param)->element->namens != (void*)node->ns) {
+ } else if ((void*)param->element->namens != (void*)node->ns) {
ok = 0;
break;
}
- } else if (strcmp((*param)->paramName, (char*)node->name) != 0) {
+ } else if (strcmp(param->paramName, (char*)node->name) != 0) {
ok = 0;
break;
}
- zend_hash_move_forward((*tmp)->requestParameters);
node = node->next;
- }
+ } ZEND_HASH_FOREACH_END();
if (ok /*&& node == NULL*/) {
- return (*tmp);
+ return tmp;
}
}
}
}
- zend_hash_move_forward(&sdl->functions);
- }
+ } ZEND_HASH_FOREACH_END();
}
return NULL;
}
static void function_to_string(sdlFunctionPtr function, smart_str *buf)
{
int i = 0;
- HashPosition pos;
- sdlParamPtr *param;
+ sdlParamPtr param;
if (function->responseParameters &&
zend_hash_num_elements(function->responseParameters) > 0) {
if (zend_hash_num_elements(function->responseParameters) == 1) {
zend_hash_internal_pointer_reset(function->responseParameters);
- zend_hash_get_current_data(function->responseParameters, (void**)¶m);
- if ((*param)->encode && (*param)->encode->details.type_str) {
- smart_str_appendl(buf, (*param)->encode->details.type_str, strlen((*param)->encode->details.type_str));
+ param = zend_hash_get_current_data_ptr(function->responseParameters);
+ if (param->encode && param->encode->details.type_str) {
+ smart_str_appendl(buf, param->encode->details.type_str, strlen(param->encode->details.type_str));
smart_str_appendc(buf, ' ');
} else {
smart_str_appendl(buf, "UNKNOWN ", 8);
} else {
i = 0;
smart_str_appendl(buf, "list(", 5);
- zend_hash_internal_pointer_reset_ex(function->responseParameters, &pos);
- while (zend_hash_get_current_data_ex(function->responseParameters, (void **)¶m, &pos) != FAILURE) {
+ ZEND_HASH_FOREACH_PTR(function->responseParameters, param) {
if (i > 0) {
smart_str_appendl(buf, ", ", 2);
}
- if ((*param)->encode && (*param)->encode->details.type_str) {
- smart_str_appendl(buf, (*param)->encode->details.type_str, strlen((*param)->encode->details.type_str));
+ if (param->encode && param->encode->details.type_str) {
+ smart_str_appendl(buf, param->encode->details.type_str, strlen(param->encode->details.type_str));
} else {
smart_str_appendl(buf, "UNKNOWN", 7);
}
smart_str_appendl(buf, " $", 2);
- smart_str_appendl(buf, (*param)->paramName, strlen((*param)->paramName));
- zend_hash_move_forward_ex(function->responseParameters, &pos);
+ smart_str_appendl(buf, param->paramName, strlen(param->paramName));
i++;
- }
+ } ZEND_HASH_FOREACH_END();
smart_str_appendl(buf, ") ", 2);
}
} else {
smart_str_appendc(buf, '(');
if (function->requestParameters) {
i = 0;
- zend_hash_internal_pointer_reset_ex(function->requestParameters, &pos);
- while (zend_hash_get_current_data_ex(function->requestParameters, (void **)¶m, &pos) != FAILURE) {
+ ZEND_HASH_FOREACH_PTR(function->requestParameters, param) {
if (i > 0) {
smart_str_appendl(buf, ", ", 2);
}
- if ((*param)->encode && (*param)->encode->details.type_str) {
- smart_str_appendl(buf, (*param)->encode->details.type_str, strlen((*param)->encode->details.type_str));
+ if (param->encode && param->encode->details.type_str) {
+ smart_str_appendl(buf, param->encode->details.type_str, strlen(param->encode->details.type_str));
} else {
smart_str_appendl(buf, "UNKNOWN", 7);
}
smart_str_appendl(buf, " $", 2);
- smart_str_appendl(buf, (*param)->paramName, strlen((*param)->paramName));
- zend_hash_move_forward_ex(function->requestParameters, &pos);
+ smart_str_appendl(buf, param->paramName, strlen(param->paramName));
i++;
- }
+ } ZEND_HASH_FOREACH_END();
}
smart_str_appendc(buf, ')');
smart_str_0(buf);
case XSD_CONTENT_SEQUENCE:
case XSD_CONTENT_ALL:
case XSD_CONTENT_CHOICE: {
- sdlContentModelPtr *tmp;
+ sdlContentModelPtr tmp;
- zend_hash_internal_pointer_reset(model->u.content);
- while (zend_hash_get_current_data(model->u.content, (void**)&tmp) == SUCCESS) {
- model_to_string(*tmp, buf, level);
- zend_hash_move_forward(model->u.content);
- }
+ ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
+ model_to_string(tmp, buf, level);
+ } ZEND_HASH_FOREACH_END();
break;
}
case XSD_CONTENT_GROUP:
{
int i;
smart_str spaces = {0};
- HashPosition pos;
for (i = 0;i < level;i++) {
smart_str_appendc(&spaces, ' ');
}
- smart_str_appendl(buf, spaces.c, spaces.len);
+ smart_str_appendl(buf, spaces.s->val, spaces.s->len);
switch (type->kind) {
case XSD_TYPEKIND_SIMPLE:
smart_str_appendl(buf, "list ", 5);
smart_str_appendl(buf, type->name, strlen(type->name));
if (type->elements) {
- sdlTypePtr *item_type;
+ sdlTypePtr item_type;
smart_str_appendl(buf, " {", 2);
- zend_hash_internal_pointer_reset_ex(type->elements, &pos);
- if (zend_hash_get_current_data_ex(type->elements, (void **)&item_type, &pos) != FAILURE) {
- smart_str_appendl(buf, (*item_type)->name, strlen((*item_type)->name));
- }
+ ZEND_HASH_FOREACH_PTR(type->elements, item_type) {
+ smart_str_appendl(buf, item_type->name, strlen(item_type->name));
+ } ZEND_HASH_FOREACH_END();
smart_str_appendc(buf, '}');
}
break;
smart_str_appendl(buf, "union ", 6);
smart_str_appendl(buf, type->name, strlen(type->name));
if (type->elements) {
- sdlTypePtr *item_type;
+ sdlTypePtr item_type;
int first = 0;
smart_str_appendl(buf, " {", 2);
- zend_hash_internal_pointer_reset_ex(type->elements, &pos);
- while (zend_hash_get_current_data_ex(type->elements, (void **)&item_type, &pos) != FAILURE) {
+ ZEND_HASH_FOREACH_PTR(type->elements, item_type) {
if (!first) {
smart_str_appendc(buf, ',');
first = 0;
}
- smart_str_appendl(buf, (*item_type)->name, strlen((*item_type)->name));
- zend_hash_move_forward_ex(type->elements, &pos);
- }
+ smart_str_appendl(buf, item_type->name, strlen(item_type->name));
+ } ZEND_HASH_FOREACH_END();
smart_str_appendc(buf, '}');
}
break;
if (type->encode &&
(type->encode->details.type == IS_ARRAY ||
type->encode->details.type == SOAP_ENC_ARRAY)) {
- sdlAttributePtr *attr;
- sdlExtraAttributePtr *ext;
+ sdlAttributePtr attr;
+ sdlExtraAttributePtr ext;
if (type->attributes &&
- zend_hash_find(type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType",
- sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType"),
- (void **)&attr) == SUCCESS &&
- zend_hash_find((*attr)->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType"), (void **)&ext) == SUCCESS) {
- char *end = strchr((*ext)->val, '[');
+ (attr = zend_hash_str_find_ptr(type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType",
+ sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType")-1)) != NULL &&
+ (ext = zend_hash_str_find_ptr(attr->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType")-1)) != NULL) {
+ char *end = strchr(ext->val, '[');
int len;
if (end == NULL) {
- len = strlen((*ext)->val);
+ len = strlen(ext->val);
} else {
- len = end-(*ext)->val;
+ len = end-ext->val;
}
if (len == 0) {
smart_str_appendl(buf, "anyType", sizeof("anyType")-1);
} else {
- smart_str_appendl(buf, (*ext)->val, len);
+ smart_str_appendl(buf, ext->val, len);
}
smart_str_appendc(buf, ' ');
smart_str_appendl(buf, type->name, strlen(type->name));
} else {
sdlTypePtr elementType;
if (type->attributes &&
- zend_hash_find(type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType",
- sizeof(SOAP_1_2_ENC_NAMESPACE":itemType"),
- (void **)&attr) == SUCCESS &&
- zend_hash_find((*attr)->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":arrayType"), (void **)&ext) == SUCCESS) {
- smart_str_appends(buf, (*ext)->val);
+ (attr = zend_hash_str_find_ptr(type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType",
+ sizeof(SOAP_1_2_ENC_NAMESPACE":itemType")-1)) != NULL &&
+ (ext = zend_hash_str_find_ptr(attr->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":arrayType")-1)) != NULL) {
+ smart_str_appends(buf, ext->val);
smart_str_appendc(buf, ' ');
} else if (type->elements &&
zend_hash_num_elements(type->elements) == 1 &&
(zend_hash_internal_pointer_reset(type->elements),
- zend_hash_get_current_data(type->elements, (void**)&elementType) == SUCCESS) &&
- (elementType = *(sdlTypePtr*)elementType) != NULL &&
+ (elementType = zend_hash_get_current_data_ptr(type->elements)) != NULL) &&
elementType->encode && elementType->encode->details.type_str) {
smart_str_appends(buf, elementType->encode->details.type_str);
smart_str_appendc(buf, ' ');
}
smart_str_appendl(buf, type->name, strlen(type->name));
if (type->attributes &&
- zend_hash_find(type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
- sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize"),
- (void **)&attr) == SUCCESS &&
- zend_hash_find((*attr)->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":arraySize"), (void **)&ext) == SUCCESS) {
+ (attr = zend_hash_str_find_ptr(type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
+ sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL &&
+ (ext = zend_hash_str_find_ptr(attr->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":arraySize")-1)) != NULL) {
smart_str_appendc(buf, '[');
- smart_str_appends(buf, (*ext)->val);
+ smart_str_appends(buf, ext->val);
smart_str_appendc(buf, ']');
} else {
smart_str_appendl(buf, "[]", 2);
enc = enc->details.sdl_type->encode;
}
if (enc) {
- smart_str_appendl(buf, spaces.c, spaces.len);
+ smart_str_appendl(buf, spaces.s->val, spaces.s->len);
smart_str_appendc(buf, ' ');
smart_str_appendl(buf, type->encode->details.type_str, strlen(type->encode->details.type_str));
smart_str_appendl(buf, " _;\n", 4);
model_to_string(type->model, buf, level+1);
}
if (type->attributes) {
- sdlAttributePtr *attr;
+ sdlAttributePtr attr;
- zend_hash_internal_pointer_reset_ex(type->attributes, &pos);
- while (zend_hash_get_current_data_ex(type->attributes, (void **)&attr, &pos) != FAILURE) {
- smart_str_appendl(buf, spaces.c, spaces.len);
+ ZEND_HASH_FOREACH_PTR(type->attributes, attr) {
+ smart_str_appendl(buf, spaces.s->val, spaces.s->len);
smart_str_appendc(buf, ' ');
- if ((*attr)->encode && (*attr)->encode->details.type_str) {
- smart_str_appends(buf, (*attr)->encode->details.type_str);
+ if (attr->encode && attr->encode->details.type_str) {
+ smart_str_appends(buf, attr->encode->details.type_str);
smart_str_appendc(buf, ' ');
} else {
smart_str_appendl(buf, "UNKNOWN ", 8);
}
- smart_str_appends(buf, (*attr)->name);
+ smart_str_appends(buf, attr->name);
smart_str_appendl(buf, ";\n", 2);
- zend_hash_move_forward_ex(type->attributes, &pos);
- }
+ } ZEND_HASH_FOREACH_END();
}
- smart_str_appendl(buf, spaces.c, spaces.len);
+ smart_str_appendl(buf, spaces.s->val, spaces.s->len);
smart_str_appendc(buf, '}');
}
break;
zend_hash_destroy(service->class_map);
FREE_HASHTABLE(service->class_map);
}
- if (service->soap_object) {
- zval_ptr_dtor(&service->soap_object);
- }
+ zval_ptr_dtor(&service->soap_object);
efree(service);
}
projects / php / commitdiff