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