2 * Unit test suite for winsock functions
4 * Copyright 2002 Martin Wilck
5 * Copyright 2005 Thomas Kho
6 * Copyright 2008 Jeff Zaroyko
7 * Copyright 2017 Dmitry Timoshkov
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #define WIN32_NO_STATUS
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 SERVERIP "127.0.0.1" /* IP to bind to */
47 #define SERVERPORT 9374 /* Port number to bind to */
49 #define wsa_ok(op, cond, msg) \
53 if ( !(cond tmp) ) err = WSAGetLastError(); \
54 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
57 #define make_keepalive(k, enable, time, interval) \
59 k.keepalivetime = time; \
60 k.keepaliveinterval = interval;
62 /* Function pointers */
63 static int (WINAPI
*pWSAPoll
)(WSAPOLLFD
*,ULONG
,INT
);
65 /* Function pointers from ntdll */
66 static DWORD (WINAPI
*pNtClose
)(HANDLE
);
68 /**************** Structs and typedefs ***************/
70 typedef struct thread_info
76 /* Information in the server about open client connections */
77 typedef struct sock_info
80 struct sockaddr_in addr
;
81 struct sockaddr_in peer
;
87 /* Test parameters for both server & client */
88 typedef struct test_params
92 const char *inet_addr
;
99 /* server-specific test parameters */
100 typedef struct server_params
102 test_params
*general
;
107 /* client-specific test parameters */
108 typedef struct client_params
110 test_params
*general
;
115 /* This type combines all information for setting up a test scenario */
116 typedef struct test_setup
120 server_params srv_params
;
122 client_params clt_params
;
125 /* Thread local storage for server */
126 typedef struct server_memory
129 struct sockaddr_in addr
;
130 sock_info sock
[MAX_CLIENTS
];
133 /* Thread local storage for client */
134 typedef struct client_memory
137 struct sockaddr_in addr
;
142 /* SelectReadThread thread parameters */
143 typedef struct select_thread_params
147 } select_thread_params
;
149 /**************** Static variables ***************/
151 static DWORD tls
; /* Thread local storage index */
152 static HANDLE thread
[1+MAX_CLIENTS
];
153 static DWORD thread_id
[1+MAX_CLIENTS
];
154 static HANDLE server_ready
;
155 static HANDLE client_ready
[MAX_CLIENTS
];
156 static int client_id
;
158 /**************** General utility functions ***************/
160 static SOCKET
setup_server_socket(struct sockaddr_in
*addr
, int *len
);
161 static SOCKET
setup_connector_socket(const struct sockaddr_in
*addr
, int len
, BOOL nonblock
);
163 static void tcp_socketpair_flags(SOCKET
*src
, SOCKET
*dst
, DWORD flags
)
165 SOCKET server
= INVALID_SOCKET
;
166 struct sockaddr_in addr
;
169 *src
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, flags
);
170 ok(*src
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
172 server
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, flags
);
173 ok(server
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
175 memset(&addr
, 0, sizeof(addr
));
176 addr
.sin_family
= AF_INET
;
177 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
178 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
179 ok(!ret
, "failed to bind socket, error %u\n", WSAGetLastError());
182 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
183 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
185 ret
= listen(server
, 1);
186 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
188 ret
= connect(*src
, (struct sockaddr
*)&addr
, sizeof(addr
));
189 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
192 *dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
193 ok(*dst
!= INVALID_SOCKET
, "failed to accept socket, error %u\n", WSAGetLastError());
198 static void tcp_socketpair(SOCKET
*src
, SOCKET
*dst
)
200 tcp_socketpair_flags(src
, dst
, WSA_FLAG_OVERLAPPED
);
203 #define check_poll(a, b) check_poll_(__LINE__, a, POLLRDNORM | POLLRDBAND | POLLWRNORM, b, FALSE)
204 #define check_poll_todo(a, b) check_poll_(__LINE__, a, POLLRDNORM | POLLRDBAND | POLLWRNORM, b, TRUE)
205 #define check_poll_mask(a, b, c) check_poll_(__LINE__, a, b, c, FALSE)
206 #define check_poll_mask_todo(a, b, c) check_poll_(__LINE__, a, b, c, TRUE)
207 static void check_poll_(int line
, SOCKET s
, short mask
, short expect
, BOOL todo
)
213 pollfd
.events
= mask
;
214 pollfd
.revents
= 0xdead;
215 ret
= pWSAPoll(&pollfd
, 1, 1000);
216 ok_(__FILE__
, line
)(ret
== (pollfd
.revents
? 1 : 0), "WSAPoll() returned %d\n", ret
);
217 todo_wine_if (todo
) ok_(__FILE__
, line
)(pollfd
.revents
== expect
, "got wrong events %#x\n", pollfd
.revents
);
220 static void set_so_opentype ( BOOL overlapped
)
222 int optval
= !overlapped
, newval
, len
= sizeof (int);
224 ok ( setsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
225 (LPVOID
) &optval
, sizeof (optval
) ) == 0,
226 "setting SO_OPENTYPE failed\n" );
227 ok ( getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
228 (LPVOID
) &newval
, &len
) == 0,
229 "getting SO_OPENTYPE failed\n" );
230 ok ( optval
== newval
, "failed to set SO_OPENTYPE\n" );
233 static int set_blocking ( SOCKET s
, BOOL blocking
)
235 u_long val
= !blocking
;
236 return ioctlsocket ( s
, FIONBIO
, &val
);
239 static void fill_buffer ( char *buf
, int chunk_size
, int n_chunks
)
242 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
243 memset ( p
, c
, chunk_size
);
246 static int test_buffer ( char *buf
, int chunk_size
, int n_chunks
)
250 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
252 for ( i
= 0; i
< chunk_size
; i
++ )
253 if ( p
[i
] != c
) return i
;
259 * This routine is called when a client / server does not expect any more data,
260 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
262 static void read_zero_bytes ( SOCKET s
)
266 while ( ( tmp
= recv ( s
, buf
, 256, 0 ) ) > 0 )
268 ok ( n
<= 0, "garbage data received: %d bytes\n", n
);
271 static int do_synchronous_send ( SOCKET s
, char *buf
, int buflen
, int flags
, int sendlen
)
273 char* last
= buf
+ buflen
, *p
;
275 for ( p
= buf
; n
> 0 && p
< last
; )
277 n
= send ( s
, p
, min ( sendlen
, last
- p
), flags
);
280 wsa_ok ( n
, 0 <=, "do_synchronous_send (%x): error %d\n" );
284 static int do_synchronous_recv ( SOCKET s
, char *buf
, int buflen
, int flags
, int recvlen
)
286 char* last
= buf
+ buflen
, *p
;
288 for ( p
= buf
; n
> 0 && p
< last
; )
290 n
= recv ( s
, p
, min ( recvlen
, last
- p
), flags
);
293 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
297 static int do_synchronous_recvfrom ( SOCKET s
, char *buf
, int buflen
, int flags
, struct sockaddr
*from
, int *fromlen
, int recvlen
)
299 char* last
= buf
+ buflen
, *p
;
301 for ( p
= buf
; n
> 0 && p
< last
; )
303 n
= recvfrom ( s
, p
, min ( recvlen
, last
- p
), flags
, from
, fromlen
);
306 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
311 * Call this routine right after thread startup.
312 * SO_OPENTYPE must by 0, regardless what the server did.
314 static void check_so_opentype (void)
318 getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
, (LPVOID
) &tmp
, &len
);
319 ok ( tmp
== 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp
);
322 /**************** Server utility functions ***************/
325 * Even if we have closed our server socket cleanly,
326 * the OS may mark the address "in use" for some time -
327 * this happens with native Linux apps, too.
329 static void do_bind ( SOCKET s
, struct sockaddr
* addr
, int addrlen
)
331 int err
, wsaerr
= 0, n_try
= BIND_TRIES
;
333 while ( ( err
= bind ( s
, addr
, addrlen
) ) != 0 &&
334 ( wsaerr
= WSAGetLastError () ) == WSAEADDRINUSE
&&
337 trace ( "address in use, waiting ...\n" );
338 Sleep ( 1000 * BIND_SLEEP
);
340 ok ( err
== 0, "failed to bind: %d\n", wsaerr
);
343 static void server_start ( server_params
*par
)
346 test_params
*gen
= par
->general
;
347 server_memory
*mem
= LocalAlloc ( LPTR
, sizeof ( server_memory
) );
349 TlsSetValue ( tls
, mem
);
350 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
351 NULL
, 0, par
->sock_flags
);
352 ok ( mem
->s
!= INVALID_SOCKET
, "Server: WSASocket failed\n" );
354 mem
->addr
.sin_family
= AF_INET
;
355 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
356 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
358 for (i
= 0; i
< MAX_CLIENTS
; i
++)
360 mem
->sock
[i
].s
= INVALID_SOCKET
;
361 mem
->sock
[i
].buf
= LocalAlloc ( LPTR
, gen
->n_chunks
* gen
->chunk_size
);
362 mem
->sock
[i
].n_recvd
= 0;
363 mem
->sock
[i
].n_sent
= 0;
366 if ( gen
->sock_type
== SOCK_STREAM
)
367 do_bind ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof (mem
->addr
) );
370 static void server_stop (void)
373 server_memory
*mem
= TlsGetValue ( tls
);
375 for (i
= 0; i
< MAX_CLIENTS
; i
++ )
377 LocalFree ( mem
->sock
[i
].buf
);
378 if ( mem
->sock
[i
].s
!= INVALID_SOCKET
)
379 closesocket ( mem
->sock
[i
].s
);
381 ok ( closesocket ( mem
->s
) == 0, "closesocket failed\n" );
383 ExitThread ( GetCurrentThreadId () );
386 /**************** Client utilitiy functions ***************/
388 static void client_start ( client_params
*par
)
390 test_params
*gen
= par
->general
;
391 client_memory
*mem
= LocalAlloc (LPTR
, sizeof (client_memory
));
393 TlsSetValue ( tls
, mem
);
395 WaitForSingleObject ( server_ready
, INFINITE
);
397 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
398 NULL
, 0, par
->sock_flags
);
400 mem
->addr
.sin_family
= AF_INET
;
401 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
402 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
404 ok ( mem
->s
!= INVALID_SOCKET
, "Client: WSASocket failed\n" );
406 mem
->send_buf
= LocalAlloc ( LPTR
, 2 * gen
->n_chunks
* gen
->chunk_size
);
407 mem
->recv_buf
= mem
->send_buf
+ gen
->n_chunks
* gen
->chunk_size
;
408 fill_buffer ( mem
->send_buf
, gen
->chunk_size
, gen
->n_chunks
);
410 SetEvent ( client_ready
[client_id
] );
411 /* Wait for the other clients to come up */
412 WaitForMultipleObjects ( min ( gen
->n_clients
, MAX_CLIENTS
), client_ready
, TRUE
, INFINITE
);
415 static void client_stop (void)
417 client_memory
*mem
= TlsGetValue ( tls
);
418 wsa_ok ( closesocket ( mem
->s
), 0 ==, "closesocket error (%x): %d\n" );
419 LocalFree ( mem
->send_buf
);
424 /**************** Servers ***************/
427 * simple_server: A very basic server doing synchronous IO.
429 static VOID WINAPI
simple_server ( server_params
*par
)
431 test_params
*gen
= par
->general
;
433 int pos
, n_recvd
, n_sent
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
434 id
= GetCurrentThreadId();
436 set_so_opentype ( FALSE
); /* non-overlapped */
437 server_start ( par
);
438 mem
= TlsGetValue ( tls
);
440 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
441 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "simple_server (%x): listen failed: %d\n");
443 SetEvent ( server_ready
); /* notify clients */
445 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
447 /* accept a single connection */
448 tmp
= sizeof ( mem
->sock
[0].peer
);
449 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
450 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "simple_server (%x): accept failed: %d\n" );
452 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
453 "simple_server (%x): strange peer address\n", id
);
455 /* Receive data & check it */
456 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
457 ok ( n_recvd
== n_expected
,
458 "simple_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
459 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
460 ok ( pos
== -1, "simple_server (%x): test pattern error: %d\n", id
, pos
);
463 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
464 ok ( n_sent
== n_expected
,
465 "simple_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
468 read_zero_bytes ( mem
->sock
[0].s
);
469 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "simple_server (%x): closesocket error: %d\n" );
470 mem
->sock
[0].s
= INVALID_SOCKET
;
477 * oob_server: A very basic server receiving out-of-band data.
479 static VOID WINAPI
oob_server ( server_params
*par
)
481 test_params
*gen
= par
->general
;
484 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
,
485 id
= GetCurrentThreadId();
487 set_so_opentype ( FALSE
); /* non-overlapped */
488 server_start ( par
);
489 mem
= TlsGetValue ( tls
);
491 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "oob_server (%x): failed to set blocking mode: %d\n");
492 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "oob_server (%x): listen failed: %d\n");
494 SetEvent ( server_ready
); /* notify clients */
496 /* accept a single connection */
497 tmp
= sizeof ( mem
->sock
[0].peer
);
498 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
499 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "oob_server (%x): accept failed: %d\n" );
501 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
502 "oob_server (%x): strange peer address\n", id
);
504 /* check initial atmark state */
505 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
506 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
508 /* Receive normal data */
509 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
510 ok ( n_recvd
== n_expected
,
511 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
512 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
513 ok ( pos
== -1, "oob_server (%x): test pattern error: %d\n", id
, pos
);
515 /* check atmark state */
516 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
517 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
520 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
521 ok ( n_sent
== n_expected
,
522 "oob_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
524 /* Receive a part of the out-of-band data and print atmark state */
525 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, 8, 0, par
->buflen
);
527 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, 8 );
530 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
532 /* Receive the rest of the out-of-band data and check atmark state */
533 do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
535 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
536 todo_wine
ok ( atmark
== 0, "oob_server (%x): not at the OOB mark: %i\n", id
, atmark
);
539 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "oob_server (%x): closesocket error: %d\n" );
540 mem
->sock
[0].s
= INVALID_SOCKET
;
546 * select_server: A non-blocking server.
548 static VOID WINAPI
select_server ( server_params
*par
)
550 test_params
*gen
= par
->general
;
552 int n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
553 id
= GetCurrentThreadId(), n_connections
= 0, n_sent
, n_recvd
,
554 n_set
, delta
, n_ready
;
555 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
556 fd_set fds_recv
, fds_send
, fds_openrecv
, fds_opensend
;
558 set_so_opentype ( FALSE
); /* non-overlapped */
559 server_start ( par
);
560 mem
= TlsGetValue ( tls
);
562 wsa_ok ( set_blocking ( mem
->s
, FALSE
), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
563 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "select_server (%x): listen failed: %d\n");
565 SetEvent ( server_ready
); /* notify clients */
567 FD_ZERO ( &fds_openrecv
);
568 FD_ZERO ( &fds_recv
);
569 FD_ZERO ( &fds_send
);
570 FD_ZERO ( &fds_opensend
);
572 FD_SET ( mem
->s
, &fds_openrecv
);
576 fds_recv
= fds_openrecv
;
577 fds_send
= fds_opensend
;
581 wsa_ok ( ( n_ready
= select ( 0, &fds_recv
, &fds_send
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
582 "select_server (%x): select() failed: %d\n" );
584 /* check for incoming requests */
585 if ( FD_ISSET ( mem
->s
, &fds_recv
) ) {
588 /* accept a single connection */
589 tmp
= sizeof ( mem
->sock
[n_connections
].peer
);
590 mem
->sock
[n_connections
].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[n_connections
].peer
, &tmp
);
591 wsa_ok ( mem
->sock
[n_connections
].s
, INVALID_SOCKET
!=, "select_server (%x): accept() failed: %d\n" );
593 ok ( mem
->sock
[n_connections
].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
594 "select_server (%x): strange peer address\n", id
);
596 /* add to list of open connections */
597 FD_SET ( mem
->sock
[n_connections
].s
, &fds_openrecv
);
598 FD_SET ( mem
->sock
[n_connections
].s
, &fds_opensend
);
603 /* handle open requests */
605 for ( i
= 0; i
< n_connections
; i
++ )
607 if ( FD_ISSET( mem
->sock
[i
].s
, &fds_recv
) ) {
610 if ( mem
->sock
[i
].n_recvd
< n_expected
) {
611 /* Receive data & check it */
612 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 );
613 ok ( n_recvd
!= SOCKET_ERROR
, "select_server (%x): error in recv(): %d\n", id
, WSAGetLastError() );
614 mem
->sock
[i
].n_recvd
+= n_recvd
;
616 if ( mem
->sock
[i
].n_recvd
== n_expected
) {
617 int pos
= test_buffer ( mem
->sock
[i
].buf
, gen
->chunk_size
, gen
->n_chunks
);
618 ok ( pos
== -1, "select_server (%x): test pattern error: %d\n", id
, pos
);
619 FD_CLR ( mem
->sock
[i
].s
, &fds_openrecv
);
622 ok ( mem
->sock
[i
].n_recvd
<= n_expected
, "select_server (%x): received too many bytes: %d\n", id
, mem
->sock
[i
].n_recvd
);
626 /* only echo back what we've received */
627 delta
= mem
->sock
[i
].n_recvd
- mem
->sock
[i
].n_sent
;
629 if ( FD_ISSET ( mem
->sock
[i
].s
, &fds_send
) ) {
632 if ( ( delta
> 0 ) && ( mem
->sock
[i
].n_sent
< n_expected
) ) {
634 n_sent
= send ( mem
->sock
[i
].s
, mem
->sock
[i
].buf
+ mem
->sock
[i
].n_sent
, min ( delta
, par
->buflen
), 0 );
635 ok ( n_sent
!= SOCKET_ERROR
, "select_server (%x): error in send(): %d\n", id
, WSAGetLastError() );
636 mem
->sock
[i
].n_sent
+= n_sent
;
638 if ( mem
->sock
[i
].n_sent
== n_expected
) {
639 FD_CLR ( mem
->sock
[i
].s
, &fds_opensend
);
642 ok ( mem
->sock
[i
].n_sent
<= n_expected
, "select_server (%x): sent too many bytes: %d\n", id
, mem
->sock
[i
].n_sent
);
647 /* check that select returned the correct number of ready sockets */
648 ok ( ( n_set
== n_ready
), "select_server (%x): select() returns wrong number of ready sockets\n", id
);
650 /* check if all clients are done */
651 if ( ( fds_opensend
.fd_count
== 0 )
652 && ( fds_openrecv
.fd_count
== 1 ) /* initial socket that accepts clients */
653 && ( n_connections
== min ( gen
->n_clients
, MAX_CLIENTS
) ) ) {
658 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
661 read_zero_bytes ( mem
->sock
[i
].s
);
662 wsa_ok ( closesocket ( mem
->sock
[i
].s
), 0 ==, "select_server (%x): closesocket error: %d\n" );
663 mem
->sock
[i
].s
= INVALID_SOCKET
;
669 /**************** Clients ***************/
672 * simple_client: A very basic client doing synchronous IO.
674 static VOID WINAPI
simple_client ( client_params
*par
)
676 test_params
*gen
= par
->general
;
678 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
680 id
= GetCurrentThreadId();
681 /* wait here because we want to call set_so_opentype before creating a socket */
682 WaitForSingleObject ( server_ready
, INFINITE
);
684 check_so_opentype ();
685 set_so_opentype ( FALSE
); /* non-overlapped */
686 client_start ( par
);
687 mem
= TlsGetValue ( tls
);
690 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
691 0 ==, "simple_client (%x): connect error: %d\n" );
692 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
693 "simple_client (%x): failed to set blocking mode\n", id
);
695 /* send data to server */
696 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
697 ok ( n_sent
== n_expected
,
698 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
700 /* shutdown send direction */
701 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
703 /* Receive data echoed back & check it */
704 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, 0, par
->buflen
);
705 ok ( n_recvd
== n_expected
,
706 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
709 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
710 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
713 read_zero_bytes ( mem
->s
);
718 * oob_client: A very basic client sending out-of-band data.
720 static VOID WINAPI
oob_client ( client_params
*par
)
722 test_params
*gen
= par
->general
;
724 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
726 id
= GetCurrentThreadId();
727 /* wait here because we want to call set_so_opentype before creating a socket */
728 WaitForSingleObject ( server_ready
, INFINITE
);
730 check_so_opentype ();
731 set_so_opentype ( FALSE
); /* non-overlapped */
732 client_start ( par
);
733 mem
= TlsGetValue ( tls
);
736 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
737 0 ==, "oob_client (%x): connect error: %d\n" );
738 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
739 "oob_client (%x): failed to set blocking mode\n", id
);
741 /* send data to server */
742 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
743 ok ( n_sent
== n_expected
,
744 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
746 /* Receive data echoed back & check it */
747 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, 0, par
->buflen
);
748 ok ( n_recvd
== n_expected
,
749 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
750 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
751 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
753 /* send out-of-band data to server */
754 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, MSG_OOB
, par
->buflen
);
755 ok ( n_sent
== n_expected
,
756 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
758 /* shutdown send direction */
759 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
762 read_zero_bytes ( mem
->s
);
767 * simple_mixed_client: mixing send and recvfrom
769 static VOID WINAPI
simple_mixed_client ( client_params
*par
)
771 test_params
*gen
= par
->general
;
773 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
774 int fromLen
= sizeof(mem
->addr
);
775 struct sockaddr test
;
777 id
= GetCurrentThreadId();
778 /* wait here because we want to call set_so_opentype before creating a socket */
779 WaitForSingleObject ( server_ready
, INFINITE
);
781 check_so_opentype ();
782 set_so_opentype ( FALSE
); /* non-overlapped */
783 client_start ( par
);
784 mem
= TlsGetValue ( tls
);
787 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
788 0 ==, "simple_client (%x): connect error: %d\n" );
789 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
790 "simple_client (%x): failed to set blocking mode\n", id
);
792 /* send data to server */
793 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
794 ok ( n_sent
== n_expected
,
795 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
797 /* shutdown send direction */
798 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
800 /* this shouldn't change, since lpFrom, is not updated on
801 connection oriented sockets - exposed by bug 11640
803 ((struct sockaddr_in
*)&test
)->sin_addr
.s_addr
= inet_addr("0.0.0.0");
805 /* Receive data echoed back & check it */
806 n_recvd
= do_synchronous_recvfrom ( mem
->s
,
810 (struct sockaddr
*)&test
,
813 ok ( n_recvd
== n_expected
,
814 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
816 /* check that lpFrom was not updated */
819 inet_ntoa(((struct sockaddr_in
*)&test
)->sin_addr
),
820 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
823 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
824 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
827 read_zero_bytes ( mem
->s
);
832 * event_client: An event-driven client
834 static void WINAPI
event_client ( client_params
*par
)
836 test_params
*gen
= par
->general
;
838 int id
= GetCurrentThreadId(), n_expected
= gen
->n_chunks
* gen
->chunk_size
,
841 WSANETWORKEVENTS wsa_events
;
842 char *send_last
, *recv_last
, *send_p
, *recv_p
;
843 LONG mask
= FD_READ
| FD_WRITE
| FD_CLOSE
;
845 client_start ( par
);
847 mem
= TlsGetValue ( tls
);
849 /* Prepare event notification for connect, makes socket nonblocking */
850 event
= WSACreateEvent ();
851 WSAEventSelect ( mem
->s
, event
, FD_CONNECT
);
852 tmp
= connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) );
854 err
= WSAGetLastError ();
855 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): connect error: %d\n", id
, err
);
856 tmp
= WaitForSingleObject ( event
, INFINITE
);
857 ok ( tmp
== WAIT_OBJECT_0
, "event_client (%x): wait for connect event failed: %d\n", id
, tmp
);
858 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
859 ok ( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
860 err
= wsa_events
.iErrorCode
[ FD_CONNECT_BIT
];
861 ok ( err
== 0, "event_client (%x): connect error: %d\n", id
, err
);
865 WSAEventSelect ( mem
->s
, event
, mask
);
867 recv_p
= mem
->recv_buf
;
868 recv_last
= mem
->recv_buf
+ n_expected
;
869 send_p
= mem
->send_buf
;
870 send_last
= mem
->send_buf
+ n_expected
;
874 err
= WaitForSingleObject ( event
, INFINITE
);
875 ok ( err
== WAIT_OBJECT_0
, "event_client (%x): wait failed\n", id
);
877 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
878 ok( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
880 if ( wsa_events
.lNetworkEvents
& FD_WRITE
)
882 err
= wsa_events
.iErrorCode
[ FD_WRITE_BIT
];
883 ok ( err
== 0, "event_client (%x): FD_WRITE error code: %d\n", id
, err
);
888 n
= send ( mem
->s
, send_p
, min ( send_last
- send_p
, par
->buflen
), 0 );
891 err
= WSAGetLastError ();
892 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): send error: %d\n", id
, err
);
897 while ( n
>= 0 && send_p
< send_last
);
899 if ( send_p
== send_last
)
901 shutdown ( mem
->s
, SD_SEND
);
903 WSAEventSelect ( mem
->s
, event
, mask
);
906 if ( wsa_events
.lNetworkEvents
& FD_READ
)
908 err
= wsa_events
.iErrorCode
[ FD_READ_BIT
];
909 ok ( err
== 0, "event_client (%x): FD_READ error code: %d\n", id
, err
);
910 if ( err
!= 0 ) break;
912 /* First read must succeed */
913 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
914 wsa_ok ( n
, 0 <=, "event_client (%x): recv error: %d\n" );
918 if ( recv_p
== recv_last
)
921 WSAEventSelect ( mem
->s
, event
, mask
);
924 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
925 ok(n
>= 0 || WSAGetLastError() == WSAEWOULDBLOCK
,
926 "event_client (%x): got error %u\n", id
, WSAGetLastError());
930 if ( wsa_events
.lNetworkEvents
& FD_CLOSE
)
932 err
= wsa_events
.iErrorCode
[ FD_CLOSE_BIT
];
933 ok ( err
== 0, "event_client (%x): FD_CLOSE error code: %d\n", id
, err
);
938 n
= send_p
- mem
->send_buf
;
939 ok ( send_p
== send_last
,
940 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n
, n_expected
);
941 n
= recv_p
- mem
->recv_buf
;
942 ok ( recv_p
== recv_last
,
943 "simple_client (%x): received less data than expected: %d of %d\n", id
, n
, n_expected
);
944 n
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
945 ok ( n
== -1, "event_client (%x): test pattern error: %d\n", id
, n
);
948 WSACloseEvent ( event
);
952 /* Tests for WSAStartup */
953 static void test_WithoutWSAStartup(void)
957 WSASetLastError(0xdeadbeef);
958 ok(WSASocketA(0, 0, 0, NULL
, 0, 0) == INVALID_SOCKET
, "WSASocketA should have failed\n");
959 err
= WSAGetLastError();
960 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %d\n", err
);
962 WSASetLastError(0xdeadbeef);
963 ok(gethostbyname("localhost") == NULL
, "gethostbyname() succeeded unexpectedly\n");
964 err
= WSAGetLastError();
965 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %d\n", err
);
968 static void test_WithWSAStartup(void)
971 WORD version
= MAKEWORD( 2, 2 );
972 INT res
, socks
, i
, j
;
977 SOCKET src
, dst
, dup_src
, dup_dst
;
981 res
= WSAStartup( version
, &data
);
982 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
984 ptr
= gethostbyname("localhost");
985 ok(ptr
!= NULL
, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
987 /* Alloc some sockets to check if they are destroyed on WSACleanup */
988 for (socks
= 0; socks
< ARRAY_SIZE(pairs
); socks
++)
990 WSAPROTOCOL_INFOA info
;
991 tcp_socketpair(&pairs
[socks
].src
, &pairs
[socks
].dst
);
993 memset(&info
, 0, sizeof(info
));
994 ok(!WSADuplicateSocketA(pairs
[socks
].src
, GetCurrentProcessId(), &info
),
995 "WSADuplicateSocketA should have worked\n");
996 pairs
[socks
].dup_src
= WSASocketA(0, 0, 0, &info
, 0, 0);
997 ok(pairs
[socks
].dup_src
!= SOCKET_ERROR
, "expected != -1\n");
999 memset(&info
, 0, sizeof(info
));
1000 ok(!WSADuplicateSocketA(pairs
[socks
].dst
, GetCurrentProcessId(), &info
),
1001 "WSADuplicateSocketA should have worked\n");
1002 pairs
[socks
].dup_dst
= WSASocketA(0, 0, 0, &info
, 0, 0);
1003 ok(pairs
[socks
].dup_dst
!= SOCKET_ERROR
, "expected != -1\n");
1006 res
= send(pairs
[0].src
, "TEST", 4, 0);
1007 ok(res
== 4, "send failed with error %d\n", WSAGetLastError());
1011 res
= WSAStartup( version
, &data
);
1012 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
1014 /* show that sockets are destroyed automatically after WSACleanup */
1015 SetLastError(0xdeadbeef);
1016 res
= send(pairs
[0].src
, "TEST", 4, 0);
1017 error
= WSAGetLastError();
1018 ok(res
== SOCKET_ERROR
, "send should have failed\n");
1019 ok(error
== WSAENOTSOCK
, "expected 10038, got %d\n", error
);
1021 SetLastError(0xdeadbeef);
1022 res
= send(pairs
[0].dst
, "TEST", 4, 0);
1023 error
= WSAGetLastError();
1024 ok(res
== SOCKET_ERROR
, "send should have failed\n");
1025 ok(error
== WSAENOTSOCK
, "expected 10038, got %d\n", error
);
1027 /* Check that all sockets were destroyed */
1028 for (i
= 0; i
< socks
; i
++)
1030 for (j
= 0; j
< 4; j
++)
1032 struct sockaddr_in saddr
;
1033 int size
= sizeof(saddr
);
1036 case 0: sock
= pairs
[i
].src
; break;
1037 case 1: sock
= pairs
[i
].dup_src
; break;
1038 case 2: sock
= pairs
[i
].dst
; break;
1039 case 3: sock
= pairs
[i
].dup_dst
; break;
1042 SetLastError(0xdeadbeef);
1043 res
= getsockname(sock
, (struct sockaddr
*)&saddr
, &size
);
1044 error
= WSAGetLastError();
1045 ok(res
== SOCKET_ERROR
, "Test[%d]: getsockname should have failed\n", i
);
1046 if (res
== SOCKET_ERROR
)
1047 ok(error
== WSAENOTSOCK
, "Test[%d]: expected 10038, got %d\n", i
, error
);
1051 /* While wine is not fixed, close all sockets manually */
1052 for (i
= 0; i
< socks
; i
++)
1054 closesocket(pairs
[i
].src
);
1055 closesocket(pairs
[i
].dst
);
1056 closesocket(pairs
[i
].dup_src
);
1057 closesocket(pairs
[i
].dup_dst
);
1061 ok(res
== 0, "expected 0, got %d\n", res
);
1062 WSASetLastError(0xdeadbeef);
1064 error
= WSAGetLastError();
1065 ok ( res
== SOCKET_ERROR
&& error
== WSANOTINITIALISED
,
1066 "WSACleanup returned %d WSAGetLastError is %d\n", res
, error
);
1069 /**************** Main program utility functions ***************/
1071 static void Init (void)
1073 WORD ver
= MAKEWORD (2, 2);
1075 HMODULE hws2_32
= GetModuleHandleA("ws2_32.dll"), ntdll
;
1077 pWSAPoll
= (void *)GetProcAddress(hws2_32
, "WSAPoll");
1079 ntdll
= LoadLibraryA("ntdll.dll");
1081 pNtClose
= (void *)GetProcAddress(ntdll
, "NtClose");
1083 ok ( WSAStartup ( ver
, &data
) == 0, "WSAStartup failed\n" );
1087 static void Exit (void)
1092 err
= WSAGetLastError();
1093 ok ( ret
== 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret
, err
);
1096 static void StartServer (LPTHREAD_START_ROUTINE routine
,
1097 test_params
*general
, server_params
*par
)
1099 par
->general
= general
;
1100 thread
[0] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[0] );
1101 ok ( thread
[0] != NULL
, "Failed to create server thread\n" );
1104 static void StartClients (LPTHREAD_START_ROUTINE routine
,
1105 test_params
*general
, client_params
*par
)
1108 par
->general
= general
;
1109 for ( i
= 1; i
<= min ( general
->n_clients
, MAX_CLIENTS
); i
++ )
1112 thread
[i
] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[i
] );
1113 ok ( thread
[i
] != NULL
, "Failed to create client thread\n" );
1114 /* Make sure the client is up and running */
1115 WaitForSingleObject ( client_ready
[client_id
], INFINITE
);
1119 static void do_test( test_setup
*test
)
1121 DWORD i
, n
= min (test
->general
.n_clients
, MAX_CLIENTS
);
1124 server_ready
= CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1125 for (i
= 0; i
<= n
; i
++)
1126 client_ready
[i
] = CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1128 StartServer ( test
->srv
, &test
->general
, &test
->srv_params
);
1129 StartClients ( test
->clt
, &test
->general
, &test
->clt_params
);
1130 WaitForSingleObject ( server_ready
, INFINITE
);
1132 wait
= WaitForMultipleObjects ( 1 + n
, thread
, TRUE
, 1000 * TEST_TIMEOUT
);
1133 ok(!wait
, "wait failed, error %u\n", wait
);
1135 CloseHandle ( server_ready
);
1136 for (i
= 0; i
<= n
; i
++)
1137 CloseHandle ( client_ready
[i
] );
1140 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1141 /* optname = SO_LINGER */
1142 static const LINGER linger_testvals
[] = {
1149 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1150 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1151 bug in the linux kernel (fixed in 2.6.8) */
1152 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1154 static void test_set_getsockopt(void)
1157 int i
, err
, lasterr
;
1161 WSAPROTOCOL_INFOA infoA
;
1162 WSAPROTOCOL_INFOW infoW
;
1163 char providername
[WSAPROTOCOL_LEN
+ 1];
1167 int family
, type
, proto
;
1169 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
1170 {AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
1171 {AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
},
1172 {AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
}
1180 s
= socket(AF_INET
, SOCK_STREAM
, 0);
1181 ok(s
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1182 if( s
== INVALID_SOCKET
) return;
1184 timeout
= SOCKTIMEOUT1
;
1185 size
= sizeof(timeout
);
1186 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1188 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1189 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1190 ok( timeout
== SOCKTIMEOUT1
, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1193 size
= sizeof(timeout
);
1194 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1196 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1197 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1198 ok( timeout
== 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1201 timeout
= SOCKTIMEOUT2
; /* 997 seconds. See remark above */
1202 size
= sizeof(timeout
);
1203 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, size
);
1205 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, &size
);
1206 ok( !err
, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1207 ok( timeout
== SOCKTIMEOUT2
, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout
);
1211 size
= sizeof(value
);
1212 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDBUF
, (char *)&value
, size
);
1213 ok( !err
, "setsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1215 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDBUF
, (char *)&value
, &size
);
1216 ok( !err
, "getsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1217 ok( value
== 4096, "expected 4096, got %u\n", value
);
1221 size
= sizeof(value
);
1222 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, size
);
1223 ok( !err
, "setsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1225 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, &size
);
1226 ok( !err
, "getsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1227 ok( value
== 4096, "expected 4096, got %u\n", value
);
1230 for( i
= 0; i
< ARRAY_SIZE(linger_testvals
);i
++) {
1231 size
= sizeof(lingval
);
1232 lingval
= linger_testvals
[i
];
1233 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *)&lingval
, size
);
1234 ok(!err
, "Test %u: failed to set SO_LINGER, error %u\n", i
, WSAGetLastError());
1235 err
= getsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *)&lingval
, &size
);
1236 ok(!err
, "Test %u: failed to get SO_LINGER, error %u\n", i
, WSAGetLastError());
1237 ok(!lingval
.l_onoff
== !linger_testvals
[i
].l_onoff
, "Test %u: expected %d, got %d\n",
1238 i
, linger_testvals
[i
].l_onoff
, lingval
.l_onoff
);
1239 if (lingval
.l_onoff
)
1240 ok(lingval
.l_linger
== linger_testvals
[i
].l_linger
, "Test %u: expected %d, got %d\n",
1241 i
, linger_testvals
[i
].l_linger
, lingval
.l_linger
);
1244 size
= sizeof(lingval
);
1245 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, size
);
1246 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1247 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1248 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, 0);
1249 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1250 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1252 size
= sizeof(BOOL
);
1253 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, size
);
1254 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1255 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1256 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, 0);
1257 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1258 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1260 /* Test for erroneously passing a value instead of a pointer as optval */
1261 size
= sizeof(char);
1262 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTROUTE
, (char *)1, size
);
1263 ok(err
== SOCKET_ERROR
, "setsockopt with optval being a value passed "
1264 "instead of failing.\n");
1265 lasterr
= WSAGetLastError();
1266 ok(lasterr
== WSAEFAULT
, "setsockopt with optval being a value "
1267 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1268 lasterr
, WSAEFAULT
);
1270 /* SO_RCVTIMEO with invalid values for level */
1271 size
= sizeof(timeout
);
1272 timeout
= SOCKTIMEOUT1
;
1273 SetLastError(0xdeadbeef);
1274 err
= setsockopt(s
, 0xffffffff, SO_RCVTIMEO
, (char *) &timeout
, size
);
1275 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1276 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1277 err
, WSAGetLastError());
1279 timeout
= SOCKTIMEOUT1
;
1280 SetLastError(0xdeadbeef);
1281 err
= setsockopt(s
, 0x00008000, SO_RCVTIMEO
, (char *) &timeout
, size
);
1282 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1283 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1284 err
, WSAGetLastError());
1286 /* Test SO_ERROR set/get */
1287 SetLastError(0xdeadbeef);
1289 err
= setsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, size
);
1291 ok( !err
&& !WSAGetLastError(),
1292 "got %d with %d (expected 0 with 0)\n",
1293 err
, WSAGetLastError());
1295 SetLastError(0xdeadbeef);
1297 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1298 ok( !err
&& !WSAGetLastError(),
1299 "got %d with %d (expected 0 with 0)\n",
1300 err
, WSAGetLastError());
1302 ok (i
== 1234, "got %d (expected 1234)\n", i
);
1304 /* Test invalid optlen */
1305 SetLastError(0xdeadbeef);
1307 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1308 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEFAULT
),
1309 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1310 err
, WSAGetLastError());
1313 /* Test with the closed socket */
1314 SetLastError(0xdeadbeef);
1317 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1318 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAENOTSOCK
),
1319 "got %d with %d (expected SOCKET_ERROR with WSAENOTSOCK)\n",
1320 err
, WSAGetLastError());
1321 ok (i
== 1234, "expected 1234, got %d\n", i
);
1323 /* Test WS_IP_MULTICAST_TTL with 8, 16, 24 and 32 bits values */
1324 s
= socket(AF_INET
, SOCK_DGRAM
, 0);
1325 ok(s
!= INVALID_SOCKET
, "Failed to create socket\n");
1328 err
= setsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &i
, size
);
1331 for (i
= 0; i
< 4; i
++)
1334 const int tests
[] = {0xffffff0a, 0xffff000b, 0xff00000c, 0x0000000d};
1335 err
= setsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &tests
[i
], i
+ 1);
1336 ok(!err
, "Test [%d] Expected 0, got %d\n", i
, err
);
1337 err
= getsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &k
, &size
);
1338 ok(!err
, "Test [%d] Expected 0, got %d\n", i
, err
);
1339 j
= i
!= 3 ? tests
[i
] & ((1 << (i
+ 1) * 8) - 1) : tests
[i
];
1340 ok(k
== j
, "Test [%d] Expected 0x%x, got 0x%x\n", i
, j
, k
);
1344 win_skip("IP_MULTICAST_TTL is unsupported\n");
1347 /* test SO_PROTOCOL_INFOA invalid parameters */
1348 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1349 "getsockopt should have failed\n");
1350 err
= WSAGetLastError();
1351 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1352 size
= sizeof(WSAPROTOCOL_INFOA
);
1353 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1354 "getsockopt should have failed\n");
1355 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1356 err
= WSAGetLastError();
1357 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1358 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1359 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1360 "getsockopt should have failed\n");
1361 err
= WSAGetLastError();
1362 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1363 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, NULL
),
1364 "getsockopt should have failed\n");
1365 err
= WSAGetLastError();
1366 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1367 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, &size
),
1368 "getsockopt should have failed\n");
1369 err
= WSAGetLastError();
1370 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1371 size
= sizeof(WSAPROTOCOL_INFOA
) / 2;
1372 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1373 "getsockopt should have failed\n");
1374 err
= WSAGetLastError();
1375 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1376 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1377 size
= sizeof(WSAPROTOCOL_INFOA
) * 2;
1378 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1379 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1380 ok(size
== sizeof(WSAPROTOCOL_INFOA
) * 2, "got size %d\n", size
);
1384 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1385 for (i
= 0; i
< ARRAY_SIZE(prottest
); i
++)
1389 s
= socket(prottest
[i
].family
, prottest
[i
].type
, prottest
[i
].proto
);
1390 if (s
== INVALID_SOCKET
&& prottest
[i
].family
== AF_INET6
) continue;
1392 ok(s
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
1395 /* compare both A and W version */
1396 infoA
.szProtocol
[0] = 0;
1397 size
= sizeof(WSAPROTOCOL_INFOA
);
1398 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1399 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1400 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1402 infoW
.szProtocol
[0] = 0;
1403 size
= sizeof(WSAPROTOCOL_INFOW
);
1404 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOW
, (char *) &infoW
, &size
);
1405 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1406 ok(size
== sizeof(WSAPROTOCOL_INFOW
), "got size %d\n", size
);
1408 ok(infoA
.szProtocol
[0], "WSAPROTOCOL_INFOA was not filled\n");
1409 ok(infoW
.szProtocol
[0], "WSAPROTOCOL_INFOW was not filled\n");
1411 WideCharToMultiByte(CP_ACP
, 0, infoW
.szProtocol
, -1,
1412 providername
, sizeof(providername
), NULL
, NULL
);
1413 ok(!strcmp(infoA
.szProtocol
,providername
),
1414 "different provider names '%s' != '%s'\n", infoA
.szProtocol
, providername
);
1416 ok(!memcmp(&infoA
, &infoW
, FIELD_OFFSET(WSAPROTOCOL_INFOA
, szProtocol
)),
1417 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1419 /* Remove IF when WSAEnumProtocols support IPV6 data */
1420 ok(infoA
.iAddressFamily
== prottest
[i
].family
, "socket family invalid, expected %d received %d\n",
1421 prottest
[i
].family
, infoA
.iAddressFamily
);
1422 ok(infoA
.iSocketType
== prottest
[i
].type
, "socket type invalid, expected %d received %d\n",
1423 prottest
[i
].type
, infoA
.iSocketType
);
1424 ok(infoA
.iProtocol
== prottest
[i
].proto
, "socket protocol invalid, expected %d received %d\n",
1425 prottest
[i
].proto
, infoA
.iProtocol
);
1427 /* IP_HDRINCL is supported only on SOCK_RAW but passed to SOCK_DGRAM by Impossible Creatures */
1430 SetLastError(0xdeadbeef);
1431 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1432 if (err
== -1) /* >= Vista */
1435 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1437 SetLastError(0xdeadbeef);
1438 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1439 ok(err
== -1, "Expected -1, got %d\n", err
);
1440 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1441 ok(k
== 99, "Expected 99, got %d\n", k
);
1445 SetLastError(0xdeadbeef);
1446 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1448 ok(err
== -1, "Expected -1, got %d\n", err
);
1450 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1452 SetLastError(0xdeadbeef);
1453 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1454 ok(err
== -1, "Expected -1, got %d\n", err
);
1455 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1456 ok(k
== 99, "Expected 99, got %d\n", k
);
1459 else /* <= 2003 the tests differ between TCP and UDP, UDP silently accepts */
1461 SetLastError(0xdeadbeef);
1463 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1464 if (prottest
[i
].type
== SOCK_DGRAM
)
1466 ok(err
== 0, "Expected 0, got %d\n", err
);
1467 ok(k
== 1, "Expected 1, got %d\n", k
);
1471 /* contratry to what we could expect the function returns error but k is changed */
1472 ok(err
== -1, "Expected -1, got %d\n", err
);
1473 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %d\n", GetLastError());
1474 ok(k
== 0, "Expected 0, got %d\n", k
);
1478 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1479 ok(err
== 0, "Expected 0, got %d\n", err
);
1482 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1483 if (prottest
[i
].type
== SOCK_DGRAM
)
1485 ok(err
== 0, "Expected 0, got %d\n", err
);
1486 ok(k
== 0, "Expected 0, got %d\n", k
);
1490 /* contratry to what we could expect the function returns error but k is changed */
1491 ok(err
== -1, "Expected -1, got %d\n", err
);
1492 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %d\n", GetLastError());
1493 ok(k
== 0, "Expected 0, got %d\n", k
);
1500 /* Test SO_BSP_STATE - Present only in >= Win 2008 */
1501 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1502 ok(s
!= INVALID_SOCKET
, "Failed to create socket\n");
1503 s2
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1504 ok(s2
!= INVALID_SOCKET
, "Failed to create socket\n");
1506 SetLastError(0xdeadbeef);
1507 size
= sizeof(csinfoA
);
1508 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1511 struct sockaddr_in saddr
;
1512 memset(&saddr
, 0, sizeof(saddr
));
1513 saddr
.sin_family
= AF_INET
;
1514 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1516 /* Socket is not bound, no information provided */
1517 ok(!csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1518 ok(csinfoA
.cs
.LocalAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.LocalAddr
.lpSockaddr
);
1519 /* Socket is not connected, no information provided */
1520 ok(!csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.RemoteAddr
.iSockaddrLength
);
1521 ok(csinfoA
.cs
.RemoteAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.RemoteAddr
.lpSockaddr
);
1523 err
= bind(s
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1524 ok(!err
, "Expected 0, got %d\n", err
);
1525 size
= sizeof(csinfoA
);
1526 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1527 ok(!err
, "Expected 0, got %d\n", err
);
1529 /* Socket is bound */
1530 ok(csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected non-zero\n");
1531 ok(csinfoA
.cs
.LocalAddr
.lpSockaddr
!= NULL
, "Expected non-null\n");
1532 /* Socket is not connected, no information provided */
1533 ok(!csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.RemoteAddr
.iSockaddrLength
);
1534 ok(csinfoA
.cs
.RemoteAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.RemoteAddr
.lpSockaddr
);
1536 err
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1537 ok(!err
, "Expected 0, got %d\n", err
);
1538 err
= getsockname(s2
, (struct sockaddr
*)&saddr
, &size
);
1539 ok(!err
, "Expected 0, got %d\n", err
);
1540 err
= listen(s2
, 1);
1541 ok(!err
, "Expected 0, got %d\n", err
);
1542 err
= connect(s
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1543 ok(!err
, "Expected 0, got %d\n", err
);
1544 size
= sizeof(saddr
);
1545 err
= accept(s2
, (struct sockaddr
*)&saddr
, &size
);
1546 ok(err
!= INVALID_SOCKET
, "Failed to accept socket\n");
1550 size
= sizeof(csinfoA
);
1551 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1552 ok(!err
, "Expected 0, got %d\n", err
);
1553 err
= getsockopt(s2
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoB
, &size
);
1554 ok(!err
, "Expected 0, got %d\n", err
);
1555 ok(size
== sizeof(csinfoA
), "Got %d\n", size
);
1556 size
= sizeof(saddr
);
1557 ok(size
== csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected %d, got %d\n", size
,
1558 csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1559 ok(size
== csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected %d, got %d\n", size
,
1560 csinfoA
.cs
.RemoteAddr
.iSockaddrLength
);
1561 ok(!memcmp(csinfoA
.cs
.LocalAddr
.lpSockaddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
),
1562 "Expected matching addresses\n");
1563 ok(!memcmp(csinfoB
.cs
.LocalAddr
.lpSockaddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
),
1564 "Expected matching addresses\n");
1565 ok(csinfoA
.cs
.iSocketType
== SOCK_STREAM
, "Wrong socket type\n");
1566 ok(csinfoB
.cs
.iSocketType
== SOCK_STREAM
, "Wrong socket type\n");
1567 ok(csinfoA
.cs
.iProtocol
== IPPROTO_TCP
, "Wrong socket protocol\n");
1568 ok(csinfoB
.cs
.iProtocol
== IPPROTO_TCP
, "Wrong socket protocol\n");
1570 err
= getpeername(s
, (struct sockaddr
*)&saddr
, &size
);
1571 ok(!err
, "Expected 0, got %d\n", err
);
1572 ok(!memcmp(&saddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1573 ok(!memcmp(&saddr
, csinfoB
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1574 err
= getpeername(s2
, (struct sockaddr
*)&saddr
, &size
);
1575 ok(!err
, "Expected 0, got %d\n", err
);
1576 ok(!memcmp(&saddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1577 ok(!memcmp(&saddr
, csinfoA
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1578 err
= getsockname(s
, (struct sockaddr
*)&saddr
, &size
);
1579 ok(!err
, "Expected 0, got %d\n", err
);
1580 ok(!memcmp(&saddr
, csinfoA
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1581 ok(!memcmp(&saddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1582 err
= getsockname(s2
, (struct sockaddr
*)&saddr
, &size
);
1583 ok(!err
, "Expected 0, got %d\n", err
);
1584 ok(!memcmp(&saddr
, csinfoB
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1585 ok(!memcmp(&saddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1587 SetLastError(0xdeadbeef);
1588 size
= sizeof(CSADDR_INFO
);
1589 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1590 ok(err
, "Expected non-zero\n");
1591 ok(size
== sizeof(CSADDR_INFO
), "Got %d\n", size
);
1592 ok(GetLastError() == WSAEFAULT
, "Expected 10014, got %d\n", GetLastError());
1594 /* At least for IPv4 the size is exactly 56 bytes */
1595 size
= sizeof(*csinfoA
.cs
.LocalAddr
.lpSockaddr
) * 2 + sizeof(csinfoA
.cs
);
1596 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1597 ok(!err
, "Expected 0, got %d\n", err
);
1599 SetLastError(0xdeadbeef);
1600 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1601 ok(err
, "Expected non-zero\n");
1602 ok(GetLastError() == WSAEFAULT
, "Expected 10014, got %d\n", GetLastError());
1605 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %d\n", GetLastError());
1610 for (i
= 0; i
< 2; i
++)
1617 level
= IPPROTO_IPV6
;
1625 s
= socket(family
, SOCK_DGRAM
, 0);
1626 if (s
== INVALID_SOCKET
&& i
)
1628 skip("IPv6 is not supported\n");
1631 ok(s
!= INVALID_SOCKET
, "socket failed with error %d\n", GetLastError());
1633 size
= sizeof(value
);
1635 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1636 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1637 ok(value
== 0, "Expected 0, got %d\n", value
);
1639 size
= sizeof(value
);
1641 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
1642 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1645 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1646 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1647 ok(value
== 1, "Expected 1, got %d\n", value
);
1649 size
= sizeof(value
);
1651 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
1652 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1654 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1655 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1656 ok(value
== 1, "Expected 1, got %d\n", value
);
1660 s
= socket(family
, SOCK_STREAM
, 0);
1661 ok(s
!= INVALID_SOCKET
, "socket failed with error %d\n", GetLastError());
1663 size
= sizeof(value
);
1665 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1666 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1667 ok(value
== 1 || broken(value
== 0) /* < vista */, "Expected 1, got %d\n", value
);
1669 size
= sizeof(value
);
1671 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
1672 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1675 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1676 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1677 ok(value
== 0, "Expected 0, got %d\n", value
);
1681 s
= socket(family
, SOCK_RAW
, 0);
1682 if (s
== INVALID_SOCKET
)
1684 if (WSAGetLastError() == WSAEACCES
) skip("SOCK_RAW is not available\n");
1685 else if (i
) skip("IPv6 is not supported\n");
1688 ok(s
!= INVALID_SOCKET
, "socket failed with error %d\n", GetLastError());
1690 size
= sizeof(value
);
1692 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1693 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1694 ok(value
== 0, "Expected 0, got %d\n", value
);
1696 size
= sizeof(value
);
1698 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
1699 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1702 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1703 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1704 ok(value
== 1, "Expected 1, got %d\n", value
);
1710 static void test_so_reuseaddr(void)
1712 struct sockaddr_in saddr
;
1714 unsigned int rc
,reuse
;
1718 saddr
.sin_family
= AF_INET
;
1719 saddr
.sin_port
= htons(SERVERPORT
+1);
1720 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1722 s1
=socket(AF_INET
, SOCK_STREAM
, 0);
1723 ok(s1
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1724 rc
= bind(s1
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1725 ok(rc
!=SOCKET_ERROR
, "bind(s1) failed error: %d\n", WSAGetLastError());
1727 s2
=socket(AF_INET
, SOCK_STREAM
, 0);
1728 ok(s2
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1732 rc
=getsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, &size
);
1733 ok(rc
==0 && reuse
==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc
,reuse
);
1735 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1736 ok(rc
==SOCKET_ERROR
, "bind() succeeded\n");
1739 rc
= setsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
1740 ok(rc
==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1742 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1743 * a port immediately after closing another socket on that port, so
1744 * basically following the BSD socket semantics here. */
1745 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1748 int s3
=socket(AF_INET
, SOCK_STREAM
, 0), s4
;
1750 /* If we could bind again in the same port this is Windows version <= XP.
1751 * Lets test if we can really connect to one of them. */
1752 set_blocking(s1
, FALSE
);
1753 set_blocking(s2
, FALSE
);
1755 ok(!rc
, "listen() failed with error: %d\n", WSAGetLastError());
1757 ok(!rc
, "listen() failed with error: %d\n", WSAGetLastError());
1758 rc
= connect(s3
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1759 ok(!rc
, "connecting to accepting socket failed %d\n", WSAGetLastError());
1761 /* the delivery of the connection is random so we need to try on both sockets */
1762 size
= sizeof(saddr
);
1763 s4
= accept(s1
, (struct sockaddr
*)&saddr
, &size
);
1764 if(s4
== INVALID_SOCKET
)
1765 s4
= accept(s2
, (struct sockaddr
*)&saddr
, &size
);
1766 ok(s4
!= INVALID_SOCKET
, "none of the listening sockets could get the connection\n");
1774 err
= WSAGetLastError();
1775 ok(err
==WSAEACCES
, "expected 10013, got %d\n", err
);
1778 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1779 ok(rc
==0, "bind() failed error: %d\n", WSAGetLastError());
1785 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
1787 static unsigned int got_ip_pktinfo_apc
;
1789 static void WINAPI
ip_pktinfo_apc(DWORD error
, DWORD size
, OVERLAPPED
*overlapped
, DWORD flags
)
1791 ok(error
== WSAEMSGSIZE
, "got error %u\n", error
);
1792 ok(size
== 6, "got size %u\n", size
);
1793 ok(!flags
, "got flags %#x\n", flags
);
1794 ++got_ip_pktinfo_apc
;
1797 static void test_ip_pktinfo(void)
1799 ULONG addresses
[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY
)};
1800 char recvbuf
[10], pktbuf
[512], msg
[] = "HELLO";
1801 struct sockaddr_in s1addr
, s2addr
, s3addr
;
1802 GUID WSARecvMsg_GUID
= WSAID_WSARECVMSG
;
1803 LPFN_WSARECVMSG pWSARecvMsg
= NULL
;
1804 unsigned int rc
, yes
= 1;
1806 DWORD dwBytes
, dwSize
, dwFlags
;
1815 memset(&ov
, 0, sizeof(ov
));
1816 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
1818 memset(&hdr
, 0x00, sizeof(hdr
));
1819 s1addr
.sin_family
= AF_INET
;
1820 s1addr
.sin_port
= htons(0);
1821 /* Note: s1addr.sin_addr is set below */
1822 iovec
[0].buf
= recvbuf
;
1823 iovec
[0].len
= sizeof(recvbuf
);
1824 hdr
.name
= (struct sockaddr
*)&s3addr
;
1825 hdr
.namelen
= sizeof(s3addr
);
1826 hdr
.lpBuffers
= &iovec
[0];
1827 hdr
.dwBufferCount
= 1;
1828 hdr
.Control
.buf
= pktbuf
;
1829 /* Note: hdr.Control.len is set below */
1832 for (i
=0;i
<ARRAY_SIZE(addresses
);i
++)
1834 s1addr
.sin_addr
.s_addr
= addresses
[i
];
1836 /* Build "server" side socket */
1837 s1
=socket(AF_INET
, SOCK_DGRAM
, 0);
1838 ok(s1
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
1840 /* Obtain the WSARecvMsg function */
1841 rc
= WSAIoctl(s1
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSARecvMsg_GUID
, sizeof(WSARecvMsg_GUID
),
1842 &pWSARecvMsg
, sizeof(pWSARecvMsg
), &dwBytes
, NULL
, NULL
);
1843 ok(!rc
, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
1845 /* Setup the server side socket */
1846 rc
=bind(s1
, (struct sockaddr
*)&s1addr
, sizeof(s1addr
));
1847 ok(rc
!= SOCKET_ERROR
, "bind() failed error: %d\n", WSAGetLastError());
1849 /* Build "client" side socket */
1850 addrlen
= sizeof(s2addr
);
1851 rc
= getsockname(s1
, (struct sockaddr
*) &s2addr
, &addrlen
);
1852 ok(!rc
, "failed to get address, error %u\n", WSAGetLastError());
1853 s2addr
.sin_addr
.s_addr
= addresses
[0]; /* Always target the local adapter address */
1854 s2
=socket(AF_INET
, SOCK_DGRAM
, 0);
1855 ok(s2
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
1857 /* Test an empty message header */
1858 rc
=pWSARecvMsg(s1
, NULL
, NULL
, NULL
, NULL
);
1859 err
=WSAGetLastError();
1860 ok(rc
== SOCKET_ERROR
&& err
== WSAEFAULT
, "WSARecvMsg() failed error: %d (ret = %d)\n", err
, rc
);
1862 /* Test that when no control data arrives, a 0-length NULL-valued control buffer should succeed */
1863 SetLastError(0xdeadbeef);
1864 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1865 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1866 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
1867 hdr
.Control
.buf
= NULL
;
1868 hdr
.Control
.len
= 0;
1869 rc
=pWSARecvMsg(s1
, &hdr
, &dwSize
, NULL
, NULL
);
1870 ok(rc
== 0, "WSARecvMsg() failed error: %d\n", WSAGetLastError());
1871 hdr
.Control
.buf
= pktbuf
;
1873 /* Now start IP_PKTINFO for future tests */
1874 rc
=setsockopt(s1
, IPPROTO_IP
, IP_PKTINFO
, (const char*)&yes
, sizeof(yes
));
1875 ok(rc
== 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
1878 * Send a packet from the client to the server and test for specifying
1879 * a short control header.
1881 SetLastError(0xdeadbeef);
1882 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1883 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1884 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
1885 hdr
.Control
.len
= 1;
1886 dwSize
= 0xdeadbeef;
1887 rc
= pWSARecvMsg(s1
, &hdr
, &dwSize
, NULL
, NULL
);
1888 ok(rc
== -1, "expected failure\n");
1889 ok(WSAGetLastError() == WSAEMSGSIZE
, "got error %u\n", WSAGetLastError());
1890 todo_wine
ok(dwSize
== sizeof(msg
), "got size %u\n", dwSize
);
1891 ok(hdr
.dwFlags
== MSG_CTRUNC
, "got flags %#x\n", hdr
.dwFlags
);
1892 hdr
.dwFlags
= 0; /* Reset flags */
1894 /* Perform another short control header test, this time with an overlapped receive */
1895 hdr
.Control
.len
= 1;
1896 ov
.Internal
= 0xdead1;
1897 ov
.InternalHigh
= 0xdead2;
1898 ov
.Offset
= 0xdead3;
1899 ov
.OffsetHigh
= 0xdead4;
1900 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
1901 err
=WSAGetLastError();
1902 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
1903 SetLastError(0xdeadbeef);
1904 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1905 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1906 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
1907 ok(!WaitForSingleObject(ov
.hEvent
, 100), "wait failed\n");
1908 ok((NTSTATUS
)ov
.Internal
== STATUS_BUFFER_OVERFLOW
, "got status %#x\n", (NTSTATUS
)ov
.Internal
);
1909 ok(ov
.InternalHigh
== sizeof(msg
), "got size %Iu\n", ov
.InternalHigh
);
1910 ok(ov
.Offset
== 0xdead3, "got Offset %Iu\n", ov
.Offset
);
1911 ok(ov
.OffsetHigh
== 0xdead4, "got OffsetHigh %Iu\n", ov
.OffsetHigh
);
1912 dwFlags
= 0xdeadbeef;
1913 rc
= WSAGetOverlappedResult(s1
, &ov
, &dwSize
, FALSE
, &dwFlags
);
1914 ok(!rc
, "expected failure\n");
1915 ok(WSAGetLastError() == WSAEMSGSIZE
, "got error %u\n", WSAGetLastError());
1916 ok(dwSize
== sizeof(msg
), "got size %u\n", dwSize
);
1917 todo_wine
ok(dwFlags
== 0xdeadbeef, "got flags %#x\n", dwFlags
);
1918 ok(hdr
.dwFlags
== MSG_CTRUNC
,
1919 "WSARecvMsg() overlapped operation set unexpected flags %d.\n", hdr
.dwFlags
);
1920 hdr
.dwFlags
= 0; /* Reset flags */
1922 /* And with an APC. */
1924 SetLastError(0xdeadbeef);
1925 rc
= sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1926 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1927 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
1928 hdr
.Control
.len
= 1;
1930 ov
.Internal
= 0xdead1;
1931 ov
.InternalHigh
= 0xdead2;
1932 ov
.Offset
= 0xdead3;
1933 ov
.OffsetHigh
= 0xdead4;
1934 dwSize
= 0xdeadbeef;
1935 rc
= pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, ip_pktinfo_apc
);
1936 ok(rc
== -1, "expected failure\n");
1937 todo_wine
ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
1939 rc
= SleepEx(1000, TRUE
);
1940 todo_wine
ok(rc
== WAIT_IO_COMPLETION
, "got %d\n", rc
);
1941 todo_wine
ok(got_ip_pktinfo_apc
== 1, "apc was called %u times\n", got_ip_pktinfo_apc
);
1942 ok(hdr
.dwFlags
== MSG_CTRUNC
, "got flags %#x\n", hdr
.dwFlags
);
1943 got_ip_pktinfo_apc
= 0;
1945 hdr
.dwFlags
= 0; /* Reset flags */
1948 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
1949 * on the server end and check that the returned packet matches what was sent.
1951 hdr
.Control
.len
= sizeof(pktbuf
);
1952 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
1953 err
=WSAGetLastError();
1954 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
1955 ok(hdr
.Control
.len
== sizeof(pktbuf
),
1956 "WSARecvMsg() control length mismatch (%d != sizeof pktbuf).\n", hdr
.Control
.len
);
1957 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1958 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1959 ok(!WaitForSingleObject(ov
.hEvent
, 100), "wait failed\n");
1961 WSAGetOverlappedResult(s1
, &ov
, &dwSize
, FALSE
, NULL
);
1962 ok(dwSize
== sizeof(msg
),
1963 "WSARecvMsg() buffer length does not match transmitted data!\n");
1964 ok(strncmp(iovec
[0].buf
, msg
, sizeof(msg
)) == 0,
1965 "WSARecvMsg() buffer does not match transmitted data!\n");
1966 ok(hdr
.Control
.len
== IP_PKTINFO_LEN
,
1967 "WSARecvMsg() control length mismatch (%d).\n", hdr
.Control
.len
);
1969 /* Test for the expected IP_PKTINFO return information. */
1971 for (cmsg
= WSA_CMSG_FIRSTHDR(&hdr
); cmsg
!= NULL
; cmsg
= WSA_CMSG_NXTHDR(&hdr
, cmsg
))
1973 if (cmsg
->cmsg_level
== IPPROTO_IP
&& cmsg
->cmsg_type
== IP_PKTINFO
)
1975 struct in_pktinfo
*pi
= (struct in_pktinfo
*)WSA_CMSG_DATA(cmsg
);
1977 ok(pi
->ipi_addr
.s_addr
== s2addr
.sin_addr
.s_addr
, "destination ip mismatch!\n");
1981 ok(foundhdr
, "IP_PKTINFO header information was not returned!\n");
1987 CloseHandle(ov
.hEvent
);
1990 /************* Array containing the tests to run **********/
1992 #define STD_STREAM_SOCKET \
1998 static test_setup tests
[] =
2000 /* Test 0: synchronous client and server */
2021 /* Test 1: event-driven client, synchronous server */
2038 WSA_FLAG_OVERLAPPED
,
2042 /* Test 2: synchronous client, non-blocking server via select() */
2063 /* Test 3: OOB client, OOB server */
2084 /* Test 4: synchronous mixed client and server */
2098 simple_mixed_client
,
2107 static void test_UDP(void)
2109 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
2110 possible that this test fails due to dropped packets. */
2112 /* peer 0 receives data from all other peers */
2113 struct sock_info peer
[NUM_UDP_PEERS
];
2115 int ss
, i
, n_recv
, n_sent
;
2117 memset (buf
,0,sizeof(buf
));
2118 for ( i
= NUM_UDP_PEERS
- 1; i
>= 0; i
-- ) {
2119 ok ( ( peer
[i
].s
= socket ( AF_INET
, SOCK_DGRAM
, 0 ) ) != INVALID_SOCKET
, "UDP: socket failed\n" );
2121 peer
[i
].addr
.sin_family
= AF_INET
;
2122 peer
[i
].addr
.sin_addr
.s_addr
= inet_addr ( SERVERIP
);
2125 peer
[i
].addr
.sin_port
= htons ( SERVERPORT
);
2127 peer
[i
].addr
.sin_port
= htons ( 0 );
2130 do_bind ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, sizeof( peer
[i
].addr
) );
2132 /* test getsockname() to get peer's port */
2133 ss
= sizeof ( peer
[i
].addr
);
2134 ok ( getsockname ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, &ss
) != SOCKET_ERROR
, "UDP: could not getsockname()\n" );
2135 ok ( peer
[i
].addr
.sin_port
!= htons ( 0 ), "UDP: bind() did not associate port\n" );
2138 /* test getsockname() */
2139 ok ( peer
[0].addr
.sin_port
== htons ( SERVERPORT
), "UDP: getsockname returned incorrect peer port\n" );
2141 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
2142 /* send client's ip */
2143 memcpy( buf
, &peer
[i
].addr
.sin_port
, sizeof(peer
[i
].addr
.sin_port
) );
2144 n_sent
= sendto ( peer
[i
].s
, buf
, sizeof(buf
), 0, (struct sockaddr
*) &peer
[0].addr
, sizeof(peer
[0].addr
) );
2145 ok ( n_sent
== sizeof(buf
), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent
);
2148 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
2149 n_recv
= recvfrom ( peer
[0].s
, buf
, sizeof(buf
), 0,(struct sockaddr
*) &peer
[0].peer
, &ss
);
2150 ok ( n_recv
== sizeof(buf
), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv
);
2151 ok ( memcmp ( &peer
[0].peer
.sin_port
, buf
, sizeof(peer
[0].addr
.sin_port
) ) == 0, "UDP: port numbers do not match\n" );
2155 static void test_WSASocket(void)
2157 SOCKET sock
= INVALID_SOCKET
;
2158 WSAPROTOCOL_INFOA
*pi
;
2159 int wsaproviders
[] = {IPPROTO_TCP
, IPPROTO_IP
};
2160 int autoprotocols
[] = {IPPROTO_TCP
, IPPROTO_UDP
};
2161 int items
, err
, size
, socktype
, i
, j
;
2166 int family
, type
, protocol
;
2168 int ret_family
, ret_type
, ret_protocol
;
2173 {0xdead, SOCK_STREAM
, IPPROTO_TCP
, WSAEAFNOSUPPORT
},
2174 {-1, SOCK_STREAM
, IPPROTO_TCP
, WSAEAFNOSUPPORT
},
2175 {AF_INET
, 0xdead, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
2176 {AF_INET
, -1, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
2177 {AF_INET
, SOCK_STREAM
, 0xdead, WSAEPROTONOSUPPORT
},
2178 {AF_INET
, SOCK_STREAM
, -1, WSAEPROTONOSUPPORT
},
2179 {0xdead, 0xdead, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
2180 {0xdead, SOCK_STREAM
, 0xdead, WSAEAFNOSUPPORT
},
2181 {AF_INET
, 0xdead, 0xdead, WSAESOCKTNOSUPPORT
},
2182 {0xdead, SOCK_STREAM
, IPPROTO_UDP
, WSAEAFNOSUPPORT
},
2185 {AF_INET
, SOCK_STREAM
, 0, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
2186 {AF_INET
, SOCK_DGRAM
, 0, 0, AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
2187 {AF_INET
, 0xdead, 0, WSAESOCKTNOSUPPORT
},
2188 {AF_INET
, 0, IPPROTO_TCP
, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
2189 {AF_INET
, 0, IPPROTO_UDP
, 0, AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
2190 {AF_INET
, 0, 0xdead, WSAEPROTONOSUPPORT
},
2191 {AF_INET
, 0, 0, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
2192 {AF_INET
, SOCK_STREAM
, IPPROTO_UDP
, WSAEPROTONOSUPPORT
},
2193 {AF_INET
, SOCK_DGRAM
, IPPROTO_TCP
, WSAEPROTONOSUPPORT
},
2196 {AF_UNSPEC
, SOCK_STREAM
, IPPROTO_TCP
, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
2197 {AF_UNSPEC
, SOCK_STREAM
, 0xdead, WSAEPROTONOSUPPORT
},
2198 {AF_UNSPEC
, 0xdead, IPPROTO_UDP
, WSAESOCKTNOSUPPORT
},
2199 {AF_UNSPEC
, SOCK_STREAM
, 0, WSAEINVAL
},
2200 {AF_UNSPEC
, SOCK_DGRAM
, 0, WSAEINVAL
},
2201 {AF_UNSPEC
, 0xdead, 0, WSAEINVAL
},
2202 {AF_UNSPEC
, 0, IPPROTO_TCP
, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
2203 {AF_UNSPEC
, 0, IPPROTO_UDP
, 0, AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
2204 {AF_UNSPEC
, 0, 0xdead, WSAEPROTONOSUPPORT
},
2205 {AF_UNSPEC
, 0, 0, WSAEINVAL
},
2208 for (i
= 0; i
< ARRAY_SIZE(tests
); ++i
)
2210 SetLastError( 0xdeadbeef );
2211 sock
= WSASocketA( tests
[i
].family
, tests
[i
].type
, tests
[i
].protocol
, NULL
, 0, 0 );
2212 todo_wine_if (!tests
[i
].error
|| i
== 7)
2213 ok(WSAGetLastError() == tests
[i
].error
, "Test %u: got wrong error %u\n", i
, WSAGetLastError());
2216 ok(sock
== INVALID_SOCKET
, "Test %u: expected failure\n", i
);
2220 WSAPROTOCOL_INFOA info
;
2222 ok(sock
!= INVALID_SOCKET
, "Text %u: expected success\n", i
);
2224 size
= sizeof(info
);
2225 err
= getsockopt( sock
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *)&info
, &size
);
2226 ok(!err
, "Test %u: getsockopt failed, error %u\n", i
, WSAGetLastError());
2227 ok(info
.iAddressFamily
== tests
[i
].ret_family
, "Test %u: got wrong family %d\n", i
, info
.iAddressFamily
);
2228 ok(info
.iSocketType
== tests
[i
].ret_type
, "Test %u: got wrong type %d\n", i
, info
.iSocketType
);
2229 ok(info
.iProtocol
== tests
[i
].ret_protocol
, "Test %u: got wrong protocol %d\n", i
, info
.iProtocol
);
2231 closesocket( sock
);
2235 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
2236 * to avoid a crash on win98.
2239 items
= WSAEnumProtocolsA(wsaproviders
, NULL
, &pi_size
);
2240 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
2242 err
= WSAGetLastError();
2243 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2246 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
2247 ok(pi
!= NULL
, "Failed to allocate memory\n");
2249 items
= WSAEnumProtocolsA(wsaproviders
, pi
, &pi_size
);
2250 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
2254 skip("No protocols enumerated.\n");
2255 HeapFree(GetProcessHeap(), 0, pi
);
2259 sock
= WSASocketA(FROM_PROTOCOL_INFO
, FROM_PROTOCOL_INFO
,
2260 FROM_PROTOCOL_INFO
, &pi
[0], 0, 0);
2261 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2265 /* find what parameters are used first: plain parameters or protocol info struct */
2266 pi
[0].iProtocol
= -1;
2267 pi
[0].iSocketType
= -1;
2268 pi
[0].iAddressFamily
= -1;
2269 ok(WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0) == INVALID_SOCKET
,
2270 "WSASocketA should have failed\n");
2271 err
= WSAGetLastError();
2272 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
2274 pi
[0].iProtocol
= 0;
2275 pi
[0].iSocketType
= 0;
2276 pi
[0].iAddressFamily
= 0;
2277 sock
= WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0);
2278 if(sock
!= INVALID_SOCKET
)
2280 win_skip("must work only in OS <= 2003\n");
2285 err
= WSAGetLastError();
2286 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
2289 pi
[0].iProtocol
= IPPROTO_UDP
;
2290 pi
[0].iSocketType
= SOCK_DGRAM
;
2291 pi
[0].iAddressFamily
= AF_INET
;
2292 sock
= WSASocketA(0, 0, 0, &pi
[0], 0, 0);
2293 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2296 size
= sizeof(socktype
);
2298 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2299 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2300 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2301 SOCK_DGRAM
, socktype
);
2303 socktype
= SOCK_STREAM
;
2304 WSASetLastError(0xdeadbeef);
2305 err
= setsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *)&socktype
, sizeof(socktype
));
2306 ok(err
== -1, "expected failure\n");
2307 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
2309 socktype
= SOCK_DGRAM
;
2310 WSASetLastError(0xdeadbeef);
2311 err
= setsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *)&socktype
, sizeof(socktype
));
2312 ok(err
== -1, "expected failure\n");
2313 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
2317 sock
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, &pi
[0], 0, 0);
2318 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2321 size
= sizeof(socktype
);
2323 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2324 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2325 ok(socktype
== SOCK_STREAM
, "Wrong socket type, expected %d received %d\n",
2326 SOCK_STREAM
, socktype
);
2328 socktype
= SOCK_STREAM
;
2329 WSASetLastError(0xdeadbeef);
2330 err
= setsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *)&socktype
, sizeof(socktype
));
2331 ok(err
== -1, "expected failure\n");
2332 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
2334 socktype
= SOCK_DGRAM
;
2335 WSASetLastError(0xdeadbeef);
2336 err
= setsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *)&socktype
, sizeof(socktype
));
2337 ok(err
== -1, "expected failure\n");
2338 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
2342 HeapFree(GetProcessHeap(), 0, pi
);
2345 items
= WSAEnumProtocolsA(NULL
, NULL
, &pi_size
);
2346 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
2348 err
= WSAGetLastError();
2349 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2352 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
2353 ok(pi
!= NULL
, "Failed to allocate memory\n");
2355 items
= WSAEnumProtocolsA(NULL
, pi
, &pi_size
);
2356 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
2359 /* when no protocol and socket type are specified the first entry
2360 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
2362 sock
= WSASocketA(AF_INET
, 0, 0, NULL
, 0, 0);
2363 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2366 size
= sizeof(socktype
);
2368 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2369 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2370 for(i
= 0; i
< items
; i
++)
2372 if(pi
[i
].dwProviderFlags
& PFL_MATCHES_PROTOCOL_ZERO
)
2374 ok(socktype
== pi
[i
].iSocketType
, "Wrong socket type, expected %d received %d\n",
2375 pi
[i
].iSocketType
, socktype
);
2379 ok(i
!= items
, "Creating a socket without protocol and socket type didn't work\n");
2382 /* when no socket type is specified the first entry from WSAEnumProtocols
2383 * that matches the protocol is returned */
2384 for (i
= 0; i
< ARRAY_SIZE(autoprotocols
); i
++)
2386 sock
= WSASocketA(0, 0, autoprotocols
[i
], NULL
, 0, 0);
2387 ok(sock
!= INVALID_SOCKET
, "Failed to create socket for protocol %d, received %d\n",
2388 autoprotocols
[i
], WSAGetLastError());
2390 size
= sizeof(socktype
);
2392 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2393 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2395 for (err
= 1, j
= 0; j
< items
; j
++)
2397 if (pi
[j
].iProtocol
== autoprotocols
[i
])
2399 ok(pi
[j
].iSocketType
== socktype
, "expected %d, got %d\n", socktype
, pi
[j
].iSocketType
);
2404 ok(!err
, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols
[i
]);
2409 HeapFree(GetProcessHeap(), 0, pi
);
2411 SetLastError(0xdeadbeef);
2412 /* starting on vista the socket function returns error during the socket
2413 creation and no longer in the socket operations (sendto, readfrom) */
2414 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_ICMP
, NULL
, 0, 0);
2415 if (sock
== INVALID_SOCKET
)
2417 err
= WSAGetLastError();
2418 ok(err
== WSAEACCES
, "Expected 10013, received %d\n", err
);
2419 skip("SOCK_RAW is not supported\n");
2423 size
= sizeof(socktype
);
2425 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2426 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2427 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2428 SOCK_RAW
, socktype
);
2431 sock
= WSASocketA(0, 0, IPPROTO_RAW
, NULL
, 0, 0);
2432 if (sock
!= INVALID_SOCKET
)
2435 size
= sizeof(socktype
);
2437 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2438 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2439 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2440 SOCK_RAW
, socktype
);
2444 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_TCP
, NULL
, 0, 0);
2445 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2447 size
= sizeof(socktype
);
2449 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2450 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2451 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2452 SOCK_RAW
, socktype
);
2455 else if (WSAGetLastError() == WSAEACCES
)
2456 skip("SOCK_RAW is not available\n");
2458 ok(0, "Failed to create socket: %d\n", WSAGetLastError());
2462 /* IPX socket tests */
2464 SetLastError(0xdeadbeef);
2465 sock
= WSASocketA(AF_IPX
, SOCK_DGRAM
, NSPROTO_IPX
, NULL
, 0, 0);
2466 if (sock
== INVALID_SOCKET
)
2468 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "got error %u\n", WSAGetLastError());
2469 skip("IPX is not supported\n");
2473 WSAPROTOCOL_INFOA info
;
2476 sock
= WSASocketA(0, 0, NSPROTO_IPX
, NULL
, 0, 0);
2477 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2480 size
= sizeof(socktype
);
2482 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2483 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2484 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2485 SOCK_DGRAM
, socktype
);
2487 /* check socket family, type and protocol */
2488 size
= sizeof(WSAPROTOCOL_INFOA
);
2489 err
= getsockopt(sock
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &info
, &size
);
2490 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2491 ok(info
.iProtocol
== NSPROTO_IPX
, "expected protocol %d, received %d\n",
2492 NSPROTO_IPX
, info
.iProtocol
);
2493 ok(info
.iAddressFamily
== AF_IPX
, "expected family %d, received %d\n",
2494 AF_IPX
, info
.iProtocol
);
2495 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
2496 SOCK_DGRAM
, info
.iSocketType
);
2499 /* SOCK_STREAM does not support NSPROTO_IPX */
2500 SetLastError(0xdeadbeef);
2501 ok(WSASocketA(AF_IPX
, SOCK_STREAM
, NSPROTO_IPX
, NULL
, 0, 0) == INVALID_SOCKET
,
2502 "WSASocketA should have failed\n");
2503 err
= WSAGetLastError();
2504 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2506 /* test extended IPX support - that is adding any number between 0 and 255
2507 * to the IPX protocol value will make it be used as IPX packet type */
2508 for(i
= 0;i
<= 255;i
+= 17)
2510 SetLastError(0xdeadbeef);
2511 sock
= WSASocketA(0, 0, NSPROTO_IPX
+ i
, NULL
, 0, 0);
2512 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2517 err
= getsockopt(sock
, NSPROTO_IPX
, IPX_PTYPE
, (char *) &socktype
, &size
);
2518 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2519 ok(socktype
== i
, "Wrong IPX packet type, expected %d received %d\n",
2527 static void test_WSADuplicateSocket(void)
2529 SOCKET source
, dupsock
;
2530 WSAPROTOCOL_INFOA info
;
2532 struct sockaddr_in addr
;
2533 int socktype
, size
, addrsize
, ret
;
2534 char teststr
[] = "TEST", buffer
[16];
2536 source
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
2537 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2539 /* test invalid parameters */
2540 SetLastError(0xdeadbeef);
2541 ok(WSADuplicateSocketA(0, 0, NULL
), "WSADuplicateSocketA should have failed\n");
2542 err
= WSAGetLastError();
2543 ok(err
== WSAENOTSOCK
, "expected 10038, received %d\n", err
);
2545 SetLastError(0xdeadbeef);
2546 ok(WSADuplicateSocketA(source
, 0, NULL
),
2547 "WSADuplicateSocketA should have failed\n");
2548 err
= WSAGetLastError();
2549 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2551 SetLastError(0xdeadbeef);
2552 ok(WSADuplicateSocketA(source
, ~0, &info
),
2553 "WSADuplicateSocketA should have failed\n");
2554 err
= WSAGetLastError();
2555 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2557 SetLastError(0xdeadbeef);
2558 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info
),
2559 "WSADuplicateSocketA should have failed\n");
2560 err
= WSAGetLastError();
2561 ok(err
== WSAENOTSOCK
, "expected 10038, received %d\n", err
);
2563 SetLastError(0xdeadbeef);
2564 ok(WSADuplicateSocketA(source
, GetCurrentProcessId(), NULL
),
2565 "WSADuplicateSocketA should have failed\n");
2566 err
= WSAGetLastError();
2567 ok(err
== WSAEFAULT
, "expected 10014, received %d\n", err
);
2569 /* test returned structure */
2570 memset(&info
, 0, sizeof(info
));
2571 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2572 "WSADuplicateSocketA should have worked\n");
2574 ok(info
.iProtocol
== IPPROTO_TCP
, "expected protocol %d, received %d\n",
2575 IPPROTO_TCP
, info
.iProtocol
);
2576 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
2577 AF_INET
, info
.iProtocol
);
2578 ok(info
.iSocketType
== SOCK_STREAM
, "expected type %d, received %d\n",
2579 SOCK_STREAM
, info
.iSocketType
);
2581 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2582 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2584 closesocket(dupsock
);
2585 closesocket(source
);
2587 /* create a socket, bind it, duplicate it then send data on source and
2588 * receive in the duplicated socket */
2589 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
2590 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2592 memset(&info
, 0, sizeof(info
));
2593 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2594 "WSADuplicateSocketA should have worked\n");
2596 ok(info
.iProtocol
== IPPROTO_UDP
, "expected protocol %d, received %d\n",
2597 IPPROTO_UDP
, info
.iProtocol
);
2598 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
2599 AF_INET
, info
.iProtocol
);
2600 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
2601 SOCK_DGRAM
, info
.iSocketType
);
2603 memset(&addr
, 0, sizeof(addr
));
2604 addr
.sin_family
= AF_INET
;
2605 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2606 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
2607 "bind should have worked\n");
2609 /* read address to find out the port number to be used in sendto */
2610 memset(&addr
, 0, sizeof(addr
));
2611 addrsize
= sizeof(addr
);
2612 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
2613 "getsockname should have worked\n");
2614 ok(addr
.sin_port
, "socket port should be != 0\n");
2616 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2617 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2620 ret
= getsockopt(dupsock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2621 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
2622 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2623 SOCK_DGRAM
, socktype
);
2625 set_blocking(source
, TRUE
);
2627 /* send data on source socket */
2628 addrsize
= sizeof(addr
);
2629 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
2630 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2632 /* receive on duplicated socket */
2633 addrsize
= sizeof(addr
);
2634 memset(buffer
, 0, sizeof(buffer
));
2635 size
= recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
);
2636 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2637 buffer
[sizeof(teststr
) - 1] = 0;
2638 ok(!strcmp(buffer
, teststr
), "expected '%s', received '%s'\n", teststr
, buffer
);
2640 closesocket(dupsock
);
2641 closesocket(source
);
2643 /* show that the source socket need to be bound before the duplicated
2644 * socket is created */
2645 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
2646 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2648 memset(&info
, 0, sizeof(info
));
2649 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2650 "WSADuplicateSocketA should have worked\n");
2652 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2653 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2655 memset(&addr
, 0, sizeof(addr
));
2656 addr
.sin_family
= AF_INET
;
2657 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2658 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
2659 "bind should have worked\n");
2661 /* read address to find out the port number to be used in sendto */
2662 memset(&addr
, 0, sizeof(addr
));
2663 addrsize
= sizeof(addr
);
2664 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
2665 "getsockname should have worked\n");
2666 ok(addr
.sin_port
, "socket port should be != 0\n");
2668 set_blocking(source
, TRUE
);
2670 addrsize
= sizeof(addr
);
2671 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
2672 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2674 SetLastError(0xdeadbeef);
2675 addrsize
= sizeof(addr
);
2676 memset(buffer
, 0, sizeof(buffer
));
2678 ok(recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
) == -1,
2679 "recvfrom should have failed\n");
2680 err
= WSAGetLastError();
2681 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2684 closesocket(dupsock
);
2685 closesocket(source
);
2688 static void test_WSAEnumNetworkEvents(void)
2691 int sock_type
[] = {SOCK_STREAM
, SOCK_DGRAM
, SOCK_STREAM
}, i
, j
, k
, l
;
2692 struct sockaddr_in address
;
2694 WSANETWORKEVENTS net_events
;
2696 memset(&address
, 0, sizeof(address
));
2697 address
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
2698 address
.sin_family
= AF_INET
;
2700 /* This test follows the steps from bugs 10204 and 24946 */
2701 for (l
= 0; l
< 2; l
++)
2703 for (i
= 0; i
< ARRAY_SIZE(sock_type
); i
++)
2706 tcp_socketpair(&s
, &s2
);
2709 s
= socket(AF_INET
, sock_type
[i
], 0);
2710 ok (s
!= SOCKET_ERROR
, "Test[%d]: failed to create socket\n", i
);
2711 ok (!bind(s
, (struct sockaddr
*) &address
, sizeof(address
)), "Test[%d]: bind failed\n", i
);
2713 event
= WSACreateEvent();
2714 ok (event
!= NULL
, "Test[%d]: failed to create event\n", i
);
2715 for (j
= 0; j
< 5; j
++) /* Repeat sometimes and the result must be the same */
2717 /* When the TCP socket is not connected NO events will be returned.
2718 * When connected and no data pending it will get the write event.
2719 * UDP sockets don't have connections so as soon as they are bound
2720 * they can read/write data. Since nobody is sendind us data only
2721 * the write event will be returned and ONLY once.
2723 ok (!WSAEventSelect(s
, event
, FD_READ
| FD_WRITE
), "Test[%d]: WSAEventSelect failed\n", i
);
2724 memset(&net_events
, 0xAB, sizeof(net_events
));
2725 ok (!WSAEnumNetworkEvents(s
, l
== 0 ? event
: NULL
, &net_events
),
2726 "Test[%d]: WSAEnumNetworkEvents failed\n", i
);
2727 if (i
>= 1 && j
== 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
2729 ok (net_events
.lNetworkEvents
== FD_WRITE
, "Test[%d]: expected 2, got %d\n",
2730 i
, net_events
.lNetworkEvents
);
2734 ok (net_events
.lNetworkEvents
== 0, "Test[%d]: expected 0, got %d\n",
2735 i
, net_events
.lNetworkEvents
);
2737 for (k
= 0; k
< FD_MAX_EVENTS
; k
++)
2739 if (net_events
.lNetworkEvents
& (1 << k
))
2741 ok (net_events
.iErrorCode
[k
] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
2742 i
, k
, net_events
.iErrorCode
[k
]);
2746 /* Bits that are not set in lNetworkEvents MUST not be changed */
2747 ok (net_events
.iErrorCode
[k
] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
2748 i
, k
, net_events
.iErrorCode
[k
]);
2753 WSACloseEvent(event
);
2754 if (i
== 2) closesocket(s2
);
2759 static DWORD WINAPI
SelectReadThread(void *param
)
2761 select_thread_params
*par
= param
;
2764 struct sockaddr_in addr
;
2765 struct timeval select_timeout
;
2768 FD_SET(par
->s
, &readfds
);
2769 select_timeout
.tv_sec
=5;
2770 select_timeout
.tv_usec
=0;
2771 addr
.sin_family
= AF_INET
;
2772 addr
.sin_addr
.s_addr
= inet_addr(SERVERIP
);
2773 addr
.sin_port
= htons(SERVERPORT
);
2775 do_bind(par
->s
, (struct sockaddr
*)&addr
, sizeof(addr
));
2776 wsa_ok(listen(par
->s
, SOMAXCONN
), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
2778 SetEvent(server_ready
);
2779 ret
= select(par
->s
+1, &readfds
, NULL
, NULL
, &select_timeout
);
2780 par
->ReadKilled
= (ret
== 1);
2785 static DWORD WINAPI
SelectCloseThread(void *param
)
2787 SOCKET s
= *(SOCKET
*)param
;
2793 static void test_errors(void)
2796 SOCKADDR_IN SockAddr
;
2799 WSASetLastError(NO_ERROR
);
2800 sock
= socket(PF_INET
, SOCK_STREAM
, 0);
2801 ok( (sock
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2802 memset(&SockAddr
, 0, sizeof(SockAddr
));
2803 SockAddr
.sin_family
= AF_INET
;
2804 SockAddr
.sin_port
= htons(6924);
2805 SockAddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2807 ret
= connect(sock
, (PSOCKADDR
)&SockAddr
, sizeof(SockAddr
));
2808 ok( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got: %d\n", ret
);
2809 if (ret
== SOCKET_ERROR
)
2811 err
= WSAGetLastError();
2812 ok( (err
== WSAECONNREFUSED
), "expected WSAECONNREFUSED, got: %d\n", err
);
2817 fd_set set
= {1, {sock
}};
2820 timeval
.tv_usec
= 50000;
2822 ret
= select(1, NULL
, &set
, NULL
, &timeval
);
2823 ok( (ret
== 0), "expected 0 (timeout), got: %d\n", ret
);
2826 ret
= closesocket(sock
);
2827 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
2830 static void test_listen(void)
2833 int ret
, acceptc
, olen
= sizeof(acceptc
);
2834 struct sockaddr_in address
;
2836 memset(&address
, 0, sizeof(address
));
2837 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2838 address
.sin_family
= AF_INET
;
2839 address
.sin_port
= htons(SERVERPORT
);
2841 /* invalid socket tests */
2842 SetLastError(0xdeadbeef);
2843 ok ((listen(0, 0) == SOCKET_ERROR
), "listen did not fail\n");
2844 ret
= WSAGetLastError();
2845 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
2847 SetLastError(0xdeadbeef);
2848 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR
), "listen did not fail\n");
2849 ret
= WSAGetLastError();
2850 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
2853 fdA
= socket(AF_INET
, SOCK_STREAM
, 0);
2854 ok ((fdA
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2856 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
2857 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2859 SetLastError(0xdeadbeef);
2860 ok ((listen(fdA
, -2) == SOCKET_ERROR
), "listen did not fail\n");
2861 ret
= WSAGetLastError();
2862 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
2864 SetLastError(0xdeadbeef);
2865 ok ((listen(fdA
, 1) == SOCKET_ERROR
), "listen did not fail\n");
2866 ret
= WSAGetLastError();
2867 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
2869 SetLastError(0xdeadbeef);
2870 ok ((listen(fdA
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
2871 ret
= WSAGetLastError();
2872 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
2874 ok (!bind(fdA
, (struct sockaddr
*) &address
, sizeof(address
)), "bind failed\n");
2876 SetLastError(0xdeadbeef);
2877 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
2878 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
2881 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
2882 ok (!ret
, "getsockopt failed\n");
2883 ok (acceptc
== 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc
);
2886 WSASetLastError(0xdeadbeef);
2887 ret
= setsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char *)&acceptc
, sizeof(acceptc
));
2888 ok(ret
== -1, "expected failure\n");
2889 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
2892 WSASetLastError(0xdeadbeef);
2893 ret
= setsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char *)&acceptc
, sizeof(acceptc
));
2894 ok(ret
== -1, "expected failure\n");
2895 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
2897 ok (!listen(fdA
, 0), "listen failed\n");
2898 ok (!listen(fdA
, SOMAXCONN
), "double listen failed\n");
2901 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
2902 ok (!ret
, "getsockopt failed\n");
2903 ok (acceptc
== 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc
);
2906 WSASetLastError(0xdeadbeef);
2907 ret
= setsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char *)&acceptc
, sizeof(acceptc
));
2908 ok(ret
== -1, "expected failure\n");
2909 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
2912 WSASetLastError(0xdeadbeef);
2913 ret
= setsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char *)&acceptc
, sizeof(acceptc
));
2914 ok(ret
== -1, "expected failure\n");
2915 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
2917 SetLastError(0xdeadbeef);
2918 ok ((listen(fdB
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
2919 ret
= WSAGetLastError();
2920 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
2922 ret
= closesocket(fdB
);
2923 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
2925 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
2926 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2928 SetLastError(0xdeadbeef);
2929 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
2930 ret
= WSAGetLastError();
2931 ok (ret
== WSAEADDRINUSE
, "expected 10048, received %d\n", ret
);
2933 ret
= closesocket(fdA
);
2934 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
2935 ret
= closesocket(fdB
);
2936 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
2939 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
2940 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
2941 static void test_select(void)
2943 static char tmp_buf
[1024];
2945 SOCKET fdListen
, fdRead
, fdWrite
;
2946 fd_set readfds
, writefds
, exceptfds
;
2950 struct timeval select_timeout
;
2951 struct sockaddr_in address
;
2952 select_thread_params thread_params
;
2953 HANDLE thread_handle
;
2956 fdRead
= socket(AF_INET
, SOCK_STREAM
, 0);
2957 ok( (fdRead
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2958 fdWrite
= socket(AF_INET
, SOCK_STREAM
, 0);
2959 ok( (fdWrite
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2962 if (fdWrite
> maxfd
)
2967 FD_SET_ALL(fdWrite
);
2968 select_timeout
.tv_sec
=0;
2969 select_timeout
.tv_usec
=0;
2971 ticks
= GetTickCount();
2972 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2973 ticks
= GetTickCount() - ticks
;
2974 ok(ret
== 0, "select should not return any socket handles\n");
2975 ok(ticks
< 10, "select was blocking for %u ms, expected < 10 ms\n", ticks
);
2976 ok(!FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
2977 ok(!FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
2978 ok(!FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
2979 ok(!FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
2983 FD_SET_ALL(fdWrite
);
2984 select_timeout
.tv_sec
=0;
2985 select_timeout
.tv_usec
=500;
2987 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2988 ok(ret
== 0, "select should not return any socket handles\n");
2989 ok(!FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
2990 ok(!FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
2991 ok(!FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
2992 ok(!FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
2994 ok ((listen(fdWrite
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
2995 ret
= closesocket(fdWrite
);
2996 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
2998 thread_params
.s
= fdRead
;
2999 thread_params
.ReadKilled
= FALSE
;
3000 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
3001 thread_handle
= CreateThread (NULL
, 0, SelectReadThread
, &thread_params
, 0, &id
);
3002 ok ( (thread_handle
!= NULL
), "CreateThread failed unexpectedly: %d\n", GetLastError());
3004 WaitForSingleObject (server_ready
, INFINITE
);
3006 ret
= closesocket(fdRead
);
3007 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
3009 WaitForSingleObject (thread_handle
, 1000);
3010 ok ( thread_params
.ReadKilled
, "closesocket did not wake up select\n");
3011 ret
= recv(fdRead
, &buffer
, 1, MSG_PEEK
);
3012 ok( (ret
== -1), "peek at closed socket expected -1 got %d\n", ret
);
3014 /* Test selecting invalid handles */
3018 ret
= select(maxfd
+1, 0, 0, 0, &select_timeout
);
3019 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3020 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3023 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3024 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3025 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3027 FD_SET(INVALID_SOCKET
, &readfds
);
3029 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3030 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3031 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3032 ok ( !FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
3035 FD_SET(INVALID_SOCKET
, &writefds
);
3037 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3038 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3039 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3040 ok ( !FD_ISSET(fdRead
, &writefds
), "FD should not be set\n");
3043 FD_SET(INVALID_SOCKET
, &exceptfds
);
3045 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3046 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3047 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3048 ok ( !FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
3050 tcp_socketpair(&fdRead
, &fdWrite
);
3052 if(fdWrite
> maxfd
) maxfd
= fdWrite
;
3055 FD_SET(fdRead
, &readfds
);
3056 ret
= select(fdRead
+1, &readfds
, NULL
, NULL
, &select_timeout
);
3057 ok(!ret
, "select returned %d\n", ret
);
3060 FD_SET(fdWrite
, &writefds
);
3061 ret
= select(fdWrite
+1, NULL
, &writefds
, NULL
, &select_timeout
);
3062 ok(ret
== 1, "select returned %d\n", ret
);
3063 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
3065 /* tests for overlapping fd_set pointers */
3067 FD_SET(fdWrite
, &readfds
);
3068 ret
= select(fdWrite
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3069 ok(ret
== 1, "select returned %d\n", ret
);
3070 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3073 FD_SET(fdWrite
, &readfds
);
3074 FD_SET(fdRead
, &readfds
);
3075 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3076 ok(ret
== 2, "select returned %d\n", ret
);
3077 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3078 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3080 ok(send(fdWrite
, "test", 4, 0) == 4, "failed to send data\n");
3082 FD_SET(fdRead
, &readfds
);
3083 ret
= select(fdRead
+1, &readfds
, NULL
, NULL
, &select_timeout
);
3084 ok(ret
== 1, "select returned %d\n", ret
);
3085 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3088 FD_SET(fdWrite
, &readfds
);
3089 FD_SET(fdRead
, &readfds
);
3090 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3091 ok(ret
== 2, "select returned %d\n", ret
);
3092 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3093 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3097 FD_SET(fdWrite
, &writefds
);
3098 ret
= select(fdWrite
+1, NULL
, &writefds
, NULL
, &select_timeout
);
3100 ok(send(fdWrite
, tmp_buf
, sizeof(tmp_buf
), 0) > 0, "failed to send data\n");
3103 FD_SET(fdWrite
, &readfds
);
3104 FD_SET(fdRead
, &readfds
);
3105 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3106 ok(ret
== 1, "select returned %d\n", ret
);
3107 ok(!FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is in the set\n");
3108 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3110 ok(send(fdRead
, "test", 4, 0) == 4, "failed to send data\n");
3113 FD_SET(fdWrite
, &readfds
);
3114 FD_SET(fdRead
, &readfds
);
3115 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3116 ok(ret
== 2, "select returned %d\n", ret
);
3117 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3118 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3120 closesocket(fdRead
);
3121 closesocket(fdWrite
);
3123 /* select() works in 3 distinct states:
3124 * - to check if a connection attempt ended with success or error;
3125 * - to check if a pending connection is waiting for acceptance;
3126 * - to check for data to read, availability for write and OOB data
3128 * The tests below ensure that all conditions are tested.
3130 memset(&address
, 0, sizeof(address
));
3131 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3132 address
.sin_family
= AF_INET
;
3133 len
= sizeof(address
);
3134 fdListen
= setup_server_socket(&address
, &len
);
3135 select_timeout
.tv_sec
= 1;
3136 select_timeout
.tv_usec
= 250000;
3138 /* When no events are pending select returns 0 with no error */
3140 FD_SET_ALL(fdListen
);
3141 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3142 ok(ret
== 0, "expected 0, got %d\n", ret
);
3144 /* When a socket is attempting to connect the listening socket receives the read descriptor */
3145 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
3147 FD_SET_ALL(fdListen
);
3148 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3149 ok(ret
== 1, "expected 1, got %d\n", ret
);
3150 ok(FD_ISSET(fdListen
, &readfds
), "fdListen socket is not in the set\n");
3151 len
= sizeof(address
);
3152 fdRead
= accept(fdListen
, (struct sockaddr
*) &address
, &len
);
3153 ok(fdRead
!= INVALID_SOCKET
, "expected a valid socket\n");
3155 /* The connector is signaled through the write descriptor */
3157 FD_SET_ALL(fdListen
);
3159 FD_SET_ALL(fdWrite
);
3160 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3161 ok(ret
== 2, "expected 2, got %d\n", ret
);
3162 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
3163 ok(FD_ISSET(fdRead
, &writefds
), "fdRead socket is not in the set\n");
3166 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
3167 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
3168 ok(id
== 0, "expected 0, got %d\n", id
);
3170 /* When data is received the receiver gets the read descriptor */
3171 ret
= send(fdWrite
, "1234", 4, 0);
3172 ok(ret
== 4, "expected 4, got %d\n", ret
);
3174 FD_SET_ALL(fdListen
);
3175 FD_SET(fdRead
, &readfds
);
3176 FD_SET(fdRead
, &exceptfds
);
3177 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3178 ok(ret
== 1, "expected 1, got %d\n", ret
);
3179 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3180 ok(!FD_ISSET(fdRead
, &exceptfds
), "fdRead socket is in the set\n");
3183 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3184 ok(ret
== 2, "expected 1, got %d\n", ret
);
3185 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3186 ok(FD_ISSET(fdRead
, &writefds
), "fdRead socket is not in the set\n");
3187 ok(!FD_ISSET(fdRead
, &exceptfds
), "fdRead socket is in the set\n");
3188 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
3189 ok(ret
== 4, "expected 4, got %d\n", ret
);
3190 ok(!strcmp(tmp_buf
, "1234"), "data received differs from sent\n");
3192 /* When OOB data is received the socket is set in the except descriptor */
3193 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
3194 ok(ret
== 1, "expected 1, got %d\n", ret
);
3196 FD_SET_ALL(fdListen
);
3197 FD_SET(fdRead
, &readfds
);
3198 FD_SET(fdRead
, &exceptfds
);
3199 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3200 ok(ret
== 1, "expected 1, got %d\n", ret
);
3201 ok(FD_ISSET(fdRead
, &exceptfds
), "fdRead socket is not in the set\n");
3203 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
3204 ok(ret
== 1, "expected 1, got %d\n", ret
);
3205 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
3207 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
3209 ret
= setsockopt(fdRead
, SOL_SOCKET
, SO_OOBINLINE
, (char*) &ret
, sizeof(ret
));
3210 ok(ret
== 0, "expected 0, got %d\n", ret
);
3211 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
3212 ok(ret
== 1, "expected 1, got %d\n", ret
);
3214 FD_SET_ALL(fdListen
);
3215 FD_SET(fdRead
, &readfds
);
3216 FD_SET(fdRead
, &exceptfds
);
3217 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3218 ok(ret
== 1, "expected 1, got %d\n", ret
);
3219 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3221 SetLastError(0xdeadbeef);
3222 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
3223 ok(ret
== SOCKET_ERROR
, "expected SOCKET_ERROR, got %d\n", ret
);
3224 ok(GetLastError() == WSAEINVAL
, "expected 10022, got %d\n", GetLastError());
3225 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
3226 ok(ret
== 1, "expected 1, got %d\n", ret
);
3227 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
3229 /* When the connection is closed the socket is set in the read descriptor */
3230 ret
= closesocket(fdRead
);
3231 ok(ret
== 0, "expected 0, got %d\n", ret
);
3233 FD_SET_ALL(fdListen
);
3234 FD_SET(fdWrite
, &readfds
);
3235 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3236 ok(ret
== 1, "expected 1, got %d\n", ret
);
3237 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3238 ret
= recv(fdWrite
, tmp_buf
, sizeof(tmp_buf
), 0);
3239 ok(ret
== 0, "expected 0, got %d\n", ret
);
3240 ret
= closesocket(fdWrite
);
3241 ok(ret
== 0, "expected 0, got %d\n", ret
);
3242 ret
= closesocket(fdListen
);
3243 ok(ret
== 0, "expected 0, got %d\n", ret
);
3245 /* w10pro64 sometimes takes over 2 seconds for an error to be reported. */
3246 if (winetest_interactive
)
3248 len
= sizeof(address
);
3249 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
3251 FD_SET(fdWrite
, &writefds
);
3252 FD_SET(fdWrite
, &exceptfds
);
3253 select_timeout
.tv_sec
= 10;
3254 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3255 ok(ret
== 1, "expected 1, got %d\n", ret
);
3258 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
3259 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
3260 ok(id
== WSAECONNREFUSED
, "expected 10061, got %d\n", id
);
3261 ok(FD_ISSET(fdWrite
, &exceptfds
), "fdWrite socket is not in the set\n");
3262 ok(select_timeout
.tv_usec
== 250000, "select timeout should not have changed\n");
3263 closesocket(fdWrite
);
3266 /* Try select() on a closed socket after connection */
3267 tcp_socketpair(&fdRead
, &fdWrite
);
3268 closesocket(fdRead
);
3270 FD_SET_ALL(fdWrite
);
3272 SetLastError(0xdeadbeef);
3273 ret
= select(0, &readfds
, NULL
, &exceptfds
, &select_timeout
);
3274 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
3275 ok(GetLastError() == WSAENOTSOCK
, "got %d\n", GetLastError());
3276 /* descriptor sets are unchanged */
3277 ok(readfds
.fd_count
== 2, "expected 2, got %d\n", readfds
.fd_count
);
3278 ok(exceptfds
.fd_count
== 2, "expected 2, got %d\n", exceptfds
.fd_count
);
3279 closesocket(fdWrite
);
3281 /* Close the socket currently being selected in a thread - bug 38399 */
3282 tcp_socketpair(&fdRead
, &fdWrite
);
3283 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
3284 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
3286 FD_SET_ALL(fdWrite
);
3287 ret
= select(0, &readfds
, NULL
, &exceptfds
, &select_timeout
);
3288 ok(ret
== 1, "expected 1, got %d\n", ret
);
3289 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3290 WaitForSingleObject (thread_handle
, 1000);
3291 closesocket(fdRead
);
3292 /* test again with only the except descriptor */
3293 tcp_socketpair(&fdRead
, &fdWrite
);
3294 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
3295 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
3297 FD_SET(fdWrite
, &exceptfds
);
3298 SetLastError(0xdeadbeef);
3299 ret
= select(0, NULL
, NULL
, &exceptfds
, &select_timeout
);
3300 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
3301 ok(GetLastError() == WSAENOTSOCK
, "got %d\n", GetLastError());
3302 ok(!FD_ISSET(fdWrite
, &exceptfds
), "fdWrite socket is in the set\n");
3303 WaitForSingleObject (thread_handle
, 1000);
3304 closesocket(fdRead
);
3306 /* test UDP behavior of unbound sockets */
3307 select_timeout
.tv_sec
= 0;
3308 select_timeout
.tv_usec
= 250000;
3309 fdWrite
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
3310 ok(fdWrite
!= INVALID_SOCKET
, "socket call failed\n");
3312 FD_SET_ALL(fdWrite
);
3313 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3314 ok(ret
== 1, "expected 1, got %d\n", ret
);
3315 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
3316 closesocket(fdWrite
);
3321 static DWORD WINAPI
AcceptKillThread(void *param
)
3323 select_thread_params
*par
= param
;
3324 struct sockaddr_in address
;
3325 int len
= sizeof(address
);
3326 SOCKET client_socket
;
3328 SetEvent(server_ready
);
3329 client_socket
= accept(par
->s
, (struct sockaddr
*) &address
, &len
);
3330 if (client_socket
!= INVALID_SOCKET
)
3331 closesocket(client_socket
);
3332 par
->ReadKilled
= (client_socket
== INVALID_SOCKET
);
3337 static int CALLBACK
AlwaysDeferConditionFunc(LPWSABUF lpCallerId
, LPWSABUF lpCallerData
, LPQOS pQos
,
3338 LPQOS lpGQOS
, LPWSABUF lpCalleeId
, LPWSABUF lpCalleeData
,
3339 GROUP
*g
, DWORD_PTR dwCallbackData
)
3344 static SOCKET
setup_server_socket(struct sockaddr_in
*addr
, int *len
)
3347 SOCKET server_socket
;
3349 server_socket
= socket(AF_INET
, SOCK_STREAM
, 0);
3350 ok(server_socket
!= INVALID_SOCKET
, "failed to bind socket, error %u\n", WSAGetLastError());
3353 ret
= setsockopt(server_socket
, SOL_SOCKET
, SO_REUSEADDR
, (char *)&val
, sizeof(val
));
3354 ok(!ret
, "failed to set SO_REUSEADDR, error %u\n", WSAGetLastError());
3356 ret
= bind(server_socket
, (struct sockaddr
*)addr
, *len
);
3357 ok(!ret
, "failed to bind socket, error %u\n", WSAGetLastError());
3359 ret
= getsockname(server_socket
, (struct sockaddr
*)addr
, len
);
3360 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
3362 ret
= listen(server_socket
, 5);
3363 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
3365 return server_socket
;
3368 static SOCKET
setup_connector_socket(const struct sockaddr_in
*addr
, int len
, BOOL nonblock
)
3373 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
3374 ok(connector
!= INVALID_SOCKET
, "failed to create connector socket %d\n", WSAGetLastError());
3377 set_blocking(connector
, !nonblock
);
3379 ret
= connect(connector
, (const struct sockaddr
*)addr
, len
);
3381 ok(!ret
, "connecting to accepting socket failed %d\n", WSAGetLastError());
3382 else if (ret
== SOCKET_ERROR
)
3383 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
3388 static void test_accept(void)
3391 SOCKET server_socket
, accepted
= INVALID_SOCKET
, connector
;
3392 struct sockaddr_in address
;
3393 SOCKADDR_STORAGE ss
, ss_empty
;
3395 select_thread_params thread_params
;
3396 HANDLE thread_handle
= NULL
;
3399 memset(&address
, 0, sizeof(address
));
3400 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3401 address
.sin_family
= AF_INET
;
3403 socklen
= sizeof(address
);
3404 server_socket
= setup_server_socket(&address
, &socklen
);
3406 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3407 if (connector
== INVALID_SOCKET
) goto done
;
3409 accepted
= WSAAccept(server_socket
, NULL
, NULL
, AlwaysDeferConditionFunc
, 0);
3410 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
3412 accepted
= accept(server_socket
, NULL
, 0);
3413 ok(accepted
!= INVALID_SOCKET
, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
3415 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
3417 thread_params
.s
= server_socket
;
3418 thread_params
.ReadKilled
= FALSE
;
3419 thread_handle
= CreateThread(NULL
, 0, AcceptKillThread
, &thread_params
, 0, &id
);
3421 WaitForSingleObject(server_ready
, INFINITE
);
3423 ret
= closesocket(server_socket
);
3424 ok(!ret
, "failed to close socket, error %u\n", WSAGetLastError());
3426 WaitForSingleObject(thread_handle
, 1000);
3427 ok(thread_params
.ReadKilled
, "closesocket did not wake up accept\n");
3429 closesocket(accepted
);
3430 closesocket(connector
);
3431 accepted
= connector
= INVALID_SOCKET
;
3433 socklen
= sizeof(address
);
3434 server_socket
= setup_server_socket(&address
, &socklen
);
3436 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3437 if (connector
== INVALID_SOCKET
) goto done
;
3440 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
3441 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
3442 ok(!socklen
, "got %d\n", socklen
);
3443 closesocket(connector
);
3444 connector
= INVALID_SOCKET
;
3446 socklen
= sizeof(address
);
3447 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3448 if (connector
== INVALID_SOCKET
) goto done
;
3450 accepted
= WSAAccept(server_socket
, NULL
, NULL
, NULL
, 0);
3451 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3452 closesocket(accepted
);
3453 closesocket(connector
);
3454 accepted
= connector
= INVALID_SOCKET
;
3456 socklen
= sizeof(address
);
3457 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3458 if (connector
== INVALID_SOCKET
) goto done
;
3460 socklen
= sizeof(ss
);
3461 memset(&ss
, 0, sizeof(ss
));
3462 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
3463 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3464 ok(socklen
!= sizeof(ss
), "unexpected length\n");
3465 ok(ss
.ss_family
, "family not set\n");
3466 closesocket(accepted
);
3467 closesocket(connector
);
3468 accepted
= connector
= INVALID_SOCKET
;
3470 socklen
= sizeof(address
);
3471 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3472 if (connector
== INVALID_SOCKET
) goto done
;
3475 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
3476 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
3477 ok(!socklen
, "got %d\n", socklen
);
3478 closesocket(connector
);
3479 accepted
= connector
= INVALID_SOCKET
;
3481 socklen
= sizeof(address
);
3482 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3483 if (connector
== INVALID_SOCKET
) goto done
;
3485 accepted
= accept(server_socket
, NULL
, NULL
);
3486 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3487 closesocket(accepted
);
3488 closesocket(connector
);
3489 accepted
= connector
= INVALID_SOCKET
;
3491 socklen
= sizeof(address
);
3492 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3493 if (connector
== INVALID_SOCKET
) goto done
;
3495 socklen
= sizeof(ss
);
3496 memset(&ss
, 0, sizeof(ss
));
3497 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
3498 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3499 ok(socklen
!= sizeof(ss
), "unexpected length\n");
3500 ok(ss
.ss_family
, "family not set\n");
3501 closesocket(accepted
);
3502 closesocket(connector
);
3503 accepted
= connector
= INVALID_SOCKET
;
3505 socklen
= sizeof(address
);
3506 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3507 if (connector
== INVALID_SOCKET
) goto done
;
3509 memset(&ss
, 0, sizeof(ss
));
3510 memset(&ss_empty
, 0, sizeof(ss_empty
));
3511 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, NULL
);
3512 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3513 ok(!memcmp(&ss
, &ss_empty
, sizeof(ss
)), "structure is different\n");
3516 if (accepted
!= INVALID_SOCKET
)
3517 closesocket(accepted
);
3518 if (connector
!= INVALID_SOCKET
)
3519 closesocket(connector
);
3520 if (thread_handle
!= NULL
)
3521 CloseHandle(thread_handle
);
3522 if (server_ready
!= INVALID_HANDLE_VALUE
)
3523 CloseHandle(server_ready
);
3524 if (server_socket
!= INVALID_SOCKET
)
3525 closesocket(server_socket
);
3528 static void test_extendedSocketOptions(void)
3532 struct sockaddr_in sa
;
3533 int sa_len
= sizeof(struct sockaddr_in
);
3534 int optval
, optlen
= sizeof(int), ret
;
3538 ret
= WSAStartup(MAKEWORD(2,0), &wsa
);
3539 ok(!ret
, "failed to startup, error %u\n", WSAGetLastError());
3541 memset(&sa
, 0, sa_len
);
3543 sa
.sin_family
= AF_INET
;
3544 sa
.sin_port
= htons(0);
3545 sa
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
3547 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
3548 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
3550 ret
= bind(sock
, (struct sockaddr
*) &sa
, sa_len
);
3551 ok(!ret
, "failed to bind socket, error %u\n", WSAGetLastError());
3553 ret
= getsockopt(sock
, SOL_SOCKET
, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3555 ok(ret
== 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret
);
3556 ok((optval
== 65507) || (optval
== 65527),
3557 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval
);
3559 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
3560 SetLastError(0xdeadbeef);
3561 optval
= 0xdeadbeef;
3562 optlen
= sizeof(int);
3563 ret
= getsockopt(sock
, 0xffffffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3564 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3565 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3566 ret
, WSAGetLastError(), optval
, optval
);
3568 /* more invalid values for level */
3569 SetLastError(0xdeadbeef);
3570 optval
= 0xdeadbeef;
3571 optlen
= sizeof(int);
3572 ret
= getsockopt(sock
, 0x1234ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3573 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3574 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3575 ret
, WSAGetLastError(), optval
, optval
);
3577 SetLastError(0xdeadbeef);
3578 optval
= 0xdeadbeef;
3579 optlen
= sizeof(int);
3580 ret
= getsockopt(sock
, 0x8000ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3581 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3582 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3583 ret
, WSAGetLastError(), optval
, optval
);
3585 SetLastError(0xdeadbeef);
3586 optval
= 0xdeadbeef;
3587 optlen
= sizeof(int);
3588 ret
= getsockopt(sock
, 0x00008000, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3589 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3590 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3591 ret
, WSAGetLastError(), optval
, optval
);
3593 SetLastError(0xdeadbeef);
3594 optval
= 0xdeadbeef;
3595 optlen
= sizeof(int);
3596 ret
= getsockopt(sock
, 0x00000800, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3597 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3598 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3599 ret
, WSAGetLastError(), optval
, optval
);
3601 SetLastError(0xdeadbeef);
3602 optlen
= sizeof(LINGER
);
3603 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
3604 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAENOPROTOOPT
),
3605 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
3606 ret
, WSAGetLastError());
3609 sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
);
3610 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
3612 ret
= bind(sock
, (struct sockaddr
*) &sa
, sa_len
);
3613 ok(!ret
, "failed to bind socket, error %u\n", WSAGetLastError());
3615 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
3616 ok(ret
== 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret
);
3618 optlen
= sizeof(BOOL
);
3619 ret
= getsockopt(sock
, SOL_SOCKET
, SO_DONTLINGER
, (char *)&bool_opt_val
, &optlen
);
3620 ok(ret
== 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret
);
3621 ok((linger_val
.l_onoff
&& !bool_opt_val
) || (!linger_val
.l_onoff
&& bool_opt_val
),
3622 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
3623 bool_opt_val
, linger_val
.l_onoff
);
3629 static void test_getsockname(void)
3633 struct sockaddr_in sa_set
, sa_get
;
3634 int sa_set_len
= sizeof(struct sockaddr_in
);
3635 int sa_get_len
= sa_set_len
;
3636 static const unsigned char null_padding
[] = {0,0,0,0,0,0,0,0};
3640 ret
= WSAStartup(MAKEWORD(2,0), &wsa
);
3641 ok(!ret
, "failed to startup, error %u\n", WSAGetLastError());
3643 memset(&sa_set
, 0, sa_set_len
);
3645 sa_set
.sin_family
= AF_INET
;
3646 sa_set
.sin_port
= htons(0);
3647 sa_set
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
3649 sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
);
3650 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
3653 WSASetLastError(0xdeadbeef);
3654 ret
= getsockname(sock
, (struct sockaddr
*)&sa_get
, &sa_get_len
);
3655 ok(ret
== SOCKET_ERROR
, "expected failure\n");
3656 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
3657 ok(!memcmp(&sa_get
, &sa_set
, sizeof(sa_get
)), "address should not be changed\n");
3659 ret
= bind(sock
, (struct sockaddr
*) &sa_set
, sa_set_len
);
3660 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
3662 WSASetLastError(0xdeadbeef);
3663 ret
= getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
);
3664 ok(!ret
, "got %d\n", ret
);
3665 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
3667 ret
= memcmp(sa_get
.sin_zero
, null_padding
, 8);
3668 ok(ret
== 0, "getsockname did not zero the sockaddr_in structure\n");
3670 sa_get_len
= sizeof(sa_get
) - 1;
3671 WSASetLastError(0xdeadbeef);
3672 ret
= getsockname(sock
, (struct sockaddr
*)&sa_get
, &sa_get_len
);
3673 ok(ret
== -1, "expected failure\n");
3674 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3675 ok(sa_get_len
== sizeof(sa_get
) - 1, "got size %d\n", sa_get_len
);
3679 h
= gethostbyname("");
3680 if (h
&& h
->h_length
== 4) /* this test is only meaningful in IPv4 */
3683 for (i
= 0; h
->h_addr_list
[i
]; i
++)
3687 ip
.s_addr
= *(ULONG
*) h
->h_addr_list
[i
];
3689 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
3690 ok(sock
!= INVALID_SOCKET
, "socket failed with %d\n", GetLastError());
3692 memset(&sa_set
, 0, sizeof(sa_set
));
3693 sa_set
.sin_family
= AF_INET
;
3694 sa_set
.sin_addr
.s_addr
= ip
.s_addr
;
3695 /* The same address we bind must be the same address we get */
3696 ret
= bind(sock
, (struct sockaddr
*)&sa_set
, sizeof(sa_set
));
3697 ok(ret
== 0, "bind failed with %d\n", GetLastError());
3698 sa_get_len
= sizeof(sa_get
);
3699 ret
= getsockname(sock
, (struct sockaddr
*)&sa_get
, &sa_get_len
);
3700 ok(ret
== 0, "getsockname failed with %d\n", GetLastError());
3701 strcpy(ipstr
, inet_ntoa(sa_get
.sin_addr
));
3702 ok(sa_get
.sin_addr
.s_addr
== sa_set
.sin_addr
.s_addr
,
3703 "address does not match: %s != %s\n", ipstr
, inet_ntoa(sa_set
.sin_addr
));
3712 static DWORD apc_error
, apc_size
;
3713 static OVERLAPPED
*apc_overlapped
;
3714 static unsigned int apc_count
;
3716 static void WINAPI
socket_apc(DWORD error
, DWORD size
, OVERLAPPED
*overlapped
, DWORD flags
)
3718 ok(!flags
, "got flags %#x\n", flags
);
3722 apc_overlapped
= overlapped
;
3725 #define check_fionread_siocatmark(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, FALSE, FALSE)
3726 #define check_fionread_siocatmark_todo(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, TRUE, TRUE)
3727 #define check_fionread_siocatmark_todo_oob(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, FALSE, TRUE)
3728 static void check_fionread_siocatmark_(int line
, SOCKET s
, unsigned int normal
, unsigned int oob
,
3729 BOOL todo_normal
, BOOL todo_oob
)
3735 WSASetLastError(0xdeadbeef);
3736 ret
= WSAIoctl(s
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), &size
, NULL
, NULL
);
3737 ok_(__FILE__
, line
)(!ret
, "expected success\n");
3738 ok_(__FILE__
, line
)(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
3739 todo_wine_if (todo_normal
) ok_(__FILE__
, line
)(value
== normal
, "FIONBIO returned %u\n", value
);
3742 WSASetLastError(0xdeadbeef);
3743 ret
= WSAIoctl(s
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), &size
, NULL
, NULL
);
3744 ok_(__FILE__
, line
)(!ret
, "expected success\n");
3745 ok_(__FILE__
, line
)(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
3746 todo_wine_if (todo_oob
) ok_(__FILE__
, line
)(value
== oob
, "SIOCATMARK returned %u\n", value
);
3749 static void test_fionread_siocatmark(void)
3751 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
3752 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
3753 SOCKET client
, server
;
3760 tcp_socketpair(&client
, &server
);
3761 set_blocking(client
, FALSE
);
3762 overlapped
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
3764 WSASetLastError(0xdeadbeef);
3765 ret
= ioctlsocket(client
, FIONREAD
, (u_long
*)1);
3766 ok(ret
== -1, "expected failure\n");
3767 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3769 WSASetLastError(0xdeadbeef);
3770 ret
= ioctlsocket(client
, SIOCATMARK
, (u_long
*)1);
3771 ok(ret
== -1, "expected failure\n");
3772 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3774 WSASetLastError(0xdeadbeef);
3775 ret
= WSAIoctl(client
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), NULL
, NULL
, NULL
);
3776 ok(ret
== -1, "expected failure\n");
3777 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3779 WSASetLastError(0xdeadbeef);
3781 ret
= WSAIoctl(client
, FIONREAD
, NULL
, 0, &value
, sizeof(value
) - 1, &size
, NULL
, NULL
);
3782 ok(ret
== -1, "expected failure\n");
3783 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3784 ok(size
== 0xdeadbeef, "got size %u\n", size
);
3786 WSASetLastError(0xdeadbeef);
3787 ret
= WSAIoctl(client
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), NULL
, NULL
, NULL
);
3788 ok(ret
== -1, "expected failure\n");
3789 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3791 WSASetLastError(0xdeadbeef);
3793 ret
= WSAIoctl(client
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
) - 1, &size
, NULL
, NULL
);
3794 ok(ret
== -1, "expected failure\n");
3795 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3796 ok(size
== 0xdeadbeef, "got size %u\n", size
);
3798 check_fionread_siocatmark(client
, 0, TRUE
);
3800 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 123, 0);
3802 ret
= WSAIoctl(client
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), NULL
, &overlapped
, NULL
);
3803 ok(ret
== -1, "expected failure\n");
3804 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3806 ret
= WSAIoctl(client
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), NULL
, &overlapped
, NULL
);
3807 ok(ret
== -1, "expected failure\n");
3808 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3810 WSASetLastError(0xdeadbeef);
3813 overlapped
.Internal
= 0xdeadbeef;
3814 overlapped
.InternalHigh
= 0xdeadbeef;
3815 ret
= WSAIoctl(client
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), &size
, &overlapped
, NULL
);
3816 ok(!ret
, "expected success\n");
3817 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
3818 ok(!value
, "got %u\n", value
);
3819 ok(size
== sizeof(value
), "got size %u\n", size
);
3820 ok(!overlapped
.Internal
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
3821 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
3823 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
3824 ok(ret
, "got error %u\n", GetLastError());
3825 ok(!size
, "got size %u\n", size
);
3826 ok(key
== 123, "got key %Iu\n", key
);
3827 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
3829 WSASetLastError(0xdeadbeef);
3832 overlapped
.Internal
= 0xdeadbeef;
3833 overlapped
.InternalHigh
= 0xdeadbeef;
3834 ret
= WSAIoctl(client
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), &size
, &overlapped
, NULL
);
3835 ok(!ret
, "expected success\n");
3836 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
3837 ok(value
== TRUE
, "got %u\n", value
);
3838 ok(size
== sizeof(value
), "got size %u\n", size
);
3839 ok(!overlapped
.Internal
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
3840 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
3842 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
3843 ok(ret
, "got error %u\n", GetLastError());
3844 ok(!size
, "got size %u\n", size
);
3845 ok(key
== 123, "got key %Iu\n", key
);
3846 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
3848 ret
= send(server
, "data", 5, 0);
3849 ok(ret
== 5, "got %d\n", ret
);
3851 /* wait for the data to be available */
3852 check_poll_mask(client
, POLLRDNORM
, POLLRDNORM
);
3854 check_fionread_siocatmark(client
, 5, TRUE
);
3856 ret
= send(server
, "a", 1, MSG_OOB
);
3857 ok(ret
== 1, "got %d\n", ret
);
3859 /* wait for the data to be available */
3860 check_poll_mask(client
, POLLRDBAND
, POLLRDBAND
);
3862 check_fionread_siocatmark_todo_oob(client
, 5, FALSE
);
3864 ret
= send(server
, "a", 1, MSG_OOB
);
3865 ok(ret
== 1, "got %d\n", ret
);
3867 check_fionread_siocatmark_todo(client
, 5, FALSE
);
3869 ret
= recv(client
, buffer
, 3, 0);
3870 ok(ret
== 3, "got %d\n", ret
);
3872 check_fionread_siocatmark_todo(client
, 2, FALSE
);
3874 ret
= recv(client
, buffer
, 1, MSG_OOB
);
3875 ok(ret
== 1, "got %d\n", ret
);
3877 /* wait for the data to be available */
3878 check_poll_mask_todo(client
, POLLRDBAND
, POLLRDBAND
);
3880 check_fionread_siocatmark_todo(client
, 2, FALSE
);
3882 ret
= recv(client
, buffer
, 5, 0);
3883 todo_wine
ok(ret
== 2, "got %d\n", ret
);
3885 check_fionread_siocatmark(client
, 0, FALSE
);
3887 ret
= recv(client
, buffer
, 1, MSG_OOB
);
3888 todo_wine
ok(ret
== 1, "got %d\n", ret
);
3890 check_fionread_siocatmark_todo_oob(client
, 0, TRUE
);
3892 ret
= send(server
, "a", 1, MSG_OOB
);
3893 ok(ret
== 1, "got %d\n", ret
);
3895 /* wait for the data to be available */
3896 check_poll_mask(client
, POLLRDBAND
, POLLRDBAND
);
3899 ret
= setsockopt(client
, SOL_SOCKET
, SO_OOBINLINE
, (char *)&ret
, sizeof(ret
));
3900 ok(!ret
, "got error %u\n", WSAGetLastError());
3902 check_fionread_siocatmark_todo_oob(client
, 1, FALSE
);
3904 ret
= recv(client
, buffer
, 1, 0);
3905 ok(ret
== 1, "got %d\n", ret
);
3907 check_fionread_siocatmark(client
, 0, TRUE
);
3909 ret
= send(server
, "a", 1, MSG_OOB
);
3910 ok(ret
== 1, "got %d\n", ret
);
3912 /* wait for the data to be available */
3913 check_poll_mask(client
, POLLRDNORM
, POLLRDNORM
);
3915 check_fionread_siocatmark(client
, 1, TRUE
);
3917 closesocket(client
);
3918 closesocket(server
);
3920 server
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3922 check_fionread_siocatmark(server
, 0, TRUE
);
3924 ret
= bind(server
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
3925 ok(!ret
, "got error %u\n", WSAGetLastError());
3927 check_fionread_siocatmark(server
, 0, TRUE
);
3929 closesocket(server
);
3930 CloseHandle(overlapped
.hEvent
);
3932 /* test with APCs */
3934 server
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3936 ret
= WSAIoctl(server
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), NULL
, &overlapped
, socket_apc
);
3937 ok(ret
== -1, "expected failure\n");
3938 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3940 ret
= WSAIoctl(server
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), NULL
, &overlapped
, socket_apc
);
3941 ok(ret
== -1, "expected failure\n");
3942 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3946 ret
= WSAIoctl(server
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), &size
, &overlapped
, socket_apc
);
3947 ok(!ret
, "expected success\n");
3948 ok(size
== sizeof(value
), "got size %u\n", size
);
3950 ret
= SleepEx(0, TRUE
);
3951 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
3952 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
3953 ok(!apc_error
, "got APC error %u\n", apc_error
);
3954 ok(!apc_size
, "got APC size %u\n", apc_size
);
3955 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
3959 ret
= WSAIoctl(server
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), &size
, &overlapped
, socket_apc
);
3960 ok(!ret
, "expected success\n");
3961 ok(size
== sizeof(value
), "got size %u\n", size
);
3963 ret
= SleepEx(0, TRUE
);
3964 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
3965 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
3966 ok(!apc_error
, "got APC error %u\n", apc_error
);
3967 ok(!apc_size
, "got APC size %u\n", apc_size
);
3968 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
3970 closesocket(server
);
3973 static void test_fionbio(void)
3975 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
3976 u_long one
= 1, zero
= 0;
3984 event
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
3985 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3986 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
3988 WSASetLastError(0xdeadbeef);
3989 ret
= ioctlsocket(s
, FIONBIO
, (u_long
*)1);
3990 ok(ret
== -1, "expected failure\n");
3991 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3993 WSASetLastError(0xdeadbeef);
3994 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, NULL
, NULL
, NULL
);
3995 ok(ret
== -1, "expected failure\n");
3996 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3998 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
) - 1, NULL
, 0, &size
, &overlapped
, NULL
);
3999 ok(ret
== -1, "expected failure\n");
4000 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4003 WSASetLastError(0xdeadbeef);
4004 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, &size
, NULL
, NULL
);
4005 ok(!ret
, "expected success\n");
4006 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4007 ok(!size
, "got size %u\n", size
);
4009 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
) + 1, NULL
, 0, &size
, NULL
, NULL
);
4010 ok(!ret
, "got error %u\n", WSAGetLastError());
4012 output
= VirtualAlloc(NULL
, 4, MEM_RESERVE
| MEM_COMMIT
, PAGE_NOACCESS
);
4013 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
) + 1, output
, 4, &size
, NULL
, NULL
);
4014 ok(!ret
, "got error %u\n", WSAGetLastError());
4015 VirtualFree(output
, 0, MEM_FREE
);
4017 overlapped
.Internal
= 0xdeadbeef;
4018 overlapped
.InternalHigh
= 0xdeadbeef;
4020 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, &size
, &overlapped
, NULL
);
4021 ok(!ret
, "expected success\n");
4022 ok(!size
, "got size %u\n", size
);
4024 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
4025 ok(ret
, "got error %u\n", GetLastError());
4026 ok(!size
, "got size %u\n", size
);
4027 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
4028 ok(!overlapped
.Internal
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
4029 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
4031 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, NULL
, &overlapped
, NULL
);
4032 ok(ret
== -1, "expected failure\n");
4033 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4035 ret
= WSAEventSelect(s
, event
, FD_READ
);
4036 ok(!ret
, "got error %u\n", WSAGetLastError());
4038 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, &size
, NULL
, NULL
);
4039 ok(!ret
, "got error %u\n", WSAGetLastError());
4042 ret
= WSAIoctl(s
, FIONBIO
, &zero
, sizeof(zero
), NULL
, 0, &size
, NULL
, NULL
);
4043 ok(ret
== -1, "expected failure\n");
4044 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
4045 todo_wine
ok(!size
, "got size %u\n", size
);
4051 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4053 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, NULL
, &overlapped
, socket_apc
);
4054 ok(ret
== -1, "expected failure\n");
4055 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4059 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, &size
, &overlapped
, socket_apc
);
4060 ok(!ret
, "expected success\n");
4061 ok(!size
, "got size %u\n", size
);
4063 ret
= SleepEx(0, TRUE
);
4064 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
4065 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
4066 ok(!apc_error
, "got APC error %u\n", apc_error
);
4067 ok(!apc_size
, "got APC size %u\n", apc_size
);
4068 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
4073 static void test_keepalive_vals(void)
4075 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
4076 struct tcp_keepalive kalive
;
4083 sock
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4084 ok(sock
!= INVALID_SOCKET
, "Creating the socket failed: %d\n", WSAGetLastError());
4085 port
= CreateIoCompletionPort((HANDLE
)sock
, NULL
, 123, 0);
4087 WSASetLastError(0xdeadbeef);
4089 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, 0, NULL
, 0, &size
, NULL
, NULL
);
4090 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
4091 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4092 ok(!size
, "got size %u\n", size
);
4094 WSASetLastError(0xdeadbeef);
4096 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, NULL
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
4097 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
4098 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4099 ok(!size
, "got size %u\n", size
);
4101 WSASetLastError(0xdeadbeef);
4103 make_keepalive(kalive
, 0, 0, 0);
4104 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
4105 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
4106 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4107 ok(!size
, "got size %u\n", size
);
4109 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, NULL
, NULL
, NULL
);
4110 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
4111 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4113 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, NULL
, &overlapped
, NULL
);
4114 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
4115 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4117 WSASetLastError(0xdeadbeef);
4119 overlapped
.Internal
= 0xdeadbeef;
4120 overlapped
.InternalHigh
= 0xdeadbeef;
4121 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
) - 1, NULL
, 0, &size
, &overlapped
, NULL
);
4122 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
4123 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4124 ok(size
== 0xdeadbeef, "got size %u\n", size
);
4125 todo_wine
ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
4126 ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
4128 WSASetLastError(0xdeadbeef);
4130 overlapped
.Internal
= 0xdeadbeef;
4131 overlapped
.InternalHigh
= 0xdeadbeef;
4132 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, &overlapped
, NULL
);
4133 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
4134 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4135 todo_wine
ok(size
== 0xdeadbeef, "got size %u\n", size
);
4137 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
4138 ok(ret
, "got error %u\n", GetLastError());
4139 ok(!size
, "got size %u\n", size
);
4140 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
4141 ok(!overlapped
.Internal
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
4142 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
4144 make_keepalive(kalive
, 1, 0, 0);
4145 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
4146 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
4148 make_keepalive(kalive
, 1, 1000, 1000);
4149 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
4150 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
4152 make_keepalive(kalive
, 1, 10000, 10000);
4153 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
4154 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
4156 make_keepalive(kalive
, 1, 100, 100);
4157 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
4158 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
4160 make_keepalive(kalive
, 0, 100, 100);
4161 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
4162 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
4167 sock
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4169 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, NULL
, &overlapped
, socket_apc
);
4170 ok(ret
== -1, "expected failure\n");
4171 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4175 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, &overlapped
, socket_apc
);
4176 ok(!ret
, "expected success\n");
4177 ok(!size
, "got size %u\n", size
);
4179 ret
= SleepEx(0, TRUE
);
4180 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
4181 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
4182 ok(!apc_error
, "got APC error %u\n", apc_error
);
4183 ok(!apc_size
, "got APC size %u\n", apc_size
);
4184 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
4189 static void test_unsupported_ioctls(void)
4191 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
4199 static const DWORD codes
[] = {0xdeadbeef, FIOASYNC
, 0x667e, SIO_FLUSH
};
4201 for (i
= 0; i
< ARRAY_SIZE(codes
); ++i
)
4203 winetest_push_context("ioctl %#x", codes
[i
]);
4204 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4205 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
4207 WSASetLastError(0xdeadbeef);
4208 ret
= WSAIoctl(s
, codes
[i
], NULL
, 0, NULL
, 0, NULL
, &overlapped
, NULL
);
4209 ok(ret
== -1, "expected failure\n");
4210 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4212 WSASetLastError(0xdeadbeef);
4214 ret
= WSAIoctl(s
, codes
[i
], NULL
, 0, NULL
, 0, &size
, NULL
, NULL
);
4215 ok(ret
== -1, "expected failure\n");
4216 ok(WSAGetLastError() == WSAEOPNOTSUPP
, "got error %u\n", WSAGetLastError());
4217 ok(!size
, "got size %u\n", size
);
4219 WSASetLastError(0xdeadbeef);
4221 overlapped
.Internal
= 0xdeadbeef;
4222 overlapped
.InternalHigh
= 0xdeadbeef;
4223 ret
= WSAIoctl(s
, codes
[i
], NULL
, 0, NULL
, 0, &size
, &overlapped
, NULL
);
4224 ok(ret
== -1, "expected failure\n");
4225 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
4226 ok(size
== 0xdeadbeef, "got size %u\n", size
);
4228 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
4229 ok(!ret
, "expected failure\n");
4230 ok(GetLastError() == ERROR_NOT_SUPPORTED
, "got error %u\n", GetLastError());
4231 ok(!size
, "got size %u\n", size
);
4232 ok(key
== 123, "got key %Iu\n", key
);
4233 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
4234 ok((NTSTATUS
)overlapped
.Internal
== STATUS_NOT_SUPPORTED
,
4235 "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
4236 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
4241 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4243 ret
= WSAIoctl(s
, codes
[i
], NULL
, 0, NULL
, 0, NULL
, &overlapped
, socket_apc
);
4244 ok(ret
== -1, "expected failure\n");
4245 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4249 ret
= WSAIoctl(s
, codes
[i
], NULL
, 0, NULL
, 0, &size
, &overlapped
, socket_apc
);
4250 ok(ret
== -1, "expected failure\n");
4251 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
4252 ok(size
== 0xdeadbeef, "got size %u\n", size
);
4254 ret
= SleepEx(0, TRUE
);
4255 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
4256 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
4257 ok(apc_error
== WSAEOPNOTSUPP
, "got APC error %u\n", apc_error
);
4258 ok(!apc_size
, "got APC size %u\n", apc_size
);
4259 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
4262 winetest_pop_context();
4266 static void test_get_extension_func(void)
4268 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
4269 GUID acceptex_guid
= WSAID_ACCEPTEX
;
4270 GUID bogus_guid
= {0xdeadbeef};
4278 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4279 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
4281 WSASetLastError(0xdeadbeef);
4282 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptex_guid
, sizeof(GUID
),
4283 &func
, sizeof(func
), NULL
, &overlapped
, NULL
);
4284 ok(ret
== -1, "expected failure\n");
4285 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4287 WSASetLastError(0xdeadbeef);
4289 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptex_guid
, sizeof(GUID
),
4290 &func
, sizeof(func
), &size
, NULL
, NULL
);
4291 ok(!ret
, "expected success\n");
4292 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4293 ok(size
== sizeof(func
), "got size %u\n", size
);
4295 WSASetLastError(0xdeadbeef);
4297 overlapped
.Internal
= 0xdeadbeef;
4298 overlapped
.InternalHigh
= 0xdeadbeef;
4299 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptex_guid
, sizeof(GUID
),
4300 &func
, sizeof(func
), &size
, &overlapped
, NULL
);
4301 ok(!ret
, "expected success\n");
4302 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4303 ok(size
== sizeof(func
), "got size %u\n", size
);
4305 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
4306 ok(ret
, "got error %u\n", GetLastError());
4307 ok(!size
, "got size %u\n", size
);
4308 ok(key
== 123, "got key %Iu\n", key
);
4309 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
4310 ok(!overlapped
.Internal
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
4311 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
4314 overlapped
.Internal
= 0xdeadbeef;
4315 overlapped
.InternalHigh
= 0xdeadbeef;
4316 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &bogus_guid
, sizeof(GUID
),
4317 &func
, sizeof(func
), &size
, &overlapped
, NULL
);
4318 ok(ret
== -1, "expected failure\n");
4319 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
4320 ok(size
== 0xdeadbeef, "got size %u\n", size
);
4321 ok(overlapped
.Internal
== 0xdeadbeef, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
4322 ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
4324 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
4325 ok(!ret
, "expected failure\n");
4326 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", WSAGetLastError());
4331 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4333 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptex_guid
, sizeof(GUID
),
4334 &func
, sizeof(func
), NULL
, &overlapped
, socket_apc
);
4335 ok(ret
== -1, "expected failure\n");
4336 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4340 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptex_guid
, sizeof(GUID
),
4341 &func
, sizeof(func
), &size
, &overlapped
, socket_apc
);
4342 ok(!ret
, "got error %u\n", WSAGetLastError());
4343 ok(size
== sizeof(func
), "got size %u\n", size
);
4345 ret
= SleepEx(0, TRUE
);
4346 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
4347 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
4348 ok(!apc_error
, "got APC error %u\n", apc_error
);
4349 ok(!apc_size
, "got APC size %u\n", apc_size
);
4350 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
4355 static void test_base_handle(void)
4357 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
4367 int family
, type
, protocol
;
4371 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
4372 {AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
4373 {AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
},
4374 {AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
},
4377 for (i
= 0; i
< ARRAY_SIZE(tests
); ++i
)
4379 s
= socket(tests
[i
].family
, tests
[i
].type
, tests
[i
].protocol
);
4380 if (s
== INVALID_SOCKET
) continue;
4381 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
4383 WSASetLastError(0xdeadbeef);
4384 ret
= WSAIoctl(s
, SIO_BASE_HANDLE
, NULL
, 0, &base
, sizeof(base
), NULL
, &overlapped
, NULL
);
4385 ok(ret
== -1, "expected failure\n");
4386 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4388 WSASetLastError(0xdeadbeef);
4391 ret
= WSAIoctl(s
, SIO_BASE_HANDLE
, NULL
, 0, &base
, sizeof(base
), &size
, NULL
, NULL
);
4392 ok(!ret
, "expected success\n");
4393 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4394 ok(size
== sizeof(base
), "got size %u\n", size
);
4395 ok(base
== s
, "expected %#Ix, got %#Ix\n", s
, base
);
4397 WSASetLastError(0xdeadbeef);
4400 overlapped
.Internal
= 0xdeadbeef;
4401 overlapped
.InternalHigh
= 0xdeadbeef;
4402 ret
= WSAIoctl(s
, SIO_BASE_HANDLE
, NULL
, 0, &base
, sizeof(base
), &size
, &overlapped
, NULL
);
4403 ok(ret
== -1, "expected failure\n");
4404 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
4405 ok(size
== 0xdeadbeef, "got size %u\n", size
);
4407 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
4408 ok(!ret
, "expected failure\n");
4409 ok(GetLastError() == ERROR_NOT_SUPPORTED
, "got error %u\n", GetLastError());
4410 ok(!size
, "got size %u\n", size
);
4411 ok(key
== 123, "got key %Iu\n", key
);
4412 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
4413 ok((NTSTATUS
)overlapped
.Internal
== STATUS_NOT_SUPPORTED
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
4414 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
4415 ok(base
== 0xdeadbeef, "expected %#Ix, got %#Ix\n", s
, base
);
4420 s
= socket(tests
[i
].family
, tests
[i
].type
, tests
[i
].protocol
);
4422 ret
= WSAIoctl(s
, SIO_BASE_HANDLE
, NULL
, 0, &base
, sizeof(base
), NULL
, &overlapped
, socket_apc
);
4423 ok(ret
== -1, "expected failure\n");
4424 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4429 ret
= WSAIoctl(s
, SIO_BASE_HANDLE
, NULL
, 0, &base
, sizeof(base
), &size
, &overlapped
, socket_apc
);
4430 ok(ret
== -1, "expected failure\n");
4431 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
4432 ok(size
== 0xdeadbeef, "got size %u\n", size
);
4434 ret
= SleepEx(0, TRUE
);
4435 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
4436 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
4437 ok(apc_error
== WSAEOPNOTSUPP
, "got APC error %u\n", apc_error
);
4438 ok(!apc_size
, "got APC size %u\n", apc_size
);
4439 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
4440 ok(base
== 0xdeadbeef, "expected %#Ix, got %#Ix\n", s
, base
);
4446 static BOOL drain_pause
= FALSE
;
4447 static DWORD WINAPI
drain_socket_thread(LPVOID arg
)
4450 SOCKET sock
= *(SOCKET
*)arg
;
4453 while ((ret
= recv(sock
, buffer
, sizeof(buffer
), 0)) != 0)
4457 if (WSAGetLastError() == WSAEWOULDBLOCK
)
4461 FD_SET(sock
, &readset
);
4462 select(sock
+1, &readset
, NULL
, NULL
, NULL
);
4473 static void test_send(void)
4475 SOCKET src
= INVALID_SOCKET
;
4476 SOCKET dst
= INVALID_SOCKET
;
4477 HANDLE hThread
= NULL
;
4478 const int buflen
= 1024*1024;
4479 char *buffer
= NULL
;
4480 int ret
, i
, zero
= 0;
4484 DWORD id
, bytes_sent
, dwRet
;
4486 memset(&ov
, 0, sizeof(ov
));
4488 tcp_socketpair(&src
, &dst
);
4490 set_blocking(dst
, FALSE
);
4491 /* force disable buffering so we can get a pending overlapped request */
4492 ret
= setsockopt(dst
, SOL_SOCKET
, SO_SNDBUF
, (char *) &zero
, sizeof(zero
));
4493 ok(!ret
, "setsockopt SO_SNDBUF failed: %d - %d\n", ret
, GetLastError());
4495 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
4497 buffer
= HeapAlloc(GetProcessHeap(), 0, buflen
);
4499 /* fill the buffer with some nonsense */
4500 for (i
= 0; i
< buflen
; ++i
)
4502 buffer
[i
] = (char) i
;
4505 ret
= send(src
, buffer
, buflen
, 0);
4506 ok(ret
== buflen
, "send should have sent %d bytes, but it only sent %d\n", buflen
, ret
);
4511 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
4512 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
4517 WSASetLastError(12345);
4518 ret
= WSASend(dst
, &buf
, 1, &bytes_sent
, 0, &ov
, NULL
);
4519 ok(ret
== SOCKET_ERROR
, "expected failure\n");
4520 ok(WSAGetLastError() == ERROR_IO_PENDING
, "wrong error %u\n", WSAGetLastError());
4522 /* don't check for completion yet, we may need to drain the buffer while still sending */
4523 set_blocking(src
, FALSE
);
4524 for (i
= 0; i
< buflen
; ++i
)
4528 ret
= recv(src
, buffer
, 1, 0);
4529 while (ret
== SOCKET_ERROR
&& GetLastError() == WSAEWOULDBLOCK
&& j
< 100)
4533 ret
= recv(src
, buffer
, 1, 0);
4536 ok(ret
== 1, "Failed to receive data %d - %d (got %d/%d)\n", ret
, GetLastError(), i
, buflen
);
4540 ok(buffer
[0] == (char) i
, "Received bad data at position %d\n", i
);
4543 dwRet
= WaitForSingleObject(ov
.hEvent
, 1000);
4544 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
4545 if (dwRet
== WAIT_OBJECT_0
)
4547 bret
= GetOverlappedResult((HANDLE
)dst
, &ov
, &bytes_sent
, FALSE
);
4548 ok(bret
&& bytes_sent
== buflen
,
4549 "Got %d instead of %d (%d - %d)\n", bytes_sent
, buflen
, bret
, GetLastError());
4552 WSASetLastError(12345);
4553 ret
= WSASend(INVALID_SOCKET
, &buf
, 1, NULL
, 0, &ov
, NULL
);
4554 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
4555 "WSASend failed %d - %d\n", ret
, WSAGetLastError());
4557 WSASetLastError(12345);
4558 ret
= WSASend(dst
, &buf
, 1, NULL
, 0, &ov
, NULL
);
4559 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == ERROR_IO_PENDING
,
4560 "Failed to start overlapped send %d - %d\n", ret
, WSAGetLastError());
4563 if (src
!= INVALID_SOCKET
)
4565 if (dst
!= INVALID_SOCKET
)
4567 if (hThread
!= NULL
)
4569 dwRet
= WaitForSingleObject(hThread
, 500);
4570 ok(dwRet
== WAIT_OBJECT_0
, "failed to wait for thread termination: %d\n", GetLastError());
4571 CloseHandle(hThread
);
4574 CloseHandle(ov
.hEvent
);
4575 HeapFree(GetProcessHeap(), 0, buffer
);
4578 #define WM_SOCKET (WM_USER+100)
4580 struct event_test_ctx
4588 static void select_events(struct event_test_ctx
*ctx
, SOCKET socket
, LONG events
)
4592 if (ctx
->is_message
)
4593 ret
= WSAAsyncSelect(socket
, ctx
->window
, WM_USER
, events
);
4595 ret
= WSAEventSelect(socket
, ctx
->event
, events
);
4596 ok(!ret
, "failed to select, error %u\n", WSAGetLastError());
4597 ctx
->socket
= socket
;
4600 #define check_events(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, FALSE)
4601 #define check_events_todo(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, TRUE)
4602 #define check_events_todo_event(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, FALSE)
4603 #define check_events_todo_msg(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, TRUE)
4604 static void check_events_(int line
, struct event_test_ctx
*ctx
,
4605 LONG flag1
, LONG flag2
, DWORD timeout
, BOOL todo_event
, BOOL todo_msg
)
4609 if (ctx
->is_message
)
4611 BOOL any_fail
= FALSE
;
4616 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
4617 while (!ret
&& !MsgWaitForMultipleObjects(0, NULL
, FALSE
, timeout
, QS_POSTMESSAGE
))
4618 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
4619 todo_wine_if (todo_msg
&& !ret
) ok_(__FILE__
, line
)(ret
, "expected a message\n");
4622 ok_(__FILE__
, line
)(msg
.wParam
== ctx
->socket
,
4623 "expected wparam %#Ix, got %#Ix\n", ctx
->socket
, msg
.wParam
);
4624 todo_wine_if (todo_msg
&& msg
.lParam
!= flag1
)
4625 ok_(__FILE__
, line
)(msg
.lParam
== flag1
, "got first event %#Ix\n", msg
.lParam
);
4626 if (msg
.lParam
!= flag1
) any_fail
= TRUE
;
4633 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
4634 while (!ret
&& !MsgWaitForMultipleObjects(0, NULL
, FALSE
, timeout
, QS_POSTMESSAGE
))
4635 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
4636 ok_(__FILE__
, line
)(ret
, "expected a message\n");
4637 ok_(__FILE__
, line
)(msg
.wParam
== ctx
->socket
, "got wparam %#Ix\n", msg
.wParam
);
4638 todo_wine_if (todo_msg
) ok_(__FILE__
, line
)(msg
.lParam
== flag2
, "got second event %#Ix\n", msg
.lParam
);
4640 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
4641 todo_wine_if (todo_msg
&& ret
) ok_(__FILE__
, line
)(!ret
, "got unexpected event %#Ix\n", msg
.lParam
);
4642 if (ret
) any_fail
= TRUE
;
4644 /* catch tests which succeed */
4645 todo_wine_if (todo_msg
) ok_(__FILE__
, line
)(!any_fail
, "event series matches\n");
4649 WSANETWORKEVENTS events
;
4651 ret
= WaitForSingleObject(ctx
->event
, timeout
);
4653 todo_wine_if (todo_event
&& ret
) ok_(__FILE__
, line
)(!ret
, "event wait timed out\n");
4655 todo_wine_if (todo_event
) ok_(__FILE__
, line
)(ret
== WAIT_TIMEOUT
, "expected timeout\n");
4656 ret
= WSAEnumNetworkEvents(ctx
->socket
, ctx
->event
, &events
);
4657 ok_(__FILE__
, line
)(!ret
, "failed to get events, error %u\n", WSAGetLastError());
4658 todo_wine_if (todo_event
)
4659 ok_(__FILE__
, line
)(events
.lNetworkEvents
== (flag1
| flag2
), "got events %#x\n", events
.lNetworkEvents
);
4663 static void test_accept_events(struct event_test_ctx
*ctx
)
4665 const struct sockaddr_in addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
4666 SOCKET listener
, server
, client
, client2
;
4667 struct sockaddr_in destaddr
;
4670 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4671 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4673 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
4675 ret
= bind(listener
, (const struct sockaddr
*)&addr
, sizeof(addr
));
4676 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
4677 len
= sizeof(destaddr
);
4678 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &len
);
4679 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
4680 ret
= listen(listener
, 2);
4681 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
4683 check_events(ctx
, 0, 0, 0);
4685 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4686 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4687 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4688 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4690 check_events(ctx
, FD_ACCEPT
, 0, 200);
4691 check_events(ctx
, 0, 0, 0);
4692 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
4693 if (ctx
->is_message
)
4694 check_events(ctx
, FD_ACCEPT
, 0, 200);
4695 check_events(ctx
, 0, 0, 0);
4696 select_events(ctx
, listener
, 0);
4697 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
4698 if (ctx
->is_message
)
4699 check_events(ctx
, FD_ACCEPT
, 0, 200);
4700 check_events(ctx
, 0, 0, 0);
4702 client2
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4703 ok(client2
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4704 ret
= connect(client2
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4705 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4707 if (!ctx
->is_message
)
4708 check_events_todo(ctx
, FD_ACCEPT
, 0, 200);
4709 check_events(ctx
, 0, 0, 0);
4711 server
= accept(listener
, NULL
, NULL
);
4712 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4713 closesocket(server
);
4715 check_events(ctx
, FD_ACCEPT
, 0, 200);
4716 check_events(ctx
, 0, 0, 0);
4718 server
= accept(listener
, NULL
, NULL
);
4719 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4720 closesocket(server
);
4722 check_events(ctx
, 0, 0, 0);
4724 closesocket(client2
);
4725 closesocket(client
);
4727 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4728 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4729 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4730 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4732 check_events(ctx
, FD_ACCEPT
, 0, 200);
4734 server
= accept(listener
, NULL
, NULL
);
4735 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4736 closesocket(server
);
4737 closesocket(client
);
4739 check_events(ctx
, 0, 0, 200);
4741 closesocket(listener
);
4743 /* Connect and then select. */
4745 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4746 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4747 ret
= bind(listener
, (const struct sockaddr
*)&addr
, sizeof(addr
));
4748 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
4749 len
= sizeof(destaddr
);
4750 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &len
);
4751 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
4752 ret
= listen(listener
, 2);
4753 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
4755 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4756 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4757 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4758 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4760 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
4762 check_events(ctx
, FD_ACCEPT
, 0, 200);
4764 server
= accept(listener
, NULL
, NULL
);
4765 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4766 closesocket(server
);
4767 closesocket(client
);
4769 /* As above, but select on a subset not containing FD_ACCEPT first. */
4771 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
);
4773 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4774 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4775 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4776 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4778 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
4779 check_events(ctx
, FD_ACCEPT
, 0, 200);
4781 server
= accept(listener
, NULL
, NULL
);
4782 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4783 closesocket(server
);
4784 closesocket(client
);
4786 /* As above, but call accept() before selecting. */
4788 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
);
4790 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4791 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4792 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4793 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4795 server
= accept(listener
, NULL
, NULL
);
4796 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4798 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
4799 check_events(ctx
, 0, 0, 200);
4801 closesocket(server
);
4802 closesocket(client
);
4804 closesocket(listener
);
4807 static void test_connect_events(struct event_test_ctx
*ctx
)
4809 const struct sockaddr_in addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
4810 SOCKET listener
, server
, client
;
4811 struct sockaddr_in destaddr
;
4814 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4815 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4816 ret
= bind(listener
, (const struct sockaddr
*)&addr
, sizeof(addr
));
4817 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
4818 len
= sizeof(destaddr
);
4819 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &len
);
4820 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
4821 ret
= listen(listener
, 2);
4822 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
4824 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4825 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4827 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4828 check_events(ctx
, 0, 0, 0);
4830 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4831 ok(!ret
|| WSAGetLastError() == WSAEWOULDBLOCK
, "failed to connect, error %u\n", WSAGetLastError());
4833 check_events(ctx
, FD_CONNECT
, FD_WRITE
, 200);
4834 check_events(ctx
, 0, 0, 0);
4835 select_events(ctx
, client
, 0);
4836 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4837 if (ctx
->is_message
)
4838 check_events(ctx
, FD_WRITE
, 0, 200);
4839 check_events(ctx
, 0, 0, 0);
4841 server
= accept(listener
, NULL
, NULL
);
4842 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4844 closesocket(client
);
4845 closesocket(server
);
4847 /* Connect and then select. */
4849 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4850 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4852 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4853 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4855 server
= accept(listener
, NULL
, NULL
);
4856 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4858 ret
= send(client
, "data", 5, 0);
4859 ok(ret
== 5, "got %d\n", ret
);
4861 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4862 if (ctx
->is_message
)
4863 check_events(ctx
, FD_WRITE
, 0, 200);
4865 check_events(ctx
, FD_CONNECT
, FD_WRITE
, 200);
4867 closesocket(client
);
4868 closesocket(server
);
4870 /* As above, but select on a subset not containing FD_CONNECT first. */
4872 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4873 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4875 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_OOB
| FD_READ
| FD_WRITE
);
4877 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4878 ok(!ret
|| WSAGetLastError() == WSAEWOULDBLOCK
, "failed to connect, error %u\n", WSAGetLastError());
4880 server
= accept(listener
, NULL
, NULL
);
4881 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4883 check_events(ctx
, FD_WRITE
, 0, 200);
4885 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4887 if (ctx
->is_message
)
4888 check_events(ctx
, FD_WRITE
, 0, 200);
4890 check_events_todo(ctx
, FD_CONNECT
, 0, 200);
4892 closesocket(client
);
4893 closesocket(server
);
4895 closesocket(listener
);
4898 /* perform a blocking recv() even on a nonblocking socket */
4899 static int sync_recv(SOCKET s
, void *buffer
, int len
, DWORD flags
)
4901 OVERLAPPED overlapped
= {0};
4906 overlapped
.hEvent
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
4907 wsabuf
.buf
= buffer
;
4909 ret
= WSARecv(s
, &wsabuf
, 1, &ret_len
, &flags
, &overlapped
, NULL
);
4910 if (ret
== -1 && WSAGetLastError() == ERROR_IO_PENDING
)
4912 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
4913 ok(!ret
, "wait timed out\n");
4914 ret
= WSAGetOverlappedResult(s
, &overlapped
, &ret_len
, FALSE
, &flags
);
4915 ret
= (ret
? 0 : -1);
4917 CloseHandle(overlapped
.hEvent
);
4918 if (!ret
) return ret_len
;
4922 static void test_write_events(struct event_test_ctx
*ctx
)
4924 static const int buffer_size
= 1024 * 1024;
4925 SOCKET server
, client
;
4929 buffer
= malloc(buffer_size
);
4931 tcp_socketpair(&client
, &server
);
4932 set_blocking(client
, FALSE
);
4934 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4935 check_events(ctx
, FD_WRITE
, 0, 200);
4936 check_events(ctx
, 0, 0, 0);
4937 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4938 if (ctx
->is_message
)
4939 check_events(ctx
, FD_WRITE
, 0, 200);
4940 check_events(ctx
, 0, 0, 0);
4941 select_events(ctx
, server
, 0);
4942 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4943 if (ctx
->is_message
)
4944 check_events(ctx
, FD_WRITE
, 0, 200);
4945 check_events(ctx
, 0, 0, 0);
4947 ret
= send(server
, "data", 5, 0);
4948 ok(ret
== 5, "got %d\n", ret
);
4950 check_events(ctx
, 0, 0, 0);
4952 ret
= sync_recv(client
, buffer
, buffer_size
, 0);
4953 ok(ret
== 5, "got %d\n", ret
);
4955 check_events(ctx
, 0, 0, 0);
4959 while (send(server
, buffer
, buffer_size
, 0) == buffer_size
);
4960 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
4962 while (recv(client
, buffer
, buffer_size
, 0) > 0);
4963 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
4965 /* Broken on Windows versions older than win10v1607 (though sometimes
4966 * works regardless, for unclear reasons. */
4967 check_events(ctx
, FD_WRITE
, 0, 200);
4968 check_events(ctx
, 0, 0, 0);
4969 select_events(ctx
, server
, 0);
4970 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4971 if (ctx
->is_message
)
4972 check_events(ctx
, FD_WRITE
, 0, 200);
4973 check_events(ctx
, 0, 0, 0);
4976 closesocket(server
);
4977 closesocket(client
);
4979 /* Despite the documentation, and unlike FD_ACCEPT and FD_RECV, calling
4980 * send() doesn't clear the FD_WRITE bit. */
4982 tcp_socketpair(&client
, &server
);
4984 select_events(ctx
, server
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4986 ret
= send(server
, "data", 5, 0);
4987 ok(ret
== 5, "got %d\n", ret
);
4989 check_events(ctx
, FD_WRITE
, 0, 200);
4991 closesocket(server
);
4992 closesocket(client
);
4997 static void test_read_events(struct event_test_ctx
*ctx
)
4999 SOCKET server
, client
;
5004 tcp_socketpair(&client
, &server
);
5005 set_blocking(client
, FALSE
);
5007 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5008 check_events(ctx
, 0, 0, 0);
5010 ret
= send(client
, "data", 5, 0);
5011 ok(ret
== 5, "got %d\n", ret
);
5013 check_events(ctx
, FD_READ
, 0, 200);
5014 check_events(ctx
, 0, 0, 0);
5015 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5016 if (ctx
->is_message
)
5017 check_events(ctx
, FD_READ
, 0, 200);
5018 check_events(ctx
, 0, 0, 0);
5019 select_events(ctx
, server
, 0);
5020 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5021 if (ctx
->is_message
)
5022 check_events(ctx
, FD_READ
, 0, 200);
5023 check_events(ctx
, 0, 0, 0);
5025 ret
= send(client
, "data", 5, 0);
5026 ok(ret
== 5, "got %d\n", ret
);
5028 if (!ctx
->is_message
)
5029 check_events_todo(ctx
, FD_READ
, 0, 200);
5030 check_events(ctx
, 0, 0, 0);
5032 ret
= recv(server
, buffer
, 2, 0);
5033 ok(ret
== 2, "got %d\n", ret
);
5035 check_events(ctx
, FD_READ
, 0, 200);
5036 check_events(ctx
, 0, 0, 0);
5038 ret
= recv(server
, buffer
, -1, 0);
5039 ok(ret
== -1, "got %d\n", ret
);
5040 ok(WSAGetLastError() == WSAEFAULT
|| WSAGetLastError() == WSAENOBUFS
/* < Windows 7 */,
5041 "got error %u\n", WSAGetLastError());
5043 if (ctx
->is_message
)
5044 check_events_todo_msg(ctx
, FD_READ
, 0, 200);
5045 check_events(ctx
, 0, 0, 0);
5047 for (i
= 0; i
< 8; ++i
)
5049 ret
= sync_recv(server
, buffer
, 1, 0);
5050 ok(ret
== 1, "got %d\n", ret
);
5053 check_events(ctx
, FD_READ
, 0, 200);
5054 check_events(ctx
, 0, 0, 0);
5057 /* Send data while we're not selecting. */
5059 select_events(ctx
, server
, 0);
5060 ret
= send(client
, "data", 5, 0);
5061 ok(ret
== 5, "got %d\n", ret
);
5062 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5064 check_events(ctx
, FD_READ
, 0, 200);
5066 ret
= recv(server
, buffer
, 5, 0);
5067 ok(ret
== 5, "got %d\n", ret
);
5069 select_events(ctx
, server
, 0);
5070 ret
= send(client
, "data", 5, 0);
5071 ok(ret
== 5, "got %d\n", ret
);
5072 ret
= sync_recv(server
, buffer
, 5, 0);
5073 ok(ret
== 5, "got %d\n", ret
);
5074 select_events(ctx
, server
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
);
5076 check_events(ctx
, 0, 0, 200);
5078 closesocket(server
);
5079 closesocket(client
);
5082 static void test_oob_events(struct event_test_ctx
*ctx
)
5084 SOCKET server
, client
;
5088 tcp_socketpair(&client
, &server
);
5089 set_blocking(client
, FALSE
);
5091 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5092 check_events(ctx
, 0, 0, 0);
5094 ret
= send(client
, "a", 1, MSG_OOB
);
5095 ok(ret
== 1, "got %d\n", ret
);
5097 check_events(ctx
, FD_OOB
, 0, 200);
5098 check_events(ctx
, 0, 0, 0);
5099 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5100 if (ctx
->is_message
)
5101 check_events(ctx
, FD_OOB
, 0, 200);
5102 check_events(ctx
, 0, 0, 0);
5103 select_events(ctx
, server
, 0);
5104 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5105 if (ctx
->is_message
)
5106 check_events(ctx
, FD_OOB
, 0, 200);
5107 check_events(ctx
, 0, 0, 0);
5109 ret
= send(client
, "b", 1, MSG_OOB
);
5110 ok(ret
== 1, "got %d\n", ret
);
5112 if (!ctx
->is_message
)
5113 check_events_todo_event(ctx
, FD_OOB
, 0, 200);
5114 check_events(ctx
, 0, 0, 0);
5116 ret
= recv(server
, buffer
, 1, MSG_OOB
);
5117 ok(ret
== 1, "got %d\n", ret
);
5119 check_events_todo(ctx
, FD_OOB
, 0, 200);
5120 check_events(ctx
, 0, 0, 0);
5122 ret
= recv(server
, buffer
, 1, MSG_OOB
);
5123 todo_wine
ok(ret
== 1, "got %d\n", ret
);
5125 check_events(ctx
, 0, 0, 0);
5127 /* Send data while we're not selecting. */
5129 select_events(ctx
, server
, 0);
5130 ret
= send(client
, "a", 1, MSG_OOB
);
5131 ok(ret
== 1, "got %d\n", ret
);
5132 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5134 check_events(ctx
, FD_OOB
, 0, 200);
5136 ret
= recv(server
, buffer
, 1, MSG_OOB
);
5137 ok(ret
== 1, "got %d\n", ret
);
5139 closesocket(server
);
5140 closesocket(client
);
5143 static void test_close_events(struct event_test_ctx
*ctx
)
5145 SOCKET server
, client
;
5149 /* Test closesocket(). */
5151 tcp_socketpair(&client
, &server
);
5153 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5155 closesocket(client
);
5157 check_events(ctx
, FD_CLOSE
, 0, 200);
5158 check_events(ctx
, 0, 0, 0);
5159 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5160 if (ctx
->is_message
)
5161 check_events(ctx
, FD_CLOSE
, 0, 200);
5162 check_events(ctx
, 0, 0, 0);
5163 select_events(ctx
, server
, 0);
5164 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5165 if (ctx
->is_message
)
5166 check_events(ctx
, FD_CLOSE
, 0, 200);
5167 check_events(ctx
, 0, 0, 0);
5169 ret
= recv(server
, buffer
, 5, 0);
5170 ok(!ret
, "got %d\n", ret
);
5172 check_events(ctx
, 0, 0, 0);
5174 closesocket(server
);
5176 /* Test shutdown(remote end, SD_SEND). */
5178 tcp_socketpair(&client
, &server
);
5180 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5182 shutdown(client
, SD_SEND
);
5184 check_events(ctx
, FD_CLOSE
, 0, 200);
5185 check_events(ctx
, 0, 0, 0);
5187 closesocket(client
);
5189 check_events(ctx
, 0, 0, 0);
5191 closesocket(server
);
5193 /* No other shutdown() call generates an event. */
5195 tcp_socketpair(&client
, &server
);
5197 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5199 shutdown(client
, SD_RECEIVE
);
5200 shutdown(server
, SD_BOTH
);
5202 check_events(ctx
, 0, 0, 200);
5204 shutdown(client
, SD_SEND
);
5206 check_events_todo(ctx
, FD_CLOSE
, 0, 200);
5207 check_events(ctx
, 0, 0, 0);
5209 closesocket(server
);
5210 closesocket(client
);
5212 /* Test sending data before calling closesocket(). */
5214 tcp_socketpair(&client
, &server
);
5216 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5218 ret
= send(client
, "data", 5, 0);
5219 ok(ret
== 5, "got %d\n", ret
);
5221 check_events(ctx
, FD_READ
, 0, 200);
5223 closesocket(client
);
5225 check_events_todo(ctx
, FD_CLOSE
, 0, 200);
5227 ret
= recv(server
, buffer
, 3, 0);
5228 ok(ret
== 3, "got %d\n", ret
);
5230 check_events(ctx
, FD_READ
, 0, 200);
5232 ret
= recv(server
, buffer
, 5, 0);
5233 ok(ret
== 2, "got %d\n", ret
);
5235 check_events_todo(ctx
, 0, 0, 0);
5237 closesocket(server
);
5239 /* Close and then select. */
5241 tcp_socketpair(&client
, &server
);
5242 closesocket(client
);
5244 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5245 check_events(ctx
, FD_CLOSE
, 0, 200);
5247 closesocket(server
);
5249 /* As above, but select on a subset not containing FD_CLOSE first. */
5251 tcp_socketpair(&client
, &server
);
5253 select_events(ctx
, server
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
);
5255 closesocket(client
);
5257 check_events(ctx
, 0, 0, 200);
5258 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5259 check_events_todo_event(ctx
, FD_CLOSE
, 0, 200);
5261 closesocket(server
);
5264 static void test_events(void)
5266 struct event_test_ctx ctx
;
5268 ctx
.is_message
= FALSE
;
5269 ctx
.event
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
5271 test_accept_events(&ctx
);
5272 test_connect_events(&ctx
);
5273 test_write_events(&ctx
);
5274 test_read_events(&ctx
);
5275 test_close_events(&ctx
);
5276 test_oob_events(&ctx
);
5278 CloseHandle(ctx
.event
);
5280 ctx
.is_message
= TRUE
;
5281 ctx
.window
= CreateWindowA("Message", NULL
, 0, 0, 0, 0, 0, HWND_MESSAGE
, NULL
, NULL
, NULL
);
5283 test_accept_events(&ctx
);
5284 test_connect_events(&ctx
);
5285 test_write_events(&ctx
);
5286 test_read_events(&ctx
);
5287 test_close_events(&ctx
);
5288 test_oob_events(&ctx
);
5290 DestroyWindow(ctx
.window
);
5293 static void test_ipv6only(void)
5295 SOCKET v4
= INVALID_SOCKET
, v6
;
5296 struct sockaddr_in sin4
;
5297 struct sockaddr_in6 sin6
;
5298 int ret
, enabled
, len
= sizeof(enabled
);
5300 memset(&sin4
, 0, sizeof(sin4
));
5301 sin4
.sin_family
= AF_INET
;
5302 sin4
.sin_port
= htons(SERVERPORT
);
5304 memset(&sin6
, 0, sizeof(sin6
));
5305 sin6
.sin6_family
= AF_INET6
;
5306 sin6
.sin6_port
= htons(SERVERPORT
);
5308 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
5309 if (v6
== INVALID_SOCKET
)
5311 skip("Could not create IPv6 socket (LastError: %d)\n", WSAGetLastError());
5316 ret
= getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
5317 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5318 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
5320 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
5321 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
5323 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5324 ok(v4
!= INVALID_SOCKET
, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
5328 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
5329 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5330 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
5334 len
= sizeof(enabled
);
5335 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
5336 ok(!ret
, "setsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5340 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
5341 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5342 ok(!enabled
, "expected 0, got %d\n", enabled
);
5346 len
= sizeof(enabled
);
5347 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
5348 ok(!ret
, "setsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5350 /* bind on IPv4 socket should succeed - IPV6_V6ONLY is enabled by default */
5351 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
5352 ok(!ret
, "Could not bind IPv4 address (LastError: %d)\n", WSAGetLastError());
5356 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
5357 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5358 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
5362 len
= sizeof(enabled
);
5363 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
5364 ok(ret
, "setsockopt(IPV6_ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
5368 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
5369 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5370 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
5374 len
= sizeof(enabled
);
5375 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
5376 ok(ret
, "setsockopt(IPV6_ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
5381 /* Test again, this time disabling IPV6_V6ONLY. */
5382 sin4
.sin_port
= htons(SERVERPORT
+2);
5383 sin6
.sin6_port
= htons(SERVERPORT
+2);
5385 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
5386 ok(v6
!= INVALID_SOCKET
, "Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
5387 WSAGetLastError(), WSAEAFNOSUPPORT
);
5390 ret
= setsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
5391 ok(!ret
, "Could not disable IPV6_V6ONLY (LastError: %d).\n", WSAGetLastError());
5394 ret
= getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
5395 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5396 ok(!enabled
, "expected 0, got %d\n", enabled
);
5400 On Windows, bind on both IPv4 and IPv6 with IPV6_V6ONLY disabled succeeds by default.
5401 Application must set SO_EXCLUSIVEADDRUSE on first socket to disallow another successful bind.
5402 In general, a standard application should not use SO_REUSEADDR.
5403 Setting both SO_EXCLUSIVEADDRUSE and SO_REUSEADDR on the same socket is not possible in
5404 either order, the later setsockopt call always fails.
5407 ret
= setsockopt(v6
, SOL_SOCKET
, SO_EXCLUSIVEADDRUSE
, (char*)&enabled
, len
);
5408 ok(!ret
, "Could not set SO_EXCLUSIVEADDRUSE on IPv6 socket (LastError: %d)\n", WSAGetLastError());
5410 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
5411 ok(!ret
, "Could not bind IPv6 address (LastError: %d)\n", WSAGetLastError());
5414 len
= sizeof(enabled
);
5415 getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
5416 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5417 ok(!enabled
, "IPV6_V6ONLY is enabled after bind\n");
5419 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5420 ok(v4
!= INVALID_SOCKET
, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
5423 ret
= setsockopt(v4
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&enabled
, len
);
5424 ok(!ret
, "Could not set SO_REUSEADDR on IPv4 socket (LastError: %d)\n", WSAGetLastError());
5426 WSASetLastError(0xdeadbeef);
5427 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
5428 ok(ret
, "bind succeeded unexpectedly for the IPv4 socket\n");
5429 ok(WSAGetLastError() == WSAEACCES
, "Expected 10013, got %d\n", WSAGetLastError());
5432 if (v4
!= INVALID_SOCKET
)
5434 if (v6
!= INVALID_SOCKET
)
5438 static void test_WSASendMsg(void)
5441 struct sockaddr_in sendaddr
, sockaddr
;
5442 GUID WSASendMsg_GUID
= WSAID_WSASENDMSG
;
5443 LPFN_WSASENDMSG pWSASendMsg
= NULL
;
5444 char teststr
[12] = "hello world", buffer
[32];
5447 DWORD bytesSent
, err
;
5450 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
5452 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
5453 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5455 /* Obtain the WSASendMsg function */
5456 WSAIoctl(sock
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSASendMsg_GUID
, sizeof(WSASendMsg_GUID
),
5457 &pWSASendMsg
, sizeof(pWSASendMsg
), &err
, NULL
, NULL
);
5461 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
5465 /* fake address for now */
5466 sendaddr
.sin_family
= AF_INET
;
5467 sendaddr
.sin_port
= htons(139);
5468 sendaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5470 memset(&msg
, 0, sizeof(msg
));
5471 iovec
[0].buf
= teststr
;
5472 iovec
[0].len
= sizeof(teststr
);
5473 iovec
[1].buf
= teststr
;
5474 iovec
[1].len
= sizeof(teststr
) / 2;
5475 msg
.name
= (struct sockaddr
*) &sendaddr
;
5476 msg
.namelen
= sizeof(sendaddr
);
5477 msg
.lpBuffers
= iovec
;
5478 msg
.dwBufferCount
= 1; /* send only one buffer for now */
5480 WSASetLastError(0xdeadbeef);
5481 ret
= pWSASendMsg(INVALID_SOCKET
, &msg
, 0, NULL
, NULL
, NULL
);
5482 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5483 err
= WSAGetLastError();
5484 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
5486 WSASetLastError(0xdeadbeef);
5487 ret
= pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
);
5488 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5489 err
= WSAGetLastError();
5490 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
5492 WSASetLastError(0xdeadbeef);
5493 ret
= pWSASendMsg(sock
, NULL
, 0, &bytesSent
, NULL
, NULL
);
5494 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5495 err
= WSAGetLastError();
5496 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
5498 WSASetLastError(0xdeadbeef);
5499 ret
= pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
);
5500 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5501 err
= WSAGetLastError();
5502 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
5506 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
5507 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5509 dst
= socket(AF_INET
, SOCK_DGRAM
, 0);
5510 ok(dst
!= INVALID_SOCKET
, "socket() failed\n");
5512 memset(&sockaddr
, 0, sizeof(sockaddr
));
5513 sockaddr
.sin_family
= AF_INET
;
5514 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5515 ok(!bind(dst
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
)),
5516 "bind should have worked\n");
5518 /* read address to find out the port number to be used in send */
5519 memset(&sendaddr
, 0, sizeof(sendaddr
));
5520 addrlen
= sizeof(sendaddr
);
5521 ok(!getsockname(dst
, (struct sockaddr
*) &sendaddr
, &addrlen
),
5522 "getsockname should have worked\n");
5523 ok(sendaddr
.sin_port
, "socket port should be != 0\n");
5525 /* ensure the sending socket is not bound */
5526 WSASetLastError(0xdeadbeef);
5527 addrlen
= sizeof(sockaddr
);
5528 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
5529 ok(ret
== SOCKET_ERROR
, "getsockname should have failed\n");
5530 err
= WSAGetLastError();
5531 ok(err
== WSAEINVAL
, "expected 10022, got %d instead\n", err
);
5533 set_blocking(sock
, TRUE
);
5536 SetLastError(0xdeadbeef);
5537 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
5538 ok(!ret
, "WSASendMsg should have worked\n");
5539 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
5540 "Expected 0, got %d\n", GetLastError());
5541 ok(bytesSent
== iovec
[0].len
, "incorrect bytes sent, expected %d, sent %d\n",
5542 iovec
[0].len
, bytesSent
);
5545 addrlen
= sizeof(sockaddr
);
5546 memset(buffer
, 0, sizeof(buffer
));
5547 SetLastError(0xdeadbeef);
5548 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
5549 ok(ret
== bytesSent
, "got %d, expected %d\n",
5551 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5553 /* A successful call to WSASendMsg must have bound the socket */
5554 addrlen
= sizeof(sockaddr
);
5555 sockaddr
.sin_port
= 0;
5556 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5557 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
5558 ok(!ret
, "getsockname should have worked\n");
5559 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
5560 inet_ntoa(sockaddr
.sin_addr
));
5561 ok(sockaddr
.sin_port
, "sin_port should be != 0\n");
5563 msg
.dwBufferCount
= 2; /* send both buffers */
5566 SetLastError(0xdeadbeef);
5567 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
5568 ok(!ret
, "WSASendMsg should have worked\n");
5569 ok(bytesSent
== iovec
[0].len
+ iovec
[1].len
, "incorrect bytes sent, expected %d, sent %d\n",
5570 iovec
[0].len
+ iovec
[1].len
, bytesSent
);
5571 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
5572 "Expected 0, got %d\n", GetLastError());
5575 addrlen
= sizeof(sockaddr
);
5576 memset(buffer
, 0, sizeof(buffer
));
5577 SetLastError(0xdeadbeef);
5578 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
5579 ok(ret
== bytesSent
, "got %d, expected %d\n",
5581 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5586 /* a bad call to WSASendMsg will also bind the socket */
5587 addrlen
= sizeof(sockaddr
);
5588 sockaddr
.sin_port
= 0;
5589 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5590 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
5591 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5592 ok(pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
5594 ok(!getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have worked\n");
5595 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
5596 inet_ntoa(sockaddr
.sin_addr
));
5597 ok(sockaddr
.sin_port
, "sin_port should be > 0\n");
5601 /* a bad call without msg parameter will not trigger the auto-bind */
5602 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
5603 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5604 ok(pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
5605 ok(getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have failed\n");
5606 err
= WSAGetLastError();
5607 ok(err
== WSAEINVAL
, "expected 10022, got %d instead\n", err
);
5610 /* SOCK_STREAM sockets are not supported */
5612 sock
= socket(AF_INET
, SOCK_STREAM
, 0);
5613 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5614 SetLastError(0xdeadbeef);
5615 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
5616 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5617 err
= WSAGetLastError();
5619 ok(err
== WSAEINVAL
, "expected 10014, got %d instead\n", err
);
5623 static void test_WSASendTo(void)
5626 struct sockaddr_in addr
, ret_addr
;
5627 char buf
[12] = "hello world";
5632 addr
.sin_family
= AF_INET
;
5633 addr
.sin_port
= htons(139);
5634 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5635 data_buf
.len
= sizeof(buf
);
5638 s
= socket(AF_INET
, SOCK_DGRAM
, 0);
5639 ok(s
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
5641 WSASetLastError(12345);
5642 ret
= WSASendTo(INVALID_SOCKET
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
5643 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
5644 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
5646 len
= sizeof(ret_addr
);
5647 ret
= getsockname(s
, (struct sockaddr
*)&ret_addr
, &len
);
5648 ok(ret
== -1, "expected failure\n");
5649 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
5651 WSASetLastError(12345);
5652 ret
= WSASendTo(s
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
5653 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
5654 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
5656 WSASetLastError(12345);
5657 ret
= WSASendTo(s
, &data_buf
, 1, &bytesSent
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
5658 ok(!ret
, "expected success\n");
5659 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5661 len
= sizeof(ret_addr
);
5662 ret
= getsockname(s
, (struct sockaddr
*)&ret_addr
, &len
);
5663 ok(!ret
, "got error %u\n", WSAGetLastError());
5664 ok(ret_addr
.sin_family
== AF_INET
, "got family %u\n", ret_addr
.sin_family
);
5665 ok(ret_addr
.sin_port
, "expected nonzero port\n");
5668 static DWORD WINAPI
recv_thread(LPVOID arg
)
5670 SOCKET sock
= *(SOCKET
*)arg
;
5677 wsa
.len
= sizeof(buffer
);
5678 ov
.hEvent
= WSACreateEvent();
5679 WSARecv(sock
, &wsa
, 1, NULL
, &flags
, &ov
, NULL
);
5681 WaitForSingleObject(ov
.hEvent
, 1000);
5682 WSACloseEvent(ov
.hEvent
);
5686 static int completion_called
;
5688 static void WINAPI
io_completion(DWORD error
, DWORD transferred
, WSAOVERLAPPED
*overlapped
, DWORD flags
)
5690 completion_called
++;
5693 static void test_WSARecv(void)
5695 SOCKET src
, dest
, server
= INVALID_SOCKET
;
5699 DWORD bytesReturned
, flags
, id
;
5701 struct sockaddr_in addr
;
5705 HANDLE thread
, event
= NULL
, io_port
;
5707 tcp_socketpair(&src
, &dest
);
5709 memset(&ov
, 0, sizeof(ov
));
5714 /* Send 4 bytes and receive in two calls of 2 */
5715 SetLastError(0xdeadbeef);
5716 iret
= send(src
, "test", 4, 0);
5717 ok(iret
== 4, "Expected 4, got %d\n", iret
);
5718 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5719 SetLastError(0xdeadbeef);
5720 bytesReturned
= 0xdeadbeef;
5721 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
5722 ok(!iret
, "Expected 0, got %d\n", iret
);
5723 ok(bytesReturned
== 2, "Expected 2, got %d\n", bytesReturned
);
5724 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5725 SetLastError(0xdeadbeef);
5726 bytesReturned
= 0xdeadbeef;
5727 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
5728 ok(!iret
, "Expected 0, got %d\n", iret
);
5729 ok(bytesReturned
== 2, "Expected 2, got %d\n", bytesReturned
);
5730 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5733 SetLastError(0xdeadbeef);
5734 iret
= send(src
, "test", 4, 0);
5735 ok(iret
== 4, "Expected 4, got %d\n", iret
);
5736 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5737 SetLastError(0xdeadbeef);
5738 bytesReturned
= 0xdeadbeef;
5739 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
5740 ok(!iret
, "Expected 0, got %d\n", iret
);
5741 ok(bytesReturned
== 4, "Expected 4, got %d\n", bytesReturned
);
5742 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5744 /* Test 2 buffers */
5747 bufs
[1].buf
= buf
+ 10;
5748 SetLastError(0xdeadbeef);
5749 iret
= send(src
, "deadbeefs", 9, 0);
5750 ok(iret
== 9, "Expected 9, got %d\n", iret
);
5751 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5752 SetLastError(0xdeadbeef);
5753 bytesReturned
= 0xdeadbeef;
5754 iret
= WSARecv(dest
, bufs
, 2, &bytesReturned
, &flags
, NULL
, NULL
);
5755 ok(!iret
, "Expected 0, got %d\n", iret
);
5756 ok(bytesReturned
== 9, "Expected 9, got %d\n", bytesReturned
);
5757 bufs
[0].buf
[4] = '\0';
5758 bufs
[1].buf
[5] = '\0';
5759 ok(!strcmp(bufs
[0].buf
, "dead"), "buf[0] doesn't match: %s != dead\n", bufs
[0].buf
);
5760 ok(!strcmp(bufs
[1].buf
, "beefs"), "buf[1] doesn't match: %s != beefs\n", bufs
[1].buf
);
5761 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5763 bufs
[0].len
= sizeof(buf
);
5764 ov
.hEvent
= event
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5765 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
5771 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
5772 ok(!iret
, "Failed to set linger %d\n", GetLastError());
5774 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, NULL
);
5775 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
5777 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
5778 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
5781 src
= INVALID_SOCKET
;
5783 dwret
= WaitForSingleObject(ov
.hEvent
, 1000);
5784 ok(dwret
== WAIT_OBJECT_0
, "Waiting for disconnect event failed with %d + errno %d\n", dwret
, GetLastError());
5786 bret
= GetOverlappedResult((HANDLE
)dest
, &ov
, &bytesReturned
, FALSE
);
5787 todo_wine
ok(!bret
, "expected failure\n");
5788 todo_wine
ok(GetLastError() == ERROR_NETNAME_DELETED
, "got error %u\n", GetLastError());
5789 ok(bytesReturned
== 0, "Bytes received is %d\n", bytesReturned
);
5791 dest
= INVALID_SOCKET
;
5793 src
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
5794 ok(src
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
5795 if (src
== INVALID_SOCKET
) goto end
;
5797 server
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
5798 ok(server
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
5799 if (server
== INVALID_SOCKET
) goto end
;
5801 memset(&addr
, 0, sizeof(addr
));
5802 addr
.sin_family
= AF_INET
;
5803 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5804 iret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
5805 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
5808 iret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
5809 ok(!iret
, "failed to get address, error %u\n", WSAGetLastError());
5811 iret
= listen(server
, 1);
5812 ok(!iret
, "failed to listen, error %u\n", WSAGetLastError());
5814 iret
= connect(src
, (struct sockaddr
*)&addr
, sizeof(addr
));
5815 ok(!iret
, "failed to connect, error %u\n", WSAGetLastError());
5818 dest
= accept(server
, (struct sockaddr
*)&addr
, &len
);
5819 ok(dest
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
5820 if (dest
== INVALID_SOCKET
) goto end
;
5822 send(src
, "test message", sizeof("test message"), 0);
5823 thread
= CreateThread(NULL
, 0, recv_thread
, &dest
, 0, &id
);
5824 WaitForSingleObject(thread
, 3000);
5825 CloseHandle(thread
);
5827 memset(&ov
, 0, sizeof(ov
));
5830 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, io_completion
);
5831 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
5832 send(src
, "test message", sizeof("test message"), 0);
5834 completion_called
= 0;
5835 dwret
= SleepEx(1000, TRUE
);
5836 ok(dwret
== WAIT_IO_COMPLETION
, "got %u\n", dwret
);
5837 ok(completion_called
== 1, "completion not called\n");
5839 dwret
= WaitForSingleObject(event
, 1);
5840 ok(dwret
== WAIT_TIMEOUT
, "got %u\n", dwret
);
5842 io_port
= CreateIoCompletionPort( (HANDLE
)dest
, NULL
, 0, 0 );
5843 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
5845 /* Using completion function on socket associated with completion port is not allowed. */
5846 memset(&ov
, 0, sizeof(ov
));
5847 completion_called
= 0;
5848 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, io_completion
);
5849 ok(iret
== SOCKET_ERROR
&& GetLastError() == WSAEINVAL
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
5850 ok(!completion_called
, "completion called\n");
5852 CloseHandle(io_port
);
5855 if (server
!= INVALID_SOCKET
)
5856 closesocket(server
);
5857 if (dest
!= INVALID_SOCKET
)
5859 if (src
!= INVALID_SOCKET
)
5862 WSACloseEvent(event
);
5865 struct write_watch_thread_args
5874 static DWORD CALLBACK
write_watch_thread( void *arg
)
5876 struct write_watch_thread_args
*args
= arg
;
5877 struct sockaddr addr
;
5878 int addr_len
= sizeof(addr
), ret
;
5879 DWORD bytes
, flags
= 0;
5885 ret
= recv( args
->dest
, args
->base
, args
->size
, 0 );
5886 ok( ret
== strlen(args
->expect
) + 1, "wrong len %d\n", ret
);
5887 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
5890 ret
= recvfrom( args
->dest
, args
->base
, args
->size
, 0, &addr
, &addr_len
);
5891 ok( ret
== strlen(args
->expect
) + 1, "wrong len %d\n", ret
);
5892 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
5895 buf
[0].len
= args
->size
;
5896 buf
[0].buf
= args
->base
;
5897 ret
= WSARecv( args
->dest
, buf
, 1, &bytes
, &flags
, NULL
, NULL
);
5898 ok( !ret
, "WSARecv failed %u\n", GetLastError() );
5899 ok( bytes
== strlen(args
->expect
) + 1, "wrong len %d\n", bytes
);
5900 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
5903 buf
[0].len
= args
->size
;
5904 buf
[0].buf
= args
->base
;
5905 ret
= WSARecvFrom( args
->dest
, buf
, 1, &bytes
, &flags
, &addr
, &addr_len
, NULL
, NULL
);
5906 ok( !ret
, "WSARecvFrom failed %u\n", GetLastError() );
5907 ok( bytes
== strlen(args
->expect
) + 1, "wrong len %d\n", bytes
);
5908 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
5914 static void test_write_watch(void)
5919 struct write_watch_thread_args args
;
5920 DWORD bytesReturned
, flags
, size
;
5921 struct sockaddr addr
;
5923 HANDLE thread
, event
;
5928 UINT (WINAPI
*pGetWriteWatch
)(DWORD
,LPVOID
,SIZE_T
,LPVOID
*,ULONG_PTR
*,ULONG
*);
5930 pGetWriteWatch
= (void *)GetProcAddress( GetModuleHandleA("kernel32.dll"), "GetWriteWatch" );
5931 if (!pGetWriteWatch
)
5933 win_skip( "write watched not supported\n" );
5937 tcp_socketpair(&src
, &dest
);
5939 memset(&ov
, 0, sizeof(ov
));
5940 ov
.hEvent
= event
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5941 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
5946 base
= VirtualAlloc( 0, size
, MEM_RESERVE
| MEM_COMMIT
| MEM_WRITE_WATCH
, PAGE_READWRITE
);
5947 ok( base
!= NULL
, "VirtualAlloc failed %u\n", GetLastError() );
5949 memset( base
, 0, size
);
5951 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
5952 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
5953 ok( count
== 16, "wrong count %lu\n", count
);
5957 bufs
[1].len
= 0x8000;
5958 bufs
[1].buf
= base
+ 0x4000;
5960 ret
= WSARecv( dest
, bufs
, 2, NULL
, &flags
, &ov
, NULL
);
5961 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
5962 "WSARecv failed - %d error %d\n", ret
, GetLastError());
5965 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
5966 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
5967 ok( count
== 9, "wrong count %lu\n", count
);
5968 ok( !base
[0], "data set\n" );
5970 send(src
, "test message", sizeof("test message"), 0);
5972 ret
= GetOverlappedResult( (HANDLE
)dest
, &ov
, &bytesReturned
, TRUE
);
5973 ok( ret
, "GetOverlappedResult failed %u\n", GetLastError() );
5974 ok( bytesReturned
== sizeof("test message"), "wrong size %u\n", bytesReturned
);
5975 ok( !memcmp( base
, "test ", 5 ), "wrong data %s\n", base
);
5976 ok( !memcmp( base
+ 0x4000, "message", 8 ), "wrong data %s\n", base
+ 0x4000 );
5979 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
5980 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
5981 ok( count
== 0, "wrong count %lu\n", count
);
5983 memset( base
, 0, size
);
5985 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
5986 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
5987 ok( count
== 16, "wrong count %lu\n", count
);
5989 bufs
[1].len
= 0x4000;
5990 bufs
[1].buf
= base
+ 0x2000;
5991 ret
= WSARecvFrom( dest
, bufs
, 2, NULL
, &flags
, &addr
, &addr_len
, &ov
, NULL
);
5992 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
5993 "WSARecv failed - %d error %d\n", ret
, GetLastError());
5996 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
5997 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
5998 ok( count
== 5, "wrong count %lu\n", count
);
5999 ok( !base
[0], "data set\n" );
6001 send(src
, "test message", sizeof("test message"), 0);
6003 ret
= GetOverlappedResult( (HANDLE
)dest
, &ov
, &bytesReturned
, TRUE
);
6004 ok( ret
, "GetOverlappedResult failed %u\n", GetLastError() );
6005 ok( bytesReturned
== sizeof("test message"), "wrong size %u\n", bytesReturned
);
6006 ok( !memcmp( base
, "test ", 5 ), "wrong data %s\n", base
);
6007 ok( !memcmp( base
+ 0x2000, "message", 8 ), "wrong data %s\n", base
+ 0x2000 );
6010 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6011 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6012 ok( count
== 0, "wrong count %lu\n", count
);
6014 memset( base
, 0, size
);
6016 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6017 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6018 ok( count
== 16, "wrong count %lu\n", count
);
6023 args
.expect
= "test message";
6024 for (args
.func
= 0; args
.func
< 4; args
.func
++)
6026 thread
= CreateThread( NULL
, 0, write_watch_thread
, &args
, 0, NULL
);
6030 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6031 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6032 ok( count
== 8, "wrong count %lu\n", count
);
6034 send(src
, "test message", sizeof("test message"), 0);
6035 WaitForSingleObject( thread
, 10000 );
6036 CloseHandle( thread
);
6039 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6040 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6041 ok( count
== 0, "wrong count %lu\n", count
);
6043 WSACloseEvent( event
);
6044 closesocket( dest
);
6046 VirtualFree( base
, 0, MEM_FREE
);
6049 static void test_WSAPoll(void)
6051 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
6053 SOCKET listener
, server
, client
;
6054 struct sockaddr_in address
;
6056 HANDLE thread_handle
;
6060 static const short invalid_flags
[] =
6061 {POLLERR
, POLLHUP
, POLLNVAL
, 0x8, POLLWRBAND
, 0x40, 0x80, POLLPRI
, 0x800, 0x1000, 0x2000, 0x4000, 0x8000};
6063 if (!pWSAPoll
) /* >= Vista */
6065 win_skip("WSAPoll is unsupported, some tests will be skipped.\n");
6069 /* Invalid parameters test */
6070 SetLastError(0xdeadbeef);
6071 ret
= pWSAPoll(NULL
, 0, 0);
6072 err
= GetLastError();
6073 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6074 ok(err
== WSAEINVAL
, "expected 10022, got %d\n", err
);
6075 SetLastError(0xdeadbeef);
6076 ret
= pWSAPoll(NULL
, 1, 0);
6077 err
= GetLastError();
6078 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6079 ok(err
== WSAEFAULT
, "expected 10014, got %d\n", err
);
6080 SetLastError(0xdeadbeef);
6081 ret
= pWSAPoll(NULL
, 0, 1);
6082 err
= GetLastError();
6083 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6084 ok(err
== WSAEINVAL
, "expected 10022, got %d\n", err
);
6085 SetLastError(0xdeadbeef);
6086 ret
= pWSAPoll(NULL
, 1, 1);
6087 err
= GetLastError();
6088 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6089 ok(err
== WSAEFAULT
, "expected 10014, got %d\n", err
);
6091 memset(&address
, 0, sizeof(address
));
6092 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6093 address
.sin_family
= AF_INET
;
6094 len
= sizeof(address
);
6095 listener
= setup_server_socket(&address
, &len
);
6097 for (i
= 0; i
< ARRAY_SIZE(invalid_flags
); ++i
)
6099 fds
[0].fd
= listener
;
6100 fds
[0].events
= invalid_flags
[i
];
6101 fds
[0].revents
= 0xdead;
6102 WSASetLastError(0xdeadbeef);
6103 ret
= pWSAPoll(fds
, 1, 0);
6104 todo_wine
ok(ret
== -1, "got %d\n", ret
);
6105 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6108 /* When no events are pending poll returns 0 with no error */
6109 fds
[0].fd
= listener
;
6110 fds
[0].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
6111 fds
[0].revents
= 0xdead;
6112 ret
= pWSAPoll(fds
, 1, 0);
6113 ok(ret
== 0, "got %d\n", ret
);
6114 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
6117 fds
[0].events
= POLLERR
;
6118 fds
[0].revents
= 0xdead;
6119 fds
[1].fd
= listener
;
6120 fds
[1].events
= POLLIN
;
6121 fds
[1].revents
= 0xdead;
6122 WSASetLastError(0xdeadbeef);
6123 ret
= pWSAPoll(fds
, 2, 0);
6124 ok(!ret
, "got %d\n", ret
);
6125 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
6126 ok(fds
[0].revents
== POLLNVAL
, "got events %#x\n", fds
[0].revents
);
6127 ok(!fds
[1].revents
, "got events %#x\n", fds
[1].revents
);
6129 fds
[0].fd
= listener
;
6130 fds
[0].events
= POLLIN
;
6131 fds
[0].revents
= 0xdead;
6132 fds
[1].fd
= 0xabacab;
6133 fds
[1].events
= POLLIN
;
6134 fds
[1].revents
= 0xdead;
6135 WSASetLastError(0xdeadbeef);
6136 ret
= pWSAPoll(fds
, 2, 0);
6137 ok(!ret
, "got %d\n", ret
);
6138 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
6139 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
6140 ok(fds
[1].revents
== POLLNVAL
, "got events %#x\n", fds
[1].revents
);
6142 fds
[0].fd
= listener
;
6143 fds
[0].events
= POLLIN
;
6144 fds
[0].revents
= 0xdead;
6145 fds
[1].fd
= 0xabacab;
6146 fds
[1].events
= POLLERR
;
6147 fds
[1].revents
= 0xdead;
6148 WSASetLastError(0xdeadbeef);
6149 ret
= pWSAPoll(fds
, 2, 0);
6150 todo_wine
ok(ret
== -1, "got %d\n", ret
);
6151 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6152 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
6153 todo_wine
ok(!fds
[1].revents
, "got events %#x\n", fds
[1].revents
);
6156 fds
[0].events
= POLLERR
;
6157 fds
[0].revents
= 0xdead;
6158 fds
[1].fd
= 0xabacab;
6159 fds
[1].events
= POLLERR
;
6160 fds
[1].revents
= 0xdead;
6161 WSASetLastError(0xdeadbeef);
6162 ret
= pWSAPoll(fds
, 2, 0);
6163 ok(ret
== -1, "got %d\n", ret
);
6164 ok(WSAGetLastError() == WSAENOTSOCK
, "got error %u\n", WSAGetLastError());
6165 ok(fds
[0].revents
== POLLNVAL
, "got events %#x\n", fds
[0].revents
);
6166 ok(fds
[1].revents
== POLLNVAL
, "got events %#x\n", fds
[1].revents
);
6168 /* Test listening socket connection attempt notifications */
6169 client
= setup_connector_socket(&address
, len
, TRUE
);
6171 fds
[0].fd
= listener
;
6172 fds
[0].events
= POLLIN
;
6173 fds
[0].revents
= 0xdead;
6174 ret
= pWSAPoll(fds
, 1, 100);
6175 ok(ret
== 1, "got %d\n", ret
);
6176 ok(fds
[0].revents
== POLLRDNORM
, "got events %#x\n", fds
[0].revents
);
6178 fds
[0].revents
= 0xdead;
6179 ret
= pWSAPoll(fds
, 1, 0);
6180 ok(ret
== 1, "got %d\n", ret
);
6181 ok(fds
[0].revents
== POLLRDNORM
, "got events %#x\n", fds
[0].revents
);
6183 fds
[0].events
= POLLRDBAND
| POLLWRNORM
;
6184 fds
[0].revents
= 0xdead;
6185 ret
= pWSAPoll(fds
, 1, 0);
6186 ok(ret
== 0, "got %d\n", ret
);
6187 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
6189 server
= accept(listener
, NULL
, NULL
);
6190 ok(server
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
6191 set_blocking(client
, FALSE
);
6192 set_blocking(server
, FALSE
);
6194 for (i
= 0; i
< ARRAY_SIZE(invalid_flags
); ++i
)
6197 fds
[0].events
= invalid_flags
[i
];
6198 fds
[0].revents
= 0xdead;
6199 WSASetLastError(0xdeadbeef);
6200 ret
= pWSAPoll(fds
, 1, 0);
6201 todo_wine
ok(ret
== -1, "got %d\n", ret
);
6202 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6205 /* Test flags exposed by connected sockets. */
6207 fds
[0].fd
= listener
;
6208 fds
[0].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
6209 fds
[0].revents
= 0xdead;
6211 fds
[1].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
6212 fds
[1].revents
= 0xdead;
6214 fds
[2].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
6215 fds
[2].revents
= 0xdead;
6216 ret
= pWSAPoll(fds
, 3, 0);
6217 ok(ret
== 2, "got %d\n", ret
);
6218 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
6219 ok(fds
[1].revents
== POLLWRNORM
, "got events %#x\n", fds
[1].revents
);
6220 ok(fds
[2].revents
== POLLWRNORM
, "got events %#x\n", fds
[2].revents
);
6222 /* Test data receiving notifications */
6224 ret
= send(server
, "1234", 4, 0);
6225 ok(ret
== 4, "got %d\n", ret
);
6227 check_poll_mask(client
, POLLRDNORM
| POLLRDBAND
, POLLRDNORM
);
6228 check_poll(client
, POLLRDNORM
| POLLWRNORM
);
6229 check_poll(server
, POLLWRNORM
);
6231 ret
= sync_recv(client
, buffer
, sizeof(buffer
), 0);
6232 ok(ret
== 4, "got %d\n", ret
);
6234 check_poll(client
, POLLWRNORM
);
6235 check_poll(server
, POLLWRNORM
);
6237 /* Because the kernel asynchronously buffers data, this test is not reliable. */
6241 static const int large_buffer_size
= 1024 * 1024;
6242 char *large_buffer
= malloc(large_buffer_size
);
6244 while (send(server
, large_buffer
, large_buffer_size
, 0) == large_buffer_size
);
6246 check_poll(client
, POLLWRNORM
| POLLRDNORM
);
6247 check_poll(server
, 0);
6249 while (recv(client
, large_buffer
, large_buffer_size
, 0) > 0);
6251 check_poll(client
, POLLWRNORM
);
6252 check_poll(server
, POLLWRNORM
);
6257 /* Test OOB data notifications */
6259 ret
= send(client
, "A", 1, MSG_OOB
);
6260 ok(ret
== 1, "got %d\n", ret
);
6262 check_poll(client
, POLLWRNORM
);
6263 check_poll_mask(server
, POLLRDNORM
| POLLRDBAND
, POLLRDBAND
);
6264 check_poll(server
, POLLWRNORM
| POLLRDBAND
);
6267 ret
= recv(server
, buffer
, 1, MSG_OOB
);
6268 ok(ret
== 1, "got %d\n", ret
);
6269 ok(buffer
[0] == 'A', "got %#x\n", buffer
[0]);
6271 check_poll(client
, POLLWRNORM
);
6272 check_poll(server
, POLLWRNORM
);
6274 /* If the socket is OOBINLINED the notification is like normal data */
6277 ret
= setsockopt(server
, SOL_SOCKET
, SO_OOBINLINE
, (char *)&ret
, sizeof(ret
));
6278 ok(!ret
, "got error %u\n", WSAGetLastError());
6279 ret
= send(client
, "A", 1, MSG_OOB
);
6280 ok(ret
== 1, "got %d\n", ret
);
6282 check_poll(client
, POLLWRNORM
);
6283 check_poll_mask(server
, POLLRDNORM
| POLLRDBAND
, POLLRDNORM
);
6284 check_poll(server
, POLLWRNORM
| POLLRDNORM
);
6287 ret
= recv(server
, buffer
, 1, 0);
6288 ok(ret
== 1, "got %d\n", ret
);
6289 ok(buffer
[0] == 'A', "got %#x\n", buffer
[0]);
6291 check_poll(client
, POLLWRNORM
);
6292 check_poll_todo(server
, POLLWRNORM
);
6294 /* Test shutdown. */
6296 ret
= shutdown(client
, SD_RECEIVE
);
6297 ok(!ret
, "got error %u\n", WSAGetLastError());
6299 check_poll(client
, POLLWRNORM
);
6300 check_poll_todo(server
, POLLWRNORM
);
6302 ret
= shutdown(client
, SD_SEND
);
6303 ok(!ret
, "got error %u\n", WSAGetLastError());
6305 check_poll(client
, POLLWRNORM
);
6306 check_poll_mask_todo(server
, 0, POLLHUP
);
6307 check_poll_todo(server
, POLLWRNORM
| POLLHUP
);
6309 closesocket(client
);
6310 closesocket(server
);
6312 /* Test shutdown via closesocket(). */
6314 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6315 ret
= connect(client
, (struct sockaddr
*)&address
, sizeof(address
));
6316 ok(!ret
, "got error %u\n", WSAGetLastError());
6317 server
= accept(listener
, NULL
, NULL
);
6318 ok(server
!= -1, "got error %u\n", WSAGetLastError());
6320 closesocket(client
);
6322 check_poll_mask(server
, 0, POLLHUP
);
6323 check_poll(server
, POLLWRNORM
| POLLHUP
);
6325 closesocket(server
);
6327 /* Test shutdown with data in the pipe. */
6329 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6330 ret
= connect(client
, (struct sockaddr
*)&address
, sizeof(address
));
6331 ok(!ret
, "got error %u\n", WSAGetLastError());
6332 server
= accept(listener
, NULL
, NULL
);
6333 ok(server
!= -1, "got error %u\n", WSAGetLastError());
6335 ret
= send(client
, "data", 5, 0);
6336 ok(ret
== 5, "got %d\n", ret
);
6338 check_poll(client
, POLLWRNORM
);
6339 check_poll_mask(server
, POLLRDNORM
| POLLRDBAND
, POLLRDNORM
);
6340 check_poll(server
, POLLWRNORM
| POLLRDNORM
);
6342 ret
= shutdown(client
, SD_SEND
);
6344 check_poll(client
, POLLWRNORM
);
6345 check_poll_mask_todo(server
, 0, POLLHUP
);
6346 check_poll_todo(server
, POLLWRNORM
| POLLRDNORM
| POLLHUP
);
6348 closesocket(client
);
6349 closesocket(server
);
6351 /* Test closing a socket while selecting on it. */
6353 tcp_socketpair(&client
, &server
);
6355 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &client
, 0, NULL
);
6357 fds
[0].events
= POLLRDNORM
| POLLRDBAND
;
6358 fds
[0].revents
= 0xdead;
6359 ret
= pWSAPoll(fds
, 1, 2000);
6360 ok(ret
== 1, "got %d\n", ret
);
6361 ok(fds
[0].revents
== POLLNVAL
, "got events %#x\n", fds
[0].revents
);
6362 ret
= WaitForSingleObject(thread_handle
, 1000);
6363 ok(!ret
, "wait failed\n");
6364 CloseHandle(thread_handle
);
6366 closesocket(server
);
6368 /* Test a failed connection.
6370 * The following WSAPoll() call times out on versions older than w10pro64,
6371 * but even on w10pro64 it takes over 2 seconds for an error to be reported,
6372 * so make the test interactive-only. */
6373 if (winetest_interactive
)
6375 const struct sockaddr_in invalid_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= inet_addr("192.0.2.0")};
6377 client
= setup_connector_socket(&invalid_addr
, sizeof(invalid_addr
), TRUE
);
6380 fds
[0].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
6381 fds
[0].revents
= 0xdead;
6382 ret
= pWSAPoll(fds
, 1, 10000);
6383 ok(ret
== 1, "got %d\n", ret
);
6384 ok(fds
[0].revents
== POLLERR
, "got events %#x\n", fds
[0].revents
);
6388 ret
= getsockopt(client
, SOL_SOCKET
, SO_ERROR
, (char *)&err
, &len
);
6389 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
6390 ok(err
== WSAECONNREFUSED
, "expected 10061, got %d\n", err
);
6391 closesocket(client
);
6394 closesocket(listener
);
6396 /* Test UDP sockets. */
6398 client
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
6399 server
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
6401 check_poll(client
, POLLWRNORM
);
6402 check_poll(server
, POLLWRNORM
);
6404 ret
= bind(client
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
6405 ok(!ret
, "got error %u\n", WSAGetLastError());
6406 len
= sizeof(address
);
6407 ret
= getsockname(client
, (struct sockaddr
*)&address
, &len
);
6408 ok(!ret
, "got error %u\n", WSAGetLastError());
6410 check_poll(client
, POLLWRNORM
);
6411 check_poll(server
, POLLWRNORM
);
6413 ret
= sendto(server
, "data", 5, 0, (struct sockaddr
*)&address
, sizeof(address
));
6414 ok(ret
== 5, "got %d\n", ret
);
6416 check_poll_mask(client
, POLLRDNORM
| POLLRDBAND
, POLLRDNORM
);
6417 check_poll(client
, POLLWRNORM
| POLLRDNORM
);
6418 check_poll(server
, POLLWRNORM
);
6420 closesocket(client
);
6421 closesocket(server
);
6424 static void test_ConnectEx(void)
6426 SOCKET listener
= INVALID_SOCKET
;
6427 SOCKET acceptor
= INVALID_SOCKET
;
6428 SOCKET connector
= INVALID_SOCKET
;
6429 struct sockaddr_in address
, conaddress
;
6431 OVERLAPPED overlapped
;
6432 LPFN_CONNECTEX pConnectEx
;
6433 GUID connectExGuid
= WSAID_CONNECTEX
;
6434 DWORD bytesReturned
;
6440 memset(&overlapped
, 0, sizeof(overlapped
));
6442 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
6443 ok(listener
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
6445 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
6446 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
6448 memset(&address
, 0, sizeof(address
));
6449 address
.sin_family
= AF_INET
;
6450 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6451 iret
= bind(listener
, (struct sockaddr
*)&address
, sizeof(address
));
6452 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
6454 addrlen
= sizeof(address
);
6455 iret
= getsockname(listener
, (struct sockaddr
*)&address
, &addrlen
);
6456 ok(!iret
, "failed to get address, error %u\n", WSAGetLastError());
6458 iret
= set_blocking(listener
, TRUE
);
6459 ok(!iret
, "failed to set nonblocking, error %u\n", WSAGetLastError());
6461 bytesReturned
= 0xdeadbeef;
6462 iret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectExGuid
, sizeof(connectExGuid
),
6463 &pConnectEx
, sizeof(pConnectEx
), &bytesReturned
, NULL
, NULL
);
6464 ok(!iret
, "failed to get ConnectEx, error %u\n", WSAGetLastError());
6466 ok(bytesReturned
== sizeof(pConnectEx
), "expected sizeof(pConnectEx), got %u\n", bytesReturned
);
6468 bret
= pConnectEx(INVALID_SOCKET
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
6469 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "ConnectEx on invalid socket "
6470 "returned %d + errno %d\n", bret
, WSAGetLastError());
6472 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
6473 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "ConnectEx on a unbound socket "
6474 "returned %d + errno %d\n", bret
, WSAGetLastError());
6476 /* ConnectEx needs a bound socket */
6477 memset(&conaddress
, 0, sizeof(conaddress
));
6478 conaddress
.sin_family
= AF_INET
;
6479 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6480 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
6481 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
6483 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, NULL
);
6484 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "ConnectEx on a NULL overlapped "
6485 "returned %d + errno %d\n", bret
, WSAGetLastError());
6487 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
6489 iret
= listen(listener
, 1);
6490 ok(!iret
, "failed to listen, error %u\n", WSAGetLastError());
6492 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
6493 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
6494 "returned %d + errno %d\n", bret
, WSAGetLastError());
6495 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
6496 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
6498 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
6499 ok(bret
, "Connecting failed, error %d\n", GetLastError());
6500 ok(bytesReturned
== 0, "Bytes sent is %d\n", bytesReturned
);
6502 closesocket(connector
);
6503 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
6504 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
6505 /* ConnectEx needs a bound socket */
6506 memset(&conaddress
, 0, sizeof(conaddress
));
6507 conaddress
.sin_family
= AF_INET
;
6508 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6509 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
6510 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
6512 acceptor
= accept(listener
, NULL
, NULL
);
6513 ok(acceptor
!= INVALID_SOCKET
, "failed to accept socket, error %u\n", WSAGetLastError());
6518 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, buffer
, 3, &bytesReturned
, &overlapped
);
6519 memset(buffer
, 0, 3);
6520 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
6521 "returned %d + errno %d\n", bret
, WSAGetLastError());
6522 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
6523 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
6525 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
6526 ok(bret
, "Connecting failed, error %d\n", GetLastError());
6527 ok(bytesReturned
== 3, "Bytes sent is %d\n", bytesReturned
);
6529 acceptor
= accept(listener
, NULL
, NULL
);
6530 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket error %d\n", WSAGetLastError());
6532 bytesReturned
= recv(acceptor
, buffer
, 3, 0);
6534 ok(bytesReturned
== 3, "Didn't get all sent data, got only %d\n", bytesReturned
);
6535 ok(buffer
[0] == '1' && buffer
[1] == '2' && buffer
[2] == '3',
6536 "Failed to get the right data, expected '123', got '%s'\n", buffer
);
6538 closesocket(connector
);
6539 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
6540 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
6541 /* ConnectEx needs a bound socket */
6542 memset(&conaddress
, 0, sizeof(conaddress
));
6543 conaddress
.sin_family
= AF_INET
;
6544 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6545 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
6546 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
6548 closesocket(acceptor
);
6549 closesocket(listener
);
6551 /* Connect with error */
6553 address
.sin_port
= htons(1);
6555 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
6556 ok(bret
== FALSE
&& GetLastError() == ERROR_IO_PENDING
, "ConnectEx to bad destination failed: "
6557 "returned %d + errno %d\n", bret
, GetLastError());
6558 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
6559 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
6561 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
6562 ok(bret
== FALSE
&& GetLastError() == ERROR_CONNECTION_REFUSED
,
6563 "Connecting to a disconnected host returned error %d - %d\n", bret
, WSAGetLastError());
6565 WSACloseEvent(overlapped
.hEvent
);
6566 closesocket(connector
);
6569 static void test_AcceptEx(void)
6571 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
6572 SOCKET listener
, acceptor
, acceptor2
, connector
, connector2
;
6573 struct sockaddr_in bindAddress
, peerAddress
, *readBindAddress
, *readRemoteAddress
;
6574 int socklen
, optlen
;
6575 GUID acceptExGuid
= WSAID_ACCEPTEX
, getAcceptExGuid
= WSAID_GETACCEPTEXSOCKADDRS
;
6576 GUID connectex_guid
= WSAID_CONNECTEX
;
6577 LPFN_ACCEPTEX pAcceptEx
= NULL
;
6578 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs
= NULL
;
6579 LPFN_CONNECTEX pConnectEx
= NULL
;
6580 fd_set fds_accept
, fds_send
;
6581 static const struct timeval timeout
= {1, 0};
6582 DWORD bytesReturned
, connect_time
;
6583 char buffer
[1024], ipbuffer
[32];
6584 OVERLAPPED overlapped
= {0}, overlapped2
= {0};
6585 int iret
, localSize
= sizeof(struct sockaddr_in
), remoteSize
= localSize
;
6589 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
6590 overlapped2
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
6592 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
6593 ok(listener
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
6595 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6596 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
6598 memset(&bindAddress
, 0, sizeof(bindAddress
));
6599 bindAddress
.sin_family
= AF_INET
;
6600 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6601 iret
= bind(listener
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6602 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
6604 socklen
= sizeof(bindAddress
);
6605 iret
= getsockname(listener
, (struct sockaddr
*)&bindAddress
, &socklen
);
6606 ok(!iret
, "failed to get address, error %u\n", WSAGetLastError());
6608 iret
= set_blocking(listener
, FALSE
);
6609 ok(!iret
, "Failed to set nonblocking, error %u\n", WSAGetLastError());
6611 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
6612 &pAcceptEx
, sizeof(pAcceptEx
), &bytesReturned
, NULL
, NULL
);
6613 ok(!iret
, "Failed to get AcceptEx, error %u\n", WSAGetLastError());
6615 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &getAcceptExGuid
, sizeof(getAcceptExGuid
),
6616 &pGetAcceptExSockaddrs
, sizeof(pGetAcceptExSockaddrs
), &bytesReturned
, NULL
, NULL
);
6617 ok(!iret
, "Failed to get GetAcceptExSockaddrs, error %u\n", WSAGetLastError());
6619 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectex_guid
, sizeof(connectex_guid
),
6620 &pConnectEx
, sizeof(pConnectEx
), &bytesReturned
, NULL
, NULL
);
6621 ok(!iret
, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
6623 overlapped
.Internal
= 0xdeadbeef;
6624 bret
= pAcceptEx(INVALID_SOCKET
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6625 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6626 &bytesReturned
, &overlapped
);
6627 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid listening socket "
6628 "returned %d + errno %d\n", bret
, WSAGetLastError());
6629 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6631 overlapped
.Internal
= 0xdeadbeef;
6632 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6633 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6634 &bytesReturned
, &overlapped
);
6636 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on a non-listening socket "
6637 "returned %d + errno %d\n", bret
, WSAGetLastError());
6638 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6639 if (!bret
&& WSAGetLastError() == ERROR_IO_PENDING
)
6640 CancelIo((HANDLE
)listener
);
6642 iret
= listen(listener
, 5);
6643 ok(!iret
, "failed to listen, error %u\n", GetLastError());
6645 overlapped
.Internal
= 0xdeadbeef;
6646 bret
= pAcceptEx(listener
, INVALID_SOCKET
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6647 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6648 &bytesReturned
, &overlapped
);
6649 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid accepting socket "
6650 "returned %d + errno %d\n", bret
, WSAGetLastError());
6651 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6653 overlapped
.Internal
= 0xdeadbeef;
6654 bret
= pAcceptEx(listener
, acceptor
, NULL
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6655 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6656 &bytesReturned
, &overlapped
);
6657 todo_wine
ok(bret
== FALSE
&& WSAGetLastError() == WSAEFAULT
,
6658 "AcceptEx on NULL buffer returned %d + errno %d\n", bret
, WSAGetLastError());
6659 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6661 overlapped
.Internal
= 0xdeadbeef;
6662 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16,
6663 &bytesReturned
, &overlapped
);
6664 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
,
6665 "AcceptEx on too small local address size returned %d + errno %d\n",
6666 bret
, WSAGetLastError());
6667 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6669 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6670 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6671 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6672 ok(!iret
, "failed to connect, error %u\n", WSAGetLastError());
6673 iret
= getsockname(connector
, (struct sockaddr
*)&peerAddress
, &remoteSize
);
6674 ok(!iret
, "getsockname failed, error %u\n", WSAGetLastError());
6676 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6677 ok(!dwret
, "wait failed\n");
6678 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6679 ok(bret
, "got error %u\n", GetLastError());
6680 ok(!(NTSTATUS
)overlapped
.Internal
, "got %#lx\n", overlapped
.Internal
);
6681 ok(!bytesReturned
, "got size %u\n", bytesReturned
);
6683 readBindAddress
= readRemoteAddress
= (struct sockaddr_in
*)0xdeadbeef;
6684 localSize
= remoteSize
= 0xdeadbeef;
6685 pGetAcceptExSockaddrs(buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16,
6686 (struct sockaddr
**)&readBindAddress
, &localSize
, (struct sockaddr
**)&readRemoteAddress
, &remoteSize
);
6687 todo_wine
ok(readBindAddress
== (struct sockaddr_in
*)0xdeadbeef, "got local addr %p\n", readBindAddress
);
6688 ok(!memcmp(readRemoteAddress
, &peerAddress
, sizeof(peerAddress
)), "remote addr didn't match\n");
6689 todo_wine
ok(localSize
== 0xdeadbeef, "got local size %u\n", localSize
);
6690 ok(remoteSize
== sizeof(struct sockaddr_in
), "got remote size %u\n", remoteSize
);
6692 closesocket(connector
);
6693 closesocket(acceptor
);
6695 /* A UDP socket cannot be accepted into. */
6697 acceptor
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
6699 overlapped
.Internal
= 0xdeadbeef;
6700 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
6701 ok(!bret
, "expected failure\n");
6702 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6703 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
6704 if (WSAGetLastError() == ERROR_IO_PENDING
)
6705 CancelIo((HANDLE
)listener
);
6707 closesocket(acceptor
);
6709 /* A bound socket cannot be accepted into. */
6711 acceptor
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6712 iret
= bind(acceptor
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
6713 ok(!iret
, "got error %u\n", WSAGetLastError());
6715 overlapped
.Internal
= 0xdeadbeef;
6716 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
6717 ok(!bret
, "expected failure\n");
6718 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6719 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
6720 if (WSAGetLastError() == ERROR_IO_PENDING
)
6721 CancelIo((HANDLE
)listener
);
6723 closesocket(acceptor
);
6725 /* A connected socket cannot be accepted into. */
6727 tcp_socketpair(&acceptor
, &acceptor2
);
6729 overlapped
.Internal
= 0xdeadbeef;
6730 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
6731 ok(!bret
, "expected failure\n");
6732 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6733 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
6734 if (WSAGetLastError() == ERROR_IO_PENDING
)
6735 CancelIo((HANDLE
)listener
);
6737 overlapped
.Internal
= 0xdeadbeef;
6738 bret
= pAcceptEx(listener
, acceptor2
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
6739 ok(!bret
, "expected failure\n");
6740 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6741 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
6742 if (WSAGetLastError() == ERROR_IO_PENDING
)
6743 CancelIo((HANDLE
)listener
);
6745 closesocket(acceptor
);
6746 closesocket(acceptor2
);
6748 /* Pass an insufficient local address size. */
6750 acceptor
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6751 ok(acceptor
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6753 overlapped
.Internal
= 0xdeadbeef;
6754 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 3,
6755 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
6756 ok(!bret
&& WSAGetLastError() == ERROR_IO_PENDING
, "got %d, error %u\n", bret
, WSAGetLastError());
6757 ok((NTSTATUS
)overlapped
.Internal
== STATUS_PENDING
, "got %#lx\n", overlapped
.Internal
);
6759 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6760 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6761 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6762 ok(!iret
, "failed to connect, error %u\n", WSAGetLastError());
6764 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6765 ok(!dwret
, "wait failed\n");
6766 bytesReturned
= 0xdeadbeef;
6767 SetLastError(0xdeadbeef);
6768 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6769 ok(!bret
, "expected failure\n");
6770 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER
, "got error %u\n", GetLastError());
6771 ok((NTSTATUS
)overlapped
.Internal
== STATUS_BUFFER_TOO_SMALL
, "got %#lx\n", overlapped
.Internal
);
6772 ok(!bytesReturned
, "got size %u\n", bytesReturned
);
6774 closesocket(acceptor
);
6776 /* The above connection request is not accepted. */
6777 acceptor
= accept(listener
, NULL
, NULL
);
6778 todo_wine
ok(acceptor
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
6779 closesocket(acceptor
);
6781 closesocket(connector
);
6783 acceptor
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6784 ok(acceptor
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6786 overlapped
.Internal
= 0xdeadbeef;
6787 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 4,
6788 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
6789 ok(!bret
&& WSAGetLastError() == ERROR_IO_PENDING
, "got %d, error %u\n", bret
, WSAGetLastError());
6790 ok((NTSTATUS
)overlapped
.Internal
== STATUS_PENDING
, "got %#lx\n", overlapped
.Internal
);
6792 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6793 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6794 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6795 ok(!iret
, "failed to connect, error %u\n", WSAGetLastError());
6797 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6798 ok(!dwret
, "wait failed\n");
6799 bytesReturned
= 0xdeadbeef;
6800 SetLastError(0xdeadbeef);
6801 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6802 todo_wine
ok(!bret
, "expected failure\n");
6803 todo_wine
ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER
, "got error %u\n", GetLastError());
6804 todo_wine
ok((NTSTATUS
)overlapped
.Internal
== STATUS_BUFFER_TOO_SMALL
, "got %#lx\n", overlapped
.Internal
);
6805 ok(!bytesReturned
, "got size %u\n", bytesReturned
);
6807 closesocket(acceptor
);
6809 /* The above connection request is not accepted. */
6810 acceptor
= accept(listener
, NULL
, NULL
);
6811 todo_wine
ok(acceptor
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
6812 closesocket(acceptor
);
6814 closesocket(connector
);
6816 acceptor
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6817 ok(acceptor
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6819 overlapped
.Internal
= 0xdeadbeef;
6820 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 15,
6821 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
6822 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx on too small local address "
6823 "size returned %d + errno %d\n",
6824 bret
, WSAGetLastError());
6825 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6826 bret
= CancelIo((HANDLE
) listener
);
6827 ok(bret
, "Failed to cancel pending accept socket\n");
6829 overlapped
.Internal
= 0xdeadbeef;
6830 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16, 0,
6831 &bytesReturned
, &overlapped
);
6832 ok(bret
== FALSE
&& WSAGetLastError() == WSAEFAULT
,
6833 "AcceptEx on too small remote address size returned %d + errno %d\n", bret
, WSAGetLastError());
6834 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6836 overlapped
.Internal
= 0xdeadbeef;
6837 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16,
6838 sizeof(struct sockaddr_in
) + 15, &bytesReturned
, &overlapped
);
6839 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
,
6840 "AcceptEx on too small remote address size returned %d + errno %d\n", bret
, WSAGetLastError());
6841 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6842 bret
= CancelIo((HANDLE
) listener
);
6843 ok(bret
, "Failed to cancel pending accept socket\n");
6845 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
6846 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6847 &bytesReturned
, NULL
);
6848 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
6849 "returned %d + errno %d\n", bret
, WSAGetLastError());
6851 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, 0, &bytesReturned
, NULL
);
6852 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
6853 "returned %d + errno %d\n", bret
, WSAGetLastError());
6855 overlapped
.Internal
= 0xdeadbeef;
6856 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
6857 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6858 &bytesReturned
, &overlapped
);
6859 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6860 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6862 /* try to accept into the same socket twice */
6863 overlapped
.Internal
= 0xdeadbeef;
6864 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
6865 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6866 &bytesReturned
, &overlapped
);
6867 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
,
6868 "AcceptEx on already pending socket returned %d + errno %d\n", bret
, WSAGetLastError());
6869 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6871 /* try to connect a socket that's being accepted into */
6872 iret
= connect(acceptor
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6873 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEINVAL
,
6874 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret
, WSAGetLastError());
6876 bret
= pConnectEx(acceptor
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
),
6877 NULL
, 0, &bytesReturned
, &overlapped2
);
6878 ok(!bret
, "expected failure\n");
6879 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6881 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6882 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6883 overlapped
.Internal
= 0xdeadbeef;
6884 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6885 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6887 dwret
= WaitForSingleObject(overlapped
.hEvent
, INFINITE
);
6888 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6889 ok(overlapped
.Internal
== STATUS_SUCCESS
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6891 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6892 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
6893 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
6895 closesocket(connector
);
6896 connector
= INVALID_SOCKET
;
6897 closesocket(acceptor
);
6899 /* Test short reads */
6901 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6902 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
6903 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
6904 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
6905 overlapped
.Internal
= 0xdeadbeef;
6906 bret
= pAcceptEx(listener
, acceptor
, buffer
, 2,
6907 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6908 &bytesReturned
, &overlapped
);
6909 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6910 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6912 connect_time
= 0xdeadbeef;
6913 optlen
= sizeof(connect_time
);
6914 iret
= getsockopt(connector
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
6915 ok(!iret
, "getsockopt failed %d\n", WSAGetLastError());
6916 ok(connect_time
== ~0u, "unexpected connect time %u\n", connect_time
);
6918 /* AcceptEx() still won't complete until we send data */
6919 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6920 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6922 connect_time
= 0xdeadbeef;
6923 optlen
= sizeof(connect_time
);
6924 iret
= getsockopt(connector
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
6925 ok(!iret
, "getsockopt failed %d\n", WSAGetLastError());
6926 ok(connect_time
< 0xdeadbeef, "unexpected connect time %u\n", connect_time
);
6928 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
6929 ok(dwret
== WAIT_TIMEOUT
, "Waiting for accept event timeout failed with %d + errno %d\n", dwret
, GetLastError());
6930 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6932 iret
= getsockname( connector
, (struct sockaddr
*)&peerAddress
, &remoteSize
);
6933 ok( !iret
, "getsockname failed.\n");
6935 /* AcceptEx() could complete any time now */
6936 iret
= send(connector
, buffer
, 1, 0);
6937 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
6939 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6940 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6941 ok(overlapped
.Internal
== STATUS_SUCCESS
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6943 /* Check if the buffer from AcceptEx is decoded correctly */
6944 pGetAcceptExSockaddrs(buffer
, 2, sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6945 (struct sockaddr
**)&readBindAddress
, &localSize
,
6946 (struct sockaddr
**)&readRemoteAddress
, &remoteSize
);
6947 strcpy( ipbuffer
, inet_ntoa(readBindAddress
->sin_addr
));
6948 ok( readBindAddress
->sin_addr
.s_addr
== bindAddress
.sin_addr
.s_addr
,
6949 "Local socket address is different %s != %s\n",
6950 ipbuffer
, inet_ntoa(bindAddress
.sin_addr
));
6951 ok( readBindAddress
->sin_port
== bindAddress
.sin_port
,
6952 "Local socket port is different: %d != %d\n",
6953 readBindAddress
->sin_port
, bindAddress
.sin_port
);
6954 strcpy( ipbuffer
, inet_ntoa(readRemoteAddress
->sin_addr
));
6955 ok( readRemoteAddress
->sin_addr
.s_addr
== peerAddress
.sin_addr
.s_addr
,
6956 "Remote socket address is different %s != %s\n",
6957 ipbuffer
, inet_ntoa(peerAddress
.sin_addr
));
6958 ok( readRemoteAddress
->sin_port
== peerAddress
.sin_port
,
6959 "Remote socket port is different: %d != %d\n",
6960 readRemoteAddress
->sin_port
, peerAddress
.sin_port
);
6962 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6963 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
6964 ok(bytesReturned
== 1, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
6966 closesocket(connector
);
6967 connector
= INVALID_SOCKET
;
6968 closesocket(acceptor
);
6970 /* Test CF_DEFER & AcceptEx interaction */
6972 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6973 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
6974 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
6975 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
6976 connector2
= socket(AF_INET
, SOCK_STREAM
, 0);
6977 ok(connector2
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
6979 iret
= set_blocking(connector
, FALSE
);
6980 ok(!iret
, "failed to set nonblocking, error %u\n", GetLastError());
6981 iret
= set_blocking(connector2
, FALSE
);
6982 ok(!iret
, "failed to set nonblocking, error %u\n", GetLastError());
6984 /* Connect socket #1 */
6985 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6986 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6990 FD_ZERO(&fds_accept
);
6991 FD_SET(listener
, &fds_accept
);
6992 iret
= select(0, &fds_accept
, NULL
, NULL
, &timeout
);
6993 ok(iret
== 1, "wait timed out\n");
6995 acceptor2
= WSAAccept(listener
, NULL
, NULL
, AlwaysDeferConditionFunc
, 0);
6996 ok(acceptor2
== INVALID_SOCKET
, "expected failure\n");
6997 ok(WSAGetLastError() == WSATRY_AGAIN
, "got error %u\n", WSAGetLastError());
6998 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16,
6999 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
7000 ok(!bret
, "expected failure\n");
7001 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
7004 FD_SET(connector
, &fds_send
);
7005 iret
= select(0, NULL
, &fds_send
, NULL
, &timeout
);
7006 ok(iret
== 1, "wait timed out\n");
7008 iret
= send(connector
, "1", 1, 0);
7009 ok(iret
== 1, "got ret %d, error %u\n", iret
, WSAGetLastError());
7011 iret
= connect(connector2
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7012 ok(iret
== SOCKET_ERROR
, "expected failure\n");
7013 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
7015 iret
= select(0, &fds_accept
, NULL
, NULL
, &timeout
);
7016 ok(iret
== 1, "wait timed out\n");
7018 acceptor2
= accept(listener
, NULL
, NULL
);
7019 ok(acceptor2
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
7020 closesocket(acceptor2
);
7023 FD_SET(connector2
, &fds_send
);
7024 iret
= select(0, NULL
, &fds_send
, NULL
, &timeout
);
7025 ok(iret
== 1, "wait timed out\n");
7027 iret
= send(connector2
, "2", 1, 0);
7028 ok(iret
== 1, "got ret %d, error %u\n", iret
, WSAGetLastError());
7030 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
7031 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
7033 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7034 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
7035 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
7037 set_blocking(acceptor
, TRUE
);
7038 iret
= recv( acceptor
, buffer
, 2, 0);
7039 ok(iret
== 1, "Failed to get data, %d, errno: %d\n", iret
, WSAGetLastError());
7040 ok(buffer
[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer
[0]);
7042 closesocket(connector
);
7043 closesocket(connector2
);
7044 closesocket(acceptor
);
7046 /* clean up in case of failures */
7047 while ((acceptor
= accept(listener
, NULL
, NULL
)) != INVALID_SOCKET
)
7048 closesocket(acceptor
);
7050 /* Disconnect during receive? */
7052 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7053 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7054 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7055 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7056 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7057 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7058 &bytesReturned
, &overlapped
);
7059 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7061 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7062 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7064 closesocket(connector
);
7065 connector
= INVALID_SOCKET
;
7067 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7068 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
7070 bytesReturned
= 123456;
7071 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7072 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
7073 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
7075 closesocket(acceptor
);
7077 /* Test closing with pending requests */
7079 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7080 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7081 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7082 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7083 &bytesReturned
, &overlapped
);
7084 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7086 closesocket(acceptor
);
7088 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7089 ok(dwret
== WAIT_OBJECT_0
,
7090 "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
7091 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7092 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
7094 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7095 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7096 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7097 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7098 &bytesReturned
, &overlapped
);
7099 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7101 CancelIo((HANDLE
) acceptor
);
7103 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7104 ok(dwret
== WAIT_TIMEOUT
, "Waiting for timeout failed with %d + errno %d\n", dwret
, GetLastError());
7106 closesocket(acceptor
);
7108 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7109 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7110 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7111 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7112 &bytesReturned
, &overlapped
);
7113 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7115 closesocket(listener
);
7117 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7118 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
7120 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7121 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
7123 CloseHandle(overlapped
.hEvent
);
7124 CloseHandle(overlapped2
.hEvent
);
7125 closesocket(acceptor
);
7126 closesocket(connector2
);
7129 static void test_shutdown(void)
7131 struct sockaddr_in addr
, server_addr
, client_addr
;
7132 SOCKET listener
, client
, server
;
7133 OVERLAPPED overlapped
= {0};
7134 DWORD size
, flags
= 0;
7139 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
7140 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
7141 ok(listener
!= INVALID_SOCKET
, "failed to create listener socket, error %d\n", WSAGetLastError());
7143 memset(&addr
, 0, sizeof(addr
));
7144 addr
.sin_family
= AF_INET
;
7145 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7146 ret
= bind(listener
, (struct sockaddr
*)&addr
, sizeof(addr
));
7147 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
7148 addrlen
= sizeof(server_addr
);
7149 ret
= getsockname(listener
, (struct sockaddr
*)&server_addr
, &addrlen
);
7150 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
7152 ret
= listen(listener
, 1);
7153 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
7155 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
7156 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
7158 WSASetLastError(0xdeadbeef);
7159 ret
= shutdown(client
, SD_SEND
);
7160 ok(ret
== -1, "expected failure\n");
7161 ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
7163 WSASetLastError(0xdeadbeef);
7164 ret
= shutdown(client
, SD_RECEIVE
);
7165 ok(ret
== -1, "expected failure\n");
7166 ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
7168 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7169 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
7170 server
= accept(listener
, NULL
, NULL
);
7171 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
7172 set_blocking(client
, FALSE
);
7174 WSASetLastError(0xdeadbeef);
7175 ret
= shutdown(client
, SD_SEND
);
7176 ok(!ret
, "expected success\n");
7177 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7179 WSASetLastError(0xdeadbeef);
7180 ret
= shutdown(client
, SD_SEND
);
7181 ok(!ret
, "expected success\n");
7182 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7184 WSASetLastError(0xdeadbeef);
7185 ret
= send(client
, "test", 5, 0);
7186 ok(ret
== -1, "got %d\n", ret
);
7187 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7189 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
7190 ok(!ret
, "got %d\n", ret
);
7191 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
7192 ok(!ret
, "got %d\n", ret
);
7194 WSASetLastError(0xdeadbeef);
7195 ret
= shutdown(server
, SD_RECEIVE
);
7196 ok(!ret
, "expected success\n");
7197 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7199 WSASetLastError(0xdeadbeef);
7200 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
7201 todo_wine
ok(ret
== -1, "got %d\n", ret
);
7202 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7204 ret
= send(server
, "test", 5, 0);
7205 ok(ret
== 5, "got %d\n", ret
);
7207 ret
= sync_recv(client
, buffer
, sizeof(buffer
), 0);
7208 ok(ret
== 5, "got %d\n", ret
);
7209 ok(!strcmp(buffer
, "test"), "got %s\n", debugstr_an(buffer
, ret
));
7211 WSASetLastError(0xdeadbeef);
7212 ret
= shutdown(client
, SD_RECEIVE
);
7213 ok(!ret
, "expected success\n");
7214 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7216 WSASetLastError(0xdeadbeef);
7217 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
7218 ok(ret
== -1, "got %d\n", ret
);
7219 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7221 WSASetLastError(0xdeadbeef);
7222 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
7223 ok(ret
== -1, "got %d\n", ret
);
7224 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7226 WSASetLastError(0xdeadbeef);
7227 ret
= shutdown(server
, SD_SEND
);
7228 ok(!ret
, "expected success\n");
7229 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7231 WSASetLastError(0xdeadbeef);
7232 ret
= send(server
, "test", 5, 0);
7233 ok(ret
== -1, "got %d\n", ret
);
7234 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7236 addrlen
= sizeof(addr
);
7237 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &addrlen
);
7238 todo_wine
ok(!ret
, "got error %u\n", WSAGetLastError());
7239 todo_wine
ok(!memcmp(&addr
, &server_addr
, sizeof(server_addr
)), "address didn't match\n");
7241 addrlen
= sizeof(client_addr
);
7242 ret
= getsockname(client
, (struct sockaddr
*)&client_addr
, &addrlen
);
7243 ok(!ret
, "got error %u\n", WSAGetLastError());
7244 addrlen
= sizeof(addr
);
7245 ret
= getpeername(server
, (struct sockaddr
*)&addr
, &addrlen
);
7246 todo_wine
ok(!ret
, "got error %u\n", WSAGetLastError());
7247 todo_wine
ok(!memcmp(&addr
, &client_addr
, sizeof(addr
)), "address didn't match\n");
7249 WSASetLastError(0xdeadbeef);
7250 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7251 ok(ret
== -1, "got %d\n", ret
);
7252 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
7254 WSASetLastError(0xdeadbeef);
7255 ret
= shutdown(client
, 0xdeadbeef);
7256 ok(ret
== -1, "expected failure\n");
7257 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
7259 closesocket(client
);
7260 closesocket(server
);
7264 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
7265 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
7266 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7267 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
7268 server
= accept(listener
, NULL
, NULL
);
7269 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
7271 WSASetLastError(0xdeadbeef);
7272 ret
= shutdown(client
, SD_BOTH
);
7273 ok(!ret
, "expected success\n");
7274 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7276 WSASetLastError(0xdeadbeef);
7277 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
7278 ok(ret
== -1, "got %d\n", ret
);
7279 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7281 WSASetLastError(0xdeadbeef);
7282 ret
= send(client
, "test", 5, 0);
7283 ok(ret
== -1, "got %d\n", ret
);
7284 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7286 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
7287 ok(!ret
, "got %d\n", ret
);
7289 WSASetLastError(0xdeadbeef);
7290 ret
= shutdown(server
, SD_BOTH
);
7291 ok(!ret
, "expected success\n");
7292 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7294 WSASetLastError(0xdeadbeef);
7295 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
7296 todo_wine
ok(ret
== -1, "got %d\n", ret
);
7297 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7299 WSASetLastError(0xdeadbeef);
7300 ret
= send(server
, "test", 5, 0);
7301 ok(ret
== -1, "got %d\n", ret
);
7302 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7304 addrlen
= sizeof(addr
);
7305 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &addrlen
);
7306 todo_wine
ok(!ret
, "got error %u\n", WSAGetLastError());
7307 todo_wine
ok(!memcmp(&addr
, &server_addr
, sizeof(server_addr
)), "address didn't match\n");
7309 addrlen
= sizeof(client_addr
);
7310 ret
= getsockname(client
, (struct sockaddr
*)&client_addr
, &addrlen
);
7311 ok(!ret
, "got error %u\n", WSAGetLastError());
7312 addrlen
= sizeof(addr
);
7313 ret
= getpeername(server
, (struct sockaddr
*)&addr
, &addrlen
);
7314 todo_wine
ok(!ret
, "got error %u\n", WSAGetLastError());
7315 todo_wine
ok(!memcmp(&addr
, &client_addr
, sizeof(addr
)), "address didn't match\n");
7317 closesocket(client
);
7318 closesocket(server
);
7320 /* Test shutting down with async I/O pending. */
7322 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
7323 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
7324 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7325 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
7326 server
= accept(listener
, NULL
, NULL
);
7327 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
7328 set_blocking(client
, FALSE
);
7330 wsabuf
.buf
= buffer
;
7331 wsabuf
.len
= sizeof(buffer
);
7332 WSASetLastError(0xdeadbeef);
7333 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
7334 ok(ret
== -1, "got %d\n", ret
);
7335 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
7337 ret
= shutdown(client
, SD_RECEIVE
);
7338 ok(!ret
, "got error %u\n", WSAGetLastError());
7340 WSASetLastError(0xdeadbeef);
7341 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, NULL
, NULL
);
7342 ok(ret
== -1, "got %d\n", ret
);
7343 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7345 ret
= send(server
, "test", 5, 0);
7346 ok(ret
== 5, "got %d\n", ret
);
7348 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7349 ok(!ret
, "wait timed out\n");
7351 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
7352 ok(ret
, "got error %u\n", GetLastError());
7353 ok(size
== 5, "got size %u\n", size
);
7354 ok(!strcmp(buffer
, "test"), "got %s\n", debugstr_an(buffer
, size
));
7356 WSASetLastError(0xdeadbeef);
7357 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
7358 ok(ret
== -1, "got %d\n", ret
);
7359 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7361 WSASetLastError(0xdeadbeef);
7362 ret
= WSARecv(server
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
7363 ok(ret
== -1, "got %d\n", ret
);
7364 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
7366 ret
= shutdown(client
, SD_SEND
);
7367 ok(!ret
, "got error %u\n", WSAGetLastError());
7369 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7370 ok(!ret
, "wait timed out\n");
7372 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
7373 ok(ret
, "got error %u\n", GetLastError());
7374 ok(!size
, "got size %u\n", size
);
7376 closesocket(client
);
7377 closesocket(server
);
7379 /* Test shutting down a listening socket. */
7381 WSASetLastError(0xdeadbeef);
7382 ret
= shutdown(listener
, SD_SEND
);
7383 ok(ret
== -1, "expected failure\n");
7384 ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
7386 WSASetLastError(0xdeadbeef);
7387 ret
= shutdown(listener
, SD_RECEIVE
);
7388 ok(ret
== -1, "expected failure\n");
7389 ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
7391 closesocket(listener
);
7393 /* Test shutting down UDP sockets. */
7395 client
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
7396 server
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
7397 memset(&addr
, 0, sizeof(addr
));
7398 addr
.sin_family
= AF_INET
;
7399 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7400 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
7401 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
7402 addrlen
= sizeof(server_addr
);
7403 ret
= getsockname(server
, (struct sockaddr
*)&server_addr
, &addrlen
);
7404 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
7405 set_blocking(server
, FALSE
);
7407 WSASetLastError(0xdeadbeef);
7408 ret
= shutdown(server
, SD_RECEIVE
);
7409 ok(!ret
, "expected success\n");
7410 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7412 WSASetLastError(0xdeadbeef);
7413 ret
= recvfrom(server
, buffer
, sizeof(buffer
), 0, NULL
, NULL
);
7414 ok(ret
== -1, "got %d\n", ret
);
7415 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7417 ret
= sendto(client
, "test", 5, 0, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7418 ok(ret
== 5, "got %d\n", ret
);
7420 WSASetLastError(0xdeadbeef);
7421 ret
= shutdown(client
, SD_SEND
);
7422 ok(!ret
, "expected success\n");
7423 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7425 WSASetLastError(0xdeadbeef);
7426 ret
= shutdown(client
, SD_SEND
);
7427 ok(!ret
, "expected success\n");
7428 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7430 WSASetLastError(0xdeadbeef);
7431 ret
= sendto(client
, "test", 5, 0, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7432 ok(ret
== -1, "got %d\n", ret
);
7433 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7435 closesocket(client
);
7436 closesocket(server
);
7438 CloseHandle(overlapped
.hEvent
);
7441 static void test_DisconnectEx(void)
7443 struct sockaddr_in server_addr
, client_addr
, addr
;
7444 GUID disconnectex_guid
= WSAID_DISCONNECTEX
;
7445 SOCKET listener
, server
, client
;
7446 LPFN_DISCONNECTEX pDisconnectEx
;
7447 OVERLAPPED overlapped
= {0};
7452 overlapped
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
7454 client
= socket(AF_INET
, SOCK_STREAM
, 0);
7455 ok(client
!= INVALID_SOCKET
, "failed to create connector socket, error %u\n", WSAGetLastError());
7457 ret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &disconnectex_guid
, sizeof(disconnectex_guid
),
7458 &pDisconnectEx
, sizeof(pDisconnectEx
), &size
, NULL
, NULL
);
7461 win_skip("WSAIoctl failed to get DisconnectEx, error %d\n", WSAGetLastError());
7462 closesocket(client
);
7466 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
7467 ok(listener
!= INVALID_SOCKET
, "failed to create listener socket, error %d\n", WSAGetLastError());
7469 memset(&addr
, 0, sizeof(addr
));
7470 addr
.sin_family
= AF_INET
;
7471 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7472 ret
= bind(listener
, (struct sockaddr
*)&addr
, sizeof(addr
));
7473 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
7474 addrlen
= sizeof(server_addr
);
7475 ret
= getsockname(listener
, (struct sockaddr
*)&server_addr
, &addrlen
);
7476 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
7477 ret
= listen(listener
, 1);
7478 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
7480 WSASetLastError(0xdeadbeef);
7481 ret
= pDisconnectEx(INVALID_SOCKET
, &overlapped
, 0, 0);
7482 ok(!ret
, "expected failure\n");
7483 ok(WSAGetLastError() == WSAENOTSOCK
, "got error %u\n", WSAGetLastError());
7485 WSASetLastError(0xdeadbeef);
7486 ret
= pDisconnectEx(client
, &overlapped
, 0, 0);
7487 ok(!ret
, "expected failure\n");
7488 ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
7490 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7491 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
7492 server
= accept(listener
, NULL
, NULL
);
7493 ok(server
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
7495 WSASetLastError(0xdeadbeef);
7496 ret
= pDisconnectEx(client
, &overlapped
, 0, 0);
7497 ok(!ret
, "expected failure\n");
7498 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
7500 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7501 ok(!ret
, "wait timed out\n");
7503 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
7504 ok(ret
, "got error %u\n", GetLastError());
7505 ok(!size
, "got size %u\n", size
);
7507 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7508 ok(ret
== -1, "expected failure\n");
7509 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
7511 WSASetLastError(0xdeadbeef);
7512 ret
= send(client
, "test", 5, 0);
7513 ok(ret
== -1, "expected failure\n");
7514 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7516 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
7517 ok(!ret
, "got %d\n", ret
);
7519 ret
= send(server
, "test", 5, 0);
7520 ok(ret
== 5, "got %d\n", ret
);
7522 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
7523 ok(ret
== 5, "got %d\n", ret
);
7524 ok(!strcmp(buffer
, "test"), "got %s\n", debugstr_an(buffer
, ret
));
7526 addrlen
= sizeof(addr
);
7527 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &addrlen
);
7528 ok(!ret
, "got error %u\n", WSAGetLastError());
7529 ok(!memcmp(&addr
, &server_addr
, sizeof(server_addr
)), "address didn't match\n");
7531 addrlen
= sizeof(client_addr
);
7532 ret
= getsockname(client
, (struct sockaddr
*)&client_addr
, &addrlen
);
7533 ok(!ret
, "got error %u\n", WSAGetLastError());
7534 addrlen
= sizeof(addr
);
7535 ret
= getpeername(server
, (struct sockaddr
*)&addr
, &addrlen
);
7536 ok(!ret
, "got error %u\n", WSAGetLastError());
7537 ok(!memcmp(&addr
, &client_addr
, sizeof(addr
)), "address didn't match\n");
7539 closesocket(client
);
7540 closesocket(server
);
7542 /* Test the synchronous case. */
7544 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
7545 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
7546 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7547 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
7548 server
= accept(listener
, NULL
, NULL
);
7549 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
7551 WSASetLastError(0xdeadbeef);
7552 ret
= pDisconnectEx(client
, NULL
, 0, 0);
7553 ok(ret
, "expected success\n");
7554 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7556 WSASetLastError(0xdeadbeef);
7557 ret
= pDisconnectEx(client
, NULL
, 0, 0);
7558 ok(ret
, "expected success\n");
7559 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7561 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7562 ok(ret
== -1, "expected failure\n");
7563 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
7565 WSASetLastError(0xdeadbeef);
7566 ret
= send(client
, "test", 5, 0);
7567 ok(ret
== -1, "expected failure\n");
7568 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7570 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
7571 ok(!ret
, "got %d\n", ret
);
7573 ret
= send(server
, "test", 5, 0);
7574 ok(ret
== 5, "got %d\n", ret
);
7576 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
7577 ok(ret
== 5, "got %d\n", ret
);
7578 ok(!strcmp(buffer
, "test"), "got %s\n", debugstr_an(buffer
, ret
));
7580 addrlen
= sizeof(addr
);
7581 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &addrlen
);
7582 ok(!ret
, "got error %u\n", WSAGetLastError());
7583 ok(!memcmp(&addr
, &server_addr
, sizeof(server_addr
)), "address didn't match\n");
7585 addrlen
= sizeof(client_addr
);
7586 ret
= getsockname(client
, (struct sockaddr
*)&client_addr
, &addrlen
);
7587 ok(!ret
, "got error %u\n", WSAGetLastError());
7588 addrlen
= sizeof(addr
);
7589 ret
= getpeername(server
, (struct sockaddr
*)&addr
, &addrlen
);
7590 ok(!ret
, "got error %u\n", WSAGetLastError());
7591 ok(!memcmp(&addr
, &client_addr
, sizeof(addr
)), "address didn't match\n");
7593 closesocket(client
);
7594 closesocket(server
);
7596 closesocket(listener
);
7597 CloseHandle(overlapped
.hEvent
);
7600 #define compare_file(h,s,o) compare_file2(h,s,o,__FILE__,__LINE__)
7602 static void compare_file2(HANDLE handle
, SOCKET sock
, int offset
, const char *file
, int line
)
7604 char buf1
[256], buf2
[256];
7608 SetFilePointer(handle
, offset
, NULL
, FILE_BEGIN
);
7611 DWORD n1
= 0, n2
= 0;
7613 success
= ReadFile(handle
, buf1
, sizeof(buf1
), &n1
, NULL
);
7614 ok_(file
,line
)(success
, "Failed to read from file.\n");
7615 if (success
&& n1
== 0)
7619 n2
= recv(sock
, buf2
, n1
, 0);
7620 ok_(file
,line
)(n1
== n2
, "Block %d size mismatch (%d != %d)\n", i
, n1
, n2
);
7621 ok_(file
,line
)(memcmp(buf1
, buf2
, n2
) == 0, "Block %d failed\n", i
);
7626 static void test_TransmitFile(void)
7628 DWORD num_bytes
, err
, file_size
, total_sent
;
7629 GUID transmitFileGuid
= WSAID_TRANSMITFILE
;
7630 LPFN_TRANSMITFILE pTransmitFile
= NULL
;
7631 HANDLE file
= INVALID_HANDLE_VALUE
;
7632 char header_msg
[] = "hello world";
7633 char footer_msg
[] = "goodbye!!!";
7634 char system_ini_path
[MAX_PATH
];
7635 struct sockaddr_in bindAddress
;
7636 TRANSMIT_FILE_BUFFERS buffers
;
7637 SOCKET client
, server
, dest
;
7643 memset( &ov
, 0, sizeof(ov
) );
7645 /* Setup sockets for testing TransmitFile */
7646 client
= socket(AF_INET
, SOCK_STREAM
, 0);
7647 ok(client
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7648 server
= socket(AF_INET
, SOCK_STREAM
, 0);
7649 ok(server
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7650 iret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &transmitFileGuid
, sizeof(transmitFileGuid
),
7651 &pTransmitFile
, sizeof(pTransmitFile
), &num_bytes
, NULL
, NULL
);
7652 ok(!iret
, "failed to get TransmitFile, error %u\n", GetLastError());
7653 GetSystemWindowsDirectoryA(system_ini_path
, MAX_PATH
);
7654 strcat(system_ini_path
, "\\system.ini");
7655 file
= CreateFileA(system_ini_path
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_ALWAYS
, 0x0, NULL
);
7656 ok(file
!= INVALID_HANDLE_VALUE
, "failed to open file, error %u\n", GetLastError());
7657 file_size
= GetFileSize(file
, NULL
);
7659 /* Test TransmitFile with an invalid socket */
7660 bret
= pTransmitFile(INVALID_SOCKET
, file
, 0, 0, NULL
, NULL
, 0);
7661 err
= WSAGetLastError();
7662 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
7663 ok(err
== WSAENOTSOCK
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTSOCK
);
7665 /* Test a bogus TransmitFile without a connected socket */
7666 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, TF_REUSE_SOCKET
);
7667 err
= WSAGetLastError();
7668 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
7669 ok(err
== WSAENOTCONN
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTCONN
);
7671 /* Setup a properly connected socket for transfers */
7672 memset(&bindAddress
, 0, sizeof(bindAddress
));
7673 bindAddress
.sin_family
= AF_INET
;
7674 bindAddress
.sin_port
= htons(SERVERPORT
+1);
7675 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7676 iret
= bind(server
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7677 ok(!iret
, "failed to bind socket, error %u\n", GetLastError());
7678 iret
= listen(server
, 1);
7679 ok(!iret
, "failed to listen, error %u\n", GetLastError());
7680 iret
= connect(client
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7681 ok(!iret
, "failed to connect, error %u\n", GetLastError());
7682 len
= sizeof(bindAddress
);
7683 dest
= accept(server
, (struct sockaddr
*)&bindAddress
, &len
);
7684 ok(dest
!= INVALID_SOCKET
, "failed to accept, error %u\n", GetLastError());
7685 iret
= set_blocking(dest
, FALSE
);
7686 ok(!iret
, "failed to set nonblocking, error %u\n", GetLastError());
7688 /* Test TransmitFile with no possible buffer */
7689 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, 0);
7690 ok(bret
, "TransmitFile failed unexpectedly.\n");
7691 iret
= recv(dest
, buf
, sizeof(buf
), 0);
7692 ok(iret
== -1, "Returned an unexpected buffer from TransmitFile (%d != -1).\n", iret
);
7694 /* Test TransmitFile with only buffer data */
7695 buffers
.Head
= &header_msg
[0];
7696 buffers
.HeadLength
= sizeof(header_msg
);
7697 buffers
.Tail
= &footer_msg
[0];
7698 buffers
.TailLength
= sizeof(footer_msg
);
7699 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, &buffers
, 0);
7700 ok(bret
, "TransmitFile failed unexpectedly.\n");
7701 iret
= recv(dest
, buf
, sizeof(buf
), 0);
7702 ok(iret
== sizeof(header_msg
)+sizeof(footer_msg
),
7703 "Returned an unexpected buffer from TransmitFile: %d\n", iret
);
7704 ok(memcmp(&buf
[0], &header_msg
[0], sizeof(header_msg
)) == 0,
7705 "TransmitFile header buffer did not match!\n");
7706 ok(memcmp(&buf
[sizeof(header_msg
)], &footer_msg
[0], sizeof(footer_msg
)) == 0,
7707 "TransmitFile footer buffer did not match!\n");
7709 /* Test TransmitFile with only file data */
7710 bret
= pTransmitFile(client
, file
, 0, 0, NULL
, NULL
, 0);
7711 ok(bret
, "TransmitFile failed unexpectedly.\n");
7712 compare_file(file
, dest
, 0);
7714 /* Test TransmitFile with both file and buffer data */
7715 buffers
.Head
= &header_msg
[0];
7716 buffers
.HeadLength
= sizeof(header_msg
);
7717 buffers
.Tail
= &footer_msg
[0];
7718 buffers
.TailLength
= sizeof(footer_msg
);
7719 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
7720 bret
= pTransmitFile(client
, file
, 0, 0, NULL
, &buffers
, 0);
7721 ok(bret
, "TransmitFile failed unexpectedly.\n");
7722 iret
= recv(dest
, buf
, sizeof(header_msg
), 0);
7723 ok(memcmp(buf
, &header_msg
[0], sizeof(header_msg
)) == 0,
7724 "TransmitFile header buffer did not match!\n");
7725 compare_file(file
, dest
, 0);
7726 iret
= recv(dest
, buf
, sizeof(footer_msg
), 0);
7727 ok(memcmp(buf
, &footer_msg
[0], sizeof(footer_msg
)) == 0,
7728 "TransmitFile footer buffer did not match!\n");
7730 /* Test overlapped TransmitFile */
7731 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
7732 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
7733 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, NULL
, 0);
7734 err
= WSAGetLastError();
7735 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
7736 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n",
7737 err
, ERROR_IO_PENDING
);
7738 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
7739 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
7740 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
7741 ok(total_sent
== file_size
,
7742 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
7743 total_sent
, file_size
);
7744 compare_file(file
, dest
, 0);
7746 /* Test overlapped TransmitFile w/ start offset */
7747 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
7748 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
7750 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, NULL
, 0);
7751 err
= WSAGetLastError();
7752 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
7753 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, ERROR_IO_PENDING
);
7754 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
7755 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
7756 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
7757 ok(total_sent
== (file_size
- ov
.Offset
),
7758 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
7759 total_sent
, file_size
- ov
.Offset
);
7760 compare_file(file
, dest
, ov
.Offset
);
7762 /* Test overlapped TransmitFile w/ file and buffer data */
7763 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
7764 buffers
.Head
= &header_msg
[0];
7765 buffers
.HeadLength
= sizeof(header_msg
);
7766 buffers
.Tail
= &footer_msg
[0];
7767 buffers
.TailLength
= sizeof(footer_msg
);
7768 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
7770 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, &buffers
, 0);
7771 err
= WSAGetLastError();
7772 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
7773 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, ERROR_IO_PENDING
);
7774 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
7775 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
7776 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
7777 ok(total_sent
== (file_size
+ buffers
.HeadLength
+ buffers
.TailLength
),
7778 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
7779 total_sent
, file_size
+ buffers
.HeadLength
+ buffers
.TailLength
);
7780 iret
= recv(dest
, buf
, sizeof(header_msg
), 0);
7781 ok(memcmp(buf
, &header_msg
[0], sizeof(header_msg
)) == 0,
7782 "TransmitFile header buffer did not match!\n");
7783 compare_file(file
, dest
, 0);
7784 iret
= recv(dest
, buf
, sizeof(footer_msg
), 0);
7785 ok(memcmp(buf
, &footer_msg
[0], sizeof(footer_msg
)) == 0,
7786 "TransmitFile footer buffer did not match!\n");
7788 /* Test TransmitFile with a UDP datagram socket */
7789 closesocket(client
);
7790 client
= socket(AF_INET
, SOCK_DGRAM
, 0);
7791 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, 0);
7792 err
= WSAGetLastError();
7793 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
7794 ok(err
== WSAENOTCONN
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTCONN
);
7797 CloseHandle(ov
.hEvent
);
7798 closesocket(client
);
7799 closesocket(server
);
7802 static void test_getpeername(void)
7805 struct sockaddr_in sa
, sa_out
;
7806 SOCKADDR_STORAGE ss
;
7808 const char buf
[] = "hello world";
7811 /* Test the parameter validation order. */
7812 ret
= getpeername(INVALID_SOCKET
, NULL
, NULL
);
7813 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
7814 ok(WSAGetLastError() == WSAENOTSOCK
,
7815 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
7817 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
7818 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
7820 ret
= getpeername(sock
, NULL
, NULL
);
7821 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
7822 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
,
7823 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
7825 memset(&sa
, 0, sizeof(sa
));
7826 sa
.sin_family
= AF_INET
;
7827 sa
.sin_port
= htons(139);
7828 sa
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7830 /* sendto does not change a socket's connection state. */
7831 ret
= sendto(sock
, buf
, sizeof(buf
), 0, (struct sockaddr
*)&sa
, sizeof(sa
));
7832 ok(ret
!= SOCKET_ERROR
,
7833 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
7835 ret
= getpeername(sock
, NULL
, NULL
);
7836 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
7837 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
,
7838 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
7840 ret
= connect(sock
, (struct sockaddr
*)&sa
, sizeof(sa
));
7842 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
7844 ret
= getpeername(sock
, NULL
, NULL
);
7845 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
7846 ok(WSAGetLastError() == WSAEFAULT
,
7847 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7849 /* Test crashes on Wine. */
7852 ret
= getpeername(sock
, (void*)0xdeadbeef, (void*)0xcafebabe);
7853 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
7854 ok(WSAGetLastError() == WSAEFAULT
,
7855 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7858 ret
= getpeername(sock
, (struct sockaddr
*)&sa_out
, NULL
);
7859 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
7860 ok(WSAGetLastError() == WSAEFAULT
,
7861 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7864 ret
= getpeername(sock
, NULL
, &sa_len
);
7865 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
7866 ok(WSAGetLastError() == WSAEFAULT
,
7867 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7868 ok(!sa_len
, "got %d\n", sa_len
);
7871 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
7872 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
7873 ok(WSAGetLastError() == WSAEFAULT
,
7874 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7875 ok(!sa_len
, "got %d\n", sa_len
);
7877 sa_len
= sizeof(ss
);
7878 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
7879 ok(ret
== 0, "Expected getpeername to return 0, got %d\n", ret
);
7880 ok(!memcmp(&sa
, &ss
, sizeof(sa
)),
7881 "Expected the returned structure to be identical to the connect structure\n");
7882 ok(sa_len
== sizeof(sa
), "got %d\n", sa_len
);
7887 static void test_sioRoutingInterfaceQuery(void)
7889 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
7890 struct sockaddr_in in
= {0}, out
= {0};
7897 sock
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
7898 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
7899 port
= CreateIoCompletionPort((HANDLE
)sock
, NULL
, 123, 0);
7901 WSASetLastError(0xdeadbeef);
7902 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), NULL
, NULL
, NULL
);
7903 ok(ret
== -1, "expected failure\n");
7904 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
7907 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
) - 1, &out
, sizeof(out
), &size
, NULL
, NULL
);
7908 ok(ret
== -1, "expected failure\n");
7909 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
7910 ok(size
== 0xdeadbeef, "got size %u\n", size
);
7913 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, NULL
, sizeof(in
), &out
, sizeof(out
), &size
, NULL
, NULL
);
7914 ok(ret
== -1, "expected failure\n");
7915 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
7916 ok(size
== 0xdeadbeef, "got size %u\n", size
);
7919 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), &size
, NULL
, NULL
);
7920 ok(ret
== -1, "expected failure\n");
7921 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "got error %u\n", WSAGetLastError());
7922 ok(size
== 0xdeadbeef, "got size %u\n", size
);
7924 in
.sin_family
= AF_INET
;
7926 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), &size
, NULL
, NULL
);
7927 todo_wine
ok(ret
== -1, "expected failure\n");
7928 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
7929 todo_wine
ok(size
== 0xdeadbeef, "got size %u\n", size
);
7931 in
.sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
7932 WSASetLastError(0xdeadbeef);
7934 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), &size
, NULL
, NULL
);
7935 ok(!ret
, "expected failure\n");
7936 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
7937 ok(size
== sizeof(out
), "got size %u\n", size
);
7938 /* We expect the source address to be INADDR_LOOPBACK as well, but
7939 * there's no guarantee that a route to the loopback address exists,
7940 * so rather than introduce spurious test failures we do not test the
7945 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
) - 1, &size
, NULL
, NULL
);
7946 ok(ret
== -1, "expected failure\n");
7947 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
7948 todo_wine
ok(size
== sizeof(out
), "got size %u\n", size
);
7951 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), NULL
, sizeof(out
), &size
, NULL
, NULL
);
7952 ok(ret
== -1, "expected failure\n");
7953 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
7954 ok(size
== 0xdeadbeef, "got size %u\n", size
);
7956 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), NULL
, &overlapped
, NULL
);
7957 ok(ret
== -1, "expected failure\n");
7958 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
7959 ok(size
== 0xdeadbeef, "got size %u\n", size
);
7961 WSASetLastError(0xdeadbeef);
7963 overlapped
.Internal
= 0xdeadbeef;
7964 overlapped
.InternalHigh
= 0xdeadbeef;
7965 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), &size
, &overlapped
, NULL
);
7966 ok(!ret
, "expected failure\n");
7967 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
7968 ok(size
== sizeof(out
), "got size %u\n", size
);
7970 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
7971 ok(ret
, "got error %u\n", GetLastError());
7972 ok(!size
, "got size %u\n", size
);
7973 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
7974 ok(!overlapped
.Internal
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
7975 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
7980 sock
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
7982 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
),
7983 &out
, sizeof(out
), NULL
, &overlapped
, socket_apc
);
7984 ok(ret
== -1, "expected failure\n");
7985 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
7989 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
),
7990 &out
, sizeof(out
), &size
, &overlapped
, socket_apc
);
7991 ok(!ret
, "expected success\n");
7992 ok(size
== sizeof(out
), "got size %u\n", size
);
7994 ret
= SleepEx(0, TRUE
);
7995 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
7996 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
7997 ok(!apc_error
, "got APC error %u\n", apc_error
);
7998 ok(!apc_size
, "got APC size %u\n", apc_size
);
7999 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
8004 static void test_sioAddressListChange(void)
8006 struct sockaddr_in bindAddress
;
8007 struct in_addr net_address
;
8008 WSAOVERLAPPED overlapped
, *olp
;
8010 DWORD num_bytes
, error
, tick
;
8011 SOCKET sock
, sock2
, sock3
;
8012 WSAEVENT event2
, event3
;
8019 /* Use gethostbyname to find the list of local network interfaces */
8020 h
= gethostbyname("");
8021 ok(!!h
, "failed to get interface list, error %u\n", WSAGetLastError());
8022 for (acount
= 0; h
->h_addr_list
[acount
]; acount
++);
8025 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
8029 net_address
.s_addr
= *(ULONG
*) h
->h_addr_list
[0];
8031 sock
= socket(AF_INET
, 0, IPPROTO_TCP
);
8032 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
8034 memset(&bindAddress
, 0, sizeof(bindAddress
));
8035 bindAddress
.sin_family
= AF_INET
;
8036 bindAddress
.sin_addr
.s_addr
= net_address
.s_addr
;
8037 SetLastError(0xdeadbeef);
8038 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8039 ok (!ret
, "bind() failed with error %d\n", GetLastError());
8040 set_blocking(sock
, FALSE
);
8042 memset(&overlapped
, 0, sizeof(overlapped
));
8043 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8044 SetLastError(0xdeadbeef);
8045 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8046 error
= GetLastError();
8047 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
8048 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
8050 CloseHandle(overlapped
.hEvent
);
8053 sock
= socket(AF_INET
, 0, IPPROTO_TCP
);
8054 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
8056 SetLastError(0xdeadbeef);
8057 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8058 ok (!ret
, "bind() failed with error %d\n", GetLastError());
8059 set_blocking(sock
, TRUE
);
8061 memset(&overlapped
, 0, sizeof(overlapped
));
8062 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8063 SetLastError(0xdeadbeef);
8064 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8065 error
= GetLastError();
8066 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
8067 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
8069 CloseHandle(overlapped
.hEvent
);
8072 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8073 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
8075 SetLastError(0xdeadbeef);
8076 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8077 ok (!ret
, "bind() failed with error %d\n", GetLastError());
8078 set_blocking(sock
, FALSE
);
8080 memset(&overlapped
, 0, sizeof(overlapped
));
8081 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8082 SetLastError(0xdeadbeef);
8083 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8084 error
= GetLastError();
8085 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
8086 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
8088 CloseHandle(overlapped
.hEvent
);
8091 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8092 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
8094 SetLastError(0xdeadbeef);
8095 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8096 ok (!ret
, "bind() failed with error %d\n", GetLastError());
8097 set_blocking(sock
, TRUE
);
8099 memset(&overlapped
, 0, sizeof(overlapped
));
8100 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8101 SetLastError(0xdeadbeef);
8102 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8103 error
= GetLastError();
8104 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
8105 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
8107 CloseHandle(overlapped
.hEvent
);
8110 /* When the socket is overlapped non-blocking and the list change is requested without
8111 * an overlapped structure the error will be different. */
8112 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8113 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
8115 SetLastError(0xdeadbeef);
8116 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8117 ok (!ret
, "bind() failed with error %d\n", GetLastError());
8118 set_blocking(sock
, FALSE
);
8120 SetLastError(0xdeadbeef);
8121 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
8122 error
= GetLastError();
8123 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
8124 ok (error
== WSAEWOULDBLOCK
, "expected 10035, got %d\n", error
);
8126 io_port
= CreateIoCompletionPort( (HANDLE
)sock
, NULL
, 0, 0 );
8127 ok (io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8129 set_blocking(sock
, FALSE
);
8130 memset(&overlapped
, 0, sizeof(overlapped
));
8131 SetLastError(0xdeadbeef);
8132 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8133 error
= GetLastError();
8134 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %u\n", error
);
8135 ok (error
== ERROR_IO_PENDING
, "expected ERROR_IO_PENDING got %u\n", error
);
8137 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8138 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 0 );
8139 ok(!bret
, "failed to get completion status %u\n", bret
);
8140 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8141 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8145 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8146 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 0 );
8147 ok(!bret
, "failed to get completion status %u\n", bret
);
8148 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %u\n", GetLastError());
8149 ok(olp
== &overlapped
, "Overlapped structure is at %p\n", olp
);
8151 CloseHandle(io_port
);
8153 /* Misuse of the API by using a blocking socket and not using an overlapped structure,
8154 * this leads to a hang forever. */
8157 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8159 SetLastError(0xdeadbeef);
8160 bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8162 set_blocking(sock
, TRUE
);
8163 WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
8169 if (!winetest_interactive
)
8171 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
8175 /* Bind an overlapped socket to the first found network interface */
8176 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8177 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
8178 sock2
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8179 ok(sock2
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
8180 sock3
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8181 ok(sock3
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
8183 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8184 ok(!ret
, "bind failed unexpectedly\n");
8185 ret
= bind(sock2
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8186 ok(!ret
, "bind failed unexpectedly\n");
8187 ret
= bind(sock3
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8188 ok(!ret
, "bind failed unexpectedly\n");
8190 set_blocking(sock2
, FALSE
);
8191 set_blocking(sock3
, FALSE
);
8193 /* Wait for address changes, request that the user connects/disconnects an interface */
8194 memset(&overlapped
, 0, sizeof(overlapped
));
8195 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8196 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8197 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
8198 ok(WSAGetLastError() == WSA_IO_PENDING
, "Expected pending last error, got %d\n", WSAGetLastError());
8200 ret
= WSAIoctl(sock2
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
8201 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
8202 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "Expected would block last error, got %d\n", WSAGetLastError());
8204 event2
= WSACreateEvent();
8205 event3
= WSACreateEvent();
8206 ret
= WSAEventSelect (sock2
, event2
, FD_ADDRESS_LIST_CHANGE
);
8207 ok(!ret
, "WSAEventSelect failed with %d\n", WSAGetLastError());
8208 /* sock3 did not request SIO_ADDRESS_LIST_CHANGE but it is trying to wait anyway */
8209 ret
= WSAEventSelect (sock3
, event3
, FD_ADDRESS_LIST_CHANGE
);
8210 ok(!ret
, "WSAEventSelect failed with %d\n", WSAGetLastError());
8212 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
8213 " change the ipv4 address of any of the local network interfaces (15 second timeout).\n");
8214 tick
= GetTickCount();
8215 ret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
8216 ok(ret
== WAIT_OBJECT_0
, "failed to get overlapped event %u\n", ret
);
8218 ret
= WaitForSingleObject(event2
, 500);
8220 ok(ret
== WAIT_OBJECT_0
, "failed to get change event %u\n", ret
);
8222 ret
= WaitForSingleObject(event3
, 500);
8223 ok(ret
== WAIT_TIMEOUT
, "unexpected change event\n");
8225 trace("Spent %d ms waiting.\n", GetTickCount() - tick
);
8227 WSACloseEvent(event2
);
8228 WSACloseEvent(event3
);
8236 * Provide consistent initialization for the AcceptEx IOCP tests.
8238 static SOCKET
setup_iocp_src(struct sockaddr_in
*bindAddress
)
8243 src
= socket(AF_INET
, SOCK_STREAM
, 0);
8244 ok(src
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8246 memset(bindAddress
, 0, sizeof(*bindAddress
));
8247 bindAddress
->sin_family
= AF_INET
;
8248 bindAddress
->sin_addr
.s_addr
= inet_addr("127.0.0.1");
8249 iret
= bind(src
, (struct sockaddr
*)bindAddress
, sizeof(*bindAddress
));
8250 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
8252 socklen
= sizeof(*bindAddress
);
8253 iret
= getsockname(src
, (struct sockaddr
*)bindAddress
, &socklen
);
8254 ok(!iret
, "failed to get address, error %u\n", WSAGetLastError());
8256 iret
= set_blocking(src
, FALSE
);
8257 ok(!iret
, "failed to make socket non-blocking, error %u\n", WSAGetLastError());
8259 iret
= listen(src
, 5);
8260 ok(!iret
, "failed to listen, error %u\n", WSAGetLastError());
8265 static void test_completion_port(void)
8268 WSAOVERLAPPED ov
, *olp
;
8269 SOCKET src
, dest
, dup
, connector
= INVALID_SOCKET
;
8270 WSAPROTOCOL_INFOA info
;
8273 DWORD num_bytes
, flags
;
8278 struct sockaddr_in bindAddress
;
8279 GUID acceptExGuid
= WSAID_ACCEPTEX
;
8280 LPFN_ACCEPTEX pAcceptEx
= NULL
;
8283 memset(buf
, 0, sizeof(buf
));
8284 io_port
= CreateIoCompletionPort(INVALID_HANDLE_VALUE
, NULL
, 0, 0);
8285 ok( io_port
!= NULL
, "Failed to create completion port %u\n", GetLastError());
8287 memset(&ov
, 0, sizeof(ov
));
8289 tcp_socketpair(&src
, &dest
);
8291 bufs
.len
= sizeof(buf
);
8297 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
8298 ok(!iret
, "Failed to set linger %d\n", GetLastError());
8300 io_port
= CreateIoCompletionPort( (HANDLE
)dest
, io_port
, 125, 0 );
8301 ok(io_port
!= NULL
, "Failed to create completion port %u\n", GetLastError());
8303 SetLastError(0xdeadbeef);
8305 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
8306 ok(iret
== SOCKET_ERROR
, "WSARecv returned %d\n", iret
);
8307 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8312 src
= INVALID_SOCKET
;
8314 SetLastError(0xdeadbeef);
8316 num_bytes
= 0xdeadbeef;
8317 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8319 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8320 todo_wine
ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %d\n", bret
);
8321 todo_wine
ok(GetLastError() == ERROR_NETNAME_DELETED
, "Last error was %d\n", GetLastError());
8322 ok(key
== 125, "Key is %lu\n", key
);
8323 ok(num_bytes
== 0, "Number of bytes received is %u\n", num_bytes
);
8324 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8326 SetLastError(0xdeadbeef);
8328 num_bytes
= 0xdeadbeef;
8329 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8331 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8332 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %d\n", bret
);
8333 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8334 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8335 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8336 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8338 if (dest
!= INVALID_SOCKET
)
8341 memset(&ov
, 0, sizeof(ov
));
8343 tcp_socketpair(&src
, &dest
);
8345 bufs
.len
= sizeof(buf
);
8351 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
8352 ok(!iret
, "Failed to set linger %d\n", GetLastError());
8354 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 125, 0);
8355 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8357 set_blocking(dest
, FALSE
);
8360 src
= INVALID_SOCKET
;
8364 num_bytes
= 0xdeadbeef;
8365 SetLastError(0xdeadbeef);
8367 iret
= WSASend(dest
, &bufs
, 1, &num_bytes
, 0, &ov
, NULL
);
8368 ok(iret
== SOCKET_ERROR
, "WSASend failed - %d\n", iret
);
8369 ok(GetLastError() == WSAECONNRESET
, "Last error was %d\n", GetLastError());
8370 ok(num_bytes
== 0xdeadbeef, "Managed to send %d\n", num_bytes
);
8372 SetLastError(0xdeadbeef);
8374 num_bytes
= 0xdeadbeef;
8375 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8377 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8378 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
8379 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8380 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8381 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8382 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8384 if (dest
!= INVALID_SOCKET
)
8387 /* Test IOCP response on successful immediate read. */
8388 tcp_socketpair(&src
, &dest
);
8390 bufs
.len
= sizeof(buf
);
8393 SetLastError(0xdeadbeef);
8395 iret
= WSASend(src
, &bufs
, 1, &num_bytes
, 0, &ov
, NULL
);
8396 ok(!iret
, "WSASend failed - %d, last error %u\n", iret
, GetLastError());
8397 ok(num_bytes
== sizeof(buf
), "Managed to send %d\n", num_bytes
);
8399 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 125, 0);
8400 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8401 set_blocking(dest
, FALSE
);
8404 FD_SET(dest
, &fds_recv
);
8405 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
8407 num_bytes
= 0xdeadbeef;
8410 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
8411 ok(!iret
, "WSARecv failed - %d, last error %u\n", iret
, GetLastError());
8412 ok(num_bytes
== sizeof(buf
), "Managed to read %d\n", num_bytes
);
8414 SetLastError(0xdeadbeef);
8416 num_bytes
= 0xdeadbeef;
8417 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8419 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8420 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
8421 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
8422 ok(key
== 125, "Key is %lu\n", key
);
8423 ok(num_bytes
== sizeof(buf
), "Number of bytes transferred is %u\n", num_bytes
);
8424 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8426 /* Test IOCP response on graceful shutdown. */
8430 FD_SET(dest
, &fds_recv
);
8431 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
8433 num_bytes
= 0xdeadbeef;
8435 memset(&ov
, 0, sizeof(ov
));
8437 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
8438 ok(!iret
, "WSARecv failed - %d, last error %u\n", iret
, GetLastError());
8439 ok(!num_bytes
, "Managed to read %d\n", num_bytes
);
8441 SetLastError(0xdeadbeef);
8443 num_bytes
= 0xdeadbeef;
8444 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8446 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8447 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
8448 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
8449 ok(key
== 125, "Key is %lu\n", key
);
8450 ok(!num_bytes
, "Number of bytes transferred is %u\n", num_bytes
);
8451 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8454 src
= INVALID_SOCKET
;
8456 dest
= INVALID_SOCKET
;
8458 /* Test IOCP response on hard shutdown. This was the condition that triggered
8459 * a crash in an actual app (bug 38980). */
8460 tcp_socketpair(&src
, &dest
);
8462 bufs
.len
= sizeof(buf
);
8465 memset(&ov
, 0, sizeof(ov
));
8469 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
8470 ok(!iret
, "Failed to set linger %d\n", GetLastError());
8472 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 125, 0);
8473 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8474 set_blocking(dest
, FALSE
);
8477 src
= INVALID_SOCKET
;
8480 FD_SET(dest
, &fds_recv
);
8481 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
8483 num_bytes
= 0xdeadbeef;
8484 SetLastError(0xdeadbeef);
8486 /* Somehow a hard shutdown doesn't work on my Linux box. It seems SO_LINGER is ignored. */
8487 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
8488 todo_wine
ok(iret
== SOCKET_ERROR
, "WSARecv failed - %d\n", iret
);
8489 todo_wine
ok(GetLastError() == WSAECONNRESET
, "Last error was %d\n", GetLastError());
8490 todo_wine
ok(num_bytes
== 0xdeadbeef, "Managed to read %d\n", num_bytes
);
8492 SetLastError(0xdeadbeef);
8494 num_bytes
= 0xdeadbeef;
8495 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8497 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8498 todo_wine
ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
8499 todo_wine
ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8500 todo_wine
ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8501 todo_wine
ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8502 todo_wine
ok(!olp
, "Overlapped structure is at %p\n", olp
);
8506 /* Test reading from a non-connected socket, mostly because the above test is marked todo. */
8507 dest
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8508 ok(dest
!= INVALID_SOCKET
, "socket() failed\n");
8510 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 125, 0);
8511 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8512 set_blocking(dest
, FALSE
);
8514 num_bytes
= 0xdeadbeef;
8515 SetLastError(0xdeadbeef);
8516 memset(&ov
, 0, sizeof(ov
));
8518 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
8519 ok(iret
== SOCKET_ERROR
, "WSARecv failed - %d\n", iret
);
8520 ok(GetLastError() == WSAENOTCONN
, "Last error was %d\n", GetLastError());
8521 ok(num_bytes
== 0xdeadbeef, "Managed to read %d\n", num_bytes
);
8523 SetLastError(0xdeadbeef);
8525 num_bytes
= 0xdeadbeef;
8526 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8528 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8529 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
8530 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8531 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8532 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8533 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8535 num_bytes
= 0xdeadbeef;
8538 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
8539 ok(dest
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8541 iret
= WSAIoctl(dest
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
8542 &pAcceptEx
, sizeof(pAcceptEx
), &num_bytes
, NULL
, NULL
);
8543 ok(!iret
, "failed to get AcceptEx, error %u\n", WSAGetLastError());
8545 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
8547 src
= setup_iocp_src(&bindAddress
);
8549 SetLastError(0xdeadbeef);
8551 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8552 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8554 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8555 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8557 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8558 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8561 src
= INVALID_SOCKET
;
8563 SetLastError(0xdeadbeef);
8565 num_bytes
= 0xdeadbeef;
8566 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8568 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8569 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8570 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
8571 ok(key
== 125, "Key is %lu\n", key
);
8572 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
8573 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8574 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8576 SetLastError(0xdeadbeef);
8578 num_bytes
= 0xdeadbeef;
8579 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8580 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8581 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8582 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8583 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8584 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8585 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8587 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
8589 src
= setup_iocp_src(&bindAddress
);
8591 SetLastError(0xdeadbeef);
8593 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8594 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8596 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8597 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8599 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8600 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8603 src
= INVALID_SOCKET
;
8605 SetLastError(0xdeadbeef);
8607 num_bytes
= 0xdeadbeef;
8608 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8610 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8611 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8612 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
8613 ok(key
== 125, "Key is %lu\n", key
);
8614 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
8615 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8616 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8618 SetLastError(0xdeadbeef);
8620 num_bytes
= 0xdeadbeef;
8621 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8622 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8623 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8624 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8625 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8626 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8627 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8629 /* Test IOCP with duplicated handle */
8631 src
= setup_iocp_src(&bindAddress
);
8633 SetLastError(0xdeadbeef);
8635 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8636 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8638 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
8639 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
8640 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
8642 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8643 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8645 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8646 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8648 SetLastError(0xdeadbeef);
8650 num_bytes
= 0xdeadbeef;
8651 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8652 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8653 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8654 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8655 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8656 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8657 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8660 src
= INVALID_SOCKET
;
8662 dup
= INVALID_SOCKET
;
8664 SetLastError(0xdeadbeef);
8666 num_bytes
= 0xdeadbeef;
8667 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8668 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8669 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8670 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
8671 ok(key
== 125, "Key is %lu\n", key
);
8672 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
8673 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8674 ok(olp
&& olp
->Internal
== (ULONG
)STATUS_CANCELLED
, "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8676 SetLastError(0xdeadbeef);
8678 num_bytes
= 0xdeadbeef;
8679 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8680 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8681 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8682 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8683 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8684 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8685 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8687 /* Test IOCP with duplicated handle (closing duplicated handle) */
8689 src
= setup_iocp_src(&bindAddress
);
8691 SetLastError(0xdeadbeef);
8693 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8694 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8696 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
8697 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
8698 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
8700 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8701 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8703 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8704 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8707 dup
= INVALID_SOCKET
;
8709 SetLastError(0xdeadbeef);
8711 num_bytes
= 0xdeadbeef;
8712 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8713 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8714 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8715 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8716 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8717 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8718 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8720 SetLastError(0xdeadbeef);
8722 num_bytes
= 0xdeadbeef;
8723 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8724 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8725 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8726 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8727 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8728 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8729 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8732 src
= INVALID_SOCKET
;
8734 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8735 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8736 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
8737 ok(key
== 125, "Key is %lu\n", key
);
8738 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
8739 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8740 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8742 SetLastError(0xdeadbeef);
8744 num_bytes
= 0xdeadbeef;
8745 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8746 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8747 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8748 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8749 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8750 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8751 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8753 /* Test IOCP with duplicated handle (closing original handle) */
8755 src
= setup_iocp_src(&bindAddress
);
8757 SetLastError(0xdeadbeef);
8759 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8760 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8762 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
8763 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
8764 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
8766 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8767 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8769 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8770 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8773 src
= INVALID_SOCKET
;
8775 SetLastError(0xdeadbeef);
8777 num_bytes
= 0xdeadbeef;
8778 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8779 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8780 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8781 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8782 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8783 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8784 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8787 dup
= INVALID_SOCKET
;
8789 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8790 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8791 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
8792 ok(key
== 125, "Key is %lu\n", key
);
8793 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
8794 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8795 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8797 SetLastError(0xdeadbeef);
8799 num_bytes
= 0xdeadbeef;
8800 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8801 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8802 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8803 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8804 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8805 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8806 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8808 /* Test IOCP without AcceptEx */
8810 src
= setup_iocp_src(&bindAddress
);
8812 SetLastError(0xdeadbeef);
8814 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8815 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8818 src
= INVALID_SOCKET
;
8820 SetLastError(0xdeadbeef);
8822 num_bytes
= 0xdeadbeef;
8823 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8824 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8825 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8826 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8827 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8828 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8829 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8833 src
= setup_iocp_src(&bindAddress
);
8835 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8836 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8838 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8839 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8841 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 236, 0);
8842 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8844 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8845 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8847 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8848 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8850 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8851 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
8853 closesocket(connector
);
8854 connector
= INVALID_SOCKET
;
8856 SetLastError(0xdeadbeef);
8858 num_bytes
= 0xdeadbeef;
8859 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8861 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8862 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
8863 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
8864 ok(key
== 125, "Key is %lu\n", key
);
8865 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
8866 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8867 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8869 SetLastError(0xdeadbeef);
8871 num_bytes
= 0xdeadbeef;
8872 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8873 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8874 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8875 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8876 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8877 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8878 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8880 if (dest
!= INVALID_SOCKET
)
8882 if (src
!= INVALID_SOCKET
)
8887 src
= setup_iocp_src(&bindAddress
);
8889 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
8890 ok(dest
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8892 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8893 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8895 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8896 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8898 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 236, 0);
8899 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8901 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8902 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8904 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8905 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8907 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8908 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
8910 iret
= send(connector
, buf
, 1, 0);
8911 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
8916 dest
= INVALID_SOCKET
;
8918 SetLastError(0xdeadbeef);
8920 num_bytes
= 0xdeadbeef;
8921 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8923 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8924 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
8925 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
8926 ok(key
== 125, "Key is %lu\n", key
);
8927 ok(num_bytes
== 1, "Number of bytes transferred is %u\n", num_bytes
);
8928 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8929 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8931 SetLastError(0xdeadbeef);
8933 num_bytes
= 0xdeadbeef;
8934 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8935 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8936 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8937 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8938 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8939 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8940 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8942 if (src
!= INVALID_SOCKET
)
8944 if (connector
!= INVALID_SOCKET
)
8945 closesocket(connector
);
8949 src
= setup_iocp_src(&bindAddress
);
8951 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
8952 ok(dest
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8954 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8955 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8957 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8958 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8960 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 236, 0);
8961 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8963 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8964 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8966 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8967 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8969 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8970 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
8974 SetLastError(0xdeadbeef);
8976 num_bytes
= 0xdeadbeef;
8977 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8979 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8980 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8981 ok(GetLastError() == ERROR_OPERATION_ABORTED
8982 || GetLastError() == ERROR_CONNECTION_ABORTED
, "got error %u\n", GetLastError());
8983 ok(key
== 125, "Key is %lu\n", key
);
8984 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
8985 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8986 ok((NTSTATUS
)olp
->Internal
== STATUS_CANCELLED
8987 || (NTSTATUS
)olp
->Internal
== STATUS_CONNECTION_ABORTED
, "got status %#lx\n", olp
->Internal
);
8989 SetLastError(0xdeadbeef);
8991 num_bytes
= 0xdeadbeef;
8992 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8993 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8994 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8995 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8996 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8997 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8998 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9001 closesocket(connector
);
9002 CloseHandle(io_port
);
9005 static void test_connect_completion_port(void)
9007 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
9008 GUID connectex_guid
= WSAID_CONNECTEX
;
9009 SOCKET connector
, listener
, acceptor
;
9010 struct sockaddr_in addr
, destaddr
;
9011 LPFN_CONNECTEX pConnectEx
;
9017 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
9019 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9020 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9022 memset(&addr
, 0, sizeof(addr
));
9023 addr
.sin_family
= AF_INET
;
9024 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
9025 ret
= bind(listener
, (struct sockaddr
*)&addr
, sizeof(addr
));
9026 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
9027 addrlen
= sizeof(destaddr
);
9028 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &addrlen
);
9029 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
9031 ret
= listen(listener
, 1);
9032 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
9034 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9035 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9037 ret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectex_guid
, sizeof(connectex_guid
),
9038 &pConnectEx
, sizeof(pConnectEx
), &size
, NULL
, NULL
);
9039 ok(!ret
, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
9041 /* connect() does not queue completion. */
9043 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
9044 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9046 ret
= connect(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
9047 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
9048 acceptor
= accept(listener
, NULL
, NULL
);
9049 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9050 closesocket(acceptor
);
9052 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9053 ok(!ret
, "expected failure\n");
9054 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
9056 closesocket(connector
);
9059 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9060 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9061 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
9062 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9063 set_blocking(connector
, FALSE
);
9065 ret
= connect(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
9066 ok(ret
== -1, "expected failure\n");
9067 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
9068 acceptor
= accept(listener
, NULL
, NULL
);
9069 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9070 closesocket(acceptor
);
9072 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9073 ok(!ret
, "expected failure\n");
9074 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
9076 closesocket(connector
);
9079 /* ConnectEx() queues completion. */
9081 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9082 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9083 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
9084 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9085 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
9086 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
9088 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
9089 NULL
, 0, &size
, &overlapped
);
9090 ok(!ret
, "expected failure\n");
9091 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
9092 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9093 ok(!ret
, "wait failed\n");
9094 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
9095 ok(ret
, "got error %u\n", GetLastError());
9096 ok(!size
, "got %u bytes\n", size
);
9097 acceptor
= accept(listener
, NULL
, NULL
);
9098 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9099 closesocket(acceptor
);
9103 overlapped_ptr
= NULL
;
9104 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9105 ok(ret
, "got error %u\n", GetLastError());
9106 ok(!key
, "got key %#Ix\n", key
);
9107 ok(!size
, "got %u bytes\n", size
);
9108 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
9110 closesocket(connector
);
9113 /* Test ConnectEx() with a non-empty buffer. */
9115 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9116 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9117 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
9118 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9119 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
9120 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
9122 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
9123 (void *)"one", 3, &size
, &overlapped
);
9124 ok(!ret
, "expected failure\n");
9125 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
9126 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9127 ok(!ret
, "wait failed\n");
9128 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
9129 ok(ret
, "got error %u\n", GetLastError());
9130 ok(size
== 3, "got %u bytes\n", size
);
9131 acceptor
= accept(listener
, NULL
, NULL
);
9132 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9133 closesocket(acceptor
);
9137 overlapped_ptr
= NULL
;
9138 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9139 ok(ret
, "got error %u\n", GetLastError());
9140 ok(!key
, "got key %#Ix\n", key
);
9141 ok(size
== 3, "got %u bytes\n", size
);
9142 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
9144 closesocket(connector
);
9147 /* Suppress completion by setting the low bit. */
9149 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9150 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9151 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
9152 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9153 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
9154 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
9156 overlapped
.hEvent
= (HANDLE
)((ULONG_PTR
)overlapped
.hEvent
| 1);
9158 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
9159 NULL
, 0, &size
, &overlapped
);
9160 ok(!ret
, "expected failure\n");
9161 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
9162 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9163 ok(!ret
, "wait failed\n");
9164 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
9165 ok(ret
, "got error %u\n", GetLastError());
9166 ok(!size
, "got %u bytes\n", size
);
9167 acceptor
= accept(listener
, NULL
, NULL
);
9168 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9169 closesocket(acceptor
);
9171 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9172 ok(!ret
, "expected failure\n");
9173 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
9175 closesocket(connector
);
9178 overlapped
.hEvent
= (HANDLE
)((ULONG_PTR
)overlapped
.hEvent
& ~1);
9180 /* Skip completion on success. */
9182 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9183 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9184 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
9185 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9186 ret
= SetFileCompletionNotificationModes((HANDLE
)connector
, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS
);
9187 ok(ret
, "got error %u\n", GetLastError());
9188 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
9189 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
9191 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
9192 NULL
, 0, &size
, &overlapped
);
9193 ok(!ret
, "expected failure\n");
9194 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
9195 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9196 ok(!ret
, "wait failed\n");
9197 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
9198 ok(ret
, "got error %u\n", GetLastError());
9199 ok(!size
, "got %u bytes\n", size
);
9200 acceptor
= accept(listener
, NULL
, NULL
);
9201 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9202 closesocket(acceptor
);
9206 overlapped_ptr
= NULL
;
9207 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9208 ok(ret
, "got error %u\n", GetLastError());
9209 ok(!key
, "got key %#Ix\n", key
);
9210 ok(!size
, "got %u bytes\n", size
);
9211 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
9213 closesocket(connector
);
9216 closesocket(listener
);
9218 /* Connect to an invalid address. */
9220 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9221 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9222 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
9223 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9224 ret
= SetFileCompletionNotificationModes((HANDLE
)connector
, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS
);
9225 ok(ret
, "got error %u\n", GetLastError());
9226 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
9227 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
9229 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
9230 NULL
, 0, &size
, &overlapped
);
9231 ok(!ret
, "expected failure\n");
9232 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
9233 ret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
9234 ok(!ret
, "wait failed\n");
9235 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
9236 ok(!ret
, "expected failure\n");
9237 ok(GetLastError() == ERROR_CONNECTION_REFUSED
, "got error %u\n", GetLastError());
9238 ok(!size
, "got %u bytes\n", size
);
9242 overlapped_ptr
= NULL
;
9243 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9244 ok(!ret
, "expected failure\n");
9245 ok(GetLastError() == ERROR_CONNECTION_REFUSED
, "got error %u\n", GetLastError());
9246 ok(!key
, "got key %#Ix\n", key
);
9247 ok(!size
, "got %u bytes\n", size
);
9248 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
9250 closesocket(connector
);
9254 static void test_shutdown_completion_port(void)
9256 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
9257 GUID disconnectex_guid
= WSAID_DISCONNECTEX
;
9258 struct sockaddr_in addr
, destaddr
;
9259 LPFN_DISCONNECTEX pDisconnectEx
;
9260 SOCKET listener
, server
, client
;
9266 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
9268 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9269 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9271 memset(&addr
, 0, sizeof(addr
));
9272 addr
.sin_family
= AF_INET
;
9273 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
9274 ret
= bind(listener
, (struct sockaddr
*)&addr
, sizeof(addr
));
9275 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
9276 addrlen
= sizeof(destaddr
);
9277 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &addrlen
);
9278 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
9280 ret
= listen(listener
, 1);
9281 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
9283 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9284 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9286 ret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &disconnectex_guid
, sizeof(disconnectex_guid
),
9287 &pDisconnectEx
, sizeof(pDisconnectEx
), &size
, NULL
, NULL
);
9288 ok(!ret
, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
9290 /* shutdown() does not queue completion. */
9292 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
9293 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9294 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
9295 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
9296 server
= accept(listener
, NULL
, NULL
);
9297 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9299 ret
= shutdown(client
, SD_BOTH
);
9300 ok(!ret
, "failed to shutdown, error %u\n", WSAGetLastError());
9302 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9303 ok(!ret
, "expected failure\n");
9304 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
9306 closesocket(server
);
9307 closesocket(client
);
9310 /* WSASendDisconnect() and WSARecvDisconnect() do not queue completion. */
9312 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9313 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9314 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
9315 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9316 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
9317 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
9318 server
= accept(listener
, NULL
, NULL
);
9319 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9321 ret
= WSASendDisconnect(client
, NULL
);
9322 ok(!ret
, "failed to shutdown, error %u\n", WSAGetLastError());
9324 ret
= WSARecvDisconnect(client
, NULL
);
9325 ok(!ret
, "failed to shutdown, error %u\n", WSAGetLastError());
9327 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9328 ok(!ret
, "expected failure\n");
9329 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
9331 closesocket(server
);
9332 closesocket(client
);
9335 /* DisconnectEx() queues completion. */
9337 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9338 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9339 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
9340 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9341 ret
= SetFileCompletionNotificationModes((HANDLE
)client
, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS
);
9342 ok(ret
, "got error %u\n", GetLastError());
9343 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
9344 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
9345 server
= accept(listener
, NULL
, NULL
);
9346 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9348 SetLastError(0xdeadbeef);
9349 ret
= pDisconnectEx(client
, &overlapped
, 0, 0);
9350 ok(!ret
, "expected failure\n");
9351 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
9353 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9354 ok(!ret
, "wait failed\n");
9357 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, TRUE
);
9358 ok(ret
, "got error %u\n", GetLastError());
9359 ok(!size
, "got %u bytes\n", size
);
9363 overlapped_ptr
= NULL
;
9364 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9365 todo_wine
ok(ret
, "got error %u\n", GetLastError());
9366 todo_wine
ok(!key
, "got key %#Ix\n", key
);
9367 todo_wine
ok(!size
, "got %u bytes\n", size
);
9368 todo_wine
ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
9370 closesocket(server
);
9371 closesocket(client
);
9374 /* Test passing a NULL overlapped structure to DisconnectEx(). */
9376 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9377 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9378 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
9379 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9380 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
9381 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
9382 server
= accept(listener
, NULL
, NULL
);
9383 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9385 SetLastError(0xdeadbeef);
9386 ret
= pDisconnectEx(client
, NULL
, 0, 0);
9387 ok(ret
, "expected success\n");
9388 ok(!GetLastError() || GetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", GetLastError());
9390 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9391 ok(!ret
, "expected failure\n");
9392 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
9394 closesocket(server
);
9395 closesocket(client
);
9398 /* Suppress completion by setting the low bit. */
9400 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9401 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9402 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
9403 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9404 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
9405 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
9406 server
= accept(listener
, NULL
, NULL
);
9407 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9409 overlapped
.hEvent
= (HANDLE
)((ULONG_PTR
)overlapped
.hEvent
| 1);
9411 SetLastError(0xdeadbeef);
9412 ret
= pDisconnectEx(client
, &overlapped
, 0, 0);
9413 ok(!ret
, "expected failure\n");
9414 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
9416 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9417 ok(!ret
, "wait failed\n");
9420 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, TRUE
);
9421 ok(ret
, "got error %u\n", GetLastError());
9422 ok(!size
, "got %u bytes\n", size
);
9424 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9425 ok(!ret
, "expected failure\n");
9426 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
9428 closesocket(server
);
9429 closesocket(client
);
9432 overlapped
.hEvent
= (HANDLE
)((ULONG_PTR
)overlapped
.hEvent
& ~1);
9434 CloseHandle(overlapped
.hEvent
);
9437 static void test_address_list_query(void)
9440 SOCKET_ADDRESS_LIST
*address_list
= (SOCKET_ADDRESS_LIST
*)buffer
;
9441 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
9442 DWORD size
, expect_size
;
9449 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9450 ok(s
!= INVALID_SOCKET
, "Failed to create socket, error %d.\n", WSAGetLastError());
9451 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
9454 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, NULL
, 0, &size
, NULL
, NULL
);
9455 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
9456 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9457 ok(size
>= FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[0]), "Got unexpected size %u.\n", size
);
9461 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, sizeof(buffer
), &size
, NULL
, NULL
);
9462 ok(!ret
, "Got unexpected ret %d.\n", ret
);
9463 ok(!WSAGetLastError(), "Got unexpected error %d.\n", WSAGetLastError());
9464 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
9466 expect_size
= FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[address_list
->iAddressCount
]);
9467 for (i
= 0; i
< address_list
->iAddressCount
; ++i
)
9469 expect_size
+= address_list
->Address
[i
].iSockaddrLength
;
9471 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
9473 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, sizeof(buffer
), NULL
, NULL
, NULL
);
9474 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
9475 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9478 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, NULL
, sizeof(buffer
), &size
, NULL
, NULL
);
9479 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
9480 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9481 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
9484 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, 0, &size
, NULL
, NULL
);
9485 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
9486 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9487 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
9490 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, 1, &size
, NULL
, NULL
);
9491 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
9492 ok(WSAGetLastError() == WSAEINVAL
, "Got unexpected error %d.\n", WSAGetLastError());
9493 ok(!size
, "Got size %u.\n", size
);
9496 memset(buffer
, 0xcc, sizeof(buffer
));
9497 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
,
9498 FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[0]), &size
, NULL
, NULL
);
9499 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
9500 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9501 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
9502 ok(address_list
->iAddressCount
== 0xcccccccc, "Got %u addresses.\n", address_list
->iAddressCount
);
9504 WSASetLastError(0xdeadbeef);
9505 overlapped
.Internal
= 0xdeadbeef;
9506 overlapped
.InternalHigh
= 0xdeadbeef;
9508 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, 0, &size
, &overlapped
, NULL
);
9509 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
9510 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9511 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
9512 ok(overlapped
.Internal
== 0xdeadbeef, "Got status %#x.\n", (NTSTATUS
)overlapped
.Internal
);
9513 ok(overlapped
.InternalHigh
== 0xdeadbeef, "Got size %Iu.\n", overlapped
.InternalHigh
);
9515 overlapped
.Internal
= 0xdeadbeef;
9516 overlapped
.InternalHigh
= 0xdeadbeef;
9518 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, 1, &size
, &overlapped
, NULL
);
9519 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
9520 ok(WSAGetLastError() == WSAEINVAL
, "Got unexpected error %d.\n", WSAGetLastError());
9521 ok(!size
, "Expected size %u, got %u.\n", expect_size
, size
);
9522 ok(overlapped
.Internal
== 0xdeadbeef, "Got status %#x.\n", (NTSTATUS
)overlapped
.Internal
);
9523 ok(overlapped
.InternalHigh
== 0xdeadbeef, "Got size %Iu.\n", overlapped
.InternalHigh
);
9525 overlapped
.Internal
= 0xdeadbeef;
9526 overlapped
.InternalHigh
= 0xdeadbeef;
9528 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
,
9529 FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[0]), &size
, &overlapped
, NULL
);
9530 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
9531 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9532 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
9533 ok(overlapped
.Internal
== 0xdeadbeef, "Got status %#x.\n", (NTSTATUS
)overlapped
.Internal
);
9534 ok(overlapped
.InternalHigh
== 0xdeadbeef, "Got size %Iu.\n", overlapped
.InternalHigh
);
9535 ok(address_list
->iAddressCount
== 0xcccccccc, "Got %u addresses.\n", address_list
->iAddressCount
);
9537 overlapped
.Internal
= 0xdeadbeef;
9538 overlapped
.InternalHigh
= 0xdeadbeef;
9540 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, sizeof(buffer
), &size
, &overlapped
, NULL
);
9541 ok(!ret
, "Got unexpected ret %d.\n", ret
);
9542 ok(!WSAGetLastError(), "Got unexpected error %d.\n", WSAGetLastError());
9543 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
9545 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9546 ok(ret
, "Got error %u.\n", GetLastError());
9547 ok(!size
, "Got size %u.\n", size
);
9548 ok(overlapped_ptr
== &overlapped
, "Got overlapped %p.\n", overlapped_ptr
);
9549 ok(!overlapped
.Internal
, "Got status %#x.\n", (NTSTATUS
)overlapped
.Internal
);
9550 ok(!overlapped
.InternalHigh
, "Got size %Iu.\n", overlapped
.InternalHigh
);
9552 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9553 ok(!ret
, "Expected failure.\n");
9554 ok(GetLastError() == WAIT_TIMEOUT
, "Got error %u.\n", GetLastError());
9559 /* Test with an APC. */
9561 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9563 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, sizeof(buffer
), NULL
, &overlapped
, socket_apc
);
9564 ok(ret
== -1, "expected failure\n");
9565 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
9569 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, sizeof(buffer
), &size
, &overlapped
, socket_apc
);
9570 ok(!ret
, "expected success\n");
9571 ok(size
== expect_size
, "got size %u\n", size
);
9573 ret
= SleepEx(0, TRUE
);
9574 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
9575 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
9576 ok(!apc_error
, "got APC error %u\n", apc_error
);
9577 ok(!apc_size
, "got APC size %u\n", apc_size
);
9578 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
9583 static void sync_read(SOCKET src
, SOCKET dst
)
9588 ret
= send(dst
, "Hello World!", 12, 0);
9589 ok(ret
== 12, "send returned %d\n", ret
);
9591 memset(data
, 0, sizeof(data
));
9592 ret
= recv(src
, data
, sizeof(data
), 0);
9593 ok(ret
== 12, "expected 12, got %d\n", ret
);
9594 ok(!memcmp(data
, "Hello World!", 12), "got %u bytes (%*s)\n", ret
, ret
, data
);
9597 static void iocp_async_read(SOCKET src
, SOCKET dst
)
9600 WSAOVERLAPPED ovl
, *ovl_iocp
;
9607 memset(data
, 0, sizeof(data
));
9608 memset(&ovl
, 0, sizeof(ovl
));
9610 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
9611 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
9613 buf
.len
= sizeof(data
);
9617 SetLastError(0xdeadbeef);
9618 ret
= WSARecv(src
, &buf
, 1, &bytes
, &flags
, &ovl
, NULL
);
9619 ok(ret
== SOCKET_ERROR
, "got %d\n", ret
);
9620 ok(GetLastError() == ERROR_IO_PENDING
, "got %u\n", GetLastError());
9621 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9625 ovl_iocp
= (void *)0xdeadbeef;
9626 SetLastError(0xdeadbeef);
9627 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9628 ok(!ret
, "got %d\n", ret
);
9629 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
9630 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9631 ok(key
== 0xdeadbeef, "got key %#lx\n", key
);
9632 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
9634 ret
= send(dst
, "Hello World!", 12, 0);
9635 ok(ret
== 12, "send returned %d\n", ret
);
9640 SetLastError(0xdeadbeef);
9641 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9642 ok(ret
, "got %d\n", ret
);
9643 ok(bytes
== 12, "got bytes %u\n", bytes
);
9644 ok(key
== 0x12345678, "got key %#lx\n", key
);
9645 ok(ovl_iocp
== &ovl
, "got ovl %p\n", ovl_iocp
);
9648 ok(ovl_iocp
->InternalHigh
== 12, "got %#lx\n", ovl_iocp
->InternalHigh
);
9649 ok(!ovl_iocp
->Internal
, "got %#lx\n", ovl_iocp
->Internal
);
9650 ok(!memcmp(data
, "Hello World!", 12), "got %u bytes (%*s)\n", bytes
, bytes
, data
);
9655 ovl_iocp
= (void *)0xdeadbeef;
9656 SetLastError(0xdeadbeef);
9657 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9658 ok(!ret
, "got %d\n", ret
);
9659 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
9660 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9661 ok(key
== 0xdeadbeef, "got key %#lx\n", key
);
9662 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
9667 static void iocp_async_read_closesocket(SOCKET src
, int how_to_close
)
9670 WSAOVERLAPPED ovl
, *ovl_iocp
;
9679 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
9680 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
9681 ok(hwnd
!= 0, "CreateWindowEx failed\n");
9683 ret
= WSAAsyncSelect(src
, hwnd
, WM_SOCKET
, FD_READ
| FD_WRITE
| FD_OOB
| FD_ACCEPT
| FD_CONNECT
| FD_CLOSE
);
9684 ok(!ret
, "got %d\n", ret
);
9687 memset(&msg
, 0, sizeof(msg
));
9688 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9689 ok(ret
, "got %d\n", ret
);
9690 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
9691 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
9692 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
9693 ok(msg
.lParam
== 2, "got %08lx\n", msg
.lParam
);
9695 memset(data
, 0, sizeof(data
));
9696 memset(&ovl
, 0, sizeof(ovl
));
9698 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
9699 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
9702 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9703 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9705 buf
.len
= sizeof(data
);
9709 SetLastError(0xdeadbeef);
9710 ret
= WSARecv(src
, &buf
, 1, &bytes
, &flags
, &ovl
, NULL
);
9711 ok(ret
== SOCKET_ERROR
, "got %d\n", ret
);
9712 ok(GetLastError() == ERROR_IO_PENDING
, "got %u\n", GetLastError());
9713 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9716 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9717 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9721 ovl_iocp
= (void *)0xdeadbeef;
9722 SetLastError(0xdeadbeef);
9723 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9724 ok(!ret
, "got %d\n", ret
);
9725 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
9726 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9727 ok(key
== 0xdeadbeef, "got key %#lx\n", key
);
9728 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
9731 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9732 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9734 switch (how_to_close
)
9740 CloseHandle((HANDLE
)src
);
9743 pNtClose((HANDLE
)src
);
9746 ok(0, "wrong value %d\n", how_to_close
);
9751 memset(&msg
, 0, sizeof(msg
));
9752 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9753 switch (how_to_close
)
9756 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9762 ok(ret
, "got %d\n", ret
);
9763 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
9764 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
9765 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
9766 ok(msg
.lParam
== 0x20, "got %08lx\n", msg
.lParam
);
9770 ok(0, "wrong value %d\n", how_to_close
);
9777 SetLastError(0xdeadbeef);
9778 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9779 ok(!ret
, "got %d\n", ret
);
9781 ok(GetLastError() == ERROR_CONNECTION_ABORTED
|| GetLastError() == ERROR_NETNAME_DELETED
/* XP */, "got %u\n", GetLastError());
9782 ok(!bytes
, "got bytes %u\n", bytes
);
9783 ok(key
== 0x12345678, "got key %#lx\n", key
);
9784 ok(ovl_iocp
== &ovl
, "got ovl %p\n", ovl_iocp
);
9787 ok(!ovl_iocp
->InternalHigh
, "got %#lx\n", ovl_iocp
->InternalHigh
);
9789 ok(ovl_iocp
->Internal
== (ULONG
)STATUS_CONNECTION_ABORTED
|| ovl_iocp
->Internal
== (ULONG
)STATUS_LOCAL_DISCONNECT
/* XP */, "got %#lx\n", ovl_iocp
->Internal
);
9794 ovl_iocp
= (void *)0xdeadbeef;
9795 SetLastError(0xdeadbeef);
9796 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9797 ok(!ret
, "got %d\n", ret
);
9798 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
9799 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9800 ok(key
== 0xdeadbeef, "got key %#lx\n", key
);
9801 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
9805 DestroyWindow(hwnd
);
9808 static void iocp_async_closesocket(SOCKET src
)
9811 WSAOVERLAPPED
*ovl_iocp
;
9818 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
9819 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
9820 ok(hwnd
!= 0, "CreateWindowEx failed\n");
9822 ret
= WSAAsyncSelect(src
, hwnd
, WM_SOCKET
, FD_READ
| FD_WRITE
| FD_OOB
| FD_ACCEPT
| FD_CONNECT
| FD_CLOSE
);
9823 ok(!ret
, "got %d\n", ret
);
9826 memset(&msg
, 0, sizeof(msg
));
9827 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9828 ok(ret
, "got %d\n", ret
);
9829 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
9830 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
9831 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
9832 ok(msg
.lParam
== 2, "got %08lx\n", msg
.lParam
);
9834 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
9835 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
9838 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9839 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9843 ovl_iocp
= (void *)0xdeadbeef;
9844 SetLastError(0xdeadbeef);
9845 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9846 ok(!ret
, "got %d\n", ret
);
9847 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
9848 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9849 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
9850 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
9853 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9854 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9859 memset(&msg
, 0, sizeof(msg
));
9860 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9861 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9865 ovl_iocp
= (void *)0xdeadbeef;
9866 SetLastError(0xdeadbeef);
9867 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9868 ok(!ret
, "got %d\n", ret
);
9869 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
9870 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9871 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
9872 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
9876 DestroyWindow(hwnd
);
9879 struct wsa_async_select_info
9885 static DWORD WINAPI
wsa_async_select_thread(void *param
)
9887 struct wsa_async_select_info
*info
= param
;
9890 ret
= WSAAsyncSelect(info
->sock
, info
->hwnd
, WM_SOCKET
, FD_READ
| FD_WRITE
| FD_OOB
| FD_ACCEPT
| FD_CONNECT
| FD_CLOSE
);
9891 ok(!ret
, "got %d\n", ret
);
9896 struct wsa_recv_info
9903 static DWORD WINAPI
wsa_recv_thread(void *param
)
9905 struct wsa_recv_info
*info
= param
;
9911 SetLastError(0xdeadbeef);
9912 ret
= WSARecv(info
->sock
, &info
->wsa_buf
, 1, &bytes
, &flags
, &info
->ovl
, NULL
);
9913 ok(ret
== SOCKET_ERROR
, "got %d\n", ret
);
9914 ok(GetLastError() == ERROR_IO_PENDING
, "got %u\n", GetLastError());
9915 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9920 static void iocp_async_read_thread_closesocket(SOCKET src
)
9922 struct wsa_async_select_info select_info
;
9923 struct wsa_recv_info recv_info
;
9924 HANDLE port
, thread
;
9925 WSAOVERLAPPED
*ovl_iocp
;
9933 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
9934 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
9935 ok(hwnd
!= 0, "CreateWindowEx failed\n");
9937 select_info
.sock
= src
;
9938 select_info
.hwnd
= hwnd
;
9939 thread
= CreateThread(NULL
, 0, wsa_async_select_thread
, &select_info
, 0, &tid
);
9940 ok(thread
!= 0, "CreateThread error %u\n", GetLastError());
9941 ret
= WaitForSingleObject(thread
, 10000);
9942 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
9945 memset(&msg
, 0, sizeof(msg
));
9946 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9947 ok(ret
, "got %d\n", ret
);
9948 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
9949 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
9950 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
9951 ok(msg
.lParam
== 2, "got %08lx\n", msg
.lParam
);
9953 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
9954 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
9957 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9958 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9960 memset(data
, 0, sizeof(data
));
9961 memset(&recv_info
.ovl
, 0, sizeof(recv_info
.ovl
));
9962 recv_info
.sock
= src
;
9963 recv_info
.wsa_buf
.len
= sizeof(data
);
9964 recv_info
.wsa_buf
.buf
= data
;
9965 thread
= CreateThread(NULL
, 0, wsa_recv_thread
, &recv_info
, 0, &tid
);
9966 ok(thread
!= 0, "CreateThread error %u\n", GetLastError());
9967 ret
= WaitForSingleObject(thread
, 10000);
9968 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
9971 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9972 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9976 ovl_iocp
= (void *)0xdeadbeef;
9977 SetLastError(0xdeadbeef);
9978 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9979 ok(!ret
, "got %d\n", ret
);
9980 ok(GetLastError() == WAIT_TIMEOUT
|| broken(GetLastError() == ERROR_OPERATION_ABORTED
) /* XP */,
9981 "got %u\n", GetLastError());
9982 if (GetLastError() == WAIT_TIMEOUT
)
9984 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9985 ok(key
== 0xdeadbeef, "got key %lx\n", key
);
9986 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
9988 else /* document XP behaviour */
9990 ok(!bytes
, "got bytes %u\n", bytes
);
9991 ok(key
== 0x12345678, "got key %#lx\n", key
);
9992 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
9995 ok(!ovl_iocp
->InternalHigh
, "got %#lx\n", ovl_iocp
->InternalHigh
);
9996 ok(ovl_iocp
->Internal
== STATUS_CANCELLED
, "got %#lx\n", ovl_iocp
->Internal
);
10004 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10005 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10010 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10011 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10013 bytes
= 0xdeadbeef;
10016 SetLastError(0xdeadbeef);
10017 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10018 ok(!ret
, "got %d\n", ret
);
10020 ok(GetLastError() == ERROR_CONNECTION_ABORTED
|| GetLastError() == ERROR_NETNAME_DELETED
/* XP */, "got %u\n", GetLastError());
10021 ok(!bytes
, "got bytes %u\n", bytes
);
10022 ok(key
== 0x12345678, "got key %#lx\n", key
);
10023 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
10026 ok(!ovl_iocp
->InternalHigh
, "got %#lx\n", ovl_iocp
->InternalHigh
);
10028 ok(ovl_iocp
->Internal
== (ULONG
)STATUS_CONNECTION_ABORTED
|| ovl_iocp
->Internal
== (ULONG
)STATUS_LOCAL_DISCONNECT
/* XP */, "got %#lx\n", ovl_iocp
->Internal
);
10032 bytes
= 0xdeadbeef;
10034 ovl_iocp
= (void *)0xdeadbeef;
10035 SetLastError(0xdeadbeef);
10036 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10037 ok(!ret
, "got %d\n", ret
);
10038 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
10039 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
10040 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
10041 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
10045 DestroyWindow(hwnd
);
10048 static void iocp_async_read_thread(SOCKET src
, SOCKET dst
)
10050 struct wsa_async_select_info select_info
;
10051 struct wsa_recv_info recv_info
;
10052 HANDLE port
, thread
;
10053 WSAOVERLAPPED
*ovl_iocp
;
10061 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
10062 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
10063 ok(hwnd
!= 0, "CreateWindowEx failed\n");
10065 select_info
.sock
= src
;
10066 select_info
.hwnd
= hwnd
;
10067 thread
= CreateThread(NULL
, 0, wsa_async_select_thread
, &select_info
, 0, &tid
);
10068 ok(thread
!= 0, "CreateThread error %u\n", GetLastError());
10069 ret
= WaitForSingleObject(thread
, 10000);
10070 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
10073 memset(&msg
, 0, sizeof(msg
));
10074 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10075 ok(ret
, "got %d\n", ret
);
10076 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
10077 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
10078 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
10079 ok(msg
.lParam
== 2, "got %08lx\n", msg
.lParam
);
10081 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
10082 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
10085 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10086 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10088 memset(data
, 0, sizeof(data
));
10089 memset(&recv_info
.ovl
, 0, sizeof(recv_info
.ovl
));
10090 recv_info
.sock
= src
;
10091 recv_info
.wsa_buf
.len
= sizeof(data
);
10092 recv_info
.wsa_buf
.buf
= data
;
10093 thread
= CreateThread(NULL
, 0, wsa_recv_thread
, &recv_info
, 0, &tid
);
10094 ok(thread
!= 0, "CreateThread error %u\n", GetLastError());
10095 ret
= WaitForSingleObject(thread
, 10000);
10096 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
10099 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10100 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10102 bytes
= 0xdeadbeef;
10104 ovl_iocp
= (void *)0xdeadbeef;
10105 SetLastError(0xdeadbeef);
10106 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10107 ok(!ret
, "got %d\n", ret
);
10108 ok(GetLastError() == WAIT_TIMEOUT
|| broken(GetLastError() == ERROR_OPERATION_ABORTED
) /* XP */, "got %u\n", GetLastError());
10109 if (GetLastError() == WAIT_TIMEOUT
)
10111 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
10112 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
10113 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
10115 else /* document XP behaviour */
10117 ok(bytes
== 0, "got bytes %u\n", bytes
);
10118 ok(key
== 0x12345678, "got key %#lx\n", key
);
10119 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
10122 ok(!ovl_iocp
->InternalHigh
, "got %#lx\n", ovl_iocp
->InternalHigh
);
10123 ok(ovl_iocp
->Internal
== STATUS_CANCELLED
, "got %#lx\n", ovl_iocp
->Internal
);
10128 memset(&msg
, 0, sizeof(msg
));
10129 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10130 ok(!ret
|| broken(msg
.hwnd
== hwnd
) /* XP */, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10131 if (ret
) /* document XP behaviour */
10133 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
10134 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
10135 ok(msg
.lParam
== 1, "got %08lx\n", msg
.lParam
);
10138 ret
= send(dst
, "Hello World!", 12, 0);
10139 ok(ret
== 12, "send returned %d\n", ret
);
10142 memset(&msg
, 0, sizeof(msg
));
10143 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10144 ok(!ret
|| broken(msg
.hwnd
== hwnd
) /* XP */, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10145 if (ret
) /* document XP behaviour */
10147 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
10148 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
10149 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
10150 ok(msg
.lParam
== 1, "got %08lx\n", msg
.lParam
);
10153 bytes
= 0xdeadbeef;
10155 ovl_iocp
= (void *)0xdeadbeef;
10156 SetLastError(0xdeadbeef);
10157 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10158 ok(ret
|| broken(GetLastError() == WAIT_TIMEOUT
) /* XP */, "got %u\n", GetLastError());
10161 ok(bytes
== 12, "got bytes %u\n", bytes
);
10162 ok(key
== 0x12345678, "got key %#lx\n", key
);
10163 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
10166 ok(ovl_iocp
->InternalHigh
== 12, "got %#lx\n", ovl_iocp
->InternalHigh
);
10167 ok(!ovl_iocp
->Internal
, "got %#lx\n", ovl_iocp
->Internal
);
10168 ok(!memcmp(data
, "Hello World!", 12), "got %u bytes (%*s)\n", bytes
, bytes
, data
);
10171 else /* document XP behaviour */
10173 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
10174 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
10175 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
10180 DestroyWindow(hwnd
);
10183 static void test_iocp(void)
10188 tcp_socketpair(&src
, &dst
);
10189 sync_read(src
, dst
);
10190 iocp_async_read(src
, dst
);
10194 tcp_socketpair(&src
, &dst
);
10195 iocp_async_read_thread(src
, dst
);
10199 for (i
= 0; i
<= 2; i
++)
10201 tcp_socketpair(&src
, &dst
);
10202 iocp_async_read_closesocket(src
, i
);
10206 tcp_socketpair(&src
, &dst
);
10207 iocp_async_closesocket(src
);
10210 tcp_socketpair(&src
, &dst
);
10211 iocp_async_read_thread_closesocket(src
);
10215 static void test_get_interface_list(void)
10217 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
10218 DWORD size
, expect_size
;
10219 unsigned int i
, count
;
10220 INTERFACE_INFO
*info
;
10221 BOOL loopback_found
;
10228 s
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
10229 ok(s
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
10230 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
10233 WSASetLastError(0xdeadbeef);
10234 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(buffer
), &size
, NULL
, NULL
);
10235 ok(!ret
, "Got unexpected ret %d.\n", ret
);
10236 ok(!WSAGetLastError(), "Got error %u.\n", WSAGetLastError());
10237 ok(size
&& size
!= 0xdeadbeef && !(size
% sizeof(INTERFACE_INFO
)), "Got unexpected size %u.\n", size
);
10238 expect_size
= size
;
10241 overlapped
.Internal
= 0xdeadbeef;
10242 overlapped
.InternalHigh
= 0xdeadbeef;
10243 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(buffer
), &size
, &overlapped
, NULL
);
10244 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
10245 ok(WSAGetLastError() == ERROR_IO_PENDING
, "Got error %u.\n", WSAGetLastError());
10246 ok(size
== 0xdeadbeef, "Got size %u.\n", size
);
10248 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 100);
10249 ok(ret
, "Got error %u.\n", GetLastError());
10250 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
10251 ok(key
== 123, "Got key %Iu.\n", key
);
10252 ok(overlapped_ptr
== &overlapped
, "Got overlapped %p.\n", overlapped_ptr
);
10253 ok(!overlapped
.Internal
, "Got status %#x.\n", (NTSTATUS
)overlapped
.Internal
);
10254 ok(overlapped
.InternalHigh
== expect_size
, "Expected size %u, got %Iu.\n", expect_size
, overlapped
.InternalHigh
);
10256 info
= (INTERFACE_INFO
*)buffer
;
10257 count
= size
/ sizeof(INTERFACE_INFO
);
10258 loopback_found
= FALSE
;
10259 for (i
= 0; i
< count
; ++i
)
10261 if (info
[i
].iiFlags
& IFF_LOOPBACK
)
10262 loopback_found
= TRUE
;
10264 ok(info
[i
].iiAddress
.AddressIn
.sin_family
== AF_INET
, "Got unexpected sin_family %#x.\n",
10265 info
[i
].iiAddress
.AddressIn
.sin_family
);
10266 ok(info
[i
].iiNetmask
.AddressIn
.sin_family
== AF_INET
, "Got unexpected sin_family %#x.\n",
10267 info
[i
].iiNetmask
.AddressIn
.sin_family
);
10268 ok(info
[i
].iiBroadcastAddress
.AddressIn
.sin_family
10269 == (info
[i
].iiFlags
& IFF_BROADCAST
) ? AF_INET
: 0, "Got unexpected sin_family %#x.\n",
10270 info
[i
].iiBroadcastAddress
.AddressIn
.sin_family
);
10271 ok(info
[i
].iiAddress
.AddressIn
.sin_addr
.S_un
.S_addr
, "Got zero iiAddress.\n");
10272 ok(info
[i
].iiNetmask
.AddressIn
.sin_addr
.S_un
.S_addr
, "Got zero iiNetmask.\n");
10273 ok((info
[i
].iiFlags
& IFF_BROADCAST
) ? info
[i
].iiBroadcastAddress
.AddressIn
.sin_addr
.S_un
.S_addr
10274 : !info
[i
].iiBroadcastAddress
.AddressIn
.sin_addr
.S_un
.S_addr
,
10275 "Got unexpected iiBroadcastAddress %s.\n", inet_ntoa(info
[i
].iiBroadcastAddress
.AddressIn
.sin_addr
));
10278 ok(loopback_found
, "Loopback interface not found.\n");
10281 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(INTERFACE_INFO
) - 1, &size
, NULL
, NULL
);
10282 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
10283 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
10284 ok(!size
, "Got unexpected size %u.\n", size
);
10287 overlapped
.Internal
= 0xdeadbeef;
10288 overlapped
.InternalHigh
= 0xdeadbeef;
10289 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(INTERFACE_INFO
) - 1, &size
, &overlapped
, NULL
);
10290 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
10291 ok(WSAGetLastError() == ERROR_IO_PENDING
, "Got error %u.\n", WSAGetLastError());
10292 ok(size
== 0xdeadbeef, "Got size %u.\n", size
);
10294 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 100);
10295 ok(!ret
, "Expected failure.\n");
10296 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER
, "Got error %u.\n", GetLastError());
10297 ok(!size
, "Got size %u.\n", size
);
10298 ok(key
== 123, "Got key %Iu.\n", key
);
10299 ok(overlapped_ptr
== &overlapped
, "Got overlapped %p.\n", overlapped_ptr
);
10300 ok((NTSTATUS
)overlapped
.Internal
== STATUS_BUFFER_TOO_SMALL
, "Got status %#x.\n", (NTSTATUS
)overlapped
.Internal
);
10301 ok(!overlapped
.InternalHigh
, "Got size %Iu.\n", overlapped
.InternalHigh
);
10303 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(buffer
), NULL
, NULL
, NULL
);
10304 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
10305 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
10310 /* Test with an APC. */
10312 s
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
10313 ok(s
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
10317 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
,
10318 sizeof(INTERFACE_INFO
) - 1, &size
, &overlapped
, socket_apc
);
10319 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
10320 ok(WSAGetLastError() == ERROR_IO_PENDING
, "Got error %u.\n", WSAGetLastError());
10321 ok(size
== 0xdeadbeef, "Got size %u.\n", size
);
10323 ret
= SleepEx(100, TRUE
);
10324 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
10325 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
10326 ok(apc_error
== WSAEFAULT
, "got APC error %u\n", apc_error
);
10327 ok(!apc_size
, "got APC size %u\n", apc_size
);
10328 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
10333 static void test_bind(void)
10335 const struct sockaddr_in invalid_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= inet_addr("192.0.2.0")};
10336 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
10337 struct sockaddr addr
;
10341 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
10343 WSASetLastError(0xdeadbeef);
10344 ret
= bind(s
, NULL
, 0);
10345 ok(ret
== -1, "expected failure\n");
10346 todo_wine
ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
10348 addr
.sa_family
= 0xdead;
10349 WSASetLastError(0xdeadbeef);
10350 ret
= bind(s
, &addr
, sizeof(addr
));
10351 ok(ret
== -1, "expected failure\n");
10352 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "got error %u\n", WSAGetLastError());
10354 WSASetLastError(0xdeadbeef);
10355 ret
= bind(s
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
) - 1);
10356 ok(ret
== -1, "expected failure\n");
10357 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
10359 WSASetLastError(0xdeadbeef);
10360 ret
= bind(s
, (const struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
10361 ok(ret
== -1, "expected failure\n");
10362 ok(WSAGetLastError() == WSAEADDRNOTAVAIL
, "got error %u\n", WSAGetLastError());
10364 WSASetLastError(0xdeadbeef);
10365 ret
= bind(s
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
10366 ok(!ret
, "expected success\n");
10367 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
10369 WSASetLastError(0xdeadbeef);
10370 ret
= bind(s
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
10371 ok(ret
== -1, "expected failure\n");
10372 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
10374 len
= sizeof(addr
);
10375 ret
= getsockname(s
, &addr
, &len
);
10376 ok(!ret
, "got error %u\n", WSAGetLastError());
10378 s2
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
10380 WSASetLastError(0xdeadbeef);
10381 ret
= bind(s2
, &addr
, sizeof(addr
));
10382 ok(ret
== -1, "expected failure\n");
10383 ok(WSAGetLastError() == WSAEADDRINUSE
, "got error %u\n", WSAGetLastError());
10388 s
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
10390 WSASetLastError(0xdeadbeef);
10391 ret
= bind(s
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
10392 ok(!ret
, "expected success\n");
10393 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
10398 /* Test calling methods on a socket which is currently connecting. */
10399 static void test_connecting_socket(void)
10401 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_ANY
)};
10402 const struct sockaddr_in invalid_addr
=
10404 .sin_family
= AF_INET
,
10405 .sin_addr
.s_addr
= inet_addr("192.0.2.0"),
10408 OVERLAPPED overlapped
= {0}, overlapped2
= {0};
10409 GUID connectex_guid
= WSAID_CONNECTEX
;
10410 LPFN_CONNECTEX pConnectEx
;
10411 struct sockaddr_in addr
;
10417 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
10418 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
10419 set_blocking(client
, FALSE
);
10421 ret
= bind(client
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
10422 ok(!ret
, "expected success\n");
10423 ok(!WSAGetLastError(), "got %u\n", WSAGetLastError());
10425 ret
= connect(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
10426 ok(ret
== -1, "got %d\n", ret
);
10427 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got %u\n", WSAGetLastError());
10429 /* Mortal Kombat 11 connects to the same address twice and expects the
10430 * second to return WSAEALREADY. */
10431 ret
= connect(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
10432 ok(ret
== -1, "got %d\n", ret
);
10433 ok(WSAGetLastError() == WSAEALREADY
, "got %u\n", WSAGetLastError());
10435 ret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectex_guid
, sizeof(connectex_guid
),
10436 &pConnectEx
, sizeof(pConnectEx
), &size
, NULL
, NULL
);
10437 ok(!ret
, "failed to get ConnectEx, error %u\n", WSAGetLastError());
10438 overlapped
.Internal
= 0xdeadbeef;
10439 overlapped
.InternalHigh
= 0xdeadbeef;
10440 ret
= pConnectEx(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
), NULL
, 0, &size
, &overlapped
);
10441 ok(!ret
, "got %d\n", ret
);
10442 ok(WSAGetLastError() == WSAEINVAL
, "got %u\n", WSAGetLastError());
10443 ok((NTSTATUS
)overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
10444 todo_wine
ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
10446 len
= sizeof(addr
);
10447 ret
= getsockname(client
, (struct sockaddr
*)&addr
, &len
);
10448 ok(!ret
, "got error %u\n", WSAGetLastError());
10449 ok(addr
.sin_family
== AF_INET
, "got family %u\n", addr
.sin_family
);
10450 ok(addr
.sin_port
, "expected nonzero port\n");
10452 len
= sizeof(addr
);
10453 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &len
);
10454 todo_wine
ok(!ret
, "got error %u\n", WSAGetLastError());
10457 ok(addr
.sin_family
== AF_INET
, "got family %u\n", addr
.sin_family
);
10458 ok(addr
.sin_addr
.s_addr
== inet_addr("192.0.2.0"), "got address %#08x\n", addr
.sin_addr
.s_addr
);
10459 ok(addr
.sin_port
== 255, "expected nonzero port\n");
10462 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
10463 ok(ret
== -1, "got %d\n", ret
);
10464 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got %u\n", WSAGetLastError());
10466 ret
= send(client
, "data", 5, 0);
10467 ok(ret
== -1, "got %d\n", ret
);
10468 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got %u\n", WSAGetLastError());
10470 closesocket(client
);
10472 /* Test with ConnectEx(). */
10474 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
10475 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
10476 set_blocking(client
, FALSE
);
10478 ret
= bind(client
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
10479 ok(!ret
, "expected success\n");
10480 ok(!WSAGetLastError(), "got %u\n", WSAGetLastError());
10482 ret
= pConnectEx(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
), NULL
, 0, &size
, &overlapped2
);
10483 ok(!ret
, "got %d\n", ret
);
10484 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
10486 ret
= connect(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
10487 ok(ret
== -1, "got %d\n", ret
);
10488 ok(WSAGetLastError() == WSAEINVAL
, "got %u\n", WSAGetLastError());
10490 overlapped
.Internal
= 0xdeadbeef;
10491 overlapped
.InternalHigh
= 0xdeadbeef;
10492 ret
= pConnectEx(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
), NULL
, 0, &size
, &overlapped
);
10493 ok(!ret
, "got %d\n", ret
);
10494 ok(WSAGetLastError() == WSAEINVAL
, "got %u\n", WSAGetLastError());
10495 ok((NTSTATUS
)overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
10496 todo_wine
ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
10498 len
= sizeof(addr
);
10499 ret
= getsockname(client
, (struct sockaddr
*)&addr
, &len
);
10500 ok(!ret
, "got error %u\n", WSAGetLastError());
10501 ok(addr
.sin_family
== AF_INET
, "got family %u\n", addr
.sin_family
);
10502 ok(addr
.sin_port
, "expected nonzero port\n");
10504 len
= sizeof(addr
);
10505 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &len
);
10506 ok(ret
== -1, "got %d\n", ret
);
10507 ok(WSAGetLastError() == WSAENOTCONN
, "got %u\n", WSAGetLastError());
10509 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
10510 ok(ret
== -1, "got %d\n", ret
);
10511 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got %u\n", WSAGetLastError());
10513 ret
= send(client
, "data", 5, 0);
10514 ok(ret
== -1, "got %d\n", ret
);
10515 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got %u\n", WSAGetLastError());
10517 closesocket(client
);
10520 static DWORD
map_status( NTSTATUS status
)
10522 static const struct
10529 {STATUS_PENDING
, ERROR_IO_INCOMPLETE
},
10531 {STATUS_BUFFER_OVERFLOW
, WSAEMSGSIZE
},
10533 {STATUS_NOT_IMPLEMENTED
, WSAEOPNOTSUPP
},
10534 {STATUS_ACCESS_VIOLATION
, WSAEFAULT
},
10535 {STATUS_PAGEFILE_QUOTA
, WSAENOBUFS
},
10536 {STATUS_INVALID_HANDLE
, WSAENOTSOCK
},
10537 {STATUS_NO_SUCH_DEVICE
, WSAENETDOWN
},
10538 {STATUS_NO_SUCH_FILE
, WSAENETDOWN
},
10539 {STATUS_NO_MEMORY
, WSAENOBUFS
},
10540 {STATUS_CONFLICTING_ADDRESSES
, WSAENOBUFS
},
10541 {STATUS_ACCESS_DENIED
, WSAEACCES
},
10542 {STATUS_BUFFER_TOO_SMALL
, WSAEFAULT
},
10543 {STATUS_OBJECT_TYPE_MISMATCH
, WSAENOTSOCK
},
10544 {STATUS_OBJECT_NAME_NOT_FOUND
, WSAENETDOWN
},
10545 {STATUS_OBJECT_PATH_NOT_FOUND
, WSAENETDOWN
},
10546 {STATUS_SHARING_VIOLATION
, WSAEADDRINUSE
},
10547 {STATUS_QUOTA_EXCEEDED
, WSAENOBUFS
},
10548 {STATUS_TOO_MANY_PAGING_FILES
, WSAENOBUFS
},
10549 {STATUS_INSUFFICIENT_RESOURCES
, WSAENOBUFS
},
10550 {STATUS_WORKING_SET_QUOTA
, WSAENOBUFS
},
10551 {STATUS_DEVICE_NOT_READY
, WSAEWOULDBLOCK
},
10552 {STATUS_PIPE_DISCONNECTED
, WSAESHUTDOWN
},
10553 {STATUS_IO_TIMEOUT
, WSAETIMEDOUT
},
10554 {STATUS_NOT_SUPPORTED
, WSAEOPNOTSUPP
},
10555 {STATUS_REMOTE_NOT_LISTENING
, WSAECONNREFUSED
},
10556 {STATUS_BAD_NETWORK_PATH
, WSAENETUNREACH
},
10557 {STATUS_NETWORK_BUSY
, WSAENETDOWN
},
10558 {STATUS_INVALID_NETWORK_RESPONSE
, WSAENETDOWN
},
10559 {STATUS_UNEXPECTED_NETWORK_ERROR
, WSAENETDOWN
},
10560 {STATUS_REQUEST_NOT_ACCEPTED
, WSAEWOULDBLOCK
},
10561 {STATUS_CANCELLED
, ERROR_OPERATION_ABORTED
},
10562 {STATUS_COMMITMENT_LIMIT
, WSAENOBUFS
},
10563 {STATUS_LOCAL_DISCONNECT
, WSAECONNABORTED
},
10564 {STATUS_REMOTE_DISCONNECT
, WSAECONNRESET
},
10565 {STATUS_REMOTE_RESOURCES
, WSAENOBUFS
},
10566 {STATUS_LINK_FAILED
, WSAECONNRESET
},
10567 {STATUS_LINK_TIMEOUT
, WSAETIMEDOUT
},
10568 {STATUS_INVALID_CONNECTION
, WSAENOTCONN
},
10569 {STATUS_INVALID_ADDRESS
, WSAEADDRNOTAVAIL
},
10570 {STATUS_INVALID_BUFFER_SIZE
, WSAEMSGSIZE
},
10571 {STATUS_INVALID_ADDRESS_COMPONENT
, WSAEADDRNOTAVAIL
},
10572 {STATUS_TOO_MANY_ADDRESSES
, WSAENOBUFS
},
10573 {STATUS_ADDRESS_ALREADY_EXISTS
, WSAEADDRINUSE
},
10574 {STATUS_CONNECTION_DISCONNECTED
, WSAECONNRESET
},
10575 {STATUS_CONNECTION_RESET
, WSAECONNRESET
},
10576 {STATUS_TRANSACTION_ABORTED
, WSAECONNABORTED
},
10577 {STATUS_CONNECTION_REFUSED
, WSAECONNREFUSED
},
10578 {STATUS_GRACEFUL_DISCONNECT
, WSAEDISCON
},
10579 {STATUS_CONNECTION_ACTIVE
, WSAEISCONN
},
10580 {STATUS_NETWORK_UNREACHABLE
, WSAENETUNREACH
},
10581 {STATUS_HOST_UNREACHABLE
, WSAEHOSTUNREACH
},
10582 {STATUS_PROTOCOL_UNREACHABLE
, WSAENETUNREACH
},
10583 {STATUS_PORT_UNREACHABLE
, WSAECONNRESET
},
10584 {STATUS_REQUEST_ABORTED
, WSAEINTR
},
10585 {STATUS_CONNECTION_ABORTED
, WSAECONNABORTED
},
10586 {STATUS_DATATYPE_MISALIGNMENT_ERROR
,WSAEFAULT
},
10587 {STATUS_HOST_DOWN
, WSAEHOSTDOWN
},
10588 {0x80070000 | ERROR_IO_INCOMPLETE
, ERROR_IO_INCOMPLETE
},
10589 {0xc0010000 | ERROR_IO_INCOMPLETE
, ERROR_IO_INCOMPLETE
},
10590 {0xc0070000 | ERROR_IO_INCOMPLETE
, ERROR_IO_INCOMPLETE
},
10595 for (i
= 0; i
< ARRAY_SIZE(errors
); ++i
)
10597 if (errors
[i
].status
== status
)
10598 return errors
[i
].error
;
10601 return NT_SUCCESS(status
) ? RtlNtStatusToDosErrorNoTeb(status
) : WSAEINVAL
;
10604 static void test_WSAGetOverlappedResult(void)
10606 OVERLAPPED overlapped
= {0};
10613 static const NTSTATUS ranges
[][2] =
10616 {0x40000000, 0x40001000},
10617 {0x80000000, 0x80001000},
10618 {0x80070000, 0x80080000},
10619 {0xc0000000, 0xc0001000},
10620 {0xc0070000, 0xc0080000},
10621 {0xd0000000, 0xd0001000},
10622 {0xd0070000, 0xd0080000},
10625 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
10627 for (i
= 0; i
< ARRAY_SIZE(ranges
); ++i
)
10629 for (status
= ranges
[i
][0]; status
< ranges
[i
][1]; ++status
)
10631 BOOL expect_ret
= NT_SUCCESS(status
) && status
!= STATUS_PENDING
;
10632 DWORD expect
= map_status(status
);
10634 overlapped
.Internal
= status
;
10635 WSASetLastError(0xdeadbeef);
10636 ret
= WSAGetOverlappedResult(s
, &overlapped
, &size
, FALSE
, &flags
);
10637 ok(ret
== expect_ret
, "status %#x: expected %d, got %d\n", status
, expect_ret
, ret
);
10640 ok(WSAGetLastError() == expect
/* >= win10 1809 */
10641 || !WSAGetLastError() /* < win10 1809 */
10642 || WSAGetLastError() == 0xdeadbeef, /* < win7 */
10643 "status %#x: expected error %u, got %u\n", status
, expect
, WSAGetLastError());
10647 ok(WSAGetLastError() == expect
10648 || (status
== (0xc0070000 | ERROR_IO_INCOMPLETE
) && WSAGetLastError() == WSAEINVAL
), /* < win8 */
10649 "status %#x: expected error %u, got %u\n", status
, expect
, WSAGetLastError());
10657 struct nonblocking_async_recv_params
10663 static DWORD CALLBACK
nonblocking_async_recv_thread(void *arg
)
10665 const struct nonblocking_async_recv_params
*params
= arg
;
10666 OVERLAPPED overlapped
= {0};
10667 DWORD flags
= 0, size
;
10672 overlapped
.hEvent
= params
->event
;
10673 wsabuf
.buf
= buffer
;
10674 wsabuf
.len
= sizeof(buffer
);
10675 memset(buffer
, 0, sizeof(buffer
));
10676 ret
= WSARecv(params
->client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
10677 ok(!ret
, "got %d\n", ret
);
10678 ret
= GetOverlappedResult((HANDLE
)params
->client
, &overlapped
, &size
, FALSE
);
10679 ok(ret
, "got error %u\n", GetLastError());
10680 ok(size
== 4, "got size %u\n", size
);
10681 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
10686 static void test_nonblocking_async_recv(void)
10688 struct nonblocking_async_recv_params params
;
10689 OVERLAPPED overlapped
= {0};
10690 SOCKET client
, server
;
10691 DWORD flags
= 0, size
;
10692 HANDLE thread
, event
;
10697 event
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
10698 wsabuf
.buf
= buffer
;
10699 wsabuf
.len
= sizeof(buffer
);
10701 tcp_socketpair(&client
, &server
);
10702 set_blocking(client
, FALSE
);
10703 set_blocking(server
, FALSE
);
10705 WSASetLastError(0xdeadbeef);
10706 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
10707 ok(ret
== -1, "got %d\n", ret
);
10708 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
10710 WSASetLastError(0xdeadbeef);
10711 overlapped
.Internal
= 0xdeadbeef;
10712 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, NULL
, NULL
);
10713 ok(ret
== -1, "got %d\n", ret
);
10714 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
10715 ok(overlapped
.Internal
== 0xdeadbeef, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
10717 /* Overlapped, with a NULL event. */
10719 overlapped
.hEvent
= NULL
;
10721 memset(buffer
, 0, sizeof(buffer
));
10722 WSASetLastError(0xdeadbeef);
10723 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
10724 ok(ret
== -1, "got %d\n", ret
);
10725 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
10726 ret
= WaitForSingleObject((HANDLE
)client
, 0);
10727 ok(ret
== WAIT_TIMEOUT
, "expected timeout\n");
10729 ret
= send(server
, "data", 4, 0);
10730 ok(ret
== 4, "got %d\n", ret
);
10732 ret
= WaitForSingleObject((HANDLE
)client
, 1000);
10733 ok(!ret
, "wait timed out\n");
10734 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
10735 ok(ret
, "got error %u\n", GetLastError());
10736 ok(size
== 4, "got size %u\n", size
);
10737 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
10739 /* Overlapped, with a non-NULL event. */
10741 overlapped
.hEvent
= event
;
10743 memset(buffer
, 0, sizeof(buffer
));
10744 WSASetLastError(0xdeadbeef);
10745 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
10746 ok(ret
== -1, "got %d\n", ret
);
10747 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
10748 ret
= WaitForSingleObject(event
, 0);
10749 ok(ret
== WAIT_TIMEOUT
, "expected timeout\n");
10751 ret
= send(server
, "data", 4, 0);
10752 ok(ret
== 4, "got %d\n", ret
);
10754 ret
= WaitForSingleObject(event
, 1000);
10755 ok(!ret
, "wait timed out\n");
10756 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
10757 ok(ret
, "got error %u\n", GetLastError());
10758 ok(size
== 4, "got size %u\n", size
);
10759 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
10761 /* With data already in the pipe; usually this does return 0 (but not
10764 ret
= send(server
, "data", 4, 0);
10765 ok(ret
== 4, "got %d\n", ret
);
10767 memset(buffer
, 0, sizeof(buffer
));
10768 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
10769 ok(!ret
|| WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
10770 ret
= WaitForSingleObject(event
, 1000);
10771 ok(!ret
, "wait timed out\n");
10772 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
10773 ok(ret
, "got error %u\n", GetLastError());
10774 ok(size
== 4, "got size %u\n", size
);
10775 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
10777 closesocket(client
);
10778 closesocket(server
);
10780 /* With a non-overlapped socket, WSARecv() always blocks when passed an
10781 * overlapped structure, but returns WSAEWOULDBLOCK otherwise. */
10783 tcp_socketpair_flags(&client
, &server
, 0);
10784 set_blocking(client
, FALSE
);
10785 set_blocking(server
, FALSE
);
10787 WSASetLastError(0xdeadbeef);
10788 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
10789 ok(ret
== -1, "got %d\n", ret
);
10790 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
10792 WSASetLastError(0xdeadbeef);
10793 overlapped
.Internal
= 0xdeadbeef;
10794 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, NULL
, NULL
);
10795 ok(ret
== -1, "got %d\n", ret
);
10796 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
10797 ok(overlapped
.Internal
== 0xdeadbeef, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
10799 /* Overlapped, with a NULL event. */
10801 params
.client
= client
;
10802 params
.event
= NULL
;
10803 thread
= CreateThread(NULL
, 0, nonblocking_async_recv_thread
, ¶ms
, 0, NULL
);
10805 ret
= WaitForSingleObject(thread
, 200);
10806 ok(ret
== WAIT_TIMEOUT
, "expected timeout\n");
10808 ret
= send(server
, "data", 4, 0);
10809 ok(ret
== 4, "got %d\n", ret
);
10811 ret
= WaitForSingleObject(thread
, 200);
10812 ok(!ret
, "wait timed out\n");
10813 CloseHandle(thread
);
10815 /* Overlapped, with a non-NULL event. */
10817 params
.client
= client
;
10818 params
.event
= event
;
10819 thread
= CreateThread(NULL
, 0, nonblocking_async_recv_thread
, ¶ms
, 0, NULL
);
10821 ret
= WaitForSingleObject(thread
, 200);
10822 ok(ret
== WAIT_TIMEOUT
, "expected timeout\n");
10824 ret
= send(server
, "data", 4, 0);
10825 ok(ret
== 4, "got %d\n", ret
);
10827 ret
= WaitForSingleObject(thread
, 200);
10828 ok(!ret
, "wait timed out\n");
10829 CloseHandle(thread
);
10831 /* With data already in the pipe. */
10833 ret
= send(server
, "data", 4, 0);
10834 ok(ret
== 4, "got %d\n", ret
);
10836 memset(buffer
, 0, sizeof(buffer
));
10837 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
10838 ok(!ret
, "got %d\n", ret
);
10839 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
10840 ok(ret
, "got error %u\n", GetLastError());
10841 ok(size
== 4, "got size %u\n", size
);
10842 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
10844 closesocket(client
);
10845 closesocket(server
);
10847 CloseHandle(overlapped
.hEvent
);
10850 static void test_empty_recv(void)
10852 OVERLAPPED overlapped
= {0};
10853 SOCKET client
, server
;
10854 DWORD size
, flags
= 0;
10859 overlapped
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
10860 tcp_socketpair(&client
, &server
);
10862 WSASetLastError(0xdeadbeef);
10863 ret
= WSARecv(client
, NULL
, 0, NULL
, &flags
, &overlapped
, NULL
);
10864 ok(ret
== -1, "expected failure\n");
10865 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
10867 wsabuf
.buf
= buffer
;
10869 WSASetLastError(0xdeadbeef);
10870 ret
= WSARecv(client
, &wsabuf
, 0, NULL
, &flags
, &overlapped
, NULL
);
10871 ok(ret
== -1, "expected failure\n");
10872 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
10874 WSASetLastError(0xdeadbeef);
10875 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
10876 ok(ret
== -1, "expected failure\n");
10877 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
10879 ret
= send(server
, "data", 5, 0);
10880 ok(ret
== 5, "got %d\n", ret
);
10882 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
10883 ok(!ret
, "wait failed\n");
10884 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
10885 ok(ret
, "got error %u\n", GetLastError());
10886 ok(!size
, "got size %u\n", size
);
10888 WSASetLastError(0xdeadbeef);
10889 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
10890 ok(!ret
, "got error %u\n", WSAGetLastError());
10891 ok(!size
, "got size %u\n", size
);
10893 ret
= recv(client
, NULL
, 0, 0);
10894 ok(!ret
, "got %d\n", ret
);
10896 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
10897 ok(ret
== 5, "got %d\n", ret
);
10898 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, ret
));
10900 closesocket(client
);
10901 closesocket(server
);
10902 CloseHandle(overlapped
.hEvent
);
10905 static void test_timeout(void)
10907 DWORD timeout
, flags
= 0, size
;
10908 OVERLAPPED overlapped
= {0};
10909 SOCKET client
, server
;
10914 tcp_socketpair(&client
, &server
);
10915 overlapped
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
10917 timeout
= 0xdeadbeef;
10918 len
= sizeof(timeout
);
10919 WSASetLastError(0xdeadbeef);
10920 ret
= getsockopt(client
, SOL_SOCKET
, SO_RCVTIMEO
, (char *)&timeout
, &len
);
10921 ok(!ret
, "expected success\n");
10922 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
10923 ok(len
== sizeof(timeout
), "got size %u\n", len
);
10924 ok(!timeout
, "got timeout %u\n", timeout
);
10927 WSASetLastError(0xdeadbeef);
10928 ret
= setsockopt(client
, SOL_SOCKET
, SO_RCVTIMEO
, (char *)&timeout
, sizeof(timeout
));
10929 ok(!ret
, "expected success\n");
10930 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
10932 timeout
= 0xdeadbeef;
10933 len
= sizeof(timeout
);
10934 WSASetLastError(0xdeadbeef);
10935 ret
= getsockopt(client
, SOL_SOCKET
, SO_RCVTIMEO
, (char *)&timeout
, &len
);
10936 ok(!ret
, "expected success\n");
10937 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
10938 ok(timeout
== 100, "got timeout %u\n", timeout
);
10940 WSASetLastError(0xdeadbeef);
10941 ret
= recv(client
, &buffer
, 1, 0);
10942 ok(ret
== -1, "got %d\n", ret
);
10943 ok(WSAGetLastError() == WSAETIMEDOUT
, "got error %u\n", WSAGetLastError());
10945 wsabuf
.buf
= &buffer
;
10947 WSASetLastError(0xdeadbeef);
10949 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, NULL
, NULL
);
10950 ok(ret
== -1, "got %d\n", ret
);
10951 ok(WSAGetLastError() == WSAETIMEDOUT
, "got error %u\n", WSAGetLastError());
10952 ok(size
== 0xdeadbeef, "got size %u\n", size
);
10954 wsabuf
.buf
= &buffer
;
10956 WSASetLastError(0xdeadbeef);
10958 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
10959 ok(ret
== -1, "got %d\n", ret
);
10960 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
10962 ret
= WaitForSingleObject(overlapped
.hEvent
, 200);
10963 ok(ret
== WAIT_TIMEOUT
, "got %d\n", ret
);
10965 ret
= send(server
, "a", 1, 0);
10966 ok(ret
== 1, "got %d\n", ret
);
10968 ret
= WaitForSingleObject(overlapped
.hEvent
, 200);
10969 ok(!ret
, "got %d\n", ret
);
10970 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
10971 ok(ret
, "got error %u\n", GetLastError());
10972 ok(size
== 1, "got size %u\n", size
);
10974 closesocket(client
);
10975 closesocket(server
);
10976 CloseHandle(overlapped
.hEvent
);
10979 static void test_so_debug(void)
10985 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
10987 len
= sizeof(debug
);
10988 WSASetLastError(0xdeadbeef);
10989 debug
= 0xdeadbeef;
10990 ret
= getsockopt(s
, SOL_SOCKET
, SO_DEBUG
, (char *)&debug
, &len
);
10991 ok(!ret
, "got %d\n", ret
);
10992 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
10993 ok(len
== sizeof(debug
), "got len %u\n", len
);
10994 ok(!debug
, "got debug %u\n", debug
);
10996 WSASetLastError(0xdeadbeef);
10998 ret
= setsockopt(s
, SOL_SOCKET
, SO_DEBUG
, (char *)&debug
, sizeof(debug
));
10999 ok(!ret
, "got %d\n", ret
);
11000 todo_wine
ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
11002 len
= sizeof(debug
);
11003 WSASetLastError(0xdeadbeef);
11004 debug
= 0xdeadbeef;
11005 ret
= getsockopt(s
, SOL_SOCKET
, SO_DEBUG
, (char *)&debug
, &len
);
11006 ok(!ret
, "got %d\n", ret
);
11007 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
11008 ok(len
== sizeof(debug
), "got len %u\n", len
);
11009 todo_wine
ok(debug
== 1, "got debug %u\n", debug
);
11018 /* Leave these tests at the beginning. They depend on WSAStartup not having been
11019 * called, which is done by Init() below. */
11020 test_WithoutWSAStartup();
11021 test_WithWSAStartup();
11025 test_set_getsockopt();
11026 test_so_reuseaddr();
11028 test_extendedSocketOptions();
11031 for (i
= 0; i
< ARRAY_SIZE(tests
); i
++)
11032 do_test(&tests
[i
]);
11037 test_WSADuplicateSocket();
11038 test_WSAEnumNetworkEvents();
11044 test_getpeername();
11045 test_getsockname();
11047 test_address_list_query();
11049 test_fionread_siocatmark();
11050 test_get_extension_func();
11051 test_get_interface_list();
11052 test_keepalive_vals();
11053 test_sioRoutingInterfaceQuery();
11054 test_sioAddressListChange();
11055 test_base_handle();
11056 test_unsupported_ioctls();
11062 test_write_watch();
11068 test_TransmitFile();
11072 test_DisconnectEx();
11074 test_completion_port();
11075 test_connect_completion_port();
11076 test_shutdown_completion_port();
11078 test_connecting_socket();
11079 test_WSAGetOverlappedResult();
11080 test_nonblocking_async_recv();
11084 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */