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/heap.h"
29 #include "wine/list.h"
30 #include "wine/unicode.h"
31 #include "webservices_private.h"
33 WINE_DEFAULT_DEBUG_CHANNEL(webservices
);
35 static const struct prop_desc msg_props
[] =
37 { sizeof(WS_MESSAGE_STATE
), TRUE
}, /* WS_MESSAGE_PROPERTY_STATE */
38 { sizeof(WS_HEAP
*), TRUE
}, /* WS_MESSAGE_PROPERTY_HEAP */
39 { sizeof(WS_ENVELOPE_VERSION
), TRUE
}, /* WS_MESSAGE_PROPERTY_ENVELOPE_VERSION */
40 { sizeof(WS_ADDRESSING_VERSION
), TRUE
}, /* WS_MESSAGE_PROPERTY_ADDRESSING_VERSION */
41 { sizeof(WS_XML_BUFFER
*), TRUE
}, /* WS_MESSAGE_PROPERTY_HEADER_BUFFER */
42 { sizeof(WS_XML_NODE_POSITION
*), TRUE
}, /* WS_MESSAGE_PROPERTY_HEADER_POSITION */
43 { sizeof(WS_XML_READER
*), TRUE
}, /* WS_MESSAGE_PROPERTY_BODY_READER */
44 { sizeof(WS_XML_WRITER
*), TRUE
}, /* WS_MESSAGE_PROPERTY_BODY_WRITER */
45 { sizeof(BOOL
), TRUE
}, /* WS_MESSAGE_PROPERTY_IS_ADDRESSED */
65 WS_MESSAGE_INITIALIZATION init
;
66 WS_MESSAGE_STATE state
;
69 WS_ENVELOPE_VERSION version_env
;
70 WS_ADDRESSING_VERSION version_addr
;
73 WS_XML_STRING
*action
;
76 WS_XML_WRITER
*writer
;
77 WS_XML_WRITER
*writer_body
;
78 WS_XML_READER
*reader
;
79 WS_XML_READER
*reader_body
;
82 struct header
**header
;
83 WS_PROXY_MESSAGE_CALLBACK_CONTEXT ctx_send
;
84 WS_PROXY_MESSAGE_CALLBACK_CONTEXT ctx_receive
;
86 struct prop prop
[ARRAY_SIZE( msg_props
)];
89 #define MSG_MAGIC (('M' << 24) | ('E' << 16) | ('S' << 8) | 'S')
90 #define HEADER_ARRAY_SIZE 2
92 static struct msg
*alloc_msg(void)
94 static const ULONG count
= ARRAY_SIZE( msg_props
);
96 ULONG size
= sizeof(*ret
) + prop_size( msg_props
, count
);
98 if (!(ret
= heap_alloc_zero( size
))) return NULL
;
99 if (!(ret
->header
= heap_alloc( HEADER_ARRAY_SIZE
* sizeof(struct header
*) )))
104 ret
->magic
= MSG_MAGIC
;
105 ret
->state
= WS_MESSAGE_STATE_EMPTY
;
106 ret
->header_size
= HEADER_ARRAY_SIZE
;
108 InitializeCriticalSection( &ret
->cs
);
110 ret
->cs
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": msg.cs");
113 prop_init( msg_props
, count
, ret
->prop
, &ret
[1] );
114 ret
->prop_count
= count
;
118 static void free_header( struct header
*header
)
120 heap_free( header
->name
.bytes
);
121 heap_free( header
->ns
.bytes
);
122 if (header
->mapped
) free_xml_string( header
->u
.text
);
126 static void reset_msg( struct msg
*msg
)
130 msg
->state
= WS_MESSAGE_STATE_EMPTY
;
132 UuidCreate( &msg
->id
);
133 memset( &msg
->id_req
, 0, sizeof(msg
->id_req
) );
134 msg
->is_addressed
= FALSE
;
135 heap_free( msg
->addr
.chars
);
136 msg
->addr
.chars
= NULL
;
137 msg
->addr
.length
= 0;
139 free_xml_string( msg
->action
);
142 WsResetHeap( msg
->heap
, NULL
);
143 msg
->buf
= NULL
; /* allocated on msg->heap */
144 msg
->writer_body
= NULL
; /* owned by caller */
145 msg
->reader_body
= NULL
; /* owned by caller */
147 for (i
= 0; i
< msg
->header_count
; i
++)
149 free_header( msg
->header
[i
] );
150 msg
->header
[i
] = NULL
;
152 msg
->header_count
= 0;
154 memset( &msg
->ctx_send
, 0, sizeof(msg
->ctx_send
) );
155 memset( &msg
->ctx_receive
, 0, sizeof(msg
->ctx_receive
) );
158 static void free_msg( struct msg
*msg
)
162 WsFreeWriter( msg
->writer
);
163 WsFreeReader( msg
->reader
);
164 WsFreeHeap( msg
->heap
);
165 heap_free( msg
->header
);
168 msg
->cs
.DebugInfo
->Spare
[0] = 0;
170 DeleteCriticalSection( &msg
->cs
);
174 #define HEAP_MAX_SIZE (1 << 16)
175 static HRESULT
create_msg( WS_ENVELOPE_VERSION env_version
, WS_ADDRESSING_VERSION addr_version
,
176 const WS_MESSAGE_PROPERTY
*properties
, ULONG count
, WS_MESSAGE
**handle
)
182 if (!(msg
= alloc_msg())) return E_OUTOFMEMORY
;
184 for (i
= 0; i
< count
; i
++)
186 if (properties
[i
].id
== WS_MESSAGE_PROPERTY_ENVELOPE_VERSION
||
187 properties
[i
].id
== WS_MESSAGE_PROPERTY_ADDRESSING_VERSION
)
192 hr
= prop_set( msg
->prop
, msg
->prop_count
, properties
[i
].id
, properties
[i
].value
,
193 properties
[i
].valueSize
);
201 if ((hr
= WsCreateHeap( HEAP_MAX_SIZE
, 0, NULL
, 0, &msg
->heap
, NULL
)) != S_OK
)
207 UuidCreate( &msg
->id
);
208 msg
->version_env
= env_version
;
209 msg
->version_addr
= addr_version
;
211 *handle
= (WS_MESSAGE
*)msg
;
215 /**************************************************************************
216 * WsCreateMessage [webservices.@]
218 HRESULT WINAPI
WsCreateMessage( WS_ENVELOPE_VERSION env_version
, WS_ADDRESSING_VERSION addr_version
,
219 const WS_MESSAGE_PROPERTY
*properties
, ULONG count
, WS_MESSAGE
**handle
,
224 TRACE( "%u %u %p %u %p %p\n", env_version
, addr_version
, properties
, count
, handle
, error
);
225 if (error
) FIXME( "ignoring error parameter\n" );
227 if (!handle
|| !env_version
|| !addr_version
||
228 (env_version
== WS_ENVELOPE_VERSION_NONE
&& addr_version
!= WS_ADDRESSING_VERSION_TRANSPORT
))
233 if ((hr
= create_msg( env_version
, addr_version
, properties
, count
, handle
)) != S_OK
) return hr
;
234 TRACE( "created %p\n", *handle
);
238 /**************************************************************************
239 * WsCreateMessageForChannel [webservices.@]
241 HRESULT WINAPI
WsCreateMessageForChannel( WS_CHANNEL
*channel_handle
, const WS_MESSAGE_PROPERTY
*properties
,
242 ULONG count
, WS_MESSAGE
**handle
, WS_ERROR
*error
)
244 WS_ENVELOPE_VERSION version_env
;
245 WS_ADDRESSING_VERSION version_addr
;
248 TRACE( "%p %p %u %p %p\n", channel_handle
, properties
, count
, handle
, error
);
249 if (error
) FIXME( "ignoring error parameter\n" );
251 if (!channel_handle
|| !handle
) return E_INVALIDARG
;
253 if ((hr
= WsGetChannelProperty( channel_handle
, WS_CHANNEL_PROPERTY_ENVELOPE_VERSION
, &version_env
,
254 sizeof(version_env
), NULL
)) != S_OK
|| !version_env
)
255 version_env
= WS_ENVELOPE_VERSION_SOAP_1_2
;
257 if ((hr
= WsGetChannelProperty( channel_handle
, WS_CHANNEL_PROPERTY_ADDRESSING_VERSION
, &version_addr
,
258 sizeof(version_addr
), NULL
)) != S_OK
|| !version_addr
)
259 version_addr
= WS_ADDRESSING_VERSION_1_0
;
261 if ((hr
= create_msg( version_env
, version_addr
, properties
, count
, handle
)) != S_OK
) return hr
;
262 TRACE( "created %p\n", *handle
);
266 /**************************************************************************
267 * WsFreeMessage [webservices.@]
269 void WINAPI
WsFreeMessage( WS_MESSAGE
*handle
)
271 struct msg
*msg
= (struct msg
*)handle
;
273 TRACE( "%p\n", handle
);
277 EnterCriticalSection( &msg
->cs
);
279 if (msg
->magic
!= MSG_MAGIC
)
281 LeaveCriticalSection( &msg
->cs
);
287 LeaveCriticalSection( &msg
->cs
);
291 /**************************************************************************
292 * WsResetMessage [webservices.@]
294 HRESULT WINAPI
WsResetMessage( WS_MESSAGE
*handle
, WS_ERROR
*error
)
296 struct msg
*msg
= (struct msg
*)handle
;
299 TRACE( "%p %p\n", handle
, error
);
300 if (error
) FIXME( "ignoring error parameter\n" );
302 if (!msg
) return E_INVALIDARG
;
304 EnterCriticalSection( &msg
->cs
);
306 if (msg
->magic
!= MSG_MAGIC
)
308 LeaveCriticalSection( &msg
->cs
);
314 LeaveCriticalSection( &msg
->cs
);
315 TRACE( "returning %08x\n", hr
);
319 /**************************************************************************
320 * WsGetMessageProperty [webservices.@]
322 HRESULT WINAPI
WsGetMessageProperty( WS_MESSAGE
*handle
, WS_MESSAGE_PROPERTY_ID id
, void *buf
,
323 ULONG size
, WS_ERROR
*error
)
325 struct msg
*msg
= (struct msg
*)handle
;
328 TRACE( "%p %u %p %u %p\n", handle
, id
, buf
, size
, error
);
329 if (error
) FIXME( "ignoring error parameter\n" );
331 if (!msg
) return E_INVALIDARG
;
333 EnterCriticalSection( &msg
->cs
);
335 if (msg
->magic
!= MSG_MAGIC
)
337 LeaveCriticalSection( &msg
->cs
);
343 case WS_MESSAGE_PROPERTY_STATE
:
344 if (!buf
|| size
!= sizeof(msg
->state
)) hr
= E_INVALIDARG
;
345 else *(WS_MESSAGE_STATE
*)buf
= msg
->state
;
348 case WS_MESSAGE_PROPERTY_HEAP
:
349 if (!buf
|| size
!= sizeof(msg
->heap
)) hr
= E_INVALIDARG
;
350 else *(WS_HEAP
**)buf
= msg
->heap
;
353 case WS_MESSAGE_PROPERTY_ENVELOPE_VERSION
:
354 if (!buf
|| size
!= sizeof(msg
->version_env
)) hr
= E_INVALIDARG
;
355 else *(WS_ENVELOPE_VERSION
*)buf
= msg
->version_env
;
358 case WS_MESSAGE_PROPERTY_ADDRESSING_VERSION
:
359 if (!buf
|| size
!= sizeof(msg
->version_addr
)) hr
= E_INVALIDARG
;
360 else *(WS_ADDRESSING_VERSION
*)buf
= msg
->version_addr
;
363 case WS_MESSAGE_PROPERTY_HEADER_BUFFER
:
364 if (!buf
|| size
!= sizeof(msg
->buf
)) hr
= E_INVALIDARG
;
365 else *(WS_XML_BUFFER
**)buf
= msg
->buf
;
368 case WS_MESSAGE_PROPERTY_BODY_READER
:
369 if (!buf
|| size
!= sizeof(msg
->reader_body
)) hr
= E_INVALIDARG
;
370 else *(WS_XML_READER
**)buf
= msg
->reader_body
;
373 case WS_MESSAGE_PROPERTY_BODY_WRITER
:
374 if (!buf
|| size
!= sizeof(msg
->writer_body
)) hr
= E_INVALIDARG
;
375 else *(WS_XML_WRITER
**)buf
= msg
->writer_body
;
378 case WS_MESSAGE_PROPERTY_IS_ADDRESSED
:
379 if (msg
->state
< WS_MESSAGE_STATE_INITIALIZED
) hr
= WS_E_INVALID_OPERATION
;
380 else *(BOOL
*)buf
= msg
->is_addressed
;
384 hr
= prop_get( msg
->prop
, msg
->prop_count
, id
, buf
, size
);
387 LeaveCriticalSection( &msg
->cs
);
388 TRACE( "returning %08x\n", hr
);
392 /**************************************************************************
393 * WsSetMessageProperty [webservices.@]
395 HRESULT WINAPI
WsSetMessageProperty( WS_MESSAGE
*handle
, WS_MESSAGE_PROPERTY_ID id
, const void *value
,
396 ULONG size
, WS_ERROR
*error
)
398 struct msg
*msg
= (struct msg
*)handle
;
401 TRACE( "%p %u %p %u\n", handle
, id
, value
, size
);
402 if (error
) FIXME( "ignoring error parameter\n" );
404 if (!msg
) return E_INVALIDARG
;
406 EnterCriticalSection( &msg
->cs
);
408 if (msg
->magic
!= MSG_MAGIC
)
410 LeaveCriticalSection( &msg
->cs
);
416 case WS_MESSAGE_PROPERTY_STATE
:
417 case WS_MESSAGE_PROPERTY_ENVELOPE_VERSION
:
418 case WS_MESSAGE_PROPERTY_ADDRESSING_VERSION
:
419 case WS_MESSAGE_PROPERTY_IS_ADDRESSED
:
420 if (msg
->state
< WS_MESSAGE_STATE_INITIALIZED
) hr
= WS_E_INVALID_OPERATION
;
421 else hr
= E_INVALIDARG
;
425 hr
= prop_set( msg
->prop
, msg
->prop_count
, id
, value
, size
);
428 LeaveCriticalSection( &msg
->cs
);
429 TRACE( "returning %08x\n", hr
);
433 /**************************************************************************
434 * WsAddressMessage [webservices.@]
436 HRESULT WINAPI
WsAddressMessage( WS_MESSAGE
*handle
, const WS_ENDPOINT_ADDRESS
*addr
, WS_ERROR
*error
)
438 struct msg
*msg
= (struct msg
*)handle
;
441 TRACE( "%p %p %p\n", handle
, addr
, error
);
442 if (error
) FIXME( "ignoring error parameter\n" );
443 if (addr
&& (addr
->headers
|| addr
->extensions
|| addr
->identity
))
445 FIXME( "headers, extensions or identity not supported\n" );
449 if (!msg
) return E_INVALIDARG
;
451 EnterCriticalSection( &msg
->cs
);
453 if (msg
->magic
!= MSG_MAGIC
)
455 LeaveCriticalSection( &msg
->cs
);
459 if (msg
->state
< WS_MESSAGE_STATE_INITIALIZED
|| msg
->is_addressed
) hr
= WS_E_INVALID_OPERATION
;
462 if (addr
&& addr
->url
.length
)
464 if (!(msg
->addr
.chars
= heap_alloc( addr
->url
.length
* sizeof(WCHAR
) ))) hr
= E_OUTOFMEMORY
;
467 memcpy( msg
->addr
.chars
, addr
->url
.chars
, addr
->url
.length
* sizeof(WCHAR
) );
468 msg
->addr
.length
= addr
->url
.length
;
472 if (hr
== S_OK
) msg
->is_addressed
= TRUE
;
474 LeaveCriticalSection( &msg
->cs
);
475 TRACE( "returning %08x\n", hr
);
479 static const WS_XML_STRING
*get_env_namespace( WS_ENVELOPE_VERSION version
)
481 static const WS_XML_STRING namespaces
[] =
483 {41, (BYTE
*)"http://schemas.xmlsoap.org/soap/envelope/"},
484 {39, (BYTE
*)"http://www.w3.org/2003/05/soap-envelope"},
488 if (version
< WS_ENVELOPE_VERSION_SOAP_1_1
|| version
> WS_ENVELOPE_VERSION_NONE
)
490 ERR( "unknown version %u\n", version
);
494 return &namespaces
[version
- 1];
497 static const WS_XML_STRING
*get_addr_namespace( WS_ADDRESSING_VERSION version
)
499 static const WS_XML_STRING namespaces
[] =
501 {48, (BYTE
*)"http://schemas.xmlsoap.org/ws/2004/08/addressing"},
502 {36, (BYTE
*)"http://www.w3.org/2005/08/addressing"},
503 {55, (BYTE
*)"http://schemas.microsoft.com/ws/2005/05/addressing/none"},
506 if (version
< WS_ADDRESSING_VERSION_0_9
|| version
> WS_ADDRESSING_VERSION_TRANSPORT
)
508 ERR( "unknown version %u\n", version
);
512 return &namespaces
[version
- 1];
515 static const WS_XML_STRING
*get_header_name( WS_HEADER_TYPE type
)
517 static const WS_XML_STRING headers
[] =
519 {6, (BYTE
*)"Action"},
521 {9, (BYTE
*)"MessageID"},
522 {9, (BYTE
*)"RelatesTo"},
524 {7, (BYTE
*)"ReplyTo"},
525 {7, (BYTE
*)"FaultTo"},
528 if (type
< WS_ACTION_HEADER
|| type
> WS_FAULT_TO_HEADER
)
530 ERR( "unknown type %u\n", type
);
534 return &headers
[type
- 1];
537 static HRESULT
write_must_understand( WS_XML_WRITER
*writer
, const WS_XML_STRING
*prefix
, const WS_XML_STRING
*ns
)
539 static const WS_XML_STRING understand
= {14, (BYTE
*)"mustUnderstand"};
540 WS_XML_INT32_TEXT one
= {{WS_XML_TEXT_TYPE_INT32
}, 1};
543 if ((hr
= WsWriteStartAttribute( writer
, prefix
, &understand
, ns
, FALSE
, NULL
)) != S_OK
) return hr
;
544 if ((hr
= WsWriteText( writer
, &one
.text
, NULL
)) != S_OK
) return hr
;
545 return WsWriteEndAttribute( writer
, NULL
);
548 static HRESULT
write_action_header( WS_XML_WRITER
*writer
, const WS_XML_STRING
*prefix_env
,
549 const WS_XML_STRING
*ns_env
, const WS_XML_STRING
*prefix_addr
,
550 const WS_XML_STRING
*ns_addr
, const WS_XML_STRING
*text
)
552 WS_XML_UTF8_TEXT utf8
= {{WS_XML_TEXT_TYPE_UTF8
}};
553 const WS_XML_STRING
*action
= get_header_name( WS_ACTION_HEADER
);
556 if (!text
|| !text
->length
) return S_OK
;
557 utf8
.value
.length
= text
->length
;
558 utf8
.value
.bytes
= text
->bytes
;
560 if ((hr
= WsWriteStartElement( writer
, prefix_addr
, action
, ns_addr
, NULL
)) != S_OK
) return hr
;
561 if ((hr
= write_must_understand( writer
, prefix_env
, ns_env
)) != S_OK
) return hr
;
562 if ((hr
= WsWriteText( writer
, &utf8
.text
, NULL
)) != S_OK
) return hr
;
563 return WsWriteEndElement( writer
, NULL
); /* </a:Action> */
566 static HRESULT
write_to_header( WS_XML_WRITER
*writer
, const WS_XML_STRING
*prefix_env
,
567 const WS_XML_STRING
*ns_env
, const WS_XML_STRING
*prefix_addr
,
568 const WS_XML_STRING
*ns_addr
, const WS_STRING
*addr
)
570 WS_XML_UTF16_TEXT utf16
= {{WS_XML_TEXT_TYPE_UTF16
}, (BYTE
*)addr
->chars
, addr
->length
* sizeof(WCHAR
)};
571 const WS_XML_STRING
*to
= get_header_name( WS_TO_HEADER
);
574 if ((hr
= WsWriteStartElement( writer
, prefix_addr
, to
, ns_addr
, NULL
)) != S_OK
) return hr
;
575 if ((hr
= write_must_understand( writer
, prefix_env
, ns_env
)) != S_OK
) return hr
;
576 if ((hr
= WsWriteText( writer
, &utf16
.text
, NULL
)) != S_OK
) return hr
;
577 return WsWriteEndElement( writer
, NULL
); /* </a:To> */
580 static HRESULT
write_replyto_header( WS_XML_WRITER
*writer
, const WS_XML_STRING
*prefix_env
,
581 const WS_XML_STRING
*ns_env
, const WS_XML_STRING
*prefix_addr
,
582 const WS_XML_STRING
*ns_addr
)
584 static const char anonymous
[] = "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous";
585 WS_XML_UTF8_TEXT utf8
= {{WS_XML_TEXT_TYPE_UTF8
}, {sizeof(anonymous
) - 1, (BYTE
*)anonymous
}};
586 const WS_XML_STRING address
= {7, (BYTE
*)"Address"}, *replyto
= get_header_name( WS_REPLY_TO_HEADER
);
589 if ((hr
= WsWriteStartElement( writer
, prefix_addr
, replyto
, ns_addr
, NULL
)) != S_OK
) return hr
;
590 if ((hr
= WsWriteStartElement( writer
, prefix_addr
, &address
, ns_addr
, NULL
)) != S_OK
) return hr
;
591 if ((hr
= WsWriteText( writer
, &utf8
.text
, NULL
)) != S_OK
) return hr
;
592 if ((hr
= WsWriteEndElement( writer
, NULL
)) != S_OK
) return hr
; /* </a:Address> */
593 return WsWriteEndElement( writer
, NULL
); /* </a:ReplyTo> */
596 static HRESULT
write_msgid_header( WS_XML_WRITER
*writer
, const WS_XML_STRING
*prefix_env
,
597 const WS_XML_STRING
*ns_env
, const WS_XML_STRING
*prefix_addr
,
598 const WS_XML_STRING
*ns_addr
, const GUID
*guid
)
600 WS_XML_UNIQUE_ID_TEXT id
= {{WS_XML_TEXT_TYPE_UNIQUE_ID
}, *guid
};
601 const WS_XML_STRING
*msgid
= get_header_name( WS_MESSAGE_ID_HEADER
);
604 if ((hr
= WsWriteStartElement( writer
, prefix_addr
, msgid
, ns_addr
, NULL
)) != S_OK
) return hr
;
605 if ((hr
= WsWriteText( writer
, &id
.text
, NULL
)) != S_OK
) return hr
;
606 return WsWriteEndElement( writer
, NULL
); /* </a:MessageID> */
609 static HRESULT
write_relatesto_header( WS_XML_WRITER
*writer
, const WS_XML_STRING
*prefix_env
,
610 const WS_XML_STRING
*ns_env
, const WS_XML_STRING
*prefix_addr
,
611 const WS_XML_STRING
*ns_addr
, const GUID
*guid
)
613 WS_XML_UNIQUE_ID_TEXT id
= {{WS_XML_TEXT_TYPE_UNIQUE_ID
}, *guid
};
614 const WS_XML_STRING
*relatesto
= get_header_name( WS_RELATES_TO_HEADER
);
617 if ((hr
= WsWriteStartElement( writer
, prefix_addr
, relatesto
, ns_addr
, NULL
)) != S_OK
) return hr
;
618 if ((hr
= WsWriteText( writer
, &id
.text
, NULL
)) != S_OK
) return hr
;
619 return WsWriteEndElement( writer
, NULL
); /* </a:RelatesTo> */
622 static HRESULT
write_headers( struct msg
*msg
, WS_XML_WRITER
*writer
, const WS_XML_STRING
*prefix_env
,
623 const WS_XML_STRING
*ns_env
, const WS_XML_STRING
*prefix_addr
,
624 const WS_XML_STRING
*ns_addr
)
626 static const WS_XML_STRING header
= {6, (BYTE
*)"Header"};
630 if ((hr
= WsWriteXmlnsAttribute( writer
, prefix_addr
, ns_addr
, FALSE
, NULL
)) != S_OK
) return hr
;
631 if ((hr
= WsWriteStartElement( writer
, prefix_env
, &header
, ns_env
, NULL
)) != S_OK
) return hr
;
633 if ((hr
= write_action_header( writer
, prefix_env
, ns_env
, prefix_addr
, ns_addr
, msg
->action
)) != S_OK
)
636 if (msg
->init
== WS_REPLY_MESSAGE
)
638 if ((hr
= write_relatesto_header( writer
, prefix_env
, ns_env
, prefix_addr
, ns_addr
, &msg
->id_req
)) != S_OK
)
641 else if (msg
->addr
.length
)
643 if ((hr
= write_to_header( writer
, prefix_env
, ns_env
, prefix_addr
, ns_addr
, &msg
->addr
)) != S_OK
)
648 if ((hr
= write_msgid_header( writer
, prefix_env
, ns_env
, prefix_addr
, ns_addr
, &msg
->id
)) != S_OK
)
650 if (msg
->version_addr
== WS_ADDRESSING_VERSION_0_9
&&
651 (hr
= write_replyto_header( writer
, prefix_env
, ns_env
, prefix_addr
, ns_addr
)) != S_OK
) return hr
;
654 for (i
= 0; i
< msg
->header_count
; i
++)
656 if (msg
->header
[i
]->mapped
) continue;
657 if ((hr
= WsWriteXmlBuffer( writer
, msg
->header
[i
]->u
.buf
, NULL
)) != S_OK
) return hr
;
660 return WsWriteEndElement( writer
, NULL
); /* </s:Header> */
663 static HRESULT
write_headers_transport( struct msg
*msg
, WS_XML_WRITER
*writer
, const WS_XML_STRING
*prefix
,
664 const WS_XML_STRING
*ns
)
666 static const WS_XML_STRING header
= {6, (BYTE
*)"Header"};
670 if ((msg
->header_count
|| !msg
->action
) &&
671 (hr
= WsWriteStartElement( writer
, prefix
, &header
, ns
, NULL
)) != S_OK
) return hr
;
673 for (i
= 0; i
< msg
->header_count
; i
++)
675 if (msg
->header
[i
]->mapped
) continue;
676 if ((hr
= WsWriteXmlBuffer( writer
, msg
->header
[i
]->u
.buf
, NULL
)) != S_OK
) return hr
;
679 if (msg
->header_count
|| !msg
->action
) hr
= WsWriteEndElement( writer
, NULL
); /* </s:Header> */
683 static HRESULT
write_envelope_start( struct msg
*msg
, WS_XML_WRITER
*writer
)
685 static const WS_XML_STRING envelope
= {8, (BYTE
*)"Envelope"}, body
= {4, (BYTE
*)"Body"};
686 static const WS_XML_STRING prefix_s
= {1, (BYTE
*)"s"}, prefix_a
= {1, (BYTE
*)"a"};
687 const WS_XML_STRING
*prefix_env
= (msg
->version_env
== WS_ENVELOPE_VERSION_NONE
) ? NULL
: &prefix_s
;
688 const WS_XML_STRING
*prefix_addr
= (msg
->version_addr
== WS_ADDRESSING_VERSION_TRANSPORT
) ? NULL
: &prefix_a
;
689 const WS_XML_STRING
*ns_env
= get_env_namespace( msg
->version_env
);
690 const WS_XML_STRING
*ns_addr
= get_addr_namespace( msg
->version_addr
);
693 if ((hr
= WsWriteStartElement( writer
, prefix_env
, &envelope
, ns_env
, NULL
)) != S_OK
) return hr
;
695 if (msg
->version_addr
== WS_ADDRESSING_VERSION_TRANSPORT
)
696 hr
= write_headers_transport( msg
, writer
, prefix_env
, ns_env
);
698 hr
= write_headers( msg
, writer
, prefix_env
, ns_env
, prefix_addr
, ns_addr
);
699 if (hr
!= S_OK
) return hr
;
701 return WsWriteStartElement( writer
, prefix_env
, &body
, ns_env
, NULL
); /* <s:Body> */
704 static HRESULT
write_envelope_end( WS_XML_WRITER
*writer
)
707 if ((hr
= WsWriteEndElement( writer
, NULL
)) != S_OK
) return hr
; /* </s:Body> */
708 return WsWriteEndElement( writer
, NULL
); /* </s:Envelope> */
711 static HRESULT
write_envelope( struct msg
*msg
)
714 if (!msg
->writer
&& (hr
= WsCreateWriter( NULL
, 0, &msg
->writer
, NULL
)) != S_OK
) return hr
;
715 if (!msg
->buf
&& (hr
= WsCreateXmlBuffer( msg
->heap
, NULL
, 0, &msg
->buf
, NULL
)) != S_OK
) return hr
;
716 if ((hr
= WsSetOutputToBuffer( msg
->writer
, msg
->buf
, NULL
, 0, NULL
)) != S_OK
) return hr
;
717 if ((hr
= write_envelope_start( msg
, msg
->writer
)) != S_OK
) return hr
;
718 return write_envelope_end( msg
->writer
);
721 /**************************************************************************
722 * WsWriteEnvelopeStart [webservices.@]
724 HRESULT WINAPI
WsWriteEnvelopeStart( WS_MESSAGE
*handle
, WS_XML_WRITER
*writer
,
725 WS_MESSAGE_DONE_CALLBACK cb
, void *state
, WS_ERROR
*error
)
727 struct msg
*msg
= (struct msg
*)handle
;
730 TRACE( "%p %p %p %p %p\n", handle
, writer
, cb
, state
, error
);
731 if (error
) FIXME( "ignoring error parameter\n" );
734 FIXME( "callback not supported\n" );
738 if (!msg
|| !writer
) return E_INVALIDARG
;
740 EnterCriticalSection( &msg
->cs
);
742 if (msg
->magic
!= MSG_MAGIC
)
744 LeaveCriticalSection( &msg
->cs
);
748 if (msg
->state
!= WS_MESSAGE_STATE_INITIALIZED
) hr
= WS_E_INVALID_OPERATION
;
749 else if ((hr
= write_envelope( msg
)) == S_OK
&&
750 (hr
= write_envelope_start( msg
, writer
)) == S_OK
)
752 msg
->writer_body
= writer
;
753 msg
->state
= WS_MESSAGE_STATE_WRITING
;
756 LeaveCriticalSection( &msg
->cs
);
757 TRACE( "returning %08x\n", hr
);
761 /**************************************************************************
762 * WsWriteEnvelopeEnd [webservices.@]
764 HRESULT WINAPI
WsWriteEnvelopeEnd( WS_MESSAGE
*handle
, WS_ERROR
*error
)
766 struct msg
*msg
= (struct msg
*)handle
;
769 TRACE( "%p %p\n", handle
, error
);
770 if (error
) FIXME( "ignoring error parameter\n" );
772 if (!msg
) return E_INVALIDARG
;
774 EnterCriticalSection( &msg
->cs
);
776 if (msg
->magic
!= MSG_MAGIC
)
778 LeaveCriticalSection( &msg
->cs
);
782 if (msg
->state
!= WS_MESSAGE_STATE_WRITING
) hr
= WS_E_INVALID_OPERATION
;
783 else if ((hr
= write_envelope_end( msg
->writer_body
)) == S_OK
)
784 msg
->state
= WS_MESSAGE_STATE_DONE
;
786 LeaveCriticalSection( &msg
->cs
);
787 TRACE( "returning %08x\n", hr
);
791 /**************************************************************************
792 * WsWriteBody [webservices.@]
794 HRESULT WINAPI
WsWriteBody( WS_MESSAGE
*handle
, const WS_ELEMENT_DESCRIPTION
*desc
, WS_WRITE_OPTION option
,
795 const void *value
, ULONG size
, WS_ERROR
*error
)
797 struct msg
*msg
= (struct msg
*)handle
;
800 TRACE( "%p %p %08x %p %u %p\n", handle
, desc
, option
, value
, size
, error
);
801 if (error
) FIXME( "ignoring error parameter\n" );
803 if (!msg
|| !desc
) return E_INVALIDARG
;
805 EnterCriticalSection( &msg
->cs
);
807 if (msg
->magic
!= MSG_MAGIC
)
809 LeaveCriticalSection( &msg
->cs
);
813 if (msg
->state
!= WS_MESSAGE_STATE_WRITING
)
815 hr
= WS_E_INVALID_OPERATION
;
819 if (desc
->elementLocalName
&&
820 (hr
= WsWriteStartElement( msg
->writer_body
, NULL
, desc
->elementLocalName
, desc
->elementNs
,
821 NULL
)) != S_OK
) goto done
;
823 if ((hr
= WsWriteType( msg
->writer_body
, WS_ANY_ELEMENT_TYPE_MAPPING
, desc
->type
, desc
->typeDescription
,
824 option
, value
, size
, NULL
)) != S_OK
) goto done
;
826 if (desc
->elementLocalName
) hr
= WsWriteEndElement( msg
->writer_body
, NULL
);
829 LeaveCriticalSection( &msg
->cs
);
830 TRACE( "returning %08x\n", hr
);
834 /**************************************************************************
835 * WsFlushBody [webservices.@]
837 HRESULT WINAPI
WsFlushBody( WS_MESSAGE
*handle
, ULONG size
, const WS_ASYNC_CONTEXT
*ctx
, WS_ERROR
*error
)
839 struct msg
*msg
= (struct msg
*)handle
;
842 TRACE( "%p %u %p %p\n", handle
, size
, ctx
, error
);
844 if (!msg
) return E_INVALIDARG
;
846 EnterCriticalSection( &msg
->cs
);
848 if (msg
->magic
!= MSG_MAGIC
)
850 LeaveCriticalSection( &msg
->cs
);
854 hr
= WsFlushWriter( msg
->writer_body
, size
, ctx
, error
);
856 LeaveCriticalSection( &msg
->cs
);
857 TRACE( "returning %08x\n", hr
);
861 static BOOL
match_current_element( WS_XML_READER
*reader
, const WS_XML_STRING
*localname
)
863 const WS_XML_NODE
*node
;
864 const WS_XML_ELEMENT_NODE
*elem
;
866 if (WsGetReaderNode( reader
, &node
, NULL
) != S_OK
) return FALSE
;
867 if (node
->nodeType
!= WS_XML_NODE_TYPE_ELEMENT
) return FALSE
;
868 elem
= (const WS_XML_ELEMENT_NODE
*)node
;
869 return WsXmlStringEquals( elem
->localName
, localname
, NULL
) == S_OK
;
872 static HRESULT
read_message_id( WS_XML_READER
*reader
, GUID
*ret
)
874 const WS_XML_NODE
*node
;
875 const WS_XML_TEXT_NODE
*text
;
878 if ((hr
= WsReadNode( reader
, NULL
)) != S_OK
) return hr
;
879 if ((hr
= WsGetReaderNode( reader
, &node
, NULL
)) != S_OK
) return hr
;
880 if (node
->nodeType
!= WS_XML_NODE_TYPE_TEXT
) return WS_E_INVALID_FORMAT
;
881 text
= (const WS_XML_TEXT_NODE
*)node
;
883 switch (text
->text
->textType
)
885 case WS_XML_TEXT_TYPE_UTF8
:
887 const WS_XML_UTF8_TEXT
*utf8
= (const WS_XML_UTF8_TEXT
*)text
->text
;
888 if (utf8
->value
.length
!= 45 || memcmp( utf8
->value
.bytes
, "urn:uuid:", 9 ))
889 return WS_E_INVALID_FORMAT
;
891 return str_to_guid( utf8
->value
.bytes
+ 9, utf8
->value
.length
- 9, ret
);
893 case WS_XML_TEXT_TYPE_UNIQUE_ID
:
895 const WS_XML_UNIQUE_ID_TEXT
*id
= (const WS_XML_UNIQUE_ID_TEXT
*)text
->text
;
900 FIXME( "unhandled text type %u\n", text
->text
->textType
);
905 static HRESULT
read_envelope_start( struct msg
*msg
, WS_XML_READER
*reader
)
907 static const WS_XML_STRING envelope
= {8, (BYTE
*)"Envelope"}, body
= {4, (BYTE
*)"Body"};
908 static const WS_XML_STRING header
= {6, (BYTE
*)"Header"}, msgid
= {9, (BYTE
*)"MessageID"};
911 if ((hr
= WsReadNode( reader
, NULL
)) != S_OK
) return hr
;
912 if (!match_current_element( reader
, &envelope
)) return WS_E_INVALID_FORMAT
;
913 if ((hr
= WsReadNode( reader
, NULL
)) != S_OK
) return hr
;
914 if (match_current_element( reader
, &header
))
918 if ((hr
= WsReadNode( reader
, NULL
)) != S_OK
) return hr
;
919 if (match_current_element( reader
, &msgid
) && (hr
= read_message_id( reader
, &msg
->id_req
)) != S_OK
)
921 if (match_current_element( reader
, &body
)) break;
924 if (!match_current_element( reader
, &body
)) return WS_E_INVALID_FORMAT
;
925 return WsReadNode( reader
, NULL
);
928 /**************************************************************************
929 * WsReadEnvelopeStart [webservices.@]
931 HRESULT WINAPI
WsReadEnvelopeStart( WS_MESSAGE
*handle
, WS_XML_READER
*reader
, WS_MESSAGE_DONE_CALLBACK cb
,
932 void *state
, WS_ERROR
*error
)
934 struct msg
*msg
= (struct msg
*)handle
;
937 TRACE( "%p %p %p %p %p\n", handle
, reader
, cb
, state
, error
);
938 if (error
) FIXME( "ignoring error parameter\n" );
941 FIXME( "callback not supported\n" );
945 if (!msg
|| !reader
) return E_INVALIDARG
;
947 EnterCriticalSection( &msg
->cs
);
949 if (msg
->magic
!= MSG_MAGIC
)
951 LeaveCriticalSection( &msg
->cs
);
955 if (msg
->state
!= WS_MESSAGE_STATE_EMPTY
) hr
= WS_E_INVALID_OPERATION
;
956 else if ((hr
= read_envelope_start( msg
, reader
)) == S_OK
&&
957 (hr
= create_header_buffer( reader
, msg
->heap
, &msg
->buf
)) == S_OK
)
959 msg
->reader_body
= reader
;
960 msg
->state
= WS_MESSAGE_STATE_READING
;
963 LeaveCriticalSection( &msg
->cs
);
964 TRACE( "returning %08x\n", hr
);
968 /**************************************************************************
969 * WsReadEnvelopeEnd [webservices.@]
971 HRESULT WINAPI
WsReadEnvelopeEnd( WS_MESSAGE
*handle
, WS_ERROR
*error
)
973 struct msg
*msg
= (struct msg
*)handle
;
976 TRACE( "%p %p\n", handle
, error
);
977 if (error
) FIXME( "ignoring error parameter\n" );
979 if (!msg
) return E_INVALIDARG
;
981 EnterCriticalSection( &msg
->cs
);
983 if (msg
->magic
!= MSG_MAGIC
)
985 LeaveCriticalSection( &msg
->cs
);
989 if (msg
->state
!= WS_MESSAGE_STATE_READING
) hr
= WS_E_INVALID_OPERATION
;
990 else if ((hr
= WsReadEndElement( msg
->reader_body
, NULL
)) == S_OK
)
991 msg
->state
= WS_MESSAGE_STATE_DONE
;
993 LeaveCriticalSection( &msg
->cs
);
994 TRACE( "returning %08x\n", hr
);
998 /**************************************************************************
999 * WsReadBody [webservices.@]
1001 HRESULT WINAPI
WsReadBody( WS_MESSAGE
*handle
, const WS_ELEMENT_DESCRIPTION
*desc
, WS_READ_OPTION option
,
1002 WS_HEAP
*heap
, void *value
, ULONG size
, WS_ERROR
*error
)
1004 struct msg
*msg
= (struct msg
*)handle
;
1007 TRACE( "%p %p %08x %p %p %u %p\n", handle
, desc
, option
, heap
, value
, size
, error
);
1008 if (error
) FIXME( "ignoring error parameter\n" );
1010 if (!msg
|| !desc
) return E_INVALIDARG
;
1012 EnterCriticalSection( &msg
->cs
);
1014 if (msg
->magic
!= MSG_MAGIC
)
1016 LeaveCriticalSection( &msg
->cs
);
1017 return E_INVALIDARG
;
1020 if (msg
->state
!= WS_MESSAGE_STATE_READING
) hr
= WS_E_INVALID_OPERATION
;
1021 else hr
= WsReadElement( msg
->reader_body
, desc
, option
, heap
, value
, size
, NULL
);
1023 LeaveCriticalSection( &msg
->cs
);
1024 TRACE( "returning %08x\n", hr
);
1028 /**************************************************************************
1029 * WsFillBody [webservices.@]
1031 HRESULT WINAPI
WsFillBody( WS_MESSAGE
*handle
, ULONG size
, const WS_ASYNC_CONTEXT
*ctx
, WS_ERROR
*error
)
1033 struct msg
*msg
= (struct msg
*)handle
;
1036 TRACE( "%p %u %p %p\n", handle
, size
, ctx
, error
);
1038 if (!msg
) return E_INVALIDARG
;
1040 EnterCriticalSection( &msg
->cs
);
1042 if (msg
->magic
!= MSG_MAGIC
)
1044 LeaveCriticalSection( &msg
->cs
);
1045 return E_INVALIDARG
;
1048 hr
= WsFillReader( msg
->reader_body
, size
, ctx
, error
);
1050 LeaveCriticalSection( &msg
->cs
);
1051 TRACE( "returning %08x\n", hr
);
1055 /**************************************************************************
1056 * WsInitializeMessage [webservices.@]
1058 HRESULT WINAPI
WsInitializeMessage( WS_MESSAGE
*handle
, WS_MESSAGE_INITIALIZATION init
,
1059 WS_MESSAGE
*src_handle
, WS_ERROR
*error
)
1061 struct msg
*msg
= (struct msg
*)handle
;
1064 TRACE( "%p %u %p %p\n", handle
, init
, src_handle
, error
);
1065 if (error
) FIXME( "ignoring error parameter\n" );
1068 FIXME( "src message not supported\n" );
1072 if (!msg
|| init
> WS_FAULT_MESSAGE
) return E_INVALIDARG
;
1074 EnterCriticalSection( &msg
->cs
);
1076 if (msg
->magic
!= MSG_MAGIC
)
1078 LeaveCriticalSection( &msg
->cs
);
1079 return E_INVALIDARG
;
1082 if (msg
->state
>= WS_MESSAGE_STATE_INITIALIZED
) hr
= WS_E_INVALID_OPERATION
;
1083 else if ((hr
= write_envelope( msg
)) == S_OK
)
1086 msg
->state
= WS_MESSAGE_STATE_INITIALIZED
;
1089 LeaveCriticalSection( &msg
->cs
);
1090 TRACE( "returning %08x\n", hr
);
1094 static HRESULT
grow_header_array( struct msg
*msg
, ULONG size
)
1096 struct header
**tmp
;
1097 if (size
<= msg
->header_size
) return S_OK
;
1098 if (!(tmp
= heap_realloc( msg
->header
, 2 * msg
->header_size
* sizeof(struct header
*) )))
1099 return E_OUTOFMEMORY
;
1101 msg
->header_size
*= 2;
1105 static struct header
*alloc_header( WS_HEADER_TYPE type
, BOOL mapped
, const WS_XML_STRING
*name
,
1106 const WS_XML_STRING
*ns
)
1109 if (!(ret
= heap_alloc_zero( sizeof(*ret
) ))) return NULL
;
1110 if (name
&& name
->length
)
1112 if (!(ret
->name
.bytes
= heap_alloc( name
->length
)))
1117 memcpy( ret
->name
.bytes
, name
->bytes
, name
->length
);
1118 ret
->name
.length
= name
->length
;
1120 if (ns
&& ns
->length
)
1122 if (!(ret
->ns
.bytes
= heap_alloc( ns
->length
)))
1127 memcpy( ret
->ns
.bytes
, ns
->bytes
, ns
->length
);
1128 ret
->ns
.length
= ns
->length
;
1131 ret
->mapped
= mapped
;
1135 static HRESULT
write_standard_header( struct msg
*msg
, WS_HEADER_TYPE type
, WS_TYPE value_type
,
1136 WS_WRITE_OPTION option
, const void *value
, ULONG size
)
1138 static const WS_XML_STRING ns
= {0, NULL
};
1139 static const WS_XML_STRING prefix_s
= {1, (BYTE
*)"s"}, prefix_a
= {1, (BYTE
*)"a"};
1140 const WS_XML_STRING
*prefix_env
= (msg
->version_env
== WS_ENVELOPE_VERSION_NONE
) ? NULL
: &prefix_s
;
1141 const WS_XML_STRING
*prefix_addr
= (msg
->version_addr
== WS_ADDRESSING_VERSION_TRANSPORT
) ? NULL
: &prefix_a
;
1142 const WS_XML_STRING
*localname
= get_header_name( type
);
1145 if ((hr
= WsWriteStartElement( msg
->writer
, prefix_addr
, localname
, &ns
, NULL
)) != S_OK
) return hr
;
1146 if ((hr
= write_must_understand( msg
->writer
, prefix_env
, &ns
)) != S_OK
) return hr
;
1147 if (msg
->version_addr
== WS_ADDRESSING_VERSION_TRANSPORT
)
1149 const WS_XML_STRING
*ns_addr
= get_addr_namespace( WS_ADDRESSING_VERSION_TRANSPORT
);
1150 if ((hr
= WsWriteXmlnsAttribute( msg
->writer
, NULL
, ns_addr
, FALSE
, NULL
)) != S_OK
) return hr
;
1152 if ((hr
= WsWriteType( msg
->writer
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, value_type
, NULL
, option
, value
, size
,
1153 NULL
)) != S_OK
) return hr
;
1154 return WsWriteEndElement( msg
->writer
, NULL
);
1157 static HRESULT
build_standard_header( struct msg
*msg
, WS_HEADER_TYPE type
, WS_TYPE value_type
,
1158 WS_WRITE_OPTION option
, const void *value
, ULONG size
,
1159 struct header
**ret
)
1161 struct header
*header
;
1165 if (!(header
= alloc_header( type
, FALSE
, get_header_name(type
), NULL
))) return E_OUTOFMEMORY
;
1167 if (!msg
->writer
&& (hr
= WsCreateWriter( NULL
, 0, &msg
->writer
, NULL
)) != S_OK
) goto done
;
1168 if ((hr
= WsCreateXmlBuffer( msg
->heap
, NULL
, 0, &buf
, NULL
)) != S_OK
) goto done
;
1169 if ((hr
= WsSetOutputToBuffer( msg
->writer
, buf
, NULL
, 0, NULL
)) != S_OK
) goto done
;
1170 if ((hr
= write_standard_header( msg
, type
, value_type
, option
, value
, size
)) != S_OK
) goto done
;
1172 header
->u
.buf
= buf
;
1175 if (hr
!= S_OK
) free_header( header
);
1180 /**************************************************************************
1181 * WsSetHeader [webservices.@]
1183 HRESULT WINAPI
WsSetHeader( WS_MESSAGE
*handle
, WS_HEADER_TYPE type
, WS_TYPE value_type
,
1184 WS_WRITE_OPTION option
, const void *value
, ULONG size
, WS_ERROR
*error
)
1186 struct msg
*msg
= (struct msg
*)handle
;
1187 struct header
*header
;
1192 TRACE( "%p %u %u %08x %p %u %p\n", handle
, type
, value_type
, option
, value
, size
, error
);
1193 if (error
) FIXME( "ignoring error parameter\n" );
1195 if (!msg
|| type
< WS_ACTION_HEADER
|| type
> WS_FAULT_TO_HEADER
) return E_INVALIDARG
;
1197 EnterCriticalSection( &msg
->cs
);
1199 if (msg
->magic
!= MSG_MAGIC
)
1201 LeaveCriticalSection( &msg
->cs
);
1202 return E_INVALIDARG
;
1205 if (msg
->state
< WS_MESSAGE_STATE_INITIALIZED
)
1207 hr
= WS_E_INVALID_OPERATION
;
1211 for (i
= 0; i
< msg
->header_count
; i
++)
1213 if (msg
->header
[i
]->type
== type
)
1222 if ((hr
= grow_header_array( msg
, msg
->header_count
+ 1 )) != S_OK
) goto done
;
1223 i
= msg
->header_count
;
1226 if ((hr
= build_standard_header( msg
, type
, value_type
, option
, value
, size
, &header
)) != S_OK
)
1229 if (!found
) msg
->header_count
++;
1230 else free_header( msg
->header
[i
] );
1232 msg
->header
[i
] = header
;
1233 hr
= write_envelope( msg
);
1236 LeaveCriticalSection( &msg
->cs
);
1237 TRACE( "returning %08x\n", hr
);
1241 static HRESULT
find_header( WS_XML_READER
*reader
, const WS_XML_STRING
*localname
, const WS_XML_STRING
*ns
)
1243 const WS_XML_NODE
*node
;
1244 const WS_XML_ELEMENT_NODE
*elem
;
1249 if ((hr
= WsReadNode( reader
, NULL
)) != S_OK
) return hr
;
1250 if ((hr
= WsGetReaderNode( reader
, &node
, NULL
)) != S_OK
) return hr
;
1251 if (node
->nodeType
== WS_XML_NODE_TYPE_EOF
) return WS_E_INVALID_FORMAT
;
1252 if (node
->nodeType
!= WS_XML_NODE_TYPE_ELEMENT
) continue;
1254 elem
= (const WS_XML_ELEMENT_NODE
*)node
;
1255 if (WsXmlStringEquals( elem
->localName
, localname
, NULL
) == S_OK
&&
1256 WsXmlStringEquals( elem
->ns
, ns
, NULL
) == S_OK
) break;
1262 static HRESULT
get_standard_header( struct msg
*msg
, WS_HEADER_TYPE type
, WS_TYPE value_type
,
1263 WS_READ_OPTION option
, WS_HEAP
*heap
, void *value
, ULONG size
)
1265 const WS_XML_STRING
*localname
= get_header_name( type
);
1266 const WS_XML_STRING
*ns
= get_addr_namespace( msg
->version_addr
);
1269 if (!heap
) heap
= msg
->heap
;
1270 if (!msg
->reader
&& (hr
= WsCreateReader( NULL
, 0, &msg
->reader
, NULL
)) != S_OK
) return hr
;
1271 if ((hr
= WsSetInputToBuffer( msg
->reader
, msg
->buf
, NULL
, 0, NULL
)) != S_OK
) return hr
;
1273 if ((hr
= find_header( msg
->reader
, localname
, ns
)) != S_OK
) return hr
;
1274 return read_header( msg
->reader
, localname
, ns
, value_type
, NULL
, option
, heap
, value
, size
);
1277 /**************************************************************************
1278 * WsGetHeader [webservices.@]
1280 HRESULT WINAPI
WsGetHeader( WS_MESSAGE
*handle
, WS_HEADER_TYPE type
, WS_TYPE value_type
, WS_READ_OPTION option
,
1281 WS_HEAP
*heap
, void *value
, ULONG size
, WS_ERROR
*error
)
1283 struct msg
*msg
= (struct msg
*)handle
;
1286 TRACE( "%p %u %u %08x %p %p %u %p\n", handle
, type
, value_type
, option
, heap
, value
, size
, error
);
1287 if (error
) FIXME( "ignoring error parameter\n" );
1289 if (!msg
|| type
< WS_ACTION_HEADER
|| type
> WS_FAULT_TO_HEADER
|| option
< WS_READ_REQUIRED_VALUE
||
1290 option
> WS_READ_OPTIONAL_POINTER
) return E_INVALIDARG
;
1292 EnterCriticalSection( &msg
->cs
);
1294 if (msg
->magic
!= MSG_MAGIC
)
1296 LeaveCriticalSection( &msg
->cs
);
1297 return E_INVALIDARG
;
1300 if (msg
->state
< WS_MESSAGE_STATE_INITIALIZED
) hr
= WS_E_INVALID_OPERATION
;
1301 else hr
= get_standard_header( msg
, type
, value_type
, option
, heap
, value
, size
);
1303 LeaveCriticalSection( &msg
->cs
);
1304 TRACE( "returning %08x\n", hr
);
1308 static void remove_header( struct msg
*msg
, ULONG i
)
1310 free_header( msg
->header
[i
] );
1311 memmove( &msg
->header
[i
], &msg
->header
[i
+ 1], (msg
->header_count
- i
- 1) * sizeof(struct header
*) );
1312 msg
->header_count
--;
1315 /**************************************************************************
1316 * WsRemoveHeader [webservices.@]
1318 HRESULT WINAPI
WsRemoveHeader( WS_MESSAGE
*handle
, WS_HEADER_TYPE type
, WS_ERROR
*error
)
1320 struct msg
*msg
= (struct msg
*)handle
;
1321 BOOL removed
= FALSE
;
1325 TRACE( "%p %u %p\n", handle
, type
, error
);
1326 if (error
) FIXME( "ignoring error parameter\n" );
1328 if (!msg
) return E_INVALIDARG
;
1330 EnterCriticalSection( &msg
->cs
);
1332 if (msg
->magic
!= MSG_MAGIC
)
1334 LeaveCriticalSection( &msg
->cs
);
1335 return E_INVALIDARG
;
1338 if (msg
->state
< WS_MESSAGE_STATE_INITIALIZED
) hr
= WS_E_INVALID_OPERATION
;
1339 else if (type
< WS_ACTION_HEADER
|| type
> WS_FAULT_TO_HEADER
) hr
= E_INVALIDARG
;
1342 for (i
= 0; i
< msg
->header_count
; i
++)
1344 if (msg
->header
[i
]->type
== type
)
1346 remove_header( msg
, i
);
1351 if (removed
) hr
= write_envelope( msg
);
1354 LeaveCriticalSection( &msg
->cs
);
1355 TRACE( "returning %08x\n", hr
);
1359 static HRESULT
build_mapped_header( const WS_XML_STRING
*name
, WS_TYPE type
, WS_WRITE_OPTION option
,
1360 const void *value
, ULONG size
, struct header
**ret
)
1362 struct header
*header
;
1364 if (!(header
= alloc_header( 0, TRUE
, name
, NULL
))) return E_OUTOFMEMORY
;
1372 if (option
!= WS_WRITE_REQUIRED_POINTER
|| size
!= sizeof(WCHAR
*))
1374 free_header( header
);
1375 return E_INVALIDARG
;
1377 src
= *(const WCHAR
**)value
;
1378 len
= WideCharToMultiByte( CP_UTF8
, 0, src
, -1, NULL
, 0, NULL
, NULL
) - 1;
1379 if (!(header
->u
.text
= alloc_xml_string( NULL
, len
)))
1381 free_header( header
);
1382 return E_OUTOFMEMORY
;
1384 WideCharToMultiByte( CP_UTF8
, 0, src
, -1, (char *)header
->u
.text
->bytes
, len
, NULL
, NULL
);
1387 case WS_XML_STRING_TYPE
:
1389 const WS_XML_STRING
*str
= value
;
1391 if (option
!= WS_WRITE_REQUIRED_VALUE
)
1393 FIXME( "unhandled write option %u\n", option
);
1394 free_header( header
);
1397 if (size
!= sizeof(*str
))
1399 free_header( header
);
1400 return E_INVALIDARG
;
1402 if (!(header
->u
.text
= alloc_xml_string( NULL
, str
->length
)))
1404 free_header( header
);
1405 return E_OUTOFMEMORY
;
1407 memcpy( header
->u
.text
->bytes
, str
->bytes
, str
->length
);
1410 case WS_STRING_TYPE
:
1413 const WS_STRING
*str
= value
;
1415 if (option
!= WS_WRITE_REQUIRED_VALUE
)
1417 FIXME( "unhandled write option %u\n", option
);
1418 free_header( header
);
1421 if (size
!= sizeof(*str
))
1423 free_header( header
);
1424 return E_INVALIDARG
;
1426 len
= WideCharToMultiByte( CP_UTF8
, 0, str
->chars
, str
->length
, NULL
, 0, NULL
, NULL
);
1427 if (!(header
->u
.text
= alloc_xml_string( NULL
, len
)))
1429 free_header( header
);
1430 return E_OUTOFMEMORY
;
1432 WideCharToMultiByte( CP_UTF8
, 0, str
->chars
, str
->length
, (char *)header
->u
.text
->bytes
,
1437 FIXME( "unhandled type %u\n", type
);
1438 free_header( header
);
1446 /**************************************************************************
1447 * WsAddMappedHeader [webservices.@]
1449 HRESULT WINAPI
WsAddMappedHeader( WS_MESSAGE
*handle
, const WS_XML_STRING
*name
, WS_TYPE type
,
1450 WS_WRITE_OPTION option
, const void *value
, ULONG size
, WS_ERROR
*error
)
1452 struct msg
*msg
= (struct msg
*)handle
;
1453 struct header
*header
;
1458 TRACE( "%p %s %u %08x %p %u %p\n", handle
, debugstr_xmlstr(name
), type
, option
, value
, size
, error
);
1459 if (error
) FIXME( "ignoring error parameter\n" );
1461 if (!msg
|| !name
) return E_INVALIDARG
;
1463 EnterCriticalSection( &msg
->cs
);
1465 if (msg
->magic
!= MSG_MAGIC
)
1467 LeaveCriticalSection( &msg
->cs
);
1468 return E_INVALIDARG
;
1471 if (msg
->state
< WS_MESSAGE_STATE_INITIALIZED
)
1473 hr
= WS_E_INVALID_OPERATION
;
1477 for (i
= 0; i
< msg
->header_count
; i
++)
1479 if (msg
->header
[i
]->type
|| !msg
->header
[i
]->mapped
) continue;
1480 if (WsXmlStringEquals( name
, &msg
->header
[i
]->name
, NULL
) == S_OK
)
1489 if ((hr
= grow_header_array( msg
, msg
->header_count
+ 1 )) != S_OK
) goto done
;
1490 i
= msg
->header_count
;
1493 if ((hr
= build_mapped_header( name
, type
, option
, value
, size
, &header
)) != S_OK
) goto done
;
1495 if (!found
) msg
->header_count
++;
1496 else free_header( msg
->header
[i
] );
1498 msg
->header
[i
] = header
;
1501 LeaveCriticalSection( &msg
->cs
);
1502 TRACE( "returning %08x\n", hr
);
1506 /**************************************************************************
1507 * WsRemoveMappedHeader [webservices.@]
1509 HRESULT WINAPI
WsRemoveMappedHeader( WS_MESSAGE
*handle
, const WS_XML_STRING
*name
, WS_ERROR
*error
)
1511 struct msg
*msg
= (struct msg
*)handle
;
1515 TRACE( "%p %s %p\n", handle
, debugstr_xmlstr(name
), error
);
1516 if (error
) FIXME( "ignoring error parameter\n" );
1518 if (!msg
|| !name
) return E_INVALIDARG
;
1520 EnterCriticalSection( &msg
->cs
);
1522 if (msg
->magic
!= MSG_MAGIC
)
1524 LeaveCriticalSection( &msg
->cs
);
1525 return E_INVALIDARG
;
1528 if (msg
->state
< WS_MESSAGE_STATE_INITIALIZED
) hr
= WS_E_INVALID_OPERATION
;
1531 for (i
= 0; i
< msg
->header_count
; i
++)
1533 if (msg
->header
[i
]->type
|| !msg
->header
[i
]->mapped
) continue;
1534 if (WsXmlStringEquals( name
, &msg
->header
[i
]->name
, NULL
) == S_OK
)
1536 remove_header( msg
, i
);
1542 LeaveCriticalSection( &msg
->cs
);
1543 TRACE( "returning %08x\n", hr
);
1547 static HRESULT
write_custom_header( WS_XML_WRITER
*writer
, const WS_XML_STRING
*name
, const WS_XML_STRING
*ns
,
1548 WS_TYPE type
, const void *desc
, WS_WRITE_OPTION option
, const void *value
,
1552 if ((hr
= WsWriteStartElement( writer
, NULL
, name
, ns
, NULL
)) != S_OK
) return hr
;
1553 if ((hr
= WsWriteType( writer
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, type
, desc
, option
, value
, size
,
1554 NULL
)) != S_OK
) return hr
;
1555 return WsWriteEndElement( writer
, NULL
);
1558 static HRESULT
build_custom_header( struct msg
*msg
, const WS_XML_STRING
*name
, const WS_XML_STRING
*ns
,
1559 WS_TYPE type
, const void *desc
, WS_WRITE_OPTION option
, const void *value
,
1560 ULONG size
, struct header
**ret
)
1562 struct header
*header
;
1566 if (!(header
= alloc_header( 0, FALSE
, name
, ns
))) return E_OUTOFMEMORY
;
1568 if (!msg
->writer
&& (hr
= WsCreateWriter( NULL
, 0, &msg
->writer
, NULL
)) != S_OK
) goto done
;
1569 if ((hr
= WsCreateXmlBuffer( msg
->heap
, NULL
, 0, &buf
, NULL
)) != S_OK
) goto done
;
1570 if ((hr
= WsSetOutputToBuffer( msg
->writer
, buf
, NULL
, 0, NULL
)) != S_OK
) goto done
;
1571 if ((hr
= write_custom_header( msg
->writer
, name
, ns
, type
, desc
, option
, value
, size
)) != S_OK
) goto done
;
1573 header
->u
.buf
= buf
;
1576 if (hr
!= S_OK
) free_header( header
);
1581 /**************************************************************************
1582 * WsAddCustomHeader [webservices.@]
1584 HRESULT WINAPI
WsAddCustomHeader( WS_MESSAGE
*handle
, const WS_ELEMENT_DESCRIPTION
*desc
, WS_WRITE_OPTION option
,
1585 const void *value
, ULONG size
, ULONG attrs
, WS_ERROR
*error
)
1587 struct msg
*msg
= (struct msg
*)handle
;
1588 struct header
*header
;
1591 TRACE( "%p %p %08x %p %u %08x %p\n", handle
, desc
, option
, value
, size
, attrs
, error
);
1592 if (error
) FIXME( "ignoring error parameter\n" );
1594 if (!msg
|| !desc
) return E_INVALIDARG
;
1596 EnterCriticalSection( &msg
->cs
);
1598 if (msg
->magic
!= MSG_MAGIC
)
1600 LeaveCriticalSection( &msg
->cs
);
1601 return E_INVALIDARG
;
1604 if (msg
->state
< WS_MESSAGE_STATE_INITIALIZED
)
1606 hr
= WS_E_INVALID_OPERATION
;
1610 if ((hr
= grow_header_array( msg
, msg
->header_count
+ 1 )) != S_OK
) goto done
;
1611 if ((hr
= build_custom_header( msg
, desc
->elementLocalName
, desc
->elementNs
, desc
->type
,
1612 desc
->typeDescription
, option
, value
, size
, &header
)) != S_OK
) goto done
;
1613 msg
->header
[msg
->header_count
++] = header
;
1614 hr
= write_envelope( msg
);
1617 LeaveCriticalSection( &msg
->cs
);
1618 TRACE( "returning %08x\n", hr
);
1622 static HRESULT
get_custom_header( struct msg
*msg
, const WS_ELEMENT_DESCRIPTION
*desc
, WS_READ_OPTION option
,
1623 WS_HEAP
*heap
, void *value
, ULONG size
)
1626 if (!heap
) heap
= msg
->heap
;
1627 if (!msg
->reader
&& (hr
= WsCreateReader( NULL
, 0, &msg
->reader
, NULL
)) != S_OK
) return hr
;
1628 if ((hr
= WsSetInputToBuffer( msg
->reader
, msg
->buf
, NULL
, 0, NULL
)) != S_OK
) return hr
;
1630 if ((hr
= find_header( msg
->reader
, desc
->elementLocalName
, desc
->elementNs
)) != S_OK
) return hr
;
1631 return read_header( msg
->reader
, desc
->elementLocalName
, desc
->elementNs
, desc
->type
, desc
->typeDescription
,
1632 option
, heap
, value
, size
);
1635 /**************************************************************************
1636 * WsGetCustomHeader [webservices.@]
1638 HRESULT WINAPI
WsGetCustomHeader( WS_MESSAGE
*handle
, const WS_ELEMENT_DESCRIPTION
*desc
,
1639 WS_REPEATING_HEADER_OPTION repeat_option
, ULONG index
, WS_READ_OPTION option
,
1640 WS_HEAP
*heap
, void *value
, ULONG size
, ULONG
*attrs
, WS_ERROR
*error
)
1642 struct msg
*msg
= (struct msg
*)handle
;
1645 TRACE( "%p %p %08x %u %08x %p %p %u %p %p\n", handle
, desc
, repeat_option
, index
, option
, heap
, value
,
1646 size
, attrs
, error
);
1647 if (error
) FIXME( "ignoring error parameter\n" );
1649 if (!msg
|| !desc
|| repeat_option
< WS_REPEATING_HEADER
|| repeat_option
> WS_SINGLETON_HEADER
||
1650 (repeat_option
== WS_SINGLETON_HEADER
&& index
)) return E_INVALIDARG
;
1652 if (repeat_option
== WS_REPEATING_HEADER
)
1654 FIXME( "repeating header not supported\n" );
1659 FIXME( "attributes not supported\n" );
1663 EnterCriticalSection( &msg
->cs
);
1665 if (msg
->magic
!= MSG_MAGIC
)
1667 LeaveCriticalSection( &msg
->cs
);
1668 return E_INVALIDARG
;
1671 if (msg
->state
< WS_MESSAGE_STATE_INITIALIZED
) hr
= WS_E_INVALID_OPERATION
;
1672 else hr
= get_custom_header( msg
, desc
, option
, heap
, value
, size
);
1674 LeaveCriticalSection( &msg
->cs
);
1675 TRACE( "returning %08x\n", hr
);
1679 /**************************************************************************
1680 * WsRemoveCustomHeader [webservices.@]
1682 HRESULT WINAPI
WsRemoveCustomHeader( WS_MESSAGE
*handle
, const WS_XML_STRING
*name
, const WS_XML_STRING
*ns
,
1685 struct msg
*msg
= (struct msg
*)handle
;
1686 BOOL removed
= FALSE
;
1690 TRACE( "%p %s %s %p\n", handle
, debugstr_xmlstr(name
), debugstr_xmlstr(ns
), error
);
1691 if (error
) FIXME( "ignoring error parameter\n" );
1693 if (!msg
|| !name
|| !ns
) return E_INVALIDARG
;
1695 EnterCriticalSection( &msg
->cs
);
1697 if (msg
->magic
!= MSG_MAGIC
)
1699 LeaveCriticalSection( &msg
->cs
);
1700 return E_INVALIDARG
;
1703 if (msg
->state
< WS_MESSAGE_STATE_INITIALIZED
) hr
= WS_E_INVALID_OPERATION
;
1706 for (i
= 0; i
< msg
->header_count
; i
++)
1708 if (msg
->header
[i
]->type
|| msg
->header
[i
]->mapped
) continue;
1709 if (WsXmlStringEquals( name
, &msg
->header
[i
]->name
, NULL
) == S_OK
&&
1710 WsXmlStringEquals( ns
, &msg
->header
[i
]->ns
, NULL
) == S_OK
)
1712 remove_header( msg
, i
);
1717 if (removed
) hr
= write_envelope( msg
);
1720 LeaveCriticalSection( &msg
->cs
);
1721 TRACE( "returning %08x\n", hr
);
1725 static WCHAR
*build_http_header( const WCHAR
*name
, const WCHAR
*value
, ULONG
*ret_len
)
1727 int len_name
= strlenW( name
), len_value
= strlenW( value
);
1728 WCHAR
*ret
= heap_alloc( (len_name
+ len_value
) * sizeof(WCHAR
) );
1730 if (!ret
) return NULL
;
1731 memcpy( ret
, name
, len_name
* sizeof(WCHAR
) );
1732 memcpy( ret
+ len_name
, value
, len_value
* sizeof(WCHAR
) );
1733 *ret_len
= len_name
+ len_value
;
1737 static inline HRESULT
insert_http_header( HINTERNET req
, const WCHAR
*header
, ULONG len
, ULONG flags
)
1739 if (WinHttpAddRequestHeaders( req
, header
, len
, flags
)) return S_OK
;
1740 return HRESULT_FROM_WIN32( GetLastError() );
1743 HRESULT
message_insert_http_headers( WS_MESSAGE
*handle
, HINTERNET req
)
1745 static const WCHAR contenttypeW
[] =
1746 {'C','o','n','t','e','n','t','-','T','y','p','e',':',' ',0};
1747 static const WCHAR soapxmlW
[] =
1748 {'a','p','p','l','i','c','a','t','i','o','n','/','s','o','a','p','+','x','m','l',0};
1749 static const WCHAR textxmlW
[] =
1750 {'t','e','x','t','/','x','m','l',0};
1751 static const WCHAR charsetW
[] =
1752 {'c','h','a','r','s','e','t','=','u','t','f','-','8',0};
1753 struct msg
*msg
= (struct msg
*)handle
;
1754 HRESULT hr
= E_OUTOFMEMORY
;
1755 WCHAR
*header
= NULL
, *buf
;
1758 EnterCriticalSection( &msg
->cs
);
1760 if (msg
->magic
!= MSG_MAGIC
)
1762 LeaveCriticalSection( &msg
->cs
);
1763 return E_INVALIDARG
;
1766 switch (msg
->version_env
)
1768 case WS_ENVELOPE_VERSION_SOAP_1_1
:
1769 header
= build_http_header( contenttypeW
, textxmlW
, &len
);
1772 case WS_ENVELOPE_VERSION_SOAP_1_2
:
1773 header
= build_http_header( contenttypeW
, soapxmlW
, &len
);
1777 FIXME( "unhandled envelope version %u\n", msg
->version_env
);
1780 if (!header
) goto done
;
1782 if ((hr
= insert_http_header( req
, header
, len
, WINHTTP_ADDREQ_FLAG_ADD
)) != S_OK
) goto done
;
1783 heap_free( header
);
1786 if (!(header
= build_http_header( contenttypeW
, charsetW
, &len
))) goto done
;
1787 if ((hr
= insert_http_header( req
, header
, len
, WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON
)) != S_OK
)
1789 heap_free( header
);
1792 switch (msg
->version_env
)
1794 case WS_ENVELOPE_VERSION_SOAP_1_1
:
1796 static const WCHAR soapactionW
[] = {'S','O','A','P','A','c','t','i','o','n',':',' ',0};
1798 if (!(len
= MultiByteToWideChar( CP_UTF8
, 0, (char *)msg
->action
->bytes
, msg
->action
->length
, NULL
, 0 )))
1802 if (!(buf
= heap_alloc( (len
+ 3) * sizeof(WCHAR
) ))) goto done
;
1804 MultiByteToWideChar( CP_UTF8
, 0, (char *)msg
->action
->bytes
, msg
->action
->length
, buf
+ 1, len
);
1808 header
= build_http_header( soapactionW
, buf
, &len
);
1810 if (!header
) goto done
;
1812 hr
= insert_http_header( req
, header
, len
, WINHTTP_ADDREQ_FLAG_ADD
);
1815 case WS_ENVELOPE_VERSION_SOAP_1_2
:
1817 static const WCHAR actionW
[] = {'a','c','t','i','o','n','=','"'};
1818 ULONG len_action
= ARRAY_SIZE( actionW
);
1820 if (!(len
= MultiByteToWideChar( CP_UTF8
, 0, (char *)msg
->action
->bytes
, msg
->action
->length
, NULL
, 0 )))
1824 if (!(buf
= heap_alloc( (len
+ len_action
+ 2) * sizeof(WCHAR
) ))) goto done
;
1825 memcpy( buf
, actionW
, len_action
* sizeof(WCHAR
) );
1826 MultiByteToWideChar( CP_UTF8
, 0, (char *)msg
->action
->bytes
, msg
->action
->length
, buf
+ len_action
, len
);
1831 header
= build_http_header( contenttypeW
, buf
, &len
);
1833 if (!header
) goto done
;
1835 hr
= insert_http_header( req
, header
, len
, WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON
);
1839 FIXME( "unhandled envelope version %u\n", msg
->version_env
);
1844 heap_free( header
);
1845 LeaveCriticalSection( &msg
->cs
);
1846 TRACE( "returning %08x\n", hr
);
1850 void message_set_send_context( WS_MESSAGE
*handle
, const WS_PROXY_MESSAGE_CALLBACK_CONTEXT
*ctx
)
1852 struct msg
*msg
= (struct msg
*)handle
;
1854 EnterCriticalSection( &msg
->cs
);
1856 if (msg
->magic
!= MSG_MAGIC
)
1858 LeaveCriticalSection( &msg
->cs
);
1862 msg
->ctx_send
.callback
= ctx
->callback
;
1863 msg
->ctx_send
.state
= ctx
->state
;
1865 LeaveCriticalSection( &msg
->cs
);
1868 void message_set_receive_context( WS_MESSAGE
*handle
, const WS_PROXY_MESSAGE_CALLBACK_CONTEXT
*ctx
)
1870 struct msg
*msg
= (struct msg
*)handle
;
1872 EnterCriticalSection( &msg
->cs
);
1874 if (msg
->magic
!= MSG_MAGIC
)
1876 LeaveCriticalSection( &msg
->cs
);
1880 msg
->ctx_receive
.callback
= ctx
->callback
;
1881 msg
->ctx_receive
.state
= ctx
->state
;
1883 LeaveCriticalSection( &msg
->cs
);
1886 void message_do_send_callback( WS_MESSAGE
*handle
)
1888 struct msg
*msg
= (struct msg
*)handle
;
1890 EnterCriticalSection( &msg
->cs
);
1892 if (msg
->magic
!= MSG_MAGIC
)
1894 LeaveCriticalSection( &msg
->cs
);
1898 if (msg
->ctx_send
.callback
)
1901 TRACE( "executing callback %p\n", msg
->ctx_send
.callback
);
1902 hr
= msg
->ctx_send
.callback( handle
, msg
->heap
, msg
->ctx_send
.state
, NULL
);
1903 TRACE( "callback %p returned %08x\n", msg
->ctx_send
.callback
, hr
);
1906 LeaveCriticalSection( &msg
->cs
);
1909 void message_do_receive_callback( WS_MESSAGE
*handle
)
1911 struct msg
*msg
= (struct msg
*)handle
;
1913 EnterCriticalSection( &msg
->cs
);
1915 if (msg
->magic
!= MSG_MAGIC
)
1917 LeaveCriticalSection( &msg
->cs
);
1921 if (msg
->ctx_receive
.callback
)
1924 TRACE( "executing callback %p\n", msg
->ctx_receive
.callback
);
1925 hr
= msg
->ctx_receive
.callback( handle
, msg
->heap
, msg
->ctx_receive
.state
, NULL
);
1926 TRACE( "callback %p returned %08x\n", msg
->ctx_receive
.callback
, hr
);
1929 LeaveCriticalSection( &msg
->cs
);
1932 HRESULT
message_set_action( WS_MESSAGE
*handle
, const WS_XML_STRING
*action
)
1934 struct msg
*msg
= (struct msg
*)handle
;
1937 EnterCriticalSection( &msg
->cs
);
1939 if (msg
->magic
!= MSG_MAGIC
)
1941 LeaveCriticalSection( &msg
->cs
);
1942 return E_INVALIDARG
;
1945 if (!action
|| !action
->length
)
1947 free_xml_string( msg
->action
);
1953 if (!(str
= dup_xml_string( action
, FALSE
))) hr
= E_OUTOFMEMORY
;
1956 free_xml_string( msg
->action
);
1961 LeaveCriticalSection( &msg
->cs
);
1965 HRESULT
message_get_id( WS_MESSAGE
*handle
, GUID
*id
)
1967 struct msg
*msg
= (struct msg
*)handle
;
1970 EnterCriticalSection( &msg
->cs
);
1972 if (msg
->magic
!= MSG_MAGIC
)
1974 LeaveCriticalSection( &msg
->cs
);
1975 return E_INVALIDARG
;
1980 LeaveCriticalSection( &msg
->cs
);
1984 HRESULT
message_set_request_id( WS_MESSAGE
*handle
, const GUID
*id
)
1986 struct msg
*msg
= (struct msg
*)handle
;
1989 EnterCriticalSection( &msg
->cs
);
1991 if (msg
->magic
!= MSG_MAGIC
)
1993 LeaveCriticalSection( &msg
->cs
);
1994 return E_INVALIDARG
;
1999 LeaveCriticalSection( &msg
->cs
);