Back to index

php5  5.3.10
Classes | Defines | Typedefs | Functions
php_sdl.c File Reference
#include "php_soap.h"
#include "ext/libxml/php_libxml.h"
#include "libxml/uri.h"
#include "ext/standard/md5.h"
#include "tsrm_virtual_cwd.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

Go to the source code of this file.

Classes

struct  _sdl_cache_bucket

Defines

#define O_BINARY   0
#define WSDL_CACHE_VERSION   0x0e
#define WSDL_CACHE_GET(ret, type, buf)   memcpy(&ret,*buf,sizeof(type)); *buf += sizeof(type);
#define WSDL_CACHE_GET_INT(ret, buf)   ret = ((unsigned char)(*buf)[0])|((unsigned char)(*buf)[1]<<8)|((unsigned char)(*buf)[2]<<16)|((int)(*buf)[3]<<24); *buf += 4;
#define WSDL_CACHE_GET_1(ret, type, buf)   ret = (type)(**buf); (*buf)++;
#define WSDL_CACHE_GET_N(ret, n, buf)   memcpy(ret,*buf,n); *buf += n;
#define WSDL_CACHE_SKIP(n, buf)   *buf += n;
#define WSDL_CACHE_PUT_INT(val, buf)
#define WSDL_CACHE_PUT_1(val, buf)   smart_str_appendc(buf,val);
#define WSDL_CACHE_PUT_N(val, n, buf)   smart_str_appendl(buf,(char*)val,n);

Typedefs

typedef struct _sdl_cache_bucket sdl_cache_bucket

Functions

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 *paramater)
static void delete_parameter_persistent (void *paramater)
static void delete_header (void *header)
static void delete_header_persistent (void *header)
static void delete_document (void *doc_ptr)
encodePtr get_encoder_from_prefix (sdlPtr sdl, xmlNodePtr node, const xmlChar *type)
static sdlTypePtr get_element (sdlPtr sdl, xmlNodePtr node, const xmlChar *type)
encodePtr get_encoder (sdlPtr sdl, const char *ns, const char *type)
encodePtr get_encoder_ex (sdlPtr sdl, const char *nscat, int len)
sdlBindingPtr get_binding_from_type (sdlPtr sdl, int type)
sdlBindingPtr get_binding_from_name (sdlPtr sdl, char *name, char *ns)
static int is_wsdl_element (xmlNodePtr node)
void sdl_set_uri_credentials (sdlCtx *ctx, char *uri TSRMLS_DC)
void sdl_restore_uri_credentials (sdlCtx *ctx TSRMLS_DC)
static void load_wsdl_ex (zval *this_ptr, char *struri, sdlCtx *ctx, int include TSRMLS_DC)
static
sdlSoapBindingFunctionHeaderPtr 
wsdl_soap_binding_header (sdlCtx *ctx, xmlNodePtr header, char *wsdl_soap_namespace, int fault)
static void wsdl_soap_binding_body (sdlCtx *ctx, xmlNodePtr node, char *wsdl_soap_namespace, sdlSoapBindingFunctionBody *binding, HashTable *params)
static HashTablewsdl_message (sdlCtx *ctx, xmlChar *message_name)
static sdlPtr load_wsdl (zval *this_ptr, char *struri TSRMLS_DC)
static char * sdl_deserialize_string (char **in)
static void sdl_deserialize_key (HashTable *ht, void *data, char **in)
static void sdl_deserialize_attribute (sdlAttributePtr attr, encodePtr *encoders, char **in)
static sdlRestrictionIntPtr sdl_deserialize_resriction_int (char **in)
static sdlRestrictionCharPtr sdl_deserialize_resriction_char (char **in)
static sdlContentModelPtr sdl_deserialize_model (sdlTypePtr *types, sdlTypePtr *elements, char **in)
static void sdl_deserialize_type (sdlTypePtr type, sdlTypePtr *types, encodePtr *encoders, char **in)
static void sdl_deserialize_encoder (encodePtr enc, sdlTypePtr *types, char **in)
static void sdl_deserialize_soap_body (sdlSoapBindingFunctionBodyPtr body, encodePtr *encoders, sdlTypePtr *types, char **in)
static HashTablesdl_deserialize_parameters (encodePtr *encoders, sdlTypePtr *types, char **in)
static sdlPtr get_sdl_from_cache (const char *fn, const char *uri, time_t t, time_t *cached TSRMLS_DC)
static void sdl_serialize_string (const char *str, smart_str *out)
static void sdl_serialize_key (HashTable *ht, smart_str *out)
static void sdl_serialize_encoder_ref (encodePtr enc, HashTable *tmp_encoders, smart_str *out)
static void sdl_serialize_type_ref (sdlTypePtr type, HashTable *tmp_types, smart_str *out)
static void sdl_serialize_attribute (sdlAttributePtr attr, HashTable *tmp_encoders, smart_str *out)
static void sdl_serialize_model (sdlContentModelPtr model, HashTable *tmp_types, HashTable *tmp_elements, smart_str *out)
static void sdl_serialize_resriction_int (sdlRestrictionIntPtr x, smart_str *out)
static void sdl_serialize_resriction_char (sdlRestrictionCharPtr x, smart_str *out)
static void sdl_serialize_type (sdlTypePtr type, HashTable *tmp_encoders, HashTable *tmp_types, smart_str *out)
static void sdl_serialize_encoder (encodePtr enc, HashTable *tmp_types, smart_str *out)
static void sdl_serialize_parameters (HashTable *ht, HashTable *tmp_encoders, HashTable *tmp_types, smart_str *out)
static void sdl_serialize_soap_body (sdlSoapBindingFunctionBodyPtr body, HashTable *tmp_encoders, HashTable *tmp_types, smart_str *out)
static void add_sdl_to_cache (const char *fn, const char *uri, time_t t, sdlPtr sdl TSRMLS_DC)
static void make_persistent_restriction_int (void *data)
static void make_persistent_restriction_char (void *data)
static void make_persistent_sdl_type_ref (sdlTypePtr *type, HashTable *ptr_map, HashTable *bp_types)
static void make_persistent_sdl_encoder_ref (encodePtr *enc, HashTable *ptr_map, HashTable *bp_encoders)
static HashTablemake_persistent_sdl_function_headers (HashTable *headers, HashTable *ptr_map)
static void make_persistent_sdl_soap_body (sdlSoapBindingFunctionBodyPtr body, HashTable *ptr_map)
static HashTablemake_persistent_sdl_parameters (HashTable *params, HashTable *ptr_map)
static HashTablemake_persistent_sdl_function_faults (sdlFunctionPtr func, HashTable *faults, HashTable *ptr_map)
static sdlAttributePtr make_persistent_sdl_attribute (sdlAttributePtr attr, HashTable *ptr_map, HashTable *bp_types, HashTable *bp_encoders)
static sdlContentModelPtr make_persistent_sdl_model (sdlContentModelPtr model, HashTable *ptr_map, HashTable *bp_types, HashTable *bp_encoders)
static sdlTypePtr make_persistent_sdl_type (sdlTypePtr type, HashTable *ptr_map, HashTable *bp_types, HashTable *bp_encoders)
static encodePtr make_persistent_sdl_encoder (encodePtr enc, HashTable *ptr_map, HashTable *bp_types, HashTable *bp_encoders)
static sdlBindingPtr make_persistent_sdl_binding (sdlBindingPtr bind, HashTable *ptr_map)
static sdlFunctionPtr make_persistent_sdl_function (sdlFunctionPtr func, HashTable *ptr_map)
static sdlPtr make_persistent_sdl (sdlPtr sdl TSRMLS_DC)
static void delete_psdl (void *data)
sdlPtr get_sdl (zval *this_ptr, char *uri, long cache_wsdl TSRMLS_DC)
void delete_sdl_impl (void *handle)
void delete_sdl (void *handle)
static void delete_sdl_soap_binding_function_body (sdlSoapBindingFunctionBody body)
static void delete_sdl_soap_binding_function_body_persistent (sdlSoapBindingFunctionBody body)

Class Documentation

struct _sdl_cache_bucket

Definition at line 3110 of file php_sdl.c.

Class Members
sdlPtr sdl
time_t time

Define Documentation

#define O_BINARY   0

Definition at line 34 of file php_sdl.c.

#define WSDL_CACHE_GET (   ret,
  type,
  buf 
)    memcpy(&ret,*buf,sizeof(type)); *buf += sizeof(type);

Definition at line 1151 of file php_sdl.c.

#define WSDL_CACHE_GET_1 (   ret,
  type,
  buf 
)    ret = (type)(**buf); (*buf)++;

Definition at line 1153 of file php_sdl.c.

#define WSDL_CACHE_GET_INT (   ret,
  buf 
)    ret = ((unsigned char)(*buf)[0])|((unsigned char)(*buf)[1]<<8)|((unsigned char)(*buf)[2]<<16)|((int)(*buf)[3]<<24); *buf += 4;

Definition at line 1152 of file php_sdl.c.

#define WSDL_CACHE_GET_N (   ret,
  n,
  buf 
)    memcpy(ret,*buf,n); *buf += n;

Definition at line 1154 of file php_sdl.c.

#define WSDL_CACHE_PUT_1 (   val,
  buf 
)    smart_str_appendc(buf,val);

Definition at line 1161 of file php_sdl.c.

#define WSDL_CACHE_PUT_INT (   val,
  buf 
)
Value:
smart_str_appendc(buf,val & 0xff); \
                                       smart_str_appendc(buf,(val >> 8) & 0xff); \
                                       smart_str_appendc(buf,(val >> 16) & 0xff); \
                                       smart_str_appendc(buf,(val >> 24) & 0xff);

Definition at line 1157 of file php_sdl.c.

#define WSDL_CACHE_PUT_N (   val,
  n,
  buf 
)    smart_str_appendl(buf,(char*)val,n);

Definition at line 1162 of file php_sdl.c.

#define WSDL_CACHE_SKIP (   n,
  buf 
)    *buf += n;

Definition at line 1155 of file php_sdl.c.

#define WSDL_CACHE_VERSION   0x0e

Definition at line 1149 of file php_sdl.c.


Typedef Documentation


Function Documentation

static void add_sdl_to_cache ( const char *  fn,
const char *  uri,
time_t  t,
sdlPtr sdl  TSRMLS_DC 
) [static]

Definition at line 2076 of file php_sdl.c.

{
       smart_str buf = {0};
       smart_str *out = &buf;
       int i;
       int type_num = 1;
       int encoder_num = 1;
       int f;
       encodePtr enc;
       HashTable tmp_types;
       HashTable tmp_encoders;
       HashTable tmp_bindings;
       HashTable tmp_functions;

#ifdef ZEND_WIN32
       f = open(fn,O_CREAT|O_WRONLY|O_EXCL|O_BINARY,S_IREAD|S_IWRITE);
#else
       f = open(fn,O_CREAT|O_WRONLY|O_EXCL|O_BINARY,S_IREAD|S_IWRITE);
#endif
       if (f < 0) {return;}

       zend_hash_init(&tmp_types, 0, NULL, NULL, 0);
       zend_hash_init(&tmp_encoders, 0, NULL, NULL, 0);
       zend_hash_init(&tmp_bindings, 0, NULL, NULL, 0);
       zend_hash_init(&tmp_functions, 0, NULL, NULL, 0);

       WSDL_CACHE_PUT_N("wsdl", 4, out);
       WSDL_CACHE_PUT_1(WSDL_CACHE_VERSION,out);
       WSDL_CACHE_PUT_1(0,out);
       WSDL_CACHE_PUT_N(&t, sizeof(t), out);

       sdl_serialize_string(uri, out);
       sdl_serialize_string(sdl->source, out);
       sdl_serialize_string(sdl->target_ns, out);

       if (sdl->groups) {
              i = zend_hash_num_elements(sdl->groups);
       } else {
              i = 0;
       }
       WSDL_CACHE_PUT_INT(i, out);
       if (i > 0) {
              sdlTypePtr *tmp;

              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);
                     ++type_num;
                     zend_hash_move_forward(sdl->groups);
              }
       }

       if (sdl->types) {
              i = zend_hash_num_elements(sdl->types);
       } else {
              i = 0;
       }
       WSDL_CACHE_PUT_INT(i, out);
       if (i > 0) {
              sdlTypePtr *tmp;

              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);
                     ++type_num;
                     zend_hash_move_forward(sdl->types);
              }
       }

       if (sdl->elements) {
              i = zend_hash_num_elements(sdl->elements);
       } else {
              i = 0;
       }
       WSDL_CACHE_PUT_INT(i, out);
       if (i > 0) {
              sdlTypePtr *tmp;

              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);
                     ++type_num;
                     zend_hash_move_forward(sdl->elements);
              }
       }

       if (sdl->encoders) {
              i = zend_hash_num_elements(sdl->encoders);
       } else {
              i = 0;
       }
       WSDL_CACHE_PUT_INT(i, out);
       if (i > 0) {
              encodePtr *tmp;

              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);
                     ++encoder_num;
                     zend_hash_move_forward(sdl->encoders);
              }
       }
       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);
              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);
              }
       }

       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);
              }
       }

       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);
              }
       }

       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);
              }
       }

       /* serialize bindings */
       if (sdl->bindings) {
              i = zend_hash_num_elements(sdl->bindings);
       } else {
              i = 0;
       }
       WSDL_CACHE_PUT_INT(i, out);
       if (i > 0) {
              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;
                            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);
                     binding_num++;
                     zend_hash_move_forward(sdl->bindings);
              }
       }

       /* serialize functions */
       i = zend_hash_num_elements(&sdl->functions);
       WSDL_CACHE_PUT_INT(i, out);
       if (i > 0) {
              sdlFunctionPtr *tmp;
              int *binding_num;
              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);
                            }
                     }
                     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;

                            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;
                                          WSDL_CACHE_PUT_1(binding->use, out);
                                          if (binding->use == SOAP_ENCODED) {
                                                 WSDL_CACHE_PUT_1(binding->encodingStyle, out);
                                          }
                                          sdl_serialize_string(binding->ns, out);
                                   } else {
                                          WSDL_CACHE_PUT_1(0, out);
                                   }
                                   zend_hash_move_forward((*tmp)->faults);
                            }
                     } else {
                            WSDL_CACHE_PUT_INT(0, out);
                     }

                     zend_hash_add(&tmp_functions, (char*)tmp, sizeof(*tmp), (void**)&function_num, sizeof(function_num), NULL);
                     function_num++;
                     zend_hash_move_forward(&sdl->functions);
              }
       }

       /* serialize requests */
       if (sdl->requests) {
              i = zend_hash_num_elements(sdl->requests);
       } else {
              i = 0;
       }
       WSDL_CACHE_PUT_INT(i, out);
       if (i > 0) {
              sdlFunctionPtr *tmp;
              int *function_num;

              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);
              }
       }

       write(f, buf.c, buf.len);
       close(f);
       smart_str_free(&buf);
       zend_hash_destroy(&tmp_functions);
       zend_hash_destroy(&tmp_bindings);
       zend_hash_destroy(&tmp_encoders);
       zend_hash_destroy(&tmp_types);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void delete_binding ( void *  binding) [static]

Definition at line 3423 of file php_sdl.c.

{
       sdlBindingPtr binding = *((sdlBindingPtr*)data);

       if (binding->location) {
              efree(binding->location);
       }
       if (binding->name) {
              efree(binding->name);
       }

       if (binding->bindingType == BINDING_SOAP) {
              sdlSoapBindingPtr soapBind = binding->bindingAttributes;
              if (soapBind) {
                     efree(soapBind);
              }
       }
       efree(binding);
}

