?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
webservices: Implement WS_MOVE_TO_CHILD_ELEMENT in the reader.
[wine.git] / dlls / webservices / reader.c
blob5b0217f2a73f2e9364c8b2a16101c6ae5079aecf
1 /*
2 * Copyright 2015, 2016 Hans Leidekker for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <stdarg.h>
20
21 #include "windef.h"
22 #include "winbase.h"
23 #include "winnls.h"
24 #include "webservices.h"
25
26 #include "wine/debug.h"
27 #include "wine/list.h"
28 #include "webservices_private.h"
29
30 WINE_DEFAULT_DEBUG_CHANNEL(webservices);
31
32 const char *debugstr_xmlstr( const WS_XML_STRING *str )
33 {
34 if (!str) return "(null)";
35 return debugstr_an( (const char *)str->bytes, str->length );
36 }
37
38 static const struct
39 {
40 ULONG size;
41 BOOL readonly;
42 }
43 error_props[] =
44 {
45 { sizeof(ULONG), TRUE }, /* WS_ERROR_PROPERTY_STRING_COUNT */
46 { sizeof(ULONG), FALSE }, /* WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE */
47 { sizeof(LANGID), FALSE } /* WS_ERROR_PROPERTY_LANGID */
48 };
49
50 struct error
51 {
52 ULONG prop_count;
53 WS_ERROR_PROPERTY prop[sizeof(error_props)/sizeof(error_props[0])];
54 };
55
56 static struct error *alloc_error(void)
57 {
58 static const ULONG count = sizeof(error_props)/sizeof(error_props[0]);
59 struct error *ret;
60 ULONG i, size = sizeof(*ret) + count * sizeof(WS_ERROR_PROPERTY);
61 char *ptr;
62
63 for (i = 0; i < count; i++) size += error_props[i].size;
64 if (!(ret = heap_alloc_zero( size ))) return NULL;
65
66 ptr = (char *)&ret->prop[count];
67 for (i = 0; i < count; i++)
68 {
69 ret->prop[i].value = ptr;
70 ret->prop[i].valueSize = error_props[i].size;
71 ptr += ret->prop[i].valueSize;
72 }
73 ret->prop_count = count;
74 return ret;
75 }
76
77 static HRESULT set_error_prop( struct error *error, WS_ERROR_PROPERTY_ID id, const void *value, ULONG size )
78 {
79 if (id >= error->prop_count || size != error_props[id].size || error_props[id].readonly)
80 return E_INVALIDARG;
81
82 memcpy( error->prop[id].value, value, size );
83 return S_OK;
84 }
85
86 static HRESULT get_error_prop( struct error *error, WS_ERROR_PROPERTY_ID id, void *buf, ULONG size )
87 {
88 if (id >= error->prop_count || size != error_props[id].size)
89 return E_INVALIDARG;
90
91 memcpy( buf, error->prop[id].value, error->prop[id].valueSize );
92 return S_OK;
93 }
94
95 /**************************************************************************
96 * WsCreateError [webservices.@]
97 */
98 HRESULT WINAPI WsCreateError( const WS_ERROR_PROPERTY *properties, ULONG count, WS_ERROR **handle )
99 {
100 struct error *error;
101 LANGID langid = GetUserDefaultUILanguage();
102 HRESULT hr;
103 ULONG i;
104
105 TRACE( "%p %u %p\n", properties, count, handle );
106
107 if (!handle) return E_INVALIDARG;
108 if (!(error = alloc_error())) return E_OUTOFMEMORY;
109
110 set_error_prop( error, WS_ERROR_PROPERTY_LANGID, &langid, sizeof(langid) );
111 for (i = 0; i < count; i++)
112 {
113 if (properties[i].id == WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE)
114 {
115 heap_free( error );
116 return E_INVALIDARG;
117 }
118 hr = set_error_prop( error, properties[i].id, properties[i].value, properties[i].valueSize );
119 if (hr != S_OK)
120 {
121 heap_free( error );
122 return hr;
123 }
124 }
125
126 *handle = (WS_ERROR *)error;
127 return S_OK;
128 }
129
130 /**************************************************************************
131 * WsFreeError [webservices.@]
132 */
133 void WINAPI WsFreeError( WS_ERROR *handle )
134 {
135 struct error *error = (struct error *)handle;
136
137 TRACE( "%p\n", handle );
138 heap_free( error );
139 }
140
141 static const struct
142 {
143 ULONG size;
144 BOOL readonly;
145 }
146 heap_props[] =
147 {
148 { sizeof(SIZE_T), FALSE }, /* WS_HEAP_PROPERTY_MAX_SIZE */
149 { sizeof(SIZE_T), FALSE }, /* WS_HEAP_PROPERTY_TRIM_SIZE */
150 { sizeof(SIZE_T), TRUE }, /* WS_HEAP_PROPERTY_REQUESTED_SIZE */
151 { sizeof(SIZE_T), TRUE } /* WS_HEAP_PROPERTY_ACTUAL_SIZE */
152 };
153
154 struct heap
155 {
156 HANDLE handle;
157 ULONG prop_count;
158 WS_HEAP_PROPERTY prop[sizeof(heap_props)/sizeof(heap_props[0])];
159 };
160
161 void *ws_alloc( WS_HEAP *handle, SIZE_T size )
162 {
163 struct heap *heap = (struct heap *)handle;
164 return HeapAlloc( heap->handle, 0, size );
165 }
166
167 static void *ws_alloc_zero( WS_HEAP *handle, SIZE_T size )
168 {
169 struct heap *heap = (struct heap *)handle;
170 return HeapAlloc( heap->handle, HEAP_ZERO_MEMORY, size );
171 }
172
173 void *ws_realloc( WS_HEAP *handle, void *ptr, SIZE_T size )
174 {
175 struct heap *heap = (struct heap *)handle;
176 return HeapReAlloc( heap->handle, 0, ptr, size );
177 }
178
179 void ws_free( WS_HEAP *handle, void *ptr )
180 {
181 struct heap *heap = (struct heap *)handle;
182 HeapFree( heap->handle, 0, ptr );
183 }
184
185 /**************************************************************************
186 * WsAlloc [webservices.@]
187 */
188 HRESULT WINAPI WsAlloc( WS_HEAP *handle, SIZE_T size, void **ptr, WS_ERROR *error )
189 {
190 void *mem;
191
192 TRACE( "%p %u %p %p\n", handle, (ULONG)size, ptr, error );
193 if (error) FIXME( "ignoring error parameter\n" );
194
195 if (!handle || !ptr) return E_INVALIDARG;
196
197 if (!(mem = ws_alloc( handle, size ))) return E_OUTOFMEMORY;
198 *ptr = mem;
199 return S_OK;
200 }
201
202 static struct heap *alloc_heap(void)
203 {
204 static const ULONG count = sizeof(heap_props)/sizeof(heap_props[0]);
205 struct heap *ret;
206 ULONG i, size = sizeof(*ret) + count * sizeof(WS_HEAP_PROPERTY);
207 char *ptr;
208
209 for (i = 0; i < count; i++) size += heap_props[i].size;
210 if (!(ret = heap_alloc_zero( size ))) return NULL;
211
212 ptr = (char *)&ret->prop[count];
213 for (i = 0; i < count; i++)
214 {
215 ret->prop[i].value = ptr;
216 ret->prop[i].valueSize = heap_props[i].size;
217 ptr += ret->prop[i].valueSize;
218 }
219 ret->prop_count = count;
220 return ret;
221 }
222
223 static HRESULT set_heap_prop( struct heap *heap, WS_HEAP_PROPERTY_ID id, const void *value, ULONG size )
224 {
225 if (id >= heap->prop_count || size != heap_props[id].size || heap_props[id].readonly)
226 return E_INVALIDARG;
227
228 memcpy( heap->prop[id].value, value, size );
229 return S_OK;
230 }
231
232 static HRESULT get_heap_prop( struct heap *heap, WS_HEAP_PROPERTY_ID id, void *buf, ULONG size )
233 {
234 if (id >= heap->prop_count || size != heap_props[id].size)
235 return E_INVALIDARG;
236
237 memcpy( buf, heap->prop[id].value, heap->prop[id].valueSize );
238 return S_OK;
239 }
240
241 /**************************************************************************
242 * WsCreateHeap [webservices.@]
243 */
244 HRESULT WINAPI WsCreateHeap( SIZE_T max_size, SIZE_T trim_size, const WS_HEAP_PROPERTY *properties,
245 ULONG count, WS_HEAP **handle, WS_ERROR *error )
246 {
247 struct heap *heap;
248
249 TRACE( "%u %u %p %u %p %p\n", (ULONG)max_size, (ULONG)trim_size, properties, count, handle, error );
250 if (error) FIXME( "ignoring error parameter\n" );
251
252 if (!handle || count) return E_INVALIDARG;
253 if (!(heap = alloc_heap())) return E_OUTOFMEMORY;
254
255 set_heap_prop( heap, WS_HEAP_PROPERTY_MAX_SIZE, &max_size, sizeof(max_size) );
256 set_heap_prop( heap, WS_HEAP_PROPERTY_TRIM_SIZE, &trim_size, sizeof(trim_size) );
257
258 if (!(heap->handle = HeapCreate( 0, 0, max_size )))
259 {
260 heap_free( heap );
261 return E_OUTOFMEMORY;
262 }
263
264 *handle = (WS_HEAP *)heap;
265 return S_OK;
266 }
267
268 /**************************************************************************
269 * WsFreeHeap [webservices.@]
270 */
271 void WINAPI WsFreeHeap( WS_HEAP *handle )
272 {
273 struct heap *heap = (struct heap *)handle;
274
275 TRACE( "%p\n", handle );
276
277 if (!heap) return;
278 HeapDestroy( heap->handle );
279 heap_free( heap );
280 }
281
282 struct node *alloc_node( WS_XML_NODE_TYPE type )
283 {
284 struct node *ret;
285
286 if (!(ret = heap_alloc_zero( sizeof(*ret) ))) return NULL;
287 ret->hdr.node.nodeType = type;
288 list_init( &ret->entry );
289 list_init( &ret->children );
290 return ret;
291 }
292
293 void free_attribute( WS_XML_ATTRIBUTE *attr )
294 {
295 if (!attr) return;
296 heap_free( attr->prefix );
297 heap_free( attr->localName );
298 heap_free( attr->ns );
299 heap_free( attr->value );
300 heap_free( attr );
301 }
302
303 void free_node( struct node *node )
304 {
305 if (!node) return;
306 switch (node->hdr.node.nodeType)
307 {
308 case WS_XML_NODE_TYPE_ELEMENT:
309 {
310 WS_XML_ELEMENT_NODE *elem = &node->hdr;
311 ULONG i;
312
313 for (i = 0; i < elem->attributeCount; i++) free_attribute( elem->attributes[i] );
314 heap_free( elem->attributes );
315 heap_free( elem->prefix );
316 heap_free( elem->localName );
317 heap_free( elem->ns );
318 break;
319 }
320 case WS_XML_NODE_TYPE_TEXT:
321 {
322 WS_XML_TEXT_NODE *text = (WS_XML_TEXT_NODE *)node;
323 heap_free( text->text );
324 break;
325 }
326 case WS_XML_NODE_TYPE_COMMENT:
327 {
328 WS_XML_COMMENT_NODE *comment = (WS_XML_COMMENT_NODE *)node;
329 heap_free( comment->value.bytes );
330 break;
331 }
332 case WS_XML_NODE_TYPE_CDATA:
333 case WS_XML_NODE_TYPE_END_CDATA:
334 case WS_XML_NODE_TYPE_END_ELEMENT:
335 case WS_XML_NODE_TYPE_EOF:
336 case WS_XML_NODE_TYPE_BOF:
337 break;
338
339 default:
340 ERR( "unhandled type %u\n", node->hdr.node.nodeType );
341 break;
342 }
343 heap_free( node );
344 }
345
346 void destroy_nodes( struct node *node )
347 {
348 struct list *ptr;
349
350 if (!node) return;
351 while ((ptr = list_head( &node->children )))
352 {
353 struct node *child = LIST_ENTRY( ptr, struct node, entry );
354 list_remove( &child->entry );
355 destroy_nodes( child );
356 }
357 free_node( node );
358 }
359
360 static const struct
361 {
362 ULONG size;
363 BOOL readonly;
364 }
365 reader_props[] =
366 {
367 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_DEPTH */
368 { sizeof(BOOL), FALSE }, /* WS_XML_READER_PROPERTY_ALLOW_FRAGMENT */
369 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_ATTRIBUTES */
370 { sizeof(BOOL), FALSE }, /* WS_XML_READER_PROPERTY_READ_DECLARATION */
371 { sizeof(WS_CHARSET), FALSE }, /* WS_XML_READER_PROPERTY_CHARSET */
372 { sizeof(ULONGLONG), TRUE }, /* WS_XML_READER_PROPERTY_ROW */
373 { sizeof(ULONGLONG), TRUE }, /* WS_XML_READER_PROPERTY_COLUMN */
374 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_UTF8_TRIM_SIZE */
375 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_STREAM_BUFFER_SIZE */
376 { sizeof(BOOL), TRUE }, /* WS_XML_READER_PROPERTY_IN_ATTRIBUTE */
377 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_STREAM_MAX_ROOT_MIME_PART_SIZE */
378 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_STREAM_MAX_MIME_HEADERS_SIZE */
379 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_MIME_PARTS */
380 { sizeof(BOOL), FALSE }, /* WS_XML_READER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES */
381 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_NAMESPACES */
382 };
383
384 enum reader_state
385 {
386 READER_STATE_INITIAL,
387 READER_STATE_BOF,
388 READER_STATE_STARTELEMENT,
389 READER_STATE_STARTATTRIBUTE,
390 READER_STATE_STARTCDATA,
391 READER_STATE_CDATA,
392 READER_STATE_TEXT,
393 READER_STATE_ENDELEMENT,
394 READER_STATE_ENDCDATA,
395 READER_STATE_COMMENT,
396 READER_STATE_EOF
397 };
398
399 struct reader
400 {
401 ULONG read_size;
402 ULONG read_pos;
403 const unsigned char *read_bufptr;
404 enum reader_state state;
405 struct node *root;
406 struct node *current;
407 ULONG current_attr;
408 WS_XML_READER_INPUT_TYPE input_type;
409 const unsigned char *input_data;
410 ULONG input_size;
411 ULONG prop_count;
412 WS_XML_READER_PROPERTY prop[sizeof(reader_props)/sizeof(reader_props[0])];
413 };
414
415 static struct reader *alloc_reader(void)
416 {
417 static const ULONG count = sizeof(reader_props)/sizeof(reader_props[0]);
418 struct reader *ret;
419 ULONG i, size = sizeof(*ret) + count * sizeof(WS_XML_READER_PROPERTY);
420 char *ptr;
421
422 for (i = 0; i < count; i++) size += reader_props[i].size;
423 if (!(ret = heap_alloc_zero( size ))) return NULL;
424
425 ptr = (char *)&ret->prop[count];
426 for (i = 0; i < count; i++)
427 {
428 ret->prop[i].value = ptr;
429 ret->prop[i].valueSize = reader_props[i].size;
430 ptr += ret->prop[i].valueSize;
431 }
432 ret->prop_count = count;
433 return ret;
434 }
435
436 static HRESULT set_reader_prop( struct reader *reader, WS_XML_READER_PROPERTY_ID id, const void *value, ULONG size )
437 {
438 if (id >= reader->prop_count || size != reader_props[id].size || reader_props[id].readonly)
439 return E_INVALIDARG;
440
441 memcpy( reader->prop[id].value, value, size );
442 return S_OK;
443 }
444
445 static HRESULT get_reader_prop( struct reader *reader, WS_XML_READER_PROPERTY_ID id, void *buf, ULONG size )
446 {
447 if (id >= reader->prop_count || size != reader_props[id].size)
448 return E_INVALIDARG;
449
450 memcpy( buf, reader->prop[id].value, reader->prop[id].valueSize );
451 return S_OK;
452 }
453
454 static void read_insert_eof( struct reader *reader, struct node *eof )
455 {
456 if (!reader->root) reader->root = eof;
457 else
458 {
459 eof->parent = reader->root;
460 list_add_tail( &reader->root->children, &eof->entry );
461 }
462 reader->current = eof;
463 }
464
465 static void read_insert_bof( struct reader *reader, struct node *bof )
466 {
467 reader->root->parent = bof;
468 list_add_tail( &bof->children, &reader->root->entry );
469 reader->current = reader->root = bof;
470 }
471
472 static void read_insert_node( struct reader *reader, struct node *parent, struct node *node )
473 {
474 node->parent = parent;
475 if (node->parent == reader->root)
476 {
477 struct list *eof = list_tail( &reader->root->children );
478 list_add_before( eof, &node->entry );
479 }
480 else list_add_tail( &parent->children, &node->entry );
481 reader->current = node;
482 }
483
484 static HRESULT read_init_state( struct reader *reader )
485 {
486 struct node *node;
487
488 destroy_nodes( reader->root );
489 reader->root = NULL;
490 if (!(node = alloc_node( WS_XML_NODE_TYPE_EOF ))) return E_OUTOFMEMORY;
491 read_insert_eof( reader, node );
492 reader->state = READER_STATE_INITIAL;
493 return S_OK;
494 }
495
496 /**************************************************************************
497 * WsCreateReader [webservices.@]
498 */
499 HRESULT WINAPI WsCreateReader( const WS_XML_READER_PROPERTY *properties, ULONG count,
500 WS_XML_READER **handle, WS_ERROR *error )
501 {
502 struct reader *reader;
503 ULONG i, max_depth = 32, max_attrs = 128, max_ns = 32;
504 WS_CHARSET charset = WS_CHARSET_UTF8;
505 BOOL read_decl = TRUE;
506 HRESULT hr;
507
508 TRACE( "%p %u %p %p\n", properties, count, handle, error );
509 if (error) FIXME( "ignoring error parameter\n" );
510
511 if (!handle) return E_INVALIDARG;
512 if (!(reader = alloc_reader())) return E_OUTOFMEMORY;
513
514 set_reader_prop( reader, WS_XML_READER_PROPERTY_MAX_DEPTH, &max_depth, sizeof(max_depth) );
515 set_reader_prop( reader, WS_XML_READER_PROPERTY_MAX_ATTRIBUTES, &max_attrs, sizeof(max_attrs) );
516 set_reader_prop( reader, WS_XML_READER_PROPERTY_READ_DECLARATION, &read_decl, sizeof(read_decl) );
517 set_reader_prop( reader, WS_XML_READER_PROPERTY_CHARSET, &charset, sizeof(charset) );
518 set_reader_prop( reader, WS_XML_READER_PROPERTY_MAX_NAMESPACES, &max_ns, sizeof(max_ns) );
519
520 for (i = 0; i < count; i++)
521 {
522 hr = set_reader_prop( reader, properties[i].id, properties[i].value, properties[i].valueSize );
523 if (hr != S_OK)
524 {
525 heap_free( reader );
526 return hr;
527 }
528 }
529
530 if ((hr = read_init_state( reader )) != S_OK)
531 {
532 heap_free( reader );
533 return hr;
534 }
535
536 *handle = (WS_XML_READER *)reader;
537 return S_OK;
538 }
539
540 /**************************************************************************
541 * WsFreeReader [webservices.@]
542 */
543 void WINAPI WsFreeReader( WS_XML_READER *handle )
544 {
545 struct reader *reader = (struct reader *)handle;
546
547 TRACE( "%p\n", handle );
548
549 if (!reader) return;
550 destroy_nodes( reader->root );
551 heap_free( reader );
552 }
553
554 /**************************************************************************
555 * WsFillReader [webservices.@]
556 */
557 HRESULT WINAPI WsFillReader( WS_XML_READER *handle, ULONG min_size, const WS_ASYNC_CONTEXT *ctx,
558 WS_ERROR *error )
559 {
560 struct reader *reader = (struct reader *)handle;
561
562 TRACE( "%p %u %p %p\n", handle, min_size, ctx, error );
563 if (error) FIXME( "ignoring error parameter\n" );
564
565 if (!reader) return E_INVALIDARG;
566
567 /* FIXME: add support for stream input */
568 reader->read_size = min( min_size, reader->input_size );
569 reader->read_pos = 0;
570
571 return S_OK;
572 }
573
574 /**************************************************************************
575 * WsGetErrorProperty [webservices.@]
576 */
577 HRESULT WINAPI WsGetErrorProperty( WS_ERROR *handle, WS_ERROR_PROPERTY_ID id, void *buf,
578 ULONG size )
579 {
580 struct error *error = (struct error *)handle;
581
582 TRACE( "%p %u %p %u\n", handle, id, buf, size );
583 return get_error_prop( error, id, buf, size );
584 }
585
586 /**************************************************************************
587 * WsGetErrorString [webservices.@]
588 */
589 HRESULT WINAPI WsGetErrorString( WS_ERROR *handle, ULONG index, WS_STRING *str )
590 {
591 FIXME( "%p %u %p: stub\n", handle, index, str );
592 return E_NOTIMPL;
593 }
594
595 /**************************************************************************
596 * WsGetHeapProperty [webservices.@]
597 */
598 HRESULT WINAPI WsGetHeapProperty( WS_HEAP *handle, WS_HEAP_PROPERTY_ID id, void *buf,
599 ULONG size, WS_ERROR *error )
600 {
601 struct heap *heap = (struct heap *)handle;
602
603 TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
604 if (error) FIXME( "ignoring error parameter\n" );
605
606 return get_heap_prop( heap, id, buf, size );
607 }
608
609 /**************************************************************************
610 * WsGetReaderNode [webservices.@]
611 */
612 HRESULT WINAPI WsGetReaderNode( WS_XML_READER *handle, const WS_XML_NODE **node,
613 WS_ERROR *error )
614 {
615 struct reader *reader = (struct reader *)handle;
616
617 TRACE( "%p %p %p\n", handle, node, error );
618 if (error) FIXME( "ignoring error parameter\n" );
619
620 if (!reader || !node) return E_INVALIDARG;
621
622 *node = &reader->current->hdr.node;
623 return S_OK;
624 }
625
626 /**************************************************************************
627 * WsGetReaderProperty [webservices.@]
628 */
629 HRESULT WINAPI WsGetReaderProperty( WS_XML_READER *handle, WS_XML_READER_PROPERTY_ID id,
630 void *buf, ULONG size, WS_ERROR *error )
631 {
632 struct reader *reader = (struct reader *)handle;
633
634 TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
635 if (error) FIXME( "ignoring error parameter\n" );
636
637 if (!reader->input_type) return WS_E_INVALID_OPERATION;
638
639 if (id == WS_XML_READER_PROPERTY_CHARSET)
640 {
641 WS_CHARSET charset;
642 HRESULT hr;
643
644 if ((hr = get_reader_prop( reader, id, &charset, size )) != S_OK) return hr;
645 if (!charset) return WS_E_INVALID_FORMAT;
646 *(WS_CHARSET *)buf = charset;
647 return S_OK;
648 }
649 return get_reader_prop( reader, id, buf, size );
650 }
651
652 /**************************************************************************
653 * WsGetXmlAttribute [webservices.@]
654 */
655 HRESULT WINAPI WsGetXmlAttribute( WS_XML_READER *handle, const WS_XML_STRING *attr,
656 WS_HEAP *heap, WCHAR **str, ULONG *len, WS_ERROR *error )
657 {
658 FIXME( "%p %p %p %p %p %p: stub\n", handle, debugstr_xmlstr(attr), heap, str, len, error );
659 return E_NOTIMPL;
660 }
661
662 WS_XML_STRING *alloc_xml_string( const unsigned char *data, ULONG len )
663 {
664 WS_XML_STRING *ret;
665
666 if (!(ret = heap_alloc( sizeof(*ret) + len ))) return NULL;
667 ret->length = len;
668 ret->bytes = (BYTE *)(ret + 1);
669 ret->dictionary = NULL;
670 ret->id = 0;
671 if (data) memcpy( ret->bytes, data, len );
672 return ret;
673 }
674
675 WS_XML_UTF8_TEXT *alloc_utf8_text( const unsigned char *data, ULONG len )
676 {
677 WS_XML_UTF8_TEXT *ret;
678
679 if (!(ret = heap_alloc( sizeof(*ret) + len ))) return NULL;
680 ret->text.textType = WS_XML_TEXT_TYPE_UTF8;
681 ret->value.length = len;
682 ret->value.bytes = (BYTE *)(ret + 1);
683 ret->value.dictionary = NULL;
684 ret->value.id = 0;
685 if (data) memcpy( ret->value.bytes, data, len );
686 return ret;
687 }
688
689 static inline BOOL read_end_of_data( struct reader *reader )
690 {
691 return reader->read_pos >= reader->read_size;
692 }
693
694 static inline const unsigned char *read_current_ptr( struct reader *reader )
695 {
696 return &reader->read_bufptr[reader->read_pos];
697 }
698
699 /* UTF-8 support based on libs/wine/utf8.c */
700
701 /* number of following bytes in sequence based on first byte value (for bytes above 0x7f) */
702 static const char utf8_length[128] =
703 {
704 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x80-0x8f */
705 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x90-0x9f */
706 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xa0-0xaf */
707 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xb0-0xbf */
708 0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 0xc0-0xcf */
709 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 0xd0-0xdf */
710 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, /* 0xe0-0xef */
711 3,3,3,3,3,0,0,0,0,0,0,0,0,0,0,0 /* 0xf0-0xff */
712 };
713
714 /* first byte mask depending on UTF-8 sequence length */
715 static const unsigned char utf8_mask[4] = { 0x7f, 0x1f, 0x0f, 0x07 };
716
717 /* minimum Unicode value depending on UTF-8 sequence length */
718 static const unsigned int utf8_minval[4] = { 0x0, 0x80, 0x800, 0x10000 };
719
720 static inline unsigned int read_utf8_char( struct reader *reader, unsigned int *skip )
721 {
722 unsigned int len, res;
723 unsigned char ch = reader->read_bufptr[reader->read_pos];
724 const unsigned char *end;
725
726 if (reader->read_pos >= reader->read_size) return 0;
727
728 if (ch < 0x80)
729 {
730 *skip = 1;
731 return ch;
732 }
733 len = utf8_length[ch - 0x80];
734 if (reader->read_pos + len >= reader->read_size) return 0;
735 end = reader->read_bufptr + reader->read_pos + len;
736 res = ch & utf8_mask[len];
737
738 switch (len)
739 {
740 case 3:
741 if ((ch = end[-3] ^ 0x80) >= 0x40) break;
742 res = (res << 6) | ch;
743 case 2:
744 if ((ch = end[-2] ^ 0x80) >= 0x40) break;
745 res = (res << 6) | ch;
746 case 1:
747 if ((ch = end[-1] ^ 0x80) >= 0x40) break;
748 res = (res << 6) | ch;
749 if (res < utf8_minval[len]) break;
750 *skip = len + 1;
751 return res;
752 }
753
754 return 0;
755 }
756
757 static inline void read_skip( struct reader *reader, unsigned int count )
758 {
759 while (reader->read_pos < reader->read_size && count)
760 {
761 reader->read_pos++;
762 count--;
763 }
764 }
765
766 static inline BOOL read_isnamechar( unsigned int ch )
767 {
768 /* FIXME: incomplete */
769 return (ch >= 'A' && ch <= 'Z') ||
770 (ch >= 'a' && ch <= 'z') ||
771 (ch >= '0' && ch <= '9') ||
772 ch == '_' || ch == '-' || ch == '.' || ch == ':';
773 }
774
775 static inline BOOL read_isspace( unsigned int ch )
776 {
777 return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n';
778 }
779
780 static inline void read_skip_whitespace( struct reader *reader )
781 {
782 while (reader->read_pos < reader->read_size && read_isspace( reader->read_bufptr[reader->read_pos] ))
783 reader->read_pos++;
784 }
785
786 static inline int read_cmp( struct reader *reader, const char *str, int len )
787 {
788 const unsigned char *ptr = read_current_ptr( reader );
789
790 if (len < 0) len = strlen( str );
791 if (reader->read_pos + len > reader->read_size) return -1;
792 while (len--)
793 {
794 if (*str != *ptr) return *ptr - *str;
795 str++; ptr++;
796 }
797 return 0;
798 }
799
800 static HRESULT read_xmldecl( struct reader *reader )
801 {
802 if (!reader->read_size) return WS_E_INVALID_FORMAT;
803
804 if (read_cmp( reader, "<", 1 ) || read_cmp( reader, "<?", 2 ))
805 {
806 reader->state = READER_STATE_BOF;
807 return S_OK;
808 }
809 if (read_cmp( reader, "<?xml ", 6 )) return WS_E_INVALID_FORMAT;
810 read_skip( reader, 6 );
811
812 /* FIXME: parse attributes */
813 while (reader->read_pos < reader->read_size && reader->read_bufptr[reader->read_pos] != '?')
814 reader->read_pos++;
815
816 if (read_cmp( reader, "?>", 2 )) return WS_E_INVALID_FORMAT;
817 read_skip( reader, 2 );
818
819 reader->state = READER_STATE_BOF;
820 return S_OK;
821 }
822
823 HRESULT append_attribute( WS_XML_ELEMENT_NODE *elem, WS_XML_ATTRIBUTE *attr )
824 {
825 if (elem->attributeCount)
826 {
827 WS_XML_ATTRIBUTE **tmp;
828 if (!(tmp = heap_realloc( elem->attributes, (elem->attributeCount + 1) * sizeof(attr) )))
829 return E_OUTOFMEMORY;
830 elem->attributes = tmp;
831 }
832 else if (!(elem->attributes = heap_alloc( sizeof(attr) ))) return E_OUTOFMEMORY;
833 elem->attributes[elem->attributeCount++] = attr;
834 return S_OK;
835 }
836
837 static HRESULT parse_name( const unsigned char *str, unsigned int len,
838 WS_XML_STRING **prefix, WS_XML_STRING **localname )
839 {
840 const unsigned char *name_ptr = str, *prefix_ptr = NULL;
841 unsigned int i, name_len = len, prefix_len = 0;
842
843 for (i = 0; i < len; i++)
844 {
845 if (str[i] == ':')
846 {
847 prefix_ptr = str;
848 prefix_len = i;
849 name_ptr = &str[i + 1];
850 name_len -= i + 1;
851 break;
852 }
853 }
854 if (!(*prefix = alloc_xml_string( prefix_ptr, prefix_len ))) return E_OUTOFMEMORY;
855 if (!(*localname = alloc_xml_string( name_ptr, name_len )))
856 {
857 heap_free( *prefix );
858 return E_OUTOFMEMORY;
859 }
860 return S_OK;
861 }
862
863 static HRESULT read_attribute( struct reader *reader, WS_XML_ATTRIBUTE **ret )
864 {
865 WS_XML_ATTRIBUTE *attr;
866 WS_XML_UTF8_TEXT *text;
867 unsigned int len = 0, ch, skip, quote;
868 const unsigned char *start;
869 HRESULT hr = WS_E_INVALID_FORMAT;
870
871 if (!(attr = heap_alloc_zero( sizeof(*attr) ))) return E_OUTOFMEMORY;
872
873 start = read_current_ptr( reader );
874 for (;;)
875 {
876 if (!(ch = read_utf8_char( reader, &skip ))) goto error;
877 if (!read_isnamechar( ch )) break;
878 read_skip( reader, skip );
879 len += skip;
880 }
881 if (!len) goto error;
882
883 if ((hr = parse_name( start, len, &attr->prefix, &attr->localName )) != S_OK) goto error;
884 if (!attr->prefix->length) attr->prefix->bytes = NULL;
885 hr = E_OUTOFMEMORY;
886 if (!(attr->ns = alloc_xml_string( NULL, 0 ))) goto error;
887 attr->ns->bytes = NULL;
888
889 hr = WS_E_INVALID_FORMAT;
890 read_skip_whitespace( reader );
891 if (read_cmp( reader, "=", 1 )) goto error;
892 read_skip( reader, 1 );
893
894 read_skip_whitespace( reader );
895 if (read_cmp( reader, "\"", 1 ) && read_cmp( reader, "'", 1 )) goto error;
896 quote = read_utf8_char( reader, &skip );
897 read_skip( reader, 1 );
898
899 len = 0;
900 start = read_current_ptr( reader );
901 for (;;)
902 {
903 if (!(ch = read_utf8_char( reader, &skip ))) goto error;
904 if (ch == quote) break;
905 read_skip( reader, skip );
906 len += skip;
907 }
908 read_skip( reader, 1 );
909
910 if (!(text = alloc_utf8_text( start, len )))
911 {
912 free_attribute( attr );
913 return E_OUTOFMEMORY;
914 }
915 attr->value = &text->text;
916 attr->singleQuote = (quote == '\'');
917
918 *ret = attr;
919 return S_OK;
920
921 error:
922 free_attribute( attr );
923 return hr;
924 }
925
926 static HRESULT read_element( struct reader *reader )
927 {
928 unsigned int len = 0, ch, skip;
929 const unsigned char *start;
930 struct node *node;
931 WS_XML_ELEMENT_NODE *elem;
932 WS_XML_ATTRIBUTE *attr;
933 HRESULT hr = WS_E_INVALID_FORMAT;
934
935 if (read_end_of_data( reader ))
936 {
937 struct list *eof = list_tail( &reader->root->children );
938 reader->current = LIST_ENTRY( eof, struct node, entry );
939 reader->state = READER_STATE_EOF;
940 return S_OK;
941 }
942
943 if (!(node = alloc_node( WS_XML_NODE_TYPE_ELEMENT ))) return E_OUTOFMEMORY;
944 elem = (WS_XML_ELEMENT_NODE *)node;
945
946 if (read_cmp( reader, "<", 1 )) goto error;
947 read_skip( reader, 1 );
948
949 start = read_current_ptr( reader );
950 for (;;)
951 {
952 if (!(ch = read_utf8_char( reader, &skip ))) goto error;
953 if (!read_isnamechar( ch )) break;
954 read_skip( reader, skip );
955 len += skip;
956 }
957 if (!len) goto error;
958
959 if ((hr = parse_name( start, len, &elem->prefix, &elem->localName )) != S_OK) goto error;
960 if (!elem->prefix->length) elem->prefix->bytes = NULL;
961 hr = E_OUTOFMEMORY;
962 if (!(elem->ns = alloc_xml_string( NULL, 0 ))) goto error;
963
964 reader->current_attr = 0;
965 for (;;)
966 {
967 read_skip_whitespace( reader );
968 if (!read_cmp( reader, ">", 1 ) || !read_cmp( reader, "/>", 2 )) break;
969 if ((hr = read_attribute( reader, &attr )) != S_OK) goto error;
970 if ((hr = append_attribute( elem, attr )) != S_OK)
971 {
972 free_attribute( attr );
973 goto error;
974 }
975 reader->current_attr++;
976 }
977
978 read_skip_whitespace( reader );
979 if (read_cmp( reader, ">", 1 ) && read_cmp( reader, "/>", 2 ))
980 {
981 hr = WS_E_INVALID_FORMAT;
982 goto error;
983 }
984
985 read_insert_node( reader, reader->current, node );
986 if (!read_cmp( reader, "/>", 2 ))
987 {
988 read_skip( reader, 2 );
989 if (!(node = alloc_node( WS_XML_NODE_TYPE_END_ELEMENT ))) return E_OUTOFMEMORY;
990 read_insert_node( reader, reader->current, node );
991 reader->state = READER_STATE_ENDELEMENT;
992 }
993 else
994 {
995 read_skip( reader, 1 );
996 reader->state = READER_STATE_STARTELEMENT;
997 }
998 return S_OK;
999
1000 error:
1001 free_node( node );
1002 return hr;
1003 }
1004
1005 static HRESULT read_text( struct reader *reader )
1006 {
1007 unsigned int len = 0, ch, skip;
1008 const unsigned char *start;
1009 struct node *node;
1010 WS_XML_TEXT_NODE *text;
1011 WS_XML_UTF8_TEXT *utf8;
1012
1013 start = read_current_ptr( reader );
1014 for (;;)
1015 {
1016 if (read_end_of_data( reader )) break;
1017 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
1018 if (ch == '<') break;
1019 read_skip( reader, skip );
1020 len += skip;
1021 }
1022
1023 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return E_OUTOFMEMORY;
1024 text = (WS_XML_TEXT_NODE *)node;
1025 if (!(utf8 = alloc_utf8_text( start, len )))
1026 {
1027 heap_free( node );
1028 return E_OUTOFMEMORY;
1029 }
1030 text->text = &utf8->text;
1031
1032 read_insert_node( reader, reader->current, node );
1033 reader->state = READER_STATE_TEXT;
1034 return S_OK;
1035 }
1036
1037 static HRESULT read_startelement( struct reader *reader )
1038 {
1039 if (!read_cmp( reader, "<", 1 )) return read_element( reader );
1040 return read_text( reader );
1041 }
1042
1043 static HRESULT read_to_startelement( struct reader *reader, BOOL *found )
1044 {
1045 HRESULT hr;
1046
1047 switch (reader->state)
1048 {
1049 case READER_STATE_INITIAL:
1050 if ((hr = read_xmldecl( reader )) != S_OK) return hr;
1051 break;
1052
1053 case READER_STATE_STARTELEMENT:
1054 if (found) *found = TRUE;
1055 return S_OK;
1056
1057 default:
1058 break;
1059 }
1060
1061 read_skip_whitespace( reader );
1062 if ((hr = read_element( reader )) == S_OK && found)
1063 {
1064 if (reader->state == READER_STATE_STARTELEMENT)
1065 *found = TRUE;
1066 else
1067 *found = FALSE;
1068 }
1069
1070 return hr;
1071 }
1072
1073 static int cmp_name( const unsigned char *name1, ULONG len1, const unsigned char *name2, ULONG len2 )
1074 {
1075 ULONG i;
1076 if (len1 != len2) return 1;
1077 for (i = 0; i < len1; i++) { if (toupper( name1[i] ) != toupper( name2[i] )) return 1; }
1078 return 0;
1079 }
1080
1081 struct node *find_parent_element( struct node *node, const WS_XML_STRING *prefix,
1082 const WS_XML_STRING *localname )
1083 {
1084 struct node *parent;
1085 const WS_XML_STRING *str;
1086
1087 for (parent = node; parent; parent = parent->parent)
1088 {
1089 if (parent->hdr.node.nodeType != WS_XML_NODE_TYPE_ELEMENT) continue;
1090 if (!localname) return parent;
1091
1092 str = parent->hdr.prefix;
1093 if (cmp_name( str->bytes, str->length, prefix->bytes, prefix->length )) continue;
1094
1095 str = parent->hdr.localName;
1096 if (cmp_name( str->bytes, str->length, localname->bytes, localname->length )) continue;
1097
1098 return parent;
1099 }
1100 return NULL;
1101 }
1102
1103 static HRESULT read_endelement( struct reader *reader )
1104 {
1105 struct node *node, *parent;
1106 unsigned int len = 0, ch, skip;
1107 const unsigned char *start;
1108 WS_XML_STRING *prefix, *localname;
1109 HRESULT hr;
1110
1111 if (read_cmp( reader, "</", 2 )) return WS_E_INVALID_FORMAT;
1112 read_skip( reader, 2 );
1113
1114 start = read_current_ptr( reader );
1115 for (;;)
1116 {
1117 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
1118 if (ch == '>')
1119 {
1120 read_skip( reader, 1 );
1121 break;
1122 }
1123 if (!read_isnamechar( ch )) return WS_E_INVALID_FORMAT;
1124 read_skip( reader, skip );
1125 len += skip;
1126 }
1127
1128 if ((hr = parse_name( start, len, &prefix, &localname )) != S_OK) return hr;
1129 parent = find_parent_element( reader->current, prefix, localname );
1130 heap_free( prefix );
1131 heap_free( localname );
1132 if (!parent) return WS_E_INVALID_FORMAT;
1133
1134 if (!(node = alloc_node( WS_XML_NODE_TYPE_END_ELEMENT ))) return E_OUTOFMEMORY;
1135 read_insert_node( reader, parent, node );
1136 reader->state = READER_STATE_ENDELEMENT;
1137 return S_OK;
1138 }
1139
1140 static HRESULT read_comment( struct reader *reader )
1141 {
1142 unsigned int len = 0, ch, skip;
1143 const unsigned char *start;
1144 struct node *node;
1145 WS_XML_COMMENT_NODE *comment;
1146
1147 if (read_cmp( reader, "<!--", 4 )) return WS_E_INVALID_FORMAT;
1148 read_skip( reader, 4 );
1149
1150 start = read_current_ptr( reader );
1151 for (;;)
1152 {
1153 if (!read_cmp( reader, "-->", 3 ))
1154 {
1155 read_skip( reader, 3 );
1156 break;
1157 }
1158 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
1159 read_skip( reader, skip );
1160 len += skip;
1161 }
1162
1163 if (!(node = alloc_node( WS_XML_NODE_TYPE_COMMENT ))) return E_OUTOFMEMORY;
1164 comment = (WS_XML_COMMENT_NODE *)node;
1165 if (!(comment->value.bytes = heap_alloc( len )))
1166 {
1167 heap_free( node );
1168 return E_OUTOFMEMORY;
1169 }
1170 memcpy( comment->value.bytes, start, len );
1171 comment->value.length = len;
1172
1173 read_insert_node( reader, reader->current, node );
1174 reader->state = READER_STATE_COMMENT;
1175 return S_OK;
1176 }
1177
1178 static HRESULT read_startcdata( struct reader *reader )
1179 {
1180 struct node *node;
1181
1182 if (read_cmp( reader, "<![CDATA[", 9 )) return WS_E_INVALID_FORMAT;
1183 read_skip( reader, 9 );
1184
1185 if (!(node = alloc_node( WS_XML_NODE_TYPE_CDATA ))) return E_OUTOFMEMORY;
1186 read_insert_node( reader, reader->current, node );
1187 reader->state = READER_STATE_STARTCDATA;
1188 return S_OK;
1189 }
1190
1191 static HRESULT read_cdata( struct reader *reader )
1192 {
1193 unsigned int len = 0, ch, skip;
1194 const unsigned char *start;
1195 struct node *node;
1196 WS_XML_TEXT_NODE *text;
1197 WS_XML_UTF8_TEXT *utf8;
1198
1199 start = read_current_ptr( reader );
1200 for (;;)
1201 {
1202 if (!read_cmp( reader, "]]>", 3 )) break;
1203 if (!(ch = read_utf8_char( reader, &skip ))) return WS_E_INVALID_FORMAT;
1204 read_skip( reader, skip );
1205 len += skip;
1206 }
1207
1208 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return E_OUTOFMEMORY;
1209 text = (WS_XML_TEXT_NODE *)node;
1210 if (!(utf8 = alloc_utf8_text( start, len )))
1211 {
1212 heap_free( node );
1213 return E_OUTOFMEMORY;
1214 }
1215 text->text = &utf8->text;
1216
1217 read_insert_node( reader, reader->current, node );
1218 reader->state = READER_STATE_CDATA;
1219 return S_OK;
1220 }
1221
1222 static HRESULT read_endcdata( struct reader *reader )
1223 {
1224 struct node *node;
1225
1226 if (read_cmp( reader, "]]>", 3 )) return WS_E_INVALID_FORMAT;
1227 read_skip( reader, 3 );
1228
1229 if (!(node = alloc_node( WS_XML_NODE_TYPE_END_CDATA ))) return E_OUTOFMEMORY;
1230 read_insert_node( reader, reader->current->parent, node );
1231 reader->state = READER_STATE_ENDCDATA;
1232 return S_OK;
1233 }
1234
1235 static HRESULT read_node( struct reader *reader )
1236 {
1237 HRESULT hr;
1238
1239 for (;;)
1240 {
1241 if (read_end_of_data( reader ))
1242 {
1243 struct list *eof = list_tail( &reader->root->children );
1244 reader->current = LIST_ENTRY( eof, struct node, entry );
1245 reader->state = READER_STATE_EOF;
1246 return S_OK;
1247 }
1248 if (reader->state == READER_STATE_STARTCDATA) return read_cdata( reader );
1249 else if (reader->state == READER_STATE_CDATA) return read_endcdata( reader );
1250 else if (!read_cmp( reader, "<?", 2 ))
1251 {
1252 hr = read_xmldecl( reader );
1253 if (FAILED( hr )) return hr;
1254 }
1255 else if (!read_cmp( reader, "</", 2 )) return read_endelement( reader );
1256 else if (!read_cmp( reader, "<![CDATA[", 9 )) return read_startcdata( reader );
1257 else if (!read_cmp( reader, "<!--", 4 )) return read_comment( reader );
1258 else if (!read_cmp( reader, "<", 1 )) return read_startelement( reader );
1259 else return read_text( reader );
1260 }
1261 }
1262
1263 /**************************************************************************
1264 * WsReadEndElement [webservices.@]
1265 */
1266 HRESULT WINAPI WsReadEndElement( WS_XML_READER *handle, WS_ERROR *error )
1267 {
1268 struct reader *reader = (struct reader *)handle;
1269
1270 TRACE( "%p %p\n", handle, error );
1271 if (error) FIXME( "ignoring error parameter\n" );
1272
1273 if (!reader) return E_INVALIDARG;
1274 return read_endelement( reader );
1275 }
1276
1277 /**************************************************************************
1278 * WsReadNode [webservices.@]
1279 */
1280 HRESULT WINAPI WsReadNode( WS_XML_READER *handle, WS_ERROR *error )
1281 {
1282 struct reader *reader = (struct reader *)handle;
1283
1284 TRACE( "%p %p\n", handle, error );
1285 if (error) FIXME( "ignoring error parameter\n" );
1286
1287 if (!reader) return E_INVALIDARG;
1288 return read_node( reader );
1289 }
1290
1291 /**************************************************************************
1292 * WsReadStartElement [webservices.@]
1293 */
1294 HRESULT WINAPI WsReadStartElement( WS_XML_READER *handle, WS_ERROR *error )
1295 {
1296 struct reader *reader = (struct reader *)handle;
1297
1298 TRACE( "%p %p\n", handle, error );
1299 if (error) FIXME( "ignoring error parameter\n" );
1300
1301 if (!reader) return E_INVALIDARG;
1302 return read_startelement( reader );
1303 }
1304
1305 /**************************************************************************
1306 * WsReadToStartElement [webservices.@]
1307 */
1308 HRESULT WINAPI WsReadToStartElement( WS_XML_READER *handle, const WS_XML_STRING *localname,
1309 const WS_XML_STRING *ns, BOOL *found, WS_ERROR *error )
1310 {
1311 struct reader *reader = (struct reader *)handle;
1312
1313 TRACE( "%p %s %s %p %p\n", handle, debugstr_xmlstr(localname), debugstr_xmlstr(ns), found, error );
1314 if (error) FIXME( "ignoring error parameter\n" );
1315
1316 if (!reader) return E_INVALIDARG;
1317 if (localname || ns) FIXME( "name and/or namespace not verified\n" );
1318
1319 return read_to_startelement( reader, found );
1320 }
1321
1322 static BOOL move_to_root_element( struct reader *reader )
1323 {
1324 struct list *ptr;
1325 struct node *node;
1326
1327 if (!(ptr = list_head( &reader->root->children ))) return FALSE;
1328 node = LIST_ENTRY( ptr, struct node, entry );
1329 if (node->hdr.node.nodeType == WS_XML_NODE_TYPE_ELEMENT)
1330 {
1331 reader->current = node;
1332 return TRUE;
1333 }
1334 while ((ptr = list_next( &reader->root->children, &node->entry )))
1335 {
1336 struct node *next = LIST_ENTRY( ptr, struct node, entry );
1337 if (next->hdr.node.nodeType == WS_XML_NODE_TYPE_ELEMENT)
1338 {
1339 reader->current = next;
1340 return TRUE;
1341 }
1342 node = next;
1343 }
1344 return FALSE;
1345 }
1346
1347 static BOOL move_to_next_element( struct reader *reader )
1348 {
1349 struct list *ptr;
1350 struct node *node = reader->current;
1351
1352 while ((ptr = list_next( &node->parent->children, &node->entry )))
1353 {
1354 struct node *next = LIST_ENTRY( ptr, struct node, entry );
1355 if (next->hdr.node.nodeType == WS_XML_NODE_TYPE_ELEMENT)
1356 {
1357 reader->current = next;
1358 return TRUE;
1359 }
1360 node = next;
1361 }
1362 return FALSE;
1363 }
1364
1365 static BOOL move_to_prev_element( struct reader *reader )
1366 {
1367 struct list *ptr;
1368 struct node *node = reader->current;
1369
1370 while ((ptr = list_prev( &node->parent->children, &node->entry )))
1371 {
1372 struct node *prev = LIST_ENTRY( ptr, struct node, entry );
1373 if (prev->hdr.node.nodeType == WS_XML_NODE_TYPE_ELEMENT)
1374 {
1375 reader->current = prev;
1376 return TRUE;
1377 }
1378 node = prev;
1379 }
1380 return FALSE;
1381 }
1382
1383 static BOOL move_to_child_element( struct reader *reader )
1384 {
1385 struct list *ptr;
1386 struct node *node;
1387
1388 if (!(ptr = list_head( &reader->current->children ))) return FALSE;
1389 node = LIST_ENTRY( ptr, struct node, entry );
1390 if (node->hdr.node.nodeType == WS_XML_NODE_TYPE_ELEMENT)
1391 {
1392 reader->current = node;
1393 return TRUE;
1394 }
1395 while ((ptr = list_next( &reader->current->children, &node->entry )))
1396 {
1397 struct node *next = LIST_ENTRY( ptr, struct node, entry );
1398 if (next->hdr.node.nodeType == WS_XML_NODE_TYPE_ELEMENT)
1399 {
1400 reader->current = next;
1401 return TRUE;
1402 }
1403 node = next;
1404 }
1405 return FALSE;
1406 }
1407
1408 static HRESULT read_move_to( struct reader *reader, WS_MOVE_TO move, BOOL *found )
1409 {
1410 struct list *ptr;
1411 BOOL success = FALSE;
1412 HRESULT hr = S_OK;
1413
1414 if (!read_end_of_data( reader ))
1415 {
1416 while (reader->state != READER_STATE_EOF && (hr = read_node( reader )) == S_OK) { /* nothing */ };
1417 if (hr != S_OK) return hr;
1418 }
1419 switch (move)
1420 {
1421 case WS_MOVE_TO_ROOT_ELEMENT:
1422 success = move_to_root_element( reader );
1423 break;
1424
1425 case WS_MOVE_TO_NEXT_ELEMENT:
1426 success = move_to_next_element( reader );
1427 break;
1428
1429 case WS_MOVE_TO_PREVIOUS_ELEMENT:
1430 success = move_to_prev_element( reader );
1431 break;
1432
1433 case WS_MOVE_TO_CHILD_ELEMENT:
1434 success = move_to_child_element( reader );
1435 break;
1436
1437 case WS_MOVE_TO_FIRST_NODE:
1438 if ((ptr = list_head( &reader->current->parent->children )))
1439 {
1440 reader->current = LIST_ENTRY( ptr, struct node, entry );
1441 success = TRUE;
1442 }
1443 break;
1444
1445 case WS_MOVE_TO_NEXT_NODE:
1446 if ((ptr = list_next( &reader->current->parent->children, &reader->current->entry )))
1447 {
1448 reader->current = LIST_ENTRY( ptr, struct node, entry );
1449 success = TRUE;
1450 }
1451 break;
1452
1453 case WS_MOVE_TO_PREVIOUS_NODE:
1454 if ((ptr = list_prev( &reader->current->parent->children, &reader->current->entry )))
1455 {
1456 reader->current = LIST_ENTRY( ptr, struct node, entry );
1457 success = TRUE;
1458 }
1459 break;
1460
1461 case WS_MOVE_TO_CHILD_NODE:
1462 if ((ptr = list_head( &reader->current->children )))
1463 {
1464 reader->current = LIST_ENTRY( ptr, struct node, entry );
1465 success = TRUE;
1466 }
1467 break;
1468
1469 case WS_MOVE_TO_BOF:
1470 reader->current = reader->root;
1471 success = TRUE;
1472 break;
1473
1474 case WS_MOVE_TO_EOF:
1475 if ((ptr = list_tail( &reader->root->children )))
1476 {
1477 reader->current = LIST_ENTRY( ptr, struct node, entry );
1478 success = TRUE;
1479 }
1480 break;
1481
1482 default:
1483 FIXME( "unhandled move %u\n", move );
1484 return E_NOTIMPL;
1485 }
1486
1487 if (found)
1488 {
1489 *found = success;
1490 return S_OK;
1491 }
1492 return success ? S_OK : WS_E_INVALID_FORMAT;
1493 }
1494
1495 /**************************************************************************
1496 * WsMoveReader [webservices.@]
1497 */
1498 HRESULT WINAPI WsMoveReader( WS_XML_READER *handle, WS_MOVE_TO move, BOOL *found, WS_ERROR *error )
1499 {
1500 struct reader *reader = (struct reader *)handle;
1501
1502 TRACE( "%p %u %p %p\n", handle, move, found, error );
1503 if (error) FIXME( "ignoring error parameter\n" );
1504
1505 if (!reader) return E_INVALIDARG;
1506 if (!reader->input_type) return WS_E_INVALID_OPERATION;
1507
1508 return read_move_to( reader, move, found );
1509 }
1510
1511 /**************************************************************************
1512 * WsReadStartAttribute [webservices.@]
1513 */
1514 HRESULT WINAPI WsReadStartAttribute( WS_XML_READER *handle, ULONG index, WS_ERROR *error )
1515 {
1516 struct reader *reader = (struct reader *)handle;
1517 WS_XML_ELEMENT_NODE *elem;
1518
1519 TRACE( "%p %u %p\n", handle, index, error );
1520 if (error) FIXME( "ignoring error parameter\n" );
1521
1522 if (!reader) return E_INVALIDARG;
1523
1524 elem = &reader->current->hdr;
1525 if (reader->state != READER_STATE_STARTELEMENT || index >= elem->attributeCount)
1526 return WS_E_INVALID_FORMAT;
1527
1528 reader->current_attr = index;
1529 reader->state = READER_STATE_STARTATTRIBUTE;
1530 return S_OK;
1531 }
1532
1533 /**************************************************************************
1534 * WsReadEndAttribute [webservices.@]
1535 */
1536 HRESULT WINAPI WsReadEndAttribute( WS_XML_READER *handle, WS_ERROR *error )
1537 {
1538 struct reader *reader = (struct reader *)handle;
1539
1540 TRACE( "%p %p\n", handle, error );
1541 if (error) FIXME( "ignoring error parameter\n" );
1542
1543 if (!reader) return E_INVALIDARG;
1544
1545 if (reader->state != READER_STATE_STARTATTRIBUTE)
1546 return WS_E_INVALID_FORMAT;
1547
1548 reader->state = READER_STATE_STARTELEMENT;
1549 return S_OK;
1550 }
1551
1552 static WCHAR *xmltext_to_widechar( WS_HEAP *heap, const WS_XML_TEXT *text )
1553 {
1554 WCHAR *ret;
1555
1556 switch (text->textType)
1557 {
1558 case WS_XML_TEXT_TYPE_UTF8:
1559 {
1560 const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text;
1561 int len = MultiByteToWideChar( CP_UTF8, 0, (char *)utf8->value.bytes, utf8->value.length, NULL, 0 );
1562 if (!(ret = ws_alloc( heap, (len + 1) * sizeof(WCHAR) ))) return NULL;
1563 MultiByteToWideChar( CP_UTF8, 0, (char *)utf8->value.bytes, utf8->value.length, ret, len );
1564 ret[len] = 0;
1565 break;
1566 }
1567 default:
1568 FIXME( "unhandled type %u\n", text->textType );
1569 return NULL;
1570 }
1571
1572 return ret;
1573 }
1574
1575 #define MAX_INT8 0x7f
1576 #define MIN_INT8 (-MAX_INT8 - 1)
1577 #define MAX_INT16 0x7fff
1578 #define MIN_INT16 (-MAX_INT16 - 1)
1579 #define MAX_INT32 0x7fffffff
1580 #define MIN_INT32 (-MAX_INT32 - 1)
1581 #define MAX_INT64 (((INT64)0x7fffffff << 32) | 0xffffffff)
1582 #define MIN_INT64 (-MAX_INT64 - 1)
1583 #define MAX_UINT8 0xff
1584 #define MAX_UINT16 0xffff
1585 #define MAX_UINT32 0xffffffff
1586 #define MAX_UINT64 (((UINT64)0xffffffff << 32) | 0xffffffff)
1587
1588 static HRESULT str_to_int64( const unsigned char *str, ULONG len, INT64 min, INT64 max, INT64 *ret )
1589 {
1590 BOOL negative = FALSE;
1591 const unsigned char *ptr = str;
1592
1593 *ret = 0;
1594 while (len && read_isspace( *ptr )) { ptr++; len--; }
1595 while (len && read_isspace( ptr[len - 1] )) { len--; }
1596 if (!len) return WS_E_INVALID_FORMAT;
1597
1598 if (*ptr == '-')
1599 {
1600 negative = TRUE;
1601 ptr++;
1602 len--;
1603 }
1604 if (!len) return WS_E_INVALID_FORMAT;
1605
1606 while (len--)
1607 {
1608 int val;
1609
1610 if (!isdigit( *ptr )) return WS_E_INVALID_FORMAT;
1611 val = *ptr - '0';
1612 if (negative) val = -val;
1613
1614 if ((!negative && (*ret > max / 10 || *ret * 10 > max - val)) ||
1615 (negative && (*ret < min / 10 || *ret * 10 < min - val)))
1616 {
1617 return WS_E_NUMERIC_OVERFLOW;
1618 }
1619 *ret = *ret * 10 + val;
1620 ptr++;
1621 }
1622
1623 return S_OK;
1624 }
1625
1626 static HRESULT str_to_uint64( const unsigned char *str, ULONG len, UINT64 max, UINT64 *ret )
1627 {
1628 const unsigned char *ptr = str;
1629
1630 *ret = 0;
1631 while (len && read_isspace( *ptr )) { ptr++; len--; }
1632 while (len && read_isspace( ptr[len - 1] )) { len--; }
1633 if (!len) return WS_E_INVALID_FORMAT;
1634
1635 while (len--)
1636 {
1637 unsigned int val;
1638
1639 if (!isdigit( *ptr )) return WS_E_INVALID_FORMAT;
1640 val = *ptr - '0';
1641
1642 if ((*ret > max / 10 || *ret * 10 > max - val)) return WS_E_NUMERIC_OVERFLOW;
1643 *ret = *ret * 10 + val;
1644 ptr++;
1645 }
1646
1647 return S_OK;
1648 }
1649
1650 static HRESULT read_get_node_text( struct reader *reader, WS_XML_UTF8_TEXT **ret )
1651 {
1652 WS_XML_TEXT_NODE *text;
1653
1654 if (reader->current->hdr.node.nodeType != WS_XML_NODE_TYPE_TEXT)
1655 return WS_E_INVALID_FORMAT;
1656
1657 text = (WS_XML_TEXT_NODE *)&reader->current->hdr.node;
1658 if (text->text->textType != WS_XML_TEXT_TYPE_UTF8)
1659 {
1660 FIXME( "text type %u not supported\n", text->text->textType );
1661 return E_NOTIMPL;
1662 }
1663 *ret = (WS_XML_UTF8_TEXT *)text->text;
1664 return S_OK;
1665 }
1666
1667 static HRESULT read_get_attribute_text( struct reader *reader, WS_XML_UTF8_TEXT **ret )
1668 {
1669 WS_XML_ELEMENT_NODE *elem = &reader->current->hdr;
1670 WS_XML_ATTRIBUTE *attr;
1671
1672 if (reader->current->hdr.node.nodeType != WS_XML_NODE_TYPE_ELEMENT ||
1673 reader->current_attr >= elem->attributeCount) return WS_E_INVALID_FORMAT;
1674
1675 attr = elem->attributes[reader->current_attr];
1676 if (attr->value->textType != WS_XML_TEXT_TYPE_UTF8)
1677 {
1678 FIXME( "text type %u not supported\n", attr->value->textType );
1679 return E_NOTIMPL;
1680 }
1681 *ret = (WS_XML_UTF8_TEXT *)attr->value;
1682 reader->current_attr++;
1683 return S_OK;
1684 }
1685
1686 static BOOL find_attribute( struct reader *reader, const WS_XML_STRING *localname,
1687 const WS_XML_STRING *ns, ULONG *index )
1688 {
1689 ULONG i;
1690 WS_XML_ELEMENT_NODE *elem = &reader->current->hdr;
1691
1692 if (!localname)
1693 {
1694 *index = reader->current_attr;
1695 return TRUE;
1696 }
1697 for (i = 0; i < elem->attributeCount; i++)
1698 {
1699 const WS_XML_STRING *localname2 = elem->attributes[i]->localName;
1700 const WS_XML_STRING *ns2 = elem->attributes[i]->ns;
1701
1702 if (!cmp_name( localname->bytes, localname->length, localname2->bytes, localname2->length ) &&
1703 !cmp_name( ns->bytes, ns->length, ns2->bytes, ns2->length ))
1704 {
1705 *index = i;
1706 return TRUE;
1707 }
1708 }
1709 return FALSE;
1710 }
1711
1712 /**************************************************************************
1713 * WsFindAttribute [webservices.@]
1714 */
1715 HRESULT WINAPI WsFindAttribute( WS_XML_READER *handle, const WS_XML_STRING *localname,
1716 const WS_XML_STRING *ns, BOOL required, ULONG *index,
1717 WS_ERROR *error )
1718 {
1719 struct reader *reader = (struct reader *)handle;
1720
1721 TRACE( "%p %s %s %d %p %p\n", handle, debugstr_xmlstr(localname), debugstr_xmlstr(ns),
1722 required, index, error );
1723 if (error) FIXME( "ignoring error parameter\n" );
1724
1725 if (!reader || !localname || !ns || !index) return E_INVALIDARG;
1726
1727 if (reader->current->hdr.node.nodeType != WS_XML_NODE_TYPE_ELEMENT)
1728 return WS_E_INVALID_OPERATION;
1729
1730 if (!find_attribute( reader, localname, ns, index ))
1731 {
1732 if (required) return WS_E_INVALID_FORMAT;
1733 *index = ~0u;
1734 return S_FALSE;
1735 }
1736 return S_OK;
1737 }
1738
1739 static HRESULT read_type_bool( struct reader *reader, WS_TYPE_MAPPING mapping,
1740 const WS_BOOL_DESCRIPTION *desc, BOOL *ret )
1741 {
1742 WS_XML_UTF8_TEXT *utf8;
1743 HRESULT hr;
1744 ULONG len;
1745
1746 if (desc)
1747 {
1748 FIXME( "description not supported\n" );
1749 return E_NOTIMPL;
1750 }
1751 switch (mapping)
1752 {
1753 case WS_ATTRIBUTE_TYPE_MAPPING:
1754 if ((hr = read_get_attribute_text( reader, &utf8 )) != S_OK) return hr;
1755 len = utf8->value.length;
1756 break;
1757
1758 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
1759 if ((hr = read_get_node_text( reader, &utf8 )) != S_OK) return hr;
1760 len = utf8->value.length;
1761 break;
1762
1763 default:
1764 FIXME( "mapping %u not supported\n", mapping );
1765 return E_NOTIMPL;
1766 }
1767
1768 if (len == 4 && !memcmp( utf8->value.bytes, "true", 4 )) *ret = TRUE;
1769 else if (len == 1 && !memcmp( utf8->value.bytes, "1", 1 )) *ret = TRUE;
1770 else if (len == 5 && !memcmp( utf8->value.bytes, "false", 5 )) *ret = FALSE;
1771 else if (len == 1 && !memcmp( utf8->value.bytes, "0", 1 )) *ret = FALSE;
1772 else return WS_E_INVALID_FORMAT;
1773
1774 return S_OK;
1775 }
1776
1777 static HRESULT read_type_int8( struct reader *reader, WS_TYPE_MAPPING mapping,
1778 const WS_INT8_DESCRIPTION *desc, INT8 *ret )
1779 {
1780 WS_XML_UTF8_TEXT *utf8;
1781 HRESULT hr;
1782 INT64 val;
1783
1784 if (desc)
1785 {
1786 FIXME( "description not supported\n" );
1787 return E_NOTIMPL;
1788 }
1789 switch (mapping)
1790 {
1791 case WS_ATTRIBUTE_TYPE_MAPPING:
1792 if ((hr = read_get_attribute_text( reader, &utf8 )) != S_OK) return hr;
1793 break;
1794
1795 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
1796 if ((hr = read_get_node_text( reader, &utf8 )) != S_OK) return hr;
1797 break;
1798
1799 default:
1800 FIXME( "mapping %u not supported\n", mapping );
1801 return E_NOTIMPL;
1802 }
1803
1804 if ((hr = str_to_int64( utf8->value.bytes, utf8->value.length, MIN_INT8, MAX_INT8, &val )) != S_OK)
1805 return hr;
1806
1807 *ret = val;
1808 return S_OK;
1809 }
1810
1811 static HRESULT read_type_int16( struct reader *reader, WS_TYPE_MAPPING mapping,
1812 const WS_INT16_DESCRIPTION *desc, INT16 *ret )
1813 {
1814 WS_XML_UTF8_TEXT *utf8;
1815 HRESULT hr;
1816 INT64 val;
1817
1818 if (desc)
1819 {
1820 FIXME( "description not supported\n" );
1821 return E_NOTIMPL;
1822 }
1823 switch (mapping)
1824 {
1825 case WS_ATTRIBUTE_TYPE_MAPPING:
1826 if ((hr = read_get_attribute_text( reader, &utf8 )) != S_OK) return hr;
1827 break;
1828
1829 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
1830 if ((hr = read_get_node_text( reader, &utf8 )) != S_OK) return hr;
1831 break;
1832
1833 default:
1834 FIXME( "mapping %u not supported\n", mapping );
1835 return E_NOTIMPL;
1836 }
1837
1838 if ((hr = str_to_int64( utf8->value.bytes, utf8->value.length, MIN_INT16, MAX_INT16, &val )) != S_OK)
1839 return hr;
1840
1841 *ret = val;
1842 return S_OK;
1843 }
1844
1845 static HRESULT read_type_int32( struct reader *reader, WS_TYPE_MAPPING mapping,
1846 const WS_INT32_DESCRIPTION *desc, INT32 *ret )
1847 {
1848 WS_XML_UTF8_TEXT *utf8;
1849 HRESULT hr;
1850 INT64 val;
1851
1852 if (desc)
1853 {
1854 FIXME( "description not supported\n" );
1855 return E_NOTIMPL;
1856 }
1857 switch (mapping)
1858 {
1859 case WS_ATTRIBUTE_TYPE_MAPPING:
1860 if ((hr = read_get_attribute_text( reader, &utf8 )) != S_OK) return hr;
1861 break;
1862
1863 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
1864 if ((hr = read_get_node_text( reader, &utf8 )) != S_OK) return hr;
1865 break;
1866
1867 default:
1868 FIXME( "mapping %u not supported\n", mapping );
1869 return E_NOTIMPL;
1870 }
1871
1872 if ((hr = str_to_int64( utf8->value.bytes, utf8->value.length, MIN_INT32, MAX_INT32, &val )) != S_OK)
1873 return hr;
1874
1875 *ret = val;
1876 return S_OK;
1877 }
1878
1879 static HRESULT read_type_int64( struct reader *reader, WS_TYPE_MAPPING mapping,
1880 const WS_INT64_DESCRIPTION *desc, INT64 *ret )
1881 {
1882 WS_XML_UTF8_TEXT *utf8;
1883 HRESULT hr;
1884 INT64 val;
1885
1886 if (desc)
1887 {
1888 FIXME( "description not supported\n" );
1889 return E_NOTIMPL;
1890 }
1891 switch (mapping)
1892 {
1893 case WS_ATTRIBUTE_TYPE_MAPPING:
1894 if ((hr = read_get_attribute_text( reader, &utf8 )) != S_OK) return hr;
1895 break;
1896
1897 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
1898 if ((hr = read_get_node_text( reader, &utf8 )) != S_OK) return hr;
1899 break;
1900
1901 default:
1902 FIXME( "mapping %u not supported\n", mapping );
1903 return E_NOTIMPL;
1904 }
1905
1906 if ((hr = str_to_int64( utf8->value.bytes, utf8->value.length, MIN_INT64, MAX_INT64, &val )) != S_OK)
1907 return hr;
1908
1909 *ret = val;
1910 return S_OK;
1911 }
1912
1913 static HRESULT read_type_uint8( struct reader *reader, WS_TYPE_MAPPING mapping,
1914 const WS_UINT8_DESCRIPTION *desc, UINT8 *ret )
1915 {
1916 WS_XML_UTF8_TEXT *utf8;
1917 HRESULT hr;
1918 UINT64 val;
1919
1920 if (desc)
1921 {
1922 FIXME( "description not supported\n" );
1923 return E_NOTIMPL;
1924 }
1925 switch (mapping)
1926 {
1927 case WS_ATTRIBUTE_TYPE_MAPPING:
1928 if ((hr = read_get_attribute_text( reader, &utf8 )) != S_OK) return hr;
1929 break;
1930
1931 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
1932 if ((hr = read_get_node_text( reader, &utf8 )) != S_OK) return hr;
1933 break;
1934
1935 default:
1936 FIXME( "mapping %u not supported\n", mapping );
1937 return E_NOTIMPL;
1938 }
1939
1940 if ((hr = str_to_uint64( utf8->value.bytes, utf8->value.length, MAX_UINT8, &val )) != S_OK)
1941 return hr;
1942
1943 *ret = val;
1944 return S_OK;
1945 }
1946
1947 static HRESULT read_type_uint16( struct reader *reader, WS_TYPE_MAPPING mapping,
1948 const WS_UINT16_DESCRIPTION *desc, UINT16 *ret )
1949 {
1950 WS_XML_UTF8_TEXT *utf8;
1951 HRESULT hr;
1952 UINT64 val;
1953
1954 if (desc)
1955 {
1956 FIXME( "description not supported\n" );
1957 return E_NOTIMPL;
1958 }
1959 switch (mapping)
1960 {
1961 case WS_ATTRIBUTE_TYPE_MAPPING:
1962 if ((hr = read_get_attribute_text( reader, &utf8 )) != S_OK) return hr;
1963 break;
1964
1965 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
1966 if ((hr = read_get_node_text( reader, &utf8 )) != S_OK) return hr;
1967 break;
1968
1969 default:
1970 FIXME( "mapping %u not supported\n", mapping );
1971 return E_NOTIMPL;
1972 }
1973
1974 if ((hr = str_to_uint64( utf8->value.bytes, utf8->value.length, MAX_UINT16, &val )) != S_OK)
1975 return hr;
1976
1977 *ret = val;
1978 return S_OK;
1979 }
1980
1981 static HRESULT read_type_uint32( struct reader *reader, WS_TYPE_MAPPING mapping,
1982 const WS_UINT32_DESCRIPTION *desc, UINT32 *ret )
1983 {
1984 WS_XML_UTF8_TEXT *utf8;
1985 HRESULT hr;
1986 UINT64 val;
1987
1988 if (desc)
1989 {
1990 FIXME( "description not supported\n" );
1991 return E_NOTIMPL;
1992 }
1993 switch (mapping)
1994 {
1995 case WS_ATTRIBUTE_TYPE_MAPPING:
1996 if ((hr = read_get_attribute_text( reader, &utf8 )) != S_OK) return hr;
1997 break;
1998
1999 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
2000 if ((hr = read_get_node_text( reader, &utf8 )) != S_OK) return hr;
2001 break;
2002
2003 default:
2004 FIXME( "mapping %u not supported\n", mapping );
2005 return E_NOTIMPL;
2006 }
2007
2008 if ((hr = str_to_uint64( utf8->value.bytes, utf8->value.length, MAX_UINT32, &val )) != S_OK)
2009 return hr;
2010
2011 *ret = val;
2012 return S_OK;
2013 }
2014
2015 static HRESULT read_type_uint64( struct reader *reader, WS_TYPE_MAPPING mapping,
2016 const WS_UINT64_DESCRIPTION *desc, UINT64 *ret )
2017 {
2018 WS_XML_UTF8_TEXT *utf8;
2019 HRESULT hr;
2020 UINT64 val;
2021
2022 if (desc)
2023 {
2024 FIXME( "description not supported\n" );
2025 return E_NOTIMPL;
2026 }
2027 switch (mapping)
2028 {
2029 case WS_ATTRIBUTE_TYPE_MAPPING:
2030 if ((hr = read_get_attribute_text( reader, &utf8 )) != S_OK) return hr;
2031 break;
2032
2033 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
2034 if ((hr = read_get_node_text( reader, &utf8 )) != S_OK) return hr;
2035 break;
2036
2037 default:
2038 FIXME( "mapping %u not supported\n", mapping );
2039 return E_NOTIMPL;
2040 }
2041
2042 if ((hr = str_to_uint64( utf8->value.bytes, utf8->value.length, MAX_UINT64, &val )) != S_OK)
2043 return hr;
2044
2045 *ret = val;
2046 return S_OK;
2047 }
2048
2049 static HRESULT read_type_wsz( struct reader *reader, WS_TYPE_MAPPING mapping,
2050 const WS_WSZ_DESCRIPTION *desc, WS_HEAP *heap, WCHAR **ret )
2051 {
2052 WS_XML_UTF8_TEXT *utf8;
2053 HRESULT hr;
2054 WCHAR *str;
2055
2056 if (desc)
2057 {
2058 FIXME( "description not supported\n" );
2059 return E_NOTIMPL;
2060 }
2061 switch (mapping)
2062 {
2063 case WS_ATTRIBUTE_TYPE_MAPPING:
2064 if ((hr = read_get_attribute_text( reader, &utf8 )) != S_OK) return hr;
2065 break;
2066
2067 case WS_ELEMENT_TYPE_MAPPING:
2068 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
2069 if ((hr = read_get_node_text( reader, &utf8 )) != S_OK) return hr;
2070 break;
2071
2072 default:
2073 FIXME( "mapping %u not supported\n", mapping );
2074 return E_NOTIMPL;
2075 }
2076
2077 if (!(str = xmltext_to_widechar( heap, &utf8->text ))) return WS_E_QUOTA_EXCEEDED;
2078 *ret = str;
2079 return S_OK;
2080 }
2081
2082 static HRESULT read_type_struct( struct reader *, WS_TYPE_MAPPING, const WS_STRUCT_DESCRIPTION *,
2083 WS_HEAP *, void ** );
2084
2085 static HRESULT read_type_struct_field( struct reader *reader, const WS_FIELD_DESCRIPTION *desc,
2086 WS_HEAP *heap, char *buf )
2087 {
2088 char *ptr = buf + desc->offset;
2089 WS_TYPE_MAPPING mapping;
2090 HRESULT hr;
2091
2092 if (desc->options && desc->options != WS_FIELD_POINTER &&
2093 desc->options != WS_FIELD_OPTIONAL &&
2094 desc->options != (WS_FIELD_POINTER | WS_FIELD_OPTIONAL))
2095 {
2096 FIXME( "options 0x%x not supported\n", desc->options );
2097 return E_NOTIMPL;
2098 }
2099
2100 switch (desc->mapping)
2101 {
2102 case WS_ATTRIBUTE_FIELD_MAPPING:
2103 mapping = WS_ATTRIBUTE_TYPE_MAPPING;
2104 break;
2105
2106 case WS_ELEMENT_FIELD_MAPPING:
2107 mapping = WS_ELEMENT_TYPE_MAPPING;
2108 break;
2109
2110 default:
2111 FIXME( "unhandled field mapping %u\n", desc->mapping );
2112 return E_NOTIMPL;
2113 }
2114
2115 switch (desc->type)
2116 {
2117 case WS_STRUCT_TYPE:
2118 hr = read_type_struct( reader, mapping, desc->typeDescription, heap, (void **)ptr );
2119 break;
2120
2121 case WS_BOOL_TYPE:
2122 hr = read_type_bool( reader, mapping, desc->typeDescription, (BOOL *)ptr );
2123 break;
2124
2125 case WS_INT8_TYPE:
2126 hr = read_type_int8( reader, mapping, desc->typeDescription, (INT8 *)ptr );
2127 break;
2128
2129 case WS_INT16_TYPE:
2130 hr = read_type_int16( reader, mapping, desc->typeDescription, (INT16 *)ptr );
2131 break;
2132
2133 case WS_INT32_TYPE:
2134 hr = read_type_int32( reader, mapping, desc->typeDescription, (INT32 *)ptr );
2135 break;
2136
2137 case WS_INT64_TYPE:
2138 hr = read_type_int64( reader, mapping, desc->typeDescription, (INT64 *)ptr );
2139 break;
2140
2141 case WS_UINT8_TYPE:
2142 hr = read_type_uint8( reader, mapping, desc->typeDescription, (UINT8 *)ptr );
2143 break;
2144
2145 case WS_UINT16_TYPE:
2146 hr = read_type_uint16( reader, mapping, desc->typeDescription, (UINT16 *)ptr );
2147 break;
2148
2149 case WS_UINT32_TYPE:
2150 hr = read_type_uint32( reader, mapping, desc->typeDescription, (UINT32 *)ptr );
2151 break;
2152
2153 case WS_UINT64_TYPE:
2154 hr = read_type_uint64( reader, mapping, desc->typeDescription, (UINT64 *)ptr );
2155 break;
2156
2157 case WS_WSZ_TYPE:
2158 hr = read_type_wsz( reader, mapping, desc->typeDescription, heap, (WCHAR **)ptr );
2159 break;
2160
2161 default:
2162 FIXME( "type %u not implemented\n", desc->type );
2163 return E_NOTIMPL;
2164 }
2165
2166 return hr;
2167 }
2168
2169 static HRESULT read_type_struct( struct reader *reader, WS_TYPE_MAPPING mapping,
2170 const WS_STRUCT_DESCRIPTION *desc, WS_HEAP *heap, void **ret )
2171 {
2172 ULONG i;
2173 HRESULT hr;
2174 char *buf;
2175
2176 if (!desc) return E_INVALIDARG;
2177
2178 if (desc->structOptions)
2179 {
2180 FIXME( "struct options 0x%x not supported\n", desc->structOptions );
2181 return E_NOTIMPL;
2182 }
2183
2184 switch (mapping)
2185 {
2186 case WS_ELEMENT_TYPE_MAPPING:
2187 if ((hr = read_to_startelement( reader, NULL )) != S_OK) return hr;
2188 break;
2189
2190 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
2191 if ((hr = read_to_startelement( reader, NULL )) != S_OK) return hr;
2192 if ((hr = read_startelement( reader )) != S_OK) return hr;
2193 break;
2194
2195 default:
2196 FIXME( "unhandled mapping %u\n", mapping );
2197 return E_NOTIMPL;
2198 }
2199
2200 if (!(buf = ws_alloc_zero( heap, desc->size ))) return WS_E_QUOTA_EXCEEDED;
2201
2202 for (i = 0; i < desc->fieldCount; i++)
2203 {
2204 if ((hr = read_type_struct_field( reader, desc->fields[i], heap, buf )) != S_OK)
2205 {
2206 ws_free( heap, buf );
2207 return hr;
2208 }
2209 }
2210
2211 switch (mapping)
2212 {
2213 case WS_ELEMENT_TYPE_MAPPING:
2214 if ((hr = read_endelement( reader )) != S_OK) return hr;
2215 break;
2216
2217 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
2218 if ((hr = read_endelement( reader )) != S_OK) return hr;
2219 if ((hr = read_node( reader )) != S_OK) return hr;
2220 if (reader->state != READER_STATE_EOF) return WS_E_INVALID_FORMAT;
2221 break;
2222
2223 default: break;
2224 }
2225
2226 *ret = buf;
2227 return S_OK;
2228 }
2229
2230 static HRESULT read_type( struct reader *reader, WS_TYPE_MAPPING mapping, WS_TYPE type,
2231 const void *desc, WS_READ_OPTION option, WS_HEAP *heap,
2232 void *value, ULONG size )
2233 {
2234 switch (type)
2235 {
2236 case WS_STRUCT_TYPE:
2237 {
2238 void **ptr = value;
2239 if (option != WS_READ_REQUIRED_POINTER || size != sizeof(*ptr))
2240 return E_INVALIDARG;
2241
2242 return read_type_struct( reader, mapping, desc, heap, ptr );
2243 }
2244 case WS_BOOL_TYPE:
2245 {
2246 BOOL *ptr = value;
2247 if (option != WS_READ_REQUIRED_VALUE)
2248 {
2249 FIXME( "read option %u not supported\n", option );
2250 return E_NOTIMPL;
2251 }
2252 if (size != sizeof(*ptr)) return E_INVALIDARG;
2253 return read_type_bool( reader, mapping, desc, ptr );
2254 }
2255 case WS_INT8_TYPE:
2256 {
2257 INT8 *ptr = value;
2258 if (option != WS_READ_REQUIRED_VALUE)
2259 {
2260 FIXME( "read option %u not supported\n", option );
2261 return E_NOTIMPL;
2262 }
2263 if (size != sizeof(*ptr)) return E_INVALIDARG;
2264 return read_type_int8( reader, mapping, desc, ptr );
2265 }
2266 case WS_INT16_TYPE:
2267 {
2268 INT16 *ptr = value;
2269 if (option != WS_READ_REQUIRED_VALUE)
2270 {
2271 FIXME( "read option %u not supported\n", option );
2272 return E_NOTIMPL;
2273 }
2274 if (size != sizeof(*ptr)) return E_INVALIDARG;
2275 return read_type_int16( reader, mapping, desc, ptr );
2276 }
2277 case WS_INT32_TYPE:
2278 {
2279 INT32 *ptr = value;
2280 if (option != WS_READ_REQUIRED_VALUE)
2281 {
2282 FIXME( "read option %u not supported\n", option );
2283 return E_NOTIMPL;
2284 }
2285 if (size != sizeof(*ptr)) return E_INVALIDARG;
2286 return read_type_int32( reader, mapping, desc, ptr );
2287 }
2288 case WS_INT64_TYPE:
2289 {
2290 INT64 *ptr = value;
2291 if (option != WS_READ_REQUIRED_VALUE)
2292 {
2293 FIXME( "read option %u not supported\n", option );
2294 return E_NOTIMPL;
2295 }
2296 if (size != sizeof(*ptr)) return E_INVALIDARG;
2297 return read_type_int64( reader, mapping, desc, ptr );
2298 }
2299 case WS_UINT8_TYPE:
2300 {
2301 UINT8 *ptr = value;
2302 if (option != WS_READ_REQUIRED_VALUE)
2303 {
2304 FIXME( "read option %u not supported\n", option );
2305 return E_NOTIMPL;
2306 }
2307 if (size != sizeof(*ptr)) return E_INVALIDARG;
2308 return read_type_uint8( reader, mapping, desc, ptr );
2309 }
2310 case WS_UINT16_TYPE:
2311 {
2312 UINT16 *ptr = value;
2313 if (option != WS_READ_REQUIRED_VALUE)
2314 {
2315 FIXME( "read option %u not supported\n", option );
2316 return E_NOTIMPL;
2317 }
2318 if (size != sizeof(*ptr)) return E_INVALIDARG;
2319 return read_type_uint16( reader, mapping, desc, ptr );
2320 }
2321 case WS_UINT32_TYPE:
2322 {
2323 UINT32 *ptr = value;
2324 if (option != WS_READ_REQUIRED_VALUE)
2325 {
2326 FIXME( "read option %u not supported\n", option );
2327 return E_NOTIMPL;
2328 }
2329 if (size != sizeof(*ptr)) return E_INVALIDARG;
2330 return read_type_uint32( reader, mapping, desc, ptr );
2331 }
2332 case WS_UINT64_TYPE:
2333 {
2334 UINT64 *ptr = value;
2335 if (option != WS_READ_REQUIRED_VALUE)
2336 {
2337 FIXME( "read option %u not supported\n", option );
2338 return E_NOTIMPL;
2339 }
2340 if (size != sizeof(*ptr)) return E_INVALIDARG;
2341 return read_type_uint64( reader, mapping, desc, ptr );
2342 }
2343 case WS_WSZ_TYPE:
2344 {
2345 WCHAR **ptr = value;
2346 if (option != WS_READ_REQUIRED_POINTER)
2347 {
2348 FIXME( "read option %u not supported\n", option );
2349 return E_NOTIMPL;
2350 }
2351 if (size != sizeof(*ptr)) return E_INVALIDARG;
2352 return read_type_wsz( reader, mapping, desc, heap, ptr );
2353 }
2354 default:
2355 FIXME( "type %u not supported\n", type );
2356 return E_NOTIMPL;
2357 }
2358 }
2359
2360 /**************************************************************************
2361 * WsReadType [webservices.@]
2362 */
2363 HRESULT WINAPI WsReadType( WS_XML_READER *handle, WS_TYPE_MAPPING mapping, WS_TYPE type,
2364 const void *desc, WS_READ_OPTION option, WS_HEAP *heap, void *value,
2365 ULONG size, WS_ERROR *error )
2366 {
2367 struct reader *reader = (struct reader *)handle;
2368
2369 TRACE( "%p %u %u %p %u %p %p %u %p\n", handle, mapping, type, desc, option, heap, value,
2370 size, error );
2371 if (error) FIXME( "ignoring error parameter\n" );
2372
2373 if (!reader || !value) return E_INVALIDARG;
2374
2375 return read_type( reader, mapping, type, desc, option, heap, value, size );
2376 }
2377
2378 /**************************************************************************
2379 * WsSetErrorProperty [webservices.@]
2380 */
2381 HRESULT WINAPI WsSetErrorProperty( WS_ERROR *handle, WS_ERROR_PROPERTY_ID id, const void *value,
2382 ULONG size )
2383 {
2384 struct error *error = (struct error *)handle;
2385
2386 TRACE( "%p %u %p %u\n", handle, id, value, size );
2387
2388 if (id == WS_ERROR_PROPERTY_LANGID) return WS_E_INVALID_OPERATION;
2389 return set_error_prop( error, id, value, size );
2390 }
2391
2392 static inline BOOL is_utf8( const unsigned char *data, ULONG size, ULONG *offset )
2393 {
2394 static const char bom[] = {0xef,0xbb,0xbf};
2395 const unsigned char *p = data;
2396
2397 return (size >= sizeof(bom) && !memcmp( p, bom, sizeof(bom) ) && (*offset = sizeof(bom))) ||
2398 (size > 2 && !(*offset = 0));
2399 }
2400
2401 static inline BOOL is_utf16le( const unsigned char *data, ULONG size, ULONG *offset )
2402 {
2403 static const char bom[] = {0xff,0xfe};
2404 const unsigned char *p = data;
2405
2406 return (size >= sizeof(bom) && !memcmp( p, bom, sizeof(bom) ) && (*offset = sizeof(bom))) ||
2407 (size >= 4 && p[0] == '<' && !p[1] && !(*offset = 0));
2408 }
2409
2410 static WS_CHARSET detect_charset( const unsigned char *data, ULONG size, ULONG *offset )
2411 {
2412 WS_CHARSET ret = 0;
2413
2414 /* FIXME: parse xml declaration */
2415
2416 if (is_utf16le( data, size, offset )) ret = WS_CHARSET_UTF16LE;
2417 else if (is_utf8( data, size, offset )) ret = WS_CHARSET_UTF8;
2418 else
2419 {
2420 FIXME( "charset not recognized\n" );
2421 return 0;
2422 }
2423
2424 TRACE( "detected charset %u\n", ret );
2425 return ret;
2426 }
2427
2428 static void set_input_buffer( struct reader *reader, const unsigned char *data, ULONG size )
2429 {
2430 reader->input_type = WS_XML_READER_INPUT_TYPE_BUFFER;
2431 reader->input_data = data;
2432 reader->input_size = size;
2433
2434 reader->read_size = reader->input_size;
2435 reader->read_pos = 0;
2436 reader->read_bufptr = reader->input_data;
2437 }
2438
2439 /**************************************************************************
2440 * WsSetInput [webservices.@]
2441 */
2442 HRESULT WINAPI WsSetInput( WS_XML_READER *handle, const WS_XML_READER_ENCODING *encoding,
2443 const WS_XML_READER_INPUT *input, const WS_XML_READER_PROPERTY *properties,
2444 ULONG count, WS_ERROR *error )
2445 {
2446 struct reader *reader = (struct reader *)handle;
2447 struct node *node;
2448 HRESULT hr;
2449 ULONG i, offset = 0;
2450
2451 TRACE( "%p %p %p %p %u %p\n", handle, encoding, input, properties, count, error );
2452 if (error) FIXME( "ignoring error parameter\n" );
2453
2454 if (!reader) return E_INVALIDARG;
2455
2456 for (i = 0; i < count; i++)
2457 {
2458 hr = set_reader_prop( reader, properties[i].id, properties[i].value, properties[i].valueSize );
2459 if (hr != S_OK) return hr;
2460 }
2461
2462 if ((hr = read_init_state( reader )) != S_OK) return hr;
2463
2464 switch (encoding->encodingType)
2465 {
2466 case WS_XML_READER_ENCODING_TYPE_TEXT:
2467 {
2468 WS_XML_READER_TEXT_ENCODING *text = (WS_XML_READER_TEXT_ENCODING *)encoding;
2469 WS_XML_READER_BUFFER_INPUT *buf = (WS_XML_READER_BUFFER_INPUT *)input;
2470 WS_CHARSET charset = text->charSet;
2471
2472 if (input->inputType != WS_XML_READER_INPUT_TYPE_BUFFER)
2473 {
2474 FIXME( "charset detection on input type %u not supported\n", input->inputType );
2475 return E_NOTIMPL;
2476 }
2477
2478 if (charset == WS_CHARSET_AUTO)
2479 charset = detect_charset( buf->encodedData, buf->encodedDataSize, &offset );
2480
2481 hr = set_reader_prop( reader, WS_XML_READER_PROPERTY_CHARSET, &charset, sizeof(charset) );
2482 if (hr != S_OK) return hr;
2483 break;
2484 }
2485 default:
2486 FIXME( "encoding type %u not supported\n", encoding->encodingType );
2487 return E_NOTIMPL;
2488 }
2489 switch (input->inputType)
2490 {
2491 case WS_XML_READER_INPUT_TYPE_BUFFER:
2492 {
2493 WS_XML_READER_BUFFER_INPUT *buf = (WS_XML_READER_BUFFER_INPUT *)input;
2494 set_input_buffer( reader, (const unsigned char *)buf->encodedData + offset, buf->encodedDataSize - offset );
2495 break;
2496 }
2497 default:
2498 FIXME( "input type %u not supported\n", input->inputType );
2499 return E_NOTIMPL;
2500 }
2501
2502 if (!(node = alloc_node( WS_XML_NODE_TYPE_BOF ))) return E_OUTOFMEMORY;
2503 read_insert_bof( reader, node );
2504 return S_OK;
2505 }
2506
2507 /**************************************************************************
2508 * WsSetInputToBuffer [webservices.@]
2509 */
2510 HRESULT WINAPI WsSetInputToBuffer( WS_XML_READER *handle, WS_XML_BUFFER *buffer,
2511 const WS_XML_READER_PROPERTY *properties, ULONG count,
2512 WS_ERROR *error )
2513 {
2514 struct reader *reader = (struct reader *)handle;
2515 struct xmlbuf *xmlbuf = (struct xmlbuf *)buffer;
2516 WS_CHARSET charset;
2517 struct node *node;
2518 HRESULT hr;
2519 ULONG i, offset = 0;
2520
2521 TRACE( "%p %p %p %u %p\n", handle, buffer, properties, count, error );
2522 if (error) FIXME( "ignoring error parameter\n" );
2523
2524 if (!reader || !xmlbuf) return E_INVALIDARG;
2525
2526 for (i = 0; i < count; i++)
2527 {
2528 hr = set_reader_prop( reader, properties[i].id, properties[i].value, properties[i].valueSize );
2529 if (hr != S_OK) return hr;
2530 }
2531
2532 if ((hr = read_init_state( reader )) != S_OK) return hr;
2533
2534 charset = detect_charset( xmlbuf->ptr, xmlbuf->size, &offset );
2535 hr = set_reader_prop( reader, WS_XML_READER_PROPERTY_CHARSET, &charset, sizeof(charset) );
2536 if (hr != S_OK) return hr;
2537
2538 set_input_buffer( reader, (const unsigned char *)xmlbuf->ptr + offset, xmlbuf->size - offset );
2539 if (!(node = alloc_node( WS_XML_NODE_TYPE_BOF ))) return E_OUTOFMEMORY;
2540 read_insert_bof( reader, node );
2541 return S_OK;
2542 }
2543
2544 /**************************************************************************
2545 * WsXmlStringEquals [webservices.@]
2546 */
2547 HRESULT WINAPI WsXmlStringEquals( const WS_XML_STRING *str1, const WS_XML_STRING *str2, WS_ERROR *error )
2548 {
2549 TRACE( "%s %s %p\n", debugstr_xmlstr(str1), debugstr_xmlstr(str2), error );
2550 if (error) FIXME( "ignoring error parameter\n" );
2551
2552 if (!str1 || !str2) return E_INVALIDARG;
2553
2554 if (str1->length != str2->length) return S_FALSE;
2555 if (!memcmp( str1->bytes, str2->bytes, str1->length )) return S_OK;
2556 return S_FALSE;
2557 }
Windows API implementation