2 * Copyright 2017 Hans Leidekker for CodeWeavers
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.
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.
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
23 #include "webservices.h"
25 #include "wine/debug.h"
26 #include "wine/heap.h"
27 #include "wine/list.h"
28 #include "wine/unicode.h"
29 #include "webservices_private.h"
32 WINE_DEFAULT_DEBUG_CHANNEL(webservices
);
34 HINSTANCE webservices_instance
;
36 static BOOL winsock_loaded
;
38 static BOOL WINAPI
winsock_startup( INIT_ONCE
*once
, void *param
, void **ctx
)
42 if (!(ret
= WSAStartup( MAKEWORD(1,1), &data
))) winsock_loaded
= TRUE
;
43 else ERR( "WSAStartup failed: %d\n", ret
);
47 void winsock_init(void)
49 static INIT_ONCE once
= INIT_ONCE_STATIC_INIT
;
50 InitOnceExecuteOnce( &once
, winsock_startup
, NULL
, NULL
);
53 /******************************************************************
54 * DllMain (webservices.@)
56 BOOL WINAPI
DllMain( HINSTANCE hinst
, DWORD reason
, void *reserved
)
60 case DLL_PROCESS_ATTACH
:
61 webservices_instance
= hinst
;
62 DisableThreadLibraryCalls( hinst
);
65 case DLL_PROCESS_DETACH
:
67 if (winsock_loaded
) WSACleanup();
73 static const struct prop_desc listener_props
[] =
75 { sizeof(ULONG
), FALSE
}, /* WS_LISTENER_PROPERTY_LISTEN_BACKLOG */
76 { sizeof(WS_IP_VERSION
), FALSE
}, /* WS_LISTENER_PROPERTY_IP_VERSION */
77 { sizeof(WS_LISTENER_STATE
), TRUE
}, /* WS_LISTENER_PROPERTY_STATE */
78 { sizeof(WS_CALLBACK_MODEL
), FALSE
}, /* WS_LISTENER_PROPERTY_ASYNC_CALLBACK_MODEL */
79 { sizeof(WS_CHANNEL_TYPE
), TRUE
}, /* WS_LISTENER_PROPERTY_CHANNEL_TYPE */
80 { sizeof(WS_CHANNEL_BINDING
), TRUE
}, /* WS_LISTENER_PROPERTY_CHANNEL_BINDING */
81 { sizeof(ULONG
), FALSE
}, /* WS_LISTENER_PROPERTY_CONNECT_TIMEOUT */
82 { sizeof(BOOL
), FALSE
}, /* WS_LISTENER_PROPERTY_IS_MULTICAST */
83 { 0, FALSE
}, /* WS_LISTENER_PROPERTY_MULTICAST_INTERFACES */
84 { sizeof(BOOL
), FALSE
}, /* WS_LISTENER_PROPERTY_MULTICAST_LOOPBACK */
85 { sizeof(ULONG
), FALSE
}, /* WS_LISTENER_PROPERTY_CLOSE_TIMEOUT */
86 { sizeof(ULONG
), FALSE
}, /* WS_LISTENER_PROPERTY_TO_HEADER_MATCHING_OPTIONS */
87 { sizeof(ULONG
), FALSE
}, /* WS_LISTENER_PROPERTY_TRANSPORT_URL_MATCHING_OPTIONS */
88 { sizeof(WS_CUSTOM_LISTENER_CALLBACKS
), FALSE
}, /* WS_LISTENER_PROPERTY_CUSTOM_LISTENER_CALLBACKS */
89 { 0, FALSE
}, /* WS_LISTENER_PROPERTY_CUSTOM_LISTENER_PARAMETERS */
90 { sizeof(void *), TRUE
}, /* WS_LISTENER_PROPERTY_CUSTOM_LISTENER_INSTANCE */
91 { sizeof(WS_DISALLOWED_USER_AGENT_SUBSTRINGS
), FALSE
} /* WS_LISTENER_PROPERTY_DISALLOWED_USER_AGENT */
99 WS_CHANNEL_BINDING binding
;
100 WS_LISTENER_STATE state
;
116 struct prop prop
[ARRAY_SIZE( listener_props
)];
119 #define LISTENER_MAGIC (('L' << 24) | ('I' << 16) | ('S' << 8) | 'T')
121 static struct listener
*alloc_listener(void)
123 static const ULONG count
= ARRAY_SIZE( listener_props
);
124 struct listener
*ret
;
125 ULONG size
= sizeof(*ret
) + prop_size( listener_props
, count
);
127 if (!(ret
= heap_alloc_zero( size
))) return NULL
;
129 ret
->magic
= LISTENER_MAGIC
;
130 if (!(ret
->wait
= CreateEventW( NULL
, FALSE
, FALSE
, NULL
)))
135 if (!(ret
->cancel
= CreateEventW( NULL
, FALSE
, FALSE
, NULL
)))
137 CloseHandle( ret
->wait
);
141 InitializeCriticalSection( &ret
->cs
);
143 ret
->cs
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": listener.cs");
146 prop_init( listener_props
, count
, ret
->prop
, &ret
[1] );
147 ret
->prop_count
= count
;
151 static void reset_listener( struct listener
*listener
)
153 listener
->state
= WS_LISTENER_STATE_CREATED
;
154 SetEvent( listener
->cancel
);
155 listener
->channel
= NULL
;
157 switch (listener
->binding
)
159 case WS_TCP_CHANNEL_BINDING
:
160 closesocket( listener
->u
.tcp
.socket
);
161 listener
->u
.tcp
.socket
= -1;
164 case WS_UDP_CHANNEL_BINDING
:
165 closesocket( listener
->u
.udp
.socket
);
166 listener
->u
.udp
.socket
= -1;
173 static void free_listener( struct listener
*listener
)
175 reset_listener( listener
);
177 CloseHandle( listener
->wait
);
178 CloseHandle( listener
->cancel
);
181 listener
->cs
.DebugInfo
->Spare
[0] = 0;
183 DeleteCriticalSection( &listener
->cs
);
184 heap_free( listener
);
187 static HRESULT
create_listener( WS_CHANNEL_TYPE type
, WS_CHANNEL_BINDING binding
,
188 const WS_LISTENER_PROPERTY
*properties
, ULONG count
, struct listener
**ret
)
190 struct listener
*listener
;
194 if (!(listener
= alloc_listener())) return E_OUTOFMEMORY
;
196 for (i
= 0; i
< count
; i
++)
198 hr
= prop_set( listener
->prop
, listener
->prop_count
, properties
[i
].id
, properties
[i
].value
,
199 properties
[i
].valueSize
);
202 free_listener( listener
);
207 listener
->type
= type
;
208 listener
->binding
= binding
;
210 switch (listener
->binding
)
212 case WS_TCP_CHANNEL_BINDING
:
213 listener
->u
.tcp
.socket
= -1;
216 case WS_UDP_CHANNEL_BINDING
:
217 listener
->u
.udp
.socket
= -1;
227 /**************************************************************************
228 * WsCreateListener [webservices.@]
230 HRESULT WINAPI
WsCreateListener( WS_CHANNEL_TYPE type
, WS_CHANNEL_BINDING binding
,
231 const WS_LISTENER_PROPERTY
*properties
, ULONG count
,
232 const WS_SECURITY_DESCRIPTION
*desc
, WS_LISTENER
**handle
,
235 struct listener
*listener
;
238 TRACE( "%u %u %p %u %p %p %p\n", type
, binding
, properties
, count
, desc
, handle
, error
);
239 if (error
) FIXME( "ignoring error parameter\n" );
240 if (desc
) FIXME( "ignoring security description\n" );
242 if (!handle
) return E_INVALIDARG
;
244 if (type
!= WS_CHANNEL_TYPE_DUPLEX_SESSION
&& type
!= WS_CHANNEL_TYPE_DUPLEX
)
246 FIXME( "channel type %u not implemented\n", type
);
249 if (binding
!= WS_TCP_CHANNEL_BINDING
&& binding
!= WS_UDP_CHANNEL_BINDING
)
251 FIXME( "channel binding %u not implemented\n", binding
);
255 if ((hr
= create_listener( type
, binding
, properties
, count
, &listener
)) != S_OK
) return hr
;
257 TRACE( "created %p\n", listener
);
258 *handle
= (WS_LISTENER
*)listener
;
262 /**************************************************************************
263 * WsFreeListener [webservices.@]
265 void WINAPI
WsFreeListener( WS_LISTENER
*handle
)
267 struct listener
*listener
= (struct listener
*)handle
;
269 TRACE( "%p\n", handle
);
271 if (!listener
) return;
273 EnterCriticalSection( &listener
->cs
);
275 if (listener
->magic
!= LISTENER_MAGIC
)
277 LeaveCriticalSection( &listener
->cs
);
283 LeaveCriticalSection( &listener
->cs
);
284 free_listener( listener
);
287 HRESULT
resolve_hostname( const WCHAR
*host
, USHORT port
, struct sockaddr
*addr
, int *addr_len
, int flags
)
289 static const WCHAR fmtW
[] = {'%','u',0};
291 ADDRINFOW hints
, *res
, *info
;
292 HRESULT hr
= WS_E_ADDRESS_NOT_AVAILABLE
;
294 memset( &hints
, 0, sizeof(hints
) );
295 hints
.ai_flags
= flags
;
296 hints
.ai_family
= AF_INET
;
299 sprintfW( service
, fmtW
, port
);
300 if (GetAddrInfoW( host
, service
, &hints
, &res
)) return HRESULT_FROM_WIN32( WSAGetLastError() );
303 while (info
&& info
->ai_family
!= AF_INET
) info
= info
->ai_next
;
306 memcpy( addr
, info
->ai_addr
, info
->ai_addrlen
);
307 *addr_len
= info
->ai_addrlen
;
311 FreeAddrInfoW( res
);
315 HRESULT
parse_url( const WS_STRING
*str
, WS_URL_SCHEME_TYPE
*scheme
, WCHAR
**host
, USHORT
*port
)
321 if ((hr
= WsCreateHeap( 1 << 8, 0, NULL
, 0, &heap
, NULL
)) != S_OK
) return hr
;
322 if ((hr
= WsDecodeUrl( str
, 0, heap
, (WS_URL
**)&url
, NULL
)) != S_OK
)
328 if (url
->host
.length
== 1 && (url
->host
.chars
[0] == '+' || url
->host
.chars
[0] == '*')) *host
= NULL
;
331 if (!(*host
= heap_alloc( (url
->host
.length
+ 1) * sizeof(WCHAR
) )))
334 return E_OUTOFMEMORY
;
336 memcpy( *host
, url
->host
.chars
, url
->host
.length
* sizeof(WCHAR
) );
337 (*host
)[url
->host
.length
] = 0;
339 *scheme
= url
->url
.scheme
;
346 static HRESULT
open_listener_tcp( struct listener
*listener
, const WS_STRING
*url
)
348 struct sockaddr_storage storage
;
349 struct sockaddr
*addr
= (struct sockaddr
*)&storage
;
350 int addr_len
, on
= 1;
351 WS_URL_SCHEME_TYPE scheme
;
356 if ((hr
= parse_url( url
, &scheme
, &host
, &port
)) != S_OK
) return hr
;
357 if (scheme
!= WS_URL_NETTCP_SCHEME_TYPE
)
360 return WS_E_INVALID_ENDPOINT_URL
;
365 hr
= resolve_hostname( host
, port
, addr
, &addr_len
, AI_PASSIVE
);
367 if (hr
!= S_OK
) return hr
;
369 if ((listener
->u
.tcp
.socket
= socket( addr
->sa_family
, SOCK_STREAM
, 0 )) == -1)
370 return HRESULT_FROM_WIN32( WSAGetLastError() );
372 if (setsockopt( listener
->u
.tcp
.socket
, SOL_SOCKET
, SO_REUSEADDR
, (char *)&on
, sizeof(on
) ) < 0)
374 closesocket( listener
->u
.tcp
.socket
);
375 listener
->u
.tcp
.socket
= -1;
376 return HRESULT_FROM_WIN32( WSAGetLastError() );
379 if (bind( listener
->u
.tcp
.socket
, addr
, addr_len
) < 0)
381 closesocket( listener
->u
.tcp
.socket
);
382 listener
->u
.tcp
.socket
= -1;
383 return HRESULT_FROM_WIN32( WSAGetLastError() );
386 if (listen( listener
->u
.tcp
.socket
, 0 ) < 0)
388 closesocket( listener
->u
.tcp
.socket
);
389 listener
->u
.tcp
.socket
= -1;
390 return HRESULT_FROM_WIN32( WSAGetLastError() );
393 listener
->state
= WS_LISTENER_STATE_OPEN
;
397 static HRESULT
open_listener_udp( struct listener
*listener
, const WS_STRING
*url
)
399 struct sockaddr_storage storage
;
400 struct sockaddr
*addr
= (struct sockaddr
*)&storage
;
402 WS_URL_SCHEME_TYPE scheme
;
407 if ((hr
= parse_url( url
, &scheme
, &host
, &port
)) != S_OK
) return hr
;
408 if (scheme
!= WS_URL_SOAPUDP_SCHEME_TYPE
)
411 return WS_E_INVALID_ENDPOINT_URL
;
416 hr
= resolve_hostname( host
, port
, addr
, &addr_len
, AI_PASSIVE
);
418 if (hr
!= S_OK
) return hr
;
420 if ((listener
->u
.udp
.socket
= socket( addr
->sa_family
, SOCK_DGRAM
, 0 )) == -1)
421 return HRESULT_FROM_WIN32( WSAGetLastError() );
423 if (bind( listener
->u
.udp
.socket
, addr
, addr_len
) < 0)
425 closesocket( listener
->u
.udp
.socket
);
426 listener
->u
.udp
.socket
= -1;
427 return HRESULT_FROM_WIN32( WSAGetLastError() );
430 listener
->state
= WS_LISTENER_STATE_OPEN
;
434 static HRESULT
open_listener( struct listener
*listener
, const WS_STRING
*url
)
436 switch (listener
->binding
)
438 case WS_TCP_CHANNEL_BINDING
:
439 return open_listener_tcp( listener
, url
);
441 case WS_UDP_CHANNEL_BINDING
:
442 return open_listener_udp( listener
, url
);
445 ERR( "unhandled binding %u\n", listener
->binding
);
450 /**************************************************************************
451 * WsOpenListener [webservices.@]
453 HRESULT WINAPI
WsOpenListener( WS_LISTENER
*handle
, WS_STRING
*url
, const WS_ASYNC_CONTEXT
*ctx
, WS_ERROR
*error
)
455 struct listener
*listener
= (struct listener
*)handle
;
458 TRACE( "%p %s %p %p\n", handle
, url
? debugstr_wn(url
->chars
, url
->length
) : "null", ctx
, error
);
459 if (error
) FIXME( "ignoring error parameter\n" );
460 if (ctx
) FIXME( "ignoring ctx parameter\n" );
462 if (!listener
|| !url
) return E_INVALIDARG
;
464 EnterCriticalSection( &listener
->cs
);
466 if (listener
->magic
!= LISTENER_MAGIC
)
468 LeaveCriticalSection( &listener
->cs
);
472 if (listener
->state
!= WS_LISTENER_STATE_CREATED
) hr
= WS_E_INVALID_OPERATION
;
473 else hr
= open_listener( listener
, url
);
475 LeaveCriticalSection( &listener
->cs
);
476 TRACE( "returning %08x\n", hr
);
480 static void close_listener( struct listener
*listener
)
482 reset_listener( listener
);
483 listener
->state
= WS_LISTENER_STATE_CLOSED
;
486 /**************************************************************************
487 * WsCloseListener [webservices.@]
489 HRESULT WINAPI
WsCloseListener( WS_LISTENER
*handle
, const WS_ASYNC_CONTEXT
*ctx
, WS_ERROR
*error
)
491 struct listener
*listener
= (struct listener
*)handle
;
494 TRACE( "%p %p %p\n", handle
, ctx
, error
);
495 if (error
) FIXME( "ignoring error parameter\n" );
496 if (ctx
) FIXME( "ignoring ctx parameter\n" );
498 if (!listener
) return E_INVALIDARG
;
500 EnterCriticalSection( &listener
->cs
);
502 if (listener
->magic
!= LISTENER_MAGIC
)
504 LeaveCriticalSection( &listener
->cs
);
508 close_listener( listener
);
510 LeaveCriticalSection( &listener
->cs
);
511 TRACE( "returning %08x\n", hr
);
515 /**************************************************************************
516 * WsResetListener [webservices.@]
518 HRESULT WINAPI
WsResetListener( WS_LISTENER
*handle
, WS_ERROR
*error
)
520 struct listener
*listener
= (struct listener
*)handle
;
523 TRACE( "%p %p\n", handle
, error
);
524 if (error
) FIXME( "ignoring error parameter\n" );
526 if (!listener
) return E_INVALIDARG
;
528 EnterCriticalSection( &listener
->cs
);
530 if (listener
->magic
!= LISTENER_MAGIC
)
532 LeaveCriticalSection( &listener
->cs
);
536 if (listener
->state
!= WS_LISTENER_STATE_CREATED
&& listener
->state
!= WS_LISTENER_STATE_CLOSED
)
537 hr
= WS_E_INVALID_OPERATION
;
539 reset_listener( listener
);
541 LeaveCriticalSection( &listener
->cs
);
542 TRACE( "returning %08x\n", hr
);
546 /**************************************************************************
547 * WsGetListenerProperty [webservices.@]
549 HRESULT WINAPI
WsGetListenerProperty( WS_LISTENER
*handle
, WS_LISTENER_PROPERTY_ID id
, void *buf
,
550 ULONG size
, WS_ERROR
*error
)
552 struct listener
*listener
= (struct listener
*)handle
;
555 TRACE( "%p %u %p %u %p\n", handle
, id
, buf
, size
, error
);
556 if (error
) FIXME( "ignoring error parameter\n" );
558 if (!listener
) return E_INVALIDARG
;
560 EnterCriticalSection( &listener
->cs
);
562 if (listener
->magic
!= LISTENER_MAGIC
)
564 LeaveCriticalSection( &listener
->cs
);
570 case WS_LISTENER_PROPERTY_STATE
:
571 if (!buf
|| size
!= sizeof(listener
->state
)) hr
= E_INVALIDARG
;
572 else *(WS_LISTENER_STATE
*)buf
= listener
->state
;
575 case WS_LISTENER_PROPERTY_CHANNEL_TYPE
:
576 if (!buf
|| size
!= sizeof(listener
->type
)) hr
= E_INVALIDARG
;
577 else *(WS_CHANNEL_TYPE
*)buf
= listener
->type
;
580 case WS_LISTENER_PROPERTY_CHANNEL_BINDING
:
581 if (!buf
|| size
!= sizeof(listener
->binding
)) hr
= E_INVALIDARG
;
582 else *(WS_CHANNEL_BINDING
*)buf
= listener
->binding
;
586 hr
= prop_get( listener
->prop
, listener
->prop_count
, id
, buf
, size
);
589 LeaveCriticalSection( &listener
->cs
);
590 TRACE( "returning %08x\n", hr
);
594 /**************************************************************************
595 * WsSetListenerProperty [webservices.@]
597 HRESULT WINAPI
WsSetListenerProperty( WS_LISTENER
*handle
, WS_LISTENER_PROPERTY_ID id
, const void *value
,
598 ULONG size
, WS_ERROR
*error
)
600 struct listener
*listener
= (struct listener
*)handle
;
603 TRACE( "%p %u %p %u\n", handle
, id
, value
, size
);
604 if (error
) FIXME( "ignoring error parameter\n" );
606 if (!listener
) return E_INVALIDARG
;
608 EnterCriticalSection( &listener
->cs
);
610 if (listener
->magic
!= LISTENER_MAGIC
)
612 LeaveCriticalSection( &listener
->cs
);
616 hr
= prop_set( listener
->prop
, listener
->prop_count
, id
, value
, size
);
618 LeaveCriticalSection( &listener
->cs
);
619 TRACE( "returning %08x\n", hr
);
623 /**************************************************************************
624 * WsAcceptChannel [webservices.@]
626 HRESULT WINAPI
WsAcceptChannel( WS_LISTENER
*handle
, WS_CHANNEL
*channel_handle
, const WS_ASYNC_CONTEXT
*ctx
,
629 struct listener
*listener
= (struct listener
*)handle
;
630 HRESULT hr
= E_NOTIMPL
;
633 TRACE( "%p %p %p %p\n", handle
, channel_handle
, ctx
, error
);
634 if (error
) FIXME( "ignoring error parameter\n" );
635 if (ctx
) FIXME( "ignoring ctx parameter\n" );
637 if (!listener
|| !channel_handle
) return E_INVALIDARG
;
639 EnterCriticalSection( &listener
->cs
);
641 if (listener
->magic
!= LISTENER_MAGIC
)
643 LeaveCriticalSection( &listener
->cs
);
647 if (listener
->state
!= WS_LISTENER_STATE_OPEN
|| listener
->channel
) hr
= WS_E_INVALID_OPERATION
;
650 wait
= listener
->wait
;
651 cancel
= listener
->cancel
;
652 listener
->channel
= channel_handle
;
654 switch (listener
->binding
)
656 case WS_TCP_CHANNEL_BINDING
:
658 SOCKET socket
= listener
->u
.tcp
.socket
;
660 LeaveCriticalSection( &listener
->cs
);
661 hr
= channel_accept_tcp( socket
, wait
, cancel
, channel_handle
);
662 TRACE( "returning %08x\n", hr
);
665 case WS_UDP_CHANNEL_BINDING
:
667 SOCKET socket
= listener
->u
.udp
.socket
;
669 LeaveCriticalSection( &listener
->cs
);
670 hr
= channel_accept_udp( socket
, wait
, cancel
, channel_handle
);
671 TRACE( "returning %08x\n", hr
);
675 FIXME( "listener binding %u not supported\n", listener
->binding
);
680 LeaveCriticalSection( &listener
->cs
);
681 TRACE( "returning %08x\n", hr
);