Here is the caller graph for this function:

static void delete_binding_persistent ( void *  binding) [static]

Definition at line 3443 of file php_sdl.c.

{
       sdlBindingPtr binding = *((sdlBindingPtr*)data);

       if (binding->location) {
              free(binding->location);
       }
       if (binding->name) {
              free(binding->name);
       }

       if (binding->bindingType == BINDING_SOAP) {
              sdlSoapBindingPtr soapBind = binding->bindingAttributes;
              if (soapBind) {
                     free(soapBind);
              }
       }
       free(binding);
}

Here is the caller graph for this function:

static void delete_document ( void *  doc_ptr) [static]

Definition at line 3655 of file php_sdl.c.

{
       xmlDocPtr doc = *((xmlDocPtr*)doc_ptr);
       xmlFreeDoc(doc);
}

Here is the caller graph for this function:

static void delete_fault ( void *  fault) [static]

Definition at line 3613 of file php_sdl.c.

{
       sdlFaultPtr fault = *((sdlFaultPtr*)data);
       if (fault->name) {
              efree(fault->name);
       }
       if (fault->details) {
              zend_hash_destroy(fault->details);
              efree(fault->details);
       }
       if (fault->bindingAttributes) {
              sdlSoapBindingFunctionFaultPtr binding = (sdlSoapBindingFunctionFaultPtr)fault->bindingAttributes;

              if (binding->ns) {
                     efree(binding->ns);
              }
              efree(fault->bindingAttributes);
       }
       efree(fault);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void delete_fault_persistent ( void *  fault) [static]

Definition at line 3634 of file php_sdl.c.

{
       sdlFaultPtr fault = *((sdlFaultPtr*)data);
       if (fault->name) {
              free(fault->name);
       }
       if (fault->details) {
              zend_hash_destroy(fault->details);
              free(fault->details);
       }
       if (fault->bindingAttributes) {
              sdlSoapBindingFunctionFaultPtr binding = (sdlSoapBindingFunctionFaultPtr)fault->bindingAttributes;

              if (binding->ns) {
                     free(binding->ns);
              }
              free(fault->bindingAttributes);
       }
       free(fault);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void delete_function ( void *  function) [static]

Definition at line 3485 of file php_sdl.c.

{
       sdlFunctionPtr function = *((sdlFunctionPtr*)data);

       if (function->functionName) {
              efree(function->functionName);
       }
       if (function->requestName) {
              efree(function->requestName);
       }
       if (function->responseName) {
              efree(function->responseName);
       }
       if (function->requestParameters) {
              zend_hash_destroy(function->requestParameters);
              efree(function->requestParameters);
       }
       if (function->responseParameters) {
              zend_hash_destroy(function->responseParameters);
              efree(function->responseParameters);
       }
       if (function->faults) {
              zend_hash_destroy(function->faults);
              efree(function->faults);
       }

       if (function->bindingAttributes &&
           function->binding && function->binding->bindingType == BINDING_SOAP) {
              sdlSoapBindingFunctionPtr soapFunction = function->bindingAttributes;
              if (soapFunction->soapAction) {
                     efree(soapFunction->soapAction);
              }
              delete_sdl_soap_binding_function_body(soapFunction->input);
              delete_sdl_soap_binding_function_body(soapFunction->output);
              efree(soapFunction);
       }
       efree(function);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void delete_function_persistent ( void *  function) [static]

Definition at line 3524 of file php_sdl.c.

{
       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->faults) {
              zend_hash_destroy(function->faults);
              free(function->faults);
       }

       if (function->bindingAttributes &&
           function->binding && function->binding->bindingType == BINDING_SOAP) {
              sdlSoapBindingFunctionPtr soapFunction = function->bindingAttributes;
              if (soapFunction->soapAction) {
                     free(soapFunction->soapAction);
              }
              delete_sdl_soap_binding_function_body_persistent(soapFunction->input);
              delete_sdl_soap_binding_function_body_persistent(soapFunction->output);
              free(soapFunction);
       }
       free(function);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void delete_header ( void *  header) [static]

Definition at line 3581 of file php_sdl.c.

{
       sdlSoapBindingFunctionHeaderPtr hdr = *((sdlSoapBindingFunctionHeaderPtr*)data);
       if (hdr->name) {
              efree(hdr->name);
       }
       if (hdr->ns) {
              efree(hdr->ns);
       }
       if (hdr->headerfaults) {
              zend_hash_destroy(hdr->headerfaults);
              efree(hdr->headerfaults);
       }
       efree(hdr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void delete_header_persistent ( void *  header) [static]

Definition at line 3597 of file php_sdl.c.

{
       sdlSoapBindingFunctionHeaderPtr hdr = *((sdlSoapBindingFunctionHeaderPtr*)data);
       if (hdr->name) {
              free(hdr->name);
       }
       if (hdr->ns) {
              free(hdr->ns);
       }
       if (hdr->headerfaults) {
              zend_hash_destroy(hdr->headerfaults);
              free(hdr->headerfaults);
       }
       free(hdr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void delete_parameter ( void *  paramater) [static]

Definition at line 3563 of file php_sdl.c.

{
       sdlParamPtr param = *((sdlParamPtr*)data);
       if (param->paramName) {
              efree(param->paramName);
       }
       efree(param);
}

Here is the caller graph for this function:

static void delete_parameter_persistent ( void *  paramater) [static]

Definition at line 3572 of file php_sdl.c.

{
       sdlParamPtr param = *((sdlParamPtr*)data);
       if (param->paramName) {
              free(param->paramName);
       }
       free(param);
}

Here is the caller graph for this function:

static void delete_psdl ( void *  data) [static]

Definition at line 3115 of file php_sdl.c.

{
       sdl_cache_bucket *p = (sdl_cache_bucket*)data;
       sdlPtr tmp = p->sdl;

       zend_hash_destroy(&tmp->functions);
       if (tmp->source) {
              free(tmp->source);
       }
       if (tmp->target_ns) {
              free(tmp->target_ns);
       }
       if (tmp->elements) {
              zend_hash_destroy(tmp->elements);
              free(tmp->elements);
       }
       if (tmp->encoders) {
              zend_hash_destroy(tmp->encoders);
              free(tmp->encoders);
       }
       if (tmp->types) {
              zend_hash_destroy(tmp->types);
              free(tmp->types);
       }
       if (tmp->groups) {
              zend_hash_destroy(tmp->groups);
              free(tmp->groups);
       }
       if (tmp->bindings) {
              zend_hash_destroy(tmp->bindings);
              free(tmp->bindings);
       }
       if (tmp->requests) {
              zend_hash_destroy(tmp->requests);
              free(tmp->requests);
       }
       free(tmp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void delete_sdl ( void *  handle)

Definition at line 3414 of file php_sdl.c.

{
       sdlPtr tmp = (sdlPtr)handle;

       if (!tmp->is_persistent) {
              delete_sdl_impl(tmp);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void delete_sdl_impl ( void *  handle)

Definition at line 3376 of file php_sdl.c.

{
       sdlPtr tmp = (sdlPtr)handle;

       zend_hash_destroy(&tmp->functions);
       if (tmp->source) {
              efree(tmp->source);
       }
       if (tmp->target_ns) {
              efree(tmp->target_ns);
       }
       if (tmp->elements) {
              zend_hash_destroy(tmp->elements);
              efree(tmp->elements);
       }
       if (tmp->encoders) {
              zend_hash_destroy(tmp->encoders);
              efree(tmp->encoders);
       }
       if (tmp->types) {
              zend_hash_destroy(tmp->types);
              efree(tmp->types);
       }
       if (tmp->groups) {
              zend_hash_destroy(tmp->groups);
              efree(tmp->groups);
       }
       if (tmp->bindings) {
              zend_hash_destroy(tmp->bindings);
              efree(tmp->bindings);
       }
       if (tmp->requests) {
              zend_hash_destroy(tmp->requests);
              efree(tmp->requests);
       }
       efree(tmp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void delete_sdl_soap_binding_function_body ( sdlSoapBindingFunctionBody  body) [static]

Definition at line 3463 of file php_sdl.c.

{
       if (body.ns) {
              efree(body.ns);
       }
       if (body.headers) {
              zend_hash_destroy(body.headers);
              efree(body.headers);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void delete_sdl_soap_binding_function_body_persistent ( sdlSoapBindingFunctionBody  body) [static]

Definition at line 3474 of file php_sdl.c.

{
       if (body.ns) {
              free(body.ns);
       }
       if (body.headers) {
              zend_hash_destroy(body.headers);
              free(body.headers);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

sdlBindingPtr get_binding_from_name ( sdlPtr  sdl,
char *  name,
char *  ns 
)

Definition at line 198 of file php_sdl.c.

{
       sdlBindingPtr binding = NULL;
       smart_str key = {0};

       smart_str_appends(&key, ns);
       smart_str_appendc(&key, ':');
       smart_str_appends(&key, name);
       smart_str_0(&key);

       zend_hash_find(sdl->bindings, key.c, key.len, (void **)&binding);

       smart_str_free(&key);
       return binding;
}

Here is the call graph for this function:

Definition at line 180 of file php_sdl.c.

{
       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;
              }
       }
       return NULL;
}
static sdlTypePtr get_element ( sdlPtr  sdl,
xmlNodePtr  node,
const xmlChar *  type 
) [static]

Definition at line 70 of file php_sdl.c.

{
       sdlTypePtr ret = NULL;

       if (sdl->elements) {
              xmlNsPtr nsptr;
              char *ns, *cptype;
              sdlTypePtr *sdl_type;

              parse_namespace(type, &cptype, &ns);
              nsptr = xmlSearchNs(node->doc, node, BAD_CAST(ns));
              if (nsptr != NULL) {
                     int ns_len = xmlStrlen(nsptr->href);
                     int type_len = strlen(cptype);
                     int len = ns_len + type_len + 1;
                     char *nscat = emalloc(len + 1);

                     memcpy(nscat, nsptr->href, ns_len);
                     nscat[ns_len] = ':';
                     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;
                     }
                     efree(nscat);
              } else {
                     if (zend_hash_find(sdl->elements, (char*)type, xmlStrlen(type) + 1, (void **)&sdl_type) == SUCCESS) {
                            ret = *sdl_type;
                     }
              }

              efree(cptype);
              if (ns) {efree(ns);}
       }
       return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

encodePtr get_encoder ( sdlPtr  sdl,
const char *  ns,
const char *  type 
)

Definition at line 110 of file php_sdl.c.

{
       encodePtr enc = NULL;
       char *nscat;
       int ns_len = strlen(ns);
       int type_len = strlen(type);
       int len = ns_len + type_len + 1;

       nscat = emalloc(len + 1);
       memcpy(nscat, ns, ns_len);
       nscat[ns_len] = ':';
       memcpy(nscat+ns_len+1, type, type_len);
       nscat[len] = '\0';

       enc = get_encoder_ex(sdl, nscat, len);

       if (enc == NULL &&
           ((ns_len == sizeof(SOAP_1_1_ENC_NAMESPACE)-1 &&
             memcmp(ns, SOAP_1_1_ENC_NAMESPACE, sizeof(SOAP_1_1_ENC_NAMESPACE)-1) == 0) ||
            (ns_len == sizeof(SOAP_1_2_ENC_NAMESPACE)-1 &&
             memcmp(ns, SOAP_1_2_ENC_NAMESPACE, sizeof(SOAP_1_2_ENC_NAMESPACE)-1) == 0))) {
              char *enc_nscat;
              int enc_ns_len;
              int enc_len;

              enc_ns_len = sizeof(XSD_NAMESPACE)-1;
              enc_len = enc_ns_len + type_len + 1;
              enc_nscat = emalloc(enc_len + 1);
              memcpy(enc_nscat, XSD_NAMESPACE, sizeof(XSD_NAMESPACE)-1);
              enc_nscat[enc_ns_len] = ':';
              memcpy(enc_nscat+enc_ns_len+1, type, type_len);
              enc_nscat[enc_len] = '\0';

              enc = get_encoder_ex(NULL, enc_nscat, enc_len);
              efree(enc_nscat);
              if (enc && sdl) {
                     encodePtr new_enc    = pemalloc(sizeof(encode), sdl->is_persistent);
                     memcpy(new_enc, enc, sizeof(encode));
                     if (sdl->is_persistent) {
                            new_enc->details.ns = zend_strndup(ns, ns_len);
                            new_enc->details.type_str = strdup(new_enc->details.type_str);
                     } else {
                            new_enc->details.ns = estrndup(ns, ns_len);
                            new_enc->details.type_str = estrdup(new_enc->details.type_str);
                     }
                     if (sdl->encoders == NULL) {
                            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);
                     enc = new_enc;
              }
       }
       efree(nscat);
       return enc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

encodePtr get_encoder_ex ( sdlPtr  sdl,
const char *  nscat,
int  len 
)

Definition at line 167 of file php_sdl.c.

{
       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);
       }
       return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

encodePtr get_encoder_from_prefix ( sdlPtr  sdl,
xmlNodePtr  node,
const xmlChar *  type 
)

Definition at line 49 of file php_sdl.c.

{
       encodePtr enc = NULL;
       xmlNsPtr nsptr;
       char *ns, *cptype;

       parse_namespace(type, &cptype, &ns);
       nsptr = xmlSearchNs(node->doc, node, BAD_CAST(ns));
       if (nsptr != NULL) {
              enc = get_encoder(sdl, (char*)nsptr->href, cptype);
              if (enc == NULL) {
                     enc = get_encoder_ex(sdl, cptype, strlen(cptype));
              }
       } else {
              enc = get_encoder_ex(sdl, (char*)type, xmlStrlen(type));
       }
       efree(cptype);
       if (ns) {efree(ns);}
       return enc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sdlPtr get_sdl ( zval *  this_ptr,
char *  uri,
long cache_wsdl  TSRMLS_DC 
)

Definition at line 3154 of file php_sdl.c.

{
       char  fn[MAXPATHLEN];
       sdlPtr sdl = NULL;
       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;
       smart_str headers = {0};
       char* key = NULL;
       time_t t = time(0);

       if (strchr(uri,':') != NULL || IS_ABSOLUTE_PATH(uri, uri_len)) {
              uri_len = strlen(uri);
       } else if (VCWD_REALPATH(uri, fn) == NULL) {
              cache_wsdl = WSDL_CACHE_NONE;
       } else {
              uri = fn;
              uri_len = strlen(uri);
       }

       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 (p->time < t - SOAP_GLOBAL(cache_ttl)) {
                            /* in-memory cache entry is expired */
                            zend_hash_del(&EG(persistent_list), uri, uri_len+1);
                     } else {
                            return p->sdl;
                     }
              }
       }

       if ((cache_wsdl & WSDL_CACHE_DISK) && (uri_len < MAXPATHLEN)) {
              time_t t = time(0);
              char md5str[33];
              PHP_MD5_CTX context;
              unsigned char digest[16];
              int len = strlen(SOAP_GLOBAL(cache_dir));
              time_t cached;
              char *user = php_get_current_user();
              int user_len = user ? strlen(user) + 1 : 0;

              md5str[0] = '\0';
              PHP_MD5Init(&context);
              PHP_MD5Update(&context, (unsigned char*)uri, uri_len);
              PHP_MD5Final(digest, &context);
              make_digest(md5str, digest);
              key = emalloc(len+sizeof("/wsdl-")-1+user_len+sizeof(md5str));
              memcpy(key,SOAP_GLOBAL(cache_dir),len);
              memcpy(key+len,"/wsdl-",sizeof("/wsdl-")-1);
              len += sizeof("/wsdl-")-1;
              if (user_len) {
                     memcpy(key+len, user, user_len-1);
                     len += user_len-1;
                     key[len++] = '-';
              }
              memcpy(key+len,md5str,sizeof(md5str));

              if ((sdl = get_sdl_from_cache(key, uri, t-SOAP_GLOBAL(cache_ttl), &cached TSRMLS_CC)) != NULL) {
                     t = cached;
                     efree(key);
                     goto cache_in_memory;
              }
       }

       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);
       } else {
              context = php_stream_context_alloc();
       }

       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;
              smart_str proxy = {0};
              str_port = **proxy_port;
              zval_copy_ctor(&str_port);
              convert_to_string(&str_port);
              smart_str_appends(&proxy,"tcp://");
              smart_str_appends(&proxy,Z_STRVAL_PP(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);
              smart_str_free(&proxy);
              
              if (!context) {
                     context = php_stream_context_alloc();
              }
              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);
              }

              proxy_authentication(this_ptr, &headers TSRMLS_CC);
       }

       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);
              smart_str_appendl(&headers, "Connection: close", sizeof("Connection: close")-1);
       }

       if (headers.len > 0) {
              zval *str_headers;

              if (!context) {
                     context = php_stream_context_alloc();
              }

              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);
              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);
       }

       SOAP_GLOBAL(error_code) = "WSDL";

       sdl = load_wsdl(this_ptr, uri TSRMLS_CC);
       if (sdl) {
              sdl->is_persistent = 0;
       }

       SOAP_GLOBAL(error_code) = old_error_code;

       if (context) {
              php_libxml_switch_context(orig_context TSRMLS_CC);
              zval_ptr_dtor(&new_context);
       }

       if ((cache_wsdl & WSDL_CACHE_DISK) && key) {
              if (sdl) {
                     add_sdl_to_cache(key, uri, t, sdl TSRMLS_CC);
              }
              efree(key);
       }

cache_in_memory:
       if (cache_wsdl & WSDL_CACHE_MEMORY) {
              if (sdl) {
                     sdlPtr psdl;
                     sdl_cache_bucket p;

                     if (SOAP_GLOBAL(mem_cache) == NULL) {
                            SOAP_GLOBAL(mem_cache) = malloc(sizeof(HashTable));
                            zend_hash_init(SOAP_GLOBAL(mem_cache), 0, NULL, delete_psdl, 1);
                     } else if (SOAP_GLOBAL(cache_limit) > 0 &&
                                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;

                            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)) {
                                   if (q->time < latest) {
                                          latest = q->time;
                                          zend_hash_get_current_key_ex(SOAP_GLOBAL(mem_cache), &key, &key_len, &idx, 0, &pos);
                                   }
                            }
                            if (key) {
                                   zend_hash_del(SOAP_GLOBAL(mem_cache), key, key_len);
                            } else {
                                   return sdl;
                            }
                     }

                     psdl = make_persistent_sdl(sdl TSRMLS_CC);
                     psdl->is_persistent = 1;
                     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)) {
                            /* remove non-persitent sdl structure */
                            delete_sdl_impl(sdl);
                            /* and replace it with persistent one */
                            sdl = psdl;
                     } else {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to register persistent entry");
                            /* clean up persistent sdl */
                            delete_psdl(&p);
                            /* keep non-persistent sdl and return it */
                     }
              }
       }

       return sdl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static sdlPtr get_sdl_from_cache ( const char *  fn,
const char *  uri,
time_t  t,
time_t *cached  TSRMLS_DC 
) [static]

Definition at line 1499 of file php_sdl.c.

{
       sdlPtr sdl;
       time_t old_t;
       int  i, num_groups, num_types, num_elements, num_encoders, num_bindings, num_func;
       sdlFunctionPtr *functions = NULL;
       sdlBindingPtr *bindings;
       sdlTypePtr *types;
       encodePtr *encoders;
       encodePtr enc;

       int f;
       struct stat st;
       char *in, *buf;

       f = open(fn, O_RDONLY|O_BINARY);
       if (f < 0) {
              return NULL;
       }
       if (fstat(f, &st) != 0) {
              close(f);
              return NULL;
       }
       buf = in = emalloc(st.st_size);
       if (read(f, in, st.st_size) != st.st_size) {
              close(f);
              efree(in);
              return NULL;
       }
       close(f);

       if (strncmp(in,"wsdl",4) != 0 || in[4] != WSDL_CACHE_VERSION || in[5] != '\0') {
              unlink(fn);
              efree(buf);
              return NULL;
       }
       in += 6;

       WSDL_CACHE_GET(old_t, time_t, &in);
       if (old_t < t) {
              unlink(fn);
              efree(buf);
              return NULL;
       }
       *cached = old_t;

       WSDL_CACHE_GET_INT(i, &in);
       if (i == 0 && strncmp(in, uri, i) != 0) {
              unlink(fn);
              efree(buf);
              return NULL;
       }
       WSDL_CACHE_SKIP(i, &in);

       sdl = emalloc(sizeof(*sdl));
       memset(sdl, 0, sizeof(*sdl));

       sdl->source = sdl_deserialize_string(&in);
       sdl->target_ns = sdl_deserialize_string(&in);

       WSDL_CACHE_GET_INT(num_groups, &in);
       WSDL_CACHE_GET_INT(num_types, &in);
       WSDL_CACHE_GET_INT(num_elements, &in);
       WSDL_CACHE_GET_INT(num_encoders, &in);

       i = num_groups+num_types+num_elements;
       types = safe_emalloc((i+1), sizeof(sdlTypePtr), 0);
       types[0] = NULL;
       while (i > 0) {
              types[i] = emalloc(sizeof(sdlType));
              memset(types[i], 0, sizeof(sdlType));
              i--;
       }

       i = num_encoders;
       enc = defaultEncoding;
       while (enc->details.type != END_KNOWN_TYPES) {
              i++; enc++;
       }
       encoders = safe_emalloc((i+1), sizeof(encodePtr), 0);
       i = num_encoders;
       encoders[0] = NULL;
       while (i > 0) {
              encoders[i] = emalloc(sizeof(encode));
              memset(encoders[i], 0, sizeof(encode));
              i--;
       }
       i = num_encoders;
       enc = defaultEncoding;
       while (enc->details.type != END_KNOWN_TYPES) {
              encoders[++i] = enc++;
       }

       i = 1;
       if (num_groups > 0) {
              sdl->groups = emalloc(sizeof(HashTable));
              zend_hash_init(sdl->groups, num_groups, NULL, delete_type, 0);
              while (i < num_groups+1) {
                     sdl_deserialize_key(sdl->groups, types[i], &in);
                     sdl_deserialize_type(types[i], types, encoders, &in);
                     i++;
              }
       }

       if (num_types > 0) {
              sdl->types = emalloc(sizeof(HashTable));
              zend_hash_init(sdl->types, num_types, NULL, delete_type, 0);
              while (i < num_groups+num_types+1) {
                     sdl_deserialize_key(sdl->types, types[i], &in);
                     sdl_deserialize_type(types[i], types, encoders, &in);
                     i++;
              }
       }

       if (num_elements > 0) {
              sdl->elements = emalloc(sizeof(HashTable));
              zend_hash_init(sdl->elements, num_elements, NULL, delete_type, 0);
              while (i < num_groups+num_types+num_elements+1) {
                     sdl_deserialize_key(sdl->elements, types[i], &in);
                     sdl_deserialize_type(types[i], types, encoders, &in);
                     i++;
              }
       }

       i = 1;
       if (num_encoders > 0) {
              sdl->encoders = emalloc(sizeof(HashTable));
              zend_hash_init(sdl->encoders, num_encoders, NULL, delete_encoder, 0);
              while (i < num_encoders+1) {
                     sdl_deserialize_key(sdl->encoders, encoders[i], &in);
                     sdl_deserialize_encoder(encoders[i], types, &in);
                     i++;
              }
       }

       /* deserialize bindings */
       WSDL_CACHE_GET_INT(num_bindings, &in);
       bindings = safe_emalloc(num_bindings, sizeof(sdlBindingPtr), 0);
       if (num_bindings > 0) {
              sdl->bindings = emalloc(sizeof(HashTable));
              zend_hash_init(sdl->bindings, num_bindings, NULL, delete_binding, 0);
              for (i = 0; i < num_bindings; i++) {
                     sdlBindingPtr binding = emalloc(sizeof(sdlBinding));
                     memset(binding, 0, sizeof(sdlBinding));
                     sdl_deserialize_key(sdl->bindings, binding, &in);
                     binding->name = sdl_deserialize_string(&in);
                     binding->location = sdl_deserialize_string(&in);
                     WSDL_CACHE_GET_1(binding->bindingType,sdlBindingType,&in);
                     if (binding->bindingType == BINDING_SOAP && *in != 0) {
                       sdlSoapBindingPtr soap_binding = binding->bindingAttributes = emalloc(sizeof(sdlSoapBinding));
                            WSDL_CACHE_GET_1(soap_binding->style,sdlEncodingStyle,&in);
                            WSDL_CACHE_GET_1(soap_binding->transport,sdlTransport,&in);
                     } else {
                            WSDL_CACHE_SKIP(1,&in);
                     }
                     bindings[i] = binding;
              }
       }

       /* deserialize functions */
       WSDL_CACHE_GET_INT(num_func, &in);
       zend_hash_init(&sdl->functions, num_func, NULL, delete_function, 0);
       if (num_func > 0) {
              functions = safe_emalloc(num_func, sizeof(sdlFunctionPtr), 0);
              for (i = 0; i < num_func; i++) {
                     int binding_num, num_faults;
                     sdlFunctionPtr func = emalloc(sizeof(sdlFunction));
                     sdl_deserialize_key(&sdl->functions, func, &in);
                     func->functionName = sdl_deserialize_string(&in);
                     func->requestName = sdl_deserialize_string(&in);
                     func->responseName = sdl_deserialize_string(&in);

                     WSDL_CACHE_GET_INT(binding_num, &in);
                     if (binding_num == 0) {
                            func->binding = NULL;
                     } else {
                            func->binding = bindings[binding_num-1];
                     }
                     if (func->binding && func->binding->bindingType == BINDING_SOAP && *in != 0) {
                            sdlSoapBindingFunctionPtr binding = func->bindingAttributes = emalloc(sizeof(sdlSoapBindingFunction));
                            memset(binding, 0, sizeof(sdlSoapBindingFunction));
                            WSDL_CACHE_GET_1(binding->style,sdlEncodingStyle,&in);
                            binding->soapAction = sdl_deserialize_string(&in);
                            sdl_deserialize_soap_body(&binding->input, encoders, types, &in);
                            sdl_deserialize_soap_body(&binding->output, encoders, types, &in);
                     } else {
                            WSDL_CACHE_SKIP(1, &in);
                            func->bindingAttributes = NULL;
                     }

                     func->requestParameters = sdl_deserialize_parameters(encoders, types, &in);
                     func->responseParameters = sdl_deserialize_parameters(encoders, types, &in);

                     WSDL_CACHE_GET_INT(num_faults, &in);
                     if (num_faults > 0) {
                       int j;

                            func->faults = emalloc(sizeof(HashTable));
                            zend_hash_init(func->faults, num_faults, NULL, delete_fault, 0);

                            for (j = 0; j < num_faults; j++) {
                                   sdlFaultPtr fault = emalloc(sizeof(sdlFault));

                                   sdl_deserialize_key(func->faults, fault, &in);
                                   fault->name =sdl_deserialize_string(&in);
                                   fault->details =sdl_deserialize_parameters(encoders, types, &in);
                                   if (*in != 0) {
                                          sdlSoapBindingFunctionFaultPtr binding = fault->bindingAttributes = emalloc(sizeof(sdlSoapBindingFunctionFault));
                                          memset(binding, 0, sizeof(sdlSoapBindingFunctionFault));
                                          WSDL_CACHE_GET_1(binding->use,sdlEncodingUse,&in);
                                          if (binding->use == SOAP_ENCODED) {
                                                 WSDL_CACHE_GET_1(binding->encodingStyle, sdlRpcEncodingStyle, &in);
                                          } else {
                                                 binding->encodingStyle = SOAP_ENCODING_DEFAULT;
                                          }
                                          binding->ns = sdl_deserialize_string(&in);
                                   } else {
                                          WSDL_CACHE_SKIP(1, &in);
                                          fault->bindingAttributes = NULL;
                                   }
                            }
                     } else {
                            func->faults = NULL;
                     }
                     functions[i] = func;
              }
       }

       /* deserialize requests */
       WSDL_CACHE_GET_INT(i, &in);
       if (i > 0) {
              sdl->requests = emalloc(sizeof(HashTable));
              zend_hash_init(sdl->requests, i, NULL, NULL, 0);
              while (i > 0) {
                     int function_num;

                     WSDL_CACHE_GET_INT(function_num, &in);
                     sdl_deserialize_key(sdl->requests, functions[function_num-1], &in);
                     i--;
              }
       }

       if (functions) {
              efree(functions);
       }
       efree(bindings);
       efree(encoders);
       efree(types);
       efree(buf);
       return sdl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int is_wsdl_element ( xmlNodePtr  node) [static]

Definition at line 214 of file php_sdl.c.

{
       if (node->ns && strcmp((char*)node->ns->href, WSDL_NAMESPACE) != 0) {
              xmlAttrPtr attr;
              if ((attr = get_attribute_ex(node->properties, "required", WSDL_NAMESPACE)) != NULL &&
                   attr->children && attr->children->content &&
                   (strcmp((char*)attr->children->content, "1") == 0 ||
                    strcmp((char*)attr->children->content, "true") == 0)) {
                     soap_error1(E_ERROR, "Parsing WSDL: Unknown required WSDL extension '%s'", node->ns->href);
              }
              return 0;
       }
       return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static sdlPtr load_wsdl ( zval *  this_ptr,
char *struri  TSRMLS_DC 
) [static]

Definition at line 697 of file php_sdl.c.

{
       sdlCtx ctx;
       int i,n;

       memset(&ctx,0,sizeof(ctx));
       ctx.sdl = emalloc(sizeof(sdl));
       memset(ctx.sdl, 0, sizeof(sdl));
       ctx.sdl->source = estrdup(struri);
       zend_hash_init(&ctx.sdl->functions, 0, NULL, delete_function, 0);

       zend_hash_init(&ctx.docs, 0, NULL, delete_document, 0);
       zend_hash_init(&ctx.messages, 0, NULL, NULL, 0);
       zend_hash_init(&ctx.bindings, 0, NULL, NULL, 0);
       zend_hash_init(&ctx.portTypes, 0, NULL, NULL, 0);
       zend_hash_init(&ctx.services,  0, NULL, NULL, 0);

       load_wsdl_ex(this_ptr, struri,&ctx, 0 TSRMLS_CC);
       schema_pass2(&ctx);

       n = zend_hash_num_elements(&ctx.services);
       if (n > 0) {
              zend_hash_internal_pointer_reset(&ctx.services);
              for (i = 0; i < n; i++) {
                     xmlNodePtr *tmp, service;
                     xmlNodePtr trav, port;
                     int has_soap_port = 0;

                     zend_hash_get_current_data(&ctx.services, (void **)&tmp);
                     service = *tmp;

                     trav = service->children;
                     while (trav != NULL) {
                            xmlAttrPtr type, name, bindingAttr, location;
                            xmlNodePtr portType, operation;
                            xmlNodePtr address, binding, trav2;
                            char *ctype;
                            sdlBindingPtr tmpbinding;
                            char *wsdl_soap_namespace = NULL;

                            if (!is_wsdl_element(trav) || node_is_equal(trav,"documentation")) {
                                   trav = trav->next;
                                   continue;
                            }
                            if (!node_is_equal(trav,"port")) {
                                   soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav->name);
                            }

                            port = trav;

                            tmpbinding = emalloc(sizeof(sdlBinding));
                            memset(tmpbinding, 0, sizeof(sdlBinding));

                            bindingAttr = get_attribute(port->properties, "binding");
                            if (bindingAttr == NULL) {
                                   soap_error0(E_ERROR, "Parsing WSDL: No binding associated with <port>");
                            }

                            /* find address and figure out binding type */
                            address = NULL;
                            trav2 = port->children;
                            while (trav2 != NULL) {
                                   if (node_is_equal(trav2,"address") && trav2->ns) {
                                          if (!strncmp((char*)trav2->ns->href, WSDL_SOAP11_NAMESPACE, sizeof(WSDL_SOAP11_NAMESPACE))) {
                                                 address = trav2;
                                                 wsdl_soap_namespace = WSDL_SOAP11_NAMESPACE;
                                                 tmpbinding->bindingType = BINDING_SOAP;
                                          } else if (!strncmp((char*)trav2->ns->href, WSDL_SOAP12_NAMESPACE, sizeof(WSDL_SOAP12_NAMESPACE))) {
                                                 address = trav2;
                                                 wsdl_soap_namespace = WSDL_SOAP12_NAMESPACE;
                                                 tmpbinding->bindingType = BINDING_SOAP;
                                          } else if (!strncmp((char*)trav2->ns->href, RPC_SOAP12_NAMESPACE, sizeof(RPC_SOAP12_NAMESPACE))) {
                                                 address = trav2;
                                                 wsdl_soap_namespace = RPC_SOAP12_NAMESPACE;
                                                 tmpbinding->bindingType = BINDING_SOAP;
                                          } else if (!strncmp((char*)trav2->ns->href, WSDL_HTTP11_NAMESPACE, sizeof(WSDL_HTTP11_NAMESPACE))) {
                                                 address = trav2;
                                                 tmpbinding->bindingType = BINDING_HTTP;
                                          } else if (!strncmp((char*)trav2->ns->href, WSDL_HTTP12_NAMESPACE, sizeof(WSDL_HTTP12_NAMESPACE))) {
                                                 address = trav2;
                                                 tmpbinding->bindingType = BINDING_HTTP;
                                          }
                                   }
                                   if (trav2 != address && is_wsdl_element(trav2) && !node_is_equal(trav2,"documentation")) {
                                          soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav2->name);
                                   }
                              trav2 = trav2->next;
                            }
                            if (!address || tmpbinding->bindingType == BINDING_HTTP) {
                                   if (has_soap_port || trav->next || i < n-1) {
                                          efree(tmpbinding);
                                          trav = trav->next;
                                          continue;
                                   } else if (!address) {
                                          soap_error0(E_ERROR, "Parsing WSDL: No address associated with <port>");
                                   }
                            }
                            has_soap_port = 1;

                            location = get_attribute(address->properties, "location");
                            if (!location) {
                                   soap_error0(E_ERROR, "Parsing WSDL: No location associated with <port>");
                            }

                            tmpbinding->location = estrdup((char*)location->children->content);

                            ctype = strrchr((char*)bindingAttr->children->content,':');
                            if (ctype == NULL) {
                                   ctype = (char*)bindingAttr->children->content;
                            } else {
                                   ++ctype;
                            }
                            if (zend_hash_find(&ctx.bindings, ctype, strlen(ctype)+1, (void*)&tmp) != SUCCESS) {
                                   soap_error1(E_ERROR, "Parsing WSDL: No <binding> element with name '%s'", ctype);
                            }
                            binding = *tmp;

                            if (tmpbinding->bindingType == BINDING_SOAP) {
                                   sdlSoapBindingPtr soapBinding;
                                   xmlNodePtr soapBindingNode;
                                   xmlAttrPtr tmp;

                                   soapBinding = emalloc(sizeof(sdlSoapBinding));
                                   memset(soapBinding, 0, sizeof(sdlSoapBinding));
                                   soapBinding->style = SOAP_DOCUMENT;

                                   soapBindingNode = get_node_ex(binding->children, "binding", wsdl_soap_namespace);
                                   if (soapBindingNode) {
                                          tmp = get_attribute(soapBindingNode->properties, "style");
                                          if (tmp && !strncmp((char*)tmp->children->content, "rpc", sizeof("rpc"))) {
                                                 soapBinding->style = SOAP_RPC;
                                          }

                                          tmp = get_attribute(soapBindingNode->properties, "transport");
                                          if (tmp) {
                                                 if (strncmp((char*)tmp->children->content, WSDL_HTTP_TRANSPORT, sizeof(WSDL_HTTP_TRANSPORT)) == 0) {
                                                        soapBinding->transport = SOAP_TRANSPORT_HTTP;
                                                 } else {
                                                        /* try the next binding */
                                                        efree(soapBinding);
                                                        efree(tmpbinding->location);
                                                        efree(tmpbinding);
                                                        trav = trav->next;
                                                        continue;
                                                 }
                                          }
                                   }
                                   tmpbinding->bindingAttributes = (void *)soapBinding;
                            }

                            name = get_attribute(binding->properties, "name");
                            if (name == NULL) {
                                   soap_error0(E_ERROR, "Parsing WSDL: Missing 'name' attribute for <binding>");
                            }
                            tmpbinding->name = estrdup((char*)name->children->content);

                            type = get_attribute(binding->properties, "type");
                            if (type == NULL) {
                                   soap_error0(E_ERROR, "Parsing WSDL: Missing 'type' attribute for <binding>");
                            }

                            ctype = strrchr((char*)type->children->content,':');
                            if (ctype == NULL) {
                                   ctype = (char*)type->children->content;
                            } else {
                                   ++ctype;
                            }
                            if (zend_hash_find(&ctx.portTypes, ctype, strlen(ctype)+1, (void**)&tmp) != SUCCESS) {
                                   soap_error1(E_ERROR, "Parsing WSDL: Missing <portType> with name '%s'", name->children->content);
                            }
                            portType = *tmp;

                            trav2 = binding->children;
                            while (trav2 != NULL) {
                                   sdlFunctionPtr function;
                                   xmlNodePtr input, output, fault, portTypeOperation, trav3;
                                   xmlAttrPtr op_name, paramOrder;

                                   if ((tmpbinding->bindingType == BINDING_SOAP &&
                                       node_is_equal_ex(trav2, "binding", wsdl_soap_namespace)) ||
                                       !is_wsdl_element(trav2) ||
                                       node_is_equal(trav2,"documentation")) {
                                          trav2 = trav2->next;
                                          continue;
                                   }
                                   if (!node_is_equal(trav2,"operation")) {
                                          soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav2->name);
                                   }

                                   operation = trav2;

                                   op_name = get_attribute(operation->properties, "name");
                                   if (op_name == NULL) {
                                          soap_error0(E_ERROR, "Parsing WSDL: Missing 'name' attribute for <operation>");
                                   }

                                   trav3 = operation->children;
                                   while  (trav3 != NULL) {
                                          if (tmpbinding->bindingType == BINDING_SOAP &&
                                              node_is_equal_ex(trav3, "operation", wsdl_soap_namespace)) {
                                          } else if (is_wsdl_element(trav3) &&
                                                     !node_is_equal(trav3,"input") &&
                                                     !node_is_equal(trav3,"output") &&
                                                     !node_is_equal(trav3,"fault") &&
                                                     !node_is_equal(trav3,"documentation")) {
                                                 soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav3->name);
                                          }
                                          trav3 = trav3->next;
                                   }

                                   portTypeOperation = get_node_with_attribute_ex(portType->children, "operation", WSDL_NAMESPACE, "name", (char*)op_name->children->content, NULL);
                                   if (portTypeOperation == NULL) {
                                          soap_error1(E_ERROR, "Parsing WSDL: Missing <portType>/<operation> with name '%s'", op_name->children->content);
                                   }

                                   function = emalloc(sizeof(sdlFunction));
                                   memset(function, 0, sizeof(sdlFunction));
                                   function->functionName = estrdup((char*)op_name->children->content);

                                   if (tmpbinding->bindingType == BINDING_SOAP) {
                                          sdlSoapBindingFunctionPtr soapFunctionBinding;
                                          sdlSoapBindingPtr soapBinding;
                                          xmlNodePtr soapOperation;
                                          xmlAttrPtr tmp;

                                          soapFunctionBinding = emalloc(sizeof(sdlSoapBindingFunction));
                                          memset(soapFunctionBinding, 0, sizeof(sdlSoapBindingFunction));
                                          soapBinding = (sdlSoapBindingPtr)tmpbinding->bindingAttributes;
                                          soapFunctionBinding->style = soapBinding->style;

                                          soapOperation = get_node_ex(operation->children, "operation", wsdl_soap_namespace);
                                          if (soapOperation) {
                                                 tmp = get_attribute(soapOperation->properties, "soapAction");
                                                 if (tmp) {
                                                        soapFunctionBinding->soapAction = estrdup((char*)tmp->children->content);
                                                 }

                                                 tmp = get_attribute(soapOperation->properties, "style");
                                                 if (tmp) {
                                                        if (!strncmp((char*)tmp->children->content, "rpc", sizeof("rpc"))) {
                                                               soapFunctionBinding->style = SOAP_RPC;
                                                        } else {
                                                               soapFunctionBinding->style = SOAP_DOCUMENT;
                                                        }
                                                 } else {
                                                        soapFunctionBinding->style = soapBinding->style;
                                                 }
                                          }

                                          function->bindingAttributes = (void *)soapFunctionBinding;
                                   }

                                   input = get_node_ex(portTypeOperation->children, "input", WSDL_NAMESPACE);
                                   if (input != NULL) {
                                          xmlAttrPtr message, name;

                                          message = get_attribute(input->properties, "message");
                                          if (message == NULL) {
                                                 soap_error1(E_ERROR, "Parsing WSDL: Missing name for <input> of '%s'", op_name->children->content);
                                          }
                                          function->requestParameters = wsdl_message(&ctx, message->children->content);

                                          name = get_attribute(input->properties, "name");
/* FIXME
                                          if (name != NULL) {
                                                 function->requestName = estrdup(name->children->content);
                                          } else {
*/
                                          {
                                                 function->requestName = estrdup(function->functionName);
                                          }

                                          if (tmpbinding->bindingType == BINDING_SOAP) {
                                                 input = get_node_ex(operation->children, "input", WSDL_NAMESPACE);
                                                 if (input != NULL) {
                                                        sdlSoapBindingFunctionPtr soapFunctionBinding = function->bindingAttributes;
                                                        wsdl_soap_binding_body(&ctx, input, wsdl_soap_namespace, &soapFunctionBinding->input, function->requestParameters);
                                                 }
                                          }
                                   }

                                   output = get_node_ex(portTypeOperation->children, "output", WSDL_NAMESPACE);
                                   if (output != NULL) {
                                          xmlAttrPtr message, name;

                                          message = get_attribute(output->properties, "message");
                                          if (message == NULL) {
                                                 soap_error1(E_ERROR, "Parsing WSDL: Missing name for <output> of '%s'", op_name->children->content);
                                          }
                                          function->responseParameters = wsdl_message(&ctx, message->children->content);

                                          name = get_attribute(output->properties, "name");
/* FIXME
                                          if (name != NULL) {
                                                 function->responseName = estrdup(name->children->content);
                                          } else if (input == NULL) {
                                                 function->responseName = estrdup(function->functionName);
                                          } else {
*/
                                          {
                                                 int len = strlen(function->functionName);
                                                 function->responseName = emalloc(len + sizeof("Response"));
                                                 memcpy(function->responseName, function->functionName, len);
                                                 memcpy(function->responseName+len, "Response", sizeof("Response"));
                                          }

                                          if (tmpbinding->bindingType == BINDING_SOAP) {
                                                 output = get_node_ex(operation->children, "output", WSDL_NAMESPACE);
                                                 if (output != NULL) {
                                                        sdlSoapBindingFunctionPtr soapFunctionBinding = function->bindingAttributes;
                                                        wsdl_soap_binding_body(&ctx, output, wsdl_soap_namespace, &soapFunctionBinding->output, function->responseParameters);
                                                 }
                                          }
                                   }

                                   paramOrder = get_attribute(portTypeOperation->properties, "parameterOrder");
                                   if (paramOrder) {
                                          /* FIXME: */
                                   }

                                   fault = portTypeOperation->children;
                                   while (fault != NULL) {
                                          if (node_is_equal_ex(fault, "fault", WSDL_NAMESPACE)) {
                                                 xmlAttrPtr message, name;
                                                 sdlFaultPtr f;

                                                 name = get_attribute(fault->properties, "name");
                                                 if (name == NULL) {
                                                        soap_error1(E_ERROR, "Parsing WSDL: Missing name for <fault> of '%s'", op_name->children->content);
                                                 }
                                                 message = get_attribute(fault->properties, "message");
                                                 if (message == NULL) {
                                                        soap_error1(E_ERROR, "Parsing WSDL: Missing name for <output> of '%s'", op_name->children->content);
                                                 }

                                                 f = emalloc(sizeof(sdlFault));
                                                 memset(f, 0, sizeof(sdlFault));

                                                 f->name = estrdup((char*)name->children->content);
                                                 f->details = wsdl_message(&ctx, message->children->content);
                                                 if (f->details == NULL || zend_hash_num_elements(f->details) > 1) {
                                                        soap_error1(E_ERROR, "Parsing WSDL: The fault message '%s' must have a single part", message->children->content);
                                                 }

                                                 if (tmpbinding->bindingType == BINDING_SOAP) {
                                                        xmlNodePtr soap_fault = get_node_with_attribute_ex(operation->children, "fault", WSDL_NAMESPACE, "name", f->name, NULL);
                                                        if (soap_fault != NULL) {
                                                               xmlNodePtr trav = soap_fault->children;
                                                               while (trav != NULL) {
                                                                      if (node_is_equal_ex(trav, "fault", wsdl_soap_namespace)) {
                                                                             xmlAttrPtr tmp;
                                                                        sdlSoapBindingFunctionFaultPtr binding;

                                                                             binding = f->bindingAttributes = emalloc(sizeof(sdlSoapBindingFunctionFault));
                                                                             memset(f->bindingAttributes, 0, sizeof(sdlSoapBindingFunctionFault));

                                                                             tmp = get_attribute(trav->properties, "use");
                                                                             if (tmp && !strncmp((char*)tmp->children->content, "encoded", sizeof("encoded"))) {
                                                                                    binding->use = SOAP_ENCODED;
                                                                             } else {
                                                                                    binding->use = SOAP_LITERAL;
                                                                             }

                                                                             tmp = get_attribute(trav->properties, "namespace");
                                                                             if (tmp) {
                                                                                    binding->ns = estrdup((char*)tmp->children->content);
                                                                             }

                                                                             if (binding->use == SOAP_ENCODED) {
                                                                                    tmp = get_attribute(trav->properties, "encodingStyle");
                                                                                    if (tmp) {
                                                                                           if (strncmp((char*)tmp->children->content, SOAP_1_1_ENC_NAMESPACE, sizeof(SOAP_1_1_ENC_NAMESPACE)) == 0) {
                                                                                                  binding->encodingStyle = SOAP_ENCODING_1_1;
                                                                                           } else if (strncmp((char*)tmp->children->content, SOAP_1_2_ENC_NAMESPACE, sizeof(SOAP_1_2_ENC_NAMESPACE)) == 0) {
                                                                                                  binding->encodingStyle = SOAP_ENCODING_1_2;
                                                                                           } else {
                                                                                                  soap_error1(E_ERROR, "Parsing WSDL: Unknown encodingStyle '%s'", tmp->children->content);
                                                                                           }
                                                                                    } else {
                                                                                           soap_error0(E_ERROR, "Parsing WSDL: Unspecified encodingStyle");
                                                                                    }
                                                                             }
                                                                      } else if (is_wsdl_element(trav) && !node_is_equal(trav,"documentation")) {
                                                                             soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav->name);
                                                                      }
                                                                      trav = trav->next;
                                                               }
                                                        }
                                                 }
                                                 if (function->faults == 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) {
                                                        soap_error2(E_ERROR, "Parsing WSDL: <fault> with name '%s' already defined in '%s'", f->name, op_name->children->content);
                                                 }
                                          }
                                          fault = fault->next;
                                   }

                                   function->binding = tmpbinding;

                                   {
                                          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);
                                          }
                                          efree(tmp);
                                          if (function->requestName != NULL && strcmp(function->requestName,function->functionName) != 0) {
                                                 if (ctx.sdl->requests == NULL) {
                                                        ctx.sdl->requests = emalloc(sizeof(HashTable));
                                                        zend_hash_init(ctx.sdl->requests, 0, NULL, NULL, 0);
                                                 }
                                                 tmp = estrdup(function->requestName);
                                                 len = strlen(tmp);
                                                 zend_hash_add(ctx.sdl->requests, php_strtolower(tmp, len), len+1, &function, sizeof(sdlFunctionPtr), NULL);
                                                 efree(tmp);
                                          }
                                   }
                                   trav2 = trav2->next;
                            }

                            if (!ctx.sdl->bindings) {
                                   ctx.sdl->bindings = emalloc(sizeof(HashTable));
                                   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);
                            trav= trav->next;
                     }

                     zend_hash_move_forward(&ctx.services);
              }
       } else {
              soap_error0(E_ERROR, "Parsing WSDL: Couldn't bind to service");
       }

       if (ctx.sdl->bindings == NULL || ctx.sdl->bindings->nNumOfElements == 0) {
              soap_error0(E_ERROR, "Parsing WSDL: Could not find any usable binding services in WSDL.");
       }

       zend_hash_destroy(&ctx.messages);
       zend_hash_destroy(&ctx.bindings);
       zend_hash_destroy(&ctx.portTypes);
       zend_hash_destroy(&ctx.services);
       zend_hash_destroy(&ctx.docs);

       return ctx.sdl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void load_wsdl_ex ( zval *  this_ptr,
char *  struri,
sdlCtx ctx,
int include  TSRMLS_DC 
) [static]

