1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 5 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1997-2016 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$ */
21
22 #include "php_soap.h"
23 #include "libxml/uri.h"
24
25 static int schema_simpleType(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr simpleType, sdlTypePtr cur_type);
26 static int schema_complexType(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr compType, sdlTypePtr cur_type);
27 static int schema_list(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr listType, sdlTypePtr cur_type);
28 static int schema_union(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr unionType, sdlTypePtr cur_type);
29 static int schema_simpleContent(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr simpCompType, sdlTypePtr cur_type);
30 static int schema_restriction_simpleContent(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr restType, sdlTypePtr cur_type, int simpleType);
31 static int schema_restriction_complexContent(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr restType, sdlTypePtr cur_type);
32 static int schema_extension_simpleContent(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr extType, sdlTypePtr cur_type);
33 static int schema_extension_complexContent(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr extType, sdlTypePtr cur_type);
34 static int schema_sequence(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr seqType, sdlTypePtr cur_type, sdlContentModelPtr model);
35 static int schema_all(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr extType, sdlTypePtr cur_type, sdlContentModelPtr model);
36 static int schema_choice(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr choiceType, sdlTypePtr cur_type, sdlContentModelPtr model);
37 static int schema_group(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr groupType, sdlTypePtr cur_type, sdlContentModelPtr model);
38 static int schema_any(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr extType, sdlTypePtr cur_type, sdlContentModelPtr model);
39 static int schema_element(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr element, sdlTypePtr cur_type, sdlContentModelPtr model);
40 static int schema_attribute(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr attrType, sdlTypePtr cur_type, sdlCtx *ctx);
41 static int schema_attributeGroup(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr attrType, sdlTypePtr cur_type, sdlCtx *ctx);
42
43 static int schema_restriction_var_int(xmlNodePtr val, sdlRestrictionIntPtr *valptr);
44
45 static int schema_restriction_var_char(xmlNodePtr val, sdlRestrictionCharPtr *valptr);
46
47 static void schema_type_fixup(sdlCtx *ctx, sdlTypePtr type);
48
create_encoder(sdlPtr sdl,sdlTypePtr cur_type,const xmlChar * ns,const xmlChar * type)49 static encodePtr create_encoder(sdlPtr sdl, sdlTypePtr cur_type, const xmlChar *ns, const xmlChar *type)
50 {
51 smart_str nscat = {0};
52 encodePtr enc, *enc_ptr;
53
54 if (sdl->encoders == NULL) {
55 sdl->encoders = emalloc(sizeof(HashTable));
56 zend_hash_init(sdl->encoders, 0, NULL, delete_encoder, 0);
57 }
58 smart_str_appends(&nscat, (char*)ns);
59 smart_str_appendc(&nscat, ':');
60 smart_str_appends(&nscat, (char*)type);
61 smart_str_0(&nscat);
62 if (zend_hash_find(sdl->encoders, nscat.c, nscat.len + 1, (void**)&enc_ptr) == SUCCESS) {
63 enc = *enc_ptr;
64 if (enc->details.ns) {
65 efree(enc->details.ns);
66 }
67 if (enc->details.type_str) {
68 efree(enc->details.type_str);
69 }
70 } else {
71 enc_ptr = NULL;
72 enc = emalloc(sizeof(encode));
73 }
74 memset(enc, 0, sizeof(encode));
75
76 enc->details.ns = estrdup((char*)ns);
77 enc->details.type_str = estrdup((char*)type);
78 enc->details.sdl_type = cur_type;
79 enc->to_xml = sdl_guess_convert_xml;
80 enc->to_zval = sdl_guess_convert_zval;
81
82 if (enc_ptr == NULL) {
83 zend_hash_update(sdl->encoders, nscat.c, nscat.len + 1, &enc, sizeof(encodePtr), NULL);
84 }
85 smart_str_free(&nscat);
86 return enc;
87 }
88
get_create_encoder(sdlPtr sdl,sdlTypePtr cur_type,const xmlChar * ns,const xmlChar * type)89 static encodePtr get_create_encoder(sdlPtr sdl, sdlTypePtr cur_type, const xmlChar *ns, const xmlChar *type)
90 {
91 encodePtr enc = get_encoder(sdl, (char*)ns, (char*)type);
92 if (enc == NULL) {
93 enc = create_encoder(sdl, cur_type, ns, type);
94 }
95 return enc;
96 }
97
schema_load_file(sdlCtx * ctx,xmlAttrPtr ns,xmlChar * location,xmlAttrPtr tns,int import TSRMLS_DC)98 static void schema_load_file(sdlCtx *ctx, xmlAttrPtr ns, xmlChar *location, xmlAttrPtr tns, int import TSRMLS_DC) {
99 if (location != NULL &&
100 !zend_hash_exists(&ctx->docs, (char*)location, xmlStrlen(location)+1)) {
101 xmlDocPtr doc;
102 xmlNodePtr schema;
103 xmlAttrPtr new_tns;
104
105 sdl_set_uri_credentials(ctx, (char*)location TSRMLS_CC);
106 doc = soap_xmlParseFile((char*)location TSRMLS_CC);
107 sdl_restore_uri_credentials(ctx TSRMLS_CC);
108
109 if (doc == NULL) {
110 soap_error1(E_ERROR, "Parsing Schema: can't import schema from '%s'", location);
111 }
112 schema = get_node(doc->children, "schema");
113 if (schema == NULL) {
114 xmlFreeDoc(doc);
115 soap_error1(E_ERROR, "Parsing Schema: can't import schema from '%s'", location);
116 }
117 new_tns = get_attribute(schema->properties, "targetNamespace");
118 if (import) {
119 if (ns != NULL && (new_tns == NULL || xmlStrcmp(ns->children->content, new_tns->children->content) != 0)) {
120 xmlFreeDoc(doc);
121 soap_error2(E_ERROR, "Parsing Schema: can't import schema from '%s', unexpected 'targetNamespace'='%s'", location, ns->children->content);
122 }
123 if (ns == NULL && new_tns != NULL) {
124 xmlFreeDoc(doc);
125 soap_error2(E_ERROR, "Parsing Schema: can't import schema from '%s', unexpected 'targetNamespace'='%s'", location, new_tns->children->content);
126 }
127 } else {
128 new_tns = get_attribute(schema->properties, "targetNamespace");
129 if (new_tns == NULL) {
130 if (tns != NULL) {
131 xmlSetProp(schema, BAD_CAST("targetNamespace"), tns->children->content);
132 }
133 } else if (tns != NULL && xmlStrcmp(tns->children->content, new_tns->children->content) != 0) {
134 xmlFreeDoc(doc);
135 soap_error1(E_ERROR, "Parsing Schema: can't include schema from '%s', different 'targetNamespace'", location);
136 }
137 }
138 zend_hash_add(&ctx->docs, (char*)location, xmlStrlen(location)+1, (void**)&doc, sizeof(xmlDocPtr), NULL);
139 load_schema(ctx, schema TSRMLS_CC);
140 }
141 }
142
143 /*
144 2.6.1 xsi:type
145 2.6.2 xsi:nil
146 2.6.3 xsi:schemaLocation, xsi:noNamespaceSchemaLocation
147 */
148
149 /*
150 <schema
151 attributeFormDefault = (qualified | unqualified) : unqualified
152 blockDefault = (#all | List of (extension | restriction | substitution)) : ''
153 elementFormDefault = (qualified | unqualified) : unqualified
154 finalDefault = (#all | List of (extension | restriction)) : ''
155 id = ID
156 targetNamespace = anyURI
157 version = token
158 xml:lang = language
159 {any attributes with non-schema namespace . . .}>
160 Content: ((include | import | redefine | annotation)*, (((simpleType | complexType | group | attributeGroup) | element | attribute | notation), annotation*)*)
161 </schema>
162 */
load_schema(sdlCtx * ctx,xmlNodePtr schema TSRMLS_DC)163 int load_schema(sdlCtx *ctx, xmlNodePtr schema TSRMLS_DC)
164 {
165 xmlNodePtr trav;
166 xmlAttrPtr tns;
167
168 if (!ctx->sdl->types) {
169 ctx->sdl->types = emalloc(sizeof(HashTable));
170 zend_hash_init(ctx->sdl->types, 0, NULL, delete_type, 0);
171 }
172 if (!ctx->attributes) {
173 ctx->attributes = emalloc(sizeof(HashTable));
174 zend_hash_init(ctx->attributes, 0, NULL, delete_attribute, 0);
175 }
176 if (!ctx->attributeGroups) {
177 ctx->attributeGroups = emalloc(sizeof(HashTable));
178 zend_hash_init(ctx->attributeGroups, 0, NULL, delete_type, 0);
179 }
180
181 tns = get_attribute(schema->properties, "targetNamespace");
182 if (tns == NULL) {
183 tns = xmlSetProp(schema, BAD_CAST("targetNamespace"), BAD_CAST(""));
184 xmlNewNs(schema, BAD_CAST(""), NULL);
185 }
186
187 trav = schema->children;
188 while (trav != NULL) {
189 if (node_is_equal(trav,"include")) {
190 xmlAttrPtr location;
191
192 location = get_attribute(trav->properties, "schemaLocation");
193 if (location == NULL) {
194 soap_error0(E_ERROR, "Parsing Schema: include has no 'schemaLocation' attribute");
195 } else {
196 xmlChar *uri;
197 xmlChar *base = xmlNodeGetBase(trav->doc, trav);
198
199 if (base == NULL) {
200 uri = xmlBuildURI(location->children->content, trav->doc->URL);
201 } else {
202 uri = xmlBuildURI(location->children->content, base);
203 xmlFree(base);
204 }
205 schema_load_file(ctx, NULL, uri, tns, 0 TSRMLS_CC);
206 xmlFree(uri);
207 }
208
209 } else if (node_is_equal(trav,"redefine")) {
210 xmlAttrPtr location;
211
212 location = get_attribute(trav->properties, "schemaLocation");
213 if (location == NULL) {
214 soap_error0(E_ERROR, "Parsing Schema: redefine has no 'schemaLocation' attribute");
215 } else {
216 xmlChar *uri;
217 xmlChar *base = xmlNodeGetBase(trav->doc, trav);
218
219 if (base == NULL) {
220 uri = xmlBuildURI(location->children->content, trav->doc->URL);
221 } else {
222 uri = xmlBuildURI(location->children->content, base);
223 xmlFree(base);
224 }
225 schema_load_file(ctx, NULL, uri, tns, 0 TSRMLS_CC);
226 xmlFree(uri);
227 /* TODO: <redefine> support */
228 }
229
230 } else if (node_is_equal(trav,"import")) {
231 xmlAttrPtr ns, location;
232 xmlChar *uri = NULL;
233
234 ns = get_attribute(trav->properties, "namespace");
235 location = get_attribute(trav->properties, "schemaLocation");
236
237 if (ns != NULL && tns != NULL && xmlStrcmp(ns->children->content, tns->children->content) == 0) {
238 if (location) {
239 soap_error1(E_ERROR, "Parsing Schema: can't import schema from '%s', namespace must not match the enclosing schema 'targetNamespace'", location->children->content);
240 } else {
241 soap_error0(E_ERROR, "Parsing Schema: can't import schema. Namespace must not match the enclosing schema 'targetNamespace'");
242 }
243 }
244 if (location) {
245 xmlChar *base = xmlNodeGetBase(trav->doc, trav);
246
247 if (base == NULL) {
248 uri = xmlBuildURI(location->children->content, trav->doc->URL);
249 } else {
250 uri = xmlBuildURI(location->children->content, base);
251 xmlFree(base);
252 }
253 }
254 schema_load_file(ctx, ns, uri, tns, 1 TSRMLS_CC);
255 if (uri != NULL) {xmlFree(uri);}
256 } else if (node_is_equal(trav,"annotation")) {
257 /* TODO: <annotation> support */
258 /* annotation cleanup
259 xmlNodePtr tmp = trav;
260 trav = trav->next;
261 xmlUnlinkNode(tmp);
262 xmlFreeNode(tmp);
263 continue;
264 */
265 } else {
266 break;
267 }
268 trav = trav->next;
269 }
270
271 while (trav != NULL) {
272 if (node_is_equal(trav,"simpleType")) {
273 schema_simpleType(ctx->sdl, tns, trav, NULL);
274 } else if (node_is_equal(trav,"complexType")) {
275 schema_complexType(ctx->sdl, tns, trav, NULL);
276 } else if (node_is_equal(trav,"group")) {
277 schema_group(ctx->sdl, tns, trav, NULL, NULL);
278 } else if (node_is_equal(trav,"attributeGroup")) {
279 schema_attributeGroup(ctx->sdl, tns, trav, NULL, ctx);
280 } else if (node_is_equal(trav,"element")) {
281 schema_element(ctx->sdl, tns, trav, NULL, NULL);
282 } else if (node_is_equal(trav,"attribute")) {
283 schema_attribute(ctx->sdl, tns, trav, NULL, ctx);
284 } else if (node_is_equal(trav,"notation")) {
285 /* TODO: <notation> support */
286 } else if (node_is_equal(trav,"annotation")) {
287 /* TODO: <annotation> support */
288 } else {
289 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in schema", trav->name);
290 }
291 trav = trav->next;
292 }
293 return TRUE;
294 }
295
296 /*
297 <simpleType
298 final = (#all | (list | union | restriction))
299 id = ID
300 name = NCName
301 {any attributes with non-schema namespace . . .}>
302 Content: (annotation?, (restriction | list | union))
303 </simpleType>
304 */
schema_simpleType(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr simpleType,sdlTypePtr cur_type)305 static int schema_simpleType(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr simpleType, sdlTypePtr cur_type)
306 {
307 xmlNodePtr trav;
308 xmlAttrPtr name, ns;
309
310 ns = get_attribute(simpleType->properties, "targetNamespace");
311 if (ns == NULL) {
312 ns = tns;
313 }
314
315 name = get_attribute(simpleType->properties, "name");
316 if (cur_type != NULL) {
317 /* Anonymous type inside <element> or <restriction> */
318 sdlTypePtr newType, *ptr;
319
320 newType = emalloc(sizeof(sdlType));
321 memset(newType, 0, sizeof(sdlType));
322 newType->kind = XSD_TYPEKIND_SIMPLE;
323 if (name != NULL) {
324 newType->name = estrdup((char*)name->children->content);
325 newType->namens = estrdup((char*)ns->children->content);
326 } else {
327 newType->name = estrdup(cur_type->name);
328 newType->namens = estrdup(cur_type->namens);
329 }
330
331 zend_hash_next_index_insert(sdl->types, &newType, sizeof(sdlTypePtr), (void **)&ptr);
332
333 if (sdl->encoders == NULL) {
334 sdl->encoders = emalloc(sizeof(HashTable));
335 zend_hash_init(sdl->encoders, 0, NULL, delete_encoder, 0);
336 }
337 cur_type->encode = emalloc(sizeof(encode));
338 memset(cur_type->encode, 0, sizeof(encode));
339 cur_type->encode->details.ns = estrdup(newType->namens);
340 cur_type->encode->details.type_str = estrdup(newType->name);
341 cur_type->encode->details.sdl_type = *ptr;
342 cur_type->encode->to_xml = sdl_guess_convert_xml;
343 cur_type->encode->to_zval = sdl_guess_convert_zval;
344 zend_hash_next_index_insert(sdl->encoders, &cur_type->encode, sizeof(encodePtr), NULL);
345
346 cur_type =*ptr;
347
348 } else if (name != NULL) {
349 sdlTypePtr newType, *ptr;
350
351 newType = emalloc(sizeof(sdlType));
352 memset(newType, 0, sizeof(sdlType));
353 newType->kind = XSD_TYPEKIND_SIMPLE;
354 newType->name = estrdup((char*)name->children->content);
355 newType->namens = estrdup((char*)ns->children->content);
356
357 if (cur_type == NULL) {
358 zend_hash_next_index_insert(sdl->types, &newType, sizeof(sdlTypePtr), (void **)&ptr);
359 } else {
360 if (cur_type->elements == NULL) {
361 cur_type->elements = emalloc(sizeof(HashTable));
362 zend_hash_init(cur_type->elements, 0, NULL, delete_type, 0);
363 }
364 zend_hash_update(cur_type->elements, newType->name, strlen(newType->name)+1, &newType, sizeof(sdlTypePtr), (void **)&ptr);
365 }
366 cur_type = (*ptr);
367
368 create_encoder(sdl, cur_type, ns->children->content, name->children->content);
369 } else {
370 soap_error0(E_ERROR, "Parsing Schema: simpleType has no 'name' attribute");
371 }
372
373 trav = simpleType->children;
374 if (trav != NULL && node_is_equal(trav,"annotation")) {
375 /* TODO: <annotation> support */
376 trav = trav->next;
377 }
378 if (trav != NULL) {
379 if (node_is_equal(trav,"restriction")) {
380 schema_restriction_simpleContent(sdl, tns, trav, cur_type, 1);
381 trav = trav->next;
382 } else if (node_is_equal(trav,"list")) {
383 cur_type->kind = XSD_TYPEKIND_LIST;
384 schema_list(sdl, tns, trav, cur_type);
385 trav = trav->next;
386 } else if (node_is_equal(trav,"union")) {
387 cur_type->kind = XSD_TYPEKIND_UNION;
388 schema_union(sdl, tns, trav, cur_type);
389 trav = trav->next;
390 } else {
391 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in simpleType", trav->name);
392 }
393 } else {
394 soap_error0(E_ERROR, "Parsing Schema: expected <restriction>, <list> or <union> in simpleType");
395 }
396 if (trav != NULL) {
397 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in simpleType", trav->name);
398 }
399
400 return TRUE;
401 }
402
403 /*
404 <list
405 id = ID
406 itemType = QName
407 {any attributes with non-schema namespace . . .}>
408 Content: (annotation?, (simpleType?))
409 </list>
410 */
schema_list(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr listType,sdlTypePtr cur_type)411 static int schema_list(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr listType, sdlTypePtr cur_type)
412 {
413 xmlNodePtr trav;
414 xmlAttrPtr itemType;
415
416 itemType = get_attribute(listType->properties, "itemType");
417 if (itemType != NULL) {
418 char *type, *ns;
419 xmlNsPtr nsptr;
420
421 parse_namespace(itemType->children->content, &type, &ns);
422 nsptr = xmlSearchNs(listType->doc, listType, BAD_CAST(ns));
423 if (nsptr != NULL) {
424 sdlTypePtr newType, *tmp;
425
426 newType = emalloc(sizeof(sdlType));
427 memset(newType, 0, sizeof(sdlType));
428
429 newType->name = estrdup(type);
430 newType->namens = estrdup((char*)nsptr->href);
431
432 newType->encode = get_create_encoder(sdl, newType, nsptr->href, BAD_CAST(type));
433
434 if (cur_type->elements == NULL) {
435 cur_type->elements = emalloc(sizeof(HashTable));
436 zend_hash_init(cur_type->elements, 0, NULL, delete_type, 0);
437 }
438 zend_hash_next_index_insert(cur_type->elements, &newType, sizeof(sdlTypePtr), (void **)&tmp);
439 }
440 if (type) {efree(type);}
441 if (ns) {efree(ns);}
442 }
443
444 trav = listType->children;
445 if (trav != NULL && node_is_equal(trav,"annotation")) {
446 /* TODO: <annotation> support */
447 trav = trav->next;
448 }
449 if (trav != NULL && node_is_equal(trav,"simpleType")) {
450 sdlTypePtr newType, *tmp;
451
452 if (itemType != NULL) {
453 soap_error0(E_ERROR, "Parsing Schema: element has both 'itemType' attribute and subtype");
454 }
455
456 newType = emalloc(sizeof(sdlType));
457 memset(newType, 0, sizeof(sdlType));
458
459 {
460 smart_str anonymous = {0};
461
462 smart_str_appendl(&anonymous, "anonymous", sizeof("anonymous")-1);
463 smart_str_append_long(&anonymous, zend_hash_num_elements(sdl->types));
464 smart_str_0(&anonymous);
465 newType->name = anonymous.c;
466 }
467 newType->namens = estrdup((char*)tns->children->content);
468
469 if (cur_type->elements == NULL) {
470 cur_type->elements = emalloc(sizeof(HashTable));
471 zend_hash_init(cur_type->elements, 0, NULL, delete_type, 0);
472 }
473 zend_hash_next_index_insert(cur_type->elements, &newType, sizeof(sdlTypePtr), (void **)&tmp);
474
475 schema_simpleType(sdl, tns, trav, newType);
476
477 trav = trav->next;
478 }
479 if (trav != NULL) {
480 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in list", trav->name);
481 }
482 return TRUE;
483 }
484
485 /*
486 <union
487 id = ID
488 memberTypes = List of QName
489 {any attributes with non-schema namespace . . .}>
490 Content: (annotation?, (simpleType*))
491 </union>
492 */
schema_union(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr unionType,sdlTypePtr cur_type)493 static int schema_union(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr unionType, sdlTypePtr cur_type)
494 {
495 xmlNodePtr trav;
496 xmlAttrPtr memberTypes;
497
498 memberTypes = get_attribute(unionType->properties, "memberTypes");
499 if (memberTypes != NULL) {
500 char *str, *start, *end, *next;
501 char *type, *ns;
502 xmlNsPtr nsptr;
503
504 str = estrdup((char*)memberTypes->children->content);
505 whiteSpace_collapse(BAD_CAST(str));
506 start = str;
507 while (start != NULL && *start != '\0') {
508 end = strchr(start,' ');
509 if (end == NULL) {
510 next = NULL;
511 } else {
512 *end = '\0';
513 next = end+1;
514 }
515
516 parse_namespace(BAD_CAST(start), &type, &ns);
517 nsptr = xmlSearchNs(unionType->doc, unionType, BAD_CAST(ns));
518 if (nsptr != NULL) {
519 sdlTypePtr newType, *tmp;
520
521 newType = emalloc(sizeof(sdlType));
522 memset(newType, 0, sizeof(sdlType));
523
524 newType->name = estrdup(type);
525 newType->namens = estrdup((char*)nsptr->href);
526
527 newType->encode = get_create_encoder(sdl, newType, nsptr->href, BAD_CAST(type));
528
529 if (cur_type->elements == NULL) {
530 cur_type->elements = emalloc(sizeof(HashTable));
531 zend_hash_init(cur_type->elements, 0, NULL, delete_type, 0);
532 }
533 zend_hash_next_index_insert(cur_type->elements, &newType, sizeof(sdlTypePtr), (void **)&tmp);
534 }
535 if (type) {efree(type);}
536 if (ns) {efree(ns);}
537
538 start = next;
539 }
540 efree(str);
541 }
542
543 trav = unionType->children;
544 if (trav != NULL && node_is_equal(trav,"annotation")) {
545 /* TODO: <annotation> support */
546 trav = trav->next;
547 }
548 while (trav != NULL) {
549 if (node_is_equal(trav,"simpleType")) {
550 sdlTypePtr newType, *tmp;
551
552 newType = emalloc(sizeof(sdlType));
553 memset(newType, 0, sizeof(sdlType));
554
555 {
556 smart_str anonymous = {0};
557
558 smart_str_appendl(&anonymous, "anonymous", sizeof("anonymous")-1);
559 smart_str_append_long(&anonymous, zend_hash_num_elements(sdl->types));
560 smart_str_0(&anonymous);
561 newType->name = anonymous.c;
562 }
563 newType->namens = estrdup((char*)tns->children->content);
564
565 if (cur_type->elements == NULL) {
566 cur_type->elements = emalloc(sizeof(HashTable));
567 zend_hash_init(cur_type->elements, 0, NULL, delete_type, 0);
568 }
569 zend_hash_next_index_insert(cur_type->elements, &newType, sizeof(sdlTypePtr), (void **)&tmp);
570
571 schema_simpleType(sdl, tns, trav, newType);
572
573 } else {
574 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in union", trav->name);
575 }
576 trav = trav->next;
577 }
578 if (trav != NULL) {
579 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in union", trav->name);
580 }
581 return TRUE;
582 }
583
584 /*
585 <simpleContent
586 id = ID
587 {any attributes with non-schema namespace . . .}>
588 Content: (annotation?, (restriction | extension))
589 </simpleContent>
590 */
schema_simpleContent(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr simpCompType,sdlTypePtr cur_type)591 static int schema_simpleContent(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr simpCompType, sdlTypePtr cur_type)
592 {
593 xmlNodePtr trav;
594
595 trav = simpCompType->children;
596 if (trav != NULL && node_is_equal(trav,"annotation")) {
597 /* TODO: <annotation> support */
598 trav = trav->next;
599 }
600 if (trav != NULL) {
601 if (node_is_equal(trav, "restriction")) {
602 cur_type->kind = XSD_TYPEKIND_RESTRICTION;
603 schema_restriction_simpleContent(sdl, tns, trav, cur_type, 0);
604 trav = trav->next;
605 } else if (node_is_equal(trav, "extension")) {
606 cur_type->kind = XSD_TYPEKIND_EXTENSION;
607 schema_extension_simpleContent(sdl, tns, trav, cur_type);
608 trav = trav->next;
609 } else {
610 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in simpleContent", trav->name);
611 }
612 } else {
613 soap_error0(E_ERROR, "Parsing Schema: expected <restriction> or <extension> in simpleContent");
614 }
615 if (trav != NULL) {
616 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in simpleContent", trav->name);
617 }
618
619 return TRUE;
620 }
621
622 /*
623 simpleType:<restriction
624 base = QName
625 id = ID
626 {any attributes with non-schema namespace . . .}>
627 Content: (annotation?, (simpleType?, (minExclusive | minInclusive | maxExclusive | maxInclusive | totalDigits | fractionDigits | length | minLength | maxLength | enumeration | whiteSpace | pattern)*)?)
628 </restriction>
629 simpleContent:<restriction
630 base = QName
631 id = ID
632 {any attributes with non-schema namespace . . .}>
633 Content: (annotation?, (simpleType?, (minExclusive | minInclusive | maxExclusive | maxInclusive | totalDigits | fractionDigits | length | minLength | maxLength | enumeration | whiteSpace | pattern)*)?, ((attribute | attributeGroup)*, anyAttribute?))
634 </restriction>
635 */
schema_restriction_simpleContent(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr restType,sdlTypePtr cur_type,int simpleType)636 static int schema_restriction_simpleContent(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr restType, sdlTypePtr cur_type, int simpleType)
637 {
638 xmlNodePtr trav;
639 xmlAttrPtr base;
640
641 base = get_attribute(restType->properties, "base");
642 if (base != NULL) {
643 char *type, *ns;
644 xmlNsPtr nsptr;
645
646 parse_namespace(base->children->content, &type, &ns);
647 nsptr = xmlSearchNs(restType->doc, restType, BAD_CAST(ns));
648 if (nsptr != NULL) {
649 cur_type->encode = get_create_encoder(sdl, cur_type, nsptr->href, BAD_CAST(type));
650 }
651 if (type) {efree(type);}
652 if (ns) {efree(ns);}
653 } else if (!simpleType) {
654 soap_error0(E_ERROR, "Parsing Schema: restriction has no 'base' attribute");
655 }
656
657 if (cur_type->restrictions == NULL) {
658 cur_type->restrictions = emalloc(sizeof(sdlRestrictions));
659 memset(cur_type->restrictions, 0, sizeof(sdlRestrictions));
660 }
661
662 trav = restType->children;
663 if (trav != NULL && node_is_equal(trav, "annotation")) {
664 /* TODO: <annotation> support */
665 trav = trav->next;
666 }
667 if (trav != NULL && node_is_equal(trav, "simpleType")) {
668 schema_simpleType(sdl, tns, trav, cur_type);
669 trav = trav->next;
670 }
671 while (trav != NULL) {
672 if (node_is_equal(trav, "minExclusive")) {
673 schema_restriction_var_int(trav, &cur_type->restrictions->minExclusive);
674 } else if (node_is_equal(trav, "minInclusive")) {
675 schema_restriction_var_int(trav, &cur_type->restrictions->minInclusive);
676 } else if (node_is_equal(trav, "maxExclusive")) {
677 schema_restriction_var_int(trav, &cur_type->restrictions->maxExclusive);
678 } else if (node_is_equal(trav, "maxInclusive")) {
679 schema_restriction_var_int(trav, &cur_type->restrictions->maxInclusive);
680 } else if (node_is_equal(trav, "totalDigits")) {
681 schema_restriction_var_int(trav, &cur_type->restrictions->totalDigits);
682 } else if (node_is_equal(trav, "fractionDigits")) {
683 schema_restriction_var_int(trav, &cur_type->restrictions->fractionDigits);
684 } else if (node_is_equal(trav, "length")) {
685 schema_restriction_var_int(trav, &cur_type->restrictions->length);
686 } else if (node_is_equal(trav, "minLength")) {
687 schema_restriction_var_int(trav, &cur_type->restrictions->minLength);
688 } else if (node_is_equal(trav, "maxLength")) {
689 schema_restriction_var_int(trav, &cur_type->restrictions->maxLength);
690 } else if (node_is_equal(trav, "whiteSpace")) {
691 schema_restriction_var_char(trav, &cur_type->restrictions->whiteSpace);
692 } else if (node_is_equal(trav, "pattern")) {
693 schema_restriction_var_char(trav, &cur_type->restrictions->pattern);
694 } else if (node_is_equal(trav, "enumeration")) {
695 sdlRestrictionCharPtr enumval = NULL;
696
697 schema_restriction_var_char(trav, &enumval);
698 if (cur_type->restrictions->enumeration == NULL) {
699 cur_type->restrictions->enumeration = emalloc(sizeof(HashTable));
700 zend_hash_init(cur_type->restrictions->enumeration, 0, NULL, delete_restriction_var_char, 0);
701 }
702 if (zend_hash_add(cur_type->restrictions->enumeration, enumval->value, strlen(enumval->value)+1, &enumval, sizeof(sdlRestrictionCharPtr), NULL) == FAILURE) {
703 delete_restriction_var_char(&enumval);
704 }
705 } else {
706 break;
707 }
708 trav = trav->next;
709 }
710 if (!simpleType) {
711 while (trav != NULL) {
712 if (node_is_equal(trav,"attribute")) {
713 schema_attribute(sdl, tns, trav, cur_type, NULL);
714 } else if (node_is_equal(trav,"attributeGroup")) {
715 schema_attributeGroup(sdl, tns, trav, cur_type, NULL);
716 } else if (node_is_equal(trav,"anyAttribute")) {
717 /* TODO: <anyAttribute> support */
718 trav = trav->next;
719 break;
720 } else {
721 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in restriction", trav->name);
722 }
723 trav = trav->next;
724 }
725 }
726 if (trav != NULL) {
727 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in restriction", trav->name);
728 }
729
730 return TRUE;
731 }
732
733 /*
734 <restriction
735 base = QName
736 id = ID
737 {any attributes with non-schema namespace . . .}>
738 Content: (annotation?, (group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?))
739 </restriction>
740 */
schema_restriction_complexContent(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr restType,sdlTypePtr cur_type)741 static int schema_restriction_complexContent(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr restType, sdlTypePtr cur_type)
742 {
743 xmlAttrPtr base;
744 xmlNodePtr trav;
745
746 base = get_attribute(restType->properties, "base");
747 if (base != NULL) {
748 char *type, *ns;
749 xmlNsPtr nsptr;
750
751 parse_namespace(base->children->content, &type, &ns);
752 nsptr = xmlSearchNs(restType->doc, restType, BAD_CAST(ns));
753 if (nsptr != NULL) {
754 cur_type->encode = get_create_encoder(sdl, cur_type, nsptr->href, BAD_CAST(type));
755 }
756 if (type) {efree(type);}
757 if (ns) {efree(ns);}
758 } else {
759 soap_error0(E_ERROR, "Parsing Schema: restriction has no 'base' attribute");
760 }
761
762 trav = restType->children;
763 if (trav != NULL && node_is_equal(trav,"annotation")) {
764 /* TODO: <annotation> support */
765 trav = trav->next;
766 }
767 if (trav != NULL) {
768 if (node_is_equal(trav,"group")) {
769 schema_group(sdl, tns, trav, cur_type, NULL);
770 trav = trav->next;
771 } else if (node_is_equal(trav,"all")) {
772 schema_all(sdl, tns, trav, cur_type, NULL);
773 trav = trav->next;
774 } else if (node_is_equal(trav,"choice")) {
775 schema_choice(sdl, tns, trav, cur_type, NULL);
776 trav = trav->next;
777 } else if (node_is_equal(trav,"sequence")) {
778 schema_sequence(sdl, tns, trav, cur_type, NULL);
779 trav = trav->next;
780 }
781 }
782 while (trav != NULL) {
783 if (node_is_equal(trav,"attribute")) {
784 schema_attribute(sdl, tns, trav, cur_type, NULL);
785 } else if (node_is_equal(trav,"attributeGroup")) {
786 schema_attributeGroup(sdl, tns, trav, cur_type, NULL);
787 } else if (node_is_equal(trav,"anyAttribute")) {
788 /* TODO: <anyAttribute> support */
789 trav = trav->next;
790 break;
791 } else {
792 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in restriction", trav->name);
793 }
794 trav = trav->next;
795 }
796 if (trav != NULL) {
797 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in restriction", trav->name);
798 }
799
800 return TRUE;
801 }
802
schema_restriction_var_int(xmlNodePtr val,sdlRestrictionIntPtr * valptr)803 static int schema_restriction_var_int(xmlNodePtr val, sdlRestrictionIntPtr *valptr)
804 {
805 xmlAttrPtr fixed, value;
806
807 if ((*valptr) == NULL) {
808 (*valptr) = emalloc(sizeof(sdlRestrictionInt));
809 }
810 memset((*valptr), 0, sizeof(sdlRestrictionInt));
811
812 fixed = get_attribute(val->properties, "fixed");
813 (*valptr)->fixed = FALSE;
814 if (fixed != NULL) {
815 if (!strncmp((char*)fixed->children->content, "true", sizeof("true")) ||
816 !strncmp((char*)fixed->children->content, "1", sizeof("1")))
817 (*valptr)->fixed = TRUE;
818 }
819
820 value = get_attribute(val->properties, "value");
821 if (value == NULL) {
822 soap_error0(E_ERROR, "Parsing Schema: missing restriction value");
823 }
824
825 (*valptr)->value = atoi((char*)value->children->content);
826
827 return TRUE;
828 }
829
schema_restriction_var_char(xmlNodePtr val,sdlRestrictionCharPtr * valptr)830 static int schema_restriction_var_char(xmlNodePtr val, sdlRestrictionCharPtr *valptr)
831 {
832 xmlAttrPtr fixed, value;
833
834 if ((*valptr) == NULL) {
835 (*valptr) = emalloc(sizeof(sdlRestrictionChar));
836 }
837 memset((*valptr), 0, sizeof(sdlRestrictionChar));
838
839 fixed = get_attribute(val->properties, "fixed");
840 (*valptr)->fixed = FALSE;
841 if (fixed != NULL) {
842 if (!strncmp((char*)fixed->children->content, "true", sizeof("true")) ||
843 !strncmp((char*)fixed->children->content, "1", sizeof("1"))) {
844 (*valptr)->fixed = TRUE;
845 }
846 }
847
848 value = get_attribute(val->properties, "value");
849 if (value == NULL) {
850 soap_error0(E_ERROR, "Parsing Schema: missing restriction value");
851 }
852
853 (*valptr)->value = estrdup((char*)value->children->content);
854 return TRUE;
855 }
856
857 /*
858 From simpleContent (not supported):
859 <extension
860 base = QName
861 id = ID
862 {any attributes with non-schema namespace . . .}>
863 Content: (annotation?, ((attribute | attributeGroup)*, anyAttribute?))
864 </extension>
865 */
schema_extension_simpleContent(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr extType,sdlTypePtr cur_type)866 static int schema_extension_simpleContent(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr extType, sdlTypePtr cur_type)
867 {
868 xmlNodePtr trav;
869 xmlAttrPtr base;
870
871 base = get_attribute(extType->properties, "base");
872 if (base != NULL) {
873 char *type, *ns;
874 xmlNsPtr nsptr;
875
876 parse_namespace(base->children->content, &type, &ns);
877 nsptr = xmlSearchNs(extType->doc, extType, BAD_CAST(ns));
878 if (nsptr != NULL) {
879 cur_type->encode = get_create_encoder(sdl, cur_type, nsptr->href, BAD_CAST(type));
880 }
881 if (type) {efree(type);}
882 if (ns) {efree(ns);}
883 } else {
884 soap_error0(E_ERROR, "Parsing Schema: extension has no 'base' attribute");
885 }
886
887 trav = extType->children;
888 if (trav != NULL && node_is_equal(trav,"annotation")) {
889 /* TODO: <annotation> support */
890 trav = trav->next;
891 }
892 while (trav != NULL) {
893 if (node_is_equal(trav,"attribute")) {
894 schema_attribute(sdl, tns, trav, cur_type, NULL);
895 } else if (node_is_equal(trav,"attributeGroup")) {
896 schema_attributeGroup(sdl, tns, trav, cur_type, NULL);
897 } else if (node_is_equal(trav,"anyAttribute")) {
898 /* TODO: <anyAttribute> support */
899 trav = trav->next;
900 break;
901 } else {
902 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in extension", trav->name);
903 }
904 trav = trav->next;
905 }
906 if (trav != NULL) {
907 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in extension", trav->name);
908 }
909 return TRUE;
910 }
911
912 /*
913 From complexContent:
914 <extension
915 base = QName
916 id = ID
917 {any attributes with non-schema namespace . . .}>
918 Content: (annotation?, ((group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?)))
919 </extension>
920 */
schema_extension_complexContent(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr extType,sdlTypePtr cur_type)921 static int schema_extension_complexContent(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr extType, sdlTypePtr cur_type)
922 {
923 xmlNodePtr trav;
924 xmlAttrPtr base;
925
926 base = get_attribute(extType->properties, "base");
927 if (base != NULL) {
928 char *type, *ns;
929 xmlNsPtr nsptr;
930
931 parse_namespace(base->children->content, &type, &ns);
932 nsptr = xmlSearchNs(extType->doc, extType, BAD_CAST(ns));
933 if (nsptr != NULL) {
934 cur_type->encode = get_create_encoder(sdl, cur_type, nsptr->href, BAD_CAST(type));
935 }
936 if (type) {efree(type);}
937 if (ns) {efree(ns);}
938 } else {
939 soap_error0(E_ERROR, "Parsing Schema: extension has no 'base' attribute");
940 }
941
942 trav = extType->children;
943 if (trav != NULL && node_is_equal(trav,"annotation")) {
944 /* TODO: <annotation> support */
945 trav = trav->next;
946 }
947 if (trav != NULL) {
948 if (node_is_equal(trav,"group")) {
949 schema_group(sdl, tns, trav, cur_type, NULL);
950 trav = trav->next;
951 } else if (node_is_equal(trav,"all")) {
952 schema_all(sdl, tns, trav, cur_type, NULL);
953 trav = trav->next;
954 } else if (node_is_equal(trav,"choice")) {
955 schema_choice(sdl, tns, trav, cur_type, NULL);
956 trav = trav->next;
957 } else if (node_is_equal(trav,"sequence")) {
958 schema_sequence(sdl, tns, trav, cur_type, NULL);
959 trav = trav->next;
960 }
961 }
962 while (trav != NULL) {
963 if (node_is_equal(trav,"attribute")) {
964 schema_attribute(sdl, tns, trav, cur_type, NULL);
965 } else if (node_is_equal(trav,"attributeGroup")) {
966 schema_attributeGroup(sdl, tns, trav, cur_type, NULL);
967 } else if (node_is_equal(trav,"anyAttribute")) {
968 /* TODO: <anyAttribute> support */
969 trav = trav->next;
970 break;
971 } else {
972 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in extension", trav->name);
973 }
974 trav = trav->next;
975 }
976 if (trav != NULL) {
977 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in extension", trav->name);
978 }
979 return TRUE;
980 }
981
schema_min_max(xmlNodePtr node,sdlContentModelPtr model)982 void schema_min_max(xmlNodePtr node, sdlContentModelPtr model)
983 {
984 xmlAttrPtr attr = get_attribute(node->properties, "minOccurs");
985
986 if (attr) {
987 model->min_occurs = atoi((char*)attr->children->content);
988 } else {
989 model->min_occurs = 1;
990 }
991
992 attr = get_attribute(node->properties, "maxOccurs");
993 if (attr) {
994 if (!strncmp((char*)attr->children->content, "unbounded", sizeof("unbounded"))) {
995 model->max_occurs = -1;
996 } else {
997 model->max_occurs = atoi((char*)attr->children->content);
998 }
999 } else {
1000 model->max_occurs = 1;
1001 }
1002 }
1003
1004 /*
1005 <all
1006 id = ID
1007 maxOccurs = 1 : 1
1008 minOccurs = (0 | 1) : 1
1009 {any attributes with non-schema namespace . . .}>
1010 Content: (annotation?, element*)
1011 </all>
1012 */
schema_all(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr all,sdlTypePtr cur_type,sdlContentModelPtr model)1013 static int schema_all(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr all, sdlTypePtr cur_type, sdlContentModelPtr model)
1014 {
1015 xmlNodePtr trav;
1016 sdlContentModelPtr newModel;
1017
1018 newModel = emalloc(sizeof(sdlContentModel));
1019 newModel->kind = XSD_CONTENT_ALL;
1020 newModel->u.content = emalloc(sizeof(HashTable));
1021 zend_hash_init(newModel->u.content, 0, NULL, delete_model, 0);
1022 if (model == NULL) {
1023 cur_type->model = newModel;
1024 } else {
1025 zend_hash_next_index_insert(model->u.content,&newModel,sizeof(sdlContentModelPtr), NULL);
1026 }
1027
1028 schema_min_max(all, newModel);
1029
1030 trav = all->children;
1031 if (trav != NULL && node_is_equal(trav,"annotation")) {
1032 /* TODO: <annotation> support */
1033 trav = trav->next;
1034 }
1035 while (trav != NULL) {
1036 if (node_is_equal(trav,"element")) {
1037 schema_element(sdl, tns, trav, cur_type, newModel);
1038 } else {
1039 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in all", trav->name);
1040 }
1041 trav = trav->next;
1042 }
1043 return TRUE;
1044 }
1045
1046 /*
1047 <group
1048 name = NCName
1049 Content: (annotation?, (all | choice | sequence))
1050 </group>
1051 <group
1052 name = NCName
1053 ref = QName>
1054 Content: (annotation?)
1055 </group>
1056 */
schema_group(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr groupType,sdlTypePtr cur_type,sdlContentModelPtr model)1057 static int schema_group(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr groupType, sdlTypePtr cur_type, sdlContentModelPtr model)
1058 {
1059 xmlNodePtr trav;
1060 xmlAttrPtr ns, name, ref = NULL;
1061 sdlContentModelPtr newModel;
1062
1063 ns = get_attribute(groupType->properties, "targetNamespace");
1064 if (ns == NULL) {
1065 ns = tns;
1066 }
1067
1068 name = get_attribute(groupType->properties, "name");
1069 if (name == NULL) {
1070 name = ref = get_attribute(groupType->properties, "ref");
1071 }
1072
1073 if (name) {
1074 smart_str key = {0};
1075
1076 if (ref) {
1077 char *type, *ns;
1078 xmlNsPtr nsptr;
1079
1080 parse_namespace(ref->children->content, &type, &ns);
1081 nsptr = xmlSearchNs(groupType->doc, groupType, BAD_CAST(ns));
1082 if (nsptr != NULL) {
1083 smart_str_appends(&key, (char*)nsptr->href);
1084 } else {
1085 xmlAttrPtr ns = get_attribute(groupType->properties, "targetNamespace");
1086 if (ns == NULL) {
1087 ns = tns;
1088 }
1089 if (ns) {
1090 smart_str_appends(&key, (char*)ns->children->content);
1091 }
1092 }
1093 smart_str_appendc(&key, ':');
1094 smart_str_appends(&key, type);
1095 smart_str_0(&key);
1096
1097 newModel = emalloc(sizeof(sdlContentModel));
1098 newModel->kind = XSD_CONTENT_GROUP_REF;
1099 newModel->u.group_ref = estrdup(key.c);
1100
1101 if (type) {efree(type);}
1102 if (ns) {efree(ns);}
1103 } else {
1104 newModel = emalloc(sizeof(sdlContentModel));
1105 newModel->kind = XSD_CONTENT_SEQUENCE; /* will be redefined */
1106 newModel->u.content = emalloc(sizeof(HashTable));
1107 zend_hash_init(newModel->u.content, 0, NULL, delete_model, 0);
1108
1109 smart_str_appends(&key, (char*)ns->children->content);
1110 smart_str_appendc(&key, ':');
1111 smart_str_appends(&key, (char*)name->children->content);
1112 smart_str_0(&key);
1113 }
1114
1115 if (cur_type == NULL) {
1116 sdlTypePtr newType;
1117
1118 newType = emalloc(sizeof(sdlType));
1119 memset(newType, 0, sizeof(sdlType));
1120
1121 if (sdl->groups == NULL) {
1122 sdl->groups = emalloc(sizeof(HashTable));
1123 zend_hash_init(sdl->groups, 0, NULL, delete_type, 0);
1124 }
1125 if (zend_hash_add(sdl->groups, key.c, key.len+1, (void**)&newType, sizeof(sdlTypePtr), NULL) != SUCCESS) {
1126 soap_error1(E_ERROR, "Parsing Schema: group '%s' already defined", key.c);
1127 }
1128
1129 cur_type = newType;
1130 }
1131 smart_str_free(&key);
1132
1133 if (model == NULL) {
1134 cur_type->model = newModel;
1135 } else {
1136 zend_hash_next_index_insert(model->u.content, &newModel, sizeof(sdlContentModelPtr), NULL);
1137 }
1138 } else {
1139 soap_error0(E_ERROR, "Parsing Schema: group has no 'name' nor 'ref' attributes");
1140 }
1141
1142 schema_min_max(groupType, newModel);
1143
1144 trav = groupType->children;
1145 if (trav != NULL && node_is_equal(trav,"annotation")) {
1146 /* TODO: <annotation> support */
1147 trav = trav->next;
1148 }
1149 if (trav != NULL) {
1150 if (node_is_equal(trav,"choice")) {
1151 if (ref != NULL) {
1152 soap_error0(E_ERROR, "Parsing Schema: group has both 'ref' attribute and subcontent");
1153 }
1154 newModel->kind = XSD_CONTENT_CHOICE;
1155 schema_choice(sdl, tns, trav, cur_type, newModel);
1156 trav = trav->next;
1157 } else if (node_is_equal(trav,"sequence")) {
1158 if (ref != NULL) {
1159 soap_error0(E_ERROR, "Parsing Schema: group has both 'ref' attribute and subcontent");
1160 }
1161 newModel->kind = XSD_CONTENT_SEQUENCE;
1162 schema_sequence(sdl, tns, trav, cur_type, newModel);
1163 trav = trav->next;
1164 } else if (node_is_equal(trav,"all")) {
1165 if (ref != NULL) {
1166 soap_error0(E_ERROR, "Parsing Schema: group has both 'ref' attribute and subcontent");
1167 }
1168 newModel->kind = XSD_CONTENT_ALL;
1169 schema_all(sdl, tns, trav, cur_type, newModel);
1170 trav = trav->next;
1171 } else {
1172 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in group", trav->name);
1173 }
1174 }
1175 if (trav != NULL) {
1176 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in group", trav->name);
1177 }
1178 return TRUE;
1179 }
1180 /*
1181 <choice
1182 id = ID
1183 maxOccurs = (nonNegativeInteger | unbounded) : 1
1184 minOccurs = nonNegativeInteger : 1
1185 {any attributes with non-schema namespace . . .}>
1186 Content: (annotation?, (element | group | choice | sequence | any)*)
1187 </choice>
1188 */
schema_choice(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr choiceType,sdlTypePtr cur_type,sdlContentModelPtr model)1189 static int schema_choice(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr choiceType, sdlTypePtr cur_type, sdlContentModelPtr model)
1190 {
1191 xmlNodePtr trav;
1192 sdlContentModelPtr newModel;
1193
1194 newModel = emalloc(sizeof(sdlContentModel));
1195 newModel->kind = XSD_CONTENT_CHOICE;
1196 newModel->u.content = emalloc(sizeof(HashTable));
1197 zend_hash_init(newModel->u.content, 0, NULL, delete_model, 0);
1198 if (model == NULL) {
1199 cur_type->model = newModel;
1200 } else {
1201 zend_hash_next_index_insert(model->u.content,&newModel,sizeof(sdlContentModelPtr), NULL);
1202 }
1203
1204 schema_min_max(choiceType, newModel);
1205
1206 trav = choiceType->children;
1207 if (trav != NULL && node_is_equal(trav,"annotation")) {
1208 /* TODO: <annotation> support */
1209 trav = trav->next;
1210 }
1211 while (trav != NULL) {
1212 if (node_is_equal(trav,"element")) {
1213 schema_element(sdl, tns, trav, cur_type, newModel);
1214 } else if (node_is_equal(trav,"group")) {
1215 schema_group(sdl, tns, trav, cur_type, newModel);
1216 } else if (node_is_equal(trav,"choice")) {
1217 schema_choice(sdl, tns, trav, cur_type, newModel);
1218 } else if (node_is_equal(trav,"sequence")) {
1219 schema_sequence(sdl, tns, trav, cur_type, newModel);
1220 } else if (node_is_equal(trav,"any")) {
1221 schema_any(sdl, tns, trav, cur_type, newModel);
1222 } else {
1223 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in choice", trav->name);
1224 }
1225 trav = trav->next;
1226 }
1227 return TRUE;
1228 }
1229
1230 /*
1231 <sequence
1232 id = ID
1233 maxOccurs = (nonNegativeInteger | unbounded) : 1
1234 minOccurs = nonNegativeInteger : 1
1235 {any attributes with non-schema namespace . . .}>
1236 Content: (annotation?, (element | group | choice | sequence | any)*)
1237 </sequence>
1238 */
schema_sequence(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr seqType,sdlTypePtr cur_type,sdlContentModelPtr model)1239 static int schema_sequence(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr seqType, sdlTypePtr cur_type, sdlContentModelPtr model)
1240 {
1241 xmlNodePtr trav;
1242 sdlContentModelPtr newModel;
1243
1244 newModel = emalloc(sizeof(sdlContentModel));
1245 newModel->kind = XSD_CONTENT_SEQUENCE;
1246 newModel->u.content = emalloc(sizeof(HashTable));
1247 zend_hash_init(newModel->u.content, 0, NULL, delete_model, 0);
1248 if (model == NULL) {
1249 cur_type->model = newModel;
1250 } else {
1251 zend_hash_next_index_insert(model->u.content,&newModel,sizeof(sdlContentModelPtr), NULL);
1252 }
1253
1254 schema_min_max(seqType, newModel);
1255
1256 trav = seqType->children;
1257 if (trav != NULL && node_is_equal(trav,"annotation")) {
1258 /* TODO: <annotation> support */
1259 trav = trav->next;
1260 }
1261 while (trav != NULL) {
1262 if (node_is_equal(trav,"element")) {
1263 schema_element(sdl, tns, trav, cur_type, newModel);
1264 } else if (node_is_equal(trav,"group")) {
1265 schema_group(sdl, tns, trav, cur_type, newModel);
1266 } else if (node_is_equal(trav,"choice")) {
1267 schema_choice(sdl, tns, trav, cur_type, newModel);
1268 } else if (node_is_equal(trav,"sequence")) {
1269 schema_sequence(sdl, tns, trav, cur_type, newModel);
1270 } else if (node_is_equal(trav,"any")) {
1271 schema_any(sdl, tns, trav, cur_type, newModel);
1272 } else {
1273 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in sequence", trav->name);
1274 }
1275 trav = trav->next;
1276 }
1277 return TRUE;
1278 }
1279
1280 /*
1281 <any
1282 id = ID
1283 maxOccurs = (nonNegativeInteger | unbounded) : 1
1284 minOccurs = nonNegativeInteger : 1
1285 namespace = ((##any | ##other) | List of (anyURI | (##targetNamespace | ##local)) ) : ##any
1286 processContents = (lax | skip | strict) : strict
1287 {any attributes with non-schema namespace . . .}>
1288 Content: (annotation?)
1289 </any>
1290 */
schema_any(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr anyType,sdlTypePtr cur_type,sdlContentModelPtr model)1291 static int schema_any(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr anyType, sdlTypePtr cur_type, sdlContentModelPtr model)
1292 {
1293 if (model != NULL) {
1294 sdlContentModelPtr newModel;
1295
1296 newModel = emalloc(sizeof(sdlContentModel));
1297 newModel->kind = XSD_CONTENT_ANY;
1298
1299 schema_min_max(anyType, newModel);
1300
1301 zend_hash_next_index_insert(model->u.content, &newModel, sizeof(sdlContentModelPtr), NULL);
1302 }
1303 return TRUE;
1304 }
1305
1306 /*
1307 <complexContent
1308 id = ID
1309 mixed = boolean
1310 {any attributes with non-schema namespace . . .}>
1311 Content: (annotation?, (restriction | extension))
1312 </complexContent>
1313 */
schema_complexContent(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr compCont,sdlTypePtr cur_type)1314 static int schema_complexContent(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr compCont, sdlTypePtr cur_type)
1315 {
1316 xmlNodePtr trav;
1317
1318 trav = compCont->children;
1319 if (trav != NULL && node_is_equal(trav,"annotation")) {
1320 /* TODO: <annotation> support */
1321 trav = trav->next;
1322 }
1323 if (trav != NULL) {
1324 if (node_is_equal(trav, "restriction")) {
1325 cur_type->kind = XSD_TYPEKIND_RESTRICTION;
1326 schema_restriction_complexContent(sdl, tns, trav, cur_type);
1327 trav = trav->next;
1328 } else if (node_is_equal(trav, "extension")) {
1329 cur_type->kind = XSD_TYPEKIND_EXTENSION;
1330 schema_extension_complexContent(sdl, tns, trav, cur_type);
1331 trav = trav->next;
1332 } else {
1333 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in complexContent", trav->name);
1334 }
1335 } else {
1336 soap_error0(E_ERROR, "Parsing Schema: <restriction> or <extension> expected in complexContent");
1337 }
1338 if (trav != NULL) {
1339 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in complexContent", trav->name);
1340 }
1341
1342 return TRUE;
1343 }
1344
1345 /*
1346 <complexType
1347 abstract = boolean : false
1348 block = (#all | List of (extension | restriction))
1349 final = (#all | List of (extension | restriction))
1350 id = ID
1351 mixed = boolean : false
1352 name = NCName
1353 {any attributes with non-schema namespace . . .}>
1354 Content: (annotation?, (simpleContent | complexContent | ((group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?))))
1355 </complexType>
1356 */
schema_complexType(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr compType,sdlTypePtr cur_type)1357 static int schema_complexType(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr compType, sdlTypePtr cur_type)
1358 {
1359 xmlNodePtr trav;
1360 xmlAttrPtr attrs, name, ns;
1361
1362 attrs = compType->properties;
1363 ns = get_attribute(attrs, "targetNamespace");
1364 if (ns == NULL) {
1365 ns = tns;
1366 }
1367
1368 name = get_attribute(attrs, "name");
1369 if (cur_type != NULL) {
1370 /* Anonymous type inside <element> */
1371 sdlTypePtr newType, *ptr;
1372
1373 newType = emalloc(sizeof(sdlType));
1374 memset(newType, 0, sizeof(sdlType));
1375 newType->kind = XSD_TYPEKIND_COMPLEX;
1376 if (name != NULL) {
1377 newType->name = estrdup((char*)name->children->content);
1378 newType->namens = estrdup((char*)ns->children->content);
1379 } else {
1380 newType->name = estrdup(cur_type->name);
1381 newType->namens = estrdup(cur_type->namens);
1382 }
1383
1384 zend_hash_next_index_insert(sdl->types, &newType, sizeof(sdlTypePtr), (void **)&ptr);
1385
1386 if (sdl->encoders == NULL) {
1387 sdl->encoders = emalloc(sizeof(HashTable));
1388 zend_hash_init(sdl->encoders, 0, NULL, delete_encoder, 0);
1389 }
1390 cur_type->encode = emalloc(sizeof(encode));
1391 memset(cur_type->encode, 0, sizeof(encode));
1392 cur_type->encode->details.ns = estrdup(newType->namens);
1393 cur_type->encode->details.type_str = estrdup(newType->name);
1394 cur_type->encode->details.sdl_type = *ptr;
1395 cur_type->encode->to_xml = sdl_guess_convert_xml;
1396 cur_type->encode->to_zval = sdl_guess_convert_zval;
1397 zend_hash_next_index_insert(sdl->encoders, &cur_type->encode, sizeof(encodePtr), NULL);
1398
1399 cur_type =*ptr;
1400
1401 } else if (name) {
1402 sdlTypePtr newType, *ptr;
1403
1404 newType = emalloc(sizeof(sdlType));
1405 memset(newType, 0, sizeof(sdlType));
1406 newType->kind = XSD_TYPEKIND_COMPLEX;
1407 newType->name = estrdup((char*)name->children->content);
1408 newType->namens = estrdup((char*)ns->children->content);
1409
1410 zend_hash_next_index_insert(sdl->types, &newType, sizeof(sdlTypePtr), (void **)&ptr);
1411
1412 cur_type = (*ptr);
1413 create_encoder(sdl, cur_type, ns->children->content, name->children->content);
1414 } else {
1415 soap_error0(E_ERROR, "Parsing Schema: complexType has no 'name' attribute");
1416 return FALSE;
1417 }
1418
1419 trav = compType->children;
1420 if (trav != NULL && node_is_equal(trav, "annotation")) {
1421 /* TODO: <annotation> support */
1422 trav = trav->next;
1423 }
1424 if (trav != NULL) {
1425 if (node_is_equal(trav,"simpleContent")) {
1426 schema_simpleContent(sdl, tns, trav, cur_type);
1427 trav = trav->next;
1428 } else if (node_is_equal(trav,"complexContent")) {
1429 schema_complexContent(sdl, tns, trav, cur_type);
1430 trav = trav->next;
1431 } else {
1432 if (node_is_equal(trav,"group")) {
1433 schema_group(sdl, tns, trav, cur_type, NULL);
1434 trav = trav->next;
1435 } else if (node_is_equal(trav,"all")) {
1436 schema_all(sdl, tns, trav, cur_type, NULL);
1437 trav = trav->next;
1438 } else if (node_is_equal(trav,"choice")) {
1439 schema_choice(sdl, tns, trav, cur_type, NULL);
1440 trav = trav->next;
1441 } else if (node_is_equal(trav,"sequence")) {
1442 schema_sequence(sdl, tns, trav, cur_type, NULL);
1443 trav = trav->next;
1444 }
1445 while (trav != NULL) {
1446 if (node_is_equal(trav,"attribute")) {
1447 schema_attribute(sdl, tns, trav, cur_type, NULL);
1448 } else if (node_is_equal(trav,"attributeGroup")) {
1449 schema_attributeGroup(sdl, tns, trav, cur_type, NULL);
1450 } else if (node_is_equal(trav,"anyAttribute")) {
1451 /* TODO: <anyAttribute> support */
1452 trav = trav->next;
1453 break;
1454 } else {
1455 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in complexType", trav->name);
1456 }
1457 trav = trav->next;
1458 }
1459 }
1460 }
1461 if (trav != NULL) {
1462 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in complexType", trav->name);
1463 }
1464 return TRUE;
1465 }
1466 /*
1467 <element
1468 abstract = boolean : false
1469 block = (#all | List of (extension | restriction | substitution))
1470 default = string
1471 final = (#all | List of (extension | restriction))
1472 fixed = string
1473 form = (qualified | unqualified)
1474 id = ID
1475 maxOccurs = (nonNegativeInteger | unbounded) : 1
1476 minOccurs = nonNegativeInteger : 1
1477 name = NCName
1478 nillable = boolean : false
1479 ref = QName
1480 substitutionGroup = QName
1481 type = QName
1482 {any attributes with non-schema namespace . . .}>
1483 Content: (annotation?, ((simpleType | complexType)?, (unique | key | keyref)*))
1484 </element>
1485 */
schema_element(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr element,sdlTypePtr cur_type,sdlContentModelPtr model)1486 static int schema_element(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr element, sdlTypePtr cur_type, sdlContentModelPtr model)
1487 {
1488 xmlNodePtr trav;
1489 xmlAttrPtr attrs, attr, ns, name, type, ref = NULL;
1490
1491 attrs = element->properties;
1492 ns = get_attribute(attrs, "targetNamespace");
1493 if (ns == NULL) {
1494 ns = tns;
1495 }
1496
1497 name = get_attribute(attrs, "name");
1498 if (name == NULL) {
1499 name = ref = get_attribute(attrs, "ref");
1500 }
1501
1502 if (name) {
1503 HashTable *addHash;
1504 sdlTypePtr newType;
1505 smart_str key = {0};
1506
1507 newType = emalloc(sizeof(sdlType));
1508 memset(newType, 0, sizeof(sdlType));
1509
1510 if (ref) {
1511 smart_str nscat = {0};
1512 char *type, *ns;
1513 xmlNsPtr nsptr;
1514
1515 parse_namespace(ref->children->content, &type, &ns);
1516 nsptr = xmlSearchNs(element->doc, element, BAD_CAST(ns));
1517 if (nsptr != NULL) {
1518 smart_str_appends(&nscat, (char*)nsptr->href);
1519 newType->namens = estrdup((char*)nsptr->href);
1520 } else {
1521 xmlAttrPtr ns = get_attribute(attrs, "targetNamespace");
1522 if (ns == NULL) {
1523 ns = tns;
1524 }
1525 if (ns) {
1526 smart_str_appends(&nscat, (char*)ns->children->content);
1527 }
1528 }
1529 smart_str_appendc(&nscat, ':');
1530 smart_str_appends(&nscat, type);
1531 newType->name = estrdup(type);
1532 smart_str_0(&nscat);
1533 if (type) {efree(type);}
1534 if (ns) {efree(ns);}
1535 newType->ref = estrdup(nscat.c);
1536 smart_str_free(&nscat);
1537 } else {
1538 newType->name = estrdup((char*)name->children->content);
1539 newType->namens = estrdup((char*)ns->children->content);
1540 }
1541
1542 newType->nillable = FALSE;
1543
1544 if (cur_type == NULL) {
1545 if (sdl->elements == NULL) {
1546 sdl->elements = emalloc(sizeof(HashTable));
1547 zend_hash_init(sdl->elements, 0, NULL, delete_type, 0);
1548 }
1549 addHash = sdl->elements;
1550 smart_str_appends(&key, newType->namens);
1551 smart_str_appendc(&key, ':');
1552 smart_str_appends(&key, newType->name);
1553 } else {
1554 if (cur_type->elements == NULL) {
1555 cur_type->elements = emalloc(sizeof(HashTable));
1556 zend_hash_init(cur_type->elements, 0, NULL, delete_type, 0);
1557 }
1558 addHash = cur_type->elements;
1559 smart_str_appends(&key, newType->name);
1560 }
1561
1562 smart_str_0(&key);
1563 if (zend_hash_add(addHash, key.c, key.len + 1, &newType, sizeof(sdlTypePtr), NULL) != SUCCESS) {
1564 if (cur_type == NULL) {
1565 soap_error1(E_ERROR, "Parsing Schema: element '%s' already defined", key.c);
1566 } else {
1567 zend_hash_next_index_insert(addHash, &newType, sizeof(sdlTypePtr), NULL);
1568 }
1569 }
1570 smart_str_free(&key);
1571
1572 if (model != NULL) {
1573 sdlContentModelPtr newModel = emalloc(sizeof(sdlContentModel));
1574
1575 newModel->kind = XSD_CONTENT_ELEMENT;
1576 newModel->u.element = newType;
1577
1578 schema_min_max(element, newModel);
1579
1580
1581 zend_hash_next_index_insert(model->u.content, &newModel, sizeof(sdlContentModelPtr), NULL);
1582 }
1583 cur_type = newType;
1584 } else {
1585 soap_error0(E_ERROR, "Parsing Schema: element has no 'name' nor 'ref' attributes");
1586 }
1587
1588 /* nillable = boolean : false */
1589 attrs = element->properties;
1590 attr = get_attribute(attrs, "nillable");
1591 if (attr) {
1592 if (ref != NULL) {
1593 soap_error0(E_ERROR, "Parsing Schema: element has both 'ref' and 'nillable' attributes");
1594 }
1595 if (!stricmp((char*)attr->children->content, "true") ||
1596 !stricmp((char*)attr->children->content, "1")) {
1597 cur_type->nillable = TRUE;
1598 } else {
1599 cur_type->nillable = FALSE;
1600 }
1601 } else {
1602 cur_type->nillable = FALSE;
1603 }
1604
1605 attr = get_attribute(attrs, "fixed");
1606 if (attr) {
1607 if (ref != NULL) {
1608 soap_error0(E_ERROR, "Parsing Schema: element has both 'ref' and 'fixed' attributes");
1609 }
1610 cur_type->fixed = estrdup((char*)attr->children->content);
1611 }
1612
1613 attr = get_attribute(attrs, "default");
1614 if (attr) {
1615 if (ref != NULL) {
1616 soap_error0(E_ERROR, "Parsing Schema: element has both 'ref' and 'fixed' attributes");
1617 } else if (ref != NULL) {
1618 soap_error0(E_ERROR, "Parsing Schema: element has both 'default' and 'fixed' attributes");
1619 }
1620 cur_type->def = estrdup((char*)attr->children->content);
1621 }
1622
1623 /* form */
1624 attr = get_attribute(attrs, "form");
1625 if (attr) {
1626 if (strncmp((char*)attr->children->content, "qualified", sizeof("qualified")) == 0) {
1627 cur_type->form = XSD_FORM_QUALIFIED;
1628 } else if (strncmp((char*)attr->children->content, "unqualified", sizeof("unqualified")) == 0) {
1629 cur_type->form = XSD_FORM_UNQUALIFIED;
1630 } else {
1631 cur_type->form = XSD_FORM_DEFAULT;
1632 }
1633 } else {
1634 cur_type->form = XSD_FORM_DEFAULT;
1635 }
1636 if (cur_type->form == XSD_FORM_DEFAULT) {
1637 xmlNodePtr parent = element->parent;
1638 while (parent) {
1639 if (node_is_equal_ex(parent, "schema", SCHEMA_NAMESPACE)) {
1640 xmlAttrPtr def;
1641 def = get_attribute(parent->properties, "elementFormDefault");
1642 if(def == NULL || strncmp((char*)def->children->content, "qualified", sizeof("qualified"))) {
1643 cur_type->form = XSD_FORM_UNQUALIFIED;
1644 } else {
1645 cur_type->form = XSD_FORM_QUALIFIED;
1646 }
1647 break;
1648 }
1649 parent = parent->parent;
1650 }
1651 if (parent == NULL) {
1652 cur_type->form = XSD_FORM_UNQUALIFIED;
1653 }
1654 }
1655
1656 /* type = QName */
1657 type = get_attribute(attrs, "type");
1658 if (type) {
1659 char *cptype, *str_ns;
1660 xmlNsPtr nsptr;
1661
1662 if (ref != NULL) {
1663 soap_error0(E_ERROR, "Parsing Schema: element has both 'ref' and 'type' attributes");
1664 }
1665 parse_namespace(type->children->content, &cptype, &str_ns);
1666 nsptr = xmlSearchNs(element->doc, element, BAD_CAST(str_ns));
1667 if (nsptr != NULL) {
1668 cur_type->encode = get_create_encoder(sdl, cur_type, nsptr->href, BAD_CAST(cptype));
1669 }
1670 if (str_ns) {efree(str_ns);}
1671 if (cptype) {efree(cptype);}
1672 }
1673
1674 trav = element->children;
1675 if (trav != NULL && node_is_equal(trav, "annotation")) {
1676 /* TODO: <annotation> support */
1677 trav = trav->next;
1678 }
1679 if (trav != NULL) {
1680 if (node_is_equal(trav,"simpleType")) {
1681 if (ref != NULL) {
1682 soap_error0(E_ERROR, "Parsing Schema: element has both 'ref' attribute and subtype");
1683 } else if (type != NULL) {
1684 soap_error0(E_ERROR, "Parsing Schema: element has both 'type' attribute and subtype");
1685 }
1686 schema_simpleType(sdl, tns, trav, cur_type);
1687 trav = trav->next;
1688 } else if (node_is_equal(trav,"complexType")) {
1689 if (ref != NULL) {
1690 soap_error0(E_ERROR, "Parsing Schema: element has both 'ref' attribute and subtype");
1691 } else if (type != NULL) {
1692 soap_error0(E_ERROR, "Parsing Schema: element has both 'type' attribute and subtype");
1693 }
1694 schema_complexType(sdl, tns, trav, cur_type);
1695 trav = trav->next;
1696 }
1697 }
1698 while (trav != NULL) {
1699 if (node_is_equal(trav,"unique")) {
1700 /* TODO: <unique> support */
1701 } else if (node_is_equal(trav,"key")) {
1702 /* TODO: <key> support */
1703 } else if (node_is_equal(trav,"keyref")) {
1704 /* TODO: <keyref> support */
1705 } else {
1706 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in element", trav->name);
1707 }
1708 trav = trav->next;
1709 }
1710
1711 return TRUE;
1712 }
1713
1714 /*
1715 <attribute
1716 default = string
1717 fixed = string
1718 form = (qualified | unqualified)
1719 id = ID
1720 name = NCName
1721 ref = QName
1722 type = QName
1723 use = (optional | prohibited | required) : optional
1724 {any attributes with non-schema namespace . . .}>
1725 Content: (annotation?, (simpleType?))
1726 </attribute>
1727 */
schema_attribute(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr attrType,sdlTypePtr cur_type,sdlCtx * ctx)1728 static int schema_attribute(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr attrType, sdlTypePtr cur_type, sdlCtx *ctx)
1729 {
1730 sdlAttributePtr newAttr;
1731 xmlAttrPtr attr, name, ref = NULL, type = NULL;
1732 xmlNodePtr trav;
1733
1734 name = get_attribute(attrType->properties, "name");
1735 if (name == NULL) {
1736 name = ref = get_attribute(attrType->properties, "ref");
1737 }
1738 if (name) {
1739 HashTable *addHash;
1740 smart_str key = {0};
1741
1742 newAttr = emalloc(sizeof(sdlAttribute));
1743 memset(newAttr, 0, sizeof(sdlAttribute));
1744
1745 if (ref) {
1746 char *attr_name, *ns;
1747 xmlNsPtr nsptr;
1748
1749 parse_namespace(ref->children->content, &attr_name, &ns);
1750 nsptr = xmlSearchNs(attrType->doc, attrType, BAD_CAST(ns));
1751 if (nsptr != NULL) {
1752 smart_str_appends(&key, (char*)nsptr->href);
1753 newAttr->namens = estrdup((char*)nsptr->href);
1754 } else {
1755 xmlAttrPtr ns = get_attribute(attrType->properties, "targetNamespace");
1756 if (ns == NULL) {
1757 ns = tns;
1758 }
1759 if (ns) {
1760 smart_str_appends(&key, (char*)ns->children->content);
1761 }
1762 }
1763 smart_str_appendc(&key, ':');
1764 smart_str_appends(&key, attr_name);
1765 smart_str_0(&key);
1766 newAttr->ref = estrdup(key.c);
1767 if (attr_name) {efree(attr_name);}
1768 if (ns) {efree(ns);}
1769 } else {
1770 xmlAttrPtr ns;
1771
1772 ns = get_attribute(attrType->properties, "targetNamespace");
1773 if (ns == NULL) {
1774 ns = tns;
1775 }
1776 if (ns != NULL) {
1777 smart_str_appends(&key, (char*)ns->children->content);
1778 smart_str_appendc(&key, ':');
1779 newAttr->namens = estrdup((char*)ns->children->content);
1780 }
1781 smart_str_appends(&key, (char*)name->children->content);
1782 smart_str_0(&key);
1783 }
1784
1785 if (cur_type == NULL) {
1786 addHash = ctx->attributes;
1787 } else {
1788 if (cur_type->attributes == NULL) {
1789 cur_type->attributes = emalloc(sizeof(HashTable));
1790 zend_hash_init(cur_type->attributes, 0, NULL, delete_attribute, 0);
1791 }
1792 addHash = cur_type->attributes;
1793 }
1794
1795 if (zend_hash_add(addHash, key.c, key.len + 1, &newAttr, sizeof(sdlAttributePtr), NULL) != SUCCESS) {
1796 soap_error1(E_ERROR, "Parsing Schema: attribute '%s' already defined", key.c);
1797 }
1798 smart_str_free(&key);
1799 } else{
1800 soap_error0(E_ERROR, "Parsing Schema: attribute has no 'name' nor 'ref' attributes");
1801 }
1802
1803 /* type = QName */
1804 type = get_attribute(attrType->properties, "type");
1805 if (type) {
1806 char *cptype, *str_ns;
1807 xmlNsPtr nsptr;
1808
1809 if (ref != NULL) {
1810 soap_error0(E_ERROR, "Parsing Schema: attribute has both 'ref' and 'type' attributes");
1811 }
1812 parse_namespace(type->children->content, &cptype, &str_ns);
1813 nsptr = xmlSearchNs(attrType->doc, attrType, BAD_CAST(str_ns));
1814 if (nsptr != NULL) {
1815 newAttr->encode = get_create_encoder(sdl, cur_type, nsptr->href, BAD_CAST(cptype));
1816 }
1817 if (str_ns) {efree(str_ns);}
1818 if (cptype) {efree(cptype);}
1819 }
1820
1821 attr = attrType->properties;
1822 while (attr != NULL) {
1823 if (attr_is_equal_ex(attr, "default", SCHEMA_NAMESPACE)) {
1824 newAttr->def = estrdup((char*)attr->children->content);
1825 } else if (attr_is_equal_ex(attr, "fixed", SCHEMA_NAMESPACE)) {
1826 newAttr->fixed = estrdup((char*)attr->children->content);
1827 } else if (attr_is_equal_ex(attr, "form", SCHEMA_NAMESPACE)) {
1828 if (strncmp((char*)attr->children->content, "qualified", sizeof("qualified")) == 0) {
1829 newAttr->form = XSD_FORM_QUALIFIED;
1830 } else if (strncmp((char*)attr->children->content, "unqualified", sizeof("unqualified")) == 0) {
1831 newAttr->form = XSD_FORM_UNQUALIFIED;
1832 } else {
1833 newAttr->form = XSD_FORM_DEFAULT;
1834 }
1835 } else if (attr_is_equal_ex(attr, "id", SCHEMA_NAMESPACE)) {
1836 /* skip */
1837 } else if (attr_is_equal_ex(attr, "name", SCHEMA_NAMESPACE)) {
1838 newAttr->name = estrdup((char*)attr->children->content);
1839 } else if (attr_is_equal_ex(attr, "ref", SCHEMA_NAMESPACE)) {
1840 /* already processed */
1841 } else if (attr_is_equal_ex(attr, "type", SCHEMA_NAMESPACE)) {
1842 /* already processed */
1843 } else if (attr_is_equal_ex(attr, "use", SCHEMA_NAMESPACE)) {
1844 if (strncmp((char*)attr->children->content, "prohibited", sizeof("prohibited")) == 0) {
1845 newAttr->use = XSD_USE_PROHIBITED;
1846 } else if (strncmp((char*)attr->children->content, "required", sizeof("required")) == 0) {
1847 newAttr->use = XSD_USE_REQUIRED;
1848 } else if (strncmp((char*)attr->children->content, "optional", sizeof("optional")) == 0) {
1849 newAttr->use = XSD_USE_OPTIONAL;
1850 } else {
1851 newAttr->use = XSD_USE_DEFAULT;
1852 }
1853 } else {
1854 xmlNsPtr nsPtr = attr_find_ns(attr);
1855
1856 if (strncmp((char*)nsPtr->href, SCHEMA_NAMESPACE, sizeof(SCHEMA_NAMESPACE))) {
1857 smart_str key2 = {0};
1858 sdlExtraAttributePtr ext;
1859 xmlNsPtr nsptr;
1860 char *value, *ns;
1861
1862 ext = emalloc(sizeof(sdlExtraAttribute));
1863 memset(ext, 0, sizeof(sdlExtraAttribute));
1864 parse_namespace(attr->children->content, &value, &ns);
1865 nsptr = xmlSearchNs(attr->doc, attr->parent, BAD_CAST(ns));
1866 if (nsptr) {
1867 ext->ns = estrdup((char*)nsptr->href);
1868 ext->val = estrdup(value);
1869 } else {
1870 ext->val = estrdup((char*)attr->children->content);
1871 }
1872 if (ns) {efree(ns);}
1873 efree(value);
1874
1875 if (!newAttr->extraAttributes) {
1876 newAttr->extraAttributes = emalloc(sizeof(HashTable));
1877 zend_hash_init(newAttr->extraAttributes, 0, NULL, delete_extra_attribute, 0);
1878 }
1879
1880 smart_str_appends(&key2, (char*)nsPtr->href);
1881 smart_str_appendc(&key2, ':');
1882 smart_str_appends(&key2, (char*)attr->name);
1883 smart_str_0(&key2);
1884 zend_hash_add(newAttr->extraAttributes, key2.c, key2.len + 1, &ext, sizeof(sdlExtraAttributePtr), NULL);
1885 smart_str_free(&key2);
1886 }
1887 }
1888 attr = attr->next;
1889 }
1890 if (newAttr->form == XSD_FORM_DEFAULT) {
1891 xmlNodePtr parent = attrType->parent;
1892 while (parent) {
1893 if (node_is_equal_ex(parent, "schema", SCHEMA_NAMESPACE)) {
1894 xmlAttrPtr def;
1895 def = get_attribute(parent->properties, "attributeFormDefault");
1896 if(def == NULL || strncmp((char*)def->children->content, "qualified", sizeof("qualified"))) {
1897 newAttr->form = XSD_FORM_UNQUALIFIED;
1898 } else {
1899 newAttr->form = XSD_FORM_QUALIFIED;
1900 }
1901 break;
1902 }
1903 parent = parent->parent;
1904 }
1905 if (parent == NULL) {
1906 newAttr->form = XSD_FORM_UNQUALIFIED;
1907 }
1908 }
1909 trav = attrType->children;
1910 if (trav != NULL && node_is_equal(trav, "annotation")) {
1911 /* TODO: <annotation> support */
1912 trav = trav->next;
1913 }
1914 if (trav != NULL) {
1915 if (node_is_equal(trav,"simpleType")) {
1916 sdlTypePtr dummy_type;
1917 if (ref != NULL) {
1918 soap_error0(E_ERROR, "Parsing Schema: attribute has both 'ref' attribute and subtype");
1919 } else if (type != NULL) {
1920 soap_error0(E_ERROR, "Parsing Schema: attribute has both 'type' attribute and subtype");
1921 }
1922 dummy_type = emalloc(sizeof(sdlType));
1923 memset(dummy_type, 0, sizeof(sdlType));
1924 {
1925 smart_str anonymous = {0};
1926
1927 smart_str_appendl(&anonymous, "anonymous", sizeof("anonymous")-1);
1928 smart_str_append_long(&anonymous, zend_hash_num_elements(sdl->types));
1929 smart_str_0(&anonymous);
1930 dummy_type->name = anonymous.c;
1931 }
1932 dummy_type->namens = estrdup((char*)tns->children->content);
1933 schema_simpleType(sdl, tns, trav, dummy_type);
1934 newAttr->encode = dummy_type->encode;
1935 delete_type(&dummy_type);
1936 trav = trav->next;
1937 }
1938 }
1939 if (trav != NULL) {
1940 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in attribute", trav->name);
1941 }
1942 return TRUE;
1943 }
1944
schema_attributeGroup(sdlPtr sdl,xmlAttrPtr tns,xmlNodePtr attrGroup,sdlTypePtr cur_type,sdlCtx * ctx)1945 static int schema_attributeGroup(sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr attrGroup, sdlTypePtr cur_type, sdlCtx *ctx)
1946 {
1947 xmlNodePtr trav;
1948 xmlAttrPtr name, ref = NULL;
1949
1950
1951 name = get_attribute(attrGroup->properties, "name");
1952 if (name == NULL) {
1953 name = ref = get_attribute(attrGroup->properties, "ref");
1954 }
1955 if (name) {
1956 if (cur_type == NULL) {
1957 xmlAttrPtr ns;
1958 sdlTypePtr newType;
1959 smart_str key = {0};
1960
1961 ns = get_attribute(attrGroup->properties, "targetNamespace");
1962 if (ns == NULL) {
1963 ns = tns;
1964 }
1965 newType = emalloc(sizeof(sdlType));
1966 memset(newType, 0, sizeof(sdlType));
1967 newType->name = estrdup((char*)name->children->content);
1968 newType->namens = estrdup((char*)ns->children->content);
1969
1970 smart_str_appends(&key, newType->namens);
1971 smart_str_appendc(&key, ':');
1972 smart_str_appends(&key, newType->name);
1973 smart_str_0(&key);
1974
1975 if (zend_hash_add(ctx->attributeGroups, key.c, key.len + 1, &newType, sizeof(sdlTypePtr), NULL) != SUCCESS) {
1976 soap_error1(E_ERROR, "Parsing Schema: attributeGroup '%s' already defined", key.c);
1977 }
1978 cur_type = newType;
1979 smart_str_free(&key);
1980 } else if (ref) {
1981 sdlAttributePtr newAttr;
1982 char *group_name, *ns;
1983 smart_str key = {0};
1984 xmlNsPtr nsptr;
1985
1986 if (cur_type->attributes == NULL) {
1987 cur_type->attributes = emalloc(sizeof(HashTable));
1988 zend_hash_init(cur_type->attributes, 0, NULL, delete_attribute, 0);
1989 }
1990 newAttr = emalloc(sizeof(sdlAttribute));
1991 memset(newAttr, 0, sizeof(sdlAttribute));
1992
1993 parse_namespace(ref->children->content, &group_name, &ns);
1994 nsptr = xmlSearchNs(attrGroup->doc, attrGroup, BAD_CAST(ns));
1995 if (nsptr != NULL) {
1996 smart_str_appends(&key, (char*)nsptr->href);
1997 }
1998 smart_str_appendc(&key, ':');
1999 smart_str_appends(&key, group_name);
2000 smart_str_0(&key);
2001 newAttr->ref = estrdup(key.c);
2002 if (group_name) {efree(group_name);}
2003 if (ns) {efree(ns);}
2004 smart_str_free(&key);
2005
2006 zend_hash_next_index_insert(cur_type->attributes, &newAttr, sizeof(sdlAttributePtr), NULL);
2007 cur_type = NULL;
2008 }
2009 } else{
2010 soap_error0(E_ERROR, "Parsing Schema: attributeGroup has no 'name' nor 'ref' attributes");
2011 }
2012
2013 trav = attrGroup->children;
2014 if (trav != NULL && node_is_equal(trav, "annotation")) {
2015 /* TODO: <annotation> support */
2016 trav = trav->next;
2017 }
2018 while (trav != NULL) {
2019 if (node_is_equal(trav,"attribute")) {
2020 if (ref != NULL) {
2021 soap_error0(E_ERROR, "Parsing Schema: attributeGroup has both 'ref' attribute and subattribute");
2022 }
2023 schema_attribute(sdl, tns, trav, cur_type, NULL);
2024 } else if (node_is_equal(trav,"attributeGroup")) {
2025 if (ref != NULL) {
2026 soap_error0(E_ERROR, "Parsing Schema: attributeGroup has both 'ref' attribute and subattribute");
2027 }
2028 schema_attributeGroup(sdl, tns, trav, cur_type, NULL);
2029 } else if (node_is_equal(trav,"anyAttribute")) {
2030 if (ref != NULL) {
2031 soap_error0(E_ERROR, "Parsing Schema: attributeGroup has both 'ref' attribute and subattribute");
2032 }
2033 /* TODO: <anyAttribute> support */
2034 trav = trav->next;
2035 break;
2036 } else {
2037 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in attributeGroup", trav->name);
2038 }
2039 trav = trav->next;
2040 }
2041 if (trav != NULL) {
2042 soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in attributeGroup", trav->name);
2043 }
2044 return TRUE;
2045 }
2046
copy_extra_attribute(void * attribute)2047 static void copy_extra_attribute(void *attribute)
2048 {
2049 sdlExtraAttributePtr *attr = (sdlExtraAttributePtr*)attribute;
2050 sdlExtraAttributePtr new_attr;
2051
2052 new_attr = emalloc(sizeof(sdlExtraAttribute));
2053 memcpy(new_attr, *attr, sizeof(sdlExtraAttribute));
2054 *attr = new_attr;
2055 if (new_attr->ns) {
2056 new_attr->ns = estrdup(new_attr->ns);
2057 }
2058 if (new_attr->val) {
2059 new_attr->val = estrdup(new_attr->val);
2060 }
2061 }
2062
schema_find_by_ref(HashTable * ht,char * ref)2063 static void* schema_find_by_ref(HashTable *ht, char *ref)
2064 {
2065 void **tmp;
2066
2067 if (zend_hash_find(ht, ref, strlen(ref)+1, (void**)&tmp) == SUCCESS) {
2068 return tmp;
2069 } else {
2070 ref = strrchr(ref, ':');
2071 if (ref) {
2072 if (zend_hash_find(ht, ref, strlen(ref)+1, (void**)&tmp) == SUCCESS) {
2073 return tmp;
2074 }
2075 }
2076 }
2077 return NULL;
2078 }
2079
schema_attribute_fixup(sdlCtx * ctx,sdlAttributePtr attr)2080 static void schema_attribute_fixup(sdlCtx *ctx, sdlAttributePtr attr)
2081 {
2082 sdlAttributePtr *tmp;
2083
2084 if (attr->ref != NULL) {
2085 if (ctx->attributes != NULL) {
2086 tmp = (sdlAttributePtr*)schema_find_by_ref(ctx->attributes, attr->ref);
2087 if (tmp) {
2088 schema_attribute_fixup(ctx, *tmp);
2089 if ((*tmp)->name != NULL && attr->name == NULL) {
2090 attr->name = estrdup((*tmp)->name);
2091 }
2092 if ((*tmp)->namens != NULL && attr->namens == NULL) {
2093 attr->namens = estrdup((*tmp)->namens);
2094 }
2095 if ((*tmp)->def != NULL && attr->def == NULL) {
2096 attr->def = estrdup((*tmp)->def);
2097 }
2098 if ((*tmp)->fixed != NULL && attr->fixed == NULL) {
2099 attr->fixed = estrdup((*tmp)->fixed);
2100 }
2101 if (attr->form == XSD_FORM_DEFAULT) {
2102 attr->form = (*tmp)->form;
2103 }
2104 if (attr->use == XSD_USE_DEFAULT) {
2105 attr->use = (*tmp)->use;
2106 }
2107 if ((*tmp)->extraAttributes != NULL) {
2108 xmlNodePtr node;
2109
2110 attr->extraAttributes = emalloc(sizeof(HashTable));
2111 zend_hash_init(attr->extraAttributes, zend_hash_num_elements((*tmp)->extraAttributes), NULL, delete_extra_attribute, 0);
2112 zend_hash_copy(attr->extraAttributes, (*tmp)->extraAttributes, copy_extra_attribute, &node, sizeof(xmlNodePtr));
2113 }
2114 attr->encode = (*tmp)->encode;
2115 }
2116 }
2117 if (attr->name == NULL && attr->ref != NULL) {
2118 char *name = strrchr(attr->ref, ':');
2119 if (name) {
2120 attr->name = estrdup(name+1);
2121 } else{
2122 attr->name = estrdup(attr->ref);
2123 }
2124 }
2125 efree(attr->ref);
2126 attr->ref = NULL;
2127 }
2128 }
2129
schema_attributegroup_fixup(sdlCtx * ctx,sdlAttributePtr attr,HashTable * ht)2130 static void schema_attributegroup_fixup(sdlCtx *ctx, sdlAttributePtr attr, HashTable *ht)
2131 {
2132 sdlTypePtr *tmp;
2133 sdlAttributePtr *tmp_attr;
2134
2135 if (attr->ref != NULL) {
2136 if (ctx->attributeGroups != NULL) {
2137 tmp = (sdlTypePtr*)schema_find_by_ref(ctx->attributeGroups, attr->ref);
2138 if (tmp) {
2139 if ((*tmp)->attributes) {
2140 zend_hash_internal_pointer_reset((*tmp)->attributes);
2141 while (zend_hash_get_current_data((*tmp)->attributes,(void**)&tmp_attr) == SUCCESS) {
2142 if (zend_hash_get_current_key_type((*tmp)->attributes) == HASH_KEY_IS_STRING) {
2143 char* key;
2144 uint key_len;
2145 sdlAttributePtr newAttr;
2146
2147 schema_attribute_fixup(ctx,*tmp_attr);
2148
2149 newAttr = emalloc(sizeof(sdlAttribute));
2150 memcpy(newAttr, *tmp_attr, sizeof(sdlAttribute));
2151 if (newAttr->def) {newAttr->def = estrdup(newAttr->def);}
2152 if (newAttr->fixed) {newAttr->fixed = estrdup(newAttr->fixed);}
2153 if (newAttr->namens) {newAttr->namens = estrdup(newAttr->namens);}
2154 if (newAttr->name) {newAttr->name = estrdup(newAttr->name);}
2155 if (newAttr->extraAttributes) {
2156 xmlNodePtr node;
2157 HashTable *ht = emalloc(sizeof(HashTable));
2158 zend_hash_init(ht, zend_hash_num_elements(newAttr->extraAttributes), NULL, delete_extra_attribute, 0);
2159 zend_hash_copy(ht, newAttr->extraAttributes, copy_extra_attribute, &node, sizeof(xmlNodePtr));
2160 newAttr->extraAttributes = ht;
2161 }
2162
2163 zend_hash_get_current_key_ex((*tmp)->attributes, &key, &key_len, NULL, 0, NULL);
2164 zend_hash_add(ht, key, key_len, &newAttr, sizeof(sdlAttributePtr), NULL);
2165
2166 zend_hash_move_forward((*tmp)->attributes);
2167 } else {
2168 ulong index;
2169
2170 schema_attributegroup_fixup(ctx,*tmp_attr, ht);
2171 zend_hash_get_current_key((*tmp)->attributes, NULL, &index, 0);
2172 zend_hash_index_del((*tmp)->attributes, index);
2173 }
2174 }
2175 }
2176 }
2177 }
2178 efree(attr->ref);
2179 attr->ref = NULL;
2180 }
2181 }
2182
schema_content_model_fixup(sdlCtx * ctx,sdlContentModelPtr model)2183 static void schema_content_model_fixup(sdlCtx *ctx, sdlContentModelPtr model)
2184 {
2185 switch (model->kind) {
2186 case XSD_CONTENT_GROUP_REF: {
2187 sdlTypePtr *tmp;
2188
2189 if (ctx->sdl->groups && zend_hash_find(ctx->sdl->groups, model->u.group_ref, strlen(model->u.group_ref)+1, (void**)&tmp) == SUCCESS) {
2190 schema_type_fixup(ctx,*tmp);
2191 efree(model->u.group_ref);
2192 model->kind = XSD_CONTENT_GROUP;
2193 model->u.group = (*tmp);
2194 } else {
2195 soap_error1(E_ERROR, "Parsing Schema: unresolved group 'ref' attribute '%s'", model->u.group_ref);
2196 }
2197 break;
2198 }
2199 case XSD_CONTENT_CHOICE: {
2200 if (model->max_occurs != 1) {
2201 HashPosition pos;
2202 sdlContentModelPtr *tmp;
2203
2204 zend_hash_internal_pointer_reset_ex(model->u.content, &pos);
2205 while (zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos) == SUCCESS) {
2206 (*tmp)->min_occurs = 0;
2207 (*tmp)->max_occurs = model->max_occurs;
2208 zend_hash_move_forward_ex(model->u.content, &pos);
2209 }
2210
2211 model->kind = XSD_CONTENT_ALL;
2212 model->min_occurs = 1;
2213 model->max_occurs = 1;
2214 }
2215 }
2216 case XSD_CONTENT_SEQUENCE:
2217 case XSD_CONTENT_ALL: {
2218 sdlContentModelPtr *tmp;
2219
2220 zend_hash_internal_pointer_reset(model->u.content);
2221 while (zend_hash_get_current_data(model->u.content, (void**)&tmp) == SUCCESS) {
2222 schema_content_model_fixup(ctx, *tmp);
2223 zend_hash_move_forward(model->u.content);
2224 }
2225 break;
2226 }
2227 default:
2228 break;
2229 }
2230 }
2231
schema_type_fixup(sdlCtx * ctx,sdlTypePtr type)2232 static void schema_type_fixup(sdlCtx *ctx, sdlTypePtr type)
2233 {
2234 sdlTypePtr *tmp;
2235 sdlAttributePtr *attr;
2236
2237 if (type->ref != NULL) {
2238 if (ctx->sdl->elements != NULL) {
2239 tmp = (sdlTypePtr*)schema_find_by_ref(ctx->sdl->elements, type->ref);
2240 if (tmp) {
2241 type->kind = (*tmp)->kind;
2242 type->encode = (*tmp)->encode;
2243 if ((*tmp)->nillable) {
2244 type->nillable = 1;
2245 }
2246 if ((*tmp)->fixed) {
2247 type->fixed = estrdup((*tmp)->fixed);
2248 }
2249 if ((*tmp)->def) {
2250 type->def = estrdup((*tmp)->def);
2251 }
2252 type->form = (*tmp)->form;
2253 } else if (strcmp(type->ref, SCHEMA_NAMESPACE ":schema") == 0) {
2254 type->encode = get_conversion(XSD_ANYXML);
2255 } else {
2256 soap_error1(E_ERROR, "Parsing Schema: unresolved element 'ref' attribute '%s'", type->ref);
2257 }
2258 }
2259 efree(type->ref);
2260 type->ref = NULL;
2261 }
2262 if (type->elements) {
2263 zend_hash_internal_pointer_reset(type->elements);
2264 while (zend_hash_get_current_data(type->elements,(void**)&tmp) == SUCCESS) {
2265 schema_type_fixup(ctx,*tmp);
2266 zend_hash_move_forward(type->elements);
2267 }
2268 }
2269 if (type->model) {
2270 schema_content_model_fixup(ctx, type->model);
2271 }
2272 if (type->attributes) {
2273 zend_hash_internal_pointer_reset(type->attributes);
2274 while (zend_hash_get_current_data(type->attributes,(void**)&attr) == SUCCESS) {
2275 if (zend_hash_get_current_key_type(type->attributes) == HASH_KEY_IS_STRING) {
2276 schema_attribute_fixup(ctx,*attr);
2277 zend_hash_move_forward(type->attributes);
2278 } else {
2279 ulong index;
2280
2281 schema_attributegroup_fixup(ctx,*attr,type->attributes);
2282 zend_hash_get_current_key(type->attributes, NULL, &index, 0);
2283 zend_hash_index_del(type->attributes, index);
2284 }
2285 }
2286 }
2287 }
2288
schema_pass2(sdlCtx * ctx)2289 void schema_pass2(sdlCtx *ctx)
2290 {
2291 sdlPtr sdl = ctx->sdl;
2292 sdlAttributePtr *attr;
2293 sdlTypePtr *type;
2294
2295 if (ctx->attributes) {
2296 zend_hash_internal_pointer_reset(ctx->attributes);
2297 while (zend_hash_get_current_data(ctx->attributes,(void**)&attr) == SUCCESS) {
2298 schema_attribute_fixup(ctx,*attr);
2299 zend_hash_move_forward(ctx->attributes);
2300 }
2301 }
2302 if (ctx->attributeGroups) {
2303 zend_hash_internal_pointer_reset(ctx->attributeGroups);
2304 while (zend_hash_get_current_data(ctx->attributeGroups,(void**)&type) == SUCCESS) {
2305 schema_type_fixup(ctx,*type);
2306 zend_hash_move_forward(ctx->attributeGroups);
2307 }
2308 }
2309 if (sdl->elements) {
2310 zend_hash_internal_pointer_reset(sdl->elements);
2311 while (zend_hash_get_current_data(sdl->elements,(void**)&type) == SUCCESS) {
2312 schema_type_fixup(ctx,*type);
2313 zend_hash_move_forward(sdl->elements);
2314 }
2315 }
2316 if (sdl->groups) {
2317 zend_hash_internal_pointer_reset(sdl->groups);
2318 while (zend_hash_get_current_data(sdl->groups,(void**)&type) == SUCCESS) {
2319 schema_type_fixup(ctx,*type);
2320 zend_hash_move_forward(sdl->groups);
2321 }
2322 }
2323 if (sdl->types) {
2324 zend_hash_internal_pointer_reset(sdl->types);
2325 while (zend_hash_get_current_data(sdl->types,(void**)&type) == SUCCESS) {
2326 schema_type_fixup(ctx,*type);
2327 zend_hash_move_forward(sdl->types);
2328 }
2329 }
2330 if (ctx->attributes) {
2331 zend_hash_destroy(ctx->attributes);
2332 efree(ctx->attributes);
2333 }
2334 if (ctx->attributeGroups) {
2335 zend_hash_destroy(ctx->attributeGroups);
2336 efree(ctx->attributeGroups);
2337 }
2338 }
2339
delete_model(void * handle)2340 void delete_model(void *handle)
2341 {
2342 sdlContentModelPtr tmp = *((sdlContentModelPtr*)handle);
2343 switch (tmp->kind) {
2344 case XSD_CONTENT_ELEMENT:
2345 case XSD_CONTENT_GROUP:
2346 break;
2347 case XSD_CONTENT_SEQUENCE:
2348 case XSD_CONTENT_ALL:
2349 case XSD_CONTENT_CHOICE:
2350 zend_hash_destroy(tmp->u.content);
2351 efree(tmp->u.content);
2352 break;
2353 case XSD_CONTENT_GROUP_REF:
2354 efree(tmp->u.group_ref);
2355 break;
2356 default:
2357 break;
2358 }
2359 efree(tmp);
2360 }
2361
delete_model_persistent(void * handle)2362 void delete_model_persistent(void *handle)
2363 {
2364 sdlContentModelPtr tmp = *((sdlContentModelPtr*)handle);
2365 switch (tmp->kind) {
2366 case XSD_CONTENT_ELEMENT:
2367 case XSD_CONTENT_GROUP:
2368 break;
2369 case XSD_CONTENT_SEQUENCE:
2370 case XSD_CONTENT_ALL:
2371 case XSD_CONTENT_CHOICE:
2372 zend_hash_destroy(tmp->u.content);
2373 free(tmp->u.content);
2374 break;
2375 case XSD_CONTENT_GROUP_REF:
2376 free(tmp->u.group_ref);
2377 break;
2378 default:
2379 break;
2380 }
2381 free(tmp);
2382 }
2383
delete_type(void * data)2384 void delete_type(void *data)
2385 {
2386 sdlTypePtr type = *((sdlTypePtr*)data);
2387
2388 if (type->name) {
2389 efree(type->name);
2390 }
2391 if (type->namens) {
2392 efree(type->namens);
2393 }
2394 if (type->def) {
2395 efree(type->def);
2396 }
2397 if (type->fixed) {
2398 efree(type->fixed);
2399 }
2400 if (type->elements) {
2401 zend_hash_destroy(type->elements);
2402 efree(type->elements);
2403 }
2404 if (type->attributes) {
2405 zend_hash_destroy(type->attributes);
2406 efree(type->attributes);
2407 }
2408 if (type->model) {
2409 delete_model((void**)&type->model);
2410 }
2411 if (type->restrictions) {
2412 delete_restriction_var_int(&type->restrictions->minExclusive);
2413 delete_restriction_var_int(&type->restrictions->minInclusive);
2414 delete_restriction_var_int(&type->restrictions->maxExclusive);
2415 delete_restriction_var_int(&type->restrictions->maxInclusive);
2416 delete_restriction_var_int(&type->restrictions->totalDigits);
2417 delete_restriction_var_int(&type->restrictions->fractionDigits);
2418 delete_restriction_var_int(&type->restrictions->length);
2419 delete_restriction_var_int(&type->restrictions->minLength);
2420 delete_restriction_var_int(&type->restrictions->maxLength);
2421 delete_restriction_var_char(&type->restrictions->whiteSpace);
2422 delete_restriction_var_char(&type->restrictions->pattern);
2423 if (type->restrictions->enumeration) {
2424 zend_hash_destroy(type->restrictions->enumeration);
2425 efree(type->restrictions->enumeration);
2426 }
2427 efree(type->restrictions);
2428 }
2429 efree(type);
2430 }
2431
delete_type_persistent(void * data)2432 void delete_type_persistent(void *data)
2433 {
2434 sdlTypePtr type = *((sdlTypePtr*)data);
2435 if (type->name) {
2436 free(type->name);
2437 }
2438 if (type->namens) {
2439 free(type->namens);
2440 }
2441 if (type->def) {
2442 free(type->def);
2443 }
2444 if (type->fixed) {
2445 free(type->fixed);
2446 }
2447 if (type->elements) {
2448 zend_hash_destroy(type->elements);
2449 free(type->elements);
2450 }
2451 if (type->attributes) {
2452 zend_hash_destroy(type->attributes);
2453 free(type->attributes);
2454 }
2455 if (type->model) {
2456 delete_model_persistent((void**)&type->model);
2457 }
2458 if (type->restrictions) {
2459 delete_restriction_var_int_persistent(&type->restrictions->minExclusive);
2460 delete_restriction_var_int_persistent(&type->restrictions->minInclusive);
2461 delete_restriction_var_int_persistent(&type->restrictions->maxExclusive);
2462 delete_restriction_var_int_persistent(&type->restrictions->maxInclusive);
2463 delete_restriction_var_int_persistent(&type->restrictions->totalDigits);
2464 delete_restriction_var_int_persistent(&type->restrictions->fractionDigits);
2465 delete_restriction_var_int_persistent(&type->restrictions->length);
2466 delete_restriction_var_int_persistent(&type->restrictions->minLength);
2467 delete_restriction_var_int_persistent(&type->restrictions->maxLength);
2468 delete_restriction_var_char_persistent(&type->restrictions->whiteSpace);
2469 delete_restriction_var_char_persistent(&type->restrictions->pattern);
2470 if (type->restrictions->enumeration) {
2471 zend_hash_destroy(type->restrictions->enumeration);
2472 free(type->restrictions->enumeration);
2473 }
2474 free(type->restrictions);
2475 }
2476 free(type);
2477 }
2478
delete_extra_attribute(void * attribute)2479 void delete_extra_attribute(void *attribute)
2480 {
2481 sdlExtraAttributePtr attr = *((sdlExtraAttributePtr*)attribute);
2482
2483 if (attr->ns) {
2484 efree(attr->ns);
2485 }
2486 if (attr->val) {
2487 efree(attr->val);
2488 }
2489 efree(attr);
2490 }
2491
delete_extra_attribute_persistent(void * attribute)2492 void delete_extra_attribute_persistent(void *attribute)
2493 {
2494 sdlExtraAttributePtr attr = *((sdlExtraAttributePtr*)attribute);
2495
2496 if (attr->ns) {
2497 free(attr->ns);
2498 }
2499 if (attr->val) {
2500 free(attr->val);
2501 }
2502 free(attr);
2503 }
2504
delete_attribute(void * attribute)2505 void delete_attribute(void *attribute)
2506 {
2507 sdlAttributePtr attr = *((sdlAttributePtr*)attribute);
2508
2509 if (attr->def) {
2510 efree(attr->def);
2511 }
2512 if (attr->fixed) {
2513 efree(attr->fixed);
2514 }
2515 if (attr->name) {
2516 efree(attr->name);
2517 }
2518 if (attr->namens) {
2519 efree(attr->namens);
2520 }
2521 if (attr->ref) {
2522 efree(attr->ref);
2523 }
2524 if (attr->extraAttributes) {
2525 zend_hash_destroy(attr->extraAttributes);
2526 efree(attr->extraAttributes);
2527 }
2528 efree(attr);
2529 }
2530
delete_attribute_persistent(void * attribute)2531 void delete_attribute_persistent(void *attribute)
2532 {
2533 sdlAttributePtr attr = *((sdlAttributePtr*)attribute);
2534
2535 if (attr->def) {
2536 free(attr->def);
2537 }
2538 if (attr->fixed) {
2539 free(attr->fixed);
2540 }
2541 if (attr->name) {
2542 free(attr->name);
2543 }
2544 if (attr->namens) {
2545 free(attr->namens);
2546 }
2547 if (attr->ref) {
2548 free(attr->ref);
2549 }
2550 if (attr->extraAttributes) {
2551 zend_hash_destroy(attr->extraAttributes);
2552 free(attr->extraAttributes);
2553 }
2554 free(attr);
2555 }
2556
delete_restriction_var_int(void * rvi)2557 void delete_restriction_var_int(void *rvi)
2558 {
2559 sdlRestrictionIntPtr ptr = *((sdlRestrictionIntPtr*)rvi);
2560 if (ptr) {
2561 efree(ptr);
2562 }
2563 }
2564
delete_restriction_var_int_persistent(void * rvi)2565 void delete_restriction_var_int_persistent(void *rvi)
2566 {
2567 sdlRestrictionIntPtr ptr = *((sdlRestrictionIntPtr*)rvi);
2568 if (ptr) {
2569 free(ptr);
2570 }
2571 }
2572
delete_restriction_var_char(void * srvc)2573 void delete_restriction_var_char(void *srvc)
2574 {
2575 sdlRestrictionCharPtr ptr = *((sdlRestrictionCharPtr*)srvc);
2576 if (ptr) {
2577 if (ptr->value) {
2578 efree(ptr->value);
2579 }
2580 efree(ptr);
2581 }
2582 }
2583
delete_restriction_var_char_persistent(void * srvc)2584 void delete_restriction_var_char_persistent(void *srvc)
2585 {
2586 sdlRestrictionCharPtr ptr = *((sdlRestrictionCharPtr*)srvc);
2587 if (ptr) {
2588 if (ptr->value) {
2589 free(ptr->value);
2590 }
2591 free(ptr);
2592 }
2593 }
2594
