include/webservices.h

   1 /*
   2  * Copyright 2015 Nikolay Sivov 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 #ifndef __WINE_WEBSERVICES_H
  20 #define __WINE_WEBSERVICES_H
  21
  22 #ifdef __cplusplus
  23 extern "C" {
  24 #endif  /* __cplusplus */
  25
  26 typedef struct _WS_ERROR WS_ERROR;
  27 typedef struct _WS_HEAP WS_HEAP;
  28 typedef struct _WS_XML_BUFFER WS_XML_BUFFER;
  29 typedef struct _WS_XML_READER WS_XML_READER;
  30 typedef struct _WS_XML_WRITER WS_XML_WRITER;
  31 typedef struct _WS_PROXY_PROPERTY WS_PROXY_PROPERTY;
  32 typedef struct _WS_SECURITY_DESCRIPTION WS_SECURITY_DESCRIPTION;
  33 typedef struct _WS_CHANNEL_PROPERTY WS_CHANNEL_PROPERTY;
  34 typedef struct _WS_SERVICE_PROXY WS_SERVICE_PROXY;
  35 typedef struct _WS_SECURITY_BINDING_PROPERTY WS_SECURITY_BINDING_PROPERTY;
  36 typedef struct _WS_SECURITY_PROPERTY WS_SECURITY_PROPERTY;
  37 typedef struct _WS_SECURITY_PROPERTIES WS_SECURITY_PROPERTIES;
  38 typedef struct _WS_SECURITY_BINDING WS_SECURITY_BINDING;
  39 typedef struct _WS_CHANNEL WS_CHANNEL;
  40 typedef struct _WS_MESSAGE_PROPERTY WS_MESSAGE_PROPERTY;
  41 typedef struct _WS_MESSAGE_PROPERTIES WS_MESSAGE_PROPERTIES;
  42 typedef struct _WS_HTTP_BINDING_TEMPLATE WS_HTTP_BINDING_TEMPLATE;
  43 typedef struct _WS_HTTP_SSL_BINDING_TEMPLATE WS_HTTP_SSL_BINDING_TEMPLATE;
  44 typedef struct _WS_CHANNEL_PROPERTIES WS_CHANNEL_PROPERTIES;
  45 typedef struct _WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE;
  46 typedef struct _WS_SECURITY_BINDING_PROPERTIES WS_SECURITY_BINDING_PROPERTIES;
  47 typedef struct _WS_CERT_CREDENTIAL WS_CERT_CREDENTIAL;
  48 typedef struct _WS_ENDPOINT_ADDRESS WS_ENDPOINT_ADDRESS;
  49 typedef struct _WS_ENDPOINT_IDENTITY WS_ENDPOINT_IDENTITY;
  50 typedef struct _WS_ENUM_DESCRIPTION WS_ENUM_DESCRIPTION;
  51 typedef struct _WS_ENUM_VALUE WS_ENUM_VALUE;
  52 typedef struct _WS_HTTP_POLICY_DESCRIPTION WS_HTTP_POLICY_DESCRIPTION;
  53 typedef struct _WS_MESSAGE WS_MESSAGE;
  54 typedef struct _WS_MESSAGE_DESCRIPTION WS_MESSAGE_DESCRIPTION;
  55 typedef struct _WS_OPERATION_DESCRIPTION WS_OPERATION_DESCRIPTION;
  56 typedef struct _WS_PARAMETER_DESCRIPTION WS_PARAMETER_DESCRIPTION;
  57 typedef struct _WS_OPERATION_CONTEXT WS_OPERATION_CONTEXT;
  58 typedef struct _WS_CALL_PROPERTY WS_CALL_PROPERTY;
  59 typedef struct _WS_DOUBLE_DESCRIPTION WS_DOUBLE_DESCRIPTION;
  60 typedef struct _WS_DATETIME WS_DATETIME;
  61 typedef struct _WS_DATETIME_DESCRIPTION WS_DATETIME_DESCRIPTION;
  62 typedef struct _WS_GUID_DESCRIPTION WS_GUID_DESCRIPTION;
  63 typedef struct _WS_URL WS_URL;
  64 typedef struct _WS_HTTP_URL WS_HTTP_URL;
  65 typedef struct _WS_HTTPS_URL WS_HTTPS_URL;
  66 typedef struct _WS_NETTCP_URL WS_NETTCP_URL;
  67 typedef struct _WS_SOAPUDP_URL WS_SOAPUDP_URL;
  68 typedef struct _WS_NETPIPE_URL WS_NETPIPE_URL;
  69 typedef struct _WS_CUSTOM_CHANNEL_CALLBACKS WS_CUSTOM_CHANNEL_CALLBACKS;
  70 typedef struct _WS_CHANNEL_ENCODER WS_CHANNEL_ENCODER;
  71 typedef struct _WS_CHANNEL_DECODER WS_CHANNEL_DECODER;
  72 typedef struct _WS_CUSTOM_HTTP_PROXY WS_CUSTOM_HTTP_PROXY;
  73 typedef struct _WS_HTTP_MESSAGE_MAPPING WS_HTTP_MESSAGE_MAPPING;
  74 typedef struct _WS_HTTP_HEADER_MAPPING WS_HTTP_HEADER_MAPPING;
  75 typedef struct _WS_HTTP_REDIRECT_CALLBACK_CONTEXT WS_HTTP_REDIRECT_CALLBACK_CONTEXT;
  76 typedef struct _WS_XML_NODE_POSITION WS_XML_NODE_POSITION;
  77
  78 struct _WS_STRUCT_DESCRIPTION;
  79 struct _WS_XML_STRING;
  80
  81 typedef enum {
  82     WS_ERROR_PROPERTY_STRING_COUNT,
  83     WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE,
  84     WS_ERROR_PROPERTY_LANGID
  85 } WS_ERROR_PROPERTY_ID;
  86
  87 typedef struct _WS_ERROR_PROPERTY {
  88     WS_ERROR_PROPERTY_ID id;
  89     void                *value;
  90     ULONG                valueSize;
  91 } WS_ERROR_PROPERTY;
  92
  93 typedef enum {
  94     WS_HEAP_PROPERTY_MAX_SIZE,
  95     WS_HEAP_PROPERTY_TRIM_SIZE,
  96     WS_HEAP_PROPERTY_REQUESTED_SIZE,
  97     WS_HEAP_PROPERTY_ACTUAL_SIZE
  98 } WS_HEAP_PROPERTY_ID;
  99
 100 typedef struct _WS_HEAP_PROPERTY {
 101     WS_HEAP_PROPERTY_ID id;
 102     void               *value;
 103     ULONG               valueSize;
 104 } WS_HEAP_PROPERTY;
 105
 106 typedef ULONG WS_XML_BUFFER_PROPERTY_ID;
 107
 108 typedef struct _WS_XML_BUFFER_PROPERTY {
 109     WS_XML_BUFFER_PROPERTY_ID id;
 110     void                     *value;
 111     ULONG                     valueSize;
 112 } WS_XML_BUFFER_PROPERTY;
 113
 114 typedef enum {
 115     WS_XML_READER_PROPERTY_MAX_DEPTH,
 116     WS_XML_READER_PROPERTY_ALLOW_FRAGMENT,
 117     WS_XML_READER_PROPERTY_MAX_ATTRIBUTES,
 118     WS_XML_READER_PROPERTY_READ_DECLARATION,
 119     WS_XML_READER_PROPERTY_CHARSET,
 120     WS_XML_READER_PROPERTY_ROW,
 121     WS_XML_READER_PROPERTY_COLUMN,
 122     WS_XML_READER_PROPERTY_UTF8_TRIM_SIZE,
 123     WS_XML_READER_PROPERTY_STREAM_BUFFER_SIZE,
 124     WS_XML_READER_PROPERTY_IN_ATTRIBUTE,
 125     WS_XML_READER_PROPERTY_STREAM_MAX_ROOT_MIME_PART_SIZE,
 126     WS_XML_READER_PROPERTY_STREAM_MAX_MIME_HEADERS_SIZE,
 127     WS_XML_READER_PROPERTY_MAX_MIME_PARTS,
 128     WS_XML_READER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES,
 129     WS_XML_READER_PROPERTY_MAX_NAMESPACES
 130 } WS_XML_READER_PROPERTY_ID;
 131
 132 typedef struct _WS_XML_READER_PROPERTY {
 133     WS_XML_READER_PROPERTY_ID id;
 134     void                     *value;
 135     ULONG                     valueSize;
 136 } WS_XML_READER_PROPERTY;
 137
 138 typedef enum {
 139     WS_XML_WRITER_PROPERTY_MAX_DEPTH,
 140     WS_XML_WRITER_PROPERTY_ALLOW_FRAGMENT,
 141     WS_XML_WRITER_PROPERTY_MAX_ATTRIBUTES,
 142     WS_XML_WRITER_PROPERTY_WRITE_DECLARATION,
 143     WS_XML_WRITER_PROPERTY_INDENT,
 144     WS_XML_WRITER_PROPERTY_BUFFER_TRIM_SIZE,
 145     WS_XML_WRITER_PROPERTY_CHARSET,
 146     WS_XML_WRITER_PROPERTY_BUFFERS,
 147     WS_XML_WRITER_PROPERTY_BUFFER_MAX_SIZE,
 148     WS_XML_WRITER_PROPERTY_BYTES,
 149     WS_XML_WRITER_PROPERTY_IN_ATTRIBUTE,
 150     WS_XML_WRITER_PROPERTY_MAX_MIME_PARTS_BUFFER_SIZE,
 151     WS_XML_WRITER_PROPERTY_INITIAL_BUFFER,
 152     WS_XML_WRITER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES,
 153     WS_XML_WRITER_PROPERTY_MAX_NAMESPACES,
 154     WS_XML_WRITER_PROPERTY_BYTES_WRITTEN,
 155     WS_XML_WRITER_PROPERTY_BYTES_TO_CLOSE,
 156     WS_XML_WRITER_PROPERTY_COMPRESS_EMPTY_ELEMENTS,
 157     WS_XML_WRITER_PROPERTY_EMIT_UNCOMPRESSED_EMPTY_ELEMENTS
 158 } WS_XML_WRITER_PROPERTY_ID;
 159
 160 typedef struct _WS_XML_WRITER_PROPERTY {
 161     WS_XML_WRITER_PROPERTY_ID id;
 162     void                     *value;
 163     ULONG                     valueSize;
 164 } WS_XML_WRITER_PROPERTY;
 165
 166 typedef struct _WS_BYTES {
 167     ULONG length;
 168     BYTE *bytes;
 169 } WS_BYTES;
 170
 171 typedef struct _WS_BUFFERS {
 172     ULONG bufferCount;
 173     WS_BYTES *buffers;
 174 } WS_BUFFERS;
 175
 176 typedef enum {
 177     WS_XML_READER_ENCODING_TYPE_TEXT   = 1,
 178     WS_XML_READER_ENCODING_TYPE_BINARY = 2,
 179     WS_XML_READER_ENCODING_TYPE_MTOM   = 3,
 180     WS_XML_READER_ENCODING_TYPE_RAW    = 4
 181 } WS_XML_READER_ENCODING_TYPE;
 182
 183 typedef struct _WS_XML_READER_ENCODING {
 184     WS_XML_READER_ENCODING_TYPE encodingType;
 185 } WS_XML_READER_ENCODING;
 186
 187 typedef enum {
 188     WS_XML_WRITER_ENCODING_TYPE_TEXT   = 1,
 189     WS_XML_WRITER_ENCODING_TYPE_BINARY = 2,
 190     WS_XML_WRITER_ENCODING_TYPE_MTOM   = 3,
 191     WS_XML_WRITER_ENCODING_TYPE_RAW    = 4
 192 } WS_XML_WRITER_ENCODING_TYPE;
 193
 194 typedef struct _WS_XML_WRITER_ENCODING {
 195     WS_XML_WRITER_ENCODING_TYPE encodingType;
 196 } WS_XML_WRITER_ENCODING;
 197
 198 typedef enum {
 199     WS_CHARSET_AUTO,
 200     WS_CHARSET_UTF8,
 201     WS_CHARSET_UTF16LE,
 202     WS_CHARSET_UTF16BE
 203 } WS_CHARSET;
 204
 205 typedef struct _WS_XML_READER_TEXT_ENCODING {
 206     WS_XML_READER_ENCODING encoding;
 207     WS_CHARSET charSet;
 208 } WS_XML_READER_TEXT_ENCODING;
 209
 210 typedef struct _WS_XML_WRITER_TEXT_ENCODING {
 211     WS_XML_WRITER_ENCODING encoding;
 212     WS_CHARSET charSet;
 213 } WS_XML_WRITER_TEXT_ENCODING;
 214
 215 typedef enum {
 216     WS_XML_READER_INPUT_TYPE_BUFFER = 1,
 217     WS_XML_READER_INPUT_TYPE_STREAM = 2
 218 } WS_XML_READER_INPUT_TYPE;
 219
 220 typedef enum {
 221     WS_XML_WRITER_OUTPUT_TYPE_BUFFER = 1,
 222     WS_XML_WRITER_OUTPUT_TYPE_STREAM = 2
 223 } WS_XML_WRITER_OUTPUT_TYPE;
 224
 225 typedef struct _WS_XML_READER_INPUT {
 226     WS_XML_READER_INPUT_TYPE inputType;
 227 } WS_XML_READER_INPUT;
 228
 229 typedef struct _WS_XML_WRITER_OUTPUT {
 230     WS_XML_WRITER_OUTPUT_TYPE outputType;
 231 } WS_XML_WRITER_OUTPUT;
 232
 233 typedef struct _WS_XML_READER_BUFFER_INPUT {
 234     WS_XML_READER_INPUT input;
 235     void *encodedData;
 236     ULONG encodedDataSize;
 237 } WS_XML_READER_BUFFER_INPUT;
 238
 239 typedef struct _WS_XML_WRITER_BUFFER_OUTPUT {
 240     WS_XML_WRITER_OUTPUT output;
 241 } WS_XML_WRITER_BUFFER_OUTPUT;
 242
 243 typedef enum {
 244     WS_SHORT_CALLBACK,
 245     WS_LONG_CALLBACK
 246 } WS_CALLBACK_MODEL;
 247
 248 typedef void (CALLBACK *WS_ASYNC_CALLBACK)
 249     (HRESULT, WS_CALLBACK_MODEL, void *);
 250
 251 typedef struct _WS_ASYNC_CONTEXT {
 252     WS_ASYNC_CALLBACK callback;
 253     void             *callbackState;
 254 } WS_ASYNC_CONTEXT;
 255
 256 typedef HRESULT (CALLBACK *WS_READ_CALLBACK)
 257     (void*, void*, ULONG, ULONG*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
 258
 259 typedef HRESULT (CALLBACK *WS_WRITE_CALLBACK)
 260     (void*, const WS_BYTES*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
 261
 262 typedef struct _WS_XML_READER_STREAM_INPUT {
 263     WS_XML_READER_INPUT input;
 264     WS_READ_CALLBACK readCallback;
 265     void *readCallbackState;
 266 } WS_XML_READER_STREAM_INPUT;
 267
 268 typedef struct _WS_XML_DICTIONARY {
 269     GUID                   guid;
 270     struct _WS_XML_STRING *strings;
 271     ULONG                  stringCount;
 272     BOOL                   isConst;
 273 } WS_XML_DICTIONARY;
 274
 275 typedef struct _WS_XML_STRING {
 276     ULONG              length;
 277     BYTE              *bytes;
 278     WS_XML_DICTIONARY *dictionary;
 279     ULONG              id;
 280 } WS_XML_STRING;
 281
 282 typedef enum {
 283     WS_ELEMENT_TYPE_MAPPING         = 1,
 284     WS_ATTRIBUTE_TYPE_MAPPING       = 2,
 285     WS_ELEMENT_CONTENT_TYPE_MAPPING = 3,
 286     WS_ANY_ELEMENT_TYPE_MAPPING     = 4
 287 } WS_TYPE_MAPPING;
 288
 289 typedef enum {
 290     WS_BOOL_TYPE,
 291     WS_INT8_TYPE,
 292     WS_INT16_TYPE,
 293     WS_INT32_TYPE,
 294     WS_INT64_TYPE,
 295     WS_UINT8_TYPE,
 296     WS_UINT16_TYPE,
 297     WS_UINT32_TYPE,
 298     WS_UINT64_TYPE,
 299     WS_FLOAT_TYPE,
 300     WS_DOUBLE_TYPE,
 301     WS_DECIMAL_TYPE,
 302     WS_DATETIME_TYPE,
 303     WS_TIMESPAN_TYPE,
 304     WS_GUID_TYPE,
 305     WS_UNIQUE_ID_TYPE,
 306     WS_STRING_TYPE,
 307     WS_WSZ_TYPE,
 308     WS_BYTES_TYPE,
 309     WS_XML_STRING_TYPE,
 310     WS_XML_QNAME_TYPE,
 311     WS_XML_BUFFER_TYPE,
 312     WS_CHAR_ARRAY_TYPE,
 313     WS_UTF8_ARRAY_TYPE,
 314     WS_BYTE_ARRAY_TYPE,
 315     WS_DESCRIPTION_TYPE,
 316     WS_STRUCT_TYPE,
 317     WS_CUSTOM_TYPE,
 318     WS_ENDPOINT_ADDRESS_TYPE,
 319     WS_FAULT_TYPE,
 320     WS_VOID_TYPE,
 321     WS_ENUM_TYPE,
 322     WS_DURATION_TYPE,
 323     WS_UNION_TYPE,
 324     WS_ANY_ATTRIBUTES_TYPE
 325 } WS_TYPE;
 326
 327 typedef enum {
 328     WS_READ_REQUIRED_VALUE   = 1,
 329     WS_READ_REQUIRED_POINTER = 2,
 330     WS_READ_OPTIONAL_POINTER = 3,
 331     WS_READ_NILLABLE_POINTER = 4,
 332     WS_READ_NILLABLE_VALUE   = 5
 333 } WS_READ_OPTION;
 334
 335 typedef enum {
 336     WS_WRITE_REQUIRED_VALUE   = 1,
 337     WS_WRITE_REQUIRED_POINTER = 2,
 338     WS_WRITE_NILLABLE_VALUE   = 3,
 339     WS_WRITE_NILLABLE_POINTER = 4
 340 } WS_WRITE_OPTION;
 341
 342 typedef struct _WS_BOOL_DESCRIPTION {
 343     BOOL value;
 344 } WS_BOOL_DESCRIPTION;
 345
 346 typedef struct _WS_INT8_DESCRIPTION {
 347     char minValue;
 348     char maxValue;
 349 } WS_INT8_DESCRIPTION;
 350
 351 typedef struct _WS_INT16_DESCRIPTION {
 352     short minValue;
 353     short maxValue;
 354 } WS_INT16_DESCRIPTION;
 355
 356 typedef struct _WS_INT32_DESCRIPTION {
 357     int minValue;
 358     int maxValue;
 359 } WS_INT32_DESCRIPTION;
 360
 361 typedef struct _WS_INT64_DESCRIPTION {
 362     __int64 minValue;
 363     __int64 maxValue;
 364 } WS_INT64_DESCRIPTION;
 365
 366 typedef struct _WS_UINT8_DESCRIPTION {
 367     BYTE minValue;
 368     BYTE maxValue;
 369 } WS_UINT8_DESCRIPTION;
 370
 371 typedef struct _WS_UINT16_DESCRIPTION {
 372     USHORT minValue;
 373     USHORT maxValue;
 374 } WS_UINT16_DESCRIPTION;
 375
 376 typedef struct _WS_UINT32_DESCRIPTION {
 377     ULONG minValue;
 378     ULONG maxValue;
 379 } WS_UINT32_DESCRIPTION;
 380
 381 typedef struct _WS_UINT64_DESCRIPTION {
 382     unsigned __int64 minValue;
 383     unsigned __int64 maxValue;
 384 } WS_UINT64_DESCRIPTION;
 385
 386 typedef struct _WS_WSZ_DESCRIPTION {
 387     ULONG minCharCount;
 388     ULONG maxCharCount;
 389 } WS_WSZ_DESCRIPTION;
 390
 391 struct _WS_ENUM_VALUE {
 392     int value;
 393     WS_XML_STRING *name;
 394 };
 395
 396 struct _WS_ENUM_DESCRIPTION {
 397     WS_ENUM_VALUE *values;
 398     ULONG valueCount;
 399     ULONG maxByteCount;
 400     ULONG *nameIndices;
 401 };
 402
 403 struct _WS_DOUBLE_DESCRIPTION {
 404     double minValue;
 405     double maxValue;
 406 };
 407
 408 typedef enum {
 409     WS_TYPE_ATTRIBUTE_FIELD_MAPPING,
 410     WS_ATTRIBUTE_FIELD_MAPPING,
 411     WS_ELEMENT_FIELD_MAPPING,
 412     WS_REPEATING_ELEMENT_FIELD_MAPPING,
 413     WS_TEXT_FIELD_MAPPING,
 414     WS_NO_FIELD_MAPPING,
 415     WS_XML_ATTRIBUTE_FIELD_MAPPING,
 416     WS_ELEMENT_CHOICE_FIELD_MAPPING,
 417     WS_REPEATING_ELEMENT_CHOICE_FIELD_MAPPING,
 418     WS_ANY_ELEMENT_FIELD_MAPPING,
 419     WS_REPEATING_ANY_ELEMENT_FIELD_MAPPING,
 420     WS_ANY_CONTENT_FIELD_MAPPING,
 421     WS_ANY_ATTRIBUTES_FIELD_MAPPING
 422 } WS_FIELD_MAPPING;
 423
 424 typedef struct _WS_DEFAULT_VALUE {
 425     void *value;
 426     ULONG valueSize;
 427 } WS_DEFAULT_VALUE;
 428
 429 typedef struct _WS_ITEM_RANGE {
 430     ULONG minItemCount;
 431     ULONG maxItemCount;
 432 } WS_ITEM_RANGE;
 433
 434 enum
 435 {
 436     WS_FIELD_POINTER         = 0x1,
 437     WS_FIELD_OPTIONAL        = 0x2,
 438     WS_FIELD_NILLABLE        = 0x4,
 439     WS_FIELD_NILLABLE_ITEM   = 0x8,
 440     WS_FIELD_OTHER_NAMESPACE = 0x10
 441 };
 442
 443 typedef struct _WS_FIELD_DESCRIPTION {
 444     WS_FIELD_MAPPING mapping;
 445     WS_XML_STRING *localName;
 446     WS_XML_STRING *ns;
 447     WS_TYPE type;
 448     void *typeDescription;
 449     ULONG offset;
 450     ULONG options;
 451     WS_DEFAULT_VALUE *defaultValue;
 452     ULONG countOffset;
 453     WS_XML_STRING *itemLocalName;
 454     WS_XML_STRING *itemNs;
 455     WS_ITEM_RANGE *itemRange;
 456 } WS_FIELD_DESCRIPTION;
 457
 458 enum
 459 {
 460     WS_STRUCT_ABSTRACT                        = 0x1,
 461     WS_STRUCT_IGNORE_TRAILING_ELEMENT_CONTENT = 0x2,
 462     WS_STRUCT_IGNORE_UNHANDLED_ATTRIBUTES     = 0x4
 463 };
 464
 465 typedef struct _WS_STRUCT_DESCRIPTION {
 466     ULONG size;
 467     ULONG alignment;
 468     WS_FIELD_DESCRIPTION **fields;
 469     ULONG fieldCount;
 470     WS_XML_STRING *typeLocalName;
 471     WS_XML_STRING *typeNs;
 472     struct _WS_STRUCT_DESCRIPTION *parentType;
 473     struct _WS_STRUCT_DESCRIPTION **subTypes;
 474     ULONG subTypeCount;
 475     ULONG structOptions;
 476 } WS_STRUCT_DESCRIPTION;
 477
 478 typedef struct _WS_ATTRIBUTE_DESCRIPTION {
 479     WS_XML_STRING *attributeLocalName;
 480     WS_XML_STRING *attributeNs;
 481     WS_TYPE type;
 482     void *typeDescription;
 483 } WS_ATTRIBUTE_DESCRIPTION;
 484
 485 typedef struct _WS_ELEMENT_DESCRIPTION {
 486     WS_XML_STRING *elementLocalName;
 487     WS_XML_STRING *elementNs;
 488     WS_TYPE type;
 489     void *typeDescription;
 490 } WS_ELEMENT_DESCRIPTION;
 491
 492 typedef struct _WS_STRING {
 493     ULONG length;
 494     WCHAR *chars;
 495 } WS_STRING;
 496
 497 typedef enum {
 498     WS_XML_NODE_TYPE_ELEMENT     = 1,
 499     WS_XML_NODE_TYPE_TEXT        = 2,
 500     WS_XML_NODE_TYPE_END_ELEMENT = 3,
 501     WS_XML_NODE_TYPE_COMMENT     = 4,
 502     WS_XML_NODE_TYPE_CDATA       = 6,
 503     WS_XML_NODE_TYPE_END_CDATA   = 7,
 504     WS_XML_NODE_TYPE_EOF         = 8,
 505     WS_XML_NODE_TYPE_BOF         = 9
 506 } WS_XML_NODE_TYPE;
 507
 508 typedef struct _WS_XML_NODE {
 509     WS_XML_NODE_TYPE nodeType;
 510 } WS_XML_NODE;
 511
 512 typedef enum {
 513     WS_MOVE_TO_ROOT_ELEMENT,
 514     WS_MOVE_TO_NEXT_ELEMENT,
 515     WS_MOVE_TO_PREVIOUS_ELEMENT,
 516     WS_MOVE_TO_CHILD_ELEMENT,
 517     WS_MOVE_TO_END_ELEMENT,
 518     WS_MOVE_TO_PARENT_ELEMENT,
 519     WS_MOVE_TO_NEXT_NODE,
 520     WS_MOVE_TO_PREVIOUS_NODE,
 521     WS_MOVE_TO_FIRST_NODE,
 522     WS_MOVE_TO_BOF,
 523     WS_MOVE_TO_EOF,
 524     WS_MOVE_TO_CHILD_NODE
 525 } WS_MOVE_TO;
 526
 527 typedef enum {
 528     WS_XML_TEXT_TYPE_UTF8      = 1,
 529     WS_XML_TEXT_TYPE_UTF16     = 2,
 530     WS_XML_TEXT_TYPE_BASE64    = 3,
 531     WS_XML_TEXT_TYPE_BOOL      = 4,
 532     WS_XML_TEXT_TYPE_INT32     = 5,
 533     WS_XML_TEXT_TYPE_INT64     = 6,
 534     WS_XML_TEXT_TYPE_UINT64    = 7,
 535     WS_XML_TEXT_TYPE_FLOAT     = 8,
 536     WS_XML_TEXT_TYPE_DOUBLE    = 9,
 537     WS_XML_TEXT_TYPE_DECIMAL   = 10,
 538     WS_XML_TEXT_TYPE_GUID      = 11,
 539     WS_XML_TEXT_TYPE_UNIQUE_ID = 12,
 540     WS_XML_TEXT_TYPE_DATETIME  = 13,
 541     WS_XML_TEXT_TYPE_TIMESPAN  = 14,
 542     WS_XML_TEXT_TYPE_QNAME     = 15,
 543     WS_XML_TEXT_TYPE_LIST      = 16
 544 } WS_XML_TEXT_TYPE;
 545
 546 typedef struct _WS_XML_TEXT {
 547     WS_XML_TEXT_TYPE textType;
 548 } WS_XML_TEXT;
 549
 550 typedef struct _WS_XML_UTF8_TEXT {
 551     WS_XML_TEXT text;
 552     WS_XML_STRING value;
 553 } WS_XML_UTF8_TEXT;
 554
 555 typedef enum {
 556     WS_BOOL_VALUE_TYPE,
 557     WS_INT8_VALUE_TYPE,
 558     WS_INT16_VALUE_TYPE,
 559     WS_INT32_VALUE_TYPE,
 560     WS_INT64_VALUE_TYPE,
 561     WS_UINT8_VALUE_TYPE,
 562     WS_UINT16_VALUE_TYPE,
 563     WS_UINT32_VALUE_TYPE,
 564     WS_UINT64_VALUE_TYPE,
 565     WS_FLOAT_VALUE_TYPE,
 566     WS_DOUBLE_VALUE_TYPE,
 567     WS_DECIMAL_VALUE_TYPE,
 568     WS_DATETIME_VALUE_TYPE,
 569     WS_TIMESPAN_VALUE_TYPE,
 570     WS_GUID_VALUE_TYPE,
 571     WS_DURATION_VALUE_TYPE
 572 } WS_VALUE_TYPE;
 573
 574 typedef struct _WS_XML_ATTRIBUTE {
 575     BYTE singleQuote;
 576     BYTE isXmlNs;
 577     WS_XML_STRING *prefix;
 578     WS_XML_STRING *localName;
 579     WS_XML_STRING *ns;
 580     WS_XML_TEXT *value;
 581 } WS_XML_ATTRIBUTE;
 582
 583 typedef struct _WS_XML_ELEMENT_NODE {
 584     WS_XML_NODE node;
 585     WS_XML_STRING *prefix;
 586     WS_XML_STRING *localName;
 587     WS_XML_STRING *ns;
 588     ULONG attributeCount;
 589     WS_XML_ATTRIBUTE **attributes;
 590     BOOL isEmpty;
 591 } WS_XML_ELEMENT_NODE;
 592
 593 typedef struct _WS_XML_TEXT_NODE {
 594     WS_XML_NODE node;
 595     WS_XML_TEXT *text;
 596 } WS_XML_TEXT_NODE;
 597
 598 typedef struct _WS_XML_COMMENT_NODE {
 599     WS_XML_NODE node;
 600     WS_XML_STRING value;
 601 } WS_XML_COMMENT_NODE;
 602
 603 typedef struct _WS_XML_NODE_POSITION {
 604     WS_XML_BUFFER *buffer;
 605     void *node;
 606 } WS_XML_NODE_POSITION;
 607
 608 typedef enum {
 609     WS_SERVICE_PROXY_STATE_CREATED,
 610     WS_SERVICE_PROXY_STATE_OPENING,
 611     WS_SERVICE_PROXY_STATE_OPEN,
 612     WS_SERVICE_PROXY_STATE_CLOSING,
 613     WS_SERVICE_PROXY_STATE_CLOSED,
 614     WS_SERVICE_PROXY_STATE_FAULTED
 615 } WS_SERVICE_PROXY_STATE;
 616
 617 typedef enum {
 618     WS_PROXY_PROPERTY_CALL_TIMEOUT,
 619     WS_PROXY_PROPERTY_MESSAGE_PROPERTIES,
 620     WS_PROXY_PROPERTY_MAX_CALL_POOL_SIZE,
 621     WS_PROXY_PROPERTY_STATE,
 622     WS_PROXY_PROPERTY_MAX_PENDING_CALLS,
 623     WS_PROXY_PROPERTY_MAX_CLOSE_TIMEOUT,
 624     WS_PROXY_FAULT_LANG_ID
 625 } WS_PROXY_PROPERTY_ID;
 626
 627 struct _WS_PROXY_PROPERTY {
 628     WS_PROXY_PROPERTY_ID id;
 629     void *value;
 630     ULONG valueSize;
 631 };
 632
 633 typedef enum {
 634     WS_CHANNEL_TYPE_INPUT           = 0x1,
 635     WS_CHANNEL_TYPE_OUTPUT          = 0x2,
 636     WS_CHANNEL_TYPE_SESSION         = 0x4,
 637     WS_CHANNEL_TYPE_INPUT_SESSION   = (WS_CHANNEL_TYPE_INPUT  | WS_CHANNEL_TYPE_SESSION),
 638     WS_CHANNEL_TYPE_OUTPUT_SESSION  = (WS_CHANNEL_TYPE_OUTPUT | WS_CHANNEL_TYPE_SESSION),
 639     WS_CHANNEL_TYPE_DUPLEX          = (WS_CHANNEL_TYPE_INPUT  | WS_CHANNEL_TYPE_OUTPUT),
 640     WS_CHANNEL_TYPE_DUPLEX_SESSION  = (WS_CHANNEL_TYPE_INPUT  | WS_CHANNEL_TYPE_OUTPUT | WS_CHANNEL_TYPE_SESSION),
 641     WS_CHANNEL_TYPE_REQUEST         = 0x8,
 642     WS_CHANNEL_TYPE_REPLY           = 0x10
 643 } WS_CHANNEL_TYPE;
 644
 645 typedef enum {
 646     WS_ENCODING_XML_BINARY_1,
 647     WS_ENCODING_XML_BINARY_SESSION_1,
 648     WS_ENCODING_XML_MTOM_UTF8,
 649     WS_ENCODING_XML_MTOM_UTF16BE,
 650     WS_ENCODING_XML_MTOM_UTF16LE,
 651     WS_ENCODING_XML_UTF8,
 652     WS_ENCODING_XML_UTF16BE,
 653     WS_ENCODING_XML_UTF16LE,
 654     WS_ENCODING_RAW
 655 } WS_ENCODING;
 656
 657 typedef enum {
 658     WS_CHANNEL_STATE_CREATED,
 659     WS_CHANNEL_STATE_OPENING,
 660     WS_CHANNEL_STATE_ACCEPTING,
 661     WS_CHANNEL_STATE_OPEN,
 662     WS_CHANNEL_STATE_FAULTED,
 663     WS_CHANNEL_STATE_CLOSING,
 664     WS_CHANNEL_STATE_CLOSED
 665 } WS_CHANNEL_STATE;
 666
 667 typedef enum {
 668     WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE               = 0,
 669     WS_CHANNEL_PROPERTY_MAX_STREAMED_MESSAGE_SIZE               = 1,
 670     WS_CHANNEL_PROPERTY_MAX_STREAMED_START_SIZE                 = 2,
 671     WS_CHANNEL_PROPERTY_MAX_STREAMED_FLUSH_SIZE                 = 3,
 672     WS_CHANNEL_PROPERTY_ENCODING                                = 4,
 673     WS_CHANNEL_PROPERTY_ENVELOPE_VERSION                        = 5,
 674     WS_CHANNEL_PROPERTY_ADDRESSING_VERSION                      = 6,
 675     WS_CHANNEL_PROPERTY_MAX_SESSION_DICTIONARY_SIZE             = 7,
 676     WS_CHANNEL_PROPERTY_STATE                                   = 8,
 677     WS_CHANNEL_PROPERTY_ASYNC_CALLBACK_MODEL                    = 9,
 678     WS_CHANNEL_PROPERTY_IP_VERSION                              = 10,
 679     WS_CHANNEL_PROPERTY_RESOLVE_TIMEOUT                         = 11,
 680     WS_CHANNEL_PROPERTY_CONNECT_TIMEOUT                         = 12,
 681     WS_CHANNEL_PROPERTY_SEND_TIMEOUT                            = 13,
 682     WS_CHANNEL_PROPERTY_RECEIVE_RESPONSE_TIMEOUT                = 14,
 683     WS_CHANNEL_PROPERTY_RECEIVE_TIMEOUT                         = 15,
 684     WS_CHANNEL_PROPERTY_CLOSE_TIMEOUT                           = 16,
 685     WS_CHANNEL_PROPERTY_ENABLE_TIMEOUTS                         = 17,
 686     WS_CHANNEL_PROPERTY_TRANSFER_MODE                           = 18,
 687     WS_CHANNEL_PROPERTY_MULTICAST_INTERFACE                     = 19,
 688     WS_CHANNEL_PROPERTY_MULTICAST_HOPS                          = 20,
 689     WS_CHANNEL_PROPERTY_REMOTE_ADDRESS                          = 21,
 690     WS_CHANNEL_PROPERTY_REMOTE_IP_ADDRESS                       = 22,
 691     WS_CHANNEL_PROPERTY_HTTP_CONNECTION_ID                      = 23,
 692     WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_CALLBACKS                = 24,
 693     WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_PARAMETERS               = 25,
 694     WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_INSTANCE                 = 26,
 695     WS_CHANNEL_PROPERTY_TRANSPORT_URL                           = 27,
 696     WS_CHANNEL_PROPERTY_NO_DELAY                                = 28,
 697     WS_CHANNEL_PROPERTY_SEND_KEEP_ALIVES                        = 29,
 698     WS_CHANNEL_PROPERTY_KEEP_ALIVE_TIME                         = 30,
 699     WS_CHANNEL_PROPERTY_KEEP_ALIVE_INTERVAL                     = 31,
 700     WS_CHANNEL_PROPERTY_MAX_HTTP_SERVER_CONNECTIONS             = 32,
 701     WS_CHANNEL_PROPERTY_IS_SESSION_SHUT_DOWN                    = 33,
 702     WS_CHANNEL_PROPERTY_CHANNEL_TYPE                            = 34,
 703     WS_CHANNEL_PROPERTY_TRIM_BUFFERED_MESSAGE_SIZE              = 35,
 704     WS_CHANNEL_PROPERTY_ENCODER                                 = 36,
 705     WS_CHANNEL_PROPERTY_DECODER                                 = 37,
 706     WS_CHANNEL_PROPERTY_PROTECTION_LEVEL                        = 38,
 707     WS_CHANNEL_PROPERTY_COOKIE_MODE                             = 39,
 708     WS_CHANNEL_PROPERTY_HTTP_PROXY_SETTING_MODE                 = 40,
 709     WS_CHANNEL_PROPERTY_CUSTOM_HTTP_PROXY                       = 41,
 710     WS_CHANNEL_PROPERTY_HTTP_MESSAGE_MAPPING                    = 42,
 711     WS_CHANNEL_PROPERTY_ENABLE_HTTP_REDIRECT                    = 43,
 712     WS_CHANNEL_PROPERTY_HTTP_REDIRECT_CALLBACK_CONTEXT          = 44,
 713     WS_CHANNEL_PROPERTY_FAULTS_AS_ERRORS                        = 45,
 714     WS_CHANNEL_PROPERTY_ALLOW_UNSECURED_FAULTS                  = 46,
 715     WS_CHANNEL_PROPERTY_HTTP_SERVER_SPN                         = 47,
 716     WS_CHANNEL_PROPERTY_HTTP_PROXY_SPN                          = 48,
 717     WS_CHANNEL_PROPERTY_MAX_HTTP_REQUEST_HEADERS_BUFFER_SIZE    = 49
 718 } WS_CHANNEL_PROPERTY_ID;
 719
 720 struct _WS_CHANNEL_PROPERTY {
 721     WS_CHANNEL_PROPERTY_ID id;
 722     void *value;
 723     ULONG valueSize;
 724 };
 725
 726 struct _WS_CHANNEL_PROPERTIES {
 727     WS_CHANNEL_PROPERTY *properties;
 728     ULONG propertyCount;
 729 };
 730
 731 typedef enum {
 732     WS_HTTP_CHANNEL_BINDING,
 733     WS_TCP_CHANNEL_BINDING,
 734     WS_UDP_CHANNEL_BINDING,
 735     WS_CUSTOM_CHANNEL_BINDING,
 736     WS_NAMEDPIPE_CHANNEL_BINDING
 737 } WS_CHANNEL_BINDING;
 738
 739 typedef enum {
 740     WS_SSL_TRANSPORT_SECURITY_BINDING_TYPE,
 741     WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TYPE,
 742     WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TYPE,
 743     WS_USERNAME_MESSAGE_SECURITY_BINDING_TYPE,
 744     WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TYPE,
 745     WS_XML_TOKEN_MESSAGE_SECURITY_BINDING_TYPE,
 746     WS_SAML_MESSAGE_SECURITY_BINDING_TYPE,
 747     WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_TYPE,
 748     WS_NAMEDPIPE_SSPI_TRANSPORT_SECURITY_BINDING_TYPE
 749 } WS_SECURITY_BINDING_TYPE;
 750
 751 typedef enum {
 752     WS_SECURITY_BINDING_PROPERTY_REQUIRE_SSL_CLIENT_CERT                    = 1,
 753     WS_SECURITY_BINDING_PROPERTY_WINDOWS_INTEGRATED_AUTH_PACKAGE            = 2,
 754     WS_SECURITY_BINDING_PROPERTY_REQUIRE_SERVER_AUTH                        = 3,
 755     WS_SECURITY_BINDING_PROPERTY_ALLOW_ANONYMOUS_CLIENTS                    = 4,
 756     WS_SECURITY_BINDING_PROPERTY_ALLOWED_IMPERSONATION_LEVEL                = 5,
 757     WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_SCHEME                    = 6,
 758     WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_TARGET                    = 7,
 759     WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_BASIC_REALM               = 8,
 760     WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_DIGEST_REALM              = 9,
 761     WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_DIGEST_DOMAIN             = 10,
 762     WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_KEY_SIZE                  = 11,
 763     WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_KEY_ENTROPY_MODE          = 12,
 764     WS_SECURITY_BINDING_PROPERTY_MESSAGE_PROPERTIES                         = 13,
 765     WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_MAX_PENDING_CONTEXTS      = 14,
 766     WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_MAX_ACTIVE_CONTEXTS       = 15,
 767     WS_SECURITY_BINDING_PROPERTY_SECURE_CONVERSATION_VERSION                = 16,
 768     WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_SUPPORT_RENEW             = 17,
 769     WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_RENEWAL_INTERVAL          = 18,
 770     WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_ROLLOVER_INTERVAL         = 19,
 771     WS_SECURITY_BINDING_PROPERTY_CERT_FAILURES_TO_IGNORE                    = 20,
 772     WS_SECURITY_BINDING_PROPERTY_DISABLE_CERT_REVOCATION_CHECK              = 21,
 773     WS_SECURITY_BINDING_PROPERTY_DISALLOWED_SECURE_PROTOCOLS                = 22,
 774     WS_SECURITY_BINDING_PROPERTY_CERTIFICATE_VALIDATION_CALLBACK_CONTEXT    = 23
 775 } WS_SECURITY_BINDING_PROPERTY_ID;
 776
 777 struct _WS_SECURITY_BINDING_PROPERTY {
 778     WS_SECURITY_BINDING_PROPERTY_ID id;
 779     void *value;
 780     ULONG valueSize;
 781 };
 782
 783 struct _WS_SECURITY_BINDING_PROPERTIES {
 784     WS_SECURITY_BINDING_PROPERTY *properties;
 785     ULONG propertyCount;
 786 };
 787
 788 struct _WS_SECURITY_BINDING {
 789     WS_SECURITY_BINDING_TYPE bindingType;
 790     WS_SECURITY_BINDING_PROPERTY *properties;
 791     ULONG propertyCount;
 792 };
 793
 794 typedef enum {
 795     WS_SECURITY_PROPERTY_TRANSPORT_PROTECTION_LEVEL     = 1,
 796     WS_SECURITY_PROPERTY_ALGORITHM_SUITE                = 2,
 797     WS_SECURITY_PROPERTY_ALGORITHM_SUITE_NAME           = 3,
 798     WS_SECURITY_PROPERTY_MAX_ALLOWED_LATENCY            = 4,
 799     WS_SECURITY_PROPERTY_TIMESTAMP_VALIDITY_DURATION    = 5,
 800     WS_SECURITY_PROPERTY_MAX_ALLOWED_CLOCK_SKEW         = 6,
 801     WS_SECURITY_PROPERTY_TIMESTAMP_USAGE                = 7,
 802     WS_SECURITY_PROPERTY_SECURITY_HEADER_LAYOUT         = 8,
 803     WS_SECURITY_PROPERTY_SECURITY_HEADER_VERSION        = 9,
 804     WS_SECURITY_PROPERTY_EXTENDED_PROTECTION_POLICY     = 10,
 805     WS_SECURITY_PROPERTY_EXTENDED_PROTECTION_SCENARIO   = 11,
 806     WS_SECURITY_PROPERTY_SERVICE_IDENTITIES             = 12
 807 } WS_SECURITY_PROPERTY_ID;
 808
 809 struct _WS_SECURITY_PROPERTY {
 810     WS_SECURITY_PROPERTY_ID id;
 811     void *value;
 812     ULONG valueSize;
 813 };
 814
 815 struct _WS_SECURITY_PROPERTIES {
 816     WS_SECURITY_PROPERTY *properties;
 817     ULONG propertyCount;
 818 };
 819
 820 struct _WS_SECURITY_DESCRIPTION {
 821     WS_SECURITY_BINDING **securityBindings;
 822     ULONG securityBindingCount;
 823     WS_SECURITY_PROPERTY *properties;
 824     ULONG propertyCount;
 825 };
 826
 827 typedef enum {
 828     WS_HTTP_BINDING_TEMPLATE_TYPE,
 829     WS_HTTP_SSL_BINDING_TEMPLATE_TYPE,
 830     WS_HTTP_HEADER_AUTH_BINDING_TEMPLATE_TYPE,
 831     WS_HTTP_SSL_HEADER_AUTH_BINDING_TEMPLATE_TYPE,
 832     WS_HTTP_SSL_USERNAME_BINDING_TEMPLATE_TYPE,
 833     WS_HTTP_SSL_KERBEROS_APREQ_BINDING_TEMPLATE_TYPE,
 834     WS_TCP_BINDING_TEMPLATE_TYPE,
 835     WS_TCP_SSPI_BINDING_TEMPLATE_TYPE,
 836     WS_TCP_SSPI_USERNAME_BINDING_TEMPLATE_TYPE,
 837     WS_TCP_SSPI_KERBEROS_APREQ_BINDING_TEMPLATE_TYPE,
 838     WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE,
 839     WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE,
 840     WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE,
 841     WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE
 842 } WS_BINDING_TEMPLATE_TYPE;
 843
 844 typedef enum {
 845     WS_SUBJECT_NAME_CERT_CREDENTIAL_TYPE    = 1,
 846     WS_THUMBPRINT_CERT_CREDENTIAL_TYPE      = 2,
 847     WS_CUSTOM_CERT_CREDENTIAL_TYPE          = 3
 848 } WS_CERT_CREDENTIAL_TYPE;
 849
 850 struct _WS_CERT_CREDENTIAL {
 851     WS_CERT_CREDENTIAL_TYPE credentialType;
 852 };
 853
 854 struct _WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE {
 855     WS_SECURITY_BINDING_PROPERTIES securityBindingProperties;
 856     WS_CERT_CREDENTIAL *localCertCredential;
 857 };
 858
 859 struct _WS_HTTP_BINDING_TEMPLATE {
 860     WS_CHANNEL_PROPERTIES channelProperties;
 861 };
 862
 863 struct _WS_HTTP_SSL_BINDING_TEMPLATE {
 864     WS_CHANNEL_PROPERTIES channelProperties;
 865     WS_SECURITY_PROPERTIES securityProperties;
 866     WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE sslTransportSecurityBinding;
 867 };
 868
 869 typedef enum {
 870     WS_ADDRESSING_VERSION_0_9       = 1,
 871     WS_ADDRESSING_VERSION_1_0       = 2,
 872     WS_ADDRESSING_VERSION_TRANSPORT = 3
 873 } WS_ADDRESSING_VERSION;
 874
 875 typedef enum {
 876     WS_ENVELOPE_VERSION_SOAP_1_1    = 1,
 877     WS_ENVELOPE_VERSION_SOAP_1_2    = 2,
 878     WS_ENVELOPE_VERSION_NONE        = 3
 879 } WS_ENVELOPE_VERSION;
 880
 881 typedef enum {
 882     WS_MESSAGE_PROPERTY_STATE,
 883     WS_MESSAGE_PROPERTY_HEAP,
 884     WS_MESSAGE_PROPERTY_ENVELOPE_VERSION,
 885     WS_MESSAGE_PROPERTY_ADDRESSING_VERSION,
 886     WS_MESSAGE_PROPERTY_HEADER_BUFFER,
 887     WS_MESSAGE_PROPERTY_HEADER_POSITION,
 888     WS_MESSAGE_PROPERTY_BODY_READER,
 889     WS_MESSAGE_PROPERTY_BODY_WRITER,
 890     WS_MESSAGE_PROPERTY_IS_ADDRESSED,
 891     WS_MESSAGE_PROPERTY_HEAP_PROPERTIES,
 892     WS_MESSAGE_PROPERTY_XML_READER_PROPERTIES,
 893     WS_MESSAGE_PROPERTY_XML_WRITER_PROPERTIES,
 894     WS_MESSAGE_PROPERTY_IS_FAULT,
 895     WS_MESSAGE_PROPERTY_MAX_PROCESSED_HEADERS,
 896     WS_MESSAGE_PROPERTY_USERNAME,
 897     WS_MESSAGE_PROPERTY_ENCODED_CERT,
 898     WS_MESSAGE_PROPERTY_TRANSPORT_SECURITY_WINDOWS_TOKEN,
 899     WS_MESSAGE_PROPERTY_HTTP_HEADER_AUTH_WINDOWS_TOKEN,
 900     WS_MESSAGE_PROPERTY_MESSAGE_SECURITY_WINDOWS_TOKEN,
 901     WS_MESSAGE_PROPERTY_SAML_ASSERTION,
 902     WS_MESSAGE_PROPERTY_SECURITY_CONTEXT,
 903     WS_MESSAGE_PROPERTY_PROTECTION_LEVEL
 904 } WS_MESSAGE_PROPERTY_ID;
 905
 906 struct _WS_MESSAGE_PROPERTY {
 907     WS_MESSAGE_PROPERTY_ID id;
 908     void *value;
 909     ULONG valueSize;
 910 };
 911
 912 struct _WS_MESSAGE_PROPERTIES {
 913     WS_MESSAGE_PROPERTY *properties;
 914     ULONG propertyCount;
 915 };
 916
 917 typedef enum {
 918     WS_MESSAGE_STATE_EMPTY          = 1,
 919     WS_MESSAGE_STATE_INITIALIZED    = 2,
 920     WS_MESSAGE_STATE_READING        = 3,
 921     WS_MESSAGE_STATE_WRITING        = 4,
 922     WS_MESSAGE_STATE_DONE           = 5
 923 } WS_MESSAGE_STATE;
 924
 925 typedef enum {
 926     WS_BLANK_MESSAGE,
 927     WS_DUPLICATE_MESSAGE,
 928     WS_REQUEST_MESSAGE,
 929     WS_REPLY_MESSAGE,
 930     WS_FAULT_MESSAGE
 931 } WS_MESSAGE_INITIALIZATION;
 932
 933 typedef enum {
 934     WS_DNS_ENDPOINT_IDENTITY_TYPE       = 1,
 935     WS_UPN_ENDPOINT_IDENTITY_TYPE       = 2,
 936     WS_SPN_ENDPOINT_IDENTITY_TYPE       = 3,
 937     WS_RSA_ENDPOINT_IDENTITY_TYPE       = 4,
 938     WS_CERT_ENDPOINT_IDENTITY_TYPE      = 5,
 939     WS_UNKNOWN_ENDPOINT_IDENTITY_TYPE   = 6
 940 } WS_ENDPOINT_IDENTITY_TYPE;
 941
 942 struct _WS_ENDPOINT_IDENTITY {
 943     WS_ENDPOINT_IDENTITY_TYPE identityType;
 944 };
 945
 946 struct _WS_ENDPOINT_ADDRESS {
 947     WS_STRING url;
 948     WS_XML_BUFFER *headers;
 949     WS_XML_BUFFER *extensions;
 950     WS_ENDPOINT_IDENTITY *identity;
 951 };
 952
 953 struct _WS_HTTP_POLICY_DESCRIPTION {
 954     WS_CHANNEL_PROPERTIES channelProperties;
 955 };
 956
 957 struct _WS_MESSAGE_DESCRIPTION {
 958     WS_XML_STRING *action;
 959     WS_ELEMENT_DESCRIPTION *bodyElementDescription;
 960 };
 961
 962 typedef enum {
 963     WS_PARAMETER_TYPE_NORMAL,
 964     WS_PARAMETER_TYPE_ARRAY,
 965     WS_PARAMETER_TYPE_ARRAY_COUNT,
 966     WS_PARAMETER_TYPE_MESSAGES
 967 } WS_PARAMETER_TYPE;
 968
 969 struct _WS_PARAMETER_DESCRIPTION {
 970     WS_PARAMETER_TYPE parameterType;
 971     USHORT inputMessageIndex;
 972     USHORT outputMessageIndex;
 973 };
 974
 975 typedef HRESULT (CALLBACK *WS_SERVICE_STUB_CALLBACK)(
 976     const WS_OPERATION_CONTEXT *context,
 977     void *frame,
 978     const void *callback,
 979     const WS_ASYNC_CONTEXT *asyncContext,
 980     WS_ERROR *error );
 981
 982 typedef enum {
 983     WS_NON_RPC_LITERAL_OPERATION,
 984     WS_RPC_LITERAL_OPERATION
 985 } WS_OPERATION_STYLE;
 986
 987 struct _WS_OPERATION_DESCRIPTION {
 988     ULONG versionInfo;
 989     WS_MESSAGE_DESCRIPTION *inputMessageDescription;
 990     WS_MESSAGE_DESCRIPTION *outputMessageDescription;
 991     ULONG inputMessageOptions;
 992     ULONG outputMessageOptions;
 993     USHORT parameterCount;
 994     WS_PARAMETER_DESCRIPTION *parameterDescription;
 995     WS_SERVICE_STUB_CALLBACK stubCallback;
 996     WS_OPERATION_STYLE style;
 997 };
 998
 999 typedef enum {
1000     WS_CALL_PROPERTY_CHECK_MUST_UNDERSTAND,
1001     WS_CALL_PROPERTY_SEND_MESSAGE_CONTEXT,
1002     WS_CALL_PROPERTY_RECEIVE_MESSAGE_CONTEXT,
1003     WS_CALL_PROPERTY_CALL_ID
1004 } WS_CALL_PROPERTY_ID;
1005
1006 struct _WS_CALL_PROPERTY {
1007     WS_CALL_PROPERTY_ID id;
1008     void *value;
1009     ULONG valueSize;
1010 };
1011
1012 typedef enum {
1013     WS_DATETIME_FORMAT_UTC,
1014     WS_DATETIME_FORMAT_LOCAL,
1015     WS_DATETIME_FORMAT_NONE
1016 } WS_DATETIME_FORMAT;
1017
1018 struct _WS_DATETIME {
1019     unsigned __int64 ticks;
1020     WS_DATETIME_FORMAT format;
1021 };
1022
1023 struct _WS_DATETIME_DESCRIPTION {
1024     WS_DATETIME minValue;
1025     WS_DATETIME maxValue;
1026 };
1027
1028 typedef enum {
1029     WS_URL_HTTP_SCHEME_TYPE,
1030     WS_URL_HTTPS_SCHEME_TYPE,
1031     WS_URL_NETTCP_SCHEME_TYPE,
1032     WS_URL_SOAPUDP_SCHEME_TYPE,
1033     WS_URL_NETPIPE_SCHEME_TYPE
1034 } WS_URL_SCHEME_TYPE;
1035
1036 enum {
1037     WS_URL_FLAGS_ALLOW_HOST_WILDCARDS   = 0x1,
1038     WS_URL_FLAGS_NO_PATH_COLLAPSE       = 0x2,
1039     WS_URL_FLAGS_ZERO_TERMINATE         = 0x4
1040 };
1041
1042 struct _WS_URL {
1043     WS_URL_SCHEME_TYPE scheme;
1044 };
1045
1046 struct _WS_HTTP_URL {
1047     WS_URL url;
1048     WS_STRING host;
1049     USHORT port;
1050     WS_STRING portAsString;
1051     WS_STRING path;
1052     WS_STRING query;
1053     WS_STRING fragment;
1054 };
1055
1056 struct _WS_HTTPS_URL {
1057     WS_URL url;
1058     WS_STRING host;
1059     USHORT port;
1060     WS_STRING portAsString;
1061     WS_STRING path;
1062     WS_STRING query;
1063     WS_STRING fragment;
1064 };
1065
1066 struct _WS_SOAPUDP_URL {
1067     WS_URL url;
1068     WS_STRING host;
1069     USHORT port;
1070     WS_STRING portAsString;
1071     WS_STRING path;
1072     WS_STRING query;
1073     WS_STRING fragment;
1074 };
1075
1076 struct _WS_NETPIPE_URL {
1077     WS_URL url;
1078     WS_STRING host;
1079     USHORT port;
1080     WS_STRING portAsString;
1081     WS_STRING path;
1082     WS_STRING query;
1083     WS_STRING fragment;
1084 };
1085
1086 typedef enum
1087 {
1088     WS_IP_VERSION_4    = 1,
1089     WS_IP_VERSION_6    = 2,
1090     WS_IP_VERSION_AUTO = 3
1091 } WS_IP_VERSION;
1092
1093 typedef enum
1094 {
1095     WS_BUFFERED_TRANSFER_MODE        = 0x0,
1096     WS_STREAMED_INPUT_TRANSFER_MODE  = 0x1,
1097     WS_STREAMED_OUTPUT_TRANSFER_MODE = 0x2,
1098     WS_STREAMED_TRANSFER_MODE        = (WS_STREAMED_INPUT_TRANSFER_MODE|WS_STREAMED_OUTPUT_TRANSFER_MODE)
1099 } WS_TRANSFER_MODE;
1100
1101 typedef HRESULT (CALLBACK *WS_CREATE_CHANNEL_CALLBACK)
1102     (WS_CHANNEL_TYPE, const void*, ULONG, void**, WS_ERROR*);
1103
1104 typedef void (CALLBACK *WS_FREE_CHANNEL_CALLBACK)
1105     (void*);
1106
1107 typedef HRESULT (CALLBACK *WS_RESET_CHANNEL_CALLBACK)
1108     (void*, WS_ERROR*);
1109
1110 typedef HRESULT (CALLBACK *WS_OPEN_CHANNEL_CALLBACK)
1111     (void*, const WS_ENDPOINT_ADDRESS*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1112
1113 typedef HRESULT (CALLBACK *WS_CLOSE_CHANNEL_CALLBACK)
1114     (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1115
1116 typedef HRESULT (CALLBACK *WS_ABORT_CHANNEL_CALLBACK)
1117     (void*, WS_ERROR*);
1118
1119 typedef HRESULT (CALLBACK *WS_GET_CHANNEL_PROPERTY_CALLBACK)
1120     (void*, WS_CHANNEL_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1121
1122 typedef HRESULT (CALLBACK *WS_SET_CHANNEL_PROPERTY_CALLBACK)
1123     (void*, WS_CHANNEL_PROPERTY_ID, const void*, ULONG, WS_ERROR*);
1124
1125 typedef HRESULT (CALLBACK *WS_WRITE_MESSAGE_START_CALLBACK)
1126     (void*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1127
1128 typedef HRESULT (CALLBACK *WS_WRITE_MESSAGE_END_CALLBACK)
1129     (void*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1130
1131 typedef HRESULT (CALLBACK *WS_READ_MESSAGE_START_CALLBACK)
1132     (void*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1133
1134 typedef HRESULT (CALLBACK *WS_READ_MESSAGE_END_CALLBACK)
1135     (void*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1136
1137 typedef HRESULT (CALLBACK *WS_ABANDON_MESSAGE_CALLBACK)
1138     (void*, WS_MESSAGE*, WS_ERROR*);
1139
1140 typedef HRESULT (CALLBACK *WS_SHUTDOWN_SESSION_CHANNEL_CALLBACK)
1141     (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1142
1143 struct _WS_CUSTOM_CHANNEL_CALLBACKS
1144 {
1145     WS_CREATE_CHANNEL_CALLBACK createChannelCallback;
1146     WS_FREE_CHANNEL_CALLBACK freeChannelCallback;
1147     WS_RESET_CHANNEL_CALLBACK resetChannelCallback;
1148     WS_OPEN_CHANNEL_CALLBACK openChannelCallback;
1149     WS_CLOSE_CHANNEL_CALLBACK closeChannelCallback;
1150     WS_ABORT_CHANNEL_CALLBACK abortChannelCallback;
1151     WS_GET_CHANNEL_PROPERTY_CALLBACK getChannelPropertyCallback;
1152     WS_SET_CHANNEL_PROPERTY_CALLBACK setChannelPropertyCallback;
1153     WS_WRITE_MESSAGE_START_CALLBACK writeMessageStartCallback;
1154     WS_WRITE_MESSAGE_END_CALLBACK writeMessageEndCallback;
1155     WS_READ_MESSAGE_START_CALLBACK readMessageStartCallback;
1156     WS_READ_MESSAGE_END_CALLBACK readMessageEndCallback;
1157     WS_ABANDON_MESSAGE_CALLBACK abandonMessageCallback;
1158     WS_SHUTDOWN_SESSION_CHANNEL_CALLBACK shutdownSessionChannelCallback;
1159 };
1160
1161 typedef HRESULT (CALLBACK *WS_CREATE_ENCODER_CALLBACK)
1162     (void*, WS_WRITE_CALLBACK, void*, void**, WS_ERROR*);
1163
1164 typedef HRESULT (CALLBACK *WS_ENCODER_GET_CONTENT_TYPE_CALLBACK)
1165     (void*, const WS_STRING*, WS_STRING*, WS_STRING*, WS_ERROR*);
1166
1167 typedef HRESULT (CALLBACK *WS_ENCODER_START_CALLBACK)
1168     (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1169
1170 typedef HRESULT (CALLBACK *WS_ENCODER_ENCODE_CALLBACK)
1171     (void*, const WS_BYTES*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1172
1173 typedef HRESULT (CALLBACK *WS_ENCODER_END_CALLBACK)
1174     (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1175
1176 typedef void (CALLBACK *WS_FREE_ENCODER_CALLBACK)
1177     (void*);
1178
1179 struct _WS_CHANNEL_ENCODER
1180 {
1181     void *createContext;
1182     WS_CREATE_ENCODER_CALLBACK createEncoderCallback;
1183     WS_ENCODER_GET_CONTENT_TYPE_CALLBACK encoderGetContentTypeCallback;
1184     WS_ENCODER_START_CALLBACK encoderStartCallback;
1185     WS_ENCODER_ENCODE_CALLBACK encoderEncodeCallback;
1186     WS_ENCODER_END_CALLBACK encoderEndCallback;
1187     WS_FREE_ENCODER_CALLBACK freeEncoderCallback;
1188 };
1189
1190 typedef HRESULT (CALLBACK *WS_CREATE_DECODER_CALLBACK)
1191     (void*, WS_READ_CALLBACK, void*, void**, WS_ERROR*);
1192
1193 typedef HRESULT (CALLBACK *WS_DECODER_GET_CONTENT_TYPE_CALLBACK)
1194     (void*, const WS_STRING*, const WS_STRING*, WS_STRING*, WS_ERROR*);
1195
1196 typedef HRESULT (CALLBACK *WS_DECODER_START_CALLBACK)
1197     (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1198
1199 typedef HRESULT (CALLBACK *WS_DECODER_DECODE_CALLBACK)
1200     (void*, void*, ULONG, ULONG*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1201
1202 typedef HRESULT (CALLBACK *WS_DECODER_END_CALLBACK)
1203     (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1204
1205 typedef void (CALLBACK *WS_FREE_DECODER_CALLBACK)
1206     (void*);
1207
1208 struct _WS_CHANNEL_DECODER
1209 {
1210     void *createContext;
1211     WS_CREATE_DECODER_CALLBACK createDecoderCallback;
1212     WS_DECODER_GET_CONTENT_TYPE_CALLBACK decoderGetContentTypeCallback;
1213     WS_DECODER_START_CALLBACK decoderStartCallback;
1214     WS_DECODER_DECODE_CALLBACK decoderDecodeCallback;
1215     WS_DECODER_END_CALLBACK decoderEndCallback;
1216     WS_FREE_DECODER_CALLBACK freeDecoderCallback;
1217 };
1218
1219 typedef enum
1220 {
1221     WS_PROTECTION_LEVEL_NONE             = 1,
1222     WS_PROTECTION_LEVEL_SIGN             = 2,
1223     WS_PROTECTION_LEVEL_SIGN_AND_ENCRYPT = 3
1224 } WS_PROTECTION_LEVEL;
1225
1226 typedef enum
1227 {
1228     WS_MANUAL_COOKIE_MODE = 1,
1229     WS_AUTO_COOKIE_MODE   = 2
1230 } WS_COOKIE_MODE;
1231
1232 typedef enum
1233 {
1234     WS_HTTP_PROXY_SETTING_MODE_AUTO   = 0x1,
1235     WS_HTTP_PROXY_SETTING_MODE_NONE   = 0x2,
1236     WS_HTTP_PROXY_SETTING_MODE_CUSTOM = 0x3
1237 } WS_HTTP_PROXY_SETTING_MODE;
1238
1239 struct _WS_CUSTOM_HTTP_PROXY
1240 {
1241     WS_STRING servers;
1242     WS_STRING bypass;
1243 };
1244
1245 struct _WS_HTTP_HEADER_MAPPING
1246 {
1247     WS_XML_STRING headerName;
1248     ULONG headerMappingOptions;
1249 };
1250
1251 struct _WS_HTTP_MESSAGE_MAPPING
1252 {
1253     ULONG requestMappingOptions;
1254     ULONG responseMappingOptions;
1255     WS_HTTP_HEADER_MAPPING **requestHeaderMappings;
1256     ULONG requestHeaderMappingCount;
1257     WS_HTTP_HEADER_MAPPING **responseHeaderMappings;
1258     ULONG responseHeaderMappingCount;
1259 };
1260
1261 typedef HRESULT (CALLBACK *WS_HTTP_REDIRECT_CALLBACK)
1262     (void*, const WS_STRING*, const WS_STRING*);
1263
1264 struct _WS_HTTP_REDIRECT_CALLBACK_CONTEXT
1265 {
1266     WS_HTTP_REDIRECT_CALLBACK callback;
1267     void *state;
1268 };
1269
1270 typedef enum
1271 {
1272     WS_RECEIVE_REQUIRED_MESSAGE = 1,
1273     WS_RECEIVE_OPTIONAL_MESSAGE = 2
1274 } WS_RECEIVE_OPTION;
1275
1276 typedef void (CALLBACK *WS_MESSAGE_DONE_CALLBACK)
1277     (void*);
1278
1279 HRESULT WINAPI WsAddressMessage(WS_MESSAGE*, const WS_ENDPOINT_ADDRESS*, WS_ERROR*);
1280 HRESULT WINAPI WsAlloc(WS_HEAP*, SIZE_T, void**, WS_ERROR*);
1281 HRESULT WINAPI WsCall(WS_SERVICE_PROXY*, const WS_OPERATION_DESCRIPTION*, const void**,
1282                       WS_HEAP*, const WS_CALL_PROPERTY*, const ULONG, const WS_ASYNC_CONTEXT*,
1283                       WS_ERROR*);
1284 HRESULT WINAPI WsCloseChannel(WS_CHANNEL*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1285 HRESULT WINAPI WsCloseServiceProxy(WS_SERVICE_PROXY*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1286 HRESULT WINAPI WsCombineUrl(const WS_STRING*, const WS_STRING*, ULONG, WS_HEAP*, WS_STRING*, WS_ERROR*);
1287 HRESULT WINAPI WsCopyNode(WS_XML_WRITER*, WS_XML_READER*, WS_ERROR*);
1288 HRESULT WINAPI WsCreateChannel(WS_CHANNEL_TYPE, WS_CHANNEL_BINDING, const WS_CHANNEL_PROPERTY*,
1289                                ULONG, const WS_SECURITY_DESCRIPTION*, WS_CHANNEL**, WS_ERROR*);
1290 HRESULT WINAPI WsCreateError(const WS_ERROR_PROPERTY*, ULONG, WS_ERROR**);
1291 HRESULT WINAPI WsCreateHeap(SIZE_T, SIZE_T, const WS_HEAP_PROPERTY*, ULONG, WS_HEAP**, WS_ERROR*);
1292 HRESULT WINAPI WsCreateMessage(WS_ENVELOPE_VERSION, WS_ADDRESSING_VERSION, const WS_MESSAGE_PROPERTY*,
1293                                ULONG, WS_MESSAGE**, WS_ERROR*);
1294 HRESULT WINAPI WsCreateMessageForChannel(WS_CHANNEL*, const WS_MESSAGE_PROPERTY*, ULONG, WS_MESSAGE**,
1295                                          WS_ERROR*);
1296 HRESULT WINAPI WsCreateReader(const WS_XML_READER_PROPERTY*, ULONG, WS_XML_READER**, WS_ERROR*);
1297 HRESULT WINAPI WsCreateServiceProxy(const WS_CHANNEL_TYPE, const WS_CHANNEL_BINDING,
1298                                     const WS_SECURITY_DESCRIPTION*, const WS_PROXY_PROPERTY*,
1299                                     const ULONG, const WS_CHANNEL_PROPERTY*, const ULONG,
1300                                     WS_SERVICE_PROXY**, WS_ERROR*);
1301 HRESULT WINAPI WsCreateServiceProxyFromTemplate(WS_CHANNEL_TYPE, const WS_PROXY_PROPERTY*,
1302                                                 const ULONG, WS_BINDING_TEMPLATE_TYPE,
1303                                                 void*, ULONG, const void*, ULONG,
1304                                                 WS_SERVICE_PROXY**, WS_ERROR*);
1305 HRESULT WINAPI WsCreateWriter(const WS_XML_WRITER_PROPERTY*, ULONG, WS_XML_WRITER**, WS_ERROR*);
1306 HRESULT WINAPI WsCreateXmlBuffer(WS_HEAP*, const WS_XML_BUFFER_PROPERTY*, ULONG, WS_XML_BUFFER**,
1307                                  WS_ERROR*);
1308 HRESULT WINAPI WsDateTimeToFileTime(const WS_DATETIME*, FILETIME*, WS_ERROR*);
1309 HRESULT WINAPI WsDecodeUrl(const WS_STRING*, ULONG, WS_HEAP*, WS_URL**, WS_ERROR*);
1310 HRESULT WINAPI WsEncodeUrl(const WS_URL*, ULONG, WS_HEAP*, WS_STRING*, WS_ERROR*);
1311 HRESULT WINAPI WsFileTimeToDateTime(const FILETIME*, WS_DATETIME*, WS_ERROR*);
1312 HRESULT WINAPI WsFillReader(WS_XML_READER*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1313 HRESULT WINAPI WsFindAttribute(WS_XML_READER*, const WS_XML_STRING*, const WS_XML_STRING*, BOOL,
1314                                ULONG*, WS_ERROR*);
1315 void WINAPI WsFreeChannel(WS_CHANNEL*);
1316 void WINAPI WsFreeError(WS_ERROR*);
1317 void WINAPI WsFreeHeap(WS_HEAP*);
1318 void WINAPI WsFreeMessage(WS_MESSAGE*);
1319 void WINAPI WsFreeReader(WS_XML_READER*);
1320 void WINAPI WsFreeServiceProxy(WS_SERVICE_PROXY*);
1321 void WINAPI WsFreeWriter(WS_XML_WRITER*);
1322 HRESULT WINAPI WsGetChannelProperty(WS_CHANNEL*, WS_CHANNEL_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1323 HRESULT WINAPI WsGetErrorProperty(WS_ERROR*, WS_ERROR_PROPERTY_ID, void*, ULONG);
1324 HRESULT WINAPI WsGetErrorString(WS_ERROR*, ULONG, WS_STRING*);
1325 HRESULT WINAPI WsGetHeapProperty(WS_HEAP*, WS_HEAP_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1326 HRESULT WINAPI WsGetMessageProperty(WS_MESSAGE*, WS_MESSAGE_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1327 HRESULT WINAPI WsGetNamespaceFromPrefix(WS_XML_READER*, const WS_XML_STRING*, BOOL,
1328                                         const WS_XML_STRING**, WS_ERROR*);
1329 HRESULT WINAPI WsGetPrefixFromNamespace(WS_XML_WRITER*, const WS_XML_STRING*, BOOL,
1330                                         const WS_XML_STRING**, WS_ERROR*);
1331 HRESULT WINAPI WsGetReaderNode(WS_XML_READER*, const WS_XML_NODE**, WS_ERROR*);
1332 HRESULT WINAPI WsGetReaderPosition(WS_XML_READER*, WS_XML_NODE_POSITION*, WS_ERROR*);
1333 HRESULT WINAPI WsGetReaderProperty(WS_XML_READER*, WS_XML_READER_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1334 HRESULT WINAPI WsGetServiceProxyProperty(WS_SERVICE_PROXY*, const WS_PROXY_PROPERTY_ID, void*,
1335                                          ULONG, WS_ERROR*);
1336 HRESULT WINAPI WsGetWriterPosition(WS_XML_WRITER*, WS_XML_NODE_POSITION*, WS_ERROR*);
1337 HRESULT WINAPI WsGetWriterProperty(WS_XML_WRITER*, WS_XML_WRITER_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1338 HRESULT WINAPI WsGetXmlAttribute(WS_XML_READER*, const WS_XML_STRING*, WS_HEAP*, WCHAR**,
1339                                  ULONG*, WS_ERROR*);
1340 HRESULT WINAPI WsInitializeMessage(WS_MESSAGE*, WS_MESSAGE_INITIALIZATION, WS_MESSAGE*, WS_ERROR*);
1341 HRESULT WINAPI WsMoveReader(WS_XML_READER*, WS_MOVE_TO, BOOL*, WS_ERROR*);
1342 HRESULT WINAPI WsMoveWriter(WS_XML_WRITER*, WS_MOVE_TO, BOOL*, WS_ERROR*);
1343 HRESULT WINAPI WsOpenChannel(WS_CHANNEL*, const WS_ENDPOINT_ADDRESS*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1344 HRESULT WINAPI WsOpenServiceProxy(WS_SERVICE_PROXY*, const WS_ENDPOINT_ADDRESS*, const WS_ASYNC_CONTEXT*,
1345                                   WS_ERROR*);
1346 HRESULT WINAPI WsReadAttribute(WS_XML_READER*, const WS_ATTRIBUTE_DESCRIPTION*, WS_READ_OPTION,
1347                                WS_HEAP*, void*, ULONG, WS_ERROR*);
1348 HRESULT WINAPI WsReadElement(WS_XML_READER*, const WS_ELEMENT_DESCRIPTION*, WS_READ_OPTION,
1349                              WS_HEAP*, void*, ULONG, WS_ERROR*);
1350 HRESULT WINAPI WsReadEndAttribute(WS_XML_READER*, WS_ERROR*);
1351 HRESULT WINAPI WsReadEndElement(WS_XML_READER*, WS_ERROR*);
1352 HRESULT WINAPI WsReadNode(WS_XML_READER*, WS_ERROR*);
1353 HRESULT WINAPI WsReadStartAttribute(WS_XML_READER*, ULONG, WS_ERROR*);
1354 HRESULT WINAPI WsReadStartElement(WS_XML_READER*, WS_ERROR*);
1355 HRESULT WINAPI WsReadToStartElement(WS_XML_READER*, const WS_XML_STRING*, const WS_XML_STRING*,
1356                                     BOOL*, WS_ERROR*);
1357 HRESULT WINAPI WsReadType(WS_XML_READER*, WS_TYPE_MAPPING, WS_TYPE, const void*, WS_READ_OPTION,
1358                           WS_HEAP*, void*, ULONG, WS_ERROR*);
1359 HRESULT WINAPI WsReadValue(WS_XML_READER*, WS_VALUE_TYPE, void*, ULONG, WS_ERROR*);
1360 HRESULT WINAPI WsReceiveMessage(WS_CHANNEL*, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION**, ULONG,
1361                                 WS_RECEIVE_OPTION, WS_READ_OPTION, WS_HEAP*, void*, ULONG, ULONG*,
1362                                 const WS_ASYNC_CONTEXT*, WS_ERROR*);
1363 HRESULT WINAPI WsRemoveNode(const WS_XML_NODE_POSITION*, WS_ERROR*);
1364 HRESULT WINAPI WsResetError(WS_ERROR*);
1365 HRESULT WINAPI WsResetHeap(WS_HEAP*, WS_ERROR*);
1366 HRESULT WINAPI WsRequestReply(WS_CHANNEL*, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*, WS_WRITE_OPTION,
1367                               const void*, ULONG, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*,
1368                               WS_READ_OPTION, WS_HEAP*, void*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1369 HRESULT WINAPI WsSendMessage(WS_CHANNEL*, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*, WS_WRITE_OPTION,
1370                              const void*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1371 HRESULT WINAPI WsSendReplyMessage(WS_CHANNEL*, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*,
1372                                   WS_WRITE_OPTION, const void*, ULONG, WS_MESSAGE*,
1373                                   const WS_ASYNC_CONTEXT*, WS_ERROR*);
1374 HRESULT WINAPI WsSetChannelProperty(WS_CHANNEL*, WS_CHANNEL_PROPERTY_ID, const void*, ULONG, WS_ERROR*);
1375 HRESULT WINAPI WsSetErrorProperty(WS_ERROR*, WS_ERROR_PROPERTY_ID, const void*, ULONG);
1376 HRESULT WINAPI WsSetInput(WS_XML_READER*, const WS_XML_READER_ENCODING*, const WS_XML_READER_INPUT*,
1377                           const WS_XML_READER_PROPERTY*, ULONG, WS_ERROR*);
1378 HRESULT WINAPI WsSetInputToBuffer(WS_XML_READER*, WS_XML_BUFFER*, const WS_XML_READER_PROPERTY*,
1379                                   ULONG, WS_ERROR*);
1380 HRESULT WINAPI WsSetMessageProperty(WS_MESSAGE*, WS_MESSAGE_PROPERTY_ID, const void*, ULONG, WS_ERROR*);
1381 HRESULT WINAPI WsSetOutput(WS_XML_WRITER*, const WS_XML_WRITER_ENCODING*, const WS_XML_WRITER_OUTPUT*,
1382                            const WS_XML_WRITER_PROPERTY*, ULONG, WS_ERROR*);
1383 HRESULT WINAPI WsSetOutputToBuffer(WS_XML_WRITER*, WS_XML_BUFFER*, const WS_XML_WRITER_PROPERTY*,
1384                                    ULONG, WS_ERROR*);
1385 HRESULT WINAPI WsSetReaderPosition(WS_XML_READER*, const WS_XML_NODE_POSITION*, WS_ERROR*);
1386 HRESULT WINAPI WsSetWriterPosition(WS_XML_WRITER*, const WS_XML_NODE_POSITION*, WS_ERROR*);
1387 HRESULT WINAPI WsSkipNode(WS_XML_READER*, WS_ERROR*);
1388 HRESULT WINAPI WsWriteAttribute(WS_XML_WRITER*, const WS_ATTRIBUTE_DESCRIPTION*, WS_WRITE_OPTION,
1389                                 const void*, ULONG, WS_ERROR*);
1390 HRESULT WINAPI WsWriteBody(WS_MESSAGE*, const WS_ELEMENT_DESCRIPTION*, WS_WRITE_OPTION, const void*,
1391                            ULONG, WS_ERROR*);
1392 HRESULT WINAPI WsWriteElement(WS_XML_WRITER*, const WS_ELEMENT_DESCRIPTION*, WS_WRITE_OPTION,
1393                               const void*, ULONG, WS_ERROR*);
1394 HRESULT WINAPI WsWriteEndAttribute(WS_XML_WRITER*, WS_ERROR*);
1395 HRESULT WINAPI WsWriteEndCData(WS_XML_WRITER*, WS_ERROR*);
1396 HRESULT WINAPI WsWriteEndElement(WS_XML_WRITER*, WS_ERROR*);
1397 HRESULT WINAPI WsWriteEndStartElement(WS_XML_WRITER*, WS_ERROR*);
1398 HRESULT WINAPI WsWriteEnvelopeEnd(WS_MESSAGE*, WS_ERROR*);
1399 HRESULT WINAPI WsWriteEnvelopeStart(WS_MESSAGE*, WS_XML_WRITER*, WS_MESSAGE_DONE_CALLBACK, void*, WS_ERROR*);
1400 HRESULT WINAPI WsWriteMessageStart(WS_CHANNEL*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1401 HRESULT WINAPI WsWriteMessageEnd(WS_CHANNEL*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1402 HRESULT WINAPI WsWriteStartAttribute(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*,
1403                                      const WS_XML_STRING*, BOOL, WS_ERROR*);
1404 HRESULT WINAPI WsWriteStartCData(WS_XML_WRITER*, WS_ERROR*);
1405 HRESULT WINAPI WsWriteStartElement(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*,
1406                                    const WS_XML_STRING*, WS_ERROR*);
1407 HRESULT WINAPI WsWriteText(WS_XML_WRITER*, const WS_XML_TEXT*, WS_ERROR*);
1408 HRESULT WINAPI WsWriteType(WS_XML_WRITER*, WS_TYPE_MAPPING, WS_TYPE, const void*, WS_WRITE_OPTION,
1409                            const void*, ULONG, WS_ERROR*);
1410 HRESULT WINAPI WsWriteValue(WS_XML_WRITER*, WS_VALUE_TYPE, const void*, ULONG, WS_ERROR*);
1411 HRESULT WINAPI WsWriteXmlBuffer(WS_XML_WRITER*, WS_XML_BUFFER*, WS_ERROR*);
1412 HRESULT WINAPI WsWriteXmlBufferToBytes(WS_XML_WRITER*, WS_XML_BUFFER*, const WS_XML_WRITER_ENCODING*,
1413                                        const WS_XML_WRITER_PROPERTY*, ULONG, WS_HEAP*, void**,
1414                                        ULONG*, WS_ERROR*);
1415 HRESULT WINAPI WsWriteXmlnsAttribute(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*,
1416                                      BOOL, WS_ERROR*);
1417 HRESULT WINAPI WsXmlStringEquals(const WS_XML_STRING*, const WS_XML_STRING*, WS_ERROR*);
1418
1419 #define WS_S_ASYNC                          0x003d0000
1420 #define WS_S_END                            0x003d0001
1421 #define WS_E_INVALID_FORMAT                 0x803d0000
1422 #define WS_E_OBJECT_FAULTED                 0x803d0001
1423 #define WS_E_NUMERIC_OVERFLOW               0x803d0002
1424 #define WS_E_INVALID_OPERATION              0x803d0003
1425 #define WS_E_OPERATION_ABORTED              0x803d0004
1426 #define WS_E_ENDPOINT_ACCESS_DENIED         0x803d0005
1427 #define WS_E_OPERATION_TIMED_OUT            0x803d0006
1428 #define WS_E_OPERATION_ABANDONED            0x803d0007
1429 #define WS_E_QUOTA_EXCEEDED                 0x803d0008
1430 #define WS_E_NO_TRANSLATION_AVAILABLE       0x803d0009
1431 #define WS_E_SECURITY_VERIFICATION_FAILURE  0x803d000a
1432 #define WS_E_ADDRESS_IN_USE                 0x803d000b
1433 #define WS_E_ADDRESS_NOT_AVAILABLE          0x803d000c
1434 #define WS_E_ENDPOINT_NOT_FOUND             0x803d000d
1435 #define WS_E_ENDPOINT_NOT_AVAILABLE         0x803d000e
1436 #define WS_E_ENDPOINT_FAILURE               0x803d000f
1437 #define WS_E_ENDPOINT_UNREACHABLE           0x803d0010
1438 #define WS_E_ENDPOINT_ACTION_NOT_SUPPORTED  0x803d0011
1439 #define WS_E_ENDPOINT_TOO_BUSY              0x803d0012
1440 #define WS_E_ENDPOINT_FAULT_RECEIVED        0x803d0013
1441 #define WS_E_ENDPOINT_DISCONNECTED          0x803d0014
1442 #define WS_E_PROXY_FAILURE                  0x803d0015
1443 #define WS_E_PROXY_ACCESS_DENIED            0x803d0016
1444 #define WS_E_NOT_SUPPORTED                  0x803d0017
1445 #define WS_E_PROXY_REQUIRES_BASIC_AUTH      0x803d0018
1446 #define WS_E_PROXY_REQUIRES_DIGEST_AUTH     0x803d0019
1447 #define WS_E_PROXY_REQUIRES_NTLM_AUTH       0x803d001a
1448 #define WS_E_PROXY_REQUIRES_NEGOTIATE_AUTH  0x803d001b
1449 #define WS_E_SERVER_REQUIRES_BASIC_AUTH     0x803d001c
1450 #define WS_E_SERVER_REQUIRES_DIGEST_AUTH    0x803d001d
1451 #define WS_E_SERVER_REQUIRES_NTLM_AUTH      0x803d001e
1452 #define WS_E_SERVER_REQUIRES_NEGOTIATE_AUTH 0x803d001f
1453 #define WS_E_INVALID_ENDPOINT_URL           0x803d0020
1454 #define WS_E_OTHER                          0x803d0021
1455 #define WS_E_SECURITY_TOKEN_EXPIRED         0x803d0022
1456 #define WS_E_SECURITY_SYSTEM_FAILURE        0x803d0023
1457
1458 #ifdef __cplusplus
1459 }
1460 #endif  /* __cplusplus */
1461
1462 #endif /* __WINE_WEBSERVICES_H */