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