headers: Import webservices.h and weakreference.idl from Wine. Signed-off-by: Jacek Caban <jacek@codeweavers.com>
diff --git a/mingw-w64-headers/Makefile.am b/mingw-w64-headers/Makefile.am index 889e245..7132c27 100644 --- a/mingw-w64-headers/Makefile.am +++ b/mingw-w64-headers/Makefile.am
@@ -264,6 +264,7 @@ include/robuffer.idl \ include/rtworkq.idl \ include/vmr9.idl \ + include/weakreference.idl \ include/wincodec.idl \ include/wincodecsdk.idl \ include/wmcontainer.idl \
diff --git a/mingw-w64-headers/Makefile.in b/mingw-w64-headers/Makefile.in index 7c89911..46e8fe8 100644 --- a/mingw-w64-headers/Makefile.in +++ b/mingw-w64-headers/Makefile.in
@@ -566,6 +566,7 @@ @HAVE_WIDL_TRUE@ include/robuffer.idl \ @HAVE_WIDL_TRUE@ include/rtworkq.idl \ @HAVE_WIDL_TRUE@ include/vmr9.idl \ +@HAVE_WIDL_TRUE@ include/weakreference.idl \ @HAVE_WIDL_TRUE@ include/wincodec.idl \ @HAVE_WIDL_TRUE@ include/wincodecsdk.idl \ @HAVE_WIDL_TRUE@ include/wmcontainer.idl \
diff --git a/mingw-w64-headers/include/weakreference.h b/mingw-w64-headers/include/weakreference.h new file mode 100644 index 0000000..78ebfc1 --- /dev/null +++ b/mingw-w64-headers/include/weakreference.h
@@ -0,0 +1,218 @@ +/*** Autogenerated by WIDL 9.11 from include/weakreference.idl - Do not edit ***/ + +#ifdef _WIN32 +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 475 +#endif +#include <rpc.h> +#include <rpcndr.h> +#endif + +#ifndef COM_NO_WINDOWS_H +#include <windows.h> +#include <ole2.h> +#endif + +#ifndef __weakreference_h__ +#define __weakreference_h__ + +#ifndef __WIDL_INLINE +#if defined(__cplusplus) || defined(_MSC_VER) +#define __WIDL_INLINE inline +#elif defined(__GNUC__) +#define __WIDL_INLINE __inline__ +#endif +#endif + +/* Forward declarations */ + +#ifndef __IWeakReference_FWD_DEFINED__ +#define __IWeakReference_FWD_DEFINED__ +typedef interface IWeakReference IWeakReference; +#ifdef __cplusplus +interface IWeakReference; +#endif /* __cplusplus */ +#endif + +#ifndef __IWeakReferenceSource_FWD_DEFINED__ +#define __IWeakReferenceSource_FWD_DEFINED__ +typedef interface IWeakReferenceSource IWeakReferenceSource; +#ifdef __cplusplus +interface IWeakReferenceSource; +#endif /* __cplusplus */ +#endif + +/* Headers for imported files */ + +#include <inspectable.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/***************************************************************************** + * IWeakReference interface + */ +#ifndef __IWeakReference_INTERFACE_DEFINED__ +#define __IWeakReference_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IWeakReference, 0x00000037, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +MIDL_INTERFACE("00000037-0000-0000-c000-000000000046") +IWeakReference : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Resolve( + REFIID iid, + IInspectable **ref) = 0; + +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IWeakReference, 0x00000037, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46) +#endif +#else +typedef struct IWeakReferenceVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IWeakReference *This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IWeakReference *This); + + ULONG (STDMETHODCALLTYPE *Release)( + IWeakReference *This); + + /*** IWeakReference methods ***/ + HRESULT (STDMETHODCALLTYPE *Resolve)( + IWeakReference *This, + REFIID iid, + IInspectable **ref); + + END_INTERFACE +} IWeakReferenceVtbl; + +interface IWeakReference { + CONST_VTBL IWeakReferenceVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +#ifndef WIDL_C_INLINE_WRAPPERS +/*** IUnknown methods ***/ +#define IWeakReference_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IWeakReference_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IWeakReference_Release(This) (This)->lpVtbl->Release(This) +/*** IWeakReference methods ***/ +#define IWeakReference_Resolve(This,iid,ref) (This)->lpVtbl->Resolve(This,iid,ref) +#else +/*** IUnknown methods ***/ +static __WIDL_INLINE HRESULT IWeakReference_QueryInterface(IWeakReference* This,REFIID riid,void **ppvObject) { + return This->lpVtbl->QueryInterface(This,riid,ppvObject); +} +static __WIDL_INLINE ULONG IWeakReference_AddRef(IWeakReference* This) { + return This->lpVtbl->AddRef(This); +} +static __WIDL_INLINE ULONG IWeakReference_Release(IWeakReference* This) { + return This->lpVtbl->Release(This); +} +/*** IWeakReference methods ***/ +static __WIDL_INLINE HRESULT IWeakReference_Resolve(IWeakReference* This,REFIID iid,IInspectable **ref) { + return This->lpVtbl->Resolve(This,iid,ref); +} +#endif +#endif + +#endif + + +#endif /* __IWeakReference_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IWeakReferenceSource interface + */ +#ifndef __IWeakReferenceSource_INTERFACE_DEFINED__ +#define __IWeakReferenceSource_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IWeakReferenceSource, 0x00000038, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +MIDL_INTERFACE("00000038-0000-0000-c000-000000000046") +IWeakReferenceSource : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetWeakReference( + IWeakReference **ref) = 0; + +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IWeakReferenceSource, 0x00000038, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46) +#endif +#else +typedef struct IWeakReferenceSourceVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IWeakReferenceSource *This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IWeakReferenceSource *This); + + ULONG (STDMETHODCALLTYPE *Release)( + IWeakReferenceSource *This); + + /*** IWeakReferenceSource methods ***/ + HRESULT (STDMETHODCALLTYPE *GetWeakReference)( + IWeakReferenceSource *This, + IWeakReference **ref); + + END_INTERFACE +} IWeakReferenceSourceVtbl; + +interface IWeakReferenceSource { + CONST_VTBL IWeakReferenceSourceVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +#ifndef WIDL_C_INLINE_WRAPPERS +/*** IUnknown methods ***/ +#define IWeakReferenceSource_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IWeakReferenceSource_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IWeakReferenceSource_Release(This) (This)->lpVtbl->Release(This) +/*** IWeakReferenceSource methods ***/ +#define IWeakReferenceSource_GetWeakReference(This,ref) (This)->lpVtbl->GetWeakReference(This,ref) +#else +/*** IUnknown methods ***/ +static __WIDL_INLINE HRESULT IWeakReferenceSource_QueryInterface(IWeakReferenceSource* This,REFIID riid,void **ppvObject) { + return This->lpVtbl->QueryInterface(This,riid,ppvObject); +} +static __WIDL_INLINE ULONG IWeakReferenceSource_AddRef(IWeakReferenceSource* This) { + return This->lpVtbl->AddRef(This); +} +static __WIDL_INLINE ULONG IWeakReferenceSource_Release(IWeakReferenceSource* This) { + return This->lpVtbl->Release(This); +} +/*** IWeakReferenceSource methods ***/ +static __WIDL_INLINE HRESULT IWeakReferenceSource_GetWeakReference(IWeakReferenceSource* This,IWeakReference **ref) { + return This->lpVtbl->GetWeakReference(This,ref); +} +#endif +#endif + +#endif + + +#endif /* __IWeakReferenceSource_INTERFACE_DEFINED__ */ + +/* Begin additional prototypes for all interfaces */ + + +/* End additional prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif /* __weakreference_h__ */
diff --git a/mingw-w64-headers/include/weakreference.idl b/mingw-w64-headers/include/weakreference.idl new file mode 100644 index 0000000..fb5b95b --- /dev/null +++ b/mingw-w64-headers/include/weakreference.idl
@@ -0,0 +1,39 @@ +/* + * Copyright 2022 Rémi Bernon 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 + */ + +import "inspectable.idl"; + +[ + object, + uuid(00000037-0000-0000-c000-000000000046), + pointer_default(unique) +] +interface IWeakReference : IUnknown +{ + HRESULT Resolve([in] REFIID iid, [out, retval, iid_is(iid)] IInspectable **ref); +} + +[ + object, + uuid(00000038-0000-0000-c000-000000000046), + pointer_default(unique) +] +interface IWeakReferenceSource : IUnknown +{ + HRESULT GetWeakReference([out, retval] IWeakReference **ref); +}
diff --git a/mingw-w64-headers/include/webservices.h b/mingw-w64-headers/include/webservices.h new file mode 100644 index 0000000..efd8e8a --- /dev/null +++ b/mingw-w64-headers/include/webservices.h
@@ -0,0 +1,1892 @@ +/* + * 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 */
diff --git a/mingw-w64-headers/wine-import.sh b/mingw-w64-headers/wine-import.sh index 86a4889..10dc7c6 100755 --- a/mingw-w64-headers/wine-import.sh +++ b/mingw-w64-headers/wine-import.sh
@@ -120,6 +120,7 @@ uiautomationcoreapi.h \ uiautomation.h \ vfwmsgs.h \ + webservices.h \ winhttp.h \ winineti.h \ wmpids.h \ @@ -218,6 +219,7 @@ uiautomationcore \ urlhist \ vmr9 \ + weakreference \ wincodec \ wincodecsdk \ windowscontracts \