?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
webservices: Implement WsWriteArray.
[wine.git] / dlls / webservices / reader.c
blobb562c004a7ade71ea6e427b5b209af95bb55bdd2
1 /*
2 * Copyright 2015, 2016 Hans Leidekker for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <stdarg.h>
20
21 #include "windef.h"
22 #include "winbase.h"
23 #include "winnls.h"
24 #include "webservices.h"
25
26 #include "wine/debug.h"
27 #include "wine/list.h"
28 #include "webservices_private.h"
29
30 WINE_DEFAULT_DEBUG_CHANNEL(webservices);
31
32 const char *debugstr_xmlstr( const WS_XML_STRING *str )
33 {
34 if (!str) return "(null)";
35 return debugstr_an( (const char *)str->bytes, str->length );
36 }
37
38 ULONG prop_size( const struct prop_desc *desc, ULONG count )
39 {
40 ULONG i, ret = count * sizeof(struct prop);
41 for (i = 0; i < count; i++) ret += desc[i].size;
42 return ret;
43 }
44
45 void prop_init( const struct prop_desc *desc, ULONG count, struct prop *prop, void *data )
46 {
47 ULONG i;
48 char *ptr = data;
49 for (i = 0; i < count; i++)
50 {
51 prop[i].value = ptr;
52 prop[i].size = desc[i].size;
53 prop[i].readonly = desc[i].readonly;
54 prop[i].writeonly = desc[i].writeonly;
55 ptr += prop[i].size;
56 }
57 }
58
59 HRESULT prop_set( const struct prop *prop, ULONG count, ULONG id, const void *value, ULONG size )
60 {
61 if (id >= count || size != prop[id].size || prop[id].readonly) return E_INVALIDARG;
62 memcpy( prop[id].value, value, size );
63 return S_OK;
64 }
65
66 HRESULT prop_get( const struct prop *prop, ULONG count, ULONG id, void *buf, ULONG size )
67 {
68 if (id >= count || size != prop[id].size || prop[id].writeonly) return E_INVALIDARG;
69 memcpy( buf, prop[id].value, prop[id].size );
70 return S_OK;
71 }
72
73 static const struct prop_desc error_props[] =
74 {
75 { sizeof(ULONG), TRUE }, /* WS_ERROR_PROPERTY_STRING_COUNT */
76 { sizeof(ULONG), FALSE }, /* WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE */
77 { sizeof(LANGID), FALSE } /* WS_ERROR_PROPERTY_LANGID */
78 };
79
80 struct error
81 {
82 ULONG prop_count;
83 struct prop prop[sizeof(error_props)/sizeof(error_props[0])];
84 };
85
86 static struct error *alloc_error(void)
87 {
88 static const ULONG count = sizeof(error_props)/sizeof(error_props[0]);
89 struct error *ret;
90 ULONG size = sizeof(*ret) + prop_size( error_props, count );
91
92 if (!(ret = heap_alloc_zero( size ))) return NULL;
93 prop_init( error_props, count, ret->prop, &ret[1] );
94 ret->prop_count = count;
95 return ret;
96 }
97
98 /**************************************************************************
99 * WsCreateError [webservices.@]
100 */
101 HRESULT WINAPI WsCreateError( const WS_ERROR_PROPERTY *properties, ULONG count, WS_ERROR **handle )
102 {
103 struct error *error;
104 LANGID langid = GetUserDefaultUILanguage();
105 HRESULT hr;
106 ULONG i;
107
108 TRACE( "%p %u %p\n", properties, count, handle );
109
110 if (!handle) return E_INVALIDARG;
111 if (!(error = alloc_error())) return E_OUTOFMEMORY;
112
113 prop_set( error->prop, error->prop_count, WS_ERROR_PROPERTY_LANGID, &langid, sizeof(langid) );
114 for (i = 0; i < count; i++)
115 {
116 if (properties[i].id == WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE)
117 {
118 heap_free( error );
119 return E_INVALIDARG;
120 }
121 hr = prop_set( error->prop, error->prop_count, properties[i].id, properties[i].value,
122 properties[i].valueSize );
123 if (hr != S_OK)
124 {
125 heap_free( error );
126 return hr;
127 }
128 }
129
130 *handle = (WS_ERROR *)error;
131 return S_OK;
132 }
133
134 /**************************************************************************
135 * WsFreeError [webservices.@]
136 */
137 void WINAPI WsFreeError( WS_ERROR *handle )
138 {
139 struct error *error = (struct error *)handle;
140
141 TRACE( "%p\n", handle );
142 heap_free( error );
143 }
144
145 /**************************************************************************
146 * WsResetError [webservices.@]
147 */
148 HRESULT WINAPI WsResetError( WS_ERROR *handle )
149 {
150 struct error *error = (struct error *)handle;
151 ULONG code;
152
153 TRACE( "%p\n", handle );
154
155 if (!handle) return E_INVALIDARG;
156
157 /* FIXME: release strings added with WsAddErrorString when it's implemented, reset string count */
158 code = 0;
159 return prop_set( error->prop, error->prop_count, WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE, &code, sizeof(code) );
160 }
161
162 static const struct prop_desc heap_props[] =
163 {
164 { sizeof(SIZE_T), FALSE }, /* WS_HEAP_PROPERTY_MAX_SIZE */
165 { sizeof(SIZE_T), FALSE }, /* WS_HEAP_PROPERTY_TRIM_SIZE */
166 { sizeof(SIZE_T), TRUE }, /* WS_HEAP_PROPERTY_REQUESTED_SIZE */
167 { sizeof(SIZE_T), TRUE } /* WS_HEAP_PROPERTY_ACTUAL_SIZE */
168 };
169
170 struct heap
171 {
172 HANDLE handle;
173 ULONG prop_count;
174 struct prop prop[sizeof(heap_props)/sizeof(heap_props[0])];
175 };
176
177 static BOOL ensure_heap( struct heap *heap )
178 {
179 SIZE_T size;
180 if (heap->handle) return TRUE;
181 if (prop_get( heap->prop, heap->prop_count, WS_HEAP_PROPERTY_MAX_SIZE, &size, sizeof(size) ) != S_OK)
182 return FALSE;
183 if (!(heap->handle = HeapCreate( 0, 0, size ))) return FALSE;
184 return TRUE;
185 }
186
187 void *ws_alloc( WS_HEAP *handle, SIZE_T size )
188 {
189 struct heap *heap = (struct heap *)handle;
190 if (!ensure_heap( heap )) return NULL;
191 return HeapAlloc( heap->handle, 0, size );
192 }
193
194 static void *ws_alloc_zero( WS_HEAP *handle, SIZE_T size )
195 {
196 struct heap *heap = (struct heap *)handle;
197 if (!ensure_heap( heap )) return NULL;
198 return HeapAlloc( heap->handle, HEAP_ZERO_MEMORY, size );
199 }
200
201 void *ws_realloc( WS_HEAP *handle, void *ptr, SIZE_T size )
202 {
203 struct heap *heap = (struct heap *)handle;
204 if (!ensure_heap( heap )) return NULL;
205 return HeapReAlloc( heap->handle, 0, ptr, size );
206 }
207
208 static void *ws_realloc_zero( WS_HEAP *handle, void *ptr, SIZE_T size )
209 {
210 struct heap *heap = (struct heap *)handle;
211 if (!ensure_heap( heap )) return NULL;
212 return HeapReAlloc( heap->handle, HEAP_ZERO_MEMORY, ptr, size );
213 }
214
215 void ws_free( WS_HEAP *handle, void *ptr )
216 {
217 struct heap *heap = (struct heap *)handle;
218 if (!heap->handle) return;
219 HeapFree( heap->handle, 0, ptr );
220 }
221
222 /**************************************************************************
223 * WsAlloc [webservices.@]
224 */
225 HRESULT WINAPI WsAlloc( WS_HEAP *handle, SIZE_T size, void **ptr, WS_ERROR *error )
226 {
227 void *mem;
228
229 TRACE( "%p %u %p %p\n", handle, (ULONG)size, ptr, error );
230 if (error) FIXME( "ignoring error parameter\n" );
231
232 if (!handle || !ptr) return E_INVALIDARG;
233
234 if (!(mem = ws_alloc( handle, size ))) return E_OUTOFMEMORY;
235 *ptr = mem;
236 return S_OK;
237 }
238
239 static struct heap *alloc_heap(void)
240 {
241 static const ULONG count = sizeof(heap_props)/sizeof(heap_props[0]);
242 struct heap *ret;
243 ULONG size = sizeof(*ret) + prop_size( heap_props, count );
244
245 if (!(ret = heap_alloc_zero( size ))) return NULL;
246 prop_init( heap_props, count, ret->prop, &ret[1] );
247 ret->prop_count = count;
248 return ret;
249 }
250
251 /**************************************************************************
252 * WsCreateHeap [webservices.@]
253 */
254 HRESULT WINAPI WsCreateHeap( SIZE_T max_size, SIZE_T trim_size, const WS_HEAP_PROPERTY *properties,
255 ULONG count, WS_HEAP **handle, WS_ERROR *error )
256 {
257 struct heap *heap;
258
259 TRACE( "%u %u %p %u %p %p\n", (ULONG)max_size, (ULONG)trim_size, properties, count, handle, error );
260 if (error) FIXME( "ignoring error parameter\n" );
261
262 if (!handle || count) return E_INVALIDARG;
263 if (!(heap = alloc_heap())) return E_OUTOFMEMORY;
264
265 prop_set( heap->prop, heap->prop_count, WS_HEAP_PROPERTY_MAX_SIZE, &max_size, sizeof(max_size) );
266 prop_set( heap->prop, heap->prop_count, WS_HEAP_PROPERTY_TRIM_SIZE, &trim_size, sizeof(trim_size) );
267
268 *handle = (WS_HEAP *)heap;
269 return S_OK;
270 }
271
272 /**************************************************************************
273 * WsFreeHeap [webservices.@]
274 */
275 void WINAPI WsFreeHeap( WS_HEAP *handle )
276 {
277 struct heap *heap = (struct heap *)handle;
278
279 TRACE( "%p\n", handle );
280
281 if (!heap) return;
282 HeapDestroy( heap->handle );
283 heap_free( heap );
284 }
285
286 /**************************************************************************
287 * WsResetHeap [webservices.@]
288 */
289 HRESULT WINAPI WsResetHeap( WS_HEAP *handle, WS_ERROR *error )
290 {
291 struct heap *heap = (struct heap *)handle;
292
293 TRACE( "%p %p\n", handle, error );
294 if (error) FIXME( "ignoring error parameter\n" );
295
296 if (!heap) return E_INVALIDARG;
297
298 HeapDestroy( heap->handle );
299 heap->handle = NULL;
300 return S_OK;
301 }
302
303 struct node *alloc_node( WS_XML_NODE_TYPE type )
304 {
305 struct node *ret;
306
307 if (!(ret = heap_alloc_zero( sizeof(*ret) ))) return NULL;
308 ret->hdr.node.nodeType = type;
309 list_init( &ret->entry );
310 list_init( &ret->children );
311 return ret;
312 }
313
314 void free_attribute( WS_XML_ATTRIBUTE *attr )
315 {
316 if (!attr) return;
317 heap_free( attr->prefix );
318 heap_free( attr->localName );
319 heap_free( attr->ns );
320 heap_free( attr->value );
321 heap_free( attr );
322 }
323
324 void free_node( struct node *node )
325 {
326 if (!node) return;
327 switch (node_type( node ))
328 {
329 case WS_XML_NODE_TYPE_ELEMENT:
330 {
331 WS_XML_ELEMENT_NODE *elem = &node->hdr;
332 ULONG i;
333
334 for (i = 0; i < elem->attributeCount; i++) free_attribute( elem->attributes[i] );
335 heap_free( elem->attributes );
336 heap_free( elem->prefix );
337 heap_free( elem->localName );
338 heap_free( elem->ns );
339 break;
340 }
341 case WS_XML_NODE_TYPE_TEXT:
342 {
343 WS_XML_TEXT_NODE *text = (WS_XML_TEXT_NODE *)node;
344 heap_free( text->text );
345 break;
346 }
347 case WS_XML_NODE_TYPE_COMMENT:
348 {
349 WS_XML_COMMENT_NODE *comment = (WS_XML_COMMENT_NODE *)node;
350 heap_free( comment->value.bytes );
351 break;
352 }
353 case WS_XML_NODE_TYPE_CDATA:
354 case WS_XML_NODE_TYPE_END_CDATA:
355 case WS_XML_NODE_TYPE_END_ELEMENT:
356 case WS_XML_NODE_TYPE_EOF:
357 case WS_XML_NODE_TYPE_BOF:
358 break;
359
360 default:
361 ERR( "unhandled type %u\n", node_type( node ) );
362 break;
363 }
364 heap_free( node );
365 }
366
367 void destroy_nodes( struct node *node )
368 {
369 struct list *ptr;
370
371 if (!node) return;
372 while ((ptr = list_head( &node->children )))
373 {
374 struct node *child = LIST_ENTRY( ptr, struct node, entry );
375 list_remove( &child->entry );
376 destroy_nodes( child );
377 }
378 free_node( node );
379 }
380
381 static WS_XML_ATTRIBUTE *dup_attribute( const WS_XML_ATTRIBUTE *src )
382 {
383 WS_XML_ATTRIBUTE *dst;
384 const WS_XML_STRING *prefix = (src->prefix && src->prefix->length) ? src->prefix : NULL;
385 const WS_XML_STRING *localname = src->localName;
386 const WS_XML_STRING *ns = src->localName;
387
388 if (!(dst = heap_alloc( sizeof(*dst) ))) return NULL;
389 dst->singleQuote = src->singleQuote;
390 dst->isXmlNs = src->isXmlNs;
391 if (prefix && !(dst->prefix = alloc_xml_string( prefix->bytes, prefix->length ))) goto error;
392 if (localname && !(dst->localName = alloc_xml_string( localname->bytes, localname->length ))) goto error;
393 if (ns && !(dst->ns = alloc_xml_string( ns->bytes, ns->length ))) goto error;
394 return dst;
395
396 error:
397 free_attribute( dst );
398 return NULL;
399 }
400
401 static WS_XML_ATTRIBUTE **dup_attributes( WS_XML_ATTRIBUTE * const *src, ULONG count )
402 {
403 WS_XML_ATTRIBUTE **dst;
404 ULONG i;
405
406 if (!(dst = heap_alloc( sizeof(*dst) * count ))) return NULL;
407 for (i = 0; i < count; i++)
408 {
409 if (!(dst[i] = dup_attribute( src[i] )))
410 {
411 for (; i > 0; i--) free_attribute( dst[i - 1] );
412 heap_free( dst );
413 return NULL;
414 }
415 }
416 return dst;
417 }
418
419 static struct node *dup_element_node( const WS_XML_ELEMENT_NODE *src )
420 {
421 struct node *node;
422 WS_XML_ELEMENT_NODE *dst;
423 ULONG count = src->attributeCount;
424 WS_XML_ATTRIBUTE **attrs = src->attributes;
425 const WS_XML_STRING *prefix = (src->prefix && src->prefix->length) ? src->prefix : NULL;
426 const WS_XML_STRING *localname = src->localName;
427 const WS_XML_STRING *ns = src->ns;
428
429 if (!(node = alloc_node( WS_XML_NODE_TYPE_ELEMENT ))) return NULL;
430 dst = &node->hdr;
431
432 if (count && !(dst->attributes = dup_attributes( attrs, count ))) goto error;
433 dst->attributeCount = count;
434
435 if (prefix && !(dst->prefix = alloc_xml_string( prefix->bytes, prefix->length ))) goto error;
436 if (localname && !(dst->localName = alloc_xml_string( localname->bytes, localname->length ))) goto error;
437 if (ns && !(dst->ns = alloc_xml_string( ns->bytes, ns->length ))) goto error;
438 return node;
439
440 error:
441 free_node( node );
442 return NULL;
443 }
444
445 static struct node *dup_text_node( const WS_XML_TEXT_NODE *src )
446 {
447 struct node *node;
448 WS_XML_TEXT_NODE *dst;
449
450 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return NULL;
451 dst = (WS_XML_TEXT_NODE *)node;
452
453 if (src->text)
454 {
455 WS_XML_UTF8_TEXT *utf8;
456 const WS_XML_UTF8_TEXT *utf8_src = (WS_XML_UTF8_TEXT *)src->text;
457 if (!(utf8 = alloc_utf8_text( utf8_src->value.bytes, utf8_src->value.length )))
458 {
459 free_node( node );
460 return NULL;
461 }
462 dst->text = &utf8->text;
463 }
464 return node;
465 }
466
467 static struct node *dup_comment_node( const WS_XML_COMMENT_NODE *src )
468 {
469 struct node *node;
470 WS_XML_COMMENT_NODE *dst;
471
472 if (!(node = alloc_node( WS_XML_NODE_TYPE_COMMENT ))) return NULL;
473 dst = (WS_XML_COMMENT_NODE *)node;
474
475 if (src->value.length && !(dst->value.bytes = heap_alloc( src->value.length )))
476 {
477 free_node( node );
478 return NULL;
479 }
480 memcpy( dst->value.bytes, src->value.bytes, src->value.length );
481 dst->value.length = src->value.length;
482 return node;
483 }
484
485 static struct node *dup_node( const struct node *src )
486 {
487 switch (node_type( src ))
488 {
489 case WS_XML_NODE_TYPE_ELEMENT:
490 return dup_element_node( &src->hdr );
491
492 case WS_XML_NODE_TYPE_TEXT:
493 return dup_text_node( (const WS_XML_TEXT_NODE *)src );
494
495 case WS_XML_NODE_TYPE_COMMENT:
496 return dup_comment_node( (const WS_XML_COMMENT_NODE *)src );
497
498 case WS_XML_NODE_TYPE_CDATA:
499 case WS_XML_NODE_TYPE_END_CDATA:
500 case WS_XML_NODE_TYPE_END_ELEMENT:
501 case WS_XML_NODE_TYPE_EOF:
502 case WS_XML_NODE_TYPE_BOF:
503 return alloc_node( node_type( src ) );
504
505 default:
506 ERR( "unhandled type %u\n", node_type( src ) );
507 break;
508 }
509 return NULL;
510 }
511
512 static HRESULT dup_tree( struct node **dst, const struct node *src )
513 {
514 struct node *parent;
515 const struct node *child;
516
517 if (!*dst && !(*dst = dup_node( src ))) return E_OUTOFMEMORY;
518 parent = *dst;
519
520 LIST_FOR_EACH_ENTRY( child, &src->children, struct node, entry )
521 {
522 HRESULT hr = E_OUTOFMEMORY;
523 struct node *new_child;
524
525 if (!(new_child = dup_node( child )) || (hr = dup_tree( &new_child, child )) != S_OK)
526 {
527 destroy_nodes( *dst );
528 return hr;
529 }
530 new_child->parent = parent;
531 list_add_tail( &parent->children, &new_child->entry );
532 }
533 return S_OK;
534 }
535
536 static const struct prop_desc reader_props[] =
537 {
538 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_DEPTH */
539 { sizeof(BOOL), FALSE }, /* WS_XML_READER_PROPERTY_ALLOW_FRAGMENT */
540 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_ATTRIBUTES */
541 { sizeof(BOOL), FALSE }, /* WS_XML_READER_PROPERTY_READ_DECLARATION */
542 { sizeof(WS_CHARSET), FALSE }, /* WS_XML_READER_PROPERTY_CHARSET */
543 { sizeof(ULONGLONG), TRUE }, /* WS_XML_READER_PROPERTY_ROW */
544 { sizeof(ULONGLONG), TRUE }, /* WS_XML_READER_PROPERTY_COLUMN */
545 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_UTF8_TRIM_SIZE */
546 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_STREAM_BUFFER_SIZE */
547 { sizeof(BOOL), TRUE }, /* WS_XML_READER_PROPERTY_IN_ATTRIBUTE */
548 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_STREAM_MAX_ROOT_MIME_PART_SIZE */
549 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_STREAM_MAX_MIME_HEADERS_SIZE */
550 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_MIME_PARTS */
551 { sizeof(BOOL), FALSE }, /* WS_XML_READER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES */
552 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_NAMESPACES */
553 };
554
555 enum reader_state
556 {
557 READER_STATE_INITIAL,
558 READER_STATE_BOF,
559 READER_STATE_STARTELEMENT,
560 READER_STATE_STARTATTRIBUTE,
561 READER_STATE_STARTCDATA,
562 READER_STATE_CDATA,
563 READER_STATE_TEXT,
564 READER_STATE_ENDELEMENT,
565 READER_STATE_ENDCDATA,
566 READER_STATE_COMMENT,
567 READER_STATE_EOF
568 };
569
570 struct prefix
571 {
572 WS_XML_STRING str;
573 WS_XML_STRING ns;
574 };
575
576 struct reader
577 {
578 ULONG read_size;
579 ULONG read_pos;
580 const unsigned char *read_bufptr;
581 enum reader_state state;
582 struct node *root;
583 struct node *current;
584 ULONG current_attr;
585 struct node *last;
586 struct prefix *prefixes;
587 ULONG nb_prefixes;
588 ULONG nb_prefixes_allocated;
589 WS_XML_READER_INPUT_TYPE input_type;
590 struct xmlbuf *input_buf;
591 const unsigned char *input_data;
592 ULONG input_size;
593 ULONG prop_count;
594 struct prop prop[sizeof(reader_props)/sizeof(reader_props[0])];
595 };
596
597 static struct reader *alloc_reader(void)
598 {
599 static const ULONG count = sizeof(reader_props)/sizeof(reader_props[0]);
600 struct reader *ret;
601 ULONG size = sizeof(*ret) + prop_size( reader_props, count );
602
603 if (!(ret = heap_alloc_zero( size ))) return NULL;
604 if (!(ret->prefixes = heap_alloc_zero( sizeof(*ret->prefixes) )))
605 {
606 heap_free( ret );
607 return NULL;
608 }
609 ret->nb_prefixes = ret->nb_prefixes_allocated = 1;
610
611 prop_init( reader_props, count, ret->prop, &ret[1] );
612 ret->prop_count = count;
613 return ret;
614 }
615
616 static void clear_prefixes( struct prefix *prefixes, ULONG count )
617 {
618 ULONG i;
619 for (i = 0; i < count; i++)
620 {
621 heap_free( prefixes[i].str.bytes );
622 prefixes[i].str.bytes = NULL;
623 prefixes[i].str.length = 0;
624
625 heap_free( prefixes[i].ns.bytes );
626 prefixes[i].ns.bytes = NULL;
627 prefixes[i].ns.length = 0;
628 }
629 }
630
631 static void free_reader( struct reader *reader )
632 {
633 if (!reader) return;
634 destroy_nodes( reader->root );
635 clear_prefixes( reader->prefixes, reader->nb_prefixes );
636 heap_free( reader->prefixes );
637 heap_free( reader );
638 }
639
640 HRESULT copy_node( WS_XML_READER *handle, struct node **node )
641 {
642 struct reader *reader = (struct reader *)handle;
643 return dup_tree( node, reader->current );
644 }
645
646 static HRESULT set_prefix( struct prefix *prefix, const WS_XML_STRING *str, const WS_XML_STRING *ns )
647 {
648 if (str)
649 {
650 heap_free( prefix->str.bytes );
651 if (!(prefix->str.bytes = heap_alloc( str->length ))) return E_OUTOFMEMORY;
652 memcpy( prefix->str.bytes, str->bytes, str->length );
653 prefix->str.length = str->length;
654 }
655
656 heap_free( prefix->ns.bytes );
657 if (!(prefix->ns.bytes = heap_alloc( ns->length ))) return E_OUTOFMEMORY;
658 memcpy( prefix->ns.bytes, ns->bytes, ns->length );
659 prefix->ns.length = ns->length;
660
661 return S_OK;
662 }
663
664 static HRESULT bind_prefix( struct reader *reader, const WS_XML_STRING *prefix, const WS_XML_STRING *ns )
665 {
666 ULONG i;
667 HRESULT hr;
668
669 for (i = 0; i < reader->nb_prefixes; i++)
670 {
671 if (WsXmlStringEquals( prefix, &reader->prefixes[i].str, NULL ) == S_OK)
672 return set_prefix( &reader->prefixes[i], NULL, ns );
673 }
674 if (i >= reader->nb_prefixes_allocated)
675 {
676 ULONG new_size = reader->nb_prefixes_allocated * sizeof(*reader->prefixes) * 2;
677 struct prefix *tmp = heap_realloc_zero( reader->prefixes, new_size );
678 if (!tmp) return E_OUTOFMEMORY;
679 reader->prefixes = tmp;
680 reader->nb_prefixes_allocated *= 2;
681 }
682
683 if ((hr = set_prefix( &reader->prefixes[i], prefix, ns )) != S_OK) return hr;
684 reader->nb_prefixes++;
685 return S_OK;
686 }
687
688 static const WS_XML_STRING *get_namespace( struct reader *reader, const WS_XML_STRING *prefix )
689 {
690 ULONG i;
691 for (i = 0; i < reader->nb_prefixes; i++)
692 {
693 if (WsXmlStringEquals( prefix, &reader->prefixes[i].str, NULL ) == S_OK)
694 return &reader->prefixes[i].ns;
695 }
696 return NULL;
697 }
698
699 static void read_insert_eof( struct reader *reader, struct node *eof )
700 {
701 if (!reader->root) reader->root = eof;
702 else
703 {
704 eof->parent = reader->root;
705 list_add_tail( &reader->root->children, &eof->entry );
706 }
707 reader->current = reader->last = eof;
708 }
709
710 static void read_insert_bof( struct reader *reader, struct node *bof )
711 {
712 reader->root->parent = bof;
713 list_add_tail( &bof->children, &reader->root->entry );
714 reader->current = reader->last = reader->root = bof;
715 }
716
717 static void read_insert_node( struct reader *reader, struct node *parent, struct node *node )
718 {
719 node->parent = parent;
720 list_add_before( list_tail( &parent->children ), &node->entry );
721 reader->current = reader->last = node;
722 }
723
724 static HRESULT read_init_state( struct reader *reader )
725 {
726 struct node *node;
727
728 destroy_nodes( reader->root );
729 reader->root = NULL;
730 reader->input_buf = NULL;
731 clear_prefixes( reader->prefixes, reader->nb_prefixes );
732 reader->nb_prefixes = 1;
733 if (!(node = alloc_node( WS_XML_NODE_TYPE_EOF ))) return E_OUTOFMEMORY;
734 read_insert_eof( reader, node );
735 reader->state = READER_STATE_INITIAL;
736 return S_OK;
737 }
738
739 /**************************************************************************
740 * WsCreateReader [webservices.@]
741 */
742 HRESULT WINAPI WsCreateReader( const WS_XML_READER_PROPERTY *properties, ULONG count,
743 WS_XML_READER **handle, WS_ERROR *error )
744 {
745 struct reader *reader;
746 ULONG i, max_depth = 32, max_attrs = 128, max_ns = 32;
747 WS_CHARSET charset = WS_CHARSET_UTF8;
748 BOOL read_decl = TRUE;
749 HRESULT hr;
750
751 TRACE( "%p %u %p %p\n", properties, count, handle, error );
752 if (error) FIXME( "ignoring error parameter\n" );
753
754 if (!handle) return E_INVALIDARG;
755 if (!(reader = alloc_reader())) return E_OUTOFMEMORY;
756
757 prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_MAX_DEPTH, &max_depth, sizeof(max_depth) );
758 prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_MAX_ATTRIBUTES, &max_attrs, sizeof(max_attrs) );
759 prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_READ_DECLARATION, &read_decl, sizeof(read_decl) );
760 prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_CHARSET, &charset, sizeof(charset) );
761 prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_MAX_NAMESPACES, &max_ns, sizeof(max_ns) );
762
763 for (i = 0; i < count; i++)
764 {
765 hr = prop_set( reader->prop, reader->prop_count, properties[i].id, properties[i].value,
766 properties[i].valueSize );
767 if (hr != S_OK)
768 {
769 free_reader( reader );
770 return hr;
771 }
772 }
773
774 if ((hr = read_init_state( reader )) != S_OK)
775 {
776 free_reader( reader );
777 return hr;
778 }
779
780 *handle = (WS_XML_READER *)reader;
781 return S_OK;
782 }
783
784 /**************************************************************************
785 * WsFreeReader [webservices.@]
786 */
787 void WINAPI WsFreeReader( WS_XML_READER *handle )
788 {
789 struct reader *reader = (struct reader *)handle;
790
791 TRACE( "%p\n", handle );
792 free_reader( reader );
793 }
794
795 /**************************************************************************
796 * WsFillReader [webservices.@]
797 */
798 HRESULT WINAPI WsFillReader( WS_XML_READER *handle, ULONG min_size, const WS_ASYNC_CONTEXT *ctx,
799 WS_ERROR *error )
800 {
801 struct reader *reader = (struct reader *)handle;
802
803 TRACE( "%p %u %p %p\n", handle, min_size, ctx, error );
804 if (error) FIXME( "ignoring error parameter\n" );
805
806 if (!reader) return E_INVALIDARG;
807
808 /* FIXME: add support for stream input */
809 reader->read_size = min( min_size, reader->input_size );
810 reader->read_pos = 0;
811
812 return S_OK;
813 }
814
815 /**************************************************************************
816 * WsGetErrorProperty [webservices.@]
817 */
818 HRESULT WINAPI WsGetErrorProperty( WS_ERROR *handle, WS_ERROR_PROPERTY_ID id, void *buf,
819 ULONG size )
820 {
821 struct error *error = (struct error *)handle;
822
823 TRACE( "%p %u %p %u\n", handle, id, buf, size );
824 return prop_get( error->prop, error->prop_count, id, buf, size );
825 }
826
827 /**************************************************************************
828 * WsGetErrorString [webservices.@]
829 */
830 HRESULT WINAPI WsGetErrorString( WS_ERROR *handle, ULONG index, WS_STRING *str )
831 {
832 FIXME( "%p %u %p: stub\n", handle, index, str );
833 return E_NOTIMPL;
834 }
835
836 /**************************************************************************
837 * WsGetHeapProperty [webservices.@]
838 */
839 HRESULT WINAPI WsGetHeapProperty( WS_HEAP *handle, WS_HEAP_PROPERTY_ID id, void *buf,
840 ULONG size, WS_ERROR *error )
841 {
842 struct heap *heap = (struct heap *)handle;
843
844 TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
845 if (error) FIXME( "ignoring error parameter\n" );
846
847 return prop_get( heap->prop, heap->prop_count, id, buf, size );
848 }
849
850 /**************************************************************************
851 * WsGetNamespaceFromPrefix [webservices.@]
852 */
853 HRESULT WINAPI WsGetNamespaceFromPrefix( WS_XML_READER *handle, const WS_XML_STRING *prefix,
854 BOOL required, const WS_XML_STRING **ns, WS_ERROR *error )
855 {
856 static const WS_XML_STRING xml = {3, (BYTE *)"xml"};
857 static const WS_XML_STRING xmlns = {5, (BYTE *)"xmlns"};
858 static const WS_XML_STRING empty_ns = {0, NULL};
859 static const WS_XML_STRING xml_ns = {36, (BYTE *)"http://www.w3.org/XML/1998/namespace"};
860 static const WS_XML_STRING xmlns_ns = {29, (BYTE *)"http://www.w3.org/2000/xmlns/"};
861 struct reader *reader = (struct reader *)handle;
862 BOOL found = FALSE;
863
864 TRACE( "%p %s %d %p %p\n", handle, debugstr_xmlstr(prefix), required, ns, error );
865 if (error) FIXME( "ignoring error parameter\n" );
866
867 if (!reader || !prefix || !ns) return E_INVALIDARG;
868 if (reader->state != READER_STATE_STARTELEMENT) return WS_E_INVALID_OPERATION;
869
870 if (!prefix->length)
871 {
872 *ns = &empty_ns;
873 found = TRUE;
874 }
875 else if (WsXmlStringEquals( prefix, &xml, NULL ) == S_OK)
876 {
877 *ns = &xml_ns;
878 found = TRUE;
879 }
880 else if (WsXmlStringEquals( prefix, &xmlns, NULL ) == S_OK)
881 {
882 *ns = &xmlns_ns;
883 found = TRUE;
884 }
885 else
886 {
887 WS_XML_ELEMENT_NODE *elem = &reader->current->hdr;
888 ULONG i;
889
890 for (i = 0; i < elem->attributeCount; i++)
891 {
892 if (!elem->attributes[i]->isXmlNs) continue;
893 if (WsXmlStringEquals( prefix, elem->attributes[i]->prefix, NULL ) == S_OK)
894 {
895 *ns = elem->attributes[i]->ns;
896 found = TRUE;
897 break;
898 }
899 }
900 }
901
902 if (!found)
903 {
904 if (required) return WS_E_INVALID_FORMAT;
905 *ns = NULL;
906 return S_FALSE;
907 }
908 return S_OK;
909 }
910
911 /**************************************************************************
912 * WsGetReaderNode [webservices.@]
913 */
914 HRESULT WINAPI WsGetReaderNode( WS_XML_READER *handle, const WS_XML_NODE **node,
915 WS_ERROR *error )
916 {
917 struct reader *reader = (struct reader *)handle;
918
919 TRACE( "%p %p %p\n", handle, node, error );
920 if (error) FIXME( "ignoring error parameter\n" );
921
922 if (!reader || !node) return E_INVALIDARG;
923
924 *node = &reader->current->hdr.node;
925 return S_OK;
926 }
927
928 /**************************************************************************
929 * WsGetReaderProperty [webservices.@]
930 */
931 HRESULT WINAPI WsGetReaderProperty( WS_XML_READER *handle, WS_XML_READER_PROPERTY_ID id,
932 void *buf, ULONG size, WS_ERROR *error )
933 {
934 struct reader *reader = (struct reader *)handle;
935
936 TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
937 if (error) FIXME( "ignoring error parameter\n" );
938
939 if (!reader->input_type) return WS_E_INVALID_OPERATION;
940
941 if (id == WS_XML_READER_PROPERTY_CHARSET)
942 {
943 WS_CHARSET charset;
944 HRESULT hr;
945
946 if ((hr = prop_get( reader->prop, reader->prop_count, id, &charset, size )) != S_OK) return hr;
947 if (!charset) return WS_E_INVALID_FORMAT;
948 *(WS_CHARSET *)buf = charset;
949 return S_OK;
950 }
951 return prop_get( reader->prop, reader->prop_count, id, buf, size );
952 }
953
954 /**************************************************************************
955 * WsGetXmlAttribute [webservices.@]
956 */
957 HRESULT WINAPI WsGetXmlAttribute( WS_XML_READER *handle, const WS_XML_STRING *attr,
958 WS_HEAP *heap, WCHAR **str, ULONG *len, WS_ERROR *error )
959 {
960 FIXME( "%p %s %p %p %p %p: stub\n", handle, debugstr_xmlstr(attr), heap, str, len, error );
961 return E_NOTIMPL;
962 }
963
964 WS_XML_STRING *alloc_xml_string( const unsigned char *data, ULONG len )
965 {
966 WS_XML_STRING *ret;
967
968 if (!(ret = heap_alloc( sizeof(*ret) + len ))) return NULL;
969 ret->length = len;
970 ret->bytes = len ? (BYTE *)(ret + 1) : NULL;
971 ret->dictionary = NULL;
972 ret->id = 0;
973 if (data) memcpy( ret->bytes, data, len );
974 return ret;
975 }
976
977 WS_XML_UTF8_TEXT *alloc_utf8_text( const unsigned char *data, ULONG len )
978 {
979 WS_XML_UTF8_TEXT *ret;
980
981 if (!(ret = heap_alloc( sizeof(*ret) + len ))) return NULL;
982 ret->text.textType = WS_XML_TEXT_TYPE_UTF8;
983 ret->value.length = len;
984 ret->value.bytes = len ? (BYTE *)(ret + 1) : NULL;
985 ret->value.dictionary = NULL;
986 ret->value.id = 0;
987 if (data) memcpy( ret->value.bytes, data, len );
988 return ret;
989 }
990
991 static inline BOOL read_end_of_data( struct reader *reader )
992 {
993 return reader->read_pos >= reader->read_size;
994 }
995
996 static inline const unsigned char *read_current_ptr( struct reader *reader )
997 {
998 return &reader->read_bufptr[reader->read_pos];
999 }
1000
1001 /* UTF-8 support based on libs/wine/utf8.c */
1002
1003 /* number of following bytes in sequence based on first byte value (for bytes above 0x7f) */
1004 static const char utf8_length[128] =
1005 {
1006 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x80-0x8f */
1007 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x90-0x9f */
1008 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xa0-0xaf */
1009 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xb0-0xbf */
1010 0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 0xc0-0xcf */
1011 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 0xd0-0xdf */
1012 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, /* 0xe0-0xef */
1013 3,3,3,3,3,0,0,0,0,0,0,0,0,0,0,0 /* 0xf0-0xff */
1014 };
1015
1016 /* first byte mask depending on UTF-8 sequence length */
1017 static const unsigned char utf8_mask[4] = { 0x7f, 0x1f, 0x0f, 0x07 };
1018
1019 /* minimum Unicode value depending on UTF-8 sequence length */
1020 static const unsigned int utf8_minval[4] = { 0x0, 0x80, 0x800, 0x10000 };
1021
1022 static inline unsigned int read_utf8_char( struct reader *reader, unsigned int *skip )
1023 {
1024 unsigned int len, res;
1025 unsigned char ch = reader->read_bufptr[reader->read_pos];
1026 const unsigned char *end;
1027
1028 if (reader->read_pos >= reader->read_size) return 0;
1029
1030 if (ch < 0x80)
1031 {
1032 *skip = 1;
1033 return ch;
1034 }
1035 len = utf8_length[ch - 0x80];
1036 if (reader->read_pos + len >= reader->read_size) return 0;
1037 end = reader->read_bufptr + reader->read_pos + len;
1038 res = ch & utf8_mask[len];
1039
1040 switch (len)
1041 {
1042 case 3:
1043 if ((ch = end[-3] ^ 0x80) >= 0x40) break;
1044 res = (res << 6) | ch;
1045 case 2:
1046 if ((ch = end[-2] ^ 0x80) >= 0x40) break;
1047 res = (res << 6) | ch;
1048 case 1:
1049 if ((ch = end[-1] ^ 0x80) >= 0x40) break;
1050 res = (res << 6) | ch;
1051 if (res < utf8_minval[len]) break;
1052 *skip = len + 1;
1053 return res;
1054 }
1055
1056 return 0;
1057 }
1058
1059 static inline void read_skip( struct reader *reader, unsigned int count )
1060 {
1061 if (reader->read_pos + count > reader->read_size) return;
1062 reader->read_pos += count;
1063 }
1064
1065 static inline void read_rewind( struct reader *reader, unsigned int count )
1066 {
1067 reader->read_pos -= count;
1068 }
1069
1070 static inline BOOL read_isnamechar( unsigned int ch )
1071 {
1072 /* FIXME: incomplete */
1073 return (ch >= 'A' && ch <= 'Z') ||
1074 (ch >= 'a' && ch <= 'z') ||
1075 (ch >= '0' && ch <= '9') ||
1076 ch == '_' || ch == '-' || ch == '.' || ch == ':';
1077 }
1078
1079 static inline BOOL read_isspace( unsigned int ch )
1080 {
1081 return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n';
1082 }
1083
1084 static inline void read_skip_whitespace( struct reader *reader )
1085 {
1086 while (reader->read_pos < reader->read_size && read_isspace( reader->read_bufptr[reader->read_pos] ))
1087 reader->read_pos++;
1088 }
1089
1090 static inline int read_cmp( struct reader *reader, const char *str, int len )
1091 {
1092 const unsigned char *ptr = read_current_ptr( reader );
1093
1094 if (len < 0) len = strlen( str );
1095 if (reader->read_pos + len > reader->read_size) return -1;
1096 while (len--)
1097 {
1098 if (*str != *ptr) return *ptr - *str;
1099 str++; ptr++;
1100 }
1101 return 0;
1102 }
1103
1104 static HRESULT read_xmldecl( struct reader *reader )
1105 {
1106 if (!reader->read_size) return WS_E_INVALID_FORMAT;
1107
1108 if (read_cmp( reader, "<", 1 ) || read_cmp( reader, "<?", 2 ))
1109 {
1110 reader->state = READER_STATE_BOF;
1111 return S_OK;
1112 }
1113 if (read_cmp( reader, "<?xml ", 6 )) return WS_E_INVALID_FORMAT;
1114 read_skip( reader, 6 );
1115
1116 /* FIXME: parse attributes */
1117 while (reader->read_pos < reader->read_size && reader->read_bufptr[reader->read_pos] != '?')
1118 reader->read_pos++;
1119
1120 if (read_cmp( reader, "?>", 2 )) return WS_E_INVALID_FORMAT;
1121 read_skip( reader, 2 );
1122
1123 reader->state = READER_STATE_BOF;
1124 return S_OK;
1125 }
1126
1127 HRESULT append_attribute( WS_XML_ELEMENT_NODE *elem, WS_XML_ATTRIBUTE *attr )
1128 {
1129 if (elem->attributeCount)
1130 {
1131 WS_XML_ATTRIBUTE **tmp;
1132 if (!(tmp = heap_realloc( elem->attributes, (elem->attributeCount + 1) * sizeof(attr) )))
1133 return E_OUTOFMEMORY;
1134 elem->attributes = tmp;
1135 }
1136 else if (!(elem->attributes = heap_alloc( sizeof(attr) ))) return E_OUTOFMEMORY;
1137 elem->attributes[elem->attributeCount++] = attr;
1138 return S_OK;
1139 }
1140
1141 static HRESULT parse_name( const unsigned char *str, unsigned int len,
1142 WS_XML_STRING **prefix, WS_XML_STRING **localname )
1143 {
1144 const unsigned char *name_ptr = str, *prefix_ptr = NULL;
1145 unsigned int i, name_len = len, prefix_len = 0;
1146
1147 for (i = 0; i < len; i++)
1148 {
1149 if (str[i] == ':')
1150 {
1151 prefix_ptr = str;
1152 prefix_len = i;
1153 name_ptr = &str[i + 1];
1154 name_len -= i + 1;
1155 break;
1156 }
1157 }
1158 if (!(*prefix = alloc_xml_string( prefix_ptr, prefix_len ))) return E_OUTOFMEMORY;
1159 if (!(*localname = alloc_xml_string( name_ptr, name_len )))
1160 {
1161 heap_free( *prefix );
1162 return E_OUTOFMEMORY;
1163 }
1164 return S_OK;
1165 }
1166
1167 static int codepoint_to_utf8( int cp, unsigned char *dst )
1168 {
1169 if (cp < 0x80)
1170 {
1171 *dst = cp;
1172 return 1;
1173 }
1174 if (cp < 0x800)
1175 {
1176 dst[1] = 0x80 | (cp & 0x3f);
1177 cp >>= 6;
1178 dst[0] = 0xc0 | cp;
1179 return 2;
1180 }
1181 if ((cp >= 0xd800 && cp <= 0xdfff) || cp == 0xfffe || cp == 0xffff) return -1;
1182 if (cp < 0x10000)
1183 {
1184 dst[2] = 0x80 | (cp & 0x3f);
1185 cp >>= 6;
1186 dst[1] = 0x80 | (cp & 0x3f);
1187 cp >>= 6;
1188 dst[0] = 0xe0 | cp;
1189 return 3;
1190 }
1191 dst[3] = 0x80 | (cp & 0x3f);
1192 cp >>= 6;
1193 dst[2] = 0x80 | (cp & 0x3f);
1194 cp >>= 6;
1195 dst[1] = 0x80 | (cp & 0x3f);
1196 cp >>= 6;
1197 dst[0] = 0xf0 | cp;
1198 return 4;
1199 }
1200
1201 static HRESULT decode_text( const unsigned char *str, ULONG len, unsigned char *ret, ULONG *ret_len )
1202 {
1203 const unsigned char *p = str;
1204 unsigned char *q = ret;
1205
1206 *ret_len = 0;
1207 while (len)
1208 {
1209 if (*p == '&')
1210 {
1211 p++; len--;
1212 if (!len) return WS_E_INVALID_FORMAT;
1213
1214 if (len >= 3 && !memcmp( p, "lt;", 3 ))
1215 {
1216 *q++ = '<';
1217 p += 3;
1218 len -= 3;
1219 }
1220 else if (len >= 3 && !memcmp( p, "gt;", 3 ))
1221 {
1222 *q++ = '>';
1223 p += 3;
1224 len -= 3;
1225 }
1226 else if (len >= 5 && !memcmp( p, "quot;", 5 ))
1227 {
1228 *q++ = '"';
1229 p += 5;
1230 len -= 5;
1231 }
1232 else if (len >= 4 && !memcmp( p, "amp;", 4 ))
1233 {
1234 *q++ = '&';
1235 p += 4;
1236 len -= 4;
1237 }
1238 else if (len >= 5 && !memcmp( p, "apos;", 5 ))
1239 {
1240 *q++ = '\'';
1241 p += 5;
1242 len -= 5;
1243 }
1244 else if (*p == '#')
1245 {
1246 ULONG start, nb_digits, i;
1247 int len_utf8, cp = 0;
1248
1249 p++; len--;
1250 if (!len || *p != 'x') return WS_E_INVALID_FORMAT;
1251 p++; len--;
1252
1253 start = len;
1254 while (len && isxdigit( *p )) { p++; len--; };
1255 if (!len) return WS_E_INVALID_FORMAT;
1256
1257 p -= nb_digits = start - len;
1258 if (!nb_digits || nb_digits > 5 || p[nb_digits] != ';') return WS_E_INVALID_FORMAT;
1259 for (i = 0; i < nb_digits; i++)
1260 {
1261 cp *= 16;
1262 if (*p >= '0' && *p <= '9') cp += *p - '0';
1263 else if (*p >= 'a' && *p <= 'f') cp += *p - 'a' + 10;
1264 else cp += *p - 'A' + 10;
1265 p++;
1266 }
1267 p++; len--;
1268 if ((len_utf8 = codepoint_to_utf8( cp, q )) < 0) return WS_E_INVALID_FORMAT;
1269 *ret_len += len_utf8;
1270 q += len_utf8;
1271 continue;
1272 }
1273 else return WS_E_INVALID_FORMAT;
1274 }
1275 else
1276 {
1277 *q++ = *p++;
1278 len--;
1279 }
1280 *ret_len += 1;
1281 }
1282 return S_OK;
1283 }
1284
1285 static HRESULT read_attribute( struct reader *reader, WS_XML_ATTRIBUTE **ret )
1286 {
1287 static const WS_XML_STRING xmlns = {5, (BYTE *)"xmlns"};
1288 WS_XML_ATTRIBUTE *attr;
1289 WS_XML_UTF8_TEXT *text = NULL;
1290 unsigned int len = 0, ch, skip, quote;
1291 const unsigned char *start;
1292 WS_XML_STRING *prefix, *localname;
1293 HRESULT hr = WS_E_INVALID_FORMAT;
1294
1295 if (!(attr = heap_alloc_zero( sizeof(*attr) ))) return E_OUTOFMEMORY;
1296
1297 start = read_current_ptr( reader );
1298 for (;;)
1299 {
1300 if (!(ch = read_utf8_char( reader, &skip ))) goto error;
1301 if (!read_isnamechar( ch )) break;
1302 read_skip( reader, skip );
1303 len += skip;
1304 }
1305 if (!len) goto error;
1306
1307 if ((hr = parse_name( start, len, &prefix, &localname )) != S_OK) goto error;
1308 hr = E_OUTOFMEMORY;
1309 if (WsXmlStringEquals( prefix, &xmlns, NULL ) == S_OK)
1310 {
1311 heap_free( prefix );
1312 attr->isXmlNs = 1;
1313 if (!(attr->prefix = alloc_xml_string( localname->bytes, localname->length )))
1314 {
1315 heap_free( localname );
1316 goto error;
1317 }
1318 attr->localName = localname;
1319 }
1320 else if (!prefix->length && WsXmlStringEquals( localname, &xmlns, NULL ) == S_OK)
1321 {
1322 attr->isXmlNs = 1;
1323 attr->prefix = prefix;
1324 attr->localName = localname;
1325 }
1326 else
1327 {
1328 attr->prefix = prefix;
1329 attr->localName = localname;
1330 }
1331
1332 hr = WS_E_INVALID_FORMAT;
1333 read_skip_whitespace( reader );
1334 if (read_cmp( reader, "=", 1 )) goto error;
1335 read_skip( reader, 1 );
1336
1337 read_skip_whitespace( reader );
1338 if (read_cmp( reader, "\"", 1 ) && read_cmp( reader, "'", 1 )) goto error;
1339 quote = read_utf8_char( reader, &skip );
1340 read_skip( reader, 1 );
1341
1342 len = 0;
1343 start = read_current_ptr( reader );
1344 for (;;)
1345 {
1346 if (!(ch = read_utf8_char( reader, &skip ))) goto error;
1347 if (ch == quote) break;
1348 read_skip( reader, skip );
1349 len += skip;
1350 }
1351 read_skip( reader, 1 );
1352
1353 hr = E_OUTOFMEMORY;
1354 if (attr->isXmlNs)
1355 {
1356 if (!(attr->ns = alloc_xml_string( start, len ))) goto error;
1357 if ((hr = bind_prefix( reader, attr->prefix, attr->ns )) != S_OK) goto error;
1358 if (!(text = alloc_utf8_text( NULL, 0 ))) goto error;
1359 }
1360 else
1361 {
1362 if (!(text = alloc_utf8_text( NULL, len ))) goto error;
1363 if ((hr = decode_text( start, len, text->value.bytes, &text->value.length )) != S_OK) goto error;
1364 }
1365
1366 attr->value = &text->text;
1367 attr->singleQuote = (quote == '\'');
1368
1369 *ret = attr;
1370 return S_OK;
1371
1372 error:
1373 heap_free( text );
1374 free_attribute( attr );
1375 return hr;
1376 }
1377
1378 static inline BOOL is_valid_parent( const struct node *node )
1379 {
1380 if (!node) return FALSE;
1381 return node_type( node ) == WS_XML_NODE_TYPE_ELEMENT || node_type( node ) == WS_XML_NODE_TYPE_BOF;
1382 }
1383
1384 struct node *find_parent( struct node *node )
1385 {
1386 if (is_valid_parent( node )) return node;
1387 if (is_valid_parent( node->parent )) return node->parent;
1388 return NULL;
1389 }
1390
1391 static HRESULT set_namespaces( struct reader *reader, WS_XML_ELEMENT_NODE *elem )
1392 {
1393 static const WS_XML_STRING xml = {3, (BYTE *)"xml"};
1394 const WS_XML_STRING *ns;
1395 ULONG i;
1396
1397 if (!(ns = get_namespace( reader, elem->prefix ))) return WS_E_INVALID_FORMAT;
1398 if (!(elem->ns = alloc_xml_string( ns->bytes, ns->length ))) return E_OUTOFMEMORY;
1399 if (!elem->ns->length) elem->ns->bytes = (BYTE *)(elem->ns + 1); /* quirk */
1400
1401 for (i = 0; i < elem->attributeCount; i++)
1402 {
1403 WS_XML_ATTRIBUTE *attr = elem->attributes[i];
1404 if (attr->isXmlNs || WsXmlStringEquals( attr->prefix, &xml, NULL ) == S_OK) continue;
1405 if (!(ns = get_namespace( reader, attr->prefix ))) return WS_E_INVALID_FORMAT;
1406 if (!(attr->ns = alloc_xml_string( ns->bytes, ns->length ))) return E_OUTOFMEMORY;
1407 }
1408 return S_OK;
1409 }
1410
1411 static HRESULT read_element( struct reader *reader )
1412 {
1413 unsigned int len = 0, ch, skip;
1414 const unsigned char *start;
1415 struct node *node = NULL, *endnode, *parent;
1416 WS_XML_ELEMENT_NODE *elem;
1417 WS_XML_ATTRIBUTE *attr = NULL;
1418 HRESULT hr = WS_E_INVALID_FORMAT;
1419
1420 if (read_end_of_data( reader ))
1421 {
1422 reader->current = LIST_ENTRY( list_tail( &reader->root->children ), struct node, entry );
1423 reader->last = reader->current;
1424 reader->state = READER_STATE_EOF;
1425 return S_OK;
1426 }
1427
1428 if (read_cmp( reader, "<", 1 )) goto error;
1429 read_skip( reader, 1 );
1430 if (!read_isnamechar( read_utf8_char( reader, &skip )))
1431 {
1432 read_rewind( reader, 1 );
1433 goto error;
1434 }
1435
1436 start = read_current_ptr( reader );
1437 for (;;)
1438 {
1439 if (!(ch = read_utf8_char( reader, &skip ))) goto error;
1440 if (!read_isnamechar( ch )) break;
1441 read_skip( reader, skip );
1442 len += skip;
1443 }
1444 if (!len) goto error;
1445
1446 if (!(parent = find_parent( reader->current ))) goto error;
1447
1448 hr = E_OUTOFMEMORY;
1449 if (!(node = alloc_node( WS_XML_NODE_TYPE_ELEMENT ))) goto error;
1450 if (!(endnode = alloc_node( WS_XML_NODE_TYPE_END_ELEMENT ))) goto error;
1451 list_add_tail( &node->children, &endnode->entry );
1452 endnode->parent = node;
1453
1454 elem = (WS_XML_ELEMENT_NODE *)node;
1455 if ((hr = parse_name( start, len, &elem->prefix, &elem->localName )) != S_OK) goto error;
1456
1457 reader->current_attr = 0;
1458 for (;;)
1459 {
1460 read_skip_whitespace( reader );
1461 if (!read_cmp( reader, ">", 1 ) || !read_cmp( reader, "/>", 2 )) break;
1462 if ((hr = read_attribute( reader, &attr )) != S_OK) goto error;
1463 if ((hr = append_attribute( elem, attr )) != S_OK)
1464 {
1465 free_attribute( attr );
1466 goto error;
1467 }
1468 reader->current_attr++;
1469 }
1470 if ((hr = set_namespaces( reader, elem )) != S_OK) goto error;
1471
1472 read_insert_node( reader, parent, node );
1473 reader->state = READER_STATE_STARTELEMENT;
1474 return S_OK;
1475
1476 error:
1477 destroy_nodes( node );
1478 return hr;
1479 }
1480
1481 static HRESULT read_text( struct reader *reader )
1482 {
1483 unsigned int len = 0, ch, skip;
1484 const unsigned char *start;
1485 struct node *node, *parent;
1486 WS_XML_TEXT_NODE *text;
1487 WS_XML_UTF8_TEXT *utf8;
1488 HRESULT hr;
1489
1490 start = read_current_ptr( reader );
1491 for (;;)
1492 {
1493 if (read_end_of_data( reader )) break;
1494 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
1495 if (ch == '<') break;
1496 read_skip( reader, skip );
1497 len += skip;
1498 }
1499
1500 if (!(parent = find_parent( reader->current ))) return WS_E_INVALID_FORMAT;
1501
1502 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return E_OUTOFMEMORY;
1503 text = (WS_XML_TEXT_NODE *)node;
1504 if (!(utf8 = alloc_utf8_text( NULL, len )))
1505 {
1506 heap_free( node );
1507 return E_OUTOFMEMORY;
1508 }
1509 if ((hr = decode_text( start, len, utf8->value.bytes, &utf8->value.length )) != S_OK)
1510 {
1511 heap_free( utf8 );
1512 heap_free( node );
1513 return hr;
1514 }
1515 text->text = &utf8->text;
1516
1517 read_insert_node( reader, parent, node );
1518 reader->state = READER_STATE_TEXT;
1519 return S_OK;
1520 }
1521
1522 static HRESULT read_node( struct reader * );
1523
1524 static HRESULT read_startelement( struct reader *reader )
1525 {
1526 read_skip_whitespace( reader );
1527 if (!read_cmp( reader, "/>", 2 ))
1528 {
1529 read_skip( reader, 2 );
1530 reader->current = LIST_ENTRY( list_tail( &reader->current->children ), struct node, entry );
1531 reader->last = reader->current;
1532 reader->state = READER_STATE_ENDELEMENT;
1533 return S_OK;
1534 }
1535 else if (!read_cmp( reader, ">", 1 ))
1536 {
1537 read_skip( reader, 1 );
1538 return read_node( reader );
1539 }
1540 return WS_E_INVALID_FORMAT;
1541 }
1542
1543 static HRESULT read_to_startelement( struct reader *reader, BOOL *found )
1544 {
1545 HRESULT hr;
1546
1547 switch (reader->state)
1548 {
1549 case READER_STATE_INITIAL:
1550 if ((hr = read_xmldecl( reader )) != S_OK) return hr;
1551 break;
1552
1553 case READER_STATE_STARTELEMENT:
1554 if (found) *found = TRUE;
1555 return S_OK;
1556
1557 default:
1558 break;
1559 }
1560
1561 read_skip_whitespace( reader );
1562 if ((hr = read_element( reader )) == S_OK && found)
1563 {
1564 if (reader->state == READER_STATE_STARTELEMENT)
1565 *found = TRUE;
1566 else
1567 *found = FALSE;
1568 }
1569
1570 return hr;
1571 }
1572
1573 static int cmp_name( const unsigned char *name1, ULONG len1, const unsigned char *name2, ULONG len2 )
1574 {
1575 ULONG i;
1576 if (len1 != len2) return 1;
1577 for (i = 0; i < len1; i++) { if (toupper( name1[i] ) != toupper( name2[i] )) return 1; }
1578 return 0;
1579 }
1580
1581 static struct node *read_find_startelement( struct reader *reader, const WS_XML_STRING *prefix,
1582 const WS_XML_STRING *localname )
1583 {
1584 struct node *parent;
1585 const WS_XML_STRING *str;
1586
1587 for (parent = reader->current; parent; parent = parent->parent)
1588 {
1589 if (node_type( parent ) == WS_XML_NODE_TYPE_ELEMENT)
1590 {
1591 str = parent->hdr.prefix;
1592 if (cmp_name( str->bytes, str->length, prefix->bytes, prefix->length )) continue;
1593 str = parent->hdr.localName;
1594 if (cmp_name( str->bytes, str->length, localname->bytes, localname->length )) continue;
1595 return parent;
1596 }
1597 }
1598 return NULL;
1599 }
1600
1601 static HRESULT read_endelement( struct reader *reader )
1602 {
1603 struct node *parent;
1604 unsigned int len = 0, ch, skip;
1605 const unsigned char *start;
1606 WS_XML_STRING *prefix, *localname;
1607 HRESULT hr;
1608
1609 if (reader->state == READER_STATE_EOF) return WS_E_INVALID_FORMAT;
1610
1611 if (read_end_of_data( reader ))
1612 {
1613 reader->current = LIST_ENTRY( list_tail( &reader->root->children ), struct node, entry );
1614 reader->last = reader->current;
1615 reader->state = READER_STATE_EOF;
1616 return S_OK;
1617 }
1618
1619 if (read_cmp( reader, "</", 2 )) return WS_E_INVALID_FORMAT;
1620 read_skip( reader, 2 );
1621
1622 start = read_current_ptr( reader );
1623 for (;;)
1624 {
1625 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
1626 if (ch == '>')
1627 {
1628 read_skip( reader, 1 );
1629 break;
1630 }
1631 if (!read_isnamechar( ch )) return WS_E_INVALID_FORMAT;
1632 read_skip( reader, skip );
1633 len += skip;
1634 }
1635
1636 if ((hr = parse_name( start, len, &prefix, &localname )) != S_OK) return hr;
1637 parent = read_find_startelement( reader, prefix, localname );
1638 heap_free( prefix );
1639 heap_free( localname );
1640 if (!parent) return WS_E_INVALID_FORMAT;
1641
1642 reader->current = LIST_ENTRY( list_tail( &parent->children ), struct node, entry );
1643 reader->last = reader->current;
1644 reader->state = READER_STATE_ENDELEMENT;
1645 return S_OK;
1646 }
1647
1648 static HRESULT read_comment( struct reader *reader )
1649 {
1650 unsigned int len = 0, ch, skip;
1651 const unsigned char *start;
1652 struct node *node, *parent;
1653 WS_XML_COMMENT_NODE *comment;
1654
1655 if (read_cmp( reader, "<!--", 4 )) return WS_E_INVALID_FORMAT;
1656 read_skip( reader, 4 );
1657
1658 start = read_current_ptr( reader );
1659 for (;;)
1660 {
1661 if (!read_cmp( reader, "-->", 3 ))
1662 {
1663 read_skip( reader, 3 );
1664 break;
1665 }
1666 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
1667 read_skip( reader, skip );
1668 len += skip;
1669 }
1670
1671 if (!(parent = find_parent( reader->current ))) return WS_E_INVALID_FORMAT;
1672
1673 if (!(node = alloc_node( WS_XML_NODE_TYPE_COMMENT ))) return E_OUTOFMEMORY;
1674 comment = (WS_XML_COMMENT_NODE *)node;
1675 if (!(comment->value.bytes = heap_alloc( len )))
1676 {
1677 heap_free( node );
1678 return E_OUTOFMEMORY;
1679 }
1680 memcpy( comment->value.bytes, start, len );
1681 comment->value.length = len;
1682
1683 read_insert_node( reader, parent, node );
1684 reader->state = READER_STATE_COMMENT;
1685 return S_OK;
1686 }
1687
1688 static HRESULT read_startcdata( struct reader *reader )
1689 {
1690 struct node *node, *endnode, *parent;
1691
1692 if (read_cmp( reader, "<![CDATA[", 9 )) return WS_E_INVALID_FORMAT;
1693 read_skip( reader, 9 );
1694
1695 if (!(parent = find_parent( reader->current ))) return WS_E_INVALID_FORMAT;
1696
1697 if (!(node = alloc_node( WS_XML_NODE_TYPE_CDATA ))) return E_OUTOFMEMORY;
1698 if (!(endnode = alloc_node( WS_XML_NODE_TYPE_END_CDATA )))
1699 {
1700 heap_free( node );
1701 return E_OUTOFMEMORY;
1702 }
1703 list_add_tail( &node->children, &endnode->entry );
1704 endnode->parent = node;
1705
1706 read_insert_node( reader, parent, node );
1707 reader->state = READER_STATE_STARTCDATA;
1708 return S_OK;
1709 }
1710
1711 static HRESULT read_cdata( struct reader *reader )
1712 {
1713 unsigned int len = 0, ch, skip;
1714 const unsigned char *start;
1715 struct node *node;
1716 WS_XML_TEXT_NODE *text;
1717 WS_XML_UTF8_TEXT *utf8;
1718
1719 start = read_current_ptr( reader );
1720 for (;;)
1721 {
1722 if (!read_cmp( reader, "]]>", 3 )) break;
1723 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
1724 read_skip( reader, skip );
1725 len += skip;
1726 }
1727
1728 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return E_OUTOFMEMORY;
1729 text = (WS_XML_TEXT_NODE *)node;
1730 if (!(utf8 = alloc_utf8_text( start, len )))
1731 {
1732 heap_free( node );
1733 return E_OUTOFMEMORY;
1734 }
1735 text->text = &utf8->text;
1736
1737 read_insert_node( reader, reader->current, node );
1738 reader->state = READER_STATE_CDATA;
1739 return S_OK;
1740 }
1741
1742 static HRESULT read_endcdata( struct reader *reader )
1743 {
1744 struct node *parent;
1745
1746 if (read_cmp( reader, "]]>", 3 )) return WS_E_INVALID_FORMAT;
1747 read_skip( reader, 3 );
1748
1749 if (node_type( reader->current ) == WS_XML_NODE_TYPE_TEXT) parent = reader->current->parent;
1750 else parent = reader->current;
1751
1752 reader->current = LIST_ENTRY( list_tail( &parent->children ), struct node, entry );
1753 reader->last = reader->current;
1754 reader->state = READER_STATE_ENDCDATA;
1755 return S_OK;
1756 }
1757
1758 static HRESULT read_node( struct reader *reader )
1759 {
1760 HRESULT hr;
1761
1762 for (;;)
1763 {
1764 if (read_end_of_data( reader ))
1765 {
1766 reader->current = LIST_ENTRY( list_tail( &reader->root->children ), struct node, entry );
1767 reader->last = reader->current;
1768 reader->state = READER_STATE_EOF;
1769 return S_OK;
1770 }
1771 if (reader->state == READER_STATE_STARTCDATA) return read_cdata( reader );
1772 else if (reader->state == READER_STATE_CDATA) return read_endcdata( reader );
1773 else if (!read_cmp( reader, "<?", 2 ))
1774 {
1775 hr = read_xmldecl( reader );
1776 if (FAILED( hr )) return hr;
1777 }
1778 else if (!read_cmp( reader, "</", 2 )) return read_endelement( reader );
1779 else if (!read_cmp( reader, "<![CDATA[", 9 )) return read_startcdata( reader );
1780 else if (!read_cmp( reader, "<!--", 4 )) return read_comment( reader );
1781 else if (!read_cmp( reader, "<", 1 )) return read_element( reader );
1782 else if (!read_cmp( reader, "/>", 2 ) || !read_cmp( reader, ">", 1 )) return read_startelement( reader );
1783 else return read_text( reader );
1784 }
1785 }
1786
1787 /**************************************************************************
1788 * WsReadEndElement [webservices.@]
1789 */
1790 HRESULT WINAPI WsReadEndElement( WS_XML_READER *handle, WS_ERROR *error )
1791 {
1792 struct reader *reader = (struct reader *)handle;
1793
1794 TRACE( "%p %p\n", handle, error );
1795 if (error) FIXME( "ignoring error parameter\n" );
1796
1797 if (!reader) return E_INVALIDARG;
1798 return read_endelement( reader );
1799 }
1800
1801 /**************************************************************************
1802 * WsReadNode [webservices.@]
1803 */
1804 HRESULT WINAPI WsReadNode( WS_XML_READER *handle, WS_ERROR *error )
1805 {
1806 struct reader *reader = (struct reader *)handle;
1807
1808 TRACE( "%p %p\n", handle, error );
1809 if (error) FIXME( "ignoring error parameter\n" );
1810
1811 if (!reader) return E_INVALIDARG;
1812 return read_node( reader );
1813 }
1814
1815 /**************************************************************************
1816 * WsReadStartElement [webservices.@]
1817 */
1818 HRESULT WINAPI WsReadStartElement( WS_XML_READER *handle, WS_ERROR *error )
1819 {
1820 struct reader *reader = (struct reader *)handle;
1821
1822 TRACE( "%p %p\n", handle, error );
1823 if (error) FIXME( "ignoring error parameter\n" );
1824
1825 if (!reader) return E_INVALIDARG;
1826 return read_startelement( reader );
1827 }
1828
1829 /**************************************************************************
1830 * WsReadToStartElement [webservices.@]
1831 */
1832 HRESULT WINAPI WsReadToStartElement( WS_XML_READER *handle, const WS_XML_STRING *localname,
1833 const WS_XML_STRING *ns, BOOL *found, WS_ERROR *error )
1834 {
1835 struct reader *reader = (struct reader *)handle;
1836
1837 TRACE( "%p %s %s %p %p\n", handle, debugstr_xmlstr(localname), debugstr_xmlstr(ns), found, error );
1838 if (error) FIXME( "ignoring error parameter\n" );
1839
1840 if (!reader) return E_INVALIDARG;
1841 if (localname || ns) FIXME( "name and/or namespace not verified\n" );
1842
1843 return read_to_startelement( reader, found );
1844 }
1845
1846 BOOL move_to_root_element( struct node *root, struct node **current )
1847 {
1848 struct list *ptr;
1849 struct node *node;
1850
1851 if (!(ptr = list_head( &root->children ))) return FALSE;
1852 node = LIST_ENTRY( ptr, struct node, entry );
1853 if (node_type( node ) == WS_XML_NODE_TYPE_ELEMENT)
1854 {
1855 *current = node;
1856 return TRUE;
1857 }
1858 while ((ptr = list_next( &root->children, &node->entry )))
1859 {
1860 struct node *next = LIST_ENTRY( ptr, struct node, entry );
1861 if (node_type( next ) == WS_XML_NODE_TYPE_ELEMENT)
1862 {
1863 *current = next;
1864 return TRUE;
1865 }
1866 node = next;
1867 }
1868 return FALSE;
1869 }
1870
1871 BOOL move_to_next_element( struct node **current )
1872 {
1873 struct list *ptr;
1874 struct node *node = *current, *parent = (*current)->parent;
1875
1876 if (!parent) return FALSE;
1877 while ((ptr = list_next( &parent->children, &node->entry )))
1878 {
1879 struct node *next = LIST_ENTRY( ptr, struct node, entry );
1880 if (node_type( next ) == WS_XML_NODE_TYPE_ELEMENT)
1881 {
1882 *current = next;
1883 return TRUE;
1884 }
1885 node = next;
1886 }
1887 return FALSE;
1888 }
1889
1890 BOOL move_to_prev_element( struct node **current )
1891 {
1892 struct list *ptr;
1893 struct node *node = *current, *parent = (*current)->parent;
1894
1895 if (!parent) return FALSE;
1896 while ((ptr = list_prev( &parent->children, &node->entry )))
1897 {
1898 struct node *prev = LIST_ENTRY( ptr, struct node, entry );
1899 if (node_type( prev ) == WS_XML_NODE_TYPE_ELEMENT)
1900 {
1901 *current = prev;
1902 return TRUE;
1903 }
1904 node = prev;
1905 }
1906 return FALSE;
1907 }
1908
1909 BOOL move_to_child_element( struct node **current )
1910 {
1911 struct list *ptr;
1912 struct node *child, *node = *current;
1913
1914 if (!(ptr = list_head( &node->children ))) return FALSE;
1915 child = LIST_ENTRY( ptr, struct node, entry );
1916 if (node_type( child ) == WS_XML_NODE_TYPE_ELEMENT)
1917 {
1918 *current = child;
1919 return TRUE;
1920 }
1921 while ((ptr = list_next( &node->children, &child->entry )))
1922 {
1923 struct node *next = LIST_ENTRY( ptr, struct node, entry );
1924 if (node_type( next ) == WS_XML_NODE_TYPE_ELEMENT)
1925 {
1926 *current = next;
1927 return TRUE;
1928 }
1929 child = next;
1930 }
1931 return FALSE;
1932 }
1933
1934 BOOL move_to_end_element( struct node **current )
1935 {
1936 struct list *ptr;
1937 struct node *node = *current;
1938
1939 if (node_type( node ) != WS_XML_NODE_TYPE_ELEMENT) return FALSE;
1940
1941 if ((ptr = list_tail( &node->children )))
1942 {
1943 struct node *tail = LIST_ENTRY( ptr, struct node, entry );
1944 if (node_type( tail ) == WS_XML_NODE_TYPE_END_ELEMENT)
1945 {
1946 *current = tail;
1947 return TRUE;
1948 }
1949 }
1950 return FALSE;
1951 }
1952
1953 BOOL move_to_parent_element( struct node **current )
1954 {
1955 struct node *parent = (*current)->parent;
1956
1957 if (parent && (node_type( parent ) == WS_XML_NODE_TYPE_ELEMENT ||
1958 node_type( parent ) == WS_XML_NODE_TYPE_BOF))
1959 {
1960 *current = parent;
1961 return TRUE;
1962 }
1963 return FALSE;
1964 }
1965
1966 BOOL move_to_first_node( struct node **current )
1967 {
1968 struct list *ptr;
1969 struct node *node = *current;
1970
1971 if ((ptr = list_head( &node->parent->children )))
1972 {
1973 *current = LIST_ENTRY( ptr, struct node, entry );
1974 return TRUE;
1975 }
1976 return FALSE;
1977 }
1978
1979 BOOL move_to_next_node( struct node **current )
1980 {
1981 struct list *ptr;
1982 struct node *node = *current;
1983
1984 if ((ptr = list_next( &node->parent->children, &node->entry )))
1985 {
1986 *current = LIST_ENTRY( ptr, struct node, entry );
1987 return TRUE;
1988 }
1989 return FALSE;
1990 }
1991
1992 BOOL move_to_prev_node( struct node **current )
1993 {
1994 struct list *ptr;
1995 struct node *node = *current;
1996
1997 if ((ptr = list_prev( &node->parent->children, &node->entry )))
1998 {
1999 *current = LIST_ENTRY( ptr, struct node, entry );
2000 return TRUE;
2001 }
2002 return FALSE;
2003 }
2004
2005 BOOL move_to_bof( struct node *root, struct node **current )
2006 {
2007 *current = root;
2008 return TRUE;
2009 }
2010
2011 BOOL move_to_eof( struct node *root, struct node **current )
2012 {
2013 struct list *ptr;
2014 if ((ptr = list_tail( &root->children )))
2015 {
2016 *current = LIST_ENTRY( ptr, struct node, entry );
2017 return TRUE;
2018 }
2019 return FALSE;
2020 }
2021
2022 BOOL move_to_child_node( struct node **current )
2023 {
2024 struct list *ptr;
2025 struct node *node = *current;
2026
2027 if ((ptr = list_head( &node->children )))
2028 {
2029 *current = LIST_ENTRY( ptr, struct node, entry );
2030 return TRUE;
2031 }
2032 return FALSE;
2033 }
2034
2035 BOOL move_to_parent_node( struct node **current )
2036 {
2037 struct node *parent = (*current)->parent;
2038 if (!parent) return FALSE;
2039 *current = parent;
2040 return TRUE;
2041 }
2042
2043 static HRESULT read_move_to( struct reader *reader, WS_MOVE_TO move, BOOL *found )
2044 {
2045 BOOL success = FALSE;
2046 HRESULT hr = S_OK;
2047
2048 if (!read_end_of_data( reader ))
2049 {
2050 while (reader->state != READER_STATE_EOF && (hr = read_node( reader )) == S_OK) { /* nothing */ };
2051 if (hr != S_OK) return hr;
2052 }
2053 switch (move)
2054 {
2055 case WS_MOVE_TO_ROOT_ELEMENT:
2056 success = move_to_root_element( reader->root, &reader->current );
2057 break;
2058
2059 case WS_MOVE_TO_NEXT_ELEMENT:
2060 success = move_to_next_element( &reader->current );
2061 break;
2062
2063 case WS_MOVE_TO_PREVIOUS_ELEMENT:
2064 success = move_to_prev_element( &reader->current );
2065 break;
2066
2067 case WS_MOVE_TO_CHILD_ELEMENT:
2068 success = move_to_child_element( &reader->current );
2069 break;
2070
2071 case WS_MOVE_TO_END_ELEMENT:
2072 success = move_to_end_element( &reader->current );
2073 break;
2074
2075 case WS_MOVE_TO_PARENT_ELEMENT:
2076 success = move_to_parent_element( &reader->current );
2077 break;
2078
2079 case WS_MOVE_TO_FIRST_NODE:
2080 success = move_to_first_node( &reader->current );
2081 break;
2082
2083 case WS_MOVE_TO_NEXT_NODE:
2084 success = move_to_next_node( &reader->current );
2085 break;
2086
2087 case WS_MOVE_TO_PREVIOUS_NODE:
2088 success = move_to_prev_node( &reader->current );
2089 break;
2090
2091 case WS_MOVE_TO_CHILD_NODE:
2092 success = move_to_child_node( &reader->current );
2093 break;
2094
2095 case WS_MOVE_TO_BOF:
2096 success = move_to_bof( reader->root, &reader->current );
2097 break;
2098
2099 case WS_MOVE_TO_EOF:
2100 success = move_to_eof( reader->root, &reader->current );
2101 break;
2102
2103 default:
2104 FIXME( "unhandled move %u\n", move );
2105 return E_NOTIMPL;
2106 }
2107
2108 if (found)
2109 {
2110 *found = success;
2111 return S_OK;
2112 }
2113 return success ? S_OK : WS_E_INVALID_FORMAT;
2114 }
2115
2116 /**************************************************************************
2117 * WsMoveReader [webservices.@]
2118 */
2119 HRESULT WINAPI WsMoveReader( WS_XML_READER *handle, WS_MOVE_TO move, BOOL *found, WS_ERROR *error )
2120 {
2121 struct reader *reader = (struct reader *)handle;
2122
2123 TRACE( "%p %u %p %p\n", handle, move, found, error );
2124 if (error) FIXME( "ignoring error parameter\n" );
2125
2126 if (!reader) return E_INVALIDARG;
2127 if (!reader->input_type) return WS_E_INVALID_OPERATION;
2128
2129 return read_move_to( reader, move, found );
2130 }
2131
2132 /**************************************************************************
2133 * WsReadStartAttribute [webservices.@]
2134 */
2135 HRESULT WINAPI WsReadStartAttribute( WS_XML_READER *handle, ULONG index, WS_ERROR *error )
2136 {
2137 struct reader *reader = (struct reader *)handle;
2138 WS_XML_ELEMENT_NODE *elem;
2139
2140 TRACE( "%p %u %p\n", handle, index, error );
2141 if (error) FIXME( "ignoring error parameter\n" );
2142
2143 if (!reader) return E_INVALIDARG;
2144
2145 elem = &reader->current->hdr;
2146 if (reader->state != READER_STATE_STARTELEMENT || index >= elem->attributeCount)
2147 return WS_E_INVALID_FORMAT;
2148
2149 reader->current_attr = index;
2150 reader->state = READER_STATE_STARTATTRIBUTE;
2151 return S_OK;
2152 }
2153
2154 /**************************************************************************
2155 * WsReadEndAttribute [webservices.@]
2156 */
2157 HRESULT WINAPI WsReadEndAttribute( WS_XML_READER *handle, WS_ERROR *error )
2158 {
2159 struct reader *reader = (struct reader *)handle;
2160
2161 TRACE( "%p %p\n", handle, error );
2162 if (error) FIXME( "ignoring error parameter\n" );
2163
2164 if (!reader) return E_INVALIDARG;
2165
2166 if (reader->state != READER_STATE_STARTATTRIBUTE)
2167 return WS_E_INVALID_FORMAT;
2168
2169 reader->state = READER_STATE_STARTELEMENT;
2170 return S_OK;
2171 }
2172
2173 static WCHAR *xmltext_to_widechar( WS_HEAP *heap, const WS_XML_TEXT *text )
2174 {
2175 WCHAR *ret;
2176
2177 switch (text->textType)
2178 {
2179 case WS_XML_TEXT_TYPE_UTF8:
2180 {
2181 const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text;
2182 int len = MultiByteToWideChar( CP_UTF8, 0, (char *)utf8->value.bytes, utf8->value.length, NULL, 0 );
2183 if (!(ret = ws_alloc( heap, (len + 1) * sizeof(WCHAR) ))) return NULL;
2184 MultiByteToWideChar( CP_UTF8, 0, (char *)utf8->value.bytes, utf8->value.length, ret, len );
2185 ret[len] = 0;
2186 break;
2187 }
2188 default:
2189 FIXME( "unhandled type %u\n", text->textType );
2190 return NULL;
2191 }
2192
2193 return ret;
2194 }
2195
2196 #define MAX_INT8 0x7f
2197 #define MIN_INT8 (-MAX_INT8 - 1)
2198 #define MAX_INT16 0x7fff
2199 #define MIN_INT16 (-MAX_INT16 - 1)
2200 #define MAX_INT32 0x7fffffff
2201 #define MIN_INT32 (-MAX_INT32 - 1)
2202 #define MAX_INT64 (((INT64)0x7fffffff << 32) | 0xffffffff)
2203 #define MIN_INT64 (-MAX_INT64 - 1)
2204 #define MAX_UINT8 0xff
2205 #define MAX_UINT16 0xffff
2206 #define MAX_UINT32 0xffffffff
2207 #define MAX_UINT64 (((UINT64)0xffffffff << 32) | 0xffffffff)
2208
2209 static HRESULT str_to_int64( const unsigned char *str, ULONG len, INT64 min, INT64 max, INT64 *ret )
2210 {
2211 BOOL negative = FALSE;
2212 const unsigned char *ptr = str;
2213
2214 *ret = 0;
2215 while (len && read_isspace( *ptr )) { ptr++; len--; }
2216 while (len && read_isspace( ptr[len - 1] )) { len--; }
2217 if (!len) return WS_E_INVALID_FORMAT;
2218
2219 if (*ptr == '-')
2220 {
2221 negative = TRUE;
2222 ptr++;
2223 len--;
2224 }
2225 if (!len) return WS_E_INVALID_FORMAT;
2226
2227 while (len--)
2228 {
2229 int val;
2230
2231 if (!isdigit( *ptr )) return WS_E_INVALID_FORMAT;
2232 val = *ptr - '0';
2233 if (negative) val = -val;
2234
2235 if ((!negative && (*ret > max / 10 || *ret * 10 > max - val)) ||
2236 (negative && (*ret < min / 10 || *ret * 10 < min - val)))
2237 {
2238 return WS_E_NUMERIC_OVERFLOW;
2239 }
2240 *ret = *ret * 10 + val;
2241 ptr++;
2242 }
2243
2244 return S_OK;
2245 }
2246
2247 static HRESULT str_to_uint64( const unsigned char *str, ULONG len, UINT64 max, UINT64 *ret )
2248 {
2249 const unsigned char *ptr = str;
2250
2251 *ret = 0;
2252 while (len && read_isspace( *ptr )) { ptr++; len--; }
2253 while (len && read_isspace( ptr[len - 1] )) { len--; }
2254 if (!len) return WS_E_INVALID_FORMAT;
2255
2256 while (len--)
2257 {
2258 unsigned int val;
2259
2260 if (!isdigit( *ptr )) return WS_E_INVALID_FORMAT;
2261 val = *ptr - '0';
2262
2263 if ((*ret > max / 10 || *ret * 10 > max - val)) return WS_E_NUMERIC_OVERFLOW;
2264 *ret = *ret * 10 + val;
2265 ptr++;
2266 }
2267
2268 return S_OK;
2269 }
2270
2271 #if defined(__i386__) || defined(__x86_64__)
2272
2273 #define RC_DOWN 0x100;
2274 BOOL set_fp_rounding( unsigned short *save )
2275 {
2276 #ifdef __GNUC__
2277 unsigned short fpword;
2278
2279 __asm__ __volatile__( "fstcw %0" : "=m" (fpword) );
2280 *save = fpword;
2281 fpword |= RC_DOWN;
2282 __asm__ __volatile__( "fldcw %0" : : "m" (fpword) );
2283 return TRUE;
2284 #else
2285 FIXME( "not implemented\n" );
2286 return FALSE;
2287 #endif
2288 }
2289 void restore_fp_rounding( unsigned short fpword )
2290 {
2291 #ifdef __GNUC__
2292 __asm__ __volatile__( "fldcw %0" : : "m" (fpword) );
2293 #else
2294 FIXME( "not implemented\n" );
2295 #endif
2296 }
2297 #else
2298 BOOL set_fp_rounding( unsigned short *save )
2299 {
2300 FIXME( "not implemented\n" );
2301 return FALSE;
2302 }
2303 void restore_fp_rounding( unsigned short fpword )
2304 {
2305 FIXME( "not implemented\n" );
2306 }
2307 #endif
2308
2309 static HRESULT str_to_double( const unsigned char *str, ULONG len, double *ret )
2310 {
2311 static const unsigned __int64 nan = 0xfff8000000000000;
2312 static const unsigned __int64 inf = 0x7ff0000000000000;
2313 static const unsigned __int64 inf_min = 0xfff0000000000000;
2314 HRESULT hr = WS_E_INVALID_FORMAT;
2315 const unsigned char *p = str, *q;
2316 int sign = 1, exp_sign = 1, exp = 0, exp_tmp = 0, neg_exp, i, nb_digits, have_digits;
2317 unsigned __int64 val = 0, tmp;
2318 long double exp_val = 1.0, exp_mul = 10.0;
2319 unsigned short fpword;
2320
2321 while (len && read_isspace( *p )) { p++; len--; }
2322 while (len && read_isspace( p[len - 1] )) { len--; }
2323 if (!len) return WS_E_INVALID_FORMAT;
2324
2325 if (len == 3 && !memcmp( p, "NaN", 3 ))
2326 {
2327 *(unsigned __int64 *)ret = nan;
2328 return S_OK;
2329 }
2330 else if (len == 3 && !memcmp( p, "INF", 3 ))
2331 {
2332 *(unsigned __int64 *)ret = inf;
2333 return S_OK;
2334 }
2335 else if (len == 4 && !memcmp( p, "-INF", 4 ))
2336 {
2337 *(unsigned __int64 *)ret = inf_min;
2338 return S_OK;
2339 }
2340
2341 *ret = 0.0;
2342 if (*p == '-')
2343 {
2344 sign = -1;
2345 p++; len--;
2346 }
2347 else if (*p == '+') { p++; len--; };
2348 if (!len) return S_OK;
2349
2350 if (!set_fp_rounding( &fpword )) return E_NOTIMPL;
2351
2352 q = p;
2353 while (len && isdigit( *q )) { q++; len--; }
2354 have_digits = nb_digits = q - p;
2355 for (i = 0; i < nb_digits; i++)
2356 {
2357 tmp = val * 10 + p[i] - '0';
2358 if (val > MAX_UINT64 / 10 || tmp < val)
2359 {
2360 for (; i < nb_digits; i++) exp++;
2361 break;
2362 }
2363 val = tmp;
2364 }
2365
2366 if (len)
2367 {
2368 if (*q == '.')
2369 {
2370 p = ++q; len--;
2371 while (len && isdigit( *q )) { q++; len--; };
2372 have_digits |= nb_digits = q - p;
2373 for (i = 0; i < nb_digits; i++)
2374 {
2375 tmp = val * 10 + p[i] - '0';
2376 if (val > MAX_UINT64 / 10 || tmp < val) break;
2377 val = tmp;
2378 exp--;
2379 }
2380 }
2381 if (len > 1 && tolower(*q) == 'e')
2382 {
2383 if (!have_digits) goto done;
2384 p = ++q; len--;
2385 if (*p == '-')
2386 {
2387 exp_sign = -1;
2388 p++; len--;
2389 }
2390 else if (*p == '+') { p++; len--; };
2391
2392 q = p;
2393 while (len && isdigit( *q )) { q++; len--; };
2394 nb_digits = q - p;
2395 if (!nb_digits || len) goto done;
2396 for (i = 0; i < nb_digits; i++)
2397 {
2398 if (exp_tmp > MAX_INT32 / 10 || (exp_tmp = exp_tmp * 10 + p[i] - '0') < 0)
2399 exp_tmp = MAX_INT32;
2400 }
2401 exp_tmp *= exp_sign;
2402
2403 if (exp < 0 && exp_tmp < 0 && exp + exp_tmp >= 0) exp = MIN_INT32;
2404 else if (exp > 0 && exp_tmp > 0 && exp + exp_tmp < 0) exp = MAX_INT32;
2405 else exp += exp_tmp;
2406 }
2407 }
2408 if (!have_digits || len) goto done;
2409
2410 if ((neg_exp = exp < 0)) exp = -exp;
2411 for (; exp; exp >>= 1)
2412 {
2413 if (exp & 1) exp_val *= exp_mul;
2414 exp_mul *= exp_mul;
2415 }
2416
2417 *ret = sign * (neg_exp ? val / exp_val : val * exp_val);
2418 hr = S_OK;
2419
2420 done:
2421 restore_fp_rounding( fpword );
2422 return hr;
2423 }
2424
2425 static HRESULT str_to_guid( const unsigned char *str, ULONG len, GUID *ret )
2426 {
2427 static const unsigned char hex[] =
2428 {
2429 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x00 */
2430 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x10 */
2431 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x20 */
2432 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, /* 0x30 */
2433 0,10,11,12,13,14,15,0,0,0,0,0,0,0,0,0, /* 0x40 */
2434 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x50 */
2435 0,10,11,12,13,14,15 /* 0x60 */
2436 };
2437 const unsigned char *p = str;
2438 ULONG i;
2439
2440 while (len && read_isspace( *p )) { p++; len--; }
2441 while (len && read_isspace( p[len - 1] )) { len--; }
2442 if (len != 36) return WS_E_INVALID_FORMAT;
2443
2444 if (p[8] != '-' || p[13] != '-' || p[18] != '-' || p[23] != '-')
2445 return WS_E_INVALID_FORMAT;
2446
2447 for (i = 0; i < 36; i++)
2448 {
2449 if (i == 8 || i == 13 || i == 18 || i == 23) continue;
2450 if (p[i] > 'f' || (!hex[p[i]] && p[i] != '0')) return WS_E_INVALID_FORMAT;
2451 }
2452
2453 ret->Data1 = hex[p[0]] << 28 | hex[p[1]] << 24 | hex[p[2]] << 20 | hex[p[3]] << 16 |
2454 hex[p[4]] << 12 | hex[p[5]] << 8 | hex[p[6]] << 4 | hex[p[7]];
2455
2456 ret->Data2 = hex[p[9]] << 12 | hex[p[10]] << 8 | hex[p[11]] << 4 | hex[p[12]];
2457 ret->Data3 = hex[p[14]] << 12 | hex[p[15]] << 8 | hex[p[16]] << 4 | hex[p[17]];
2458
2459 ret->Data4[0] = hex[p[19]] << 4 | hex[p[20]];
2460 ret->Data4[1] = hex[p[21]] << 4 | hex[p[22]];
2461 ret->Data4[2] = hex[p[24]] << 4 | hex[p[25]];
2462 ret->Data4[3] = hex[p[26]] << 4 | hex[p[27]];
2463 ret->Data4[4] = hex[p[28]] << 4 | hex[p[29]];
2464 ret->Data4[5] = hex[p[30]] << 4 | hex[p[31]];
2465 ret->Data4[6] = hex[p[32]] << 4 | hex[p[33]];
2466 ret->Data4[7] = hex[p[34]] << 4 | hex[p[35]];
2467
2468 return S_OK;
2469 }
2470
2471 #define TICKS_PER_SEC 10000000
2472 #define TICKS_PER_MIN (60 * (ULONGLONG)TICKS_PER_SEC)
2473 #define TICKS_PER_HOUR (3600 * (ULONGLONG)TICKS_PER_SEC)
2474 #define TICKS_PER_DAY (86400 * (ULONGLONG)TICKS_PER_SEC)
2475 #define TICKS_MAX 3155378975999999999
2476
2477 static const int month_offsets[2][12] =
2478 {
2479 {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},
2480 {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335}
2481 };
2482
2483 static const int month_days[2][12] =
2484 {
2485 {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
2486 {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
2487 };
2488
2489 static inline int is_leap_year( int year )
2490 {
2491 return !(year % 4) && (year % 100 || !(year % 400));
2492 }
2493
2494 static inline int valid_day( int year, int month, int day )
2495 {
2496 return day > 0 && day <= month_days[is_leap_year( year )][month - 1];
2497 }
2498
2499 static inline int leap_days_before( int year )
2500 {
2501 return (year - 1) / 4 - (year - 1) / 100 + (year - 1) / 400;
2502 }
2503
2504 static HRESULT str_to_datetime( const unsigned char *bytes, ULONG len, WS_DATETIME *ret )
2505 {
2506 const unsigned char *p = bytes, *q;
2507 int year, month, day, hour, min, sec, sec_frac = 0, tz_hour, tz_min, tz_neg;
2508
2509 while (len && read_isspace( *p )) { p++; len--; }
2510 while (len && read_isspace( p[len - 1] )) { len--; }
2511
2512 q = p;
2513 while (len && isdigit( *q )) { q++; len--; };
2514 if (q - p != 4 || !len || *q != '-') return WS_E_INVALID_FORMAT;
2515 year = (p[0] - '0') * 1000 + (p[1] - '0') * 100 + (p[2] - '0') * 10 + p[3] - '0';
2516 if (year < 1) return WS_E_INVALID_FORMAT;
2517
2518 p = ++q; len--;
2519 while (len && isdigit( *q )) { q++; len--; };
2520 if (q - p != 2 || !len || *q != '-') return WS_E_INVALID_FORMAT;
2521 month = (p[0] - '0') * 10 + p[1] - '0';
2522 if (month < 1 || month > 12) return WS_E_INVALID_FORMAT;
2523
2524 p = ++q; len--;
2525 while (len && isdigit( *q )) { q++; len--; };
2526 if (q - p != 2 || !len || *q != 'T') return WS_E_INVALID_FORMAT;
2527 day = (p[0] - '0') * 10 + p[1] - '0';
2528 if (!valid_day( year, month, day )) return WS_E_INVALID_FORMAT;
2529
2530 p = ++q; len--;
2531 while (len && isdigit( *q )) { q++; len--; };
2532 if (q - p != 2 || !len || *q != ':') return WS_E_INVALID_FORMAT;
2533 hour = (p[0] - '0') * 10 + p[1] - '0';
2534 if (hour > 24) return WS_E_INVALID_FORMAT;
2535
2536 p = ++q; len--;
2537 while (len && isdigit( *q )) { q++; len--; };
2538 if (q - p != 2 || !len || *q != ':') return WS_E_INVALID_FORMAT;
2539 min = (p[0] - '0') * 10 + p[1] - '0';
2540 if (min > 59 || (min > 0 && hour == 24)) return WS_E_INVALID_FORMAT;
2541
2542 p = ++q; len--;
2543 while (len && isdigit( *q )) { q++; len--; };
2544 if (q - p != 2 || !len) return WS_E_INVALID_FORMAT;
2545 sec = (p[0] - '0') * 10 + p[1] - '0';
2546 if (sec > 59 || (sec > 0 && hour == 24)) return WS_E_INVALID_FORMAT;
2547
2548 if (*q == '.')
2549 {
2550 unsigned int i, nb_digits, mul = TICKS_PER_SEC / 10;
2551 p = ++q; len--;
2552 while (len && isdigit( *q )) { q++; len--; };
2553 nb_digits = q - p;
2554 if (nb_digits < 1 || nb_digits > 7) return WS_E_INVALID_FORMAT;
2555 for (i = 0; i < nb_digits; i++)
2556 {
2557 sec_frac += (p[i] - '0') * mul;
2558 mul /= 10;
2559 }
2560 }
2561 if (*q == 'Z')
2562 {
2563 if (--len) return WS_E_INVALID_FORMAT;
2564 tz_hour = tz_min = tz_neg = 0;
2565 ret->format = WS_DATETIME_FORMAT_UTC;
2566 }
2567 else if (*q == '+' || *q == '-')
2568 {
2569 tz_neg = (*q == '-') ? 1 : 0;
2570
2571 p = ++q; len--;
2572 while (len && isdigit( *q )) { q++; len--; };
2573 if (q - p != 2 || !len || *q != ':') return WS_E_INVALID_FORMAT;
2574 tz_hour = (p[0] - '0') * 10 + p[1] - '0';
2575 if (tz_hour > 14) return WS_E_INVALID_FORMAT;
2576
2577 p = ++q; len--;
2578 while (len && isdigit( *q )) { q++; len--; };
2579 if (q - p != 2 || len) return WS_E_INVALID_FORMAT;
2580 tz_min = (p[0] - '0') * 10 + p[1] - '0';
2581 if (tz_min > 59 || (tz_min > 0 && tz_hour == 14)) return WS_E_INVALID_FORMAT;
2582
2583 ret->format = WS_DATETIME_FORMAT_LOCAL;
2584 }
2585 else return WS_E_INVALID_FORMAT;
2586
2587 ret->ticks = ((year - 1) * 365 + leap_days_before( year )) * TICKS_PER_DAY;
2588 ret->ticks += month_offsets[is_leap_year( year )][month - 1] * TICKS_PER_DAY;
2589 ret->ticks += (day - 1) * TICKS_PER_DAY;
2590 ret->ticks += hour * TICKS_PER_HOUR;
2591 ret->ticks += min * TICKS_PER_MIN;
2592 ret->ticks += sec * TICKS_PER_SEC;
2593 ret->ticks += sec_frac;
2594
2595 if (tz_neg)
2596 {
2597 if (tz_hour * TICKS_PER_HOUR + tz_min * TICKS_PER_MIN + ret->ticks > TICKS_MAX)
2598 return WS_E_INVALID_FORMAT;
2599 ret->ticks += tz_hour * TICKS_PER_HOUR;
2600 ret->ticks += tz_min * TICKS_PER_MIN;
2601 }
2602 else
2603 {
2604 if (tz_hour * TICKS_PER_HOUR + tz_min * TICKS_PER_MIN > ret->ticks)
2605 return WS_E_INVALID_FORMAT;
2606 ret->ticks -= tz_hour * TICKS_PER_HOUR;
2607 ret->ticks -= tz_min * TICKS_PER_MIN;
2608 }
2609
2610 return S_OK;
2611 }
2612
2613 #define TICKS_1601_01_01 504911232000000000
2614
2615 /**************************************************************************
2616 * WsDateTimeToFileTime [webservices.@]
2617 */
2618 HRESULT WINAPI WsDateTimeToFileTime( const WS_DATETIME *dt, FILETIME *ft, WS_ERROR *error )
2619 {
2620 unsigned __int64 ticks;
2621
2622 TRACE( "%p %p %p\n", dt, ft, error );
2623 if (error) FIXME( "ignoring error parameter\n" );
2624
2625 if (!dt || !ft) return E_INVALIDARG;
2626
2627 if (dt->ticks < TICKS_1601_01_01) return WS_E_INVALID_FORMAT;
2628 ticks = dt->ticks - TICKS_1601_01_01;
2629 ft->dwHighDateTime = ticks >> 32;
2630 ft->dwLowDateTime = (DWORD)ticks;
2631 return S_OK;
2632 }
2633
2634 /**************************************************************************
2635 * WsFileTimeToDateTime [webservices.@]
2636 */
2637 HRESULT WINAPI WsFileTimeToDateTime( const FILETIME *ft, WS_DATETIME *dt, WS_ERROR *error )
2638 {
2639 unsigned __int64 ticks;
2640
2641 TRACE( "%p %p %p\n", ft, dt, error );
2642 if (error) FIXME( "ignoring error parameter\n" );
2643
2644 if (!dt || !ft) return E_INVALIDARG;
2645
2646 ticks = ((unsigned __int64)ft->dwHighDateTime << 32) | ft->dwLowDateTime;
2647 if (ticks > MAX_UINT64 - TICKS_1601_01_01) return WS_E_NUMERIC_OVERFLOW;
2648 if (ticks + TICKS_1601_01_01 > TICKS_MAX) return WS_E_INVALID_FORMAT;
2649 dt->ticks = ticks + TICKS_1601_01_01;
2650 dt->format = WS_DATETIME_FORMAT_UTC;
2651 return S_OK;
2652 }
2653
2654 static HRESULT read_get_node_text( struct reader *reader, WS_XML_UTF8_TEXT **ret )
2655 {
2656 WS_XML_TEXT_NODE *text;
2657
2658 if (node_type( reader->current ) != WS_XML_NODE_TYPE_TEXT)
2659 return WS_E_INVALID_FORMAT;
2660
2661 text = (WS_XML_TEXT_NODE *)&reader->current->hdr.node;
2662 if (text->text->textType != WS_XML_TEXT_TYPE_UTF8)
2663 {
2664 FIXME( "text type %u not supported\n", text->text->textType );
2665 return E_NOTIMPL;
2666 }
2667 *ret = (WS_XML_UTF8_TEXT *)text->text;
2668 return S_OK;
2669 }
2670
2671 static HRESULT read_get_attribute_text( struct reader *reader, ULONG index, WS_XML_UTF8_TEXT **ret )
2672 {
2673 WS_XML_ELEMENT_NODE *elem = &reader->current->hdr;
2674 WS_XML_ATTRIBUTE *attr;
2675
2676 if (node_type( reader->current ) != WS_XML_NODE_TYPE_ELEMENT)
2677 return WS_E_INVALID_FORMAT;
2678
2679 attr = elem->attributes[index];
2680 if (attr->value->textType != WS_XML_TEXT_TYPE_UTF8)
2681 {
2682 FIXME( "text type %u not supported\n", attr->value->textType );
2683 return E_NOTIMPL;
2684 }
2685 *ret = (WS_XML_UTF8_TEXT *)attr->value;
2686 return S_OK;
2687 }
2688
2689 static BOOL find_attribute( struct reader *reader, const WS_XML_STRING *localname,
2690 const WS_XML_STRING *ns, ULONG *index )
2691 {
2692 ULONG i;
2693 WS_XML_ELEMENT_NODE *elem = &reader->current->hdr;
2694
2695 if (!localname)
2696 {
2697 *index = reader->current_attr;
2698 return TRUE;
2699 }
2700 for (i = 0; i < elem->attributeCount; i++)
2701 {
2702 const WS_XML_STRING *localname2 = elem->attributes[i]->localName;
2703 const WS_XML_STRING *ns2 = elem->attributes[i]->ns;
2704
2705 if (!cmp_name( localname->bytes, localname->length, localname2->bytes, localname2->length ) &&
2706 !cmp_name( ns->bytes, ns->length, ns2->bytes, ns2->length ))
2707 {
2708 *index = i;
2709 return TRUE;
2710 }
2711 }
2712 return FALSE;
2713 }
2714
2715 /**************************************************************************
2716 * WsFindAttribute [webservices.@]
2717 */
2718 HRESULT WINAPI WsFindAttribute( WS_XML_READER *handle, const WS_XML_STRING *localname,
2719 const WS_XML_STRING *ns, BOOL required, ULONG *index,
2720 WS_ERROR *error )
2721 {
2722 struct reader *reader = (struct reader *)handle;
2723
2724 TRACE( "%p %s %s %d %p %p\n", handle, debugstr_xmlstr(localname), debugstr_xmlstr(ns),
2725 required, index, error );
2726 if (error) FIXME( "ignoring error parameter\n" );
2727
2728 if (!reader || !localname || !ns || !index) return E_INVALIDARG;
2729
2730 if (node_type( reader->current ) != WS_XML_NODE_TYPE_ELEMENT)
2731 return WS_E_INVALID_OPERATION;
2732
2733 if (!find_attribute( reader, localname, ns, index ))
2734 {
2735 if (required) return WS_E_INVALID_FORMAT;
2736 *index = ~0u;
2737 return S_FALSE;
2738 }
2739 return S_OK;
2740 }
2741
2742 static HRESULT read_get_text( struct reader *reader, WS_TYPE_MAPPING mapping,
2743 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
2744 WS_XML_UTF8_TEXT **ret, BOOL *found )
2745 {
2746 switch (mapping)
2747 {
2748 case WS_ATTRIBUTE_TYPE_MAPPING:
2749 {
2750 ULONG index;
2751 if (!(*found = find_attribute( reader, localname, ns, &index ))) return S_OK;
2752 return read_get_attribute_text( reader, index, ret );
2753 }
2754 case WS_ELEMENT_TYPE_MAPPING:
2755 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
2756 case WS_ANY_ELEMENT_TYPE_MAPPING:
2757 {
2758 HRESULT hr;
2759 *found = TRUE;
2760 if (localname)
2761 {
2762 const WS_XML_ELEMENT_NODE *elem = &reader->current->hdr;
2763
2764 if (WsXmlStringEquals( localname, elem->localName, NULL ) != S_OK ||
2765 WsXmlStringEquals( ns, elem->ns, NULL ) != S_OK)
2766 {
2767 *found = FALSE;
2768 return S_OK;
2769 }
2770 if ((hr = read_startelement( reader )) != S_OK) return hr;
2771 }
2772 return read_get_node_text( reader, ret );
2773 }
2774 default:
2775 FIXME( "mapping %u not supported\n", mapping );
2776 return E_NOTIMPL;
2777 }
2778 }
2779
2780 static HRESULT read_type_bool( struct reader *reader, WS_TYPE_MAPPING mapping,
2781 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
2782 const WS_BOOL_DESCRIPTION *desc, WS_READ_OPTION option,
2783 WS_HEAP *heap, void *ret, ULONG size )
2784 {
2785 WS_XML_UTF8_TEXT *utf8;
2786 HRESULT hr;
2787 BOOL found, val = FALSE;
2788
2789 if (desc)
2790 {
2791 FIXME( "description not supported\n" );
2792 return E_NOTIMPL;
2793 }
2794 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
2795 if (found)
2796 {
2797 ULONG len = utf8->value.length;
2798 if (len == 4 && !memcmp( utf8->value.bytes, "true", 4 )) val = TRUE;
2799 else if (len == 1 && !memcmp( utf8->value.bytes, "1", 1 )) val = TRUE;
2800 else if (len == 5 && !memcmp( utf8->value.bytes, "false", 5 )) val = FALSE;
2801 else if (len == 1 && !memcmp( utf8->value.bytes, "0", 1 )) val = FALSE;
2802 else return WS_E_INVALID_FORMAT;
2803 }
2804
2805 switch (option)
2806 {
2807 case WS_READ_REQUIRED_VALUE:
2808 if (!found) return WS_E_INVALID_FORMAT;
2809 if (size != sizeof(BOOL)) return E_INVALIDARG;
2810 *(BOOL *)ret = val;
2811 break;
2812
2813 case WS_READ_REQUIRED_POINTER:
2814 if (!found) return WS_E_INVALID_FORMAT;
2815 /* fall through */
2816
2817 case WS_READ_OPTIONAL_POINTER:
2818 {
2819 BOOL *heap_val = NULL;
2820 if (size != sizeof(heap_val)) return E_INVALIDARG;
2821 if (found)
2822 {
2823 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
2824 *heap_val = val;
2825 }
2826 *(BOOL **)ret = heap_val;
2827 break;
2828 }
2829 default:
2830 FIXME( "read option %u not supported\n", option );
2831 return E_NOTIMPL;
2832 }
2833
2834 return S_OK;
2835 }
2836
2837 static HRESULT read_type_int8( struct reader *reader, WS_TYPE_MAPPING mapping,
2838 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
2839 const WS_INT8_DESCRIPTION *desc, WS_READ_OPTION option,
2840 WS_HEAP *heap, void *ret, ULONG size )
2841 {
2842 WS_XML_UTF8_TEXT *utf8;
2843 HRESULT hr;
2844 INT64 val;
2845 BOOL found;
2846
2847 if (desc)
2848 {
2849 FIXME( "description not supported\n" );
2850 return E_NOTIMPL;
2851 }
2852 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
2853 if (found && (hr = str_to_int64( utf8->value.bytes, utf8->value.length, MIN_INT8, MAX_INT8, &val )) != S_OK)
2854 return hr;
2855
2856 switch (option)
2857 {
2858 case WS_READ_REQUIRED_VALUE:
2859 if (!found) return WS_E_INVALID_FORMAT;
2860 if (size != sizeof(INT8)) return E_INVALIDARG;
2861 *(INT8 *)ret = val;
2862 break;
2863
2864 case WS_READ_REQUIRED_POINTER:
2865 if (!found) return WS_E_INVALID_FORMAT;
2866 /* fall through */
2867
2868 case WS_READ_OPTIONAL_POINTER:
2869 {
2870 INT8 *heap_val = NULL;
2871 if (size != sizeof(heap_val)) return E_INVALIDARG;
2872 if (found)
2873 {
2874 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
2875 *heap_val = val;
2876 }
2877 *(INT8 **)ret = heap_val;
2878 break;
2879 }
2880 default:
2881 FIXME( "read option %u not supported\n", option );
2882 return E_NOTIMPL;
2883 }
2884
2885 return S_OK;
2886 }
2887
2888 static HRESULT read_type_int16( struct reader *reader, WS_TYPE_MAPPING mapping,
2889 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
2890 const WS_INT16_DESCRIPTION *desc, WS_READ_OPTION option,
2891 WS_HEAP *heap, void *ret, ULONG size )
2892 {
2893 WS_XML_UTF8_TEXT *utf8;
2894 HRESULT hr;
2895 INT64 val;
2896 BOOL found;
2897
2898 if (desc)
2899 {
2900 FIXME( "description not supported\n" );
2901 return E_NOTIMPL;
2902 }
2903 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
2904 if (found && (hr = str_to_int64( utf8->value.bytes, utf8->value.length, MIN_INT16, MAX_INT16, &val )) != S_OK)
2905 return hr;
2906
2907 switch (option)
2908 {
2909 case WS_READ_REQUIRED_VALUE:
2910 if (!found) return WS_E_INVALID_FORMAT;
2911 if (size != sizeof(INT16)) return E_INVALIDARG;
2912 *(INT16 *)ret = val;
2913 break;
2914
2915 case WS_READ_REQUIRED_POINTER:
2916 if (!found) return WS_E_INVALID_FORMAT;
2917 /* fall through */
2918
2919 case WS_READ_OPTIONAL_POINTER:
2920 {
2921 INT16 *heap_val = NULL;
2922 if (size != sizeof(heap_val)) return E_INVALIDARG;
2923 if (found)
2924 {
2925 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
2926 *heap_val = val;
2927 }
2928 *(INT16 **)ret = heap_val;
2929 break;
2930 }
2931 default:
2932 FIXME( "read option %u not supported\n", option );
2933 return E_NOTIMPL;
2934 }
2935
2936 return S_OK;
2937 }
2938
2939 static HRESULT read_type_int32( struct reader *reader, WS_TYPE_MAPPING mapping,
2940 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
2941 const WS_INT32_DESCRIPTION *desc, WS_READ_OPTION option,
2942 WS_HEAP *heap, void *ret, ULONG size )
2943 {
2944 WS_XML_UTF8_TEXT *utf8;
2945 HRESULT hr;
2946 INT64 val;
2947 BOOL found;
2948
2949 if (desc)
2950 {
2951 FIXME( "description not supported\n" );
2952 return E_NOTIMPL;
2953 }
2954 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
2955 if (found && (hr = str_to_int64( utf8->value.bytes, utf8->value.length, MIN_INT32, MAX_INT32, &val )) != S_OK)
2956 return hr;
2957
2958 switch (option)
2959 {
2960 case WS_READ_REQUIRED_VALUE:
2961 if (!found) return WS_E_INVALID_FORMAT;
2962 if (size != sizeof(INT32)) return E_INVALIDARG;
2963 *(INT32 *)ret = val;
2964 break;
2965
2966 case WS_READ_REQUIRED_POINTER:
2967 if (!found) return WS_E_INVALID_FORMAT;
2968 /* fall through */
2969
2970 case WS_READ_OPTIONAL_POINTER:
2971 {
2972 INT32 *heap_val = NULL;
2973 if (size != sizeof(heap_val)) return E_INVALIDARG;
2974 if (found)
2975 {
2976 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
2977 *heap_val = val;
2978 }
2979 *(INT32 **)ret = heap_val;
2980 break;
2981 }
2982 default:
2983 FIXME( "read option %u not supported\n", option );
2984 return E_NOTIMPL;
2985 }
2986
2987 return S_OK;
2988 }
2989
2990 static HRESULT read_type_int64( struct reader *reader, WS_TYPE_MAPPING mapping,
2991 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
2992 const WS_INT64_DESCRIPTION *desc, WS_READ_OPTION option,
2993 WS_HEAP *heap, void *ret, ULONG size )
2994 {
2995 WS_XML_UTF8_TEXT *utf8;
2996 HRESULT hr;
2997 INT64 val;
2998 BOOL found;
2999
3000 if (desc)
3001 {
3002 FIXME( "description not supported\n" );
3003 return E_NOTIMPL;
3004 }
3005 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3006 if (found && (hr = str_to_int64( utf8->value.bytes, utf8->value.length, MIN_INT64, MAX_INT64, &val )) != S_OK)
3007 return hr;
3008
3009 switch (option)
3010 {
3011 case WS_READ_REQUIRED_VALUE:
3012 if (!found) return WS_E_INVALID_FORMAT;
3013 if (size != sizeof(INT64)) return E_INVALIDARG;
3014 *(INT64 *)ret = val;
3015 break;
3016
3017 case WS_READ_REQUIRED_POINTER:
3018 if (!found) return WS_E_INVALID_FORMAT;
3019 /* fall through */
3020
3021 case WS_READ_OPTIONAL_POINTER:
3022 {
3023 INT64 *heap_val = NULL;
3024 if (size != sizeof(heap_val)) return E_INVALIDARG;
3025 if (found)
3026 {
3027 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3028 *heap_val = val;
3029 }
3030 *(INT64 **)ret = heap_val;
3031 break;
3032 }
3033 default:
3034 FIXME( "read option %u not supported\n", option );
3035 return E_NOTIMPL;
3036 }
3037
3038 return S_OK;
3039 }
3040
3041 static HRESULT read_type_uint8( struct reader *reader, WS_TYPE_MAPPING mapping,
3042 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3043 const WS_UINT8_DESCRIPTION *desc, WS_READ_OPTION option,
3044 WS_HEAP *heap, void *ret, ULONG size )
3045 {
3046 WS_XML_UTF8_TEXT *utf8;
3047 HRESULT hr;
3048 UINT64 val;
3049 BOOL found;
3050
3051 if (desc)
3052 {
3053 FIXME( "description not supported\n" );
3054 return E_NOTIMPL;
3055 }
3056 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3057 if (found && (hr = str_to_uint64( utf8->value.bytes, utf8->value.length, MAX_UINT8, &val )) != S_OK)
3058 return hr;
3059
3060 switch (option)
3061 {
3062 case WS_READ_REQUIRED_VALUE:
3063 if (!found) return WS_E_INVALID_FORMAT;
3064 if (size != sizeof(UINT8)) return E_INVALIDARG;
3065 *(UINT8 *)ret = val;
3066 break;
3067
3068 case WS_READ_REQUIRED_POINTER:
3069 if (!found) return WS_E_INVALID_FORMAT;
3070 /* fall through */
3071
3072 case WS_READ_OPTIONAL_POINTER:
3073 {
3074 UINT8 *heap_val = NULL;
3075 if (size != sizeof(heap_val)) return E_INVALIDARG;
3076 if (found)
3077 {
3078 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3079 *heap_val = val;
3080 }
3081 *(UINT8 **)ret = heap_val;
3082 break;
3083 }
3084 default:
3085 FIXME( "read option %u not supported\n", option );
3086 return E_NOTIMPL;
3087 }
3088
3089 return S_OK;
3090 }
3091
3092 static HRESULT read_type_uint16( struct reader *reader, WS_TYPE_MAPPING mapping,
3093 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3094 const WS_UINT16_DESCRIPTION *desc, WS_READ_OPTION option,
3095 WS_HEAP *heap, void *ret, ULONG size )
3096 {
3097 WS_XML_UTF8_TEXT *utf8;
3098 HRESULT hr;
3099 UINT64 val;
3100 BOOL found;
3101
3102 if (desc)
3103 {
3104 FIXME( "description not supported\n" );
3105 return E_NOTIMPL;
3106 }
3107 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3108 if (found && (hr = str_to_uint64( utf8->value.bytes, utf8->value.length, MAX_UINT16, &val )) != S_OK)
3109 return hr;
3110
3111 switch (option)
3112 {
3113 case WS_READ_REQUIRED_VALUE:
3114 if (!found) return WS_E_INVALID_FORMAT;
3115 if (size != sizeof(UINT16)) return E_INVALIDARG;
3116 *(UINT16 *)ret = val;
3117 break;
3118
3119 case WS_READ_REQUIRED_POINTER:
3120 if (!found) return WS_E_INVALID_FORMAT;
3121 /* fall through */
3122
3123 case WS_READ_OPTIONAL_POINTER:
3124 {
3125 UINT16 *heap_val = NULL;
3126 if (size != sizeof(heap_val)) return E_INVALIDARG;
3127 if (found)
3128 {
3129 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3130 *heap_val = val;
3131 }
3132 *(UINT16 **)ret = heap_val;
3133 break;
3134 }
3135 default:
3136 FIXME( "read option %u not supported\n", option );
3137 return E_NOTIMPL;
3138 }
3139
3140 return S_OK;
3141 }
3142
3143 static HRESULT read_type_uint32( struct reader *reader, WS_TYPE_MAPPING mapping,
3144 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3145 const WS_UINT32_DESCRIPTION *desc, WS_READ_OPTION option,
3146 WS_HEAP *heap, void *ret, ULONG size )
3147 {
3148 WS_XML_UTF8_TEXT *utf8;
3149 HRESULT hr;
3150 UINT64 val;
3151 BOOL found;
3152
3153 if (desc)
3154 {
3155 FIXME( "description not supported\n" );
3156 return E_NOTIMPL;
3157 }
3158 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3159 if (found && (hr = str_to_uint64( utf8->value.bytes, utf8->value.length, MAX_UINT32, &val )) != S_OK)
3160 return hr;
3161
3162 switch (option)
3163 {
3164 case WS_READ_REQUIRED_VALUE:
3165 if (!found) return WS_E_INVALID_FORMAT;
3166 if (size != sizeof(UINT32)) return E_INVALIDARG;
3167 *(UINT32 *)ret = val;
3168 break;
3169
3170 case WS_READ_REQUIRED_POINTER:
3171 if (!found) return WS_E_INVALID_FORMAT;
3172 /* fall through */
3173
3174 case WS_READ_OPTIONAL_POINTER:
3175 {
3176 UINT32 *heap_val = NULL;
3177 if (size != sizeof(heap_val)) return E_INVALIDARG;
3178 if (found)
3179 {
3180 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3181 *heap_val = val;
3182 }
3183 *(UINT32 **)ret = heap_val;
3184 break;
3185 }
3186 default:
3187 FIXME( "read option %u not supported\n", option );
3188 return E_NOTIMPL;
3189 }
3190
3191 return S_OK;
3192 }
3193
3194 static HRESULT read_type_uint64( struct reader *reader, WS_TYPE_MAPPING mapping,
3195 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3196 const WS_UINT64_DESCRIPTION *desc, WS_READ_OPTION option,
3197 WS_HEAP *heap, void *ret, ULONG size )
3198 {
3199 WS_XML_UTF8_TEXT *utf8;
3200 HRESULT hr;
3201 UINT64 val;
3202 BOOL found;
3203
3204 if (desc)
3205 {
3206 FIXME( "description not supported\n" );
3207 return E_NOTIMPL;
3208 }
3209 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3210 if (found && (hr = str_to_uint64( utf8->value.bytes, utf8->value.length, MAX_UINT64, &val )) != S_OK)
3211 return hr;
3212
3213 switch (option)
3214 {
3215 case WS_READ_REQUIRED_VALUE:
3216 if (!found) return WS_E_INVALID_FORMAT;
3217 if (size != sizeof(UINT64)) return E_INVALIDARG;
3218 *(UINT64 *)ret = val;
3219 break;
3220
3221 case WS_READ_REQUIRED_POINTER:
3222 if (!found) return WS_E_INVALID_FORMAT;
3223 /* fall through */
3224
3225 case WS_READ_OPTIONAL_POINTER:
3226 {
3227 UINT64 *heap_val = NULL;
3228 if (size != sizeof(heap_val)) return E_INVALIDARG;
3229 if (found)
3230 {
3231 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3232 *heap_val = val;
3233 }
3234 *(UINT64 **)ret = heap_val;
3235 break;
3236 }
3237 default:
3238 FIXME( "read option %u not supported\n", option );
3239 return E_NOTIMPL;
3240 }
3241
3242 return S_OK;
3243 }
3244
3245 static HRESULT read_type_double( struct reader *reader, WS_TYPE_MAPPING mapping,
3246 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3247 const WS_DOUBLE_DESCRIPTION *desc, WS_READ_OPTION option,
3248 WS_HEAP *heap, void *ret, ULONG size )
3249 {
3250 WS_XML_UTF8_TEXT *utf8;
3251 HRESULT hr;
3252 double val = 0.0;
3253 BOOL found;
3254
3255 if (desc) FIXME( "ignoring description\n" );
3256
3257 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3258 if (found && (hr = str_to_double( utf8->value.bytes, utf8->value.length, &val )) != S_OK) return hr;
3259
3260 switch (option)
3261 {
3262 case WS_READ_REQUIRED_VALUE:
3263 if (!found) return WS_E_INVALID_FORMAT;
3264 if (size != sizeof(double)) return E_INVALIDARG;
3265 *(double *)ret = val;
3266 break;
3267
3268 case WS_READ_REQUIRED_POINTER:
3269 if (!found) return WS_E_INVALID_FORMAT;
3270 /* fall through */
3271
3272 case WS_READ_OPTIONAL_POINTER:
3273 {
3274 double *heap_val = NULL;
3275 if (size != sizeof(heap_val)) return E_INVALIDARG;
3276 if (found)
3277 {
3278 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3279 *heap_val = val;
3280 }
3281 *(double **)ret = heap_val;
3282 break;
3283 }
3284 default:
3285 FIXME( "read option %u not supported\n", option );
3286 return E_NOTIMPL;
3287 }
3288
3289 return S_OK;
3290 }
3291
3292 static HRESULT read_type_wsz( struct reader *reader, WS_TYPE_MAPPING mapping,
3293 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3294 const WS_WSZ_DESCRIPTION *desc, WS_READ_OPTION option,
3295 WS_HEAP *heap, WCHAR **ret, ULONG size )
3296 {
3297 WS_XML_UTF8_TEXT *utf8;
3298 HRESULT hr;
3299 WCHAR *str = NULL;
3300 BOOL found;
3301
3302 if (desc)
3303 {
3304 FIXME( "description not supported\n" );
3305 return E_NOTIMPL;
3306 }
3307 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3308 if (found && !(str = xmltext_to_widechar( heap, &utf8->text ))) return WS_E_QUOTA_EXCEEDED;
3309
3310 switch (option)
3311 {
3312 case WS_READ_REQUIRED_POINTER:
3313 if (!found) return WS_E_INVALID_FORMAT;
3314 /* fall through */
3315
3316 case WS_READ_OPTIONAL_POINTER:
3317 if (size != sizeof(str)) return E_INVALIDARG;
3318 *ret = str;
3319 break;
3320
3321 default:
3322 FIXME( "read option %u not supported\n", option );
3323 return E_NOTIMPL;
3324 }
3325
3326 return S_OK;
3327 }
3328
3329 static HRESULT get_enum_value( const WS_XML_UTF8_TEXT *text, const WS_ENUM_DESCRIPTION *desc, int *ret )
3330 {
3331 ULONG i;
3332 for (i = 0; i < desc->valueCount; i++)
3333 {
3334 if (WsXmlStringEquals( &text->value, desc->values[i].name, NULL ) == S_OK)
3335 {
3336 *ret = desc->values[i].value;
3337 return S_OK;
3338 }
3339 }
3340 return WS_E_INVALID_FORMAT;
3341 }
3342
3343 static HRESULT read_type_enum( struct reader *reader, WS_TYPE_MAPPING mapping,
3344 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3345 const WS_ENUM_DESCRIPTION *desc, WS_READ_OPTION option,
3346 WS_HEAP *heap, void *ret, ULONG size )
3347 {
3348 WS_XML_UTF8_TEXT *utf8;
3349 HRESULT hr;
3350 int val = 0;
3351 BOOL found;
3352
3353 if (!desc) return E_INVALIDARG;
3354
3355 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3356 if (found && (hr = get_enum_value( utf8, desc, &val )) != S_OK) return hr;
3357
3358 switch (option)
3359 {
3360 case WS_READ_REQUIRED_VALUE:
3361 if (!found) return WS_E_INVALID_FORMAT;
3362 if (size != sizeof(int)) return E_INVALIDARG;
3363 *(int *)ret = val;
3364 break;
3365
3366 case WS_READ_REQUIRED_POINTER:
3367 if (!found) return WS_E_INVALID_FORMAT;
3368 /* fall through */
3369
3370 case WS_READ_OPTIONAL_POINTER:
3371 {
3372 int *heap_val = NULL;
3373 if (size != sizeof(heap_val)) return E_INVALIDARG;
3374 if (found)
3375 {
3376 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3377 *heap_val = val;
3378 }
3379 *(int **)ret = heap_val;
3380 break;
3381 }
3382 default:
3383 FIXME( "read option %u not supported\n", option );
3384 return E_NOTIMPL;
3385 }
3386
3387 return S_OK;
3388 }
3389
3390 static HRESULT read_type_datetime( struct reader *reader, WS_TYPE_MAPPING mapping,
3391 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3392 const WS_DATETIME_DESCRIPTION *desc, WS_READ_OPTION option,
3393 WS_HEAP *heap, void *ret, ULONG size )
3394 {
3395 WS_XML_UTF8_TEXT *utf8;
3396 HRESULT hr;
3397 WS_DATETIME val = {0, WS_DATETIME_FORMAT_UTC};
3398 BOOL found;
3399
3400 if (desc) FIXME( "ignoring description\n" );
3401
3402 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3403 if (found && (hr = str_to_datetime( utf8->value.bytes, utf8->value.length, &val )) != S_OK) return hr;
3404
3405 switch (option)
3406 {
3407 case WS_READ_REQUIRED_VALUE:
3408 if (!found) return WS_E_INVALID_FORMAT;
3409 if (size != sizeof(WS_DATETIME)) return E_INVALIDARG;
3410 *(WS_DATETIME *)ret = val;
3411 break;
3412
3413 case WS_READ_REQUIRED_POINTER:
3414 if (!found) return WS_E_INVALID_FORMAT;
3415 /* fall through */
3416
3417 case WS_READ_OPTIONAL_POINTER:
3418 {
3419 WS_DATETIME *heap_val = NULL;
3420 if (size != sizeof(heap_val)) return E_INVALIDARG;
3421 if (found)
3422 {
3423 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3424 *heap_val = val;
3425 }
3426 *(WS_DATETIME **)ret = heap_val;
3427 break;
3428 }
3429 default:
3430 FIXME( "read option %u not supported\n", option );
3431 return E_NOTIMPL;
3432 }
3433
3434 return S_OK;
3435 }
3436
3437 static HRESULT read_type_guid( struct reader *reader, WS_TYPE_MAPPING mapping,
3438 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3439 const WS_GUID_DESCRIPTION *desc, WS_READ_OPTION option,
3440 WS_HEAP *heap, void *ret, ULONG size )
3441 {
3442 WS_XML_UTF8_TEXT *utf8;
3443 GUID val;
3444 HRESULT hr;
3445 BOOL found;
3446
3447 if (desc) FIXME( "ignoring description\n" );
3448
3449 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3450 if (found && (hr = str_to_guid( utf8->value.bytes, utf8->value.length, &val )) != S_OK) return hr;
3451
3452 switch (option)
3453 {
3454 case WS_READ_REQUIRED_VALUE:
3455 if (!found) return WS_E_INVALID_FORMAT;
3456 if (size != sizeof(GUID)) return E_INVALIDARG;
3457 *(GUID *)ret = val;
3458 break;
3459
3460 case WS_READ_REQUIRED_POINTER:
3461 if (!found) return WS_E_INVALID_FORMAT;
3462 /* fall through */
3463
3464 case WS_READ_OPTIONAL_POINTER:
3465 {
3466 GUID *heap_val = NULL;
3467 if (size != sizeof(heap_val)) return E_INVALIDARG;
3468 if (found)
3469 {
3470 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3471 *heap_val = val;
3472 }
3473 *(GUID **)ret = heap_val;
3474 break;
3475 }
3476 default:
3477 FIXME( "read option %u not supported\n", option );
3478 return E_NOTIMPL;
3479 }
3480
3481 return S_OK;
3482 }
3483
3484 static BOOL is_empty_text_node( const struct node *node )
3485 {
3486 const WS_XML_TEXT_NODE *text = (const WS_XML_TEXT_NODE *)node;
3487 const WS_XML_UTF8_TEXT *utf8;
3488 ULONG i;
3489
3490 if (node_type( node ) != WS_XML_NODE_TYPE_TEXT) return FALSE;
3491 if (text->text->textType != WS_XML_TEXT_TYPE_UTF8)
3492 {
3493 ERR( "unhandled text type %u\n", text->text->textType );
3494 return FALSE;
3495 }
3496 utf8 = (const WS_XML_UTF8_TEXT *)text->text;
3497 for (i = 0; i < utf8->value.length; i++) if (!read_isspace( utf8->value.bytes[i] )) return FALSE;
3498 return TRUE;
3499 }
3500
3501 static HRESULT read_next_node( struct reader *reader )
3502 {
3503 if (reader->current == reader->last) return read_node( reader );
3504 if (move_to_child_node( &reader->current )) return S_OK;
3505 if (move_to_next_node( &reader->current )) return S_OK;
3506 if (!move_to_parent_node( &reader->current )) return WS_E_INVALID_FORMAT;
3507 if (move_to_next_node( &reader->current )) return S_OK;
3508 return WS_E_INVALID_FORMAT;
3509 }
3510
3511 /* skips comment and empty text nodes */
3512 static HRESULT read_type_next_node( struct reader *reader )
3513 {
3514 for (;;)
3515 {
3516 HRESULT hr;
3517 WS_XML_NODE_TYPE type;
3518
3519 if ((hr = read_next_node( reader )) != S_OK) return hr;
3520 type = node_type( reader->current );
3521 if (type == WS_XML_NODE_TYPE_COMMENT ||
3522 (type == WS_XML_NODE_TYPE_TEXT && is_empty_text_node( reader->current ))) continue;
3523 return S_OK;
3524 }
3525 }
3526
3527 static BOOL match_current_element( struct reader *reader, const WS_XML_STRING *localname,
3528 const WS_XML_STRING *ns )
3529 {
3530 const WS_XML_ELEMENT_NODE *elem = &reader->current->hdr;
3531 if (node_type( reader->current ) != WS_XML_NODE_TYPE_ELEMENT) return FALSE;
3532 return WsXmlStringEquals( localname, elem->localName, NULL ) == S_OK &&
3533 WsXmlStringEquals( ns, elem->ns, NULL ) == S_OK;
3534 }
3535
3536 static HRESULT read_type_next_element_node( struct reader *reader, const WS_XML_STRING *localname,
3537 const WS_XML_STRING *ns )
3538 {
3539 struct node *node;
3540 ULONG attr;
3541 HRESULT hr;
3542
3543 if (!localname) return S_OK; /* assume reader is already correctly positioned */
3544 if (reader->current == reader->last)
3545 {
3546 BOOL found;
3547 if ((hr = read_to_startelement( reader, &found )) != S_OK) return hr;
3548 if (!found) return WS_E_INVALID_FORMAT;
3549 }
3550 if (match_current_element( reader, localname, ns )) return S_OK;
3551
3552 node = reader->current;
3553 attr = reader->current_attr;
3554
3555 if ((hr = read_type_next_node( reader )) != S_OK) return hr;
3556 if (match_current_element( reader, localname, ns )) return S_OK;
3557
3558 reader->current = node;
3559 reader->current_attr = attr;
3560
3561 return WS_E_INVALID_FORMAT;
3562 }
3563
3564 ULONG get_type_size( WS_TYPE type, const WS_STRUCT_DESCRIPTION *desc )
3565 {
3566 switch (type)
3567 {
3568 case WS_INT8_TYPE:
3569 case WS_UINT8_TYPE:
3570 return sizeof(INT8);
3571
3572 case WS_INT16_TYPE:
3573 case WS_UINT16_TYPE:
3574 return sizeof(INT16);
3575
3576 case WS_BOOL_TYPE:
3577 case WS_INT32_TYPE:
3578 case WS_UINT32_TYPE:
3579 case WS_ENUM_TYPE:
3580 return sizeof(INT32);
3581
3582 case WS_INT64_TYPE:
3583 case WS_UINT64_TYPE:
3584 return sizeof(INT64);
3585
3586 case WS_DOUBLE_TYPE:
3587 return sizeof(double);
3588
3589 case WS_DATETIME_TYPE:
3590 return sizeof(WS_DATETIME);
3591
3592 case WS_GUID_TYPE:
3593 return sizeof(GUID);
3594
3595 case WS_WSZ_TYPE:
3596 return sizeof(WCHAR *);
3597
3598 case WS_STRUCT_TYPE:
3599 return desc->size;
3600
3601 default:
3602 ERR( "unhandled type %u\n", type );
3603 return 0;
3604 }
3605 }
3606
3607 static WS_READ_OPTION get_array_read_option( WS_TYPE type )
3608 {
3609 switch (type)
3610 {
3611 case WS_BOOL_TYPE:
3612 case WS_INT8_TYPE:
3613 case WS_INT16_TYPE:
3614 case WS_INT32_TYPE:
3615 case WS_INT64_TYPE:
3616 case WS_UINT8_TYPE:
3617 case WS_UINT16_TYPE:
3618 case WS_UINT32_TYPE:
3619 case WS_UINT64_TYPE:
3620 case WS_DOUBLE_TYPE:
3621 case WS_ENUM_TYPE:
3622 case WS_STRUCT_TYPE:
3623 case WS_DATETIME_TYPE:
3624 case WS_GUID_TYPE:
3625 return WS_READ_REQUIRED_VALUE;
3626
3627 case WS_WSZ_TYPE:
3628 return WS_READ_REQUIRED_POINTER;
3629
3630 default:
3631 FIXME( "unhandled type %u\n", type );
3632 return 0;
3633 }
3634 }
3635
3636 static HRESULT read_type( struct reader *, WS_TYPE_MAPPING, WS_TYPE, const WS_XML_STRING *,
3637 const WS_XML_STRING *, const void *, WS_READ_OPTION, WS_HEAP *,
3638 void *, ULONG );
3639
3640 static HRESULT read_type_repeating_element( struct reader *reader, const WS_FIELD_DESCRIPTION *desc,
3641 WS_HEAP *heap, void **ret, ULONG size, ULONG *count )
3642 {
3643 HRESULT hr;
3644 ULONG item_size, nb_items = 0, nb_allocated = 1, offset = 0;
3645 WS_READ_OPTION option;
3646 char *buf;
3647
3648 if (size != sizeof(void *) || !(option = get_array_read_option( desc->type ))) return E_INVALIDARG;
3649
3650 /* wrapper element */
3651 if (desc->localName && ((hr = read_type_next_element_node( reader, desc->localName, desc->ns )) != S_OK))
3652 return hr;
3653
3654 if (option == WS_READ_REQUIRED_VALUE)
3655 item_size = get_type_size( desc->type, desc->typeDescription );
3656 else
3657 item_size = sizeof(void *);
3658
3659 if (!(buf = ws_alloc_zero( heap, item_size ))) return WS_E_QUOTA_EXCEEDED;
3660 for (;;)
3661 {
3662 if (nb_items >= nb_allocated)
3663 {
3664 if (!(buf = ws_realloc_zero( heap, buf, nb_allocated * 2 * item_size )))
3665 return WS_E_QUOTA_EXCEEDED;
3666 nb_allocated *= 2;
3667 }
3668 hr = read_type( reader, WS_ELEMENT_TYPE_MAPPING, desc->type, desc->itemLocalName, desc->itemNs,
3669 desc->typeDescription, option, heap, buf + offset, item_size );
3670 if (hr == WS_E_INVALID_FORMAT) break;
3671 if (hr != S_OK)
3672 {
3673 ws_free( heap, buf );
3674 return hr;
3675 }
3676 offset += item_size;
3677 nb_items++;
3678 }
3679
3680 if (desc->localName && ((hr = read_type_next_node( reader )) != S_OK)) return hr;
3681
3682 if (desc->itemRange && (nb_items < desc->itemRange->minItemCount || nb_items > desc->itemRange->maxItemCount))
3683 {
3684 TRACE( "number of items %u out of range (%u-%u)\n", nb_items, desc->itemRange->minItemCount,
3685 desc->itemRange->maxItemCount );
3686 ws_free( heap, buf );
3687 return WS_E_INVALID_FORMAT;
3688 }
3689
3690 *count = nb_items;
3691 *ret = buf;
3692
3693 return S_OK;
3694 }
3695
3696 static HRESULT read_type_text( struct reader *reader, const WS_FIELD_DESCRIPTION *desc,
3697 WS_READ_OPTION option, WS_HEAP *heap, void *ret, ULONG size )
3698 {
3699 HRESULT hr;
3700 if (reader->current == reader->last)
3701 {
3702 BOOL found;
3703 if ((hr = read_to_startelement( reader, &found )) != S_OK) return S_OK;
3704 if (!found) return WS_E_INVALID_FORMAT;
3705 }
3706 if ((hr = read_next_node( reader )) != S_OK) return hr;
3707 if (node_type( reader->current ) != WS_XML_NODE_TYPE_TEXT) return WS_E_INVALID_FORMAT;
3708
3709 return read_type( reader, WS_ANY_ELEMENT_TYPE_MAPPING, desc->type, NULL, NULL,
3710 desc->typeDescription, option, heap, ret, size );
3711 }
3712
3713 static WS_READ_OPTION get_field_read_option( WS_TYPE type )
3714 {
3715 switch (type)
3716 {
3717 case WS_BOOL_TYPE:
3718 case WS_INT8_TYPE:
3719 case WS_INT16_TYPE:
3720 case WS_INT32_TYPE:
3721 case WS_INT64_TYPE:
3722 case WS_UINT8_TYPE:
3723 case WS_UINT16_TYPE:
3724 case WS_UINT32_TYPE:
3725 case WS_UINT64_TYPE:
3726 case WS_DOUBLE_TYPE:
3727 case WS_ENUM_TYPE:
3728 case WS_DATETIME_TYPE:
3729 case WS_GUID_TYPE:
3730 return WS_READ_REQUIRED_VALUE;
3731
3732 case WS_WSZ_TYPE:
3733 case WS_STRUCT_TYPE:
3734 return WS_READ_REQUIRED_POINTER;
3735
3736 default:
3737 FIXME( "unhandled type %u\n", type );
3738 return 0;
3739 }
3740 }
3741
3742 static HRESULT read_type_struct_field( struct reader *reader, const WS_FIELD_DESCRIPTION *desc,
3743 WS_HEAP *heap, char *buf )
3744 {
3745 char *ptr;
3746 WS_READ_OPTION option;
3747 ULONG size;
3748 HRESULT hr;
3749
3750 if (!desc) return E_INVALIDARG;
3751 if (desc->options & ~(WS_FIELD_POINTER | WS_FIELD_OPTIONAL))
3752 {
3753 FIXME( "options %08x not supported\n", desc->options );
3754 return E_NOTIMPL;
3755 }
3756 if (!(option = get_field_read_option( desc->type ))) return E_INVALIDARG;
3757
3758 if (option == WS_READ_REQUIRED_VALUE)
3759 size = get_type_size( desc->type, desc->typeDescription );
3760 else
3761 size = sizeof(void *);
3762
3763 ptr = buf + desc->offset;
3764 switch (desc->mapping)
3765 {
3766 case WS_ATTRIBUTE_FIELD_MAPPING:
3767 hr = read_type( reader, WS_ATTRIBUTE_TYPE_MAPPING, desc->type, desc->localName, desc->ns,
3768 desc->typeDescription, option, heap, ptr, size );
3769 break;
3770
3771 case WS_ELEMENT_FIELD_MAPPING:
3772 hr = read_type( reader, WS_ELEMENT_TYPE_MAPPING, desc->type, desc->localName, desc->ns,
3773 desc->typeDescription, option, heap, ptr, size );
3774 break;
3775
3776 case WS_REPEATING_ELEMENT_FIELD_MAPPING:
3777 {
3778 ULONG count;
3779 hr = read_type_repeating_element( reader, desc, heap, (void **)ptr, size, &count );
3780 if (hr == S_OK) *(ULONG *)(buf + desc->countOffset) = count;
3781 break;
3782 }
3783 case WS_TEXT_FIELD_MAPPING:
3784 hr = read_type_text( reader, desc, option, heap, ptr, size );
3785 break;
3786
3787 default:
3788 FIXME( "unhandled field mapping %u\n", desc->mapping );
3789 return E_NOTIMPL;
3790 }
3791
3792 if (hr == WS_E_INVALID_FORMAT && desc->options & WS_FIELD_OPTIONAL)
3793 {
3794 switch (option)
3795 {
3796 case WS_READ_REQUIRED_VALUE:
3797 if (desc->defaultValue) memcpy( ptr, desc->defaultValue->value, desc->defaultValue->valueSize );
3798 else memset( ptr, 0, size );
3799 return S_OK;
3800
3801 case WS_READ_REQUIRED_POINTER:
3802 *(void **)ptr = NULL;
3803 return S_OK;
3804
3805 default:
3806 ERR( "unhandled option %u\n", option );
3807 return E_NOTIMPL;
3808 }
3809 }
3810
3811 return hr;
3812 }
3813
3814 static HRESULT read_type_struct( struct reader *reader, WS_TYPE_MAPPING mapping,
3815 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3816 const WS_STRUCT_DESCRIPTION *desc, WS_READ_OPTION option,
3817 WS_HEAP *heap, void *ret, ULONG size )
3818 {
3819 ULONG i;
3820 HRESULT hr;
3821 char *buf;
3822
3823 if (!desc) return E_INVALIDARG;
3824 if (desc->structOptions) FIXME( "struct options %08x not supported\n", desc->structOptions );
3825
3826 switch (option)
3827 {
3828 case WS_READ_REQUIRED_POINTER:
3829 case WS_READ_OPTIONAL_POINTER:
3830 if (size != sizeof(void *)) return E_INVALIDARG;
3831 if (!(buf = ws_alloc_zero( heap, desc->size ))) return WS_E_QUOTA_EXCEEDED;
3832 break;
3833
3834 case WS_READ_REQUIRED_VALUE:
3835 if (size != desc->size) return E_INVALIDARG;
3836 buf = ret;
3837 break;
3838
3839 default:
3840 FIXME( "unhandled read option %u\n", option );
3841 return E_NOTIMPL;
3842 }
3843
3844 for (i = 0; i < desc->fieldCount; i++)
3845 {
3846 if ((hr = read_type_struct_field( reader, desc->fields[i], heap, buf )) != S_OK)
3847 break;
3848 }
3849
3850 switch (option)
3851 {
3852 case WS_READ_REQUIRED_POINTER:
3853 if (hr != S_OK)
3854 {
3855 ws_free( heap, buf );
3856 return hr;
3857 }
3858 *(char **)ret = buf;
3859 return S_OK;
3860
3861 case WS_READ_OPTIONAL_POINTER:
3862 if (hr != S_OK)
3863 {
3864 ws_free( heap, buf );
3865 buf = NULL;
3866 }
3867 *(char **)ret = buf;
3868 return S_OK;
3869
3870 case WS_READ_REQUIRED_VALUE:
3871 return hr;
3872
3873 default:
3874 ERR( "unhandled read option %u\n", option );
3875 return E_NOTIMPL;
3876 }
3877 }
3878
3879 static HRESULT read_type( struct reader *reader, WS_TYPE_MAPPING mapping, WS_TYPE type,
3880 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3881 const void *desc, WS_READ_OPTION option, WS_HEAP *heap,
3882 void *value, ULONG size )
3883 {
3884 HRESULT hr;
3885
3886 switch (mapping)
3887 {
3888 case WS_ELEMENT_TYPE_MAPPING:
3889 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
3890 if ((hr = read_type_next_element_node( reader, localname, ns )) != S_OK) return hr;
3891 break;
3892
3893 case WS_ANY_ELEMENT_TYPE_MAPPING:
3894 case WS_ATTRIBUTE_TYPE_MAPPING:
3895 break;
3896
3897 default:
3898 FIXME( "unhandled mapping %u\n", mapping );
3899 return E_NOTIMPL;
3900 }
3901
3902 switch (type)
3903 {
3904 case WS_STRUCT_TYPE:
3905 if ((hr = read_type_struct( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
3906 return hr;
3907 break;
3908
3909 case WS_BOOL_TYPE:
3910 if ((hr = read_type_bool( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
3911 return hr;
3912 break;
3913
3914 case WS_INT8_TYPE:
3915 if ((hr = read_type_int8( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
3916 return hr;
3917 break;
3918
3919 case WS_INT16_TYPE:
3920 if ((hr = read_type_int16( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
3921 return hr;
3922 break;
3923
3924 case WS_INT32_TYPE:
3925 if ((hr = read_type_int32( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
3926 return hr;
3927 break;
3928
3929 case WS_INT64_TYPE:
3930 if ((hr = read_type_int64( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
3931 return hr;
3932 break;
3933
3934 case WS_UINT8_TYPE:
3935 if ((hr = read_type_uint8( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
3936 return hr;
3937 break;
3938
3939 case WS_UINT16_TYPE:
3940 if ((hr = read_type_uint16( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
3941 return hr;
3942 break;
3943
3944 case WS_UINT32_TYPE:
3945 if ((hr = read_type_uint32( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
3946 return hr;
3947 break;
3948
3949 case WS_UINT64_TYPE:
3950 if ((hr = read_type_uint64( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
3951 return hr;
3952 break;
3953
3954 case WS_DOUBLE_TYPE:
3955 if ((hr = read_type_double( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
3956 return hr;
3957 break;
3958
3959 case WS_WSZ_TYPE:
3960 if ((hr = read_type_wsz( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
3961 return hr;
3962 break;
3963
3964 case WS_ENUM_TYPE:
3965 if ((hr = read_type_enum( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
3966 return hr;
3967 break;
3968
3969 case WS_DATETIME_TYPE:
3970 if ((hr = read_type_datetime( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
3971 return hr;
3972 break;
3973
3974 case WS_GUID_TYPE:
3975 if ((hr = read_type_guid( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
3976 return hr;
3977 break;
3978
3979 default:
3980 FIXME( "type %u not supported\n", type );
3981 return E_NOTIMPL;
3982 }
3983
3984 switch (mapping)
3985 {
3986 case WS_ELEMENT_TYPE_MAPPING:
3987 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
3988 return read_type_next_node( reader );
3989
3990 case WS_ATTRIBUTE_TYPE_MAPPING:
3991 default:
3992 return S_OK;
3993 }
3994 }
3995
3996 /**************************************************************************
3997 * WsReadType [webservices.@]
3998 */
3999 HRESULT WINAPI WsReadType( WS_XML_READER *handle, WS_TYPE_MAPPING mapping, WS_TYPE type,
4000 const void *desc, WS_READ_OPTION option, WS_HEAP *heap, void *value,
4001 ULONG size, WS_ERROR *error )
4002 {
4003 struct reader *reader = (struct reader *)handle;
4004 HRESULT hr;
4005
4006 TRACE( "%p %u %u %p %u %p %p %u %p\n", handle, mapping, type, desc, option, heap, value,
4007 size, error );
4008 if (error) FIXME( "ignoring error parameter\n" );
4009
4010 if (!reader || !value) return E_INVALIDARG;
4011
4012 if ((hr = read_type( reader, mapping, type, NULL, NULL, desc, option, heap, value, size )) != S_OK)
4013 return hr;
4014
4015 switch (mapping)
4016 {
4017 case WS_ELEMENT_TYPE_MAPPING:
4018 if ((hr = read_node( reader )) != S_OK) return hr;
4019 break;
4020
4021 default:
4022 break;
4023 }
4024
4025 if (!read_end_of_data( reader )) return WS_E_INVALID_FORMAT;
4026 return S_OK;
4027 }
4028
4029 /**************************************************************************
4030 * WsReadElement [webservices.@]
4031 */
4032 HRESULT WINAPI WsReadElement( WS_XML_READER *handle, const WS_ELEMENT_DESCRIPTION *desc,
4033 WS_READ_OPTION option, WS_HEAP *heap, void *value, ULONG size,
4034 WS_ERROR *error )
4035 {
4036 struct reader *reader = (struct reader *)handle;
4037
4038 TRACE( "%p %p %u %p %p %u %p\n", handle, desc, option, heap, value, size, error );
4039 if (error) FIXME( "ignoring error parameter\n" );
4040
4041 if (!reader || !desc || !value) return E_INVALIDARG;
4042
4043 return read_type( reader, WS_ELEMENT_TYPE_MAPPING, desc->type, desc->elementLocalName,
4044 desc->elementNs, desc->typeDescription, option, heap, value, size );
4045 }
4046
4047 /**************************************************************************
4048 * WsReadValue [webservices.@]
4049 */
4050 HRESULT WINAPI WsReadValue( WS_XML_READER *handle, WS_VALUE_TYPE value_type, void *value, ULONG size,
4051 WS_ERROR *error )
4052 {
4053 struct reader *reader = (struct reader *)handle;
4054 WS_TYPE type = map_value_type( value_type );
4055
4056 TRACE( "%p %u %p %u %p\n", handle, type, value, size, error );
4057 if (error) FIXME( "ignoring error parameter\n" );
4058
4059 if (!reader || !value || type == ~0u) return E_INVALIDARG;
4060
4061 return read_type( reader, WS_ELEMENT_TYPE_MAPPING, type, NULL, NULL, NULL, WS_READ_REQUIRED_VALUE,
4062 NULL, value, size );
4063 }
4064
4065 /**************************************************************************
4066 * WsSetErrorProperty [webservices.@]
4067 */
4068 HRESULT WINAPI WsSetErrorProperty( WS_ERROR *handle, WS_ERROR_PROPERTY_ID id, const void *value,
4069 ULONG size )
4070 {
4071 struct error *error = (struct error *)handle;
4072
4073 TRACE( "%p %u %p %u\n", handle, id, value, size );
4074
4075 if (id == WS_ERROR_PROPERTY_LANGID) return WS_E_INVALID_OPERATION;
4076 return prop_set( error->prop, error->prop_count, id, value, size );
4077 }
4078
4079 static inline BOOL is_utf8( const unsigned char *data, ULONG size, ULONG *offset )
4080 {
4081 static const char bom[] = {0xef,0xbb,0xbf};
4082 const unsigned char *p = data;
4083
4084 return (size >= sizeof(bom) && !memcmp( p, bom, sizeof(bom) ) && (*offset = sizeof(bom))) ||
4085 (size > 2 && !(*offset = 0));
4086 }
4087
4088 static inline BOOL is_utf16le( const unsigned char *data, ULONG size, ULONG *offset )
4089 {
4090 static const char bom[] = {0xff,0xfe};
4091 const unsigned char *p = data;
4092
4093 return (size >= sizeof(bom) && !memcmp( p, bom, sizeof(bom) ) && (*offset = sizeof(bom))) ||
4094 (size >= 4 && p[0] == '<' && !p[1] && !(*offset = 0));
4095 }
4096
4097 static WS_CHARSET detect_charset( const unsigned char *data, ULONG size, ULONG *offset )
4098 {
4099 WS_CHARSET ret = 0;
4100
4101 /* FIXME: parse xml declaration */
4102
4103 if (is_utf16le( data, size, offset )) ret = WS_CHARSET_UTF16LE;
4104 else if (is_utf8( data, size, offset )) ret = WS_CHARSET_UTF8;
4105 else
4106 {
4107 FIXME( "charset not recognized\n" );
4108 return 0;
4109 }
4110
4111 TRACE( "detected charset %u\n", ret );
4112 return ret;
4113 }
4114
4115 static void set_input_buffer( struct reader *reader, struct xmlbuf *buf, const unsigned char *data, ULONG size )
4116 {
4117 reader->input_type = WS_XML_READER_INPUT_TYPE_BUFFER;
4118 reader->input_buf = buf;
4119 reader->input_data = data;
4120 reader->input_size = size;
4121
4122 reader->read_size = reader->input_size;
4123 reader->read_pos = 0;
4124 reader->read_bufptr = reader->input_data;
4125 }
4126
4127 /**************************************************************************
4128 * WsSetInput [webservices.@]
4129 */
4130 HRESULT WINAPI WsSetInput( WS_XML_READER *handle, const WS_XML_READER_ENCODING *encoding,
4131 const WS_XML_READER_INPUT *input, const WS_XML_READER_PROPERTY *properties,
4132 ULONG count, WS_ERROR *error )
4133 {
4134 struct reader *reader = (struct reader *)handle;
4135 struct node *node;
4136 HRESULT hr;
4137 ULONG i, offset = 0;
4138
4139 TRACE( "%p %p %p %p %u %p\n", handle, encoding, input, properties, count, error );
4140 if (error) FIXME( "ignoring error parameter\n" );
4141
4142 if (!reader) return E_INVALIDARG;
4143
4144 for (i = 0; i < count; i++)
4145 {
4146 hr = prop_set( reader->prop, reader->prop_count, properties[i].id, properties[i].value,
4147 properties[i].valueSize );
4148 if (hr != S_OK) return hr;
4149 }
4150
4151 if ((hr = read_init_state( reader )) != S_OK) return hr;
4152
4153 switch (encoding->encodingType)
4154 {
4155 case WS_XML_READER_ENCODING_TYPE_TEXT:
4156 {
4157 WS_XML_READER_TEXT_ENCODING *text = (WS_XML_READER_TEXT_ENCODING *)encoding;
4158 WS_XML_READER_BUFFER_INPUT *buf = (WS_XML_READER_BUFFER_INPUT *)input;
4159 WS_CHARSET charset = text->charSet;
4160
4161 if (input->inputType != WS_XML_READER_INPUT_TYPE_BUFFER)
4162 {
4163 FIXME( "charset detection on input type %u not supported\n", input->inputType );
4164 return E_NOTIMPL;
4165 }
4166
4167 if (charset == WS_CHARSET_AUTO)
4168 charset = detect_charset( buf->encodedData, buf->encodedDataSize, &offset );
4169
4170 hr = prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_CHARSET,
4171 &charset, sizeof(charset) );
4172 if (hr != S_OK) return hr;
4173 break;
4174 }
4175 default:
4176 FIXME( "encoding type %u not supported\n", encoding->encodingType );
4177 return E_NOTIMPL;
4178 }
4179 switch (input->inputType)
4180 {
4181 case WS_XML_READER_INPUT_TYPE_BUFFER:
4182 {
4183 WS_XML_READER_BUFFER_INPUT *buf = (WS_XML_READER_BUFFER_INPUT *)input;
4184 set_input_buffer( reader, NULL, (const unsigned char *)buf->encodedData + offset,
4185 buf->encodedDataSize - offset );
4186 break;
4187 }
4188 default:
4189 FIXME( "input type %u not supported\n", input->inputType );
4190 return E_NOTIMPL;
4191 }
4192
4193 if (!(node = alloc_node( WS_XML_NODE_TYPE_BOF ))) return E_OUTOFMEMORY;
4194 read_insert_bof( reader, node );
4195 return S_OK;
4196 }
4197
4198 /**************************************************************************
4199 * WsSetInputToBuffer [webservices.@]
4200 */
4201 HRESULT WINAPI WsSetInputToBuffer( WS_XML_READER *handle, WS_XML_BUFFER *buffer,
4202 const WS_XML_READER_PROPERTY *properties, ULONG count,
4203 WS_ERROR *error )
4204 {
4205 struct reader *reader = (struct reader *)handle;
4206 struct xmlbuf *xmlbuf = (struct xmlbuf *)buffer;
4207 WS_CHARSET charset;
4208 struct node *node;
4209 HRESULT hr;
4210 ULONG i, offset = 0;
4211
4212 TRACE( "%p %p %p %u %p\n", handle, buffer, properties, count, error );
4213 if (error) FIXME( "ignoring error parameter\n" );
4214
4215 if (!reader || !xmlbuf) return E_INVALIDARG;
4216
4217 for (i = 0; i < count; i++)
4218 {
4219 hr = prop_set( reader->prop, reader->prop_count, properties[i].id, properties[i].value,
4220 properties[i].valueSize );
4221 if (hr != S_OK) return hr;
4222 }
4223
4224 if ((hr = read_init_state( reader )) != S_OK) return hr;
4225
4226 charset = detect_charset( xmlbuf->ptr, xmlbuf->size, &offset );
4227 hr = prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_CHARSET,
4228 &charset, sizeof(charset) );
4229 if (hr != S_OK) return hr;
4230
4231 set_input_buffer( reader, xmlbuf, (const unsigned char *)xmlbuf->ptr + offset, xmlbuf->size - offset );
4232 if (!(node = alloc_node( WS_XML_NODE_TYPE_BOF ))) return E_OUTOFMEMORY;
4233 read_insert_bof( reader, node );
4234 return S_OK;
4235 }
4236
4237 /**************************************************************************
4238 * WsXmlStringEquals [webservices.@]
4239 */
4240 HRESULT WINAPI WsXmlStringEquals( const WS_XML_STRING *str1, const WS_XML_STRING *str2, WS_ERROR *error )
4241 {
4242 TRACE( "%s %s %p\n", debugstr_xmlstr(str1), debugstr_xmlstr(str2), error );
4243 if (error) FIXME( "ignoring error parameter\n" );
4244
4245 if (!str1 || !str2) return E_INVALIDARG;
4246
4247 if (str1->length != str2->length) return S_FALSE;
4248 if (!memcmp( str1->bytes, str2->bytes, str1->length )) return S_OK;
4249 return S_FALSE;
4250 }
4251
4252 /**************************************************************************
4253 * WsGetReaderPosition [webservices.@]
4254 */
4255 HRESULT WINAPI WsGetReaderPosition( WS_XML_READER *handle, WS_XML_NODE_POSITION *pos, WS_ERROR *error )
4256 {
4257 struct reader *reader = (struct reader *)handle;
4258
4259 TRACE( "%p %p %p\n", handle, pos, error );
4260 if (error) FIXME( "ignoring error parameter\n" );
4261
4262 if (!reader || !pos) return E_INVALIDARG;
4263 if (!reader->input_buf) return WS_E_INVALID_OPERATION;
4264
4265 pos->buffer = (WS_XML_BUFFER *)reader->input_buf;
4266 pos->node = reader->current;
4267 return S_OK;
4268 }
4269
4270 /**************************************************************************
4271 * WsSetReaderPosition [webservices.@]
4272 */
4273 HRESULT WINAPI WsSetReaderPosition( WS_XML_READER *handle, const WS_XML_NODE_POSITION *pos, WS_ERROR *error )
4274 {
4275 struct reader *reader = (struct reader *)handle;
4276
4277 TRACE( "%p %p %p\n", handle, pos, error );
4278 if (error) FIXME( "ignoring error parameter\n" );
4279
4280 if (!reader || !pos || (struct xmlbuf *)pos->buffer != reader->input_buf) return E_INVALIDARG;
4281 if (!reader->input_buf) return WS_E_INVALID_OPERATION;
4282
4283 reader->current = pos->node;
4284 return S_OK;
4285 }
Windows API implementation