2 * Unit test suite for winsock functions
4 * Copyright 2002 Martin Wilck
5 * Copyright 2005 Thomas Kho
6 * Copyright 2008 Jeff Zaroyko
7 * Copyright 2017 Dmitry Timoshkov
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #define WIN32_NO_STATUS
36 #include "wine/test.h"
38 #define MAX_CLIENTS 4 /* Max number of clients */
39 #define FIRST_CHAR 'A' /* First character in transferred pattern */
40 #define BIND_SLEEP 10 /* seconds to wait between attempts to bind() */
41 #define BIND_TRIES 6 /* Number of bind() attempts */
42 #define TEST_TIMEOUT 30 /* seconds to wait before killing child threads
43 after server initialization, if something hangs */
45 #define NUM_UDP_PEERS 3 /* Number of UDP sockets to create and test > 1 */
47 #define NUM_THREADS 3 /* Number of threads to run getservbyname */
48 #define NUM_QUERIES 250 /* Number of getservbyname queries per thread */
50 #define SERVERIP "127.0.0.1" /* IP to bind to */
51 #define SERVERPORT 9374 /* Port number to bind to */
53 #define wsa_ok(op, cond, msg) \
57 if ( !(cond tmp) ) err = WSAGetLastError(); \
58 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
61 #define make_keepalive(k, enable, time, interval) \
63 k.keepalivetime = time; \
64 k.keepaliveinterval = interval;
66 /* Function pointers */
67 static void (WINAPI
*pfreeaddrinfo
)(struct addrinfo
*);
68 static int (WINAPI
*pgetaddrinfo
)(LPCSTR
,LPCSTR
,const struct addrinfo
*,struct addrinfo
**);
69 static void (WINAPI
*pFreeAddrInfoW
)(PADDRINFOW
);
70 static void (WINAPI
*pFreeAddrInfoExW
)(ADDRINFOEXW
*ai
);
71 static int (WINAPI
*pGetAddrInfoW
)(LPCWSTR
,LPCWSTR
,const ADDRINFOW
*,PADDRINFOW
*);
72 static int (WINAPI
*pGetAddrInfoExW
)(const WCHAR
*name
, const WCHAR
*servname
, DWORD
namespace,
73 GUID
*namespace_id
, const ADDRINFOEXW
*hints
, ADDRINFOEXW
**result
,
74 struct timeval
*timeout
, OVERLAPPED
*overlapped
,
75 LPLOOKUPSERVICE_COMPLETION_ROUTINE completion_routine
, HANDLE
*handle
);
76 static int (WINAPI
*pGetAddrInfoExOverlappedResult
)(OVERLAPPED
*overlapped
);
77 static PCSTR (WINAPI
*pInetNtop
)(INT
,LPVOID
,LPSTR
,ULONG
);
78 static PCWSTR(WINAPI
*pInetNtopW
)(INT
,LPVOID
,LPWSTR
,ULONG
);
79 static int (WINAPI
*pInetPtonA
)(INT
,LPCSTR
,LPVOID
);
80 static int (WINAPI
*pInetPtonW
)(INT
,LPWSTR
,LPVOID
);
81 static int (WINAPI
*pWSALookupServiceBeginW
)(LPWSAQUERYSETW
,DWORD
,LPHANDLE
);
82 static int (WINAPI
*pWSALookupServiceEnd
)(HANDLE
);
83 static int (WINAPI
*pWSALookupServiceNextW
)(HANDLE
,DWORD
,LPDWORD
,LPWSAQUERYSETW
);
84 static int (WINAPI
*pWSAEnumNameSpaceProvidersA
)(LPDWORD
,LPWSANAMESPACE_INFOA
);
85 static int (WINAPI
*pWSAEnumNameSpaceProvidersW
)(LPDWORD
,LPWSANAMESPACE_INFOW
);
86 static int (WINAPI
*pWSAPoll
)(WSAPOLLFD
*,ULONG
,INT
);
88 /* Function pointers from iphlpapi */
89 static DWORD (WINAPI
*pGetAdaptersInfo
)(PIP_ADAPTER_INFO
,PULONG
);
90 static DWORD (WINAPI
*pGetIpForwardTable
)(PMIB_IPFORWARDTABLE
,PULONG
,BOOL
);
92 /* Function pointers from ntdll */
93 static DWORD (WINAPI
*pNtClose
)(HANDLE
);
95 /**************** Structs and typedefs ***************/
97 typedef struct thread_info
103 /* Information in the server about open client connections */
104 typedef struct sock_info
107 struct sockaddr_in addr
;
108 struct sockaddr_in peer
;
114 /* Test parameters for both server & client */
115 typedef struct test_params
119 const char *inet_addr
;
126 /* server-specific test parameters */
127 typedef struct server_params
129 test_params
*general
;
134 /* client-specific test parameters */
135 typedef struct client_params
137 test_params
*general
;
142 /* This type combines all information for setting up a test scenario */
143 typedef struct test_setup
147 server_params srv_params
;
149 client_params clt_params
;
152 /* Thread local storage for server */
153 typedef struct server_memory
156 struct sockaddr_in addr
;
157 sock_info sock
[MAX_CLIENTS
];
160 /* Thread local storage for client */
161 typedef struct client_memory
164 struct sockaddr_in addr
;
169 /* SelectReadThread thread parameters */
170 typedef struct select_thread_params
174 } select_thread_params
;
176 /* Tests used in both getaddrinfo and GetAddrInfoW */
177 static const struct addr_hint_tests
179 int family
, socktype
, protocol
;
182 {AF_UNSPEC
, SOCK_STREAM
, IPPROTO_TCP
, 0 },
183 {AF_UNSPEC
, SOCK_STREAM
, IPPROTO_UDP
, 0 },
184 {AF_UNSPEC
, SOCK_STREAM
, IPPROTO_IPV6
,0 },
185 {AF_UNSPEC
, SOCK_DGRAM
, IPPROTO_TCP
, 0 },
186 {AF_UNSPEC
, SOCK_DGRAM
, IPPROTO_UDP
, 0 },
187 {AF_UNSPEC
, SOCK_DGRAM
, IPPROTO_IPV6
,0 },
188 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, 0 },
189 {AF_INET
, SOCK_STREAM
, IPPROTO_UDP
, 0 },
190 {AF_INET
, SOCK_STREAM
, IPPROTO_IPV6
,0 },
191 {AF_INET
, SOCK_DGRAM
, IPPROTO_TCP
, 0 },
192 {AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, 0 },
193 {AF_INET
, SOCK_DGRAM
, IPPROTO_IPV6
,0 },
194 {AF_UNSPEC
, 0, IPPROTO_TCP
, 0 },
195 {AF_UNSPEC
, 0, IPPROTO_UDP
, 0 },
196 {AF_UNSPEC
, 0, IPPROTO_IPV6
,0 },
197 {AF_UNSPEC
, SOCK_STREAM
, 0, 0 },
198 {AF_UNSPEC
, SOCK_DGRAM
, 0, 0 },
199 {AF_INET
, 0, IPPROTO_TCP
, 0 },
200 {AF_INET
, 0, IPPROTO_UDP
, 0 },
201 {AF_INET
, 0, IPPROTO_IPV6
,0 },
202 {AF_INET
, SOCK_STREAM
, 0, 0 },
203 {AF_INET
, SOCK_DGRAM
, 0, 0 },
204 {AF_UNSPEC
, 999, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
205 {AF_UNSPEC
, 999, IPPROTO_UDP
, WSAESOCKTNOSUPPORT
},
206 {AF_UNSPEC
, 999, IPPROTO_IPV6
,WSAESOCKTNOSUPPORT
},
207 {AF_INET
, 999, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
208 {AF_INET
, 999, IPPROTO_UDP
, WSAESOCKTNOSUPPORT
},
209 {AF_INET
, 999, IPPROTO_IPV6
,WSAESOCKTNOSUPPORT
},
210 {AF_UNSPEC
, SOCK_STREAM
, 999, 0 },
211 {AF_UNSPEC
, SOCK_STREAM
, 999, 0 },
212 {AF_INET
, SOCK_DGRAM
, 999, 0 },
213 {AF_INET
, SOCK_DGRAM
, 999, 0 },
216 /**************** Static variables ***************/
218 static DWORD tls
; /* Thread local storage index */
219 static HANDLE thread
[1+MAX_CLIENTS
];
220 static DWORD thread_id
[1+MAX_CLIENTS
];
221 static HANDLE server_ready
;
222 static HANDLE client_ready
[MAX_CLIENTS
];
223 static int client_id
;
225 /**************** General utility functions ***************/
227 static SOCKET
setup_server_socket(struct sockaddr_in
*addr
, int *len
);
228 static SOCKET
setup_connector_socket(struct sockaddr_in
*addr
, int len
, BOOL nonblock
);
230 static int tcp_socketpair(SOCKET
*src
, SOCKET
*dst
)
232 SOCKET server
= INVALID_SOCKET
;
233 struct sockaddr_in addr
;
237 *src
= INVALID_SOCKET
;
238 *dst
= INVALID_SOCKET
;
240 *src
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
241 if (*src
== INVALID_SOCKET
)
244 server
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
245 if (server
== INVALID_SOCKET
)
248 memset(&addr
, 0, sizeof(addr
));
249 addr
.sin_family
= AF_INET
;
250 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
251 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
256 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
260 ret
= listen(server
, 1);
264 ret
= connect(*src
, (struct sockaddr
*)&addr
, sizeof(addr
));
269 *dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
272 if (server
!= INVALID_SOCKET
)
274 if (*src
!= INVALID_SOCKET
&& *dst
!= INVALID_SOCKET
)
281 static int tcp_socketpair_ovl(SOCKET
*src
, SOCKET
*dst
)
283 SOCKET server
= INVALID_SOCKET
;
284 struct sockaddr_in addr
;
287 *src
= INVALID_SOCKET
;
288 *dst
= INVALID_SOCKET
;
290 *src
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
291 if (*src
== INVALID_SOCKET
)
294 server
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
295 if (server
== INVALID_SOCKET
)
298 memset(&addr
, 0, sizeof(addr
));
299 addr
.sin_family
= AF_INET
;
300 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
301 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
306 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
310 ret
= listen(server
, 1);
314 ret
= connect(*src
, (struct sockaddr
*)&addr
, sizeof(addr
));
319 *dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
322 if (server
!= INVALID_SOCKET
)
324 if (*src
!= INVALID_SOCKET
&& *dst
!= INVALID_SOCKET
)
331 static void set_so_opentype ( BOOL overlapped
)
333 int optval
= !overlapped
, newval
, len
= sizeof (int);
335 ok ( setsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
336 (LPVOID
) &optval
, sizeof (optval
) ) == 0,
337 "setting SO_OPENTYPE failed\n" );
338 ok ( getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
339 (LPVOID
) &newval
, &len
) == 0,
340 "getting SO_OPENTYPE failed\n" );
341 ok ( optval
== newval
, "failed to set SO_OPENTYPE\n" );
344 static int set_blocking ( SOCKET s
, BOOL blocking
)
346 u_long val
= !blocking
;
347 return ioctlsocket ( s
, FIONBIO
, &val
);
350 static void fill_buffer ( char *buf
, int chunk_size
, int n_chunks
)
353 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
354 memset ( p
, c
, chunk_size
);
357 static int test_buffer ( char *buf
, int chunk_size
, int n_chunks
)
361 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
363 for ( i
= 0; i
< chunk_size
; i
++ )
364 if ( p
[i
] != c
) return i
;
370 * This routine is called when a client / server does not expect any more data,
371 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
373 static void read_zero_bytes ( SOCKET s
)
377 while ( ( tmp
= recv ( s
, buf
, 256, 0 ) ) > 0 )
379 ok ( n
<= 0, "garbage data received: %d bytes\n", n
);
382 static int do_synchronous_send ( SOCKET s
, char *buf
, int buflen
, int flags
, int sendlen
)
384 char* last
= buf
+ buflen
, *p
;
386 for ( p
= buf
; n
> 0 && p
< last
; )
388 n
= send ( s
, p
, min ( sendlen
, last
- p
), flags
);
391 wsa_ok ( n
, 0 <=, "do_synchronous_send (%x): error %d\n" );
395 static int do_synchronous_recv ( SOCKET s
, char *buf
, int buflen
, int flags
, int recvlen
)
397 char* last
= buf
+ buflen
, *p
;
399 for ( p
= buf
; n
> 0 && p
< last
; )
401 n
= recv ( s
, p
, min ( recvlen
, last
- p
), flags
);
404 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
408 static int do_synchronous_recvfrom ( SOCKET s
, char *buf
, int buflen
, int flags
, struct sockaddr
*from
, int *fromlen
, int recvlen
)
410 char* last
= buf
+ buflen
, *p
;
412 for ( p
= buf
; n
> 0 && p
< last
; )
414 n
= recvfrom ( s
, p
, min ( recvlen
, last
- p
), flags
, from
, fromlen
);
417 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
422 * Call this routine right after thread startup.
423 * SO_OPENTYPE must by 0, regardless what the server did.
425 static void check_so_opentype (void)
429 getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
, (LPVOID
) &tmp
, &len
);
430 ok ( tmp
== 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp
);
433 static void compare_addrinfo (ADDRINFO
*a
, ADDRINFO
*b
)
435 for (; a
&& b
; a
= a
->ai_next
, b
= b
->ai_next
)
437 ok(a
->ai_flags
== b
->ai_flags
,
438 "Wrong flags %d != %d\n", a
->ai_flags
, b
->ai_flags
);
439 ok(a
->ai_family
== b
->ai_family
,
440 "Wrong family %d != %d\n", a
->ai_family
, b
->ai_family
);
441 ok(a
->ai_socktype
== b
->ai_socktype
,
442 "Wrong socktype %d != %d\n", a
->ai_socktype
, b
->ai_socktype
);
443 ok(a
->ai_protocol
== b
->ai_protocol
,
444 "Wrong protocol %d != %d\n", a
->ai_protocol
, b
->ai_protocol
);
445 ok(a
->ai_addrlen
== b
->ai_addrlen
,
446 "Wrong addrlen %lu != %lu\n", a
->ai_addrlen
, b
->ai_addrlen
);
447 ok(!memcmp(a
->ai_addr
, b
->ai_addr
, min(a
->ai_addrlen
, b
->ai_addrlen
)),
448 "Wrong address data\n");
449 if (a
->ai_canonname
&& b
->ai_canonname
)
451 ok(!strcmp(a
->ai_canonname
, b
->ai_canonname
), "Wrong canonical name '%s' != '%s'\n",
452 a
->ai_canonname
, b
->ai_canonname
);
455 ok(!a
->ai_canonname
&& !b
->ai_canonname
, "Expected both names absent (%p != %p)\n",
456 a
->ai_canonname
, b
->ai_canonname
);
458 ok(!a
&& !b
, "Expected both addresses null (%p != %p)\n", a
, b
);
461 static void compare_addrinfow (ADDRINFOW
*a
, ADDRINFOW
*b
)
463 for (; a
&& b
; a
= a
->ai_next
, b
= b
->ai_next
)
465 ok(a
->ai_flags
== b
->ai_flags
,
466 "Wrong flags %d != %d\n", a
->ai_flags
, b
->ai_flags
);
467 ok(a
->ai_family
== b
->ai_family
,
468 "Wrong family %d != %d\n", a
->ai_family
, b
->ai_family
);
469 ok(a
->ai_socktype
== b
->ai_socktype
,
470 "Wrong socktype %d != %d\n", a
->ai_socktype
, b
->ai_socktype
);
471 ok(a
->ai_protocol
== b
->ai_protocol
,
472 "Wrong protocol %d != %d\n", a
->ai_protocol
, b
->ai_protocol
);
473 ok(a
->ai_addrlen
== b
->ai_addrlen
,
474 "Wrong addrlen %lu != %lu\n", a
->ai_addrlen
, b
->ai_addrlen
);
475 ok(!memcmp(a
->ai_addr
, b
->ai_addr
, min(a
->ai_addrlen
, b
->ai_addrlen
)),
476 "Wrong address data\n");
477 if (a
->ai_canonname
&& b
->ai_canonname
)
479 ok(!lstrcmpW(a
->ai_canonname
, b
->ai_canonname
), "Wrong canonical name '%s' != '%s'\n",
480 wine_dbgstr_w(a
->ai_canonname
), wine_dbgstr_w(b
->ai_canonname
));
483 ok(!a
->ai_canonname
&& !b
->ai_canonname
, "Expected both names absent (%p != %p)\n",
484 a
->ai_canonname
, b
->ai_canonname
);
486 ok(!a
&& !b
, "Expected both addresses null (%p != %p)\n", a
, b
);
489 /**************** Server utility functions ***************/
492 * Even if we have closed our server socket cleanly,
493 * the OS may mark the address "in use" for some time -
494 * this happens with native Linux apps, too.
496 static void do_bind ( SOCKET s
, struct sockaddr
* addr
, int addrlen
)
498 int err
, wsaerr
= 0, n_try
= BIND_TRIES
;
500 while ( ( err
= bind ( s
, addr
, addrlen
) ) != 0 &&
501 ( wsaerr
= WSAGetLastError () ) == WSAEADDRINUSE
&&
504 trace ( "address in use, waiting ...\n" );
505 Sleep ( 1000 * BIND_SLEEP
);
507 ok ( err
== 0, "failed to bind: %d\n", wsaerr
);
510 static void server_start ( server_params
*par
)
513 test_params
*gen
= par
->general
;
514 server_memory
*mem
= LocalAlloc ( LPTR
, sizeof ( server_memory
) );
516 TlsSetValue ( tls
, mem
);
517 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
518 NULL
, 0, par
->sock_flags
);
519 ok ( mem
->s
!= INVALID_SOCKET
, "Server: WSASocket failed\n" );
521 mem
->addr
.sin_family
= AF_INET
;
522 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
523 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
525 for (i
= 0; i
< MAX_CLIENTS
; i
++)
527 mem
->sock
[i
].s
= INVALID_SOCKET
;
528 mem
->sock
[i
].buf
= LocalAlloc ( LPTR
, gen
->n_chunks
* gen
->chunk_size
);
529 mem
->sock
[i
].n_recvd
= 0;
530 mem
->sock
[i
].n_sent
= 0;
533 if ( gen
->sock_type
== SOCK_STREAM
)
534 do_bind ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof (mem
->addr
) );
537 static void server_stop (void)
540 server_memory
*mem
= TlsGetValue ( tls
);
542 for (i
= 0; i
< MAX_CLIENTS
; i
++ )
544 LocalFree ( mem
->sock
[i
].buf
);
545 if ( mem
->sock
[i
].s
!= INVALID_SOCKET
)
546 closesocket ( mem
->sock
[i
].s
);
548 ok ( closesocket ( mem
->s
) == 0, "closesocket failed\n" );
550 ExitThread ( GetCurrentThreadId () );
553 /**************** Client utilitiy functions ***************/
555 static void client_start ( client_params
*par
)
557 test_params
*gen
= par
->general
;
558 client_memory
*mem
= LocalAlloc (LPTR
, sizeof (client_memory
));
560 TlsSetValue ( tls
, mem
);
562 WaitForSingleObject ( server_ready
, INFINITE
);
564 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
565 NULL
, 0, par
->sock_flags
);
567 mem
->addr
.sin_family
= AF_INET
;
568 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
569 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
571 ok ( mem
->s
!= INVALID_SOCKET
, "Client: WSASocket failed\n" );
573 mem
->send_buf
= LocalAlloc ( LPTR
, 2 * gen
->n_chunks
* gen
->chunk_size
);
574 mem
->recv_buf
= mem
->send_buf
+ gen
->n_chunks
* gen
->chunk_size
;
575 fill_buffer ( mem
->send_buf
, gen
->chunk_size
, gen
->n_chunks
);
577 SetEvent ( client_ready
[client_id
] );
578 /* Wait for the other clients to come up */
579 WaitForMultipleObjects ( min ( gen
->n_clients
, MAX_CLIENTS
), client_ready
, TRUE
, INFINITE
);
582 static void client_stop (void)
584 client_memory
*mem
= TlsGetValue ( tls
);
585 wsa_ok ( closesocket ( mem
->s
), 0 ==, "closesocket error (%x): %d\n" );
586 LocalFree ( mem
->send_buf
);
591 /**************** Servers ***************/
594 * simple_server: A very basic server doing synchronous IO.
596 static VOID WINAPI
simple_server ( server_params
*par
)
598 test_params
*gen
= par
->general
;
600 int pos
, n_recvd
, n_sent
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
601 id
= GetCurrentThreadId();
603 trace ( "simple_server (%x) starting\n", id
);
605 set_so_opentype ( FALSE
); /* non-overlapped */
606 server_start ( par
);
607 mem
= TlsGetValue ( tls
);
609 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
610 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "simple_server (%x): listen failed: %d\n");
612 trace ( "simple_server (%x) ready\n", id
);
613 SetEvent ( server_ready
); /* notify clients */
615 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
617 trace ( "simple_server (%x): waiting for client\n", id
);
619 /* accept a single connection */
620 tmp
= sizeof ( mem
->sock
[0].peer
);
621 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
622 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "simple_server (%x): accept failed: %d\n" );
624 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
625 "simple_server (%x): strange peer address\n", id
);
627 /* Receive data & check it */
628 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
629 ok ( n_recvd
== n_expected
,
630 "simple_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
631 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
632 ok ( pos
== -1, "simple_server (%x): test pattern error: %d\n", id
, pos
);
635 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
636 ok ( n_sent
== n_expected
,
637 "simple_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
640 read_zero_bytes ( mem
->sock
[0].s
);
641 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "simple_server (%x): closesocket error: %d\n" );
642 mem
->sock
[0].s
= INVALID_SOCKET
;
645 trace ( "simple_server (%x) exiting\n", id
);
650 * oob_server: A very basic server receiving out-of-band data.
652 static VOID WINAPI
oob_server ( server_params
*par
)
654 test_params
*gen
= par
->general
;
657 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
,
658 id
= GetCurrentThreadId();
660 trace ( "oob_server (%x) starting\n", id
);
662 set_so_opentype ( FALSE
); /* non-overlapped */
663 server_start ( par
);
664 mem
= TlsGetValue ( tls
);
666 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "oob_server (%x): failed to set blocking mode: %d\n");
667 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "oob_server (%x): listen failed: %d\n");
669 trace ( "oob_server (%x) ready\n", id
);
670 SetEvent ( server_ready
); /* notify clients */
672 trace ( "oob_server (%x): waiting for client\n", id
);
674 /* accept a single connection */
675 tmp
= sizeof ( mem
->sock
[0].peer
);
676 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
677 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "oob_server (%x): accept failed: %d\n" );
679 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
680 "oob_server (%x): strange peer address\n", id
);
682 /* check initial atmark state */
683 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
684 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
686 /* Receive normal data */
687 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
688 ok ( n_recvd
== n_expected
,
689 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
690 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
691 ok ( pos
== -1, "oob_server (%x): test pattern error: %d\n", id
, pos
);
693 /* check atmark state */
694 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
695 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
698 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
699 ok ( n_sent
== n_expected
,
700 "oob_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
702 /* Receive a part of the out-of-band data and print atmark state */
703 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, 8, 0, par
->buflen
);
705 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, 8 );
708 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
709 trace( "oob_server (%x): %s the OOB mark: %i\n", id
, atmark
== 1 ? "not at" : "at", atmark
);
711 /* Receive the rest of the out-of-band data and check atmark state */
712 do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
714 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
715 todo_wine
ok ( atmark
== 0, "oob_server (%x): not at the OOB mark: %i\n", id
, atmark
);
718 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "oob_server (%x): closesocket error: %d\n" );
719 mem
->sock
[0].s
= INVALID_SOCKET
;
721 trace ( "oob_server (%x) exiting\n", id
);
726 * select_server: A non-blocking server.
728 static VOID WINAPI
select_server ( server_params
*par
)
730 test_params
*gen
= par
->general
;
732 int n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
733 id
= GetCurrentThreadId(), n_connections
= 0, n_sent
, n_recvd
,
734 n_set
, delta
, n_ready
;
735 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
736 fd_set fds_recv
, fds_send
, fds_openrecv
, fds_opensend
;
738 trace ( "select_server (%x) starting\n", id
);
740 set_so_opentype ( FALSE
); /* non-overlapped */
741 server_start ( par
);
742 mem
= TlsGetValue ( tls
);
744 wsa_ok ( set_blocking ( mem
->s
, FALSE
), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
745 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "select_server (%x): listen failed: %d\n");
747 trace ( "select_server (%x) ready\n", id
);
748 SetEvent ( server_ready
); /* notify clients */
750 FD_ZERO ( &fds_openrecv
);
751 FD_ZERO ( &fds_recv
);
752 FD_ZERO ( &fds_send
);
753 FD_ZERO ( &fds_opensend
);
755 FD_SET ( mem
->s
, &fds_openrecv
);
759 fds_recv
= fds_openrecv
;
760 fds_send
= fds_opensend
;
764 wsa_ok ( ( n_ready
= select ( 0, &fds_recv
, &fds_send
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
765 "select_server (%x): select() failed: %d\n" );
767 /* check for incoming requests */
768 if ( FD_ISSET ( mem
->s
, &fds_recv
) ) {
771 trace ( "select_server (%x): accepting client connection\n", id
);
773 /* accept a single connection */
774 tmp
= sizeof ( mem
->sock
[n_connections
].peer
);
775 mem
->sock
[n_connections
].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[n_connections
].peer
, &tmp
);
776 wsa_ok ( mem
->sock
[n_connections
].s
, INVALID_SOCKET
!=, "select_server (%x): accept() failed: %d\n" );
778 ok ( mem
->sock
[n_connections
].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
779 "select_server (%x): strange peer address\n", id
);
781 /* add to list of open connections */
782 FD_SET ( mem
->sock
[n_connections
].s
, &fds_openrecv
);
783 FD_SET ( mem
->sock
[n_connections
].s
, &fds_opensend
);
788 /* handle open requests */
790 for ( i
= 0; i
< n_connections
; i
++ )
792 if ( FD_ISSET( mem
->sock
[i
].s
, &fds_recv
) ) {
795 if ( mem
->sock
[i
].n_recvd
< n_expected
) {
796 /* Receive data & check it */
797 n_recvd
= recv ( mem
->sock
[i
].s
, mem
->sock
[i
].buf
+ mem
->sock
[i
].n_recvd
, min ( n_expected
- mem
->sock
[i
].n_recvd
, par
->buflen
), 0 );
798 ok ( n_recvd
!= SOCKET_ERROR
, "select_server (%x): error in recv(): %d\n", id
, WSAGetLastError() );
799 mem
->sock
[i
].n_recvd
+= n_recvd
;
801 if ( mem
->sock
[i
].n_recvd
== n_expected
) {
802 int pos
= test_buffer ( mem
->sock
[i
].buf
, gen
->chunk_size
, gen
->n_chunks
);
803 ok ( pos
== -1, "select_server (%x): test pattern error: %d\n", id
, pos
);
804 FD_CLR ( mem
->sock
[i
].s
, &fds_openrecv
);
807 ok ( mem
->sock
[i
].n_recvd
<= n_expected
, "select_server (%x): received too many bytes: %d\n", id
, mem
->sock
[i
].n_recvd
);
811 /* only echo back what we've received */
812 delta
= mem
->sock
[i
].n_recvd
- mem
->sock
[i
].n_sent
;
814 if ( FD_ISSET ( mem
->sock
[i
].s
, &fds_send
) ) {
817 if ( ( delta
> 0 ) && ( mem
->sock
[i
].n_sent
< n_expected
) ) {
819 n_sent
= send ( mem
->sock
[i
].s
, mem
->sock
[i
].buf
+ mem
->sock
[i
].n_sent
, min ( delta
, par
->buflen
), 0 );
820 ok ( n_sent
!= SOCKET_ERROR
, "select_server (%x): error in send(): %d\n", id
, WSAGetLastError() );
821 mem
->sock
[i
].n_sent
+= n_sent
;
823 if ( mem
->sock
[i
].n_sent
== n_expected
) {
824 FD_CLR ( mem
->sock
[i
].s
, &fds_opensend
);
827 ok ( mem
->sock
[i
].n_sent
<= n_expected
, "select_server (%x): sent too many bytes: %d\n", id
, mem
->sock
[i
].n_sent
);
832 /* check that select returned the correct number of ready sockets */
833 ok ( ( n_set
== n_ready
), "select_server (%x): select() returns wrong number of ready sockets\n", id
);
835 /* check if all clients are done */
836 if ( ( fds_opensend
.fd_count
== 0 )
837 && ( fds_openrecv
.fd_count
== 1 ) /* initial socket that accepts clients */
838 && ( n_connections
== min ( gen
->n_clients
, MAX_CLIENTS
) ) ) {
843 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
846 read_zero_bytes ( mem
->sock
[i
].s
);
847 wsa_ok ( closesocket ( mem
->sock
[i
].s
), 0 ==, "select_server (%x): closesocket error: %d\n" );
848 mem
->sock
[i
].s
= INVALID_SOCKET
;
851 trace ( "select_server (%x) exiting\n", id
);
855 /**************** Clients ***************/
858 * simple_client: A very basic client doing synchronous IO.
860 static VOID WINAPI
simple_client ( client_params
*par
)
862 test_params
*gen
= par
->general
;
864 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
866 id
= GetCurrentThreadId();
867 trace ( "simple_client (%x): starting\n", id
);
868 /* wait here because we want to call set_so_opentype before creating a socket */
869 WaitForSingleObject ( server_ready
, INFINITE
);
870 trace ( "simple_client (%x): server ready\n", id
);
872 check_so_opentype ();
873 set_so_opentype ( FALSE
); /* non-overlapped */
874 client_start ( par
);
875 mem
= TlsGetValue ( tls
);
878 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
879 0 ==, "simple_client (%x): connect error: %d\n" );
880 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
881 "simple_client (%x): failed to set blocking mode\n", id
);
882 trace ( "simple_client (%x) connected\n", id
);
884 /* send data to server */
885 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
886 ok ( n_sent
== n_expected
,
887 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
889 /* shutdown send direction */
890 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
892 /* Receive data echoed back & check it */
893 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, 0, par
->buflen
);
894 ok ( n_recvd
== n_expected
,
895 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
898 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
899 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
902 read_zero_bytes ( mem
->s
);
903 trace ( "simple_client (%x) exiting\n", id
);
908 * oob_client: A very basic client sending out-of-band data.
910 static VOID WINAPI
oob_client ( client_params
*par
)
912 test_params
*gen
= par
->general
;
914 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
916 id
= GetCurrentThreadId();
917 trace ( "oob_client (%x): starting\n", id
);
918 /* wait here because we want to call set_so_opentype before creating a socket */
919 WaitForSingleObject ( server_ready
, INFINITE
);
920 trace ( "oob_client (%x): server ready\n", id
);
922 check_so_opentype ();
923 set_so_opentype ( FALSE
); /* non-overlapped */
924 client_start ( par
);
925 mem
= TlsGetValue ( tls
);
928 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
929 0 ==, "oob_client (%x): connect error: %d\n" );
930 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
931 "oob_client (%x): failed to set blocking mode\n", id
);
932 trace ( "oob_client (%x) connected\n", id
);
934 /* send data to server */
935 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
936 ok ( n_sent
== n_expected
,
937 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
939 /* Receive data echoed back & check it */
940 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, 0, par
->buflen
);
941 ok ( n_recvd
== n_expected
,
942 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
943 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
944 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
946 /* send out-of-band data to server */
947 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, MSG_OOB
, par
->buflen
);
948 ok ( n_sent
== n_expected
,
949 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
951 /* shutdown send direction */
952 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
955 read_zero_bytes ( mem
->s
);
956 trace ( "oob_client (%x) exiting\n", id
);
961 * simple_mixed_client: mixing send and recvfrom
963 static VOID WINAPI
simple_mixed_client ( client_params
*par
)
965 test_params
*gen
= par
->general
;
967 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
968 int fromLen
= sizeof(mem
->addr
);
969 struct sockaddr test
;
971 id
= GetCurrentThreadId();
972 trace ( "simple_client (%x): starting\n", id
);
973 /* wait here because we want to call set_so_opentype before creating a socket */
974 WaitForSingleObject ( server_ready
, INFINITE
);
975 trace ( "simple_client (%x): server ready\n", id
);
977 check_so_opentype ();
978 set_so_opentype ( FALSE
); /* non-overlapped */
979 client_start ( par
);
980 mem
= TlsGetValue ( tls
);
983 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
984 0 ==, "simple_client (%x): connect error: %d\n" );
985 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
986 "simple_client (%x): failed to set blocking mode\n", id
);
987 trace ( "simple_client (%x) connected\n", id
);
989 /* send data to server */
990 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
991 ok ( n_sent
== n_expected
,
992 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
994 /* shutdown send direction */
995 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
997 /* this shouldn't change, since lpFrom, is not updated on
998 connection oriented sockets - exposed by bug 11640
1000 ((struct sockaddr_in
*)&test
)->sin_addr
.s_addr
= inet_addr("0.0.0.0");
1002 /* Receive data echoed back & check it */
1003 n_recvd
= do_synchronous_recvfrom ( mem
->s
,
1007 (struct sockaddr
*)&test
,
1010 ok ( n_recvd
== n_expected
,
1011 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
1013 /* check that lpFrom was not updated */
1016 inet_ntoa(((struct sockaddr_in
*)&test
)->sin_addr
),
1017 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
1020 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
1021 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
1024 read_zero_bytes ( mem
->s
);
1025 trace ( "simple_client (%x) exiting\n", id
);
1030 * event_client: An event-driven client
1032 static void WINAPI
event_client ( client_params
*par
)
1034 test_params
*gen
= par
->general
;
1036 int id
= GetCurrentThreadId(), n_expected
= gen
->n_chunks
* gen
->chunk_size
,
1039 WSANETWORKEVENTS wsa_events
;
1040 char *send_last
, *recv_last
, *send_p
, *recv_p
;
1041 LONG mask
= FD_READ
| FD_WRITE
| FD_CLOSE
;
1043 trace ( "event_client (%x): starting\n", id
);
1044 client_start ( par
);
1045 trace ( "event_client (%x): server ready\n", id
);
1047 mem
= TlsGetValue ( tls
);
1049 /* Prepare event notification for connect, makes socket nonblocking */
1050 event
= WSACreateEvent ();
1051 WSAEventSelect ( mem
->s
, event
, FD_CONNECT
);
1052 tmp
= connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) );
1054 err
= WSAGetLastError ();
1055 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): connect error: %d\n", id
, err
);
1056 tmp
= WaitForSingleObject ( event
, INFINITE
);
1057 ok ( tmp
== WAIT_OBJECT_0
, "event_client (%x): wait for connect event failed: %d\n", id
, tmp
);
1058 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
1059 ok ( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
1060 err
= wsa_events
.iErrorCode
[ FD_CONNECT_BIT
];
1061 ok ( err
== 0, "event_client (%x): connect error: %d\n", id
, err
);
1062 if ( err
) goto out
;
1065 trace ( "event_client (%x) connected\n", id
);
1067 WSAEventSelect ( mem
->s
, event
, mask
);
1069 recv_p
= mem
->recv_buf
;
1070 recv_last
= mem
->recv_buf
+ n_expected
;
1071 send_p
= mem
->send_buf
;
1072 send_last
= mem
->send_buf
+ n_expected
;
1076 err
= WaitForSingleObject ( event
, INFINITE
);
1077 ok ( err
== WAIT_OBJECT_0
, "event_client (%x): wait failed\n", id
);
1079 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
1080 ok( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
1082 if ( wsa_events
.lNetworkEvents
& FD_WRITE
)
1084 err
= wsa_events
.iErrorCode
[ FD_WRITE_BIT
];
1085 ok ( err
== 0, "event_client (%x): FD_WRITE error code: %d\n", id
, err
);
1090 n
= send ( mem
->s
, send_p
, min ( send_last
- send_p
, par
->buflen
), 0 );
1093 err
= WSAGetLastError ();
1094 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): send error: %d\n", id
, err
);
1099 while ( n
>= 0 && send_p
< send_last
);
1101 if ( send_p
== send_last
)
1103 trace ( "event_client (%x): all data sent - shutdown\n", id
);
1104 shutdown ( mem
->s
, SD_SEND
);
1106 WSAEventSelect ( mem
->s
, event
, mask
);
1109 if ( wsa_events
.lNetworkEvents
& FD_READ
)
1111 err
= wsa_events
.iErrorCode
[ FD_READ_BIT
];
1112 ok ( err
== 0, "event_client (%x): FD_READ error code: %d\n", id
, err
);
1113 if ( err
!= 0 ) break;
1115 /* First read must succeed */
1116 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
1117 wsa_ok ( n
, 0 <=, "event_client (%x): recv error: %d\n" );
1121 if ( recv_p
== recv_last
)
1124 trace ( "event_client (%x): all data received\n", id
);
1125 WSAEventSelect ( mem
->s
, event
, mask
);
1128 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
1129 if ( n
< 0 && ( err
= WSAGetLastError()) != WSAEWOULDBLOCK
)
1130 ok ( 0, "event_client (%x): read error: %d\n", id
, err
);
1134 if ( wsa_events
.lNetworkEvents
& FD_CLOSE
)
1136 trace ( "event_client (%x): close event\n", id
);
1137 err
= wsa_events
.iErrorCode
[ FD_CLOSE_BIT
];
1138 ok ( err
== 0, "event_client (%x): FD_CLOSE error code: %d\n", id
, err
);
1143 n
= send_p
- mem
->send_buf
;
1144 ok ( send_p
== send_last
,
1145 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n
, n_expected
);
1146 n
= recv_p
- mem
->recv_buf
;
1147 ok ( recv_p
== recv_last
,
1148 "simple_client (%x): received less data than expected: %d of %d\n", id
, n
, n_expected
);
1149 n
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
1150 ok ( n
== -1, "event_client (%x): test pattern error: %d\n", id
, n
);
1153 WSACloseEvent ( event
);
1154 trace ( "event_client (%x) exiting\n", id
);
1158 /* Tests for WSAStartup */
1159 static void test_WithoutWSAStartup(void)
1163 WSASetLastError(0xdeadbeef);
1164 ok(WSASocketA(0, 0, 0, NULL
, 0, 0) == INVALID_SOCKET
, "WSASocketA should have failed\n");
1165 err
= WSAGetLastError();
1166 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %d\n", err
);
1168 WSASetLastError(0xdeadbeef);
1169 ok(gethostbyname("localhost") == NULL
, "gethostbyname() succeeded unexpectedly\n");
1170 err
= WSAGetLastError();
1171 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %d\n", err
);
1174 static void test_WithWSAStartup(void)
1177 WORD version
= MAKEWORD( 2, 2 );
1178 INT res
, socks
, i
, j
;
1183 SOCKET src
, dst
, dup_src
, dup_dst
;
1187 res
= WSAStartup( version
, &data
);
1188 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
1190 ptr
= gethostbyname("localhost");
1191 ok(ptr
!= NULL
, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
1193 /* Alloc some sockets to check if they are destroyed on WSACleanup */
1194 for (socks
= 0; socks
< sizeof(pairs
) / sizeof(pairs
[0]); socks
++)
1196 WSAPROTOCOL_INFOA info
;
1197 if (tcp_socketpair(&pairs
[socks
].src
, &pairs
[socks
].dst
)) break;
1199 memset(&info
, 0, sizeof(info
));
1200 ok(!WSADuplicateSocketA(pairs
[socks
].src
, GetCurrentProcessId(), &info
),
1201 "WSADuplicateSocketA should have worked\n");
1202 pairs
[socks
].dup_src
= WSASocketA(0, 0, 0, &info
, 0, 0);
1203 ok(pairs
[socks
].dup_src
!= SOCKET_ERROR
, "expected != -1\n");
1205 memset(&info
, 0, sizeof(info
));
1206 ok(!WSADuplicateSocketA(pairs
[socks
].dst
, GetCurrentProcessId(), &info
),
1207 "WSADuplicateSocketA should have worked\n");
1208 pairs
[socks
].dup_dst
= WSASocketA(0, 0, 0, &info
, 0, 0);
1209 ok(pairs
[socks
].dup_dst
!= SOCKET_ERROR
, "expected != -1\n");
1212 res
= send(pairs
[0].src
, "TEST", 4, 0);
1213 ok(res
== 4, "send failed with error %d\n", WSAGetLastError());
1217 res
= WSAStartup( version
, &data
);
1218 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
1220 /* show that sockets are destroyed automatically after WSACleanup */
1222 SetLastError(0xdeadbeef);
1223 res
= send(pairs
[0].src
, "TEST", 4, 0);
1224 error
= WSAGetLastError();
1225 ok(res
== SOCKET_ERROR
, "send should have failed\n");
1226 ok(error
== WSAENOTSOCK
, "expected 10038, got %d\n", error
);
1228 SetLastError(0xdeadbeef);
1229 res
= send(pairs
[0].dst
, "TEST", 4, 0);
1230 error
= WSAGetLastError();
1231 ok(res
== SOCKET_ERROR
, "send should have failed\n");
1232 ok(error
== WSAENOTSOCK
, "expected 10038, got %d\n", error
);
1234 /* Check that all sockets were destroyed */
1235 for (i
= 0; i
< socks
; i
++)
1237 for (j
= 0; j
< 4; j
++)
1239 struct sockaddr_in saddr
;
1240 int size
= sizeof(saddr
);
1243 case 0: sock
= pairs
[i
].src
; break;
1244 case 1: sock
= pairs
[i
].dup_src
; break;
1245 case 2: sock
= pairs
[i
].dst
; break;
1246 case 3: sock
= pairs
[i
].dup_dst
; break;
1249 SetLastError(0xdeadbeef);
1250 res
= getsockname(sock
, (struct sockaddr
*)&saddr
, &size
);
1251 error
= WSAGetLastError();
1252 ok(res
== SOCKET_ERROR
, "Test[%d]: getsockname should have failed\n", i
);
1253 ok(error
== WSAENOTSOCK
, "Test[%d]: expected 10038, got %d\n", i
, error
);
1259 /* While wine is not fixed, close all sockets manually */
1260 for (i
= 0; i
< socks
; i
++)
1262 closesocket(pairs
[i
].src
);
1263 closesocket(pairs
[i
].dst
);
1264 closesocket(pairs
[i
].dup_src
);
1265 closesocket(pairs
[i
].dup_dst
);
1269 ok(res
== 0, "expected 0, got %d\n", res
);
1270 WSASetLastError(0xdeadbeef);
1272 error
= WSAGetLastError();
1273 ok ( res
== SOCKET_ERROR
&& error
== WSANOTINITIALISED
,
1274 "WSACleanup returned %d WSAGetLastError is %d\n", res
, error
);
1277 /**************** Main program utility functions ***************/
1279 static void Init (void)
1281 WORD ver
= MAKEWORD (2, 2);
1283 HMODULE hws2_32
= GetModuleHandleA("ws2_32.dll"), hiphlpapi
, ntdll
;
1285 pfreeaddrinfo
= (void *)GetProcAddress(hws2_32
, "freeaddrinfo");
1286 pgetaddrinfo
= (void *)GetProcAddress(hws2_32
, "getaddrinfo");
1287 pFreeAddrInfoW
= (void *)GetProcAddress(hws2_32
, "FreeAddrInfoW");
1288 pFreeAddrInfoExW
= (void *)GetProcAddress(hws2_32
, "FreeAddrInfoExW");
1289 pGetAddrInfoW
= (void *)GetProcAddress(hws2_32
, "GetAddrInfoW");
1290 pGetAddrInfoExW
= (void *)GetProcAddress(hws2_32
, "GetAddrInfoExW");
1291 pGetAddrInfoExOverlappedResult
= (void *)GetProcAddress(hws2_32
, "GetAddrInfoExOverlappedResult");
1292 pInetNtop
= (void *)GetProcAddress(hws2_32
, "inet_ntop");
1293 pInetNtopW
= (void *)GetProcAddress(hws2_32
, "InetNtopW");
1294 pInetPtonA
= (void *)GetProcAddress(hws2_32
, "inet_pton");
1295 pInetPtonW
= (void *)GetProcAddress(hws2_32
, "InetPtonW");
1296 pWSALookupServiceBeginW
= (void *)GetProcAddress(hws2_32
, "WSALookupServiceBeginW");
1297 pWSALookupServiceEnd
= (void *)GetProcAddress(hws2_32
, "WSALookupServiceEnd");
1298 pWSALookupServiceNextW
= (void *)GetProcAddress(hws2_32
, "WSALookupServiceNextW");
1299 pWSAEnumNameSpaceProvidersA
= (void *)GetProcAddress(hws2_32
, "WSAEnumNameSpaceProvidersA");
1300 pWSAEnumNameSpaceProvidersW
= (void *)GetProcAddress(hws2_32
, "WSAEnumNameSpaceProvidersW");
1301 pWSAPoll
= (void *)GetProcAddress(hws2_32
, "WSAPoll");
1303 hiphlpapi
= LoadLibraryA("iphlpapi.dll");
1306 pGetIpForwardTable
= (void *)GetProcAddress(hiphlpapi
, "GetIpForwardTable");
1307 pGetAdaptersInfo
= (void *)GetProcAddress(hiphlpapi
, "GetAdaptersInfo");
1310 ntdll
= LoadLibraryA("ntdll.dll");
1312 pNtClose
= (void *)GetProcAddress(ntdll
, "NtClose");
1314 ok ( WSAStartup ( ver
, &data
) == 0, "WSAStartup failed\n" );
1318 static void Exit (void)
1323 err
= WSAGetLastError();
1324 ok ( ret
== 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret
, err
);
1327 static void StartServer (LPTHREAD_START_ROUTINE routine
,
1328 test_params
*general
, server_params
*par
)
1330 par
->general
= general
;
1331 thread
[0] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[0] );
1332 ok ( thread
[0] != NULL
, "Failed to create server thread\n" );
1335 static void StartClients (LPTHREAD_START_ROUTINE routine
,
1336 test_params
*general
, client_params
*par
)
1339 par
->general
= general
;
1340 for ( i
= 1; i
<= min ( general
->n_clients
, MAX_CLIENTS
); i
++ )
1343 thread
[i
] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[i
] );
1344 ok ( thread
[i
] != NULL
, "Failed to create client thread\n" );
1345 /* Make sure the client is up and running */
1346 WaitForSingleObject ( client_ready
[client_id
], INFINITE
);
1350 static void do_test( test_setup
*test
)
1352 DWORD i
, n
= min (test
->general
.n_clients
, MAX_CLIENTS
);
1355 server_ready
= CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1356 for (i
= 0; i
<= n
; i
++)
1357 client_ready
[i
] = CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1359 StartServer ( test
->srv
, &test
->general
, &test
->srv_params
);
1360 StartClients ( test
->clt
, &test
->general
, &test
->clt_params
);
1361 WaitForSingleObject ( server_ready
, INFINITE
);
1363 wait
= WaitForMultipleObjects ( 1 + n
, thread
, TRUE
, 1000 * TEST_TIMEOUT
);
1364 ok ( wait
<= WAIT_OBJECT_0
+ n
,
1365 "some threads have not completed: %x\n", wait
);
1367 if ( ! ( wait
<= WAIT_OBJECT_0
+ n
) )
1369 for (i
= 0; i
<= n
; i
++)
1371 if ( WaitForSingleObject ( thread
[i
], 0 ) != WAIT_OBJECT_0
)
1373 trace ("terminating thread %08x\n", thread_id
[i
]);
1374 TerminateThread ( thread
[i
], 0 );
1378 CloseHandle ( server_ready
);
1379 for (i
= 0; i
<= n
; i
++)
1380 CloseHandle ( client_ready
[i
] );
1383 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1384 /* optname = SO_LINGER */
1385 static const LINGER linger_testvals
[] = {
1392 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1393 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1394 bug in the linux kernel (fixed in 2.6.8) */
1395 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1397 static void test_set_getsockopt(void)
1400 int i
, err
, lasterr
;
1404 WSAPROTOCOL_INFOA infoA
;
1405 WSAPROTOCOL_INFOW infoW
;
1406 char providername
[WSAPROTOCOL_LEN
+ 1];
1410 int family
, type
, proto
;
1412 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
1413 {AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
1414 {AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
},
1415 {AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
}
1423 s
= socket(AF_INET
, SOCK_STREAM
, 0);
1424 ok(s
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1425 if( s
== INVALID_SOCKET
) return;
1427 timeout
= SOCKTIMEOUT1
;
1428 size
= sizeof(timeout
);
1429 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1431 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1432 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1433 ok( timeout
== SOCKTIMEOUT1
, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1436 size
= sizeof(timeout
);
1437 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1439 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1440 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1441 ok( timeout
== 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1444 timeout
= SOCKTIMEOUT2
; /* 997 seconds. See remark above */
1445 size
= sizeof(timeout
);
1446 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, size
);
1448 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, &size
);
1449 ok( !err
, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1450 ok( timeout
== SOCKTIMEOUT2
, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout
);
1454 size
= sizeof(value
);
1455 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDBUF
, (char *)&value
, size
);
1456 ok( !err
, "setsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1458 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDBUF
, (char *)&value
, &size
);
1459 ok( !err
, "getsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1460 todo_wine
ok( value
== 4096, "expected 4096, got %u\n", value
);
1464 size
= sizeof(value
);
1465 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, size
);
1466 ok( !err
, "setsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1468 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, &size
);
1469 ok( !err
, "getsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1470 todo_wine
ok( value
== 4096, "expected 4096, got %u\n", value
);
1473 for( i
= 0; i
< sizeof(linger_testvals
)/sizeof(LINGER
);i
++) {
1474 size
= sizeof(lingval
);
1475 lingval
= linger_testvals
[i
];
1476 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *) &lingval
, size
);
1478 err
= getsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *) &lingval
, &size
);
1479 ok( !err
, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
1480 ok( !lingval
.l_onoff
== !linger_testvals
[i
].l_onoff
&&
1481 (lingval
.l_linger
== linger_testvals
[i
].l_linger
||
1482 (!lingval
.l_linger
&& !linger_testvals
[i
].l_onoff
))
1483 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i
,
1484 lingval
.l_onoff
, lingval
.l_linger
,
1485 linger_testvals
[i
].l_onoff
, linger_testvals
[i
].l_linger
);
1488 size
= sizeof(lingval
);
1489 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, size
);
1490 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1491 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1492 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, 0);
1493 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1494 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1496 size
= sizeof(BOOL
);
1497 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, size
);
1498 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1499 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1500 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, 0);
1501 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1502 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1504 /* Test for erroneously passing a value instead of a pointer as optval */
1505 size
= sizeof(char);
1506 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTROUTE
, (char *)1, size
);
1507 ok(err
== SOCKET_ERROR
, "setsockopt with optval being a value passed "
1508 "instead of failing.\n");
1509 lasterr
= WSAGetLastError();
1510 ok(lasterr
== WSAEFAULT
, "setsockopt with optval being a value "
1511 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1512 lasterr
, WSAEFAULT
);
1514 /* SO_RCVTIMEO with invalid values for level */
1515 size
= sizeof(timeout
);
1516 timeout
= SOCKTIMEOUT1
;
1517 SetLastError(0xdeadbeef);
1518 err
= setsockopt(s
, 0xffffffff, SO_RCVTIMEO
, (char *) &timeout
, size
);
1519 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1520 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1521 err
, WSAGetLastError());
1523 timeout
= SOCKTIMEOUT1
;
1524 SetLastError(0xdeadbeef);
1525 err
= setsockopt(s
, 0x00008000, SO_RCVTIMEO
, (char *) &timeout
, size
);
1526 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1527 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1528 err
, WSAGetLastError());
1530 /* Test SO_ERROR set/get */
1531 SetLastError(0xdeadbeef);
1533 err
= setsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, size
);
1535 ok( !err
&& !WSAGetLastError(),
1536 "got %d with %d (expected 0 with 0)\n",
1537 err
, WSAGetLastError());
1539 SetLastError(0xdeadbeef);
1541 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1543 ok( !err
&& !WSAGetLastError(),
1544 "got %d with %d (expected 0 with 0)\n",
1545 err
, WSAGetLastError());
1547 ok (i
== 1234, "got %d (expected 1234)\n", i
);
1549 /* Test invalid optlen */
1550 SetLastError(0xdeadbeef);
1552 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1554 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEFAULT
),
1555 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1556 err
, WSAGetLastError());
1559 /* Test with the closed socket */
1560 SetLastError(0xdeadbeef);
1563 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1565 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAENOTSOCK
),
1566 "got %d with %d (expected SOCKET_ERROR with WSAENOTSOCK)\n",
1567 err
, WSAGetLastError());
1568 ok (i
== 1234, "expected 1234, got %d\n", i
);
1570 /* Test WS_IP_MULTICAST_TTL with 8, 16, 24 and 32 bits values */
1571 s
= socket(AF_INET
, SOCK_DGRAM
, 0);
1572 ok(s
!= INVALID_SOCKET
, "Failed to create socket\n");
1575 err
= setsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &i
, size
);
1578 for (i
= 0; i
< 4; i
++)
1581 const int tests
[] = {0xffffff0a, 0xffff000b, 0xff00000c, 0x0000000d};
1582 err
= setsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &tests
[i
], i
+ 1);
1583 ok(!err
, "Test [%d] Expected 0, got %d\n", i
, err
);
1584 err
= getsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &k
, &size
);
1585 ok(!err
, "Test [%d] Expected 0, got %d\n", i
, err
);
1586 j
= i
!= 3 ? tests
[i
] & ((1 << (i
+ 1) * 8) - 1) : tests
[i
];
1587 ok(k
== j
, "Test [%d] Expected 0x%x, got 0x%x\n", i
, j
, k
);
1591 win_skip("IP_MULTICAST_TTL is unsupported\n");
1594 /* test SO_PROTOCOL_INFOA invalid parameters */
1595 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1596 "getsockopt should have failed\n");
1597 err
= WSAGetLastError();
1598 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1599 size
= sizeof(WSAPROTOCOL_INFOA
);
1600 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1601 "getsockopt should have failed\n");
1602 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1603 err
= WSAGetLastError();
1604 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1605 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1606 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1607 "getsockopt should have failed\n");
1608 err
= WSAGetLastError();
1609 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1610 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, NULL
),
1611 "getsockopt should have failed\n");
1612 err
= WSAGetLastError();
1613 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1614 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, &size
),
1615 "getsockopt should have failed\n");
1616 err
= WSAGetLastError();
1617 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1618 size
= sizeof(WSAPROTOCOL_INFOA
) / 2;
1619 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1620 "getsockopt should have failed\n");
1621 err
= WSAGetLastError();
1622 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1623 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1624 size
= sizeof(WSAPROTOCOL_INFOA
) * 2;
1625 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1626 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1627 ok(size
== sizeof(WSAPROTOCOL_INFOA
) * 2, "got size %d\n", size
);
1631 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1632 for (i
= 0; i
< sizeof(prottest
) / sizeof(prottest
[0]); i
++)
1636 s
= socket(prottest
[i
].family
, prottest
[i
].type
, prottest
[i
].proto
);
1637 if (s
== INVALID_SOCKET
&& prottest
[i
].family
== AF_INET6
) continue;
1639 ok(s
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
1642 /* compare both A and W version */
1643 infoA
.szProtocol
[0] = 0;
1644 size
= sizeof(WSAPROTOCOL_INFOA
);
1645 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1646 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1647 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1649 infoW
.szProtocol
[0] = 0;
1650 size
= sizeof(WSAPROTOCOL_INFOW
);
1651 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOW
, (char *) &infoW
, &size
);
1652 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1653 ok(size
== sizeof(WSAPROTOCOL_INFOW
), "got size %d\n", size
);
1655 trace("provider name '%s', family %d, type %d, proto %d\n",
1656 infoA
.szProtocol
, prottest
[i
].family
, prottest
[i
].type
, prottest
[i
].proto
);
1658 ok(infoA
.szProtocol
[0], "WSAPROTOCOL_INFOA was not filled\n");
1659 ok(infoW
.szProtocol
[0], "WSAPROTOCOL_INFOW was not filled\n");
1661 WideCharToMultiByte(CP_ACP
, 0, infoW
.szProtocol
, -1,
1662 providername
, sizeof(providername
), NULL
, NULL
);
1663 ok(!strcmp(infoA
.szProtocol
,providername
),
1664 "different provider names '%s' != '%s'\n", infoA
.szProtocol
, providername
);
1666 ok(!memcmp(&infoA
, &infoW
, FIELD_OFFSET(WSAPROTOCOL_INFOA
, szProtocol
)),
1667 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1669 /* Remove IF when WSAEnumProtocols support IPV6 data */
1670 todo_wine_if (prottest
[i
].family
== AF_INET6
)
1671 ok(infoA
.iAddressFamily
== prottest
[i
].family
, "socket family invalid, expected %d received %d\n",
1672 prottest
[i
].family
, infoA
.iAddressFamily
);
1673 ok(infoA
.iSocketType
== prottest
[i
].type
, "socket type invalid, expected %d received %d\n",
1674 prottest
[i
].type
, infoA
.iSocketType
);
1675 ok(infoA
.iProtocol
== prottest
[i
].proto
, "socket protocol invalid, expected %d received %d\n",
1676 prottest
[i
].proto
, infoA
.iProtocol
);
1678 /* IP_HDRINCL is supported only on SOCK_RAW but passed to SOCK_DGRAM by Impossible Creatures */
1681 SetLastError(0xdeadbeef);
1682 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1683 if (err
== -1) /* >= Vista */
1686 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1688 SetLastError(0xdeadbeef);
1689 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1690 ok(err
== -1, "Expected -1, got %d\n", err
);
1691 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1692 ok(k
== 99, "Expected 99, got %d\n", k
);
1696 SetLastError(0xdeadbeef);
1697 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1699 ok(err
== -1, "Expected -1, got %d\n", err
);
1701 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1703 SetLastError(0xdeadbeef);
1704 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1705 ok(err
== -1, "Expected -1, got %d\n", err
);
1706 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1707 ok(k
== 99, "Expected 99, got %d\n", k
);
1710 else /* <= 2003 the tests differ between TCP and UDP, UDP silently accepts */
1712 SetLastError(0xdeadbeef);
1714 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1715 if (prottest
[i
].type
== SOCK_DGRAM
)
1717 ok(err
== 0, "Expected 0, got %d\n", err
);
1718 ok(k
== 1, "Expected 1, got %d\n", k
);
1722 /* contratry to what we could expect the function returns error but k is changed */
1723 ok(err
== -1, "Expected -1, got %d\n", err
);
1724 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %d\n", GetLastError());
1725 ok(k
== 0, "Expected 0, got %d\n", k
);
1729 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1730 ok(err
== 0, "Expected 0, got %d\n", err
);
1733 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1734 if (prottest
[i
].type
== SOCK_DGRAM
)
1736 ok(err
== 0, "Expected 0, got %d\n", err
);
1737 ok(k
== 0, "Expected 0, got %d\n", k
);
1741 /* contratry to what we could expect the function returns error but k is changed */
1742 ok(err
== -1, "Expected -1, got %d\n", err
);
1743 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %d\n", GetLastError());
1744 ok(k
== 0, "Expected 0, got %d\n", k
);
1751 /* Test SO_BSP_STATE - Present only in >= Win 2008 */
1752 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1753 ok(s
!= INVALID_SOCKET
, "Failed to create socket\n");
1754 s2
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1755 ok(s2
!= INVALID_SOCKET
, "Failed to create socket\n");
1757 SetLastError(0xdeadbeef);
1758 size
= sizeof(csinfoA
);
1759 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1762 struct sockaddr_in saddr
;
1763 memset(&saddr
, 0, sizeof(saddr
));
1764 saddr
.sin_family
= AF_INET
;
1765 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1767 /* Socket is not bound, no information provided */
1768 ok(!csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1769 ok(csinfoA
.cs
.LocalAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.LocalAddr
.lpSockaddr
);
1770 /* Socket is not connected, no information provided */
1771 ok(!csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1772 ok(csinfoA
.cs
.RemoteAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.LocalAddr
.lpSockaddr
);
1774 err
= bind(s
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1775 ok(!err
, "Expected 0, got %d\n", err
);
1776 size
= sizeof(csinfoA
);
1777 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1778 ok(!err
, "Expected 0, got %d\n", err
);
1780 /* Socket is bound */
1781 ok(csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected non-zero\n");
1782 ok(csinfoA
.cs
.LocalAddr
.lpSockaddr
!= NULL
, "Expected non-null\n");
1783 /* Socket is not connected, no information provided */
1784 ok(!csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1785 ok(csinfoA
.cs
.RemoteAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.LocalAddr
.lpSockaddr
);
1787 err
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1788 ok(!err
, "Expected 0, got %d\n", err
);
1789 err
= getsockname(s2
, (struct sockaddr
*)&saddr
, &size
);
1790 ok(!err
, "Expected 0, got %d\n", err
);
1791 err
= listen(s2
, 1);
1792 ok(!err
, "Expected 0, got %d\n", err
);
1793 err
= connect(s
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1794 ok(!err
, "Expected 0, got %d\n", err
);
1795 size
= sizeof(saddr
);
1796 err
= accept(s2
, (struct sockaddr
*)&saddr
, &size
);
1797 ok(err
!= INVALID_SOCKET
, "Failed to accept socket\n");
1801 size
= sizeof(csinfoA
);
1802 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1803 ok(!err
, "Expected 0, got %d\n", err
);
1804 err
= getsockopt(s2
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoB
, &size
);
1805 ok(!err
, "Expected 0, got %d\n", err
);
1806 ok(size
== sizeof(csinfoA
), "Got %d\n", size
);
1807 size
= sizeof(saddr
);
1808 ok(size
== csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected %d, got %d\n", size
,
1809 csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1810 ok(size
== csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected %d, got %d\n", size
,
1811 csinfoA
.cs
.RemoteAddr
.iSockaddrLength
);
1812 ok(!memcmp(csinfoA
.cs
.LocalAddr
.lpSockaddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
),
1813 "Expected matching addresses\n");
1814 ok(!memcmp(csinfoB
.cs
.LocalAddr
.lpSockaddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
),
1815 "Expected matching addresses\n");
1816 ok(csinfoA
.cs
.iSocketType
== SOCK_STREAM
, "Wrong socket type\n");
1817 ok(csinfoB
.cs
.iSocketType
== SOCK_STREAM
, "Wrong socket type\n");
1818 ok(csinfoA
.cs
.iProtocol
== IPPROTO_TCP
, "Wrong socket protocol\n");
1819 ok(csinfoB
.cs
.iProtocol
== IPPROTO_TCP
, "Wrong socket protocol\n");
1821 err
= getpeername(s
, (struct sockaddr
*)&saddr
, &size
);
1822 ok(!err
, "Expected 0, got %d\n", err
);
1823 ok(!memcmp(&saddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1824 ok(!memcmp(&saddr
, csinfoB
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1825 err
= getpeername(s2
, (struct sockaddr
*)&saddr
, &size
);
1826 ok(!err
, "Expected 0, got %d\n", err
);
1827 ok(!memcmp(&saddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1828 ok(!memcmp(&saddr
, csinfoA
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1829 err
= getsockname(s
, (struct sockaddr
*)&saddr
, &size
);
1830 ok(!err
, "Expected 0, got %d\n", err
);
1831 ok(!memcmp(&saddr
, csinfoA
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1832 ok(!memcmp(&saddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1833 err
= getsockname(s2
, (struct sockaddr
*)&saddr
, &size
);
1834 ok(!err
, "Expected 0, got %d\n", err
);
1835 ok(!memcmp(&saddr
, csinfoB
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1836 ok(!memcmp(&saddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1838 SetLastError(0xdeadbeef);
1839 size
= sizeof(CSADDR_INFO
);
1840 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1841 ok(err
, "Expected non-zero\n");
1842 ok(size
== sizeof(CSADDR_INFO
), "Got %d\n", size
);
1843 ok(GetLastError() == WSAEFAULT
, "Expected 10014, got %d\n", GetLastError());
1845 /* At least for IPv4 the size is exactly 56 bytes */
1846 size
= sizeof(*csinfoA
.cs
.LocalAddr
.lpSockaddr
) * 2 + sizeof(csinfoA
.cs
);
1847 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1848 ok(!err
, "Expected 0, got %d\n", err
);
1850 SetLastError(0xdeadbeef);
1851 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1852 ok(err
, "Expected non-zero\n");
1853 ok(GetLastError() == WSAEFAULT
, "Expected 10014, got %d\n", GetLastError());
1856 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %d\n", GetLastError());
1861 for (i
= 0; i
< 2; i
++)
1868 level
= IPPROTO_IPV6
;
1876 s
= socket(family
, SOCK_DGRAM
, 0);
1877 if (s
== INVALID_SOCKET
&& i
)
1879 skip("IPv6 is not supported\n");
1882 ok(s
!= INVALID_SOCKET
, "socket failed with error %d\n", GetLastError());
1884 size
= sizeof(value
);
1886 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1887 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1888 ok(value
== 0, "Expected 0, got %d\n", value
);
1890 size
= sizeof(value
);
1892 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
1893 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1896 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1897 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1898 ok(value
== 1, "Expected 1, got %d\n", value
);
1900 size
= sizeof(value
);
1902 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
1903 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1905 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1906 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1907 ok(value
== 1, "Expected 1, got %d\n", value
);
1913 static void test_so_reuseaddr(void)
1915 struct sockaddr_in saddr
;
1917 unsigned int rc
,reuse
;
1921 saddr
.sin_family
= AF_INET
;
1922 saddr
.sin_port
= htons(SERVERPORT
+1);
1923 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1925 s1
=socket(AF_INET
, SOCK_STREAM
, 0);
1926 ok(s1
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1927 rc
= bind(s1
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1928 ok(rc
!=SOCKET_ERROR
, "bind(s1) failed error: %d\n", WSAGetLastError());
1930 s2
=socket(AF_INET
, SOCK_STREAM
, 0);
1931 ok(s2
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1935 rc
=getsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, &size
);
1936 ok(rc
==0 && reuse
==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc
,reuse
);
1938 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1939 ok(rc
==SOCKET_ERROR
, "bind() succeeded\n");
1942 rc
= setsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
1943 ok(rc
==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1945 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1946 * a port immediately after closing another socket on that port, so
1947 * basically following the BSD socket semantics here. */
1948 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1951 int s3
=socket(AF_INET
, SOCK_STREAM
, 0), s4
;
1952 trace("<= Win XP behavior of SO_REUSEADDR\n");
1954 /* If we could bind again in the same port this is Windows version <= XP.
1955 * Lets test if we can really connect to one of them. */
1956 set_blocking(s1
, FALSE
);
1957 set_blocking(s2
, FALSE
);
1959 ok(!rc
, "listen() failed with error: %d\n", WSAGetLastError());
1961 ok(!rc
, "listen() failed with error: %d\n", WSAGetLastError());
1962 rc
= connect(s3
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1963 ok(!rc
, "connecting to accepting socket failed %d\n", WSAGetLastError());
1965 /* the delivery of the connection is random so we need to try on both sockets */
1966 size
= sizeof(saddr
);
1967 s4
= accept(s1
, (struct sockaddr
*)&saddr
, &size
);
1968 if(s4
== INVALID_SOCKET
)
1969 s4
= accept(s2
, (struct sockaddr
*)&saddr
, &size
);
1970 ok(s4
!= INVALID_SOCKET
, "none of the listening sockets could get the connection\n");
1978 trace(">= Win 2003 behavior of SO_REUSEADDR\n");
1979 err
= WSAGetLastError();
1980 ok(err
==WSAEACCES
, "expected 10013, got %d\n", err
);
1983 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1984 ok(rc
==0, "bind() failed error: %d\n", WSAGetLastError());
1990 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
1992 static void test_ip_pktinfo(void)
1994 ULONG addresses
[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY
)};
1995 char recvbuf
[10], pktbuf
[512], msg
[] = "HELLO";
1996 struct sockaddr_in s1addr
, s2addr
, s3addr
;
1997 GUID WSARecvMsg_GUID
= WSAID_WSARECVMSG
;
1998 LPFN_WSARECVMSG pWSARecvMsg
= NULL
;
1999 unsigned int rc
, yes
= 1;
2001 DWORD dwBytes
, dwSize
, dwFlags
;
2010 memset(&ov
, 0, sizeof(ov
));
2011 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
2012 if (ov
.hEvent
== INVALID_HANDLE_VALUE
)
2014 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
2018 memset(&hdr
, 0x00, sizeof(hdr
));
2019 s1addr
.sin_family
= AF_INET
;
2020 s1addr
.sin_port
= htons(0);
2021 /* Note: s1addr.sin_addr is set below */
2022 iovec
[0].buf
= recvbuf
;
2023 iovec
[0].len
= sizeof(recvbuf
);
2024 hdr
.name
= (struct sockaddr
*)&s3addr
;
2025 hdr
.namelen
= sizeof(s3addr
);
2026 hdr
.lpBuffers
= &iovec
[0];
2027 hdr
.dwBufferCount
= 1;
2028 hdr
.Control
.buf
= pktbuf
;
2029 /* Note: hdr.Control.len is set below */
2032 for (i
=0;i
<sizeof(addresses
)/sizeof(UINT32
);i
++)
2034 s1addr
.sin_addr
.s_addr
= addresses
[i
];
2036 /* Build "server" side socket */
2037 s1
=socket(AF_INET
, SOCK_DGRAM
, 0);
2038 if (s1
== INVALID_SOCKET
)
2040 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
2044 /* Obtain the WSARecvMsg function */
2045 WSAIoctl(s1
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSARecvMsg_GUID
, sizeof(WSARecvMsg_GUID
),
2046 &pWSARecvMsg
, sizeof(pWSARecvMsg
), &dwBytes
, NULL
, NULL
);
2049 win_skip("WSARecvMsg is unsupported, some tests will be skipped.\n");
2054 /* Setup the server side socket */
2055 rc
=bind(s1
, (struct sockaddr
*)&s1addr
, sizeof(s1addr
));
2056 ok(rc
!= SOCKET_ERROR
, "bind() failed error: %d\n", WSAGetLastError());
2057 rc
=setsockopt(s1
, IPPROTO_IP
, IP_PKTINFO
, (const char*)&yes
, sizeof(yes
));
2058 ok(rc
== 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
2060 /* Build "client" side socket */
2061 addrlen
= sizeof(s2addr
);
2062 if (getsockname(s1
, (struct sockaddr
*) &s2addr
, &addrlen
) != 0)
2064 skip("Failed to call getsockname, some tests skipped: %d\n", WSAGetLastError());
2068 s2addr
.sin_addr
.s_addr
= addresses
[0]; /* Always target the local adapter address */
2069 s2
=socket(AF_INET
, SOCK_DGRAM
, 0);
2070 if (s2
== INVALID_SOCKET
)
2072 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
2077 /* Test an empty message header */
2078 rc
=pWSARecvMsg(s1
, NULL
, NULL
, NULL
, NULL
);
2079 err
=WSAGetLastError();
2080 ok(rc
== SOCKET_ERROR
&& err
== WSAEFAULT
, "WSARecvMsg() failed error: %d (ret = %d)\n", err
, rc
);
2083 * Send a packet from the client to the server and test for specifying
2084 * a short control header.
2086 SetLastError(0xdeadbeef);
2087 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
2088 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
2089 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
2090 hdr
.Control
.len
= 1;
2091 rc
=pWSARecvMsg(s1
, &hdr
, &dwSize
, NULL
, NULL
);
2092 err
=WSAGetLastError();
2093 ok(rc
== SOCKET_ERROR
&& err
== WSAEMSGSIZE
&& (hdr
.dwFlags
& MSG_CTRUNC
),
2094 "WSARecvMsg() failed error: %d (ret: %d, flags: %d)\n", err
, rc
, hdr
.dwFlags
);
2095 hdr
.dwFlags
= 0; /* Reset flags */
2097 /* Perform another short control header test, this time with an overlapped receive */
2098 hdr
.Control
.len
= 1;
2099 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
2100 err
=WSAGetLastError();
2101 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
2102 SetLastError(0xdeadbeef);
2103 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
2104 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
2105 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
2106 if (WaitForSingleObject(ov
.hEvent
, 100) != WAIT_OBJECT_0
)
2108 skip("Server side did not receive packet, some tests skipped.\n");
2114 WSAGetOverlappedResult(s1
, &ov
, NULL
, FALSE
, &dwFlags
);
2116 "WSAGetOverlappedResult() returned unexpected flags %d!\n", dwFlags
);
2117 ok(hdr
.dwFlags
== MSG_CTRUNC
,
2118 "WSARecvMsg() overlapped operation set unexpected flags %d.\n", hdr
.dwFlags
);
2119 hdr
.dwFlags
= 0; /* Reset flags */
2122 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
2123 * on the server end and check that the returned packet matches what was sent.
2125 hdr
.Control
.len
= sizeof(pktbuf
);
2126 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
2127 err
=WSAGetLastError();
2128 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
2129 ok(hdr
.Control
.len
== sizeof(pktbuf
),
2130 "WSARecvMsg() control length mismatch (%d != sizeof pktbuf).\n", hdr
.Control
.len
);
2131 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
2132 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
2133 if (WaitForSingleObject(ov
.hEvent
, 100) != WAIT_OBJECT_0
)
2135 skip("Server side did not receive packet, some tests skipped.\n");
2141 WSAGetOverlappedResult(s1
, &ov
, &dwSize
, FALSE
, NULL
);
2142 ok(dwSize
== sizeof(msg
),
2143 "WSARecvMsg() buffer length does not match transmitted data!\n");
2144 ok(strncmp(iovec
[0].buf
, msg
, sizeof(msg
)) == 0,
2145 "WSARecvMsg() buffer does not match transmitted data!\n");
2146 ok(hdr
.Control
.len
== IP_PKTINFO_LEN
,
2147 "WSARecvMsg() control length mismatch (%d).\n", hdr
.Control
.len
);
2149 /* Test for the expected IP_PKTINFO return information. */
2151 for (cmsg
= WSA_CMSG_FIRSTHDR(&hdr
); cmsg
!= NULL
; cmsg
= WSA_CMSG_NXTHDR(&hdr
, cmsg
))
2153 if (cmsg
->cmsg_level
== IPPROTO_IP
&& cmsg
->cmsg_type
== IP_PKTINFO
)
2155 struct in_pktinfo
*pi
= (struct in_pktinfo
*)WSA_CMSG_DATA(cmsg
);
2157 ok(pi
->ipi_addr
.s_addr
== s2addr
.sin_addr
.s_addr
, "destination ip mismatch!\n");
2161 ok(foundhdr
, "IP_PKTINFO header information was not returned!\n");
2168 CloseHandle(ov
.hEvent
);
2171 /************* Array containing the tests to run **********/
2173 #define STD_STREAM_SOCKET \
2179 static test_setup tests
[] =
2181 /* Test 0: synchronous client and server */
2202 /* Test 1: event-driven client, synchronous server */
2219 WSA_FLAG_OVERLAPPED
,
2223 /* Test 2: synchronous client, non-blocking server via select() */
2244 /* Test 3: OOB client, OOB server */
2265 /* Test 4: synchronous mixed client and server */
2279 simple_mixed_client
,
2288 static void test_UDP(void)
2290 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
2291 possible that this test fails due to dropped packets. */
2293 /* peer 0 receives data from all other peers */
2294 struct sock_info peer
[NUM_UDP_PEERS
];
2296 int ss
, i
, n_recv
, n_sent
;
2298 memset (buf
,0,sizeof(buf
));
2299 for ( i
= NUM_UDP_PEERS
- 1; i
>= 0; i
-- ) {
2300 ok ( ( peer
[i
].s
= socket ( AF_INET
, SOCK_DGRAM
, 0 ) ) != INVALID_SOCKET
, "UDP: socket failed\n" );
2302 peer
[i
].addr
.sin_family
= AF_INET
;
2303 peer
[i
].addr
.sin_addr
.s_addr
= inet_addr ( SERVERIP
);
2306 peer
[i
].addr
.sin_port
= htons ( SERVERPORT
);
2308 peer
[i
].addr
.sin_port
= htons ( 0 );
2311 do_bind ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, sizeof( peer
[i
].addr
) );
2313 /* test getsockname() to get peer's port */
2314 ss
= sizeof ( peer
[i
].addr
);
2315 ok ( getsockname ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, &ss
) != SOCKET_ERROR
, "UDP: could not getsockname()\n" );
2316 ok ( peer
[i
].addr
.sin_port
!= htons ( 0 ), "UDP: bind() did not associate port\n" );
2319 /* test getsockname() */
2320 ok ( peer
[0].addr
.sin_port
== htons ( SERVERPORT
), "UDP: getsockname returned incorrect peer port\n" );
2322 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
2323 /* send client's ip */
2324 memcpy( buf
, &peer
[i
].addr
.sin_port
, sizeof(peer
[i
].addr
.sin_port
) );
2325 n_sent
= sendto ( peer
[i
].s
, buf
, sizeof(buf
), 0, (struct sockaddr
*) &peer
[0].addr
, sizeof(peer
[0].addr
) );
2326 ok ( n_sent
== sizeof(buf
), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent
);
2329 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
2330 n_recv
= recvfrom ( peer
[0].s
, buf
, sizeof(buf
), 0,(struct sockaddr
*) &peer
[0].peer
, &ss
);
2331 ok ( n_recv
== sizeof(buf
), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv
);
2332 ok ( memcmp ( &peer
[0].peer
.sin_port
, buf
, sizeof(peer
[0].addr
.sin_port
) ) == 0, "UDP: port numbers do not match\n" );
2336 static DWORD WINAPI
do_getservbyname( void *param
)
2342 } serv
[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
2344 HANDLE
*starttest
= param
;
2346 struct servent
*pserv
[2];
2348 ok ( WaitForSingleObject ( *starttest
, TEST_TIMEOUT
* 1000 ) != WAIT_TIMEOUT
,
2349 "test_getservbyname: timeout waiting for start signal\n" );
2351 /* ensure that necessary buffer resizes are completed */
2352 for ( j
= 0; j
< 2; j
++) {
2353 pserv
[j
] = getservbyname ( serv
[j
].name
, serv
[j
].proto
);
2356 for ( i
= 0; i
< NUM_QUERIES
/ 2; i
++ ) {
2357 for ( j
= 0; j
< 2; j
++ ) {
2358 pserv
[j
] = getservbyname ( serv
[j
].name
, serv
[j
].proto
);
2359 ok ( pserv
[j
] != NULL
|| broken(pserv
[j
] == NULL
) /* win8, fixed in win81 */,
2360 "getservbyname could not retrieve information for %s: %d\n", serv
[j
].name
, WSAGetLastError() );
2361 if ( !pserv
[j
] ) continue;
2362 ok ( pserv
[j
]->s_port
== htons(serv
[j
].port
),
2363 "getservbyname returned the wrong port for %s: %d\n", serv
[j
].name
, ntohs(pserv
[j
]->s_port
) );
2364 ok ( !strcmp ( pserv
[j
]->s_proto
, serv
[j
].proto
),
2365 "getservbyname returned the wrong protocol for %s: %s\n", serv
[j
].name
, pserv
[j
]->s_proto
);
2366 ok ( !strcmp ( pserv
[j
]->s_name
, serv
[j
].name
),
2367 "getservbyname returned the wrong name for %s: %s\n", serv
[j
].name
, pserv
[j
]->s_name
);
2370 ok ( pserv
[0] == pserv
[1] || broken(pserv
[0] != pserv
[1]) /* win8, fixed in win81 */,
2371 "getservbyname: winsock resized servent buffer when not necessary\n" );
2377 static void test_getservbyname(void)
2380 HANDLE starttest
, thread
[NUM_THREADS
];
2381 DWORD thread_id
[NUM_THREADS
];
2383 starttest
= CreateEventA ( NULL
, 1, 0, "test_getservbyname_starttest" );
2385 /* create threads */
2386 for ( i
= 0; i
< NUM_THREADS
; i
++ ) {
2387 thread
[i
] = CreateThread ( NULL
, 0, do_getservbyname
, &starttest
, 0, &thread_id
[i
] );
2390 /* signal threads to start */
2391 SetEvent ( starttest
);
2393 for ( i
= 0; i
< NUM_THREADS
; i
++) {
2394 WaitForSingleObject ( thread
[i
], TEST_TIMEOUT
* 1000 );
2398 static void test_WSASocket(void)
2400 SOCKET sock
= INVALID_SOCKET
;
2401 WSAPROTOCOL_INFOA
*pi
;
2402 int wsaproviders
[] = {IPPROTO_TCP
, IPPROTO_IP
};
2403 int autoprotocols
[] = {IPPROTO_TCP
, IPPROTO_UDP
};
2404 int items
, err
, size
, socktype
, i
, j
;
2407 SetLastError(0xdeadbeef);
2408 ok(WSASocketA(0, 0, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2409 "WSASocketA should have failed\n");
2410 err
= WSAGetLastError();
2411 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
2413 sock
= WSASocketA(AF_INET
, 0, 0, NULL
, 0, 0);
2414 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2417 sock
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, NULL
, 0, 0);
2418 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2421 SetLastError(0xdeadbeef);
2422 ok(WSASocketA(0, SOCK_STREAM
, -1, NULL
, 0, 0) == INVALID_SOCKET
,
2423 "WSASocketA should have failed\n");
2424 err
= WSAGetLastError();
2425 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2427 SetLastError(0xdeadbeef);
2428 ok(WSASocketA(0, -1, IPPROTO_UDP
, NULL
, 0, 0) == INVALID_SOCKET
,
2429 "WSASocketA should have failed\n");
2430 err
= WSAGetLastError();
2431 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
2433 SetLastError(0xdeadbeef);
2434 ok(WSASocketA(0, -1, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2435 "WSASocketA should have failed\n");
2436 err
= WSAGetLastError();
2437 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
2439 SetLastError(0xdeadbeef);
2440 ok(WSASocketA(AF_INET
, -1, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2441 "WSASocketA should have failed\n");
2442 err
= WSAGetLastError();
2443 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
2445 SetLastError(0xdeadbeef);
2446 ok(WSASocketA(AF_INET
, 0, -1, NULL
, 0, 0) == INVALID_SOCKET
,
2447 "WSASocketA should have failed\n");
2448 err
= WSAGetLastError();
2449 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2451 SetLastError(0xdeadbeef);
2452 ok(WSASocketA(0, -1, -1, NULL
, 0, 0) == INVALID_SOCKET
,
2453 "WSASocketA should have failed\n");
2454 err
= WSAGetLastError();
2455 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
2457 SetLastError(0xdeadbeef);
2458 ok(WSASocketA(-1, SOCK_STREAM
, IPPROTO_UDP
, NULL
, 0, 0) == INVALID_SOCKET
,
2459 "WSASocketA should have failed\n");
2460 err
= WSAGetLastError();
2461 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
2463 sock
= WSASocketA(AF_INET
, 0, IPPROTO_TCP
, NULL
, 0, 0);
2464 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2467 SetLastError(0xdeadbeef);
2468 ok(WSASocketA(0, SOCK_STREAM
, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2469 "WSASocketA should have failed\n");
2470 err
= WSAGetLastError();
2471 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
2473 SetLastError(0xdeadbeef);
2474 ok(WSASocketA(0, 0, 0xdead, NULL
, 0, 0) == INVALID_SOCKET
,
2475 "WSASocketA should have failed\n");
2476 err
= WSAGetLastError();
2477 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2479 SetLastError(0xdeadbeef);
2480 ok(WSASocketA(AF_INET
, 0xdead, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2481 "WSASocketA should have failed\n");
2482 err
= WSAGetLastError();
2483 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
2485 SetLastError(0xdeadbeef);
2486 ok(WSASocketA(0, 0xdead, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2487 "WSASocketA should have failed\n");
2488 err
= WSAGetLastError();
2489 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
2491 sock
= WSASocketA(0, 0, IPPROTO_TCP
, NULL
, 0, 0);
2492 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2495 /* SOCK_STREAM does not support IPPROTO_UDP */
2496 SetLastError(0xdeadbeef);
2497 ok(WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_UDP
, NULL
, 0, 0) == INVALID_SOCKET
,
2498 "WSASocketA should have failed\n");
2499 err
= WSAGetLastError();
2500 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2502 /* SOCK_DGRAM does not support IPPROTO_TCP */
2503 SetLastError(0xdeadbeef);
2504 ok(WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_TCP
, NULL
, 0, 0) == INVALID_SOCKET
,
2505 "WSASocketA should have failed\n");
2506 err
= WSAGetLastError();
2507 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2509 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
2510 * to avoid a crash on win98.
2513 items
= WSAEnumProtocolsA(wsaproviders
, NULL
, &pi_size
);
2514 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
2516 err
= WSAGetLastError();
2517 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2520 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
2521 ok(pi
!= NULL
, "Failed to allocate memory\n");
2523 skip("Can't continue without memory.\n");
2527 items
= WSAEnumProtocolsA(wsaproviders
, pi
, &pi_size
);
2528 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
2532 skip("No protocols enumerated.\n");
2533 HeapFree(GetProcessHeap(), 0, pi
);
2537 sock
= WSASocketA(FROM_PROTOCOL_INFO
, FROM_PROTOCOL_INFO
,
2538 FROM_PROTOCOL_INFO
, &pi
[0], 0, 0);
2539 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2543 /* find what parameters are used first: plain parameters or protocol info struct */
2544 pi
[0].iProtocol
= -1;
2545 pi
[0].iSocketType
= -1;
2546 pi
[0].iAddressFamily
= -1;
2547 ok(WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0) == INVALID_SOCKET
,
2548 "WSASocketA should have failed\n");
2549 err
= WSAGetLastError();
2550 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
2552 pi
[0].iProtocol
= 0;
2553 pi
[0].iSocketType
= 0;
2554 pi
[0].iAddressFamily
= 0;
2555 sock
= WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0);
2556 if(sock
!= INVALID_SOCKET
)
2558 win_skip("must work only in OS <= 2003\n");
2563 err
= WSAGetLastError();
2564 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
2567 pi
[0].iProtocol
= IPPROTO_UDP
;
2568 pi
[0].iSocketType
= SOCK_DGRAM
;
2569 pi
[0].iAddressFamily
= AF_INET
;
2570 sock
= WSASocketA(0, 0, 0, &pi
[0], 0, 0);
2571 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2573 size
= sizeof(socktype
);
2575 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2576 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2577 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2578 SOCK_DGRAM
, socktype
);
2581 sock
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, &pi
[0], 0, 0);
2582 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2584 size
= sizeof(socktype
);
2586 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2587 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2588 ok(socktype
== SOCK_STREAM
, "Wrong socket type, expected %d received %d\n",
2589 SOCK_STREAM
, socktype
);
2592 HeapFree(GetProcessHeap(), 0, pi
);
2595 items
= WSAEnumProtocolsA(NULL
, NULL
, &pi_size
);
2596 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
2598 err
= WSAGetLastError();
2599 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2602 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
2603 ok(pi
!= NULL
, "Failed to allocate memory\n");
2605 skip("Can't continue without memory.\n");
2609 items
= WSAEnumProtocolsA(NULL
, pi
, &pi_size
);
2610 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
2613 /* when no protocol and socket type are specified the first entry
2614 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
2616 sock
= WSASocketA(AF_INET
, 0, 0, NULL
, 0, 0);
2617 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2620 size
= sizeof(socktype
);
2622 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2623 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2624 for(i
= 0; i
< items
; i
++)
2626 if(pi
[i
].dwProviderFlags
& PFL_MATCHES_PROTOCOL_ZERO
)
2628 ok(socktype
== pi
[i
].iSocketType
, "Wrong socket type, expected %d received %d\n",
2629 pi
[i
].iSocketType
, socktype
);
2633 ok(i
!= items
, "Creating a socket without protocol and socket type didn't work\n");
2636 /* when no socket type is specified the first entry from WSAEnumProtocols
2637 * that matches the protocol is returned */
2638 for (i
= 0; i
< sizeof(autoprotocols
) / sizeof(autoprotocols
[0]); i
++)
2640 sock
= WSASocketA(0, 0, autoprotocols
[i
], NULL
, 0, 0);
2641 ok(sock
!= INVALID_SOCKET
, "Failed to create socket for protocol %d, received %d\n",
2642 autoprotocols
[i
], WSAGetLastError());
2644 size
= sizeof(socktype
);
2646 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2647 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2649 for (err
= 1, j
= 0; j
< items
; j
++)
2651 if (pi
[j
].iProtocol
== autoprotocols
[i
])
2653 if (socktype
== pi
[j
].iSocketType
)
2656 ok(0, "Wrong socket type, expected %d received %d\n",
2657 pi
[j
].iSocketType
, socktype
);
2661 ok(!err
, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols
[i
]);
2666 HeapFree(GetProcessHeap(), 0, pi
);
2668 SetLastError(0xdeadbeef);
2669 /* starting on vista the socket function returns error during the socket
2670 creation and no longer in the socket operations (sendto, readfrom) */
2671 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_ICMP
, NULL
, 0, 0);
2672 if (sock
== INVALID_SOCKET
)
2674 err
= WSAGetLastError();
2675 ok(err
== WSAEACCES
, "Expected 10013, received %d\n", err
);
2676 skip("SOCK_RAW is not supported\n");
2680 trace("SOCK_RAW is supported\n");
2682 size
= sizeof(socktype
);
2684 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2685 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2686 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2687 SOCK_RAW
, socktype
);
2691 sock
= WSASocketA(0, 0, IPPROTO_RAW
, NULL
, 0, 0);
2692 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2694 size
= sizeof(socktype
);
2696 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2697 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2698 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2699 SOCK_RAW
, socktype
);
2703 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_TCP
, NULL
, 0, 0);
2704 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2706 size
= sizeof(socktype
);
2708 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2709 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2710 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2711 SOCK_RAW
, socktype
);
2715 /* IPX socket tests */
2717 SetLastError(0xdeadbeef);
2718 sock
= WSASocketA(AF_IPX
, SOCK_DGRAM
, NSPROTO_IPX
, NULL
, 0, 0);
2719 if (sock
== INVALID_SOCKET
)
2721 err
= WSAGetLastError();
2722 ok(err
== WSAEAFNOSUPPORT
|| broken(err
== WSAEPROTONOSUPPORT
), "Expected 10047, received %d\n", err
);
2723 skip("IPX is not supported\n");
2727 WSAPROTOCOL_INFOA info
;
2730 trace("IPX is supported\n");
2732 sock
= WSASocketA(0, 0, NSPROTO_IPX
, NULL
, 0, 0);
2733 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2736 size
= sizeof(socktype
);
2738 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2739 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2740 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2741 SOCK_DGRAM
, socktype
);
2743 /* check socket family, type and protocol */
2744 size
= sizeof(WSAPROTOCOL_INFOA
);
2745 err
= getsockopt(sock
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &info
, &size
);
2746 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2747 ok(info
.iProtocol
== NSPROTO_IPX
, "expected protocol %d, received %d\n",
2748 NSPROTO_IPX
, info
.iProtocol
);
2749 ok(info
.iAddressFamily
== AF_IPX
, "expected family %d, received %d\n",
2750 AF_IPX
, info
.iProtocol
);
2751 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
2752 SOCK_DGRAM
, info
.iSocketType
);
2755 /* SOCK_STREAM does not support NSPROTO_IPX */
2756 SetLastError(0xdeadbeef);
2757 ok(WSASocketA(AF_IPX
, SOCK_STREAM
, NSPROTO_IPX
, NULL
, 0, 0) == INVALID_SOCKET
,
2758 "WSASocketA should have failed\n");
2759 err
= WSAGetLastError();
2760 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2762 /* test extended IPX support - that is adding any number between 0 and 255
2763 * to the IPX protocol value will make it be used as IPX packet type */
2764 for(i
= 0;i
<= 255;i
+= 17)
2766 SetLastError(0xdeadbeef);
2767 sock
= WSASocketA(0, 0, NSPROTO_IPX
+ i
, NULL
, 0, 0);
2768 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2773 err
= getsockopt(sock
, NSPROTO_IPX
, IPX_PTYPE
, (char *) &socktype
, &size
);
2774 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2775 ok(socktype
== i
, "Wrong IPX packet type, expected %d received %d\n",
2783 static void test_WSADuplicateSocket(void)
2785 SOCKET source
, dupsock
;
2786 WSAPROTOCOL_INFOA info
;
2788 struct sockaddr_in addr
;
2789 int socktype
, size
, addrsize
, ret
;
2790 char teststr
[] = "TEST", buffer
[16];
2792 source
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
2793 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2795 /* test invalid parameters */
2796 SetLastError(0xdeadbeef);
2797 ok(WSADuplicateSocketA(0, 0, NULL
), "WSADuplicateSocketA should have failed\n");
2798 err
= WSAGetLastError();
2799 ok(err
== WSAENOTSOCK
, "expected 10038, received %d\n", err
);
2801 SetLastError(0xdeadbeef);
2802 ok(WSADuplicateSocketA(source
, 0, NULL
),
2803 "WSADuplicateSocketA should have failed\n");
2804 err
= WSAGetLastError();
2805 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2807 SetLastError(0xdeadbeef);
2808 ok(WSADuplicateSocketA(source
, ~0, &info
),
2809 "WSADuplicateSocketA should have failed\n");
2810 err
= WSAGetLastError();
2811 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2813 SetLastError(0xdeadbeef);
2814 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info
),
2815 "WSADuplicateSocketA should have failed\n");
2816 err
= WSAGetLastError();
2817 ok(err
== WSAENOTSOCK
, "expected 10038, received %d\n", err
);
2819 SetLastError(0xdeadbeef);
2820 ok(WSADuplicateSocketA(source
, GetCurrentProcessId(), NULL
),
2821 "WSADuplicateSocketA should have failed\n");
2822 err
= WSAGetLastError();
2823 ok(err
== WSAEFAULT
, "expected 10014, received %d\n", err
);
2825 /* test returned structure */
2826 memset(&info
, 0, sizeof(info
));
2827 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2828 "WSADuplicateSocketA should have worked\n");
2830 ok(info
.iProtocol
== IPPROTO_TCP
, "expected protocol %d, received %d\n",
2831 IPPROTO_TCP
, info
.iProtocol
);
2832 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
2833 AF_INET
, info
.iProtocol
);
2834 ok(info
.iSocketType
== SOCK_STREAM
, "expected type %d, received %d\n",
2835 SOCK_STREAM
, info
.iSocketType
);
2837 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2838 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2840 closesocket(dupsock
);
2841 closesocket(source
);
2843 /* create a socket, bind it, duplicate it then send data on source and
2844 * receive in the duplicated socket */
2845 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
2846 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2848 memset(&info
, 0, sizeof(info
));
2849 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2850 "WSADuplicateSocketA should have worked\n");
2852 ok(info
.iProtocol
== IPPROTO_UDP
, "expected protocol %d, received %d\n",
2853 IPPROTO_UDP
, info
.iProtocol
);
2854 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
2855 AF_INET
, info
.iProtocol
);
2856 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
2857 SOCK_DGRAM
, info
.iSocketType
);
2859 memset(&addr
, 0, sizeof(addr
));
2860 addr
.sin_family
= AF_INET
;
2861 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2862 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
2863 "bind should have worked\n");
2865 /* read address to find out the port number to be used in sendto */
2866 memset(&addr
, 0, sizeof(addr
));
2867 addrsize
= sizeof(addr
);
2868 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
2869 "getsockname should have worked\n");
2870 ok(addr
.sin_port
, "socket port should be != 0\n");
2872 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2873 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2876 ret
= getsockopt(dupsock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2877 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
2878 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2879 SOCK_DGRAM
, socktype
);
2881 set_blocking(source
, TRUE
);
2883 /* send data on source socket */
2884 addrsize
= sizeof(addr
);
2885 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
2886 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2888 /* receive on duplicated socket */
2889 addrsize
= sizeof(addr
);
2890 memset(buffer
, 0, sizeof(buffer
));
2891 size
= recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
);
2892 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2893 buffer
[sizeof(teststr
) - 1] = 0;
2894 ok(!strcmp(buffer
, teststr
), "expected '%s', received '%s'\n", teststr
, buffer
);
2896 closesocket(dupsock
);
2897 closesocket(source
);
2899 /* show that the source socket need to be bound before the duplicated
2900 * socket is created */
2901 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
2902 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2904 memset(&info
, 0, sizeof(info
));
2905 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2906 "WSADuplicateSocketA should have worked\n");
2908 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2909 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2911 memset(&addr
, 0, sizeof(addr
));
2912 addr
.sin_family
= AF_INET
;
2913 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2914 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
2915 "bind should have worked\n");
2917 /* read address to find out the port number to be used in sendto */
2918 memset(&addr
, 0, sizeof(addr
));
2919 addrsize
= sizeof(addr
);
2920 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
2921 "getsockname should have worked\n");
2922 ok(addr
.sin_port
, "socket port should be != 0\n");
2924 set_blocking(source
, TRUE
);
2926 addrsize
= sizeof(addr
);
2927 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
2928 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2930 SetLastError(0xdeadbeef);
2931 addrsize
= sizeof(addr
);
2932 memset(buffer
, 0, sizeof(buffer
));
2934 ok(recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
) == -1,
2935 "recvfrom should have failed\n");
2936 err
= WSAGetLastError();
2937 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2940 closesocket(dupsock
);
2941 closesocket(source
);
2944 static void test_WSAEnumNetworkEvents(void)
2947 int sock_type
[] = {SOCK_STREAM
, SOCK_DGRAM
, SOCK_STREAM
}, i
, j
, k
, l
;
2948 struct sockaddr_in address
;
2950 WSANETWORKEVENTS net_events
;
2952 memset(&address
, 0, sizeof(address
));
2953 address
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
2954 address
.sin_family
= AF_INET
;
2956 /* This test follows the steps from bugs 10204 and 24946 */
2957 for (l
= 0; l
< 2; l
++)
2959 for (i
= 0; i
< sizeof(sock_type
) / sizeof(sock_type
[0]); i
++)
2962 ok(!tcp_socketpair(&s
, &s2
), "Test[%d]: creating socket pair failed\n", i
);
2965 s
= socket(AF_INET
, sock_type
[i
], 0);
2966 ok (s
!= SOCKET_ERROR
, "Test[%d]: failed to create socket\n", i
);
2967 ok (!bind(s
, (struct sockaddr
*) &address
, sizeof(address
)), "Test[%d]: bind failed\n", i
);
2969 event
= WSACreateEvent();
2970 ok (event
!= NULL
, "Test[%d]: failed to create event\n", i
);
2971 for (j
= 0; j
< 5; j
++) /* Repeat sometimes and the result must be the same */
2973 /* When the TCP socket is not connected NO events will be returned.
2974 * When connected and no data pending it will get the write event.
2975 * UDP sockets don't have connections so as soon as they are bound
2976 * they can read/write data. Since nobody is sendind us data only
2977 * the write event will be returned and ONLY once.
2979 ok (!WSAEventSelect(s
, event
, FD_READ
| FD_WRITE
), "Test[%d]: WSAEventSelect failed\n", i
);
2980 memset(&net_events
, 0xAB, sizeof(net_events
));
2981 ok (!WSAEnumNetworkEvents(s
, l
== 0 ? event
: NULL
, &net_events
),
2982 "Test[%d]: WSAEnumNetworkEvents failed\n", i
);
2983 if (i
>= 1 && j
== 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
2985 todo_wine_if (i
== 0) /* Remove when fixed */
2986 ok (net_events
.lNetworkEvents
== FD_WRITE
, "Test[%d]: expected 2, got %d\n",
2987 i
, net_events
.lNetworkEvents
);
2991 todo_wine_if (i
!= 0) /* Remove when fixed */
2992 ok (net_events
.lNetworkEvents
== 0, "Test[%d]: expected 0, got %d\n",
2993 i
, net_events
.lNetworkEvents
);
2995 for (k
= 0; k
< FD_MAX_EVENTS
; k
++)
2997 if (i
>= 1 && j
== 0 && k
== 1) /* first UDP and connected TCP test, FD_WRITE bit no error*/
2999 ok (net_events
.iErrorCode
[k
] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
3000 i
, k
, net_events
.iErrorCode
[k
]);
3004 /* Bits that are not set in lNetworkEvents MUST not be changed */
3006 ok (net_events
.iErrorCode
[k
] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
3007 i
, k
, net_events
.iErrorCode
[k
]);
3012 WSACloseEvent(event
);
3013 if (i
== 2) closesocket(s2
);
3018 static void test_WSAAddressToStringA(void)
3020 SOCKET v6
= INVALID_SOCKET
;
3024 SOCKADDR_IN sockaddr
;
3025 CHAR address
[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
3027 CHAR expect1
[] = "0.0.0.0";
3028 CHAR expect2
[] = "255.255.255.255";
3029 CHAR expect3
[] = "0.0.0.0:65535";
3030 CHAR expect4
[] = "255.255.255.255:65535";
3032 SOCKADDR_IN6 sockaddr6
;
3033 CHAR address6
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
3035 CHAR addr6_1
[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3036 CHAR addr6_2
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3037 CHAR addr6_3
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
3039 CHAR expect6_1
[] = "::1";
3040 CHAR expect6_2
[] = "20ab::1";
3041 CHAR expect6_3
[] = "[20ab::2001]:33274";
3042 CHAR expect6_3_2
[] = "[20ab::2001%4660]:33274";
3043 CHAR expect6_3_3
[] = "20ab::2001%4660";
3047 sockaddr
.sin_family
= AF_INET
;
3048 sockaddr
.sin_port
= 0;
3049 sockaddr
.sin_addr
.s_addr
= 0;
3051 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3052 GLE
= WSAGetLastError();
3053 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEFAULT
) || (ret
== 0),
3054 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
3057 len
= sizeof(address
);
3059 sockaddr
.sin_family
= AF_INET
;
3060 sockaddr
.sin_port
= 0;
3061 sockaddr
.sin_addr
.s_addr
= 0;
3063 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3064 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3066 ok( !strcmp( address
, expect1
), "Expected: %s, got: %s\n", expect1
, address
);
3067 ok( len
== sizeof( expect1
), "Got size %d\n", len
);
3069 len
= sizeof(address
);
3071 sockaddr
.sin_family
= AF_INET
;
3072 sockaddr
.sin_port
= 0;
3073 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
3075 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3076 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3078 ok( !strcmp( address
, expect2
), "Expected: %s, got: %s\n", expect2
, address
);
3080 len
= sizeof(address
);
3082 sockaddr
.sin_family
= AF_INET
;
3083 sockaddr
.sin_port
= 0xffff;
3084 sockaddr
.sin_addr
.s_addr
= 0;
3086 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3087 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3089 ok( !strcmp( address
, expect3
), "Expected: %s, got: %s\n", expect3
, address
);
3091 len
= sizeof(address
);
3093 sockaddr
.sin_family
= AF_INET
;
3094 sockaddr
.sin_port
= 0xffff;
3095 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
3097 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3098 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3100 ok( !strcmp( address
, expect4
), "Expected: %s, got: %s\n", expect4
, address
);
3101 ok( len
== sizeof( expect4
), "Got size %d\n", len
);
3103 /*check to see it IPv6 is available */
3104 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
3105 if (v6
== INVALID_SOCKET
) {
3106 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
3107 WSAGetLastError(), WSAEAFNOSUPPORT
);
3110 /* Test a short IPv6 address */
3111 len
= sizeof(address6
);
3113 sockaddr6
.sin6_family
= AF_INET6
;
3114 sockaddr6
.sin6_port
= 0x0000;
3115 sockaddr6
.sin6_scope_id
= 0;
3116 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_1
, sizeof(addr6_1
));
3118 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3119 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3120 ok( !strcmp( address6
, expect6_1
), "Expected: %s, got: %s\n", expect6_1
, address6
);
3121 ok( len
== sizeof(expect6_1
), "Got size %d\n", len
);
3123 /* Test a longer IPv6 address */
3124 len
= sizeof(address6
);
3126 sockaddr6
.sin6_family
= AF_INET6
;
3127 sockaddr6
.sin6_port
= 0x0000;
3128 sockaddr6
.sin6_scope_id
= 0;
3129 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_2
, sizeof(addr6_2
));
3131 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3132 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3133 ok( !strcmp( address6
, expect6_2
), "Expected: %s, got: %s\n", expect6_2
, address6
);
3134 ok( len
== sizeof(expect6_2
), "Got size %d\n", len
);
3136 /* Test IPv6 address and port number */
3137 len
= sizeof(address6
);
3139 sockaddr6
.sin6_family
= AF_INET6
;
3140 sockaddr6
.sin6_port
= 0xfa81;
3141 sockaddr6
.sin6_scope_id
= 0;
3142 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
3144 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3145 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3146 ok( !strcmp( address6
, expect6_3
), "Expected: %s, got: %s\n", expect6_3
, address6
);
3147 ok( len
== sizeof(expect6_3
), "Got size %d\n", len
);
3149 /* Test IPv6 address, port number and scope_id */
3150 len
= sizeof(address6
);
3152 sockaddr6
.sin6_family
= AF_INET6
;
3153 sockaddr6
.sin6_port
= 0xfa81;
3154 sockaddr6
.sin6_scope_id
= 0x1234;
3155 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
3157 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3158 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3159 ok( !strcmp( address6
, expect6_3_2
), "Expected: %s, got: %s\n", expect6_3_2
, address6
);
3160 ok( len
== sizeof(expect6_3_2
), "Got size %d\n", len
);
3162 /* Test IPv6 address and scope_id */
3163 len
= sizeof(address6
);
3165 sockaddr6
.sin6_family
= AF_INET6
;
3166 sockaddr6
.sin6_port
= 0x0000;
3167 sockaddr6
.sin6_scope_id
= 0x1234;
3168 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
3170 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3171 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3172 ok( !strcmp( address6
, expect6_3_3
), "Expected: %s, got: %s\n", expect6_3_3
, address6
);
3173 ok( len
== sizeof(expect6_3_3
), "Got size %d\n", len
);
3176 if (v6
!= INVALID_SOCKET
)
3180 static void test_WSAAddressToStringW(void)
3182 SOCKET v6
= INVALID_SOCKET
;
3186 SOCKADDR_IN sockaddr
;
3187 WCHAR address
[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
3189 WCHAR expect1
[] = { '0','.','0','.','0','.','0', 0 };
3190 WCHAR expect2
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
3191 WCHAR expect3
[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
3192 WCHAR expect4
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
3193 '6', '5', '5', '3', '5', 0 };
3195 SOCKADDR_IN6 sockaddr6
;
3196 WCHAR address6
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
3198 CHAR addr6_1
[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3199 CHAR addr6_2
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3200 CHAR addr6_3
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
3202 WCHAR expect6_1
[] = {':',':','1',0};
3203 WCHAR expect6_2
[] = {'2','0','a','b',':',':','1',0};
3204 WCHAR expect6_3
[] = {'[','2','0','a','b',':',':','2','0','0','1',']',':','3','3','2','7','4',0};
3205 WCHAR expect6_3_2
[] = {'[','2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',']',':','3','3','2','7','4',0};
3206 WCHAR expect6_3_3
[] = {'2','0','a','b',':',':','2','0','0','1','%','6','5','5','3','4',0};
3210 sockaddr
.sin_family
= AF_INET
;
3211 sockaddr
.sin_port
= 0;
3212 sockaddr
.sin_addr
.s_addr
= 0;
3214 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3215 GLE
= WSAGetLastError();
3216 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEFAULT
) || (ret
== 0),
3217 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
3220 len
= sizeof(address
);
3222 sockaddr
.sin_family
= AF_INET
;
3223 sockaddr
.sin_port
= 0;
3224 sockaddr
.sin_addr
.s_addr
= 0;
3226 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3227 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3229 ok( !lstrcmpW( address
, expect1
), "Expected different address string\n" );
3230 ok( len
== sizeof( expect1
)/sizeof( WCHAR
), "Got size %d\n", len
);
3232 len
= sizeof(address
);
3234 sockaddr
.sin_family
= AF_INET
;
3235 sockaddr
.sin_port
= 0;
3236 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
3238 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3239 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3241 ok( !lstrcmpW( address
, expect2
), "Expected different address string\n" );
3243 len
= sizeof(address
);
3245 sockaddr
.sin_family
= AF_INET
;
3246 sockaddr
.sin_port
= 0xffff;
3247 sockaddr
.sin_addr
.s_addr
= 0;
3249 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3250 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3252 ok( !lstrcmpW( address
, expect3
), "Expected different address string\n" );
3254 len
= sizeof(address
);
3256 sockaddr
.sin_family
= AF_INET
;
3257 sockaddr
.sin_port
= 0xffff;
3258 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
3260 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3261 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3263 ok( !lstrcmpW( address
, expect4
), "Expected different address string\n" );
3264 ok( len
== sizeof( expect4
)/sizeof( WCHAR
), "Got %d\n", len
);
3266 /*check to see it IPv6 is available */
3267 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
3268 if (v6
== INVALID_SOCKET
) {
3269 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
3270 WSAGetLastError(), WSAEAFNOSUPPORT
);
3274 /* Test a short IPv6 address */
3275 len
= sizeof(address6
)/sizeof(WCHAR
);
3277 sockaddr6
.sin6_family
= AF_INET6
;
3278 sockaddr6
.sin6_port
= 0x0000;
3279 sockaddr6
.sin6_scope_id
= 0;
3280 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_1
, sizeof(addr6_1
));
3282 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3283 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3284 ok( !lstrcmpW( address6
, expect6_1
), "Wrong string returned\n" );
3285 ok( len
== sizeof(expect6_1
)/sizeof(WCHAR
), "Got %d\n", len
);
3287 /* Test a longer IPv6 address */
3288 len
= sizeof(address6
)/sizeof(WCHAR
);
3290 sockaddr6
.sin6_family
= AF_INET6
;
3291 sockaddr6
.sin6_port
= 0x0000;
3292 sockaddr6
.sin6_scope_id
= 0;
3293 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_2
, sizeof(addr6_2
));
3295 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3296 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3298 ok( !lstrcmpW( address6
, expect6_2
), "Wrong string returned\n" );
3299 ok( len
== sizeof(expect6_2
)/sizeof(WCHAR
), "Got %d\n", len
);
3301 /* Test IPv6 address and port number */
3302 len
= sizeof(address6
)/sizeof(WCHAR
);
3304 sockaddr6
.sin6_family
= AF_INET6
;
3305 sockaddr6
.sin6_port
= 0xfa81;
3306 sockaddr6
.sin6_scope_id
= 0;
3307 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
3309 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3310 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3311 ok( !lstrcmpW( address6
, expect6_3
),
3312 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3
), wine_dbgstr_w(address6
) );
3313 ok( len
== sizeof(expect6_3
)/sizeof(WCHAR
), "Got %d\n", len
);
3315 /* Test IPv6 address, port number and scope_id */
3316 len
= sizeof(address6
)/sizeof(WCHAR
);
3318 sockaddr6
.sin6_family
= AF_INET6
;
3319 sockaddr6
.sin6_port
= 0xfa81;
3320 sockaddr6
.sin6_scope_id
= 0x1234;
3321 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
3323 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3324 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3325 ok( !lstrcmpW( address6
, expect6_3_2
),
3326 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_2
), wine_dbgstr_w(address6
) );
3327 ok( len
== sizeof(expect6_3_2
)/sizeof(WCHAR
), "Got %d\n", len
);
3329 /* Test IPv6 address and scope_id */
3330 len
= sizeof(address6
)/sizeof(WCHAR
);
3332 sockaddr6
.sin6_family
= AF_INET6
;
3333 sockaddr6
.sin6_port
= 0x0000;
3334 sockaddr6
.sin6_scope_id
= 0xfffe;
3335 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
3337 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3338 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3339 ok( !lstrcmpW( address6
, expect6_3_3
),
3340 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_3
), wine_dbgstr_w(address6
) );
3341 ok( len
== sizeof(expect6_3_3
)/sizeof(WCHAR
), "Got %d\n", len
);
3344 if (v6
!= INVALID_SOCKET
)
3348 static void test_WSAStringToAddressA(void)
3351 SOCKADDR_IN sockaddr
;
3352 SOCKADDR_IN6 sockaddr6
;
3355 CHAR address1
[] = "0.0.0.0";
3356 CHAR address2
[] = "127.127.127.127";
3357 CHAR address3
[] = "255.255.255.255";
3358 CHAR address4
[] = "127.127.127.127:65535";
3359 CHAR address5
[] = "255.255.255.255:65535";
3360 CHAR address6
[] = "::1";
3361 CHAR address7
[] = "[::1]";
3362 CHAR address8
[] = "[::1]:65535";
3363 CHAR address9
[] = "2001::1";
3366 sockaddr
.sin_family
= AF_INET
;
3368 ret
= WSAStringToAddressA( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3369 ok( ret
== SOCKET_ERROR
, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
3370 WSAGetLastError() );
3372 len
= sizeof(sockaddr
);
3373 sockaddr
.sin_port
= 0;
3374 sockaddr
.sin_addr
.s_addr
= 0;
3376 ret
= WSAStringToAddressA( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3377 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0,
3378 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3380 len
= sizeof(sockaddr
);
3381 sockaddr
.sin_port
= 0;
3382 sockaddr
.sin_addr
.s_addr
= 0;
3384 ret
= WSAStringToAddressA( address2
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3385 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f,
3386 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3388 len
= sizeof(sockaddr
);
3389 sockaddr
.sin_port
= 0;
3390 sockaddr
.sin_addr
.s_addr
= 0;
3392 ret
= WSAStringToAddressA( address3
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3393 GLE
= WSAGetLastError();
3394 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff) ||
3395 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
3396 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE
);
3398 len
= sizeof(sockaddr
);
3399 sockaddr
.sin_port
= 0;
3400 sockaddr
.sin_addr
.s_addr
= 0;
3402 ret
= WSAStringToAddressA( address4
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3403 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f && sockaddr
.sin_port
== 0xffff,
3404 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3406 len
= sizeof(sockaddr
);
3407 sockaddr
.sin_port
= 0;
3408 sockaddr
.sin_addr
.s_addr
= 0;
3410 ret
= WSAStringToAddressA( address5
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3411 GLE
= WSAGetLastError();
3412 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff && sockaddr
.sin_port
== 0xffff) ||
3413 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
3414 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE
);
3416 len
= sizeof(sockaddr
);
3418 ret
= WSAStringToAddressA( address9
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3419 GLE
= WSAGetLastError();
3420 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3421 "WSAStringToAddressA() should have failed with %d\n", GLE
);
3423 len
= sizeof(sockaddr6
);
3424 memset(&sockaddr6
, 0, len
);
3425 sockaddr6
.sin6_family
= AF_INET6
;
3427 ret
= WSAStringToAddressA( address6
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3429 if (ret
== SOCKET_ERROR
)
3431 win_skip("IPv6 not supported\n");
3435 GLE
= WSAGetLastError();
3436 ok( ret
== 0, "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
3438 len
= sizeof(sockaddr6
);
3439 memset(&sockaddr6
, 0, len
);
3440 sockaddr6
.sin6_family
= AF_INET6
;
3442 ret
= WSAStringToAddressA( address7
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3444 GLE
= WSAGetLastError();
3445 ok( ret
== 0, "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
3447 len
= sizeof(sockaddr6
);
3448 memset(&sockaddr6
, 0, len
);
3449 sockaddr6
.sin6_family
= AF_INET6
;
3451 ret
= WSAStringToAddressA( address8
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3453 GLE
= WSAGetLastError();
3454 ok( ret
== 0 && sockaddr6
.sin6_port
== 0xffff,
3455 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
3457 len
= sizeof(sockaddr6
);
3459 ret
= WSAStringToAddressA( address7
+ 1, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3460 GLE
= WSAGetLastError();
3461 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3462 "WSAStringToAddressW() should have failed with %d\n", GLE
);
3464 len
= sizeof(sockaddr6
);
3466 ret
= WSAStringToAddressA( address8
+ 1, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3467 GLE
= WSAGetLastError();
3468 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3469 "WSAStringToAddressW() should have failed with %d\n", GLE
);
3472 static void test_WSAStringToAddressW(void)
3475 SOCKADDR_IN sockaddr
, *sin
;
3476 SOCKADDR_IN6 sockaddr6
;
3477 SOCKADDR_STORAGE sockaddr_storage
;
3480 WCHAR address1
[] = { '0','.','0','.','0','.','0', 0 };
3481 WCHAR address2
[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
3482 WCHAR address3
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
3483 WCHAR address4
[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
3484 ':', '6', '5', '5', '3', '5', 0 };
3485 WCHAR address5
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
3486 '6', '5', '5', '3', '5', 0 };
3487 WCHAR address6
[] = {':',':','1','\0'};
3488 WCHAR address7
[] = {'[',':',':','1',']','\0'};
3489 WCHAR address8
[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
3490 WCHAR address9
[] = {'2','0','0','1',':',':','1','\0'};
3493 sockaddr
.sin_family
= AF_INET
;
3495 ret
= WSAStringToAddressW( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3496 ok( ret
== SOCKET_ERROR
, "WSAStringToAddressW() failed unexpectedly: %d\n",
3497 WSAGetLastError() );
3499 len
= sizeof(sockaddr
);
3500 sockaddr
.sin_port
= 0;
3501 sockaddr
.sin_addr
.s_addr
= 0;
3503 ret
= WSAStringToAddressW( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3504 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0,
3505 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3507 len
= sizeof(sockaddr
);
3508 sockaddr
.sin_port
= 0;
3509 sockaddr
.sin_addr
.s_addr
= 0;
3511 ret
= WSAStringToAddressW( address2
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3512 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f,
3513 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3515 len
= sizeof(sockaddr
);
3516 sockaddr
.sin_port
= 0;
3517 sockaddr
.sin_addr
.s_addr
= 0;
3519 ret
= WSAStringToAddressW( address3
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3520 GLE
= WSAGetLastError();
3521 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff) ||
3522 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
3523 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
3525 len
= sizeof(sockaddr
);
3526 sockaddr
.sin_port
= 0;
3527 sockaddr
.sin_addr
.s_addr
= 0;
3529 ret
= WSAStringToAddressW( address4
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3530 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f && sockaddr
.sin_port
== 0xffff,
3531 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3533 len
= sizeof(sockaddr
);
3534 sockaddr
.sin_port
= 0;
3535 sockaddr
.sin_addr
.s_addr
= 0;
3537 ret
= WSAStringToAddressW( address5
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3538 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff && sockaddr
.sin_port
== 0xffff) ||
3539 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
3540 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
3542 /* Test with a larger buffer than necessary */
3543 len
= sizeof(sockaddr_storage
);
3544 sin
= (SOCKADDR_IN
*)&sockaddr_storage
;
3546 sin
->sin_addr
.s_addr
= 0;
3548 ret
= WSAStringToAddressW( address5
, AF_INET
, NULL
, (SOCKADDR
*)sin
, &len
);
3549 ok( (ret
== 0 && sin
->sin_addr
.s_addr
== 0xffffffff && sin
->sin_port
== 0xffff) ||
3550 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
3551 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
3552 ok( len
== sizeof(SOCKADDR_IN
), "unexpected length %d\n", len
);
3554 len
= sizeof(sockaddr
);
3556 ret
= WSAStringToAddressW( address9
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3557 GLE
= WSAGetLastError();
3558 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3559 "WSAStringToAddressW() should have failed with %d\n", GLE
);
3561 len
= sizeof(sockaddr6
);
3562 memset(&sockaddr6
, 0, len
);
3563 sockaddr6
.sin6_family
= AF_INET6
;
3565 ret
= WSAStringToAddressW( address6
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3567 if (ret
== SOCKET_ERROR
)
3569 win_skip("IPv6 not supported\n");
3573 GLE
= WSAGetLastError();
3574 ok( ret
== 0, "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
3576 len
= sizeof(sockaddr6
);
3577 memset(&sockaddr6
, 0, len
);
3578 sockaddr6
.sin6_family
= AF_INET6
;
3580 ret
= WSAStringToAddressW( address7
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3582 GLE
= WSAGetLastError();
3583 ok( ret
== 0, "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
3585 len
= sizeof(sockaddr6
);
3586 memset(&sockaddr6
, 0, len
);
3587 sockaddr6
.sin6_family
= AF_INET6
;
3589 ret
= WSAStringToAddressW( address8
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3591 GLE
= WSAGetLastError();
3592 ok( ret
== 0 && sockaddr6
.sin6_port
== 0xffff,
3593 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
3595 len
= sizeof(sockaddr6
);
3597 ret
= WSAStringToAddressW( address7
+ 1, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3598 GLE
= WSAGetLastError();
3599 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3600 "WSAStringToAddressW() should have failed with %d\n", GLE
);
3602 len
= sizeof(sockaddr6
);
3604 ret
= WSAStringToAddressW( address8
+ 1, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3605 GLE
= WSAGetLastError();
3606 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3607 "WSAStringToAddressW() should have failed with %d\n", GLE
);
3610 static DWORD WINAPI
SelectReadThread(void *param
)
3612 select_thread_params
*par
= param
;
3615 struct sockaddr_in addr
;
3616 struct timeval select_timeout
;
3619 FD_SET(par
->s
, &readfds
);
3620 select_timeout
.tv_sec
=5;
3621 select_timeout
.tv_usec
=0;
3622 addr
.sin_family
= AF_INET
;
3623 addr
.sin_addr
.s_addr
= inet_addr(SERVERIP
);
3624 addr
.sin_port
= htons(SERVERPORT
);
3626 do_bind(par
->s
, (struct sockaddr
*)&addr
, sizeof(addr
));
3627 wsa_ok(listen(par
->s
, SOMAXCONN
), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
3629 SetEvent(server_ready
);
3630 ret
= select(par
->s
+1, &readfds
, NULL
, NULL
, &select_timeout
);
3631 par
->ReadKilled
= (ret
== 1);
3636 static DWORD WINAPI
SelectCloseThread(void *param
)
3638 SOCKET s
= *(SOCKET
*)param
;
3644 static void test_errors(void)
3647 SOCKADDR_IN SockAddr
;
3650 WSASetLastError(NO_ERROR
);
3651 sock
= socket(PF_INET
, SOCK_STREAM
, 0);
3652 ok( (sock
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3653 memset(&SockAddr
, 0, sizeof(SockAddr
));
3654 SockAddr
.sin_family
= AF_INET
;
3655 SockAddr
.sin_port
= htons(6924);
3656 SockAddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3658 ret
= connect(sock
, (PSOCKADDR
)&SockAddr
, sizeof(SockAddr
));
3659 ok( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got: %d\n", ret
);
3660 if (ret
== SOCKET_ERROR
)
3662 err
= WSAGetLastError();
3663 ok( (err
== WSAECONNREFUSED
), "expected WSAECONNREFUSED, got: %d\n", err
);
3668 fd_set set
= {1, {sock
}};
3671 timeval
.tv_usec
= 50000;
3673 ret
= select(1, NULL
, &set
, NULL
, &timeval
);
3674 ok( (ret
== 0), "expected 0 (timeout), got: %d\n", ret
);
3677 ret
= closesocket(sock
);
3678 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
3681 static void test_listen(void)
3684 int ret
, acceptc
, olen
= sizeof(acceptc
);
3685 struct sockaddr_in address
;
3687 memset(&address
, 0, sizeof(address
));
3688 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3689 address
.sin_family
= AF_INET
;
3690 address
.sin_port
= htons(SERVERPORT
);
3692 /* invalid socket tests */
3693 SetLastError(0xdeadbeef);
3694 ok ((listen(0, 0) == SOCKET_ERROR
), "listen did not fail\n");
3695 ret
= WSAGetLastError();
3696 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
3698 SetLastError(0xdeadbeef);
3699 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR
), "listen did not fail\n");
3700 ret
= WSAGetLastError();
3701 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
3704 fdA
= socket(AF_INET
, SOCK_STREAM
, 0);
3705 ok ((fdA
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3707 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
3708 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3710 SetLastError(0xdeadbeef);
3711 ok ((listen(fdA
, -2) == SOCKET_ERROR
), "listen did not fail\n");
3712 ret
= WSAGetLastError();
3713 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3715 SetLastError(0xdeadbeef);
3716 ok ((listen(fdA
, 1) == SOCKET_ERROR
), "listen did not fail\n");
3717 ret
= WSAGetLastError();
3718 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3720 SetLastError(0xdeadbeef);
3721 ok ((listen(fdA
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
3722 ret
= WSAGetLastError();
3723 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3725 ok (!bind(fdA
, (struct sockaddr
*) &address
, sizeof(address
)), "bind failed\n");
3727 SetLastError(0xdeadbeef);
3728 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
3729 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3732 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
3733 ok (!ret
, "getsockopt failed\n");
3734 ok (acceptc
== 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc
);
3736 ok (!listen(fdA
, 0), "listen failed\n");
3737 ok (!listen(fdA
, SOMAXCONN
), "double listen failed\n");
3740 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
3741 ok (!ret
, "getsockopt failed\n");
3742 ok (acceptc
== 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc
);
3744 SetLastError(0xdeadbeef);
3745 ok ((listen(fdB
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
3746 ret
= WSAGetLastError();
3747 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3749 ret
= closesocket(fdB
);
3750 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
3752 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
3753 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3755 SetLastError(0xdeadbeef);
3756 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
3757 ret
= WSAGetLastError();
3758 ok (ret
== WSAEADDRINUSE
, "expected 10048, received %d\n", ret
);
3760 ret
= closesocket(fdA
);
3761 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
3762 ret
= closesocket(fdB
);
3763 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
3766 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
3767 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
3768 static void test_select(void)
3770 static char tmp_buf
[1024];
3772 SOCKET fdListen
, fdRead
, fdWrite
;
3773 fd_set readfds
, writefds
, exceptfds
;
3777 struct timeval select_timeout
;
3778 struct sockaddr_in address
;
3779 select_thread_params thread_params
;
3780 HANDLE thread_handle
;
3783 fdRead
= socket(AF_INET
, SOCK_STREAM
, 0);
3784 ok( (fdRead
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3785 fdWrite
= socket(AF_INET
, SOCK_STREAM
, 0);
3786 ok( (fdWrite
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3789 if (fdWrite
> maxfd
)
3794 FD_SET_ALL(fdWrite
);
3795 select_timeout
.tv_sec
=0;
3796 select_timeout
.tv_usec
=0;
3798 ticks
= GetTickCount();
3799 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3800 ticks
= GetTickCount() - ticks
;
3801 ok(ret
== 0, "select should not return any socket handles\n");
3802 ok(ticks
< 10, "select was blocking for %u ms, expected < 10 ms\n", ticks
);
3803 ok(!FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
3804 ok(!FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
3805 ok(!FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
3806 ok(!FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
3810 FD_SET_ALL(fdWrite
);
3811 select_timeout
.tv_sec
=0;
3812 select_timeout
.tv_usec
=500;
3814 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3815 ok(ret
== 0, "select should not return any socket handles\n");
3816 ok(!FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
3817 ok(!FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
3818 ok(!FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
3819 ok(!FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
3821 ok ((listen(fdWrite
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
3822 ret
= closesocket(fdWrite
);
3823 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
3825 thread_params
.s
= fdRead
;
3826 thread_params
.ReadKilled
= FALSE
;
3827 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
3828 thread_handle
= CreateThread (NULL
, 0, SelectReadThread
, &thread_params
, 0, &id
);
3829 ok ( (thread_handle
!= NULL
), "CreateThread failed unexpectedly: %d\n", GetLastError());
3831 WaitForSingleObject (server_ready
, INFINITE
);
3833 ret
= closesocket(fdRead
);
3834 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
3836 WaitForSingleObject (thread_handle
, 1000);
3837 ok ( thread_params
.ReadKilled
, "closesocket did not wake up select\n");
3838 ret
= recv(fdRead
, &buffer
, 1, MSG_PEEK
);
3839 ok( (ret
== -1), "peek at closed socket expected -1 got %d\n", ret
);
3841 /* Test selecting invalid handles */
3845 ret
= select(maxfd
+1, 0, 0, 0, &select_timeout
);
3846 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3847 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3850 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3851 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3852 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3854 FD_SET(INVALID_SOCKET
, &readfds
);
3856 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3857 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3858 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3859 ok ( !FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
3862 FD_SET(INVALID_SOCKET
, &writefds
);
3864 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3865 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3866 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3867 ok ( !FD_ISSET(fdRead
, &writefds
), "FD should not be set\n");
3870 FD_SET(INVALID_SOCKET
, &exceptfds
);
3872 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3873 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3874 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3875 ok ( !FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
3877 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
3879 if(fdWrite
> maxfd
) maxfd
= fdWrite
;
3882 FD_SET(fdRead
, &readfds
);
3883 ret
= select(fdRead
+1, &readfds
, NULL
, NULL
, &select_timeout
);
3884 ok(!ret
, "select returned %d\n", ret
);
3887 FD_SET(fdWrite
, &writefds
);
3888 ret
= select(fdWrite
+1, NULL
, &writefds
, NULL
, &select_timeout
);
3889 ok(ret
== 1, "select returned %d\n", ret
);
3890 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
3892 /* tests for overlapping fd_set pointers */
3894 FD_SET(fdWrite
, &readfds
);
3895 ret
= select(fdWrite
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3896 ok(ret
== 1, "select returned %d\n", ret
);
3897 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3900 FD_SET(fdWrite
, &readfds
);
3901 FD_SET(fdRead
, &readfds
);
3902 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3903 ok(ret
== 2, "select returned %d\n", ret
);
3904 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3905 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3907 ok(send(fdWrite
, "test", 4, 0) == 4, "failed to send data\n");
3909 FD_SET(fdRead
, &readfds
);
3910 ret
= select(fdRead
+1, &readfds
, NULL
, NULL
, &select_timeout
);
3911 ok(ret
== 1, "select returned %d\n", ret
);
3912 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3915 FD_SET(fdWrite
, &readfds
);
3916 FD_SET(fdRead
, &readfds
);
3917 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3918 ok(ret
== 2, "select returned %d\n", ret
);
3919 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3920 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3924 FD_SET(fdWrite
, &writefds
);
3925 ret
= select(fdWrite
+1, NULL
, &writefds
, NULL
, &select_timeout
);
3927 ok(send(fdWrite
, tmp_buf
, sizeof(tmp_buf
), 0) > 0, "failed to send data\n");
3930 FD_SET(fdWrite
, &readfds
);
3931 FD_SET(fdRead
, &readfds
);
3932 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3933 ok(ret
== 1, "select returned %d\n", ret
);
3934 ok(!FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is in the set\n");
3935 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3937 ok(send(fdRead
, "test", 4, 0) == 4, "failed to send data\n");
3940 FD_SET(fdWrite
, &readfds
);
3941 FD_SET(fdRead
, &readfds
);
3942 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3943 ok(ret
== 2, "select returned %d\n", ret
);
3944 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3945 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3947 closesocket(fdRead
);
3948 closesocket(fdWrite
);
3950 /* select() works in 3 distinct states:
3951 * - to check if a connection attempt ended with success or error;
3952 * - to check if a pending connection is waiting for acceptance;
3953 * - to check for data to read, availability for write and OOB data
3955 * The tests below ensure that all conditions are tested.
3957 memset(&address
, 0, sizeof(address
));
3958 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3959 address
.sin_family
= AF_INET
;
3960 len
= sizeof(address
);
3961 fdListen
= setup_server_socket(&address
, &len
);
3962 select_timeout
.tv_sec
= 1;
3963 select_timeout
.tv_usec
= 250000;
3965 /* When no events are pending select returns 0 with no error */
3967 FD_SET_ALL(fdListen
);
3968 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3969 ok(ret
== 0, "expected 0, got %d\n", ret
);
3971 /* When a socket is attempting to connect the listening socket receives the read descriptor */
3972 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
3974 FD_SET_ALL(fdListen
);
3975 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3976 ok(ret
== 1, "expected 1, got %d\n", ret
);
3977 ok(FD_ISSET(fdListen
, &readfds
), "fdListen socket is not in the set\n");
3978 len
= sizeof(address
);
3979 fdRead
= accept(fdListen
, (struct sockaddr
*) &address
, &len
);
3980 ok(fdRead
!= INVALID_SOCKET
, "expected a valid socket\n");
3982 /* The connector is signaled through the write descriptor */
3984 FD_SET_ALL(fdListen
);
3986 FD_SET_ALL(fdWrite
);
3987 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3988 ok(ret
== 2, "expected 2, got %d\n", ret
);
3989 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
3990 ok(FD_ISSET(fdRead
, &writefds
), "fdRead socket is not in the set\n");
3993 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
3994 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
3995 ok(id
== 0, "expected 0, got %d\n", id
);
3997 /* When data is received the receiver gets the read descriptor */
3998 ret
= send(fdWrite
, "1234", 4, 0);
3999 ok(ret
== 4, "expected 4, got %d\n", ret
);
4001 FD_SET_ALL(fdListen
);
4002 FD_SET(fdRead
, &readfds
);
4003 FD_SET(fdRead
, &exceptfds
);
4004 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4005 ok(ret
== 1, "expected 1, got %d\n", ret
);
4006 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
4007 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
4008 ok(ret
== 4, "expected 4, got %d\n", ret
);
4009 ok(!strcmp(tmp_buf
, "1234"), "data received differs from sent\n");
4011 /* When OOB data is received the socket is set in the except descriptor */
4012 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
4013 ok(ret
== 1, "expected 1, got %d\n", ret
);
4015 FD_SET_ALL(fdListen
);
4016 FD_SET(fdRead
, &readfds
);
4017 FD_SET(fdRead
, &exceptfds
);
4018 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4019 ok(ret
== 1, "expected 1, got %d\n", ret
);
4020 ok(FD_ISSET(fdRead
, &exceptfds
), "fdRead socket is not in the set\n");
4022 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
4023 ok(ret
== 1, "expected 1, got %d\n", ret
);
4024 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
4026 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
4028 ret
= setsockopt(fdRead
, SOL_SOCKET
, SO_OOBINLINE
, (char*) &ret
, sizeof(ret
));
4029 ok(ret
== 0, "expected 0, got %d\n", ret
);
4030 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
4031 ok(ret
== 1, "expected 1, got %d\n", ret
);
4033 FD_SET_ALL(fdListen
);
4034 FD_SET(fdRead
, &readfds
);
4035 FD_SET(fdRead
, &exceptfds
);
4036 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4037 ok(ret
== 1, "expected 1, got %d\n", ret
);
4038 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
4040 SetLastError(0xdeadbeef);
4041 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
4042 ok(ret
== SOCKET_ERROR
, "expected SOCKET_ERROR, got %d\n", ret
);
4043 ok(GetLastError() == WSAEINVAL
, "expected 10022, got %d\n", GetLastError());
4044 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
4045 ok(ret
== 1, "expected 1, got %d\n", ret
);
4046 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
4048 /* When the connection is closed the socket is set in the read descriptor */
4049 ret
= closesocket(fdRead
);
4050 ok(ret
== 0, "expected 0, got %d\n", ret
);
4052 FD_SET_ALL(fdListen
);
4053 FD_SET(fdWrite
, &readfds
);
4054 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4055 ok(ret
== 1, "expected 1, got %d\n", ret
);
4056 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
4057 ret
= recv(fdWrite
, tmp_buf
, sizeof(tmp_buf
), 0);
4058 ok(ret
== 0, "expected 0, got %d\n", ret
);
4060 /* When a connection is attempted to a non-listening socket it will get to the except descriptor */
4061 ret
= closesocket(fdWrite
);
4062 ok(ret
== 0, "expected 0, got %d\n", ret
);
4063 ret
= closesocket(fdListen
);
4064 ok(ret
== 0, "expected 0, got %d\n", ret
);
4065 len
= sizeof(address
);
4066 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
4068 FD_SET(fdWrite
, &writefds
);
4069 FD_SET(fdWrite
, &exceptfds
);
4070 select_timeout
.tv_sec
= 2; /* requires more time to realize it will not connect */
4071 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4072 ok(ret
== 1, "expected 1, got %d\n", ret
);
4075 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
4076 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
4077 ok(id
== WSAECONNREFUSED
, "expected 10061, got %d\n", id
);
4078 ok(FD_ISSET(fdWrite
, &exceptfds
), "fdWrite socket is not in the set\n");
4079 ok(select_timeout
.tv_usec
== 250000, "select timeout should not have changed\n");
4080 closesocket(fdWrite
);
4082 /* Try select() on a closed socket after connection */
4083 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
4084 closesocket(fdRead
);
4086 FD_SET_ALL(fdWrite
);
4088 SetLastError(0xdeadbeef);
4089 ret
= select(0, &readfds
, NULL
, &exceptfds
, &select_timeout
);
4090 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
4092 ok(GetLastError() == WSAENOTSOCK
, "expected 10038, got %d\n", GetLastError());
4093 /* descriptor sets are unchanged */
4094 ok(readfds
.fd_count
== 2, "expected 2, got %d\n", readfds
.fd_count
);
4095 ok(exceptfds
.fd_count
== 2, "expected 2, got %d\n", exceptfds
.fd_count
);
4096 closesocket(fdWrite
);
4098 /* Close the socket currently being selected in a thread - bug 38399 */
4099 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
4100 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
4101 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
4103 FD_SET_ALL(fdWrite
);
4104 ret
= select(0, &readfds
, NULL
, &exceptfds
, &select_timeout
);
4105 ok(ret
== 1, "expected 1, got %d\n", ret
);
4106 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
4107 WaitForSingleObject (thread_handle
, 1000);
4108 closesocket(fdRead
);
4109 /* test again with only the except descriptor */
4110 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
4111 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
4112 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
4114 FD_SET(fdWrite
, &exceptfds
);
4115 SetLastError(0xdeadbeef);
4116 ret
= select(0, NULL
, NULL
, &exceptfds
, &select_timeout
);
4118 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
4120 ok(GetLastError() == WSAENOTSOCK
, "expected 10038, got %d\n", GetLastError());
4121 WaitForSingleObject (thread_handle
, 1000);
4122 closesocket(fdRead
);
4124 /* test UDP behavior of unbound sockets */
4125 select_timeout
.tv_sec
= 0;
4126 select_timeout
.tv_usec
= 250000;
4127 fdWrite
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
4128 ok(fdWrite
!= INVALID_SOCKET
, "socket call failed\n");
4130 FD_SET_ALL(fdWrite
);
4131 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4132 ok(ret
== 1, "expected 1, got %d\n", ret
);
4133 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
4134 closesocket(fdWrite
);
4139 static DWORD WINAPI
AcceptKillThread(void *param
)
4141 select_thread_params
*par
= param
;
4142 struct sockaddr_in address
;
4143 int len
= sizeof(address
);
4144 SOCKET client_socket
;
4146 SetEvent(server_ready
);
4147 client_socket
= accept(par
->s
, (struct sockaddr
*) &address
, &len
);
4148 if (client_socket
!= INVALID_SOCKET
)
4149 closesocket(client_socket
);
4150 par
->ReadKilled
= (client_socket
== INVALID_SOCKET
);
4155 static int CALLBACK
AlwaysDeferConditionFunc(LPWSABUF lpCallerId
, LPWSABUF lpCallerData
, LPQOS pQos
,
4156 LPQOS lpGQOS
, LPWSABUF lpCalleeId
, LPWSABUF lpCalleeData
,
4157 GROUP
*g
, DWORD_PTR dwCallbackData
)
4162 static SOCKET
setup_server_socket(struct sockaddr_in
*addr
, int *len
)
4165 SOCKET server_socket
;
4167 server_socket
= socket(AF_INET
, SOCK_STREAM
, 0);
4168 if (server_socket
== INVALID_SOCKET
)
4170 trace("error creating server socket: %d\n", WSAGetLastError());
4171 return INVALID_SOCKET
;
4175 ret
= setsockopt(server_socket
, SOL_SOCKET
, SO_REUSEADDR
, (char *)&val
, sizeof(val
));
4178 trace("error setting SO_REUSEADDR: %d\n", WSAGetLastError());
4179 closesocket(server_socket
);
4180 return INVALID_SOCKET
;
4183 ret
= bind(server_socket
, (struct sockaddr
*)addr
, *len
);
4186 trace("error binding server socket: %d\n", WSAGetLastError());
4189 ret
= getsockname(server_socket
, (struct sockaddr
*)addr
, len
);
4192 skip("failed to lookup bind address: %d\n", WSAGetLastError());
4193 closesocket(server_socket
);
4194 return INVALID_SOCKET
;
4197 ret
= listen(server_socket
, 5);
4200 trace("error making server socket listen: %d\n", WSAGetLastError());
4201 closesocket(server_socket
);
4202 return INVALID_SOCKET
;
4205 return server_socket
;
4208 static SOCKET
setup_connector_socket(struct sockaddr_in
*addr
, int len
, BOOL nonblock
)
4213 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
4214 ok(connector
!= INVALID_SOCKET
, "failed to create connector socket %d\n", WSAGetLastError());
4217 set_blocking(connector
, !nonblock
);
4219 ret
= connect(connector
, (struct sockaddr
*)addr
, len
);
4221 ok(!ret
, "connecting to accepting socket failed %d\n", WSAGetLastError());
4222 else if (ret
== SOCKET_ERROR
)
4224 DWORD error
= WSAGetLastError();
4225 ok(error
== WSAEWOULDBLOCK
|| error
== WSAEINPROGRESS
,
4226 "expected 10035 or 10036, got %d\n", error
);
4232 static void test_accept(void)
4235 SOCKET server_socket
, accepted
= INVALID_SOCKET
, connector
;
4236 struct sockaddr_in address
;
4237 SOCKADDR_STORAGE ss
, ss_empty
;
4239 select_thread_params thread_params
;
4240 HANDLE thread_handle
= NULL
;
4243 memset(&address
, 0, sizeof(address
));
4244 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4245 address
.sin_family
= AF_INET
;
4247 socklen
= sizeof(address
);
4248 server_socket
= setup_server_socket(&address
, &socklen
);
4249 if (server_socket
== INVALID_SOCKET
)
4251 trace("error creating server socket: %d\n", WSAGetLastError());
4255 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4256 if (connector
== INVALID_SOCKET
) goto done
;
4258 trace("Blocking accept next\n");
4260 accepted
= WSAAccept(server_socket
, NULL
, NULL
, AlwaysDeferConditionFunc
, 0);
4261 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
4263 accepted
= accept(server_socket
, NULL
, 0);
4264 ok(accepted
!= INVALID_SOCKET
, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
4266 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
4267 if (server_ready
== INVALID_HANDLE_VALUE
)
4269 trace("error creating event: %d\n", GetLastError());
4273 thread_params
.s
= server_socket
;
4274 thread_params
.ReadKilled
= FALSE
;
4275 thread_handle
= CreateThread(NULL
, 0, AcceptKillThread
, &thread_params
, 0, &id
);
4276 if (thread_handle
== NULL
)
4278 trace("error creating thread: %d\n", GetLastError());
4282 WaitForSingleObject(server_ready
, INFINITE
);
4284 ret
= closesocket(server_socket
);
4287 trace("closesocket failed: %d\n", WSAGetLastError());
4291 WaitForSingleObject(thread_handle
, 1000);
4292 ok(thread_params
.ReadKilled
, "closesocket did not wake up accept\n");
4294 closesocket(accepted
);
4295 closesocket(connector
);
4296 accepted
= connector
= INVALID_SOCKET
;
4298 socklen
= sizeof(address
);
4299 server_socket
= setup_server_socket(&address
, &socklen
);
4300 if (server_socket
== INVALID_SOCKET
) goto done
;
4302 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4303 if (connector
== INVALID_SOCKET
) goto done
;
4306 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
4307 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
4308 ok(!socklen
, "got %d\n", socklen
);
4309 closesocket(connector
);
4310 connector
= INVALID_SOCKET
;
4312 socklen
= sizeof(address
);
4313 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4314 if (connector
== INVALID_SOCKET
) goto done
;
4316 accepted
= WSAAccept(server_socket
, NULL
, NULL
, NULL
, 0);
4317 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
4318 closesocket(accepted
);
4319 closesocket(connector
);
4320 accepted
= connector
= INVALID_SOCKET
;
4322 socklen
= sizeof(address
);
4323 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4324 if (connector
== INVALID_SOCKET
) goto done
;
4326 socklen
= sizeof(ss
);
4327 memset(&ss
, 0, sizeof(ss
));
4328 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
4329 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
4330 ok(socklen
!= sizeof(ss
), "unexpected length\n");
4331 ok(ss
.ss_family
, "family not set\n");
4332 closesocket(accepted
);
4333 closesocket(connector
);
4334 accepted
= connector
= INVALID_SOCKET
;
4336 socklen
= sizeof(address
);
4337 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4338 if (connector
== INVALID_SOCKET
) goto done
;
4341 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
4342 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
4343 ok(!socklen
, "got %d\n", socklen
);
4344 closesocket(connector
);
4345 accepted
= connector
= INVALID_SOCKET
;
4347 socklen
= sizeof(address
);
4348 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4349 if (connector
== INVALID_SOCKET
) goto done
;
4351 accepted
= accept(server_socket
, NULL
, NULL
);
4352 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
4353 closesocket(accepted
);
4354 closesocket(connector
);
4355 accepted
= connector
= INVALID_SOCKET
;
4357 socklen
= sizeof(address
);
4358 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4359 if (connector
== INVALID_SOCKET
) goto done
;
4361 socklen
= sizeof(ss
);
4362 memset(&ss
, 0, sizeof(ss
));
4363 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
4364 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
4365 ok(socklen
!= sizeof(ss
), "unexpected length\n");
4366 ok(ss
.ss_family
, "family not set\n");
4367 closesocket(accepted
);
4368 closesocket(connector
);
4369 accepted
= connector
= INVALID_SOCKET
;
4371 socklen
= sizeof(address
);
4372 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4373 if (connector
== INVALID_SOCKET
) goto done
;
4375 memset(&ss
, 0, sizeof(ss
));
4376 memset(&ss_empty
, 0, sizeof(ss_empty
));
4377 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, NULL
);
4378 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
4379 ok(!memcmp(&ss
, &ss_empty
, sizeof(ss
)), "structure is different\n");
4382 if (accepted
!= INVALID_SOCKET
)
4383 closesocket(accepted
);
4384 if (connector
!= INVALID_SOCKET
)
4385 closesocket(connector
);
4386 if (thread_handle
!= NULL
)
4387 CloseHandle(thread_handle
);
4388 if (server_ready
!= INVALID_HANDLE_VALUE
)
4389 CloseHandle(server_ready
);
4390 if (server_socket
!= INVALID_SOCKET
)
4391 closesocket(server_socket
);
4394 static void test_extendedSocketOptions(void)
4398 struct sockaddr_in sa
;
4399 int sa_len
= sizeof(struct sockaddr_in
);
4400 int optval
, optlen
= sizeof(int), ret
;
4404 if(WSAStartup(MAKEWORD(2,0), &wsa
)){
4405 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4409 memset(&sa
, 0, sa_len
);
4411 sa
.sin_family
= AF_INET
;
4412 sa
.sin_port
= htons(0);
4413 sa
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
4415 if((sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
4416 trace("Creating the socket failed: %d\n", WSAGetLastError());
4421 if(bind(sock
, (struct sockaddr
*) &sa
, sa_len
) < 0){
4422 trace("Failed to bind socket: %d\n", WSAGetLastError());
4428 ret
= getsockopt(sock
, SOL_SOCKET
, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
4430 ok(ret
== 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret
);
4431 ok((optval
== 65507) || (optval
== 65527),
4432 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval
);
4434 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
4435 SetLastError(0xdeadbeef);
4436 optval
= 0xdeadbeef;
4437 optlen
= sizeof(int);
4438 ret
= getsockopt(sock
, 0xffffffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
4439 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
4440 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4441 ret
, WSAGetLastError(), optval
, optval
);
4443 /* more invalid values for level */
4444 SetLastError(0xdeadbeef);
4445 optval
= 0xdeadbeef;
4446 optlen
= sizeof(int);
4447 ret
= getsockopt(sock
, 0x1234ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
4448 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
4449 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4450 ret
, WSAGetLastError(), optval
, optval
);
4452 SetLastError(0xdeadbeef);
4453 optval
= 0xdeadbeef;
4454 optlen
= sizeof(int);
4455 ret
= getsockopt(sock
, 0x8000ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
4456 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
4457 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4458 ret
, WSAGetLastError(), optval
, optval
);
4460 SetLastError(0xdeadbeef);
4461 optval
= 0xdeadbeef;
4462 optlen
= sizeof(int);
4463 ret
= getsockopt(sock
, 0x00008000, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
4464 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
4465 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4466 ret
, WSAGetLastError(), optval
, optval
);
4468 SetLastError(0xdeadbeef);
4469 optval
= 0xdeadbeef;
4470 optlen
= sizeof(int);
4471 ret
= getsockopt(sock
, 0x00000800, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
4472 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
4473 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4474 ret
, WSAGetLastError(), optval
, optval
);
4476 SetLastError(0xdeadbeef);
4477 optlen
= sizeof(LINGER
);
4478 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
4479 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAENOPROTOOPT
),
4480 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
4481 ret
, WSAGetLastError());
4484 if((sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
4485 trace("Creating the socket failed: %d\n", WSAGetLastError());
4490 if(bind(sock
, (struct sockaddr
*) &sa
, sa_len
) < 0){
4491 trace("Failed to bind socket: %d\n", WSAGetLastError());
4497 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
4498 ok(ret
== 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret
);
4500 optlen
= sizeof(BOOL
);
4501 ret
= getsockopt(sock
, SOL_SOCKET
, SO_DONTLINGER
, (char *)&bool_opt_val
, &optlen
);
4502 ok(ret
== 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret
);
4503 ok((linger_val
.l_onoff
&& !bool_opt_val
) || (!linger_val
.l_onoff
&& bool_opt_val
),
4504 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
4505 bool_opt_val
, linger_val
.l_onoff
);
4511 static void test_getsockname(void)
4515 struct sockaddr_in sa_set
, sa_get
;
4516 int sa_set_len
= sizeof(struct sockaddr_in
);
4517 int sa_get_len
= sa_set_len
;
4518 static const unsigned char null_padding
[] = {0,0,0,0,0,0,0,0};
4522 if(WSAStartup(MAKEWORD(2,0), &wsa
)){
4523 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4527 memset(&sa_set
, 0, sa_set_len
);
4529 sa_set
.sin_family
= AF_INET
;
4530 sa_set
.sin_port
= htons(0);
4531 sa_set
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
4533 if((sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
4534 trace("Creating the socket failed: %d\n", WSAGetLastError());
4540 if (getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
) == 0)
4541 ok(0, "getsockname on unbound socket should fail\n");
4543 ok(WSAGetLastError() == WSAEINVAL
, "getsockname on unbound socket "
4544 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL
);
4545 ok(memcmp(&sa_get
, &sa_set
, sizeof(sa_get
)) == 0,
4546 "failed getsockname modified sockaddr when it shouldn't\n");
4549 if(bind(sock
, (struct sockaddr
*) &sa_set
, sa_set_len
) < 0){
4550 trace("Failed to bind socket: %d\n", WSAGetLastError());
4556 if(getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
) != 0){
4557 trace("Failed to call getsockname: %d\n", WSAGetLastError());
4563 ret
= memcmp(sa_get
.sin_zero
, null_padding
, 8);
4564 ok(ret
== 0, "getsockname did not zero the sockaddr_in structure\n");
4568 h
= gethostbyname("");
4569 if (h
&& h
->h_length
== 4) /* this test is only meaningful in IPv4 */
4572 for (i
= 0; h
->h_addr_list
[i
]; i
++)
4576 ip
.s_addr
= *(ULONG
*) h
->h_addr_list
[i
];
4578 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
4579 ok(sock
!= INVALID_SOCKET
, "socket failed with %d\n", GetLastError());
4581 memset(&sa_set
, 0, sizeof(sa_set
));
4582 sa_set
.sin_family
= AF_INET
;
4583 sa_set
.sin_addr
.s_addr
= ip
.s_addr
;
4584 /* The same address we bind must be the same address we get */
4585 ret
= bind(sock
, (struct sockaddr
*)&sa_set
, sizeof(sa_set
));
4586 ok(ret
== 0, "bind failed with %d\n", GetLastError());
4587 sa_get_len
= sizeof(sa_get
);
4588 ret
= getsockname(sock
, (struct sockaddr
*)&sa_get
, &sa_get_len
);
4589 ok(ret
== 0, "getsockname failed with %d\n", GetLastError());
4590 strcpy(ipstr
, inet_ntoa(sa_get
.sin_addr
));
4591 trace("testing bind on interface %s\n", ipstr
);
4592 ok(sa_get
.sin_addr
.s_addr
== sa_set
.sin_addr
.s_addr
,
4593 "address does not match: %s != %s\n", ipstr
, inet_ntoa(sa_set
.sin_addr
));
4602 static void test_dns(void)
4613 h
= gethostbyname("");
4614 ok(h
!= NULL
, "gethostbyname(\"\") failed with %d\n", h_errno
);
4616 /* Use an address with valid alias names if possible */
4617 h
= gethostbyname("source.winehq.org");
4620 skip("Can't test the hostent structure because gethostbyname failed\n");
4624 /* The returned struct must be allocated in a very strict way. First we need to
4625 * count how many aliases there are because they must be located right after
4626 * the struct hostent size. Knowing the amount of aliases we know the exact
4627 * location of the first IP returned. Rule valid for >= XP, for older OS's
4628 * it's somewhat the opposite. */
4630 if(h
->h_addr_list
== addr
.mem
) /* <= W2K */
4632 win_skip("Skipping hostent tests since this OS is unsupported\n");
4636 ok(h
->h_aliases
== addr
.mem
,
4637 "hostent->h_aliases should be in %p, it is in %p\n", addr
.mem
, h
->h_aliases
);
4639 for(ptr
= h
->h_aliases
, acount
= 1; *ptr
; ptr
++) acount
++;
4640 addr
.chr
+= sizeof(*ptr
) * acount
;
4641 ok(h
->h_addr_list
== addr
.mem
,
4642 "hostent->h_addr_list should be in %p, it is in %p\n", addr
.mem
, h
->h_addr_list
);
4644 for(ptr
= h
->h_addr_list
, acount
= 1; *ptr
; ptr
++) acount
++;
4646 addr
.chr
+= sizeof(*ptr
) * acount
;
4647 ok(h
->h_addr_list
[0] == addr
.mem
,
4648 "hostent->h_addr_list[0] should be in %p, it is in %p\n", addr
.mem
, h
->h_addr_list
[0]);
4651 /* Our winsock headers don't define gethostname because it conflicts with the
4652 * definition in unistd.h. Define it here to get rid of the warning. */
4654 int WINAPI
gethostname(char *name
, int namelen
);
4656 static void test_gethostbyname(void)
4659 struct in_addr
**addr_list
;
4660 char name
[256], first_ip
[16];
4662 PMIB_IPFORWARDTABLE routes
= NULL
;
4663 PIP_ADAPTER_INFO adapters
= NULL
, k
;
4664 DWORD adap_size
= 0, route_size
= 0;
4665 BOOL found_default
= FALSE
;
4666 BOOL local_ip
= FALSE
;
4668 ret
= gethostname(name
, sizeof(name
));
4669 ok(ret
== 0, "gethostname() call failed: %d\n", WSAGetLastError());
4671 he
= gethostbyname(name
);
4672 ok(he
!= NULL
, "gethostbyname(\"%s\") failed: %d\n", name
, WSAGetLastError());
4673 addr_list
= (struct in_addr
**)he
->h_addr_list
;
4674 strcpy(first_ip
, inet_ntoa(*addr_list
[0]));
4676 trace("List of local IPs:\n");
4677 for(count
= 0; addr_list
[count
] != NULL
; count
++)
4679 char *ip
= inet_ntoa(*addr_list
[count
]);
4680 if (!strcmp(ip
, "127.0.0.1"))
4687 ok (count
== 1, "expected 127.0.0.1 to be the only IP returned\n");
4688 skip("Only the loopback address is present, skipping tests\n");
4692 if (!pGetAdaptersInfo
|| !pGetIpForwardTable
)
4694 win_skip("GetAdaptersInfo and/or GetIpForwardTable not found, skipping tests\n");
4698 ret
= pGetAdaptersInfo(NULL
, &adap_size
);
4699 ok (ret
== ERROR_BUFFER_OVERFLOW
, "GetAdaptersInfo failed with a different error: %d\n", ret
);
4700 ret
= pGetIpForwardTable(NULL
, &route_size
, FALSE
);
4701 ok (ret
== ERROR_INSUFFICIENT_BUFFER
, "GetIpForwardTable failed with a different error: %d\n", ret
);
4703 adapters
= HeapAlloc(GetProcessHeap(), 0, adap_size
);
4704 routes
= HeapAlloc(GetProcessHeap(), 0, route_size
);
4706 ret
= pGetAdaptersInfo(adapters
, &adap_size
);
4707 ok (ret
== NO_ERROR
, "GetAdaptersInfo failed, error: %d\n", ret
);
4708 ret
= pGetIpForwardTable(routes
, &route_size
, FALSE
);
4709 ok (ret
== NO_ERROR
, "GetIpForwardTable failed, error: %d\n", ret
);
4711 /* This test only has meaning if there is more than one IP configured */
4712 if (adapters
->Next
== NULL
&& count
== 1)
4714 skip("Only one IP is present, skipping tests\n");
4718 for (i
= 0; !found_default
&& i
< routes
->dwNumEntries
; i
++)
4720 /* default route (ip 0.0.0.0) ? */
4721 if (routes
->table
[i
].dwForwardDest
) continue;
4723 for (k
= adapters
; k
!= NULL
; k
= k
->Next
)
4727 if (k
->Index
!= routes
->table
[i
].dwForwardIfIndex
) continue;
4729 /* the first IP returned from gethostbyname must be a default route */
4730 ip
= k
->IpAddressList
.IpAddress
.String
;
4731 if (!strcmp(first_ip
, ip
))
4733 found_default
= TRUE
;
4738 ok (found_default
, "failed to find the first IP from gethostbyname!\n");
4741 HeapFree(GetProcessHeap(), 0, adapters
);
4742 HeapFree(GetProcessHeap(), 0, routes
);
4745 static void test_gethostbyname_hack(void)
4749 static BYTE loopback
[] = {127, 0, 0, 1};
4750 static BYTE magic_loopback
[] = {127, 12, 34, 56};
4753 ret
= gethostname(name
, 256);
4754 ok(ret
== 0, "gethostname() call failed: %d\n", WSAGetLastError());
4756 he
= gethostbyname("localhost");
4757 ok(he
!= NULL
, "gethostbyname(\"localhost\") failed: %d\n", h_errno
);
4760 if(he
->h_length
!= 4)
4762 skip("h_length is %d, not IPv4, skipping test.\n", he
->h_length
);
4766 ok(memcmp(he
->h_addr_list
[0], loopback
, he
->h_length
) == 0,
4767 "gethostbyname(\"localhost\") returned %u.%u.%u.%u\n",
4768 he
->h_addr_list
[0][0], he
->h_addr_list
[0][1], he
->h_addr_list
[0][2],
4769 he
->h_addr_list
[0][3]);
4772 if(strcmp(name
, "localhost") == 0)
4774 skip("hostname seems to be \"localhost\", skipping test.\n");
4778 he
= gethostbyname(name
);
4779 ok(he
!= NULL
, "gethostbyname(\"%s\") failed: %d\n", name
, h_errno
);
4782 if(he
->h_length
!= 4)
4784 skip("h_length is %d, not IPv4, skipping test.\n", he
->h_length
);
4788 if (he
->h_addr_list
[0][0] == 127)
4790 ok(memcmp(he
->h_addr_list
[0], magic_loopback
, he
->h_length
) == 0,
4791 "gethostbyname(\"%s\") returned %u.%u.%u.%u not 127.12.34.56\n",
4792 name
, he
->h_addr_list
[0][0], he
->h_addr_list
[0][1],
4793 he
->h_addr_list
[0][2], he
->h_addr_list
[0][3]);
4797 gethostbyname("nonexistent.winehq.org");
4798 /* Don't check for the return value, as some braindead ISPs will kindly
4799 * resolve nonexistent host names to addresses of the ISP's spam pages. */
4802 static void test_gethostname(void)
4808 WSASetLastError(0xdeadbeef);
4809 ret
= gethostname(NULL
, 256);
4810 ok(ret
== -1, "gethostname() returned %d\n", ret
);
4811 ok(WSAGetLastError() == WSAEFAULT
, "gethostname with null buffer "
4812 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT
);
4814 ret
= gethostname(name
, sizeof(name
));
4815 ok(ret
== 0, "gethostname() call failed: %d\n", WSAGetLastError());
4816 he
= gethostbyname(name
);
4817 ok(he
!= NULL
, "gethostbyname(\"%s\") failed: %d\n", name
, WSAGetLastError());
4820 WSASetLastError(0xdeadbeef);
4821 strcpy(name
, "deadbeef");
4822 ret
= gethostname(name
, len
);
4823 ok(ret
== -1, "gethostname() returned %d\n", ret
);
4824 ok(!strcmp(name
, "deadbeef"), "name changed unexpected!\n");
4825 ok(WSAGetLastError() == WSAEFAULT
, "gethostname with insufficient length "
4826 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT
);
4829 ret
= gethostname(name
, len
);
4830 ok(ret
== 0, "gethostname() call failed: %d\n", WSAGetLastError());
4831 he
= gethostbyname(name
);
4832 ok(he
!= NULL
, "gethostbyname(\"%s\") failed: %d\n", name
, WSAGetLastError());
4835 static void test_inet_addr(void)
4839 addr
= inet_addr(NULL
);
4840 ok(addr
== INADDR_NONE
, "inet_addr succeeded unexpectedly\n");
4843 static void test_addr_to_print(void)
4849 struct in6_addr in6
;
4851 u_long addr0_Num
= 0x00000000;
4852 PCSTR addr0_Str
= "0.0.0.0";
4853 u_long addr1_Num
= 0x20201015;
4854 PCSTR addr1_Str
= "21.16.32.32";
4855 u_char addr2_Num
[16] = {0,0,0,0,0,0,0,0,0,0,0xff,0xfe,0xcC,0x98,0xbd,0x74};
4856 PCSTR addr2_Str
= "::fffe:cc98:bd74";
4857 u_char addr3_Num
[16] = {0x20,0x30,0xa4,0xb1};
4858 PCSTR addr3_Str
= "2030:a4b1::";
4859 u_char addr4_Num
[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0xcC,0x98,0xbd,0x74};
4860 PCSTR addr4_Str
= "::204.152.189.116";
4862 /* Test IPv4 addresses */
4863 in
.s_addr
= addr0_Num
;
4865 pdst
= inet_ntoa(*((struct in_addr
*)&in
.s_addr
));
4866 ok(pdst
!= NULL
, "inet_ntoa failed %s\n", dst
);
4867 ok(!strcmp(pdst
, addr0_Str
),"Address %s != %s\n", pdst
, addr0_Str
);
4869 /* Test that inet_ntoa and inet_ntop return the same value */
4870 in
.S_un
.S_addr
= addr1_Num
;
4871 pdst
= inet_ntoa(*((struct in_addr
*)&in
.s_addr
));
4872 ok(pdst
!= NULL
, "inet_ntoa failed %s\n", dst
);
4873 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
4875 /* InetNtop became available in Vista and Win2008 */
4878 win_skip("InetNtop not present, not executing tests\n");
4882 /* Second part of test */
4883 pdst
= pInetNtop(AF_INET
,(void*)&in
.s_addr
, dst
, sizeof(dst
));
4884 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst
);
4885 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
4887 /* Test invalid parm conditions */
4888 pdst
= pInetNtop(1, (void*)&in
.s_addr
, dst
, sizeof(dst
));
4889 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4890 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "Should be WSAEAFNOSUPPORT\n");
4892 /* Test Null destination */
4894 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, NULL
, sizeof(dst
));
4895 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4896 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4897 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4899 /* Test zero length passed */
4902 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, 0);
4903 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4904 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4905 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4907 /* Test length one shorter than the address length */
4910 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, 6);
4911 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4912 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4913 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4915 /* Test longer length is ok */
4918 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, sizeof(dst
)+1);
4919 ok(pdst
!= NULL
, "The pointer should be returned (%p)\n", pdst
);
4920 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
4922 /* Test the IPv6 addresses */
4924 /* Test an zero prefixed IPV6 address */
4925 memcpy(in6
.u
.Byte
, addr2_Num
, sizeof(addr2_Num
));
4926 pdst
= pInetNtop(AF_INET6
,(void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
4927 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
4928 ok(!strcmp(pdst
, addr2_Str
),"Address %s != %s\n", pdst
, addr2_Str
);
4930 /* Test an zero suffixed IPV6 address */
4931 memcpy(in6
.s6_addr
, addr3_Num
, sizeof(addr3_Num
));
4932 pdst
= pInetNtop(AF_INET6
,(void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
4933 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
4934 ok(!strcmp(pdst
, addr3_Str
),"Address %s != %s\n", pdst
, addr3_Str
);
4936 /* Test the IPv6 address contains the IPv4 address in IPv4 notation */
4937 memcpy(in6
.s6_addr
, addr4_Num
, sizeof(addr4_Num
));
4938 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
4939 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
4940 ok(!strcmp(pdst
, addr4_Str
),"Address %s != %s\n", pdst
, addr4_Str
);
4942 /* Test invalid parm conditions */
4943 memcpy(in6
.u
.Byte
, addr2_Num
, sizeof(addr2_Num
));
4945 /* Test Null destination */
4947 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, NULL
, sizeof(dst6
));
4948 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4949 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4950 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4952 /* Test zero length passed */
4955 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 0);
4956 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4957 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4958 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4960 /* Test length one shorter than the address length */
4963 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 16);
4964 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4965 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4966 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4968 /* Test longer length is ok */
4971 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 18);
4972 ok(pdst
!= NULL
, "The pointer should be returned (%p)\n", pdst
);
4974 static void test_inet_pton(void)
4980 const char *printable
, *collapsed
, *raw_data
;
4982 {AF_UNSPEC
, -1, WSAEFAULT
, /* Test 0 */
4984 {AF_INET
, -1, WSAEFAULT
,
4986 {AF_INET6
, -1, WSAEFAULT
,
4988 {AF_UNSPEC
, -1, WSAEAFNOSUPPORT
,
4989 "127.0.0.1", NULL
, NULL
},
4991 "127.0.0.1", "127.0.0.1",
4992 "\x7f\x00\x00\x01"},
4994 "127.0.0.1", "127.0.0.1", NULL
},
4996 "::1/128", NULL
, NULL
},
4998 "::1/128", NULL
, NULL
},
4999 {AF_UNSPEC
, -1, WSAEAFNOSUPPORT
,
5000 "broken", NULL
, NULL
},
5002 "broken", NULL
, NULL
},
5003 {AF_INET6
, 0, 0, /* Test 10 */
5004 "broken", NULL
, NULL
},
5005 {AF_UNSPEC
, -1, WSAEAFNOSUPPORT
,
5006 "177.32.45.20", NULL
, NULL
},
5008 "177.32.45.20", "177.32.45.20",
5009 "\xb1\x20\x2d\x14"},
5011 "177.32.45.20", NULL
, NULL
},
5013 "2607:f0d0:1002:51::4", NULL
, NULL
},
5015 "2607:f0d0:1002:51::4", "2607:f0d0:1002:51::4",
5016 "\x26\x07\xf0\xd0\x10\x02\x00\x51\x00\x00\x00\x00\x00\x00\x00\x04"},
5018 "::177.32.45.20", NULL
, NULL
},
5020 "::177.32.45.20", "::177.32.45.20",
5021 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x20\x2d\x14"},
5023 "fe80::0202:b3ff:fe1e:8329", NULL
, NULL
},
5025 "fe80::0202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
5026 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
5027 {AF_INET6
, 1, 0, /* Test 20 */
5028 "fe80::202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
5029 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
5035 "a.b.c", NULL
, NULL
},
5037 "a.b.c.d", NULL
, NULL
},
5039 "2001:cdba:0000:0000:0000:0000:3257:9652", "2001:cdba::3257:9652",
5040 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
5042 "2001:cdba::3257:9652", "2001:cdba::3257:9652",
5043 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
5045 "2001:cdba:0:0:0:0:3257:9652", "2001:cdba::3257:9652",
5046 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"}
5050 char buffer
[64],str
[64];
5051 WCHAR printableW
[64], collapsedW
[64];
5055 /* InetNtop and InetPton became available in Vista and Win2008 */
5056 if (!pInetNtop
|| !pInetNtopW
|| !pInetPtonA
|| !pInetPtonW
)
5058 win_skip("InetNtop and/or InetPton not present, not executing tests\n");
5062 for (i
= 0; i
< sizeof(tests
) / sizeof(tests
[0]); i
++)
5064 WSASetLastError(0xdeadbeef);
5065 ret
= pInetPtonA(tests
[i
].family
, tests
[i
].printable
, buffer
);
5066 ok (ret
== tests
[i
].ret
, "Test [%d]: Expected %d, got %d\n", i
, tests
[i
].ret
, ret
);
5067 if (tests
[i
].ret
== -1)
5069 err
= WSAGetLastError();
5070 ok (tests
[i
].err
== err
, "Test [%d]: Expected 0x%x, got 0x%x\n", i
, tests
[i
].err
, err
);
5072 if (tests
[i
].ret
!= 1) continue;
5073 ok (memcmp(buffer
, tests
[i
].raw_data
,
5074 tests
[i
].family
== AF_INET
? sizeof(struct in_addr
) : sizeof(struct in6_addr
)) == 0,
5075 "Test [%d]: Expected binary data differs\n", i
);
5077 /* Test the result from Pton with Ntop */
5078 strcpy (str
, "deadbeef");
5079 ptr
= pInetNtop(tests
[i
].family
, buffer
, str
, sizeof(str
));
5080 ok (ptr
!= NULL
, "Test [%d]: Failed with NULL\n", i
);
5081 ok (ptr
== str
, "Test [%d]: Pointers differ (%p != %p)\n", i
, ptr
, str
);
5083 ok (strcmp(ptr
, tests
[i
].collapsed
) == 0, "Test [%d]: Expected '%s', got '%s'\n",
5084 i
, tests
[i
].collapsed
, ptr
);
5087 for (i
= 0; i
< sizeof(tests
) / sizeof(tests
[0]); i
++)
5089 if (tests
[i
].printable
)
5090 MultiByteToWideChar(CP_ACP
, 0, tests
[i
].printable
, -1, printableW
,
5091 sizeof(printableW
) / sizeof(printableW
[0]));
5092 WSASetLastError(0xdeadbeef);
5093 ret
= pInetPtonW(tests
[i
].family
, tests
[i
].printable
? printableW
: NULL
, buffer
);
5094 ok(ret
== tests
[i
].ret
, "Test [%d]: Expected %d, got %d\n", i
, tests
[i
].ret
, ret
);
5095 if (tests
[i
].ret
== -1)
5097 err
= WSAGetLastError();
5098 ok(tests
[i
].err
== err
, "Test [%d]: Expected 0x%x, got 0x%x\n", i
, tests
[i
].err
, err
);
5100 if (tests
[i
].ret
!= 1) continue;
5101 ok(memcmp(buffer
, tests
[i
].raw_data
,
5102 tests
[i
].family
== AF_INET
? sizeof(struct in_addr
) : sizeof(struct in6_addr
)) == 0,
5103 "Test [%d]: Expected binary data differs\n", i
);
5105 /* Test the result from Pton with Ntop */
5106 printableW
[0] = 0xdead;
5107 ptrW
= pInetNtopW(tests
[i
].family
, buffer
, printableW
, sizeof(printableW
) / sizeof(printableW
[0]));
5108 ok (ptrW
!= NULL
, "Test [%d]: Failed with NULL\n", i
);
5109 ok (ptrW
== printableW
, "Test [%d]: Pointers differ (%p != %p)\n", i
, ptrW
, printableW
);
5110 if (!ptrW
) continue;
5112 MultiByteToWideChar(CP_ACP
, 0, tests
[i
].collapsed
, -1, collapsedW
,
5113 sizeof(collapsedW
) / sizeof(collapsedW
[0]));
5114 ok (lstrcmpW(ptrW
, collapsedW
) == 0, "Test [%d]: Expected '%s', got '%s'\n",
5115 i
, tests
[i
].collapsed
, wine_dbgstr_w(ptrW
));
5119 static void test_ioctlsocket(void)
5121 SOCKET sock
, src
, dst
;
5122 struct tcp_keepalive kalive
;
5124 static const LONG cmds
[] = {FIONBIO
, FIONREAD
, SIOCATMARK
};
5130 sock
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5131 ok(sock
!= INVALID_SOCKET
, "Creating the socket failed: %d\n", WSAGetLastError());
5132 if(sock
== INVALID_SOCKET
)
5134 skip("Can't continue without a socket.\n");
5138 for(i
= 0; i
< sizeof(cmds
)/sizeof(cmds
[0]); i
++)
5140 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
5141 ret
= ioctlsocket(sock
, cmds
[i
], (u_long
*)1);
5142 ok(ret
== SOCKET_ERROR
, "ioctlsocket succeeded unexpectedly\n");
5143 ret
= WSAGetLastError();
5144 ok(ret
== WSAEFAULT
, "expected WSAEFAULT, got %d instead\n", ret
);
5147 /* A fresh and not connected socket has no urgent data, this test shows
5148 * that normal(not urgent) data returns a non-zero value for SIOCATMARK. */
5150 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
5151 ok(ret
!= SOCKET_ERROR
, "ioctlsocket failed unexpectedly\n");
5152 ok(arg
, "SIOCATMARK expected a non-zero value\n");
5154 /* when SO_OOBINLINE is set SIOCATMARK must always return TRUE */
5156 ret
= setsockopt(sock
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&optval
, sizeof(optval
));
5157 ok(ret
!= SOCKET_ERROR
, "setsockopt failed unexpectedly\n");
5159 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
5160 ok(ret
!= SOCKET_ERROR
, "ioctlsocket failed unexpectedly\n");
5161 ok(arg
, "SIOCATMARK expected a non-zero value\n");
5163 /* disable SO_OOBINLINE and get the same old behavior */
5165 ret
= setsockopt(sock
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&optval
, sizeof(optval
));
5166 ok(ret
!= SOCKET_ERROR
, "setsockopt failed unexpectedly\n");
5168 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
5169 ok(ret
!= SOCKET_ERROR
, "ioctlsocket failed unexpectedly\n");
5170 ok(arg
, "SIOCATMARK expected a non-zero value\n");
5172 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &arg
, 0, NULL
, 0, &arg
, NULL
, NULL
);
5173 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
5174 ret
= WSAGetLastError();
5175 ok(ret
== WSAEFAULT
|| broken(ret
== WSAEINVAL
), "expected WSAEFAULT, got %d instead\n", ret
);
5177 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, NULL
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5178 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
5179 ret
= WSAGetLastError();
5180 ok(ret
== WSAEFAULT
|| broken(ret
== WSAEINVAL
), "expected WSAEFAULT, got %d instead\n", ret
);
5182 make_keepalive(kalive
, 0, 0, 0);
5183 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5184 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
5186 make_keepalive(kalive
, 1, 0, 0);
5187 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5188 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
5190 make_keepalive(kalive
, 1, 1000, 1000);
5191 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5192 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
5194 make_keepalive(kalive
, 1, 10000, 10000);
5195 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5196 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
5198 make_keepalive(kalive
, 1, 100, 100);
5199 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5200 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
5202 make_keepalive(kalive
, 0, 100, 100);
5203 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5204 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
5208 if (tcp_socketpair(&src
, &dst
) != 0)
5210 ok(0, "creating socket pair failed, skipping test\n");
5214 /* test FIONREAD on TCP sockets */
5215 optval
= 0xdeadbeef;
5216 ret
= WSAIoctl(dst
, FIONREAD
, NULL
, 0, &optval
, sizeof(optval
), &arg
, NULL
, NULL
);
5217 ok(ret
== 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
5218 ok(optval
== 0, "FIONREAD should have returned 0 bytes, got %d instead\n", optval
);
5220 optval
= 0xdeadbeef;
5221 ok(send(src
, "TEST", 4, 0) == 4, "failed to send test data\n");
5223 ret
= WSAIoctl(dst
, FIONREAD
, NULL
, 0, &optval
, sizeof(optval
), &arg
, NULL
, NULL
);
5224 ok(ret
== 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
5225 ok(optval
== 4, "FIONREAD should have returned 4 bytes, got %d instead\n", optval
);
5227 /* trying to read from an OOB inlined socket with MSG_OOB results in WSAEINVAL */
5228 set_blocking(dst
, FALSE
);
5230 SetLastError(0xdeadbeef);
5231 ret
= recv(dst
, &data
, 1, i
);
5232 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
5233 ret
= GetLastError();
5234 ok(ret
== WSAEWOULDBLOCK
, "expected 10035, got %d\n", ret
);
5235 bufs
.len
= sizeof(char);
5237 ret
= WSARecv(dst
, &bufs
, 1, &bytes_rec
, &i
, NULL
, NULL
);
5238 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
5239 ret
= GetLastError();
5240 ok(ret
== WSAEWOULDBLOCK
, "expected 10035, got %d\n", ret
);
5242 ret
= setsockopt(dst
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&optval
, sizeof(optval
));
5243 ok(ret
!= SOCKET_ERROR
, "setsockopt failed unexpectedly\n");
5245 SetLastError(0xdeadbeef);
5246 ret
= recv(dst
, &data
, 1, i
);
5247 ok(ret
== SOCKET_ERROR
, "expected SOCKET_ERROR, got %d\n", ret
);
5248 ret
= GetLastError();
5249 ok(ret
== WSAEINVAL
, "expected 10022, got %d\n", ret
);
5250 bufs
.len
= sizeof(char);
5252 ret
= WSARecv(dst
, &bufs
, 1, &bytes_rec
, &i
, NULL
, NULL
);
5253 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
5254 ret
= GetLastError();
5255 ok(ret
== WSAEINVAL
, "expected 10022, got %d\n", ret
);
5258 optval
= 0xdeadbeef;
5259 ret
= WSAIoctl(dst
, FIONREAD
, NULL
, 0, &optval
, sizeof(optval
), &arg
, NULL
, NULL
);
5260 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
5261 ok(optval
== 0xdeadbeef, "FIONREAD should not have changed last error, got %d instead\n", optval
);
5265 static BOOL drain_pause
= FALSE
;
5266 static DWORD WINAPI
drain_socket_thread(LPVOID arg
)
5269 SOCKET sock
= *(SOCKET
*)arg
;
5272 while ((ret
= recv(sock
, buffer
, sizeof(buffer
), 0)) != 0)
5276 if (WSAGetLastError() == WSAEWOULDBLOCK
)
5280 FD_SET(sock
, &readset
);
5281 select(sock
+1, &readset
, NULL
, NULL
, NULL
);
5292 static void test_send(void)
5294 SOCKET src
= INVALID_SOCKET
;
5295 SOCKET dst
= INVALID_SOCKET
;
5296 HANDLE hThread
= NULL
;
5297 const int buflen
= 1024*1024;
5298 char *buffer
= NULL
;
5299 int ret
, i
, zero
= 0;
5303 DWORD id
, bytes_sent
, dwRet
;
5305 memset(&ov
, 0, sizeof(ov
));
5307 if (tcp_socketpair(&src
, &dst
) != 0)
5309 ok(0, "creating socket pair failed, skipping test\n");
5313 set_blocking(dst
, FALSE
);
5314 /* force disable buffering so we can get a pending overlapped request */
5315 ret
= setsockopt(dst
, SOL_SOCKET
, SO_SNDBUF
, (char *) &zero
, sizeof(zero
));
5316 ok(!ret
, "setsockopt SO_SNDBUF failed: %d - %d\n", ret
, GetLastError());
5318 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
5319 if (hThread
== NULL
)
5321 ok(0, "CreateThread failed, error %d\n", GetLastError());
5325 buffer
= HeapAlloc(GetProcessHeap(), 0, buflen
);
5328 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
5332 /* fill the buffer with some nonsense */
5333 for (i
= 0; i
< buflen
; ++i
)
5335 buffer
[i
] = (char) i
;
5338 ret
= send(src
, buffer
, buflen
, 0);
5340 ok(ret
== buflen
, "send should have sent %d bytes, but it only sent %d\n", buflen
, ret
);
5342 ok(0, "send failed, error %d\n", WSAGetLastError());
5347 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5348 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
5353 WSASetLastError(12345);
5354 ret
= WSASend(dst
, &buf
, 1, &bytes_sent
, 0, &ov
, NULL
);
5355 ok((ret
== SOCKET_ERROR
&& WSAGetLastError() == ERROR_IO_PENDING
) || broken(bytes_sent
== buflen
),
5356 "Failed to start overlapped send %d - %d - %d/%d\n", ret
, WSAGetLastError(), bytes_sent
, buflen
);
5358 /* don't check for completion yet, we may need to drain the buffer while still sending */
5359 set_blocking(src
, FALSE
);
5360 for (i
= 0; i
< buflen
; ++i
)
5364 ret
= recv(src
, buffer
, 1, 0);
5365 while (ret
== SOCKET_ERROR
&& GetLastError() == WSAEWOULDBLOCK
&& j
< 100)
5369 ret
= recv(src
, buffer
, 1, 0);
5372 ok(ret
== 1, "Failed to receive data %d - %d (got %d/%d)\n", ret
, GetLastError(), i
, buflen
);
5376 ok(buffer
[0] == (char) i
, "Received bad data at position %d\n", i
);
5379 dwRet
= WaitForSingleObject(ov
.hEvent
, 1000);
5380 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
5381 if (dwRet
== WAIT_OBJECT_0
)
5383 bret
= GetOverlappedResult((HANDLE
)dst
, &ov
, &bytes_sent
, FALSE
);
5384 ok(bret
&& bytes_sent
== buflen
,
5385 "Got %d instead of %d (%d - %d)\n", bytes_sent
, buflen
, bret
, GetLastError());
5388 WSASetLastError(12345);
5389 ret
= WSASend(INVALID_SOCKET
, &buf
, 1, NULL
, 0, &ov
, NULL
);
5390 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
5391 "WSASend failed %d - %d\n", ret
, WSAGetLastError());
5393 WSASetLastError(12345);
5394 ret
= WSASend(dst
, &buf
, 1, NULL
, 0, &ov
, NULL
);
5395 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == ERROR_IO_PENDING
,
5396 "Failed to start overlapped send %d - %d\n", ret
, WSAGetLastError());
5399 if (src
!= INVALID_SOCKET
)
5401 if (dst
!= INVALID_SOCKET
)
5403 if (hThread
!= NULL
)
5405 dwRet
= WaitForSingleObject(hThread
, 500);
5406 ok(dwRet
== WAIT_OBJECT_0
, "failed to wait for thread termination: %d\n", GetLastError());
5407 CloseHandle(hThread
);
5410 CloseHandle(ov
.hEvent
);
5411 HeapFree(GetProcessHeap(), 0, buffer
);
5414 typedef struct async_message
5418 struct async_message
*next
;
5421 static struct async_message
*messages_received
;
5423 #define WM_SOCKET (WM_USER+100)
5424 static LRESULT CALLBACK
ws2_test_WndProc(HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
5426 struct async_message
*message
;
5431 message
= HeapAlloc(GetProcessHeap(), 0, sizeof(*message
));
5432 message
->socket
= (SOCKET
) wparam
;
5433 message
->lparam
= lparam
;
5434 message
->next
= NULL
;
5436 if (messages_received
)
5438 struct async_message
*last
= messages_received
;
5439 while (last
->next
) last
= last
->next
;
5440 last
->next
= message
;
5443 messages_received
= message
;
5447 return DefWindowProcA(hwnd
, msg
, wparam
, lparam
);
5450 static void get_event_details(int event
, int *bit
, char *name
)
5455 if (bit
) *bit
= FD_ACCEPT_BIT
;
5456 if (name
) strcpy(name
, "FD_ACCEPT");
5459 if (bit
) *bit
= FD_CONNECT_BIT
;
5460 if (name
) strcpy(name
, "FD_CONNECT");
5463 if (bit
) *bit
= FD_READ_BIT
;
5464 if (name
) strcpy(name
, "FD_READ");
5467 if (bit
) *bit
= FD_OOB_BIT
;
5468 if (name
) strcpy(name
, "FD_OOB");
5471 if (bit
) *bit
= FD_WRITE_BIT
;
5472 if (name
) strcpy(name
, "FD_WRITE");
5475 if (bit
) *bit
= FD_CLOSE_BIT
;
5476 if (name
) strcpy(name
, "FD_CLOSE");
5480 if (name
) sprintf(name
, "bad%x", event
);
5484 static const char *dbgstr_event_seq(const LPARAM
*seq
)
5486 static char message
[1024];
5494 get_event_details(WSAGETSELECTEVENT(*seq
), NULL
, name
);
5495 len
+= sprintf(message
+ len
, "%s(%d) ", name
, WSAGETSELECTERROR(*seq
));
5499 strcpy( message
+ len
, "]" );
5503 static char *dbgstr_event_seq_result(SOCKET s
, WSANETWORKEVENTS
*netEvents
)
5505 static char message
[1024];
5506 struct async_message
*curr
= messages_received
;
5507 int index
, error
, bit
= 0;
5517 if (bit
>= FD_MAX_EVENTS
) break;
5518 if ( !(netEvents
->lNetworkEvents
& (1 << bit
)) )
5523 get_event_details(1 << bit
, &index
, name
);
5524 error
= netEvents
->iErrorCode
[index
];
5530 if (curr
->socket
!= s
)
5535 get_event_details(WSAGETSELECTEVENT(curr
->lparam
), NULL
, name
);
5536 error
= WSAGETSELECTERROR(curr
->lparam
);
5540 len
+= sprintf(message
+ len
, "%s(%d) ", name
, error
);
5543 strcpy( message
+ len
, "]" );
5547 static void flush_events(SOCKET s
, HANDLE hEvent
)
5549 WSANETWORKEVENTS netEvents
;
5550 struct async_message
*prev
= NULL
, *curr
= messages_received
;
5554 if (hEvent
!= INVALID_HANDLE_VALUE
)
5556 dwRet
= WaitForSingleObject(hEvent
, 100);
5557 if (dwRet
== WAIT_OBJECT_0
)
5559 ret
= WSAEnumNetworkEvents(s
, hEvent
, &netEvents
);
5561 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret
);
5568 if (curr
->socket
== s
)
5570 if (prev
) prev
->next
= curr
->next
;
5571 else messages_received
= curr
->next
;
5573 HeapFree(GetProcessHeap(), 0, curr
);
5575 if (prev
) curr
= prev
->next
;
5576 else curr
= messages_received
;
5587 static int match_event_sequence(SOCKET s
, WSANETWORKEVENTS
*netEvents
, const LPARAM
*seq
)
5589 int event
, index
, error
, events
;
5590 struct async_message
*curr
;
5594 events
= netEvents
->lNetworkEvents
;
5597 event
= WSAGETSELECTEVENT(*seq
);
5598 error
= WSAGETSELECTERROR(*seq
);
5599 get_event_details(event
, &index
, NULL
);
5601 if (!(events
& event
) && index
!= -1)
5603 if (events
& event
&& index
!= -1)
5605 if (netEvents
->iErrorCode
[index
] != error
)
5616 curr
= messages_received
;
5619 if (curr
->socket
== s
)
5621 if (!*seq
) return 0;
5622 if (*seq
!= curr
->lparam
) return 0;
5633 /* checks for a sequence of events, (order only checked if window is used) */
5634 static void ok_event_sequence(SOCKET s
, HANDLE hEvent
, const LPARAM
*seq
, const LPARAM
**broken_seqs
, int completelyBroken
)
5637 WSANETWORKEVENTS events
, *netEvents
= NULL
;
5641 if (hEvent
!= INVALID_HANDLE_VALUE
)
5643 netEvents
= &events
;
5645 dwRet
= WaitForSingleObject(hEvent
, 200);
5646 if (dwRet
== WAIT_OBJECT_0
)
5648 ret
= WSAEnumNetworkEvents(s
, hEvent
, netEvents
);
5651 winetest_ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret
);
5656 memset(netEvents
, 0, sizeof(*netEvents
));
5661 /* Run the message loop a little */
5662 while (PeekMessageA( &msg
, 0, 0, 0, PM_REMOVE
))
5664 DispatchMessageA(&msg
);
5668 if (match_event_sequence(s
, netEvents
, seq
))
5670 winetest_ok(1, "Sequence matches expected: %s\n", dbgstr_event_seq(seq
));
5671 flush_events(s
, hEvent
);
5677 for (; *broken_seqs
; broken_seqs
++)
5679 if (match_event_sequence(s
, netEvents
, *broken_seqs
))
5681 winetest_ok(broken(1), "Sequence matches broken: %s, expected %s\n", dbgstr_event_seq_result(s
, netEvents
), dbgstr_event_seq(seq
));
5682 flush_events(s
, hEvent
);
5688 winetest_ok(broken(completelyBroken
), "Expected event sequence %s, got %s\n", dbgstr_event_seq(seq
),
5689 dbgstr_event_seq_result(s
, netEvents
));
5690 flush_events(s
, hEvent
);
5693 #define ok_event_seq (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : ok_event_sequence
5695 static void test_events(int useMessages
)
5697 SOCKET server
= INVALID_SOCKET
;
5698 SOCKET src
= INVALID_SOCKET
, src2
= INVALID_SOCKET
;
5699 SOCKET dst
= INVALID_SOCKET
, dst2
= INVALID_SOCKET
;
5700 struct sockaddr_in addr
;
5701 HANDLE hThread
= NULL
;
5702 HANDLE hEvent
= INVALID_HANDLE_VALUE
, hEvent2
= INVALID_HANDLE_VALUE
;
5703 WNDCLASSEXA wndclass
;
5705 char *buffer
= NULL
;
5706 int bufferSize
= 1024*1024;
5710 DWORD bytesReturned
;
5716 static char szClassName
[] = "wstestclass";
5717 const LPARAM
*broken_seq
[3];
5718 static const LPARAM empty_seq
[] = { 0 };
5719 static const LPARAM close_seq
[] = { WSAMAKESELECTREPLY(FD_CLOSE
, 0), 0 };
5720 static const LPARAM write_seq
[] = { WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
5721 static const LPARAM read_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0), 0 };
5722 static const LPARAM oob_seq
[] = { WSAMAKESELECTREPLY(FD_OOB
, 0), 0 };
5723 static const LPARAM connect_seq
[] = { WSAMAKESELECTREPLY(FD_CONNECT
, 0),
5724 WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
5725 static const LPARAM read_read_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
5726 WSAMAKESELECTREPLY(FD_READ
, 0), 0 };
5727 static const LPARAM read_write_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
5728 WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
5729 static const LPARAM read_close_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
5730 WSAMAKESELECTREPLY(FD_CLOSE
, 0), 0 };
5732 memset(&ov
, 0, sizeof(ov
));
5733 memset(&ov2
, 0, sizeof(ov2
));
5735 /* don't use socketpair, we want connection event */
5736 src
= socket(AF_INET
, SOCK_STREAM
, 0);
5737 if (src
== INVALID_SOCKET
)
5739 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5743 ret
= set_blocking(src
, TRUE
);
5744 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
5746 src2
= socket(AF_INET
, SOCK_STREAM
, 0);
5747 if (src2
== INVALID_SOCKET
)
5749 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5753 ret
= set_blocking(src2
, TRUE
);
5754 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
5757 if (getsockopt(src
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&bret
, &len
) == SOCKET_ERROR
)
5759 ok(0, "failed to get oobinline status, %d\n", GetLastError());
5762 ok(bret
== FALSE
, "OOB not inline\n");
5766 trace("Event test using messages\n");
5768 wndclass
.cbSize
= sizeof(wndclass
);
5769 wndclass
.style
= CS_HREDRAW
| CS_VREDRAW
;
5770 wndclass
.lpfnWndProc
= ws2_test_WndProc
;
5771 wndclass
.cbClsExtra
= 0;
5772 wndclass
.cbWndExtra
= 0;
5773 wndclass
.hInstance
= GetModuleHandleA(NULL
);
5774 wndclass
.hIcon
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
5775 wndclass
.hIconSm
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
5776 wndclass
.hCursor
= LoadCursorA(NULL
, (LPCSTR
)IDC_ARROW
);
5777 wndclass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
5778 wndclass
.lpszClassName
= szClassName
;
5779 wndclass
.lpszMenuName
= NULL
;
5780 RegisterClassExA(&wndclass
);
5782 hWnd
= CreateWindowA(szClassName
, "WS2Test", WS_OVERLAPPEDWINDOW
,
5783 0, 0, 500, 500, NULL
, NULL
, GetModuleHandleA(NULL
), NULL
);
5786 ok(0, "failed to create window: %d\n", GetLastError());
5790 ret
= WSAAsyncSelect(src
, hWnd
, WM_SOCKET
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
5793 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
5797 ok(set_blocking(src
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
5798 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5800 ret
= WSAAsyncSelect(src2
, hWnd
, WM_SOCKET
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
5803 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
5807 ok(set_blocking(src2
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
5808 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5812 trace("Event test using events\n");
5814 hEvent
= WSACreateEvent();
5815 if (hEvent
== INVALID_HANDLE_VALUE
)
5817 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5821 hEvent2
= WSACreateEvent();
5822 if (hEvent2
== INVALID_HANDLE_VALUE
)
5824 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5828 ret
= WSAEventSelect(src
, hEvent
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
5831 ok(0, "WSAEventSelect failed, error %d\n", ret
);
5835 ok(set_blocking(src
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
5836 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5838 ret
= WSAEventSelect(src2
, hEvent2
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
5841 ok(0, "WSAEventSelect failed, error %d\n", ret
);
5845 ok(set_blocking(src2
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
5846 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5849 server
= socket(AF_INET
, SOCK_STREAM
, 0);
5850 if (server
== INVALID_SOCKET
)
5852 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5856 memset(&addr
, 0, sizeof(addr
));
5857 addr
.sin_family
= AF_INET
;
5858 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5859 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
5862 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5867 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
5870 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5874 ret
= listen(server
, 2);
5877 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5881 SetLastError(0xdeadbeef);
5882 ret
= connect(src
, NULL
, 0);
5883 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
5884 ok(GetLastError() == WSAEFAULT
, "expected 10014, got %d\n", GetLastError());
5886 ret
= connect(src
, (struct sockaddr
*)&addr
, sizeof(addr
));
5887 if (ret
== SOCKET_ERROR
&& WSAGetLastError() != WSAEWOULDBLOCK
)
5889 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5893 ret
= connect(src2
, (struct sockaddr
*)&addr
, sizeof(addr
));
5894 if (ret
== SOCKET_ERROR
&& WSAGetLastError() != WSAEWOULDBLOCK
)
5896 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5901 dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
5902 if (dst
== INVALID_SOCKET
)
5904 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5909 dst2
= accept(server
, (struct sockaddr
*)&addr
, &len
);
5910 if (dst2
== INVALID_SOCKET
)
5912 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5916 closesocket(server
);
5917 server
= INVALID_SOCKET
;
5919 /* On Windows it seems when a non-blocking socket sends to a
5920 blocking socket on the same host, the send() is BLOCKING,
5921 so make both sockets non-blocking. src is already non-blocking
5922 from the async select */
5924 if (set_blocking(dst
, FALSE
))
5926 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
5930 buffer
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, bufferSize
);
5933 ok(0, "could not allocate memory for test\n");
5937 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5938 if (ov
.hEvent
== NULL
)
5940 ok(0, "could not create event object, errno = %d\n", GetLastError());
5944 ov2
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5945 if (ov2
.hEvent
== NULL
)
5947 ok(0, "could not create event object, errno = %d\n", GetLastError());
5951 /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
5952 ok_event_seq(src
, hEvent
, connect_seq
, NULL
, 1);
5953 ok_event_seq(src2
, hEvent2
, connect_seq
, NULL
, 1);
5954 /* broken on all windows - FD_CONNECT error is garbage */
5956 /* Test simple send/recv */
5957 SetLastError(0xdeadbeef);
5958 ret
= send(dst
, buffer
, 100, 0);
5959 ok(ret
== 100, "Failed to send buffer %d err %d\n", ret
, GetLastError());
5960 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5961 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
5963 SetLastError(0xdeadbeef);
5964 ret
= recv(src
, buffer
, 1, MSG_PEEK
);
5965 ok(ret
== 1, "Failed to peek at recv buffer %d err %d\n", ret
, GetLastError());
5966 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5967 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
5969 SetLastError(0xdeadbeef);
5970 ret
= recv(src
, buffer
, 50, 0);
5971 ok(ret
== 50, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
5972 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5973 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
5975 ret
= recv(src
, buffer
, 50, 0);
5976 ok(ret
== 50, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
5977 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
5979 /* fun fact - events are re-enabled even on failure, but only for messages */
5980 ret
= send(dst
, "1", 1, 0);
5981 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
5982 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
5984 ret
= recv(src
, buffer
, -1, 0);
5985 ok(ret
== SOCKET_ERROR
&& (GetLastError() == WSAEFAULT
|| GetLastError() == WSAENOBUFS
),
5986 "Failed to recv buffer %d err %d\n", ret
, GetLastError());
5989 broken_seq
[0] = empty_seq
; /* win9x */
5990 broken_seq
[1] = NULL
;
5991 todo_wine
ok_event_seq(src
, hEvent
, read_seq
, broken_seq
, 0);
5994 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
5996 SetLastError(0xdeadbeef);
5997 ret
= recv(src
, buffer
, 1, 0);
5998 ok(ret
== 1, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
5999 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6000 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
6002 /* Interaction with overlapped */
6003 bufs
.len
= sizeof(char);
6005 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
6006 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
6007 "WSARecv failed - %d error %d\n", ret
, GetLastError());
6009 bufs
.len
= sizeof(char);
6010 bufs
.buf
= buffer
+1;
6011 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov2
, NULL
);
6012 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
6013 "WSARecv failed - %d error %d\n", ret
, GetLastError());
6015 ret
= send(dst
, "12", 2, 0);
6016 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
6017 broken_seq
[0] = read_read_seq
; /* win9x */
6018 broken_seq
[1] = NULL
;
6019 ok_event_seq(src
, hEvent
, empty_seq
, broken_seq
, 0);
6021 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
6022 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
6023 if (dwRet
== WAIT_OBJECT_0
)
6025 bret
= GetOverlappedResult((HANDLE
)src
, &ov
, &bytesReturned
, FALSE
);
6026 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
6027 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
6028 ok(buffer
[0] == '1', "Got %c instead of 1\n", buffer
[0]);
6031 dwRet
= WaitForSingleObject(ov2
.hEvent
, 100);
6032 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
6033 if (dwRet
== WAIT_OBJECT_0
)
6035 bret
= GetOverlappedResult((HANDLE
)src
, &ov2
, &bytesReturned
, FALSE
);
6036 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
6037 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
6038 ok(buffer
[1] == '2', "Got %c instead of 2\n", buffer
[1]);
6041 SetLastError(0xdeadbeef);
6042 ret
= send(dst
, "1", 1, 0);
6043 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
6044 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6045 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
6047 ret
= recv(src
, buffer
, 1, 0);
6048 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
6049 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
6051 /* Notifications are delivered as soon as possible, blocked only on
6052 * async requests on the same type */
6053 bufs
.len
= sizeof(char);
6055 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
6056 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
6057 "WSARecv failed - %d error %d\n", ret
, GetLastError());
6060 ret
= send(dst
, "1", 1, MSG_OOB
);
6061 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
6062 ok_event_seq(src
, hEvent
, oob_seq
, NULL
, 0);
6065 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
6066 ok(dwRet
== WAIT_TIMEOUT
, "OOB message activated read?: %d - %d\n", dwRet
, GetLastError());
6068 ret
= send(dst
, "2", 1, 0);
6069 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
6070 broken_seq
[0] = read_seq
; /* win98 */
6071 broken_seq
[1] = NULL
;
6072 ok_event_seq(src
, hEvent
, empty_seq
, broken_seq
, 0);
6074 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
6075 ok(dwRet
== WAIT_OBJECT_0
|| broken(dwRet
== WAIT_TIMEOUT
),
6076 "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
6077 if (dwRet
== WAIT_OBJECT_0
)
6079 bret
= GetOverlappedResult((HANDLE
)src
, &ov
, &bytesReturned
, FALSE
);
6080 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
6081 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
6082 ok(buffer
[0] == '2', "Got %c instead of 2\n", buffer
[0]);
6086 ret
= recv(src
, buffer
, 1, MSG_OOB
);
6087 todo_wine
ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
6088 /* We get OOB notification, but no data on wine */
6089 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
6092 /* Flood the send queue */
6093 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
6094 if (hThread
== NULL
)
6096 ok(0, "CreateThread failed, error %d\n", GetLastError());
6100 /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
6101 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
6103 /* Now if we send a ton of data and the 'server' does not drain it fast
6104 * enough (set drain_pause to be sure), the socket send buffer will only
6105 * take some of it, and we will get a short write. This will trigger
6106 * another FD_WRITE event as soon as data is sent and more space becomes
6107 * available, but not any earlier. */
6111 ret
= send(src
, buffer
, bufferSize
, 0);
6112 } while (ret
== bufferSize
);
6113 drain_pause
= FALSE
;
6114 if (ret
>= 0 || WSAGetLastError() == WSAEWOULDBLOCK
)
6116 Sleep(400); /* win9x */
6117 broken_seq
[0] = read_write_seq
;
6118 broken_seq
[1] = NULL
;
6119 ok_event_seq(src
, hEvent
, write_seq
, broken_seq
, 0);
6123 ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
6126 /* Test how FD_CLOSE is handled */
6127 ret
= send(dst
, "12", 2, 0);
6128 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
6130 /* Wait a little and let the send complete */
6133 dst
= INVALID_SOCKET
;
6136 /* We can never implement this in wine, best we can hope for is
6137 sending FD_CLOSE after the reads complete */
6138 broken_seq
[0] = read_seq
; /* win9x */
6139 broken_seq
[1] = NULL
;
6140 todo_wine
ok_event_seq(src
, hEvent
, read_close_seq
, broken_seq
, 0);
6142 ret
= recv(src
, buffer
, 1, 0);
6143 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
6144 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
6146 ret
= recv(src
, buffer
, 1, 0);
6147 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
6148 /* want it? it's here, but you can't have it */
6149 broken_seq
[0] = close_seq
; /* win9x */
6150 broken_seq
[1] = NULL
;
6151 todo_wine
ok_event_seq(src
, hEvent
, empty_seq
, /* wine sends FD_CLOSE here */
6154 /* Test how FD_CLOSE is handled */
6155 ret
= send(dst2
, "12", 2, 0);
6156 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
6159 shutdown(dst2
, SD_SEND
);
6162 /* Some of the below are technically todo_wine, but our event sequence is still valid, so to prevent
6163 regressions, don't mark them as todo_wine, and mark windows as broken */
6164 broken_seq
[0] = read_close_seq
;
6165 broken_seq
[1] = close_seq
;
6166 broken_seq
[2] = NULL
;
6167 ok_event_seq(src2
, hEvent2
, read_seq
, broken_seq
, 0);
6169 ret
= recv(src2
, buffer
, 1, 0);
6170 ok(ret
== 1 || broken(!ret
), "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
6171 broken_seq
[0] = close_seq
; /* win98 */
6172 broken_seq
[1] = NULL
;
6173 ok_event_seq(src2
, hEvent2
, read_seq
, broken_seq
, 0);
6175 ret
= recv(src2
, buffer
, 1, 0);
6176 ok(ret
== 1 || broken(!ret
), "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
6177 broken_seq
[0] = empty_seq
;
6178 broken_seq
[1] = NULL
;
6179 ok_event_seq(src2
, hEvent2
, close_seq
, broken_seq
, 0);
6181 ret
= send(src2
, "1", 1, 0);
6182 ok(ret
== 1, "Sending to half-closed socket failed %d err %d\n", ret
, GetLastError());
6183 ok_event_seq(src2
, hEvent2
, empty_seq
, NULL
, 0);
6185 ret
= send(src2
, "1", 1, 0);
6186 ok(ret
== 1, "Sending to half-closed socket failed %d err %d\n", ret
, GetLastError());
6187 ok_event_seq(src2
, hEvent2
, empty_seq
, NULL
, 0);
6191 ret
= WSAAsyncSelect(src
, hWnd
, WM_SOCKET
, 0);
6194 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
6198 ret
= set_blocking(src
, TRUE
);
6199 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
6201 ret
= WSAAsyncSelect(src2
, hWnd
, WM_SOCKET
, 0);
6204 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
6208 ret
= set_blocking(src2
, TRUE
);
6209 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
6213 ret
= WSAEventSelect(src
, hEvent2
, 0);
6216 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
6220 ret
= set_blocking(src
, TRUE
);
6221 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
6223 ret
= WSAEventSelect(src2
, hEvent2
, 0);
6226 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
6230 ret
= set_blocking(src2
, TRUE
);
6231 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
6235 if (src
!= INVALID_SOCKET
)
6237 flush_events(src
, hEvent
);
6240 if (src2
!= INVALID_SOCKET
)
6242 flush_events(src2
, hEvent2
);
6245 HeapFree(GetProcessHeap(), 0, buffer
);
6246 if (server
!= INVALID_SOCKET
)
6247 closesocket(server
);
6248 if (dst
!= INVALID_SOCKET
)
6250 if (dst2
!= INVALID_SOCKET
)
6252 if (hThread
!= NULL
)
6253 CloseHandle(hThread
);
6255 DestroyWindow(hWnd
);
6257 CloseHandle(hEvent
);
6258 if (hEvent2
!= NULL
)
6259 CloseHandle(hEvent2
);
6260 if (ov
.hEvent
!= NULL
)
6261 CloseHandle(ov
.hEvent
);
6262 if (ov2
.hEvent
!= NULL
)
6263 CloseHandle(ov2
.hEvent
);
6266 static void test_ipv6only(void)
6268 SOCKET v4
= INVALID_SOCKET
, v6
;
6269 struct sockaddr_in sin4
;
6270 struct sockaddr_in6 sin6
;
6271 int ret
, enabled
, len
= sizeof(enabled
);
6273 memset(&sin4
, 0, sizeof(sin4
));
6274 sin4
.sin_family
= AF_INET
;
6275 sin4
.sin_port
= htons(SERVERPORT
);
6277 memset(&sin6
, 0, sizeof(sin6
));
6278 sin6
.sin6_family
= AF_INET6
;
6279 sin6
.sin6_port
= htons(SERVERPORT
);
6281 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
6282 if (v6
== INVALID_SOCKET
)
6284 skip("Could not create IPv6 socket (LastError: %d)\n", WSAGetLastError());
6289 ret
= getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
6290 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6291 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
6293 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
6296 skip("Could not bind IPv6 address (LastError: %d)\n", WSAGetLastError());
6300 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6301 ok(v4
!= INVALID_SOCKET
, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
6305 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
6306 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6307 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
6311 len
= sizeof(enabled
);
6312 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
6313 ok(!ret
, "setsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6317 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
6318 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6319 ok(!enabled
, "expected 0, got %d\n", enabled
);
6323 len
= sizeof(enabled
);
6324 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
6325 ok(!ret
, "setsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6327 /* bind on IPv4 socket should succeed - IPV6_V6ONLY is enabled by default */
6328 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
6329 ok(!ret
, "Could not bind IPv4 address (LastError: %d)\n", WSAGetLastError());
6333 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
6334 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6335 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
6339 len
= sizeof(enabled
);
6340 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
6341 ok(ret
, "setsockopt(IPV6_ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
6345 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
6346 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6347 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
6351 len
= sizeof(enabled
);
6352 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
6353 ok(ret
, "setsockopt(IPV6_ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
6358 /* Test again, this time disabling IPV6_V6ONLY. */
6359 sin4
.sin_port
= htons(SERVERPORT
+2);
6360 sin6
.sin6_port
= htons(SERVERPORT
+2);
6362 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
6363 ok(v6
!= INVALID_SOCKET
, "Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
6364 WSAGetLastError(), WSAEAFNOSUPPORT
);
6367 ret
= setsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
6368 ok(!ret
, "Could not disable IPV6_V6ONLY (LastError: %d).\n", WSAGetLastError());
6371 ret
= getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
6372 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6373 ok(!enabled
, "expected 0, got %d\n", enabled
);
6377 On Windows, bind on both IPv4 and IPv6 with IPV6_V6ONLY disabled succeeds by default.
6378 Application must set SO_EXCLUSIVEADDRUSE on first socket to disallow another successful bind.
6379 In general, a standard application should not use SO_REUSEADDR.
6380 Setting both SO_EXCLUSIVEADDRUSE and SO_REUSEADDR on the same socket is not possible in
6381 either order, the later setsockopt call always fails.
6384 ret
= setsockopt(v6
, SOL_SOCKET
, SO_EXCLUSIVEADDRUSE
, (char*)&enabled
, len
);
6385 ok(!ret
, "Could not set SO_EXCLUSIVEADDRUSE on IPv6 socket (LastError: %d)\n", WSAGetLastError());
6387 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
6388 ok(!ret
, "Could not bind IPv6 address (LastError: %d)\n", WSAGetLastError());
6391 len
= sizeof(enabled
);
6392 getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
6393 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6394 ok(!enabled
, "IPV6_V6ONLY is enabled after bind\n");
6396 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6397 ok(v4
!= INVALID_SOCKET
, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
6400 ret
= setsockopt(v4
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&enabled
, len
);
6401 ok(!ret
, "Could not set SO_REUSEADDR on IPv4 socket (LastError: %d)\n", WSAGetLastError());
6403 WSASetLastError(0xdeadbeef);
6404 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
6405 ok(ret
, "bind succeeded unexpectedly for the IPv4 socket\n");
6406 ok(WSAGetLastError() == WSAEACCES
, "Expected 10013, got %d\n", WSAGetLastError());
6409 if (v4
!= INVALID_SOCKET
)
6411 if (v6
!= INVALID_SOCKET
)
6415 static void test_WSASendMsg(void)
6418 struct sockaddr_in sendaddr
, sockaddr
;
6419 GUID WSASendMsg_GUID
= WSAID_WSASENDMSG
;
6420 LPFN_WSASENDMSG pWSASendMsg
= NULL
;
6421 char teststr
[12] = "hello world", buffer
[32];
6424 DWORD bytesSent
, err
;
6427 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
6429 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
6430 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
6432 /* Obtain the WSASendMsg function */
6433 WSAIoctl(sock
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSASendMsg_GUID
, sizeof(WSASendMsg_GUID
),
6434 &pWSASendMsg
, sizeof(pWSASendMsg
), &err
, NULL
, NULL
);
6438 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
6442 /* fake address for now */
6443 sendaddr
.sin_family
= AF_INET
;
6444 sendaddr
.sin_port
= htons(139);
6445 sendaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6447 memset(&msg
, 0, sizeof(msg
));
6448 iovec
[0].buf
= teststr
;
6449 iovec
[0].len
= sizeof(teststr
);
6450 iovec
[1].buf
= teststr
;
6451 iovec
[1].len
= sizeof(teststr
) / 2;
6452 msg
.name
= (struct sockaddr
*) &sendaddr
;
6453 msg
.namelen
= sizeof(sendaddr
);
6454 msg
.lpBuffers
= iovec
;
6455 msg
.dwBufferCount
= 1; /* send only one buffer for now */
6457 WSASetLastError(0xdeadbeef);
6458 ret
= pWSASendMsg(INVALID_SOCKET
, &msg
, 0, NULL
, NULL
, NULL
);
6459 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
6460 err
= WSAGetLastError();
6461 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
6463 WSASetLastError(0xdeadbeef);
6464 ret
= pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
);
6465 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
6466 err
= WSAGetLastError();
6467 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
6469 WSASetLastError(0xdeadbeef);
6470 ret
= pWSASendMsg(sock
, NULL
, 0, &bytesSent
, NULL
, NULL
);
6471 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
6472 err
= WSAGetLastError();
6473 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
6475 WSASetLastError(0xdeadbeef);
6476 ret
= pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
);
6477 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
6478 err
= WSAGetLastError();
6479 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
6483 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
6484 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
6486 dst
= socket(AF_INET
, SOCK_DGRAM
, 0);
6487 ok(dst
!= INVALID_SOCKET
, "socket() failed\n");
6489 memset(&sockaddr
, 0, sizeof(sockaddr
));
6490 sockaddr
.sin_family
= AF_INET
;
6491 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6492 ok(!bind(dst
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
)),
6493 "bind should have worked\n");
6495 /* read address to find out the port number to be used in send */
6496 memset(&sendaddr
, 0, sizeof(sendaddr
));
6497 addrlen
= sizeof(sendaddr
);
6498 ok(!getsockname(dst
, (struct sockaddr
*) &sendaddr
, &addrlen
),
6499 "getsockname should have worked\n");
6500 ok(sendaddr
.sin_port
, "socket port should be != 0\n");
6502 /* ensure the sending socket is not bound */
6503 WSASetLastError(0xdeadbeef);
6504 addrlen
= sizeof(sockaddr
);
6505 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
6506 ok(ret
== SOCKET_ERROR
, "getsockname should have failed\n");
6507 err
= WSAGetLastError();
6508 ok(err
== WSAEINVAL
, "expected 10022, got %d instead\n", err
);
6510 set_blocking(sock
, TRUE
);
6513 SetLastError(0xdeadbeef);
6514 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
6515 ok(!ret
, "WSASendMsg should have worked\n");
6516 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
6517 "Expected 0, got %d\n", GetLastError());
6518 ok(bytesSent
== iovec
[0].len
, "incorret bytes sent, expected %d, sent %d\n",
6519 iovec
[0].len
, bytesSent
);
6522 addrlen
= sizeof(sockaddr
);
6523 memset(buffer
, 0, sizeof(buffer
));
6524 SetLastError(0xdeadbeef);
6525 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
6526 ok(ret
== bytesSent
, "got %d, expected %d\n",
6528 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6530 /* A successful call to WSASendMsg must have bound the socket */
6531 addrlen
= sizeof(sockaddr
);
6532 sockaddr
.sin_port
= 0;
6533 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6534 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
6535 ok(!ret
, "getsockname should have worked\n");
6536 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
6537 inet_ntoa(sockaddr
.sin_addr
));
6538 ok(sockaddr
.sin_port
, "sin_port should be != 0\n");
6540 msg
.dwBufferCount
= 2; /* send both buffers */
6543 SetLastError(0xdeadbeef);
6544 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
6545 ok(!ret
, "WSASendMsg should have worked\n");
6546 ok(bytesSent
== iovec
[0].len
+ iovec
[1].len
, "incorret bytes sent, expected %d, sent %d\n",
6547 iovec
[0].len
+ iovec
[1].len
, bytesSent
);
6548 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
6549 "Expected 0, got %d\n", GetLastError());
6552 addrlen
= sizeof(sockaddr
);
6553 memset(buffer
, 0, sizeof(buffer
));
6554 SetLastError(0xdeadbeef);
6555 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
6556 ok(ret
== bytesSent
, "got %d, expected %d\n",
6558 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6563 /* a bad call to WSASendMsg will also bind the socket */
6564 addrlen
= sizeof(sockaddr
);
6565 sockaddr
.sin_port
= 0;
6566 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6567 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
6568 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
6569 ok(pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
6571 ok(!getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have worked\n");
6572 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
6573 inet_ntoa(sockaddr
.sin_addr
));
6574 ok(sockaddr
.sin_port
, "sin_port should be > 0\n");
6578 /* a bad call without msg parameter will not trigger the auto-bind */
6579 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
6580 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
6581 ok(pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
6582 ok(getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have failed\n");
6583 err
= WSAGetLastError();
6584 ok(err
== WSAEINVAL
, "expected 10022, got %d instead\n", err
);
6587 /* SOCK_STREAM sockets are not supported */
6589 sock
= socket(AF_INET
, SOCK_STREAM
, 0);
6590 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
6591 SetLastError(0xdeadbeef);
6592 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
6593 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
6594 err
= WSAGetLastError();
6596 ok(err
== WSAEINVAL
, "expected 10014, got %d instead\n", err
);
6600 static void test_WSASendTo(void)
6603 struct sockaddr_in addr
;
6604 char buf
[12] = "hello world";
6609 addr
.sin_family
= AF_INET
;
6610 addr
.sin_port
= htons(139);
6611 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6612 data_buf
.len
= sizeof(buf
);
6615 if( (s
= socket(AF_INET
, SOCK_DGRAM
, 0)) == INVALID_SOCKET
) {
6616 ok(0, "socket() failed error: %d\n", WSAGetLastError());
6620 WSASetLastError(12345);
6621 ret
= WSASendTo(INVALID_SOCKET
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
6622 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
6623 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
6625 WSASetLastError(12345);
6626 ret
= WSASendTo(s
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
6627 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
6628 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
6630 WSASetLastError(12345);
6631 if(WSASendTo(s
, &data_buf
, 1, &bytesSent
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
)) {
6632 ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
6635 ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
6636 "a successful call to WSASendTo()\n");
6639 static DWORD WINAPI
recv_thread(LPVOID arg
)
6641 SOCKET sock
= *(SOCKET
*)arg
;
6648 wsa
.len
= sizeof(buffer
);
6649 ov
.hEvent
= WSACreateEvent();
6650 WSARecv(sock
, &wsa
, 1, NULL
, &flags
, &ov
, NULL
);
6652 WaitForSingleObject(ov
.hEvent
, 1000);
6653 WSACloseEvent(ov
.hEvent
);
6657 static int completion_called
;
6659 static void WINAPI
io_completion(DWORD error
, DWORD transferred
, WSAOVERLAPPED
*overlapped
, DWORD flags
)
6661 completion_called
++;
6664 static void test_WSARecv(void)
6666 SOCKET src
, dest
, server
= INVALID_SOCKET
;
6670 DWORD bytesReturned
, flags
, id
;
6672 struct sockaddr_in addr
;
6676 HANDLE thread
, event
= NULL
, io_port
;
6678 tcp_socketpair(&src
, &dest
);
6679 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
6681 skip("failed to create sockets\n");
6685 memset(&ov
, 0, sizeof(ov
));
6690 /* Send 4 bytes and receive in two calls of 2 */
6691 SetLastError(0xdeadbeef);
6692 iret
= send(src
, "test", 4, 0);
6693 ok(iret
== 4, "Expected 4, got %d\n", iret
);
6694 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6695 SetLastError(0xdeadbeef);
6696 bytesReturned
= 0xdeadbeef;
6697 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
6698 ok(!iret
, "Expected 0, got %d\n", iret
);
6699 ok(bytesReturned
== 2, "Expected 2, got %d\n", bytesReturned
);
6700 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6701 SetLastError(0xdeadbeef);
6702 bytesReturned
= 0xdeadbeef;
6703 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
6704 ok(!iret
, "Expected 0, got %d\n", iret
);
6705 ok(bytesReturned
== 2, "Expected 2, got %d\n", bytesReturned
);
6706 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6709 SetLastError(0xdeadbeef);
6710 iret
= send(src
, "test", 4, 0);
6711 ok(iret
== 4, "Expected 4, got %d\n", iret
);
6712 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6713 SetLastError(0xdeadbeef);
6714 bytesReturned
= 0xdeadbeef;
6715 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
6716 ok(!iret
, "Expected 0, got %d\n", iret
);
6717 ok(bytesReturned
== 4, "Expected 4, got %d\n", bytesReturned
);
6718 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6720 /* Test 2 buffers */
6723 bufs
[1].buf
= buf
+ 10;
6724 SetLastError(0xdeadbeef);
6725 iret
= send(src
, "deadbeefs", 9, 0);
6726 ok(iret
== 9, "Expected 9, got %d\n", iret
);
6727 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6728 SetLastError(0xdeadbeef);
6729 bytesReturned
= 0xdeadbeef;
6730 iret
= WSARecv(dest
, bufs
, 2, &bytesReturned
, &flags
, NULL
, NULL
);
6731 ok(!iret
, "Expected 0, got %d\n", iret
);
6732 ok(bytesReturned
== 9, "Expected 9, got %d\n", bytesReturned
);
6733 bufs
[0].buf
[4] = '\0';
6734 bufs
[1].buf
[5] = '\0';
6735 ok(!strcmp(bufs
[0].buf
, "dead"), "buf[0] doesn't match: %s != dead\n", bufs
[0].buf
);
6736 ok(!strcmp(bufs
[1].buf
, "beefs"), "buf[1] doesn't match: %s != beefs\n", bufs
[1].buf
);
6737 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6739 bufs
[0].len
= sizeof(buf
);
6740 ov
.hEvent
= event
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
6741 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
6747 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
6748 ok(!iret
, "Failed to set linger %d\n", GetLastError());
6750 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, NULL
);
6751 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
6753 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
6754 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
6757 src
= INVALID_SOCKET
;
6759 dwret
= WaitForSingleObject(ov
.hEvent
, 1000);
6760 ok(dwret
== WAIT_OBJECT_0
, "Waiting for disconnect event failed with %d + errno %d\n", dwret
, GetLastError());
6762 bret
= GetOverlappedResult((HANDLE
)dest
, &ov
, &bytesReturned
, FALSE
);
6763 todo_wine
ok(!bret
&& (GetLastError() == ERROR_NETNAME_DELETED
|| broken(GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */),
6764 "Did not get disconnect event: %d, error %d\n", bret
, GetLastError());
6765 ok(bytesReturned
== 0, "Bytes received is %d\n", bytesReturned
);
6767 dest
= INVALID_SOCKET
;
6769 src
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
6770 ok(src
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
6771 if (src
== INVALID_SOCKET
) goto end
;
6773 server
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
6774 ok(server
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
6775 if (server
== INVALID_SOCKET
) goto end
;
6777 memset(&addr
, 0, sizeof(addr
));
6778 addr
.sin_family
= AF_INET
;
6779 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6780 iret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
6784 iret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
6787 iret
= listen(server
, 1);
6790 iret
= connect(src
, (struct sockaddr
*)&addr
, sizeof(addr
));
6794 dest
= accept(server
, (struct sockaddr
*)&addr
, &len
);
6795 ok(dest
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
6796 if (dest
== INVALID_SOCKET
) goto end
;
6798 send(src
, "test message", sizeof("test message"), 0);
6799 thread
= CreateThread(NULL
, 0, recv_thread
, &dest
, 0, &id
);
6800 WaitForSingleObject(thread
, 3000);
6801 CloseHandle(thread
);
6803 memset(&ov
, 0, sizeof(ov
));
6806 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, io_completion
);
6807 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
6808 send(src
, "test message", sizeof("test message"), 0);
6810 completion_called
= 0;
6811 dwret
= SleepEx(1000, TRUE
);
6812 ok(dwret
== WAIT_IO_COMPLETION
, "got %u\n", dwret
);
6813 ok(completion_called
== 1, "completion not called\n");
6815 dwret
= WaitForSingleObject(event
, 1);
6816 ok(dwret
== WAIT_TIMEOUT
, "got %u\n", dwret
);
6818 io_port
= CreateIoCompletionPort( (HANDLE
)dest
, NULL
, 0, 0 );
6819 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
6821 /* Using completion function on socket associated with completion port is not allowed. */
6822 memset(&ov
, 0, sizeof(ov
));
6823 completion_called
= 0;
6824 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, io_completion
);
6825 ok(iret
== SOCKET_ERROR
&& GetLastError() == WSAEINVAL
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
6826 ok(!completion_called
, "completion called\n");
6828 CloseHandle(io_port
);
6831 if (server
!= INVALID_SOCKET
)
6832 closesocket(server
);
6833 if (dest
!= INVALID_SOCKET
)
6835 if (src
!= INVALID_SOCKET
)
6838 WSACloseEvent(event
);
6841 struct write_watch_thread_args
6850 static DWORD CALLBACK
write_watch_thread( void *arg
)
6852 struct write_watch_thread_args
*args
= arg
;
6853 struct sockaddr addr
;
6854 int addr_len
= sizeof(addr
), ret
;
6855 DWORD bytes
, flags
= 0;
6861 ret
= recv( args
->dest
, args
->base
, args
->size
, 0 );
6862 ok( ret
== strlen(args
->expect
) + 1, "wrong len %d\n", ret
);
6863 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
6866 ret
= recvfrom( args
->dest
, args
->base
, args
->size
, 0, &addr
, &addr_len
);
6867 ok( ret
== strlen(args
->expect
) + 1, "wrong len %d\n", ret
);
6868 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
6871 buf
[0].len
= args
->size
;
6872 buf
[0].buf
= args
->base
;
6873 ret
= WSARecv( args
->dest
, buf
, 1, &bytes
, &flags
, NULL
, NULL
);
6874 ok( !ret
, "WSARecv failed %u\n", GetLastError() );
6875 ok( bytes
== strlen(args
->expect
) + 1, "wrong len %d\n", bytes
);
6876 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
6879 buf
[0].len
= args
->size
;
6880 buf
[0].buf
= args
->base
;
6881 ret
= WSARecvFrom( args
->dest
, buf
, 1, &bytes
, &flags
, &addr
, &addr_len
, NULL
, NULL
);
6882 ok( !ret
, "WSARecvFrom failed %u\n", GetLastError() );
6883 ok( bytes
== strlen(args
->expect
) + 1, "wrong len %d\n", bytes
);
6884 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
6890 static void test_write_watch(void)
6895 struct write_watch_thread_args args
;
6896 DWORD bytesReturned
, flags
, size
;
6897 struct sockaddr addr
;
6899 HANDLE thread
, event
;
6904 UINT (WINAPI
*pGetWriteWatch
)(DWORD
,LPVOID
,SIZE_T
,LPVOID
*,ULONG_PTR
*,ULONG
*);
6906 pGetWriteWatch
= (void *)GetProcAddress( GetModuleHandleA("kernel32.dll"), "GetWriteWatch" );
6907 if (!pGetWriteWatch
)
6909 win_skip( "write watched not supported\n" );
6913 tcp_socketpair(&src
, &dest
);
6914 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
6916 skip("failed to create sockets\n");
6920 memset(&ov
, 0, sizeof(ov
));
6921 ov
.hEvent
= event
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
6922 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
6927 base
= VirtualAlloc( 0, size
, MEM_RESERVE
| MEM_COMMIT
| MEM_WRITE_WATCH
, PAGE_READWRITE
);
6928 ok( base
!= NULL
, "VirtualAlloc failed %u\n", GetLastError() );
6930 memset( base
, 0, size
);
6932 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6933 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6934 ok( count
== 16, "wrong count %lu\n", count
);
6938 bufs
[1].len
= 0x8000;
6939 bufs
[1].buf
= base
+ 0x4000;
6941 ret
= WSARecv( dest
, bufs
, 2, NULL
, &flags
, &ov
, NULL
);
6942 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
6943 "WSARecv failed - %d error %d\n", ret
, GetLastError());
6946 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6947 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6948 ok( count
== 9, "wrong count %lu\n", count
);
6949 ok( !base
[0], "data set\n" );
6951 send(src
, "test message", sizeof("test message"), 0);
6953 ret
= GetOverlappedResult( (HANDLE
)dest
, &ov
, &bytesReturned
, TRUE
);
6954 ok( ret
, "GetOverlappedResult failed %u\n", GetLastError() );
6955 ok( bytesReturned
== sizeof("test message"), "wrong size %u\n", bytesReturned
);
6956 ok( !memcmp( base
, "test ", 5 ), "wrong data %s\n", base
);
6957 ok( !memcmp( base
+ 0x4000, "message", 8 ), "wrong data %s\n", base
+ 0x4000 );
6960 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6961 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6962 ok( count
== 0, "wrong count %lu\n", count
);
6964 memset( base
, 0, size
);
6966 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6967 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6968 ok( count
== 16, "wrong count %lu\n", count
);
6970 bufs
[1].len
= 0x4000;
6971 bufs
[1].buf
= base
+ 0x2000;
6972 ret
= WSARecvFrom( dest
, bufs
, 2, NULL
, &flags
, &addr
, &addr_len
, &ov
, NULL
);
6973 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
6974 "WSARecv failed - %d error %d\n", ret
, GetLastError());
6977 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6978 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6979 ok( count
== 5, "wrong count %lu\n", count
);
6980 ok( !base
[0], "data set\n" );
6982 send(src
, "test message", sizeof("test message"), 0);
6984 ret
= GetOverlappedResult( (HANDLE
)dest
, &ov
, &bytesReturned
, TRUE
);
6985 ok( ret
, "GetOverlappedResult failed %u\n", GetLastError() );
6986 ok( bytesReturned
== sizeof("test message"), "wrong size %u\n", bytesReturned
);
6987 ok( !memcmp( base
, "test ", 5 ), "wrong data %s\n", base
);
6988 ok( !memcmp( base
+ 0x2000, "message", 8 ), "wrong data %s\n", base
+ 0x2000 );
6991 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6992 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6993 ok( count
== 0, "wrong count %lu\n", count
);
6995 memset( base
, 0, size
);
6997 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6998 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6999 ok( count
== 16, "wrong count %lu\n", count
);
7004 args
.expect
= "test message";
7005 for (args
.func
= 0; args
.func
< 4; args
.func
++)
7007 thread
= CreateThread( NULL
, 0, write_watch_thread
, &args
, 0, NULL
);
7011 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
7012 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
7013 ok( count
== 8, "wrong count %lu\n", count
);
7015 send(src
, "test message", sizeof("test message"), 0);
7016 WaitForSingleObject( thread
, 10000 );
7017 CloseHandle( thread
);
7020 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
7021 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
7022 ok( count
== 0, "wrong count %lu\n", count
);
7024 WSACloseEvent( event
);
7025 closesocket( dest
);
7027 VirtualFree( base
, 0, MEM_FREE
);
7030 #define POLL_CLEAR() ix = 0
7031 #define POLL_SET(s, ev) {fds[ix].fd = s; fds[ix++].events = ev;}
7032 #define POLL_ISSET(s, rev) poll_isset(fds, ix, s, rev)
7033 static BOOL
poll_isset(WSAPOLLFD
*fds
, int max
, SOCKET s
, int rev
)
7036 for (k
= 0; k
< max
; k
++)
7037 if (fds
[k
].fd
== s
&& (fds
[k
].revents
== rev
)) return TRUE
;
7041 static void test_WSAPoll(void)
7043 int ix
, ret
, err
, poll_timeout
;
7044 SOCKET fdListen
, fdRead
, fdWrite
;
7045 struct sockaddr_in address
;
7047 static char tmp_buf
[1024];
7049 HANDLE thread_handle
;
7052 if (!pWSAPoll
) /* >= Vista */
7054 skip("WSAPoll is unsupported, some tests will be skipped.\n");
7058 /* Invalid parameters test */
7059 SetLastError(0xdeadbeef);
7060 ret
= pWSAPoll(NULL
, 0, 0);
7061 err
= GetLastError();
7062 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
7063 ok(err
== WSAEINVAL
, "expected 10022, got %d\n", err
);
7064 SetLastError(0xdeadbeef);
7065 ret
= pWSAPoll(NULL
, 1, 0);
7066 err
= GetLastError();
7067 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
7068 ok(err
== WSAEFAULT
, "expected 10014, got %d\n", err
);
7069 SetLastError(0xdeadbeef);
7070 ret
= pWSAPoll(NULL
, 0, 1);
7071 err
= GetLastError();
7072 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
7073 ok(err
== WSAEINVAL
, "expected 10022, got %d\n", err
);
7074 SetLastError(0xdeadbeef);
7075 ret
= pWSAPoll(NULL
, 1, 1);
7076 err
= GetLastError();
7077 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
7078 ok(err
== WSAEFAULT
, "expected 10014, got %d\n", err
);
7080 /* WSAPoll() tries to mime the unix poll() call. The following tests do:
7081 * - check if a connection attempt ended with success or error;
7082 * - check if a pending connection is waiting for acceptance;
7083 * - check for data to read, availability for write and OOB data
7085 memset(&address
, 0, sizeof(address
));
7086 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7087 address
.sin_family
= AF_INET
;
7088 len
= sizeof(address
);
7089 fdListen
= setup_server_socket(&address
, &len
);
7092 /* When no events are pending poll returns 0 with no error */
7094 POLL_SET(fdListen
, POLLIN
);
7095 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
7096 ok(ret
== 0, "expected 0, got %d\n", ret
);
7098 /* Test listening socket connection attempt notifications */
7099 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
7101 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
7102 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
7103 ok(ret
== 1, "expected 1, got %d\n", ret
);
7104 ok(POLL_ISSET(fdListen
, POLLRDNORM
), "fdListen socket events incorrect\n");
7105 len
= sizeof(address
);
7106 fdRead
= accept(fdListen
, (struct sockaddr
*) &address
, &len
);
7107 ok(fdRead
!= INVALID_SOCKET
, "expected a valid socket\n");
7109 /* Test client side connection attempt notifications */
7111 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
7112 POLL_SET(fdRead
, POLLIN
| POLLOUT
);
7113 POLL_SET(fdWrite
, POLLIN
| POLLOUT
);
7114 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
7115 ok(ret
== 2, "expected 2, got %d\n", ret
);
7116 ok(POLL_ISSET(fdWrite
, POLLWRNORM
), "fdWrite socket events incorrect\n");
7117 ok(POLL_ISSET(fdRead
, POLLWRNORM
), "fdRead socket events incorrect\n");
7120 err
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
7121 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
7122 ok(id
== 0, "expected 0, got %d\n", id
);
7124 /* Test data receiving notifications */
7125 ret
= send(fdWrite
, "1234", 4, 0);
7126 ok(ret
== 4, "expected 4, got %d\n", ret
);
7128 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
7129 POLL_SET(fdRead
, POLLIN
);
7130 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
7131 ok(ret
== 1, "expected 1, got %d\n", ret
);
7132 ok(POLL_ISSET(fdRead
, POLLRDNORM
), "fdRead socket events incorrect\n");
7133 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
7134 ok(ret
== 4, "expected 4, got %d\n", ret
);
7135 ok(!strcmp(tmp_buf
, "1234"), "data received differs from sent\n");
7137 /* Test OOB data notifications */
7138 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
7139 ok(ret
== 1, "expected 1, got %d\n", ret
);
7141 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
7142 POLL_SET(fdRead
, POLLIN
);
7143 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
7144 ok(ret
== 1, "expected 1, got %d\n", ret
);
7145 ok(POLL_ISSET(fdRead
, POLLRDBAND
), "fdRead socket events incorrect\n");
7147 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
7148 ok(ret
== 1, "expected 1, got %d\n", ret
);
7149 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
7151 /* If the socket is OOBINLINED the notification is like normal data */
7153 ret
= setsockopt(fdRead
, SOL_SOCKET
, SO_OOBINLINE
, (char*) &ret
, sizeof(ret
));
7154 ok(ret
== 0, "expected 0, got %d\n", ret
);
7155 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
7156 ok(ret
== 1, "expected 1, got %d\n", ret
);
7158 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
7159 POLL_SET(fdRead
, POLLIN
| POLLOUT
);
7160 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
7161 ok(ret
== 1, "expected 1, got %d\n", ret
);
7163 SetLastError(0xdeadbeef);
7164 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
7165 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
7166 ok(GetLastError() == WSAEINVAL
, "expected 10022, got %d\n", GetLastError());
7167 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
7168 ok(ret
== 1, "expected 1, got %d\n", ret
);
7169 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
7171 /* Test connection closed notifications */
7172 ret
= closesocket(fdRead
);
7173 ok(ret
== 0, "expected 0, got %d\n", ret
);
7175 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
7176 POLL_SET(fdWrite
, POLLIN
);
7177 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
7178 ok(ret
== 1, "expected 1, got %d\n", ret
);
7179 ok(POLL_ISSET(fdWrite
, POLLHUP
), "fdWrite socket events incorrect\n");
7180 ret
= recv(fdWrite
, tmp_buf
, sizeof(tmp_buf
), 0);
7181 ok(ret
== 0, "expected 0, got %d\n", ret
);
7183 /* When a connection is attempted to a non-listening socket due to a bug
7184 * in the MS code it will never be notified. This is a long standing issue
7185 * that will never be fixed for compatibility reasons so we have to deal
7186 * with it manually. */
7187 ret
= closesocket(fdWrite
);
7188 ok(ret
== 0, "expected 0, got %d\n", ret
);
7189 ret
= closesocket(fdListen
);
7190 ok(ret
== 0, "expected 0, got %d\n", ret
);
7191 len
= sizeof(address
);
7192 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
7194 POLL_SET(fdWrite
, POLLIN
| POLLOUT
);
7195 poll_timeout
= 2000;
7196 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
7198 ok(ret
== 0, "expected 0, got %d\n", ret
);
7201 err
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
7202 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
7203 ok(id
== WSAECONNREFUSED
, "expected 10061, got %d\n", id
);
7204 closesocket(fdWrite
);
7206 /* Try poll() on a closed socket after connection */
7207 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
7208 closesocket(fdRead
);
7210 POLL_SET(fdWrite
, POLLIN
| POLLOUT
);
7211 POLL_SET(fdRead
, POLLIN
| POLLOUT
);
7212 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
7213 ok(ret
== 1, "expected 1, got %d\n", ret
);
7214 ok(POLL_ISSET(fdRead
, POLLNVAL
), "fdRead socket events incorrect\n");
7216 POLL_SET(fdWrite
, POLLIN
| POLLOUT
);
7217 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
7218 ok(ret
== 1, "expected 1, got %d\n", ret
);
7220 ok(POLL_ISSET(fdWrite
, POLLWRNORM
| POLLHUP
) || broken(POLL_ISSET(fdWrite
, POLLWRNORM
)) /* <= 2008 */,
7221 "fdWrite socket events incorrect\n");
7222 closesocket(fdWrite
);
7224 /* Close the socket currently being polled in a thread */
7225 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
7226 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
7227 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
7229 POLL_SET(fdWrite
, POLLIN
| POLLOUT
);
7230 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
7231 ok(ret
== 1, "expected 1, got %d\n", ret
);
7232 ok(POLL_ISSET(fdWrite
, POLLWRNORM
), "fdWrite socket events incorrect\n");
7233 WaitForSingleObject (thread_handle
, 1000);
7234 closesocket(fdRead
);
7235 /* test again with less flags - behavior changes */
7236 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
7237 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
7238 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
7240 POLL_SET(fdWrite
, POLLIN
);
7241 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
7242 ok(ret
== 1, "expected 1, got %d\n", ret
);
7243 ok(POLL_ISSET(fdWrite
, POLLNVAL
), "fdWrite socket events incorrect\n");
7244 WaitForSingleObject (thread_handle
, 1000);
7245 closesocket(fdRead
);
7251 static void test_GetAddrInfoW(void)
7253 static const WCHAR port
[] = {'8','0',0};
7254 static const WCHAR empty
[] = {0};
7255 static const WCHAR localhost
[] = {'l','o','c','a','l','h','o','s','t',0};
7256 static const WCHAR nxdomain
[] =
7257 {'n','x','d','o','m','a','i','n','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',0};
7258 static const WCHAR zero
[] = {'0',0};
7260 ADDRINFOW
*result
, *result2
, *p
, hint
;
7262 DWORD size
= sizeof(name
)/sizeof(WCHAR
);
7263 /* te su to.winehq.org written in katakana */
7264 static const WCHAR idn_domain
[] =
7265 {0x30C6,0x30B9,0x30C8,'.','w','i','n','e','h','q','.','o','r','g',0};
7266 static const WCHAR idn_punycode
[] =
7267 {'x','n','-','-','z','c','k','z','a','h','.','w','i','n','e','h','q','.','o','r','g',0};
7269 if (!pGetAddrInfoW
|| !pFreeAddrInfoW
)
7271 win_skip("GetAddrInfoW and/or FreeAddrInfoW not present\n");
7274 memset(&hint
, 0, sizeof(ADDRINFOW
));
7276 GetComputerNameExW( ComputerNamePhysicalDnsHostname
, name
, &size
);
7278 result
= (ADDRINFOW
*)0xdeadbeef;
7279 WSASetLastError(0xdeadbeef);
7280 ret
= pGetAddrInfoW(NULL
, NULL
, NULL
, &result
);
7281 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
7282 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
7283 ok(result
== NULL
, "got %p\n", result
);
7286 WSASetLastError(0xdeadbeef);
7287 ret
= pGetAddrInfoW(empty
, NULL
, NULL
, &result
);
7288 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7289 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7290 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7291 pFreeAddrInfoW(result
);
7294 ret
= pGetAddrInfoW(NULL
, zero
, NULL
, &result
);
7295 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7296 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7299 ret
= pGetAddrInfoW(NULL
, empty
, NULL
, &result2
);
7300 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7301 ok(result2
!= NULL
, "GetAddrInfoW failed\n");
7302 compare_addrinfow(result
, result2
);
7303 pFreeAddrInfoW(result
);
7304 pFreeAddrInfoW(result2
);
7307 ret
= pGetAddrInfoW(empty
, zero
, NULL
, &result
);
7308 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7309 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7310 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7313 ret
= pGetAddrInfoW(empty
, empty
, NULL
, &result2
);
7314 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7315 ok(result2
!= NULL
, "GetAddrInfoW failed\n");
7316 compare_addrinfow(result
, result2
);
7317 pFreeAddrInfoW(result
);
7318 pFreeAddrInfoW(result2
);
7321 ret
= pGetAddrInfoW(localhost
, NULL
, NULL
, &result
);
7322 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7323 pFreeAddrInfoW(result
);
7326 ret
= pGetAddrInfoW(localhost
, empty
, NULL
, &result
);
7327 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7328 pFreeAddrInfoW(result
);
7331 ret
= pGetAddrInfoW(localhost
, zero
, NULL
, &result
);
7332 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7333 pFreeAddrInfoW(result
);
7336 ret
= pGetAddrInfoW(localhost
, port
, NULL
, &result
);
7337 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7338 pFreeAddrInfoW(result
);
7341 ret
= pGetAddrInfoW(localhost
, NULL
, &hint
, &result
);
7342 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7343 pFreeAddrInfoW(result
);
7346 SetLastError(0xdeadbeef);
7347 ret
= pGetAddrInfoW(localhost
, port
, &hint
, &result
);
7348 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7349 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7350 pFreeAddrInfoW(result
);
7352 /* try to get information from the computer name, result is the same
7353 * as if requesting with an empty host name. */
7354 ret
= pGetAddrInfoW(name
, NULL
, NULL
, &result
);
7355 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7356 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7358 ret
= pGetAddrInfoW(empty
, NULL
, NULL
, &result2
);
7359 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7360 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7361 compare_addrinfow(result
, result2
);
7362 pFreeAddrInfoW(result
);
7363 pFreeAddrInfoW(result2
);
7365 ret
= pGetAddrInfoW(name
, empty
, NULL
, &result
);
7366 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7367 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7369 ret
= pGetAddrInfoW(empty
, empty
, NULL
, &result2
);
7370 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7371 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7372 compare_addrinfow(result
, result2
);
7373 pFreeAddrInfoW(result
);
7374 pFreeAddrInfoW(result2
);
7376 result
= (ADDRINFOW
*)0xdeadbeef;
7377 WSASetLastError(0xdeadbeef);
7378 ret
= pGetAddrInfoW(NULL
, NULL
, NULL
, &result
);
7381 skip("nxdomain returned success. Broken ISP redirects?\n");
7384 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
7385 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
7386 ok(result
== NULL
, "got %p\n", result
);
7388 result
= (ADDRINFOW
*)0xdeadbeef;
7389 WSASetLastError(0xdeadbeef);
7390 ret
= pGetAddrInfoW(nxdomain
, NULL
, NULL
, &result
);
7393 skip("nxdomain returned success. Broken ISP redirects?\n");
7396 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
7397 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
7398 ok(result
== NULL
, "got %p\n", result
);
7400 for (i
= 0;i
< (sizeof(hinttests
) / sizeof(hinttests
[0]));i
++)
7402 hint
.ai_family
= hinttests
[i
].family
;
7403 hint
.ai_socktype
= hinttests
[i
].socktype
;
7404 hint
.ai_protocol
= hinttests
[i
].protocol
;
7407 SetLastError(0xdeadbeef);
7408 ret
= pGetAddrInfoW(localhost
, NULL
, &hint
, &result
);
7411 if (hinttests
[i
].error
)
7412 ok(0, "test %d: GetAddrInfoW succeeded unexpectedly\n", i
);
7418 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
7419 if (hinttests
[i
].family
== AF_UNSPEC
)
7420 ok(p
->ai_family
== AF_INET
|| p
->ai_family
== AF_INET6
,
7421 "test %d: expected AF_INET or AF_INET6, got %d\n",
7424 ok(p
->ai_family
== hinttests
[i
].family
,
7425 "test %d: expected family %d, got %d\n",
7426 i
, hinttests
[i
].family
, p
->ai_family
);
7428 ok(p
->ai_socktype
== hinttests
[i
].socktype
,
7429 "test %d: expected type %d, got %d\n",
7430 i
, hinttests
[i
].socktype
, p
->ai_socktype
);
7431 ok(p
->ai_protocol
== hinttests
[i
].protocol
,
7432 "test %d: expected protocol %d, got %d\n",
7433 i
, hinttests
[i
].protocol
, p
->ai_protocol
);
7438 pFreeAddrInfoW(result
);
7442 DWORD err
= WSAGetLastError();
7443 if (hinttests
[i
].error
)
7444 ok(hinttests
[i
].error
== err
, "test %d: GetAddrInfoW failed with error %d, expected %d\n",
7445 i
, err
, hinttests
[i
].error
);
7447 ok(0, "test %d: GetAddrInfoW failed with %d (err %d)\n", i
, ret
, err
);
7451 /* Test IDN resolution (Internationalized Domain Names) present since Windows 8 */
7452 trace("Testing punycode IDN %s\n", wine_dbgstr_w(idn_punycode
));
7454 ret
= pGetAddrInfoW(idn_punycode
, NULL
, NULL
, &result
);
7455 ok(!ret
, "got %d expected success\n", ret
);
7456 ok(result
!= NULL
, "got %p\n", result
);
7457 pFreeAddrInfoW(result
);
7459 hint
.ai_family
= AF_INET
;
7460 hint
.ai_socktype
= 0;
7461 hint
.ai_protocol
= 0;
7465 ret
= pGetAddrInfoW(idn_punycode
, NULL
, &hint
, &result
);
7466 ok(!ret
, "got %d expected success\n", ret
);
7467 ok(result
!= NULL
, "got %p\n", result
);
7469 trace("Testing unicode IDN %s\n", wine_dbgstr_w(idn_domain
));
7471 ret
= pGetAddrInfoW(idn_domain
, NULL
, NULL
, &result2
);
7472 if (ret
== WSAHOST_NOT_FOUND
&& broken(1))
7474 pFreeAddrInfoW(result
);
7475 win_skip("IDN resolution not supported in Win <= 7\n");
7479 ok(!ret
, "got %d expected success\n", ret
);
7480 ok(result2
!= NULL
, "got %p\n", result2
);
7481 pFreeAddrInfoW(result2
);
7483 hint
.ai_family
= AF_INET
;
7484 hint
.ai_socktype
= 0;
7485 hint
.ai_protocol
= 0;
7489 ret
= pGetAddrInfoW(idn_domain
, NULL
, &hint
, &result2
);
7490 ok(!ret
, "got %d expected success\n", ret
);
7491 ok(result2
!= NULL
, "got %p\n", result2
);
7493 /* ensure manually resolved punycode and unicode hosts result in same data */
7494 compare_addrinfow(result
, result2
);
7496 pFreeAddrInfoW(result
);
7497 pFreeAddrInfoW(result2
);
7499 hint
.ai_family
= AF_INET
;
7500 hint
.ai_socktype
= 0;
7501 hint
.ai_protocol
= 0;
7505 ret
= pGetAddrInfoW(idn_domain
, NULL
, &hint
, &result2
);
7506 ok(!ret
, "got %d expected success\n", ret
);
7507 ok(result2
!= NULL
, "got %p\n", result2
);
7508 pFreeAddrInfoW(result2
);
7510 /* Disable IDN resolution and test again*/
7511 hint
.ai_family
= AF_INET
;
7512 hint
.ai_socktype
= 0;
7513 hint
.ai_protocol
= 0;
7514 hint
.ai_flags
= AI_DISABLE_IDN_ENCODING
;
7516 SetLastError(0xdeadbeef);
7518 ret
= pGetAddrInfoW(idn_domain
, NULL
, &hint
, &result2
);
7519 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
7520 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
7521 ok(result2
== NULL
, "got %p\n", result2
);
7524 static void test_GetAddrInfoExW(void)
7526 static const WCHAR empty
[] = {0};
7527 static const WCHAR localhost
[] = {'l','o','c','a','l','h','o','s','t',0};
7528 static const WCHAR winehq
[] = {'t','e','s','t','.','w','i','n','e','h','q','.','o','r','g',0};
7529 ADDRINFOEXW
*result
;
7530 OVERLAPPED overlapped
;
7534 if (!pGetAddrInfoExW
|| !pGetAddrInfoExOverlappedResult
)
7536 win_skip("GetAddrInfoExW and/or GetAddrInfoExOverlappedResult not present\n");
7540 event
= WSACreateEvent();
7542 result
= (ADDRINFOEXW
*)0xdeadbeef;
7543 WSASetLastError(0xdeadbeef);
7544 ret
= pGetAddrInfoExW(NULL
, NULL
, NS_DNS
, NULL
, NULL
, &result
, NULL
, NULL
, NULL
, NULL
);
7545 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
7546 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
7547 ok(result
== NULL
, "got %p\n", result
);
7550 WSASetLastError(0xdeadbeef);
7551 ret
= pGetAddrInfoExW(empty
, NULL
, NS_DNS
, NULL
, NULL
, &result
, NULL
, NULL
, NULL
, NULL
);
7552 ok(!ret
, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7553 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7554 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7555 pFreeAddrInfoExW(result
);
7558 ret
= pGetAddrInfoExW(localhost
, NULL
, NS_DNS
, NULL
, NULL
, &result
, NULL
, NULL
, NULL
, NULL
);
7559 ok(!ret
, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7560 pFreeAddrInfoExW(result
);
7562 result
= (void*)0xdeadbeef;
7563 memset(&overlapped
, 0xcc, sizeof(overlapped
));
7564 overlapped
.hEvent
= event
;
7566 ret
= pGetAddrInfoExW(localhost
, NULL
, NS_DNS
, NULL
, NULL
, &result
, NULL
, &overlapped
, NULL
, NULL
);
7567 ok(ret
== ERROR_IO_PENDING
, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7568 ok(!result
, "result != NULL\n");
7569 ok(WaitForSingleObject(event
, 1000) == WAIT_OBJECT_0
, "wait failed\n");
7570 ret
= pGetAddrInfoExOverlappedResult(&overlapped
);
7571 ok(!ret
, "overlapped result is %d\n", ret
);
7572 pFreeAddrInfoExW(result
);
7574 result
= (void*)0xdeadbeef;
7575 memset(&overlapped
, 0xcc, sizeof(overlapped
));
7577 overlapped
.hEvent
= event
;
7578 WSASetLastError(0xdeadbeef);
7579 ret
= pGetAddrInfoExW(winehq
, NULL
, NS_DNS
, NULL
, NULL
, &result
, NULL
, &overlapped
, NULL
, NULL
);
7580 ok(ret
== ERROR_IO_PENDING
, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7581 ok(WSAGetLastError() == ERROR_IO_PENDING
, "expected 11001, got %d\n", WSAGetLastError());
7582 ret
= overlapped
.Internal
;
7583 ok(ret
== WSAEINPROGRESS
|| ret
== ERROR_SUCCESS
, "overlapped.Internal = %u\n", ret
);
7584 ok(WaitForSingleObject(event
, 1000) == WAIT_OBJECT_0
, "wait failed\n");
7585 ret
= pGetAddrInfoExOverlappedResult(&overlapped
);
7586 ok(!ret
, "overlapped result is %d\n", ret
);
7587 ok(overlapped
.hEvent
== event
, "hEvent changed %p\n", overlapped
.hEvent
);
7588 ok(overlapped
.Internal
== ERROR_SUCCESS
, "overlapped.Internal = %lx\n", overlapped
.Internal
);
7589 ok(overlapped
.Pointer
== &result
, "overlapped.Pointer != &result\n");
7590 ok(result
!= NULL
, "result == NULL\n");
7593 ok(!result
->ai_blob
, "ai_blob != NULL\n");
7594 ok(!result
->ai_bloblen
, "ai_bloblen != 0\n");
7595 ok(!result
->ai_provider
, "ai_provider = %s\n", wine_dbgstr_guid(result
->ai_provider
));
7596 pFreeAddrInfoExW(result
);
7599 result
= (void*)0xdeadbeef;
7600 memset(&overlapped
, 0xcc, sizeof(overlapped
));
7602 overlapped
.hEvent
= event
;
7603 ret
= pGetAddrInfoExW(NULL
, NULL
, NS_DNS
, NULL
, NULL
, &result
, NULL
, &overlapped
, NULL
, NULL
);
7605 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
7607 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
7608 ok(result
== NULL
, "got %p\n", result
);
7609 ret
= WaitForSingleObject(event
, 0);
7610 todo_wine_if(ret
!= WAIT_TIMEOUT
) /* Remove when abowe todo_wines are fixed */
7611 ok(ret
== WAIT_TIMEOUT
, "wait failed\n");
7613 WSACloseEvent(event
);
7616 static void verify_ipv6_addrinfo(ADDRINFOA
*result
, const char *expectedIp
)
7618 SOCKADDR_IN6
*sockaddr6
;
7622 ok(result
->ai_family
== AF_INET6
, "ai_family == %d\n", result
->ai_family
);
7623 ok(result
->ai_addrlen
>= sizeof(struct sockaddr_in6
), "ai_addrlen == %d\n", (int)result
->ai_addrlen
);
7624 ok(result
->ai_addr
!= NULL
, "ai_addr == NULL\n");
7626 if (result
->ai_addr
!= NULL
)
7628 sockaddr6
= (SOCKADDR_IN6
*)result
->ai_addr
;
7629 ok(sockaddr6
->sin6_family
== AF_INET6
, "ai_addr->sin6_family == %d\n", sockaddr6
->sin6_family
);
7630 ok(sockaddr6
->sin6_port
== 0, "ai_addr->sin6_port == %d\n", sockaddr6
->sin6_port
);
7632 ZeroMemory(ipBuffer
, sizeof(ipBuffer
));
7633 ret
= pInetNtop(AF_INET6
, &sockaddr6
->sin6_addr
, ipBuffer
, sizeof(ipBuffer
));
7634 ok(ret
!= NULL
, "inet_ntop failed (%d)\n", WSAGetLastError());
7635 ok(strcmp(ipBuffer
, expectedIp
) == 0, "ai_addr->sin6_addr == '%s' (expected '%s')\n", ipBuffer
, expectedIp
);
7639 static void test_getaddrinfo(void)
7642 ADDRINFOA
*result
, *result2
, *p
, hint
;
7643 SOCKADDR_IN
*sockaddr
;
7644 CHAR name
[256], *ip
;
7645 DWORD size
= sizeof(name
);
7647 if (!pgetaddrinfo
|| !pfreeaddrinfo
)
7649 win_skip("getaddrinfo and/or freeaddrinfo not present\n");
7652 memset(&hint
, 0, sizeof(ADDRINFOA
));
7653 GetComputerNameExA( ComputerNamePhysicalDnsHostname
, name
, &size
);
7655 result
= (ADDRINFOA
*)0xdeadbeef;
7656 WSASetLastError(0xdeadbeef);
7657 ret
= pgetaddrinfo(NULL
, NULL
, NULL
, &result
);
7658 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
7659 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
7660 ok(result
== NULL
, "got %p\n", result
);
7663 WSASetLastError(0xdeadbeef);
7664 ret
= pgetaddrinfo("", NULL
, NULL
, &result
);
7665 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7666 ok(result
!= NULL
, "getaddrinfo failed\n");
7667 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7668 pfreeaddrinfo(result
);
7671 ret
= pgetaddrinfo(NULL
, "0", NULL
, &result
);
7672 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7673 ok(result
!= NULL
, "getaddrinfo failed\n");
7676 ret
= pgetaddrinfo(NULL
, "", NULL
, &result2
);
7677 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7678 ok(result2
!= NULL
, "getaddrinfo failed\n");
7679 compare_addrinfo(result
, result2
);
7680 pfreeaddrinfo(result
);
7681 pfreeaddrinfo(result2
);
7684 WSASetLastError(0xdeadbeef);
7685 ret
= pgetaddrinfo("", "0", NULL
, &result
);
7686 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7687 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7688 ok(result
!= NULL
, "getaddrinfo failed\n");
7691 ret
= pgetaddrinfo("", "", NULL
, &result2
);
7692 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7693 ok(result2
!= NULL
, "getaddrinfo failed\n");
7694 compare_addrinfo(result
, result2
);
7695 pfreeaddrinfo(result
);
7696 pfreeaddrinfo(result2
);
7699 ret
= pgetaddrinfo("localhost", NULL
, NULL
, &result
);
7700 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7701 pfreeaddrinfo(result
);
7704 ret
= pgetaddrinfo("localhost", "", NULL
, &result
);
7705 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7706 pfreeaddrinfo(result
);
7709 ret
= pgetaddrinfo("localhost", "0", NULL
, &result
);
7710 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7711 pfreeaddrinfo(result
);
7714 ret
= pgetaddrinfo("localhost", "80", NULL
, &result
);
7715 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7716 pfreeaddrinfo(result
);
7719 ret
= pgetaddrinfo("localhost", NULL
, &hint
, &result
);
7720 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7721 pfreeaddrinfo(result
);
7724 WSASetLastError(0xdeadbeef);
7725 ret
= pgetaddrinfo("localhost", "80", &hint
, &result
);
7726 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7727 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7728 pfreeaddrinfo(result
);
7730 hint
.ai_flags
= AI_NUMERICHOST
;
7731 result
= (void*)0xdeadbeef;
7732 ret
= pgetaddrinfo("localhost", "80", &hint
, &result
);
7733 ok(ret
== WSAHOST_NOT_FOUND
, "getaddrinfo failed with %d\n", WSAGetLastError());
7734 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected WSAHOST_NOT_FOUND, got %d\n", WSAGetLastError());
7735 ok(!result
, "result = %p\n", result
);
7738 /* try to get information from the computer name, result is the same
7739 * as if requesting with an empty host name. */
7740 ret
= pgetaddrinfo(name
, NULL
, NULL
, &result
);
7741 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7742 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7744 ret
= pgetaddrinfo("", NULL
, NULL
, &result2
);
7745 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7746 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7747 compare_addrinfo(result
, result2
);
7748 pfreeaddrinfo(result
);
7749 pfreeaddrinfo(result2
);
7751 ret
= pgetaddrinfo(name
, "", NULL
, &result
);
7752 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7753 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7755 ret
= pgetaddrinfo("", "", NULL
, &result2
);
7756 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7757 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7758 compare_addrinfo(result
, result2
);
7759 pfreeaddrinfo(result
);
7760 pfreeaddrinfo(result2
);
7762 result
= (ADDRINFOA
*)0xdeadbeef;
7763 WSASetLastError(0xdeadbeef);
7764 ret
= pgetaddrinfo("nxdomain.codeweavers.com", NULL
, NULL
, &result
);
7767 skip("nxdomain returned success. Broken ISP redirects?\n");
7770 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
7771 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
7772 ok(result
== NULL
, "got %p\n", result
);
7774 /* Test IPv4 address conversion */
7776 ret
= pgetaddrinfo("192.168.1.253", NULL
, NULL
, &result
);
7777 ok(!ret
, "getaddrinfo failed with %d\n", ret
);
7778 ok(result
->ai_family
== AF_INET
, "ai_family == %d\n", result
->ai_family
);
7779 ok(result
->ai_addrlen
>= sizeof(struct sockaddr_in
), "ai_addrlen == %d\n", (int)result
->ai_addrlen
);
7780 ok(result
->ai_addr
!= NULL
, "ai_addr == NULL\n");
7781 sockaddr
= (SOCKADDR_IN
*)result
->ai_addr
;
7782 ok(sockaddr
->sin_family
== AF_INET
, "ai_addr->sin_family == %d\n", sockaddr
->sin_family
);
7783 ok(sockaddr
->sin_port
== 0, "ai_addr->sin_port == %d\n", sockaddr
->sin_port
);
7785 ip
= inet_ntoa(sockaddr
->sin_addr
);
7786 ok(strcmp(ip
, "192.168.1.253") == 0, "sockaddr->ai_addr == '%s'\n", ip
);
7787 pfreeaddrinfo(result
);
7789 /* Test IPv4 address conversion with port */
7791 hint
.ai_flags
= AI_NUMERICHOST
;
7792 ret
= pgetaddrinfo("192.168.1.253:1024", NULL
, &hint
, &result
);
7794 ok(ret
== WSAHOST_NOT_FOUND
, "getaddrinfo returned unexpected result: %d\n", ret
);
7795 ok(result
== NULL
, "expected NULL, got %p\n", result
);
7797 /* Test IPv6 address conversion */
7799 SetLastError(0xdeadbeef);
7800 ret
= pgetaddrinfo("2a00:2039:dead:beef:cafe::6666", NULL
, NULL
, &result
);
7804 ok(!ret
, "getaddrinfo failed with %d\n", ret
);
7805 verify_ipv6_addrinfo(result
, "2a00:2039:dead:beef:cafe::6666");
7806 pfreeaddrinfo(result
);
7808 /* Test IPv6 address conversion with brackets */
7810 ret
= pgetaddrinfo("[beef::cafe]", NULL
, NULL
, &result
);
7811 ok(!ret
, "getaddrinfo failed with %d\n", ret
);
7812 verify_ipv6_addrinfo(result
, "beef::cafe");
7813 pfreeaddrinfo(result
);
7815 /* Test IPv6 address conversion with brackets and hints */
7816 memset(&hint
, 0, sizeof(ADDRINFOA
));
7817 hint
.ai_flags
= AI_NUMERICHOST
;
7818 hint
.ai_family
= AF_INET6
;
7820 ret
= pgetaddrinfo("[beef::cafe]", NULL
, &hint
, &result
);
7821 ok(!ret
, "getaddrinfo failed with %d\n", ret
);
7822 verify_ipv6_addrinfo(result
, "beef::cafe");
7823 pfreeaddrinfo(result
);
7825 memset(&hint
, 0, sizeof(ADDRINFOA
));
7826 hint
.ai_flags
= AI_NUMERICHOST
;
7827 hint
.ai_family
= AF_INET
;
7829 ret
= pgetaddrinfo("[beef::cafe]", NULL
, &hint
, &result
);
7830 ok(ret
== WSAHOST_NOT_FOUND
, "getaddrinfo failed with %d\n", ret
);
7832 /* Test IPv6 address conversion with brackets and port */
7834 ret
= pgetaddrinfo("[beef::cafe]:10239", NULL
, NULL
, &result
);
7835 ok(!ret
, "getaddrinfo failed with %d\n", ret
);
7836 verify_ipv6_addrinfo(result
, "beef::cafe");
7837 pfreeaddrinfo(result
);
7839 /* Test IPv6 address conversion with unmatched brackets */
7841 hint
.ai_flags
= AI_NUMERICHOST
;
7842 ret
= pgetaddrinfo("[beef::cafe", NULL
, &hint
, &result
);
7843 ok(ret
== WSAHOST_NOT_FOUND
, "getaddrinfo failed with %d\n", ret
);
7845 ret
= pgetaddrinfo("beef::cafe]", NULL
, &hint
, &result
);
7846 ok(ret
== WSAHOST_NOT_FOUND
, "getaddrinfo failed with %d\n", ret
);
7850 ok(ret
== WSAHOST_NOT_FOUND
, "getaddrinfo failed with %d\n", ret
);
7851 win_skip("getaddrinfo does not support IPV6\n");
7856 for (i
= 0;i
< (sizeof(hinttests
) / sizeof(hinttests
[0]));i
++)
7858 hint
.ai_family
= hinttests
[i
].family
;
7859 hint
.ai_socktype
= hinttests
[i
].socktype
;
7860 hint
.ai_protocol
= hinttests
[i
].protocol
;
7863 SetLastError(0xdeadbeef);
7864 ret
= pgetaddrinfo("localhost", NULL
, &hint
, &result
);
7867 if (hinttests
[i
].error
)
7868 ok(0, "test %d: getaddrinfo succeeded unexpectedly\n", i
);
7874 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
7875 if (hinttests
[i
].family
== AF_UNSPEC
)
7876 ok(p
->ai_family
== AF_INET
|| p
->ai_family
== AF_INET6
,
7877 "test %d: expected AF_INET or AF_INET6, got %d\n",
7880 ok(p
->ai_family
== hinttests
[i
].family
,
7881 "test %d: expected family %d, got %d\n",
7882 i
, hinttests
[i
].family
, p
->ai_family
);
7884 ok(p
->ai_socktype
== hinttests
[i
].socktype
,
7885 "test %d: expected type %d, got %d\n",
7886 i
, hinttests
[i
].socktype
, p
->ai_socktype
);
7887 ok(p
->ai_protocol
== hinttests
[i
].protocol
,
7888 "test %d: expected protocol %d, got %d\n",
7889 i
, hinttests
[i
].protocol
, p
->ai_protocol
);
7894 pfreeaddrinfo(result
);
7898 DWORD err
= WSAGetLastError();
7899 if (hinttests
[i
].error
)
7900 ok(hinttests
[i
].error
== err
, "test %d: getaddrinfo failed with error %d, expected %d\n",
7901 i
, err
, hinttests
[i
].error
);
7903 ok(0, "test %d: getaddrinfo failed with %d (err %d)\n", i
, ret
, err
);
7908 static void test_ConnectEx(void)
7910 SOCKET listener
= INVALID_SOCKET
;
7911 SOCKET acceptor
= INVALID_SOCKET
;
7912 SOCKET connector
= INVALID_SOCKET
;
7913 struct sockaddr_in address
, conaddress
;
7915 OVERLAPPED overlapped
;
7916 LPFN_CONNECTEX pConnectEx
;
7917 GUID connectExGuid
= WSAID_CONNECTEX
;
7918 DWORD bytesReturned
;
7924 memset(&overlapped
, 0, sizeof(overlapped
));
7926 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
7927 if (listener
== INVALID_SOCKET
) {
7928 skip("could not create listener socket, error %d\n", WSAGetLastError());
7932 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7933 if (connector
== INVALID_SOCKET
) {
7934 skip("could not create connector socket, error %d\n", WSAGetLastError());
7938 memset(&address
, 0, sizeof(address
));
7939 address
.sin_family
= AF_INET
;
7940 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7941 iret
= bind(listener
, (struct sockaddr
*)&address
, sizeof(address
));
7943 skip("failed to bind, error %d\n", WSAGetLastError());
7947 addrlen
= sizeof(address
);
7948 iret
= getsockname(listener
, (struct sockaddr
*)&address
, &addrlen
);
7950 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
7954 if (set_blocking(listener
, TRUE
)) {
7955 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7959 bytesReturned
= 0xdeadbeef;
7960 iret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectExGuid
, sizeof(connectExGuid
),
7961 &pConnectEx
, sizeof(pConnectEx
), &bytesReturned
, NULL
, NULL
);
7963 win_skip("WSAIoctl failed to get ConnectEx with ret %d + errno %d\n", iret
, WSAGetLastError());
7967 ok(bytesReturned
== sizeof(pConnectEx
), "expected sizeof(pConnectEx), got %u\n", bytesReturned
);
7969 bret
= pConnectEx(INVALID_SOCKET
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
7970 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "ConnectEx on invalid socket "
7971 "returned %d + errno %d\n", bret
, WSAGetLastError());
7973 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
7974 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "ConnectEx on a unbound socket "
7975 "returned %d + errno %d\n", bret
, WSAGetLastError());
7976 if (bret
== TRUE
|| WSAGetLastError() != WSAEINVAL
)
7978 acceptor
= accept(listener
, NULL
, NULL
);
7979 if (acceptor
!= INVALID_SOCKET
) {
7980 closesocket(acceptor
);
7981 acceptor
= INVALID_SOCKET
;
7984 closesocket(connector
);
7985 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7986 if (connector
== INVALID_SOCKET
) {
7987 skip("could not create connector socket, error %d\n", WSAGetLastError());
7992 /* ConnectEx needs a bound socket */
7993 memset(&conaddress
, 0, sizeof(conaddress
));
7994 conaddress
.sin_family
= AF_INET
;
7995 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7996 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
7998 skip("failed to bind, error %d\n", WSAGetLastError());
8002 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, NULL
);
8003 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "ConnectEx on a NULL overlapped "
8004 "returned %d + errno %d\n", bret
, WSAGetLastError());
8006 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8007 if (overlapped
.hEvent
== NULL
) {
8008 skip("could not create event object, errno = %d\n", GetLastError());
8012 iret
= listen(listener
, 1);
8014 skip("listening failed, errno = %d\n", WSAGetLastError());
8018 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
8019 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
8020 "returned %d + errno %d\n", bret
, WSAGetLastError());
8021 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
8022 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
8024 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
8025 ok(bret
, "Connecting failed, error %d\n", GetLastError());
8026 ok(bytesReturned
== 0, "Bytes sent is %d\n", bytesReturned
);
8028 closesocket(connector
);
8029 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8030 if (connector
== INVALID_SOCKET
) {
8031 skip("could not create connector socket, error %d\n", WSAGetLastError());
8034 /* ConnectEx needs a bound socket */
8035 memset(&conaddress
, 0, sizeof(conaddress
));
8036 conaddress
.sin_family
= AF_INET
;
8037 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8038 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
8040 skip("failed to bind, error %d\n", WSAGetLastError());
8044 acceptor
= accept(listener
, NULL
, NULL
);
8045 if (acceptor
!= INVALID_SOCKET
) {
8046 closesocket(acceptor
);
8052 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, buffer
, 3, &bytesReturned
, &overlapped
);
8053 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
8054 "returned %d + errno %d\n", bret
, WSAGetLastError());
8055 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
8056 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
8058 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
8059 ok(bret
, "Connecting failed, error %d\n", GetLastError());
8060 ok(bytesReturned
== 3, "Bytes sent is %d\n", bytesReturned
);
8062 acceptor
= accept(listener
, NULL
, NULL
);
8063 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket error %d\n", WSAGetLastError());
8065 bytesReturned
= recv(acceptor
, buffer
, 3, 0);
8067 ok(bytesReturned
== 3, "Didn't get all sent data, got only %d\n", bytesReturned
);
8068 ok(buffer
[0] == '1' && buffer
[1] == '2' && buffer
[2] == '3',
8069 "Failed to get the right data, expected '123', got '%s'\n", buffer
);
8071 closesocket(connector
);
8072 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8073 if (connector
== INVALID_SOCKET
) {
8074 skip("could not create connector socket, error %d\n", WSAGetLastError());
8077 /* ConnectEx needs a bound socket */
8078 memset(&conaddress
, 0, sizeof(conaddress
));
8079 conaddress
.sin_family
= AF_INET
;
8080 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8081 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
8083 skip("failed to bind, error %d\n", WSAGetLastError());
8087 if (acceptor
!= INVALID_SOCKET
) {
8088 closesocket(acceptor
);
8089 acceptor
= INVALID_SOCKET
;
8092 /* Connect with error */
8093 closesocket(listener
);
8094 listener
= INVALID_SOCKET
;
8096 address
.sin_port
= htons(1);
8098 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
8099 ok(bret
== FALSE
&& GetLastError() == ERROR_IO_PENDING
, "ConnectEx to bad destination failed: "
8100 "returned %d + errno %d\n", bret
, GetLastError());
8101 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
8102 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
8104 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
8105 ok(bret
== FALSE
&& GetLastError() == ERROR_CONNECTION_REFUSED
,
8106 "Connecting to a disconnected host returned error %d - %d\n", bret
, WSAGetLastError());
8109 if (overlapped
.hEvent
)
8110 WSACloseEvent(overlapped
.hEvent
);
8111 if (listener
!= INVALID_SOCKET
)
8112 closesocket(listener
);
8113 if (acceptor
!= INVALID_SOCKET
)
8114 closesocket(acceptor
);
8115 if (connector
!= INVALID_SOCKET
)
8116 closesocket(connector
);
8119 static void test_AcceptEx(void)
8121 SOCKET listener
= INVALID_SOCKET
;
8122 SOCKET acceptor
= INVALID_SOCKET
;
8123 SOCKET connector
= INVALID_SOCKET
;
8124 SOCKET connector2
= INVALID_SOCKET
;
8125 struct sockaddr_in bindAddress
, peerAddress
, *readBindAddress
, *readRemoteAddress
;
8126 int socklen
, optlen
;
8127 GUID acceptExGuid
= WSAID_ACCEPTEX
, getAcceptExGuid
= WSAID_GETACCEPTEXSOCKADDRS
;
8128 LPFN_ACCEPTEX pAcceptEx
= NULL
;
8129 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs
= NULL
;
8130 fd_set fds_accept
, fds_send
;
8131 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
8133 DWORD bytesReturned
, connect_time
;
8134 char buffer
[1024], ipbuffer
[32];
8135 OVERLAPPED overlapped
;
8136 int iret
, localSize
= sizeof(struct sockaddr_in
), remoteSize
= localSize
;
8140 memset(&overlapped
, 0, sizeof(overlapped
));
8142 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
8143 if (listener
== INVALID_SOCKET
) {
8144 skip("could not create listener socket, error %d\n", WSAGetLastError());
8148 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
8149 if (acceptor
== INVALID_SOCKET
) {
8150 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8154 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8155 if (connector
== INVALID_SOCKET
) {
8156 skip("could not create connector socket, error %d\n", WSAGetLastError());
8160 memset(&bindAddress
, 0, sizeof(bindAddress
));
8161 bindAddress
.sin_family
= AF_INET
;
8162 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8163 iret
= bind(listener
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8165 skip("failed to bind, error %d\n", WSAGetLastError());
8169 socklen
= sizeof(bindAddress
);
8170 iret
= getsockname(listener
, (struct sockaddr
*)&bindAddress
, &socklen
);
8172 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
8176 if (set_blocking(listener
, FALSE
)) {
8177 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8181 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
8182 &pAcceptEx
, sizeof(pAcceptEx
), &bytesReturned
, NULL
, NULL
);
8184 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret
, WSAGetLastError());
8188 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &getAcceptExGuid
, sizeof(getAcceptExGuid
),
8189 &pGetAcceptExSockaddrs
, sizeof(pGetAcceptExSockaddrs
), &bytesReturned
, NULL
, NULL
);
8191 skip("WSAIoctl failed to get GetAcceptExSockaddrs with ret %d + errno %d\n", iret
, WSAGetLastError());
8195 bret
= pAcceptEx(INVALID_SOCKET
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
8196 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8197 &bytesReturned
, &overlapped
);
8198 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid listening socket "
8199 "returned %d + errno %d\n", bret
, WSAGetLastError());
8201 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
8202 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8203 &bytesReturned
, &overlapped
);
8205 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on a non-listening socket "
8206 "returned %d + errno %d\n", bret
, WSAGetLastError());
8208 iret
= listen(listener
, 5);
8210 skip("listening failed, errno = %d\n", WSAGetLastError());
8214 bret
= pAcceptEx(listener
, INVALID_SOCKET
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
8215 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8216 &bytesReturned
, &overlapped
);
8217 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid accepting socket "
8218 "returned %d + errno %d\n", bret
, WSAGetLastError());
8220 bret
= pAcceptEx(listener
, acceptor
, NULL
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
8221 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8222 &bytesReturned
, &overlapped
);
8223 todo_wine
ok(bret
== FALSE
&& WSAGetLastError() == WSAEFAULT
,
8224 "AcceptEx on NULL buffer returned %d + errno %d\n", bret
, WSAGetLastError());
8226 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16,
8227 &bytesReturned
, &overlapped
);
8228 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
,
8229 "AcceptEx on too small local address size returned %d + errno %d\n",
8230 bret
, WSAGetLastError());
8231 bret
= CancelIo((HANDLE
) listener
);
8232 ok(bret
, "Failed to cancel pending accept socket\n");
8234 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 15,
8235 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
8236 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx on too small local address "
8237 "size returned %d + errno %d\n",
8238 bret
, WSAGetLastError());
8239 bret
= CancelIo((HANDLE
) listener
);
8240 ok(bret
, "Failed to cancel pending accept socket\n");
8242 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16, 0,
8243 &bytesReturned
, &overlapped
);
8244 ok(bret
== FALSE
&& WSAGetLastError() == WSAEFAULT
,
8245 "AcceptEx on too small remote address size returned %d + errno %d\n", bret
, WSAGetLastError());
8247 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16,
8248 sizeof(struct sockaddr_in
) + 15, &bytesReturned
, &overlapped
);
8249 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
,
8250 "AcceptEx on too small remote address size returned %d + errno %d\n", bret
, WSAGetLastError());
8251 bret
= CancelIo((HANDLE
) listener
);
8252 ok(bret
, "Failed to cancel pending accept socket\n");
8254 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
8255 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8256 &bytesReturned
, NULL
);
8257 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
8258 "returned %d + errno %d\n", bret
, WSAGetLastError());
8260 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, 0, &bytesReturned
, NULL
);
8261 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
8262 "returned %d + errno %d\n", bret
, WSAGetLastError());
8264 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8265 if (overlapped
.hEvent
== NULL
) {
8266 skip("could not create event object, errno = %d\n", GetLastError());
8270 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
8271 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8272 &bytesReturned
, &overlapped
);
8273 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8275 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
8276 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8277 &bytesReturned
, &overlapped
);
8278 todo_wine
ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
,
8279 "AcceptEx on already pending socket returned %d + errno %d\n", bret
, WSAGetLastError());
8280 if (bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
) {
8281 /* We need to cancel this call, otherwise things fail */
8282 bret
= CancelIo((HANDLE
) listener
);
8283 ok(bret
, "Failed to cancel failed test. Bailing...\n");
8285 WaitForSingleObject(overlapped
.hEvent
, 0);
8287 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
8288 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8289 &bytesReturned
, &overlapped
);
8290 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8293 iret
= connect(acceptor
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8294 todo_wine
ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEINVAL
,
8295 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret
, WSAGetLastError());
8296 if (!iret
|| (iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
)) {
8297 /* We need to cancel this call, otherwise things fail */
8298 closesocket(acceptor
);
8299 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
8300 if (acceptor
== INVALID_SOCKET
) {
8301 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8305 bret
= CancelIo((HANDLE
) listener
);
8306 ok(bret
, "Failed to cancel failed test. Bailing...\n");
8309 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
8310 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8311 &bytesReturned
, &overlapped
);
8312 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8315 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8316 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8318 dwret
= WaitForSingleObject(overlapped
.hEvent
, INFINITE
);
8319 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
8321 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
8322 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
8323 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
8325 closesocket(connector
);
8326 connector
= INVALID_SOCKET
;
8327 closesocket(acceptor
);
8329 /* Test short reads */
8331 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
8332 if (acceptor
== INVALID_SOCKET
) {
8333 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8336 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8337 if (connector
== INVALID_SOCKET
) {
8338 skip("could not create connector socket, error %d\n", WSAGetLastError());
8341 bret
= pAcceptEx(listener
, acceptor
, buffer
, 2,
8342 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8343 &bytesReturned
, &overlapped
);
8344 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8346 connect_time
= 0xdeadbeef;
8347 optlen
= sizeof(connect_time
);
8348 iret
= getsockopt(connector
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
8349 ok(!iret
, "getsockopt failed %d\n", WSAGetLastError());
8350 ok(connect_time
== ~0u, "unexpected connect time %u\n", connect_time
);
8352 /* AcceptEx() still won't complete until we send data */
8353 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8354 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8356 connect_time
= 0xdeadbeef;
8357 optlen
= sizeof(connect_time
);
8358 iret
= getsockopt(connector
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
8359 ok(!iret
, "getsockopt failed %d\n", WSAGetLastError());
8360 ok(connect_time
< 0xdeadbeef, "unexpected connect time %u\n", connect_time
);
8362 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
8363 ok(dwret
== WAIT_TIMEOUT
, "Waiting for accept event timeout failed with %d + errno %d\n", dwret
, GetLastError());
8365 iret
= getsockname( connector
, (struct sockaddr
*)&peerAddress
, &remoteSize
);
8366 ok( !iret
, "getsockname failed.\n");
8368 /* AcceptEx() could complete any time now */
8369 iret
= send(connector
, buffer
, 1, 0);
8370 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
8372 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8373 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
8375 /* Check if the buffer from AcceptEx is decoded correctly */
8376 pGetAcceptExSockaddrs(buffer
, 2, sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8377 (struct sockaddr
**)&readBindAddress
, &localSize
,
8378 (struct sockaddr
**)&readRemoteAddress
, &remoteSize
);
8379 strcpy( ipbuffer
, inet_ntoa(readBindAddress
->sin_addr
));
8380 ok( readBindAddress
->sin_addr
.s_addr
== bindAddress
.sin_addr
.s_addr
,
8381 "Local socket address is different %s != %s\n",
8382 ipbuffer
, inet_ntoa(bindAddress
.sin_addr
));
8383 ok( readBindAddress
->sin_port
== bindAddress
.sin_port
,
8384 "Local socket port is different: %d != %d\n",
8385 readBindAddress
->sin_port
, bindAddress
.sin_port
);
8386 strcpy( ipbuffer
, inet_ntoa(readRemoteAddress
->sin_addr
));
8387 ok( readRemoteAddress
->sin_addr
.s_addr
== peerAddress
.sin_addr
.s_addr
,
8388 "Remote socket address is different %s != %s\n",
8389 ipbuffer
, inet_ntoa(peerAddress
.sin_addr
));
8390 ok( readRemoteAddress
->sin_port
== peerAddress
.sin_port
,
8391 "Remote socket port is different: %d != %d\n",
8392 readRemoteAddress
->sin_port
, peerAddress
.sin_port
);
8394 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
8395 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
8396 ok(bytesReturned
== 1, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
8398 closesocket(connector
);
8399 connector
= INVALID_SOCKET
;
8400 closesocket(acceptor
);
8402 /* Test CF_DEFER & AcceptEx interaction */
8404 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
8405 if (acceptor
== INVALID_SOCKET
) {
8406 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8409 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8410 if (connector
== INVALID_SOCKET
) {
8411 skip("could not create connector socket, error %d\n", WSAGetLastError());
8414 connector2
= socket(AF_INET
, SOCK_STREAM
, 0);
8415 if (connector
== INVALID_SOCKET
) {
8416 skip("could not create connector socket, error %d\n", WSAGetLastError());
8420 if (set_blocking(connector
, FALSE
)) {
8421 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8425 if (set_blocking(connector2
, FALSE
)) {
8426 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8430 /* Connect socket #1 */
8431 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8432 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8434 FD_ZERO ( &fds_accept
);
8435 FD_ZERO ( &fds_send
);
8437 FD_SET ( listener
, &fds_accept
);
8438 FD_SET ( connector
, &fds_send
);
8444 for (i
= 0; i
< 4000; ++i
)
8446 fd_set fds_openaccept
= fds_accept
, fds_opensend
= fds_send
;
8448 wsa_ok ( ( select ( 0, &fds_openaccept
, &fds_opensend
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
8449 "acceptex test(%d): could not select on socket, errno %d\n" );
8451 /* check for incoming requests */
8452 if ( FD_ISSET ( listener
, &fds_openaccept
) ) {
8455 SOCKET tmp
= WSAAccept(listener
, NULL
, NULL
, (LPCONDITIONPROC
) AlwaysDeferConditionFunc
, 0);
8456 ok(tmp
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
8457 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
8458 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8459 &bytesReturned
, &overlapped
);
8460 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8462 else if (got
== 2) {
8463 /* this should be socket #2 */
8464 SOCKET tmp
= accept(listener
, NULL
, NULL
);
8465 ok(tmp
!= INVALID_SOCKET
, "accept failed %d\n", WSAGetLastError());
8469 ok(FALSE
, "Got more than 2 connections?\n");
8472 if ( conn1
&& FD_ISSET ( connector2
, &fds_opensend
) ) {
8473 /* Send data on second socket, and stop */
8474 send(connector2
, "2", 1, 0);
8475 FD_CLR ( connector2
, &fds_send
);
8479 if ( FD_ISSET ( connector
, &fds_opensend
) ) {
8480 /* Once #1 is connected, allow #2 to connect */
8483 send(connector
, "1", 1, 0);
8484 FD_CLR ( connector
, &fds_send
);
8486 iret
= connect(connector2
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8487 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8488 FD_SET ( connector2
, &fds_send
);
8492 ok (got
== 2 || broken(got
== 1) /* NT4 */,
8493 "Did not get both connections, got %d\n", got
);
8495 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
8496 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
8498 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
8499 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
8500 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
8502 set_blocking(acceptor
, TRUE
);
8503 iret
= recv( acceptor
, buffer
, 2, 0);
8504 ok(iret
== 1, "Failed to get data, %d, errno: %d\n", iret
, WSAGetLastError());
8506 ok(buffer
[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer
[0]);
8508 closesocket(connector
);
8509 connector
= INVALID_SOCKET
;
8510 closesocket(acceptor
);
8512 /* clean up in case of failures */
8513 while ((acceptor
= accept(listener
, NULL
, NULL
)) != INVALID_SOCKET
)
8514 closesocket(acceptor
);
8516 /* Disconnect during receive? */
8518 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
8519 if (acceptor
== INVALID_SOCKET
) {
8520 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8523 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8524 if (connector
== INVALID_SOCKET
) {
8525 skip("could not create connector socket, error %d\n", WSAGetLastError());
8528 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
8529 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8530 &bytesReturned
, &overlapped
);
8531 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8533 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8534 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8536 closesocket(connector
);
8537 connector
= INVALID_SOCKET
;
8539 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8540 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
8542 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
8543 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
8544 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
8546 closesocket(acceptor
);
8548 /* Test closing with pending requests */
8550 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
8551 if (acceptor
== INVALID_SOCKET
) {
8552 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8555 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
8556 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8557 &bytesReturned
, &overlapped
);
8558 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8560 closesocket(acceptor
);
8562 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8563 todo_wine
ok(dwret
== WAIT_OBJECT_0
,
8564 "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
8566 if (dwret
!= WAIT_TIMEOUT
) {
8567 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
8568 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
8571 bret
= CancelIo((HANDLE
) listener
);
8572 ok(bret
, "Failed to cancel failed test. Bailing...\n");
8574 WaitForSingleObject(overlapped
.hEvent
, 0);
8577 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
8578 if (acceptor
== INVALID_SOCKET
) {
8579 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8582 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
8583 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8584 &bytesReturned
, &overlapped
);
8585 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8587 CancelIo((HANDLE
) acceptor
);
8589 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8590 ok(dwret
== WAIT_TIMEOUT
, "Waiting for timeout failed with %d + errno %d\n", dwret
, GetLastError());
8592 closesocket(acceptor
);
8594 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
8595 if (acceptor
== INVALID_SOCKET
) {
8596 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8599 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
8600 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8601 &bytesReturned
, &overlapped
);
8602 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8604 closesocket(listener
);
8605 listener
= INVALID_SOCKET
;
8607 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8608 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
8610 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
8611 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
8614 if (overlapped
.hEvent
)
8615 WSACloseEvent(overlapped
.hEvent
);
8616 if (listener
!= INVALID_SOCKET
)
8617 closesocket(listener
);
8618 if (acceptor
!= INVALID_SOCKET
)
8619 closesocket(acceptor
);
8620 if (connector
!= INVALID_SOCKET
)
8621 closesocket(connector
);
8622 if (connector2
!= INVALID_SOCKET
)
8623 closesocket(connector2
);
8626 static void test_DisconnectEx(void)
8628 SOCKET listener
, acceptor
, connector
;
8629 LPFN_DISCONNECTEX pDisconnectEx
;
8630 GUID disconnectExGuid
= WSAID_DISCONNECTEX
;
8631 struct sockaddr_in address
;
8632 DWORD num_bytes
, flags
;
8633 OVERLAPPED overlapped
;
8637 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8638 ok(connector
!= INVALID_SOCKET
, "failed to create connector socket, error %d\n", WSAGetLastError());
8640 iret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &disconnectExGuid
, sizeof(disconnectExGuid
),
8641 &pDisconnectEx
, sizeof(pDisconnectEx
), &num_bytes
, NULL
, NULL
);
8644 win_skip("WSAIoctl failed to get DisconnectEx, error %d\n", WSAGetLastError());
8645 closesocket(connector
);
8649 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
8650 ok(listener
!= INVALID_SOCKET
, "failed to create listener socket, error %d\n", WSAGetLastError());
8652 memset(&address
, 0, sizeof(address
));
8653 address
.sin_family
= AF_INET
;
8654 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8655 iret
= bind(listener
, (struct sockaddr
*)&address
, sizeof(address
));
8656 ok(iret
== 0, "failed to bind, error %d\n", WSAGetLastError());
8658 addrlen
= sizeof(address
);
8659 iret
= getsockname(listener
, (struct sockaddr
*)&address
, &addrlen
);
8660 ok(iret
== 0, "failed to lookup bind address, error %d\n", WSAGetLastError());
8662 iret
= listen(listener
, 1);
8663 ok(iret
== 0, "failed to listen, error %d\n", WSAGetLastError());
8665 set_blocking(listener
, TRUE
);
8667 memset(&overlapped
, 0, sizeof(overlapped
));
8668 bret
= pDisconnectEx(INVALID_SOCKET
, &overlapped
, 0, 0);
8669 ok(bret
== FALSE
, "DisconnectEx unexpectedly succeeded\n");
8670 ok(WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %d\n", WSAGetLastError());
8672 memset(&overlapped
, 0, sizeof(overlapped
));
8673 bret
= pDisconnectEx(connector
, &overlapped
, 0, 0);
8674 ok(bret
== FALSE
, "DisconnectEx unexpectedly succeeded\n");
8675 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "expected WSAENOTCONN, got %d\n", WSAGetLastError());
8677 iret
= connect(connector
, (struct sockaddr
*)&address
, addrlen
);
8678 ok(iret
== 0, "failed to connect, error %d\n", WSAGetLastError());
8680 acceptor
= accept(listener
, NULL
, NULL
);
8681 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket, error %d\n", WSAGetLastError());
8683 memset(&overlapped
, 0, sizeof(overlapped
));
8684 overlapped
.hEvent
= WSACreateEvent();
8685 ok(overlapped
.hEvent
!= WSA_INVALID_EVENT
, "WSACreateEvent failed, error %d\n", WSAGetLastError());
8686 bret
= pDisconnectEx(connector
, &overlapped
, 0, 0);
8688 ok(overlapped
.Internal
== STATUS_PENDING
, "expected STATUS_PENDING, got %08lx\n", overlapped
.Internal
);
8689 else if (WSAGetLastError() == ERROR_IO_PENDING
)
8690 bret
= WSAGetOverlappedResult(connector
, &overlapped
, &num_bytes
, TRUE
, &flags
);
8691 ok(bret
, "DisconnectEx failed, error %d\n", WSAGetLastError());
8692 WSACloseEvent(overlapped
.hEvent
);
8694 iret
= connect(connector
, (struct sockaddr
*)&address
, sizeof(address
));
8695 ok(iret
!= 0, "connect unexpectedly succeeded\n");
8696 ok(WSAGetLastError() == WSAEISCONN
, "expected WSAEISCONN, got %d\n", WSAGetLastError());
8698 closesocket(acceptor
);
8699 closesocket(connector
);
8701 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8702 ok(connector
!= INVALID_SOCKET
, "failed to create connector socket, error %d\n", WSAGetLastError());
8704 iret
= connect(connector
, (struct sockaddr
*)&address
, addrlen
);
8705 ok(iret
== 0, "failed to connect, error %d\n", WSAGetLastError());
8707 acceptor
= accept(listener
, NULL
, NULL
);
8708 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket, error %d\n", WSAGetLastError());
8710 bret
= pDisconnectEx(connector
, NULL
, 0, 0);
8711 ok(bret
, "DisconnectEx failed, error %d\n", WSAGetLastError());
8713 iret
= connect(connector
, (struct sockaddr
*)&address
, sizeof(address
));
8714 ok(iret
!= 0, "connect unexpectedly succeeded\n");
8715 ok(WSAGetLastError() == WSAEISCONN
, "expected WSAEISCONN, got %d\n", WSAGetLastError());
8717 closesocket(acceptor
);
8718 closesocket(connector
);
8719 closesocket(listener
);
8722 #define compare_file(h,s,o) compare_file2(h,s,o,__FILE__,__LINE__)
8724 static void compare_file2(HANDLE handle
, SOCKET sock
, int offset
, const char *file
, int line
)
8726 char buf1
[256], buf2
[256];
8730 SetFilePointer(handle
, offset
, NULL
, FILE_BEGIN
);
8733 DWORD n1
= 0, n2
= 0;
8735 success
= ReadFile(handle
, buf1
, sizeof(buf1
), &n1
, NULL
);
8736 ok_(file
,line
)(success
, "Failed to read from file.\n");
8737 if (success
&& n1
== 0)
8741 n2
= recv(sock
, buf2
, n1
, 0);
8742 ok_(file
,line
)(n1
== n2
, "Block %d size mismatch (%d != %d)\n", i
, n1
, n2
);
8743 ok_(file
,line
)(memcmp(buf1
, buf2
, n2
) == 0, "Block %d failed\n", i
);
8748 static void test_TransmitFile(void)
8750 DWORD num_bytes
, err
, file_size
, total_sent
;
8751 GUID transmitFileGuid
= WSAID_TRANSMITFILE
;
8752 LPFN_TRANSMITFILE pTransmitFile
= NULL
;
8753 HANDLE file
= INVALID_HANDLE_VALUE
;
8754 char header_msg
[] = "hello world";
8755 char footer_msg
[] = "goodbye!!!";
8756 char system_ini_path
[MAX_PATH
];
8757 struct sockaddr_in bindAddress
;
8758 TRANSMIT_FILE_BUFFERS buffers
;
8759 SOCKET client
, server
, dest
;
8765 memset( &ov
, 0, sizeof(ov
) );
8767 /* Setup sockets for testing TransmitFile */
8768 client
= socket(AF_INET
, SOCK_STREAM
, 0);
8769 server
= socket(AF_INET
, SOCK_STREAM
, 0);
8770 if (client
== INVALID_SOCKET
|| server
== INVALID_SOCKET
)
8772 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8775 iret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &transmitFileGuid
, sizeof(transmitFileGuid
),
8776 &pTransmitFile
, sizeof(pTransmitFile
), &num_bytes
, NULL
, NULL
);
8779 skip("WSAIoctl failed to get TransmitFile with ret %d + errno %d\n", iret
, WSAGetLastError());
8782 GetSystemWindowsDirectoryA(system_ini_path
, MAX_PATH
);
8783 strcat(system_ini_path
, "\\system.ini");
8784 file
= CreateFileA(system_ini_path
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_ALWAYS
, 0x0, NULL
);
8785 if (file
== INVALID_HANDLE_VALUE
)
8787 skip("Unable to open a file to transmit.\n");
8790 file_size
= GetFileSize(file
, NULL
);
8792 /* Test TransmitFile with an invalid socket */
8793 bret
= pTransmitFile(INVALID_SOCKET
, file
, 0, 0, NULL
, NULL
, 0);
8794 err
= WSAGetLastError();
8795 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8796 ok(err
== WSAENOTSOCK
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTSOCK
);
8798 /* Test a bogus TransmitFile without a connected socket */
8799 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, TF_REUSE_SOCKET
);
8800 err
= WSAGetLastError();
8801 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8802 ok(err
== WSAENOTCONN
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTCONN
);
8804 /* Setup a properly connected socket for transfers */
8805 memset(&bindAddress
, 0, sizeof(bindAddress
));
8806 bindAddress
.sin_family
= AF_INET
;
8807 bindAddress
.sin_port
= htons(SERVERPORT
+1);
8808 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8809 iret
= bind(server
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8812 skip("failed to bind(), error %d\n", WSAGetLastError());
8815 iret
= listen(server
, 1);
8818 skip("failed to listen(), error %d\n", WSAGetLastError());
8821 iret
= connect(client
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8824 skip("failed to connect(), error %d\n", WSAGetLastError());
8827 len
= sizeof(bindAddress
);
8828 dest
= accept(server
, (struct sockaddr
*)&bindAddress
, &len
);
8829 if (dest
== INVALID_SOCKET
)
8831 skip("failed to accept(), error %d\n", WSAGetLastError());
8834 if (set_blocking(dest
, FALSE
))
8836 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8840 /* Test TransmitFile with no possible buffer */
8841 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, 0);
8842 ok(bret
, "TransmitFile failed unexpectedly.\n");
8843 iret
= recv(dest
, buf
, sizeof(buf
), 0);
8844 ok(iret
== -1, "Returned an unexpected buffer from TransmitFile (%d != -1).\n", iret
);
8846 /* Test TransmitFile with only buffer data */
8847 buffers
.Head
= &header_msg
[0];
8848 buffers
.HeadLength
= sizeof(header_msg
);
8849 buffers
.Tail
= &footer_msg
[0];
8850 buffers
.TailLength
= sizeof(footer_msg
);
8851 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, &buffers
, 0);
8852 ok(bret
, "TransmitFile failed unexpectedly.\n");
8853 iret
= recv(dest
, buf
, sizeof(buf
), 0);
8854 ok(iret
== sizeof(header_msg
)+sizeof(footer_msg
),
8855 "Returned an unexpected buffer from TransmitFile: %d\n", iret
);
8856 ok(memcmp(&buf
[0], &header_msg
[0], sizeof(header_msg
)) == 0,
8857 "TransmitFile header buffer did not match!\n");
8858 ok(memcmp(&buf
[sizeof(header_msg
)], &footer_msg
[0], sizeof(footer_msg
)) == 0,
8859 "TransmitFile footer buffer did not match!\n");
8861 /* Test TransmitFile with only file data */
8862 bret
= pTransmitFile(client
, file
, 0, 0, NULL
, NULL
, 0);
8863 ok(bret
, "TransmitFile failed unexpectedly.\n");
8864 compare_file(file
, dest
, 0);
8866 /* Test TransmitFile with both file and buffer data */
8867 buffers
.Head
= &header_msg
[0];
8868 buffers
.HeadLength
= sizeof(header_msg
);
8869 buffers
.Tail
= &footer_msg
[0];
8870 buffers
.TailLength
= sizeof(footer_msg
);
8871 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
8872 bret
= pTransmitFile(client
, file
, 0, 0, NULL
, &buffers
, 0);
8873 ok(bret
, "TransmitFile failed unexpectedly.\n");
8874 iret
= recv(dest
, buf
, sizeof(header_msg
), 0);
8875 ok(memcmp(buf
, &header_msg
[0], sizeof(header_msg
)) == 0,
8876 "TransmitFile header buffer did not match!\n");
8877 compare_file(file
, dest
, 0);
8878 iret
= recv(dest
, buf
, sizeof(footer_msg
), 0);
8879 ok(memcmp(buf
, &footer_msg
[0], sizeof(footer_msg
)) == 0,
8880 "TransmitFile footer buffer did not match!\n");
8882 /* Test overlapped TransmitFile */
8883 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
8884 if (ov
.hEvent
== INVALID_HANDLE_VALUE
)
8886 skip("Could not create event object, some tests will be skipped. errno = %d\n",
8890 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
8891 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, NULL
, 0);
8892 err
= WSAGetLastError();
8893 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8894 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n",
8895 err
, ERROR_IO_PENDING
);
8896 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
8897 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
8898 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
8899 ok(total_sent
== file_size
,
8900 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8901 total_sent
, file_size
);
8902 compare_file(file
, dest
, 0);
8904 /* Test overlapped TransmitFile w/ start offset */
8905 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
8906 if (ov
.hEvent
== INVALID_HANDLE_VALUE
)
8908 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
8911 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
8913 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, NULL
, 0);
8914 err
= WSAGetLastError();
8915 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8916 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, ERROR_IO_PENDING
);
8917 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
8918 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
8919 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
8920 ok(total_sent
== (file_size
- ov
.Offset
),
8921 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8922 total_sent
, file_size
- ov
.Offset
);
8923 compare_file(file
, dest
, ov
.Offset
);
8925 /* Test overlapped TransmitFile w/ file and buffer data */
8926 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
8927 if (ov
.hEvent
== INVALID_HANDLE_VALUE
)
8929 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
8932 buffers
.Head
= &header_msg
[0];
8933 buffers
.HeadLength
= sizeof(header_msg
);
8934 buffers
.Tail
= &footer_msg
[0];
8935 buffers
.TailLength
= sizeof(footer_msg
);
8936 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
8938 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, &buffers
, 0);
8939 err
= WSAGetLastError();
8940 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8941 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, ERROR_IO_PENDING
);
8942 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
8943 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
8944 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
8945 ok(total_sent
== (file_size
+ buffers
.HeadLength
+ buffers
.TailLength
),
8946 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8947 total_sent
, file_size
+ buffers
.HeadLength
+ buffers
.TailLength
);
8948 iret
= recv(dest
, buf
, sizeof(header_msg
), 0);
8949 ok(memcmp(buf
, &header_msg
[0], sizeof(header_msg
)) == 0,
8950 "TransmitFile header buffer did not match!\n");
8951 compare_file(file
, dest
, 0);
8952 iret
= recv(dest
, buf
, sizeof(footer_msg
), 0);
8953 ok(memcmp(buf
, &footer_msg
[0], sizeof(footer_msg
)) == 0,
8954 "TransmitFile footer buffer did not match!\n");
8956 /* Test TransmitFile with a UDP datagram socket */
8957 closesocket(client
);
8958 client
= socket(AF_INET
, SOCK_DGRAM
, 0);
8959 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, 0);
8960 err
= WSAGetLastError();
8961 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8962 ok(err
== WSAENOTCONN
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTCONN
);
8966 CloseHandle(ov
.hEvent
);
8967 closesocket(client
);
8968 closesocket(server
);
8971 static void test_getpeername(void)
8974 struct sockaddr_in sa
, sa_out
;
8975 SOCKADDR_STORAGE ss
;
8977 const char buf
[] = "hello world";
8980 /* Test the parameter validation order. */
8981 ret
= getpeername(INVALID_SOCKET
, NULL
, NULL
);
8982 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
8983 ok(WSAGetLastError() == WSAENOTSOCK
,
8984 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
8986 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
8987 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
8988 if (sock
== INVALID_SOCKET
)
8990 skip("Socket creation failed with %d\n", WSAGetLastError());
8994 ret
= getpeername(sock
, NULL
, NULL
);
8995 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
8996 ok(WSAGetLastError() == WSAENOTCONN
,
8997 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
8999 memset(&sa
, 0, sizeof(sa
));
9000 sa
.sin_family
= AF_INET
;
9001 sa
.sin_port
= htons(139);
9002 sa
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
9004 /* sendto does not change a socket's connection state. */
9005 ret
= sendto(sock
, buf
, sizeof(buf
), 0, (struct sockaddr
*)&sa
, sizeof(sa
));
9006 ok(ret
!= SOCKET_ERROR
,
9007 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
9009 ret
= getpeername(sock
, NULL
, NULL
);
9010 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
9011 ok(WSAGetLastError() == WSAENOTCONN
,
9012 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
9014 ret
= connect(sock
, (struct sockaddr
*)&sa
, sizeof(sa
));
9016 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
9018 ret
= getpeername(sock
, NULL
, NULL
);
9019 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
9020 ok(WSAGetLastError() == WSAEFAULT
,
9021 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9023 /* Test crashes on Wine. */
9026 ret
= getpeername(sock
, (void*)0xdeadbeef, (void*)0xcafebabe);
9027 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
9028 ok(WSAGetLastError() == WSAEFAULT
,
9029 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9032 ret
= getpeername(sock
, (struct sockaddr
*)&sa_out
, NULL
);
9033 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
9034 ok(WSAGetLastError() == WSAEFAULT
,
9035 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9038 ret
= getpeername(sock
, NULL
, &sa_len
);
9039 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
9040 ok(WSAGetLastError() == WSAEFAULT
,
9041 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9042 ok(!sa_len
, "got %d\n", sa_len
);
9045 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
9046 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
9047 ok(WSAGetLastError() == WSAEFAULT
,
9048 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9049 ok(!sa_len
, "got %d\n", sa_len
);
9051 sa_len
= sizeof(ss
);
9052 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
9053 ok(ret
== 0, "Expected getpeername to return 0, got %d\n", ret
);
9054 ok(!memcmp(&sa
, &ss
, sizeof(sa
)),
9055 "Expected the returned structure to be identical to the connect structure\n");
9056 ok(sa_len
== sizeof(sa
), "got %d\n", sa_len
);
9061 static void test_sioRoutingInterfaceQuery(void)
9065 SOCKADDR_IN sin
= { 0 }, sout
= { 0 };
9066 DWORD bytesReturned
;
9068 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
9069 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
9070 if (sock
== INVALID_SOCKET
)
9072 skip("Socket creation failed with %d\n", WSAGetLastError());
9075 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, NULL
, 0, NULL
, 0, NULL
,
9077 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
9078 "expected WSAEFAULT, got %d\n", WSAGetLastError());
9079 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
9080 NULL
, 0, NULL
, NULL
, NULL
);
9081 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
9082 "expected WSAEFAULT, got %d\n", WSAGetLastError());
9083 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
9084 NULL
, 0, &bytesReturned
, NULL
, NULL
);
9085 todo_wine
ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEAFNOSUPPORT
,
9086 "expected WSAEAFNOSUPPORT, got %d\n", WSAGetLastError());
9087 sin
.sin_family
= AF_INET
;
9088 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
9089 NULL
, 0, &bytesReturned
, NULL
, NULL
);
9090 todo_wine
ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEINVAL
,
9091 "expected WSAEINVAL, got %d\n", WSAGetLastError());
9092 sin
.sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
9093 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
9094 NULL
, 0, &bytesReturned
, NULL
, NULL
);
9095 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
9096 "expected WSAEFAULT, got %d\n", WSAGetLastError());
9097 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
9098 &sout
, sizeof(sout
), &bytesReturned
, NULL
, NULL
);
9099 ok(!ret
, "WSAIoctl failed: %d\n", WSAGetLastError());
9100 ok(sout
.sin_family
== AF_INET
, "expected AF_INET, got %d\n", sout
.sin_family
);
9101 /* We expect the source address to be INADDR_LOOPBACK as well, but
9102 * there's no guarantee that a route to the loopback address exists,
9103 * so rather than introduce spurious test failures we do not test the
9109 static void test_sioAddressListChange(void)
9111 struct sockaddr_in bindAddress
;
9112 struct in_addr net_address
;
9113 WSAOVERLAPPED overlapped
, *olp
;
9115 DWORD num_bytes
, error
, tick
;
9116 SOCKET sock
, sock2
, sock3
;
9117 WSAEVENT event2
, event3
;
9124 /* Use gethostbyname to find the list of local network interfaces */
9125 h
= gethostbyname("");
9128 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, gethostbyname failed with %u\n",
9132 for (acount
= 0; h
->h_addr_list
[acount
]; acount
++);
9135 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
9139 net_address
.s_addr
= *(ULONG
*) h
->h_addr_list
[0];
9141 sock
= socket(AF_INET
, 0, IPPROTO_TCP
);
9142 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
9144 memset(&bindAddress
, 0, sizeof(bindAddress
));
9145 bindAddress
.sin_family
= AF_INET
;
9146 bindAddress
.sin_addr
.s_addr
= net_address
.s_addr
;
9147 SetLastError(0xdeadbeef);
9148 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9149 ok (!ret
, "bind() failed with error %d\n", GetLastError());
9150 set_blocking(sock
, FALSE
);
9152 memset(&overlapped
, 0, sizeof(overlapped
));
9153 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
9154 SetLastError(0xdeadbeef);
9155 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
9156 error
= GetLastError();
9157 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
9158 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
9160 CloseHandle(overlapped
.hEvent
);
9163 sock
= socket(AF_INET
, 0, IPPROTO_TCP
);
9164 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
9166 SetLastError(0xdeadbeef);
9167 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9168 ok (!ret
, "bind() failed with error %d\n", GetLastError());
9169 set_blocking(sock
, TRUE
);
9171 memset(&overlapped
, 0, sizeof(overlapped
));
9172 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
9173 SetLastError(0xdeadbeef);
9174 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
9175 error
= GetLastError();
9176 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
9177 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
9179 CloseHandle(overlapped
.hEvent
);
9182 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
9183 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
9185 SetLastError(0xdeadbeef);
9186 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9187 ok (!ret
, "bind() failed with error %d\n", GetLastError());
9188 set_blocking(sock
, FALSE
);
9190 memset(&overlapped
, 0, sizeof(overlapped
));
9191 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
9192 SetLastError(0xdeadbeef);
9193 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
9194 error
= GetLastError();
9195 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
9196 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
9198 CloseHandle(overlapped
.hEvent
);
9201 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
9202 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
9204 SetLastError(0xdeadbeef);
9205 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9206 ok (!ret
, "bind() failed with error %d\n", GetLastError());
9207 set_blocking(sock
, TRUE
);
9209 memset(&overlapped
, 0, sizeof(overlapped
));
9210 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
9211 SetLastError(0xdeadbeef);
9212 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
9213 error
= GetLastError();
9214 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
9215 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
9217 CloseHandle(overlapped
.hEvent
);
9220 /* When the socket is overlapped non-blocking and the list change is requested without
9221 * an overlapped structure the error will be different. */
9222 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
9223 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
9225 SetLastError(0xdeadbeef);
9226 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9227 ok (!ret
, "bind() failed with error %d\n", GetLastError());
9228 set_blocking(sock
, FALSE
);
9230 SetLastError(0xdeadbeef);
9231 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
9232 error
= GetLastError();
9233 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
9234 ok (error
== WSAEWOULDBLOCK
, "expected 10035, got %d\n", error
);
9236 io_port
= CreateIoCompletionPort( (HANDLE
)sock
, NULL
, 0, 0 );
9237 ok (io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9239 set_blocking(sock
, FALSE
);
9240 memset(&overlapped
, 0, sizeof(overlapped
));
9241 SetLastError(0xdeadbeef);
9242 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
9243 error
= GetLastError();
9244 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %u\n", error
);
9245 ok (error
== ERROR_IO_PENDING
, "expected ERROR_IO_PENDING got %u\n", error
);
9247 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9248 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 0 );
9249 ok(!bret
, "failed to get completion status %u\n", bret
);
9250 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9251 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9255 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9256 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 0 );
9257 ok(!bret
, "failed to get completion status %u\n", bret
);
9258 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %u\n", GetLastError());
9259 ok(olp
== &overlapped
, "Overlapped structure is at %p\n", olp
);
9261 CloseHandle(io_port
);
9263 /* Misuse of the API by using a blocking socket and not using an overlapped structure,
9264 * this leads to a hang forever. */
9267 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
9269 SetLastError(0xdeadbeef);
9270 bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9272 set_blocking(sock
, TRUE
);
9273 WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
9279 if (!winetest_interactive
)
9281 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
9285 /* Bind an overlapped socket to the first found network interface */
9286 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
9287 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
9288 sock2
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
9289 ok(sock2
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
9290 sock3
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
9291 ok(sock3
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
9293 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9294 ok(!ret
, "bind failed unexpectedly\n");
9295 ret
= bind(sock2
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9296 ok(!ret
, "bind failed unexpectedly\n");
9297 ret
= bind(sock3
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9298 ok(!ret
, "bind failed unexpectedly\n");
9300 set_blocking(sock2
, FALSE
);
9301 set_blocking(sock3
, FALSE
);
9303 /* Wait for address changes, request that the user connects/disconnects an interface */
9304 memset(&overlapped
, 0, sizeof(overlapped
));
9305 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
9306 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
9307 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
9308 ok(WSAGetLastError() == WSA_IO_PENDING
, "Expected pending last error, got %d\n", WSAGetLastError());
9310 ret
= WSAIoctl(sock2
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
9311 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
9312 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "Expected would block last error, got %d\n", WSAGetLastError());
9314 event2
= WSACreateEvent();
9315 event3
= WSACreateEvent();
9316 ret
= WSAEventSelect (sock2
, event2
, FD_ADDRESS_LIST_CHANGE
);
9317 ok(!ret
, "WSAEventSelect failed with %d\n", WSAGetLastError());
9318 /* sock3 did not request SIO_ADDRESS_LIST_CHANGE but it is trying to wait anyway */
9319 ret
= WSAEventSelect (sock3
, event3
, FD_ADDRESS_LIST_CHANGE
);
9320 ok(!ret
, "WSAEventSelect failed with %d\n", WSAGetLastError());
9322 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
9323 " change the ipv4 address of any of the local network interfaces (15 second timeout).\n");
9324 tick
= GetTickCount();
9325 ret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
9326 ok(ret
== WAIT_OBJECT_0
, "failed to get overlapped event %u\n", ret
);
9328 ret
= WaitForSingleObject(event2
, 500);
9330 ok(ret
== WAIT_OBJECT_0
, "failed to get change event %u\n", ret
);
9332 ret
= WaitForSingleObject(event3
, 500);
9333 ok(ret
== WAIT_TIMEOUT
, "unexpected change event\n");
9335 trace("Spent %d ms waiting.\n", GetTickCount() - tick
);
9337 WSACloseEvent(event2
);
9338 WSACloseEvent(event3
);
9345 static void test_synchronous_WSAIoctl(void)
9347 HANDLE previous_port
, io_port
;
9348 WSAOVERLAPPED overlapped
, *olp
;
9356 previous_port
= CreateIoCompletionPort( INVALID_HANDLE_VALUE
, NULL
, 0, 0 );
9357 ok( previous_port
!= NULL
, "failed to create completion port %u\n", GetLastError() );
9359 socket
= WSASocketW( AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
9360 ok( socket
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError() );
9362 io_port
= CreateIoCompletionPort( (HANDLE
)socket
, previous_port
, 0, 0 );
9363 ok( io_port
!= NULL
, "failed to create completion port %u\n", GetLastError() );
9366 memset( &overlapped
, 0, sizeof(overlapped
) );
9367 res
= WSAIoctl( socket
, FIONBIO
, &on
, sizeof(on
), NULL
, 0, &num_bytes
, &overlapped
, NULL
);
9368 ok( !res
, "WSAIoctl failed %d\n", WSAGetLastError() );
9370 ret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 10000 );
9371 ok( ret
, "failed to get completion status %u\n", GetLastError() );
9373 CloseHandle( io_port
);
9374 closesocket( socket
);
9375 CloseHandle( previous_port
);
9378 #define WM_ASYNCCOMPLETE (WM_USER + 100)
9379 static HWND
create_async_message_window(void)
9381 static const char class_name
[] = "ws2_32 async message window class";
9383 WNDCLASSEXA wndclass
;
9386 wndclass
.cbSize
= sizeof(wndclass
);
9387 wndclass
.style
= CS_HREDRAW
| CS_VREDRAW
;
9388 wndclass
.lpfnWndProc
= DefWindowProcA
;
9389 wndclass
.cbClsExtra
= 0;
9390 wndclass
.cbWndExtra
= 0;
9391 wndclass
.hInstance
= GetModuleHandleA(NULL
);
9392 wndclass
.hIcon
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
9393 wndclass
.hIconSm
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
9394 wndclass
.hCursor
= LoadCursorA(NULL
, (LPCSTR
)IDC_ARROW
);
9395 wndclass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
9396 wndclass
.lpszClassName
= class_name
;
9397 wndclass
.lpszMenuName
= NULL
;
9399 RegisterClassExA(&wndclass
);
9401 hWnd
= CreateWindowA(class_name
, "ws2_32 async message window", WS_OVERLAPPEDWINDOW
,
9402 0, 0, 500, 500, NULL
, NULL
, GetModuleHandleA(NULL
), NULL
);
9405 ok(0, "failed to create window: %u\n", GetLastError());
9412 static void wait_for_async_message(HWND hwnd
, HANDLE handle
)
9417 while ((ret
= GetMessageA(&msg
, 0, 0, 0)) &&
9418 !(msg
.hwnd
== hwnd
&& msg
.message
== WM_ASYNCCOMPLETE
))
9420 TranslateMessage(&msg
);
9421 DispatchMessageA(&msg
);
9424 ok(ret
, "did not expect WM_QUIT message\n");
9425 ok(msg
.wParam
== (WPARAM
)handle
, "expected wParam = %p, got %lx\n", handle
, msg
.wParam
);
9428 static void test_WSAAsyncGetServByPort(void)
9430 HWND hwnd
= create_async_message_window();
9432 char buffer
[MAXGETHOSTSTRUCT
];
9437 /* FIXME: The asynchronous window messages should be tested. */
9439 /* Parameters are not checked when initiating the asynchronous operation. */
9440 ret
= WSAAsyncGetServByPort(NULL
, 0, 0, NULL
, NULL
, 0);
9441 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
9443 ret
= WSAAsyncGetServByPort(hwnd
, WM_ASYNCCOMPLETE
, 0, NULL
, NULL
, 0);
9444 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
9445 wait_for_async_message(hwnd
, ret
);
9447 ret
= WSAAsyncGetServByPort(hwnd
, WM_ASYNCCOMPLETE
, htons(80), NULL
, NULL
, 0);
9448 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
9449 wait_for_async_message(hwnd
, ret
);
9451 ret
= WSAAsyncGetServByPort(hwnd
, WM_ASYNCCOMPLETE
, htons(80), NULL
, buffer
, MAXGETHOSTSTRUCT
);
9452 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
9453 wait_for_async_message(hwnd
, ret
);
9455 DestroyWindow(hwnd
);
9458 static void test_WSAAsyncGetServByName(void)
9460 HWND hwnd
= create_async_message_window();
9462 char buffer
[MAXGETHOSTSTRUCT
];
9467 /* FIXME: The asynchronous window messages should be tested. */
9469 /* Parameters are not checked when initiating the asynchronous operation. */
9470 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "", NULL
, NULL
, 0);
9471 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
9472 wait_for_async_message(hwnd
, ret
);
9474 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "", "", buffer
, MAXGETHOSTSTRUCT
);
9475 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
9476 wait_for_async_message(hwnd
, ret
);
9478 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "http", NULL
, NULL
, 0);
9479 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
9480 wait_for_async_message(hwnd
, ret
);
9482 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "http", "tcp", buffer
, MAXGETHOSTSTRUCT
);
9483 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
9484 wait_for_async_message(hwnd
, ret
);
9486 DestroyWindow(hwnd
);
9490 * Provide consistent initialization for the AcceptEx IOCP tests.
9492 static SOCKET
setup_iocp_src(struct sockaddr_in
*bindAddress
)
9494 SOCKET src
, ret
= INVALID_SOCKET
;
9497 src
= socket(AF_INET
, SOCK_STREAM
, 0);
9498 if (src
== INVALID_SOCKET
)
9500 skip("could not create listener socket, error %d\n", WSAGetLastError());
9504 memset(bindAddress
, 0, sizeof(*bindAddress
));
9505 bindAddress
->sin_family
= AF_INET
;
9506 bindAddress
->sin_addr
.s_addr
= inet_addr("127.0.0.1");
9507 iret
= bind(src
, (struct sockaddr
*)bindAddress
, sizeof(*bindAddress
));
9510 skip("failed to bind, error %d\n", WSAGetLastError());
9514 socklen
= sizeof(*bindAddress
);
9515 iret
= getsockname(src
, (struct sockaddr
*)bindAddress
, &socklen
);
9517 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
9521 if (set_blocking(src
, FALSE
))
9523 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
9527 iret
= listen(src
, 5);
9530 skip("listening failed, errno = %d\n", WSAGetLastError());
9536 if (src
!= ret
&& ret
== INVALID_SOCKET
)
9541 static void test_completion_port(void)
9543 HANDLE previous_port
, io_port
;
9544 WSAOVERLAPPED ov
, *olp
;
9545 SOCKET src
, dest
, dup
, connector
= INVALID_SOCKET
;
9546 WSAPROTOCOL_INFOA info
;
9549 DWORD num_bytes
, flags
;
9554 struct sockaddr_in bindAddress
;
9555 GUID acceptExGuid
= WSAID_ACCEPTEX
;
9556 LPFN_ACCEPTEX pAcceptEx
= NULL
;
9559 memset(buf
, 0, sizeof(buf
));
9560 previous_port
= CreateIoCompletionPort(INVALID_HANDLE_VALUE
, NULL
, 0, 0);
9561 ok( previous_port
!= NULL
, "Failed to create completion port %u\n", GetLastError());
9563 memset(&ov
, 0, sizeof(ov
));
9565 tcp_socketpair(&src
, &dest
);
9566 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
9568 skip("failed to create sockets\n");
9572 bufs
.len
= sizeof(buf
);
9578 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
9579 ok(!iret
, "Failed to set linger %d\n", GetLastError());
9581 io_port
= CreateIoCompletionPort( (HANDLE
)dest
, previous_port
, 125, 0 );
9582 ok(io_port
!= NULL
, "Failed to create completion port %u\n", GetLastError());
9584 SetLastError(0xdeadbeef);
9586 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
9587 ok(iret
== SOCKET_ERROR
, "WSARecv returned %d\n", iret
);
9588 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9593 src
= INVALID_SOCKET
;
9595 SetLastError(0xdeadbeef);
9597 num_bytes
= 0xdeadbeef;
9598 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9600 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9601 todo_wine
ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %d\n", bret
);
9602 todo_wine
ok(GetLastError() == ERROR_NETNAME_DELETED
, "Last error was %d\n", GetLastError());
9603 ok(key
== 125, "Key is %lu\n", key
);
9604 ok(num_bytes
== 0, "Number of bytes received is %u\n", num_bytes
);
9605 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9607 SetLastError(0xdeadbeef);
9609 num_bytes
= 0xdeadbeef;
9610 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9612 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9613 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %d\n", bret
);
9614 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9615 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9616 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9617 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9619 if (dest
!= INVALID_SOCKET
)
9622 memset(&ov
, 0, sizeof(ov
));
9624 tcp_socketpair(&src
, &dest
);
9625 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
9627 skip("failed to create sockets\n");
9631 bufs
.len
= sizeof(buf
);
9637 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
9638 ok(!iret
, "Failed to set linger %d\n", GetLastError());
9640 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 125, 0);
9641 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9643 set_blocking(dest
, FALSE
);
9646 src
= INVALID_SOCKET
;
9650 num_bytes
= 0xdeadbeef;
9651 SetLastError(0xdeadbeef);
9653 iret
= WSASend(dest
, &bufs
, 1, &num_bytes
, 0, &ov
, NULL
);
9654 ok(iret
== SOCKET_ERROR
, "WSASend failed - %d\n", iret
);
9655 ok(GetLastError() == WSAECONNRESET
, "Last error was %d\n", GetLastError());
9656 ok(num_bytes
== 0xdeadbeef, "Managed to send %d\n", num_bytes
);
9658 SetLastError(0xdeadbeef);
9660 num_bytes
= 0xdeadbeef;
9661 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9663 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9664 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
9665 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9666 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9667 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9668 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9670 if (dest
!= INVALID_SOCKET
)
9673 /* Test IOCP response on successful immediate read. */
9674 tcp_socketpair(&src
, &dest
);
9675 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
9677 skip("failed to create sockets\n");
9681 bufs
.len
= sizeof(buf
);
9684 SetLastError(0xdeadbeef);
9686 iret
= WSASend(src
, &bufs
, 1, &num_bytes
, 0, &ov
, NULL
);
9687 ok(!iret
, "WSASend failed - %d, last error %u\n", iret
, GetLastError());
9688 ok(num_bytes
== sizeof(buf
), "Managed to send %d\n", num_bytes
);
9690 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 125, 0);
9691 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9692 set_blocking(dest
, FALSE
);
9695 FD_SET(dest
, &fds_recv
);
9696 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
9698 num_bytes
= 0xdeadbeef;
9701 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
9702 ok(!iret
, "WSARecv failed - %d, last error %u\n", iret
, GetLastError());
9703 ok(num_bytes
== sizeof(buf
), "Managed to read %d\n", num_bytes
);
9705 SetLastError(0xdeadbeef);
9707 num_bytes
= 0xdeadbeef;
9708 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9710 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9711 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
9712 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9713 ok(key
== 125, "Key is %lu\n", key
);
9714 ok(num_bytes
== sizeof(buf
), "Number of bytes transferred is %u\n", num_bytes
);
9715 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9717 /* Test IOCP response on graceful shutdown. */
9721 FD_SET(dest
, &fds_recv
);
9722 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
9724 num_bytes
= 0xdeadbeef;
9726 memset(&ov
, 0, sizeof(ov
));
9728 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
9729 ok(!iret
, "WSARecv failed - %d, last error %u\n", iret
, GetLastError());
9730 ok(!num_bytes
, "Managed to read %d\n", num_bytes
);
9732 SetLastError(0xdeadbeef);
9734 num_bytes
= 0xdeadbeef;
9735 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9737 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9738 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
9739 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9740 ok(key
== 125, "Key is %lu\n", key
);
9741 ok(!num_bytes
, "Number of bytes transferred is %u\n", num_bytes
);
9742 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9745 src
= INVALID_SOCKET
;
9747 dest
= INVALID_SOCKET
;
9749 /* Test IOCP response on hard shutdown. This was the condition that triggered
9750 * a crash in an actual app (bug 38980). */
9751 tcp_socketpair(&src
, &dest
);
9752 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
9754 skip("failed to create sockets\n");
9758 bufs
.len
= sizeof(buf
);
9761 memset(&ov
, 0, sizeof(ov
));
9765 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
9766 ok(!iret
, "Failed to set linger %d\n", GetLastError());
9768 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 125, 0);
9769 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9770 set_blocking(dest
, FALSE
);
9773 src
= INVALID_SOCKET
;
9776 FD_SET(dest
, &fds_recv
);
9777 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
9779 num_bytes
= 0xdeadbeef;
9780 SetLastError(0xdeadbeef);
9782 /* Somehow a hard shutdown doesn't work on my Linux box. It seems SO_LINGER is ignored. */
9783 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
9784 todo_wine
ok(iret
== SOCKET_ERROR
, "WSARecv failed - %d\n", iret
);
9785 todo_wine
ok(GetLastError() == WSAECONNRESET
, "Last error was %d\n", GetLastError());
9786 todo_wine
ok(num_bytes
== 0xdeadbeef, "Managed to read %d\n", num_bytes
);
9788 SetLastError(0xdeadbeef);
9790 num_bytes
= 0xdeadbeef;
9791 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9793 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9794 todo_wine
ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
9795 todo_wine
ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9796 todo_wine
ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9797 todo_wine
ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9798 todo_wine
ok(!olp
, "Overlapped structure is at %p\n", olp
);
9802 /* Test reading from a non-connected socket, mostly because the above test is marked todo. */
9803 dest
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9804 ok(dest
!= INVALID_SOCKET
, "socket() failed\n");
9806 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 125, 0);
9807 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9808 set_blocking(dest
, FALSE
);
9810 num_bytes
= 0xdeadbeef;
9811 SetLastError(0xdeadbeef);
9812 memset(&ov
, 0, sizeof(ov
));
9814 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
9815 ok(iret
== SOCKET_ERROR
, "WSARecv failed - %d\n", iret
);
9816 ok(GetLastError() == WSAENOTCONN
, "Last error was %d\n", GetLastError());
9817 ok(num_bytes
== 0xdeadbeef, "Managed to read %d\n", num_bytes
);
9819 SetLastError(0xdeadbeef);
9821 num_bytes
= 0xdeadbeef;
9822 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9824 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9825 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
9826 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9827 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9828 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9829 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9831 num_bytes
= 0xdeadbeef;
9834 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
9835 if (dest
== INVALID_SOCKET
)
9837 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
9841 iret
= WSAIoctl(dest
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
9842 &pAcceptEx
, sizeof(pAcceptEx
), &num_bytes
, NULL
, NULL
);
9845 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret
, WSAGetLastError());
9849 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
9851 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
9854 SetLastError(0xdeadbeef);
9856 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
9857 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9859 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
9860 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9862 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
9863 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9866 src
= INVALID_SOCKET
;
9868 SetLastError(0xdeadbeef);
9870 num_bytes
= 0xdeadbeef;
9871 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9873 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9874 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9875 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
9876 ok(key
== 125, "Key is %lu\n", key
);
9877 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
9878 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9879 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
9881 SetLastError(0xdeadbeef);
9883 num_bytes
= 0xdeadbeef;
9884 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9885 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9886 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9887 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9888 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9889 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9890 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9892 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
9894 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
9897 SetLastError(0xdeadbeef);
9899 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
9900 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9902 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
9903 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9905 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
9906 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9909 src
= INVALID_SOCKET
;
9911 SetLastError(0xdeadbeef);
9913 num_bytes
= 0xdeadbeef;
9914 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9916 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9917 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9918 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
9919 ok(key
== 125, "Key is %lu\n", key
);
9920 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
9921 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9922 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
9924 SetLastError(0xdeadbeef);
9926 num_bytes
= 0xdeadbeef;
9927 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9928 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9929 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9930 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9931 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9932 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9933 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9935 /* Test IOCP with duplicated handle */
9937 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
9940 SetLastError(0xdeadbeef);
9942 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
9943 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9945 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
9946 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
9947 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
9949 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
9950 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9952 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
9953 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9955 SetLastError(0xdeadbeef);
9957 num_bytes
= 0xdeadbeef;
9958 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9959 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9960 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9961 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9962 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9963 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9964 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9967 src
= INVALID_SOCKET
;
9969 dup
= INVALID_SOCKET
;
9971 SetLastError(0xdeadbeef);
9973 num_bytes
= 0xdeadbeef;
9974 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9975 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9976 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9977 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
9978 ok(key
== 125, "Key is %lu\n", key
);
9979 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
9980 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9981 ok(olp
&& olp
->Internal
== (ULONG
)STATUS_CANCELLED
, "Internal status is %lx\n", olp
? olp
->Internal
: 0);
9983 SetLastError(0xdeadbeef);
9985 num_bytes
= 0xdeadbeef;
9986 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9987 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9988 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9989 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9990 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9991 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9992 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9994 /* Test IOCP with duplicated handle (closing duplicated handle) */
9996 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
9999 SetLastError(0xdeadbeef);
10001 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
10002 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
10004 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
10005 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
10006 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
10008 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
10009 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
10011 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
10012 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
10015 dup
= INVALID_SOCKET
;
10017 SetLastError(0xdeadbeef);
10019 num_bytes
= 0xdeadbeef;
10020 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10021 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10022 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10023 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
10024 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
10025 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
10026 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10028 SetLastError(0xdeadbeef);
10030 num_bytes
= 0xdeadbeef;
10031 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10032 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10033 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10034 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
10035 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
10036 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
10037 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10040 src
= INVALID_SOCKET
;
10042 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
10043 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10044 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
10045 ok(key
== 125, "Key is %lu\n", key
);
10046 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
10047 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
10048 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
10050 SetLastError(0xdeadbeef);
10052 num_bytes
= 0xdeadbeef;
10053 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10054 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10055 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10056 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
10057 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
10058 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
10059 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10061 /* Test IOCP with duplicated handle (closing original handle) */
10063 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
10066 SetLastError(0xdeadbeef);
10068 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
10069 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
10071 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
10072 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
10073 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
10075 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
10076 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
10078 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
10079 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
10082 src
= INVALID_SOCKET
;
10084 SetLastError(0xdeadbeef);
10086 num_bytes
= 0xdeadbeef;
10087 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10088 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10089 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10090 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
10091 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
10092 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
10093 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10096 dup
= INVALID_SOCKET
;
10098 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
10099 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10100 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
10101 ok(key
== 125, "Key is %lu\n", key
);
10102 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
10103 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
10104 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
10106 SetLastError(0xdeadbeef);
10108 num_bytes
= 0xdeadbeef;
10109 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10110 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10111 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10112 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
10113 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
10114 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
10115 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10117 /* Test IOCP without AcceptEx */
10119 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
10122 SetLastError(0xdeadbeef);
10124 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
10125 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
10128 src
= INVALID_SOCKET
;
10130 SetLastError(0xdeadbeef);
10132 num_bytes
= 0xdeadbeef;
10133 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10134 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10135 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10136 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
10137 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
10138 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
10139 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10143 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
10146 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
10147 if (connector
== INVALID_SOCKET
) {
10148 skip("could not create connector socket, error %d\n", WSAGetLastError());
10152 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
10153 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
10155 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 236, 0);
10156 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
10158 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
10159 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
10161 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
10162 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
10164 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
10165 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
10167 closesocket(connector
);
10168 connector
= INVALID_SOCKET
;
10170 SetLastError(0xdeadbeef);
10172 num_bytes
= 0xdeadbeef;
10173 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10175 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
10176 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
10177 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
10178 ok(key
== 125, "Key is %lu\n", key
);
10179 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
10180 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
10181 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
10183 SetLastError(0xdeadbeef);
10185 num_bytes
= 0xdeadbeef;
10186 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10187 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10188 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10189 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
10190 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
10191 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
10192 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10194 if (dest
!= INVALID_SOCKET
)
10196 if (src
!= INVALID_SOCKET
)
10201 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
10204 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
10205 if (dest
== INVALID_SOCKET
)
10207 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
10211 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
10212 if (connector
== INVALID_SOCKET
) {
10213 skip("could not create connector socket, error %d\n", WSAGetLastError());
10217 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
10218 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
10220 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 236, 0);
10221 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
10223 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
10224 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
10226 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
10227 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
10229 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
10230 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
10232 iret
= send(connector
, buf
, 1, 0);
10233 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
10238 dest
= INVALID_SOCKET
;
10240 SetLastError(0xdeadbeef);
10242 num_bytes
= 0xdeadbeef;
10243 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10245 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
10246 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
10247 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
10248 ok(key
== 125, "Key is %lu\n", key
);
10249 ok(num_bytes
== 1, "Number of bytes transferred is %u\n", num_bytes
);
10250 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
10251 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
10253 SetLastError(0xdeadbeef);
10255 num_bytes
= 0xdeadbeef;
10256 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10257 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10258 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10259 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
10260 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
10261 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
10262 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10264 if (src
!= INVALID_SOCKET
)
10266 if (connector
!= INVALID_SOCKET
)
10267 closesocket(connector
);
10271 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
10274 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
10275 if (dest
== INVALID_SOCKET
)
10277 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
10281 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
10282 if (connector
== INVALID_SOCKET
) {
10283 skip("could not create connector socket, error %d\n", WSAGetLastError());
10287 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
10288 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
10290 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 236, 0);
10291 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
10293 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
10294 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
10296 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
10297 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
10299 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
10300 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
10303 dest
= INVALID_SOCKET
;
10305 SetLastError(0xdeadbeef);
10307 num_bytes
= 0xdeadbeef;
10308 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10310 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
10311 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10312 todo_wine
ok(GetLastError() == ERROR_NETNAME_DELETED
||
10313 GetLastError() == ERROR_OPERATION_ABORTED
||
10314 GetLastError() == ERROR_CONNECTION_ABORTED
||
10315 GetLastError() == ERROR_PIPE_NOT_CONNECTED
/* win 2000 */,
10316 "Last error was %d\n", GetLastError());
10317 ok(key
== 125, "Key is %lu\n", key
);
10318 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
10319 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
10320 todo_wine
ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_LOCAL_DISCONNECT
||
10321 olp
->Internal
== (ULONG
)STATUS_CANCELLED
||
10322 olp
->Internal
== (ULONG
)STATUS_CONNECTION_ABORTED
||
10323 olp
->Internal
== (ULONG
)STATUS_PIPE_DISCONNECTED
/* win 2000 */),
10324 "Internal status is %lx\n", olp
? olp
->Internal
: 0);
10326 SetLastError(0xdeadbeef);
10328 num_bytes
= 0xdeadbeef;
10329 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10330 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10331 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10332 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
10333 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
10334 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
10335 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10339 if (dest
!= INVALID_SOCKET
)
10341 if (src
!= INVALID_SOCKET
)
10343 if (connector
!= INVALID_SOCKET
)
10344 closesocket(connector
);
10345 CloseHandle(previous_port
);
10348 static void test_address_list_query(void)
10350 SOCKET_ADDRESS_LIST
*address_list
;
10351 DWORD bytes_returned
, size
;
10356 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
10357 ok(s
!= INVALID_SOCKET
, "Failed to create socket, error %d.\n", WSAGetLastError());
10359 bytes_returned
= 0;
10360 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, NULL
, 0, &bytes_returned
, NULL
, NULL
);
10361 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
10362 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
10363 ok(bytes_returned
>= FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[0]),
10364 "Got unexpected bytes_returned %u.\n", bytes_returned
);
10366 size
= bytes_returned
;
10367 bytes_returned
= 0;
10368 address_list
= HeapAlloc(GetProcessHeap(), 0, size
* 2);
10369 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, address_list
, size
* 2, &bytes_returned
, NULL
, NULL
);
10370 ok(!ret
, "Got unexpected ret %d, error %d.\n", ret
, WSAGetLastError());
10371 ok(bytes_returned
== size
, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned
, size
);
10373 bytes_returned
= FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[address_list
->iAddressCount
]);
10374 for (i
= 0; i
< address_list
->iAddressCount
; ++i
)
10376 bytes_returned
+= address_list
->Address
[i
].iSockaddrLength
;
10378 ok(size
== bytes_returned
, "Got unexpected size %u, expected %u.\n", size
, bytes_returned
);
10380 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, address_list
, size
, NULL
, NULL
, NULL
);
10381 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
10382 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
10384 bytes_returned
= 0xdeadbeef;
10385 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, NULL
, size
, &bytes_returned
, NULL
, NULL
);
10386 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
10387 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
10388 ok(bytes_returned
== size
, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned
, size
);
10390 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, address_list
, 1, &bytes_returned
, NULL
, NULL
);
10391 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
10392 ok(WSAGetLastError() == WSAEINVAL
, "Got unexpected error %d.\n", WSAGetLastError());
10393 ok(bytes_returned
== 0, "Got unexpected bytes_returned %u.\n", bytes_returned
);
10395 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, address_list
,
10396 FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[0]), &bytes_returned
, NULL
, NULL
);
10397 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
10398 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
10399 ok(bytes_returned
== size
, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned
, size
);
10401 HeapFree(GetProcessHeap(), 0, address_list
);
10405 static DWORD WINAPI
inet_ntoa_thread_proc(void *param
)
10409 HANDLE
*event
= param
;
10411 addr
= inet_addr("4.3.2.1");
10412 ok(addr
== htonl(0x04030201), "expected 0x04030201, got %08x\n", addr
);
10413 str
= inet_ntoa(*(struct in_addr
*)&addr
);
10414 ok(!strcmp(str
, "4.3.2.1"), "expected 4.3.2.1, got %s\n", str
);
10416 SetEvent(event
[0]);
10417 WaitForSingleObject(event
[1], 3000);
10422 static void test_inet_ntoa(void)
10426 HANDLE thread
, event
[2];
10429 addr
= inet_addr("1.2.3.4");
10430 ok(addr
== htonl(0x01020304), "expected 0x01020304, got %08x\n", addr
);
10431 str
= inet_ntoa(*(struct in_addr
*)&addr
);
10432 ok(!strcmp(str
, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str
);
10434 event
[0] = CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
10435 event
[1] = CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
10437 thread
= CreateThread(NULL
, 0, inet_ntoa_thread_proc
, event
, 0, &tid
);
10438 WaitForSingleObject(event
[0], 3000);
10440 ok(!strcmp(str
, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str
);
10442 SetEvent(event
[1]);
10443 WaitForSingleObject(thread
, 3000);
10445 CloseHandle(event
[0]);
10446 CloseHandle(event
[1]);
10447 CloseHandle(thread
);
10450 static void test_WSALookupService(void)
10452 char buffer
[4096], strbuff
[128];
10453 WSAQUERYSETW
*qs
= NULL
;
10457 DWORD error
, offset
, bsize
;
10459 if (!pWSALookupServiceBeginW
|| !pWSALookupServiceEnd
|| !pWSALookupServiceNextW
)
10461 win_skip("WSALookupServiceBeginW or WSALookupServiceEnd or WSALookupServiceNextW not found\n");
10465 qs
= (WSAQUERYSETW
*)buffer
;
10466 memset(qs
, 0, sizeof(*qs
));
10468 /* invalid parameter tests */
10469 ret
= pWSALookupServiceBeginW(NULL
, 0, &hnd
);
10470 error
= WSAGetLastError();
10471 ok(ret
== SOCKET_ERROR
, "WSALookupServiceBeginW should have failed\n");
10473 ok(error
== WSAEFAULT
, "expected 10014, got %d\n", error
);
10475 ret
= pWSALookupServiceBeginW(qs
, 0, NULL
);
10476 error
= WSAGetLastError();
10477 ok(ret
== SOCKET_ERROR
, "WSALookupServiceBeginW should have failed\n");
10479 ok(error
== WSAEFAULT
, "expected 10014, got %d\n", error
);
10481 ret
= pWSALookupServiceBeginW(qs
, 0, &hnd
);
10482 error
= WSAGetLastError();
10483 ok(ret
== SOCKET_ERROR
, "WSALookupServiceBeginW should have failed\n");
10485 ok(error
== WSAEINVAL
10486 || broken(error
== ERROR_INVALID_PARAMETER
) /* == XP */
10487 || broken(error
== WSAEFAULT
) /* == NT */
10488 || broken(error
== WSASERVICE_NOT_FOUND
) /* == 2000 */,
10489 "expected 10022, got %d\n", error
);
10491 ret
= pWSALookupServiceEnd(NULL
);
10492 error
= WSAGetLastError();
10494 ok(ret
== SOCKET_ERROR
, "WSALookupServiceEnd should have failed\n");
10496 ok(error
== ERROR_INVALID_HANDLE
, "expected 6, got %d\n", error
);
10498 /* standard network list query */
10499 qs
->dwSize
= sizeof(*qs
);
10500 hnd
= (HANDLE
)0xdeadbeef;
10501 ret
= pWSALookupServiceBeginW(qs
, LUP_RETURN_ALL
| LUP_DEEP
, &hnd
);
10502 error
= WSAGetLastError();
10503 if(ret
&& error
== ERROR_INVALID_PARAMETER
)
10505 win_skip("the current WSALookupServiceBeginW test is not supported in win <= 2000\n");
10510 ok(!ret
, "WSALookupServiceBeginW failed unexpectedly with error %d\n", error
);
10512 ok(hnd
!= (HANDLE
)0xdeadbeef, "Handle was not filled\n");
10517 memset(qs
, 0, sizeof(*qs
));
10518 bsize
= sizeof(buffer
);
10520 if (pWSALookupServiceNextW(hnd
, 0, &bsize
, qs
) == SOCKET_ERROR
)
10522 error
= WSAGetLastError();
10523 if (error
== WSA_E_NO_MORE
) break;
10524 ok(0, "Error %d happened while listing services\n", error
);
10528 WideCharToMultiByte(CP_ACP
, 0, qs
->lpszServiceInstanceName
, -1,
10529 strbuff
, sizeof(strbuff
), NULL
, NULL
);
10530 trace("Network Name: %s\n", strbuff
);
10532 /* network data is written in the blob field */
10535 /* each network may have multiple NLA_BLOB information structures */
10538 netdata
= (PNLA_BLOB
) &qs
->lpBlob
->pBlobData
[offset
];
10539 switch (netdata
->header
.type
)
10542 trace("\tNLA Data Type: NLA_RAW_DATA\n");
10544 case NLA_INTERFACE
:
10545 trace("\tNLA Data Type: NLA_INTERFACE\n");
10546 trace("\t\tType: %d\n", netdata
->data
.interfaceData
.dwType
);
10547 trace("\t\tSpeed: %d\n", netdata
->data
.interfaceData
.dwSpeed
);
10548 trace("\t\tAdapter Name: %s\n", netdata
->data
.interfaceData
.adapterName
);
10550 case NLA_802_1X_LOCATION
:
10551 trace("\tNLA Data Type: NLA_802_1X_LOCATION\n");
10552 trace("\t\tInformation: %s\n", netdata
->data
.locationData
.information
);
10554 case NLA_CONNECTIVITY
:
10555 switch (netdata
->data
.connectivity
.type
)
10557 case NLA_NETWORK_AD_HOC
:
10558 trace("\t\tNetwork Type: AD HOC\n");
10560 case NLA_NETWORK_MANAGED
:
10561 trace("\t\tNetwork Type: Managed\n");
10563 case NLA_NETWORK_UNMANAGED
:
10564 trace("\t\tNetwork Type: Unmanaged\n");
10566 case NLA_NETWORK_UNKNOWN
:
10567 trace("\t\tNetwork Type: Unknown\n");
10569 switch (netdata
->data
.connectivity
.internet
)
10571 case NLA_INTERNET_NO
:
10572 trace("\t\tInternet connectivity: No\n");
10574 case NLA_INTERNET_YES
:
10575 trace("\t\tInternet connectivity: Yes\n");
10577 case NLA_INTERNET_UNKNOWN
:
10578 trace("\t\tInternet connectivity: Unknown\n");
10583 trace("\tNLA Data Type: NLA_ICS\n");
10584 trace("\t\tSpeed: %d\n",
10585 netdata
->data
.ICS
.remote
.speed
);
10586 trace("\t\tType: %d\n",
10587 netdata
->data
.ICS
.remote
.type
);
10588 trace("\t\tState: %d\n",
10589 netdata
->data
.ICS
.remote
.state
);
10590 WideCharToMultiByte(CP_ACP
, 0, netdata
->data
.ICS
.remote
.machineName
, -1,
10591 strbuff
, sizeof(strbuff
), NULL
, NULL
);
10592 trace("\t\tMachine Name: %s\n", strbuff
);
10593 WideCharToMultiByte(CP_ACP
, 0, netdata
->data
.ICS
.remote
.sharedAdapterName
, -1,
10594 strbuff
, sizeof(strbuff
), NULL
, NULL
);
10595 trace("\t\tShared Adapter Name: %s\n", strbuff
);
10598 trace("\tNLA Data Type: Unknown\n");
10607 ret
= pWSALookupServiceEnd(hnd
);
10608 ok(!ret
, "WSALookupServiceEnd failed unexpectedly\n");
10611 static void test_WSAEnumNameSpaceProvidersA(void)
10613 LPWSANAMESPACE_INFOA name
= NULL
;
10614 DWORD ret
, error
, blen
= 0, i
;
10615 if (!pWSAEnumNameSpaceProvidersA
)
10617 win_skip("WSAEnumNameSpaceProvidersA not found\n");
10621 SetLastError(0xdeadbeef);
10622 ret
= pWSAEnumNameSpaceProvidersA(&blen
, name
);
10623 error
= WSAGetLastError();
10625 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
10627 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
10629 /* Invalid parameter tests */
10630 SetLastError(0xdeadbeef);
10631 ret
= pWSAEnumNameSpaceProvidersA(NULL
, name
);
10632 error
= WSAGetLastError();
10634 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
10636 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
10638 SetLastError(0xdeadbeef);
10639 ret
= pWSAEnumNameSpaceProvidersA(NULL
, NULL
);
10640 error
= WSAGetLastError();
10642 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
10644 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
10646 SetLastError(0xdeadbeef);
10647 ret
= pWSAEnumNameSpaceProvidersA(&blen
, NULL
);
10648 error
= WSAGetLastError();
10650 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
10652 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
10654 name
= HeapAlloc(GetProcessHeap(), 0, blen
);
10657 skip("Failed to alloc memory\n");
10661 ret
= pWSAEnumNameSpaceProvidersA(&blen
, name
);
10663 ok(ret
> 0, "Expected more than zero name space providers\n");
10665 for (i
= 0;i
< ret
; i
++)
10667 trace("Name space Identifier (%p): %s\n", name
[i
].lpszIdentifier
,
10668 name
[i
].lpszIdentifier
);
10669 switch (name
[i
].dwNameSpace
)
10672 trace("\tName space ID: NS_DNS (%u)\n", name
[i
].dwNameSpace
);
10675 trace("\tName space ID: NS_NLA (%u)\n", name
[i
].dwNameSpace
);
10678 trace("\tName space ID: Unknown (%u)\n", name
[i
].dwNameSpace
);
10681 trace("\tActive: %d\n", name
[i
].fActive
);
10682 trace("\tVersion: %d\n", name
[i
].dwVersion
);
10685 HeapFree(GetProcessHeap(), 0, name
);
10688 static void test_WSAEnumNameSpaceProvidersW(void)
10690 LPWSANAMESPACE_INFOW name
= NULL
;
10691 DWORD ret
, error
, blen
= 0, i
;
10692 if (!pWSAEnumNameSpaceProvidersW
)
10694 win_skip("WSAEnumNameSpaceProvidersW not found\n");
10698 SetLastError(0xdeadbeef);
10699 ret
= pWSAEnumNameSpaceProvidersW(&blen
, name
);
10700 error
= WSAGetLastError();
10702 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
10704 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
10706 /* Invalid parameter tests */
10707 SetLastError(0xdeadbeef);
10708 ret
= pWSAEnumNameSpaceProvidersW(NULL
, name
);
10709 error
= WSAGetLastError();
10711 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
10713 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
10715 SetLastError(0xdeadbeef);
10716 ret
= pWSAEnumNameSpaceProvidersW(NULL
, NULL
);
10717 error
= WSAGetLastError();
10719 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
10721 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
10723 SetLastError(0xdeadbeef);
10724 ret
= pWSAEnumNameSpaceProvidersW(&blen
, NULL
);
10725 error
= WSAGetLastError();
10727 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
10729 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
10731 name
= HeapAlloc(GetProcessHeap(), 0, blen
);
10734 skip("Failed to alloc memory\n");
10738 ret
= pWSAEnumNameSpaceProvidersW(&blen
, name
);
10740 ok(ret
> 0, "Expected more than zero name space providers\n");
10742 for (i
= 0;i
< ret
; i
++)
10744 trace("Name space Identifier (%p): %s\n", name
[i
].lpszIdentifier
,
10745 wine_dbgstr_w(name
[i
].lpszIdentifier
));
10746 switch (name
[i
].dwNameSpace
)
10749 trace("\tName space ID: NS_DNS (%u)\n", name
[i
].dwNameSpace
);
10752 trace("\tName space ID: NS_NLA (%u)\n", name
[i
].dwNameSpace
);
10755 trace("\tName space ID: Unknown (%u)\n", name
[i
].dwNameSpace
);
10758 trace("\tActive: %d\n", name
[i
].fActive
);
10759 trace("\tVersion: %d\n", name
[i
].dwVersion
);
10762 HeapFree(GetProcessHeap(), 0, name
);
10765 static void sync_read(SOCKET src
, SOCKET dst
)
10770 ret
= send(dst
, "Hello World!", 12, 0);
10771 ok(ret
== 12, "send returned %d\n", ret
);
10773 memset(data
, 0, sizeof(data
));
10774 ret
= recv(src
, data
, sizeof(data
), 0);
10775 ok(ret
== 12, "expected 12, got %d\n", ret
);
10776 ok(!memcmp(data
, "Hello World!", 12), "got %u bytes (%*s)\n", ret
, ret
, data
);
10779 static void iocp_async_read(SOCKET src
, SOCKET dst
)
10782 WSAOVERLAPPED ovl
, *ovl_iocp
;
10786 DWORD flags
, bytes
;
10789 memset(data
, 0, sizeof(data
));
10790 memset(&ovl
, 0, sizeof(ovl
));
10792 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
10793 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
10795 buf
.len
= sizeof(data
);
10797 bytes
= 0xdeadbeef;
10799 SetLastError(0xdeadbeef);
10800 ret
= WSARecv(src
, &buf
, 1, &bytes
, &flags
, &ovl
, NULL
);
10801 ok(ret
== SOCKET_ERROR
, "got %d\n", ret
);
10802 ok(GetLastError() == ERROR_IO_PENDING
, "got %u\n", GetLastError());
10803 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
10805 bytes
= 0xdeadbeef;
10807 ovl_iocp
= (void *)0xdeadbeef;
10808 SetLastError(0xdeadbeef);
10809 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10810 ok(!ret
, "got %d\n", ret
);
10811 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
10812 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
10813 ok(key
== 0xdeadbeef, "got key %#lx\n", key
);
10814 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
10816 ret
= send(dst
, "Hello World!", 12, 0);
10817 ok(ret
== 12, "send returned %d\n", ret
);
10819 bytes
= 0xdeadbeef;
10822 SetLastError(0xdeadbeef);
10823 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10824 ok(ret
, "got %d\n", ret
);
10825 ok(bytes
== 12, "got bytes %u\n", bytes
);
10826 ok(key
== 0x12345678, "got key %#lx\n", key
);
10827 ok(ovl_iocp
== &ovl
, "got ovl %p\n", ovl_iocp
);
10830 ok(ovl_iocp
->InternalHigh
== 12, "got %#lx\n", ovl_iocp
->InternalHigh
);
10831 ok(!ovl_iocp
->Internal
, "got %#lx\n", ovl_iocp
->Internal
);
10832 ok(!memcmp(data
, "Hello World!", 12), "got %u bytes (%*s)\n", bytes
, bytes
, data
);
10835 bytes
= 0xdeadbeef;
10837 ovl_iocp
= (void *)0xdeadbeef;
10838 SetLastError(0xdeadbeef);
10839 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10840 ok(!ret
, "got %d\n", ret
);
10841 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
10842 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
10843 ok(key
== 0xdeadbeef, "got key %#lx\n", key
);
10844 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
10849 static void iocp_async_read_closesocket(SOCKET src
, int how_to_close
)
10852 WSAOVERLAPPED ovl
, *ovl_iocp
;
10856 DWORD flags
, bytes
;
10861 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
10862 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
10863 ok(hwnd
!= 0, "CreateWindowEx failed\n");
10865 ret
= WSAAsyncSelect(src
, hwnd
, WM_SOCKET
, FD_READ
| FD_WRITE
| FD_OOB
| FD_ACCEPT
| FD_CONNECT
| FD_CLOSE
);
10866 ok(!ret
, "got %d\n", ret
);
10869 memset(&msg
, 0, sizeof(msg
));
10870 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10871 ok(ret
, "got %d\n", ret
);
10872 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
10873 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
10874 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
10875 ok(msg
.lParam
== 2, "got %08lx\n", msg
.lParam
);
10877 memset(data
, 0, sizeof(data
));
10878 memset(&ovl
, 0, sizeof(ovl
));
10880 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
10881 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
10884 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10885 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10887 buf
.len
= sizeof(data
);
10889 bytes
= 0xdeadbeef;
10891 SetLastError(0xdeadbeef);
10892 ret
= WSARecv(src
, &buf
, 1, &bytes
, &flags
, &ovl
, NULL
);
10893 ok(ret
== SOCKET_ERROR
, "got %d\n", ret
);
10894 ok(GetLastError() == ERROR_IO_PENDING
, "got %u\n", GetLastError());
10895 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
10898 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10899 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10901 bytes
= 0xdeadbeef;
10903 ovl_iocp
= (void *)0xdeadbeef;
10904 SetLastError(0xdeadbeef);
10905 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10906 ok(!ret
, "got %d\n", ret
);
10907 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
10908 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
10909 ok(key
== 0xdeadbeef, "got key %#lx\n", key
);
10910 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
10913 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10914 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10916 switch (how_to_close
)
10922 CloseHandle((HANDLE
)src
);
10925 pNtClose((HANDLE
)src
);
10928 ok(0, "wrong value %d\n", how_to_close
);
10933 memset(&msg
, 0, sizeof(msg
));
10934 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10935 switch (how_to_close
)
10938 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10944 ok(ret
, "got %d\n", ret
);
10945 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
10946 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
10947 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
10948 ok(msg
.lParam
== 0x20, "got %08lx\n", msg
.lParam
);
10952 ok(0, "wrong value %d\n", how_to_close
);
10956 bytes
= 0xdeadbeef;
10959 SetLastError(0xdeadbeef);
10960 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10961 ok(!ret
, "got %d\n", ret
);
10963 ok(GetLastError() == ERROR_CONNECTION_ABORTED
|| GetLastError() == ERROR_NETNAME_DELETED
/* XP */, "got %u\n", GetLastError());
10964 ok(!bytes
, "got bytes %u\n", bytes
);
10965 ok(key
== 0x12345678, "got key %#lx\n", key
);
10966 ok(ovl_iocp
== &ovl
, "got ovl %p\n", ovl_iocp
);
10969 ok(!ovl_iocp
->InternalHigh
, "got %#lx\n", ovl_iocp
->InternalHigh
);
10971 ok(ovl_iocp
->Internal
== (ULONG
)STATUS_CONNECTION_ABORTED
|| ovl_iocp
->Internal
== (ULONG
)STATUS_LOCAL_DISCONNECT
/* XP */, "got %#lx\n", ovl_iocp
->Internal
);
10974 bytes
= 0xdeadbeef;
10976 ovl_iocp
= (void *)0xdeadbeef;
10977 SetLastError(0xdeadbeef);
10978 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10979 ok(!ret
, "got %d\n", ret
);
10980 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
10981 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
10982 ok(key
== 0xdeadbeef, "got key %#lx\n", key
);
10983 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
10987 DestroyWindow(hwnd
);
10990 static void iocp_async_closesocket(SOCKET src
)
10993 WSAOVERLAPPED
*ovl_iocp
;
11000 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
11001 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
11002 ok(hwnd
!= 0, "CreateWindowEx failed\n");
11004 ret
= WSAAsyncSelect(src
, hwnd
, WM_SOCKET
, FD_READ
| FD_WRITE
| FD_OOB
| FD_ACCEPT
| FD_CONNECT
| FD_CLOSE
);
11005 ok(!ret
, "got %d\n", ret
);
11008 memset(&msg
, 0, sizeof(msg
));
11009 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11010 ok(ret
, "got %d\n", ret
);
11011 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
11012 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
11013 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
11014 ok(msg
.lParam
== 2, "got %08lx\n", msg
.lParam
);
11016 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
11017 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
11020 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11021 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
11023 bytes
= 0xdeadbeef;
11025 ovl_iocp
= (void *)0xdeadbeef;
11026 SetLastError(0xdeadbeef);
11027 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
11028 ok(!ret
, "got %d\n", ret
);
11029 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
11030 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
11031 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
11032 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
11035 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11036 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
11041 memset(&msg
, 0, sizeof(msg
));
11042 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11043 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
11045 bytes
= 0xdeadbeef;
11047 ovl_iocp
= (void *)0xdeadbeef;
11048 SetLastError(0xdeadbeef);
11049 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
11050 ok(!ret
, "got %d\n", ret
);
11051 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
11052 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
11053 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
11054 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
11058 DestroyWindow(hwnd
);
11061 struct wsa_async_select_info
11067 static DWORD WINAPI
wsa_async_select_thread(void *param
)
11069 struct wsa_async_select_info
*info
= param
;
11072 ret
= WSAAsyncSelect(info
->sock
, info
->hwnd
, WM_SOCKET
, FD_READ
| FD_WRITE
| FD_OOB
| FD_ACCEPT
| FD_CONNECT
| FD_CLOSE
);
11073 ok(!ret
, "got %d\n", ret
);
11078 struct wsa_recv_info
11085 static DWORD WINAPI
wsa_recv_thread(void *param
)
11087 struct wsa_recv_info
*info
= param
;
11089 DWORD flags
, bytes
;
11091 bytes
= 0xdeadbeef;
11093 SetLastError(0xdeadbeef);
11094 ret
= WSARecv(info
->sock
, &info
->wsa_buf
, 1, &bytes
, &flags
, &info
->ovl
, NULL
);
11095 ok(ret
== SOCKET_ERROR
, "got %d\n", ret
);
11096 ok(GetLastError() == ERROR_IO_PENDING
, "got %u\n", GetLastError());
11097 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
11102 static void iocp_async_read_thread_closesocket(SOCKET src
)
11104 struct wsa_async_select_info select_info
;
11105 struct wsa_recv_info recv_info
;
11106 HANDLE port
, thread
;
11107 WSAOVERLAPPED
*ovl_iocp
;
11115 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
11116 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
11117 ok(hwnd
!= 0, "CreateWindowEx failed\n");
11119 select_info
.sock
= src
;
11120 select_info
.hwnd
= hwnd
;
11121 thread
= CreateThread(NULL
, 0, wsa_async_select_thread
, &select_info
, 0, &tid
);
11122 ok(thread
!= 0, "CreateThread error %u\n", GetLastError());
11123 ret
= WaitForSingleObject(thread
, 10000);
11124 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
11127 memset(&msg
, 0, sizeof(msg
));
11128 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11129 ok(ret
, "got %d\n", ret
);
11130 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
11131 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
11132 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
11133 ok(msg
.lParam
== 2, "got %08lx\n", msg
.lParam
);
11135 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
11136 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
11139 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11140 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
11142 memset(data
, 0, sizeof(data
));
11143 memset(&recv_info
.ovl
, 0, sizeof(recv_info
.ovl
));
11144 recv_info
.sock
= src
;
11145 recv_info
.wsa_buf
.len
= sizeof(data
);
11146 recv_info
.wsa_buf
.buf
= data
;
11147 thread
= CreateThread(NULL
, 0, wsa_recv_thread
, &recv_info
, 0, &tid
);
11148 ok(thread
!= 0, "CreateThread error %u\n", GetLastError());
11149 ret
= WaitForSingleObject(thread
, 10000);
11150 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
11153 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11154 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
11156 bytes
= 0xdeadbeef;
11158 ovl_iocp
= (void *)0xdeadbeef;
11159 SetLastError(0xdeadbeef);
11160 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
11161 ok(!ret
, "got %d\n", ret
);
11162 ok(GetLastError() == WAIT_TIMEOUT
|| broken(GetLastError() == ERROR_OPERATION_ABORTED
) /* XP */,
11163 "got %u\n", GetLastError());
11164 if (GetLastError() == WAIT_TIMEOUT
)
11166 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
11167 ok(key
== 0xdeadbeef, "got key %lx\n", key
);
11168 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
11170 else /* document XP behaviour */
11172 ok(!bytes
, "got bytes %u\n", bytes
);
11173 ok(key
== 0x12345678, "got key %#lx\n", key
);
11174 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
11177 ok(!ovl_iocp
->InternalHigh
, "got %#lx\n", ovl_iocp
->InternalHigh
);
11178 ok(ovl_iocp
->Internal
== STATUS_CANCELLED
, "got %#lx\n", ovl_iocp
->Internal
);
11186 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11187 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
11192 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11193 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
11195 bytes
= 0xdeadbeef;
11198 SetLastError(0xdeadbeef);
11199 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
11200 ok(!ret
, "got %d\n", ret
);
11202 ok(GetLastError() == ERROR_CONNECTION_ABORTED
|| GetLastError() == ERROR_NETNAME_DELETED
/* XP */, "got %u\n", GetLastError());
11203 ok(!bytes
, "got bytes %u\n", bytes
);
11204 ok(key
== 0x12345678, "got key %#lx\n", key
);
11205 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
11208 ok(!ovl_iocp
->InternalHigh
, "got %#lx\n", ovl_iocp
->InternalHigh
);
11210 ok(ovl_iocp
->Internal
== (ULONG
)STATUS_CONNECTION_ABORTED
|| ovl_iocp
->Internal
== (ULONG
)STATUS_LOCAL_DISCONNECT
/* XP */, "got %#lx\n", ovl_iocp
->Internal
);
11214 bytes
= 0xdeadbeef;
11216 ovl_iocp
= (void *)0xdeadbeef;
11217 SetLastError(0xdeadbeef);
11218 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
11219 ok(!ret
, "got %d\n", ret
);
11220 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
11221 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
11222 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
11223 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
11227 DestroyWindow(hwnd
);
11230 static void iocp_async_read_thread(SOCKET src
, SOCKET dst
)
11232 struct wsa_async_select_info select_info
;
11233 struct wsa_recv_info recv_info
;
11234 HANDLE port
, thread
;
11235 WSAOVERLAPPED
*ovl_iocp
;
11243 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
11244 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
11245 ok(hwnd
!= 0, "CreateWindowEx failed\n");
11247 select_info
.sock
= src
;
11248 select_info
.hwnd
= hwnd
;
11249 thread
= CreateThread(NULL
, 0, wsa_async_select_thread
, &select_info
, 0, &tid
);
11250 ok(thread
!= 0, "CreateThread error %u\n", GetLastError());
11251 ret
= WaitForSingleObject(thread
, 10000);
11252 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
11255 memset(&msg
, 0, sizeof(msg
));
11256 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11257 ok(ret
, "got %d\n", ret
);
11258 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
11259 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
11260 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
11261 ok(msg
.lParam
== 2, "got %08lx\n", msg
.lParam
);
11263 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
11264 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
11267 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11268 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
11270 memset(data
, 0, sizeof(data
));
11271 memset(&recv_info
.ovl
, 0, sizeof(recv_info
.ovl
));
11272 recv_info
.sock
= src
;
11273 recv_info
.wsa_buf
.len
= sizeof(data
);
11274 recv_info
.wsa_buf
.buf
= data
;
11275 thread
= CreateThread(NULL
, 0, wsa_recv_thread
, &recv_info
, 0, &tid
);
11276 ok(thread
!= 0, "CreateThread error %u\n", GetLastError());
11277 ret
= WaitForSingleObject(thread
, 10000);
11278 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
11281 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11282 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
11284 bytes
= 0xdeadbeef;
11286 ovl_iocp
= (void *)0xdeadbeef;
11287 SetLastError(0xdeadbeef);
11288 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
11289 ok(!ret
, "got %d\n", ret
);
11290 ok(GetLastError() == WAIT_TIMEOUT
|| broken(GetLastError() == ERROR_OPERATION_ABORTED
) /* XP */, "got %u\n", GetLastError());
11291 if (GetLastError() == WAIT_TIMEOUT
)
11293 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
11294 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
11295 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
11297 else /* document XP behaviour */
11299 ok(bytes
== 0, "got bytes %u\n", bytes
);
11300 ok(key
== 0x12345678, "got key %#lx\n", key
);
11301 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
11304 ok(!ovl_iocp
->InternalHigh
, "got %#lx\n", ovl_iocp
->InternalHigh
);
11305 ok(ovl_iocp
->Internal
== STATUS_CANCELLED
, "got %#lx\n", ovl_iocp
->Internal
);
11310 memset(&msg
, 0, sizeof(msg
));
11311 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11312 ok(!ret
|| broken(msg
.hwnd
== hwnd
) /* XP */, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
11313 if (ret
) /* document XP behaviour */
11315 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
11316 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
11317 ok(msg
.lParam
== 1, "got %08lx\n", msg
.lParam
);
11320 ret
= send(dst
, "Hello World!", 12, 0);
11321 ok(ret
== 12, "send returned %d\n", ret
);
11324 memset(&msg
, 0, sizeof(msg
));
11325 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11326 ok(!ret
|| broken(msg
.hwnd
== hwnd
) /* XP */, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
11327 if (ret
) /* document XP behaviour */
11329 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
11330 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
11331 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
11332 ok(msg
.lParam
== 1, "got %08lx\n", msg
.lParam
);
11335 bytes
= 0xdeadbeef;
11337 ovl_iocp
= (void *)0xdeadbeef;
11338 SetLastError(0xdeadbeef);
11339 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
11340 ok(ret
|| broken(GetLastError() == WAIT_TIMEOUT
) /* XP */, "got %u\n", GetLastError());
11343 ok(bytes
== 12, "got bytes %u\n", bytes
);
11344 ok(key
== 0x12345678, "got key %#lx\n", key
);
11345 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
11348 ok(ovl_iocp
->InternalHigh
== 12, "got %#lx\n", ovl_iocp
->InternalHigh
);
11349 ok(!ovl_iocp
->Internal
, "got %#lx\n", ovl_iocp
->Internal
);
11350 ok(!memcmp(data
, "Hello World!", 12), "got %u bytes (%*s)\n", bytes
, bytes
, data
);
11353 else /* document XP behaviour */
11355 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
11356 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
11357 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
11362 DestroyWindow(hwnd
);
11365 static void test_iocp(void)
11370 ret
= tcp_socketpair_ovl(&src
, &dst
);
11371 ok(!ret
, "creating socket pair failed\n");
11372 sync_read(src
, dst
);
11373 iocp_async_read(src
, dst
);
11377 ret
= tcp_socketpair_ovl(&src
, &dst
);
11378 ok(!ret
, "creating socket pair failed\n");
11379 iocp_async_read_thread(src
, dst
);
11383 for (i
= 0; i
<= 2; i
++)
11385 ret
= tcp_socketpair_ovl(&src
, &dst
);
11386 ok(!ret
, "creating socket pair failed\n");
11387 iocp_async_read_closesocket(src
, i
);
11391 ret
= tcp_socketpair_ovl(&src
, &dst
);
11392 ok(!ret
, "creating socket pair failed\n");
11393 iocp_async_closesocket(src
);
11396 ret
= tcp_socketpair_ovl(&src
, &dst
);
11397 ok(!ret
, "creating socket pair failed\n");
11398 iocp_async_read_thread_closesocket(src
);
11406 /* Leave these tests at the beginning. They depend on WSAStartup not having been
11407 * called, which is done by Init() below. */
11408 test_WithoutWSAStartup();
11409 test_WithWSAStartup();
11415 test_set_getsockopt();
11416 test_so_reuseaddr();
11418 test_extendedSocketOptions();
11420 for (i
= 0; i
< sizeof(tests
)/sizeof(tests
[0]); i
++)
11422 trace ( " **** STARTING TEST %d ****\n", i
);
11423 do_test ( &tests
[i
] );
11424 trace ( " **** TEST %d COMPLETE ****\n", i
);
11429 test_getservbyname();
11431 test_WSADuplicateSocket();
11432 test_WSAEnumNetworkEvents();
11434 test_WSAAddressToStringA();
11435 test_WSAAddressToStringW();
11437 test_WSAStringToAddressA();
11438 test_WSAStringToAddressW();
11444 test_getpeername();
11445 test_getsockname();
11447 test_addr_to_print();
11448 test_ioctlsocket();
11450 test_gethostbyname();
11451 test_gethostbyname_hack();
11452 test_gethostname();
11458 test_write_watch();
11465 test_TransmitFile();
11466 test_GetAddrInfoW();
11467 test_GetAddrInfoExW();
11468 test_getaddrinfo();
11471 test_DisconnectEx();
11473 test_sioRoutingInterfaceQuery();
11474 test_sioAddressListChange();
11476 test_WSALookupService();
11477 test_WSAEnumNameSpaceProvidersA();
11478 test_WSAEnumNameSpaceProvidersW();
11480 test_WSAAsyncGetServByPort();
11481 test_WSAAsyncGetServByName();
11483 test_completion_port();
11484 test_address_list_query();
11486 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
11488 test_synchronous_WSAIoctl();