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