?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
webservices: Build a session dictionary for strings not present in the static dictionary.
[wine.git] / dlls / webservices / channel.c
blob29c8108055efc9ef6f57b12bd07f0819d6f94a34
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 #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 enum session_state
90 {
91 SESSION_STATE_UNINITIALIZED,
92 SESSION_STATE_SETUP_COMPLETE,
93 };
94
95 struct channel
96 {
97 ULONG magic;
98 CRITICAL_SECTION cs;
99 WS_CHANNEL_TYPE type;
100 WS_CHANNEL_BINDING binding;
101 WS_CHANNEL_STATE state;
102 WS_ENDPOINT_ADDRESS addr;
103 WS_XML_WRITER *writer;
104 WS_XML_READER *reader;
105 WS_MESSAGE *msg;
106 WS_ENCODING encoding;
107 enum session_state session_state;
108 struct dictionary dict;
109 union
110 {
111 struct
112 {
113 HINTERNET session;
114 HINTERNET connect;
115 HINTERNET request;
116 WCHAR *path;
117 DWORD flags;
118 } http;
119 struct
120 {
121 SOCKET socket;
122 } tcp;
123 struct
124 {
125 SOCKET socket;
126 } udp;
127 } u;
128 char *read_buf;
129 ULONG read_buflen;
130 ULONG read_size;
131 ULONG prop_count;
132 struct prop prop[sizeof(channel_props)/sizeof(channel_props[0])];
133 };
134
135 #define CHANNEL_MAGIC (('C' << 24) | ('H' << 16) | ('A' << 8) | 'N')
136
137 static struct channel *alloc_channel(void)
138 {
139 static const ULONG count = sizeof(channel_props)/sizeof(channel_props[0]);
140 struct channel *ret;
141 ULONG size = sizeof(*ret) + prop_size( channel_props, count );
142
143 if (!(ret = heap_alloc_zero( size ))) return NULL;
144
145 ret->magic = CHANNEL_MAGIC;
146 InitializeCriticalSection( &ret->cs );
147 ret->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": channel.cs");
148
149 prop_init( channel_props, count, ret->prop, &ret[1] );
150 ret->prop_count = count;
151 return ret;
152 }
153
154 static void reset_channel( struct channel *channel )
155 {
156 channel->state = WS_CHANNEL_STATE_CREATED;
157 heap_free( channel->addr.url.chars );
158 channel->addr.url.chars = NULL;
159 channel->addr.url.length = 0;
160 channel->msg = NULL;
161 channel->read_size = 0;
162 channel->session_state = SESSION_STATE_UNINITIALIZED;
163 clear_dict( &channel->dict );
164
165 switch (channel->binding)
166 {
167 case WS_HTTP_CHANNEL_BINDING:
168 WinHttpCloseHandle( channel->u.http.request );
169 channel->u.http.request = NULL;
170 WinHttpCloseHandle( channel->u.http.connect );
171 channel->u.http.connect = NULL;
172 WinHttpCloseHandle( channel->u.http.session );
173 channel->u.http.session = NULL;
174 heap_free( channel->u.http.path );
175 channel->u.http.path = NULL;
176 channel->u.http.flags = 0;
177 break;
178
179 case WS_TCP_CHANNEL_BINDING:
180 closesocket( channel->u.tcp.socket );
181 channel->u.tcp.socket = -1;
182 break;
183
184 case WS_UDP_CHANNEL_BINDING:
185 closesocket( channel->u.udp.socket );
186 channel->u.udp.socket = -1;
187 break;
188
189 default: break;
190 }
191 }
192
193 static void free_channel( struct channel *channel )
194 {
195 reset_channel( channel );
196
197 WsFreeWriter( channel->writer );
198 WsFreeReader( channel->reader );
199
200 heap_free( channel->read_buf );
201
202 channel->cs.DebugInfo->Spare[0] = 0;
203 DeleteCriticalSection( &channel->cs );
204 heap_free( channel );
205 }
206
207 static HRESULT create_channel( WS_CHANNEL_TYPE type, WS_CHANNEL_BINDING binding,
208 const WS_CHANNEL_PROPERTY *properties, ULONG count, struct channel **ret )
209 {
210 struct channel *channel;
211 ULONG i, msg_size = 65536;
212 WS_ENVELOPE_VERSION env_version = WS_ENVELOPE_VERSION_SOAP_1_2;
213 WS_ADDRESSING_VERSION addr_version = WS_ADDRESSING_VERSION_1_0;
214 HRESULT hr;
215
216 if (!(channel = alloc_channel())) return E_OUTOFMEMORY;
217
218 prop_set( channel->prop, channel->prop_count, WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE,
219 &msg_size, sizeof(msg_size) );
220 prop_set( channel->prop, channel->prop_count, WS_CHANNEL_PROPERTY_ENVELOPE_VERSION,
221 &env_version, sizeof(env_version) );
222 prop_set( channel->prop, channel->prop_count, WS_CHANNEL_PROPERTY_ADDRESSING_VERSION,
223 &addr_version, sizeof(addr_version) );
224
225 channel->type = type;
226 channel->binding = binding;
227
228 switch (channel->binding)
229 {
230 case WS_HTTP_CHANNEL_BINDING:
231 channel->encoding = WS_ENCODING_XML_UTF8;
232 break;
233
234 case WS_TCP_CHANNEL_BINDING:
235 channel->u.tcp.socket = -1;
236 channel->encoding = WS_ENCODING_XML_BINARY_SESSION_1;
237 break;
238
239 case WS_UDP_CHANNEL_BINDING:
240 channel->u.udp.socket = -1;
241 channel->encoding = WS_ENCODING_XML_UTF8;
242 break;
243
244 default: break;
245 }
246
247 for (i = 0; i < count; i++)
248 {
249 switch (properties[i].id)
250 {
251 case WS_CHANNEL_PROPERTY_ENCODING:
252 if (!properties[i].value || properties[i].valueSize != sizeof(channel->encoding))
253 {
254 free_channel( channel );
255 return E_INVALIDARG;
256 }
257 channel->encoding = *(WS_ENCODING *)properties[i].value;
258 break;
259
260 default:
261 if ((hr = prop_set( channel->prop, channel->prop_count, properties[i].id, properties[i].value,
262 properties[i].valueSize )) != S_OK)
263 {
264 free_channel( channel );
265 return hr;
266 }
267 break;
268 }
269 }
270
271 *ret = channel;
272 return S_OK;
273 }
274
275 /**************************************************************************
276 * WsCreateChannel [webservices.@]
277 */
278 HRESULT WINAPI WsCreateChannel( WS_CHANNEL_TYPE type, WS_CHANNEL_BINDING binding,
279 const WS_CHANNEL_PROPERTY *properties, ULONG count,
280 const WS_SECURITY_DESCRIPTION *desc, WS_CHANNEL **handle,
281 WS_ERROR *error )
282 {
283 struct channel *channel;
284 HRESULT hr;
285
286 TRACE( "%u %u %p %u %p %p %p\n", type, binding, properties, count, desc, handle, error );
287 if (error) FIXME( "ignoring error parameter\n" );
288 if (desc) FIXME( "ignoring security description\n" );
289
290 if (!handle) return E_INVALIDARG;
291
292 if (type != WS_CHANNEL_TYPE_REQUEST && type != WS_CHANNEL_TYPE_DUPLEX &&
293 type != WS_CHANNEL_TYPE_DUPLEX_SESSION)
294 {
295 FIXME( "channel type %u not implemented\n", type );
296 return E_NOTIMPL;
297 }
298 if (binding != WS_HTTP_CHANNEL_BINDING && binding != WS_TCP_CHANNEL_BINDING &&
299 binding != WS_UDP_CHANNEL_BINDING)
300 {
301 FIXME( "channel binding %u not implemented\n", binding );
302 return E_NOTIMPL;
303 }
304
305 if ((hr = create_channel( type, binding, properties, count, &channel )) != S_OK) return hr;
306
307 *handle = (WS_CHANNEL *)channel;
308 return S_OK;
309 }
310
311 /**************************************************************************
312 * WsCreateChannelForListener [webservices.@]
313 */
314 HRESULT WINAPI WsCreateChannelForListener( WS_LISTENER *listener_handle, const WS_CHANNEL_PROPERTY *properties,
315 ULONG count, WS_CHANNEL **handle, WS_ERROR *error )
316 {
317 struct channel *channel;
318 WS_CHANNEL_TYPE type;
319 WS_CHANNEL_BINDING binding;
320 HRESULT hr;
321
322 TRACE( "%p %p %u %p %p\n", listener_handle, properties, count, handle, error );
323 if (error) FIXME( "ignoring error parameter\n" );
324
325 if (!listener_handle || !handle) return E_INVALIDARG;
326
327 if ((hr = WsGetListenerProperty( listener_handle, WS_LISTENER_PROPERTY_CHANNEL_TYPE, &type,
328 sizeof(type), NULL )) != S_OK) return hr;
329
330 if ((hr = WsGetListenerProperty( listener_handle, WS_LISTENER_PROPERTY_CHANNEL_BINDING, &binding,
331 sizeof(binding), NULL )) != S_OK) return hr;
332
333 if ((hr = create_channel( type, binding, properties, count, &channel )) != S_OK) return hr;
334
335 *handle = (WS_CHANNEL *)channel;
336 return S_OK;
337 }
338
339 /**************************************************************************
340 * WsFreeChannel [webservices.@]
341 */
342 void WINAPI WsFreeChannel( WS_CHANNEL *handle )
343 {
344 struct channel *channel = (struct channel *)handle;
345
346 TRACE( "%p\n", handle );
347
348 if (!channel) return;
349
350 EnterCriticalSection( &channel->cs );
351
352 if (channel->magic != CHANNEL_MAGIC)
353 {
354 LeaveCriticalSection( &channel->cs );
355 return;
356 }
357
358 channel->magic = 0;
359
360 LeaveCriticalSection( &channel->cs );
361 free_channel( channel );
362 }
363
364 /**************************************************************************
365 * WsResetChannel [webservices.@]
366 */
367 HRESULT WINAPI WsResetChannel( WS_CHANNEL *handle, WS_ERROR *error )
368 {
369 struct channel *channel = (struct channel *)handle;
370
371 TRACE( "%p %p\n", handle, error );
372 if (error) FIXME( "ignoring error parameter\n" );
373
374 if (!channel) return E_INVALIDARG;
375
376 EnterCriticalSection( &channel->cs );
377
378 if (channel->magic != CHANNEL_MAGIC)
379 {
380 LeaveCriticalSection( &channel->cs );
381 return E_INVALIDARG;
382 }
383
384 if (channel->state != WS_CHANNEL_STATE_CREATED && channel->state != WS_CHANNEL_STATE_CLOSED)
385 {
386 LeaveCriticalSection( &channel->cs );
387 return WS_E_INVALID_OPERATION;
388 }
389
390 reset_channel( channel );
391
392 LeaveCriticalSection( &channel->cs );
393 return S_OK;
394 }
395
396 /**************************************************************************
397 * WsGetChannelProperty [webservices.@]
398 */
399 HRESULT WINAPI WsGetChannelProperty( WS_CHANNEL *handle, WS_CHANNEL_PROPERTY_ID id, void *buf,
400 ULONG size, WS_ERROR *error )
401 {
402 struct channel *channel = (struct channel *)handle;
403 HRESULT hr = S_OK;
404
405 TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
406 if (error) FIXME( "ignoring error parameter\n" );
407
408 if (!channel) return E_INVALIDARG;
409
410 EnterCriticalSection( &channel->cs );
411
412 if (channel->magic != CHANNEL_MAGIC)
413 {
414 LeaveCriticalSection( &channel->cs );
415 return E_INVALIDARG;
416 }
417
418 switch (id)
419 {
420 case WS_CHANNEL_PROPERTY_CHANNEL_TYPE:
421 if (!buf || size != sizeof(channel->type)) hr = E_INVALIDARG;
422 else *(WS_CHANNEL_TYPE *)buf = channel->type;
423 break;
424
425 case WS_CHANNEL_PROPERTY_ENCODING:
426 if (!buf || size != sizeof(channel->encoding)) hr = E_INVALIDARG;
427 else *(WS_ENCODING *)buf = channel->encoding;
428 break;
429
430 default:
431 hr = prop_get( channel->prop, channel->prop_count, id, buf, size );
432 }
433
434 LeaveCriticalSection( &channel->cs );
435 return hr;
436 }
437
438 /**************************************************************************
439 * WsSetChannelProperty [webservices.@]
440 */
441 HRESULT WINAPI WsSetChannelProperty( WS_CHANNEL *handle, WS_CHANNEL_PROPERTY_ID id, const void *value,
442 ULONG size, WS_ERROR *error )
443 {
444 struct channel *channel = (struct channel *)handle;
445 HRESULT hr;
446
447 TRACE( "%p %u %p %u\n", handle, id, value, size );
448 if (error) FIXME( "ignoring error parameter\n" );
449
450 if (!channel) return E_INVALIDARG;
451
452 EnterCriticalSection( &channel->cs );
453
454 if (channel->magic != CHANNEL_MAGIC)
455 {
456 LeaveCriticalSection( &channel->cs );
457 return E_INVALIDARG;
458 }
459
460 hr = prop_set( channel->prop, channel->prop_count, id, value, size );
461
462 LeaveCriticalSection( &channel->cs );
463 return hr;
464 }
465
466 static HRESULT open_channel( struct channel *channel, const WS_ENDPOINT_ADDRESS *endpoint )
467 {
468 if (endpoint->headers || endpoint->extensions || endpoint->identity)
469 {
470 FIXME( "headers, extensions or identity not supported\n" );
471 return E_NOTIMPL;
472 }
473
474 if (!(channel->addr.url.chars = heap_alloc( endpoint->url.length * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
475 memcpy( channel->addr.url.chars, endpoint->url.chars, endpoint->url.length * sizeof(WCHAR) );
476 channel->addr.url.length = endpoint->url.length;
477
478 channel->state = WS_CHANNEL_STATE_OPEN;
479 return S_OK;
480 }
481
482 /**************************************************************************
483 * WsOpenChannel [webservices.@]
484 */
485 HRESULT WINAPI WsOpenChannel( WS_CHANNEL *handle, const WS_ENDPOINT_ADDRESS *endpoint,
486 const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
487 {
488 struct channel *channel = (struct channel *)handle;
489 HRESULT hr;
490
491 TRACE( "%p %p %p %p\n", handle, endpoint, ctx, error );
492 if (error) FIXME( "ignoring error parameter\n" );
493 if (ctx) FIXME( "ignoring ctx parameter\n" );
494
495 if (!channel || !endpoint) return E_INVALIDARG;
496
497 EnterCriticalSection( &channel->cs );
498
499 if (channel->magic != CHANNEL_MAGIC)
500 {
501 LeaveCriticalSection( &channel->cs );
502 return E_INVALIDARG;
503 }
504
505 if (channel->state != WS_CHANNEL_STATE_CREATED)
506 {
507 LeaveCriticalSection( &channel->cs );
508 return WS_E_INVALID_OPERATION;
509 }
510
511 hr = open_channel( channel, endpoint );
512
513 LeaveCriticalSection( &channel->cs );
514 return hr;
515 }
516
517 static void close_channel( struct channel *channel )
518 {
519 reset_channel( channel );
520 channel->state = WS_CHANNEL_STATE_CLOSED;
521 }
522
523 /**************************************************************************
524 * WsCloseChannel [webservices.@]
525 */
526 HRESULT WINAPI WsCloseChannel( WS_CHANNEL *handle, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
527 {
528 struct channel *channel = (struct channel *)handle;
529
530 TRACE( "%p %p %p\n", handle, ctx, error );
531 if (error) FIXME( "ignoring error parameter\n" );
532 if (ctx) FIXME( "ignoring ctx parameter\n" );
533
534 if (!channel) return E_INVALIDARG;
535
536 EnterCriticalSection( &channel->cs );
537
538 if (channel->magic != CHANNEL_MAGIC)
539 {
540 LeaveCriticalSection( &channel->cs );
541 return E_INVALIDARG;
542 }
543
544 close_channel( channel );
545
546 LeaveCriticalSection( &channel->cs );
547 return S_OK;
548 }
549
550 static HRESULT parse_http_url( const WCHAR *url, ULONG len, URL_COMPONENTS *uc )
551 {
552 HRESULT hr = E_OUTOFMEMORY;
553 WCHAR *tmp;
554 DWORD err;
555
556 memset( uc, 0, sizeof(*uc) );
557 uc->dwStructSize = sizeof(*uc);
558 uc->dwHostNameLength = 128;
559 uc->lpszHostName = heap_alloc( uc->dwHostNameLength * sizeof(WCHAR) );
560 uc->dwUrlPathLength = 128;
561 uc->lpszUrlPath = heap_alloc( uc->dwUrlPathLength * sizeof(WCHAR) );
562 uc->dwExtraInfoLength = 128;
563 uc->lpszExtraInfo = heap_alloc( uc->dwExtraInfoLength * sizeof(WCHAR) );
564 if (!uc->lpszHostName || !uc->lpszUrlPath || !uc->lpszExtraInfo) goto error;
565
566 if (!WinHttpCrackUrl( url, len, ICU_DECODE, uc ))
567 {
568 if ((err = GetLastError()) != ERROR_INSUFFICIENT_BUFFER)
569 {
570 hr = HRESULT_FROM_WIN32( err );
571 goto error;
572 }
573 if (!(tmp = heap_realloc( uc->lpszHostName, uc->dwHostNameLength * sizeof(WCHAR) ))) goto error;
574 uc->lpszHostName = tmp;
575 if (!(tmp = heap_realloc( uc->lpszUrlPath, uc->dwUrlPathLength * sizeof(WCHAR) ))) goto error;
576 uc->lpszUrlPath = tmp;
577 if (!(tmp = heap_realloc( uc->lpszExtraInfo, uc->dwExtraInfoLength * sizeof(WCHAR) ))) goto error;
578 uc->lpszExtraInfo = tmp;
579 WinHttpCrackUrl( url, len, ICU_DECODE, uc );
580 }
581
582 return S_OK;
583
584 error:
585 heap_free( uc->lpszHostName );
586 heap_free( uc->lpszUrlPath );
587 heap_free( uc->lpszExtraInfo );
588 return hr;
589 }
590
591 static HRESULT connect_channel_http( struct channel *channel )
592 {
593 static const WCHAR agentW[] =
594 {'M','S','-','W','e','b','S','e','r','v','i','c','e','s','/','1','.','0',0};
595 HINTERNET ses = NULL, con = NULL;
596 URL_COMPONENTS uc;
597 HRESULT hr;
598
599 if (channel->u.http.connect) return S_OK;
600
601 if ((hr = parse_http_url( channel->addr.url.chars, channel->addr.url.length, &uc )) != S_OK) return hr;
602 if (!(channel->u.http.path = heap_alloc( (uc.dwUrlPathLength + uc.dwExtraInfoLength + 1) * sizeof(WCHAR) )))
603 {
604 hr = E_OUTOFMEMORY;
605 goto done;
606 }
607 else
608 {
609 strcpyW( channel->u.http.path, uc.lpszUrlPath );
610 if (uc.dwExtraInfoLength) strcatW( channel->u.http.path, uc.lpszExtraInfo );
611 }
612
613 channel->u.http.flags = WINHTTP_FLAG_REFRESH;
614 switch (uc.nScheme)
615 {
616 case INTERNET_SCHEME_HTTP: break;
617 case INTERNET_SCHEME_HTTPS:
618 channel->u.http.flags |= WINHTTP_FLAG_SECURE;
619 break;
620
621 default:
622 hr = WS_E_INVALID_ENDPOINT_URL;
623 goto done;
624 }
625
626 if (!(ses = WinHttpOpen( agentW, 0, NULL, NULL, 0 )))
627 {
628 hr = HRESULT_FROM_WIN32( GetLastError() );
629 goto done;
630 }
631 if (!(con = WinHttpConnect( ses, uc.lpszHostName, uc.nPort, 0 )))
632 {
633 hr = HRESULT_FROM_WIN32( GetLastError() );
634 goto done;
635 }
636
637 channel->u.http.session = ses;
638 channel->u.http.connect = con;
639
640 done:
641 if (hr != S_OK)
642 {
643 WinHttpCloseHandle( con );
644 WinHttpCloseHandle( ses );
645 }
646 heap_free( uc.lpszHostName );
647 heap_free( uc.lpszUrlPath );
648 heap_free( uc.lpszExtraInfo );
649 return hr;
650 }
651
652 static HRESULT connect_channel_tcp( struct channel *channel )
653 {
654 struct sockaddr_storage storage;
655 struct sockaddr *addr = (struct sockaddr *)&storage;
656 int addr_len;
657 WS_URL_SCHEME_TYPE scheme;
658 WCHAR *host;
659 USHORT port;
660 HRESULT hr;
661
662 if (channel->u.tcp.socket != -1) return S_OK;
663
664 if ((hr = parse_url( &channel->addr.url, &scheme, &host, &port )) != S_OK) return hr;
665 if (scheme != WS_URL_NETTCP_SCHEME_TYPE)
666 {
667 heap_free( host );
668 return WS_E_INVALID_ENDPOINT_URL;
669 }
670
671 winsock_init();
672
673 hr = resolve_hostname( host, port, addr, &addr_len, 0 );
674 heap_free( host );
675 if (hr != S_OK) return hr;
676
677 if ((channel->u.tcp.socket = socket( addr->sa_family, SOCK_STREAM, 0 )) == -1)
678 return HRESULT_FROM_WIN32( WSAGetLastError() );
679
680 if (connect( channel->u.tcp.socket, addr, addr_len ) < 0)
681 {
682 closesocket( channel->u.tcp.socket );
683 channel->u.tcp.socket = -1;
684 return HRESULT_FROM_WIN32( WSAGetLastError() );
685 }
686
687 return S_OK;
688 }
689
690 static HRESULT connect_channel_udp( struct channel *channel )
691 {
692 struct sockaddr_storage storage;
693 struct sockaddr *addr = (struct sockaddr *)&storage;
694 int addr_len;
695 WS_URL_SCHEME_TYPE scheme;
696 WCHAR *host;
697 USHORT port;
698 HRESULT hr;
699
700 if (channel->u.udp.socket != -1) return S_OK;
701
702 if ((hr = parse_url( &channel->addr.url, &scheme, &host, &port )) != S_OK) return hr;
703 if (scheme != WS_URL_SOAPUDP_SCHEME_TYPE)
704 {
705 heap_free( host );
706 return WS_E_INVALID_ENDPOINT_URL;
707 }
708
709 winsock_init();
710
711 hr = resolve_hostname( host, port, addr, &addr_len, 0 );
712 heap_free( host );
713 if (hr != S_OK) return hr;
714
715 if ((channel->u.udp.socket = socket( addr->sa_family, SOCK_DGRAM, 0 )) == -1)
716 return HRESULT_FROM_WIN32( WSAGetLastError() );
717
718 if (connect( channel->u.udp.socket, addr, addr_len ) < 0)
719 {
720 closesocket( channel->u.udp.socket );
721 channel->u.udp.socket = -1;
722 return HRESULT_FROM_WIN32( WSAGetLastError() );
723 }
724
725 return S_OK;
726 }
727
728 static HRESULT connect_channel( struct channel *channel )
729 {
730 switch (channel->binding)
731 {
732 case WS_HTTP_CHANNEL_BINDING:
733 return connect_channel_http( channel );
734
735 case WS_TCP_CHANNEL_BINDING:
736 return connect_channel_tcp( channel );
737
738 case WS_UDP_CHANNEL_BINDING:
739 return connect_channel_udp( channel );
740
741 default:
742 ERR( "unhandled binding %u\n", channel->binding );
743 return E_NOTIMPL;
744 }
745 }
746
747 static HRESULT write_message( WS_MESSAGE *handle, WS_XML_WRITER *writer, const WS_ELEMENT_DESCRIPTION *desc,
748 WS_WRITE_OPTION option, const void *body, ULONG size )
749 {
750 HRESULT hr;
751 if ((hr = WsWriteEnvelopeStart( handle, writer, NULL, NULL, NULL )) != S_OK) return hr;
752 if ((hr = WsWriteBody( handle, desc, option, body, size, NULL )) != S_OK) return hr;
753 return WsWriteEnvelopeEnd( handle, NULL );
754 }
755
756 static HRESULT send_message_http( HINTERNET request, BYTE *data, ULONG len )
757 {
758 if (!WinHttpSendRequest( request, NULL, 0, data, len, len, 0 ))
759 return HRESULT_FROM_WIN32( GetLastError() );
760
761 if (!WinHttpReceiveResponse( request, NULL ))
762 return HRESULT_FROM_WIN32( GetLastError() );
763 return S_OK;
764 }
765
766 static HRESULT send_byte( SOCKET socket, BYTE byte )
767 {
768 int count = send( socket, (char *)&byte, 1, 0 );
769 if (count < 0) return HRESULT_FROM_WIN32( WSAGetLastError() );
770 if (count != 1) return WS_E_OTHER;
771 return S_OK;
772 }
773
774 static HRESULT send_bytes( SOCKET socket, BYTE *bytes, int len )
775 {
776 int count = send( socket, (char *)bytes, len, 0 );
777 if (count < 0) return HRESULT_FROM_WIN32( WSAGetLastError() );
778 if (count != len) return WS_E_OTHER;
779 return S_OK;
780 }
781
782 static HRESULT send_size( SOCKET socket, ULONG size )
783 {
784 HRESULT hr;
785 if (size < 0x80) return send_byte( socket, size );
786 if ((hr = send_byte( socket, (size & 0x7f) | 0x80 )) != S_OK) return hr;
787 if ((size >>= 7) < 0x80) return send_byte( socket, size );
788 if ((hr = send_byte( socket, (size & 0x7f) | 0x80 )) != S_OK) return hr;
789 if ((size >>= 7) < 0x80) return send_byte( socket, size );
790 if ((hr = send_byte( socket, (size & 0x7f) | 0x80 )) != S_OK) return hr;
791 if ((size >>= 7) < 0x80) return send_byte( socket, size );
792 if ((hr = send_byte( socket, (size & 0x7f) | 0x80 )) != S_OK) return hr;
793 if ((size >>= 7) < 0x08) return send_byte( socket, size );
794 return E_INVALIDARG;
795 }
796
797 enum frame_record_type
798 {
799 FRAME_RECORD_TYPE_VERSION,
800 FRAME_RECORD_TYPE_MODE,
801 FRAME_RECORD_TYPE_VIA,
802 FRAME_RECORD_TYPE_KNOWN_ENCODING,
803 FRAME_RECORD_TYPE_EXTENSIBLE_ENCODING,
804 FRAME_RECORD_TYPE_UNSIZED_ENVELOPE,
805 FRAME_RECORD_TYPE_SIZED_ENVELOPE,
806 FRAME_RECORD_TYPE_END,
807 FRAME_RECORD_TYPE_FAULT,
808 FRAME_RECORD_TYPE_UPGRADE_REQUEST,
809 FRAME_RECORD_TYPE_UPGRADE_RESPONSE,
810 FRAME_RECORD_TYPE_PREAMBLE_ACK,
811 FRAME_RECORD_TYPE_PREAMBLE_END,
812 };
813
814 static inline ULONG size_length( ULONG size )
815 {
816 if (size < 0x80) return 1;
817 if (size < 0x4000) return 2;
818 if (size < 0x200000) return 3;
819 if (size < 0x10000000) return 4;
820 return 5;
821 }
822
823 static ULONG string_table_size( const WS_XML_DICTIONARY *dict )
824 {
825 ULONG i, size = 0;
826 for (i = 0; i < dict->stringCount; i++)
827 size += size_length( dict->strings[i].length ) + dict->strings[i].length;
828 return size;
829 }
830
831 static HRESULT send_string_table( SOCKET socket, const WS_XML_DICTIONARY *dict )
832 {
833 ULONG i;
834 HRESULT hr;
835 for (i = 0; i < dict->stringCount; i++)
836 {
837 if ((hr = send_size( socket, dict->strings[i].length )) != S_OK) return hr;
838 if ((hr = send_bytes( socket, dict->strings[i].bytes, dict->strings[i].length )) != S_OK) return hr;
839 }
840 return S_OK;
841 }
842
843 static HRESULT string_to_utf8( const WS_STRING *str, unsigned char **ret, int *len )
844 {
845 *len = WideCharToMultiByte( CP_UTF8, 0, str->chars, str->length, NULL, 0, NULL, NULL );
846 if (!(*ret = heap_alloc( *len ))) return E_OUTOFMEMORY;
847 WideCharToMultiByte( CP_UTF8, 0, str->chars, str->length, (char *)*ret, *len, NULL, NULL );
848 return S_OK;
849 }
850
851 enum session_mode
852 {
853 SESSION_MODE_INVALID = 0,
854 SESSION_MODE_SINGLETON = 1,
855 SESSION_MODE_DUPLEX = 2,
856 SESSION_MODE_SIMPLEX = 3,
857 };
858
859 static enum session_mode map_channel_type( struct channel *channel )
860 {
861 switch (channel->type)
862 {
863 case WS_CHANNEL_TYPE_DUPLEX_SESSION: return SESSION_MODE_DUPLEX;
864 default:
865 FIXME( "unhandled channel type %08x\n", channel->type );
866 return SESSION_MODE_INVALID;
867 }
868 }
869
870 enum known_encoding
871 {
872 KNOWN_ENCODING_SOAP11_UTF8 = 0x00,
873 KNOWN_ENCODING_SOAP11_UTF16 = 0x01,
874 KNOWN_ENCODING_SOAP11_UTF16LE = 0x02,
875 KNOWN_ENCODING_SOAP12_UTF8 = 0x03,
876 KNOWN_ENCODING_SOAP12_UTF16 = 0x04,
877 KNOWN_ENCODING_SOAP12_UTF16LE = 0x05,
878 KNOWN_ENCODING_SOAP12_MTOM = 0x06,
879 KNOWN_ENCODING_SOAP12_BINARY = 0x07,
880 KNOWN_ENCODING_SOAP12_BINARY_SESSION = 0x08,
881 };
882
883 static enum known_encoding map_channel_encoding( struct channel *channel )
884 {
885 WS_ENVELOPE_VERSION version;
886
887 prop_get( channel->prop, channel->prop_count, WS_CHANNEL_PROPERTY_ENVELOPE_VERSION, &version, sizeof(version) );
888
889 switch (version)
890 {
891 case WS_ENVELOPE_VERSION_SOAP_1_1:
892 switch (channel->encoding)
893 {
894 case WS_ENCODING_XML_UTF8: return KNOWN_ENCODING_SOAP11_UTF8;
895 case WS_ENCODING_XML_UTF16LE: return KNOWN_ENCODING_SOAP11_UTF16LE;
896 default:
897 FIXME( "unhandled version/encoding %u/%u\n", version, channel->encoding );
898 return 0;
899 }
900 case WS_ENVELOPE_VERSION_SOAP_1_2:
901 switch (channel->encoding)
902 {
903 case WS_ENCODING_XML_UTF8: return KNOWN_ENCODING_SOAP12_UTF8;
904 case WS_ENCODING_XML_UTF16LE: return KNOWN_ENCODING_SOAP12_UTF16LE;
905 case WS_ENCODING_XML_BINARY_1: return KNOWN_ENCODING_SOAP12_BINARY;
906 case WS_ENCODING_XML_BINARY_SESSION_1: return KNOWN_ENCODING_SOAP12_BINARY_SESSION;
907 default:
908 FIXME( "unhandled version/encoding %u/%u\n", version, channel->encoding );
909 return 0;
910 }
911 default:
912 ERR( "unhandled version %u\n", version );
913 return 0;
914 }
915 }
916
917 #define FRAME_VERSION_MAJOR 1
918 #define FRAME_VERSION_MINOR 1
919
920 static HRESULT send_preamble( struct channel *channel )
921 {
922 unsigned char *url;
923 HRESULT hr;
924 int len;
925
926 if ((hr = send_byte( channel->u.tcp.socket, FRAME_RECORD_TYPE_VERSION )) != S_OK) return hr;
927 if ((hr = send_byte( channel->u.tcp.socket, FRAME_VERSION_MAJOR )) != S_OK) return hr;
928 if ((hr = send_byte( channel->u.tcp.socket, FRAME_VERSION_MINOR )) != S_OK) return hr;
929
930 if ((hr = send_byte( channel->u.tcp.socket, FRAME_RECORD_TYPE_MODE )) != S_OK) return hr;
931 if ((hr = send_byte( channel->u.tcp.socket, map_channel_type(channel) )) != S_OK) return hr;
932
933 if ((hr = send_byte( channel->u.tcp.socket, FRAME_RECORD_TYPE_VIA )) != S_OK) return hr;
934 if ((hr = string_to_utf8( &channel->addr.url, &url, &len )) != S_OK) return hr;
935 if ((hr = send_size( channel->u.tcp.socket, len )) != S_OK) goto done;
936 if ((hr = send_bytes( channel->u.tcp.socket, url, len )) != S_OK) goto done;
937
938 if ((hr = send_byte( channel->u.tcp.socket, FRAME_RECORD_TYPE_KNOWN_ENCODING )) != S_OK) goto done;
939 if ((hr = send_byte( channel->u.tcp.socket, map_channel_encoding(channel) )) != S_OK) goto done;
940 hr = send_byte( channel->u.tcp.socket, FRAME_RECORD_TYPE_PREAMBLE_END );
941
942 done:
943 heap_free( url );
944 return hr;
945 }
946
947 static HRESULT receive_bytes( struct channel *channel, unsigned char *bytes, int len )
948 {
949 int count = recv( channel->u.tcp.socket, (char *)bytes, len, 0 );
950 if (count < 0) return HRESULT_FROM_WIN32( WSAGetLastError() );
951 if (count != len) return WS_E_INVALID_FORMAT;
952 return S_OK;
953 }
954
955 static HRESULT receive_preamble_ack( struct channel *channel )
956 {
957 unsigned char byte;
958 HRESULT hr;
959
960 if ((hr = receive_bytes( channel, &byte, 1 )) != S_OK) return hr;
961 if (byte != FRAME_RECORD_TYPE_PREAMBLE_ACK) return WS_E_INVALID_FORMAT;
962 channel->session_state = SESSION_STATE_SETUP_COMPLETE;
963 return S_OK;
964 }
965
966 static HRESULT send_sized_envelope( struct channel *channel, BYTE *data, ULONG len )
967 {
968 ULONG table_size = string_table_size( &channel->dict.dict );
969 HRESULT hr;
970
971 if ((hr = send_byte( channel->u.tcp.socket, FRAME_RECORD_TYPE_SIZED_ENVELOPE )) != S_OK) return hr;
972 if ((hr = send_size( channel->u.tcp.socket, size_length(table_size) + table_size + len )) != S_OK) return hr;
973 if ((hr = send_size( channel->u.tcp.socket, table_size )) != S_OK) return hr;
974 if ((hr = send_string_table( channel->u.tcp.socket, &channel->dict.dict )) != S_OK) return hr;
975 return send_bytes( channel->u.tcp.socket, data, len );
976 }
977
978 static HRESULT open_http_request( struct channel *channel, HINTERNET *req )
979 {
980 static const WCHAR postW[] = {'P','O','S','T',0};
981 if ((*req = WinHttpOpenRequest( channel->u.http.connect, postW, channel->u.http.path,
982 NULL, NULL, NULL, channel->u.http.flags ))) return S_OK;
983 return HRESULT_FROM_WIN32( GetLastError() );
984 }
985
986 static HRESULT send_message( struct channel *channel, WS_MESSAGE *msg )
987 {
988 WS_XML_WRITER *writer;
989 WS_BYTES buf;
990 HRESULT hr;
991
992 channel->msg = msg;
993 if ((hr = connect_channel( channel )) != S_OK) return hr;
994
995 WsGetMessageProperty( channel->msg, WS_MESSAGE_PROPERTY_BODY_WRITER, &writer, sizeof(writer), NULL );
996 WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &buf, sizeof(buf), NULL );
997
998 switch (channel->binding)
999 {
1000 case WS_HTTP_CHANNEL_BINDING:
1001 if (channel->u.http.request)
1002 {
1003 WinHttpCloseHandle( channel->u.http.request );
1004 channel->u.http.request = NULL;
1005 }
1006 if ((hr = open_http_request( channel, &channel->u.http.request )) != S_OK) return hr;
1007 if ((hr = message_insert_http_headers( msg, channel->u.http.request )) != S_OK) return hr;
1008 return send_message_http( channel->u.http.request, buf.bytes, buf.length );
1009
1010 case WS_TCP_CHANNEL_BINDING:
1011 if (channel->encoding == WS_ENCODING_XML_BINARY_SESSION_1)
1012 {
1013 switch (channel->session_state)
1014 {
1015 case SESSION_STATE_UNINITIALIZED:
1016 if ((hr = send_preamble( channel )) != S_OK) return hr;
1017 if ((hr = receive_preamble_ack( channel )) != S_OK) return hr;
1018 /* fall through */
1019
1020 case SESSION_STATE_SETUP_COMPLETE:
1021 return send_sized_envelope( channel, buf.bytes, buf.length );
1022
1023 default:
1024 ERR( "unhandled session state %u\n", channel->session_state );
1025 return WS_E_OTHER;
1026 }
1027 }
1028 return send_bytes( channel->u.tcp.socket, buf.bytes, buf.length );
1029
1030 case WS_UDP_CHANNEL_BINDING:
1031 return send_bytes( channel->u.udp.socket, buf.bytes, buf.length );
1032
1033 default:
1034 ERR( "unhandled binding %u\n", channel->binding );
1035 return E_NOTIMPL;
1036 }
1037 }
1038
1039 HRESULT channel_send_message( WS_CHANNEL *handle, WS_MESSAGE *msg )
1040 {
1041 struct channel *channel = (struct channel *)handle;
1042 HRESULT hr;
1043
1044 EnterCriticalSection( &channel->cs );
1045
1046 if (channel->magic != CHANNEL_MAGIC)
1047 {
1048 LeaveCriticalSection( &channel->cs );
1049 return E_INVALIDARG;
1050 }
1051
1052 hr = send_message( channel, msg );
1053
1054 LeaveCriticalSection( &channel->cs );
1055 return hr;
1056 }
1057
1058 static HRESULT CALLBACK dict_cb( void *state, const WS_XML_STRING *str, BOOL *found, ULONG *id, WS_ERROR *error )
1059 {
1060 struct dictionary *dict = state;
1061 HRESULT hr = S_OK;
1062 int index;
1063
1064 if ((index = find_string( dict, str->bytes, str->length, id )) == -1 ||
1065 (hr = insert_string( dict, str->bytes, str->length, index, id )) == S_OK)
1066 {
1067 *found = TRUE;
1068 return S_OK;
1069 }
1070 *found = FALSE;
1071 return hr;
1072 }
1073
1074 static HRESULT init_writer( struct channel *channel )
1075 {
1076 WS_XML_WRITER_BUFFER_OUTPUT buf = {{WS_XML_WRITER_OUTPUT_TYPE_BUFFER}};
1077 WS_XML_WRITER_TEXT_ENCODING text = {{WS_XML_WRITER_ENCODING_TYPE_TEXT}};
1078 WS_XML_WRITER_BINARY_ENCODING bin = {{WS_XML_WRITER_ENCODING_TYPE_BINARY}};
1079 WS_XML_WRITER_ENCODING *encoding;
1080 HRESULT hr;
1081
1082 if (!channel->writer && (hr = WsCreateWriter( NULL, 0, &channel->writer, NULL )) != S_OK) return hr;
1083
1084 switch (channel->encoding)
1085 {
1086 case WS_ENCODING_XML_UTF8:
1087 text.charSet = WS_CHARSET_UTF8;
1088 encoding = &text.encoding;
1089 break;
1090
1091 case WS_ENCODING_XML_BINARY_SESSION_1:
1092 if ((hr = writer_enable_lookup( channel->writer )) != S_OK) return hr;
1093 clear_dict( &channel->dict );
1094 bin.staticDictionary = (WS_XML_DICTIONARY *)&dict_builtin_static.dict;
1095 bin.dynamicStringCallback = dict_cb;
1096 bin.dynamicStringCallbackState = &channel->dict;
1097 encoding = &bin.encoding;
1098 break;
1099
1100 case WS_ENCODING_XML_BINARY_1:
1101 encoding = &bin.encoding;
1102 break;
1103
1104 default:
1105 FIXME( "unhandled encoding %u\n", channel->encoding );
1106 return WS_E_NOT_SUPPORTED;
1107 }
1108
1109 return WsSetOutput( channel->writer, encoding, &buf.output, NULL, 0, NULL );
1110 }
1111
1112 /**************************************************************************
1113 * WsSendMessage [webservices.@]
1114 */
1115 HRESULT WINAPI WsSendMessage( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_MESSAGE_DESCRIPTION *desc,
1116 WS_WRITE_OPTION option, const void *body, ULONG size, const WS_ASYNC_CONTEXT *ctx,
1117 WS_ERROR *error )
1118 {
1119 struct channel *channel = (struct channel *)handle;
1120 HRESULT hr;
1121
1122 TRACE( "%p %p %p %08x %p %u %p %p\n", handle, msg, desc, option, body, size, ctx, error );
1123 if (error) FIXME( "ignoring error parameter\n" );
1124 if (ctx) FIXME( "ignoring ctx parameter\n" );
1125
1126 if (!channel || !msg || !desc) return E_INVALIDARG;
1127
1128 EnterCriticalSection( &channel->cs );
1129
1130 if (channel->magic != CHANNEL_MAGIC)
1131 {
1132 LeaveCriticalSection( &channel->cs );
1133 return E_INVALIDARG;
1134 }
1135
1136 if ((hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL )) != S_OK) goto done;
1137 if ((hr = WsAddressMessage( msg, &channel->addr, NULL )) != S_OK) goto done;
1138 if ((hr = message_set_action( msg, desc->action )) != S_OK) goto done;
1139
1140 if ((hr = init_writer( channel )) != S_OK) goto done;
1141 if ((hr = write_message( msg, channel->writer, desc->bodyElementDescription, option, body, size )) != S_OK)
1142 goto done;
1143 hr = send_message( channel, msg );
1144
1145 done:
1146 LeaveCriticalSection( &channel->cs );
1147 return hr;
1148 }
1149
1150 /**************************************************************************
1151 * WsSendReplyMessage [webservices.@]
1152 */
1153 HRESULT WINAPI WsSendReplyMessage( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_MESSAGE_DESCRIPTION *desc,
1154 WS_WRITE_OPTION option, const void *body, ULONG size, WS_MESSAGE *request,
1155 const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
1156 {
1157 struct channel *channel = (struct channel *)handle;
1158 HRESULT hr;
1159
1160 TRACE( "%p %p %p %08x %p %u %p %p %p\n", handle, msg, desc, option, body, size, request, ctx, error );
1161 if (error) FIXME( "ignoring error parameter\n" );
1162 if (ctx) FIXME( "ignoring ctx parameter\n" );
1163
1164 if (!channel || !msg || !desc || !request) return E_INVALIDARG;
1165
1166 EnterCriticalSection( &channel->cs );
1167
1168 if (channel->magic != CHANNEL_MAGIC)
1169 {
1170 LeaveCriticalSection( &channel->cs );
1171 return E_INVALIDARG;
1172 }
1173
1174 if ((hr = WsInitializeMessage( msg, WS_REPLY_MESSAGE, NULL, NULL )) != S_OK) goto done;
1175 if ((hr = WsAddressMessage( msg, &channel->addr, NULL )) != S_OK) goto done;
1176 if ((hr = message_set_action( msg, desc->action )) != S_OK) goto done;
1177
1178 if ((hr = init_writer( channel )) != S_OK) goto done;
1179 if ((hr = write_message( msg, channel->writer, desc->bodyElementDescription, option, body, size )) != S_OK)
1180 goto done;
1181 hr = send_message( channel, msg );
1182
1183 done:
1184 LeaveCriticalSection( &channel->cs );
1185 FIXME( "returning %08x\n", hr );
1186 return hr;
1187 }
1188
1189 static HRESULT resize_read_buffer( struct channel *channel, ULONG size )
1190 {
1191 if (!channel->read_buf)
1192 {
1193 if (!(channel->read_buf = heap_alloc( size ))) return E_OUTOFMEMORY;
1194 channel->read_buflen = size;
1195 return S_OK;
1196 }
1197 if (channel->read_buflen < size)
1198 {
1199 char *tmp;
1200 ULONG new_size = max( size, channel->read_buflen * 2 );
1201 if (!(tmp = heap_realloc( channel->read_buf, new_size ))) return E_OUTOFMEMORY;
1202 channel->read_buf = tmp;
1203 channel->read_buflen = new_size;
1204 }
1205 return S_OK;
1206 }
1207
1208 static HRESULT init_reader( struct channel *channel )
1209 {
1210 WS_XML_READER_BUFFER_INPUT buf = {{WS_XML_READER_INPUT_TYPE_BUFFER}};
1211 WS_XML_READER_TEXT_ENCODING text = {{WS_XML_READER_ENCODING_TYPE_TEXT}};
1212 WS_XML_READER_BINARY_ENCODING bin = {{WS_XML_READER_ENCODING_TYPE_BINARY}};
1213 WS_XML_READER_ENCODING *encoding;
1214 HRESULT hr;
1215
1216 if (!channel->reader && (hr = WsCreateReader( NULL, 0, &channel->reader, NULL )) != S_OK) return hr;
1217
1218 switch (channel->encoding)
1219 {
1220 case WS_ENCODING_XML_UTF8:
1221 text.charSet = WS_CHARSET_UTF8;
1222 encoding = &text.encoding;
1223 break;
1224
1225 case WS_ENCODING_XML_BINARY_SESSION_1:
1226 bin.staticDictionary = (WS_XML_DICTIONARY *)&dict_builtin_static.dict;
1227 bin.dynamicDictionary = &channel->dict.dict;
1228 /* fall through */
1229
1230 case WS_ENCODING_XML_BINARY_1:
1231 encoding = &bin.encoding;
1232 break;
1233
1234 default:
1235 FIXME( "unhandled encoding %u\n", channel->encoding );
1236 return WS_E_NOT_SUPPORTED;
1237 }
1238
1239 buf.encodedData = channel->read_buf;
1240 buf.encodedDataSize = channel->read_size;
1241 return WsSetInput( channel->reader, encoding, &buf.input, NULL, 0, NULL );
1242 }
1243
1244 #define INITIAL_READ_BUFFER_SIZE 4096
1245 static HRESULT receive_message_http( struct channel *channel )
1246 {
1247 DWORD len, bytes_read, offset = 0, size = INITIAL_READ_BUFFER_SIZE;
1248 ULONG max_len;
1249 HRESULT hr;
1250
1251 prop_get( channel->prop, channel->prop_count, WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE,
1252 &max_len, sizeof(max_len) );
1253
1254 if ((hr = resize_read_buffer( channel, size )) != S_OK) return hr;
1255 channel->read_size = 0;
1256 for (;;)
1257 {
1258 if (!WinHttpQueryDataAvailable( channel->u.http.request, &len ))
1259 {
1260 return HRESULT_FROM_WIN32( GetLastError() );
1261 }
1262 if (!len) break;
1263 if (channel->read_size + len > max_len) return WS_E_QUOTA_EXCEEDED;
1264 if ((hr = resize_read_buffer( channel, channel->read_size + len )) != S_OK) return hr;
1265
1266 if (!WinHttpReadData( channel->u.http.request, channel->read_buf + offset, len, &bytes_read ))
1267 {
1268 return HRESULT_FROM_WIN32( GetLastError() );
1269 }
1270 if (!bytes_read) break;
1271 channel->read_size += bytes_read;
1272 offset += bytes_read;
1273 }
1274
1275 return init_reader( channel );
1276 }
1277
1278 static HRESULT receive_message_unsized( struct channel *channel, SOCKET socket )
1279 {
1280 int bytes_read;
1281 ULONG max_len;
1282 HRESULT hr;
1283
1284 prop_get( channel->prop, channel->prop_count, WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE,
1285 &max_len, sizeof(max_len) );
1286
1287 if ((hr = resize_read_buffer( channel, max_len )) != S_OK) return hr;
1288
1289 channel->read_size = 0;
1290 if ((bytes_read = recv( socket, channel->read_buf, max_len, 0 )) < 0)
1291 {
1292 return HRESULT_FROM_WIN32( WSAGetLastError() );
1293 }
1294 channel->read_size = bytes_read;
1295 return S_OK;
1296 }
1297
1298 static HRESULT receive_message_sized( struct channel *channel, unsigned int size )
1299 {
1300 unsigned int offset = 0, to_read = size;
1301 int bytes_read;
1302 HRESULT hr;
1303
1304 if ((hr = resize_read_buffer( channel, size )) != S_OK) return hr;
1305
1306 channel->read_size = 0;
1307 while (channel->read_size < size)
1308 {
1309 if ((bytes_read = recv( channel->u.tcp.socket, channel->read_buf + offset, to_read, 0 )) < 0)
1310 {
1311 return HRESULT_FROM_WIN32( WSAGetLastError() );
1312 }
1313 if (!bytes_read) break;
1314 channel->read_size += bytes_read;
1315 to_read -= bytes_read;
1316 offset += bytes_read;
1317 }
1318 if (channel->read_size != size) return WS_E_INVALID_FORMAT;
1319 return S_OK;
1320 }
1321
1322 static HRESULT receive_size( struct channel *channel, unsigned int *size )
1323 {
1324 unsigned char byte;
1325 HRESULT hr;
1326
1327 if ((hr = receive_bytes( channel, &byte, 1 )) != S_OK) return hr;
1328 *size = byte & 0x7f;
1329 if (!(byte & 0x80)) return S_OK;
1330
1331 if ((hr = receive_bytes( channel, &byte, 1 )) != S_OK) return hr;
1332 *size += (byte & 0x7f) << 7;
1333 if (!(byte & 0x80)) return S_OK;
1334
1335 if ((hr = receive_bytes( channel, &byte, 1 )) != S_OK) return hr;
1336 *size += (byte & 0x7f) << 14;
1337 if (!(byte & 0x80)) return S_OK;
1338
1339 if ((hr = receive_bytes( channel, &byte, 1 )) != S_OK) return hr;
1340 *size += (byte & 0x7f) << 21;
1341 if (!(byte & 0x80)) return S_OK;
1342
1343 if ((hr = receive_bytes( channel, &byte, 1 )) != S_OK) return hr;
1344 if (byte & ~0x0f) return WS_E_INVALID_FORMAT;
1345 *size += byte << 28;
1346 return S_OK;
1347 }
1348
1349 static WS_ENCODING map_known_encoding( enum known_encoding encoding )
1350 {
1351 switch (encoding)
1352 {
1353 case KNOWN_ENCODING_SOAP11_UTF8:
1354 case KNOWN_ENCODING_SOAP12_UTF8: return WS_ENCODING_XML_UTF8;
1355 case KNOWN_ENCODING_SOAP11_UTF16:
1356 case KNOWN_ENCODING_SOAP12_UTF16: return WS_ENCODING_XML_UTF16BE;
1357 case KNOWN_ENCODING_SOAP11_UTF16LE:
1358 case KNOWN_ENCODING_SOAP12_UTF16LE: return WS_ENCODING_XML_UTF16LE;
1359 case KNOWN_ENCODING_SOAP12_BINARY: return WS_ENCODING_XML_BINARY_1;
1360 case KNOWN_ENCODING_SOAP12_BINARY_SESSION: return WS_ENCODING_XML_BINARY_SESSION_1;
1361 default:
1362 WARN( "unhandled encoding %u, assuming UTF8\n", encoding );
1363 return WS_ENCODING_XML_UTF8;
1364 }
1365 }
1366
1367 static HRESULT receive_preamble( struct channel *channel )
1368 {
1369 unsigned char type;
1370 HRESULT hr;
1371
1372 for (;;)
1373 {
1374 if ((hr = receive_bytes( channel, &type, 1 )) != S_OK) return hr;
1375 if (type == FRAME_RECORD_TYPE_PREAMBLE_END) break;
1376 switch (type)
1377 {
1378 case FRAME_RECORD_TYPE_VERSION:
1379 {
1380 unsigned char major, minor;
1381 if ((hr = receive_bytes( channel, &major, 1 )) != S_OK) return hr;
1382 if ((hr = receive_bytes( channel, &minor, 1 )) != S_OK) return hr;
1383 TRACE( "major %u minor %u\n", major, major );
1384 break;
1385 }
1386 case FRAME_RECORD_TYPE_MODE:
1387 {
1388 unsigned char mode;
1389 if ((hr = receive_bytes( channel, &mode, 1 )) != S_OK) return hr;
1390 TRACE( "mode %u\n", mode );
1391 break;
1392 }
1393 case FRAME_RECORD_TYPE_VIA:
1394 {
1395 unsigned int size;
1396 unsigned char *url;
1397
1398 if ((hr = receive_size( channel, &size )) != S_OK) return hr;
1399 if (!(url = heap_alloc( size ))) return E_OUTOFMEMORY;
1400 if ((hr = receive_bytes( channel, url, size )) != S_OK)
1401 {
1402 heap_free( url );
1403 return hr;
1404 }
1405 TRACE( "transport URL %s\n", debugstr_an((char *)url, size) );
1406 heap_free( url ); /* FIXME: verify */
1407 break;
1408 }
1409 case FRAME_RECORD_TYPE_KNOWN_ENCODING:
1410 {
1411 unsigned char encoding;
1412 if ((hr = receive_bytes( channel, &encoding, 1 )) != S_OK) return hr;
1413 TRACE( "encoding %u\n", encoding );
1414 channel->encoding = map_known_encoding( encoding );
1415 break;
1416 }
1417 default:
1418 WARN( "unhandled record type %u\n", type );
1419 return WS_E_INVALID_FORMAT;
1420 }
1421 }
1422
1423 return S_OK;
1424 }
1425
1426 static HRESULT receive_sized_envelope( struct channel *channel )
1427 {
1428 unsigned char type;
1429 unsigned int size;
1430 HRESULT hr;
1431
1432 if ((hr = receive_bytes( channel, &type, 1 )) != S_OK) return hr;
1433 if (type != FRAME_RECORD_TYPE_SIZED_ENVELOPE) return WS_E_INVALID_FORMAT;
1434 if ((hr = receive_size( channel, &size )) != S_OK) return hr;
1435 if ((hr = receive_message_sized( channel, size )) != S_OK) return hr;
1436 return S_OK;
1437 }
1438
1439 static HRESULT read_size( const BYTE **ptr, ULONG len, ULONG *size )
1440 {
1441 const BYTE *buf = *ptr;
1442
1443 if (len < 1) return WS_E_INVALID_FORMAT;
1444 *size = buf[0] & 0x7f;
1445 if (!(buf[0] & 0x80))
1446 {
1447 *ptr += 1;
1448 return S_OK;
1449 }
1450 if (len < 2) return WS_E_INVALID_FORMAT;
1451 *size += (buf[1] & 0x7f) << 7;
1452 if (!(buf[1] & 0x80))
1453 {
1454 *ptr += 2;
1455 return S_OK;
1456 }
1457 if (len < 3) return WS_E_INVALID_FORMAT;
1458 *size += (buf[2] & 0x7f) << 14;
1459 if (!(buf[2] & 0x80))
1460 {
1461 *ptr += 3;
1462 return S_OK;
1463 }
1464 if (len < 4) return WS_E_INVALID_FORMAT;
1465 *size += (buf[3] & 0x7f) << 21;
1466 if (!(buf[3] & 0x80))
1467 {
1468 *ptr += 4;
1469 return S_OK;
1470 }
1471 if (len < 5 || (buf[4] & ~0x07)) return WS_E_INVALID_FORMAT;
1472 *size += buf[4] << 28;
1473 *ptr += 5;
1474 return S_OK;
1475 }
1476
1477 static HRESULT build_dict( const BYTE *buf, ULONG buflen, struct dictionary *dict, ULONG *used )
1478 {
1479 ULONG size, strings_size, strings_offset;
1480 const BYTE *ptr = buf;
1481 BYTE *bytes;
1482 int index;
1483 HRESULT hr;
1484
1485 if ((hr = read_size( &ptr, buflen, &strings_size )) != S_OK) return hr;
1486 strings_offset = ptr - buf;
1487 if (buflen < strings_offset + strings_size) return WS_E_INVALID_FORMAT;
1488 *used = strings_offset + strings_size;
1489 if (!strings_size) return S_OK;
1490
1491 UuidCreate( &dict->dict.guid );
1492 dict->dict.isConst = FALSE;
1493
1494 buflen -= strings_offset;
1495 ptr = buf + strings_offset;
1496 while (ptr < buf + strings_size)
1497 {
1498 if ((hr = read_size( &ptr, buflen, &size )) != S_OK)
1499 {
1500 clear_dict( dict );
1501 return hr;
1502 }
1503 if (size > buflen)
1504 {
1505 clear_dict( dict );
1506 return WS_E_INVALID_FORMAT;
1507 }
1508 buflen -= size;
1509 if (!(bytes = heap_alloc( size )))
1510 {
1511 hr = E_OUTOFMEMORY;
1512 goto error;
1513 }
1514 memcpy( bytes, ptr, size );
1515 if ((index = find_string( dict, bytes, size, NULL )) == -1) /* duplicate */
1516 {
1517 heap_free( bytes );
1518 ptr += size;
1519 continue;
1520 }
1521 if ((hr = insert_string( dict, bytes, size, index, NULL )) != S_OK)
1522 {
1523 clear_dict( dict );
1524 return hr;
1525 }
1526 ptr += size;
1527 }
1528 return S_OK;
1529
1530 error:
1531 clear_dict( dict );
1532 return hr;
1533 }
1534
1535 static HRESULT send_preamble_ack( struct channel *channel )
1536 {
1537 HRESULT hr;
1538 if ((hr = send_byte( channel->u.tcp.socket, FRAME_RECORD_TYPE_PREAMBLE_ACK )) != S_OK) return hr;
1539 channel->session_state = SESSION_STATE_SETUP_COMPLETE;
1540 return S_OK;
1541 }
1542
1543 static HRESULT receive_message_session_setup( struct channel *channel )
1544 {
1545 HRESULT hr;
1546
1547 if ((hr = receive_preamble( channel )) != S_OK) return hr;
1548 if ((hr = send_preamble_ack( channel )) != S_OK) return hr;
1549 if ((hr = receive_sized_envelope( channel )) != S_OK) return hr;
1550 if (channel->encoding == WS_ENCODING_XML_BINARY_SESSION_1)
1551 {
1552 ULONG size;
1553 if ((hr = build_dict( (const BYTE *)channel->read_buf, channel->read_size, &channel->dict, &size )) != S_OK)
1554 return hr;
1555 channel->read_size -= size;
1556 memmove( channel->read_buf, channel->read_buf + size, channel->read_size );
1557 }
1558
1559 return init_reader( channel );
1560 }
1561
1562 static HRESULT receive_message_session( struct channel *channel )
1563 {
1564 HRESULT hr;
1565 if ((hr = receive_sized_envelope( channel )) != S_OK) return hr;
1566 return init_reader( channel );
1567 }
1568
1569 static HRESULT receive_message_sock( struct channel *channel, SOCKET socket )
1570 {
1571 HRESULT hr;
1572 if ((hr = receive_message_unsized( channel, socket )) != S_OK) return hr;
1573 return init_reader( channel );
1574 }
1575
1576 static HRESULT receive_message( struct channel *channel )
1577 {
1578 HRESULT hr;
1579 if ((hr = connect_channel( channel )) != S_OK) return hr;
1580
1581 switch (channel->binding)
1582 {
1583 case WS_HTTP_CHANNEL_BINDING:
1584 return receive_message_http( channel );
1585
1586 case WS_TCP_CHANNEL_BINDING:
1587 if (channel->encoding == WS_ENCODING_XML_BINARY_SESSION_1)
1588 {
1589 switch (channel->session_state)
1590 {
1591 case SESSION_STATE_UNINITIALIZED:
1592 return receive_message_session_setup( channel );
1593
1594 case SESSION_STATE_SETUP_COMPLETE:
1595 return receive_message_session( channel );
1596
1597 default:
1598 ERR( "unhandled session state %u\n", channel->session_state );
1599 return WS_E_OTHER;
1600 }
1601 }
1602 return receive_message_sock( channel, channel->u.tcp.socket );
1603
1604 case WS_UDP_CHANNEL_BINDING:
1605 return receive_message_sock( channel, channel->u.udp.socket );
1606
1607 default:
1608 ERR( "unhandled binding %u\n", channel->binding );
1609 return E_NOTIMPL;
1610 }
1611 }
1612
1613 HRESULT channel_receive_message( WS_CHANNEL *handle )
1614 {
1615 struct channel *channel = (struct channel *)handle;
1616 HRESULT hr;
1617
1618 EnterCriticalSection( &channel->cs );
1619
1620 if (channel->magic != CHANNEL_MAGIC)
1621 {
1622 LeaveCriticalSection( &channel->cs );
1623 return E_INVALIDARG;
1624 }
1625
1626 hr = receive_message( channel );
1627
1628 LeaveCriticalSection( &channel->cs );
1629 return hr;
1630 }
1631
1632 HRESULT channel_get_reader( WS_CHANNEL *handle, WS_XML_READER **reader )
1633 {
1634 struct channel *channel = (struct channel *)handle;
1635
1636 EnterCriticalSection( &channel->cs );
1637
1638 if (channel->magic != CHANNEL_MAGIC)
1639 {
1640 LeaveCriticalSection( &channel->cs );
1641 return E_INVALIDARG;
1642 }
1643
1644 *reader = channel->reader;
1645
1646 LeaveCriticalSection( &channel->cs );
1647 return S_OK;
1648 }
1649
1650 static HRESULT read_message( WS_MESSAGE *handle, WS_XML_READER *reader, const WS_ELEMENT_DESCRIPTION *desc,
1651 WS_READ_OPTION option, WS_HEAP *heap, void *body, ULONG size )
1652 {
1653 HRESULT hr;
1654 if ((hr = WsReadEnvelopeStart( handle, reader, NULL, NULL, NULL )) != S_OK) return hr;
1655 if ((hr = WsReadBody( handle, desc, option, heap, body, size, NULL )) != S_OK) return hr;
1656 return WsReadEnvelopeEnd( handle, NULL );
1657 }
1658
1659 /**************************************************************************
1660 * WsReceiveMessage [webservices.@]
1661 */
1662 HRESULT WINAPI WsReceiveMessage( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_MESSAGE_DESCRIPTION **desc,
1663 ULONG count, WS_RECEIVE_OPTION option, WS_READ_OPTION read_option, WS_HEAP *heap,
1664 void *value, ULONG size, ULONG *index, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
1665 {
1666 struct channel *channel = (struct channel *)handle;
1667 HRESULT hr;
1668
1669 TRACE( "%p %p %p %u %08x %08x %p %p %u %p %p %p\n", handle, msg, desc, count, option, read_option, heap,
1670 value, size, index, ctx, error );
1671 if (error) FIXME( "ignoring error parameter\n" );
1672 if (ctx) FIXME( "ignoring ctx parameter\n" );
1673 if (index)
1674 {
1675 FIXME( "index parameter not supported\n" );
1676 return E_NOTIMPL;
1677 }
1678 if (count != 1)
1679 {
1680 FIXME( "no support for multiple descriptions\n" );
1681 return E_NOTIMPL;
1682 }
1683 if (option != WS_RECEIVE_REQUIRED_MESSAGE)
1684 {
1685 FIXME( "receive option %08x not supported\n", option );
1686 return E_NOTIMPL;
1687 }
1688
1689 if (!channel || !msg || !desc || !count) return E_INVALIDARG;
1690
1691 EnterCriticalSection( &channel->cs );
1692
1693 if (channel->magic != CHANNEL_MAGIC)
1694 {
1695 LeaveCriticalSection( &channel->cs );
1696 return E_INVALIDARG;
1697 }
1698
1699 if ((hr = receive_message( channel )) != S_OK) goto done;
1700 hr = read_message( msg, channel->reader, desc[0]->bodyElementDescription, read_option, heap, value, size );
1701
1702 done:
1703 LeaveCriticalSection( &channel->cs );
1704 return hr;
1705 }
1706
1707 /**************************************************************************
1708 * WsReadMessageStart [webservices.@]
1709 */
1710 HRESULT WINAPI WsReadMessageStart( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx,
1711 WS_ERROR *error )
1712 {
1713 struct channel *channel = (struct channel *)handle;
1714 HRESULT hr;
1715
1716 TRACE( "%p %p %p %p\n", handle, msg, ctx, error );
1717 if (error) FIXME( "ignoring error parameter\n" );
1718 if (ctx) FIXME( "ignoring ctx parameter\n" );
1719
1720 if (!channel || !msg) return E_INVALIDARG;
1721
1722 EnterCriticalSection( &channel->cs );
1723
1724 if (channel->magic != CHANNEL_MAGIC)
1725 {
1726 LeaveCriticalSection( &channel->cs );
1727 return E_INVALIDARG;
1728 }
1729
1730 if ((hr = receive_message( channel )) == S_OK)
1731 {
1732 hr = WsReadEnvelopeStart( msg, channel->reader, NULL, NULL, NULL );
1733 }
1734
1735 LeaveCriticalSection( &channel->cs );
1736 return hr;
1737 }
1738
1739 /**************************************************************************
1740 * WsReadMessageEnd [webservices.@]
1741 */
1742 HRESULT WINAPI WsReadMessageEnd( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx,
1743 WS_ERROR *error )
1744 {
1745 struct channel *channel = (struct channel *)handle;
1746 HRESULT hr;
1747
1748 TRACE( "%p %p %p %p\n", handle, msg, ctx, error );
1749 if (error) FIXME( "ignoring error parameter\n" );
1750 if (ctx) FIXME( "ignoring ctx parameter\n" );
1751
1752 if (!channel || !msg) return E_INVALIDARG;
1753
1754 EnterCriticalSection( &channel->cs );
1755
1756 if (channel->magic != CHANNEL_MAGIC)
1757 {
1758 LeaveCriticalSection( &channel->cs );
1759 return E_INVALIDARG;
1760 }
1761
1762 hr = WsReadEnvelopeEnd( msg, NULL );
1763
1764 LeaveCriticalSection( &channel->cs );
1765 return hr;
1766 }
1767
1768 /**************************************************************************
1769 * WsWriteMessageStart [webservices.@]
1770 */
1771 HRESULT WINAPI WsWriteMessageStart( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx,
1772 WS_ERROR *error )
1773 {
1774 struct channel *channel = (struct channel *)handle;
1775 HRESULT hr;
1776
1777 TRACE( "%p %p %p %p\n", handle, msg, ctx, error );
1778 if (error) FIXME( "ignoring error parameter\n" );
1779 if (ctx) FIXME( "ignoring ctx parameter\n" );
1780
1781 if (!channel || !msg) return E_INVALIDARG;
1782
1783 EnterCriticalSection( &channel->cs );
1784
1785 if (channel->magic != CHANNEL_MAGIC)
1786 {
1787 LeaveCriticalSection( &channel->cs );
1788 return E_INVALIDARG;
1789 }
1790
1791 if ((hr = init_writer( channel )) != S_OK) goto done;
1792 if ((hr = WsAddressMessage( msg, &channel->addr, NULL )) != S_OK) goto done;
1793 hr = WsWriteEnvelopeStart( msg, channel->writer, NULL, NULL, NULL );
1794
1795 done:
1796 LeaveCriticalSection( &channel->cs );
1797 return hr;
1798 }
1799
1800 /**************************************************************************
1801 * WsWriteMessageEnd [webservices.@]
1802 */
1803 HRESULT WINAPI WsWriteMessageEnd( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx,
1804 WS_ERROR *error )
1805 {
1806 struct channel *channel = (struct channel *)handle;
1807 HRESULT hr;
1808
1809 TRACE( "%p %p %p %p\n", handle, msg, ctx, error );
1810 if (error) FIXME( "ignoring error parameter\n" );
1811 if (ctx) FIXME( "ignoring ctx parameter\n" );
1812
1813 if (!channel || !msg) return E_INVALIDARG;
1814
1815 EnterCriticalSection( &channel->cs );
1816
1817 if (channel->magic != CHANNEL_MAGIC)
1818 {
1819 LeaveCriticalSection( &channel->cs );
1820 return E_INVALIDARG;
1821 }
1822
1823 if ((hr = WsWriteEnvelopeEnd( msg, NULL )) == S_OK) hr = send_message( channel, msg );
1824
1825 LeaveCriticalSection( &channel->cs );
1826 return hr;
1827 }
1828
1829 static HRESULT sock_accept( SOCKET socket, HANDLE wait, HANDLE cancel, SOCKET *ret )
1830 {
1831 HANDLE handles[] = { wait, cancel };
1832 ULONG nonblocking = 0;
1833 HRESULT hr = S_OK;
1834
1835 if (WSAEventSelect( socket, handles[0], FD_ACCEPT )) return HRESULT_FROM_WIN32( WSAGetLastError() );
1836
1837 switch (WSAWaitForMultipleEvents( 2, handles, FALSE, WSA_INFINITE, FALSE ))
1838 {
1839 case 0:
1840 if ((*ret = accept( socket, NULL, NULL )) != -1)
1841 {
1842 WSAEventSelect( *ret, NULL, 0 );
1843 ioctlsocket( *ret, FIONBIO, &nonblocking );
1844 break;
1845 }
1846 hr = HRESULT_FROM_WIN32( WSAGetLastError() );
1847 break;
1848
1849 case 1:
1850 hr = WS_E_OPERATION_ABORTED;
1851 break;
1852
1853 default:
1854 hr = HRESULT_FROM_WIN32( WSAGetLastError() );
1855 break;
1856 }
1857
1858 return hr;
1859 }
1860
1861 HRESULT channel_accept_tcp( SOCKET socket, HANDLE wait, HANDLE cancel, WS_CHANNEL *handle )
1862 {
1863 struct channel *channel = (struct channel *)handle;
1864 HRESULT hr;
1865
1866 EnterCriticalSection( &channel->cs );
1867
1868 if (channel->magic != CHANNEL_MAGIC)
1869 {
1870 LeaveCriticalSection( &channel->cs );
1871 return E_INVALIDARG;
1872 }
1873
1874 hr = sock_accept( socket, wait, cancel, &channel->u.tcp.socket );
1875
1876 LeaveCriticalSection( &channel->cs );
1877 return hr;
1878 }
1879
1880 static HRESULT sock_wait( SOCKET socket, HANDLE wait, HANDLE cancel )
1881 {
1882 HANDLE handles[] = { wait, cancel };
1883 ULONG nonblocking = 0;
1884 HRESULT hr;
1885
1886 if (WSAEventSelect( socket, handles[0], FD_READ )) return HRESULT_FROM_WIN32( WSAGetLastError() );
1887
1888 switch (WSAWaitForMultipleEvents( 2, handles, FALSE, WSA_INFINITE, FALSE ))
1889 {
1890 case 0:
1891 hr = S_OK;
1892 break;
1893
1894 case 1:
1895 hr = WS_E_OPERATION_ABORTED;
1896 break;
1897
1898 default:
1899 hr = HRESULT_FROM_WIN32( WSAGetLastError() );
1900 break;
1901 }
1902
1903 WSAEventSelect( socket, NULL, 0 );
1904 ioctlsocket( socket, FIONBIO, &nonblocking );
1905 return hr;
1906 }
1907
1908 HRESULT channel_accept_udp( SOCKET socket, HANDLE wait, HANDLE cancel, WS_CHANNEL *handle )
1909 {
1910 struct channel *channel = (struct channel *)handle;
1911 HRESULT hr;
1912
1913 EnterCriticalSection( &channel->cs );
1914
1915 if (channel->magic != CHANNEL_MAGIC)
1916 {
1917 LeaveCriticalSection( &channel->cs );
1918 return E_INVALIDARG;
1919 }
1920
1921 if ((hr = sock_wait( socket, wait, cancel )) == S_OK) channel->u.udp.socket = socket;
1922
1923 LeaveCriticalSection( &channel->cs );
1924 return hr;
1925 }
Windows API implementation