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