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 static BOOL winsock_loaded
;
36 static BOOL WINAPI
winsock_startup( INIT_ONCE
*once
, void *param
, void **ctx
)
40 if (!(ret
= WSAStartup( MAKEWORD(1,1), &data
))) winsock_loaded
= TRUE
;
41 else ERR( "WSAStartup failed: %d\n", ret
);
45 void winsock_init(void)
47 static INIT_ONCE once
= INIT_ONCE_STATIC_INIT
;
48 InitOnceExecuteOnce( &once
, winsock_startup
, NULL
, NULL
);
51 static const struct prop_desc listener_props
[] =
53 { sizeof(ULONG
), FALSE
}, /* WS_LISTENER_PROPERTY_LISTEN_BACKLOG */
54 { sizeof(WS_IP_VERSION
), FALSE
}, /* WS_LISTENER_PROPERTY_IP_VERSION */
55 { sizeof(WS_LISTENER_STATE
), TRUE
}, /* WS_LISTENER_PROPERTY_STATE */
56 { sizeof(WS_CALLBACK_MODEL
), FALSE
}, /* WS_LISTENER_PROPERTY_ASYNC_CALLBACK_MODEL */
57 { sizeof(WS_CHANNEL_TYPE
), TRUE
}, /* WS_LISTENER_PROPERTY_CHANNEL_TYPE */
58 { sizeof(WS_CHANNEL_BINDING
), TRUE
}, /* WS_LISTENER_PROPERTY_CHANNEL_BINDING */
59 { sizeof(ULONG
), FALSE
}, /* WS_LISTENER_PROPERTY_CONNECT_TIMEOUT */
60 { sizeof(BOOL
), FALSE
}, /* WS_LISTENER_PROPERTY_IS_MULTICAST */
61 { 0, FALSE
}, /* WS_LISTENER_PROPERTY_MULTICAST_INTERFACES */
62 { sizeof(BOOL
), FALSE
}, /* WS_LISTENER_PROPERTY_MULTICAST_LOOPBACK */
63 { sizeof(ULONG
), FALSE
}, /* WS_LISTENER_PROPERTY_CLOSE_TIMEOUT */
64 { sizeof(ULONG
), FALSE
}, /* WS_LISTENER_PROPERTY_TO_HEADER_MATCHING_OPTIONS */
65 { sizeof(ULONG
), FALSE
}, /* WS_LISTENER_PROPERTY_TRANSPORT_URL_MATCHING_OPTIONS */
66 { sizeof(WS_CUSTOM_LISTENER_CALLBACKS
), FALSE
}, /* WS_LISTENER_PROPERTY_CUSTOM_LISTENER_CALLBACKS */
67 { 0, FALSE
}, /* WS_LISTENER_PROPERTY_CUSTOM_LISTENER_PARAMETERS */
68 { sizeof(void *), TRUE
}, /* WS_LISTENER_PROPERTY_CUSTOM_LISTENER_INSTANCE */
69 { sizeof(WS_DISALLOWED_USER_AGENT_SUBSTRINGS
), FALSE
} /* WS_LISTENER_PROPERTY_DISALLOWED_USER_AGENT */
77 WS_CHANNEL_BINDING binding
;
78 WS_LISTENER_STATE state
;
94 struct prop prop
[sizeof(listener_props
)/sizeof(listener_props
[0])];
97 #define LISTENER_MAGIC (('L' << 24) | ('I' << 16) | ('S' << 8) | 'T')
99 static struct listener
*alloc_listener(void)
101 static const ULONG count
= sizeof(listener_props
)/sizeof(listener_props
[0]);
102 struct listener
*ret
;
103 ULONG size
= sizeof(*ret
) + prop_size( listener_props
, count
);
105 if (!(ret
= heap_alloc_zero( size
))) return NULL
;
107 ret
->magic
= LISTENER_MAGIC
;
108 if (!(ret
->wait
= CreateEventW( NULL
, FALSE
, FALSE
, NULL
)))
113 if (!(ret
->cancel
= CreateEventW( NULL
, FALSE
, FALSE
, NULL
)))
115 CloseHandle( ret
->wait
);
119 InitializeCriticalSection( &ret
->cs
);
120 ret
->cs
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": listener.cs");
122 prop_init( listener_props
, count
, ret
->prop
, &ret
[1] );
123 ret
->prop_count
= count
;
127 static void reset_listener( struct listener
*listener
)
129 listener
->state
= WS_LISTENER_STATE_CREATED
;
130 SetEvent( listener
->cancel
);
131 listener
->channel
= NULL
;
133 switch (listener
->binding
)
135 case WS_TCP_CHANNEL_BINDING
:
136 closesocket( listener
->u
.tcp
.socket
);
137 listener
->u
.tcp
.socket
= -1;
140 case WS_UDP_CHANNEL_BINDING
:
141 closesocket( listener
->u
.udp
.socket
);
142 listener
->u
.udp
.socket
= -1;
149 static void free_listener( struct listener
*listener
)
151 reset_listener( listener
);
153 CloseHandle( listener
->wait
);
154 CloseHandle( listener
->cancel
);
156 listener
->cs
.DebugInfo
->Spare
[0] = 0;
157 DeleteCriticalSection( &listener
->cs
);
158 heap_free( listener
);
161 static HRESULT
create_listener( WS_CHANNEL_TYPE type
, WS_CHANNEL_BINDING binding
,
162 const WS_LISTENER_PROPERTY
*properties
, ULONG count
, struct listener
**ret
)
164 struct listener
*listener
;
168 if (!(listener
= alloc_listener())) return E_OUTOFMEMORY
;
170 for (i
= 0; i
< count
; i
++)
172 hr
= prop_set( listener
->prop
, listener
->prop_count
, properties
[i
].id
, properties
[i
].value
,
173 properties
[i
].valueSize
);
176 free_listener( listener
);
181 listener
->type
= type
;
182 listener
->binding
= binding
;
184 switch (listener
->binding
)
186 case WS_TCP_CHANNEL_BINDING
:
187 listener
->u
.tcp
.socket
= -1;
190 case WS_UDP_CHANNEL_BINDING
:
191 listener
->u
.udp
.socket
= -1;
201 /**************************************************************************
202 * WsCreateListener [webservices.@]
204 HRESULT WINAPI
WsCreateListener( WS_CHANNEL_TYPE type
, WS_CHANNEL_BINDING binding
,
205 const WS_LISTENER_PROPERTY
*properties
, ULONG count
,
206 const WS_SECURITY_DESCRIPTION
*desc
, WS_LISTENER
**handle
,
209 struct listener
*listener
;
212 TRACE( "%u %u %p %u %p %p %p\n", type
, binding
, properties
, count
, desc
, handle
, error
);
213 if (error
) FIXME( "ignoring error parameter\n" );
214 if (desc
) FIXME( "ignoring security description\n" );
216 if (!handle
) return E_INVALIDARG
;
218 if (type
!= WS_CHANNEL_TYPE_DUPLEX_SESSION
&& type
!= WS_CHANNEL_TYPE_DUPLEX
)
220 FIXME( "channel type %u not implemented\n", type
);
223 if (binding
!= WS_TCP_CHANNEL_BINDING
&& binding
!= WS_UDP_CHANNEL_BINDING
)
225 FIXME( "channel binding %u not implemented\n", binding
);
229 if ((hr
= create_listener( type
, binding
, properties
, count
, &listener
)) != S_OK
) return hr
;
231 TRACE( "created %p\n", listener
);
232 *handle
= (WS_LISTENER
*)listener
;
236 /**************************************************************************
237 * WsFreeListener [webservices.@]
239 void WINAPI
WsFreeListener( WS_LISTENER
*handle
)
241 struct listener
*listener
= (struct listener
*)handle
;
243 TRACE( "%p\n", handle
);
245 if (!listener
) return;
247 EnterCriticalSection( &listener
->cs
);
249 if (listener
->magic
!= LISTENER_MAGIC
)
251 LeaveCriticalSection( &listener
->cs
);
257 LeaveCriticalSection( &listener
->cs
);
258 free_listener( listener
);
261 HRESULT
resolve_hostname( const WCHAR
*host
, USHORT port
, struct sockaddr
*addr
, int *addr_len
, int flags
)
263 static const WCHAR fmtW
[] = {'%','u',0};
265 ADDRINFOW hints
, *res
, *info
;
266 HRESULT hr
= WS_E_ADDRESS_NOT_AVAILABLE
;
268 memset( &hints
, 0, sizeof(hints
) );
269 hints
.ai_flags
= flags
;
270 hints
.ai_family
= AF_INET
;
273 sprintfW( service
, fmtW
, port
);
274 if (GetAddrInfoW( host
, service
, &hints
, &res
)) return HRESULT_FROM_WIN32( WSAGetLastError() );
277 while (info
&& info
->ai_family
!= AF_INET
) info
= info
->ai_next
;
280 memcpy( addr
, info
->ai_addr
, info
->ai_addrlen
);
281 *addr_len
= info
->ai_addrlen
;
285 FreeAddrInfoW( res
);
289 HRESULT
parse_url( const WS_STRING
*str
, WS_URL_SCHEME_TYPE
*scheme
, WCHAR
**host
, USHORT
*port
)
295 if ((hr
= WsCreateHeap( 1 << 8, 0, NULL
, 0, &heap
, NULL
)) != S_OK
) return hr
;
296 if ((hr
= WsDecodeUrl( str
, 0, heap
, (WS_URL
**)&url
, NULL
)) != S_OK
)
302 if (url
->host
.length
== 1 && (url
->host
.chars
[0] == '+' || url
->host
.chars
[0] == '*')) *host
= NULL
;
305 if (!(*host
= heap_alloc( (url
->host
.length
+ 1) * sizeof(WCHAR
) )))
308 return E_OUTOFMEMORY
;
310 memcpy( *host
, url
->host
.chars
, url
->host
.length
* sizeof(WCHAR
) );
311 (*host
)[url
->host
.length
] = 0;
313 *scheme
= url
->url
.scheme
;
320 static HRESULT
open_listener_tcp( struct listener
*listener
, const WS_STRING
*url
)
322 struct sockaddr_storage storage
;
323 struct sockaddr
*addr
= (struct sockaddr
*)&storage
;
324 int addr_len
, on
= 1;
325 WS_URL_SCHEME_TYPE scheme
;
330 if ((hr
= parse_url( url
, &scheme
, &host
, &port
)) != S_OK
) return hr
;
331 if (scheme
!= WS_URL_NETTCP_SCHEME_TYPE
)
334 return WS_E_INVALID_ENDPOINT_URL
;
339 hr
= resolve_hostname( host
, port
, addr
, &addr_len
, AI_PASSIVE
);
341 if (hr
!= S_OK
) return hr
;
343 if ((listener
->u
.tcp
.socket
= socket( addr
->sa_family
, SOCK_STREAM
, 0 )) == -1)
344 return HRESULT_FROM_WIN32( WSAGetLastError() );
346 if (setsockopt( listener
->u
.tcp
.socket
, SOL_SOCKET
, SO_REUSEADDR
, (char *)&on
, sizeof(on
) ) < 0)
348 closesocket( listener
->u
.tcp
.socket
);
349 listener
->u
.tcp
.socket
= -1;
350 return HRESULT_FROM_WIN32( WSAGetLastError() );
353 if (bind( listener
->u
.tcp
.socket
, addr
, addr_len
) < 0)
355 closesocket( listener
->u
.tcp
.socket
);
356 listener
->u
.tcp
.socket
= -1;
357 return HRESULT_FROM_WIN32( WSAGetLastError() );
360 if (listen( listener
->u
.tcp
.socket
, 0 ) < 0)
362 closesocket( listener
->u
.tcp
.socket
);
363 listener
->u
.tcp
.socket
= -1;
364 return HRESULT_FROM_WIN32( WSAGetLastError() );
367 listener
->state
= WS_LISTENER_STATE_OPEN
;
371 static HRESULT
open_listener_udp( struct listener
*listener
, const WS_STRING
*url
)
373 struct sockaddr_storage storage
;
374 struct sockaddr
*addr
= (struct sockaddr
*)&storage
;
376 WS_URL_SCHEME_TYPE scheme
;
381 if ((hr
= parse_url( url
, &scheme
, &host
, &port
)) != S_OK
) return hr
;
382 if (scheme
!= WS_URL_SOAPUDP_SCHEME_TYPE
)
385 return WS_E_INVALID_ENDPOINT_URL
;
390 hr
= resolve_hostname( host
, port
, addr
, &addr_len
, AI_PASSIVE
);
392 if (hr
!= S_OK
) return hr
;
394 if ((listener
->u
.udp
.socket
= socket( addr
->sa_family
, SOCK_DGRAM
, 0 )) == -1)
395 return HRESULT_FROM_WIN32( WSAGetLastError() );
397 if (bind( listener
->u
.udp
.socket
, addr
, addr_len
) < 0)
399 closesocket( listener
->u
.udp
.socket
);
400 listener
->u
.udp
.socket
= -1;
401 return HRESULT_FROM_WIN32( WSAGetLastError() );
404 listener
->state
= WS_LISTENER_STATE_OPEN
;
408 static HRESULT
open_listener( struct listener
*listener
, const WS_STRING
*url
)
410 switch (listener
->binding
)
412 case WS_TCP_CHANNEL_BINDING
:
413 return open_listener_tcp( listener
, url
);
415 case WS_UDP_CHANNEL_BINDING
:
416 return open_listener_udp( listener
, url
);
419 ERR( "unhandled binding %u\n", listener
->binding
);
424 /**************************************************************************
425 * WsOpenListener [webservices.@]
427 HRESULT WINAPI
WsOpenListener( WS_LISTENER
*handle
, WS_STRING
*url
, const WS_ASYNC_CONTEXT
*ctx
, WS_ERROR
*error
)
429 struct listener
*listener
= (struct listener
*)handle
;
432 TRACE( "%p %s %p %p\n", handle
, url
? debugstr_wn(url
->chars
, url
->length
) : "null", ctx
, error
);
433 if (error
) FIXME( "ignoring error parameter\n" );
434 if (ctx
) FIXME( "ignoring ctx parameter\n" );
436 if (!listener
|| !url
) return E_INVALIDARG
;
438 EnterCriticalSection( &listener
->cs
);
440 if (listener
->magic
!= LISTENER_MAGIC
)
442 LeaveCriticalSection( &listener
->cs
);
446 if (listener
->state
!= WS_LISTENER_STATE_CREATED
)
448 LeaveCriticalSection( &listener
->cs
);
449 return WS_E_INVALID_OPERATION
;
452 hr
= open_listener( listener
, url
);
454 LeaveCriticalSection( &listener
->cs
);
458 static void close_listener( struct listener
*listener
)
460 reset_listener( listener
);
461 listener
->state
= WS_LISTENER_STATE_CLOSED
;
464 /**************************************************************************
465 * WsCloseListener [webservices.@]
467 HRESULT WINAPI
WsCloseListener( WS_LISTENER
*handle
, const WS_ASYNC_CONTEXT
*ctx
, WS_ERROR
*error
)
469 struct listener
*listener
= (struct listener
*)handle
;
471 TRACE( "%p %p %p\n", handle
, ctx
, error
);
472 if (error
) FIXME( "ignoring error parameter\n" );
473 if (ctx
) FIXME( "ignoring ctx parameter\n" );
475 if (!listener
) return E_INVALIDARG
;
477 EnterCriticalSection( &listener
->cs
);
479 if (listener
->magic
!= LISTENER_MAGIC
)
481 LeaveCriticalSection( &listener
->cs
);
485 close_listener( listener
);
487 LeaveCriticalSection( &listener
->cs
);
491 /**************************************************************************
492 * WsResetListener [webservices.@]
494 HRESULT WINAPI
WsResetListener( WS_LISTENER
*handle
, WS_ERROR
*error
)
496 struct listener
*listener
= (struct listener
*)handle
;
498 TRACE( "%p %p\n", handle
, error
);
499 if (error
) FIXME( "ignoring error parameter\n" );
501 if (!listener
) return E_INVALIDARG
;
503 EnterCriticalSection( &listener
->cs
);
505 if (listener
->magic
!= LISTENER_MAGIC
)
507 LeaveCriticalSection( &listener
->cs
);
511 if (listener
->state
!= WS_LISTENER_STATE_CREATED
&& listener
->state
!= WS_LISTENER_STATE_CLOSED
)
513 LeaveCriticalSection( &listener
->cs
);
514 return WS_E_INVALID_OPERATION
;
517 reset_listener( listener
);
519 LeaveCriticalSection( &listener
->cs
);
523 /**************************************************************************
524 * WsGetListenerProperty [webservices.@]
526 HRESULT WINAPI
WsGetListenerProperty( WS_LISTENER
*handle
, WS_LISTENER_PROPERTY_ID id
, void *buf
,
527 ULONG size
, WS_ERROR
*error
)
529 struct listener
*listener
= (struct listener
*)handle
;
532 TRACE( "%p %u %p %u %p\n", handle
, id
, buf
, size
, error
);
533 if (error
) FIXME( "ignoring error parameter\n" );
535 if (!listener
) return E_INVALIDARG
;
537 EnterCriticalSection( &listener
->cs
);
539 if (listener
->magic
!= LISTENER_MAGIC
)
541 LeaveCriticalSection( &listener
->cs
);
547 case WS_LISTENER_PROPERTY_STATE
:
548 if (!buf
|| size
!= sizeof(listener
->state
)) hr
= E_INVALIDARG
;
549 else *(WS_LISTENER_STATE
*)buf
= listener
->state
;
552 case WS_LISTENER_PROPERTY_CHANNEL_TYPE
:
553 if (!buf
|| size
!= sizeof(listener
->type
)) hr
= E_INVALIDARG
;
554 else *(WS_CHANNEL_TYPE
*)buf
= listener
->type
;
557 case WS_LISTENER_PROPERTY_CHANNEL_BINDING
:
558 if (!buf
|| size
!= sizeof(listener
->binding
)) hr
= E_INVALIDARG
;
559 else *(WS_CHANNEL_BINDING
*)buf
= listener
->binding
;
563 hr
= prop_get( listener
->prop
, listener
->prop_count
, id
, buf
, size
);
566 LeaveCriticalSection( &listener
->cs
);
570 /**************************************************************************
571 * WsSetListenerProperty [webservices.@]
573 HRESULT WINAPI
WsSetListenerProperty( WS_LISTENER
*handle
, WS_LISTENER_PROPERTY_ID id
, const void *value
,
574 ULONG size
, WS_ERROR
*error
)
576 struct listener
*listener
= (struct listener
*)handle
;
579 TRACE( "%p %u %p %u\n", handle
, id
, value
, size
);
580 if (error
) FIXME( "ignoring error parameter\n" );
582 if (!listener
) return E_INVALIDARG
;
584 EnterCriticalSection( &listener
->cs
);
586 if (listener
->magic
!= LISTENER_MAGIC
)
588 LeaveCriticalSection( &listener
->cs
);
592 hr
= prop_set( listener
->prop
, listener
->prop_count
, id
, value
, size
);
594 LeaveCriticalSection( &listener
->cs
);
598 /**************************************************************************
599 * WsAcceptChannel [webservices.@]
601 HRESULT WINAPI
WsAcceptChannel( WS_LISTENER
*handle
, WS_CHANNEL
*channel_handle
, const WS_ASYNC_CONTEXT
*ctx
,
604 struct listener
*listener
= (struct listener
*)handle
;
605 HRESULT hr
= E_NOTIMPL
;
608 TRACE( "%p %p %p %p\n", handle
, channel_handle
, ctx
, error
);
609 if (error
) FIXME( "ignoring error parameter\n" );
610 if (ctx
) FIXME( "ignoring ctx parameter\n" );
612 if (!listener
|| !channel_handle
) return E_INVALIDARG
;
614 EnterCriticalSection( &listener
->cs
);
616 if (listener
->magic
!= LISTENER_MAGIC
)
618 LeaveCriticalSection( &listener
->cs
);
622 if (listener
->state
!= WS_LISTENER_STATE_OPEN
|| listener
->channel
)
624 LeaveCriticalSection( &listener
->cs
);
625 return WS_E_INVALID_OPERATION
;
628 wait
= listener
->wait
;
629 cancel
= listener
->cancel
;
630 listener
->channel
= channel_handle
;
632 switch (listener
->binding
)
634 case WS_TCP_CHANNEL_BINDING
:
636 SOCKET socket
= listener
->u
.tcp
.socket
;
638 LeaveCriticalSection( &listener
->cs
);
639 return channel_accept_tcp( socket
, wait
, cancel
, channel_handle
);
641 case WS_UDP_CHANNEL_BINDING
:
643 SOCKET socket
= listener
->u
.udp
.socket
;
645 LeaveCriticalSection( &listener
->cs
);
646 return channel_accept_udp( socket
, wait
, cancel
, channel_handle
);
649 FIXME( "listener binding %u not supported\n", listener
->binding
);
653 LeaveCriticalSection( &listener
->cs
);