Definition at line 287 of file php_sdl.c.

{
       sdlPtr tmpsdl = ctx->sdl;
       xmlDocPtr wsdl;
       xmlNodePtr root, definitions, trav;
       xmlAttrPtr targetNamespace;

       if (zend_hash_exists(&ctx->docs, struri, strlen(struri)+1)) {
              return;
       }
       
       sdl_set_uri_credentials(ctx, struri TSRMLS_CC);
       wsdl = soap_xmlParseFile(struri TSRMLS_CC);
       sdl_restore_uri_credentials(ctx TSRMLS_CC);
       
       if (!wsdl) {
              xmlErrorPtr xmlErrorPtr = xmlGetLastError();

              if (xmlErrorPtr) {
                     soap_error2(E_ERROR, "Parsing WSDL: Couldn't load from '%s' : %s", struri, xmlErrorPtr->message);
              } else {
                     soap_error1(E_ERROR, "Parsing WSDL: Couldn't load from '%s'", struri);
              }
       }

       zend_hash_add(&ctx->docs, struri, strlen(struri)+1, (void**)&wsdl, sizeof(xmlDocPtr), NULL);

       root = wsdl->children;
       definitions = get_node_ex(root, "definitions", WSDL_NAMESPACE);
       if (!definitions) {
              if (include) {
                     xmlNodePtr schema = get_node_ex(root, "schema", XSD_NAMESPACE);
                     if (schema) {
                            load_schema(ctx, schema TSRMLS_CC);
                            return;
                     }
              }
              soap_error1(E_ERROR, "Parsing WSDL: Couldn't find <definitions> in '%s'", struri);
       }

       if (!include) {
              targetNamespace = get_attribute(definitions->properties, "targetNamespace");
              if (targetNamespace) {
                     tmpsdl->target_ns = estrdup((char*)targetNamespace->children->content);
              }
       }

       trav = definitions->children;
       while (trav != NULL) {
              if (!is_wsdl_element(trav)) {
                     trav = trav->next;
                     continue;
              }
              if (node_is_equal(trav,"types")) {
                     /* TODO: Only one "types" is allowed */
                     xmlNodePtr trav2 = trav->children;

                     while (trav2 != NULL) {
                            if (node_is_equal_ex(trav2, "schema", XSD_NAMESPACE)) {
                                   load_schema(ctx, trav2 TSRMLS_CC);
                            } else if (is_wsdl_element(trav2) && !node_is_equal(trav2,"documentation")) {
                                   soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav2->name);
                            }
                            trav2 = trav2->next;
                     }
              } else if (node_is_equal(trav,"import")) {
                     /* TODO: namespace ??? */
                     xmlAttrPtr tmp = get_attribute(trav->properties, "location");
                     if (tmp) {
                            xmlChar *uri;
                            xmlChar *base = xmlNodeGetBase(trav->doc, trav);

                            if (base == NULL) {
                                   uri = xmlBuildURI(tmp->children->content, trav->doc->URL);
                            } else {
                                   uri = xmlBuildURI(tmp->children->content, base);
                                   xmlFree(base);
                            }
                            load_wsdl_ex(this_ptr, (char*)uri, ctx, 1 TSRMLS_CC);
                            xmlFree(uri);
                     }

              } 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) {
                                   soap_error1(E_ERROR, "Parsing WSDL: <message> '%s' already defined", name->children->content);
                            }
                     } else {
                            soap_error0(E_ERROR, "Parsing WSDL: <message> has no name attribute");
                     }

              } 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) {
                                   soap_error1(E_ERROR, "Parsing WSDL: <portType> '%s' already defined", name->children->content);
                            }
                     } else {
                            soap_error0(E_ERROR, "Parsing WSDL: <portType> has no name attribute");
                     }

              } 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) {
                                   soap_error1(E_ERROR, "Parsing WSDL: <binding> '%s' already defined", name->children->content);
                            }
                     } else {
                            soap_error0(E_ERROR, "Parsing WSDL: <binding> has no name attribute");
                     }

              } 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) {
                                   soap_error1(E_ERROR, "Parsing WSDL: <service> '%s' already defined", name->children->content);
                            }
                     } else {
                            soap_error0(E_ERROR, "Parsing WSDL: <service> has no name attribute");
                     }
              } else if (!node_is_equal(trav,"documentation")) {
                     soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav->name);
              }
              trav = trav->next;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void make_persistent_restriction_char ( void *  data) [static]

