Annotation of embedaddon/php/ext/soap/php_sdl.c, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | PHP Version 5 |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1997-2012 The PHP Group |
! 6: +----------------------------------------------------------------------+
! 7: | This source file is subject to version 3.01 of the PHP license, |
! 8: | that is bundled with this package in the file LICENSE, and is |
! 9: | available through the world-wide-web at the following url: |
! 10: | http://www.php.net/license/3_01.txt |
! 11: | If you did not receive a copy of the PHP license and are unable to |
! 12: | obtain it through the world-wide-web, please send a note to |
! 13: | license@php.net so we can mail you a copy immediately. |
! 14: +----------------------------------------------------------------------+
! 15: | Authors: Brad Lafountain <rodif_bl@yahoo.com> |
! 16: | Shane Caraveo <shane@caraveo.com> |
! 17: | Dmitry Stogov <dmitry@zend.com> |
! 18: +----------------------------------------------------------------------+
! 19: */
! 20: /* $Id: php_sdl.c 321634 2012-01-01 13:15:04Z felipe $ */
! 21:
! 22: #include "php_soap.h"
! 23: #include "ext/libxml/php_libxml.h"
! 24: #include "libxml/uri.h"
! 25:
! 26: #include "ext/standard/md5.h"
! 27: #include "tsrm_virtual_cwd.h"
! 28:
! 29: #include <sys/types.h>
! 30: #include <sys/stat.h>
! 31: #include <fcntl.h>
! 32:
! 33: #ifndef O_BINARY
! 34: # define O_BINARY 0
! 35: #endif
! 36:
! 37: static void delete_fault(void *fault);
! 38: static void delete_fault_persistent(void *fault);
! 39: static void delete_binding(void *binding);
! 40: static void delete_binding_persistent(void *binding);
! 41: static void delete_function(void *function);
! 42: static void delete_function_persistent(void *function);
! 43: static void delete_parameter(void *paramater);
! 44: static void delete_parameter_persistent(void *paramater);
! 45: static void delete_header(void *header);
! 46: static void delete_header_persistent(void *header);
! 47: static void delete_document(void *doc_ptr);
! 48:
! 49: encodePtr get_encoder_from_prefix(sdlPtr sdl, xmlNodePtr node, const xmlChar *type)
! 50: {
! 51: encodePtr enc = NULL;
! 52: xmlNsPtr nsptr;
! 53: char *ns, *cptype;
! 54:
! 55: parse_namespace(type, &cptype, &ns);
! 56: nsptr = xmlSearchNs(node->doc, node, BAD_CAST(ns));
! 57: if (nsptr != NULL) {
! 58: enc = get_encoder(sdl, (char*)nsptr->href, cptype);
! 59: if (enc == NULL) {
! 60: enc = get_encoder_ex(sdl, cptype, strlen(cptype));
! 61: }
! 62: } else {
! 63: enc = get_encoder_ex(sdl, (char*)type, xmlStrlen(type));
! 64: }
! 65: efree(cptype);
! 66: if (ns) {efree(ns);}
! 67: return enc;
! 68: }
! 69:
! 70: static sdlTypePtr get_element(sdlPtr sdl, xmlNodePtr node, const xmlChar *type)
! 71: {
! 72: sdlTypePtr ret = NULL;
! 73:
! 74: if (sdl->elements) {
! 75: xmlNsPtr nsptr;
! 76: char *ns, *cptype;
! 77: sdlTypePtr *sdl_type;
! 78:
! 79: parse_namespace(type, &cptype, &ns);
! 80: nsptr = xmlSearchNs(node->doc, node, BAD_CAST(ns));
! 81: if (nsptr != NULL) {
! 82: int ns_len = xmlStrlen(nsptr->href);
! 83: int type_len = strlen(cptype);
! 84: int len = ns_len + type_len + 1;
! 85: char *nscat = emalloc(len + 1);
! 86:
! 87: memcpy(nscat, nsptr->href, ns_len);
! 88: nscat[ns_len] = ':';
! 89: memcpy(nscat+ns_len+1, cptype, type_len);
! 90: nscat[len] = '\0';
! 91:
! 92: if (zend_hash_find(sdl->elements, nscat, len + 1, (void **)&sdl_type) == SUCCESS) {
! 93: ret = *sdl_type;
! 94: } else if (zend_hash_find(sdl->elements, (char*)type, type_len + 1, (void **)&sdl_type) == SUCCESS) {
! 95: ret = *sdl_type;
! 96: }
! 97: efree(nscat);
! 98: } else {
! 99: if (zend_hash_find(sdl->elements, (char*)type, xmlStrlen(type) + 1, (void **)&sdl_type) == SUCCESS) {
! 100: ret = *sdl_type;
! 101: }
! 102: }
! 103:
! 104: efree(cptype);
! 105: if (ns) {efree(ns);}
! 106: }
! 107: return ret;
! 108: }
! 109:
! 110: encodePtr get_encoder(sdlPtr sdl, const char *ns, const char *type)
! 111: {
! 112: encodePtr enc = NULL;
! 113: char *nscat;
! 114: int ns_len = strlen(ns);
! 115: int type_len = strlen(type);
! 116: int len = ns_len + type_len + 1;
! 117:
! 118: nscat = emalloc(len + 1);
! 119: memcpy(nscat, ns, ns_len);
! 120: nscat[ns_len] = ':';
! 121: memcpy(nscat+ns_len+1, type, type_len);
! 122: nscat[len] = '\0';
! 123:
! 124: enc = get_encoder_ex(sdl, nscat, len);
! 125:
! 126: if (enc == NULL &&
! 127: ((ns_len == sizeof(SOAP_1_1_ENC_NAMESPACE)-1 &&
! 128: memcmp(ns, SOAP_1_1_ENC_NAMESPACE, sizeof(SOAP_1_1_ENC_NAMESPACE)-1) == 0) ||
! 129: (ns_len == sizeof(SOAP_1_2_ENC_NAMESPACE)-1 &&
! 130: memcmp(ns, SOAP_1_2_ENC_NAMESPACE, sizeof(SOAP_1_2_ENC_NAMESPACE)-1) == 0))) {
! 131: char *enc_nscat;
! 132: int enc_ns_len;
! 133: int enc_len;
! 134:
! 135: enc_ns_len = sizeof(XSD_NAMESPACE)-1;
! 136: enc_len = enc_ns_len + type_len + 1;
! 137: enc_nscat = emalloc(enc_len + 1);
! 138: memcpy(enc_nscat, XSD_NAMESPACE, sizeof(XSD_NAMESPACE)-1);
! 139: enc_nscat[enc_ns_len] = ':';
! 140: memcpy(enc_nscat+enc_ns_len+1, type, type_len);
! 141: enc_nscat[enc_len] = '\0';
! 142:
! 143: enc = get_encoder_ex(NULL, enc_nscat, enc_len);
! 144: efree(enc_nscat);
! 145: if (enc && sdl) {
! 146: encodePtr new_enc = pemalloc(sizeof(encode), sdl->is_persistent);
! 147: memcpy(new_enc, enc, sizeof(encode));
! 148: if (sdl->is_persistent) {
! 149: new_enc->details.ns = zend_strndup(ns, ns_len);
! 150: new_enc->details.type_str = strdup(new_enc->details.type_str);
! 151: } else {
! 152: new_enc->details.ns = estrndup(ns, ns_len);
! 153: new_enc->details.type_str = estrdup(new_enc->details.type_str);
! 154: }
! 155: if (sdl->encoders == NULL) {
! 156: sdl->encoders = pemalloc(sizeof(HashTable), sdl->is_persistent);
! 157: zend_hash_init(sdl->encoders, 0, NULL, delete_encoder, sdl->is_persistent);
! 158: }
! 159: zend_hash_update(sdl->encoders, nscat, len + 1, &new_enc, sizeof(encodePtr), NULL);
! 160: enc = new_enc;
! 161: }
! 162: }
! 163: efree(nscat);
! 164: return enc;
! 165: }
! 166:
! 167: encodePtr get_encoder_ex(sdlPtr sdl, const char *nscat, int len)
! 168: {
! 169: encodePtr *enc;
! 170: TSRMLS_FETCH();
! 171:
! 172: if (zend_hash_find(&SOAP_GLOBAL(defEnc), (char*)nscat, len + 1, (void **)&enc) == SUCCESS) {
! 173: return (*enc);
! 174: } else if (sdl && sdl->encoders && zend_hash_find(sdl->encoders, (char*)nscat, len + 1, (void **)&enc) == SUCCESS) {
! 175: return (*enc);
! 176: }
! 177: return NULL;
! 178: }
! 179:
! 180: sdlBindingPtr get_binding_from_type(sdlPtr sdl, int type)
! 181: {
! 182: sdlBindingPtr *binding;
! 183:
! 184: if (sdl == NULL) {
! 185: return NULL;
! 186: }
! 187:
! 188: for (zend_hash_internal_pointer_reset(sdl->bindings);
! 189: zend_hash_get_current_data(sdl->bindings, (void **) &binding) == SUCCESS;
! 190: zend_hash_move_forward(sdl->bindings)) {
! 191: if ((*binding)->bindingType == type) {
! 192: return *binding;
! 193: }
! 194: }
! 195: return NULL;
! 196: }
! 197:
! 198: sdlBindingPtr get_binding_from_name(sdlPtr sdl, char *name, char *ns)
! 199: {
! 200: sdlBindingPtr binding = NULL;
! 201: smart_str key = {0};
! 202:
! 203: smart_str_appends(&key, ns);
! 204: smart_str_appendc(&key, ':');
! 205: smart_str_appends(&key, name);
! 206: smart_str_0(&key);
! 207:
! 208: zend_hash_find(sdl->bindings, key.c, key.len, (void **)&binding);
! 209:
! 210: smart_str_free(&key);
! 211: return binding;
! 212: }
! 213:
! 214: static int is_wsdl_element(xmlNodePtr node)
! 215: {
! 216: if (node->ns && strcmp((char*)node->ns->href, WSDL_NAMESPACE) != 0) {
! 217: xmlAttrPtr attr;
! 218: if ((attr = get_attribute_ex(node->properties, "required", WSDL_NAMESPACE)) != NULL &&
! 219: attr->children && attr->children->content &&
! 220: (strcmp((char*)attr->children->content, "1") == 0 ||
! 221: strcmp((char*)attr->children->content, "true") == 0)) {
! 222: soap_error1(E_ERROR, "Parsing WSDL: Unknown required WSDL extension '%s'", node->ns->href);
! 223: }
! 224: return 0;
! 225: }
! 226: return 1;
! 227: }
! 228:
! 229: void sdl_set_uri_credentials(sdlCtx *ctx, char *uri TSRMLS_DC)
! 230: {
! 231: char *s;
! 232: int l1, l2;
! 233: zval *context = NULL;
! 234: zval **header = NULL;
! 235:
! 236: /* check if we load xsd from the same server */
! 237: s = strstr(ctx->sdl->source, "://");
! 238: if (!s) return;
! 239: s = strchr(s+3, '/');
! 240: l1 = s - ctx->sdl->source;
! 241: s = strstr((char*)uri, "://");
! 242: if (!s) return;
! 243: s = strchr(s+3, '/');
! 244: l2 = s - (char*)uri;
! 245: if (l1 != l2 || memcmp(ctx->sdl->source, uri, l1) != 0) {
! 246: /* another server. clear authentication credentals */
! 247: context = php_libxml_switch_context(NULL TSRMLS_CC);
! 248: php_libxml_switch_context(context TSRMLS_CC);
! 249: if (context) {
! 250: ctx->context = php_stream_context_from_zval(context, 1);
! 251:
! 252: if (ctx->context &&
! 253: php_stream_context_get_option(ctx->context, "http", "header", &header) == SUCCESS) {
! 254: s = strstr(Z_STRVAL_PP(header), "Authorization: Basic");
! 255: if (s && (s == Z_STRVAL_PP(header) || *(s-1) == '\n' || *(s-1) == '\r')) {
! 256: char *rest = strstr(s, "\r\n");
! 257: if (rest) {
! 258: zval new_header;
! 259:
! 260: rest += 2;
! 261: Z_TYPE(new_header) = IS_STRING;
! 262: Z_STRLEN(new_header) = Z_STRLEN_PP(header) - (rest - s);
! 263: Z_STRVAL(new_header) = emalloc(Z_STRLEN_PP(header) + 1);
! 264: memcpy(Z_STRVAL(new_header), Z_STRVAL_PP(header), s - Z_STRVAL_PP(header));
! 265: memcpy(Z_STRVAL(new_header) + (s - Z_STRVAL_PP(header)), rest, Z_STRLEN_PP(header) - (rest - Z_STRVAL_PP(header)) + 1);
! 266: ctx->old_header = *header;
! 267: Z_ADDREF_P(ctx->old_header);
! 268: php_stream_context_set_option(ctx->context, "http", "header", &new_header);
! 269: zval_dtor(&new_header);
! 270: }
! 271: }
! 272: }
! 273: }
! 274: }
! 275: }
! 276:
! 277: void sdl_restore_uri_credentials(sdlCtx *ctx TSRMLS_DC)
! 278: {
! 279: if (ctx->old_header) {
! 280: php_stream_context_set_option(ctx->context, "http", "header", ctx->old_header);
! 281: zval_ptr_dtor(&ctx->old_header);
! 282: ctx->old_header = NULL;
! 283: }
! 284: ctx->context = NULL;
! 285: }
! 286:
! 287: static void load_wsdl_ex(zval *this_ptr, char *struri, sdlCtx *ctx, int include TSRMLS_DC)
! 288: {
! 289: sdlPtr tmpsdl = ctx->sdl;
! 290: xmlDocPtr wsdl;
! 291: xmlNodePtr root, definitions, trav;
! 292: xmlAttrPtr targetNamespace;
! 293:
! 294: if (zend_hash_exists(&ctx->docs, struri, strlen(struri)+1)) {
! 295: return;
! 296: }
! 297:
! 298: sdl_set_uri_credentials(ctx, struri TSRMLS_CC);
! 299: wsdl = soap_xmlParseFile(struri TSRMLS_CC);
! 300: sdl_restore_uri_credentials(ctx TSRMLS_CC);
! 301:
! 302: if (!wsdl) {
! 303: xmlErrorPtr xmlErrorPtr = xmlGetLastError();
! 304:
! 305: if (xmlErrorPtr) {
! 306: soap_error2(E_ERROR, "Parsing WSDL: Couldn't load from '%s' : %s", struri, xmlErrorPtr->message);
! 307: } else {
! 308: soap_error1(E_ERROR, "Parsing WSDL: Couldn't load from '%s'", struri);
! 309: }
! 310: }
! 311:
! 312: zend_hash_add(&ctx->docs, struri, strlen(struri)+1, (void**)&wsdl, sizeof(xmlDocPtr), NULL);
! 313:
! 314: root = wsdl->children;
! 315: definitions = get_node_ex(root, "definitions", WSDL_NAMESPACE);
! 316: if (!definitions) {
! 317: if (include) {
! 318: xmlNodePtr schema = get_node_ex(root, "schema", XSD_NAMESPACE);
! 319: if (schema) {
! 320: load_schema(ctx, schema TSRMLS_CC);
! 321: return;
! 322: }
! 323: }
! 324: soap_error1(E_ERROR, "Parsing WSDL: Couldn't find <definitions> in '%s'", struri);
! 325: }
! 326:
! 327: if (!include) {
! 328: targetNamespace = get_attribute(definitions->properties, "targetNamespace");
! 329: if (targetNamespace) {
! 330: tmpsdl->target_ns = estrdup((char*)targetNamespace->children->content);
! 331: }
! 332: }
! 333:
! 334: trav = definitions->children;
! 335: while (trav != NULL) {
! 336: if (!is_wsdl_element(trav)) {
! 337: trav = trav->next;
! 338: continue;
! 339: }
! 340: if (node_is_equal(trav,"types")) {
! 341: /* TODO: Only one "types" is allowed */
! 342: xmlNodePtr trav2 = trav->children;
! 343:
! 344: while (trav2 != NULL) {
! 345: if (node_is_equal_ex(trav2, "schema", XSD_NAMESPACE)) {
! 346: load_schema(ctx, trav2 TSRMLS_CC);
! 347: } else if (is_wsdl_element(trav2) && !node_is_equal(trav2,"documentation")) {
! 348: soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav2->name);
! 349: }
! 350: trav2 = trav2->next;
! 351: }
! 352: } else if (node_is_equal(trav,"import")) {
! 353: /* TODO: namespace ??? */
! 354: xmlAttrPtr tmp = get_attribute(trav->properties, "location");
! 355: if (tmp) {
! 356: xmlChar *uri;
! 357: xmlChar *base = xmlNodeGetBase(trav->doc, trav);
! 358:
! 359: if (base == NULL) {
! 360: uri = xmlBuildURI(tmp->children->content, trav->doc->URL);
! 361: } else {
! 362: uri = xmlBuildURI(tmp->children->content, base);
! 363: xmlFree(base);
! 364: }
! 365: load_wsdl_ex(this_ptr, (char*)uri, ctx, 1 TSRMLS_CC);
! 366: xmlFree(uri);
! 367: }
! 368:
! 369: } else if (node_is_equal(trav,"message")) {
! 370: xmlAttrPtr name = get_attribute(trav->properties, "name");
! 371: if (name && name->children && name->children->content) {
! 372: if (zend_hash_add(&ctx->messages, (char*)name->children->content, xmlStrlen(name->children->content)+1,&trav, sizeof(xmlNodePtr), NULL) != SUCCESS) {
! 373: soap_error1(E_ERROR, "Parsing WSDL: <message> '%s' already defined", name->children->content);
! 374: }
! 375: } else {
! 376: soap_error0(E_ERROR, "Parsing WSDL: <message> has no name attribute");
! 377: }
! 378:
! 379: } else if (node_is_equal(trav,"portType")) {
! 380: xmlAttrPtr name = get_attribute(trav->properties, "name");
! 381: if (name && name->children && name->children->content) {
! 382: if (zend_hash_add(&ctx->portTypes, (char*)name->children->content, xmlStrlen(name->children->content)+1,&trav, sizeof(xmlNodePtr), NULL) != SUCCESS) {
! 383: soap_error1(E_ERROR, "Parsing WSDL: <portType> '%s' already defined", name->children->content);
! 384: }
! 385: } else {
! 386: soap_error0(E_ERROR, "Parsing WSDL: <portType> has no name attribute");
! 387: }
! 388:
! 389: } else if (node_is_equal(trav,"binding")) {
! 390: xmlAttrPtr name = get_attribute(trav->properties, "name");
! 391: if (name && name->children && name->children->content) {
! 392: if (zend_hash_add(&ctx->bindings, (char*)name->children->content, xmlStrlen(name->children->content)+1,&trav, sizeof(xmlNodePtr), NULL) != SUCCESS) {
! 393: soap_error1(E_ERROR, "Parsing WSDL: <binding> '%s' already defined", name->children->content);
! 394: }
! 395: } else {
! 396: soap_error0(E_ERROR, "Parsing WSDL: <binding> has no name attribute");
! 397: }
! 398:
! 399: } else if (node_is_equal(trav,"service")) {
! 400: xmlAttrPtr name = get_attribute(trav->properties, "name");
! 401: if (name && name->children && name->children->content) {
! 402: if (zend_hash_add(&ctx->services, (char*)name->children->content, xmlStrlen(name->children->content)+1,&trav, sizeof(xmlNodePtr), NULL) != SUCCESS) {
! 403: soap_error1(E_ERROR, "Parsing WSDL: <service> '%s' already defined", name->children->content);
! 404: }
! 405: } else {
! 406: soap_error0(E_ERROR, "Parsing WSDL: <service> has no name attribute");
! 407: }
! 408: } else if (!node_is_equal(trav,"documentation")) {
! 409: soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav->name);
! 410: }
! 411: trav = trav->next;
! 412: }
! 413: }
! 414:
! 415: static sdlSoapBindingFunctionHeaderPtr wsdl_soap_binding_header(sdlCtx* ctx, xmlNodePtr header, char* wsdl_soap_namespace, int fault)
! 416: {
! 417: xmlAttrPtr tmp;
! 418: xmlNodePtr *message, part;
! 419: char *ctype;
! 420: sdlSoapBindingFunctionHeaderPtr h;
! 421:
! 422: tmp = get_attribute(header->properties, "message");
! 423: if (!tmp) {
! 424: soap_error0(E_ERROR, "Parsing WSDL: Missing message attribute for <header>");
! 425: }
! 426:
! 427: ctype = strrchr((char*)tmp->children->content,':');
! 428: if (ctype == NULL) {
! 429: ctype = (char*)tmp->children->content;
! 430: } else {
! 431: ++ctype;
! 432: }
! 433: if (zend_hash_find(&ctx->messages, ctype, strlen(ctype)+1, (void**)&message) != SUCCESS) {
! 434: soap_error1(E_ERROR, "Parsing WSDL: Missing <message> with name '%s'", tmp->children->content);
! 435: }
! 436:
! 437: tmp = get_attribute(header->properties, "part");
! 438: if (!tmp) {
! 439: soap_error0(E_ERROR, "Parsing WSDL: Missing part attribute for <header>");
! 440: }
! 441: part = get_node_with_attribute_ex((*message)->children, "part", WSDL_NAMESPACE, "name", (char*)tmp->children->content, NULL);
! 442: if (!part) {
! 443: soap_error1(E_ERROR, "Parsing WSDL: Missing part '%s' in <message>", tmp->children->content);
! 444: }
! 445:
! 446: h = emalloc(sizeof(sdlSoapBindingFunctionHeader));
! 447: memset(h, 0, sizeof(sdlSoapBindingFunctionHeader));
! 448: h->name = estrdup((char*)tmp->children->content);
! 449:
! 450: tmp = get_attribute(header->properties, "use");
! 451: if (tmp && !strncmp((char*)tmp->children->content, "encoded", sizeof("encoded"))) {
! 452: h->use = SOAP_ENCODED;
! 453: } else {
! 454: h->use = SOAP_LITERAL;
! 455: }
! 456:
! 457: tmp = get_attribute(header->properties, "namespace");
! 458: if (tmp) {
! 459: h->ns = estrdup((char*)tmp->children->content);
! 460: }
! 461:
! 462: if (h->use == SOAP_ENCODED) {
! 463: tmp = get_attribute(header->properties, "encodingStyle");
! 464: if (tmp) {
! 465: if (strncmp((char*)tmp->children->content, SOAP_1_1_ENC_NAMESPACE, sizeof(SOAP_1_1_ENC_NAMESPACE)) == 0) {
! 466: h->encodingStyle = SOAP_ENCODING_1_1;
! 467: } else if (strncmp((char*)tmp->children->content, SOAP_1_2_ENC_NAMESPACE, sizeof(SOAP_1_2_ENC_NAMESPACE)) == 0) {
! 468: h->encodingStyle = SOAP_ENCODING_1_2;
! 469: } else {
! 470: soap_error1(E_ERROR, "Parsing WSDL: Unknown encodingStyle '%s'", tmp->children->content);
! 471: }
! 472: } else {
! 473: soap_error0(E_ERROR, "Parsing WSDL: Unspecified encodingStyle");
! 474: }
! 475: }
! 476:
! 477: tmp = get_attribute(part->properties, "type");
! 478: if (tmp != NULL) {
! 479: h->encode = get_encoder_from_prefix(ctx->sdl, part, tmp->children->content);
! 480: } else {
! 481: tmp = get_attribute(part->properties, "element");
! 482: if (tmp != NULL) {
! 483: h->element = get_element(ctx->sdl, part, tmp->children->content);
! 484: if (h->element) {
! 485: h->encode = h->element->encode;
! 486: if (!h->ns && h->element->namens) {
! 487: h->ns = estrdup(h->element->namens);
! 488: }
! 489: if (h->element->name) {
! 490: efree(h->name);
! 491: h->name = estrdup(h->element->name);
! 492: }
! 493: }
! 494: }
! 495: }
! 496: if (!fault) {
! 497: xmlNodePtr trav = header->children;
! 498: while (trav != NULL) {
! 499: if (node_is_equal_ex(trav, "headerfault", wsdl_soap_namespace)) {
! 500: sdlSoapBindingFunctionHeaderPtr hf = wsdl_soap_binding_header(ctx, trav, wsdl_soap_namespace, 1);
! 501: smart_str key = {0};
! 502:
! 503: if (h->headerfaults == NULL) {
! 504: h->headerfaults = emalloc(sizeof(HashTable));
! 505: zend_hash_init(h->headerfaults, 0, NULL, delete_header, 0);
! 506: }
! 507:
! 508: if (hf->ns) {
! 509: smart_str_appends(&key,hf->ns);
! 510: smart_str_appendc(&key,':');
! 511: }
! 512: smart_str_appends(&key,hf->name);
! 513: smart_str_0(&key);
! 514: if (zend_hash_add(h->headerfaults, key.c, key.len+1, (void**)&hf, sizeof(sdlSoapBindingFunctionHeaderPtr), NULL) != SUCCESS) {
! 515: delete_header((void**)&hf);
! 516: }
! 517: smart_str_free(&key);
! 518: } else if (is_wsdl_element(trav) && !node_is_equal(trav,"documentation")) {
! 519: soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav->name);
! 520: }
! 521: trav = trav->next;
! 522: }
! 523: }
! 524: return h;
! 525: }
! 526:
! 527: static void wsdl_soap_binding_body(sdlCtx* ctx, xmlNodePtr node, char* wsdl_soap_namespace, sdlSoapBindingFunctionBody *binding, HashTable* params)
! 528: {
! 529: xmlNodePtr body, trav;
! 530: xmlAttrPtr tmp;
! 531:
! 532: trav = node->children;
! 533: while (trav != NULL) {
! 534: if (node_is_equal_ex(trav, "body", wsdl_soap_namespace)) {
! 535: body = trav;
! 536:
! 537: tmp = get_attribute(body->properties, "use");
! 538: if (tmp && !strncmp((char*)tmp->children->content, "literal", sizeof("literal"))) {
! 539: binding->use = SOAP_LITERAL;
! 540: } else {
! 541: binding->use = SOAP_ENCODED;
! 542: }
! 543:
! 544: tmp = get_attribute(body->properties, "namespace");
! 545: if (tmp) {
! 546: binding->ns = estrdup((char*)tmp->children->content);
! 547: }
! 548:
! 549: tmp = get_attribute(body->properties, "parts");
! 550: if (tmp) {
! 551: HashTable ht;
! 552: char *parts = (char*)tmp->children->content;
! 553:
! 554: /* Delete all parts those are not in the "parts" attribute */
! 555: zend_hash_init(&ht, 0, NULL, delete_parameter, 0);
! 556: while (*parts) {
! 557: HashPosition pos;
! 558: sdlParamPtr *param;
! 559: int found = 0;
! 560: char *end;
! 561:
! 562: while (*parts == ' ') ++parts;
! 563: if (*parts == '\0') break;
! 564: end = strchr(parts, ' ');
! 565: if (end) *end = '\0';
! 566: zend_hash_internal_pointer_reset_ex(params, &pos);
! 567: while (zend_hash_get_current_data_ex(params, (void **)¶m, &pos) != FAILURE) {
! 568: if ((*param)->paramName &&
! 569: strcmp(parts, (*param)->paramName) == 0) {
! 570: sdlParamPtr x_param;
! 571: x_param = emalloc(sizeof(sdlParam));
! 572: *x_param = **param;
! 573: (*param)->paramName = NULL;
! 574: zend_hash_next_index_insert(&ht, &x_param, sizeof(sdlParamPtr), NULL);
! 575: found = 1;
! 576: break;
! 577: }
! 578: zend_hash_move_forward_ex(params, &pos);
! 579: }
! 580: if (!found) {
! 581: soap_error1(E_ERROR, "Parsing WSDL: Missing part '%s' in <message>", parts);
! 582: }
! 583: parts += strlen(parts);
! 584: if (end) *end = ' ';
! 585: }
! 586: zend_hash_destroy(params);
! 587: *params = ht;
! 588: }
! 589:
! 590: if (binding->use == SOAP_ENCODED) {
! 591: tmp = get_attribute(body->properties, "encodingStyle");
! 592: if (tmp) {
! 593: if (strncmp((char*)tmp->children->content, SOAP_1_1_ENC_NAMESPACE, sizeof(SOAP_1_1_ENC_NAMESPACE)) == 0) {
! 594: binding->encodingStyle = SOAP_ENCODING_1_1;
! 595: } else if (strncmp((char*)tmp->children->content, SOAP_1_2_ENC_NAMESPACE, sizeof(SOAP_1_2_ENC_NAMESPACE)) == 0) {
! 596: binding->encodingStyle = SOAP_ENCODING_1_2;
! 597: } else {
! 598: soap_error1(E_ERROR, "Parsing WSDL: Unknown encodingStyle '%s'", tmp->children->content);
! 599: }
! 600: } else {
! 601: soap_error0(E_ERROR, "Parsing WSDL: Unspecified encodingStyle");
! 602: }
! 603: }
! 604: } else if (node_is_equal_ex(trav, "header", wsdl_soap_namespace)) {
! 605: sdlSoapBindingFunctionHeaderPtr h = wsdl_soap_binding_header(ctx, trav, wsdl_soap_namespace, 0);
! 606: smart_str key = {0};
! 607:
! 608: if (binding->headers == NULL) {
! 609: binding->headers = emalloc(sizeof(HashTable));
! 610: zend_hash_init(binding->headers, 0, NULL, delete_header, 0);
! 611: }
! 612:
! 613: if (h->ns) {
! 614: smart_str_appends(&key,h->ns);
! 615: smart_str_appendc(&key,':');
! 616: }
! 617: smart_str_appends(&key,h->name);
! 618: smart_str_0(&key);
! 619: if (zend_hash_add(binding->headers, key.c, key.len+1, (void**)&h, sizeof(sdlSoapBindingFunctionHeaderPtr), NULL) != SUCCESS) {
! 620: delete_header((void**)&h);
! 621: }
! 622: smart_str_free(&key);
! 623: } else if (is_wsdl_element(trav) && !node_is_equal(trav,"documentation")) {
! 624: soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav->name);
! 625: }
! 626: trav = trav->next;
! 627: }
! 628: }
! 629:
! 630: static HashTable* wsdl_message(sdlCtx *ctx, xmlChar* message_name)
! 631: {
! 632: xmlNodePtr trav, part, message = NULL, *tmp;
! 633: HashTable* parameters = NULL;
! 634: char *ctype;
! 635:
! 636: ctype = strrchr((char*)message_name,':');
! 637: if (ctype == NULL) {
! 638: ctype = (char*)message_name;
! 639: } else {
! 640: ++ctype;
! 641: }
! 642: if (zend_hash_find(&ctx->messages, ctype, strlen(ctype)+1, (void**)&tmp) != SUCCESS) {
! 643: soap_error1(E_ERROR, "Parsing WSDL: Missing <message> with name '%s'", message_name);
! 644: }
! 645: message = *tmp;
! 646:
! 647: parameters = emalloc(sizeof(HashTable));
! 648: zend_hash_init(parameters, 0, NULL, delete_parameter, 0);
! 649:
! 650: trav = message->children;
! 651: while (trav != NULL) {
! 652: xmlAttrPtr element, type, name;
! 653: sdlParamPtr param;
! 654:
! 655: if (trav->ns != NULL && strcmp((char*)trav->ns->href, WSDL_NAMESPACE) != 0) {
! 656: soap_error1(E_ERROR, "Parsing WSDL: Unexpected extensibility element <%s>", trav->name);
! 657: }
! 658: if (node_is_equal(trav,"documentation")) {
! 659: trav = trav->next;
! 660: continue;
! 661: }
! 662: if (!node_is_equal(trav,"part")) {
! 663: soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav->name);
! 664: }
! 665: part = trav;
! 666: param = emalloc(sizeof(sdlParam));
! 667: memset(param,0,sizeof(sdlParam));
! 668: param->order = 0;
! 669:
! 670: name = get_attribute(part->properties, "name");
! 671: if (name == NULL) {
! 672: soap_error1(E_ERROR, "Parsing WSDL: No name associated with <part> '%s'", message->name);
! 673: }
! 674:
! 675: param->paramName = estrdup((char*)name->children->content);
! 676:
! 677: type = get_attribute(part->properties, "type");
! 678: if (type != NULL) {
! 679: param->encode = get_encoder_from_prefix(ctx->sdl, part, type->children->content);
! 680: } else {
! 681: element = get_attribute(part->properties, "element");
! 682: if (element != NULL) {
! 683: param->element = get_element(ctx->sdl, part, element->children->content);
! 684: if (param->element) {
! 685: param->encode = param->element->encode;
! 686: }
! 687: }
! 688: }
! 689:
! 690: zend_hash_next_index_insert(parameters, ¶m, sizeof(sdlParamPtr), NULL);
! 691:
! 692: trav = trav->next;
! 693: }
! 694: return parameters;
! 695: }
! 696:
! 697: static sdlPtr load_wsdl(zval *this_ptr, char *struri TSRMLS_DC)
! 698: {
! 699: sdlCtx ctx;
! 700: int i,n;
! 701:
! 702: memset(&ctx,0,sizeof(ctx));
! 703: ctx.sdl = emalloc(sizeof(sdl));
! 704: memset(ctx.sdl, 0, sizeof(sdl));
! 705: ctx.sdl->source = estrdup(struri);
! 706: zend_hash_init(&ctx.sdl->functions, 0, NULL, delete_function, 0);
! 707:
! 708: zend_hash_init(&ctx.docs, 0, NULL, delete_document, 0);
! 709: zend_hash_init(&ctx.messages, 0, NULL, NULL, 0);
! 710: zend_hash_init(&ctx.bindings, 0, NULL, NULL, 0);
! 711: zend_hash_init(&ctx.portTypes, 0, NULL, NULL, 0);
! 712: zend_hash_init(&ctx.services, 0, NULL, NULL, 0);
! 713:
! 714: load_wsdl_ex(this_ptr, struri,&ctx, 0 TSRMLS_CC);
! 715: schema_pass2(&ctx);
! 716:
! 717: n = zend_hash_num_elements(&ctx.services);
! 718: if (n > 0) {
! 719: zend_hash_internal_pointer_reset(&ctx.services);
! 720: for (i = 0; i < n; i++) {
! 721: xmlNodePtr *tmp, service;
! 722: xmlNodePtr trav, port;
! 723: int has_soap_port = 0;
! 724:
! 725: zend_hash_get_current_data(&ctx.services, (void **)&tmp);
! 726: service = *tmp;
! 727:
! 728: trav = service->children;
! 729: while (trav != NULL) {
! 730: xmlAttrPtr type, name, bindingAttr, location;
! 731: xmlNodePtr portType, operation;
! 732: xmlNodePtr address, binding, trav2;
! 733: char *ctype;
! 734: sdlBindingPtr tmpbinding;
! 735: char *wsdl_soap_namespace = NULL;
! 736:
! 737: if (!is_wsdl_element(trav) || node_is_equal(trav,"documentation")) {
! 738: trav = trav->next;
! 739: continue;
! 740: }
! 741: if (!node_is_equal(trav,"port")) {
! 742: soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav->name);
! 743: }
! 744:
! 745: port = trav;
! 746:
! 747: tmpbinding = emalloc(sizeof(sdlBinding));
! 748: memset(tmpbinding, 0, sizeof(sdlBinding));
! 749:
! 750: bindingAttr = get_attribute(port->properties, "binding");
! 751: if (bindingAttr == NULL) {
! 752: soap_error0(E_ERROR, "Parsing WSDL: No binding associated with <port>");
! 753: }
! 754:
! 755: /* find address and figure out binding type */
! 756: address = NULL;
! 757: trav2 = port->children;
! 758: while (trav2 != NULL) {
! 759: if (node_is_equal(trav2,"address") && trav2->ns) {
! 760: if (!strncmp((char*)trav2->ns->href, WSDL_SOAP11_NAMESPACE, sizeof(WSDL_SOAP11_NAMESPACE))) {
! 761: address = trav2;
! 762: wsdl_soap_namespace = WSDL_SOAP11_NAMESPACE;
! 763: tmpbinding->bindingType = BINDING_SOAP;
! 764: } else if (!strncmp((char*)trav2->ns->href, WSDL_SOAP12_NAMESPACE, sizeof(WSDL_SOAP12_NAMESPACE))) {
! 765: address = trav2;
! 766: wsdl_soap_namespace = WSDL_SOAP12_NAMESPACE;
! 767: tmpbinding->bindingType = BINDING_SOAP;
! 768: } else if (!strncmp((char*)trav2->ns->href, RPC_SOAP12_NAMESPACE, sizeof(RPC_SOAP12_NAMESPACE))) {
! 769: address = trav2;
! 770: wsdl_soap_namespace = RPC_SOAP12_NAMESPACE;
! 771: tmpbinding->bindingType = BINDING_SOAP;
! 772: } else if (!strncmp((char*)trav2->ns->href, WSDL_HTTP11_NAMESPACE, sizeof(WSDL_HTTP11_NAMESPACE))) {
! 773: address = trav2;
! 774: tmpbinding->bindingType = BINDING_HTTP;
! 775: } else if (!strncmp((char*)trav2->ns->href, WSDL_HTTP12_NAMESPACE, sizeof(WSDL_HTTP12_NAMESPACE))) {
! 776: address = trav2;
! 777: tmpbinding->bindingType = BINDING_HTTP;
! 778: }
! 779: }
! 780: if (trav2 != address && is_wsdl_element(trav2) && !node_is_equal(trav2,"documentation")) {
! 781: soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav2->name);
! 782: }
! 783: trav2 = trav2->next;
! 784: }
! 785: if (!address || tmpbinding->bindingType == BINDING_HTTP) {
! 786: if (has_soap_port || trav->next || i < n-1) {
! 787: efree(tmpbinding);
! 788: trav = trav->next;
! 789: continue;
! 790: } else if (!address) {
! 791: soap_error0(E_ERROR, "Parsing WSDL: No address associated with <port>");
! 792: }
! 793: }
! 794: has_soap_port = 1;
! 795:
! 796: location = get_attribute(address->properties, "location");
! 797: if (!location) {
! 798: soap_error0(E_ERROR, "Parsing WSDL: No location associated with <port>");
! 799: }
! 800:
! 801: tmpbinding->location = estrdup((char*)location->children->content);
! 802:
! 803: ctype = strrchr((char*)bindingAttr->children->content,':');
! 804: if (ctype == NULL) {
! 805: ctype = (char*)bindingAttr->children->content;
! 806: } else {
! 807: ++ctype;
! 808: }
! 809: if (zend_hash_find(&ctx.bindings, ctype, strlen(ctype)+1, (void*)&tmp) != SUCCESS) {
! 810: soap_error1(E_ERROR, "Parsing WSDL: No <binding> element with name '%s'", ctype);
! 811: }
! 812: binding = *tmp;
! 813:
! 814: if (tmpbinding->bindingType == BINDING_SOAP) {
! 815: sdlSoapBindingPtr soapBinding;
! 816: xmlNodePtr soapBindingNode;
! 817: xmlAttrPtr tmp;
! 818:
! 819: soapBinding = emalloc(sizeof(sdlSoapBinding));
! 820: memset(soapBinding, 0, sizeof(sdlSoapBinding));
! 821: soapBinding->style = SOAP_DOCUMENT;
! 822:
! 823: soapBindingNode = get_node_ex(binding->children, "binding", wsdl_soap_namespace);
! 824: if (soapBindingNode) {
! 825: tmp = get_attribute(soapBindingNode->properties, "style");
! 826: if (tmp && !strncmp((char*)tmp->children->content, "rpc", sizeof("rpc"))) {
! 827: soapBinding->style = SOAP_RPC;
! 828: }
! 829:
! 830: tmp = get_attribute(soapBindingNode->properties, "transport");
! 831: if (tmp) {
! 832: if (strncmp((char*)tmp->children->content, WSDL_HTTP_TRANSPORT, sizeof(WSDL_HTTP_TRANSPORT)) == 0) {
! 833: soapBinding->transport = SOAP_TRANSPORT_HTTP;
! 834: } else {
! 835: /* try the next binding */
! 836: efree(soapBinding);
! 837: efree(tmpbinding->location);
! 838: efree(tmpbinding);
! 839: trav = trav->next;
! 840: continue;
! 841: }
! 842: }
! 843: }
! 844: tmpbinding->bindingAttributes = (void *)soapBinding;
! 845: }
! 846:
! 847: name = get_attribute(binding->properties, "name");
! 848: if (name == NULL) {
! 849: soap_error0(E_ERROR, "Parsing WSDL: Missing 'name' attribute for <binding>");
! 850: }
! 851: tmpbinding->name = estrdup((char*)name->children->content);
! 852:
! 853: type = get_attribute(binding->properties, "type");
! 854: if (type == NULL) {
! 855: soap_error0(E_ERROR, "Parsing WSDL: Missing 'type' attribute for <binding>");
! 856: }
! 857:
! 858: ctype = strrchr((char*)type->children->content,':');
! 859: if (ctype == NULL) {
! 860: ctype = (char*)type->children->content;
! 861: } else {
! 862: ++ctype;
! 863: }
! 864: if (zend_hash_find(&ctx.portTypes, ctype, strlen(ctype)+1, (void**)&tmp) != SUCCESS) {
! 865: soap_error1(E_ERROR, "Parsing WSDL: Missing <portType> with name '%s'", name->children->content);
! 866: }
! 867: portType = *tmp;
! 868:
! 869: trav2 = binding->children;
! 870: while (trav2 != NULL) {
! 871: sdlFunctionPtr function;
! 872: xmlNodePtr input, output, fault, portTypeOperation, trav3;
! 873: xmlAttrPtr op_name, paramOrder;
! 874:
! 875: if ((tmpbinding->bindingType == BINDING_SOAP &&
! 876: node_is_equal_ex(trav2, "binding", wsdl_soap_namespace)) ||
! 877: !is_wsdl_element(trav2) ||
! 878: node_is_equal(trav2,"documentation")) {
! 879: trav2 = trav2->next;
! 880: continue;
! 881: }
! 882: if (!node_is_equal(trav2,"operation")) {
! 883: soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav2->name);
! 884: }
! 885:
! 886: operation = trav2;
! 887:
! 888: op_name = get_attribute(operation->properties, "name");
! 889: if (op_name == NULL) {
! 890: soap_error0(E_ERROR, "Parsing WSDL: Missing 'name' attribute for <operation>");
! 891: }
! 892:
! 893: trav3 = operation->children;
! 894: while (trav3 != NULL) {
! 895: if (tmpbinding->bindingType == BINDING_SOAP &&
! 896: node_is_equal_ex(trav3, "operation", wsdl_soap_namespace)) {
! 897: } else if (is_wsdl_element(trav3) &&
! 898: !node_is_equal(trav3,"input") &&
! 899: !node_is_equal(trav3,"output") &&
! 900: !node_is_equal(trav3,"fault") &&
! 901: !node_is_equal(trav3,"documentation")) {
! 902: soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav3->name);
! 903: }
! 904: trav3 = trav3->next;
! 905: }
! 906:
! 907: portTypeOperation = get_node_with_attribute_ex(portType->children, "operation", WSDL_NAMESPACE, "name", (char*)op_name->children->content, NULL);
! 908: if (portTypeOperation == NULL) {
! 909: soap_error1(E_ERROR, "Parsing WSDL: Missing <portType>/<operation> with name '%s'", op_name->children->content);
! 910: }
! 911:
! 912: function = emalloc(sizeof(sdlFunction));
! 913: memset(function, 0, sizeof(sdlFunction));
! 914: function->functionName = estrdup((char*)op_name->children->content);
! 915:
! 916: if (tmpbinding->bindingType == BINDING_SOAP) {
! 917: sdlSoapBindingFunctionPtr soapFunctionBinding;
! 918: sdlSoapBindingPtr soapBinding;
! 919: xmlNodePtr soapOperation;
! 920: xmlAttrPtr tmp;
! 921:
! 922: soapFunctionBinding = emalloc(sizeof(sdlSoapBindingFunction));
! 923: memset(soapFunctionBinding, 0, sizeof(sdlSoapBindingFunction));
! 924: soapBinding = (sdlSoapBindingPtr)tmpbinding->bindingAttributes;
! 925: soapFunctionBinding->style = soapBinding->style;
! 926:
! 927: soapOperation = get_node_ex(operation->children, "operation", wsdl_soap_namespace);
! 928: if (soapOperation) {
! 929: tmp = get_attribute(soapOperation->properties, "soapAction");
! 930: if (tmp) {
! 931: soapFunctionBinding->soapAction = estrdup((char*)tmp->children->content);
! 932: }
! 933:
! 934: tmp = get_attribute(soapOperation->properties, "style");
! 935: if (tmp) {
! 936: if (!strncmp((char*)tmp->children->content, "rpc", sizeof("rpc"))) {
! 937: soapFunctionBinding->style = SOAP_RPC;
! 938: } else {
! 939: soapFunctionBinding->style = SOAP_DOCUMENT;
! 940: }
! 941: } else {
! 942: soapFunctionBinding->style = soapBinding->style;
! 943: }
! 944: }
! 945:
! 946: function->bindingAttributes = (void *)soapFunctionBinding;
! 947: }
! 948:
! 949: input = get_node_ex(portTypeOperation->children, "input", WSDL_NAMESPACE);
! 950: if (input != NULL) {
! 951: xmlAttrPtr message, name;
! 952:
! 953: message = get_attribute(input->properties, "message");
! 954: if (message == NULL) {
! 955: soap_error1(E_ERROR, "Parsing WSDL: Missing name for <input> of '%s'", op_name->children->content);
! 956: }
! 957: function->requestParameters = wsdl_message(&ctx, message->children->content);
! 958:
! 959: name = get_attribute(input->properties, "name");
! 960: /* FIXME
! 961: if (name != NULL) {
! 962: function->requestName = estrdup(name->children->content);
! 963: } else {
! 964: */
! 965: {
! 966: function->requestName = estrdup(function->functionName);
! 967: }
! 968:
! 969: if (tmpbinding->bindingType == BINDING_SOAP) {
! 970: input = get_node_ex(operation->children, "input", WSDL_NAMESPACE);
! 971: if (input != NULL) {
! 972: sdlSoapBindingFunctionPtr soapFunctionBinding = function->bindingAttributes;
! 973: wsdl_soap_binding_body(&ctx, input, wsdl_soap_namespace, &soapFunctionBinding->input, function->requestParameters);
! 974: }
! 975: }
! 976: }
! 977:
! 978: output = get_node_ex(portTypeOperation->children, "output", WSDL_NAMESPACE);
! 979: if (output != NULL) {
! 980: xmlAttrPtr message, name;
! 981:
! 982: message = get_attribute(output->properties, "message");
! 983: if (message == NULL) {
! 984: soap_error1(E_ERROR, "Parsing WSDL: Missing name for <output> of '%s'", op_name->children->content);
! 985: }
! 986: function->responseParameters = wsdl_message(&ctx, message->children->content);
! 987:
! 988: name = get_attribute(output->properties, "name");
! 989: /* FIXME
! 990: if (name != NULL) {
! 991: function->responseName = estrdup(name->children->content);
! 992: } else if (input == NULL) {
! 993: function->responseName = estrdup(function->functionName);
! 994: } else {
! 995: */
! 996: {
! 997: int len = strlen(function->functionName);
! 998: function->responseName = emalloc(len + sizeof("Response"));
! 999: memcpy(function->responseName, function->functionName, len);
! 1000: memcpy(function->responseName+len, "Response", sizeof("Response"));
! 1001: }
! 1002:
! 1003: if (tmpbinding->bindingType == BINDING_SOAP) {
! 1004: output = get_node_ex(operation->children, "output", WSDL_NAMESPACE);
! 1005: if (output != NULL) {
! 1006: sdlSoapBindingFunctionPtr soapFunctionBinding = function->bindingAttributes;
! 1007: wsdl_soap_binding_body(&ctx, output, wsdl_soap_namespace, &soapFunctionBinding->output, function->responseParameters);
! 1008: }
! 1009: }
! 1010: }
! 1011:
! 1012: paramOrder = get_attribute(portTypeOperation->properties, "parameterOrder");
! 1013: if (paramOrder) {
! 1014: /* FIXME: */
! 1015: }
! 1016:
! 1017: fault = portTypeOperation->children;
! 1018: while (fault != NULL) {
! 1019: if (node_is_equal_ex(fault, "fault", WSDL_NAMESPACE)) {
! 1020: xmlAttrPtr message, name;
! 1021: sdlFaultPtr f;
! 1022:
! 1023: name = get_attribute(fault->properties, "name");
! 1024: if (name == NULL) {
! 1025: soap_error1(E_ERROR, "Parsing WSDL: Missing name for <fault> of '%s'", op_name->children->content);
! 1026: }
! 1027: message = get_attribute(fault->properties, "message");
! 1028: if (message == NULL) {
! 1029: soap_error1(E_ERROR, "Parsing WSDL: Missing name for <output> of '%s'", op_name->children->content);
! 1030: }
! 1031:
! 1032: f = emalloc(sizeof(sdlFault));
! 1033: memset(f, 0, sizeof(sdlFault));
! 1034:
! 1035: f->name = estrdup((char*)name->children->content);
! 1036: f->details = wsdl_message(&ctx, message->children->content);
! 1037: if (f->details == NULL || zend_hash_num_elements(f->details) > 1) {
! 1038: soap_error1(E_ERROR, "Parsing WSDL: The fault message '%s' must have a single part", message->children->content);
! 1039: }
! 1040:
! 1041: if (tmpbinding->bindingType == BINDING_SOAP) {
! 1042: xmlNodePtr soap_fault = get_node_with_attribute_ex(operation->children, "fault", WSDL_NAMESPACE, "name", f->name, NULL);
! 1043: if (soap_fault != NULL) {
! 1044: xmlNodePtr trav = soap_fault->children;
! 1045: while (trav != NULL) {
! 1046: if (node_is_equal_ex(trav, "fault", wsdl_soap_namespace)) {
! 1047: xmlAttrPtr tmp;
! 1048: sdlSoapBindingFunctionFaultPtr binding;
! 1049:
! 1050: binding = f->bindingAttributes = emalloc(sizeof(sdlSoapBindingFunctionFault));
! 1051: memset(f->bindingAttributes, 0, sizeof(sdlSoapBindingFunctionFault));
! 1052:
! 1053: tmp = get_attribute(trav->properties, "use");
! 1054: if (tmp && !strncmp((char*)tmp->children->content, "encoded", sizeof("encoded"))) {
! 1055: binding->use = SOAP_ENCODED;
! 1056: } else {
! 1057: binding->use = SOAP_LITERAL;
! 1058: }
! 1059:
! 1060: tmp = get_attribute(trav->properties, "namespace");
! 1061: if (tmp) {
! 1062: binding->ns = estrdup((char*)tmp->children->content);
! 1063: }
! 1064:
! 1065: if (binding->use == SOAP_ENCODED) {
! 1066: tmp = get_attribute(trav->properties, "encodingStyle");
! 1067: if (tmp) {
! 1068: if (strncmp((char*)tmp->children->content, SOAP_1_1_ENC_NAMESPACE, sizeof(SOAP_1_1_ENC_NAMESPACE)) == 0) {
! 1069: binding->encodingStyle = SOAP_ENCODING_1_1;
! 1070: } else if (strncmp((char*)tmp->children->content, SOAP_1_2_ENC_NAMESPACE, sizeof(SOAP_1_2_ENC_NAMESPACE)) == 0) {
! 1071: binding->encodingStyle = SOAP_ENCODING_1_2;
! 1072: } else {
! 1073: soap_error1(E_ERROR, "Parsing WSDL: Unknown encodingStyle '%s'", tmp->children->content);
! 1074: }
! 1075: } else {
! 1076: soap_error0(E_ERROR, "Parsing WSDL: Unspecified encodingStyle");
! 1077: }
! 1078: }
! 1079: } else if (is_wsdl_element(trav) && !node_is_equal(trav,"documentation")) {
! 1080: soap_error1(E_ERROR, "Parsing WSDL: Unexpected WSDL element <%s>", trav->name);
! 1081: }
! 1082: trav = trav->next;
! 1083: }
! 1084: }
! 1085: }
! 1086: if (function->faults == NULL) {
! 1087: function->faults = emalloc(sizeof(HashTable));
! 1088: zend_hash_init(function->faults, 0, NULL, delete_fault, 0);
! 1089: }
! 1090: if (zend_hash_add(function->faults, f->name, strlen(f->name)+1, (void**)&f, sizeof(sdlFaultPtr), NULL) != SUCCESS) {
! 1091: soap_error2(E_ERROR, "Parsing WSDL: <fault> with name '%s' already defined in '%s'", f->name, op_name->children->content);
! 1092: }
! 1093: }
! 1094: fault = fault->next;
! 1095: }
! 1096:
! 1097: function->binding = tmpbinding;
! 1098:
! 1099: {
! 1100: char *tmp = estrdup(function->functionName);
! 1101: int len = strlen(tmp);
! 1102:
! 1103: if (zend_hash_add(&ctx.sdl->functions, php_strtolower(tmp, len), len+1, &function, sizeof(sdlFunctionPtr), NULL) != SUCCESS) {
! 1104: zend_hash_next_index_insert(&ctx.sdl->functions, &function, sizeof(sdlFunctionPtr), NULL);
! 1105: }
! 1106: efree(tmp);
! 1107: if (function->requestName != NULL && strcmp(function->requestName,function->functionName) != 0) {
! 1108: if (ctx.sdl->requests == NULL) {
! 1109: ctx.sdl->requests = emalloc(sizeof(HashTable));
! 1110: zend_hash_init(ctx.sdl->requests, 0, NULL, NULL, 0);
! 1111: }
! 1112: tmp = estrdup(function->requestName);
! 1113: len = strlen(tmp);
! 1114: zend_hash_add(ctx.sdl->requests, php_strtolower(tmp, len), len+1, &function, sizeof(sdlFunctionPtr), NULL);
! 1115: efree(tmp);
! 1116: }
! 1117: }
! 1118: trav2 = trav2->next;
! 1119: }
! 1120:
! 1121: if (!ctx.sdl->bindings) {
! 1122: ctx.sdl->bindings = emalloc(sizeof(HashTable));
! 1123: zend_hash_init(ctx.sdl->bindings, 0, NULL, delete_binding, 0);
! 1124: }
! 1125:
! 1126: zend_hash_add(ctx.sdl->bindings, tmpbinding->name, strlen(tmpbinding->name), &tmpbinding, sizeof(sdlBindingPtr), NULL);
! 1127: trav= trav->next;
! 1128: }
! 1129:
! 1130: zend_hash_move_forward(&ctx.services);
! 1131: }
! 1132: } else {
! 1133: soap_error0(E_ERROR, "Parsing WSDL: Couldn't bind to service");
! 1134: }
! 1135:
! 1136: if (ctx.sdl->bindings == NULL || ctx.sdl->bindings->nNumOfElements == 0) {
! 1137: soap_error0(E_ERROR, "Parsing WSDL: Could not find any usable binding services in WSDL.");
! 1138: }
! 1139:
! 1140: zend_hash_destroy(&ctx.messages);
! 1141: zend_hash_destroy(&ctx.bindings);
! 1142: zend_hash_destroy(&ctx.portTypes);
! 1143: zend_hash_destroy(&ctx.services);
! 1144: zend_hash_destroy(&ctx.docs);
! 1145:
! 1146: return ctx.sdl;
! 1147: }
! 1148:
! 1149: #define WSDL_CACHE_VERSION 0x0e
! 1150:
! 1151: #define WSDL_CACHE_GET(ret,type,buf) memcpy(&ret,*buf,sizeof(type)); *buf += sizeof(type);
! 1152: #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;
! 1153: #define WSDL_CACHE_GET_1(ret,type,buf) ret = (type)(**buf); (*buf)++;
! 1154: #define WSDL_CACHE_GET_N(ret,n,buf) memcpy(ret,*buf,n); *buf += n;
! 1155: #define WSDL_CACHE_SKIP(n,buf) *buf += n;
! 1156:
! 1157: #define WSDL_CACHE_PUT_INT(val,buf) smart_str_appendc(buf,val & 0xff); \
! 1158: smart_str_appendc(buf,(val >> 8) & 0xff); \
! 1159: smart_str_appendc(buf,(val >> 16) & 0xff); \
! 1160: smart_str_appendc(buf,(val >> 24) & 0xff);
! 1161: #define WSDL_CACHE_PUT_1(val,buf) smart_str_appendc(buf,val);
! 1162: #define WSDL_CACHE_PUT_N(val,n,buf) smart_str_appendl(buf,(char*)val,n);
! 1163:
! 1164: static char* sdl_deserialize_string(char **in)
! 1165: {
! 1166: char *s;
! 1167: int len;
! 1168:
! 1169: WSDL_CACHE_GET_INT(len, in);
! 1170: if (len == 0x7fffffff) {
! 1171: return NULL;
! 1172: } else {
! 1173: s = emalloc(len+1);
! 1174: WSDL_CACHE_GET_N(s, len, in);
! 1175: s[len] = '\0';
! 1176: return s;
! 1177: }
! 1178: }
! 1179:
! 1180: static void sdl_deserialize_key(HashTable* ht, void* data, char **in)
! 1181: {
! 1182: int len;
! 1183:
! 1184: WSDL_CACHE_GET_INT(len, in);
! 1185: if (len == 0) {
! 1186: zend_hash_next_index_insert(ht, &data, sizeof(void*), NULL);
! 1187: } else {
! 1188: zend_hash_add(ht, *in, len, &data, sizeof(void*), NULL);
! 1189: WSDL_CACHE_SKIP(len, in);
! 1190: }
! 1191: }
! 1192:
! 1193: static void sdl_deserialize_attribute(sdlAttributePtr attr, encodePtr *encoders, char **in)
! 1194: {
! 1195: int i;
! 1196:
! 1197: attr->name = sdl_deserialize_string(in);
! 1198: attr->namens = sdl_deserialize_string(in);
! 1199: attr->ref = sdl_deserialize_string(in);
! 1200: attr->def = sdl_deserialize_string(in);
! 1201: attr->fixed = sdl_deserialize_string(in);
! 1202: WSDL_CACHE_GET_1(attr->form, sdlForm, in);
! 1203: WSDL_CACHE_GET_1(attr->use, sdlUse, in);
! 1204: WSDL_CACHE_GET_INT(i, in);
! 1205: attr->encode = encoders[i];
! 1206: WSDL_CACHE_GET_INT(i, in);
! 1207: if (i > 0) {
! 1208: attr->extraAttributes = emalloc(sizeof(HashTable));
! 1209: zend_hash_init(attr->extraAttributes, i, NULL, delete_extra_attribute, 0);
! 1210: while (i > 0) {
! 1211: sdlExtraAttributePtr x = emalloc(sizeof(sdlExtraAttribute));
! 1212: sdl_deserialize_key(attr->extraAttributes, x, in);
! 1213: x->ns = sdl_deserialize_string(in);
! 1214: x->val = sdl_deserialize_string(in);
! 1215: --i;
! 1216: }
! 1217: }
! 1218: }
! 1219:
! 1220: static sdlRestrictionIntPtr sdl_deserialize_resriction_int(char **in)
! 1221: {
! 1222: if (**in == 1) {
! 1223: sdlRestrictionIntPtr x = emalloc(sizeof(sdlRestrictionInt));
! 1224: WSDL_CACHE_SKIP(1, in);
! 1225: WSDL_CACHE_GET_INT(x->value, in);
! 1226: WSDL_CACHE_GET_1(x->fixed, char, in);
! 1227: return x;
! 1228: } else {
! 1229: WSDL_CACHE_SKIP(1, in);
! 1230: return NULL;
! 1231: }
! 1232: }
! 1233:
! 1234: static sdlRestrictionCharPtr sdl_deserialize_resriction_char(char **in)
! 1235: {
! 1236: if (**in == 1) {
! 1237: sdlRestrictionCharPtr x = emalloc(sizeof(sdlRestrictionChar));
! 1238: WSDL_CACHE_SKIP(1, in);
! 1239: x->value = sdl_deserialize_string(in);
! 1240: WSDL_CACHE_GET_1(x->fixed, char, in);
! 1241: return x;
! 1242: } else {
! 1243: WSDL_CACHE_SKIP(1, in);
! 1244: return NULL;
! 1245: }
! 1246: }
! 1247:
! 1248: static sdlContentModelPtr sdl_deserialize_model(sdlTypePtr *types, sdlTypePtr *elements, char **in)
! 1249: {
! 1250: int i;
! 1251: sdlContentModelPtr model = emalloc(sizeof(sdlContentModel));
! 1252:
! 1253: WSDL_CACHE_GET_1(model->kind, sdlContentKind, in);
! 1254: WSDL_CACHE_GET_INT(model->min_occurs, in);
! 1255: WSDL_CACHE_GET_INT(model->max_occurs, in);
! 1256: switch (model->kind) {
! 1257: case XSD_CONTENT_ELEMENT:
! 1258: WSDL_CACHE_GET_INT(i, in);
! 1259: model->u.element = elements[i];
! 1260: break;
! 1261: case XSD_CONTENT_SEQUENCE:
! 1262: case XSD_CONTENT_ALL:
! 1263: case XSD_CONTENT_CHOICE:
! 1264: WSDL_CACHE_GET_INT(i, in);
! 1265: model->u.content = emalloc(sizeof(HashTable));
! 1266: zend_hash_init(model->u.content, i, NULL, delete_model, 0);
! 1267: while (i > 0) {
! 1268: sdlContentModelPtr x = sdl_deserialize_model(types, elements, in);
! 1269: zend_hash_next_index_insert(model->u.content,&x,sizeof(sdlContentModelPtr),NULL);
! 1270: i--;
! 1271: }
! 1272: break;
! 1273: case XSD_CONTENT_GROUP_REF:
! 1274: model->u.group_ref = sdl_deserialize_string(in);
! 1275: break;
! 1276: case XSD_CONTENT_GROUP:
! 1277: WSDL_CACHE_GET_INT(i, in);
! 1278: model->u.group = types[i];
! 1279: break;
! 1280: default:
! 1281: break;
! 1282: }
! 1283: return model;
! 1284: }
! 1285:
! 1286: static void sdl_deserialize_type(sdlTypePtr type, sdlTypePtr *types, encodePtr *encoders, char **in)
! 1287: {
! 1288: int i;
! 1289: sdlTypePtr *elements = NULL;
! 1290:
! 1291: WSDL_CACHE_GET_1(type->kind, sdlTypeKind, in);
! 1292: type->name = sdl_deserialize_string(in);
! 1293: type->namens = sdl_deserialize_string(in);
! 1294: type->def = sdl_deserialize_string(in);
! 1295: type->fixed = sdl_deserialize_string(in);
! 1296: type->ref = sdl_deserialize_string(in);
! 1297: WSDL_CACHE_GET_1(type->nillable, char, in);
! 1298: WSDL_CACHE_GET_1(type->form, sdlForm, in);
! 1299:
! 1300: WSDL_CACHE_GET_INT(i, in);
! 1301: type->encode = encoders[i];
! 1302:
! 1303: if (**in == 1) {
! 1304: WSDL_CACHE_SKIP(1, in);
! 1305: type->restrictions = emalloc(sizeof(sdlRestrictions));
! 1306: /*memset(type->restrictions, 0, sizeof(sdlRestrictions));*/
! 1307: type->restrictions->minExclusive = sdl_deserialize_resriction_int(in);
! 1308: type->restrictions->minInclusive = sdl_deserialize_resriction_int(in);
! 1309: type->restrictions->maxExclusive = sdl_deserialize_resriction_int(in);
! 1310: type->restrictions->maxInclusive = sdl_deserialize_resriction_int(in);
! 1311: type->restrictions->totalDigits = sdl_deserialize_resriction_int(in);
! 1312: type->restrictions->fractionDigits = sdl_deserialize_resriction_int(in);
! 1313: type->restrictions->length = sdl_deserialize_resriction_int(in);
! 1314: type->restrictions->minLength = sdl_deserialize_resriction_int(in);
! 1315: type->restrictions->maxLength = sdl_deserialize_resriction_int(in);
! 1316: type->restrictions->whiteSpace = sdl_deserialize_resriction_char(in);
! 1317: type->restrictions->pattern = sdl_deserialize_resriction_char(in);
! 1318: WSDL_CACHE_GET_INT(i, in);
! 1319: if (i > 0) {
! 1320: type->restrictions->enumeration = emalloc(sizeof(HashTable));
! 1321: zend_hash_init(type->restrictions->enumeration, i, NULL, delete_restriction_var_char, 0);
! 1322: while (i > 0) {
! 1323: sdlRestrictionCharPtr x = sdl_deserialize_resriction_char(in);
! 1324: sdl_deserialize_key(type->restrictions->enumeration, x, in);
! 1325: --i;
! 1326: }
! 1327: } else {
! 1328: type->restrictions->enumeration = NULL;
! 1329: }
! 1330: } else {
! 1331: WSDL_CACHE_SKIP(1, in);
! 1332: }
! 1333:
! 1334: WSDL_CACHE_GET_INT(i, in);
! 1335: if (i > 0) {
! 1336: elements = safe_emalloc((i+1), sizeof(sdlTypePtr), 0);
! 1337: elements[0] = NULL;
! 1338: type->elements = emalloc(sizeof(HashTable));
! 1339: zend_hash_init(type->elements, i, NULL, delete_type, 0);
! 1340: while (i > 0) {
! 1341: sdlTypePtr t = emalloc(sizeof(sdlType));
! 1342: memset(t, 0, sizeof(sdlType));
! 1343: sdl_deserialize_key(type->elements, t, in);
! 1344: sdl_deserialize_type(t, types, encoders, in);
! 1345: elements[i] = t;
! 1346: --i;
! 1347: }
! 1348: }
! 1349:
! 1350: WSDL_CACHE_GET_INT(i, in);
! 1351: if (i > 0) {
! 1352: type->attributes = emalloc(sizeof(HashTable));
! 1353: zend_hash_init(type->attributes, i, NULL, delete_attribute, 0);
! 1354: while (i > 0) {
! 1355: sdlAttributePtr attr = emalloc(sizeof(sdlAttribute));
! 1356: memset(attr, 0, sizeof(sdlAttribute));
! 1357: sdl_deserialize_key(type->attributes, attr, in);
! 1358: sdl_deserialize_attribute(attr, encoders, in);
! 1359: --i;
! 1360: }
! 1361: }
! 1362:
! 1363: if (**in != 0) {
! 1364: WSDL_CACHE_SKIP(1, in);
! 1365: type->model = sdl_deserialize_model(types, elements, in);
! 1366: } else {
! 1367: WSDL_CACHE_SKIP(1, in);
! 1368: }
! 1369: if (elements != NULL) {
! 1370: efree(elements);
! 1371: }
! 1372: }
! 1373:
! 1374: static void sdl_deserialize_encoder(encodePtr enc, sdlTypePtr *types, char **in)
! 1375: {
! 1376: int i;
! 1377:
! 1378: WSDL_CACHE_GET_INT(enc->details.type, in);
! 1379: enc->details.type_str = sdl_deserialize_string(in);
! 1380: enc->details.ns = sdl_deserialize_string(in);
! 1381: WSDL_CACHE_GET_INT(i, in);
! 1382: enc->details.sdl_type = types[i];
! 1383: enc->to_xml = sdl_guess_convert_xml;
! 1384: enc->to_zval = sdl_guess_convert_zval;
! 1385:
! 1386: if (enc->details.sdl_type == NULL) {
! 1387: int ns_len = strlen(enc->details.ns);
! 1388: int type_len = strlen(enc->details.type_str);
! 1389:
! 1390: if (((ns_len == sizeof(SOAP_1_1_ENC_NAMESPACE)-1 &&
! 1391: memcmp(enc->details.ns, SOAP_1_1_ENC_NAMESPACE, sizeof(SOAP_1_1_ENC_NAMESPACE)-1) == 0) ||
! 1392: (ns_len == sizeof(SOAP_1_2_ENC_NAMESPACE)-1 &&
! 1393: memcmp(enc->details.ns, SOAP_1_2_ENC_NAMESPACE, sizeof(SOAP_1_2_ENC_NAMESPACE)-1) == 0))) {
! 1394: char *enc_nscat;
! 1395: int enc_ns_len;
! 1396: int enc_len;
! 1397: encodePtr real_enc;
! 1398:
! 1399: enc_ns_len = sizeof(XSD_NAMESPACE)-1;
! 1400: enc_len = enc_ns_len + type_len + 1;
! 1401: enc_nscat = emalloc(enc_len + 1);
! 1402: memcpy(enc_nscat, XSD_NAMESPACE, sizeof(XSD_NAMESPACE)-1);
! 1403: enc_nscat[enc_ns_len] = ':';
! 1404: memcpy(enc_nscat+enc_ns_len+1, enc->details.type_str, type_len);
! 1405: enc_nscat[enc_len] = '\0';
! 1406:
! 1407: real_enc = get_encoder_ex(NULL, enc_nscat, enc_len);
! 1408: efree(enc_nscat);
! 1409: if (real_enc) {
! 1410: enc->to_zval = real_enc->to_zval;
! 1411: enc->to_xml = real_enc->to_xml;
! 1412: }
! 1413: }
! 1414: }
! 1415: }
! 1416:
! 1417: static void sdl_deserialize_soap_body(sdlSoapBindingFunctionBodyPtr body, encodePtr *encoders, sdlTypePtr *types, char **in)
! 1418: {
! 1419: int i, j, n;
! 1420:
! 1421: WSDL_CACHE_GET_1(body->use, sdlEncodingUse, in);
! 1422: if (body->use == SOAP_ENCODED) {
! 1423: WSDL_CACHE_GET_1(body->encodingStyle, sdlRpcEncodingStyle, in);
! 1424: } else {
! 1425: body->encodingStyle = SOAP_ENCODING_DEFAULT;
! 1426: }
! 1427: body->ns = sdl_deserialize_string(in);
! 1428: WSDL_CACHE_GET_INT(i, in);
! 1429: if (i > 0) {
! 1430: body->headers = emalloc(sizeof(HashTable));
! 1431: zend_hash_init(body->headers, i, NULL, delete_header, 0);
! 1432: while (i > 0) {
! 1433: sdlSoapBindingFunctionHeaderPtr tmp = emalloc(sizeof(sdlSoapBindingFunctionHeader));
! 1434: memset(tmp, 0, sizeof(sdlSoapBindingFunctionHeader));
! 1435: sdl_deserialize_key(body->headers, tmp, in);
! 1436: WSDL_CACHE_GET_1(tmp->use, sdlEncodingUse, in);
! 1437: if (tmp->use == SOAP_ENCODED) {
! 1438: WSDL_CACHE_GET_1(tmp->encodingStyle, sdlRpcEncodingStyle, in);
! 1439: } else {
! 1440: tmp->encodingStyle = SOAP_ENCODING_DEFAULT;
! 1441: }
! 1442: tmp->name = sdl_deserialize_string(in);
! 1443: tmp->ns = sdl_deserialize_string(in);
! 1444: WSDL_CACHE_GET_INT(n, in);
! 1445: tmp->encode = encoders[n];
! 1446: WSDL_CACHE_GET_INT(n, in);
! 1447: tmp->element = types[n];
! 1448: --i;
! 1449: WSDL_CACHE_GET_INT(j, in);
! 1450: if (j > 0) {
! 1451: tmp->headerfaults = emalloc(sizeof(HashTable));
! 1452: zend_hash_init(tmp->headerfaults, i, NULL, delete_header, 0);
! 1453: while (j > 0) {
! 1454: sdlSoapBindingFunctionHeaderPtr tmp2 = emalloc(sizeof(sdlSoapBindingFunctionHeader));
! 1455: memset(tmp2, 0, sizeof(sdlSoapBindingFunctionHeader));
! 1456: sdl_deserialize_key(tmp->headerfaults, tmp2, in);
! 1457: WSDL_CACHE_GET_1(tmp2->use, sdlEncodingUse, in);
! 1458: if (tmp2->use == SOAP_ENCODED) {
! 1459: WSDL_CACHE_GET_1(tmp2->encodingStyle, sdlRpcEncodingStyle, in);
! 1460: } else {
! 1461: tmp2->encodingStyle = SOAP_ENCODING_DEFAULT;
! 1462: }
! 1463: tmp2->name = sdl_deserialize_string(in);
! 1464: tmp2->ns = sdl_deserialize_string(in);
! 1465: WSDL_CACHE_GET_INT(n, in);
! 1466: tmp2->encode = encoders[n];
! 1467: WSDL_CACHE_GET_INT(n, in);
! 1468: tmp2->element = types[n];
! 1469: --j;
! 1470: }
! 1471: }
! 1472: }
! 1473: }
! 1474: }
! 1475:
! 1476: static HashTable* sdl_deserialize_parameters(encodePtr *encoders, sdlTypePtr *types, char **in)
! 1477: {
! 1478: int i, n;
! 1479: HashTable *ht;
! 1480:
! 1481: WSDL_CACHE_GET_INT(i, in);
! 1482: if (i == 0) {return NULL;}
! 1483: ht = emalloc(sizeof(HashTable));
! 1484: zend_hash_init(ht, i, NULL, delete_parameter, 0);
! 1485: while (i > 0) {
! 1486: sdlParamPtr param = emalloc(sizeof(sdlParam));
! 1487: sdl_deserialize_key(ht, param, in);
! 1488: param->paramName = sdl_deserialize_string(in);
! 1489: WSDL_CACHE_GET_INT(param->order, in);
! 1490: WSDL_CACHE_GET_INT(n, in);
! 1491: param->encode = encoders[n];
! 1492: WSDL_CACHE_GET_INT(n, in);
! 1493: param->element = types[n];
! 1494: --i;
! 1495: }
! 1496: return ht;
! 1497: }
! 1498:
! 1499: static sdlPtr get_sdl_from_cache(const char *fn, const char *uri, time_t t, time_t *cached TSRMLS_DC)
! 1500: {
! 1501: sdlPtr sdl;
! 1502: time_t old_t;
! 1503: int i, num_groups, num_types, num_elements, num_encoders, num_bindings, num_func;
! 1504: sdlFunctionPtr *functions = NULL;
! 1505: sdlBindingPtr *bindings;
! 1506: sdlTypePtr *types;
! 1507: encodePtr *encoders;
! 1508: encodePtr enc;
! 1509:
! 1510: int f;
! 1511: struct stat st;
! 1512: char *in, *buf;
! 1513:
! 1514: f = open(fn, O_RDONLY|O_BINARY);
! 1515: if (f < 0) {
! 1516: return NULL;
! 1517: }
! 1518: if (fstat(f, &st) != 0) {
! 1519: close(f);
! 1520: return NULL;
! 1521: }
! 1522: buf = in = emalloc(st.st_size);
! 1523: if (read(f, in, st.st_size) != st.st_size) {
! 1524: close(f);
! 1525: efree(in);
! 1526: return NULL;
! 1527: }
! 1528: close(f);
! 1529:
! 1530: if (strncmp(in,"wsdl",4) != 0 || in[4] != WSDL_CACHE_VERSION || in[5] != '\0') {
! 1531: unlink(fn);
! 1532: efree(buf);
! 1533: return NULL;
! 1534: }
! 1535: in += 6;
! 1536:
! 1537: WSDL_CACHE_GET(old_t, time_t, &in);
! 1538: if (old_t < t) {
! 1539: unlink(fn);
! 1540: efree(buf);
! 1541: return NULL;
! 1542: }
! 1543: *cached = old_t;
! 1544:
! 1545: WSDL_CACHE_GET_INT(i, &in);
! 1546: if (i == 0 && strncmp(in, uri, i) != 0) {
! 1547: unlink(fn);
! 1548: efree(buf);
! 1549: return NULL;
! 1550: }
! 1551: WSDL_CACHE_SKIP(i, &in);
! 1552:
! 1553: sdl = emalloc(sizeof(*sdl));
! 1554: memset(sdl, 0, sizeof(*sdl));
! 1555:
! 1556: sdl->source = sdl_deserialize_string(&in);
! 1557: sdl->target_ns = sdl_deserialize_string(&in);
! 1558:
! 1559: WSDL_CACHE_GET_INT(num_groups, &in);
! 1560: WSDL_CACHE_GET_INT(num_types, &in);
! 1561: WSDL_CACHE_GET_INT(num_elements, &in);
! 1562: WSDL_CACHE_GET_INT(num_encoders, &in);
! 1563:
! 1564: i = num_groups+num_types+num_elements;
! 1565: types = safe_emalloc((i+1), sizeof(sdlTypePtr), 0);
! 1566: types[0] = NULL;
! 1567: while (i > 0) {
! 1568: types[i] = emalloc(sizeof(sdlType));
! 1569: memset(types[i], 0, sizeof(sdlType));
! 1570: i--;
! 1571: }
! 1572:
! 1573: i = num_encoders;
! 1574: enc = defaultEncoding;
! 1575: while (enc->details.type != END_KNOWN_TYPES) {
! 1576: i++; enc++;
! 1577: }
! 1578: encoders = safe_emalloc((i+1), sizeof(encodePtr), 0);
! 1579: i = num_encoders;
! 1580: encoders[0] = NULL;
! 1581: while (i > 0) {
! 1582: encoders[i] = emalloc(sizeof(encode));
! 1583: memset(encoders[i], 0, sizeof(encode));
! 1584: i--;
! 1585: }
! 1586: i = num_encoders;
! 1587: enc = defaultEncoding;
! 1588: while (enc->details.type != END_KNOWN_TYPES) {
! 1589: encoders[++i] = enc++;
! 1590: }
! 1591:
! 1592: i = 1;
! 1593: if (num_groups > 0) {
! 1594: sdl->groups = emalloc(sizeof(HashTable));
! 1595: zend_hash_init(sdl->groups, num_groups, NULL, delete_type, 0);
! 1596: while (i < num_groups+1) {
! 1597: sdl_deserialize_key(sdl->groups, types[i], &in);
! 1598: sdl_deserialize_type(types[i], types, encoders, &in);
! 1599: i++;
! 1600: }
! 1601: }
! 1602:
! 1603: if (num_types > 0) {
! 1604: sdl->types = emalloc(sizeof(HashTable));
! 1605: zend_hash_init(sdl->types, num_types, NULL, delete_type, 0);
! 1606: while (i < num_groups+num_types+1) {
! 1607: sdl_deserialize_key(sdl->types, types[i], &in);
! 1608: sdl_deserialize_type(types[i], types, encoders, &in);
! 1609: i++;
! 1610: }
! 1611: }
! 1612:
! 1613: if (num_elements > 0) {
! 1614: sdl->elements = emalloc(sizeof(HashTable));
! 1615: zend_hash_init(sdl->elements, num_elements, NULL, delete_type, 0);
! 1616: while (i < num_groups+num_types+num_elements+1) {
! 1617: sdl_deserialize_key(sdl->elements, types[i], &in);
! 1618: sdl_deserialize_type(types[i], types, encoders, &in);
! 1619: i++;
! 1620: }
! 1621: }
! 1622:
! 1623: i = 1;
! 1624: if (num_encoders > 0) {
! 1625: sdl->encoders = emalloc(sizeof(HashTable));
! 1626: zend_hash_init(sdl->encoders, num_encoders, NULL, delete_encoder, 0);
! 1627: while (i < num_encoders+1) {
! 1628: sdl_deserialize_key(sdl->encoders, encoders[i], &in);
! 1629: sdl_deserialize_encoder(encoders[i], types, &in);
! 1630: i++;
! 1631: }
! 1632: }
! 1633:
! 1634: /* deserialize bindings */
! 1635: WSDL_CACHE_GET_INT(num_bindings, &in);
! 1636: bindings = safe_emalloc(num_bindings, sizeof(sdlBindingPtr), 0);
! 1637: if (num_bindings > 0) {
! 1638: sdl->bindings = emalloc(sizeof(HashTable));
! 1639: zend_hash_init(sdl->bindings, num_bindings, NULL, delete_binding, 0);
! 1640: for (i = 0; i < num_bindings; i++) {
! 1641: sdlBindingPtr binding = emalloc(sizeof(sdlBinding));
! 1642: memset(binding, 0, sizeof(sdlBinding));
! 1643: sdl_deserialize_key(sdl->bindings, binding, &in);
! 1644: binding->name = sdl_deserialize_string(&in);
! 1645: binding->location = sdl_deserialize_string(&in);
! 1646: WSDL_CACHE_GET_1(binding->bindingType,sdlBindingType,&in);
! 1647: if (binding->bindingType == BINDING_SOAP && *in != 0) {
! 1648: sdlSoapBindingPtr soap_binding = binding->bindingAttributes = emalloc(sizeof(sdlSoapBinding));
! 1649: WSDL_CACHE_GET_1(soap_binding->style,sdlEncodingStyle,&in);
! 1650: WSDL_CACHE_GET_1(soap_binding->transport,sdlTransport,&in);
! 1651: } else {
! 1652: WSDL_CACHE_SKIP(1,&in);
! 1653: }
! 1654: bindings[i] = binding;
! 1655: }
! 1656: }
! 1657:
! 1658: /* deserialize functions */
! 1659: WSDL_CACHE_GET_INT(num_func, &in);
! 1660: zend_hash_init(&sdl->functions, num_func, NULL, delete_function, 0);
! 1661: if (num_func > 0) {
! 1662: functions = safe_emalloc(num_func, sizeof(sdlFunctionPtr), 0);
! 1663: for (i = 0; i < num_func; i++) {
! 1664: int binding_num, num_faults;
! 1665: sdlFunctionPtr func = emalloc(sizeof(sdlFunction));
! 1666: sdl_deserialize_key(&sdl->functions, func, &in);
! 1667: func->functionName = sdl_deserialize_string(&in);
! 1668: func->requestName = sdl_deserialize_string(&in);
! 1669: func->responseName = sdl_deserialize_string(&in);
! 1670:
! 1671: WSDL_CACHE_GET_INT(binding_num, &in);
! 1672: if (binding_num == 0) {
! 1673: func->binding = NULL;
! 1674: } else {
! 1675: func->binding = bindings[binding_num-1];
! 1676: }
! 1677: if (func->binding && func->binding->bindingType == BINDING_SOAP && *in != 0) {
! 1678: sdlSoapBindingFunctionPtr binding = func->bindingAttributes = emalloc(sizeof(sdlSoapBindingFunction));
! 1679: memset(binding, 0, sizeof(sdlSoapBindingFunction));
! 1680: WSDL_CACHE_GET_1(binding->style,sdlEncodingStyle,&in);
! 1681: binding->soapAction = sdl_deserialize_string(&in);
! 1682: sdl_deserialize_soap_body(&binding->input, encoders, types, &in);
! 1683: sdl_deserialize_soap_body(&binding->output, encoders, types, &in);
! 1684: } else {
! 1685: WSDL_CACHE_SKIP(1, &in);
! 1686: func->bindingAttributes = NULL;
! 1687: }
! 1688:
! 1689: func->requestParameters = sdl_deserialize_parameters(encoders, types, &in);
! 1690: func->responseParameters = sdl_deserialize_parameters(encoders, types, &in);
! 1691:
! 1692: WSDL_CACHE_GET_INT(num_faults, &in);
! 1693: if (num_faults > 0) {
! 1694: int j;
! 1695:
! 1696: func->faults = emalloc(sizeof(HashTable));
! 1697: zend_hash_init(func->faults, num_faults, NULL, delete_fault, 0);
! 1698:
! 1699: for (j = 0; j < num_faults; j++) {
! 1700: sdlFaultPtr fault = emalloc(sizeof(sdlFault));
! 1701:
! 1702: sdl_deserialize_key(func->faults, fault, &in);
! 1703: fault->name =sdl_deserialize_string(&in);
! 1704: fault->details =sdl_deserialize_parameters(encoders, types, &in);
! 1705: if (*in != 0) {
! 1706: sdlSoapBindingFunctionFaultPtr binding = fault->bindingAttributes = emalloc(sizeof(sdlSoapBindingFunctionFault));
! 1707: memset(binding, 0, sizeof(sdlSoapBindingFunctionFault));
! 1708: WSDL_CACHE_GET_1(binding->use,sdlEncodingUse,&in);
! 1709: if (binding->use == SOAP_ENCODED) {
! 1710: WSDL_CACHE_GET_1(binding->encodingStyle, sdlRpcEncodingStyle, &in);
! 1711: } else {
! 1712: binding->encodingStyle = SOAP_ENCODING_DEFAULT;
! 1713: }
! 1714: binding->ns = sdl_deserialize_string(&in);
! 1715: } else {
! 1716: WSDL_CACHE_SKIP(1, &in);
! 1717: fault->bindingAttributes = NULL;
! 1718: }
! 1719: }
! 1720: } else {
! 1721: func->faults = NULL;
! 1722: }
! 1723: functions[i] = func;
! 1724: }
! 1725: }
! 1726:
! 1727: /* deserialize requests */
! 1728: WSDL_CACHE_GET_INT(i, &in);
! 1729: if (i > 0) {
! 1730: sdl->requests = emalloc(sizeof(HashTable));
! 1731: zend_hash_init(sdl->requests, i, NULL, NULL, 0);
! 1732: while (i > 0) {
! 1733: int function_num;
! 1734:
! 1735: WSDL_CACHE_GET_INT(function_num, &in);
! 1736: sdl_deserialize_key(sdl->requests, functions[function_num-1], &in);
! 1737: i--;
! 1738: }
! 1739: }
! 1740:
! 1741: if (functions) {
! 1742: efree(functions);
! 1743: }
! 1744: efree(bindings);
! 1745: efree(encoders);
! 1746: efree(types);
! 1747: efree(buf);
! 1748: return sdl;
! 1749: }
! 1750:
! 1751: static void sdl_serialize_string(const char *str, smart_str *out)
! 1752: {
! 1753: int i;
! 1754:
! 1755: if (str) {
! 1756: i = strlen(str);
! 1757: WSDL_CACHE_PUT_INT(i, out);
! 1758: if (i > 0) {
! 1759: WSDL_CACHE_PUT_N(str, i, out);
! 1760: }
! 1761: } else {
! 1762: WSDL_CACHE_PUT_INT(0x7fffffff, out);
! 1763: }
! 1764: }
! 1765:
! 1766: static void sdl_serialize_key(HashTable *ht, smart_str *out)
! 1767: {
! 1768: char *key;
! 1769: uint key_len;
! 1770: ulong index;
! 1771:
! 1772: if (zend_hash_get_current_key_ex(ht, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
! 1773: WSDL_CACHE_PUT_INT(key_len, out);
! 1774: WSDL_CACHE_PUT_N(key, key_len, out);
! 1775: } else {
! 1776: WSDL_CACHE_PUT_INT(0, out);
! 1777: }
! 1778: }
! 1779:
! 1780: static void sdl_serialize_encoder_ref(encodePtr enc, HashTable *tmp_encoders, smart_str *out) {
! 1781: if (enc) {
! 1782: int *encoder_num;
! 1783: if (zend_hash_find(tmp_encoders, (char*)&enc, sizeof(enc), (void**)&encoder_num) == SUCCESS) {
! 1784: WSDL_CACHE_PUT_INT(*encoder_num, out);
! 1785: } else {
! 1786: WSDL_CACHE_PUT_INT(0, out);
! 1787: }
! 1788: } else {
! 1789: WSDL_CACHE_PUT_INT(0, out);
! 1790: }
! 1791: }
! 1792:
! 1793: static void sdl_serialize_type_ref(sdlTypePtr type, HashTable *tmp_types, smart_str *out) {
! 1794: if (type) {
! 1795: int *type_num;
! 1796: if (zend_hash_find(tmp_types, (char*)&type, sizeof(type), (void**)&type_num) == SUCCESS) {
! 1797: WSDL_CACHE_PUT_INT(*type_num, out);
! 1798: } else {
! 1799: WSDL_CACHE_PUT_INT(0, out);
! 1800: }
! 1801: } else {
! 1802: WSDL_CACHE_PUT_INT(0,out);
! 1803: }
! 1804: }
! 1805:
! 1806: static void sdl_serialize_attribute(sdlAttributePtr attr, HashTable *tmp_encoders, smart_str *out)
! 1807: {
! 1808: int i;
! 1809:
! 1810: sdl_serialize_string(attr->name, out);
! 1811: sdl_serialize_string(attr->namens, out);
! 1812: sdl_serialize_string(attr->ref, out);
! 1813: sdl_serialize_string(attr->def, out);
! 1814: sdl_serialize_string(attr->fixed, out);
! 1815: WSDL_CACHE_PUT_1(attr->form, out);
! 1816: WSDL_CACHE_PUT_1(attr->use, out);
! 1817: sdl_serialize_encoder_ref(attr->encode, tmp_encoders, out);
! 1818: if (attr->extraAttributes) {
! 1819: i = zend_hash_num_elements(attr->extraAttributes);
! 1820: } else {
! 1821: i = 0;
! 1822: }
! 1823: WSDL_CACHE_PUT_INT(i, out);
! 1824: if (i > 0) {
! 1825: sdlExtraAttributePtr *tmp;
! 1826: zend_hash_internal_pointer_reset(attr->extraAttributes);
! 1827: while (zend_hash_get_current_data(attr->extraAttributes, (void**)&tmp) == SUCCESS) {
! 1828: sdl_serialize_key(attr->extraAttributes, out);
! 1829: sdl_serialize_string((*tmp)->ns, out);
! 1830: sdl_serialize_string((*tmp)->val, out);
! 1831: zend_hash_move_forward(attr->extraAttributes);
! 1832: }
! 1833: }
! 1834: }
! 1835:
! 1836: static void sdl_serialize_model(sdlContentModelPtr model, HashTable *tmp_types, HashTable *tmp_elements, smart_str *out)
! 1837: {
! 1838: WSDL_CACHE_PUT_1(model->kind, out);
! 1839: WSDL_CACHE_PUT_INT(model->min_occurs, out);
! 1840: WSDL_CACHE_PUT_INT(model->max_occurs, out);
! 1841: switch (model->kind) {
! 1842: case XSD_CONTENT_ELEMENT:
! 1843: sdl_serialize_type_ref(model->u.element, tmp_elements, out);
! 1844: break;
! 1845: case XSD_CONTENT_SEQUENCE:
! 1846: case XSD_CONTENT_ALL:
! 1847: case XSD_CONTENT_CHOICE: {
! 1848: sdlContentModelPtr *tmp;
! 1849: int i = zend_hash_num_elements(model->u.content);
! 1850:
! 1851: WSDL_CACHE_PUT_INT(i, out);
! 1852: zend_hash_internal_pointer_reset(model->u.content);
! 1853: while (zend_hash_get_current_data(model->u.content, (void**)&tmp) == SUCCESS) {
! 1854: sdl_serialize_model(*tmp, tmp_types, tmp_elements, out);
! 1855: zend_hash_move_forward(model->u.content);
! 1856: }
! 1857: }
! 1858: break;
! 1859: case XSD_CONTENT_GROUP_REF:
! 1860: sdl_serialize_string(model->u.group_ref,out);
! 1861: break;
! 1862: case XSD_CONTENT_GROUP:
! 1863: sdl_serialize_type_ref(model->u.group, tmp_types, out);
! 1864: break;
! 1865: default:
! 1866: break;
! 1867: }
! 1868: }
! 1869:
! 1870: static void sdl_serialize_resriction_int(sdlRestrictionIntPtr x, smart_str *out)
! 1871: {
! 1872: if (x) {
! 1873: WSDL_CACHE_PUT_1(1, out);
! 1874: WSDL_CACHE_PUT_INT(x->value, out);
! 1875: WSDL_CACHE_PUT_1(x->fixed, out);
! 1876: } else {
! 1877: WSDL_CACHE_PUT_1(0, out);
! 1878: }
! 1879: }
! 1880:
! 1881: static void sdl_serialize_resriction_char(sdlRestrictionCharPtr x, smart_str *out)
! 1882: {
! 1883: if (x) {
! 1884: WSDL_CACHE_PUT_1(1, out);
! 1885: sdl_serialize_string(x->value, out);
! 1886: WSDL_CACHE_PUT_1(x->fixed, out);
! 1887: } else {
! 1888: WSDL_CACHE_PUT_1(0, out);
! 1889: }
! 1890: }
! 1891:
! 1892: static void sdl_serialize_type(sdlTypePtr type, HashTable *tmp_encoders, HashTable *tmp_types, smart_str *out)
! 1893: {
! 1894: int i;
! 1895: HashTable *tmp_elements = NULL;
! 1896:
! 1897: WSDL_CACHE_PUT_1(type->kind, out);
! 1898: sdl_serialize_string(type->name, out);
! 1899: sdl_serialize_string(type->namens, out);
! 1900: sdl_serialize_string(type->def, out);
! 1901: sdl_serialize_string(type->fixed, out);
! 1902: sdl_serialize_string(type->ref, out);
! 1903: WSDL_CACHE_PUT_1(type->nillable, out);
! 1904: WSDL_CACHE_PUT_1(type->form, out);
! 1905: sdl_serialize_encoder_ref(type->encode, tmp_encoders, out);
! 1906:
! 1907: if (type->restrictions) {
! 1908: WSDL_CACHE_PUT_1(1, out);
! 1909: sdl_serialize_resriction_int(type->restrictions->minExclusive,out);
! 1910: sdl_serialize_resriction_int(type->restrictions->minInclusive,out);
! 1911: sdl_serialize_resriction_int(type->restrictions->maxExclusive,out);
! 1912: sdl_serialize_resriction_int(type->restrictions->maxInclusive,out);
! 1913: sdl_serialize_resriction_int(type->restrictions->totalDigits,out);
! 1914: sdl_serialize_resriction_int(type->restrictions->fractionDigits,out);
! 1915: sdl_serialize_resriction_int(type->restrictions->length,out);
! 1916: sdl_serialize_resriction_int(type->restrictions->minLength,out);
! 1917: sdl_serialize_resriction_int(type->restrictions->maxLength,out);
! 1918: sdl_serialize_resriction_char(type->restrictions->whiteSpace,out);
! 1919: sdl_serialize_resriction_char(type->restrictions->pattern,out);
! 1920: if (type->restrictions->enumeration) {
! 1921: i = zend_hash_num_elements(type->restrictions->enumeration);
! 1922: } else {
! 1923: i = 0;
! 1924: }
! 1925: WSDL_CACHE_PUT_INT(i, out);
! 1926: if (i > 0) {
! 1927: sdlRestrictionCharPtr *tmp;
! 1928:
! 1929: zend_hash_internal_pointer_reset(type->restrictions->enumeration);
! 1930: while (zend_hash_get_current_data(type->restrictions->enumeration, (void**)&tmp) == SUCCESS) {
! 1931: sdl_serialize_resriction_char(*tmp, out);
! 1932: sdl_serialize_key(type->restrictions->enumeration, out);
! 1933: zend_hash_move_forward(type->restrictions->enumeration);
! 1934: }
! 1935: }
! 1936: } else {
! 1937: WSDL_CACHE_PUT_1(0, out);
! 1938: }
! 1939: if (type->elements) {
! 1940: i = zend_hash_num_elements(type->elements);
! 1941: } else {
! 1942: i = 0;
! 1943: }
! 1944: WSDL_CACHE_PUT_INT(i, out);
! 1945: if (i > 0) {
! 1946: sdlTypePtr *tmp;
! 1947:
! 1948: tmp_elements = emalloc(sizeof(HashTable));
! 1949: zend_hash_init(tmp_elements, i, NULL, NULL, 0);
! 1950:
! 1951: zend_hash_internal_pointer_reset(type->elements);
! 1952: while (zend_hash_get_current_data(type->elements, (void**)&tmp) == SUCCESS) {
! 1953: sdl_serialize_key(type->elements, out);
! 1954: sdl_serialize_type(*tmp, tmp_encoders, tmp_types, out);
! 1955: zend_hash_add(tmp_elements, (char*)tmp, sizeof(*tmp), &i, sizeof(int), NULL);
! 1956: i--;
! 1957: zend_hash_move_forward(type->elements);
! 1958: }
! 1959: }
! 1960:
! 1961: if (type->attributes) {
! 1962: i = zend_hash_num_elements(type->attributes);
! 1963: } else {
! 1964: i = 0;
! 1965: }
! 1966: WSDL_CACHE_PUT_INT(i, out);
! 1967: if (i > 0) {
! 1968: sdlAttributePtr *tmp;
! 1969: zend_hash_internal_pointer_reset(type->attributes);
! 1970: while (zend_hash_get_current_data(type->attributes, (void**)&tmp) == SUCCESS) {
! 1971: sdl_serialize_key(type->attributes, out);
! 1972: sdl_serialize_attribute(*tmp, tmp_encoders, out);
! 1973: zend_hash_move_forward(type->attributes);
! 1974: }
! 1975: }
! 1976: if (type->model) {
! 1977: WSDL_CACHE_PUT_1(1, out);
! 1978: sdl_serialize_model(type->model, tmp_types, tmp_elements, out);
! 1979: } else {
! 1980: WSDL_CACHE_PUT_1(0, out);
! 1981: }
! 1982: if (tmp_elements != NULL) {
! 1983: zend_hash_destroy(tmp_elements);
! 1984: efree(tmp_elements);
! 1985: }
! 1986: }
! 1987:
! 1988: static void sdl_serialize_encoder(encodePtr enc, HashTable *tmp_types, smart_str *out)
! 1989: {
! 1990: WSDL_CACHE_PUT_INT(enc->details.type, out);
! 1991: sdl_serialize_string(enc->details.type_str, out);
! 1992: sdl_serialize_string(enc->details.ns, out);
! 1993: sdl_serialize_type_ref(enc->details.sdl_type, tmp_types, out);
! 1994: }
! 1995:
! 1996: static void sdl_serialize_parameters(HashTable *ht, HashTable *tmp_encoders, HashTable *tmp_types, smart_str *out)
! 1997: {
! 1998: int i;
! 1999:
! 2000: if (ht) {
! 2001: i = zend_hash_num_elements(ht);
! 2002: } else {
! 2003: i = 0;
! 2004: }
! 2005: WSDL_CACHE_PUT_INT(i, out);
! 2006: if (i > 0) {
! 2007: sdlParamPtr *tmp;
! 2008:
! 2009: zend_hash_internal_pointer_reset(ht);
! 2010: while (zend_hash_get_current_data(ht, (void**)&tmp) == SUCCESS) {
! 2011: sdl_serialize_key(ht, out);
! 2012: sdl_serialize_string((*tmp)->paramName, out);
! 2013: WSDL_CACHE_PUT_INT((*tmp)->order, out);
! 2014: sdl_serialize_encoder_ref((*tmp)->encode, tmp_encoders, out);
! 2015: sdl_serialize_type_ref((*tmp)->element, tmp_types, out);
! 2016: zend_hash_move_forward(ht);
! 2017: }
! 2018: }
! 2019: }
! 2020:
! 2021: static void sdl_serialize_soap_body(sdlSoapBindingFunctionBodyPtr body, HashTable *tmp_encoders, HashTable *tmp_types, smart_str *out)
! 2022: {
! 2023: int i, j;
! 2024:
! 2025: WSDL_CACHE_PUT_1(body->use, out);
! 2026: if (body->use == SOAP_ENCODED) {
! 2027: WSDL_CACHE_PUT_1(body->encodingStyle, out);
! 2028: }
! 2029: sdl_serialize_string(body->ns, out);
! 2030: if (body->headers) {
! 2031: i = zend_hash_num_elements(body->headers);
! 2032: } else {
! 2033: i = 0;
! 2034: }
! 2035: WSDL_CACHE_PUT_INT(i, out);
! 2036: if (i > 0) {
! 2037: sdlSoapBindingFunctionHeaderPtr *tmp;
! 2038: zend_hash_internal_pointer_reset(body->headers);
! 2039: while (zend_hash_get_current_data(body->headers, (void**)&tmp) == SUCCESS) {
! 2040: sdl_serialize_key(body->headers, out);
! 2041: WSDL_CACHE_PUT_1((*tmp)->use, out);
! 2042: if ((*tmp)->use == SOAP_ENCODED) {
! 2043: WSDL_CACHE_PUT_1((*tmp)->encodingStyle, out);
! 2044: }
! 2045: sdl_serialize_string((*tmp)->name, out);
! 2046: sdl_serialize_string((*tmp)->ns, out);
! 2047: sdl_serialize_encoder_ref((*tmp)->encode, tmp_encoders, out);
! 2048: sdl_serialize_type_ref((*tmp)->element, tmp_types, out);
! 2049: if ((*tmp)->headerfaults) {
! 2050: j = zend_hash_num_elements((*tmp)->headerfaults);
! 2051: } else {
! 2052: j = 0;
! 2053: }
! 2054: WSDL_CACHE_PUT_INT(j, out);
! 2055: if (j > 0) {
! 2056: sdlSoapBindingFunctionHeaderPtr *tmp2;
! 2057: zend_hash_internal_pointer_reset((*tmp)->headerfaults);
! 2058: while (zend_hash_get_current_data((*tmp)->headerfaults, (void**)&tmp2) == SUCCESS) {
! 2059: sdl_serialize_key((*tmp)->headerfaults, out);
! 2060: WSDL_CACHE_PUT_1((*tmp2)->use, out);
! 2061: if ((*tmp2)->use == SOAP_ENCODED) {
! 2062: WSDL_CACHE_PUT_1((*tmp2)->encodingStyle, out);
! 2063: }
! 2064: sdl_serialize_string((*tmp2)->name, out);
! 2065: sdl_serialize_string((*tmp2)->ns, out);
! 2066: sdl_serialize_encoder_ref((*tmp2)->encode, tmp_encoders, out);
! 2067: sdl_serialize_type_ref((*tmp2)->element, tmp_types, out);
! 2068: zend_hash_move_forward((*tmp)->headerfaults);
! 2069: }
! 2070: }
! 2071: zend_hash_move_forward(body->headers);
! 2072: }
! 2073: }
! 2074: }
! 2075:
! 2076: static void add_sdl_to_cache(const char *fn, const char *uri, time_t t, sdlPtr sdl TSRMLS_DC)
! 2077: {
! 2078: smart_str buf = {0};
! 2079: smart_str *out = &buf;
! 2080: int i;
! 2081: int type_num = 1;
! 2082: int encoder_num = 1;
! 2083: int f;
! 2084: encodePtr enc;
! 2085: HashTable tmp_types;
! 2086: HashTable tmp_encoders;
! 2087: HashTable tmp_bindings;
! 2088: HashTable tmp_functions;
! 2089:
! 2090: #ifdef ZEND_WIN32
! 2091: f = open(fn,O_CREAT|O_WRONLY|O_EXCL|O_BINARY,S_IREAD|S_IWRITE);
! 2092: #else
! 2093: f = open(fn,O_CREAT|O_WRONLY|O_EXCL|O_BINARY,S_IREAD|S_IWRITE);
! 2094: #endif
! 2095: if (f < 0) {return;}
! 2096:
! 2097: zend_hash_init(&tmp_types, 0, NULL, NULL, 0);
! 2098: zend_hash_init(&tmp_encoders, 0, NULL, NULL, 0);
! 2099: zend_hash_init(&tmp_bindings, 0, NULL, NULL, 0);
! 2100: zend_hash_init(&tmp_functions, 0, NULL, NULL, 0);
! 2101:
! 2102: WSDL_CACHE_PUT_N("wsdl", 4, out);
! 2103: WSDL_CACHE_PUT_1(WSDL_CACHE_VERSION,out);
! 2104: WSDL_CACHE_PUT_1(0,out);
! 2105: WSDL_CACHE_PUT_N(&t, sizeof(t), out);
! 2106:
! 2107: sdl_serialize_string(uri, out);
! 2108: sdl_serialize_string(sdl->source, out);
! 2109: sdl_serialize_string(sdl->target_ns, out);
! 2110:
! 2111: if (sdl->groups) {
! 2112: i = zend_hash_num_elements(sdl->groups);
! 2113: } else {
! 2114: i = 0;
! 2115: }
! 2116: WSDL_CACHE_PUT_INT(i, out);
! 2117: if (i > 0) {
! 2118: sdlTypePtr *tmp;
! 2119:
! 2120: zend_hash_internal_pointer_reset(sdl->groups);
! 2121: while (zend_hash_get_current_data(sdl->groups, (void**)&tmp) == SUCCESS) {
! 2122: zend_hash_add(&tmp_types, (char*)tmp, sizeof(*tmp), (void**)&type_num, sizeof(type_num), NULL);
! 2123: ++type_num;
! 2124: zend_hash_move_forward(sdl->groups);
! 2125: }
! 2126: }
! 2127:
! 2128: if (sdl->types) {
! 2129: i = zend_hash_num_elements(sdl->types);
! 2130: } else {
! 2131: i = 0;
! 2132: }
! 2133: WSDL_CACHE_PUT_INT(i, out);
! 2134: if (i > 0) {
! 2135: sdlTypePtr *tmp;
! 2136:
! 2137: zend_hash_internal_pointer_reset(sdl->types);
! 2138: while (zend_hash_get_current_data(sdl->types, (void**)&tmp) == SUCCESS) {
! 2139: zend_hash_add(&tmp_types, (char*)tmp, sizeof(*tmp), (void**)&type_num, sizeof(type_num), NULL);
! 2140: ++type_num;
! 2141: zend_hash_move_forward(sdl->types);
! 2142: }
! 2143: }
! 2144:
! 2145: if (sdl->elements) {
! 2146: i = zend_hash_num_elements(sdl->elements);
! 2147: } else {
! 2148: i = 0;
! 2149: }
! 2150: WSDL_CACHE_PUT_INT(i, out);
! 2151: if (i > 0) {
! 2152: sdlTypePtr *tmp;
! 2153:
! 2154: zend_hash_internal_pointer_reset(sdl->elements);
! 2155: while (zend_hash_get_current_data(sdl->elements, (void**)&tmp) == SUCCESS) {
! 2156: zend_hash_add(&tmp_types, (char*)tmp, sizeof(*tmp), (void**)&type_num, sizeof(type_num), NULL);
! 2157: ++type_num;
! 2158: zend_hash_move_forward(sdl->elements);
! 2159: }
! 2160: }
! 2161:
! 2162: if (sdl->encoders) {
! 2163: i = zend_hash_num_elements(sdl->encoders);
! 2164: } else {
! 2165: i = 0;
! 2166: }
! 2167: WSDL_CACHE_PUT_INT(i, out);
! 2168: if (i > 0) {
! 2169: encodePtr *tmp;
! 2170:
! 2171: zend_hash_internal_pointer_reset(sdl->encoders);
! 2172: while (zend_hash_get_current_data(sdl->encoders, (void**)&tmp) == SUCCESS) {
! 2173: zend_hash_add(&tmp_encoders, (char*)tmp, sizeof(*tmp), (void**)&encoder_num, sizeof(encoder_num), NULL);
! 2174: ++encoder_num;
! 2175: zend_hash_move_forward(sdl->encoders);
! 2176: }
! 2177: }
! 2178: enc = defaultEncoding;
! 2179: while (enc->details.type != END_KNOWN_TYPES) {
! 2180: zend_hash_add(&tmp_encoders, (char*)&enc, sizeof(encodePtr), (void**)&encoder_num, sizeof(encoder_num), NULL);
! 2181: enc++;
! 2182: ++encoder_num;
! 2183: }
! 2184:
! 2185: if (sdl->groups) {
! 2186: sdlTypePtr *tmp;
! 2187: zend_hash_internal_pointer_reset(sdl->groups);
! 2188: while (zend_hash_get_current_data(sdl->groups, (void**)&tmp) == SUCCESS) {
! 2189: sdl_serialize_key(sdl->groups, out);
! 2190: sdl_serialize_type(*tmp, &tmp_encoders, &tmp_types, out);
! 2191: zend_hash_move_forward(sdl->groups);
! 2192: }
! 2193: }
! 2194:
! 2195: if (sdl->types) {
! 2196: sdlTypePtr *tmp;
! 2197: zend_hash_internal_pointer_reset(sdl->types);
! 2198: while (zend_hash_get_current_data(sdl->types, (void**)&tmp) == SUCCESS) {
! 2199: sdl_serialize_key(sdl->types, out);
! 2200: sdl_serialize_type(*tmp, &tmp_encoders, &tmp_types, out);
! 2201: zend_hash_move_forward(sdl->types);
! 2202: }
! 2203: }
! 2204:
! 2205: if (sdl->elements) {
! 2206: sdlTypePtr *tmp;
! 2207: zend_hash_internal_pointer_reset(sdl->elements);
! 2208: while (zend_hash_get_current_data(sdl->elements, (void**)&tmp) == SUCCESS) {
! 2209: sdl_serialize_key(sdl->elements, out);
! 2210: sdl_serialize_type(*tmp, &tmp_encoders, &tmp_types, out);
! 2211: zend_hash_move_forward(sdl->elements);
! 2212: }
! 2213: }
! 2214:
! 2215: if (sdl->encoders) {
! 2216: encodePtr *tmp;
! 2217: zend_hash_internal_pointer_reset(sdl->encoders);
! 2218: while (zend_hash_get_current_data(sdl->encoders, (void**)&tmp) == SUCCESS) {
! 2219: sdl_serialize_key(sdl->encoders, out);
! 2220: sdl_serialize_encoder(*tmp, &tmp_types, out);
! 2221: zend_hash_move_forward(sdl->encoders);
! 2222: }
! 2223: }
! 2224:
! 2225: /* serialize bindings */
! 2226: if (sdl->bindings) {
! 2227: i = zend_hash_num_elements(sdl->bindings);
! 2228: } else {
! 2229: i = 0;
! 2230: }
! 2231: WSDL_CACHE_PUT_INT(i, out);
! 2232: if (i > 0) {
! 2233: sdlBindingPtr *tmp;
! 2234: int binding_num = 1;
! 2235:
! 2236: zend_hash_internal_pointer_reset(sdl->bindings);
! 2237: while (zend_hash_get_current_data(sdl->bindings, (void**)&tmp) == SUCCESS) {
! 2238: sdl_serialize_key(sdl->bindings, out);
! 2239: sdl_serialize_string((*tmp)->name, out);
! 2240: sdl_serialize_string((*tmp)->location, out);
! 2241: WSDL_CACHE_PUT_1((*tmp)->bindingType,out);
! 2242: if ((*tmp)->bindingType == BINDING_SOAP && (*tmp)->bindingAttributes != NULL) {
! 2243: sdlSoapBindingPtr binding = (sdlSoapBindingPtr)(*tmp)->bindingAttributes;
! 2244: WSDL_CACHE_PUT_1(binding->style, out);
! 2245: WSDL_CACHE_PUT_1(binding->transport, out);
! 2246: } else {
! 2247: WSDL_CACHE_PUT_1(0,out);
! 2248: }
! 2249:
! 2250: zend_hash_add(&tmp_bindings, (char*)tmp, sizeof(*tmp), (void**)&binding_num, sizeof(binding_num), NULL);
! 2251: binding_num++;
! 2252: zend_hash_move_forward(sdl->bindings);
! 2253: }
! 2254: }
! 2255:
! 2256: /* serialize functions */
! 2257: i = zend_hash_num_elements(&sdl->functions);
! 2258: WSDL_CACHE_PUT_INT(i, out);
! 2259: if (i > 0) {
! 2260: sdlFunctionPtr *tmp;
! 2261: int *binding_num;
! 2262: int function_num = 1;
! 2263:
! 2264: zend_hash_internal_pointer_reset(&sdl->functions);
! 2265: while (zend_hash_get_current_data(&sdl->functions, (void**)&tmp) == SUCCESS) {
! 2266: sdl_serialize_key(&sdl->functions, out);
! 2267: sdl_serialize_string((*tmp)->functionName, out);
! 2268: sdl_serialize_string((*tmp)->requestName, out);
! 2269: sdl_serialize_string((*tmp)->responseName, out);
! 2270:
! 2271: if ((*tmp)->binding == NULL ||
! 2272: zend_hash_find(&tmp_bindings,(char*)&(*tmp)->binding,sizeof((*tmp)->binding), (void**)&binding_num) != SUCCESS) {
! 2273: }
! 2274: WSDL_CACHE_PUT_INT(*binding_num, out);
! 2275: if (*binding_num >= 0) {
! 2276: if ((*tmp)->binding->bindingType == BINDING_SOAP && (*tmp)->bindingAttributes != NULL) {
! 2277: sdlSoapBindingFunctionPtr binding = (sdlSoapBindingFunctionPtr)(*tmp)->bindingAttributes;
! 2278: WSDL_CACHE_PUT_1(binding->style, out);
! 2279: sdl_serialize_string(binding->soapAction, out);
! 2280: sdl_serialize_soap_body(&binding->input, &tmp_encoders, &tmp_types, out);
! 2281: sdl_serialize_soap_body(&binding->output, &tmp_encoders, &tmp_types, out);
! 2282: } else {
! 2283: WSDL_CACHE_PUT_1(0,out);
! 2284: }
! 2285: }
! 2286: sdl_serialize_parameters((*tmp)->requestParameters, &tmp_encoders, &tmp_types, out);
! 2287: sdl_serialize_parameters((*tmp)->responseParameters, &tmp_encoders, &tmp_types, out);
! 2288:
! 2289: if ((*tmp)->faults) {
! 2290: sdlFaultPtr *fault;
! 2291:
! 2292: WSDL_CACHE_PUT_INT(zend_hash_num_elements((*tmp)->faults), out);
! 2293:
! 2294: zend_hash_internal_pointer_reset((*tmp)->faults);
! 2295: while (zend_hash_get_current_data((*tmp)->faults, (void**)&fault) == SUCCESS) {
! 2296: sdl_serialize_key((*tmp)->faults, out);
! 2297: sdl_serialize_string((*fault)->name, out);
! 2298: sdl_serialize_parameters((*fault)->details, &tmp_encoders, &tmp_types, out);
! 2299: if ((*tmp)->binding->bindingType == BINDING_SOAP && (*fault)->bindingAttributes != NULL) {
! 2300: sdlSoapBindingFunctionFaultPtr binding = (sdlSoapBindingFunctionFaultPtr)(*fault)->bindingAttributes;
! 2301: WSDL_CACHE_PUT_1(binding->use, out);
! 2302: if (binding->use == SOAP_ENCODED) {
! 2303: WSDL_CACHE_PUT_1(binding->encodingStyle, out);
! 2304: }
! 2305: sdl_serialize_string(binding->ns, out);
! 2306: } else {
! 2307: WSDL_CACHE_PUT_1(0, out);
! 2308: }
! 2309: zend_hash_move_forward((*tmp)->faults);
! 2310: }
! 2311: } else {
! 2312: WSDL_CACHE_PUT_INT(0, out);
! 2313: }
! 2314:
! 2315: zend_hash_add(&tmp_functions, (char*)tmp, sizeof(*tmp), (void**)&function_num, sizeof(function_num), NULL);
! 2316: function_num++;
! 2317: zend_hash_move_forward(&sdl->functions);
! 2318: }
! 2319: }
! 2320:
! 2321: /* serialize requests */
! 2322: if (sdl->requests) {
! 2323: i = zend_hash_num_elements(sdl->requests);
! 2324: } else {
! 2325: i = 0;
! 2326: }
! 2327: WSDL_CACHE_PUT_INT(i, out);
! 2328: if (i > 0) {
! 2329: sdlFunctionPtr *tmp;
! 2330: int *function_num;
! 2331:
! 2332: zend_hash_internal_pointer_reset(sdl->requests);
! 2333: while (zend_hash_get_current_data(sdl->requests, (void**)&tmp) == SUCCESS) {
! 2334: if (zend_hash_find(&tmp_functions, (char*)tmp, sizeof(*tmp), (void**)&function_num) != SUCCESS) {
! 2335: }
! 2336: WSDL_CACHE_PUT_INT(*function_num, out);
! 2337: sdl_serialize_key(sdl->requests, out);
! 2338: zend_hash_move_forward(sdl->requests);
! 2339: }
! 2340: }
! 2341:
! 2342: write(f, buf.c, buf.len);
! 2343: close(f);
! 2344: smart_str_free(&buf);
! 2345: zend_hash_destroy(&tmp_functions);
! 2346: zend_hash_destroy(&tmp_bindings);
! 2347: zend_hash_destroy(&tmp_encoders);
! 2348: zend_hash_destroy(&tmp_types);
! 2349: }
! 2350:
! 2351:
! 2352: static void make_persistent_restriction_int(void *data)
! 2353: {
! 2354: sdlRestrictionIntPtr *rest = (sdlRestrictionIntPtr *)data;
! 2355: sdlRestrictionIntPtr prest = NULL;
! 2356:
! 2357: prest = malloc(sizeof(sdlRestrictionInt));
! 2358: *prest = **rest;
! 2359: *rest = prest;
! 2360: }
! 2361:
! 2362:
! 2363: static void make_persistent_restriction_char(void *data)
! 2364: {
! 2365: sdlRestrictionCharPtr *rest = (sdlRestrictionCharPtr *)data;
! 2366: sdlRestrictionCharPtr prest = NULL;
! 2367:
! 2368: prest = malloc(sizeof(sdlRestrictionChar));
! 2369: memset(prest, 0, sizeof(sdlRestrictionChar));
! 2370: prest->value = strdup((*rest)->value);
! 2371: prest->fixed = (*rest)->fixed;
! 2372: *rest = prest;
! 2373: }
! 2374:
! 2375:
! 2376: static void make_persistent_sdl_type_ref(sdlTypePtr *type, HashTable *ptr_map, HashTable *bp_types)
! 2377: {
! 2378: sdlTypePtr *tmp;
! 2379:
! 2380: if (zend_hash_find(ptr_map, (char *)type, sizeof(sdlTypePtr), (void**)&tmp) == SUCCESS) {
! 2381: *type = *tmp;
! 2382: } else {
! 2383: zend_hash_next_index_insert(bp_types, (void*)&type, sizeof(sdlTypePtr*), NULL);
! 2384: }
! 2385: }
! 2386:
! 2387:
! 2388: static void make_persistent_sdl_encoder_ref(encodePtr *enc, HashTable *ptr_map, HashTable *bp_encoders)
! 2389: {
! 2390: encodePtr *tmp;
! 2391:
! 2392: /* do not process defaultEncoding's here */
! 2393: if ((*enc) >= defaultEncoding && (*enc) < defaultEncoding + numDefaultEncodings) {
! 2394: return;
! 2395: }
! 2396:
! 2397: if (zend_hash_find(ptr_map, (char *)enc, sizeof(encodePtr), (void**)&tmp) == SUCCESS) {
! 2398: *enc = *tmp;
! 2399: } else {
! 2400: zend_hash_next_index_insert(bp_encoders, (void*)&enc, sizeof(encodePtr*), NULL);
! 2401: }
! 2402: }
! 2403:
! 2404:
! 2405: static HashTable* make_persistent_sdl_function_headers(HashTable *headers, HashTable *ptr_map)
! 2406: {
! 2407: HashTable *pheaders;
! 2408: sdlSoapBindingFunctionHeaderPtr *tmp, pheader;
! 2409: encodePtr *penc;
! 2410: sdlTypePtr *ptype;
! 2411: ulong index;
! 2412: char *key;
! 2413: uint key_len;
! 2414:
! 2415: pheaders = malloc(sizeof(HashTable));
! 2416: zend_hash_init(pheaders, zend_hash_num_elements(headers), NULL, delete_header_persistent, 1);
! 2417:
! 2418: zend_hash_internal_pointer_reset(headers);
! 2419: while (zend_hash_get_current_data(headers, (void**)&tmp) == SUCCESS) {
! 2420: pheader = malloc(sizeof(sdlSoapBindingFunctionHeader));
! 2421: memset(pheader, 0, sizeof(sdlSoapBindingFunctionHeader));
! 2422: *pheader = **tmp;
! 2423:
! 2424: if (pheader->name) {
! 2425: pheader->name = strdup(pheader->name);
! 2426: }
! 2427: if (pheader->ns) {
! 2428: pheader->ns = strdup(pheader->ns);
! 2429: }
! 2430:
! 2431: if (pheader->encode->details.sdl_type) {
! 2432: if (zend_hash_find(ptr_map, (char*)&pheader->encode, sizeof(encodePtr), (void**)&penc) == FAILURE) {
! 2433: assert(0);
! 2434: }
! 2435: pheader->encode = *penc;
! 2436: }
! 2437: if (pheader->element) {
! 2438: if (zend_hash_find(ptr_map, (char*)&pheader->element, sizeof(sdlTypePtr), (void**)&ptype) == FAILURE) {
! 2439: assert(0);
! 2440: }
! 2441: pheader->element = *ptype;
! 2442: }
! 2443:
! 2444: if (pheader->headerfaults) {
! 2445: pheader->headerfaults = make_persistent_sdl_function_headers(pheader->headerfaults, ptr_map);
! 2446: }
! 2447:
! 2448: if (zend_hash_get_current_key_ex(headers, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
! 2449: zend_hash_add(pheaders, key, key_len, (void*)&pheader, sizeof(sdlSoapBindingFunctionHeaderPtr), NULL);
! 2450: } else {
! 2451: zend_hash_next_index_insert(pheaders, (void*)&pheader, sizeof(sdlSoapBindingFunctionHeaderPtr), NULL);
! 2452: }
! 2453:
! 2454: zend_hash_move_forward(headers);
! 2455: }
! 2456:
! 2457: return pheaders;
! 2458: }
! 2459:
! 2460:
! 2461: static void make_persistent_sdl_soap_body(sdlSoapBindingFunctionBodyPtr body, HashTable *ptr_map)
! 2462: {
! 2463: if (body->ns) {
! 2464: body->ns = strdup(body->ns);
! 2465: }
! 2466:
! 2467: if (body->headers) {
! 2468: body->headers = make_persistent_sdl_function_headers(body->headers, ptr_map);
! 2469: }
! 2470: }
! 2471:
! 2472:
! 2473: static HashTable* make_persistent_sdl_parameters(HashTable *params, HashTable *ptr_map)
! 2474: {
! 2475: HashTable *pparams;
! 2476: sdlParamPtr *tmp, pparam;
! 2477: sdlTypePtr *ptype;
! 2478: encodePtr *penc;
! 2479: ulong index;
! 2480: char *key;
! 2481: uint key_len;
! 2482:
! 2483: pparams = malloc(sizeof(HashTable));
! 2484: zend_hash_init(pparams, zend_hash_num_elements(params), NULL, delete_parameter_persistent, 1);
! 2485:
! 2486: zend_hash_internal_pointer_reset(params);
! 2487: while (zend_hash_get_current_data(params, (void**)&tmp) == SUCCESS) {
! 2488: pparam = malloc(sizeof(sdlParam));
! 2489: memset(pparam, 0, sizeof(sdlParam));
! 2490: *pparam = **tmp;
! 2491:
! 2492: if (pparam->paramName) {
! 2493: pparam->paramName = strdup(pparam->paramName);
! 2494: }
! 2495:
! 2496: if (pparam->encode && pparam->encode->details.sdl_type) {
! 2497: if (zend_hash_find(ptr_map, (char*)&pparam->encode, sizeof(encodePtr), (void**)&penc) == FAILURE) {
! 2498: assert(0);
! 2499: }
! 2500: pparam->encode = *penc;
! 2501: }
! 2502: if (pparam->element) {
! 2503: if (zend_hash_find(ptr_map, (char*)&pparam->element, sizeof(sdlTypePtr), (void**)&ptype) == FAILURE) {
! 2504: assert(0);
! 2505: }
! 2506: pparam->element = *ptype;
! 2507: }
! 2508:
! 2509: if (zend_hash_get_current_key_ex(params, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
! 2510: zend_hash_add(pparams, key, key_len, (void*)&pparam, sizeof(sdlParamPtr), NULL);
! 2511: } else {
! 2512: zend_hash_next_index_insert(pparams, (void*)&pparam, sizeof(sdlParamPtr), NULL);
! 2513: }
! 2514:
! 2515: zend_hash_move_forward(params);
! 2516: }
! 2517:
! 2518:
! 2519: return pparams;
! 2520: }
! 2521:
! 2522: static HashTable* make_persistent_sdl_function_faults(sdlFunctionPtr func, HashTable *faults, HashTable *ptr_map)
! 2523: {
! 2524: HashTable *pfaults;
! 2525: sdlFaultPtr *tmp, pfault;
! 2526: ulong index;
! 2527: char *key;
! 2528: uint key_len;
! 2529:
! 2530: pfaults = malloc(sizeof(HashTable));
! 2531: zend_hash_init(pfaults, zend_hash_num_elements(faults), NULL, delete_fault_persistent, 1);
! 2532:
! 2533: zend_hash_internal_pointer_reset(faults);
! 2534: while (zend_hash_get_current_data(faults, (void**)&tmp) == SUCCESS) {
! 2535: pfault = malloc(sizeof(sdlFault));
! 2536: memset(pfault, 0, sizeof(sdlFault));
! 2537: *pfault = **tmp;
! 2538:
! 2539: if (pfault->name) {
! 2540: pfault->name = strdup(pfault->name);
! 2541: }
! 2542: if (pfault->details) {
! 2543: pfault->details = make_persistent_sdl_parameters(pfault->details, ptr_map);
! 2544: }
! 2545:
! 2546: if (func->binding->bindingType == BINDING_SOAP && pfault->bindingAttributes) {
! 2547: sdlSoapBindingFunctionFaultPtr soap_binding;
! 2548:
! 2549: soap_binding = malloc(sizeof(sdlSoapBindingFunctionFault));
! 2550: memset(soap_binding, 0, sizeof(sdlSoapBindingFunctionFault));
! 2551: *soap_binding = *(sdlSoapBindingFunctionFaultPtr)pfault->bindingAttributes;
! 2552: if (soap_binding->ns) {
! 2553: soap_binding->ns = strdup(soap_binding->ns);
! 2554: }
! 2555: pfault->bindingAttributes = soap_binding;
! 2556: }
! 2557:
! 2558: if (zend_hash_get_current_key_ex(faults, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
! 2559: zend_hash_add(pfaults, key, key_len, (void*)&pfault, sizeof(sdlParamPtr), NULL);
! 2560: } else {
! 2561: zend_hash_next_index_insert(pfaults, (void*)&pfault, sizeof(sdlParamPtr), NULL);
! 2562: }
! 2563:
! 2564: zend_hash_move_forward(faults);
! 2565: }
! 2566:
! 2567:
! 2568: return pfaults;
! 2569: }
! 2570:
! 2571:
! 2572: static sdlAttributePtr make_persistent_sdl_attribute(sdlAttributePtr attr, HashTable *ptr_map, HashTable *bp_types, HashTable *bp_encoders)
! 2573: {
! 2574: sdlAttributePtr pattr;
! 2575: ulong index;
! 2576: char *key;
! 2577: uint key_len;
! 2578:
! 2579: pattr = malloc(sizeof(sdlAttribute));
! 2580: memset(pattr, 0, sizeof(sdlAttribute));
! 2581:
! 2582: *pattr = *attr;
! 2583:
! 2584: if (pattr->name) {
! 2585: pattr->name = strdup(pattr->name);
! 2586: }
! 2587: if (pattr->namens) {
! 2588: pattr->namens = strdup(pattr->namens);
! 2589: }
! 2590: if (pattr->ref) {
! 2591: pattr->ref = strdup(pattr->ref);
! 2592: }
! 2593: if (pattr->def) {
! 2594: pattr->def = strdup(pattr->def);
! 2595: }
! 2596: if (pattr->fixed) {
! 2597: pattr->fixed = strdup(pattr->fixed);
! 2598: }
! 2599:
! 2600: /* we do not want to process defaultEncoding's here */
! 2601: if (pattr->encode) {
! 2602: make_persistent_sdl_encoder_ref(&pattr->encode, ptr_map, bp_encoders);
! 2603: }
! 2604:
! 2605: if (pattr->extraAttributes) {
! 2606: sdlExtraAttributePtr *tmp, pextra;
! 2607:
! 2608: pattr->extraAttributes = malloc(sizeof(HashTable));
! 2609: zend_hash_init(pattr->extraAttributes, zend_hash_num_elements(attr->extraAttributes), NULL, delete_extra_attribute_persistent, 1);
! 2610:
! 2611: zend_hash_internal_pointer_reset(pattr->extraAttributes);
! 2612: while (zend_hash_get_current_data(attr->extraAttributes, (void**)&tmp) == SUCCESS) {
! 2613: pextra = malloc(sizeof(sdlExtraAttribute));
! 2614: memset(pextra, 0, sizeof(sdlExtraAttribute));
! 2615: if ((*tmp)->ns) {
! 2616: pextra->ns = strdup((*tmp)->ns);
! 2617: }
! 2618: if ((*tmp)->val) {
! 2619: pextra->val = strdup((*tmp)->val);
! 2620: }
! 2621:
! 2622: if (zend_hash_get_current_key_ex(attr->extraAttributes, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
! 2623: zend_hash_add(pattr->extraAttributes, key, key_len, (void*)&pextra, sizeof(sdlExtraAttributePtr), NULL);
! 2624: }
! 2625:
! 2626: zend_hash_move_forward(attr->extraAttributes);
! 2627: }
! 2628: }
! 2629:
! 2630: return pattr;
! 2631: }
! 2632:
! 2633:
! 2634: static sdlContentModelPtr make_persistent_sdl_model(sdlContentModelPtr model, HashTable *ptr_map, HashTable *bp_types, HashTable *bp_encoders)
! 2635: {
! 2636: sdlContentModelPtr pmodel;
! 2637: sdlContentModelPtr *tmp, pcontent;
! 2638:
! 2639: pmodel = malloc(sizeof(sdlContentModel));
! 2640: memset(pmodel, 0, sizeof(sdlContentModel));
! 2641: *pmodel = *model;
! 2642:
! 2643: switch (pmodel->kind) {
! 2644: case XSD_CONTENT_ELEMENT:
! 2645: if (pmodel->u.element) {
! 2646: make_persistent_sdl_type_ref(&pmodel->u.element, ptr_map, bp_types);
! 2647: }
! 2648: break;
! 2649:
! 2650: case XSD_CONTENT_SEQUENCE:
! 2651: case XSD_CONTENT_ALL:
! 2652: case XSD_CONTENT_CHOICE:
! 2653: pmodel->u.content = malloc(sizeof(HashTable));
! 2654: zend_hash_init(pmodel->u.content, zend_hash_num_elements(model->u.content), NULL, delete_model_persistent, 1);
! 2655:
! 2656: zend_hash_internal_pointer_reset(model->u.content);
! 2657: while (zend_hash_get_current_data(model->u.content, (void**)&tmp) == SUCCESS) {
! 2658: pcontent = make_persistent_sdl_model(*tmp, ptr_map, bp_types, bp_encoders);
! 2659: zend_hash_next_index_insert(pmodel->u.content, (void*)&pcontent, sizeof(sdlContentModelPtr), NULL);
! 2660: zend_hash_move_forward(model->u.content);
! 2661: }
! 2662: break;
! 2663:
! 2664: case XSD_CONTENT_GROUP_REF:
! 2665: if (pmodel->u.group_ref) {
! 2666: pmodel->u.group_ref = strdup(pmodel->u.group_ref);
! 2667: }
! 2668: break;
! 2669:
! 2670: case XSD_CONTENT_GROUP:
! 2671: if (pmodel->u.group) {
! 2672: make_persistent_sdl_type_ref(&pmodel->u.group, ptr_map, bp_types);
! 2673: }
! 2674: break;
! 2675:
! 2676: default:
! 2677: break;
! 2678: }
! 2679:
! 2680: return pmodel;
! 2681: }
! 2682:
! 2683:
! 2684: static sdlTypePtr make_persistent_sdl_type(sdlTypePtr type, HashTable *ptr_map, HashTable *bp_types, HashTable *bp_encoders)
! 2685: {
! 2686: ulong index;
! 2687: char *key;
! 2688: uint key_len;
! 2689: sdlTypePtr ptype = NULL;
! 2690:
! 2691: ptype = malloc(sizeof(sdlType));
! 2692: memset(ptype, 0, sizeof(sdlType));
! 2693:
! 2694: *ptype = *type;
! 2695:
! 2696: if (ptype->name) {
! 2697: ptype->name = strdup(ptype->name);
! 2698: }
! 2699: if (ptype->namens) {
! 2700: ptype->namens = strdup(ptype->namens);
! 2701: }
! 2702: if (ptype->def) {
! 2703: ptype->def = strdup(ptype->def);
! 2704: }
! 2705: if (ptype->fixed) {
! 2706: ptype->fixed = strdup(ptype->fixed);
! 2707: }
! 2708: if (ptype->ref) {
! 2709: ptype->ref = strdup(ptype->ref);
! 2710: }
! 2711:
! 2712: /* we do not want to process defaultEncoding's here */
! 2713: if (ptype->encode) {
! 2714: make_persistent_sdl_encoder_ref(&ptype->encode, ptr_map, bp_encoders);
! 2715: }
! 2716:
! 2717: if (ptype->restrictions) {
! 2718: ptype->restrictions = malloc(sizeof(sdlRestrictions));
! 2719: memset(ptype->restrictions, 0, sizeof(sdlRestrictions));
! 2720: *ptype->restrictions = *type->restrictions;
! 2721:
! 2722: if (ptype->restrictions->minExclusive) {
! 2723: make_persistent_restriction_int(&ptype->restrictions->minExclusive);
! 2724: }
! 2725: if (ptype->restrictions->maxExclusive) {
! 2726: make_persistent_restriction_int(&ptype->restrictions->maxExclusive);
! 2727: }
! 2728: if (ptype->restrictions->minInclusive) {
! 2729: make_persistent_restriction_int(&ptype->restrictions->minInclusive);
! 2730: }
! 2731: if (ptype->restrictions->maxInclusive) {
! 2732: make_persistent_restriction_int(&ptype->restrictions->maxInclusive);
! 2733: }
! 2734: if (ptype->restrictions->totalDigits) {
! 2735: make_persistent_restriction_int(&ptype->restrictions->totalDigits);
! 2736: }
! 2737: if (ptype->restrictions->fractionDigits) {
! 2738: make_persistent_restriction_int(&ptype->restrictions->fractionDigits);
! 2739: }
! 2740: if (ptype->restrictions->length) {
! 2741: make_persistent_restriction_int(&ptype->restrictions->length);
! 2742: }
! 2743: if (ptype->restrictions->minLength) {
! 2744: make_persistent_restriction_int(&ptype->restrictions->minLength);
! 2745: }
! 2746: if (ptype->restrictions->maxLength) {
! 2747: make_persistent_restriction_int(&ptype->restrictions->maxLength);
! 2748: }
! 2749: if (ptype->restrictions->whiteSpace) {
! 2750: make_persistent_restriction_char(&ptype->restrictions->whiteSpace);
! 2751: }
! 2752: if (ptype->restrictions->pattern) {
! 2753: make_persistent_restriction_char(&ptype->restrictions->pattern);
! 2754: }
! 2755:
! 2756: if (type->restrictions->enumeration) {
! 2757: sdlRestrictionCharPtr tmp;
! 2758:
! 2759: ptype->restrictions->enumeration = malloc(sizeof(HashTable));
! 2760: zend_hash_init(ptype->restrictions->enumeration, zend_hash_num_elements(type->restrictions->enumeration), NULL, delete_restriction_var_char_persistent, 1);
! 2761: zend_hash_copy(ptype->restrictions->enumeration, type->restrictions->enumeration, make_persistent_restriction_char, (void*)&tmp, sizeof(sdlRestrictionCharPtr));
! 2762: }
! 2763: }
! 2764:
! 2765: if (ptype->elements) {
! 2766: sdlTypePtr *tmp, pelem;
! 2767:
! 2768: ptype->elements = malloc(sizeof(HashTable));
! 2769: zend_hash_init(ptype->elements, zend_hash_num_elements(type->elements), NULL, delete_type_persistent, 1);
! 2770:
! 2771: zend_hash_internal_pointer_reset(type->elements);
! 2772: while (zend_hash_get_current_data(type->elements, (void **)&tmp) == SUCCESS) {
! 2773: pelem = make_persistent_sdl_type(*tmp, ptr_map, bp_types, bp_encoders);
! 2774: if (zend_hash_get_current_key_ex(type->elements, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
! 2775: zend_hash_add(ptype->elements, key, key_len, (void*)&pelem, sizeof(sdlTypePtr), NULL);
! 2776: } else {
! 2777: zend_hash_next_index_insert(ptype->elements, (void*)&pelem, sizeof(sdlTypePtr), NULL);
! 2778: }
! 2779: zend_hash_add(ptr_map, (char*)tmp, sizeof(*tmp), (void*)&pelem, sizeof(sdlTypePtr), NULL);
! 2780: zend_hash_move_forward(type->elements);
! 2781: }
! 2782: }
! 2783:
! 2784: if (ptype->attributes) {
! 2785: sdlAttributePtr *tmp, pattr;
! 2786:
! 2787: ptype->attributes = malloc(sizeof(HashTable));
! 2788: zend_hash_init(ptype->attributes, zend_hash_num_elements(type->attributes), NULL, delete_attribute_persistent, 1);
! 2789:
! 2790: zend_hash_internal_pointer_reset(type->attributes);
! 2791: while (zend_hash_get_current_data(type->attributes, (void **)&tmp) == SUCCESS) {
! 2792: pattr = make_persistent_sdl_attribute(*tmp, ptr_map, bp_types, bp_encoders);
! 2793: if (zend_hash_get_current_key_ex(type->attributes, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
! 2794: zend_hash_add(ptype->attributes, key, key_len, (void*)&pattr, sizeof(sdlAttributePtr), NULL);
! 2795: } else {
! 2796: zend_hash_next_index_insert(ptype->attributes, (void*)&pattr, sizeof(sdlAttributePtr), NULL);
! 2797: }
! 2798: zend_hash_move_forward(type->attributes);
! 2799: }
! 2800: }
! 2801:
! 2802: if (type->model) {
! 2803: ptype->model = make_persistent_sdl_model(ptype->model, ptr_map, bp_types, bp_encoders);
! 2804: }
! 2805:
! 2806: return ptype;
! 2807: }
! 2808:
! 2809: static encodePtr make_persistent_sdl_encoder(encodePtr enc, HashTable *ptr_map, HashTable *bp_types, HashTable *bp_encoders)
! 2810: {
! 2811: encodePtr penc = NULL;
! 2812:
! 2813: penc = malloc(sizeof(encode));
! 2814: memset(penc, 0, sizeof(encode));
! 2815:
! 2816: *penc = *enc;
! 2817:
! 2818: if (penc->details.type_str) {
! 2819: penc->details.type_str = strdup(penc->details.type_str);
! 2820: }
! 2821: if (penc->details.ns) {
! 2822: penc->details.ns = strdup(penc->details.ns);
! 2823: }
! 2824:
! 2825: if (penc->details.sdl_type) {
! 2826: make_persistent_sdl_type_ref(&penc->details.sdl_type, ptr_map, bp_types);
! 2827: }
! 2828:
! 2829: return penc;
! 2830: }
! 2831:
! 2832: static sdlBindingPtr make_persistent_sdl_binding(sdlBindingPtr bind, HashTable *ptr_map)
! 2833: {
! 2834: sdlBindingPtr pbind = NULL;
! 2835:
! 2836: pbind = malloc(sizeof(sdlBinding));
! 2837: memset(pbind, 0, sizeof(sdlBinding));
! 2838:
! 2839: *pbind = *bind;
! 2840:
! 2841: if (pbind->name) {
! 2842: pbind->name = strdup(pbind->name);
! 2843: }
! 2844: if (pbind->location) {
! 2845: pbind->location = strdup(pbind->location);
! 2846: }
! 2847:
! 2848: if (pbind->bindingType == BINDING_SOAP && pbind->bindingAttributes) {
! 2849: sdlSoapBindingPtr soap_binding;
! 2850:
! 2851: soap_binding = malloc(sizeof(sdlSoapBinding));
! 2852: memset(soap_binding, 0, sizeof(sdlSoapBinding));
! 2853: *soap_binding = *(sdlSoapBindingPtr)pbind->bindingAttributes;
! 2854: pbind->bindingAttributes = soap_binding;
! 2855: }
! 2856:
! 2857: return pbind;
! 2858: }
! 2859:
! 2860: static sdlFunctionPtr make_persistent_sdl_function(sdlFunctionPtr func, HashTable *ptr_map)
! 2861: {
! 2862: sdlFunctionPtr pfunc = NULL;
! 2863:
! 2864: pfunc = malloc(sizeof(sdlFunction));
! 2865: memset(pfunc, 0, sizeof(sdlFunction));
! 2866:
! 2867: *pfunc = *func;
! 2868:
! 2869: if (pfunc->functionName) {
! 2870: pfunc->functionName = strdup(pfunc->functionName);
! 2871: }
! 2872: if (pfunc->requestName) {
! 2873: pfunc->requestName = strdup(pfunc->requestName);
! 2874: }
! 2875: if (pfunc->responseName) {
! 2876: pfunc->responseName = strdup(pfunc->responseName);
! 2877: }
! 2878:
! 2879: if (pfunc->binding) {
! 2880: sdlBindingPtr *tmp;
! 2881:
! 2882: if (zend_hash_find(ptr_map, (char*)&pfunc->binding, sizeof(pfunc->binding), (void**)&tmp) == FAILURE) {
! 2883: assert(0);
! 2884: }
! 2885: pfunc->binding = *tmp;
! 2886:
! 2887: if (pfunc->binding->bindingType == BINDING_SOAP && pfunc->bindingAttributes) {
! 2888: sdlSoapBindingFunctionPtr soap_binding;
! 2889:
! 2890: soap_binding = malloc(sizeof(sdlSoapBindingFunction));
! 2891: memset(soap_binding, 0, sizeof(sdlSoapBindingFunction));
! 2892: *soap_binding = *(sdlSoapBindingFunctionPtr)pfunc->bindingAttributes;
! 2893: if (soap_binding->soapAction) {
! 2894: soap_binding->soapAction = strdup(soap_binding->soapAction);
! 2895: }
! 2896: make_persistent_sdl_soap_body(&soap_binding->input, ptr_map);
! 2897: make_persistent_sdl_soap_body(&soap_binding->output, ptr_map);
! 2898: pfunc->bindingAttributes = soap_binding;
! 2899: }
! 2900:
! 2901: if (pfunc->requestParameters) {
! 2902: pfunc->requestParameters = make_persistent_sdl_parameters(pfunc->requestParameters, ptr_map);
! 2903: }
! 2904: if (pfunc->responseParameters) {
! 2905: pfunc->responseParameters = make_persistent_sdl_parameters(pfunc->responseParameters, ptr_map);
! 2906: }
! 2907: if (pfunc->faults) {
! 2908: pfunc->faults = make_persistent_sdl_function_faults(pfunc, pfunc->faults, ptr_map);
! 2909: }
! 2910: }
! 2911:
! 2912: return pfunc;
! 2913: }
! 2914:
! 2915: static sdlPtr make_persistent_sdl(sdlPtr sdl TSRMLS_DC)
! 2916: {
! 2917: sdlPtr psdl = NULL;
! 2918: HashTable ptr_map;
! 2919: HashTable bp_types, bp_encoders;
! 2920: ulong index;
! 2921: char *key;
! 2922: uint key_len;
! 2923:
! 2924: zend_hash_init(&bp_types, 0, NULL, NULL, 0);
! 2925: zend_hash_init(&bp_encoders, 0, NULL, NULL, 0);
! 2926: zend_hash_init(&ptr_map, 0, NULL, NULL, 0);
! 2927:
! 2928: psdl = malloc(sizeof(*sdl));
! 2929: memset(psdl, 0, sizeof(*sdl));
! 2930:
! 2931: if (sdl->source) {
! 2932: psdl->source = strdup(sdl->source);
! 2933: }
! 2934: if (sdl->target_ns) {
! 2935: psdl->target_ns = strdup(sdl->target_ns);
! 2936: }
! 2937:
! 2938: if (sdl->groups) {
! 2939: sdlTypePtr *tmp;
! 2940: sdlTypePtr ptype;
! 2941:
! 2942: psdl->groups = malloc(sizeof(HashTable));
! 2943: zend_hash_init(psdl->groups, zend_hash_num_elements(sdl->groups), NULL, delete_type_persistent, 1);
! 2944:
! 2945: zend_hash_internal_pointer_reset(sdl->groups);
! 2946: while (zend_hash_get_current_data(sdl->groups, (void **)&tmp) == SUCCESS) {
! 2947: ptype = make_persistent_sdl_type(*tmp, &ptr_map, &bp_types, &bp_encoders);
! 2948: if (zend_hash_get_current_key_ex(sdl->groups, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
! 2949: zend_hash_add(psdl->groups, key, key_len, (void*)&ptype, sizeof(sdlTypePtr), NULL);
! 2950: } else {
! 2951: zend_hash_next_index_insert(psdl->groups, (void*)&ptype, sizeof(sdlTypePtr), NULL);
! 2952: }
! 2953: zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&ptype, sizeof(sdlTypePtr), NULL);
! 2954: zend_hash_move_forward(sdl->groups);
! 2955: }
! 2956: }
! 2957:
! 2958: if (sdl->types) {
! 2959: sdlTypePtr *tmp;
! 2960: sdlTypePtr ptype;
! 2961:
! 2962: psdl->types = malloc(sizeof(HashTable));
! 2963: zend_hash_init(psdl->types, zend_hash_num_elements(sdl->types), NULL, delete_type_persistent, 1);
! 2964:
! 2965: zend_hash_internal_pointer_reset(sdl->types);
! 2966: while (zend_hash_get_current_data(sdl->types, (void **)&tmp) == SUCCESS) {
! 2967: ptype = make_persistent_sdl_type(*tmp, &ptr_map, &bp_types, &bp_encoders);
! 2968: if (zend_hash_get_current_key_ex(sdl->types, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
! 2969: zend_hash_add(psdl->types, key, key_len, (void*)&ptype, sizeof(sdlTypePtr), NULL);
! 2970: } else {
! 2971: zend_hash_next_index_insert(psdl->types, (void*)&ptype, sizeof(sdlTypePtr), NULL);
! 2972: }
! 2973: zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&ptype, sizeof(sdlTypePtr), NULL);
! 2974: zend_hash_move_forward(sdl->types);
! 2975: }
! 2976: }
! 2977:
! 2978: if (sdl->elements) {
! 2979: sdlTypePtr *tmp;
! 2980: sdlTypePtr ptype;
! 2981:
! 2982: psdl->elements = malloc(sizeof(HashTable));
! 2983: zend_hash_init(psdl->elements, zend_hash_num_elements(sdl->elements), NULL, delete_type_persistent, 1);
! 2984:
! 2985: zend_hash_internal_pointer_reset(sdl->elements);
! 2986: while (zend_hash_get_current_data(sdl->elements, (void **)&tmp) == SUCCESS) {
! 2987: ptype = make_persistent_sdl_type(*tmp, &ptr_map, &bp_types, &bp_encoders);
! 2988: if (zend_hash_get_current_key_ex(sdl->elements, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
! 2989: zend_hash_add(psdl->elements, key, key_len, (void*)&ptype, sizeof(sdlTypePtr), NULL);
! 2990: } else {
! 2991: zend_hash_next_index_insert(psdl->elements, (void*)&ptype, sizeof(sdlTypePtr), NULL);
! 2992: }
! 2993: zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&ptype, sizeof(sdlTypePtr), NULL);
! 2994: zend_hash_move_forward(sdl->elements);
! 2995: }
! 2996: }
! 2997:
! 2998: if (sdl->encoders) {
! 2999: encodePtr *tmp;
! 3000: encodePtr penc;
! 3001:
! 3002: psdl->encoders = malloc(sizeof(HashTable));
! 3003: zend_hash_init(psdl->encoders, zend_hash_num_elements(sdl->encoders), NULL, delete_encoder_persistent, 1);
! 3004:
! 3005: zend_hash_internal_pointer_reset(sdl->encoders);
! 3006: while (zend_hash_get_current_data(sdl->encoders, (void **)&tmp) == SUCCESS) {
! 3007: penc = make_persistent_sdl_encoder(*tmp, &ptr_map, &bp_types, &bp_encoders);
! 3008: if (zend_hash_get_current_key_ex(sdl->encoders, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
! 3009: zend_hash_add(psdl->encoders, key, key_len, (void*)&penc, sizeof(encodePtr), NULL);
! 3010: } else {
! 3011: zend_hash_next_index_insert(psdl->encoders, (void*)&penc, sizeof(encodePtr), NULL);
! 3012: }
! 3013: zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&penc, sizeof(encodePtr), NULL);
! 3014: zend_hash_move_forward(sdl->encoders);
! 3015: }
! 3016: }
! 3017:
! 3018: /* do backpatching here */
! 3019: if (zend_hash_num_elements(&bp_types)) {
! 3020: sdlTypePtr **tmp, *ptype = NULL;
! 3021:
! 3022: zend_hash_internal_pointer_reset(&bp_types);
! 3023: while (zend_hash_get_current_data(&bp_types, (void**)&tmp) == SUCCESS) {
! 3024: if (zend_hash_find(&ptr_map, (char*)(*tmp), sizeof(**tmp), (void**)&ptype) == FAILURE) {
! 3025: assert(0);
! 3026: }
! 3027: **tmp = *ptype;
! 3028: zend_hash_move_forward(&bp_types);
! 3029: }
! 3030: }
! 3031: if (zend_hash_num_elements(&bp_encoders)) {
! 3032: encodePtr **tmp, *penc = NULL;
! 3033:
! 3034: zend_hash_internal_pointer_reset(&bp_encoders);
! 3035: while (zend_hash_get_current_data(&bp_encoders, (void**)&tmp) == SUCCESS) {
! 3036: if (zend_hash_find(&ptr_map, (char*)(*tmp), sizeof(**tmp), (void**)&penc) == FAILURE) {
! 3037: assert(0);
! 3038: }
! 3039: **tmp = *penc;
! 3040: zend_hash_move_forward(&bp_encoders);
! 3041: }
! 3042: }
! 3043:
! 3044:
! 3045: if (sdl->bindings) {
! 3046: sdlBindingPtr *tmp;
! 3047: sdlBindingPtr pbind;
! 3048:
! 3049: psdl->bindings = malloc(sizeof(HashTable));
! 3050: zend_hash_init(psdl->bindings, zend_hash_num_elements(sdl->bindings), NULL, delete_binding_persistent, 1);
! 3051:
! 3052: zend_hash_internal_pointer_reset(sdl->bindings);
! 3053: while (zend_hash_get_current_data(sdl->bindings, (void **)&tmp) == SUCCESS) {
! 3054: pbind = make_persistent_sdl_binding(*tmp, &ptr_map);
! 3055: if (zend_hash_get_current_key_ex(sdl->bindings, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
! 3056: zend_hash_add(psdl->bindings, key, key_len, (void*)&pbind, sizeof(sdlBindingPtr), NULL);
! 3057: } else {
! 3058: zend_hash_next_index_insert(psdl->bindings, (void*)&pbind, sizeof(sdlBindingPtr), NULL);
! 3059: }
! 3060: zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&pbind, sizeof(sdlBindingPtr), NULL);
! 3061: zend_hash_move_forward(sdl->bindings);
! 3062: }
! 3063: }
! 3064:
! 3065: zend_hash_init(&psdl->functions, zend_hash_num_elements(&sdl->functions), NULL, delete_function_persistent, 1);
! 3066: if (zend_hash_num_elements(&sdl->functions)) {
! 3067: sdlFunctionPtr *tmp;
! 3068: sdlFunctionPtr pfunc;
! 3069:
! 3070: zend_hash_internal_pointer_reset(&sdl->functions);
! 3071: while (zend_hash_get_current_data(&sdl->functions, (void **)&tmp) == SUCCESS) {
! 3072: pfunc = make_persistent_sdl_function(*tmp, &ptr_map);
! 3073: if (zend_hash_get_current_key_ex(&sdl->functions, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
! 3074: zend_hash_add(&psdl->functions, key, key_len, (void*)&pfunc, sizeof(sdlFunctionPtr), NULL);
! 3075: } else {
! 3076: zend_hash_next_index_insert(&psdl->functions, (void*)&pfunc, sizeof(sdlFunctionPtr), NULL);
! 3077: }
! 3078: zend_hash_add(&ptr_map, (char*)tmp, sizeof(*tmp), (void*)&pfunc, sizeof(sdlFunctionPtr), NULL);
! 3079: zend_hash_move_forward(&sdl->functions);
! 3080: }
! 3081: }
! 3082:
! 3083: if (sdl->requests) {
! 3084: sdlFunctionPtr *tmp;
! 3085: sdlFunctionPtr *preq;
! 3086:
! 3087: psdl->requests = malloc(sizeof(HashTable));
! 3088: zend_hash_init(psdl->requests, zend_hash_num_elements(sdl->requests), NULL, NULL, 1);
! 3089:
! 3090: zend_hash_internal_pointer_reset(sdl->requests);
! 3091: while (zend_hash_get_current_data(sdl->requests, (void **)&tmp) == SUCCESS) {
! 3092: if (zend_hash_find(&ptr_map, (char*)tmp, sizeof(*tmp), (void**)&preq) == FAILURE) {
! 3093: assert(0);
! 3094: }
! 3095: *tmp = *preq;
! 3096: if (zend_hash_get_current_key_ex(sdl->requests, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
! 3097: zend_hash_add(psdl->requests, key, key_len, (void*)&preq, sizeof(sdlFunctionPtr), NULL);
! 3098: }
! 3099: zend_hash_move_forward(sdl->requests);
! 3100: }
! 3101: }
! 3102:
! 3103: zend_hash_destroy(&ptr_map);
! 3104: zend_hash_destroy(&bp_encoders);
! 3105: zend_hash_destroy(&bp_types);
! 3106:
! 3107: return psdl;
! 3108: }
! 3109:
! 3110: typedef struct _sdl_cache_bucket {
! 3111: sdlPtr sdl;
! 3112: time_t time;
! 3113: } sdl_cache_bucket;
! 3114:
! 3115: static void delete_psdl(void *data)
! 3116: {
! 3117: sdl_cache_bucket *p = (sdl_cache_bucket*)data;
! 3118: sdlPtr tmp = p->sdl;
! 3119:
! 3120: zend_hash_destroy(&tmp->functions);
! 3121: if (tmp->source) {
! 3122: free(tmp->source);
! 3123: }
! 3124: if (tmp->target_ns) {
! 3125: free(tmp->target_ns);
! 3126: }
! 3127: if (tmp->elements) {
! 3128: zend_hash_destroy(tmp->elements);
! 3129: free(tmp->elements);
! 3130: }
! 3131: if (tmp->encoders) {
! 3132: zend_hash_destroy(tmp->encoders);
! 3133: free(tmp->encoders);
! 3134: }
! 3135: if (tmp->types) {
! 3136: zend_hash_destroy(tmp->types);
! 3137: free(tmp->types);
! 3138: }
! 3139: if (tmp->groups) {
! 3140: zend_hash_destroy(tmp->groups);
! 3141: free(tmp->groups);
! 3142: }
! 3143: if (tmp->bindings) {
! 3144: zend_hash_destroy(tmp->bindings);
! 3145: free(tmp->bindings);
! 3146: }
! 3147: if (tmp->requests) {
! 3148: zend_hash_destroy(tmp->requests);
! 3149: free(tmp->requests);
! 3150: }
! 3151: free(tmp);
! 3152: }
! 3153:
! 3154: sdlPtr get_sdl(zval *this_ptr, char *uri, long cache_wsdl TSRMLS_DC)
! 3155: {
! 3156: char fn[MAXPATHLEN];
! 3157: sdlPtr sdl = NULL;
! 3158: char* old_error_code = SOAP_GLOBAL(error_code);
! 3159: int uri_len = 0;
! 3160: php_stream_context *context=NULL;
! 3161: zval **tmp, **proxy_host, **proxy_port, *orig_context = NULL, *new_context = NULL;
! 3162: smart_str headers = {0};
! 3163: char* key = NULL;
! 3164: time_t t = time(0);
! 3165:
! 3166: if (strchr(uri,':') != NULL || IS_ABSOLUTE_PATH(uri, uri_len)) {
! 3167: uri_len = strlen(uri);
! 3168: } else if (VCWD_REALPATH(uri, fn) == NULL) {
! 3169: cache_wsdl = WSDL_CACHE_NONE;
! 3170: } else {
! 3171: uri = fn;
! 3172: uri_len = strlen(uri);
! 3173: }
! 3174:
! 3175: if ((cache_wsdl & WSDL_CACHE_MEMORY) && SOAP_GLOBAL(mem_cache)) {
! 3176: sdl_cache_bucket *p;
! 3177:
! 3178: if (SUCCESS == zend_hash_find(SOAP_GLOBAL(mem_cache), uri, uri_len+1, (void*)&p)) {
! 3179: if (p->time < t - SOAP_GLOBAL(cache_ttl)) {
! 3180: /* in-memory cache entry is expired */
! 3181: zend_hash_del(&EG(persistent_list), uri, uri_len+1);
! 3182: } else {
! 3183: return p->sdl;
! 3184: }
! 3185: }
! 3186: }
! 3187:
! 3188: if ((cache_wsdl & WSDL_CACHE_DISK) && (uri_len < MAXPATHLEN)) {
! 3189: time_t t = time(0);
! 3190: char md5str[33];
! 3191: PHP_MD5_CTX context;
! 3192: unsigned char digest[16];
! 3193: int len = strlen(SOAP_GLOBAL(cache_dir));
! 3194: time_t cached;
! 3195: char *user = php_get_current_user();
! 3196: int user_len = user ? strlen(user) + 1 : 0;
! 3197:
! 3198: md5str[0] = '\0';
! 3199: PHP_MD5Init(&context);
! 3200: PHP_MD5Update(&context, (unsigned char*)uri, uri_len);
! 3201: PHP_MD5Final(digest, &context);
! 3202: make_digest(md5str, digest);
! 3203: key = emalloc(len+sizeof("/wsdl-")-1+user_len+sizeof(md5str));
! 3204: memcpy(key,SOAP_GLOBAL(cache_dir),len);
! 3205: memcpy(key+len,"/wsdl-",sizeof("/wsdl-")-1);
! 3206: len += sizeof("/wsdl-")-1;
! 3207: if (user_len) {
! 3208: memcpy(key+len, user, user_len-1);
! 3209: len += user_len-1;
! 3210: key[len++] = '-';
! 3211: }
! 3212: memcpy(key+len,md5str,sizeof(md5str));
! 3213:
! 3214: if ((sdl = get_sdl_from_cache(key, uri, t-SOAP_GLOBAL(cache_ttl), &cached TSRMLS_CC)) != NULL) {
! 3215: t = cached;
! 3216: efree(key);
! 3217: goto cache_in_memory;
! 3218: }
! 3219: }
! 3220:
! 3221: if (SUCCESS == zend_hash_find(Z_OBJPROP_P(this_ptr),
! 3222: "_stream_context", sizeof("_stream_context"), (void**)&tmp)) {
! 3223: context = php_stream_context_from_zval(*tmp, 0);
! 3224: } else {
! 3225: context = php_stream_context_alloc();
! 3226: }
! 3227:
! 3228: if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_proxy_host", sizeof("_proxy_host"), (void **) &proxy_host) == SUCCESS &&
! 3229: Z_TYPE_PP(proxy_host) == IS_STRING &&
! 3230: zend_hash_find(Z_OBJPROP_P(this_ptr), "_proxy_port", sizeof("_proxy_port"), (void **) &proxy_port) == SUCCESS &&
! 3231: Z_TYPE_PP(proxy_port) == IS_LONG) {
! 3232: zval str_port, *str_proxy;
! 3233: smart_str proxy = {0};
! 3234: str_port = **proxy_port;
! 3235: zval_copy_ctor(&str_port);
! 3236: convert_to_string(&str_port);
! 3237: smart_str_appends(&proxy,"tcp://");
! 3238: smart_str_appends(&proxy,Z_STRVAL_PP(proxy_host));
! 3239: smart_str_appends(&proxy,":");
! 3240: smart_str_appends(&proxy,Z_STRVAL(str_port));
! 3241: smart_str_0(&proxy);
! 3242: zval_dtor(&str_port);
! 3243: MAKE_STD_ZVAL(str_proxy);
! 3244: ZVAL_STRING(str_proxy, proxy.c, 1);
! 3245: smart_str_free(&proxy);
! 3246:
! 3247: if (!context) {
! 3248: context = php_stream_context_alloc();
! 3249: }
! 3250: php_stream_context_set_option(context, "http", "proxy", str_proxy);
! 3251: zval_ptr_dtor(&str_proxy);
! 3252:
! 3253: if (uri_len < sizeof("https://")-1 ||
! 3254: strncasecmp(uri, "https://", sizeof("https://")-1) != 0) {
! 3255: MAKE_STD_ZVAL(str_proxy);
! 3256: ZVAL_BOOL(str_proxy, 1);
! 3257: php_stream_context_set_option(context, "http", "request_fulluri", str_proxy);
! 3258: zval_ptr_dtor(&str_proxy);
! 3259: }
! 3260:
! 3261: proxy_authentication(this_ptr, &headers TSRMLS_CC);
! 3262: }
! 3263:
! 3264: basic_authentication(this_ptr, &headers TSRMLS_CC);
! 3265:
! 3266: /* Use HTTP/1.1 with "Connection: close" by default */
! 3267: if (php_stream_context_get_option(context, "http", "protocol_version", &tmp) == FAILURE) {
! 3268: zval *http_version;
! 3269: MAKE_STD_ZVAL(http_version);
! 3270: ZVAL_DOUBLE(http_version, 1.1);
! 3271: php_stream_context_set_option(context, "http", "protocol_version", http_version);
! 3272: zval_ptr_dtor(&http_version);
! 3273: smart_str_appendl(&headers, "Connection: close", sizeof("Connection: close")-1);
! 3274: }
! 3275:
! 3276: if (headers.len > 0) {
! 3277: zval *str_headers;
! 3278:
! 3279: if (!context) {
! 3280: context = php_stream_context_alloc();
! 3281: }
! 3282:
! 3283: smart_str_0(&headers);
! 3284: MAKE_STD_ZVAL(str_headers);
! 3285: ZVAL_STRING(str_headers, headers.c, 1);
! 3286: php_stream_context_set_option(context, "http", "header", str_headers);
! 3287: smart_str_free(&headers);
! 3288: zval_ptr_dtor(&str_headers);
! 3289: }
! 3290:
! 3291: if (context) {
! 3292: MAKE_STD_ZVAL(new_context);
! 3293: php_stream_context_to_zval(context, new_context);
! 3294: orig_context = php_libxml_switch_context(new_context TSRMLS_CC);
! 3295: }
! 3296:
! 3297: SOAP_GLOBAL(error_code) = "WSDL";
! 3298:
! 3299: sdl = load_wsdl(this_ptr, uri TSRMLS_CC);
! 3300: if (sdl) {
! 3301: sdl->is_persistent = 0;
! 3302: }
! 3303:
! 3304: SOAP_GLOBAL(error_code) = old_error_code;
! 3305:
! 3306: if (context) {
! 3307: php_libxml_switch_context(orig_context TSRMLS_CC);
! 3308: zval_ptr_dtor(&new_context);
! 3309: }
! 3310:
! 3311: if ((cache_wsdl & WSDL_CACHE_DISK) && key) {
! 3312: if (sdl) {
! 3313: add_sdl_to_cache(key, uri, t, sdl TSRMLS_CC);
! 3314: }
! 3315: efree(key);
! 3316: }
! 3317:
! 3318: cache_in_memory:
! 3319: if (cache_wsdl & WSDL_CACHE_MEMORY) {
! 3320: if (sdl) {
! 3321: sdlPtr psdl;
! 3322: sdl_cache_bucket p;
! 3323:
! 3324: if (SOAP_GLOBAL(mem_cache) == NULL) {
! 3325: SOAP_GLOBAL(mem_cache) = malloc(sizeof(HashTable));
! 3326: zend_hash_init(SOAP_GLOBAL(mem_cache), 0, NULL, delete_psdl, 1);
! 3327: } else if (SOAP_GLOBAL(cache_limit) > 0 &&
! 3328: SOAP_GLOBAL(cache_limit) <= zend_hash_num_elements(SOAP_GLOBAL(mem_cache))) {
! 3329: /* in-memory cache overflow */
! 3330: sdl_cache_bucket *q;
! 3331: HashPosition pos;
! 3332: time_t latest = t;
! 3333: char *key = NULL;
! 3334: uint key_len;
! 3335: ulong idx;
! 3336:
! 3337: for (zend_hash_internal_pointer_reset_ex(SOAP_GLOBAL(mem_cache), &pos);
! 3338: zend_hash_get_current_data_ex(SOAP_GLOBAL(mem_cache), (void **) &q, &pos) == SUCCESS;
! 3339: zend_hash_move_forward_ex(SOAP_GLOBAL(mem_cache), &pos)) {
! 3340: if (q->time < latest) {
! 3341: latest = q->time;
! 3342: zend_hash_get_current_key_ex(SOAP_GLOBAL(mem_cache), &key, &key_len, &idx, 0, &pos);
! 3343: }
! 3344: }
! 3345: if (key) {
! 3346: zend_hash_del(SOAP_GLOBAL(mem_cache), key, key_len);
! 3347: } else {
! 3348: return sdl;
! 3349: }
! 3350: }
! 3351:
! 3352: psdl = make_persistent_sdl(sdl TSRMLS_CC);
! 3353: psdl->is_persistent = 1;
! 3354: p.time = t;
! 3355: p.sdl = psdl;
! 3356:
! 3357: if (SUCCESS == zend_hash_update(SOAP_GLOBAL(mem_cache), uri,
! 3358: uri_len+1, (void*)&p, sizeof(sdl_cache_bucket), NULL)) {
! 3359: /* remove non-persitent sdl structure */
! 3360: delete_sdl_impl(sdl);
! 3361: /* and replace it with persistent one */
! 3362: sdl = psdl;
! 3363: } else {
! 3364: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to register persistent entry");
! 3365: /* clean up persistent sdl */
! 3366: delete_psdl(&p);
! 3367: /* keep non-persistent sdl and return it */
! 3368: }
! 3369: }
! 3370: }
! 3371:
! 3372: return sdl;
! 3373: }
! 3374:
! 3375: /* Deletes */
! 3376: void delete_sdl_impl(void *handle)
! 3377: {
! 3378: sdlPtr tmp = (sdlPtr)handle;
! 3379:
! 3380: zend_hash_destroy(&tmp->functions);
! 3381: if (tmp->source) {
! 3382: efree(tmp->source);
! 3383: }
! 3384: if (tmp->target_ns) {
! 3385: efree(tmp->target_ns);
! 3386: }
! 3387: if (tmp->elements) {
! 3388: zend_hash_destroy(tmp->elements);
! 3389: efree(tmp->elements);
! 3390: }
! 3391: if (tmp->encoders) {
! 3392: zend_hash_destroy(tmp->encoders);
! 3393: efree(tmp->encoders);
! 3394: }
! 3395: if (tmp->types) {
! 3396: zend_hash_destroy(tmp->types);
! 3397: efree(tmp->types);
! 3398: }
! 3399: if (tmp->groups) {
! 3400: zend_hash_destroy(tmp->groups);
! 3401: efree(tmp->groups);
! 3402: }
! 3403: if (tmp->bindings) {
! 3404: zend_hash_destroy(tmp->bindings);
! 3405: efree(tmp->bindings);
! 3406: }
! 3407: if (tmp->requests) {
! 3408: zend_hash_destroy(tmp->requests);
! 3409: efree(tmp->requests);
! 3410: }
! 3411: efree(tmp);
! 3412: }
! 3413:
! 3414: void delete_sdl(void *handle)
! 3415: {
! 3416: sdlPtr tmp = (sdlPtr)handle;
! 3417:
! 3418: if (!tmp->is_persistent) {
! 3419: delete_sdl_impl(tmp);
! 3420: }
! 3421: }
! 3422:
! 3423: static void delete_binding(void *data)
! 3424: {
! 3425: sdlBindingPtr binding = *((sdlBindingPtr*)data);
! 3426:
! 3427: if (binding->location) {
! 3428: efree(binding->location);
! 3429: }
! 3430: if (binding->name) {
! 3431: efree(binding->name);
! 3432: }
! 3433:
! 3434: if (binding->bindingType == BINDING_SOAP) {
! 3435: sdlSoapBindingPtr soapBind = binding->bindingAttributes;
! 3436: if (soapBind) {
! 3437: efree(soapBind);
! 3438: }
! 3439: }
! 3440: efree(binding);
! 3441: }
! 3442:
! 3443: static void delete_binding_persistent(void *data)
! 3444: {
! 3445: sdlBindingPtr binding = *((sdlBindingPtr*)data);
! 3446:
! 3447: if (binding->location) {
! 3448: free(binding->location);
! 3449: }
! 3450: if (binding->name) {
! 3451: free(binding->name);
! 3452: }
! 3453:
! 3454: if (binding->bindingType == BINDING_SOAP) {
! 3455: sdlSoapBindingPtr soapBind = binding->bindingAttributes;
! 3456: if (soapBind) {
! 3457: free(soapBind);
! 3458: }
! 3459: }
! 3460: free(binding);
! 3461: }
! 3462:
! 3463: static void delete_sdl_soap_binding_function_body(sdlSoapBindingFunctionBody body)
! 3464: {
! 3465: if (body.ns) {
! 3466: efree(body.ns);
! 3467: }
! 3468: if (body.headers) {
! 3469: zend_hash_destroy(body.headers);
! 3470: efree(body.headers);
! 3471: }
! 3472: }
! 3473:
! 3474: static void delete_sdl_soap_binding_function_body_persistent(sdlSoapBindingFunctionBody body)
! 3475: {
! 3476: if (body.ns) {
! 3477: free(body.ns);
! 3478: }
! 3479: if (body.headers) {
! 3480: zend_hash_destroy(body.headers);
! 3481: free(body.headers);
! 3482: }
! 3483: }
! 3484:
! 3485: static void delete_function(void *data)
! 3486: {
! 3487: sdlFunctionPtr function = *((sdlFunctionPtr*)data);
! 3488:
! 3489: if (function->functionName) {
! 3490: efree(function->functionName);
! 3491: }
! 3492: if (function->requestName) {
! 3493: efree(function->requestName);
! 3494: }
! 3495: if (function->responseName) {
! 3496: efree(function->responseName);
! 3497: }
! 3498: if (function->requestParameters) {
! 3499: zend_hash_destroy(function->requestParameters);
! 3500: efree(function->requestParameters);
! 3501: }
! 3502: if (function->responseParameters) {
! 3503: zend_hash_destroy(function->responseParameters);
! 3504: efree(function->responseParameters);
! 3505: }
! 3506: if (function->faults) {
! 3507: zend_hash_destroy(function->faults);
! 3508: efree(function->faults);
! 3509: }
! 3510:
! 3511: if (function->bindingAttributes &&
! 3512: function->binding && function->binding->bindingType == BINDING_SOAP) {
! 3513: sdlSoapBindingFunctionPtr soapFunction = function->bindingAttributes;
! 3514: if (soapFunction->soapAction) {
! 3515: efree(soapFunction->soapAction);
! 3516: }
! 3517: delete_sdl_soap_binding_function_body(soapFunction->input);
! 3518: delete_sdl_soap_binding_function_body(soapFunction->output);
! 3519: efree(soapFunction);
! 3520: }
! 3521: efree(function);
! 3522: }
! 3523:
! 3524: static void delete_function_persistent(void *data)
! 3525: {
! 3526: sdlFunctionPtr function = *((sdlFunctionPtr*)data);
! 3527:
! 3528: if (function->functionName) {
! 3529: free(function->functionName);
! 3530: }
! 3531: if (function->requestName) {
! 3532: free(function->requestName);
! 3533: }
! 3534: if (function->responseName) {
! 3535: free(function->responseName);
! 3536: }
! 3537: if (function->requestParameters) {
! 3538: zend_hash_destroy(function->requestParameters);
! 3539: free(function->requestParameters);
! 3540: }
! 3541: if (function->responseParameters) {
! 3542: zend_hash_destroy(function->responseParameters);
! 3543: free(function->responseParameters);
! 3544: }
! 3545: if (function->faults) {
! 3546: zend_hash_destroy(function->faults);
! 3547: free(function->faults);
! 3548: }
! 3549:
! 3550: if (function->bindingAttributes &&
! 3551: function->binding && function->binding->bindingType == BINDING_SOAP) {
! 3552: sdlSoapBindingFunctionPtr soapFunction = function->bindingAttributes;
! 3553: if (soapFunction->soapAction) {
! 3554: free(soapFunction->soapAction);
! 3555: }
! 3556: delete_sdl_soap_binding_function_body_persistent(soapFunction->input);
! 3557: delete_sdl_soap_binding_function_body_persistent(soapFunction->output);
! 3558: free(soapFunction);
! 3559: }
! 3560: free(function);
! 3561: }
! 3562:
! 3563: static void delete_parameter(void *data)
! 3564: {
! 3565: sdlParamPtr param = *((sdlParamPtr*)data);
! 3566: if (param->paramName) {
! 3567: efree(param->paramName);
! 3568: }
! 3569: efree(param);
! 3570: }
! 3571:
! 3572: static void delete_parameter_persistent(void *data)
! 3573: {
! 3574: sdlParamPtr param = *((sdlParamPtr*)data);
! 3575: if (param->paramName) {
! 3576: free(param->paramName);
! 3577: }
! 3578: free(param);
! 3579: }
! 3580:
! 3581: static void delete_header(void *data)
! 3582: {
! 3583: sdlSoapBindingFunctionHeaderPtr hdr = *((sdlSoapBindingFunctionHeaderPtr*)data);
! 3584: if (hdr->name) {
! 3585: efree(hdr->name);
! 3586: }
! 3587: if (hdr->ns) {
! 3588: efree(hdr->ns);
! 3589: }
! 3590: if (hdr->headerfaults) {
! 3591: zend_hash_destroy(hdr->headerfaults);
! 3592: efree(hdr->headerfaults);
! 3593: }
! 3594: efree(hdr);
! 3595: }
! 3596:
! 3597: static void delete_header_persistent(void *data)
! 3598: {
! 3599: sdlSoapBindingFunctionHeaderPtr hdr = *((sdlSoapBindingFunctionHeaderPtr*)data);
! 3600: if (hdr->name) {
! 3601: free(hdr->name);
! 3602: }
! 3603: if (hdr->ns) {
! 3604: free(hdr->ns);
! 3605: }
! 3606: if (hdr->headerfaults) {
! 3607: zend_hash_destroy(hdr->headerfaults);
! 3608: free(hdr->headerfaults);
! 3609: }
! 3610: free(hdr);
! 3611: }
! 3612:
! 3613: static void delete_fault(void *data)
! 3614: {
! 3615: sdlFaultPtr fault = *((sdlFaultPtr*)data);
! 3616: if (fault->name) {
! 3617: efree(fault->name);
! 3618: }
! 3619: if (fault->details) {
! 3620: zend_hash_destroy(fault->details);
! 3621: efree(fault->details);
! 3622: }
! 3623: if (fault->bindingAttributes) {
! 3624: sdlSoapBindingFunctionFaultPtr binding = (sdlSoapBindingFunctionFaultPtr)fault->bindingAttributes;
! 3625:
! 3626: if (binding->ns) {
! 3627: efree(binding->ns);
! 3628: }
! 3629: efree(fault->bindingAttributes);
! 3630: }
! 3631: efree(fault);
! 3632: }
! 3633:
! 3634: static void delete_fault_persistent(void *data)
! 3635: {
! 3636: sdlFaultPtr fault = *((sdlFaultPtr*)data);
! 3637: if (fault->name) {
! 3638: free(fault->name);
! 3639: }
! 3640: if (fault->details) {
! 3641: zend_hash_destroy(fault->details);
! 3642: free(fault->details);
! 3643: }
! 3644: if (fault->bindingAttributes) {
! 3645: sdlSoapBindingFunctionFaultPtr binding = (sdlSoapBindingFunctionFaultPtr)fault->bindingAttributes;
! 3646:
! 3647: if (binding->ns) {
! 3648: free(binding->ns);
! 3649: }
! 3650: free(fault->bindingAttributes);
! 3651: }
! 3652: free(fault);
! 3653: }
! 3654:
! 3655: static void delete_document(void *doc_ptr)
! 3656: {
! 3657: xmlDocPtr doc = *((xmlDocPtr*)doc_ptr);
! 3658: xmlFreeDoc(doc);
! 3659: }
! 3660:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to php_sdl.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / soap