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