?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Drop support for WINED3DFMT_D32_UNORM.
[wine.git] / dlls / webservices / msg.c
blob31c424b8f007f701203059641017c084192a429b
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 /**************************************************************************
835 * WsFlushBody [webservices.@]
836 */
837 HRESULT WINAPI WsFlushBody( WS_MESSAGE *handle, ULONG size, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
838 {
839 struct msg *msg = (struct msg *)handle;
840 HRESULT hr;
841
842 TRACE( "%p %u %p %p\n", handle, size, ctx, error );
843
844 if (!msg) return E_INVALIDARG;
845
846 EnterCriticalSection( &msg->cs );
847
848 if (msg->magic != MSG_MAGIC)
849 {
850 LeaveCriticalSection( &msg->cs );
851 return E_INVALIDARG;
852 }
853
854 hr = WsFlushWriter( msg->writer_body, size, ctx, error );
855
856 LeaveCriticalSection( &msg->cs );
857 TRACE( "returning %08x\n", hr );
858 return hr;
859 }
860
861 static BOOL match_current_element( WS_XML_READER *reader, const WS_XML_STRING *localname )
862 {
863 const WS_XML_NODE *node;
864 const WS_XML_ELEMENT_NODE *elem;
865
866 if (WsGetReaderNode( reader, &node, NULL ) != S_OK) return FALSE;
867 if (node->nodeType != WS_XML_NODE_TYPE_ELEMENT) return FALSE;
868 elem = (const WS_XML_ELEMENT_NODE *)node;
869 return WsXmlStringEquals( elem->localName, localname, NULL ) == S_OK;
870 }
871
872 static HRESULT read_message_id( WS_XML_READER *reader, GUID *ret )
873 {
874 const WS_XML_NODE *node;
875 const WS_XML_TEXT_NODE *text;
876 HRESULT hr;
877
878 if ((hr = WsReadNode( reader, NULL )) != S_OK) return hr;
879 if ((hr = WsGetReaderNode( reader, &node, NULL )) != S_OK) return hr;
880 if (node->nodeType != WS_XML_NODE_TYPE_TEXT) return WS_E_INVALID_FORMAT;
881 text = (const WS_XML_TEXT_NODE *)node;
882
883 switch (text->text->textType)
884 {
885 case WS_XML_TEXT_TYPE_UTF8:
886 {
887 const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text->text;
888 if (utf8->value.length != 45 || memcmp( utf8->value.bytes, "urn:uuid:", 9 ))
889 return WS_E_INVALID_FORMAT;
890
891 return str_to_guid( utf8->value.bytes + 9, utf8->value.length - 9, ret );
892 }
893 case WS_XML_TEXT_TYPE_UNIQUE_ID:
894 {
895 const WS_XML_UNIQUE_ID_TEXT *id = (const WS_XML_UNIQUE_ID_TEXT *)text->text;
896 *ret = id->value;
897 return S_OK;
898 }
899 default:
900 FIXME( "unhandled text type %u\n", text->text->textType );
901 return E_NOTIMPL;
902 }
903 }
904
905 static HRESULT read_envelope_start( struct msg *msg, WS_XML_READER *reader )
906 {
907 static const WS_XML_STRING envelope = {8, (BYTE *)"Envelope"}, body = {4, (BYTE *)"Body"};
908 static const WS_XML_STRING header = {6, (BYTE *)"Header"}, msgid = {9, (BYTE *)"MessageID"};
909 HRESULT hr;
910
911 if ((hr = WsReadNode( reader, NULL )) != S_OK) return hr;
912 if (!match_current_element( reader, &envelope )) return WS_E_INVALID_FORMAT;
913 if ((hr = WsReadNode( reader, NULL )) != S_OK) return hr;
914 if (match_current_element( reader, &header ))
915 {
916 for (;;)
917 {
918 if ((hr = WsReadNode( reader, NULL )) != S_OK) return hr;
919 if (match_current_element( reader, &msgid ) && (hr = read_message_id( reader, &msg->id_req )) != S_OK)
920 return hr;
921 if (match_current_element( reader, &body )) break;
922 }
923 }
924 if (!match_current_element( reader, &body )) return WS_E_INVALID_FORMAT;
925 return WsReadNode( reader, NULL );
926 }
927
928 /**************************************************************************
929 * WsReadEnvelopeStart [webservices.@]
930 */
931 HRESULT WINAPI WsReadEnvelopeStart( WS_MESSAGE *handle, WS_XML_READER *reader, WS_MESSAGE_DONE_CALLBACK cb,
932 void *state, WS_ERROR *error )
933 {
934 struct msg *msg = (struct msg *)handle;
935 HRESULT hr;
936
937 TRACE( "%p %p %p %p %p\n", handle, reader, cb, state, error );
938 if (error) FIXME( "ignoring error parameter\n" );
939 if (cb)
940 {
941 FIXME( "callback not supported\n" );
942 return E_NOTIMPL;
943 }
944
945 if (!msg || !reader) return E_INVALIDARG;
946
947 EnterCriticalSection( &msg->cs );
948
949 if (msg->magic != MSG_MAGIC)
950 {
951 LeaveCriticalSection( &msg->cs );
952 return E_INVALIDARG;
953 }
954
955 if (msg->state != WS_MESSAGE_STATE_EMPTY) hr = WS_E_INVALID_OPERATION;
956 else if ((hr = read_envelope_start( msg, reader )) == S_OK &&
957 (hr = create_header_buffer( reader, msg->heap, &msg->buf )) == S_OK)
958 {
959 msg->reader_body = reader;
960 msg->state = WS_MESSAGE_STATE_READING;
961 }
962
963 LeaveCriticalSection( &msg->cs );
964 TRACE( "returning %08x\n", hr );
965 return hr;
966 }
967
968 /**************************************************************************
969 * WsReadEnvelopeEnd [webservices.@]
970 */
971 HRESULT WINAPI WsReadEnvelopeEnd( WS_MESSAGE *handle, WS_ERROR *error )
972 {
973 struct msg *msg = (struct msg *)handle;
974 HRESULT hr;
975
976 TRACE( "%p %p\n", handle, error );
977 if (error) FIXME( "ignoring error parameter\n" );
978
979 if (!msg) return E_INVALIDARG;
980
981 EnterCriticalSection( &msg->cs );
982
983 if (msg->magic != MSG_MAGIC)
984 {
985 LeaveCriticalSection( &msg->cs );
986 return E_INVALIDARG;
987 }
988
989 if (msg->state != WS_MESSAGE_STATE_READING) hr = WS_E_INVALID_OPERATION;
990 else if ((hr = WsReadEndElement( msg->reader_body, NULL )) == S_OK)
991 msg->state = WS_MESSAGE_STATE_DONE;
992
993 LeaveCriticalSection( &msg->cs );
994 TRACE( "returning %08x\n", hr );
995 return hr;
996 }
997
998 /**************************************************************************
999 * WsReadBody [webservices.@]
1000 */
1001 HRESULT WINAPI WsReadBody( WS_MESSAGE *handle, const WS_ELEMENT_DESCRIPTION *desc, WS_READ_OPTION option,
1002 WS_HEAP *heap, void *value, ULONG size, WS_ERROR *error )
1003 {
1004 struct msg *msg = (struct msg *)handle;
1005 HRESULT hr;
1006
1007 TRACE( "%p %p %08x %p %p %u %p\n", handle, desc, option, heap, value, size, error );
1008 if (error) FIXME( "ignoring error parameter\n" );
1009
1010 if (!msg || !desc) return E_INVALIDARG;
1011
1012 EnterCriticalSection( &msg->cs );
1013
1014 if (msg->magic != MSG_MAGIC)
1015 {
1016 LeaveCriticalSection( &msg->cs );
1017 return E_INVALIDARG;
1018 }
1019
1020 if (msg->state != WS_MESSAGE_STATE_READING) hr = WS_E_INVALID_OPERATION;
1021 else hr = WsReadElement( msg->reader_body, desc, option, heap, value, size, NULL );
1022
1023 LeaveCriticalSection( &msg->cs );
1024 TRACE( "returning %08x\n", hr );
1025 return hr;
1026 }
1027
1028 /**************************************************************************
1029 * WsFillBody [webservices.@]
1030 */
1031 HRESULT WINAPI WsFillBody( WS_MESSAGE *handle, ULONG size, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
1032 {
1033 struct msg *msg = (struct msg *)handle;
1034 HRESULT hr;
1035
1036 TRACE( "%p %u %p %p\n", handle, size, ctx, error );
1037
1038 if (!msg) return E_INVALIDARG;
1039
1040 EnterCriticalSection( &msg->cs );
1041
1042 if (msg->magic != MSG_MAGIC)
1043 {
1044 LeaveCriticalSection( &msg->cs );
1045 return E_INVALIDARG;
1046 }
1047
1048 hr = WsFillReader( msg->reader_body, size, ctx, error );
1049
1050 LeaveCriticalSection( &msg->cs );
1051 TRACE( "returning %08x\n", hr );
1052 return hr;
1053 }
1054
1055 /**************************************************************************
1056 * WsInitializeMessage [webservices.@]
1057 */
1058 HRESULT WINAPI WsInitializeMessage( WS_MESSAGE *handle, WS_MESSAGE_INITIALIZATION init,
1059 WS_MESSAGE *src_handle, WS_ERROR *error )
1060 {
1061 struct msg *msg = (struct msg *)handle;
1062 HRESULT hr;
1063
1064 TRACE( "%p %u %p %p\n", handle, init, src_handle, error );
1065 if (error) FIXME( "ignoring error parameter\n" );
1066 if (src_handle)
1067 {
1068 FIXME( "src message not supported\n" );
1069 return E_NOTIMPL;
1070 }
1071
1072 if (!msg || init > WS_FAULT_MESSAGE) return E_INVALIDARG;
1073
1074 EnterCriticalSection( &msg->cs );
1075
1076 if (msg->magic != MSG_MAGIC)
1077 {
1078 LeaveCriticalSection( &msg->cs );
1079 return E_INVALIDARG;
1080 }
1081
1082 if (msg->state >= WS_MESSAGE_STATE_INITIALIZED) hr = WS_E_INVALID_OPERATION;
1083 else if ((hr = write_envelope( msg )) == S_OK)
1084 {
1085 msg->init = init;
1086 msg->state = WS_MESSAGE_STATE_INITIALIZED;
1087 }
1088
1089 LeaveCriticalSection( &msg->cs );
1090 TRACE( "returning %08x\n", hr );
1091 return hr;
1092 }
1093
1094 static HRESULT grow_header_array( struct msg *msg, ULONG size )
1095 {
1096 struct header **tmp;
1097 if (size <= msg->header_size) return S_OK;
1098 if (!(tmp = heap_realloc( msg->header, 2 * msg->header_size * sizeof(struct header *) )))
1099 return E_OUTOFMEMORY;
1100 msg->header = tmp;
1101 msg->header_size *= 2;
1102 return S_OK;
1103 }
1104
1105 static struct header *alloc_header( WS_HEADER_TYPE type, BOOL mapped, const WS_XML_STRING *name,
1106 const WS_XML_STRING *ns )
1107 {
1108 struct header *ret;
1109 if (!(ret = heap_alloc_zero( sizeof(*ret) ))) return NULL;
1110 if (name && name->length)
1111 {
1112 if (!(ret->name.bytes = heap_alloc( name->length )))
1113 {
1114 free_header( ret );
1115 return NULL;
1116 }
1117 memcpy( ret->name.bytes, name->bytes, name->length );
1118 ret->name.length = name->length;
1119 }
1120 if (ns && ns->length)
1121 {
1122 if (!(ret->ns.bytes = heap_alloc( ns->length )))
1123 {
1124 free_header( ret );
1125 return NULL;
1126 }
1127 memcpy( ret->ns.bytes, ns->bytes, ns->length );
1128 ret->ns.length = ns->length;
1129 }
1130 ret->type = type;
1131 ret->mapped = mapped;
1132 return ret;
1133 }
1134
1135 static HRESULT write_standard_header( struct msg *msg, WS_HEADER_TYPE type, WS_TYPE value_type,
1136 WS_WRITE_OPTION option, const void *value, ULONG size )
1137 {
1138 static const WS_XML_STRING ns = {0, NULL};
1139 static const WS_XML_STRING prefix_s = {1, (BYTE *)"s"}, prefix_a = {1, (BYTE *)"a"};
1140 const WS_XML_STRING *prefix_env = (msg->version_env == WS_ENVELOPE_VERSION_NONE) ? NULL : &prefix_s;
1141 const WS_XML_STRING *prefix_addr = (msg->version_addr == WS_ADDRESSING_VERSION_TRANSPORT) ? NULL : &prefix_a;
1142 const WS_XML_STRING *localname = get_header_name( type );
1143 HRESULT hr;
1144
1145 if ((hr = WsWriteStartElement( msg->writer, prefix_addr, localname, &ns, NULL )) != S_OK) return hr;
1146 if ((hr = write_must_understand( msg->writer, prefix_env, &ns )) != S_OK) return hr;
1147 if (msg->version_addr == WS_ADDRESSING_VERSION_TRANSPORT)
1148 {
1149 const WS_XML_STRING *ns_addr = get_addr_namespace( WS_ADDRESSING_VERSION_TRANSPORT );
1150 if ((hr = WsWriteXmlnsAttribute( msg->writer, NULL, ns_addr, FALSE, NULL )) != S_OK) return hr;
1151 }
1152 if ((hr = WsWriteType( msg->writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, value_type, NULL, option, value, size,
1153 NULL )) != S_OK) return hr;
1154 return WsWriteEndElement( msg->writer, NULL );
1155 }
1156
1157 static HRESULT build_standard_header( struct msg *msg, WS_HEADER_TYPE type, WS_TYPE value_type,
1158 WS_WRITE_OPTION option, const void *value, ULONG size,
1159 struct header **ret )
1160 {
1161 struct header *header;
1162 WS_XML_BUFFER *buf;
1163 HRESULT hr;
1164
1165 if (!(header = alloc_header( type, FALSE, get_header_name(type), NULL ))) return E_OUTOFMEMORY;
1166
1167 if (!msg->writer && (hr = WsCreateWriter( NULL, 0, &msg->writer, NULL )) != S_OK) goto done;
1168 if ((hr = WsCreateXmlBuffer( msg->heap, NULL, 0, &buf, NULL )) != S_OK) goto done;
1169 if ((hr = WsSetOutputToBuffer( msg->writer, buf, NULL, 0, NULL )) != S_OK) goto done;
1170 if ((hr = write_standard_header( msg, type, value_type, option, value, size )) != S_OK) goto done;
1171
1172 header->u.buf = buf;
1173
1174 done:
1175 if (hr != S_OK) free_header( header );
1176 else *ret = header;
1177 return hr;
1178 }
1179
1180 /**************************************************************************
1181 * WsSetHeader [webservices.@]
1182 */
1183 HRESULT WINAPI WsSetHeader( WS_MESSAGE *handle, WS_HEADER_TYPE type, WS_TYPE value_type,
1184 WS_WRITE_OPTION option, const void *value, ULONG size, WS_ERROR *error )
1185 {
1186 struct msg *msg = (struct msg *)handle;
1187 struct header *header;
1188 BOOL found = FALSE;
1189 HRESULT hr;
1190 ULONG i;
1191
1192 TRACE( "%p %u %u %08x %p %u %p\n", handle, type, value_type, option, value, size, error );
1193 if (error) FIXME( "ignoring error parameter\n" );
1194
1195 if (!msg || type < WS_ACTION_HEADER || type > WS_FAULT_TO_HEADER) return E_INVALIDARG;
1196
1197 EnterCriticalSection( &msg->cs );
1198
1199 if (msg->magic != MSG_MAGIC)
1200 {
1201 LeaveCriticalSection( &msg->cs );
1202 return E_INVALIDARG;
1203 }
1204
1205 if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
1206 {
1207 hr = WS_E_INVALID_OPERATION;
1208 goto done;
1209 }
1210
1211 for (i = 0; i < msg->header_count; i++)
1212 {
1213 if (msg->header[i]->type == type)
1214 {
1215 found = TRUE;
1216 break;
1217 }
1218 }
1219
1220 if (!found)
1221 {
1222 if ((hr = grow_header_array( msg, msg->header_count + 1 )) != S_OK) goto done;
1223 i = msg->header_count;
1224 }
1225
1226 if ((hr = build_standard_header( msg, type, value_type, option, value, size, &header )) != S_OK)
1227 goto done;
1228
1229 if (!found) msg->header_count++;
1230 else free_header( msg->header[i] );
1231
1232 msg->header[i] = header;
1233 hr = write_envelope( msg );
1234
1235 done:
1236 LeaveCriticalSection( &msg->cs );
1237 TRACE( "returning %08x\n", hr );
1238 return hr;
1239 }
1240
1241 static HRESULT find_header( WS_XML_READER *reader, const WS_XML_STRING *localname, const WS_XML_STRING *ns )
1242 {
1243 const WS_XML_NODE *node;
1244 const WS_XML_ELEMENT_NODE *elem;
1245 HRESULT hr;
1246
1247 for (;;)
1248 {
1249 if ((hr = WsReadNode( reader, NULL )) != S_OK) return hr;
1250 if ((hr = WsGetReaderNode( reader, &node, NULL )) != S_OK) return hr;
1251 if (node->nodeType == WS_XML_NODE_TYPE_EOF) return WS_E_INVALID_FORMAT;
1252 if (node->nodeType != WS_XML_NODE_TYPE_ELEMENT) continue;
1253
1254 elem = (const WS_XML_ELEMENT_NODE *)node;
1255 if (WsXmlStringEquals( elem->localName, localname, NULL ) == S_OK &&
1256 WsXmlStringEquals( elem->ns, ns, NULL ) == S_OK) break;
1257 }
1258
1259 return S_OK;
1260 }
1261
1262 static HRESULT get_standard_header( struct msg *msg, WS_HEADER_TYPE type, WS_TYPE value_type,
1263 WS_READ_OPTION option, WS_HEAP *heap, void *value, ULONG size )
1264 {
1265 const WS_XML_STRING *localname = get_header_name( type );
1266 const WS_XML_STRING *ns = get_addr_namespace( msg->version_addr );
1267 HRESULT hr;
1268
1269 if (!heap) heap = msg->heap;
1270 if (!msg->reader && (hr = WsCreateReader( NULL, 0, &msg->reader, NULL )) != S_OK) return hr;
1271 if ((hr = WsSetInputToBuffer( msg->reader, msg->buf, NULL, 0, NULL )) != S_OK) return hr;
1272
1273 if ((hr = find_header( msg->reader, localname, ns )) != S_OK) return hr;
1274 return read_header( msg->reader, localname, ns, value_type, NULL, option, heap, value, size );
1275 }
1276
1277 /**************************************************************************
1278 * WsGetHeader [webservices.@]
1279 */
1280 HRESULT WINAPI WsGetHeader( WS_MESSAGE *handle, WS_HEADER_TYPE type, WS_TYPE value_type, WS_READ_OPTION option,
1281 WS_HEAP *heap, void *value, ULONG size, WS_ERROR *error )
1282 {
1283 struct msg *msg = (struct msg *)handle;
1284 HRESULT hr;
1285
1286 TRACE( "%p %u %u %08x %p %p %u %p\n", handle, type, value_type, option, heap, value, size, error );
1287 if (error) FIXME( "ignoring error parameter\n" );
1288
1289 if (!msg || type < WS_ACTION_HEADER || type > WS_FAULT_TO_HEADER || option < WS_READ_REQUIRED_VALUE ||
1290 option > WS_READ_OPTIONAL_POINTER) return E_INVALIDARG;
1291
1292 EnterCriticalSection( &msg->cs );
1293
1294 if (msg->magic != MSG_MAGIC)
1295 {
1296 LeaveCriticalSection( &msg->cs );
1297 return E_INVALIDARG;
1298 }
1299
1300 if (msg->state < WS_MESSAGE_STATE_INITIALIZED) hr = WS_E_INVALID_OPERATION;
1301 else hr = get_standard_header( msg, type, value_type, option, heap, value, size );
1302
1303 LeaveCriticalSection( &msg->cs );
1304 TRACE( "returning %08x\n", hr );
1305 return hr;
1306 }
1307
1308 static void remove_header( struct msg *msg, ULONG i )
1309 {
1310 free_header( msg->header[i] );
1311 memmove( &msg->header[i], &msg->header[i + 1], (msg->header_count - i - 1) * sizeof(struct header *) );
1312 msg->header_count--;
1313 }
1314
1315 /**************************************************************************
1316 * WsRemoveHeader [webservices.@]
1317 */
1318 HRESULT WINAPI WsRemoveHeader( WS_MESSAGE *handle, WS_HEADER_TYPE type, WS_ERROR *error )
1319 {
1320 struct msg *msg = (struct msg *)handle;
1321 BOOL removed = FALSE;
1322 HRESULT hr = S_OK;
1323 ULONG i;
1324
1325 TRACE( "%p %u %p\n", handle, type, error );
1326 if (error) FIXME( "ignoring error parameter\n" );
1327
1328 if (!msg) return E_INVALIDARG;
1329
1330 EnterCriticalSection( &msg->cs );
1331
1332 if (msg->magic != MSG_MAGIC)
1333 {
1334 LeaveCriticalSection( &msg->cs );
1335 return E_INVALIDARG;
1336 }
1337
1338 if (msg->state < WS_MESSAGE_STATE_INITIALIZED) hr = WS_E_INVALID_OPERATION;
1339 else if (type < WS_ACTION_HEADER || type > WS_FAULT_TO_HEADER) hr = E_INVALIDARG;
1340 else
1341 {
1342 for (i = 0; i < msg->header_count; i++)
1343 {
1344 if (msg->header[i]->type == type)
1345 {
1346 remove_header( msg, i );
1347 removed = TRUE;
1348 break;
1349 }
1350 }
1351 if (removed) hr = write_envelope( msg );
1352 }
1353
1354 LeaveCriticalSection( &msg->cs );
1355 TRACE( "returning %08x\n", hr );
1356 return hr;
1357 }
1358
1359 static HRESULT build_mapped_header( const WS_XML_STRING *name, WS_TYPE type, WS_WRITE_OPTION option,
1360 const void *value, ULONG size, struct header **ret )
1361 {
1362 struct header *header;
1363
1364 if (!(header = alloc_header( 0, TRUE, name, NULL ))) return E_OUTOFMEMORY;
1365 switch (type)
1366 {
1367 case WS_WSZ_TYPE:
1368 {
1369 int len;
1370 const WCHAR *src;
1371
1372 if (option != WS_WRITE_REQUIRED_POINTER || size != sizeof(WCHAR *))
1373 {
1374 free_header( header );
1375 return E_INVALIDARG;
1376 }
1377 src = *(const WCHAR **)value;
1378 len = WideCharToMultiByte( CP_UTF8, 0, src, -1, NULL, 0, NULL, NULL ) - 1;
1379 if (!(header->u.text = alloc_xml_string( NULL, len )))
1380 {
1381 free_header( header );
1382 return E_OUTOFMEMORY;
1383 }
1384 WideCharToMultiByte( CP_UTF8, 0, src, -1, (char *)header->u.text->bytes, len, NULL, NULL );
1385 break;
1386 }
1387 case WS_XML_STRING_TYPE:
1388 {
1389 const WS_XML_STRING *str = value;
1390
1391 if (option != WS_WRITE_REQUIRED_VALUE)
1392 {
1393 FIXME( "unhandled write option %u\n", option );
1394 free_header( header );
1395 return E_NOTIMPL;
1396 }
1397 if (size != sizeof(*str))
1398 {
1399 free_header( header );
1400 return E_INVALIDARG;
1401 }
1402 if (!(header->u.text = alloc_xml_string( NULL, str->length )))
1403 {
1404 free_header( header );
1405 return E_OUTOFMEMORY;
1406 }
1407 memcpy( header->u.text->bytes, str->bytes, str->length );
1408 break;
1409 }
1410 case WS_STRING_TYPE:
1411 {
1412 int len;
1413 const WS_STRING *str = value;
1414
1415 if (option != WS_WRITE_REQUIRED_VALUE)
1416 {
1417 FIXME( "unhandled write option %u\n", option );
1418 free_header( header );
1419 return E_NOTIMPL;
1420 }
1421 if (size != sizeof(*str))
1422 {
1423 free_header( header );
1424 return E_INVALIDARG;
1425 }
1426 len = WideCharToMultiByte( CP_UTF8, 0, str->chars, str->length, NULL, 0, NULL, NULL );
1427 if (!(header->u.text = alloc_xml_string( NULL, len )))
1428 {
1429 free_header( header );
1430 return E_OUTOFMEMORY;
1431 }
1432 WideCharToMultiByte( CP_UTF8, 0, str->chars, str->length, (char *)header->u.text->bytes,
1433 len, NULL, NULL );
1434 break;
1435 }
1436 default:
1437 FIXME( "unhandled type %u\n", type );
1438 free_header( header );
1439 return E_NOTIMPL;
1440 }
1441
1442 *ret = header;
1443 return S_OK;
1444 }
1445
1446 /**************************************************************************
1447 * WsAddMappedHeader [webservices.@]
1448 */
1449 HRESULT WINAPI WsAddMappedHeader( WS_MESSAGE *handle, const WS_XML_STRING *name, WS_TYPE type,
1450 WS_WRITE_OPTION option, const void *value, ULONG size, WS_ERROR *error )
1451 {
1452 struct msg *msg = (struct msg *)handle;
1453 struct header *header;
1454 BOOL found = FALSE;
1455 HRESULT hr;
1456 ULONG i;
1457
1458 TRACE( "%p %s %u %08x %p %u %p\n", handle, debugstr_xmlstr(name), type, option, value, size, error );
1459 if (error) FIXME( "ignoring error parameter\n" );
1460
1461 if (!msg || !name) return E_INVALIDARG;
1462
1463 EnterCriticalSection( &msg->cs );
1464
1465 if (msg->magic != MSG_MAGIC)
1466 {
1467 LeaveCriticalSection( &msg->cs );
1468 return E_INVALIDARG;
1469 }
1470
1471 if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
1472 {
1473 hr = WS_E_INVALID_OPERATION;
1474 goto done;
1475 }
1476
1477 for (i = 0; i < msg->header_count; i++)
1478 {
1479 if (msg->header[i]->type || !msg->header[i]->mapped) continue;
1480 if (WsXmlStringEquals( name, &msg->header[i]->name, NULL ) == S_OK)
1481 {
1482 found = TRUE;
1483 break;
1484 }
1485 }
1486
1487 if (!found)
1488 {
1489 if ((hr = grow_header_array( msg, msg->header_count + 1 )) != S_OK) goto done;
1490 i = msg->header_count;
1491 }
1492
1493 if ((hr = build_mapped_header( name, type, option, value, size, &header )) != S_OK) goto done;
1494
1495 if (!found) msg->header_count++;
1496 else free_header( msg->header[i] );
1497
1498 msg->header[i] = header;
1499
1500 done:
1501 LeaveCriticalSection( &msg->cs );
1502 TRACE( "returning %08x\n", hr );
1503 return hr;
1504 }
1505
1506 /**************************************************************************
1507 * WsRemoveMappedHeader [webservices.@]
1508 */
1509 HRESULT WINAPI WsRemoveMappedHeader( WS_MESSAGE *handle, const WS_XML_STRING *name, WS_ERROR *error )
1510 {
1511 struct msg *msg = (struct msg *)handle;
1512 HRESULT hr = S_OK;
1513 ULONG i;
1514
1515 TRACE( "%p %s %p\n", handle, debugstr_xmlstr(name), error );
1516 if (error) FIXME( "ignoring error parameter\n" );
1517
1518 if (!msg || !name) return E_INVALIDARG;
1519
1520 EnterCriticalSection( &msg->cs );
1521
1522 if (msg->magic != MSG_MAGIC)
1523 {
1524 LeaveCriticalSection( &msg->cs );
1525 return E_INVALIDARG;
1526 }
1527
1528 if (msg->state < WS_MESSAGE_STATE_INITIALIZED) hr = WS_E_INVALID_OPERATION;
1529 else
1530 {
1531 for (i = 0; i < msg->header_count; i++)
1532 {
1533 if (msg->header[i]->type || !msg->header[i]->mapped) continue;
1534 if (WsXmlStringEquals( name, &msg->header[i]->name, NULL ) == S_OK)
1535 {
1536 remove_header( msg, i );
1537 break;
1538 }
1539 }
1540 }
1541
1542 LeaveCriticalSection( &msg->cs );
1543 TRACE( "returning %08x\n", hr );
1544 return hr;
1545 }
1546
1547 static HRESULT write_custom_header( WS_XML_WRITER *writer, const WS_XML_STRING *name, const WS_XML_STRING *ns,
1548 WS_TYPE type, const void *desc, WS_WRITE_OPTION option, const void *value,
1549 ULONG size )
1550 {
1551 HRESULT hr;
1552 if ((hr = WsWriteStartElement( writer, NULL, name, ns, NULL )) != S_OK) return hr;
1553 if ((hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, type, desc, option, value, size,
1554 NULL )) != S_OK) return hr;
1555 return WsWriteEndElement( writer, NULL );
1556 }
1557
1558 static HRESULT build_custom_header( struct msg *msg, const WS_XML_STRING *name, const WS_XML_STRING *ns,
1559 WS_TYPE type, const void *desc, WS_WRITE_OPTION option, const void *value,
1560 ULONG size, struct header **ret )
1561 {
1562 struct header *header;
1563 WS_XML_BUFFER *buf;
1564 HRESULT hr;
1565
1566 if (!(header = alloc_header( 0, FALSE, name, ns ))) return E_OUTOFMEMORY;
1567
1568 if (!msg->writer && (hr = WsCreateWriter( NULL, 0, &msg->writer, NULL )) != S_OK) goto done;
1569 if ((hr = WsCreateXmlBuffer( msg->heap, NULL, 0, &buf, NULL )) != S_OK) goto done;
1570 if ((hr = WsSetOutputToBuffer( msg->writer, buf, NULL, 0, NULL )) != S_OK) goto done;
1571 if ((hr = write_custom_header( msg->writer, name, ns, type, desc, option, value, size )) != S_OK) goto done;
1572
1573 header->u.buf = buf;
1574
1575 done:
1576 if (hr != S_OK) free_header( header );
1577 else *ret = header;
1578 return hr;
1579 }
1580
1581 /**************************************************************************
1582 * WsAddCustomHeader [webservices.@]
1583 */
1584 HRESULT WINAPI WsAddCustomHeader( WS_MESSAGE *handle, const WS_ELEMENT_DESCRIPTION *desc, WS_WRITE_OPTION option,
1585 const void *value, ULONG size, ULONG attrs, WS_ERROR *error )
1586 {
1587 struct msg *msg = (struct msg *)handle;
1588 struct header *header;
1589 HRESULT hr;
1590
1591 TRACE( "%p %p %08x %p %u %08x %p\n", handle, desc, option, value, size, attrs, error );
1592 if (error) FIXME( "ignoring error parameter\n" );
1593
1594 if (!msg || !desc) return E_INVALIDARG;
1595
1596 EnterCriticalSection( &msg->cs );
1597
1598 if (msg->magic != MSG_MAGIC)
1599 {
1600 LeaveCriticalSection( &msg->cs );
1601 return E_INVALIDARG;
1602 }
1603
1604 if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
1605 {
1606 hr = WS_E_INVALID_OPERATION;
1607 goto done;
1608 }
1609
1610 if ((hr = grow_header_array( msg, msg->header_count + 1 )) != S_OK) goto done;
1611 if ((hr = build_custom_header( msg, desc->elementLocalName, desc->elementNs, desc->type,
1612 desc->typeDescription, option, value, size, &header )) != S_OK) goto done;
1613 msg->header[msg->header_count++] = header;
1614 hr = write_envelope( msg );
1615
1616 done:
1617 LeaveCriticalSection( &msg->cs );
1618 TRACE( "returning %08x\n", hr );
1619 return hr;
1620 }
1621
1622 static HRESULT get_custom_header( struct msg *msg, const WS_ELEMENT_DESCRIPTION *desc, WS_READ_OPTION option,
1623 WS_HEAP *heap, void *value, ULONG size )
1624 {
1625 HRESULT hr;
1626 if (!heap) heap = msg->heap;
1627 if (!msg->reader && (hr = WsCreateReader( NULL, 0, &msg->reader, NULL )) != S_OK) return hr;
1628 if ((hr = WsSetInputToBuffer( msg->reader, msg->buf, NULL, 0, NULL )) != S_OK) return hr;
1629
1630 if ((hr = find_header( msg->reader, desc->elementLocalName, desc->elementNs )) != S_OK) return hr;
1631 return read_header( msg->reader, desc->elementLocalName, desc->elementNs, desc->type, desc->typeDescription,
1632 option, heap, value, size );
1633 }
1634
1635 /**************************************************************************
1636 * WsGetCustomHeader [webservices.@]
1637 */
1638 HRESULT WINAPI WsGetCustomHeader( WS_MESSAGE *handle, const WS_ELEMENT_DESCRIPTION *desc,
1639 WS_REPEATING_HEADER_OPTION repeat_option, ULONG index, WS_READ_OPTION option,
1640 WS_HEAP *heap, void *value, ULONG size, ULONG *attrs, WS_ERROR *error )
1641 {
1642 struct msg *msg = (struct msg *)handle;
1643 HRESULT hr;
1644
1645 TRACE( "%p %p %08x %u %08x %p %p %u %p %p\n", handle, desc, repeat_option, index, option, heap, value,
1646 size, attrs, error );
1647 if (error) FIXME( "ignoring error parameter\n" );
1648
1649 if (!msg || !desc || repeat_option < WS_REPEATING_HEADER || repeat_option > WS_SINGLETON_HEADER ||
1650 (repeat_option == WS_SINGLETON_HEADER && index)) return E_INVALIDARG;
1651
1652 if (repeat_option == WS_REPEATING_HEADER)
1653 {
1654 FIXME( "repeating header not supported\n" );
1655 return E_NOTIMPL;
1656 }
1657 if (attrs)
1658 {
1659 FIXME( "attributes not supported\n" );
1660 return E_NOTIMPL;
1661 }
1662
1663 EnterCriticalSection( &msg->cs );
1664
1665 if (msg->magic != MSG_MAGIC)
1666 {
1667 LeaveCriticalSection( &msg->cs );
1668 return E_INVALIDARG;
1669 }
1670
1671 if (msg->state < WS_MESSAGE_STATE_INITIALIZED) hr = WS_E_INVALID_OPERATION;
1672 else hr = get_custom_header( msg, desc, option, heap, value, size );
1673
1674 LeaveCriticalSection( &msg->cs );
1675 TRACE( "returning %08x\n", hr );
1676 return hr;
1677 }
1678
1679 /**************************************************************************
1680 * WsRemoveCustomHeader [webservices.@]
1681 */
1682 HRESULT WINAPI WsRemoveCustomHeader( WS_MESSAGE *handle, const WS_XML_STRING *name, const WS_XML_STRING *ns,
1683 WS_ERROR *error )
1684 {
1685 struct msg *msg = (struct msg *)handle;
1686 BOOL removed = FALSE;
1687 HRESULT hr = S_OK;
1688 ULONG i;
1689
1690 TRACE( "%p %s %s %p\n", handle, debugstr_xmlstr(name), debugstr_xmlstr(ns), error );
1691 if (error) FIXME( "ignoring error parameter\n" );
1692
1693 if (!msg || !name || !ns) return E_INVALIDARG;
1694
1695 EnterCriticalSection( &msg->cs );
1696
1697 if (msg->magic != MSG_MAGIC)
1698 {
1699 LeaveCriticalSection( &msg->cs );
1700 return E_INVALIDARG;
1701 }
1702
1703 if (msg->state < WS_MESSAGE_STATE_INITIALIZED) hr = WS_E_INVALID_OPERATION;
1704 else
1705 {
1706 for (i = 0; i < msg->header_count; i++)
1707 {
1708 if (msg->header[i]->type || msg->header[i]->mapped) continue;
1709 if (WsXmlStringEquals( name, &msg->header[i]->name, NULL ) == S_OK &&
1710 WsXmlStringEquals( ns, &msg->header[i]->ns, NULL ) == S_OK)
1711 {
1712 remove_header( msg, i );
1713 removed = TRUE;
1714 i--;
1715 }
1716 }
1717 if (removed) hr = write_envelope( msg );
1718 }
1719
1720 LeaveCriticalSection( &msg->cs );
1721 TRACE( "returning %08x\n", hr );
1722 return hr;
1723 }
1724
1725 static WCHAR *build_http_header( const WCHAR *name, const WCHAR *value, ULONG *ret_len )
1726 {
1727 int len_name = strlenW( name ), len_value = strlenW( value );
1728 WCHAR *ret = heap_alloc( (len_name + len_value) * sizeof(WCHAR) );
1729
1730 if (!ret) return NULL;
1731 memcpy( ret, name, len_name * sizeof(WCHAR) );
1732 memcpy( ret + len_name, value, len_value * sizeof(WCHAR) );
1733 *ret_len = len_name + len_value;
1734 return ret;
1735 }
1736
1737 static inline HRESULT insert_http_header( HINTERNET req, const WCHAR *header, ULONG len, ULONG flags )
1738 {
1739 if (WinHttpAddRequestHeaders( req, header, len, flags )) return S_OK;
1740 return HRESULT_FROM_WIN32( GetLastError() );
1741 }
1742
1743 HRESULT message_insert_http_headers( WS_MESSAGE *handle, HINTERNET req )
1744 {
1745 static const WCHAR contenttypeW[] =
1746 {'C','o','n','t','e','n','t','-','T','y','p','e',':',' ',0};
1747 static const WCHAR soapxmlW[] =
1748 {'a','p','p','l','i','c','a','t','i','o','n','/','s','o','a','p','+','x','m','l',0};
1749 static const WCHAR textxmlW[] =
1750 {'t','e','x','t','/','x','m','l',0};
1751 static const WCHAR charsetW[] =
1752 {'c','h','a','r','s','e','t','=','u','t','f','-','8',0};
1753 struct msg *msg = (struct msg *)handle;
1754 HRESULT hr = E_OUTOFMEMORY;
1755 WCHAR *header = NULL, *buf;
1756 ULONG len;
1757
1758 EnterCriticalSection( &msg->cs );
1759
1760 if (msg->magic != MSG_MAGIC)
1761 {
1762 LeaveCriticalSection( &msg->cs );
1763 return E_INVALIDARG;
1764 }
1765
1766 switch (msg->version_env)
1767 {
1768 case WS_ENVELOPE_VERSION_SOAP_1_1:
1769 header = build_http_header( contenttypeW, textxmlW, &len );
1770 break;
1771
1772 case WS_ENVELOPE_VERSION_SOAP_1_2:
1773 header = build_http_header( contenttypeW, soapxmlW, &len );
1774 break;
1775
1776 default:
1777 FIXME( "unhandled envelope version %u\n", msg->version_env );
1778 hr = E_NOTIMPL;
1779 }
1780 if (!header) goto done;
1781
1782 if ((hr = insert_http_header( req, header, len, WINHTTP_ADDREQ_FLAG_ADD )) != S_OK) goto done;
1783 heap_free( header );
1784
1785 hr = E_OUTOFMEMORY;
1786 if (!(header = build_http_header( contenttypeW, charsetW, &len ))) goto done;
1787 if ((hr = insert_http_header( req, header, len, WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON )) != S_OK)
1788 goto done;
1789 heap_free( header );
1790 header = NULL;
1791
1792 switch (msg->version_env)
1793 {
1794 case WS_ENVELOPE_VERSION_SOAP_1_1:
1795 {
1796 static const WCHAR soapactionW[] = {'S','O','A','P','A','c','t','i','o','n',':',' ',0};
1797
1798 if (!(len = MultiByteToWideChar( CP_UTF8, 0, (char *)msg->action->bytes, msg->action->length, NULL, 0 )))
1799 break;
1800
1801 hr = E_OUTOFMEMORY;
1802 if (!(buf = heap_alloc( (len + 3) * sizeof(WCHAR) ))) goto done;
1803 buf[0] = '"';
1804 MultiByteToWideChar( CP_UTF8, 0, (char *)msg->action->bytes, msg->action->length, buf + 1, len );
1805 buf[len + 1] = '"';
1806 buf[len + 2] = 0;
1807
1808 header = build_http_header( soapactionW, buf, &len );
1809 heap_free( buf );
1810 if (!header) goto done;
1811
1812 hr = insert_http_header( req, header, len, WINHTTP_ADDREQ_FLAG_ADD );
1813 break;
1814 }
1815 case WS_ENVELOPE_VERSION_SOAP_1_2:
1816 {
1817 static const WCHAR actionW[] = {'a','c','t','i','o','n','=','"'};
1818 ULONG len_action = ARRAY_SIZE( actionW );
1819
1820 if (!(len = MultiByteToWideChar( CP_UTF8, 0, (char *)msg->action->bytes, msg->action->length, NULL, 0 )))
1821 break;
1822
1823 hr = E_OUTOFMEMORY;
1824 if (!(buf = heap_alloc( (len + len_action + 2) * sizeof(WCHAR) ))) goto done;
1825 memcpy( buf, actionW, len_action * sizeof(WCHAR) );
1826 MultiByteToWideChar( CP_UTF8, 0, (char *)msg->action->bytes, msg->action->length, buf + len_action, len );
1827 len += len_action;
1828 buf[len++] = '"';
1829 buf[len] = 0;
1830
1831 header = build_http_header( contenttypeW, buf, &len );
1832 heap_free( buf );
1833 if (!header) goto done;
1834
1835 hr = insert_http_header( req, header, len, WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON );
1836 break;
1837 }
1838 default:
1839 FIXME( "unhandled envelope version %u\n", msg->version_env );
1840 hr = E_NOTIMPL;
1841 }
1842
1843 done:
1844 heap_free( header );
1845 LeaveCriticalSection( &msg->cs );
1846 TRACE( "returning %08x\n", hr );
1847 return hr;
1848 }
1849
1850 void message_set_send_context( WS_MESSAGE *handle, const WS_PROXY_MESSAGE_CALLBACK_CONTEXT *ctx )
1851 {
1852 struct msg *msg = (struct msg *)handle;
1853
1854 EnterCriticalSection( &msg->cs );
1855
1856 if (msg->magic != MSG_MAGIC)
1857 {
1858 LeaveCriticalSection( &msg->cs );
1859 return;
1860 }
1861
1862 msg->ctx_send.callback = ctx->callback;
1863 msg->ctx_send.state = ctx->state;
1864
1865 LeaveCriticalSection( &msg->cs );
1866 }
1867
1868 void message_set_receive_context( WS_MESSAGE *handle, const WS_PROXY_MESSAGE_CALLBACK_CONTEXT *ctx )
1869 {
1870 struct msg *msg = (struct msg *)handle;
1871
1872 EnterCriticalSection( &msg->cs );
1873
1874 if (msg->magic != MSG_MAGIC)
1875 {
1876 LeaveCriticalSection( &msg->cs );
1877 return;
1878 }
1879
1880 msg->ctx_receive.callback = ctx->callback;
1881 msg->ctx_receive.state = ctx->state;
1882
1883 LeaveCriticalSection( &msg->cs );
1884 }
1885
1886 void message_do_send_callback( WS_MESSAGE *handle )
1887 {
1888 struct msg *msg = (struct msg *)handle;
1889
1890 EnterCriticalSection( &msg->cs );
1891
1892 if (msg->magic != MSG_MAGIC)
1893 {
1894 LeaveCriticalSection( &msg->cs );
1895 return;
1896 }
1897
1898 if (msg->ctx_send.callback)
1899 {
1900 HRESULT hr;
1901 TRACE( "executing callback %p\n", msg->ctx_send.callback );
1902 hr = msg->ctx_send.callback( handle, msg->heap, msg->ctx_send.state, NULL );
1903 TRACE( "callback %p returned %08x\n", msg->ctx_send.callback, hr );
1904 }
1905
1906 LeaveCriticalSection( &msg->cs );
1907 }
1908
1909 void message_do_receive_callback( WS_MESSAGE *handle )
1910 {
1911 struct msg *msg = (struct msg *)handle;
1912
1913 EnterCriticalSection( &msg->cs );
1914
1915 if (msg->magic != MSG_MAGIC)
1916 {
1917 LeaveCriticalSection( &msg->cs );
1918 return;
1919 }
1920
1921 if (msg->ctx_receive.callback)
1922 {
1923 HRESULT hr;
1924 TRACE( "executing callback %p\n", msg->ctx_receive.callback );
1925 hr = msg->ctx_receive.callback( handle, msg->heap, msg->ctx_receive.state, NULL );
1926 TRACE( "callback %p returned %08x\n", msg->ctx_receive.callback, hr );
1927 }
1928
1929 LeaveCriticalSection( &msg->cs );
1930 }
1931
1932 HRESULT message_set_action( WS_MESSAGE *handle, const WS_XML_STRING *action )
1933 {
1934 struct msg *msg = (struct msg *)handle;
1935 HRESULT hr = S_OK;
1936
1937 EnterCriticalSection( &msg->cs );
1938
1939 if (msg->magic != MSG_MAGIC)
1940 {
1941 LeaveCriticalSection( &msg->cs );
1942 return E_INVALIDARG;
1943 }
1944
1945 if (!action || !action->length)
1946 {
1947 free_xml_string( msg->action );
1948 msg->action = NULL;
1949 }
1950 else
1951 {
1952 WS_XML_STRING *str;
1953 if (!(str = dup_xml_string( action, FALSE ))) hr = E_OUTOFMEMORY;
1954 else
1955 {
1956 free_xml_string( msg->action );
1957 msg->action = str;
1958 }
1959 }
1960
1961 LeaveCriticalSection( &msg->cs );
1962 return hr;
1963 }
1964
1965 HRESULT message_get_id( WS_MESSAGE *handle, GUID *id )
1966 {
1967 struct msg *msg = (struct msg *)handle;
1968 HRESULT hr = S_OK;
1969
1970 EnterCriticalSection( &msg->cs );
1971
1972 if (msg->magic != MSG_MAGIC)
1973 {
1974 LeaveCriticalSection( &msg->cs );
1975 return E_INVALIDARG;
1976 }
1977
1978 *id = msg->id_req;
1979
1980 LeaveCriticalSection( &msg->cs );
1981 return hr;
1982 }
1983
1984 HRESULT message_set_request_id( WS_MESSAGE *handle, const GUID *id )
1985 {
1986 struct msg *msg = (struct msg *)handle;
1987 HRESULT hr = S_OK;
1988
1989 EnterCriticalSection( &msg->cs );
1990
1991 if (msg->magic != MSG_MAGIC)
1992 {
1993 LeaveCriticalSection( &msg->cs );
1994 return E_INVALIDARG;
1995 }
1996
1997 msg->id_req = *id;
1998
1999 LeaveCriticalSection( &msg->cs );
2000 return hr;
2001 }
Windows API implementation