dlls/webservices/reader.c

   1 /*
   2  * Copyright 2015 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
  29 WINE_DEFAULT_DEBUG_CHANNEL(webservices);
  30
  31 static inline void *heap_alloc( SIZE_T size )
  32 {
  33     return HeapAlloc( GetProcessHeap(), 0, size );
  34 }
  35
  36 static inline void *heap_alloc_zero( SIZE_T size )
  37 {
  38     return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size );
  39 }
  40
  41 static inline void *heap_realloc( void *mem, SIZE_T size )
  42 {
  43     return HeapReAlloc( GetProcessHeap(), 0, mem, size );
  44 }
  45
  46 static inline BOOL heap_free( void *mem )
  47 {
  48     return HeapFree( GetProcessHeap(), 0, mem );
  49 }
  50
  51 static const struct
  52 {
  53     ULONG size;
  54     BOOL  readonly;
  55 }
  56 error_props[] =
  57 {
  58     { sizeof(ULONG), TRUE },    /* WS_ERROR_PROPERTY_STRING_COUNT */
  59     { sizeof(ULONG), FALSE },   /* WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE */
  60     { sizeof(LANGID), FALSE }   /* WS_ERROR_PROPERTY_LANGID */
  61 };
  62
  63 struct error
  64 {
  65     ULONG             prop_count;
  66     WS_ERROR_PROPERTY prop[sizeof(error_props)/sizeof(error_props[0])];
  67 };
  68
  69 static struct error *alloc_error(void)
  70 {
  71     static const ULONG count = sizeof(error_props)/sizeof(error_props[0]);
  72     struct error *ret;
  73     ULONG i, size = sizeof(*ret) + count * sizeof(WS_ERROR_PROPERTY);
  74     char *ptr;
  75
  76     for (i = 0; i < count; i++) size += error_props[i].size;
  77     if (!(ret = heap_alloc_zero( size ))) return NULL;
  78
  79     ptr = (char *)&ret->prop[count];
  80     for (i = 0; i < count; i++)
  81     {
  82         ret->prop[i].value = ptr;
  83         ret->prop[i].valueSize = error_props[i].size;
  84         ptr += ret->prop[i].valueSize;
  85     }
  86     ret->prop_count = count;
  87     return ret;
  88 }
  89
  90 static HRESULT set_error_prop( struct error *error, WS_ERROR_PROPERTY_ID id, const void *value, ULONG size )
  91 {
  92     if (id >= error->prop_count || size != error_props[id].size || error_props[id].readonly)
  93         return E_INVALIDARG;
  94
  95     memcpy( error->prop[id].value, value, size );
  96     return S_OK;
  97 }
  98
  99 static HRESULT get_error_prop( struct error *error, WS_ERROR_PROPERTY_ID id, void *buf, ULONG size )
 100 {
 101     if (id >= error->prop_count || size != error_props[id].size)
 102         return E_INVALIDARG;
 103
 104     memcpy( buf, error->prop[id].value, error->prop[id].valueSize );
 105     return S_OK;
 106 }
 107
 108 /**************************************************************************
 109  *          WsCreateError               [webservices.@]
 110  */
 111 HRESULT WINAPI WsCreateError( const WS_ERROR_PROPERTY *properties, ULONG count, WS_ERROR **handle )
 112 {
 113     struct error *error;
 114     LANGID langid = GetUserDefaultUILanguage();
 115     HRESULT hr;
 116     ULONG i;
 117
 118     TRACE( "%p %u %p\n", properties, count, handle );
 119
 120     if (!handle) return E_INVALIDARG;
 121     if (!(error = alloc_error())) return E_OUTOFMEMORY;
 122
 123     set_error_prop( error, WS_ERROR_PROPERTY_LANGID, &langid, sizeof(langid) );
 124     for (i = 0; i < count; i++)
 125     {
 126         if (properties[i].id == WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE)
 127         {
 128             heap_free( error );
 129             return E_INVALIDARG;
 130         }
 131         hr = set_error_prop( error, properties[i].id, properties[i].value, properties[i].valueSize );
 132         if (hr != S_OK)
 133         {
 134             heap_free( error );
 135             return hr;
 136         }
 137     }
 138
 139     *handle = (WS_ERROR *)error;
 140     return S_OK;
 141 }
 142
 143 /**************************************************************************
 144  *          WsFreeError         [webservices.@]
 145  */
 146 void WINAPI WsFreeError( WS_ERROR *handle )
 147 {
 148     struct error *error = (struct error *)handle;
 149
 150     TRACE( "%p\n", handle );
 151     heap_free( error );
 152 }
 153
 154 static const struct
 155 {
 156     ULONG size;
 157     BOOL  readonly;
 158 }
 159 heap_props[] =
 160 {
 161     { sizeof(SIZE_T), FALSE }, /* WS_HEAP_PROPERTY_MAX_SIZE */
 162     { sizeof(SIZE_T), FALSE }, /* WS_HEAP_PROPERTY_TRIM_SIZE */
 163     { sizeof(SIZE_T), TRUE },  /* WS_HEAP_PROPERTY_REQUESTED_SIZE */
 164     { sizeof(SIZE_T), TRUE }   /* WS_HEAP_PROPERTY_ACTUAL_SIZE */
 165 };
 166
 167 struct heap
 168 {
 169     HANDLE           handle;
 170     ULONG            prop_count;
 171     WS_HEAP_PROPERTY prop[sizeof(heap_props)/sizeof(heap_props[0])];
 172 };
 173
 174 static struct heap *alloc_heap(void)
 175 {
 176     static const ULONG count = sizeof(heap_props)/sizeof(heap_props[0]);
 177     struct heap *ret;
 178     ULONG i, size = sizeof(*ret) + count * sizeof(WS_HEAP_PROPERTY);
 179     char *ptr;
 180
 181     for (i = 0; i < count; i++) size += heap_props[i].size;
 182     if (!(ret = heap_alloc_zero( size ))) return NULL;
 183
 184     ptr = (char *)&ret->prop[count];
 185     for (i = 0; i < count; i++)
 186     {
 187         ret->prop[i].value = ptr;
 188         ret->prop[i].valueSize = heap_props[i].size;
 189         ptr += ret->prop[i].valueSize;
 190     }
 191     ret->prop_count = count;
 192     return ret;
 193 }
 194
 195 static HRESULT set_heap_prop( struct heap *heap, WS_HEAP_PROPERTY_ID id, const void *value, ULONG size )
 196 {
 197     if (id >= heap->prop_count || size != heap_props[id].size || heap_props[id].readonly)
 198         return E_INVALIDARG;
 199
 200     memcpy( heap->prop[id].value, value, size );
 201     return S_OK;
 202 }
 203
 204 static HRESULT get_heap_prop( struct heap *heap, WS_HEAP_PROPERTY_ID id, void *buf, ULONG size )
 205 {
 206     if (id >= heap->prop_count || size != heap_props[id].size)
 207         return E_INVALIDARG;
 208
 209     memcpy( buf, heap->prop[id].value, heap->prop[id].valueSize );
 210     return S_OK;
 211 }
 212
 213 /**************************************************************************
 214  *          WsCreateHeap                [webservices.@]
 215  */
 216 HRESULT WINAPI WsCreateHeap( SIZE_T max_size, SIZE_T trim_size, const WS_HEAP_PROPERTY *properties,
 217                              ULONG count, WS_HEAP **handle, WS_ERROR *error )
 218 {
 219     struct heap *heap;
 220
 221     TRACE( "%u %u %p %u %p %p\n", (ULONG)max_size, (ULONG)trim_size, properties, count, handle, error );
 222     if (error) FIXME( "ignoring error parameter\n" );
 223
 224     if (!handle || count) return E_INVALIDARG;
 225     if (!(heap = alloc_heap())) return E_OUTOFMEMORY;
 226
 227     set_heap_prop( heap, WS_HEAP_PROPERTY_MAX_SIZE, &max_size, sizeof(max_size) );
 228     set_heap_prop( heap, WS_HEAP_PROPERTY_TRIM_SIZE, &trim_size, sizeof(trim_size) );
 229
 230     if (!(heap->handle = HeapCreate( 0, 0, max_size )))
 231     {
 232         heap_free( heap );
 233         return E_OUTOFMEMORY;
 234     }
 235
 236     *handle = (WS_HEAP *)heap;
 237     return S_OK;
 238 }
 239
 240 /**************************************************************************
 241  *          WsFreeHeap          [webservices.@]
 242  */
 243 void WINAPI WsFreeHeap( WS_HEAP *handle )
 244 {
 245     struct heap *heap = (struct heap *)handle;
 246
 247     TRACE( "%p\n", handle );
 248
 249     if (!heap) return;
 250     HeapDestroy( heap->handle );
 251     heap_free( heap );
 252 }
 253
 254 struct node
 255 {
 256     WS_XML_ELEMENT_NODE hdr;
 257     struct list entry;
 258 };
 259
 260 static struct node *alloc_node( WS_XML_NODE_TYPE type )
 261 {
 262     struct node *ret;
 263
 264     if (!(ret = heap_alloc_zero( sizeof(*ret) ))) return NULL;
 265     ret->hdr.node.nodeType = type;
 266     list_init( &ret->entry );
 267     return ret;
 268 }
 269
 270 static void free_node( struct node *node )
 271 {
 272     if (!node) return;
 273     switch (node->hdr.node.nodeType)
 274     {
 275     case WS_XML_NODE_TYPE_ELEMENT:
 276     {
 277         WS_XML_ELEMENT_NODE *elem = (WS_XML_ELEMENT_NODE *)node;
 278         heap_free( elem->prefix );
 279         heap_free( elem->localName );
 280         heap_free( elem->ns );
 281         break;
 282     }
 283     case WS_XML_NODE_TYPE_TEXT:
 284     {
 285         WS_XML_TEXT_NODE *text = (WS_XML_TEXT_NODE *)node;
 286         heap_free( text->text );
 287         break;
 288     }
 289     case WS_XML_NODE_TYPE_END_ELEMENT:
 290     case WS_XML_NODE_TYPE_EOF:
 291     case WS_XML_NODE_TYPE_BOF:
 292         break;
 293
 294     default:
 295         ERR( "unhandled type %u\n", node->hdr.node.nodeType );
 296         break;
 297     }
 298     heap_free( node );
 299 }
 300
 301 static void destroy_nodes( struct list *list )
 302 {
 303     struct list *ptr;
 304
 305     while ((ptr = list_head( list )))
 306     {
 307         struct node *node = LIST_ENTRY( ptr, struct node, entry );
 308         list_remove( &node->entry );
 309         free_node( node );
 310     }
 311 }
 312
 313 static const struct
 314 {
 315     ULONG size;
 316     BOOL  readonly;
 317 }
 318 reader_props[] =
 319 {
 320     { sizeof(ULONG), FALSE },      /* WS_XML_READER_PROPERTY_MAX_DEPTH */
 321     { sizeof(BOOL), FALSE },       /* WS_XML_READER_PROPERTY_ALLOW_FRAGMENT */
 322     { sizeof(ULONG), FALSE },      /* WS_XML_READER_PROPERTY_MAX_ATTRIBUTES */
 323     { sizeof(BOOL), FALSE },       /* WS_XML_READER_PROPERTY_READ_DECLARATION */
 324     { sizeof(WS_CHARSET), FALSE }, /* WS_XML_READER_PROPERTY_CHARSET */
 325     { sizeof(ULONGLONG), TRUE },   /* WS_XML_READER_PROPERTY_ROW */
 326     { sizeof(ULONGLONG), TRUE },   /* WS_XML_READER_PROPERTY_COLUMN */
 327     { sizeof(ULONG), FALSE },      /* WS_XML_READER_PROPERTY_UTF8_TRIM_SIZE */
 328     { sizeof(ULONG), FALSE },      /* WS_XML_READER_PROPERTY_STREAM_BUFFER_SIZE */
 329     { sizeof(BOOL), TRUE },        /* WS_XML_READER_PROPERTY_IN_ATTRIBUTE */
 330     { sizeof(ULONG), FALSE },      /* WS_XML_READER_PROPERTY_STREAM_MAX_ROOT_MIME_PART_SIZE */
 331     { sizeof(ULONG), FALSE },      /* WS_XML_READER_PROPERTY_STREAM_MAX_MIME_HEADERS_SIZE */
 332     { sizeof(ULONG), FALSE },      /* WS_XML_READER_PROPERTY_MAX_MIME_PARTS */
 333     { sizeof(BOOL), FALSE },       /* WS_XML_READER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES */
 334     { sizeof(ULONG), FALSE },      /* WS_XML_READER_PROPERTY_MAX_NAMESPACES */
 335 };
 336
 337 struct reader
 338 {
 339     ULONG                   read_size;
 340     ULONG                   read_pos;
 341     struct list             nodes;
 342     struct node            *current;
 343     const char             *input_data;
 344     ULONG                   input_size;
 345     ULONG                   prop_count;
 346     WS_XML_READER_PROPERTY  prop[sizeof(reader_props)/sizeof(reader_props[0])];
 347 };
 348
 349 static struct reader *alloc_reader(void)
 350 {
 351     static const ULONG count = sizeof(reader_props)/sizeof(reader_props[0]);
 352     struct reader *ret;
 353     ULONG i, size = sizeof(*ret) + count * sizeof(WS_XML_READER_PROPERTY);
 354     char *ptr;
 355
 356     for (i = 0; i < count; i++) size += reader_props[i].size;
 357     if (!(ret = heap_alloc_zero( size ))) return NULL;
 358
 359     ptr = (char *)&ret->prop[count];
 360     for (i = 0; i < count; i++)
 361     {
 362         ret->prop[i].value = ptr;
 363         ret->prop[i].valueSize = reader_props[i].size;
 364         ptr += ret->prop[i].valueSize;
 365     }
 366     ret->prop_count = count;
 367     return ret;
 368 }
 369
 370 static HRESULT set_reader_prop( struct reader *reader, WS_XML_READER_PROPERTY_ID id, const void *value, ULONG size )
 371 {
 372     if (id >= reader->prop_count || size != reader_props[id].size || reader_props[id].readonly)
 373         return E_INVALIDARG;
 374
 375     memcpy( reader->prop[id].value, value, size );
 376     return S_OK;
 377 }
 378
 379 static HRESULT get_reader_prop( struct reader *reader, WS_XML_READER_PROPERTY_ID id, void *buf, ULONG size )
 380 {
 381     if (id >= reader->prop_count || size != reader_props[id].size)
 382         return E_INVALIDARG;
 383
 384     memcpy( buf, reader->prop[id].value, reader->prop[id].valueSize );
 385     return S_OK;
 386 }
 387
 388 /**************************************************************************
 389  *          WsCreateReader              [webservices.@]
 390  */
 391 HRESULT WINAPI WsCreateReader( const WS_XML_READER_PROPERTY *properties, ULONG count,
 392                                WS_XML_READER **handle, WS_ERROR *error )
 393 {
 394     struct reader *reader;
 395     struct node *node;
 396     ULONG i, max_depth = 32, max_attrs = 128, max_ns = 32;
 397     WS_CHARSET charset = WS_CHARSET_UTF8;
 398     BOOL read_decl = TRUE;
 399     HRESULT hr;
 400
 401     TRACE( "%p %u %p %p\n", properties, count, handle, error );
 402     if (error) FIXME( "ignoring error parameter\n" );
 403
 404     if (!handle) return E_INVALIDARG;
 405     if (!(reader = alloc_reader())) return E_OUTOFMEMORY;
 406
 407     set_reader_prop( reader, WS_XML_READER_PROPERTY_MAX_DEPTH, &max_depth, sizeof(max_depth) );
 408     set_reader_prop( reader, WS_XML_READER_PROPERTY_MAX_ATTRIBUTES, &max_attrs, sizeof(max_attrs) );
 409     set_reader_prop( reader, WS_XML_READER_PROPERTY_READ_DECLARATION, &read_decl, sizeof(read_decl) );
 410     set_reader_prop( reader, WS_XML_READER_PROPERTY_CHARSET, &charset, sizeof(charset) );
 411     set_reader_prop( reader, WS_XML_READER_PROPERTY_MAX_NAMESPACES, &max_ns, sizeof(max_ns) );
 412
 413     for (i = 0; i < count; i++)
 414     {
 415         hr = set_reader_prop( reader, properties[i].id, properties[i].value, properties[i].valueSize );
 416         if (hr != S_OK)
 417         {
 418             heap_free( reader );
 419             return hr;
 420         }
 421     }
 422
 423     if (!(node = alloc_node( WS_XML_NODE_TYPE_EOF )))
 424     {
 425         heap_free( reader );
 426         return E_OUTOFMEMORY;
 427     }
 428     list_init( &reader->nodes );
 429     list_add_tail( &reader->nodes, &node->entry );
 430     reader->current = node;
 431
 432     *handle = (WS_XML_READER *)reader;
 433     return S_OK;
 434 }
 435
 436 /**************************************************************************
 437  *          WsFreeReader                [webservices.@]
 438  */
 439 void WINAPI WsFreeReader( WS_XML_READER *handle )
 440 {
 441     struct reader *reader = (struct reader *)handle;
 442
 443     TRACE( "%p\n", handle );
 444
 445     if (!reader) return;
 446     destroy_nodes( &reader->nodes );
 447     heap_free( reader );
 448 }
 449
 450 /**************************************************************************
 451  *          WsFillReader                [webservices.@]
 452  */
 453 HRESULT WINAPI WsFillReader( WS_XML_READER *handle, ULONG min_size, const WS_ASYNC_CONTEXT *ctx,
 454                              WS_ERROR *error )
 455 {
 456     struct reader *reader = (struct reader *)handle;
 457
 458     TRACE( "%p %u %p %p\n", handle, min_size, ctx, error );
 459     if (error) FIXME( "ignoring error parameter\n" );
 460
 461     if (!reader) return E_INVALIDARG;
 462
 463     /* FIXME: add support for stream input */
 464     reader->read_size = min( min_size, reader->input_size );
 465     reader->read_pos  = 0;
 466
 467     return S_OK;
 468 }
 469
 470 /**************************************************************************
 471  *          WsGetErrorProperty          [webservices.@]
 472  */
 473 HRESULT WINAPI WsGetErrorProperty( WS_ERROR *handle, WS_ERROR_PROPERTY_ID id, void *buf,
 474                                    ULONG size )
 475 {
 476     struct error *error = (struct error *)handle;
 477
 478     TRACE( "%p %u %p %u\n", handle, id, buf, size );
 479     return get_error_prop( error, id, buf, size );
 480 }
 481
 482 /**************************************************************************
 483  *          WsGetHeapProperty           [webservices.@]
 484  */
 485 HRESULT WINAPI WsGetHeapProperty( WS_HEAP *handle, WS_HEAP_PROPERTY_ID id, void *buf,
 486                                   ULONG size, WS_ERROR *error )
 487 {
 488     struct heap *heap = (struct heap *)handle;
 489
 490     TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
 491     if (error) FIXME( "ignoring error parameter\n" );
 492
 493     return get_heap_prop( heap, id, buf, size );
 494 }
 495
 496 /**************************************************************************
 497  *          WsGetReaderNode             [webservices.@]
 498  */
 499 HRESULT WINAPI WsGetReaderNode( WS_XML_READER *handle, const WS_XML_NODE **node,
 500                                 WS_ERROR *error )
 501 {
 502     struct reader *reader = (struct reader *)handle;
 503
 504     TRACE( "%p %p %p\n", handle, node, error );
 505     if (error) FIXME( "ignoring error parameter\n" );
 506
 507     if (!reader || !node) return E_INVALIDARG;
 508
 509     *node = &reader->current->hdr.node;
 510     return S_OK;
 511 }
 512
 513 /**************************************************************************
 514  *          WsGetReaderProperty         [webservices.@]
 515  */
 516 HRESULT WINAPI WsGetReaderProperty( WS_XML_READER *handle, WS_XML_READER_PROPERTY_ID id,
 517                                     void *buf, ULONG size, WS_ERROR *error )
 518 {
 519     struct reader *reader = (struct reader *)handle;
 520
 521     TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
 522     if (error) FIXME( "ignoring error parameter\n" );
 523
 524     if (!reader->input_data) return WS_E_INVALID_OPERATION;
 525     return get_reader_prop( reader, id, buf, size );
 526 }
 527
 528 /**************************************************************************
 529  *          WsSetErrorProperty          [webservices.@]
 530  */
 531 HRESULT WINAPI WsSetErrorProperty( WS_ERROR *handle, WS_ERROR_PROPERTY_ID id, const void *value,
 532                                    ULONG size )
 533 {
 534     struct error *error = (struct error *)handle;
 535
 536     TRACE( "%p %u %p %u\n", handle, id, value, size );
 537
 538     if (id == WS_ERROR_PROPERTY_LANGID) return WS_E_INVALID_OPERATION;
 539     return set_error_prop( error, id, value, size );
 540 }
 541
 542 /**************************************************************************
 543  *          WsSetInput          [webservices.@]
 544  */
 545 HRESULT WINAPI WsSetInput( WS_XML_READER *handle, const WS_XML_READER_ENCODING *encoding,
 546                            const WS_XML_READER_INPUT *input, const WS_XML_READER_PROPERTY *properties,
 547                            ULONG count, WS_ERROR *error )
 548 {
 549     struct reader *reader = (struct reader *)handle;
 550     struct node *node;
 551     HRESULT hr;
 552     ULONG i;
 553
 554     TRACE( "%p %p %p %p %u %p\n", handle, encoding, input, properties, count, error );
 555     if (error) FIXME( "ignoring error parameter\n" );
 556
 557     if (!reader) return E_INVALIDARG;
 558
 559     switch (encoding->encodingType)
 560     {
 561         case WS_XML_READER_ENCODING_TYPE_TEXT:
 562         {
 563             WS_XML_READER_TEXT_ENCODING *text = (WS_XML_READER_TEXT_ENCODING *)encoding;
 564             if (text->charSet != WS_CHARSET_UTF8)
 565             {
 566                 FIXME( "charset %u not supported\n", text->charSet );
 567                 return E_NOTIMPL;
 568             }
 569             break;
 570         }
 571         default:
 572             FIXME( "encoding type %u not supported\n", encoding->encodingType );
 573             return E_NOTIMPL;
 574     }
 575     switch (input->inputType)
 576     {
 577         case WS_XML_READER_INPUT_TYPE_BUFFER:
 578         {
 579             WS_XML_READER_BUFFER_INPUT *buf = (WS_XML_READER_BUFFER_INPUT *)input;
 580             reader->input_data = buf->encodedData;
 581             reader->input_size = buf->encodedDataSize;
 582             break;
 583         }
 584         default:
 585             FIXME( "input type %u not supported\n", input->inputType );
 586             return E_NOTIMPL;
 587     }
 588
 589     for (i = 0; i < count; i++)
 590     {
 591         hr = set_reader_prop( reader, properties[i].id, properties[i].value, properties[i].valueSize );
 592         if (hr != S_OK) return hr;
 593     }
 594
 595     if (!(node = alloc_node( WS_XML_NODE_TYPE_BOF ))) return E_OUTOFMEMORY;
 596     list_add_head( &reader->nodes, &node->entry );
 597     reader->current = node;
 598
 599     return S_OK;
 600 }