| /* |
| * Copyright 2015 Nikolay Sivov for CodeWeavers |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #ifndef __WINE_WEBSERVICES_H |
| #define __WINE_WEBSERVICES_H |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif /* __cplusplus */ |
| |
| typedef struct _WS_ERROR WS_ERROR; |
| typedef struct _WS_HEAP WS_HEAP; |
| typedef struct _WS_XML_BUFFER WS_XML_BUFFER; |
| typedef struct _WS_XML_READER WS_XML_READER; |
| typedef struct _WS_XML_WRITER WS_XML_WRITER; |
| typedef struct _WS_PROXY_PROPERTY WS_PROXY_PROPERTY; |
| typedef struct _WS_SECURITY_DESCRIPTION WS_SECURITY_DESCRIPTION; |
| typedef struct _WS_CHANNEL_PROPERTY WS_CHANNEL_PROPERTY; |
| typedef struct _WS_SERVICE_PROXY WS_SERVICE_PROXY; |
| typedef struct _WS_SECURITY_BINDING_PROPERTY WS_SECURITY_BINDING_PROPERTY; |
| typedef struct _WS_SECURITY_PROPERTY WS_SECURITY_PROPERTY; |
| typedef struct _WS_SECURITY_PROPERTIES WS_SECURITY_PROPERTIES; |
| typedef struct _WS_SECURITY_BINDING WS_SECURITY_BINDING; |
| typedef struct _WS_CHANNEL WS_CHANNEL; |
| typedef struct _WS_MESSAGE_PROPERTY WS_MESSAGE_PROPERTY; |
| typedef struct _WS_MESSAGE_PROPERTIES WS_MESSAGE_PROPERTIES; |
| typedef struct _WS_HTTP_BINDING_TEMPLATE WS_HTTP_BINDING_TEMPLATE; |
| typedef struct _WS_HTTP_SSL_BINDING_TEMPLATE WS_HTTP_SSL_BINDING_TEMPLATE; |
| typedef struct _WS_CHANNEL_PROPERTIES WS_CHANNEL_PROPERTIES; |
| typedef struct _WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE; |
| typedef struct _WS_SECURITY_BINDING_PROPERTIES WS_SECURITY_BINDING_PROPERTIES; |
| typedef struct _WS_CERT_CREDENTIAL WS_CERT_CREDENTIAL; |
| typedef struct _WS_ENDPOINT_ADDRESS WS_ENDPOINT_ADDRESS; |
| typedef struct _WS_ENDPOINT_IDENTITY WS_ENDPOINT_IDENTITY; |
| typedef struct _WS_ENUM_DESCRIPTION WS_ENUM_DESCRIPTION; |
| typedef struct _WS_ENUM_VALUE WS_ENUM_VALUE; |
| typedef struct _WS_HTTP_POLICY_DESCRIPTION WS_HTTP_POLICY_DESCRIPTION; |
| typedef struct _WS_MESSAGE WS_MESSAGE; |
| typedef struct _WS_MESSAGE_DESCRIPTION WS_MESSAGE_DESCRIPTION; |
| typedef struct _WS_OPERATION_DESCRIPTION WS_OPERATION_DESCRIPTION; |
| typedef struct _WS_PARAMETER_DESCRIPTION WS_PARAMETER_DESCRIPTION; |
| typedef struct _WS_OPERATION_CONTEXT WS_OPERATION_CONTEXT; |
| typedef struct _WS_CALL_PROPERTY WS_CALL_PROPERTY; |
| typedef struct _WS_FLOAT_DESCRIPTION WS_FLOAT_DESCRIPTION; |
| typedef struct _WS_DOUBLE_DESCRIPTION WS_DOUBLE_DESCRIPTION; |
| typedef struct _WS_DATETIME WS_DATETIME; |
| typedef struct _WS_XML_DATETIME_TEXT WS_XML_DATETIME_TEXT; |
| typedef struct _WS_XML_BASE64_TEXT WS_XML_BASE64_TEXT; |
| typedef struct _WS_DATETIME_DESCRIPTION WS_DATETIME_DESCRIPTION; |
| typedef struct _WS_GUID_DESCRIPTION WS_GUID_DESCRIPTION; |
| typedef struct _WS_UNIQUE_ID_DESCRIPTION WS_UNIQUE_ID_DESCRIPTION; |
| typedef struct _WS_BYTES_DESCRIPTION WS_BYTES_DESCRIPTION; |
| typedef struct _WS_URL WS_URL; |
| typedef struct _WS_HTTP_URL WS_HTTP_URL; |
| typedef struct _WS_HTTPS_URL WS_HTTPS_URL; |
| typedef struct _WS_NETTCP_URL WS_NETTCP_URL; |
| typedef struct _WS_SOAPUDP_URL WS_SOAPUDP_URL; |
| typedef struct _WS_NETPIPE_URL WS_NETPIPE_URL; |
| typedef struct _WS_CUSTOM_CHANNEL_CALLBACKS WS_CUSTOM_CHANNEL_CALLBACKS; |
| typedef struct _WS_CHANNEL_ENCODER WS_CHANNEL_ENCODER; |
| typedef struct _WS_CHANNEL_DECODER WS_CHANNEL_DECODER; |
| typedef struct _WS_CUSTOM_HTTP_PROXY WS_CUSTOM_HTTP_PROXY; |
| typedef struct _WS_HTTP_MESSAGE_MAPPING WS_HTTP_MESSAGE_MAPPING; |
| typedef struct _WS_HTTP_HEADER_MAPPING WS_HTTP_HEADER_MAPPING; |
| typedef struct _WS_HTTP_REDIRECT_CALLBACK_CONTEXT WS_HTTP_REDIRECT_CALLBACK_CONTEXT; |
| typedef struct _WS_PROXY_MESSAGE_CALLBACK_CONTEXT WS_PROXY_MESSAGE_CALLBACK_CONTEXT; |
| typedef struct _WS_LISTENER WS_LISTENER; |
| typedef struct _WS_LISTENER_PROPERTY WS_LISTENER_PROPERTY; |
| typedef struct _WS_DISALLOWED_USER_AGENT_SUBSTRINGS WS_DISALLOWED_USER_AGENT_SUBSTRINGS; |
| typedef struct _WS_LISTENER_PROPERTIES WS_LISTENER_PROPERTIES; |
| typedef struct _WS_CUSTOM_LISTENER_CALLBACKS WS_CUSTOM_LISTENER_CALLBACKS; |
| |
| struct _WS_STRUCT_DESCRIPTION; |
| struct _WS_XML_STRING; |
| |
| typedef enum { |
| WS_ERROR_PROPERTY_STRING_COUNT, |
| WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE, |
| WS_ERROR_PROPERTY_LANGID |
| } WS_ERROR_PROPERTY_ID; |
| |
| typedef struct _WS_ERROR_PROPERTY { |
| WS_ERROR_PROPERTY_ID id; |
| void *value; |
| ULONG valueSize; |
| } WS_ERROR_PROPERTY; |
| |
| typedef enum { |
| WS_HEAP_PROPERTY_MAX_SIZE, |
| WS_HEAP_PROPERTY_TRIM_SIZE, |
| WS_HEAP_PROPERTY_REQUESTED_SIZE, |
| WS_HEAP_PROPERTY_ACTUAL_SIZE |
| } WS_HEAP_PROPERTY_ID; |
| |
| typedef struct _WS_HEAP_PROPERTY { |
| WS_HEAP_PROPERTY_ID id; |
| void *value; |
| ULONG valueSize; |
| } WS_HEAP_PROPERTY; |
| |
| typedef struct _WS_HEAP_PROPERTIES { |
| WS_HEAP_PROPERTY *properties; |
| ULONG propertyCount; |
| } WS_HEAP_PROPERTIES; |
| |
| typedef ULONG WS_XML_BUFFER_PROPERTY_ID; |
| |
| typedef struct _WS_XML_BUFFER_PROPERTY { |
| WS_XML_BUFFER_PROPERTY_ID id; |
| void *value; |
| ULONG valueSize; |
| } WS_XML_BUFFER_PROPERTY; |
| |
| typedef enum { |
| WS_XML_READER_PROPERTY_MAX_DEPTH, |
| WS_XML_READER_PROPERTY_ALLOW_FRAGMENT, |
| WS_XML_READER_PROPERTY_MAX_ATTRIBUTES, |
| WS_XML_READER_PROPERTY_READ_DECLARATION, |
| WS_XML_READER_PROPERTY_CHARSET, |
| WS_XML_READER_PROPERTY_ROW, |
| WS_XML_READER_PROPERTY_COLUMN, |
| WS_XML_READER_PROPERTY_UTF8_TRIM_SIZE, |
| WS_XML_READER_PROPERTY_STREAM_BUFFER_SIZE, |
| WS_XML_READER_PROPERTY_IN_ATTRIBUTE, |
| WS_XML_READER_PROPERTY_STREAM_MAX_ROOT_MIME_PART_SIZE, |
| WS_XML_READER_PROPERTY_STREAM_MAX_MIME_HEADERS_SIZE, |
| WS_XML_READER_PROPERTY_MAX_MIME_PARTS, |
| WS_XML_READER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES, |
| WS_XML_READER_PROPERTY_MAX_NAMESPACES |
| } WS_XML_READER_PROPERTY_ID; |
| |
| typedef struct _WS_XML_READER_PROPERTY { |
| WS_XML_READER_PROPERTY_ID id; |
| void *value; |
| ULONG valueSize; |
| } WS_XML_READER_PROPERTY; |
| |
| typedef struct _WS_XML_READER_PROPERTIES { |
| WS_XML_READER_PROPERTY *properties; |
| ULONG propertyCount; |
| } WS_XML_READER_PROPERTIES; |
| |
| typedef enum { |
| WS_XML_WRITER_PROPERTY_MAX_DEPTH, |
| WS_XML_WRITER_PROPERTY_ALLOW_FRAGMENT, |
| WS_XML_WRITER_PROPERTY_MAX_ATTRIBUTES, |
| WS_XML_WRITER_PROPERTY_WRITE_DECLARATION, |
| WS_XML_WRITER_PROPERTY_INDENT, |
| WS_XML_WRITER_PROPERTY_BUFFER_TRIM_SIZE, |
| WS_XML_WRITER_PROPERTY_CHARSET, |
| WS_XML_WRITER_PROPERTY_BUFFERS, |
| WS_XML_WRITER_PROPERTY_BUFFER_MAX_SIZE, |
| WS_XML_WRITER_PROPERTY_BYTES, |
| WS_XML_WRITER_PROPERTY_IN_ATTRIBUTE, |
| WS_XML_WRITER_PROPERTY_MAX_MIME_PARTS_BUFFER_SIZE, |
| WS_XML_WRITER_PROPERTY_INITIAL_BUFFER, |
| WS_XML_WRITER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES, |
| WS_XML_WRITER_PROPERTY_MAX_NAMESPACES, |
| WS_XML_WRITER_PROPERTY_BYTES_WRITTEN, |
| WS_XML_WRITER_PROPERTY_BYTES_TO_CLOSE, |
| WS_XML_WRITER_PROPERTY_COMPRESS_EMPTY_ELEMENTS, |
| WS_XML_WRITER_PROPERTY_EMIT_UNCOMPRESSED_EMPTY_ELEMENTS |
| } WS_XML_WRITER_PROPERTY_ID; |
| |
| typedef struct _WS_XML_WRITER_PROPERTY { |
| WS_XML_WRITER_PROPERTY_ID id; |
| void *value; |
| ULONG valueSize; |
| } WS_XML_WRITER_PROPERTY; |
| |
| typedef struct _WS_XML_WRITER_PROPERTIES { |
| WS_XML_WRITER_PROPERTY *properties; |
| ULONG propertyCount; |
| } WS_XML_WRITER_PROPERTIES; |
| |
| typedef struct _WS_BYTES { |
| ULONG length; |
| BYTE *bytes; |
| } WS_BYTES; |
| |
| typedef struct _WS_BUFFERS { |
| ULONG bufferCount; |
| WS_BYTES *buffers; |
| } WS_BUFFERS; |
| |
| typedef enum { |
| WS_XML_READER_ENCODING_TYPE_TEXT = 1, |
| WS_XML_READER_ENCODING_TYPE_BINARY = 2, |
| WS_XML_READER_ENCODING_TYPE_MTOM = 3, |
| WS_XML_READER_ENCODING_TYPE_RAW = 4 |
| } WS_XML_READER_ENCODING_TYPE; |
| |
| typedef struct _WS_XML_READER_ENCODING { |
| WS_XML_READER_ENCODING_TYPE encodingType; |
| } WS_XML_READER_ENCODING; |
| |
| typedef enum { |
| WS_XML_WRITER_ENCODING_TYPE_TEXT = 1, |
| WS_XML_WRITER_ENCODING_TYPE_BINARY = 2, |
| WS_XML_WRITER_ENCODING_TYPE_MTOM = 3, |
| WS_XML_WRITER_ENCODING_TYPE_RAW = 4 |
| } WS_XML_WRITER_ENCODING_TYPE; |
| |
| typedef struct _WS_XML_WRITER_ENCODING { |
| WS_XML_WRITER_ENCODING_TYPE encodingType; |
| } WS_XML_WRITER_ENCODING; |
| |
| typedef enum { |
| WS_CHARSET_AUTO, |
| WS_CHARSET_UTF8, |
| WS_CHARSET_UTF16LE, |
| WS_CHARSET_UTF16BE |
| } WS_CHARSET; |
| |
| typedef struct _WS_XML_DICTIONARY { |
| GUID guid; |
| struct _WS_XML_STRING *strings; |
| ULONG stringCount; |
| WINBOOL isConst; |
| } WS_XML_DICTIONARY; |
| |
| typedef struct _WS_XML_STRING { |
| ULONG length; |
| BYTE *bytes; |
| WS_XML_DICTIONARY *dictionary; |
| ULONG id; |
| } WS_XML_STRING; |
| |
| typedef struct _WS_XML_READER_TEXT_ENCODING { |
| WS_XML_READER_ENCODING encoding; |
| WS_CHARSET charSet; |
| } WS_XML_READER_TEXT_ENCODING; |
| |
| typedef struct _WS_XML_READER_BINARY_ENCODING { |
| WS_XML_READER_ENCODING encoding; |
| WS_XML_DICTIONARY *staticDictionary; |
| WS_XML_DICTIONARY *dynamicDictionary; |
| } WS_XML_READER_BINARY_ENCODING; |
| |
| typedef struct _WS_XML_WRITER_TEXT_ENCODING { |
| WS_XML_WRITER_ENCODING encoding; |
| WS_CHARSET charSet; |
| } WS_XML_WRITER_TEXT_ENCODING; |
| |
| typedef HRESULT (CALLBACK *WS_DYNAMIC_STRING_CALLBACK) |
| (void*, const WS_XML_STRING*, WINBOOL*, ULONG*, WS_ERROR*); |
| |
| typedef struct _WS_XML_WRITER_BINARY_ENCODING { |
| WS_XML_WRITER_ENCODING encoding; |
| WS_XML_DICTIONARY *staticDictionary; |
| WS_DYNAMIC_STRING_CALLBACK dynamicStringCallback; |
| void *dynamicStringCallbackState; |
| } WS_XML_WRITER_BINARY_ENCODING; |
| |
| typedef enum { |
| WS_XML_READER_INPUT_TYPE_BUFFER = 1, |
| WS_XML_READER_INPUT_TYPE_STREAM = 2 |
| } WS_XML_READER_INPUT_TYPE; |
| |
| typedef enum { |
| WS_XML_WRITER_OUTPUT_TYPE_BUFFER = 1, |
| WS_XML_WRITER_OUTPUT_TYPE_STREAM = 2 |
| } WS_XML_WRITER_OUTPUT_TYPE; |
| |
| typedef struct _WS_XML_READER_INPUT { |
| WS_XML_READER_INPUT_TYPE inputType; |
| } WS_XML_READER_INPUT; |
| |
| typedef struct _WS_XML_WRITER_OUTPUT { |
| WS_XML_WRITER_OUTPUT_TYPE outputType; |
| } WS_XML_WRITER_OUTPUT; |
| |
| typedef struct _WS_XML_READER_BUFFER_INPUT { |
| WS_XML_READER_INPUT input; |
| void *encodedData; |
| ULONG encodedDataSize; |
| } WS_XML_READER_BUFFER_INPUT; |
| |
| typedef struct _WS_XML_WRITER_BUFFER_OUTPUT { |
| WS_XML_WRITER_OUTPUT output; |
| } WS_XML_WRITER_BUFFER_OUTPUT; |
| |
| typedef enum { |
| WS_SHORT_CALLBACK, |
| WS_LONG_CALLBACK |
| } WS_CALLBACK_MODEL; |
| |
| typedef void (CALLBACK *WS_ASYNC_CALLBACK) |
| (HRESULT, WS_CALLBACK_MODEL, void *); |
| |
| typedef struct _WS_ASYNC_CONTEXT { |
| WS_ASYNC_CALLBACK callback; |
| void *callbackState; |
| } WS_ASYNC_CONTEXT; |
| |
| typedef HRESULT (CALLBACK *WS_READ_CALLBACK) |
| (void*, void*, ULONG, ULONG*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| typedef struct _WS_XML_READER_STREAM_INPUT { |
| WS_XML_READER_INPUT input; |
| WS_READ_CALLBACK readCallback; |
| void *readCallbackState; |
| } WS_XML_READER_STREAM_INPUT; |
| |
| typedef HRESULT (CALLBACK *WS_WRITE_CALLBACK) |
| (void*, const WS_BYTES*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| typedef struct _WS_XML_WRITER_STREAM_OUTPUT { |
| WS_XML_WRITER_OUTPUT output; |
| WS_WRITE_CALLBACK writeCallback; |
| void *writeCallbackState; |
| } WS_XML_WRITER_STREAM_OUTPUT; |
| |
| typedef enum { |
| WS_ELEMENT_TYPE_MAPPING = 1, |
| WS_ATTRIBUTE_TYPE_MAPPING = 2, |
| WS_ELEMENT_CONTENT_TYPE_MAPPING = 3, |
| WS_ANY_ELEMENT_TYPE_MAPPING = 4 |
| } WS_TYPE_MAPPING; |
| |
| typedef enum { |
| WS_BOOL_TYPE, |
| WS_INT8_TYPE, |
| WS_INT16_TYPE, |
| WS_INT32_TYPE, |
| WS_INT64_TYPE, |
| WS_UINT8_TYPE, |
| WS_UINT16_TYPE, |
| WS_UINT32_TYPE, |
| WS_UINT64_TYPE, |
| WS_FLOAT_TYPE, |
| WS_DOUBLE_TYPE, |
| WS_DECIMAL_TYPE, |
| WS_DATETIME_TYPE, |
| WS_TIMESPAN_TYPE, |
| WS_GUID_TYPE, |
| WS_UNIQUE_ID_TYPE, |
| WS_STRING_TYPE, |
| WS_WSZ_TYPE, |
| WS_BYTES_TYPE, |
| WS_XML_STRING_TYPE, |
| WS_XML_QNAME_TYPE, |
| WS_XML_BUFFER_TYPE, |
| WS_CHAR_ARRAY_TYPE, |
| WS_UTF8_ARRAY_TYPE, |
| WS_BYTE_ARRAY_TYPE, |
| WS_DESCRIPTION_TYPE, |
| WS_STRUCT_TYPE, |
| WS_CUSTOM_TYPE, |
| WS_ENDPOINT_ADDRESS_TYPE, |
| WS_FAULT_TYPE, |
| WS_VOID_TYPE, |
| WS_ENUM_TYPE, |
| WS_DURATION_TYPE, |
| WS_UNION_TYPE, |
| WS_ANY_ATTRIBUTES_TYPE |
| } WS_TYPE; |
| |
| typedef enum { |
| WS_READ_REQUIRED_VALUE = 1, |
| WS_READ_REQUIRED_POINTER = 2, |
| WS_READ_OPTIONAL_POINTER = 3, |
| WS_READ_NILLABLE_POINTER = 4, |
| WS_READ_NILLABLE_VALUE = 5 |
| } WS_READ_OPTION; |
| |
| typedef enum { |
| WS_WRITE_REQUIRED_VALUE = 1, |
| WS_WRITE_REQUIRED_POINTER = 2, |
| WS_WRITE_NILLABLE_VALUE = 3, |
| WS_WRITE_NILLABLE_POINTER = 4 |
| } WS_WRITE_OPTION; |
| |
| typedef struct _WS_BOOL_DESCRIPTION { |
| WINBOOL value; |
| } WS_BOOL_DESCRIPTION; |
| |
| typedef struct _WS_INT8_DESCRIPTION { |
| char minValue; |
| char maxValue; |
| } WS_INT8_DESCRIPTION; |
| |
| typedef struct _WS_INT16_DESCRIPTION { |
| short minValue; |
| short maxValue; |
| } WS_INT16_DESCRIPTION; |
| |
| typedef struct _WS_INT32_DESCRIPTION { |
| int minValue; |
| int maxValue; |
| } WS_INT32_DESCRIPTION; |
| |
| typedef struct _WS_INT64_DESCRIPTION { |
| __int64 DECLSPEC_ALIGN(8) minValue; |
| __int64 DECLSPEC_ALIGN(8) maxValue; |
| } WS_INT64_DESCRIPTION; |
| |
| typedef struct _WS_UINT8_DESCRIPTION { |
| BYTE minValue; |
| BYTE maxValue; |
| } WS_UINT8_DESCRIPTION; |
| |
| typedef struct _WS_UINT16_DESCRIPTION { |
| USHORT minValue; |
| USHORT maxValue; |
| } WS_UINT16_DESCRIPTION; |
| |
| typedef struct _WS_UINT32_DESCRIPTION { |
| ULONG minValue; |
| ULONG maxValue; |
| } WS_UINT32_DESCRIPTION; |
| |
| typedef struct _WS_UINT64_DESCRIPTION { |
| unsigned __int64 DECLSPEC_ALIGN(8) minValue; |
| unsigned __int64 DECLSPEC_ALIGN(8) maxValue; |
| } WS_UINT64_DESCRIPTION; |
| |
| typedef struct _WS_WSZ_DESCRIPTION { |
| ULONG minCharCount; |
| ULONG maxCharCount; |
| } WS_WSZ_DESCRIPTION; |
| |
| typedef struct _WS_STRING_DESCRIPTION { |
| ULONG minCharCount; |
| ULONG maxCharCount; |
| } WS_STRING_DESCRIPTION; |
| |
| typedef struct _WS_XML_STRING_DESCRIPTION { |
| ULONG minByteCount; |
| ULONG maxByteCount; |
| } WS_XML_STRING_DESCRIPTION; |
| |
| typedef struct _WS_XML_QNAME_DESCRIPTION { |
| ULONG minLocalNameByteCount; |
| ULONG maxLocalNameByteCount; |
| ULONG minNsByteCount; |
| ULONG maxNsByteCount; |
| } WS_XML_QNAME_DESCRIPTION; |
| |
| struct _WS_ENUM_VALUE { |
| int value; |
| WS_XML_STRING *name; |
| }; |
| |
| struct _WS_ENUM_DESCRIPTION { |
| WS_ENUM_VALUE *values; |
| ULONG valueCount; |
| ULONG maxByteCount; |
| ULONG *nameIndices; |
| }; |
| |
| struct _WS_FLOAT_DESCRIPTION { |
| float minValue; |
| float maxValue; |
| }; |
| |
| struct _WS_DOUBLE_DESCRIPTION { |
| double DECLSPEC_ALIGN(8) minValue; |
| double DECLSPEC_ALIGN(8) maxValue; |
| }; |
| |
| struct _WS_GUID_DESCRIPTION { |
| GUID value; |
| }; |
| |
| struct _WS_UNIQUE_ID_DESCRIPTION { |
| ULONG minCharCount; |
| ULONG maxCharCount; |
| }; |
| |
| struct _WS_BYTES_DESCRIPTION { |
| ULONG minByteCount; |
| ULONG maxByteCount; |
| }; |
| |
| typedef enum { |
| WS_TYPE_ATTRIBUTE_FIELD_MAPPING, |
| WS_ATTRIBUTE_FIELD_MAPPING, |
| WS_ELEMENT_FIELD_MAPPING, |
| WS_REPEATING_ELEMENT_FIELD_MAPPING, |
| WS_TEXT_FIELD_MAPPING, |
| WS_NO_FIELD_MAPPING, |
| WS_XML_ATTRIBUTE_FIELD_MAPPING, |
| WS_ELEMENT_CHOICE_FIELD_MAPPING, |
| WS_REPEATING_ELEMENT_CHOICE_FIELD_MAPPING, |
| WS_ANY_ELEMENT_FIELD_MAPPING, |
| WS_REPEATING_ANY_ELEMENT_FIELD_MAPPING, |
| WS_ANY_CONTENT_FIELD_MAPPING, |
| WS_ANY_ATTRIBUTES_FIELD_MAPPING |
| } WS_FIELD_MAPPING; |
| |
| typedef struct _WS_DEFAULT_VALUE { |
| void *value; |
| ULONG valueSize; |
| } WS_DEFAULT_VALUE; |
| |
| typedef struct _WS_ITEM_RANGE { |
| ULONG minItemCount; |
| ULONG maxItemCount; |
| } WS_ITEM_RANGE; |
| |
| enum |
| { |
| WS_FIELD_POINTER = 0x1, |
| WS_FIELD_OPTIONAL = 0x2, |
| WS_FIELD_NILLABLE = 0x4, |
| WS_FIELD_NILLABLE_ITEM = 0x8, |
| WS_FIELD_OTHER_NAMESPACE = 0x10 |
| }; |
| |
| typedef struct _WS_FIELD_DESCRIPTION { |
| WS_FIELD_MAPPING mapping; |
| WS_XML_STRING *localName; |
| WS_XML_STRING *ns; |
| WS_TYPE type; |
| void *typeDescription; |
| ULONG offset; |
| ULONG options; |
| WS_DEFAULT_VALUE *defaultValue; |
| ULONG countOffset; |
| WS_XML_STRING *itemLocalName; |
| WS_XML_STRING *itemNs; |
| WS_ITEM_RANGE *itemRange; |
| } WS_FIELD_DESCRIPTION; |
| |
| enum |
| { |
| WS_STRUCT_ABSTRACT = 0x1, |
| WS_STRUCT_IGNORE_TRAILING_ELEMENT_CONTENT = 0x2, |
| WS_STRUCT_IGNORE_UNHANDLED_ATTRIBUTES = 0x4 |
| }; |
| |
| typedef struct _WS_STRUCT_DESCRIPTION { |
| ULONG size; |
| ULONG alignment; |
| WS_FIELD_DESCRIPTION **fields; |
| ULONG fieldCount; |
| WS_XML_STRING *typeLocalName; |
| WS_XML_STRING *typeNs; |
| struct _WS_STRUCT_DESCRIPTION *parentType; |
| struct _WS_STRUCT_DESCRIPTION **subTypes; |
| ULONG subTypeCount; |
| ULONG structOptions; |
| } WS_STRUCT_DESCRIPTION; |
| |
| typedef struct _WS_UNION_FIELD_DESCRIPTION { |
| int value; |
| WS_FIELD_DESCRIPTION field; |
| } WS_UNION_FIELD_DESCRIPTION; |
| |
| typedef struct _WS_UNION_DESCRIPTION { |
| ULONG size; |
| ULONG alignment; |
| WS_UNION_FIELD_DESCRIPTION **fields; |
| ULONG fieldCount; |
| ULONG enumOffset; |
| int noneEnumValue; |
| ULONG *valueIndices; |
| } WS_UNION_DESCRIPTION; |
| |
| typedef struct _WS_ATTRIBUTE_DESCRIPTION { |
| WS_XML_STRING *attributeLocalName; |
| WS_XML_STRING *attributeNs; |
| WS_TYPE type; |
| void *typeDescription; |
| } WS_ATTRIBUTE_DESCRIPTION; |
| |
| typedef struct _WS_ELEMENT_DESCRIPTION { |
| WS_XML_STRING *elementLocalName; |
| WS_XML_STRING *elementNs; |
| WS_TYPE type; |
| void *typeDescription; |
| } WS_ELEMENT_DESCRIPTION; |
| |
| typedef struct _WS_STRING { |
| ULONG length; |
| WCHAR *chars; |
| } WS_STRING; |
| |
| typedef struct _WS_UNIQUE_ID { |
| WS_STRING uri; |
| GUID guid; |
| } WS_UNIQUE_ID; |
| |
| typedef enum { |
| WS_XML_NODE_TYPE_ELEMENT = 1, |
| WS_XML_NODE_TYPE_TEXT = 2, |
| WS_XML_NODE_TYPE_END_ELEMENT = 3, |
| WS_XML_NODE_TYPE_COMMENT = 4, |
| WS_XML_NODE_TYPE_CDATA = 6, |
| WS_XML_NODE_TYPE_END_CDATA = 7, |
| WS_XML_NODE_TYPE_EOF = 8, |
| WS_XML_NODE_TYPE_BOF = 9 |
| } WS_XML_NODE_TYPE; |
| |
| typedef struct _WS_XML_NODE { |
| WS_XML_NODE_TYPE nodeType; |
| } WS_XML_NODE; |
| |
| typedef enum { |
| WS_MOVE_TO_ROOT_ELEMENT, |
| WS_MOVE_TO_NEXT_ELEMENT, |
| WS_MOVE_TO_PREVIOUS_ELEMENT, |
| WS_MOVE_TO_CHILD_ELEMENT, |
| WS_MOVE_TO_END_ELEMENT, |
| WS_MOVE_TO_PARENT_ELEMENT, |
| WS_MOVE_TO_NEXT_NODE, |
| WS_MOVE_TO_PREVIOUS_NODE, |
| WS_MOVE_TO_FIRST_NODE, |
| WS_MOVE_TO_BOF, |
| WS_MOVE_TO_EOF, |
| WS_MOVE_TO_CHILD_NODE |
| } WS_MOVE_TO; |
| |
| typedef enum { |
| WS_XML_TEXT_TYPE_UTF8 = 1, |
| WS_XML_TEXT_TYPE_UTF16 = 2, |
| WS_XML_TEXT_TYPE_BASE64 = 3, |
| WS_XML_TEXT_TYPE_BOOL = 4, |
| WS_XML_TEXT_TYPE_INT32 = 5, |
| WS_XML_TEXT_TYPE_INT64 = 6, |
| WS_XML_TEXT_TYPE_UINT64 = 7, |
| WS_XML_TEXT_TYPE_FLOAT = 8, |
| WS_XML_TEXT_TYPE_DOUBLE = 9, |
| WS_XML_TEXT_TYPE_DECIMAL = 10, |
| WS_XML_TEXT_TYPE_GUID = 11, |
| WS_XML_TEXT_TYPE_UNIQUE_ID = 12, |
| WS_XML_TEXT_TYPE_DATETIME = 13, |
| WS_XML_TEXT_TYPE_TIMESPAN = 14, |
| WS_XML_TEXT_TYPE_QNAME = 15, |
| WS_XML_TEXT_TYPE_LIST = 16 |
| } WS_XML_TEXT_TYPE; |
| |
| typedef struct _WS_XML_TEXT { |
| WS_XML_TEXT_TYPE textType; |
| } WS_XML_TEXT; |
| |
| typedef struct _WS_XML_UTF8_TEXT { |
| WS_XML_TEXT text; |
| WS_XML_STRING value; |
| } WS_XML_UTF8_TEXT; |
| |
| typedef struct _WS_XML_UTF16_TEXT { |
| WS_XML_TEXT text; |
| BYTE *bytes; |
| ULONG byteCount; |
| } WS_XML_UTF16_TEXT; |
| |
| typedef struct _WS_XML_BOOL_TEXT { |
| WS_XML_TEXT text; |
| WINBOOL value; |
| } WS_XML_BOOL_TEXT; |
| |
| typedef struct _WS_XML_INT32_TEXT { |
| WS_XML_TEXT text; |
| __int32 value; |
| } WS_XML_INT32_TEXT; |
| |
| typedef struct _WS_XML_INT64_TEXT { |
| WS_XML_TEXT text; |
| __int64 DECLSPEC_ALIGN(8) value; |
| } WS_XML_INT64_TEXT; |
| |
| typedef struct _WS_XML_UINT64_TEXT { |
| WS_XML_TEXT text; |
| unsigned __int64 DECLSPEC_ALIGN(8) value; |
| } WS_XML_UINT64_TEXT; |
| |
| typedef struct _WS_XML_FLOAT_TEXT { |
| WS_XML_TEXT text; |
| float value; |
| } WS_XML_FLOAT_TEXT; |
| |
| typedef struct _WS_XML_DOUBLE_TEXT { |
| WS_XML_TEXT text; |
| double DECLSPEC_ALIGN(8) value; |
| } WS_XML_DOUBLE_TEXT; |
| |
| typedef struct _WS_XML_GUID_TEXT { |
| WS_XML_TEXT text; |
| GUID value; |
| } WS_XML_GUID_TEXT; |
| |
| typedef struct _WS_XML_UNIQUE_ID_TEXT { |
| WS_XML_TEXT text; |
| GUID value; |
| } WS_XML_UNIQUE_ID_TEXT; |
| |
| typedef struct _WS_XML_QNAME_TEXT { |
| WS_XML_TEXT text; |
| WS_XML_STRING *prefix; |
| WS_XML_STRING *localName; |
| WS_XML_STRING *ns; |
| } WS_XML_QNAME_TEXT; |
| |
| typedef enum { |
| WS_BOOL_VALUE_TYPE, |
| WS_INT8_VALUE_TYPE, |
| WS_INT16_VALUE_TYPE, |
| WS_INT32_VALUE_TYPE, |
| WS_INT64_VALUE_TYPE, |
| WS_UINT8_VALUE_TYPE, |
| WS_UINT16_VALUE_TYPE, |
| WS_UINT32_VALUE_TYPE, |
| WS_UINT64_VALUE_TYPE, |
| WS_FLOAT_VALUE_TYPE, |
| WS_DOUBLE_VALUE_TYPE, |
| WS_DECIMAL_VALUE_TYPE, |
| WS_DATETIME_VALUE_TYPE, |
| WS_TIMESPAN_VALUE_TYPE, |
| WS_GUID_VALUE_TYPE, |
| WS_DURATION_VALUE_TYPE |
| } WS_VALUE_TYPE; |
| |
| typedef struct _WS_XML_ATTRIBUTE { |
| BYTE singleQuote; |
| BYTE isXmlNs; |
| WS_XML_STRING *prefix; |
| WS_XML_STRING *localName; |
| WS_XML_STRING *ns; |
| WS_XML_TEXT *value; |
| } WS_XML_ATTRIBUTE; |
| |
| typedef struct _WS_XML_ELEMENT_NODE { |
| WS_XML_NODE node; |
| WS_XML_STRING *prefix; |
| WS_XML_STRING *localName; |
| WS_XML_STRING *ns; |
| ULONG attributeCount; |
| WS_XML_ATTRIBUTE **attributes; |
| WINBOOL isEmpty; |
| } WS_XML_ELEMENT_NODE; |
| |
| typedef struct _WS_XML_TEXT_NODE { |
| WS_XML_NODE node; |
| WS_XML_TEXT *text; |
| } WS_XML_TEXT_NODE; |
| |
| typedef struct _WS_XML_COMMENT_NODE { |
| WS_XML_NODE node; |
| WS_XML_STRING value; |
| } WS_XML_COMMENT_NODE; |
| |
| typedef struct _WS_XML_NODE_POSITION { |
| WS_XML_BUFFER *buffer; |
| void *node; |
| } WS_XML_NODE_POSITION; |
| |
| typedef struct _WS_XML_QNAME { |
| WS_XML_STRING localName; |
| WS_XML_STRING ns; |
| } WS_XML_QNAME; |
| |
| typedef enum { |
| WS_SERVICE_PROXY_STATE_CREATED, |
| WS_SERVICE_PROXY_STATE_OPENING, |
| WS_SERVICE_PROXY_STATE_OPEN, |
| WS_SERVICE_PROXY_STATE_CLOSING, |
| WS_SERVICE_PROXY_STATE_CLOSED, |
| WS_SERVICE_PROXY_STATE_FAULTED |
| } WS_SERVICE_PROXY_STATE; |
| |
| typedef enum { |
| WS_PROXY_PROPERTY_CALL_TIMEOUT, |
| WS_PROXY_PROPERTY_MESSAGE_PROPERTIES, |
| WS_PROXY_PROPERTY_MAX_CALL_POOL_SIZE, |
| WS_PROXY_PROPERTY_STATE, |
| WS_PROXY_PROPERTY_MAX_PENDING_CALLS, |
| WS_PROXY_PROPERTY_MAX_CLOSE_TIMEOUT, |
| WS_PROXY_FAULT_LANG_ID |
| } WS_PROXY_PROPERTY_ID; |
| |
| struct _WS_PROXY_PROPERTY { |
| WS_PROXY_PROPERTY_ID id; |
| void *value; |
| ULONG valueSize; |
| }; |
| |
| typedef enum { |
| WS_CHANNEL_TYPE_INPUT = 0x1, |
| WS_CHANNEL_TYPE_OUTPUT = 0x2, |
| WS_CHANNEL_TYPE_SESSION = 0x4, |
| WS_CHANNEL_TYPE_INPUT_SESSION = (WS_CHANNEL_TYPE_INPUT | WS_CHANNEL_TYPE_SESSION), |
| WS_CHANNEL_TYPE_OUTPUT_SESSION = (WS_CHANNEL_TYPE_OUTPUT | WS_CHANNEL_TYPE_SESSION), |
| WS_CHANNEL_TYPE_DUPLEX = (WS_CHANNEL_TYPE_INPUT | WS_CHANNEL_TYPE_OUTPUT), |
| WS_CHANNEL_TYPE_DUPLEX_SESSION = (WS_CHANNEL_TYPE_INPUT | WS_CHANNEL_TYPE_OUTPUT | WS_CHANNEL_TYPE_SESSION), |
| WS_CHANNEL_TYPE_REQUEST = 0x8, |
| WS_CHANNEL_TYPE_REPLY = 0x10 |
| } WS_CHANNEL_TYPE; |
| |
| typedef enum { |
| WS_ENCODING_XML_BINARY_1, |
| WS_ENCODING_XML_BINARY_SESSION_1, |
| WS_ENCODING_XML_MTOM_UTF8, |
| WS_ENCODING_XML_MTOM_UTF16BE, |
| WS_ENCODING_XML_MTOM_UTF16LE, |
| WS_ENCODING_XML_UTF8, |
| WS_ENCODING_XML_UTF16BE, |
| WS_ENCODING_XML_UTF16LE, |
| WS_ENCODING_RAW |
| } WS_ENCODING; |
| |
| typedef enum { |
| WS_CHANNEL_STATE_CREATED, |
| WS_CHANNEL_STATE_OPENING, |
| WS_CHANNEL_STATE_ACCEPTING, |
| WS_CHANNEL_STATE_OPEN, |
| WS_CHANNEL_STATE_FAULTED, |
| WS_CHANNEL_STATE_CLOSING, |
| WS_CHANNEL_STATE_CLOSED |
| } WS_CHANNEL_STATE; |
| |
| typedef enum { |
| WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE = 0, |
| WS_CHANNEL_PROPERTY_MAX_STREAMED_MESSAGE_SIZE = 1, |
| WS_CHANNEL_PROPERTY_MAX_STREAMED_START_SIZE = 2, |
| WS_CHANNEL_PROPERTY_MAX_STREAMED_FLUSH_SIZE = 3, |
| WS_CHANNEL_PROPERTY_ENCODING = 4, |
| WS_CHANNEL_PROPERTY_ENVELOPE_VERSION = 5, |
| WS_CHANNEL_PROPERTY_ADDRESSING_VERSION = 6, |
| WS_CHANNEL_PROPERTY_MAX_SESSION_DICTIONARY_SIZE = 7, |
| WS_CHANNEL_PROPERTY_STATE = 8, |
| WS_CHANNEL_PROPERTY_ASYNC_CALLBACK_MODEL = 9, |
| WS_CHANNEL_PROPERTY_IP_VERSION = 10, |
| WS_CHANNEL_PROPERTY_RESOLVE_TIMEOUT = 11, |
| WS_CHANNEL_PROPERTY_CONNECT_TIMEOUT = 12, |
| WS_CHANNEL_PROPERTY_SEND_TIMEOUT = 13, |
| WS_CHANNEL_PROPERTY_RECEIVE_RESPONSE_TIMEOUT = 14, |
| WS_CHANNEL_PROPERTY_RECEIVE_TIMEOUT = 15, |
| WS_CHANNEL_PROPERTY_CLOSE_TIMEOUT = 16, |
| WS_CHANNEL_PROPERTY_ENABLE_TIMEOUTS = 17, |
| WS_CHANNEL_PROPERTY_TRANSFER_MODE = 18, |
| WS_CHANNEL_PROPERTY_MULTICAST_INTERFACE = 19, |
| WS_CHANNEL_PROPERTY_MULTICAST_HOPS = 20, |
| WS_CHANNEL_PROPERTY_REMOTE_ADDRESS = 21, |
| WS_CHANNEL_PROPERTY_REMOTE_IP_ADDRESS = 22, |
| WS_CHANNEL_PROPERTY_HTTP_CONNECTION_ID = 23, |
| WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_CALLBACKS = 24, |
| WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_PARAMETERS = 25, |
| WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_INSTANCE = 26, |
| WS_CHANNEL_PROPERTY_TRANSPORT_URL = 27, |
| WS_CHANNEL_PROPERTY_NO_DELAY = 28, |
| WS_CHANNEL_PROPERTY_SEND_KEEP_ALIVES = 29, |
| WS_CHANNEL_PROPERTY_KEEP_ALIVE_TIME = 30, |
| WS_CHANNEL_PROPERTY_KEEP_ALIVE_INTERVAL = 31, |
| WS_CHANNEL_PROPERTY_MAX_HTTP_SERVER_CONNECTIONS = 32, |
| WS_CHANNEL_PROPERTY_IS_SESSION_SHUT_DOWN = 33, |
| WS_CHANNEL_PROPERTY_CHANNEL_TYPE = 34, |
| WS_CHANNEL_PROPERTY_TRIM_BUFFERED_MESSAGE_SIZE = 35, |
| WS_CHANNEL_PROPERTY_ENCODER = 36, |
| WS_CHANNEL_PROPERTY_DECODER = 37, |
| WS_CHANNEL_PROPERTY_PROTECTION_LEVEL = 38, |
| WS_CHANNEL_PROPERTY_COOKIE_MODE = 39, |
| WS_CHANNEL_PROPERTY_HTTP_PROXY_SETTING_MODE = 40, |
| WS_CHANNEL_PROPERTY_CUSTOM_HTTP_PROXY = 41, |
| WS_CHANNEL_PROPERTY_HTTP_MESSAGE_MAPPING = 42, |
| WS_CHANNEL_PROPERTY_ENABLE_HTTP_REDIRECT = 43, |
| WS_CHANNEL_PROPERTY_HTTP_REDIRECT_CALLBACK_CONTEXT = 44, |
| WS_CHANNEL_PROPERTY_FAULTS_AS_ERRORS = 45, |
| WS_CHANNEL_PROPERTY_ALLOW_UNSECURED_FAULTS = 46, |
| WS_CHANNEL_PROPERTY_HTTP_SERVER_SPN = 47, |
| WS_CHANNEL_PROPERTY_HTTP_PROXY_SPN = 48, |
| WS_CHANNEL_PROPERTY_MAX_HTTP_REQUEST_HEADERS_BUFFER_SIZE = 49 |
| } WS_CHANNEL_PROPERTY_ID; |
| |
| struct _WS_CHANNEL_PROPERTY { |
| WS_CHANNEL_PROPERTY_ID id; |
| void *value; |
| ULONG valueSize; |
| }; |
| |
| struct _WS_CHANNEL_PROPERTIES { |
| WS_CHANNEL_PROPERTY *properties; |
| ULONG propertyCount; |
| }; |
| |
| typedef enum { |
| WS_HTTP_CHANNEL_BINDING, |
| WS_TCP_CHANNEL_BINDING, |
| WS_UDP_CHANNEL_BINDING, |
| WS_CUSTOM_CHANNEL_BINDING, |
| WS_NAMEDPIPE_CHANNEL_BINDING |
| } WS_CHANNEL_BINDING; |
| |
| typedef enum { |
| WS_SSL_TRANSPORT_SECURITY_BINDING_TYPE, |
| WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TYPE, |
| WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TYPE, |
| WS_USERNAME_MESSAGE_SECURITY_BINDING_TYPE, |
| WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TYPE, |
| WS_XML_TOKEN_MESSAGE_SECURITY_BINDING_TYPE, |
| WS_SAML_MESSAGE_SECURITY_BINDING_TYPE, |
| WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_TYPE, |
| WS_NAMEDPIPE_SSPI_TRANSPORT_SECURITY_BINDING_TYPE |
| } WS_SECURITY_BINDING_TYPE; |
| |
| typedef enum { |
| WS_SECURITY_BINDING_PROPERTY_REQUIRE_SSL_CLIENT_CERT = 1, |
| WS_SECURITY_BINDING_PROPERTY_WINDOWS_INTEGRATED_AUTH_PACKAGE = 2, |
| WS_SECURITY_BINDING_PROPERTY_REQUIRE_SERVER_AUTH = 3, |
| WS_SECURITY_BINDING_PROPERTY_ALLOW_ANONYMOUS_CLIENTS = 4, |
| WS_SECURITY_BINDING_PROPERTY_ALLOWED_IMPERSONATION_LEVEL = 5, |
| WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_SCHEME = 6, |
| WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_TARGET = 7, |
| WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_BASIC_REALM = 8, |
| WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_DIGEST_REALM = 9, |
| WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_DIGEST_DOMAIN = 10, |
| WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_KEY_SIZE = 11, |
| WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_KEY_ENTROPY_MODE = 12, |
| WS_SECURITY_BINDING_PROPERTY_MESSAGE_PROPERTIES = 13, |
| WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_MAX_PENDING_CONTEXTS = 14, |
| WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_MAX_ACTIVE_CONTEXTS = 15, |
| WS_SECURITY_BINDING_PROPERTY_SECURE_CONVERSATION_VERSION = 16, |
| WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_SUPPORT_RENEW = 17, |
| WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_RENEWAL_INTERVAL = 18, |
| WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_ROLLOVER_INTERVAL = 19, |
| WS_SECURITY_BINDING_PROPERTY_CERT_FAILURES_TO_IGNORE = 20, |
| WS_SECURITY_BINDING_PROPERTY_DISABLE_CERT_REVOCATION_CHECK = 21, |
| WS_SECURITY_BINDING_PROPERTY_DISALLOWED_SECURE_PROTOCOLS = 22, |
| WS_SECURITY_BINDING_PROPERTY_CERTIFICATE_VALIDATION_CALLBACK_CONTEXT = 23 |
| } WS_SECURITY_BINDING_PROPERTY_ID; |
| |
| struct _WS_SECURITY_BINDING_PROPERTY { |
| WS_SECURITY_BINDING_PROPERTY_ID id; |
| void *value; |
| ULONG valueSize; |
| }; |
| |
| struct _WS_SECURITY_BINDING_PROPERTIES { |
| WS_SECURITY_BINDING_PROPERTY *properties; |
| ULONG propertyCount; |
| }; |
| |
| struct _WS_SECURITY_BINDING { |
| WS_SECURITY_BINDING_TYPE bindingType; |
| WS_SECURITY_BINDING_PROPERTY *properties; |
| ULONG propertyCount; |
| }; |
| |
| typedef enum { |
| WS_SECURITY_PROPERTY_TRANSPORT_PROTECTION_LEVEL = 1, |
| WS_SECURITY_PROPERTY_ALGORITHM_SUITE = 2, |
| WS_SECURITY_PROPERTY_ALGORITHM_SUITE_NAME = 3, |
| WS_SECURITY_PROPERTY_MAX_ALLOWED_LATENCY = 4, |
| WS_SECURITY_PROPERTY_TIMESTAMP_VALIDITY_DURATION = 5, |
| WS_SECURITY_PROPERTY_MAX_ALLOWED_CLOCK_SKEW = 6, |
| WS_SECURITY_PROPERTY_TIMESTAMP_USAGE = 7, |
| WS_SECURITY_PROPERTY_SECURITY_HEADER_LAYOUT = 8, |
| WS_SECURITY_PROPERTY_SECURITY_HEADER_VERSION = 9, |
| WS_SECURITY_PROPERTY_EXTENDED_PROTECTION_POLICY = 10, |
| WS_SECURITY_PROPERTY_EXTENDED_PROTECTION_SCENARIO = 11, |
| WS_SECURITY_PROPERTY_SERVICE_IDENTITIES = 12 |
| } WS_SECURITY_PROPERTY_ID; |
| |
| struct _WS_SECURITY_PROPERTY { |
| WS_SECURITY_PROPERTY_ID id; |
| void *value; |
| ULONG valueSize; |
| }; |
| |
| struct _WS_SECURITY_PROPERTIES { |
| WS_SECURITY_PROPERTY *properties; |
| ULONG propertyCount; |
| }; |
| |
| struct _WS_SECURITY_DESCRIPTION { |
| WS_SECURITY_BINDING **securityBindings; |
| ULONG securityBindingCount; |
| WS_SECURITY_PROPERTY *properties; |
| ULONG propertyCount; |
| }; |
| |
| typedef enum { |
| WS_HTTP_BINDING_TEMPLATE_TYPE, |
| WS_HTTP_SSL_BINDING_TEMPLATE_TYPE, |
| WS_HTTP_HEADER_AUTH_BINDING_TEMPLATE_TYPE, |
| WS_HTTP_SSL_HEADER_AUTH_BINDING_TEMPLATE_TYPE, |
| WS_HTTP_SSL_USERNAME_BINDING_TEMPLATE_TYPE, |
| WS_HTTP_SSL_KERBEROS_APREQ_BINDING_TEMPLATE_TYPE, |
| WS_TCP_BINDING_TEMPLATE_TYPE, |
| WS_TCP_SSPI_BINDING_TEMPLATE_TYPE, |
| WS_TCP_SSPI_USERNAME_BINDING_TEMPLATE_TYPE, |
| WS_TCP_SSPI_KERBEROS_APREQ_BINDING_TEMPLATE_TYPE, |
| WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE, |
| WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE, |
| WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE, |
| WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE |
| } WS_BINDING_TEMPLATE_TYPE; |
| |
| typedef enum { |
| WS_SUBJECT_NAME_CERT_CREDENTIAL_TYPE = 1, |
| WS_THUMBPRINT_CERT_CREDENTIAL_TYPE = 2, |
| WS_CUSTOM_CERT_CREDENTIAL_TYPE = 3 |
| } WS_CERT_CREDENTIAL_TYPE; |
| |
| struct _WS_CERT_CREDENTIAL { |
| WS_CERT_CREDENTIAL_TYPE credentialType; |
| }; |
| |
| struct _WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE { |
| WS_SECURITY_BINDING_PROPERTIES securityBindingProperties; |
| WS_CERT_CREDENTIAL *localCertCredential; |
| }; |
| |
| struct _WS_HTTP_BINDING_TEMPLATE { |
| WS_CHANNEL_PROPERTIES channelProperties; |
| }; |
| |
| struct _WS_HTTP_SSL_BINDING_TEMPLATE { |
| WS_CHANNEL_PROPERTIES channelProperties; |
| WS_SECURITY_PROPERTIES securityProperties; |
| WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE sslTransportSecurityBinding; |
| }; |
| |
| enum { |
| WS_MUST_UNDERSTAND_HEADER_ATTRIBUTE = 0x1, |
| WS_RELAY_HEADER_ATTRIBUTE = 0x2 |
| }; |
| |
| typedef enum { |
| WS_ADDRESSING_VERSION_0_9 = 1, |
| WS_ADDRESSING_VERSION_1_0 = 2, |
| WS_ADDRESSING_VERSION_TRANSPORT = 3 |
| } WS_ADDRESSING_VERSION; |
| |
| typedef enum { |
| WS_ENVELOPE_VERSION_SOAP_1_1 = 1, |
| WS_ENVELOPE_VERSION_SOAP_1_2 = 2, |
| WS_ENVELOPE_VERSION_NONE = 3 |
| } WS_ENVELOPE_VERSION; |
| |
| typedef enum { |
| WS_MESSAGE_PROPERTY_STATE, |
| WS_MESSAGE_PROPERTY_HEAP, |
| WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, |
| WS_MESSAGE_PROPERTY_ADDRESSING_VERSION, |
| WS_MESSAGE_PROPERTY_HEADER_BUFFER, |
| WS_MESSAGE_PROPERTY_HEADER_POSITION, |
| WS_MESSAGE_PROPERTY_BODY_READER, |
| WS_MESSAGE_PROPERTY_BODY_WRITER, |
| WS_MESSAGE_PROPERTY_IS_ADDRESSED, |
| WS_MESSAGE_PROPERTY_HEAP_PROPERTIES, |
| WS_MESSAGE_PROPERTY_XML_READER_PROPERTIES, |
| WS_MESSAGE_PROPERTY_XML_WRITER_PROPERTIES, |
| WS_MESSAGE_PROPERTY_IS_FAULT, |
| WS_MESSAGE_PROPERTY_MAX_PROCESSED_HEADERS, |
| WS_MESSAGE_PROPERTY_USERNAME, |
| WS_MESSAGE_PROPERTY_ENCODED_CERT, |
| WS_MESSAGE_PROPERTY_TRANSPORT_SECURITY_WINDOWS_TOKEN, |
| WS_MESSAGE_PROPERTY_HTTP_HEADER_AUTH_WINDOWS_TOKEN, |
| WS_MESSAGE_PROPERTY_MESSAGE_SECURITY_WINDOWS_TOKEN, |
| WS_MESSAGE_PROPERTY_SAML_ASSERTION, |
| WS_MESSAGE_PROPERTY_SECURITY_CONTEXT, |
| WS_MESSAGE_PROPERTY_PROTECTION_LEVEL |
| } WS_MESSAGE_PROPERTY_ID; |
| |
| struct _WS_MESSAGE_PROPERTY { |
| WS_MESSAGE_PROPERTY_ID id; |
| void *value; |
| ULONG valueSize; |
| }; |
| |
| struct _WS_MESSAGE_PROPERTIES { |
| WS_MESSAGE_PROPERTY *properties; |
| ULONG propertyCount; |
| }; |
| |
| typedef enum { |
| WS_MESSAGE_STATE_EMPTY = 1, |
| WS_MESSAGE_STATE_INITIALIZED = 2, |
| WS_MESSAGE_STATE_READING = 3, |
| WS_MESSAGE_STATE_WRITING = 4, |
| WS_MESSAGE_STATE_DONE = 5 |
| } WS_MESSAGE_STATE; |
| |
| typedef enum { |
| WS_BLANK_MESSAGE, |
| WS_DUPLICATE_MESSAGE, |
| WS_REQUEST_MESSAGE, |
| WS_REPLY_MESSAGE, |
| WS_FAULT_MESSAGE |
| } WS_MESSAGE_INITIALIZATION; |
| |
| typedef enum { |
| WS_ACTION_HEADER = 1, |
| WS_TO_HEADER = 2, |
| WS_MESSAGE_ID_HEADER = 3, |
| WS_RELATES_TO_HEADER = 4, |
| WS_FROM_HEADER = 5, |
| WS_REPLY_TO_HEADER = 6, |
| WS_FAULT_TO_HEADER = 7 |
| } WS_HEADER_TYPE; |
| |
| typedef enum { |
| WS_REPEATING_HEADER = 1, |
| WS_SINGLETON_HEADER = 2 |
| } WS_REPEATING_HEADER_OPTION; |
| |
| typedef enum { |
| WS_DNS_ENDPOINT_IDENTITY_TYPE = 1, |
| WS_UPN_ENDPOINT_IDENTITY_TYPE = 2, |
| WS_SPN_ENDPOINT_IDENTITY_TYPE = 3, |
| WS_RSA_ENDPOINT_IDENTITY_TYPE = 4, |
| WS_CERT_ENDPOINT_IDENTITY_TYPE = 5, |
| WS_UNKNOWN_ENDPOINT_IDENTITY_TYPE = 6 |
| } WS_ENDPOINT_IDENTITY_TYPE; |
| |
| struct _WS_ENDPOINT_IDENTITY { |
| WS_ENDPOINT_IDENTITY_TYPE identityType; |
| }; |
| |
| struct _WS_ENDPOINT_ADDRESS { |
| WS_STRING url; |
| WS_XML_BUFFER *headers; |
| WS_XML_BUFFER *extensions; |
| WS_ENDPOINT_IDENTITY *identity; |
| }; |
| |
| typedef struct _WS_FAULT_CODE { |
| WS_XML_QNAME value; |
| struct _WS_FAULT_CODE *subCode; |
| } WS_FAULT_CODE; |
| |
| typedef struct _WS_FAULT_REASON { |
| WS_STRING text; |
| WS_STRING lang; |
| } WS_FAULT_REASON; |
| |
| typedef struct _WS_FAULT { |
| WS_FAULT_CODE *code; |
| WS_FAULT_REASON *reasons; |
| ULONG reasonCount; |
| WS_STRING actor; |
| WS_STRING node; |
| WS_XML_BUFFER *detail; |
| } WS_FAULT; |
| |
| typedef struct _WS_FAULT_DESCRIPTION { |
| WS_ENVELOPE_VERSION envelopeVersion; |
| } WS_FAULT_DESCRIPTION; |
| |
| typedef struct _WS_FAULT_DETAIL_DESCRIPTION { |
| WS_XML_STRING *action; |
| WS_ELEMENT_DESCRIPTION *detailElementDescription; |
| } WS_FAULT_DETAIL_DESCRIPTION; |
| |
| typedef enum { |
| WS_FAULT_ERROR_PROPERTY_FAULT = 0, |
| WS_FAULT_ERROR_PROPERTY_ACTION = 1, |
| WS_FAULT_ERROR_PROPERTY_HEADER = 2 |
| } WS_FAULT_ERROR_PROPERTY_ID; |
| |
| |
| struct _WS_HTTP_POLICY_DESCRIPTION { |
| WS_CHANNEL_PROPERTIES channelProperties; |
| }; |
| |
| struct _WS_MESSAGE_DESCRIPTION { |
| WS_XML_STRING *action; |
| WS_ELEMENT_DESCRIPTION *bodyElementDescription; |
| }; |
| |
| typedef enum { |
| WS_PARAMETER_TYPE_NORMAL, |
| WS_PARAMETER_TYPE_ARRAY, |
| WS_PARAMETER_TYPE_ARRAY_COUNT, |
| WS_PARAMETER_TYPE_MESSAGES |
| } WS_PARAMETER_TYPE; |
| |
| struct _WS_PARAMETER_DESCRIPTION { |
| WS_PARAMETER_TYPE parameterType; |
| USHORT inputMessageIndex; |
| USHORT outputMessageIndex; |
| }; |
| |
| typedef HRESULT (CALLBACK *WS_SERVICE_STUB_CALLBACK)( |
| const WS_OPERATION_CONTEXT *context, |
| void *frame, |
| const void *callback, |
| const WS_ASYNC_CONTEXT *asyncContext, |
| WS_ERROR *error ); |
| |
| typedef enum { |
| WS_NON_RPC_LITERAL_OPERATION, |
| WS_RPC_LITERAL_OPERATION |
| } WS_OPERATION_STYLE; |
| |
| struct _WS_OPERATION_DESCRIPTION { |
| ULONG versionInfo; |
| WS_MESSAGE_DESCRIPTION *inputMessageDescription; |
| WS_MESSAGE_DESCRIPTION *outputMessageDescription; |
| ULONG inputMessageOptions; |
| ULONG outputMessageOptions; |
| USHORT parameterCount; |
| WS_PARAMETER_DESCRIPTION *parameterDescription; |
| WS_SERVICE_STUB_CALLBACK stubCallback; |
| WS_OPERATION_STYLE style; |
| }; |
| |
| typedef enum { |
| WS_CALL_PROPERTY_CHECK_MUST_UNDERSTAND, |
| WS_CALL_PROPERTY_SEND_MESSAGE_CONTEXT, |
| WS_CALL_PROPERTY_RECEIVE_MESSAGE_CONTEXT, |
| WS_CALL_PROPERTY_CALL_ID |
| } WS_CALL_PROPERTY_ID; |
| |
| struct _WS_CALL_PROPERTY { |
| WS_CALL_PROPERTY_ID id; |
| void *value; |
| ULONG valueSize; |
| }; |
| |
| typedef enum { |
| WS_DATETIME_FORMAT_UTC, |
| WS_DATETIME_FORMAT_LOCAL, |
| WS_DATETIME_FORMAT_NONE |
| } WS_DATETIME_FORMAT; |
| |
| struct _WS_DATETIME { |
| unsigned __int64 DECLSPEC_ALIGN(8) ticks; |
| WS_DATETIME_FORMAT format; |
| }; |
| |
| struct _WS_DATETIME_DESCRIPTION { |
| WS_DATETIME minValue; |
| WS_DATETIME maxValue; |
| }; |
| |
| struct _WS_XML_DATETIME_TEXT { |
| WS_XML_TEXT text; |
| WS_DATETIME value; |
| }; |
| |
| struct _WS_XML_BASE64_TEXT { |
| WS_XML_TEXT text; |
| BYTE *bytes; |
| ULONG length; |
| }; |
| |
| typedef enum { |
| WS_URL_HTTP_SCHEME_TYPE, |
| WS_URL_HTTPS_SCHEME_TYPE, |
| WS_URL_NETTCP_SCHEME_TYPE, |
| WS_URL_SOAPUDP_SCHEME_TYPE, |
| WS_URL_NETPIPE_SCHEME_TYPE |
| } WS_URL_SCHEME_TYPE; |
| |
| enum { |
| WS_URL_FLAGS_ALLOW_HOST_WILDCARDS = 0x1, |
| WS_URL_FLAGS_NO_PATH_COLLAPSE = 0x2, |
| WS_URL_FLAGS_ZERO_TERMINATE = 0x4 |
| }; |
| |
| struct _WS_URL { |
| WS_URL_SCHEME_TYPE scheme; |
| }; |
| |
| struct _WS_HTTP_URL { |
| WS_URL url; |
| WS_STRING host; |
| USHORT port; |
| WS_STRING portAsString; |
| WS_STRING path; |
| WS_STRING query; |
| WS_STRING fragment; |
| }; |
| |
| struct _WS_HTTPS_URL { |
| WS_URL url; |
| WS_STRING host; |
| USHORT port; |
| WS_STRING portAsString; |
| WS_STRING path; |
| WS_STRING query; |
| WS_STRING fragment; |
| }; |
| |
| struct _WS_NETTCP_URL { |
| WS_URL url; |
| WS_STRING host; |
| USHORT port; |
| WS_STRING portAsString; |
| WS_STRING path; |
| WS_STRING query; |
| WS_STRING fragment; |
| }; |
| |
| struct _WS_SOAPUDP_URL { |
| WS_URL url; |
| WS_STRING host; |
| USHORT port; |
| WS_STRING portAsString; |
| WS_STRING path; |
| WS_STRING query; |
| WS_STRING fragment; |
| }; |
| |
| struct _WS_NETPIPE_URL { |
| WS_URL url; |
| WS_STRING host; |
| USHORT port; |
| WS_STRING portAsString; |
| WS_STRING path; |
| WS_STRING query; |
| WS_STRING fragment; |
| }; |
| |
| typedef enum |
| { |
| WS_IP_VERSION_4 = 1, |
| WS_IP_VERSION_6 = 2, |
| WS_IP_VERSION_AUTO = 3 |
| } WS_IP_VERSION; |
| |
| typedef enum |
| { |
| WS_BUFFERED_TRANSFER_MODE = 0x0, |
| WS_STREAMED_INPUT_TRANSFER_MODE = 0x1, |
| WS_STREAMED_OUTPUT_TRANSFER_MODE = 0x2, |
| WS_STREAMED_TRANSFER_MODE = (WS_STREAMED_INPUT_TRANSFER_MODE|WS_STREAMED_OUTPUT_TRANSFER_MODE) |
| } WS_TRANSFER_MODE; |
| |
| typedef HRESULT (CALLBACK *WS_CREATE_CHANNEL_CALLBACK) |
| (WS_CHANNEL_TYPE, const void*, ULONG, void**, WS_ERROR*); |
| |
| typedef void (CALLBACK *WS_FREE_CHANNEL_CALLBACK) |
| (void*); |
| |
| typedef HRESULT (CALLBACK *WS_RESET_CHANNEL_CALLBACK) |
| (void*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_OPEN_CHANNEL_CALLBACK) |
| (void*, const WS_ENDPOINT_ADDRESS*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_CLOSE_CHANNEL_CALLBACK) |
| (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_ABORT_CHANNEL_CALLBACK) |
| (void*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_GET_CHANNEL_PROPERTY_CALLBACK) |
| (void*, WS_CHANNEL_PROPERTY_ID, void*, ULONG, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_SET_CHANNEL_PROPERTY_CALLBACK) |
| (void*, WS_CHANNEL_PROPERTY_ID, const void*, ULONG, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_WRITE_MESSAGE_START_CALLBACK) |
| (void*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_WRITE_MESSAGE_END_CALLBACK) |
| (void*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_READ_MESSAGE_START_CALLBACK) |
| (void*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_READ_MESSAGE_END_CALLBACK) |
| (void*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_ABANDON_MESSAGE_CALLBACK) |
| (void*, WS_MESSAGE*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_SHUTDOWN_SESSION_CHANNEL_CALLBACK) |
| (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| struct _WS_CUSTOM_CHANNEL_CALLBACKS |
| { |
| WS_CREATE_CHANNEL_CALLBACK createChannelCallback; |
| WS_FREE_CHANNEL_CALLBACK freeChannelCallback; |
| WS_RESET_CHANNEL_CALLBACK resetChannelCallback; |
| WS_OPEN_CHANNEL_CALLBACK openChannelCallback; |
| WS_CLOSE_CHANNEL_CALLBACK closeChannelCallback; |
| WS_ABORT_CHANNEL_CALLBACK abortChannelCallback; |
| WS_GET_CHANNEL_PROPERTY_CALLBACK getChannelPropertyCallback; |
| WS_SET_CHANNEL_PROPERTY_CALLBACK setChannelPropertyCallback; |
| WS_WRITE_MESSAGE_START_CALLBACK writeMessageStartCallback; |
| WS_WRITE_MESSAGE_END_CALLBACK writeMessageEndCallback; |
| WS_READ_MESSAGE_START_CALLBACK readMessageStartCallback; |
| WS_READ_MESSAGE_END_CALLBACK readMessageEndCallback; |
| WS_ABANDON_MESSAGE_CALLBACK abandonMessageCallback; |
| WS_SHUTDOWN_SESSION_CHANNEL_CALLBACK shutdownSessionChannelCallback; |
| }; |
| |
| typedef HRESULT (CALLBACK *WS_CREATE_ENCODER_CALLBACK) |
| (void*, WS_WRITE_CALLBACK, void*, void**, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_ENCODER_GET_CONTENT_TYPE_CALLBACK) |
| (void*, const WS_STRING*, WS_STRING*, WS_STRING*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_ENCODER_START_CALLBACK) |
| (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_ENCODER_ENCODE_CALLBACK) |
| (void*, const WS_BYTES*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_ENCODER_END_CALLBACK) |
| (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| typedef void (CALLBACK *WS_FREE_ENCODER_CALLBACK) |
| (void*); |
| |
| struct _WS_CHANNEL_ENCODER |
| { |
| void *createContext; |
| WS_CREATE_ENCODER_CALLBACK createEncoderCallback; |
| WS_ENCODER_GET_CONTENT_TYPE_CALLBACK encoderGetContentTypeCallback; |
| WS_ENCODER_START_CALLBACK encoderStartCallback; |
| WS_ENCODER_ENCODE_CALLBACK encoderEncodeCallback; |
| WS_ENCODER_END_CALLBACK encoderEndCallback; |
| WS_FREE_ENCODER_CALLBACK freeEncoderCallback; |
| }; |
| |
| typedef HRESULT (CALLBACK *WS_CREATE_DECODER_CALLBACK) |
| (void*, WS_READ_CALLBACK, void*, void**, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_DECODER_GET_CONTENT_TYPE_CALLBACK) |
| (void*, const WS_STRING*, const WS_STRING*, WS_STRING*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_DECODER_START_CALLBACK) |
| (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_DECODER_DECODE_CALLBACK) |
| (void*, void*, ULONG, ULONG*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_DECODER_END_CALLBACK) |
| (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| typedef void (CALLBACK *WS_FREE_DECODER_CALLBACK) |
| (void*); |
| |
| struct _WS_CHANNEL_DECODER |
| { |
| void *createContext; |
| WS_CREATE_DECODER_CALLBACK createDecoderCallback; |
| WS_DECODER_GET_CONTENT_TYPE_CALLBACK decoderGetContentTypeCallback; |
| WS_DECODER_START_CALLBACK decoderStartCallback; |
| WS_DECODER_DECODE_CALLBACK decoderDecodeCallback; |
| WS_DECODER_END_CALLBACK decoderEndCallback; |
| WS_FREE_DECODER_CALLBACK freeDecoderCallback; |
| }; |
| |
| typedef enum |
| { |
| WS_PROTECTION_LEVEL_NONE = 1, |
| WS_PROTECTION_LEVEL_SIGN = 2, |
| WS_PROTECTION_LEVEL_SIGN_AND_ENCRYPT = 3 |
| } WS_PROTECTION_LEVEL; |
| |
| typedef enum |
| { |
| WS_MANUAL_COOKIE_MODE = 1, |
| WS_AUTO_COOKIE_MODE = 2 |
| } WS_COOKIE_MODE; |
| |
| typedef enum |
| { |
| WS_HTTP_PROXY_SETTING_MODE_AUTO = 0x1, |
| WS_HTTP_PROXY_SETTING_MODE_NONE = 0x2, |
| WS_HTTP_PROXY_SETTING_MODE_CUSTOM = 0x3 |
| } WS_HTTP_PROXY_SETTING_MODE; |
| |
| struct _WS_CUSTOM_HTTP_PROXY |
| { |
| WS_STRING servers; |
| WS_STRING bypass; |
| }; |
| |
| struct _WS_HTTP_HEADER_MAPPING |
| { |
| WS_XML_STRING headerName; |
| ULONG headerMappingOptions; |
| }; |
| |
| struct _WS_HTTP_MESSAGE_MAPPING |
| { |
| ULONG requestMappingOptions; |
| ULONG responseMappingOptions; |
| WS_HTTP_HEADER_MAPPING **requestHeaderMappings; |
| ULONG requestHeaderMappingCount; |
| WS_HTTP_HEADER_MAPPING **responseHeaderMappings; |
| ULONG responseHeaderMappingCount; |
| }; |
| |
| typedef HRESULT (CALLBACK *WS_HTTP_REDIRECT_CALLBACK) |
| (void*, const WS_STRING*, const WS_STRING*); |
| |
| struct _WS_HTTP_REDIRECT_CALLBACK_CONTEXT |
| { |
| WS_HTTP_REDIRECT_CALLBACK callback; |
| void *state; |
| }; |
| |
| typedef enum |
| { |
| WS_RECEIVE_REQUIRED_MESSAGE = 1, |
| WS_RECEIVE_OPTIONAL_MESSAGE = 2 |
| } WS_RECEIVE_OPTION; |
| |
| typedef void (CALLBACK *WS_MESSAGE_DONE_CALLBACK) |
| (void*); |
| |
| typedef HRESULT (CALLBACK *WS_PROXY_MESSAGE_CALLBACK) |
| (WS_MESSAGE*, WS_HEAP*, void*, WS_ERROR*); |
| |
| struct _WS_PROXY_MESSAGE_CALLBACK_CONTEXT |
| { |
| WS_PROXY_MESSAGE_CALLBACK callback; |
| void *state; |
| }; |
| |
| typedef enum |
| { |
| WS_LISTENER_STATE_CREATED, |
| WS_LISTENER_STATE_OPENING, |
| WS_LISTENER_STATE_OPEN, |
| WS_LISTENER_STATE_FAULTED, |
| WS_LISTENER_STATE_CLOSING, |
| WS_LISTENER_STATE_CLOSED |
| } WS_LISTENER_STATE; |
| |
| typedef enum |
| { |
| WS_LISTENER_PROPERTY_LISTEN_BACKLOG, |
| WS_LISTENER_PROPERTY_IP_VERSION, |
| WS_LISTENER_PROPERTY_STATE, |
| WS_LISTENER_PROPERTY_ASYNC_CALLBACK_MODEL, |
| WS_LISTENER_PROPERTY_CHANNEL_TYPE, |
| WS_LISTENER_PROPERTY_CHANNEL_BINDING, |
| WS_LISTENER_PROPERTY_CONNECT_TIMEOUT, |
| WS_LISTENER_PROPERTY_IS_MULTICAST, |
| WS_LISTENER_PROPERTY_MULTICAST_INTERFACES, |
| WS_LISTENER_PROPERTY_MULTICAST_LOOPBACK, |
| WS_LISTENER_PROPERTY_CLOSE_TIMEOUT, |
| WS_LISTENER_PROPERTY_TO_HEADER_MATCHING_OPTIONS, |
| WS_LISTENER_PROPERTY_TRANSPORT_URL_MATCHING_OPTIONS, |
| WS_LISTENER_PROPERTY_CUSTOM_LISTENER_CALLBACKS, |
| WS_LISTENER_PROPERTY_CUSTOM_LISTENER_PARAMETERS, |
| WS_LISTENER_PROPERTY_CUSTOM_LISTENER_INSTANCE, |
| WS_LISTENER_PROPERTY_DISALLOWED_USER_AGENT |
| } WS_LISTENER_PROPERTY_ID; |
| |
| struct _WS_LISTENER_PROPERTY |
| { |
| WS_LISTENER_PROPERTY_ID id; |
| void *value; |
| ULONG valueSize; |
| }; |
| |
| struct _WS_DISALLOWED_USER_AGENT_SUBSTRINGS |
| { |
| ULONG subStringCount; |
| WS_STRING **subStrings; |
| }; |
| |
| struct _WS_LISTENER_PROPERTIES |
| { |
| WS_LISTENER_PROPERTY *properties; |
| ULONG propertyCount; |
| }; |
| |
| typedef HRESULT (CALLBACK *WS_CREATE_LISTENER_CALLBACK) |
| (WS_CHANNEL_TYPE, const void*, ULONG, void**, WS_ERROR*); |
| |
| typedef void (CALLBACK *WS_FREE_LISTENER_CALLBACK) |
| (void*); |
| |
| typedef HRESULT (CALLBACK *WS_RESET_LISTENER_CALLBACK) |
| (void*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_OPEN_LISTENER_CALLBACK) |
| (void*, const WS_STRING*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_CLOSE_LISTENER_CALLBACK) |
| (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_ABORT_LISTENER_CALLBACK) |
| (void*, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_GET_LISTENER_PROPERTY_CALLBACK) |
| (void*, WS_LISTENER_PROPERTY_ID, void*, ULONG, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_SET_LISTENER_PROPERTY_CALLBACK) |
| (void*, WS_LISTENER_PROPERTY_ID, const void*, ULONG, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_CREATE_CHANNEL_FOR_LISTENER_CALLBACK) |
| (void*, const void*, ULONG, void**, WS_ERROR*); |
| |
| typedef HRESULT (CALLBACK *WS_ACCEPT_CHANNEL_CALLBACK) |
| (void*, void*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| |
| struct _WS_CUSTOM_LISTENER_CALLBACKS |
| { |
| WS_CREATE_LISTENER_CALLBACK createListenerCallback; |
| WS_FREE_LISTENER_CALLBACK freeListenerCallback; |
| WS_RESET_LISTENER_CALLBACK resetListenerCallback; |
| WS_OPEN_LISTENER_CALLBACK openListenerCallback; |
| WS_CLOSE_LISTENER_CALLBACK closeListenerCallback; |
| WS_ABORT_LISTENER_CALLBACK abortListenerCallback; |
| WS_GET_LISTENER_PROPERTY_CALLBACK getListenerPropertyCallback; |
| WS_SET_LISTENER_PROPERTY_CALLBACK setListenerPropertyCallback; |
| WS_CREATE_CHANNEL_FOR_LISTENER_CALLBACK createChannelForListenerCallback; |
| WS_ACCEPT_CHANNEL_CALLBACK acceptChannelCallback; |
| }; |
| |
| enum |
| { |
| WS_MATCH_URL_DNS_HOST = 0x1, |
| WS_MATCH_URL_DNS_FULLY_QUALIFIED_HOST = 0x2, |
| WS_MATCH_URL_NETBIOS_HOST = 0x4, |
| WS_MATCH_URL_LOCAL_HOST = 0x8, |
| WS_MATCH_URL_HOST_ADDRESSES = 0x10, |
| WS_MATCH_URL_THIS_HOST = (WS_MATCH_URL_DNS_HOST | |
| WS_MATCH_URL_DNS_FULLY_QUALIFIED_HOST | |
| WS_MATCH_URL_NETBIOS_HOST | |
| WS_MATCH_URL_LOCAL_HOST | |
| WS_MATCH_URL_HOST_ADDRESSES), |
| WS_MATCH_URL_PORT = 0x20, |
| WS_MATCH_URL_EXACT_PATH = 0x40, |
| WS_MATCH_URL_PREFIX_PATH = 0x80, |
| WS_MATCH_URL_NO_QUERY = 0x100 |
| }; |
| |
| HRESULT WINAPI WsAbortServiceProxy(WS_SERVICE_PROXY*, WS_ERROR*); |
| HRESULT WINAPI WsAcceptChannel(WS_LISTENER*, WS_CHANNEL*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsAddCustomHeader(WS_MESSAGE*, const WS_ELEMENT_DESCRIPTION*, WS_WRITE_OPTION, |
| const void*, ULONG, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsAddErrorString(WS_ERROR*, const WS_STRING*); |
| HRESULT WINAPI WsAddMappedHeader(WS_MESSAGE*, const WS_XML_STRING*, WS_TYPE, WS_WRITE_OPTION, |
| const void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsAddressMessage(WS_MESSAGE*, const WS_ENDPOINT_ADDRESS*, WS_ERROR*); |
| HRESULT WINAPI WsAlloc(WS_HEAP*, SIZE_T, void**, WS_ERROR*); |
| HRESULT WINAPI WsCall(WS_SERVICE_PROXY*, const WS_OPERATION_DESCRIPTION*, const void**, |
| WS_HEAP*, const WS_CALL_PROPERTY*, const ULONG, const WS_ASYNC_CONTEXT*, |
| WS_ERROR*); |
| HRESULT WINAPI WsCloseChannel(WS_CHANNEL*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsCloseListener(WS_LISTENER*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsCloseServiceProxy(WS_SERVICE_PROXY*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsCombineUrl(const WS_STRING*, const WS_STRING*, ULONG, WS_HEAP*, WS_STRING*, WS_ERROR*); |
| HRESULT WINAPI WsCopyNode(WS_XML_WRITER*, WS_XML_READER*, WS_ERROR*); |
| HRESULT WINAPI WsCreateChannel(WS_CHANNEL_TYPE, WS_CHANNEL_BINDING, const WS_CHANNEL_PROPERTY*, |
| ULONG, const WS_SECURITY_DESCRIPTION*, WS_CHANNEL**, WS_ERROR*); |
| HRESULT WINAPI WsCreateChannelForListener(WS_LISTENER*, const WS_CHANNEL_PROPERTY*, ULONG, WS_CHANNEL**, |
| WS_ERROR*); |
| HRESULT WINAPI WsCreateError(const WS_ERROR_PROPERTY*, ULONG, WS_ERROR**); |
| HRESULT WINAPI WsCreateHeap(SIZE_T, SIZE_T, const WS_HEAP_PROPERTY*, ULONG, WS_HEAP**, WS_ERROR*); |
| HRESULT WINAPI WsCreateListener(WS_CHANNEL_TYPE, WS_CHANNEL_BINDING, const WS_LISTENER_PROPERTY*, |
| ULONG, const WS_SECURITY_DESCRIPTION*, WS_LISTENER**, WS_ERROR*); |
| HRESULT WINAPI WsCreateMessage(WS_ENVELOPE_VERSION, WS_ADDRESSING_VERSION, const WS_MESSAGE_PROPERTY*, |
| ULONG, WS_MESSAGE**, WS_ERROR*); |
| HRESULT WINAPI WsCreateMessageForChannel(WS_CHANNEL*, const WS_MESSAGE_PROPERTY*, ULONG, WS_MESSAGE**, |
| WS_ERROR*); |
| HRESULT WINAPI WsCreateReader(const WS_XML_READER_PROPERTY*, ULONG, WS_XML_READER**, WS_ERROR*); |
| HRESULT WINAPI WsCreateServiceProxy(const WS_CHANNEL_TYPE, const WS_CHANNEL_BINDING, |
| const WS_SECURITY_DESCRIPTION*, const WS_PROXY_PROPERTY*, |
| const ULONG, const WS_CHANNEL_PROPERTY*, const ULONG, |
| WS_SERVICE_PROXY**, WS_ERROR*); |
| HRESULT WINAPI WsCreateServiceProxyFromTemplate(WS_CHANNEL_TYPE, const WS_PROXY_PROPERTY*, |
| const ULONG, WS_BINDING_TEMPLATE_TYPE, |
| void*, ULONG, const void*, ULONG, |
| WS_SERVICE_PROXY**, WS_ERROR*); |
| HRESULT WINAPI WsCreateWriter(const WS_XML_WRITER_PROPERTY*, ULONG, WS_XML_WRITER**, WS_ERROR*); |
| HRESULT WINAPI WsCreateXmlBuffer(WS_HEAP*, const WS_XML_BUFFER_PROPERTY*, ULONG, WS_XML_BUFFER**, |
| WS_ERROR*); |
| HRESULT WINAPI WsDateTimeToFileTime(const WS_DATETIME*, FILETIME*, WS_ERROR*); |
| HRESULT WINAPI WsDecodeUrl(const WS_STRING*, ULONG, WS_HEAP*, WS_URL**, WS_ERROR*); |
| HRESULT WINAPI WsEncodeUrl(const WS_URL*, ULONG, WS_HEAP*, WS_STRING*, WS_ERROR*); |
| HRESULT WINAPI WsFileTimeToDateTime(const FILETIME*, WS_DATETIME*, WS_ERROR*); |
| HRESULT WINAPI WsFillBody(WS_MESSAGE*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsFillReader(WS_XML_READER*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsFindAttribute(WS_XML_READER*, const WS_XML_STRING*, const WS_XML_STRING*, WINBOOL, |
| ULONG*, WS_ERROR*); |
| HRESULT WINAPI WsFlushBody(WS_MESSAGE*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsFlushWriter(WS_XML_WRITER*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| void WINAPI WsFreeChannel(WS_CHANNEL*); |
| void WINAPI WsFreeError(WS_ERROR*); |
| void WINAPI WsFreeHeap(WS_HEAP*); |
| void WINAPI WsFreeListener(WS_LISTENER*); |
| void WINAPI WsFreeMessage(WS_MESSAGE*); |
| void WINAPI WsFreeReader(WS_XML_READER*); |
| void WINAPI WsFreeServiceProxy(WS_SERVICE_PROXY*); |
| void WINAPI WsFreeWriter(WS_XML_WRITER*); |
| HRESULT WINAPI WsGetChannelProperty(WS_CHANNEL*, WS_CHANNEL_PROPERTY_ID, void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsGetCustomHeader(WS_MESSAGE*, const WS_ELEMENT_DESCRIPTION*, WS_REPEATING_HEADER_OPTION, |
| ULONG, WS_READ_OPTION, WS_HEAP*, void*, ULONG, ULONG*, WS_ERROR*); |
| HRESULT WINAPI WsGetDictionary(WS_ENCODING, WS_XML_DICTIONARY**, WS_ERROR*); |
| HRESULT WINAPI WsGetErrorProperty(WS_ERROR*, WS_ERROR_PROPERTY_ID, void*, ULONG); |
| HRESULT WINAPI WsGetErrorString(WS_ERROR*, ULONG, WS_STRING*); |
| HRESULT WINAPI WsGetFaultErrorDetail(WS_ERROR*, const WS_FAULT_DETAIL_DESCRIPTION*, WS_READ_OPTION, |
| WS_HEAP*, void*, ULONG); |
| HRESULT WINAPI WsGetFaultErrorProperty(WS_ERROR*, WS_FAULT_ERROR_PROPERTY_ID, void*, ULONG); |
| HRESULT WINAPI WsGetHeader(WS_MESSAGE*, WS_HEADER_TYPE, WS_TYPE, WS_READ_OPTION, WS_HEAP*, void*, |
| ULONG, WS_ERROR*); |
| HRESULT WINAPI WsGetHeapProperty(WS_HEAP*, WS_HEAP_PROPERTY_ID, void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsGetListenerProperty(WS_LISTENER*, WS_LISTENER_PROPERTY_ID, void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsGetMappedHeader(WS_MESSAGE*, const WS_XML_STRING*, WS_REPEATING_HEADER_OPTION, |
| ULONG, WS_TYPE, WS_READ_OPTION, WS_HEAP*, void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsGetMessageProperty(WS_MESSAGE*, WS_MESSAGE_PROPERTY_ID, void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsGetNamespaceFromPrefix(WS_XML_READER*, const WS_XML_STRING*, WINBOOL, |
| const WS_XML_STRING**, WS_ERROR*); |
| HRESULT WINAPI WsGetPrefixFromNamespace(WS_XML_WRITER*, const WS_XML_STRING*, WINBOOL, |
| const WS_XML_STRING**, WS_ERROR*); |
| HRESULT WINAPI WsGetReaderNode(WS_XML_READER*, const WS_XML_NODE**, WS_ERROR*); |
| HRESULT WINAPI WsGetReaderPosition(WS_XML_READER*, WS_XML_NODE_POSITION*, WS_ERROR*); |
| HRESULT WINAPI WsGetReaderProperty(WS_XML_READER*, WS_XML_READER_PROPERTY_ID, void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsGetServiceProxyProperty(WS_SERVICE_PROXY*, const WS_PROXY_PROPERTY_ID, void*, |
| ULONG, WS_ERROR*); |
| HRESULT WINAPI WsGetWriterPosition(WS_XML_WRITER*, WS_XML_NODE_POSITION*, WS_ERROR*); |
| HRESULT WINAPI WsGetWriterProperty(WS_XML_WRITER*, WS_XML_WRITER_PROPERTY_ID, void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsGetXmlAttribute(WS_XML_READER*, const WS_XML_STRING*, WS_HEAP*, WCHAR**, |
| ULONG*, WS_ERROR*); |
| HRESULT WINAPI WsInitializeMessage(WS_MESSAGE*, WS_MESSAGE_INITIALIZATION, WS_MESSAGE*, WS_ERROR*); |
| HRESULT WINAPI WsMoveReader(WS_XML_READER*, WS_MOVE_TO, WINBOOL*, WS_ERROR*); |
| HRESULT WINAPI WsMoveWriter(WS_XML_WRITER*, WS_MOVE_TO, WINBOOL*, WS_ERROR*); |
| HRESULT WINAPI WsOpenChannel(WS_CHANNEL*, const WS_ENDPOINT_ADDRESS*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsOpenListener(WS_LISTENER*, const WS_STRING*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsOpenServiceProxy(WS_SERVICE_PROXY*, const WS_ENDPOINT_ADDRESS*, const WS_ASYNC_CONTEXT*, |
| WS_ERROR*); |
| HRESULT WINAPI WsReadAttribute(WS_XML_READER*, const WS_ATTRIBUTE_DESCRIPTION*, WS_READ_OPTION, |
| WS_HEAP*, void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsReadBody(WS_MESSAGE*, const WS_ELEMENT_DESCRIPTION*, WS_READ_OPTION, WS_HEAP*, void*, |
| ULONG, WS_ERROR*); |
| HRESULT WINAPI WsReadBytes(WS_XML_READER*, void*, ULONG, ULONG*, WS_ERROR*); |
| HRESULT WINAPI WsReadChars(WS_XML_READER*, WCHAR*, ULONG, ULONG*, WS_ERROR*); |
| HRESULT WINAPI WsReadCharsUtf8(WS_XML_READER*, BYTE*, ULONG, ULONG*, WS_ERROR*); |
| HRESULT WINAPI WsReadElement(WS_XML_READER*, const WS_ELEMENT_DESCRIPTION*, WS_READ_OPTION, |
| WS_HEAP*, void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsReadEndAttribute(WS_XML_READER*, WS_ERROR*); |
| HRESULT WINAPI WsReadEndElement(WS_XML_READER*, WS_ERROR*); |
| HRESULT WINAPI WsReadEnvelopeEnd(WS_MESSAGE*, WS_ERROR*); |
| HRESULT WINAPI WsReadEnvelopeStart(WS_MESSAGE*, WS_XML_READER*, WS_MESSAGE_DONE_CALLBACK, void*, |
| WS_ERROR*); |
| HRESULT WINAPI WsReadMessageEnd(WS_CHANNEL*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsReadMessageStart(WS_CHANNEL*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsReadNode(WS_XML_READER*, WS_ERROR*); |
| HRESULT WINAPI WsReadQualifiedName(WS_XML_READER*, WS_HEAP*, WS_XML_STRING*, WS_XML_STRING*, |
| WS_XML_STRING*, WS_ERROR*); |
| HRESULT WINAPI WsReadStartAttribute(WS_XML_READER*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsReadStartElement(WS_XML_READER*, WS_ERROR*); |
| HRESULT WINAPI WsReadToStartElement(WS_XML_READER*, const WS_XML_STRING*, const WS_XML_STRING*, |
| WINBOOL*, WS_ERROR*); |
| HRESULT WINAPI WsReadType(WS_XML_READER*, WS_TYPE_MAPPING, WS_TYPE, const void*, WS_READ_OPTION, |
| WS_HEAP*, void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsReadValue(WS_XML_READER*, WS_VALUE_TYPE, void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsReadXmlBuffer(WS_XML_READER*, WS_HEAP*, WS_XML_BUFFER**, WS_ERROR*); |
| HRESULT WINAPI WsReceiveMessage(WS_CHANNEL*, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION**, ULONG, |
| WS_RECEIVE_OPTION, WS_READ_OPTION, WS_HEAP*, void*, ULONG, ULONG*, |
| const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsRemoveCustomHeader(WS_MESSAGE*, const WS_XML_STRING*, const WS_XML_STRING*, |
| WS_ERROR*); |
| HRESULT WINAPI WsRemoveHeader(WS_MESSAGE*, WS_HEADER_TYPE, WS_ERROR*); |
| HRESULT WINAPI WsRemoveMappedHeader(WS_MESSAGE*, const WS_XML_STRING*, WS_ERROR*); |
| HRESULT WINAPI WsRemoveNode(const WS_XML_NODE_POSITION*, WS_ERROR*); |
| HRESULT WINAPI WsRequestReply(WS_CHANNEL*, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*, WS_WRITE_OPTION, |
| const void*, ULONG, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*, WS_READ_OPTION, |
| WS_HEAP*, void*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsResetChannel(WS_CHANNEL*, WS_ERROR*); |
| HRESULT WINAPI WsResetMessage(WS_MESSAGE*, WS_ERROR*); |
| HRESULT WINAPI WsResetError(WS_ERROR*); |
| HRESULT WINAPI WsResetHeap(WS_HEAP*, WS_ERROR*); |
| HRESULT WINAPI WsResetListener(WS_LISTENER*, WS_ERROR*); |
| HRESULT WINAPI WsResetMessage(WS_MESSAGE*, WS_ERROR*); |
| HRESULT WINAPI WsResetServiceProxy(WS_SERVICE_PROXY*, WS_ERROR*); |
| HRESULT WINAPI WsRequestReply(WS_CHANNEL*, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*, WS_WRITE_OPTION, |
| const void*, ULONG, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*, |
| WS_READ_OPTION, WS_HEAP*, void*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsSendMessage(WS_CHANNEL*, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*, WS_WRITE_OPTION, |
| const void*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsSendReplyMessage(WS_CHANNEL*, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*, |
| WS_WRITE_OPTION, const void*, ULONG, WS_MESSAGE*, |
| const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsSetChannelProperty(WS_CHANNEL*, WS_CHANNEL_PROPERTY_ID, const void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsSetErrorProperty(WS_ERROR*, WS_ERROR_PROPERTY_ID, const void*, ULONG); |
| HRESULT WINAPI WsSetFaultErrorProperty(WS_ERROR*, WS_FAULT_ERROR_PROPERTY_ID, const void*, ULONG); |
| HRESULT WINAPI WsSetHeader(WS_MESSAGE*, WS_HEADER_TYPE, WS_TYPE, WS_WRITE_OPTION, const void*, ULONG, |
| WS_ERROR*); |
| HRESULT WINAPI WsSetInput(WS_XML_READER*, const WS_XML_READER_ENCODING*, const WS_XML_READER_INPUT*, |
| const WS_XML_READER_PROPERTY*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsSetInputToBuffer(WS_XML_READER*, WS_XML_BUFFER*, const WS_XML_READER_PROPERTY*, |
| ULONG, WS_ERROR*); |
| HRESULT WINAPI WsSetListenerProperty(WS_LISTENER*, WS_LISTENER_PROPERTY_ID, const void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsSetMessageProperty(WS_MESSAGE*, WS_MESSAGE_PROPERTY_ID, const void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsSetOutput(WS_XML_WRITER*, const WS_XML_WRITER_ENCODING*, const WS_XML_WRITER_OUTPUT*, |
| const WS_XML_WRITER_PROPERTY*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsSetOutputToBuffer(WS_XML_WRITER*, WS_XML_BUFFER*, const WS_XML_WRITER_PROPERTY*, |
| ULONG, WS_ERROR*); |
| HRESULT WINAPI WsSetReaderPosition(WS_XML_READER*, const WS_XML_NODE_POSITION*, WS_ERROR*); |
| HRESULT WINAPI WsSetWriterPosition(WS_XML_WRITER*, const WS_XML_NODE_POSITION*, WS_ERROR*); |
| HRESULT WINAPI WsShutdownSessionChannel(WS_CHANNEL*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsSkipNode(WS_XML_READER*, WS_ERROR*); |
| HRESULT WINAPI WsWriteArray(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*, WS_VALUE_TYPE, |
| const void*, ULONG, ULONG, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsWriteAttribute(WS_XML_WRITER*, const WS_ATTRIBUTE_DESCRIPTION*, WS_WRITE_OPTION, |
| const void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsWriteBody(WS_MESSAGE*, const WS_ELEMENT_DESCRIPTION*, WS_WRITE_OPTION, const void*, |
| ULONG, WS_ERROR*); |
| HRESULT WINAPI WsWriteBytes(WS_XML_WRITER*, const void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsWriteChars(WS_XML_WRITER*, const WCHAR*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsWriteCharsUtf8(WS_XML_WRITER*, const BYTE*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsWriteElement(WS_XML_WRITER*, const WS_ELEMENT_DESCRIPTION*, WS_WRITE_OPTION, |
| const void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsWriteEndAttribute(WS_XML_WRITER*, WS_ERROR*); |
| HRESULT WINAPI WsWriteEndCData(WS_XML_WRITER*, WS_ERROR*); |
| HRESULT WINAPI WsWriteEndElement(WS_XML_WRITER*, WS_ERROR*); |
| HRESULT WINAPI WsWriteEndStartElement(WS_XML_WRITER*, WS_ERROR*); |
| HRESULT WINAPI WsWriteEnvelopeEnd(WS_MESSAGE*, WS_ERROR*); |
| HRESULT WINAPI WsWriteEnvelopeStart(WS_MESSAGE*, WS_XML_WRITER*, WS_MESSAGE_DONE_CALLBACK, void*, WS_ERROR*); |
| HRESULT WINAPI WsWriteMessageStart(WS_CHANNEL*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsWriteMessageEnd(WS_CHANNEL*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*); |
| HRESULT WINAPI WsWriteNode(WS_XML_WRITER*, const WS_XML_NODE*, WS_ERROR*); |
| HRESULT WINAPI WsWriteQualifiedName(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*, |
| const WS_XML_STRING*, WS_ERROR*); |
| HRESULT WINAPI WsWriteStartAttribute(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*, |
| const WS_XML_STRING*, WINBOOL, WS_ERROR*); |
| HRESULT WINAPI WsWriteStartCData(WS_XML_WRITER*, WS_ERROR*); |
| HRESULT WINAPI WsWriteStartElement(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*, |
| const WS_XML_STRING*, WS_ERROR*); |
| HRESULT WINAPI WsWriteText(WS_XML_WRITER*, const WS_XML_TEXT*, WS_ERROR*); |
| HRESULT WINAPI WsWriteType(WS_XML_WRITER*, WS_TYPE_MAPPING, WS_TYPE, const void*, WS_WRITE_OPTION, |
| const void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsWriteValue(WS_XML_WRITER*, WS_VALUE_TYPE, const void*, ULONG, WS_ERROR*); |
| HRESULT WINAPI WsWriteXmlBuffer(WS_XML_WRITER*, WS_XML_BUFFER*, WS_ERROR*); |
| HRESULT WINAPI WsWriteXmlBufferToBytes(WS_XML_WRITER*, WS_XML_BUFFER*, const WS_XML_WRITER_ENCODING*, |
| const WS_XML_WRITER_PROPERTY*, ULONG, WS_HEAP*, void**, |
| ULONG*, WS_ERROR*); |
| HRESULT WINAPI WsWriteXmlnsAttribute(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*, |
| WINBOOL, WS_ERROR*); |
| HRESULT WINAPI WsXmlStringEquals(const WS_XML_STRING*, const WS_XML_STRING*, WS_ERROR*); |
| |
| #ifndef FACILITY_WEBSERVICES |
| #define FACILITY_WEBSERVICES 61 |
| #define WS_S_ASYNC 0x003d0000 |
| #define WS_S_END 0x003d0001 |
| #define WS_E_INVALID_FORMAT 0x803d0000 |
| #define WS_E_OBJECT_FAULTED 0x803d0001 |
| #define WS_E_NUMERIC_OVERFLOW 0x803d0002 |
| #define WS_E_INVALID_OPERATION 0x803d0003 |
| #define WS_E_OPERATION_ABORTED 0x803d0004 |
| #define WS_E_ENDPOINT_ACCESS_DENIED 0x803d0005 |
| #define WS_E_OPERATION_TIMED_OUT 0x803d0006 |
| #define WS_E_OPERATION_ABANDONED 0x803d0007 |
| #define WS_E_QUOTA_EXCEEDED 0x803d0008 |
| #define WS_E_NO_TRANSLATION_AVAILABLE 0x803d0009 |
| #define WS_E_SECURITY_VERIFICATION_FAILURE 0x803d000a |
| #define WS_E_ADDRESS_IN_USE 0x803d000b |
| #define WS_E_ADDRESS_NOT_AVAILABLE 0x803d000c |
| #define WS_E_ENDPOINT_NOT_FOUND 0x803d000d |
| #define WS_E_ENDPOINT_NOT_AVAILABLE 0x803d000e |
| #define WS_E_ENDPOINT_FAILURE 0x803d000f |
| #define WS_E_ENDPOINT_UNREACHABLE 0x803d0010 |
| #define WS_E_ENDPOINT_ACTION_NOT_SUPPORTED 0x803d0011 |
| #define WS_E_ENDPOINT_TOO_BUSY 0x803d0012 |
| #define WS_E_ENDPOINT_FAULT_RECEIVED 0x803d0013 |
| #define WS_E_ENDPOINT_DISCONNECTED 0x803d0014 |
| #define WS_E_PROXY_FAILURE 0x803d0015 |
| #define WS_E_PROXY_ACCESS_DENIED 0x803d0016 |
| #define WS_E_NOT_SUPPORTED 0x803d0017 |
| #define WS_E_PROXY_REQUIRES_BASIC_AUTH 0x803d0018 |
| #define WS_E_PROXY_REQUIRES_DIGEST_AUTH 0x803d0019 |
| #define WS_E_PROXY_REQUIRES_NTLM_AUTH 0x803d001a |
| #define WS_E_PROXY_REQUIRES_NEGOTIATE_AUTH 0x803d001b |
| #define WS_E_SERVER_REQUIRES_BASIC_AUTH 0x803d001c |
| #define WS_E_SERVER_REQUIRES_DIGEST_AUTH 0x803d001d |
| #define WS_E_SERVER_REQUIRES_NTLM_AUTH 0x803d001e |
| #define WS_E_SERVER_REQUIRES_NEGOTIATE_AUTH 0x803d001f |
| #define WS_E_INVALID_ENDPOINT_URL 0x803d0020 |
| #define WS_E_OTHER 0x803d0021 |
| #define WS_E_SECURITY_TOKEN_EXPIRED 0x803d0022 |
| #define WS_E_SECURITY_SYSTEM_FAILURE 0x803d0023 |
| #endif |
| |
| #define WS_STRING_VALUE(s) { sizeof(s) / sizeof((s)[0]) - 1, (WCHAR *)(s) } |
| #define WS_XML_STRING_VALUE(s) { sizeof(s) - 1, (BYTE *)(s) } |
| |
| #ifdef __cplusplus |
| } |
| #endif /* __cplusplus */ |
| |
| #endif /* __WINE_WEBSERVICES_H */ |