Definition at line 2363 of file php_sdl.c.

{
       sdlRestrictionCharPtr *rest = (sdlRestrictionCharPtr *)data;
       sdlRestrictionCharPtr prest = NULL;

       prest = malloc(sizeof(sdlRestrictionChar));
       memset(prest, 0, sizeof(sdlRestrictionChar));
       prest->value = strdup((*rest)->value);
       prest->fixed = (*rest)->fixed;
       *rest = prest;
}

Here is the caller graph for this function:

static void make_persistent_restriction_int ( void *  data) [static]

Definition at line 2352 of file php_sdl.c.

{
       sdlRestrictionIntPtr *rest = (sdlRestrictionIntPtr *)data;
       sdlRestrictionIntPtr prest = NULL;

       prest = malloc(sizeof(sdlRestrictionInt));
       *prest = **rest;
       *rest = prest;
}

Here is the caller graph for this function:

static sdlPtr make_persistent_sdl ( sdlPtr sdl  TSRMLS_DC) [static]

Definition at line 2915 of file php_sdl.c.

{
       sdlPtr psdl = NULL;
       HashTable ptr_map;
       HashTable bp_types, bp_encoders;
       ulong index;
       char *key;
       uint key_len;

       zend_hash_init(&bp_types, 0, NULL, NULL, 0);
       zend_hash_init(&bp_encoders, 0, NULL, NULL, 0);
       zend_hash_init(&ptr_map, 0, NULL, NULL, 0);

       psdl = malloc(sizeof(*sdl));
       memset(psdl, 0, sizeof(*sdl));

       if (sdl->source) {
              psdl->source = strdup(sdl->source);
       }
       if (sdl->target_ns) {
              psdl->target_ns = strdup(sdl->target_ns);
       }

       if (sdl->groups) {
              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);
                     } else {
                            zend_hash_next_index_insert(psdl->groups, (void*)&ptype, sizeof(sdlTypePtr), NULL);
                     }
                     zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&ptype, sizeof(sdlTypePtr), NULL);
                     zend_hash_move_forward(sdl->groups);
              }
       }

       if (sdl->types) {
              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);
                     } else {
                            zend_hash_next_index_insert(psdl->types, (void*)&ptype, sizeof(sdlTypePtr), NULL);
                     }
                     zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&ptype, sizeof(sdlTypePtr), NULL);
                     zend_hash_move_forward(sdl->types);
              }
       }

       if (sdl->elements) {
              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);
                     } else {
                            zend_hash_next_index_insert(psdl->elements, (void*)&ptype, sizeof(sdlTypePtr), NULL);
                     }
                     zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&ptype, sizeof(sdlTypePtr), NULL);
                     zend_hash_move_forward(sdl->elements);
              }
       }

       if (sdl->encoders) {
              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);
                     } else {
                            zend_hash_next_index_insert(psdl->encoders, (void*)&penc, sizeof(encodePtr), NULL);
                     }
                     zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&penc, sizeof(encodePtr), NULL);
                     zend_hash_move_forward(sdl->encoders);
              }
       }

       /* do backpatching here */
       if (zend_hash_num_elements(&bp_types)) {
              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) {
                            assert(0);
                     }
                     **tmp = *ptype;
                     zend_hash_move_forward(&bp_types);
              }
       }
       if (zend_hash_num_elements(&bp_encoders)) {
              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) {
                            assert(0);
                     }
                     **tmp = *penc;
                     zend_hash_move_forward(&bp_encoders);
              }
       }


       if (sdl->bindings) {
              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);
                     } else {
                            zend_hash_next_index_insert(psdl->bindings, (void*)&pbind, sizeof(sdlBindingPtr), NULL);
                     }
                     zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&pbind, sizeof(sdlBindingPtr), NULL);
                     zend_hash_move_forward(sdl->bindings);
              }
       }

       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 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);
                     } else {
                            zend_hash_next_index_insert(&psdl->functions, (void*)&pfunc, sizeof(sdlFunctionPtr), NULL);
                     }
                     zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&pfunc, sizeof(sdlFunctionPtr), NULL);
                     zend_hash_move_forward(&sdl->functions);
              }
       }

       if (sdl->requests) {
              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) {
                            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);
                     }
                     zend_hash_move_forward(sdl->requests);
              }
       }

       zend_hash_destroy(&ptr_map);
       zend_hash_destroy(&bp_encoders);
       zend_hash_destroy(&bp_types);

       return psdl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static sdlAttributePtr make_persistent_sdl_attribute ( sdlAttributePtr  attr,
HashTable ptr_map,
HashTable bp_types,
HashTable bp_encoders 
) [static]

