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