?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
include: Fix __dmb declaration.
[wine.git] / dlls / webservices / channel.c
blobf2906c8673360f968653e91661545da41c00ebcc
1 /*
2 * Copyright 2016 Hans Leidekker for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <stdarg.h>
20
21 #include "windef.h"
22 #include "winbase.h"
23 #include "winuser.h"
24 #include "rpc.h"
25 #include "webservices.h"
26
27 #include "wine/debug.h"
28 #include "wine/heap.h"
29 #include "wine/list.h"
30 #include "webservices_private.h"
31 #include "sock.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(webservices);
34
35 static const struct prop_desc channel_props[] =
36 {
37 { sizeof(ULONG), FALSE }, /* WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE */
38 { sizeof(UINT64), FALSE }, /* WS_CHANNEL_PROPERTY_MAX_STREAMED_MESSAGE_SIZE */
39 { sizeof(ULONG), FALSE }, /* WS_CHANNEL_PROPERTY_MAX_STREAMED_START_SIZE */
40 { sizeof(ULONG), FALSE }, /* WS_CHANNEL_PROPERTY_MAX_STREAMED_FLUSH_SIZE */
41 { sizeof(WS_ENCODING), TRUE }, /* WS_CHANNEL_PROPERTY_ENCODING */
42 { sizeof(WS_ENVELOPE_VERSION), FALSE }, /* WS_CHANNEL_PROPERTY_ENVELOPE_VERSION */
43 { sizeof(WS_ADDRESSING_VERSION), FALSE }, /* WS_CHANNEL_PROPERTY_ADDRESSING_VERSION */
44 { sizeof(ULONG), FALSE }, /* WS_CHANNEL_PROPERTY_MAX_SESSION_DICTIONARY_SIZE */
45 { sizeof(WS_CHANNEL_STATE), TRUE }, /* WS_CHANNEL_PROPERTY_STATE */
46 { sizeof(WS_CALLBACK_MODEL), FALSE }, /* WS_CHANNEL_PROPERTY_ASYNC_CALLBACK_MODEL */
47 { sizeof(WS_IP_VERSION), FALSE }, /* WS_CHANNEL_PROPERTY_IP_VERSION */
48 { sizeof(ULONG), FALSE }, /* WS_CHANNEL_PROPERTY_RESOLVE_TIMEOUT */
49 { sizeof(ULONG), FALSE }, /* WS_CHANNEL_PROPERTY_CONNECT_TIMEOUT */
50 { sizeof(ULONG), FALSE }, /* WS_CHANNEL_PROPERTY_SEND_TIMEOUT */
51 { sizeof(ULONG), FALSE }, /* WS_CHANNEL_PROPERTY_RECEIVE_RESPONSE_TIMEOUT */
52 { sizeof(ULONG), FALSE }, /* WS_CHANNEL_PROPERTY_RECEIVE_TIMEOUT */
53 { sizeof(ULONG), FALSE }, /* WS_CHANNEL_PROPERTY_CLOSE_TIMEOUT */
54 { sizeof(BOOL), FALSE }, /* WS_CHANNEL_PROPERTY_ENABLE_TIMEOUTS */
55 { sizeof(WS_TRANSFER_MODE), FALSE }, /* WS_CHANNEL_PROPERTY_TRANSFER_MODE */
56 { sizeof(ULONG), FALSE }, /* WS_CHANNEL_PROPERTY_MULTICAST_INTERFACE */
57 { sizeof(ULONG), FALSE }, /* WS_CHANNEL_PROPERTY_MULTICAST_HOPS */
58 { sizeof(WS_ENDPOINT_ADDRESS), TRUE }, /* WS_CHANNEL_PROPERTY_REMOTE_ADDRESS */
59 { sizeof(SOCKADDR_STORAGE), TRUE }, /* WS_CHANNEL_PROPERTY_REMOTE_IP_ADDRESS */
60 { sizeof(ULONGLONG), TRUE }, /* WS_CHANNEL_PROPERTY_HTTP_CONNECTION_ID */
61 { sizeof(WS_CUSTOM_CHANNEL_CALLBACKS), FALSE }, /* WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_CALLBACKS */
62 { 0, FALSE }, /* WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_PARAMETERS */
63 { sizeof(void *), FALSE }, /* WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_INSTANCE */
64 { sizeof(WS_STRING), TRUE }, /* WS_CHANNEL_PROPERTY_TRANSPORT_URL */
65 { sizeof(BOOL), FALSE }, /* WS_CHANNEL_PROPERTY_NO_DELAY */
66 { sizeof(BOOL), FALSE }, /* WS_CHANNEL_PROPERTY_SEND_KEEP_ALIVES */
67 { sizeof(ULONG), FALSE }, /* WS_CHANNEL_PROPERTY_KEEP_ALIVE_TIME */
68 { sizeof(ULONG), FALSE }, /* WS_CHANNEL_PROPERTY_KEEP_ALIVE_INTERVAL */
69 { sizeof(ULONG), FALSE }, /* WS_CHANNEL_PROPERTY_MAX_HTTP_SERVER_CONNECTIONS */
70 { sizeof(BOOL), TRUE }, /* WS_CHANNEL_PROPERTY_IS_SESSION_SHUT_DOWN */
71 { sizeof(WS_CHANNEL_TYPE), TRUE }, /* WS_CHANNEL_PROPERTY_CHANNEL_TYPE */
72 { sizeof(ULONG), FALSE }, /* WS_CHANNEL_PROPERTY_TRIM_BUFFERED_MESSAGE_SIZE */
73 { sizeof(WS_CHANNEL_ENCODER), FALSE }, /* WS_CHANNEL_PROPERTY_ENCODER */
74 { sizeof(WS_CHANNEL_DECODER), FALSE }, /* WS_CHANNEL_PROPERTY_DECODER */
75 { sizeof(WS_PROTECTION_LEVEL), TRUE }, /* WS_CHANNEL_PROPERTY_PROTECTION_LEVEL */
76 { sizeof(WS_COOKIE_MODE), FALSE }, /* WS_CHANNEL_PROPERTY_COOKIE_MODE */
77 { sizeof(WS_HTTP_PROXY_SETTING_MODE), FALSE }, /* WS_CHANNEL_PROPERTY_HTTP_PROXY_SETTING_MODE */
78 { sizeof(WS_CUSTOM_HTTP_PROXY), FALSE }, /* WS_CHANNEL_PROPERTY_CUSTOM_HTTP_PROXY */
79 { sizeof(WS_HTTP_MESSAGE_MAPPING), FALSE }, /* WS_CHANNEL_PROPERTY_HTTP_MESSAGE_MAPPING */
80 { sizeof(BOOL), FALSE }, /* WS_CHANNEL_PROPERTY_ENABLE_HTTP_REDIRECT */
81 { sizeof(WS_HTTP_REDIRECT_CALLBACK_CONTEXT), FALSE }, /* WS_CHANNEL_PROPERTY_HTTP_REDIRECT_CALLBACK_CONTEXT */
82 { sizeof(BOOL), FALSE }, /* WS_CHANNEL_PROPERTY_FAULTS_AS_ERRORS */
83 { sizeof(BOOL), FALSE }, /* WS_CHANNEL_PROPERTY_ALLOW_UNSECURED_FAULTS */
84 { sizeof(WCHAR *), TRUE }, /* WS_CHANNEL_PROPERTY_HTTP_SERVER_SPN */
85 { sizeof(WCHAR *), TRUE }, /* WS_CHANNEL_PROPERTY_HTTP_PROXY_SPN */
86 { sizeof(ULONG), FALSE } /* WS_CHANNEL_PROPERTY_MAX_HTTP_REQUEST_HEADERS_BUFFER_SIZE */
87 };
88
89 struct task
90 {
91 struct list entry;
92 void (*proc)( struct task * );
93 };
94
95 struct queue
96 {
97 CRITICAL_SECTION cs;
98 HANDLE wait;
99 HANDLE cancel;
100 HANDLE ready;
101 struct list tasks;
102 };
103
104 static struct task *dequeue_task( struct queue *queue )
105 {
106 struct task *task;
107
108 EnterCriticalSection( &queue->cs );
109 TRACE( "%u tasks queued\n", list_count( &queue->tasks ) );
110 task = LIST_ENTRY( list_head( &queue->tasks ), struct task, entry );
111 if (task) list_remove( &task->entry );
112 LeaveCriticalSection( &queue->cs );
113
114 TRACE( "returning task %p\n", task );
115 return task;
116 }
117
118 static void CALLBACK queue_runner( TP_CALLBACK_INSTANCE *instance, void *ctx )
119 {
120 struct queue *queue = ctx;
121 HANDLE handles[] = { queue->wait, queue->cancel };
122
123 SetEvent( queue->ready );
124 for (;;)
125 {
126 DWORD err = WaitForMultipleObjects( 2, handles, FALSE, INFINITE );
127 switch (err)
128 {
129 case WAIT_OBJECT_0:
130 {
131 struct task *task;
132 while ((task = dequeue_task( queue )))
133 {
134 task->proc( task );
135 heap_free( task );
136 }
137 break;
138 }
139 case WAIT_OBJECT_0 + 1:
140 TRACE( "cancelled\n" );
141 SetEvent( queue->ready );
142 return;
143
144 default:
145 ERR( "wait failed %u\n", err );
146 return;
147 }
148 }
149 }
150
151 static HRESULT start_queue( struct queue *queue )
152 {
153 HRESULT hr = E_OUTOFMEMORY;
154
155 if (queue->wait) return S_OK;
156 list_init( &queue->tasks );
157 if (!(queue->wait = CreateEventW( NULL, FALSE, FALSE, NULL ))) goto error;
158 if (!(queue->cancel = CreateEventW( NULL, FALSE, FALSE, NULL ))) goto error;
159 if (!(queue->ready = CreateEventW( NULL, FALSE, FALSE, NULL ))) goto error;
160 if (!TrySubmitThreadpoolCallback( queue_runner, queue, NULL )) hr = HRESULT_FROM_WIN32( GetLastError() );
161 else
162 {
163 WaitForSingleObject( queue->ready, INFINITE );
164 return S_OK;
165 }
166
167 error:
168 CloseHandle( queue->wait );
169 queue->wait = NULL;
170 CloseHandle( queue->cancel );
171 queue->cancel = NULL;
172 CloseHandle( queue->ready );
173 queue->ready = NULL;
174 return hr;
175 }
176
177 static HRESULT queue_task( struct queue *queue, struct task *task )
178 {
179 HRESULT hr;
180 if ((hr = start_queue( queue )) != S_OK) return hr;
181
182 EnterCriticalSection( &queue->cs );
183 TRACE( "queueing task %p\n", task );
184 list_add_tail( &queue->tasks, &task->entry );
185 LeaveCriticalSection( &queue->cs );
186
187 SetEvent( queue->wait );
188 return WS_S_ASYNC;
189 };
190
191 enum session_state
192 {
193 SESSION_STATE_UNINITIALIZED,
194 SESSION_STATE_SETUP_COMPLETE,
195 SESSION_STATE_SHUTDOWN,
196 };
197
198 struct channel
199 {
200 ULONG magic;
201 CRITICAL_SECTION cs;
202 WS_CHANNEL_TYPE type;
203 WS_CHANNEL_BINDING binding;
204 WS_CHANNEL_STATE state;
205 WS_ENDPOINT_ADDRESS addr;
206 WS_XML_WRITER *writer;
207 WS_XML_READER *reader;
208 WS_MESSAGE *msg;
209 WS_ENCODING encoding;
210 enum session_state session_state;
211 struct dictionary dict_send;
212 struct dictionary dict_recv;
213 struct queue send_q;
214 struct queue recv_q;
215 union
216 {
217 struct
218 {
219 HINTERNET session;
220 HINTERNET connect;
221 HINTERNET request;
222 WCHAR *path;
223 DWORD flags;
224 } http;
225 struct
226 {
227 SOCKET socket;
228 } tcp;
229 struct
230 {
231 SOCKET socket;
232 } udp;
233 } u;
234 char *read_buf;
235 ULONG read_buflen;
236 ULONG read_size;
237 ULONG prop_count;
238 struct prop prop[ARRAY_SIZE( channel_props )];
239 };
240
241 #define CHANNEL_MAGIC (('C' << 24) | ('H' << 16) | ('A' << 8) | 'N')
242
243 static struct channel *alloc_channel(void)
244 {
245 static const ULONG count = ARRAY_SIZE( channel_props );
246 struct channel *ret;
247 ULONG size = sizeof(*ret) + prop_size( channel_props, count );
248
249 if (!(ret = heap_alloc_zero( size ))) return NULL;
250
251 ret->magic = CHANNEL_MAGIC;
252 InitializeCriticalSection( &ret->cs );
253 InitializeCriticalSection( &ret->send_q.cs );
254 InitializeCriticalSection( &ret->recv_q.cs );
255 ret->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": channel.cs");
256 ret->send_q.cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": channel.send_q.cs");
257 ret->recv_q.cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": channel.recv_q.cs");
258
259 prop_init( channel_props, count, ret->prop, &ret[1] );
260 ret->prop_count = count;
261 return ret;
262 }
263
264 static void clear_addr( WS_ENDPOINT_ADDRESS *addr )
265 {
266 heap_free( addr->url.chars );
267 addr->url.chars = NULL;
268 addr->url.length = 0;
269 }
270
271 static void clear_queue( struct queue *queue )
272 {
273 struct list *ptr;
274
275 SetEvent( queue->cancel );
276 WaitForSingleObject( queue->ready, INFINITE );
277
278 while ((ptr = list_head( &queue->tasks )))
279 {
280 struct task *task = LIST_ENTRY( ptr, struct task, entry );
281 list_remove( &task->entry );
282 heap_free( task );
283 }
284
285 CloseHandle( queue->wait );
286 queue->wait = NULL;
287 CloseHandle( queue->cancel );
288 queue->cancel = NULL;
289 CloseHandle( queue->ready );
290 queue->ready = NULL;
291 }
292
293 static void reset_channel( struct channel *channel )
294 {
295 clear_queue( &channel->send_q );
296 clear_queue( &channel->recv_q );
297 channel->state = WS_CHANNEL_STATE_CREATED;
298 channel->session_state = SESSION_STATE_UNINITIALIZED;
299 clear_addr( &channel->addr );
300 clear_dict( &channel->dict_send );
301 clear_dict( &channel->dict_recv );
302 channel->msg = NULL;
303 channel->read_size = 0;
304
305 switch (channel->binding)
306 {
307 case WS_HTTP_CHANNEL_BINDING:
308 WinHttpCloseHandle( channel->u.http.request );
309 channel->u.http.request = NULL;
310 WinHttpCloseHandle( channel->u.http.connect );
311 channel->u.http.connect = NULL;
312 WinHttpCloseHandle( channel->u.http.session );
313 channel->u.http.session = NULL;
314 heap_free( channel->u.http.path );
315 channel->u.http.path = NULL;
316 channel->u.http.flags = 0;
317 break;
318
319 case WS_TCP_CHANNEL_BINDING:
320 closesocket( channel->u.tcp.socket );
321 channel->u.tcp.socket = -1;
322 break;
323
324 case WS_UDP_CHANNEL_BINDING:
325 closesocket( channel->u.udp.socket );
326 channel->u.udp.socket = -1;
327 break;
328
329 default: break;
330 }
331 }
332
333 static void free_header_mappings( WS_HTTP_HEADER_MAPPING **mappings, ULONG count )
334 {
335 ULONG i;
336 for (i = 0; i < count; i++) heap_free( mappings[i] );
337 heap_free( mappings );
338 }
339
340 static void free_message_mapping( const WS_HTTP_MESSAGE_MAPPING *mapping )
341 {
342 free_header_mappings( mapping->requestHeaderMappings, mapping->requestHeaderMappingCount );
343 free_header_mappings( mapping->responseHeaderMappings, mapping->responseHeaderMappingCount );
344 }
345
346 static void free_props( struct channel *channel )
347 {
348 struct prop *prop = &channel->prop[WS_CHANNEL_PROPERTY_HTTP_MESSAGE_MAPPING];
349 WS_HTTP_MESSAGE_MAPPING *mapping = (WS_HTTP_MESSAGE_MAPPING *)prop->value;
350 free_message_mapping( mapping );
351 }
352
353 static void free_channel( struct channel *channel )
354 {
355 reset_channel( channel );
356
357 WsFreeWriter( channel->writer );
358 WsFreeReader( channel->reader );
359
360 heap_free( channel->read_buf );
361 free_props( channel );
362
363 channel->send_q.cs.DebugInfo->Spare[0] = 0;
364 channel->recv_q.cs.DebugInfo->Spare[0] = 0;
365 channel->cs.DebugInfo->Spare[0] = 0;
366 DeleteCriticalSection( &channel->send_q.cs );
367 DeleteCriticalSection( &channel->recv_q.cs );
368 DeleteCriticalSection( &channel->cs );
369 heap_free( channel );
370 }
371
372 static WS_HTTP_HEADER_MAPPING *dup_header_mapping( const WS_HTTP_HEADER_MAPPING *src )
373 {
374 WS_HTTP_HEADER_MAPPING *dst;
375
376 if (!(dst = heap_alloc( sizeof(*dst) + src->headerName.length ))) return NULL;
377
378 dst->headerName.bytes = (BYTE *)(dst + 1);
379 memcpy( dst->headerName.bytes, src->headerName.bytes, src->headerName.length );
380 dst->headerName.length = src->headerName.length;
381 dst->headerMappingOptions = src->headerMappingOptions;
382 return dst;
383 }
384
385 static HRESULT dup_message_mapping( const WS_HTTP_MESSAGE_MAPPING *src, WS_HTTP_MESSAGE_MAPPING *dst )
386 {
387 ULONG i, size;
388
389 size = src->requestHeaderMappingCount * sizeof(*dst->responseHeaderMappings);
390 if (!(dst->requestHeaderMappings = heap_alloc( size ))) return E_OUTOFMEMORY;
391
392 for (i = 0; i < src->requestHeaderMappingCount; i++)
393 {
394 if (!(dst->requestHeaderMappings[i] = dup_header_mapping( src->requestHeaderMappings[i] )))
395 {
396 free_header_mappings( dst->requestHeaderMappings, i );
397 return E_OUTOFMEMORY;
398 }
399 }
400
401 size = src->responseHeaderMappingCount * sizeof(*dst->responseHeaderMappings);
402 if (!(dst->responseHeaderMappings = heap_alloc( size )))
403 {
404 heap_free( dst->responseHeaderMappings );
405 return E_OUTOFMEMORY;
406 }
407
408 for (i = 0; i < src->responseHeaderMappingCount; i++)
409 {
410 if (!(dst->responseHeaderMappings[i] = dup_header_mapping( src->responseHeaderMappings[i] )))
411 {
412 free_header_mappings( dst->responseHeaderMappings, i );
413 return E_OUTOFMEMORY;
414 }
415 }
416
417 dst->requestMappingOptions = src->requestMappingOptions;
418 dst->responseMappingOptions = src->responseMappingOptions;
419 dst->requestHeaderMappingCount = src->requestHeaderMappingCount;
420 dst->responseHeaderMappingCount = src->responseHeaderMappingCount;
421 return S_OK;
422 }
423
424 static HRESULT create_channel( WS_CHANNEL_TYPE type, WS_CHANNEL_BINDING binding,
425 const WS_CHANNEL_PROPERTY *properties, ULONG count, struct channel **ret )
426 {
427 struct channel *channel;
428 ULONG i, msg_size = 65536;
429 WS_ENVELOPE_VERSION env_version = WS_ENVELOPE_VERSION_SOAP_1_2;
430 WS_ADDRESSING_VERSION addr_version = WS_ADDRESSING_VERSION_1_0;
431 HRESULT hr;
432
433 if (!(channel = alloc_channel())) return E_OUTOFMEMORY;
434
435 prop_set( channel->prop, channel->prop_count, WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE,
436 &msg_size, sizeof(msg_size) );
437 prop_set( channel->prop, channel->prop_count, WS_CHANNEL_PROPERTY_ENVELOPE_VERSION,
438 &env_version, sizeof(env_version) );
439 prop_set( channel->prop, channel->prop_count, WS_CHANNEL_PROPERTY_ADDRESSING_VERSION,
440 &addr_version, sizeof(addr_version) );
441
442 channel->type = type;
443 channel->binding = binding;
444
445 switch (channel->binding)
446 {
447 case WS_HTTP_CHANNEL_BINDING:
448 channel->encoding = WS_ENCODING_XML_UTF8;
449 break;
450
451 case WS_TCP_CHANNEL_BINDING:
452 channel->u.tcp.socket = -1;
453 channel->encoding = WS_ENCODING_XML_BINARY_SESSION_1;
454 break;
455
456 case WS_UDP_CHANNEL_BINDING:
457 channel->u.udp.socket = -1;
458 channel->encoding = WS_ENCODING_XML_UTF8;
459 break;
460
461 default: break;
462 }
463
464 for (i = 0; i < count; i++)
465 {
466 const WS_CHANNEL_PROPERTY *prop = &properties[i];
467
468 TRACE( "property id %u value %p size %u\n", prop->id, prop->value, prop->valueSize );
469 if (prop->valueSize == sizeof(ULONG) && prop->value) TRACE( " value %08x\n", *(ULONG *)prop->value );
470
471 switch (prop->id)
472 {
473 case WS_CHANNEL_PROPERTY_ENCODING:
474 if (!prop->value || prop->valueSize != sizeof(channel->encoding))
475 {
476 free_channel( channel );
477 return E_INVALIDARG;
478 }
479 channel->encoding = *(WS_ENCODING *)prop->value;
480 break;
481
482 case WS_CHANNEL_PROPERTY_HTTP_MESSAGE_MAPPING:
483 {
484 const WS_HTTP_MESSAGE_MAPPING *src = (WS_HTTP_MESSAGE_MAPPING *)prop->value;
485 WS_HTTP_MESSAGE_MAPPING dst;
486
487 if (!prop->value || prop->valueSize != sizeof(*src))
488 {
489 free_channel( channel );
490 return E_INVALIDARG;
491 }
492
493 if ((hr = dup_message_mapping( src, &dst )) != S_OK) return hr;
494
495 if ((hr = prop_set( channel->prop, channel->prop_count, WS_CHANNEL_PROPERTY_HTTP_MESSAGE_MAPPING, &dst,
496 sizeof(dst) )) != S_OK)
497 {
498 free_message_mapping( &dst );
499 free_channel( channel );
500 return hr;
501 }
502 break;
503
504 }
505 default:
506 if ((hr = prop_set( channel->prop, channel->prop_count, prop->id, prop->value, prop->valueSize )) != S_OK)
507 {
508 free_channel( channel );
509 return hr;
510 }
511 break;
512 }
513 }
514
515 *ret = channel;
516 return S_OK;
517 }
518
519 /**************************************************************************
520 * WsCreateChannel [webservices.@]
521 */
522 HRESULT WINAPI WsCreateChannel( WS_CHANNEL_TYPE type, WS_CHANNEL_BINDING binding,
523 const WS_CHANNEL_PROPERTY *properties, ULONG count,
524 const WS_SECURITY_DESCRIPTION *desc, WS_CHANNEL **handle,
525 WS_ERROR *error )
526 {
527 struct channel *channel;
528 HRESULT hr;
529
530 TRACE( "%u %u %p %u %p %p %p\n", type, binding, properties, count, desc, handle, error );
531 if (error) FIXME( "ignoring error parameter\n" );
532 if (desc) FIXME( "ignoring security description\n" );
533
534 if (!handle) return E_INVALIDARG;
535
536 if (type != WS_CHANNEL_TYPE_REQUEST && type != WS_CHANNEL_TYPE_DUPLEX &&
537 type != WS_CHANNEL_TYPE_DUPLEX_SESSION)
538 {
539 FIXME( "channel type %u not implemented\n", type );
540 return E_NOTIMPL;
541 }
542 if (binding != WS_HTTP_CHANNEL_BINDING && binding != WS_TCP_CHANNEL_BINDING &&
543 binding != WS_UDP_CHANNEL_BINDING)
544 {
545 FIXME( "channel binding %u not implemented\n", binding );
546 return E_NOTIMPL;
547 }
548
549 if ((hr = create_channel( type, binding, properties, count, &channel )) != S_OK) return hr;
550
551 TRACE( "created %p\n", channel );
552 *handle = (WS_CHANNEL *)channel;
553 return S_OK;
554 }
555
556 /**************************************************************************
557 * WsCreateChannelForListener [webservices.@]
558 */
559 HRESULT WINAPI WsCreateChannelForListener( WS_LISTENER *listener_handle, const WS_CHANNEL_PROPERTY *properties,
560 ULONG count, WS_CHANNEL **handle, WS_ERROR *error )
561 {
562 struct channel *channel;
563 WS_CHANNEL_TYPE type;
564 WS_CHANNEL_BINDING binding;
565 HRESULT hr;
566
567 TRACE( "%p %p %u %p %p\n", listener_handle, properties, count, handle, error );
568 if (error) FIXME( "ignoring error parameter\n" );
569
570 if (!listener_handle || !handle) return E_INVALIDARG;
571
572 if ((hr = WsGetListenerProperty( listener_handle, WS_LISTENER_PROPERTY_CHANNEL_TYPE, &type,
573 sizeof(type), NULL )) != S_OK) return hr;
574
575 if ((hr = WsGetListenerProperty( listener_handle, WS_LISTENER_PROPERTY_CHANNEL_BINDING, &binding,
576 sizeof(binding), NULL )) != S_OK) return hr;
577
578 if ((hr = create_channel( type, binding, properties, count, &channel )) != S_OK) return hr;
579
580 TRACE( "created %p\n", channel );
581 *handle = (WS_CHANNEL *)channel;
582 return S_OK;
583 }
584
585 /**************************************************************************
586 * WsFreeChannel [webservices.@]
587 */
588 void WINAPI WsFreeChannel( WS_CHANNEL *handle )
589 {
590 struct channel *channel = (struct channel *)handle;
591
592 TRACE( "%p\n", handle );
593
594 if (!channel) return;
595
596 EnterCriticalSection( &channel->cs );
597
598 if (channel->magic != CHANNEL_MAGIC)
599 {
600 LeaveCriticalSection( &channel->cs );
601 return;
602 }
603
604 channel->magic = 0;
605
606 LeaveCriticalSection( &channel->cs );
607 free_channel( channel );
608 }
609
610 /**************************************************************************
611 * WsResetChannel [webservices.@]
612 */
613 HRESULT WINAPI WsResetChannel( WS_CHANNEL *handle, WS_ERROR *error )
614 {
615 struct channel *channel = (struct channel *)handle;
616 HRESULT hr = S_OK;
617
618 TRACE( "%p %p\n", handle, error );
619 if (error) FIXME( "ignoring error parameter\n" );
620
621 if (!channel) return E_INVALIDARG;
622
623 EnterCriticalSection( &channel->cs );
624
625 if (channel->magic != CHANNEL_MAGIC)
626 {
627 LeaveCriticalSection( &channel->cs );
628 return E_INVALIDARG;
629 }
630
631 if (channel->state != WS_CHANNEL_STATE_CREATED && channel->state != WS_CHANNEL_STATE_CLOSED)
632 hr = WS_E_INVALID_OPERATION;
633 else
634 reset_channel( channel );
635
636 LeaveCriticalSection( &channel->cs );
637 TRACE( "returning %08x\n", hr );
638 return hr;
639 }
640
641 /**************************************************************************
642 * WsGetChannelProperty [webservices.@]
643 */
644 HRESULT WINAPI WsGetChannelProperty( WS_CHANNEL *handle, WS_CHANNEL_PROPERTY_ID id, void *buf,
645 ULONG size, WS_ERROR *error )
646 {
647 struct channel *channel = (struct channel *)handle;
648 HRESULT hr = S_OK;
649
650 TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
651 if (error) FIXME( "ignoring error parameter\n" );
652
653 if (!channel) return E_INVALIDARG;
654
655 EnterCriticalSection( &channel->cs );
656
657 if (channel->magic != CHANNEL_MAGIC)
658 {
659 LeaveCriticalSection( &channel->cs );
660 return E_INVALIDARG;
661 }
662
663 switch (id)
664 {
665 case WS_CHANNEL_PROPERTY_CHANNEL_TYPE:
666 if (!buf || size != sizeof(channel->type)) hr = E_INVALIDARG;
667 else *(WS_CHANNEL_TYPE *)buf = channel->type;
668 break;
669
670 case WS_CHANNEL_PROPERTY_ENCODING:
671 if (!buf || size != sizeof(channel->encoding)) hr = E_INVALIDARG;
672 else *(WS_ENCODING *)buf = channel->encoding;
673 break;
674
675 default:
676 hr = prop_get( channel->prop, channel->prop_count, id, buf, size );
677 }
678
679 LeaveCriticalSection( &channel->cs );
680 TRACE( "returning %08x\n", hr );
681 return hr;
682 }
683
684 /**************************************************************************
685 * WsSetChannelProperty [webservices.@]
686 */
687 HRESULT WINAPI WsSetChannelProperty( WS_CHANNEL *handle, WS_CHANNEL_PROPERTY_ID id, const void *value,
688 ULONG size, WS_ERROR *error )
689 {
690 struct channel *channel = (struct channel *)handle;
691 HRESULT hr;
692
693 TRACE( "%p %u %p %u\n", handle, id, value, size );
694 if (error) FIXME( "ignoring error parameter\n" );
695
696 if (!channel) return E_INVALIDARG;
697
698 EnterCriticalSection( &channel->cs );
699
700 if (channel->magic != CHANNEL_MAGIC)
701 {
702 LeaveCriticalSection( &channel->cs );
703 return E_INVALIDARG;
704 }
705
706 hr = prop_set( channel->prop, channel->prop_count, id, value, size );
707
708 LeaveCriticalSection( &channel->cs );
709 TRACE( "returning %08x\n", hr );
710 return hr;
711 }
712
713 static HRESULT open_channel( struct channel *channel, const WS_ENDPOINT_ADDRESS *endpoint )
714 {
715 if (endpoint->headers || endpoint->extensions || endpoint->identity)
716 {
717 FIXME( "headers, extensions or identity not supported\n" );
718 return E_NOTIMPL;
719 }
720
721 TRACE( "endpoint %s\n", debugstr_wn(endpoint->url.chars, endpoint->url.length) );
722
723 if (!(channel->addr.url.chars = heap_alloc( endpoint->url.length * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
724 memcpy( channel->addr.url.chars, endpoint->url.chars, endpoint->url.length * sizeof(WCHAR) );
725 channel->addr.url.length = endpoint->url.length;
726
727 channel->state = WS_CHANNEL_STATE_OPEN;
728 return S_OK;
729 }
730
731 /**************************************************************************
732 * WsOpenChannel [webservices.@]
733 */
734 HRESULT WINAPI WsOpenChannel( WS_CHANNEL *handle, const WS_ENDPOINT_ADDRESS *endpoint,
735 const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
736 {
737 struct channel *channel = (struct channel *)handle;
738 HRESULT hr;
739
740 TRACE( "%p %p %p %p\n", handle, endpoint, ctx, error );
741 if (error) FIXME( "ignoring error parameter\n" );
742 if (ctx) FIXME( "ignoring ctx parameter\n" );
743
744 if (!channel || !endpoint) return E_INVALIDARG;
745
746 EnterCriticalSection( &channel->cs );
747
748 if (channel->magic != CHANNEL_MAGIC)
749 {
750 LeaveCriticalSection( &channel->cs );
751 return E_INVALIDARG;
752 }
753
754 if (channel->state != WS_CHANNEL_STATE_CREATED) hr = WS_E_INVALID_OPERATION;
755 else hr = open_channel( channel, endpoint );
756
757 LeaveCriticalSection( &channel->cs );
758 TRACE( "returning %08x\n", hr );
759 return hr;
760 }
761
762 enum frame_record_type
763 {
764 FRAME_RECORD_TYPE_VERSION,
765 FRAME_RECORD_TYPE_MODE,
766 FRAME_RECORD_TYPE_VIA,
767 FRAME_RECORD_TYPE_KNOWN_ENCODING,
768 FRAME_RECORD_TYPE_EXTENSIBLE_ENCODING,
769 FRAME_RECORD_TYPE_UNSIZED_ENVELOPE,
770 FRAME_RECORD_TYPE_SIZED_ENVELOPE,
771 FRAME_RECORD_TYPE_END,
772 FRAME_RECORD_TYPE_FAULT,
773 FRAME_RECORD_TYPE_UPGRADE_REQUEST,
774 FRAME_RECORD_TYPE_UPGRADE_RESPONSE,
775 FRAME_RECORD_TYPE_PREAMBLE_ACK,
776 FRAME_RECORD_TYPE_PREAMBLE_END,
777 };
778
779 static HRESULT send_byte( SOCKET socket, BYTE byte )
780 {
781 int count = send( socket, (char *)&byte, 1, 0 );
782 if (count < 0) return HRESULT_FROM_WIN32( WSAGetLastError() );
783 if (count != 1) return WS_E_OTHER;
784 return S_OK;
785 }
786
787 static HRESULT shutdown_session( struct channel *channel )
788 {
789 HRESULT hr;
790
791 if (channel->state != WS_CHANNEL_STATE_OPEN ||
792 (channel->type != WS_CHANNEL_TYPE_OUTPUT_SESSION &&
793 channel->type != WS_CHANNEL_TYPE_DUPLEX_SESSION) ||
794 channel->session_state >= SESSION_STATE_SHUTDOWN) return WS_E_INVALID_OPERATION;
795
796 switch (channel->binding)
797 {
798 case WS_TCP_CHANNEL_BINDING:
799 if ((hr = send_byte( channel->u.tcp.socket, FRAME_RECORD_TYPE_END )) != S_OK) return hr;
800 channel->session_state = SESSION_STATE_SHUTDOWN;
801 return S_OK;
802
803 default:
804 FIXME( "unhandled binding %u\n", channel->binding );
805 return E_NOTIMPL;
806 }
807 }
808
809 HRESULT WINAPI WsShutdownSessionChannel( WS_CHANNEL *handle, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
810 {
811 struct channel *channel = (struct channel *)handle;
812 HRESULT hr;
813
814 TRACE( "%p %p %p\n", handle, ctx, error );
815 if (error) FIXME( "ignoring error parameter\n" );
816 if (ctx) FIXME( "ignoring ctx parameter\n" );
817
818 if (!channel) return E_INVALIDARG;
819
820 EnterCriticalSection( &channel->cs );
821
822 if (channel->magic != CHANNEL_MAGIC)
823 {
824 LeaveCriticalSection( &channel->cs );
825 return E_INVALIDARG;
826 }
827
828 hr = shutdown_session( channel );
829
830 LeaveCriticalSection( &channel->cs );
831 TRACE( "returning %08x\n", hr );
832 return hr;
833 }
834
835 static void close_channel( struct channel *channel )
836 {
837 reset_channel( channel );
838 channel->state = WS_CHANNEL_STATE_CLOSED;
839 }
840
841 /**************************************************************************
842 * WsCloseChannel [webservices.@]
843 */
844 HRESULT WINAPI WsCloseChannel( WS_CHANNEL *handle, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
845 {
846 struct channel *channel = (struct channel *)handle;
847 HRESULT hr = S_OK;
848
849 TRACE( "%p %p %p\n", handle, ctx, error );
850 if (error) FIXME( "ignoring error parameter\n" );
851 if (ctx) FIXME( "ignoring ctx parameter\n" );
852
853 if (!channel) return E_INVALIDARG;
854
855 EnterCriticalSection( &channel->cs );
856
857 if (channel->magic != CHANNEL_MAGIC)
858 {
859 LeaveCriticalSection( &channel->cs );
860 return E_INVALIDARG;
861 }
862
863 close_channel( channel );
864
865 LeaveCriticalSection( &channel->cs );
866 TRACE( "returning %08x\n", hr );
867 return hr;
868 }
869
870 static HRESULT parse_http_url( const WCHAR *url, ULONG len, URL_COMPONENTS *uc )
871 {
872 HRESULT hr = E_OUTOFMEMORY;
873 WCHAR *tmp;
874 DWORD err;
875
876 memset( uc, 0, sizeof(*uc) );
877 uc->dwStructSize = sizeof(*uc);
878 uc->dwHostNameLength = 128;
879 uc->lpszHostName = heap_alloc( uc->dwHostNameLength * sizeof(WCHAR) );
880 uc->dwUrlPathLength = 128;
881 uc->lpszUrlPath = heap_alloc( uc->dwUrlPathLength * sizeof(WCHAR) );
882 uc->dwExtraInfoLength = 128;
883 uc->lpszExtraInfo = heap_alloc( uc->dwExtraInfoLength * sizeof(WCHAR) );
884 if (!uc->lpszHostName || !uc->lpszUrlPath || !uc->lpszExtraInfo) goto error;
885
886 if (!WinHttpCrackUrl( url, len, ICU_DECODE, uc ))
887 {
888 if ((err = GetLastError()) != ERROR_INSUFFICIENT_BUFFER)
889 {
890 hr = HRESULT_FROM_WIN32( err );
891 goto error;
892 }
893 if (!(tmp = heap_realloc( uc->lpszHostName, uc->dwHostNameLength * sizeof(WCHAR) ))) goto error;
894 uc->lpszHostName = tmp;
895 if (!(tmp = heap_realloc( uc->lpszUrlPath, uc->dwUrlPathLength * sizeof(WCHAR) ))) goto error;
896 uc->lpszUrlPath = tmp;
897 if (!(tmp = heap_realloc( uc->lpszExtraInfo, uc->dwExtraInfoLength * sizeof(WCHAR) ))) goto error;
898 uc->lpszExtraInfo = tmp;
899 WinHttpCrackUrl( url, len, ICU_DECODE, uc );
900 }
901
902 return S_OK;
903
904 error:
905 heap_free( uc->lpszHostName );
906 heap_free( uc->lpszUrlPath );
907 heap_free( uc->lpszExtraInfo );
908 return hr;
909 }
910
911 static HRESULT connect_channel_http( struct channel *channel )
912 {
913 HINTERNET ses = NULL, con = NULL;
914 URL_COMPONENTS uc;
915 HRESULT hr;
916
917 if (channel->u.http.connect) return S_OK;
918
919 if ((hr = parse_http_url( channel->addr.url.chars, channel->addr.url.length, &uc )) != S_OK) return hr;
920 if (!(channel->u.http.path = heap_alloc( (uc.dwUrlPathLength + uc.dwExtraInfoLength + 1) * sizeof(WCHAR) )))
921 {
922 hr = E_OUTOFMEMORY;
923 goto done;
924 }
925 else
926 {
927 lstrcpyW( channel->u.http.path, uc.lpszUrlPath );
928 if (uc.dwExtraInfoLength) lstrcatW( channel->u.http.path, uc.lpszExtraInfo );
929 }
930
931 channel->u.http.flags = WINHTTP_FLAG_REFRESH;
932 switch (uc.nScheme)
933 {
934 case INTERNET_SCHEME_HTTP: break;
935 case INTERNET_SCHEME_HTTPS:
936 channel->u.http.flags |= WINHTTP_FLAG_SECURE;
937 break;
938
939 default:
940 hr = WS_E_INVALID_ENDPOINT_URL;
941 goto done;
942 }
943
944 if (!(ses = WinHttpOpen( L"MS-WebServices/1.0", 0, NULL, NULL, 0 )))
945 {
946 hr = HRESULT_FROM_WIN32( GetLastError() );
947 goto done;
948 }
949 if (!(con = WinHttpConnect( ses, uc.lpszHostName, uc.nPort, 0 )))
950 {
951 hr = HRESULT_FROM_WIN32( GetLastError() );
952 goto done;
953 }
954
955 channel->u.http.session = ses;
956 channel->u.http.connect = con;
957
958 done:
959 if (hr != S_OK)
960 {
961 WinHttpCloseHandle( con );
962 WinHttpCloseHandle( ses );
963 }
964 heap_free( uc.lpszHostName );
965 heap_free( uc.lpszUrlPath );
966 heap_free( uc.lpszExtraInfo );
967 return hr;
968 }
969
970 static HRESULT connect_channel_tcp( struct channel *channel )
971 {
972 struct sockaddr_storage storage;
973 struct sockaddr *addr = (struct sockaddr *)&storage;
974 int addr_len;
975 WS_URL_SCHEME_TYPE scheme;
976 WCHAR *host;
977 USHORT port;
978 HRESULT hr;
979
980 if (channel->u.tcp.socket != -1) return S_OK;
981
982 if ((hr = parse_url( &channel->addr.url, &scheme, &host, &port )) != S_OK) return hr;
983 if (scheme != WS_URL_NETTCP_SCHEME_TYPE)
984 {
985 heap_free( host );
986 return WS_E_INVALID_ENDPOINT_URL;
987 }
988
989 winsock_init();
990
991 hr = resolve_hostname( host, port, addr, &addr_len, 0 );
992 heap_free( host );
993 if (hr != S_OK) return hr;
994
995 if ((channel->u.tcp.socket = socket( addr->sa_family, SOCK_STREAM, 0 )) == -1)
996 return HRESULT_FROM_WIN32( WSAGetLastError() );
997
998 if (connect( channel->u.tcp.socket, addr, addr_len ) < 0)
999 {
1000 closesocket( channel->u.tcp.socket );
1001 channel->u.tcp.socket = -1;
1002 return HRESULT_FROM_WIN32( WSAGetLastError() );
1003 }
1004
1005 return S_OK;
1006 }
1007
1008 static HRESULT connect_channel_udp( struct channel *channel )
1009 {
1010 struct sockaddr_storage storage;
1011 struct sockaddr *addr = (struct sockaddr *)&storage;
1012 int addr_len;
1013 WS_URL_SCHEME_TYPE scheme;
1014 WCHAR *host;
1015 USHORT port;
1016 HRESULT hr;
1017
1018 if (channel->u.udp.socket != -1) return S_OK;
1019
1020 if ((hr = parse_url( &channel->addr.url, &scheme, &host, &port )) != S_OK) return hr;
1021 if (scheme != WS_URL_SOAPUDP_SCHEME_TYPE)
1022 {
1023 heap_free( host );
1024 return WS_E_INVALID_ENDPOINT_URL;
1025 }
1026
1027 winsock_init();
1028
1029 hr = resolve_hostname( host, port, addr, &addr_len, 0 );
1030 heap_free( host );
1031 if (hr != S_OK) return hr;
1032
1033 if ((channel->u.udp.socket = socket( addr->sa_family, SOCK_DGRAM, 0 )) == -1)
1034 return HRESULT_FROM_WIN32( WSAGetLastError() );
1035
1036 if (connect( channel->u.udp.socket, addr, addr_len ) < 0)
1037 {
1038 closesocket( channel->u.udp.socket );
1039 channel->u.udp.socket = -1;
1040 return HRESULT_FROM_WIN32( WSAGetLastError() );
1041 }
1042
1043 return S_OK;
1044 }
1045
1046 static HRESULT connect_channel( struct channel *channel )
1047 {
1048 switch (channel->binding)
1049 {
1050 case WS_HTTP_CHANNEL_BINDING:
1051 return connect_channel_http( channel );
1052
1053 case WS_TCP_CHANNEL_BINDING:
1054 return connect_channel_tcp( channel );
1055
1056 case WS_UDP_CHANNEL_BINDING:
1057 return connect_channel_udp( channel );
1058
1059 default:
1060 ERR( "unhandled binding %u\n", channel->binding );
1061 return E_NOTIMPL;
1062 }
1063 }
1064
1065 static HRESULT send_message_http( HINTERNET request, BYTE *data, ULONG len )
1066 {
1067 if (!WinHttpSendRequest( request, NULL, 0, data, len, len, 0 ))
1068 return HRESULT_FROM_WIN32( GetLastError() );
1069
1070 if (!WinHttpReceiveResponse( request, NULL ))
1071 return HRESULT_FROM_WIN32( GetLastError() );
1072 return S_OK;
1073 }
1074
1075 static HRESULT send_bytes( SOCKET socket, BYTE *bytes, int len )
1076 {
1077 int count = send( socket, (char *)bytes, len, 0 );
1078 if (count < 0) return HRESULT_FROM_WIN32( WSAGetLastError() );
1079 if (count != len) return WS_E_OTHER;
1080 return S_OK;
1081 }
1082
1083 static HRESULT send_size( SOCKET socket, ULONG size )
1084 {
1085 HRESULT hr;
1086 if (size < 0x80) return send_byte( socket, size );
1087 if ((hr = send_byte( socket, (size & 0x7f) | 0x80 )) != S_OK) return hr;
1088 if ((size >>= 7) < 0x80) return send_byte( socket, size );
1089 if ((hr = send_byte( socket, (size & 0x7f) | 0x80 )) != S_OK) return hr;
1090 if ((size >>= 7) < 0x80) return send_byte( socket, size );
1091 if ((hr = send_byte( socket, (size & 0x7f) | 0x80 )) != S_OK) return hr;
1092 if ((size >>= 7) < 0x80) return send_byte( socket, size );
1093 if ((hr = send_byte( socket, (size & 0x7f) | 0x80 )) != S_OK) return hr;
1094 if ((size >>= 7) < 0x08) return send_byte( socket, size );
1095 return E_INVALIDARG;
1096 }
1097
1098 static inline ULONG size_length( ULONG size )
1099 {
1100 if (size < 0x80) return 1;
1101 if (size < 0x4000) return 2;
1102 if (size < 0x200000) return 3;
1103 if (size < 0x10000000) return 4;
1104 return 5;
1105 }
1106
1107 static ULONG string_table_size( const struct dictionary *dict )
1108 {
1109 ULONG i, size = 0;
1110 for (i = 0; i < dict->dict.stringCount; i++)
1111 {
1112 if (dict->sequence[i] == dict->current_sequence)
1113 size += size_length( dict->dict.strings[i].length ) + dict->dict.strings[i].length;
1114 }
1115 return size;
1116 }
1117
1118 static HRESULT send_string_table( SOCKET socket, const struct dictionary *dict )
1119 {
1120 ULONG i;
1121 HRESULT hr;
1122 for (i = 0; i < dict->dict.stringCount; i++)
1123 {
1124 if (dict->sequence[i] != dict->current_sequence) continue;
1125 if ((hr = send_size( socket, dict->dict.strings[i].length )) != S_OK) return hr;
1126 if ((hr = send_bytes( socket, dict->dict.strings[i].bytes, dict->dict.strings[i].length )) != S_OK) return hr;
1127 }
1128 return S_OK;
1129 }
1130
1131 static HRESULT string_to_utf8( const WS_STRING *str, unsigned char **ret, int *len )
1132 {
1133 *len = WideCharToMultiByte( CP_UTF8, 0, str->chars, str->length, NULL, 0, NULL, NULL );
1134 if (!(*ret = heap_alloc( *len ))) return E_OUTOFMEMORY;
1135 WideCharToMultiByte( CP_UTF8, 0, str->chars, str->length, (char *)*ret, *len, NULL, NULL );
1136 return S_OK;
1137 }
1138
1139 enum session_mode
1140 {
1141 SESSION_MODE_INVALID = 0,
1142 SESSION_MODE_SINGLETON = 1,
1143 SESSION_MODE_DUPLEX = 2,
1144 SESSION_MODE_SIMPLEX = 3,
1145 };
1146
1147 static enum session_mode map_channel_type( struct channel *channel )
1148 {
1149 switch (channel->type)
1150 {
1151 case WS_CHANNEL_TYPE_DUPLEX_SESSION: return SESSION_MODE_DUPLEX;
1152 default:
1153 FIXME( "unhandled channel type %08x\n", channel->type );
1154 return SESSION_MODE_INVALID;
1155 }
1156 }
1157
1158 enum known_encoding
1159 {
1160 KNOWN_ENCODING_SOAP11_UTF8 = 0x00,
1161 KNOWN_ENCODING_SOAP11_UTF16 = 0x01,
1162 KNOWN_ENCODING_SOAP11_UTF16LE = 0x02,
1163 KNOWN_ENCODING_SOAP12_UTF8 = 0x03,
1164 KNOWN_ENCODING_SOAP12_UTF16 = 0x04,
1165 KNOWN_ENCODING_SOAP12_UTF16LE = 0x05,
1166 KNOWN_ENCODING_SOAP12_MTOM = 0x06,
1167 KNOWN_ENCODING_SOAP12_BINARY = 0x07,
1168 KNOWN_ENCODING_SOAP12_BINARY_SESSION = 0x08,
1169 };
1170
1171 static enum known_encoding map_channel_encoding( struct channel *channel )
1172 {
1173 WS_ENVELOPE_VERSION version;
1174
1175 prop_get( channel->prop, channel->prop_count, WS_CHANNEL_PROPERTY_ENVELOPE_VERSION, &version, sizeof(version) );
1176
1177 switch (version)
1178 {
1179 case WS_ENVELOPE_VERSION_SOAP_1_1:
1180 switch (channel->encoding)
1181 {
1182 case WS_ENCODING_XML_UTF8: return KNOWN_ENCODING_SOAP11_UTF8;
1183 case WS_ENCODING_XML_UTF16LE: return KNOWN_ENCODING_SOAP11_UTF16LE;
1184 default:
1185 FIXME( "unhandled version/encoding %u/%u\n", version, channel->encoding );
1186 return 0;
1187 }
1188 case WS_ENVELOPE_VERSION_SOAP_1_2:
1189 switch (channel->encoding)
1190 {
1191 case WS_ENCODING_XML_UTF8: return KNOWN_ENCODING_SOAP12_UTF8;
1192 case WS_ENCODING_XML_UTF16LE: return KNOWN_ENCODING_SOAP12_UTF16LE;
1193 case WS_ENCODING_XML_BINARY_1: return KNOWN_ENCODING_SOAP12_BINARY;
1194 case WS_ENCODING_XML_BINARY_SESSION_1: return KNOWN_ENCODING_SOAP12_BINARY_SESSION;
1195 default:
1196 FIXME( "unhandled version/encoding %u/%u\n", version, channel->encoding );
1197 return 0;
1198 }
1199 default:
1200 ERR( "unhandled version %u\n", version );
1201 return 0;
1202 }
1203 }
1204
1205 #define FRAME_VERSION_MAJOR 1
1206 #define FRAME_VERSION_MINOR 1
1207
1208 static HRESULT send_preamble( struct channel *channel )
1209 {
1210 unsigned char *url;
1211 HRESULT hr;
1212 int len;
1213
1214 if ((hr = send_byte( channel->u.tcp.socket, FRAME_RECORD_TYPE_VERSION )) != S_OK) return hr;
1215 if ((hr = send_byte( channel->u.tcp.socket, FRAME_VERSION_MAJOR )) != S_OK) return hr;
1216 if ((hr = send_byte( channel->u.tcp.socket, FRAME_VERSION_MINOR )) != S_OK) return hr;
1217
1218 if ((hr = send_byte( channel->u.tcp.socket, FRAME_RECORD_TYPE_MODE )) != S_OK) return hr;
1219 if ((hr = send_byte( channel->u.tcp.socket, map_channel_type(channel) )) != S_OK) return hr;
1220
1221 if ((hr = send_byte( channel->u.tcp.socket, FRAME_RECORD_TYPE_VIA )) != S_OK) return hr;
1222 if ((hr = string_to_utf8( &channel->addr.url, &url, &len )) != S_OK) return hr;
1223 if ((hr = send_size( channel->u.tcp.socket, len )) != S_OK) goto done;
1224 if ((hr = send_bytes( channel->u.tcp.socket, url, len )) != S_OK) goto done;
1225
1226 if ((hr = send_byte( channel->u.tcp.socket, FRAME_RECORD_TYPE_KNOWN_ENCODING )) != S_OK) goto done;
1227 if ((hr = send_byte( channel->u.tcp.socket, map_channel_encoding(channel) )) != S_OK) goto done;
1228 hr = send_byte( channel->u.tcp.socket, FRAME_RECORD_TYPE_PREAMBLE_END );
1229
1230 done:
1231 heap_free( url );
1232 return hr;
1233 }
1234
1235 static HRESULT receive_bytes( struct channel *channel, unsigned char *bytes, int len )
1236 {
1237 int count = recv( channel->u.tcp.socket, (char *)bytes, len, 0 );
1238 if (count < 0) return HRESULT_FROM_WIN32( WSAGetLastError() );
1239 if (count != len) return WS_E_INVALID_FORMAT;
1240 return S_OK;
1241 }
1242
1243 static HRESULT receive_preamble_ack( struct channel *channel )
1244 {
1245 unsigned char byte;
1246 HRESULT hr;
1247
1248 if ((hr = receive_bytes( channel, &byte, 1 )) != S_OK) return hr;
1249 if (byte != FRAME_RECORD_TYPE_PREAMBLE_ACK) return WS_E_INVALID_FORMAT;
1250 channel->session_state = SESSION_STATE_SETUP_COMPLETE;
1251 return S_OK;
1252 }
1253
1254 static HRESULT send_sized_envelope( struct channel *channel, BYTE *data, ULONG len )
1255 {
1256 ULONG table_size = string_table_size( &channel->dict_send );
1257 HRESULT hr;
1258
1259 if ((hr = send_byte( channel->u.tcp.socket, FRAME_RECORD_TYPE_SIZED_ENVELOPE )) != S_OK) return hr;
1260 if ((hr = send_size( channel->u.tcp.socket, size_length(table_size) + table_size + len )) != S_OK) return hr;
1261 if ((hr = send_size( channel->u.tcp.socket, table_size )) != S_OK) return hr;
1262 if ((hr = send_string_table( channel->u.tcp.socket, &channel->dict_send )) != S_OK) return hr;
1263 return send_bytes( channel->u.tcp.socket, data, len );
1264 }
1265
1266 static HRESULT open_http_request( struct channel *channel, HINTERNET *req )
1267 {
1268 if ((*req = WinHttpOpenRequest( channel->u.http.connect, L"POST", channel->u.http.path,
1269 NULL, NULL, NULL, channel->u.http.flags ))) return S_OK;
1270 return HRESULT_FROM_WIN32( GetLastError() );
1271 }
1272
1273 static HRESULT send_message( struct channel *channel, WS_MESSAGE *msg )
1274 {
1275 WS_XML_WRITER *writer;
1276 WS_BYTES buf;
1277 HRESULT hr;
1278
1279 channel->msg = msg;
1280 WsGetMessageProperty( channel->msg, WS_MESSAGE_PROPERTY_BODY_WRITER, &writer, sizeof(writer), NULL );
1281 WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &buf, sizeof(buf), NULL );
1282
1283 switch (channel->binding)
1284 {
1285 case WS_HTTP_CHANNEL_BINDING:
1286 if (channel->u.http.request)
1287 {
1288 WinHttpCloseHandle( channel->u.http.request );
1289 channel->u.http.request = NULL;
1290 }
1291 if ((hr = open_http_request( channel, &channel->u.http.request )) != S_OK) return hr;
1292 if ((hr = message_insert_http_headers( msg, channel->u.http.request )) != S_OK) return hr;
1293 return send_message_http( channel->u.http.request, buf.bytes, buf.length );
1294
1295 case WS_TCP_CHANNEL_BINDING:
1296 if (channel->type & WS_CHANNEL_TYPE_SESSION)
1297 {
1298 switch (channel->session_state)
1299 {
1300 case SESSION_STATE_UNINITIALIZED:
1301 if ((hr = send_preamble( channel )) != S_OK) return hr;
1302 if ((hr = receive_preamble_ack( channel )) != S_OK) return hr;
1303 /* fall through */
1304
1305 case SESSION_STATE_SETUP_COMPLETE:
1306 return send_sized_envelope( channel, buf.bytes, buf.length );
1307
1308 default:
1309 ERR( "unhandled session state %u\n", channel->session_state );
1310 return WS_E_OTHER;
1311 }
1312 }
1313 /* fall through */
1314
1315 case WS_UDP_CHANNEL_BINDING:
1316 return WsFlushWriter( writer, 0, NULL, NULL );
1317
1318 default:
1319 ERR( "unhandled binding %u\n", channel->binding );
1320 return E_NOTIMPL;
1321 }
1322 }
1323
1324 HRESULT channel_send_message( WS_CHANNEL *handle, WS_MESSAGE *msg )
1325 {
1326 struct channel *channel = (struct channel *)handle;
1327 HRESULT hr;
1328
1329 EnterCriticalSection( &channel->cs );
1330
1331 if (channel->magic != CHANNEL_MAGIC)
1332 {
1333 LeaveCriticalSection( &channel->cs );
1334 return E_INVALIDARG;
1335 }
1336
1337 if ((hr = connect_channel( channel )) == S_OK) hr = send_message( channel, msg );
1338
1339 LeaveCriticalSection( &channel->cs );
1340 return hr;
1341 }
1342
1343 static HRESULT CALLBACK dict_cb( void *state, const WS_XML_STRING *str, BOOL *found, ULONG *id, WS_ERROR *error )
1344 {
1345 struct dictionary *dict = state;
1346 HRESULT hr = S_OK;
1347 BYTE *bytes;
1348 int index;
1349
1350 if ((index = find_string( dict, str->bytes, str->length, id )) == -1)
1351 {
1352 *found = TRUE;
1353 return S_OK;
1354 }
1355
1356 if (!(bytes = heap_alloc( str->length ))) return E_OUTOFMEMORY;
1357 memcpy( bytes, str->bytes, str->length );
1358 if ((hr = insert_string( dict, bytes, str->length, index, id )) == S_OK)
1359 {
1360 *found = TRUE;
1361 return S_OK;
1362 }
1363 heap_free( bytes );
1364
1365 *found = FALSE;
1366 return hr;
1367 }
1368
1369 static CALLBACK HRESULT write_callback( void *state, const WS_BYTES *buf, ULONG count,
1370 const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
1371 {
1372 SOCKET socket = *(SOCKET *)state;
1373 if (send( socket, (const char *)buf->bytes, buf->length, 0 ) < 0)
1374 {
1375 TRACE( "send failed %u\n", WSAGetLastError() );
1376 }
1377 return S_OK;
1378 }
1379
1380 static HRESULT init_writer( struct channel *channel )
1381 {
1382 WS_XML_WRITER_BUFFER_OUTPUT buf = {{WS_XML_WRITER_OUTPUT_TYPE_BUFFER}};
1383 WS_XML_WRITER_STREAM_OUTPUT stream = {{WS_XML_WRITER_OUTPUT_TYPE_STREAM}};
1384 WS_XML_WRITER_TEXT_ENCODING text = {{WS_XML_WRITER_ENCODING_TYPE_TEXT}, WS_CHARSET_UTF8};
1385 WS_XML_WRITER_BINARY_ENCODING bin = {{WS_XML_WRITER_ENCODING_TYPE_BINARY}};
1386 const WS_XML_WRITER_ENCODING *encoding;
1387 const WS_XML_WRITER_OUTPUT *output;
1388 WS_XML_WRITER_PROPERTY prop;
1389 ULONG max_size = (1 << 17);
1390 HRESULT hr;
1391
1392 prop.id = WS_XML_WRITER_PROPERTY_BUFFER_MAX_SIZE;
1393 prop.value = &max_size;
1394 prop.valueSize = sizeof(max_size);
1395 if (!channel->writer && (hr = WsCreateWriter( &prop, 1, &channel->writer, NULL )) != S_OK) return hr;
1396
1397 switch (channel->encoding)
1398 {
1399 case WS_ENCODING_XML_UTF8:
1400 encoding = &text.encoding;
1401 if (channel->binding == WS_UDP_CHANNEL_BINDING ||
1402 (channel->binding == WS_TCP_CHANNEL_BINDING && !(channel->type & WS_CHANNEL_TYPE_SESSION)))
1403 {
1404 stream.writeCallback = write_callback;
1405 stream.writeCallbackState = (channel->binding == WS_UDP_CHANNEL_BINDING) ?
1406 &channel->u.udp.socket : &channel->u.tcp.socket;
1407 output = &stream.output;
1408 }
1409 else output = &buf.output;
1410 break;
1411
1412 case WS_ENCODING_XML_BINARY_SESSION_1:
1413 bin.staticDictionary = (WS_XML_DICTIONARY *)&dict_builtin_static.dict;
1414 /* fall through */
1415
1416 case WS_ENCODING_XML_BINARY_1:
1417 encoding = &bin.encoding;
1418 output = &buf.output;
1419 break;
1420
1421 default:
1422 FIXME( "unhandled encoding %u\n", channel->encoding );
1423 return WS_E_NOT_SUPPORTED;
1424 }
1425
1426 return WsSetOutput( channel->writer, encoding, output, NULL, 0, NULL );
1427 }
1428
1429 static HRESULT write_message( struct channel *channel, WS_MESSAGE *msg, const WS_ELEMENT_DESCRIPTION *desc,
1430 WS_WRITE_OPTION option, const void *body, ULONG size )
1431 {
1432 HRESULT hr;
1433 if ((hr = writer_set_lookup( channel->writer, TRUE )) != S_OK) return hr;
1434 if ((hr = WsWriteEnvelopeStart( msg, channel->writer, NULL, NULL, NULL )) != S_OK) return hr;
1435 if ((hr = writer_set_lookup( channel->writer, FALSE )) != S_OK) return hr;
1436 channel->dict_send.current_sequence++;
1437 if ((hr = writer_set_dict_callback( channel->writer, dict_cb, &channel->dict_send )) != S_OK) return hr;
1438 if ((hr = WsWriteBody( msg, desc, option, body, size, NULL )) != S_OK) return hr;
1439 return WsWriteEnvelopeEnd( msg, NULL );
1440 }
1441
1442 /**************************************************************************
1443 * WsSendMessage [webservices.@]
1444 */
1445 HRESULT WINAPI WsSendMessage( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_MESSAGE_DESCRIPTION *desc,
1446 WS_WRITE_OPTION option, const void *body, ULONG size, const WS_ASYNC_CONTEXT *ctx,
1447 WS_ERROR *error )
1448 {
1449 struct channel *channel = (struct channel *)handle;
1450 HRESULT hr;
1451
1452 TRACE( "%p %p %p %08x %p %u %p %p\n", handle, msg, desc, option, body, size, ctx, error );
1453 if (error) FIXME( "ignoring error parameter\n" );
1454 if (ctx) FIXME( "ignoring ctx parameter\n" );
1455
1456 if (!channel || !msg || !desc) return E_INVALIDARG;
1457
1458 EnterCriticalSection( &channel->cs );
1459
1460 if (channel->magic != CHANNEL_MAGIC)
1461 {
1462 LeaveCriticalSection( &channel->cs );
1463 return E_INVALIDARG;
1464 }
1465
1466 if ((hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL )) != S_OK) goto done;
1467 if ((hr = WsAddressMessage( msg, &channel->addr, NULL )) != S_OK) goto done;
1468 if ((hr = message_set_action( msg, desc->action )) != S_OK) goto done;
1469
1470 if ((hr = connect_channel( channel )) != S_OK) goto done;
1471 if ((hr = init_writer( channel )) != S_OK) goto done;
1472 if ((hr = write_message( channel, msg, desc->bodyElementDescription, option, body, size )) != S_OK) goto done;
1473 hr = send_message( channel, msg );
1474
1475 done:
1476 LeaveCriticalSection( &channel->cs );
1477 TRACE( "returning %08x\n", hr );
1478 return hr;
1479 }
1480
1481 /**************************************************************************
1482 * WsSendReplyMessage [webservices.@]
1483 */
1484 HRESULT WINAPI WsSendReplyMessage( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_MESSAGE_DESCRIPTION *desc,
1485 WS_WRITE_OPTION option, const void *body, ULONG size, WS_MESSAGE *request,
1486 const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
1487 {
1488 struct channel *channel = (struct channel *)handle;
1489 GUID req_id;
1490 HRESULT hr;
1491
1492 TRACE( "%p %p %p %08x %p %u %p %p %p\n", handle, msg, desc, option, body, size, request, ctx, error );
1493 if (error) FIXME( "ignoring error parameter\n" );
1494 if (ctx) FIXME( "ignoring ctx parameter\n" );
1495
1496 if (!channel || !msg || !desc || !request) return E_INVALIDARG;
1497
1498 EnterCriticalSection( &channel->cs );
1499
1500 if (channel->magic != CHANNEL_MAGIC)
1501 {
1502 LeaveCriticalSection( &channel->cs );
1503 return E_INVALIDARG;
1504 }
1505
1506 if ((hr = WsInitializeMessage( msg, WS_REPLY_MESSAGE, NULL, NULL )) != S_OK) goto done;
1507 if ((hr = WsAddressMessage( msg, &channel->addr, NULL )) != S_OK) goto done;
1508 if ((hr = message_set_action( msg, desc->action )) != S_OK) goto done;
1509 if ((hr = message_get_id( request, &req_id )) != S_OK) goto done;
1510 if ((hr = message_set_request_id( msg, &req_id )) != S_OK) goto done;
1511
1512 if ((hr = connect_channel( channel )) != S_OK) goto done;
1513 if ((hr = init_writer( channel )) != S_OK) goto done;
1514 if ((hr = write_message( channel, msg, desc->bodyElementDescription, option, body, size )) != S_OK) goto done;
1515 hr = send_message( channel, msg );
1516
1517 done:
1518 LeaveCriticalSection( &channel->cs );
1519 TRACE( "returning %08x\n", hr );
1520 return hr;
1521 }
1522
1523 static HRESULT resize_read_buffer( struct channel *channel, ULONG size )
1524 {
1525 if (!channel->read_buf)
1526 {
1527 if (!(channel->read_buf = heap_alloc( size ))) return E_OUTOFMEMORY;
1528 channel->read_buflen = size;
1529 return S_OK;
1530 }
1531 if (channel->read_buflen < size)
1532 {
1533 char *tmp;
1534 ULONG new_size = max( size, channel->read_buflen * 2 );
1535 if (!(tmp = heap_realloc( channel->read_buf, new_size ))) return E_OUTOFMEMORY;
1536 channel->read_buf = tmp;
1537 channel->read_buflen = new_size;
1538 }
1539 return S_OK;
1540 }
1541
1542 static CALLBACK HRESULT read_callback( void *state, void *buf, ULONG buflen, ULONG *retlen,
1543 const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
1544 {
1545 SOCKET socket = *(SOCKET *)state;
1546 int ret;
1547
1548 if ((ret = recv( socket, buf, buflen, 0 )) >= 0) *retlen = ret;
1549 else
1550 {
1551 TRACE( "recv failed %u\n", WSAGetLastError() );
1552 *retlen = 0;
1553 }
1554 return S_OK;
1555 }
1556
1557 static HRESULT init_reader( struct channel *channel )
1558 {
1559 WS_XML_READER_BUFFER_INPUT buf = {{WS_XML_READER_INPUT_TYPE_BUFFER}};
1560 WS_XML_READER_STREAM_INPUT stream = {{WS_XML_READER_INPUT_TYPE_STREAM}};
1561 WS_XML_READER_TEXT_ENCODING text = {{WS_XML_READER_ENCODING_TYPE_TEXT}};
1562 WS_XML_READER_BINARY_ENCODING bin = {{WS_XML_READER_ENCODING_TYPE_BINARY}};
1563 const WS_XML_READER_ENCODING *encoding;
1564 const WS_XML_READER_INPUT *input;
1565 HRESULT hr;
1566
1567 if (!channel->reader && (hr = WsCreateReader( NULL, 0, &channel->reader, NULL )) != S_OK) return hr;
1568
1569 switch (channel->encoding)
1570 {
1571 case WS_ENCODING_XML_UTF8:
1572 text.charSet = WS_CHARSET_UTF8;
1573 encoding = &text.encoding;
1574
1575 if (channel->binding == WS_UDP_CHANNEL_BINDING ||
1576 (channel->binding == WS_TCP_CHANNEL_BINDING && !(channel->type & WS_CHANNEL_TYPE_SESSION)))
1577 {
1578 stream.readCallback = read_callback;
1579 stream.readCallbackState = (channel->binding == WS_UDP_CHANNEL_BINDING) ?
1580 &channel->u.udp.socket : &channel->u.tcp.socket;
1581 input = &stream.input;
1582 }
1583 else
1584 {
1585 buf.encodedData = channel->read_buf;
1586 buf.encodedDataSize = channel->read_size;
1587 input = &buf.input;
1588 }
1589 break;
1590
1591 case WS_ENCODING_XML_BINARY_SESSION_1:
1592 bin.staticDictionary = (WS_XML_DICTIONARY *)&dict_builtin_static.dict;
1593 bin.dynamicDictionary = &channel->dict_recv.dict;
1594 /* fall through */
1595
1596 case WS_ENCODING_XML_BINARY_1:
1597 encoding = &bin.encoding;
1598
1599 buf.encodedData = channel->read_buf;
1600 buf.encodedDataSize = channel->read_size;
1601 input = &buf.input;
1602 break;
1603
1604 default:
1605 FIXME( "unhandled encoding %u\n", channel->encoding );
1606 return WS_E_NOT_SUPPORTED;
1607 }
1608
1609 return WsSetInput( channel->reader, encoding, input, NULL, 0, NULL );
1610 }
1611
1612 static const WS_HTTP_MESSAGE_MAPPING *get_http_message_mapping( struct channel *channel )
1613 {
1614 const struct prop *prop = &channel->prop[WS_CHANNEL_PROPERTY_HTTP_MESSAGE_MAPPING];
1615 return (const WS_HTTP_MESSAGE_MAPPING *)prop->value;
1616 }
1617
1618 static HRESULT map_http_response_headers( struct channel *channel, WS_MESSAGE *msg )
1619 {
1620 const WS_HTTP_MESSAGE_MAPPING *mapping = get_http_message_mapping( channel );
1621 return message_map_http_response_headers( msg, channel->u.http.request, mapping );
1622 }
1623
1624 #define INITIAL_READ_BUFFER_SIZE 4096
1625 static HRESULT receive_message_http( struct channel *channel, WS_MESSAGE *msg )
1626 {
1627 DWORD len, bytes_read, offset = 0, size = INITIAL_READ_BUFFER_SIZE;
1628 ULONG max_len;
1629 HRESULT hr;
1630
1631 if ((hr = map_http_response_headers( channel, msg )) != S_OK) return hr;
1632
1633 prop_get( channel->prop, channel->prop_count, WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE,
1634 &max_len, sizeof(max_len) );
1635
1636 if ((hr = resize_read_buffer( channel, size )) != S_OK) return hr;
1637 channel->read_size = 0;
1638 for (;;)
1639 {
1640 if (!WinHttpQueryDataAvailable( channel->u.http.request, &len ))
1641 {
1642 return HRESULT_FROM_WIN32( GetLastError() );
1643 }
1644 if (!len) break;
1645 if (channel->read_size + len > max_len) return WS_E_QUOTA_EXCEEDED;
1646 if ((hr = resize_read_buffer( channel, channel->read_size + len )) != S_OK) return hr;
1647
1648 if (!WinHttpReadData( channel->u.http.request, channel->read_buf + offset, len, &bytes_read ))
1649 {
1650 return HRESULT_FROM_WIN32( GetLastError() );
1651 }
1652 if (!bytes_read) break;
1653 channel->read_size += bytes_read;
1654 offset += bytes_read;
1655 }
1656
1657 return S_OK;
1658 }
1659
1660 static HRESULT receive_message_sized( struct channel *channel, unsigned int size )
1661 {
1662 unsigned int offset = 0, to_read = size;
1663 int bytes_read;
1664 HRESULT hr;
1665
1666 if ((hr = resize_read_buffer( channel, size )) != S_OK) return hr;
1667
1668 channel->read_size = 0;
1669 while (channel->read_size < size)
1670 {
1671 if ((bytes_read = recv( channel->u.tcp.socket, channel->read_buf + offset, to_read, 0 )) < 0)
1672 {
1673 return HRESULT_FROM_WIN32( WSAGetLastError() );
1674 }
1675 if (!bytes_read) break;
1676 channel->read_size += bytes_read;
1677 to_read -= bytes_read;
1678 offset += bytes_read;
1679 }
1680 if (channel->read_size != size) return WS_E_INVALID_FORMAT;
1681 return S_OK;
1682 }
1683
1684 static HRESULT receive_size( struct channel *channel, unsigned int *size )
1685 {
1686 unsigned char byte;
1687 HRESULT hr;
1688
1689 if ((hr = receive_bytes( channel, &byte, 1 )) != S_OK) return hr;
1690 *size = byte & 0x7f;
1691 if (!(byte & 0x80)) return S_OK;
1692
1693 if ((hr = receive_bytes( channel, &byte, 1 )) != S_OK) return hr;
1694 *size += (byte & 0x7f) << 7;
1695 if (!(byte & 0x80)) return S_OK;
1696
1697 if ((hr = receive_bytes( channel, &byte, 1 )) != S_OK) return hr;
1698 *size += (byte & 0x7f) << 14;
1699 if (!(byte & 0x80)) return S_OK;
1700
1701 if ((hr = receive_bytes( channel, &byte, 1 )) != S_OK) return hr;
1702 *size += (byte & 0x7f) << 21;
1703 if (!(byte & 0x80)) return S_OK;
1704
1705 if ((hr = receive_bytes( channel, &byte, 1 )) != S_OK) return hr;
1706 if (byte & ~0x0f) return WS_E_INVALID_FORMAT;
1707 *size += byte << 28;
1708 return S_OK;
1709 }
1710
1711 static WS_ENCODING map_known_encoding( enum known_encoding encoding )
1712 {
1713 switch (encoding)
1714 {
1715 case KNOWN_ENCODING_SOAP11_UTF8:
1716 case KNOWN_ENCODING_SOAP12_UTF8: return WS_ENCODING_XML_UTF8;
1717 case KNOWN_ENCODING_SOAP11_UTF16:
1718 case KNOWN_ENCODING_SOAP12_UTF16: return WS_ENCODING_XML_UTF16BE;
1719 case KNOWN_ENCODING_SOAP11_UTF16LE:
1720 case KNOWN_ENCODING_SOAP12_UTF16LE: return WS_ENCODING_XML_UTF16LE;
1721 case KNOWN_ENCODING_SOAP12_BINARY: return WS_ENCODING_XML_BINARY_1;
1722 case KNOWN_ENCODING_SOAP12_BINARY_SESSION: return WS_ENCODING_XML_BINARY_SESSION_1;
1723 default:
1724 WARN( "unhandled encoding %u, assuming UTF8\n", encoding );
1725 return WS_ENCODING_XML_UTF8;
1726 }
1727 }
1728
1729 static HRESULT receive_preamble( struct channel *channel )
1730 {
1731 unsigned char type;
1732 HRESULT hr;
1733
1734 for (;;)
1735 {
1736 if ((hr = receive_bytes( channel, &type, 1 )) != S_OK) return hr;
1737 if (type == FRAME_RECORD_TYPE_PREAMBLE_END) break;
1738 switch (type)
1739 {
1740 case FRAME_RECORD_TYPE_VERSION:
1741 {
1742 unsigned char major, minor;
1743 if ((hr = receive_bytes( channel, &major, 1 )) != S_OK) return hr;
1744 if ((hr = receive_bytes( channel, &minor, 1 )) != S_OK) return hr;
1745 TRACE( "major %u minor %u\n", major, major );
1746 break;
1747 }
1748 case FRAME_RECORD_TYPE_MODE:
1749 {
1750 unsigned char mode;
1751 if ((hr = receive_bytes( channel, &mode, 1 )) != S_OK) return hr;
1752 TRACE( "mode %u\n", mode );
1753 break;
1754 }
1755 case FRAME_RECORD_TYPE_VIA:
1756 {
1757 unsigned int size;
1758 unsigned char *url;
1759
1760 if ((hr = receive_size( channel, &size )) != S_OK) return hr;
1761 if (!(url = heap_alloc( size ))) return E_OUTOFMEMORY;
1762 if ((hr = receive_bytes( channel, url, size )) != S_OK)
1763 {
1764 heap_free( url );
1765 return hr;
1766 }
1767 TRACE( "transport URL %s\n", debugstr_an((char *)url, size) );
1768 heap_free( url ); /* FIXME: verify */
1769 break;
1770 }
1771 case FRAME_RECORD_TYPE_KNOWN_ENCODING:
1772 {
1773 unsigned char encoding;
1774 if ((hr = receive_bytes( channel, &encoding, 1 )) != S_OK) return hr;
1775 TRACE( "encoding %u\n", encoding );
1776 channel->encoding = map_known_encoding( encoding );
1777 break;
1778 }
1779 default:
1780 WARN( "unhandled record type %u\n", type );
1781 return WS_E_INVALID_FORMAT;
1782 }
1783 }
1784
1785 return S_OK;
1786 }
1787
1788 static HRESULT receive_sized_envelope( struct channel *channel )
1789 {
1790 unsigned char type;
1791 unsigned int size;
1792 HRESULT hr;
1793
1794 if ((hr = receive_bytes( channel, &type, 1 )) != S_OK) return hr;
1795 if (type != FRAME_RECORD_TYPE_SIZED_ENVELOPE) return WS_E_INVALID_FORMAT;
1796 if ((hr = receive_size( channel, &size )) != S_OK) return hr;
1797 if ((hr = receive_message_sized( channel, size )) != S_OK) return hr;
1798 return S_OK;
1799 }
1800
1801 static HRESULT read_size( const BYTE **ptr, ULONG len, ULONG *size )
1802 {
1803 const BYTE *buf = *ptr;
1804
1805 if (len < 1) return WS_E_INVALID_FORMAT;
1806 *size = buf[0] & 0x7f;
1807 if (!(buf[0] & 0x80))
1808 {
1809 *ptr += 1;
1810 return S_OK;
1811 }
1812 if (len < 2) return WS_E_INVALID_FORMAT;
1813 *size += (buf[1] & 0x7f) << 7;
1814 if (!(buf[1] & 0x80))
1815 {
1816 *ptr += 2;
1817 return S_OK;
1818 }
1819 if (len < 3) return WS_E_INVALID_FORMAT;
1820 *size += (buf[2] & 0x7f) << 14;
1821 if (!(buf[2] & 0x80))
1822 {
1823 *ptr += 3;
1824 return S_OK;
1825 }
1826 if (len < 4) return WS_E_INVALID_FORMAT;
1827 *size += (buf[3] & 0x7f) << 21;
1828 if (!(buf[3] & 0x80))
1829 {
1830 *ptr += 4;
1831 return S_OK;
1832 }
1833 if (len < 5 || (buf[4] & ~0x07)) return WS_E_INVALID_FORMAT;
1834 *size += buf[4] << 28;
1835 *ptr += 5;
1836 return S_OK;
1837 }
1838
1839 static HRESULT build_dict( const BYTE *buf, ULONG buflen, struct dictionary *dict, ULONG *used )
1840 {
1841 ULONG size, strings_size, strings_offset;
1842 const BYTE *ptr = buf;
1843 BYTE *bytes;
1844 int index;
1845 HRESULT hr;
1846
1847 if ((hr = read_size( &ptr, buflen, &strings_size )) != S_OK) return hr;
1848 strings_offset = ptr - buf;
1849 if (buflen < strings_offset + strings_size) return WS_E_INVALID_FORMAT;
1850 *used = strings_offset + strings_size;
1851 if (!strings_size) return S_OK;
1852
1853 UuidCreate( &dict->dict.guid );
1854 dict->dict.isConst = FALSE;
1855
1856 buflen -= strings_offset;
1857 ptr = buf + strings_offset;
1858 while (ptr < buf + strings_size)
1859 {
1860 if ((hr = read_size( &ptr, buflen, &size )) != S_OK)
1861 {
1862 clear_dict( dict );
1863 return hr;
1864 }
1865 if (size > buflen)
1866 {
1867 clear_dict( dict );
1868 return WS_E_INVALID_FORMAT;
1869 }
1870 buflen -= size;
1871 if (!(bytes = heap_alloc( size )))
1872 {
1873 hr = E_OUTOFMEMORY;
1874 goto error;
1875 }
1876 memcpy( bytes, ptr, size );
1877 if ((index = find_string( dict, bytes, size, NULL )) == -1) /* duplicate */
1878 {
1879 heap_free( bytes );
1880 ptr += size;
1881 continue;
1882 }
1883 if ((hr = insert_string( dict, bytes, size, index, NULL )) != S_OK)
1884 {
1885 heap_free( bytes );
1886 clear_dict( dict );
1887 return hr;
1888 }
1889 ptr += size;
1890 }
1891 return S_OK;
1892
1893 error:
1894 clear_dict( dict );
1895 return hr;
1896 }
1897
1898 static HRESULT send_preamble_ack( struct channel *channel )
1899 {
1900 HRESULT hr;
1901 if ((hr = send_byte( channel->u.tcp.socket, FRAME_RECORD_TYPE_PREAMBLE_ACK )) != S_OK) return hr;
1902 channel->session_state = SESSION_STATE_SETUP_COMPLETE;
1903 return S_OK;
1904 }
1905
1906 static HRESULT receive_message_session( struct channel *channel )
1907 {
1908 HRESULT hr;
1909
1910 if ((hr = receive_sized_envelope( channel )) != S_OK) return hr;
1911 if (channel->encoding == WS_ENCODING_XML_BINARY_SESSION_1)
1912 {
1913 ULONG size;
1914 if ((hr = build_dict( (const BYTE *)channel->read_buf, channel->read_size, &channel->dict_recv,
1915 &size )) != S_OK) return hr;
1916 channel->read_size -= size;
1917 memmove( channel->read_buf, channel->read_buf + size, channel->read_size );
1918 }
1919
1920 return S_OK;
1921 }
1922
1923 static HRESULT receive_message_bytes( struct channel *channel, WS_MESSAGE *msg )
1924 {
1925 HRESULT hr;
1926 if ((hr = connect_channel( channel )) != S_OK) return hr;
1927
1928 switch (channel->binding)
1929 {
1930 case WS_HTTP_CHANNEL_BINDING:
1931 return receive_message_http( channel, msg );
1932
1933 case WS_TCP_CHANNEL_BINDING:
1934 if (channel->type & WS_CHANNEL_TYPE_SESSION)
1935 {
1936 switch (channel->session_state)
1937 {
1938 case SESSION_STATE_UNINITIALIZED:
1939 if ((hr = receive_preamble( channel )) != S_OK) return hr;
1940 if ((hr = send_preamble_ack( channel )) != S_OK) return hr;
1941 /* fall through */
1942
1943 case SESSION_STATE_SETUP_COMPLETE:
1944 return receive_message_session( channel );
1945
1946 default:
1947 ERR( "unhandled session state %u\n", channel->session_state );
1948 return WS_E_OTHER;
1949 }
1950 }
1951 return S_OK; /* nothing to do, data is read through stream callback */
1952
1953 case WS_UDP_CHANNEL_BINDING:
1954 return S_OK;
1955
1956 default:
1957 ERR( "unhandled binding %u\n", channel->binding );
1958 return E_NOTIMPL;
1959 }
1960 }
1961
1962 HRESULT channel_receive_message( WS_CHANNEL *handle, WS_MESSAGE *msg )
1963 {
1964 struct channel *channel = (struct channel *)handle;
1965 HRESULT hr;
1966
1967 EnterCriticalSection( &channel->cs );
1968
1969 if (channel->magic != CHANNEL_MAGIC)
1970 {
1971 LeaveCriticalSection( &channel->cs );
1972 return E_INVALIDARG;
1973 }
1974
1975 if ((hr = receive_message_bytes( channel, msg )) == S_OK) hr = init_reader( channel );
1976
1977 LeaveCriticalSection( &channel->cs );
1978 return hr;
1979 }
1980
1981 HRESULT channel_get_reader( WS_CHANNEL *handle, WS_XML_READER **reader )
1982 {
1983 struct channel *channel = (struct channel *)handle;
1984
1985 EnterCriticalSection( &channel->cs );
1986
1987 if (channel->magic != CHANNEL_MAGIC)
1988 {
1989 LeaveCriticalSection( &channel->cs );
1990 return E_INVALIDARG;
1991 }
1992
1993 *reader = channel->reader;
1994
1995 LeaveCriticalSection( &channel->cs );
1996 return S_OK;
1997 }
1998
1999 static HRESULT read_message( WS_MESSAGE *handle, WS_XML_READER *reader, const WS_ELEMENT_DESCRIPTION *desc,
2000 WS_READ_OPTION option, WS_HEAP *heap, void *body, ULONG size )
2001 {
2002 HRESULT hr;
2003 if ((hr = WsReadEnvelopeStart( handle, reader, NULL, NULL, NULL )) != S_OK) return hr;
2004 if ((hr = WsReadBody( handle, desc, option, heap, body, size, NULL )) != S_OK) return hr;
2005 return WsReadEnvelopeEnd( handle, NULL );
2006 }
2007
2008 static HRESULT receive_message( struct channel *channel, WS_MESSAGE *msg, const WS_MESSAGE_DESCRIPTION **desc,
2009 ULONG count, WS_RECEIVE_OPTION option, WS_READ_OPTION read_option, WS_HEAP *heap,
2010 void *value, ULONG size, ULONG *index )
2011 {
2012 HRESULT hr;
2013 ULONG i;
2014
2015 if ((hr = receive_message_bytes( channel, msg )) != S_OK) return hr;
2016 if ((hr = init_reader( channel )) != S_OK) return hr;
2017
2018 for (i = 0; i < count; i++)
2019 {
2020 const WS_ELEMENT_DESCRIPTION *body = desc[i]->bodyElementDescription;
2021 if ((hr = read_message( msg, channel->reader, body, read_option, heap, value, size )) == S_OK)
2022 {
2023 if (index) *index = i;
2024 break;
2025 }
2026 if ((hr = WsResetMessage( msg, NULL )) != S_OK) return hr;
2027 if ((hr = init_reader( channel )) != S_OK) return hr;
2028 }
2029 return (i == count) ? WS_E_INVALID_FORMAT : S_OK;
2030 }
2031
2032 struct receive_message
2033 {
2034 struct task task;
2035 struct channel *channel;
2036 WS_MESSAGE *msg;
2037 const WS_MESSAGE_DESCRIPTION **desc;
2038 ULONG count;
2039 WS_RECEIVE_OPTION option;
2040 WS_READ_OPTION read_option;
2041 WS_HEAP *heap;
2042 void *value;
2043 ULONG size;
2044 ULONG *index;
2045 WS_ASYNC_CONTEXT ctx;
2046 };
2047
2048 static void receive_message_proc( struct task *task )
2049 {
2050 struct receive_message *r = (struct receive_message *)task;
2051 HRESULT hr;
2052
2053 hr = receive_message( r->channel, r->msg, r->desc, r->count, r->option, r->read_option, r->heap, r->value,
2054 r->size, r->index );
2055
2056 TRACE( "calling %p(%08x)\n", r->ctx.callback, hr );
2057 r->ctx.callback( hr, WS_LONG_CALLBACK, r->ctx.callbackState );
2058 TRACE( "%p returned\n", r->ctx.callback );
2059 }
2060
2061 static HRESULT queue_receive_message( struct channel *channel, WS_MESSAGE *msg, const WS_MESSAGE_DESCRIPTION **desc,
2062 ULONG count, WS_RECEIVE_OPTION option, WS_READ_OPTION read_option,
2063 WS_HEAP *heap, void *value, ULONG size, ULONG *index,
2064 const WS_ASYNC_CONTEXT *ctx )
2065 {
2066 struct receive_message *r;
2067
2068 if (!(r = heap_alloc( sizeof(*r) ))) return E_OUTOFMEMORY;
2069 r->task.proc = receive_message_proc;
2070 r->channel = channel;
2071 r->msg = msg;
2072 r->desc = desc;
2073 r->count = count;
2074 r->option = option;
2075 r->read_option = read_option;
2076 r->heap = heap;
2077 r->value = value;
2078 r->size = size;
2079 r->index = index;
2080 r->ctx = *ctx;
2081 return queue_task( &channel->recv_q, &r->task );
2082 }
2083
2084 /**************************************************************************
2085 * WsReceiveMessage [webservices.@]
2086 */
2087 HRESULT WINAPI WsReceiveMessage( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_MESSAGE_DESCRIPTION **desc,
2088 ULONG count, WS_RECEIVE_OPTION option, WS_READ_OPTION read_option, WS_HEAP *heap,
2089 void *value, ULONG size, ULONG *index, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
2090 {
2091 struct channel *channel = (struct channel *)handle;
2092 HRESULT hr;
2093
2094 TRACE( "%p %p %p %u %08x %08x %p %p %u %p %p %p\n", handle, msg, desc, count, option, read_option, heap,
2095 value, size, index, ctx, error );
2096 if (error) FIXME( "ignoring error parameter\n" );
2097
2098 if (!channel || !msg || !desc || !count) return E_INVALIDARG;
2099
2100 EnterCriticalSection( &channel->cs );
2101
2102 if (channel->magic != CHANNEL_MAGIC)
2103 {
2104 LeaveCriticalSection( &channel->cs );
2105 return E_INVALIDARG;
2106 }
2107
2108 if (ctx)
2109 hr = queue_receive_message( channel, msg, desc, count, option, read_option, heap, value, size, index, ctx );
2110 else
2111 hr = receive_message( channel, msg, desc, count, option, read_option, heap, value, size, index );
2112
2113 LeaveCriticalSection( &channel->cs );
2114 TRACE( "returning %08x\n", hr );
2115 return hr;
2116 }
2117
2118 static HRESULT request_reply( struct channel *channel, WS_MESSAGE *request,
2119 const WS_MESSAGE_DESCRIPTION *request_desc, WS_WRITE_OPTION write_option,
2120 const void *request_body, ULONG request_size, WS_MESSAGE *reply,
2121 const WS_MESSAGE_DESCRIPTION *reply_desc, WS_READ_OPTION read_option,
2122 WS_HEAP *heap, void *value, ULONG size )
2123 {
2124 HRESULT hr;
2125 WsInitializeMessage( request, WS_REQUEST_MESSAGE, NULL, NULL );
2126 if ((hr = WsAddressMessage( request, &channel->addr, NULL )) != S_OK) return hr;
2127 if ((hr = message_set_action( request, request_desc->action )) != S_OK) return hr;
2128
2129 if ((hr = connect_channel( channel )) != S_OK) return hr;
2130 if ((hr = init_writer( channel )) != S_OK) return hr;
2131 if ((hr = write_message( channel, request, request_desc->bodyElementDescription, write_option, request_body,
2132 request_size )) != S_OK) return hr;
2133 if ((hr = send_message( channel, request )) != S_OK) return hr;
2134
2135 return receive_message( channel, reply, &reply_desc, 1, WS_RECEIVE_OPTIONAL_MESSAGE, read_option, heap,
2136 value, size, NULL );
2137 }
2138
2139 struct request_reply
2140 {
2141 struct task task;
2142 struct channel *channel;
2143 WS_MESSAGE *request;
2144 const WS_MESSAGE_DESCRIPTION *request_desc;
2145 WS_WRITE_OPTION write_option;
2146 const void *request_body;
2147 ULONG request_size;
2148 WS_MESSAGE *reply;
2149 const WS_MESSAGE_DESCRIPTION *reply_desc;
2150 WS_READ_OPTION read_option;
2151 WS_HEAP *heap;
2152 void *value;
2153 ULONG size;
2154 WS_ASYNC_CONTEXT ctx;
2155 };
2156
2157 static void request_reply_proc( struct task *task )
2158 {
2159 struct request_reply *r = (struct request_reply *)task;
2160 HRESULT hr;
2161
2162 hr = request_reply( r->channel, r->request, r->request_desc, r->write_option, r->request_body, r->request_size,
2163 r->reply, r->reply_desc, r->read_option, r->heap, r->value, r->size );
2164
2165 TRACE( "calling %p(%08x)\n", r->ctx.callback, hr );
2166 r->ctx.callback( hr, WS_LONG_CALLBACK, r->ctx.callbackState );
2167 TRACE( "%p returned\n", r->ctx.callback );
2168 }
2169
2170 static HRESULT queue_request_reply( struct channel *channel, WS_MESSAGE *request,
2171 const WS_MESSAGE_DESCRIPTION *request_desc, WS_WRITE_OPTION write_option,
2172 const void *request_body, ULONG request_size, WS_MESSAGE *reply,
2173 const WS_MESSAGE_DESCRIPTION *reply_desc, WS_READ_OPTION read_option,
2174 WS_HEAP *heap, void *value, ULONG size, const WS_ASYNC_CONTEXT *ctx )
2175 {
2176 struct request_reply *r;
2177
2178 if (!(r = heap_alloc( sizeof(*r) ))) return E_OUTOFMEMORY;
2179 r->task.proc = request_reply_proc;
2180 r->channel = channel;
2181 r->request = request;
2182 r->request_desc = request_desc;
2183 r->write_option = write_option;
2184 r->request_body = request_body;
2185 r->request_size = request_size;
2186 r->reply = reply;
2187 r->reply_desc = reply_desc;
2188 r->read_option = read_option;
2189 r->heap = heap;
2190 r->value = value;
2191 r->size = size;
2192 r->ctx = *ctx;
2193 return queue_task( &channel->recv_q, &r->task );
2194 }
2195
2196 /**************************************************************************
2197 * WsRequestReply [webservices.@]
2198 */
2199 HRESULT WINAPI WsRequestReply( WS_CHANNEL *handle, WS_MESSAGE *request, const WS_MESSAGE_DESCRIPTION *request_desc,
2200 WS_WRITE_OPTION write_option, const void *request_body, ULONG request_size,
2201 WS_MESSAGE *reply, const WS_MESSAGE_DESCRIPTION *reply_desc, WS_READ_OPTION read_option,
2202 WS_HEAP *heap, void *value, ULONG size, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
2203 {
2204 struct channel *channel = (struct channel *)handle;
2205 HRESULT hr;
2206
2207 TRACE( "%p %p %p %08x %p %u %p %p %08x %p %p %u %p %p\n", handle, request, request_desc, write_option,
2208 request_body, request_size, reply, reply_desc, read_option, heap, value, size, ctx, error );
2209 if (error) FIXME( "ignoring error parameter\n" );
2210 if (ctx) FIXME( "ignoring ctx parameter\n" );
2211
2212 if (!channel || !request || !reply) return E_INVALIDARG;
2213
2214 EnterCriticalSection( &channel->cs );
2215
2216 if (channel->magic != CHANNEL_MAGIC)
2217 {
2218 LeaveCriticalSection( &channel->cs );
2219 return E_INVALIDARG;
2220 }
2221
2222 if (ctx)
2223 hr = queue_request_reply( channel, request, request_desc, write_option, request_body, request_size, reply,
2224 reply_desc, read_option, heap, value, size, ctx );
2225 else
2226 hr = request_reply( channel, request, request_desc, write_option, request_body, request_size, reply,
2227 reply_desc, read_option, heap, value, size );
2228
2229 LeaveCriticalSection( &channel->cs );
2230 TRACE( "returning %08x\n", hr );
2231 return hr;
2232 }
2233
2234 /**************************************************************************
2235 * WsReadMessageStart [webservices.@]
2236 */
2237 HRESULT WINAPI WsReadMessageStart( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx,
2238 WS_ERROR *error )
2239 {
2240 struct channel *channel = (struct channel *)handle;
2241 HRESULT hr;
2242
2243 TRACE( "%p %p %p %p\n", handle, msg, ctx, error );
2244 if (error) FIXME( "ignoring error parameter\n" );
2245 if (ctx) FIXME( "ignoring ctx parameter\n" );
2246
2247 if (!channel || !msg) return E_INVALIDARG;
2248
2249 EnterCriticalSection( &channel->cs );
2250
2251 if (channel->magic != CHANNEL_MAGIC)
2252 {
2253 LeaveCriticalSection( &channel->cs );
2254 return E_INVALIDARG;
2255 }
2256
2257 if ((hr = receive_message_bytes( channel, msg )) == S_OK)
2258 {
2259 if ((hr = init_reader( channel )) == S_OK)
2260 hr = WsReadEnvelopeStart( msg, channel->reader, NULL, NULL, NULL );
2261 }
2262
2263 LeaveCriticalSection( &channel->cs );
2264 TRACE( "returning %08x\n", hr );
2265 return hr;
2266 }
2267
2268 /**************************************************************************
2269 * WsReadMessageEnd [webservices.@]
2270 */
2271 HRESULT WINAPI WsReadMessageEnd( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx,
2272 WS_ERROR *error )
2273 {
2274 struct channel *channel = (struct channel *)handle;
2275 HRESULT hr;
2276
2277 TRACE( "%p %p %p %p\n", handle, msg, ctx, error );
2278 if (error) FIXME( "ignoring error parameter\n" );
2279 if (ctx) FIXME( "ignoring ctx parameter\n" );
2280
2281 if (!channel || !msg) return E_INVALIDARG;
2282
2283 EnterCriticalSection( &channel->cs );
2284
2285 if (channel->magic != CHANNEL_MAGIC)
2286 {
2287 LeaveCriticalSection( &channel->cs );
2288 return E_INVALIDARG;
2289 }
2290
2291 hr = WsReadEnvelopeEnd( msg, NULL );
2292
2293 LeaveCriticalSection( &channel->cs );
2294 TRACE( "returning %08x\n", hr );
2295 return hr;
2296 }
2297
2298 /**************************************************************************
2299 * WsWriteMessageStart [webservices.@]
2300 */
2301 HRESULT WINAPI WsWriteMessageStart( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx,
2302 WS_ERROR *error )
2303 {
2304 struct channel *channel = (struct channel *)handle;
2305 HRESULT hr;
2306
2307 TRACE( "%p %p %p %p\n", handle, msg, ctx, error );
2308 if (error) FIXME( "ignoring error parameter\n" );
2309 if (ctx) FIXME( "ignoring ctx parameter\n" );
2310
2311 if (!channel || !msg) return E_INVALIDARG;
2312
2313 EnterCriticalSection( &channel->cs );
2314
2315 if (channel->magic != CHANNEL_MAGIC)
2316 {
2317 LeaveCriticalSection( &channel->cs );
2318 return E_INVALIDARG;
2319 }
2320
2321 if ((hr = connect_channel( channel )) != S_OK) goto done;
2322 if ((hr = init_writer( channel )) != S_OK) goto done;
2323 if ((hr = WsAddressMessage( msg, &channel->addr, NULL )) != S_OK) goto done;
2324 hr = WsWriteEnvelopeStart( msg, channel->writer, NULL, NULL, NULL );
2325
2326 done:
2327 LeaveCriticalSection( &channel->cs );
2328 TRACE( "returning %08x\n", hr );
2329 return hr;
2330 }
2331
2332 /**************************************************************************
2333 * WsWriteMessageEnd [webservices.@]
2334 */
2335 HRESULT WINAPI WsWriteMessageEnd( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx,
2336 WS_ERROR *error )
2337 {
2338 struct channel *channel = (struct channel *)handle;
2339 HRESULT hr;
2340
2341 TRACE( "%p %p %p %p\n", handle, msg, ctx, error );
2342 if (error) FIXME( "ignoring error parameter\n" );
2343 if (ctx) FIXME( "ignoring ctx parameter\n" );
2344
2345 if (!channel || !msg) return E_INVALIDARG;
2346
2347 EnterCriticalSection( &channel->cs );
2348
2349 if (channel->magic != CHANNEL_MAGIC)
2350 {
2351 LeaveCriticalSection( &channel->cs );
2352 return E_INVALIDARG;
2353 }
2354
2355 if ((hr = WsWriteEnvelopeEnd( msg, NULL )) == S_OK && (hr = connect_channel( channel )) == S_OK)
2356 hr = send_message( channel, msg );
2357
2358 LeaveCriticalSection( &channel->cs );
2359 TRACE( "returning %08x\n", hr );
2360 return hr;
2361 }
2362
2363 static void set_blocking( SOCKET socket, BOOL blocking )
2364 {
2365 ULONG state = !blocking;
2366 ioctlsocket( socket, FIONBIO, &state );
2367 }
2368
2369 static HRESULT sock_accept( SOCKET socket, HANDLE wait, HANDLE cancel, SOCKET *ret )
2370 {
2371 HANDLE handles[] = { wait, cancel };
2372 HRESULT hr = S_OK;
2373
2374 if (WSAEventSelect( socket, handles[0], FD_ACCEPT )) return HRESULT_FROM_WIN32( WSAGetLastError() );
2375
2376 switch (WSAWaitForMultipleEvents( 2, handles, FALSE, WSA_INFINITE, FALSE ))
2377 {
2378 case 0:
2379 if ((*ret = accept( socket, NULL, NULL )) != -1)
2380 {
2381 WSAEventSelect( *ret, NULL, 0 );
2382 set_blocking( *ret, TRUE );
2383 break;
2384 }
2385 hr = HRESULT_FROM_WIN32( WSAGetLastError() );
2386 break;
2387
2388 case 1:
2389 hr = WS_E_OPERATION_ABORTED;
2390 break;
2391
2392 default:
2393 hr = HRESULT_FROM_WIN32( WSAGetLastError() );
2394 break;
2395 }
2396
2397 return hr;
2398 }
2399
2400 HRESULT channel_accept_tcp( SOCKET socket, HANDLE wait, HANDLE cancel, WS_CHANNEL *handle )
2401 {
2402 struct channel *channel = (struct channel *)handle;
2403 HRESULT hr;
2404
2405 EnterCriticalSection( &channel->cs );
2406
2407 if (channel->magic != CHANNEL_MAGIC)
2408 {
2409 LeaveCriticalSection( &channel->cs );
2410 return E_INVALIDARG;
2411 }
2412
2413 hr = sock_accept( socket, wait, cancel, &channel->u.tcp.socket );
2414
2415 LeaveCriticalSection( &channel->cs );
2416 return hr;
2417 }
2418
2419 static HRESULT sock_wait( SOCKET socket, HANDLE wait, HANDLE cancel )
2420 {
2421 HANDLE handles[] = { wait, cancel };
2422 HRESULT hr;
2423
2424 if (WSAEventSelect( socket, handles[0], FD_READ )) return HRESULT_FROM_WIN32( WSAGetLastError() );
2425
2426 switch (WSAWaitForMultipleEvents( 2, handles, FALSE, WSA_INFINITE, FALSE ))
2427 {
2428 case 0:
2429 hr = S_OK;
2430 break;
2431
2432 case 1:
2433 hr = WS_E_OPERATION_ABORTED;
2434 break;
2435
2436 default:
2437 hr = HRESULT_FROM_WIN32( WSAGetLastError() );
2438 break;
2439 }
2440
2441 WSAEventSelect( socket, NULL, 0 );
2442 set_blocking( socket, TRUE );
2443 return hr;
2444 }
2445
2446 HRESULT channel_accept_udp( SOCKET socket, HANDLE wait, HANDLE cancel, WS_CHANNEL *handle )
2447 {
2448 struct channel *channel = (struct channel *)handle;
2449 HRESULT hr;
2450
2451 EnterCriticalSection( &channel->cs );
2452
2453 if (channel->magic != CHANNEL_MAGIC)
2454 {
2455 LeaveCriticalSection( &channel->cs );
2456 return E_INVALIDARG;
2457 }
2458
2459 if ((hr = sock_wait( socket, wait, cancel )) == S_OK) channel->u.udp.socket = socket;
2460
2461 LeaveCriticalSection( &channel->cs );
2462 return hr;
2463 }
2464
2465 /**************************************************************************
2466 * WsAbortChannel [webservices.@]
2467 */
2468 HRESULT WINAPI WsAbortChannel( WS_CHANNEL *handle, WS_ERROR *error )
2469 {
2470 FIXME( "%p %p: stub!\n", handle, error );
2471 return E_NOTIMPL;
2472 }
Windows API implementation