Definition at line 2572 of file php_sdl.c.

{
       sdlAttributePtr pattr;
       ulong index;
       char *key;
       uint key_len;

       pattr = malloc(sizeof(sdlAttribute));
       memset(pattr, 0, sizeof(sdlAttribute));

       *pattr = *attr;

       if (pattr->name) {
              pattr->name = strdup(pattr->name);
       }
       if (pattr->namens) {
              pattr->namens = strdup(pattr->namens);
       }
       if (pattr->ref) {
              pattr->ref = strdup(pattr->ref);
       }
       if (pattr->def) {
              pattr->def = strdup(pattr->def);
       }
       if (pattr->fixed) {
              pattr->fixed = strdup(pattr->fixed);
       }

       /* we do not want to process defaultEncoding's here */
       if (pattr->encode) {
              make_persistent_sdl_encoder_ref(&pattr->encode, ptr_map, bp_encoders);
       }

       if (pattr->extraAttributes) {
              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) {
                     pextra = malloc(sizeof(sdlExtraAttribute));
                     memset(pextra, 0, sizeof(sdlExtraAttribute));
                     if ((*tmp)->ns) {
                            pextra->ns = strdup((*tmp)->ns);
                     }
                     if ((*tmp)->val) {
                            pextra->val = strdup((*tmp)->val);
                     }

                     if (zend_hash_get_current_key_ex(attr->extraAttributes, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
                            zend_hash_add(pattr->extraAttributes, key, key_len, (void*)&pextra, sizeof(sdlExtraAttributePtr), NULL);
                     }

                     zend_hash_move_forward(attr->extraAttributes);
              }
       }

       return pattr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static sdlBindingPtr make_persistent_sdl_binding ( sdlBindingPtr  bind,
HashTable ptr_map 
) [static]

Definition at line 2832 of file php_sdl.c.

{
       sdlBindingPtr pbind = NULL;

       pbind = malloc(sizeof(sdlBinding));
       memset(pbind, 0, sizeof(sdlBinding));

       *pbind = *bind;

       if (pbind->name) {
              pbind->name = strdup(pbind->name);
       }
       if (pbind->location) {
              pbind->location = strdup(pbind->location);
       }

       if (pbind->bindingType == BINDING_SOAP && pbind->bindingAttributes) {
              sdlSoapBindingPtr soap_binding;
          
              soap_binding = malloc(sizeof(sdlSoapBinding));
              memset(soap_binding, 0, sizeof(sdlSoapBinding));
              *soap_binding = *(sdlSoapBindingPtr)pbind->bindingAttributes;
              pbind->bindingAttributes = soap_binding;
       }

       return pbind;
}

Here is the caller graph for this function:

static encodePtr make_persistent_sdl_encoder ( encodePtr  enc,
HashTable ptr_map,
HashTable bp_types,
HashTable bp_encoders 
) [static]

Definition at line 2809 of file php_sdl.c.

{
       encodePtr penc = NULL;

       penc = malloc(sizeof(encode));
       memset(penc, 0, sizeof(encode));

       *penc = *enc;

       if (penc->details.type_str) {
              penc->details.type_str = strdup(penc->details.type_str);
       }
       if (penc->details.ns) {
              penc->details.ns = strdup(penc->details.ns);
       }

       if (penc->details.sdl_type) {
              make_persistent_sdl_type_ref(&penc->details.sdl_type, ptr_map, bp_types);
       }

       return penc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void make_persistent_sdl_encoder_ref ( encodePtr enc,
HashTable ptr_map,
HashTable bp_encoders 
) [static]

Definition at line 2388 of file php_sdl.c.

{
       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;
       } else {
              zend_hash_next_index_insert(bp_encoders, (void*)&enc, sizeof(encodePtr*), NULL);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static sdlFunctionPtr make_persistent_sdl_function ( sdlFunctionPtr  func,
HashTable ptr_map 
) [static]

Definition at line 2860 of file php_sdl.c.

{
       sdlFunctionPtr pfunc = NULL;

       pfunc = malloc(sizeof(sdlFunction));
       memset(pfunc, 0, sizeof(sdlFunction));

       *pfunc = *func;

       if (pfunc->functionName) {
              pfunc->functionName = strdup(pfunc->functionName);
       }
       if (pfunc->requestName) {
              pfunc->requestName = strdup(pfunc->requestName);
       }
       if (pfunc->responseName) {
              pfunc->responseName = strdup(pfunc->responseName);
       }

       if (pfunc->binding) {
              sdlBindingPtr *tmp;

              if (zend_hash_find(ptr_map, (char*)&pfunc->binding, sizeof(pfunc->binding), (void**)&tmp) == FAILURE) {
                     assert(0);
              }
              pfunc->binding = *tmp;
              
              if (pfunc->binding->bindingType == BINDING_SOAP && pfunc->bindingAttributes) {
                     sdlSoapBindingFunctionPtr soap_binding;

                     soap_binding = malloc(sizeof(sdlSoapBindingFunction));
                     memset(soap_binding, 0, sizeof(sdlSoapBindingFunction));
                     *soap_binding = *(sdlSoapBindingFunctionPtr)pfunc->bindingAttributes;
                     if (soap_binding->soapAction) {
                            soap_binding->soapAction = strdup(soap_binding->soapAction);
                     }
                     make_persistent_sdl_soap_body(&soap_binding->input, ptr_map);
                     make_persistent_sdl_soap_body(&soap_binding->output, ptr_map);
                     pfunc->bindingAttributes = soap_binding;
              }

              if (pfunc->requestParameters) {
                     pfunc->requestParameters = make_persistent_sdl_parameters(pfunc->requestParameters, ptr_map);
              }
              if (pfunc->responseParameters) {
                     pfunc->responseParameters = make_persistent_sdl_parameters(pfunc->responseParameters, ptr_map);
              }
              if (pfunc->faults) {
                     pfunc->faults = make_persistent_sdl_function_faults(pfunc, pfunc->faults, ptr_map);
              }
       }

       return pfunc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static HashTable* make_persistent_sdl_function_faults ( sdlFunctionPtr  func,
HashTable faults,
HashTable ptr_map 
) [static]

Definition at line 2522 of file php_sdl.c.

{
       HashTable *pfaults;
       sdlFaultPtr  *tmp, pfault;
       ulong index;
       char *key;
       uint key_len;

       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) {
              pfault = malloc(sizeof(sdlFault));
              memset(pfault, 0, sizeof(sdlFault));
              *pfault = **tmp;

              if (pfault->name) {
                     pfault->name = strdup(pfault->name);
              }
              if (pfault->details) {
                     pfault->details = make_persistent_sdl_parameters(pfault->details, ptr_map);
              }

              if (func->binding->bindingType == BINDING_SOAP && pfault->bindingAttributes) {
                     sdlSoapBindingFunctionFaultPtr soap_binding;

                     soap_binding = malloc(sizeof(sdlSoapBindingFunctionFault));
                     memset(soap_binding, 0, sizeof(sdlSoapBindingFunctionFault));
                     *soap_binding = *(sdlSoapBindingFunctionFaultPtr)pfault->bindingAttributes;
                     if (soap_binding->ns) {
                            soap_binding->ns = strdup(soap_binding->ns);
                     }
                     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);
              } else {
                     zend_hash_next_index_insert(pfaults, (void*)&pfault, sizeof(sdlParamPtr), NULL);
              }

              zend_hash_move_forward(faults);
       }


       return pfaults;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static HashTable* make_persistent_sdl_function_headers ( HashTable headers,
HashTable ptr_map 
) [static]

Definition at line 2405 of file php_sdl.c.

{
       HashTable *pheaders;
       sdlSoapBindingFunctionHeaderPtr *tmp, pheader;
       encodePtr *penc;
       sdlTypePtr *ptype;
       ulong index;
       char *key;
       uint key_len;

       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) {
              pheader = malloc(sizeof(sdlSoapBindingFunctionHeader));
              memset(pheader, 0, sizeof(sdlSoapBindingFunctionHeader));
              *pheader = **tmp;

              if (pheader->name) {
                     pheader->name = strdup(pheader->name);
              }
              if (pheader->ns) {
                     pheader->ns = strdup(pheader->ns);
              }

              if (pheader->encode->details.sdl_type) {
                     if (zend_hash_find(ptr_map, (char*)&pheader->encode, sizeof(encodePtr), (void**)&penc) == FAILURE) {
                            assert(0);
                     }
                     pheader->encode = *penc;
              }
              if (pheader->element) {
                     if (zend_hash_find(ptr_map, (char*)&pheader->element, sizeof(sdlTypePtr), (void**)&ptype) == FAILURE) {
                            assert(0);
                     }
                     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);
              } else {
                     zend_hash_next_index_insert(pheaders, (void*)&pheader, sizeof(sdlSoapBindingFunctionHeaderPtr), NULL);
              }

              zend_hash_move_forward(headers);
       }

       return pheaders;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static sdlContentModelPtr make_persistent_sdl_model ( sdlContentModelPtr  model,
HashTable ptr_map,
HashTable bp_types,
HashTable bp_encoders 
) [static]

Definition at line 2634 of file php_sdl.c.

{
       sdlContentModelPtr pmodel;
       sdlContentModelPtr *tmp, pcontent;

       pmodel = malloc(sizeof(sdlContentModel));
       memset(pmodel, 0, sizeof(sdlContentModel));
       *pmodel = *model;

       switch (pmodel->kind) {
              case XSD_CONTENT_ELEMENT:
                     if (pmodel->u.element) {
                            make_persistent_sdl_type_ref(&pmodel->u.element, ptr_map, bp_types);
                     }
                     break;

              case XSD_CONTENT_SEQUENCE:
              case XSD_CONTENT_ALL:
              case XSD_CONTENT_CHOICE:
                     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);
                     }
                     break;

              case XSD_CONTENT_GROUP_REF:
                     if (pmodel->u.group_ref) {
                            pmodel->u.group_ref = strdup(pmodel->u.group_ref);
                     }
                     break;

              case XSD_CONTENT_GROUP:
                     if (pmodel->u.group) {
                            make_persistent_sdl_type_ref(&pmodel->u.group, ptr_map, bp_types);
                     }
                     break;

              default:
                     break;
       }

       return pmodel;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static HashTable* make_persistent_sdl_parameters ( HashTable params,
HashTable ptr_map 
) [static]

Definition at line 2473 of file php_sdl.c.

{
       HashTable *pparams;
       sdlParamPtr *tmp, pparam;
       sdlTypePtr *ptype;
       encodePtr *penc;
       ulong index;
       char *key;
       uint key_len;

       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) {
              pparam = malloc(sizeof(sdlParam));
              memset(pparam, 0, sizeof(sdlParam));
              *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) {
                            assert(0);
                     }
                     pparam->encode = *penc;
              }
              if (pparam->element) {
                     if (zend_hash_find(ptr_map, (char*)&pparam->element, sizeof(sdlTypePtr), (void**)&ptype) == FAILURE) {
                            assert(0);
                     }
                     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);
              } else {
                     zend_hash_next_index_insert(pparams, (void*)&pparam, sizeof(sdlParamPtr), NULL);
              }

              zend_hash_move_forward(params);
       }


       return pparams;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void make_persistent_sdl_soap_body ( sdlSoapBindingFunctionBodyPtr  body,
HashTable ptr_map 
) [static]

