2 * Unit test suite for winsock functions
4 * Copyright 2002 Martin Wilck
5 * Copyright 2005 Thomas Kho
6 * Copyright 2008 Jeff Zaroyko
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #define WIN32_NO_STATUS
35 #include "wine/test.h"
37 #define MAX_CLIENTS 4 /* Max number of clients */
38 #define FIRST_CHAR 'A' /* First character in transferred pattern */
39 #define BIND_SLEEP 10 /* seconds to wait between attempts to bind() */
40 #define BIND_TRIES 6 /* Number of bind() attempts */
41 #define TEST_TIMEOUT 30 /* seconds to wait before killing child threads
42 after server initialization, if something hangs */
44 #define NUM_UDP_PEERS 3 /* Number of UDP sockets to create and test > 1 */
46 #define NUM_THREADS 3 /* Number of threads to run getservbyname */
47 #define NUM_QUERIES 250 /* Number of getservbyname queries per thread */
49 #define SERVERIP "127.0.0.1" /* IP to bind to */
50 #define SERVERPORT 9374 /* Port number to bind to */
52 #define wsa_ok(op, cond, msg) \
56 if ( !(cond tmp) ) err = WSAGetLastError(); \
57 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
60 #define make_keepalive(k, enable, time, interval) \
62 k.keepalivetime = time; \
63 k.keepaliveinterval = interval;
65 /* Function pointers */
66 static void (WINAPI
*pfreeaddrinfo
)(struct addrinfo
*);
67 static int (WINAPI
*pgetaddrinfo
)(LPCSTR
,LPCSTR
,const struct addrinfo
*,struct addrinfo
**);
68 static void (WINAPI
*pFreeAddrInfoW
)(PADDRINFOW
);
69 static int (WINAPI
*pGetAddrInfoW
)(LPCWSTR
,LPCWSTR
,const ADDRINFOW
*,PADDRINFOW
*);
70 static PCSTR (WINAPI
*pInetNtop
)(INT
,LPVOID
,LPSTR
,ULONG
);
71 static PCWSTR(WINAPI
*pInetNtopW
)(INT
,LPVOID
,LPWSTR
,ULONG
);
72 static int (WINAPI
*pInetPtonA
)(INT
,LPCSTR
,LPVOID
);
73 static int (WINAPI
*pInetPtonW
)(INT
,LPWSTR
,LPVOID
);
74 static int (WINAPI
*pWSALookupServiceBeginW
)(LPWSAQUERYSETW
,DWORD
,LPHANDLE
);
75 static int (WINAPI
*pWSALookupServiceEnd
)(HANDLE
);
76 static int (WINAPI
*pWSALookupServiceNextW
)(HANDLE
,DWORD
,LPDWORD
,LPWSAQUERYSETW
);
77 static int (WINAPI
*pWSAEnumNameSpaceProvidersA
)(LPDWORD
,LPWSANAMESPACE_INFOA
);
78 static int (WINAPI
*pWSAEnumNameSpaceProvidersW
)(LPDWORD
,LPWSANAMESPACE_INFOW
);
79 static int (WINAPI
*pWSAPoll
)(WSAPOLLFD
*,ULONG
,INT
);
81 /* Function pointers from iphlpapi */
82 static DWORD (WINAPI
*pGetAdaptersInfo
)(PIP_ADAPTER_INFO
,PULONG
);
83 static DWORD (WINAPI
*pGetIpForwardTable
)(PMIB_IPFORWARDTABLE
,PULONG
,BOOL
);
85 /**************** Structs and typedefs ***************/
87 typedef struct thread_info
93 /* Information in the server about open client connections */
94 typedef struct sock_info
97 struct sockaddr_in addr
;
98 struct sockaddr_in peer
;
104 /* Test parameters for both server & client */
105 typedef struct test_params
109 const char *inet_addr
;
116 /* server-specific test parameters */
117 typedef struct server_params
119 test_params
*general
;
124 /* client-specific test parameters */
125 typedef struct client_params
127 test_params
*general
;
132 /* This type combines all information for setting up a test scenario */
133 typedef struct test_setup
137 server_params srv_params
;
139 client_params clt_params
;
142 /* Thread local storage for server */
143 typedef struct server_memory
146 struct sockaddr_in addr
;
147 sock_info sock
[MAX_CLIENTS
];
150 /* Thread local storage for client */
151 typedef struct client_memory
154 struct sockaddr_in addr
;
159 /* SelectReadThread thread parameters */
160 typedef struct select_thread_params
164 } select_thread_params
;
166 /* Tests used in both getaddrinfo and GetAddrInfoW */
167 static const struct addr_hint_tests
169 int family
, socktype
, protocol
;
172 {AF_UNSPEC
, SOCK_STREAM
, IPPROTO_TCP
, 0 },
173 {AF_UNSPEC
, SOCK_STREAM
, IPPROTO_UDP
, 0 },
174 {AF_UNSPEC
, SOCK_STREAM
, IPPROTO_IPV6
,0 },
175 {AF_UNSPEC
, SOCK_DGRAM
, IPPROTO_TCP
, 0 },
176 {AF_UNSPEC
, SOCK_DGRAM
, IPPROTO_UDP
, 0 },
177 {AF_UNSPEC
, SOCK_DGRAM
, IPPROTO_IPV6
,0 },
178 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, 0 },
179 {AF_INET
, SOCK_STREAM
, IPPROTO_UDP
, 0 },
180 {AF_INET
, SOCK_STREAM
, IPPROTO_IPV6
,0 },
181 {AF_INET
, SOCK_DGRAM
, IPPROTO_TCP
, 0 },
182 {AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, 0 },
183 {AF_INET
, SOCK_DGRAM
, IPPROTO_IPV6
,0 },
184 {AF_UNSPEC
, 0, IPPROTO_TCP
, 0 },
185 {AF_UNSPEC
, 0, IPPROTO_UDP
, 0 },
186 {AF_UNSPEC
, 0, IPPROTO_IPV6
,0 },
187 {AF_UNSPEC
, SOCK_STREAM
, 0, 0 },
188 {AF_UNSPEC
, SOCK_DGRAM
, 0, 0 },
189 {AF_INET
, 0, IPPROTO_TCP
, 0 },
190 {AF_INET
, 0, IPPROTO_UDP
, 0 },
191 {AF_INET
, 0, IPPROTO_IPV6
,0 },
192 {AF_INET
, SOCK_STREAM
, 0, 0 },
193 {AF_INET
, SOCK_DGRAM
, 0, 0 },
194 {AF_UNSPEC
, 999, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
195 {AF_UNSPEC
, 999, IPPROTO_UDP
, WSAESOCKTNOSUPPORT
},
196 {AF_UNSPEC
, 999, IPPROTO_IPV6
,WSAESOCKTNOSUPPORT
},
197 {AF_INET
, 999, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
198 {AF_INET
, 999, IPPROTO_UDP
, WSAESOCKTNOSUPPORT
},
199 {AF_INET
, 999, IPPROTO_IPV6
,WSAESOCKTNOSUPPORT
},
200 {AF_UNSPEC
, SOCK_STREAM
, 999, 0 },
201 {AF_UNSPEC
, SOCK_STREAM
, 999, 0 },
202 {AF_INET
, SOCK_DGRAM
, 999, 0 },
203 {AF_INET
, SOCK_DGRAM
, 999, 0 },
206 /**************** Static variables ***************/
208 static DWORD tls
; /* Thread local storage index */
209 static HANDLE thread
[1+MAX_CLIENTS
];
210 static DWORD thread_id
[1+MAX_CLIENTS
];
211 static HANDLE server_ready
;
212 static HANDLE client_ready
[MAX_CLIENTS
];
213 static int client_id
;
215 /**************** General utility functions ***************/
217 static SOCKET
setup_server_socket(struct sockaddr_in
*addr
, int *len
);
218 static SOCKET
setup_connector_socket(struct sockaddr_in
*addr
, int len
, BOOL nonblock
);
220 static int tcp_socketpair(SOCKET
*src
, SOCKET
*dst
)
222 SOCKET server
= INVALID_SOCKET
;
223 struct sockaddr_in addr
;
227 *src
= INVALID_SOCKET
;
228 *dst
= INVALID_SOCKET
;
230 *src
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
231 if (*src
== INVALID_SOCKET
)
234 server
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
235 if (server
== INVALID_SOCKET
)
238 memset(&addr
, 0, sizeof(addr
));
239 addr
.sin_family
= AF_INET
;
240 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
241 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
246 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
250 ret
= listen(server
, 1);
254 ret
= connect(*src
, (struct sockaddr
*)&addr
, sizeof(addr
));
259 *dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
262 if (server
!= INVALID_SOCKET
)
264 if (*src
!= INVALID_SOCKET
&& *dst
!= INVALID_SOCKET
)
271 static void set_so_opentype ( BOOL overlapped
)
273 int optval
= !overlapped
, newval
, len
= sizeof (int);
275 ok ( setsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
276 (LPVOID
) &optval
, sizeof (optval
) ) == 0,
277 "setting SO_OPENTYPE failed\n" );
278 ok ( getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
279 (LPVOID
) &newval
, &len
) == 0,
280 "getting SO_OPENTYPE failed\n" );
281 ok ( optval
== newval
, "failed to set SO_OPENTYPE\n" );
284 static int set_blocking ( SOCKET s
, BOOL blocking
)
286 u_long val
= !blocking
;
287 return ioctlsocket ( s
, FIONBIO
, &val
);
290 static void fill_buffer ( char *buf
, int chunk_size
, int n_chunks
)
293 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
294 memset ( p
, c
, chunk_size
);
297 static int test_buffer ( char *buf
, int chunk_size
, int n_chunks
)
301 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
303 for ( i
= 0; i
< chunk_size
; i
++ )
304 if ( p
[i
] != c
) return i
;
310 * This routine is called when a client / server does not expect any more data,
311 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
313 static void read_zero_bytes ( SOCKET s
)
317 while ( ( tmp
= recv ( s
, buf
, 256, 0 ) ) > 0 )
319 ok ( n
<= 0, "garbage data received: %d bytes\n", n
);
322 static int do_synchronous_send ( SOCKET s
, char *buf
, int buflen
, int flags
, int sendlen
)
324 char* last
= buf
+ buflen
, *p
;
326 for ( p
= buf
; n
> 0 && p
< last
; )
328 n
= send ( s
, p
, min ( sendlen
, last
- p
), flags
);
331 wsa_ok ( n
, 0 <=, "do_synchronous_send (%x): error %d\n" );
335 static int do_synchronous_recv ( SOCKET s
, char *buf
, int buflen
, int flags
, int recvlen
)
337 char* last
= buf
+ buflen
, *p
;
339 for ( p
= buf
; n
> 0 && p
< last
; )
341 n
= recv ( s
, p
, min ( recvlen
, last
- p
), flags
);
344 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
348 static int do_synchronous_recvfrom ( SOCKET s
, char *buf
, int buflen
, int flags
, struct sockaddr
*from
, int *fromlen
, int recvlen
)
350 char* last
= buf
+ buflen
, *p
;
352 for ( p
= buf
; n
> 0 && p
< last
; )
354 n
= recvfrom ( s
, p
, min ( recvlen
, last
- p
), flags
, from
, fromlen
);
357 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
362 * Call this routine right after thread startup.
363 * SO_OPENTYPE must by 0, regardless what the server did.
365 static void check_so_opentype (void)
369 getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
, (LPVOID
) &tmp
, &len
);
370 ok ( tmp
== 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp
);
373 static void compare_addrinfo (ADDRINFO
*a
, ADDRINFO
*b
)
375 for (; a
&& b
; a
= a
->ai_next
, b
= b
->ai_next
)
377 ok(a
->ai_flags
== b
->ai_flags
,
378 "Wrong flags %d != %d\n", a
->ai_flags
, b
->ai_flags
);
379 ok(a
->ai_family
== b
->ai_family
,
380 "Wrong family %d != %d\n", a
->ai_family
, b
->ai_family
);
381 ok(a
->ai_socktype
== b
->ai_socktype
,
382 "Wrong socktype %d != %d\n", a
->ai_socktype
, b
->ai_socktype
);
383 ok(a
->ai_protocol
== b
->ai_protocol
,
384 "Wrong protocol %d != %d\n", a
->ai_protocol
, b
->ai_protocol
);
385 ok(a
->ai_addrlen
== b
->ai_addrlen
,
386 "Wrong addrlen %lu != %lu\n", a
->ai_addrlen
, b
->ai_addrlen
);
387 ok(!memcmp(a
->ai_addr
, b
->ai_addr
, min(a
->ai_addrlen
, b
->ai_addrlen
)),
388 "Wrong address data\n");
389 if (a
->ai_canonname
&& b
->ai_canonname
)
391 ok(!strcmp(a
->ai_canonname
, b
->ai_canonname
), "Wrong canonical name '%s' != '%s'\n",
392 a
->ai_canonname
, b
->ai_canonname
);
395 ok(!a
->ai_canonname
&& !b
->ai_canonname
, "Expected both names absent (%p != %p)\n",
396 a
->ai_canonname
, b
->ai_canonname
);
398 ok(!a
&& !b
, "Expected both addresses null (%p != %p)\n", a
, b
);
401 static void compare_addrinfow (ADDRINFOW
*a
, ADDRINFOW
*b
)
403 for (; a
&& b
; a
= a
->ai_next
, b
= b
->ai_next
)
405 ok(a
->ai_flags
== b
->ai_flags
,
406 "Wrong flags %d != %d\n", a
->ai_flags
, b
->ai_flags
);
407 ok(a
->ai_family
== b
->ai_family
,
408 "Wrong family %d != %d\n", a
->ai_family
, b
->ai_family
);
409 ok(a
->ai_socktype
== b
->ai_socktype
,
410 "Wrong socktype %d != %d\n", a
->ai_socktype
, b
->ai_socktype
);
411 ok(a
->ai_protocol
== b
->ai_protocol
,
412 "Wrong protocol %d != %d\n", a
->ai_protocol
, b
->ai_protocol
);
413 ok(a
->ai_addrlen
== b
->ai_addrlen
,
414 "Wrong addrlen %lu != %lu\n", a
->ai_addrlen
, b
->ai_addrlen
);
415 ok(!memcmp(a
->ai_addr
, b
->ai_addr
, min(a
->ai_addrlen
, b
->ai_addrlen
)),
416 "Wrong address data\n");
417 if (a
->ai_canonname
&& b
->ai_canonname
)
419 ok(!lstrcmpW(a
->ai_canonname
, b
->ai_canonname
), "Wrong canonical name '%s' != '%s'\n",
420 wine_dbgstr_w(a
->ai_canonname
), wine_dbgstr_w(b
->ai_canonname
));
423 ok(!a
->ai_canonname
&& !b
->ai_canonname
, "Expected both names absent (%p != %p)\n",
424 a
->ai_canonname
, b
->ai_canonname
);
426 ok(!a
&& !b
, "Expected both addresses null (%p != %p)\n", a
, b
);
429 /**************** Server utility functions ***************/
432 * Even if we have closed our server socket cleanly,
433 * the OS may mark the address "in use" for some time -
434 * this happens with native Linux apps, too.
436 static void do_bind ( SOCKET s
, struct sockaddr
* addr
, int addrlen
)
438 int err
, wsaerr
= 0, n_try
= BIND_TRIES
;
440 while ( ( err
= bind ( s
, addr
, addrlen
) ) != 0 &&
441 ( wsaerr
= WSAGetLastError () ) == WSAEADDRINUSE
&&
444 trace ( "address in use, waiting ...\n" );
445 Sleep ( 1000 * BIND_SLEEP
);
447 ok ( err
== 0, "failed to bind: %d\n", wsaerr
);
450 static void server_start ( server_params
*par
)
453 test_params
*gen
= par
->general
;
454 server_memory
*mem
= LocalAlloc ( LPTR
, sizeof ( server_memory
) );
456 TlsSetValue ( tls
, mem
);
457 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
458 NULL
, 0, par
->sock_flags
);
459 ok ( mem
->s
!= INVALID_SOCKET
, "Server: WSASocket failed\n" );
461 mem
->addr
.sin_family
= AF_INET
;
462 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
463 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
465 for (i
= 0; i
< MAX_CLIENTS
; i
++)
467 mem
->sock
[i
].s
= INVALID_SOCKET
;
468 mem
->sock
[i
].buf
= LocalAlloc ( LPTR
, gen
->n_chunks
* gen
->chunk_size
);
469 mem
->sock
[i
].n_recvd
= 0;
470 mem
->sock
[i
].n_sent
= 0;
473 if ( gen
->sock_type
== SOCK_STREAM
)
474 do_bind ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof (mem
->addr
) );
477 static void server_stop (void)
480 server_memory
*mem
= TlsGetValue ( tls
);
482 for (i
= 0; i
< MAX_CLIENTS
; i
++ )
484 LocalFree ( mem
->sock
[i
].buf
);
485 if ( mem
->sock
[i
].s
!= INVALID_SOCKET
)
486 closesocket ( mem
->sock
[i
].s
);
488 ok ( closesocket ( mem
->s
) == 0, "closesocket failed\n" );
490 ExitThread ( GetCurrentThreadId () );
493 /**************** Client utilitiy functions ***************/
495 static void client_start ( client_params
*par
)
497 test_params
*gen
= par
->general
;
498 client_memory
*mem
= LocalAlloc (LPTR
, sizeof (client_memory
));
500 TlsSetValue ( tls
, mem
);
502 WaitForSingleObject ( server_ready
, INFINITE
);
504 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
505 NULL
, 0, par
->sock_flags
);
507 mem
->addr
.sin_family
= AF_INET
;
508 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
509 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
511 ok ( mem
->s
!= INVALID_SOCKET
, "Client: WSASocket failed\n" );
513 mem
->send_buf
= LocalAlloc ( LPTR
, 2 * gen
->n_chunks
* gen
->chunk_size
);
514 mem
->recv_buf
= mem
->send_buf
+ gen
->n_chunks
* gen
->chunk_size
;
515 fill_buffer ( mem
->send_buf
, gen
->chunk_size
, gen
->n_chunks
);
517 SetEvent ( client_ready
[client_id
] );
518 /* Wait for the other clients to come up */
519 WaitForMultipleObjects ( min ( gen
->n_clients
, MAX_CLIENTS
), client_ready
, TRUE
, INFINITE
);
522 static void client_stop (void)
524 client_memory
*mem
= TlsGetValue ( tls
);
525 wsa_ok ( closesocket ( mem
->s
), 0 ==, "closesocket error (%x): %d\n" );
526 LocalFree ( mem
->send_buf
);
531 /**************** Servers ***************/
534 * simple_server: A very basic server doing synchronous IO.
536 static VOID WINAPI
simple_server ( server_params
*par
)
538 test_params
*gen
= par
->general
;
540 int pos
, n_recvd
, n_sent
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
541 id
= GetCurrentThreadId();
543 trace ( "simple_server (%x) starting\n", id
);
545 set_so_opentype ( FALSE
); /* non-overlapped */
546 server_start ( par
);
547 mem
= TlsGetValue ( tls
);
549 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
550 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "simple_server (%x): listen failed: %d\n");
552 trace ( "simple_server (%x) ready\n", id
);
553 SetEvent ( server_ready
); /* notify clients */
555 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
557 trace ( "simple_server (%x): waiting for client\n", id
);
559 /* accept a single connection */
560 tmp
= sizeof ( mem
->sock
[0].peer
);
561 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
562 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "simple_server (%x): accept failed: %d\n" );
564 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
565 "simple_server (%x): strange peer address\n", id
);
567 /* Receive data & check it */
568 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
569 ok ( n_recvd
== n_expected
,
570 "simple_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
571 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
572 ok ( pos
== -1, "simple_server (%x): test pattern error: %d\n", id
, pos
);
575 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
576 ok ( n_sent
== n_expected
,
577 "simple_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
580 read_zero_bytes ( mem
->sock
[0].s
);
581 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "simple_server (%x): closesocket error: %d\n" );
582 mem
->sock
[0].s
= INVALID_SOCKET
;
585 trace ( "simple_server (%x) exiting\n", id
);
590 * oob_server: A very basic server receiving out-of-band data.
592 static VOID WINAPI
oob_server ( server_params
*par
)
594 test_params
*gen
= par
->general
;
597 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
,
598 id
= GetCurrentThreadId();
600 trace ( "oob_server (%x) starting\n", id
);
602 set_so_opentype ( FALSE
); /* non-overlapped */
603 server_start ( par
);
604 mem
= TlsGetValue ( tls
);
606 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "oob_server (%x): failed to set blocking mode: %d\n");
607 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "oob_server (%x): listen failed: %d\n");
609 trace ( "oob_server (%x) ready\n", id
);
610 SetEvent ( server_ready
); /* notify clients */
612 trace ( "oob_server (%x): waiting for client\n", id
);
614 /* accept a single connection */
615 tmp
= sizeof ( mem
->sock
[0].peer
);
616 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
617 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "oob_server (%x): accept failed: %d\n" );
619 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
620 "oob_server (%x): strange peer address\n", id
);
622 /* check initial atmark state */
623 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
624 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
626 /* Receive normal data */
627 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
628 ok ( n_recvd
== n_expected
,
629 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
630 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
631 ok ( pos
== -1, "oob_server (%x): test pattern error: %d\n", id
, pos
);
633 /* check atmark state */
634 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
635 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
638 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
639 ok ( n_sent
== n_expected
,
640 "oob_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
642 /* Receive a part of the out-of-band data and print atmark state */
643 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, 8, 0, par
->buflen
);
645 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, 8 );
648 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
649 trace( "oob_server (%x): %s the OOB mark: %i\n", id
, atmark
== 1 ? "not at" : "at", atmark
);
651 /* Receive the rest of the out-of-band data and check atmark state */
652 do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
654 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
655 todo_wine
ok ( atmark
== 0, "oob_server (%x): not at the OOB mark: %i\n", id
, atmark
);
658 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "oob_server (%x): closesocket error: %d\n" );
659 mem
->sock
[0].s
= INVALID_SOCKET
;
661 trace ( "oob_server (%x) exiting\n", id
);
666 * select_server: A non-blocking server.
668 static VOID WINAPI
select_server ( server_params
*par
)
670 test_params
*gen
= par
->general
;
672 int n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
673 id
= GetCurrentThreadId(), n_connections
= 0, n_sent
, n_recvd
,
674 n_set
, delta
, n_ready
;
675 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
676 fd_set fds_recv
, fds_send
, fds_openrecv
, fds_opensend
;
678 trace ( "select_server (%x) starting\n", id
);
680 set_so_opentype ( FALSE
); /* non-overlapped */
681 server_start ( par
);
682 mem
= TlsGetValue ( tls
);
684 wsa_ok ( set_blocking ( mem
->s
, FALSE
), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
685 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "select_server (%x): listen failed: %d\n");
687 trace ( "select_server (%x) ready\n", id
);
688 SetEvent ( server_ready
); /* notify clients */
690 FD_ZERO ( &fds_openrecv
);
691 FD_ZERO ( &fds_recv
);
692 FD_ZERO ( &fds_send
);
693 FD_ZERO ( &fds_opensend
);
695 FD_SET ( mem
->s
, &fds_openrecv
);
699 fds_recv
= fds_openrecv
;
700 fds_send
= fds_opensend
;
704 wsa_ok ( ( n_ready
= select ( 0, &fds_recv
, &fds_send
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
705 "select_server (%x): select() failed: %d\n" );
707 /* check for incoming requests */
708 if ( FD_ISSET ( mem
->s
, &fds_recv
) ) {
711 trace ( "select_server (%x): accepting client connection\n", id
);
713 /* accept a single connection */
714 tmp
= sizeof ( mem
->sock
[n_connections
].peer
);
715 mem
->sock
[n_connections
].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[n_connections
].peer
, &tmp
);
716 wsa_ok ( mem
->sock
[n_connections
].s
, INVALID_SOCKET
!=, "select_server (%x): accept() failed: %d\n" );
718 ok ( mem
->sock
[n_connections
].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
719 "select_server (%x): strange peer address\n", id
);
721 /* add to list of open connections */
722 FD_SET ( mem
->sock
[n_connections
].s
, &fds_openrecv
);
723 FD_SET ( mem
->sock
[n_connections
].s
, &fds_opensend
);
728 /* handle open requests */
730 for ( i
= 0; i
< n_connections
; i
++ )
732 if ( FD_ISSET( mem
->sock
[i
].s
, &fds_recv
) ) {
735 if ( mem
->sock
[i
].n_recvd
< n_expected
) {
736 /* Receive data & check it */
737 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 );
738 ok ( n_recvd
!= SOCKET_ERROR
, "select_server (%x): error in recv(): %d\n", id
, WSAGetLastError() );
739 mem
->sock
[i
].n_recvd
+= n_recvd
;
741 if ( mem
->sock
[i
].n_recvd
== n_expected
) {
742 int pos
= test_buffer ( mem
->sock
[i
].buf
, gen
->chunk_size
, gen
->n_chunks
);
743 ok ( pos
== -1, "select_server (%x): test pattern error: %d\n", id
, pos
);
744 FD_CLR ( mem
->sock
[i
].s
, &fds_openrecv
);
747 ok ( mem
->sock
[i
].n_recvd
<= n_expected
, "select_server (%x): received too many bytes: %d\n", id
, mem
->sock
[i
].n_recvd
);
751 /* only echo back what we've received */
752 delta
= mem
->sock
[i
].n_recvd
- mem
->sock
[i
].n_sent
;
754 if ( FD_ISSET ( mem
->sock
[i
].s
, &fds_send
) ) {
757 if ( ( delta
> 0 ) && ( mem
->sock
[i
].n_sent
< n_expected
) ) {
759 n_sent
= send ( mem
->sock
[i
].s
, mem
->sock
[i
].buf
+ mem
->sock
[i
].n_sent
, min ( delta
, par
->buflen
), 0 );
760 ok ( n_sent
!= SOCKET_ERROR
, "select_server (%x): error in send(): %d\n", id
, WSAGetLastError() );
761 mem
->sock
[i
].n_sent
+= n_sent
;
763 if ( mem
->sock
[i
].n_sent
== n_expected
) {
764 FD_CLR ( mem
->sock
[i
].s
, &fds_opensend
);
767 ok ( mem
->sock
[i
].n_sent
<= n_expected
, "select_server (%x): sent too many bytes: %d\n", id
, mem
->sock
[i
].n_sent
);
772 /* check that select returned the correct number of ready sockets */
773 ok ( ( n_set
== n_ready
), "select_server (%x): select() returns wrong number of ready sockets\n", id
);
775 /* check if all clients are done */
776 if ( ( fds_opensend
.fd_count
== 0 )
777 && ( fds_openrecv
.fd_count
== 1 ) /* initial socket that accepts clients */
778 && ( n_connections
== min ( gen
->n_clients
, MAX_CLIENTS
) ) ) {
783 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
786 read_zero_bytes ( mem
->sock
[i
].s
);
787 wsa_ok ( closesocket ( mem
->sock
[i
].s
), 0 ==, "select_server (%x): closesocket error: %d\n" );
788 mem
->sock
[i
].s
= INVALID_SOCKET
;
791 trace ( "select_server (%x) exiting\n", id
);
795 /**************** Clients ***************/
798 * simple_client: A very basic client doing synchronous IO.
800 static VOID WINAPI
simple_client ( client_params
*par
)
802 test_params
*gen
= par
->general
;
804 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
806 id
= GetCurrentThreadId();
807 trace ( "simple_client (%x): starting\n", id
);
808 /* wait here because we want to call set_so_opentype before creating a socket */
809 WaitForSingleObject ( server_ready
, INFINITE
);
810 trace ( "simple_client (%x): server ready\n", id
);
812 check_so_opentype ();
813 set_so_opentype ( FALSE
); /* non-overlapped */
814 client_start ( par
);
815 mem
= TlsGetValue ( tls
);
818 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
819 0 ==, "simple_client (%x): connect error: %d\n" );
820 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
821 "simple_client (%x): failed to set blocking mode\n", id
);
822 trace ( "simple_client (%x) connected\n", id
);
824 /* send data to server */
825 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
826 ok ( n_sent
== n_expected
,
827 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
829 /* shutdown send direction */
830 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
832 /* Receive data echoed back & check it */
833 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, 0, par
->buflen
);
834 ok ( n_recvd
== n_expected
,
835 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
838 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
839 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
842 read_zero_bytes ( mem
->s
);
843 trace ( "simple_client (%x) exiting\n", id
);
848 * oob_client: A very basic client sending out-of-band data.
850 static VOID WINAPI
oob_client ( client_params
*par
)
852 test_params
*gen
= par
->general
;
854 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
856 id
= GetCurrentThreadId();
857 trace ( "oob_client (%x): starting\n", id
);
858 /* wait here because we want to call set_so_opentype before creating a socket */
859 WaitForSingleObject ( server_ready
, INFINITE
);
860 trace ( "oob_client (%x): server ready\n", id
);
862 check_so_opentype ();
863 set_so_opentype ( FALSE
); /* non-overlapped */
864 client_start ( par
);
865 mem
= TlsGetValue ( tls
);
868 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
869 0 ==, "oob_client (%x): connect error: %d\n" );
870 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
871 "oob_client (%x): failed to set blocking mode\n", id
);
872 trace ( "oob_client (%x) connected\n", id
);
874 /* send data to server */
875 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
876 ok ( n_sent
== n_expected
,
877 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
879 /* Receive data echoed back & check it */
880 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, 0, par
->buflen
);
881 ok ( n_recvd
== n_expected
,
882 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
883 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
884 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
886 /* send out-of-band data to server */
887 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, MSG_OOB
, par
->buflen
);
888 ok ( n_sent
== n_expected
,
889 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
891 /* shutdown send direction */
892 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
895 read_zero_bytes ( mem
->s
);
896 trace ( "oob_client (%x) exiting\n", id
);
901 * simple_mixed_client: mixing send and recvfrom
903 static VOID WINAPI
simple_mixed_client ( client_params
*par
)
905 test_params
*gen
= par
->general
;
907 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
908 int fromLen
= sizeof(mem
->addr
);
909 struct sockaddr test
;
911 id
= GetCurrentThreadId();
912 trace ( "simple_client (%x): starting\n", id
);
913 /* wait here because we want to call set_so_opentype before creating a socket */
914 WaitForSingleObject ( server_ready
, INFINITE
);
915 trace ( "simple_client (%x): server ready\n", id
);
917 check_so_opentype ();
918 set_so_opentype ( FALSE
); /* non-overlapped */
919 client_start ( par
);
920 mem
= TlsGetValue ( tls
);
923 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
924 0 ==, "simple_client (%x): connect error: %d\n" );
925 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
926 "simple_client (%x): failed to set blocking mode\n", id
);
927 trace ( "simple_client (%x) connected\n", id
);
929 /* send data to server */
930 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
931 ok ( n_sent
== n_expected
,
932 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
934 /* shutdown send direction */
935 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
937 /* this shouldn't change, since lpFrom, is not updated on
938 connection oriented sockets - exposed by bug 11640
940 ((struct sockaddr_in
*)&test
)->sin_addr
.s_addr
= inet_addr("0.0.0.0");
942 /* Receive data echoed back & check it */
943 n_recvd
= do_synchronous_recvfrom ( mem
->s
,
947 (struct sockaddr
*)&test
,
950 ok ( n_recvd
== n_expected
,
951 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
953 /* check that lpFrom was not updated */
956 inet_ntoa(((struct sockaddr_in
*)&test
)->sin_addr
),
957 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
960 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
961 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
964 read_zero_bytes ( mem
->s
);
965 trace ( "simple_client (%x) exiting\n", id
);
970 * event_client: An event-driven client
972 static void WINAPI
event_client ( client_params
*par
)
974 test_params
*gen
= par
->general
;
976 int id
= GetCurrentThreadId(), n_expected
= gen
->n_chunks
* gen
->chunk_size
,
979 WSANETWORKEVENTS wsa_events
;
980 char *send_last
, *recv_last
, *send_p
, *recv_p
;
981 LONG mask
= FD_READ
| FD_WRITE
| FD_CLOSE
;
983 trace ( "event_client (%x): starting\n", id
);
984 client_start ( par
);
985 trace ( "event_client (%x): server ready\n", id
);
987 mem
= TlsGetValue ( tls
);
989 /* Prepare event notification for connect, makes socket nonblocking */
990 event
= WSACreateEvent ();
991 WSAEventSelect ( mem
->s
, event
, FD_CONNECT
);
992 tmp
= connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) );
994 err
= WSAGetLastError ();
995 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): connect error: %d\n", id
, err
);
996 tmp
= WaitForSingleObject ( event
, INFINITE
);
997 ok ( tmp
== WAIT_OBJECT_0
, "event_client (%x): wait for connect event failed: %d\n", id
, tmp
);
998 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
999 ok ( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
1000 err
= wsa_events
.iErrorCode
[ FD_CONNECT_BIT
];
1001 ok ( err
== 0, "event_client (%x): connect error: %d\n", id
, err
);
1002 if ( err
) goto out
;
1005 trace ( "event_client (%x) connected\n", id
);
1007 WSAEventSelect ( mem
->s
, event
, mask
);
1009 recv_p
= mem
->recv_buf
;
1010 recv_last
= mem
->recv_buf
+ n_expected
;
1011 send_p
= mem
->send_buf
;
1012 send_last
= mem
->send_buf
+ n_expected
;
1016 err
= WaitForSingleObject ( event
, INFINITE
);
1017 ok ( err
== WAIT_OBJECT_0
, "event_client (%x): wait failed\n", id
);
1019 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
1020 ok( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
1022 if ( wsa_events
.lNetworkEvents
& FD_WRITE
)
1024 err
= wsa_events
.iErrorCode
[ FD_WRITE_BIT
];
1025 ok ( err
== 0, "event_client (%x): FD_WRITE error code: %d\n", id
, err
);
1030 n
= send ( mem
->s
, send_p
, min ( send_last
- send_p
, par
->buflen
), 0 );
1033 err
= WSAGetLastError ();
1034 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): send error: %d\n", id
, err
);
1039 while ( n
>= 0 && send_p
< send_last
);
1041 if ( send_p
== send_last
)
1043 trace ( "event_client (%x): all data sent - shutdown\n", id
);
1044 shutdown ( mem
->s
, SD_SEND
);
1046 WSAEventSelect ( mem
->s
, event
, mask
);
1049 if ( wsa_events
.lNetworkEvents
& FD_READ
)
1051 err
= wsa_events
.iErrorCode
[ FD_READ_BIT
];
1052 ok ( err
== 0, "event_client (%x): FD_READ error code: %d\n", id
, err
);
1053 if ( err
!= 0 ) break;
1055 /* First read must succeed */
1056 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
1057 wsa_ok ( n
, 0 <=, "event_client (%x): recv error: %d\n" );
1061 if ( recv_p
== recv_last
)
1064 trace ( "event_client (%x): all data received\n", id
);
1065 WSAEventSelect ( mem
->s
, event
, mask
);
1068 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
1069 if ( n
< 0 && ( err
= WSAGetLastError()) != WSAEWOULDBLOCK
)
1070 ok ( 0, "event_client (%x): read error: %d\n", id
, err
);
1074 if ( wsa_events
.lNetworkEvents
& FD_CLOSE
)
1076 trace ( "event_client (%x): close event\n", id
);
1077 err
= wsa_events
.iErrorCode
[ FD_CLOSE_BIT
];
1078 ok ( err
== 0, "event_client (%x): FD_CLOSE error code: %d\n", id
, err
);
1083 n
= send_p
- mem
->send_buf
;
1084 ok ( send_p
== send_last
,
1085 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n
, n_expected
);
1086 n
= recv_p
- mem
->recv_buf
;
1087 ok ( recv_p
== recv_last
,
1088 "simple_client (%x): received less data than expected: %d of %d\n", id
, n
, n_expected
);
1089 n
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
1090 ok ( n
== -1, "event_client (%x): test pattern error: %d\n", id
, n
);
1093 WSACloseEvent ( event
);
1094 trace ( "event_client (%x) exiting\n", id
);
1098 /* Tests for WSAStartup */
1099 static void test_WithoutWSAStartup(void)
1103 WSASetLastError(0xdeadbeef);
1104 ok(WSASocketA(0, 0, 0, NULL
, 0, 0) == INVALID_SOCKET
, "WSASocketA should have failed\n");
1105 err
= WSAGetLastError();
1106 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %d\n", err
);
1108 WSASetLastError(0xdeadbeef);
1109 ok(gethostbyname("localhost") == NULL
, "gethostbyname() succeeded unexpectedly\n");
1110 err
= WSAGetLastError();
1111 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %d\n", err
);
1114 static void test_WithWSAStartup(void)
1117 WORD version
= MAKEWORD( 2, 2 );
1118 INT res
, socks
, i
, j
;
1123 SOCKET src
, dst
, dup_src
, dup_dst
;
1127 res
= WSAStartup( version
, &data
);
1128 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
1130 ptr
= gethostbyname("localhost");
1131 ok(ptr
!= NULL
, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
1133 /* Alloc some sockets to check if they are destroyed on WSACleanup */
1134 for (socks
= 0; socks
< sizeof(pairs
) / sizeof(pairs
[0]); socks
++)
1136 WSAPROTOCOL_INFOA info
;
1137 if (tcp_socketpair(&pairs
[socks
].src
, &pairs
[socks
].dst
)) break;
1139 memset(&info
, 0, sizeof(info
));
1140 ok(!WSADuplicateSocketA(pairs
[socks
].src
, GetCurrentProcessId(), &info
),
1141 "WSADuplicateSocketA should have worked\n");
1142 pairs
[socks
].dup_src
= WSASocketA(0, 0, 0, &info
, 0, 0);
1143 ok(pairs
[socks
].dup_src
!= SOCKET_ERROR
, "expected != -1\n");
1145 memset(&info
, 0, sizeof(info
));
1146 ok(!WSADuplicateSocketA(pairs
[socks
].dst
, GetCurrentProcessId(), &info
),
1147 "WSADuplicateSocketA should have worked\n");
1148 pairs
[socks
].dup_dst
= WSASocketA(0, 0, 0, &info
, 0, 0);
1149 ok(pairs
[socks
].dup_dst
!= SOCKET_ERROR
, "expected != -1\n");
1152 res
= send(pairs
[0].src
, "TEST", 4, 0);
1153 ok(res
== 4, "send failed with error %d\n", WSAGetLastError());
1157 res
= WSAStartup( version
, &data
);
1158 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
1160 /* show that sockets are destroyed automatically after WSACleanup */
1162 SetLastError(0xdeadbeef);
1163 res
= send(pairs
[0].src
, "TEST", 4, 0);
1164 error
= WSAGetLastError();
1165 ok(res
== SOCKET_ERROR
, "send should have failed\n");
1166 ok(error
== WSAENOTSOCK
, "expected 10038, got %d\n", error
);
1168 SetLastError(0xdeadbeef);
1169 res
= send(pairs
[0].dst
, "TEST", 4, 0);
1170 error
= WSAGetLastError();
1171 ok(res
== SOCKET_ERROR
, "send should have failed\n");
1172 ok(error
== WSAENOTSOCK
, "expected 10038, got %d\n", error
);
1174 /* Check that all sockets were destroyed */
1175 for (i
= 0; i
< socks
; i
++)
1177 for (j
= 0; j
< 4; j
++)
1179 struct sockaddr_in saddr
;
1180 int size
= sizeof(saddr
);
1183 case 0: sock
= pairs
[i
].src
; break;
1184 case 1: sock
= pairs
[i
].dup_src
; break;
1185 case 2: sock
= pairs
[i
].dst
; break;
1186 case 3: sock
= pairs
[i
].dup_dst
; break;
1189 SetLastError(0xdeadbeef);
1190 res
= getsockname(sock
, (struct sockaddr
*)&saddr
, &size
);
1191 error
= WSAGetLastError();
1192 ok(res
== SOCKET_ERROR
, "Test[%d]: getsockname should have failed\n", i
);
1193 ok(error
== WSAENOTSOCK
, "Test[%d]: expected 10038, got %d\n", i
, error
);
1199 /* While wine is not fixed, close all sockets manually */
1200 for (i
= 0; i
< socks
; i
++)
1202 closesocket(pairs
[i
].src
);
1203 closesocket(pairs
[i
].dst
);
1204 closesocket(pairs
[i
].dup_src
);
1205 closesocket(pairs
[i
].dup_dst
);
1209 ok(res
== 0, "expected 0, got %d\n", res
);
1210 WSASetLastError(0xdeadbeef);
1212 error
= WSAGetLastError();
1213 ok ( (res
== SOCKET_ERROR
&& error
== WSANOTINITIALISED
) ||
1214 broken(res
== 0), /* WinME */
1215 "WSACleanup returned %d WSAGetLastError is %d\n", res
, error
);
1218 /**************** Main program utility functions ***************/
1220 static void Init (void)
1222 WORD ver
= MAKEWORD (2, 2);
1224 HMODULE hws2_32
= GetModuleHandleA("ws2_32.dll"), hiphlpapi
;
1226 pfreeaddrinfo
= (void *)GetProcAddress(hws2_32
, "freeaddrinfo");
1227 pgetaddrinfo
= (void *)GetProcAddress(hws2_32
, "getaddrinfo");
1228 pFreeAddrInfoW
= (void *)GetProcAddress(hws2_32
, "FreeAddrInfoW");
1229 pGetAddrInfoW
= (void *)GetProcAddress(hws2_32
, "GetAddrInfoW");
1230 pInetNtop
= (void *)GetProcAddress(hws2_32
, "inet_ntop");
1231 pInetNtopW
= (void *)GetProcAddress(hws2_32
, "InetNtopW");
1232 pInetPtonA
= (void *)GetProcAddress(hws2_32
, "inet_pton");
1233 pInetPtonW
= (void *)GetProcAddress(hws2_32
, "InetPtonW");
1234 pWSALookupServiceBeginW
= (void *)GetProcAddress(hws2_32
, "WSALookupServiceBeginW");
1235 pWSALookupServiceEnd
= (void *)GetProcAddress(hws2_32
, "WSALookupServiceEnd");
1236 pWSALookupServiceNextW
= (void *)GetProcAddress(hws2_32
, "WSALookupServiceNextW");
1237 pWSAEnumNameSpaceProvidersA
= (void *)GetProcAddress(hws2_32
, "WSAEnumNameSpaceProvidersA");
1238 pWSAEnumNameSpaceProvidersW
= (void *)GetProcAddress(hws2_32
, "WSAEnumNameSpaceProvidersW");
1239 pWSAPoll
= (void *)GetProcAddress(hws2_32
, "WSAPoll");
1241 hiphlpapi
= LoadLibraryA("iphlpapi.dll");
1244 pGetIpForwardTable
= (void *)GetProcAddress(hiphlpapi
, "GetIpForwardTable");
1245 pGetAdaptersInfo
= (void *)GetProcAddress(hiphlpapi
, "GetAdaptersInfo");
1248 ok ( WSAStartup ( ver
, &data
) == 0, "WSAStartup failed\n" );
1252 static void Exit (void)
1257 err
= WSAGetLastError();
1258 ok ( ret
== 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret
, err
);
1261 static void StartServer (LPTHREAD_START_ROUTINE routine
,
1262 test_params
*general
, server_params
*par
)
1264 par
->general
= general
;
1265 thread
[0] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[0] );
1266 ok ( thread
[0] != NULL
, "Failed to create server thread\n" );
1269 static void StartClients (LPTHREAD_START_ROUTINE routine
,
1270 test_params
*general
, client_params
*par
)
1273 par
->general
= general
;
1274 for ( i
= 1; i
<= min ( general
->n_clients
, MAX_CLIENTS
); i
++ )
1277 thread
[i
] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[i
] );
1278 ok ( thread
[i
] != NULL
, "Failed to create client thread\n" );
1279 /* Make sure the client is up and running */
1280 WaitForSingleObject ( client_ready
[client_id
], INFINITE
);
1284 static void do_test( test_setup
*test
)
1286 DWORD i
, n
= min (test
->general
.n_clients
, MAX_CLIENTS
);
1289 server_ready
= CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1290 for (i
= 0; i
<= n
; i
++)
1291 client_ready
[i
] = CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1293 StartServer ( test
->srv
, &test
->general
, &test
->srv_params
);
1294 StartClients ( test
->clt
, &test
->general
, &test
->clt_params
);
1295 WaitForSingleObject ( server_ready
, INFINITE
);
1297 wait
= WaitForMultipleObjects ( 1 + n
, thread
, TRUE
, 1000 * TEST_TIMEOUT
);
1298 ok ( wait
<= WAIT_OBJECT_0
+ n
,
1299 "some threads have not completed: %x\n", wait
);
1301 if ( ! ( wait
<= WAIT_OBJECT_0
+ n
) )
1303 for (i
= 0; i
<= n
; i
++)
1305 if ( WaitForSingleObject ( thread
[i
], 0 ) != WAIT_OBJECT_0
)
1307 trace ("terminating thread %08x\n", thread_id
[i
]);
1308 TerminateThread ( thread
[i
], 0 );
1312 CloseHandle ( server_ready
);
1313 for (i
= 0; i
<= n
; i
++)
1314 CloseHandle ( client_ready
[i
] );
1317 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1318 /* optname = SO_LINGER */
1319 static const LINGER linger_testvals
[] = {
1326 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1327 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1328 bug in the linux kernel (fixed in 2.6.8) */
1329 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1331 static void test_set_getsockopt(void)
1334 int i
, err
, lasterr
;
1338 WSAPROTOCOL_INFOA infoA
;
1339 WSAPROTOCOL_INFOW infoW
;
1340 char providername
[WSAPROTOCOL_LEN
+ 1];
1344 int family
, type
, proto
;
1346 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
1347 {AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
1348 {AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
},
1349 {AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
}
1357 s
= socket(AF_INET
, SOCK_STREAM
, 0);
1358 ok(s
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1359 if( s
== INVALID_SOCKET
) return;
1361 timeout
= SOCKTIMEOUT1
;
1362 size
= sizeof(timeout
);
1363 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1365 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1366 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1367 ok( timeout
== SOCKTIMEOUT1
, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1370 size
= sizeof(timeout
);
1371 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1373 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1374 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1375 ok( timeout
== 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1378 timeout
= SOCKTIMEOUT2
; /* 997 seconds. See remark above */
1379 size
= sizeof(timeout
);
1380 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, size
);
1382 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, &size
);
1383 ok( !err
, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1384 ok( timeout
== SOCKTIMEOUT2
, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout
);
1388 size
= sizeof(value
);
1389 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDBUF
, (char *)&value
, size
);
1390 ok( !err
, "setsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1392 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDBUF
, (char *)&value
, &size
);
1393 ok( !err
, "getsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1394 todo_wine
ok( value
== 4096, "expected 4096, got %u\n", value
);
1398 size
= sizeof(value
);
1399 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, size
);
1400 ok( !err
, "setsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1402 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, &size
);
1403 ok( !err
, "getsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1404 todo_wine
ok( value
== 4096, "expected 4096, got %u\n", value
);
1407 for( i
= 0; i
< sizeof(linger_testvals
)/sizeof(LINGER
);i
++) {
1408 size
= sizeof(lingval
);
1409 lingval
= linger_testvals
[i
];
1410 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *) &lingval
, size
);
1412 err
= getsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *) &lingval
, &size
);
1413 ok( !err
, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
1414 ok( !lingval
.l_onoff
== !linger_testvals
[i
].l_onoff
&&
1415 (lingval
.l_linger
== linger_testvals
[i
].l_linger
||
1416 (!lingval
.l_linger
&& !linger_testvals
[i
].l_onoff
))
1417 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i
,
1418 lingval
.l_onoff
, lingval
.l_linger
,
1419 linger_testvals
[i
].l_onoff
, linger_testvals
[i
].l_linger
);
1422 size
= sizeof(lingval
);
1423 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, size
);
1424 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1425 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1426 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, 0);
1427 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1428 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1430 size
= sizeof(BOOL
);
1431 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, size
);
1432 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1433 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1434 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, 0);
1435 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1436 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1438 /* Test for erroneously passing a value instead of a pointer as optval */
1439 size
= sizeof(char);
1440 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTROUTE
, (char *)1, size
);
1441 ok(err
== SOCKET_ERROR
, "setsockopt with optval being a value passed "
1442 "instead of failing.\n");
1443 lasterr
= WSAGetLastError();
1444 ok(lasterr
== WSAEFAULT
, "setsockopt with optval being a value "
1445 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1446 lasterr
, WSAEFAULT
);
1448 /* SO_RCVTIMEO with invalid values for level */
1449 size
= sizeof(timeout
);
1450 timeout
= SOCKTIMEOUT1
;
1451 SetLastError(0xdeadbeef);
1452 err
= setsockopt(s
, 0xffffffff, SO_RCVTIMEO
, (char *) &timeout
, size
);
1453 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1454 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1455 err
, WSAGetLastError());
1457 timeout
= SOCKTIMEOUT1
;
1458 SetLastError(0xdeadbeef);
1459 err
= setsockopt(s
, 0x00008000, SO_RCVTIMEO
, (char *) &timeout
, size
);
1460 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1461 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1462 err
, WSAGetLastError());
1464 /* Test SO_ERROR set/get */
1465 SetLastError(0xdeadbeef);
1467 err
= setsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, size
);
1469 ok( !err
&& !WSAGetLastError(),
1470 "got %d with %d (expected 0 with 0)\n",
1471 err
, WSAGetLastError());
1473 SetLastError(0xdeadbeef);
1475 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1477 ok( !err
&& !WSAGetLastError(),
1478 "got %d with %d (expected 0 with 0)\n",
1479 err
, WSAGetLastError());
1481 ok (i
== 1234, "got %d (expected 1234)\n", i
);
1483 /* Test invalid optlen */
1484 SetLastError(0xdeadbeef);
1486 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1488 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEFAULT
),
1489 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1490 err
, WSAGetLastError());
1493 /* Test with the closed socket */
1494 SetLastError(0xdeadbeef);
1497 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1499 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAENOTSOCK
),
1500 "got %d with %d (expected SOCKET_ERROR with WSAENOTSOCK)\n",
1501 err
, WSAGetLastError());
1502 ok (i
== 1234, "expected 1234, got %d\n", i
);
1504 /* Test WS_IP_MULTICAST_TTL with 8, 16, 24 and 32 bits values */
1505 s
= socket(AF_INET
, SOCK_DGRAM
, 0);
1506 ok(s
!= INVALID_SOCKET
, "Failed to create socket\n");
1509 err
= setsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &i
, size
);
1512 for (i
= 0; i
< 4; i
++)
1515 const int tests
[] = {0xffffff0a, 0xffff000b, 0xff00000c, 0x0000000d};
1516 err
= setsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &tests
[i
], i
+ 1);
1517 ok(!err
, "Test [%d] Expected 0, got %d\n", i
, err
);
1518 err
= getsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &k
, &size
);
1519 ok(!err
, "Test [%d] Expected 0, got %d\n", i
, err
);
1520 j
= i
!= 3 ? tests
[i
] & ((1 << (i
+ 1) * 8) - 1) : tests
[i
];
1521 ok(k
== j
, "Test [%d] Expected 0x%x, got 0x%x\n", i
, j
, k
);
1525 win_skip("IP_MULTICAST_TTL is unsupported\n");
1528 /* test SO_PROTOCOL_INFOA invalid parameters */
1529 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1530 "getsockopt should have failed\n");
1531 err
= WSAGetLastError();
1532 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1533 size
= sizeof(WSAPROTOCOL_INFOA
);
1534 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1535 "getsockopt should have failed\n");
1536 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1537 err
= WSAGetLastError();
1538 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1539 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1540 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1541 "getsockopt should have failed\n");
1542 err
= WSAGetLastError();
1543 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1544 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, NULL
),
1545 "getsockopt should have failed\n");
1546 err
= WSAGetLastError();
1547 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1548 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, &size
),
1549 "getsockopt should have failed\n");
1550 err
= WSAGetLastError();
1551 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1552 size
= sizeof(WSAPROTOCOL_INFOA
) / 2;
1553 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1554 "getsockopt should have failed\n");
1555 err
= WSAGetLastError();
1556 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1557 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1558 size
= sizeof(WSAPROTOCOL_INFOA
) * 2;
1559 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1560 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1561 ok(size
== sizeof(WSAPROTOCOL_INFOA
) * 2, "got size %d\n", size
);
1565 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1566 for (i
= 0; i
< sizeof(prottest
) / sizeof(prottest
[0]); i
++)
1570 s
= socket(prottest
[i
].family
, prottest
[i
].type
, prottest
[i
].proto
);
1571 if (s
== INVALID_SOCKET
&& prottest
[i
].family
== AF_INET6
) continue;
1573 ok(s
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
1576 /* compare both A and W version */
1577 infoA
.szProtocol
[0] = 0;
1578 size
= sizeof(WSAPROTOCOL_INFOA
);
1579 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1580 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1581 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1583 infoW
.szProtocol
[0] = 0;
1584 size
= sizeof(WSAPROTOCOL_INFOW
);
1585 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOW
, (char *) &infoW
, &size
);
1586 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1587 ok(size
== sizeof(WSAPROTOCOL_INFOW
), "got size %d\n", size
);
1589 trace("provider name '%s', family %d, type %d, proto %d\n",
1590 infoA
.szProtocol
, prottest
[i
].family
, prottest
[i
].type
, prottest
[i
].proto
);
1592 ok(infoA
.szProtocol
[0] || broken(!infoA
.szProtocol
[0]) /* NT4 */,
1593 "WSAPROTOCOL_INFOA was not filled\n");
1594 ok(infoW
.szProtocol
[0] || broken(!infoA
.szProtocol
[0]) /* NT4 */,
1595 "WSAPROTOCOL_INFOW was not filled\n");
1597 WideCharToMultiByte(CP_ACP
, 0, infoW
.szProtocol
, -1,
1598 providername
, sizeof(providername
), NULL
, NULL
);
1599 ok(!strcmp(infoA
.szProtocol
,providername
),
1600 "different provider names '%s' != '%s'\n", infoA
.szProtocol
, providername
);
1602 ok(!memcmp(&infoA
, &infoW
, FIELD_OFFSET(WSAPROTOCOL_INFOA
, szProtocol
)),
1603 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1605 /* Remove IF when WSAEnumProtocols support IPV6 data */
1606 todo_wine_if (prottest
[i
].family
== AF_INET6
)
1607 ok(infoA
.iAddressFamily
== prottest
[i
].family
, "socket family invalid, expected %d received %d\n",
1608 prottest
[i
].family
, infoA
.iAddressFamily
);
1609 ok(infoA
.iSocketType
== prottest
[i
].type
, "socket type invalid, expected %d received %d\n",
1610 prottest
[i
].type
, infoA
.iSocketType
);
1611 ok(infoA
.iProtocol
== prottest
[i
].proto
, "socket protocol invalid, expected %d received %d\n",
1612 prottest
[i
].proto
, infoA
.iProtocol
);
1614 /* IP_HDRINCL is supported only on SOCK_RAW but passed to SOCK_DGRAM by Impossible Creatures */
1617 SetLastError(0xdeadbeef);
1618 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1619 if (err
== -1) /* >= Vista */
1622 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1624 SetLastError(0xdeadbeef);
1625 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1626 ok(err
== -1, "Expected -1, got %d\n", err
);
1627 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1628 ok(k
== 99, "Expected 99, got %d\n", k
);
1632 SetLastError(0xdeadbeef);
1633 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1635 ok(err
== -1, "Expected -1, got %d\n", err
);
1637 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1639 SetLastError(0xdeadbeef);
1640 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1641 ok(err
== -1, "Expected -1, got %d\n", err
);
1642 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1643 ok(k
== 99, "Expected 99, got %d\n", k
);
1646 else /* <= 2003 the tests differ between TCP and UDP, UDP silenty accepts */
1648 SetLastError(0xdeadbeef);
1650 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1651 if (prottest
[i
].type
== SOCK_DGRAM
)
1653 ok(err
== 0, "Expected 0, got %d\n", err
);
1654 ok(k
== 1, "Expected 1, got %d\n", k
);
1658 /* contratry to what we could expect the function returns error but k is changed */
1659 ok(err
== -1, "Expected -1, got %d\n", err
);
1660 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %d\n", GetLastError());
1661 ok(k
== 0, "Expected 0, got %d\n", k
);
1665 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1666 ok(err
== 0, "Expected 0, got %d\n", err
);
1669 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1670 if (prottest
[i
].type
== SOCK_DGRAM
)
1672 ok(err
== 0, "Expected 0, got %d\n", err
);
1673 ok(k
== 0, "Expected 0, got %d\n", k
);
1677 /* contratry to what we could expect the function returns error but k is changed */
1678 ok(err
== -1, "Expected -1, got %d\n", err
);
1679 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %d\n", GetLastError());
1680 ok(k
== 0, "Expected 0, got %d\n", k
);
1687 /* Test SO_BSP_STATE - Present only in >= Win 2008 */
1688 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1689 ok(s
!= INVALID_SOCKET
, "Failed to create socket\n");
1690 s2
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1691 ok(s2
!= INVALID_SOCKET
, "Failed to create socket\n");
1693 SetLastError(0xdeadbeef);
1694 size
= sizeof(csinfoA
);
1695 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1698 struct sockaddr_in saddr
;
1699 memset(&saddr
, 0, sizeof(saddr
));
1700 saddr
.sin_family
= AF_INET
;
1701 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1703 /* Socket is not bound, no information provided */
1704 ok(!csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1705 ok(csinfoA
.cs
.LocalAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.LocalAddr
.lpSockaddr
);
1706 /* Socket is not connected, no information provided */
1707 ok(!csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1708 ok(csinfoA
.cs
.RemoteAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.LocalAddr
.lpSockaddr
);
1710 err
= bind(s
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1711 ok(!err
, "Expected 0, got %d\n", err
);
1712 size
= sizeof(csinfoA
);
1713 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1714 ok(!err
, "Expected 0, got %d\n", err
);
1716 /* Socket is bound */
1717 ok(csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected non-zero\n");
1718 ok(csinfoA
.cs
.LocalAddr
.lpSockaddr
!= NULL
, "Expected non-null\n");
1719 /* Socket is not connected, no information provided */
1720 ok(!csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1721 ok(csinfoA
.cs
.RemoteAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.LocalAddr
.lpSockaddr
);
1723 err
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1724 ok(!err
, "Expected 0, got %d\n", err
);
1725 err
= getsockname(s2
, (struct sockaddr
*)&saddr
, &size
);
1726 ok(!err
, "Expected 0, got %d\n", err
);
1727 err
= listen(s2
, 1);
1728 ok(!err
, "Expected 0, got %d\n", err
);
1729 err
= connect(s
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1730 ok(!err
, "Expected 0, got %d\n", err
);
1731 size
= sizeof(saddr
);
1732 err
= accept(s2
, (struct sockaddr
*)&saddr
, &size
);
1733 ok(err
!= INVALID_SOCKET
, "Failed to accept socket\n");
1737 size
= sizeof(csinfoA
);
1738 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1739 ok(!err
, "Expected 0, got %d\n", err
);
1740 err
= getsockopt(s2
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoB
, &size
);
1741 ok(!err
, "Expected 0, got %d\n", err
);
1742 ok(size
== sizeof(csinfoA
), "Got %d\n", size
);
1743 size
= sizeof(saddr
);
1744 ok(size
== csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected %d, got %d\n", size
,
1745 csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1746 ok(size
== csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected %d, got %d\n", size
,
1747 csinfoA
.cs
.RemoteAddr
.iSockaddrLength
);
1748 ok(!memcmp(csinfoA
.cs
.LocalAddr
.lpSockaddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
),
1749 "Expected matching addresses\n");
1750 ok(!memcmp(csinfoB
.cs
.LocalAddr
.lpSockaddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
),
1751 "Expected matching addresses\n");
1752 ok(csinfoA
.cs
.iSocketType
== SOCK_STREAM
, "Wrong socket type\n");
1753 ok(csinfoB
.cs
.iSocketType
== SOCK_STREAM
, "Wrong socket type\n");
1754 ok(csinfoA
.cs
.iProtocol
== IPPROTO_TCP
, "Wrong socket protocol\n");
1755 ok(csinfoB
.cs
.iProtocol
== IPPROTO_TCP
, "Wrong socket protocol\n");
1757 err
= getpeername(s
, (struct sockaddr
*)&saddr
, &size
);
1758 ok(!err
, "Expected 0, got %d\n", err
);
1759 ok(!memcmp(&saddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1760 ok(!memcmp(&saddr
, csinfoB
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1761 err
= getpeername(s2
, (struct sockaddr
*)&saddr
, &size
);
1762 ok(!err
, "Expected 0, got %d\n", err
);
1763 ok(!memcmp(&saddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1764 ok(!memcmp(&saddr
, csinfoA
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1765 err
= getsockname(s
, (struct sockaddr
*)&saddr
, &size
);
1766 ok(!err
, "Expected 0, got %d\n", err
);
1767 ok(!memcmp(&saddr
, csinfoA
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1768 ok(!memcmp(&saddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1769 err
= getsockname(s2
, (struct sockaddr
*)&saddr
, &size
);
1770 ok(!err
, "Expected 0, got %d\n", err
);
1771 ok(!memcmp(&saddr
, csinfoB
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1772 ok(!memcmp(&saddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1774 SetLastError(0xdeadbeef);
1775 size
= sizeof(CSADDR_INFO
);
1776 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1777 ok(err
, "Expected non-zero\n");
1778 ok(size
== sizeof(CSADDR_INFO
), "Got %d\n", size
);
1779 ok(GetLastError() == WSAEFAULT
, "Expected 10014, got %d\n", GetLastError());
1781 /* At least for IPv4 the size is exactly 56 bytes */
1782 size
= sizeof(*csinfoA
.cs
.LocalAddr
.lpSockaddr
) * 2 + sizeof(csinfoA
.cs
);
1783 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1784 ok(!err
, "Expected 0, got %d\n", err
);
1786 SetLastError(0xdeadbeef);
1787 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1788 ok(err
, "Expected non-zero\n");
1789 ok(GetLastError() == WSAEFAULT
, "Expected 10014, got %d\n", GetLastError());
1792 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %d\n", GetLastError());
1797 for (i
= 0; i
< 2; i
++)
1804 level
= IPPROTO_IPV6
;
1812 s
= socket(family
, SOCK_DGRAM
, 0);
1813 if (s
== INVALID_SOCKET
&& i
)
1815 skip("IPv6 is not supported\n");
1818 ok(s
!= INVALID_SOCKET
, "socket failed with error %d\n", GetLastError());
1820 size
= sizeof(value
);
1822 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1823 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1824 ok(value
== 0, "Expected 0, got %d\n", value
);
1826 size
= sizeof(value
);
1828 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
1829 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1832 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1833 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1834 ok(value
== 1, "Expected 1, got %d\n", value
);
1836 size
= sizeof(value
);
1838 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
1839 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1841 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1842 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1843 ok(value
== 1, "Expected 1, got %d\n", value
);
1849 static void test_so_reuseaddr(void)
1851 struct sockaddr_in saddr
;
1853 unsigned int rc
,reuse
;
1857 saddr
.sin_family
= AF_INET
;
1858 saddr
.sin_port
= htons(SERVERPORT
+1);
1859 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1861 s1
=socket(AF_INET
, SOCK_STREAM
, 0);
1862 ok(s1
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1863 rc
= bind(s1
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1864 ok(rc
!=SOCKET_ERROR
, "bind(s1) failed error: %d\n", WSAGetLastError());
1866 s2
=socket(AF_INET
, SOCK_STREAM
, 0);
1867 ok(s2
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1871 rc
=getsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, &size
);
1872 ok(rc
==0 && reuse
==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc
,reuse
);
1874 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1875 ok(rc
==SOCKET_ERROR
, "bind() succeeded\n");
1878 rc
= setsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
1879 ok(rc
==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1881 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1882 * a port immediately after closing another socket on that port, so
1883 * basically following the BSD socket semantics here. */
1884 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1887 int s3
=socket(AF_INET
, SOCK_STREAM
, 0), s4
;
1888 trace("<= Win XP behavior of SO_REUSEADDR\n");
1890 /* If we could bind again in the same port this is Windows version <= XP.
1891 * Lets test if we can really connect to one of them. */
1892 set_blocking(s1
, FALSE
);
1893 set_blocking(s2
, FALSE
);
1895 ok(!rc
, "listen() failed with error: %d\n", WSAGetLastError());
1897 ok(!rc
, "listen() failed with error: %d\n", WSAGetLastError());
1898 rc
= connect(s3
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1899 ok(!rc
, "connecting to accepting socket failed %d\n", WSAGetLastError());
1901 /* the delivery of the connection is random so we need to try on both sockets */
1902 size
= sizeof(saddr
);
1903 s4
= accept(s1
, (struct sockaddr
*)&saddr
, &size
);
1904 if(s4
== INVALID_SOCKET
)
1905 s4
= accept(s2
, (struct sockaddr
*)&saddr
, &size
);
1906 ok(s4
!= INVALID_SOCKET
, "none of the listening sockets could get the connection\n");
1914 trace(">= Win 2003 behavior of SO_REUSEADDR\n");
1915 err
= WSAGetLastError();
1916 ok(err
==WSAEACCES
, "expected 10013, got %d\n", err
);
1919 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1920 ok(rc
==0, "bind() failed error: %d\n", WSAGetLastError());
1926 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
1928 static void test_ip_pktinfo(void)
1930 ULONG addresses
[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY
)};
1931 char recvbuf
[10], pktbuf
[512], msg
[] = "HELLO";
1932 struct sockaddr_in s1addr
, s2addr
, s3addr
;
1933 GUID WSARecvMsg_GUID
= WSAID_WSARECVMSG
;
1934 LPFN_WSARECVMSG pWSARecvMsg
= NULL
;
1935 unsigned int rc
, yes
= 1;
1937 DWORD dwBytes
, dwSize
, dwFlags
;
1946 memset(&ov
, 0, sizeof(ov
));
1947 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
1948 if (ov
.hEvent
== INVALID_HANDLE_VALUE
)
1950 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
1954 memset(&hdr
, 0x00, sizeof(hdr
));
1955 s1addr
.sin_family
= AF_INET
;
1956 s1addr
.sin_port
= htons(0);
1957 /* Note: s1addr.sin_addr is set below */
1958 iovec
[0].buf
= recvbuf
;
1959 iovec
[0].len
= sizeof(recvbuf
);
1960 hdr
.name
= (struct sockaddr
*)&s3addr
;
1961 hdr
.namelen
= sizeof(s3addr
);
1962 hdr
.lpBuffers
= &iovec
[0];
1963 hdr
.dwBufferCount
= 1;
1964 hdr
.Control
.buf
= pktbuf
;
1965 /* Note: hdr.Control.len is set below */
1968 for (i
=0;i
<sizeof(addresses
)/sizeof(UINT32
);i
++)
1970 s1addr
.sin_addr
.s_addr
= addresses
[i
];
1972 /* Build "server" side socket */
1973 s1
=socket(AF_INET
, SOCK_DGRAM
, 0);
1974 if (s1
== INVALID_SOCKET
)
1976 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1980 /* Obtain the WSARecvMsg function */
1981 WSAIoctl(s1
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSARecvMsg_GUID
, sizeof(WSARecvMsg_GUID
),
1982 &pWSARecvMsg
, sizeof(pWSARecvMsg
), &dwBytes
, NULL
, NULL
);
1985 win_skip("WSARecvMsg is unsupported, some tests will be skipped.\n");
1990 /* Setup the server side socket */
1991 rc
=bind(s1
, (struct sockaddr
*)&s1addr
, sizeof(s1addr
));
1992 ok(rc
!= SOCKET_ERROR
, "bind() failed error: %d\n", WSAGetLastError());
1993 rc
=setsockopt(s1
, IPPROTO_IP
, IP_PKTINFO
, (const char*)&yes
, sizeof(yes
));
1994 ok(rc
== 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
1996 /* Build "client" side socket */
1997 addrlen
= sizeof(s2addr
);
1998 if (getsockname(s1
, (struct sockaddr
*) &s2addr
, &addrlen
) != 0)
2000 skip("Failed to call getsockname, some tests skipped: %d\n", WSAGetLastError());
2004 s2addr
.sin_addr
.s_addr
= addresses
[0]; /* Always target the local adapter address */
2005 s2
=socket(AF_INET
, SOCK_DGRAM
, 0);
2006 if (s2
== INVALID_SOCKET
)
2008 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
2013 /* Test an empty message header */
2014 rc
=pWSARecvMsg(s1
, NULL
, NULL
, NULL
, NULL
);
2015 err
=WSAGetLastError();
2016 ok(rc
== SOCKET_ERROR
&& err
== WSAEFAULT
, "WSARecvMsg() failed error: %d (ret = %d)\n", err
, rc
);
2019 * Send a packet from the client to the server and test for specifying
2020 * a short control header.
2022 SetLastError(0xdeadbeef);
2023 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
2024 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
2025 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
2026 hdr
.Control
.len
= 1;
2027 rc
=pWSARecvMsg(s1
, &hdr
, &dwSize
, NULL
, NULL
);
2028 err
=WSAGetLastError();
2029 ok(rc
== SOCKET_ERROR
&& err
== WSAEMSGSIZE
&& (hdr
.dwFlags
& MSG_CTRUNC
),
2030 "WSARecvMsg() failed error: %d (ret: %d, flags: %d)\n", err
, rc
, hdr
.dwFlags
);
2031 hdr
.dwFlags
= 0; /* Reset flags */
2033 /* Perform another short control header test, this time with an overlapped receive */
2034 hdr
.Control
.len
= 1;
2035 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
2036 err
=WSAGetLastError();
2037 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
2038 SetLastError(0xdeadbeef);
2039 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
2040 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
2041 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
2042 if (WaitForSingleObject(ov
.hEvent
, 100) != WAIT_OBJECT_0
)
2044 skip("Server side did not receive packet, some tests skipped.\n");
2050 WSAGetOverlappedResult(s1
, &ov
, NULL
, FALSE
, &dwFlags
);
2052 "WSAGetOverlappedResult() returned unexpected flags %d!\n", dwFlags
);
2053 ok(hdr
.dwFlags
== MSG_CTRUNC
,
2054 "WSARecvMsg() overlapped operation set unexpected flags %d.\n", hdr
.dwFlags
);
2055 hdr
.dwFlags
= 0; /* Reset flags */
2058 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
2059 * on the server end and check that the returned packet matches what was sent.
2061 hdr
.Control
.len
= sizeof(pktbuf
);
2062 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
2063 err
=WSAGetLastError();
2064 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
2065 ok(hdr
.Control
.len
== sizeof(pktbuf
),
2066 "WSARecvMsg() control length mismatch (%d != sizeof pktbuf).\n", hdr
.Control
.len
);
2067 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
2068 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
2069 if (WaitForSingleObject(ov
.hEvent
, 100) != WAIT_OBJECT_0
)
2071 skip("Server side did not receive packet, some tests skipped.\n");
2077 WSAGetOverlappedResult(s1
, &ov
, &dwSize
, FALSE
, NULL
);
2078 ok(dwSize
== sizeof(msg
),
2079 "WSARecvMsg() buffer length does not match transmitted data!\n");
2080 ok(strncmp(iovec
[0].buf
, msg
, sizeof(msg
)) == 0,
2081 "WSARecvMsg() buffer does not match transmitted data!\n");
2082 ok(hdr
.Control
.len
== IP_PKTINFO_LEN
,
2083 "WSARecvMsg() control length mismatch (%d).\n", hdr
.Control
.len
);
2085 /* Test for the expected IP_PKTINFO return information. */
2087 for (cmsg
= WSA_CMSG_FIRSTHDR(&hdr
); cmsg
!= NULL
; cmsg
= WSA_CMSG_NXTHDR(&hdr
, cmsg
))
2089 if (cmsg
->cmsg_level
== IPPROTO_IP
&& cmsg
->cmsg_type
== IP_PKTINFO
)
2091 struct in_pktinfo
*pi
= (struct in_pktinfo
*)WSA_CMSG_DATA(cmsg
);
2093 ok(pi
->ipi_addr
.s_addr
== s2addr
.sin_addr
.s_addr
, "destination ip mismatch!\n");
2097 ok(foundhdr
, "IP_PKTINFO header information was not returned!\n");
2104 CloseHandle(ov
.hEvent
);
2107 /************* Array containing the tests to run **********/
2109 #define STD_STREAM_SOCKET \
2115 static test_setup tests
[] =
2117 /* Test 0: synchronous client and server */
2138 /* Test 1: event-driven client, synchronous server */
2155 WSA_FLAG_OVERLAPPED
,
2159 /* Test 2: synchronous client, non-blocking server via select() */
2180 /* Test 3: OOB client, OOB server */
2201 /* Test 4: synchronous mixed client and server */
2215 simple_mixed_client
,
2224 static void test_UDP(void)
2226 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
2227 possible that this test fails due to dropped packets. */
2229 /* peer 0 receives data from all other peers */
2230 struct sock_info peer
[NUM_UDP_PEERS
];
2232 int ss
, i
, n_recv
, n_sent
;
2234 memset (buf
,0,sizeof(buf
));
2235 for ( i
= NUM_UDP_PEERS
- 1; i
>= 0; i
-- ) {
2236 ok ( ( peer
[i
].s
= socket ( AF_INET
, SOCK_DGRAM
, 0 ) ) != INVALID_SOCKET
, "UDP: socket failed\n" );
2238 peer
[i
].addr
.sin_family
= AF_INET
;
2239 peer
[i
].addr
.sin_addr
.s_addr
= inet_addr ( SERVERIP
);
2242 peer
[i
].addr
.sin_port
= htons ( SERVERPORT
);
2244 peer
[i
].addr
.sin_port
= htons ( 0 );
2247 do_bind ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, sizeof( peer
[i
].addr
) );
2249 /* test getsockname() to get peer's port */
2250 ss
= sizeof ( peer
[i
].addr
);
2251 ok ( getsockname ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, &ss
) != SOCKET_ERROR
, "UDP: could not getsockname()\n" );
2252 ok ( peer
[i
].addr
.sin_port
!= htons ( 0 ), "UDP: bind() did not associate port\n" );
2255 /* test getsockname() */
2256 ok ( peer
[0].addr
.sin_port
== htons ( SERVERPORT
), "UDP: getsockname returned incorrect peer port\n" );
2258 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
2259 /* send client's ip */
2260 memcpy( buf
, &peer
[i
].addr
.sin_port
, sizeof(peer
[i
].addr
.sin_port
) );
2261 n_sent
= sendto ( peer
[i
].s
, buf
, sizeof(buf
), 0, (struct sockaddr
*) &peer
[0].addr
, sizeof(peer
[0].addr
) );
2262 ok ( n_sent
== sizeof(buf
), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent
);
2265 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
2266 n_recv
= recvfrom ( peer
[0].s
, buf
, sizeof(buf
), 0,(struct sockaddr
*) &peer
[0].peer
, &ss
);
2267 ok ( n_recv
== sizeof(buf
), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv
);
2268 ok ( memcmp ( &peer
[0].peer
.sin_port
, buf
, sizeof(peer
[0].addr
.sin_port
) ) == 0, "UDP: port numbers do not match\n" );
2272 static DWORD WINAPI
do_getservbyname( void *param
)
2278 } serv
[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
2280 HANDLE
*starttest
= param
;
2282 struct servent
*pserv
[2];
2284 ok ( WaitForSingleObject ( *starttest
, TEST_TIMEOUT
* 1000 ) != WAIT_TIMEOUT
,
2285 "test_getservbyname: timeout waiting for start signal\n" );
2287 /* ensure that necessary buffer resizes are completed */
2288 for ( j
= 0; j
< 2; j
++) {
2289 pserv
[j
] = getservbyname ( serv
[j
].name
, serv
[j
].proto
);
2292 for ( i
= 0; i
< NUM_QUERIES
/ 2; i
++ ) {
2293 for ( j
= 0; j
< 2; j
++ ) {
2294 pserv
[j
] = getservbyname ( serv
[j
].name
, serv
[j
].proto
);
2295 ok ( pserv
[j
] != NULL
|| broken(pserv
[j
] == NULL
) /* win8, fixed in win81 */,
2296 "getservbyname could not retrieve information for %s: %d\n", serv
[j
].name
, WSAGetLastError() );
2297 if ( !pserv
[j
] ) continue;
2298 ok ( pserv
[j
]->s_port
== htons(serv
[j
].port
),
2299 "getservbyname returned the wrong port for %s: %d\n", serv
[j
].name
, ntohs(pserv
[j
]->s_port
) );
2300 ok ( !strcmp ( pserv
[j
]->s_proto
, serv
[j
].proto
),
2301 "getservbyname returned the wrong protocol for %s: %s\n", serv
[j
].name
, pserv
[j
]->s_proto
);
2302 ok ( !strcmp ( pserv
[j
]->s_name
, serv
[j
].name
),
2303 "getservbyname returned the wrong name for %s: %s\n", serv
[j
].name
, pserv
[j
]->s_name
);
2306 ok ( pserv
[0] == pserv
[1] || broken(pserv
[0] != pserv
[1]) /* win8, fixed in win81 */,
2307 "getservbyname: winsock resized servent buffer when not necessary\n" );
2313 static void test_getservbyname(void)
2316 HANDLE starttest
, thread
[NUM_THREADS
];
2317 DWORD thread_id
[NUM_THREADS
];
2319 starttest
= CreateEventA ( NULL
, 1, 0, "test_getservbyname_starttest" );
2321 /* create threads */
2322 for ( i
= 0; i
< NUM_THREADS
; i
++ ) {
2323 thread
[i
] = CreateThread ( NULL
, 0, do_getservbyname
, &starttest
, 0, &thread_id
[i
] );
2326 /* signal threads to start */
2327 SetEvent ( starttest
);
2329 for ( i
= 0; i
< NUM_THREADS
; i
++) {
2330 WaitForSingleObject ( thread
[i
], TEST_TIMEOUT
* 1000 );
2334 static void test_WSASocket(void)
2336 SOCKET sock
= INVALID_SOCKET
;
2337 WSAPROTOCOL_INFOA
*pi
;
2338 int wsaproviders
[] = {IPPROTO_TCP
, IPPROTO_IP
};
2339 int autoprotocols
[] = {IPPROTO_TCP
, IPPROTO_UDP
};
2340 int items
, err
, size
, socktype
, i
, j
;
2343 SetLastError(0xdeadbeef);
2344 ok(WSASocketA(0, 0, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2345 "WSASocketA should have failed\n");
2346 err
= WSAGetLastError();
2347 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
2349 sock
= WSASocketA(AF_INET
, 0, 0, NULL
, 0, 0);
2350 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2353 sock
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, NULL
, 0, 0);
2354 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2357 SetLastError(0xdeadbeef);
2358 ok(WSASocketA(0, SOCK_STREAM
, -1, NULL
, 0, 0) == INVALID_SOCKET
,
2359 "WSASocketA should have failed\n");
2360 err
= WSAGetLastError();
2361 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2363 SetLastError(0xdeadbeef);
2364 ok(WSASocketA(0, -1, IPPROTO_UDP
, NULL
, 0, 0) == INVALID_SOCKET
,
2365 "WSASocketA should have failed\n");
2366 err
= WSAGetLastError();
2367 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
2369 SetLastError(0xdeadbeef);
2370 ok(WSASocketA(0, -1, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2371 "WSASocketA should have failed\n");
2372 err
= WSAGetLastError();
2373 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
2375 SetLastError(0xdeadbeef);
2376 ok(WSASocketA(AF_INET
, -1, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2377 "WSASocketA should have failed\n");
2378 err
= WSAGetLastError();
2379 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
2381 SetLastError(0xdeadbeef);
2382 ok(WSASocketA(AF_INET
, 0, -1, NULL
, 0, 0) == INVALID_SOCKET
,
2383 "WSASocketA should have failed\n");
2384 err
= WSAGetLastError();
2385 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2387 SetLastError(0xdeadbeef);
2388 ok(WSASocketA(0, -1, -1, NULL
, 0, 0) == INVALID_SOCKET
,
2389 "WSASocketA should have failed\n");
2390 err
= WSAGetLastError();
2391 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
2393 SetLastError(0xdeadbeef);
2394 ok(WSASocketA(-1, SOCK_STREAM
, IPPROTO_UDP
, NULL
, 0, 0) == INVALID_SOCKET
,
2395 "WSASocketA should have failed\n");
2396 err
= WSAGetLastError();
2397 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
2399 sock
= WSASocketA(AF_INET
, 0, IPPROTO_TCP
, NULL
, 0, 0);
2400 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2403 SetLastError(0xdeadbeef);
2404 ok(WSASocketA(0, SOCK_STREAM
, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2405 "WSASocketA should have failed\n");
2406 err
= WSAGetLastError();
2407 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
2409 SetLastError(0xdeadbeef);
2410 ok(WSASocketA(0, 0, 0xdead, NULL
, 0, 0) == INVALID_SOCKET
,
2411 "WSASocketA should have failed\n");
2412 err
= WSAGetLastError();
2413 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2415 SetLastError(0xdeadbeef);
2416 ok(WSASocketA(AF_INET
, 0xdead, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2417 "WSASocketA should have failed\n");
2418 err
= WSAGetLastError();
2419 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
2421 SetLastError(0xdeadbeef);
2422 ok(WSASocketA(0, 0xdead, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2423 "WSASocketA should have failed\n");
2424 err
= WSAGetLastError();
2425 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
2427 sock
= WSASocketA(0, 0, IPPROTO_TCP
, NULL
, 0, 0);
2428 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2431 /* SOCK_STREAM does not support IPPROTO_UDP */
2432 SetLastError(0xdeadbeef);
2433 ok(WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_UDP
, NULL
, 0, 0) == INVALID_SOCKET
,
2434 "WSASocketA should have failed\n");
2435 err
= WSAGetLastError();
2436 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2438 /* SOCK_DGRAM does not support IPPROTO_TCP */
2439 SetLastError(0xdeadbeef);
2440 ok(WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_TCP
, NULL
, 0, 0) == INVALID_SOCKET
,
2441 "WSASocketA should have failed\n");
2442 err
= WSAGetLastError();
2443 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2445 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
2446 * to avoid a crash on win98.
2449 items
= WSAEnumProtocolsA(wsaproviders
, NULL
, &pi_size
);
2450 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
2452 err
= WSAGetLastError();
2453 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2456 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
2457 ok(pi
!= NULL
, "Failed to allocate memory\n");
2459 skip("Can't continue without memory.\n");
2463 items
= WSAEnumProtocolsA(wsaproviders
, pi
, &pi_size
);
2464 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
2468 skip("No protocols enumerated.\n");
2469 HeapFree(GetProcessHeap(), 0, pi
);
2473 sock
= WSASocketA(FROM_PROTOCOL_INFO
, FROM_PROTOCOL_INFO
,
2474 FROM_PROTOCOL_INFO
, &pi
[0], 0, 0);
2475 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2479 /* find what parameters are used first: plain parameters or protocol info struct */
2480 pi
[0].iProtocol
= -1;
2481 pi
[0].iSocketType
= -1;
2482 pi
[0].iAddressFamily
= -1;
2483 ok(WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0) == INVALID_SOCKET
,
2484 "WSASocketA should have failed\n");
2485 err
= WSAGetLastError();
2486 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
2488 pi
[0].iProtocol
= 0;
2489 pi
[0].iSocketType
= 0;
2490 pi
[0].iAddressFamily
= 0;
2491 sock
= WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0);
2492 if(sock
!= INVALID_SOCKET
)
2494 win_skip("must work only in OS <= 2003\n");
2499 err
= WSAGetLastError();
2500 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
2503 pi
[0].iProtocol
= IPPROTO_UDP
;
2504 pi
[0].iSocketType
= SOCK_DGRAM
;
2505 pi
[0].iAddressFamily
= AF_INET
;
2506 sock
= WSASocketA(0, 0, 0, &pi
[0], 0, 0);
2507 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2509 size
= sizeof(socktype
);
2511 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2512 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2513 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2514 SOCK_DGRAM
, socktype
);
2517 sock
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, &pi
[0], 0, 0);
2518 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2520 size
= sizeof(socktype
);
2522 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2523 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2524 ok(socktype
== SOCK_STREAM
, "Wrong socket type, expected %d received %d\n",
2525 SOCK_STREAM
, socktype
);
2528 HeapFree(GetProcessHeap(), 0, pi
);
2531 items
= WSAEnumProtocolsA(NULL
, NULL
, &pi_size
);
2532 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
2534 err
= WSAGetLastError();
2535 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2538 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
2539 ok(pi
!= NULL
, "Failed to allocate memory\n");
2541 skip("Can't continue without memory.\n");
2545 items
= WSAEnumProtocolsA(NULL
, pi
, &pi_size
);
2546 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
2549 /* when no protocol and socket type are specified the first entry
2550 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
2552 sock
= WSASocketA(AF_INET
, 0, 0, NULL
, 0, 0);
2553 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2556 size
= sizeof(socktype
);
2558 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2559 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2560 for(i
= 0; i
< items
; i
++)
2562 if(pi
[i
].dwProviderFlags
& PFL_MATCHES_PROTOCOL_ZERO
)
2564 ok(socktype
== pi
[i
].iSocketType
, "Wrong socket type, expected %d received %d\n",
2565 pi
[i
].iSocketType
, socktype
);
2569 ok(i
!= items
, "Creating a socket without protocol and socket type didn't work\n");
2572 /* when no socket type is specified the first entry from WSAEnumProtocols
2573 * that matches the protocol is returned */
2574 for (i
= 0; i
< sizeof(autoprotocols
) / sizeof(autoprotocols
[0]); i
++)
2576 sock
= WSASocketA(0, 0, autoprotocols
[i
], NULL
, 0, 0);
2577 ok(sock
!= INVALID_SOCKET
, "Failed to create socket for protocol %d, received %d\n",
2578 autoprotocols
[i
], WSAGetLastError());
2580 size
= sizeof(socktype
);
2582 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2583 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2585 for (err
= 1, j
= 0; j
< items
; j
++)
2587 if (pi
[j
].iProtocol
== autoprotocols
[i
])
2589 if (socktype
== pi
[j
].iSocketType
)
2592 ok(0, "Wrong socket type, expected %d received %d\n",
2593 pi
[j
].iSocketType
, socktype
);
2597 ok(!err
, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols
[i
]);
2602 HeapFree(GetProcessHeap(), 0, pi
);
2604 SetLastError(0xdeadbeef);
2605 /* starting on vista the socket function returns error during the socket
2606 creation and no longer in the socket operations (sendto, readfrom) */
2607 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_ICMP
, NULL
, 0, 0);
2608 if (sock
== INVALID_SOCKET
)
2610 err
= WSAGetLastError();
2611 ok(err
== WSAEACCES
, "Expected 10013, received %d\n", err
);
2612 skip("SOCK_RAW is not supported\n");
2616 trace("SOCK_RAW is supported\n");
2618 size
= sizeof(socktype
);
2620 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2621 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2622 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2623 SOCK_RAW
, socktype
);
2627 sock
= WSASocketA(0, 0, IPPROTO_RAW
, NULL
, 0, 0);
2628 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2630 size
= sizeof(socktype
);
2632 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2633 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2634 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2635 SOCK_RAW
, socktype
);
2639 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_TCP
, NULL
, 0, 0);
2640 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2642 size
= sizeof(socktype
);
2644 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2645 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2646 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2647 SOCK_RAW
, socktype
);
2651 /* IPX socket tests */
2653 SetLastError(0xdeadbeef);
2654 sock
= WSASocketA(AF_IPX
, SOCK_DGRAM
, NSPROTO_IPX
, NULL
, 0, 0);
2655 if (sock
== INVALID_SOCKET
)
2657 err
= WSAGetLastError();
2658 ok(err
== WSAEAFNOSUPPORT
|| broken(err
== WSAEPROTONOSUPPORT
), "Expected 10047, received %d\n", err
);
2659 skip("IPX is not supported\n");
2663 WSAPROTOCOL_INFOA info
;
2666 trace("IPX is supported\n");
2668 sock
= WSASocketA(0, 0, NSPROTO_IPX
, NULL
, 0, 0);
2669 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2672 size
= sizeof(socktype
);
2674 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2675 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2676 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2677 SOCK_DGRAM
, socktype
);
2679 /* check socket family, type and protocol */
2680 size
= sizeof(WSAPROTOCOL_INFOA
);
2681 err
= getsockopt(sock
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &info
, &size
);
2682 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2683 ok(info
.iProtocol
== NSPROTO_IPX
, "expected protocol %d, received %d\n",
2684 NSPROTO_IPX
, info
.iProtocol
);
2685 ok(info
.iAddressFamily
== AF_IPX
, "expected family %d, received %d\n",
2686 AF_IPX
, info
.iProtocol
);
2687 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
2688 SOCK_DGRAM
, info
.iSocketType
);
2691 /* SOCK_STREAM does not support NSPROTO_IPX */
2692 SetLastError(0xdeadbeef);
2693 ok(WSASocketA(AF_IPX
, SOCK_STREAM
, NSPROTO_IPX
, NULL
, 0, 0) == INVALID_SOCKET
,
2694 "WSASocketA should have failed\n");
2695 err
= WSAGetLastError();
2696 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2698 /* test extended IPX support - that is adding any number between 0 and 255
2699 * to the IPX protocol value will make it be used as IPX packet type */
2700 for(i
= 0;i
<= 255;i
+= 17)
2702 SetLastError(0xdeadbeef);
2703 sock
= WSASocketA(0, 0, NSPROTO_IPX
+ i
, NULL
, 0, 0);
2704 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2709 err
= getsockopt(sock
, NSPROTO_IPX
, IPX_PTYPE
, (char *) &socktype
, &size
);
2710 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2711 ok(socktype
== i
, "Wrong IPX packet type, expected %d received %d\n",
2719 static void test_WSADuplicateSocket(void)
2721 SOCKET source
, dupsock
;
2722 WSAPROTOCOL_INFOA info
;
2724 struct sockaddr_in addr
;
2725 int socktype
, size
, addrsize
, ret
;
2726 char teststr
[] = "TEST", buffer
[16];
2728 source
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
2729 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2731 /* test invalid parameters */
2732 SetLastError(0xdeadbeef);
2733 ok(WSADuplicateSocketA(0, 0, NULL
), "WSADuplicateSocketA should have failed\n");
2734 err
= WSAGetLastError();
2735 ok(err
== WSAENOTSOCK
, "expected 10038, received %d\n", err
);
2737 SetLastError(0xdeadbeef);
2738 ok(WSADuplicateSocketA(source
, 0, NULL
),
2739 "WSADuplicateSocketA should have failed\n");
2740 err
= WSAGetLastError();
2741 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2743 SetLastError(0xdeadbeef);
2744 ok(WSADuplicateSocketA(source
, ~0, &info
),
2745 "WSADuplicateSocketA should have failed\n");
2746 err
= WSAGetLastError();
2747 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2749 SetLastError(0xdeadbeef);
2750 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info
),
2751 "WSADuplicateSocketA should have failed\n");
2752 err
= WSAGetLastError();
2753 ok(err
== WSAENOTSOCK
, "expected 10038, received %d\n", err
);
2755 SetLastError(0xdeadbeef);
2756 ok(WSADuplicateSocketA(source
, GetCurrentProcessId(), NULL
),
2757 "WSADuplicateSocketA should have failed\n");
2758 err
= WSAGetLastError();
2759 ok(err
== WSAEFAULT
, "expected 10014, received %d\n", err
);
2761 /* test returned structure */
2762 memset(&info
, 0, sizeof(info
));
2763 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2764 "WSADuplicateSocketA should have worked\n");
2766 ok(info
.iProtocol
== IPPROTO_TCP
, "expected protocol %d, received %d\n",
2767 IPPROTO_TCP
, info
.iProtocol
);
2768 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
2769 AF_INET
, info
.iProtocol
);
2770 ok(info
.iSocketType
== SOCK_STREAM
, "expected type %d, received %d\n",
2771 SOCK_STREAM
, info
.iSocketType
);
2773 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2774 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2776 closesocket(dupsock
);
2777 closesocket(source
);
2779 /* create a socket, bind it, duplicate it then send data on source and
2780 * receive in the duplicated socket */
2781 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
2782 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2784 memset(&info
, 0, sizeof(info
));
2785 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2786 "WSADuplicateSocketA should have worked\n");
2788 ok(info
.iProtocol
== IPPROTO_UDP
, "expected protocol %d, received %d\n",
2789 IPPROTO_UDP
, info
.iProtocol
);
2790 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
2791 AF_INET
, info
.iProtocol
);
2792 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
2793 SOCK_DGRAM
, info
.iSocketType
);
2795 memset(&addr
, 0, sizeof(addr
));
2796 addr
.sin_family
= AF_INET
;
2797 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2798 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
2799 "bind should have worked\n");
2801 /* read address to find out the port number to be used in sendto */
2802 memset(&addr
, 0, sizeof(addr
));
2803 addrsize
= sizeof(addr
);
2804 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
2805 "getsockname should have worked\n");
2806 ok(addr
.sin_port
, "socket port should be != 0\n");
2808 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2809 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2812 ret
= getsockopt(dupsock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2813 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
2814 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2815 SOCK_DGRAM
, socktype
);
2817 set_blocking(source
, TRUE
);
2819 /* send data on source socket */
2820 addrsize
= sizeof(addr
);
2821 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
2822 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2824 /* receive on duplicated socket */
2825 addrsize
= sizeof(addr
);
2826 memset(buffer
, 0, sizeof(buffer
));
2827 size
= recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
);
2828 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2829 buffer
[sizeof(teststr
) - 1] = 0;
2830 ok(!strcmp(buffer
, teststr
), "expected '%s', received '%s'\n", teststr
, buffer
);
2832 closesocket(dupsock
);
2833 closesocket(source
);
2835 /* show that the source socket need to be bound before the duplicated
2836 * socket is created */
2837 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
2838 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2840 memset(&info
, 0, sizeof(info
));
2841 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2842 "WSADuplicateSocketA should have worked\n");
2844 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2845 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2847 memset(&addr
, 0, sizeof(addr
));
2848 addr
.sin_family
= AF_INET
;
2849 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2850 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
2851 "bind should have worked\n");
2853 /* read address to find out the port number to be used in sendto */
2854 memset(&addr
, 0, sizeof(addr
));
2855 addrsize
= sizeof(addr
);
2856 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
2857 "getsockname should have worked\n");
2858 ok(addr
.sin_port
, "socket port should be != 0\n");
2860 set_blocking(source
, TRUE
);
2862 addrsize
= sizeof(addr
);
2863 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
2864 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2866 SetLastError(0xdeadbeef);
2867 addrsize
= sizeof(addr
);
2868 memset(buffer
, 0, sizeof(buffer
));
2870 ok(recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
) == -1,
2871 "recvfrom should have failed\n");
2872 err
= WSAGetLastError();
2873 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2876 closesocket(dupsock
);
2877 closesocket(source
);
2880 static void test_WSAEnumNetworkEvents(void)
2883 int sock_type
[] = {SOCK_STREAM
, SOCK_DGRAM
, SOCK_STREAM
}, i
, j
, k
, l
;
2884 struct sockaddr_in address
;
2886 WSANETWORKEVENTS net_events
;
2887 /* Windows 2000 Pro without SP installed (testbot) will crash if
2888 * WSAEnumNetworkEvents have a NULL event, so skip this test in <= 2000 */
2889 DWORD ver
= GetVersion() & 0xFFFF;
2890 BOOL supports_null
= ((ver
& 0xFF) << 8 | (ver
>> 8)) > 0x0500;
2892 memset(&address
, 0, sizeof(address
));
2893 address
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
2894 address
.sin_family
= AF_INET
;
2896 /* This test follows the steps from bugs 10204 and 24946 */
2897 for (l
= 0; l
< 2; l
++)
2899 if (l
== 1 && !supports_null
&& broken(1)) continue;
2901 for (i
= 0; i
< sizeof(sock_type
) / sizeof(sock_type
[0]); i
++)
2904 ok(!tcp_socketpair(&s
, &s2
), "Test[%d]: creating socket pair failed\n", i
);
2907 s
= socket(AF_INET
, sock_type
[i
], 0);
2908 ok (s
!= SOCKET_ERROR
, "Test[%d]: failed to create socket\n", i
);
2909 ok (!bind(s
, (struct sockaddr
*) &address
, sizeof(address
)), "Test[%d]: bind failed\n", i
);
2911 event
= WSACreateEvent();
2912 ok (event
!= NULL
, "Test[%d]: failed to create event\n", i
);
2913 for (j
= 0; j
< 5; j
++) /* Repeat sometimes and the result must be the same */
2915 /* When the TCP socket is not connected NO events will be returned.
2916 * When connected and no data pending it will get the write event.
2917 * UDP sockets don't have connections so as soon as they are bound
2918 * they can read/write data. Since nobody is sendind us data only
2919 * the write event will be returned and ONLY once.
2921 ok (!WSAEventSelect(s
, event
, FD_READ
| FD_WRITE
), "Test[%d]: WSAEventSelect failed\n", i
);
2922 memset(&net_events
, 0xAB, sizeof(net_events
));
2923 ok (!WSAEnumNetworkEvents(s
, l
== 0 ? event
: NULL
, &net_events
),
2924 "Test[%d]: WSAEnumNetworkEvents failed\n", i
);
2925 if (i
>= 1 && j
== 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
2927 todo_wine_if (i
== 0) /* Remove when fixed */
2928 ok (net_events
.lNetworkEvents
== FD_WRITE
, "Test[%d]: expected 2, got %d\n",
2929 i
, net_events
.lNetworkEvents
);
2933 todo_wine_if (i
!= 0) /* Remove when fixed */
2934 ok (net_events
.lNetworkEvents
== 0, "Test[%d]: expected 0, got %d\n",
2935 i
, net_events
.lNetworkEvents
);
2937 for (k
= 0; k
< FD_MAX_EVENTS
; k
++)
2939 if (i
>= 1 && j
== 0 && k
== 1) /* first UDP and connected TCP test, FD_WRITE bit no error*/
2941 ok (net_events
.iErrorCode
[k
] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
2942 i
, k
, net_events
.iErrorCode
[k
]);
2946 /* Bits that are not set in lNetworkEvents MUST not be changed */
2948 ok (net_events
.iErrorCode
[k
] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
2949 i
, k
, net_events
.iErrorCode
[k
]);
2954 WSACloseEvent(event
);
2955 if (i
== 2) closesocket(s2
);
2960 static void test_WSAAddressToStringA(void)
2962 SOCKET v6
= INVALID_SOCKET
;
2966 SOCKADDR_IN sockaddr
;
2967 CHAR address
[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
2969 CHAR expect1
[] = "0.0.0.0";
2970 CHAR expect2
[] = "255.255.255.255";
2971 CHAR expect3
[] = "0.0.0.0:65535";
2972 CHAR expect4
[] = "255.255.255.255:65535";
2974 SOCKADDR_IN6 sockaddr6
;
2975 CHAR address6
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
2977 CHAR addr6_1
[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2978 CHAR addr6_2
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2979 CHAR addr6_3
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
2981 CHAR expect6_1
[] = "::1";
2982 CHAR expect6_2
[] = "20ab::1";
2983 CHAR expect6_3
[] = "[20ab::2001]:33274";
2984 CHAR expect6_3_nt
[] = "20ab::2001@33274";
2985 CHAR expect6_3_w2k
[] = "20ab::2001";
2986 CHAR expect6_3_2
[] = "[20ab::2001%4660]:33274";
2987 CHAR expect6_3_2_nt
[] = "4660/20ab::2001@33274";
2988 CHAR expect6_3_2_w2k
[] = "20ab::2001%4660";
2989 CHAR expect6_3_3
[] = "20ab::2001%4660";
2990 CHAR expect6_3_3_nt
[] = "4660/20ab::2001";
2994 sockaddr
.sin_family
= AF_INET
;
2995 sockaddr
.sin_port
= 0;
2996 sockaddr
.sin_addr
.s_addr
= 0;
2998 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2999 GLE
= WSAGetLastError();
3000 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEFAULT
) || (ret
== 0),
3001 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
3004 len
= sizeof(address
);
3006 sockaddr
.sin_family
= AF_INET
;
3007 sockaddr
.sin_port
= 0;
3008 sockaddr
.sin_addr
.s_addr
= 0;
3010 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3011 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3013 ok( !strcmp( address
, expect1
), "Expected: %s, got: %s\n", expect1
, address
);
3014 ok( len
== sizeof( expect1
), "Got size %d\n", len
);
3016 len
= sizeof(address
);
3018 sockaddr
.sin_family
= AF_INET
;
3019 sockaddr
.sin_port
= 0;
3020 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
3022 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3023 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3025 ok( !strcmp( address
, expect2
), "Expected: %s, got: %s\n", expect2
, address
);
3027 len
= sizeof(address
);
3029 sockaddr
.sin_family
= AF_INET
;
3030 sockaddr
.sin_port
= 0xffff;
3031 sockaddr
.sin_addr
.s_addr
= 0;
3033 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3034 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3036 ok( !strcmp( address
, expect3
), "Expected: %s, got: %s\n", expect3
, address
);
3038 len
= sizeof(address
);
3040 sockaddr
.sin_family
= AF_INET
;
3041 sockaddr
.sin_port
= 0xffff;
3042 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
3044 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3045 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3047 ok( !strcmp( address
, expect4
), "Expected: %s, got: %s\n", expect4
, address
);
3048 ok( len
== sizeof( expect4
), "Got size %d\n", len
);
3050 /*check to see it IPv6 is available */
3051 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
3052 if (v6
== INVALID_SOCKET
) {
3053 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
3054 WSAGetLastError(), WSAEAFNOSUPPORT
);
3057 /* Test a short IPv6 address */
3058 len
= sizeof(address6
);
3060 sockaddr6
.sin6_family
= AF_INET6
;
3061 sockaddr6
.sin6_port
= 0x0000;
3062 sockaddr6
.sin6_scope_id
= 0;
3063 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_1
, sizeof(addr6_1
));
3065 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3066 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3067 ok( !strcmp( address6
, expect6_1
), "Expected: %s, got: %s\n", expect6_1
, address6
);
3068 ok( len
== sizeof(expect6_1
), "Got size %d\n", len
);
3070 /* Test a longer IPv6 address */
3071 len
= sizeof(address6
);
3073 sockaddr6
.sin6_family
= AF_INET6
;
3074 sockaddr6
.sin6_port
= 0x0000;
3075 sockaddr6
.sin6_scope_id
= 0;
3076 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_2
, sizeof(addr6_2
));
3078 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3079 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3080 ok( !strcmp( address6
, expect6_2
), "Expected: %s, got: %s\n", expect6_2
, address6
);
3081 ok( len
== sizeof(expect6_2
), "Got size %d\n", len
);
3083 /* Test IPv6 address and port number */
3084 len
= sizeof(address6
);
3086 sockaddr6
.sin6_family
= AF_INET6
;
3087 sockaddr6
.sin6_port
= 0xfa81;
3088 sockaddr6
.sin6_scope_id
= 0;
3089 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
3091 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3092 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3093 ok( !strcmp( address6
, expect6_3
) ||
3094 broken( !strcmp( address6
, expect6_3_nt
) ) || /* NT4 */
3095 broken( !strcmp( address6
, expect6_3_w2k
) ), /* Win2000 */
3096 "Expected: %s, got: %s\n", expect6_3
, address6
);
3097 ok( len
== sizeof(expect6_3
) ||
3098 broken( len
== sizeof(expect6_3_nt
) ) || /* NT4 */
3099 broken( len
== sizeof(expect6_3_w2k
) ), /* Win2000 */
3100 "Got size %d\n", len
);
3102 /* Test IPv6 address, port number and scope_id */
3103 len
= sizeof(address6
);
3105 sockaddr6
.sin6_family
= AF_INET6
;
3106 sockaddr6
.sin6_port
= 0xfa81;
3107 sockaddr6
.sin6_scope_id
= 0x1234;
3108 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
3110 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3111 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3112 ok( !strcmp( address6
, expect6_3_2
) ||
3113 broken( !strcmp( address6
, expect6_3_2_nt
) ) || /* NT4 */
3114 broken( !strcmp( address6
, expect6_3_2_w2k
) ), /* Win2000 */
3115 "Expected: %s, got: %s\n", expect6_3_2
, address6
);
3116 ok( len
== sizeof(expect6_3_2
) ||
3117 broken( len
== sizeof(expect6_3_2_nt
) ) || /* NT4 */
3118 broken( len
== sizeof(expect6_3_2_w2k
) ), /* Win2000 */
3119 "Got size %d\n", len
);
3121 /* Test IPv6 address and scope_id */
3122 len
= sizeof(address6
);
3124 sockaddr6
.sin6_family
= AF_INET6
;
3125 sockaddr6
.sin6_port
= 0x0000;
3126 sockaddr6
.sin6_scope_id
= 0x1234;
3127 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
3129 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3130 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3131 ok( !strcmp( address6
, expect6_3_3
) ||
3132 broken( !strcmp( address6
, expect6_3_3_nt
) ), /* NT4 */
3133 "Expected: %s, got: %s\n", expect6_3_3
, address6
);
3134 ok( len
== sizeof(expect6_3_3
) ||
3135 broken( len
== sizeof(expect6_3_3_nt
) ), /* NT4 */
3136 "Got size %d\n", len
);
3139 if (v6
!= INVALID_SOCKET
)
3143 static void test_WSAAddressToStringW(void)
3145 SOCKET v6
= INVALID_SOCKET
;
3149 SOCKADDR_IN sockaddr
;
3150 WCHAR address
[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
3152 WCHAR expect1
[] = { '0','.','0','.','0','.','0', 0 };
3153 WCHAR expect2
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
3154 WCHAR expect3
[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
3155 WCHAR expect4
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
3156 '6', '5', '5', '3', '5', 0 };
3158 SOCKADDR_IN6 sockaddr6
;
3159 WCHAR address6
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
3161 CHAR addr6_1
[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3162 CHAR addr6_2
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3163 CHAR addr6_3
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
3165 WCHAR expect6_1
[] = {':',':','1',0};
3166 WCHAR expect6_2
[] = {'2','0','a','b',':',':','1',0};
3167 WCHAR expect6_3
[] = {'[','2','0','a','b',':',':','2','0','0','1',']',':','3','3','2','7','4',0};
3168 WCHAR expect6_3_nt
[] = {'2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
3169 WCHAR expect6_3_w2k
[] = {'2','0','a','b',':',':','2','0','0','1',0};
3170 WCHAR expect6_3_2
[] = {'[','2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',']',':','3','3','2','7','4',0};
3171 WCHAR expect6_3_2_nt
[] = {'4','6','6','0','/','2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
3172 WCHAR expect6_3_2_w2k
[] = {'2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',0};
3173 WCHAR expect6_3_3
[] = {'2','0','a','b',':',':','2','0','0','1','%','6','5','5','3','4',0};
3174 WCHAR expect6_3_3_nt
[] = {'6','5','5','3','4','/','2','0','a','b',':',':','2','0','0','1',0};
3178 sockaddr
.sin_family
= AF_INET
;
3179 sockaddr
.sin_port
= 0;
3180 sockaddr
.sin_addr
.s_addr
= 0;
3182 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3183 GLE
= WSAGetLastError();
3184 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEFAULT
) || (ret
== 0),
3185 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
3188 len
= sizeof(address
);
3190 sockaddr
.sin_family
= AF_INET
;
3191 sockaddr
.sin_port
= 0;
3192 sockaddr
.sin_addr
.s_addr
= 0;
3194 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3195 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3197 ok( !lstrcmpW( address
, expect1
), "Expected different address string\n" );
3198 ok( len
== sizeof( expect1
)/sizeof( WCHAR
), "Got size %d\n", len
);
3200 len
= sizeof(address
);
3202 sockaddr
.sin_family
= AF_INET
;
3203 sockaddr
.sin_port
= 0;
3204 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
3206 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3207 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3209 ok( !lstrcmpW( address
, expect2
), "Expected different address string\n" );
3211 len
= sizeof(address
);
3213 sockaddr
.sin_family
= AF_INET
;
3214 sockaddr
.sin_port
= 0xffff;
3215 sockaddr
.sin_addr
.s_addr
= 0;
3217 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3218 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3220 ok( !lstrcmpW( address
, expect3
), "Expected different address string\n" );
3222 len
= sizeof(address
);
3224 sockaddr
.sin_family
= AF_INET
;
3225 sockaddr
.sin_port
= 0xffff;
3226 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
3228 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3229 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3231 ok( !lstrcmpW( address
, expect4
), "Expected different address string\n" );
3232 ok( len
== sizeof( expect4
)/sizeof( WCHAR
), "Got %d\n", len
);
3234 /*check to see it IPv6 is available */
3235 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
3236 if (v6
== INVALID_SOCKET
) {
3237 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
3238 WSAGetLastError(), WSAEAFNOSUPPORT
);
3242 /* Test a short IPv6 address */
3243 len
= sizeof(address6
)/sizeof(WCHAR
);
3245 sockaddr6
.sin6_family
= AF_INET6
;
3246 sockaddr6
.sin6_port
= 0x0000;
3247 sockaddr6
.sin6_scope_id
= 0;
3248 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_1
, sizeof(addr6_1
));
3250 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3251 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3252 ok( !lstrcmpW( address6
, expect6_1
), "Wrong string returned\n" );
3253 ok( len
== sizeof(expect6_1
)/sizeof(WCHAR
), "Got %d\n", len
);
3255 /* Test a longer IPv6 address */
3256 len
= sizeof(address6
)/sizeof(WCHAR
);
3258 sockaddr6
.sin6_family
= AF_INET6
;
3259 sockaddr6
.sin6_port
= 0x0000;
3260 sockaddr6
.sin6_scope_id
= 0;
3261 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_2
, sizeof(addr6_2
));
3263 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3264 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3266 ok( !lstrcmpW( address6
, expect6_2
), "Wrong string returned\n" );
3267 ok( len
== sizeof(expect6_2
)/sizeof(WCHAR
), "Got %d\n", len
);
3269 /* Test IPv6 address and port number */
3270 len
= sizeof(address6
)/sizeof(WCHAR
);
3272 sockaddr6
.sin6_family
= AF_INET6
;
3273 sockaddr6
.sin6_port
= 0xfa81;
3274 sockaddr6
.sin6_scope_id
= 0;
3275 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
3277 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3278 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3279 ok( !lstrcmpW( address6
, expect6_3
) ||
3280 broken( !lstrcmpW( address6
, expect6_3_nt
) ) || /* NT4 */
3281 broken( !lstrcmpW( address6
, expect6_3_w2k
) ), /* Win2000 */
3282 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3
),
3283 wine_dbgstr_w(address6
) );
3284 ok( len
== sizeof(expect6_3
)/sizeof(WCHAR
) ||
3285 broken(len
== sizeof(expect6_3_nt
)/sizeof(WCHAR
) ) || /* NT4 */
3286 broken(len
== sizeof(expect6_3_w2k
)/sizeof(WCHAR
) ), /* Win2000 */
3289 /* Test IPv6 address, port number and scope_id */
3290 len
= sizeof(address6
)/sizeof(WCHAR
);
3292 sockaddr6
.sin6_family
= AF_INET6
;
3293 sockaddr6
.sin6_port
= 0xfa81;
3294 sockaddr6
.sin6_scope_id
= 0x1234;
3295 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
3297 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3298 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3299 ok( !lstrcmpW( address6
, expect6_3_2
) ||
3300 broken( !lstrcmpW( address6
, expect6_3_2_nt
) ) || /* NT4 */
3301 broken( !lstrcmpW( address6
, expect6_3_2_w2k
) ), /* Win2000 */
3302 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_2
),
3303 wine_dbgstr_w(address6
) );
3304 ok( len
== sizeof(expect6_3_2
)/sizeof(WCHAR
) ||
3305 broken( len
== sizeof(expect6_3_2_nt
)/sizeof(WCHAR
) ) || /* NT4 */
3306 broken( len
== sizeof(expect6_3_2_w2k
)/sizeof(WCHAR
) ), /* Win2000 */
3309 /* Test IPv6 address and scope_id */
3310 len
= sizeof(address6
)/sizeof(WCHAR
);
3312 sockaddr6
.sin6_family
= AF_INET6
;
3313 sockaddr6
.sin6_port
= 0x0000;
3314 sockaddr6
.sin6_scope_id
= 0xfffe;
3315 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
3317 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3318 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3319 ok( !lstrcmpW( address6
, expect6_3_3
) ||
3320 broken( !lstrcmpW( address6
, expect6_3_3_nt
) ), /* NT4 */
3321 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_3
),
3322 wine_dbgstr_w(address6
) );
3323 ok( len
== sizeof(expect6_3_3
)/sizeof(WCHAR
) ||
3324 broken( len
== sizeof(expect6_3_3_nt
)/sizeof(WCHAR
) ), /* NT4 */
3328 if (v6
!= INVALID_SOCKET
)
3332 static void test_WSAStringToAddressA(void)
3335 SOCKADDR_IN sockaddr
;
3336 SOCKADDR_IN6 sockaddr6
;
3339 CHAR address1
[] = "0.0.0.0";
3340 CHAR address2
[] = "127.127.127.127";
3341 CHAR address3
[] = "255.255.255.255";
3342 CHAR address4
[] = "127.127.127.127:65535";
3343 CHAR address5
[] = "255.255.255.255:65535";
3344 CHAR address6
[] = "::1";
3345 CHAR address7
[] = "[::1]";
3346 CHAR address8
[] = "[::1]:65535";
3347 CHAR address9
[] = "2001::1";
3350 sockaddr
.sin_family
= AF_INET
;
3352 ret
= WSAStringToAddressA( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3353 ok( ret
== SOCKET_ERROR
, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
3354 WSAGetLastError() );
3356 len
= sizeof(sockaddr
);
3357 sockaddr
.sin_port
= 0;
3358 sockaddr
.sin_addr
.s_addr
= 0;
3360 ret
= WSAStringToAddressA( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3361 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0,
3362 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3364 len
= sizeof(sockaddr
);
3365 sockaddr
.sin_port
= 0;
3366 sockaddr
.sin_addr
.s_addr
= 0;
3368 ret
= WSAStringToAddressA( address2
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3369 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f,
3370 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3372 len
= sizeof(sockaddr
);
3373 sockaddr
.sin_port
= 0;
3374 sockaddr
.sin_addr
.s_addr
= 0;
3376 ret
= WSAStringToAddressA( address3
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3377 GLE
= WSAGetLastError();
3378 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff) ||
3379 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
3380 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE
);
3382 len
= sizeof(sockaddr
);
3383 sockaddr
.sin_port
= 0;
3384 sockaddr
.sin_addr
.s_addr
= 0;
3386 ret
= WSAStringToAddressA( address4
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3387 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f && sockaddr
.sin_port
== 0xffff,
3388 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3390 len
= sizeof(sockaddr
);
3391 sockaddr
.sin_port
= 0;
3392 sockaddr
.sin_addr
.s_addr
= 0;
3394 ret
= WSAStringToAddressA( address5
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3395 GLE
= WSAGetLastError();
3396 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff && sockaddr
.sin_port
== 0xffff) ||
3397 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
3398 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE
);
3400 len
= sizeof(sockaddr
);
3402 ret
= WSAStringToAddressA( address9
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3403 GLE
= WSAGetLastError();
3404 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3405 "WSAStringToAddressA() should have failed with %d\n", GLE
);
3407 len
= sizeof(sockaddr6
);
3408 memset(&sockaddr6
, 0, len
);
3409 sockaddr6
.sin6_family
= AF_INET6
;
3411 ret
= WSAStringToAddressA( address6
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3413 if (ret
== SOCKET_ERROR
)
3415 win_skip("IPv6 not supported\n");
3419 GLE
= WSAGetLastError();
3420 ok( ret
== 0, "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
3422 len
= sizeof(sockaddr6
);
3423 memset(&sockaddr6
, 0, len
);
3424 sockaddr6
.sin6_family
= AF_INET6
;
3426 ret
= WSAStringToAddressA( address7
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3428 GLE
= WSAGetLastError();
3429 ok( ret
== 0, "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
3431 len
= sizeof(sockaddr6
);
3432 memset(&sockaddr6
, 0, len
);
3433 sockaddr6
.sin6_family
= AF_INET6
;
3435 ret
= WSAStringToAddressA( address8
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3437 GLE
= WSAGetLastError();
3438 ok( ret
== 0 && sockaddr6
.sin6_port
== 0xffff,
3439 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
3441 len
= sizeof(sockaddr6
);
3443 ret
= WSAStringToAddressA( address7
+ 1, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3444 GLE
= WSAGetLastError();
3445 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3446 "WSAStringToAddressW() should have failed with %d\n", GLE
);
3448 len
= sizeof(sockaddr6
);
3450 ret
= WSAStringToAddressA( address8
+ 1, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3451 GLE
= WSAGetLastError();
3452 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3453 "WSAStringToAddressW() should have failed with %d\n", GLE
);
3456 static void test_WSAStringToAddressW(void)
3459 SOCKADDR_IN sockaddr
, *sin
;
3460 SOCKADDR_IN6 sockaddr6
;
3461 SOCKADDR_STORAGE sockaddr_storage
;
3464 WCHAR address1
[] = { '0','.','0','.','0','.','0', 0 };
3465 WCHAR address2
[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
3466 WCHAR address3
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
3467 WCHAR address4
[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
3468 ':', '6', '5', '5', '3', '5', 0 };
3469 WCHAR address5
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
3470 '6', '5', '5', '3', '5', 0 };
3471 WCHAR address6
[] = {':',':','1','\0'};
3472 WCHAR address7
[] = {'[',':',':','1',']','\0'};
3473 WCHAR address8
[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
3474 WCHAR address9
[] = {'2','0','0','1',':',':','1','\0'};
3477 sockaddr
.sin_family
= AF_INET
;
3479 ret
= WSAStringToAddressW( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3480 ok( ret
== SOCKET_ERROR
, "WSAStringToAddressW() failed unexpectedly: %d\n",
3481 WSAGetLastError() );
3483 len
= sizeof(sockaddr
);
3484 sockaddr
.sin_port
= 0;
3485 sockaddr
.sin_addr
.s_addr
= 0;
3487 ret
= WSAStringToAddressW( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3488 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0,
3489 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3491 len
= sizeof(sockaddr
);
3492 sockaddr
.sin_port
= 0;
3493 sockaddr
.sin_addr
.s_addr
= 0;
3495 ret
= WSAStringToAddressW( address2
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3496 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f,
3497 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3499 len
= sizeof(sockaddr
);
3500 sockaddr
.sin_port
= 0;
3501 sockaddr
.sin_addr
.s_addr
= 0;
3503 ret
= WSAStringToAddressW( address3
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3504 GLE
= WSAGetLastError();
3505 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff) ||
3506 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
3507 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
3509 len
= sizeof(sockaddr
);
3510 sockaddr
.sin_port
= 0;
3511 sockaddr
.sin_addr
.s_addr
= 0;
3513 ret
= WSAStringToAddressW( address4
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3514 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f && sockaddr
.sin_port
== 0xffff,
3515 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3517 len
= sizeof(sockaddr
);
3518 sockaddr
.sin_port
= 0;
3519 sockaddr
.sin_addr
.s_addr
= 0;
3521 ret
= WSAStringToAddressW( address5
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3522 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff && sockaddr
.sin_port
== 0xffff) ||
3523 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
3524 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
3526 /* Test with a larger buffer than necessary */
3527 len
= sizeof(sockaddr_storage
);
3528 sin
= (SOCKADDR_IN
*)&sockaddr_storage
;
3530 sin
->sin_addr
.s_addr
= 0;
3532 ret
= WSAStringToAddressW( address5
, AF_INET
, NULL
, (SOCKADDR
*)sin
, &len
);
3533 ok( (ret
== 0 && sin
->sin_addr
.s_addr
== 0xffffffff && sin
->sin_port
== 0xffff) ||
3534 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
3535 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
3536 ok( len
== sizeof(SOCKADDR_IN
) ||
3537 broken(len
== sizeof(SOCKADDR_STORAGE
)) /* NT4/2k */,
3538 "unexpected length %d\n", len
);
3540 len
= sizeof(sockaddr
);
3542 ret
= WSAStringToAddressW( address9
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3543 GLE
= WSAGetLastError();
3544 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3545 "WSAStringToAddressW() should have failed with %d\n", GLE
);
3547 len
= sizeof(sockaddr6
);
3548 memset(&sockaddr6
, 0, len
);
3549 sockaddr6
.sin6_family
= AF_INET6
;
3551 ret
= WSAStringToAddressW( address6
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3553 if (ret
== SOCKET_ERROR
)
3555 win_skip("IPv6 not supported\n");
3559 GLE
= WSAGetLastError();
3560 ok( ret
== 0, "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
3562 len
= sizeof(sockaddr6
);
3563 memset(&sockaddr6
, 0, len
);
3564 sockaddr6
.sin6_family
= AF_INET6
;
3566 ret
= WSAStringToAddressW( address7
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3568 GLE
= WSAGetLastError();
3569 ok( ret
== 0, "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
3571 len
= sizeof(sockaddr6
);
3572 memset(&sockaddr6
, 0, len
);
3573 sockaddr6
.sin6_family
= AF_INET6
;
3575 ret
= WSAStringToAddressW( address8
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3577 GLE
= WSAGetLastError();
3578 ok( ret
== 0 && sockaddr6
.sin6_port
== 0xffff,
3579 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
3581 len
= sizeof(sockaddr6
);
3583 ret
= WSAStringToAddressW( address7
+ 1, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3584 GLE
= WSAGetLastError();
3585 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3586 "WSAStringToAddressW() should have failed with %d\n", GLE
);
3588 len
= sizeof(sockaddr6
);
3590 ret
= WSAStringToAddressW( address8
+ 1, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3591 GLE
= WSAGetLastError();
3592 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3593 "WSAStringToAddressW() should have failed with %d\n", GLE
);
3596 static DWORD WINAPI
SelectReadThread(void *param
)
3598 select_thread_params
*par
= param
;
3601 struct sockaddr_in addr
;
3602 struct timeval select_timeout
;
3605 FD_SET(par
->s
, &readfds
);
3606 select_timeout
.tv_sec
=5;
3607 select_timeout
.tv_usec
=0;
3608 addr
.sin_family
= AF_INET
;
3609 addr
.sin_addr
.s_addr
= inet_addr(SERVERIP
);
3610 addr
.sin_port
= htons(SERVERPORT
);
3612 do_bind(par
->s
, (struct sockaddr
*)&addr
, sizeof(addr
));
3613 wsa_ok(listen(par
->s
, SOMAXCONN
), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
3615 SetEvent(server_ready
);
3616 ret
= select(par
->s
+1, &readfds
, NULL
, NULL
, &select_timeout
);
3617 par
->ReadKilled
= (ret
== 1);
3622 static DWORD WINAPI
SelectCloseThread(void *param
)
3624 SOCKET s
= *(SOCKET
*)param
;
3630 static void test_errors(void)
3633 SOCKADDR_IN SockAddr
;
3636 WSASetLastError(NO_ERROR
);
3637 sock
= socket(PF_INET
, SOCK_STREAM
, 0);
3638 ok( (sock
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3639 memset(&SockAddr
, 0, sizeof(SockAddr
));
3640 SockAddr
.sin_family
= AF_INET
;
3641 SockAddr
.sin_port
= htons(6924);
3642 SockAddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3644 ret
= connect(sock
, (PSOCKADDR
)&SockAddr
, sizeof(SockAddr
));
3645 ok( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got: %d\n", ret
);
3646 if (ret
== SOCKET_ERROR
)
3648 err
= WSAGetLastError();
3649 ok( (err
== WSAECONNREFUSED
), "expected WSAECONNREFUSED, got: %d\n", err
);
3654 fd_set set
= {1, {sock
}};
3657 timeval
.tv_usec
= 50000;
3659 ret
= select(1, NULL
, &set
, NULL
, &timeval
);
3660 ok( (ret
== 0), "expected 0 (timeout), got: %d\n", ret
);
3663 ret
= closesocket(sock
);
3664 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
3667 static void test_listen(void)
3670 int ret
, acceptc
, olen
= sizeof(acceptc
);
3671 struct sockaddr_in address
;
3673 memset(&address
, 0, sizeof(address
));
3674 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3675 address
.sin_family
= AF_INET
;
3676 address
.sin_port
= htons(SERVERPORT
);
3678 /* invalid socket tests */
3679 SetLastError(0xdeadbeef);
3680 ok ((listen(0, 0) == SOCKET_ERROR
), "listen did not fail\n");
3681 ret
= WSAGetLastError();
3682 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
3684 SetLastError(0xdeadbeef);
3685 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR
), "listen did not fail\n");
3686 ret
= WSAGetLastError();
3687 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
3690 fdA
= socket(AF_INET
, SOCK_STREAM
, 0);
3691 ok ((fdA
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3693 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
3694 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3696 SetLastError(0xdeadbeef);
3697 ok ((listen(fdA
, -2) == SOCKET_ERROR
), "listen did not fail\n");
3698 ret
= WSAGetLastError();
3699 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3701 SetLastError(0xdeadbeef);
3702 ok ((listen(fdA
, 1) == SOCKET_ERROR
), "listen did not fail\n");
3703 ret
= WSAGetLastError();
3704 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3706 SetLastError(0xdeadbeef);
3707 ok ((listen(fdA
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
3708 ret
= WSAGetLastError();
3709 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3711 ok (!bind(fdA
, (struct sockaddr
*) &address
, sizeof(address
)), "bind failed\n");
3713 SetLastError(0xdeadbeef);
3714 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
3715 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3718 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
3719 ok (!ret
, "getsockopt failed\n");
3720 ok (acceptc
== 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc
);
3722 ok (!listen(fdA
, 0), "listen failed\n");
3723 ok (!listen(fdA
, SOMAXCONN
), "double listen failed\n");
3726 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
3727 ok (!ret
, "getsockopt failed\n");
3728 ok (acceptc
== 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc
);
3730 SetLastError(0xdeadbeef);
3731 ok ((listen(fdB
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
3732 ret
= WSAGetLastError();
3733 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3735 ret
= closesocket(fdB
);
3736 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
3738 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
3739 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3741 SetLastError(0xdeadbeef);
3742 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
3743 ret
= WSAGetLastError();
3744 ok (ret
== WSAEADDRINUSE
, "expected 10048, received %d\n", ret
);
3746 ret
= closesocket(fdA
);
3747 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
3748 ret
= closesocket(fdB
);
3749 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
3752 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
3753 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
3754 static void test_select(void)
3756 static char tmp_buf
[1024];
3758 SOCKET fdListen
, fdRead
, fdWrite
;
3759 fd_set readfds
, writefds
, exceptfds
;
3763 struct timeval select_timeout
;
3764 struct sockaddr_in address
;
3765 select_thread_params thread_params
;
3766 HANDLE thread_handle
;
3769 fdRead
= socket(AF_INET
, SOCK_STREAM
, 0);
3770 ok( (fdRead
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3771 fdWrite
= socket(AF_INET
, SOCK_STREAM
, 0);
3772 ok( (fdWrite
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3775 if (fdWrite
> maxfd
)
3780 FD_SET_ALL(fdWrite
);
3781 select_timeout
.tv_sec
=0;
3782 select_timeout
.tv_usec
=0;
3784 ticks
= GetTickCount();
3785 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3786 ticks
= GetTickCount() - ticks
;
3787 ok(ret
== 0, "select should not return any socket handles\n");
3788 ok(ticks
< 10, "select was blocking for %u ms, expected < 10 ms\n", ticks
);
3789 ok(!FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
3790 ok(!FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
3791 ok(!FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
3792 ok(!FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
3796 FD_SET_ALL(fdWrite
);
3797 select_timeout
.tv_sec
=0;
3798 select_timeout
.tv_usec
=500;
3800 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3801 ok(ret
== 0, "select should not return any socket handles\n");
3802 ok(!FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
3803 ok(!FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
3804 ok(!FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
3805 ok(!FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
3807 ok ((listen(fdWrite
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
3808 ret
= closesocket(fdWrite
);
3809 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
3811 thread_params
.s
= fdRead
;
3812 thread_params
.ReadKilled
= FALSE
;
3813 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
3814 thread_handle
= CreateThread (NULL
, 0, SelectReadThread
, &thread_params
, 0, &id
);
3815 ok ( (thread_handle
!= NULL
), "CreateThread failed unexpectedly: %d\n", GetLastError());
3817 WaitForSingleObject (server_ready
, INFINITE
);
3819 ret
= closesocket(fdRead
);
3820 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
3822 WaitForSingleObject (thread_handle
, 1000);
3823 ok ( (thread_params
.ReadKilled
) ||
3824 broken(thread_params
.ReadKilled
== 0), /*Win98*/
3825 "closesocket did not wakeup select\n");
3826 ret
= recv(fdRead
, &buffer
, 1, MSG_PEEK
);
3827 ok( (ret
== -1), "peek at closed socket expected -1 got %d\n", ret
);
3829 /* Test selecting invalid handles */
3833 ret
= select(maxfd
+1, 0, 0, 0, &select_timeout
);
3834 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3835 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3838 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3839 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3840 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3842 FD_SET(INVALID_SOCKET
, &readfds
);
3844 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3845 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3846 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3847 ok ( !FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
3850 FD_SET(INVALID_SOCKET
, &writefds
);
3852 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3853 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3854 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3855 ok ( !FD_ISSET(fdRead
, &writefds
), "FD should not be set\n");
3858 FD_SET(INVALID_SOCKET
, &exceptfds
);
3860 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3861 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3862 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3863 ok ( !FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
3865 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
3867 if(fdWrite
> maxfd
) maxfd
= fdWrite
;
3870 FD_SET(fdRead
, &readfds
);
3871 ret
= select(fdRead
+1, &readfds
, NULL
, NULL
, &select_timeout
);
3872 ok(!ret
, "select returned %d\n", ret
);
3875 FD_SET(fdWrite
, &writefds
);
3876 ret
= select(fdWrite
+1, NULL
, &writefds
, NULL
, &select_timeout
);
3877 ok(ret
== 1, "select returned %d\n", ret
);
3878 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
3880 /* tests for overlapping fd_set pointers */
3882 FD_SET(fdWrite
, &readfds
);
3883 ret
= select(fdWrite
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3884 ok(ret
== 1, "select returned %d\n", ret
);
3885 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3888 FD_SET(fdWrite
, &readfds
);
3889 FD_SET(fdRead
, &readfds
);
3890 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3891 ok(ret
== 2, "select returned %d\n", ret
);
3892 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3893 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3895 ok(send(fdWrite
, "test", 4, 0) == 4, "failed to send data\n");
3897 FD_SET(fdRead
, &readfds
);
3898 ret
= select(fdRead
+1, &readfds
, NULL
, NULL
, &select_timeout
);
3899 ok(ret
== 1, "select returned %d\n", ret
);
3900 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3903 FD_SET(fdWrite
, &readfds
);
3904 FD_SET(fdRead
, &readfds
);
3905 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3906 ok(ret
== 2, "select returned %d\n", ret
);
3907 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3908 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3912 FD_SET(fdWrite
, &writefds
);
3913 ret
= select(fdWrite
+1, NULL
, &writefds
, NULL
, &select_timeout
);
3915 ok(send(fdWrite
, tmp_buf
, sizeof(tmp_buf
), 0) > 0, "failed to send data\n");
3918 FD_SET(fdWrite
, &readfds
);
3919 FD_SET(fdRead
, &readfds
);
3920 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3921 ok(ret
== 1, "select returned %d\n", ret
);
3922 ok(!FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is in the set\n");
3923 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3925 ok(send(fdRead
, "test", 4, 0) == 4, "failed to send data\n");
3928 FD_SET(fdWrite
, &readfds
);
3929 FD_SET(fdRead
, &readfds
);
3930 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3931 ok(ret
== 2, "select returned %d\n", ret
);
3932 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3933 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3935 closesocket(fdRead
);
3936 closesocket(fdWrite
);
3938 /* select() works in 3 distinct states:
3939 * - to check if a connection attempt ended with success or error;
3940 * - to check if a pending connection is waiting for acceptance;
3941 * - to check for data to read, availability for write and OOB data
3943 * The tests below ensure that all conditions are tested.
3945 memset(&address
, 0, sizeof(address
));
3946 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3947 address
.sin_family
= AF_INET
;
3948 len
= sizeof(address
);
3949 fdListen
= setup_server_socket(&address
, &len
);
3950 select_timeout
.tv_sec
= 1;
3951 select_timeout
.tv_usec
= 250000;
3953 /* When no events are pending select returns 0 with no error */
3955 FD_SET_ALL(fdListen
);
3956 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3957 ok(ret
== 0, "expected 0, got %d\n", ret
);
3959 /* When a socket is attempting to connect the listening socket receives the read descriptor */
3960 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
3962 FD_SET_ALL(fdListen
);
3963 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3964 ok(ret
== 1, "expected 1, got %d\n", ret
);
3965 ok(FD_ISSET(fdListen
, &readfds
), "fdListen socket is not in the set\n");
3966 len
= sizeof(address
);
3967 fdRead
= accept(fdListen
, (struct sockaddr
*) &address
, &len
);
3968 ok(fdRead
!= INVALID_SOCKET
, "expected a valid socket\n");
3970 /* The connector is signaled through the write descriptor */
3972 FD_SET_ALL(fdListen
);
3974 FD_SET_ALL(fdWrite
);
3975 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3976 ok(ret
== 2, "expected 2, got %d\n", ret
);
3977 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
3978 ok(FD_ISSET(fdRead
, &writefds
), "fdRead socket is not in the set\n");
3981 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
3982 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
3983 ok(id
== 0, "expected 0, got %d\n", id
);
3985 /* When data is received the receiver gets the read descriptor */
3986 ret
= send(fdWrite
, "1234", 4, 0);
3987 ok(ret
== 4, "expected 4, got %d\n", ret
);
3989 FD_SET_ALL(fdListen
);
3990 FD_SET(fdRead
, &readfds
);
3991 FD_SET(fdRead
, &exceptfds
);
3992 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3993 ok(ret
== 1, "expected 1, got %d\n", ret
);
3994 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3995 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
3996 ok(ret
== 4, "expected 4, got %d\n", ret
);
3997 ok(!strcmp(tmp_buf
, "1234"), "data received differs from sent\n");
3999 /* When OOB data is received the socket is set in the except descriptor */
4000 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
4001 ok(ret
== 1, "expected 1, got %d\n", ret
);
4003 FD_SET_ALL(fdListen
);
4004 FD_SET(fdRead
, &readfds
);
4005 FD_SET(fdRead
, &exceptfds
);
4006 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4007 ok(ret
== 1, "expected 1, got %d\n", ret
);
4008 ok(FD_ISSET(fdRead
, &exceptfds
), "fdRead socket is not in the set\n");
4010 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
4011 ok(ret
== 1, "expected 1, got %d\n", ret
);
4012 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
4014 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
4016 ret
= setsockopt(fdRead
, SOL_SOCKET
, SO_OOBINLINE
, (char*) &ret
, sizeof(ret
));
4017 ok(ret
== 0, "expected 0, got %d\n", ret
);
4018 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
4019 ok(ret
== 1, "expected 1, got %d\n", ret
);
4021 FD_SET_ALL(fdListen
);
4022 FD_SET(fdRead
, &readfds
);
4023 FD_SET(fdRead
, &exceptfds
);
4024 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4025 ok(ret
== 1, "expected 1, got %d\n", ret
);
4026 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
4028 SetLastError(0xdeadbeef);
4029 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
4030 if (ret
== SOCKET_ERROR
) /* can't recv with MSG_OOB if OOBINLINED */
4032 ok(GetLastError() == WSAEINVAL
, "expected 10022, got %d\n", GetLastError());
4033 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
4034 ok(ret
== 1, "expected 1, got %d\n", ret
);
4035 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
4037 else ok(broken(ret
== 1) /* <= NT4 */, "expected error, got 1\n");
4039 /* When the connection is closed the socket is set in the read descriptor */
4040 ret
= closesocket(fdRead
);
4041 ok(ret
== 0, "expected 0, got %d\n", ret
);
4043 FD_SET_ALL(fdListen
);
4044 FD_SET(fdWrite
, &readfds
);
4045 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4046 ok(ret
== 1, "expected 1, got %d\n", ret
);
4047 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
4048 ret
= recv(fdWrite
, tmp_buf
, sizeof(tmp_buf
), 0);
4049 ok(ret
== 0, "expected 0, got %d\n", ret
);
4051 /* When a connection is attempted to a non-listening socket it will get to the except descriptor */
4052 ret
= closesocket(fdWrite
);
4053 ok(ret
== 0, "expected 0, got %d\n", ret
);
4054 ret
= closesocket(fdListen
);
4055 ok(ret
== 0, "expected 0, got %d\n", ret
);
4056 len
= sizeof(address
);
4057 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
4059 FD_SET(fdWrite
, &writefds
);
4060 FD_SET(fdWrite
, &exceptfds
);
4061 select_timeout
.tv_sec
= 2; /* requires more time to realize it will not connect */
4062 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4063 ok(ret
== 1, "expected 1, got %d\n", ret
);
4066 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
4067 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
4068 ok(id
== WSAECONNREFUSED
, "expected 10061, got %d\n", id
);
4069 ok(FD_ISSET(fdWrite
, &exceptfds
), "fdWrite socket is not in the set\n");
4070 ok(select_timeout
.tv_usec
== 250000, "select timeout should not have changed\n");
4071 closesocket(fdWrite
);
4073 /* Try select() on a closed socket after connection */
4074 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
4075 closesocket(fdRead
);
4077 FD_SET_ALL(fdWrite
);
4079 SetLastError(0xdeadbeef);
4080 ret
= select(0, &readfds
, NULL
, &exceptfds
, &select_timeout
);
4081 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
4083 ok(GetLastError() == WSAENOTSOCK
, "expected 10038, got %d\n", GetLastError());
4084 /* descriptor sets are unchanged */
4085 ok(readfds
.fd_count
== 2, "expected 2, got %d\n", readfds
.fd_count
);
4086 ok(exceptfds
.fd_count
== 2, "expected 2, got %d\n", exceptfds
.fd_count
);
4087 closesocket(fdWrite
);
4089 /* Close the socket currently being selected in a thread - bug 38399 */
4090 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
4091 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
4092 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
4094 FD_SET_ALL(fdWrite
);
4095 ret
= select(0, &readfds
, NULL
, &exceptfds
, &select_timeout
);
4096 ok(ret
== 1, "expected 1, got %d\n", ret
);
4097 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
4098 WaitForSingleObject (thread_handle
, 1000);
4099 closesocket(fdRead
);
4100 /* test again with only the except descriptor */
4101 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
4102 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
4103 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
4105 FD_SET(fdWrite
, &exceptfds
);
4106 SetLastError(0xdeadbeef);
4107 ret
= select(0, NULL
, NULL
, &exceptfds
, &select_timeout
);
4109 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
4111 ok(GetLastError() == WSAENOTSOCK
, "expected 10038, got %d\n", GetLastError());
4112 WaitForSingleObject (thread_handle
, 1000);
4113 closesocket(fdRead
);
4115 /* test UDP behavior of unbound sockets */
4116 select_timeout
.tv_sec
= 0;
4117 select_timeout
.tv_usec
= 250000;
4118 fdWrite
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
4119 ok(fdWrite
!= INVALID_SOCKET
, "socket call failed\n");
4121 FD_SET_ALL(fdWrite
);
4122 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4123 ok(ret
== 1, "expected 1, got %d\n", ret
);
4124 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
4125 closesocket(fdWrite
);
4130 static DWORD WINAPI
AcceptKillThread(void *param
)
4132 select_thread_params
*par
= param
;
4133 struct sockaddr_in address
;
4134 int len
= sizeof(address
);
4135 SOCKET client_socket
;
4137 SetEvent(server_ready
);
4138 client_socket
= accept(par
->s
, (struct sockaddr
*) &address
, &len
);
4139 if (client_socket
!= INVALID_SOCKET
)
4140 closesocket(client_socket
);
4141 par
->ReadKilled
= (client_socket
== INVALID_SOCKET
);
4146 static int CALLBACK
AlwaysDeferConditionFunc(LPWSABUF lpCallerId
, LPWSABUF lpCallerData
, LPQOS pQos
,
4147 LPQOS lpGQOS
, LPWSABUF lpCalleeId
, LPWSABUF lpCalleeData
,
4148 GROUP
*g
, DWORD_PTR dwCallbackData
)
4153 static SOCKET
setup_server_socket(struct sockaddr_in
*addr
, int *len
)
4156 SOCKET server_socket
;
4158 server_socket
= socket(AF_INET
, SOCK_STREAM
, 0);
4159 if (server_socket
== INVALID_SOCKET
)
4161 trace("error creating server socket: %d\n", WSAGetLastError());
4162 return INVALID_SOCKET
;
4166 ret
= setsockopt(server_socket
, SOL_SOCKET
, SO_REUSEADDR
, (char *)&val
, sizeof(val
));
4169 trace("error setting SO_REUSEADDR: %d\n", WSAGetLastError());
4170 closesocket(server_socket
);
4171 return INVALID_SOCKET
;
4174 ret
= bind(server_socket
, (struct sockaddr
*)addr
, *len
);
4177 trace("error binding server socket: %d\n", WSAGetLastError());
4180 ret
= getsockname(server_socket
, (struct sockaddr
*)addr
, len
);
4183 skip("failed to lookup bind address: %d\n", WSAGetLastError());
4184 closesocket(server_socket
);
4185 return INVALID_SOCKET
;
4188 ret
= listen(server_socket
, 5);
4191 trace("error making server socket listen: %d\n", WSAGetLastError());
4192 closesocket(server_socket
);
4193 return INVALID_SOCKET
;
4196 return server_socket
;
4199 static SOCKET
setup_connector_socket(struct sockaddr_in
*addr
, int len
, BOOL nonblock
)
4204 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
4205 ok(connector
!= INVALID_SOCKET
, "failed to create connector socket %d\n", WSAGetLastError());
4208 set_blocking(connector
, !nonblock
);
4210 ret
= connect(connector
, (struct sockaddr
*)addr
, len
);
4212 ok(!ret
, "connecting to accepting socket failed %d\n", WSAGetLastError());
4213 else if (ret
== SOCKET_ERROR
)
4215 DWORD error
= WSAGetLastError();
4216 ok(error
== WSAEWOULDBLOCK
|| error
== WSAEINPROGRESS
,
4217 "expected 10035 or 10036, got %d\n", error
);
4223 static void test_accept(void)
4226 SOCKET server_socket
, accepted
= INVALID_SOCKET
, connector
;
4227 struct sockaddr_in address
;
4228 SOCKADDR_STORAGE ss
, ss_empty
;
4230 select_thread_params thread_params
;
4231 HANDLE thread_handle
= NULL
;
4234 memset(&address
, 0, sizeof(address
));
4235 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4236 address
.sin_family
= AF_INET
;
4238 socklen
= sizeof(address
);
4239 server_socket
= setup_server_socket(&address
, &socklen
);
4240 if (server_socket
== INVALID_SOCKET
)
4242 trace("error creating server socket: %d\n", WSAGetLastError());
4246 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4247 if (connector
== INVALID_SOCKET
) goto done
;
4249 trace("Blocking accept next\n");
4251 accepted
= WSAAccept(server_socket
, NULL
, NULL
, AlwaysDeferConditionFunc
, 0);
4252 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
4254 accepted
= accept(server_socket
, NULL
, 0);
4255 ok(accepted
!= INVALID_SOCKET
, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
4257 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
4258 if (server_ready
== INVALID_HANDLE_VALUE
)
4260 trace("error creating event: %d\n", GetLastError());
4264 thread_params
.s
= server_socket
;
4265 thread_params
.ReadKilled
= FALSE
;
4266 thread_handle
= CreateThread(NULL
, 0, AcceptKillThread
, &thread_params
, 0, &id
);
4267 if (thread_handle
== NULL
)
4269 trace("error creating thread: %d\n", GetLastError());
4273 WaitForSingleObject(server_ready
, INFINITE
);
4275 ret
= closesocket(server_socket
);
4278 trace("closesocket failed: %d\n", WSAGetLastError());
4282 WaitForSingleObject(thread_handle
, 1000);
4283 ok(thread_params
.ReadKilled
|| broken(!thread_params
.ReadKilled
) /* Win98/ME, after accept */,
4284 "closesocket did not wakeup accept\n");
4286 closesocket(accepted
);
4287 closesocket(connector
);
4288 accepted
= connector
= INVALID_SOCKET
;
4290 socklen
= sizeof(address
);
4291 server_socket
= setup_server_socket(&address
, &socklen
);
4292 if (server_socket
== INVALID_SOCKET
) goto done
;
4294 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4295 if (connector
== INVALID_SOCKET
) goto done
;
4298 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
4299 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
4300 ok(!socklen
, "got %d\n", socklen
);
4301 closesocket(connector
);
4302 connector
= INVALID_SOCKET
;
4304 socklen
= sizeof(address
);
4305 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4306 if (connector
== INVALID_SOCKET
) goto done
;
4308 accepted
= WSAAccept(server_socket
, NULL
, NULL
, NULL
, 0);
4309 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
4310 closesocket(accepted
);
4311 closesocket(connector
);
4312 accepted
= connector
= INVALID_SOCKET
;
4314 socklen
= sizeof(address
);
4315 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4316 if (connector
== INVALID_SOCKET
) goto done
;
4318 socklen
= sizeof(ss
);
4319 memset(&ss
, 0, sizeof(ss
));
4320 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
4321 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
4322 ok(socklen
!= sizeof(ss
), "unexpected length\n");
4323 ok(ss
.ss_family
, "family not set\n");
4324 closesocket(accepted
);
4325 closesocket(connector
);
4326 accepted
= connector
= INVALID_SOCKET
;
4328 socklen
= sizeof(address
);
4329 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4330 if (connector
== INVALID_SOCKET
) goto done
;
4333 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
4334 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
4335 ok(!socklen
, "got %d\n", socklen
);
4336 closesocket(connector
);
4337 accepted
= connector
= INVALID_SOCKET
;
4339 socklen
= sizeof(address
);
4340 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4341 if (connector
== INVALID_SOCKET
) goto done
;
4343 accepted
= accept(server_socket
, NULL
, NULL
);
4344 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
4345 closesocket(accepted
);
4346 closesocket(connector
);
4347 accepted
= connector
= INVALID_SOCKET
;
4349 socklen
= sizeof(address
);
4350 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4351 if (connector
== INVALID_SOCKET
) goto done
;
4353 socklen
= sizeof(ss
);
4354 memset(&ss
, 0, sizeof(ss
));
4355 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
4356 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
4357 ok(socklen
!= sizeof(ss
), "unexpected length\n");
4358 ok(ss
.ss_family
, "family not set\n");
4359 closesocket(accepted
);
4360 closesocket(connector
);
4361 accepted
= connector
= INVALID_SOCKET
;
4363 socklen
= sizeof(address
);
4364 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4365 if (connector
== INVALID_SOCKET
) goto done
;
4367 memset(&ss
, 0, sizeof(ss
));
4368 memset(&ss_empty
, 0, sizeof(ss_empty
));
4369 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, NULL
);
4370 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
4371 ok(!memcmp(&ss
, &ss_empty
, sizeof(ss
)), "structure is different\n");
4374 if (accepted
!= INVALID_SOCKET
)
4375 closesocket(accepted
);
4376 if (connector
!= INVALID_SOCKET
)
4377 closesocket(connector
);
4378 if (thread_handle
!= NULL
)
4379 CloseHandle(thread_handle
);
4380 if (server_ready
!= INVALID_HANDLE_VALUE
)
4381 CloseHandle(server_ready
);
4382 if (server_socket
!= INVALID_SOCKET
)
4383 closesocket(server_socket
);
4386 static void test_extendedSocketOptions(void)
4390 struct sockaddr_in sa
;
4391 int sa_len
= sizeof(struct sockaddr_in
);
4392 int optval
, optlen
= sizeof(int), ret
;
4396 if(WSAStartup(MAKEWORD(2,0), &wsa
)){
4397 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4401 memset(&sa
, 0, sa_len
);
4403 sa
.sin_family
= AF_INET
;
4404 sa
.sin_port
= htons(0);
4405 sa
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
4407 if((sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
4408 trace("Creating the socket failed: %d\n", WSAGetLastError());
4413 if(bind(sock
, (struct sockaddr
*) &sa
, sa_len
) < 0){
4414 trace("Failed to bind socket: %d\n", WSAGetLastError());
4420 ret
= getsockopt(sock
, SOL_SOCKET
, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
4422 ok(ret
== 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret
);
4423 ok((optval
== 65507) || (optval
== 65527),
4424 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval
);
4426 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
4427 SetLastError(0xdeadbeef);
4428 optval
= 0xdeadbeef;
4429 optlen
= sizeof(int);
4430 ret
= getsockopt(sock
, 0xffffffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
4431 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
4432 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4433 ret
, WSAGetLastError(), optval
, optval
);
4435 /* more invalid values for level */
4436 SetLastError(0xdeadbeef);
4437 optval
= 0xdeadbeef;
4438 optlen
= sizeof(int);
4439 ret
= getsockopt(sock
, 0x1234ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
4440 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
4441 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4442 ret
, WSAGetLastError(), optval
, optval
);
4444 SetLastError(0xdeadbeef);
4445 optval
= 0xdeadbeef;
4446 optlen
= sizeof(int);
4447 ret
= getsockopt(sock
, 0x8000ffff, 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
, 0x00008000, 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
, 0x00000800, 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 optlen
= sizeof(LINGER
);
4470 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
4471 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAENOPROTOOPT
),
4472 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
4473 ret
, WSAGetLastError());
4476 if((sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
4477 trace("Creating the socket failed: %d\n", WSAGetLastError());
4482 if(bind(sock
, (struct sockaddr
*) &sa
, sa_len
) < 0){
4483 trace("Failed to bind socket: %d\n", WSAGetLastError());
4489 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
4490 ok(ret
== 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret
);
4492 optlen
= sizeof(BOOL
);
4493 ret
= getsockopt(sock
, SOL_SOCKET
, SO_DONTLINGER
, (char *)&bool_opt_val
, &optlen
);
4494 ok(ret
== 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret
);
4495 ok((linger_val
.l_onoff
&& !bool_opt_val
) || (!linger_val
.l_onoff
&& bool_opt_val
),
4496 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
4497 bool_opt_val
, linger_val
.l_onoff
);
4503 static void test_getsockname(void)
4507 struct sockaddr_in sa_set
, sa_get
;
4508 int sa_set_len
= sizeof(struct sockaddr_in
);
4509 int sa_get_len
= sa_set_len
;
4510 static const unsigned char null_padding
[] = {0,0,0,0,0,0,0,0};
4514 if(WSAStartup(MAKEWORD(2,0), &wsa
)){
4515 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4519 memset(&sa_set
, 0, sa_set_len
);
4521 sa_set
.sin_family
= AF_INET
;
4522 sa_set
.sin_port
= htons(0);
4523 sa_set
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
4525 if((sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
4526 trace("Creating the socket failed: %d\n", WSAGetLastError());
4532 if (getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
) == 0)
4533 ok(0, "getsockname on unbound socket should fail\n");
4535 ok(WSAGetLastError() == WSAEINVAL
, "getsockname on unbound socket "
4536 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL
);
4537 ok(memcmp(&sa_get
, &sa_set
, sizeof(sa_get
)) == 0,
4538 "failed getsockname modified sockaddr when it shouldn't\n");
4541 if(bind(sock
, (struct sockaddr
*) &sa_set
, sa_set_len
) < 0){
4542 trace("Failed to bind socket: %d\n", WSAGetLastError());
4548 if(getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
) != 0){
4549 trace("Failed to call getsockname: %d\n", WSAGetLastError());
4555 ret
= memcmp(sa_get
.sin_zero
, null_padding
, 8);
4556 ok(ret
== 0 || broken(ret
!= 0), /* NT4 */
4557 "getsockname did not zero the sockaddr_in structure\n");
4561 h
= gethostbyname("");
4562 if (h
&& h
->h_length
== 4) /* this test is only meaningful in IPv4 */
4565 for (i
= 0; h
->h_addr_list
[i
]; i
++)
4569 ip
.s_addr
= *(ULONG
*) h
->h_addr_list
[i
];
4571 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
4572 ok(sock
!= INVALID_SOCKET
, "socket failed with %d\n", GetLastError());
4574 memset(&sa_set
, 0, sizeof(sa_set
));
4575 sa_set
.sin_family
= AF_INET
;
4576 sa_set
.sin_addr
.s_addr
= ip
.s_addr
;
4577 /* The same address we bind must be the same address we get */
4578 ret
= bind(sock
, (struct sockaddr
*)&sa_set
, sizeof(sa_set
));
4579 ok(ret
== 0, "bind failed with %d\n", GetLastError());
4580 sa_get_len
= sizeof(sa_get
);
4581 ret
= getsockname(sock
, (struct sockaddr
*)&sa_get
, &sa_get_len
);
4582 ok(ret
== 0, "getsockname failed with %d\n", GetLastError());
4583 strcpy(ipstr
, inet_ntoa(sa_get
.sin_addr
));
4584 trace("testing bind on interface %s\n", ipstr
);
4585 ok(sa_get
.sin_addr
.s_addr
== sa_set
.sin_addr
.s_addr
,
4586 "address does not match: %s != %s\n", ipstr
, inet_ntoa(sa_set
.sin_addr
));
4595 static void test_dns(void)
4606 h
= gethostbyname("");
4607 ok(h
!= NULL
, "gethostbyname(\"\") failed with %d\n", h_errno
);
4609 /* Use an address with valid alias names if possible */
4610 h
= gethostbyname("source.winehq.org");
4613 skip("Can't test the hostent structure because gethostbyname failed\n");
4617 /* The returned struct must be allocated in a very strict way. First we need to
4618 * count how many aliases there are because they must be located right after
4619 * the struct hostent size. Knowing the amount of aliases we know the exact
4620 * location of the first IP returned. Rule valid for >= XP, for older OS's
4621 * it's somewhat the opposite. */
4623 if(h
->h_addr_list
== addr
.mem
) /* <= W2K */
4625 win_skip("Skipping hostent tests since this OS is unsupported\n");
4629 ok(h
->h_aliases
== addr
.mem
,
4630 "hostent->h_aliases should be in %p, it is in %p\n", addr
.mem
, h
->h_aliases
);
4632 for(ptr
= h
->h_aliases
, acount
= 1; *ptr
; ptr
++) acount
++;
4633 addr
.chr
+= sizeof(*ptr
) * acount
;
4634 ok(h
->h_addr_list
== addr
.mem
,
4635 "hostent->h_addr_list should be in %p, it is in %p\n", addr
.mem
, h
->h_addr_list
);
4637 for(ptr
= h
->h_addr_list
, acount
= 1; *ptr
; ptr
++) acount
++;
4639 addr
.chr
+= sizeof(*ptr
) * acount
;
4640 ok(h
->h_addr_list
[0] == addr
.mem
,
4641 "hostent->h_addr_list[0] should be in %p, it is in %p\n", addr
.mem
, h
->h_addr_list
[0]);
4644 /* Our winsock headers don't define gethostname because it conflicts with the
4645 * definition in unistd.h. Define it here to get rid of the warning. */
4647 int WINAPI
gethostname(char *name
, int namelen
);
4649 static void test_gethostbyname(void)
4652 struct in_addr
**addr_list
;
4653 char name
[256], first_ip
[16];
4655 PMIB_IPFORWARDTABLE routes
= NULL
;
4656 PIP_ADAPTER_INFO adapters
= NULL
, k
;
4657 DWORD adap_size
= 0, route_size
= 0;
4658 BOOL found_default
= FALSE
;
4659 BOOL local_ip
= FALSE
;
4661 ret
= gethostname(name
, sizeof(name
));
4662 ok(ret
== 0, "gethostname() call failed: %d\n", WSAGetLastError());
4664 he
= gethostbyname(name
);
4665 ok(he
!= NULL
, "gethostbyname(\"%s\") failed: %d\n", name
, WSAGetLastError());
4666 addr_list
= (struct in_addr
**)he
->h_addr_list
;
4667 strcpy(first_ip
, inet_ntoa(*addr_list
[0]));
4669 trace("List of local IPs:\n");
4670 for(count
= 0; addr_list
[count
] != NULL
; count
++)
4672 char *ip
= inet_ntoa(*addr_list
[count
]);
4673 if (!strcmp(ip
, "127.0.0.1"))
4680 ok (count
== 1, "expected 127.0.0.1 to be the only IP returned\n");
4681 skip("Only the loopback address is present, skipping tests\n");
4685 if (!pGetAdaptersInfo
|| !pGetIpForwardTable
)
4687 win_skip("GetAdaptersInfo and/or GetIpForwardTable not found, skipping tests\n");
4691 ret
= pGetAdaptersInfo(NULL
, &adap_size
);
4692 ok (ret
== ERROR_BUFFER_OVERFLOW
, "GetAdaptersInfo failed with a different error: %d\n", ret
);
4693 ret
= pGetIpForwardTable(NULL
, &route_size
, FALSE
);
4694 ok (ret
== ERROR_INSUFFICIENT_BUFFER
, "GetIpForwardTable failed with a different error: %d\n", ret
);
4696 adapters
= HeapAlloc(GetProcessHeap(), 0, adap_size
);
4697 routes
= HeapAlloc(GetProcessHeap(), 0, route_size
);
4699 ret
= pGetAdaptersInfo(adapters
, &adap_size
);
4700 ok (ret
== NO_ERROR
, "GetAdaptersInfo failed, error: %d\n", ret
);
4701 ret
= pGetIpForwardTable(routes
, &route_size
, FALSE
);
4702 ok (ret
== NO_ERROR
, "GetIpForwardTable failed, error: %d\n", ret
);
4704 /* This test only has meaning if there is more than one IP configured */
4705 if (adapters
->Next
== NULL
&& count
== 1)
4707 skip("Only one IP is present, skipping tests\n");
4711 for (i
= 0; !found_default
&& i
< routes
->dwNumEntries
; i
++)
4713 /* default route (ip 0.0.0.0) ? */
4714 if (routes
->table
[i
].dwForwardDest
) continue;
4716 for (k
= adapters
; k
!= NULL
; k
= k
->Next
)
4720 if (k
->Index
!= routes
->table
[i
].dwForwardIfIndex
) continue;
4722 /* the first IP returned from gethostbyname must be a default route */
4723 ip
= k
->IpAddressList
.IpAddress
.String
;
4724 if (!strcmp(first_ip
, ip
))
4726 found_default
= TRUE
;
4731 ok (found_default
, "failed to find the first IP from gethostbyname!\n");
4734 HeapFree(GetProcessHeap(), 0, adapters
);
4735 HeapFree(GetProcessHeap(), 0, routes
);
4738 static void test_gethostbyname_hack(void)
4742 static BYTE loopback
[] = {127, 0, 0, 1};
4743 static BYTE magic_loopback
[] = {127, 12, 34, 56};
4746 ret
= gethostname(name
, 256);
4747 ok(ret
== 0, "gethostname() call failed: %d\n", WSAGetLastError());
4749 he
= gethostbyname("localhost");
4750 ok(he
!= NULL
, "gethostbyname(\"localhost\") failed: %d\n", h_errno
);
4753 if(he
->h_length
!= 4)
4755 skip("h_length is %d, not IPv4, skipping test.\n", he
->h_length
);
4759 ok(memcmp(he
->h_addr_list
[0], loopback
, he
->h_length
) == 0,
4760 "gethostbyname(\"localhost\") returned %u.%u.%u.%u\n",
4761 he
->h_addr_list
[0][0], he
->h_addr_list
[0][1], he
->h_addr_list
[0][2],
4762 he
->h_addr_list
[0][3]);
4765 if(strcmp(name
, "localhost") == 0)
4767 skip("hostname seems to be \"localhost\", skipping test.\n");
4771 he
= gethostbyname(name
);
4772 ok(he
!= NULL
, "gethostbyname(\"%s\") failed: %d\n", name
, h_errno
);
4775 if(he
->h_length
!= 4)
4777 skip("h_length is %d, not IPv4, skipping test.\n", he
->h_length
);
4781 if (he
->h_addr_list
[0][0] == 127)
4783 ok(memcmp(he
->h_addr_list
[0], magic_loopback
, he
->h_length
) == 0,
4784 "gethostbyname(\"%s\") returned %u.%u.%u.%u not 127.12.34.56\n",
4785 name
, he
->h_addr_list
[0][0], he
->h_addr_list
[0][1],
4786 he
->h_addr_list
[0][2], he
->h_addr_list
[0][3]);
4790 gethostbyname("nonexistent.winehq.org");
4791 /* Don't check for the return value, as some braindead ISPs will kindly
4792 * resolve nonexistent host names to addresses of the ISP's spam pages. */
4795 static void test_gethostname(void)
4801 WSASetLastError(0xdeadbeef);
4802 ret
= gethostname(NULL
, 256);
4803 ok(ret
== -1, "gethostname() returned %d\n", ret
);
4804 ok(WSAGetLastError() == WSAEFAULT
, "gethostname with null buffer "
4805 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT
);
4807 ret
= gethostname(name
, sizeof(name
));
4808 ok(ret
== 0, "gethostname() call failed: %d\n", WSAGetLastError());
4809 he
= gethostbyname(name
);
4810 ok(he
!= NULL
, "gethostbyname(\"%s\") failed: %d\n", name
, WSAGetLastError());
4813 WSASetLastError(0xdeadbeef);
4814 strcpy(name
, "deadbeef");
4815 ret
= gethostname(name
, len
);
4816 ok(ret
== -1, "gethostname() returned %d\n", ret
);
4817 ok(!strcmp(name
, "deadbeef"), "name changed unexpected!\n");
4818 ok(WSAGetLastError() == WSAEFAULT
, "gethostname with insufficient length "
4819 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT
);
4822 ret
= gethostname(name
, len
);
4823 ok(ret
== 0, "gethostname() call failed: %d\n", WSAGetLastError());
4824 he
= gethostbyname(name
);
4825 ok(he
!= NULL
, "gethostbyname(\"%s\") failed: %d\n", name
, WSAGetLastError());
4828 static void test_inet_addr(void)
4832 addr
= inet_addr(NULL
);
4833 ok(addr
== INADDR_NONE
, "inet_addr succeeded unexpectedly\n");
4836 static void test_addr_to_print(void)
4842 struct in6_addr in6
;
4844 u_long addr0_Num
= 0x00000000;
4845 PCSTR addr0_Str
= "0.0.0.0";
4846 u_long addr1_Num
= 0x20201015;
4847 PCSTR addr1_Str
= "21.16.32.32";
4848 u_char addr2_Num
[16] = {0,0,0,0,0,0,0,0,0,0,0xff,0xfe,0xcC,0x98,0xbd,0x74};
4849 PCSTR addr2_Str
= "::fffe:cc98:bd74";
4850 u_char addr3_Num
[16] = {0x20,0x30,0xa4,0xb1};
4851 PCSTR addr3_Str
= "2030:a4b1::";
4852 u_char addr4_Num
[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0xcC,0x98,0xbd,0x74};
4853 PCSTR addr4_Str
= "::204.152.189.116";
4855 /* Test IPv4 addresses */
4856 in
.s_addr
= addr0_Num
;
4858 pdst
= inet_ntoa(*((struct in_addr
*)&in
.s_addr
));
4859 ok(pdst
!= NULL
, "inet_ntoa failed %s\n", dst
);
4860 ok(!strcmp(pdst
, addr0_Str
),"Address %s != %s\n", pdst
, addr0_Str
);
4862 /* Test that inet_ntoa and inet_ntop return the same value */
4863 in
.S_un
.S_addr
= addr1_Num
;
4864 pdst
= inet_ntoa(*((struct in_addr
*)&in
.s_addr
));
4865 ok(pdst
!= NULL
, "inet_ntoa failed %s\n", dst
);
4866 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
4868 /* InetNtop became available in Vista and Win2008 */
4871 win_skip("InetNtop not present, not executing tests\n");
4875 /* Second part of test */
4876 pdst
= pInetNtop(AF_INET
,(void*)&in
.s_addr
, dst
, sizeof(dst
));
4877 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst
);
4878 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
4880 /* Test invalid parm conditions */
4881 pdst
= pInetNtop(1, (void*)&in
.s_addr
, dst
, sizeof(dst
));
4882 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4883 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "Should be WSAEAFNOSUPPORT\n");
4885 /* Test Null destination */
4887 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, NULL
, sizeof(dst
));
4888 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4889 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4890 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4892 /* Test zero length passed */
4895 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, 0);
4896 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4897 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4898 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4900 /* Test length one shorter than the address length */
4903 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, 6);
4904 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4905 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4906 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4908 /* Test longer length is ok */
4911 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, sizeof(dst
)+1);
4912 ok(pdst
!= NULL
, "The pointer should be returned (%p)\n", pdst
);
4913 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
4915 /* Test the IPv6 addresses */
4917 /* Test an zero prefixed IPV6 address */
4918 memcpy(in6
.u
.Byte
, addr2_Num
, sizeof(addr2_Num
));
4919 pdst
= pInetNtop(AF_INET6
,(void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
4920 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
4921 ok(!strcmp(pdst
, addr2_Str
),"Address %s != %s\n", pdst
, addr2_Str
);
4923 /* Test an zero suffixed IPV6 address */
4924 memcpy(in6
.s6_addr
, addr3_Num
, sizeof(addr3_Num
));
4925 pdst
= pInetNtop(AF_INET6
,(void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
4926 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
4927 ok(!strcmp(pdst
, addr3_Str
),"Address %s != %s\n", pdst
, addr3_Str
);
4929 /* Test the IPv6 address contains the IPv4 address in IPv4 notation */
4930 memcpy(in6
.s6_addr
, addr4_Num
, sizeof(addr4_Num
));
4931 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
4932 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
4933 ok(!strcmp(pdst
, addr4_Str
),"Address %s != %s\n", pdst
, addr4_Str
);
4935 /* Test invalid parm conditions */
4936 memcpy(in6
.u
.Byte
, addr2_Num
, sizeof(addr2_Num
));
4938 /* Test Null destination */
4940 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, NULL
, sizeof(dst6
));
4941 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4942 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4943 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4945 /* Test zero length passed */
4948 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 0);
4949 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4950 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4951 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4953 /* Test length one shorter than the address length */
4956 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 16);
4957 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4958 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4959 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4961 /* Test longer length is ok */
4964 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 18);
4965 ok(pdst
!= NULL
, "The pointer should be returned (%p)\n", pdst
);
4967 static void test_inet_pton(void)
4973 const char *printable
, *collapsed
, *raw_data
;
4975 {AF_UNSPEC
, -1, WSAEFAULT
, /* Test 0 */
4977 {AF_INET
, -1, WSAEFAULT
,
4979 {AF_INET6
, -1, WSAEFAULT
,
4981 {AF_UNSPEC
, -1, WSAEAFNOSUPPORT
,
4982 "127.0.0.1", NULL
, NULL
},
4984 "127.0.0.1", "127.0.0.1",
4985 "\x7f\x00\x00\x01"},
4987 "127.0.0.1", "127.0.0.1", NULL
},
4989 "::1/128", NULL
, NULL
},
4991 "::1/128", NULL
, NULL
},
4992 {AF_UNSPEC
, -1, WSAEAFNOSUPPORT
,
4993 "broken", NULL
, NULL
},
4995 "broken", NULL
, NULL
},
4996 {AF_INET6
, 0, 0, /* Test 10 */
4997 "broken", NULL
, NULL
},
4998 {AF_UNSPEC
, -1, WSAEAFNOSUPPORT
,
4999 "177.32.45.20", NULL
, NULL
},
5001 "177.32.45.20", "177.32.45.20",
5002 "\xb1\x20\x2d\x14"},
5004 "177.32.45.20", NULL
, NULL
},
5006 "2607:f0d0:1002:51::4", NULL
, NULL
},
5008 "2607:f0d0:1002:51::4", "2607:f0d0:1002:51::4",
5009 "\x26\x07\xf0\xd0\x10\x02\x00\x51\x00\x00\x00\x00\x00\x00\x00\x04"},
5011 "::177.32.45.20", NULL
, NULL
},
5013 "::177.32.45.20", "::177.32.45.20",
5014 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x20\x2d\x14"},
5016 "fe80::0202:b3ff:fe1e:8329", NULL
, NULL
},
5018 "fe80::0202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
5019 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
5020 {AF_INET6
, 1, 0, /* Test 20 */
5021 "fe80::202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
5022 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
5028 "a.b.c", NULL
, NULL
},
5030 "a.b.c.d", NULL
, NULL
},
5032 "2001:cdba:0000:0000:0000:0000:3257:9652", "2001:cdba::3257:9652",
5033 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
5035 "2001:cdba::3257:9652", "2001:cdba::3257:9652",
5036 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
5038 "2001:cdba:0:0:0:0:3257:9652", "2001:cdba::3257:9652",
5039 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"}
5043 char buffer
[64],str
[64];
5044 WCHAR printableW
[64], collapsedW
[64];
5048 /* InetNtop and InetPton became available in Vista and Win2008 */
5049 if (!pInetNtop
|| !pInetNtopW
|| !pInetPtonA
|| !pInetPtonW
)
5051 win_skip("InetNtop and/or InetPton not present, not executing tests\n");
5055 for (i
= 0; i
< sizeof(tests
) / sizeof(tests
[0]); i
++)
5057 WSASetLastError(0xdeadbeef);
5058 ret
= pInetPtonA(tests
[i
].family
, tests
[i
].printable
, buffer
);
5059 ok (ret
== tests
[i
].ret
, "Test [%d]: Expected %d, got %d\n", i
, tests
[i
].ret
, ret
);
5060 if (tests
[i
].ret
== -1)
5062 err
= WSAGetLastError();
5063 ok (tests
[i
].err
== err
, "Test [%d]: Expected 0x%x, got 0x%x\n", i
, tests
[i
].err
, err
);
5065 if (tests
[i
].ret
!= 1) continue;
5066 ok (memcmp(buffer
, tests
[i
].raw_data
,
5067 tests
[i
].family
== AF_INET
? sizeof(struct in_addr
) : sizeof(struct in6_addr
)) == 0,
5068 "Test [%d]: Expected binary data differs\n", i
);
5070 /* Test the result from Pton with Ntop */
5071 strcpy (str
, "deadbeef");
5072 ptr
= pInetNtop(tests
[i
].family
, buffer
, str
, sizeof(str
));
5073 ok (ptr
!= NULL
, "Test [%d]: Failed with NULL\n", i
);
5074 ok (ptr
== str
, "Test [%d]: Pointers differ (%p != %p)\n", i
, ptr
, str
);
5076 ok (strcmp(ptr
, tests
[i
].collapsed
) == 0, "Test [%d]: Expected '%s', got '%s'\n",
5077 i
, tests
[i
].collapsed
, ptr
);
5080 for (i
= 0; i
< sizeof(tests
) / sizeof(tests
[0]); i
++)
5082 if (tests
[i
].printable
)
5083 MultiByteToWideChar(CP_ACP
, 0, tests
[i
].printable
, -1, printableW
,
5084 sizeof(printableW
) / sizeof(printableW
[0]));
5085 WSASetLastError(0xdeadbeef);
5086 ret
= pInetPtonW(tests
[i
].family
, tests
[i
].printable
? printableW
: NULL
, buffer
);
5087 ok(ret
== tests
[i
].ret
, "Test [%d]: Expected %d, got %d\n", i
, tests
[i
].ret
, ret
);
5088 if (tests
[i
].ret
== -1)
5090 err
= WSAGetLastError();
5091 ok(tests
[i
].err
== err
, "Test [%d]: Expected 0x%x, got 0x%x\n", i
, tests
[i
].err
, err
);
5093 if (tests
[i
].ret
!= 1) continue;
5094 ok(memcmp(buffer
, tests
[i
].raw_data
,
5095 tests
[i
].family
== AF_INET
? sizeof(struct in_addr
) : sizeof(struct in6_addr
)) == 0,
5096 "Test [%d]: Expected binary data differs\n", i
);
5098 /* Test the result from Pton with Ntop */
5099 printableW
[0] = 0xdead;
5100 ptrW
= pInetNtopW(tests
[i
].family
, buffer
, printableW
, sizeof(printableW
) / sizeof(printableW
[0]));
5101 ok (ptrW
!= NULL
, "Test [%d]: Failed with NULL\n", i
);
5102 ok (ptrW
== printableW
, "Test [%d]: Pointers differ (%p != %p)\n", i
, ptrW
, printableW
);
5103 if (!ptrW
) continue;
5105 MultiByteToWideChar(CP_ACP
, 0, tests
[i
].collapsed
, -1, collapsedW
,
5106 sizeof(collapsedW
) / sizeof(collapsedW
[0]));
5107 ok (lstrcmpW(ptrW
, collapsedW
) == 0, "Test [%d]: Expected '%s', got '%s'\n",
5108 i
, tests
[i
].collapsed
, wine_dbgstr_w(ptrW
));
5112 static void test_ioctlsocket(void)
5114 SOCKET sock
, src
, dst
;
5115 struct tcp_keepalive kalive
;
5117 static const LONG cmds
[] = {FIONBIO
, FIONREAD
, SIOCATMARK
};
5123 sock
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5124 ok(sock
!= INVALID_SOCKET
, "Creating the socket failed: %d\n", WSAGetLastError());
5125 if(sock
== INVALID_SOCKET
)
5127 skip("Can't continue without a socket.\n");
5131 for(i
= 0; i
< sizeof(cmds
)/sizeof(cmds
[0]); i
++)
5133 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
5134 ret
= ioctlsocket(sock
, cmds
[i
], (u_long
*)1);
5135 ok(ret
== SOCKET_ERROR
, "ioctlsocket succeeded unexpectedly\n");
5136 ret
= WSAGetLastError();
5137 ok(ret
== WSAEFAULT
, "expected WSAEFAULT, got %d instead\n", ret
);
5140 /* A fresh and not connected socket has no urgent data, this test shows
5141 * that normal(not urgent) data returns a non-zero value for SIOCATMARK. */
5143 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
5144 ok(ret
!= SOCKET_ERROR
, "ioctlsocket failed unexpectedly\n");
5145 ok(arg
, "SIOCATMARK expected a non-zero value\n");
5147 /* when SO_OOBINLINE is set SIOCATMARK must always return TRUE */
5149 ret
= setsockopt(sock
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&optval
, sizeof(optval
));
5150 ok(ret
!= SOCKET_ERROR
, "setsockopt failed unexpectedly\n");
5152 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
5153 ok(ret
!= SOCKET_ERROR
, "ioctlsocket failed unexpectedly\n");
5154 ok(arg
, "SIOCATMARK expected a non-zero value\n");
5156 /* disable SO_OOBINLINE and get the same old behavior */
5158 ret
= setsockopt(sock
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&optval
, sizeof(optval
));
5159 ok(ret
!= SOCKET_ERROR
, "setsockopt failed unexpectedly\n");
5161 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
5162 ok(ret
!= SOCKET_ERROR
, "ioctlsocket failed unexpectedly\n");
5163 ok(arg
, "SIOCATMARK expected a non-zero value\n");
5165 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &arg
, 0, NULL
, 0, &arg
, NULL
, NULL
);
5166 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
5167 ret
= WSAGetLastError();
5168 ok(ret
== WSAEFAULT
|| broken(ret
== WSAEINVAL
), "expected WSAEFAULT, got %d instead\n", ret
);
5170 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, NULL
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5171 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
5172 ret
= WSAGetLastError();
5173 ok(ret
== WSAEFAULT
|| broken(ret
== WSAEINVAL
), "expected WSAEFAULT, got %d instead\n", ret
);
5175 /* broken used to catch W95, W98, NT4 */
5176 make_keepalive(kalive
, 0, 0, 0);
5177 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5178 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
5180 make_keepalive(kalive
, 1, 0, 0);
5181 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5182 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
5184 make_keepalive(kalive
, 1, 1000, 1000);
5185 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5186 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
5188 make_keepalive(kalive
, 1, 10000, 10000);
5189 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5190 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
5192 make_keepalive(kalive
, 1, 100, 100);
5193 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5194 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
5196 make_keepalive(kalive
, 0, 100, 100);
5197 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5198 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
5202 if (tcp_socketpair(&src
, &dst
) != 0)
5204 ok(0, "creating socket pair failed, skipping test\n");
5208 /* test FIONREAD on TCP sockets */
5209 optval
= 0xdeadbeef;
5210 ret
= WSAIoctl(dst
, FIONREAD
, NULL
, 0, &optval
, sizeof(optval
), &arg
, NULL
, NULL
);
5211 ok(ret
== 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
5212 ok(optval
== 0, "FIONREAD should have returned 0 bytes, got %d instead\n", optval
);
5214 optval
= 0xdeadbeef;
5215 ok(send(src
, "TEST", 4, 0) == 4, "failed to send test data\n");
5217 ret
= WSAIoctl(dst
, FIONREAD
, NULL
, 0, &optval
, sizeof(optval
), &arg
, NULL
, NULL
);
5218 ok(ret
== 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
5219 ok(optval
== 4, "FIONREAD should have returned 4 bytes, got %d instead\n", optval
);
5221 /* trying to read from an OOB inlined socket with MSG_OOB results in WSAEINVAL */
5222 set_blocking(dst
, FALSE
);
5224 SetLastError(0xdeadbeef);
5225 ret
= recv(dst
, &data
, 1, i
);
5226 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
5227 ret
= GetLastError();
5228 ok(ret
== WSAEWOULDBLOCK
, "expected 10035, got %d\n", ret
);
5229 bufs
.len
= sizeof(char);
5231 ret
= WSARecv(dst
, &bufs
, 1, &bytes_rec
, &i
, NULL
, NULL
);
5232 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
5233 ret
= GetLastError();
5234 ok(ret
== WSAEWOULDBLOCK
, "expected 10035, got %d\n", ret
);
5236 ret
= setsockopt(dst
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&optval
, sizeof(optval
));
5237 ok(ret
!= SOCKET_ERROR
, "setsockopt failed unexpectedly\n");
5239 SetLastError(0xdeadbeef);
5240 ret
= recv(dst
, &data
, 1, i
);
5241 if (ret
== SOCKET_ERROR
)
5243 ret
= GetLastError();
5244 ok(ret
== WSAEINVAL
, "expected 10022, got %d\n", ret
);
5245 bufs
.len
= sizeof(char);
5247 ret
= WSARecv(dst
, &bufs
, 1, &bytes_rec
, &i
, NULL
, NULL
);
5248 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
5249 ret
= GetLastError();
5250 ok(ret
== WSAEINVAL
, "expected 10022, got %d\n", ret
);
5252 else ok(broken(ret
== 1) /* <= NT4 */, "expected error, got 1\n");
5255 optval
= 0xdeadbeef;
5256 ret
= WSAIoctl(dst
, FIONREAD
, NULL
, 0, &optval
, sizeof(optval
), &arg
, NULL
, NULL
);
5257 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
5258 ok(optval
== 0xdeadbeef, "FIONREAD should not have changed last error, got %d instead\n", optval
);
5262 static BOOL drain_pause
= FALSE
;
5263 static DWORD WINAPI
drain_socket_thread(LPVOID arg
)
5266 SOCKET sock
= *(SOCKET
*)arg
;
5269 while ((ret
= recv(sock
, buffer
, sizeof(buffer
), 0)) != 0)
5273 if (WSAGetLastError() == WSAEWOULDBLOCK
)
5277 FD_SET(sock
, &readset
);
5278 select(sock
+1, &readset
, NULL
, NULL
, NULL
);
5289 static void test_send(void)
5291 SOCKET src
= INVALID_SOCKET
;
5292 SOCKET dst
= INVALID_SOCKET
;
5293 HANDLE hThread
= NULL
;
5294 const int buflen
= 1024*1024;
5295 char *buffer
= NULL
;
5296 int ret
, i
, zero
= 0;
5300 DWORD id
, bytes_sent
, dwRet
;
5302 memset(&ov
, 0, sizeof(ov
));
5304 if (tcp_socketpair(&src
, &dst
) != 0)
5306 ok(0, "creating socket pair failed, skipping test\n");
5310 set_blocking(dst
, FALSE
);
5311 /* force disable buffering so we can get a pending overlapped request */
5312 ret
= setsockopt(dst
, SOL_SOCKET
, SO_SNDBUF
, (char *) &zero
, sizeof(zero
));
5313 ok(!ret
, "setsockopt SO_SNDBUF failed: %d - %d\n", ret
, GetLastError());
5315 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
5316 if (hThread
== NULL
)
5318 ok(0, "CreateThread failed, error %d\n", GetLastError());
5322 buffer
= HeapAlloc(GetProcessHeap(), 0, buflen
);
5325 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
5329 /* fill the buffer with some nonsense */
5330 for (i
= 0; i
< buflen
; ++i
)
5332 buffer
[i
] = (char) i
;
5335 ret
= send(src
, buffer
, buflen
, 0);
5337 ok(ret
== buflen
, "send should have sent %d bytes, but it only sent %d\n", buflen
, ret
);
5339 ok(0, "send failed, error %d\n", WSAGetLastError());
5344 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5345 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
5350 WSASetLastError(12345);
5351 ret
= WSASend(dst
, &buf
, 1, &bytes_sent
, 0, &ov
, NULL
);
5352 ok((ret
== SOCKET_ERROR
&& WSAGetLastError() == ERROR_IO_PENDING
) || broken(bytes_sent
== buflen
),
5353 "Failed to start overlapped send %d - %d - %d/%d\n", ret
, WSAGetLastError(), bytes_sent
, buflen
);
5355 /* don't check for completion yet, we may need to drain the buffer while still sending */
5356 set_blocking(src
, FALSE
);
5357 for (i
= 0; i
< buflen
; ++i
)
5361 ret
= recv(src
, buffer
, 1, 0);
5362 while (ret
== SOCKET_ERROR
&& GetLastError() == WSAEWOULDBLOCK
&& j
< 100)
5366 ret
= recv(src
, buffer
, 1, 0);
5369 ok(ret
== 1, "Failed to receive data %d - %d (got %d/%d)\n", ret
, GetLastError(), i
, buflen
);
5373 ok(buffer
[0] == (char) i
, "Received bad data at position %d\n", i
);
5376 dwRet
= WaitForSingleObject(ov
.hEvent
, 1000);
5377 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
5378 if (dwRet
== WAIT_OBJECT_0
)
5380 bret
= GetOverlappedResult((HANDLE
)dst
, &ov
, &bytes_sent
, FALSE
);
5381 ok((bret
&& bytes_sent
== buflen
) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
5382 "Got %d instead of %d (%d - %d)\n", bytes_sent
, buflen
, bret
, GetLastError());
5385 WSASetLastError(12345);
5386 ret
= WSASend(INVALID_SOCKET
, &buf
, 1, NULL
, 0, &ov
, NULL
);
5387 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
5388 "WSASend failed %d - %d\n", ret
, WSAGetLastError());
5390 WSASetLastError(12345);
5391 ret
= WSASend(dst
, &buf
, 1, NULL
, 0, &ov
, NULL
);
5392 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == ERROR_IO_PENDING
,
5393 "Failed to start overlapped send %d - %d\n", ret
, WSAGetLastError());
5396 if (src
!= INVALID_SOCKET
)
5398 if (dst
!= INVALID_SOCKET
)
5400 if (hThread
!= NULL
)
5402 dwRet
= WaitForSingleObject(hThread
, 500);
5403 ok(dwRet
== WAIT_OBJECT_0
, "failed to wait for thread termination: %d\n", GetLastError());
5404 CloseHandle(hThread
);
5407 CloseHandle(ov
.hEvent
);
5408 HeapFree(GetProcessHeap(), 0, buffer
);
5411 typedef struct async_message
5415 struct async_message
*next
;
5418 static struct async_message
*messages_received
;
5420 #define WM_SOCKET (WM_USER+100)
5421 static LRESULT CALLBACK
ws2_test_WndProc(HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
5423 struct async_message
*message
;
5428 message
= HeapAlloc(GetProcessHeap(), 0, sizeof(*message
));
5429 message
->socket
= (SOCKET
) wparam
;
5430 message
->lparam
= lparam
;
5431 message
->next
= NULL
;
5433 if (messages_received
)
5435 struct async_message
*last
= messages_received
;
5436 while (last
->next
) last
= last
->next
;
5437 last
->next
= message
;
5440 messages_received
= message
;
5444 return DefWindowProcA(hwnd
, msg
, wparam
, lparam
);
5447 static void get_event_details(int event
, int *bit
, char *name
)
5452 if (bit
) *bit
= FD_ACCEPT_BIT
;
5453 if (name
) strcpy(name
, "FD_ACCEPT");
5456 if (bit
) *bit
= FD_CONNECT_BIT
;
5457 if (name
) strcpy(name
, "FD_CONNECT");
5460 if (bit
) *bit
= FD_READ_BIT
;
5461 if (name
) strcpy(name
, "FD_READ");
5464 if (bit
) *bit
= FD_OOB_BIT
;
5465 if (name
) strcpy(name
, "FD_OOB");
5468 if (bit
) *bit
= FD_WRITE_BIT
;
5469 if (name
) strcpy(name
, "FD_WRITE");
5472 if (bit
) *bit
= FD_CLOSE_BIT
;
5473 if (name
) strcpy(name
, "FD_CLOSE");
5477 if (name
) sprintf(name
, "bad%x", event
);
5481 static const char *dbgstr_event_seq(const LPARAM
*seq
)
5483 static char message
[1024];
5491 get_event_details(WSAGETSELECTEVENT(*seq
), NULL
, name
);
5492 len
+= sprintf(message
+ len
, "%s(%d) ", name
, WSAGETSELECTERROR(*seq
));
5496 strcpy( message
+ len
, "]" );
5500 static char *dbgstr_event_seq_result(SOCKET s
, WSANETWORKEVENTS
*netEvents
)
5502 static char message
[1024];
5503 struct async_message
*curr
= messages_received
;
5504 int index
, error
, bit
= 0;
5514 if (bit
>= FD_MAX_EVENTS
) break;
5515 if ( !(netEvents
->lNetworkEvents
& (1 << bit
)) )
5520 get_event_details(1 << bit
, &index
, name
);
5521 error
= netEvents
->iErrorCode
[index
];
5527 if (curr
->socket
!= s
)
5532 get_event_details(WSAGETSELECTEVENT(curr
->lparam
), NULL
, name
);
5533 error
= WSAGETSELECTERROR(curr
->lparam
);
5537 len
+= sprintf(message
+ len
, "%s(%d) ", name
, error
);
5540 strcpy( message
+ len
, "]" );
5544 static void flush_events(SOCKET s
, HANDLE hEvent
)
5546 WSANETWORKEVENTS netEvents
;
5547 struct async_message
*prev
= NULL
, *curr
= messages_received
;
5551 if (hEvent
!= INVALID_HANDLE_VALUE
)
5553 dwRet
= WaitForSingleObject(hEvent
, 100);
5554 if (dwRet
== WAIT_OBJECT_0
)
5556 ret
= WSAEnumNetworkEvents(s
, hEvent
, &netEvents
);
5558 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret
);
5565 if (curr
->socket
== s
)
5567 if (prev
) prev
->next
= curr
->next
;
5568 else messages_received
= curr
->next
;
5570 HeapFree(GetProcessHeap(), 0, curr
);
5572 if (prev
) curr
= prev
->next
;
5573 else curr
= messages_received
;
5584 static int match_event_sequence(SOCKET s
, WSANETWORKEVENTS
*netEvents
, const LPARAM
*seq
)
5586 int event
, index
, error
, events
;
5587 struct async_message
*curr
;
5591 events
= netEvents
->lNetworkEvents
;
5594 event
= WSAGETSELECTEVENT(*seq
);
5595 error
= WSAGETSELECTERROR(*seq
);
5596 get_event_details(event
, &index
, NULL
);
5598 if (!(events
& event
) && index
!= -1)
5600 if (events
& event
&& index
!= -1)
5602 if (netEvents
->iErrorCode
[index
] != error
)
5613 curr
= messages_received
;
5616 if (curr
->socket
== s
)
5618 if (!*seq
) return 0;
5619 if (*seq
!= curr
->lparam
) return 0;
5630 /* checks for a sequence of events, (order only checked if window is used) */
5631 static void ok_event_sequence(SOCKET s
, HANDLE hEvent
, const LPARAM
*seq
, const LPARAM
**broken_seqs
, int completelyBroken
)
5634 WSANETWORKEVENTS events
, *netEvents
= NULL
;
5638 if (hEvent
!= INVALID_HANDLE_VALUE
)
5640 netEvents
= &events
;
5642 dwRet
= WaitForSingleObject(hEvent
, 200);
5643 if (dwRet
== WAIT_OBJECT_0
)
5645 ret
= WSAEnumNetworkEvents(s
, hEvent
, netEvents
);
5648 winetest_ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret
);
5653 memset(netEvents
, 0, sizeof(*netEvents
));
5658 /* Run the message loop a little */
5659 while (PeekMessageA( &msg
, 0, 0, 0, PM_REMOVE
))
5661 DispatchMessageA(&msg
);
5665 if (match_event_sequence(s
, netEvents
, seq
))
5667 winetest_ok(1, "Sequence matches expected: %s\n", dbgstr_event_seq(seq
));
5668 flush_events(s
, hEvent
);
5674 for (; *broken_seqs
; broken_seqs
++)
5676 if (match_event_sequence(s
, netEvents
, *broken_seqs
))
5678 winetest_ok(broken(1), "Sequence matches broken: %s, expected %s\n", dbgstr_event_seq_result(s
, netEvents
), dbgstr_event_seq(seq
));
5679 flush_events(s
, hEvent
);
5685 winetest_ok(broken(completelyBroken
), "Expected event sequence %s, got %s\n", dbgstr_event_seq(seq
),
5686 dbgstr_event_seq_result(s
, netEvents
));
5687 flush_events(s
, hEvent
);
5690 #define ok_event_seq (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : ok_event_sequence
5692 static void test_events(int useMessages
)
5694 SOCKET server
= INVALID_SOCKET
;
5695 SOCKET src
= INVALID_SOCKET
, src2
= INVALID_SOCKET
;
5696 SOCKET dst
= INVALID_SOCKET
, dst2
= INVALID_SOCKET
;
5697 struct sockaddr_in addr
;
5698 HANDLE hThread
= NULL
;
5699 HANDLE hEvent
= INVALID_HANDLE_VALUE
, hEvent2
= INVALID_HANDLE_VALUE
;
5700 WNDCLASSEXA wndclass
;
5702 char *buffer
= NULL
;
5703 int bufferSize
= 1024*1024;
5707 DWORD bytesReturned
;
5713 static char szClassName
[] = "wstestclass";
5714 const LPARAM
*broken_seq
[3];
5715 static const LPARAM empty_seq
[] = { 0 };
5716 static const LPARAM close_seq
[] = { WSAMAKESELECTREPLY(FD_CLOSE
, 0), 0 };
5717 static const LPARAM write_seq
[] = { WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
5718 static const LPARAM read_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0), 0 };
5719 static const LPARAM oob_seq
[] = { WSAMAKESELECTREPLY(FD_OOB
, 0), 0 };
5720 static const LPARAM connect_seq
[] = { WSAMAKESELECTREPLY(FD_CONNECT
, 0),
5721 WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
5722 static const LPARAM read_read_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
5723 WSAMAKESELECTREPLY(FD_READ
, 0), 0 };
5724 static const LPARAM read_write_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
5725 WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
5726 static const LPARAM read_close_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
5727 WSAMAKESELECTREPLY(FD_CLOSE
, 0), 0 };
5729 memset(&ov
, 0, sizeof(ov
));
5730 memset(&ov2
, 0, sizeof(ov2
));
5732 /* don't use socketpair, we want connection event */
5733 src
= socket(AF_INET
, SOCK_STREAM
, 0);
5734 if (src
== INVALID_SOCKET
)
5736 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5740 ret
= set_blocking(src
, TRUE
);
5741 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
5743 src2
= socket(AF_INET
, SOCK_STREAM
, 0);
5744 if (src2
== INVALID_SOCKET
)
5746 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5750 ret
= set_blocking(src2
, TRUE
);
5751 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
5754 if (getsockopt(src
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&bret
, &len
) == SOCKET_ERROR
)
5756 ok(0, "failed to get oobinline status, %d\n", GetLastError());
5759 ok(bret
== FALSE
, "OOB not inline\n");
5763 trace("Event test using messages\n");
5765 wndclass
.cbSize
= sizeof(wndclass
);
5766 wndclass
.style
= CS_HREDRAW
| CS_VREDRAW
;
5767 wndclass
.lpfnWndProc
= ws2_test_WndProc
;
5768 wndclass
.cbClsExtra
= 0;
5769 wndclass
.cbWndExtra
= 0;
5770 wndclass
.hInstance
= GetModuleHandleA(NULL
);
5771 wndclass
.hIcon
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
5772 wndclass
.hIconSm
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
5773 wndclass
.hCursor
= LoadCursorA(NULL
, (LPCSTR
)IDC_ARROW
);
5774 wndclass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
5775 wndclass
.lpszClassName
= szClassName
;
5776 wndclass
.lpszMenuName
= NULL
;
5777 RegisterClassExA(&wndclass
);
5779 hWnd
= CreateWindowA(szClassName
, "WS2Test", WS_OVERLAPPEDWINDOW
,
5780 0, 0, 500, 500, NULL
, NULL
, GetModuleHandleA(NULL
), NULL
);
5783 ok(0, "failed to create window: %d\n", GetLastError());
5787 ret
= WSAAsyncSelect(src
, hWnd
, WM_SOCKET
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
5790 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
5794 ok(set_blocking(src
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
5795 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5797 ret
= WSAAsyncSelect(src2
, hWnd
, WM_SOCKET
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
5800 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
5804 ok(set_blocking(src2
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
5805 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5809 trace("Event test using events\n");
5811 hEvent
= WSACreateEvent();
5812 if (hEvent
== INVALID_HANDLE_VALUE
)
5814 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5818 hEvent2
= WSACreateEvent();
5819 if (hEvent2
== INVALID_HANDLE_VALUE
)
5821 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5825 ret
= WSAEventSelect(src
, hEvent
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
5828 ok(0, "WSAEventSelect failed, error %d\n", ret
);
5832 ok(set_blocking(src
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
5833 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5835 ret
= WSAEventSelect(src2
, hEvent2
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
5838 ok(0, "WSAEventSelect failed, error %d\n", ret
);
5842 ok(set_blocking(src2
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
5843 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5846 server
= socket(AF_INET
, SOCK_STREAM
, 0);
5847 if (server
== INVALID_SOCKET
)
5849 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5853 memset(&addr
, 0, sizeof(addr
));
5854 addr
.sin_family
= AF_INET
;
5855 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5856 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
5859 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5864 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
5867 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5871 ret
= listen(server
, 2);
5874 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5878 SetLastError(0xdeadbeef);
5879 ret
= connect(src
, NULL
, 0);
5880 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
5881 ok(GetLastError() == WSAEFAULT
, "expected 10014, got %d\n", GetLastError());
5883 ret
= connect(src
, (struct sockaddr
*)&addr
, sizeof(addr
));
5884 if (ret
== SOCKET_ERROR
&& WSAGetLastError() != WSAEWOULDBLOCK
)
5886 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5890 ret
= connect(src2
, (struct sockaddr
*)&addr
, sizeof(addr
));
5891 if (ret
== SOCKET_ERROR
&& WSAGetLastError() != WSAEWOULDBLOCK
)
5893 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5898 dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
5899 if (dst
== INVALID_SOCKET
)
5901 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5906 dst2
= accept(server
, (struct sockaddr
*)&addr
, &len
);
5907 if (dst2
== INVALID_SOCKET
)
5909 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5913 closesocket(server
);
5914 server
= INVALID_SOCKET
;
5916 /* On Windows it seems when a non-blocking socket sends to a
5917 blocking socket on the same host, the send() is BLOCKING,
5918 so make both sockets non-blocking. src is already non-blocking
5919 from the async select */
5921 if (set_blocking(dst
, FALSE
))
5923 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
5927 buffer
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, bufferSize
);
5930 ok(0, "could not allocate memory for test\n");
5934 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5935 if (ov
.hEvent
== NULL
)
5937 ok(0, "could not create event object, errno = %d\n", GetLastError());
5941 ov2
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5942 if (ov2
.hEvent
== NULL
)
5944 ok(0, "could not create event object, errno = %d\n", GetLastError());
5948 /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
5949 ok_event_seq(src
, hEvent
, connect_seq
, NULL
, 1);
5950 ok_event_seq(src2
, hEvent2
, connect_seq
, NULL
, 1);
5951 /* broken on all windows - FD_CONNECT error is garbage */
5953 /* Test simple send/recv */
5954 SetLastError(0xdeadbeef);
5955 ret
= send(dst
, buffer
, 100, 0);
5956 ok(ret
== 100, "Failed to send buffer %d err %d\n", ret
, GetLastError());
5957 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5958 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
5960 SetLastError(0xdeadbeef);
5961 ret
= recv(src
, buffer
, 1, MSG_PEEK
);
5962 ok(ret
== 1, "Failed to peek at recv buffer %d err %d\n", ret
, GetLastError());
5963 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5964 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
5966 SetLastError(0xdeadbeef);
5967 ret
= recv(src
, buffer
, 50, 0);
5968 ok(ret
== 50, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
5969 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5970 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
5972 ret
= recv(src
, buffer
, 50, 0);
5973 ok(ret
== 50, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
5974 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
5976 /* fun fact - events are re-enabled even on failure, but only for messages */
5977 ret
= send(dst
, "1", 1, 0);
5978 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
5979 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
5981 ret
= recv(src
, buffer
, -1, 0);
5982 ok(ret
== SOCKET_ERROR
&& (GetLastError() == WSAEFAULT
|| GetLastError() == WSAENOBUFS
),
5983 "Failed to recv buffer %d err %d\n", ret
, GetLastError());
5986 broken_seq
[0] = empty_seq
; /* win9x */
5987 broken_seq
[1] = NULL
;
5988 todo_wine
ok_event_seq(src
, hEvent
, read_seq
, broken_seq
, 0);
5991 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
5993 SetLastError(0xdeadbeef);
5994 ret
= recv(src
, buffer
, 1, 0);
5995 ok(ret
== 1, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
5996 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5997 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
5999 /* Interaction with overlapped */
6000 bufs
.len
= sizeof(char);
6002 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
6003 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
6004 "WSARecv failed - %d error %d\n", ret
, GetLastError());
6006 bufs
.len
= sizeof(char);
6007 bufs
.buf
= buffer
+1;
6008 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov2
, NULL
);
6009 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
6010 "WSARecv failed - %d error %d\n", ret
, GetLastError());
6012 ret
= send(dst
, "12", 2, 0);
6013 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
6014 broken_seq
[0] = read_read_seq
; /* win9x */
6015 broken_seq
[1] = NULL
;
6016 ok_event_seq(src
, hEvent
, empty_seq
, broken_seq
, 0);
6018 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
6019 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
6020 if (dwRet
== WAIT_OBJECT_0
)
6022 bret
= GetOverlappedResult((HANDLE
)src
, &ov
, &bytesReturned
, FALSE
);
6023 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
6024 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
6025 ok(buffer
[0] == '1', "Got %c instead of 1\n", buffer
[0]);
6028 dwRet
= WaitForSingleObject(ov2
.hEvent
, 100);
6029 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
6030 if (dwRet
== WAIT_OBJECT_0
)
6032 bret
= GetOverlappedResult((HANDLE
)src
, &ov2
, &bytesReturned
, FALSE
);
6033 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
6034 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
6035 ok(buffer
[1] == '2', "Got %c instead of 2\n", buffer
[1]);
6038 SetLastError(0xdeadbeef);
6039 ret
= send(dst
, "1", 1, 0);
6040 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
6041 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6042 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
6044 ret
= recv(src
, buffer
, 1, 0);
6045 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
6046 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
6048 /* Notifications are delivered as soon as possible, blocked only on
6049 * async requests on the same type */
6050 bufs
.len
= sizeof(char);
6052 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
6053 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
6054 "WSARecv failed - %d error %d\n", ret
, GetLastError());
6057 ret
= send(dst
, "1", 1, MSG_OOB
);
6058 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
6059 ok_event_seq(src
, hEvent
, oob_seq
, NULL
, 0);
6062 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
6063 ok(dwRet
== WAIT_TIMEOUT
, "OOB message activated read?: %d - %d\n", dwRet
, GetLastError());
6065 ret
= send(dst
, "2", 1, 0);
6066 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
6067 broken_seq
[0] = read_seq
; /* win98 */
6068 broken_seq
[1] = NULL
;
6069 ok_event_seq(src
, hEvent
, empty_seq
, broken_seq
, 0);
6071 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
6072 ok(dwRet
== WAIT_OBJECT_0
|| broken(dwRet
== WAIT_TIMEOUT
),
6073 "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
6074 if (dwRet
== WAIT_OBJECT_0
)
6076 bret
= GetOverlappedResult((HANDLE
)src
, &ov
, &bytesReturned
, FALSE
);
6077 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
6078 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
6079 ok(buffer
[0] == '2', "Got %c instead of 2\n", buffer
[0]);
6081 else if (dwRet
== WAIT_TIMEOUT
)
6083 /* this happens on win98. We get an FD_READ later on the next test */
6084 CancelIo((HANDLE
) src
);
6088 ret
= recv(src
, buffer
, 1, MSG_OOB
);
6089 todo_wine
ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
6090 /* We get OOB notification, but no data on wine */
6091 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
6094 /* Flood the send queue */
6095 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
6096 if (hThread
== NULL
)
6098 ok(0, "CreateThread failed, error %d\n", GetLastError());
6102 /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
6103 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
6105 /* Now if we send a ton of data and the 'server' does not drain it fast
6106 * enough (set drain_pause to be sure), the socket send buffer will only
6107 * take some of it, and we will get a short write. This will trigger
6108 * another FD_WRITE event as soon as data is sent and more space becomes
6109 * available, but not any earlier. */
6113 ret
= send(src
, buffer
, bufferSize
, 0);
6114 } while (ret
== bufferSize
);
6115 drain_pause
= FALSE
;
6116 if (ret
>= 0 || WSAGetLastError() == WSAEWOULDBLOCK
)
6118 Sleep(400); /* win9x */
6119 broken_seq
[0] = read_write_seq
;
6120 broken_seq
[1] = NULL
;
6121 ok_event_seq(src
, hEvent
, write_seq
, broken_seq
, 0);
6125 ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
6128 /* Test how FD_CLOSE is handled */
6129 ret
= send(dst
, "12", 2, 0);
6130 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
6132 /* Wait a little and let the send complete */
6135 dst
= INVALID_SOCKET
;
6138 /* We can never implement this in wine, best we can hope for is
6139 sending FD_CLOSE after the reads complete */
6140 broken_seq
[0] = read_seq
; /* win9x */
6141 broken_seq
[1] = NULL
;
6142 todo_wine
ok_event_seq(src
, hEvent
, read_close_seq
, broken_seq
, 0);
6144 ret
= recv(src
, buffer
, 1, 0);
6145 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
6146 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
6148 ret
= recv(src
, buffer
, 1, 0);
6149 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
6150 /* want it? it's here, but you can't have it */
6151 broken_seq
[0] = close_seq
; /* win9x */
6152 broken_seq
[1] = NULL
;
6153 todo_wine
ok_event_seq(src
, hEvent
, empty_seq
, /* wine sends FD_CLOSE here */
6156 /* Test how FD_CLOSE is handled */
6157 ret
= send(dst2
, "12", 2, 0);
6158 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
6161 shutdown(dst2
, SD_SEND
);
6164 /* Some of the below are technically todo_wine, but our event sequence is still valid, so to prevent
6165 regressions, don't mark them as todo_wine, and mark windows as broken */
6166 broken_seq
[0] = read_close_seq
;
6167 broken_seq
[1] = close_seq
;
6168 broken_seq
[2] = NULL
;
6169 ok_event_seq(src2
, hEvent2
, read_seq
, broken_seq
, 0);
6171 ret
= recv(src2
, buffer
, 1, 0);
6172 ok(ret
== 1 || broken(!ret
), "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
6173 broken_seq
[0] = close_seq
; /* win98 */
6174 broken_seq
[1] = NULL
;
6175 ok_event_seq(src2
, hEvent2
, read_seq
, broken_seq
, 0);
6177 ret
= recv(src2
, buffer
, 1, 0);
6178 ok(ret
== 1 || broken(!ret
), "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
6179 broken_seq
[0] = empty_seq
;
6180 broken_seq
[1] = NULL
;
6181 ok_event_seq(src2
, hEvent2
, close_seq
, broken_seq
, 0);
6183 ret
= send(src2
, "1", 1, 0);
6184 ok(ret
== 1, "Sending to half-closed socket failed %d err %d\n", ret
, GetLastError());
6185 ok_event_seq(src2
, hEvent2
, empty_seq
, NULL
, 0);
6187 ret
= send(src2
, "1", 1, 0);
6188 ok(ret
== 1, "Sending to half-closed socket failed %d err %d\n", ret
, GetLastError());
6189 ok_event_seq(src2
, hEvent2
, empty_seq
, NULL
, 0);
6193 ret
= WSAAsyncSelect(src
, hWnd
, WM_SOCKET
, 0);
6196 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
6200 ret
= set_blocking(src
, TRUE
);
6201 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
6203 ret
= WSAAsyncSelect(src2
, hWnd
, WM_SOCKET
, 0);
6206 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
6210 ret
= set_blocking(src2
, TRUE
);
6211 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
6215 ret
= WSAEventSelect(src
, hEvent2
, 0);
6218 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
6222 ret
= set_blocking(src
, TRUE
);
6223 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
6225 ret
= WSAEventSelect(src2
, hEvent2
, 0);
6228 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
6232 ret
= set_blocking(src2
, TRUE
);
6233 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
6237 if (src
!= INVALID_SOCKET
)
6239 flush_events(src
, hEvent
);
6242 if (src2
!= INVALID_SOCKET
)
6244 flush_events(src2
, hEvent2
);
6247 HeapFree(GetProcessHeap(), 0, buffer
);
6248 if (server
!= INVALID_SOCKET
)
6249 closesocket(server
);
6250 if (dst
!= INVALID_SOCKET
)
6252 if (dst2
!= INVALID_SOCKET
)
6254 if (hThread
!= NULL
)
6255 CloseHandle(hThread
);
6257 DestroyWindow(hWnd
);
6259 CloseHandle(hEvent
);
6260 if (hEvent2
!= NULL
)
6261 CloseHandle(hEvent2
);
6262 if (ov
.hEvent
!= NULL
)
6263 CloseHandle(ov
.hEvent
);
6264 if (ov2
.hEvent
!= NULL
)
6265 CloseHandle(ov2
.hEvent
);
6268 static void test_ipv6only(void)
6270 SOCKET v4
= INVALID_SOCKET
, v6
;
6271 struct sockaddr_in sin4
;
6272 struct sockaddr_in6 sin6
;
6273 int ret
, enabled
, len
= sizeof(enabled
);
6275 memset(&sin4
, 0, sizeof(sin4
));
6276 sin4
.sin_family
= AF_INET
;
6277 sin4
.sin_port
= htons(SERVERPORT
);
6279 memset(&sin6
, 0, sizeof(sin6
));
6280 sin6
.sin6_family
= AF_INET6
;
6281 sin6
.sin6_port
= htons(SERVERPORT
);
6283 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
6284 if (v6
== INVALID_SOCKET
)
6286 skip("Could not create IPv6 socket (LastError: %d)\n", WSAGetLastError());
6291 ret
= getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
6292 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6293 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
6295 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
6298 skip("Could not bind IPv6 address (LastError: %d)\n", WSAGetLastError());
6302 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6303 ok(v4
!= INVALID_SOCKET
, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
6307 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
6308 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6309 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
6313 len
= sizeof(enabled
);
6314 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
6315 ok(!ret
, "setsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6319 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
6320 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6321 ok(!enabled
, "expected 0, got %d\n", enabled
);
6325 len
= sizeof(enabled
);
6326 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
6327 ok(!ret
, "setsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6329 /* bind on IPv4 socket should succeed - IPV6_V6ONLY is enabled by default */
6330 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
6331 ok(!ret
, "Could not bind IPv4 address (LastError: %d)\n", WSAGetLastError());
6335 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
6336 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6337 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
6341 len
= sizeof(enabled
);
6342 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
6343 ok(ret
, "setsockopt(IPV6_ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
6347 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
6348 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6349 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
6353 len
= sizeof(enabled
);
6354 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
6355 ok(ret
, "setsockopt(IPV6_ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
6360 /* Test again, this time disabling IPV6_V6ONLY. */
6361 sin4
.sin_port
= htons(SERVERPORT
+2);
6362 sin6
.sin6_port
= htons(SERVERPORT
+2);
6364 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
6365 ok(v6
!= INVALID_SOCKET
, "Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
6366 WSAGetLastError(), WSAEAFNOSUPPORT
);
6369 ret
= setsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
6370 ok(!ret
, "Could not disable IPV6_V6ONLY (LastError: %d).\n", WSAGetLastError());
6373 ret
= getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
6374 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6375 ok(!enabled
, "expected 0, got %d\n", enabled
);
6379 On Windows, bind on both IPv4 and IPv6 with IPV6_V6ONLY disabled succeeds by default.
6380 Application must set SO_EXCLUSIVEADDRUSE on first socket to disallow another successful bind.
6381 In general, a standard application should not use SO_REUSEADDR.
6382 Setting both SO_EXCLUSIVEADDRUSE and SO_REUSEADDR on the same socket is not possible in
6383 either order, the later setsockopt call always fails.
6386 ret
= setsockopt(v6
, SOL_SOCKET
, SO_EXCLUSIVEADDRUSE
, (char*)&enabled
, len
);
6387 ok(!ret
, "Could not set SO_EXCLUSIVEADDRUSE on IPv6 socket (LastError: %d)\n", WSAGetLastError());
6389 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
6390 ok(!ret
, "Could not bind IPv6 address (LastError: %d)\n", WSAGetLastError());
6393 len
= sizeof(enabled
);
6394 getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
6395 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6396 ok(!enabled
, "IPV6_V6ONLY is enabled after bind\n");
6398 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6399 ok(v4
!= INVALID_SOCKET
, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
6402 ret
= setsockopt(v4
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&enabled
, len
);
6403 ok(!ret
, "Could not set SO_REUSEADDR on IPv4 socket (LastError: %d)\n", WSAGetLastError());
6405 WSASetLastError(0xdeadbeef);
6406 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
6407 ok(ret
, "bind succeeded unexpectedly for the IPv4 socket\n");
6408 ok(WSAGetLastError() == WSAEACCES
, "Expected 10013, got %d\n", WSAGetLastError());
6411 if (v4
!= INVALID_SOCKET
)
6413 if (v6
!= INVALID_SOCKET
)
6417 static void test_WSASendMsg(void)
6420 struct sockaddr_in sendaddr
, sockaddr
;
6421 GUID WSASendMsg_GUID
= WSAID_WSASENDMSG
;
6422 LPFN_WSASENDMSG pWSASendMsg
= NULL
;
6423 char teststr
[12] = "hello world", buffer
[32];
6426 DWORD bytesSent
, err
;
6429 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
6431 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
6432 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
6434 /* Obtain the WSASendMsg function */
6435 WSAIoctl(sock
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSASendMsg_GUID
, sizeof(WSASendMsg_GUID
),
6436 &pWSASendMsg
, sizeof(pWSASendMsg
), &err
, NULL
, NULL
);
6440 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
6444 /* fake address for now */
6445 sendaddr
.sin_family
= AF_INET
;
6446 sendaddr
.sin_port
= htons(139);
6447 sendaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6449 memset(&msg
, 0, sizeof(msg
));
6450 iovec
[0].buf
= teststr
;
6451 iovec
[0].len
= sizeof(teststr
);
6452 iovec
[1].buf
= teststr
;
6453 iovec
[1].len
= sizeof(teststr
) / 2;
6454 msg
.name
= (struct sockaddr
*) &sendaddr
;
6455 msg
.namelen
= sizeof(sendaddr
);
6456 msg
.lpBuffers
= iovec
;
6457 msg
.dwBufferCount
= 1; /* send only one buffer for now */
6459 WSASetLastError(0xdeadbeef);
6460 ret
= pWSASendMsg(INVALID_SOCKET
, &msg
, 0, NULL
, NULL
, NULL
);
6461 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
6462 err
= WSAGetLastError();
6463 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
6465 WSASetLastError(0xdeadbeef);
6466 ret
= pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
);
6467 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
6468 err
= WSAGetLastError();
6469 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
6471 WSASetLastError(0xdeadbeef);
6472 ret
= pWSASendMsg(sock
, NULL
, 0, &bytesSent
, NULL
, NULL
);
6473 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
6474 err
= WSAGetLastError();
6475 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
6477 WSASetLastError(0xdeadbeef);
6478 ret
= pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
);
6479 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
6480 err
= WSAGetLastError();
6481 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
6485 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
6486 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
6488 dst
= socket(AF_INET
, SOCK_DGRAM
, 0);
6489 ok(dst
!= INVALID_SOCKET
, "socket() failed\n");
6491 memset(&sockaddr
, 0, sizeof(sockaddr
));
6492 sockaddr
.sin_family
= AF_INET
;
6493 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6494 ok(!bind(dst
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
)),
6495 "bind should have worked\n");
6497 /* read address to find out the port number to be used in send */
6498 memset(&sendaddr
, 0, sizeof(sendaddr
));
6499 addrlen
= sizeof(sendaddr
);
6500 ok(!getsockname(dst
, (struct sockaddr
*) &sendaddr
, &addrlen
),
6501 "getsockname should have worked\n");
6502 ok(sendaddr
.sin_port
, "socket port should be != 0\n");
6504 /* ensure the sending socket is not bound */
6505 WSASetLastError(0xdeadbeef);
6506 addrlen
= sizeof(sockaddr
);
6507 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
6508 ok(ret
== SOCKET_ERROR
, "getsockname should have failed\n");
6509 err
= WSAGetLastError();
6510 ok(err
== WSAEINVAL
, "expected 10022, got %d instead\n", err
);
6512 set_blocking(sock
, TRUE
);
6515 SetLastError(0xdeadbeef);
6516 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
6517 ok(!ret
, "WSASendMsg should have worked\n");
6518 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
6519 "Expected 0, got %d\n", GetLastError());
6520 ok(bytesSent
== iovec
[0].len
, "incorret bytes sent, expected %d, sent %d\n",
6521 iovec
[0].len
, bytesSent
);
6524 addrlen
= sizeof(sockaddr
);
6525 memset(buffer
, 0, sizeof(buffer
));
6526 SetLastError(0xdeadbeef);
6527 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
6528 ok(ret
== bytesSent
, "got %d, expected %d\n",
6530 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6532 /* A successful call to WSASendMsg must have bound the socket */
6533 addrlen
= sizeof(sockaddr
);
6534 sockaddr
.sin_port
= 0;
6535 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6536 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
6537 ok(!ret
, "getsockname should have worked\n");
6538 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
6539 inet_ntoa(sockaddr
.sin_addr
));
6540 ok(sockaddr
.sin_port
, "sin_port should be != 0\n");
6542 msg
.dwBufferCount
= 2; /* send both buffers */
6545 SetLastError(0xdeadbeef);
6546 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
6547 ok(!ret
, "WSASendMsg should have worked\n");
6548 ok(bytesSent
== iovec
[0].len
+ iovec
[1].len
, "incorret bytes sent, expected %d, sent %d\n",
6549 iovec
[0].len
+ iovec
[1].len
, bytesSent
);
6550 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
6551 "Expected 0, got %d\n", GetLastError());
6554 addrlen
= sizeof(sockaddr
);
6555 memset(buffer
, 0, sizeof(buffer
));
6556 SetLastError(0xdeadbeef);
6557 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
6558 ok(ret
== bytesSent
, "got %d, expected %d\n",
6560 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6565 /* a bad call to WSASendMsg will also bind the socket */
6566 addrlen
= sizeof(sockaddr
);
6567 sockaddr
.sin_port
= 0;
6568 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6569 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
6570 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
6571 ok(pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
6573 ok(!getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have worked\n");
6574 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
6575 inet_ntoa(sockaddr
.sin_addr
));
6576 ok(sockaddr
.sin_port
, "sin_port should be > 0\n");
6580 /* a bad call without msg parameter will not trigger the auto-bind */
6581 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
6582 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
6583 ok(pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
6584 ok(getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have failed\n");
6585 err
= WSAGetLastError();
6586 ok(err
== WSAEINVAL
, "expected 10022, got %d instead\n", err
);
6589 /* SOCK_STREAM sockets are not supported */
6591 sock
= socket(AF_INET
, SOCK_STREAM
, 0);
6592 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
6593 SetLastError(0xdeadbeef);
6594 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
6595 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
6596 err
= WSAGetLastError();
6598 ok(err
== WSAEINVAL
, "expected 10014, got %d instead\n", err
);
6602 static void test_WSASendTo(void)
6605 struct sockaddr_in addr
;
6606 char buf
[12] = "hello world";
6611 addr
.sin_family
= AF_INET
;
6612 addr
.sin_port
= htons(139);
6613 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6614 data_buf
.len
= sizeof(buf
);
6617 if( (s
= socket(AF_INET
, SOCK_DGRAM
, 0)) == INVALID_SOCKET
) {
6618 ok(0, "socket() failed error: %d\n", WSAGetLastError());
6622 WSASetLastError(12345);
6623 ret
= WSASendTo(INVALID_SOCKET
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
6624 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
6625 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
6627 WSASetLastError(12345);
6628 ret
= WSASendTo(s
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
6629 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
6630 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
6632 WSASetLastError(12345);
6633 if(WSASendTo(s
, &data_buf
, 1, &bytesSent
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
)) {
6634 ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
6637 ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
6638 "a successful call to WSASendTo()\n");
6641 static DWORD WINAPI
recv_thread(LPVOID arg
)
6643 SOCKET sock
= *(SOCKET
*)arg
;
6650 wsa
.len
= sizeof(buffer
);
6651 ov
.hEvent
= WSACreateEvent();
6652 WSARecv(sock
, &wsa
, 1, NULL
, &flags
, &ov
, NULL
);
6654 WaitForSingleObject(ov
.hEvent
, 1000);
6655 WSACloseEvent(ov
.hEvent
);
6659 static int completion_called
;
6661 static void WINAPI
io_completion(DWORD error
, DWORD transferred
, WSAOVERLAPPED
*overlapped
, DWORD flags
)
6663 completion_called
++;
6666 static void test_WSARecv(void)
6668 SOCKET src
, dest
, server
= INVALID_SOCKET
;
6672 DWORD bytesReturned
, flags
, id
;
6674 struct sockaddr_in addr
;
6678 HANDLE thread
, event
= NULL
, io_port
;
6680 tcp_socketpair(&src
, &dest
);
6681 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
6683 skip("failed to create sockets\n");
6687 memset(&ov
, 0, sizeof(ov
));
6692 /* Send 4 bytes and receive in two calls of 2 */
6693 SetLastError(0xdeadbeef);
6694 iret
= send(src
, "test", 4, 0);
6695 ok(iret
== 4, "Expected 4, got %d\n", iret
);
6696 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6697 SetLastError(0xdeadbeef);
6698 bytesReturned
= 0xdeadbeef;
6699 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
6700 ok(!iret
, "Expected 0, got %d\n", iret
);
6701 ok(bytesReturned
== 2, "Expected 2, got %d\n", bytesReturned
);
6702 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6703 SetLastError(0xdeadbeef);
6704 bytesReturned
= 0xdeadbeef;
6705 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
6706 ok(!iret
, "Expected 0, got %d\n", iret
);
6707 ok(bytesReturned
== 2, "Expected 2, got %d\n", bytesReturned
);
6708 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6711 SetLastError(0xdeadbeef);
6712 iret
= send(src
, "test", 4, 0);
6713 ok(iret
== 4, "Expected 4, got %d\n", iret
);
6714 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6715 SetLastError(0xdeadbeef);
6716 bytesReturned
= 0xdeadbeef;
6717 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
6718 ok(!iret
, "Expected 0, got %d\n", iret
);
6719 ok(bytesReturned
== 4, "Expected 4, got %d\n", bytesReturned
);
6720 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6722 /* Test 2 buffers */
6725 bufs
[1].buf
= buf
+ 10;
6726 SetLastError(0xdeadbeef);
6727 iret
= send(src
, "deadbeefs", 9, 0);
6728 ok(iret
== 9, "Expected 9, got %d\n", iret
);
6729 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6730 SetLastError(0xdeadbeef);
6731 bytesReturned
= 0xdeadbeef;
6732 iret
= WSARecv(dest
, bufs
, 2, &bytesReturned
, &flags
, NULL
, NULL
);
6733 ok(!iret
, "Expected 0, got %d\n", iret
);
6734 ok(bytesReturned
== 9, "Expected 9, got %d\n", bytesReturned
);
6735 bufs
[0].buf
[4] = '\0';
6736 bufs
[1].buf
[5] = '\0';
6737 ok(!strcmp(bufs
[0].buf
, "dead"), "buf[0] doesn't match: %s != dead\n", bufs
[0].buf
);
6738 ok(!strcmp(bufs
[1].buf
, "beefs"), "buf[1] doesn't match: %s != beefs\n", bufs
[1].buf
);
6739 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6741 bufs
[0].len
= sizeof(buf
);
6742 ov
.hEvent
= event
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
6743 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
6749 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
6750 ok(!iret
, "Failed to set linger %d\n", GetLastError());
6752 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, NULL
);
6753 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
6755 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
6756 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
6759 src
= INVALID_SOCKET
;
6761 dwret
= WaitForSingleObject(ov
.hEvent
, 1000);
6762 ok(dwret
== WAIT_OBJECT_0
, "Waiting for disconnect event failed with %d + errno %d\n", dwret
, GetLastError());
6764 bret
= GetOverlappedResult((HANDLE
)dest
, &ov
, &bytesReturned
, FALSE
);
6765 todo_wine
ok(!bret
&& (GetLastError() == ERROR_NETNAME_DELETED
|| broken(GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */),
6766 "Did not get disconnect event: %d, error %d\n", bret
, GetLastError());
6767 ok(bytesReturned
== 0, "Bytes received is %d\n", bytesReturned
);
6769 dest
= INVALID_SOCKET
;
6771 src
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
6772 ok(src
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
6773 if (src
== INVALID_SOCKET
) goto end
;
6775 server
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
6776 ok(server
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
6777 if (server
== INVALID_SOCKET
) goto end
;
6779 memset(&addr
, 0, sizeof(addr
));
6780 addr
.sin_family
= AF_INET
;
6781 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6782 iret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
6786 iret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
6789 iret
= listen(server
, 1);
6792 iret
= connect(src
, (struct sockaddr
*)&addr
, sizeof(addr
));
6796 dest
= accept(server
, (struct sockaddr
*)&addr
, &len
);
6797 ok(dest
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
6798 if (dest
== INVALID_SOCKET
) goto end
;
6800 send(src
, "test message", sizeof("test message"), 0);
6801 thread
= CreateThread(NULL
, 0, recv_thread
, &dest
, 0, &id
);
6802 WaitForSingleObject(thread
, 3000);
6803 CloseHandle(thread
);
6805 memset(&ov
, 0, sizeof(ov
));
6808 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, io_completion
);
6809 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
6810 send(src
, "test message", sizeof("test message"), 0);
6812 completion_called
= 0;
6813 dwret
= SleepEx(1000, TRUE
);
6814 ok(dwret
== WAIT_IO_COMPLETION
, "got %u\n", dwret
);
6815 ok(completion_called
== 1, "completion not called\n");
6817 dwret
= WaitForSingleObject(event
, 1);
6818 ok(dwret
== WAIT_TIMEOUT
, "got %u\n", dwret
);
6820 io_port
= CreateIoCompletionPort( (HANDLE
)dest
, NULL
, 0, 0 );
6821 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
6823 /* Using completion function on socket associated with completion port is not allowed. */
6824 memset(&ov
, 0, sizeof(ov
));
6825 completion_called
= 0;
6826 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, io_completion
);
6828 ok(iret
== SOCKET_ERROR
&& GetLastError() == WSAEINVAL
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
6829 ok(!completion_called
, "completion called\n");
6831 CloseHandle(io_port
);
6834 if (server
!= INVALID_SOCKET
)
6835 closesocket(server
);
6836 if (dest
!= INVALID_SOCKET
)
6838 if (src
!= INVALID_SOCKET
)
6841 WSACloseEvent(event
);
6844 #define POLL_CLEAR() ix = 0
6845 #define POLL_SET(s, ev) {fds[ix].fd = s; fds[ix++].events = ev;}
6846 #define POLL_ISSET(s, rev) poll_isset(fds, ix, s, rev)
6847 static BOOL
poll_isset(WSAPOLLFD
*fds
, int max
, SOCKET s
, int rev
)
6850 for (k
= 0; k
< max
; k
++)
6851 if (fds
[k
].fd
== s
&& (fds
[k
].revents
== rev
)) return TRUE
;
6855 static void test_WSAPoll(void)
6857 int ix
, ret
, err
, poll_timeout
;
6858 SOCKET fdListen
, fdRead
, fdWrite
;
6859 struct sockaddr_in address
;
6861 static char tmp_buf
[1024];
6863 HANDLE thread_handle
;
6866 if (!pWSAPoll
) /* >= Vista */
6868 skip("WSAPoll is unsupported, some tests will be skipped.\n");
6872 /* Invalid parameters test */
6873 SetLastError(0xdeadbeef);
6874 ret
= pWSAPoll(NULL
, 0, 0);
6875 err
= GetLastError();
6876 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6877 ok(err
== WSAEINVAL
, "expected 10022, got %d\n", err
);
6878 SetLastError(0xdeadbeef);
6879 ret
= pWSAPoll(NULL
, 1, 0);
6880 err
= GetLastError();
6881 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6882 ok(err
== WSAEFAULT
, "expected 10014, got %d\n", err
);
6883 SetLastError(0xdeadbeef);
6884 ret
= pWSAPoll(NULL
, 0, 1);
6885 err
= GetLastError();
6886 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6887 ok(err
== WSAEINVAL
, "expected 10022, got %d\n", err
);
6888 SetLastError(0xdeadbeef);
6889 ret
= pWSAPoll(NULL
, 1, 1);
6890 err
= GetLastError();
6891 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6892 ok(err
== WSAEFAULT
, "expected 10014, got %d\n", err
);
6894 /* WSAPoll() tries to mime the unix poll() call. The following tests do:
6895 * - check if a connection attempt ended with success or error;
6896 * - check if a pending connection is waiting for acceptance;
6897 * - check for data to read, availability for write and OOB data
6899 memset(&address
, 0, sizeof(address
));
6900 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6901 address
.sin_family
= AF_INET
;
6902 len
= sizeof(address
);
6903 fdListen
= setup_server_socket(&address
, &len
);
6906 /* When no events are pending poll returns 0 with no error */
6908 POLL_SET(fdListen
, POLLIN
);
6909 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6910 ok(ret
== 0, "expected 0, got %d\n", ret
);
6912 /* Test listening socket connection attempt notifications */
6913 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
6915 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
6916 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6917 ok(ret
== 1, "expected 1, got %d\n", ret
);
6918 ok(POLL_ISSET(fdListen
, POLLRDNORM
), "fdListen socket events incorrect\n");
6919 len
= sizeof(address
);
6920 fdRead
= accept(fdListen
, (struct sockaddr
*) &address
, &len
);
6921 ok(fdRead
!= INVALID_SOCKET
, "expected a valid socket\n");
6923 /* Test client side connection attempt notifications */
6925 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
6926 POLL_SET(fdRead
, POLLIN
| POLLOUT
);
6927 POLL_SET(fdWrite
, POLLIN
| POLLOUT
);
6928 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6929 ok(ret
== 2, "expected 2, got %d\n", ret
);
6930 ok(POLL_ISSET(fdWrite
, POLLWRNORM
), "fdWrite socket events incorrect\n");
6931 ok(POLL_ISSET(fdRead
, POLLWRNORM
), "fdRead socket events incorrect\n");
6934 err
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
6935 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
6936 ok(id
== 0, "expected 0, got %d\n", id
);
6938 /* Test data receiving notifications */
6939 ret
= send(fdWrite
, "1234", 4, 0);
6940 ok(ret
== 4, "expected 4, got %d\n", ret
);
6942 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
6943 POLL_SET(fdRead
, POLLIN
);
6944 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6945 ok(ret
== 1, "expected 1, got %d\n", ret
);
6946 ok(POLL_ISSET(fdRead
, POLLRDNORM
), "fdRead socket events incorrect\n");
6947 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
6948 ok(ret
== 4, "expected 4, got %d\n", ret
);
6949 ok(!strcmp(tmp_buf
, "1234"), "data received differs from sent\n");
6951 /* Test OOB data notifications */
6952 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
6953 ok(ret
== 1, "expected 1, got %d\n", ret
);
6955 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
6956 POLL_SET(fdRead
, POLLIN
);
6957 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6958 ok(ret
== 1, "expected 1, got %d\n", ret
);
6959 ok(POLL_ISSET(fdRead
, POLLRDBAND
), "fdRead socket events incorrect\n");
6961 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
6962 ok(ret
== 1, "expected 1, got %d\n", ret
);
6963 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
6965 /* If the socket is OOBINLINED the notification is like normal data */
6967 ret
= setsockopt(fdRead
, SOL_SOCKET
, SO_OOBINLINE
, (char*) &ret
, sizeof(ret
));
6968 ok(ret
== 0, "expected 0, got %d\n", ret
);
6969 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
6970 ok(ret
== 1, "expected 1, got %d\n", ret
);
6972 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
6973 POLL_SET(fdRead
, POLLIN
| POLLOUT
);
6974 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6975 ok(ret
== 1, "expected 1, got %d\n", ret
);
6977 SetLastError(0xdeadbeef);
6978 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
6979 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6980 ok(GetLastError() == WSAEINVAL
, "expected 10022, got %d\n", GetLastError());
6981 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
6982 ok(ret
== 1, "expected 1, got %d\n", ret
);
6983 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
6985 /* Test connection closed notifications */
6986 ret
= closesocket(fdRead
);
6987 ok(ret
== 0, "expected 0, got %d\n", ret
);
6989 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
6990 POLL_SET(fdWrite
, POLLIN
);
6991 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6992 ok(ret
== 1, "expected 1, got %d\n", ret
);
6993 ok(POLL_ISSET(fdWrite
, POLLHUP
), "fdWrite socket events incorrect\n");
6994 ret
= recv(fdWrite
, tmp_buf
, sizeof(tmp_buf
), 0);
6995 ok(ret
== 0, "expected 0, got %d\n", ret
);
6997 /* When a connection is attempted to a non-listening socket due to a bug
6998 * in the MS code it will never be notified. This is a long standing issue
6999 * that will never be fixed for compatibility reasons so we have to deal
7000 * with it manually. */
7001 ret
= closesocket(fdWrite
);
7002 ok(ret
== 0, "expected 0, got %d\n", ret
);
7003 ret
= closesocket(fdListen
);
7004 ok(ret
== 0, "expected 0, got %d\n", ret
);
7005 len
= sizeof(address
);
7006 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
7008 POLL_SET(fdWrite
, POLLIN
| POLLOUT
);
7009 poll_timeout
= 2000;
7010 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
7012 ok(ret
== 0, "expected 0, got %d\n", ret
);
7015 err
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
7016 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
7017 ok(id
== WSAECONNREFUSED
, "expected 10061, got %d\n", id
);
7018 closesocket(fdWrite
);
7020 /* Try poll() on a closed socket after connection */
7021 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
7022 closesocket(fdRead
);
7024 POLL_SET(fdWrite
, POLLIN
| POLLOUT
);
7025 POLL_SET(fdRead
, POLLIN
| POLLOUT
);
7026 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
7027 ok(ret
== 1, "expected 1, got %d\n", ret
);
7028 ok(POLL_ISSET(fdRead
, POLLNVAL
), "fdRead socket events incorrect\n");
7030 POLL_SET(fdWrite
, POLLIN
| POLLOUT
);
7031 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
7032 ok(ret
== 1, "expected 1, got %d\n", ret
);
7034 ok(POLL_ISSET(fdWrite
, POLLWRNORM
| POLLHUP
) || broken(POLL_ISSET(fdWrite
, POLLWRNORM
)) /* <= 2008 */,
7035 "fdWrite socket events incorrect\n");
7036 closesocket(fdWrite
);
7038 /* Close the socket currently being polled in a thread */
7039 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
7040 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
7041 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
7043 POLL_SET(fdWrite
, POLLIN
| POLLOUT
);
7044 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
7045 ok(ret
== 1, "expected 1, got %d\n", ret
);
7046 ok(POLL_ISSET(fdWrite
, POLLWRNORM
), "fdWrite socket events incorrect\n");
7047 WaitForSingleObject (thread_handle
, 1000);
7048 closesocket(fdRead
);
7049 /* test again with less flags - behavior changes */
7050 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
7051 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
7052 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
7054 POLL_SET(fdWrite
, POLLIN
);
7055 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
7056 ok(ret
== 1, "expected 1, got %d\n", ret
);
7057 ok(POLL_ISSET(fdWrite
, POLLNVAL
), "fdWrite socket events incorrect\n");
7058 WaitForSingleObject (thread_handle
, 1000);
7059 closesocket(fdRead
);
7065 static void test_GetAddrInfoW(void)
7067 static const WCHAR port
[] = {'8','0',0};
7068 static const WCHAR empty
[] = {0};
7069 static const WCHAR localhost
[] = {'l','o','c','a','l','h','o','s','t',0};
7070 static const WCHAR nxdomain
[] =
7071 {'n','x','d','o','m','a','i','n','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',0};
7072 static const WCHAR zero
[] = {'0',0};
7074 ADDRINFOW
*result
, *result2
, *p
, hint
;
7076 DWORD size
= sizeof(name
)/sizeof(WCHAR
);
7077 /* te su to.winehq.org written in katakana */
7078 static const WCHAR idn_domain
[] =
7079 {0x30C6,0x30B9,0x30C8,'.','w','i','n','e','h','q','.','o','r','g',0};
7080 static const WCHAR idn_punycode
[] =
7081 {'x','n','-','-','z','c','k','z','a','h','.','w','i','n','e','h','q','.','o','r','g',0};
7083 if (!pGetAddrInfoW
|| !pFreeAddrInfoW
)
7085 win_skip("GetAddrInfoW and/or FreeAddrInfoW not present\n");
7088 memset(&hint
, 0, sizeof(ADDRINFOW
));
7090 GetComputerNameExW( ComputerNamePhysicalDnsHostname
, name
, &size
);
7092 result
= (ADDRINFOW
*)0xdeadbeef;
7093 WSASetLastError(0xdeadbeef);
7094 ret
= pGetAddrInfoW(NULL
, NULL
, NULL
, &result
);
7095 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
7096 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
7097 ok(result
== NULL
, "got %p\n", result
);
7100 WSASetLastError(0xdeadbeef);
7101 ret
= pGetAddrInfoW(empty
, NULL
, NULL
, &result
);
7102 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7103 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7104 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7105 pFreeAddrInfoW(result
);
7108 ret
= pGetAddrInfoW(NULL
, zero
, NULL
, &result
);
7109 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7110 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7113 ret
= pGetAddrInfoW(NULL
, empty
, NULL
, &result2
);
7114 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7115 ok(result2
!= NULL
, "GetAddrInfoW failed\n");
7116 compare_addrinfow(result
, result2
);
7117 pFreeAddrInfoW(result
);
7118 pFreeAddrInfoW(result2
);
7121 ret
= pGetAddrInfoW(empty
, zero
, NULL
, &result
);
7122 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7123 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7124 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7127 ret
= pGetAddrInfoW(empty
, empty
, NULL
, &result2
);
7128 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7129 ok(result2
!= NULL
, "GetAddrInfoW failed\n");
7130 compare_addrinfow(result
, result2
);
7131 pFreeAddrInfoW(result
);
7132 pFreeAddrInfoW(result2
);
7135 ret
= pGetAddrInfoW(localhost
, NULL
, NULL
, &result
);
7136 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7137 pFreeAddrInfoW(result
);
7140 ret
= pGetAddrInfoW(localhost
, empty
, NULL
, &result
);
7141 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7142 pFreeAddrInfoW(result
);
7145 ret
= pGetAddrInfoW(localhost
, zero
, NULL
, &result
);
7146 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7147 pFreeAddrInfoW(result
);
7150 ret
= pGetAddrInfoW(localhost
, port
, NULL
, &result
);
7151 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7152 pFreeAddrInfoW(result
);
7155 ret
= pGetAddrInfoW(localhost
, NULL
, &hint
, &result
);
7156 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7157 pFreeAddrInfoW(result
);
7160 SetLastError(0xdeadbeef);
7161 ret
= pGetAddrInfoW(localhost
, port
, &hint
, &result
);
7162 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7163 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7164 pFreeAddrInfoW(result
);
7166 /* try to get information from the computer name, result is the same
7167 * as if requesting with an empty host name. */
7168 ret
= pGetAddrInfoW(name
, NULL
, NULL
, &result
);
7169 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7170 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7172 ret
= pGetAddrInfoW(empty
, NULL
, NULL
, &result2
);
7173 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7174 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7175 compare_addrinfow(result
, result2
);
7176 pFreeAddrInfoW(result
);
7177 pFreeAddrInfoW(result2
);
7179 ret
= pGetAddrInfoW(name
, empty
, NULL
, &result
);
7180 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7181 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7183 ret
= pGetAddrInfoW(empty
, empty
, NULL
, &result2
);
7184 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7185 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7186 compare_addrinfow(result
, result2
);
7187 pFreeAddrInfoW(result
);
7188 pFreeAddrInfoW(result2
);
7190 result
= (ADDRINFOW
*)0xdeadbeef;
7191 WSASetLastError(0xdeadbeef);
7192 ret
= pGetAddrInfoW(NULL
, NULL
, NULL
, &result
);
7195 skip("nxdomain returned success. Broken ISP redirects?\n");
7198 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
7199 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
7200 ok(result
== NULL
, "got %p\n", result
);
7202 result
= (ADDRINFOW
*)0xdeadbeef;
7203 WSASetLastError(0xdeadbeef);
7204 ret
= pGetAddrInfoW(nxdomain
, NULL
, NULL
, &result
);
7207 skip("nxdomain returned success. Broken ISP redirects?\n");
7210 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
7211 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
7212 ok(result
== NULL
, "got %p\n", result
);
7214 for (i
= 0;i
< (sizeof(hinttests
) / sizeof(hinttests
[0]));i
++)
7216 hint
.ai_family
= hinttests
[i
].family
;
7217 hint
.ai_socktype
= hinttests
[i
].socktype
;
7218 hint
.ai_protocol
= hinttests
[i
].protocol
;
7221 SetLastError(0xdeadbeef);
7222 ret
= pGetAddrInfoW(localhost
, NULL
, &hint
, &result
);
7225 if (hinttests
[i
].error
)
7226 ok(0, "test %d: GetAddrInfoW succeeded unexpectedly\n", i
);
7232 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
7233 if (hinttests
[i
].family
== AF_UNSPEC
)
7234 ok(p
->ai_family
== AF_INET
|| p
->ai_family
== AF_INET6
,
7235 "test %d: expected AF_INET or AF_INET6, got %d\n",
7238 ok(p
->ai_family
== hinttests
[i
].family
,
7239 "test %d: expected family %d, got %d\n",
7240 i
, hinttests
[i
].family
, p
->ai_family
);
7242 ok(p
->ai_socktype
== hinttests
[i
].socktype
,
7243 "test %d: expected type %d, got %d\n",
7244 i
, hinttests
[i
].socktype
, p
->ai_socktype
);
7245 ok(p
->ai_protocol
== hinttests
[i
].protocol
,
7246 "test %d: expected protocol %d, got %d\n",
7247 i
, hinttests
[i
].protocol
, p
->ai_protocol
);
7252 pFreeAddrInfoW(result
);
7256 DWORD err
= WSAGetLastError();
7257 if (hinttests
[i
].error
)
7258 ok(hinttests
[i
].error
== err
, "test %d: GetAddrInfoW failed with error %d, expected %d\n",
7259 i
, err
, hinttests
[i
].error
);
7261 ok(0, "test %d: GetAddrInfoW failed with %d (err %d)\n", i
, ret
, err
);
7265 /* Test IDN resolution (Internationalized Domain Names) present since Windows 8 */
7266 trace("Testing punycode IDN %s\n", wine_dbgstr_w(idn_punycode
));
7268 ret
= pGetAddrInfoW(idn_punycode
, NULL
, NULL
, &result
);
7269 ok(!ret
, "got %d expected success\n", ret
);
7270 ok(result
!= NULL
, "got %p\n", result
);
7271 pFreeAddrInfoW(result
);
7273 hint
.ai_family
= AF_INET
;
7274 hint
.ai_socktype
= 0;
7275 hint
.ai_protocol
= 0;
7279 ret
= pGetAddrInfoW(idn_punycode
, NULL
, &hint
, &result
);
7280 ok(!ret
, "got %d expected success\n", ret
);
7281 ok(result
!= NULL
, "got %p\n", result
);
7283 trace("Testing unicode IDN %s\n", wine_dbgstr_w(idn_domain
));
7285 ret
= pGetAddrInfoW(idn_domain
, NULL
, NULL
, &result2
);
7286 if (ret
== WSAHOST_NOT_FOUND
&& broken(1))
7288 pFreeAddrInfoW(result
);
7289 win_skip("IDN resolution not supported in Win <= 7\n");
7293 ok(!ret
, "got %d expected success\n", ret
);
7294 ok(result2
!= NULL
, "got %p\n", result2
);
7295 pFreeAddrInfoW(result2
);
7297 hint
.ai_family
= AF_INET
;
7298 hint
.ai_socktype
= 0;
7299 hint
.ai_protocol
= 0;
7303 ret
= pGetAddrInfoW(idn_domain
, NULL
, &hint
, &result2
);
7304 ok(!ret
, "got %d expected success\n", ret
);
7305 ok(result2
!= NULL
, "got %p\n", result2
);
7307 /* ensure manually resolved punycode and unicode hosts result in same data */
7308 compare_addrinfow(result
, result2
);
7310 pFreeAddrInfoW(result
);
7311 pFreeAddrInfoW(result2
);
7313 hint
.ai_family
= AF_INET
;
7314 hint
.ai_socktype
= 0;
7315 hint
.ai_protocol
= 0;
7319 ret
= pGetAddrInfoW(idn_domain
, NULL
, &hint
, &result2
);
7320 ok(!ret
, "got %d expected success\n", ret
);
7321 ok(result2
!= NULL
, "got %p\n", result2
);
7322 pFreeAddrInfoW(result2
);
7324 /* Disable IDN resolution and test again*/
7325 hint
.ai_family
= AF_INET
;
7326 hint
.ai_socktype
= 0;
7327 hint
.ai_protocol
= 0;
7328 hint
.ai_flags
= AI_DISABLE_IDN_ENCODING
;
7330 SetLastError(0xdeadbeef);
7332 ret
= pGetAddrInfoW(idn_domain
, NULL
, &hint
, &result2
);
7333 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
7334 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
7335 ok(result2
== NULL
, "got %p\n", result2
);
7338 static void verify_ipv6_addrinfo(ADDRINFOA
*result
, const char *expectedIp
)
7340 SOCKADDR_IN6
*sockaddr6
;
7344 ok(result
->ai_family
== AF_INET6
, "ai_family == %d\n", result
->ai_family
);
7345 ok(result
->ai_addrlen
>= sizeof(struct sockaddr_in6
), "ai_addrlen == %d\n", (int)result
->ai_addrlen
);
7346 ok(result
->ai_addr
!= NULL
, "ai_addr == NULL\n");
7348 if (result
->ai_addr
!= NULL
)
7350 sockaddr6
= (SOCKADDR_IN6
*)result
->ai_addr
;
7351 ok(sockaddr6
->sin6_family
== AF_INET6
, "ai_addr->sin6_family == %d\n", sockaddr6
->sin6_family
);
7352 ok(sockaddr6
->sin6_port
== 0, "ai_addr->sin6_port == %d\n", sockaddr6
->sin6_port
);
7354 ZeroMemory(ipBuffer
, sizeof(ipBuffer
));
7355 ret
= pInetNtop(AF_INET6
, &sockaddr6
->sin6_addr
, ipBuffer
, sizeof(ipBuffer
));
7356 ok(ret
!= NULL
, "inet_ntop failed (%d)\n", WSAGetLastError());
7357 ok(strcmp(ipBuffer
, expectedIp
) == 0, "ai_addr->sin6_addr == '%s' (expected '%s')\n", ipBuffer
, expectedIp
);
7361 static void test_getaddrinfo(void)
7364 ADDRINFOA
*result
, *result2
, *p
, hint
;
7365 SOCKADDR_IN
*sockaddr
;
7366 CHAR name
[256], *ip
;
7367 DWORD size
= sizeof(name
);
7369 if (!pgetaddrinfo
|| !pfreeaddrinfo
)
7371 win_skip("getaddrinfo and/or freeaddrinfo not present\n");
7374 memset(&hint
, 0, sizeof(ADDRINFOA
));
7375 GetComputerNameExA( ComputerNamePhysicalDnsHostname
, name
, &size
);
7377 result
= (ADDRINFOA
*)0xdeadbeef;
7378 WSASetLastError(0xdeadbeef);
7379 ret
= pgetaddrinfo(NULL
, NULL
, NULL
, &result
);
7380 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
7381 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
7382 ok(result
== NULL
, "got %p\n", result
);
7385 WSASetLastError(0xdeadbeef);
7386 ret
= pgetaddrinfo("", NULL
, NULL
, &result
);
7387 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7388 ok(result
!= NULL
, "getaddrinfo failed\n");
7389 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7390 pfreeaddrinfo(result
);
7393 ret
= pgetaddrinfo(NULL
, "0", NULL
, &result
);
7394 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7395 ok(result
!= NULL
, "getaddrinfo failed\n");
7398 ret
= pgetaddrinfo(NULL
, "", NULL
, &result2
);
7399 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7400 ok(result2
!= NULL
, "getaddrinfo failed\n");
7401 compare_addrinfo(result
, result2
);
7402 pfreeaddrinfo(result
);
7403 pfreeaddrinfo(result2
);
7406 WSASetLastError(0xdeadbeef);
7407 ret
= pgetaddrinfo("", "0", NULL
, &result
);
7408 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7409 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7410 ok(result
!= NULL
, "getaddrinfo failed\n");
7413 ret
= pgetaddrinfo("", "", NULL
, &result2
);
7414 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7415 ok(result2
!= NULL
, "getaddrinfo failed\n");
7416 compare_addrinfo(result
, result2
);
7417 pfreeaddrinfo(result
);
7418 pfreeaddrinfo(result2
);
7421 ret
= pgetaddrinfo("localhost", NULL
, NULL
, &result
);
7422 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7423 pfreeaddrinfo(result
);
7426 ret
= pgetaddrinfo("localhost", "", NULL
, &result
);
7427 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7428 pfreeaddrinfo(result
);
7431 ret
= pgetaddrinfo("localhost", "0", NULL
, &result
);
7432 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7433 pfreeaddrinfo(result
);
7436 ret
= pgetaddrinfo("localhost", "80", NULL
, &result
);
7437 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7438 pfreeaddrinfo(result
);
7441 ret
= pgetaddrinfo("localhost", NULL
, &hint
, &result
);
7442 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7443 pfreeaddrinfo(result
);
7446 WSASetLastError(0xdeadbeef);
7447 ret
= pgetaddrinfo("localhost", "80", &hint
, &result
);
7448 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7449 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7450 pfreeaddrinfo(result
);
7452 hint
.ai_flags
= AI_NUMERICHOST
;
7453 result
= (void*)0xdeadbeef;
7454 ret
= pgetaddrinfo("localhost", "80", &hint
, &result
);
7455 ok(ret
== WSAHOST_NOT_FOUND
, "getaddrinfo failed with %d\n", WSAGetLastError());
7456 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected WSAHOST_NOT_FOUND, got %d\n", WSAGetLastError());
7457 ok(!result
, "result = %p\n", result
);
7460 /* try to get information from the computer name, result is the same
7461 * as if requesting with an empty host name. */
7462 ret
= pgetaddrinfo(name
, NULL
, NULL
, &result
);
7463 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7464 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7466 ret
= pgetaddrinfo("", NULL
, NULL
, &result2
);
7467 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7468 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7469 compare_addrinfo(result
, result2
);
7470 pfreeaddrinfo(result
);
7471 pfreeaddrinfo(result2
);
7473 ret
= pgetaddrinfo(name
, "", NULL
, &result
);
7474 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7475 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7477 ret
= pgetaddrinfo("", "", NULL
, &result2
);
7478 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7479 ok(result
!= NULL
, "GetAddrInfoW failed\n");
7480 compare_addrinfo(result
, result2
);
7481 pfreeaddrinfo(result
);
7482 pfreeaddrinfo(result2
);
7484 result
= (ADDRINFOA
*)0xdeadbeef;
7485 WSASetLastError(0xdeadbeef);
7486 ret
= pgetaddrinfo("nxdomain.codeweavers.com", NULL
, NULL
, &result
);
7489 skip("nxdomain returned success. Broken ISP redirects?\n");
7492 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
7493 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
7494 ok(result
== NULL
, "got %p\n", result
);
7496 /* Test IPv4 address conversion */
7498 ret
= pgetaddrinfo("192.168.1.253", NULL
, NULL
, &result
);
7499 ok(!ret
, "getaddrinfo failed with %d\n", ret
);
7500 ok(result
->ai_family
== AF_INET
, "ai_family == %d\n", result
->ai_family
);
7501 ok(result
->ai_addrlen
>= sizeof(struct sockaddr_in
), "ai_addrlen == %d\n", (int)result
->ai_addrlen
);
7502 ok(result
->ai_addr
!= NULL
, "ai_addr == NULL\n");
7503 sockaddr
= (SOCKADDR_IN
*)result
->ai_addr
;
7504 ok(sockaddr
->sin_family
== AF_INET
, "ai_addr->sin_family == %d\n", sockaddr
->sin_family
);
7505 ok(sockaddr
->sin_port
== 0, "ai_addr->sin_port == %d\n", sockaddr
->sin_port
);
7507 ip
= inet_ntoa(sockaddr
->sin_addr
);
7508 ok(strcmp(ip
, "192.168.1.253") == 0, "sockaddr->ai_addr == '%s'\n", ip
);
7509 pfreeaddrinfo(result
);
7511 /* Test IPv4 address conversion with port */
7513 hint
.ai_flags
= AI_NUMERICHOST
;
7514 ret
= pgetaddrinfo("192.168.1.253:1024", NULL
, &hint
, &result
);
7516 ok(ret
== WSAHOST_NOT_FOUND
, "getaddrinfo returned unexpected result: %d\n", ret
);
7517 ok(result
== NULL
, "expected NULL, got %p\n", result
);
7519 /* Test IPv6 address conversion */
7521 SetLastError(0xdeadbeef);
7522 ret
= pgetaddrinfo("2a00:2039:dead:beef:cafe::6666", NULL
, NULL
, &result
);
7526 ok(!ret
, "getaddrinfo failed with %d\n", ret
);
7527 verify_ipv6_addrinfo(result
, "2a00:2039:dead:beef:cafe::6666");
7528 pfreeaddrinfo(result
);
7530 /* Test IPv6 address conversion with brackets */
7532 ret
= pgetaddrinfo("[beef::cafe]", NULL
, NULL
, &result
);
7533 ok(!ret
, "getaddrinfo failed with %d\n", ret
);
7534 verify_ipv6_addrinfo(result
, "beef::cafe");
7535 pfreeaddrinfo(result
);
7537 /* Test IPv6 address conversion with brackets and hints */
7538 memset(&hint
, 0, sizeof(ADDRINFOA
));
7539 hint
.ai_flags
= AI_NUMERICHOST
;
7540 hint
.ai_family
= AF_INET6
;
7542 ret
= pgetaddrinfo("[beef::cafe]", NULL
, &hint
, &result
);
7543 ok(!ret
, "getaddrinfo failed with %d\n", ret
);
7544 verify_ipv6_addrinfo(result
, "beef::cafe");
7545 pfreeaddrinfo(result
);
7547 memset(&hint
, 0, sizeof(ADDRINFOA
));
7548 hint
.ai_flags
= AI_NUMERICHOST
;
7549 hint
.ai_family
= AF_INET
;
7551 ret
= pgetaddrinfo("[beef::cafe]", NULL
, &hint
, &result
);
7552 ok(ret
== WSAHOST_NOT_FOUND
, "getaddrinfo failed with %d\n", ret
);
7554 /* Test IPv6 address conversion with brackets and port */
7556 ret
= pgetaddrinfo("[beef::cafe]:10239", NULL
, NULL
, &result
);
7557 ok(!ret
, "getaddrinfo failed with %d\n", ret
);
7558 verify_ipv6_addrinfo(result
, "beef::cafe");
7559 pfreeaddrinfo(result
);
7561 /* Test IPv6 address conversion with unmatched brackets */
7563 hint
.ai_flags
= AI_NUMERICHOST
;
7564 ret
= pgetaddrinfo("[beef::cafe", NULL
, &hint
, &result
);
7565 ok(ret
== WSAHOST_NOT_FOUND
, "getaddrinfo failed with %d\n", ret
);
7567 ret
= pgetaddrinfo("beef::cafe]", NULL
, &hint
, &result
);
7568 ok(ret
== WSAHOST_NOT_FOUND
, "getaddrinfo failed with %d\n", ret
);
7572 ok(ret
== WSAHOST_NOT_FOUND
, "getaddrinfo failed with %d\n", ret
);
7573 win_skip("getaddrinfo does not support IPV6\n");
7578 for (i
= 0;i
< (sizeof(hinttests
) / sizeof(hinttests
[0]));i
++)
7580 hint
.ai_family
= hinttests
[i
].family
;
7581 hint
.ai_socktype
= hinttests
[i
].socktype
;
7582 hint
.ai_protocol
= hinttests
[i
].protocol
;
7585 SetLastError(0xdeadbeef);
7586 ret
= pgetaddrinfo("localhost", NULL
, &hint
, &result
);
7589 if (hinttests
[i
].error
)
7590 ok(0, "test %d: getaddrinfo succeeded unexpectedly\n", i
);
7596 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
7597 if (hinttests
[i
].family
== AF_UNSPEC
)
7598 ok(p
->ai_family
== AF_INET
|| p
->ai_family
== AF_INET6
,
7599 "test %d: expected AF_INET or AF_INET6, got %d\n",
7602 ok(p
->ai_family
== hinttests
[i
].family
,
7603 "test %d: expected family %d, got %d\n",
7604 i
, hinttests
[i
].family
, p
->ai_family
);
7606 ok(p
->ai_socktype
== hinttests
[i
].socktype
,
7607 "test %d: expected type %d, got %d\n",
7608 i
, hinttests
[i
].socktype
, p
->ai_socktype
);
7609 ok(p
->ai_protocol
== hinttests
[i
].protocol
,
7610 "test %d: expected protocol %d, got %d\n",
7611 i
, hinttests
[i
].protocol
, p
->ai_protocol
);
7616 pfreeaddrinfo(result
);
7620 DWORD err
= WSAGetLastError();
7621 if (hinttests
[i
].error
)
7622 ok(hinttests
[i
].error
== err
, "test %d: getaddrinfo failed with error %d, expected %d\n",
7623 i
, err
, hinttests
[i
].error
);
7625 ok(0, "test %d: getaddrinfo failed with %d (err %d)\n", i
, ret
, err
);
7630 static void test_ConnectEx(void)
7632 SOCKET listener
= INVALID_SOCKET
;
7633 SOCKET acceptor
= INVALID_SOCKET
;
7634 SOCKET connector
= INVALID_SOCKET
;
7635 struct sockaddr_in address
, conaddress
;
7637 OVERLAPPED overlapped
;
7638 LPFN_CONNECTEX pConnectEx
;
7639 GUID connectExGuid
= WSAID_CONNECTEX
;
7640 DWORD bytesReturned
;
7646 memset(&overlapped
, 0, sizeof(overlapped
));
7648 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
7649 if (listener
== INVALID_SOCKET
) {
7650 skip("could not create listener socket, error %d\n", WSAGetLastError());
7654 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7655 if (connector
== INVALID_SOCKET
) {
7656 skip("could not create connector socket, error %d\n", WSAGetLastError());
7660 memset(&address
, 0, sizeof(address
));
7661 address
.sin_family
= AF_INET
;
7662 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7663 iret
= bind(listener
, (struct sockaddr
*)&address
, sizeof(address
));
7665 skip("failed to bind, error %d\n", WSAGetLastError());
7669 addrlen
= sizeof(address
);
7670 iret
= getsockname(listener
, (struct sockaddr
*)&address
, &addrlen
);
7672 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
7676 if (set_blocking(listener
, TRUE
)) {
7677 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7681 iret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectExGuid
, sizeof(connectExGuid
),
7682 &pConnectEx
, sizeof(pConnectEx
), &bytesReturned
, NULL
, NULL
);
7684 win_skip("WSAIoctl failed to get ConnectEx with ret %d + errno %d\n", iret
, WSAGetLastError());
7688 bret
= pConnectEx(INVALID_SOCKET
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
7689 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "ConnectEx on invalid socket "
7690 "returned %d + errno %d\n", bret
, WSAGetLastError());
7692 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
7693 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "ConnectEx on a unbound socket "
7694 "returned %d + errno %d\n", bret
, WSAGetLastError());
7695 if (bret
== TRUE
|| WSAGetLastError() != WSAEINVAL
)
7697 acceptor
= accept(listener
, NULL
, NULL
);
7698 if (acceptor
!= INVALID_SOCKET
) {
7699 closesocket(acceptor
);
7700 acceptor
= INVALID_SOCKET
;
7703 closesocket(connector
);
7704 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7705 if (connector
== INVALID_SOCKET
) {
7706 skip("could not create connector socket, error %d\n", WSAGetLastError());
7711 /* ConnectEx needs a bound socket */
7712 memset(&conaddress
, 0, sizeof(conaddress
));
7713 conaddress
.sin_family
= AF_INET
;
7714 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7715 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
7717 skip("failed to bind, error %d\n", WSAGetLastError());
7721 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, NULL
);
7722 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "ConnectEx on a NULL overlapped "
7723 "returned %d + errno %d\n", bret
, WSAGetLastError());
7725 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
7726 if (overlapped
.hEvent
== NULL
) {
7727 skip("could not create event object, errno = %d\n", GetLastError());
7731 iret
= listen(listener
, 1);
7733 skip("listening failed, errno = %d\n", WSAGetLastError());
7737 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
7738 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
7739 "returned %d + errno %d\n", bret
, WSAGetLastError());
7740 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
7741 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
7743 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
7744 ok(bret
, "Connecting failed, error %d\n", GetLastError());
7745 ok(bytesReturned
== 0, "Bytes sent is %d\n", bytesReturned
);
7747 closesocket(connector
);
7748 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7749 if (connector
== INVALID_SOCKET
) {
7750 skip("could not create connector socket, error %d\n", WSAGetLastError());
7753 /* ConnectEx needs a bound socket */
7754 memset(&conaddress
, 0, sizeof(conaddress
));
7755 conaddress
.sin_family
= AF_INET
;
7756 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7757 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
7759 skip("failed to bind, error %d\n", WSAGetLastError());
7763 acceptor
= accept(listener
, NULL
, NULL
);
7764 if (acceptor
!= INVALID_SOCKET
) {
7765 closesocket(acceptor
);
7771 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, buffer
, 3, &bytesReturned
, &overlapped
);
7772 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
7773 "returned %d + errno %d\n", bret
, WSAGetLastError());
7774 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
7775 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
7777 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
7778 ok(bret
, "Connecting failed, error %d\n", GetLastError());
7779 ok(bytesReturned
== 3, "Bytes sent is %d\n", bytesReturned
);
7781 acceptor
= accept(listener
, NULL
, NULL
);
7782 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket error %d\n", WSAGetLastError());
7784 bytesReturned
= recv(acceptor
, buffer
, 3, 0);
7786 ok(bytesReturned
== 3, "Didn't get all sent data, got only %d\n", bytesReturned
);
7787 ok(buffer
[0] == '1' && buffer
[1] == '2' && buffer
[2] == '3',
7788 "Failed to get the right data, expected '123', got '%s'\n", buffer
);
7790 closesocket(connector
);
7791 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7792 if (connector
== INVALID_SOCKET
) {
7793 skip("could not create connector socket, error %d\n", WSAGetLastError());
7796 /* ConnectEx needs a bound socket */
7797 memset(&conaddress
, 0, sizeof(conaddress
));
7798 conaddress
.sin_family
= AF_INET
;
7799 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7800 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
7802 skip("failed to bind, error %d\n", WSAGetLastError());
7806 if (acceptor
!= INVALID_SOCKET
) {
7807 closesocket(acceptor
);
7808 acceptor
= INVALID_SOCKET
;
7811 /* Connect with error */
7812 closesocket(listener
);
7813 listener
= INVALID_SOCKET
;
7815 address
.sin_port
= htons(1);
7817 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
7818 ok(bret
== FALSE
&& GetLastError(), "ConnectEx to bad destination failed: "
7819 "returned %d + errno %d\n", bret
, GetLastError());
7821 if (GetLastError() == ERROR_IO_PENDING
)
7823 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
7824 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
7826 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
7827 ok(bret
== FALSE
&& GetLastError() == ERROR_CONNECTION_REFUSED
,
7828 "Connecting to a disconnected host returned error %d - %d\n", bret
, WSAGetLastError());
7831 ok(GetLastError() == WSAECONNREFUSED
,
7832 "Connecting to a disconnected host returned error %d - %d\n", bret
, WSAGetLastError());
7836 if (overlapped
.hEvent
)
7837 WSACloseEvent(overlapped
.hEvent
);
7838 if (listener
!= INVALID_SOCKET
)
7839 closesocket(listener
);
7840 if (acceptor
!= INVALID_SOCKET
)
7841 closesocket(acceptor
);
7842 if (connector
!= INVALID_SOCKET
)
7843 closesocket(connector
);
7846 static void test_AcceptEx(void)
7848 SOCKET listener
= INVALID_SOCKET
;
7849 SOCKET acceptor
= INVALID_SOCKET
;
7850 SOCKET connector
= INVALID_SOCKET
;
7851 SOCKET connector2
= INVALID_SOCKET
;
7852 struct sockaddr_in bindAddress
, peerAddress
, *readBindAddress
, *readRemoteAddress
;
7853 int socklen
, optlen
;
7854 GUID acceptExGuid
= WSAID_ACCEPTEX
, getAcceptExGuid
= WSAID_GETACCEPTEXSOCKADDRS
;
7855 LPFN_ACCEPTEX pAcceptEx
= NULL
;
7856 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs
= NULL
;
7857 fd_set fds_accept
, fds_send
;
7858 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
7860 DWORD bytesReturned
, connect_time
;
7861 char buffer
[1024], ipbuffer
[32];
7862 OVERLAPPED overlapped
;
7863 int iret
, localSize
= sizeof(struct sockaddr_in
), remoteSize
= localSize
;
7867 memset(&overlapped
, 0, sizeof(overlapped
));
7869 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
7870 if (listener
== INVALID_SOCKET
) {
7871 skip("could not create listener socket, error %d\n", WSAGetLastError());
7875 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7876 if (acceptor
== INVALID_SOCKET
) {
7877 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7881 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7882 if (connector
== INVALID_SOCKET
) {
7883 skip("could not create connector socket, error %d\n", WSAGetLastError());
7887 memset(&bindAddress
, 0, sizeof(bindAddress
));
7888 bindAddress
.sin_family
= AF_INET
;
7889 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7890 iret
= bind(listener
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7892 skip("failed to bind, error %d\n", WSAGetLastError());
7896 socklen
= sizeof(bindAddress
);
7897 iret
= getsockname(listener
, (struct sockaddr
*)&bindAddress
, &socklen
);
7899 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
7903 if (set_blocking(listener
, FALSE
)) {
7904 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7908 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
7909 &pAcceptEx
, sizeof(pAcceptEx
), &bytesReturned
, NULL
, NULL
);
7911 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret
, WSAGetLastError());
7915 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &getAcceptExGuid
, sizeof(getAcceptExGuid
),
7916 &pGetAcceptExSockaddrs
, sizeof(pGetAcceptExSockaddrs
), &bytesReturned
, NULL
, NULL
);
7918 skip("WSAIoctl failed to get GetAcceptExSockaddrs with ret %d + errno %d\n", iret
, WSAGetLastError());
7922 bret
= pAcceptEx(INVALID_SOCKET
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7923 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7924 &bytesReturned
, &overlapped
);
7925 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid listening socket "
7926 "returned %d + errno %d\n", bret
, WSAGetLastError());
7928 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7929 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7930 &bytesReturned
, &overlapped
);
7932 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on a non-listening socket "
7933 "returned %d + errno %d\n", bret
, WSAGetLastError());
7935 iret
= listen(listener
, 5);
7937 skip("listening failed, errno = %d\n", WSAGetLastError());
7941 bret
= pAcceptEx(listener
, INVALID_SOCKET
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7942 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7943 &bytesReturned
, &overlapped
);
7944 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid accepting socket "
7945 "returned %d + errno %d\n", bret
, WSAGetLastError());
7947 bret
= pAcceptEx(listener
, acceptor
, NULL
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7948 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7949 &bytesReturned
, &overlapped
);
7951 (WSAGetLastError() == WSAEINVAL
||
7952 broken(WSAGetLastError() == WSAEFAULT
)), /* NT4 */
7953 "AcceptEx on NULL buffer returned %d + errno %d\n", bret
, WSAGetLastError());
7955 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16,
7956 &bytesReturned
, &overlapped
);
7957 ok(bret
== FALSE
&& (WSAGetLastError() == ERROR_IO_PENDING
|| broken(WSAGetLastError() == WSAEINVAL
)) /* NT4 */,
7958 "AcceptEx on too small local address size returned %d + errno %d\n",
7959 bret
, WSAGetLastError());
7960 bret
= CancelIo((HANDLE
) listener
);
7961 ok(bret
, "Failed to cancel pending accept socket\n");
7963 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 15,
7964 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
7965 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx on too small local address "
7966 "size returned %d + errno %d\n",
7967 bret
, WSAGetLastError());
7968 bret
= CancelIo((HANDLE
) listener
);
7969 ok(bret
, "Failed to cancel pending accept socket\n");
7971 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16, 0,
7972 &bytesReturned
, &overlapped
);
7973 ok(bret
== FALSE
&& (WSAGetLastError() == WSAEFAULT
|| broken(WSAGetLastError() == WSAEINVAL
)) /* NT4 */,
7974 "AcceptEx on too small remote address size returned %d + errno %d\n", bret
, WSAGetLastError());
7976 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16,
7977 sizeof(struct sockaddr_in
) + 15, &bytesReturned
, &overlapped
);
7978 ok(bret
== FALSE
&& (WSAGetLastError() == ERROR_IO_PENDING
|| broken(WSAGetLastError() == WSAEINVAL
)) /* NT4 */,
7979 "AcceptEx on too small remote address size returned %d + errno %d\n", bret
, WSAGetLastError());
7980 bret
= CancelIo((HANDLE
) listener
);
7981 ok(bret
, "Failed to cancel pending accept socket\n");
7983 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
7984 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7985 &bytesReturned
, NULL
);
7986 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
7987 "returned %d + errno %d\n", bret
, WSAGetLastError());
7989 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, 0, &bytesReturned
, NULL
);
7990 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
7991 "returned %d + errno %d\n", bret
, WSAGetLastError());
7993 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
7994 if (overlapped
.hEvent
== NULL
) {
7995 skip("could not create event object, errno = %d\n", GetLastError());
7999 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
8000 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8001 &bytesReturned
, &overlapped
);
8002 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8004 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
8005 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8006 &bytesReturned
, &overlapped
);
8007 todo_wine
ok((bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
) || broken(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
) /* NT4 */,
8008 "AcceptEx on already pending socket returned %d + errno %d\n", bret
, WSAGetLastError());
8009 if (bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
) {
8010 /* We need to cancel this call, otherwise things fail */
8011 bret
= CancelIo((HANDLE
) listener
);
8012 ok(bret
, "Failed to cancel failed test. Bailing...\n");
8014 WaitForSingleObject(overlapped
.hEvent
, 0);
8016 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
8017 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8018 &bytesReturned
, &overlapped
);
8019 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8022 iret
= connect(acceptor
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8023 todo_wine
ok((iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEINVAL
) || broken(!iret
) /* NT4 */,
8024 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret
, WSAGetLastError());
8025 if (!iret
|| (iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
)) {
8026 /* We need to cancel this call, otherwise things fail */
8027 closesocket(acceptor
);
8028 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
8029 if (acceptor
== INVALID_SOCKET
) {
8030 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8034 bret
= CancelIo((HANDLE
) listener
);
8035 ok(bret
, "Failed to cancel failed test. Bailing...\n");
8038 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
8039 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8040 &bytesReturned
, &overlapped
);
8041 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8044 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8045 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8047 dwret
= WaitForSingleObject(overlapped
.hEvent
, INFINITE
);
8048 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
8050 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
8051 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
8052 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
8054 closesocket(connector
);
8055 connector
= INVALID_SOCKET
;
8056 closesocket(acceptor
);
8058 /* Test short reads */
8060 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
8061 if (acceptor
== INVALID_SOCKET
) {
8062 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8065 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8066 if (connector
== INVALID_SOCKET
) {
8067 skip("could not create connector socket, error %d\n", WSAGetLastError());
8070 bret
= pAcceptEx(listener
, acceptor
, buffer
, 2,
8071 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8072 &bytesReturned
, &overlapped
);
8073 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8075 connect_time
= 0xdeadbeef;
8076 optlen
= sizeof(connect_time
);
8077 iret
= getsockopt(connector
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
8078 ok(!iret
, "getsockopt failed %d\n", WSAGetLastError());
8079 ok(connect_time
== ~0u, "unexpected connect time %u\n", connect_time
);
8081 /* AcceptEx() still won't complete until we send data */
8082 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8083 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8085 connect_time
= 0xdeadbeef;
8086 optlen
= sizeof(connect_time
);
8087 iret
= getsockopt(connector
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
8088 ok(!iret
, "getsockopt failed %d\n", WSAGetLastError());
8089 ok(connect_time
< 0xdeadbeef, "unexpected connect time %u\n", connect_time
);
8091 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
8092 ok(dwret
== WAIT_TIMEOUT
, "Waiting for accept event timeout failed with %d + errno %d\n", dwret
, GetLastError());
8094 iret
= getsockname( connector
, (struct sockaddr
*)&peerAddress
, &remoteSize
);
8095 ok( !iret
, "getsockname failed.\n");
8097 /* AcceptEx() could complete any time now */
8098 iret
= send(connector
, buffer
, 1, 0);
8099 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
8101 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8102 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
8104 /* Check if the buffer from AcceptEx is decoded correctly */
8105 pGetAcceptExSockaddrs(buffer
, 2, sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8106 (struct sockaddr
**)&readBindAddress
, &localSize
,
8107 (struct sockaddr
**)&readRemoteAddress
, &remoteSize
);
8108 strcpy( ipbuffer
, inet_ntoa(readBindAddress
->sin_addr
));
8109 ok( readBindAddress
->sin_addr
.s_addr
== bindAddress
.sin_addr
.s_addr
,
8110 "Local socket address is different %s != %s\n",
8111 ipbuffer
, inet_ntoa(bindAddress
.sin_addr
));
8112 ok( readBindAddress
->sin_port
== bindAddress
.sin_port
,
8113 "Local socket port is different: %d != %d\n",
8114 readBindAddress
->sin_port
, bindAddress
.sin_port
);
8115 strcpy( ipbuffer
, inet_ntoa(readRemoteAddress
->sin_addr
));
8116 ok( readRemoteAddress
->sin_addr
.s_addr
== peerAddress
.sin_addr
.s_addr
,
8117 "Remote socket address is different %s != %s\n",
8118 ipbuffer
, inet_ntoa(peerAddress
.sin_addr
));
8119 ok( readRemoteAddress
->sin_port
== peerAddress
.sin_port
,
8120 "Remote socket port is different: %d != %d\n",
8121 readRemoteAddress
->sin_port
, peerAddress
.sin_port
);
8123 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
8124 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
8125 ok(bytesReturned
== 1, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
8127 closesocket(connector
);
8128 connector
= INVALID_SOCKET
;
8129 closesocket(acceptor
);
8131 /* Test CF_DEFER & AcceptEx interaction */
8133 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
8134 if (acceptor
== INVALID_SOCKET
) {
8135 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8138 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8139 if (connector
== INVALID_SOCKET
) {
8140 skip("could not create connector socket, error %d\n", WSAGetLastError());
8143 connector2
= socket(AF_INET
, SOCK_STREAM
, 0);
8144 if (connector
== INVALID_SOCKET
) {
8145 skip("could not create connector socket, error %d\n", WSAGetLastError());
8149 if (set_blocking(connector
, FALSE
)) {
8150 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8154 if (set_blocking(connector2
, FALSE
)) {
8155 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8159 /* Connect socket #1 */
8160 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8161 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8163 FD_ZERO ( &fds_accept
);
8164 FD_ZERO ( &fds_send
);
8166 FD_SET ( listener
, &fds_accept
);
8167 FD_SET ( connector
, &fds_send
);
8173 for (i
= 0; i
< 4000; ++i
)
8175 fd_set fds_openaccept
= fds_accept
, fds_opensend
= fds_send
;
8177 wsa_ok ( ( select ( 0, &fds_openaccept
, &fds_opensend
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
8178 "acceptex test(%d): could not select on socket, errno %d\n" );
8180 /* check for incoming requests */
8181 if ( FD_ISSET ( listener
, &fds_openaccept
) ) {
8184 SOCKET tmp
= WSAAccept(listener
, NULL
, NULL
, (LPCONDITIONPROC
) AlwaysDeferConditionFunc
, 0);
8185 ok(tmp
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
8186 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
8187 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8188 &bytesReturned
, &overlapped
);
8189 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8191 else if (got
== 2) {
8192 /* this should be socket #2 */
8193 SOCKET tmp
= accept(listener
, NULL
, NULL
);
8194 ok(tmp
!= INVALID_SOCKET
, "accept failed %d\n", WSAGetLastError());
8198 ok(FALSE
, "Got more than 2 connections?\n");
8201 if ( conn1
&& FD_ISSET ( connector2
, &fds_opensend
) ) {
8202 /* Send data on second socket, and stop */
8203 send(connector2
, "2", 1, 0);
8204 FD_CLR ( connector2
, &fds_send
);
8208 if ( FD_ISSET ( connector
, &fds_opensend
) ) {
8209 /* Once #1 is connected, allow #2 to connect */
8212 send(connector
, "1", 1, 0);
8213 FD_CLR ( connector
, &fds_send
);
8215 iret
= connect(connector2
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8216 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8217 FD_SET ( connector2
, &fds_send
);
8221 ok (got
== 2 || broken(got
== 1) /* NT4 */,
8222 "Did not get both connections, got %d\n", got
);
8224 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
8225 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
8227 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
8228 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
8229 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
8231 set_blocking(acceptor
, TRUE
);
8232 iret
= recv( acceptor
, buffer
, 2, 0);
8233 ok(iret
== 1, "Failed to get data, %d, errno: %d\n", iret
, WSAGetLastError());
8235 ok(buffer
[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer
[0]);
8237 closesocket(connector
);
8238 connector
= INVALID_SOCKET
;
8239 closesocket(acceptor
);
8241 /* clean up in case of failures */
8242 while ((acceptor
= accept(listener
, NULL
, NULL
)) != INVALID_SOCKET
)
8243 closesocket(acceptor
);
8245 /* Disconnect during receive? */
8247 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
8248 if (acceptor
== INVALID_SOCKET
) {
8249 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8252 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8253 if (connector
== INVALID_SOCKET
) {
8254 skip("could not create connector socket, error %d\n", WSAGetLastError());
8257 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
8258 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8259 &bytesReturned
, &overlapped
);
8260 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8262 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8263 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8265 closesocket(connector
);
8266 connector
= INVALID_SOCKET
;
8268 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8269 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
8271 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
8272 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
8273 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
8275 closesocket(acceptor
);
8277 /* Test closing with pending requests */
8279 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
8280 if (acceptor
== INVALID_SOCKET
) {
8281 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8284 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
8285 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8286 &bytesReturned
, &overlapped
);
8287 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8289 closesocket(acceptor
);
8291 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8292 todo_wine
ok(dwret
== WAIT_OBJECT_0
|| broken(dwret
== WAIT_TIMEOUT
) /* NT4/2000 */,
8293 "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
8295 if (dwret
!= WAIT_TIMEOUT
) {
8296 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
8297 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
8300 bret
= CancelIo((HANDLE
) listener
);
8301 ok(bret
, "Failed to cancel failed test. Bailing...\n");
8303 WaitForSingleObject(overlapped
.hEvent
, 0);
8306 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
8307 if (acceptor
== INVALID_SOCKET
) {
8308 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8311 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
8312 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8313 &bytesReturned
, &overlapped
);
8314 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8316 CancelIo((HANDLE
) acceptor
);
8318 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8319 ok(dwret
== WAIT_TIMEOUT
, "Waiting for timeout failed with %d + errno %d\n", dwret
, GetLastError());
8321 closesocket(acceptor
);
8323 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
8324 if (acceptor
== INVALID_SOCKET
) {
8325 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8328 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
8329 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8330 &bytesReturned
, &overlapped
);
8331 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
8333 closesocket(listener
);
8334 listener
= INVALID_SOCKET
;
8336 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8337 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
8339 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
8340 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
8343 if (overlapped
.hEvent
)
8344 WSACloseEvent(overlapped
.hEvent
);
8345 if (listener
!= INVALID_SOCKET
)
8346 closesocket(listener
);
8347 if (acceptor
!= INVALID_SOCKET
)
8348 closesocket(acceptor
);
8349 if (connector
!= INVALID_SOCKET
)
8350 closesocket(connector
);
8351 if (connector2
!= INVALID_SOCKET
)
8352 closesocket(connector2
);
8355 static void test_DisconnectEx(void)
8357 SOCKET listener
, acceptor
, connector
;
8358 LPFN_DISCONNECTEX pDisconnectEx
;
8359 GUID disconnectExGuid
= WSAID_DISCONNECTEX
;
8360 struct sockaddr_in address
;
8361 DWORD num_bytes
, flags
;
8362 OVERLAPPED overlapped
;
8366 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8367 ok(connector
!= INVALID_SOCKET
, "failed to create connector socket, error %d\n", WSAGetLastError());
8369 iret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &disconnectExGuid
, sizeof(disconnectExGuid
),
8370 &pDisconnectEx
, sizeof(pDisconnectEx
), &num_bytes
, NULL
, NULL
);
8373 win_skip("WSAIoctl failed to get DisconnectEx, error %d\n", WSAGetLastError());
8374 closesocket(connector
);
8378 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
8379 ok(listener
!= INVALID_SOCKET
, "failed to create listener socket, error %d\n", WSAGetLastError());
8381 memset(&address
, 0, sizeof(address
));
8382 address
.sin_family
= AF_INET
;
8383 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8384 iret
= bind(listener
, (struct sockaddr
*)&address
, sizeof(address
));
8385 ok(iret
== 0, "failed to bind, error %d\n", WSAGetLastError());
8387 addrlen
= sizeof(address
);
8388 iret
= getsockname(listener
, (struct sockaddr
*)&address
, &addrlen
);
8389 ok(iret
== 0, "failed to lookup bind address, error %d\n", WSAGetLastError());
8391 iret
= listen(listener
, 1);
8392 ok(iret
== 0, "failed to listen, error %d\n", WSAGetLastError());
8394 set_blocking(listener
, TRUE
);
8396 memset(&overlapped
, 0, sizeof(overlapped
));
8397 bret
= pDisconnectEx(INVALID_SOCKET
, &overlapped
, 0, 0);
8398 ok(bret
== FALSE
, "DisconnectEx unexpectedly succeeded\n");
8399 ok(WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %d\n", WSAGetLastError());
8401 memset(&overlapped
, 0, sizeof(overlapped
));
8402 bret
= pDisconnectEx(connector
, &overlapped
, 0, 0);
8403 ok(bret
== FALSE
, "DisconnectEx unexpectedly succeeded\n");
8404 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "expected WSAENOTCONN, got %d\n", WSAGetLastError());
8406 iret
= connect(connector
, (struct sockaddr
*)&address
, addrlen
);
8407 ok(iret
== 0, "failed to connect, error %d\n", WSAGetLastError());
8409 acceptor
= accept(listener
, NULL
, NULL
);
8410 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket, error %d\n", WSAGetLastError());
8412 memset(&overlapped
, 0, sizeof(overlapped
));
8413 overlapped
.hEvent
= WSACreateEvent();
8414 ok(overlapped
.hEvent
!= WSA_INVALID_EVENT
, "WSACreateEvent failed, error %d\n", WSAGetLastError());
8415 bret
= pDisconnectEx(connector
, &overlapped
, 0, 0);
8417 ok(overlapped
.Internal
== STATUS_PENDING
, "expected STATUS_PENDING, got %08lx\n", overlapped
.Internal
);
8418 else if (WSAGetLastError() == ERROR_IO_PENDING
)
8419 bret
= WSAGetOverlappedResult(connector
, &overlapped
, &num_bytes
, TRUE
, &flags
);
8420 ok(bret
, "DisconnectEx failed, error %d\n", WSAGetLastError());
8421 WSACloseEvent(overlapped
.hEvent
);
8423 iret
= connect(connector
, (struct sockaddr
*)&address
, sizeof(address
));
8424 ok(iret
!= 0, "connect unexpectedly succeeded\n");
8425 ok(WSAGetLastError() == WSAEISCONN
, "expected WSAEISCONN, got %d\n", WSAGetLastError());
8427 closesocket(acceptor
);
8428 closesocket(connector
);
8430 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8431 ok(connector
!= INVALID_SOCKET
, "failed to create connector socket, error %d\n", WSAGetLastError());
8433 iret
= connect(connector
, (struct sockaddr
*)&address
, addrlen
);
8434 ok(iret
== 0, "failed to connect, error %d\n", WSAGetLastError());
8436 acceptor
= accept(listener
, NULL
, NULL
);
8437 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket, error %d\n", WSAGetLastError());
8439 bret
= pDisconnectEx(connector
, NULL
, 0, 0);
8440 ok(bret
, "DisconnectEx failed, error %d\n", WSAGetLastError());
8442 iret
= connect(connector
, (struct sockaddr
*)&address
, sizeof(address
));
8443 ok(iret
!= 0, "connect unexpectedly succeeded\n");
8444 ok(WSAGetLastError() == WSAEISCONN
, "expected WSAEISCONN, got %d\n", WSAGetLastError());
8446 closesocket(acceptor
);
8447 closesocket(connector
);
8448 closesocket(listener
);
8451 #define compare_file(h,s,o) compare_file2(h,s,o,__FILE__,__LINE__)
8453 static void compare_file2(HANDLE handle
, SOCKET sock
, int offset
, const char *file
, int line
)
8455 char buf1
[256], buf2
[256];
8459 SetFilePointer(handle
, offset
, NULL
, FILE_BEGIN
);
8462 DWORD n1
= 0, n2
= 0;
8464 success
= ReadFile(handle
, buf1
, sizeof(buf1
), &n1
, NULL
);
8465 ok_(file
,line
)(success
, "Failed to read from file.\n");
8466 if (success
&& n1
== 0)
8470 n2
= recv(sock
, buf2
, n1
, 0);
8471 ok_(file
,line
)(n1
== n2
, "Block %d size mismatch (%d != %d)\n", i
, n1
, n2
);
8472 ok_(file
,line
)(memcmp(buf1
, buf2
, n2
) == 0, "Block %d failed\n", i
);
8477 static void test_TransmitFile(void)
8479 DWORD num_bytes
, err
, file_size
, total_sent
;
8480 GUID transmitFileGuid
= WSAID_TRANSMITFILE
;
8481 LPFN_TRANSMITFILE pTransmitFile
= NULL
;
8482 HANDLE file
= INVALID_HANDLE_VALUE
;
8483 char header_msg
[] = "hello world";
8484 char footer_msg
[] = "goodbye!!!";
8485 char system_ini_path
[MAX_PATH
];
8486 struct sockaddr_in bindAddress
;
8487 TRANSMIT_FILE_BUFFERS buffers
;
8488 SOCKET client
, server
, dest
;
8494 memset( &ov
, 0, sizeof(ov
) );
8496 /* Setup sockets for testing TransmitFile */
8497 client
= socket(AF_INET
, SOCK_STREAM
, 0);
8498 server
= socket(AF_INET
, SOCK_STREAM
, 0);
8499 if (client
== INVALID_SOCKET
|| server
== INVALID_SOCKET
)
8501 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8504 iret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &transmitFileGuid
, sizeof(transmitFileGuid
),
8505 &pTransmitFile
, sizeof(pTransmitFile
), &num_bytes
, NULL
, NULL
);
8508 skip("WSAIoctl failed to get TransmitFile with ret %d + errno %d\n", iret
, WSAGetLastError());
8511 GetSystemWindowsDirectoryA(system_ini_path
, MAX_PATH
);
8512 strcat(system_ini_path
, "\\system.ini");
8513 file
= CreateFileA(system_ini_path
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_ALWAYS
, 0x0, NULL
);
8514 if (file
== INVALID_HANDLE_VALUE
)
8516 skip("Unable to open a file to transmit.\n");
8519 file_size
= GetFileSize(file
, NULL
);
8521 /* Test TransmitFile with an invalid socket */
8522 bret
= pTransmitFile(INVALID_SOCKET
, file
, 0, 0, NULL
, NULL
, 0);
8523 err
= WSAGetLastError();
8524 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8525 ok(err
== WSAENOTSOCK
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTSOCK
);
8527 /* Test a bogus TransmitFile without a connected socket */
8528 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, TF_REUSE_SOCKET
);
8529 err
= WSAGetLastError();
8530 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8531 ok(err
== WSAENOTCONN
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTCONN
);
8533 /* Setup a properly connected socket for transfers */
8534 memset(&bindAddress
, 0, sizeof(bindAddress
));
8535 bindAddress
.sin_family
= AF_INET
;
8536 bindAddress
.sin_port
= htons(SERVERPORT
+1);
8537 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8538 iret
= bind(server
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8541 skip("failed to bind(), error %d\n", WSAGetLastError());
8544 iret
= listen(server
, 1);
8547 skip("failed to listen(), error %d\n", WSAGetLastError());
8550 iret
= connect(client
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8553 skip("failed to connect(), error %d\n", WSAGetLastError());
8556 len
= sizeof(bindAddress
);
8557 dest
= accept(server
, (struct sockaddr
*)&bindAddress
, &len
);
8558 if (dest
== INVALID_SOCKET
)
8560 skip("failed to accept(), error %d\n", WSAGetLastError());
8563 if (set_blocking(dest
, FALSE
))
8565 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8569 /* Test TransmitFile with no possible buffer */
8570 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, 0);
8571 ok(bret
, "TransmitFile failed unexpectedly.\n");
8572 iret
= recv(dest
, buf
, sizeof(buf
), 0);
8573 ok(iret
== -1, "Returned an unexpected buffer from TransmitFile (%d != -1).\n", iret
);
8575 /* Test TransmitFile with only buffer data */
8576 buffers
.Head
= &header_msg
[0];
8577 buffers
.HeadLength
= sizeof(header_msg
);
8578 buffers
.Tail
= &footer_msg
[0];
8579 buffers
.TailLength
= sizeof(footer_msg
);
8580 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, &buffers
, 0);
8581 ok(bret
, "TransmitFile failed unexpectedly.\n");
8582 iret
= recv(dest
, buf
, sizeof(buf
), 0);
8583 ok(iret
== sizeof(header_msg
)+sizeof(footer_msg
),
8584 "Returned an unexpected buffer from TransmitFile: %d\n", iret
);
8585 ok(memcmp(&buf
[0], &header_msg
[0], sizeof(header_msg
)) == 0,
8586 "TransmitFile header buffer did not match!\n");
8587 ok(memcmp(&buf
[sizeof(header_msg
)], &footer_msg
[0], sizeof(footer_msg
)) == 0,
8588 "TransmitFile footer buffer did not match!\n");
8590 /* Test TransmitFile with only file data */
8591 bret
= pTransmitFile(client
, file
, 0, 0, NULL
, NULL
, 0);
8592 ok(bret
, "TransmitFile failed unexpectedly.\n");
8593 compare_file(file
, dest
, 0);
8595 /* Test TransmitFile with both file and buffer data */
8596 buffers
.Head
= &header_msg
[0];
8597 buffers
.HeadLength
= sizeof(header_msg
);
8598 buffers
.Tail
= &footer_msg
[0];
8599 buffers
.TailLength
= sizeof(footer_msg
);
8600 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
8601 bret
= pTransmitFile(client
, file
, 0, 0, NULL
, &buffers
, 0);
8602 ok(bret
, "TransmitFile failed unexpectedly.\n");
8603 iret
= recv(dest
, buf
, sizeof(header_msg
), 0);
8604 ok(memcmp(buf
, &header_msg
[0], sizeof(header_msg
)) == 0,
8605 "TransmitFile header buffer did not match!\n");
8606 compare_file(file
, dest
, 0);
8607 iret
= recv(dest
, buf
, sizeof(footer_msg
), 0);
8608 ok(memcmp(buf
, &footer_msg
[0], sizeof(footer_msg
)) == 0,
8609 "TransmitFile footer buffer did not match!\n");
8611 /* Test overlapped TransmitFile */
8612 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
8613 if (ov
.hEvent
== INVALID_HANDLE_VALUE
)
8615 skip("Could not create event object, some tests will be skipped. errno = %d\n",
8619 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
8620 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, NULL
, 0);
8621 err
= WSAGetLastError();
8622 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8623 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n",
8624 err
, ERROR_IO_PENDING
);
8625 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
8626 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
8627 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
8628 ok(total_sent
== file_size
,
8629 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8630 total_sent
, file_size
);
8631 compare_file(file
, dest
, 0);
8633 /* Test overlapped TransmitFile w/ start offset */
8634 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
8635 if (ov
.hEvent
== INVALID_HANDLE_VALUE
)
8637 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
8640 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
8642 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, NULL
, 0);
8643 err
= WSAGetLastError();
8644 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8645 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, ERROR_IO_PENDING
);
8646 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
8647 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
8648 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
8649 ok(total_sent
== (file_size
- ov
.Offset
),
8650 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8651 total_sent
, file_size
- ov
.Offset
);
8652 compare_file(file
, dest
, ov
.Offset
);
8654 /* Test overlapped TransmitFile w/ file and buffer data */
8655 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
8656 if (ov
.hEvent
== INVALID_HANDLE_VALUE
)
8658 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
8661 buffers
.Head
= &header_msg
[0];
8662 buffers
.HeadLength
= sizeof(header_msg
);
8663 buffers
.Tail
= &footer_msg
[0];
8664 buffers
.TailLength
= sizeof(footer_msg
);
8665 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
8667 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, &buffers
, 0);
8668 err
= WSAGetLastError();
8669 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8670 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, ERROR_IO_PENDING
);
8671 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
8672 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
8673 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
8674 ok(total_sent
== (file_size
+ buffers
.HeadLength
+ buffers
.TailLength
),
8675 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8676 total_sent
, file_size
+ buffers
.HeadLength
+ buffers
.TailLength
);
8677 iret
= recv(dest
, buf
, sizeof(header_msg
), 0);
8678 ok(memcmp(buf
, &header_msg
[0], sizeof(header_msg
)) == 0,
8679 "TransmitFile header buffer did not match!\n");
8680 compare_file(file
, dest
, 0);
8681 iret
= recv(dest
, buf
, sizeof(footer_msg
), 0);
8682 ok(memcmp(buf
, &footer_msg
[0], sizeof(footer_msg
)) == 0,
8683 "TransmitFile footer buffer did not match!\n");
8685 /* Test TransmitFile with a UDP datagram socket */
8686 closesocket(client
);
8687 client
= socket(AF_INET
, SOCK_DGRAM
, 0);
8688 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, 0);
8689 err
= WSAGetLastError();
8690 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8691 ok(err
== WSAENOTCONN
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTCONN
);
8695 CloseHandle(ov
.hEvent
);
8696 closesocket(client
);
8697 closesocket(server
);
8700 static void test_getpeername(void)
8703 struct sockaddr_in sa
, sa_out
;
8704 SOCKADDR_STORAGE ss
;
8706 const char buf
[] = "hello world";
8709 /* Test the parameter validation order. */
8710 ret
= getpeername(INVALID_SOCKET
, NULL
, NULL
);
8711 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
8712 ok(WSAGetLastError() == WSAENOTSOCK
,
8713 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
8715 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
8716 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
8717 if (sock
== INVALID_SOCKET
)
8719 skip("Socket creation failed with %d\n", WSAGetLastError());
8723 ret
= getpeername(sock
, NULL
, NULL
);
8724 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
8725 ok(WSAGetLastError() == WSAENOTCONN
||
8726 broken(WSAGetLastError() == WSAEFAULT
), /* Win9x and WinMe */
8727 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
8729 memset(&sa
, 0, sizeof(sa
));
8730 sa
.sin_family
= AF_INET
;
8731 sa
.sin_port
= htons(139);
8732 sa
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8734 /* sendto does not change a socket's connection state. */
8735 ret
= sendto(sock
, buf
, sizeof(buf
), 0, (struct sockaddr
*)&sa
, sizeof(sa
));
8736 ok(ret
!= SOCKET_ERROR
,
8737 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
8739 ret
= getpeername(sock
, NULL
, NULL
);
8740 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
8741 ok(WSAGetLastError() == WSAENOTCONN
||
8742 broken(WSAGetLastError() == WSAEFAULT
), /* Win9x and WinMe */
8743 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
8745 ret
= connect(sock
, (struct sockaddr
*)&sa
, sizeof(sa
));
8747 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
8749 ret
= getpeername(sock
, NULL
, NULL
);
8750 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
8751 ok(WSAGetLastError() == WSAEFAULT
,
8752 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8754 /* Test crashes on Wine. */
8757 ret
= getpeername(sock
, (void*)0xdeadbeef, (void*)0xcafebabe);
8758 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
8759 ok(WSAGetLastError() == WSAEFAULT
,
8760 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8763 ret
= getpeername(sock
, (struct sockaddr
*)&sa_out
, NULL
);
8764 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
8765 ok(WSAGetLastError() == WSAEFAULT
,
8766 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8769 ret
= getpeername(sock
, NULL
, &sa_len
);
8770 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
8771 ok(WSAGetLastError() == WSAEFAULT
,
8772 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8773 ok(!sa_len
, "got %d\n", sa_len
);
8776 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
8777 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
8778 ok(WSAGetLastError() == WSAEFAULT
,
8779 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8780 ok(!sa_len
, "got %d\n", sa_len
);
8782 sa_len
= sizeof(ss
);
8783 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
8784 ok(ret
== 0, "Expected getpeername to return 0, got %d\n", ret
);
8785 ok(!memcmp(&sa
, &ss
, sizeof(sa
)),
8786 "Expected the returned structure to be identical to the connect structure\n");
8787 ok(sa_len
== sizeof(sa
), "got %d\n", sa_len
);
8792 static void test_sioRoutingInterfaceQuery(void)
8796 SOCKADDR_IN sin
= { 0 }, sout
= { 0 };
8797 DWORD bytesReturned
;
8799 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
8800 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
8801 if (sock
== INVALID_SOCKET
)
8803 skip("Socket creation failed with %d\n", WSAGetLastError());
8806 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, NULL
, 0, NULL
, 0, NULL
,
8808 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
8809 "expected WSAEFAULT, got %d\n", WSAGetLastError());
8810 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
8811 NULL
, 0, NULL
, NULL
, NULL
);
8812 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
8813 "expected WSAEFAULT, got %d\n", WSAGetLastError());
8814 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
8815 NULL
, 0, &bytesReturned
, NULL
, NULL
);
8816 ok(ret
== SOCKET_ERROR
&&
8817 (WSAGetLastError() == WSAEFAULT
/* Win98 */ ||
8818 WSAGetLastError() == WSAEINVAL
/* NT4 */||
8819 WSAGetLastError() == WSAEAFNOSUPPORT
),
8820 "expected WSAEFAULT or WSAEINVAL or WSAEAFNOSUPPORT, got %d\n",
8822 sin
.sin_family
= AF_INET
;
8823 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
8824 NULL
, 0, &bytesReturned
, NULL
, NULL
);
8825 ok(ret
== SOCKET_ERROR
&&
8826 (WSAGetLastError() == WSAEFAULT
/* Win98 */ ||
8827 WSAGetLastError() == WSAEINVAL
),
8828 "expected WSAEFAULT or WSAEINVAL, got %d\n", WSAGetLastError());
8829 sin
.sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
8830 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
8831 NULL
, 0, &bytesReturned
, NULL
, NULL
);
8832 ok(ret
== SOCKET_ERROR
&&
8833 (WSAGetLastError() == WSAEINVAL
/* NT4 */ ||
8834 WSAGetLastError() == WSAEFAULT
),
8835 "expected WSAEINVAL or WSAEFAULT, got %d\n", WSAGetLastError());
8836 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
8837 &sout
, sizeof(sout
), &bytesReturned
, NULL
, NULL
);
8838 ok(!ret
|| broken(WSAGetLastError() == WSAEINVAL
/* NT4 */),
8839 "WSAIoctl failed: %d\n", WSAGetLastError());
8842 ok(sout
.sin_family
== AF_INET
, "expected AF_INET, got %d\n",
8844 /* We expect the source address to be INADDR_LOOPBACK as well, but
8845 * there's no guarantee that a route to the loopback address exists,
8846 * so rather than introduce spurious test failures we do not test the
8853 static void test_sioAddressListChange(void)
8855 struct sockaddr_in bindAddress
;
8856 struct in_addr net_address
;
8857 WSAOVERLAPPED overlapped
, *olp
;
8859 DWORD num_bytes
, error
, tick
;
8860 SOCKET sock
, sock2
, sock3
;
8861 WSAEVENT event2
, event3
;
8868 /* Use gethostbyname to find the list of local network interfaces */
8869 h
= gethostbyname("");
8872 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, gethostbyname failed with %u\n",
8876 for (acount
= 0; h
->h_addr_list
[acount
]; acount
++);
8879 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
8883 net_address
.s_addr
= *(ULONG
*) h
->h_addr_list
[0];
8885 sock
= socket(AF_INET
, 0, IPPROTO_TCP
);
8886 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
8888 memset(&bindAddress
, 0, sizeof(bindAddress
));
8889 bindAddress
.sin_family
= AF_INET
;
8890 bindAddress
.sin_addr
.s_addr
= net_address
.s_addr
;
8891 SetLastError(0xdeadbeef);
8892 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8893 ok (!ret
, "bind() failed with error %d\n", GetLastError());
8894 set_blocking(sock
, FALSE
);
8896 memset(&overlapped
, 0, sizeof(overlapped
));
8897 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8898 SetLastError(0xdeadbeef);
8899 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8900 error
= GetLastError();
8901 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
8902 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
8904 CloseHandle(overlapped
.hEvent
);
8907 sock
= socket(AF_INET
, 0, IPPROTO_TCP
);
8908 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
8910 SetLastError(0xdeadbeef);
8911 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8912 ok (!ret
, "bind() failed with error %d\n", GetLastError());
8913 set_blocking(sock
, TRUE
);
8915 memset(&overlapped
, 0, sizeof(overlapped
));
8916 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8917 SetLastError(0xdeadbeef);
8918 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8919 error
= GetLastError();
8920 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
8921 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
8923 CloseHandle(overlapped
.hEvent
);
8926 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8927 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
8929 SetLastError(0xdeadbeef);
8930 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8931 ok (!ret
, "bind() failed with error %d\n", GetLastError());
8932 set_blocking(sock
, FALSE
);
8934 memset(&overlapped
, 0, sizeof(overlapped
));
8935 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8936 SetLastError(0xdeadbeef);
8937 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8938 error
= GetLastError();
8939 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
8940 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
8942 CloseHandle(overlapped
.hEvent
);
8945 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8946 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
8948 SetLastError(0xdeadbeef);
8949 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8950 ok (!ret
, "bind() failed with error %d\n", GetLastError());
8951 set_blocking(sock
, TRUE
);
8953 memset(&overlapped
, 0, sizeof(overlapped
));
8954 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8955 SetLastError(0xdeadbeef);
8956 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8957 error
= GetLastError();
8958 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
8959 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
8961 CloseHandle(overlapped
.hEvent
);
8964 /* When the socket is overlapped non-blocking and the list change is requested without
8965 * an overlapped structure the error will be different. */
8966 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8967 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
8969 SetLastError(0xdeadbeef);
8970 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8971 ok (!ret
, "bind() failed with error %d\n", GetLastError());
8972 set_blocking(sock
, FALSE
);
8974 SetLastError(0xdeadbeef);
8975 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
8976 error
= GetLastError();
8977 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
8978 ok (error
== WSAEWOULDBLOCK
, "expected 10035, got %d\n", error
);
8980 io_port
= CreateIoCompletionPort( (HANDLE
)sock
, NULL
, 0, 0 );
8981 ok (io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8983 set_blocking(sock
, FALSE
);
8984 memset(&overlapped
, 0, sizeof(overlapped
));
8985 SetLastError(0xdeadbeef);
8986 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8987 error
= GetLastError();
8988 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %u\n", error
);
8989 ok (error
== ERROR_IO_PENDING
, "expected ERROR_IO_PENDING got %u\n", error
);
8991 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8992 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 0 );
8993 ok(!bret
, "failed to get completion status %u\n", bret
);
8994 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8995 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8999 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9000 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 0 );
9001 ok(!bret
, "failed to get completion status %u\n", bret
);
9002 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %u\n", GetLastError());
9003 ok(olp
== &overlapped
, "Overlapped structure is at %p\n", olp
);
9005 CloseHandle(io_port
);
9007 /* Misuse of the API by using a blocking socket and not using an overlapped structure,
9008 * this leads to a hang forever. */
9011 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
9013 SetLastError(0xdeadbeef);
9014 bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9016 set_blocking(sock
, TRUE
);
9017 WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
9023 if (!winetest_interactive
)
9025 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
9029 /* Bind an overlapped socket to the first found network interface */
9030 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
9031 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
9032 sock2
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
9033 ok(sock2
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
9034 sock3
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
9035 ok(sock3
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
9037 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9038 ok(!ret
, "bind failed unexpectedly\n");
9039 ret
= bind(sock2
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9040 ok(!ret
, "bind failed unexpectedly\n");
9041 ret
= bind(sock3
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9042 ok(!ret
, "bind failed unexpectedly\n");
9044 set_blocking(sock2
, FALSE
);
9045 set_blocking(sock3
, FALSE
);
9047 /* Wait for address changes, request that the user connects/disconnects an interface */
9048 memset(&overlapped
, 0, sizeof(overlapped
));
9049 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
9050 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
9051 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
9052 ok(WSAGetLastError() == WSA_IO_PENDING
, "Expected pending last error, got %d\n", WSAGetLastError());
9054 ret
= WSAIoctl(sock2
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
9055 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
9056 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "Expected would block last error, got %d\n", WSAGetLastError());
9058 event2
= WSACreateEvent();
9059 event3
= WSACreateEvent();
9060 ret
= WSAEventSelect (sock2
, event2
, FD_ADDRESS_LIST_CHANGE
);
9061 ok(!ret
, "WSAEventSelect failed with %d\n", WSAGetLastError());
9062 /* sock3 did not request SIO_ADDRESS_LIST_CHANGE but it is trying to wait anyway */
9063 ret
= WSAEventSelect (sock3
, event3
, FD_ADDRESS_LIST_CHANGE
);
9064 ok(!ret
, "WSAEventSelect failed with %d\n", WSAGetLastError());
9066 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
9067 " change the ipv4 address of any of the local network interfaces (15 second timeout).\n");
9068 tick
= GetTickCount();
9069 ret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
9070 ok(ret
== WAIT_OBJECT_0
, "failed to get overlapped event %u\n", ret
);
9072 ret
= WaitForSingleObject(event2
, 500);
9074 ok(ret
== WAIT_OBJECT_0
, "failed to get change event %u\n", ret
);
9076 ret
= WaitForSingleObject(event3
, 500);
9077 ok(ret
== WAIT_TIMEOUT
, "unexpected change event\n");
9079 trace("Spent %d ms waiting.\n", GetTickCount() - tick
);
9081 WSACloseEvent(event2
);
9082 WSACloseEvent(event3
);
9089 static void test_synchronous_WSAIoctl(void)
9091 HANDLE previous_port
, io_port
;
9092 WSAOVERLAPPED overlapped
, *olp
;
9100 previous_port
= CreateIoCompletionPort( INVALID_HANDLE_VALUE
, NULL
, 0, 0 );
9101 ok( previous_port
!= NULL
, "failed to create completion port %u\n", GetLastError() );
9103 socket
= WSASocketW( AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
9104 ok( socket
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError() );
9106 io_port
= CreateIoCompletionPort( (HANDLE
)socket
, previous_port
, 0, 0 );
9107 ok( io_port
!= NULL
, "failed to create completion port %u\n", GetLastError() );
9110 memset( &overlapped
, 0, sizeof(overlapped
) );
9111 res
= WSAIoctl( socket
, FIONBIO
, &on
, sizeof(on
), NULL
, 0, &num_bytes
, &overlapped
, NULL
);
9112 ok( !res
, "WSAIoctl failed %d\n", WSAGetLastError() );
9114 ret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 10000 );
9115 ok( ret
, "failed to get completion status %u\n", GetLastError() );
9117 CloseHandle( io_port
);
9118 closesocket( socket
);
9119 CloseHandle( previous_port
);
9122 #define WM_ASYNCCOMPLETE (WM_USER + 100)
9123 static HWND
create_async_message_window(void)
9125 static const char class_name
[] = "ws2_32 async message window class";
9127 WNDCLASSEXA wndclass
;
9130 wndclass
.cbSize
= sizeof(wndclass
);
9131 wndclass
.style
= CS_HREDRAW
| CS_VREDRAW
;
9132 wndclass
.lpfnWndProc
= DefWindowProcA
;
9133 wndclass
.cbClsExtra
= 0;
9134 wndclass
.cbWndExtra
= 0;
9135 wndclass
.hInstance
= GetModuleHandleA(NULL
);
9136 wndclass
.hIcon
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
9137 wndclass
.hIconSm
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
9138 wndclass
.hCursor
= LoadCursorA(NULL
, (LPCSTR
)IDC_ARROW
);
9139 wndclass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
9140 wndclass
.lpszClassName
= class_name
;
9141 wndclass
.lpszMenuName
= NULL
;
9143 RegisterClassExA(&wndclass
);
9145 hWnd
= CreateWindowA(class_name
, "ws2_32 async message window", WS_OVERLAPPEDWINDOW
,
9146 0, 0, 500, 500, NULL
, NULL
, GetModuleHandleA(NULL
), NULL
);
9149 ok(0, "failed to create window: %u\n", GetLastError());
9156 static void wait_for_async_message(HWND hwnd
, HANDLE handle
)
9161 while ((ret
= GetMessageA(&msg
, 0, 0, 0)) &&
9162 !(msg
.hwnd
== hwnd
&& msg
.message
== WM_ASYNCCOMPLETE
))
9164 TranslateMessage(&msg
);
9165 DispatchMessageA(&msg
);
9168 ok(ret
, "did not expect WM_QUIT message\n");
9169 ok(msg
.wParam
== (WPARAM
)handle
, "expected wParam = %p, got %lx\n", handle
, msg
.wParam
);
9172 static void test_WSAAsyncGetServByPort(void)
9174 HWND hwnd
= create_async_message_window();
9176 char buffer
[MAXGETHOSTSTRUCT
];
9181 /* FIXME: The asynchronous window messages should be tested. */
9183 /* Parameters are not checked when initiating the asynchronous operation. */
9184 ret
= WSAAsyncGetServByPort(NULL
, 0, 0, NULL
, NULL
, 0);
9185 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
9187 ret
= WSAAsyncGetServByPort(hwnd
, WM_ASYNCCOMPLETE
, 0, NULL
, NULL
, 0);
9188 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
9189 wait_for_async_message(hwnd
, ret
);
9191 ret
= WSAAsyncGetServByPort(hwnd
, WM_ASYNCCOMPLETE
, htons(80), NULL
, NULL
, 0);
9192 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
9193 wait_for_async_message(hwnd
, ret
);
9195 ret
= WSAAsyncGetServByPort(hwnd
, WM_ASYNCCOMPLETE
, htons(80), NULL
, buffer
, MAXGETHOSTSTRUCT
);
9196 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
9197 wait_for_async_message(hwnd
, ret
);
9199 DestroyWindow(hwnd
);
9202 static void test_WSAAsyncGetServByName(void)
9204 HWND hwnd
= create_async_message_window();
9206 char buffer
[MAXGETHOSTSTRUCT
];
9211 /* FIXME: The asynchronous window messages should be tested. */
9213 /* Parameters are not checked when initiating the asynchronous operation. */
9214 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "", NULL
, NULL
, 0);
9215 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
9216 wait_for_async_message(hwnd
, ret
);
9218 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "", "", buffer
, MAXGETHOSTSTRUCT
);
9219 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
9220 wait_for_async_message(hwnd
, ret
);
9222 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "http", NULL
, NULL
, 0);
9223 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
9224 wait_for_async_message(hwnd
, ret
);
9226 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "http", "tcp", buffer
, MAXGETHOSTSTRUCT
);
9227 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
9228 wait_for_async_message(hwnd
, ret
);
9230 DestroyWindow(hwnd
);
9234 * Provide consistent initialization for the AcceptEx IOCP tests.
9236 static SOCKET
setup_iocp_src(struct sockaddr_in
*bindAddress
)
9238 SOCKET src
, ret
= INVALID_SOCKET
;
9241 src
= socket(AF_INET
, SOCK_STREAM
, 0);
9242 if (src
== INVALID_SOCKET
)
9244 skip("could not create listener socket, error %d\n", WSAGetLastError());
9248 memset(bindAddress
, 0, sizeof(*bindAddress
));
9249 bindAddress
->sin_family
= AF_INET
;
9250 bindAddress
->sin_addr
.s_addr
= inet_addr("127.0.0.1");
9251 iret
= bind(src
, (struct sockaddr
*)bindAddress
, sizeof(*bindAddress
));
9254 skip("failed to bind, error %d\n", WSAGetLastError());
9258 socklen
= sizeof(*bindAddress
);
9259 iret
= getsockname(src
, (struct sockaddr
*)bindAddress
, &socklen
);
9261 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
9265 if (set_blocking(src
, FALSE
))
9267 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
9271 iret
= listen(src
, 5);
9274 skip("listening failed, errno = %d\n", WSAGetLastError());
9280 if (src
!= ret
&& ret
== INVALID_SOCKET
)
9285 static void test_completion_port(void)
9287 HANDLE previous_port
, io_port
;
9288 WSAOVERLAPPED ov
, *olp
;
9289 SOCKET src
, dest
, dup
, connector
= INVALID_SOCKET
;
9290 WSAPROTOCOL_INFOA info
;
9293 DWORD num_bytes
, flags
;
9298 struct sockaddr_in bindAddress
;
9299 GUID acceptExGuid
= WSAID_ACCEPTEX
;
9300 LPFN_ACCEPTEX pAcceptEx
= NULL
;
9303 memset(buf
, 0, sizeof(buf
));
9304 previous_port
= CreateIoCompletionPort(INVALID_HANDLE_VALUE
, NULL
, 0, 0);
9305 ok( previous_port
!= NULL
, "Failed to create completion port %u\n", GetLastError());
9307 memset(&ov
, 0, sizeof(ov
));
9309 tcp_socketpair(&src
, &dest
);
9310 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
9312 skip("failed to create sockets\n");
9316 bufs
.len
= sizeof(buf
);
9322 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
9323 ok(!iret
, "Failed to set linger %d\n", GetLastError());
9325 io_port
= CreateIoCompletionPort( (HANDLE
)dest
, previous_port
, 125, 0 );
9326 ok(io_port
!= NULL
, "Failed to create completion port %u\n", GetLastError());
9328 SetLastError(0xdeadbeef);
9330 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
9331 ok(iret
== SOCKET_ERROR
, "WSARecv returned %d\n", iret
);
9332 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9337 src
= INVALID_SOCKET
;
9339 SetLastError(0xdeadbeef);
9341 num_bytes
= 0xdeadbeef;
9342 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9344 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9345 todo_wine
ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %d\n", bret
);
9346 todo_wine
ok(GetLastError() == ERROR_NETNAME_DELETED
, "Last error was %d\n", GetLastError());
9347 ok(key
== 125, "Key is %lu\n", key
);
9348 ok(num_bytes
== 0, "Number of bytes received is %u\n", num_bytes
);
9349 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9351 SetLastError(0xdeadbeef);
9353 num_bytes
= 0xdeadbeef;
9354 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9356 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9357 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %d\n", bret
);
9358 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9359 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9360 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9361 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9363 if (dest
!= INVALID_SOCKET
)
9366 memset(&ov
, 0, sizeof(ov
));
9368 tcp_socketpair(&src
, &dest
);
9369 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
9371 skip("failed to create sockets\n");
9375 bufs
.len
= sizeof(buf
);
9381 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
9382 ok(!iret
, "Failed to set linger %d\n", GetLastError());
9384 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 125, 0);
9385 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9387 set_blocking(dest
, FALSE
);
9390 src
= INVALID_SOCKET
;
9394 num_bytes
= 0xdeadbeef;
9395 SetLastError(0xdeadbeef);
9397 iret
= WSASend(dest
, &bufs
, 1, &num_bytes
, 0, &ov
, NULL
);
9398 ok(iret
== SOCKET_ERROR
, "WSASend failed - %d\n", iret
);
9399 ok(GetLastError() == WSAECONNRESET
, "Last error was %d\n", GetLastError());
9400 ok(num_bytes
== 0xdeadbeef, "Managed to send %d\n", num_bytes
);
9402 SetLastError(0xdeadbeef);
9404 num_bytes
= 0xdeadbeef;
9405 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9407 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9408 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
9409 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9410 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9411 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9412 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9414 if (dest
!= INVALID_SOCKET
)
9417 /* Test IOCP response on successful immediate read. */
9418 tcp_socketpair(&src
, &dest
);
9419 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
9421 skip("failed to create sockets\n");
9425 bufs
.len
= sizeof(buf
);
9428 SetLastError(0xdeadbeef);
9430 iret
= WSASend(src
, &bufs
, 1, &num_bytes
, 0, &ov
, NULL
);
9431 ok(!iret
, "WSASend failed - %d, last error %u\n", iret
, GetLastError());
9432 ok(num_bytes
== sizeof(buf
), "Managed to send %d\n", num_bytes
);
9434 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 125, 0);
9435 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9436 set_blocking(dest
, FALSE
);
9439 FD_SET(dest
, &fds_recv
);
9440 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
9442 num_bytes
= 0xdeadbeef;
9445 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
9446 ok(!iret
, "WSARecv failed - %d, last error %u\n", iret
, GetLastError());
9447 ok(num_bytes
== sizeof(buf
), "Managed to read %d\n", num_bytes
);
9449 SetLastError(0xdeadbeef);
9451 num_bytes
= 0xdeadbeef;
9452 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9454 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9455 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
9456 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9457 ok(key
== 125, "Key is %lu\n", key
);
9458 ok(num_bytes
== sizeof(buf
), "Number of bytes transferred is %u\n", num_bytes
);
9459 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9461 /* Test IOCP response on graceful shutdown. */
9465 FD_SET(dest
, &fds_recv
);
9466 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
9468 num_bytes
= 0xdeadbeef;
9470 memset(&ov
, 0, sizeof(ov
));
9472 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
9473 ok(!iret
, "WSARecv failed - %d, last error %u\n", iret
, GetLastError());
9474 ok(!num_bytes
, "Managed to read %d\n", num_bytes
);
9476 SetLastError(0xdeadbeef);
9478 num_bytes
= 0xdeadbeef;
9479 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9481 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9482 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
9483 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9484 ok(key
== 125, "Key is %lu\n", key
);
9485 ok(!num_bytes
, "Number of bytes transferred is %u\n", num_bytes
);
9486 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9489 src
= INVALID_SOCKET
;
9491 dest
= INVALID_SOCKET
;
9493 /* Test IOCP response on hard shutdown. This was the condition that triggered
9494 * a crash in an actual app (bug 38980). */
9495 tcp_socketpair(&src
, &dest
);
9496 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
9498 skip("failed to create sockets\n");
9502 bufs
.len
= sizeof(buf
);
9505 memset(&ov
, 0, sizeof(ov
));
9509 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
9510 ok(!iret
, "Failed to set linger %d\n", GetLastError());
9512 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 125, 0);
9513 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9514 set_blocking(dest
, FALSE
);
9517 src
= INVALID_SOCKET
;
9520 FD_SET(dest
, &fds_recv
);
9521 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
9523 num_bytes
= 0xdeadbeef;
9524 SetLastError(0xdeadbeef);
9526 /* Somehow a hard shutdown doesn't work on my Linux box. It seems SO_LINGER is ignored. */
9527 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
9528 todo_wine
ok(iret
== SOCKET_ERROR
, "WSARecv failed - %d\n", iret
);
9529 todo_wine
ok(GetLastError() == WSAECONNRESET
, "Last error was %d\n", GetLastError());
9530 todo_wine
ok(num_bytes
== 0xdeadbeef, "Managed to read %d\n", num_bytes
);
9532 SetLastError(0xdeadbeef);
9534 num_bytes
= 0xdeadbeef;
9535 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9537 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9538 todo_wine
ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
9539 todo_wine
ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9540 todo_wine
ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9541 todo_wine
ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9542 todo_wine
ok(!olp
, "Overlapped structure is at %p\n", olp
);
9546 /* Test reading from a non-connected socket, mostly because the above test is marked todo. */
9547 dest
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9548 ok(dest
!= INVALID_SOCKET
, "socket() failed\n");
9550 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 125, 0);
9551 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9552 set_blocking(dest
, FALSE
);
9554 num_bytes
= 0xdeadbeef;
9555 SetLastError(0xdeadbeef);
9556 memset(&ov
, 0, sizeof(ov
));
9558 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
9559 ok(iret
== SOCKET_ERROR
, "WSARecv failed - %d\n", iret
);
9560 ok(GetLastError() == WSAENOTCONN
, "Last error was %d\n", GetLastError());
9561 ok(num_bytes
== 0xdeadbeef, "Managed to read %d\n", num_bytes
);
9563 SetLastError(0xdeadbeef);
9565 num_bytes
= 0xdeadbeef;
9566 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9568 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9569 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
9570 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9571 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9572 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9573 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9575 num_bytes
= 0xdeadbeef;
9578 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
9579 if (dest
== INVALID_SOCKET
)
9581 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
9585 iret
= WSAIoctl(dest
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
9586 &pAcceptEx
, sizeof(pAcceptEx
), &num_bytes
, NULL
, NULL
);
9589 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret
, WSAGetLastError());
9593 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
9595 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
9598 SetLastError(0xdeadbeef);
9600 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
9601 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9603 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
9604 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9606 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
9607 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9610 src
= INVALID_SOCKET
;
9612 SetLastError(0xdeadbeef);
9614 num_bytes
= 0xdeadbeef;
9615 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9617 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9618 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9619 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
9620 ok(key
== 125, "Key is %lu\n", key
);
9621 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
9622 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9623 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
9625 SetLastError(0xdeadbeef);
9627 num_bytes
= 0xdeadbeef;
9628 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9629 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9630 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9631 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9632 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9633 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9634 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9636 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
9638 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
9641 SetLastError(0xdeadbeef);
9643 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
9644 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9646 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
9647 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9649 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
9650 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9653 src
= INVALID_SOCKET
;
9655 SetLastError(0xdeadbeef);
9657 num_bytes
= 0xdeadbeef;
9658 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9660 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9661 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9662 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
9663 ok(key
== 125, "Key is %lu\n", key
);
9664 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
9665 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9666 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
9668 SetLastError(0xdeadbeef);
9670 num_bytes
= 0xdeadbeef;
9671 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9672 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9673 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9674 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9675 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9676 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9677 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9679 /* Test IOCP with duplicated handle */
9681 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
9684 SetLastError(0xdeadbeef);
9686 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
9687 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9689 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
9690 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
9691 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
9693 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
9694 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9696 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
9697 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9699 SetLastError(0xdeadbeef);
9701 num_bytes
= 0xdeadbeef;
9702 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9703 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9704 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9705 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9706 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9707 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9708 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9711 src
= INVALID_SOCKET
;
9713 dup
= INVALID_SOCKET
;
9715 SetLastError(0xdeadbeef);
9717 num_bytes
= 0xdeadbeef;
9718 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9719 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9720 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9721 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
9722 ok(key
== 125, "Key is %lu\n", key
);
9723 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
9724 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9725 ok(olp
&& olp
->Internal
== (ULONG
)STATUS_CANCELLED
, "Internal status is %lx\n", olp
? olp
->Internal
: 0);
9727 SetLastError(0xdeadbeef);
9729 num_bytes
= 0xdeadbeef;
9730 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9731 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9732 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9733 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9734 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9735 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9736 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9738 /* Test IOCP with duplicated handle (closing duplicated handle) */
9740 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
9743 SetLastError(0xdeadbeef);
9745 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
9746 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9748 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
9749 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
9750 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
9752 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
9753 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9755 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
9756 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9759 dup
= INVALID_SOCKET
;
9761 SetLastError(0xdeadbeef);
9763 num_bytes
= 0xdeadbeef;
9764 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9765 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9766 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9767 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9768 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9769 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9770 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9772 SetLastError(0xdeadbeef);
9774 num_bytes
= 0xdeadbeef;
9775 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9776 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9777 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9778 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9779 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9780 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9781 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9784 src
= INVALID_SOCKET
;
9786 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9787 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9788 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
9789 ok(key
== 125, "Key is %lu\n", key
);
9790 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
9791 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9792 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
9794 SetLastError(0xdeadbeef);
9796 num_bytes
= 0xdeadbeef;
9797 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9798 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9799 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9800 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9801 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9802 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9803 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9805 /* Test IOCP with duplicated handle (closing original handle) */
9807 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
9810 SetLastError(0xdeadbeef);
9812 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
9813 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9815 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
9816 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
9817 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
9819 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
9820 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9822 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
9823 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9826 src
= INVALID_SOCKET
;
9828 SetLastError(0xdeadbeef);
9830 num_bytes
= 0xdeadbeef;
9831 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9832 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9833 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9834 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9835 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9836 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9837 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9840 dup
= INVALID_SOCKET
;
9842 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9843 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9844 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
9845 ok(key
== 125, "Key is %lu\n", key
);
9846 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
9847 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9848 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
9850 SetLastError(0xdeadbeef);
9852 num_bytes
= 0xdeadbeef;
9853 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9854 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9855 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9856 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9857 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9858 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9859 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9861 /* Test IOCP without AcceptEx */
9863 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
9866 SetLastError(0xdeadbeef);
9868 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
9869 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9872 src
= INVALID_SOCKET
;
9874 SetLastError(0xdeadbeef);
9876 num_bytes
= 0xdeadbeef;
9877 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9878 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9879 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9880 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9881 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9882 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9883 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9887 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
9890 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
9891 if (connector
== INVALID_SOCKET
) {
9892 skip("could not create connector socket, error %d\n", WSAGetLastError());
9896 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
9897 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9899 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 236, 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());
9908 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9909 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
9911 closesocket(connector
);
9912 connector
= INVALID_SOCKET
;
9914 SetLastError(0xdeadbeef);
9916 num_bytes
= 0xdeadbeef;
9917 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9919 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9920 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
9921 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9922 ok(key
== 125, "Key is %lu\n", key
);
9923 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
9924 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9925 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
9927 SetLastError(0xdeadbeef);
9929 num_bytes
= 0xdeadbeef;
9930 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9931 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9932 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9933 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9934 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9935 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9936 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9938 if (dest
!= INVALID_SOCKET
)
9940 if (src
!= INVALID_SOCKET
)
9945 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
9948 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
9949 if (dest
== INVALID_SOCKET
)
9951 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
9955 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
9956 if (connector
== INVALID_SOCKET
) {
9957 skip("could not create connector socket, error %d\n", WSAGetLastError());
9961 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
9962 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9964 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 236, 0);
9965 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9967 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
9968 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9970 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
9971 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9973 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9974 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
9976 iret
= send(connector
, buf
, 1, 0);
9977 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
9982 dest
= INVALID_SOCKET
;
9984 SetLastError(0xdeadbeef);
9986 num_bytes
= 0xdeadbeef;
9987 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9989 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9990 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
9991 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9992 ok(key
== 125, "Key is %lu\n", key
);
9993 ok(num_bytes
== 1, "Number of bytes transferred is %u\n", num_bytes
);
9994 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9995 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
9997 SetLastError(0xdeadbeef);
9999 num_bytes
= 0xdeadbeef;
10000 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10001 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10002 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10003 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
10004 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
10005 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
10006 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10008 if (src
!= INVALID_SOCKET
)
10010 if (connector
!= INVALID_SOCKET
)
10011 closesocket(connector
);
10015 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
10018 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
10019 if (dest
== INVALID_SOCKET
)
10021 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
10025 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
10026 if (connector
== INVALID_SOCKET
) {
10027 skip("could not create connector socket, error %d\n", WSAGetLastError());
10031 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
10032 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
10034 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 236, 0);
10035 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
10037 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
10038 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
10040 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
10041 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
10043 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
10044 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
10047 dest
= INVALID_SOCKET
;
10049 SetLastError(0xdeadbeef);
10051 num_bytes
= 0xdeadbeef;
10052 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10054 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
10055 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10056 todo_wine
ok(GetLastError() == ERROR_NETNAME_DELETED
||
10057 GetLastError() == ERROR_OPERATION_ABORTED
||
10058 GetLastError() == ERROR_CONNECTION_ABORTED
||
10059 GetLastError() == ERROR_PIPE_NOT_CONNECTED
/* win 2000 */,
10060 "Last error was %d\n", GetLastError());
10061 ok(key
== 125, "Key is %lu\n", key
);
10062 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
10063 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
10064 todo_wine
ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_LOCAL_DISCONNECT
||
10065 olp
->Internal
== (ULONG
)STATUS_CANCELLED
||
10066 olp
->Internal
== (ULONG
)STATUS_CONNECTION_ABORTED
||
10067 olp
->Internal
== (ULONG
)STATUS_PIPE_DISCONNECTED
/* win 2000 */),
10068 "Internal status is %lx\n", olp
? olp
->Internal
: 0);
10070 SetLastError(0xdeadbeef);
10072 num_bytes
= 0xdeadbeef;
10073 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10074 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10075 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10076 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
10077 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
10078 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
10079 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10083 if (dest
!= INVALID_SOCKET
)
10085 if (src
!= INVALID_SOCKET
)
10087 if (connector
!= INVALID_SOCKET
)
10088 closesocket(connector
);
10089 CloseHandle(previous_port
);
10092 static void test_address_list_query(void)
10094 SOCKET_ADDRESS_LIST
*address_list
;
10095 DWORD bytes_returned
, size
;
10100 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
10101 ok(s
!= INVALID_SOCKET
, "Failed to create socket, error %d.\n", WSAGetLastError());
10103 bytes_returned
= 0;
10104 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, NULL
, 0, &bytes_returned
, NULL
, NULL
);
10105 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
10106 if(WSAGetLastError() == WSAEINVAL
)
10108 win_skip("Windows <= NT4 is not supported in this test\n");
10112 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
10113 ok(bytes_returned
>= FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[0]),
10114 "Got unexpected bytes_returned %u.\n", bytes_returned
);
10116 size
= bytes_returned
;
10117 bytes_returned
= 0;
10118 address_list
= HeapAlloc(GetProcessHeap(), 0, size
* 2);
10119 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, address_list
, size
* 2, &bytes_returned
, NULL
, NULL
);
10120 ok(!ret
, "Got unexpected ret %d, error %d.\n", ret
, WSAGetLastError());
10121 ok(bytes_returned
== size
, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned
, size
);
10123 bytes_returned
= FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[address_list
->iAddressCount
]);
10124 for (i
= 0; i
< address_list
->iAddressCount
; ++i
)
10126 bytes_returned
+= address_list
->Address
[i
].iSockaddrLength
;
10128 ok(size
== bytes_returned
, "Got unexpected size %u, expected %u.\n", size
, bytes_returned
);
10130 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, address_list
, size
, NULL
, NULL
, NULL
);
10131 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
10132 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
10134 bytes_returned
= 0xdeadbeef;
10135 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, NULL
, size
, &bytes_returned
, NULL
, NULL
);
10136 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
10137 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
10138 ok(bytes_returned
== size
, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned
, size
);
10140 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, address_list
, 1, &bytes_returned
, NULL
, NULL
);
10141 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
10142 ok(WSAGetLastError() == WSAEINVAL
, "Got unexpected error %d.\n", WSAGetLastError());
10143 ok(bytes_returned
== 0, "Got unexpected bytes_returned %u.\n", bytes_returned
);
10145 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, address_list
,
10146 FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[0]), &bytes_returned
, NULL
, NULL
);
10147 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
10148 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
10149 ok(bytes_returned
== size
, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned
, size
);
10151 HeapFree(GetProcessHeap(), 0, address_list
);
10155 static DWORD WINAPI
inet_ntoa_thread_proc(void *param
)
10159 HANDLE
*event
= param
;
10161 addr
= inet_addr("4.3.2.1");
10162 ok(addr
== htonl(0x04030201), "expected 0x04030201, got %08x\n", addr
);
10163 str
= inet_ntoa(*(struct in_addr
*)&addr
);
10164 ok(!strcmp(str
, "4.3.2.1"), "expected 4.3.2.1, got %s\n", str
);
10166 SetEvent(event
[0]);
10167 WaitForSingleObject(event
[1], 3000);
10172 static void test_inet_ntoa(void)
10176 HANDLE thread
, event
[2];
10179 addr
= inet_addr("1.2.3.4");
10180 ok(addr
== htonl(0x01020304), "expected 0x01020304, got %08x\n", addr
);
10181 str
= inet_ntoa(*(struct in_addr
*)&addr
);
10182 ok(!strcmp(str
, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str
);
10184 event
[0] = CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
10185 event
[1] = CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
10187 thread
= CreateThread(NULL
, 0, inet_ntoa_thread_proc
, event
, 0, &tid
);
10188 WaitForSingleObject(event
[0], 3000);
10190 ok(!strcmp(str
, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str
);
10192 SetEvent(event
[1]);
10193 WaitForSingleObject(thread
, 3000);
10195 CloseHandle(event
[0]);
10196 CloseHandle(event
[1]);
10197 CloseHandle(thread
);
10200 static void test_WSALookupService(void)
10202 char buffer
[4096], strbuff
[128];
10203 WSAQUERYSETW
*qs
= NULL
;
10207 DWORD error
, offset
, bsize
;
10209 if (!pWSALookupServiceBeginW
|| !pWSALookupServiceEnd
|| !pWSALookupServiceNextW
)
10211 win_skip("WSALookupServiceBeginW or WSALookupServiceEnd or WSALookupServiceNextW not found\n");
10215 qs
= (WSAQUERYSETW
*)buffer
;
10216 memset(qs
, 0, sizeof(*qs
));
10218 /* invalid parameter tests */
10219 ret
= pWSALookupServiceBeginW(NULL
, 0, &hnd
);
10220 error
= WSAGetLastError();
10221 ok(ret
== SOCKET_ERROR
, "WSALookupServiceBeginW should have failed\n");
10223 ok(error
== WSAEFAULT
, "expected 10014, got %d\n", error
);
10225 ret
= pWSALookupServiceBeginW(qs
, 0, NULL
);
10226 error
= WSAGetLastError();
10227 ok(ret
== SOCKET_ERROR
, "WSALookupServiceBeginW should have failed\n");
10229 ok(error
== WSAEFAULT
, "expected 10014, got %d\n", error
);
10231 ret
= pWSALookupServiceBeginW(qs
, 0, &hnd
);
10232 error
= WSAGetLastError();
10233 ok(ret
== SOCKET_ERROR
, "WSALookupServiceBeginW should have failed\n");
10235 ok(error
== WSAEINVAL
10236 || broken(error
== ERROR_INVALID_PARAMETER
) /* == XP */
10237 || broken(error
== WSAEFAULT
) /* == NT */
10238 || broken(error
== WSASERVICE_NOT_FOUND
) /* == 2000 */,
10239 "expected 10022, got %d\n", error
);
10241 ret
= pWSALookupServiceEnd(NULL
);
10242 error
= WSAGetLastError();
10244 ok(ret
== SOCKET_ERROR
, "WSALookupServiceEnd should have failed\n");
10246 ok(error
== ERROR_INVALID_HANDLE
, "expected 6, got %d\n", error
);
10248 /* standard network list query */
10249 qs
->dwSize
= sizeof(*qs
);
10250 hnd
= (HANDLE
)0xdeadbeef;
10251 ret
= pWSALookupServiceBeginW(qs
, LUP_RETURN_ALL
| LUP_DEEP
, &hnd
);
10252 error
= WSAGetLastError();
10253 if(ret
&& error
== ERROR_INVALID_PARAMETER
)
10255 win_skip("the current WSALookupServiceBeginW test is not supported in win <= 2000\n");
10260 ok(!ret
, "WSALookupServiceBeginW failed unexpectedly with error %d\n", error
);
10262 ok(hnd
!= (HANDLE
)0xdeadbeef, "Handle was not filled\n");
10267 memset(qs
, 0, sizeof(*qs
));
10268 bsize
= sizeof(buffer
);
10270 if (pWSALookupServiceNextW(hnd
, 0, &bsize
, qs
) == SOCKET_ERROR
)
10272 error
= WSAGetLastError();
10273 if (error
== WSA_E_NO_MORE
) break;
10274 ok(0, "Error %d happened while listing services\n", error
);
10278 WideCharToMultiByte(CP_ACP
, 0, qs
->lpszServiceInstanceName
, -1,
10279 strbuff
, sizeof(strbuff
), NULL
, NULL
);
10280 trace("Network Name: %s\n", strbuff
);
10282 /* network data is written in the blob field */
10285 /* each network may have multiple NLA_BLOB information structures */
10288 netdata
= (PNLA_BLOB
) &qs
->lpBlob
->pBlobData
[offset
];
10289 switch (netdata
->header
.type
)
10292 trace("\tNLA Data Type: NLA_RAW_DATA\n");
10294 case NLA_INTERFACE
:
10295 trace("\tNLA Data Type: NLA_INTERFACE\n");
10296 trace("\t\tType: %d\n", netdata
->data
.interfaceData
.dwType
);
10297 trace("\t\tSpeed: %d\n", netdata
->data
.interfaceData
.dwSpeed
);
10298 trace("\t\tAdapter Name: %s\n", netdata
->data
.interfaceData
.adapterName
);
10300 case NLA_802_1X_LOCATION
:
10301 trace("\tNLA Data Type: NLA_802_1X_LOCATION\n");
10302 trace("\t\tInformation: %s\n", netdata
->data
.locationData
.information
);
10304 case NLA_CONNECTIVITY
:
10305 switch (netdata
->data
.connectivity
.type
)
10307 case NLA_NETWORK_AD_HOC
:
10308 trace("\t\tNetwork Type: AD HOC\n");
10310 case NLA_NETWORK_MANAGED
:
10311 trace("\t\tNetwork Type: Managed\n");
10313 case NLA_NETWORK_UNMANAGED
:
10314 trace("\t\tNetwork Type: Unmanaged\n");
10316 case NLA_NETWORK_UNKNOWN
:
10317 trace("\t\tNetwork Type: Unknown\n");
10319 switch (netdata
->data
.connectivity
.internet
)
10321 case NLA_INTERNET_NO
:
10322 trace("\t\tInternet connectivity: No\n");
10324 case NLA_INTERNET_YES
:
10325 trace("\t\tInternet connectivity: Yes\n");
10327 case NLA_INTERNET_UNKNOWN
:
10328 trace("\t\tInternet connectivity: Unknown\n");
10333 trace("\tNLA Data Type: NLA_ICS\n");
10334 trace("\t\tSpeed: %d\n",
10335 netdata
->data
.ICS
.remote
.speed
);
10336 trace("\t\tType: %d\n",
10337 netdata
->data
.ICS
.remote
.type
);
10338 trace("\t\tState: %d\n",
10339 netdata
->data
.ICS
.remote
.state
);
10340 WideCharToMultiByte(CP_ACP
, 0, netdata
->data
.ICS
.remote
.machineName
, -1,
10341 strbuff
, sizeof(strbuff
), NULL
, NULL
);
10342 trace("\t\tMachine Name: %s\n", strbuff
);
10343 WideCharToMultiByte(CP_ACP
, 0, netdata
->data
.ICS
.remote
.sharedAdapterName
, -1,
10344 strbuff
, sizeof(strbuff
), NULL
, NULL
);
10345 trace("\t\tShared Adapter Name: %s\n", strbuff
);
10348 trace("\tNLA Data Type: Unknown\n");
10357 ret
= pWSALookupServiceEnd(hnd
);
10358 ok(!ret
, "WSALookupServiceEnd failed unexpectedly\n");
10361 static void test_WSAEnumNameSpaceProvidersA(void)
10363 LPWSANAMESPACE_INFOA name
= NULL
;
10364 DWORD ret
, error
, blen
= 0, i
;
10365 if (!pWSAEnumNameSpaceProvidersA
)
10367 win_skip("WSAEnumNameSpaceProvidersA not found\n");
10371 SetLastError(0xdeadbeef);
10372 ret
= pWSAEnumNameSpaceProvidersA(&blen
, name
);
10373 error
= WSAGetLastError();
10375 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
10377 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
10379 /* Invalid parameter tests */
10380 SetLastError(0xdeadbeef);
10381 ret
= pWSAEnumNameSpaceProvidersA(NULL
, name
);
10382 error
= WSAGetLastError();
10384 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
10386 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
10388 SetLastError(0xdeadbeef);
10389 ret
= pWSAEnumNameSpaceProvidersA(NULL
, NULL
);
10390 error
= WSAGetLastError();
10392 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
10394 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
10396 SetLastError(0xdeadbeef);
10397 ret
= pWSAEnumNameSpaceProvidersA(&blen
, NULL
);
10398 error
= WSAGetLastError();
10400 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
10402 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
10404 name
= HeapAlloc(GetProcessHeap(), 0, blen
);
10407 skip("Failed to alloc memory\n");
10411 ret
= pWSAEnumNameSpaceProvidersA(&blen
, name
);
10413 ok(ret
> 0, "Expected more than zero name space providers\n");
10415 for (i
= 0;i
< ret
; i
++)
10417 trace("Name space Identifier (%p): %s\n", name
[i
].lpszIdentifier
,
10418 name
[i
].lpszIdentifier
);
10419 switch (name
[i
].dwNameSpace
)
10422 trace("\tName space ID: NS_DNS (%u)\n", name
[i
].dwNameSpace
);
10425 trace("\tName space ID: NS_NLA (%u)\n", name
[i
].dwNameSpace
);
10428 trace("\tName space ID: Unknown (%u)\n", name
[i
].dwNameSpace
);
10431 trace("\tActive: %d\n", name
[i
].fActive
);
10432 trace("\tVersion: %d\n", name
[i
].dwVersion
);
10435 HeapFree(GetProcessHeap(), 0, name
);
10438 static void test_WSAEnumNameSpaceProvidersW(void)
10440 LPWSANAMESPACE_INFOW name
= NULL
;
10441 DWORD ret
, error
, blen
= 0, i
;
10442 if (!pWSAEnumNameSpaceProvidersW
)
10444 win_skip("WSAEnumNameSpaceProvidersW not found\n");
10448 SetLastError(0xdeadbeef);
10449 ret
= pWSAEnumNameSpaceProvidersW(&blen
, name
);
10450 error
= WSAGetLastError();
10452 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
10454 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
10456 /* Invalid parameter tests */
10457 SetLastError(0xdeadbeef);
10458 ret
= pWSAEnumNameSpaceProvidersW(NULL
, name
);
10459 error
= WSAGetLastError();
10461 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
10463 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
10465 SetLastError(0xdeadbeef);
10466 ret
= pWSAEnumNameSpaceProvidersW(NULL
, NULL
);
10467 error
= WSAGetLastError();
10469 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
10471 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
10473 SetLastError(0xdeadbeef);
10474 ret
= pWSAEnumNameSpaceProvidersW(&blen
, NULL
);
10475 error
= WSAGetLastError();
10477 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
10479 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
10481 name
= HeapAlloc(GetProcessHeap(), 0, blen
);
10484 skip("Failed to alloc memory\n");
10488 ret
= pWSAEnumNameSpaceProvidersW(&blen
, name
);
10490 ok(ret
> 0, "Expected more than zero name space providers\n");
10492 for (i
= 0;i
< ret
; i
++)
10494 trace("Name space Identifier (%p): %s\n", name
[i
].lpszIdentifier
,
10495 wine_dbgstr_w(name
[i
].lpszIdentifier
));
10496 switch (name
[i
].dwNameSpace
)
10499 trace("\tName space ID: NS_DNS (%u)\n", name
[i
].dwNameSpace
);
10502 trace("\tName space ID: NS_NLA (%u)\n", name
[i
].dwNameSpace
);
10505 trace("\tName space ID: Unknown (%u)\n", name
[i
].dwNameSpace
);
10508 trace("\tActive: %d\n", name
[i
].fActive
);
10509 trace("\tVersion: %d\n", name
[i
].dwVersion
);
10512 HeapFree(GetProcessHeap(), 0, name
);
10515 /**************** Main program ***************/
10521 /* Leave these tests at the beginning. They depend on WSAStartup not having been
10522 * called, which is done by Init() below. */
10523 test_WithoutWSAStartup();
10524 test_WithWSAStartup();
10530 test_set_getsockopt();
10531 test_so_reuseaddr();
10533 test_extendedSocketOptions();
10535 for (i
= 0; i
< sizeof(tests
)/sizeof(tests
[0]); i
++)
10537 trace ( " **** STARTING TEST %d ****\n", i
);
10538 do_test ( &tests
[i
] );
10539 trace ( " **** TEST %d COMPLETE ****\n", i
);
10544 test_getservbyname();
10546 test_WSADuplicateSocket();
10547 test_WSAEnumNetworkEvents();
10549 test_WSAAddressToStringA();
10550 test_WSAAddressToStringW();
10552 test_WSAStringToAddressA();
10553 test_WSAStringToAddressW();
10559 test_getpeername();
10560 test_getsockname();
10562 test_addr_to_print();
10563 test_ioctlsocket();
10565 test_gethostbyname();
10566 test_gethostbyname_hack();
10567 test_gethostname();
10578 test_TransmitFile();
10579 test_GetAddrInfoW();
10580 test_getaddrinfo();
10583 test_DisconnectEx();
10585 test_sioRoutingInterfaceQuery();
10586 test_sioAddressListChange();
10588 test_WSALookupService();
10589 test_WSAEnumNameSpaceProvidersA();
10590 test_WSAEnumNameSpaceProvidersW();
10592 test_WSAAsyncGetServByPort();
10593 test_WSAAsyncGetServByName();
10595 test_completion_port();
10596 test_address_list_query();
10598 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
10600 test_synchronous_WSAIoctl();