?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ntdll: Allow explicitly specified asm.v2 namespace for "trustInfo".
[wine.git] / dlls / webservices / reader.c
bloba56bb7eb9fa76ee66b092c267d2d77e4d77f3373
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 #include <assert.h>
21
22 #include "windef.h"
23 #include "winbase.h"
24 #include "winnls.h"
25 #include "webservices.h"
26
27 #include "wine/debug.h"
28 #include "wine/heap.h"
29 #include "wine/list.h"
30 #include "webservices_private.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(webservices);
33
34 ULONG prop_size( const struct prop_desc *desc, ULONG count )
35 {
36 ULONG i, ret = count * sizeof(struct prop);
37 for (i = 0; i < count; i++) ret += desc[i].size;
38 return ret;
39 }
40
41 void prop_init( const struct prop_desc *desc, ULONG count, struct prop *prop, void *data )
42 {
43 ULONG i;
44 char *ptr = data;
45 for (i = 0; i < count; i++)
46 {
47 prop[i].value = ptr;
48 prop[i].size = desc[i].size;
49 prop[i].readonly = desc[i].readonly;
50 prop[i].writeonly = desc[i].writeonly;
51 ptr += prop[i].size;
52 }
53 }
54
55 HRESULT prop_set( const struct prop *prop, ULONG count, ULONG id, const void *value, ULONG size )
56 {
57 if (id >= count || size != prop[id].size || prop[id].readonly) return E_INVALIDARG;
58 memcpy( prop[id].value, value, size );
59 return S_OK;
60 }
61
62 HRESULT prop_get( const struct prop *prop, ULONG count, ULONG id, void *buf, ULONG size )
63 {
64 if (id >= count || size != prop[id].size || prop[id].writeonly) return E_INVALIDARG;
65 memcpy( buf, prop[id].value, prop[id].size );
66 return S_OK;
67 }
68
69 struct node *alloc_node( WS_XML_NODE_TYPE type )
70 {
71 struct node *ret;
72
73 if (!(ret = heap_alloc_zero( sizeof(*ret) ))) return NULL;
74 ret->hdr.node.nodeType = type;
75 list_init( &ret->entry );
76 list_init( &ret->children );
77 return ret;
78 }
79
80 void free_attribute( WS_XML_ATTRIBUTE *attr )
81 {
82 if (!attr) return;
83 free_xml_string( attr->prefix );
84 free_xml_string( attr->localName );
85 free_xml_string( attr->ns );
86 heap_free( attr->value );
87 heap_free( attr );
88 }
89
90 void free_node( struct node *node )
91 {
92 if (!node) return;
93 switch (node_type( node ))
94 {
95 case WS_XML_NODE_TYPE_ELEMENT:
96 {
97 WS_XML_ELEMENT_NODE *elem = &node->hdr;
98 ULONG i;
99
100 for (i = 0; i < elem->attributeCount; i++) free_attribute( elem->attributes[i] );
101 heap_free( elem->attributes );
102 free_xml_string( elem->prefix );
103 free_xml_string( elem->localName );
104 free_xml_string( elem->ns );
105 break;
106 }
107 case WS_XML_NODE_TYPE_TEXT:
108 {
109 WS_XML_TEXT_NODE *text = (WS_XML_TEXT_NODE *)node;
110 heap_free( text->text );
111 break;
112 }
113 case WS_XML_NODE_TYPE_COMMENT:
114 {
115 WS_XML_COMMENT_NODE *comment = (WS_XML_COMMENT_NODE *)node;
116 heap_free( comment->value.bytes );
117 break;
118 }
119 case WS_XML_NODE_TYPE_CDATA:
120 case WS_XML_NODE_TYPE_END_CDATA:
121 case WS_XML_NODE_TYPE_END_ELEMENT:
122 case WS_XML_NODE_TYPE_EOF:
123 case WS_XML_NODE_TYPE_BOF:
124 break;
125
126 default:
127 ERR( "unhandled type %u\n", node_type( node ) );
128 break;
129 }
130 heap_free( node );
131 }
132
133 void destroy_nodes( struct node *node )
134 {
135 struct list *ptr;
136
137 if (!node) return;
138 while ((ptr = list_head( &node->children )))
139 {
140 struct node *child = LIST_ENTRY( ptr, struct node, entry );
141 list_remove( &child->entry );
142 destroy_nodes( child );
143 }
144 free_node( node );
145 }
146
147 static WS_XML_ATTRIBUTE *dup_attribute( const WS_XML_ATTRIBUTE *src, WS_XML_WRITER_ENCODING_TYPE enc )
148 {
149 WS_XML_ATTRIBUTE *dst;
150 HRESULT hr;
151
152 if (!(dst = heap_alloc_zero( sizeof(*dst) ))) return NULL;
153 dst->singleQuote = src->singleQuote;
154 dst->isXmlNs = src->isXmlNs;
155
156 if (src->prefix && !(dst->prefix = dup_xml_string( src->prefix, FALSE ))) goto error;
157 if (src->localName && !(dst->localName = dup_xml_string( src->localName, FALSE ))) goto error;
158 if (src->ns && !(dst->ns = dup_xml_string( src->ns, FALSE ))) goto error;
159
160 if (src->value)
161 {
162 switch (enc)
163 {
164 case WS_XML_WRITER_ENCODING_TYPE_BINARY:
165 if ((hr = text_to_text( src->value, NULL, NULL, &dst->value )) != S_OK) goto error;
166 break;
167
168 case WS_XML_WRITER_ENCODING_TYPE_TEXT:
169 if ((hr = text_to_utf8text( src->value, NULL, NULL, (WS_XML_UTF8_TEXT **)&dst->value )) != S_OK)
170 goto error;
171 break;
172
173 default:
174 ERR( "unhandled encoding %u\n", enc );
175 goto error;
176 }
177 }
178
179 return dst;
180
181 error:
182 free_attribute( dst );
183 return NULL;
184 }
185
186 static WS_XML_ATTRIBUTE **dup_attributes( WS_XML_ATTRIBUTE * const *src, ULONG count,
187 WS_XML_WRITER_ENCODING_TYPE enc )
188 {
189 WS_XML_ATTRIBUTE **dst;
190 ULONG i;
191
192 if (!(dst = heap_alloc( sizeof(*dst) * count ))) return NULL;
193 for (i = 0; i < count; i++)
194 {
195 if (!(dst[i] = dup_attribute( src[i], enc )))
196 {
197 for (; i > 0; i--) free_attribute( dst[i - 1] );
198 heap_free( dst );
199 return NULL;
200 }
201 }
202 return dst;
203 }
204
205 static struct node *dup_element_node( const WS_XML_ELEMENT_NODE *src, WS_XML_WRITER_ENCODING_TYPE enc )
206 {
207 struct node *node;
208 WS_XML_ELEMENT_NODE *dst;
209 ULONG count = src->attributeCount;
210 WS_XML_ATTRIBUTE **attrs = src->attributes;
211 const WS_XML_STRING *prefix = (src->prefix && src->prefix->length) ? src->prefix : NULL;
212 const WS_XML_STRING *localname = src->localName;
213 const WS_XML_STRING *ns = src->ns;
214
215 if (!(node = alloc_node( WS_XML_NODE_TYPE_ELEMENT ))) return NULL;
216 dst = &node->hdr;
217
218 if (count && !(dst->attributes = dup_attributes( attrs, count, enc ))) goto error;
219 dst->attributeCount = count;
220
221 if (prefix && !(dst->prefix = dup_xml_string( prefix, FALSE ))) goto error;
222 if (localname && !(dst->localName = dup_xml_string( localname, FALSE ))) goto error;
223 if (ns && !(dst->ns = dup_xml_string( ns, FALSE ))) goto error;
224 return node;
225
226 error:
227 free_node( node );
228 return NULL;
229 }
230
231 static struct node *dup_text_node( const WS_XML_TEXT_NODE *src, WS_XML_WRITER_ENCODING_TYPE enc )
232 {
233 struct node *node;
234 WS_XML_TEXT_NODE *dst;
235 HRESULT hr;
236
237 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return NULL;
238 dst = (WS_XML_TEXT_NODE *)node;
239 if (!src->text) return node;
240
241 switch (enc)
242 {
243 case WS_XML_WRITER_ENCODING_TYPE_BINARY:
244 hr = text_to_text( src->text, NULL, NULL, &dst->text );
245 break;
246
247 case WS_XML_WRITER_ENCODING_TYPE_TEXT:
248 hr = text_to_utf8text( src->text, NULL, NULL, (WS_XML_UTF8_TEXT **)&dst->text );
249 break;
250
251 default:
252 ERR( "unhandled encoding %u\n", enc );
253 free_node( node );
254 return NULL;
255 }
256
257 if (hr != S_OK)
258 {
259 free_node( node );
260 return NULL;
261 }
262
263 return node;
264 }
265
266 static struct node *dup_comment_node( const WS_XML_COMMENT_NODE *src )
267 {
268 struct node *node;
269 WS_XML_COMMENT_NODE *dst;
270
271 if (!(node = alloc_node( WS_XML_NODE_TYPE_COMMENT ))) return NULL;
272 dst = (WS_XML_COMMENT_NODE *)node;
273
274 if (src->value.length && !(dst->value.bytes = heap_alloc( src->value.length )))
275 {
276 free_node( node );
277 return NULL;
278 }
279 memcpy( dst->value.bytes, src->value.bytes, src->value.length );
280 dst->value.length = src->value.length;
281 return node;
282 }
283
284 static struct node *dup_node( const struct node *src, WS_XML_WRITER_ENCODING_TYPE enc )
285 {
286 switch (node_type( src ))
287 {
288 case WS_XML_NODE_TYPE_ELEMENT:
289 return dup_element_node( &src->hdr, enc );
290
291 case WS_XML_NODE_TYPE_TEXT:
292 return dup_text_node( (const WS_XML_TEXT_NODE *)src, enc );
293
294 case WS_XML_NODE_TYPE_COMMENT:
295 return dup_comment_node( (const WS_XML_COMMENT_NODE *)src );
296
297 case WS_XML_NODE_TYPE_CDATA:
298 case WS_XML_NODE_TYPE_END_CDATA:
299 case WS_XML_NODE_TYPE_END_ELEMENT:
300 case WS_XML_NODE_TYPE_EOF:
301 case WS_XML_NODE_TYPE_BOF:
302 return alloc_node( node_type( src ) );
303
304 default:
305 ERR( "unhandled type %u\n", node_type( src ) );
306 break;
307 }
308 return NULL;
309 }
310
311 static HRESULT dup_tree( const struct node *src, WS_XML_WRITER_ENCODING_TYPE enc, struct node **dst )
312 {
313 struct node *parent;
314 const struct node *child;
315
316 if (!*dst && !(*dst = dup_node( src, enc ))) return E_OUTOFMEMORY;
317 parent = *dst;
318
319 LIST_FOR_EACH_ENTRY( child, &src->children, struct node, entry )
320 {
321 HRESULT hr = E_OUTOFMEMORY;
322 struct node *new_child;
323
324 if (!(new_child = dup_node( child, enc )) || (hr = dup_tree( child, enc, &new_child )) != S_OK)
325 {
326 destroy_nodes( *dst );
327 return hr;
328 }
329 new_child->parent = parent;
330 list_add_tail( &parent->children, &new_child->entry );
331 }
332 return S_OK;
333 }
334
335 static const struct prop_desc reader_props[] =
336 {
337 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_DEPTH */
338 { sizeof(BOOL), FALSE }, /* WS_XML_READER_PROPERTY_ALLOW_FRAGMENT */
339 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_ATTRIBUTES */
340 { sizeof(BOOL), FALSE }, /* WS_XML_READER_PROPERTY_READ_DECLARATION */
341 { sizeof(WS_CHARSET), FALSE }, /* WS_XML_READER_PROPERTY_CHARSET */
342 { sizeof(ULONGLONG), TRUE }, /* WS_XML_READER_PROPERTY_ROW */
343 { sizeof(ULONGLONG), TRUE }, /* WS_XML_READER_PROPERTY_COLUMN */
344 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_UTF8_TRIM_SIZE */
345 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_STREAM_BUFFER_SIZE */
346 { sizeof(BOOL), TRUE }, /* WS_XML_READER_PROPERTY_IN_ATTRIBUTE */
347 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_STREAM_MAX_ROOT_MIME_PART_SIZE */
348 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_STREAM_MAX_MIME_HEADERS_SIZE */
349 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_MIME_PARTS */
350 { sizeof(BOOL), FALSE }, /* WS_XML_READER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES */
351 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_NAMESPACES */
352 };
353
354 enum reader_state
355 {
356 READER_STATE_INITIAL,
357 READER_STATE_BOF,
358 READER_STATE_STARTELEMENT,
359 READER_STATE_STARTATTRIBUTE,
360 READER_STATE_STARTCDATA,
361 READER_STATE_CDATA,
362 READER_STATE_TEXT,
363 READER_STATE_ENDELEMENT,
364 READER_STATE_ENDCDATA,
365 READER_STATE_COMMENT,
366 READER_STATE_EOF
367 };
368
369 struct prefix
370 {
371 WS_XML_STRING *str;
372 WS_XML_STRING *ns;
373 };
374
375 struct reader
376 {
377 ULONG magic;
378 CRITICAL_SECTION cs;
379 ULONG read_size;
380 ULONG read_pos;
381 const unsigned char *read_bufptr;
382 enum reader_state state;
383 struct node *root;
384 struct node *current;
385 ULONG current_attr;
386 struct node *last;
387 struct prefix *prefixes;
388 ULONG nb_prefixes;
389 ULONG nb_prefixes_allocated;
390 WS_XML_READER_ENCODING_TYPE input_enc;
391 WS_CHARSET input_charset;
392 WS_XML_READER_INPUT_TYPE input_type;
393 struct xmlbuf *input_buf;
394 const unsigned char *input_data;
395 ULONG input_size;
396 ULONG text_conv_offset;
397 const WS_XML_DICTIONARY *dict_static;
398 WS_XML_DICTIONARY *dict;
399 ULONG prop_count;
400 struct prop prop[sizeof(reader_props)/sizeof(reader_props[0])];
401 };
402
403 #define READER_MAGIC (('R' << 24) | ('E' << 16) | ('A' << 8) | 'D')
404
405 static struct reader *alloc_reader(void)
406 {
407 static const ULONG count = sizeof(reader_props)/sizeof(reader_props[0]);
408 struct reader *ret;
409 ULONG size = sizeof(*ret) + prop_size( reader_props, count );
410
411 if (!(ret = heap_alloc_zero( size ))) return NULL;
412 if (!(ret->prefixes = heap_alloc_zero( sizeof(*ret->prefixes) )))
413 {
414 heap_free( ret );
415 return NULL;
416 }
417 ret->nb_prefixes = ret->nb_prefixes_allocated = 1;
418
419 ret->magic = READER_MAGIC;
420 InitializeCriticalSection( &ret->cs );
421 ret->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": reader.cs");
422
423 prop_init( reader_props, count, ret->prop, &ret[1] );
424 ret->prop_count = count;
425 return ret;
426 }
427
428 static void clear_prefixes( struct prefix *prefixes, ULONG count )
429 {
430 ULONG i;
431 for (i = 0; i < count; i++)
432 {
433 free_xml_string( prefixes[i].str );
434 prefixes[i].str = NULL;
435 free_xml_string( prefixes[i].ns );
436 prefixes[i].ns = NULL;
437 }
438 }
439
440 static HRESULT set_prefix( struct prefix *prefix, const WS_XML_STRING *str, const WS_XML_STRING *ns )
441 {
442 if (str)
443 {
444 free_xml_string( prefix->str );
445 if (!(prefix->str = dup_xml_string( str, FALSE ))) return E_OUTOFMEMORY;
446 }
447 if (prefix->ns) free_xml_string( prefix->ns );
448 if (!(prefix->ns = dup_xml_string( ns, FALSE ))) return E_OUTOFMEMORY;
449 return S_OK;
450 }
451
452 static HRESULT bind_prefix( struct reader *reader, const WS_XML_STRING *prefix, const WS_XML_STRING *ns )
453 {
454 ULONG i;
455 HRESULT hr;
456
457 for (i = 0; i < reader->nb_prefixes; i++)
458 {
459 if (WsXmlStringEquals( prefix, reader->prefixes[i].str, NULL ) == S_OK)
460 return set_prefix( &reader->prefixes[i], NULL, ns );
461 }
462 if (i >= reader->nb_prefixes_allocated)
463 {
464 ULONG new_size = reader->nb_prefixes_allocated * sizeof(*reader->prefixes) * 2;
465 struct prefix *tmp = heap_realloc_zero( reader->prefixes, new_size );
466 if (!tmp) return E_OUTOFMEMORY;
467 reader->prefixes = tmp;
468 reader->nb_prefixes_allocated *= 2;
469 }
470 if ((hr = set_prefix( &reader->prefixes[i], prefix, ns )) != S_OK) return hr;
471 reader->nb_prefixes++;
472 return S_OK;
473 }
474
475 static const WS_XML_STRING *get_namespace( struct reader *reader, const WS_XML_STRING *prefix )
476 {
477 ULONG i;
478 for (i = 0; i < reader->nb_prefixes; i++)
479 {
480 if (WsXmlStringEquals( prefix, reader->prefixes[i].str, NULL ) == S_OK)
481 return reader->prefixes[i].ns;
482 }
483 return NULL;
484 }
485
486 static void read_insert_eof( struct reader *reader, struct node *eof )
487 {
488 if (!reader->root) reader->root = eof;
489 else
490 {
491 eof->parent = reader->root;
492 list_add_tail( &reader->root->children, &eof->entry );
493 }
494 reader->current = reader->last = eof;
495 }
496
497 static void read_insert_bof( struct reader *reader, struct node *bof )
498 {
499 reader->root->parent = bof;
500 list_add_tail( &bof->children, &reader->root->entry );
501 reader->current = reader->last = reader->root = bof;
502 }
503
504 static void read_insert_node( struct reader *reader, struct node *parent, struct node *node )
505 {
506 node->parent = parent;
507 list_add_before( list_tail( &parent->children ), &node->entry );
508 reader->current = reader->last = node;
509 }
510
511 static void free_reader( struct reader *reader )
512 {
513 destroy_nodes( reader->root );
514 clear_prefixes( reader->prefixes, reader->nb_prefixes );
515 heap_free( reader->prefixes );
516 reader->cs.DebugInfo->Spare[0] = 0;
517 DeleteCriticalSection( &reader->cs );
518 heap_free( reader );
519 }
520
521 static HRESULT init_reader( struct reader *reader )
522 {
523 static const WS_XML_STRING empty = {0, NULL};
524 struct node *node;
525 HRESULT hr;
526
527 reader->state = READER_STATE_INITIAL;
528 destroy_nodes( reader->root );
529 reader->root = reader->current = NULL;
530 reader->current_attr = 0;
531 clear_prefixes( reader->prefixes, reader->nb_prefixes );
532 reader->nb_prefixes = 1;
533 if ((hr = bind_prefix( reader, &empty, &empty )) != S_OK) return hr;
534
535 if (!(node = alloc_node( WS_XML_NODE_TYPE_EOF ))) return E_OUTOFMEMORY;
536 read_insert_eof( reader, node );
537 reader->input_enc = WS_XML_READER_ENCODING_TYPE_TEXT;
538 reader->input_charset = WS_CHARSET_UTF8;
539 reader->dict_static = NULL;
540 reader->dict = NULL;
541 return S_OK;
542 }
543
544 /**************************************************************************
545 * WsCreateReader [webservices.@]
546 */
547 HRESULT WINAPI WsCreateReader( const WS_XML_READER_PROPERTY *properties, ULONG count,
548 WS_XML_READER **handle, WS_ERROR *error )
549 {
550 struct reader *reader;
551 ULONG i, max_depth = 32, max_attrs = 128, max_ns = 32;
552 BOOL read_decl = TRUE;
553 HRESULT hr;
554
555 TRACE( "%p %u %p %p\n", properties, count, handle, error );
556 if (error) FIXME( "ignoring error parameter\n" );
557
558 if (!handle) return E_INVALIDARG;
559 if (!(reader = alloc_reader())) return E_OUTOFMEMORY;
560
561 prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_MAX_DEPTH, &max_depth, sizeof(max_depth) );
562 prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_MAX_ATTRIBUTES, &max_attrs, sizeof(max_attrs) );
563 prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_READ_DECLARATION, &read_decl, sizeof(read_decl) );
564 prop_set( reader->prop, reader->prop_count, WS_XML_READER_PROPERTY_MAX_NAMESPACES, &max_ns, sizeof(max_ns) );
565
566 for (i = 0; i < count; i++)
567 {
568 hr = prop_set( reader->prop, reader->prop_count, properties[i].id, properties[i].value,
569 properties[i].valueSize );
570 if (hr != S_OK)
571 {
572 free_reader( reader );
573 return hr;
574 }
575 }
576
577 if ((hr = init_reader( reader )) != S_OK)
578 {
579 free_reader( reader );
580 return hr;
581 }
582
583 TRACE( "created %p\n", reader );
584 *handle = (WS_XML_READER *)reader;
585 return S_OK;
586 }
587
588 /**************************************************************************
589 * WsFreeReader [webservices.@]
590 */
591 void WINAPI WsFreeReader( WS_XML_READER *handle )
592 {
593 struct reader *reader = (struct reader *)handle;
594
595 TRACE( "%p\n", handle );
596
597 if (!reader) return;
598
599 EnterCriticalSection( &reader->cs );
600
601 if (reader->magic != READER_MAGIC)
602 {
603 LeaveCriticalSection( &reader->cs );
604 return;
605 }
606
607 reader->magic = 0;
608
609 LeaveCriticalSection( &reader->cs );
610 free_reader( reader );
611 }
612
613 /**************************************************************************
614 * WsFillReader [webservices.@]
615 */
616 HRESULT WINAPI WsFillReader( WS_XML_READER *handle, ULONG min_size, const WS_ASYNC_CONTEXT *ctx,
617 WS_ERROR *error )
618 {
619 struct reader *reader = (struct reader *)handle;
620
621 TRACE( "%p %u %p %p\n", handle, min_size, ctx, error );
622 if (error) FIXME( "ignoring error parameter\n" );
623
624 if (!reader) return E_INVALIDARG;
625
626 EnterCriticalSection( &reader->cs );
627
628 if (reader->magic != READER_MAGIC)
629 {
630 LeaveCriticalSection( &reader->cs );
631 return E_INVALIDARG;
632 }
633
634 /* FIXME: add support for stream input */
635 reader->read_size = min( min_size, reader->input_size );
636 reader->read_pos = 0;
637
638 LeaveCriticalSection( &reader->cs );
639 return S_OK;
640 }
641
642 /**************************************************************************
643 * WsGetNamespaceFromPrefix [webservices.@]
644 */
645 HRESULT WINAPI WsGetNamespaceFromPrefix( WS_XML_READER *handle, const WS_XML_STRING *prefix,
646 BOOL required, const WS_XML_STRING **ns, WS_ERROR *error )
647 {
648 static const WS_XML_STRING xml = {3, (BYTE *)"xml"};
649 static const WS_XML_STRING xmlns = {5, (BYTE *)"xmlns"};
650 static const WS_XML_STRING empty_ns = {0, NULL};
651 static const WS_XML_STRING xml_ns = {36, (BYTE *)"http://www.w3.org/XML/1998/namespace"};
652 static const WS_XML_STRING xmlns_ns = {29, (BYTE *)"http://www.w3.org/2000/xmlns/"};
653 struct reader *reader = (struct reader *)handle;
654 BOOL found = FALSE;
655
656 TRACE( "%p %s %d %p %p\n", handle, debugstr_xmlstr(prefix), required, ns, error );
657 if (error) FIXME( "ignoring error parameter\n" );
658
659 if (!reader || !prefix || !ns) return E_INVALIDARG;
660
661 EnterCriticalSection( &reader->cs );
662
663 if (reader->magic != READER_MAGIC)
664 {
665 LeaveCriticalSection( &reader->cs );
666 return E_INVALIDARG;
667 }
668
669 if (reader->state != READER_STATE_STARTELEMENT)
670 {
671 LeaveCriticalSection( &reader->cs );
672 return WS_E_INVALID_OPERATION;
673 }
674
675 if (!prefix->length)
676 {
677 *ns = &empty_ns;
678 found = TRUE;
679 }
680 else if (WsXmlStringEquals( prefix, &xml, NULL ) == S_OK)
681 {
682 *ns = &xml_ns;
683 found = TRUE;
684 }
685 else if (WsXmlStringEquals( prefix, &xmlns, NULL ) == S_OK)
686 {
687 *ns = &xmlns_ns;
688 found = TRUE;
689 }
690 else
691 {
692 WS_XML_ELEMENT_NODE *elem = &reader->current->hdr;
693 ULONG i;
694
695 for (i = 0; i < elem->attributeCount; i++)
696 {
697 if (!elem->attributes[i]->isXmlNs) continue;
698 if (WsXmlStringEquals( prefix, elem->attributes[i]->prefix, NULL ) == S_OK)
699 {
700 *ns = elem->attributes[i]->ns;
701 found = TRUE;
702 break;
703 }
704 }
705 }
706
707 LeaveCriticalSection( &reader->cs );
708
709 if (!found)
710 {
711 if (required) return WS_E_INVALID_FORMAT;
712 *ns = NULL;
713 return S_FALSE;
714 }
715
716 return S_OK;
717 }
718
719 /**************************************************************************
720 * WsGetReaderNode [webservices.@]
721 */
722 HRESULT WINAPI WsGetReaderNode( WS_XML_READER *handle, const WS_XML_NODE **node,
723 WS_ERROR *error )
724 {
725 struct reader *reader = (struct reader *)handle;
726
727 TRACE( "%p %p %p\n", handle, node, error );
728 if (error) FIXME( "ignoring error parameter\n" );
729
730 if (!reader || !node) return E_INVALIDARG;
731
732 EnterCriticalSection( &reader->cs );
733
734 if (reader->magic != READER_MAGIC)
735 {
736 LeaveCriticalSection( &reader->cs );
737 return E_INVALIDARG;
738 }
739
740 *node = &reader->current->hdr.node;
741
742 LeaveCriticalSection( &reader->cs );
743 return S_OK;
744 }
745
746 static HRESULT get_charset( struct reader *reader, void *buf, ULONG size )
747 {
748 if (!buf || size != sizeof(reader->input_charset)) return E_INVALIDARG;
749 if (!reader->input_charset) return WS_E_INVALID_FORMAT;
750 *(WS_CHARSET *)buf = reader->input_charset;
751 return S_OK;
752 }
753
754 /**************************************************************************
755 * WsGetReaderProperty [webservices.@]
756 */
757 HRESULT WINAPI WsGetReaderProperty( WS_XML_READER *handle, WS_XML_READER_PROPERTY_ID id,
758 void *buf, ULONG size, WS_ERROR *error )
759 {
760 struct reader *reader = (struct reader *)handle;
761 HRESULT hr;
762
763 TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
764 if (error) FIXME( "ignoring error parameter\n" );
765
766 if (!reader) return E_INVALIDARG;
767
768 EnterCriticalSection( &reader->cs );
769
770 if (reader->magic != READER_MAGIC)
771 {
772 LeaveCriticalSection( &reader->cs );
773 return E_INVALIDARG;
774 }
775
776 if (!reader->input_type)
777 {
778 LeaveCriticalSection( &reader->cs );
779 return WS_E_INVALID_OPERATION;
780 }
781
782 if (id == WS_XML_READER_PROPERTY_CHARSET) hr = get_charset( reader, buf, size );
783 else hr = prop_get( reader->prop, reader->prop_count, id, buf, size );
784
785 LeaveCriticalSection( &reader->cs );
786 return hr;
787 }
788
789 /**************************************************************************
790 * WsGetXmlAttribute [webservices.@]
791 */
792 HRESULT WINAPI WsGetXmlAttribute( WS_XML_READER *handle, const WS_XML_STRING *attr,
793 WS_HEAP *heap, WCHAR **str, ULONG *len, WS_ERROR *error )
794 {
795 FIXME( "%p %s %p %p %p %p: stub\n", handle, debugstr_xmlstr(attr), heap, str, len, error );
796 return E_NOTIMPL;
797 }
798
799 WS_XML_UTF8_TEXT *alloc_utf8_text( const BYTE *data, ULONG len )
800 {
801 WS_XML_UTF8_TEXT *ret;
802
803 if (!(ret = heap_alloc( sizeof(*ret) + len ))) return NULL;
804 ret->text.textType = WS_XML_TEXT_TYPE_UTF8;
805 ret->value.length = len;
806 ret->value.bytes = len ? (BYTE *)(ret + 1) : NULL;
807 ret->value.dictionary = NULL;
808 ret->value.id = 0;
809 if (data) memcpy( ret->value.bytes, data, len );
810 return ret;
811 }
812
813 WS_XML_UTF16_TEXT *alloc_utf16_text( const BYTE *data, ULONG len )
814 {
815 WS_XML_UTF16_TEXT *ret;
816
817 if (!(ret = heap_alloc( sizeof(*ret) + len ))) return NULL;
818 ret->text.textType = WS_XML_TEXT_TYPE_UTF16;
819 ret->byteCount = len;
820 ret->bytes = len ? (BYTE *)(ret + 1) : NULL;
821 if (data) memcpy( ret->bytes, data, len );
822 return ret;
823 }
824
825 WS_XML_BASE64_TEXT *alloc_base64_text( const BYTE *data, ULONG len )
826 {
827 WS_XML_BASE64_TEXT *ret;
828
829 if (!(ret = heap_alloc( sizeof(*ret) + len ))) return NULL;
830 ret->text.textType = WS_XML_TEXT_TYPE_BASE64;
831 ret->length = len;
832 ret->bytes = len ? (BYTE *)(ret + 1) : NULL;
833 if (data) memcpy( ret->bytes, data, len );
834 return ret;
835 }
836
837 WS_XML_BOOL_TEXT *alloc_bool_text( BOOL value )
838 {
839 WS_XML_BOOL_TEXT *ret;
840
841 if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL;
842 ret->text.textType = WS_XML_TEXT_TYPE_BOOL;
843 ret->value = value;
844 return ret;
845 }
846
847 WS_XML_INT32_TEXT *alloc_int32_text( INT32 value )
848 {
849 WS_XML_INT32_TEXT *ret;
850
851 if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL;
852 ret->text.textType = WS_XML_TEXT_TYPE_INT32;
853 ret->value = value;
854 return ret;
855 }
856
857 WS_XML_INT64_TEXT *alloc_int64_text( INT64 value )
858 {
859 WS_XML_INT64_TEXT *ret;
860
861 if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL;
862 ret->text.textType = WS_XML_TEXT_TYPE_INT64;
863 ret->value = value;
864 return ret;
865 }
866
867 WS_XML_UINT64_TEXT *alloc_uint64_text( UINT64 value )
868 {
869 WS_XML_UINT64_TEXT *ret;
870
871 if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL;
872 ret->text.textType = WS_XML_TEXT_TYPE_UINT64;
873 ret->value = value;
874 return ret;
875 }
876
877 WS_XML_FLOAT_TEXT *alloc_float_text( float value )
878 {
879 WS_XML_FLOAT_TEXT *ret;
880
881 if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL;
882 ret->text.textType = WS_XML_TEXT_TYPE_FLOAT;
883 ret->value = value;
884 return ret;
885 }
886
887 WS_XML_DOUBLE_TEXT *alloc_double_text( double value )
888 {
889 WS_XML_DOUBLE_TEXT *ret;
890
891 if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL;
892 ret->text.textType = WS_XML_TEXT_TYPE_DOUBLE;
893 ret->value = value;
894 return ret;
895 }
896
897 WS_XML_GUID_TEXT *alloc_guid_text( const GUID *value )
898 {
899 WS_XML_GUID_TEXT *ret;
900
901 if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL;
902 ret->text.textType = WS_XML_TEXT_TYPE_GUID;
903 ret->value = *value;
904 return ret;
905 }
906
907 WS_XML_UNIQUE_ID_TEXT *alloc_unique_id_text( const GUID *value )
908 {
909 WS_XML_UNIQUE_ID_TEXT *ret;
910
911 if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL;
912 ret->text.textType = WS_XML_TEXT_TYPE_UNIQUE_ID;
913 ret->value = *value;
914 return ret;
915 }
916
917 WS_XML_DATETIME_TEXT *alloc_datetime_text( const WS_DATETIME *value )
918 {
919 WS_XML_DATETIME_TEXT *ret;
920
921 if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL;
922 ret->text.textType = WS_XML_TEXT_TYPE_DATETIME;
923 ret->value = *value;
924 return ret;
925 }
926
927 static inline BOOL read_end_of_data( struct reader *reader )
928 {
929 return reader->read_pos >= reader->read_size;
930 }
931
932 static inline const unsigned char *read_current_ptr( struct reader *reader )
933 {
934 return &reader->read_bufptr[reader->read_pos];
935 }
936
937 static inline HRESULT read_peek( struct reader *reader, unsigned char *byte )
938 {
939 if (reader->read_pos >= reader->read_size) return WS_E_INVALID_FORMAT;
940 *byte = reader->read_bufptr[reader->read_pos];
941 return S_OK;
942 }
943
944 static inline HRESULT read_byte( struct reader *reader, unsigned char *byte )
945 {
946 if (reader->read_pos >= reader->read_size) return WS_E_INVALID_FORMAT;
947 *byte = reader->read_bufptr[reader->read_pos++];
948 return S_OK;
949 }
950
951 static inline HRESULT read_bytes( struct reader *reader, unsigned char *bytes, unsigned int len )
952 {
953 if (reader->read_pos + len > reader->read_size) return WS_E_INVALID_FORMAT;
954 memcpy( bytes, reader->read_bufptr + reader->read_pos, len );
955 reader->read_pos += len;
956 return S_OK;
957 }
958
959 /* UTF-8 support based on libs/wine/utf8.c */
960
961 /* number of following bytes in sequence based on first byte value (for bytes above 0x7f) */
962 static const char utf8_length[128] =
963 {
964 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x80-0x8f */
965 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x90-0x9f */
966 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xa0-0xaf */
967 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xb0-0xbf */
968 0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 0xc0-0xcf */
969 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 0xd0-0xdf */
970 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, /* 0xe0-0xef */
971 3,3,3,3,3,0,0,0,0,0,0,0,0,0,0,0 /* 0xf0-0xff */
972 };
973
974 /* first byte mask depending on UTF-8 sequence length */
975 static const unsigned char utf8_mask[4] = { 0x7f, 0x1f, 0x0f, 0x07 };
976
977 /* minimum Unicode value depending on UTF-8 sequence length */
978 static const unsigned int utf8_minval[4] = { 0x0, 0x80, 0x800, 0x10000 };
979
980 static inline unsigned int read_utf8_char( struct reader *reader, unsigned int *skip )
981 {
982 unsigned int len, res;
983 unsigned char ch = reader->read_bufptr[reader->read_pos];
984 const unsigned char *end;
985
986 if (reader->read_pos >= reader->read_size) return 0;
987
988 if (ch < 0x80)
989 {
990 *skip = 1;
991 return ch;
992 }
993 len = utf8_length[ch - 0x80];
994 if (reader->read_pos + len >= reader->read_size) return 0;
995 end = reader->read_bufptr + reader->read_pos + len + 1;
996 res = ch & utf8_mask[len];
997
998 switch (len)
999 {
1000 case 3:
1001 if ((ch = end[-3] ^ 0x80) >= 0x40) break;
1002 res = (res << 6) | ch;
1003 case 2:
1004 if ((ch = end[-2] ^ 0x80) >= 0x40) break;
1005 res = (res << 6) | ch;
1006 case 1:
1007 if ((ch = end[-1] ^ 0x80) >= 0x40) break;
1008 res = (res << 6) | ch;
1009 if (res < utf8_minval[len]) break;
1010 *skip = len + 1;
1011 return res;
1012 }
1013
1014 return 0;
1015 }
1016
1017 static inline void read_skip( struct reader *reader, unsigned int count )
1018 {
1019 if (reader->read_pos + count > reader->read_size) return;
1020 reader->read_pos += count;
1021 }
1022
1023 static inline void read_rewind( struct reader *reader, unsigned int count )
1024 {
1025 reader->read_pos -= count;
1026 }
1027
1028 static inline BOOL read_isnamechar( unsigned int ch )
1029 {
1030 /* FIXME: incomplete */
1031 return (ch >= 'A' && ch <= 'Z') ||
1032 (ch >= 'a' && ch <= 'z') ||
1033 (ch >= '0' && ch <= '9') ||
1034 ch == '_' || ch == '-' || ch == '.' || ch == ':';
1035 }
1036
1037 static inline BOOL read_isspace( unsigned int ch )
1038 {
1039 return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n';
1040 }
1041
1042 static inline void read_skip_whitespace( struct reader *reader )
1043 {
1044 while (reader->read_pos < reader->read_size && read_isspace( reader->read_bufptr[reader->read_pos] ))
1045 reader->read_pos++;
1046 }
1047
1048 static inline int read_cmp( struct reader *reader, const char *str, int len )
1049 {
1050 const unsigned char *ptr = read_current_ptr( reader );
1051
1052 if (len < 0) len = strlen( str );
1053 if (reader->read_pos + len > reader->read_size) return -1;
1054 while (len--)
1055 {
1056 if (*str != *ptr) return *ptr - *str;
1057 str++; ptr++;
1058 }
1059 return 0;
1060 }
1061
1062 static HRESULT read_xmldecl( struct reader *reader )
1063 {
1064 if (!reader->read_size) return WS_E_INVALID_FORMAT;
1065
1066 if (read_cmp( reader, "<", 1 ) || read_cmp( reader, "<?", 2 ))
1067 {
1068 reader->state = READER_STATE_BOF;
1069 return S_OK;
1070 }
1071 if (read_cmp( reader, "<?xml ", 6 )) return WS_E_INVALID_FORMAT;
1072 read_skip( reader, 6 );
1073
1074 /* FIXME: parse attributes */
1075 while (reader->read_pos < reader->read_size && reader->read_bufptr[reader->read_pos] != '?')
1076 reader->read_pos++;
1077
1078 if (read_cmp( reader, "?>", 2 )) return WS_E_INVALID_FORMAT;
1079 read_skip( reader, 2 );
1080
1081 reader->state = READER_STATE_BOF;
1082 return S_OK;
1083 }
1084
1085 HRESULT append_attribute( WS_XML_ELEMENT_NODE *elem, WS_XML_ATTRIBUTE *attr )
1086 {
1087 if (elem->attributeCount)
1088 {
1089 WS_XML_ATTRIBUTE **tmp;
1090 if (!(tmp = heap_realloc( elem->attributes, (elem->attributeCount + 1) * sizeof(attr) )))
1091 return E_OUTOFMEMORY;
1092 elem->attributes = tmp;
1093 }
1094 else if (!(elem->attributes = heap_alloc( sizeof(attr) ))) return E_OUTOFMEMORY;
1095 elem->attributes[elem->attributeCount++] = attr;
1096 return S_OK;
1097 }
1098
1099 static inline void init_xml_string( BYTE *bytes, ULONG len, WS_XML_STRING *str )
1100 {
1101 str->length = len;
1102 str->bytes = bytes;
1103 str->dictionary = NULL;
1104 str->id = 0;
1105 }
1106
1107 static HRESULT split_qname( const BYTE *str, ULONG len, WS_XML_STRING *prefix, WS_XML_STRING *localname )
1108 {
1109 BYTE *prefix_bytes = NULL, *localname_bytes = (BYTE *)str, *ptr = (BYTE *)str;
1110 ULONG prefix_len = 0, localname_len = len;
1111
1112 while (len--)
1113 {
1114 if (*ptr == ':')
1115 {
1116 if (ptr == str) return WS_E_INVALID_FORMAT;
1117 prefix_bytes = (BYTE *)str;
1118 prefix_len = ptr - str;
1119 localname_bytes = ptr + 1;
1120 localname_len = len;
1121 break;
1122 }
1123 ptr++;
1124 }
1125 if (!localname_len) return WS_E_INVALID_FORMAT;
1126
1127 init_xml_string( prefix_bytes, prefix_len, prefix );
1128 init_xml_string( localname_bytes, localname_len, localname );
1129 return S_OK;
1130 }
1131
1132 static HRESULT parse_qname( const BYTE *str, ULONG len, WS_XML_STRING **prefix_ret, WS_XML_STRING **localname_ret )
1133 {
1134 WS_XML_STRING prefix, localname;
1135 HRESULT hr;
1136
1137 if ((hr = split_qname( str, len, &prefix, &localname )) != S_OK) return hr;
1138 if (!(*prefix_ret = alloc_xml_string( NULL, prefix.length ))) return E_OUTOFMEMORY;
1139 if (!(*localname_ret = dup_xml_string( &localname, FALSE )))
1140 {
1141 free_xml_string( *prefix_ret );
1142 return E_OUTOFMEMORY;
1143 }
1144 memcpy( (*prefix_ret)->bytes, prefix.bytes, prefix.length );
1145 if (prefix.length && add_xml_string( *prefix_ret ) != S_OK) WARN( "prefix not added to dictionary\n" );
1146 return S_OK;
1147 }
1148
1149 static int codepoint_to_utf8( int cp, unsigned char *dst )
1150 {
1151 if (!cp) return -1;
1152 if (cp < 0x80)
1153 {
1154 *dst = cp;
1155 return 1;
1156 }
1157 if (cp < 0x800)
1158 {
1159 dst[1] = 0x80 | (cp & 0x3f);
1160 cp >>= 6;
1161 dst[0] = 0xc0 | cp;
1162 return 2;
1163 }
1164 if ((cp >= 0xd800 && cp <= 0xdfff) || cp == 0xfffe || cp == 0xffff) return -1;
1165 if (cp < 0x10000)
1166 {
1167 dst[2] = 0x80 | (cp & 0x3f);
1168 cp >>= 6;
1169 dst[1] = 0x80 | (cp & 0x3f);
1170 cp >>= 6;
1171 dst[0] = 0xe0 | cp;
1172 return 3;
1173 }
1174 if (cp >= 0x110000) return -1;
1175 dst[3] = 0x80 | (cp & 0x3f);
1176 cp >>= 6;
1177 dst[2] = 0x80 | (cp & 0x3f);
1178 cp >>= 6;
1179 dst[1] = 0x80 | (cp & 0x3f);
1180 cp >>= 6;
1181 dst[0] = 0xf0 | cp;
1182 return 4;
1183 }
1184
1185 static HRESULT decode_text( const unsigned char *str, ULONG len, unsigned char *ret, ULONG *ret_len )
1186 {
1187 const unsigned char *p = str;
1188 unsigned char *q = ret;
1189
1190 *ret_len = 0;
1191 while (len)
1192 {
1193 if (*p == '&')
1194 {
1195 p++; len--;
1196 if (!len) return WS_E_INVALID_FORMAT;
1197
1198 if (len >= 3 && !memcmp( p, "lt;", 3 ))
1199 {
1200 *q++ = '<';
1201 p += 3;
1202 len -= 3;
1203 }
1204 else if (len >= 3 && !memcmp( p, "gt;", 3 ))
1205 {
1206 *q++ = '>';
1207 p += 3;
1208 len -= 3;
1209 }
1210 else if (len >= 5 && !memcmp( p, "quot;", 5 ))
1211 {
1212 *q++ = '"';
1213 p += 5;
1214 len -= 5;
1215 }
1216 else if (len >= 4 && !memcmp( p, "amp;", 4 ))
1217 {
1218 *q++ = '&';
1219 p += 4;
1220 len -= 4;
1221 }
1222 else if (len >= 5 && !memcmp( p, "apos;", 5 ))
1223 {
1224 *q++ = '\'';
1225 p += 5;
1226 len -= 5;
1227 }
1228 else if (*p == '#')
1229 {
1230 ULONG start, nb_digits, i;
1231 int len_utf8, cp = 0;
1232
1233 p++; len--;
1234 if (!len) return WS_E_INVALID_FORMAT;
1235 if (*p == 'x')
1236 {
1237 p++; len--;
1238
1239 start = len;
1240 while (len && isxdigit( *p )) { p++; len--; };
1241 if (!len) return WS_E_INVALID_FORMAT;
1242
1243 p -= nb_digits = start - len;
1244 if (!nb_digits || nb_digits > 6 || p[nb_digits] != ';') return WS_E_INVALID_FORMAT;
1245 for (i = 0; i < nb_digits; i++)
1246 {
1247 cp *= 16;
1248 if (*p >= '0' && *p <= '9') cp += *p - '0';
1249 else if (*p >= 'a' && *p <= 'f') cp += *p - 'a' + 10;
1250 else cp += *p - 'A' + 10;
1251 p++;
1252 }
1253 }
1254 else if (isdigit( *p ))
1255 {
1256 while (len && *p == '0') { p++; len--; };
1257 if (!len) return WS_E_INVALID_FORMAT;
1258
1259 start = len;
1260 while (len && isdigit( *p )) { p++; len--; };
1261 if (!len) return WS_E_INVALID_FORMAT;
1262
1263 p -= nb_digits = start - len;
1264 if (!nb_digits || nb_digits > 7 || p[nb_digits] != ';') return WS_E_INVALID_FORMAT;
1265 for (i = 0; i < nb_digits; i++)
1266 {
1267 cp *= 10;
1268 cp += *p - '0';
1269 p++;
1270 }
1271 }
1272 else return WS_E_INVALID_FORMAT;
1273 p++; len--;
1274 if ((len_utf8 = codepoint_to_utf8( cp, q )) < 0) return WS_E_INVALID_FORMAT;
1275 *ret_len += len_utf8;
1276 q += len_utf8;
1277 continue;
1278 }
1279 else return WS_E_INVALID_FORMAT;
1280 }
1281 else
1282 {
1283 *q++ = *p++;
1284 len--;
1285 }
1286 *ret_len += 1;
1287 }
1288 return S_OK;
1289 }
1290
1291 static HRESULT read_attribute_value_text( struct reader *reader, WS_XML_ATTRIBUTE *attr )
1292 {
1293 WS_XML_UTF8_TEXT *utf8 = NULL;
1294 unsigned int len, ch, skip, quote;
1295 const unsigned char *start;
1296 HRESULT hr = E_OUTOFMEMORY;
1297
1298 read_skip_whitespace( reader );
1299 if (read_cmp( reader, "=", 1 )) return WS_E_INVALID_FORMAT;
1300 read_skip( reader, 1 );
1301
1302 read_skip_whitespace( reader );
1303 if (read_cmp( reader, "\"", 1 ) && read_cmp( reader, "'", 1 )) return WS_E_INVALID_FORMAT;
1304 quote = read_utf8_char( reader, &skip );
1305 read_skip( reader, 1 );
1306
1307 len = 0;
1308 start = read_current_ptr( reader );
1309 for (;;)
1310 {
1311 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
1312 if (ch == quote) break;
1313 read_skip( reader, skip );
1314 len += skip;
1315 }
1316 read_skip( reader, 1 );
1317
1318 if (attr->isXmlNs)
1319 {
1320 if (!(attr->ns = alloc_xml_string( start, len ))) goto error;
1321 if ((hr = bind_prefix( reader, attr->prefix, attr->ns )) != S_OK) goto error;
1322 if (!(utf8 = alloc_utf8_text( NULL, 0 )))
1323 {
1324 hr = E_OUTOFMEMORY;
1325 goto error;
1326 }
1327 }
1328 else
1329 {
1330 if (!(utf8 = alloc_utf8_text( NULL, len ))) goto error;
1331 if ((hr = decode_text( start, len, utf8->value.bytes, &utf8->value.length )) != S_OK) goto error;
1332 }
1333
1334 attr->value = &utf8->text;
1335 attr->singleQuote = (quote == '\'');
1336 return S_OK;
1337
1338 error:
1339 heap_free( utf8 );
1340 return hr;
1341 }
1342
1343 static inline BOOL is_text_type( unsigned char type )
1344 {
1345 return (type >= RECORD_ZERO_TEXT && type <= RECORD_QNAME_DICTIONARY_TEXT_WITH_ENDELEMENT);
1346 }
1347
1348 static HRESULT read_int31( struct reader *reader, ULONG *len )
1349 {
1350 unsigned char byte;
1351 HRESULT hr;
1352
1353 if ((hr = read_byte( reader, &byte )) != S_OK) return hr;
1354 *len = byte & 0x7f;
1355 if (!(byte & 0x80)) return S_OK;
1356
1357 if ((hr = read_byte( reader, &byte )) != S_OK) return hr;
1358 *len += (byte & 0x7f) << 7;
1359 if (!(byte & 0x80)) return S_OK;
1360
1361 if ((hr = read_byte( reader, &byte )) != S_OK) return hr;
1362 *len += (byte & 0x7f) << 14;
1363 if (!(byte & 0x80)) return S_OK;
1364
1365 if ((hr = read_byte( reader, &byte )) != S_OK) return hr;
1366 *len += (byte & 0x7f) << 21;
1367 if (!(byte & 0x80)) return S_OK;
1368
1369 if ((hr = read_byte( reader, &byte )) != S_OK) return hr;
1370 *len += (byte & 0x07) << 28;
1371 return S_OK;
1372 }
1373
1374 static HRESULT read_string( struct reader *reader, WS_XML_STRING **str )
1375 {
1376 ULONG len;
1377 HRESULT hr;
1378 if ((hr = read_int31( reader, &len )) != S_OK) return hr;
1379 if (!(*str = alloc_xml_string( NULL, len ))) return E_OUTOFMEMORY;
1380 if ((hr = read_bytes( reader, (*str)->bytes, len )) == S_OK)
1381 {
1382 if (add_xml_string( *str ) != S_OK) WARN( "string not added to dictionary\n" );
1383 return S_OK;
1384 }
1385 free_xml_string( *str );
1386 return hr;
1387 }
1388
1389 static HRESULT read_dict_string( struct reader *reader, WS_XML_STRING **str )
1390 {
1391 const WS_XML_DICTIONARY *dict;
1392 HRESULT hr;
1393 ULONG id;
1394
1395 if ((hr = read_int31( reader, &id )) != S_OK) return hr;
1396 dict = (id & 1) ? reader->dict : reader->dict_static;
1397 if (!dict || (id >>= 1) >= dict->stringCount) return WS_E_INVALID_FORMAT;
1398 if (!(*str = alloc_xml_string( NULL, 0 ))) return E_OUTOFMEMORY;
1399 *(*str) = dict->strings[id];
1400 return S_OK;
1401 }
1402
1403 static HRESULT read_datetime( struct reader *reader, WS_DATETIME *ret )
1404 {
1405 UINT64 val;
1406 HRESULT hr;
1407
1408 if ((hr = read_bytes( reader, (unsigned char *)&val, sizeof(val) )) != S_OK) return hr;
1409
1410 if ((val & 0x03) == 1) ret->format = WS_DATETIME_FORMAT_UTC;
1411 else if ((val & 0x03) == 2) ret->format = WS_DATETIME_FORMAT_LOCAL;
1412 else ret->format = WS_DATETIME_FORMAT_NONE;
1413
1414 if ((ret->ticks = val >> 2) > TICKS_MAX) return WS_E_INVALID_FORMAT;
1415 return S_OK;
1416 }
1417
1418 static HRESULT lookup_string( struct reader *reader, ULONG id, const WS_XML_STRING **ret )
1419 {
1420 const WS_XML_DICTIONARY *dict = (id & 1) ? reader->dict : reader->dict_static;
1421 if (!dict || (id >>= 1) >= dict->stringCount) return WS_E_INVALID_FORMAT;
1422 *ret = &dict->strings[id];
1423 return S_OK;
1424 }
1425
1426 static HRESULT read_attribute_value_bin( struct reader *reader, WS_XML_ATTRIBUTE *attr )
1427 {
1428 WS_XML_UTF8_TEXT *text_utf8 = NULL;
1429 WS_XML_BASE64_TEXT *text_base64 = NULL;
1430 WS_XML_INT32_TEXT *text_int32;
1431 WS_XML_INT64_TEXT *text_int64;
1432 WS_XML_BOOL_TEXT *text_bool;
1433 const WS_XML_STRING *str;
1434 unsigned char type;
1435 UINT8 val_uint8;
1436 UINT16 val_uint16;
1437 INT32 val_int32;
1438 ULONG len = 0, id;
1439 GUID guid;
1440 HRESULT hr;
1441
1442 if ((hr = read_byte( reader, &type )) != S_OK) return hr;
1443 if (!is_text_type( type )) return WS_E_INVALID_FORMAT;
1444
1445 switch (type)
1446 {
1447 case RECORD_ZERO_TEXT:
1448 {
1449 if (!(text_int32 = alloc_int32_text( 0 ))) return E_OUTOFMEMORY;
1450 attr->value = &text_int32->text;
1451 return S_OK;
1452 }
1453 case RECORD_ONE_TEXT:
1454 {
1455 if (!(text_int32 = alloc_int32_text( 1 ))) return E_OUTOFMEMORY;
1456 attr->value = &text_int32->text;
1457 return S_OK;
1458 }
1459 case RECORD_FALSE_TEXT:
1460 {
1461 if (!(text_bool = alloc_bool_text( FALSE ))) return E_OUTOFMEMORY;
1462 attr->value = &text_bool->text;
1463 return S_OK;
1464 }
1465 case RECORD_TRUE_TEXT:
1466 {
1467 if (!(text_bool = alloc_bool_text( TRUE ))) return E_OUTOFMEMORY;
1468 attr->value = &text_bool->text;
1469 return S_OK;
1470 }
1471 case RECORD_INT8_TEXT:
1472 {
1473 INT8 val_int8;
1474 if ((hr = read_byte( reader, (unsigned char *)&val_int8 )) != S_OK) return hr;
1475 if (!(text_int64 = alloc_int64_text( val_int8 ))) return E_OUTOFMEMORY;
1476 attr->value = &text_int64->text;
1477 return S_OK;
1478 }
1479 case RECORD_INT16_TEXT:
1480 {
1481 INT16 val_int16;
1482 if ((hr = read_bytes( reader, (unsigned char *)&val_int16, sizeof(val_int16) )) != S_OK) return hr;
1483 if (!(text_int64 = alloc_int64_text( val_int16 ))) return E_OUTOFMEMORY;
1484 attr->value = &text_int64->text;
1485 return S_OK;
1486 }
1487 case RECORD_INT32_TEXT:
1488 if ((hr = read_bytes( reader, (unsigned char *)&val_int32, sizeof(val_int32) )) != S_OK) return hr;
1489 if (!(text_int64 = alloc_int64_text( val_int32 ))) return E_OUTOFMEMORY;
1490 attr->value = &text_int64->text;
1491 return S_OK;
1492
1493 case RECORD_INT64_TEXT:
1494 {
1495 INT64 val_int64;
1496 if ((hr = read_bytes( reader, (unsigned char *)&val_int64, sizeof(val_int64) )) != S_OK) return hr;
1497 if (!(text_int64 = alloc_int64_text( val_int64 ))) return E_OUTOFMEMORY;
1498 attr->value = &text_int64->text;
1499 return S_OK;
1500 }
1501 case RECORD_FLOAT_TEXT:
1502 {
1503 WS_XML_FLOAT_TEXT *text_float;
1504 float val_float;
1505
1506 if ((hr = read_bytes( reader, (unsigned char *)&val_float, sizeof(val_float) )) != S_OK) return hr;
1507 if (!(text_float = alloc_float_text( val_float ))) return E_OUTOFMEMORY;
1508 attr->value = &text_float->text;
1509 return S_OK;
1510 }
1511 case RECORD_DOUBLE_TEXT:
1512 {
1513 WS_XML_DOUBLE_TEXT *text_double;
1514 double val_double;
1515
1516 if ((hr = read_bytes( reader, (unsigned char *)&val_double, sizeof(val_double) )) != S_OK) return hr;
1517 if (!(text_double = alloc_double_text( val_double ))) return E_OUTOFMEMORY;
1518 attr->value = &text_double->text;
1519 return S_OK;
1520 }
1521 case RECORD_DATETIME_TEXT:
1522 {
1523 WS_XML_DATETIME_TEXT *text_datetime;
1524 WS_DATETIME datetime;
1525
1526 if ((hr = read_datetime( reader, &datetime )) != S_OK) return hr;
1527 if (!(text_datetime = alloc_datetime_text( &datetime ))) return E_OUTOFMEMORY;
1528 attr->value = &text_datetime->text;
1529 return S_OK;
1530 }
1531 case RECORD_CHARS8_TEXT:
1532 if ((hr = read_byte( reader, (unsigned char *)&val_uint8 )) != S_OK) return hr;
1533 len = val_uint8;
1534 break;
1535
1536 case RECORD_CHARS16_TEXT:
1537 if ((hr = read_bytes( reader, (unsigned char *)&val_uint16, sizeof(val_uint16) )) != S_OK) return hr;
1538 len = val_uint16;
1539 break;
1540
1541 case RECORD_CHARS32_TEXT:
1542 if ((hr = read_bytes( reader, (unsigned char *)&val_int32, sizeof(val_int32) )) != S_OK) return hr;
1543 if (val_int32 < 0) return WS_E_INVALID_FORMAT;
1544 len = val_int32;
1545 break;
1546
1547 case RECORD_BYTES8_TEXT:
1548 if ((hr = read_byte( reader, (unsigned char *)&val_uint8 )) != S_OK) return hr;
1549 if (!(text_base64 = alloc_base64_text( NULL, val_uint8 ))) return E_OUTOFMEMORY;
1550 if ((hr = read_bytes( reader, text_base64->bytes, val_uint8 )) != S_OK)
1551 {
1552 heap_free( text_base64 );
1553 return hr;
1554 }
1555 break;
1556
1557 case RECORD_BYTES16_TEXT:
1558 if ((hr = read_bytes( reader, (unsigned char *)&val_uint16, sizeof(val_uint16) )) != S_OK) return hr;
1559 if (!(text_base64 = alloc_base64_text( NULL, val_uint16 ))) return E_OUTOFMEMORY;
1560 if ((hr = read_bytes( reader, text_base64->bytes, val_uint16 )) != S_OK)
1561 {
1562 heap_free( text_base64 );
1563 return hr;
1564 }
1565 break;
1566
1567 case RECORD_BYTES32_TEXT:
1568 if ((hr = read_bytes( reader, (unsigned char *)&val_int32, sizeof(val_int32) )) != S_OK) return hr;
1569 if (val_int32 < 0) return WS_E_INVALID_FORMAT;
1570 if (!(text_base64 = alloc_base64_text( NULL, val_int32 ))) return E_OUTOFMEMORY;
1571 if ((hr = read_bytes( reader, text_base64->bytes, val_int32 )) != S_OK)
1572 {
1573 heap_free( text_base64 );
1574 return hr;
1575 }
1576 break;
1577
1578 case RECORD_EMPTY_TEXT:
1579 break;
1580
1581 case RECORD_DICTIONARY_TEXT:
1582 if ((hr = read_int31( reader, &id )) != S_OK) return hr;
1583 if ((hr = lookup_string( reader, id, &str )) != S_OK) return hr;
1584 if (!(text_utf8 = alloc_utf8_text( str->bytes, str->length ))) return E_OUTOFMEMORY;
1585 break;
1586
1587 case RECORD_UNIQUE_ID_TEXT:
1588 {
1589 WS_XML_UNIQUE_ID_TEXT *text_unique_id;
1590 if ((hr = read_bytes( reader, (unsigned char *)&guid, sizeof(guid) )) != S_OK) return hr;
1591 if (!(text_unique_id = alloc_unique_id_text( &guid ))) return E_OUTOFMEMORY;
1592 attr->value = &text_unique_id->text;
1593 return S_OK;
1594 }
1595 case RECORD_GUID_TEXT:
1596 {
1597 WS_XML_GUID_TEXT *guid_text;
1598 if ((hr = read_bytes( reader, (unsigned char *)&guid, sizeof(guid) )) != S_OK) return hr;
1599 if (!(guid_text = alloc_guid_text( &guid ))) return E_OUTOFMEMORY;
1600 attr->value = &guid_text->text;
1601 return S_OK;
1602 }
1603 case RECORD_UINT64_TEXT:
1604 {
1605 WS_XML_UINT64_TEXT *text_uint64;
1606 UINT64 val_uint64;
1607
1608 if ((hr = read_bytes( reader, (unsigned char *)&val_uint64, sizeof(val_uint64) )) != S_OK) return hr;
1609 if (!(text_uint64 = alloc_uint64_text( val_uint64 ))) return E_OUTOFMEMORY;
1610 attr->value = &text_uint64->text;
1611 return S_OK;
1612 }
1613 case RECORD_BOOL_TEXT:
1614 {
1615 WS_XML_BOOL_TEXT *text_bool;
1616 BOOL val_bool;
1617
1618 if ((hr = read_bytes( reader, (unsigned char *)&val_bool, sizeof(val_bool) )) != S_OK) return hr;
1619 if (!(text_bool = alloc_bool_text( !!val_bool ))) return E_OUTOFMEMORY;
1620 attr->value = &text_bool->text;
1621 return S_OK;
1622 }
1623 default:
1624 ERR( "unhandled record type %02x\n", type );
1625 return WS_E_NOT_SUPPORTED;
1626 }
1627
1628 if (type >= RECORD_BYTES8_TEXT && type <= RECORD_BYTES32_TEXT)
1629 {
1630 attr->value = &text_base64->text;
1631 return S_OK;
1632 }
1633
1634 if (!text_utf8)
1635 {
1636 if (!(text_utf8 = alloc_utf8_text( NULL, len ))) return E_OUTOFMEMORY;
1637 if (!len) text_utf8->value.bytes = (BYTE *)(text_utf8 + 1); /* quirk */
1638 if ((hr = read_bytes( reader, text_utf8->value.bytes, len )) != S_OK)
1639 {
1640 heap_free( text_utf8 );
1641 return hr;
1642 }
1643 }
1644
1645 attr->value = &text_utf8->text;
1646 return S_OK;
1647 }
1648
1649 static HRESULT read_attribute_text( struct reader *reader, WS_XML_ATTRIBUTE **ret )
1650 {
1651 static const WS_XML_STRING xmlns = {5, (BYTE *)"xmlns"};
1652 WS_XML_ATTRIBUTE *attr;
1653 unsigned int len = 0, ch, skip;
1654 const unsigned char *start;
1655 WS_XML_STRING *prefix, *localname;
1656 HRESULT hr = WS_E_INVALID_FORMAT;
1657
1658 if (!(attr = heap_alloc_zero( sizeof(*attr) ))) return E_OUTOFMEMORY;
1659
1660 start = read_current_ptr( reader );
1661 for (;;)
1662 {
1663 if (!(ch = read_utf8_char( reader, &skip ))) goto error;
1664 if (!read_isnamechar( ch )) break;
1665 read_skip( reader, skip );
1666 len += skip;
1667 }
1668 if (!len) goto error;
1669
1670 if ((hr = parse_qname( start, len, &prefix, &localname )) != S_OK) goto error;
1671 if (WsXmlStringEquals( prefix, &xmlns, NULL ) == S_OK)
1672 {
1673 free_xml_string( prefix );
1674 attr->isXmlNs = 1;
1675 if (!(attr->prefix = alloc_xml_string( localname->bytes, localname->length )))
1676 {
1677 free_xml_string( localname );
1678 hr = E_OUTOFMEMORY;
1679 goto error;
1680 }
1681 attr->localName = localname;
1682 }
1683 else if (!prefix->length && WsXmlStringEquals( localname, &xmlns, NULL ) == S_OK)
1684 {
1685 attr->isXmlNs = 1;
1686 attr->prefix = prefix;
1687 attr->localName = localname;
1688 }
1689 else
1690 {
1691 attr->prefix = prefix;
1692 attr->localName = localname;
1693 }
1694
1695 if ((hr = read_attribute_value_text( reader, attr )) != S_OK) goto error;
1696
1697 *ret = attr;
1698 return S_OK;
1699
1700 error:
1701 free_attribute( attr );
1702 return hr;
1703 }
1704
1705 static inline BOOL is_attribute_type( unsigned char type )
1706 {
1707 return (type >= RECORD_SHORT_ATTRIBUTE && type <= RECORD_PREFIX_ATTRIBUTE_Z);
1708 }
1709
1710 static WS_XML_STRING *get_xmlns_localname( struct reader *reader, const WS_XML_STRING *prefix )
1711 {
1712 if (!get_namespace( reader, prefix )) return alloc_xml_string( NULL, 0 );
1713 return alloc_xml_string( prefix->bytes, prefix->length );
1714 }
1715
1716 static HRESULT read_attribute_bin( struct reader *reader, WS_XML_ATTRIBUTE **ret )
1717 {
1718 WS_XML_UTF8_TEXT *utf8;
1719 WS_XML_ATTRIBUTE *attr;
1720 unsigned char type = 0;
1721 HRESULT hr;
1722
1723 if ((hr = read_byte( reader, &type )) != S_OK) return hr;
1724 if (!is_attribute_type( type )) return WS_E_INVALID_FORMAT;
1725 if (!(attr = heap_alloc_zero( sizeof(*attr) ))) return E_OUTOFMEMORY;
1726
1727 if (type >= RECORD_PREFIX_ATTRIBUTE_A && type <= RECORD_PREFIX_ATTRIBUTE_Z)
1728 {
1729 unsigned char ch = type - RECORD_PREFIX_ATTRIBUTE_A + 'a';
1730 if (!(attr->prefix = alloc_xml_string( &ch, 1 )))
1731 {
1732 hr = E_OUTOFMEMORY;
1733 goto error;
1734 }
1735 if ((hr = read_string( reader, &attr->localName )) != S_OK) goto error;
1736 if ((hr = read_attribute_value_bin( reader, attr )) != S_OK) goto error;
1737 }
1738 else if (type >= RECORD_PREFIX_DICTIONARY_ATTRIBUTE_A && type <= RECORD_PREFIX_DICTIONARY_ATTRIBUTE_Z)
1739 {
1740 unsigned char ch = type - RECORD_PREFIX_DICTIONARY_ATTRIBUTE_A + 'a';
1741 if (!(attr->prefix = alloc_xml_string( &ch, 1 )))
1742 {
1743 hr = E_OUTOFMEMORY;
1744 goto error;
1745 }
1746 if ((hr = read_dict_string( reader, &attr->localName )) != S_OK) goto error;
1747 if ((hr = read_attribute_value_bin( reader, attr )) != S_OK) goto error;
1748 }
1749 else
1750 {
1751 switch (type)
1752 {
1753 case RECORD_SHORT_ATTRIBUTE:
1754 if (!(attr->prefix = alloc_xml_string( NULL, 0 )))
1755 {
1756 hr = E_OUTOFMEMORY;
1757 goto error;
1758 }
1759 if ((hr = read_string( reader, &attr->localName )) != S_OK) goto error;
1760 if ((hr = read_attribute_value_bin( reader, attr )) != S_OK) goto error;
1761 break;
1762
1763 case RECORD_ATTRIBUTE:
1764 if ((hr = read_string( reader, &attr->prefix )) != S_OK) goto error;
1765 if ((hr = read_string( reader, &attr->localName )) != S_OK) goto error;
1766 if ((hr = read_attribute_value_bin( reader, attr )) != S_OK) goto error;
1767 break;
1768
1769 case RECORD_SHORT_DICTIONARY_ATTRIBUTE:
1770 if (!(attr->prefix = alloc_xml_string( NULL, 0 )))
1771 {
1772 hr = E_OUTOFMEMORY;
1773 goto error;
1774 }
1775 if ((hr = read_dict_string( reader, &attr->localName )) != S_OK) goto error;
1776 if ((hr = read_attribute_value_bin( reader, attr )) != S_OK) goto error;
1777 break;
1778
1779 case RECORD_DICTIONARY_ATTRIBUTE:
1780 if ((hr = read_string( reader, &attr->prefix )) != S_OK) goto error;
1781 if ((hr = read_dict_string( reader, &attr->localName )) != S_OK) goto error;
1782 if ((hr = read_attribute_value_bin( reader, attr )) != S_OK) goto error;
1783 break;
1784
1785 case RECORD_SHORT_XMLNS_ATTRIBUTE:
1786 if (!(attr->prefix = alloc_xml_string( NULL, 0 )))
1787 {
1788 hr = E_OUTOFMEMORY;
1789 goto error;
1790 }
1791 if (!(attr->localName = get_xmlns_localname( reader, attr->prefix )))
1792 {
1793 hr = E_OUTOFMEMORY;
1794 goto error;
1795 }
1796 if ((hr = read_string( reader, &attr->ns )) != S_OK) goto error;
1797 if ((hr = bind_prefix( reader, attr->prefix, attr->ns )) != S_OK) goto error;
1798 attr->isXmlNs = 1;
1799 break;
1800
1801 case RECORD_XMLNS_ATTRIBUTE:
1802 if ((hr = read_string( reader, &attr->prefix )) != S_OK) goto error;
1803 if (!(attr->localName = get_xmlns_localname( reader, attr->prefix )))
1804 {
1805 hr = E_OUTOFMEMORY;
1806 goto error;
1807 }
1808 if ((hr = read_string( reader, &attr->ns )) != S_OK) goto error;
1809 if ((hr = bind_prefix( reader, attr->prefix, attr->ns )) != S_OK) goto error;
1810 attr->isXmlNs = 1;
1811 break;
1812
1813 case RECORD_SHORT_DICTIONARY_XMLNS_ATTRIBUTE:
1814 if (!(attr->prefix = alloc_xml_string( NULL, 0 )))
1815 {
1816 hr = E_OUTOFMEMORY;
1817 goto error;
1818 }
1819 if (!(attr->localName = get_xmlns_localname( reader, attr->prefix )))
1820 {
1821 hr = E_OUTOFMEMORY;
1822 goto error;
1823 }
1824 if ((hr = read_dict_string( reader, &attr->ns )) != S_OK) goto error;
1825 if (!(utf8 = alloc_utf8_text( NULL, 0 )))
1826 {
1827 hr = E_OUTOFMEMORY;
1828 goto error;
1829 }
1830 attr->value = &utf8->text;
1831 if ((hr = bind_prefix( reader, attr->prefix, attr->ns )) != S_OK) goto error;
1832 attr->isXmlNs = 1;
1833 break;
1834
1835 case RECORD_DICTIONARY_XMLNS_ATTRIBUTE:
1836 if ((hr = read_string( reader, &attr->prefix )) != S_OK) goto error;
1837 if (!(attr->localName = get_xmlns_localname( reader, attr->prefix )))
1838 {
1839 hr = E_OUTOFMEMORY;
1840 goto error;
1841 }
1842 if ((hr = read_dict_string( reader, &attr->ns )) != S_OK) goto error;
1843 if (!(utf8 = alloc_utf8_text( NULL, 0 )))
1844 {
1845 hr = E_OUTOFMEMORY;
1846 goto error;
1847 }
1848 attr->value = &utf8->text;
1849 if ((hr = bind_prefix( reader, attr->prefix, attr->ns )) != S_OK) goto error;
1850 attr->isXmlNs = 1;
1851 break;
1852
1853 default:
1854 ERR( "unhandled record type %02x\n", type );
1855 return WS_E_NOT_SUPPORTED;
1856 }
1857 }
1858
1859 *ret = attr;
1860 return S_OK;
1861
1862 error:
1863 free_attribute( attr );
1864 return hr;
1865 }
1866
1867 static inline struct node *find_parent( struct reader *reader )
1868 {
1869 if (node_type( reader->current ) == WS_XML_NODE_TYPE_END_ELEMENT)
1870 {
1871 if (is_valid_parent( reader->current->parent->parent )) return reader->current->parent->parent;
1872 return NULL;
1873 }
1874 if (is_valid_parent( reader->current )) return reader->current;
1875 if (is_valid_parent( reader->current->parent )) return reader->current->parent;
1876 return NULL;
1877 }
1878
1879 static HRESULT set_namespaces( struct reader *reader, WS_XML_ELEMENT_NODE *elem )
1880 {
1881 static const WS_XML_STRING xml = {3, (BYTE *)"xml"};
1882 const WS_XML_STRING *ns;
1883 ULONG i;
1884
1885 if (!(ns = get_namespace( reader, elem->prefix ))) return WS_E_INVALID_FORMAT;
1886 if (!(elem->ns = dup_xml_string( ns, FALSE ))) return E_OUTOFMEMORY;
1887
1888 for (i = 0; i < elem->attributeCount; i++)
1889 {
1890 WS_XML_ATTRIBUTE *attr = elem->attributes[i];
1891 if (attr->isXmlNs || WsXmlStringEquals( attr->prefix, &xml, NULL ) == S_OK) continue;
1892 if (!(ns = get_namespace( reader, attr->prefix ))) return WS_E_INVALID_FORMAT;
1893 if (!(attr->ns = alloc_xml_string( NULL, ns->length ))) return E_OUTOFMEMORY;
1894 if (attr->ns->length) memcpy( attr->ns->bytes, ns->bytes, ns->length );
1895 }
1896 return S_OK;
1897 }
1898
1899 static WS_XML_ELEMENT_NODE *alloc_element_pair(void)
1900 {
1901 struct node *node, *end;
1902 if (!(node = alloc_node( WS_XML_NODE_TYPE_ELEMENT ))) return NULL;
1903 if (!(end = alloc_node( WS_XML_NODE_TYPE_END_ELEMENT )))
1904 {
1905 free_node( node );
1906 return NULL;
1907 }
1908 list_add_tail( &node->children, &end->entry );
1909 end->parent = node;
1910 return &node->hdr;
1911 }
1912
1913 static HRESULT read_attributes_text( struct reader *reader, WS_XML_ELEMENT_NODE *elem )
1914 {
1915 WS_XML_ATTRIBUTE *attr;
1916 HRESULT hr;
1917
1918 reader->current_attr = 0;
1919 for (;;)
1920 {
1921 read_skip_whitespace( reader );
1922 if (!read_cmp( reader, ">", 1 ) || !read_cmp( reader, "/>", 2 )) break;
1923 if ((hr = read_attribute_text( reader, &attr )) != S_OK) return hr;
1924 if ((hr = append_attribute( elem, attr )) != S_OK)
1925 {
1926 free_attribute( attr );
1927 return hr;
1928 }
1929 reader->current_attr++;
1930 }
1931 return S_OK;
1932 }
1933
1934 static HRESULT read_element_text( struct reader *reader )
1935 {
1936 unsigned int len = 0, ch, skip;
1937 const unsigned char *start;
1938 struct node *node = NULL, *parent;
1939 WS_XML_ELEMENT_NODE *elem;
1940 HRESULT hr = WS_E_INVALID_FORMAT;
1941
1942 if (read_end_of_data( reader ))
1943 {
1944 reader->current = LIST_ENTRY( list_tail( &reader->root->children ), struct node, entry );
1945 reader->last = reader->current;
1946 reader->state = READER_STATE_EOF;
1947 return S_OK;
1948 }
1949
1950 if (read_cmp( reader, "<", 1 )) return WS_E_INVALID_FORMAT;
1951 read_skip( reader, 1 );
1952 if (!read_isnamechar( read_utf8_char( reader, &skip )))
1953 {
1954 read_rewind( reader, 1 );
1955 return WS_E_INVALID_FORMAT;
1956 }
1957
1958 if (!(elem = alloc_element_pair())) return E_OUTOFMEMORY;
1959 node = (struct node *)elem;
1960
1961 start = read_current_ptr( reader );
1962 for (;;)
1963 {
1964 if (!(ch = read_utf8_char( reader, &skip ))) goto error;
1965 if (!read_isnamechar( ch )) break;
1966 read_skip( reader, skip );
1967 len += skip;
1968 }
1969 if (!len) goto error;
1970
1971 if (!(parent = find_parent( reader ))) goto error;
1972 if ((hr = parse_qname( start, len, &elem->prefix, &elem->localName )) != S_OK) goto error;
1973 if ((hr = read_attributes_text( reader, elem )) != S_OK) goto error;
1974 if ((hr = set_namespaces( reader, elem )) != S_OK) goto error;
1975
1976 read_insert_node( reader, parent, node );
1977 reader->state = READER_STATE_STARTELEMENT;
1978 return S_OK;
1979
1980 error:
1981 destroy_nodes( node );
1982 return hr;
1983 }
1984
1985 static inline BOOL is_element_type( unsigned char type )
1986 {
1987 return (type >= RECORD_SHORT_ELEMENT && type <= RECORD_PREFIX_ELEMENT_Z);
1988 }
1989
1990 static HRESULT read_attributes_bin( struct reader *reader, WS_XML_ELEMENT_NODE *elem )
1991 {
1992 WS_XML_ATTRIBUTE *attr;
1993 unsigned char type;
1994 HRESULT hr;
1995
1996 reader->current_attr = 0;
1997 for (;;)
1998 {
1999 if ((hr = read_peek( reader, &type )) != S_OK) return hr;
2000 if (!is_attribute_type( type )) break;
2001 if ((hr = read_attribute_bin( reader, &attr )) != S_OK) return hr;
2002 if ((hr = append_attribute( elem, attr )) != S_OK)
2003 {
2004 free_attribute( attr );
2005 return hr;
2006 }
2007 reader->current_attr++;
2008 }
2009 return S_OK;
2010 }
2011
2012 static HRESULT read_element_bin( struct reader *reader )
2013 {
2014 struct node *node = NULL, *parent;
2015 WS_XML_ELEMENT_NODE *elem;
2016 unsigned char type;
2017 HRESULT hr;
2018
2019 if ((hr = read_byte( reader, &type )) != S_OK) return hr;
2020 if (!is_element_type( type )) return WS_E_INVALID_FORMAT;
2021
2022 if (!(elem = alloc_element_pair())) return E_OUTOFMEMORY;
2023 node = (struct node *)elem;
2024
2025 if (type >= RECORD_PREFIX_ELEMENT_A && type <= RECORD_PREFIX_ELEMENT_Z)
2026 {
2027 unsigned char ch = type - RECORD_PREFIX_ELEMENT_A + 'a';
2028 if (!(elem->prefix = alloc_xml_string( &ch, 1 )))
2029 {
2030 hr = E_OUTOFMEMORY;
2031 goto error;
2032 }
2033 if ((hr = read_string( reader, &elem->localName )) != S_OK) goto error;
2034 }
2035 else if (type >= RECORD_PREFIX_DICTIONARY_ELEMENT_A && type <= RECORD_PREFIX_DICTIONARY_ELEMENT_Z)
2036 {
2037 unsigned char ch = type - RECORD_PREFIX_DICTIONARY_ELEMENT_A + 'a';
2038 if (!(elem->prefix = alloc_xml_string( &ch, 1 )))
2039 {
2040 hr = E_OUTOFMEMORY;
2041 goto error;
2042 }
2043 if ((hr = read_dict_string( reader, &elem->localName )) != S_OK) goto error;
2044 }
2045 else
2046 {
2047 switch (type)
2048 {
2049 case RECORD_SHORT_ELEMENT:
2050 if (!(elem->prefix = alloc_xml_string( NULL, 0 )))
2051 {
2052 hr = E_OUTOFMEMORY;
2053 goto error;
2054 }
2055 if ((hr = read_string( reader, &elem->localName )) != S_OK) goto error;
2056 break;
2057
2058 case RECORD_ELEMENT:
2059 if ((hr = read_string( reader, &elem->prefix )) != S_OK) goto error;
2060 if ((hr = read_string( reader, &elem->localName )) != S_OK) goto error;
2061 break;
2062
2063 case RECORD_SHORT_DICTIONARY_ELEMENT:
2064 if (!(elem->prefix = alloc_xml_string( NULL, 0 )))
2065 {
2066 hr = E_OUTOFMEMORY;
2067 goto error;
2068 }
2069 if ((hr = read_dict_string( reader, &elem->localName )) != S_OK) goto error;
2070 break;
2071
2072 case RECORD_DICTIONARY_ELEMENT:
2073 if ((hr = read_string( reader, &elem->prefix )) != S_OK) goto error;
2074 if ((hr = read_dict_string( reader, &elem->localName )) != S_OK) goto error;
2075 break;
2076
2077 default:
2078 ERR( "unhandled record type %02x\n", type );
2079 return WS_E_NOT_SUPPORTED;
2080 }
2081 }
2082
2083 if (!(parent = find_parent( reader )))
2084 {
2085 hr = WS_E_INVALID_FORMAT;
2086 goto error;
2087 }
2088
2089 if ((hr = read_attributes_bin( reader, elem )) != S_OK) goto error;
2090 if ((hr = set_namespaces( reader, elem )) != S_OK) goto error;
2091
2092 read_insert_node( reader, parent, node );
2093 reader->state = READER_STATE_STARTELEMENT;
2094 return S_OK;
2095
2096 error:
2097 destroy_nodes( node );
2098 return hr;
2099 }
2100
2101 static HRESULT read_text_text( struct reader *reader )
2102 {
2103 unsigned int len = 0, ch, skip;
2104 const unsigned char *start;
2105 struct node *node, *parent;
2106 WS_XML_TEXT_NODE *text;
2107 WS_XML_UTF8_TEXT *utf8;
2108 HRESULT hr;
2109
2110 start = read_current_ptr( reader );
2111 for (;;)
2112 {
2113 if (read_end_of_data( reader )) break;
2114 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
2115 if (ch == '<') break;
2116 read_skip( reader, skip );
2117 len += skip;
2118 }
2119
2120 if (!(parent = find_parent( reader ))) return WS_E_INVALID_FORMAT;
2121
2122 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return E_OUTOFMEMORY;
2123 text = (WS_XML_TEXT_NODE *)node;
2124 if (!(utf8 = alloc_utf8_text( NULL, len )))
2125 {
2126 heap_free( node );
2127 return E_OUTOFMEMORY;
2128 }
2129 if ((hr = decode_text( start, len, utf8->value.bytes, &utf8->value.length )) != S_OK)
2130 {
2131 heap_free( utf8 );
2132 heap_free( node );
2133 return hr;
2134 }
2135 text->text = &utf8->text;
2136
2137 read_insert_node( reader, parent, node );
2138 reader->state = READER_STATE_TEXT;
2139 reader->text_conv_offset = 0;
2140 return S_OK;
2141 }
2142
2143 static struct node *alloc_utf8_text_node( const BYTE *data, ULONG len, WS_XML_UTF8_TEXT **ret )
2144 {
2145 struct node *node;
2146 WS_XML_UTF8_TEXT *utf8;
2147 WS_XML_TEXT_NODE *text;
2148
2149 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return NULL;
2150 if (!(utf8 = alloc_utf8_text( data, len )))
2151 {
2152 heap_free( node );
2153 return NULL;
2154 }
2155 text = (WS_XML_TEXT_NODE *)node;
2156 text->text = &utf8->text;
2157 if (ret) *ret = utf8;
2158 return node;
2159 }
2160
2161 static struct node *alloc_base64_text_node( const BYTE *data, ULONG len, WS_XML_BASE64_TEXT **ret )
2162 {
2163 struct node *node;
2164 WS_XML_BASE64_TEXT *base64;
2165 WS_XML_TEXT_NODE *text;
2166
2167 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return NULL;
2168 if (!(base64 = alloc_base64_text( data, len )))
2169 {
2170 heap_free( node );
2171 return NULL;
2172 }
2173 text = (WS_XML_TEXT_NODE *)node;
2174 text->text = &base64->text;
2175 if (ret) *ret = base64;
2176 return node;
2177 }
2178
2179 static struct node *alloc_bool_text_node( BOOL value )
2180 {
2181 struct node *node;
2182 WS_XML_BOOL_TEXT *text_bool;
2183 WS_XML_TEXT_NODE *text;
2184
2185 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return NULL;
2186 if (!(text_bool = alloc_bool_text( value )))
2187 {
2188 heap_free( node );
2189 return NULL;
2190 }
2191 text = (WS_XML_TEXT_NODE *)node;
2192 text->text = &text_bool->text;
2193 return node;
2194 }
2195
2196 static struct node *alloc_int32_text_node( INT32 value )
2197 {
2198 struct node *node;
2199 WS_XML_INT32_TEXT *text_int32;
2200 WS_XML_TEXT_NODE *text;
2201
2202 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return NULL;
2203 if (!(text_int32 = alloc_int32_text( value )))
2204 {
2205 heap_free( node );
2206 return NULL;
2207 }
2208 text = (WS_XML_TEXT_NODE *)node;
2209 text->text = &text_int32->text;
2210 return node;
2211 }
2212
2213 static struct node *alloc_int64_text_node( INT64 value )
2214 {
2215 struct node *node;
2216 WS_XML_INT64_TEXT *text_int64;
2217 WS_XML_TEXT_NODE *text;
2218
2219 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return NULL;
2220 if (!(text_int64 = alloc_int64_text( value )))
2221 {
2222 heap_free( node );
2223 return NULL;
2224 }
2225 text = (WS_XML_TEXT_NODE *)node;
2226 text->text = &text_int64->text;
2227 return node;
2228 }
2229
2230 static struct node *alloc_float_text_node( float value )
2231 {
2232 struct node *node;
2233 WS_XML_FLOAT_TEXT *text_float;
2234 WS_XML_TEXT_NODE *text;
2235
2236 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return NULL;
2237 if (!(text_float = alloc_float_text( value )))
2238 {
2239 heap_free( node );
2240 return NULL;
2241 }
2242 text = (WS_XML_TEXT_NODE *)node;
2243 text->text = &text_float->text;
2244 return node;
2245 }
2246
2247 static struct node *alloc_double_text_node( double value )
2248 {
2249 struct node *node;
2250 WS_XML_DOUBLE_TEXT *text_double;
2251 WS_XML_TEXT_NODE *text;
2252
2253 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return NULL;
2254 if (!(text_double = alloc_double_text( value )))
2255 {
2256 heap_free( node );
2257 return NULL;
2258 }
2259 text = (WS_XML_TEXT_NODE *)node;
2260 text->text = &text_double->text;
2261 return node;
2262 }
2263
2264 static struct node *alloc_datetime_text_node( const WS_DATETIME *value )
2265 {
2266 struct node *node;
2267 WS_XML_DATETIME_TEXT *text_datetime;
2268 WS_XML_TEXT_NODE *text;
2269
2270 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return NULL;
2271 if (!(text_datetime = alloc_datetime_text( value )))
2272 {
2273 heap_free( node );
2274 return NULL;
2275 }
2276 text = (WS_XML_TEXT_NODE *)node;
2277 text->text = &text_datetime->text;
2278 return node;
2279 }
2280
2281 static struct node *alloc_unique_id_text_node( const GUID *value )
2282 {
2283 struct node *node;
2284 WS_XML_UNIQUE_ID_TEXT *text_unique_id;
2285 WS_XML_TEXT_NODE *text;
2286
2287 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return NULL;
2288 if (!(text_unique_id = alloc_unique_id_text( value )))
2289 {
2290 heap_free( node );
2291 return NULL;
2292 }
2293 text = (WS_XML_TEXT_NODE *)node;
2294 text->text = &text_unique_id->text;
2295 return node;
2296 }
2297
2298 static struct node *alloc_guid_text_node( const GUID *value )
2299 {
2300 struct node *node;
2301 WS_XML_GUID_TEXT *text_guid;
2302 WS_XML_TEXT_NODE *text;
2303
2304 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return NULL;
2305 if (!(text_guid = alloc_guid_text( value )))
2306 {
2307 heap_free( node );
2308 return NULL;
2309 }
2310 text = (WS_XML_TEXT_NODE *)node;
2311 text->text = &text_guid->text;
2312 return node;
2313 }
2314
2315 static struct node *alloc_uint64_text_node( UINT64 value )
2316 {
2317 struct node *node;
2318 WS_XML_UINT64_TEXT *text_uint64;
2319 WS_XML_TEXT_NODE *text;
2320
2321 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return NULL;
2322 if (!(text_uint64 = alloc_uint64_text( value )))
2323 {
2324 heap_free( node );
2325 return NULL;
2326 }
2327 text = (WS_XML_TEXT_NODE *)node;
2328 text->text = &text_uint64->text;
2329 return node;
2330 }
2331
2332 static HRESULT append_text_bytes( struct reader *reader, WS_XML_TEXT_NODE *node, ULONG len )
2333 {
2334 WS_XML_BASE64_TEXT *new, *old = (WS_XML_BASE64_TEXT *)node->text;
2335 HRESULT hr;
2336
2337 if (!(new = alloc_base64_text( NULL, old->length + len ))) return E_OUTOFMEMORY;
2338 memcpy( new->bytes, old->bytes, old->length );
2339 if ((hr = read_bytes( reader, new->bytes + old->length, len )) != S_OK) return hr;
2340 heap_free( old );
2341 node->text = &new->text;
2342 return S_OK;
2343 }
2344
2345 static HRESULT read_text_bytes( struct reader *reader, unsigned char type )
2346 {
2347 struct node *node = NULL, *parent;
2348 WS_XML_BASE64_TEXT *base64;
2349 HRESULT hr;
2350 ULONG len;
2351
2352 if (!(parent = find_parent( reader ))) return WS_E_INVALID_FORMAT;
2353 for (;;)
2354 {
2355 switch (type)
2356 {
2357 case RECORD_BYTES8_TEXT:
2358 case RECORD_BYTES8_TEXT_WITH_ENDELEMENT:
2359 {
2360 UINT8 len_uint8;
2361 if ((hr = read_byte( reader, (unsigned char *)&len_uint8 )) != S_OK) goto error;
2362 len = len_uint8;
2363 break;
2364 }
2365 case RECORD_BYTES16_TEXT:
2366 case RECORD_BYTES16_TEXT_WITH_ENDELEMENT:
2367 {
2368 UINT16 len_uint16;
2369 if ((hr = read_bytes( reader, (unsigned char *)&len_uint16, sizeof(len_uint16) )) != S_OK) goto error;
2370 len = len_uint16;
2371 break;
2372 }
2373 case RECORD_BYTES32_TEXT:
2374 case RECORD_BYTES32_TEXT_WITH_ENDELEMENT:
2375 {
2376 INT32 len_int32;
2377 if ((hr = read_bytes( reader, (unsigned char *)&len_int32, sizeof(len_int32) )) != S_OK) goto error;
2378 if (len_int32 < 0)
2379 {
2380 hr = WS_E_INVALID_FORMAT;
2381 goto error;
2382 }
2383 len = len_int32;
2384 break;
2385 }
2386 default:
2387 ERR( "unexpected type %u\n", type );
2388 hr = E_INVALIDARG;
2389 goto error;
2390 }
2391
2392 if (!node)
2393 {
2394 if (!(node = alloc_base64_text_node( NULL, len, &base64 ))) return E_OUTOFMEMORY;
2395 if ((hr = read_bytes( reader, base64->bytes, len )) != S_OK) goto error;
2396 }
2397 else if ((hr = append_text_bytes( reader, (WS_XML_TEXT_NODE *)node, len )) != S_OK) goto error;
2398
2399 if (type & 1)
2400 {
2401 node->flags |= NODE_FLAG_TEXT_WITH_IMPLICIT_END_ELEMENT;
2402 break;
2403 }
2404 if ((hr = read_peek( reader, &type )) != S_OK) goto error;
2405 if (type < RECORD_BYTES8_TEXT || type > RECORD_BYTES32_TEXT_WITH_ENDELEMENT) break;
2406 read_skip( reader, 1 );
2407 }
2408
2409 read_insert_node( reader, parent, node );
2410 reader->state = READER_STATE_TEXT;
2411 reader->text_conv_offset = 0;
2412 return S_OK;
2413
2414 error:
2415 free_node( node );
2416 return hr;
2417 }
2418
2419 static HRESULT read_text_bin( struct reader *reader )
2420 {
2421 struct node *node = NULL, *parent;
2422 unsigned char type;
2423 WS_XML_UTF8_TEXT *utf8;
2424 INT32 val_int32;
2425 UINT8 val_uint8;
2426 UINT16 val_uint16;
2427 ULONG len, id;
2428 GUID uuid;
2429 HRESULT hr;
2430
2431 if ((hr = read_byte( reader, &type )) != S_OK) return hr;
2432 if (!is_text_type( type ) || !(parent = find_parent( reader ))) return WS_E_INVALID_FORMAT;
2433
2434 switch (type)
2435 {
2436 case RECORD_ZERO_TEXT:
2437 case RECORD_ZERO_TEXT_WITH_ENDELEMENT:
2438 if (!(node = alloc_int32_text_node( 0 ))) return E_OUTOFMEMORY;
2439 break;
2440
2441 case RECORD_ONE_TEXT:
2442 case RECORD_ONE_TEXT_WITH_ENDELEMENT:
2443 if (!(node = alloc_int32_text_node( 1 ))) return E_OUTOFMEMORY;
2444 break;
2445
2446 case RECORD_FALSE_TEXT:
2447 case RECORD_FALSE_TEXT_WITH_ENDELEMENT:
2448 if (!(node = alloc_bool_text_node( FALSE ))) return E_OUTOFMEMORY;
2449 break;
2450
2451 case RECORD_TRUE_TEXT:
2452 case RECORD_TRUE_TEXT_WITH_ENDELEMENT:
2453 if (!(node = alloc_bool_text_node( TRUE ))) return E_OUTOFMEMORY;
2454 break;
2455
2456 case RECORD_INT8_TEXT:
2457 case RECORD_INT8_TEXT_WITH_ENDELEMENT:
2458 {
2459 INT8 val_int8;
2460 if ((hr = read_byte( reader, (unsigned char *)&val_int8 )) != S_OK) return hr;
2461 if (!(node = alloc_int32_text_node( val_int8 ))) return E_OUTOFMEMORY;
2462 break;
2463 }
2464 case RECORD_INT16_TEXT:
2465 case RECORD_INT16_TEXT_WITH_ENDELEMENT:
2466 {
2467 INT16 val_int16;
2468 if ((hr = read_bytes( reader, (unsigned char *)&val_int16, sizeof(val_int16) )) != S_OK) return hr;
2469 if (!(node = alloc_int32_text_node( val_int16 ))) return E_OUTOFMEMORY;
2470 break;
2471 }
2472 case RECORD_INT32_TEXT:
2473 case RECORD_INT32_TEXT_WITH_ENDELEMENT:
2474 if ((hr = read_bytes( reader, (unsigned char *)&val_int32, sizeof(val_int32) )) != S_OK) return hr;
2475 if (!(node = alloc_int32_text_node( val_int32 ))) return E_OUTOFMEMORY;
2476 break;
2477
2478 case RECORD_INT64_TEXT:
2479 case RECORD_INT64_TEXT_WITH_ENDELEMENT:
2480 {
2481 INT64 val_int64;
2482 if ((hr = read_bytes( reader, (unsigned char *)&val_int64, sizeof(val_int64) )) != S_OK) return hr;
2483 if (!(node = alloc_int64_text_node( val_int64 ))) return E_OUTOFMEMORY;
2484 break;
2485 }
2486 case RECORD_FLOAT_TEXT:
2487 case RECORD_FLOAT_TEXT_WITH_ENDELEMENT:
2488 {
2489 float val_float;
2490 if ((hr = read_bytes( reader, (unsigned char *)&val_float, sizeof(val_float) )) != S_OK) return hr;
2491 if (!(node = alloc_float_text_node( val_float ))) return E_OUTOFMEMORY;
2492 break;
2493 }
2494 case RECORD_DOUBLE_TEXT:
2495 case RECORD_DOUBLE_TEXT_WITH_ENDELEMENT:
2496 {
2497 double val_double;
2498 if ((hr = read_bytes( reader, (unsigned char *)&val_double, sizeof(val_double) )) != S_OK) return hr;
2499 if (!(node = alloc_double_text_node( val_double ))) return E_OUTOFMEMORY;
2500 break;
2501 }
2502 case RECORD_DATETIME_TEXT:
2503 case RECORD_DATETIME_TEXT_WITH_ENDELEMENT:
2504 {
2505 WS_DATETIME datetime;
2506 if ((hr = read_datetime( reader, &datetime )) != S_OK) return hr;
2507 if (!(node = alloc_datetime_text_node( &datetime ))) return E_OUTOFMEMORY;
2508 break;
2509 }
2510 case RECORD_CHARS8_TEXT:
2511 case RECORD_CHARS8_TEXT_WITH_ENDELEMENT:
2512 if ((hr = read_byte( reader, (unsigned char *)&val_uint8 )) != S_OK) return hr;
2513 len = val_uint8;
2514 break;
2515
2516 case RECORD_CHARS16_TEXT:
2517 case RECORD_CHARS16_TEXT_WITH_ENDELEMENT:
2518 if ((hr = read_bytes( reader, (unsigned char *)&val_uint16, sizeof(val_uint16) )) != S_OK) return hr;
2519 len = val_uint16;
2520 break;
2521
2522 case RECORD_CHARS32_TEXT:
2523 case RECORD_CHARS32_TEXT_WITH_ENDELEMENT:
2524 if ((hr = read_bytes( reader, (unsigned char *)&val_int32, sizeof(val_int32) )) != S_OK) return hr;
2525 if (val_int32 < 0) return WS_E_INVALID_FORMAT;
2526 len = val_int32;
2527 break;
2528
2529 case RECORD_BYTES8_TEXT:
2530 case RECORD_BYTES8_TEXT_WITH_ENDELEMENT:
2531 case RECORD_BYTES16_TEXT:
2532 case RECORD_BYTES16_TEXT_WITH_ENDELEMENT:
2533 case RECORD_BYTES32_TEXT:
2534 case RECORD_BYTES32_TEXT_WITH_ENDELEMENT:
2535 return read_text_bytes( reader, type );
2536
2537 case RECORD_EMPTY_TEXT:
2538 case RECORD_EMPTY_TEXT_WITH_ENDELEMENT:
2539 len = 0;
2540 break;
2541
2542 case RECORD_DICTIONARY_TEXT:
2543 case RECORD_DICTIONARY_TEXT_WITH_ENDELEMENT:
2544 {
2545 const WS_XML_STRING *str;
2546 if ((hr = read_int31( reader, &id )) != S_OK) return hr;
2547 if ((hr = lookup_string( reader, id, &str )) != S_OK) return hr;
2548 if (!(node = alloc_utf8_text_node( str->bytes, str->length, NULL ))) return E_OUTOFMEMORY;
2549 break;
2550 }
2551 case RECORD_UNIQUE_ID_TEXT:
2552 case RECORD_UNIQUE_ID_TEXT_WITH_ENDELEMENT:
2553 if ((hr = read_bytes( reader, (unsigned char *)&uuid, sizeof(uuid) )) != S_OK) return hr;
2554 if (!(node = alloc_unique_id_text_node( &uuid ))) return E_OUTOFMEMORY;
2555 break;
2556
2557 case RECORD_GUID_TEXT:
2558 case RECORD_GUID_TEXT_WITH_ENDELEMENT:
2559 if ((hr = read_bytes( reader, (unsigned char *)&uuid, sizeof(uuid) )) != S_OK) return hr;
2560 if (!(node = alloc_guid_text_node( &uuid ))) return E_OUTOFMEMORY;
2561 break;
2562
2563 case RECORD_UINT64_TEXT:
2564 case RECORD_UINT64_TEXT_WITH_ENDELEMENT:
2565 {
2566 UINT64 val_uint64;
2567 if ((hr = read_bytes( reader, (unsigned char *)&val_uint64, sizeof(val_uint64) )) != S_OK) return hr;
2568 if (!(node = alloc_uint64_text_node( val_uint64 ))) return E_OUTOFMEMORY;
2569 break;
2570 }
2571 case RECORD_BOOL_TEXT:
2572 case RECORD_BOOL_TEXT_WITH_ENDELEMENT:
2573 {
2574 BOOL val_bool;
2575 if ((hr = read_bytes( reader, (unsigned char *)&val_bool, sizeof(val_bool) )) != S_OK) return hr;
2576 if (!(node = alloc_bool_text_node( !!val_bool ))) return E_OUTOFMEMORY;
2577 break;
2578 }
2579 default:
2580 ERR( "unhandled record type %02x\n", type );
2581 return WS_E_NOT_SUPPORTED;
2582 }
2583
2584 if (!node)
2585 {
2586 if (!(node = alloc_utf8_text_node( NULL, len, &utf8 ))) return E_OUTOFMEMORY;
2587 if (!len) utf8->value.bytes = (BYTE *)(utf8 + 1); /* quirk */
2588 if ((hr = read_bytes( reader, utf8->value.bytes, len )) != S_OK)
2589 {
2590 free_node( node );
2591 return hr;
2592 }
2593 }
2594
2595 if (type & 1) node->flags |= NODE_FLAG_TEXT_WITH_IMPLICIT_END_ELEMENT;
2596 read_insert_node( reader, parent, node );
2597 reader->state = READER_STATE_TEXT;
2598 reader->text_conv_offset = 0;
2599 return S_OK;
2600 }
2601
2602 static HRESULT read_node_text( struct reader * );
2603
2604 static HRESULT read_startelement_text( struct reader *reader )
2605 {
2606 read_skip_whitespace( reader );
2607 if (!read_cmp( reader, "/>", 2 ))
2608 {
2609 read_skip( reader, 2 );
2610 reader->current = LIST_ENTRY( list_tail( &reader->current->children ), struct node, entry );
2611 reader->last = reader->current;
2612 reader->state = READER_STATE_ENDELEMENT;
2613 return S_OK;
2614 }
2615 else if (!read_cmp( reader, ">", 1 ))
2616 {
2617 read_skip( reader, 1 );
2618 return read_node_text( reader );
2619 }
2620 return WS_E_INVALID_FORMAT;
2621 }
2622
2623 static HRESULT read_node_bin( struct reader * );
2624
2625 static HRESULT read_startelement_bin( struct reader *reader )
2626 {
2627 if (node_type( reader->current ) != WS_XML_NODE_TYPE_ELEMENT) return WS_E_INVALID_FORMAT;
2628 return read_node_bin( reader );
2629 }
2630
2631 static HRESULT read_startelement( struct reader *reader )
2632 {
2633 switch (reader->input_enc)
2634 {
2635 case WS_XML_READER_ENCODING_TYPE_TEXT: return read_startelement_text( reader );
2636 case WS_XML_READER_ENCODING_TYPE_BINARY: return read_startelement_bin( reader );
2637 default:
2638 ERR( "unhandled encoding %u\n", reader->input_enc );
2639 return WS_E_NOT_SUPPORTED;
2640 }
2641 }
2642
2643 static HRESULT read_to_startelement_text( struct reader *reader, BOOL *found )
2644 {
2645 HRESULT hr;
2646
2647 switch (reader->state)
2648 {
2649 case READER_STATE_INITIAL:
2650 if ((hr = read_xmldecl( reader )) != S_OK) return hr;
2651 break;
2652
2653 case READER_STATE_STARTELEMENT:
2654 if (found) *found = TRUE;
2655 return S_OK;
2656
2657 default:
2658 break;
2659 }
2660
2661 read_skip_whitespace( reader );
2662 if ((hr = read_element_text( reader )) == S_OK && found)
2663 {
2664 if (reader->state == READER_STATE_STARTELEMENT)
2665 *found = TRUE;
2666 else
2667 *found = FALSE;
2668 }
2669
2670 return hr;
2671 }
2672
2673 static HRESULT read_to_startelement_bin( struct reader *reader, BOOL *found )
2674 {
2675 HRESULT hr;
2676
2677 if (reader->state == READER_STATE_STARTELEMENT)
2678 {
2679 if (found) *found = TRUE;
2680 return S_OK;
2681 }
2682
2683 if ((hr = read_element_bin( reader )) == S_OK && found)
2684 {
2685 if (reader->state == READER_STATE_STARTELEMENT)
2686 *found = TRUE;
2687 else
2688 *found = FALSE;
2689 }
2690
2691 return hr;
2692 }
2693
2694 static HRESULT read_to_startelement( struct reader *reader, BOOL *found )
2695 {
2696 switch (reader->input_enc)
2697 {
2698 case WS_XML_READER_ENCODING_TYPE_TEXT: return read_to_startelement_text( reader, found );
2699 case WS_XML_READER_ENCODING_TYPE_BINARY: return read_to_startelement_bin( reader, found );
2700 default:
2701 ERR( "unhandled encoding %u\n", reader->input_enc );
2702 return WS_E_NOT_SUPPORTED;
2703 }
2704 }
2705
2706 static int cmp_name( const unsigned char *name1, ULONG len1, const unsigned char *name2, ULONG len2 )
2707 {
2708 ULONG i;
2709 if (len1 != len2) return 1;
2710 for (i = 0; i < len1; i++) { if (toupper( name1[i] ) != toupper( name2[i] )) return 1; }
2711 return 0;
2712 }
2713
2714 static struct node *find_startelement( struct reader *reader, const WS_XML_STRING *prefix,
2715 const WS_XML_STRING *localname )
2716 {
2717 struct node *parent;
2718 const WS_XML_STRING *str;
2719
2720 for (parent = reader->current; parent; parent = parent->parent)
2721 {
2722 if (node_type( parent ) == WS_XML_NODE_TYPE_ELEMENT)
2723 {
2724 str = parent->hdr.prefix;
2725 if (cmp_name( str->bytes, str->length, prefix->bytes, prefix->length )) continue;
2726 str = parent->hdr.localName;
2727 if (cmp_name( str->bytes, str->length, localname->bytes, localname->length )) continue;
2728 return parent;
2729 }
2730 }
2731 return NULL;
2732 }
2733
2734 static HRESULT read_endelement_text( struct reader *reader )
2735 {
2736 struct node *parent;
2737 unsigned int len = 0, ch, skip;
2738 const unsigned char *start;
2739 WS_XML_STRING prefix, localname;
2740 HRESULT hr;
2741
2742 if (read_cmp( reader, "</", 2 )) return WS_E_INVALID_FORMAT;
2743 read_skip( reader, 2 );
2744
2745 start = read_current_ptr( reader );
2746 for (;;)
2747 {
2748 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
2749 if (ch == '>')
2750 {
2751 read_skip( reader, 1 );
2752 break;
2753 }
2754 if (!read_isnamechar( ch )) return WS_E_INVALID_FORMAT;
2755 read_skip( reader, skip );
2756 len += skip;
2757 }
2758
2759 if ((hr = split_qname( start, len, &prefix, &localname )) != S_OK) return hr;
2760 if (!(parent = find_startelement( reader, &prefix, &localname ))) return WS_E_INVALID_FORMAT;
2761
2762 reader->current = LIST_ENTRY( list_tail( &parent->children ), struct node, entry );
2763 reader->last = reader->current;
2764 reader->state = READER_STATE_ENDELEMENT;
2765 return S_OK;
2766 }
2767
2768 static HRESULT read_endelement_bin( struct reader *reader )
2769 {
2770 struct node *parent;
2771 unsigned char type;
2772 HRESULT hr;
2773
2774 if (!(reader->current->flags & NODE_FLAG_TEXT_WITH_IMPLICIT_END_ELEMENT))
2775 {
2776 if ((hr = read_byte( reader, &type )) != S_OK) return hr;
2777 if (type != RECORD_ENDELEMENT) return WS_E_INVALID_FORMAT;
2778 }
2779 if (!(parent = find_parent( reader ))) return WS_E_INVALID_FORMAT;
2780
2781 reader->current = LIST_ENTRY( list_tail( &parent->children ), struct node, entry );
2782 reader->last = reader->current;
2783 reader->state = READER_STATE_ENDELEMENT;
2784 return S_OK;
2785 }
2786
2787 static HRESULT read_endelement( struct reader *reader )
2788 {
2789 if (reader->state == READER_STATE_EOF) return WS_E_INVALID_FORMAT;
2790
2791 if (read_end_of_data( reader ))
2792 {
2793 reader->current = LIST_ENTRY( list_tail( &reader->root->children ), struct node, entry );
2794 reader->last = reader->current;
2795 reader->state = READER_STATE_EOF;
2796 return S_OK;
2797 }
2798
2799 switch (reader->input_enc)
2800 {
2801 case WS_XML_READER_ENCODING_TYPE_TEXT: return read_endelement_text( reader );
2802 case WS_XML_READER_ENCODING_TYPE_BINARY: return read_endelement_bin( reader );
2803 default:
2804 ERR( "unhandled encoding %u\n", reader->input_enc );
2805 return WS_E_NOT_SUPPORTED;
2806 }
2807 }
2808
2809 static HRESULT read_comment_text( struct reader *reader )
2810 {
2811 unsigned int len = 0, ch, skip;
2812 const unsigned char *start;
2813 struct node *node, *parent;
2814 WS_XML_COMMENT_NODE *comment;
2815
2816 if (read_cmp( reader, "<!--", 4 )) return WS_E_INVALID_FORMAT;
2817 read_skip( reader, 4 );
2818
2819 start = read_current_ptr( reader );
2820 for (;;)
2821 {
2822 if (!read_cmp( reader, "-->", 3 ))
2823 {
2824 read_skip( reader, 3 );
2825 break;
2826 }
2827 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
2828 read_skip( reader, skip );
2829 len += skip;
2830 }
2831
2832 if (!(parent = find_parent( reader ))) return WS_E_INVALID_FORMAT;
2833
2834 if (!(node = alloc_node( WS_XML_NODE_TYPE_COMMENT ))) return E_OUTOFMEMORY;
2835 comment = (WS_XML_COMMENT_NODE *)node;
2836 if (!(comment->value.bytes = heap_alloc( len )))
2837 {
2838 heap_free( node );
2839 return E_OUTOFMEMORY;
2840 }
2841 memcpy( comment->value.bytes, start, len );
2842 comment->value.length = len;
2843
2844 read_insert_node( reader, parent, node );
2845 reader->state = READER_STATE_COMMENT;
2846 return S_OK;
2847 }
2848
2849 static HRESULT read_comment_bin( struct reader *reader )
2850 {
2851 struct node *node, *parent;
2852 WS_XML_COMMENT_NODE *comment;
2853 unsigned char type;
2854 ULONG len;
2855 HRESULT hr;
2856
2857 if ((hr = read_byte( reader, &type )) != S_OK) return hr;
2858 if (type != RECORD_COMMENT) return WS_E_INVALID_FORMAT;
2859 if ((hr = read_int31( reader, &len )) != S_OK) return hr;
2860
2861 if (!(parent = find_parent( reader ))) return WS_E_INVALID_FORMAT;
2862
2863 if (!(node = alloc_node( WS_XML_NODE_TYPE_COMMENT ))) return E_OUTOFMEMORY;
2864 comment = (WS_XML_COMMENT_NODE *)node;
2865 if (!(comment->value.bytes = heap_alloc( len )))
2866 {
2867 heap_free( node );
2868 return E_OUTOFMEMORY;
2869 }
2870 if ((hr = read_bytes( reader, comment->value.bytes, len )) != S_OK)
2871 {
2872 free_node( node );
2873 return E_OUTOFMEMORY;
2874 }
2875 comment->value.length = len;
2876
2877 read_insert_node( reader, parent, node );
2878 reader->state = READER_STATE_COMMENT;
2879 return S_OK;
2880 }
2881
2882 static HRESULT read_startcdata( struct reader *reader )
2883 {
2884 struct node *node, *endnode, *parent;
2885
2886 if (read_cmp( reader, "<![CDATA[", 9 )) return WS_E_INVALID_FORMAT;
2887 read_skip( reader, 9 );
2888
2889 if (!(parent = find_parent( reader ))) return WS_E_INVALID_FORMAT;
2890
2891 if (!(node = alloc_node( WS_XML_NODE_TYPE_CDATA ))) return E_OUTOFMEMORY;
2892 if (!(endnode = alloc_node( WS_XML_NODE_TYPE_END_CDATA )))
2893 {
2894 heap_free( node );
2895 return E_OUTOFMEMORY;
2896 }
2897 list_add_tail( &node->children, &endnode->entry );
2898 endnode->parent = node;
2899
2900 read_insert_node( reader, parent, node );
2901 reader->state = READER_STATE_STARTCDATA;
2902 return S_OK;
2903 }
2904
2905 static HRESULT read_cdata( struct reader *reader )
2906 {
2907 unsigned int len = 0, ch, skip;
2908 const unsigned char *start;
2909 struct node *node;
2910 WS_XML_TEXT_NODE *text;
2911 WS_XML_UTF8_TEXT *utf8;
2912
2913 start = read_current_ptr( reader );
2914 for (;;)
2915 {
2916 if (!read_cmp( reader, "]]>", 3 )) break;
2917 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
2918 read_skip( reader, skip );
2919 len += skip;
2920 }
2921
2922 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return E_OUTOFMEMORY;
2923 text = (WS_XML_TEXT_NODE *)node;
2924 if (!(utf8 = alloc_utf8_text( start, len )))
2925 {
2926 heap_free( node );
2927 return E_OUTOFMEMORY;
2928 }
2929 text->text = &utf8->text;
2930
2931 read_insert_node( reader, reader->current, node );
2932 reader->state = READER_STATE_CDATA;
2933 return S_OK;
2934 }
2935
2936 static HRESULT read_endcdata( struct reader *reader )
2937 {
2938 struct node *parent;
2939
2940 if (read_cmp( reader, "]]>", 3 )) return WS_E_INVALID_FORMAT;
2941 read_skip( reader, 3 );
2942
2943 if (node_type( reader->current ) == WS_XML_NODE_TYPE_TEXT) parent = reader->current->parent;
2944 else parent = reader->current;
2945
2946 reader->current = LIST_ENTRY( list_tail( &parent->children ), struct node, entry );
2947 reader->last = reader->current;
2948 reader->state = READER_STATE_ENDCDATA;
2949 return S_OK;
2950 }
2951
2952 static HRESULT read_node_text( struct reader *reader )
2953 {
2954 HRESULT hr;
2955
2956 for (;;)
2957 {
2958 if (read_end_of_data( reader ))
2959 {
2960 reader->current = LIST_ENTRY( list_tail( &reader->root->children ), struct node, entry );
2961 reader->last = reader->current;
2962 reader->state = READER_STATE_EOF;
2963 return S_OK;
2964 }
2965 if (reader->state == READER_STATE_STARTCDATA) return read_cdata( reader );
2966 else if (reader->state == READER_STATE_CDATA) return read_endcdata( reader );
2967 else if (!read_cmp( reader, "<?", 2 ))
2968 {
2969 hr = read_xmldecl( reader );
2970 if (FAILED( hr )) return hr;
2971 }
2972 else if (!read_cmp( reader, "</", 2 )) return read_endelement_text( reader );
2973 else if (!read_cmp( reader, "<![CDATA[", 9 )) return read_startcdata( reader );
2974 else if (!read_cmp( reader, "<!--", 4 )) return read_comment_text( reader );
2975 else if (!read_cmp( reader, "<", 1 )) return read_element_text( reader );
2976 else if (!read_cmp( reader, "/>", 2 ) || !read_cmp( reader, ">", 1 )) return read_startelement_text( reader );
2977 else return read_text_text( reader );
2978 }
2979 }
2980
2981 static HRESULT read_node_bin( struct reader *reader )
2982 {
2983 unsigned char type;
2984 HRESULT hr;
2985
2986 if (reader->current->flags & NODE_FLAG_TEXT_WITH_IMPLICIT_END_ELEMENT)
2987 {
2988 reader->current = LIST_ENTRY( list_tail( &reader->current->parent->children ), struct node, entry );
2989 reader->last = reader->current;
2990 reader->state = READER_STATE_ENDELEMENT;
2991 return S_OK;
2992 }
2993 if (read_end_of_data( reader ))
2994 {
2995 reader->current = LIST_ENTRY( list_tail( &reader->root->children ), struct node, entry );
2996 reader->last = reader->current;
2997 reader->state = READER_STATE_EOF;
2998 return S_OK;
2999 }
3000
3001 if ((hr = read_peek( reader, &type )) != S_OK) return hr;
3002 if (type == RECORD_ENDELEMENT)
3003 {
3004 return read_endelement_bin( reader );
3005 }
3006 else if (type == RECORD_COMMENT)
3007 {
3008 return read_comment_bin( reader );
3009 }
3010 else if (type >= RECORD_SHORT_ELEMENT && type <= RECORD_PREFIX_ELEMENT_Z)
3011 {
3012 return read_element_bin( reader );
3013 }
3014 else if (type >= RECORD_ZERO_TEXT && type <= RECORD_QNAME_DICTIONARY_TEXT_WITH_ENDELEMENT)
3015 {
3016 return read_text_bin( reader );
3017 }
3018 FIXME( "unhandled record type %02x\n", type );
3019 return WS_E_NOT_SUPPORTED;
3020 }
3021
3022 static HRESULT read_node( struct reader *reader )
3023 {
3024 switch (reader->input_enc)
3025 {
3026 case WS_XML_READER_ENCODING_TYPE_TEXT: return read_node_text( reader );
3027 case WS_XML_READER_ENCODING_TYPE_BINARY: return read_node_bin( reader );
3028 default:
3029 ERR( "unhandled encoding %u\n", reader->input_enc );
3030 return WS_E_NOT_SUPPORTED;
3031 }
3032 }
3033
3034 HRESULT copy_node( WS_XML_READER *handle, WS_XML_WRITER_ENCODING_TYPE enc, struct node **node )
3035 {
3036 struct reader *reader = (struct reader *)handle;
3037 const struct list *ptr;
3038 const struct node *start;
3039 HRESULT hr;
3040
3041 EnterCriticalSection( &reader->cs );
3042
3043 if (reader->magic != READER_MAGIC)
3044 {
3045 LeaveCriticalSection( &reader->cs );
3046 return E_INVALIDARG;
3047 }
3048
3049 if (reader->current != reader->root) ptr = &reader->current->entry;
3050 else /* copy whole tree */
3051 {
3052 if (!read_end_of_data( reader ))
3053 {
3054 for (;;)
3055 {
3056 if ((hr = read_node( reader )) != S_OK) goto done;
3057 if (node_type( reader->current ) == WS_XML_NODE_TYPE_EOF) break;
3058 }
3059 }
3060 ptr = list_head( &reader->root->children );
3061 }
3062
3063 start = LIST_ENTRY( ptr, struct node, entry );
3064 if (node_type( start ) == WS_XML_NODE_TYPE_EOF) hr = WS_E_INVALID_OPERATION;
3065 else hr = dup_tree( start, enc, node );
3066
3067 done:
3068 LeaveCriticalSection( &reader->cs );
3069 return hr;
3070 }
3071
3072 /**************************************************************************
3073 * WsReadEndElement [webservices.@]
3074 */
3075 HRESULT WINAPI WsReadEndElement( WS_XML_READER *handle, WS_ERROR *error )
3076 {
3077 struct reader *reader = (struct reader *)handle;
3078 HRESULT hr;
3079
3080 TRACE( "%p %p\n", handle, error );
3081 if (error) FIXME( "ignoring error parameter\n" );
3082
3083 if (!reader) return E_INVALIDARG;
3084
3085 EnterCriticalSection( &reader->cs );
3086
3087 if (reader->magic != READER_MAGIC)
3088 {
3089 LeaveCriticalSection( &reader->cs );
3090 return E_INVALIDARG;
3091 }
3092
3093 hr = read_endelement( reader );
3094
3095 LeaveCriticalSection( &reader->cs );
3096 return hr;
3097 }
3098
3099 /**************************************************************************
3100 * WsReadNode [webservices.@]
3101 */
3102 HRESULT WINAPI WsReadNode( WS_XML_READER *handle, WS_ERROR *error )
3103 {
3104 struct reader *reader = (struct reader *)handle;
3105 HRESULT hr;
3106
3107 TRACE( "%p %p\n", handle, error );
3108 if (error) FIXME( "ignoring error parameter\n" );
3109
3110 if (!reader) return E_INVALIDARG;
3111
3112 EnterCriticalSection( &reader->cs );
3113
3114 if (reader->magic != READER_MAGIC)
3115 {
3116 LeaveCriticalSection( &reader->cs );
3117 return E_INVALIDARG;
3118 }
3119
3120 hr = read_node( reader );
3121
3122 LeaveCriticalSection( &reader->cs );
3123 return hr;
3124 }
3125
3126 static HRESULT skip_node( struct reader *reader )
3127 {
3128 const struct node *parent;
3129 HRESULT hr;
3130
3131 if (node_type( reader->current ) == WS_XML_NODE_TYPE_EOF) return WS_E_INVALID_OPERATION;
3132 if (node_type( reader->current ) == WS_XML_NODE_TYPE_ELEMENT) parent = reader->current;
3133 else parent = NULL;
3134
3135 for (;;)
3136 {
3137 if ((hr = read_node( reader )) != S_OK || !parent) break;
3138 if (node_type( reader->current ) != WS_XML_NODE_TYPE_END_ELEMENT) continue;
3139 if (reader->current->parent == parent) return read_node( reader );
3140 }
3141
3142 return hr;
3143 }
3144
3145 /**************************************************************************
3146 * WsSkipNode [webservices.@]
3147 */
3148 HRESULT WINAPI WsSkipNode( WS_XML_READER *handle, WS_ERROR *error )
3149 {
3150 struct reader *reader = (struct reader *)handle;
3151 HRESULT hr;
3152
3153 TRACE( "%p %p\n", handle, error );
3154 if (error) FIXME( "ignoring error parameter\n" );
3155
3156 if (!reader) return E_INVALIDARG;
3157
3158 EnterCriticalSection( &reader->cs );
3159
3160 if (reader->magic != READER_MAGIC)
3161 {
3162 LeaveCriticalSection( &reader->cs );
3163 return E_INVALIDARG;
3164 }
3165
3166 hr = skip_node( reader );
3167
3168 LeaveCriticalSection( &reader->cs );
3169 return hr;
3170 }
3171
3172 /**************************************************************************
3173 * WsReadStartElement [webservices.@]
3174 */
3175 HRESULT WINAPI WsReadStartElement( WS_XML_READER *handle, WS_ERROR *error )
3176 {
3177 struct reader *reader = (struct reader *)handle;
3178 HRESULT hr;
3179
3180 TRACE( "%p %p\n", handle, error );
3181 if (error) FIXME( "ignoring error parameter\n" );
3182
3183 if (!reader) return E_INVALIDARG;
3184
3185 EnterCriticalSection( &reader->cs );
3186
3187 if (reader->magic != READER_MAGIC)
3188 {
3189 LeaveCriticalSection( &reader->cs );
3190 return E_INVALIDARG;
3191 }
3192
3193 hr = read_startelement( reader );
3194
3195 LeaveCriticalSection( &reader->cs );
3196 return hr;
3197 }
3198
3199 /**************************************************************************
3200 * WsReadToStartElement [webservices.@]
3201 */
3202 HRESULT WINAPI WsReadToStartElement( WS_XML_READER *handle, const WS_XML_STRING *localname,
3203 const WS_XML_STRING *ns, BOOL *found, WS_ERROR *error )
3204 {
3205 struct reader *reader = (struct reader *)handle;
3206 HRESULT hr;
3207
3208 TRACE( "%p %s %s %p %p\n", handle, debugstr_xmlstr(localname), debugstr_xmlstr(ns), found, error );
3209 if (error) FIXME( "ignoring error parameter\n" );
3210
3211 if (!reader) return E_INVALIDARG;
3212 if (localname || ns) FIXME( "name and/or namespace not verified\n" );
3213
3214 EnterCriticalSection( &reader->cs );
3215
3216 if (reader->magic != READER_MAGIC)
3217 {
3218 LeaveCriticalSection( &reader->cs );
3219 return E_INVALIDARG;
3220 }
3221
3222 hr = read_to_startelement( reader, found );
3223
3224 LeaveCriticalSection( &reader->cs );
3225 return hr;
3226 }
3227
3228 BOOL move_to_root_element( struct node *root, struct node **current )
3229 {
3230 struct list *ptr;
3231 struct node *node;
3232
3233 if (!(ptr = list_head( &root->children ))) return FALSE;
3234 node = LIST_ENTRY( ptr, struct node, entry );
3235 if (node_type( node ) == WS_XML_NODE_TYPE_ELEMENT)
3236 {
3237 *current = node;
3238 return TRUE;
3239 }
3240 while ((ptr = list_next( &root->children, &node->entry )))
3241 {
3242 struct node *next = LIST_ENTRY( ptr, struct node, entry );
3243 if (node_type( next ) == WS_XML_NODE_TYPE_ELEMENT)
3244 {
3245 *current = next;
3246 return TRUE;
3247 }
3248 node = next;
3249 }
3250 return FALSE;
3251 }
3252
3253 BOOL move_to_next_element( struct node **current )
3254 {
3255 struct list *ptr;
3256 struct node *node = *current, *parent = (*current)->parent;
3257
3258 if (!parent) return FALSE;
3259 while ((ptr = list_next( &parent->children, &node->entry )))
3260 {
3261 struct node *next = LIST_ENTRY( ptr, struct node, entry );
3262 if (node_type( next ) == WS_XML_NODE_TYPE_ELEMENT)
3263 {
3264 *current = next;
3265 return TRUE;
3266 }
3267 node = next;
3268 }
3269 return FALSE;
3270 }
3271
3272 BOOL move_to_prev_element( struct node **current )
3273 {
3274 struct list *ptr;
3275 struct node *node = *current, *parent = (*current)->parent;
3276
3277 if (!parent) return FALSE;
3278 while ((ptr = list_prev( &parent->children, &node->entry )))
3279 {
3280 struct node *prev = LIST_ENTRY( ptr, struct node, entry );
3281 if (node_type( prev ) == WS_XML_NODE_TYPE_ELEMENT)
3282 {
3283 *current = prev;
3284 return TRUE;
3285 }
3286 node = prev;
3287 }
3288 return FALSE;
3289 }
3290
3291 BOOL move_to_child_element( struct node **current )
3292 {
3293 struct list *ptr;
3294 struct node *child, *node = *current;
3295
3296 if (!(ptr = list_head( &node->children ))) return FALSE;
3297 child = LIST_ENTRY( ptr, struct node, entry );
3298 if (node_type( child ) == WS_XML_NODE_TYPE_ELEMENT)
3299 {
3300 *current = child;
3301 return TRUE;
3302 }
3303 while ((ptr = list_next( &node->children, &child->entry )))
3304 {
3305 struct node *next = LIST_ENTRY( ptr, struct node, entry );
3306 if (node_type( next ) == WS_XML_NODE_TYPE_ELEMENT)
3307 {
3308 *current = next;
3309 return TRUE;
3310 }
3311 child = next;
3312 }
3313 return FALSE;
3314 }
3315
3316 BOOL move_to_end_element( struct node **current )
3317 {
3318 struct list *ptr;
3319 struct node *node = *current;
3320
3321 if (node_type( node ) != WS_XML_NODE_TYPE_ELEMENT) return FALSE;
3322
3323 if ((ptr = list_tail( &node->children )))
3324 {
3325 struct node *tail = LIST_ENTRY( ptr, struct node, entry );
3326 if (node_type( tail ) == WS_XML_NODE_TYPE_END_ELEMENT)
3327 {
3328 *current = tail;
3329 return TRUE;
3330 }
3331 }
3332 return FALSE;
3333 }
3334
3335 BOOL move_to_parent_element( struct node **current )
3336 {
3337 struct node *parent = (*current)->parent;
3338
3339 if (parent && (node_type( parent ) == WS_XML_NODE_TYPE_ELEMENT ||
3340 node_type( parent ) == WS_XML_NODE_TYPE_BOF))
3341 {
3342 *current = parent;
3343 return TRUE;
3344 }
3345 return FALSE;
3346 }
3347
3348 BOOL move_to_first_node( struct node **current )
3349 {
3350 struct list *ptr;
3351 struct node *node = *current;
3352
3353 if ((ptr = list_head( &node->parent->children )))
3354 {
3355 *current = LIST_ENTRY( ptr, struct node, entry );
3356 return TRUE;
3357 }
3358 return FALSE;
3359 }
3360
3361 BOOL move_to_next_node( struct node **current )
3362 {
3363 struct list *ptr;
3364 struct node *node = *current;
3365
3366 if ((ptr = list_next( &node->parent->children, &node->entry )))
3367 {
3368 *current = LIST_ENTRY( ptr, struct node, entry );
3369 return TRUE;
3370 }
3371 return FALSE;
3372 }
3373
3374 BOOL move_to_prev_node( struct node **current )
3375 {
3376 struct list *ptr;
3377 struct node *node = *current;
3378
3379 if ((ptr = list_prev( &node->parent->children, &node->entry )))
3380 {
3381 *current = LIST_ENTRY( ptr, struct node, entry );
3382 return TRUE;
3383 }
3384 return FALSE;
3385 }
3386
3387 BOOL move_to_bof( struct node *root, struct node **current )
3388 {
3389 *current = root;
3390 return TRUE;
3391 }
3392
3393 BOOL move_to_eof( struct node *root, struct node **current )
3394 {
3395 struct list *ptr;
3396 if ((ptr = list_tail( &root->children )))
3397 {
3398 *current = LIST_ENTRY( ptr, struct node, entry );
3399 return TRUE;
3400 }
3401 return FALSE;
3402 }
3403
3404 BOOL move_to_child_node( struct node **current )
3405 {
3406 struct list *ptr;
3407 struct node *node = *current;
3408
3409 if ((ptr = list_head( &node->children )))
3410 {
3411 *current = LIST_ENTRY( ptr, struct node, entry );
3412 return TRUE;
3413 }
3414 return FALSE;
3415 }
3416
3417 BOOL move_to_parent_node( struct node **current )
3418 {
3419 struct node *parent = (*current)->parent;
3420 if (!parent) return FALSE;
3421 *current = parent;
3422 return TRUE;
3423 }
3424
3425 static HRESULT read_move_to( struct reader *reader, WS_MOVE_TO move, BOOL *found )
3426 {
3427 BOOL success = FALSE;
3428 HRESULT hr = S_OK;
3429
3430 if (!read_end_of_data( reader ))
3431 {
3432 struct node *saved_current = reader->current;
3433 while (reader->state != READER_STATE_EOF && (hr = read_node( reader )) == S_OK) { /* nothing */ };
3434 if (hr != S_OK) return hr;
3435 reader->current = saved_current;
3436 }
3437 switch (move)
3438 {
3439 case WS_MOVE_TO_ROOT_ELEMENT:
3440 success = move_to_root_element( reader->root, &reader->current );
3441 break;
3442
3443 case WS_MOVE_TO_NEXT_ELEMENT:
3444 success = move_to_next_element( &reader->current );
3445 break;
3446
3447 case WS_MOVE_TO_PREVIOUS_ELEMENT:
3448 success = move_to_prev_element( &reader->current );
3449 break;
3450
3451 case WS_MOVE_TO_CHILD_ELEMENT:
3452 success = move_to_child_element( &reader->current );
3453 break;
3454
3455 case WS_MOVE_TO_END_ELEMENT:
3456 success = move_to_end_element( &reader->current );
3457 break;
3458
3459 case WS_MOVE_TO_PARENT_ELEMENT:
3460 success = move_to_parent_element( &reader->current );
3461 break;
3462
3463 case WS_MOVE_TO_FIRST_NODE:
3464 success = move_to_first_node( &reader->current );
3465 break;
3466
3467 case WS_MOVE_TO_NEXT_NODE:
3468 success = move_to_next_node( &reader->current );
3469 break;
3470
3471 case WS_MOVE_TO_PREVIOUS_NODE:
3472 success = move_to_prev_node( &reader->current );
3473 break;
3474
3475 case WS_MOVE_TO_CHILD_NODE:
3476 success = move_to_child_node( &reader->current );
3477 break;
3478
3479 case WS_MOVE_TO_BOF:
3480 success = move_to_bof( reader->root, &reader->current );
3481 break;
3482
3483 case WS_MOVE_TO_EOF:
3484 success = move_to_eof( reader->root, &reader->current );
3485 break;
3486
3487 default:
3488 FIXME( "unhandled move %u\n", move );
3489 return E_NOTIMPL;
3490 }
3491
3492 if (found)
3493 {
3494 *found = success;
3495 return S_OK;
3496 }
3497 return success ? S_OK : WS_E_INVALID_FORMAT;
3498 }
3499
3500 /**************************************************************************
3501 * WsMoveReader [webservices.@]
3502 */
3503 HRESULT WINAPI WsMoveReader( WS_XML_READER *handle, WS_MOVE_TO move, BOOL *found, WS_ERROR *error )
3504 {
3505 struct reader *reader = (struct reader *)handle;
3506 HRESULT hr;
3507
3508 TRACE( "%p %u %p %p\n", handle, move, found, error );
3509 if (error) FIXME( "ignoring error parameter\n" );
3510
3511 if (!reader) return E_INVALIDARG;
3512
3513 EnterCriticalSection( &reader->cs );
3514
3515 if (reader->magic != READER_MAGIC)
3516 {
3517 LeaveCriticalSection( &reader->cs );
3518 return E_INVALIDARG;
3519 }
3520
3521 if (!reader->input_type)
3522 {
3523 LeaveCriticalSection( &reader->cs );
3524 return WS_E_INVALID_OPERATION;
3525 }
3526
3527 hr = read_move_to( reader, move, found );
3528
3529 LeaveCriticalSection( &reader->cs );
3530 return hr;
3531 }
3532
3533 /**************************************************************************
3534 * WsReadStartAttribute [webservices.@]
3535 */
3536 HRESULT WINAPI WsReadStartAttribute( WS_XML_READER *handle, ULONG index, WS_ERROR *error )
3537 {
3538 struct reader *reader = (struct reader *)handle;
3539 const WS_XML_ELEMENT_NODE *elem;
3540
3541 TRACE( "%p %u %p\n", handle, index, error );
3542 if (error) FIXME( "ignoring error parameter\n" );
3543
3544 if (!reader) return E_INVALIDARG;
3545
3546 EnterCriticalSection( &reader->cs );
3547
3548 if (reader->magic != READER_MAGIC)
3549 {
3550 LeaveCriticalSection( &reader->cs );
3551 return E_INVALIDARG;
3552 }
3553
3554 elem = &reader->current->hdr;
3555 if (reader->state != READER_STATE_STARTELEMENT || index >= elem->attributeCount)
3556 {
3557 LeaveCriticalSection( &reader->cs );
3558 return WS_E_INVALID_FORMAT;
3559 }
3560
3561 reader->current_attr = index;
3562 reader->state = READER_STATE_STARTATTRIBUTE;
3563
3564 LeaveCriticalSection( &reader->cs );
3565 return S_OK;
3566 }
3567
3568 /**************************************************************************
3569 * WsReadEndAttribute [webservices.@]
3570 */
3571 HRESULT WINAPI WsReadEndAttribute( WS_XML_READER *handle, WS_ERROR *error )
3572 {
3573 struct reader *reader = (struct reader *)handle;
3574
3575 TRACE( "%p %p\n", handle, error );
3576 if (error) FIXME( "ignoring error parameter\n" );
3577
3578 if (!reader) return E_INVALIDARG;
3579
3580 EnterCriticalSection( &reader->cs );
3581
3582 if (reader->magic != READER_MAGIC)
3583 {
3584 LeaveCriticalSection( &reader->cs );
3585 return E_INVALIDARG;
3586 }
3587
3588 if (reader->state != READER_STATE_STARTATTRIBUTE)
3589 {
3590 LeaveCriticalSection( &reader->cs );
3591 return WS_E_INVALID_FORMAT;
3592 }
3593
3594 reader->state = READER_STATE_STARTELEMENT;
3595
3596 LeaveCriticalSection( &reader->cs );
3597 return S_OK;
3598 }
3599
3600 static HRESULT str_to_bool( const unsigned char *str, ULONG len, BOOL *ret )
3601 {
3602 if (len == 4 && !memcmp( str, "true", 4 )) *ret = TRUE;
3603 else if (len == 1 && !memcmp( str, "1", 1 )) *ret = TRUE;
3604 else if (len == 5 && !memcmp( str, "false", 5 )) *ret = FALSE;
3605 else if (len == 1 && !memcmp( str, "0", 1 )) *ret = FALSE;
3606 else return WS_E_INVALID_FORMAT;
3607 return S_OK;
3608 }
3609
3610 static HRESULT str_to_int64( const unsigned char *str, ULONG len, INT64 min, INT64 max, INT64 *ret )
3611 {
3612 BOOL negative = FALSE;
3613 const unsigned char *ptr = str;
3614
3615 *ret = 0;
3616 while (len && read_isspace( *ptr )) { ptr++; len--; }
3617 while (len && read_isspace( ptr[len - 1] )) { len--; }
3618 if (!len) return WS_E_INVALID_FORMAT;
3619
3620 if (*ptr == '-')
3621 {
3622 negative = TRUE;
3623 ptr++;
3624 len--;
3625 }
3626 if (!len) return WS_E_INVALID_FORMAT;
3627
3628 while (len--)
3629 {
3630 int val;
3631
3632 if (!isdigit( *ptr )) return WS_E_INVALID_FORMAT;
3633 val = *ptr - '0';
3634 if (negative) val = -val;
3635
3636 if ((!negative && (*ret > max / 10 || *ret * 10 > max - val)) ||
3637 (negative && (*ret < min / 10 || *ret * 10 < min - val)))
3638 {
3639 return WS_E_NUMERIC_OVERFLOW;
3640 }
3641 *ret = *ret * 10 + val;
3642 ptr++;
3643 }
3644
3645 return S_OK;
3646 }
3647
3648 static HRESULT str_to_uint64( const unsigned char *str, ULONG len, UINT64 max, UINT64 *ret )
3649 {
3650 const unsigned char *ptr = str;
3651
3652 *ret = 0;
3653 while (len && read_isspace( *ptr )) { ptr++; len--; }
3654 while (len && read_isspace( ptr[len - 1] )) { len--; }
3655 if (!len) return WS_E_INVALID_FORMAT;
3656
3657 while (len--)
3658 {
3659 unsigned int val;
3660
3661 if (!isdigit( *ptr )) return WS_E_INVALID_FORMAT;
3662 val = *ptr - '0';
3663
3664 if ((*ret > max / 10 || *ret * 10 > max - val)) return WS_E_NUMERIC_OVERFLOW;
3665 *ret = *ret * 10 + val;
3666 ptr++;
3667 }
3668
3669 return S_OK;
3670 }
3671
3672 BOOL set_fpword( unsigned short new, unsigned short *old )
3673 {
3674 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
3675 unsigned short fpword;
3676
3677 __asm__ __volatile__( "fstcw %0" : "=m" (fpword) );
3678 *old = fpword;
3679 fpword = new;
3680 __asm__ __volatile__( "fldcw %0" : : "m" (fpword) );
3681 return TRUE;
3682 #else
3683 FIXME( "not implemented\n" );
3684 return FALSE;
3685 #endif
3686 }
3687
3688 void restore_fpword( unsigned short fpword )
3689 {
3690 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
3691 __asm__ __volatile__( "fldcw %0" : : "m" (fpword) );
3692 #else
3693 FIXME( "not implemented\n" );
3694 #endif
3695 }
3696
3697 static HRESULT str_to_double( const unsigned char *str, ULONG len, double *ret )
3698 {
3699 static const unsigned __int64 nan = 0xfff8000000000000;
3700 static const unsigned __int64 inf = 0x7ff0000000000000;
3701 static const unsigned __int64 inf_min = 0xfff0000000000000;
3702 HRESULT hr = WS_E_INVALID_FORMAT;
3703 const unsigned char *p = str, *q;
3704 int sign = 1, exp_sign = 1, exp = 0, exp_tmp = 0, neg_exp, i, nb_digits, have_digits;
3705 unsigned __int64 val = 0, tmp;
3706 long double exp_val = 1.0, exp_mul = 10.0;
3707 unsigned short fpword;
3708
3709 while (len && read_isspace( *p )) { p++; len--; }
3710 while (len && read_isspace( p[len - 1] )) { len--; }
3711 if (!len) return WS_E_INVALID_FORMAT;
3712
3713 if (len == 3 && !memcmp( p, "NaN", 3 ))
3714 {
3715 *(unsigned __int64 *)ret = nan;
3716 return S_OK;
3717 }
3718 if (len == 3 && !memcmp( p, "INF", 3 ))
3719 {
3720 *(unsigned __int64 *)ret = inf;
3721 return S_OK;
3722 }
3723 if (len == 4 && !memcmp( p, "-INF", 4 ))
3724 {
3725 *(unsigned __int64 *)ret = inf_min;
3726 return S_OK;
3727 }
3728
3729 *ret = 0.0;
3730 if (*p == '-')
3731 {
3732 sign = -1;
3733 p++; len--;
3734 }
3735 else if (*p == '+') { p++; len--; };
3736 if (!len) return S_OK;
3737
3738 if (!set_fpword( 0x37f, &fpword )) return E_NOTIMPL;
3739
3740 q = p;
3741 while (len && isdigit( *q )) { q++; len--; }
3742 have_digits = nb_digits = q - p;
3743 for (i = 0; i < nb_digits; i++)
3744 {
3745 tmp = val * 10 + p[i] - '0';
3746 if (val > MAX_UINT64 / 10 || tmp < val)
3747 {
3748 for (; i < nb_digits; i++) exp++;
3749 break;
3750 }
3751 val = tmp;
3752 }
3753
3754 if (len)
3755 {
3756 if (*q == '.')
3757 {
3758 p = ++q; len--;
3759 while (len && isdigit( *q )) { q++; len--; };
3760 have_digits |= nb_digits = q - p;
3761 for (i = 0; i < nb_digits; i++)
3762 {
3763 tmp = val * 10 + p[i] - '0';
3764 if (val > MAX_UINT64 / 10 || tmp < val) break;
3765 val = tmp;
3766 exp--;
3767 }
3768 }
3769 if (len > 1 && tolower(*q) == 'e')
3770 {
3771 if (!have_digits) goto done;
3772 p = ++q; len--;
3773 if (*p == '-')
3774 {
3775 exp_sign = -1;
3776 p++; len--;
3777 }
3778 else if (*p == '+') { p++; len--; };
3779
3780 q = p;
3781 while (len && isdigit( *q )) { q++; len--; };
3782 nb_digits = q - p;
3783 if (!nb_digits || len) goto done;
3784 for (i = 0; i < nb_digits; i++)
3785 {
3786 if (exp_tmp > MAX_INT32 / 10 || (exp_tmp = exp_tmp * 10 + p[i] - '0') < 0)
3787 exp_tmp = MAX_INT32;
3788 }
3789 exp_tmp *= exp_sign;
3790
3791 if (exp < 0 && exp_tmp < 0 && exp + exp_tmp >= 0) exp = MIN_INT32;
3792 else if (exp > 0 && exp_tmp > 0 && exp + exp_tmp < 0) exp = MAX_INT32;
3793 else exp += exp_tmp;
3794 }
3795 }
3796 if (!have_digits || len) goto done;
3797
3798 if ((neg_exp = exp < 0)) exp = -exp;
3799 for (; exp; exp >>= 1)
3800 {
3801 if (exp & 1) exp_val *= exp_mul;
3802 exp_mul *= exp_mul;
3803 }
3804
3805 *ret = sign * (neg_exp ? val / exp_val : val * exp_val);
3806 hr = S_OK;
3807
3808 done:
3809 restore_fpword( fpword );
3810 return hr;
3811 }
3812
3813 static HRESULT str_to_float( const unsigned char *str, ULONG len, float *ret )
3814 {
3815 static const unsigned int inf = 0x7f800000;
3816 static const unsigned int inf_min = 0xff800000;
3817 const unsigned char *p = str;
3818 double val;
3819 HRESULT hr;
3820
3821 while (len && read_isspace( *p )) { p++; len--; }
3822 while (len && read_isspace( p[len - 1] )) { len--; }
3823 if (!len) return WS_E_INVALID_FORMAT;
3824
3825 if (len == 3 && !memcmp( p, "INF", 3 ))
3826 {
3827 *(unsigned int *)ret = inf;
3828 return S_OK;
3829 }
3830 if (len == 4 && !memcmp( p, "-INF", 4 ))
3831 {
3832 *(unsigned int *)ret = inf_min;
3833 return S_OK;
3834 }
3835
3836 if ((hr = str_to_double( p, len, &val )) != S_OK) return hr;
3837 *ret = val;
3838 return S_OK;
3839 }
3840
3841 static HRESULT str_to_guid( const unsigned char *str, ULONG len, GUID *ret )
3842 {
3843 static const unsigned char hex[] =
3844 {
3845 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x00 */
3846 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x10 */
3847 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x20 */
3848 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, /* 0x30 */
3849 0,10,11,12,13,14,15,0,0,0,0,0,0,0,0,0, /* 0x40 */
3850 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x50 */
3851 0,10,11,12,13,14,15 /* 0x60 */
3852 };
3853 const unsigned char *p = str;
3854 ULONG i;
3855
3856 while (len && read_isspace( *p )) { p++; len--; }
3857 while (len && read_isspace( p[len - 1] )) { len--; }
3858 if (len != 36) return WS_E_INVALID_FORMAT;
3859
3860 if (p[8] != '-' || p[13] != '-' || p[18] != '-' || p[23] != '-')
3861 return WS_E_INVALID_FORMAT;
3862
3863 for (i = 0; i < 36; i++)
3864 {
3865 if (i == 8 || i == 13 || i == 18 || i == 23) continue;
3866 if (p[i] > 'f' || (!hex[p[i]] && p[i] != '0')) return WS_E_INVALID_FORMAT;
3867 }
3868
3869 ret->Data1 = hex[p[0]] << 28 | hex[p[1]] << 24 | hex[p[2]] << 20 | hex[p[3]] << 16 |
3870 hex[p[4]] << 12 | hex[p[5]] << 8 | hex[p[6]] << 4 | hex[p[7]];
3871
3872 ret->Data2 = hex[p[9]] << 12 | hex[p[10]] << 8 | hex[p[11]] << 4 | hex[p[12]];
3873 ret->Data3 = hex[p[14]] << 12 | hex[p[15]] << 8 | hex[p[16]] << 4 | hex[p[17]];
3874
3875 ret->Data4[0] = hex[p[19]] << 4 | hex[p[20]];
3876 ret->Data4[1] = hex[p[21]] << 4 | hex[p[22]];
3877 ret->Data4[2] = hex[p[24]] << 4 | hex[p[25]];
3878 ret->Data4[3] = hex[p[26]] << 4 | hex[p[27]];
3879 ret->Data4[4] = hex[p[28]] << 4 | hex[p[29]];
3880 ret->Data4[5] = hex[p[30]] << 4 | hex[p[31]];
3881 ret->Data4[6] = hex[p[32]] << 4 | hex[p[33]];
3882 ret->Data4[7] = hex[p[34]] << 4 | hex[p[35]];
3883
3884 return S_OK;
3885 }
3886
3887 static HRESULT str_to_string( const unsigned char *str, ULONG len, WS_HEAP *heap, WS_STRING *ret )
3888 {
3889 int len_utf16 = MultiByteToWideChar( CP_UTF8, 0, (const char *)str, len, NULL, 0 );
3890 if (!(ret->chars = ws_alloc( heap, len_utf16 * sizeof(WCHAR) ))) return WS_E_QUOTA_EXCEEDED;
3891 MultiByteToWideChar( CP_UTF8, 0, (const char *)str, len, ret->chars, len_utf16 );
3892 ret->length = len_utf16;
3893 return S_OK;
3894 }
3895
3896 static HRESULT str_to_unique_id( const unsigned char *str, ULONG len, WS_HEAP *heap, WS_UNIQUE_ID *ret )
3897 {
3898 if (len == 45 && !memcmp( str, "urn:uuid:", 9 ))
3899 {
3900 ret->uri.length = 0;
3901 ret->uri.chars = NULL;
3902 return str_to_guid( str + 9, len - 9, &ret->guid );
3903 }
3904
3905 memset( &ret->guid, 0, sizeof(ret->guid) );
3906 return str_to_string( str, len, heap, &ret->uri );
3907 }
3908
3909 static inline unsigned char decode_char( unsigned char c )
3910 {
3911 if (c >= 'A' && c <= 'Z') return c - 'A';
3912 if (c >= 'a' && c <= 'z') return c - 'a' + 26;
3913 if (c >= '0' && c <= '9') return c - '0' + 52;
3914 if (c == '+') return 62;
3915 if (c == '/') return 63;
3916 return 64;
3917 }
3918
3919 static ULONG decode_base64( const unsigned char *base64, ULONG len, unsigned char *buf )
3920 {
3921 ULONG i = 0;
3922 unsigned char c0, c1, c2, c3;
3923 const unsigned char *p = base64;
3924
3925 while (len > 4)
3926 {
3927 if ((c0 = decode_char( p[0] )) > 63) return 0;
3928 if ((c1 = decode_char( p[1] )) > 63) return 0;
3929 if ((c2 = decode_char( p[2] )) > 63) return 0;
3930 if ((c3 = decode_char( p[3] )) > 63) return 0;
3931 buf[i + 0] = (c0 << 2) | (c1 >> 4);
3932 buf[i + 1] = (c1 << 4) | (c2 >> 2);
3933 buf[i + 2] = (c2 << 6) | c3;
3934 len -= 4;
3935 i += 3;
3936 p += 4;
3937 }
3938 if (p[2] == '=')
3939 {
3940 if ((c0 = decode_char( p[0] )) > 63) return 0;
3941 if ((c1 = decode_char( p[1] )) > 63) return 0;
3942 buf[i] = (c0 << 2) | (c1 >> 4);
3943 i++;
3944 }
3945 else if (p[3] == '=')
3946 {
3947 if ((c0 = decode_char( p[0] )) > 63) return 0;
3948 if ((c1 = decode_char( p[1] )) > 63) return 0;
3949 if ((c2 = decode_char( p[2] )) > 63) return 0;
3950 buf[i + 0] = (c0 << 2) | (c1 >> 4);
3951 buf[i + 1] = (c1 << 4) | (c2 >> 2);
3952 i += 2;
3953 }
3954 else
3955 {
3956 if ((c0 = decode_char( p[0] )) > 63) return 0;
3957 if ((c1 = decode_char( p[1] )) > 63) return 0;
3958 if ((c2 = decode_char( p[2] )) > 63) return 0;
3959 if ((c3 = decode_char( p[3] )) > 63) return 0;
3960 buf[i + 0] = (c0 << 2) | (c1 >> 4);
3961 buf[i + 1] = (c1 << 4) | (c2 >> 2);
3962 buf[i + 2] = (c2 << 6) | c3;
3963 i += 3;
3964 }
3965 return i;
3966 }
3967
3968 static HRESULT str_to_bytes( const unsigned char *str, ULONG len, WS_HEAP *heap, WS_BYTES *ret )
3969 {
3970 const unsigned char *p = str;
3971
3972 while (len && read_isspace( *p )) { p++; len--; }
3973 while (len && read_isspace( p[len - 1] )) { len--; }
3974
3975 if (len % 4) return WS_E_INVALID_FORMAT;
3976 if (!(ret->bytes = ws_alloc( heap, len * 3 / 4 ))) return WS_E_QUOTA_EXCEEDED;
3977 ret->length = decode_base64( p, len, ret->bytes );
3978 return S_OK;
3979 }
3980
3981 static HRESULT str_to_xml_string( const unsigned char *str, ULONG len, WS_HEAP *heap, WS_XML_STRING *ret )
3982 {
3983 if (!(ret->bytes = ws_alloc( heap, len ))) return WS_E_QUOTA_EXCEEDED;
3984 memcpy( ret->bytes, str, len );
3985 ret->length = len;
3986 ret->dictionary = NULL;
3987 ret->id = 0;
3988 return S_OK;
3989 }
3990
3991 static HRESULT copy_xml_string( WS_HEAP *heap, const WS_XML_STRING *src, WS_XML_STRING *dst )
3992 {
3993 if (!(dst->bytes = ws_alloc( heap, src->length ))) return WS_E_QUOTA_EXCEEDED;
3994 memcpy( dst->bytes, src->bytes, src->length );
3995 dst->length = src->length;
3996 return S_OK;
3997 }
3998
3999 static HRESULT str_to_qname( struct reader *reader, const unsigned char *str, ULONG len, WS_HEAP *heap,
4000 WS_XML_STRING *prefix_ret, WS_XML_STRING *localname_ret, WS_XML_STRING *ns_ret )
4001 {
4002 const unsigned char *p = str;
4003 WS_XML_STRING prefix, localname;
4004 const WS_XML_STRING *ns;
4005 HRESULT hr;
4006
4007 while (len && read_isspace( *p )) { p++; len--; }
4008 while (len && read_isspace( p[len - 1] )) { len--; }
4009
4010 if ((hr = split_qname( p, len, &prefix, &localname )) != S_OK) return hr;
4011 if (!(ns = get_namespace( reader, &prefix ))) return WS_E_INVALID_FORMAT;
4012
4013 if (prefix_ret && (hr = copy_xml_string( heap, &prefix, prefix_ret )) != S_OK) return hr;
4014 if ((hr = copy_xml_string( heap, &localname, localname_ret )) != S_OK)
4015 {
4016 ws_free( heap, prefix_ret->bytes, prefix_ret->length );
4017 return hr;
4018 }
4019 if ((hr = copy_xml_string( heap, ns, ns_ret )) != S_OK)
4020 {
4021 ws_free( heap, prefix_ret->bytes, prefix_ret->length );
4022 ws_free( heap, localname_ret->bytes, localname_ret->length );
4023 return hr;
4024 }
4025 return S_OK;
4026 }
4027
4028 static HRESULT read_qualified_name( struct reader *reader, WS_HEAP *heap, WS_XML_STRING *prefix,
4029 WS_XML_STRING *localname, WS_XML_STRING *ns )
4030 {
4031 const WS_XML_TEXT_NODE *node = (const WS_XML_TEXT_NODE *)reader->current;
4032 const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)node->text;
4033 return str_to_qname( reader, utf8->value.bytes, utf8->value.length, heap, prefix, localname, ns );
4034 }
4035
4036 /**************************************************************************
4037 * WsReadQualifiedName [webservices.@]
4038 */
4039 HRESULT WINAPI WsReadQualifiedName( WS_XML_READER *handle, WS_HEAP *heap, WS_XML_STRING *prefix,
4040 WS_XML_STRING *localname, WS_XML_STRING *ns,
4041 WS_ERROR *error )
4042 {
4043 struct reader *reader = (struct reader *)handle;
4044 HRESULT hr;
4045
4046 TRACE( "%p %p %p %p %p %p\n", handle, heap, prefix, localname, ns, error );
4047 if (error) FIXME( "ignoring error parameter\n" );
4048
4049 if (!reader || !heap) return E_INVALIDARG;
4050
4051 EnterCriticalSection( &reader->cs );
4052
4053 if (reader->magic != READER_MAGIC)
4054 {
4055 LeaveCriticalSection( &reader->cs );
4056 return E_INVALIDARG;
4057 }
4058
4059 if (!reader->input_type)
4060 {
4061 LeaveCriticalSection( &reader->cs );
4062 return WS_E_INVALID_OPERATION;
4063 }
4064
4065 if (!localname)
4066 {
4067 LeaveCriticalSection( &reader->cs );
4068 return E_INVALIDARG;
4069 }
4070
4071 if (reader->state != READER_STATE_TEXT)
4072 {
4073 LeaveCriticalSection( &reader->cs );
4074 return WS_E_INVALID_FORMAT;
4075 }
4076
4077 hr = read_qualified_name( reader, heap, prefix, localname, ns );
4078
4079 LeaveCriticalSection( &reader->cs );
4080 return hr;
4081 }
4082
4083 static const int month_offsets[2][12] =
4084 {
4085 {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},
4086 {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335}
4087 };
4088
4089 static inline int valid_day( int year, int month, int day )
4090 {
4091 return day > 0 && day <= month_days[leap_year( year )][month - 1];
4092 }
4093
4094 static inline int leap_days_before( int year )
4095 {
4096 return (year - 1) / 4 - (year - 1) / 100 + (year - 1) / 400;
4097 }
4098
4099 static HRESULT str_to_datetime( const unsigned char *bytes, ULONG len, WS_DATETIME *ret )
4100 {
4101 const unsigned char *p = bytes, *q;
4102 int year, month, day, hour, min, sec, sec_frac = 0, tz_hour, tz_min, tz_neg;
4103
4104 while (len && read_isspace( *p )) { p++; len--; }
4105 while (len && read_isspace( p[len - 1] )) { len--; }
4106
4107 q = p;
4108 while (len && isdigit( *q )) { q++; len--; };
4109 if (q - p != 4 || !len || *q != '-') return WS_E_INVALID_FORMAT;
4110 year = (p[0] - '0') * 1000 + (p[1] - '0') * 100 + (p[2] - '0') * 10 + p[3] - '0';
4111 if (year < 1) return WS_E_INVALID_FORMAT;
4112
4113 p = ++q; len--;
4114 while (len && isdigit( *q )) { q++; len--; };
4115 if (q - p != 2 || !len || *q != '-') return WS_E_INVALID_FORMAT;
4116 month = (p[0] - '0') * 10 + p[1] - '0';
4117 if (month < 1 || month > 12) return WS_E_INVALID_FORMAT;
4118
4119 p = ++q; len--;
4120 while (len && isdigit( *q )) { q++; len--; };
4121 if (q - p != 2 || !len || *q != 'T') return WS_E_INVALID_FORMAT;
4122 day = (p[0] - '0') * 10 + p[1] - '0';
4123 if (!valid_day( year, month, day )) return WS_E_INVALID_FORMAT;
4124
4125 p = ++q; len--;
4126 while (len && isdigit( *q )) { q++; len--; };
4127 if (q - p != 2 || !len || *q != ':') return WS_E_INVALID_FORMAT;
4128 hour = (p[0] - '0') * 10 + p[1] - '0';
4129 if (hour > 24) return WS_E_INVALID_FORMAT;
4130
4131 p = ++q; len--;
4132 while (len && isdigit( *q )) { q++; len--; };
4133 if (q - p != 2 || !len || *q != ':') return WS_E_INVALID_FORMAT;
4134 min = (p[0] - '0') * 10 + p[1] - '0';
4135 if (min > 59 || (min > 0 && hour == 24)) return WS_E_INVALID_FORMAT;
4136
4137 p = ++q; len--;
4138 while (len && isdigit( *q )) { q++; len--; };
4139 if (q - p != 2 || !len) return WS_E_INVALID_FORMAT;
4140 sec = (p[0] - '0') * 10 + p[1] - '0';
4141 if (sec > 59 || (sec > 0 && hour == 24)) return WS_E_INVALID_FORMAT;
4142
4143 if (*q == '.')
4144 {
4145 unsigned int i, nb_digits, mul = TICKS_PER_SEC / 10;
4146 p = ++q; len--;
4147 while (len && isdigit( *q )) { q++; len--; };
4148 nb_digits = q - p;
4149 if (nb_digits < 1 || nb_digits > 7) return WS_E_INVALID_FORMAT;
4150 for (i = 0; i < nb_digits; i++)
4151 {
4152 sec_frac += (p[i] - '0') * mul;
4153 mul /= 10;
4154 }
4155 }
4156 if (*q == 'Z')
4157 {
4158 if (--len) return WS_E_INVALID_FORMAT;
4159 tz_hour = tz_min = tz_neg = 0;
4160 ret->format = WS_DATETIME_FORMAT_UTC;
4161 }
4162 else if (*q == '+' || *q == '-')
4163 {
4164 tz_neg = (*q == '-') ? 1 : 0;
4165
4166 p = ++q; len--;
4167 while (len && isdigit( *q )) { q++; len--; };
4168 if (q - p != 2 || !len || *q != ':') return WS_E_INVALID_FORMAT;
4169 tz_hour = (p[0] - '0') * 10 + p[1] - '0';
4170 if (tz_hour > 14) return WS_E_INVALID_FORMAT;
4171
4172 p = ++q; len--;
4173 while (len && isdigit( *q )) { q++; len--; };
4174 if (q - p != 2 || len) return WS_E_INVALID_FORMAT;
4175 tz_min = (p[0] - '0') * 10 + p[1] - '0';
4176 if (tz_min > 59 || (tz_min > 0 && tz_hour == 14)) return WS_E_INVALID_FORMAT;
4177
4178 ret->format = WS_DATETIME_FORMAT_LOCAL;
4179 }
4180 else return WS_E_INVALID_FORMAT;
4181
4182 ret->ticks = ((year - 1) * 365 + leap_days_before( year )) * TICKS_PER_DAY;
4183 ret->ticks += month_offsets[leap_year( year )][month - 1] * TICKS_PER_DAY;
4184 ret->ticks += (day - 1) * TICKS_PER_DAY;
4185 ret->ticks += hour * TICKS_PER_HOUR;
4186 ret->ticks += min * TICKS_PER_MIN;
4187 ret->ticks += sec * TICKS_PER_SEC;
4188 ret->ticks += sec_frac;
4189
4190 if (tz_neg)
4191 {
4192 if (tz_hour * TICKS_PER_HOUR + tz_min * TICKS_PER_MIN + ret->ticks > TICKS_MAX)
4193 return WS_E_INVALID_FORMAT;
4194 ret->ticks += tz_hour * TICKS_PER_HOUR;
4195 ret->ticks += tz_min * TICKS_PER_MIN;
4196 }
4197 else
4198 {
4199 if (tz_hour * TICKS_PER_HOUR + tz_min * TICKS_PER_MIN > ret->ticks)
4200 return WS_E_INVALID_FORMAT;
4201 ret->ticks -= tz_hour * TICKS_PER_HOUR;
4202 ret->ticks -= tz_min * TICKS_PER_MIN;
4203 }
4204
4205 return S_OK;
4206 }
4207
4208 /**************************************************************************
4209 * WsDateTimeToFileTime [webservices.@]
4210 */
4211 HRESULT WINAPI WsDateTimeToFileTime( const WS_DATETIME *dt, FILETIME *ft, WS_ERROR *error )
4212 {
4213 unsigned __int64 ticks;
4214
4215 TRACE( "%p %p %p\n", dt, ft, error );
4216 if (error) FIXME( "ignoring error parameter\n" );
4217
4218 if (!dt || !ft) return E_INVALIDARG;
4219
4220 if (dt->ticks < TICKS_1601_01_01) return WS_E_INVALID_FORMAT;
4221 ticks = dt->ticks - TICKS_1601_01_01;
4222 ft->dwHighDateTime = ticks >> 32;
4223 ft->dwLowDateTime = (DWORD)ticks;
4224 return S_OK;
4225 }
4226
4227 /**************************************************************************
4228 * WsFileTimeToDateTime [webservices.@]
4229 */
4230 HRESULT WINAPI WsFileTimeToDateTime( const FILETIME *ft, WS_DATETIME *dt, WS_ERROR *error )
4231 {
4232 unsigned __int64 ticks;
4233
4234 TRACE( "%p %p %p\n", ft, dt, error );
4235 if (error) FIXME( "ignoring error parameter\n" );
4236
4237 if (!dt || !ft) return E_INVALIDARG;
4238
4239 ticks = ((unsigned __int64)ft->dwHighDateTime << 32) | ft->dwLowDateTime;
4240 if (ticks > MAX_UINT64 - TICKS_1601_01_01) return WS_E_NUMERIC_OVERFLOW;
4241 if (ticks + TICKS_1601_01_01 > TICKS_MAX) return WS_E_INVALID_FORMAT;
4242 dt->ticks = ticks + TICKS_1601_01_01;
4243 dt->format = WS_DATETIME_FORMAT_UTC;
4244 return S_OK;
4245 }
4246
4247 static BOOL find_attribute( struct reader *reader, const WS_XML_STRING *localname,
4248 const WS_XML_STRING *ns, ULONG *index )
4249 {
4250 ULONG i;
4251 WS_XML_ELEMENT_NODE *elem = &reader->current->hdr;
4252
4253 if (!localname)
4254 {
4255 *index = reader->current_attr;
4256 return TRUE;
4257 }
4258 for (i = 0; i < elem->attributeCount; i++)
4259 {
4260 const WS_XML_STRING *localname2 = elem->attributes[i]->localName;
4261 const WS_XML_STRING *ns2 = elem->attributes[i]->ns;
4262
4263 if (!cmp_name( localname->bytes, localname->length, localname2->bytes, localname2->length ) &&
4264 !cmp_name( ns->bytes, ns->length, ns2->bytes, ns2->length ))
4265 {
4266 *index = i;
4267 return TRUE;
4268 }
4269 }
4270 return FALSE;
4271 }
4272
4273 /**************************************************************************
4274 * WsFindAttribute [webservices.@]
4275 */
4276 HRESULT WINAPI WsFindAttribute( WS_XML_READER *handle, const WS_XML_STRING *localname,
4277 const WS_XML_STRING *ns, BOOL required, ULONG *index,
4278 WS_ERROR *error )
4279 {
4280 struct reader *reader = (struct reader *)handle;
4281 HRESULT hr = S_OK;
4282
4283 TRACE( "%p %s %s %d %p %p\n", handle, debugstr_xmlstr(localname), debugstr_xmlstr(ns),
4284 required, index, error );
4285 if (error) FIXME( "ignoring error parameter\n" );
4286
4287 if (!reader || !localname || !ns || !index) return E_INVALIDARG;
4288
4289 EnterCriticalSection( &reader->cs );
4290
4291 if (reader->magic != READER_MAGIC)
4292 {
4293 LeaveCriticalSection( &reader->cs );
4294 return E_INVALIDARG;
4295 }
4296
4297 if (node_type( reader->current ) != WS_XML_NODE_TYPE_ELEMENT)
4298 {
4299 LeaveCriticalSection( &reader->cs );
4300 return WS_E_INVALID_OPERATION;
4301 }
4302
4303 if (!find_attribute( reader, localname, ns, index ))
4304 {
4305 if (required) hr = WS_E_INVALID_FORMAT;
4306 else
4307 {
4308 *index = ~0u;
4309 hr = S_FALSE;
4310 }
4311 }
4312
4313 LeaveCriticalSection( &reader->cs );
4314 return hr;
4315 }
4316
4317 static HRESULT get_node_text( struct reader *reader, const WS_XML_TEXT **ret )
4318 {
4319 WS_XML_TEXT_NODE *node = (WS_XML_TEXT_NODE *)&reader->current->hdr.node;
4320 *ret = node->text;
4321 return S_OK;
4322 }
4323
4324 static HRESULT get_attribute_text( struct reader *reader, ULONG index, const WS_XML_TEXT **ret )
4325 {
4326 WS_XML_ELEMENT_NODE *elem = &reader->current->hdr;
4327 *ret = elem->attributes[index]->value;
4328 return S_OK;
4329 }
4330
4331 static BOOL match_element( const struct node *node, const WS_XML_STRING *localname, const WS_XML_STRING *ns )
4332 {
4333 const WS_XML_ELEMENT_NODE *elem = (const WS_XML_ELEMENT_NODE *)node;
4334 if (node_type( node ) != WS_XML_NODE_TYPE_ELEMENT) return FALSE;
4335 return WsXmlStringEquals( localname, elem->localName, NULL ) == S_OK &&
4336 WsXmlStringEquals( ns, elem->ns, NULL ) == S_OK;
4337 }
4338
4339 static HRESULT read_next_node( struct reader *reader )
4340 {
4341 if (reader->current == reader->last) return read_node( reader );
4342 if (move_to_child_node( &reader->current )) return S_OK;
4343 if (move_to_next_node( &reader->current )) return S_OK;
4344 if (!move_to_parent_node( &reader->current )) return WS_E_INVALID_FORMAT;
4345 if (move_to_next_node( &reader->current )) return S_OK;
4346 return WS_E_INVALID_FORMAT;
4347 }
4348
4349 static HRESULT get_text( struct reader *reader, WS_TYPE_MAPPING mapping, const WS_XML_STRING *localname,
4350 const WS_XML_STRING *ns, const WS_XML_TEXT **ret, BOOL *found )
4351 {
4352 switch (mapping)
4353 {
4354 case WS_ATTRIBUTE_TYPE_MAPPING:
4355 {
4356 ULONG index;
4357 if (!(*found = find_attribute( reader, localname, ns, &index ))) return S_OK;
4358 return get_attribute_text( reader, index, ret );
4359 }
4360 case WS_ELEMENT_TYPE_MAPPING:
4361 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
4362 case WS_ANY_ELEMENT_TYPE_MAPPING:
4363 {
4364 *found = TRUE;
4365 if (localname)
4366 {
4367 HRESULT hr;
4368 if (!match_element( reader->current, localname, ns ))
4369 {
4370 *found = FALSE;
4371 return S_OK;
4372 }
4373 if ((hr = read_next_node( reader )) != S_OK) return hr;
4374 if (node_type( reader->current ) != WS_XML_NODE_TYPE_TEXT)
4375 {
4376 if (!move_to_parent_element( &reader->current )) return WS_E_INVALID_FORMAT;
4377 *found = FALSE;
4378 return S_OK;
4379 }
4380 }
4381 if (node_type( reader->current ) != WS_XML_NODE_TYPE_TEXT)
4382 {
4383 *found = FALSE;
4384 return S_OK;
4385 }
4386 return get_node_text( reader, ret );
4387 }
4388 default:
4389 FIXME( "mapping %u not supported\n", mapping );
4390 return E_NOTIMPL;
4391 }
4392 }
4393
4394 static HRESULT text_to_bool( const WS_XML_TEXT *text, BOOL *val )
4395 {
4396 HRESULT hr;
4397
4398 switch (text->textType)
4399 {
4400 case WS_XML_TEXT_TYPE_UTF8:
4401 {
4402 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
4403 hr = str_to_bool( text_utf8->value.bytes, text_utf8->value.length, val );
4404 break;
4405 }
4406 case WS_XML_TEXT_TYPE_BOOL:
4407 {
4408 const WS_XML_BOOL_TEXT *text_bool = (const WS_XML_BOOL_TEXT *)text;
4409 *val = text_bool->value;
4410 hr = S_OK;
4411 break;
4412 }
4413 default:
4414 FIXME( "unhandled text type %u\n", text->textType );
4415 return E_NOTIMPL;
4416 }
4417
4418 return hr;
4419 }
4420
4421 static HRESULT read_type_bool( struct reader *reader, WS_TYPE_MAPPING mapping,
4422 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
4423 const WS_BOOL_DESCRIPTION *desc, WS_READ_OPTION option,
4424 WS_HEAP *heap, void *ret, ULONG size )
4425 {
4426 const WS_XML_TEXT *text;
4427 HRESULT hr;
4428 BOOL found, val = FALSE;
4429
4430 if (desc)
4431 {
4432 FIXME( "description not supported\n" );
4433 return E_NOTIMPL;
4434 }
4435 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
4436 if (found && (hr = text_to_bool( text, &val )) != S_OK) return hr;
4437
4438 switch (option)
4439 {
4440 case WS_READ_REQUIRED_VALUE:
4441 if (!found) return WS_E_INVALID_FORMAT;
4442 /* fall through */
4443
4444 case WS_READ_NILLABLE_VALUE:
4445 if (size != sizeof(val)) return E_INVALIDARG;
4446 *(BOOL *)ret = val;
4447 break;
4448
4449 case WS_READ_REQUIRED_POINTER:
4450 if (!found) return WS_E_INVALID_FORMAT;
4451 /* fall through */
4452
4453 case WS_READ_OPTIONAL_POINTER:
4454 case WS_READ_NILLABLE_POINTER:
4455 {
4456 BOOL *heap_val = NULL;
4457 if (size != sizeof(heap_val)) return E_INVALIDARG;
4458 if (found)
4459 {
4460 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
4461 *heap_val = val;
4462 }
4463 *(BOOL **)ret = heap_val;
4464 break;
4465 }
4466 default:
4467 FIXME( "read option %u not supported\n", option );
4468 return E_NOTIMPL;
4469 }
4470
4471 return S_OK;
4472 }
4473
4474 static HRESULT text_to_int8( const WS_XML_TEXT *text, INT64 *val )
4475 {
4476 HRESULT hr;
4477
4478 switch (text->textType)
4479 {
4480 case WS_XML_TEXT_TYPE_UTF8:
4481 {
4482 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
4483 hr = str_to_int64( text_utf8->value.bytes, text_utf8->value.length, MIN_INT8, MAX_INT8, val );
4484 break;
4485 }
4486 case WS_XML_TEXT_TYPE_INT32:
4487 {
4488 const WS_XML_INT32_TEXT *text_int32 = (const WS_XML_INT32_TEXT *)text;
4489 assert( text_int32->value >= MIN_INT8 );
4490 assert( text_int32->value <= MAX_INT8 );
4491 *val = text_int32->value;
4492 hr = S_OK;
4493 break;
4494 }
4495 default:
4496 FIXME( "unhandled text type %u\n", text->textType );
4497 return E_NOTIMPL;
4498 }
4499
4500 return hr;
4501 }
4502
4503 static HRESULT read_type_int8( struct reader *reader, WS_TYPE_MAPPING mapping,
4504 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
4505 const WS_INT8_DESCRIPTION *desc, WS_READ_OPTION option,
4506 WS_HEAP *heap, void *ret, ULONG size )
4507 {
4508 const WS_XML_TEXT *text;
4509 HRESULT hr;
4510 INT64 val = 0;
4511 BOOL found;
4512
4513 if (desc)
4514 {
4515 FIXME( "description not supported\n" );
4516 return E_NOTIMPL;
4517 }
4518 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
4519 if (found && (hr = text_to_int8( text, &val )) != S_OK) return hr;
4520
4521 switch (option)
4522 {
4523 case WS_READ_REQUIRED_VALUE:
4524 if (!found) return WS_E_INVALID_FORMAT;
4525 /* fall through */
4526
4527 case WS_READ_NILLABLE_VALUE:
4528 if (size != sizeof(INT8)) return E_INVALIDARG;
4529 *(INT8 *)ret = val;
4530 break;
4531
4532 case WS_READ_REQUIRED_POINTER:
4533 if (!found) return WS_E_INVALID_FORMAT;
4534 /* fall through */
4535
4536 case WS_READ_OPTIONAL_POINTER:
4537 case WS_READ_NILLABLE_POINTER:
4538 {
4539 INT8 *heap_val = NULL;
4540 if (size != sizeof(heap_val)) return E_INVALIDARG;
4541 if (found)
4542 {
4543 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
4544 *heap_val = val;
4545 }
4546 *(INT8 **)ret = heap_val;
4547 break;
4548 }
4549 default:
4550 FIXME( "read option %u not supported\n", option );
4551 return E_NOTIMPL;
4552 }
4553
4554 return S_OK;
4555 }
4556
4557 static HRESULT text_to_int16( const WS_XML_TEXT *text, INT64 *val )
4558 {
4559 HRESULT hr;
4560
4561 switch (text->textType)
4562 {
4563 case WS_XML_TEXT_TYPE_UTF8:
4564 {
4565 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
4566 hr = str_to_int64( text_utf8->value.bytes, text_utf8->value.length, MIN_INT16, MAX_INT16, val );
4567 break;
4568 }
4569 case WS_XML_TEXT_TYPE_INT32:
4570 {
4571 const WS_XML_INT32_TEXT *text_int32 = (const WS_XML_INT32_TEXT *)text;
4572 assert( text_int32->value >= MIN_INT16 );
4573 assert( text_int32->value <= MAX_INT16 );
4574 *val = text_int32->value;
4575 hr = S_OK;
4576 break;
4577 }
4578 default:
4579 FIXME( "unhandled text type %u\n", text->textType );
4580 return E_NOTIMPL;
4581 }
4582
4583 return hr;
4584 }
4585
4586 static HRESULT read_type_int16( struct reader *reader, WS_TYPE_MAPPING mapping,
4587 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
4588 const WS_INT16_DESCRIPTION *desc, WS_READ_OPTION option,
4589 WS_HEAP *heap, void *ret, ULONG size )
4590 {
4591 const WS_XML_TEXT *text;
4592 HRESULT hr;
4593 INT64 val = 0;
4594 BOOL found;
4595
4596 if (desc)
4597 {
4598 FIXME( "description not supported\n" );
4599 return E_NOTIMPL;
4600 }
4601 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
4602 if (found && (hr = text_to_int16( text, &val )) != S_OK) return hr;
4603
4604 switch (option)
4605 {
4606 case WS_READ_REQUIRED_VALUE:
4607 if (!found) return WS_E_INVALID_FORMAT;
4608 /* fall through */
4609
4610 case WS_READ_NILLABLE_VALUE:
4611 if (size != sizeof(INT16)) return E_INVALIDARG;
4612 *(INT16 *)ret = val;
4613 break;
4614
4615 case WS_READ_REQUIRED_POINTER:
4616 if (!found) return WS_E_INVALID_FORMAT;
4617 /* fall through */
4618
4619 case WS_READ_OPTIONAL_POINTER:
4620 case WS_READ_NILLABLE_POINTER:
4621 {
4622 INT16 *heap_val = NULL;
4623 if (size != sizeof(heap_val)) return E_INVALIDARG;
4624 if (found)
4625 {
4626 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
4627 *heap_val = val;
4628 }
4629 *(INT16 **)ret = heap_val;
4630 break;
4631 }
4632 default:
4633 FIXME( "read option %u not supported\n", option );
4634 return E_NOTIMPL;
4635 }
4636
4637 return S_OK;
4638 }
4639
4640 static HRESULT text_to_int32( const WS_XML_TEXT *text, INT64 *val )
4641 {
4642 HRESULT hr;
4643
4644 switch (text->textType)
4645 {
4646 case WS_XML_TEXT_TYPE_UTF8:
4647 {
4648 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
4649 hr = str_to_int64( text_utf8->value.bytes, text_utf8->value.length, MIN_INT32, MAX_INT32, val );
4650 break;
4651 }
4652 case WS_XML_TEXT_TYPE_INT32:
4653 {
4654 const WS_XML_INT32_TEXT *text_int32 = (const WS_XML_INT32_TEXT *)text;
4655 *val = text_int32->value;
4656 hr = S_OK;
4657 break;
4658 }
4659 default:
4660 FIXME( "unhandled text type %u\n", text->textType );
4661 return E_NOTIMPL;
4662 }
4663
4664 return hr;
4665 }
4666
4667 static HRESULT read_type_int32( struct reader *reader, WS_TYPE_MAPPING mapping,
4668 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
4669 const WS_INT32_DESCRIPTION *desc, WS_READ_OPTION option,
4670 WS_HEAP *heap, void *ret, ULONG size )
4671 {
4672 const WS_XML_TEXT *text;
4673 HRESULT hr;
4674 INT64 val = 0;
4675 BOOL found;
4676
4677 if (desc)
4678 {
4679 FIXME( "description not supported\n" );
4680 return E_NOTIMPL;
4681 }
4682 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
4683 if (found && (hr = text_to_int32( text, &val )) != S_OK) return hr;
4684
4685 switch (option)
4686 {
4687 case WS_READ_REQUIRED_VALUE:
4688 if (!found) return WS_E_INVALID_FORMAT;
4689 /* fall through */
4690
4691 case WS_READ_NILLABLE_VALUE:
4692 if (size != sizeof(INT32)) return E_INVALIDARG;
4693 *(INT32 *)ret = val;
4694 break;
4695
4696 case WS_READ_REQUIRED_POINTER:
4697 if (!found) return WS_E_INVALID_FORMAT;
4698 /* fall through */
4699
4700 case WS_READ_OPTIONAL_POINTER:
4701 case WS_READ_NILLABLE_POINTER:
4702 {
4703 INT32 *heap_val = NULL;
4704 if (size != sizeof(heap_val)) return E_INVALIDARG;
4705 if (found)
4706 {
4707 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
4708 *heap_val = val;
4709 }
4710 *(INT32 **)ret = heap_val;
4711 break;
4712 }
4713 default:
4714 FIXME( "read option %u not supported\n", option );
4715 return E_NOTIMPL;
4716 }
4717
4718 return S_OK;
4719 }
4720
4721 static HRESULT text_to_int64( const WS_XML_TEXT *text, INT64 *val )
4722 {
4723 HRESULT hr;
4724
4725 switch (text->textType)
4726 {
4727 case WS_XML_TEXT_TYPE_UTF8:
4728 {
4729 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
4730 hr = str_to_int64( text_utf8->value.bytes, text_utf8->value.length, MIN_INT64, MAX_INT64, val );
4731 break;
4732 }
4733 case WS_XML_TEXT_TYPE_INT64:
4734 {
4735 const WS_XML_INT64_TEXT *text_int64 = (const WS_XML_INT64_TEXT *)text;
4736 *val = text_int64->value;
4737 hr = S_OK;
4738 break;
4739 }
4740 default:
4741 FIXME( "unhandled text type %u\n", text->textType );
4742 return E_NOTIMPL;
4743 }
4744
4745 return hr;
4746 }
4747
4748 static HRESULT read_type_int64( struct reader *reader, WS_TYPE_MAPPING mapping,
4749 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
4750 const WS_INT64_DESCRIPTION *desc, WS_READ_OPTION option,
4751 WS_HEAP *heap, void *ret, ULONG size )
4752 {
4753 const WS_XML_TEXT *text;
4754 HRESULT hr;
4755 INT64 val = 0;
4756 BOOL found;
4757
4758 if (desc)
4759 {
4760 FIXME( "description not supported\n" );
4761 return E_NOTIMPL;
4762 }
4763 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
4764 if (found && (hr = text_to_int64( text, &val )) != S_OK) return hr;
4765
4766 switch (option)
4767 {
4768 case WS_READ_REQUIRED_VALUE:
4769 if (!found) return WS_E_INVALID_FORMAT;
4770 /* fall through */
4771
4772 case WS_READ_NILLABLE_VALUE:
4773 if (size != sizeof(val)) return E_INVALIDARG;
4774 *(INT64 *)ret = val;
4775 break;
4776
4777 case WS_READ_REQUIRED_POINTER:
4778 if (!found) return WS_E_INVALID_FORMAT;
4779 /* fall through */
4780
4781 case WS_READ_OPTIONAL_POINTER:
4782 case WS_READ_NILLABLE_POINTER:
4783 {
4784 INT64 *heap_val = NULL;
4785 if (size != sizeof(heap_val)) return E_INVALIDARG;
4786 if (found)
4787 {
4788 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
4789 *heap_val = val;
4790 }
4791 *(INT64 **)ret = heap_val;
4792 break;
4793 }
4794 default:
4795 FIXME( "read option %u not supported\n", option );
4796 return E_NOTIMPL;
4797 }
4798
4799 return S_OK;
4800 }
4801
4802 static HRESULT text_to_uint8( const WS_XML_TEXT *text, UINT64 *val )
4803 {
4804 HRESULT hr;
4805
4806 switch (text->textType)
4807 {
4808 case WS_XML_TEXT_TYPE_UTF8:
4809 {
4810 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
4811 hr = str_to_uint64( text_utf8->value.bytes, text_utf8->value.length, MAX_UINT8, val );
4812 break;
4813 }
4814 case WS_XML_TEXT_TYPE_UINT64:
4815 {
4816 const WS_XML_UINT64_TEXT *text_uint64 = (const WS_XML_UINT64_TEXT *)text;
4817 assert( text_uint64->value <= MAX_UINT8 );
4818 *val = text_uint64->value;
4819 hr = S_OK;
4820 break;
4821 }
4822 default:
4823 FIXME( "unhandled text type %u\n", text->textType );
4824 return E_NOTIMPL;
4825 }
4826
4827 return hr;
4828 }
4829
4830 static HRESULT read_type_uint8( struct reader *reader, WS_TYPE_MAPPING mapping,
4831 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
4832 const WS_UINT8_DESCRIPTION *desc, WS_READ_OPTION option,
4833 WS_HEAP *heap, void *ret, ULONG size )
4834 {
4835 const WS_XML_TEXT *text;
4836 HRESULT hr;
4837 UINT64 val = 0;
4838 BOOL found;
4839
4840 if (desc)
4841 {
4842 FIXME( "description not supported\n" );
4843 return E_NOTIMPL;
4844 }
4845 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
4846 if (found && (hr = text_to_uint8( text, &val )) != S_OK) return hr;
4847
4848 switch (option)
4849 {
4850 case WS_READ_REQUIRED_VALUE:
4851 if (!found) return WS_E_INVALID_FORMAT;
4852 /* fall through */
4853
4854 case WS_READ_NILLABLE_VALUE:
4855 if (size != sizeof(UINT8)) return E_INVALIDARG;
4856 *(UINT8 *)ret = val;
4857 break;
4858
4859 case WS_READ_REQUIRED_POINTER:
4860 if (!found) return WS_E_INVALID_FORMAT;
4861 /* fall through */
4862
4863 case WS_READ_OPTIONAL_POINTER:
4864 case WS_READ_NILLABLE_POINTER:
4865 {
4866 UINT8 *heap_val = NULL;
4867 if (size != sizeof(heap_val)) return E_INVALIDARG;
4868 if (found)
4869 {
4870 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
4871 *heap_val = val;
4872 }
4873 *(UINT8 **)ret = heap_val;
4874 break;
4875 }
4876 default:
4877 FIXME( "read option %u not supported\n", option );
4878 return E_NOTIMPL;
4879 }
4880
4881 return S_OK;
4882 }
4883
4884 static HRESULT text_to_uint16( const WS_XML_TEXT *text, UINT64 *val )
4885 {
4886 HRESULT hr;
4887
4888 switch (text->textType)
4889 {
4890 case WS_XML_TEXT_TYPE_UTF8:
4891 {
4892 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
4893 hr = str_to_uint64( text_utf8->value.bytes, text_utf8->value.length, MAX_UINT16, val );
4894 break;
4895 }
4896 case WS_XML_TEXT_TYPE_INT32:
4897 {
4898 const WS_XML_INT32_TEXT *text_int32 = (const WS_XML_INT32_TEXT *)text;
4899 assert( text_int32->value >= 0 );
4900 assert( text_int32->value <= MAX_UINT16 );
4901 *val = text_int32->value;
4902 hr = S_OK;
4903 break;
4904 }
4905 case WS_XML_TEXT_TYPE_UINT64:
4906 {
4907 const WS_XML_UINT64_TEXT *text_uint64 = (const WS_XML_UINT64_TEXT *)text;
4908 assert( text_uint64->value <= MAX_UINT16 );
4909 *val = text_uint64->value;
4910 hr = S_OK;
4911 break;
4912 }
4913 default:
4914 FIXME( "unhandled text type %u\n", text->textType );
4915 return E_NOTIMPL;
4916 }
4917
4918 return hr;
4919 }
4920
4921 static HRESULT read_type_uint16( struct reader *reader, WS_TYPE_MAPPING mapping,
4922 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
4923 const WS_UINT16_DESCRIPTION *desc, WS_READ_OPTION option,
4924 WS_HEAP *heap, void *ret, ULONG size )
4925 {
4926 const WS_XML_TEXT *text;
4927 HRESULT hr;
4928 UINT64 val = 0;
4929 BOOL found;
4930
4931 if (desc)
4932 {
4933 FIXME( "description not supported\n" );
4934 return E_NOTIMPL;
4935 }
4936 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
4937 if (found && (hr = text_to_uint16( text, &val )) != S_OK) return hr;
4938
4939 switch (option)
4940 {
4941 case WS_READ_REQUIRED_VALUE:
4942 if (!found) return WS_E_INVALID_FORMAT;
4943 /* fall through */
4944
4945 case WS_READ_NILLABLE_VALUE:
4946 if (size != sizeof(UINT16)) return E_INVALIDARG;
4947 *(UINT16 *)ret = val;
4948 break;
4949
4950 case WS_READ_REQUIRED_POINTER:
4951 if (!found) return WS_E_INVALID_FORMAT;
4952 /* fall through */
4953
4954 case WS_READ_OPTIONAL_POINTER:
4955 case WS_READ_NILLABLE_POINTER:
4956 {
4957 UINT16 *heap_val = NULL;
4958 if (size != sizeof(heap_val)) return E_INVALIDARG;
4959 if (found)
4960 {
4961 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
4962 *heap_val = val;
4963 }
4964 *(UINT16 **)ret = heap_val;
4965 break;
4966 }
4967 default:
4968 FIXME( "read option %u not supported\n", option );
4969 return E_NOTIMPL;
4970 }
4971
4972 return S_OK;
4973 }
4974
4975 static HRESULT text_to_uint32( const WS_XML_TEXT *text, UINT64 *val )
4976 {
4977 HRESULT hr;
4978
4979 switch (text->textType)
4980 {
4981 case WS_XML_TEXT_TYPE_UTF8:
4982 {
4983 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
4984 hr = str_to_uint64( text_utf8->value.bytes, text_utf8->value.length, MAX_UINT32, val );
4985 break;
4986 }
4987 case WS_XML_TEXT_TYPE_INT32:
4988 {
4989 const WS_XML_INT32_TEXT *text_int32 = (const WS_XML_INT32_TEXT *)text;
4990 assert( text_int32->value >= 0 );
4991 *val = text_int32->value;
4992 hr = S_OK;
4993 break;
4994 }
4995 case WS_XML_TEXT_TYPE_UINT64:
4996 {
4997 const WS_XML_UINT64_TEXT *text_uint64 = (const WS_XML_UINT64_TEXT *)text;
4998 assert( text_uint64->value <= MAX_UINT32 );
4999 *val = text_uint64->value;
5000 hr = S_OK;
5001 break;
5002 }
5003 default:
5004 FIXME( "unhandled text type %u\n", text->textType );
5005 return E_NOTIMPL;
5006 }
5007
5008 return hr;
5009 }
5010
5011 static HRESULT read_type_uint32( struct reader *reader, WS_TYPE_MAPPING mapping,
5012 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
5013 const WS_UINT32_DESCRIPTION *desc, WS_READ_OPTION option,
5014 WS_HEAP *heap, void *ret, ULONG size )
5015 {
5016 const WS_XML_TEXT *text;
5017 HRESULT hr;
5018 UINT64 val = 0;
5019 BOOL found;
5020
5021 if (desc)
5022 {
5023 FIXME( "description not supported\n" );
5024 return E_NOTIMPL;
5025 }
5026 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
5027 if (found && (hr = text_to_uint32( text, &val )) != S_OK) return hr;
5028
5029 switch (option)
5030 {
5031 case WS_READ_REQUIRED_VALUE:
5032 if (!found) return WS_E_INVALID_FORMAT;
5033 /* fall through */
5034
5035 case WS_READ_NILLABLE_VALUE:
5036 if (size != sizeof(UINT32)) return E_INVALIDARG;
5037 *(UINT32 *)ret = val;
5038 break;
5039
5040 case WS_READ_REQUIRED_POINTER:
5041 if (!found) return WS_E_INVALID_FORMAT;
5042 /* fall through */
5043
5044 case WS_READ_OPTIONAL_POINTER:
5045 case WS_READ_NILLABLE_POINTER:
5046 {
5047 UINT32 *heap_val = NULL;
5048 if (size != sizeof(heap_val)) return E_INVALIDARG;
5049 if (found)
5050 {
5051 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
5052 *heap_val = val;
5053 }
5054 *(UINT32 **)ret = heap_val;
5055 break;
5056 }
5057 default:
5058 FIXME( "read option %u not supported\n", option );
5059 return E_NOTIMPL;
5060 }
5061
5062 return S_OK;
5063 }
5064
5065 static HRESULT text_to_uint64( const WS_XML_TEXT *text, UINT64 *val )
5066 {
5067 HRESULT hr;
5068
5069 switch (text->textType)
5070 {
5071 case WS_XML_TEXT_TYPE_UTF8:
5072 {
5073 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
5074 hr = str_to_uint64( text_utf8->value.bytes, text_utf8->value.length, MAX_UINT64, val );
5075 break;
5076 }
5077 case WS_XML_TEXT_TYPE_UINT64:
5078 {
5079 const WS_XML_UINT64_TEXT *text_uint64 = (const WS_XML_UINT64_TEXT *)text;
5080 *val = text_uint64->value;
5081 hr = S_OK;
5082 break;
5083 }
5084 default:
5085 FIXME( "unhandled text type %u\n", text->textType );
5086 return E_NOTIMPL;
5087 }
5088
5089 return hr;
5090 }
5091
5092 static HRESULT read_type_uint64( struct reader *reader, WS_TYPE_MAPPING mapping,
5093 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
5094 const WS_UINT64_DESCRIPTION *desc, WS_READ_OPTION option,
5095 WS_HEAP *heap, void *ret, ULONG size )
5096 {
5097 const WS_XML_TEXT *text;
5098 HRESULT hr;
5099 UINT64 val = 0;
5100 BOOL found;
5101
5102 if (desc)
5103 {
5104 FIXME( "description not supported\n" );
5105 return E_NOTIMPL;
5106 }
5107 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
5108 if (found && (hr = text_to_uint64( text, &val )) != S_OK) return hr;
5109
5110 switch (option)
5111 {
5112 case WS_READ_REQUIRED_VALUE:
5113 if (!found) return WS_E_INVALID_FORMAT;
5114 /* fall through */
5115
5116 case WS_READ_NILLABLE_VALUE:
5117 if (size != sizeof(val)) return E_INVALIDARG;
5118 *(UINT64 *)ret = val;
5119 break;
5120
5121 case WS_READ_REQUIRED_POINTER:
5122 if (!found) return WS_E_INVALID_FORMAT;
5123 /* fall through */
5124
5125 case WS_READ_OPTIONAL_POINTER:
5126 case WS_READ_NILLABLE_POINTER:
5127 {
5128 UINT64 *heap_val = NULL;
5129 if (size != sizeof(heap_val)) return E_INVALIDARG;
5130 if (found)
5131 {
5132 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
5133 *heap_val = val;
5134 }
5135 *(UINT64 **)ret = heap_val;
5136 break;
5137 }
5138 default:
5139 FIXME( "read option %u not supported\n", option );
5140 return E_NOTIMPL;
5141 }
5142
5143 return S_OK;
5144 }
5145
5146 static HRESULT text_to_float( const WS_XML_TEXT *text, float *val )
5147 {
5148 HRESULT hr;
5149
5150 switch (text->textType)
5151 {
5152 case WS_XML_TEXT_TYPE_UTF8:
5153 {
5154 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
5155 hr = str_to_float( text_utf8->value.bytes, text_utf8->value.length, val );
5156 break;
5157 }
5158 case WS_XML_TEXT_TYPE_FLOAT:
5159 {
5160 const WS_XML_FLOAT_TEXT *text_float = (const WS_XML_FLOAT_TEXT *)text;
5161 *val = text_float->value;
5162 hr = S_OK;
5163 break;
5164 }
5165 default:
5166 FIXME( "unhandled text type %u\n", text->textType );
5167 return E_NOTIMPL;
5168 }
5169
5170 return hr;
5171 }
5172
5173 static HRESULT read_type_float( struct reader *reader, WS_TYPE_MAPPING mapping,
5174 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
5175 const WS_FLOAT_DESCRIPTION *desc, WS_READ_OPTION option,
5176 WS_HEAP *heap, void *ret, ULONG size )
5177 {
5178 const WS_XML_TEXT *text;
5179 HRESULT hr;
5180 float val = 0.0;
5181 BOOL found;
5182
5183 if (desc) FIXME( "ignoring description\n" );
5184
5185 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
5186 if (found && (hr = text_to_float( text, &val )) != S_OK) return hr;
5187
5188 switch (option)
5189 {
5190 case WS_READ_REQUIRED_VALUE:
5191 if (!found) return WS_E_INVALID_FORMAT;
5192 /* fall through */
5193
5194 case WS_READ_NILLABLE_VALUE:
5195 if (size != sizeof(val)) return E_INVALIDARG;
5196 *(float *)ret = val;
5197 break;
5198
5199 case WS_READ_REQUIRED_POINTER:
5200 if (!found) return WS_E_INVALID_FORMAT;
5201 /* fall through */
5202
5203 case WS_READ_OPTIONAL_POINTER:
5204 case WS_READ_NILLABLE_POINTER:
5205 {
5206 float *heap_val = NULL;
5207 if (size != sizeof(heap_val)) return E_INVALIDARG;
5208 if (found)
5209 {
5210 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
5211 *heap_val = val;
5212 }
5213 *(float **)ret = heap_val;
5214 break;
5215 }
5216 default:
5217 FIXME( "read option %u not supported\n", option );
5218 return E_NOTIMPL;
5219 }
5220
5221 return S_OK;
5222 }
5223
5224 static HRESULT text_to_double( const WS_XML_TEXT *text, double *val )
5225 {
5226 HRESULT hr;
5227
5228 switch (text->textType)
5229 {
5230 case WS_XML_TEXT_TYPE_UTF8:
5231 {
5232 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
5233 hr = str_to_double( text_utf8->value.bytes, text_utf8->value.length, val );
5234 break;
5235 }
5236 case WS_XML_TEXT_TYPE_DOUBLE:
5237 {
5238 const WS_XML_DOUBLE_TEXT *text_double = (const WS_XML_DOUBLE_TEXT *)text;
5239 *val = text_double->value;
5240 hr = S_OK;
5241 break;
5242 }
5243 default:
5244 FIXME( "unhandled text type %u\n", text->textType );
5245 return E_NOTIMPL;
5246 }
5247
5248 return hr;
5249 }
5250
5251 static HRESULT read_type_double( struct reader *reader, WS_TYPE_MAPPING mapping,
5252 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
5253 const WS_DOUBLE_DESCRIPTION *desc, WS_READ_OPTION option,
5254 WS_HEAP *heap, void *ret, ULONG size )
5255 {
5256 const WS_XML_TEXT *text;
5257 HRESULT hr;
5258 double val = 0.0;
5259 BOOL found;
5260
5261 if (desc) FIXME( "ignoring description\n" );
5262
5263 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
5264 if (found && (hr = text_to_double( text, &val )) != S_OK) return hr;
5265
5266 switch (option)
5267 {
5268 case WS_READ_REQUIRED_VALUE:
5269 if (!found) return WS_E_INVALID_FORMAT;
5270 /* fall through */
5271
5272 case WS_READ_NILLABLE_VALUE:
5273 if (size != sizeof(val)) return E_INVALIDARG;
5274 *(double *)ret = val;
5275 break;
5276
5277 case WS_READ_REQUIRED_POINTER:
5278 if (!found) return WS_E_INVALID_FORMAT;
5279 /* fall through */
5280
5281 case WS_READ_OPTIONAL_POINTER:
5282 case WS_READ_NILLABLE_POINTER:
5283 {
5284 double *heap_val = NULL;
5285 if (size != sizeof(heap_val)) return E_INVALIDARG;
5286 if (found)
5287 {
5288 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
5289 *heap_val = val;
5290 }
5291 *(double **)ret = heap_val;
5292 break;
5293 }
5294 default:
5295 FIXME( "read option %u not supported\n", option );
5296 return E_NOTIMPL;
5297 }
5298
5299 return S_OK;
5300 }
5301
5302 static HRESULT text_to_wsz( const WS_XML_TEXT *text, WS_HEAP *heap, WCHAR **ret )
5303 {
5304 const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text;
5305 int len;
5306
5307 assert( text->textType == WS_XML_TEXT_TYPE_UTF8 );
5308 len = MultiByteToWideChar( CP_UTF8, 0, (char *)utf8->value.bytes, utf8->value.length, NULL, 0 );
5309 if (!(*ret = ws_alloc( heap, (len + 1) * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
5310 MultiByteToWideChar( CP_UTF8, 0, (char *)utf8->value.bytes, utf8->value.length, *ret, len );
5311 (*ret)[len] = 0;
5312 return S_OK;
5313 }
5314
5315 static HRESULT read_type_wsz( struct reader *reader, WS_TYPE_MAPPING mapping,
5316 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
5317 const WS_WSZ_DESCRIPTION *desc, WS_READ_OPTION option,
5318 WS_HEAP *heap, WCHAR **ret, ULONG size )
5319 {
5320 const WS_XML_TEXT *text;
5321 HRESULT hr;
5322 WCHAR *str = NULL;
5323 BOOL found;
5324
5325 if (desc)
5326 {
5327 FIXME( "description not supported\n" );
5328 return E_NOTIMPL;
5329 }
5330 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
5331 if (found && (hr = text_to_wsz( text, heap, &str )) != S_OK) return hr;
5332
5333 switch (option)
5334 {
5335 case WS_READ_REQUIRED_POINTER:
5336 if (!str && !(str = ws_alloc_zero( heap, sizeof(*str) ))) return WS_E_QUOTA_EXCEEDED;
5337 /* fall through */
5338
5339 case WS_READ_OPTIONAL_POINTER:
5340 case WS_READ_NILLABLE_POINTER:
5341 if (size != sizeof(str)) return E_INVALIDARG;
5342 *ret = str;
5343 break;
5344
5345 default:
5346 FIXME( "read option %u not supported\n", option );
5347 return E_NOTIMPL;
5348 }
5349
5350 return S_OK;
5351 }
5352
5353 static HRESULT get_enum_value( const WS_XML_TEXT *text, const WS_ENUM_DESCRIPTION *desc, int *ret )
5354 {
5355 const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text;
5356 ULONG i;
5357
5358 assert( text->textType == WS_XML_TEXT_TYPE_UTF8 );
5359 for (i = 0; i < desc->valueCount; i++)
5360 {
5361 if (WsXmlStringEquals( &utf8->value, desc->values[i].name, NULL ) == S_OK)
5362 {
5363 *ret = desc->values[i].value;
5364 return S_OK;
5365 }
5366 }
5367 return WS_E_INVALID_FORMAT;
5368 }
5369
5370 static HRESULT read_type_enum( struct reader *reader, WS_TYPE_MAPPING mapping,
5371 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
5372 const WS_ENUM_DESCRIPTION *desc, WS_READ_OPTION option,
5373 WS_HEAP *heap, void *ret, ULONG size )
5374 {
5375 const WS_XML_TEXT *text;
5376 HRESULT hr;
5377 int val = 0;
5378 BOOL found;
5379
5380 if (!desc) return E_INVALIDARG;
5381
5382 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
5383 if (found && (hr = get_enum_value( text, desc, &val )) != S_OK) return hr;
5384
5385 switch (option)
5386 {
5387 case WS_READ_REQUIRED_VALUE:
5388 if (!found) return WS_E_INVALID_FORMAT;
5389 /* fall through */
5390
5391 case WS_READ_NILLABLE_VALUE:
5392 if (size != sizeof(val)) return E_INVALIDARG;
5393 *(int *)ret = val;
5394 break;
5395
5396 case WS_READ_REQUIRED_POINTER:
5397 if (!found) return WS_E_INVALID_FORMAT;
5398 /* fall through */
5399
5400 case WS_READ_OPTIONAL_POINTER:
5401 case WS_READ_NILLABLE_POINTER:
5402 {
5403 int *heap_val = NULL;
5404 if (size != sizeof(heap_val)) return E_INVALIDARG;
5405 if (found)
5406 {
5407 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
5408 *heap_val = val;
5409 }
5410 *(int **)ret = heap_val;
5411 break;
5412 }
5413 default:
5414 FIXME( "read option %u not supported\n", option );
5415 return E_NOTIMPL;
5416 }
5417
5418 return S_OK;
5419 }
5420
5421 static HRESULT text_to_datetime( const WS_XML_TEXT *text, WS_DATETIME *val )
5422 {
5423 HRESULT hr;
5424
5425 switch (text->textType)
5426 {
5427 case WS_XML_TEXT_TYPE_UTF8:
5428 {
5429 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
5430 hr = str_to_datetime( text_utf8->value.bytes, text_utf8->value.length, val );
5431 break;
5432 }
5433 case WS_XML_TEXT_TYPE_DATETIME:
5434 {
5435 const WS_XML_DATETIME_TEXT *text_datetime = (const WS_XML_DATETIME_TEXT *)text;
5436 *val = text_datetime->value;
5437 hr = S_OK;
5438 break;
5439 }
5440 default:
5441 FIXME( "unhandled text type %u\n", text->textType );
5442 return E_NOTIMPL;
5443 }
5444
5445 return hr;
5446 }
5447
5448 static HRESULT read_type_datetime( struct reader *reader, WS_TYPE_MAPPING mapping,
5449 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
5450 const WS_DATETIME_DESCRIPTION *desc, WS_READ_OPTION option,
5451 WS_HEAP *heap, void *ret, ULONG size )
5452 {
5453 const WS_XML_TEXT *text;
5454 HRESULT hr;
5455 WS_DATETIME val = {0, WS_DATETIME_FORMAT_UTC};
5456 BOOL found;
5457
5458 if (desc) FIXME( "ignoring description\n" );
5459
5460 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
5461 if (found && (hr = text_to_datetime( text, &val )) != S_OK) return hr;
5462
5463 switch (option)
5464 {
5465 case WS_READ_REQUIRED_VALUE:
5466 if (!found) return WS_E_INVALID_FORMAT;
5467 /* fall through */
5468
5469 case WS_READ_NILLABLE_VALUE:
5470 if (size != sizeof(val)) return E_INVALIDARG;
5471 *(WS_DATETIME *)ret = val;
5472 break;
5473
5474 case WS_READ_REQUIRED_POINTER:
5475 if (!found) return WS_E_INVALID_FORMAT;
5476 /* fall through */
5477
5478 case WS_READ_OPTIONAL_POINTER:
5479 case WS_READ_NILLABLE_POINTER:
5480 {
5481 WS_DATETIME *heap_val = NULL;
5482 if (size != sizeof(heap_val)) return E_INVALIDARG;
5483 if (found)
5484 {
5485 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
5486 *heap_val = val;
5487 }
5488 *(WS_DATETIME **)ret = heap_val;
5489 break;
5490 }
5491 default:
5492 FIXME( "read option %u not supported\n", option );
5493 return E_NOTIMPL;
5494 }
5495
5496 return S_OK;
5497 }
5498
5499 static HRESULT text_to_guid( const WS_XML_TEXT *text, GUID *val )
5500 {
5501 HRESULT hr;
5502
5503 switch (text->textType)
5504 {
5505 case WS_XML_TEXT_TYPE_UTF8:
5506 {
5507 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
5508 hr = str_to_guid( text_utf8->value.bytes, text_utf8->value.length, val );
5509 break;
5510 }
5511 case WS_XML_TEXT_TYPE_GUID:
5512 {
5513 const WS_XML_GUID_TEXT *text_guid = (const WS_XML_GUID_TEXT *)text;
5514 *val = text_guid->value;
5515 hr = S_OK;
5516 break;
5517 }
5518 default:
5519 FIXME( "unhandled text type %u\n", text->textType );
5520 return E_NOTIMPL;
5521 }
5522
5523 return hr;
5524 }
5525
5526 static HRESULT read_type_guid( struct reader *reader, WS_TYPE_MAPPING mapping,
5527 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
5528 const WS_GUID_DESCRIPTION *desc, WS_READ_OPTION option,
5529 WS_HEAP *heap, void *ret, ULONG size )
5530 {
5531 const WS_XML_TEXT *text;
5532 GUID val = {0};
5533 HRESULT hr;
5534 BOOL found;
5535
5536 if (desc) FIXME( "ignoring description\n" );
5537
5538 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
5539 if (found && (hr = text_to_guid( text, &val )) != S_OK) return hr;
5540
5541 switch (option)
5542 {
5543 case WS_READ_REQUIRED_VALUE:
5544 if (!found) return WS_E_INVALID_FORMAT;
5545 /* fall through */
5546
5547 case WS_READ_NILLABLE_VALUE:
5548 if (size != sizeof(val)) return E_INVALIDARG;
5549 *(GUID *)ret = val;
5550 break;
5551
5552 case WS_READ_REQUIRED_POINTER:
5553 if (!found) return WS_E_INVALID_FORMAT;
5554 /* fall through */
5555
5556 case WS_READ_OPTIONAL_POINTER:
5557 case WS_READ_NILLABLE_POINTER:
5558 {
5559 GUID *heap_val = NULL;
5560 if (size != sizeof(heap_val)) return E_INVALIDARG;
5561 if (found)
5562 {
5563 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
5564 *heap_val = val;
5565 }
5566 *(GUID **)ret = heap_val;
5567 break;
5568 }
5569 default:
5570 FIXME( "read option %u not supported\n", option );
5571 return E_NOTIMPL;
5572 }
5573
5574 return S_OK;
5575 }
5576
5577 static HRESULT text_to_unique_id( const WS_XML_TEXT *text, WS_HEAP *heap, WS_UNIQUE_ID *val )
5578 {
5579 HRESULT hr;
5580
5581 switch (text->textType)
5582 {
5583 case WS_XML_TEXT_TYPE_UTF8:
5584 {
5585 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
5586 hr = str_to_unique_id( text_utf8->value.bytes, text_utf8->value.length, heap, val );
5587 break;
5588 }
5589 case WS_XML_TEXT_TYPE_UNIQUE_ID:
5590 {
5591 const WS_XML_UNIQUE_ID_TEXT *text_unique_id = (const WS_XML_UNIQUE_ID_TEXT *)text;
5592 val->guid = text_unique_id->value;
5593 val->uri.length = 0;
5594 val->uri.chars = NULL;
5595 hr = S_OK;
5596 break;
5597 }
5598 default:
5599 FIXME( "unhandled text type %u\n", text->textType );
5600 return E_NOTIMPL;
5601 }
5602
5603 return hr;
5604 }
5605
5606 static HRESULT read_type_unique_id( struct reader *reader, WS_TYPE_MAPPING mapping,
5607 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
5608 const WS_UNIQUE_ID_DESCRIPTION *desc, WS_READ_OPTION option,
5609 WS_HEAP *heap, void *ret, ULONG size )
5610 {
5611 const WS_XML_TEXT *text;
5612 WS_UNIQUE_ID val = {{0}};
5613 HRESULT hr;
5614 BOOL found;
5615
5616 if (desc) FIXME( "ignoring description\n" );
5617
5618 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
5619 if (found && (hr = text_to_unique_id( text, heap, &val )) != S_OK) return hr;
5620
5621 switch (option)
5622 {
5623 case WS_READ_REQUIRED_VALUE:
5624 if (!found) return WS_E_INVALID_FORMAT;
5625 /* fall through */
5626
5627 case WS_READ_NILLABLE_VALUE:
5628 if (size != sizeof(val)) return E_INVALIDARG;
5629 *(WS_UNIQUE_ID *)ret = val;
5630 break;
5631
5632 case WS_READ_REQUIRED_POINTER:
5633 if (!found) return WS_E_INVALID_FORMAT;
5634 /* fall through */
5635
5636 case WS_READ_OPTIONAL_POINTER:
5637 case WS_READ_NILLABLE_POINTER:
5638 {
5639 WS_UNIQUE_ID *heap_val = NULL;
5640 if (size != sizeof(heap_val)) return E_INVALIDARG;
5641 if (found)
5642 {
5643 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
5644 *heap_val = val;
5645 }
5646 *(WS_UNIQUE_ID **)ret = heap_val;
5647 break;
5648 }
5649 default:
5650 FIXME( "read option %u not supported\n", option );
5651 return E_NOTIMPL;
5652 }
5653
5654 return S_OK;
5655 }
5656
5657 static HRESULT text_to_string( const WS_XML_TEXT *text, WS_HEAP *heap, WS_STRING *val )
5658 {
5659 HRESULT hr;
5660
5661 switch (text->textType)
5662 {
5663 case WS_XML_TEXT_TYPE_UTF8:
5664 {
5665 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
5666 hr = str_to_string( text_utf8->value.bytes, text_utf8->value.length, heap, val );
5667 break;
5668 }
5669 case WS_XML_TEXT_TYPE_UTF16:
5670 {
5671 const WS_XML_UTF16_TEXT *text_utf16 = (const WS_XML_UTF16_TEXT *)text;
5672 if (!(val->chars = ws_alloc( heap, text_utf16->byteCount ))) return WS_E_QUOTA_EXCEEDED;
5673 memcpy( val->chars, text_utf16->bytes, text_utf16->byteCount );
5674 val->length = text_utf16->byteCount / sizeof(WCHAR);
5675 hr = S_OK;
5676 break;
5677 }
5678 default:
5679 FIXME( "unhandled text type %u\n", text->textType );
5680 return E_NOTIMPL;
5681 }
5682
5683 return hr;
5684 }
5685
5686 static HRESULT read_type_string( struct reader *reader, WS_TYPE_MAPPING mapping,
5687 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
5688 const WS_STRING_DESCRIPTION *desc, WS_READ_OPTION option,
5689 WS_HEAP *heap, void *ret, ULONG size )
5690 {
5691 const WS_XML_TEXT *text;
5692 WS_STRING val = {0};
5693 HRESULT hr;
5694 BOOL found;
5695
5696 if (desc) FIXME( "ignoring description\n" );
5697
5698 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
5699 if (found && (hr = text_to_string( text, heap, &val )) != S_OK) return hr;
5700
5701 switch (option)
5702 {
5703 case WS_READ_REQUIRED_VALUE:
5704 case WS_READ_NILLABLE_VALUE:
5705 if (size != sizeof(val)) return E_INVALIDARG;
5706 *(WS_STRING *)ret = val;
5707 break;
5708
5709 case WS_READ_REQUIRED_POINTER:
5710 {
5711 WS_STRING *heap_val;
5712 if (size != sizeof(heap_val)) return E_INVALIDARG;
5713 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
5714 *heap_val = val;
5715 *(WS_STRING **)ret = heap_val;
5716 break;
5717 }
5718 case WS_READ_OPTIONAL_POINTER:
5719 case WS_READ_NILLABLE_POINTER:
5720 {
5721 WS_STRING *heap_val = NULL;
5722 if (size != sizeof(heap_val)) return E_INVALIDARG;
5723 if (found)
5724 {
5725 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
5726 *heap_val = val;
5727 }
5728 *(WS_STRING **)ret = heap_val;
5729 break;
5730 }
5731 default:
5732 FIXME( "read option %u not supported\n", option );
5733 return E_NOTIMPL;
5734 }
5735
5736 return S_OK;
5737 }
5738
5739 static HRESULT text_to_bytes( const WS_XML_TEXT *text, WS_HEAP *heap, WS_BYTES *val )
5740 {
5741 HRESULT hr;
5742
5743 switch (text->textType)
5744 {
5745 case WS_XML_TEXT_TYPE_UTF8:
5746 {
5747 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
5748 hr = str_to_bytes( text_utf8->value.bytes, text_utf8->value.length, heap, val );
5749 break;
5750 }
5751 case WS_XML_TEXT_TYPE_BASE64:
5752 {
5753 const WS_XML_BASE64_TEXT *text_base64 = (const WS_XML_BASE64_TEXT *)text;
5754 if (!(val->bytes = ws_alloc( heap, text_base64->length ))) return WS_E_QUOTA_EXCEEDED;
5755 memcpy( val->bytes, text_base64->bytes, text_base64->length );
5756 val->length = text_base64->length;
5757 hr = S_OK;
5758 break;
5759 }
5760 default:
5761 FIXME( "unhandled text type %u\n", text->textType );
5762 return E_NOTIMPL;
5763 }
5764
5765 return hr;
5766 }
5767
5768 static HRESULT read_type_bytes( struct reader *reader, WS_TYPE_MAPPING mapping,
5769 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
5770 const WS_BYTES_DESCRIPTION *desc, WS_READ_OPTION option,
5771 WS_HEAP *heap, void *ret, ULONG size )
5772 {
5773 const WS_XML_TEXT *text;
5774 WS_BYTES val = {0};
5775 HRESULT hr;
5776 BOOL found;
5777
5778 if (desc) FIXME( "ignoring description\n" );
5779
5780 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
5781 if (found && (hr = text_to_bytes( text, heap, &val )) != S_OK) return hr;
5782
5783 switch (option)
5784 {
5785 case WS_READ_REQUIRED_VALUE:
5786 case WS_READ_NILLABLE_VALUE:
5787 if (size != sizeof(val)) return E_INVALIDARG;
5788 *(WS_BYTES *)ret = val;
5789 break;
5790
5791 case WS_READ_REQUIRED_POINTER:
5792 {
5793 WS_BYTES *heap_val;
5794 if (size != sizeof(heap_val)) return E_INVALIDARG;
5795 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
5796 *heap_val = val;
5797 *(WS_BYTES **)ret = heap_val;
5798 break;
5799 }
5800 case WS_READ_OPTIONAL_POINTER:
5801 case WS_READ_NILLABLE_POINTER:
5802 {
5803 WS_BYTES *heap_val = NULL;
5804 if (size != sizeof(heap_val)) return E_INVALIDARG;
5805 if (found)
5806 {
5807 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
5808 *heap_val = val;
5809 }
5810 *(WS_BYTES **)ret = heap_val;
5811 break;
5812 }
5813 default:
5814 FIXME( "read option %u not supported\n", option );
5815 return E_NOTIMPL;
5816 }
5817
5818 return S_OK;
5819 }
5820
5821 static HRESULT text_to_xml_string( const WS_XML_TEXT *text, WS_HEAP *heap, WS_XML_STRING *val )
5822 {
5823 const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text;
5824 assert( text->textType == WS_XML_TEXT_TYPE_UTF8 );
5825 return str_to_xml_string( utf8->value.bytes, utf8->value.length, heap, val );
5826 }
5827
5828 static HRESULT read_type_xml_string( struct reader *reader, WS_TYPE_MAPPING mapping,
5829 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
5830 const WS_XML_STRING_DESCRIPTION *desc, WS_READ_OPTION option,
5831 WS_HEAP *heap, void *ret, ULONG size )
5832 {
5833 const WS_XML_TEXT *text;
5834 WS_XML_STRING val = {0};
5835 HRESULT hr;
5836 BOOL found;
5837
5838 if (desc) FIXME( "ignoring description\n" );
5839
5840 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
5841 if (found && (hr = text_to_xml_string( text, heap, &val )) != S_OK) return hr;
5842
5843 switch (option)
5844 {
5845 case WS_READ_REQUIRED_VALUE:
5846 case WS_READ_NILLABLE_VALUE:
5847 if (size != sizeof(val)) return E_INVALIDARG;
5848 *(WS_XML_STRING *)ret = val;
5849 break;
5850
5851 case WS_READ_REQUIRED_POINTER:
5852 {
5853 WS_XML_STRING *heap_val;
5854 if (size != sizeof(heap_val)) return E_INVALIDARG;
5855 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
5856 *heap_val = val;
5857 *(WS_XML_STRING **)ret = heap_val;
5858 break;
5859 }
5860 case WS_READ_OPTIONAL_POINTER:
5861 case WS_READ_NILLABLE_POINTER:
5862 {
5863 WS_XML_STRING *heap_val = NULL;
5864 if (size != sizeof(heap_val)) return E_INVALIDARG;
5865 if (found)
5866 {
5867 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
5868 *heap_val = val;
5869 }
5870 *(WS_XML_STRING **)ret = heap_val;
5871 break;
5872 }
5873 default:
5874 FIXME( "read option %u not supported\n", option );
5875 return E_NOTIMPL;
5876 }
5877
5878 return S_OK;
5879 }
5880
5881 static HRESULT text_to_qname( struct reader *reader, const WS_XML_TEXT *text, WS_HEAP *heap, WS_XML_QNAME *val )
5882 {
5883 HRESULT hr;
5884
5885 switch (text->textType)
5886 {
5887 case WS_XML_TEXT_TYPE_UTF8:
5888 {
5889 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
5890 hr = str_to_qname( reader, text_utf8->value.bytes, text_utf8->value.length, heap, NULL,
5891 &val->localName, &val->ns );
5892 break;
5893 }
5894 case WS_XML_TEXT_TYPE_QNAME:
5895 {
5896 const WS_XML_QNAME_TEXT *text_qname = (const WS_XML_QNAME_TEXT *)text;
5897 if ((hr = copy_xml_string( heap, text_qname->localName, &val->localName )) != S_OK) return hr;
5898 if ((hr = copy_xml_string( heap, text_qname->ns, &val->ns )) != S_OK)
5899 {
5900 ws_free( heap, val->localName.bytes, val->localName.length );
5901 return hr;
5902 }
5903 break;
5904 }
5905 default:
5906 FIXME( "unhandled text type %u\n", text->textType );
5907 return E_NOTIMPL;
5908 }
5909
5910 return hr;
5911 }
5912
5913 static HRESULT read_type_qname( struct reader *reader, WS_TYPE_MAPPING mapping,
5914 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
5915 const WS_XML_QNAME_DESCRIPTION *desc, WS_READ_OPTION option,
5916 WS_HEAP *heap, void *ret, ULONG size )
5917 {
5918 const WS_XML_TEXT *text;
5919 WS_XML_QNAME val = {{0}};
5920 HRESULT hr;
5921 BOOL found;
5922
5923 if (desc) FIXME( "ignoring description\n" );
5924
5925 if (node_type( reader->current ) != WS_XML_NODE_TYPE_ELEMENT) return WS_E_INVALID_FORMAT;
5926 if ((hr = read_startelement( reader )) != S_OK) return hr;
5927 if (node_type( reader->current ) != WS_XML_NODE_TYPE_TEXT) return WS_E_INVALID_FORMAT;
5928
5929 if ((hr = get_text( reader, mapping, localname, ns, &text, &found )) != S_OK) return hr;
5930 if (found && (hr = text_to_qname( reader, text, heap, &val )) != S_OK) return hr;
5931
5932 switch (option)
5933 {
5934 case WS_READ_REQUIRED_VALUE:
5935 if (!found) return WS_E_INVALID_FORMAT;
5936 /* fall through */
5937
5938 case WS_READ_NILLABLE_VALUE:
5939 if (size != sizeof(val)) return E_INVALIDARG;
5940 *(WS_XML_QNAME *)ret = val;
5941 break;
5942
5943 case WS_READ_REQUIRED_POINTER:
5944 if (!found) return WS_E_INVALID_FORMAT;
5945 /* fall through */
5946
5947 case WS_READ_OPTIONAL_POINTER:
5948 case WS_READ_NILLABLE_POINTER:
5949 {
5950 WS_XML_QNAME *heap_val = NULL;
5951 if (size != sizeof(heap_val)) return E_INVALIDARG;
5952 if (found)
5953 {
5954 if (!(heap_val = ws_alloc( heap, sizeof(*heap_val) ))) return WS_E_QUOTA_EXCEEDED;
5955 *heap_val = val;
5956 }
5957 *(WS_XML_QNAME **)ret = heap_val;
5958 break;
5959 }
5960 default:
5961 FIXME( "read option %u not supported\n", option );
5962 return E_NOTIMPL;
5963 }
5964
5965 return S_OK;
5966 }
5967
5968 static BOOL is_empty_text_node( const struct node *node )
5969 {
5970 const WS_XML_TEXT_NODE *text = (const WS_XML_TEXT_NODE *)node;
5971
5972 if (node_type( node ) != WS_XML_NODE_TYPE_TEXT) return FALSE;
5973 switch (text->text->textType)
5974 {
5975 case WS_XML_TEXT_TYPE_UTF8:
5976 {
5977 ULONG i;
5978 const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text->text;
5979 for (i = 0; i < utf8->value.length; i++) if (!read_isspace( utf8->value.bytes[i] )) return FALSE;
5980 return TRUE;
5981 }
5982 case WS_XML_TEXT_TYPE_BASE64:
5983 {
5984 const WS_XML_BASE64_TEXT *base64 = (const WS_XML_BASE64_TEXT *)text->text;
5985 return !base64->length;
5986 }
5987 case WS_XML_TEXT_TYPE_BOOL:
5988 case WS_XML_TEXT_TYPE_INT32:
5989 case WS_XML_TEXT_TYPE_INT64:
5990 case WS_XML_TEXT_TYPE_UINT64:
5991 case WS_XML_TEXT_TYPE_FLOAT:
5992 case WS_XML_TEXT_TYPE_DOUBLE:
5993 case WS_XML_TEXT_TYPE_DECIMAL:
5994 case WS_XML_TEXT_TYPE_GUID:
5995 case WS_XML_TEXT_TYPE_UNIQUE_ID:
5996 case WS_XML_TEXT_TYPE_DATETIME:
5997 return FALSE;
5998
5999 default:
6000 ERR( "unhandled text type %u\n", text->text->textType );
6001 return FALSE;
6002 }
6003 }
6004
6005 /* skips comment and empty text nodes */
6006 static HRESULT read_type_next_node( struct reader *reader )
6007 {
6008 for (;;)
6009 {
6010 HRESULT hr;
6011 WS_XML_NODE_TYPE type;
6012
6013 if ((hr = read_next_node( reader )) != S_OK) return hr;
6014 type = node_type( reader->current );
6015 if (type == WS_XML_NODE_TYPE_COMMENT ||
6016 (type == WS_XML_NODE_TYPE_TEXT && is_empty_text_node( reader->current ))) continue;
6017 return S_OK;
6018 }
6019 }
6020
6021 static HRESULT read_type_next_element_node( struct reader *reader, const WS_XML_STRING *localname,
6022 const WS_XML_STRING *ns )
6023 {
6024 struct node *node;
6025 ULONG attr;
6026 HRESULT hr;
6027
6028 if (!localname) return S_OK; /* assume reader is already correctly positioned */
6029 if (reader->current == reader->last)
6030 {
6031 BOOL found;
6032 if ((hr = read_to_startelement( reader, &found )) != S_OK) return hr;
6033 if (!found) return WS_E_INVALID_FORMAT;
6034 }
6035 if (match_element( reader->current, localname, ns )) return S_OK;
6036
6037 node = reader->current;
6038 attr = reader->current_attr;
6039
6040 if ((hr = read_type_next_node( reader )) != S_OK) return hr;
6041 if (match_element( reader->current, localname, ns )) return S_OK;
6042
6043 reader->current = node;
6044 reader->current_attr = attr;
6045
6046 return WS_E_INVALID_FORMAT;
6047 }
6048
6049 ULONG get_type_size( WS_TYPE type, const void *desc )
6050 {
6051 switch (type)
6052 {
6053 case WS_INT8_TYPE:
6054 case WS_UINT8_TYPE:
6055 return sizeof(INT8);
6056
6057 case WS_INT16_TYPE:
6058 case WS_UINT16_TYPE:
6059 return sizeof(INT16);
6060
6061 case WS_BOOL_TYPE:
6062 case WS_INT32_TYPE:
6063 case WS_UINT32_TYPE:
6064 case WS_ENUM_TYPE:
6065 return sizeof(INT32);
6066
6067 case WS_INT64_TYPE:
6068 case WS_UINT64_TYPE:
6069 return sizeof(INT64);
6070
6071 case WS_FLOAT_TYPE:
6072 return sizeof(float);
6073
6074 case WS_DOUBLE_TYPE:
6075 return sizeof(double);
6076
6077 case WS_DATETIME_TYPE:
6078 return sizeof(WS_DATETIME);
6079
6080 case WS_GUID_TYPE:
6081 return sizeof(GUID);
6082
6083 case WS_UNIQUE_ID_TYPE:
6084 return sizeof(WS_UNIQUE_ID);
6085
6086 case WS_STRING_TYPE:
6087 return sizeof(WS_STRING);
6088
6089 case WS_WSZ_TYPE:
6090 return sizeof(WCHAR *);
6091
6092 case WS_BYTES_TYPE:
6093 return sizeof(WS_BYTES);
6094
6095 case WS_XML_STRING_TYPE:
6096 return sizeof(WS_XML_STRING);
6097
6098 case WS_XML_QNAME_TYPE:
6099 return sizeof(WS_XML_QNAME);
6100
6101 case WS_DESCRIPTION_TYPE:
6102 return sizeof(WS_STRUCT_DESCRIPTION *);
6103
6104 case WS_STRUCT_TYPE:
6105 {
6106 const WS_STRUCT_DESCRIPTION *desc_struct = desc;
6107 return desc_struct->size;
6108 }
6109 case WS_UNION_TYPE:
6110 {
6111 const WS_UNION_DESCRIPTION *desc_union = desc;
6112 return desc_union->size;
6113 }
6114 default:
6115 ERR( "unhandled type %u\n", type );
6116 return 0;
6117 }
6118 }
6119
6120 static WS_READ_OPTION get_field_read_option( WS_TYPE type, ULONG options )
6121 {
6122 if (options & WS_FIELD_POINTER)
6123 {
6124 if (options & WS_FIELD_NILLABLE) return WS_READ_NILLABLE_POINTER;
6125 if (options & WS_FIELD_OPTIONAL) return WS_READ_OPTIONAL_POINTER;
6126 return WS_READ_REQUIRED_POINTER;
6127 }
6128
6129 switch (type)
6130 {
6131 case WS_BOOL_TYPE:
6132 case WS_INT8_TYPE:
6133 case WS_INT16_TYPE:
6134 case WS_INT32_TYPE:
6135 case WS_INT64_TYPE:
6136 case WS_UINT8_TYPE:
6137 case WS_UINT16_TYPE:
6138 case WS_UINT32_TYPE:
6139 case WS_UINT64_TYPE:
6140 case WS_FLOAT_TYPE:
6141 case WS_DOUBLE_TYPE:
6142 case WS_DATETIME_TYPE:
6143 case WS_GUID_TYPE:
6144 case WS_UNIQUE_ID_TYPE:
6145 case WS_STRING_TYPE:
6146 case WS_BYTES_TYPE:
6147 case WS_XML_STRING_TYPE:
6148 case WS_XML_QNAME_TYPE:
6149 case WS_STRUCT_TYPE:
6150 case WS_ENUM_TYPE:
6151 case WS_UNION_TYPE:
6152 if (options & (WS_FIELD_OPTIONAL|WS_FIELD_NILLABLE)) return WS_READ_NILLABLE_VALUE;
6153 return WS_READ_REQUIRED_VALUE;
6154
6155 case WS_WSZ_TYPE:
6156 case WS_DESCRIPTION_TYPE:
6157 if (options & WS_FIELD_NILLABLE) return WS_READ_NILLABLE_POINTER;
6158 if (options & WS_FIELD_OPTIONAL) return WS_READ_OPTIONAL_POINTER;
6159 return WS_READ_REQUIRED_POINTER;
6160
6161 default:
6162 FIXME( "unhandled type %u\n", type );
6163 return 0;
6164 }
6165 }
6166
6167 static HRESULT read_type_field( struct reader *, const WS_FIELD_DESCRIPTION *, WS_HEAP *, char *, ULONG );
6168
6169 static HRESULT read_type_union( struct reader *reader, const WS_UNION_DESCRIPTION *desc, WS_READ_OPTION option,
6170 WS_HEAP *heap, void *ret, ULONG size )
6171 {
6172 BOOL found = FALSE;
6173 HRESULT hr;
6174 ULONG i;
6175
6176 switch (option)
6177 {
6178 case WS_READ_REQUIRED_VALUE:
6179 case WS_READ_NILLABLE_VALUE:
6180 if (size != desc->size) return E_INVALIDARG;
6181 break;
6182
6183 default:
6184 return E_INVALIDARG;
6185 }
6186
6187 if ((hr = read_type_next_node( reader )) != S_OK) return hr;
6188 if (node_type( reader->current ) != WS_XML_NODE_TYPE_ELEMENT) return WS_E_INVALID_FORMAT;
6189 for (i = 0; i < desc->fieldCount; i++)
6190 {
6191 if ((found = match_element( reader->current, desc->fields[i]->field.localName, desc->fields[i]->field.ns )))
6192 break;
6193 }
6194
6195 if (!found) *(int *)((char *)ret + desc->enumOffset) = desc->noneEnumValue;
6196 else
6197 {
6198 ULONG offset = desc->fields[i]->field.offset;
6199 if ((hr = read_type_field( reader, &desc->fields[i]->field, heap, ret, offset )) == S_OK)
6200 *(int *)((char *)ret + desc->enumOffset) = desc->fields[i]->value;
6201 }
6202
6203 switch (option)
6204 {
6205 case WS_READ_NILLABLE_VALUE:
6206 if (!found) move_to_parent_element( &reader->current );
6207 break;
6208
6209 case WS_READ_REQUIRED_VALUE:
6210 if (!found) hr = WS_E_INVALID_FORMAT;
6211 break;
6212
6213 default:
6214 return E_INVALIDARG;
6215 }
6216
6217 return hr;
6218 }
6219
6220 static HRESULT read_type( struct reader *, WS_TYPE_MAPPING, WS_TYPE, const WS_XML_STRING *,
6221 const WS_XML_STRING *, const void *, WS_READ_OPTION, WS_HEAP *,
6222 void *, ULONG );
6223
6224 static HRESULT read_type_array( struct reader *reader, const WS_FIELD_DESCRIPTION *desc, WS_HEAP *heap,
6225 void **ret, ULONG *count )
6226 {
6227 HRESULT hr;
6228 ULONG item_size, nb_items = 0, nb_allocated = 1, offset = 0;
6229 WS_READ_OPTION option;
6230 char *buf;
6231
6232 if (!(option = get_field_read_option( desc->type, desc->options ))) return E_INVALIDARG;
6233
6234 /* wrapper element */
6235 if (desc->localName && ((hr = read_type_next_element_node( reader, desc->localName, desc->ns )) != S_OK))
6236 return hr;
6237
6238 if (option == WS_READ_REQUIRED_VALUE || option == WS_READ_NILLABLE_VALUE)
6239 item_size = get_type_size( desc->type, desc->typeDescription );
6240 else
6241 item_size = sizeof(void *);
6242
6243 if (!(buf = ws_alloc_zero( heap, item_size ))) return WS_E_QUOTA_EXCEEDED;
6244 for (;;)
6245 {
6246 if (nb_items >= nb_allocated)
6247 {
6248 SIZE_T old_size = nb_allocated * item_size, new_size = old_size * 2;
6249 if (!(buf = ws_realloc_zero( heap, buf, old_size, new_size ))) return WS_E_QUOTA_EXCEEDED;
6250 nb_allocated *= 2;
6251 }
6252
6253 if (desc->type == WS_UNION_TYPE)
6254 hr = read_type_union( reader, desc->typeDescription, option, heap, buf + offset, item_size );
6255 else
6256 hr = read_type( reader, WS_ELEMENT_TYPE_MAPPING, desc->type, desc->itemLocalName, desc->itemNs,
6257 desc->typeDescription, option, heap, buf + offset, item_size );
6258
6259 if (hr == WS_E_INVALID_FORMAT) break;
6260 if (hr != S_OK)
6261 {
6262 ws_free( heap, buf, nb_allocated * item_size );
6263 return hr;
6264 }
6265 offset += item_size;
6266 nb_items++;
6267 }
6268
6269 if (desc->localName && ((hr = read_type_next_node( reader )) != S_OK)) return hr;
6270
6271 if (desc->itemRange && (nb_items < desc->itemRange->minItemCount || nb_items > desc->itemRange->maxItemCount))
6272 {
6273 TRACE( "number of items %u out of range (%u-%u)\n", nb_items, desc->itemRange->minItemCount,
6274 desc->itemRange->maxItemCount );
6275 ws_free( heap, buf, nb_allocated * item_size );
6276 return WS_E_INVALID_FORMAT;
6277 }
6278
6279 *count = nb_items;
6280 *ret = buf;
6281
6282 return S_OK;
6283 }
6284
6285 static HRESULT read_type_text( struct reader *reader, const WS_FIELD_DESCRIPTION *desc,
6286 WS_READ_OPTION option, WS_HEAP *heap, void *ret, ULONG size )
6287 {
6288 HRESULT hr;
6289 if (reader->current == reader->last)
6290 {
6291 BOOL found;
6292 if ((hr = read_to_startelement( reader, &found )) != S_OK) return hr;
6293 if (!found) return WS_E_INVALID_FORMAT;
6294 }
6295 if ((hr = read_next_node( reader )) != S_OK) return hr;
6296 if (node_type( reader->current ) != WS_XML_NODE_TYPE_TEXT) return WS_E_INVALID_FORMAT;
6297
6298 return read_type( reader, WS_ANY_ELEMENT_TYPE_MAPPING, desc->type, NULL, NULL,
6299 desc->typeDescription, option, heap, ret, size );
6300 }
6301
6302 static HRESULT read_type_field( struct reader *reader, const WS_FIELD_DESCRIPTION *desc, WS_HEAP *heap, char *buf,
6303 ULONG offset )
6304 {
6305 char *ptr;
6306 WS_READ_OPTION option;
6307 ULONG size;
6308 HRESULT hr;
6309
6310 if (!desc) return E_INVALIDARG;
6311 if (desc->options & ~(WS_FIELD_POINTER|WS_FIELD_OPTIONAL|WS_FIELD_NILLABLE|WS_FIELD_NILLABLE_ITEM))
6312 {
6313 FIXME( "options %08x not supported\n", desc->options );
6314 return E_NOTIMPL;
6315 }
6316 if (!(option = get_field_read_option( desc->type, desc->options ))) return E_INVALIDARG;
6317
6318 if (option == WS_READ_REQUIRED_VALUE || option == WS_READ_NILLABLE_VALUE)
6319 size = get_type_size( desc->type, desc->typeDescription );
6320 else
6321 size = sizeof(void *);
6322
6323 ptr = buf + offset;
6324 switch (desc->mapping)
6325 {
6326 case WS_TYPE_ATTRIBUTE_FIELD_MAPPING:
6327 FIXME( "WS_TYPE_ATTRIBUTE_FIELD_MAPPING not supported\n" );
6328 return S_OK;
6329
6330 case WS_ATTRIBUTE_FIELD_MAPPING:
6331 hr = read_type( reader, WS_ATTRIBUTE_TYPE_MAPPING, desc->type, desc->localName, desc->ns,
6332 desc->typeDescription, option, heap, ptr, size );
6333 break;
6334
6335 case WS_ELEMENT_FIELD_MAPPING:
6336 hr = read_type( reader, WS_ELEMENT_TYPE_MAPPING, desc->type, desc->localName, desc->ns,
6337 desc->typeDescription, option, heap, ptr, size );
6338 break;
6339
6340 case WS_ELEMENT_CHOICE_FIELD_MAPPING:
6341 if (desc->type != WS_UNION_TYPE || !desc->typeDescription ||
6342 (desc->options & (WS_FIELD_POINTER|WS_FIELD_NILLABLE))) return E_INVALIDARG;
6343 hr = read_type_union( reader, desc->typeDescription, option, heap, ptr, size );
6344 break;
6345
6346 case WS_REPEATING_ELEMENT_FIELD_MAPPING:
6347 case WS_REPEATING_ELEMENT_CHOICE_FIELD_MAPPING:
6348 {
6349 ULONG count;
6350 hr = read_type_array( reader, desc, heap, (void **)ptr, &count );
6351 if (hr == S_OK) *(ULONG *)(buf + desc->countOffset) = count;
6352 break;
6353 }
6354 case WS_TEXT_FIELD_MAPPING:
6355 hr = read_type_text( reader, desc, option, heap, ptr, size );
6356 break;
6357
6358 default:
6359 FIXME( "unhandled field mapping %u\n", desc->mapping );
6360 return E_NOTIMPL;
6361 }
6362
6363 if (hr == WS_E_INVALID_FORMAT)
6364 {
6365 switch (option)
6366 {
6367 case WS_READ_REQUIRED_VALUE:
6368 case WS_READ_REQUIRED_POINTER:
6369 return WS_E_INVALID_FORMAT;
6370
6371 case WS_READ_NILLABLE_VALUE:
6372 if (desc->defaultValue) memcpy( ptr, desc->defaultValue->value, desc->defaultValue->valueSize );
6373 return S_OK;
6374
6375 case WS_READ_OPTIONAL_POINTER:
6376 case WS_READ_NILLABLE_POINTER:
6377 *(void **)ptr = NULL;
6378 return S_OK;
6379
6380 default:
6381 ERR( "unhandled option %u\n", option );
6382 return E_NOTIMPL;
6383 }
6384 }
6385
6386 return hr;
6387 }
6388
6389 static HRESULT read_type_struct( struct reader *reader, WS_TYPE_MAPPING mapping, const WS_XML_STRING *localname,
6390 const WS_XML_STRING *ns, const WS_STRUCT_DESCRIPTION *desc, WS_READ_OPTION option,
6391 WS_HEAP *heap, void *ret, ULONG size )
6392 {
6393 ULONG i, offset;
6394 HRESULT hr;
6395 char *buf;
6396
6397 if (!desc) return E_INVALIDARG;
6398 if (desc->structOptions & ~WS_STRUCT_IGNORE_TRAILING_ELEMENT_CONTENT)
6399 {
6400 FIXME( "struct options %08x not supported\n",
6401 desc->structOptions & ~WS_STRUCT_IGNORE_TRAILING_ELEMENT_CONTENT );
6402 }
6403
6404 switch (option)
6405 {
6406 case WS_READ_REQUIRED_POINTER:
6407 case WS_READ_OPTIONAL_POINTER:
6408 case WS_READ_NILLABLE_POINTER:
6409 if (size != sizeof(void *)) return E_INVALIDARG;
6410 if (!(buf = ws_alloc_zero( heap, desc->size ))) return WS_E_QUOTA_EXCEEDED;
6411 break;
6412
6413 case WS_READ_REQUIRED_VALUE:
6414 case WS_READ_NILLABLE_VALUE:
6415 if (size != desc->size) return E_INVALIDARG;
6416 buf = ret;
6417 break;
6418
6419 default:
6420 FIXME( "unhandled read option %u\n", option );
6421 return E_NOTIMPL;
6422 }
6423
6424 for (i = 0; i < desc->fieldCount; i++)
6425 {
6426 offset = desc->fields[i]->offset;
6427 if ((hr = read_type_field( reader, desc->fields[i], heap, buf, offset )) != S_OK) break;
6428 }
6429
6430 switch (option)
6431 {
6432 case WS_READ_REQUIRED_POINTER:
6433 if (hr != S_OK)
6434 {
6435 ws_free( heap, buf, desc->size );
6436 return hr;
6437 }
6438 *(char **)ret = buf;
6439 break;
6440
6441 case WS_READ_OPTIONAL_POINTER:
6442 case WS_READ_NILLABLE_POINTER:
6443 if (is_nil_value( buf, desc->size ))
6444 {
6445 ws_free( heap, buf, desc->size );
6446 buf = NULL;
6447 }
6448 *(char **)ret = buf;
6449 break;
6450
6451 case WS_READ_REQUIRED_VALUE:
6452 case WS_READ_NILLABLE_VALUE:
6453 if (hr != S_OK) return hr;
6454 break;
6455
6456 default:
6457 ERR( "unhandled read option %u\n", option );
6458 return E_NOTIMPL;
6459 }
6460
6461 if (desc->structOptions & WS_STRUCT_IGNORE_TRAILING_ELEMENT_CONTENT)
6462 {
6463 struct node *parent = find_parent( reader );
6464 parent->flags |= NODE_FLAG_IGNORE_TRAILING_ELEMENT_CONTENT;
6465 }
6466 return S_OK;
6467 }
6468
6469 static HRESULT start_mapping( struct reader *reader, WS_TYPE_MAPPING mapping, const WS_XML_STRING *localname,
6470 const WS_XML_STRING *ns )
6471 {
6472 switch (mapping)
6473 {
6474 case WS_ELEMENT_TYPE_MAPPING:
6475 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
6476 return read_type_next_element_node( reader, localname, ns );
6477
6478 case WS_ANY_ELEMENT_TYPE_MAPPING:
6479 case WS_ATTRIBUTE_TYPE_MAPPING:
6480 return S_OK;
6481
6482 default:
6483 FIXME( "unhandled mapping %u\n", mapping );
6484 return E_NOTIMPL;
6485 }
6486 }
6487
6488 static HRESULT read_type_endelement_node( struct reader *reader )
6489 {
6490 const struct node *parent = find_parent( reader );
6491 HRESULT hr;
6492
6493 for (;;)
6494 {
6495 if ((hr = read_type_next_node( reader )) != S_OK) return hr;
6496 if (node_type( reader->current ) == WS_XML_NODE_TYPE_END_ELEMENT && reader->current->parent == parent)
6497 {
6498 return S_OK;
6499 }
6500 if (read_end_of_data( reader ) || !(parent->flags & NODE_FLAG_IGNORE_TRAILING_ELEMENT_CONTENT)) break;
6501 }
6502
6503 return WS_E_INVALID_FORMAT;
6504 }
6505
6506 static HRESULT end_mapping( struct reader *reader, WS_TYPE_MAPPING mapping )
6507 {
6508 switch (mapping)
6509 {
6510 case WS_ELEMENT_TYPE_MAPPING:
6511 return read_type_endelement_node( reader );
6512
6513 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
6514 return read_type_next_node( reader );
6515
6516 case WS_ATTRIBUTE_TYPE_MAPPING:
6517 default:
6518 return S_OK;
6519 }
6520 }
6521
6522 static BOOL is_true_text( const WS_XML_TEXT *text )
6523 {
6524 switch (text->textType)
6525 {
6526 case WS_XML_TEXT_TYPE_UTF8:
6527 {
6528 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
6529 if (text_utf8->value.length == 4 && !memcmp( text_utf8->value.bytes, "true", 4 )) return TRUE;
6530 return FALSE;
6531 }
6532 case WS_XML_TEXT_TYPE_BOOL:
6533 {
6534 const WS_XML_BOOL_TEXT *text_bool = (const WS_XML_BOOL_TEXT *)text;
6535 return text_bool->value;
6536 }
6537 default:
6538 ERR( "unhandled text type %u\n", text->textType );
6539 return FALSE;
6540 }
6541 }
6542
6543 static HRESULT is_nil_element( const WS_XML_ELEMENT_NODE *elem )
6544 {
6545 static const WS_XML_STRING localname = {3, (BYTE *)"nil"};
6546 static const WS_XML_STRING ns = {41, (BYTE *)"http://www.w3.org/2001/XMLSchema-instance"};
6547 ULONG i;
6548
6549 for (i = 0; i < elem->attributeCount; i++)
6550 {
6551 if (elem->attributes[i]->isXmlNs) continue;
6552 if (WsXmlStringEquals( elem->attributes[i]->localName, &localname, NULL ) == S_OK &&
6553 WsXmlStringEquals( elem->attributes[i]->ns, &ns, NULL ) == S_OK &&
6554 is_true_text( elem->attributes[i]->value )) return TRUE;
6555 }
6556 return FALSE;
6557 }
6558
6559 static HRESULT read_type( struct reader *reader, WS_TYPE_MAPPING mapping, WS_TYPE type,
6560 const WS_XML_STRING *localname, const WS_XML_STRING *ns, const void *desc,
6561 WS_READ_OPTION option, WS_HEAP *heap, void *value, ULONG size )
6562 {
6563 HRESULT hr;
6564
6565 if ((hr = start_mapping( reader, mapping, localname, ns )) != S_OK) return hr;
6566
6567 if (mapping == WS_ELEMENT_TYPE_MAPPING && is_nil_element( &reader->current->hdr ))
6568 {
6569 if (option != WS_READ_NILLABLE_POINTER && option != WS_READ_NILLABLE_VALUE) return WS_E_INVALID_FORMAT;
6570 return end_mapping( reader, mapping );
6571 }
6572
6573 switch (type)
6574 {
6575 case WS_BOOL_TYPE:
6576 if ((hr = read_type_bool( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6577 return hr;
6578 break;
6579
6580 case WS_INT8_TYPE:
6581 if ((hr = read_type_int8( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6582 return hr;
6583 break;
6584
6585 case WS_INT16_TYPE:
6586 if ((hr = read_type_int16( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6587 return hr;
6588 break;
6589
6590 case WS_INT32_TYPE:
6591 if ((hr = read_type_int32( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6592 return hr;
6593 break;
6594
6595 case WS_INT64_TYPE:
6596 if ((hr = read_type_int64( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6597 return hr;
6598 break;
6599
6600 case WS_UINT8_TYPE:
6601 if ((hr = read_type_uint8( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6602 return hr;
6603 break;
6604
6605 case WS_UINT16_TYPE:
6606 if ((hr = read_type_uint16( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6607 return hr;
6608 break;
6609
6610 case WS_UINT32_TYPE:
6611 if ((hr = read_type_uint32( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6612 return hr;
6613 break;
6614
6615 case WS_UINT64_TYPE:
6616 if ((hr = read_type_uint64( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6617 return hr;
6618 break;
6619
6620 case WS_FLOAT_TYPE:
6621 if ((hr = read_type_float( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6622 return hr;
6623 break;
6624
6625 case WS_DOUBLE_TYPE:
6626 if ((hr = read_type_double( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6627 return hr;
6628 break;
6629
6630 case WS_DATETIME_TYPE:
6631 if ((hr = read_type_datetime( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6632 return hr;
6633 break;
6634
6635 case WS_GUID_TYPE:
6636 if ((hr = read_type_guid( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6637 return hr;
6638 break;
6639
6640 case WS_UNIQUE_ID_TYPE:
6641 if ((hr = read_type_unique_id( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6642 return hr;
6643 break;
6644
6645 case WS_STRING_TYPE:
6646 if ((hr = read_type_string( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6647 return hr;
6648 break;
6649
6650 case WS_WSZ_TYPE:
6651 if ((hr = read_type_wsz( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6652 return hr;
6653 break;
6654
6655 case WS_BYTES_TYPE:
6656 if ((hr = read_type_bytes( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6657 return hr;
6658 break;
6659
6660 case WS_XML_STRING_TYPE:
6661 if ((hr = read_type_xml_string( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6662 return hr;
6663 break;
6664
6665 case WS_XML_QNAME_TYPE:
6666 if ((hr = read_type_qname( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6667 return hr;
6668 break;
6669
6670 case WS_STRUCT_TYPE:
6671 if ((hr = read_type_struct( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6672 return hr;
6673 break;
6674
6675 case WS_ENUM_TYPE:
6676 if ((hr = read_type_enum( reader, mapping, localname, ns, desc, option, heap, value, size )) != S_OK)
6677 return hr;
6678 break;
6679
6680 default:
6681 FIXME( "type %u not supported\n", type );
6682 return E_NOTIMPL;
6683 }
6684
6685 return end_mapping( reader, mapping );
6686 }
6687
6688 /**************************************************************************
6689 * WsReadType [webservices.@]
6690 */
6691 HRESULT WINAPI WsReadType( WS_XML_READER *handle, WS_TYPE_MAPPING mapping, WS_TYPE type,
6692 const void *desc, WS_READ_OPTION option, WS_HEAP *heap, void *value,
6693 ULONG size, WS_ERROR *error )
6694 {
6695 struct reader *reader = (struct reader *)handle;
6696 HRESULT hr;
6697
6698 TRACE( "%p %u %u %p %u %p %p %u %p\n", handle, mapping, type, desc, option, heap, value,
6699 size, error );
6700 if (error) FIXME( "ignoring error parameter\n" );
6701
6702 if (!reader || !value) return E_INVALIDARG;
6703
6704 EnterCriticalSection( &reader->cs );
6705
6706 if (reader->magic != READER_MAGIC)
6707 {
6708 LeaveCriticalSection( &reader->cs );
6709 return E_INVALIDARG;
6710 }
6711
6712 if ((hr = read_type( reader, mapping, type, NULL, NULL, desc, option, heap, value, size )) != S_OK)
6713 {
6714 LeaveCriticalSection( &reader->cs );
6715 return hr;
6716 }
6717
6718 switch (mapping)
6719 {
6720 case WS_ELEMENT_TYPE_MAPPING:
6721 hr = read_node( reader );
6722 break;
6723
6724 default:
6725 break;
6726 }
6727
6728 if (hr == S_OK && !read_end_of_data( reader )) hr = WS_E_INVALID_FORMAT;
6729
6730 LeaveCriticalSection( &reader->cs );
6731 return hr;
6732 }
6733
6734 HRESULT read_header( WS_XML_READER *handle, const WS_XML_STRING *localname, const WS_XML_STRING *ns,
6735 WS_TYPE type, const void *desc, WS_READ_OPTION option, WS_HEAP *heap, void *value,
6736 ULONG size )
6737 {
6738 struct reader *reader = (struct reader *)handle;
6739 HRESULT hr;
6740
6741 EnterCriticalSection( &reader->cs );
6742
6743 if (reader->magic != READER_MAGIC)
6744 {
6745 LeaveCriticalSection( &reader->cs );
6746 return E_INVALIDARG;
6747 }
6748
6749 hr = read_type( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, type, localname, ns, desc, option, heap,
6750 value, size );
6751
6752 LeaveCriticalSection( &reader->cs );
6753 return hr;
6754 }
6755
6756 /**************************************************************************
6757 * WsReadElement [webservices.@]
6758 */
6759 HRESULT WINAPI WsReadElement( WS_XML_READER *handle, const WS_ELEMENT_DESCRIPTION *desc,
6760 WS_READ_OPTION option, WS_HEAP *heap, void *value, ULONG size,
6761 WS_ERROR *error )
6762 {
6763 struct reader *reader = (struct reader *)handle;
6764 HRESULT hr;
6765
6766 TRACE( "%p %p %u %p %p %u %p\n", handle, desc, option, heap, value, size, error );
6767 if (error) FIXME( "ignoring error parameter\n" );
6768
6769 if (!reader || !desc || !value) return E_INVALIDARG;
6770
6771 EnterCriticalSection( &reader->cs );
6772
6773 if (reader->magic != READER_MAGIC)
6774 {
6775 LeaveCriticalSection( &reader->cs );
6776 return E_INVALIDARG;
6777 }
6778
6779 hr = read_type( reader, WS_ELEMENT_TYPE_MAPPING, desc->type, desc->elementLocalName,
6780 desc->elementNs, desc->typeDescription, option, heap, value, size );
6781
6782 LeaveCriticalSection( &reader->cs );
6783 return hr;
6784 }
6785
6786 /**************************************************************************
6787 * WsReadValue [webservices.@]
6788 */
6789 HRESULT WINAPI WsReadValue( WS_XML_READER *handle, WS_VALUE_TYPE value_type, void *value, ULONG size,
6790 WS_ERROR *error )
6791 {
6792 struct reader *reader = (struct reader *)handle;
6793 WS_TYPE type = map_value_type( value_type );
6794 HRESULT hr;
6795
6796 TRACE( "%p %u %p %u %p\n", handle, type, value, size, error );
6797 if (error) FIXME( "ignoring error parameter\n" );
6798
6799 if (!reader || !value || type == ~0u) return E_INVALIDARG;
6800
6801 EnterCriticalSection( &reader->cs );
6802
6803 if (reader->magic != READER_MAGIC)
6804 {
6805 LeaveCriticalSection( &reader->cs );
6806 return E_INVALIDARG;
6807 }
6808
6809 hr = read_type( reader, WS_ELEMENT_TYPE_MAPPING, type, NULL, NULL, NULL, WS_READ_REQUIRED_VALUE,
6810 NULL, value, size );
6811
6812 LeaveCriticalSection( &reader->cs );
6813 return hr;
6814 }
6815
6816 /**************************************************************************
6817 * WsReadAttribute [webservices.@]
6818 */
6819 HRESULT WINAPI WsReadAttribute( WS_XML_READER *handle, const WS_ATTRIBUTE_DESCRIPTION *desc,
6820 WS_READ_OPTION option, WS_HEAP *heap, void *value, ULONG size,
6821 WS_ERROR *error )
6822 {
6823 struct reader *reader = (struct reader *)handle;
6824 HRESULT hr;
6825
6826 TRACE( "%p %p %u %p %p %u %p\n", handle, desc, option, heap, value, size, error );
6827 if (error) FIXME( "ignoring error parameter\n" );
6828
6829 if (!reader || !desc || !value) return E_INVALIDARG;
6830
6831 EnterCriticalSection( &reader->cs );
6832
6833 if (reader->magic != READER_MAGIC)
6834 {
6835 LeaveCriticalSection( &reader->cs );
6836 return E_INVALIDARG;
6837 }
6838
6839 if (!reader->input_type)
6840 {
6841 LeaveCriticalSection( &reader->cs );
6842 return WS_E_INVALID_OPERATION;
6843 }
6844
6845 hr = read_type( reader, WS_ATTRIBUTE_TYPE_MAPPING, desc->type, desc->attributeLocalName,
6846 desc->attributeNs, desc->typeDescription, option, heap, value, size );
6847
6848 LeaveCriticalSection( &reader->cs );
6849 return hr;
6850 }
6851
6852 static inline BOOL is_utf8( const unsigned char *data, ULONG size, ULONG *offset )
6853 {
6854 static const char bom[] = {0xef,0xbb,0xbf};
6855 const unsigned char *p = data;
6856
6857 return (size >= sizeof(bom) && !memcmp( p, bom, sizeof(bom) ) && (*offset = sizeof(bom))) ||
6858 (size > 2 && !(*offset = 0));
6859 }
6860
6861 static inline BOOL is_utf16le( const unsigned char *data, ULONG size, ULONG *offset )
6862 {
6863 static const char bom[] = {0xff,0xfe};
6864 const unsigned char *p = data;
6865
6866 return (size >= sizeof(bom) && !memcmp( p, bom, sizeof(bom) ) && (*offset = sizeof(bom))) ||
6867 (size >= 4 && p[0] == '<' && !p[1] && !(*offset = 0));
6868 }
6869
6870 static WS_CHARSET detect_charset( const unsigned char *data, ULONG size, ULONG *offset )
6871 {
6872 WS_CHARSET ret = 0;
6873
6874 /* FIXME: parse xml declaration */
6875
6876 if (is_utf16le( data, size, offset )) ret = WS_CHARSET_UTF16LE;
6877 else if (is_utf8( data, size, offset )) ret = WS_CHARSET_UTF8;
6878 else
6879 {
6880 FIXME( "charset not recognized\n" );
6881 return 0;
6882 }
6883
6884 TRACE( "detected charset %u\n", ret );
6885 return ret;
6886 }
6887
6888 static void set_input_buffer( struct reader *reader, struct xmlbuf *buf, const unsigned char *data, ULONG size )
6889 {
6890 reader->input_type = WS_XML_READER_INPUT_TYPE_BUFFER;
6891 reader->input_buf = buf;
6892 reader->input_data = data;
6893 reader->input_size = size;
6894
6895 reader->read_size = reader->input_size;
6896 reader->read_pos = 0;
6897 reader->read_bufptr = reader->input_data;
6898
6899 reader->text_conv_offset = 0;
6900 }
6901
6902 /**************************************************************************
6903 * WsSetInput [webservices.@]
6904 */
6905 HRESULT WINAPI WsSetInput( WS_XML_READER *handle, const WS_XML_READER_ENCODING *encoding,
6906 const WS_XML_READER_INPUT *input, const WS_XML_READER_PROPERTY *properties,
6907 ULONG count, WS_ERROR *error )
6908 {
6909 struct reader *reader = (struct reader *)handle;
6910 struct node *node;
6911 ULONG i, offset = 0;
6912 HRESULT hr;
6913
6914 TRACE( "%p %p %p %p %u %p\n", handle, encoding, input, properties, count, error );
6915 if (error) FIXME( "ignoring error parameter\n" );
6916
6917 if (!reader) return E_INVALIDARG;
6918
6919 EnterCriticalSection( &reader->cs );
6920
6921 if (reader->magic != READER_MAGIC)
6922 {
6923 LeaveCriticalSection( &reader->cs );
6924 return E_INVALIDARG;
6925 }
6926
6927 for (i = 0; i < count; i++)
6928 {
6929 hr = prop_set( reader->prop, reader->prop_count, properties[i].id, properties[i].value,
6930 properties[i].valueSize );
6931 if (hr != S_OK) goto done;
6932 }
6933
6934 if ((hr = init_reader( reader )) != S_OK) goto done;
6935
6936 switch (encoding->encodingType)
6937 {
6938 case WS_XML_READER_ENCODING_TYPE_TEXT:
6939 {
6940 WS_XML_READER_TEXT_ENCODING *text = (WS_XML_READER_TEXT_ENCODING *)encoding;
6941 WS_XML_READER_BUFFER_INPUT *buf = (WS_XML_READER_BUFFER_INPUT *)input;
6942
6943 if (input->inputType != WS_XML_READER_INPUT_TYPE_BUFFER)
6944 {
6945 FIXME( "charset detection on input type %u not supported\n", input->inputType );
6946 hr = E_NOTIMPL;
6947 goto done;
6948 }
6949
6950 if (text->charSet != WS_CHARSET_AUTO) reader->input_charset = text->charSet;
6951 else reader->input_charset = detect_charset( buf->encodedData, buf->encodedDataSize, &offset );
6952
6953 reader->input_enc = WS_XML_READER_ENCODING_TYPE_TEXT;
6954 break;
6955 }
6956 case WS_XML_READER_ENCODING_TYPE_BINARY:
6957 {
6958 WS_XML_READER_BINARY_ENCODING *bin = (WS_XML_READER_BINARY_ENCODING *)encoding;
6959 reader->input_enc = WS_XML_READER_ENCODING_TYPE_BINARY;
6960 reader->input_charset = 0;
6961 reader->dict_static = bin->staticDictionary ? bin->staticDictionary : &dict_builtin_static.dict;
6962 reader->dict = bin->dynamicDictionary ? bin->dynamicDictionary : &dict_builtin.dict;
6963 break;
6964 }
6965 default:
6966 FIXME( "encoding type %u not supported\n", encoding->encodingType );
6967 hr = E_NOTIMPL;
6968 goto done;
6969 }
6970
6971 switch (input->inputType)
6972 {
6973 case WS_XML_READER_INPUT_TYPE_BUFFER:
6974 {
6975 WS_XML_READER_BUFFER_INPUT *buf = (WS_XML_READER_BUFFER_INPUT *)input;
6976 set_input_buffer( reader, NULL, (const unsigned char *)buf->encodedData + offset,
6977 buf->encodedDataSize - offset );
6978 break;
6979 }
6980 default:
6981 FIXME( "input type %u not supported\n", input->inputType );
6982 hr = E_NOTIMPL;
6983 goto done;
6984 }
6985
6986 if (!(node = alloc_node( WS_XML_NODE_TYPE_BOF ))) hr = E_OUTOFMEMORY;
6987 else read_insert_bof( reader, node );
6988
6989 done:
6990 LeaveCriticalSection( &reader->cs );
6991 return hr;
6992 }
6993
6994 /**************************************************************************
6995 * WsSetInputToBuffer [webservices.@]
6996 */
6997 HRESULT WINAPI WsSetInputToBuffer( WS_XML_READER *handle, WS_XML_BUFFER *buffer,
6998 const WS_XML_READER_PROPERTY *properties, ULONG count,
6999 WS_ERROR *error )
7000 {
7001 struct reader *reader = (struct reader *)handle;
7002 struct xmlbuf *xmlbuf = (struct xmlbuf *)buffer;
7003 struct node *node;
7004 HRESULT hr;
7005 ULONG i;
7006
7007 TRACE( "%p %p %p %u %p\n", handle, buffer, properties, count, error );
7008 if (error) FIXME( "ignoring error parameter\n" );
7009
7010 if (!reader || !xmlbuf) return E_INVALIDARG;
7011
7012 EnterCriticalSection( &reader->cs );
7013
7014 if (reader->magic != READER_MAGIC)
7015 {
7016 LeaveCriticalSection( &reader->cs );
7017 return E_INVALIDARG;
7018 }
7019
7020 for (i = 0; i < count; i++)
7021 {
7022 hr = prop_set( reader->prop, reader->prop_count, properties[i].id, properties[i].value,
7023 properties[i].valueSize );
7024 if (hr != S_OK) goto done;
7025 }
7026
7027 if ((hr = init_reader( reader )) != S_OK) goto done;
7028
7029 reader->input_enc = xmlbuf->encoding;
7030 reader->input_charset = xmlbuf->charset;
7031 reader->dict_static = xmlbuf->dict_static;
7032 reader->dict = xmlbuf->dict;
7033 set_input_buffer( reader, xmlbuf, xmlbuf->bytes.bytes, xmlbuf->bytes.length );
7034
7035 if (!(node = alloc_node( WS_XML_NODE_TYPE_BOF ))) hr = E_OUTOFMEMORY;
7036 else read_insert_bof( reader, node );
7037
7038 done:
7039 LeaveCriticalSection( &reader->cs );
7040 return hr;
7041 }
7042
7043 /**************************************************************************
7044 * WsGetReaderPosition [webservices.@]
7045 */
7046 HRESULT WINAPI WsGetReaderPosition( WS_XML_READER *handle, WS_XML_NODE_POSITION *pos, WS_ERROR *error )
7047 {
7048 struct reader *reader = (struct reader *)handle;
7049
7050 TRACE( "%p %p %p\n", handle, pos, error );
7051 if (error) FIXME( "ignoring error parameter\n" );
7052
7053 if (!reader || !pos) return E_INVALIDARG;
7054
7055 EnterCriticalSection( &reader->cs );
7056
7057 if (reader->magic != READER_MAGIC)
7058 {
7059 LeaveCriticalSection( &reader->cs );
7060 return E_INVALIDARG;
7061 }
7062
7063 if (!reader->input_buf)
7064 {
7065 LeaveCriticalSection( &reader->cs );
7066 return WS_E_INVALID_OPERATION;
7067 }
7068
7069 pos->buffer = (WS_XML_BUFFER *)reader->input_buf;
7070 pos->node = reader->current;
7071
7072 LeaveCriticalSection( &reader->cs );
7073 return S_OK;
7074 }
7075
7076 /**************************************************************************
7077 * WsSetReaderPosition [webservices.@]
7078 */
7079 HRESULT WINAPI WsSetReaderPosition( WS_XML_READER *handle, const WS_XML_NODE_POSITION *pos, WS_ERROR *error )
7080 {
7081 struct reader *reader = (struct reader *)handle;
7082
7083 TRACE( "%p %p %p\n", handle, pos, error );
7084 if (error) FIXME( "ignoring error parameter\n" );
7085
7086 if (!reader || !pos) return E_INVALIDARG;
7087
7088 EnterCriticalSection( &reader->cs );
7089
7090 if (reader->magic != READER_MAGIC || (struct xmlbuf *)pos->buffer != reader->input_buf)
7091 {
7092 LeaveCriticalSection( &reader->cs );
7093 return E_INVALIDARG;
7094 }
7095
7096 if (!reader->input_buf)
7097 {
7098 LeaveCriticalSection( &reader->cs );
7099 return WS_E_INVALID_OPERATION;
7100 }
7101
7102 reader->current = pos->node;
7103
7104 LeaveCriticalSection( &reader->cs );
7105 return S_OK;
7106 }
7107
7108 static HRESULT utf8_to_base64( const WS_XML_UTF8_TEXT *utf8, WS_XML_BASE64_TEXT *base64 )
7109 {
7110 if (utf8->value.length % 4) return WS_E_INVALID_FORMAT;
7111 if (!(base64->bytes = heap_alloc( utf8->value.length * 3 / 4 ))) return E_OUTOFMEMORY;
7112 base64->length = decode_base64( utf8->value.bytes, utf8->value.length, base64->bytes );
7113 return S_OK;
7114 }
7115
7116 /**************************************************************************
7117 * WsReadBytes [webservices.@]
7118 */
7119 HRESULT WINAPI WsReadBytes( WS_XML_READER *handle, void *bytes, ULONG max_count, ULONG *count, WS_ERROR *error )
7120 {
7121 struct reader *reader = (struct reader *)handle;
7122 HRESULT hr;
7123
7124 TRACE( "%p %p %u %p %p\n", handle, bytes, max_count, count, error );
7125 if (error) FIXME( "ignoring error parameter\n" );
7126
7127 if (!reader) return E_INVALIDARG;
7128
7129 EnterCriticalSection( &reader->cs );
7130
7131 if (reader->magic != READER_MAGIC)
7132 {
7133 LeaveCriticalSection( &reader->cs );
7134 return E_INVALIDARG;
7135 }
7136
7137 if (!reader->input_type)
7138 {
7139 LeaveCriticalSection( &reader->cs );
7140 return WS_E_INVALID_OPERATION;
7141 }
7142
7143 if (!count)
7144 {
7145 LeaveCriticalSection( &reader->cs );
7146 return E_INVALIDARG;
7147 }
7148
7149 *count = 0;
7150 if (node_type( reader->current ) == WS_XML_NODE_TYPE_TEXT && bytes)
7151 {
7152 const WS_XML_TEXT_NODE *text = (const WS_XML_TEXT_NODE *)reader->current;
7153 WS_XML_BASE64_TEXT base64;
7154
7155 if ((hr = utf8_to_base64( (const WS_XML_UTF8_TEXT *)text->text, &base64 )) != S_OK)
7156 {
7157 LeaveCriticalSection( &reader->cs );
7158 return hr;
7159 }
7160 if (reader->text_conv_offset == base64.length)
7161 {
7162 heap_free( base64.bytes );
7163 hr = read_node( reader );
7164 LeaveCriticalSection( &reader->cs );
7165 return hr;
7166 }
7167 *count = min( base64.length - reader->text_conv_offset, max_count );
7168 memcpy( bytes, base64.bytes + reader->text_conv_offset, *count );
7169 reader->text_conv_offset += *count;
7170 heap_free( base64.bytes );
7171 }
7172
7173 LeaveCriticalSection( &reader->cs );
7174 return S_OK;
7175 }
7176
7177 static HRESULT utf8_to_utf16( const WS_XML_UTF8_TEXT *utf8, WS_XML_UTF16_TEXT *utf16 )
7178 {
7179 int len = MultiByteToWideChar( CP_UTF8, 0, (char *)utf8->value.bytes, utf8->value.length, NULL, 0 );
7180 if (!(utf16->bytes = heap_alloc( len * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
7181 MultiByteToWideChar( CP_UTF8, 0, (char *)utf8->value.bytes, utf8->value.length, (WCHAR *)utf16->bytes, len );
7182 utf16->byteCount = len * sizeof(WCHAR);
7183 return S_OK;
7184 }
7185
7186 /**************************************************************************
7187 * WsReadChars [webservices.@]
7188 */
7189 HRESULT WINAPI WsReadChars( WS_XML_READER *handle, WCHAR *chars, ULONG max_count, ULONG *count, WS_ERROR *error )
7190 {
7191 struct reader *reader = (struct reader *)handle;
7192
7193 TRACE( "%p %p %u %p %p\n", handle, chars, max_count, count, error );
7194 if (error) FIXME( "ignoring error parameter\n" );
7195
7196 if (!reader) return E_INVALIDARG;
7197
7198 EnterCriticalSection( &reader->cs );
7199
7200 if (reader->magic != READER_MAGIC)
7201 {
7202 LeaveCriticalSection( &reader->cs );
7203 return E_INVALIDARG;
7204 }
7205
7206 if (!reader->input_type)
7207 {
7208 LeaveCriticalSection( &reader->cs );
7209 return WS_E_INVALID_OPERATION;
7210 }
7211
7212 if (!count)
7213 {
7214 LeaveCriticalSection( &reader->cs );
7215 return E_INVALIDARG;
7216 }
7217
7218 *count = 0;
7219 if (node_type( reader->current ) == WS_XML_NODE_TYPE_TEXT && chars)
7220 {
7221 const WS_XML_TEXT_NODE *text = (const WS_XML_TEXT_NODE *)reader->current;
7222 WS_XML_UTF16_TEXT utf16;
7223 HRESULT hr;
7224
7225 if ((hr = utf8_to_utf16( (const WS_XML_UTF8_TEXT *)text->text, &utf16 )) != S_OK)
7226 {
7227 LeaveCriticalSection( &reader->cs );
7228 return hr;
7229 }
7230 if (reader->text_conv_offset == utf16.byteCount / sizeof(WCHAR))
7231 {
7232 heap_free( utf16.bytes );
7233 hr = read_node( reader );
7234 LeaveCriticalSection( &reader->cs );
7235 return hr;
7236 }
7237 *count = min( utf16.byteCount / sizeof(WCHAR) - reader->text_conv_offset, max_count );
7238 memcpy( chars, utf16.bytes + reader->text_conv_offset * sizeof(WCHAR), *count * sizeof(WCHAR) );
7239 reader->text_conv_offset += *count;
7240 heap_free( utf16.bytes );
7241 }
7242
7243 LeaveCriticalSection( &reader->cs );
7244 return S_OK;
7245 }
7246
7247 /**************************************************************************
7248 * WsReadCharsUtf8 [webservices.@]
7249 */
7250 HRESULT WINAPI WsReadCharsUtf8( WS_XML_READER *handle, BYTE *bytes, ULONG max_count, ULONG *count, WS_ERROR *error )
7251 {
7252 struct reader *reader = (struct reader *)handle;
7253 HRESULT hr;
7254
7255 TRACE( "%p %p %u %p %p\n", handle, bytes, max_count, count, error );
7256 if (error) FIXME( "ignoring error parameter\n" );
7257
7258 if (!reader) return E_INVALIDARG;
7259
7260 EnterCriticalSection( &reader->cs );
7261
7262 if (reader->magic != READER_MAGIC)
7263 {
7264 LeaveCriticalSection( &reader->cs );
7265 return E_INVALIDARG;
7266 }
7267
7268 if (!reader->input_type)
7269 {
7270 LeaveCriticalSection( &reader->cs );
7271 return WS_E_INVALID_OPERATION;
7272 }
7273
7274 if (!count)
7275 {
7276 LeaveCriticalSection( &reader->cs );
7277 return E_INVALIDARG;
7278 }
7279
7280 *count = 0;
7281 if (node_type( reader->current ) == WS_XML_NODE_TYPE_TEXT && bytes)
7282 {
7283 const WS_XML_TEXT_NODE *text = (const WS_XML_TEXT_NODE *)reader->current;
7284 const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text->text;
7285
7286 if (reader->text_conv_offset == utf8->value.length)
7287 {
7288 hr = read_node( reader );
7289 LeaveCriticalSection( &reader->cs );
7290 return hr;
7291 }
7292 *count = min( utf8->value.length - reader->text_conv_offset, max_count );
7293 memcpy( bytes, utf8->value.bytes + reader->text_conv_offset, *count );
7294 reader->text_conv_offset += *count;
7295 }
7296
7297 LeaveCriticalSection( &reader->cs );
7298 return S_OK;
7299 }
7300
7301 static HRESULT move_to_element( struct reader *reader )
7302 {
7303 HRESULT hr;
7304 if (node_type( reader->current ) == WS_XML_NODE_TYPE_BOF &&
7305 (hr = read_move_to( reader, WS_MOVE_TO_CHILD_NODE, NULL )) != S_OK) return hr;
7306 if (node_type( reader->current ) != WS_XML_NODE_TYPE_ELEMENT) return E_FAIL;
7307 return S_OK;
7308 }
7309
7310 static HRESULT copy_tree( struct reader *reader, WS_XML_WRITER *writer )
7311 {
7312 const struct node *node, *parent;
7313 BOOL done = FALSE;
7314 HRESULT hr;
7315
7316 if ((hr = move_to_element( reader )) != S_OK) return hr;
7317 parent = reader->current;
7318 for (;;)
7319 {
7320 node = reader->current;
7321 if ((hr = WsWriteNode( writer, (const WS_XML_NODE *)node, NULL )) != S_OK) break;
7322 if (node_type( node ) == WS_XML_NODE_TYPE_END_ELEMENT && node->parent == parent) done = TRUE;
7323 if ((hr = read_next_node( reader )) != S_OK || done) break;
7324 }
7325 return hr;
7326 }
7327
7328 /**************************************************************************
7329 * WsReadXmlBuffer [webservices.@]
7330 */
7331 HRESULT WINAPI WsReadXmlBuffer( WS_XML_READER *handle, WS_HEAP *heap, WS_XML_BUFFER **ret, WS_ERROR *error )
7332 {
7333 struct reader *reader = (struct reader *)handle;
7334 WS_XML_WRITER *writer = NULL;
7335 WS_XML_BUFFER *buffer;
7336 HRESULT hr;
7337
7338 TRACE( "%p %p %p %p\n", handle, heap, ret, error );
7339 if (error) FIXME( "ignoring error parameter\n" );
7340
7341 if (!reader || !heap) return E_INVALIDARG;
7342 if (!ret) return E_FAIL;
7343
7344 EnterCriticalSection( &reader->cs );
7345
7346 if (reader->magic != READER_MAGIC)
7347 {
7348 LeaveCriticalSection( &reader->cs );
7349 return E_INVALIDARG;
7350 }
7351
7352 if (!reader->input_type)
7353 {
7354 LeaveCriticalSection( &reader->cs );
7355 return WS_E_INVALID_OPERATION;
7356 }
7357
7358 if ((hr = WsCreateWriter( NULL, 0, &writer, NULL )) != S_OK) goto done;
7359 if ((hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL )) != S_OK) goto done;
7360 if ((hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL )) != S_OK) goto done;
7361 if ((hr = copy_tree( reader, writer )) == S_OK) *ret = buffer;
7362
7363 done:
7364 if (hr != S_OK) free_xmlbuf( (struct xmlbuf *)buffer );
7365 WsFreeWriter( writer );
7366 LeaveCriticalSection( &reader->cs );
7367 return hr;
7368 }
7369
7370 HRESULT create_header_buffer( WS_XML_READER *handle, WS_HEAP *heap, WS_XML_BUFFER **ret )
7371 {
7372 struct reader *reader = (struct reader *)handle;
7373 HRESULT hr = WS_E_QUOTA_EXCEEDED;
7374 struct xmlbuf *xmlbuf;
7375
7376 EnterCriticalSection( &reader->cs );
7377
7378 if (reader->magic != READER_MAGIC)
7379 {
7380 LeaveCriticalSection( &reader->cs );
7381 return E_INVALIDARG;
7382 }
7383
7384 if ((xmlbuf = alloc_xmlbuf( heap, reader->read_pos, reader->input_enc, reader->input_charset,
7385 reader->dict_static, reader->dict )))
7386 {
7387 memcpy( xmlbuf->bytes.bytes, reader->read_bufptr, reader->read_pos );
7388 xmlbuf->bytes.length = reader->read_pos;
7389 *ret = (WS_XML_BUFFER *)xmlbuf;
7390 hr = S_OK;
7391 }
7392
7393 LeaveCriticalSection( &reader->cs );
7394 return hr;
7395 }
7396
7397 HRESULT get_param_desc( const WS_STRUCT_DESCRIPTION *desc, USHORT index, const WS_FIELD_DESCRIPTION **ret )
7398 {
7399 if (index >= desc->fieldCount) return E_INVALIDARG;
7400 *ret = desc->fields[index];
7401 return S_OK;
7402 }
7403
7404 static ULONG get_field_size( const WS_FIELD_DESCRIPTION *desc )
7405 {
7406 if (desc->options & WS_FIELD_POINTER) return sizeof(void *);
7407 return get_type_size( desc->type, desc->typeDescription );
7408 }
7409
7410 static HRESULT read_param( struct reader *reader, const WS_FIELD_DESCRIPTION *desc, WS_HEAP *heap, void *ret )
7411 {
7412 if (!ret && !(ret = ws_alloc_zero( heap, get_field_size(desc) ))) return WS_E_QUOTA_EXCEEDED;
7413 return read_type_field( reader, desc, heap, ret, 0 );
7414 }
7415
7416 static HRESULT read_param_array( struct reader *reader, const WS_FIELD_DESCRIPTION *desc, WS_HEAP *heap,
7417 void **ret, ULONG *count )
7418 {
7419 if (!ret && !(ret = ws_alloc_zero( heap, sizeof(void **) ))) return WS_E_QUOTA_EXCEEDED;
7420 return read_type_array( reader, desc, heap, ret, count );
7421 }
7422
7423 static void set_array_len( const WS_PARAMETER_DESCRIPTION *params, ULONG count, ULONG index, ULONG len,
7424 const void **args )
7425 {
7426 ULONG i, *ptr;
7427 for (i = 0; i < count; i++)
7428 {
7429 if (params[i].outputMessageIndex != index || params[i].parameterType != WS_PARAMETER_TYPE_ARRAY_COUNT)
7430 continue;
7431 if ((ptr = *(ULONG **)args[i])) *ptr = len;
7432 break;
7433 }
7434 }
7435
7436 HRESULT read_output_params( WS_XML_READER *handle, WS_HEAP *heap, const WS_ELEMENT_DESCRIPTION *desc,
7437 const WS_PARAMETER_DESCRIPTION *params, ULONG count, const void **args )
7438 {
7439 struct reader *reader = (struct reader *)handle;
7440 const WS_STRUCT_DESCRIPTION *desc_struct;
7441 const WS_FIELD_DESCRIPTION *desc_field;
7442 ULONG i, len;
7443 HRESULT hr;
7444
7445 if (desc->type != WS_STRUCT_TYPE || !(desc_struct = desc->typeDescription)) return E_INVALIDARG;
7446
7447 EnterCriticalSection( &reader->cs );
7448
7449 if (reader->magic != READER_MAGIC)
7450 {
7451 LeaveCriticalSection( &reader->cs );
7452 return E_INVALIDARG;
7453 }
7454
7455 if ((hr = start_mapping( reader, WS_ELEMENT_TYPE_MAPPING, desc->elementLocalName, desc->elementNs )) != S_OK)
7456 goto done;
7457
7458 for (i = 0; i < count; i++)
7459 {
7460 if (params[i].outputMessageIndex == INVALID_PARAMETER_INDEX) continue;
7461 if (params[i].parameterType == WS_PARAMETER_TYPE_MESSAGES)
7462 {
7463 FIXME( "messages type not supported\n" );
7464 hr = E_NOTIMPL;
7465 goto done;
7466 }
7467 if ((hr = get_param_desc( desc_struct, params[i].outputMessageIndex, &desc_field )) != S_OK) goto done;
7468 if (params[i].parameterType == WS_PARAMETER_TYPE_NORMAL)
7469 {
7470 void *ptr = *(void **)args[i];
7471 if ((hr = read_param( reader, desc_field, heap, ptr )) != S_OK) goto done;
7472 }
7473 else if (params[i].parameterType == WS_PARAMETER_TYPE_ARRAY)
7474 {
7475 void **ptr = *(void ***)args[i];
7476 if ((hr = read_param_array( reader, desc_field, heap, ptr, &len )) != S_OK) goto done;
7477 set_array_len( params, count, params[i].outputMessageIndex, len, args );
7478 }
7479 }
7480
7481 if (desc_struct->structOptions & WS_STRUCT_IGNORE_TRAILING_ELEMENT_CONTENT)
7482 {
7483 struct node *parent = find_parent( reader );
7484 parent->flags |= NODE_FLAG_IGNORE_TRAILING_ELEMENT_CONTENT;
7485 }
7486
7487 hr = end_mapping( reader, WS_ELEMENT_TYPE_MAPPING );
7488
7489 done:
7490 LeaveCriticalSection( &reader->cs );
7491 return hr;
7492 }
Windows API implementation