?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
usp10: Fall back to 'dflt' language if shaping language tag isn't found.
[wine.git] / dlls / webservices / msg.c
blob02cb22b88fc6b4c36cbf130bb16286e657bdd941
1 /*
2 * Copyright 2016 Hans Leidekker for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <stdarg.h>
20
21 #include "windef.h"
22 #include "winbase.h"
23 #include "winuser.h"
24 #include "rpc.h"
25 #include "webservices.h"
26
27 #include "wine/debug.h"
28 #include "wine/list.h"
29 #include "wine/unicode.h"
30 #include "webservices_private.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(webservices);
33
34 static const struct prop_desc msg_props[] =
35 {
36 { sizeof(WS_MESSAGE_STATE), TRUE }, /* WS_MESSAGE_PROPERTY_STATE */
37 { sizeof(WS_HEAP *), TRUE }, /* WS_MESSAGE_PROPERTY_HEAP */
38 { sizeof(WS_ENVELOPE_VERSION), TRUE }, /* WS_MESSAGE_PROPERTY_ENVELOPE_VERSION */
39 { sizeof(WS_ADDRESSING_VERSION), TRUE }, /* WS_MESSAGE_PROPERTY_ADDRESSING_VERSION */
40 { sizeof(WS_XML_BUFFER *), TRUE }, /* WS_MESSAGE_PROPERTY_HEADER_BUFFER */
41 { sizeof(WS_XML_NODE_POSITION *), TRUE }, /* WS_MESSAGE_PROPERTY_HEADER_POSITION */
42 { sizeof(WS_XML_READER *), TRUE }, /* WS_MESSAGE_PROPERTY_BODY_READER */
43 { sizeof(WS_XML_WRITER *), TRUE }, /* WS_MESSAGE_PROPERTY_BODY_WRITER */
44 { sizeof(BOOL), TRUE }, /* WS_MESSAGE_PROPERTY_IS_ADDRESSED */
45 };
46
47 struct header
48 {
49 WS_HEADER_TYPE type;
50 BOOL mapped;
51 WS_XML_STRING name;
52 WS_XML_STRING ns;
53 union
54 {
55 WS_XML_BUFFER *buf;
56 WS_XML_STRING *text;
57 } u;
58 };
59
60 struct msg
61 {
62 ULONG magic;
63 CRITICAL_SECTION cs;
64 WS_MESSAGE_INITIALIZATION init;
65 WS_MESSAGE_STATE state;
66 GUID id;
67 WS_ENVELOPE_VERSION version_env;
68 WS_ADDRESSING_VERSION version_addr;
69 BOOL is_addressed;
70 WS_STRING addr;
71 WS_STRING action;
72 WS_HEAP *heap;
73 WS_XML_BUFFER *buf;
74 WS_XML_WRITER *writer;
75 WS_XML_WRITER *writer_body;
76 WS_XML_READER *reader;
77 WS_XML_READER *reader_body;
78 ULONG header_count;
79 ULONG header_size;
80 struct header **header;
81 WS_PROXY_MESSAGE_CALLBACK_CONTEXT ctx_send;
82 WS_PROXY_MESSAGE_CALLBACK_CONTEXT ctx_receive;
83 ULONG prop_count;
84 struct prop prop[sizeof(msg_props)/sizeof(msg_props[0])];
85 };
86
87 #define MSG_MAGIC (('M' << 24) | ('E' << 16) | ('S' << 8) | 'S')
88 #define HEADER_ARRAY_SIZE 2
89
90 static struct msg *alloc_msg(void)
91 {
92 static const ULONG count = sizeof(msg_props)/sizeof(msg_props[0]);
93 struct msg *ret;
94 ULONG size = sizeof(*ret) + prop_size( msg_props, count );
95
96 if (!(ret = heap_alloc_zero( size ))) return NULL;
97 if (!(ret->header = heap_alloc( HEADER_ARRAY_SIZE * sizeof(struct header *) )))
98 {
99 heap_free( ret );
100 return NULL;
101 }
102 ret->magic = MSG_MAGIC;
103 ret->state = WS_MESSAGE_STATE_EMPTY;
104 ret->header_size = HEADER_ARRAY_SIZE;
105
106 InitializeCriticalSection( &ret->cs );
107 ret->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": msg.cs");
108
109 prop_init( msg_props, count, ret->prop, &ret[1] );
110 ret->prop_count = count;
111 return ret;
112 }
113
114 static void free_header( struct header *header )
115 {
116 heap_free( header->name.bytes );
117 heap_free( header->ns.bytes );
118 if (header->mapped) free_xml_string( header->u.text );
119 heap_free( header );
120 }
121
122 static void reset_msg( struct msg *msg )
123 {
124 ULONG i;
125
126 msg->state = WS_MESSAGE_STATE_EMPTY;
127 msg->init = 0;
128 UuidCreate( &msg->id );
129 msg->is_addressed = FALSE;
130 heap_free( msg->addr.chars );
131 msg->addr.chars = NULL;
132 msg->addr.length = 0;
133
134 heap_free( msg->action.chars );
135 msg->action.chars = NULL;
136 msg->action.length = 0;
137
138 WsResetHeap( msg->heap, NULL );
139 msg->buf = NULL; /* allocated on msg->heap */
140 msg->writer_body = NULL; /* owned by caller */
141 msg->reader_body = NULL; /* owned by caller */
142
143 for (i = 0; i < msg->header_count; i++)
144 {
145 free_header( msg->header[i] );
146 msg->header[i] = NULL;
147 }
148 msg->header_count = 0;
149
150 memset( &msg->ctx_send, 0, sizeof(msg->ctx_send) );
151 memset( &msg->ctx_receive, 0, sizeof(msg->ctx_receive) );
152 }
153
154 static void free_msg( struct msg *msg )
155 {
156 reset_msg( msg );
157
158 WsFreeWriter( msg->writer );
159 WsFreeReader( msg->reader );
160 WsFreeHeap( msg->heap );
161 heap_free( msg->header );
162
163 msg->cs.DebugInfo->Spare[0] = 0;
164 DeleteCriticalSection( &msg->cs );
165 heap_free( msg );
166 }
167
168 #define HEAP_MAX_SIZE (1 << 16)
169 static HRESULT create_msg( WS_ENVELOPE_VERSION env_version, WS_ADDRESSING_VERSION addr_version,
170 const WS_MESSAGE_PROPERTY *properties, ULONG count, WS_MESSAGE **handle )
171 {
172 struct msg *msg;
173 HRESULT hr;
174 ULONG i;
175
176 if (!(msg = alloc_msg())) return E_OUTOFMEMORY;
177
178 for (i = 0; i < count; i++)
179 {
180 if (properties[i].id == WS_MESSAGE_PROPERTY_ENVELOPE_VERSION ||
181 properties[i].id == WS_MESSAGE_PROPERTY_ADDRESSING_VERSION)
182 {
183 free_msg( msg );
184 return E_INVALIDARG;
185 }
186 hr = prop_set( msg->prop, msg->prop_count, properties[i].id, properties[i].value,
187 properties[i].valueSize );
188 if (hr != S_OK)
189 {
190 free_msg( msg );
191 return hr;
192 }
193 }
194
195 if ((hr = WsCreateHeap( HEAP_MAX_SIZE, 0, NULL, 0, &msg->heap, NULL )) != S_OK)
196 {
197 free_msg( msg );
198 return hr;
199 }
200
201 UuidCreate( &msg->id );
202 msg->version_env = env_version;
203 msg->version_addr = addr_version;
204
205 *handle = (WS_MESSAGE *)msg;
206 return S_OK;
207 }
208
209 /**************************************************************************
210 * WsCreateMessage [webservices.@]
211 */
212 HRESULT WINAPI WsCreateMessage( WS_ENVELOPE_VERSION env_version, WS_ADDRESSING_VERSION addr_version,
213 const WS_MESSAGE_PROPERTY *properties, ULONG count, WS_MESSAGE **handle,
214 WS_ERROR *error )
215 {
216 TRACE( "%u %u %p %u %p %p\n", env_version, addr_version, properties, count, handle, error );
217 if (error) FIXME( "ignoring error parameter\n" );
218
219 if (!handle || !env_version || !addr_version ||
220 (env_version == WS_ENVELOPE_VERSION_NONE && addr_version != WS_ADDRESSING_VERSION_TRANSPORT))
221 {
222 return E_INVALIDARG;
223 }
224 return create_msg( env_version, addr_version, properties, count, handle );
225 }
226
227 /**************************************************************************
228 * WsCreateMessageForChannel [webservices.@]
229 */
230 HRESULT WINAPI WsCreateMessageForChannel( WS_CHANNEL *channel_handle, const WS_MESSAGE_PROPERTY *properties,
231 ULONG count, WS_MESSAGE **handle, WS_ERROR *error )
232 {
233 WS_ENVELOPE_VERSION version_env;
234 WS_ADDRESSING_VERSION version_addr;
235 HRESULT hr;
236
237 TRACE( "%p %p %u %p %p\n", channel_handle, properties, count, handle, error );
238 if (error) FIXME( "ignoring error parameter\n" );
239
240 if (!channel_handle || !handle) return E_INVALIDARG;
241
242 if ((hr = WsGetChannelProperty( channel_handle, WS_CHANNEL_PROPERTY_ENVELOPE_VERSION, &version_env,
243 sizeof(version_env), NULL )) != S_OK || !version_env)
244 version_env = WS_ENVELOPE_VERSION_SOAP_1_2;
245
246 if ((hr = WsGetChannelProperty( channel_handle, WS_CHANNEL_PROPERTY_ADDRESSING_VERSION, &version_addr,
247 sizeof(version_addr), NULL )) != S_OK || !version_addr)
248 version_addr = WS_ADDRESSING_VERSION_1_0;
249
250 return create_msg( version_env, version_addr, properties, count, handle );
251 }
252
253 /**************************************************************************
254 * WsFreeMessage [webservices.@]
255 */
256 void WINAPI WsFreeMessage( WS_MESSAGE *handle )
257 {
258 struct msg *msg = (struct msg *)handle;
259
260 TRACE( "%p\n", handle );
261
262 if (!msg) return;
263
264 EnterCriticalSection( &msg->cs );
265
266 if (msg->magic != MSG_MAGIC)
267 {
268 LeaveCriticalSection( &msg->cs );
269 return;
270 }
271
272 msg->magic = 0;
273
274 LeaveCriticalSection( &msg->cs );
275 free_msg( msg );
276 }
277
278 /**************************************************************************
279 * WsResetMessage [webservices.@]
280 */
281 HRESULT WINAPI WsResetMessage( WS_MESSAGE *handle, WS_ERROR *error )
282 {
283 struct msg *msg = (struct msg *)handle;
284
285 TRACE( "%p %p\n", handle, error );
286 if (error) FIXME( "ignoring error parameter\n" );
287
288 if (!msg) return E_INVALIDARG;
289
290 EnterCriticalSection( &msg->cs );
291
292 if (msg->magic != MSG_MAGIC)
293 {
294 LeaveCriticalSection( &msg->cs );
295 return E_INVALIDARG;
296 }
297
298 reset_msg( msg );
299
300 LeaveCriticalSection( &msg->cs );
301 return S_OK;
302 }
303
304 /**************************************************************************
305 * WsGetMessageProperty [webservices.@]
306 */
307 HRESULT WINAPI WsGetMessageProperty( WS_MESSAGE *handle, WS_MESSAGE_PROPERTY_ID id, void *buf,
308 ULONG size, WS_ERROR *error )
309 {
310 struct msg *msg = (struct msg *)handle;
311 HRESULT hr = S_OK;
312
313 TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
314 if (error) FIXME( "ignoring error parameter\n" );
315
316 if (!msg) return E_INVALIDARG;
317
318 EnterCriticalSection( &msg->cs );
319
320 if (msg->magic != MSG_MAGIC)
321 {
322 LeaveCriticalSection( &msg->cs );
323 return E_INVALIDARG;
324 }
325
326 switch (id)
327 {
328 case WS_MESSAGE_PROPERTY_STATE:
329 if (!buf || size != sizeof(msg->state)) hr = E_INVALIDARG;
330 else *(WS_MESSAGE_STATE *)buf = msg->state;
331 break;
332
333 case WS_MESSAGE_PROPERTY_HEAP:
334 if (!buf || size != sizeof(msg->heap)) hr = E_INVALIDARG;
335 else *(WS_HEAP **)buf = msg->heap;
336 break;
337
338 case WS_MESSAGE_PROPERTY_ENVELOPE_VERSION:
339 if (!buf || size != sizeof(msg->version_env)) hr = E_INVALIDARG;
340 else *(WS_ENVELOPE_VERSION *)buf = msg->version_env;
341 break;
342
343 case WS_MESSAGE_PROPERTY_ADDRESSING_VERSION:
344 if (!buf || size != sizeof(msg->version_addr)) hr = E_INVALIDARG;
345 else *(WS_ADDRESSING_VERSION *)buf = msg->version_addr;
346 break;
347
348 case WS_MESSAGE_PROPERTY_HEADER_BUFFER:
349 if (!buf || size != sizeof(msg->buf)) hr = E_INVALIDARG;
350 else *(WS_XML_BUFFER **)buf = msg->buf;
351 break;
352
353 case WS_MESSAGE_PROPERTY_BODY_READER:
354 if (!buf || size != sizeof(msg->reader_body)) hr = E_INVALIDARG;
355 else *(WS_XML_READER **)buf = msg->reader_body;
356 break;
357
358 case WS_MESSAGE_PROPERTY_BODY_WRITER:
359 if (!buf || size != sizeof(msg->writer_body)) hr = E_INVALIDARG;
360 else *(WS_XML_WRITER **)buf = msg->writer_body;
361 break;
362
363 case WS_MESSAGE_PROPERTY_IS_ADDRESSED:
364 if (msg->state < WS_MESSAGE_STATE_INITIALIZED) hr = WS_E_INVALID_OPERATION;
365 else *(BOOL *)buf = msg->is_addressed;
366 break;
367
368 default:
369 hr = prop_get( msg->prop, msg->prop_count, id, buf, size );
370 }
371
372 LeaveCriticalSection( &msg->cs );
373 return hr;
374 }
375
376 /**************************************************************************
377 * WsSetMessageProperty [webservices.@]
378 */
379 HRESULT WINAPI WsSetMessageProperty( WS_MESSAGE *handle, WS_MESSAGE_PROPERTY_ID id, const void *value,
380 ULONG size, WS_ERROR *error )
381 {
382 struct msg *msg = (struct msg *)handle;
383 HRESULT hr;
384
385 TRACE( "%p %u %p %u\n", handle, id, value, size );
386 if (error) FIXME( "ignoring error parameter\n" );
387
388 if (!msg) return E_INVALIDARG;
389
390 EnterCriticalSection( &msg->cs );
391
392 if (msg->magic != MSG_MAGIC)
393 {
394 LeaveCriticalSection( &msg->cs );
395 return E_INVALIDARG;
396 }
397
398 switch (id)
399 {
400 case WS_MESSAGE_PROPERTY_STATE:
401 case WS_MESSAGE_PROPERTY_ENVELOPE_VERSION:
402 case WS_MESSAGE_PROPERTY_ADDRESSING_VERSION:
403 case WS_MESSAGE_PROPERTY_IS_ADDRESSED:
404 if (msg->state < WS_MESSAGE_STATE_INITIALIZED) hr = WS_E_INVALID_OPERATION;
405 else hr = E_INVALIDARG;
406 break;
407
408 default:
409 hr = prop_set( msg->prop, msg->prop_count, id, value, size );
410 }
411
412 LeaveCriticalSection( &msg->cs );
413 return hr;
414 }
415
416 /**************************************************************************
417 * WsAddressMessage [webservices.@]
418 */
419 HRESULT WINAPI WsAddressMessage( WS_MESSAGE *handle, const WS_ENDPOINT_ADDRESS *addr, WS_ERROR *error )
420 {
421 struct msg *msg = (struct msg *)handle;
422 HRESULT hr = S_OK;
423
424 TRACE( "%p %p %p\n", handle, addr, error );
425 if (error) FIXME( "ignoring error parameter\n" );
426 if (addr && (addr->headers || addr->extensions || addr->identity))
427 {
428 FIXME( "headers, extensions or identity not supported\n" );
429 return E_NOTIMPL;
430 }
431
432 if (!msg) return E_INVALIDARG;
433
434 EnterCriticalSection( &msg->cs );
435
436 if (msg->magic != MSG_MAGIC)
437 {
438 LeaveCriticalSection( &msg->cs );
439 return E_INVALIDARG;
440 }
441
442 if (msg->state < WS_MESSAGE_STATE_INITIALIZED || msg->is_addressed)
443 {
444 LeaveCriticalSection( &msg->cs );
445 return WS_E_INVALID_OPERATION;
446 }
447
448 if (addr && addr->url.length)
449 {
450 if (!(msg->addr.chars = heap_alloc( addr->url.length * sizeof(WCHAR) ))) hr = E_OUTOFMEMORY;
451 else
452 {
453 memcpy( msg->addr.chars, addr->url.chars, addr->url.length * sizeof(WCHAR) );
454 msg->addr.length = addr->url.length;
455 }
456 }
457
458 if (hr == S_OK) msg->is_addressed = TRUE;
459
460 LeaveCriticalSection( &msg->cs );
461 return hr;
462 }
463
464 static const WS_XML_STRING *get_env_namespace( WS_ENVELOPE_VERSION version )
465 {
466 static const WS_XML_STRING namespaces[] =
467 {
468 {41, (BYTE *)"http://schemas.xmlsoap.org/soap/envelope/"},
469 {39, (BYTE *)"http://www.w3.org/2003/05/soap-envelope"},
470 {0, NULL},
471 };
472
473 if (version < WS_ENVELOPE_VERSION_SOAP_1_1 || version > WS_ENVELOPE_VERSION_NONE)
474 {
475 ERR( "unknown version %u\n", version );
476 return NULL;
477 }
478
479 return &namespaces[version - 1];
480 }
481
482 static const WS_XML_STRING *get_addr_namespace( WS_ADDRESSING_VERSION version )
483 {
484 static const WS_XML_STRING namespaces[] =
485 {
486 {48, (BYTE *)"http://schemas.xmlsoap.org/ws/2004/08/addressing"},
487 {36, (BYTE *)"http://www.w3.org/2005/08/addressing"},
488 {55, (BYTE *)"http://schemas.microsoft.com/ws/2005/05/addressing/none"},
489 };
490
491 if (version < WS_ADDRESSING_VERSION_0_9 || version > WS_ADDRESSING_VERSION_TRANSPORT)
492 {
493 ERR( "unknown version %u\n", version );
494 return NULL;
495 }
496
497 return &namespaces[version - 1];
498 }
499
500 static const WS_XML_STRING *get_header_name( WS_HEADER_TYPE type )
501 {
502 static const WS_XML_STRING headers[] =
503 {
504 {6, (BYTE *)"Action"},
505 {2, (BYTE *)"To"},
506 {9, (BYTE *)"MessageID"},
507 {9, (BYTE *)"RelatesTo"},
508 {4, (BYTE *)"From"},
509 {7, (BYTE *)"ReplyTo"},
510 {7, (BYTE *)"FaultTo"},
511 };
512
513 if (type < WS_ACTION_HEADER || type > WS_FAULT_TO_HEADER)
514 {
515 ERR( "unknown type %u\n", type );
516 return NULL;
517 }
518
519 return &headers[type - 1];
520 }
521
522 static HRESULT write_must_understand( WS_XML_WRITER *writer, const WS_XML_STRING *prefix, const WS_XML_STRING *ns )
523 {
524 static const WS_XML_STRING understand = {14, (BYTE *)"mustUnderstand"};
525 WS_XML_INT32_TEXT one = {{WS_XML_TEXT_TYPE_INT32}, 1};
526 HRESULT hr;
527
528 if ((hr = WsWriteStartAttribute( writer, prefix, &understand, ns, FALSE, NULL )) != S_OK) return hr;
529 if ((hr = WsWriteText( writer, &one.text, NULL )) != S_OK) return hr;
530 return WsWriteEndAttribute( writer, NULL );
531 }
532
533 static HRESULT write_headers( struct msg *msg, WS_XML_WRITER *writer, const WS_XML_STRING *prefix_env,
534 const WS_XML_STRING *ns_env, const WS_XML_STRING *prefix_addr,
535 const WS_XML_STRING *ns_addr )
536 {
537 static const char anonymous[] = "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous";
538 static const WS_XML_STRING header = {6, (BYTE *)"Header"}, address = {7, (BYTE *)"Address"};
539 const WS_XML_STRING *msgid = get_header_name( WS_MESSAGE_ID_HEADER );
540 const WS_XML_STRING *replyto = get_header_name( WS_REPLY_TO_HEADER );
541 const WS_XML_STRING *to = get_header_name( WS_TO_HEADER );
542 const WS_XML_STRING *action = get_header_name( WS_ACTION_HEADER );
543 HRESULT hr;
544 ULONG i;
545
546 if ((hr = WsWriteXmlnsAttribute( writer, prefix_addr, ns_addr, FALSE, NULL )) != S_OK) return hr;
547 if ((hr = WsWriteStartElement( writer, prefix_env, &header, ns_env, NULL )) != S_OK) return hr;
548
549 if (msg->action.length)
550 {
551 WS_XML_UTF16_TEXT utf16 = {{WS_XML_TEXT_TYPE_UTF16}, (BYTE *)msg->action.chars,
552 msg->action.length * sizeof(WCHAR)};
553 if ((hr = WsWriteStartElement( writer, prefix_addr, action, ns_addr, NULL )) != S_OK) return hr;
554 if ((hr = write_must_understand( writer, prefix_env, ns_env )) != S_OK) return hr;
555 if ((hr = WsWriteText( writer, &utf16.text, NULL )) != S_OK) return hr;
556 if ((hr = WsWriteEndElement( writer, NULL )) != S_OK) return hr; /* </a:Action> */
557 }
558 if (msg->addr.length)
559 {
560 WS_XML_UTF16_TEXT utf16 = {{WS_XML_TEXT_TYPE_UTF16}, (BYTE *)msg->addr.chars,
561 msg->addr.length * sizeof(WCHAR)};
562 if ((hr = WsWriteStartElement( writer, prefix_addr, to, ns_addr, NULL )) != S_OK) return hr;
563 if ((hr = write_must_understand( writer, prefix_env, ns_env )) != S_OK) return hr;
564 if ((hr = WsWriteText( writer, &utf16.text, NULL )) != S_OK) return hr;
565 if ((hr = WsWriteEndElement( writer, NULL )) != S_OK) return hr; /* </a:To> */
566 }
567 else
568 {
569 WS_XML_UNIQUE_ID_TEXT id;
570 if ((hr = WsWriteStartElement( writer, prefix_addr, msgid, ns_addr, NULL )) != S_OK) return hr;
571 id.text.textType = WS_XML_TEXT_TYPE_UNIQUE_ID;
572 id.value = msg->id;
573 if ((hr = WsWriteText( writer, &id.text, NULL )) != S_OK) return hr;
574 if ((hr = WsWriteEndElement( writer, NULL )) != S_OK) return hr; /* </a:MessageID> */
575
576 if (msg->version_addr == WS_ADDRESSING_VERSION_0_9)
577 {
578 WS_XML_UTF8_TEXT utf8 = {{WS_XML_TEXT_TYPE_UTF8}, {sizeof(anonymous) - 1, (BYTE *)anonymous}};
579 if ((hr = WsWriteStartElement( writer, prefix_addr, replyto, ns_addr, NULL )) != S_OK) return hr;
580 if ((hr = WsWriteStartElement( writer, prefix_addr, &address, ns_addr, NULL )) != S_OK) return hr;
581 if ((hr = WsWriteText( writer, &utf8.text, NULL )) != S_OK) return hr;
582 if ((hr = WsWriteEndElement( writer, NULL )) != S_OK) return hr; /* </a:Address> */
583 if ((hr = WsWriteEndElement( writer, NULL )) != S_OK) return hr; /* </a:ReplyTo> */
584 }
585 }
586
587 for (i = 0; i < msg->header_count; i++)
588 {
589 if (msg->header[i]->mapped) continue;
590 if ((hr = WsWriteXmlBuffer( writer, msg->header[i]->u.buf, NULL )) != S_OK) return hr;
591 }
592
593 return WsWriteEndElement( writer, NULL ); /* </s:Header> */
594 }
595
596 static HRESULT write_headers_transport( struct msg *msg, WS_XML_WRITER *writer, const WS_XML_STRING *prefix,
597 const WS_XML_STRING *ns )
598 {
599 static const WS_XML_STRING header = {6, (BYTE *)"Header"};
600 HRESULT hr = S_OK;
601 ULONG i;
602
603 if ((msg->header_count || !msg->action.length) &&
604 (hr = WsWriteStartElement( writer, prefix, &header, ns, NULL )) != S_OK) return hr;
605
606 for (i = 0; i < msg->header_count; i++)
607 {
608 if (msg->header[i]->mapped) continue;
609 if ((hr = WsWriteXmlBuffer( writer, msg->header[i]->u.buf, NULL )) != S_OK) return hr;
610 }
611
612 if (msg->header_count || !msg->action.length) hr = WsWriteEndElement( writer, NULL ); /* </s:Header> */
613 return hr;
614 }
615
616 static HRESULT write_envelope_start( struct msg *msg, WS_XML_WRITER *writer )
617 {
618 static const WS_XML_STRING envelope = {8, (BYTE *)"Envelope"}, body = {4, (BYTE *)"Body"};
619 static const WS_XML_STRING prefix_s = {1, (BYTE *)"s"}, prefix_a = {1, (BYTE *)"a"};
620 const WS_XML_STRING *prefix_env = (msg->version_env == WS_ENVELOPE_VERSION_NONE) ? NULL : &prefix_s;
621 const WS_XML_STRING *prefix_addr = (msg->version_addr == WS_ADDRESSING_VERSION_TRANSPORT) ? NULL : &prefix_a;
622 const WS_XML_STRING *ns_env = get_env_namespace( msg->version_env );
623 const WS_XML_STRING *ns_addr = get_addr_namespace( msg->version_addr );
624 HRESULT hr;
625
626 if ((hr = WsWriteStartElement( writer, prefix_env, &envelope, ns_env, NULL )) != S_OK) return hr;
627
628 if (msg->version_addr == WS_ADDRESSING_VERSION_TRANSPORT)
629 hr = write_headers_transport( msg, writer, prefix_env, ns_env );
630 else
631 hr = write_headers( msg, writer, prefix_env, ns_env, prefix_addr, ns_addr );
632 if (hr != S_OK) return hr;
633
634 return WsWriteStartElement( writer, prefix_env, &body, ns_env, NULL ); /* <s:Body> */
635 }
636
637 static HRESULT write_envelope_end( WS_XML_WRITER *writer )
638 {
639 HRESULT hr;
640 if ((hr = WsWriteEndElement( writer, NULL )) != S_OK) return hr; /* </s:Body> */
641 return WsWriteEndElement( writer, NULL ); /* </s:Envelope> */
642 }
643
644 static HRESULT write_envelope( struct msg *msg )
645 {
646 HRESULT hr;
647 if (!msg->writer && (hr = WsCreateWriter( NULL, 0, &msg->writer, NULL )) != S_OK) return hr;
648 if (!msg->buf && (hr = WsCreateXmlBuffer( msg->heap, NULL, 0, &msg->buf, NULL )) != S_OK) return hr;
649 if ((hr = WsSetOutputToBuffer( msg->writer, msg->buf, NULL, 0, NULL )) != S_OK) return hr;
650 if ((hr = write_envelope_start( msg, msg->writer )) != S_OK) return hr;
651 return write_envelope_end( msg->writer );
652 }
653
654 /**************************************************************************
655 * WsWriteEnvelopeStart [webservices.@]
656 */
657 HRESULT WINAPI WsWriteEnvelopeStart( WS_MESSAGE *handle, WS_XML_WRITER *writer,
658 WS_MESSAGE_DONE_CALLBACK cb, void *state, WS_ERROR *error )
659 {
660 struct msg *msg = (struct msg *)handle;
661 HRESULT hr;
662
663 TRACE( "%p %p %p %p %p\n", handle, writer, cb, state, error );
664 if (error) FIXME( "ignoring error parameter\n" );
665 if (cb)
666 {
667 FIXME( "callback not supported\n" );
668 return E_NOTIMPL;
669 }
670
671 if (!msg || !writer) return E_INVALIDARG;
672
673 EnterCriticalSection( &msg->cs );
674
675 if (msg->magic != MSG_MAGIC)
676 {
677 LeaveCriticalSection( &msg->cs );
678 return E_INVALIDARG;
679 }
680
681 if (msg->state != WS_MESSAGE_STATE_INITIALIZED)
682 {
683 LeaveCriticalSection( &msg->cs );
684 return WS_E_INVALID_OPERATION;
685 }
686
687 if ((hr = write_envelope( msg )) != S_OK) goto done;
688 if ((hr = write_envelope_start( msg, writer )) != S_OK) goto done;
689
690 msg->writer_body = writer;
691 msg->state = WS_MESSAGE_STATE_WRITING;
692
693 done:
694 LeaveCriticalSection( &msg->cs );
695 return hr;
696 }
697
698 /**************************************************************************
699 * WsWriteEnvelopeEnd [webservices.@]
700 */
701 HRESULT WINAPI WsWriteEnvelopeEnd( WS_MESSAGE *handle, WS_ERROR *error )
702 {
703 struct msg *msg = (struct msg *)handle;
704 HRESULT hr;
705
706 TRACE( "%p %p\n", handle, error );
707 if (error) FIXME( "ignoring error parameter\n" );
708
709 if (!msg) return E_INVALIDARG;
710
711 EnterCriticalSection( &msg->cs );
712
713 if (msg->magic != MSG_MAGIC)
714 {
715 LeaveCriticalSection( &msg->cs );
716 return E_INVALIDARG;
717 }
718
719 if (msg->state != WS_MESSAGE_STATE_WRITING)
720 {
721 LeaveCriticalSection( &msg->cs );
722 return WS_E_INVALID_OPERATION;
723 }
724
725 if ((hr = write_envelope_end( msg->writer_body )) == S_OK) msg->state = WS_MESSAGE_STATE_DONE;
726
727 LeaveCriticalSection( &msg->cs );
728 return hr;
729 }
730
731 /**************************************************************************
732 * WsWriteBody [webservices.@]
733 */
734 HRESULT WINAPI WsWriteBody( WS_MESSAGE *handle, const WS_ELEMENT_DESCRIPTION *desc, WS_WRITE_OPTION option,
735 const void *value, ULONG size, WS_ERROR *error )
736 {
737 struct msg *msg = (struct msg *)handle;
738 HRESULT hr;
739
740 TRACE( "%p %p %08x %p %u %p\n", handle, desc, option, value, size, error );
741 if (error) FIXME( "ignoring error parameter\n" );
742
743 if (!msg || !desc) return E_INVALIDARG;
744
745 EnterCriticalSection( &msg->cs );
746
747 if (msg->magic != MSG_MAGIC)
748 {
749 LeaveCriticalSection( &msg->cs );
750 return E_INVALIDARG;
751 }
752
753 if (msg->state != WS_MESSAGE_STATE_WRITING)
754 {
755 LeaveCriticalSection( &msg->cs );
756 return WS_E_INVALID_OPERATION;
757 }
758
759 if (desc->elementLocalName &&
760 (hr = WsWriteStartElement( msg->writer_body, NULL, desc->elementLocalName, desc->elementNs,
761 NULL )) != S_OK) goto done;
762
763 if ((hr = WsWriteType( msg->writer_body, WS_ANY_ELEMENT_TYPE_MAPPING, desc->type, desc->typeDescription,
764 option, value, size, NULL )) != S_OK) goto done;
765
766 if (desc->elementLocalName) hr = WsWriteEndElement( msg->writer_body, NULL );
767
768 done:
769 LeaveCriticalSection( &msg->cs );
770 return hr;
771 }
772
773 static BOOL match_current_element( WS_XML_READER *reader, const WS_XML_STRING *localname )
774 {
775 const WS_XML_NODE *node;
776 const WS_XML_ELEMENT_NODE *elem;
777
778 if (WsGetReaderNode( reader, &node, NULL ) != S_OK) return FALSE;
779 if (node->nodeType != WS_XML_NODE_TYPE_ELEMENT) return FALSE;
780 elem = (const WS_XML_ELEMENT_NODE *)node;
781 return WsXmlStringEquals( elem->localName, localname, NULL ) == S_OK;
782 }
783
784 static HRESULT read_envelope_start( WS_XML_READER *reader )
785 {
786 static const WS_XML_STRING envelope = {8, (BYTE *)"Envelope"}, body = {4, (BYTE *)"Body"};
787 static const WS_XML_STRING header = {6, (BYTE *)"Header"};
788 HRESULT hr;
789
790 if ((hr = WsReadNode( reader, NULL )) != S_OK) return hr;
791 if (!match_current_element( reader, &envelope )) return WS_E_INVALID_FORMAT;
792 if ((hr = WsReadNode( reader, NULL )) != S_OK) return hr;
793 if (match_current_element( reader, &header ))
794 {
795 for (;;)
796 {
797 /* FIXME: store headers */
798 if ((hr = WsReadNode( reader, NULL )) != S_OK) return hr;
799 if (match_current_element( reader, &body )) break;
800 }
801 }
802 if (!match_current_element( reader, &body )) return WS_E_INVALID_FORMAT;
803 return WsReadNode( reader, NULL );
804 }
805
806 /**************************************************************************
807 * WsReadEnvelopeStart [webservices.@]
808 */
809 HRESULT WINAPI WsReadEnvelopeStart( WS_MESSAGE *handle, WS_XML_READER *reader, WS_MESSAGE_DONE_CALLBACK cb,
810 void *state, WS_ERROR *error )
811 {
812 struct msg *msg = (struct msg *)handle;
813 HRESULT hr;
814
815 TRACE( "%p %p %p %p %p\n", handle, reader, cb, state, error );
816 if (error) FIXME( "ignoring error parameter\n" );
817 if (cb)
818 {
819 FIXME( "callback not supported\n" );
820 return E_NOTIMPL;
821 }
822
823 if (!msg || !reader) return E_INVALIDARG;
824
825 EnterCriticalSection( &msg->cs );
826
827 if (msg->magic != MSG_MAGIC)
828 {
829 LeaveCriticalSection( &msg->cs );
830 return E_INVALIDARG;
831 }
832
833 if (msg->state != WS_MESSAGE_STATE_EMPTY)
834 {
835 LeaveCriticalSection( &msg->cs );
836 return WS_E_INVALID_OPERATION;
837 }
838
839 if ((hr = read_envelope_start( reader )) == S_OK)
840 {
841 msg->reader_body = reader;
842 msg->state = WS_MESSAGE_STATE_READING;
843 }
844
845 LeaveCriticalSection( &msg->cs );
846 return hr;
847 }
848
849 static HRESULT read_envelope_end( WS_XML_READER *reader )
850 {
851 HRESULT hr;
852 if ((hr = WsReadEndElement( reader, NULL )) != S_OK) return hr; /* </s:Body> */
853 return WsReadEndElement( reader, NULL ); /* </s:Envelope> */
854 }
855
856 /**************************************************************************
857 * WsReadEnvelopeEnd [webservices.@]
858 */
859 HRESULT WINAPI WsReadEnvelopeEnd( WS_MESSAGE *handle, WS_ERROR *error )
860 {
861 struct msg *msg = (struct msg *)handle;
862 HRESULT hr;
863
864 TRACE( "%p %p\n", handle, error );
865 if (error) FIXME( "ignoring error parameter\n" );
866
867 if (!msg) return E_INVALIDARG;
868
869 EnterCriticalSection( &msg->cs );
870
871 if (msg->magic != MSG_MAGIC)
872 {
873 LeaveCriticalSection( &msg->cs );
874 return E_INVALIDARG;
875 }
876
877 if (msg->state != WS_MESSAGE_STATE_READING)
878 {
879 LeaveCriticalSection( &msg->cs );
880 return WS_E_INVALID_OPERATION;
881 }
882
883 if ((hr = read_envelope_end( msg->reader_body )) == S_OK) msg->state = WS_MESSAGE_STATE_DONE;
884
885 LeaveCriticalSection( &msg->cs );
886 return hr;
887 }
888
889 /**************************************************************************
890 * WsReadBody [webservices.@]
891 */
892 HRESULT WINAPI WsReadBody( WS_MESSAGE *handle, const WS_ELEMENT_DESCRIPTION *desc, WS_READ_OPTION option,
893 WS_HEAP *heap, void *value, ULONG size, WS_ERROR *error )
894 {
895 struct msg *msg = (struct msg *)handle;
896 HRESULT hr;
897
898 TRACE( "%p %p %08x %p %p %u %p\n", handle, desc, option, heap, value, size, error );
899 if (error) FIXME( "ignoring error parameter\n" );
900
901 if (!msg || !desc) return E_INVALIDARG;
902
903 EnterCriticalSection( &msg->cs );
904
905 if (msg->magic != MSG_MAGIC)
906 {
907 LeaveCriticalSection( &msg->cs );
908 return E_INVALIDARG;
909 }
910
911 if (msg->state != WS_MESSAGE_STATE_READING)
912 {
913 LeaveCriticalSection( &msg->cs );
914 return WS_E_INVALID_OPERATION;
915 }
916
917 hr = WsReadElement( msg->reader_body, desc, option, heap, value, size, NULL );
918
919 LeaveCriticalSection( &msg->cs );
920 return hr;
921 }
922
923 /**************************************************************************
924 * WsInitializeMessage [webservices.@]
925 */
926 HRESULT WINAPI WsInitializeMessage( WS_MESSAGE *handle, WS_MESSAGE_INITIALIZATION init,
927 WS_MESSAGE *src_handle, WS_ERROR *error )
928 {
929 struct msg *msg = (struct msg *)handle;
930 HRESULT hr;
931
932 TRACE( "%p %u %p %p\n", handle, init, src_handle, error );
933 if (error) FIXME( "ignoring error parameter\n" );
934 if (src_handle)
935 {
936 FIXME( "src message not supported\n" );
937 return E_NOTIMPL;
938 }
939
940 if (!msg || init > WS_FAULT_MESSAGE) return E_INVALIDARG;
941
942 EnterCriticalSection( &msg->cs );
943
944 if (msg->magic != MSG_MAGIC)
945 {
946 LeaveCriticalSection( &msg->cs );
947 return E_INVALIDARG;
948 }
949
950 if (msg->state >= WS_MESSAGE_STATE_INITIALIZED)
951 {
952 LeaveCriticalSection( &msg->cs );
953 return WS_E_INVALID_OPERATION;
954 }
955
956 if ((hr = write_envelope( msg )) == S_OK)
957 {
958 msg->init = init;
959 msg->state = WS_MESSAGE_STATE_INITIALIZED;
960 }
961
962 LeaveCriticalSection( &msg->cs );
963 return hr;
964 }
965
966 static HRESULT grow_header_array( struct msg *msg, ULONG size )
967 {
968 struct header **tmp;
969 if (size <= msg->header_size) return S_OK;
970 if (!(tmp = heap_realloc( msg->header, 2 * msg->header_size * sizeof(struct header *) )))
971 return E_OUTOFMEMORY;
972 msg->header = tmp;
973 msg->header_size *= 2;
974 return S_OK;
975 }
976
977 static struct header *alloc_header( WS_HEADER_TYPE type, BOOL mapped, const WS_XML_STRING *name,
978 const WS_XML_STRING *ns )
979 {
980 struct header *ret;
981 if (!(ret = heap_alloc_zero( sizeof(*ret) ))) return NULL;
982 if (name && name->length)
983 {
984 if (!(ret->name.bytes = heap_alloc( name->length )))
985 {
986 free_header( ret );
987 return NULL;
988 }
989 memcpy( ret->name.bytes, name->bytes, name->length );
990 ret->name.length = name->length;
991 }
992 if (ns && ns->length)
993 {
994 if (!(ret->ns.bytes = heap_alloc( ns->length )))
995 {
996 free_header( ret );
997 return NULL;
998 }
999 memcpy( ret->ns.bytes, ns->bytes, ns->length );
1000 ret->ns.length = ns->length;
1001 }
1002 ret->type = type;
1003 ret->mapped = mapped;
1004 return ret;
1005 }
1006
1007 static HRESULT write_standard_header( struct msg *msg, WS_HEADER_TYPE type, WS_TYPE value_type,
1008 WS_WRITE_OPTION option, const void *value, ULONG size )
1009 {
1010 static const WS_XML_STRING ns = {0, NULL};
1011 static const WS_XML_STRING prefix_s = {1, (BYTE *)"s"}, prefix_a = {1, (BYTE *)"a"};
1012 const WS_XML_STRING *prefix_env = (msg->version_env == WS_ENVELOPE_VERSION_NONE) ? NULL : &prefix_s;
1013 const WS_XML_STRING *prefix_addr = (msg->version_addr == WS_ADDRESSING_VERSION_TRANSPORT) ? NULL : &prefix_a;
1014 const WS_XML_STRING *localname = get_header_name( type );
1015 HRESULT hr;
1016
1017 if ((hr = WsWriteStartElement( msg->writer, prefix_addr, localname, &ns, NULL )) != S_OK) return hr;
1018 if ((hr = write_must_understand( msg->writer, prefix_env, &ns )) != S_OK) return hr;
1019 if (msg->version_addr == WS_ADDRESSING_VERSION_TRANSPORT)
1020 {
1021 const WS_XML_STRING *ns_addr = get_addr_namespace( WS_ADDRESSING_VERSION_TRANSPORT );
1022 if ((hr = WsWriteXmlnsAttribute( msg->writer, NULL, ns_addr, FALSE, NULL )) != S_OK) return hr;
1023 }
1024 if ((hr = WsWriteType( msg->writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, value_type, NULL, option, value, size,
1025 NULL )) != S_OK) return hr;
1026 return WsWriteEndElement( msg->writer, NULL );
1027 }
1028
1029 static HRESULT build_standard_header( struct msg *msg, WS_HEADER_TYPE type, WS_TYPE value_type,
1030 WS_WRITE_OPTION option, const void *value, ULONG size,
1031 struct header **ret )
1032 {
1033 struct header *header;
1034 WS_XML_BUFFER *buf;
1035 HRESULT hr;
1036
1037 if (!(header = alloc_header( type, FALSE, get_header_name(type), NULL ))) return E_OUTOFMEMORY;
1038
1039 if (!msg->writer && (hr = WsCreateWriter( NULL, 0, &msg->writer, NULL )) != S_OK) goto done;
1040 if ((hr = WsCreateXmlBuffer( msg->heap, NULL, 0, &buf, NULL )) != S_OK) goto done;
1041 if ((hr = WsSetOutputToBuffer( msg->writer, buf, NULL, 0, NULL )) != S_OK) goto done;
1042 if ((hr = write_standard_header( msg, type, value_type, option, value, size )) != S_OK) goto done;
1043
1044 header->u.buf = buf;
1045
1046 done:
1047 if (hr != S_OK) free_header( header );
1048 else *ret = header;
1049 return hr;
1050 }
1051
1052 /**************************************************************************
1053 * WsSetHeader [webservices.@]
1054 */
1055 HRESULT WINAPI WsSetHeader( WS_MESSAGE *handle, WS_HEADER_TYPE type, WS_TYPE value_type,
1056 WS_WRITE_OPTION option, const void *value, ULONG size, WS_ERROR *error )
1057 {
1058 struct msg *msg = (struct msg *)handle;
1059 struct header *header;
1060 BOOL found = FALSE;
1061 HRESULT hr;
1062 ULONG i;
1063
1064 TRACE( "%p %u %u %08x %p %u %p\n", handle, type, value_type, option, value, size, error );
1065 if (error) FIXME( "ignoring error parameter\n" );
1066
1067 if (!msg || type < WS_ACTION_HEADER || type > WS_FAULT_TO_HEADER) return E_INVALIDARG;
1068
1069 EnterCriticalSection( &msg->cs );
1070
1071 if (msg->magic != MSG_MAGIC)
1072 {
1073 LeaveCriticalSection( &msg->cs );
1074 return E_INVALIDARG;
1075 }
1076
1077 if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
1078 {
1079 LeaveCriticalSection( &msg->cs );
1080 return WS_E_INVALID_OPERATION;
1081 }
1082
1083 for (i = 0; i < msg->header_count; i++)
1084 {
1085 if (msg->header[i]->type == type)
1086 {
1087 found = TRUE;
1088 break;
1089 }
1090 }
1091
1092 if (!found)
1093 {
1094 if ((hr = grow_header_array( msg, msg->header_count + 1 )) != S_OK) goto done;
1095 i = msg->header_count;
1096 }
1097
1098 if ((hr = build_standard_header( msg, type, value_type, option, value, size, &header )) != S_OK)
1099 goto done;
1100
1101 if (!found) msg->header_count++;
1102 else free_header( msg->header[i] );
1103
1104 msg->header[i] = header;
1105 hr = write_envelope( msg );
1106
1107 done:
1108 LeaveCriticalSection( &msg->cs );
1109 return hr;
1110 }
1111
1112 static HRESULT find_header( WS_XML_READER *reader, const WS_XML_STRING *localname, const WS_XML_STRING *ns )
1113 {
1114 const WS_XML_NODE *node;
1115 const WS_XML_ELEMENT_NODE *elem;
1116 HRESULT hr;
1117
1118 for (;;)
1119 {
1120 if ((hr = WsReadNode( reader, NULL )) != S_OK) return hr;
1121 if ((hr = WsGetReaderNode( reader, &node, NULL )) != S_OK) return hr;
1122 if (node->nodeType == WS_XML_NODE_TYPE_EOF) return WS_E_INVALID_FORMAT;
1123 if (node->nodeType != WS_XML_NODE_TYPE_ELEMENT) continue;
1124
1125 elem = (const WS_XML_ELEMENT_NODE *)node;
1126 if (WsXmlStringEquals( elem->localName, localname, NULL ) == S_OK &&
1127 WsXmlStringEquals( elem->ns, ns, NULL ) == S_OK) break;
1128 }
1129
1130 return S_OK;
1131 }
1132
1133 static HRESULT get_standard_header( struct msg *msg, WS_HEADER_TYPE type, WS_TYPE value_type,
1134 WS_READ_OPTION option, WS_HEAP *heap, void *value, ULONG size )
1135 {
1136 const WS_XML_STRING *localname = get_header_name( type );
1137 const WS_XML_STRING *ns = get_addr_namespace( msg->version_addr );
1138 HRESULT hr;
1139
1140 if (!heap) heap = msg->heap;
1141 if (!msg->reader && (hr = WsCreateReader( NULL, 0, &msg->reader, NULL )) != S_OK) return hr;
1142 if ((hr = WsSetInputToBuffer( msg->reader, msg->buf, NULL, 0, NULL )) != S_OK) return hr;
1143
1144 if ((hr = find_header( msg->reader, localname, ns )) != S_OK) return hr;
1145 return read_header( msg->reader, localname, ns, value_type, NULL, option, heap, value, size );
1146 }
1147
1148 /**************************************************************************
1149 * WsGetHeader [webservices.@]
1150 */
1151 HRESULT WINAPI WsGetHeader( WS_MESSAGE *handle, WS_HEADER_TYPE type, WS_TYPE value_type, WS_READ_OPTION option,
1152 WS_HEAP *heap, void *value, ULONG size, WS_ERROR *error )
1153 {
1154 struct msg *msg = (struct msg *)handle;
1155 HRESULT hr;
1156
1157 TRACE( "%p %u %u %08x %p %p %u %p\n", handle, type, value_type, option, heap, value, size, error );
1158 if (error) FIXME( "ignoring error parameter\n" );
1159
1160 if (!msg || type < WS_ACTION_HEADER || type > WS_FAULT_TO_HEADER || option < WS_READ_REQUIRED_VALUE ||
1161 option > WS_READ_OPTIONAL_POINTER) return E_INVALIDARG;
1162
1163 EnterCriticalSection( &msg->cs );
1164
1165 if (msg->magic != MSG_MAGIC)
1166 {
1167 LeaveCriticalSection( &msg->cs );
1168 return E_INVALIDARG;
1169 }
1170
1171 if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
1172 {
1173 LeaveCriticalSection( &msg->cs );
1174 return WS_E_INVALID_OPERATION;
1175 }
1176
1177 hr = get_standard_header( msg, type, value_type, option, heap, value, size );
1178
1179 LeaveCriticalSection( &msg->cs );
1180 return hr;
1181 }
1182
1183 static void remove_header( struct msg *msg, ULONG i )
1184 {
1185 free_header( msg->header[i] );
1186 memmove( &msg->header[i], &msg->header[i + 1], (msg->header_count - i - 1) * sizeof(struct header *) );
1187 msg->header_count--;
1188 }
1189
1190 /**************************************************************************
1191 * WsRemoveHeader [webservices.@]
1192 */
1193 HRESULT WINAPI WsRemoveHeader( WS_MESSAGE *handle, WS_HEADER_TYPE type, WS_ERROR *error )
1194 {
1195 struct msg *msg = (struct msg *)handle;
1196 BOOL removed = FALSE;
1197 HRESULT hr = S_OK;
1198 ULONG i;
1199
1200 TRACE( "%p %u %p\n", handle, type, error );
1201 if (error) FIXME( "ignoring error parameter\n" );
1202
1203 if (!msg) return E_INVALIDARG;
1204
1205 EnterCriticalSection( &msg->cs );
1206
1207 if (msg->magic != MSG_MAGIC)
1208 {
1209 LeaveCriticalSection( &msg->cs );
1210 return E_INVALIDARG;
1211 }
1212
1213 if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
1214 {
1215 LeaveCriticalSection( &msg->cs );
1216 return WS_E_INVALID_OPERATION;
1217 }
1218
1219 if (type < WS_ACTION_HEADER || type > WS_FAULT_TO_HEADER)
1220 {
1221 LeaveCriticalSection( &msg->cs );
1222 return E_INVALIDARG;
1223 }
1224
1225 for (i = 0; i < msg->header_count; i++)
1226 {
1227 if (msg->header[i]->type == type)
1228 {
1229 remove_header( msg, i );
1230 removed = TRUE;
1231 break;
1232 }
1233 }
1234
1235 if (removed) hr = write_envelope( msg );
1236
1237 LeaveCriticalSection( &msg->cs );
1238 return hr;
1239 }
1240
1241 static HRESULT build_mapped_header( const WS_XML_STRING *name, WS_TYPE type, WS_WRITE_OPTION option,
1242 const void *value, ULONG size, struct header **ret )
1243 {
1244 struct header *header;
1245
1246 if (!(header = alloc_header( 0, TRUE, name, NULL ))) return E_OUTOFMEMORY;
1247 switch (type)
1248 {
1249 case WS_WSZ_TYPE:
1250 {
1251 int len;
1252 const WCHAR *src;
1253
1254 if (option != WS_WRITE_REQUIRED_POINTER || size != sizeof(WCHAR *))
1255 {
1256 free_header( header );
1257 return E_INVALIDARG;
1258 }
1259 src = *(const WCHAR **)value;
1260 len = WideCharToMultiByte( CP_UTF8, 0, src, -1, NULL, 0, NULL, NULL ) - 1;
1261 if (!(header->u.text = alloc_xml_string( NULL, len )))
1262 {
1263 free_header( header );
1264 return E_OUTOFMEMORY;
1265 }
1266 WideCharToMultiByte( CP_UTF8, 0, src, -1, (char *)header->u.text->bytes, len, NULL, NULL );
1267 break;
1268 }
1269 case WS_XML_STRING_TYPE:
1270 {
1271 const WS_XML_STRING *str = value;
1272
1273 if (option != WS_WRITE_REQUIRED_VALUE)
1274 {
1275 FIXME( "unhandled write option %u\n", option );
1276 free_header( header );
1277 return E_NOTIMPL;
1278 }
1279 if (size != sizeof(*str))
1280 {
1281 free_header( header );
1282 return E_INVALIDARG;
1283 }
1284 if (!(header->u.text = alloc_xml_string( NULL, str->length )))
1285 {
1286 free_header( header );
1287 return E_OUTOFMEMORY;
1288 }
1289 memcpy( header->u.text->bytes, str->bytes, str->length );
1290 break;
1291 }
1292 case WS_STRING_TYPE:
1293 {
1294 int len;
1295 const WS_STRING *str = value;
1296
1297 if (option != WS_WRITE_REQUIRED_VALUE)
1298 {
1299 FIXME( "unhandled write option %u\n", option );
1300 free_header( header );
1301 return E_NOTIMPL;
1302 }
1303 if (size != sizeof(*str))
1304 {
1305 free_header( header );
1306 return E_INVALIDARG;
1307 }
1308 len = WideCharToMultiByte( CP_UTF8, 0, str->chars, str->length, NULL, 0, NULL, NULL );
1309 if (!(header->u.text = alloc_xml_string( NULL, len )))
1310 {
1311 free_header( header );
1312 return E_OUTOFMEMORY;
1313 }
1314 WideCharToMultiByte( CP_UTF8, 0, str->chars, str->length, (char *)header->u.text->bytes,
1315 len, NULL, NULL );
1316 break;
1317 }
1318 default:
1319 FIXME( "unhandled type %u\n", type );
1320 free_header( header );
1321 return E_NOTIMPL;
1322 }
1323
1324 *ret = header;
1325 return S_OK;
1326 }
1327
1328 /**************************************************************************
1329 * WsAddMappedHeader [webservices.@]
1330 */
1331 HRESULT WINAPI WsAddMappedHeader( WS_MESSAGE *handle, const WS_XML_STRING *name, WS_TYPE type,
1332 WS_WRITE_OPTION option, const void *value, ULONG size, WS_ERROR *error )
1333 {
1334 struct msg *msg = (struct msg *)handle;
1335 struct header *header;
1336 BOOL found = FALSE;
1337 HRESULT hr;
1338 ULONG i;
1339
1340 TRACE( "%p %s %u %08x %p %u %p\n", handle, debugstr_xmlstr(name), type, option, value, size, error );
1341 if (error) FIXME( "ignoring error parameter\n" );
1342
1343 if (!msg || !name) return E_INVALIDARG;
1344
1345 EnterCriticalSection( &msg->cs );
1346
1347 if (msg->magic != MSG_MAGIC)
1348 {
1349 LeaveCriticalSection( &msg->cs );
1350 return E_INVALIDARG;
1351 }
1352
1353 if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
1354 {
1355 LeaveCriticalSection( &msg->cs );
1356 return WS_E_INVALID_OPERATION;
1357 }
1358
1359 for (i = 0; i < msg->header_count; i++)
1360 {
1361 if (msg->header[i]->type || !msg->header[i]->mapped) continue;
1362 if (WsXmlStringEquals( name, &msg->header[i]->name, NULL ) == S_OK)
1363 {
1364 found = TRUE;
1365 break;
1366 }
1367 }
1368
1369 if (!found)
1370 {
1371 if ((hr = grow_header_array( msg, msg->header_count + 1 )) != S_OK) goto done;
1372 i = msg->header_count;
1373 }
1374
1375 if ((hr = build_mapped_header( name, type, option, value, size, &header )) != S_OK) goto done;
1376
1377 if (!found) msg->header_count++;
1378 else free_header( msg->header[i] );
1379
1380 msg->header[i] = header;
1381
1382 done:
1383 LeaveCriticalSection( &msg->cs );
1384 return hr;
1385 }
1386
1387 /**************************************************************************
1388 * WsRemoveMappedHeader [webservices.@]
1389 */
1390 HRESULT WINAPI WsRemoveMappedHeader( WS_MESSAGE *handle, const WS_XML_STRING *name, WS_ERROR *error )
1391 {
1392 struct msg *msg = (struct msg *)handle;
1393 ULONG i;
1394
1395 TRACE( "%p %s %p\n", handle, debugstr_xmlstr(name), error );
1396 if (error) FIXME( "ignoring error parameter\n" );
1397
1398 if (!msg || !name) return E_INVALIDARG;
1399
1400 EnterCriticalSection( &msg->cs );
1401
1402 if (msg->magic != MSG_MAGIC)
1403 {
1404 LeaveCriticalSection( &msg->cs );
1405 return E_INVALIDARG;
1406 }
1407
1408 if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
1409 {
1410 LeaveCriticalSection( &msg->cs );
1411 return WS_E_INVALID_OPERATION;
1412 }
1413
1414 for (i = 0; i < msg->header_count; i++)
1415 {
1416 if (msg->header[i]->type || !msg->header[i]->mapped) continue;
1417 if (WsXmlStringEquals( name, &msg->header[i]->name, NULL ) == S_OK)
1418 {
1419 remove_header( msg, i );
1420 break;
1421 }
1422 }
1423
1424 LeaveCriticalSection( &msg->cs );
1425 return S_OK;
1426 }
1427
1428 static HRESULT write_custom_header( WS_XML_WRITER *writer, const WS_XML_STRING *name, const WS_XML_STRING *ns,
1429 WS_TYPE type, const void *desc, WS_WRITE_OPTION option, const void *value,
1430 ULONG size )
1431 {
1432 HRESULT hr;
1433 if ((hr = WsWriteStartElement( writer, NULL, name, ns, NULL )) != S_OK) return hr;
1434 if ((hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, type, desc, option, value, size,
1435 NULL )) != S_OK) return hr;
1436 return WsWriteEndElement( writer, NULL );
1437 }
1438
1439 static HRESULT build_custom_header( struct msg *msg, const WS_XML_STRING *name, const WS_XML_STRING *ns,
1440 WS_TYPE type, const void *desc, WS_WRITE_OPTION option, const void *value,
1441 ULONG size, struct header **ret )
1442 {
1443 struct header *header;
1444 WS_XML_BUFFER *buf;
1445 HRESULT hr;
1446
1447 if (!(header = alloc_header( 0, FALSE, name, ns ))) return E_OUTOFMEMORY;
1448
1449 if (!msg->writer && (hr = WsCreateWriter( NULL, 0, &msg->writer, NULL )) != S_OK) goto done;
1450 if ((hr = WsCreateXmlBuffer( msg->heap, NULL, 0, &buf, NULL )) != S_OK) goto done;
1451 if ((hr = WsSetOutputToBuffer( msg->writer, buf, NULL, 0, NULL )) != S_OK) goto done;
1452 if ((hr = write_custom_header( msg->writer, name, ns, type, desc, option, value, size )) != S_OK) goto done;
1453
1454 header->u.buf = buf;
1455
1456 done:
1457 if (hr != S_OK) free_header( header );
1458 else *ret = header;
1459 return hr;
1460 }
1461
1462 /**************************************************************************
1463 * WsAddCustomHeader [webservices.@]
1464 */
1465 HRESULT WINAPI WsAddCustomHeader( WS_MESSAGE *handle, const WS_ELEMENT_DESCRIPTION *desc, WS_WRITE_OPTION option,
1466 const void *value, ULONG size, ULONG attrs, WS_ERROR *error )
1467 {
1468 struct msg *msg = (struct msg *)handle;
1469 struct header *header;
1470 HRESULT hr;
1471
1472 TRACE( "%p %p %08x %p %u %08x %p\n", handle, desc, option, value, size, attrs, error );
1473 if (error) FIXME( "ignoring error parameter\n" );
1474
1475 if (!msg || !desc) return E_INVALIDARG;
1476
1477 EnterCriticalSection( &msg->cs );
1478
1479 if (msg->magic != MSG_MAGIC)
1480 {
1481 LeaveCriticalSection( &msg->cs );
1482 return E_INVALIDARG;
1483 }
1484
1485 if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
1486 {
1487 LeaveCriticalSection( &msg->cs );
1488 return WS_E_INVALID_OPERATION;
1489 }
1490
1491 if ((hr = grow_header_array( msg, msg->header_count + 1 )) != S_OK) goto done;
1492 if ((hr = build_custom_header( msg, desc->elementLocalName, desc->elementNs, desc->type,
1493 desc->typeDescription, option, value, size, &header )) != S_OK) goto done;
1494 msg->header[msg->header_count++] = header;
1495 hr = write_envelope( msg );
1496
1497 done:
1498 LeaveCriticalSection( &msg->cs );
1499 return hr;
1500 }
1501
1502 static HRESULT get_custom_header( struct msg *msg, const WS_ELEMENT_DESCRIPTION *desc, WS_READ_OPTION option,
1503 WS_HEAP *heap, void *value, ULONG size )
1504 {
1505 HRESULT hr;
1506 if (!heap) heap = msg->heap;
1507 if (!msg->reader && (hr = WsCreateReader( NULL, 0, &msg->reader, NULL )) != S_OK) return hr;
1508 if ((hr = WsSetInputToBuffer( msg->reader, msg->buf, NULL, 0, NULL )) != S_OK) return hr;
1509
1510 if ((hr = find_header( msg->reader, desc->elementLocalName, desc->elementNs )) != S_OK) return hr;
1511 return read_header( msg->reader, desc->elementLocalName, desc->elementNs, desc->type, desc->typeDescription,
1512 option, heap, value, size );
1513 }
1514
1515 /**************************************************************************
1516 * WsGetCustomHeader [webservices.@]
1517 */
1518 HRESULT WINAPI WsGetCustomHeader( WS_MESSAGE *handle, const WS_ELEMENT_DESCRIPTION *desc,
1519 WS_REPEATING_HEADER_OPTION repeat_option, ULONG index, WS_READ_OPTION option,
1520 WS_HEAP *heap, void *value, ULONG size, ULONG *attrs, WS_ERROR *error )
1521 {
1522 struct msg *msg = (struct msg *)handle;
1523 HRESULT hr;
1524
1525 TRACE( "%p %p %08x %u %08x %p %p %u %p %p\n", handle, desc, repeat_option, index, option, heap, value,
1526 size, attrs, error );
1527 if (error) FIXME( "ignoring error parameter\n" );
1528
1529 if (!msg || !desc || repeat_option < WS_REPEATING_HEADER || repeat_option > WS_SINGLETON_HEADER ||
1530 (repeat_option == WS_SINGLETON_HEADER && index)) return E_INVALIDARG;
1531
1532 if (repeat_option == WS_REPEATING_HEADER)
1533 {
1534 FIXME( "repeating header not supported\n" );
1535 return E_NOTIMPL;
1536 }
1537 if (attrs)
1538 {
1539 FIXME( "attributes not supported\n" );
1540 return E_NOTIMPL;
1541 }
1542
1543 EnterCriticalSection( &msg->cs );
1544
1545 if (msg->magic != MSG_MAGIC)
1546 {
1547 LeaveCriticalSection( &msg->cs );
1548 return E_INVALIDARG;
1549 }
1550
1551 if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
1552 {
1553 LeaveCriticalSection( &msg->cs );
1554 return WS_E_INVALID_OPERATION;
1555 }
1556
1557 hr = get_custom_header( msg, desc, option, heap, value, size );
1558
1559 LeaveCriticalSection( &msg->cs );
1560 return hr;
1561 }
1562
1563 /**************************************************************************
1564 * WsRemoveCustomHeader [webservices.@]
1565 */
1566 HRESULT WINAPI WsRemoveCustomHeader( WS_MESSAGE *handle, const WS_XML_STRING *name, const WS_XML_STRING *ns,
1567 WS_ERROR *error )
1568 {
1569 struct msg *msg = (struct msg *)handle;
1570 BOOL removed = FALSE;
1571 HRESULT hr = S_OK;
1572 ULONG i;
1573
1574 TRACE( "%p %s %s %p\n", handle, debugstr_xmlstr(name), debugstr_xmlstr(ns), error );
1575 if (error) FIXME( "ignoring error parameter\n" );
1576
1577 if (!msg || !name || !ns) return E_INVALIDARG;
1578
1579 EnterCriticalSection( &msg->cs );
1580
1581 if (msg->magic != MSG_MAGIC)
1582 {
1583 LeaveCriticalSection( &msg->cs );
1584 return E_INVALIDARG;
1585 }
1586
1587 if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
1588 {
1589 LeaveCriticalSection( &msg->cs );
1590 return WS_E_INVALID_OPERATION;
1591 }
1592
1593 for (i = 0; i < msg->header_count; i++)
1594 {
1595 if (msg->header[i]->type || msg->header[i]->mapped) continue;
1596 if (WsXmlStringEquals( name, &msg->header[i]->name, NULL ) == S_OK &&
1597 WsXmlStringEquals( ns, &msg->header[i]->ns, NULL ) == S_OK)
1598 {
1599 remove_header( msg, i );
1600 removed = TRUE;
1601 i--;
1602 }
1603 }
1604
1605 if (removed) hr = write_envelope( msg );
1606
1607 LeaveCriticalSection( &msg->cs );
1608 return hr;
1609 }
1610
1611 static WCHAR *build_http_header( const WCHAR *name, const WCHAR *value, ULONG *ret_len )
1612 {
1613 static const WCHAR fmtW[] = {'%','s',':',' ','%','s',0};
1614 WCHAR *ret = heap_alloc( (strlenW(name) + strlenW(value) + 3) * sizeof(WCHAR) );
1615 if (ret) *ret_len = sprintfW( ret, fmtW, name, value );
1616 return ret;
1617 }
1618
1619 static inline HRESULT insert_http_header( HINTERNET req, const WCHAR *header, ULONG len, ULONG flags )
1620 {
1621 if (WinHttpAddRequestHeaders( req, header, len, flags )) return S_OK;
1622 return HRESULT_FROM_WIN32( GetLastError() );
1623 }
1624
1625 HRESULT message_insert_http_headers( WS_MESSAGE *handle, HINTERNET req )
1626 {
1627 static const WCHAR contenttypeW[] =
1628 {'C','o','n','t','e','n','t','-','T','y','p','e',0};
1629 static const WCHAR soapxmlW[] =
1630 {'a','p','p','l','i','c','a','t','i','o','n','/','s','o','a','p','+','x','m','l',0};
1631 static const WCHAR textxmlW[] =
1632 {'t','e','x','t','/','x','m','l',0};
1633 static const WCHAR charsetW[] =
1634 {'c','h','a','r','s','e','t','=','u','t','f','-','8',0};
1635 struct msg *msg = (struct msg *)handle;
1636 HRESULT hr = E_OUTOFMEMORY;
1637 WCHAR *header = NULL, *buf;
1638 ULONG len;
1639
1640 EnterCriticalSection( &msg->cs );
1641
1642 if (msg->magic != MSG_MAGIC)
1643 {
1644 LeaveCriticalSection( &msg->cs );
1645 return E_INVALIDARG;
1646 }
1647
1648 switch (msg->version_env)
1649 {
1650 case WS_ENVELOPE_VERSION_SOAP_1_1:
1651 header = build_http_header( contenttypeW, textxmlW, &len );
1652 break;
1653
1654 case WS_ENVELOPE_VERSION_SOAP_1_2:
1655 header = build_http_header( contenttypeW, soapxmlW, &len );
1656 break;
1657
1658 default:
1659 FIXME( "unhandled envelope version %u\n", msg->version_env );
1660 hr = E_NOTIMPL;
1661 }
1662 if (!header) goto done;
1663
1664 if ((hr = insert_http_header( req, header, len, WINHTTP_ADDREQ_FLAG_ADD )) != S_OK) goto done;
1665 heap_free( header );
1666
1667 hr = E_OUTOFMEMORY;
1668 if (!(header = build_http_header( contenttypeW, charsetW, &len ))) goto done;
1669 if ((hr = insert_http_header( req, header, len, WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON )) != S_OK)
1670 goto done;
1671 heap_free( header );
1672 header = NULL;
1673
1674 switch (msg->version_env)
1675 {
1676 case WS_ENVELOPE_VERSION_SOAP_1_1:
1677 {
1678 static const WCHAR soapactionW[] = {'S','O','A','P','A','c','t','i','o','n',0};
1679
1680 if (!(len = msg->action.length)) break;
1681
1682 hr = E_OUTOFMEMORY;
1683 if (!(buf = heap_alloc( (len + 3) * sizeof(WCHAR) ))) goto done;
1684 buf[0] = '"';
1685 memcpy( buf + 1, msg->action.chars, len * sizeof(WCHAR) );
1686 buf[len + 1] = '"';
1687 buf[len + 2] = 0;
1688
1689 header = build_http_header( soapactionW, buf, &len );
1690 heap_free( buf );
1691 if (!header) goto done;
1692
1693 hr = insert_http_header( req, header, len, WINHTTP_ADDREQ_FLAG_ADD );
1694 break;
1695 }
1696 case WS_ENVELOPE_VERSION_SOAP_1_2:
1697 {
1698 static const WCHAR actionW[] = {'a','c','t','i','o','n','=','"'};
1699 ULONG len_action = sizeof(actionW)/sizeof(actionW[0]);
1700
1701 if (!(len = msg->action.length)) break;
1702
1703 hr = E_OUTOFMEMORY;
1704 if (!(buf = heap_alloc( (len + len_action + 2) * sizeof(WCHAR) ))) goto done;
1705 memcpy( buf, actionW, len_action * sizeof(WCHAR) );
1706 memcpy( buf + len_action, msg->action.chars, len * sizeof(WCHAR) );
1707 len += len_action;
1708 buf[len++] = '"';
1709 buf[len] = 0;
1710
1711 header = build_http_header( contenttypeW, buf, &len );
1712 heap_free( buf );
1713 if (!header) goto done;
1714
1715 hr = insert_http_header( req, header, len, WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON );
1716 break;
1717 }
1718 default:
1719 FIXME( "unhandled envelope version %u\n", msg->version_env );
1720 hr = E_NOTIMPL;
1721 }
1722
1723 done:
1724 heap_free( header );
1725 LeaveCriticalSection( &msg->cs );
1726 return hr;
1727 }
1728
1729 void message_set_send_context( WS_MESSAGE *handle, const WS_PROXY_MESSAGE_CALLBACK_CONTEXT *ctx )
1730 {
1731 struct msg *msg = (struct msg *)handle;
1732
1733 EnterCriticalSection( &msg->cs );
1734
1735 if (msg->magic != MSG_MAGIC)
1736 {
1737 LeaveCriticalSection( &msg->cs );
1738 return;
1739 }
1740
1741 msg->ctx_send.callback = ctx->callback;
1742 msg->ctx_send.state = ctx->state;
1743
1744 LeaveCriticalSection( &msg->cs );
1745 }
1746
1747 void message_set_receive_context( WS_MESSAGE *handle, const WS_PROXY_MESSAGE_CALLBACK_CONTEXT *ctx )
1748 {
1749 struct msg *msg = (struct msg *)handle;
1750
1751 EnterCriticalSection( &msg->cs );
1752
1753 if (msg->magic != MSG_MAGIC)
1754 {
1755 LeaveCriticalSection( &msg->cs );
1756 return;
1757 }
1758
1759 msg->ctx_receive.callback = ctx->callback;
1760 msg->ctx_receive.state = ctx->state;
1761
1762 LeaveCriticalSection( &msg->cs );
1763 }
1764
1765 void message_do_send_callback( WS_MESSAGE *handle )
1766 {
1767 struct msg *msg = (struct msg *)handle;
1768
1769 EnterCriticalSection( &msg->cs );
1770
1771 if (msg->magic != MSG_MAGIC)
1772 {
1773 LeaveCriticalSection( &msg->cs );
1774 return;
1775 }
1776
1777 if (msg->ctx_send.callback)
1778 {
1779 HRESULT hr;
1780 TRACE( "executing callback %p\n", msg->ctx_send.callback );
1781 hr = msg->ctx_send.callback( handle, msg->heap, msg->ctx_send.state, NULL );
1782 TRACE( "callback %p returned %08x\n", msg->ctx_send.callback, hr );
1783 }
1784
1785 LeaveCriticalSection( &msg->cs );
1786 }
1787
1788 void message_do_receive_callback( WS_MESSAGE *handle )
1789 {
1790 struct msg *msg = (struct msg *)handle;
1791
1792 EnterCriticalSection( &msg->cs );
1793
1794 if (msg->magic != MSG_MAGIC)
1795 {
1796 LeaveCriticalSection( &msg->cs );
1797 return;
1798 }
1799
1800 if (msg->ctx_receive.callback)
1801 {
1802 HRESULT hr;
1803 TRACE( "executing callback %p\n", msg->ctx_receive.callback );
1804 hr = msg->ctx_receive.callback( handle, msg->heap, msg->ctx_receive.state, NULL );
1805 TRACE( "callback %p returned %08x\n", msg->ctx_receive.callback, hr );
1806 }
1807
1808 LeaveCriticalSection( &msg->cs );
1809 }
1810
1811 HRESULT message_set_action( WS_MESSAGE *handle, const WS_XML_STRING *action )
1812 {
1813 struct msg *msg = (struct msg *)handle;
1814 HRESULT hr = S_OK;
1815
1816 EnterCriticalSection( &msg->cs );
1817
1818 if (msg->magic != MSG_MAGIC)
1819 {
1820 LeaveCriticalSection( &msg->cs );
1821 return E_INVALIDARG;
1822 }
1823
1824 if (!action || !action->length)
1825 {
1826 heap_free( msg->action.chars );
1827 msg->action.chars = NULL;
1828 msg->action.length = 0;
1829 }
1830 else
1831 {
1832 WCHAR *chars;
1833 int len = MultiByteToWideChar( CP_UTF8, 0, (char *)action->bytes, action->length, NULL, 0 );
1834 if (!(chars = heap_alloc( len * sizeof(WCHAR) ))) hr = E_OUTOFMEMORY;
1835 else
1836 {
1837 MultiByteToWideChar( CP_UTF8, 0, (char *)action->bytes, action->length, chars, len );
1838 heap_free( msg->action.chars );
1839 msg->action.chars = chars;
1840 msg->action.length = len;
1841 }
1842 }
1843
1844 LeaveCriticalSection( &msg->cs );
1845 return hr;
1846 }
Windows API implementation