Definition at line 2461 of file php_sdl.c.

{
       if (body->ns) {
              body->ns = strdup(body->ns);
       }

       if (body->headers) {
              body->headers = make_persistent_sdl_function_headers(body->headers, ptr_map);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static sdlTypePtr make_persistent_sdl_type ( sdlTypePtr  type,
HashTable ptr_map,
HashTable bp_types,
HashTable bp_encoders 
) [static]

Definition at line 2684 of file php_sdl.c.

{
       ulong index;
       char *key;
       uint key_len;
       sdlTypePtr ptype = NULL;

       ptype = malloc(sizeof(sdlType));
       memset(ptype, 0, sizeof(sdlType));

       *ptype = *type;

       if (ptype->name) {
              ptype->name = strdup(ptype->name);
       }
       if (ptype->namens) {
              ptype->namens = strdup(ptype->namens);
       }
       if (ptype->def) {
              ptype->def = strdup(ptype->def);
       }
       if (ptype->fixed) {
              ptype->fixed = strdup(ptype->fixed);
       }
       if (ptype->ref) {
              ptype->ref = strdup(ptype->ref);
       }

       /* we do not want to process defaultEncoding's here */
       if (ptype->encode) {
              make_persistent_sdl_encoder_ref(&ptype->encode, ptr_map, bp_encoders);
       }

       if (ptype->restrictions) {
              ptype->restrictions = malloc(sizeof(sdlRestrictions));
              memset(ptype->restrictions, 0, sizeof(sdlRestrictions));
              *ptype->restrictions = *type->restrictions;

              if (ptype->restrictions->minExclusive) {
                     make_persistent_restriction_int(&ptype->restrictions->minExclusive);
              }
              if (ptype->restrictions->maxExclusive) {
                     make_persistent_restriction_int(&ptype->restrictions->maxExclusive);
              }
              if (ptype->restrictions->minInclusive) {
                     make_persistent_restriction_int(&ptype->restrictions->minInclusive);
              }
              if (ptype->restrictions->maxInclusive) {
                     make_persistent_restriction_int(&ptype->restrictions->maxInclusive);
              }
              if (ptype->restrictions->totalDigits) {
                     make_persistent_restriction_int(&ptype->restrictions->totalDigits);
              }
              if (ptype->restrictions->fractionDigits) {
                     make_persistent_restriction_int(&ptype->restrictions->fractionDigits);
              }
              if (ptype->restrictions->length) {
                     make_persistent_restriction_int(&ptype->restrictions->length);
              }
              if (ptype->restrictions->minLength) {
                     make_persistent_restriction_int(&ptype->restrictions->minLength);
              }
              if (ptype->restrictions->maxLength) {
                     make_persistent_restriction_int(&ptype->restrictions->maxLength);
              }
              if (ptype->restrictions->whiteSpace) {
                     make_persistent_restriction_char(&ptype->restrictions->whiteSpace);
              }
              if (ptype->restrictions->pattern) {
                     make_persistent_restriction_char(&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));
              }
       }

       if (ptype->elements) {
              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);
                     } else {
                            zend_hash_next_index_insert(ptype->elements, (void*)&pelem, sizeof(sdlTypePtr), NULL);
                     }
                     zend_hash_add(ptr_map, (char*)tmp, sizeof(*tmp), (void*)&pelem, sizeof(sdlTypePtr), NULL);
                     zend_hash_move_forward(type->elements);
              }
       }

       if (ptype->attributes) {
              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);
                     } else {
                            zend_hash_next_index_insert(ptype->attributes, (void*)&pattr, sizeof(sdlAttributePtr), NULL);
                     }
                     zend_hash_move_forward(type->attributes);
              }
       }

       if (type->model) {
              ptype->model = make_persistent_sdl_model(ptype->model, ptr_map, bp_types, bp_encoders);
       }

       return ptype;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void make_persistent_sdl_type_ref ( sdlTypePtr type,
HashTable ptr_map,
HashTable bp_types 
) [static]

Definition at line 2376 of file php_sdl.c.

