2 * Copyright 2016 Hans Leidekker for CodeWeavers
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #include "webservices.h"
27 #include "wine/debug.h"
28 #include "wine/list.h"
29 #include "webservices_private.h"
31 WINE_DEFAULT_DEBUG_CHANNEL(webservices
);
33 static const char ns_env_1_1
[] = "http://schemas.xmlsoap.org/soap/envelope/";
34 static const char ns_env_1_2
[] = "http://www.w3.org/2003/05/soap-envelope";
35 static const char ns_addr_0_9
[] = "http://schemas.xmlsoap.org/ws/2004/08/addressing";
36 static const char ns_addr_1_0
[] = "http://www.w3.org/2005/08/addressing";
38 static const struct prop_desc msg_props
[] =
40 { sizeof(WS_MESSAGE_STATE
), TRUE
}, /* WS_MESSAGE_PROPERTY_STATE */
41 { sizeof(WS_HEAP
*), TRUE
}, /* WS_MESSAGE_PROPERTY_HEAP */
42 { sizeof(WS_ENVELOPE_VERSION
), TRUE
}, /* WS_MESSAGE_PROPERTY_ENVELOPE_VERSION */
43 { sizeof(WS_ADDRESSING_VERSION
), TRUE
}, /* WS_MESSAGE_PROPERTY_ADDRESSING_VERSION */
44 { sizeof(WS_XML_BUFFER
*), TRUE
}, /* WS_MESSAGE_PROPERTY_HEADER_BUFFER */
45 { sizeof(WS_XML_NODE_POSITION
*), TRUE
}, /* WS_MESSAGE_PROPERTY_HEADER_POSITION */
46 { sizeof(WS_XML_READER
*), TRUE
}, /* WS_MESSAGE_PROPERTY_BODY_READER */
47 { sizeof(WS_XML_WRITER
*), TRUE
}, /* WS_MESSAGE_PROPERTY_BODY_WRITER */
48 { sizeof(BOOL
), TRUE
}, /* WS_MESSAGE_PROPERTY_IS_ADDRESSED */
53 WS_MESSAGE_INITIALIZATION init
;
54 WS_MESSAGE_STATE state
;
56 WS_ENVELOPE_VERSION version_env
;
57 WS_ADDRESSING_VERSION version_addr
;
62 WS_XML_WRITER
*writer
;
63 WS_XML_WRITER
*writer_body
;
65 struct prop prop
[sizeof(msg_props
)/sizeof(msg_props
[0])];
68 static struct msg
*alloc_msg(void)
70 static const ULONG count
= sizeof(msg_props
)/sizeof(msg_props
[0]);
72 ULONG size
= sizeof(*ret
) + prop_size( msg_props
, count
);
74 if (!(ret
= heap_alloc_zero( size
))) return NULL
;
75 ret
->state
= WS_MESSAGE_STATE_EMPTY
;
76 prop_init( msg_props
, count
, ret
->prop
, &ret
[1] );
77 ret
->prop_count
= count
;
81 static void free_msg( struct msg
*msg
)
84 WsFreeWriter( msg
->writer
);
85 WsFreeHeap( msg
->heap
);
86 heap_free( msg
->addr
.chars
);
90 #define HEAP_MAX_SIZE (1 << 16)
92 static HRESULT
create_msg( WS_ENVELOPE_VERSION env_version
, WS_ADDRESSING_VERSION addr_version
,
93 const WS_MESSAGE_PROPERTY
*properties
, ULONG count
, WS_MESSAGE
**handle
)
99 if (!(msg
= alloc_msg())) return E_OUTOFMEMORY
;
101 for (i
= 0; i
< count
; i
++)
103 if (properties
[i
].id
== WS_MESSAGE_PROPERTY_ENVELOPE_VERSION
||
104 properties
[i
].id
== WS_MESSAGE_PROPERTY_ADDRESSING_VERSION
)
109 hr
= prop_set( msg
->prop
, msg
->prop_count
, properties
[i
].id
, properties
[i
].value
,
110 properties
[i
].valueSize
);
118 if ((hr
= WsCreateHeap( HEAP_MAX_SIZE
, 0, NULL
, 0, &msg
->heap
, NULL
)) != S_OK
)
123 if ((hr
= WsCreateXmlBuffer( msg
->heap
, NULL
, 0, &msg
->buf
, NULL
)) != S_OK
)
129 UuidCreate( &msg
->id
);
130 msg
->version_env
= env_version
;
131 msg
->version_addr
= addr_version
;
133 *handle
= (WS_MESSAGE
*)msg
;
137 /**************************************************************************
138 * WsCreateMessage [webservices.@]
140 HRESULT WINAPI
WsCreateMessage( WS_ENVELOPE_VERSION env_version
, WS_ADDRESSING_VERSION addr_version
,
141 const WS_MESSAGE_PROPERTY
*properties
, ULONG count
, WS_MESSAGE
**handle
,
144 TRACE( "%u %u %p %u %p %p\n", env_version
, addr_version
, properties
, count
, handle
, error
);
145 if (error
) FIXME( "ignoring error parameter\n" );
147 if (!handle
|| !env_version
|| !addr_version
) return E_INVALIDARG
;
148 return create_msg( env_version
, addr_version
, properties
, count
, handle
);
151 /**************************************************************************
152 * WsCreateMessageForChannel [webservices.@]
154 HRESULT WINAPI
WsCreateMessageForChannel( WS_CHANNEL
*channel_handle
, const WS_MESSAGE_PROPERTY
*properties
,
155 ULONG count
, WS_MESSAGE
**handle
, WS_ERROR
*error
)
157 WS_ENVELOPE_VERSION version_env
;
158 WS_ADDRESSING_VERSION version_addr
;
161 TRACE( "%p %p %u %p %p\n", channel_handle
, properties
, count
, handle
, error
);
162 if (error
) FIXME( "ignoring error parameter\n" );
164 if (!channel_handle
|| !handle
) return E_INVALIDARG
;
166 if ((hr
= WsGetChannelProperty( channel_handle
, WS_CHANNEL_PROPERTY_ENVELOPE_VERSION
, &version_env
,
167 sizeof(version_env
), NULL
)) != S_OK
|| !version_env
)
168 version_env
= WS_ENVELOPE_VERSION_SOAP_1_2
;
170 if ((hr
= WsGetChannelProperty( channel_handle
, WS_CHANNEL_PROPERTY_ADDRESSING_VERSION
, &version_addr
,
171 sizeof(version_addr
), NULL
)) != S_OK
|| !version_addr
)
172 version_addr
= WS_ADDRESSING_VERSION_1_0
;
174 return create_msg( version_env
, version_addr
, properties
, count
, handle
);
177 /**************************************************************************
178 * WsInitializeMessage [webservices.@]
180 HRESULT WINAPI
WsInitializeMessage( WS_MESSAGE
*handle
, WS_MESSAGE_INITIALIZATION init
,
181 WS_MESSAGE
*src_handle
, WS_ERROR
*error
)
183 struct msg
*msg
= (struct msg
*)handle
;
185 TRACE( "%p %u %p %p\n", handle
, init
, src_handle
, error
);
186 if (error
) FIXME( "ignoring error parameter\n" );
189 FIXME( "src message not supported\n" );
193 if (!handle
|| init
> WS_FAULT_MESSAGE
) return E_INVALIDARG
;
194 if (msg
->state
>= WS_MESSAGE_STATE_INITIALIZED
) return WS_E_INVALID_OPERATION
;
197 msg
->state
= WS_MESSAGE_STATE_INITIALIZED
;
201 /**************************************************************************
202 * WsFreeMessage [webservices.@]
204 void WINAPI
WsFreeMessage( WS_MESSAGE
*handle
)
206 struct msg
*msg
= (struct msg
*)handle
;
208 TRACE( "%p\n", handle
);
212 /**************************************************************************
213 * WsGetMessageProperty [webservices.@]
215 HRESULT WINAPI
WsGetMessageProperty( WS_MESSAGE
*handle
, WS_MESSAGE_PROPERTY_ID id
, void *buf
,
216 ULONG size
, WS_ERROR
*error
)
218 struct msg
*msg
= (struct msg
*)handle
;
220 TRACE( "%p %u %p %u %p\n", handle
, id
, buf
, size
, error
);
221 if (error
) FIXME( "ignoring error parameter\n" );
223 if (!handle
) return E_INVALIDARG
;
227 case WS_MESSAGE_PROPERTY_STATE
:
228 if (!buf
|| size
!= sizeof(msg
->state
)) return E_INVALIDARG
;
229 *(WS_MESSAGE_STATE
*)buf
= msg
->state
;
232 case WS_MESSAGE_PROPERTY_HEAP
:
233 if (!buf
|| size
!= sizeof(msg
->heap
)) return E_INVALIDARG
;
234 *(WS_HEAP
**)buf
= msg
->heap
;
237 case WS_MESSAGE_PROPERTY_ENVELOPE_VERSION
:
238 if (!buf
|| size
!= sizeof(msg
->version_env
)) return E_INVALIDARG
;
239 *(WS_ENVELOPE_VERSION
*)buf
= msg
->version_env
;
242 case WS_MESSAGE_PROPERTY_ADDRESSING_VERSION
:
243 if (!buf
|| size
!= sizeof(msg
->version_addr
)) return E_INVALIDARG
;
244 *(WS_ADDRESSING_VERSION
*)buf
= msg
->version_addr
;
247 case WS_MESSAGE_PROPERTY_HEADER_BUFFER
:
248 if (!buf
|| size
!= sizeof(msg
->buf
)) return E_INVALIDARG
;
249 *(WS_XML_BUFFER
**)buf
= msg
->buf
;
252 case WS_MESSAGE_PROPERTY_IS_ADDRESSED
:
253 if (msg
->state
< WS_MESSAGE_STATE_INITIALIZED
) return WS_E_INVALID_OPERATION
;
254 *(BOOL
*)buf
= msg
->is_addressed
;
258 return prop_get( msg
->prop
, msg
->prop_count
, id
, buf
, size
);
262 /**************************************************************************
263 * WsSetMessageProperty [webservices.@]
265 HRESULT WINAPI
WsSetMessageProperty( WS_MESSAGE
*handle
, WS_MESSAGE_PROPERTY_ID id
, const void *value
,
266 ULONG size
, WS_ERROR
*error
)
268 struct msg
*msg
= (struct msg
*)handle
;
270 TRACE( "%p %u %p %u\n", handle
, id
, value
, size
);
271 if (error
) FIXME( "ignoring error parameter\n" );
273 if (!handle
) return E_INVALIDARG
;
277 case WS_MESSAGE_PROPERTY_STATE
:
278 case WS_MESSAGE_PROPERTY_ENVELOPE_VERSION
:
279 case WS_MESSAGE_PROPERTY_ADDRESSING_VERSION
:
280 case WS_MESSAGE_PROPERTY_IS_ADDRESSED
:
281 if (msg
->state
< WS_MESSAGE_STATE_INITIALIZED
) return WS_E_INVALID_OPERATION
;
287 return prop_set( msg
->prop
, msg
->prop_count
, id
, value
, size
);
290 /**************************************************************************
291 * WsAddressMessage [webservices.@]
293 HRESULT WINAPI
WsAddressMessage( WS_MESSAGE
*handle
, const WS_ENDPOINT_ADDRESS
*addr
, WS_ERROR
*error
)
295 struct msg
*msg
= (struct msg
*)handle
;
297 TRACE( "%p %p %p\n", handle
, addr
, error
);
298 if (error
) FIXME( "ignoring error parameter\n" );
299 if (addr
&& (addr
->headers
|| addr
->extensions
|| addr
->identity
))
301 FIXME( "headers, extensions or identity not supported\n" );
305 if (!handle
) return E_INVALIDARG
;
306 if (msg
->state
< WS_MESSAGE_STATE_INITIALIZED
|| msg
->is_addressed
) return WS_E_INVALID_OPERATION
;
308 if (addr
&& addr
->url
.length
)
310 if (!(msg
->addr
.chars
= heap_alloc( addr
->url
.length
* sizeof(WCHAR
) ))) return E_OUTOFMEMORY
;
311 memcpy( msg
->addr
.chars
, addr
->url
.chars
, addr
->url
.length
* sizeof(WCHAR
) );
312 msg
->addr
.length
= addr
->url
.length
;
315 msg
->is_addressed
= TRUE
;
319 static HRESULT
get_env_namespace( WS_ENVELOPE_VERSION ver
, WS_XML_STRING
*str
)
323 case WS_ENVELOPE_VERSION_SOAP_1_1
:
324 str
->bytes
= (BYTE
*)ns_env_1_1
;
325 str
->length
= sizeof(ns_env_1_1
)/sizeof(ns_env_1_1
[0]) - 1;
328 case WS_ENVELOPE_VERSION_SOAP_1_2
:
329 str
->bytes
= (BYTE
*)ns_env_1_2
;
330 str
->length
= sizeof(ns_env_1_2
)/sizeof(ns_env_1_2
[0]) - 1;
334 ERR( "unhandled envelope version %u\n", ver
);
339 static HRESULT
get_addr_namespace( WS_ADDRESSING_VERSION ver
, WS_XML_STRING
*str
)
343 case WS_ADDRESSING_VERSION_0_9
:
344 str
->bytes
= (BYTE
*)ns_addr_0_9
;
345 str
->length
= sizeof(ns_addr_0_9
)/sizeof(ns_addr_0_9
[0]) - 1;
348 case WS_ADDRESSING_VERSION_1_0
:
349 str
->bytes
= (BYTE
*)ns_addr_1_0
;
350 str
->length
= sizeof(ns_addr_1_0
)/sizeof(ns_addr_1_0
[0]) - 1;
354 ERR( "unhandled addressing version %u\n", ver
);
359 static HRESULT
write_envelope_start( struct msg
*msg
, WS_XML_WRITER
*writer
)
361 static const char anonymous
[] = "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous";
362 WS_XML_STRING prefix_s
= {1, (BYTE
*)"s"}, prefix_a
= {1, (BYTE
*)"a"}, body
= {4, (BYTE
*)"Body"};
363 WS_XML_STRING envelope
= {8, (BYTE
*)"Envelope"}, header
= {6, (BYTE
*)"Header"};
364 WS_XML_STRING msgid
= {9, (BYTE
*)"MessageID"}, replyto
= {7, (BYTE
*)"ReplyTo"};
365 WS_XML_STRING address
= {7, (BYTE
*)"Address"}, ns_env
, ns_addr
;
366 WS_XML_UTF8_TEXT urn
, addr
;
369 if ((hr
= get_env_namespace( msg
->version_env
, &ns_env
)) != S_OK
) return hr
;
370 if ((hr
= get_addr_namespace( msg
->version_addr
, &ns_addr
)) != S_OK
) return hr
;
372 if ((hr
= WsWriteStartElement( writer
, &prefix_s
, &envelope
, &ns_env
, NULL
)) != S_OK
) return hr
;
373 if ((hr
= WsWriteXmlnsAttribute( writer
, &prefix_a
, &ns_addr
, FALSE
, NULL
)) != S_OK
) return hr
;
374 if ((hr
= WsWriteStartElement( writer
, &prefix_s
, &header
, &ns_env
, NULL
)) != S_OK
) return hr
;
375 if ((hr
= WsWriteStartElement( writer
, &prefix_a
, &msgid
, &ns_addr
, NULL
)) != S_OK
) return hr
;
377 urn
.text
.textType
= WS_XML_TEXT_TYPE_UNIQUE_ID
;
378 memcpy( &urn
.value
, &msg
->id
, sizeof(msg
->id
) );
379 if ((hr
= WsWriteText( writer
, &urn
.text
, NULL
)) != S_OK
) return hr
;
381 if ((hr
= WsWriteEndElement( writer
, NULL
)) != S_OK
) return hr
; /* </a:MessageID> */
382 if (msg
->version_addr
== WS_ADDRESSING_VERSION_0_9
)
384 if ((hr
= WsWriteStartElement( writer
, &prefix_a
, &replyto
, &ns_addr
, NULL
)) != S_OK
) return hr
;
385 if ((hr
= WsWriteStartElement( writer
, &prefix_a
, &address
, &ns_addr
, NULL
)) != S_OK
) return hr
;
387 addr
.text
.textType
= WS_XML_TEXT_TYPE_UTF8
;
388 addr
.value
.bytes
= (BYTE
*)anonymous
;
389 addr
.value
.length
= sizeof(anonymous
) - 1;
390 if ((hr
= WsWriteText( writer
, &addr
.text
, NULL
)) != S_OK
) return hr
;
391 if ((hr
= WsWriteEndElement( writer
, NULL
)) != S_OK
) return hr
; /* </a:Address> */
392 if ((hr
= WsWriteEndElement( writer
, NULL
)) != S_OK
) return hr
; /* </a:ReplyTo> */
395 if ((hr
= WsWriteEndElement( writer
, NULL
)) != S_OK
) return hr
; /* </s:Header> */
396 return WsWriteStartElement( writer
, &prefix_s
, &body
, &ns_env
, NULL
); /* <s:Body> */
399 static HRESULT
write_envelope_end( struct msg
*msg
, WS_XML_WRITER
*writer
)
402 if ((hr
= WsWriteEndElement( writer
, NULL
)) != S_OK
) return hr
; /* </s:Body> */
403 return WsWriteEndElement( writer
, NULL
); /* </s:Envelope> */
406 /**************************************************************************
407 * WsWriteEnvelopeStart [webservices.@]
409 HRESULT WINAPI
WsWriteEnvelopeStart( WS_MESSAGE
*handle
, WS_XML_WRITER
*writer
,
410 WS_MESSAGE_DONE_CALLBACK cb
, void *state
, WS_ERROR
*error
)
412 struct msg
*msg
= (struct msg
*)handle
;
415 TRACE( "%p %p %p %p %p\n", handle
, writer
, cb
, state
, error
);
416 if (error
) FIXME( "ignoring error parameter\n" );
419 FIXME( "callback not supported\n" );
423 if (!handle
) return E_INVALIDARG
;
424 if (msg
->state
!= WS_MESSAGE_STATE_INITIALIZED
) return WS_E_INVALID_OPERATION
;
426 if ((hr
= WsCreateWriter( NULL
, 0, &msg
->writer
, NULL
)) != S_OK
) return hr
;
427 if ((hr
= WsSetOutputToBuffer( msg
->writer
, msg
->buf
, NULL
, 0, NULL
)) != S_OK
) return hr
;
428 if ((hr
= write_envelope_start( msg
, msg
->writer
)) != S_OK
) return hr
;
429 if ((hr
= write_envelope_start( msg
, writer
)) != S_OK
) return hr
;
430 if ((hr
= write_envelope_end( msg
, msg
->writer
)) != S_OK
) return hr
;
432 msg
->writer_body
= writer
;
433 msg
->state
= WS_MESSAGE_STATE_WRITING
;
437 /**************************************************************************
438 * WsWriteEnvelopeEnd [webservices.@]
440 HRESULT WINAPI
WsWriteEnvelopeEnd( WS_MESSAGE
*handle
, WS_ERROR
*error
)
442 struct msg
*msg
= (struct msg
*)handle
;
445 TRACE( "%p %p\n", handle
, error
);
446 if (error
) FIXME( "ignoring error parameter\n" );
448 if (!handle
) return E_INVALIDARG
;
449 if (msg
->state
!= WS_MESSAGE_STATE_WRITING
) return WS_E_INVALID_OPERATION
;
451 if ((hr
= write_envelope_end( msg
, msg
->writer_body
)) != S_OK
) return hr
;
453 msg
->state
= WS_MESSAGE_STATE_DONE
;
457 /**************************************************************************
458 * WsWriteBody [webservices.@]
460 HRESULT WINAPI
WsWriteBody( WS_MESSAGE
*handle
, const WS_ELEMENT_DESCRIPTION
*desc
, WS_WRITE_OPTION option
,
461 const void *value
, ULONG size
, WS_ERROR
*error
)
463 struct msg
*msg
= (struct msg
*)handle
;
466 TRACE( "%p %p %08x %p %u %p\n", handle
, desc
, option
, value
, size
, error
);
467 if (error
) FIXME( "ignoring error parameter\n" );
469 if (!handle
|| !desc
) return E_INVALIDARG
;
470 if (msg
->state
!= WS_MESSAGE_STATE_WRITING
) return WS_E_INVALID_OPERATION
;
472 if (desc
->elementLocalName
&&
473 (hr
= WsWriteStartElement( msg
->writer_body
, NULL
, desc
->elementLocalName
, desc
->elementNs
,
474 NULL
)) != S_OK
) return hr
;
476 if ((hr
= WsWriteType( msg
->writer_body
, WS_ANY_ELEMENT_TYPE_MAPPING
, desc
->type
, desc
->typeDescription
,
477 option
, value
, size
, NULL
)) != S_OK
) return hr
;
479 if (desc
->elementLocalName
) hr
= WsWriteEndElement( msg
->writer_body
, NULL
);