?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
webservices: Add support for reading attributes in binary mode.
[wine.git] / dlls / webservices / reader.c
bloba5e3efc5bd30af5c32024ae9854a8ef560970638
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 struct node *alloc_node( WS_XML_NODE_TYPE type )
74 {
75 struct node *ret;
76
77 if (!(ret = heap_alloc_zero( sizeof(*ret) ))) return NULL;
78 ret->hdr.node.nodeType = type;
79 list_init( &ret->entry );
80 list_init( &ret->children );
81 return ret;
82 }
83
84 void free_attribute( WS_XML_ATTRIBUTE *attr )
85 {
86 if (!attr) return;
87 heap_free( attr->prefix );
88 heap_free( attr->localName );
89 heap_free( attr->ns );
90 heap_free( attr->value );
91 heap_free( attr );
92 }
93
94 void free_node( struct node *node )
95 {
96 if (!node) return;
97 switch (node_type( node ))
98 {
99 case WS_XML_NODE_TYPE_ELEMENT:
100 {
101 WS_XML_ELEMENT_NODE *elem = &node->hdr;
102 ULONG i;
103
104 for (i = 0; i < elem->attributeCount; i++) free_attribute( elem->attributes[i] );
105 heap_free( elem->attributes );
106 heap_free( elem->prefix );
107 heap_free( elem->localName );
108 heap_free( elem->ns );
109 break;
110 }
111 case WS_XML_NODE_TYPE_TEXT:
112 {
113 WS_XML_TEXT_NODE *text = (WS_XML_TEXT_NODE *)node;
114 heap_free( text->text );
115 break;
116 }
117 case WS_XML_NODE_TYPE_COMMENT:
118 {
119 WS_XML_COMMENT_NODE *comment = (WS_XML_COMMENT_NODE *)node;
120 heap_free( comment->value.bytes );
121 break;
122 }
123 case WS_XML_NODE_TYPE_CDATA:
124 case WS_XML_NODE_TYPE_END_CDATA:
125 case WS_XML_NODE_TYPE_END_ELEMENT:
126 case WS_XML_NODE_TYPE_EOF:
127 case WS_XML_NODE_TYPE_BOF:
128 break;
129
130 default:
131 ERR( "unhandled type %u\n", node_type( node ) );
132 break;
133 }
134 heap_free( node );
135 }
136
137 void destroy_nodes( struct node *node )
138 {
139 struct list *ptr;
140
141 if (!node) return;
142 while ((ptr = list_head( &node->children )))
143 {
144 struct node *child = LIST_ENTRY( ptr, struct node, entry );
145 list_remove( &child->entry );
146 destroy_nodes( child );
147 }
148 free_node( node );
149 }
150
151 static WS_XML_ATTRIBUTE *dup_attribute( const WS_XML_ATTRIBUTE *src )
152 {
153 WS_XML_ATTRIBUTE *dst;
154 const WS_XML_STRING *prefix = src->prefix;
155 const WS_XML_STRING *localname = src->localName;
156 const WS_XML_STRING *ns = src->localName;
157 const WS_XML_TEXT *text = src->value;
158
159 if (!(dst = heap_alloc( sizeof(*dst) ))) return NULL;
160 dst->singleQuote = src->singleQuote;
161 dst->isXmlNs = src->isXmlNs;
162
163 if (!prefix) dst->prefix = NULL;
164 else if (!(dst->prefix = alloc_xml_string( prefix->bytes, prefix->length ))) goto error;
165 if (!(dst->localName = alloc_xml_string( localname->bytes, localname->length ))) goto error;
166 if (!(dst->ns = alloc_xml_string( ns->bytes, ns->length ))) goto error;
167
168 if (text)
169 {
170 WS_XML_UTF8_TEXT *utf8;
171 const WS_XML_UTF8_TEXT *utf8_src = (const WS_XML_UTF8_TEXT *)text;
172 if (!(utf8 = alloc_utf8_text( utf8_src->value.bytes, utf8_src->value.length ))) goto error;
173 dst->value = &utf8->text;
174 }
175
176 return dst;
177
178 error:
179 free_attribute( dst );
180 return NULL;
181 }
182
183 static WS_XML_ATTRIBUTE **dup_attributes( WS_XML_ATTRIBUTE * const *src, ULONG count )
184 {
185 WS_XML_ATTRIBUTE **dst;
186 ULONG i;
187
188 if (!(dst = heap_alloc( sizeof(*dst) * count ))) return NULL;
189 for (i = 0; i < count; i++)
190 {
191 if (!(dst[i] = dup_attribute( src[i] )))
192 {
193 for (; i > 0; i--) free_attribute( dst[i - 1] );
194 heap_free( dst );
195 return NULL;
196 }
197 }
198 return dst;
199 }
200
201 static struct node *dup_element_node( const WS_XML_ELEMENT_NODE *src )
202 {
203 struct node *node;
204 WS_XML_ELEMENT_NODE *dst;
205 ULONG count = src->attributeCount;
206 WS_XML_ATTRIBUTE **attrs = src->attributes;
207 const WS_XML_STRING *prefix = (src->prefix && src->prefix->length) ? src->prefix : NULL;
208 const WS_XML_STRING *localname = src->localName;
209 const WS_XML_STRING *ns = src->ns;
210
211 if (!(node = alloc_node( WS_XML_NODE_TYPE_ELEMENT ))) return NULL;
212 dst = &node->hdr;
213
214 if (count && !(dst->attributes = dup_attributes( attrs, count ))) goto error;
215 dst->attributeCount = count;
216
217 if (prefix && !(dst->prefix = alloc_xml_string( prefix->bytes, prefix->length ))) goto error;
218 if (localname && !(dst->localName = alloc_xml_string( localname->bytes, localname->length ))) goto error;
219 if (ns && !(dst->ns = alloc_xml_string( ns->bytes, ns->length ))) goto error;
220 return node;
221
222 error:
223 free_node( node );
224 return NULL;
225 }
226
227 static struct node *dup_text_node( const WS_XML_TEXT_NODE *src )
228 {
229 struct node *node;
230 WS_XML_TEXT_NODE *dst;
231
232 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return NULL;
233 dst = (WS_XML_TEXT_NODE *)node;
234
235 if (src->text)
236 {
237 WS_XML_UTF8_TEXT *utf8;
238 const WS_XML_UTF8_TEXT *utf8_src = (const WS_XML_UTF8_TEXT *)src->text;
239 if (!(utf8 = alloc_utf8_text( utf8_src->value.bytes, utf8_src->value.length )))
240 {
241 free_node( node );
242 return NULL;
243 }
244 dst->text = &utf8->text;
245 }
246 return node;
247 }
248
249 static struct node *dup_comment_node( const WS_XML_COMMENT_NODE *src )
250 {
251 struct node *node;
252 WS_XML_COMMENT_NODE *dst;
253
254 if (!(node = alloc_node( WS_XML_NODE_TYPE_COMMENT ))) return NULL;
255 dst = (WS_XML_COMMENT_NODE *)node;
256
257 if (src->value.length && !(dst->value.bytes = heap_alloc( src->value.length )))
258 {
259 free_node( node );
260 return NULL;
261 }
262 memcpy( dst->value.bytes, src->value.bytes, src->value.length );
263 dst->value.length = src->value.length;
264 return node;
265 }
266
267 static struct node *dup_node( const struct node *src )
268 {
269 switch (node_type( src ))
270 {
271 case WS_XML_NODE_TYPE_ELEMENT:
272 return dup_element_node( &src->hdr );
273
274 case WS_XML_NODE_TYPE_TEXT:
275 return dup_text_node( (const WS_XML_TEXT_NODE *)src );
276
277 case WS_XML_NODE_TYPE_COMMENT:
278 return dup_comment_node( (const WS_XML_COMMENT_NODE *)src );
279
280 case WS_XML_NODE_TYPE_CDATA:
281 case WS_XML_NODE_TYPE_END_CDATA:
282 case WS_XML_NODE_TYPE_END_ELEMENT:
283 case WS_XML_NODE_TYPE_EOF:
284 case WS_XML_NODE_TYPE_BOF:
285 return alloc_node( node_type( src ) );
286
287 default:
288 ERR( "unhandled type %u\n", node_type( src ) );
289 break;
290 }
291 return NULL;
292 }
293
294 static HRESULT dup_tree( struct node **dst, const struct node *src )
295 {
296 struct node *parent;
297 const struct node *child;
298
299 if (!*dst && !(*dst = dup_node( src ))) return E_OUTOFMEMORY;
300 parent = *dst;
301
302 LIST_FOR_EACH_ENTRY( child, &src->children, struct node, entry )
303 {
304 HRESULT hr = E_OUTOFMEMORY;
305 struct node *new_child;
306
307 if (!(new_child = dup_node( child )) || (hr = dup_tree( &new_child, child )) != S_OK)
308 {
309 destroy_nodes( *dst );
310 return hr;
311 }
312 new_child->parent = parent;
313 list_add_tail( &parent->children, &new_child->entry );
314 }
315 return S_OK;
316 }
317
318 static const struct prop_desc reader_props[] =
319 {
320 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_DEPTH */
321 { sizeof(BOOL), FALSE }, /* WS_XML_READER_PROPERTY_ALLOW_FRAGMENT */
322 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_ATTRIBUTES */
323 { sizeof(BOOL), FALSE }, /* WS_XML_READER_PROPERTY_READ_DECLARATION */
324 { sizeof(WS_CHARSET), FALSE }, /* WS_XML_READER_PROPERTY_CHARSET */
325 { sizeof(ULONGLONG), TRUE }, /* WS_XML_READER_PROPERTY_ROW */
326 { sizeof(ULONGLONG), TRUE }, /* WS_XML_READER_PROPERTY_COLUMN */
327 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_UTF8_TRIM_SIZE */
328 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_STREAM_BUFFER_SIZE */
329 { sizeof(BOOL), TRUE }, /* WS_XML_READER_PROPERTY_IN_ATTRIBUTE */
330 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_STREAM_MAX_ROOT_MIME_PART_SIZE */
331 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_STREAM_MAX_MIME_HEADERS_SIZE */
332 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_MIME_PARTS */
333 { sizeof(BOOL), FALSE }, /* WS_XML_READER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES */
334 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_NAMESPACES */
335 };
336
337 enum reader_state
338 {
339 READER_STATE_INITIAL,
340 READER_STATE_BOF,
341 READER_STATE_STARTELEMENT,
342 READER_STATE_STARTATTRIBUTE,
343 READER_STATE_STARTCDATA,
344 READER_STATE_CDATA,
345 READER_STATE_TEXT,
346 READER_STATE_ENDELEMENT,
347 READER_STATE_ENDCDATA,
348 READER_STATE_COMMENT,
349 READER_STATE_EOF
350 };
351
352 struct prefix
353 {
354 WS_XML_STRING str;
355 WS_XML_STRING ns;
356 };
357
358 struct reader
359 {
360 ULONG magic;
361 CRITICAL_SECTION cs;
362 ULONG read_size;
363 ULONG read_pos;
364 const unsigned char *read_bufptr;
365 enum reader_state state;
366 struct node *root;
367 struct node *current;
368 ULONG current_attr;
369 struct node *last;
370 struct prefix *prefixes;
371 ULONG nb_prefixes;
372 ULONG nb_prefixes_allocated;
373 WS_XML_READER_ENCODING_TYPE input_enc;
374 WS_XML_READER_INPUT_TYPE input_type;
375 struct xmlbuf *input_buf;
376 const unsigned char *input_data;
377 ULONG input_size;
378 ULONG text_conv_offset;
379 ULONG prop_count;
380 struct prop prop[sizeof(reader_props)/sizeof(reader_props[0])];
381 };
382
383 #define READER_MAGIC (('R' << 24) | ('E' << 16) | ('A' << 8) | 'D')
384
385 static struct reader *alloc_reader(void)
386 {
387 static const ULONG count = sizeof(reader_props)/sizeof(reader_props[0]);
388 struct reader *ret;
389 ULONG size = sizeof(*ret) + prop_size( reader_props, count );
390
391 if (!(ret = heap_alloc_zero( size ))) return NULL;
392 if (!(ret->prefixes = heap_alloc_zero( sizeof(*ret->prefixes) )))
393 {
394 heap_free( ret );
395 return NULL;
396 }
397 ret->nb_prefixes = ret->nb_prefixes_allocated = 1;
398
399 ret->magic = READER_MAGIC;
400 InitializeCriticalSection( &ret->cs );
401 ret->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": reader.cs");
402
403 prop_init( reader_props, count, ret->prop, &ret[1] );
404 ret->prop_count = count;
405 return ret;
406 }
407
408 static void clear_prefixes( struct prefix *prefixes, ULONG count )
409 {
410 ULONG i;
411 for (i = 0; i < count; i++)
412 {
413 heap_free( prefixes[i].str.bytes );
414 prefixes[i].str.bytes = NULL;
415 prefixes[i].str.length = 0;
416
417 heap_free( prefixes[i].ns.bytes );
418 prefixes[i].ns.bytes = NULL;
419 prefixes[i].ns.length = 0;
420 }
421 }
422
423 static HRESULT set_prefix( struct prefix *prefix, const WS_XML_STRING *str, const WS_XML_STRING *ns )
424 {
425 if (str)
426 {
427 heap_free( prefix->str.bytes );
428 if (!(prefix->str.bytes = heap_alloc( str->length ))) return E_OUTOFMEMORY;
429 memcpy( prefix->str.bytes, str->bytes, str->length );
430 prefix->str.length = str->length;
431 }
432
433 heap_free( prefix->ns.bytes );
434 if (!(prefix->ns.bytes = heap_alloc( ns->length ))) return E_OUTOFMEMORY;
435 memcpy( prefix->ns.bytes, ns->bytes, ns->length );
436 prefix->ns.length = ns->length;
437
438 return S_OK;
439 }
440
441 static HRESULT bind_prefix( struct reader *reader, const WS_XML_STRING *prefix, const WS_XML_STRING *ns )
442 {
443 ULONG i;
444 HRESULT hr;
445
446 for (i = 0; i < reader->nb_prefixes; i++)
447 {
448 if (WsXmlStringEquals( prefix, &reader->prefixes[i].str, NULL ) == S_OK)
449 return set_prefix( &reader->prefixes[i], NULL, ns );
450 }
451 if (i >= reader->nb_prefixes_allocated)
452 {
453 ULONG new_size = reader->nb_prefixes_allocated * sizeof(*reader->prefixes) * 2;
454 struct prefix *tmp = heap_realloc_zero( reader->prefixes, new_size );
455 if (!tmp) return E_OUTOFMEMORY;
456 reader->prefixes = tmp;
457 reader->nb_prefixes_allocated *= 2;
458 }
459
460 if ((hr = set_prefix( &reader->prefixes[i], prefix, ns )) != S_OK) return hr;
461 reader->nb_prefixes++;
462 return S_OK;
463 }
464
465 static const WS_XML_STRING *get_namespace( struct reader *reader, const WS_XML_STRING *prefix )
466 {
467 ULONG i;
468 for (i = 0; i < reader->nb_prefixes; i++)
469 {
470 if (WsXmlStringEquals( prefix, &reader->prefixes[i].str, NULL ) == S_OK)
471 return &reader->prefixes[i].ns;
472 }
473 return NULL;
474 }
475
476 static void read_insert_eof( struct reader *reader, struct node *eof )
477 {
478 if (!reader->root) reader->root = eof;
479 else
480 {
481 eof->parent = reader->root;
482 list_add_tail( &reader->root->children, &eof->entry );
483 }
484 reader->current = reader->last = eof;
485 }
486
487 static void read_insert_bof( struct reader *reader, struct node *bof )
488 {
489 reader->root->parent = bof;
490 list_add_tail( &bof->children, &reader->root->entry );
491 reader->current = reader->last = reader->root = bof;
492 }
493
494 static void read_insert_node( struct reader *reader, struct node *parent, struct node *node )
495 {
496 node->parent = parent;
497 list_add_before( list_tail( &parent->children ), &node->entry );
498 reader->current = reader->last = node;
499 }
500
501 static void free_reader( struct reader *reader )
502 {
503 destroy_nodes( reader->root );
504 clear_prefixes( reader->prefixes, reader->nb_prefixes );
505 heap_free( reader->prefixes );
506 reader->cs.DebugInfo->Spare[0] = 0;
507 DeleteCriticalSection( &reader->cs );
508 heap_free( reader );
509 }
510
511 static HRESULT init_reader( struct reader *reader )
512 {
513 struct node *node;
514
515 reader->state = READER_STATE_INITIAL;
516 destroy_nodes( reader->root );
517 reader->root = reader->current = NULL;
518 reader->current_attr = 0;
519 clear_prefixes( reader->prefixes, reader->nb_prefixes );
520 reader->nb_prefixes = 1;
521 if (!(node = alloc_node( WS_XML_NODE_TYPE_EOF ))) return E_OUTOFMEMORY;
522 read_insert_eof( reader, node );
523 reader->input_enc = WS_XML_READER_ENCODING_TYPE_TEXT;
524 return S_OK;
525 }
526
527 /**************************************************************************
528 * WsCreateReader [webservices.@]
529 */
530 HRESULT WINAPI WsCreateReader( const WS_XML_READER_PROPERTY *properties, ULONG count,
531 WS_XML_READER **handle, WS_ERROR *error )
532 {
533 struct reader *reader;
534 ULONG i, max_depth = 32, max_attrs = 128, max_ns = 32;
535 WS_CHARSET charset = WS_CHARSET_UTF8;
536 BOOL read_decl = TRUE;
537 HRESULT hr;
538
539 TRACE( "%p %u %p %p\n", properties, count, handle, error );
540 if (error) FIXME( "ignoring error parameter\n" );
541
542 if (!handle) return E_INVALIDARG;
543 if (!(reader = alloc_reader())) return E_OUTOFMEMORY;
544
545 prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_MAX_DEPTH, &max_depth, sizeof(max_depth) );
546 prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_MAX_ATTRIBUTES, &max_attrs, sizeof(max_attrs) );
547 prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_READ_DECLARATION, &read_decl, sizeof(read_decl) );
548 prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_CHARSET, &charset, sizeof(charset) );
549 prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_MAX_NAMESPACES, &max_ns, sizeof(max_ns) );
550
551 for (i = 0; i < count; i++)
552 {
553 hr = prop_set( reader->prop, reader->prop_count, properties[i].id, properties[i].value,
554 properties[i].valueSize );
555 if (hr != S_OK)
556 {
557 free_reader( reader );
558 return hr;
559 }
560 }
561
562 if ((hr = init_reader( reader )) != S_OK)
563 {
564 free_reader( reader );
565 return hr;
566 }
567
568 *handle = (WS_XML_READER *)reader;
569 return S_OK;
570 }
571
572 /**************************************************************************
573 * WsFreeReader [webservices.@]
574 */
575 void WINAPI WsFreeReader( WS_XML_READER *handle )
576 {
577 struct reader *reader = (struct reader *)handle;
578
579 TRACE( "%p\n", handle );
580
581 if (!reader) return;
582
583 EnterCriticalSection( &reader->cs );
584
585 if (reader->magic != READER_MAGIC)
586 {
587 LeaveCriticalSection( &reader->cs );
588 return;
589 }
590
591 reader->magic = 0;
592
593 LeaveCriticalSection( &reader->cs );
594 free_reader( reader );
595 }
596
597 /**************************************************************************
598 * WsFillReader [webservices.@]
599 */
600 HRESULT WINAPI WsFillReader( WS_XML_READER *handle, ULONG min_size, const WS_ASYNC_CONTEXT *ctx,
601 WS_ERROR *error )
602 {
603 struct reader *reader = (struct reader *)handle;
604
605 TRACE( "%p %u %p %p\n", handle, min_size, ctx, error );
606 if (error) FIXME( "ignoring error parameter\n" );
607
608 if (!reader) return E_INVALIDARG;
609
610 EnterCriticalSection( &reader->cs );
611
612 if (reader->magic != READER_MAGIC)
613 {
614 LeaveCriticalSection( &reader->cs );
615 return E_INVALIDARG;
616 }
617
618 /* FIXME: add support for stream input */
619 reader->read_size = min( min_size, reader->input_size );
620 reader->read_pos = 0;
621
622 LeaveCriticalSection( &reader->cs );
623 return S_OK;
624 }
625
626 /**************************************************************************
627 * WsGetNamespaceFromPrefix [webservices.@]
628 */
629 HRESULT WINAPI WsGetNamespaceFromPrefix( WS_XML_READER *handle, const WS_XML_STRING *prefix,
630 BOOL required, const WS_XML_STRING **ns, WS_ERROR *error )
631 {
632 static const WS_XML_STRING xml = {3, (BYTE *)"xml"};
633 static const WS_XML_STRING xmlns = {5, (BYTE *)"xmlns"};
634 static const WS_XML_STRING empty_ns = {0, NULL};
635 static const WS_XML_STRING xml_ns = {36, (BYTE *)"http://www.w3.org/XML/1998/namespace"};
636 static const WS_XML_STRING xmlns_ns = {29, (BYTE *)"http://www.w3.org/2000/xmlns/"};
637 struct reader *reader = (struct reader *)handle;
638 BOOL found = FALSE;
639
640 TRACE( "%p %s %d %p %p\n", handle, debugstr_xmlstr(prefix), required, ns, error );
641 if (error) FIXME( "ignoring error parameter\n" );
642
643 if (!reader || !prefix || !ns) return E_INVALIDARG;
644
645 EnterCriticalSection( &reader->cs );
646
647 if (reader->magic != READER_MAGIC)
648 {
649 LeaveCriticalSection( &reader->cs );
650 return E_INVALIDARG;
651 }
652
653 if (reader->state != READER_STATE_STARTELEMENT)
654 {
655 LeaveCriticalSection( &reader->cs );
656 return WS_E_INVALID_OPERATION;
657 }
658
659 if (!prefix->length)
660 {
661 *ns = &empty_ns;
662 found = TRUE;
663 }
664 else if (WsXmlStringEquals( prefix, &xml, NULL ) == S_OK)
665 {
666 *ns = &xml_ns;
667 found = TRUE;
668 }
669 else if (WsXmlStringEquals( prefix, &xmlns, NULL ) == S_OK)
670 {
671 *ns = &xmlns_ns;
672 found = TRUE;
673 }
674 else
675 {
676 WS_XML_ELEMENT_NODE *elem = &reader->current->hdr;
677 ULONG i;
678
679 for (i = 0; i < elem->attributeCount; i++)
680 {
681 if (!elem->attributes[i]->isXmlNs) continue;
682 if (WsXmlStringEquals( prefix, elem->attributes[i]->prefix, NULL ) == S_OK)
683 {
684 *ns = elem->attributes[i]->ns;
685 found = TRUE;
686 break;
687 }
688 }
689 }
690
691 LeaveCriticalSection( &reader->cs );
692
693 if (!found)
694 {
695 if (required) return WS_E_INVALID_FORMAT;
696 *ns = NULL;
697 return S_FALSE;
698 }
699
700 return S_OK;
701 }
702
703 /**************************************************************************
704 * WsGetReaderNode [webservices.@]
705 */
706 HRESULT WINAPI WsGetReaderNode( WS_XML_READER *handle, const WS_XML_NODE **node,
707 WS_ERROR *error )
708 {
709 struct reader *reader = (struct reader *)handle;
710
711 TRACE( "%p %p %p\n", handle, node, error );
712 if (error) FIXME( "ignoring error parameter\n" );
713
714 if (!reader || !node) return E_INVALIDARG;
715
716 EnterCriticalSection( &reader->cs );
717
718 if (reader->magic != READER_MAGIC)
719 {
720 LeaveCriticalSection( &reader->cs );
721 return E_INVALIDARG;
722 }
723
724 *node = &reader->current->hdr.node;
725
726 LeaveCriticalSection( &reader->cs );
727 return S_OK;
728 }
729
730 /**************************************************************************
731 * WsGetReaderProperty [webservices.@]
732 */
733 HRESULT WINAPI WsGetReaderProperty( WS_XML_READER *handle, WS_XML_READER_PROPERTY_ID id,
734 void *buf, ULONG size, WS_ERROR *error )
735 {
736 struct reader *reader = (struct reader *)handle;
737 HRESULT hr;
738
739 TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
740 if (error) FIXME( "ignoring error parameter\n" );
741
742 if (!reader) return E_INVALIDARG;
743
744 EnterCriticalSection( &reader->cs );
745
746 if (reader->magic != READER_MAGIC)
747 {
748 LeaveCriticalSection( &reader->cs );
749 return E_INVALIDARG;
750 }
751
752 if (!reader->input_type)
753 {
754 LeaveCriticalSection( &reader->cs );
755 return WS_E_INVALID_OPERATION;
756 }
757
758 if (id == WS_XML_READER_PROPERTY_CHARSET)
759 {
760 WS_CHARSET charset;
761 if ((hr = prop_get( reader->prop, reader->prop_count, id, &charset, size )) != S_OK) goto done;
762 if (!charset)
763 {
764 hr = WS_E_INVALID_FORMAT;
765 goto done;
766 }
767 *(WS_CHARSET *)buf = charset;
768 hr = S_OK;
769 }
770 else hr = prop_get( reader->prop, reader->prop_count, id, buf, size );
771
772 done:
773 LeaveCriticalSection( &reader->cs );
774 return hr;
775 }
776
777 /**************************************************************************
778 * WsGetXmlAttribute [webservices.@]
779 */
780 HRESULT WINAPI WsGetXmlAttribute( WS_XML_READER *handle, const WS_XML_STRING *attr,
781 WS_HEAP *heap, WCHAR **str, ULONG *len, WS_ERROR *error )
782 {
783 FIXME( "%p %s %p %p %p %p: stub\n", handle, debugstr_xmlstr(attr), heap, str, len, error );
784 return E_NOTIMPL;
785 }
786
787 WS_XML_STRING *alloc_xml_string( const unsigned char *data, ULONG len )
788 {
789 WS_XML_STRING *ret;
790
791 if (!(ret = heap_alloc( sizeof(*ret) + len ))) return NULL;
792 ret->length = len;
793 ret->bytes = len ? (BYTE *)(ret + 1) : NULL;
794 ret->dictionary = NULL;
795 ret->id = 0;
796 if (data) memcpy( ret->bytes, data, len );
797 return ret;
798 }
799
800 WS_XML_UTF8_TEXT *alloc_utf8_text( const unsigned char *data, ULONG len )
801 {
802 WS_XML_UTF8_TEXT *ret;
803
804 if (!(ret = heap_alloc( sizeof(*ret) + len ))) return NULL;
805 ret->text.textType = WS_XML_TEXT_TYPE_UTF8;
806 ret->value.length = len;
807 ret->value.bytes = len ? (BYTE *)(ret + 1) : NULL;
808 ret->value.dictionary = NULL;
809 ret->value.id = 0;
810 if (data) memcpy( ret->value.bytes, data, len );
811 return ret;
812 }
813
814 static inline BOOL read_end_of_data( struct reader *reader )
815 {
816 return reader->read_pos >= reader->read_size;
817 }
818
819 static inline const unsigned char *read_current_ptr( struct reader *reader )
820 {
821 return &reader->read_bufptr[reader->read_pos];
822 }
823
824 static inline HRESULT read_peek( struct reader *reader, unsigned char *byte )
825 {
826 if (reader->read_pos >= reader->read_size) return WS_E_INVALID_FORMAT;
827 *byte = reader->read_bufptr[reader->read_pos];
828 return S_OK;
829 }
830
831 static inline HRESULT read_byte( struct reader *reader, unsigned char *byte )
832 {
833 if (reader->read_pos >= reader->read_size) return WS_E_INVALID_FORMAT;
834 *byte = reader->read_bufptr[reader->read_pos++];
835 return S_OK;
836 }
837
838 static inline HRESULT read_bytes( struct reader *reader, unsigned char *bytes, unsigned int len )
839 {
840 if (reader->read_pos + len > reader->read_size) return WS_E_INVALID_FORMAT;
841 memcpy( bytes, reader->read_bufptr + reader->read_pos, len );
842 reader->read_pos += len;
843 return S_OK;
844 }
845
846 /* UTF-8 support based on libs/wine/utf8.c */
847
848 /* number of following bytes in sequence based on first byte value (for bytes above 0x7f) */
849 static const char utf8_length[128] =
850 {
851 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x80-0x8f */
852 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x90-0x9f */
853 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xa0-0xaf */
854 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xb0-0xbf */
855 0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 0xc0-0xcf */
856 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 0xd0-0xdf */
857 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, /* 0xe0-0xef */
858 3,3,3,3,3,0,0,0,0,0,0,0,0,0,0,0 /* 0xf0-0xff */
859 };
860
861 /* first byte mask depending on UTF-8 sequence length */
862 static const unsigned char utf8_mask[4] = { 0x7f, 0x1f, 0x0f, 0x07 };
863
864 /* minimum Unicode value depending on UTF-8 sequence length */
865 static const unsigned int utf8_minval[4] = { 0x0, 0x80, 0x800, 0x10000 };
866
867 static inline unsigned int read_utf8_char( struct reader *reader, unsigned int *skip )
868 {
869 unsigned int len, res;
870 unsigned char ch = reader->read_bufptr[reader->read_pos];
871 const unsigned char *end;
872
873 if (reader->read_pos >= reader->read_size) return 0;
874
875 if (ch < 0x80)
876 {
877 *skip = 1;
878 return ch;
879 }
880 len = utf8_length[ch - 0x80];
881 if (reader->read_pos + len >= reader->read_size) return 0;
882 end = reader->read_bufptr + reader->read_pos + len + 1;
883 res = ch & utf8_mask[len];
884
885 switch (len)
886 {
887 case 3:
888 if ((ch = end[-3] ^ 0x80) >= 0x40) break;
889 res = (res << 6) | ch;
890 case 2:
891 if ((ch = end[-2] ^ 0x80) >= 0x40) break;
892 res = (res << 6) | ch;
893 case 1:
894 if ((ch = end[-1] ^ 0x80) >= 0x40) break;
895 res = (res << 6) | ch;
896 if (res < utf8_minval[len]) break;
897 *skip = len + 1;
898 return res;
899 }
900
901 return 0;
902 }
903
904 static inline void read_skip( struct reader *reader, unsigned int count )
905 {
906 if (reader->read_pos + count > reader->read_size) return;
907 reader->read_pos += count;
908 }
909
910 static inline void read_rewind( struct reader *reader, unsigned int count )
911 {
912 reader->read_pos -= count;
913 }
914
915 static inline BOOL read_isnamechar( unsigned int ch )
916 {
917 /* FIXME: incomplete */
918 return (ch >= 'A' && ch <= 'Z') ||
919 (ch >= 'a' && ch <= 'z') ||
920 (ch >= '0' && ch <= '9') ||
921 ch == '_' || ch == '-' || ch == '.' || ch == ':';
922 }
923
924 static inline BOOL read_isspace( unsigned int ch )
925 {
926 return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n';
927 }
928
929 static inline void read_skip_whitespace( struct reader *reader )
930 {
931 while (reader->read_pos < reader->read_size && read_isspace( reader->read_bufptr[reader->read_pos] ))
932 reader->read_pos++;
933 }
934
935 static inline int read_cmp( struct reader *reader, const char *str, int len )
936 {
937 const unsigned char *ptr = read_current_ptr( reader );
938
939 if (len < 0) len = strlen( str );
940 if (reader->read_pos + len > reader->read_size) return -1;
941 while (len--)
942 {
943 if (*str != *ptr) return *ptr - *str;
944 str++; ptr++;
945 }
946 return 0;
947 }
948
949 static HRESULT read_xmldecl( struct reader *reader )
950 {
951 if (!reader->read_size) return WS_E_INVALID_FORMAT;
952
953 if (read_cmp( reader, "<", 1 ) || read_cmp( reader, "<?", 2 ))
954 {
955 reader->state = READER_STATE_BOF;
956 return S_OK;
957 }
958 if (read_cmp( reader, "<?xml ", 6 )) return WS_E_INVALID_FORMAT;
959 read_skip( reader, 6 );
960
961 /* FIXME: parse attributes */
962 while (reader->read_pos < reader->read_size && reader->read_bufptr[reader->read_pos] != '?')
963 reader->read_pos++;
964
965 if (read_cmp( reader, "?>", 2 )) return WS_E_INVALID_FORMAT;
966 read_skip( reader, 2 );
967
968 reader->state = READER_STATE_BOF;
969 return S_OK;
970 }
971
972 HRESULT append_attribute( WS_XML_ELEMENT_NODE *elem, WS_XML_ATTRIBUTE *attr )
973 {
974 if (elem->attributeCount)
975 {
976 WS_XML_ATTRIBUTE **tmp;
977 if (!(tmp = heap_realloc( elem->attributes, (elem->attributeCount + 1) * sizeof(attr) )))
978 return E_OUTOFMEMORY;
979 elem->attributes = tmp;
980 }
981 else if (!(elem->attributes = heap_alloc( sizeof(attr) ))) return E_OUTOFMEMORY;
982 elem->attributes[elem->attributeCount++] = attr;
983 return S_OK;
984 }
985
986 static HRESULT split_name( const unsigned char *str, ULONG len, const unsigned char **prefix,
987 ULONG *prefix_len, const unsigned char **localname, ULONG *localname_len )
988 {
989 const unsigned char *ptr = str;
990
991 *prefix = NULL;
992 *prefix_len = 0;
993
994 *localname = str;
995 *localname_len = len;
996
997 while (len--)
998 {
999 if (*ptr == ':')
1000 {
1001 if (ptr == str) return WS_E_INVALID_FORMAT;
1002 *prefix = str;
1003 *prefix_len = ptr - str;
1004 *localname = ptr + 1;
1005 *localname_len = len;
1006 break;
1007 }
1008 ptr++;
1009 }
1010 return S_OK;
1011 }
1012
1013 static HRESULT parse_name( const unsigned char *str, ULONG len, WS_XML_STRING **prefix, WS_XML_STRING **localname )
1014 {
1015 const unsigned char *localname_ptr, *prefix_ptr;
1016 ULONG localname_len, prefix_len;
1017 HRESULT hr;
1018
1019 if ((hr = split_name( str, len, &prefix_ptr, &prefix_len, &localname_ptr, &localname_len )) != S_OK) return hr;
1020 if (!(*prefix = alloc_xml_string( prefix_ptr, prefix_len ))) return E_OUTOFMEMORY;
1021 if (!(*localname = alloc_xml_string( localname_ptr, localname_len )))
1022 {
1023 heap_free( *prefix );
1024 *prefix = NULL;
1025 return E_OUTOFMEMORY;
1026 }
1027 return S_OK;
1028 }
1029
1030 static int codepoint_to_utf8( int cp, unsigned char *dst )
1031 {
1032 if (!cp) return -1;
1033 if (cp < 0x80)
1034 {
1035 *dst = cp;
1036 return 1;
1037 }
1038 if (cp < 0x800)
1039 {
1040 dst[1] = 0x80 | (cp & 0x3f);
1041 cp >>= 6;
1042 dst[0] = 0xc0 | cp;
1043 return 2;
1044 }
1045 if ((cp >= 0xd800 && cp <= 0xdfff) || cp == 0xfffe || cp == 0xffff) return -1;
1046 if (cp < 0x10000)
1047 {
1048 dst[2] = 0x80 | (cp & 0x3f);
1049 cp >>= 6;
1050 dst[1] = 0x80 | (cp & 0x3f);
1051 cp >>= 6;
1052 dst[0] = 0xe0 | cp;
1053 return 3;
1054 }
1055 if (cp >= 0x110000) return -1;
1056 dst[3] = 0x80 | (cp & 0x3f);
1057 cp >>= 6;
1058 dst[2] = 0x80 | (cp & 0x3f);
1059 cp >>= 6;
1060 dst[1] = 0x80 | (cp & 0x3f);
1061 cp >>= 6;
1062 dst[0] = 0xf0 | cp;
1063 return 4;
1064 }
1065
1066 static HRESULT decode_text( const unsigned char *str, ULONG len, unsigned char *ret, ULONG *ret_len )
1067 {
1068 const unsigned char *p = str;
1069 unsigned char *q = ret;
1070
1071 *ret_len = 0;
1072 while (len)
1073 {
1074 if (*p == '&')
1075 {
1076 p++; len--;
1077 if (!len) return WS_E_INVALID_FORMAT;
1078
1079 if (len >= 3 && !memcmp( p, "lt;", 3 ))
1080 {
1081 *q++ = '<';
1082 p += 3;
1083 len -= 3;
1084 }
1085 else if (len >= 3 && !memcmp( p, "gt;", 3 ))
1086 {
1087 *q++ = '>';
1088 p += 3;
1089 len -= 3;
1090 }
1091 else if (len >= 5 && !memcmp( p, "quot;", 5 ))
1092 {
1093 *q++ = '"';
1094 p += 5;
1095 len -= 5;
1096 }
1097 else if (len >= 4 && !memcmp( p, "amp;", 4 ))
1098 {
1099 *q++ = '&';
1100 p += 4;
1101 len -= 4;
1102 }
1103 else if (len >= 5 && !memcmp( p, "apos;", 5 ))
1104 {
1105 *q++ = '\'';
1106 p += 5;
1107 len -= 5;
1108 }
1109 else if (*p == '#')
1110 {
1111 ULONG start, nb_digits, i;
1112 int len_utf8, cp = 0;
1113
1114 p++; len--;
1115 if (!len) return WS_E_INVALID_FORMAT;
1116 if (*p == 'x')
1117 {
1118 p++; len--;
1119
1120 start = len;
1121 while (len && isxdigit( *p )) { p++; len--; };
1122 if (!len) return WS_E_INVALID_FORMAT;
1123
1124 p -= nb_digits = start - len;
1125 if (!nb_digits || nb_digits > 6 || p[nb_digits] != ';') return WS_E_INVALID_FORMAT;
1126 for (i = 0; i < nb_digits; i++)
1127 {
1128 cp *= 16;
1129 if (*p >= '0' && *p <= '9') cp += *p - '0';
1130 else if (*p >= 'a' && *p <= 'f') cp += *p - 'a' + 10;
1131 else cp += *p - 'A' + 10;
1132 p++;
1133 }
1134 }
1135 else if (isdigit( *p ))
1136 {
1137 while (len && *p == '0') { p++; len--; };
1138 if (!len) return WS_E_INVALID_FORMAT;
1139
1140 start = len;
1141 while (len && isdigit( *p )) { p++; len--; };
1142 if (!len) return WS_E_INVALID_FORMAT;
1143
1144 p -= nb_digits = start - len;
1145 if (!nb_digits || nb_digits > 7 || p[nb_digits] != ';') return WS_E_INVALID_FORMAT;
1146 for (i = 0; i < nb_digits; i++)
1147 {
1148 cp *= 10;
1149 cp += *p - '0';
1150 p++;
1151 }
1152 }
1153 else return WS_E_INVALID_FORMAT;
1154 p++; len--;
1155 if ((len_utf8 = codepoint_to_utf8( cp, q )) < 0) return WS_E_INVALID_FORMAT;
1156 *ret_len += len_utf8;
1157 q += len_utf8;
1158 continue;
1159 }
1160 else return WS_E_INVALID_FORMAT;
1161 }
1162 else
1163 {
1164 *q++ = *p++;
1165 len--;
1166 }
1167 *ret_len += 1;
1168 }
1169 return S_OK;
1170 }
1171
1172 static HRESULT read_attribute_value_text( struct reader *reader, WS_XML_ATTRIBUTE *attr )
1173 {
1174 WS_XML_UTF8_TEXT *utf8 = NULL;
1175 unsigned int len, ch, skip, quote;
1176 const unsigned char *start;
1177 HRESULT hr = E_OUTOFMEMORY;
1178
1179 read_skip_whitespace( reader );
1180 if (read_cmp( reader, "=", 1 )) return WS_E_INVALID_FORMAT;
1181 read_skip( reader, 1 );
1182
1183 read_skip_whitespace( reader );
1184 if (read_cmp( reader, "\"", 1 ) && read_cmp( reader, "'", 1 )) return WS_E_INVALID_FORMAT;
1185 quote = read_utf8_char( reader, &skip );
1186 read_skip( reader, 1 );
1187
1188 len = 0;
1189 start = read_current_ptr( reader );
1190 for (;;)
1191 {
1192 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
1193 if (ch == quote) break;
1194 read_skip( reader, skip );
1195 len += skip;
1196 }
1197 read_skip( reader, 1 );
1198
1199 if (attr->isXmlNs)
1200 {
1201 if (!(attr->ns = alloc_xml_string( start, len ))) goto error;
1202 if ((hr = bind_prefix( reader, attr->prefix, attr->ns )) != S_OK) goto error;
1203 if (!(utf8 = alloc_utf8_text( NULL, 0 )))
1204 {
1205 hr = E_OUTOFMEMORY;
1206 goto error;
1207 }
1208 }
1209 else
1210 {
1211 if (!(utf8 = alloc_utf8_text( NULL, len ))) goto error;
1212 if ((hr = decode_text( start, len, utf8->value.bytes, &utf8->value.length )) != S_OK) goto error;
1213 }
1214
1215 attr->value = &utf8->text;
1216 attr->singleQuote = (quote == '\'');
1217 return S_OK;
1218
1219 error:
1220 heap_free( utf8 );
1221 return hr;
1222 }
1223
1224 static inline BOOL is_text_type( unsigned char type )
1225 {
1226 return (type >= RECORD_ZERO_TEXT && type <= RECORD_QNAME_DICTIONARY_TEXT_WITH_ENDELEMENT);
1227 }
1228
1229 static HRESULT read_int31( struct reader *reader, ULONG *len )
1230 {
1231 unsigned char byte;
1232 HRESULT hr;
1233
1234 if ((hr = read_byte( reader, &byte )) != S_OK) return hr;
1235 *len = byte & 0x7f;
1236 if (!(byte & 0x80)) return S_OK;
1237
1238 if ((hr = read_byte( reader, &byte )) != S_OK) return hr;
1239 *len += (byte & 0x7f) << 7;
1240 if (!(byte & 0x80)) return S_OK;
1241
1242 if ((hr = read_byte( reader, &byte )) != S_OK) return hr;
1243 *len += (byte & 0x7f) << 14;
1244 if (!(byte & 0x80)) return S_OK;
1245
1246 if ((hr = read_byte( reader, &byte )) != S_OK) return hr;
1247 *len += (byte & 0x7f) << 21;
1248 if (!(byte & 0x80)) return S_OK;
1249
1250 if ((hr = read_byte( reader, &byte )) != S_OK) return hr;
1251 *len += (byte & 0x07) << 28;
1252 return S_OK;
1253 }
1254
1255 static HRESULT read_string( struct reader *reader, WS_XML_STRING **str )
1256 {
1257 ULONG len;
1258 HRESULT hr;
1259 if ((hr = read_int31( reader, &len )) != S_OK) return hr;
1260 if (!(*str = alloc_xml_string( NULL, len ))) return E_OUTOFMEMORY;
1261 if ((hr = read_bytes( reader, (*str)->bytes, len )) == S_OK) return S_OK;
1262 heap_free( *str );
1263 return hr;
1264 }
1265
1266 static HRESULT read_attribute_value_bin( struct reader *reader, WS_XML_ATTRIBUTE *attr )
1267 {
1268 WS_XML_UTF8_TEXT *utf8 = NULL;
1269 unsigned char type;
1270 HRESULT hr;
1271 ULONG len;
1272
1273 if ((hr = read_byte( reader, &type )) != S_OK) return hr;
1274 if (!is_text_type( type )) return WS_E_INVALID_FORMAT;
1275
1276 switch (type)
1277 {
1278 case RECORD_CHARS8_TEXT:
1279 {
1280 unsigned char len8;
1281 if ((hr = read_byte( reader, &len8 )) != S_OK) return hr;
1282 len = len8;
1283 break;
1284 }
1285 default:
1286 ERR( "unhandled record type %02x\n", type );
1287 return WS_E_NOT_SUPPORTED;
1288 }
1289
1290 if (!(utf8 = alloc_utf8_text( NULL, len ))) return E_OUTOFMEMORY;
1291 if (!len) utf8->value.bytes = (BYTE *)(utf8 + 1); /* quirk */
1292 if ((hr = read_bytes( reader, utf8->value.bytes, len )) != S_OK)
1293 {
1294 heap_free( utf8 );
1295 return hr;
1296 }
1297
1298 attr->value = &utf8->text;
1299 return S_OK;
1300 }
1301
1302 static HRESULT read_attribute_text( struct reader *reader, WS_XML_ATTRIBUTE **ret )
1303 {
1304 static const WS_XML_STRING xmlns = {5, (BYTE *)"xmlns"};
1305 WS_XML_ATTRIBUTE *attr;
1306 unsigned int len = 0, ch, skip;
1307 const unsigned char *start;
1308 WS_XML_STRING *prefix, *localname;
1309 HRESULT hr = WS_E_INVALID_FORMAT;
1310
1311 if (!(attr = heap_alloc_zero( sizeof(*attr) ))) return E_OUTOFMEMORY;
1312
1313 start = read_current_ptr( reader );
1314 for (;;)
1315 {
1316 if (!(ch = read_utf8_char( reader, &skip ))) goto error;
1317 if (!read_isnamechar( ch )) break;
1318 read_skip( reader, skip );
1319 len += skip;
1320 }
1321 if (!len) goto error;
1322
1323 if ((hr = parse_name( start, len, &prefix, &localname )) != S_OK) goto error;
1324 if (WsXmlStringEquals( prefix, &xmlns, NULL ) == S_OK)
1325 {
1326 heap_free( prefix );
1327 attr->isXmlNs = 1;
1328 if (!(attr->prefix = alloc_xml_string( localname->bytes, localname->length )))
1329 {
1330 heap_free( localname );
1331 hr = E_OUTOFMEMORY;
1332 goto error;
1333 }
1334 attr->localName = localname;
1335 }
1336 else if (!prefix->length && WsXmlStringEquals( localname, &xmlns, NULL ) == S_OK)
1337 {
1338 attr->isXmlNs = 1;
1339 attr->prefix = prefix;
1340 attr->localName = localname;
1341 }
1342 else
1343 {
1344 attr->prefix = prefix;
1345 attr->localName = localname;
1346 }
1347
1348 if ((hr = read_attribute_value_text( reader, attr )) != S_OK) goto error;
1349
1350 *ret = attr;
1351 return S_OK;
1352
1353 error:
1354 free_attribute( attr );
1355 return hr;
1356 }
1357
1358 static inline BOOL is_attribute_type( unsigned char type )
1359 {
1360 return (type >= RECORD_SHORT_ATTRIBUTE && type <= RECORD_PREFIX_ATTRIBUTE_Z);
1361 }
1362
1363 static HRESULT read_attribute_bin( struct reader *reader, WS_XML_ATTRIBUTE **ret )
1364 {
1365 WS_XML_ATTRIBUTE *attr;
1366 unsigned char type = 0;
1367 HRESULT hr;
1368
1369 if ((hr = read_byte( reader, &type )) != S_OK) return hr;
1370 if (!is_attribute_type( type )) return WS_E_INVALID_FORMAT;
1371 if (!(attr = heap_alloc_zero( sizeof(*attr) ))) return E_OUTOFMEMORY;
1372
1373 if (type >= RECORD_PREFIX_ATTRIBUTE_A && type <= RECORD_PREFIX_ATTRIBUTE_Z)
1374 {
1375 unsigned char ch = type - RECORD_PREFIX_ATTRIBUTE_A + 'a';
1376 if (!(attr->prefix = alloc_xml_string( &ch, 1 )))
1377 {
1378 hr = E_OUTOFMEMORY;
1379 goto error;
1380 }
1381 if ((hr = read_string( reader, &attr->localName )) != S_OK) goto error;
1382 if ((hr = read_attribute_value_bin( reader, attr )) != S_OK) goto error;
1383 }
1384 else
1385 {
1386 switch (type)
1387 {
1388 case RECORD_SHORT_ATTRIBUTE:
1389 if (!(attr->prefix = alloc_xml_string( NULL, 0 )))
1390 {
1391 hr = E_OUTOFMEMORY;
1392 goto error;
1393 }
1394 if ((hr = read_string( reader, &attr->localName )) != S_OK) goto error;
1395 if ((hr = read_attribute_value_bin( reader, attr )) != S_OK) goto error;
1396 break;
1397
1398 case RECORD_ATTRIBUTE:
1399 if ((hr = read_string( reader, &attr->prefix )) != S_OK) goto error;
1400 if ((hr = read_string( reader, &attr->localName )) != S_OK) goto error;
1401 if ((hr = read_attribute_value_bin( reader, attr )) != S_OK) goto error;
1402 break;
1403
1404 case RECORD_SHORT_XMLNS_ATTRIBUTE:
1405 if (!(attr->prefix = alloc_xml_string( NULL, 0 )))
1406 {
1407 hr = E_OUTOFMEMORY;
1408 goto error;
1409 }
1410 if ((hr = read_string( reader, &attr->ns )) != S_OK) goto error;
1411 attr->isXmlNs = 1;
1412 break;
1413
1414 case RECORD_XMLNS_ATTRIBUTE:
1415 if ((hr = read_string( reader, &attr->prefix )) != S_OK) goto error;
1416 if ((hr = read_string( reader, &attr->ns )) != S_OK) goto error;
1417 if ((hr = bind_prefix( reader, attr->prefix, attr->ns )) != S_OK) goto error;
1418 attr->isXmlNs = 1;
1419 break;
1420
1421 default:
1422 ERR( "unhandled record type %02x\n", type );
1423 return WS_E_NOT_SUPPORTED;
1424 }
1425 }
1426
1427 *ret = attr;
1428 return S_OK;
1429
1430 error:
1431 free_attribute( attr );
1432 return hr;
1433 }
1434
1435 static inline struct node *find_parent( struct reader *reader )
1436 {
1437 if (node_type( reader->current ) == WS_XML_NODE_TYPE_END_ELEMENT)
1438 {
1439 if (is_valid_parent( reader->current->parent->parent )) return reader->current->parent->parent;
1440 return NULL;
1441 }
1442 if (is_valid_parent( reader->current )) return reader->current;
1443 if (is_valid_parent( reader->current->parent )) return reader->current->parent;
1444 return NULL;
1445 }
1446
1447 static HRESULT set_namespaces( struct reader *reader, WS_XML_ELEMENT_NODE *elem )
1448 {
1449 static const WS_XML_STRING xml = {3, (BYTE *)"xml"};
1450 const WS_XML_STRING *ns;
1451 ULONG i;
1452
1453 if (!(ns = get_namespace( reader, elem->prefix ))) return WS_E_INVALID_FORMAT;
1454 if (!(elem->ns = alloc_xml_string( ns->bytes, ns->length ))) return E_OUTOFMEMORY;
1455 if (!elem->ns->length) elem->ns->bytes = (BYTE *)(elem->ns + 1); /* quirk */
1456
1457 for (i = 0; i < elem->attributeCount; i++)
1458 {
1459 WS_XML_ATTRIBUTE *attr = elem->attributes[i];
1460 if (attr->isXmlNs || WsXmlStringEquals( attr->prefix, &xml, NULL ) == S_OK) continue;
1461 if (!(ns = get_namespace( reader, attr->prefix ))) return WS_E_INVALID_FORMAT;
1462 if (!(attr->ns = alloc_xml_string( ns->bytes, ns->length ))) return E_OUTOFMEMORY;
1463 }
1464 return S_OK;
1465 }
1466
1467 static WS_XML_ELEMENT_NODE *alloc_element_pair(void)
1468 {
1469 struct node *node, *end;
1470 if (!(node = alloc_node( WS_XML_NODE_TYPE_ELEMENT ))) return NULL;
1471 if (!(end = alloc_node( WS_XML_NODE_TYPE_END_ELEMENT )))
1472 {
1473 free_node( node );
1474 return NULL;
1475 }
1476 list_add_tail( &node->children, &end->entry );
1477 end->parent = node;
1478 return &node->hdr;
1479 }
1480
1481 static HRESULT read_attributes_text( struct reader *reader, WS_XML_ELEMENT_NODE *elem )
1482 {
1483 WS_XML_ATTRIBUTE *attr;
1484 HRESULT hr;
1485
1486 reader->current_attr = 0;
1487 for (;;)
1488 {
1489 read_skip_whitespace( reader );
1490 if (!read_cmp( reader, ">", 1 ) || !read_cmp( reader, "/>", 2 )) break;
1491 if ((hr = read_attribute_text( reader, &attr )) != S_OK) return hr;
1492 if ((hr = append_attribute( elem, attr )) != S_OK)
1493 {
1494 free_attribute( attr );
1495 return hr;
1496 }
1497 reader->current_attr++;
1498 }
1499 return S_OK;
1500 }
1501
1502 static HRESULT read_element_text( struct reader *reader )
1503 {
1504 unsigned int len = 0, ch, skip;
1505 const unsigned char *start;
1506 struct node *node = NULL, *parent;
1507 WS_XML_ELEMENT_NODE *elem;
1508 HRESULT hr = WS_E_INVALID_FORMAT;
1509
1510 if (read_end_of_data( reader ))
1511 {
1512 reader->current = LIST_ENTRY( list_tail( &reader->root->children ), struct node, entry );
1513 reader->last = reader->current;
1514 reader->state = READER_STATE_EOF;
1515 return S_OK;
1516 }
1517
1518 if (read_cmp( reader, "<", 1 )) return WS_E_INVALID_FORMAT;
1519 read_skip( reader, 1 );
1520 if (!read_isnamechar( read_utf8_char( reader, &skip )))
1521 {
1522 read_rewind( reader, 1 );
1523 return WS_E_INVALID_FORMAT;
1524 }
1525
1526 if (!(elem = alloc_element_pair())) return E_OUTOFMEMORY;
1527 node = (struct node *)elem;
1528
1529 start = read_current_ptr( reader );
1530 for (;;)
1531 {
1532 if (!(ch = read_utf8_char( reader, &skip ))) goto error;
1533 if (!read_isnamechar( ch )) break;
1534 read_skip( reader, skip );
1535 len += skip;
1536 }
1537 if (!len) goto error;
1538
1539 if (!(parent = find_parent( reader ))) goto error;
1540 if ((hr = parse_name( start, len, &elem->prefix, &elem->localName )) != S_OK) goto error;
1541
1542 if ((hr = read_attributes_text( reader, elem )) != S_OK) goto error;
1543 if ((hr = set_namespaces( reader, elem )) != S_OK) goto error;
1544
1545 read_insert_node( reader, parent, node );
1546 reader->state = READER_STATE_STARTELEMENT;
1547 return S_OK;
1548
1549 error:
1550 destroy_nodes( node );
1551 return hr;
1552 }
1553
1554 static inline BOOL is_element_type( unsigned char type )
1555 {
1556 return (type >= RECORD_SHORT_ELEMENT && type <= RECORD_PREFIX_ELEMENT_Z);
1557 }
1558
1559 static HRESULT read_attributes_bin( struct reader *reader, WS_XML_ELEMENT_NODE *elem )
1560 {
1561 WS_XML_ATTRIBUTE *attr;
1562 unsigned char type;
1563 HRESULT hr;
1564
1565 reader->current_attr = 0;
1566 for (;;)
1567 {
1568 if ((hr = read_peek( reader, &type )) != S_OK) return hr;
1569 if (!is_attribute_type( type )) break;
1570 if ((hr = read_attribute_bin( reader, &attr )) != S_OK) return hr;
1571 if ((hr = append_attribute( elem, attr )) != S_OK)
1572 {
1573 free_attribute( attr );
1574 return hr;
1575 }
1576 reader->current_attr++;
1577 }
1578 return S_OK;
1579 }
1580
1581 static HRESULT read_element_bin( struct reader *reader )
1582 {
1583 struct node *node = NULL, *parent;
1584 WS_XML_ELEMENT_NODE *elem;
1585 unsigned char type;
1586 HRESULT hr;
1587
1588 if ((hr = read_byte( reader, &type )) != S_OK) return hr;
1589 if (!is_element_type( type )) return WS_E_INVALID_FORMAT;
1590
1591 if (!(elem = alloc_element_pair())) return E_OUTOFMEMORY;
1592 node = (struct node *)elem;
1593
1594 if (type >= RECORD_PREFIX_ELEMENT_A && type <= RECORD_PREFIX_ELEMENT_Z)
1595 {
1596 unsigned char ch = type - RECORD_PREFIX_ELEMENT_A + 'a';
1597 if (!(elem->prefix = alloc_xml_string( &ch, 1 )))
1598 {
1599 hr = E_OUTOFMEMORY;
1600 goto error;
1601 }
1602 if ((hr = read_string( reader, &elem->localName )) != S_OK) goto error;
1603 }
1604 else
1605 {
1606 switch (type)
1607 {
1608 case RECORD_SHORT_ELEMENT:
1609 if (!(elem->prefix = alloc_xml_string( NULL, 0 )))
1610 {
1611 hr = E_OUTOFMEMORY;
1612 goto error;
1613 }
1614 if ((hr = read_string( reader, &elem->localName )) != S_OK) goto error;
1615 break;
1616
1617 case RECORD_ELEMENT:
1618 if ((hr = read_string( reader, &elem->prefix )) != S_OK) goto error;
1619 if ((hr = read_string( reader, &elem->localName )) != S_OK) goto error;
1620 break;
1621
1622 default:
1623 ERR( "unhandled record type %02x\n", type );
1624 return WS_E_NOT_SUPPORTED;
1625 }
1626 }
1627
1628 if (!(parent = find_parent( reader )))
1629 {
1630 hr = WS_E_INVALID_FORMAT;
1631 goto error;
1632 }
1633
1634 if ((hr = read_attributes_bin( reader, elem )) != S_OK) goto error;
1635 if ((hr = set_namespaces( reader, elem )) != S_OK) goto error;
1636
1637 read_insert_node( reader, parent, node );
1638 reader->state = READER_STATE_STARTELEMENT;
1639 return S_OK;
1640
1641 error:
1642 destroy_nodes( node );
1643 return hr;
1644 }
1645
1646 static HRESULT read_text( struct reader *reader )
1647 {
1648 unsigned int len = 0, ch, skip;
1649 const unsigned char *start;
1650 struct node *node, *parent;
1651 WS_XML_TEXT_NODE *text;
1652 WS_XML_UTF8_TEXT *utf8;
1653 HRESULT hr;
1654
1655 start = read_current_ptr( reader );
1656 for (;;)
1657 {
1658 if (read_end_of_data( reader )) break;
1659 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
1660 if (ch == '<') break;
1661 read_skip( reader, skip );
1662 len += skip;
1663 }
1664
1665 if (!(parent = find_parent( reader ))) return WS_E_INVALID_FORMAT;
1666
1667 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return E_OUTOFMEMORY;
1668 text = (WS_XML_TEXT_NODE *)node;
1669 if (!(utf8 = alloc_utf8_text( NULL, len )))
1670 {
1671 heap_free( node );
1672 return E_OUTOFMEMORY;
1673 }
1674 if ((hr = decode_text( start, len, utf8->value.bytes, &utf8->value.length )) != S_OK)
1675 {
1676 heap_free( utf8 );
1677 heap_free( node );
1678 return hr;
1679 }
1680 text->text = &utf8->text;
1681
1682 read_insert_node( reader, parent, node );
1683 reader->state = READER_STATE_TEXT;
1684 reader->text_conv_offset = 0;
1685 return S_OK;
1686 }
1687
1688 static HRESULT read_node_text( struct reader * );
1689
1690 static HRESULT read_startelement( struct reader *reader )
1691 {
1692 read_skip_whitespace( reader );
1693 if (!read_cmp( reader, "/>", 2 ))
1694 {
1695 read_skip( reader, 2 );
1696 reader->current = LIST_ENTRY( list_tail( &reader->current->children ), struct node, entry );
1697 reader->last = reader->current;
1698 reader->state = READER_STATE_ENDELEMENT;
1699 return S_OK;
1700 }
1701 else if (!read_cmp( reader, ">", 1 ))
1702 {
1703 read_skip( reader, 1 );
1704 return read_node_text( reader );
1705 }
1706 return WS_E_INVALID_FORMAT;
1707 }
1708
1709 static HRESULT read_to_startelement( struct reader *reader, BOOL *found )
1710 {
1711 HRESULT hr;
1712
1713 switch (reader->state)
1714 {
1715 case READER_STATE_INITIAL:
1716 if ((hr = read_xmldecl( reader )) != S_OK) return hr;
1717 break;
1718
1719 case READER_STATE_STARTELEMENT:
1720 if (found) *found = TRUE;
1721 return S_OK;
1722
1723 default:
1724 break;
1725 }
1726
1727 read_skip_whitespace( reader );
1728 if ((hr = read_element_text( reader )) == S_OK && found)
1729 {
1730 if (reader->state == READER_STATE_STARTELEMENT)
1731 *found = TRUE;
1732 else
1733 *found = FALSE;
1734 }
1735
1736 return hr;
1737 }
1738
1739 static int cmp_name( const unsigned char *name1, ULONG len1, const unsigned char *name2, ULONG len2 )
1740 {
1741 ULONG i;
1742 if (len1 != len2) return 1;
1743 for (i = 0; i < len1; i++) { if (toupper( name1[i] ) != toupper( name2[i] )) return 1; }
1744 return 0;
1745 }
1746
1747 static struct node *find_startelement( struct reader *reader, const WS_XML_STRING *prefix,
1748 const WS_XML_STRING *localname )
1749 {
1750 struct node *parent;
1751 const WS_XML_STRING *str;
1752
1753 for (parent = reader->current; parent; parent = parent->parent)
1754 {
1755 if (node_type( parent ) == WS_XML_NODE_TYPE_ELEMENT)
1756 {
1757 str = parent->hdr.prefix;
1758 if (cmp_name( str->bytes, str->length, prefix->bytes, prefix->length )) continue;
1759 str = parent->hdr.localName;
1760 if (cmp_name( str->bytes, str->length, localname->bytes, localname->length )) continue;
1761 return parent;
1762 }
1763 }
1764 return NULL;
1765 }
1766
1767 static HRESULT read_endelement_text( struct reader *reader )
1768 {
1769 struct node *parent;
1770 unsigned int len = 0, ch, skip;
1771 const unsigned char *start;
1772 WS_XML_STRING *prefix, *localname;
1773 HRESULT hr;
1774
1775 if (read_cmp( reader, "</", 2 )) return WS_E_INVALID_FORMAT;
1776 read_skip( reader, 2 );
1777
1778 start = read_current_ptr( reader );
1779 for (;;)
1780 {
1781 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
1782 if (ch == '>')
1783 {
1784 read_skip( reader, 1 );
1785 break;
1786 }
1787 if (!read_isnamechar( ch )) return WS_E_INVALID_FORMAT;
1788 read_skip( reader, skip );
1789 len += skip;
1790 }
1791
1792 if ((hr = parse_name( start, len, &prefix, &localname )) != S_OK) return hr;
1793 parent = find_startelement( reader, prefix, localname );
1794 heap_free( prefix );
1795 heap_free( localname );
1796 if (!parent) return WS_E_INVALID_FORMAT;
1797
1798 reader->current = LIST_ENTRY( list_tail( &parent->children ), struct node, entry );
1799 reader->last = reader->current;
1800 reader->state = READER_STATE_ENDELEMENT;
1801 return S_OK;
1802 }
1803
1804 static HRESULT read_endelement_bin( struct reader *reader )
1805 {
1806 struct node *parent;
1807 unsigned char type;
1808 HRESULT hr;
1809
1810 if ((hr = read_byte( reader, &type )) != S_OK) return hr;
1811 if (type != RECORD_ENDELEMENT) return WS_E_INVALID_FORMAT;
1812
1813 if (!(parent = find_parent( reader ))) return WS_E_INVALID_FORMAT;
1814
1815 reader->current = LIST_ENTRY( list_tail( &parent->children ), struct node, entry );
1816 reader->last = reader->current;
1817 reader->state = READER_STATE_ENDELEMENT;
1818 return S_OK;
1819 }
1820
1821 static HRESULT read_endelement( struct reader *reader )
1822 {
1823 if (reader->state == READER_STATE_EOF) return WS_E_INVALID_FORMAT;
1824
1825 if (read_end_of_data( reader ))
1826 {
1827 reader->current = LIST_ENTRY( list_tail( &reader->root->children ), struct node, entry );
1828 reader->last = reader->current;
1829 reader->state = READER_STATE_EOF;
1830 return S_OK;
1831 }
1832
1833 switch (reader->input_enc)
1834 {
1835 case WS_XML_READER_ENCODING_TYPE_TEXT: return read_endelement_text( reader );
1836 case WS_XML_READER_ENCODING_TYPE_BINARY: return read_endelement_bin( reader );
1837 default:
1838 ERR( "unhandled encoding %u\n", reader->input_enc );
1839 return WS_E_NOT_SUPPORTED;
1840 }
1841 }
1842
1843 static HRESULT read_comment( struct reader *reader )
1844 {
1845 unsigned int len = 0, ch, skip;
1846 const unsigned char *start;
1847 struct node *node, *parent;
1848 WS_XML_COMMENT_NODE *comment;
1849
1850 if (read_cmp( reader, "<!--", 4 )) return WS_E_INVALID_FORMAT;
1851 read_skip( reader, 4 );
1852
1853 start = read_current_ptr( reader );
1854 for (;;)
1855 {
1856 if (!read_cmp( reader, "-->", 3 ))
1857 {
1858 read_skip( reader, 3 );
1859 break;
1860 }
1861 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
1862 read_skip( reader, skip );
1863 len += skip;
1864 }
1865
1866 if (!(parent = find_parent( reader ))) return WS_E_INVALID_FORMAT;
1867
1868 if (!(node = alloc_node( WS_XML_NODE_TYPE_COMMENT ))) return E_OUTOFMEMORY;
1869 comment = (WS_XML_COMMENT_NODE *)node;
1870 if (!(comment->value.bytes = heap_alloc( len )))
1871 {
1872 heap_free( node );
1873 return E_OUTOFMEMORY;
1874 }
1875 memcpy( comment->value.bytes, start, len );
1876 comment->value.length = len;
1877
1878 read_insert_node( reader, parent, node );
1879 reader->state = READER_STATE_COMMENT;
1880 return S_OK;
1881 }
1882
1883 static HRESULT read_startcdata( struct reader *reader )
1884 {
1885 struct node *node, *endnode, *parent;
1886
1887 if (read_cmp( reader, "<![CDATA[", 9 )) return WS_E_INVALID_FORMAT;
1888 read_skip( reader, 9 );
1889
1890 if (!(parent = find_parent( reader ))) return WS_E_INVALID_FORMAT;
1891
1892 if (!(node = alloc_node( WS_XML_NODE_TYPE_CDATA ))) return E_OUTOFMEMORY;
1893 if (!(endnode = alloc_node( WS_XML_NODE_TYPE_END_CDATA )))
1894 {
1895 heap_free( node );
1896 return E_OUTOFMEMORY;
1897 }
1898 list_add_tail( &node->children, &endnode->entry );
1899 endnode->parent = node;
1900
1901 read_insert_node( reader, parent, node );
1902 reader->state = READER_STATE_STARTCDATA;
1903 return S_OK;
1904 }
1905
1906 static HRESULT read_cdata( struct reader *reader )
1907 {
1908 unsigned int len = 0, ch, skip;
1909 const unsigned char *start;
1910 struct node *node;
1911 WS_XML_TEXT_NODE *text;
1912 WS_XML_UTF8_TEXT *utf8;
1913
1914 start = read_current_ptr( reader );
1915 for (;;)
1916 {
1917 if (!read_cmp( reader, "]]>", 3 )) break;
1918 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
1919 read_skip( reader, skip );
1920 len += skip;
1921 }
1922
1923 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return E_OUTOFMEMORY;
1924 text = (WS_XML_TEXT_NODE *)node;
1925 if (!(utf8 = alloc_utf8_text( start, len )))
1926 {
1927 heap_free( node );
1928 return E_OUTOFMEMORY;
1929 }
1930 text->text = &utf8->text;
1931
1932 read_insert_node( reader, reader->current, node );
1933 reader->state = READER_STATE_CDATA;
1934 return S_OK;
1935 }
1936
1937 static HRESULT read_endcdata( struct reader *reader )
1938 {
1939 struct node *parent;
1940
1941 if (read_cmp( reader, "]]>", 3 )) return WS_E_INVALID_FORMAT;
1942 read_skip( reader, 3 );
1943
1944 if (node_type( reader->current ) == WS_XML_NODE_TYPE_TEXT) parent = reader->current->parent;
1945 else parent = reader->current;
1946
1947 reader->current = LIST_ENTRY( list_tail( &parent->children ), struct node, entry );
1948 reader->last = reader->current;
1949 reader->state = READER_STATE_ENDCDATA;
1950 return S_OK;
1951 }
1952
1953 static HRESULT read_node_text( struct reader *reader )
1954 {
1955 HRESULT hr;
1956
1957 for (;;)
1958 {
1959 if (read_end_of_data( reader ))
1960 {
1961 reader->current = LIST_ENTRY( list_tail( &reader->root->children ), struct node, entry );
1962 reader->last = reader->current;
1963 reader->state = READER_STATE_EOF;
1964 return S_OK;
1965 }
1966 if (reader->state == READER_STATE_STARTCDATA) return read_cdata( reader );
1967 else if (reader->state == READER_STATE_CDATA) return read_endcdata( reader );
1968 else if (!read_cmp( reader, "<?", 2 ))
1969 {
1970 hr = read_xmldecl( reader );
1971 if (FAILED( hr )) return hr;
1972 }
1973 else if (!read_cmp( reader, "</", 2 )) return read_endelement_text( reader );
1974 else if (!read_cmp( reader, "<![CDATA[", 9 )) return read_startcdata( reader );
1975 else if (!read_cmp( reader, "<!--", 4 )) return read_comment( reader );
1976 else if (!read_cmp( reader, "<", 1 )) return read_element_text( reader );
1977 else if (!read_cmp( reader, "/>", 2 ) || !read_cmp( reader, ">", 1 )) return read_startelement( reader );
1978 else return read_text( reader );
1979 }
1980 }
1981
1982 static HRESULT read_node_bin( struct reader *reader )
1983 {
1984 unsigned char type;
1985 HRESULT hr;
1986
1987 if (node_type( reader->current ) == WS_XML_NODE_TYPE_TEXT)
1988 {
1989 reader->current = LIST_ENTRY( list_tail( &reader->current->parent->children ), struct node, entry );
1990 reader->last = reader->current;
1991 reader->state = READER_STATE_ENDELEMENT;
1992 return S_OK;
1993 }
1994 if (read_end_of_data( reader ))
1995 {
1996 reader->current = LIST_ENTRY( list_tail( &reader->root->children ), struct node, entry );
1997 reader->last = reader->current;
1998 reader->state = READER_STATE_EOF;
1999 return S_OK;
2000 }
2001
2002 if ((hr = read_peek( reader, &type )) != S_OK) return hr;
2003 if (type == RECORD_ENDELEMENT)
2004 {
2005 return read_endelement_bin( reader );
2006 }
2007 else if (type >= RECORD_SHORT_ELEMENT && type <= RECORD_PREFIX_ELEMENT_Z)
2008 {
2009 return read_element_bin( reader );
2010 }
2011
2012 FIXME( "unhandled record type %02x\n", type );
2013 return WS_E_NOT_SUPPORTED;
2014 }
2015
2016 static HRESULT read_node( struct reader *reader )
2017 {
2018 switch (reader->input_enc)
2019 {
2020 case WS_XML_READER_ENCODING_TYPE_TEXT: return read_node_text( reader );
2021 case WS_XML_READER_ENCODING_TYPE_BINARY: return read_node_bin( reader );
2022 default:
2023 ERR( "unhandled encoding %u\n", reader->input_enc );
2024 return WS_E_NOT_SUPPORTED;
2025 }
2026 }
2027
2028 HRESULT copy_node( WS_XML_READER *handle, struct node **node )
2029 {
2030 struct reader *reader = (struct reader *)handle;
2031 const struct list *ptr;
2032 const struct node *start;
2033 HRESULT hr;
2034
2035 EnterCriticalSection( &reader->cs );
2036
2037 if (reader->magic != READER_MAGIC)
2038 {
2039 LeaveCriticalSection( &reader->cs );
2040 return E_INVALIDARG;
2041 }
2042
2043 if (reader->current != reader->root) ptr = &reader->current->entry;
2044 else /* copy whole tree */
2045 {
2046 if (!read_end_of_data( reader ))
2047 {
2048 for (;;)
2049 {
2050 if ((hr = read_node( reader )) != S_OK) goto done;
2051 if (node_type( reader->current ) == WS_XML_NODE_TYPE_EOF) break;
2052 }
2053 }
2054 ptr = list_head( &reader->root->children );
2055 }
2056
2057 start = LIST_ENTRY( ptr, struct node, entry );
2058 if (node_type( start ) == WS_XML_NODE_TYPE_EOF) hr = WS_E_INVALID_OPERATION;
2059 else hr = dup_tree( node, start );
2060
2061 done:
2062 LeaveCriticalSection( &reader->cs );
2063 return hr;
2064 }
2065
2066 /**************************************************************************
2067 * WsReadEndElement [webservices.@]
2068 */
2069 HRESULT WINAPI WsReadEndElement( WS_XML_READER *handle, WS_ERROR *error )
2070 {
2071 struct reader *reader = (struct reader *)handle;
2072 HRESULT hr;
2073
2074 TRACE( "%p %p\n", handle, error );
2075 if (error) FIXME( "ignoring error parameter\n" );
2076
2077 if (!reader) return E_INVALIDARG;
2078
2079 EnterCriticalSection( &reader->cs );
2080
2081 if (reader->magic != READER_MAGIC)
2082 {
2083 LeaveCriticalSection( &reader->cs );
2084 return E_INVALIDARG;
2085 }
2086
2087 hr = read_endelement( reader );
2088
2089 LeaveCriticalSection( &reader->cs );
2090 return hr;
2091 }
2092
2093 /**************************************************************************
2094 * WsReadNode [webservices.@]
2095 */
2096 HRESULT WINAPI WsReadNode( WS_XML_READER *handle, WS_ERROR *error )
2097 {
2098 struct reader *reader = (struct reader *)handle;
2099 HRESULT hr;
2100
2101 TRACE( "%p %p\n", handle, error );
2102 if (error) FIXME( "ignoring error parameter\n" );
2103
2104 if (!reader) return E_INVALIDARG;
2105
2106 EnterCriticalSection( &reader->cs );
2107
2108 if (reader->magic != READER_MAGIC)
2109 {
2110 LeaveCriticalSection( &reader->cs );
2111 return E_INVALIDARG;
2112 }
2113
2114 hr = read_node( reader );
2115
2116 LeaveCriticalSection( &reader->cs );
2117 return hr;
2118 }
2119
2120 static HRESULT skip_node( struct reader *reader )
2121 {
2122 const struct node *parent;
2123 HRESULT hr;
2124
2125 if (node_type( reader->current ) == WS_XML_NODE_TYPE_EOF) return WS_E_INVALID_OPERATION;
2126 if (node_type( reader->current ) == WS_XML_NODE_TYPE_ELEMENT) parent = reader->current;
2127 else parent = NULL;
2128
2129 for (;;)
2130 {
2131 if ((hr = read_node( reader ) != S_OK) || !parent) break;
2132 if (node_type( reader->current ) != WS_XML_NODE_TYPE_END_ELEMENT) continue;
2133 if (reader->current->parent == parent) return read_node( reader );
2134 }
2135
2136 return hr;
2137 }
2138
2139 /**************************************************************************
2140 * WsSkipNode [webservices.@]
2141 */
2142 HRESULT WINAPI WsSkipNode( WS_XML_READER *handle, WS_ERROR *error )
2143 {
2144 struct reader *reader = (struct reader *)handle;
2145 HRESULT hr;
2146
2147 TRACE( "%p %p\n", handle, error );
2148 if (error) FIXME( "ignoring error parameter\n" );
2149
2150 if (!reader) return E_INVALIDARG;
2151
2152 EnterCriticalSection( &reader->cs );
2153
2154 if (reader->magic != READER_MAGIC)
2155 {
2156 LeaveCriticalSection( &reader->cs );
2157 return E_INVALIDARG;
2158 }
2159
2160 hr = skip_node( reader );
2161
2162 LeaveCriticalSection( &reader->cs );
2163 return hr;
2164 }
2165
2166 /**************************************************************************
2167 * WsReadStartElement [webservices.@]
2168 */
2169 HRESULT WINAPI WsReadStartElement( WS_XML_READER *handle, WS_ERROR *error )
2170 {
2171 struct reader *reader = (struct reader *)handle;
2172 HRESULT hr;
2173
2174 TRACE( "%p %p\n", handle, error );
2175 if (error) FIXME( "ignoring error parameter\n" );
2176
2177 if (!reader) return E_INVALIDARG;
2178
2179 EnterCriticalSection( &reader->cs );
2180
2181 if (reader->magic != READER_MAGIC)
2182 {
2183 LeaveCriticalSection( &reader->cs );
2184 return E_INVALIDARG;
2185 }
2186
2187 hr = read_startelement( reader );
2188
2189 LeaveCriticalSection( &reader->cs );
2190 return hr;
2191 }
2192
2193 /**************************************************************************
2194 * WsReadToStartElement [webservices.@]
2195 */
2196 HRESULT WINAPI WsReadToStartElement( WS_XML_READER *handle, const WS_XML_STRING *localname,
2197 const WS_XML_STRING *ns, BOOL *found, WS_ERROR *error )
2198 {
2199 struct reader *reader = (struct reader *)handle;
2200 HRESULT hr;
2201
2202 TRACE( "%p %s %s %p %p\n", handle, debugstr_xmlstr(localname), debugstr_xmlstr(ns), found, error );
2203 if (error) FIXME( "ignoring error parameter\n" );
2204
2205 if (!reader) return E_INVALIDARG;
2206 if (localname || ns) FIXME( "name and/or namespace not verified\n" );
2207
2208 EnterCriticalSection( &reader->cs );
2209
2210 if (reader->magic != READER_MAGIC)
2211 {
2212 LeaveCriticalSection( &reader->cs );
2213 return E_INVALIDARG;
2214 }
2215
2216 hr = read_to_startelement( reader, found );
2217
2218 LeaveCriticalSection( &reader->cs );
2219 return hr;
2220 }
2221
2222 BOOL move_to_root_element( struct node *root, struct node **current )
2223 {
2224 struct list *ptr;
2225 struct node *node;
2226
2227 if (!(ptr = list_head( &root->children ))) return FALSE;
2228 node = LIST_ENTRY( ptr, struct node, entry );
2229 if (node_type( node ) == WS_XML_NODE_TYPE_ELEMENT)
2230 {
2231 *current = node;
2232 return TRUE;
2233 }
2234 while ((ptr = list_next( &root->children, &node->entry )))
2235 {
2236 struct node *next = LIST_ENTRY( ptr, struct node, entry );
2237 if (node_type( next ) == WS_XML_NODE_TYPE_ELEMENT)
2238 {
2239 *current = next;
2240 return TRUE;
2241 }
2242 node = next;
2243 }
2244 return FALSE;
2245 }
2246
2247 BOOL move_to_next_element( struct node **current )
2248 {
2249 struct list *ptr;
2250 struct node *node = *current, *parent = (*current)->parent;
2251
2252 if (!parent) return FALSE;
2253 while ((ptr = list_next( &parent->children, &node->entry )))
2254 {
2255 struct node *next = LIST_ENTRY( ptr, struct node, entry );
2256 if (node_type( next ) == WS_XML_NODE_TYPE_ELEMENT)
2257 {
2258 *current = next;
2259 return TRUE;
2260 }
2261 node = next;
2262 }
2263 return FALSE;
2264 }
2265
2266 BOOL move_to_prev_element( struct node **current )
2267 {
2268 struct list *ptr;
2269 struct node *node = *current, *parent = (*current)->parent;
2270
2271 if (!parent) return FALSE;
2272 while ((ptr = list_prev( &parent->children, &node->entry )))
2273 {
2274 struct node *prev = LIST_ENTRY( ptr, struct node, entry );
2275 if (node_type( prev ) == WS_XML_NODE_TYPE_ELEMENT)
2276 {
2277 *current = prev;
2278 return TRUE;
2279 }
2280 node = prev;
2281 }
2282 return FALSE;
2283 }
2284
2285 BOOL move_to_child_element( struct node **current )
2286 {
2287 struct list *ptr;
2288 struct node *child, *node = *current;
2289
2290 if (!(ptr = list_head( &node->children ))) return FALSE;
2291 child = LIST_ENTRY( ptr, struct node, entry );
2292 if (node_type( child ) == WS_XML_NODE_TYPE_ELEMENT)
2293 {
2294 *current = child;
2295 return TRUE;
2296 }
2297 while ((ptr = list_next( &node->children, &child->entry )))
2298 {
2299 struct node *next = LIST_ENTRY( ptr, struct node, entry );
2300 if (node_type( next ) == WS_XML_NODE_TYPE_ELEMENT)
2301 {
2302 *current = next;
2303 return TRUE;
2304 }
2305 child = next;
2306 }
2307 return FALSE;
2308 }
2309
2310 BOOL move_to_end_element( struct node **current )
2311 {
2312 struct list *ptr;
2313 struct node *node = *current;
2314
2315 if (node_type( node ) != WS_XML_NODE_TYPE_ELEMENT) return FALSE;
2316
2317 if ((ptr = list_tail( &node->children )))
2318 {
2319 struct node *tail = LIST_ENTRY( ptr, struct node, entry );
2320 if (node_type( tail ) == WS_XML_NODE_TYPE_END_ELEMENT)
2321 {
2322 *current = tail;
2323 return TRUE;
2324 }
2325 }
2326 return FALSE;
2327 }
2328
2329 BOOL move_to_parent_element( struct node **current )
2330 {
2331 struct node *parent = (*current)->parent;
2332
2333 if (parent && (node_type( parent ) == WS_XML_NODE_TYPE_ELEMENT ||
2334 node_type( parent ) == WS_XML_NODE_TYPE_BOF))
2335 {
2336 *current = parent;
2337 return TRUE;
2338 }
2339 return FALSE;
2340 }
2341
2342 BOOL move_to_first_node( struct node **current )
2343 {
2344 struct list *ptr;
2345 struct node *node = *current;
2346
2347 if ((ptr = list_head( &node->parent->children )))
2348 {
2349 *current = LIST_ENTRY( ptr, struct node, entry );
2350 return TRUE;
2351 }
2352 return FALSE;
2353 }
2354
2355 BOOL move_to_next_node( struct node **current )
2356 {
2357 struct list *ptr;
2358 struct node *node = *current;
2359
2360 if ((ptr = list_next( &node->parent->children, &node->entry )))
2361 {
2362 *current = LIST_ENTRY( ptr, struct node, entry );
2363 return TRUE;
2364 }
2365 return FALSE;
2366 }
2367
2368 BOOL move_to_prev_node( struct node **current )
2369 {
2370 struct list *ptr;
2371 struct node *node = *current;
2372
2373 if ((ptr = list_prev( &node->parent->children, &node->entry )))
2374 {
2375 *current = LIST_ENTRY( ptr, struct node, entry );
2376 return TRUE;
2377 }
2378 return FALSE;
2379 }
2380
2381 BOOL move_to_bof( struct node *root, struct node **current )
2382 {
2383 *current = root;
2384 return TRUE;
2385 }
2386
2387 BOOL move_to_eof( struct node *root, struct node **current )
2388 {
2389 struct list *ptr;
2390 if ((ptr = list_tail( &root->children )))
2391 {
2392 *current = LIST_ENTRY( ptr, struct node, entry );
2393 return TRUE;
2394 }
2395 return FALSE;
2396 }
2397
2398 BOOL move_to_child_node( struct node **current )
2399 {
2400 struct list *ptr;
2401 struct node *node = *current;
2402
2403 if ((ptr = list_head( &node->children )))
2404 {
2405 *current = LIST_ENTRY( ptr, struct node, entry );
2406 return TRUE;
2407 }
2408 return FALSE;
2409 }
2410
2411 BOOL move_to_parent_node( struct node **current )
2412 {
2413 struct node *parent = (*current)->parent;
2414 if (!parent) return FALSE;
2415 *current = parent;
2416 return TRUE;
2417 }
2418
2419 static HRESULT read_move_to( struct reader *reader, WS_MOVE_TO move, BOOL *found )
2420 {
2421 BOOL success = FALSE;
2422 HRESULT hr = S_OK;
2423
2424 if (!read_end_of_data( reader ))
2425 {
2426 while (reader->state != READER_STATE_EOF && (hr = read_node( reader )) == S_OK) { /* nothing */ };
2427 if (hr != S_OK) return hr;
2428 }
2429 switch (move)
2430 {
2431 case WS_MOVE_TO_ROOT_ELEMENT:
2432 success = move_to_root_element( reader->root, &reader->current );
2433 break;
2434
2435 case WS_MOVE_TO_NEXT_ELEMENT:
2436 success = move_to_next_element( &reader->current );
2437 break;
2438
2439 case WS_MOVE_TO_PREVIOUS_ELEMENT:
2440 success = move_to_prev_element( &reader->current );
2441 break;
2442
2443 case WS_MOVE_TO_CHILD_ELEMENT:
2444 success = move_to_child_element( &reader->current );
2445 break;
2446
2447 case WS_MOVE_TO_END_ELEMENT:
2448 success = move_to_end_element( &reader->current );
2449 break;
2450
2451 case WS_MOVE_TO_PARENT_ELEMENT:
2452 success = move_to_parent_element( &reader->current );
2453 break;
2454
2455 case WS_MOVE_TO_FIRST_NODE:
2456 success = move_to_first_node( &reader->current );
2457 break;
2458
2459 case WS_MOVE_TO_NEXT_NODE:
2460 success = move_to_next_node( &reader->current );
2461 break;
2462
2463 case WS_MOVE_TO_PREVIOUS_NODE:
2464 success = move_to_prev_node( &reader->current );
2465 break;
2466
2467 case WS_MOVE_TO_CHILD_NODE:
2468 success = move_to_child_node( &reader->current );
2469 break;
2470
2471 case WS_MOVE_TO_BOF:
2472 success = move_to_bof( reader->root, &reader->current );
2473 break;
2474
2475 case WS_MOVE_TO_EOF:
2476 success = move_to_eof( reader->root, &reader->current );
2477 break;
2478
2479 default:
2480 FIXME( "unhandled move %u\n", move );
2481 return E_NOTIMPL;
2482 }
2483
2484 if (found)
2485 {
2486 *found = success;
2487 return S_OK;
2488 }
2489 return success ? S_OK : WS_E_INVALID_FORMAT;
2490 }
2491
2492 /**************************************************************************
2493 * WsMoveReader [webservices.@]
2494 */
2495 HRESULT WINAPI WsMoveReader( WS_XML_READER *handle, WS_MOVE_TO move, BOOL *found, WS_ERROR *error )
2496 {
2497 struct reader *reader = (struct reader *)handle;
2498 HRESULT hr;
2499
2500 TRACE( "%p %u %p %p\n", handle, move, found, error );
2501 if (error) FIXME( "ignoring error parameter\n" );
2502
2503 if (!reader) return E_INVALIDARG;
2504
2505 EnterCriticalSection( &reader->cs );
2506
2507 if (reader->magic != READER_MAGIC)
2508 {
2509 LeaveCriticalSection( &reader->cs );
2510 return E_INVALIDARG;
2511 }
2512
2513 if (!reader->input_type)
2514 {
2515 LeaveCriticalSection( &reader->cs );
2516 return WS_E_INVALID_OPERATION;
2517 }
2518
2519 hr = read_move_to( reader, move, found );
2520
2521 LeaveCriticalSection( &reader->cs );
2522 return hr;
2523 }
2524
2525 /**************************************************************************
2526 * WsReadStartAttribute [webservices.@]
2527 */
2528 HRESULT WINAPI WsReadStartAttribute( WS_XML_READER *handle, ULONG index, WS_ERROR *error )
2529 {
2530 struct reader *reader = (struct reader *)handle;
2531 const WS_XML_ELEMENT_NODE *elem;
2532
2533 TRACE( "%p %u %p\n", handle, index, error );
2534 if (error) FIXME( "ignoring error parameter\n" );
2535
2536 if (!reader) return E_INVALIDARG;
2537
2538 EnterCriticalSection( &reader->cs );
2539
2540 if (reader->magic != READER_MAGIC)
2541 {
2542 LeaveCriticalSection( &reader->cs );
2543 return E_INVALIDARG;
2544 }
2545
2546 elem = &reader->current->hdr;
2547 if (reader->state != READER_STATE_STARTELEMENT || index >= elem->attributeCount)
2548 {
2549 LeaveCriticalSection( &reader->cs );
2550 return WS_E_INVALID_FORMAT;
2551 }
2552
2553 reader->current_attr = index;
2554 reader->state = READER_STATE_STARTATTRIBUTE;
2555
2556 LeaveCriticalSection( &reader->cs );
2557 return S_OK;
2558 }
2559
2560 /**************************************************************************
2561 * WsReadEndAttribute [webservices.@]
2562 */
2563 HRESULT WINAPI WsReadEndAttribute( WS_XML_READER *handle, WS_ERROR *error )
2564 {
2565 struct reader *reader = (struct reader *)handle;
2566
2567 TRACE( "%p %p\n", handle, error );
2568 if (error) FIXME( "ignoring error parameter\n" );
2569
2570 if (!reader) return E_INVALIDARG;
2571
2572 EnterCriticalSection( &reader->cs );
2573
2574 if (reader->magic != READER_MAGIC)
2575 {
2576 LeaveCriticalSection( &reader->cs );
2577 return E_INVALIDARG;
2578 }
2579
2580 if (reader->state != READER_STATE_STARTATTRIBUTE)
2581 {
2582 LeaveCriticalSection( &reader->cs );
2583 return WS_E_INVALID_FORMAT;
2584 }
2585
2586 reader->state = READER_STATE_STARTELEMENT;
2587
2588 LeaveCriticalSection( &reader->cs );
2589 return S_OK;
2590 }
2591
2592 static HRESULT find_namespace( struct reader *reader, const WS_XML_STRING *prefix, const WS_XML_STRING **ns )
2593 {
2594 const struct node *node;
2595 for (node = reader->current->parent; node_type( node ) == WS_XML_NODE_TYPE_ELEMENT; node = node->parent)
2596 {
2597 const WS_XML_ELEMENT_NODE *elem = &node->hdr;
2598 ULONG i;
2599 for (i = 0; i < elem->attributeCount; i++)
2600 {
2601 if (!elem->attributes[i]->isXmlNs) continue;
2602 if (WsXmlStringEquals( elem->attributes[i]->prefix, prefix, NULL ) != S_OK) continue;
2603 *ns = elem->attributes[i]->ns;
2604 return S_OK;
2605 }
2606 }
2607 return WS_E_INVALID_FORMAT;
2608 }
2609
2610 static HRESULT read_qualified_name( struct reader *reader, WS_HEAP *heap, WS_XML_STRING *prefix_ret,
2611 WS_XML_STRING *localname_ret, WS_XML_STRING *ns_ret )
2612 {
2613 const WS_XML_TEXT_NODE *node = (const WS_XML_TEXT_NODE *)reader->current;
2614 const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)node->text;
2615 unsigned char *prefix_bytes, *localname_bytes, *ns_bytes;
2616 const unsigned char *ptr = utf8->value.bytes;
2617 WS_XML_STRING prefix, localname, empty = {0, NULL};
2618 const WS_XML_STRING *ns = &empty;
2619 ULONG len = utf8->value.length;
2620 HRESULT hr;
2621
2622 while (len && read_isspace( *ptr )) { ptr++; len--; }
2623 while (len && read_isspace( ptr[len - 1] )) { len--; }
2624 if (!len) return WS_E_INVALID_FORMAT;
2625
2626 if ((hr = split_name( ptr, len, (const unsigned char **)&prefix.bytes, &prefix.length,
2627 (const unsigned char **)&localname.bytes, &localname.length )) != S_OK) return hr;
2628
2629 if (!localname.length) return WS_E_INVALID_FORMAT;
2630 if (prefix.length && (hr = find_namespace( reader, &prefix, &ns )) != S_OK) return hr;
2631
2632 if (!(prefix_bytes = ws_alloc( heap, prefix.length ))) return WS_E_QUOTA_EXCEEDED;
2633 memcpy( prefix_bytes, prefix.bytes, prefix.length );
2634
2635 if (!(localname_bytes = ws_alloc( heap, localname.length )))
2636 {
2637 ws_free( heap, prefix_bytes, prefix.length );
2638 return WS_E_QUOTA_EXCEEDED;
2639 }
2640 memcpy( localname_bytes, localname.bytes, localname.length );
2641
2642 if (!(ns_bytes = ws_alloc( heap, ns->length )))
2643 {
2644 ws_free( heap, prefix_bytes, prefix.length );
2645 ws_free( heap, localname_bytes, localname.length );
2646 return WS_E_QUOTA_EXCEEDED;
2647 }
2648 memcpy( ns_bytes, ns->bytes, ns->length );
2649
2650 prefix_ret->bytes = prefix_bytes;
2651 prefix_ret->length = prefix.length;
2652
2653 localname_ret->bytes = localname_bytes;
2654 localname_ret->length = localname.length;
2655
2656 ns_ret->bytes = ns_bytes;
2657 ns_ret->length = ns->length;
2658
2659 return S_OK;
2660 }
2661
2662 /**************************************************************************
2663 * WsReadQualifiedName [webservices.@]
2664 */
2665 HRESULT WINAPI WsReadQualifiedName( WS_XML_READER *handle, WS_HEAP *heap, WS_XML_STRING *prefix,
2666 WS_XML_STRING *localname, WS_XML_STRING *ns,
2667 WS_ERROR *error )
2668 {
2669 struct reader *reader = (struct reader *)handle;
2670 HRESULT hr;
2671
2672 TRACE( "%p %p %p %p %p %p\n", handle, heap, prefix, localname, ns, error );
2673 if (error) FIXME( "ignoring error parameter\n" );
2674
2675 if (!reader || !heap) return E_INVALIDARG;
2676
2677 EnterCriticalSection( &reader->cs );
2678
2679 if (reader->magic != READER_MAGIC)
2680 {
2681 LeaveCriticalSection( &reader->cs );
2682 return E_INVALIDARG;
2683 }
2684
2685 if (!reader->input_type)
2686 {
2687 LeaveCriticalSection( &reader->cs );
2688 return WS_E_INVALID_OPERATION;
2689 }
2690
2691 if (!localname)
2692 {
2693 LeaveCriticalSection( &reader->cs );
2694 return E_INVALIDARG;
2695 }
2696
2697 if (reader->state != READER_STATE_TEXT)
2698 {
2699 LeaveCriticalSection( &reader->cs );
2700 return WS_E_INVALID_FORMAT;
2701 }
2702
2703 hr = read_qualified_name( reader, heap, prefix, localname, ns );
2704
2705 LeaveCriticalSection( &reader->cs );
2706 return hr;
2707 }
2708
2709 static WCHAR *xmltext_to_widechar( WS_HEAP *heap, const WS_XML_TEXT *text )
2710 {
2711 WCHAR *ret;
2712
2713 switch (text->textType)
2714 {
2715 case WS_XML_TEXT_TYPE_UTF8:
2716 {
2717 const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text;
2718 int len = MultiByteToWideChar( CP_UTF8, 0, (char *)utf8->value.bytes, utf8->value.length, NULL, 0 );
2719 if (!(ret = ws_alloc( heap, (len + 1) * sizeof(WCHAR) ))) return NULL;
2720 MultiByteToWideChar( CP_UTF8, 0, (char *)utf8->value.bytes, utf8->value.length, ret, len );
2721 ret[len] = 0;
2722 break;
2723 }
2724 default:
2725 FIXME( "unhandled type %u\n", text->textType );
2726 return NULL;
2727 }
2728
2729 return ret;
2730 }
2731
2732 #define MAX_INT8 0x7f
2733 #define MIN_INT8 (-MAX_INT8 - 1)
2734 #define MAX_INT16 0x7fff
2735 #define MIN_INT16 (-MAX_INT16 - 1)
2736 #define MAX_INT32 0x7fffffff
2737 #define MIN_INT32 (-MAX_INT32 - 1)
2738 #define MAX_INT64 (((INT64)0x7fffffff << 32) | 0xffffffff)
2739 #define MIN_INT64 (-MAX_INT64 - 1)
2740 #define MAX_UINT8 0xff
2741 #define MAX_UINT16 0xffff
2742 #define MAX_UINT32 0xffffffff
2743 #define MAX_UINT64 (((UINT64)0xffffffff << 32) | 0xffffffff)
2744
2745 static HRESULT str_to_int64( const unsigned char *str, ULONG len, INT64 min, INT64 max, INT64 *ret )
2746 {
2747 BOOL negative = FALSE;
2748 const unsigned char *ptr = str;
2749
2750 *ret = 0;
2751 while (len && read_isspace( *ptr )) { ptr++; len--; }
2752 while (len && read_isspace( ptr[len - 1] )) { len--; }
2753 if (!len) return WS_E_INVALID_FORMAT;
2754
2755 if (*ptr == '-')
2756 {
2757 negative = TRUE;
2758 ptr++;
2759 len--;
2760 }
2761 if (!len) return WS_E_INVALID_FORMAT;
2762
2763 while (len--)
2764 {
2765 int val;
2766
2767 if (!isdigit( *ptr )) return WS_E_INVALID_FORMAT;
2768 val = *ptr - '0';
2769 if (negative) val = -val;
2770
2771 if ((!negative && (*ret > max / 10 || *ret * 10 > max - val)) ||
2772 (negative && (*ret < min / 10 || *ret * 10 < min - val)))
2773 {
2774 return WS_E_NUMERIC_OVERFLOW;
2775 }
2776 *ret = *ret * 10 + val;
2777 ptr++;
2778 }
2779
2780 return S_OK;
2781 }
2782
2783 static HRESULT str_to_uint64( const unsigned char *str, ULONG len, UINT64 max, UINT64 *ret )
2784 {
2785 const unsigned char *ptr = str;
2786
2787 *ret = 0;
2788 while (len && read_isspace( *ptr )) { ptr++; len--; }
2789 while (len && read_isspace( ptr[len - 1] )) { len--; }
2790 if (!len) return WS_E_INVALID_FORMAT;
2791
2792 while (len--)
2793 {
2794 unsigned int val;
2795
2796 if (!isdigit( *ptr )) return WS_E_INVALID_FORMAT;
2797 val = *ptr - '0';
2798
2799 if ((*ret > max / 10 || *ret * 10 > max - val)) return WS_E_NUMERIC_OVERFLOW;
2800 *ret = *ret * 10 + val;
2801 ptr++;
2802 }
2803
2804 return S_OK;
2805 }
2806
2807 BOOL set_fpword( unsigned short new, unsigned short *old )
2808 {
2809 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
2810 unsigned short fpword;
2811
2812 __asm__ __volatile__( "fstcw %0" : "=m" (fpword) );
2813 *old = fpword;
2814 fpword = new;
2815 __asm__ __volatile__( "fldcw %0" : : "m" (fpword) );
2816 return TRUE;
2817 #else
2818 FIXME( "not implemented\n" );
2819 return FALSE;
2820 #endif
2821 }
2822
2823 void restore_fpword( unsigned short fpword )
2824 {
2825 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
2826 __asm__ __volatile__( "fldcw %0" : : "m" (fpword) );
2827 #else
2828 FIXME( "not implemented\n" );
2829 #endif
2830 }
2831
2832 static HRESULT str_to_double( const unsigned char *str, ULONG len, double *ret )
2833 {
2834 static const unsigned __int64 nan = 0xfff8000000000000;
2835 static const unsigned __int64 inf = 0x7ff0000000000000;
2836 static const unsigned __int64 inf_min = 0xfff0000000000000;
2837 HRESULT hr = WS_E_INVALID_FORMAT;
2838 const unsigned char *p = str, *q;
2839 int sign = 1, exp_sign = 1, exp = 0, exp_tmp = 0, neg_exp, i, nb_digits, have_digits;
2840 unsigned __int64 val = 0, tmp;
2841 long double exp_val = 1.0, exp_mul = 10.0;
2842 unsigned short fpword;
2843
2844 while (len && read_isspace( *p )) { p++; len--; }
2845 while (len && read_isspace( p[len - 1] )) { len--; }
2846 if (!len) return WS_E_INVALID_FORMAT;
2847
2848 if (len == 3 && !memcmp( p, "NaN", 3 ))
2849 {
2850 *(unsigned __int64 *)ret = nan;
2851 return S_OK;
2852 }
2853 else if (len == 3 && !memcmp( p, "INF", 3 ))
2854 {
2855 *(unsigned __int64 *)ret = inf;
2856 return S_OK;
2857 }
2858 else if (len == 4 && !memcmp( p, "-INF", 4 ))
2859 {
2860 *(unsigned __int64 *)ret = inf_min;
2861 return S_OK;
2862 }
2863
2864 *ret = 0.0;
2865 if (*p == '-')
2866 {
2867 sign = -1;
2868 p++; len--;
2869 }
2870 else if (*p == '+') { p++; len--; };
2871 if (!len) return S_OK;
2872
2873 if (!set_fpword( 0x37f, &fpword )) return E_NOTIMPL;
2874
2875 q = p;
2876 while (len && isdigit( *q )) { q++; len--; }
2877 have_digits = nb_digits = q - p;
2878 for (i = 0; i < nb_digits; i++)
2879 {
2880 tmp = val * 10 + p[i] - '0';
2881 if (val > MAX_UINT64 / 10 || tmp < val)
2882 {
2883 for (; i < nb_digits; i++) exp++;
2884 break;
2885 }
2886 val = tmp;
2887 }
2888
2889 if (len)
2890 {
2891 if (*q == '.')
2892 {
2893 p = ++q; len--;
2894 while (len && isdigit( *q )) { q++; len--; };
2895 have_digits |= nb_digits = q - p;
2896 for (i = 0; i < nb_digits; i++)
2897 {
2898 tmp = val * 10 + p[i] - '0';
2899 if (val > MAX_UINT64 / 10 || tmp < val) break;
2900 val = tmp;
2901 exp--;
2902 }
2903 }
2904 if (len > 1 && tolower(*q) == 'e')
2905 {
2906 if (!have_digits) goto done;
2907 p = ++q; len--;
2908 if (*p == '-')
2909 {
2910 exp_sign = -1;
2911 p++; len--;
2912 }
2913 else if (*p == '+') { p++; len--; };
2914
2915 q = p;
2916 while (len && isdigit( *q )) { q++; len--; };
2917 nb_digits = q - p;
2918 if (!nb_digits || len) goto done;
2919 for (i = 0; i < nb_digits; i++)
2920 {
2921 if (exp_tmp > MAX_INT32 / 10 || (exp_tmp = exp_tmp * 10 + p[i] - '0') < 0)
2922 exp_tmp = MAX_INT32;
2923 }
2924 exp_tmp *= exp_sign;
2925
2926 if (exp < 0 && exp_tmp < 0 && exp + exp_tmp >= 0) exp = MIN_INT32;
2927 else if (exp > 0 && exp_tmp > 0 && exp + exp_tmp < 0) exp = MAX_INT32;
2928 else exp += exp_tmp;
2929 }
2930 }
2931 if (!have_digits || len) goto done;
2932
2933 if ((neg_exp = exp < 0)) exp = -exp;
2934 for (; exp; exp >>= 1)
2935 {
2936 if (exp & 1) exp_val *= exp_mul;
2937 exp_mul *= exp_mul;
2938 }
2939
2940 *ret = sign * (neg_exp ? val / exp_val : val * exp_val);
2941 hr = S_OK;
2942
2943 done:
2944 restore_fpword( fpword );
2945 return hr;
2946 }
2947
2948 static HRESULT str_to_guid( const unsigned char *str, ULONG len, GUID *ret )
2949 {
2950 static const unsigned char hex[] =
2951 {
2952 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x00 */
2953 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x10 */
2954 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x20 */
2955 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, /* 0x30 */
2956 0,10,11,12,13,14,15,0,0,0,0,0,0,0,0,0, /* 0x40 */
2957 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x50 */
2958 0,10,11,12,13,14,15 /* 0x60 */
2959 };
2960 const unsigned char *p = str;
2961 ULONG i;
2962
2963 while (len && read_isspace( *p )) { p++; len--; }
2964 while (len && read_isspace( p[len - 1] )) { len--; }
2965 if (len != 36) return WS_E_INVALID_FORMAT;
2966
2967 if (p[8] != '-' || p[13] != '-' || p[18] != '-' || p[23] != '-')
2968 return WS_E_INVALID_FORMAT;
2969
2970 for (i = 0; i < 36; i++)
2971 {
2972 if (i == 8 || i == 13 || i == 18 || i == 23) continue;
2973 if (p[i] > 'f' || (!hex[p[i]] && p[i] != '0')) return WS_E_INVALID_FORMAT;
2974 }
2975
2976 ret->Data1 = hex[p[0]] << 28 | hex[p[1]] << 24 | hex[p[2]] << 20 | hex[p[3]] << 16 |
2977 hex[p[4]] << 12 | hex[p[5]] << 8 | hex[p[6]] << 4 | hex[p[7]];
2978
2979 ret->Data2 = hex[p[9]] << 12 | hex[p[10]] << 8 | hex[p[11]] << 4 | hex[p[12]];
2980 ret->Data3 = hex[p[14]] << 12 | hex[p[15]] << 8 | hex[p[16]] << 4 | hex[p[17]];
2981
2982 ret->Data4[0] = hex[p[19]] << 4 | hex[p[20]];
2983 ret->Data4[1] = hex[p[21]] << 4 | hex[p[22]];
2984 ret->Data4[2] = hex[p[24]] << 4 | hex[p[25]];
2985 ret->Data4[3] = hex[p[26]] << 4 | hex[p[27]];
2986 ret->Data4[4] = hex[p[28]] << 4 | hex[p[29]];
2987 ret->Data4[5] = hex[p[30]] << 4 | hex[p[31]];
2988 ret->Data4[6] = hex[p[32]] << 4 | hex[p[33]];
2989 ret->Data4[7] = hex[p[34]] << 4 | hex[p[35]];
2990
2991 return S_OK;
2992 }
2993
2994 static inline unsigned char decode_char( unsigned char c )
2995 {
2996 if (c >= 'A' && c <= 'Z') return c - 'A';
2997 if (c >= 'a' && c <= 'z') return c - 'a' + 26;
2998 if (c >= '0' && c <= '9') return c - '0' + 52;
2999 if (c == '+') return 62;
3000 if (c == '/') return 63;
3001 return 64;
3002 }
3003
3004 static ULONG decode_base64( const unsigned char *base64, ULONG len, unsigned char *buf )
3005 {
3006 ULONG i = 0;
3007 unsigned char c0, c1, c2, c3;
3008 const unsigned char *p = base64;
3009
3010 while (len > 4)
3011 {
3012 if ((c0 = decode_char( p[0] )) > 63) return 0;
3013 if ((c1 = decode_char( p[1] )) > 63) return 0;
3014 if ((c2 = decode_char( p[2] )) > 63) return 0;
3015 if ((c3 = decode_char( p[3] )) > 63) return 0;
3016 buf[i + 0] = (c0 << 2) | (c1 >> 4);
3017 buf[i + 1] = (c1 << 4) | (c2 >> 2);
3018 buf[i + 2] = (c2 << 6) | c3;
3019 len -= 4;
3020 i += 3;
3021 p += 4;
3022 }
3023 if (p[2] == '=')
3024 {
3025 if ((c0 = decode_char( p[0] )) > 63) return 0;
3026 if ((c1 = decode_char( p[1] )) > 63) return 0;
3027 buf[i] = (c0 << 2) | (c1 >> 4);
3028 i++;
3029 }
3030 else if (p[3] == '=')
3031 {
3032 if ((c0 = decode_char( p[0] )) > 63) return 0;
3033 if ((c1 = decode_char( p[1] )) > 63) return 0;
3034 if ((c2 = decode_char( p[2] )) > 63) return 0;
3035 buf[i + 0] = (c0 << 2) | (c1 >> 4);
3036 buf[i + 1] = (c1 << 4) | (c2 >> 2);
3037 i += 2;
3038 }
3039 else
3040 {
3041 if ((c0 = decode_char( p[0] )) > 63) return 0;
3042 if ((c1 = decode_char( p[1] )) > 63) return 0;
3043 if ((c2 = decode_char( p[2] )) > 63) return 0;
3044 if ((c3 = decode_char( p[3] )) > 63) return 0;
3045 buf[i + 0] = (c0 << 2) | (c1 >> 4);
3046 buf[i + 1] = (c1 << 4) | (c2 >> 2);
3047 buf[i + 2] = (c2 << 6) | c3;
3048 i += 3;
3049 }
3050 return i;
3051 }
3052
3053 static HRESULT str_to_bytes( const unsigned char *str, ULONG len, WS_HEAP *heap, WS_BYTES *ret )
3054 {
3055 const unsigned char *p = str;
3056
3057 while (len && read_isspace( *p )) { p++; len--; }
3058 while (len && read_isspace( p[len - 1] )) { len--; }
3059
3060 if (len % 4) return WS_E_INVALID_FORMAT;
3061 if (!(ret->bytes = ws_alloc( heap, len * 3 / 4 ))) return WS_E_QUOTA_EXCEEDED;
3062 ret->length = decode_base64( p, len, ret->bytes );
3063 return S_OK;
3064 }
3065
3066 static const int month_offsets[2][12] =
3067 {
3068 {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},
3069 {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335}
3070 };
3071
3072 static inline int valid_day( int year, int month, int day )
3073 {
3074 return day > 0 && day <= month_days[leap_year( year )][month - 1];
3075 }
3076
3077 static inline int leap_days_before( int year )
3078 {
3079 return (year - 1) / 4 - (year - 1) / 100 + (year - 1) / 400;
3080 }
3081
3082 static HRESULT str_to_datetime( const unsigned char *bytes, ULONG len, WS_DATETIME *ret )
3083 {
3084 const unsigned char *p = bytes, *q;
3085 int year, month, day, hour, min, sec, sec_frac = 0, tz_hour, tz_min, tz_neg;
3086
3087 while (len && read_isspace( *p )) { p++; len--; }
3088 while (len && read_isspace( p[len - 1] )) { len--; }
3089
3090 q = p;
3091 while (len && isdigit( *q )) { q++; len--; };
3092 if (q - p != 4 || !len || *q != '-') return WS_E_INVALID_FORMAT;
3093 year = (p[0] - '0') * 1000 + (p[1] - '0') * 100 + (p[2] - '0') * 10 + p[3] - '0';
3094 if (year < 1) return WS_E_INVALID_FORMAT;
3095
3096 p = ++q; len--;
3097 while (len && isdigit( *q )) { q++; len--; };
3098 if (q - p != 2 || !len || *q != '-') return WS_E_INVALID_FORMAT;
3099 month = (p[0] - '0') * 10 + p[1] - '0';
3100 if (month < 1 || month > 12) return WS_E_INVALID_FORMAT;
3101
3102 p = ++q; len--;
3103 while (len && isdigit( *q )) { q++; len--; };
3104 if (q - p != 2 || !len || *q != 'T') return WS_E_INVALID_FORMAT;
3105 day = (p[0] - '0') * 10 + p[1] - '0';
3106 if (!valid_day( year, month, day )) return WS_E_INVALID_FORMAT;
3107
3108 p = ++q; len--;
3109 while (len && isdigit( *q )) { q++; len--; };
3110 if (q - p != 2 || !len || *q != ':') return WS_E_INVALID_FORMAT;
3111 hour = (p[0] - '0') * 10 + p[1] - '0';
3112 if (hour > 24) return WS_E_INVALID_FORMAT;
3113
3114 p = ++q; len--;
3115 while (len && isdigit( *q )) { q++; len--; };
3116 if (q - p != 2 || !len || *q != ':') return WS_E_INVALID_FORMAT;
3117 min = (p[0] - '0') * 10 + p[1] - '0';
3118 if (min > 59 || (min > 0 && hour == 24)) return WS_E_INVALID_FORMAT;
3119
3120 p = ++q; len--;
3121 while (len && isdigit( *q )) { q++; len--; };
3122 if (q - p != 2 || !len) return WS_E_INVALID_FORMAT;
3123 sec = (p[0] - '0') * 10 + p[1] - '0';
3124 if (sec > 59 || (sec > 0 && hour == 24)) return WS_E_INVALID_FORMAT;
3125
3126 if (*q == '.')
3127 {
3128 unsigned int i, nb_digits, mul = TICKS_PER_SEC / 10;
3129 p = ++q; len--;
3130 while (len && isdigit( *q )) { q++; len--; };
3131 nb_digits = q - p;
3132 if (nb_digits < 1 || nb_digits > 7) return WS_E_INVALID_FORMAT;
3133 for (i = 0; i < nb_digits; i++)
3134 {
3135 sec_frac += (p[i] - '0') * mul;
3136 mul /= 10;
3137 }
3138 }
3139 if (*q == 'Z')
3140 {
3141 if (--len) return WS_E_INVALID_FORMAT;
3142 tz_hour = tz_min = tz_neg = 0;
3143 ret->format = WS_DATETIME_FORMAT_UTC;
3144 }
3145 else if (*q == '+' || *q == '-')
3146 {
3147 tz_neg = (*q == '-') ? 1 : 0;
3148
3149 p = ++q; len--;
3150 while (len && isdigit( *q )) { q++; len--; };
3151 if (q - p != 2 || !len || *q != ':') return WS_E_INVALID_FORMAT;
3152 tz_hour = (p[0] - '0') * 10 + p[1] - '0';
3153 if (tz_hour > 14) return WS_E_INVALID_FORMAT;
3154
3155 p = ++q; len--;
3156 while (len && isdigit( *q )) { q++; len--; };
3157 if (q - p != 2 || len) return WS_E_INVALID_FORMAT;
3158 tz_min = (p[0] - '0') * 10 + p[1] - '0';
3159 if (tz_min > 59 || (tz_min > 0 && tz_hour == 14)) return WS_E_INVALID_FORMAT;
3160
3161 ret->format = WS_DATETIME_FORMAT_LOCAL;
3162 }
3163 else return WS_E_INVALID_FORMAT;
3164
3165 ret->ticks = ((year - 1) * 365 + leap_days_before( year )) * TICKS_PER_DAY;
3166 ret->ticks += month_offsets[leap_year( year )][month - 1] * TICKS_PER_DAY;
3167 ret->ticks += (day - 1) * TICKS_PER_DAY;
3168 ret->ticks += hour * TICKS_PER_HOUR;
3169 ret->ticks += min * TICKS_PER_MIN;
3170 ret->ticks += sec * TICKS_PER_SEC;
3171 ret->ticks += sec_frac;
3172
3173 if (tz_neg)
3174 {
3175 if (tz_hour * TICKS_PER_HOUR + tz_min * TICKS_PER_MIN + ret->ticks > TICKS_MAX)
3176 return WS_E_INVALID_FORMAT;
3177 ret->ticks += tz_hour * TICKS_PER_HOUR;
3178 ret->ticks += tz_min * TICKS_PER_MIN;
3179 }
3180 else
3181 {
3182 if (tz_hour * TICKS_PER_HOUR + tz_min * TICKS_PER_MIN > ret->ticks)
3183 return WS_E_INVALID_FORMAT;
3184 ret->ticks -= tz_hour * TICKS_PER_HOUR;
3185 ret->ticks -= tz_min * TICKS_PER_MIN;
3186 }
3187
3188 return S_OK;
3189 }
3190
3191 /**************************************************************************
3192 * WsDateTimeToFileTime [webservices.@]
3193 */
3194 HRESULT WINAPI WsDateTimeToFileTime( const WS_DATETIME *dt, FILETIME *ft, WS_ERROR *error )
3195 {
3196 unsigned __int64 ticks;
3197
3198 TRACE( "%p %p %p\n", dt, ft, error );
3199 if (error) FIXME( "ignoring error parameter\n" );
3200
3201 if (!dt || !ft) return E_INVALIDARG;
3202
3203 if (dt->ticks < TICKS_1601_01_01) return WS_E_INVALID_FORMAT;
3204 ticks = dt->ticks - TICKS_1601_01_01;
3205 ft->dwHighDateTime = ticks >> 32;
3206 ft->dwLowDateTime = (DWORD)ticks;
3207 return S_OK;
3208 }
3209
3210 /**************************************************************************
3211 * WsFileTimeToDateTime [webservices.@]
3212 */
3213 HRESULT WINAPI WsFileTimeToDateTime( const FILETIME *ft, WS_DATETIME *dt, WS_ERROR *error )
3214 {
3215 unsigned __int64 ticks;
3216
3217 TRACE( "%p %p %p\n", ft, dt, error );
3218 if (error) FIXME( "ignoring error parameter\n" );
3219
3220 if (!dt || !ft) return E_INVALIDARG;
3221
3222 ticks = ((unsigned __int64)ft->dwHighDateTime << 32) | ft->dwLowDateTime;
3223 if (ticks > MAX_UINT64 - TICKS_1601_01_01) return WS_E_NUMERIC_OVERFLOW;
3224 if (ticks + TICKS_1601_01_01 > TICKS_MAX) return WS_E_INVALID_FORMAT;
3225 dt->ticks = ticks + TICKS_1601_01_01;
3226 dt->format = WS_DATETIME_FORMAT_UTC;
3227 return S_OK;
3228 }
3229
3230 static HRESULT read_get_node_text( struct reader *reader, WS_XML_UTF8_TEXT **ret )
3231 {
3232 WS_XML_TEXT_NODE *text;
3233
3234 if (node_type( reader->current ) != WS_XML_NODE_TYPE_TEXT)
3235 return WS_E_INVALID_FORMAT;
3236
3237 text = (WS_XML_TEXT_NODE *)&reader->current->hdr.node;
3238 if (text->text->textType != WS_XML_TEXT_TYPE_UTF8)
3239 {
3240 FIXME( "text type %u not supported\n", text->text->textType );
3241 return E_NOTIMPL;
3242 }
3243 *ret = (WS_XML_UTF8_TEXT *)text->text;
3244 return S_OK;
3245 }
3246
3247 static HRESULT read_get_attribute_text( struct reader *reader, ULONG index, WS_XML_UTF8_TEXT **ret )
3248 {
3249 WS_XML_ELEMENT_NODE *elem = &reader->current->hdr;
3250 WS_XML_ATTRIBUTE *attr;
3251
3252 if (node_type( reader->current ) != WS_XML_NODE_TYPE_ELEMENT)
3253 return WS_E_INVALID_FORMAT;
3254
3255 attr = elem->attributes[index];
3256 if (attr->value->textType != WS_XML_TEXT_TYPE_UTF8)
3257 {
3258 FIXME( "text type %u not supported\n", attr->value->textType );
3259 return E_NOTIMPL;
3260 }
3261 *ret = (WS_XML_UTF8_TEXT *)attr->value;
3262 return S_OK;
3263 }
3264
3265 static BOOL find_attribute( struct reader *reader, const WS_XML_STRING *localname,
3266 const WS_XML_STRING *ns, ULONG *index )
3267 {
3268 ULONG i;
3269 WS_XML_ELEMENT_NODE *elem = &reader->current->hdr;
3270
3271 if (!localname)
3272 {
3273 *index = reader->current_attr;
3274 return TRUE;
3275 }
3276 for (i = 0; i < elem->attributeCount; i++)
3277 {
3278 const WS_XML_STRING *localname2 = elem->attributes[i]->localName;
3279 const WS_XML_STRING *ns2 = elem->attributes[i]->ns;
3280
3281 if (!cmp_name( localname->bytes, localname->length, localname2->bytes, localname2->length ) &&
3282 !cmp_name( ns->bytes, ns->length, ns2->bytes, ns2->length ))
3283 {
3284 *index = i;
3285 return TRUE;
3286 }
3287 }
3288 return FALSE;
3289 }
3290
3291 /**************************************************************************
3292 * WsFindAttribute [webservices.@]
3293 */
3294 HRESULT WINAPI WsFindAttribute( WS_XML_READER *handle, const WS_XML_STRING *localname,
3295 const WS_XML_STRING *ns, BOOL required, ULONG *index,
3296 WS_ERROR *error )
3297 {
3298 struct reader *reader = (struct reader *)handle;
3299 HRESULT hr = S_OK;
3300
3301 TRACE( "%p %s %s %d %p %p\n", handle, debugstr_xmlstr(localname), debugstr_xmlstr(ns),
3302 required, index, error );
3303 if (error) FIXME( "ignoring error parameter\n" );
3304
3305 if (!reader || !localname || !ns || !index) return E_INVALIDARG;
3306
3307 EnterCriticalSection( &reader->cs );
3308
3309 if (reader->magic != READER_MAGIC)
3310 {
3311 LeaveCriticalSection( &reader->cs );
3312 return E_INVALIDARG;
3313 }
3314
3315 if (node_type( reader->current ) != WS_XML_NODE_TYPE_ELEMENT)
3316 {
3317 LeaveCriticalSection( &reader->cs );
3318 return WS_E_INVALID_OPERATION;
3319 }
3320
3321 if (!find_attribute( reader, localname, ns, index ))
3322 {
3323 if (required) hr = WS_E_INVALID_FORMAT;
3324 else
3325 {
3326 *index = ~0u;
3327 hr = S_FALSE;
3328 }
3329 }
3330
3331 LeaveCriticalSection( &reader->cs );
3332 return hr;
3333 }
3334
3335 static HRESULT read_get_text( struct reader *reader, WS_TYPE_MAPPING mapping,
3336 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3337 WS_XML_UTF8_TEXT **ret, BOOL *found )
3338 {
3339 switch (mapping)
3340 {
3341 case WS_ATTRIBUTE_TYPE_MAPPING:
3342 {
3343 ULONG index;
3344 if (!(*found = find_attribute( reader, localname, ns, &index ))) return S_OK;
3345 return read_get_attribute_text( reader, index, ret );
3346 }
3347 case WS_ELEMENT_TYPE_MAPPING:
3348 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
3349 case WS_ANY_ELEMENT_TYPE_MAPPING:
3350 {
3351 HRESULT hr;
3352 *found = TRUE;
3353 if (localname)
3354 {
3355 const WS_XML_ELEMENT_NODE *elem = &reader->current->hdr;
3356
3357 if (WsXmlStringEquals( localname, elem->localName, NULL ) != S_OK ||
3358 WsXmlStringEquals( ns, elem->ns, NULL ) != S_OK)
3359 {
3360 *found = FALSE;
3361 return S_OK;
3362 }
3363 if ((hr = read_startelement( reader )) != S_OK) return hr;
3364 }
3365 return read_get_node_text( reader, ret );
3366 }
3367 default:
3368 FIXME( "mapping %u not supported\n", mapping );
3369 return E_NOTIMPL;
3370 }
3371 }
3372
3373 static HRESULT read_type_bool( struct reader *reader, WS_TYPE_MAPPING mapping,
3374 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3375 const WS_BOOL_DESCRIPTION *desc, WS_READ_OPTION option,
3376 WS_HEAP *heap, void *ret, ULONG size )
3377 {
3378 WS_XML_UTF8_TEXT *utf8;
3379 HRESULT hr;
3380 BOOL found, val = FALSE;
3381
3382 if (desc)
3383 {
3384 FIXME( "description not supported\n" );
3385 return E_NOTIMPL;
3386 }
3387 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3388 if (found)
3389 {
3390 ULONG len = utf8->value.length;
3391 if (len == 4 && !memcmp( utf8->value.bytes, "true", 4 )) val = TRUE;
3392 else if (len == 1 && !memcmp( utf8->value.bytes, "1", 1 )) val = TRUE;
3393 else if (len == 5 && !memcmp( utf8->value.bytes, "false", 5 )) val = FALSE;
3394 else if (len == 1 && !memcmp( utf8->value.bytes, "0", 1 )) val = FALSE;
3395 else return WS_E_INVALID_FORMAT;
3396 }
3397
3398 switch (option)
3399 {
3400 case WS_READ_REQUIRED_VALUE:
3401 if (!found) return WS_E_INVALID_FORMAT;
3402 /* fall through */
3403
3404 case WS_READ_NILLABLE_VALUE:
3405 if (size != sizeof(BOOL)) return E_INVALIDARG;
3406 *(BOOL *)ret = val;
3407 break;
3408
3409 case WS_READ_REQUIRED_POINTER:
3410 if (!found) return WS_E_INVALID_FORMAT;
3411 /* fall through */
3412
3413 case WS_READ_OPTIONAL_POINTER:
3414 case WS_READ_NILLABLE_POINTER:
3415 {
3416 BOOL *heap_val = NULL;
3417 if (size != sizeof(heap_val)) return E_INVALIDARG;
3418 if (found)
3419 {
3420 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3421 *heap_val = val;
3422 }
3423 *(BOOL **)ret = heap_val;
3424 break;
3425 }
3426 default:
3427 FIXME( "read option %u not supported\n", option );
3428 return E_NOTIMPL;
3429 }
3430
3431 return S_OK;
3432 }
3433
3434 static HRESULT read_type_int8( struct reader *reader, WS_TYPE_MAPPING mapping,
3435 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3436 const WS_INT8_DESCRIPTION *desc, WS_READ_OPTION option,
3437 WS_HEAP *heap, void *ret, ULONG size )
3438 {
3439 WS_XML_UTF8_TEXT *utf8;
3440 HRESULT hr;
3441 INT64 val = 0;
3442 BOOL found;
3443
3444 if (desc)
3445 {
3446 FIXME( "description not supported\n" );
3447 return E_NOTIMPL;
3448 }
3449 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3450 if (found && (hr = str_to_int64( utf8->value.bytes, utf8->value.length, MIN_INT8, MAX_INT8, &val )) != S_OK)
3451 return hr;
3452
3453 switch (option)
3454 {
3455 case WS_READ_REQUIRED_VALUE:
3456 if (!found) return WS_E_INVALID_FORMAT;
3457 /* fall through */
3458
3459 case WS_READ_NILLABLE_VALUE:
3460 if (size != sizeof(INT8)) return E_INVALIDARG;
3461 *(INT8 *)ret = val;
3462 break;
3463
3464 case WS_READ_REQUIRED_POINTER:
3465 if (!found) return WS_E_INVALID_FORMAT;
3466 /* fall through */
3467
3468 case WS_READ_OPTIONAL_POINTER:
3469 case WS_READ_NILLABLE_POINTER:
3470 {
3471 INT8 *heap_val = NULL;
3472 if (size != sizeof(heap_val)) return E_INVALIDARG;
3473 if (found)
3474 {
3475 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3476 *heap_val = val;
3477 }
3478 *(INT8 **)ret = heap_val;
3479 break;
3480 }
3481 default:
3482 FIXME( "read option %u not supported\n", option );
3483 return E_NOTIMPL;
3484 }
3485
3486 return S_OK;
3487 }
3488
3489 static HRESULT read_type_int16( struct reader *reader, WS_TYPE_MAPPING mapping,
3490 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3491 const WS_INT16_DESCRIPTION *desc, WS_READ_OPTION option,
3492 WS_HEAP *heap, void *ret, ULONG size )
3493 {
3494 WS_XML_UTF8_TEXT *utf8;
3495 HRESULT hr;
3496 INT64 val = 0;
3497 BOOL found;
3498
3499 if (desc)
3500 {
3501 FIXME( "description not supported\n" );
3502 return E_NOTIMPL;
3503 }
3504 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3505 if (found && (hr = str_to_int64( utf8->value.bytes, utf8->value.length, MIN_INT16, MAX_INT16, &val )) != S_OK)
3506 return hr;
3507
3508 switch (option)
3509 {
3510 case WS_READ_REQUIRED_VALUE:
3511 if (!found) return WS_E_INVALID_FORMAT;
3512 /* fall through */
3513
3514 case WS_READ_NILLABLE_VALUE:
3515 if (size != sizeof(INT16)) return E_INVALIDARG;
3516 *(INT16 *)ret = val;
3517 break;
3518
3519 case WS_READ_REQUIRED_POINTER:
3520 if (!found) return WS_E_INVALID_FORMAT;
3521 /* fall through */
3522
3523 case WS_READ_OPTIONAL_POINTER:
3524 case WS_READ_NILLABLE_POINTER:
3525 {
3526 INT16 *heap_val = NULL;
3527 if (size != sizeof(heap_val)) return E_INVALIDARG;
3528 if (found)
3529 {
3530 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3531 *heap_val = val;
3532 }
3533 *(INT16 **)ret = heap_val;
3534 break;
3535 }
3536 default:
3537 FIXME( "read option %u not supported\n", option );
3538 return E_NOTIMPL;
3539 }
3540
3541 return S_OK;
3542 }
3543
3544 static HRESULT read_type_int32( struct reader *reader, WS_TYPE_MAPPING mapping,
3545 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3546 const WS_INT32_DESCRIPTION *desc, WS_READ_OPTION option,
3547 WS_HEAP *heap, void *ret, ULONG size )
3548 {
3549 WS_XML_UTF8_TEXT *utf8;
3550 HRESULT hr;
3551 INT64 val = 0;
3552 BOOL found;
3553
3554 if (desc)
3555 {
3556 FIXME( "description not supported\n" );
3557 return E_NOTIMPL;
3558 }
3559 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3560 if (found && (hr = str_to_int64( utf8->value.bytes, utf8->value.length, MIN_INT32, MAX_INT32, &val )) != S_OK)
3561 return hr;
3562
3563 switch (option)
3564 {
3565 case WS_READ_REQUIRED_VALUE:
3566 if (!found) return WS_E_INVALID_FORMAT;
3567 /* fall through */
3568
3569 case WS_READ_NILLABLE_VALUE:
3570 if (size != sizeof(INT32)) return E_INVALIDARG;
3571 *(INT32 *)ret = val;
3572 break;
3573
3574 case WS_READ_REQUIRED_POINTER:
3575 if (!found) return WS_E_INVALID_FORMAT;
3576 /* fall through */
3577
3578 case WS_READ_OPTIONAL_POINTER:
3579 case WS_READ_NILLABLE_POINTER:
3580 {
3581 INT32 *heap_val = NULL;
3582 if (size != sizeof(heap_val)) return E_INVALIDARG;
3583 if (found)
3584 {
3585 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3586 *heap_val = val;
3587 }
3588 *(INT32 **)ret = heap_val;
3589 break;
3590 }
3591 default:
3592 FIXME( "read option %u not supported\n", option );
3593 return E_NOTIMPL;
3594 }
3595
3596 return S_OK;
3597 }
3598
3599 static HRESULT read_type_int64( struct reader *reader, WS_TYPE_MAPPING mapping,
3600 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3601 const WS_INT64_DESCRIPTION *desc, WS_READ_OPTION option,
3602 WS_HEAP *heap, void *ret, ULONG size )
3603 {
3604 WS_XML_UTF8_TEXT *utf8;
3605 HRESULT hr;
3606 INT64 val = 0;
3607 BOOL found;
3608
3609 if (desc)
3610 {
3611 FIXME( "description not supported\n" );
3612 return E_NOTIMPL;
3613 }
3614 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3615 if (found && (hr = str_to_int64( utf8->value.bytes, utf8->value.length, MIN_INT64, MAX_INT64, &val )) != S_OK)
3616 return hr;
3617
3618 switch (option)
3619 {
3620 case WS_READ_REQUIRED_VALUE:
3621 if (!found) return WS_E_INVALID_FORMAT;
3622 /* fall through */
3623
3624 case WS_READ_NILLABLE_VALUE:
3625 if (size != sizeof(INT64)) return E_INVALIDARG;
3626 *(INT64 *)ret = val;
3627 break;
3628
3629 case WS_READ_REQUIRED_POINTER:
3630 if (!found) return WS_E_INVALID_FORMAT;
3631 /* fall through */
3632
3633 case WS_READ_OPTIONAL_POINTER:
3634 case WS_READ_NILLABLE_POINTER:
3635 {
3636 INT64 *heap_val = NULL;
3637 if (size != sizeof(heap_val)) return E_INVALIDARG;
3638 if (found)
3639 {
3640 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3641 *heap_val = val;
3642 }
3643 *(INT64 **)ret = heap_val;
3644 break;
3645 }
3646 default:
3647 FIXME( "read option %u not supported\n", option );
3648 return E_NOTIMPL;
3649 }
3650
3651 return S_OK;
3652 }
3653
3654 static HRESULT read_type_uint8( struct reader *reader, WS_TYPE_MAPPING mapping,
3655 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3656 const WS_UINT8_DESCRIPTION *desc, WS_READ_OPTION option,
3657 WS_HEAP *heap, void *ret, ULONG size )
3658 {
3659 WS_XML_UTF8_TEXT *utf8;
3660 HRESULT hr;
3661 UINT64 val = 0;
3662 BOOL found;
3663
3664 if (desc)
3665 {
3666 FIXME( "description not supported\n" );
3667 return E_NOTIMPL;
3668 }
3669 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3670 if (found && (hr = str_to_uint64( utf8->value.bytes, utf8->value.length, MAX_UINT8, &val )) != S_OK)
3671 return hr;
3672
3673 switch (option)
3674 {
3675 case WS_READ_REQUIRED_VALUE:
3676 if (!found) return WS_E_INVALID_FORMAT;
3677 /* fall through */
3678
3679 case WS_READ_NILLABLE_VALUE:
3680 if (size != sizeof(UINT8)) return E_INVALIDARG;
3681 *(UINT8 *)ret = val;
3682 break;
3683
3684 case WS_READ_REQUIRED_POINTER:
3685 if (!found) return WS_E_INVALID_FORMAT;
3686 /* fall through */
3687
3688 case WS_READ_OPTIONAL_POINTER:
3689 case WS_READ_NILLABLE_POINTER:
3690 {
3691 UINT8 *heap_val = NULL;
3692 if (size != sizeof(heap_val)) return E_INVALIDARG;
3693 if (found)
3694 {
3695 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3696 *heap_val = val;
3697 }
3698 *(UINT8 **)ret = heap_val;
3699 break;
3700 }
3701 default:
3702 FIXME( "read option %u not supported\n", option );
3703 return E_NOTIMPL;
3704 }
3705
3706 return S_OK;
3707 }
3708
3709 static HRESULT read_type_uint16( struct reader *reader, WS_TYPE_MAPPING mapping,
3710 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3711 const WS_UINT16_DESCRIPTION *desc, WS_READ_OPTION option,
3712 WS_HEAP *heap, void *ret, ULONG size )
3713 {
3714 WS_XML_UTF8_TEXT *utf8;
3715 HRESULT hr;
3716 UINT64 val = 0;
3717 BOOL found;
3718
3719 if (desc)
3720 {
3721 FIXME( "description not supported\n" );
3722 return E_NOTIMPL;
3723 }
3724 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3725 if (found && (hr = str_to_uint64( utf8->value.bytes, utf8->value.length, MAX_UINT16, &val )) != S_OK)
3726 return hr;
3727
3728 switch (option)
3729 {
3730 case WS_READ_REQUIRED_VALUE:
3731 if (!found) return WS_E_INVALID_FORMAT;
3732 /* fall through */
3733
3734 case WS_READ_NILLABLE_VALUE:
3735 if (size != sizeof(UINT16)) return E_INVALIDARG;
3736 *(UINT16 *)ret = val;
3737 break;
3738
3739 case WS_READ_REQUIRED_POINTER:
3740 if (!found) return WS_E_INVALID_FORMAT;
3741 /* fall through */
3742
3743 case WS_READ_OPTIONAL_POINTER:
3744 case WS_READ_NILLABLE_POINTER:
3745 {
3746 UINT16 *heap_val = NULL;
3747 if (size != sizeof(heap_val)) return E_INVALIDARG;
3748 if (found)
3749 {
3750 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3751 *heap_val = val;
3752 }
3753 *(UINT16 **)ret = heap_val;
3754 break;
3755 }
3756 default:
3757 FIXME( "read option %u not supported\n", option );
3758 return E_NOTIMPL;
3759 }
3760
3761 return S_OK;
3762 }
3763
3764 static HRESULT read_type_uint32( struct reader *reader, WS_TYPE_MAPPING mapping,
3765 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3766 const WS_UINT32_DESCRIPTION *desc, WS_READ_OPTION option,
3767 WS_HEAP *heap, void *ret, ULONG size )
3768 {
3769 WS_XML_UTF8_TEXT *utf8;
3770 HRESULT hr;
3771 UINT64 val = 0;
3772 BOOL found;
3773
3774 if (desc)
3775 {
3776 FIXME( "description not supported\n" );
3777 return E_NOTIMPL;
3778 }
3779 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3780 if (found && (hr = str_to_uint64( utf8->value.bytes, utf8->value.length, MAX_UINT32, &val )) != S_OK)
3781 return hr;
3782
3783 switch (option)
3784 {
3785 case WS_READ_REQUIRED_VALUE:
3786 if (!found) return WS_E_INVALID_FORMAT;
3787 /* fall through */
3788
3789 case WS_READ_NILLABLE_VALUE:
3790 if (size != sizeof(UINT32)) return E_INVALIDARG;
3791 *(UINT32 *)ret = val;
3792 break;
3793
3794 case WS_READ_REQUIRED_POINTER:
3795 if (!found) return WS_E_INVALID_FORMAT;
3796 /* fall through */
3797
3798 case WS_READ_OPTIONAL_POINTER:
3799 case WS_READ_NILLABLE_POINTER:
3800 {
3801 UINT32 *heap_val = NULL;
3802 if (size != sizeof(heap_val)) return E_INVALIDARG;
3803 if (found)
3804 {
3805 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3806 *heap_val = val;
3807 }
3808 *(UINT32 **)ret = heap_val;
3809 break;
3810 }
3811 default:
3812 FIXME( "read option %u not supported\n", option );
3813 return E_NOTIMPL;
3814 }
3815
3816 return S_OK;
3817 }
3818
3819 static HRESULT read_type_uint64( struct reader *reader, WS_TYPE_MAPPING mapping,
3820 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3821 const WS_UINT64_DESCRIPTION *desc, WS_READ_OPTION option,
3822 WS_HEAP *heap, void *ret, ULONG size )
3823 {
3824 WS_XML_UTF8_TEXT *utf8;
3825 HRESULT hr;
3826 UINT64 val = 0;
3827 BOOL found;
3828
3829 if (desc)
3830 {
3831 FIXME( "description not supported\n" );
3832 return E_NOTIMPL;
3833 }
3834 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3835 if (found && (hr = str_to_uint64( utf8->value.bytes, utf8->value.length, MAX_UINT64, &val )) != S_OK)
3836 return hr;
3837
3838 switch (option)
3839 {
3840 case WS_READ_REQUIRED_VALUE:
3841 if (!found) return WS_E_INVALID_FORMAT;
3842 /* fall through */
3843
3844 case WS_READ_NILLABLE_VALUE:
3845 if (size != sizeof(UINT64)) return E_INVALIDARG;
3846 *(UINT64 *)ret = val;
3847 break;
3848
3849 case WS_READ_REQUIRED_POINTER:
3850 if (!found) return WS_E_INVALID_FORMAT;
3851 /* fall through */
3852
3853 case WS_READ_OPTIONAL_POINTER:
3854 case WS_READ_NILLABLE_POINTER:
3855 {
3856 UINT64 *heap_val = NULL;
3857 if (size != sizeof(heap_val)) return E_INVALIDARG;
3858 if (found)
3859 {
3860 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3861 *heap_val = val;
3862 }
3863 *(UINT64 **)ret = heap_val;
3864 break;
3865 }
3866 default:
3867 FIXME( "read option %u not supported\n", option );
3868 return E_NOTIMPL;
3869 }
3870
3871 return S_OK;
3872 }
3873
3874 static HRESULT read_type_double( struct reader *reader, WS_TYPE_MAPPING mapping,
3875 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3876 const WS_DOUBLE_DESCRIPTION *desc, WS_READ_OPTION option,
3877 WS_HEAP *heap, void *ret, ULONG size )
3878 {
3879 WS_XML_UTF8_TEXT *utf8;
3880 HRESULT hr;
3881 double val = 0.0;
3882 BOOL found;
3883
3884 if (desc) FIXME( "ignoring description\n" );
3885
3886 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3887 if (found && (hr = str_to_double( utf8->value.bytes, utf8->value.length, &val )) != S_OK) return hr;
3888
3889 switch (option)
3890 {
3891 case WS_READ_REQUIRED_VALUE:
3892 if (!found) return WS_E_INVALID_FORMAT;
3893 /* fall through */
3894
3895 case WS_READ_NILLABLE_VALUE:
3896 if (size != sizeof(double)) return E_INVALIDARG;
3897 *(double *)ret = val;
3898 break;
3899
3900 case WS_READ_REQUIRED_POINTER:
3901 if (!found) return WS_E_INVALID_FORMAT;
3902 /* fall through */
3903
3904 case WS_READ_OPTIONAL_POINTER:
3905 case WS_READ_NILLABLE_POINTER:
3906 {
3907 double *heap_val = NULL;
3908 if (size != sizeof(heap_val)) return E_INVALIDARG;
3909 if (found)
3910 {
3911 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
3912 *heap_val = val;
3913 }
3914 *(double **)ret = heap_val;
3915 break;
3916 }
3917 default:
3918 FIXME( "read option %u not supported\n", option );
3919 return E_NOTIMPL;
3920 }
3921
3922 return S_OK;
3923 }
3924
3925 static HRESULT read_type_wsz( struct reader *reader, WS_TYPE_MAPPING mapping,
3926 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3927 const WS_WSZ_DESCRIPTION *desc, WS_READ_OPTION option,
3928 WS_HEAP *heap, WCHAR **ret, ULONG size )
3929 {
3930 WS_XML_UTF8_TEXT *utf8;
3931 HRESULT hr;
3932 WCHAR *str = NULL;
3933 BOOL found;
3934
3935 if (desc)
3936 {
3937 FIXME( "description not supported\n" );
3938 return E_NOTIMPL;
3939 }
3940 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3941 if (found && !(str = xmltext_to_widechar( heap, &utf8->text ))) return WS_E_QUOTA_EXCEEDED;
3942
3943 switch (option)
3944 {
3945 case WS_READ_REQUIRED_POINTER:
3946 if (!found) return WS_E_INVALID_FORMAT;
3947 /* fall through */
3948
3949 case WS_READ_OPTIONAL_POINTER:
3950 case WS_READ_NILLABLE_POINTER:
3951 if (size != sizeof(str)) return E_INVALIDARG;
3952 *ret = str;
3953 break;
3954
3955 default:
3956 FIXME( "read option %u not supported\n", option );
3957 return E_NOTIMPL;
3958 }
3959
3960 return S_OK;
3961 }
3962
3963 static HRESULT get_enum_value( const WS_XML_UTF8_TEXT *text, const WS_ENUM_DESCRIPTION *desc, int *ret )
3964 {
3965 ULONG i;
3966 for (i = 0; i < desc->valueCount; i++)
3967 {
3968 if (WsXmlStringEquals( &text->value, desc->values[i].name, NULL ) == S_OK)
3969 {
3970 *ret = desc->values[i].value;
3971 return S_OK;
3972 }
3973 }
3974 return WS_E_INVALID_FORMAT;
3975 }
3976
3977 static HRESULT read_type_enum( struct reader *reader, WS_TYPE_MAPPING mapping,
3978 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
3979 const WS_ENUM_DESCRIPTION *desc, WS_READ_OPTION option,
3980 WS_HEAP *heap, void *ret, ULONG size )
3981 {
3982 WS_XML_UTF8_TEXT *utf8;
3983 HRESULT hr;
3984 int val = 0;
3985 BOOL found;
3986
3987 if (!desc) return E_INVALIDARG;
3988
3989 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
3990 if (found && (hr = get_enum_value( utf8, desc, &val )) != S_OK) return hr;
3991
3992 switch (option)
3993 {
3994 case WS_READ_REQUIRED_VALUE:
3995 if (!found) return WS_E_INVALID_FORMAT;
3996 /* fall through */
3997
3998 case WS_READ_NILLABLE_VALUE:
3999 if (size != sizeof(int)) return E_INVALIDARG;
4000 *(int *)ret = val;
4001 break;
4002
4003 case WS_READ_REQUIRED_POINTER:
4004 if (!found) return WS_E_INVALID_FORMAT;
4005 /* fall through */
4006
4007 case WS_READ_OPTIONAL_POINTER:
4008 case WS_READ_NILLABLE_POINTER:
4009 {
4010 int *heap_val = NULL;
4011 if (size != sizeof(heap_val)) return E_INVALIDARG;
4012 if (found)
4013 {
4014 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
4015 *heap_val = val;
4016 }
4017 *(int **)ret = heap_val;
4018 break;
4019 }
4020 default:
4021 FIXME( "read option %u not supported\n", option );
4022 return E_NOTIMPL;
4023 }
4024
4025 return S_OK;
4026 }
4027
4028 static HRESULT read_type_datetime( struct reader *reader, WS_TYPE_MAPPING mapping,
4029 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
4030 const WS_DATETIME_DESCRIPTION *desc, WS_READ_OPTION option,
4031 WS_HEAP *heap, void *ret, ULONG size )
4032 {
4033 WS_XML_UTF8_TEXT *utf8;
4034 HRESULT hr;
4035 WS_DATETIME val = {0, WS_DATETIME_FORMAT_UTC};
4036 BOOL found;
4037
4038 if (desc) FIXME( "ignoring description\n" );
4039
4040 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
4041 if (found && (hr = str_to_datetime( utf8->value.bytes, utf8->value.length, &val )) != S_OK) return hr;
4042
4043 switch (option)
4044 {
4045 case WS_READ_REQUIRED_VALUE:
4046 if (!found) return WS_E_INVALID_FORMAT;
4047 /* fall through */
4048
4049 case WS_READ_NILLABLE_VALUE:
4050 if (size != sizeof(WS_DATETIME)) return E_INVALIDARG;
4051 *(WS_DATETIME *)ret = val;
4052 break;
4053
4054 case WS_READ_REQUIRED_POINTER:
4055 if (!found) return WS_E_INVALID_FORMAT;
4056 /* fall through */
4057
4058 case WS_READ_OPTIONAL_POINTER:
4059 case WS_READ_NILLABLE_POINTER:
4060 {
4061 WS_DATETIME *heap_val = NULL;
4062 if (size != sizeof(heap_val)) return E_INVALIDARG;
4063 if (found)
4064 {
4065 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
4066 *heap_val = val;
4067 }
4068 *(WS_DATETIME **)ret = heap_val;
4069 break;
4070 }
4071 default:
4072 FIXME( "read option %u not supported\n", option );
4073 return E_NOTIMPL;
4074 }
4075
4076 return S_OK;
4077 }
4078
4079 static HRESULT read_type_guid( struct reader *reader, WS_TYPE_MAPPING mapping,
4080 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
4081 const WS_GUID_DESCRIPTION *desc, WS_READ_OPTION option,
4082 WS_HEAP *heap, void *ret, ULONG size )
4083 {
4084 WS_XML_UTF8_TEXT *utf8;
4085 GUID val = {0};
4086 HRESULT hr;
4087 BOOL found;
4088
4089 if (desc) FIXME( "ignoring description\n" );
4090
4091 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
4092 if (found && (hr = str_to_guid( utf8->value.bytes, utf8->value.length, &val )) != S_OK) return hr;
4093
4094 switch (option)
4095 {
4096 case WS_READ_REQUIRED_VALUE:
4097 if (!found) return WS_E_INVALID_FORMAT;
4098 /* fall through */
4099
4100 case WS_READ_NILLABLE_VALUE:
4101 if (size != sizeof(GUID)) return E_INVALIDARG;
4102 *(GUID *)ret = val;
4103 break;
4104
4105 case WS_READ_REQUIRED_POINTER:
4106 if (!found) return WS_E_INVALID_FORMAT;
4107 /* fall through */
4108
4109 case WS_READ_OPTIONAL_POINTER:
4110 case WS_READ_NILLABLE_POINTER:
4111 {
4112 GUID *heap_val = NULL;
4113 if (size != sizeof(heap_val)) return E_INVALIDARG;
4114 if (found)
4115 {
4116 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
4117 *heap_val = val;
4118 }
4119 *(GUID **)ret = heap_val;
4120 break;
4121 }
4122 default:
4123 FIXME( "read option %u not supported\n", option );
4124 return E_NOTIMPL;
4125 }
4126
4127 return S_OK;
4128 }
4129
4130 static HRESULT read_type_bytes( struct reader *reader, WS_TYPE_MAPPING mapping,
4131 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
4132 const WS_BYTES_DESCRIPTION *desc, WS_READ_OPTION option,
4133 WS_HEAP *heap, void *ret, ULONG size )
4134 {
4135 WS_XML_UTF8_TEXT *utf8;
4136 WS_BYTES val = {0};
4137 HRESULT hr;
4138 BOOL found;
4139
4140 if (desc) FIXME( "ignoring description\n" );
4141
4142 if ((hr = read_get_text( reader, mapping, localname, ns, &utf8, &found )) != S_OK) return hr;
4143 if (found && (hr = str_to_bytes( utf8->value.bytes, utf8->value.length, heap, &val )) != S_OK)
4144 return hr;
4145
4146 switch (option)
4147 {
4148 case WS_READ_REQUIRED_VALUE:
4149 if (!found) return WS_E_INVALID_FORMAT;
4150 /* fall through */
4151
4152 case WS_READ_NILLABLE_VALUE:
4153 if (size != sizeof(WS_BYTES)) return E_INVALIDARG;
4154 *(WS_BYTES *)ret = val;
4155 break;
4156
4157 case WS_READ_REQUIRED_POINTER:
4158 if (!found) return WS_E_INVALID_FORMAT;
4159 /* fall through */
4160
4161 case WS_READ_OPTIONAL_POINTER:
4162 case WS_READ_NILLABLE_POINTER:
4163 {
4164 WS_BYTES *heap_val = NULL;
4165 if (size != sizeof(heap_val)) return E_INVALIDARG;
4166 if (found)
4167 {
4168 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
4169 *heap_val = val;
4170 }
4171 *(WS_BYTES **)ret = heap_val;
4172 break;
4173 }
4174 default:
4175 FIXME( "read option %u not supported\n", option );
4176 return E_NOTIMPL;
4177 }
4178
4179 return S_OK;
4180 }
4181
4182 static BOOL is_empty_text_node( const struct node *node )
4183 {
4184 const WS_XML_TEXT_NODE *text = (const WS_XML_TEXT_NODE *)node;
4185 const WS_XML_UTF8_TEXT *utf8;
4186 ULONG i;
4187
4188 if (node_type( node ) != WS_XML_NODE_TYPE_TEXT) return FALSE;
4189 if (text->text->textType != WS_XML_TEXT_TYPE_UTF8)
4190 {
4191 ERR( "unhandled text type %u\n", text->text->textType );
4192 return FALSE;
4193 }
4194 utf8 = (const WS_XML_UTF8_TEXT *)text->text;
4195 for (i = 0; i < utf8->value.length; i++) if (!read_isspace( utf8->value.bytes[i] )) return FALSE;
4196 return TRUE;
4197 }
4198
4199 static HRESULT read_next_node( struct reader *reader )
4200 {
4201 if (reader->current == reader->last) return read_node( reader );
4202 if (move_to_child_node( &reader->current )) return S_OK;
4203 if (move_to_next_node( &reader->current )) return S_OK;
4204 if (!move_to_parent_node( &reader->current )) return WS_E_INVALID_FORMAT;
4205 if (move_to_next_node( &reader->current )) return S_OK;
4206 return WS_E_INVALID_FORMAT;
4207 }
4208
4209 /* skips comment and empty text nodes */
4210 static HRESULT read_type_next_node( struct reader *reader )
4211 {
4212 for (;;)
4213 {
4214 HRESULT hr;
4215 WS_XML_NODE_TYPE type;
4216
4217 if ((hr = read_next_node( reader )) != S_OK) return hr;
4218 type = node_type( reader->current );
4219 if (type == WS_XML_NODE_TYPE_COMMENT ||
4220 (type == WS_XML_NODE_TYPE_TEXT && is_empty_text_node( reader->current ))) continue;
4221 return S_OK;
4222 }
4223 }
4224
4225 static BOOL match_current_element( struct reader *reader, const WS_XML_STRING *localname,
4226 const WS_XML_STRING *ns )
4227 {
4228 const WS_XML_ELEMENT_NODE *elem = &reader->current->hdr;
4229 if (node_type( reader->current ) != WS_XML_NODE_TYPE_ELEMENT) return FALSE;
4230 return WsXmlStringEquals( localname, elem->localName, NULL ) == S_OK &&
4231 WsXmlStringEquals( ns, elem->ns, NULL ) == S_OK;
4232 }
4233
4234 static HRESULT read_type_next_element_node( struct reader *reader, const WS_XML_STRING *localname,
4235 const WS_XML_STRING *ns )
4236 {
4237 struct node *node;
4238 ULONG attr;
4239 HRESULT hr;
4240
4241 if (!localname) return S_OK; /* assume reader is already correctly positioned */
4242 if (reader->current == reader->last)
4243 {
4244 BOOL found;
4245 if ((hr = read_to_startelement( reader, &found )) != S_OK) return hr;
4246 if (!found) return WS_E_INVALID_FORMAT;
4247 }
4248 if (match_current_element( reader, localname, ns )) return S_OK;
4249
4250 node = reader->current;
4251 attr = reader->current_attr;
4252
4253 if ((hr = read_type_next_node( reader )) != S_OK) return hr;
4254 if (match_current_element( reader, localname, ns )) return S_OK;
4255
4256 reader->current = node;
4257 reader->current_attr = attr;
4258
4259 return WS_E_INVALID_FORMAT;
4260 }
4261
4262 ULONG get_type_size( WS_TYPE type, const WS_STRUCT_DESCRIPTION *desc )
4263 {
4264 switch (type)
4265 {
4266 case WS_INT8_TYPE:
4267 case WS_UINT8_TYPE:
4268 return sizeof(INT8);
4269
4270 case WS_INT16_TYPE:
4271 case WS_UINT16_TYPE:
4272 return sizeof(INT16);
4273
4274 case WS_BOOL_TYPE:
4275 case WS_INT32_TYPE:
4276 case WS_UINT32_TYPE:
4277 case WS_ENUM_TYPE:
4278 return sizeof(INT32);
4279
4280 case WS_INT64_TYPE:
4281 case WS_UINT64_TYPE:
4282 return sizeof(INT64);
4283
4284 case WS_DOUBLE_TYPE:
4285 return sizeof(double);
4286
4287 case WS_DATETIME_TYPE:
4288 return sizeof(WS_DATETIME);
4289
4290 case WS_GUID_TYPE:
4291 return sizeof(GUID);
4292
4293 case WS_STRING_TYPE:
4294 return sizeof(WS_STRING);
4295
4296 case WS_WSZ_TYPE:
4297 return sizeof(WCHAR *);
4298
4299 case WS_BYTES_TYPE:
4300 return sizeof(WS_BYTES);
4301
4302 case WS_XML_STRING_TYPE:
4303 return sizeof(WS_XML_STRING);
4304
4305 case WS_STRUCT_TYPE:
4306 return desc->size;
4307
4308 case WS_DESCRIPTION_TYPE:
4309 return sizeof(WS_STRUCT_DESCRIPTION *);
4310
4311 default:
4312 ERR( "unhandled type %u\n", type );
4313 return 0;
4314 }
4315 }
4316
4317 static WS_READ_OPTION get_field_read_option( WS_TYPE type, ULONG options )
4318 {
4319 if (options & WS_FIELD_POINTER)
4320 {
4321 if (options & WS_FIELD_NILLABLE) return WS_READ_NILLABLE_POINTER;
4322 if (options & WS_FIELD_OPTIONAL) return WS_READ_OPTIONAL_POINTER;
4323 return WS_READ_REQUIRED_POINTER;
4324 }
4325
4326 switch (type)
4327 {
4328 case WS_BOOL_TYPE:
4329 case WS_INT8_TYPE:
4330 case WS_INT16_TYPE:
4331 case WS_INT32_TYPE:
4332 case WS_INT64_TYPE:
4333 case WS_UINT8_TYPE:
4334 case WS_UINT16_TYPE:
4335 case WS_UINT32_TYPE:
4336 case WS_UINT64_TYPE:
4337 case WS_DOUBLE_TYPE:
4338 case WS_DATETIME_TYPE:
4339 case WS_GUID_TYPE:
4340 case WS_STRING_TYPE:
4341 case WS_BYTES_TYPE:
4342 case WS_XML_STRING_TYPE:
4343 case WS_STRUCT_TYPE:
4344 case WS_ENUM_TYPE:
4345 if (options & (WS_FIELD_OPTIONAL|WS_FIELD_NILLABLE)) return WS_READ_NILLABLE_VALUE;
4346 return WS_READ_REQUIRED_VALUE;
4347
4348 case WS_WSZ_TYPE:
4349 case WS_DESCRIPTION_TYPE:
4350 if (options & WS_FIELD_NILLABLE) return WS_READ_NILLABLE_POINTER;
4351 if (options & WS_FIELD_OPTIONAL) return WS_READ_OPTIONAL_POINTER;
4352 return WS_READ_REQUIRED_POINTER;
4353
4354 default:
4355 FIXME( "unhandled type %u\n", type );
4356 return 0;
4357 }
4358 }
4359
4360 static HRESULT read_type( struct reader *, WS_TYPE_MAPPING, WS_TYPE, const WS_XML_STRING *,
4361 const WS_XML_STRING *, const void *, WS_READ_OPTION, WS_HEAP *,
4362 void *, ULONG );
4363
4364 static HRESULT read_type_repeating_element( struct reader *reader, const WS_FIELD_DESCRIPTION *desc,
4365 WS_HEAP *heap, void **ret, ULONG *count )
4366 {
4367 HRESULT hr;
4368 ULONG item_size, nb_items = 0, nb_allocated = 1, offset = 0;
4369 WS_READ_OPTION option;
4370 char *buf;
4371
4372 if (!(option = get_field_read_option( desc->type, desc->options ))) return E_INVALIDARG;
4373
4374 /* wrapper element */
4375 if (desc->localName && ((hr = read_type_next_element_node( reader, desc->localName, desc->ns )) != S_OK))
4376 return hr;
4377
4378 if (option == WS_READ_REQUIRED_VALUE || option == WS_READ_NILLABLE_VALUE)
4379 item_size = get_type_size( desc->type, desc->typeDescription );
4380 else
4381 item_size = sizeof(void *);
4382
4383 if (!(buf = ws_alloc_zero( heap, item_size ))) return WS_E_QUOTA_EXCEEDED;
4384 for (;;)
4385 {
4386 if (nb_items >= nb_allocated)
4387 {
4388 SIZE_T old_size = nb_allocated * item_size, new_size = old_size * 2;
4389 if (!(buf = ws_realloc_zero( heap, buf, old_size, new_size )))
4390 return WS_E_QUOTA_EXCEEDED;
4391 nb_allocated *= 2;
4392 }
4393 hr = read_type( reader, WS_ELEMENT_TYPE_MAPPING, desc->type, desc->itemLocalName, desc->itemNs,
4394 desc->typeDescription, option, heap, buf + offset, item_size );
4395 if (hr == WS_E_INVALID_FORMAT) break;
4396 if (hr != S_OK)
4397 {
4398 ws_free( heap, buf, nb_allocated * item_size );
4399 return hr;
4400 }
4401 offset += item_size;
4402 nb_items++;
4403 }
4404
4405 if (desc->localName && ((hr = read_type_next_node( reader )) != S_OK)) return hr;
4406
4407 if (desc->itemRange && (nb_items < desc->itemRange->minItemCount || nb_items > desc->itemRange->maxItemCount))
4408 {
4409 TRACE( "number of items %u out of range (%u-%u)\n", nb_items, desc->itemRange->minItemCount,
4410 desc->itemRange->maxItemCount );
4411 ws_free( heap, buf, nb_allocated * item_size );
4412 return WS_E_INVALID_FORMAT;
4413 }
4414
4415 *count = nb_items;
4416 *ret = buf;
4417
4418 return S_OK;
4419 }
4420
4421 static HRESULT read_type_text( struct reader *reader, const WS_FIELD_DESCRIPTION *desc,
4422 WS_READ_OPTION option, WS_HEAP *heap, void *ret, ULONG size )
4423 {
4424 HRESULT hr;
4425 if (reader->current == reader->last)
4426 {
4427 BOOL found;
4428 if ((hr = read_to_startelement( reader, &found )) != S_OK) return S_OK;
4429 if (!found) return WS_E_INVALID_FORMAT;
4430 }
4431 if ((hr = read_next_node( reader )) != S_OK) return hr;
4432 if (node_type( reader->current ) != WS_XML_NODE_TYPE_TEXT) return WS_E_INVALID_FORMAT;
4433
4434 return read_type( reader, WS_ANY_ELEMENT_TYPE_MAPPING, desc->type, NULL, NULL,
4435 desc->typeDescription, option, heap, ret, size );
4436 }
4437
4438 static HRESULT read_type_struct_field( struct reader *reader, const WS_FIELD_DESCRIPTION *desc,
4439 WS_HEAP *heap, char *buf, ULONG offset )
4440 {
4441 char *ptr;
4442 WS_READ_OPTION option;
4443 ULONG size;
4444 HRESULT hr;
4445
4446 if (!desc) return E_INVALIDARG;
4447 if (desc->options & ~(WS_FIELD_POINTER|WS_FIELD_OPTIONAL|WS_FIELD_NILLABLE|WS_FIELD_NILLABLE_ITEM))
4448 {
4449 FIXME( "options %08x not supported\n", desc->options );
4450 return E_NOTIMPL;
4451 }
4452 if (!(option = get_field_read_option( desc->type, desc->options ))) return E_INVALIDARG;
4453
4454 if (option == WS_READ_REQUIRED_VALUE || option == WS_READ_NILLABLE_VALUE)
4455 size = get_type_size( desc->type, desc->typeDescription );
4456 else
4457 size = sizeof(void *);
4458
4459 ptr = buf + offset;
4460 switch (desc->mapping)
4461 {
4462 case WS_TYPE_ATTRIBUTE_FIELD_MAPPING:
4463 FIXME( "WS_TYPE_ATTRIBUTE_FIELD_MAPPING not supported\n" );
4464 return S_OK;
4465
4466 case WS_ATTRIBUTE_FIELD_MAPPING:
4467 hr = read_type( reader, WS_ATTRIBUTE_TYPE_MAPPING, desc->type, desc->localName, desc->ns,
4468 desc->typeDescription, option, heap, ptr, size );
4469 break;
4470
4471 case WS_ELEMENT_FIELD_MAPPING:
4472 hr = read_type( reader, WS_ELEMENT_TYPE_MAPPING, desc->type, desc->localName, desc->ns,
4473 desc->typeDescription, option, heap, ptr, size );
4474 break;
4475
4476 case WS_REPEATING_ELEMENT_FIELD_MAPPING:
4477 {
4478 ULONG count;
4479 hr = read_type_repeating_element( reader, desc, heap, (void **)ptr, &count );
4480 if (hr == S_OK) *(ULONG *)(buf + desc->countOffset) = count;
4481 break;
4482 }
4483 case WS_TEXT_FIELD_MAPPING:
4484 hr = read_type_text( reader, desc, option, heap, ptr, size );
4485 break;
4486
4487 default:
4488 FIXME( "unhandled field mapping %u\n", desc->mapping );
4489 return E_NOTIMPL;
4490 }
4491
4492 if (hr == WS_E_INVALID_FORMAT)
4493 {
4494 switch (option)
4495 {
4496 case WS_READ_REQUIRED_VALUE:
4497 case WS_READ_REQUIRED_POINTER:
4498 return WS_E_INVALID_FORMAT;
4499
4500 case WS_READ_NILLABLE_VALUE:
4501 if (desc->defaultValue) memcpy( ptr, desc->defaultValue->value, desc->defaultValue->valueSize );
4502 return S_OK;
4503
4504 case WS_READ_OPTIONAL_POINTER:
4505 case WS_READ_NILLABLE_POINTER:
4506 *(void **)ptr = NULL;
4507 return S_OK;
4508
4509 default:
4510 ERR( "unhandled option %u\n", option );
4511 return E_NOTIMPL;
4512 }
4513 }
4514
4515 return hr;
4516 }
4517
4518 static HRESULT read_type_struct( struct reader *reader, WS_TYPE_MAPPING mapping,
4519 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
4520 const WS_STRUCT_DESCRIPTION *desc, WS_READ_OPTION option,
4521 WS_HEAP *heap, void *ret, ULONG size )
4522 {
4523 ULONG i, offset;
4524 HRESULT hr;
4525 char *buf;
4526
4527 if (!desc) return E_INVALIDARG;
4528 if (desc->structOptions & ~WS_STRUCT_IGNORE_TRAILING_ELEMENT_CONTENT)
4529 {
4530 FIXME( "struct options %08x not supported\n",
4531 desc->structOptions & ~WS_STRUCT_IGNORE_TRAILING_ELEMENT_CONTENT );
4532 }
4533
4534 switch (option)
4535 {
4536 case WS_READ_REQUIRED_POINTER:
4537 case WS_READ_OPTIONAL_POINTER:
4538 case WS_READ_NILLABLE_POINTER:
4539 if (size != sizeof(void *)) return E_INVALIDARG;
4540 if (!(buf = ws_alloc_zero( heap, desc->size ))) return WS_E_QUOTA_EXCEEDED;
4541 break;
4542
4543 case WS_READ_REQUIRED_VALUE:
4544 case WS_READ_NILLABLE_VALUE:
4545 if (size != desc->size) return E_INVALIDARG;
4546 buf = ret;
4547 break;
4548
4549 default:
4550 FIXME( "unhandled read option %u\n", option );
4551 return E_NOTIMPL;
4552 }
4553
4554 for (i = 0; i < desc->fieldCount; i++)
4555 {
4556 offset = desc->fields[i]->offset;
4557 if ((hr = read_type_struct_field( reader, desc->fields[i], heap, buf, offset )) != S_OK)
4558 break;
4559 }
4560
4561 switch (option)
4562 {
4563 case WS_READ_REQUIRED_POINTER:
4564 if (hr != S_OK)
4565 {
4566 ws_free( heap, buf, desc->size );
4567 return hr;
4568 }
4569 *(char **)ret = buf;
4570 break;
4571
4572 case WS_READ_OPTIONAL_POINTER:
4573 case WS_READ_NILLABLE_POINTER:
4574 if (is_nil_value( buf, desc->size ))
4575 {
4576 ws_free( heap, buf, desc->size );
4577 buf = NULL;
4578 }
4579 *(char **)ret = buf;
4580 break;
4581
4582 case WS_READ_REQUIRED_VALUE:
4583 case WS_READ_NILLABLE_VALUE:
4584 if (hr != S_OK) return hr;
4585 break;
4586
4587 default:
4588 ERR( "unhandled read option %u\n", option );
4589 return E_NOTIMPL;
4590 }
4591
4592 if (desc->structOptions & WS_STRUCT_IGNORE_TRAILING_ELEMENT_CONTENT)
4593 {
4594 struct node *parent = find_parent( reader );
4595 parent->flags |= NODE_FLAG_IGNORE_TRAILING_ELEMENT_CONTENT;
4596 }
4597 return S_OK;
4598 }
4599
4600 static HRESULT start_mapping( struct reader *reader, WS_TYPE_MAPPING mapping, const WS_XML_STRING *localname,
4601 const WS_XML_STRING *ns )
4602 {
4603 switch (mapping)
4604 {
4605 case WS_ELEMENT_TYPE_MAPPING:
4606 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
4607 return read_type_next_element_node( reader, localname, ns );
4608
4609 case WS_ANY_ELEMENT_TYPE_MAPPING:
4610 case WS_ATTRIBUTE_TYPE_MAPPING:
4611 return S_OK;
4612
4613 default:
4614 FIXME( "unhandled mapping %u\n", mapping );
4615 return E_NOTIMPL;
4616 }
4617 }
4618
4619 static HRESULT read_type_endelement_node( struct reader *reader )
4620 {
4621 const struct node *parent = find_parent( reader );
4622 HRESULT hr;
4623
4624 for (;;)
4625 {
4626 if ((hr = read_type_next_node( reader )) != S_OK) return hr;
4627 if (node_type( reader->current ) == WS_XML_NODE_TYPE_END_ELEMENT && reader->current->parent == parent)
4628 {
4629 return S_OK;
4630 }
4631 if (read_end_of_data( reader ) || !(parent->flags & NODE_FLAG_IGNORE_TRAILING_ELEMENT_CONTENT)) break;
4632 }
4633
4634 return WS_E_INVALID_FORMAT;
4635 }
4636
4637 static HRESULT end_mapping( struct reader *reader, WS_TYPE_MAPPING mapping )
4638 {
4639 switch (mapping)
4640 {
4641 case WS_ELEMENT_TYPE_MAPPING:
4642 return read_type_endelement_node( reader );
4643
4644 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
4645 return read_type_next_node( reader );
4646
4647 case WS_ATTRIBUTE_TYPE_MAPPING:
4648 default:
4649 return S_OK;
4650 }
4651 }
4652
4653 static HRESULT is_nil_element( const WS_XML_ELEMENT_NODE *elem )
4654 {
4655 static const WS_XML_STRING localname = {3, (BYTE *)"nil"};
4656 static const WS_XML_STRING ns = {41, (BYTE *)"http://www.w3.org/2001/XMLSchema-instance"};
4657 ULONG i;
4658
4659 for (i = 0; i < elem->attributeCount; i++)
4660 {
4661 const WS_XML_UTF8_TEXT *text = (WS_XML_UTF8_TEXT *)elem->attributes[i]->value;
4662
4663 if (elem->attributes[i]->isXmlNs) continue;
4664 if (WsXmlStringEquals( elem->attributes[i]->localName, &localname, NULL ) == S_OK &&
4665 WsXmlStringEquals( elem->attributes[i]->ns, &ns, NULL ) == S_OK &&
4666 text->value.length == 4 && !memcmp( text->value.bytes, "true", 4 )) return TRUE;
4667 }
4668 return FALSE;
4669 }
4670
4671 static HRESULT read_type( struct reader *reader, WS_TYPE_MAPPING mapping, WS_TYPE type,
4672 const WS_XML_STRING *localname, const WS_XML_STRING *ns, const void *desc,
4673 WS_READ_OPTION option, WS_HEAP *heap, void *value, ULONG size )
4674 {
4675 HRESULT hr;
4676
4677 if ((hr = start_mapping( reader, mapping, localname, ns )) != S_OK) return hr;
4678
4679 if (mapping == WS_ELEMENT_TYPE_MAPPING && is_nil_element( &reader->current->hdr ))
4680 {
4681 if (option != WS_READ_NILLABLE_POINTER && option != WS_READ_NILLABLE_VALUE) return WS_E_INVALID_FORMAT;
4682 return end_mapping( reader, mapping );
4683 }
4684
4685 switch (type)
4686 {
4687 case WS_BOOL_TYPE:
4688 if ((hr = read_type_bool( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
4689 return hr;
4690 break;
4691
4692 case WS_INT8_TYPE:
4693 if ((hr = read_type_int8( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
4694 return hr;
4695 break;
4696
4697 case WS_INT16_TYPE:
4698 if ((hr = read_type_int16( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
4699 return hr;
4700 break;
4701
4702 case WS_INT32_TYPE:
4703 if ((hr = read_type_int32( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
4704 return hr;
4705 break;
4706
4707 case WS_INT64_TYPE:
4708 if ((hr = read_type_int64( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
4709 return hr;
4710 break;
4711
4712 case WS_UINT8_TYPE:
4713 if ((hr = read_type_uint8( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
4714 return hr;
4715 break;
4716
4717 case WS_UINT16_TYPE:
4718 if ((hr = read_type_uint16( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
4719 return hr;
4720 break;
4721
4722 case WS_UINT32_TYPE:
4723 if ((hr = read_type_uint32( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
4724 return hr;
4725 break;
4726
4727 case WS_UINT64_TYPE:
4728 if ((hr = read_type_uint64( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
4729 return hr;
4730 break;
4731
4732 case WS_DOUBLE_TYPE:
4733 if ((hr = read_type_double( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
4734 return hr;
4735 break;
4736
4737 case WS_DATETIME_TYPE:
4738 if ((hr = read_type_datetime( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
4739 return hr;
4740 break;
4741
4742 case WS_GUID_TYPE:
4743 if ((hr = read_type_guid( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
4744 return hr;
4745 break;
4746
4747 case WS_WSZ_TYPE:
4748 if ((hr = read_type_wsz( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
4749 return hr;
4750 break;
4751
4752 case WS_BYTES_TYPE:
4753 if ((hr = read_type_bytes( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
4754 return hr;
4755 break;
4756
4757 case WS_STRUCT_TYPE:
4758 if ((hr = read_type_struct( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
4759 return hr;
4760 break;
4761
4762 case WS_ENUM_TYPE:
4763 if ((hr = read_type_enum( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
4764 return hr;
4765 break;
4766
4767 default:
4768 FIXME( "type %u not supported\n", type );
4769 return E_NOTIMPL;
4770 }
4771
4772 return end_mapping( reader, mapping );
4773 }
4774
4775 /**************************************************************************
4776 * WsReadType [webservices.@]
4777 */
4778 HRESULT WINAPI WsReadType( WS_XML_READER *handle, WS_TYPE_MAPPING mapping, WS_TYPE type,
4779 const void *desc, WS_READ_OPTION option, WS_HEAP *heap, void *value,
4780 ULONG size, WS_ERROR *error )
4781 {
4782 struct reader *reader = (struct reader *)handle;
4783 HRESULT hr;
4784
4785 TRACE( "%p %u %u %p %u %p %p %u %p\n", handle, mapping, type, desc, option, heap, value,
4786 size, error );
4787 if (error) FIXME( "ignoring error parameter\n" );
4788
4789 if (!reader || !value) return E_INVALIDARG;
4790
4791 EnterCriticalSection( &reader->cs );
4792
4793 if (reader->magic != READER_MAGIC)
4794 {
4795 LeaveCriticalSection( &reader->cs );
4796 return E_INVALIDARG;
4797 }
4798
4799 if ((hr = read_type( reader, mapping, type, NULL, NULL, desc, option, heap, value, size )) != S_OK)
4800 {
4801 LeaveCriticalSection( &reader->cs );
4802 return hr;
4803 }
4804
4805 switch (mapping)
4806 {
4807 case WS_ELEMENT_TYPE_MAPPING:
4808 hr = read_node( reader );
4809 break;
4810
4811 default:
4812 break;
4813 }
4814
4815 if (hr == S_OK && !read_end_of_data( reader )) hr = WS_E_INVALID_FORMAT;
4816
4817 LeaveCriticalSection( &reader->cs );
4818 return hr;
4819 }
4820
4821 /**************************************************************************
4822 * WsReadElement [webservices.@]
4823 */
4824 HRESULT WINAPI WsReadElement( WS_XML_READER *handle, const WS_ELEMENT_DESCRIPTION *desc,
4825 WS_READ_OPTION option, WS_HEAP *heap, void *value, ULONG size,
4826 WS_ERROR *error )
4827 {
4828 struct reader *reader = (struct reader *)handle;
4829 HRESULT hr;
4830
4831 TRACE( "%p %p %u %p %p %u %p\n", handle, desc, option, heap, value, size, error );
4832 if (error) FIXME( "ignoring error parameter\n" );
4833
4834 if (!reader || !desc || !value) return E_INVALIDARG;
4835
4836 EnterCriticalSection( &reader->cs );
4837
4838 if (reader->magic != READER_MAGIC)
4839 {
4840 LeaveCriticalSection( &reader->cs );
4841 return E_INVALIDARG;
4842 }
4843
4844 hr = read_type( reader, WS_ELEMENT_TYPE_MAPPING, desc->type, desc->elementLocalName,
4845 desc->elementNs, desc->typeDescription, option, heap, value, size );
4846
4847 LeaveCriticalSection( &reader->cs );
4848 return hr;
4849 }
4850
4851 /**************************************************************************
4852 * WsReadValue [webservices.@]
4853 */
4854 HRESULT WINAPI WsReadValue( WS_XML_READER *handle, WS_VALUE_TYPE value_type, void *value, ULONG size,
4855 WS_ERROR *error )
4856 {
4857 struct reader *reader = (struct reader *)handle;
4858 WS_TYPE type = map_value_type( value_type );
4859 HRESULT hr;
4860
4861 TRACE( "%p %u %p %u %p\n", handle, type, value, size, error );
4862 if (error) FIXME( "ignoring error parameter\n" );
4863
4864 if (!reader || !value || type == ~0u) return E_INVALIDARG;
4865
4866 EnterCriticalSection( &reader->cs );
4867
4868 if (reader->magic != READER_MAGIC)
4869 {
4870 LeaveCriticalSection( &reader->cs );
4871 return E_INVALIDARG;
4872 }
4873
4874 hr = read_type( reader, WS_ELEMENT_TYPE_MAPPING, type, NULL, NULL, NULL, WS_READ_REQUIRED_VALUE,
4875 NULL, value, size );
4876
4877 LeaveCriticalSection( &reader->cs );
4878 return hr;
4879 }
4880
4881 /**************************************************************************
4882 * WsReadAttribute [webservices.@]
4883 */
4884 HRESULT WINAPI WsReadAttribute( WS_XML_READER *handle, const WS_ATTRIBUTE_DESCRIPTION *desc,
4885 WS_READ_OPTION option, WS_HEAP *heap, void *value, ULONG size,
4886 WS_ERROR *error )
4887 {
4888 struct reader *reader = (struct reader *)handle;
4889 HRESULT hr;
4890
4891 TRACE( "%p %p %u %p %p %u %p\n", handle, desc, option, heap, value, size, error );
4892 if (error) FIXME( "ignoring error parameter\n" );
4893
4894 if (!reader || !desc || !value) return E_INVALIDARG;
4895
4896 EnterCriticalSection( &reader->cs );
4897
4898 if (reader->magic != READER_MAGIC)
4899 {
4900 LeaveCriticalSection( &reader->cs );
4901 return E_INVALIDARG;
4902 }
4903
4904 if (!reader->input_type)
4905 {
4906 LeaveCriticalSection( &reader->cs );
4907 return WS_E_INVALID_OPERATION;
4908 }
4909
4910 hr = read_type( reader, WS_ATTRIBUTE_TYPE_MAPPING, desc->type, desc->attributeLocalName,
4911 desc->attributeNs, desc->typeDescription, option, heap, value, size );
4912
4913 LeaveCriticalSection( &reader->cs );
4914 return hr;
4915 }
4916
4917 static inline BOOL is_utf8( const unsigned char *data, ULONG size, ULONG *offset )
4918 {
4919 static const char bom[] = {0xef,0xbb,0xbf};
4920 const unsigned char *p = data;
4921
4922 return (size >= sizeof(bom) && !memcmp( p, bom, sizeof(bom) ) && (*offset = sizeof(bom))) ||
4923 (size > 2 && !(*offset = 0));
4924 }
4925
4926 static inline BOOL is_utf16le( const unsigned char *data, ULONG size, ULONG *offset )
4927 {
4928 static const char bom[] = {0xff,0xfe};
4929 const unsigned char *p = data;
4930
4931 return (size >= sizeof(bom) && !memcmp( p, bom, sizeof(bom) ) && (*offset = sizeof(bom))) ||
4932 (size >= 4 && p[0] == '<' && !p[1] && !(*offset = 0));
4933 }
4934
4935 static WS_CHARSET detect_charset( const unsigned char *data, ULONG size, ULONG *offset )
4936 {
4937 WS_CHARSET ret = 0;
4938
4939 /* FIXME: parse xml declaration */
4940
4941 if (is_utf16le( data, size, offset )) ret = WS_CHARSET_UTF16LE;
4942 else if (is_utf8( data, size, offset )) ret = WS_CHARSET_UTF8;
4943 else
4944 {
4945 FIXME( "charset not recognized\n" );
4946 return 0;
4947 }
4948
4949 TRACE( "detected charset %u\n", ret );
4950 return ret;
4951 }
4952
4953 static void set_input_buffer( struct reader *reader, struct xmlbuf *buf, const unsigned char *data, ULONG size )
4954 {
4955 reader->input_type = WS_XML_READER_INPUT_TYPE_BUFFER;
4956 reader->input_buf = buf;
4957 reader->input_data = data;
4958 reader->input_size = size;
4959
4960 reader->read_size = reader->input_size;
4961 reader->read_pos = 0;
4962 reader->read_bufptr = reader->input_data;
4963
4964 reader->text_conv_offset = 0;
4965 }
4966
4967 /**************************************************************************
4968 * WsSetInput [webservices.@]
4969 */
4970 HRESULT WINAPI WsSetInput( WS_XML_READER *handle, const WS_XML_READER_ENCODING *encoding,
4971 const WS_XML_READER_INPUT *input, const WS_XML_READER_PROPERTY *properties,
4972 ULONG count, WS_ERROR *error )
4973 {
4974 struct reader *reader = (struct reader *)handle;
4975 struct node *node;
4976 ULONG i, offset = 0;
4977 HRESULT hr;
4978
4979 TRACE( "%p %p %p %p %u %p\n", handle, encoding, input, properties, count, error );
4980 if (error) FIXME( "ignoring error parameter\n" );
4981
4982 if (!reader) return E_INVALIDARG;
4983
4984 EnterCriticalSection( &reader->cs );
4985
4986 if (reader->magic != READER_MAGIC)
4987 {
4988 LeaveCriticalSection( &reader->cs );
4989 return E_INVALIDARG;
4990 }
4991
4992 for (i = 0; i < count; i++)
4993 {
4994 hr = prop_set( reader->prop, reader->prop_count, properties[i].id, properties[i].value,
4995 properties[i].valueSize );
4996 if (hr != S_OK) goto done;
4997 }
4998
4999 if ((hr = init_reader( reader )) != S_OK) goto done;
5000
5001 switch (encoding->encodingType)
5002 {
5003 case WS_XML_READER_ENCODING_TYPE_TEXT:
5004 {
5005 WS_XML_READER_TEXT_ENCODING *text = (WS_XML_READER_TEXT_ENCODING *)encoding;
5006 WS_XML_READER_BUFFER_INPUT *buf = (WS_XML_READER_BUFFER_INPUT *)input;
5007 WS_CHARSET charset = text->charSet;
5008
5009 if (input->inputType != WS_XML_READER_INPUT_TYPE_BUFFER)
5010 {
5011 FIXME( "charset detection on input type %u not supported\n", input->inputType );
5012 hr = E_NOTIMPL;
5013 goto done;
5014 }
5015
5016 if (charset == WS_CHARSET_AUTO)
5017 charset = detect_charset( buf->encodedData, buf->encodedDataSize, &offset );
5018
5019 hr = prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_CHARSET,
5020 &charset, sizeof(charset) );
5021 if (hr != S_OK) goto done;
5022
5023 reader->input_enc = WS_XML_READER_ENCODING_TYPE_TEXT;
5024 break;
5025 }
5026 case WS_XML_READER_ENCODING_TYPE_BINARY:
5027 reader->input_enc = WS_XML_READER_ENCODING_TYPE_BINARY;
5028 break;
5029
5030 default:
5031 FIXME( "encoding type %u not supported\n", encoding->encodingType );
5032 hr = E_NOTIMPL;
5033 goto done;
5034 }
5035
5036 switch (input->inputType)
5037 {
5038 case WS_XML_READER_INPUT_TYPE_BUFFER:
5039 {
5040 WS_XML_READER_BUFFER_INPUT *buf = (WS_XML_READER_BUFFER_INPUT *)input;
5041 set_input_buffer( reader, NULL, (const unsigned char *)buf->encodedData + offset,
5042 buf->encodedDataSize - offset );
5043 break;
5044 }
5045 default:
5046 FIXME( "input type %u not supported\n", input->inputType );
5047 hr = E_NOTIMPL;
5048 goto done;
5049 }
5050
5051 if (!(node = alloc_node( WS_XML_NODE_TYPE_BOF ))) hr = E_OUTOFMEMORY;
5052 else read_insert_bof( reader, node );
5053
5054 done:
5055 LeaveCriticalSection( &reader->cs );
5056 return hr;
5057 }
5058
5059 /**************************************************************************
5060 * WsSetInputToBuffer [webservices.@]
5061 */
5062 HRESULT WINAPI WsSetInputToBuffer( WS_XML_READER *handle, WS_XML_BUFFER *buffer,
5063 const WS_XML_READER_PROPERTY *properties, ULONG count,
5064 WS_ERROR *error )
5065 {
5066 struct reader *reader = (struct reader *)handle;
5067 struct xmlbuf *xmlbuf = (struct xmlbuf *)buffer;
5068 WS_CHARSET charset;
5069 struct node *node;
5070 ULONG i, offset = 0;
5071 HRESULT hr;
5072
5073 TRACE( "%p %p %p %u %p\n", handle, buffer, properties, count, error );
5074 if (error) FIXME( "ignoring error parameter\n" );
5075
5076 if (!reader || !xmlbuf) return E_INVALIDARG;
5077
5078 EnterCriticalSection( &reader->cs );
5079
5080 if (reader->magic != READER_MAGIC)
5081 {
5082 LeaveCriticalSection( &reader->cs );
5083 return E_INVALIDARG;
5084 }
5085
5086 for (i = 0; i < count; i++)
5087 {
5088 hr = prop_set( reader->prop, reader->prop_count, properties[i].id, properties[i].value,
5089 properties[i].valueSize );
5090 if (hr != S_OK) goto done;
5091 }
5092
5093 if ((hr = init_reader( reader )) != S_OK) goto done;
5094
5095 charset = detect_charset( xmlbuf->bytes.bytes, xmlbuf->bytes.length, &offset );
5096 hr = prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_CHARSET, &charset,
5097 sizeof(charset) );
5098 if (hr != S_OK) goto done;
5099
5100 set_input_buffer( reader, xmlbuf, xmlbuf->bytes.bytes + offset, xmlbuf->bytes.length - offset );
5101 if (!(node = alloc_node( WS_XML_NODE_TYPE_BOF ))) hr = E_OUTOFMEMORY;
5102 else read_insert_bof( reader, node );
5103
5104 done:
5105 LeaveCriticalSection( &reader->cs );
5106 return hr;
5107 }
5108
5109 /**************************************************************************
5110 * WsXmlStringEquals [webservices.@]
5111 */
5112 HRESULT WINAPI WsXmlStringEquals( const WS_XML_STRING *str1, const WS_XML_STRING *str2, WS_ERROR *error )
5113 {
5114 TRACE( "%s %s %p\n", debugstr_xmlstr(str1), debugstr_xmlstr(str2), error );
5115 if (error) FIXME( "ignoring error parameter\n" );
5116
5117 if (!str1 || !str2) return E_INVALIDARG;
5118
5119 if (str1->length != str2->length) return S_FALSE;
5120 if (!memcmp( str1->bytes, str2->bytes, str1->length )) return S_OK;
5121 return S_FALSE;
5122 }
5123
5124 /**************************************************************************
5125 * WsGetReaderPosition [webservices.@]
5126 */
5127 HRESULT WINAPI WsGetReaderPosition( WS_XML_READER *handle, WS_XML_NODE_POSITION *pos, WS_ERROR *error )
5128 {
5129 struct reader *reader = (struct reader *)handle;
5130
5131 TRACE( "%p %p %p\n", handle, pos, error );
5132 if (error) FIXME( "ignoring error parameter\n" );
5133
5134 if (!reader || !pos) return E_INVALIDARG;
5135
5136 EnterCriticalSection( &reader->cs );
5137
5138 if (reader->magic != READER_MAGIC)
5139 {
5140 LeaveCriticalSection( &reader->cs );
5141 return E_INVALIDARG;
5142 }
5143
5144 if (!reader->input_buf)
5145 {
5146 LeaveCriticalSection( &reader->cs );
5147 return WS_E_INVALID_OPERATION;
5148 }
5149
5150 pos->buffer = (WS_XML_BUFFER *)reader->input_buf;
5151 pos->node = reader->current;
5152
5153 LeaveCriticalSection( &reader->cs );
5154 return S_OK;
5155 }
5156
5157 /**************************************************************************
5158 * WsSetReaderPosition [webservices.@]
5159 */
5160 HRESULT WINAPI WsSetReaderPosition( WS_XML_READER *handle, const WS_XML_NODE_POSITION *pos, WS_ERROR *error )
5161 {
5162 struct reader *reader = (struct reader *)handle;
5163
5164 TRACE( "%p %p %p\n", handle, pos, error );
5165 if (error) FIXME( "ignoring error parameter\n" );
5166
5167 if (!reader || !pos) return E_INVALIDARG;
5168
5169 EnterCriticalSection( &reader->cs );
5170
5171 if (reader->magic != READER_MAGIC || (struct xmlbuf *)pos->buffer != reader->input_buf)
5172 {
5173 LeaveCriticalSection( &reader->cs );
5174 return E_INVALIDARG;
5175 }
5176
5177 if (!reader->input_buf)
5178 {
5179 LeaveCriticalSection( &reader->cs );
5180 return WS_E_INVALID_OPERATION;
5181 }
5182
5183 reader->current = pos->node;
5184
5185 LeaveCriticalSection( &reader->cs );
5186 return S_OK;
5187 }
5188
5189 static HRESULT utf8_to_base64( const WS_XML_UTF8_TEXT *utf8, WS_XML_BASE64_TEXT *base64 )
5190 {
5191 if (utf8->value.length % 4) return WS_E_INVALID_FORMAT;
5192 if (!(base64->bytes = heap_alloc( utf8->value.length * 3 / 4 ))) return E_OUTOFMEMORY;
5193 base64->length = decode_base64( utf8->value.bytes, utf8->value.length, base64->bytes );
5194 return S_OK;
5195 }
5196
5197 /**************************************************************************
5198 * WsReadBytes [webservices.@]
5199 */
5200 HRESULT WINAPI WsReadBytes( WS_XML_READER *handle, void *bytes, ULONG max_count, ULONG *count, WS_ERROR *error )
5201 {
5202 struct reader *reader = (struct reader *)handle;
5203 HRESULT hr;
5204
5205 TRACE( "%p %p %u %p %p\n", handle, bytes, max_count, count, error );
5206 if (error) FIXME( "ignoring error parameter\n" );
5207
5208 if (!reader) return E_INVALIDARG;
5209
5210 EnterCriticalSection( &reader->cs );
5211
5212 if (reader->magic != READER_MAGIC)
5213 {
5214 LeaveCriticalSection( &reader->cs );
5215 return E_INVALIDARG;
5216 }
5217
5218 if (!reader->input_type)
5219 {
5220 LeaveCriticalSection( &reader->cs );
5221 return WS_E_INVALID_OPERATION;
5222 }
5223
5224 if (!count)
5225 {
5226 LeaveCriticalSection( &reader->cs );
5227 return E_INVALIDARG;
5228 }
5229
5230 *count = 0;
5231 if (node_type( reader->current ) == WS_XML_NODE_TYPE_TEXT && bytes)
5232 {
5233 const WS_XML_TEXT_NODE *text = (const WS_XML_TEXT_NODE *)reader->current;
5234 WS_XML_BASE64_TEXT base64;
5235
5236 if ((hr = utf8_to_base64( (const WS_XML_UTF8_TEXT *)text->text, &base64 )) != S_OK)
5237 {
5238 LeaveCriticalSection( &reader->cs );
5239 return hr;
5240 }
5241 if (reader->text_conv_offset == base64.length)
5242 {
5243 heap_free( base64.bytes );
5244 hr = read_node( reader );
5245 LeaveCriticalSection( &reader->cs );
5246 return hr;
5247 }
5248 *count = min( base64.length - reader->text_conv_offset, max_count );
5249 memcpy( bytes, base64.bytes + reader->text_conv_offset, *count );
5250 reader->text_conv_offset += *count;
5251 heap_free( base64.bytes );
5252 }
5253
5254 LeaveCriticalSection( &reader->cs );
5255 return S_OK;
5256 }
5257
5258 static HRESULT utf8_to_utf16( const WS_XML_UTF8_TEXT *utf8, WS_XML_UTF16_TEXT *utf16 )
5259 {
5260 int len = MultiByteToWideChar( CP_UTF8, 0, (char *)utf8->value.bytes, utf8->value.length, NULL, 0 );
5261 if (!(utf16->bytes = heap_alloc( len * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
5262 MultiByteToWideChar( CP_UTF8, 0, (char *)utf8->value.bytes, utf8->value.length, (WCHAR *)utf16->bytes, len );
5263 utf16->byteCount = len * sizeof(WCHAR);
5264 return S_OK;
5265 }
5266
5267 /**************************************************************************
5268 * WsReadChars [webservices.@]
5269 */
5270 HRESULT WINAPI WsReadChars( WS_XML_READER *handle, WCHAR *chars, ULONG max_count, ULONG *count, WS_ERROR *error )
5271 {
5272 struct reader *reader = (struct reader *)handle;
5273
5274 TRACE( "%p %p %u %p %p\n", handle, chars, max_count, count, error );
5275 if (error) FIXME( "ignoring error parameter\n" );
5276
5277 if (!reader) return E_INVALIDARG;
5278
5279 EnterCriticalSection( &reader->cs );
5280
5281 if (reader->magic != READER_MAGIC)
5282 {
5283 LeaveCriticalSection( &reader->cs );
5284 return E_INVALIDARG;
5285 }
5286
5287 if (!reader->input_type)
5288 {
5289 LeaveCriticalSection( &reader->cs );
5290 return WS_E_INVALID_OPERATION;
5291 }
5292
5293 if (!count)
5294 {
5295 LeaveCriticalSection( &reader->cs );
5296 return E_INVALIDARG;
5297 }
5298
5299 *count = 0;
5300 if (node_type( reader->current ) == WS_XML_NODE_TYPE_TEXT && chars)
5301 {
5302 const WS_XML_TEXT_NODE *text = (const WS_XML_TEXT_NODE *)reader->current;
5303 WS_XML_UTF16_TEXT utf16;
5304 HRESULT hr;
5305
5306 if ((hr = utf8_to_utf16( (const WS_XML_UTF8_TEXT *)text->text, &utf16 )) != S_OK)
5307 {
5308 LeaveCriticalSection( &reader->cs );
5309 return hr;
5310 }
5311 if (reader->text_conv_offset == utf16.byteCount / sizeof(WCHAR))
5312 {
5313 heap_free( utf16.bytes );
5314 hr = read_node( reader );
5315 LeaveCriticalSection( &reader->cs );
5316 return hr;
5317 }
5318 *count = min( utf16.byteCount / sizeof(WCHAR) - reader->text_conv_offset, max_count );
5319 memcpy( chars, utf16.bytes + reader->text_conv_offset * sizeof(WCHAR), *count * sizeof(WCHAR) );
5320 reader->text_conv_offset += *count;
5321 heap_free( utf16.bytes );
5322 }
5323
5324 LeaveCriticalSection( &reader->cs );
5325 return S_OK;
5326 }
5327
5328 /**************************************************************************
5329 * WsReadCharsUtf8 [webservices.@]
5330 */
5331 HRESULT WINAPI WsReadCharsUtf8( WS_XML_READER *handle, BYTE *bytes, ULONG max_count, ULONG *count, WS_ERROR *error )
5332 {
5333 struct reader *reader = (struct reader *)handle;
5334 HRESULT hr;
5335
5336 TRACE( "%p %p %u %p %p\n", handle, bytes, max_count, count, error );
5337 if (error) FIXME( "ignoring error parameter\n" );
5338
5339 if (!reader) return E_INVALIDARG;
5340
5341 EnterCriticalSection( &reader->cs );
5342
5343 if (reader->magic != READER_MAGIC)
5344 {
5345 LeaveCriticalSection( &reader->cs );
5346 return E_INVALIDARG;
5347 }
5348
5349 if (!reader->input_type)
5350 {
5351 LeaveCriticalSection( &reader->cs );
5352 return WS_E_INVALID_OPERATION;
5353 }
5354
5355 if (!count)
5356 {
5357 LeaveCriticalSection( &reader->cs );
5358 return E_INVALIDARG;
5359 }
5360
5361 *count = 0;
5362 if (node_type( reader->current ) == WS_XML_NODE_TYPE_TEXT && bytes)
5363 {
5364 const WS_XML_TEXT_NODE *text = (const WS_XML_TEXT_NODE *)reader->current;
5365 const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text->text;
5366
5367 if (reader->text_conv_offset == utf8->value.length)
5368 {
5369 hr = read_node( reader );
5370 LeaveCriticalSection( &reader->cs );
5371 return hr;
5372 }
5373 *count = min( utf8->value.length - reader->text_conv_offset, max_count );
5374 memcpy( bytes, utf8->value.bytes + reader->text_conv_offset, *count );
5375 reader->text_conv_offset += *count;
5376 }
5377
5378 LeaveCriticalSection( &reader->cs );
5379 return S_OK;
5380 }
5381
5382 HRESULT get_param_desc( const WS_STRUCT_DESCRIPTION *desc, USHORT index, const WS_FIELD_DESCRIPTION **ret )
5383 {
5384 if (index >= desc->fieldCount) return E_INVALIDARG;
5385 *ret = desc->fields[index];
5386 return S_OK;
5387 }
5388
5389 static ULONG get_field_size( const WS_FIELD_DESCRIPTION *desc )
5390 {
5391 WS_READ_OPTION option;
5392 ULONG size;
5393
5394 switch ((option = get_field_read_option( desc->type, desc->options )))
5395 {
5396 case WS_READ_REQUIRED_POINTER:
5397 case WS_READ_OPTIONAL_POINTER:
5398 case WS_READ_NILLABLE_POINTER:
5399 size = sizeof(void *);
5400 break;
5401
5402 case WS_READ_REQUIRED_VALUE:
5403 case WS_READ_NILLABLE_VALUE:
5404 size = get_type_size( desc->type, desc->typeDescription );
5405 break;
5406
5407 default:
5408 WARN( "unhandled option %u\n", option );
5409 return 0;
5410 }
5411
5412 return size;
5413 }
5414
5415 static HRESULT read_param( struct reader *reader, const WS_FIELD_DESCRIPTION *desc, WS_HEAP *heap, void *ret )
5416 {
5417 if (!ret && !(ret = ws_alloc_zero( heap, get_field_size(desc) ))) return WS_E_QUOTA_EXCEEDED;
5418 return read_type_struct_field( reader, desc, heap, ret, 0 );
5419 }
5420
5421 static HRESULT read_param_array( struct reader *reader, const WS_FIELD_DESCRIPTION *desc, WS_HEAP *heap,
5422 void **ret, ULONG *count )
5423 {
5424 if (!ret && !(ret = ws_alloc_zero( heap, sizeof(void **) ))) return WS_E_QUOTA_EXCEEDED;
5425 return read_type_repeating_element( reader, desc, heap, ret, count );
5426 }
5427
5428 static void set_array_len( const WS_PARAMETER_DESCRIPTION *params, ULONG count, ULONG index, ULONG len,
5429 const void **args )
5430 {
5431 ULONG i, *ptr;
5432 for (i = 0; i < count; i++)
5433 {
5434 if (params[i].outputMessageIndex != index || params[i].parameterType != WS_PARAMETER_TYPE_ARRAY_COUNT)
5435 continue;
5436 if ((ptr = *(ULONG **)args[i])) *ptr = len;
5437 break;
5438 }
5439 }
5440
5441 HRESULT read_output_params( WS_XML_READER *handle, WS_HEAP *heap, const WS_ELEMENT_DESCRIPTION *desc,
5442 const WS_PARAMETER_DESCRIPTION *params, ULONG count, const void **args )
5443 {
5444 struct reader *reader = (struct reader *)handle;
5445 const WS_STRUCT_DESCRIPTION *desc_struct;
5446 const WS_FIELD_DESCRIPTION *desc_field;
5447 ULONG i, len;
5448 HRESULT hr;
5449
5450 if (desc->type != WS_STRUCT_TYPE || !(desc_struct = desc->typeDescription)) return E_INVALIDARG;
5451
5452 EnterCriticalSection( &reader->cs );
5453
5454 if (reader->magic != READER_MAGIC)
5455 {
5456 LeaveCriticalSection( &reader->cs );
5457 return E_INVALIDARG;
5458 }
5459
5460 if ((hr = start_mapping( reader, WS_ELEMENT_TYPE_MAPPING, desc->elementLocalName, desc->elementNs )) != S_OK)
5461 goto done;
5462
5463 for (i = 0; i < count; i++)
5464 {
5465 if (params[i].outputMessageIndex == INVALID_PARAMETER_INDEX) continue;
5466 if (params[i].parameterType == WS_PARAMETER_TYPE_MESSAGES)
5467 {
5468 FIXME( "messages type not supported\n" );
5469 hr = E_NOTIMPL;
5470 goto done;
5471 }
5472 if ((hr = get_param_desc( desc_struct, params[i].outputMessageIndex, &desc_field )) != S_OK) goto done;
5473 if (params[i].parameterType == WS_PARAMETER_TYPE_NORMAL)
5474 {
5475 void *ptr = *(void **)args[i];
5476 if ((hr = read_param( reader, desc_field, heap, ptr )) != S_OK) goto done;
5477 }
5478 else if (params[i].parameterType == WS_PARAMETER_TYPE_ARRAY)
5479 {
5480 void **ptr = *(void ***)args[i];
5481 if ((hr = read_param_array( reader, desc_field, heap, ptr, &len )) != S_OK) goto done;
5482 set_array_len( params, count, params[i].outputMessageIndex, len, args );
5483 }
5484 }
5485
5486 if (desc_struct->structOptions & WS_STRUCT_IGNORE_TRAILING_ELEMENT_CONTENT)
5487 {
5488 struct node *parent = find_parent( reader );
5489 parent->flags |= NODE_FLAG_IGNORE_TRAILING_ELEMENT_CONTENT;
5490 }
5491
5492 hr = end_mapping( reader, WS_ELEMENT_TYPE_MAPPING );
5493
5494 done:
5495 LeaveCriticalSection( &reader->cs );
5496 return hr;
5497 }
Windows API implementation