{
       sdlTypePtr *tmp;

       if (zend_hash_find(ptr_map, (char *)type, sizeof(sdlTypePtr), (void**)&tmp) == SUCCESS) {
              *type = *tmp;
       } else {
              zend_hash_next_index_insert(bp_types, (void*)&type, sizeof(sdlTypePtr*), NULL);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sdl_deserialize_attribute ( sdlAttributePtr  attr,
encodePtr encoders,
char **  in 
) [static]

Definition at line 1193 of file php_sdl.c.

{
       int i;

       attr->name = sdl_deserialize_string(in);
       attr->namens = sdl_deserialize_string(in);
       attr->ref = sdl_deserialize_string(in);
       attr->def = sdl_deserialize_string(in);
       attr->fixed = sdl_deserialize_string(in);
       WSDL_CACHE_GET_1(attr->form, sdlForm, in);
       WSDL_CACHE_GET_1(attr->use, sdlUse, in);
       WSDL_CACHE_GET_INT(i, in);
       attr->encode = encoders[i];
       WSDL_CACHE_GET_INT(i, in);
       if (i > 0) {
              attr->extraAttributes = emalloc(sizeof(HashTable));
              zend_hash_init(attr->extraAttributes, i, NULL, delete_extra_attribute, 0);
              while (i > 0) {
                     sdlExtraAttributePtr x = emalloc(sizeof(sdlExtraAttribute));
                     sdl_deserialize_key(attr->extraAttributes, x, in);
                     x->ns = sdl_deserialize_string(in);
                     x->val = sdl_deserialize_string(in);
                     --i;
              }
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sdl_deserialize_encoder ( encodePtr  enc,
sdlTypePtr types,
char **  in 
) [static]

Definition at line 1374 of file php_sdl.c.

{
       int i;

       WSDL_CACHE_GET_INT(enc->details.type, in);
       enc->details.type_str = sdl_deserialize_string(in);
       enc->details.ns = sdl_deserialize_string(in);
       WSDL_CACHE_GET_INT(i, in);
       enc->details.sdl_type = types[i];
       enc->to_xml = sdl_guess_convert_xml;
       enc->to_zval = sdl_guess_convert_zval;

       if (enc->details.sdl_type == NULL) {
              int ns_len = strlen(enc->details.ns);
              int type_len = strlen(enc->details.type_str);

              if (((ns_len == sizeof(SOAP_1_1_ENC_NAMESPACE)-1 &&
                    memcmp(enc->details.ns, SOAP_1_1_ENC_NAMESPACE, sizeof(SOAP_1_1_ENC_NAMESPACE)-1) == 0) ||
                   (ns_len == sizeof(SOAP_1_2_ENC_NAMESPACE)-1 &&
                    memcmp(enc->details.ns, SOAP_1_2_ENC_NAMESPACE, sizeof(SOAP_1_2_ENC_NAMESPACE)-1) == 0))) {
                     char *enc_nscat;
                     int enc_ns_len;
                     int enc_len;
                     encodePtr real_enc;

                     enc_ns_len = sizeof(XSD_NAMESPACE)-1;
                     enc_len = enc_ns_len + type_len + 1;
                     enc_nscat = emalloc(enc_len + 1);
                     memcpy(enc_nscat, XSD_NAMESPACE, sizeof(XSD_NAMESPACE)-1);
                     enc_nscat[enc_ns_len] = ':';
                     memcpy(enc_nscat+enc_ns_len+1, enc->details.type_str, type_len);
                     enc_nscat[enc_len] = '\0';

                     real_enc = get_encoder_ex(NULL, enc_nscat, enc_len);
                     efree(enc_nscat);
                     if (real_enc) {
                            enc->to_zval = real_enc->to_zval;
                            enc->to_xml = real_enc->to_xml;
                     }
              }
       }      
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sdl_deserialize_key ( HashTable ht,
void *  data,
char **  in 
) [static]

Definition at line 1180 of file php_sdl.c.

{
       int len;

       WSDL_CACHE_GET_INT(len, in);
       if (len == 0) {
              zend_hash_next_index_insert(ht, &data, sizeof(void*), NULL);
       } else {
              zend_hash_add(ht, *in, len, &data, sizeof(void*), NULL);
              WSDL_CACHE_SKIP(len, in);
       }
}

Here is the caller graph for this function:

static sdlContentModelPtr sdl_deserialize_model ( sdlTypePtr types,
sdlTypePtr elements,
char **  in 
) [static]

Definition at line 1248 of file php_sdl.c.

{
       int i;
       sdlContentModelPtr model = emalloc(sizeof(sdlContentModel));

       WSDL_CACHE_GET_1(model->kind, sdlContentKind, in);
       WSDL_CACHE_GET_INT(model->min_occurs, in);
       WSDL_CACHE_GET_INT(model->max_occurs, in);
       switch (model->kind) {
              case XSD_CONTENT_ELEMENT:
                     WSDL_CACHE_GET_INT(i, in);
                     model->u.element = elements[i];
                     break;
              case XSD_CONTENT_SEQUENCE:
              case XSD_CONTENT_ALL:
              case XSD_CONTENT_CHOICE:
                     WSDL_CACHE_GET_INT(i, in);
                     model->u.content = emalloc(sizeof(HashTable));
                     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);
                            i--;
                     }
                     break;
              case XSD_CONTENT_GROUP_REF:
                     model->u.group_ref = sdl_deserialize_string(in);
                     break;
              case XSD_CONTENT_GROUP:
                     WSDL_CACHE_GET_INT(i, in);
                     model->u.group = types[i];
                     break;
              default:
                     break;
       }
       return model;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static HashTable* sdl_deserialize_parameters ( encodePtr encoders,
sdlTypePtr types,
char **  in 
) [static]

Definition at line 1476 of file php_sdl.c.

{
       int i, n;
       HashTable *ht;

       WSDL_CACHE_GET_INT(i, in);
       if (i == 0) {return NULL;}
       ht = emalloc(sizeof(HashTable));
       zend_hash_init(ht, i, NULL, delete_parameter, 0);
       while (i > 0) {
              sdlParamPtr param = emalloc(sizeof(sdlParam));
              sdl_deserialize_key(ht, param, in);
              param->paramName = sdl_deserialize_string(in);
              WSDL_CACHE_GET_INT(param->order, in);
              WSDL_CACHE_GET_INT(n, in);
              param->encode = encoders[n];
              WSDL_CACHE_GET_INT(n, in);
              param->element = types[n];
              --i;
       }
       return ht;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static sdlRestrictionCharPtr sdl_deserialize_resriction_char ( char **  in) [static]

Definition at line 1234 of file php_sdl.c.

{
       if (**in == 1) {
              sdlRestrictionCharPtr x = emalloc(sizeof(sdlRestrictionChar));
              WSDL_CACHE_SKIP(1, in);
              x->value = sdl_deserialize_string(in);
              WSDL_CACHE_GET_1(x->fixed, char, in);
              return x;
       } else {
              WSDL_CACHE_SKIP(1, in);
              return NULL;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static sdlRestrictionIntPtr sdl_deserialize_resriction_int ( char **  in) [static]

Definition at line 1220 of file php_sdl.c.

{
       if (**in == 1) {
              sdlRestrictionIntPtr x = emalloc(sizeof(sdlRestrictionInt));
              WSDL_CACHE_SKIP(1, in);
              WSDL_CACHE_GET_INT(x->value, in);
              WSDL_CACHE_GET_1(x->fixed, char, in);
              return x;
       } else {
              WSDL_CACHE_SKIP(1, in);
              return NULL;
       }
}

Here is the caller graph for this function:

static void sdl_deserialize_soap_body ( sdlSoapBindingFunctionBodyPtr  body,
encodePtr encoders,
sdlTypePtr types,
char **  in 
) [static]

Definition at line 1417 of file php_sdl.c.

{
       int i, j, n;

       WSDL_CACHE_GET_1(body->use, sdlEncodingUse, in);
       if (body->use == SOAP_ENCODED) {
              WSDL_CACHE_GET_1(body->encodingStyle, sdlRpcEncodingStyle, in);
       } else {
              body->encodingStyle = SOAP_ENCODING_DEFAULT;
       }
       body->ns = sdl_deserialize_string(in);
       WSDL_CACHE_GET_INT(i, in);
       if (i > 0) {
              body->headers = emalloc(sizeof(HashTable));
              zend_hash_init(body->headers, i, NULL, delete_header, 0);
              while (i > 0) {
                     sdlSoapBindingFunctionHeaderPtr tmp = emalloc(sizeof(sdlSoapBindingFunctionHeader));
                     memset(tmp, 0, sizeof(sdlSoapBindingFunctionHeader));
                     sdl_deserialize_key(body->headers, tmp, in);
                     WSDL_CACHE_GET_1(tmp->use, sdlEncodingUse, in);
                     if (tmp->use == SOAP_ENCODED) {
                            WSDL_CACHE_GET_1(tmp->encodingStyle, sdlRpcEncodingStyle, in);
                     } else {
                            tmp->encodingStyle = SOAP_ENCODING_DEFAULT;
                     }
                     tmp->name = sdl_deserialize_string(in);
                     tmp->ns = sdl_deserialize_string(in);
                     WSDL_CACHE_GET_INT(n, in);
                     tmp->encode = encoders[n];
                     WSDL_CACHE_GET_INT(n, in);
                     tmp->element = types[n];
                     --i;
                     WSDL_CACHE_GET_INT(j, in);
                     if (j > 0) {
                            tmp->headerfaults = emalloc(sizeof(HashTable));
                            zend_hash_init(tmp->headerfaults, i, NULL, delete_header, 0);
                            while (j > 0) {
                                   sdlSoapBindingFunctionHeaderPtr tmp2 = emalloc(sizeof(sdlSoapBindingFunctionHeader));
                                   memset(tmp2, 0, sizeof(sdlSoapBindingFunctionHeader));
                                   sdl_deserialize_key(tmp->headerfaults, tmp2, in);
                                   WSDL_CACHE_GET_1(tmp2->use, sdlEncodingUse, in);
                                   if (tmp2->use == SOAP_ENCODED) {
                                          WSDL_CACHE_GET_1(tmp2->encodingStyle, sdlRpcEncodingStyle, in);
                                   } else {
                                          tmp2->encodingStyle = SOAP_ENCODING_DEFAULT;
                                   }
                                   tmp2->name = sdl_deserialize_string(in);
                                   tmp2->ns = sdl_deserialize_string(in);
                                   WSDL_CACHE_GET_INT(n, in);
                                   tmp2->encode = encoders[n];
                                   WSDL_CACHE_GET_INT(n, in);
                                   tmp2->element = types[n];
                                   --j;
                            }
                     }
              }
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* sdl_deserialize_string ( char **  in) [static]

Definition at line 1164 of file php_sdl.c.

{
       char *s;
       int len;

       WSDL_CACHE_GET_INT(len, in);
       if (len == 0x7fffffff) {
              return NULL;
       } else {
              s = emalloc(len+1);
              WSDL_CACHE_GET_N(s, len, in);
              s[len] = '\0';
              return s;
       }
}

Here is the caller graph for this function:

static void sdl_deserialize_type ( sdlTypePtr  type,
sdlTypePtr types,
encodePtr encoders,
char **  in 
) [static]

Definition at line 1286 of file php_sdl.c.

{
       int i;
       sdlTypePtr *elements = NULL;

       WSDL_CACHE_GET_1(type->kind, sdlTypeKind, in);
       type->name = sdl_deserialize_string(in);
       type->namens = sdl_deserialize_string(in);
       type->def = sdl_deserialize_string(in);
       type->fixed = sdl_deserialize_string(in);
       type->ref = sdl_deserialize_string(in);
       WSDL_CACHE_GET_1(type->nillable, char, in);
       WSDL_CACHE_GET_1(type->form, sdlForm, in);

       WSDL_CACHE_GET_INT(i, in);
       type->encode = encoders[i];

       if (**in == 1) {
              WSDL_CACHE_SKIP(1, in);
              type->restrictions = emalloc(sizeof(sdlRestrictions));
              /*memset(type->restrictions, 0, sizeof(sdlRestrictions));*/
              type->restrictions->minExclusive = sdl_deserialize_resriction_int(in);
              type->restrictions->minInclusive = sdl_deserialize_resriction_int(in);
              type->restrictions->maxExclusive = sdl_deserialize_resriction_int(in);
              type->restrictions->maxInclusive = sdl_deserialize_resriction_int(in);
              type->restrictions->totalDigits = sdl_deserialize_resriction_int(in);
              type->restrictions->fractionDigits = sdl_deserialize_resriction_int(in);
              type->restrictions->length = sdl_deserialize_resriction_int(in);
              type->restrictions->minLength = sdl_deserialize_resriction_int(in);
              type->restrictions->maxLength = sdl_deserialize_resriction_int(in);
              type->restrictions->whiteSpace = sdl_deserialize_resriction_char(in);
              type->restrictions->pattern = sdl_deserialize_resriction_char(in);
              WSDL_CACHE_GET_INT(i, in);
              if (i > 0) {
                     type->restrictions->enumeration = emalloc(sizeof(HashTable));
                     zend_hash_init(type->restrictions->enumeration, i, NULL, delete_restriction_var_char, 0);
                     while (i > 0) {
                            sdlRestrictionCharPtr x = sdl_deserialize_resriction_char(in);
                            sdl_deserialize_key(type->restrictions->enumeration, x, in);
                            --i;
                     }
              } else {
                     type->restrictions->enumeration = NULL;
              }
       } else {
              WSDL_CACHE_SKIP(1, in);
       }

       WSDL_CACHE_GET_INT(i, in);
       if (i > 0) {
              elements = safe_emalloc((i+1), sizeof(sdlTypePtr), 0);
              elements[0] = NULL;
              type->elements = emalloc(sizeof(HashTable));
              zend_hash_init(type->elements, i, NULL, delete_type, 0);
              while (i > 0) {
                     sdlTypePtr t = emalloc(sizeof(sdlType));
                     memset(t, 0, sizeof(sdlType));
                     sdl_deserialize_key(type->elements, t, in);
                     sdl_deserialize_type(t, types, encoders, in);
                     elements[i] = t;
                     --i;
              }
       }

       WSDL_CACHE_GET_INT(i, in);
       if (i > 0) {
              type->attributes = emalloc(sizeof(HashTable));
              zend_hash_init(type->attributes, i, NULL, delete_attribute, 0);
              while (i > 0) {
                     sdlAttributePtr attr = emalloc(sizeof(sdlAttribute));
                     memset(attr, 0, sizeof(sdlAttribute));
                     sdl_deserialize_key(type->attributes, attr, in);
                     sdl_deserialize_attribute(attr, encoders, in);
                     --i;
              }
       }

       if (**in != 0) {
              WSDL_CACHE_SKIP(1, in);
              type->model = sdl_deserialize_model(types, elements, in);
       } else {
              WSDL_CACHE_SKIP(1, in);
       }
       if (elements != NULL) {
              efree(elements);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sdl_restore_uri_credentials ( sdlCtx *ctx  TSRMLS_DC)

Definition at line 277 of file php_sdl.c.

{
       if (ctx->old_header) {
           php_stream_context_set_option(ctx->context, "http", "header", ctx->old_header);
           zval_ptr_dtor(&ctx->old_header);
              ctx->old_header = NULL;
       }
       ctx->context = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sdl_serialize_attribute ( sdlAttributePtr  attr,
HashTable tmp_encoders,
smart_str out 
) [static]

Definition at line 1806 of file php_sdl.c.

{
       int i;

       sdl_serialize_string(attr->name, out);
       sdl_serialize_string(attr->namens, out);
       sdl_serialize_string(attr->ref, out);
       sdl_serialize_string(attr->def, out);
       sdl_serialize_string(attr->fixed, out);
       WSDL_CACHE_PUT_1(attr->form, out);
       WSDL_CACHE_PUT_1(attr->use, out);
       sdl_serialize_encoder_ref(attr->encode, tmp_encoders, out);
       if (attr->extraAttributes) {
              i = zend_hash_num_elements(attr->extraAttributes);
       } else {
              i = 0;
       }
       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);
              }
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sdl_serialize_encoder ( encodePtr  enc,
HashTable tmp_types,
smart_str out 
) [static]

Definition at line 1988 of file php_sdl.c.

{
       WSDL_CACHE_PUT_INT(enc->details.type, out);
       sdl_serialize_string(enc->details.type_str, out);
       sdl_serialize_string(enc->details.ns, out);
       sdl_serialize_type_ref(enc->details.sdl_type, tmp_types, out);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sdl_serialize_encoder_ref ( encodePtr  enc,
HashTable tmp_encoders,
smart_str out 
) [static]

Definition at line 1780 of file php_sdl.c.

                                                                                              {
       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);
              } else {
                     WSDL_CACHE_PUT_INT(0, out);
              }
       } else {
              WSDL_CACHE_PUT_INT(0, out);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sdl_serialize_key ( HashTable ht,
smart_str out 
) [static]

Definition at line 1766 of file php_sdl.c.

{
       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);
       } else {
              WSDL_CACHE_PUT_INT(0, out);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sdl_serialize_model ( sdlContentModelPtr  model,
HashTable tmp_types,
HashTable tmp_elements,
smart_str out 
) [static]

Definition at line 1836 of file php_sdl.c.

{
       WSDL_CACHE_PUT_1(model->kind, out);
       WSDL_CACHE_PUT_INT(model->min_occurs, out);
       WSDL_CACHE_PUT_INT(model->max_occurs, out);
       switch (model->kind) {
              case XSD_CONTENT_ELEMENT:
                     sdl_serialize_type_ref(model->u.element, tmp_elements, out);
                     break;
              case XSD_CONTENT_SEQUENCE:
              case XSD_CONTENT_ALL:
              case XSD_CONTENT_CHOICE: {
                            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);
                            }
                     }
                     break;
              case XSD_CONTENT_GROUP_REF:
                     sdl_serialize_string(model->u.group_ref,out);
                     break;
              case XSD_CONTENT_GROUP:
                     sdl_serialize_type_ref(model->u.group, tmp_types, out);
                     break;
              default:
                     break;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sdl_serialize_parameters ( HashTable ht,
HashTable tmp_encoders,
HashTable tmp_types,
smart_str out 
) [static]

Definition at line 1996 of file php_sdl.c.

{
       int i;

       if (ht) {
              i = zend_hash_num_elements(ht);
       } else {
              i = 0;
       }
       WSDL_CACHE_PUT_INT(i, out);
       if (i > 0) {
              sdlParamPtr *tmp;

              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);
              }
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sdl_serialize_resriction_char ( sdlRestrictionCharPtr  x,
smart_str out 
) [static]

Definition at line 1881 of file php_sdl.c.

{
       if (x) {
              WSDL_CACHE_PUT_1(1, out);
              sdl_serialize_string(x->value, out);
              WSDL_CACHE_PUT_1(x->fixed, out);
       } else {
              WSDL_CACHE_PUT_1(0, out);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sdl_serialize_resriction_int ( sdlRestrictionIntPtr  x,
smart_str out 
) [static]

Definition at line 1870 of file php_sdl.c.

{
       if (x) {
              WSDL_CACHE_PUT_1(1, out);
              WSDL_CACHE_PUT_INT(x->value, out);
              WSDL_CACHE_PUT_1(x->fixed, out);
       } else {
              WSDL_CACHE_PUT_1(0, out);
       }
}

Here is the caller graph for this function:

static void sdl_serialize_soap_body ( sdlSoapBindingFunctionBodyPtr  body,
HashTable tmp_encoders,
HashTable tmp_types,
smart_str out 
) [static]

Definition at line 2021 of file php_sdl.c.

{
       int i, j;

       WSDL_CACHE_PUT_1(body->use, out);
       if (body->use == SOAP_ENCODED) {
              WSDL_CACHE_PUT_1(body->encodingStyle, out);
       }
       sdl_serialize_string(body->ns, out);
       if (body->headers) {
              i = zend_hash_num_elements(body->headers);
       } else {
              i = 0;
       }
       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);
                     } 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);
                                   }
                                   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);
                            }
                     }
                     zend_hash_move_forward(body->headers);
              }
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sdl_serialize_string ( const char *  str,
smart_str out 
) [static]

Definition at line 1751 of file php_sdl.c.

{
       int i;

       if (str) {
              i = strlen(str);
              WSDL_CACHE_PUT_INT(i, out);
              if (i > 0) {
                     WSDL_CACHE_PUT_N(str, i, out);
              }
       } else {
              WSDL_CACHE_PUT_INT(0x7fffffff, out);
       }
}

Here is the caller graph for this function:

static void sdl_serialize_type ( sdlTypePtr  type,
HashTable tmp_encoders,
HashTable tmp_types,
smart_str out 
) [static]

Definition at line 1892 of file php_sdl.c.

{
       int i;
       HashTable *tmp_elements = NULL;

       WSDL_CACHE_PUT_1(type->kind, out);
       sdl_serialize_string(type->name, out);
       sdl_serialize_string(type->namens, out);
       sdl_serialize_string(type->def, out);
       sdl_serialize_string(type->fixed, out);
       sdl_serialize_string(type->ref, out);
       WSDL_CACHE_PUT_1(type->nillable, out);
       WSDL_CACHE_PUT_1(type->form, out);
       sdl_serialize_encoder_ref(type->encode, tmp_encoders, out);

       if (type->restrictions) {
              WSDL_CACHE_PUT_1(1, out);
              sdl_serialize_resriction_int(type->restrictions->minExclusive,out);
              sdl_serialize_resriction_int(type->restrictions->minInclusive,out);
              sdl_serialize_resriction_int(type->restrictions->maxExclusive,out);
              sdl_serialize_resriction_int(type->restrictions->maxInclusive,out);
              sdl_serialize_resriction_int(type->restrictions->totalDigits,out);
              sdl_serialize_resriction_int(type->restrictions->fractionDigits,out);
              sdl_serialize_resriction_int(type->restrictions->length,out);
              sdl_serialize_resriction_int(type->restrictions->minLength,out);
              sdl_serialize_resriction_int(type->restrictions->maxLength,out);
              sdl_serialize_resriction_char(type->restrictions->whiteSpace,out);
              sdl_serialize_resriction_char(type->restrictions->pattern,out);
              if (type->restrictions->enumeration) {
                     i = zend_hash_num_elements(type->restrictions->enumeration);
              } else {
                     i = 0;
              }
              WSDL_CACHE_PUT_INT(i, out);
              if (i > 0) {
                     sdlRestrictionCharPtr *tmp;

                     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);
                     }
              }
       } else {
              WSDL_CACHE_PUT_1(0, out);
       }
       if (type->elements) {
              i = zend_hash_num_elements(type->elements);
       } else {
              i = 0;
       }
       WSDL_CACHE_PUT_INT(i, out);
       if (i > 0) {
              sdlTypePtr *tmp;

              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);
                     i--;
                     zend_hash_move_forward(type->elements);
              }
       }

       if (type->attributes) {
              i = zend_hash_num_elements(type->attributes);
       } else {
              i = 0;
       }
       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);
              }
       }
       if (type->model) {
              WSDL_CACHE_PUT_1(1, out);
              sdl_serialize_model(type->model, tmp_types, tmp_elements, out);
       } else {
              WSDL_CACHE_PUT_1(0, out);
       }
       if (tmp_elements != NULL) {
              zend_hash_destroy(tmp_elements);
              efree(tmp_elements);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sdl_serialize_type_ref ( sdlTypePtr  type,
HashTable tmp_types,
smart_str out 
) [static]

Definition at line 1793 of file php_sdl.c.

                                                                                          {
       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);
              } else {
                     WSDL_CACHE_PUT_INT(0, out);
              }
       } else {
              WSDL_CACHE_PUT_INT(0,out);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sdl_set_uri_credentials ( sdlCtx ctx,
char *uri  TSRMLS_DC 
)

Definition at line 229 of file php_sdl.c.

{
       char *s;
       int l1, l2;
       zval *context = NULL;
       zval **header = NULL;

       /* check if we load xsd from the same server */
       s = strstr(ctx->sdl->source, "://");
       if (!s) return;
       s = strchr(s+3, '/');
       l1 = s - ctx->sdl->source;
       s = strstr((char*)uri, "://");
       if (!s) return;
       s = strchr(s+3, '/');
       l2 = s - (char*)uri;
       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);

                     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')) {
                                   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);
                                          php_stream_context_set_option(ctx->context, "http", "header", &new_header);
                                          zval_dtor(&new_header);
                                   }
                            }
                     }
              }
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static HashTable* wsdl_message ( sdlCtx ctx,
xmlChar *  message_name 
) [static]

