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