- function/method overloading (test(int); test(string))
- wsdl caching
- wsdl auto generation
+? SOAP binding
+- HTTP GET/POST binding
+- MIME binding
Error Handling
--------------
- transport abstraction layer
? SoapAction HTTP header field
? HTTP status codes
+? HTTP chunked Transfer-Encoding
UDDI
----
#include "php_soap.h"
+/* zval type decode */
+static zval *to_zval_double(encodeType type, xmlNodePtr data);
+static zval *to_zval_long(encodeType type, xmlNodePtr data);
+static zval *to_zval_ulong(encodeType type, xmlNodePtr data);
+static zval *to_zval_bool(encodeType type, xmlNodePtr data);
+static zval *to_zval_string(encodeType type, xmlNodePtr data);
+static zval *to_zval_stringr(encodeType type, xmlNodePtr data);
+static zval *to_zval_stringc(encodeType type, xmlNodePtr data);
+static zval *to_zval_map(encodeType type, xmlNodePtr data);
+static zval *to_zval_null(encodeType type, xmlNodePtr data);
+
+static xmlNodePtr to_xml_long(encodeType type, zval *data, int style);
+static xmlNodePtr to_xml_ulong(encodeType type, zval *data, int style);
+static xmlNodePtr to_xml_double(encodeType type, zval *data, int style);
+static xmlNodePtr to_xml_bool(encodeType type, zval *data, int style);
+
+/* String encode */
+static xmlNodePtr to_xml_string(encodeType type, zval *data, int style);
+static xmlNodePtr to_xml_stringl(encodeType type, zval *data, int style);
+
+/* Null encode */
+static xmlNodePtr to_xml_null(encodeType type, zval *data, int style);
+
+/* Struct encode */
+static xmlNodePtr to_xml_object(encodeType type, zval *data, int style);
+
+/* Array encode */
+static xmlNodePtr guess_array_map(encodeType type, zval *data, int style);
+static xmlNodePtr to_xml_array(encodeType type, zval *data, int style);
+static xmlNodePtr to_xml_map(encodeType type, zval *data, int style);
+
+/* Datetime encode/decode */
+static xmlNodePtr to_xml_datetime_ex(encodeType type, zval *data, char *format, int style);
+static xmlNodePtr to_xml_datetime(encodeType type, zval *data, int style);
+static xmlNodePtr to_xml_time(encodeType type, zval *data, int style);
+static xmlNodePtr to_xml_date(encodeType type, zval *data, int style);
+static xmlNodePtr to_xml_gyearmonth(encodeType type, zval *data, int style);
+static xmlNodePtr to_xml_gyear(encodeType type, zval *data, int style);
+static xmlNodePtr to_xml_gmonthday(encodeType type, zval *data, int style);
+static xmlNodePtr to_xml_gday(encodeType type, zval *data, int style);
+static xmlNodePtr to_xml_gmonth(encodeType type, zval *data, int style);
+static xmlNodePtr to_xml_duration(encodeType type, zval *data, int style);
+
encode defaultEncoding[] = {
{{UNKNOWN_TYPE, NULL, NULL, NULL}, guess_zval_convert, guess_xml_convert},
/* TODO: get rid of "bogus".. ither by passing in the already created xmlnode or passing in the node name */
/* String encode/decode */
-zval *to_zval_string(encodeType type, xmlNodePtr data)
+static zval *to_zval_string(encodeType type, xmlNodePtr data)
{
zval *ret;
MAKE_STD_ZVAL(ret);
return ret;
}
-zval *to_zval_stringr(encodeType type, xmlNodePtr data)
+static zval *to_zval_stringr(encodeType type, xmlNodePtr data)
{
zval *ret;
MAKE_STD_ZVAL(ret);
return ret;
}
-zval *to_zval_stringc(encodeType type, xmlNodePtr data)
+static zval *to_zval_stringc(encodeType type, xmlNodePtr data)
{
zval *ret;
MAKE_STD_ZVAL(ret);
return ret;
}
-xmlNodePtr to_xml_string(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_string(encodeType type, zval *data, int style)
{
xmlNodePtr ret;
char *str, *pstr;
return ret;
}
-xmlNodePtr to_xml_stringl(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_stringl(encodeType type, zval *data, int style)
{
xmlNodePtr ret;
return ret;
}
-zval *to_zval_double(encodeType type, xmlNodePtr data)
+static zval *to_zval_double(encodeType type, xmlNodePtr data)
{
zval *ret;
MAKE_STD_ZVAL(ret);
return ret;
}
-zval *to_zval_long(encodeType type, xmlNodePtr data)
+static zval *to_zval_long(encodeType type, xmlNodePtr data)
{
zval *ret;
MAKE_STD_ZVAL(ret);
return ret;
}
-zval *to_zval_ulong(encodeType type, xmlNodePtr data)
+static zval *to_zval_ulong(encodeType type, xmlNodePtr data)
{
zval *ret;
MAKE_STD_ZVAL(ret);
return ret;
}
-xmlNodePtr to_xml_long(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_long(encodeType type, zval *data, int style)
{
xmlNodePtr ret;
zval tmp;
return ret;
}
-xmlNodePtr to_xml_ulong(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_ulong(encodeType type, zval *data, int style)
{
xmlNodePtr ret;
zval tmp;
return ret;
}
-xmlNodePtr to_xml_double(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_double(encodeType type, zval *data, int style)
{
xmlNodePtr ret;
zval tmp;
return ret;
}
-zval *to_zval_bool(encodeType type, xmlNodePtr data)
+static zval *to_zval_bool(encodeType type, xmlNodePtr data)
{
zval *ret;
MAKE_STD_ZVAL(ret);
return ret;
}
-xmlNodePtr to_xml_bool(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_bool(encodeType type, zval *data, int style)
{
xmlNodePtr ret;
zval tmp;
}
/* Null encode/decode */
-zval *to_zval_null(encodeType type, xmlNodePtr data)
+static zval *to_zval_null(encodeType type, xmlNodePtr data)
{
zval *ret;
MAKE_STD_ZVAL(ret);
return ret;
}
-xmlNodePtr to_xml_null(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_null(encodeType type, zval *data, int style)
{
xmlNodePtr ret;
return ret;
}
-xmlNodePtr to_xml_object(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_object(encodeType type, zval *data, int style)
{
xmlNodePtr xmlParam;
HashTable *prop;
smart_str_free(ns);
efree(ns);
}
- } else {
+ } else if (Z_TYPE_P(data) == IS_OBJECT) {
xmlParam = xmlNewNode(NULL, "BOGUS");
FIND_ZVAL_NULL(data, xmlParam, style);
}
/* Array encode/decode */
-xmlNodePtr guess_array_map(encodeType type, zval *data, int style)
+static xmlNodePtr guess_array_map(encodeType type, zval *data, int style)
{
encodePtr enc = NULL;
TSRMLS_FETCH();
return master_to_xml(enc, data, style);
}
-xmlNodePtr to_xml_array(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_array(encodeType type, zval *data, int style)
{
smart_str array_type_and_size = {0}, array_type = {0};
int i;
xmlAddChild(xmlParam, xparam);
zend_hash_move_forward(data->value.ht);
}
- }
- if (style == SOAP_ENCODED) {
- set_ns_and_type(xmlParam, type);
+ if (style == SOAP_ENCODED) {
+ set_ns_and_type(xmlParam, type);
+ }
}
return xmlParam;
}
}
/* Map encode/decode */
-xmlNodePtr to_xml_map(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_map(encodeType type, zval *data, int style)
{
xmlNodePtr xmlParam;
int i;
}
zend_hash_move_forward(data->value.ht);
}
- }
- if (style == SOAP_ENCODED) {
- set_ns_and_type(xmlParam, type);
+ if (style == SOAP_ENCODED) {
+ set_ns_and_type(xmlParam, type);
+ }
}
return xmlParam;
}
-zval *to_zval_map(encodeType type, xmlNodePtr data)
+static zval *to_zval_map(encodeType type, xmlNodePtr data)
{
zval *ret, *key, *value;
xmlNodePtr trav, item, xmlKey, xmlValue;
}
/* Time encode/decode */
-xmlNodePtr to_xml_datetime_ex(encodeType type, zval *data, char *format, int style)
+static xmlNodePtr to_xml_datetime_ex(encodeType type, zval *data, char *format, int style)
{
/* logic hacked from ext/standard/datetime.c */
struct tm *ta, tmbuf;
return xmlParam;
}
-xmlNodePtr to_xml_duration(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_duration(encodeType type, zval *data, int style)
{
/* TODO: '-'?P([0-9]+Y)?([0-9]+M)?([0-9]+D)?T([0-9]+H)?([0-9]+M)?([0-9]+S)? */
return to_xml_string(type, data, style);
}
-xmlNodePtr to_xml_datetime(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_datetime(encodeType type, zval *data, int style)
{
return to_xml_datetime_ex(type, data, "%Y-%m-%dT%H:%M:%S", style);
}
-xmlNodePtr to_xml_time(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_time(encodeType type, zval *data, int style)
{
/* TODO: microsecconds */
return to_xml_datetime_ex(type, data, "%H:%M:%S", style);
}
-xmlNodePtr to_xml_date(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_date(encodeType type, zval *data, int style)
{
return to_xml_datetime_ex(type, data, "%Y-%m-%d", style);
}
-xmlNodePtr to_xml_gyearmonth(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_gyearmonth(encodeType type, zval *data, int style)
{
return to_xml_datetime_ex(type, data, "%Y-%m", style);
}
-xmlNodePtr to_xml_gyear(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_gyear(encodeType type, zval *data, int style)
{
return to_xml_datetime_ex(type, data, "%Y", style);
}
-xmlNodePtr to_xml_gmonthday(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_gmonthday(encodeType type, zval *data, int style)
{
return to_xml_datetime_ex(type, data, "--%m-%d", style);
}
-xmlNodePtr to_xml_gday(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_gday(encodeType type, zval *data, int style)
{
return to_xml_datetime_ex(type, data, "---%d", style);
}
-xmlNodePtr to_xml_gmonth(encodeType type, zval *data, int style)
+static xmlNodePtr to_xml_gmonth(encodeType type, zval *data, int style)
{
return to_xml_datetime_ex(type, data, "--%m--", style);
}
void whiteSpace_replace(char* str);
void whiteSpace_collapse(char* str);
-/* zval type decode */
-zval *to_zval_double(encodeType type, xmlNodePtr data);
-zval *to_zval_long(encodeType type, xmlNodePtr data);
-zval *to_zval_ulong(encodeType type, xmlNodePtr data);
-zval *to_zval_bool(encodeType type, xmlNodePtr data);
zval *to_zval_object(encodeType type, xmlNodePtr data);
-zval *to_zval_string(encodeType type, xmlNodePtr data);
-zval *to_zval_stringr(encodeType type, xmlNodePtr data);
-zval *to_zval_stringc(encodeType type, xmlNodePtr data);
zval *to_zval_array(encodeType type, xmlNodePtr data);
-zval *to_zval_map(encodeType type, xmlNodePtr data);
-zval *to_zval_null(encodeType type, xmlNodePtr data);
-zval *guess_zval_convert(encodeType type, xmlNodePtr data);
-
-xmlNodePtr to_xml_long(encodeType type, zval *data, int style);
-xmlNodePtr to_xml_ulong(encodeType type, zval *data, int style);
-xmlNodePtr to_xml_double(encodeType type, zval *data, int style);
-xmlNodePtr to_xml_bool(encodeType type, zval *data, int style);
-
-/* String encode */
-xmlNodePtr to_xml_string(encodeType type, zval *data, int style);
-xmlNodePtr to_xml_stringl(encodeType type, zval *data, int style);
-
-/* Null encode */
-xmlNodePtr to_xml_null(encodeType type, zval *data, int style);
-
-/* Struct encode */
-xmlNodePtr to_xml_object(encodeType type, zval *data, int style);
-
-/* Array encode */
-xmlNodePtr guess_array_map(encodeType type, zval *data, int style);
-xmlNodePtr to_xml_array(encodeType type, zval *data, int style);
-xmlNodePtr to_xml_map(encodeType type, zval *data, int style);
/* Try and guess for non-wsdl clients and servers */
+zval *guess_zval_convert(encodeType type, xmlNodePtr data);
xmlNodePtr guess_xml_convert(encodeType type, zval *data, int style);
-/* Datetime encode/decode */
-xmlNodePtr to_xml_datetime_ex(encodeType type, zval *data, char *format, int style);
-xmlNodePtr to_xml_datetime(encodeType type, zval *data, int style);
-xmlNodePtr to_xml_time(encodeType type, zval *data, int style);
-xmlNodePtr to_xml_date(encodeType type, zval *data, int style);
-xmlNodePtr to_xml_gyearmonth(encodeType type, zval *data, int style);
-xmlNodePtr to_xml_gyear(encodeType type, zval *data, int style);
-xmlNodePtr to_xml_gmonthday(encodeType type, zval *data, int style);
-xmlNodePtr to_xml_gday(encodeType type, zval *data, int style);
-xmlNodePtr to_xml_gmonth(encodeType type, zval *data, int style);
-xmlNodePtr to_xml_duration(encodeType type, zval *data, int style);
-
#define get_conversion(e) get_conversion_ex(SOAP_GLOBAL(defEncIndex), e)
#define get_conversion_from_type(n, t) get_conversion_from_type_ex(SOAP_GLOBAL(defEnc), n, t)
#define get_conversion_from_href_type(t) get_conversion_from_href_type_ex(SOAP_GLOBAL(defEnc), t, strlen(t))
#define smart_str_append_const(str, const) \
smart_str_appendl(str,const,sizeof(const)-1)
-int send_http_soap_request(zval *this_ptr, xmlDoc *doc, char *soapaction TSRMLS_DC)
+int send_http_soap_request(zval *this_ptr, xmlDoc *doc, char *location, char *soapaction TSRMLS_DC)
{
xmlChar *buf;
smart_str soap_headers = {0};
- int buf_size,err,ret;
- sdlPtr sdl;
+ int buf_size,err;
php_url *phpurl = NULL;
php_stream *stream;
- zval **trace;
+ zval **trace, **tmp;
- FETCH_THIS_SOCKET(stream);
- FETCH_THIS_URL(phpurl);
- FETCH_THIS_SDL(sdl);
+ if (this_ptr == NULL || Z_TYPE_P(this_ptr) != IS_OBJECT) {
+ return FALSE;
+ }
+
+ if (zend_hash_find(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket"), (void **)&tmp) == SUCCESS) {
+ php_stream_from_zval_no_verify(stream,tmp);
+ } else {
+ stream = NULL;
+ }
xmlDocDumpMemory(doc, &buf, &buf_size);
if (!buf) {
}
}
+ if (location != NULL && location[0] != '\000') {
+ phpurl = php_url_parse(location);
+ }
+ if (phpurl == NULL) {
+ xmlFree(buf);
+ add_soap_fault(this_ptr, "SOAP-ENV:Client", "Unable to parse URL", NULL, NULL TSRMLS_CC);
+ return FALSE;
+ }
+
if (!stream) {
- char *url;
int use_ssl;
-
- if (!sdl) {
- zval **location;
- if (zend_hash_find(Z_OBJPROP_P(this_ptr), "location", sizeof("location"),(void **) &location) == FAILURE) {
- xmlFree(buf);
- add_soap_fault(this_ptr, "SOAP-ENV:Client", "Error could not find location", NULL, NULL TSRMLS_CC);
- return FALSE;
- }
- url = Z_STRVAL_PP(location);
- } else {
- sdlBindingPtr binding;
- FETCH_THIS_PORT(binding);
- url = binding->location;
- }
-
- if (url[0] != '\000') {
- phpurl = php_url_parse(url);
- }
- if (phpurl == NULL) {
- xmlFree(buf);
- add_soap_fault(this_ptr, "SOAP-ENV:Client", "Unable to parse URL", NULL, NULL TSRMLS_CC);
- return FALSE;
- }
-
use_ssl = strcmp(phpurl->scheme, "https") == 0;
if (use_ssl && php_stream_locate_url_wrapper("https://", NULL, STREAM_LOCATE_WRAPPERS_ONLY TSRMLS_CC) == NULL) {
xmlFree(buf);
if (stream) {
php_stream_auto_cleanup(stream);
add_property_resource(this_ptr, "httpsocket", php_stream_get_resource_id(stream));
- ret = zend_list_insert(phpurl, le_url);
- add_property_resource(this_ptr, "httpurl", ret);
- zend_list_addref(ret);
} else {
xmlFree(buf);
php_url_free(phpurl);
smart_str_append_long(&soap_headers, buf_size);
smart_str_append_const(&soap_headers, "\r\n"
"SOAPAction: \"");
- /* TODO: need to grab soap action from wsdl....*/
smart_str_appends(&soap_headers, soapaction);
smart_str_append_const(&soap_headers, "\"\r\n");
err = php_stream_write(stream, soap_headers.c, soap_headers.len);
if (err != soap_headers.len) {
+ php_url_free(phpurl);
xmlFree(buf);
smart_str_free(&soap_headers);
php_stream_close(stream);
smart_str_free(&soap_headers);
}
+ php_url_free(phpurl);
xmlFree(buf);
return TRUE;
}
{
char *http_headers, *http_body, *content_type, *http_version, http_status[4], *cookie_itt;
int http_header_size, http_body_size, http_close;
- zval **socket_ref;
php_stream *stream;
- zval **trace;
+ zval **trace, **tmp;
char* connection;
int http_1_1 = 0;
- if (FIND_SOCKET_PROPERTY(this_ptr, socket_ref) != FAILURE) {
- FETCH_SOCKET_RES(stream, socket_ref);
+ if (zend_hash_find(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket"), (void **)&tmp) == SUCCESS) {
+ php_stream_from_zval_no_verify(stream,tmp);
+ } else {
+ stream = NULL;
+ }
+ if (stream == NULL) {
+ return FALSE;
}
if (!get_http_headers(stream, &http_headers, &http_header_size TSRMLS_CC)) {
add_property_stringl(this_ptr, "__last_response", http_body, http_body_size, 1);
}
- /* Close every time right now till i can spend more time on it
- it works.. it's just slower??
- */
/* See if the server requested a close */
http_close = TRUE;
connection = get_http_header_value(http_headers,"Connection: ");
#ifndef PHP_HTTP_H
#define PHP_HTTP_H
-int send_http_soap_request(zval *this_ptr, xmlDoc *doc, char *soapaction TSRMLS_DC);
+int send_http_soap_request(zval *this_ptr, xmlDoc *doc, char *location, char *soapaction TSRMLS_DC);
int get_http_soap_response(zval *this_ptr, char **buffer, int *buffer_len TSRMLS_DC);
#endif
char *name, *ns = NULL;
zval* tmp;
- if (fn->bindingType == BINDING_SOAP) {
+ if (fn->binding->bindingType == BINDING_SOAP) {
sdlSoapBindingFunctionPtr fnb = (sdlSoapBindingFunctionPtr)fn->bindingAttributes;
int res_count = zend_hash_num_elements(fn->responseParameters);
#include "php_soap.h"
+typedef struct sdlCtx {
+ sdlPtr root;
+ HashTable messages;
+ HashTable bindings;
+ HashTable portTypes;
+ HashTable services;
+} sdlCtx;
+
+static void delete_binding(void *binding);
+static void delete_function(void *function);
+static void delete_paramater(void *paramater);
+static void delete_document(void *doc_ptr);
+
encodePtr get_encoder_from_prefix(sdlPtr sdl, xmlNodePtr data, const char *type)
{
encodePtr enc = NULL;
return enc;
}
-zval *sdl_guess_convert_zval(encodeType enc, xmlNodePtr data)
-{
- sdlTypePtr type;
-
- type = enc.sdl_type;
- if (type->encode) {
- if (type->encode->details.type == IS_ARRAY ||
- type->encode->details.type == SOAP_ENC_ARRAY) {
- return to_zval_array(enc, data);
- } else if (type->encode->details.type == IS_OBJECT ||
- type->encode->details.type == SOAP_ENC_OBJECT) {
- return to_zval_object(enc, data);
- } else {
- if (memcmp(&type->encode->details,&enc,sizeof(enc))!=0) {
- return master_to_zval(type->encode, data);
- } else {
- TSRMLS_FETCH();
- return master_to_zval(get_conversion(UNKNOWN_TYPE), data);
- }
- }
- } else if (type->elements) {
- return to_zval_object(enc, data);
- } else {
- return guess_zval_convert(enc, data);
- }
-}
-
-xmlNodePtr sdl_guess_convert_xml(encodeType enc, zval *data, int style)
-{
- sdlTypePtr type;
- xmlNodePtr ret = NULL;
-
- type = enc.sdl_type;
-
- if (type->restrictions) {
- if (type->restrictions->enumeration) {
- if (Z_TYPE_P(data) == IS_STRING) {
- if (!zend_hash_exists(type->restrictions->enumeration,Z_STRVAL_P(data),Z_STRLEN_P(data)+1)) {
- php_error(E_WARNING,"Restriction: invalid enumeration value \"%s\".",Z_STRVAL_P(data));
- }
- }
- }
- }
-
- if (type->encode) {
- if (type->encode->details.type == IS_ARRAY ||
- type->encode->details.type == SOAP_ENC_ARRAY) {
- ret = sdl_to_xml_array(type, data, style);
- } else if (type->encode->details.type == IS_OBJECT ||
- type->encode->details.type == SOAP_ENC_OBJECT) {
- ret = sdl_to_xml_object(type, data, style);
- } else {
- if (memcmp(&type->encode->details,&enc,sizeof(enc))!=0) {
- ret = master_to_xml(type->encode, data, style);
- } else {
- TSRMLS_FETCH();
- ret = master_to_xml(get_conversion(UNKNOWN_TYPE), data, style);
- }
- }
- }
- else if (type->elements) {
- ret = sdl_to_xml_object(type, data, style);
- } else {
- ret = guess_xml_convert(enc, data, style);
- }
- set_ns_and_type(ret, enc);
- return ret;
-}
-
-xmlNodePtr sdl_to_xml_object(sdlTypePtr type, zval *data, int style)
+static xmlNodePtr sdl_to_xml_object(encodeType enc_type, zval *data, int style)
{
+ sdlTypePtr type = enc_type.sdl_type;
xmlNodePtr ret;
sdlTypePtr *t, tmp;
TSRMLS_FETCH();
}
zend_hash_move_forward(type->elements);
}
+ if (style == SOAP_ENCODED) {
+ set_ns_and_type(ret, enc_type);
+ }
return ret;
}
}
}
-xmlNodePtr sdl_to_xml_array(sdlTypePtr type, zval *data, int style)
+static xmlNodePtr sdl_to_xml_array(encodeType enc_type, zval *data, int style)
{
+ sdlTypePtr type = enc_type.sdl_type;
smart_str array_type_and_size = {0}, array_type = {0};
int i;
int dimension = 1;
add_xml_array_elements(xmlParam, type, enc, dimension, dims, data, style);
efree(dims);
+ if (style == SOAP_ENCODED) {
+ set_ns_and_type(xmlParam, enc_type);
+ }
}
return xmlParam;
}
-sdlPtr get_sdl(char *uri)
+zval *sdl_guess_convert_zval(encodeType enc, xmlNodePtr data)
{
- sdlPtr tmp, *hndl;
- TSRMLS_FETCH();
+ sdlTypePtr type;
- tmp = NULL;
- hndl = NULL;
- if (zend_hash_find(SOAP_GLOBAL(sdls), uri, strlen(uri), (void **)&hndl) == FAILURE) {
- tmp = load_wsdl(uri);
- zend_hash_add(SOAP_GLOBAL(sdls), uri, strlen(uri), &tmp, sizeof(sdlPtr), NULL);
- } else {
- tmp = *hndl;
+ type = enc.sdl_type;
+ if (type->encode) {
+ if (type->encode->details.type == IS_ARRAY ||
+ type->encode->details.type == SOAP_ENC_ARRAY) {
+ return to_zval_array(enc, data);
+ } else if (type->encode->details.type == IS_OBJECT ||
+ type->encode->details.type == SOAP_ENC_OBJECT) {
+ return to_zval_object(enc, data);
+ } else {
+ if (memcmp(&type->encode->details,&enc,sizeof(enc))!=0) {
+ return master_to_zval(type->encode, data);
+ } else {
+ TSRMLS_FETCH();
+ return master_to_zval(get_conversion(UNKNOWN_TYPE), data);
+ }
+ }
+ } else if (type->elements) {
+ return to_zval_object(enc, data);
+ } else {
+ return guess_zval_convert(enc, data);
}
+}
- return tmp;
+xmlNodePtr sdl_guess_convert_xml(encodeType enc, zval *data, int style)
+{
+ sdlTypePtr type;
+ xmlNodePtr ret = NULL;
+
+ type = enc.sdl_type;
+
+ if (type->restrictions) {
+ if (type->restrictions->enumeration) {
+ if (Z_TYPE_P(data) == IS_STRING) {
+ if (!zend_hash_exists(type->restrictions->enumeration,Z_STRVAL_P(data),Z_STRLEN_P(data)+1)) {
+ php_error(E_WARNING,"Restriction: invalid enumeration value \"%s\".",Z_STRVAL_P(data));
+ }
+ }
+ }
+ }
+
+ if (type->encode) {
+ if (type->encode->details.type == IS_ARRAY ||
+ type->encode->details.type == SOAP_ENC_ARRAY) {
+ ret = sdl_to_xml_array(enc, data, style);
+ } else if (type->encode->details.type == IS_OBJECT ||
+ type->encode->details.type == SOAP_ENC_OBJECT) {
+ ret = sdl_to_xml_object(enc, data, style);
+ } else {
+ if (memcmp(&type->encode->details,&enc,sizeof(enc))!=0) {
+ ret = master_to_xml(type->encode, data, style);
+ } else {
+ TSRMLS_FETCH();
+ ret = master_to_xml(get_conversion(UNKNOWN_TYPE), data, style);
+ }
+ }
+ }
+ else if (type->elements) {
+ ret = sdl_to_xml_object(enc, data, style);
+ } else {
+ ret = guess_xml_convert(enc, data, style);
+ }
+ return ret;
}
sdlBindingPtr get_binding_from_type(sdlPtr sdl, int type)
return binding;
}
-int load_php_sdl()
-{
-#ifdef BRAD_0
- xmlNodePtr rootElement;
- xmlNodePtr services;
-
- SOAP_SERVER_GLOBAL_VARS();
- SOAP_SERVER_GLOBAL(availableServices) = xmlParseFile(servicesFile);
- rootElement = SOAP_SERVER_GLOBAL(availableServices)->children;
- services = rootElement->children;
-
- do {
- if (IS_ELEMENT_TYPE(services,PHP_SOAPSERVER_SERVICE)) {
- phpSoapServicePtr newService;
- xmlNodePtr attrib, trav;
- HashTable *fn = NULL;
- HashTable *include = NULL;
- HashTable *cl = NULL;
-
- /* Init New Service */
- newService = emalloc(sizeof(phpSoapService));
- newService->serviceNode = services;
- newService->started = FALSE;
-
- fn = newService->functions = emalloc(sizeof(HashTable));
- include = newService->include_files = emalloc(sizeof(HashTable));
- zend_hash_init(fn, 0, NULL, free_function, 0);
- zend_hash_init(include, 0, NULL, ZVAL_PTR_DTOR, 0);
-
- attrib = services->properties;
- trav = attrib;
- /* Get Attributes of Service */
- do {
- if (IS_ATTRIBUTE_TYPE(trav,PHP_SOAPSERVER_SERVICE_NAME)) {
- char* name = ATTRIBUTE_VALUE(trav);
-
- /* Assign Service Vals */
- ALLOC_INIT_ZVAL(newService->serviceName);
- ZVAL_STRING(newService->serviceName,name,1);
- }
-
- if (IS_ATTRIBUTE_TYPE(trav,PHP_SOAPSERVER_SERVICE_STARTED)) {
- char* started = ATTRIBUTE_VALUE(trav);
-
- /* Assign Service Vals */
- if (!stricmp(started,"true")) {
- newService->started = TRUE;
- }
- }
- } while (trav = trav->next);
-
- /* Get ChildNodes of Service */
- trav = services->children;
- do {
- /* Include Files */
- if (IS_ELEMENT_TYPE(trav,PHP_SOAPSERVER_SERVICE_INCLUDE_FILE)) {
- xmlNodePtr trav1 = trav->properties;
- do {
- if (IS_ATTRIBUTE_TYPE(trav1,PHP_SOAPSERVER_SERVICE_INCLUDE_FILE_NAME)) {
- char* name = ATTRIBUTE_VALUE(trav1);
- zval* z_name;
-
- ALLOC_INIT_ZVAL(z_name);
- ZVAL_STRING(z_name,name,1);
- zend_hash_next_index_insert(include,&z_name,sizeof(zval),NULL);
- }
- } while (trav1 = trav1->next);
- }
-
- /* Functions */
- if (IS_ELEMENT_TYPE(trav,PHP_SOAPSERVER_SERVICE_FUNCTION)) {
- phpSoapServiceFunctionPtr function;
- xmlNodePtr trav1;
- HashTable *par = NULL;
-
- function = emalloc(sizeof(phpSoapServiceFunction));
- function->functionNode = trav;
-
- par = function->functionParams = emalloc(sizeof(HashTable));
- zend_hash_init(par, 0, NULL, free_param, 0);
-
- trav1 = trav->properties;
-
- do {
- if (IS_ATTRIBUTE_TYPE(trav1,PHP_SOAPSERVER_SERVICE_FUNCTION_NAME)) {
- char* name = ATTRIBUTE_VALUE(trav1);
-
- ALLOC_INIT_ZVAL(function->functionName);
- ZVAL_STRING(function->functionName,name,1);
- }
- } while (trav1 = trav1->next);
-
- trav1 = trav->children;
- do {
- if (IS_ELEMENT_TYPE(trav1,PHP_SOAPSERVER_SERVICE_FUNCTION_PARAM)) {
- phpSoapServiceParamPtr param;
- xmlNodePtr trav2;
-
- param = emalloc(sizeof(phpSoapServiceParam));
- param->paramNode = trav1;
-
- trav2 = trav1->properties;
-
- do {
- if (IS_ATTRIBUTE_TYPE(trav2,PHP_SOAPSERVER_SERVICE_FUNCTION_PARAM_NAME)) {
- char* name = ATTRIBUTE_VALUE(trav2);
-
- ALLOC_INIT_ZVAL(param->paramName);
- ZVAL_STRING(param->paramName,name,1);
- } else if (IS_ATTRIBUTE_TYPE(trav2,PHP_SOAPSERVER_SERVICE_FUNCTION_PARAM_TYPE)) {
- char* type = ATTRIBUTE_VALUE(trav2);
- ALLOC_INIT_ZVAL(param->paramType);
- ZVAL_STRING(param->paramType,type,1);
- } else if (IS_ATTRIBUTE_TYPE(trav2,PHP_SOAPSERVER_SERVICE_FUNCTION_PARAM_POSITION)) {
- char* val = ATTRIBUTE_VALUE(trav2);
- ALLOC_INIT_ZVAL(param->paramName);
- ZVAL_LONG(param->paramName,atoi(val));
- }
- } while (trav2 = trav2->next);
- zend_hash_add(par,Z_STRVAL_P(param->paramName),Z_STRLEN_P(param->paramName),param,sizeof(phpSoapServiceParam),NULL);
- }
- } while (trav1 = trav1->next);
- zend_hash_add(fn,Z_STRVAL_P(function->functionName),Z_STRLEN_P(function->functionName),function,sizeof(phpSoapServiceFunction),NULL);
- }
-
- /* Classes */
- if (IS_ELEMENT_TYPE(trav,PHP_SOAPSERVER_SERVICE_CLASS)) {
- xmlNodePtr att, func;
- att = trav->properties;
-
- if (fn == NULL) {
- fn = newService->functions = emalloc(sizeof(HashTable));
- zend_hash_init(fn, 0, NULL, ZVAL_PTR_DTOR, 0);
- }
-
- }
-
- } while (trav = trav->next);
-
- zend_hash_add(SOAP_SERVER_GLOBAL(services),Z_STRVAL_P(newService->serviceName),Z_STRLEN_P(newService->serviceName),newService,sizeof(phpSoapService),NULL);
- }
- } while (services = services->next);
-#endif
- return TRUE;
-}
-
-int write_php_sdl()
-{
- return TRUE;
-}
-
-typedef struct sdlCtx {
- sdlPtr root;
- HashTable messages;
- HashTable bindings;
- HashTable portTypes;
- HashTable services;
-} sdlCtx;
-
static void load_wsdl_ex(char *struri, sdlCtx *ctx, int include)
{
sdlPtr tmpsdl = ctx->root;
php_error(E_ERROR, "SOAP-ERROR: Parsing WSDL: Couldn't find \"definitions\" in %s", struri);
}
- targetNamespace = get_attribute(definitions->properties, "targetNamespace");
- if (targetNamespace) {
- tmpsdl->target_ns = strdup(targetNamespace->children->content);
+ if (!include) {
+ targetNamespace = get_attribute(definitions->properties, "targetNamespace");
+ if (targetNamespace) {
+ tmpsdl->target_ns = strdup(targetNamespace->children->content);
+ }
}
trav = definitions->children;
}
}
-static void delete_document(void *doc_ptr)
-{
- xmlDocPtr doc = *((xmlDocPtr*)doc_ptr);
- xmlFreeDoc(doc);
-}
-
-sdlPtr load_wsdl(char *struri)
+static sdlPtr load_wsdl(char *struri)
{
sdlCtx ctx;
int i,n;
memset(ctx.root, 0, sizeof(sdl));
ctx.root->source = strdup(struri);
zend_hash_init(&ctx.root->docs, 0, NULL, delete_document, 1);
+ zend_hash_init(&ctx.root->functions, 0, NULL, delete_function, 1);
zend_hash_init(&ctx.messages, 0, NULL, NULL, 0);
zend_hash_init(&ctx.bindings, 0, NULL, NULL, 0);
function->responseName = NULL;
function->requestName = NULL;
function->bindingAttributes = NULL;
- function->bindingType = tmpbinding->bindingType;
if (tmpbinding->bindingType == BINDING_SOAP) {
sdlSoapBindingFunctionPtr soapFunctionBinding;
if (!fault) {
}
- if (!tmpbinding->functions) {
- tmpbinding->functions = malloc(sizeof(HashTable));
- zend_hash_init(tmpbinding->functions, 0, NULL, delete_function, 1);
- }
-
- zend_hash_add(tmpbinding->functions, php_strtolower(function->functionName, strlen(function->functionName)), strlen(function->functionName), &function, sizeof(sdlFunctionPtr), NULL);
+ function->binding = tmpbinding;
+ zend_hash_add(&ctx.root->functions, php_strtolower(function->functionName, strlen(function->functionName)), strlen(function->functionName), &function, sizeof(sdlFunctionPtr), NULL);
}
ENDFOREACH(trav2);
return ctx.root;
}
-int write_wsdl()
+sdlPtr get_sdl(char *uri)
{
- return TRUE;
+ sdlPtr tmp, *hndl;
+ TSRMLS_FETCH();
+
+ tmp = NULL;
+ hndl = NULL;
+ if (zend_hash_find(SOAP_GLOBAL(sdls), uri, strlen(uri), (void **)&hndl) == FAILURE) {
+ tmp = load_wsdl(uri);
+ zend_hash_add(SOAP_GLOBAL(sdls), uri, strlen(uri), &tmp, sizeof(sdlPtr), NULL);
+ } else {
+ tmp = *hndl;
+ }
+
+ return tmp;
}
-int write_ms_sdl()
+/* Deletes */
+void delete_sdl(void *handle)
{
- return TRUE;
+ sdlPtr tmp = *((sdlPtr*)handle);
+
+ zend_hash_destroy(&tmp->docs);
+ zend_hash_destroy(&tmp->functions);
+ if (tmp->source) {
+ free(tmp->source);
+ }
+ if (tmp->target_ns) {
+ free(tmp->target_ns);
+ }
+ if (tmp->encoders) {
+ zend_hash_destroy(tmp->encoders);
+ free(tmp->encoders);
+ }
+ if (tmp->types) {
+ zend_hash_destroy(tmp->types);
+ free(tmp->types);
+ }
+ if (tmp->bindings) {
+ zend_hash_destroy(tmp->bindings);
+ free(tmp->bindings);
+ }
+ free(tmp);
}
-int load_ms_sdl(char *struri,int force_load)
+static void delete_binding(void *data)
{
-/* Commenting this out. Does anyone need it? */
-#ifdef BRAD_0
-
- if (get_sdl(struri) == NULL || force_load) {
- SOAP_TLS_VARS();
- xmlDocPtr sdl = xmlParseFile(struri);
- xmlNodePtr schema,trav,trav2,req,res,paramOrd,reqRes,address,serviceAdd,service,soap,serviceDesc,root = sdl->children;
- xmlAttrPtr tmpattr,uri;
- char *add,*functionName,*soapAction,*request,*response,*parameterOrder,*value,*namespace;
- SDLPtr sdlPtr;
- SoapFunctionPtr tmpFunction;
- zval *tempZval;
- serviceDesc = get_node(root,"serviceDescription");
- soap = get_node(serviceDesc->children,"soap");
- trav = soap->children;
- sdlPtr = emalloc(sizeof(SDL));
-
- ALLOC_INIT_ZVAL(sdlPtr->sdlUri);
- ZVAL_STRING(sdlPtr->sdlUri,struri,1);
-
- FOREACHNODE(trav,"service",service) {
- sdlPtr->soapFunctions = emalloc(sizeof(HashTable));
- sdlPtr->addresses = emalloc(sizeof(HashTable));
- zend_hash_init(sdlPtr->soapFunctions, 0, NULL, delete_function, 0);
- zend_hash_init(sdlPtr->addresses, 0, NULL, ZVAL_PTR_DTOR, 0);
-
- serviceAdd = get_node(service->children,"addresses");
- trav2 = serviceAdd->children;
- ALLOC_INIT_ZVAL(tempZval);
- FOREACHNODE(trav2,"address",address) {
- uri = get_attribute(address->properties,"uri");
- add = uri->children->content;
- ZVAL_STRING(tempZval,add,1);
- zend_hash_next_index_insert(sdlPtr->addresses,tempZval,sizeof(zval),NULL);
- }
- ENDFOREACH(trav2);
- trav2 = service->children;
- FOREACHNODE(trav2,"requestResponse",reqRes) {
- tmpFunction = emalloc(sizeof(SoapFunction));
-
- tmpattr = get_attribute(reqRes->properties,"name");
- functionName = tmpattr->children->content;
- ALLOC_INIT_ZVAL(tmpFunction->functionName);
- ZVAL_STRING(tmpFunction->functionName,functionName,1);
-
- tmpattr = get_attribute(reqRes->properties,"soapAction");
- soapAction = tmpattr->children->content;
- ALLOC_INIT_ZVAL(tmpFunction->soapAction);
- ZVAL_STRING(tmpFunction->soapAction,soapAction,1);
-
- /* Request */
- req = get_node(reqRes->children,"request");
- tmpattr = get_attribute(req->properties,"ref");
- if (tmpattr != NULL) {
- request = tmpattr->children->content;
- parse_namespace(request,&value,&namespace);
- ALLOC_INIT_ZVAL(tmpFunction->requestName);
- ZVAL_STRING(tmpFunction->requestName,value,1);
- tmpFunction->requestParameters = emalloc(sizeof(HashTable));
- zend_hash_init(tmpFunction->requestParameters, 0, NULL, delete_paramater, 0);
- efree(value);
- efree(namespace);
- }
+ sdlBindingPtr binding = *((sdlBindingPtr*)data);
- /* Response */
- res = get_node(reqRes->children,"response");
- tmpattr = get_attribute(res->properties,"ref");
- if (tmpattr != NULL) {
- response = tmpattr->children->content;
- parse_namespace(response,&value,&namespace);
- ALLOC_INIT_ZVAL(tmpFunction->responseName);
- ZVAL_STRING(tmpFunction->responseName,value,1);
- tmpFunction->responseParameters = emalloc(sizeof(HashTable));
- zend_hash_init(tmpFunction->responseParameters, 0, NULL, delete_paramater, 0);
- efree(value);
- efree(namespace);
- }
+ if (binding->location) {
+ free(binding->location);
+ }
+ if (binding->name) {
+ free(binding->name);
+ }
- /* Parameters */
- paramOrd = get_node(reqRes->children,"parameterorder");
- if (paramOrd != NULL) {
- zval *space,*array,**strval;
- int count,i;
- ALLOC_INIT_ZVAL(space);
- ZVAL_STRING(space," ",0);
- parameterOrder = paramOrd->children->content;
- ZVAL_STRING(tempZval,parameterOrder,1);
- ALLOC_INIT_ZVAL(array);
- array_init(array);
-
- /* Split on space */
- php_explode(space, tempZval, array, -1);
- zend_hash_internal_pointer_reset(array->value.ht);
- count = zend_hash_num_elements(array->value.ht);
-
- for (i = 0;i < count;i++) {
- SoapParamPtr param;
- param = emalloc(sizeof(SoapParam));
- param->order = i+1;
- param->type = NULL;
- zend_hash_get_current_data(array->value.ht,(void **)&strval);
- ALLOC_INIT_ZVAL(param->paramName);
- ZVAL_STRING(param->paramName,Z_STRVAL_PP(strval),1);
- zend_hash_next_index_insert(tmpFunction->requestParameters,param,sizeof(SoapParam),NULL);
- zend_hash_move_forward(array->value.ht);
- }
- }
- zend_hash_add(sdlPtr->soapFunctions,(char *)php_strtolower(functionName,strlen(functionName)),strlen(functionName),tmpFunction,sizeof(SoapFunction),NULL);
- }
- ENDFOREACH(trav2);
+ if (binding->bindingType == BINDING_SOAP) {
+ sdlSoapBindingPtr soapBind = binding->bindingAttributes;
+ free(soapBind->transport);
+ }
+}
+
+static void delete_sdl_soap_binding_function_body(sdlSoapBindingFunctionBody body)
+{
+ if (body.ns) {
+ free(body.ns);
+ }
+ if (body.parts) {
+ free(body.parts);
+ }
+ if (body.encodingStyle) {
+ free(body.encodingStyle);
+ }
+}
+
+static void delete_function(void *data)
+{
+ sdlFunctionPtr function = *((sdlFunctionPtr*)data);
+
+ if (function->functionName) {
+ free(function->functionName);
+ }
+ if (function->requestName) {
+ free(function->requestName);
+ }
+ if (function->responseName) {
+ free(function->responseName);
+ }
+ if (function->requestParameters) {
+ zend_hash_destroy(function->requestParameters);
+ free(function->requestParameters);
+ }
+ if (function->responseParameters) {
+ zend_hash_destroy(function->responseParameters);
+ free(function->responseParameters);
+ }
+
+ if (function->bindingAttributes &&
+ function->binding && function->binding->bindingType == BINDING_SOAP) {
+ sdlSoapBindingFunctionPtr soapFunction = function->bindingAttributes;
+ if (soapFunction->soapAction) {
+ free(soapFunction->soapAction);
}
- ENDFOREACH(trav);
+ delete_sdl_soap_binding_function_body(soapFunction->input);
+ delete_sdl_soap_binding_function_body(soapFunction->output);
+ delete_sdl_soap_binding_function_body(soapFunction->falut);
+ }
+}
+
+static void delete_paramater(void *data)
+{
+ sdlParamPtr param = *((sdlParamPtr*)data);
+ if (param->paramName) {
+ free(param->paramName);
+ }
+ free(param);
+}
+
+void delete_mapping(void *data)
+{
+ soapMappingPtr map = (soapMappingPtr)data;
+
+ if (map->ns) {
+ efree(map->ns);
+ }
+ if (map->ctype) {
+ efree(map->ctype);
+ }
- trav = serviceDesc->children;
- FOREACHNODE(trav,"schema",schema) {
- load_schema(&sdlPtr, schema);
+ if (map->type == SOAP_MAP_FUNCTION) {
+ if (map->map_functions.to_xml_before) {
+ zval_ptr_dtor(&map->map_functions.to_xml_before);
+ }
+ if (map->map_functions.to_xml) {
+ zval_ptr_dtor(&map->map_functions.to_xml);
+ }
+ if (map->map_functions.to_xml_after) {
+ zval_ptr_dtor(&map->map_functions.to_xml_after);
+ }
+ if (map->map_functions.to_zval_before) {
+ zval_ptr_dtor(&map->map_functions.to_zval_before);
+ }
+ if (map->map_functions.to_zval) {
+ zval_ptr_dtor(&map->map_functions.to_zval);
+ }
+ if (map->map_functions.to_zval_after) {
+ zval_ptr_dtor(&map->map_functions.to_zval_after);
}
- ENDFOREACH(trav);
- sdlPtr->have_sdl = 1;
- map_types_to_functions(sdlPtr);
- zend_hash_add(SOAP_GLOBAL(SDLs),struri,strlen(struri),sdlPtr,sizeof(SDL),NULL);
}
-#endif
- return FALSE;
+ efree(map);
}
void delete_type(void *data)
free(attr->extraAttributes);
}
}
+
+static void delete_document(void *doc_ptr)
+{
+ xmlDocPtr doc = *((xmlDocPtr*)doc_ptr);
+ xmlFreeDoc(doc);
+}
+
struct _sdl {
HashTable docs; /* pointer to the parsed xml file */
+ HashTable functions; /* array of sdlFunction */
HashTable *types; /* array of sdlTypesPtr */
HashTable *encoders; /* array of encodePtr */
HashTable *bindings; /* array of sdlBindings (key'd by name) */
struct _sdlBinding {
char *name;
- HashTable *functions;
char *location;
int bindingType;
- void *bindingAttributes;
+ void *bindingAttributes; /* sdlSoapBindingPtr */
};
/* Soap Binding Specfic stuff */
char *responseName;
HashTable *requestParameters; /* array of sdlParamPtr */
HashTable *responseParameters; /* array of sdlParamPtr (this should only be one) */
- int bindingType;
- void *bindingAttributes;
+ struct _sdlBinding* binding;
+// int bindingType;
+ void* bindingAttributes; /* sdlSoapBindingFunctionPtr */
};
struct _sdlAttribute {
};
sdlPtr get_sdl(char *uri);
-sdlPtr load_wsdl(char *struri);
-int load_sdl(char *struri, int force_load);
-int load_ms_sdl(char *struri, int force_load);
encodePtr get_encoder_from_prefix(sdlPtr sdl, xmlNodePtr data, const char *type);
encodePtr get_encoder(sdlPtr sdl, const char *ns, const char *type);
xmlNodePtr sdl_guess_convert_xml(encodeType enc, zval* data, int style);
zval *sdl_guess_convert_zval(encodeType enc, xmlNodePtr data);
-xmlNodePtr sdl_to_xml_array(sdlTypePtr type, zval *data, int style);
-xmlNodePtr sdl_to_xml_object(sdlTypePtr type, zval *data, int style);
-
+void delete_sdl(void *handle);
void delete_type(void *type);
void delete_attribute(void *attribute);
+void delete_mapping(void *data);
#endif
extern int le_url;
extern int le_service;
-
struct _soapHeaderHandler {
char *ns;
int type;
zval* add_soap_fault(zval *obj, char *fault_code, char *fault_string, char *fault_actor, zval *fault_detail TSRMLS_DC);
sdlParamPtr get_param(sdlFunctionPtr function, char *param_name, int index, int);
-sdlFunctionPtr get_function(sdlBindingPtr sdl, char *function_name);
+sdlFunctionPtr get_function(sdlPtr sdl, char *function_name);
-void delete_sdl(void *handle);
-void delete_binding(void *binding);
-void delete_sdl_soap_binding_function_body(sdlSoapBindingFunctionBody body);
-void delete_function(void *function);
-void delete_paramater(void *paramater);
void delete_service(void *service);
void delete_http_socket(void *handle);
void delete_url(void *handle);
-void delete_mapping(void *data);
#ifndef ZEND_ENGINE_2
void soap_call_function_handler(INTERNAL_FUNCTION_PARAMETERS, zend_property_reference *property_reference);
if (ZEND_NUM_ARGS() != 1 || getParameters(ht, 3, &p, &p1, &p2) == FAILURE) \
WRONG_PARAM_COUNT;
-#define FETCH_THIS_PORT(ss) \
- { \
- zval *__thisObj; zval *__port; sdlBindingPtr *__tmp; \
- GET_THIS_OBJECT(__thisObj) \
- if(FIND_PORT_PROPERTY(__thisObj, __port) == FAILURE) { \
- ss = NULL; \
- php_error(E_ERROR, "Error could find current port"); \
- } \
- __tmp = (sdlBindingPtr*)Z_LVAL_P(__port); \
- ss = *__tmp; \
- }
-
-#define FIND_PORT_PROPERTY(ss,tmp) zend_hash_find(Z_OBJPROP_P(ss), "port", sizeof("port"), (void **)&tmp)
-
#define FETCH_THIS_SDL(ss) \
{ \
zval *__thisObj,**__tmp; \
#define FIND_SERVICE_PROPERTY(ss,tmp) zend_hash_find(Z_OBJPROP_P(ss), "service", sizeof("service"), (void **)&tmp)
#define FETCH_SERVICE_RES(ss,tmp) ss = (soapServicePtr) zend_fetch_resource(tmp TSRMLS_CC, -1, "service", NULL, 1, le_service)
-#define FETCH_THIS_URL(ss) \
- { \
- zval *__thisObj,**__tmp; \
- GET_THIS_OBJECT(__thisObj) \
- if(FIND_URL_PROPERTY(__thisObj,__tmp) != FAILURE) { \
- FETCH_URL_RES(ss,__tmp); \
- } else { \
- ss = NULL; \
- } \
- }
-
-#define FIND_URL_PROPERTY(ss,tmp) zend_hash_find(Z_OBJPROP_P(ss), "httpurl", sizeof("httpurl"), (void **)&tmp)
-#define FETCH_URL_RES(ss,tmp) ss = (php_url *) zend_fetch_resource(tmp TSRMLS_CC, -1, "httpurl", NULL, 1, le_url)
-
#define FETCH_THIS_SOCKET(ss) \
{ \
zval *__thisObj,**__tmp; \
if (call_status == SUCCESS) {
sdlFunctionPtr function;
- function = get_function(get_binding_from_type(service->sdl, BINDING_SOAP), Z_STRVAL(function_name));
+ /* TODO: make 'strict' (use the sdl defnintions) */
+ function = get_function(service->sdl, Z_STRVAL(function_name));
SOAP_GLOBAL(overrides) = service->mapping;
doc_return = seralize_response_call(function, response_name, service->uri, &retval, soap_version TSRMLS_CC);
SOAP_GLOBAL(overrides) = NULL;
ret = zend_list_insert(sdl, le_sdl);
add_property_resource(thisObj, "sdl", ret);
- /* FIXME: this is extremely bad practice */
- add_property_resource(thisObj, "port", (long)get_binding_from_type(sdl, BINDING_SOAP));
zend_list_addref(ret);
}
}
zend_try {
SOAP_GLOBAL(sdl) = sdl;
if (sdl != NULL) {
- sdlBindingPtr binding;
-
- zval* this_ptr = thisObj;
- FETCH_THIS_PORT(binding);
-
php_strtolower(function, function_len);
- fn = get_function(binding, function);
+ fn = get_function(sdl, function);
if (fn != NULL) {
+ sdlBindingPtr binding = fn->binding;
if (binding->bindingType == BINDING_SOAP) {
sdlSoapBindingFunctionPtr fnb = (sdlSoapBindingFunctionPtr)fn->bindingAttributes;
request = seralize_function_call(thisObj, fn, NULL, fnb->input.ns, real_args, arg_count, soap_version TSRMLS_CC);
- ret = send_http_soap_request(thisObj, request, fnb->soapAction TSRMLS_CC);
+ ret = send_http_soap_request(thisObj, request, binding->location, fnb->soapAction TSRMLS_CC);
} else {
request = seralize_function_call(thisObj, fn, NULL, sdl->target_ns, real_args, arg_count, soap_version TSRMLS_CC);
- ret = send_http_soap_request(thisObj, request, NULL TSRMLS_CC);
+ ret = send_http_soap_request(thisObj, request, binding->location, NULL TSRMLS_CC);
}
xmlFreeDoc(request);
smart_str_free(&error);
}
} else {
- zval **uri;
+ zval **uri, **location;
smart_str *action;
if (zend_hash_find(Z_OBJPROP_P(thisObj), "uri", sizeof("uri"), (void *)&uri) == FAILURE) {
- add_soap_fault(thisObj, "SOAP-ENV:Client", "Error finding uri in soap_call_function_handler", NULL, NULL TSRMLS_CC);
+ add_soap_fault(thisObj, "SOAP-ENV:Client", "Error finding \"uri\" property", NULL, NULL TSRMLS_CC);
+ } else if (zend_hash_find(Z_OBJPROP_P(thisObj), "location", sizeof("location"),(void **) &location) == FAILURE) {
+ add_soap_fault(thisObj, "SOAP-ENV:Client", "Error could not find \"location\" property", NULL, NULL TSRMLS_CC);
} else {
request = seralize_function_call(thisObj, NULL, function, Z_STRVAL_PP(uri), real_args, arg_count, soap_version TSRMLS_CC);
action = build_soap_action(thisObj, function);
- ret = send_http_soap_request(thisObj, request, action->c TSRMLS_CC);
+ ret = send_http_soap_request(thisObj, request, Z_STRVAL_PP(location), action->c TSRMLS_CC);
smart_str_free(action);
efree(action);
if (sdl) {
smart_str buf = {0};
sdlFunctionPtr *function;
- sdlBindingPtr binding;
-
- FETCH_THIS_PORT(binding);
array_init(return_value);
- zend_hash_internal_pointer_reset_ex(binding->functions, &pos);
- while (zend_hash_get_current_data_ex(binding->functions, (void **)&function, &pos) != FAILURE) {
+ 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, 1);
- zend_hash_move_forward_ex(binding->functions, &pos);
smart_str_free(&buf);
+ zend_hash_move_forward_ex(&sdl->functions, &pos);
}
}
}
php_error(E_ERROR,"looks like we got \"Body\" without function call\n");
}
- /* TODO: make 'strict' (use the sdl defnintions) */
- binding = get_binding_from_type(sdl, BINDING_SOAP);
-
INIT_ZVAL(tmp_function_name);
ZVAL_STRING(&tmp_function_name, (char *)func->name, 1);
(*function_name) = tmp_function_name;
- function = get_function(binding, php_strtolower((char *)func->name, strlen(func->name)));
+ function = get_function(sdl, php_strtolower((char *)func->name, strlen(func->name)));
if (sdl != NULL && function == NULL) {
php_error(E_ERROR, "Error function \"%s\" doesn't exists for this service \"%s\"", func->name, binding->location);
}
gen_ns = encode_new_ns();
if (function) {
- if (function->bindingType == BINDING_SOAP) {
+ if (function->binding->bindingType == BINDING_SOAP) {
sdlSoapBindingFunctionPtr fnb = (sdlSoapBindingFunctionPtr)function->bindingAttributes;
style = fnb->style;
if (style == SOAP_RPC) {
xmlAddChild(method, param);
} else if (style == SOAP_DOCUMENT) {
- if (function && function->bindingType == BINDING_SOAP) {
+ if (function && function->binding->bindingType == BINDING_SOAP) {
sdlParamPtr *sparam;
if (zend_hash_index_find(function->requestParameters, 0, (void **)&sparam) == SUCCESS) {
return NULL;
}
-sdlFunctionPtr get_function(sdlBindingPtr sdl, char *function_name)
+sdlFunctionPtr get_function(sdlPtr sdl, char *function_name)
{
sdlFunctionPtr *tmp;
if (sdl != NULL) {
- if (zend_hash_find(sdl->functions, function_name, strlen(function_name), (void **)&tmp) != FAILURE) {
+ if (zend_hash_find(&sdl->functions, function_name, strlen(function_name), (void **)&tmp) != FAILURE) {
return (*tmp);
}
}
smart_str_0(buf);
}
-/* Deletes */
-void delete_sdl(void *handle)
-{
- sdlPtr tmp = *((sdlPtr*)handle);
-
- zend_hash_destroy(&tmp->docs);
- if (tmp->source) {
- free(tmp->source);
- }
- if (tmp->target_ns) {
- free(tmp->target_ns);
- }
- if (tmp->encoders) {
- zend_hash_destroy(tmp->encoders);
- free(tmp->encoders);
- }
- if (tmp->types) {
- zend_hash_destroy(tmp->types);
- free(tmp->types);
- }
- if (tmp->bindings) {
- zend_hash_destroy(tmp->bindings);
- free(tmp->bindings);
- }
- free(tmp);
-}
-
void delete_url(void *handle)
{
php_url_free((php_url*)handle);
efree(service->uri);
efree(service);
}
-
-void delete_binding(void *data)
-{
- sdlBindingPtr binding = *((sdlBindingPtr*)data);
-
- if (binding->functions) {
- zend_hash_destroy(binding->functions);
- free(binding->functions);
- }
-
- if (binding->location) {
- free(binding->location);
- }
- if (binding->name) {
- free(binding->name);
- }
-
- if (binding->bindingType == BINDING_SOAP) {
- sdlSoapBindingPtr soapBind = binding->bindingAttributes;
- free(soapBind->transport);
- }
-}
-
-void delete_function(void *data)
-{
- sdlFunctionPtr function = *((sdlFunctionPtr*)data);
-
- if (function->functionName) {
- free(function->functionName);
- }
- if (function->requestName) {
- free(function->requestName);
- }
- if (function->responseName) {
- free(function->responseName);
- }
- if (function->requestParameters) {
- zend_hash_destroy(function->requestParameters);
- free(function->requestParameters);
- }
- if (function->responseParameters) {
- zend_hash_destroy(function->responseParameters);
- free(function->responseParameters);
- }
-
- if (function->bindingType == BINDING_SOAP) {
- sdlSoapBindingFunctionPtr soapFunction = function->bindingAttributes;
- if (soapFunction->soapAction) {
- free(soapFunction->soapAction);
- }
- delete_sdl_soap_binding_function_body(soapFunction->input);
- delete_sdl_soap_binding_function_body(soapFunction->output);
- delete_sdl_soap_binding_function_body(soapFunction->falut);
- }
-}
-
-void delete_sdl_soap_binding_function_body(sdlSoapBindingFunctionBody body)
-{
- if (body.ns) {
- free(body.ns);
- }
- if (body.parts) {
- free(body.parts);
- }
- if (body.encodingStyle) {
- free(body.encodingStyle);
- }
-}
-
-void delete_paramater(void *data)
-{
- sdlParamPtr param = *((sdlParamPtr*)data);
- if (param->paramName) {
- free(param->paramName);
- }
- free(param);
-}
-
-void delete_mapping(void *data)
-{
- soapMappingPtr map = (soapMappingPtr)data;
-
- if (map->ns) {
- efree(map->ns);
- }
- if (map->ctype) {
- efree(map->ctype);
- }
-
- if (map->type == SOAP_MAP_FUNCTION) {
- if (map->map_functions.to_xml_before) {
- zval_ptr_dtor(&map->map_functions.to_xml_before);
- }
- if (map->map_functions.to_xml) {
- zval_ptr_dtor(&map->map_functions.to_xml);
- }
- if (map->map_functions.to_xml_after) {
- zval_ptr_dtor(&map->map_functions.to_xml_after);
- }
- if (map->map_functions.to_zval_before) {
- zval_ptr_dtor(&map->map_functions.to_zval_before);
- }
- if (map->map_functions.to_zval) {
- zval_ptr_dtor(&map->map_functions.to_zval);
- }
- if (map->map_functions.to_zval_after) {
- zval_ptr_dtor(&map->map_functions.to_zval_after);
- }
- }
- efree(map);
-}
projects / php / commitdiff