?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
webservices: Implement WsReadBody.
[wine.git] / dlls / webservices / msg.c
blob4a47fd358e3eb013122652f177790bfbbe5af4ea
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 WS_MESSAGE_INITIALIZATION init;
68 WS_MESSAGE_STATE state;
69 GUID id;
70 WS_ENVELOPE_VERSION version_env;
71 WS_ADDRESSING_VERSION version_addr;
72 BOOL is_addressed;
73 WS_STRING addr;
74 WS_HEAP *heap;
75 WS_XML_BUFFER *buf;
76 WS_XML_WRITER *writer;
77 WS_XML_WRITER *writer_body;
78 WS_XML_READER *reader_body;
79 ULONG header_count;
80 ULONG header_size;
81 struct header **header;
82 ULONG prop_count;
83 struct prop prop[sizeof(msg_props)/sizeof(msg_props[0])];
84 };
85
86 #define HEADER_ARRAY_SIZE 2
87 static struct msg *alloc_msg(void)
88 {
89 static const ULONG count = sizeof(msg_props)/sizeof(msg_props[0]);
90 struct msg *ret;
91 ULONG size = sizeof(*ret) + prop_size( msg_props, count );
92
93 if (!(ret = heap_alloc_zero( size ))) return NULL;
94 if (!(ret->header = heap_alloc( HEADER_ARRAY_SIZE * sizeof(struct header *) )))
95 {
96 heap_free( ret );
97 return NULL;
98 }
99 ret->state = WS_MESSAGE_STATE_EMPTY;
100 ret->header_size = HEADER_ARRAY_SIZE;
101 prop_init( msg_props, count, ret->prop, &ret[1] );
102 ret->prop_count = count;
103 return ret;
104 }
105
106 static void free_header( struct header *header )
107 {
108 heap_free( header->name.bytes );
109 heap_free( header->ns.bytes );
110 if (header->mapped) heap_free( header->u.text );
111 heap_free( header );
112 }
113
114 static void free_msg( struct msg *msg )
115 {
116 ULONG i;
117 if (!msg) return;
118 WsFreeWriter( msg->writer );
119 WsFreeHeap( msg->heap );
120 heap_free( msg->addr.chars );
121 for (i = 0; i < msg->header_count; i++) free_header( msg->header[i] );
122 heap_free( msg->header );
123 heap_free( msg );
124 }
125
126 #define HEAP_MAX_SIZE (1 << 16)
127 static HRESULT create_msg( WS_ENVELOPE_VERSION env_version, WS_ADDRESSING_VERSION addr_version,
128 const WS_MESSAGE_PROPERTY *properties, ULONG count, WS_MESSAGE **handle )
129 {
130 struct msg *msg;
131 HRESULT hr;
132 ULONG i;
133
134 if (!(msg = alloc_msg())) return E_OUTOFMEMORY;
135
136 for (i = 0; i < count; i++)
137 {
138 if (properties[i].id == WS_MESSAGE_PROPERTY_ENVELOPE_VERSION ||
139 properties[i].id == WS_MESSAGE_PROPERTY_ADDRESSING_VERSION)
140 {
141 free_msg( msg );
142 return E_INVALIDARG;
143 }
144 hr = prop_set( msg->prop, msg->prop_count, properties[i].id, properties[i].value,
145 properties[i].valueSize );
146 if (hr != S_OK)
147 {
148 free_msg( msg );
149 return hr;
150 }
151 }
152
153 if ((hr = WsCreateHeap( HEAP_MAX_SIZE, 0, NULL, 0, &msg->heap, NULL )) != S_OK)
154 {
155 free_msg( msg );
156 return hr;
157 }
158 if ((hr = WsCreateXmlBuffer( msg->heap, NULL, 0, &msg->buf, NULL )) != S_OK)
159 {
160 free_msg( msg );
161 return hr;
162 }
163
164 UuidCreate( &msg->id );
165 msg->version_env = env_version;
166 msg->version_addr = addr_version;
167
168 *handle = (WS_MESSAGE *)msg;
169 return S_OK;
170 }
171
172 /**************************************************************************
173 * WsCreateMessage [webservices.@]
174 */
175 HRESULT WINAPI WsCreateMessage( WS_ENVELOPE_VERSION env_version, WS_ADDRESSING_VERSION addr_version,
176 const WS_MESSAGE_PROPERTY *properties, ULONG count, WS_MESSAGE **handle,
177 WS_ERROR *error )
178 {
179 TRACE( "%u %u %p %u %p %p\n", env_version, addr_version, properties, count, handle, error );
180 if (error) FIXME( "ignoring error parameter\n" );
181
182 if (!handle || !env_version || !addr_version) return E_INVALIDARG;
183 return create_msg( env_version, addr_version, properties, count, handle );
184 }
185
186 /**************************************************************************
187 * WsCreateMessageForChannel [webservices.@]
188 */
189 HRESULT WINAPI WsCreateMessageForChannel( WS_CHANNEL *channel_handle, const WS_MESSAGE_PROPERTY *properties,
190 ULONG count, WS_MESSAGE **handle, WS_ERROR *error )
191 {
192 WS_ENVELOPE_VERSION version_env;
193 WS_ADDRESSING_VERSION version_addr;
194 HRESULT hr;
195
196 TRACE( "%p %p %u %p %p\n", channel_handle, properties, count, handle, error );
197 if (error) FIXME( "ignoring error parameter\n" );
198
199 if (!channel_handle || !handle) return E_INVALIDARG;
200
201 if ((hr = WsGetChannelProperty( channel_handle, WS_CHANNEL_PROPERTY_ENVELOPE_VERSION, &version_env,
202 sizeof(version_env), NULL )) != S_OK || !version_env)
203 version_env = WS_ENVELOPE_VERSION_SOAP_1_2;
204
205 if ((hr = WsGetChannelProperty( channel_handle, WS_CHANNEL_PROPERTY_ADDRESSING_VERSION, &version_addr,
206 sizeof(version_addr), NULL )) != S_OK || !version_addr)
207 version_addr = WS_ADDRESSING_VERSION_1_0;
208
209 return create_msg( version_env, version_addr, properties, count, handle );
210 }
211
212 /**************************************************************************
213 * WsFreeMessage [webservices.@]
214 */
215 void WINAPI WsFreeMessage( WS_MESSAGE *handle )
216 {
217 struct msg *msg = (struct msg *)handle;
218
219 TRACE( "%p\n", handle );
220 free_msg( msg );
221 }
222
223 /**************************************************************************
224 * WsGetMessageProperty [webservices.@]
225 */
226 HRESULT WINAPI WsGetMessageProperty( WS_MESSAGE *handle, WS_MESSAGE_PROPERTY_ID id, void *buf,
227 ULONG size, WS_ERROR *error )
228 {
229 struct msg *msg = (struct msg *)handle;
230
231 TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
232 if (error) FIXME( "ignoring error parameter\n" );
233
234 if (!handle) return E_INVALIDARG;
235
236 switch (id)
237 {
238 case WS_MESSAGE_PROPERTY_STATE:
239 if (!buf || size != sizeof(msg->state)) return E_INVALIDARG;
240 *(WS_MESSAGE_STATE *)buf = msg->state;
241 return S_OK;
242
243 case WS_MESSAGE_PROPERTY_HEAP:
244 if (!buf || size != sizeof(msg->heap)) return E_INVALIDARG;
245 *(WS_HEAP **)buf = msg->heap;
246 return S_OK;
247
248 case WS_MESSAGE_PROPERTY_ENVELOPE_VERSION:
249 if (!buf || size != sizeof(msg->version_env)) return E_INVALIDARG;
250 *(WS_ENVELOPE_VERSION *)buf = msg->version_env;
251 return S_OK;
252
253 case WS_MESSAGE_PROPERTY_ADDRESSING_VERSION:
254 if (!buf || size != sizeof(msg->version_addr)) return E_INVALIDARG;
255 *(WS_ADDRESSING_VERSION *)buf = msg->version_addr;
256 return S_OK;
257
258 case WS_MESSAGE_PROPERTY_HEADER_BUFFER:
259 if (!buf || size != sizeof(msg->buf)) return E_INVALIDARG;
260 *(WS_XML_BUFFER **)buf = msg->buf;
261 return S_OK;
262
263 case WS_MESSAGE_PROPERTY_IS_ADDRESSED:
264 if (msg->state < WS_MESSAGE_STATE_INITIALIZED) return WS_E_INVALID_OPERATION;
265 *(BOOL *)buf = msg->is_addressed;
266 return S_OK;
267
268 default:
269 return prop_get( msg->prop, msg->prop_count, id, buf, size );
270 }
271 }
272
273 /**************************************************************************
274 * WsSetMessageProperty [webservices.@]
275 */
276 HRESULT WINAPI WsSetMessageProperty( WS_MESSAGE *handle, WS_MESSAGE_PROPERTY_ID id, const void *value,
277 ULONG size, WS_ERROR *error )
278 {
279 struct msg *msg = (struct msg *)handle;
280
281 TRACE( "%p %u %p %u\n", handle, id, value, size );
282 if (error) FIXME( "ignoring error parameter\n" );
283
284 if (!handle) return E_INVALIDARG;
285
286 switch (id)
287 {
288 case WS_MESSAGE_PROPERTY_STATE:
289 case WS_MESSAGE_PROPERTY_ENVELOPE_VERSION:
290 case WS_MESSAGE_PROPERTY_ADDRESSING_VERSION:
291 case WS_MESSAGE_PROPERTY_IS_ADDRESSED:
292 if (msg->state < WS_MESSAGE_STATE_INITIALIZED) return WS_E_INVALID_OPERATION;
293 return E_INVALIDARG;
294
295 default:
296 break;
297 }
298 return prop_set( msg->prop, msg->prop_count, id, value, size );
299 }
300
301 /**************************************************************************
302 * WsAddressMessage [webservices.@]
303 */
304 HRESULT WINAPI WsAddressMessage( WS_MESSAGE *handle, const WS_ENDPOINT_ADDRESS *addr, WS_ERROR *error )
305 {
306 struct msg *msg = (struct msg *)handle;
307
308 TRACE( "%p %p %p\n", handle, addr, error );
309 if (error) FIXME( "ignoring error parameter\n" );
310 if (addr && (addr->headers || addr->extensions || addr->identity))
311 {
312 FIXME( "headers, extensions or identity not supported\n" );
313 return E_NOTIMPL;
314 }
315
316 if (!handle) return E_INVALIDARG;
317 if (msg->state < WS_MESSAGE_STATE_INITIALIZED || msg->is_addressed) return WS_E_INVALID_OPERATION;
318
319 if (addr && addr->url.length)
320 {
321 if (!(msg->addr.chars = heap_alloc( addr->url.length * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
322 memcpy( msg->addr.chars, addr->url.chars, addr->url.length * sizeof(WCHAR) );
323 msg->addr.length = addr->url.length;
324 }
325
326 msg->is_addressed = TRUE;
327 return S_OK;
328 }
329
330 static HRESULT get_env_namespace( WS_ENVELOPE_VERSION ver, WS_XML_STRING *str )
331 {
332 switch (ver)
333 {
334 case WS_ENVELOPE_VERSION_SOAP_1_1:
335 str->bytes = (BYTE *)ns_env_1_1;
336 str->length = sizeof(ns_env_1_1)/sizeof(ns_env_1_1[0]) - 1;
337 return S_OK;
338
339 case WS_ENVELOPE_VERSION_SOAP_1_2:
340 str->bytes = (BYTE *)ns_env_1_2;
341 str->length = sizeof(ns_env_1_2)/sizeof(ns_env_1_2[0]) - 1;
342 return S_OK;
343
344 default:
345 ERR( "unhandled envelope version %u\n", ver );
346 return E_NOTIMPL;
347 }
348 }
349
350 static HRESULT get_addr_namespace( WS_ADDRESSING_VERSION ver, WS_XML_STRING *str )
351 {
352 switch (ver)
353 {
354 case WS_ADDRESSING_VERSION_0_9:
355 str->bytes = (BYTE *)ns_addr_0_9;
356 str->length = sizeof(ns_addr_0_9)/sizeof(ns_addr_0_9[0]) - 1;
357 return S_OK;
358
359 case WS_ADDRESSING_VERSION_1_0:
360 str->bytes = (BYTE *)ns_addr_1_0;
361 str->length = sizeof(ns_addr_1_0)/sizeof(ns_addr_1_0[0]) - 1;
362 return S_OK;
363
364 case WS_ADDRESSING_VERSION_TRANSPORT:
365 str->bytes = NULL;
366 str->length = 0;
367 return S_OK;
368
369 default:
370 ERR( "unhandled addressing version %u\n", ver );
371 return E_NOTIMPL;
372 }
373 }
374
375 static const WS_XML_STRING *get_header_name( WS_HEADER_TYPE type )
376 {
377 static const WS_XML_STRING action = {6, (BYTE *)"Action"}, to = {2, (BYTE *)"To"};
378 static const WS_XML_STRING msgid = {9, (BYTE *)"MessageID"}, relto = {9, (BYTE *)"RelatesTo"};
379 static const WS_XML_STRING from = {4, (BYTE *)"From"}, replyto = {7, (BYTE *)"ReplyTo"};
380 static const WS_XML_STRING faultto = {7, (BYTE *)"FaultTo"};
381
382 switch (type)
383 {
384 case WS_ACTION_HEADER: return &action;
385 case WS_TO_HEADER: return &to;
386 case WS_MESSAGE_ID_HEADER: return &msgid;
387 case WS_RELATES_TO_HEADER: return &relto;
388 case WS_FROM_HEADER: return &from;
389 case WS_REPLY_TO_HEADER: return &replyto;
390 case WS_FAULT_TO_HEADER: return &faultto;
391 default:
392 ERR( "unknown type %u\n", type );
393 return NULL;
394 }
395 }
396
397 static HRESULT write_envelope_start( struct msg *msg, WS_XML_WRITER *writer )
398 {
399 static const char anonymous[] = "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous";
400 static const WS_XML_STRING prefix_s = {1, (BYTE *)"s"}, prefix_a = {1, (BYTE *)"a"};
401 static const WS_XML_STRING envelope = {8, (BYTE *)"Envelope"}, header = {6, (BYTE *)"Header"};
402 static const WS_XML_STRING msgid = {9, (BYTE *)"MessageID"}, replyto = {7, (BYTE *)"ReplyTo"};
403 static const WS_XML_STRING address = {7, (BYTE *)"Address"}, body = {4, (BYTE *)"Body"};
404 WS_XML_STRING ns_env, ns_addr;
405 WS_XML_UTF8_TEXT urn, addr;
406 HRESULT hr;
407 ULONG i;
408
409 if ((hr = get_env_namespace( msg->version_env, &ns_env )) != S_OK) return hr;
410 if ((hr = get_addr_namespace( msg->version_addr, &ns_addr )) != S_OK) return hr;
411
412 if ((hr = WsWriteStartElement( writer, &prefix_s, &envelope, &ns_env, NULL )) != S_OK) return hr;
413 if (msg->version_addr < WS_ADDRESSING_VERSION_TRANSPORT &&
414 (hr = WsWriteXmlnsAttribute( writer, &prefix_a, &ns_addr, FALSE, NULL )) != S_OK) return hr;
415 if ((hr = WsWriteStartElement( writer, &prefix_s, &header, &ns_env, NULL )) != S_OK) return hr;
416
417 if (msg->version_addr < WS_ADDRESSING_VERSION_TRANSPORT)
418 {
419 if ((hr = WsWriteStartElement( writer, &prefix_a, &msgid, &ns_addr, NULL )) != S_OK) return hr;
420 urn.text.textType = WS_XML_TEXT_TYPE_UNIQUE_ID;
421 memcpy( &urn.value, &msg->id, sizeof(msg->id) );
422 if ((hr = WsWriteText( writer, &urn.text, NULL )) != S_OK) return hr;
423 if ((hr = WsWriteEndElement( writer, NULL )) != S_OK) return hr; /* </a:MessageID> */
424 }
425
426 for (i = 0; i < msg->header_count; i++)
427 {
428 if (msg->header[i]->mapped) continue;
429 if ((hr = WsWriteXmlBuffer( writer, msg->header[i]->u.buf, NULL )) != S_OK) return hr;
430 }
431
432 if (msg->version_addr == WS_ADDRESSING_VERSION_0_9)
433 {
434 if ((hr = WsWriteStartElement( writer, &prefix_a, &replyto, &ns_addr, NULL )) != S_OK) return hr;
435 if ((hr = WsWriteStartElement( writer, &prefix_a, &address, &ns_addr, NULL )) != S_OK) return hr;
436
437 addr.text.textType = WS_XML_TEXT_TYPE_UTF8;
438 addr.value.bytes = (BYTE *)anonymous;
439 addr.value.length = sizeof(anonymous) - 1;
440 if ((hr = WsWriteText( writer, &addr.text, NULL )) != S_OK) return hr;
441 if ((hr = WsWriteEndElement( writer, NULL )) != S_OK) return hr; /* </a:Address> */
442 if ((hr = WsWriteEndElement( writer, NULL )) != S_OK) return hr; /* </a:ReplyTo> */
443 }
444
445 if ((hr = WsWriteEndElement( writer, NULL )) != S_OK) return hr; /* </s:Header> */
446 return WsWriteStartElement( writer, &prefix_s, &body, &ns_env, NULL ); /* <s:Body> */
447 }
448
449 static HRESULT write_envelope_end( WS_XML_WRITER *writer )
450 {
451 HRESULT hr;
452 if ((hr = WsWriteEndElement( writer, NULL )) != S_OK) return hr; /* </s:Body> */
453 return WsWriteEndElement( writer, NULL ); /* </s:Envelope> */
454 }
455
456 static HRESULT write_envelope( struct msg *msg )
457 {
458 HRESULT hr;
459 if (!msg->writer && (hr = WsCreateWriter( NULL, 0, &msg->writer, NULL )) != S_OK) return hr;
460 if (!msg->buf && (hr = WsCreateXmlBuffer( msg->heap, NULL, 0, &msg->buf, NULL )) != S_OK) return hr;
461 if ((hr = WsSetOutputToBuffer( msg->writer, msg->buf, NULL, 0, NULL )) != S_OK) return hr;
462 if ((hr = write_envelope_start( msg, msg->writer )) != S_OK) return hr;
463 return write_envelope_end( msg->writer );
464 }
465
466 /**************************************************************************
467 * WsWriteEnvelopeStart [webservices.@]
468 */
469 HRESULT WINAPI WsWriteEnvelopeStart( WS_MESSAGE *handle, WS_XML_WRITER *writer,
470 WS_MESSAGE_DONE_CALLBACK cb, void *state, WS_ERROR *error )
471 {
472 struct msg *msg = (struct msg *)handle;
473 HRESULT hr;
474
475 TRACE( "%p %p %p %p %p\n", handle, writer, cb, state, error );
476 if (error) FIXME( "ignoring error parameter\n" );
477 if (cb)
478 {
479 FIXME( "callback not supported\n" );
480 return E_NOTIMPL;
481 }
482
483 if (!handle || !writer) return E_INVALIDARG;
484 if (msg->state != WS_MESSAGE_STATE_INITIALIZED) return WS_E_INVALID_OPERATION;
485
486 if ((hr = write_envelope( msg )) != S_OK) return hr;
487 if ((hr = write_envelope_start( msg, writer )) != S_OK) return hr;
488
489 msg->writer_body = writer;
490 msg->state = WS_MESSAGE_STATE_WRITING;
491 return S_OK;
492 }
493
494 /**************************************************************************
495 * WsWriteEnvelopeEnd [webservices.@]
496 */
497 HRESULT WINAPI WsWriteEnvelopeEnd( WS_MESSAGE *handle, WS_ERROR *error )
498 {
499 struct msg *msg = (struct msg *)handle;
500 HRESULT hr;
501
502 TRACE( "%p %p\n", handle, error );
503 if (error) FIXME( "ignoring error parameter\n" );
504
505 if (!handle) return E_INVALIDARG;
506 if (msg->state != WS_MESSAGE_STATE_WRITING) return WS_E_INVALID_OPERATION;
507
508 if ((hr = write_envelope_end( msg->writer_body )) != S_OK) return hr;
509
510 msg->state = WS_MESSAGE_STATE_DONE;
511 return S_OK;
512 }
513
514 /**************************************************************************
515 * WsWriteBody [webservices.@]
516 */
517 HRESULT WINAPI WsWriteBody( WS_MESSAGE *handle, const WS_ELEMENT_DESCRIPTION *desc, WS_WRITE_OPTION option,
518 const void *value, ULONG size, WS_ERROR *error )
519 {
520 struct msg *msg = (struct msg *)handle;
521 HRESULT hr;
522
523 TRACE( "%p %p %08x %p %u %p\n", handle, desc, option, value, size, error );
524 if (error) FIXME( "ignoring error parameter\n" );
525
526 if (!handle || !desc) return E_INVALIDARG;
527 if (msg->state != WS_MESSAGE_STATE_WRITING) return WS_E_INVALID_OPERATION;
528
529 if (desc->elementLocalName &&
530 (hr = WsWriteStartElement( msg->writer_body, NULL, desc->elementLocalName, desc->elementNs,
531 NULL )) != S_OK) return hr;
532
533 if ((hr = WsWriteType( msg->writer_body, WS_ANY_ELEMENT_TYPE_MAPPING, desc->type, desc->typeDescription,
534 option, value, size, NULL )) != S_OK) return hr;
535
536 if (desc->elementLocalName) hr = WsWriteEndElement( msg->writer_body, NULL );
537 return hr;
538 }
539
540 static BOOL match_current_element( WS_XML_READER *reader, const WS_XML_STRING *localname )
541 {
542 const WS_XML_NODE *node;
543 const WS_XML_ELEMENT_NODE *elem;
544
545 if (WsGetReaderNode( reader, &node, NULL ) != S_OK) return FALSE;
546 if (node->nodeType != WS_XML_NODE_TYPE_ELEMENT) return FALSE;
547 elem = (const WS_XML_ELEMENT_NODE *)node;
548 return WsXmlStringEquals( elem->localName, localname, NULL ) == S_OK;
549 }
550
551 static HRESULT read_envelope_start( WS_XML_READER *reader )
552 {
553 static const WS_XML_STRING envelope = {8, (BYTE *)"Envelope"}, body = {4, (BYTE *)"Body"};
554 HRESULT hr;
555
556 if ((hr = WsReadNode( reader, NULL )) != S_OK) return hr;
557 if (!match_current_element( reader, &envelope )) return WS_E_INVALID_FORMAT;
558 /* FIXME: read headers */
559 if ((hr = WsReadNode( reader, NULL )) != S_OK) return hr;
560 if (!match_current_element( reader, &body )) return WS_E_INVALID_FORMAT;
561 return WsReadNode( reader, NULL );
562 }
563
564 /**************************************************************************
565 * WsReadEnvelopeStart [webservices.@]
566 */
567 HRESULT WINAPI WsReadEnvelopeStart( WS_MESSAGE *handle, WS_XML_READER *reader, WS_MESSAGE_DONE_CALLBACK cb,
568 void *state, WS_ERROR *error )
569 {
570 struct msg *msg = (struct msg *)handle;
571 HRESULT hr;
572
573 TRACE( "%p %p %p %p %p\n", handle, reader, cb, state, error );
574 if (error) FIXME( "ignoring error parameter\n" );
575 if (cb)
576 {
577 FIXME( "callback not supported\n" );
578 return E_NOTIMPL;
579 }
580
581 if (!handle || !reader) return E_INVALIDARG;
582 if (msg->state != WS_MESSAGE_STATE_EMPTY) return WS_E_INVALID_OPERATION;
583
584 if ((hr = read_envelope_start( reader )) != S_OK) return hr;
585
586 msg->reader_body = reader;
587 msg->state = WS_MESSAGE_STATE_READING;
588 return S_OK;
589 }
590
591 static HRESULT read_envelope_end( WS_XML_READER *reader )
592 {
593 HRESULT hr;
594 if ((hr = WsReadEndElement( reader, NULL )) != S_OK) return hr; /* </s:Body> */
595 return WsReadEndElement( reader, NULL ); /* </s:Envelope> */
596 }
597
598 /**************************************************************************
599 * WsReadEnvelopeEnd [webservices.@]
600 */
601 HRESULT WINAPI WsReadEnvelopeEnd( WS_MESSAGE *handle, WS_ERROR *error )
602 {
603 struct msg *msg = (struct msg *)handle;
604 HRESULT hr;
605
606 TRACE( "%p %p\n", handle, error );
607 if (error) FIXME( "ignoring error parameter\n" );
608
609 if (!handle) return E_INVALIDARG;
610 if (msg->state != WS_MESSAGE_STATE_READING) return WS_E_INVALID_OPERATION;
611
612 if ((hr = read_envelope_end( msg->reader_body )) != S_OK) return hr;
613
614 msg->state = WS_MESSAGE_STATE_DONE;
615 return S_OK;
616 }
617
618 /**************************************************************************
619 * WsReadBody [webservices.@]
620 */
621 HRESULT WINAPI WsReadBody( WS_MESSAGE *handle, const WS_ELEMENT_DESCRIPTION *desc, WS_READ_OPTION option,
622 WS_HEAP *heap, void *value, ULONG size, WS_ERROR *error )
623 {
624 struct msg *msg = (struct msg *)handle;
625
626 TRACE( "%p %p %08x %p %p %u %p\n", handle, desc, option, heap, value, size, error );
627 if (error) FIXME( "ignoring error parameter\n" );
628
629 if (!handle || !desc) return E_INVALIDARG;
630 if (msg->state != WS_MESSAGE_STATE_READING) return WS_E_INVALID_OPERATION;
631
632 return WsReadElement( msg->reader_body, desc, option, heap, value, size, NULL );
633 }
634
635 /**************************************************************************
636 * WsInitializeMessage [webservices.@]
637 */
638 HRESULT WINAPI WsInitializeMessage( WS_MESSAGE *handle, WS_MESSAGE_INITIALIZATION init,
639 WS_MESSAGE *src_handle, WS_ERROR *error )
640 {
641 struct msg *msg = (struct msg *)handle;
642
643 TRACE( "%p %u %p %p\n", handle, init, src_handle, error );
644 if (error) FIXME( "ignoring error parameter\n" );
645 if (src_handle)
646 {
647 FIXME( "src message not supported\n" );
648 return E_NOTIMPL;
649 }
650
651 if (!handle || init > WS_FAULT_MESSAGE) return E_INVALIDARG;
652 if (msg->state >= WS_MESSAGE_STATE_INITIALIZED) return WS_E_INVALID_OPERATION;
653
654 msg->init = init;
655 msg->state = WS_MESSAGE_STATE_INITIALIZED;
656 return write_envelope( msg );
657 }
658
659 static HRESULT grow_header_array( struct msg *msg, ULONG size )
660 {
661 struct header **tmp;
662 if (size <= msg->header_size) return S_OK;
663 if (!(tmp = heap_realloc( msg->header, 2 * msg->header_size * sizeof(struct header *) )))
664 return E_OUTOFMEMORY;
665 msg->header = tmp;
666 msg->header_size *= 2;
667 return S_OK;
668 }
669
670 static struct header *alloc_header( WS_HEADER_TYPE type, BOOL mapped, const WS_XML_STRING *name,
671 const WS_XML_STRING *ns )
672 {
673 struct header *ret;
674 if (!(ret = heap_alloc_zero( sizeof(*ret) ))) return NULL;
675 if (name && name->length)
676 {
677 if (!(ret->name.bytes = heap_alloc( name->length )))
678 {
679 free_header( ret );
680 return NULL;
681 }
682 memcpy( ret->name.bytes, name->bytes, name->length );
683 ret->name.length = name->length;
684 }
685 if (ns && ns->length)
686 {
687 if (!(ret->ns.bytes = heap_alloc( ns->length )))
688 {
689 free_header( ret );
690 return NULL;
691 }
692 memcpy( ret->ns.bytes, ns->bytes, ns->length );
693 ret->ns.length = ns->length;
694 }
695 ret->type = type;
696 ret->mapped = mapped;
697 return ret;
698 }
699
700 static HRESULT write_standard_header( WS_XML_WRITER *writer, const WS_XML_STRING *name, WS_TYPE value_type,
701 WS_WRITE_OPTION option, const void *value, ULONG size )
702 {
703 static const WS_XML_STRING prefix_s = {1, (BYTE *)"s"}, prefix_a = {1, (BYTE *)"a"};
704 static const WS_XML_STRING understand = {14, (BYTE *)"mustUnderstand"}, ns = {0, NULL};
705 WS_XML_INT32_TEXT one = {{WS_XML_TEXT_TYPE_INT32}, 1};
706 HRESULT hr;
707
708 if ((hr = WsWriteStartElement( writer, &prefix_a, name, &ns, NULL )) != S_OK) return hr;
709 if ((hr = WsWriteStartAttribute( writer, &prefix_s, &understand, &ns, FALSE, NULL )) != S_OK) return hr;
710 if ((hr = WsWriteText( writer, &one.text, NULL )) != S_OK) return hr;
711 if ((hr = WsWriteEndAttribute( writer, NULL )) != S_OK) return hr;
712 if ((hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, value_type, NULL, option, value, size,
713 NULL )) != S_OK) return hr;
714 return WsWriteEndElement( writer, NULL );
715 }
716
717 static HRESULT build_standard_header( WS_HEAP *heap, WS_HEADER_TYPE type, WS_TYPE value_type,
718 WS_WRITE_OPTION option, const void *value, ULONG size,
719 struct header **ret )
720 {
721 const WS_XML_STRING *name = get_header_name( type );
722 struct header *header;
723 WS_XML_WRITER *writer;
724 WS_XML_BUFFER *buf;
725 HRESULT hr;
726
727 if (!(header = alloc_header( type, FALSE, name, NULL ))) return E_OUTOFMEMORY;
728
729 if ((hr = WsCreateWriter( NULL, 0, &writer, NULL )) != S_OK) goto done;
730 if ((hr = WsCreateXmlBuffer( heap, NULL, 0, &buf, NULL )) != S_OK) goto done;
731 if ((hr = WsSetOutputToBuffer( writer, buf, NULL, 0, NULL )) != S_OK) goto done;
732 if ((hr = write_standard_header( writer, name, value_type, option, value, size )) != S_OK)
733 goto done;
734
735 header->u.buf = buf;
736
737 done:
738 if (hr != S_OK) free_header( header );
739 else *ret = header;
740 WsFreeWriter( writer );
741 return hr;
742 }
743
744 /**************************************************************************
745 * WsSetHeader [webservices.@]
746 */
747 HRESULT WINAPI WsSetHeader( WS_MESSAGE *handle, WS_HEADER_TYPE type, WS_TYPE value_type,
748 WS_WRITE_OPTION option, const void *value, ULONG size, WS_ERROR *error )
749 {
750 struct msg *msg = (struct msg *)handle;
751 struct header *header;
752 BOOL found = FALSE;
753 HRESULT hr;
754 ULONG i;
755
756 TRACE( "%p %u %u %08x %p %u %p\n", handle, type, value_type, option, value, size, error );
757 if (error) FIXME( "ignoring error parameter\n" );
758
759 if (!handle || type < WS_ACTION_HEADER || type > WS_FAULT_TO_HEADER) return E_INVALIDARG;
760 if (msg->state < WS_MESSAGE_STATE_INITIALIZED) return WS_E_INVALID_OPERATION;
761
762 for (i = 0; i < msg->header_count; i++)
763 {
764 if (msg->header[i]->type == type)
765 {
766 found = TRUE;
767 break;
768 }
769 }
770
771 if (!found)
772 {
773 if ((hr = grow_header_array( msg, msg->header_count + 1 )) != S_OK) return hr;
774 i = msg->header_count;
775 }
776
777 if ((hr = build_standard_header( msg->heap, type, value_type, option, value, size, &header )) != S_OK)
778 return hr;
779
780 if (!found) msg->header_count++;
781 else free_header( msg->header[i] );
782
783 msg->header[i] = header;
784 return write_envelope( msg );
785 }
786
787 static void remove_header( struct msg *msg, ULONG i )
788 {
789 free_header( msg->header[i] );
790 memmove( &msg->header[i], &msg->header[i + 1], (msg->header_count - i) * sizeof(struct header *) );
791 msg->header_count--;
792 }
793
794 /**************************************************************************
795 * WsRemoveHeader [webservices.@]
796 */
797 HRESULT WINAPI WsRemoveHeader( WS_MESSAGE *handle, WS_HEADER_TYPE type, WS_ERROR *error )
798 {
799 struct msg *msg = (struct msg *)handle;
800 BOOL removed = FALSE;
801 ULONG i;
802
803 TRACE( "%p %u %p\n", handle, type, error );
804 if (error) FIXME( "ignoring error parameter\n" );
805
806 if (!handle) return E_INVALIDARG;
807 if (msg->state < WS_MESSAGE_STATE_INITIALIZED) return WS_E_INVALID_OPERATION;
808 if (type < WS_ACTION_HEADER || type > WS_FAULT_TO_HEADER) return E_INVALIDARG;
809
810 for (i = 0; i < msg->header_count; i++)
811 {
812 if (msg->header[i]->type == type)
813 {
814 remove_header( msg, i );
815 removed = TRUE;
816 break;
817 }
818 }
819
820 if (removed) return write_envelope( msg );
821 return S_OK;
822 }
823
824 static HRESULT build_mapped_header( const WS_XML_STRING *name, WS_TYPE type, WS_WRITE_OPTION option,
825 const void *value, ULONG size, struct header **ret )
826 {
827 struct header *header;
828
829 if (!(header = alloc_header( 0, TRUE, name, NULL ))) return E_OUTOFMEMORY;
830 switch (type)
831 {
832 case WS_WSZ_TYPE:
833 {
834 int len;
835 const WCHAR *src;
836
837 if (option != WS_WRITE_REQUIRED_POINTER || size != sizeof(WCHAR *))
838 {
839 free_header( header );
840 return E_INVALIDARG;
841 }
842 src = *(const WCHAR **)value;
843 len = WideCharToMultiByte( CP_UTF8, 0, src, -1, NULL, 0, NULL, NULL ) - 1;
844 if (!(header->u.text = alloc_xml_string( NULL, len )))
845 {
846 free_header( header );
847 return E_OUTOFMEMORY;
848 }
849 WideCharToMultiByte( CP_UTF8, 0, src, -1, (char *)header->u.text->bytes, len, NULL, NULL );
850 break;
851 }
852 case WS_XML_STRING_TYPE:
853 {
854 const WS_XML_STRING *str = value;
855
856 if (option != WS_WRITE_REQUIRED_VALUE)
857 {
858 FIXME( "unhandled write option %u\n", option );
859 free_header( header );
860 return E_NOTIMPL;
861 }
862 if (size != sizeof(*str))
863 {
864 free_header( header );
865 return E_INVALIDARG;
866 }
867 if (!(header->u.text = alloc_xml_string( NULL, str->length )))
868 {
869 free_header( header );
870 return E_OUTOFMEMORY;
871 }
872 memcpy( header->u.text->bytes, str->bytes, str->length );
873 break;
874 }
875 case WS_STRING_TYPE:
876 {
877 int len;
878 const WS_STRING *str = value;
879
880 if (option != WS_WRITE_REQUIRED_VALUE)
881 {
882 FIXME( "unhandled write option %u\n", option );
883 free_header( header );
884 return E_NOTIMPL;
885 }
886 if (size != sizeof(*str))
887 {
888 free_header( header );
889 return E_INVALIDARG;
890 }
891 len = WideCharToMultiByte( CP_UTF8, 0, str->chars, str->length, NULL, 0, NULL, NULL );
892 if (!(header->u.text = alloc_xml_string( NULL, len )))
893 {
894 free_header( header );
895 return E_OUTOFMEMORY;
896 }
897 WideCharToMultiByte( CP_UTF8, 0, str->chars, str->length, (char *)header->u.text->bytes,
898 len, NULL, NULL );
899 break;
900 }
901 default:
902 FIXME( "unhandled type %u\n", type );
903 free_header( header );
904 return E_NOTIMPL;
905 }
906
907 *ret = header;
908 return S_OK;
909 }
910
911 /**************************************************************************
912 * WsAddMappedHeader [webservices.@]
913 */
914 HRESULT WINAPI WsAddMappedHeader( WS_MESSAGE *handle, const WS_XML_STRING *name, WS_TYPE type,
915 WS_WRITE_OPTION option, const void *value, ULONG size , WS_ERROR *error )
916 {
917 struct msg *msg = (struct msg *)handle;
918 struct header *header;
919 BOOL found = FALSE;
920 HRESULT hr;
921 ULONG i;
922
923 TRACE( "%p %s %u %08x %p %u %p\n", handle, debugstr_xmlstr(name), type, option, value, size, error );
924 if (error) FIXME( "ignoring error parameter\n" );
925
926 if (!handle || !name) return E_INVALIDARG;
927 if (msg->state < WS_MESSAGE_STATE_INITIALIZED) return WS_E_INVALID_OPERATION;
928
929 for (i = 0; i < msg->header_count; i++)
930 {
931 if (msg->header[i]->type || !msg->header[i]->mapped) continue;
932 if (WsXmlStringEquals( name, &msg->header[i]->name, NULL ) == S_OK)
933 {
934 found = TRUE;
935 break;
936 }
937 }
938
939 if (!found)
940 {
941 if ((hr = grow_header_array( msg, msg->header_count + 1 )) != S_OK) return hr;
942 i = msg->header_count;
943 }
944
945 if ((hr = build_mapped_header( name, type, option, value, size, &header )) != S_OK) return hr;
946
947 if (!found) msg->header_count++;
948 else free_header( msg->header[i] );
949
950 msg->header[i] = header;
951 return S_OK;
952 }
953
954 /**************************************************************************
955 * WsRemoveMappedHeader [webservices.@]
956 */
957 HRESULT WINAPI WsRemoveMappedHeader( WS_MESSAGE *handle, const WS_XML_STRING *name, WS_ERROR *error )
958 {
959 struct msg *msg = (struct msg *)handle;
960 ULONG i;
961
962 TRACE( "%p %s %p\n", handle, debugstr_xmlstr(name), error );
963 if (error) FIXME( "ignoring error parameter\n" );
964
965 if (!handle || !name) return E_INVALIDARG;
966 if (msg->state < WS_MESSAGE_STATE_INITIALIZED) return WS_E_INVALID_OPERATION;
967
968 for (i = 0; i < msg->header_count; i++)
969 {
970 if (msg->header[i]->type || !msg->header[i]->mapped) continue;
971 if (WsXmlStringEquals( name, &msg->header[i]->name, NULL ) == S_OK)
972 {
973 remove_header( msg, i );
974 break;
975 }
976 }
977
978 return S_OK;
979 }
980
981 static HRESULT write_custom_header( WS_XML_WRITER *writer, const WS_XML_STRING *name, const WS_XML_STRING *ns,
982 WS_TYPE type, const void *desc, WS_WRITE_OPTION option, const void *value,
983 ULONG size )
984 {
985 HRESULT hr;
986 if ((hr = WsWriteStartElement( writer, NULL, name, ns, NULL )) != S_OK) return hr;
987 if ((hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, type, desc, option, value, size,
988 NULL )) != S_OK) return hr;
989 return WsWriteEndElement( writer, NULL );
990 }
991
992 static HRESULT build_custom_header( WS_HEAP *heap, const WS_XML_STRING *name, const WS_XML_STRING *ns,
993 WS_TYPE type, const void *desc, WS_WRITE_OPTION option, const void *value,
994 ULONG size, struct header **ret )
995 {
996 struct header *header;
997 WS_XML_WRITER *writer;
998 WS_XML_BUFFER *buf;
999 HRESULT hr;
1000
1001 if (!(header = alloc_header( 0, FALSE, name, ns ))) return E_OUTOFMEMORY;
1002
1003 if ((hr = WsCreateWriter( NULL, 0, &writer, NULL )) != S_OK) goto done;
1004 if ((hr = WsCreateXmlBuffer( heap, NULL, 0, &buf, NULL )) != S_OK) goto done;
1005 if ((hr = WsSetOutputToBuffer( writer, buf, NULL, 0, NULL )) != S_OK) goto done;
1006 if ((hr = write_custom_header( writer, name, ns, type, desc, option, value, size )) != S_OK) goto done;
1007
1008 header->u.buf = buf;
1009
1010 done:
1011 if (hr != S_OK) free_header( header );
1012 else *ret = header;
1013 WsFreeWriter( writer );
1014 return hr;
1015 }
1016
1017 /**************************************************************************
1018 * WsAddCustomHeader [webservices.@]
1019 */
1020 HRESULT WINAPI WsAddCustomHeader( WS_MESSAGE *handle, const WS_ELEMENT_DESCRIPTION *desc, WS_WRITE_OPTION option,
1021 const void *value, ULONG size, ULONG attrs, WS_ERROR *error )
1022 {
1023 struct msg *msg = (struct msg *)handle;
1024 struct header *header;
1025 BOOL found = FALSE;
1026 HRESULT hr;
1027 ULONG i;
1028
1029 TRACE( "%p %p %08x %p %u %08x %p\n", handle, desc, option, value, size, attrs, error );
1030 if (error) FIXME( "ignoring error parameter\n" );
1031
1032 if (!handle || !desc) return E_INVALIDARG;
1033 if (msg->state < WS_MESSAGE_STATE_INITIALIZED) return WS_E_INVALID_OPERATION;
1034
1035 for (i = 0; i < msg->header_count; i++)
1036 {
1037 if (msg->header[i]->type || msg->header[i]->mapped) continue;
1038 if (WsXmlStringEquals( desc->elementLocalName, &msg->header[i]->name, NULL ) &&
1039 WsXmlStringEquals( desc->elementNs, &msg->header[i]->ns, NULL ) == S_OK)
1040 {
1041 found = TRUE;
1042 break;
1043 }
1044 }
1045
1046 if (!found)
1047 {
1048 if ((hr = grow_header_array( msg, msg->header_count + 1 )) != S_OK) return hr;
1049 i = msg->header_count;
1050 }
1051
1052 if ((hr = build_custom_header( msg->heap, desc->elementLocalName, desc->elementNs, desc->type,
1053 desc->typeDescription, option, value, size, &header )) != S_OK) return hr;
1054
1055 if (!found) msg->header_count++;
1056 else free_header( msg->header[i] );
1057
1058 msg->header[i] = header;
1059 return write_envelope( msg );
1060 }
1061
1062 /**************************************************************************
1063 * WsRemoveCustomHeader [webservices.@]
1064 */
1065 HRESULT WINAPI WsRemoveCustomHeader( WS_MESSAGE *handle, const WS_XML_STRING *name, const WS_XML_STRING *ns,
1066 WS_ERROR *error )
1067 {
1068 struct msg *msg = (struct msg *)handle;
1069 BOOL removed = FALSE;
1070 ULONG i;
1071
1072 TRACE( "%p %s %s %p\n", handle, debugstr_xmlstr(name), debugstr_xmlstr(ns), error );
1073 if (error) FIXME( "ignoring error parameter\n" );
1074
1075 if (!handle || !name || !ns) return E_INVALIDARG;
1076 if (msg->state < WS_MESSAGE_STATE_INITIALIZED) return WS_E_INVALID_OPERATION;
1077
1078 for (i = 0; i < msg->header_count; i++)
1079 {
1080 if (msg->header[i]->type || msg->header[i]->mapped) continue;
1081 if (WsXmlStringEquals( name, &msg->header[i]->name, NULL ) == S_OK &&
1082 WsXmlStringEquals( ns, &msg->header[i]->ns, NULL ) == S_OK)
1083 {
1084 remove_header( msg, i );
1085 removed = TRUE;
1086 break;
1087 }
1088 }
1089
1090 if (removed) return write_envelope( msg );
1091 return S_OK;
1092 }
Windows API implementation