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