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