master
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
23extern "C" {
24#endif /* __cplusplus */
25
26typedef struct _WS_ERROR WS_ERROR;
27typedef struct _WS_HEAP WS_HEAP;
28typedef struct _WS_XML_BUFFER WS_XML_BUFFER;
29typedef struct _WS_XML_READER WS_XML_READER;
30typedef struct _WS_XML_WRITER WS_XML_WRITER;
31typedef struct _WS_PROXY_PROPERTY WS_PROXY_PROPERTY;
32typedef struct _WS_SECURITY_DESCRIPTION WS_SECURITY_DESCRIPTION;
33typedef struct _WS_CHANNEL_PROPERTY WS_CHANNEL_PROPERTY;
34typedef struct _WS_SERVICE_PROXY WS_SERVICE_PROXY;
35typedef struct _WS_SECURITY_BINDING_PROPERTY WS_SECURITY_BINDING_PROPERTY;
36typedef struct _WS_SECURITY_PROPERTY WS_SECURITY_PROPERTY;
37typedef struct _WS_SECURITY_PROPERTIES WS_SECURITY_PROPERTIES;
38typedef struct _WS_SECURITY_BINDING WS_SECURITY_BINDING;
39typedef struct _WS_CHANNEL WS_CHANNEL;
40typedef struct _WS_MESSAGE_PROPERTY WS_MESSAGE_PROPERTY;
41typedef struct _WS_MESSAGE_PROPERTIES WS_MESSAGE_PROPERTIES;
42typedef struct _WS_HTTP_BINDING_TEMPLATE WS_HTTP_BINDING_TEMPLATE;
43typedef struct _WS_HTTP_SSL_BINDING_TEMPLATE WS_HTTP_SSL_BINDING_TEMPLATE;
44typedef struct _WS_CHANNEL_PROPERTIES WS_CHANNEL_PROPERTIES;
45typedef struct _WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE;
46typedef struct _WS_SECURITY_BINDING_PROPERTIES WS_SECURITY_BINDING_PROPERTIES;
47typedef struct _WS_CERT_CREDENTIAL WS_CERT_CREDENTIAL;
48typedef struct _WS_ENDPOINT_ADDRESS WS_ENDPOINT_ADDRESS;
49typedef struct _WS_ENDPOINT_IDENTITY WS_ENDPOINT_IDENTITY;
50typedef struct _WS_ENUM_DESCRIPTION WS_ENUM_DESCRIPTION;
51typedef struct _WS_ENUM_VALUE WS_ENUM_VALUE;
52typedef struct _WS_HTTP_POLICY_DESCRIPTION WS_HTTP_POLICY_DESCRIPTION;
53typedef struct _WS_MESSAGE WS_MESSAGE;
54typedef struct _WS_MESSAGE_DESCRIPTION WS_MESSAGE_DESCRIPTION;
55typedef struct _WS_OPERATION_DESCRIPTION WS_OPERATION_DESCRIPTION;
56typedef struct _WS_PARAMETER_DESCRIPTION WS_PARAMETER_DESCRIPTION;
57typedef struct _WS_OPERATION_CONTEXT WS_OPERATION_CONTEXT;
58typedef struct _WS_CALL_PROPERTY WS_CALL_PROPERTY;
59typedef struct _WS_FLOAT_DESCRIPTION WS_FLOAT_DESCRIPTION;
60typedef struct _WS_DOUBLE_DESCRIPTION WS_DOUBLE_DESCRIPTION;
61typedef struct _WS_DATETIME WS_DATETIME;
62typedef struct _WS_XML_DATETIME_TEXT WS_XML_DATETIME_TEXT;
63typedef struct _WS_XML_BASE64_TEXT WS_XML_BASE64_TEXT;
64typedef struct _WS_DATETIME_DESCRIPTION WS_DATETIME_DESCRIPTION;
65typedef struct _WS_GUID_DESCRIPTION WS_GUID_DESCRIPTION;
66typedef struct _WS_UNIQUE_ID_DESCRIPTION WS_UNIQUE_ID_DESCRIPTION;
67typedef struct _WS_BYTES_DESCRIPTION WS_BYTES_DESCRIPTION;
68typedef struct _WS_URL WS_URL;
69typedef struct _WS_HTTP_URL WS_HTTP_URL;
70typedef struct _WS_HTTPS_URL WS_HTTPS_URL;
71typedef struct _WS_NETTCP_URL WS_NETTCP_URL;
72typedef struct _WS_SOAPUDP_URL WS_SOAPUDP_URL;
73typedef struct _WS_NETPIPE_URL WS_NETPIPE_URL;
74typedef struct _WS_CUSTOM_CHANNEL_CALLBACKS WS_CUSTOM_CHANNEL_CALLBACKS;
75typedef struct _WS_CHANNEL_ENCODER WS_CHANNEL_ENCODER;
76typedef struct _WS_CHANNEL_DECODER WS_CHANNEL_DECODER;
77typedef struct _WS_CUSTOM_HTTP_PROXY WS_CUSTOM_HTTP_PROXY;
78typedef struct _WS_HTTP_MESSAGE_MAPPING WS_HTTP_MESSAGE_MAPPING;
79typedef struct _WS_HTTP_HEADER_MAPPING WS_HTTP_HEADER_MAPPING;
80typedef struct _WS_HTTP_REDIRECT_CALLBACK_CONTEXT WS_HTTP_REDIRECT_CALLBACK_CONTEXT;
81typedef struct _WS_PROXY_MESSAGE_CALLBACK_CONTEXT WS_PROXY_MESSAGE_CALLBACK_CONTEXT;
82typedef struct _WS_LISTENER WS_LISTENER;
83typedef struct _WS_LISTENER_PROPERTY WS_LISTENER_PROPERTY;
84typedef struct _WS_DISALLOWED_USER_AGENT_SUBSTRINGS WS_DISALLOWED_USER_AGENT_SUBSTRINGS;
85typedef struct _WS_LISTENER_PROPERTIES WS_LISTENER_PROPERTIES;
86typedef struct _WS_CUSTOM_LISTENER_CALLBACKS WS_CUSTOM_LISTENER_CALLBACKS;
87
88struct _WS_STRUCT_DESCRIPTION;
89struct _WS_XML_STRING;
90
91typedef 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
97typedef struct _WS_ERROR_PROPERTY {
98 WS_ERROR_PROPERTY_ID id;
99 void *value;
100 ULONG valueSize;
101} WS_ERROR_PROPERTY;
102
103typedef 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
110typedef struct _WS_HEAP_PROPERTY {
111 WS_HEAP_PROPERTY_ID id;
112 void *value;
113 ULONG valueSize;
114} WS_HEAP_PROPERTY;
115
116typedef struct _WS_HEAP_PROPERTIES {
117 WS_HEAP_PROPERTY *properties;
118 ULONG propertyCount;
119} WS_HEAP_PROPERTIES;
120
121typedef ULONG WS_XML_BUFFER_PROPERTY_ID;
122
123typedef struct _WS_XML_BUFFER_PROPERTY {
124 WS_XML_BUFFER_PROPERTY_ID id;
125 void *value;
126 ULONG valueSize;
127} WS_XML_BUFFER_PROPERTY;
128
129typedef 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
147typedef struct _WS_XML_READER_PROPERTY {
148 WS_XML_READER_PROPERTY_ID id;
149 void *value;
150 ULONG valueSize;
151} WS_XML_READER_PROPERTY;
152
153typedef struct _WS_XML_READER_PROPERTIES {
154 WS_XML_READER_PROPERTY *properties;
155 ULONG propertyCount;
156} WS_XML_READER_PROPERTIES;
157
158typedef 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
180typedef struct _WS_XML_WRITER_PROPERTY {
181 WS_XML_WRITER_PROPERTY_ID id;
182 void *value;
183 ULONG valueSize;
184} WS_XML_WRITER_PROPERTY;
185
186typedef struct _WS_XML_WRITER_PROPERTIES {
187 WS_XML_WRITER_PROPERTY *properties;
188 ULONG propertyCount;
189} WS_XML_WRITER_PROPERTIES;
190
191typedef struct _WS_BYTES {
192 ULONG length;
193 BYTE *bytes;
194} WS_BYTES;
195
196typedef struct _WS_BUFFERS {
197 ULONG bufferCount;
198 WS_BYTES *buffers;
199} WS_BUFFERS;
200
201typedef 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
208typedef struct _WS_XML_READER_ENCODING {
209 WS_XML_READER_ENCODING_TYPE encodingType;
210} WS_XML_READER_ENCODING;
211
212typedef 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
219typedef struct _WS_XML_WRITER_ENCODING {
220 WS_XML_WRITER_ENCODING_TYPE encodingType;
221} WS_XML_WRITER_ENCODING;
222
223typedef enum {
224 WS_CHARSET_AUTO,
225 WS_CHARSET_UTF8,
226 WS_CHARSET_UTF16LE,
227 WS_CHARSET_UTF16BE
228} WS_CHARSET;
229
230typedef struct _WS_XML_DICTIONARY {
231 GUID guid;
232 struct _WS_XML_STRING *strings;
233 ULONG stringCount;
234 WINBOOL isConst;
235} WS_XML_DICTIONARY;
236
237typedef struct _WS_XML_STRING {
238 ULONG length;
239 BYTE *bytes;
240 WS_XML_DICTIONARY *dictionary;
241 ULONG id;
242} WS_XML_STRING;
243
244typedef struct _WS_XML_READER_TEXT_ENCODING {
245 WS_XML_READER_ENCODING encoding;
246 WS_CHARSET charSet;
247} WS_XML_READER_TEXT_ENCODING;
248
249typedef 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
255typedef struct _WS_XML_WRITER_TEXT_ENCODING {
256 WS_XML_WRITER_ENCODING encoding;
257 WS_CHARSET charSet;
258} WS_XML_WRITER_TEXT_ENCODING;
259
260typedef HRESULT (CALLBACK *WS_DYNAMIC_STRING_CALLBACK)
261 (void*, const WS_XML_STRING*, WINBOOL*, ULONG*, WS_ERROR*);
262
263typedef 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
270typedef enum {
271 WS_XML_READER_INPUT_TYPE_BUFFER = 1,
272 WS_XML_READER_INPUT_TYPE_STREAM = 2
273} WS_XML_READER_INPUT_TYPE;
274
275typedef enum {
276 WS_XML_WRITER_OUTPUT_TYPE_BUFFER = 1,
277 WS_XML_WRITER_OUTPUT_TYPE_STREAM = 2
278} WS_XML_WRITER_OUTPUT_TYPE;
279
280typedef struct _WS_XML_READER_INPUT {
281 WS_XML_READER_INPUT_TYPE inputType;
282} WS_XML_READER_INPUT;
283
284typedef struct _WS_XML_WRITER_OUTPUT {
285 WS_XML_WRITER_OUTPUT_TYPE outputType;
286} WS_XML_WRITER_OUTPUT;
287
288typedef 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
294typedef struct _WS_XML_WRITER_BUFFER_OUTPUT {
295 WS_XML_WRITER_OUTPUT output;
296} WS_XML_WRITER_BUFFER_OUTPUT;
297
298typedef enum {
299 WS_SHORT_CALLBACK,
300 WS_LONG_CALLBACK
301} WS_CALLBACK_MODEL;
302
303typedef void (CALLBACK *WS_ASYNC_CALLBACK)
304 (HRESULT, WS_CALLBACK_MODEL, void *);
305
306typedef struct _WS_ASYNC_CONTEXT {
307 WS_ASYNC_CALLBACK callback;
308 void *callbackState;
309} WS_ASYNC_CONTEXT;
310
311typedef HRESULT (CALLBACK *WS_READ_CALLBACK)
312 (void*, void*, ULONG, ULONG*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
313
314typedef 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
320typedef HRESULT (CALLBACK *WS_WRITE_CALLBACK)
321 (void*, const WS_BYTES*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
322
323typedef 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
329typedef 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
336typedef 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
374typedef 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
382typedef 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
389typedef struct _WS_BOOL_DESCRIPTION {
390 WINBOOL value;
391} WS_BOOL_DESCRIPTION;
392
393typedef struct _WS_INT8_DESCRIPTION {
394 char minValue;
395 char maxValue;
396} WS_INT8_DESCRIPTION;
397
398typedef struct _WS_INT16_DESCRIPTION {
399 short minValue;
400 short maxValue;
401} WS_INT16_DESCRIPTION;
402
403typedef struct _WS_INT32_DESCRIPTION {
404 int minValue;
405 int maxValue;
406} WS_INT32_DESCRIPTION;
407
408typedef struct _WS_INT64_DESCRIPTION {
409 __int64 DECLSPEC_ALIGN(8) minValue;
410 __int64 DECLSPEC_ALIGN(8) maxValue;
411} WS_INT64_DESCRIPTION;
412
413typedef struct _WS_UINT8_DESCRIPTION {
414 BYTE minValue;
415 BYTE maxValue;
416} WS_UINT8_DESCRIPTION;
417
418typedef struct _WS_UINT16_DESCRIPTION {
419 USHORT minValue;
420 USHORT maxValue;
421} WS_UINT16_DESCRIPTION;
422
423typedef struct _WS_UINT32_DESCRIPTION {
424 ULONG minValue;
425 ULONG maxValue;
426} WS_UINT32_DESCRIPTION;
427
428typedef struct _WS_UINT64_DESCRIPTION {
429 unsigned __int64 DECLSPEC_ALIGN(8) minValue;
430 unsigned __int64 DECLSPEC_ALIGN(8) maxValue;
431} WS_UINT64_DESCRIPTION;
432
433typedef struct _WS_WSZ_DESCRIPTION {
434 ULONG minCharCount;
435 ULONG maxCharCount;
436} WS_WSZ_DESCRIPTION;
437
438typedef struct _WS_STRING_DESCRIPTION {
439 ULONG minCharCount;
440 ULONG maxCharCount;
441} WS_STRING_DESCRIPTION;
442
443typedef struct _WS_XML_STRING_DESCRIPTION {
444 ULONG minByteCount;
445 ULONG maxByteCount;
446} WS_XML_STRING_DESCRIPTION;
447
448typedef struct _WS_XML_QNAME_DESCRIPTION {
449 ULONG minLocalNameByteCount;
450 ULONG maxLocalNameByteCount;
451 ULONG minNsByteCount;
452 ULONG maxNsByteCount;
453} WS_XML_QNAME_DESCRIPTION;
454
455struct _WS_ENUM_VALUE {
456 int value;
457 WS_XML_STRING *name;
458};
459
460struct _WS_ENUM_DESCRIPTION {
461 WS_ENUM_VALUE *values;
462 ULONG valueCount;
463 ULONG maxByteCount;
464 ULONG *nameIndices;
465};
466
467struct _WS_FLOAT_DESCRIPTION {
468 float minValue;
469 float maxValue;
470};
471
472struct _WS_DOUBLE_DESCRIPTION {
473 double DECLSPEC_ALIGN(8) minValue;
474 double DECLSPEC_ALIGN(8) maxValue;
475};
476
477struct _WS_GUID_DESCRIPTION {
478 GUID value;
479};
480
481struct _WS_UNIQUE_ID_DESCRIPTION {
482 ULONG minCharCount;
483 ULONG maxCharCount;
484};
485
486struct _WS_BYTES_DESCRIPTION {
487 ULONG minByteCount;
488 ULONG maxByteCount;
489};
490
491typedef 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
507typedef struct _WS_DEFAULT_VALUE {
508 void *value;
509 ULONG valueSize;
510} WS_DEFAULT_VALUE;
511
512typedef struct _WS_ITEM_RANGE {
513 ULONG minItemCount;
514 ULONG maxItemCount;
515} WS_ITEM_RANGE;
516
517enum
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
526typedef 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
541enum
542{
543 WS_STRUCT_ABSTRACT = 0x1,
544 WS_STRUCT_IGNORE_TRAILING_ELEMENT_CONTENT = 0x2,
545 WS_STRUCT_IGNORE_UNHANDLED_ATTRIBUTES = 0x4
546};
547
548typedef 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
561typedef struct _WS_UNION_FIELD_DESCRIPTION {
562 int value;
563 WS_FIELD_DESCRIPTION field;
564} WS_UNION_FIELD_DESCRIPTION;
565
566typedef 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
576typedef 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
583typedef 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
590typedef struct _WS_STRING {
591 ULONG length;
592 WCHAR *chars;
593} WS_STRING;
594
595typedef struct _WS_UNIQUE_ID {
596 WS_STRING uri;
597 GUID guid;
598} WS_UNIQUE_ID;
599
600typedef 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
611typedef struct _WS_XML_NODE {
612 WS_XML_NODE_TYPE nodeType;
613} WS_XML_NODE;
614
615typedef 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
630typedef 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
649typedef struct _WS_XML_TEXT {
650 WS_XML_TEXT_TYPE textType;
651} WS_XML_TEXT;
652
653typedef struct _WS_XML_UTF8_TEXT {
654 WS_XML_TEXT text;
655 WS_XML_STRING value;
656} WS_XML_UTF8_TEXT;
657
658typedef struct _WS_XML_UTF16_TEXT {
659 WS_XML_TEXT text;
660 BYTE *bytes;
661 ULONG byteCount;
662} WS_XML_UTF16_TEXT;
663
664typedef struct _WS_XML_BOOL_TEXT {
665 WS_XML_TEXT text;
666 WINBOOL value;
667} WS_XML_BOOL_TEXT;
668
669typedef struct _WS_XML_INT32_TEXT {
670 WS_XML_TEXT text;
671 __int32 value;
672} WS_XML_INT32_TEXT;
673
674typedef struct _WS_XML_INT64_TEXT {
675 WS_XML_TEXT text;
676 __int64 DECLSPEC_ALIGN(8) value;
677} WS_XML_INT64_TEXT;
678
679typedef struct _WS_XML_UINT64_TEXT {
680 WS_XML_TEXT text;
681 unsigned __int64 DECLSPEC_ALIGN(8) value;
682} WS_XML_UINT64_TEXT;
683
684typedef struct _WS_XML_FLOAT_TEXT {
685 WS_XML_TEXT text;
686 float value;
687} WS_XML_FLOAT_TEXT;
688
689typedef struct _WS_XML_DOUBLE_TEXT {
690 WS_XML_TEXT text;
691 double DECLSPEC_ALIGN(8) value;
692} WS_XML_DOUBLE_TEXT;
693
694typedef struct _WS_XML_GUID_TEXT {
695 WS_XML_TEXT text;
696 GUID value;
697} WS_XML_GUID_TEXT;
698
699typedef struct _WS_XML_UNIQUE_ID_TEXT {
700 WS_XML_TEXT text;
701 GUID value;
702} WS_XML_UNIQUE_ID_TEXT;
703
704typedef 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
711typedef 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
730typedef 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
739typedef 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 WINBOOL isEmpty;
747} WS_XML_ELEMENT_NODE;
748
749typedef struct _WS_XML_TEXT_NODE {
750 WS_XML_NODE node;
751 WS_XML_TEXT *text;
752} WS_XML_TEXT_NODE;
753
754typedef struct _WS_XML_COMMENT_NODE {
755 WS_XML_NODE node;
756 WS_XML_STRING value;
757} WS_XML_COMMENT_NODE;
758
759typedef struct _WS_XML_NODE_POSITION {
760 WS_XML_BUFFER *buffer;
761 void *node;
762} WS_XML_NODE_POSITION;
763
764typedef struct _WS_XML_QNAME {
765 WS_XML_STRING localName;
766 WS_XML_STRING ns;
767} WS_XML_QNAME;
768
769typedef 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
778typedef 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
788struct _WS_PROXY_PROPERTY {
789 WS_PROXY_PROPERTY_ID id;
790 void *value;
791 ULONG valueSize;
792};
793
794typedef 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
806typedef 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
818typedef 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
828typedef 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
881struct _WS_CHANNEL_PROPERTY {
882 WS_CHANNEL_PROPERTY_ID id;
883 void *value;
884 ULONG valueSize;
885};
886
887struct _WS_CHANNEL_PROPERTIES {
888 WS_CHANNEL_PROPERTY *properties;
889 ULONG propertyCount;
890};
891
892typedef 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
900typedef 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
912typedef 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
938struct _WS_SECURITY_BINDING_PROPERTY {
939 WS_SECURITY_BINDING_PROPERTY_ID id;
940 void *value;
941 ULONG valueSize;
942};
943
944struct _WS_SECURITY_BINDING_PROPERTIES {
945 WS_SECURITY_BINDING_PROPERTY *properties;
946 ULONG propertyCount;
947};
948
949struct _WS_SECURITY_BINDING {
950 WS_SECURITY_BINDING_TYPE bindingType;
951 WS_SECURITY_BINDING_PROPERTY *properties;
952 ULONG propertyCount;
953};
954
955typedef 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
970struct _WS_SECURITY_PROPERTY {
971 WS_SECURITY_PROPERTY_ID id;
972 void *value;
973 ULONG valueSize;
974};
975
976struct _WS_SECURITY_PROPERTIES {
977 WS_SECURITY_PROPERTY *properties;
978 ULONG propertyCount;
979};
980
981struct _WS_SECURITY_DESCRIPTION {
982 WS_SECURITY_BINDING **securityBindings;
983 ULONG securityBindingCount;
984 WS_SECURITY_PROPERTY *properties;
985 ULONG propertyCount;
986};
987
988typedef 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
1005typedef 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
1011struct _WS_CERT_CREDENTIAL {
1012 WS_CERT_CREDENTIAL_TYPE credentialType;
1013};
1014
1015struct _WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE {
1016 WS_SECURITY_BINDING_PROPERTIES securityBindingProperties;
1017 WS_CERT_CREDENTIAL *localCertCredential;
1018};
1019
1020struct _WS_HTTP_BINDING_TEMPLATE {
1021 WS_CHANNEL_PROPERTIES channelProperties;
1022};
1023
1024struct _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
1030enum {
1031 WS_MUST_UNDERSTAND_HEADER_ATTRIBUTE = 0x1,
1032 WS_RELAY_HEADER_ATTRIBUTE = 0x2
1033};
1034
1035typedef 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
1041typedef 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
1047typedef 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
1072struct _WS_MESSAGE_PROPERTY {
1073 WS_MESSAGE_PROPERTY_ID id;
1074 void *value;
1075 ULONG valueSize;
1076};
1077
1078struct _WS_MESSAGE_PROPERTIES {
1079 WS_MESSAGE_PROPERTY *properties;
1080 ULONG propertyCount;
1081};
1082
1083typedef 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
1091typedef 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
1099typedef 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
1109typedef enum {
1110 WS_REPEATING_HEADER = 1,
1111 WS_SINGLETON_HEADER = 2
1112} WS_REPEATING_HEADER_OPTION;
1113
1114typedef 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
1123struct _WS_ENDPOINT_IDENTITY {
1124 WS_ENDPOINT_IDENTITY_TYPE identityType;
1125};
1126
1127struct _WS_ENDPOINT_ADDRESS {
1128 WS_STRING url;
1129 WS_XML_BUFFER *headers;
1130 WS_XML_BUFFER *extensions;
1131 WS_ENDPOINT_IDENTITY *identity;
1132};
1133
1134typedef struct _WS_FAULT_CODE {
1135 WS_XML_QNAME value;
1136 struct _WS_FAULT_CODE *subCode;
1137} WS_FAULT_CODE;
1138
1139typedef struct _WS_FAULT_REASON {
1140 WS_STRING text;
1141 WS_STRING lang;
1142} WS_FAULT_REASON;
1143
1144typedef 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
1153typedef struct _WS_FAULT_DESCRIPTION {
1154 WS_ENVELOPE_VERSION envelopeVersion;
1155} WS_FAULT_DESCRIPTION;
1156
1157typedef struct _WS_FAULT_DETAIL_DESCRIPTION {
1158 WS_XML_STRING *action;
1159 WS_ELEMENT_DESCRIPTION *detailElementDescription;
1160} WS_FAULT_DETAIL_DESCRIPTION;
1161
1162typedef 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
1169struct _WS_HTTP_POLICY_DESCRIPTION {
1170 WS_CHANNEL_PROPERTIES channelProperties;
1171};
1172
1173struct _WS_MESSAGE_DESCRIPTION {
1174 WS_XML_STRING *action;
1175 WS_ELEMENT_DESCRIPTION *bodyElementDescription;
1176};
1177
1178typedef 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
1185struct _WS_PARAMETER_DESCRIPTION {
1186 WS_PARAMETER_TYPE parameterType;
1187 USHORT inputMessageIndex;
1188 USHORT outputMessageIndex;
1189};
1190
1191typedef 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
1198typedef enum {
1199 WS_NON_RPC_LITERAL_OPERATION,
1200 WS_RPC_LITERAL_OPERATION
1201} WS_OPERATION_STYLE;
1202
1203struct _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
1215typedef 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
1222struct _WS_CALL_PROPERTY {
1223 WS_CALL_PROPERTY_ID id;
1224 void *value;
1225 ULONG valueSize;
1226};
1227
1228typedef enum {
1229 WS_DATETIME_FORMAT_UTC,
1230 WS_DATETIME_FORMAT_LOCAL,
1231 WS_DATETIME_FORMAT_NONE
1232} WS_DATETIME_FORMAT;
1233
1234struct _WS_DATETIME {
1235 unsigned __int64 DECLSPEC_ALIGN(8) ticks;
1236 WS_DATETIME_FORMAT format;
1237};
1238
1239struct _WS_DATETIME_DESCRIPTION {
1240 WS_DATETIME minValue;
1241 WS_DATETIME maxValue;
1242};
1243
1244struct _WS_XML_DATETIME_TEXT {
1245 WS_XML_TEXT text;
1246 WS_DATETIME value;
1247};
1248
1249struct _WS_XML_BASE64_TEXT {
1250 WS_XML_TEXT text;
1251 BYTE *bytes;
1252 ULONG length;
1253};
1254
1255typedef 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
1263enum {
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
1269struct _WS_URL {
1270 WS_URL_SCHEME_TYPE scheme;
1271};
1272
1273struct _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
1283struct _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
1293struct _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
1303struct _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
1313struct _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
1323typedef 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
1330typedef 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
1338typedef HRESULT (CALLBACK *WS_CREATE_CHANNEL_CALLBACK)
1339 (WS_CHANNEL_TYPE, const void*, ULONG, void**, WS_ERROR*);
1340
1341typedef void (CALLBACK *WS_FREE_CHANNEL_CALLBACK)
1342 (void*);
1343
1344typedef HRESULT (CALLBACK *WS_RESET_CHANNEL_CALLBACK)
1345 (void*, WS_ERROR*);
1346
1347typedef HRESULT (CALLBACK *WS_OPEN_CHANNEL_CALLBACK)
1348 (void*, const WS_ENDPOINT_ADDRESS*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1349
1350typedef HRESULT (CALLBACK *WS_CLOSE_CHANNEL_CALLBACK)
1351 (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1352
1353typedef HRESULT (CALLBACK *WS_ABORT_CHANNEL_CALLBACK)
1354 (void*, WS_ERROR*);
1355
1356typedef HRESULT (CALLBACK *WS_GET_CHANNEL_PROPERTY_CALLBACK)
1357 (void*, WS_CHANNEL_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1358
1359typedef HRESULT (CALLBACK *WS_SET_CHANNEL_PROPERTY_CALLBACK)
1360 (void*, WS_CHANNEL_PROPERTY_ID, const void*, ULONG, WS_ERROR*);
1361
1362typedef HRESULT (CALLBACK *WS_WRITE_MESSAGE_START_CALLBACK)
1363 (void*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1364
1365typedef HRESULT (CALLBACK *WS_WRITE_MESSAGE_END_CALLBACK)
1366 (void*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1367
1368typedef HRESULT (CALLBACK *WS_READ_MESSAGE_START_CALLBACK)
1369 (void*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1370
1371typedef HRESULT (CALLBACK *WS_READ_MESSAGE_END_CALLBACK)
1372 (void*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1373
1374typedef HRESULT (CALLBACK *WS_ABANDON_MESSAGE_CALLBACK)
1375 (void*, WS_MESSAGE*, WS_ERROR*);
1376
1377typedef HRESULT (CALLBACK *WS_SHUTDOWN_SESSION_CHANNEL_CALLBACK)
1378 (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1379
1380struct _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
1398typedef HRESULT (CALLBACK *WS_CREATE_ENCODER_CALLBACK)
1399 (void*, WS_WRITE_CALLBACK, void*, void**, WS_ERROR*);
1400
1401typedef HRESULT (CALLBACK *WS_ENCODER_GET_CONTENT_TYPE_CALLBACK)
1402 (void*, const WS_STRING*, WS_STRING*, WS_STRING*, WS_ERROR*);
1403
1404typedef HRESULT (CALLBACK *WS_ENCODER_START_CALLBACK)
1405 (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1406
1407typedef HRESULT (CALLBACK *WS_ENCODER_ENCODE_CALLBACK)
1408 (void*, const WS_BYTES*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1409
1410typedef HRESULT (CALLBACK *WS_ENCODER_END_CALLBACK)
1411 (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1412
1413typedef void (CALLBACK *WS_FREE_ENCODER_CALLBACK)
1414 (void*);
1415
1416struct _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
1427typedef HRESULT (CALLBACK *WS_CREATE_DECODER_CALLBACK)
1428 (void*, WS_READ_CALLBACK, void*, void**, WS_ERROR*);
1429
1430typedef HRESULT (CALLBACK *WS_DECODER_GET_CONTENT_TYPE_CALLBACK)
1431 (void*, const WS_STRING*, const WS_STRING*, WS_STRING*, WS_ERROR*);
1432
1433typedef HRESULT (CALLBACK *WS_DECODER_START_CALLBACK)
1434 (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1435
1436typedef HRESULT (CALLBACK *WS_DECODER_DECODE_CALLBACK)
1437 (void*, void*, ULONG, ULONG*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1438
1439typedef HRESULT (CALLBACK *WS_DECODER_END_CALLBACK)
1440 (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1441
1442typedef void (CALLBACK *WS_FREE_DECODER_CALLBACK)
1443 (void*);
1444
1445struct _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
1456typedef 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
1463typedef enum
1464{
1465 WS_MANUAL_COOKIE_MODE = 1,
1466 WS_AUTO_COOKIE_MODE = 2
1467} WS_COOKIE_MODE;
1468
1469typedef 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
1476struct _WS_CUSTOM_HTTP_PROXY
1477{
1478 WS_STRING servers;
1479 WS_STRING bypass;
1480};
1481
1482struct _WS_HTTP_HEADER_MAPPING
1483{
1484 WS_XML_STRING headerName;
1485 ULONG headerMappingOptions;
1486};
1487
1488struct _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
1498typedef HRESULT (CALLBACK *WS_HTTP_REDIRECT_CALLBACK)
1499 (void*, const WS_STRING*, const WS_STRING*);
1500
1501struct _WS_HTTP_REDIRECT_CALLBACK_CONTEXT
1502{
1503 WS_HTTP_REDIRECT_CALLBACK callback;
1504 void *state;
1505};
1506
1507typedef enum
1508{
1509 WS_RECEIVE_REQUIRED_MESSAGE = 1,
1510 WS_RECEIVE_OPTIONAL_MESSAGE = 2
1511} WS_RECEIVE_OPTION;
1512
1513typedef void (CALLBACK *WS_MESSAGE_DONE_CALLBACK)
1514 (void*);
1515
1516typedef HRESULT (CALLBACK *WS_PROXY_MESSAGE_CALLBACK)
1517 (WS_MESSAGE*, WS_HEAP*, void*, WS_ERROR*);
1518
1519struct _WS_PROXY_MESSAGE_CALLBACK_CONTEXT
1520{
1521 WS_PROXY_MESSAGE_CALLBACK callback;
1522 void *state;
1523};
1524
1525typedef 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
1535typedef 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
1556struct _WS_LISTENER_PROPERTY
1557{
1558 WS_LISTENER_PROPERTY_ID id;
1559 void *value;
1560 ULONG valueSize;
1561};
1562
1563struct _WS_DISALLOWED_USER_AGENT_SUBSTRINGS
1564{
1565 ULONG subStringCount;
1566 WS_STRING **subStrings;
1567};
1568
1569struct _WS_LISTENER_PROPERTIES
1570{
1571 WS_LISTENER_PROPERTY *properties;
1572 ULONG propertyCount;
1573};
1574
1575typedef HRESULT (CALLBACK *WS_CREATE_LISTENER_CALLBACK)
1576 (WS_CHANNEL_TYPE, const void*, ULONG, void**, WS_ERROR*);
1577
1578typedef void (CALLBACK *WS_FREE_LISTENER_CALLBACK)
1579 (void*);
1580
1581typedef HRESULT (CALLBACK *WS_RESET_LISTENER_CALLBACK)
1582 (void*, WS_ERROR*);
1583
1584typedef HRESULT (CALLBACK *WS_OPEN_LISTENER_CALLBACK)
1585 (void*, const WS_STRING*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1586
1587typedef HRESULT (CALLBACK *WS_CLOSE_LISTENER_CALLBACK)
1588 (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1589
1590typedef HRESULT (CALLBACK *WS_ABORT_LISTENER_CALLBACK)
1591 (void*, WS_ERROR*);
1592
1593typedef HRESULT (CALLBACK *WS_GET_LISTENER_PROPERTY_CALLBACK)
1594 (void*, WS_LISTENER_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1595
1596typedef HRESULT (CALLBACK *WS_SET_LISTENER_PROPERTY_CALLBACK)
1597 (void*, WS_LISTENER_PROPERTY_ID, const void*, ULONG, WS_ERROR*);
1598
1599typedef HRESULT (CALLBACK *WS_CREATE_CHANNEL_FOR_LISTENER_CALLBACK)
1600 (void*, const void*, ULONG, void**, WS_ERROR*);
1601
1602typedef HRESULT (CALLBACK *WS_ACCEPT_CHANNEL_CALLBACK)
1603 (void*, void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1604
1605struct _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
1619enum
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
1637HRESULT WINAPI WsAbortServiceProxy(WS_SERVICE_PROXY*, WS_ERROR*);
1638HRESULT WINAPI WsAcceptChannel(WS_LISTENER*, WS_CHANNEL*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1639HRESULT WINAPI WsAddCustomHeader(WS_MESSAGE*, const WS_ELEMENT_DESCRIPTION*, WS_WRITE_OPTION,
1640 const void*, ULONG, ULONG, WS_ERROR*);
1641HRESULT WINAPI WsAddErrorString(WS_ERROR*, const WS_STRING*);
1642HRESULT WINAPI WsAddMappedHeader(WS_MESSAGE*, const WS_XML_STRING*, WS_TYPE, WS_WRITE_OPTION,
1643 const void*, ULONG, WS_ERROR*);
1644HRESULT WINAPI WsAddressMessage(WS_MESSAGE*, const WS_ENDPOINT_ADDRESS*, WS_ERROR*);
1645HRESULT WINAPI WsAlloc(WS_HEAP*, SIZE_T, void**, WS_ERROR*);
1646HRESULT 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*);
1649HRESULT WINAPI WsCloseChannel(WS_CHANNEL*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1650HRESULT WINAPI WsCloseListener(WS_LISTENER*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1651HRESULT WINAPI WsCloseServiceProxy(WS_SERVICE_PROXY*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1652HRESULT WINAPI WsCombineUrl(const WS_STRING*, const WS_STRING*, ULONG, WS_HEAP*, WS_STRING*, WS_ERROR*);
1653HRESULT WINAPI WsCopyNode(WS_XML_WRITER*, WS_XML_READER*, WS_ERROR*);
1654HRESULT WINAPI WsCreateChannel(WS_CHANNEL_TYPE, WS_CHANNEL_BINDING, const WS_CHANNEL_PROPERTY*,
1655 ULONG, const WS_SECURITY_DESCRIPTION*, WS_CHANNEL**, WS_ERROR*);
1656HRESULT WINAPI WsCreateChannelForListener(WS_LISTENER*, const WS_CHANNEL_PROPERTY*, ULONG, WS_CHANNEL**,
1657 WS_ERROR*);
1658HRESULT WINAPI WsCreateError(const WS_ERROR_PROPERTY*, ULONG, WS_ERROR**);
1659HRESULT WINAPI WsCreateHeap(SIZE_T, SIZE_T, const WS_HEAP_PROPERTY*, ULONG, WS_HEAP**, WS_ERROR*);
1660HRESULT WINAPI WsCreateListener(WS_CHANNEL_TYPE, WS_CHANNEL_BINDING, const WS_LISTENER_PROPERTY*,
1661 ULONG, const WS_SECURITY_DESCRIPTION*, WS_LISTENER**, WS_ERROR*);
1662HRESULT WINAPI WsCreateMessage(WS_ENVELOPE_VERSION, WS_ADDRESSING_VERSION, const WS_MESSAGE_PROPERTY*,
1663 ULONG, WS_MESSAGE**, WS_ERROR*);
1664HRESULT WINAPI WsCreateMessageForChannel(WS_CHANNEL*, const WS_MESSAGE_PROPERTY*, ULONG, WS_MESSAGE**,
1665 WS_ERROR*);
1666HRESULT WINAPI WsCreateReader(const WS_XML_READER_PROPERTY*, ULONG, WS_XML_READER**, WS_ERROR*);
1667HRESULT 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*);
1671HRESULT 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*);
1675HRESULT WINAPI WsCreateWriter(const WS_XML_WRITER_PROPERTY*, ULONG, WS_XML_WRITER**, WS_ERROR*);
1676HRESULT WINAPI WsCreateXmlBuffer(WS_HEAP*, const WS_XML_BUFFER_PROPERTY*, ULONG, WS_XML_BUFFER**,
1677 WS_ERROR*);
1678HRESULT WINAPI WsDateTimeToFileTime(const WS_DATETIME*, FILETIME*, WS_ERROR*);
1679HRESULT WINAPI WsDecodeUrl(const WS_STRING*, ULONG, WS_HEAP*, WS_URL**, WS_ERROR*);
1680HRESULT WINAPI WsEncodeUrl(const WS_URL*, ULONG, WS_HEAP*, WS_STRING*, WS_ERROR*);
1681HRESULT WINAPI WsFileTimeToDateTime(const FILETIME*, WS_DATETIME*, WS_ERROR*);
1682HRESULT WINAPI WsFillBody(WS_MESSAGE*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1683HRESULT WINAPI WsFillReader(WS_XML_READER*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1684HRESULT WINAPI WsFindAttribute(WS_XML_READER*, const WS_XML_STRING*, const WS_XML_STRING*, WINBOOL,
1685 ULONG*, WS_ERROR*);
1686HRESULT WINAPI WsFlushBody(WS_MESSAGE*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1687HRESULT WINAPI WsFlushWriter(WS_XML_WRITER*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1688void WINAPI WsFreeChannel(WS_CHANNEL*);
1689void WINAPI WsFreeError(WS_ERROR*);
1690void WINAPI WsFreeHeap(WS_HEAP*);
1691void WINAPI WsFreeListener(WS_LISTENER*);
1692void WINAPI WsFreeMessage(WS_MESSAGE*);
1693void WINAPI WsFreeReader(WS_XML_READER*);
1694void WINAPI WsFreeServiceProxy(WS_SERVICE_PROXY*);
1695void WINAPI WsFreeWriter(WS_XML_WRITER*);
1696HRESULT WINAPI WsGetChannelProperty(WS_CHANNEL*, WS_CHANNEL_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1697HRESULT WINAPI WsGetCustomHeader(WS_MESSAGE*, const WS_ELEMENT_DESCRIPTION*, WS_REPEATING_HEADER_OPTION,
1698 ULONG, WS_READ_OPTION, WS_HEAP*, void*, ULONG, ULONG*, WS_ERROR*);
1699HRESULT WINAPI WsGetDictionary(WS_ENCODING, WS_XML_DICTIONARY**, WS_ERROR*);
1700HRESULT WINAPI WsGetErrorProperty(WS_ERROR*, WS_ERROR_PROPERTY_ID, void*, ULONG);
1701HRESULT WINAPI WsGetErrorString(WS_ERROR*, ULONG, WS_STRING*);
1702HRESULT WINAPI WsGetFaultErrorDetail(WS_ERROR*, const WS_FAULT_DETAIL_DESCRIPTION*, WS_READ_OPTION,
1703 WS_HEAP*, void*, ULONG);
1704HRESULT WINAPI WsGetFaultErrorProperty(WS_ERROR*, WS_FAULT_ERROR_PROPERTY_ID, void*, ULONG);
1705HRESULT WINAPI WsGetHeader(WS_MESSAGE*, WS_HEADER_TYPE, WS_TYPE, WS_READ_OPTION, WS_HEAP*, void*,
1706 ULONG, WS_ERROR*);
1707HRESULT WINAPI WsGetHeapProperty(WS_HEAP*, WS_HEAP_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1708HRESULT WINAPI WsGetListenerProperty(WS_LISTENER*, WS_LISTENER_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1709HRESULT 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*);
1711HRESULT WINAPI WsGetMessageProperty(WS_MESSAGE*, WS_MESSAGE_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1712HRESULT WINAPI WsGetNamespaceFromPrefix(WS_XML_READER*, const WS_XML_STRING*, WINBOOL,
1713 const WS_XML_STRING**, WS_ERROR*);
1714HRESULT WINAPI WsGetPrefixFromNamespace(WS_XML_WRITER*, const WS_XML_STRING*, WINBOOL,
1715 const WS_XML_STRING**, WS_ERROR*);
1716HRESULT WINAPI WsGetReaderNode(WS_XML_READER*, const WS_XML_NODE**, WS_ERROR*);
1717HRESULT WINAPI WsGetReaderPosition(WS_XML_READER*, WS_XML_NODE_POSITION*, WS_ERROR*);
1718HRESULT WINAPI WsGetReaderProperty(WS_XML_READER*, WS_XML_READER_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1719HRESULT WINAPI WsGetServiceProxyProperty(WS_SERVICE_PROXY*, const WS_PROXY_PROPERTY_ID, void*,
1720 ULONG, WS_ERROR*);
1721HRESULT WINAPI WsGetWriterPosition(WS_XML_WRITER*, WS_XML_NODE_POSITION*, WS_ERROR*);
1722HRESULT WINAPI WsGetWriterProperty(WS_XML_WRITER*, WS_XML_WRITER_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1723HRESULT WINAPI WsGetXmlAttribute(WS_XML_READER*, const WS_XML_STRING*, WS_HEAP*, WCHAR**,
1724 ULONG*, WS_ERROR*);
1725HRESULT WINAPI WsInitializeMessage(WS_MESSAGE*, WS_MESSAGE_INITIALIZATION, WS_MESSAGE*, WS_ERROR*);
1726HRESULT WINAPI WsMoveReader(WS_XML_READER*, WS_MOVE_TO, WINBOOL*, WS_ERROR*);
1727HRESULT WINAPI WsMoveWriter(WS_XML_WRITER*, WS_MOVE_TO, WINBOOL*, WS_ERROR*);
1728HRESULT WINAPI WsOpenChannel(WS_CHANNEL*, const WS_ENDPOINT_ADDRESS*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1729HRESULT WINAPI WsOpenListener(WS_LISTENER*, const WS_STRING*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1730HRESULT WINAPI WsOpenServiceProxy(WS_SERVICE_PROXY*, const WS_ENDPOINT_ADDRESS*, const WS_ASYNC_CONTEXT*,
1731 WS_ERROR*);
1732HRESULT WINAPI WsReadAttribute(WS_XML_READER*, const WS_ATTRIBUTE_DESCRIPTION*, WS_READ_OPTION,
1733 WS_HEAP*, void*, ULONG, WS_ERROR*);
1734HRESULT WINAPI WsReadBody(WS_MESSAGE*, const WS_ELEMENT_DESCRIPTION*, WS_READ_OPTION, WS_HEAP*, void*,
1735 ULONG, WS_ERROR*);
1736HRESULT WINAPI WsReadBytes(WS_XML_READER*, void*, ULONG, ULONG*, WS_ERROR*);
1737HRESULT WINAPI WsReadChars(WS_XML_READER*, WCHAR*, ULONG, ULONG*, WS_ERROR*);
1738HRESULT WINAPI WsReadCharsUtf8(WS_XML_READER*, BYTE*, ULONG, ULONG*, WS_ERROR*);
1739HRESULT WINAPI WsReadElement(WS_XML_READER*, const WS_ELEMENT_DESCRIPTION*, WS_READ_OPTION,
1740 WS_HEAP*, void*, ULONG, WS_ERROR*);
1741HRESULT WINAPI WsReadEndAttribute(WS_XML_READER*, WS_ERROR*);
1742HRESULT WINAPI WsReadEndElement(WS_XML_READER*, WS_ERROR*);
1743HRESULT WINAPI WsReadEnvelopeEnd(WS_MESSAGE*, WS_ERROR*);
1744HRESULT WINAPI WsReadEnvelopeStart(WS_MESSAGE*, WS_XML_READER*, WS_MESSAGE_DONE_CALLBACK, void*,
1745 WS_ERROR*);
1746HRESULT WINAPI WsReadMessageEnd(WS_CHANNEL*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1747HRESULT WINAPI WsReadMessageStart(WS_CHANNEL*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1748HRESULT WINAPI WsReadNode(WS_XML_READER*, WS_ERROR*);
1749HRESULT WINAPI WsReadQualifiedName(WS_XML_READER*, WS_HEAP*, WS_XML_STRING*, WS_XML_STRING*,
1750 WS_XML_STRING*, WS_ERROR*);
1751HRESULT WINAPI WsReadStartAttribute(WS_XML_READER*, ULONG, WS_ERROR*);
1752HRESULT WINAPI WsReadStartElement(WS_XML_READER*, WS_ERROR*);
1753HRESULT WINAPI WsReadToStartElement(WS_XML_READER*, const WS_XML_STRING*, const WS_XML_STRING*,
1754 WINBOOL*, WS_ERROR*);
1755HRESULT WINAPI WsReadType(WS_XML_READER*, WS_TYPE_MAPPING, WS_TYPE, const void*, WS_READ_OPTION,
1756 WS_HEAP*, void*, ULONG, WS_ERROR*);
1757HRESULT WINAPI WsReadValue(WS_XML_READER*, WS_VALUE_TYPE, void*, ULONG, WS_ERROR*);
1758HRESULT WINAPI WsReadXmlBuffer(WS_XML_READER*, WS_HEAP*, WS_XML_BUFFER**, WS_ERROR*);
1759HRESULT 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*);
1762HRESULT WINAPI WsRemoveCustomHeader(WS_MESSAGE*, const WS_XML_STRING*, const WS_XML_STRING*,
1763 WS_ERROR*);
1764HRESULT WINAPI WsRemoveHeader(WS_MESSAGE*, WS_HEADER_TYPE, WS_ERROR*);
1765HRESULT WINAPI WsRemoveMappedHeader(WS_MESSAGE*, const WS_XML_STRING*, WS_ERROR*);
1766HRESULT WINAPI WsRemoveNode(const WS_XML_NODE_POSITION*, WS_ERROR*);
1767HRESULT 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*);
1770HRESULT WINAPI WsResetChannel(WS_CHANNEL*, WS_ERROR*);
1771HRESULT WINAPI WsResetMessage(WS_MESSAGE*, WS_ERROR*);
1772HRESULT WINAPI WsResetError(WS_ERROR*);
1773HRESULT WINAPI WsResetHeap(WS_HEAP*, WS_ERROR*);
1774HRESULT WINAPI WsResetListener(WS_LISTENER*, WS_ERROR*);
1775HRESULT WINAPI WsResetMessage(WS_MESSAGE*, WS_ERROR*);
1776HRESULT WINAPI WsResetServiceProxy(WS_SERVICE_PROXY*, WS_ERROR*);
1777HRESULT 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*);
1780HRESULT WINAPI WsSendMessage(WS_CHANNEL*, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*, WS_WRITE_OPTION,
1781 const void*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1782HRESULT 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*);
1785HRESULT WINAPI WsSetChannelProperty(WS_CHANNEL*, WS_CHANNEL_PROPERTY_ID, const void*, ULONG, WS_ERROR*);
1786HRESULT WINAPI WsSetErrorProperty(WS_ERROR*, WS_ERROR_PROPERTY_ID, const void*, ULONG);
1787HRESULT WINAPI WsSetFaultErrorProperty(WS_ERROR*, WS_FAULT_ERROR_PROPERTY_ID, const void*, ULONG);
1788HRESULT WINAPI WsSetHeader(WS_MESSAGE*, WS_HEADER_TYPE, WS_TYPE, WS_WRITE_OPTION, const void*, ULONG,
1789 WS_ERROR*);
1790HRESULT WINAPI WsSetInput(WS_XML_READER*, const WS_XML_READER_ENCODING*, const WS_XML_READER_INPUT*,
1791 const WS_XML_READER_PROPERTY*, ULONG, WS_ERROR*);
1792HRESULT WINAPI WsSetInputToBuffer(WS_XML_READER*, WS_XML_BUFFER*, const WS_XML_READER_PROPERTY*,
1793 ULONG, WS_ERROR*);
1794HRESULT WINAPI WsSetListenerProperty(WS_LISTENER*, WS_LISTENER_PROPERTY_ID, const void*, ULONG, WS_ERROR*);
1795HRESULT WINAPI WsSetMessageProperty(WS_MESSAGE*, WS_MESSAGE_PROPERTY_ID, const void*, ULONG, WS_ERROR*);
1796HRESULT WINAPI WsSetOutput(WS_XML_WRITER*, const WS_XML_WRITER_ENCODING*, const WS_XML_WRITER_OUTPUT*,
1797 const WS_XML_WRITER_PROPERTY*, ULONG, WS_ERROR*);
1798HRESULT WINAPI WsSetOutputToBuffer(WS_XML_WRITER*, WS_XML_BUFFER*, const WS_XML_WRITER_PROPERTY*,
1799 ULONG, WS_ERROR*);
1800HRESULT WINAPI WsSetReaderPosition(WS_XML_READER*, const WS_XML_NODE_POSITION*, WS_ERROR*);
1801HRESULT WINAPI WsSetWriterPosition(WS_XML_WRITER*, const WS_XML_NODE_POSITION*, WS_ERROR*);
1802HRESULT WINAPI WsShutdownSessionChannel(WS_CHANNEL*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1803HRESULT WINAPI WsSkipNode(WS_XML_READER*, WS_ERROR*);
1804HRESULT WINAPI WsWriteArray(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*, WS_VALUE_TYPE,
1805 const void*, ULONG, ULONG, ULONG, WS_ERROR*);
1806HRESULT WINAPI WsWriteAttribute(WS_XML_WRITER*, const WS_ATTRIBUTE_DESCRIPTION*, WS_WRITE_OPTION,
1807 const void*, ULONG, WS_ERROR*);
1808HRESULT WINAPI WsWriteBody(WS_MESSAGE*, const WS_ELEMENT_DESCRIPTION*, WS_WRITE_OPTION, const void*,
1809 ULONG, WS_ERROR*);
1810HRESULT WINAPI WsWriteBytes(WS_XML_WRITER*, const void*, ULONG, WS_ERROR*);
1811HRESULT WINAPI WsWriteChars(WS_XML_WRITER*, const WCHAR*, ULONG, WS_ERROR*);
1812HRESULT WINAPI WsWriteCharsUtf8(WS_XML_WRITER*, const BYTE*, ULONG, WS_ERROR*);
1813HRESULT WINAPI WsWriteElement(WS_XML_WRITER*, const WS_ELEMENT_DESCRIPTION*, WS_WRITE_OPTION,
1814 const void*, ULONG, WS_ERROR*);
1815HRESULT WINAPI WsWriteEndAttribute(WS_XML_WRITER*, WS_ERROR*);
1816HRESULT WINAPI WsWriteEndCData(WS_XML_WRITER*, WS_ERROR*);
1817HRESULT WINAPI WsWriteEndElement(WS_XML_WRITER*, WS_ERROR*);
1818HRESULT WINAPI WsWriteEndStartElement(WS_XML_WRITER*, WS_ERROR*);
1819HRESULT WINAPI WsWriteEnvelopeEnd(WS_MESSAGE*, WS_ERROR*);
1820HRESULT WINAPI WsWriteEnvelopeStart(WS_MESSAGE*, WS_XML_WRITER*, WS_MESSAGE_DONE_CALLBACK, void*, WS_ERROR*);
1821HRESULT WINAPI WsWriteMessageStart(WS_CHANNEL*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1822HRESULT WINAPI WsWriteMessageEnd(WS_CHANNEL*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1823HRESULT WINAPI WsWriteNode(WS_XML_WRITER*, const WS_XML_NODE*, WS_ERROR*);
1824HRESULT WINAPI WsWriteQualifiedName(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*,
1825 const WS_XML_STRING*, WS_ERROR*);
1826HRESULT WINAPI WsWriteStartAttribute(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*,
1827 const WS_XML_STRING*, WINBOOL, WS_ERROR*);
1828HRESULT WINAPI WsWriteStartCData(WS_XML_WRITER*, WS_ERROR*);
1829HRESULT WINAPI WsWriteStartElement(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*,
1830 const WS_XML_STRING*, WS_ERROR*);
1831HRESULT WINAPI WsWriteText(WS_XML_WRITER*, const WS_XML_TEXT*, WS_ERROR*);
1832HRESULT WINAPI WsWriteType(WS_XML_WRITER*, WS_TYPE_MAPPING, WS_TYPE, const void*, WS_WRITE_OPTION,
1833 const void*, ULONG, WS_ERROR*);
1834HRESULT WINAPI WsWriteValue(WS_XML_WRITER*, WS_VALUE_TYPE, const void*, ULONG, WS_ERROR*);
1835HRESULT WINAPI WsWriteXmlBuffer(WS_XML_WRITER*, WS_XML_BUFFER*, WS_ERROR*);
1836HRESULT 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*);
1839HRESULT WINAPI WsWriteXmlnsAttribute(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*,
1840 WINBOOL, WS_ERROR*);
1841HRESULT WINAPI WsXmlStringEquals(const WS_XML_STRING*, const WS_XML_STRING*, WS_ERROR*);
1842
1843#ifndef FACILITY_WEBSERVICES
1844#define FACILITY_WEBSERVICES 61
1845#define WS_S_ASYNC 0x003d0000
1846#define WS_S_END 0x003d0001
1847#define WS_E_INVALID_FORMAT 0x803d0000
1848#define WS_E_OBJECT_FAULTED 0x803d0001
1849#define WS_E_NUMERIC_OVERFLOW 0x803d0002
1850#define WS_E_INVALID_OPERATION 0x803d0003
1851#define WS_E_OPERATION_ABORTED 0x803d0004
1852#define WS_E_ENDPOINT_ACCESS_DENIED 0x803d0005
1853#define WS_E_OPERATION_TIMED_OUT 0x803d0006
1854#define WS_E_OPERATION_ABANDONED 0x803d0007
1855#define WS_E_QUOTA_EXCEEDED 0x803d0008
1856#define WS_E_NO_TRANSLATION_AVAILABLE 0x803d0009
1857#define WS_E_SECURITY_VERIFICATION_FAILURE 0x803d000a
1858#define WS_E_ADDRESS_IN_USE 0x803d000b
1859#define WS_E_ADDRESS_NOT_AVAILABLE 0x803d000c
1860#define WS_E_ENDPOINT_NOT_FOUND 0x803d000d
1861#define WS_E_ENDPOINT_NOT_AVAILABLE 0x803d000e
1862#define WS_E_ENDPOINT_FAILURE 0x803d000f
1863#define WS_E_ENDPOINT_UNREACHABLE 0x803d0010
1864#define WS_E_ENDPOINT_ACTION_NOT_SUPPORTED 0x803d0011
1865#define WS_E_ENDPOINT_TOO_BUSY 0x803d0012
1866#define WS_E_ENDPOINT_FAULT_RECEIVED 0x803d0013
1867#define WS_E_ENDPOINT_DISCONNECTED 0x803d0014
1868#define WS_E_PROXY_FAILURE 0x803d0015
1869#define WS_E_PROXY_ACCESS_DENIED 0x803d0016
1870#define WS_E_NOT_SUPPORTED 0x803d0017
1871#define WS_E_PROXY_REQUIRES_BASIC_AUTH 0x803d0018
1872#define WS_E_PROXY_REQUIRES_DIGEST_AUTH 0x803d0019
1873#define WS_E_PROXY_REQUIRES_NTLM_AUTH 0x803d001a
1874#define WS_E_PROXY_REQUIRES_NEGOTIATE_AUTH 0x803d001b
1875#define WS_E_SERVER_REQUIRES_BASIC_AUTH 0x803d001c
1876#define WS_E_SERVER_REQUIRES_DIGEST_AUTH 0x803d001d
1877#define WS_E_SERVER_REQUIRES_NTLM_AUTH 0x803d001e
1878#define WS_E_SERVER_REQUIRES_NEGOTIATE_AUTH 0x803d001f
1879#define WS_E_INVALID_ENDPOINT_URL 0x803d0020
1880#define WS_E_OTHER 0x803d0021
1881#define WS_E_SECURITY_TOKEN_EXPIRED 0x803d0022
1882#define WS_E_SECURITY_SYSTEM_FAILURE 0x803d0023
1883#endif
1884
1885#define WS_STRING_VALUE(s) { sizeof(s) / sizeof((s)[0]) - 1, (WCHAR *)(s) }
1886#define WS_XML_STRING_VALUE(s) { sizeof(s) - 1, (BYTE *)(s) }
1887
1888#ifdef __cplusplus
1889}
1890#endif /* __cplusplus */
1891
1892#endif /* __WINE_WEBSERVICES_H */