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