Definition at line 630 of file php_sdl.c.

{
       xmlNodePtr trav, part, message = NULL, *tmp;
       HashTable* parameters = NULL;
       char *ctype;

       ctype = strrchr((char*)message_name,':');
       if (ctype == NULL) {
              ctype = (char*)message_name;
       } else {
              ++ctype;
       }
       if (zend_hash_find(&ctx->messages, ctype, strlen(ctype)+1, (void**)&tmp) != SUCCESS) {
              soap_error1(E_ERROR, "Parsing WSDL: Missing <message> with name '%s'", message_name);
       }
       message = *tmp;

       parameters = emalloc(sizeof(HashTable));
       zend_hash_init(parameters, 0, NULL, delete_parameter, 0);

       trav = message->children;
       while (trav != NULL) {
              xmlAttrPtr element, type, name;
              sdlParamPtr param;

              if (trav->ns != NULL && strcmp((char*)trav->ns->href, WSDL_NAMESPACE) != 0) {
                     soap_error1(E_ERROR, "Parsing WSDL: Unexpected extensibility element <%s>", trav->name);
              }
              if (node_is_equal(trav,"documentation")) {
                     trav = trav->next;
                     continue;
              }
              if (!node_is_equal(trav,"part")) {
                     soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav->name);
              }
              part = trav;
              param = emalloc(sizeof(sdlParam));
              memset(param,0,sizeof(sdlParam));
              param->order = 0;

              name = get_attribute(part->properties, "name");
              if (name == NULL) {
                     soap_error1(E_ERROR, "Parsing WSDL: No name associated with <part> '%s'", message->name);
              }

              param->paramName = estrdup((char*)name->children->content);

              type = get_attribute(part->properties, "type");
              if (type != NULL) {
                     param->encode = get_encoder_from_prefix(ctx->sdl, part, type->children->content);
              } else {
                     element = get_attribute(part->properties, "element");
                     if (element != NULL) {
                            param->element = get_element(ctx->sdl, part, element->children->content);
                            if (param->element) {
                                   param->encode = param->element->encode;
                            }
                     }
              }

              zend_hash_next_index_insert(parameters, &param, sizeof(sdlParamPtr), NULL);

              trav = trav->next;
       }
       return parameters;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void wsdl_soap_binding_body ( sdlCtx ctx,
xmlNodePtr  node,
char *  wsdl_soap_namespace,
sdlSoapBindingFunctionBody *  binding,
HashTable params 
) [static]

Definition at line 527 of file php_sdl.c.

{
       xmlNodePtr body, trav;
       xmlAttrPtr tmp;

       trav = node->children;
       while (trav != NULL) {
              if (node_is_equal_ex(trav, "body", wsdl_soap_namespace)) {
                     body = trav;

                     tmp = get_attribute(body->properties, "use");
                     if (tmp && !strncmp((char*)tmp->children->content, "literal", sizeof("literal"))) {
                            binding->use = SOAP_LITERAL;
                     } else {
                            binding->use = SOAP_ENCODED;
                     }

                     tmp = get_attribute(body->properties, "namespace");
                     if (tmp) {
                            binding->ns = estrdup((char*)tmp->children->content);
                     }

                     tmp = get_attribute(body->properties, "parts");
                     if (tmp) {
                            HashTable    ht;
                            char *parts = (char*)tmp->children->content;

                            /* 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;
                                   int found = 0;
                                   char *end;

                                   while (*parts == ' ') ++parts;
                                   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 **)&param, &pos) != FAILURE) {
                                          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);
                                          found = 1;
                                          break;
                                          }
                                          zend_hash_move_forward_ex(params, &pos);
                                   }
                                   if (!found) {
                                          soap_error1(E_ERROR, "Parsing WSDL: Missing part '%s' in <message>", parts);
                                   }
                                   parts += strlen(parts);
                                   if (end) *end = ' ';
                            }
                            zend_hash_destroy(params);
                            *params = ht;
                     }

                     if (binding->use == SOAP_ENCODED) {
                            tmp = get_attribute(body->properties, "encodingStyle");
                            if (tmp) {
                                   if (strncmp((char*)tmp->children->content, SOAP_1_1_ENC_NAMESPACE, sizeof(SOAP_1_1_ENC_NAMESPACE)) == 0) {
                                          binding->encodingStyle = SOAP_ENCODING_1_1;
                                   } else if (strncmp((char*)tmp->children->content, SOAP_1_2_ENC_NAMESPACE, sizeof(SOAP_1_2_ENC_NAMESPACE)) == 0) {
                                          binding->encodingStyle = SOAP_ENCODING_1_2;
                                   } else {
                                          soap_error1(E_ERROR, "Parsing WSDL: Unknown encodingStyle '%s'", tmp->children->content);
                                   }
                            } else {
                                   soap_error0(E_ERROR, "Parsing WSDL: Unspecified encodingStyle");
                            }
                     }
              } else if (node_is_equal_ex(trav, "header", wsdl_soap_namespace)) {
                     sdlSoapBindingFunctionHeaderPtr h = wsdl_soap_binding_header(ctx, trav, wsdl_soap_namespace, 0);
                     smart_str key = {0};

                     if (binding->headers == NULL) {
                            binding->headers = emalloc(sizeof(HashTable));
                            zend_hash_init(binding->headers, 0, NULL, delete_header, 0);
                     }

                     if (h->ns) {
                            smart_str_appends(&key,h->ns);
                            smart_str_appendc(&key,':');
                     }
                     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);
                     }
                     smart_str_free(&key);
              } else if (is_wsdl_element(trav) && !node_is_equal(trav,"documentation")) {
                     soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav->name);
              }
              trav = trav->next;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static sdlSoapBindingFunctionHeaderPtr wsdl_soap_binding_header ( sdlCtx ctx,
xmlNodePtr  header,
char *  wsdl_soap_namespace,
int  fault 
) [static]

Definition at line 415 of file php_sdl.c.

{
       xmlAttrPtr tmp;
       xmlNodePtr *message, part;
       char *ctype;
       sdlSoapBindingFunctionHeaderPtr h;

       tmp = get_attribute(header->properties, "message");
       if (!tmp) {
              soap_error0(E_ERROR, "Parsing WSDL: Missing message attribute for <header>");
       }

       ctype = strrchr((char*)tmp->children->content,':');
       if (ctype == NULL) {
              ctype = (char*)tmp->children->content;
       } else {
              ++ctype;
       }
       if (zend_hash_find(&ctx->messages, ctype, strlen(ctype)+1, (void**)&message) != SUCCESS) {
              soap_error1(E_ERROR, "Parsing WSDL: Missing <message> with name '%s'", tmp->children->content);
       }

       tmp = get_attribute(header->properties, "part");
       if (!tmp) {
              soap_error0(E_ERROR, "Parsing WSDL: Missing part attribute for <header>");
       }
       part = get_node_with_attribute_ex((*message)->children, "part", WSDL_NAMESPACE, "name", (char*)tmp->children->content, NULL);
       if (!part) {
              soap_error1(E_ERROR, "Parsing WSDL: Missing part '%s' in <message>", tmp->children->content);
       }

       h = emalloc(sizeof(sdlSoapBindingFunctionHeader));
       memset(h, 0, sizeof(sdlSoapBindingFunctionHeader));
       h->name = estrdup((char*)tmp->children->content);

       tmp = get_attribute(header->properties, "use");
       if (tmp && !strncmp((char*)tmp->children->content, "encoded", sizeof("encoded"))) {
              h->use = SOAP_ENCODED;
       } else {
              h->use = SOAP_LITERAL;
       }

       tmp = get_attribute(header->properties, "namespace");
       if (tmp) {
              h->ns = estrdup((char*)tmp->children->content);
       }

       if (h->use == SOAP_ENCODED) {
              tmp = get_attribute(header->properties, "encodingStyle");
              if (tmp) {
                     if (strncmp((char*)tmp->children->content, SOAP_1_1_ENC_NAMESPACE, sizeof(SOAP_1_1_ENC_NAMESPACE)) == 0) {
                            h->encodingStyle = SOAP_ENCODING_1_1;
                     } else if (strncmp((char*)tmp->children->content, SOAP_1_2_ENC_NAMESPACE, sizeof(SOAP_1_2_ENC_NAMESPACE)) == 0) {
                            h->encodingStyle = SOAP_ENCODING_1_2;
                     } else {
                            soap_error1(E_ERROR, "Parsing WSDL: Unknown encodingStyle '%s'", tmp->children->content);
                     }
              } else {
                     soap_error0(E_ERROR, "Parsing WSDL: Unspecified encodingStyle");
              }
       }

       tmp = get_attribute(part->properties, "type");
       if (tmp != NULL) {
              h->encode = get_encoder_from_prefix(ctx->sdl, part, tmp->children->content);
       } else {
              tmp = get_attribute(part->properties, "element");
              if (tmp != NULL) {
                     h->element = get_element(ctx->sdl, part, tmp->children->content);
                     if (h->element) {
                            h->encode = h->element->encode;
                            if (!h->ns && h->element->namens) {
                                   h->ns = estrdup(h->element->namens);
                            }
                            if (h->element->name) {
                                   efree(h->name);
                                   h->name = estrdup(h->element->name);
                            }
                     }
              }
       }
       if (!fault) {
              xmlNodePtr trav = header->children;
              while (trav != NULL) {
                     if (node_is_equal_ex(trav, "headerfault", wsdl_soap_namespace)) {
                            sdlSoapBindingFunctionHeaderPtr hf = wsdl_soap_binding_header(ctx, trav, wsdl_soap_namespace, 1);
                            smart_str key = {0};

                            if (h->headerfaults == NULL) {
                                   h->headerfaults = emalloc(sizeof(HashTable));
                                   zend_hash_init(h->headerfaults, 0, NULL, delete_header, 0);
                            }

                            if (hf->ns) {
                                   smart_str_appends(&key,hf->ns);
                                   smart_str_appendc(&key,':');
                            }
                            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);
                            }
                            smart_str_free(&key);
                     } else if (is_wsdl_element(trav) && !node_is_equal(trav,"documentation")) {
                            soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav->name);
                     }
                     trav = trav->next;
              }
       }
       return h;
}

Here is the call graph for this function:

Here is the caller graph for this function: