2 * Unit test suite for winsock functions
4 * Copyright 2002 Martin Wilck
5 * Copyright 2005 Thomas Kho
6 * Copyright 2008 Jeff Zaroyko
7 * Copyright 2017 Dmitry Timoshkov
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #define WIN32_NO_STATUS
36 #include "wine/test.h"
38 #define MAX_CLIENTS 4 /* Max number of clients */
39 #define FIRST_CHAR 'A' /* First character in transferred pattern */
40 #define BIND_SLEEP 10 /* seconds to wait between attempts to bind() */
41 #define BIND_TRIES 6 /* Number of bind() attempts */
42 #define TEST_TIMEOUT 30 /* seconds to wait before killing child threads
43 after server initialization, if something hangs */
45 #define NUM_UDP_PEERS 3 /* Number of UDP sockets to create and test > 1 */
47 #define SERVERIP "127.0.0.1" /* IP to bind to */
48 #define SERVERPORT 9374 /* Port number to bind to */
50 #define wsa_ok(op, cond, msg) \
54 if ( !(cond tmp) ) err = WSAGetLastError(); \
55 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
58 #define make_keepalive(k, enable, time, interval) \
60 k.keepalivetime = time; \
61 k.keepaliveinterval = interval;
63 /* Function pointers */
64 static int (WINAPI
*pWSAPoll
)(WSAPOLLFD
*,ULONG
,INT
);
66 /* Function pointers from ntdll */
67 static DWORD (WINAPI
*pNtClose
)(HANDLE
);
69 /**************** Structs and typedefs ***************/
71 typedef struct thread_info
77 /* Information in the server about open client connections */
78 typedef struct sock_info
81 struct sockaddr_in addr
;
82 struct sockaddr_in peer
;
88 /* Test parameters for both server & client */
89 typedef struct test_params
93 const char *inet_addr
;
100 /* server-specific test parameters */
101 typedef struct server_params
103 test_params
*general
;
108 /* client-specific test parameters */
109 typedef struct client_params
111 test_params
*general
;
116 /* This type combines all information for setting up a test scenario */
117 typedef struct test_setup
121 server_params srv_params
;
123 client_params clt_params
;
126 /* Thread local storage for server */
127 typedef struct server_memory
130 struct sockaddr_in addr
;
131 sock_info sock
[MAX_CLIENTS
];
134 /* Thread local storage for client */
135 typedef struct client_memory
138 struct sockaddr_in addr
;
143 /* SelectReadThread thread parameters */
144 typedef struct select_thread_params
148 } select_thread_params
;
150 /**************** Static variables ***************/
152 static DWORD tls
; /* Thread local storage index */
153 static HANDLE thread
[1+MAX_CLIENTS
];
154 static DWORD thread_id
[1+MAX_CLIENTS
];
155 static HANDLE server_ready
;
156 static HANDLE client_ready
[MAX_CLIENTS
];
157 static int client_id
;
159 /**************** General utility functions ***************/
161 static SOCKET
setup_server_socket(struct sockaddr_in
*addr
, int *len
);
162 static SOCKET
setup_connector_socket(const struct sockaddr_in
*addr
, int len
, BOOL nonblock
);
164 static void tcp_socketpair_flags(SOCKET
*src
, SOCKET
*dst
, DWORD flags
)
166 SOCKET server
= INVALID_SOCKET
;
167 struct sockaddr_in addr
;
170 *src
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, flags
);
171 ok(*src
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
173 server
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, flags
);
174 ok(server
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
176 memset(&addr
, 0, sizeof(addr
));
177 addr
.sin_family
= AF_INET
;
178 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
179 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
180 ok(!ret
, "failed to bind socket, error %u\n", WSAGetLastError());
183 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
184 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
186 ret
= listen(server
, 1);
187 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
189 ret
= connect(*src
, (struct sockaddr
*)&addr
, sizeof(addr
));
190 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
193 *dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
194 ok(*dst
!= INVALID_SOCKET
, "failed to accept socket, error %u\n", WSAGetLastError());
199 static void tcp_socketpair(SOCKET
*src
, SOCKET
*dst
)
201 tcp_socketpair_flags(src
, dst
, WSA_FLAG_OVERLAPPED
);
204 #define check_poll(a, b) check_poll_(__LINE__, a, POLLRDNORM | POLLRDBAND | POLLWRNORM, b, FALSE)
205 #define check_poll_todo(a, b) check_poll_(__LINE__, a, POLLRDNORM | POLLRDBAND | POLLWRNORM, b, TRUE)
206 #define check_poll_mask(a, b, c) check_poll_(__LINE__, a, b, c, FALSE)
207 #define check_poll_mask_todo(a, b, c) check_poll_(__LINE__, a, b, c, TRUE)
208 static void check_poll_(int line
, SOCKET s
, short mask
, short expect
, BOOL todo
)
214 pollfd
.events
= mask
;
215 pollfd
.revents
= 0xdead;
216 ret
= pWSAPoll(&pollfd
, 1, 1000);
217 ok_(__FILE__
, line
)(ret
== (pollfd
.revents
? 1 : 0), "WSAPoll() returned %d\n", ret
);
218 todo_wine_if (todo
) ok_(__FILE__
, line
)(pollfd
.revents
== expect
, "got wrong events %#x\n", pollfd
.revents
);
221 static void set_so_opentype ( BOOL overlapped
)
223 int optval
= !overlapped
, newval
, len
= sizeof (int);
225 ok ( setsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
226 (LPVOID
) &optval
, sizeof (optval
) ) == 0,
227 "setting SO_OPENTYPE failed\n" );
228 ok ( getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
229 (LPVOID
) &newval
, &len
) == 0,
230 "getting SO_OPENTYPE failed\n" );
231 ok ( optval
== newval
, "failed to set SO_OPENTYPE\n" );
234 static int set_blocking ( SOCKET s
, BOOL blocking
)
236 u_long val
= !blocking
;
237 return ioctlsocket ( s
, FIONBIO
, &val
);
240 static void fill_buffer ( char *buf
, int chunk_size
, int n_chunks
)
243 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
244 memset ( p
, c
, chunk_size
);
247 static int test_buffer ( char *buf
, int chunk_size
, int n_chunks
)
251 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
253 for ( i
= 0; i
< chunk_size
; i
++ )
254 if ( p
[i
] != c
) return i
;
260 * This routine is called when a client / server does not expect any more data,
261 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
263 static void read_zero_bytes ( SOCKET s
)
267 while ( ( tmp
= recv ( s
, buf
, 256, 0 ) ) > 0 )
269 ok ( n
<= 0, "garbage data received: %d bytes\n", n
);
272 static int do_synchronous_send ( SOCKET s
, char *buf
, int buflen
, int flags
, int sendlen
)
274 char* last
= buf
+ buflen
, *p
;
276 for ( p
= buf
; n
> 0 && p
< last
; )
278 n
= send ( s
, p
, min ( sendlen
, last
- p
), flags
);
281 wsa_ok ( n
, 0 <=, "do_synchronous_send (%x): error %d\n" );
285 static int do_synchronous_recv ( SOCKET s
, char *buf
, int buflen
, int flags
, int recvlen
)
287 char* last
= buf
+ buflen
, *p
;
289 for ( p
= buf
; n
> 0 && p
< last
; )
291 n
= recv ( s
, p
, min ( recvlen
, last
- p
), flags
);
294 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
298 static int do_synchronous_recvfrom ( SOCKET s
, char *buf
, int buflen
, int flags
, struct sockaddr
*from
, int *fromlen
, int recvlen
)
300 char* last
= buf
+ buflen
, *p
;
302 for ( p
= buf
; n
> 0 && p
< last
; )
304 n
= recvfrom ( s
, p
, min ( recvlen
, last
- p
), flags
, from
, fromlen
);
307 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
312 * Call this routine right after thread startup.
313 * SO_OPENTYPE must by 0, regardless what the server did.
315 static void check_so_opentype (void)
319 getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
, (LPVOID
) &tmp
, &len
);
320 ok ( tmp
== 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp
);
323 /**************** Server utility functions ***************/
326 * Even if we have closed our server socket cleanly,
327 * the OS may mark the address "in use" for some time -
328 * this happens with native Linux apps, too.
330 static void do_bind ( SOCKET s
, struct sockaddr
* addr
, int addrlen
)
332 int err
, wsaerr
= 0, n_try
= BIND_TRIES
;
334 while ( ( err
= bind ( s
, addr
, addrlen
) ) != 0 &&
335 ( wsaerr
= WSAGetLastError () ) == WSAEADDRINUSE
&&
338 trace ( "address in use, waiting ...\n" );
339 Sleep ( 1000 * BIND_SLEEP
);
341 ok ( err
== 0, "failed to bind: %d\n", wsaerr
);
344 static void server_start ( server_params
*par
)
347 test_params
*gen
= par
->general
;
348 server_memory
*mem
= LocalAlloc ( LPTR
, sizeof ( server_memory
) );
350 TlsSetValue ( tls
, mem
);
351 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
352 NULL
, 0, par
->sock_flags
);
353 ok ( mem
->s
!= INVALID_SOCKET
, "Server: WSASocket failed\n" );
355 mem
->addr
.sin_family
= AF_INET
;
356 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
357 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
359 for (i
= 0; i
< MAX_CLIENTS
; i
++)
361 mem
->sock
[i
].s
= INVALID_SOCKET
;
362 mem
->sock
[i
].buf
= LocalAlloc ( LPTR
, gen
->n_chunks
* gen
->chunk_size
);
363 mem
->sock
[i
].n_recvd
= 0;
364 mem
->sock
[i
].n_sent
= 0;
367 if ( gen
->sock_type
== SOCK_STREAM
)
368 do_bind ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof (mem
->addr
) );
371 static void server_stop (void)
374 server_memory
*mem
= TlsGetValue ( tls
);
376 for (i
= 0; i
< MAX_CLIENTS
; i
++ )
378 LocalFree ( mem
->sock
[i
].buf
);
379 if ( mem
->sock
[i
].s
!= INVALID_SOCKET
)
380 closesocket ( mem
->sock
[i
].s
);
382 ok ( closesocket ( mem
->s
) == 0, "closesocket failed\n" );
384 ExitThread ( GetCurrentThreadId () );
387 /**************** Client utilitiy functions ***************/
389 static void client_start ( client_params
*par
)
391 test_params
*gen
= par
->general
;
392 client_memory
*mem
= LocalAlloc (LPTR
, sizeof (client_memory
));
394 TlsSetValue ( tls
, mem
);
396 WaitForSingleObject ( server_ready
, INFINITE
);
398 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
399 NULL
, 0, par
->sock_flags
);
401 mem
->addr
.sin_family
= AF_INET
;
402 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
403 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
405 ok ( mem
->s
!= INVALID_SOCKET
, "Client: WSASocket failed\n" );
407 mem
->send_buf
= LocalAlloc ( LPTR
, 2 * gen
->n_chunks
* gen
->chunk_size
);
408 mem
->recv_buf
= mem
->send_buf
+ gen
->n_chunks
* gen
->chunk_size
;
409 fill_buffer ( mem
->send_buf
, gen
->chunk_size
, gen
->n_chunks
);
411 SetEvent ( client_ready
[client_id
] );
412 /* Wait for the other clients to come up */
413 WaitForMultipleObjects ( min ( gen
->n_clients
, MAX_CLIENTS
), client_ready
, TRUE
, INFINITE
);
416 static void client_stop (void)
418 client_memory
*mem
= TlsGetValue ( tls
);
419 wsa_ok ( closesocket ( mem
->s
), 0 ==, "closesocket error (%x): %d\n" );
420 LocalFree ( mem
->send_buf
);
425 /**************** Servers ***************/
428 * simple_server: A very basic server doing synchronous IO.
430 static VOID WINAPI
simple_server ( server_params
*par
)
432 test_params
*gen
= par
->general
;
434 int pos
, n_recvd
, n_sent
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
435 id
= GetCurrentThreadId();
437 set_so_opentype ( FALSE
); /* non-overlapped */
438 server_start ( par
);
439 mem
= TlsGetValue ( tls
);
441 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
442 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "simple_server (%x): listen failed: %d\n");
444 SetEvent ( server_ready
); /* notify clients */
446 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
448 /* accept a single connection */
449 tmp
= sizeof ( mem
->sock
[0].peer
);
450 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
451 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "simple_server (%x): accept failed: %d\n" );
453 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
454 "simple_server (%x): strange peer address\n", id
);
456 /* Receive data & check it */
457 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
458 ok ( n_recvd
== n_expected
,
459 "simple_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
460 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
461 ok ( pos
== -1, "simple_server (%x): test pattern error: %d\n", id
, pos
);
464 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
465 ok ( n_sent
== n_expected
,
466 "simple_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
469 read_zero_bytes ( mem
->sock
[0].s
);
470 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "simple_server (%x): closesocket error: %d\n" );
471 mem
->sock
[0].s
= INVALID_SOCKET
;
478 * oob_server: A very basic server receiving out-of-band data.
480 static VOID WINAPI
oob_server ( server_params
*par
)
482 test_params
*gen
= par
->general
;
485 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
,
486 id
= GetCurrentThreadId();
488 set_so_opentype ( FALSE
); /* non-overlapped */
489 server_start ( par
);
490 mem
= TlsGetValue ( tls
);
492 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "oob_server (%x): failed to set blocking mode: %d\n");
493 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "oob_server (%x): listen failed: %d\n");
495 SetEvent ( server_ready
); /* notify clients */
497 /* accept a single connection */
498 tmp
= sizeof ( mem
->sock
[0].peer
);
499 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
500 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "oob_server (%x): accept failed: %d\n" );
502 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
503 "oob_server (%x): strange peer address\n", id
);
505 /* check initial atmark state */
506 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
507 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
509 /* Receive normal data */
510 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
511 ok ( n_recvd
== n_expected
,
512 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
513 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
514 ok ( pos
== -1, "oob_server (%x): test pattern error: %d\n", id
, pos
);
516 /* check atmark state */
517 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
518 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
521 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
522 ok ( n_sent
== n_expected
,
523 "oob_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
525 /* Receive a part of the out-of-band data and print atmark state */
526 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, 8, 0, par
->buflen
);
528 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, 8 );
531 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
533 /* Receive the rest of the out-of-band data and check atmark state */
534 do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
536 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
537 todo_wine
ok ( atmark
== 0, "oob_server (%x): not at the OOB mark: %i\n", id
, atmark
);
540 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "oob_server (%x): closesocket error: %d\n" );
541 mem
->sock
[0].s
= INVALID_SOCKET
;
547 * select_server: A non-blocking server.
549 static VOID WINAPI
select_server ( server_params
*par
)
551 test_params
*gen
= par
->general
;
553 int n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
554 id
= GetCurrentThreadId(), n_connections
= 0, n_sent
, n_recvd
,
555 n_set
, delta
, n_ready
;
556 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
557 fd_set fds_recv
, fds_send
, fds_openrecv
, fds_opensend
;
559 set_so_opentype ( FALSE
); /* non-overlapped */
560 server_start ( par
);
561 mem
= TlsGetValue ( tls
);
563 wsa_ok ( set_blocking ( mem
->s
, FALSE
), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
564 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "select_server (%x): listen failed: %d\n");
566 SetEvent ( server_ready
); /* notify clients */
568 FD_ZERO ( &fds_openrecv
);
569 FD_ZERO ( &fds_recv
);
570 FD_ZERO ( &fds_send
);
571 FD_ZERO ( &fds_opensend
);
573 FD_SET ( mem
->s
, &fds_openrecv
);
577 fds_recv
= fds_openrecv
;
578 fds_send
= fds_opensend
;
582 wsa_ok ( ( n_ready
= select ( 0, &fds_recv
, &fds_send
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
583 "select_server (%x): select() failed: %d\n" );
585 /* check for incoming requests */
586 if ( FD_ISSET ( mem
->s
, &fds_recv
) ) {
589 /* accept a single connection */
590 tmp
= sizeof ( mem
->sock
[n_connections
].peer
);
591 mem
->sock
[n_connections
].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[n_connections
].peer
, &tmp
);
592 wsa_ok ( mem
->sock
[n_connections
].s
, INVALID_SOCKET
!=, "select_server (%x): accept() failed: %d\n" );
594 ok ( mem
->sock
[n_connections
].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
595 "select_server (%x): strange peer address\n", id
);
597 /* add to list of open connections */
598 FD_SET ( mem
->sock
[n_connections
].s
, &fds_openrecv
);
599 FD_SET ( mem
->sock
[n_connections
].s
, &fds_opensend
);
604 /* handle open requests */
606 for ( i
= 0; i
< n_connections
; i
++ )
608 if ( FD_ISSET( mem
->sock
[i
].s
, &fds_recv
) ) {
611 if ( mem
->sock
[i
].n_recvd
< n_expected
) {
612 /* Receive data & check it */
613 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 );
614 ok ( n_recvd
!= SOCKET_ERROR
, "select_server (%x): error in recv(): %d\n", id
, WSAGetLastError() );
615 mem
->sock
[i
].n_recvd
+= n_recvd
;
617 if ( mem
->sock
[i
].n_recvd
== n_expected
) {
618 int pos
= test_buffer ( mem
->sock
[i
].buf
, gen
->chunk_size
, gen
->n_chunks
);
619 ok ( pos
== -1, "select_server (%x): test pattern error: %d\n", id
, pos
);
620 FD_CLR ( mem
->sock
[i
].s
, &fds_openrecv
);
623 ok ( mem
->sock
[i
].n_recvd
<= n_expected
, "select_server (%x): received too many bytes: %d\n", id
, mem
->sock
[i
].n_recvd
);
627 /* only echo back what we've received */
628 delta
= mem
->sock
[i
].n_recvd
- mem
->sock
[i
].n_sent
;
630 if ( FD_ISSET ( mem
->sock
[i
].s
, &fds_send
) ) {
633 if ( ( delta
> 0 ) && ( mem
->sock
[i
].n_sent
< n_expected
) ) {
635 n_sent
= send ( mem
->sock
[i
].s
, mem
->sock
[i
].buf
+ mem
->sock
[i
].n_sent
, min ( delta
, par
->buflen
), 0 );
636 ok ( n_sent
!= SOCKET_ERROR
, "select_server (%x): error in send(): %d\n", id
, WSAGetLastError() );
637 mem
->sock
[i
].n_sent
+= n_sent
;
639 if ( mem
->sock
[i
].n_sent
== n_expected
) {
640 FD_CLR ( mem
->sock
[i
].s
, &fds_opensend
);
643 ok ( mem
->sock
[i
].n_sent
<= n_expected
, "select_server (%x): sent too many bytes: %d\n", id
, mem
->sock
[i
].n_sent
);
648 /* check that select returned the correct number of ready sockets */
649 ok ( ( n_set
== n_ready
), "select_server (%x): select() returns wrong number of ready sockets\n", id
);
651 /* check if all clients are done */
652 if ( ( fds_opensend
.fd_count
== 0 )
653 && ( fds_openrecv
.fd_count
== 1 ) /* initial socket that accepts clients */
654 && ( n_connections
== min ( gen
->n_clients
, MAX_CLIENTS
) ) ) {
659 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
662 read_zero_bytes ( mem
->sock
[i
].s
);
663 wsa_ok ( closesocket ( mem
->sock
[i
].s
), 0 ==, "select_server (%x): closesocket error: %d\n" );
664 mem
->sock
[i
].s
= INVALID_SOCKET
;
670 /**************** Clients ***************/
673 * simple_client: A very basic client doing synchronous IO.
675 static VOID WINAPI
simple_client ( client_params
*par
)
677 test_params
*gen
= par
->general
;
679 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
681 id
= GetCurrentThreadId();
682 /* wait here because we want to call set_so_opentype before creating a socket */
683 WaitForSingleObject ( server_ready
, INFINITE
);
685 check_so_opentype ();
686 set_so_opentype ( FALSE
); /* non-overlapped */
687 client_start ( par
);
688 mem
= TlsGetValue ( tls
);
691 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
692 0 ==, "simple_client (%x): connect error: %d\n" );
693 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
694 "simple_client (%x): failed to set blocking mode\n", id
);
696 /* send data to server */
697 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
698 ok ( n_sent
== n_expected
,
699 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
701 /* shutdown send direction */
702 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
704 /* Receive data echoed back & check it */
705 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, 0, par
->buflen
);
706 ok ( n_recvd
== n_expected
,
707 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
710 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
711 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
714 read_zero_bytes ( mem
->s
);
719 * oob_client: A very basic client sending out-of-band data.
721 static VOID WINAPI
oob_client ( client_params
*par
)
723 test_params
*gen
= par
->general
;
725 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
727 id
= GetCurrentThreadId();
728 /* wait here because we want to call set_so_opentype before creating a socket */
729 WaitForSingleObject ( server_ready
, INFINITE
);
731 check_so_opentype ();
732 set_so_opentype ( FALSE
); /* non-overlapped */
733 client_start ( par
);
734 mem
= TlsGetValue ( tls
);
737 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
738 0 ==, "oob_client (%x): connect error: %d\n" );
739 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
740 "oob_client (%x): failed to set blocking mode\n", id
);
742 /* send data to server */
743 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
744 ok ( n_sent
== n_expected
,
745 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
747 /* Receive data echoed back & check it */
748 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, 0, par
->buflen
);
749 ok ( n_recvd
== n_expected
,
750 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
751 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
752 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
754 /* send out-of-band data to server */
755 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, MSG_OOB
, par
->buflen
);
756 ok ( n_sent
== n_expected
,
757 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
759 /* shutdown send direction */
760 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
763 read_zero_bytes ( mem
->s
);
768 * simple_mixed_client: mixing send and recvfrom
770 static VOID WINAPI
simple_mixed_client ( client_params
*par
)
772 test_params
*gen
= par
->general
;
774 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
775 int fromLen
= sizeof(mem
->addr
);
776 struct sockaddr test
;
778 id
= GetCurrentThreadId();
779 /* wait here because we want to call set_so_opentype before creating a socket */
780 WaitForSingleObject ( server_ready
, INFINITE
);
782 check_so_opentype ();
783 set_so_opentype ( FALSE
); /* non-overlapped */
784 client_start ( par
);
785 mem
= TlsGetValue ( tls
);
788 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
789 0 ==, "simple_client (%x): connect error: %d\n" );
790 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
791 "simple_client (%x): failed to set blocking mode\n", id
);
793 /* send data to server */
794 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
795 ok ( n_sent
== n_expected
,
796 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
798 /* shutdown send direction */
799 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
801 /* this shouldn't change, since lpFrom, is not updated on
802 connection oriented sockets - exposed by bug 11640
804 ((struct sockaddr_in
*)&test
)->sin_addr
.s_addr
= inet_addr("0.0.0.0");
806 /* Receive data echoed back & check it */
807 n_recvd
= do_synchronous_recvfrom ( mem
->s
,
811 (struct sockaddr
*)&test
,
814 ok ( n_recvd
== n_expected
,
815 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
817 /* check that lpFrom was not updated */
820 inet_ntoa(((struct sockaddr_in
*)&test
)->sin_addr
),
821 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
824 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
825 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
828 read_zero_bytes ( mem
->s
);
833 * event_client: An event-driven client
835 static void WINAPI
event_client ( client_params
*par
)
837 test_params
*gen
= par
->general
;
839 int id
= GetCurrentThreadId(), n_expected
= gen
->n_chunks
* gen
->chunk_size
,
842 WSANETWORKEVENTS wsa_events
;
843 char *send_last
, *recv_last
, *send_p
, *recv_p
;
844 LONG mask
= FD_READ
| FD_WRITE
| FD_CLOSE
;
846 client_start ( par
);
848 mem
= TlsGetValue ( tls
);
850 /* Prepare event notification for connect, makes socket nonblocking */
851 event
= WSACreateEvent ();
852 WSAEventSelect ( mem
->s
, event
, FD_CONNECT
);
853 tmp
= connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) );
855 err
= WSAGetLastError ();
856 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): connect error: %d\n", id
, err
);
857 tmp
= WaitForSingleObject ( event
, INFINITE
);
858 ok ( tmp
== WAIT_OBJECT_0
, "event_client (%x): wait for connect event failed: %d\n", id
, tmp
);
859 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
860 ok ( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
861 err
= wsa_events
.iErrorCode
[ FD_CONNECT_BIT
];
862 ok ( err
== 0, "event_client (%x): connect error: %d\n", id
, err
);
866 WSAEventSelect ( mem
->s
, event
, mask
);
868 recv_p
= mem
->recv_buf
;
869 recv_last
= mem
->recv_buf
+ n_expected
;
870 send_p
= mem
->send_buf
;
871 send_last
= mem
->send_buf
+ n_expected
;
875 err
= WaitForSingleObject ( event
, INFINITE
);
876 ok ( err
== WAIT_OBJECT_0
, "event_client (%x): wait failed\n", id
);
878 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
879 ok( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
881 if ( wsa_events
.lNetworkEvents
& FD_WRITE
)
883 err
= wsa_events
.iErrorCode
[ FD_WRITE_BIT
];
884 ok ( err
== 0, "event_client (%x): FD_WRITE error code: %d\n", id
, err
);
889 n
= send ( mem
->s
, send_p
, min ( send_last
- send_p
, par
->buflen
), 0 );
892 err
= WSAGetLastError ();
893 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): send error: %d\n", id
, err
);
898 while ( n
>= 0 && send_p
< send_last
);
900 if ( send_p
== send_last
)
902 shutdown ( mem
->s
, SD_SEND
);
904 WSAEventSelect ( mem
->s
, event
, mask
);
907 if ( wsa_events
.lNetworkEvents
& FD_READ
)
909 err
= wsa_events
.iErrorCode
[ FD_READ_BIT
];
910 ok ( err
== 0, "event_client (%x): FD_READ error code: %d\n", id
, err
);
911 if ( err
!= 0 ) break;
913 /* First read must succeed */
914 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
915 wsa_ok ( n
, 0 <=, "event_client (%x): recv error: %d\n" );
919 if ( recv_p
== recv_last
)
922 WSAEventSelect ( mem
->s
, event
, mask
);
925 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
926 ok(n
>= 0 || WSAGetLastError() == WSAEWOULDBLOCK
,
927 "event_client (%x): got error %u\n", id
, WSAGetLastError());
931 if ( wsa_events
.lNetworkEvents
& FD_CLOSE
)
933 err
= wsa_events
.iErrorCode
[ FD_CLOSE_BIT
];
934 ok ( err
== 0, "event_client (%x): FD_CLOSE error code: %d\n", id
, err
);
939 n
= send_p
- mem
->send_buf
;
940 ok ( send_p
== send_last
,
941 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n
, n_expected
);
942 n
= recv_p
- mem
->recv_buf
;
943 ok ( recv_p
== recv_last
,
944 "simple_client (%x): received less data than expected: %d of %d\n", id
, n
, n_expected
);
945 n
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
946 ok ( n
== -1, "event_client (%x): test pattern error: %d\n", id
, n
);
949 WSACloseEvent ( event
);
953 /* Tests for WSAStartup */
954 static void test_WithoutWSAStartup(void)
958 WSASetLastError(0xdeadbeef);
959 ok(WSASocketA(0, 0, 0, NULL
, 0, 0) == INVALID_SOCKET
, "WSASocketA should have failed\n");
960 err
= WSAGetLastError();
961 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %d\n", err
);
963 WSASetLastError(0xdeadbeef);
964 ok(gethostbyname("localhost") == NULL
, "gethostbyname() succeeded unexpectedly\n");
965 err
= WSAGetLastError();
966 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %d\n", err
);
969 static void test_WithWSAStartup(void)
972 WORD version
= MAKEWORD( 2, 2 );
973 INT res
, socks
, i
, j
;
978 SOCKET src
, dst
, dup_src
, dup_dst
;
982 res
= WSAStartup( version
, &data
);
983 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
985 ptr
= gethostbyname("localhost");
986 ok(ptr
!= NULL
, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
988 /* Alloc some sockets to check if they are destroyed on WSACleanup */
989 for (socks
= 0; socks
< ARRAY_SIZE(pairs
); socks
++)
991 WSAPROTOCOL_INFOA info
;
992 tcp_socketpair(&pairs
[socks
].src
, &pairs
[socks
].dst
);
994 memset(&info
, 0, sizeof(info
));
995 ok(!WSADuplicateSocketA(pairs
[socks
].src
, GetCurrentProcessId(), &info
),
996 "WSADuplicateSocketA should have worked\n");
997 pairs
[socks
].dup_src
= WSASocketA(0, 0, 0, &info
, 0, 0);
998 ok(pairs
[socks
].dup_src
!= SOCKET_ERROR
, "expected != -1\n");
1000 memset(&info
, 0, sizeof(info
));
1001 ok(!WSADuplicateSocketA(pairs
[socks
].dst
, GetCurrentProcessId(), &info
),
1002 "WSADuplicateSocketA should have worked\n");
1003 pairs
[socks
].dup_dst
= WSASocketA(0, 0, 0, &info
, 0, 0);
1004 ok(pairs
[socks
].dup_dst
!= SOCKET_ERROR
, "expected != -1\n");
1007 res
= send(pairs
[0].src
, "TEST", 4, 0);
1008 ok(res
== 4, "send failed with error %d\n", WSAGetLastError());
1012 res
= WSAStartup( version
, &data
);
1013 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
1015 /* show that sockets are destroyed automatically after WSACleanup */
1016 SetLastError(0xdeadbeef);
1017 res
= send(pairs
[0].src
, "TEST", 4, 0);
1018 error
= WSAGetLastError();
1019 ok(res
== SOCKET_ERROR
, "send should have failed\n");
1020 ok(error
== WSAENOTSOCK
, "expected 10038, got %d\n", error
);
1022 SetLastError(0xdeadbeef);
1023 res
= send(pairs
[0].dst
, "TEST", 4, 0);
1024 error
= WSAGetLastError();
1025 ok(res
== SOCKET_ERROR
, "send should have failed\n");
1026 ok(error
== WSAENOTSOCK
, "expected 10038, got %d\n", error
);
1028 /* Check that all sockets were destroyed */
1029 for (i
= 0; i
< socks
; i
++)
1031 for (j
= 0; j
< 4; j
++)
1033 struct sockaddr_in saddr
;
1034 int size
= sizeof(saddr
);
1037 case 0: sock
= pairs
[i
].src
; break;
1038 case 1: sock
= pairs
[i
].dup_src
; break;
1039 case 2: sock
= pairs
[i
].dst
; break;
1040 case 3: sock
= pairs
[i
].dup_dst
; break;
1043 SetLastError(0xdeadbeef);
1044 res
= getsockname(sock
, (struct sockaddr
*)&saddr
, &size
);
1045 error
= WSAGetLastError();
1046 ok(res
== SOCKET_ERROR
, "Test[%d]: getsockname should have failed\n", i
);
1047 if (res
== SOCKET_ERROR
)
1048 ok(error
== WSAENOTSOCK
, "Test[%d]: expected 10038, got %d\n", i
, error
);
1052 /* While wine is not fixed, close all sockets manually */
1053 for (i
= 0; i
< socks
; i
++)
1055 closesocket(pairs
[i
].src
);
1056 closesocket(pairs
[i
].dst
);
1057 closesocket(pairs
[i
].dup_src
);
1058 closesocket(pairs
[i
].dup_dst
);
1062 ok(res
== 0, "expected 0, got %d\n", res
);
1063 WSASetLastError(0xdeadbeef);
1065 error
= WSAGetLastError();
1066 ok ( res
== SOCKET_ERROR
&& error
== WSANOTINITIALISED
,
1067 "WSACleanup returned %d WSAGetLastError is %d\n", res
, error
);
1070 /**************** Main program utility functions ***************/
1072 static void Init (void)
1074 WORD ver
= MAKEWORD (2, 2);
1076 HMODULE hws2_32
= GetModuleHandleA("ws2_32.dll"), ntdll
;
1078 pWSAPoll
= (void *)GetProcAddress(hws2_32
, "WSAPoll");
1080 ntdll
= LoadLibraryA("ntdll.dll");
1082 pNtClose
= (void *)GetProcAddress(ntdll
, "NtClose");
1084 ok ( WSAStartup ( ver
, &data
) == 0, "WSAStartup failed\n" );
1088 static void Exit (void)
1093 err
= WSAGetLastError();
1094 ok ( ret
== 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret
, err
);
1097 static void StartServer (LPTHREAD_START_ROUTINE routine
,
1098 test_params
*general
, server_params
*par
)
1100 par
->general
= general
;
1101 thread
[0] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[0] );
1102 ok ( thread
[0] != NULL
, "Failed to create server thread\n" );
1105 static void StartClients (LPTHREAD_START_ROUTINE routine
,
1106 test_params
*general
, client_params
*par
)
1109 par
->general
= general
;
1110 for ( i
= 1; i
<= min ( general
->n_clients
, MAX_CLIENTS
); i
++ )
1113 thread
[i
] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[i
] );
1114 ok ( thread
[i
] != NULL
, "Failed to create client thread\n" );
1115 /* Make sure the client is up and running */
1116 WaitForSingleObject ( client_ready
[client_id
], INFINITE
);
1120 static void do_test( test_setup
*test
)
1122 DWORD i
, n
= min (test
->general
.n_clients
, MAX_CLIENTS
);
1125 server_ready
= CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1126 for (i
= 0; i
<= n
; i
++)
1127 client_ready
[i
] = CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1129 StartServer ( test
->srv
, &test
->general
, &test
->srv_params
);
1130 StartClients ( test
->clt
, &test
->general
, &test
->clt_params
);
1131 WaitForSingleObject ( server_ready
, INFINITE
);
1133 wait
= WaitForMultipleObjects ( 1 + n
, thread
, TRUE
, 1000 * TEST_TIMEOUT
);
1134 ok(!wait
, "wait failed, error %u\n", wait
);
1136 CloseHandle ( server_ready
);
1137 for (i
= 0; i
<= n
; i
++)
1138 CloseHandle ( client_ready
[i
] );
1141 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1142 /* optname = SO_LINGER */
1143 static const LINGER linger_testvals
[] = {
1150 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1151 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1152 bug in the linux kernel (fixed in 2.6.8) */
1153 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1155 static void test_set_getsockopt(void)
1158 int i
, err
, lasterr
;
1162 WSAPROTOCOL_INFOA infoA
;
1163 WSAPROTOCOL_INFOW infoW
;
1164 char providername
[WSAPROTOCOL_LEN
+ 1];
1168 int family
, type
, proto
;
1170 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
1171 {AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
1172 {AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
},
1173 {AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
}
1181 s
= socket(AF_INET
, SOCK_STREAM
, 0);
1182 ok(s
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1183 if( s
== INVALID_SOCKET
) return;
1185 timeout
= SOCKTIMEOUT1
;
1186 size
= sizeof(timeout
);
1187 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1189 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1190 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1191 ok( timeout
== SOCKTIMEOUT1
, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1194 size
= sizeof(timeout
);
1195 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1197 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1198 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1199 ok( timeout
== 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1202 timeout
= SOCKTIMEOUT2
; /* 997 seconds. See remark above */
1203 size
= sizeof(timeout
);
1204 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, size
);
1206 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, &size
);
1207 ok( !err
, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1208 ok( timeout
== SOCKTIMEOUT2
, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout
);
1212 size
= sizeof(value
);
1213 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDBUF
, (char *)&value
, size
);
1214 ok( !err
, "setsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1216 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDBUF
, (char *)&value
, &size
);
1217 ok( !err
, "getsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1218 ok( value
== 4096, "expected 4096, got %u\n", value
);
1222 size
= sizeof(value
);
1223 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, size
);
1224 ok( !err
, "setsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1226 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, &size
);
1227 ok( !err
, "getsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1228 ok( value
== 4096, "expected 4096, got %u\n", value
);
1231 for( i
= 0; i
< ARRAY_SIZE(linger_testvals
);i
++) {
1232 size
= sizeof(lingval
);
1233 lingval
= linger_testvals
[i
];
1234 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *)&lingval
, size
);
1235 ok(!err
, "Test %u: failed to set SO_LINGER, error %u\n", i
, WSAGetLastError());
1236 err
= getsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *)&lingval
, &size
);
1237 ok(!err
, "Test %u: failed to get SO_LINGER, error %u\n", i
, WSAGetLastError());
1238 ok(!lingval
.l_onoff
== !linger_testvals
[i
].l_onoff
, "Test %u: expected %d, got %d\n",
1239 i
, linger_testvals
[i
].l_onoff
, lingval
.l_onoff
);
1240 if (lingval
.l_onoff
)
1241 ok(lingval
.l_linger
== linger_testvals
[i
].l_linger
, "Test %u: expected %d, got %d\n",
1242 i
, linger_testvals
[i
].l_linger
, lingval
.l_linger
);
1245 size
= sizeof(lingval
);
1246 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, size
);
1247 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1248 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1249 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, 0);
1250 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1251 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1253 size
= sizeof(BOOL
);
1254 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, size
);
1255 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1256 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1257 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, 0);
1258 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1259 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1261 /* Test for erroneously passing a value instead of a pointer as optval */
1262 size
= sizeof(char);
1263 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTROUTE
, (char *)1, size
);
1264 ok(err
== SOCKET_ERROR
, "setsockopt with optval being a value passed "
1265 "instead of failing.\n");
1266 lasterr
= WSAGetLastError();
1267 ok(lasterr
== WSAEFAULT
, "setsockopt with optval being a value "
1268 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1269 lasterr
, WSAEFAULT
);
1271 /* SO_RCVTIMEO with invalid values for level */
1272 size
= sizeof(timeout
);
1273 timeout
= SOCKTIMEOUT1
;
1274 SetLastError(0xdeadbeef);
1275 err
= setsockopt(s
, 0xffffffff, SO_RCVTIMEO
, (char *) &timeout
, size
);
1276 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1277 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1278 err
, WSAGetLastError());
1280 timeout
= SOCKTIMEOUT1
;
1281 SetLastError(0xdeadbeef);
1282 err
= setsockopt(s
, 0x00008000, SO_RCVTIMEO
, (char *) &timeout
, size
);
1283 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1284 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1285 err
, WSAGetLastError());
1287 /* Test SO_ERROR set/get */
1288 SetLastError(0xdeadbeef);
1290 err
= setsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, size
);
1292 ok( !err
&& !WSAGetLastError(),
1293 "got %d with %d (expected 0 with 0)\n",
1294 err
, WSAGetLastError());
1296 SetLastError(0xdeadbeef);
1298 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1299 ok( !err
&& !WSAGetLastError(),
1300 "got %d with %d (expected 0 with 0)\n",
1301 err
, WSAGetLastError());
1303 ok (i
== 1234, "got %d (expected 1234)\n", i
);
1305 /* Test invalid optlen */
1306 SetLastError(0xdeadbeef);
1308 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1309 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEFAULT
),
1310 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1311 err
, WSAGetLastError());
1314 /* Test with the closed socket */
1315 SetLastError(0xdeadbeef);
1318 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1319 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAENOTSOCK
),
1320 "got %d with %d (expected SOCKET_ERROR with WSAENOTSOCK)\n",
1321 err
, WSAGetLastError());
1322 ok (i
== 1234, "expected 1234, got %d\n", i
);
1324 /* Test WS_IP_MULTICAST_TTL with 8, 16, 24 and 32 bits values */
1325 s
= socket(AF_INET
, SOCK_DGRAM
, 0);
1326 ok(s
!= INVALID_SOCKET
, "Failed to create socket\n");
1329 err
= setsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &i
, size
);
1332 for (i
= 0; i
< 4; i
++)
1335 const int tests
[] = {0xffffff0a, 0xffff000b, 0xff00000c, 0x0000000d};
1336 err
= setsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &tests
[i
], i
+ 1);
1337 ok(!err
, "Test [%d] Expected 0, got %d\n", i
, err
);
1338 err
= getsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &k
, &size
);
1339 ok(!err
, "Test [%d] Expected 0, got %d\n", i
, err
);
1340 j
= i
!= 3 ? tests
[i
] & ((1 << (i
+ 1) * 8) - 1) : tests
[i
];
1341 ok(k
== j
, "Test [%d] Expected 0x%x, got 0x%x\n", i
, j
, k
);
1345 win_skip("IP_MULTICAST_TTL is unsupported\n");
1348 /* test SO_PROTOCOL_INFOA invalid parameters */
1349 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1350 "getsockopt should have failed\n");
1351 err
= WSAGetLastError();
1352 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1353 size
= sizeof(WSAPROTOCOL_INFOA
);
1354 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1355 "getsockopt should have failed\n");
1356 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1357 err
= WSAGetLastError();
1358 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1359 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1360 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1361 "getsockopt should have failed\n");
1362 err
= WSAGetLastError();
1363 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1364 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, NULL
),
1365 "getsockopt should have failed\n");
1366 err
= WSAGetLastError();
1367 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1368 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, &size
),
1369 "getsockopt should have failed\n");
1370 err
= WSAGetLastError();
1371 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1372 size
= sizeof(WSAPROTOCOL_INFOA
) / 2;
1373 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1374 "getsockopt should have failed\n");
1375 err
= WSAGetLastError();
1376 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1377 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1378 size
= sizeof(WSAPROTOCOL_INFOA
) * 2;
1379 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1380 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1381 ok(size
== sizeof(WSAPROTOCOL_INFOA
) * 2, "got size %d\n", size
);
1385 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1386 for (i
= 0; i
< ARRAY_SIZE(prottest
); i
++)
1390 s
= socket(prottest
[i
].family
, prottest
[i
].type
, prottest
[i
].proto
);
1391 if (s
== INVALID_SOCKET
&& prottest
[i
].family
== AF_INET6
) continue;
1393 ok(s
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
1396 /* compare both A and W version */
1397 infoA
.szProtocol
[0] = 0;
1398 size
= sizeof(WSAPROTOCOL_INFOA
);
1399 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1400 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1401 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1403 infoW
.szProtocol
[0] = 0;
1404 size
= sizeof(WSAPROTOCOL_INFOW
);
1405 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOW
, (char *) &infoW
, &size
);
1406 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1407 ok(size
== sizeof(WSAPROTOCOL_INFOW
), "got size %d\n", size
);
1409 ok(infoA
.szProtocol
[0], "WSAPROTOCOL_INFOA was not filled\n");
1410 ok(infoW
.szProtocol
[0], "WSAPROTOCOL_INFOW was not filled\n");
1412 WideCharToMultiByte(CP_ACP
, 0, infoW
.szProtocol
, -1,
1413 providername
, sizeof(providername
), NULL
, NULL
);
1414 ok(!strcmp(infoA
.szProtocol
,providername
),
1415 "different provider names '%s' != '%s'\n", infoA
.szProtocol
, providername
);
1417 ok(!memcmp(&infoA
, &infoW
, FIELD_OFFSET(WSAPROTOCOL_INFOA
, szProtocol
)),
1418 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1420 /* Remove IF when WSAEnumProtocols support IPV6 data */
1421 ok(infoA
.iAddressFamily
== prottest
[i
].family
, "socket family invalid, expected %d received %d\n",
1422 prottest
[i
].family
, infoA
.iAddressFamily
);
1423 ok(infoA
.iSocketType
== prottest
[i
].type
, "socket type invalid, expected %d received %d\n",
1424 prottest
[i
].type
, infoA
.iSocketType
);
1425 ok(infoA
.iProtocol
== prottest
[i
].proto
, "socket protocol invalid, expected %d received %d\n",
1426 prottest
[i
].proto
, infoA
.iProtocol
);
1428 /* IP_HDRINCL is supported only on SOCK_RAW but passed to SOCK_DGRAM by Impossible Creatures */
1431 SetLastError(0xdeadbeef);
1432 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1433 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
);
1441 ok(err
== -1, "Expected -1, got %d\n", err
);
1442 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1443 ok(k
== 99, "Expected 99, got %d\n", k
);
1448 SetLastError(0xdeadbeef);
1449 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1450 ok(err
== -1, "Expected -1, got %d\n", err
);
1451 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1453 SetLastError(0xdeadbeef);
1454 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1457 ok(err
== -1, "Expected -1, got %d\n", err
);
1458 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1459 ok(k
== 99, "Expected 99, got %d\n", k
);
1462 else /* <= 2003 the tests differ between TCP and UDP, UDP silently accepts */
1464 SetLastError(0xdeadbeef);
1466 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1467 if (prottest
[i
].type
== SOCK_DGRAM
)
1469 ok(err
== 0, "Expected 0, got %d\n", err
);
1470 ok(k
== 1, "Expected 1, got %d\n", k
);
1474 /* contratry to what we could expect the function returns error but k is changed */
1475 ok(err
== -1, "Expected -1, got %d\n", err
);
1476 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %d\n", GetLastError());
1477 ok(k
== 0, "Expected 0, got %d\n", k
);
1481 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1482 ok(err
== 0, "Expected 0, got %d\n", err
);
1485 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1486 if (prottest
[i
].type
== SOCK_DGRAM
)
1488 ok(err
== 0, "Expected 0, got %d\n", err
);
1489 ok(k
== 0, "Expected 0, got %d\n", k
);
1493 /* contratry to what we could expect the function returns error but k is changed */
1494 ok(err
== -1, "Expected -1, got %d\n", err
);
1495 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %d\n", GetLastError());
1496 ok(k
== 0, "Expected 0, got %d\n", k
);
1503 /* Test SO_BSP_STATE - Present only in >= Win 2008 */
1504 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1505 ok(s
!= INVALID_SOCKET
, "Failed to create socket\n");
1506 s2
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1507 ok(s2
!= INVALID_SOCKET
, "Failed to create socket\n");
1509 SetLastError(0xdeadbeef);
1510 size
= sizeof(csinfoA
);
1511 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1514 struct sockaddr_in saddr
;
1515 memset(&saddr
, 0, sizeof(saddr
));
1516 saddr
.sin_family
= AF_INET
;
1517 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1519 /* Socket is not bound, no information provided */
1520 ok(!csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1521 ok(csinfoA
.cs
.LocalAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.LocalAddr
.lpSockaddr
);
1522 /* Socket is not connected, no information provided */
1523 ok(!csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.RemoteAddr
.iSockaddrLength
);
1524 ok(csinfoA
.cs
.RemoteAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.RemoteAddr
.lpSockaddr
);
1526 err
= bind(s
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1527 ok(!err
, "Expected 0, got %d\n", err
);
1528 size
= sizeof(csinfoA
);
1529 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1530 ok(!err
, "Expected 0, got %d\n", err
);
1532 /* Socket is bound */
1533 ok(csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected non-zero\n");
1534 ok(csinfoA
.cs
.LocalAddr
.lpSockaddr
!= NULL
, "Expected non-null\n");
1535 /* Socket is not connected, no information provided */
1536 ok(!csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.RemoteAddr
.iSockaddrLength
);
1537 ok(csinfoA
.cs
.RemoteAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.RemoteAddr
.lpSockaddr
);
1539 err
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1540 ok(!err
, "Expected 0, got %d\n", err
);
1541 err
= getsockname(s2
, (struct sockaddr
*)&saddr
, &size
);
1542 ok(!err
, "Expected 0, got %d\n", err
);
1543 err
= listen(s2
, 1);
1544 ok(!err
, "Expected 0, got %d\n", err
);
1545 err
= connect(s
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1546 ok(!err
, "Expected 0, got %d\n", err
);
1547 size
= sizeof(saddr
);
1548 err
= accept(s2
, (struct sockaddr
*)&saddr
, &size
);
1549 ok(err
!= INVALID_SOCKET
, "Failed to accept socket\n");
1553 size
= sizeof(csinfoA
);
1554 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1555 ok(!err
, "Expected 0, got %d\n", err
);
1556 err
= getsockopt(s2
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoB
, &size
);
1557 ok(!err
, "Expected 0, got %d\n", err
);
1558 ok(size
== sizeof(csinfoA
), "Got %d\n", size
);
1559 size
= sizeof(saddr
);
1560 ok(size
== csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected %d, got %d\n", size
,
1561 csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1562 ok(size
== csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected %d, got %d\n", size
,
1563 csinfoA
.cs
.RemoteAddr
.iSockaddrLength
);
1564 ok(!memcmp(csinfoA
.cs
.LocalAddr
.lpSockaddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
),
1565 "Expected matching addresses\n");
1566 ok(!memcmp(csinfoB
.cs
.LocalAddr
.lpSockaddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
),
1567 "Expected matching addresses\n");
1568 ok(csinfoA
.cs
.iSocketType
== SOCK_STREAM
, "Wrong socket type\n");
1569 ok(csinfoB
.cs
.iSocketType
== SOCK_STREAM
, "Wrong socket type\n");
1570 ok(csinfoA
.cs
.iProtocol
== IPPROTO_TCP
, "Wrong socket protocol\n");
1571 ok(csinfoB
.cs
.iProtocol
== IPPROTO_TCP
, "Wrong socket protocol\n");
1573 err
= getpeername(s
, (struct sockaddr
*)&saddr
, &size
);
1574 ok(!err
, "Expected 0, got %d\n", err
);
1575 ok(!memcmp(&saddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1576 ok(!memcmp(&saddr
, csinfoB
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1577 err
= getpeername(s2
, (struct sockaddr
*)&saddr
, &size
);
1578 ok(!err
, "Expected 0, got %d\n", err
);
1579 ok(!memcmp(&saddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1580 ok(!memcmp(&saddr
, csinfoA
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1581 err
= getsockname(s
, (struct sockaddr
*)&saddr
, &size
);
1582 ok(!err
, "Expected 0, got %d\n", err
);
1583 ok(!memcmp(&saddr
, csinfoA
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1584 ok(!memcmp(&saddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1585 err
= getsockname(s2
, (struct sockaddr
*)&saddr
, &size
);
1586 ok(!err
, "Expected 0, got %d\n", err
);
1587 ok(!memcmp(&saddr
, csinfoB
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1588 ok(!memcmp(&saddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1590 SetLastError(0xdeadbeef);
1591 size
= sizeof(CSADDR_INFO
);
1592 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1593 ok(err
, "Expected non-zero\n");
1594 ok(size
== sizeof(CSADDR_INFO
), "Got %d\n", size
);
1595 ok(GetLastError() == WSAEFAULT
, "Expected 10014, got %d\n", GetLastError());
1597 /* At least for IPv4 the size is exactly 56 bytes */
1598 size
= sizeof(*csinfoA
.cs
.LocalAddr
.lpSockaddr
) * 2 + sizeof(csinfoA
.cs
);
1599 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1600 ok(!err
, "Expected 0, got %d\n", err
);
1602 SetLastError(0xdeadbeef);
1603 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1604 ok(err
, "Expected non-zero\n");
1605 ok(GetLastError() == WSAEFAULT
, "Expected 10014, got %d\n", GetLastError());
1608 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %d\n", GetLastError());
1613 for (i
= 0; i
< 2; i
++)
1620 level
= IPPROTO_IPV6
;
1628 s
= socket(family
, SOCK_DGRAM
, 0);
1629 if (s
== INVALID_SOCKET
&& i
)
1631 skip("IPv6 is not supported\n");
1634 ok(s
!= INVALID_SOCKET
, "socket failed with error %d\n", GetLastError());
1636 size
= sizeof(value
);
1638 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1639 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1640 ok(value
== 0, "Expected 0, got %d\n", value
);
1642 size
= sizeof(value
);
1644 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
1645 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1648 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1649 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1650 ok(value
== 1, "Expected 1, got %d\n", value
);
1652 size
= sizeof(value
);
1654 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
1655 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1657 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1658 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1659 ok(value
== 1, "Expected 1, got %d\n", value
);
1663 s
= socket(family
, SOCK_STREAM
, 0);
1664 ok(s
!= INVALID_SOCKET
, "socket failed with error %d\n", GetLastError());
1666 size
= sizeof(value
);
1668 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1669 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1670 ok(value
== 1 || broken(value
== 0) /* < vista */, "Expected 1, got %d\n", value
);
1672 size
= sizeof(value
);
1674 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
1675 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1678 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1679 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1680 ok(value
== 0, "Expected 0, got %d\n", value
);
1684 s
= socket(family
, SOCK_RAW
, 0);
1685 if (s
== INVALID_SOCKET
)
1687 if (WSAGetLastError() == WSAEACCES
) skip("SOCK_RAW is not available\n");
1688 else if (i
) skip("IPv6 is not supported\n");
1691 ok(s
!= INVALID_SOCKET
, "socket failed with error %d\n", GetLastError());
1693 size
= sizeof(value
);
1695 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1696 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1697 ok(value
== 0, "Expected 0, got %d\n", value
);
1699 size
= sizeof(value
);
1701 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
1702 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1705 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1706 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1707 ok(value
== 1, "Expected 1, got %d\n", value
);
1713 static void test_so_reuseaddr(void)
1715 struct sockaddr_in saddr
;
1717 unsigned int rc
,reuse
;
1721 saddr
.sin_family
= AF_INET
;
1722 saddr
.sin_port
= htons(SERVERPORT
+1);
1723 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1725 s1
=socket(AF_INET
, SOCK_STREAM
, 0);
1726 ok(s1
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1727 rc
= bind(s1
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1728 ok(rc
!=SOCKET_ERROR
, "bind(s1) failed error: %d\n", WSAGetLastError());
1730 s2
=socket(AF_INET
, SOCK_STREAM
, 0);
1731 ok(s2
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1735 rc
=getsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, &size
);
1736 ok(rc
==0 && reuse
==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc
,reuse
);
1738 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1739 ok(rc
==SOCKET_ERROR
, "bind() succeeded\n");
1742 rc
= setsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
1743 ok(rc
==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1745 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1746 * a port immediately after closing another socket on that port, so
1747 * basically following the BSD socket semantics here. */
1748 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1751 int s3
=socket(AF_INET
, SOCK_STREAM
, 0), s4
;
1753 /* If we could bind again in the same port this is Windows version <= XP.
1754 * Lets test if we can really connect to one of them. */
1755 set_blocking(s1
, FALSE
);
1756 set_blocking(s2
, FALSE
);
1758 ok(!rc
, "listen() failed with error: %d\n", WSAGetLastError());
1760 ok(!rc
, "listen() failed with error: %d\n", WSAGetLastError());
1761 rc
= connect(s3
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1762 ok(!rc
, "connecting to accepting socket failed %d\n", WSAGetLastError());
1764 /* the delivery of the connection is random so we need to try on both sockets */
1765 size
= sizeof(saddr
);
1766 s4
= accept(s1
, (struct sockaddr
*)&saddr
, &size
);
1767 if(s4
== INVALID_SOCKET
)
1768 s4
= accept(s2
, (struct sockaddr
*)&saddr
, &size
);
1769 ok(s4
!= INVALID_SOCKET
, "none of the listening sockets could get the connection\n");
1777 err
= WSAGetLastError();
1778 ok(err
==WSAEACCES
, "expected 10013, got %d\n", err
);
1781 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1782 ok(rc
==0, "bind() failed error: %d\n", WSAGetLastError());
1788 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
1790 static unsigned int got_ip_pktinfo_apc
;
1792 static void WINAPI
ip_pktinfo_apc(DWORD error
, DWORD size
, OVERLAPPED
*overlapped
, DWORD flags
)
1794 ok(error
== WSAEMSGSIZE
, "got error %u\n", error
);
1795 ok(size
== 6, "got size %u\n", size
);
1796 ok(!flags
, "got flags %#x\n", flags
);
1797 ++got_ip_pktinfo_apc
;
1800 static void test_ip_pktinfo(void)
1802 ULONG addresses
[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY
)};
1803 char recvbuf
[10], pktbuf
[512], msg
[] = "HELLO";
1804 struct sockaddr_in s1addr
, s2addr
, s3addr
;
1805 GUID WSARecvMsg_GUID
= WSAID_WSARECVMSG
;
1806 LPFN_WSARECVMSG pWSARecvMsg
= NULL
;
1807 unsigned int rc
, yes
= 1;
1809 DWORD dwBytes
, dwSize
, dwFlags
;
1818 memset(&ov
, 0, sizeof(ov
));
1819 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
1821 memset(&hdr
, 0x00, sizeof(hdr
));
1822 s1addr
.sin_family
= AF_INET
;
1823 s1addr
.sin_port
= htons(0);
1824 /* Note: s1addr.sin_addr is set below */
1825 iovec
[0].buf
= recvbuf
;
1826 iovec
[0].len
= sizeof(recvbuf
);
1827 hdr
.name
= (struct sockaddr
*)&s3addr
;
1828 hdr
.namelen
= sizeof(s3addr
);
1829 hdr
.lpBuffers
= &iovec
[0];
1830 hdr
.dwBufferCount
= 1;
1831 hdr
.Control
.buf
= pktbuf
;
1832 /* Note: hdr.Control.len is set below */
1835 for (i
=0;i
<ARRAY_SIZE(addresses
);i
++)
1837 s1addr
.sin_addr
.s_addr
= addresses
[i
];
1839 /* Build "server" side socket */
1840 s1
=socket(AF_INET
, SOCK_DGRAM
, 0);
1841 ok(s1
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
1843 /* Obtain the WSARecvMsg function */
1844 rc
= WSAIoctl(s1
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSARecvMsg_GUID
, sizeof(WSARecvMsg_GUID
),
1845 &pWSARecvMsg
, sizeof(pWSARecvMsg
), &dwBytes
, NULL
, NULL
);
1846 ok(!rc
, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
1848 /* Setup the server side socket */
1849 rc
=bind(s1
, (struct sockaddr
*)&s1addr
, sizeof(s1addr
));
1850 ok(rc
!= SOCKET_ERROR
, "bind() failed error: %d\n", WSAGetLastError());
1852 /* Build "client" side socket */
1853 addrlen
= sizeof(s2addr
);
1854 rc
= getsockname(s1
, (struct sockaddr
*) &s2addr
, &addrlen
);
1855 ok(!rc
, "failed to get address, error %u\n", WSAGetLastError());
1856 s2addr
.sin_addr
.s_addr
= addresses
[0]; /* Always target the local adapter address */
1857 s2
=socket(AF_INET
, SOCK_DGRAM
, 0);
1858 ok(s2
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
1860 /* Test an empty message header */
1861 rc
=pWSARecvMsg(s1
, NULL
, NULL
, NULL
, NULL
);
1862 err
=WSAGetLastError();
1863 ok(rc
== SOCKET_ERROR
&& err
== WSAEFAULT
, "WSARecvMsg() failed error: %d (ret = %d)\n", err
, rc
);
1865 /* Test that when no control data arrives, a 0-length NULL-valued control buffer should succeed */
1866 SetLastError(0xdeadbeef);
1867 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1868 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1869 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
1870 hdr
.Control
.buf
= NULL
;
1871 hdr
.Control
.len
= 0;
1872 rc
=pWSARecvMsg(s1
, &hdr
, &dwSize
, NULL
, NULL
);
1873 ok(rc
== 0, "WSARecvMsg() failed error: %d\n", WSAGetLastError());
1874 hdr
.Control
.buf
= pktbuf
;
1876 /* Now start IP_PKTINFO for future tests */
1877 rc
=setsockopt(s1
, IPPROTO_IP
, IP_PKTINFO
, (const char*)&yes
, sizeof(yes
));
1878 ok(rc
== 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
1881 * Send a packet from the client to the server and test for specifying
1882 * a short control header.
1884 SetLastError(0xdeadbeef);
1885 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1886 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1887 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
1888 hdr
.Control
.len
= 1;
1889 dwSize
= 0xdeadbeef;
1890 rc
= pWSARecvMsg(s1
, &hdr
, &dwSize
, NULL
, NULL
);
1891 ok(rc
== -1, "expected failure\n");
1892 ok(WSAGetLastError() == WSAEMSGSIZE
, "got error %u\n", WSAGetLastError());
1893 todo_wine
ok(dwSize
== sizeof(msg
), "got size %u\n", dwSize
);
1894 ok(hdr
.dwFlags
== MSG_CTRUNC
, "got flags %#x\n", hdr
.dwFlags
);
1895 hdr
.dwFlags
= 0; /* Reset flags */
1897 /* Perform another short control header test, this time with an overlapped receive */
1898 hdr
.Control
.len
= 1;
1899 ov
.Internal
= 0xdead1;
1900 ov
.InternalHigh
= 0xdead2;
1901 ov
.Offset
= 0xdead3;
1902 ov
.OffsetHigh
= 0xdead4;
1903 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
1904 err
=WSAGetLastError();
1905 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
1906 SetLastError(0xdeadbeef);
1907 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1908 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1909 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
1910 ok(!WaitForSingleObject(ov
.hEvent
, 100), "wait failed\n");
1911 ok((NTSTATUS
)ov
.Internal
== STATUS_BUFFER_OVERFLOW
, "got status %#x\n", (NTSTATUS
)ov
.Internal
);
1912 ok(ov
.InternalHigh
== sizeof(msg
), "got size %Iu\n", ov
.InternalHigh
);
1913 ok(ov
.Offset
== 0xdead3, "got Offset %Iu\n", ov
.Offset
);
1914 ok(ov
.OffsetHigh
== 0xdead4, "got OffsetHigh %Iu\n", ov
.OffsetHigh
);
1915 dwFlags
= 0xdeadbeef;
1916 rc
= WSAGetOverlappedResult(s1
, &ov
, &dwSize
, FALSE
, &dwFlags
);
1917 ok(!rc
, "expected failure\n");
1918 ok(WSAGetLastError() == WSAEMSGSIZE
, "got error %u\n", WSAGetLastError());
1919 ok(dwSize
== sizeof(msg
), "got size %u\n", dwSize
);
1920 todo_wine
ok(dwFlags
== 0xdeadbeef, "got flags %#x\n", dwFlags
);
1921 ok(hdr
.dwFlags
== MSG_CTRUNC
,
1922 "WSARecvMsg() overlapped operation set unexpected flags %d.\n", hdr
.dwFlags
);
1923 hdr
.dwFlags
= 0; /* Reset flags */
1925 /* And with an APC. */
1927 SetLastError(0xdeadbeef);
1928 rc
= sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1929 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1930 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
1931 hdr
.Control
.len
= 1;
1933 ov
.Internal
= 0xdead1;
1934 ov
.InternalHigh
= 0xdead2;
1935 ov
.Offset
= 0xdead3;
1936 ov
.OffsetHigh
= 0xdead4;
1937 dwSize
= 0xdeadbeef;
1938 rc
= pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, ip_pktinfo_apc
);
1939 ok(rc
== -1, "expected failure\n");
1940 todo_wine
ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
1942 rc
= SleepEx(1000, TRUE
);
1943 todo_wine
ok(rc
== WAIT_IO_COMPLETION
, "got %d\n", rc
);
1944 todo_wine
ok(got_ip_pktinfo_apc
== 1, "apc was called %u times\n", got_ip_pktinfo_apc
);
1945 ok(hdr
.dwFlags
== MSG_CTRUNC
, "got flags %#x\n", hdr
.dwFlags
);
1946 got_ip_pktinfo_apc
= 0;
1948 hdr
.dwFlags
= 0; /* Reset flags */
1951 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
1952 * on the server end and check that the returned packet matches what was sent.
1954 hdr
.Control
.len
= sizeof(pktbuf
);
1955 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
1956 err
=WSAGetLastError();
1957 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
1958 ok(hdr
.Control
.len
== sizeof(pktbuf
),
1959 "WSARecvMsg() control length mismatch (%d != sizeof pktbuf).\n", hdr
.Control
.len
);
1960 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1961 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1962 ok(!WaitForSingleObject(ov
.hEvent
, 100), "wait failed\n");
1964 WSAGetOverlappedResult(s1
, &ov
, &dwSize
, FALSE
, NULL
);
1965 ok(dwSize
== sizeof(msg
),
1966 "WSARecvMsg() buffer length does not match transmitted data!\n");
1967 ok(strncmp(iovec
[0].buf
, msg
, sizeof(msg
)) == 0,
1968 "WSARecvMsg() buffer does not match transmitted data!\n");
1969 ok(hdr
.Control
.len
== IP_PKTINFO_LEN
,
1970 "WSARecvMsg() control length mismatch (%d).\n", hdr
.Control
.len
);
1972 /* Test for the expected IP_PKTINFO return information. */
1974 for (cmsg
= WSA_CMSG_FIRSTHDR(&hdr
); cmsg
!= NULL
; cmsg
= WSA_CMSG_NXTHDR(&hdr
, cmsg
))
1976 if (cmsg
->cmsg_level
== IPPROTO_IP
&& cmsg
->cmsg_type
== IP_PKTINFO
)
1978 struct in_pktinfo
*pi
= (struct in_pktinfo
*)WSA_CMSG_DATA(cmsg
);
1980 ok(pi
->ipi_addr
.s_addr
== s2addr
.sin_addr
.s_addr
, "destination ip mismatch!\n");
1984 ok(foundhdr
, "IP_PKTINFO header information was not returned!\n");
1990 CloseHandle(ov
.hEvent
);
1993 /************* Array containing the tests to run **********/
1995 #define STD_STREAM_SOCKET \
2001 static test_setup tests
[] =
2003 /* Test 0: synchronous client and server */
2024 /* Test 1: event-driven client, synchronous server */
2041 WSA_FLAG_OVERLAPPED
,
2045 /* Test 2: synchronous client, non-blocking server via select() */
2066 /* Test 3: OOB client, OOB server */
2087 /* Test 4: synchronous mixed client and server */
2101 simple_mixed_client
,
2110 static void test_UDP(void)
2112 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
2113 possible that this test fails due to dropped packets. */
2115 /* peer 0 receives data from all other peers */
2116 struct sock_info peer
[NUM_UDP_PEERS
];
2118 int ss
, i
, n_recv
, n_sent
;
2120 memset (buf
,0,sizeof(buf
));
2121 for ( i
= NUM_UDP_PEERS
- 1; i
>= 0; i
-- ) {
2122 ok ( ( peer
[i
].s
= socket ( AF_INET
, SOCK_DGRAM
, 0 ) ) != INVALID_SOCKET
, "UDP: socket failed\n" );
2124 peer
[i
].addr
.sin_family
= AF_INET
;
2125 peer
[i
].addr
.sin_addr
.s_addr
= inet_addr ( SERVERIP
);
2128 peer
[i
].addr
.sin_port
= htons ( SERVERPORT
);
2130 peer
[i
].addr
.sin_port
= htons ( 0 );
2133 do_bind ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, sizeof( peer
[i
].addr
) );
2135 /* test getsockname() to get peer's port */
2136 ss
= sizeof ( peer
[i
].addr
);
2137 ok ( getsockname ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, &ss
) != SOCKET_ERROR
, "UDP: could not getsockname()\n" );
2138 ok ( peer
[i
].addr
.sin_port
!= htons ( 0 ), "UDP: bind() did not associate port\n" );
2141 /* test getsockname() */
2142 ok ( peer
[0].addr
.sin_port
== htons ( SERVERPORT
), "UDP: getsockname returned incorrect peer port\n" );
2144 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
2145 /* send client's ip */
2146 memcpy( buf
, &peer
[i
].addr
.sin_port
, sizeof(peer
[i
].addr
.sin_port
) );
2147 n_sent
= sendto ( peer
[i
].s
, buf
, sizeof(buf
), 0, (struct sockaddr
*) &peer
[0].addr
, sizeof(peer
[0].addr
) );
2148 ok ( n_sent
== sizeof(buf
), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent
);
2151 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
2152 n_recv
= recvfrom ( peer
[0].s
, buf
, sizeof(buf
), 0,(struct sockaddr
*) &peer
[0].peer
, &ss
);
2153 ok ( n_recv
== sizeof(buf
), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv
);
2154 ok ( memcmp ( &peer
[0].peer
.sin_port
, buf
, sizeof(peer
[0].addr
.sin_port
) ) == 0, "UDP: port numbers do not match\n" );
2158 static void test_WSASocket(void)
2160 SOCKET sock
= INVALID_SOCKET
;
2161 WSAPROTOCOL_INFOA
*pi
;
2162 int wsaproviders
[] = {IPPROTO_TCP
, IPPROTO_IP
};
2163 int autoprotocols
[] = {IPPROTO_TCP
, IPPROTO_UDP
};
2164 int items
, err
, size
, socktype
, i
, j
;
2169 int family
, type
, protocol
;
2171 int ret_family
, ret_type
, ret_protocol
;
2176 {0xdead, SOCK_STREAM
, IPPROTO_TCP
, WSAEAFNOSUPPORT
},
2177 {-1, SOCK_STREAM
, IPPROTO_TCP
, WSAEAFNOSUPPORT
},
2178 {AF_INET
, 0xdead, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
2179 {AF_INET
, -1, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
2180 {AF_INET
, SOCK_STREAM
, 0xdead, WSAEPROTONOSUPPORT
},
2181 {AF_INET
, SOCK_STREAM
, -1, WSAEPROTONOSUPPORT
},
2182 {0xdead, 0xdead, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
2183 {0xdead, SOCK_STREAM
, 0xdead, WSAEAFNOSUPPORT
},
2184 {AF_INET
, 0xdead, 0xdead, WSAESOCKTNOSUPPORT
},
2185 {0xdead, SOCK_STREAM
, IPPROTO_UDP
, WSAEAFNOSUPPORT
},
2188 {AF_INET
, SOCK_STREAM
, 0, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
2189 {AF_INET
, SOCK_DGRAM
, 0, 0, AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
2190 {AF_INET
, 0xdead, 0, WSAESOCKTNOSUPPORT
},
2191 {AF_INET
, 0, IPPROTO_TCP
, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
2192 {AF_INET
, 0, IPPROTO_UDP
, 0, AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
2193 {AF_INET
, 0, 0xdead, WSAEPROTONOSUPPORT
},
2194 {AF_INET
, 0, 0, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
2195 {AF_INET
, SOCK_STREAM
, IPPROTO_UDP
, WSAEPROTONOSUPPORT
},
2196 {AF_INET
, SOCK_DGRAM
, IPPROTO_TCP
, WSAEPROTONOSUPPORT
},
2199 {AF_UNSPEC
, SOCK_STREAM
, IPPROTO_TCP
, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
2200 {AF_UNSPEC
, SOCK_STREAM
, 0xdead, WSAEPROTONOSUPPORT
},
2201 {AF_UNSPEC
, 0xdead, IPPROTO_UDP
, WSAESOCKTNOSUPPORT
},
2202 {AF_UNSPEC
, SOCK_STREAM
, 0, WSAEINVAL
},
2203 {AF_UNSPEC
, SOCK_DGRAM
, 0, WSAEINVAL
},
2204 {AF_UNSPEC
, 0xdead, 0, WSAEINVAL
},
2205 {AF_UNSPEC
, 0, IPPROTO_TCP
, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
2206 {AF_UNSPEC
, 0, IPPROTO_UDP
, 0, AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
2207 {AF_UNSPEC
, 0, 0xdead, WSAEPROTONOSUPPORT
},
2208 {AF_UNSPEC
, 0, 0, WSAEINVAL
},
2211 for (i
= 0; i
< ARRAY_SIZE(tests
); ++i
)
2213 SetLastError( 0xdeadbeef );
2214 sock
= WSASocketA( tests
[i
].family
, tests
[i
].type
, tests
[i
].protocol
, NULL
, 0, 0 );
2215 todo_wine_if (!tests
[i
].error
|| i
== 7)
2216 ok(WSAGetLastError() == tests
[i
].error
, "Test %u: got wrong error %u\n", i
, WSAGetLastError());
2219 ok(sock
== INVALID_SOCKET
, "Test %u: expected failure\n", i
);
2223 WSAPROTOCOL_INFOA info
;
2225 ok(sock
!= INVALID_SOCKET
, "Text %u: expected success\n", i
);
2227 size
= sizeof(info
);
2228 err
= getsockopt( sock
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *)&info
, &size
);
2229 ok(!err
, "Test %u: getsockopt failed, error %u\n", i
, WSAGetLastError());
2230 ok(info
.iAddressFamily
== tests
[i
].ret_family
, "Test %u: got wrong family %d\n", i
, info
.iAddressFamily
);
2231 ok(info
.iSocketType
== tests
[i
].ret_type
, "Test %u: got wrong type %d\n", i
, info
.iSocketType
);
2232 ok(info
.iProtocol
== tests
[i
].ret_protocol
, "Test %u: got wrong protocol %d\n", i
, info
.iProtocol
);
2234 closesocket( sock
);
2238 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
2239 * to avoid a crash on win98.
2242 items
= WSAEnumProtocolsA(wsaproviders
, NULL
, &pi_size
);
2243 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
2245 err
= WSAGetLastError();
2246 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2249 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
2250 ok(pi
!= NULL
, "Failed to allocate memory\n");
2252 items
= WSAEnumProtocolsA(wsaproviders
, pi
, &pi_size
);
2253 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
2257 skip("No protocols enumerated.\n");
2258 HeapFree(GetProcessHeap(), 0, pi
);
2262 sock
= WSASocketA(FROM_PROTOCOL_INFO
, FROM_PROTOCOL_INFO
,
2263 FROM_PROTOCOL_INFO
, &pi
[0], 0, 0);
2264 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2268 /* find what parameters are used first: plain parameters or protocol info struct */
2269 pi
[0].iProtocol
= -1;
2270 pi
[0].iSocketType
= -1;
2271 pi
[0].iAddressFamily
= -1;
2272 ok(WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0) == INVALID_SOCKET
,
2273 "WSASocketA should have failed\n");
2274 err
= WSAGetLastError();
2275 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
2277 pi
[0].iProtocol
= 0;
2278 pi
[0].iSocketType
= 0;
2279 pi
[0].iAddressFamily
= 0;
2280 sock
= WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0);
2281 if(sock
!= INVALID_SOCKET
)
2283 win_skip("must work only in OS <= 2003\n");
2288 err
= WSAGetLastError();
2289 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
2292 pi
[0].iProtocol
= IPPROTO_UDP
;
2293 pi
[0].iSocketType
= SOCK_DGRAM
;
2294 pi
[0].iAddressFamily
= AF_INET
;
2295 sock
= WSASocketA(0, 0, 0, &pi
[0], 0, 0);
2296 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2299 size
= sizeof(socktype
);
2301 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2302 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2303 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2304 SOCK_DGRAM
, socktype
);
2306 socktype
= SOCK_STREAM
;
2307 WSASetLastError(0xdeadbeef);
2308 err
= setsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *)&socktype
, sizeof(socktype
));
2309 ok(err
== -1, "expected failure\n");
2310 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
2312 socktype
= SOCK_DGRAM
;
2313 WSASetLastError(0xdeadbeef);
2314 err
= setsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *)&socktype
, sizeof(socktype
));
2315 ok(err
== -1, "expected failure\n");
2316 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
2320 sock
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, &pi
[0], 0, 0);
2321 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2324 size
= sizeof(socktype
);
2326 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2327 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2328 ok(socktype
== SOCK_STREAM
, "Wrong socket type, expected %d received %d\n",
2329 SOCK_STREAM
, socktype
);
2331 socktype
= SOCK_STREAM
;
2332 WSASetLastError(0xdeadbeef);
2333 err
= setsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *)&socktype
, sizeof(socktype
));
2334 ok(err
== -1, "expected failure\n");
2335 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
2337 socktype
= SOCK_DGRAM
;
2338 WSASetLastError(0xdeadbeef);
2339 err
= setsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *)&socktype
, sizeof(socktype
));
2340 ok(err
== -1, "expected failure\n");
2341 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
2345 HeapFree(GetProcessHeap(), 0, pi
);
2348 items
= WSAEnumProtocolsA(NULL
, NULL
, &pi_size
);
2349 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
2351 err
= WSAGetLastError();
2352 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2355 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
2356 ok(pi
!= NULL
, "Failed to allocate memory\n");
2358 items
= WSAEnumProtocolsA(NULL
, pi
, &pi_size
);
2359 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
2362 /* when no protocol and socket type are specified the first entry
2363 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
2365 sock
= WSASocketA(AF_INET
, 0, 0, NULL
, 0, 0);
2366 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2369 size
= sizeof(socktype
);
2371 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2372 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2373 for(i
= 0; i
< items
; i
++)
2375 if(pi
[i
].dwProviderFlags
& PFL_MATCHES_PROTOCOL_ZERO
)
2377 ok(socktype
== pi
[i
].iSocketType
, "Wrong socket type, expected %d received %d\n",
2378 pi
[i
].iSocketType
, socktype
);
2382 ok(i
!= items
, "Creating a socket without protocol and socket type didn't work\n");
2385 /* when no socket type is specified the first entry from WSAEnumProtocols
2386 * that matches the protocol is returned */
2387 for (i
= 0; i
< ARRAY_SIZE(autoprotocols
); i
++)
2389 sock
= WSASocketA(0, 0, autoprotocols
[i
], NULL
, 0, 0);
2390 ok(sock
!= INVALID_SOCKET
, "Failed to create socket for protocol %d, received %d\n",
2391 autoprotocols
[i
], WSAGetLastError());
2393 size
= sizeof(socktype
);
2395 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2396 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2398 for (err
= 1, j
= 0; j
< items
; j
++)
2400 if (pi
[j
].iProtocol
== autoprotocols
[i
])
2402 ok(pi
[j
].iSocketType
== socktype
, "expected %d, got %d\n", socktype
, pi
[j
].iSocketType
);
2407 ok(!err
, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols
[i
]);
2412 HeapFree(GetProcessHeap(), 0, pi
);
2414 SetLastError(0xdeadbeef);
2415 /* starting on vista the socket function returns error during the socket
2416 creation and no longer in the socket operations (sendto, readfrom) */
2417 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_ICMP
, NULL
, 0, 0);
2418 if (sock
== INVALID_SOCKET
)
2420 err
= WSAGetLastError();
2421 ok(err
== WSAEACCES
, "Expected 10013, received %d\n", err
);
2422 skip("SOCK_RAW is not supported\n");
2426 size
= sizeof(socktype
);
2428 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2429 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2430 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2431 SOCK_RAW
, socktype
);
2434 sock
= WSASocketA(0, 0, IPPROTO_RAW
, NULL
, 0, 0);
2435 if (sock
!= INVALID_SOCKET
)
2438 size
= sizeof(socktype
);
2440 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2441 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2442 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2443 SOCK_RAW
, socktype
);
2447 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_TCP
, NULL
, 0, 0);
2448 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2450 size
= sizeof(socktype
);
2452 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2453 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2454 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2455 SOCK_RAW
, socktype
);
2458 else if (WSAGetLastError() == WSAEACCES
)
2459 skip("SOCK_RAW is not available\n");
2461 ok(0, "Failed to create socket: %d\n", WSAGetLastError());
2465 /* IPX socket tests */
2467 SetLastError(0xdeadbeef);
2468 sock
= WSASocketA(AF_IPX
, SOCK_DGRAM
, NSPROTO_IPX
, NULL
, 0, 0);
2469 if (sock
== INVALID_SOCKET
)
2471 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "got error %u\n", WSAGetLastError());
2472 skip("IPX is not supported\n");
2476 WSAPROTOCOL_INFOA info
;
2479 sock
= WSASocketA(0, 0, NSPROTO_IPX
, NULL
, 0, 0);
2480 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2483 size
= sizeof(socktype
);
2485 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2486 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2487 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2488 SOCK_DGRAM
, socktype
);
2490 /* check socket family, type and protocol */
2491 size
= sizeof(WSAPROTOCOL_INFOA
);
2492 err
= getsockopt(sock
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &info
, &size
);
2493 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2494 ok(info
.iProtocol
== NSPROTO_IPX
, "expected protocol %d, received %d\n",
2495 NSPROTO_IPX
, info
.iProtocol
);
2496 ok(info
.iAddressFamily
== AF_IPX
, "expected family %d, received %d\n",
2497 AF_IPX
, info
.iProtocol
);
2498 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
2499 SOCK_DGRAM
, info
.iSocketType
);
2502 /* SOCK_STREAM does not support NSPROTO_IPX */
2503 SetLastError(0xdeadbeef);
2504 ok(WSASocketA(AF_IPX
, SOCK_STREAM
, NSPROTO_IPX
, NULL
, 0, 0) == INVALID_SOCKET
,
2505 "WSASocketA should have failed\n");
2506 err
= WSAGetLastError();
2507 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2509 /* test extended IPX support - that is adding any number between 0 and 255
2510 * to the IPX protocol value will make it be used as IPX packet type */
2511 for(i
= 0;i
<= 255;i
+= 17)
2513 SetLastError(0xdeadbeef);
2514 sock
= WSASocketA(0, 0, NSPROTO_IPX
+ i
, NULL
, 0, 0);
2515 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2520 err
= getsockopt(sock
, NSPROTO_IPX
, IPX_PTYPE
, (char *) &socktype
, &size
);
2521 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2522 ok(socktype
== i
, "Wrong IPX packet type, expected %d received %d\n",
2530 static void test_WSADuplicateSocket(void)
2532 SOCKET source
, dupsock
;
2533 WSAPROTOCOL_INFOA info
;
2535 struct sockaddr_in addr
;
2536 int socktype
, size
, addrsize
, ret
;
2537 char teststr
[] = "TEST", buffer
[16];
2539 source
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
2540 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2542 /* test invalid parameters */
2543 SetLastError(0xdeadbeef);
2544 ok(WSADuplicateSocketA(0, 0, NULL
), "WSADuplicateSocketA should have failed\n");
2545 err
= WSAGetLastError();
2546 ok(err
== WSAENOTSOCK
, "expected 10038, received %d\n", err
);
2548 SetLastError(0xdeadbeef);
2549 ok(WSADuplicateSocketA(source
, 0, NULL
),
2550 "WSADuplicateSocketA should have failed\n");
2551 err
= WSAGetLastError();
2552 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2554 SetLastError(0xdeadbeef);
2555 ok(WSADuplicateSocketA(source
, ~0, &info
),
2556 "WSADuplicateSocketA should have failed\n");
2557 err
= WSAGetLastError();
2558 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2560 SetLastError(0xdeadbeef);
2561 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info
),
2562 "WSADuplicateSocketA should have failed\n");
2563 err
= WSAGetLastError();
2564 ok(err
== WSAENOTSOCK
, "expected 10038, received %d\n", err
);
2566 SetLastError(0xdeadbeef);
2567 ok(WSADuplicateSocketA(source
, GetCurrentProcessId(), NULL
),
2568 "WSADuplicateSocketA should have failed\n");
2569 err
= WSAGetLastError();
2570 ok(err
== WSAEFAULT
, "expected 10014, received %d\n", err
);
2572 /* test returned structure */
2573 memset(&info
, 0, sizeof(info
));
2574 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2575 "WSADuplicateSocketA should have worked\n");
2577 ok(info
.iProtocol
== IPPROTO_TCP
, "expected protocol %d, received %d\n",
2578 IPPROTO_TCP
, info
.iProtocol
);
2579 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
2580 AF_INET
, info
.iProtocol
);
2581 ok(info
.iSocketType
== SOCK_STREAM
, "expected type %d, received %d\n",
2582 SOCK_STREAM
, info
.iSocketType
);
2584 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2585 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2587 closesocket(dupsock
);
2588 closesocket(source
);
2590 /* create a socket, bind it, duplicate it then send data on source and
2591 * receive in the duplicated socket */
2592 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
2593 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2595 memset(&info
, 0, sizeof(info
));
2596 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2597 "WSADuplicateSocketA should have worked\n");
2599 ok(info
.iProtocol
== IPPROTO_UDP
, "expected protocol %d, received %d\n",
2600 IPPROTO_UDP
, info
.iProtocol
);
2601 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
2602 AF_INET
, info
.iProtocol
);
2603 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
2604 SOCK_DGRAM
, info
.iSocketType
);
2606 memset(&addr
, 0, sizeof(addr
));
2607 addr
.sin_family
= AF_INET
;
2608 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2609 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
2610 "bind should have worked\n");
2612 /* read address to find out the port number to be used in sendto */
2613 memset(&addr
, 0, sizeof(addr
));
2614 addrsize
= sizeof(addr
);
2615 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
2616 "getsockname should have worked\n");
2617 ok(addr
.sin_port
, "socket port should be != 0\n");
2619 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2620 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2623 ret
= getsockopt(dupsock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2624 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
2625 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2626 SOCK_DGRAM
, socktype
);
2628 set_blocking(source
, TRUE
);
2630 /* send data on source socket */
2631 addrsize
= sizeof(addr
);
2632 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
2633 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2635 /* receive on duplicated socket */
2636 addrsize
= sizeof(addr
);
2637 memset(buffer
, 0, sizeof(buffer
));
2638 size
= recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
);
2639 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2640 buffer
[sizeof(teststr
) - 1] = 0;
2641 ok(!strcmp(buffer
, teststr
), "expected '%s', received '%s'\n", teststr
, buffer
);
2643 closesocket(dupsock
);
2644 closesocket(source
);
2646 /* show that the source socket need to be bound before the duplicated
2647 * socket is created */
2648 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
2649 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2651 memset(&info
, 0, sizeof(info
));
2652 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2653 "WSADuplicateSocketA should have worked\n");
2655 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2656 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2658 memset(&addr
, 0, sizeof(addr
));
2659 addr
.sin_family
= AF_INET
;
2660 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2661 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
2662 "bind should have worked\n");
2664 /* read address to find out the port number to be used in sendto */
2665 memset(&addr
, 0, sizeof(addr
));
2666 addrsize
= sizeof(addr
);
2667 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
2668 "getsockname should have worked\n");
2669 ok(addr
.sin_port
, "socket port should be != 0\n");
2671 set_blocking(source
, TRUE
);
2673 addrsize
= sizeof(addr
);
2674 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
2675 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2677 SetLastError(0xdeadbeef);
2678 addrsize
= sizeof(addr
);
2679 memset(buffer
, 0, sizeof(buffer
));
2681 ok(recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
) == -1,
2682 "recvfrom should have failed\n");
2683 err
= WSAGetLastError();
2684 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2687 closesocket(dupsock
);
2688 closesocket(source
);
2691 static void test_WSAEnumNetworkEvents(void)
2694 int sock_type
[] = {SOCK_STREAM
, SOCK_DGRAM
, SOCK_STREAM
}, i
, j
, k
, l
;
2695 struct sockaddr_in address
;
2697 WSANETWORKEVENTS net_events
;
2699 memset(&address
, 0, sizeof(address
));
2700 address
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
2701 address
.sin_family
= AF_INET
;
2703 /* This test follows the steps from bugs 10204 and 24946 */
2704 for (l
= 0; l
< 2; l
++)
2706 for (i
= 0; i
< ARRAY_SIZE(sock_type
); i
++)
2709 tcp_socketpair(&s
, &s2
);
2712 s
= socket(AF_INET
, sock_type
[i
], 0);
2713 ok (s
!= SOCKET_ERROR
, "Test[%d]: failed to create socket\n", i
);
2714 ok (!bind(s
, (struct sockaddr
*) &address
, sizeof(address
)), "Test[%d]: bind failed\n", i
);
2716 event
= WSACreateEvent();
2717 ok (event
!= NULL
, "Test[%d]: failed to create event\n", i
);
2718 for (j
= 0; j
< 5; j
++) /* Repeat sometimes and the result must be the same */
2720 /* When the TCP socket is not connected NO events will be returned.
2721 * When connected and no data pending it will get the write event.
2722 * UDP sockets don't have connections so as soon as they are bound
2723 * they can read/write data. Since nobody is sendind us data only
2724 * the write event will be returned and ONLY once.
2726 ok (!WSAEventSelect(s
, event
, FD_READ
| FD_WRITE
), "Test[%d]: WSAEventSelect failed\n", i
);
2727 memset(&net_events
, 0xAB, sizeof(net_events
));
2728 ok (!WSAEnumNetworkEvents(s
, l
== 0 ? event
: NULL
, &net_events
),
2729 "Test[%d]: WSAEnumNetworkEvents failed\n", i
);
2730 if (i
>= 1 && j
== 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
2732 ok (net_events
.lNetworkEvents
== FD_WRITE
, "Test[%d]: expected 2, got %d\n",
2733 i
, net_events
.lNetworkEvents
);
2737 ok (net_events
.lNetworkEvents
== 0, "Test[%d]: expected 0, got %d\n",
2738 i
, net_events
.lNetworkEvents
);
2740 for (k
= 0; k
< FD_MAX_EVENTS
; k
++)
2742 if (net_events
.lNetworkEvents
& (1 << k
))
2744 ok (net_events
.iErrorCode
[k
] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
2745 i
, k
, net_events
.iErrorCode
[k
]);
2749 /* Bits that are not set in lNetworkEvents MUST not be changed */
2750 ok (net_events
.iErrorCode
[k
] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
2751 i
, k
, net_events
.iErrorCode
[k
]);
2756 WSACloseEvent(event
);
2757 if (i
== 2) closesocket(s2
);
2762 static DWORD WINAPI
SelectReadThread(void *param
)
2764 select_thread_params
*par
= param
;
2767 struct sockaddr_in addr
;
2768 struct timeval select_timeout
;
2771 FD_SET(par
->s
, &readfds
);
2772 select_timeout
.tv_sec
=5;
2773 select_timeout
.tv_usec
=0;
2774 addr
.sin_family
= AF_INET
;
2775 addr
.sin_addr
.s_addr
= inet_addr(SERVERIP
);
2776 addr
.sin_port
= htons(SERVERPORT
);
2778 do_bind(par
->s
, (struct sockaddr
*)&addr
, sizeof(addr
));
2779 wsa_ok(listen(par
->s
, SOMAXCONN
), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
2781 SetEvent(server_ready
);
2782 ret
= select(par
->s
+1, &readfds
, NULL
, NULL
, &select_timeout
);
2783 par
->ReadKilled
= (ret
== 1);
2788 static DWORD WINAPI
SelectCloseThread(void *param
)
2790 SOCKET s
= *(SOCKET
*)param
;
2796 static void test_errors(void)
2799 SOCKADDR_IN SockAddr
;
2802 WSASetLastError(NO_ERROR
);
2803 sock
= socket(PF_INET
, SOCK_STREAM
, 0);
2804 ok( (sock
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2805 memset(&SockAddr
, 0, sizeof(SockAddr
));
2806 SockAddr
.sin_family
= AF_INET
;
2807 SockAddr
.sin_port
= htons(6924);
2808 SockAddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2810 ret
= connect(sock
, (PSOCKADDR
)&SockAddr
, sizeof(SockAddr
));
2811 ok( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got: %d\n", ret
);
2812 if (ret
== SOCKET_ERROR
)
2814 err
= WSAGetLastError();
2815 ok( (err
== WSAECONNREFUSED
), "expected WSAECONNREFUSED, got: %d\n", err
);
2820 fd_set set
= {1, {sock
}};
2823 timeval
.tv_usec
= 50000;
2825 ret
= select(1, NULL
, &set
, NULL
, &timeval
);
2826 ok( (ret
== 0), "expected 0 (timeout), got: %d\n", ret
);
2829 ret
= closesocket(sock
);
2830 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
2833 static void test_listen(void)
2836 int ret
, acceptc
, olen
= sizeof(acceptc
);
2837 struct sockaddr_in address
;
2839 memset(&address
, 0, sizeof(address
));
2840 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2841 address
.sin_family
= AF_INET
;
2842 address
.sin_port
= htons(SERVERPORT
);
2844 /* invalid socket tests */
2845 SetLastError(0xdeadbeef);
2846 ok ((listen(0, 0) == SOCKET_ERROR
), "listen did not fail\n");
2847 ret
= WSAGetLastError();
2848 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
2850 SetLastError(0xdeadbeef);
2851 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR
), "listen did not fail\n");
2852 ret
= WSAGetLastError();
2853 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
2856 fdA
= socket(AF_INET
, SOCK_STREAM
, 0);
2857 ok ((fdA
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2859 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
2860 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2862 SetLastError(0xdeadbeef);
2863 ok ((listen(fdA
, -2) == SOCKET_ERROR
), "listen did not fail\n");
2864 ret
= WSAGetLastError();
2865 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
2867 SetLastError(0xdeadbeef);
2868 ok ((listen(fdA
, 1) == SOCKET_ERROR
), "listen did not fail\n");
2869 ret
= WSAGetLastError();
2870 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
2872 SetLastError(0xdeadbeef);
2873 ok ((listen(fdA
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
2874 ret
= WSAGetLastError();
2875 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
2877 ok (!bind(fdA
, (struct sockaddr
*) &address
, sizeof(address
)), "bind failed\n");
2879 SetLastError(0xdeadbeef);
2880 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
2881 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
2884 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
2885 ok (!ret
, "getsockopt failed\n");
2886 ok (acceptc
== 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc
);
2889 WSASetLastError(0xdeadbeef);
2890 ret
= setsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char *)&acceptc
, sizeof(acceptc
));
2891 ok(ret
== -1, "expected failure\n");
2892 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
2895 WSASetLastError(0xdeadbeef);
2896 ret
= setsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char *)&acceptc
, sizeof(acceptc
));
2897 ok(ret
== -1, "expected failure\n");
2898 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
2900 ok (!listen(fdA
, 0), "listen failed\n");
2901 ok (!listen(fdA
, SOMAXCONN
), "double listen failed\n");
2904 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
2905 ok (!ret
, "getsockopt failed\n");
2906 ok (acceptc
== 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc
);
2909 WSASetLastError(0xdeadbeef);
2910 ret
= setsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char *)&acceptc
, sizeof(acceptc
));
2911 ok(ret
== -1, "expected failure\n");
2912 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
2915 WSASetLastError(0xdeadbeef);
2916 ret
= setsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char *)&acceptc
, sizeof(acceptc
));
2917 ok(ret
== -1, "expected failure\n");
2918 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
2920 SetLastError(0xdeadbeef);
2921 ok ((listen(fdB
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
2922 ret
= WSAGetLastError();
2923 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
2925 ret
= closesocket(fdB
);
2926 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
2928 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
2929 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2931 SetLastError(0xdeadbeef);
2932 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
2933 ret
= WSAGetLastError();
2934 ok (ret
== WSAEADDRINUSE
, "expected 10048, received %d\n", ret
);
2936 ret
= closesocket(fdA
);
2937 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
2938 ret
= closesocket(fdB
);
2939 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
2942 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
2943 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
2944 static void test_select(void)
2946 static char tmp_buf
[1024];
2948 SOCKET fdListen
, fdRead
, fdWrite
;
2949 fd_set readfds
, writefds
, exceptfds
;
2953 struct timeval select_timeout
;
2954 struct sockaddr_in address
;
2955 select_thread_params thread_params
;
2956 HANDLE thread_handle
;
2959 fdRead
= socket(AF_INET
, SOCK_STREAM
, 0);
2960 ok( (fdRead
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2961 fdWrite
= socket(AF_INET
, SOCK_STREAM
, 0);
2962 ok( (fdWrite
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2965 if (fdWrite
> maxfd
)
2970 FD_SET_ALL(fdWrite
);
2971 select_timeout
.tv_sec
=0;
2972 select_timeout
.tv_usec
=0;
2974 ticks
= GetTickCount();
2975 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2976 ticks
= GetTickCount() - ticks
;
2977 ok(ret
== 0, "select should not return any socket handles\n");
2978 ok(ticks
< 10, "select was blocking for %u ms, expected < 10 ms\n", ticks
);
2979 ok(!FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
2980 ok(!FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
2981 ok(!FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
2982 ok(!FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
2986 FD_SET_ALL(fdWrite
);
2987 select_timeout
.tv_sec
=0;
2988 select_timeout
.tv_usec
=500;
2990 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2991 ok(ret
== 0, "select should not return any socket handles\n");
2992 ok(!FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
2993 ok(!FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
2994 ok(!FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
2995 ok(!FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
2997 ok ((listen(fdWrite
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
2998 ret
= closesocket(fdWrite
);
2999 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
3001 thread_params
.s
= fdRead
;
3002 thread_params
.ReadKilled
= FALSE
;
3003 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
3004 thread_handle
= CreateThread (NULL
, 0, SelectReadThread
, &thread_params
, 0, &id
);
3005 ok ( (thread_handle
!= NULL
), "CreateThread failed unexpectedly: %d\n", GetLastError());
3007 WaitForSingleObject (server_ready
, INFINITE
);
3009 ret
= closesocket(fdRead
);
3010 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
3012 WaitForSingleObject (thread_handle
, 1000);
3013 ok ( thread_params
.ReadKilled
, "closesocket did not wake up select\n");
3014 ret
= recv(fdRead
, &buffer
, 1, MSG_PEEK
);
3015 ok( (ret
== -1), "peek at closed socket expected -1 got %d\n", ret
);
3017 /* Test selecting invalid handles */
3021 ret
= select(maxfd
+1, 0, 0, 0, &select_timeout
);
3022 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3023 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3026 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3027 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3028 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3030 FD_SET(INVALID_SOCKET
, &readfds
);
3032 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3033 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3034 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3035 ok ( !FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
3038 FD_SET(INVALID_SOCKET
, &writefds
);
3040 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3041 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3042 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3043 ok ( !FD_ISSET(fdRead
, &writefds
), "FD should not be set\n");
3046 FD_SET(INVALID_SOCKET
, &exceptfds
);
3048 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3049 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3050 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3051 ok ( !FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
3053 tcp_socketpair(&fdRead
, &fdWrite
);
3055 if(fdWrite
> maxfd
) maxfd
= fdWrite
;
3058 FD_SET(fdRead
, &readfds
);
3059 ret
= select(fdRead
+1, &readfds
, NULL
, NULL
, &select_timeout
);
3060 ok(!ret
, "select returned %d\n", ret
);
3063 FD_SET(fdWrite
, &writefds
);
3064 ret
= select(fdWrite
+1, NULL
, &writefds
, NULL
, &select_timeout
);
3065 ok(ret
== 1, "select returned %d\n", ret
);
3066 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
3068 /* tests for overlapping fd_set pointers */
3070 FD_SET(fdWrite
, &readfds
);
3071 ret
= select(fdWrite
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3072 ok(ret
== 1, "select returned %d\n", ret
);
3073 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3076 FD_SET(fdWrite
, &readfds
);
3077 FD_SET(fdRead
, &readfds
);
3078 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3079 ok(ret
== 2, "select returned %d\n", ret
);
3080 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3081 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3083 ok(send(fdWrite
, "test", 4, 0) == 4, "failed to send data\n");
3085 FD_SET(fdRead
, &readfds
);
3086 ret
= select(fdRead
+1, &readfds
, NULL
, NULL
, &select_timeout
);
3087 ok(ret
== 1, "select returned %d\n", ret
);
3088 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3091 FD_SET(fdWrite
, &readfds
);
3092 FD_SET(fdRead
, &readfds
);
3093 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3094 ok(ret
== 2, "select returned %d\n", ret
);
3095 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3096 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3100 FD_SET(fdWrite
, &writefds
);
3101 ret
= select(fdWrite
+1, NULL
, &writefds
, NULL
, &select_timeout
);
3103 ok(send(fdWrite
, tmp_buf
, sizeof(tmp_buf
), 0) > 0, "failed to send data\n");
3106 FD_SET(fdWrite
, &readfds
);
3107 FD_SET(fdRead
, &readfds
);
3108 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3109 ok(ret
== 1, "select returned %d\n", ret
);
3110 ok(!FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is in the set\n");
3111 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3113 ok(send(fdRead
, "test", 4, 0) == 4, "failed to send data\n");
3116 FD_SET(fdWrite
, &readfds
);
3117 FD_SET(fdRead
, &readfds
);
3118 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3119 ok(ret
== 2, "select returned %d\n", ret
);
3120 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3121 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3123 closesocket(fdRead
);
3124 closesocket(fdWrite
);
3126 /* select() works in 3 distinct states:
3127 * - to check if a connection attempt ended with success or error;
3128 * - to check if a pending connection is waiting for acceptance;
3129 * - to check for data to read, availability for write and OOB data
3131 * The tests below ensure that all conditions are tested.
3133 memset(&address
, 0, sizeof(address
));
3134 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3135 address
.sin_family
= AF_INET
;
3136 len
= sizeof(address
);
3137 fdListen
= setup_server_socket(&address
, &len
);
3138 select_timeout
.tv_sec
= 1;
3139 select_timeout
.tv_usec
= 250000;
3141 /* When no events are pending select returns 0 with no error */
3143 FD_SET_ALL(fdListen
);
3144 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3145 ok(ret
== 0, "expected 0, got %d\n", ret
);
3147 /* When a socket is attempting to connect the listening socket receives the read descriptor */
3148 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
3150 FD_SET_ALL(fdListen
);
3151 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3152 ok(ret
== 1, "expected 1, got %d\n", ret
);
3153 ok(FD_ISSET(fdListen
, &readfds
), "fdListen socket is not in the set\n");
3154 len
= sizeof(address
);
3155 fdRead
= accept(fdListen
, (struct sockaddr
*) &address
, &len
);
3156 ok(fdRead
!= INVALID_SOCKET
, "expected a valid socket\n");
3158 /* The connector is signaled through the write descriptor */
3160 FD_SET_ALL(fdListen
);
3162 FD_SET_ALL(fdWrite
);
3163 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3164 ok(ret
== 2, "expected 2, got %d\n", ret
);
3165 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
3166 ok(FD_ISSET(fdRead
, &writefds
), "fdRead socket is not in the set\n");
3169 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
3170 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
3171 ok(id
== 0, "expected 0, got %d\n", id
);
3173 /* When data is received the receiver gets the read descriptor */
3174 ret
= send(fdWrite
, "1234", 4, 0);
3175 ok(ret
== 4, "expected 4, got %d\n", ret
);
3177 FD_SET_ALL(fdListen
);
3178 FD_SET(fdRead
, &readfds
);
3179 FD_SET(fdRead
, &exceptfds
);
3180 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3181 ok(ret
== 1, "expected 1, got %d\n", ret
);
3182 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3183 ok(!FD_ISSET(fdRead
, &exceptfds
), "fdRead socket is in the set\n");
3186 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3187 ok(ret
== 2, "expected 1, got %d\n", ret
);
3188 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3189 ok(FD_ISSET(fdRead
, &writefds
), "fdRead socket is not in the set\n");
3190 ok(!FD_ISSET(fdRead
, &exceptfds
), "fdRead socket is in the set\n");
3191 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
3192 ok(ret
== 4, "expected 4, got %d\n", ret
);
3193 ok(!strcmp(tmp_buf
, "1234"), "data received differs from sent\n");
3195 /* When OOB data is received the socket is set in the except descriptor */
3196 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
3197 ok(ret
== 1, "expected 1, got %d\n", ret
);
3199 FD_SET_ALL(fdListen
);
3200 FD_SET(fdRead
, &readfds
);
3201 FD_SET(fdRead
, &exceptfds
);
3202 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3203 ok(ret
== 1, "expected 1, got %d\n", ret
);
3204 ok(FD_ISSET(fdRead
, &exceptfds
), "fdRead socket is not in the set\n");
3206 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
3207 ok(ret
== 1, "expected 1, got %d\n", ret
);
3208 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
3210 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
3212 ret
= setsockopt(fdRead
, SOL_SOCKET
, SO_OOBINLINE
, (char*) &ret
, sizeof(ret
));
3213 ok(ret
== 0, "expected 0, got %d\n", ret
);
3214 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
3215 ok(ret
== 1, "expected 1, got %d\n", ret
);
3217 FD_SET_ALL(fdListen
);
3218 FD_SET(fdRead
, &readfds
);
3219 FD_SET(fdRead
, &exceptfds
);
3220 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3221 ok(ret
== 1, "expected 1, got %d\n", ret
);
3222 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3224 SetLastError(0xdeadbeef);
3225 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
3226 ok(ret
== SOCKET_ERROR
, "expected SOCKET_ERROR, got %d\n", ret
);
3227 ok(GetLastError() == WSAEINVAL
, "expected 10022, got %d\n", GetLastError());
3228 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
3229 ok(ret
== 1, "expected 1, got %d\n", ret
);
3230 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
3232 /* When the connection is closed the socket is set in the read descriptor */
3233 ret
= closesocket(fdRead
);
3234 ok(ret
== 0, "expected 0, got %d\n", ret
);
3236 FD_SET_ALL(fdListen
);
3237 FD_SET(fdWrite
, &readfds
);
3238 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3239 ok(ret
== 1, "expected 1, got %d\n", ret
);
3240 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3241 ret
= recv(fdWrite
, tmp_buf
, sizeof(tmp_buf
), 0);
3242 ok(ret
== 0, "expected 0, got %d\n", ret
);
3243 ret
= closesocket(fdWrite
);
3244 ok(ret
== 0, "expected 0, got %d\n", ret
);
3246 /* w10pro64 sometimes takes over 2 seconds for an error to be reported. */
3247 if (winetest_interactive
)
3249 const struct sockaddr_in invalid_addr
=
3251 .sin_family
= AF_INET
,
3252 .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
),
3256 fdWrite
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3257 set_blocking(fdWrite
, FALSE
);
3259 ret
= connect(fdWrite
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
3260 ok(ret
== -1, "got %d\n", ret
);
3261 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
3264 FD_SET(fdWrite
, &readfds
);
3265 FD_SET(fdWrite
, &writefds
);
3266 FD_SET(fdWrite
, &exceptfds
);
3267 select_timeout
.tv_sec
= 10;
3268 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3269 ok(ret
== 1, "expected 1, got %d\n", ret
);
3270 ok(FD_ISSET(fdWrite
, &exceptfds
), "fdWrite socket is not in the set\n");
3271 ok(select_timeout
.tv_usec
== 250000, "select timeout should not have changed\n");
3275 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char *)&id
, &len
);
3276 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
3277 ok(id
== WSAECONNREFUSED
, "got error %u\n", id
);
3281 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char *)&id
, &len
);
3282 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
3283 ok(id
== WSAECONNREFUSED
, "got error %u\n", id
);
3286 FD_SET(fdWrite
, &readfds
);
3287 FD_SET(fdWrite
, &writefds
);
3288 FD_SET(fdWrite
, &exceptfds
);
3289 select_timeout
.tv_sec
= 10;
3290 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3291 ok(ret
== 1, "got %d\n", ret
);
3292 ok(FD_ISSET(fdWrite
, &exceptfds
), "fdWrite socket is not in the set\n");
3294 /* Calling connect() doesn't reset the socket error, but a successful
3295 * connection does. This is kind of tricky to test, because while
3296 * Windows takes a couple seconds to actually fail the connection,
3297 * Linux will fail the connection almost immediately. */
3299 ret
= connect(fdWrite
, (const struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
3300 ok(ret
== -1, "got %d\n", ret
);
3301 todo_wine
ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
3302 if (WSAGetLastError() == WSAECONNABORTED
)
3304 ret
= connect(fdWrite
, (const struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
3305 ok(ret
== -1, "got %d\n", ret
);
3306 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
3311 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char *)&id
, &len
);
3312 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
3313 ok(id
== WSAECONNREFUSED
, "got error %u\n", id
);
3316 FD_SET(fdWrite
, &readfds
);
3317 FD_SET(fdWrite
, &writefds
);
3318 FD_SET(fdWrite
, &exceptfds
);
3319 select_timeout
.tv_sec
= 10;
3320 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3321 ok(ret
== 1, "got %d\n", ret
);
3322 ok(FD_ISSET(fdWrite
, &exceptfds
), "fdWrite socket is not in the set\n");
3324 len
= sizeof(address
);
3325 ret
= getsockname(fdListen
, (struct sockaddr
*)&address
, &len
);
3326 ok(!ret
, "got error %u\n", WSAGetLastError());
3327 ret
= connect(fdWrite
, (const struct sockaddr
*)&address
, sizeof(address
));
3328 ok(ret
== -1, "got %d\n", ret
);
3329 todo_wine
ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
3330 if (WSAGetLastError() == WSAECONNABORTED
)
3332 ret
= connect(fdWrite
, (const struct sockaddr
*)&address
, sizeof(address
));
3333 ok(ret
== -1, "got %d\n", ret
);
3334 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
3338 FD_SET(fdWrite
, &readfds
);
3339 FD_SET(fdWrite
, &writefds
);
3340 FD_SET(fdWrite
, &exceptfds
);
3341 select_timeout
.tv_sec
= 1;
3342 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3343 ok(ret
== 1, "expected 1, got %d\n", ret
);
3344 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
3348 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char *)&id
, &len
);
3349 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
3350 ok(!id
, "got error %u\n", id
);
3352 closesocket(fdWrite
);
3354 /* test polling after a (synchronous) failure */
3356 fdWrite
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3358 ret
= connect(fdWrite
, (const struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
3359 ok(ret
== -1, "got %d\n", ret
);
3360 ok(WSAGetLastError() == WSAECONNREFUSED
, "got error %u\n", WSAGetLastError());
3363 FD_SET(fdWrite
, &readfds
);
3364 FD_SET(fdWrite
, &writefds
);
3365 FD_SET(fdWrite
, &exceptfds
);
3366 select_timeout
.tv_sec
= 0;
3367 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3368 ok(ret
== 1, "expected 1, got %d\n", ret
);
3369 ok(FD_ISSET(fdWrite
, &exceptfds
), "fdWrite socket is not in the set\n");
3373 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char *)&id
, &len
);
3374 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
3375 todo_wine
ok(!id
, "got error %u\n", id
);
3377 closesocket(fdWrite
);
3380 ret
= closesocket(fdListen
);
3381 ok(ret
== 0, "expected 0, got %d\n", ret
);
3383 select_timeout
.tv_sec
= 1;
3384 select_timeout
.tv_usec
= 250000;
3386 /* Try select() on a closed socket after connection */
3387 tcp_socketpair(&fdRead
, &fdWrite
);
3388 closesocket(fdRead
);
3390 FD_SET_ALL(fdWrite
);
3392 SetLastError(0xdeadbeef);
3393 ret
= select(0, &readfds
, NULL
, &exceptfds
, &select_timeout
);
3394 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
3395 ok(GetLastError() == WSAENOTSOCK
, "got %d\n", GetLastError());
3396 /* descriptor sets are unchanged */
3397 ok(readfds
.fd_count
== 2, "expected 2, got %d\n", readfds
.fd_count
);
3398 ok(exceptfds
.fd_count
== 2, "expected 2, got %d\n", exceptfds
.fd_count
);
3399 closesocket(fdWrite
);
3401 /* Close the socket currently being selected in a thread - bug 38399 */
3402 tcp_socketpair(&fdRead
, &fdWrite
);
3403 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
3404 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
3406 FD_SET_ALL(fdWrite
);
3407 ret
= select(0, &readfds
, NULL
, &exceptfds
, &select_timeout
);
3408 ok(ret
== 1, "expected 1, got %d\n", ret
);
3409 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3410 WaitForSingleObject (thread_handle
, 1000);
3411 closesocket(fdRead
);
3412 /* test again with only the except descriptor */
3413 tcp_socketpair(&fdRead
, &fdWrite
);
3414 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
3415 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
3417 FD_SET(fdWrite
, &exceptfds
);
3418 SetLastError(0xdeadbeef);
3419 ret
= select(0, NULL
, NULL
, &exceptfds
, &select_timeout
);
3420 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
3421 ok(GetLastError() == WSAENOTSOCK
, "got %d\n", GetLastError());
3422 ok(!FD_ISSET(fdWrite
, &exceptfds
), "fdWrite socket is in the set\n");
3423 WaitForSingleObject (thread_handle
, 1000);
3424 closesocket(fdRead
);
3426 /* test UDP behavior of unbound sockets */
3427 select_timeout
.tv_sec
= 0;
3428 select_timeout
.tv_usec
= 250000;
3429 fdWrite
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
3430 ok(fdWrite
!= INVALID_SOCKET
, "socket call failed\n");
3432 FD_SET_ALL(fdWrite
);
3433 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3434 ok(ret
== 1, "expected 1, got %d\n", ret
);
3435 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
3436 closesocket(fdWrite
);
3441 static DWORD WINAPI
AcceptKillThread(void *param
)
3443 select_thread_params
*par
= param
;
3444 struct sockaddr_in address
;
3445 int len
= sizeof(address
);
3446 SOCKET client_socket
;
3448 SetEvent(server_ready
);
3449 client_socket
= accept(par
->s
, (struct sockaddr
*) &address
, &len
);
3450 if (client_socket
!= INVALID_SOCKET
)
3451 closesocket(client_socket
);
3452 par
->ReadKilled
= (client_socket
== INVALID_SOCKET
);
3457 static int CALLBACK
AlwaysDeferConditionFunc(LPWSABUF lpCallerId
, LPWSABUF lpCallerData
, LPQOS pQos
,
3458 LPQOS lpGQOS
, LPWSABUF lpCalleeId
, LPWSABUF lpCalleeData
,
3459 GROUP
*g
, DWORD_PTR dwCallbackData
)
3464 static SOCKET
setup_server_socket(struct sockaddr_in
*addr
, int *len
)
3467 SOCKET server_socket
;
3469 server_socket
= socket(AF_INET
, SOCK_STREAM
, 0);
3470 ok(server_socket
!= INVALID_SOCKET
, "failed to bind socket, error %u\n", WSAGetLastError());
3473 ret
= setsockopt(server_socket
, SOL_SOCKET
, SO_REUSEADDR
, (char *)&val
, sizeof(val
));
3474 ok(!ret
, "failed to set SO_REUSEADDR, error %u\n", WSAGetLastError());
3476 ret
= bind(server_socket
, (struct sockaddr
*)addr
, *len
);
3477 ok(!ret
, "failed to bind socket, error %u\n", WSAGetLastError());
3479 ret
= getsockname(server_socket
, (struct sockaddr
*)addr
, len
);
3480 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
3482 ret
= listen(server_socket
, 5);
3483 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
3485 return server_socket
;
3488 static SOCKET
setup_connector_socket(const struct sockaddr_in
*addr
, int len
, BOOL nonblock
)
3493 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
3494 ok(connector
!= INVALID_SOCKET
, "failed to create connector socket %d\n", WSAGetLastError());
3497 set_blocking(connector
, !nonblock
);
3499 ret
= connect(connector
, (const struct sockaddr
*)addr
, len
);
3501 ok(!ret
, "connecting to accepting socket failed %d\n", WSAGetLastError());
3502 else if (ret
== SOCKET_ERROR
)
3503 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
3508 static void test_accept(void)
3511 SOCKET server_socket
, accepted
= INVALID_SOCKET
, connector
;
3512 struct sockaddr_in address
;
3513 SOCKADDR_STORAGE ss
, ss_empty
;
3515 select_thread_params thread_params
;
3516 HANDLE thread_handle
= NULL
;
3519 memset(&address
, 0, sizeof(address
));
3520 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3521 address
.sin_family
= AF_INET
;
3523 socklen
= sizeof(address
);
3524 server_socket
= setup_server_socket(&address
, &socklen
);
3526 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3527 if (connector
== INVALID_SOCKET
) goto done
;
3529 accepted
= WSAAccept(server_socket
, NULL
, NULL
, AlwaysDeferConditionFunc
, 0);
3530 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
3532 accepted
= accept(server_socket
, NULL
, 0);
3533 ok(accepted
!= INVALID_SOCKET
, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
3535 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
3537 thread_params
.s
= server_socket
;
3538 thread_params
.ReadKilled
= FALSE
;
3539 thread_handle
= CreateThread(NULL
, 0, AcceptKillThread
, &thread_params
, 0, &id
);
3541 WaitForSingleObject(server_ready
, INFINITE
);
3543 ret
= closesocket(server_socket
);
3544 ok(!ret
, "failed to close socket, error %u\n", WSAGetLastError());
3546 WaitForSingleObject(thread_handle
, 1000);
3547 ok(thread_params
.ReadKilled
, "closesocket did not wake up accept\n");
3549 closesocket(accepted
);
3550 closesocket(connector
);
3551 accepted
= connector
= INVALID_SOCKET
;
3553 socklen
= sizeof(address
);
3554 server_socket
= setup_server_socket(&address
, &socklen
);
3556 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3557 if (connector
== INVALID_SOCKET
) goto done
;
3560 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
3561 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
3562 ok(!socklen
, "got %d\n", socklen
);
3563 closesocket(connector
);
3564 connector
= INVALID_SOCKET
;
3566 socklen
= sizeof(address
);
3567 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3568 if (connector
== INVALID_SOCKET
) goto done
;
3570 accepted
= WSAAccept(server_socket
, NULL
, NULL
, NULL
, 0);
3571 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3572 closesocket(accepted
);
3573 closesocket(connector
);
3574 accepted
= connector
= INVALID_SOCKET
;
3576 socklen
= sizeof(address
);
3577 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3578 if (connector
== INVALID_SOCKET
) goto done
;
3580 socklen
= sizeof(ss
);
3581 memset(&ss
, 0, sizeof(ss
));
3582 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
3583 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3584 ok(socklen
!= sizeof(ss
), "unexpected length\n");
3585 ok(ss
.ss_family
, "family not set\n");
3586 closesocket(accepted
);
3587 closesocket(connector
);
3588 accepted
= connector
= INVALID_SOCKET
;
3590 socklen
= sizeof(address
);
3591 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3592 if (connector
== INVALID_SOCKET
) goto done
;
3595 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
3596 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
3597 ok(!socklen
, "got %d\n", socklen
);
3598 closesocket(connector
);
3599 accepted
= connector
= INVALID_SOCKET
;
3601 socklen
= sizeof(address
);
3602 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3603 if (connector
== INVALID_SOCKET
) goto done
;
3605 accepted
= accept(server_socket
, NULL
, NULL
);
3606 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3607 closesocket(accepted
);
3608 closesocket(connector
);
3609 accepted
= connector
= INVALID_SOCKET
;
3611 socklen
= sizeof(address
);
3612 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3613 if (connector
== INVALID_SOCKET
) goto done
;
3615 socklen
= sizeof(ss
);
3616 memset(&ss
, 0, sizeof(ss
));
3617 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
3618 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3619 ok(socklen
!= sizeof(ss
), "unexpected length\n");
3620 ok(ss
.ss_family
, "family not set\n");
3621 closesocket(accepted
);
3622 closesocket(connector
);
3623 accepted
= connector
= INVALID_SOCKET
;
3625 socklen
= sizeof(address
);
3626 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3627 if (connector
== INVALID_SOCKET
) goto done
;
3629 memset(&ss
, 0, sizeof(ss
));
3630 memset(&ss_empty
, 0, sizeof(ss_empty
));
3631 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, NULL
);
3632 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3633 ok(!memcmp(&ss
, &ss_empty
, sizeof(ss
)), "structure is different\n");
3636 if (accepted
!= INVALID_SOCKET
)
3637 closesocket(accepted
);
3638 if (connector
!= INVALID_SOCKET
)
3639 closesocket(connector
);
3640 if (thread_handle
!= NULL
)
3641 CloseHandle(thread_handle
);
3642 if (server_ready
!= INVALID_HANDLE_VALUE
)
3643 CloseHandle(server_ready
);
3644 if (server_socket
!= INVALID_SOCKET
)
3645 closesocket(server_socket
);
3648 static void test_extendedSocketOptions(void)
3652 struct sockaddr_in sa
;
3653 int sa_len
= sizeof(struct sockaddr_in
);
3654 int optval
, optlen
= sizeof(int), ret
;
3658 ret
= WSAStartup(MAKEWORD(2,0), &wsa
);
3659 ok(!ret
, "failed to startup, error %u\n", WSAGetLastError());
3661 memset(&sa
, 0, sa_len
);
3663 sa
.sin_family
= AF_INET
;
3664 sa
.sin_port
= htons(0);
3665 sa
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
3667 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
3668 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
3670 ret
= bind(sock
, (struct sockaddr
*) &sa
, sa_len
);
3671 ok(!ret
, "failed to bind socket, error %u\n", WSAGetLastError());
3673 ret
= getsockopt(sock
, SOL_SOCKET
, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3675 ok(ret
== 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret
);
3676 ok((optval
== 65507) || (optval
== 65527),
3677 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval
);
3679 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
3680 SetLastError(0xdeadbeef);
3681 optval
= 0xdeadbeef;
3682 optlen
= sizeof(int);
3683 ret
= getsockopt(sock
, 0xffffffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3684 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3685 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3686 ret
, WSAGetLastError(), optval
, optval
);
3688 /* more invalid values for level */
3689 SetLastError(0xdeadbeef);
3690 optval
= 0xdeadbeef;
3691 optlen
= sizeof(int);
3692 ret
= getsockopt(sock
, 0x1234ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3693 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3694 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3695 ret
, WSAGetLastError(), optval
, optval
);
3697 SetLastError(0xdeadbeef);
3698 optval
= 0xdeadbeef;
3699 optlen
= sizeof(int);
3700 ret
= getsockopt(sock
, 0x8000ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3701 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3702 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3703 ret
, WSAGetLastError(), optval
, optval
);
3705 SetLastError(0xdeadbeef);
3706 optval
= 0xdeadbeef;
3707 optlen
= sizeof(int);
3708 ret
= getsockopt(sock
, 0x00008000, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3709 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3710 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3711 ret
, WSAGetLastError(), optval
, optval
);
3713 SetLastError(0xdeadbeef);
3714 optval
= 0xdeadbeef;
3715 optlen
= sizeof(int);
3716 ret
= getsockopt(sock
, 0x00000800, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3717 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3718 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3719 ret
, WSAGetLastError(), optval
, optval
);
3721 SetLastError(0xdeadbeef);
3722 optlen
= sizeof(LINGER
);
3723 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
3724 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAENOPROTOOPT
),
3725 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
3726 ret
, WSAGetLastError());
3729 sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
);
3730 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
3732 ret
= bind(sock
, (struct sockaddr
*) &sa
, sa_len
);
3733 ok(!ret
, "failed to bind socket, error %u\n", WSAGetLastError());
3735 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
3736 ok(ret
== 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret
);
3738 optlen
= sizeof(BOOL
);
3739 ret
= getsockopt(sock
, SOL_SOCKET
, SO_DONTLINGER
, (char *)&bool_opt_val
, &optlen
);
3740 ok(ret
== 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret
);
3741 ok((linger_val
.l_onoff
&& !bool_opt_val
) || (!linger_val
.l_onoff
&& bool_opt_val
),
3742 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
3743 bool_opt_val
, linger_val
.l_onoff
);
3749 static void test_getsockname(void)
3753 struct sockaddr_in sa_set
, sa_get
;
3754 int sa_set_len
= sizeof(struct sockaddr_in
);
3755 int sa_get_len
= sa_set_len
;
3756 static const unsigned char null_padding
[] = {0,0,0,0,0,0,0,0};
3760 ret
= WSAStartup(MAKEWORD(2,0), &wsa
);
3761 ok(!ret
, "failed to startup, error %u\n", WSAGetLastError());
3763 memset(&sa_set
, 0, sa_set_len
);
3765 sa_set
.sin_family
= AF_INET
;
3766 sa_set
.sin_port
= htons(0);
3767 sa_set
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
3769 sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
);
3770 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
3773 WSASetLastError(0xdeadbeef);
3774 ret
= getsockname(sock
, (struct sockaddr
*)&sa_get
, &sa_get_len
);
3775 ok(ret
== SOCKET_ERROR
, "expected failure\n");
3776 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
3777 ok(!memcmp(&sa_get
, &sa_set
, sizeof(sa_get
)), "address should not be changed\n");
3779 ret
= bind(sock
, (struct sockaddr
*) &sa_set
, sa_set_len
);
3780 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
3782 WSASetLastError(0xdeadbeef);
3783 memset(&sa_get
, 0, sizeof(sa_get
));
3784 ret
= getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
);
3785 ok(!ret
, "got %d\n", ret
);
3786 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
3787 ok(sa_get
.sin_family
== AF_INET
, "got family %#x\n", sa_get
.sin_family
);
3788 ok(sa_get
.sin_port
!= 0, "got zero port\n");
3789 ok(sa_get
.sin_addr
.s_addr
== INADDR_ANY
, "got addr %08x\n", sa_get
.sin_addr
.s_addr
);
3791 ret
= memcmp(sa_get
.sin_zero
, null_padding
, 8);
3792 ok(ret
== 0, "getsockname did not zero the sockaddr_in structure\n");
3794 sa_get_len
= sizeof(sa_get
) - 1;
3795 WSASetLastError(0xdeadbeef);
3796 ret
= getsockname(sock
, (struct sockaddr
*)&sa_get
, &sa_get_len
);
3797 ok(ret
== -1, "expected failure\n");
3798 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3799 ok(sa_get_len
== sizeof(sa_get
) - 1, "got size %d\n", sa_get_len
);
3803 h
= gethostbyname("");
3804 if (h
&& h
->h_length
== 4) /* this test is only meaningful in IPv4 */
3807 for (i
= 0; h
->h_addr_list
[i
]; i
++)
3811 ip
.s_addr
= *(ULONG
*) h
->h_addr_list
[i
];
3813 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
3814 ok(sock
!= INVALID_SOCKET
, "socket failed with %d\n", GetLastError());
3816 memset(&sa_set
, 0, sizeof(sa_set
));
3817 sa_set
.sin_family
= AF_INET
;
3818 sa_set
.sin_addr
.s_addr
= ip
.s_addr
;
3819 /* The same address we bind must be the same address we get */
3820 ret
= bind(sock
, (struct sockaddr
*)&sa_set
, sizeof(sa_set
));
3821 ok(ret
== 0, "bind failed with %d\n", GetLastError());
3822 sa_get_len
= sizeof(sa_get
);
3823 ret
= getsockname(sock
, (struct sockaddr
*)&sa_get
, &sa_get_len
);
3824 ok(ret
== 0, "getsockname failed with %d\n", GetLastError());
3825 strcpy(ipstr
, inet_ntoa(sa_get
.sin_addr
));
3826 ok(sa_get
.sin_addr
.s_addr
== sa_set
.sin_addr
.s_addr
,
3827 "address does not match: %s != %s\n", ipstr
, inet_ntoa(sa_set
.sin_addr
));
3836 static DWORD apc_error
, apc_size
;
3837 static OVERLAPPED
*apc_overlapped
;
3838 static unsigned int apc_count
;
3840 static void WINAPI
socket_apc(DWORD error
, DWORD size
, OVERLAPPED
*overlapped
, DWORD flags
)
3842 ok(!flags
, "got flags %#x\n", flags
);
3846 apc_overlapped
= overlapped
;
3849 #define check_fionread_siocatmark(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, FALSE, FALSE)
3850 #define check_fionread_siocatmark_todo(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, TRUE, TRUE)
3851 #define check_fionread_siocatmark_todo_oob(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, FALSE, TRUE)
3852 static void check_fionread_siocatmark_(int line
, SOCKET s
, unsigned int normal
, unsigned int oob
,
3853 BOOL todo_normal
, BOOL todo_oob
)
3859 WSASetLastError(0xdeadbeef);
3860 ret
= WSAIoctl(s
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), &size
, NULL
, NULL
);
3861 ok_(__FILE__
, line
)(!ret
, "expected success\n");
3862 ok_(__FILE__
, line
)(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
3863 todo_wine_if (todo_normal
) ok_(__FILE__
, line
)(value
== normal
, "FIONBIO returned %u\n", value
);
3866 WSASetLastError(0xdeadbeef);
3867 ret
= WSAIoctl(s
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), &size
, NULL
, NULL
);
3868 ok_(__FILE__
, line
)(!ret
, "expected success\n");
3869 ok_(__FILE__
, line
)(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
3870 todo_wine_if (todo_oob
) ok_(__FILE__
, line
)(value
== oob
, "SIOCATMARK returned %u\n", value
);
3873 static void test_fionread_siocatmark(void)
3875 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
3876 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
3877 SOCKET client
, server
;
3884 tcp_socketpair(&client
, &server
);
3885 set_blocking(client
, FALSE
);
3886 overlapped
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
3888 WSASetLastError(0xdeadbeef);
3889 ret
= ioctlsocket(client
, FIONREAD
, (u_long
*)1);
3890 ok(ret
== -1, "expected failure\n");
3891 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3893 WSASetLastError(0xdeadbeef);
3894 ret
= ioctlsocket(client
, SIOCATMARK
, (u_long
*)1);
3895 ok(ret
== -1, "expected failure\n");
3896 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3898 WSASetLastError(0xdeadbeef);
3899 ret
= WSAIoctl(client
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), NULL
, NULL
, NULL
);
3900 ok(ret
== -1, "expected failure\n");
3901 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3903 WSASetLastError(0xdeadbeef);
3905 ret
= WSAIoctl(client
, FIONREAD
, NULL
, 0, &value
, sizeof(value
) - 1, &size
, NULL
, NULL
);
3906 ok(ret
== -1, "expected failure\n");
3907 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3908 ok(size
== 0xdeadbeef, "got size %u\n", size
);
3910 WSASetLastError(0xdeadbeef);
3911 ret
= WSAIoctl(client
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), NULL
, NULL
, NULL
);
3912 ok(ret
== -1, "expected failure\n");
3913 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3915 WSASetLastError(0xdeadbeef);
3917 ret
= WSAIoctl(client
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
) - 1, &size
, NULL
, NULL
);
3918 ok(ret
== -1, "expected failure\n");
3919 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3920 ok(size
== 0xdeadbeef, "got size %u\n", size
);
3922 check_fionread_siocatmark(client
, 0, TRUE
);
3924 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 123, 0);
3926 ret
= WSAIoctl(client
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), NULL
, &overlapped
, NULL
);
3927 ok(ret
== -1, "expected failure\n");
3928 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3930 ret
= WSAIoctl(client
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), NULL
, &overlapped
, NULL
);
3931 ok(ret
== -1, "expected failure\n");
3932 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3934 WSASetLastError(0xdeadbeef);
3937 overlapped
.Internal
= 0xdeadbeef;
3938 overlapped
.InternalHigh
= 0xdeadbeef;
3939 ret
= WSAIoctl(client
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), &size
, &overlapped
, NULL
);
3940 ok(!ret
, "expected success\n");
3941 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
3942 ok(!value
, "got %u\n", value
);
3943 ok(size
== sizeof(value
), "got size %u\n", size
);
3944 ok(!overlapped
.Internal
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
3945 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
3947 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
3948 ok(ret
, "got error %u\n", GetLastError());
3949 ok(!size
, "got size %u\n", size
);
3950 ok(key
== 123, "got key %Iu\n", key
);
3951 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
3953 WSASetLastError(0xdeadbeef);
3956 overlapped
.Internal
= 0xdeadbeef;
3957 overlapped
.InternalHigh
= 0xdeadbeef;
3958 ret
= WSAIoctl(client
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), &size
, &overlapped
, NULL
);
3959 ok(!ret
, "expected success\n");
3960 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
3961 ok(value
== TRUE
, "got %u\n", value
);
3962 ok(size
== sizeof(value
), "got size %u\n", size
);
3963 ok(!overlapped
.Internal
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
3964 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
3966 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
3967 ok(ret
, "got error %u\n", GetLastError());
3968 ok(!size
, "got size %u\n", size
);
3969 ok(key
== 123, "got key %Iu\n", key
);
3970 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
3972 ret
= send(server
, "data", 5, 0);
3973 ok(ret
== 5, "got %d\n", ret
);
3975 /* wait for the data to be available */
3976 check_poll_mask(client
, POLLRDNORM
, POLLRDNORM
);
3978 check_fionread_siocatmark(client
, 5, TRUE
);
3980 ret
= send(server
, "a", 1, MSG_OOB
);
3981 ok(ret
== 1, "got %d\n", ret
);
3983 /* wait for the data to be available */
3984 check_poll_mask(client
, POLLRDBAND
, POLLRDBAND
);
3986 check_fionread_siocatmark_todo_oob(client
, 5, FALSE
);
3988 ret
= send(server
, "a", 1, MSG_OOB
);
3989 ok(ret
== 1, "got %d\n", ret
);
3991 check_fionread_siocatmark_todo(client
, 5, FALSE
);
3993 ret
= recv(client
, buffer
, 3, 0);
3994 ok(ret
== 3, "got %d\n", ret
);
3996 check_fionread_siocatmark_todo(client
, 2, FALSE
);
3998 ret
= recv(client
, buffer
, 1, MSG_OOB
);
3999 ok(ret
== 1, "got %d\n", ret
);
4001 /* wait for the data to be available */
4002 check_poll_mask_todo(client
, POLLRDBAND
, POLLRDBAND
);
4004 check_fionread_siocatmark_todo(client
, 2, FALSE
);
4006 ret
= recv(client
, buffer
, 5, 0);
4007 todo_wine
ok(ret
== 2, "got %d\n", ret
);
4009 check_fionread_siocatmark(client
, 0, FALSE
);
4011 ret
= recv(client
, buffer
, 1, MSG_OOB
);
4012 todo_wine
ok(ret
== 1, "got %d\n", ret
);
4014 check_fionread_siocatmark_todo_oob(client
, 0, TRUE
);
4016 ret
= send(server
, "a", 1, MSG_OOB
);
4017 ok(ret
== 1, "got %d\n", ret
);
4019 /* wait for the data to be available */
4020 check_poll_mask(client
, POLLRDBAND
, POLLRDBAND
);
4023 ret
= setsockopt(client
, SOL_SOCKET
, SO_OOBINLINE
, (char *)&ret
, sizeof(ret
));
4024 ok(!ret
, "got error %u\n", WSAGetLastError());
4026 check_fionread_siocatmark_todo_oob(client
, 1, FALSE
);
4028 ret
= recv(client
, buffer
, 1, 0);
4029 ok(ret
== 1, "got %d\n", ret
);
4031 check_fionread_siocatmark(client
, 0, TRUE
);
4033 ret
= send(server
, "a", 1, MSG_OOB
);
4034 ok(ret
== 1, "got %d\n", ret
);
4036 /* wait for the data to be available */
4037 check_poll_mask(client
, POLLRDNORM
, POLLRDNORM
);
4039 check_fionread_siocatmark(client
, 1, TRUE
);
4041 closesocket(client
);
4042 closesocket(server
);
4044 server
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4046 check_fionread_siocatmark(server
, 0, TRUE
);
4048 ret
= bind(server
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
4049 ok(!ret
, "got error %u\n", WSAGetLastError());
4051 check_fionread_siocatmark(server
, 0, TRUE
);
4053 closesocket(server
);
4054 CloseHandle(overlapped
.hEvent
);
4056 /* test with APCs */
4058 server
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4060 ret
= WSAIoctl(server
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), NULL
, &overlapped
, socket_apc
);
4061 ok(ret
== -1, "expected failure\n");
4062 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4064 ret
= WSAIoctl(server
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), NULL
, &overlapped
, socket_apc
);
4065 ok(ret
== -1, "expected failure\n");
4066 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4070 ret
= WSAIoctl(server
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), &size
, &overlapped
, socket_apc
);
4071 ok(!ret
, "expected success\n");
4072 ok(size
== sizeof(value
), "got size %u\n", size
);
4074 ret
= SleepEx(0, TRUE
);
4075 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
4076 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
4077 ok(!apc_error
, "got APC error %u\n", apc_error
);
4078 ok(!apc_size
, "got APC size %u\n", apc_size
);
4079 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
4083 ret
= WSAIoctl(server
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), &size
, &overlapped
, socket_apc
);
4084 ok(!ret
, "expected success\n");
4085 ok(size
== sizeof(value
), "got size %u\n", size
);
4087 ret
= SleepEx(0, TRUE
);
4088 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
4089 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
4090 ok(!apc_error
, "got APC error %u\n", apc_error
);
4091 ok(!apc_size
, "got APC size %u\n", apc_size
);
4092 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
4094 closesocket(server
);
4097 static void test_fionbio(void)
4099 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
4100 u_long one
= 1, zero
= 0;
4108 event
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
4109 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4110 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
4112 WSASetLastError(0xdeadbeef);
4113 ret
= ioctlsocket(s
, FIONBIO
, (u_long
*)1);
4114 ok(ret
== -1, "expected failure\n");
4115 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4117 WSASetLastError(0xdeadbeef);
4118 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, NULL
, NULL
, NULL
);
4119 ok(ret
== -1, "expected failure\n");
4120 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4122 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
) - 1, NULL
, 0, &size
, &overlapped
, NULL
);
4123 ok(ret
== -1, "expected failure\n");
4124 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4127 WSASetLastError(0xdeadbeef);
4128 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, &size
, NULL
, NULL
);
4129 ok(!ret
, "expected success\n");
4130 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4131 ok(!size
, "got size %u\n", size
);
4133 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
) + 1, NULL
, 0, &size
, NULL
, NULL
);
4134 ok(!ret
, "got error %u\n", WSAGetLastError());
4136 output
= VirtualAlloc(NULL
, 4, MEM_RESERVE
| MEM_COMMIT
, PAGE_NOACCESS
);
4137 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
) + 1, output
, 4, &size
, NULL
, NULL
);
4138 ok(!ret
, "got error %u\n", WSAGetLastError());
4139 VirtualFree(output
, 0, MEM_FREE
);
4141 overlapped
.Internal
= 0xdeadbeef;
4142 overlapped
.InternalHigh
= 0xdeadbeef;
4144 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, &size
, &overlapped
, NULL
);
4145 ok(!ret
, "expected success\n");
4146 ok(!size
, "got size %u\n", size
);
4148 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
4149 ok(ret
, "got error %u\n", GetLastError());
4150 ok(!size
, "got size %u\n", size
);
4151 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
4152 ok(!overlapped
.Internal
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
4153 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
4155 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, NULL
, &overlapped
, NULL
);
4156 ok(ret
== -1, "expected failure\n");
4157 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4159 ret
= WSAEventSelect(s
, event
, FD_READ
);
4160 ok(!ret
, "got error %u\n", WSAGetLastError());
4162 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, &size
, NULL
, NULL
);
4163 ok(!ret
, "got error %u\n", WSAGetLastError());
4166 ret
= WSAIoctl(s
, FIONBIO
, &zero
, sizeof(zero
), NULL
, 0, &size
, NULL
, NULL
);
4167 ok(ret
== -1, "expected failure\n");
4168 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
4169 todo_wine
ok(!size
, "got size %u\n", size
);
4175 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4177 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, NULL
, &overlapped
, socket_apc
);
4178 ok(ret
== -1, "expected failure\n");
4179 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4183 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, &size
, &overlapped
, socket_apc
);
4184 ok(!ret
, "expected success\n");
4185 ok(!size
, "got size %u\n", size
);
4187 ret
= SleepEx(0, TRUE
);
4188 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
4189 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
4190 ok(!apc_error
, "got APC error %u\n", apc_error
);
4191 ok(!apc_size
, "got APC size %u\n", apc_size
);
4192 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
4197 static void test_keepalive_vals(void)
4199 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
4200 struct tcp_keepalive kalive
;
4207 sock
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4208 ok(sock
!= INVALID_SOCKET
, "Creating the socket failed: %d\n", WSAGetLastError());
4209 port
= CreateIoCompletionPort((HANDLE
)sock
, NULL
, 123, 0);
4211 WSASetLastError(0xdeadbeef);
4213 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, 0, NULL
, 0, &size
, NULL
, NULL
);
4214 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
4215 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4216 ok(!size
, "got size %u\n", size
);
4218 WSASetLastError(0xdeadbeef);
4220 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, NULL
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
4221 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
4222 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4223 ok(!size
, "got size %u\n", size
);
4225 WSASetLastError(0xdeadbeef);
4227 make_keepalive(kalive
, 0, 0, 0);
4228 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
4229 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
4230 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4231 ok(!size
, "got size %u\n", size
);
4233 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, NULL
, NULL
, NULL
);
4234 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
4235 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4237 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, NULL
, &overlapped
, NULL
);
4238 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
4239 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4241 WSASetLastError(0xdeadbeef);
4243 overlapped
.Internal
= 0xdeadbeef;
4244 overlapped
.InternalHigh
= 0xdeadbeef;
4245 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
) - 1, NULL
, 0, &size
, &overlapped
, NULL
);
4246 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
4247 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4248 ok(size
== 0xdeadbeef, "got size %u\n", size
);
4249 todo_wine
ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
4250 ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
4252 WSASetLastError(0xdeadbeef);
4254 overlapped
.Internal
= 0xdeadbeef;
4255 overlapped
.InternalHigh
= 0xdeadbeef;
4256 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, &overlapped
, NULL
);
4257 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
4258 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4259 todo_wine
ok(size
== 0xdeadbeef, "got size %u\n", size
);
4261 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
4262 ok(ret
, "got error %u\n", GetLastError());
4263 ok(!size
, "got size %u\n", size
);
4264 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
4265 ok(!overlapped
.Internal
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
4266 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
4268 make_keepalive(kalive
, 1, 0, 0);
4269 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
4270 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
4272 make_keepalive(kalive
, 1, 1000, 1000);
4273 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
4274 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
4276 make_keepalive(kalive
, 1, 10000, 10000);
4277 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
4278 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
4280 make_keepalive(kalive
, 1, 100, 100);
4281 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
4282 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
4284 make_keepalive(kalive
, 0, 100, 100);
4285 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
4286 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
4291 sock
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4293 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, NULL
, &overlapped
, socket_apc
);
4294 ok(ret
== -1, "expected failure\n");
4295 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4299 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, &overlapped
, socket_apc
);
4300 ok(!ret
, "expected success\n");
4301 ok(!size
, "got size %u\n", size
);
4303 ret
= SleepEx(0, TRUE
);
4304 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
4305 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
4306 ok(!apc_error
, "got APC error %u\n", apc_error
);
4307 ok(!apc_size
, "got APC size %u\n", apc_size
);
4308 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
4313 static void test_unsupported_ioctls(void)
4315 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
4323 static const DWORD codes
[] = {0xdeadbeef, FIOASYNC
, 0x667e, SIO_FLUSH
};
4325 for (i
= 0; i
< ARRAY_SIZE(codes
); ++i
)
4327 winetest_push_context("ioctl %#x", codes
[i
]);
4328 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4329 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
4331 WSASetLastError(0xdeadbeef);
4332 ret
= WSAIoctl(s
, codes
[i
], NULL
, 0, NULL
, 0, NULL
, &overlapped
, NULL
);
4333 ok(ret
== -1, "expected failure\n");
4334 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4336 WSASetLastError(0xdeadbeef);
4338 ret
= WSAIoctl(s
, codes
[i
], NULL
, 0, NULL
, 0, &size
, NULL
, NULL
);
4339 ok(ret
== -1, "expected failure\n");
4340 ok(WSAGetLastError() == WSAEOPNOTSUPP
, "got error %u\n", WSAGetLastError());
4341 ok(!size
, "got size %u\n", size
);
4343 WSASetLastError(0xdeadbeef);
4345 overlapped
.Internal
= 0xdeadbeef;
4346 overlapped
.InternalHigh
= 0xdeadbeef;
4347 ret
= WSAIoctl(s
, codes
[i
], NULL
, 0, NULL
, 0, &size
, &overlapped
, NULL
);
4348 ok(ret
== -1, "expected failure\n");
4349 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
4350 ok(size
== 0xdeadbeef, "got size %u\n", size
);
4352 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
4353 ok(!ret
, "expected failure\n");
4354 ok(GetLastError() == ERROR_NOT_SUPPORTED
, "got error %u\n", GetLastError());
4355 ok(!size
, "got size %u\n", size
);
4356 ok(key
== 123, "got key %Iu\n", key
);
4357 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
4358 ok((NTSTATUS
)overlapped
.Internal
== STATUS_NOT_SUPPORTED
,
4359 "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
4360 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
4365 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4367 ret
= WSAIoctl(s
, codes
[i
], NULL
, 0, NULL
, 0, NULL
, &overlapped
, socket_apc
);
4368 ok(ret
== -1, "expected failure\n");
4369 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4373 ret
= WSAIoctl(s
, codes
[i
], NULL
, 0, NULL
, 0, &size
, &overlapped
, socket_apc
);
4374 ok(ret
== -1, "expected failure\n");
4375 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
4376 ok(size
== 0xdeadbeef, "got size %u\n", size
);
4378 ret
= SleepEx(0, TRUE
);
4379 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
4380 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
4381 ok(apc_error
== WSAEOPNOTSUPP
, "got APC error %u\n", apc_error
);
4382 ok(!apc_size
, "got APC size %u\n", apc_size
);
4383 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
4386 winetest_pop_context();
4390 static void test_get_extension_func(void)
4392 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
4393 GUID acceptex_guid
= WSAID_ACCEPTEX
;
4394 GUID bogus_guid
= {0xdeadbeef};
4402 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4403 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
4405 WSASetLastError(0xdeadbeef);
4406 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptex_guid
, sizeof(GUID
),
4407 &func
, sizeof(func
), NULL
, &overlapped
, NULL
);
4408 ok(ret
== -1, "expected failure\n");
4409 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4411 WSASetLastError(0xdeadbeef);
4413 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptex_guid
, sizeof(GUID
),
4414 &func
, sizeof(func
), &size
, NULL
, NULL
);
4415 ok(!ret
, "expected success\n");
4416 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4417 ok(size
== sizeof(func
), "got size %u\n", size
);
4419 WSASetLastError(0xdeadbeef);
4421 overlapped
.Internal
= 0xdeadbeef;
4422 overlapped
.InternalHigh
= 0xdeadbeef;
4423 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptex_guid
, sizeof(GUID
),
4424 &func
, sizeof(func
), &size
, &overlapped
, NULL
);
4425 ok(!ret
, "expected success\n");
4426 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4427 ok(size
== sizeof(func
), "got size %u\n", size
);
4429 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
4430 ok(ret
, "got error %u\n", GetLastError());
4431 ok(!size
, "got size %u\n", size
);
4432 ok(key
== 123, "got key %Iu\n", key
);
4433 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
4434 ok(!overlapped
.Internal
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
4435 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
4438 overlapped
.Internal
= 0xdeadbeef;
4439 overlapped
.InternalHigh
= 0xdeadbeef;
4440 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &bogus_guid
, sizeof(GUID
),
4441 &func
, sizeof(func
), &size
, &overlapped
, NULL
);
4442 ok(ret
== -1, "expected failure\n");
4443 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
4444 ok(size
== 0xdeadbeef, "got size %u\n", size
);
4445 ok(overlapped
.Internal
== 0xdeadbeef, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
4446 ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
4448 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
4449 ok(!ret
, "expected failure\n");
4450 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", WSAGetLastError());
4455 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4457 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptex_guid
, sizeof(GUID
),
4458 &func
, sizeof(func
), NULL
, &overlapped
, socket_apc
);
4459 ok(ret
== -1, "expected failure\n");
4460 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4464 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptex_guid
, sizeof(GUID
),
4465 &func
, sizeof(func
), &size
, &overlapped
, socket_apc
);
4466 ok(!ret
, "got error %u\n", WSAGetLastError());
4467 ok(size
== sizeof(func
), "got size %u\n", size
);
4469 ret
= SleepEx(0, TRUE
);
4470 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
4471 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
4472 ok(!apc_error
, "got APC error %u\n", apc_error
);
4473 ok(!apc_size
, "got APC size %u\n", apc_size
);
4474 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
4479 static void test_base_handle(void)
4481 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
4491 int family
, type
, protocol
;
4495 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
4496 {AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
4497 {AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
},
4498 {AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
},
4501 for (i
= 0; i
< ARRAY_SIZE(tests
); ++i
)
4503 s
= socket(tests
[i
].family
, tests
[i
].type
, tests
[i
].protocol
);
4504 if (s
== INVALID_SOCKET
) continue;
4505 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
4507 WSASetLastError(0xdeadbeef);
4508 ret
= WSAIoctl(s
, SIO_BASE_HANDLE
, NULL
, 0, &base
, sizeof(base
), NULL
, &overlapped
, NULL
);
4509 ok(ret
== -1, "expected failure\n");
4510 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4512 WSASetLastError(0xdeadbeef);
4515 ret
= WSAIoctl(s
, SIO_BASE_HANDLE
, NULL
, 0, &base
, sizeof(base
), &size
, NULL
, NULL
);
4516 ok(!ret
, "expected success\n");
4517 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4518 ok(size
== sizeof(base
), "got size %u\n", size
);
4519 ok(base
== s
, "expected %#Ix, got %#Ix\n", s
, base
);
4521 WSASetLastError(0xdeadbeef);
4524 overlapped
.Internal
= 0xdeadbeef;
4525 overlapped
.InternalHigh
= 0xdeadbeef;
4526 ret
= WSAIoctl(s
, SIO_BASE_HANDLE
, NULL
, 0, &base
, sizeof(base
), &size
, &overlapped
, NULL
);
4527 ok(ret
== -1, "expected failure\n");
4528 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
4529 ok(size
== 0xdeadbeef, "got size %u\n", size
);
4531 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
4532 ok(!ret
, "expected failure\n");
4533 ok(GetLastError() == ERROR_NOT_SUPPORTED
, "got error %u\n", GetLastError());
4534 ok(!size
, "got size %u\n", size
);
4535 ok(key
== 123, "got key %Iu\n", key
);
4536 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
4537 ok((NTSTATUS
)overlapped
.Internal
== STATUS_NOT_SUPPORTED
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
4538 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
4539 ok(base
== 0xdeadbeef, "expected %#Ix, got %#Ix\n", s
, base
);
4544 s
= socket(tests
[i
].family
, tests
[i
].type
, tests
[i
].protocol
);
4546 ret
= WSAIoctl(s
, SIO_BASE_HANDLE
, NULL
, 0, &base
, sizeof(base
), NULL
, &overlapped
, socket_apc
);
4547 ok(ret
== -1, "expected failure\n");
4548 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
4553 ret
= WSAIoctl(s
, SIO_BASE_HANDLE
, NULL
, 0, &base
, sizeof(base
), &size
, &overlapped
, socket_apc
);
4554 ok(ret
== -1, "expected failure\n");
4555 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
4556 ok(size
== 0xdeadbeef, "got size %u\n", size
);
4558 ret
= SleepEx(0, TRUE
);
4559 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
4560 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
4561 ok(apc_error
== WSAEOPNOTSUPP
, "got APC error %u\n", apc_error
);
4562 ok(!apc_size
, "got APC size %u\n", apc_size
);
4563 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
4564 ok(base
== 0xdeadbeef, "expected %#Ix, got %#Ix\n", s
, base
);
4570 static BOOL drain_pause
= FALSE
;
4571 static DWORD WINAPI
drain_socket_thread(LPVOID arg
)
4574 SOCKET sock
= *(SOCKET
*)arg
;
4577 while ((ret
= recv(sock
, buffer
, sizeof(buffer
), 0)) != 0)
4581 if (WSAGetLastError() == WSAEWOULDBLOCK
)
4585 FD_SET(sock
, &readset
);
4586 select(sock
+1, &readset
, NULL
, NULL
, NULL
);
4597 static void test_send(void)
4599 SOCKET src
= INVALID_SOCKET
;
4600 SOCKET dst
= INVALID_SOCKET
;
4601 HANDLE hThread
= NULL
;
4602 const int buflen
= 1024*1024;
4603 char *buffer
= NULL
;
4604 int ret
, i
, zero
= 0;
4608 DWORD id
, bytes_sent
, dwRet
;
4610 memset(&ov
, 0, sizeof(ov
));
4612 tcp_socketpair(&src
, &dst
);
4614 set_blocking(dst
, FALSE
);
4615 /* force disable buffering so we can get a pending overlapped request */
4616 ret
= setsockopt(dst
, SOL_SOCKET
, SO_SNDBUF
, (char *) &zero
, sizeof(zero
));
4617 ok(!ret
, "setsockopt SO_SNDBUF failed: %d - %d\n", ret
, GetLastError());
4619 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
4621 buffer
= HeapAlloc(GetProcessHeap(), 0, buflen
);
4623 /* fill the buffer with some nonsense */
4624 for (i
= 0; i
< buflen
; ++i
)
4626 buffer
[i
] = (char) i
;
4629 ret
= send(src
, buffer
, buflen
, 0);
4630 ok(ret
== buflen
, "send should have sent %d bytes, but it only sent %d\n", buflen
, ret
);
4635 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
4636 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
4641 WSASetLastError(12345);
4642 ret
= WSASend(dst
, &buf
, 1, &bytes_sent
, 0, &ov
, NULL
);
4643 ok(ret
== SOCKET_ERROR
, "expected failure\n");
4644 ok(WSAGetLastError() == ERROR_IO_PENDING
, "wrong error %u\n", WSAGetLastError());
4646 /* don't check for completion yet, we may need to drain the buffer while still sending */
4647 set_blocking(src
, FALSE
);
4648 for (i
= 0; i
< buflen
; ++i
)
4652 ret
= recv(src
, buffer
, 1, 0);
4653 while (ret
== SOCKET_ERROR
&& GetLastError() == WSAEWOULDBLOCK
&& j
< 100)
4657 ret
= recv(src
, buffer
, 1, 0);
4660 ok(ret
== 1, "Failed to receive data %d - %d (got %d/%d)\n", ret
, GetLastError(), i
, buflen
);
4664 ok(buffer
[0] == (char) i
, "Received bad data at position %d\n", i
);
4667 dwRet
= WaitForSingleObject(ov
.hEvent
, 1000);
4668 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
4669 if (dwRet
== WAIT_OBJECT_0
)
4671 bret
= GetOverlappedResult((HANDLE
)dst
, &ov
, &bytes_sent
, FALSE
);
4672 ok(bret
&& bytes_sent
== buflen
,
4673 "Got %d instead of %d (%d - %d)\n", bytes_sent
, buflen
, bret
, GetLastError());
4676 WSASetLastError(12345);
4677 ret
= WSASend(INVALID_SOCKET
, &buf
, 1, NULL
, 0, &ov
, NULL
);
4678 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
4679 "WSASend failed %d - %d\n", ret
, WSAGetLastError());
4681 WSASetLastError(12345);
4682 ret
= WSASend(dst
, &buf
, 1, NULL
, 0, &ov
, NULL
);
4683 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == ERROR_IO_PENDING
,
4684 "Failed to start overlapped send %d - %d\n", ret
, WSAGetLastError());
4687 if (src
!= INVALID_SOCKET
)
4689 if (dst
!= INVALID_SOCKET
)
4691 if (hThread
!= NULL
)
4693 dwRet
= WaitForSingleObject(hThread
, 500);
4694 ok(dwRet
== WAIT_OBJECT_0
, "failed to wait for thread termination: %d\n", GetLastError());
4695 CloseHandle(hThread
);
4698 CloseHandle(ov
.hEvent
);
4699 HeapFree(GetProcessHeap(), 0, buffer
);
4702 #define WM_SOCKET (WM_USER+100)
4704 struct event_test_ctx
4712 static void select_events(struct event_test_ctx
*ctx
, SOCKET socket
, LONG events
)
4716 if (ctx
->is_message
)
4717 ret
= WSAAsyncSelect(socket
, ctx
->window
, WM_USER
, events
);
4719 ret
= WSAEventSelect(socket
, ctx
->event
, events
);
4720 ok(!ret
, "failed to select, error %u\n", WSAGetLastError());
4721 ctx
->socket
= socket
;
4724 #define check_events(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, FALSE)
4725 #define check_events_todo(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, TRUE)
4726 #define check_events_todo_event(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, FALSE)
4727 #define check_events_todo_msg(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, TRUE)
4728 static void check_events_(int line
, struct event_test_ctx
*ctx
,
4729 LONG flag1
, LONG flag2
, DWORD timeout
, BOOL todo_event
, BOOL todo_msg
)
4733 if (ctx
->is_message
)
4735 BOOL any_fail
= FALSE
;
4740 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
4741 while (!ret
&& !MsgWaitForMultipleObjects(0, NULL
, FALSE
, timeout
, QS_POSTMESSAGE
))
4742 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
4743 todo_wine_if (todo_msg
&& !ret
) ok_(__FILE__
, line
)(ret
, "expected a message\n");
4746 ok_(__FILE__
, line
)(msg
.wParam
== ctx
->socket
,
4747 "expected wparam %#Ix, got %#Ix\n", ctx
->socket
, msg
.wParam
);
4748 todo_wine_if (todo_msg
&& msg
.lParam
!= flag1
)
4749 ok_(__FILE__
, line
)(msg
.lParam
== flag1
, "got first event %#Ix\n", msg
.lParam
);
4750 if (msg
.lParam
!= flag1
) any_fail
= TRUE
;
4757 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
4758 while (!ret
&& !MsgWaitForMultipleObjects(0, NULL
, FALSE
, timeout
, QS_POSTMESSAGE
))
4759 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
4760 ok_(__FILE__
, line
)(ret
, "expected a message\n");
4761 ok_(__FILE__
, line
)(msg
.wParam
== ctx
->socket
, "got wparam %#Ix\n", msg
.wParam
);
4762 todo_wine_if (todo_msg
) ok_(__FILE__
, line
)(msg
.lParam
== flag2
, "got second event %#Ix\n", msg
.lParam
);
4764 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
4765 todo_wine_if (todo_msg
&& ret
) ok_(__FILE__
, line
)(!ret
, "got unexpected event %#Ix\n", msg
.lParam
);
4766 if (ret
) any_fail
= TRUE
;
4768 /* catch tests which succeed */
4769 todo_wine_if (todo_msg
) ok_(__FILE__
, line
)(!any_fail
, "event series matches\n");
4773 WSANETWORKEVENTS events
;
4775 ret
= WaitForSingleObject(ctx
->event
, timeout
);
4777 todo_wine_if (todo_event
&& ret
) ok_(__FILE__
, line
)(!ret
, "event wait timed out\n");
4779 todo_wine_if (todo_event
) ok_(__FILE__
, line
)(ret
== WAIT_TIMEOUT
, "expected timeout\n");
4780 ret
= WSAEnumNetworkEvents(ctx
->socket
, ctx
->event
, &events
);
4781 ok_(__FILE__
, line
)(!ret
, "failed to get events, error %u\n", WSAGetLastError());
4782 todo_wine_if (todo_event
)
4783 ok_(__FILE__
, line
)(events
.lNetworkEvents
== (flag1
| flag2
), "got events %#x\n", events
.lNetworkEvents
);
4787 static void test_accept_events(struct event_test_ctx
*ctx
)
4789 const struct sockaddr_in addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
4790 SOCKET listener
, server
, client
, client2
;
4791 struct sockaddr_in destaddr
;
4794 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4795 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4797 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
4799 ret
= bind(listener
, (const struct sockaddr
*)&addr
, sizeof(addr
));
4800 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
4801 len
= sizeof(destaddr
);
4802 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &len
);
4803 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
4804 ret
= listen(listener
, 2);
4805 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
4807 check_events(ctx
, 0, 0, 0);
4809 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4810 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4811 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4812 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4814 check_events(ctx
, FD_ACCEPT
, 0, 200);
4815 check_events(ctx
, 0, 0, 0);
4816 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
4817 if (ctx
->is_message
)
4818 check_events(ctx
, FD_ACCEPT
, 0, 200);
4819 check_events(ctx
, 0, 0, 0);
4820 select_events(ctx
, listener
, 0);
4821 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
4822 if (ctx
->is_message
)
4823 check_events(ctx
, FD_ACCEPT
, 0, 200);
4824 check_events(ctx
, 0, 0, 0);
4826 client2
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4827 ok(client2
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4828 ret
= connect(client2
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4829 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4831 if (!ctx
->is_message
)
4832 check_events_todo(ctx
, FD_ACCEPT
, 0, 200);
4833 check_events(ctx
, 0, 0, 0);
4835 server
= accept(listener
, NULL
, NULL
);
4836 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4837 closesocket(server
);
4839 check_events(ctx
, FD_ACCEPT
, 0, 200);
4840 check_events(ctx
, 0, 0, 0);
4842 server
= accept(listener
, NULL
, NULL
);
4843 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4844 closesocket(server
);
4846 check_events(ctx
, 0, 0, 0);
4848 closesocket(client2
);
4849 closesocket(client
);
4851 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4852 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4853 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4854 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4856 check_events(ctx
, FD_ACCEPT
, 0, 200);
4858 server
= accept(listener
, NULL
, NULL
);
4859 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4860 closesocket(server
);
4861 closesocket(client
);
4863 check_events(ctx
, 0, 0, 200);
4865 closesocket(listener
);
4867 /* Connect and then select. */
4869 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4870 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4871 ret
= bind(listener
, (const struct sockaddr
*)&addr
, sizeof(addr
));
4872 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
4873 len
= sizeof(destaddr
);
4874 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &len
);
4875 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
4876 ret
= listen(listener
, 2);
4877 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
4879 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4880 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4881 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4882 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4884 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
4886 check_events(ctx
, FD_ACCEPT
, 0, 200);
4888 server
= accept(listener
, NULL
, NULL
);
4889 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4890 closesocket(server
);
4891 closesocket(client
);
4893 /* As above, but select on a subset not containing FD_ACCEPT first. */
4895 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
);
4897 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4898 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4899 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4900 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4902 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
4903 check_events(ctx
, FD_ACCEPT
, 0, 200);
4905 server
= accept(listener
, NULL
, NULL
);
4906 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4907 closesocket(server
);
4908 closesocket(client
);
4910 /* As above, but call accept() before selecting. */
4912 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
);
4914 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4915 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4916 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4917 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4919 server
= accept(listener
, NULL
, NULL
);
4920 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4922 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
4923 check_events(ctx
, 0, 0, 200);
4925 closesocket(server
);
4926 closesocket(client
);
4928 closesocket(listener
);
4931 static void test_connect_events(struct event_test_ctx
*ctx
)
4933 const struct sockaddr_in addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
4934 SOCKET listener
, server
, client
;
4935 struct sockaddr_in destaddr
;
4938 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4939 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4940 ret
= bind(listener
, (const struct sockaddr
*)&addr
, sizeof(addr
));
4941 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
4942 len
= sizeof(destaddr
);
4943 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &len
);
4944 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
4945 ret
= listen(listener
, 2);
4946 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
4948 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4949 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4951 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4952 check_events(ctx
, 0, 0, 0);
4954 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4955 ok(!ret
|| WSAGetLastError() == WSAEWOULDBLOCK
, "failed to connect, error %u\n", WSAGetLastError());
4957 check_events(ctx
, FD_CONNECT
, FD_WRITE
, 200);
4958 check_events(ctx
, 0, 0, 0);
4959 select_events(ctx
, client
, 0);
4960 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4961 if (ctx
->is_message
)
4962 check_events(ctx
, FD_WRITE
, 0, 200);
4963 check_events(ctx
, 0, 0, 0);
4965 server
= accept(listener
, NULL
, NULL
);
4966 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4968 closesocket(client
);
4969 closesocket(server
);
4971 /* Connect and then select. */
4973 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4974 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4976 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4977 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4979 server
= accept(listener
, NULL
, NULL
);
4980 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4982 ret
= send(client
, "data", 5, 0);
4983 ok(ret
== 5, "got %d\n", ret
);
4985 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4986 if (ctx
->is_message
)
4987 check_events(ctx
, FD_WRITE
, 0, 200);
4989 check_events(ctx
, FD_CONNECT
, FD_WRITE
, 200);
4991 closesocket(client
);
4992 closesocket(server
);
4994 /* As above, but select on a subset not containing FD_CONNECT first. */
4996 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4997 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4999 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_OOB
| FD_READ
| FD_WRITE
);
5001 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
5002 ok(!ret
|| WSAGetLastError() == WSAEWOULDBLOCK
, "failed to connect, error %u\n", WSAGetLastError());
5004 server
= accept(listener
, NULL
, NULL
);
5005 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
5007 check_events(ctx
, FD_WRITE
, 0, 200);
5009 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
5011 if (ctx
->is_message
)
5012 check_events(ctx
, FD_WRITE
, 0, 200);
5014 check_events_todo(ctx
, FD_CONNECT
, 0, 200);
5016 closesocket(client
);
5017 closesocket(server
);
5019 closesocket(listener
);
5022 /* perform a blocking recv() even on a nonblocking socket */
5023 static int sync_recv(SOCKET s
, void *buffer
, int len
, DWORD flags
)
5025 OVERLAPPED overlapped
= {0};
5030 overlapped
.hEvent
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
5031 wsabuf
.buf
= buffer
;
5033 ret
= WSARecv(s
, &wsabuf
, 1, &ret_len
, &flags
, &overlapped
, NULL
);
5034 if (ret
== -1 && WSAGetLastError() == ERROR_IO_PENDING
)
5036 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
5037 ok(!ret
, "wait timed out\n");
5038 ret
= WSAGetOverlappedResult(s
, &overlapped
, &ret_len
, FALSE
, &flags
);
5039 ret
= (ret
? 0 : -1);
5041 CloseHandle(overlapped
.hEvent
);
5042 if (!ret
) return ret_len
;
5046 static void test_write_events(struct event_test_ctx
*ctx
)
5048 static const int buffer_size
= 1024 * 1024;
5049 SOCKET server
, client
;
5053 buffer
= malloc(buffer_size
);
5055 tcp_socketpair(&client
, &server
);
5056 set_blocking(client
, FALSE
);
5058 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
5059 check_events(ctx
, FD_WRITE
, 0, 200);
5060 check_events(ctx
, 0, 0, 0);
5061 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
5062 if (ctx
->is_message
)
5063 check_events(ctx
, FD_WRITE
, 0, 200);
5064 check_events(ctx
, 0, 0, 0);
5065 select_events(ctx
, server
, 0);
5066 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
5067 if (ctx
->is_message
)
5068 check_events(ctx
, FD_WRITE
, 0, 200);
5069 check_events(ctx
, 0, 0, 0);
5071 ret
= send(server
, "data", 5, 0);
5072 ok(ret
== 5, "got %d\n", ret
);
5074 check_events(ctx
, 0, 0, 0);
5076 ret
= sync_recv(client
, buffer
, buffer_size
, 0);
5077 ok(ret
== 5, "got %d\n", ret
);
5079 check_events(ctx
, 0, 0, 0);
5083 while (send(server
, buffer
, buffer_size
, 0) == buffer_size
);
5084 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
5086 while (recv(client
, buffer
, buffer_size
, 0) > 0);
5087 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
5089 /* Broken on Windows versions older than win10v1607 (though sometimes
5090 * works regardless, for unclear reasons. */
5091 check_events(ctx
, FD_WRITE
, 0, 200);
5092 check_events(ctx
, 0, 0, 0);
5093 select_events(ctx
, server
, 0);
5094 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
5095 if (ctx
->is_message
)
5096 check_events(ctx
, FD_WRITE
, 0, 200);
5097 check_events(ctx
, 0, 0, 0);
5100 closesocket(server
);
5101 closesocket(client
);
5103 /* Despite the documentation, and unlike FD_ACCEPT and FD_RECV, calling
5104 * send() doesn't clear the FD_WRITE bit. */
5106 tcp_socketpair(&client
, &server
);
5108 select_events(ctx
, server
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
5110 ret
= send(server
, "data", 5, 0);
5111 ok(ret
== 5, "got %d\n", ret
);
5113 check_events(ctx
, FD_WRITE
, 0, 200);
5115 closesocket(server
);
5116 closesocket(client
);
5121 static void test_read_events(struct event_test_ctx
*ctx
)
5123 SOCKET server
, client
;
5128 tcp_socketpair(&client
, &server
);
5129 set_blocking(client
, FALSE
);
5131 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5132 check_events(ctx
, 0, 0, 0);
5134 ret
= send(client
, "data", 5, 0);
5135 ok(ret
== 5, "got %d\n", ret
);
5137 check_events(ctx
, FD_READ
, 0, 200);
5138 check_events(ctx
, 0, 0, 0);
5139 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5140 if (ctx
->is_message
)
5141 check_events(ctx
, FD_READ
, 0, 200);
5142 check_events(ctx
, 0, 0, 0);
5143 select_events(ctx
, server
, 0);
5144 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5145 if (ctx
->is_message
)
5146 check_events(ctx
, FD_READ
, 0, 200);
5147 check_events(ctx
, 0, 0, 0);
5149 ret
= send(client
, "data", 5, 0);
5150 ok(ret
== 5, "got %d\n", ret
);
5152 if (!ctx
->is_message
)
5153 check_events_todo(ctx
, FD_READ
, 0, 200);
5154 check_events(ctx
, 0, 0, 0);
5156 ret
= recv(server
, buffer
, 2, 0);
5157 ok(ret
== 2, "got %d\n", ret
);
5159 check_events(ctx
, FD_READ
, 0, 200);
5160 check_events(ctx
, 0, 0, 0);
5162 ret
= recv(server
, buffer
, -1, 0);
5163 ok(ret
== -1, "got %d\n", ret
);
5164 ok(WSAGetLastError() == WSAEFAULT
|| WSAGetLastError() == WSAENOBUFS
/* < Windows 7 */,
5165 "got error %u\n", WSAGetLastError());
5167 if (ctx
->is_message
)
5168 check_events_todo_msg(ctx
, FD_READ
, 0, 200);
5169 check_events(ctx
, 0, 0, 0);
5171 for (i
= 0; i
< 8; ++i
)
5173 ret
= sync_recv(server
, buffer
, 1, 0);
5174 ok(ret
== 1, "got %d\n", ret
);
5177 check_events(ctx
, FD_READ
, 0, 200);
5178 check_events(ctx
, 0, 0, 0);
5181 /* Send data while we're not selecting. */
5183 select_events(ctx
, server
, 0);
5184 ret
= send(client
, "data", 5, 0);
5185 ok(ret
== 5, "got %d\n", ret
);
5186 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5188 check_events(ctx
, FD_READ
, 0, 200);
5190 ret
= recv(server
, buffer
, 5, 0);
5191 ok(ret
== 5, "got %d\n", ret
);
5193 select_events(ctx
, server
, 0);
5194 ret
= send(client
, "data", 5, 0);
5195 ok(ret
== 5, "got %d\n", ret
);
5196 ret
= sync_recv(server
, buffer
, 5, 0);
5197 ok(ret
== 5, "got %d\n", ret
);
5198 select_events(ctx
, server
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
);
5200 check_events(ctx
, 0, 0, 200);
5202 closesocket(server
);
5203 closesocket(client
);
5206 static void test_oob_events(struct event_test_ctx
*ctx
)
5208 SOCKET server
, client
;
5212 tcp_socketpair(&client
, &server
);
5213 set_blocking(client
, FALSE
);
5215 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5216 check_events(ctx
, 0, 0, 0);
5218 ret
= send(client
, "a", 1, MSG_OOB
);
5219 ok(ret
== 1, "got %d\n", ret
);
5221 check_events(ctx
, FD_OOB
, 0, 200);
5222 check_events(ctx
, 0, 0, 0);
5223 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5224 if (ctx
->is_message
)
5225 check_events(ctx
, FD_OOB
, 0, 200);
5226 check_events(ctx
, 0, 0, 0);
5227 select_events(ctx
, server
, 0);
5228 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5229 if (ctx
->is_message
)
5230 check_events(ctx
, FD_OOB
, 0, 200);
5231 check_events(ctx
, 0, 0, 0);
5233 ret
= send(client
, "b", 1, MSG_OOB
);
5234 ok(ret
== 1, "got %d\n", ret
);
5236 if (!ctx
->is_message
)
5237 check_events_todo_event(ctx
, FD_OOB
, 0, 200);
5238 check_events(ctx
, 0, 0, 0);
5240 ret
= recv(server
, buffer
, 1, MSG_OOB
);
5241 ok(ret
== 1, "got %d\n", ret
);
5243 check_events_todo(ctx
, FD_OOB
, 0, 200);
5244 check_events(ctx
, 0, 0, 0);
5246 ret
= recv(server
, buffer
, 1, MSG_OOB
);
5247 todo_wine
ok(ret
== 1, "got %d\n", ret
);
5249 check_events(ctx
, 0, 0, 0);
5251 /* Send data while we're not selecting. */
5253 select_events(ctx
, server
, 0);
5254 ret
= send(client
, "a", 1, MSG_OOB
);
5255 ok(ret
== 1, "got %d\n", ret
);
5256 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5258 check_events(ctx
, FD_OOB
, 0, 200);
5260 ret
= recv(server
, buffer
, 1, MSG_OOB
);
5261 ok(ret
== 1, "got %d\n", ret
);
5263 closesocket(server
);
5264 closesocket(client
);
5267 static void test_close_events(struct event_test_ctx
*ctx
)
5269 SOCKET server
, client
;
5273 /* Test closesocket(). */
5275 tcp_socketpair(&client
, &server
);
5277 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5279 closesocket(client
);
5281 check_events(ctx
, FD_CLOSE
, 0, 200);
5282 check_events(ctx
, 0, 0, 0);
5283 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5284 if (ctx
->is_message
)
5285 check_events(ctx
, FD_CLOSE
, 0, 200);
5286 check_events(ctx
, 0, 0, 0);
5287 select_events(ctx
, server
, 0);
5288 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5289 if (ctx
->is_message
)
5290 check_events(ctx
, FD_CLOSE
, 0, 200);
5291 check_events(ctx
, 0, 0, 0);
5293 ret
= recv(server
, buffer
, 5, 0);
5294 ok(!ret
, "got %d\n", ret
);
5296 check_events(ctx
, 0, 0, 0);
5298 closesocket(server
);
5300 /* Test shutdown(remote end, SD_SEND). */
5302 tcp_socketpair(&client
, &server
);
5304 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5306 shutdown(client
, SD_SEND
);
5308 check_events(ctx
, FD_CLOSE
, 0, 200);
5309 check_events(ctx
, 0, 0, 0);
5311 closesocket(client
);
5313 check_events(ctx
, 0, 0, 0);
5315 closesocket(server
);
5317 /* No other shutdown() call generates an event. */
5319 tcp_socketpair(&client
, &server
);
5321 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5323 shutdown(client
, SD_RECEIVE
);
5324 shutdown(server
, SD_BOTH
);
5326 check_events(ctx
, 0, 0, 200);
5328 shutdown(client
, SD_SEND
);
5330 check_events_todo(ctx
, FD_CLOSE
, 0, 200);
5331 check_events(ctx
, 0, 0, 0);
5333 closesocket(server
);
5334 closesocket(client
);
5336 /* Test sending data before calling closesocket(). */
5338 tcp_socketpair(&client
, &server
);
5340 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5342 ret
= send(client
, "data", 5, 0);
5343 ok(ret
== 5, "got %d\n", ret
);
5345 check_events(ctx
, FD_READ
, 0, 200);
5347 closesocket(client
);
5349 check_events_todo(ctx
, FD_CLOSE
, 0, 200);
5351 ret
= recv(server
, buffer
, 3, 0);
5352 ok(ret
== 3, "got %d\n", ret
);
5354 check_events(ctx
, FD_READ
, 0, 200);
5356 ret
= recv(server
, buffer
, 5, 0);
5357 ok(ret
== 2, "got %d\n", ret
);
5359 check_events_todo(ctx
, 0, 0, 0);
5361 closesocket(server
);
5363 /* Close and then select. */
5365 tcp_socketpair(&client
, &server
);
5366 closesocket(client
);
5368 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5369 check_events(ctx
, FD_CLOSE
, 0, 200);
5371 closesocket(server
);
5373 /* As above, but select on a subset not containing FD_CLOSE first. */
5375 tcp_socketpair(&client
, &server
);
5377 select_events(ctx
, server
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
);
5379 closesocket(client
);
5381 check_events(ctx
, 0, 0, 200);
5382 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
5383 check_events_todo_event(ctx
, FD_CLOSE
, 0, 200);
5385 closesocket(server
);
5388 static void test_events(void)
5390 struct event_test_ctx ctx
;
5392 ctx
.is_message
= FALSE
;
5393 ctx
.event
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
5395 test_accept_events(&ctx
);
5396 test_connect_events(&ctx
);
5397 test_write_events(&ctx
);
5398 test_read_events(&ctx
);
5399 test_close_events(&ctx
);
5400 test_oob_events(&ctx
);
5402 CloseHandle(ctx
.event
);
5404 ctx
.is_message
= TRUE
;
5405 ctx
.window
= CreateWindowA("Message", NULL
, 0, 0, 0, 0, 0, HWND_MESSAGE
, NULL
, NULL
, NULL
);
5407 test_accept_events(&ctx
);
5408 test_connect_events(&ctx
);
5409 test_write_events(&ctx
);
5410 test_read_events(&ctx
);
5411 test_close_events(&ctx
);
5412 test_oob_events(&ctx
);
5414 DestroyWindow(ctx
.window
);
5417 static void test_ipv6only(void)
5419 SOCKET v4
= INVALID_SOCKET
, v6
;
5420 struct sockaddr_in sin4
;
5421 struct sockaddr_in6 sin6
;
5422 int ret
, enabled
, len
= sizeof(enabled
);
5424 memset(&sin4
, 0, sizeof(sin4
));
5425 sin4
.sin_family
= AF_INET
;
5426 sin4
.sin_port
= htons(SERVERPORT
);
5428 memset(&sin6
, 0, sizeof(sin6
));
5429 sin6
.sin6_family
= AF_INET6
;
5430 sin6
.sin6_port
= htons(SERVERPORT
);
5432 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
5433 if (v6
== INVALID_SOCKET
)
5435 skip("Could not create IPv6 socket (LastError: %d)\n", WSAGetLastError());
5440 ret
= getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
5441 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5442 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
5444 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
5445 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
5447 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5448 ok(v4
!= INVALID_SOCKET
, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
5452 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
5453 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5454 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
5458 len
= sizeof(enabled
);
5459 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
5460 ok(!ret
, "setsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5464 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
5465 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5466 ok(!enabled
, "expected 0, got %d\n", enabled
);
5470 len
= sizeof(enabled
);
5471 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
5472 ok(!ret
, "setsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5474 /* bind on IPv4 socket should succeed - IPV6_V6ONLY is enabled by default */
5475 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
5476 ok(!ret
, "Could not bind IPv4 address (LastError: %d)\n", WSAGetLastError());
5480 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
5481 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5482 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
5486 len
= sizeof(enabled
);
5487 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
5488 ok(ret
, "setsockopt(IPV6_ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
5492 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
5493 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5494 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
5498 len
= sizeof(enabled
);
5499 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
5500 ok(ret
, "setsockopt(IPV6_ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
5505 /* Test again, this time disabling IPV6_V6ONLY. */
5506 sin4
.sin_port
= htons(SERVERPORT
+2);
5507 sin6
.sin6_port
= htons(SERVERPORT
+2);
5509 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
5510 ok(v6
!= INVALID_SOCKET
, "Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
5511 WSAGetLastError(), WSAEAFNOSUPPORT
);
5514 ret
= setsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
5515 ok(!ret
, "Could not disable IPV6_V6ONLY (LastError: %d).\n", WSAGetLastError());
5518 ret
= getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
5519 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5520 ok(!enabled
, "expected 0, got %d\n", enabled
);
5524 On Windows, bind on both IPv4 and IPv6 with IPV6_V6ONLY disabled succeeds by default.
5525 Application must set SO_EXCLUSIVEADDRUSE on first socket to disallow another successful bind.
5526 In general, a standard application should not use SO_REUSEADDR.
5527 Setting both SO_EXCLUSIVEADDRUSE and SO_REUSEADDR on the same socket is not possible in
5528 either order, the later setsockopt call always fails.
5531 ret
= setsockopt(v6
, SOL_SOCKET
, SO_EXCLUSIVEADDRUSE
, (char*)&enabled
, len
);
5532 ok(!ret
, "Could not set SO_EXCLUSIVEADDRUSE on IPv6 socket (LastError: %d)\n", WSAGetLastError());
5534 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
5535 ok(!ret
, "Could not bind IPv6 address (LastError: %d)\n", WSAGetLastError());
5538 len
= sizeof(enabled
);
5539 getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
5540 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5541 ok(!enabled
, "IPV6_V6ONLY is enabled after bind\n");
5543 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5544 ok(v4
!= INVALID_SOCKET
, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
5547 ret
= setsockopt(v4
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&enabled
, len
);
5548 ok(!ret
, "Could not set SO_REUSEADDR on IPv4 socket (LastError: %d)\n", WSAGetLastError());
5550 WSASetLastError(0xdeadbeef);
5551 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
5552 ok(ret
, "bind succeeded unexpectedly for the IPv4 socket\n");
5553 ok(WSAGetLastError() == WSAEACCES
, "Expected 10013, got %d\n", WSAGetLastError());
5556 if (v4
!= INVALID_SOCKET
)
5558 if (v6
!= INVALID_SOCKET
)
5562 static void test_WSASendMsg(void)
5565 struct sockaddr_in sendaddr
, sockaddr
;
5566 GUID WSASendMsg_GUID
= WSAID_WSASENDMSG
;
5567 LPFN_WSASENDMSG pWSASendMsg
= NULL
;
5568 char teststr
[12] = "hello world", buffer
[32];
5571 DWORD bytesSent
, err
;
5574 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
5576 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
5577 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5579 /* Obtain the WSASendMsg function */
5580 WSAIoctl(sock
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSASendMsg_GUID
, sizeof(WSASendMsg_GUID
),
5581 &pWSASendMsg
, sizeof(pWSASendMsg
), &err
, NULL
, NULL
);
5585 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
5589 /* fake address for now */
5590 sendaddr
.sin_family
= AF_INET
;
5591 sendaddr
.sin_port
= htons(139);
5592 sendaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5594 memset(&msg
, 0, sizeof(msg
));
5595 iovec
[0].buf
= teststr
;
5596 iovec
[0].len
= sizeof(teststr
);
5597 iovec
[1].buf
= teststr
;
5598 iovec
[1].len
= sizeof(teststr
) / 2;
5599 msg
.name
= (struct sockaddr
*) &sendaddr
;
5600 msg
.namelen
= sizeof(sendaddr
);
5601 msg
.lpBuffers
= iovec
;
5602 msg
.dwBufferCount
= 1; /* send only one buffer for now */
5604 WSASetLastError(0xdeadbeef);
5605 ret
= pWSASendMsg(INVALID_SOCKET
, &msg
, 0, NULL
, NULL
, NULL
);
5606 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5607 err
= WSAGetLastError();
5608 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
5610 WSASetLastError(0xdeadbeef);
5611 ret
= pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
);
5612 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5613 err
= WSAGetLastError();
5614 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
5616 WSASetLastError(0xdeadbeef);
5617 ret
= pWSASendMsg(sock
, NULL
, 0, &bytesSent
, NULL
, NULL
);
5618 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5619 err
= WSAGetLastError();
5620 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
5622 WSASetLastError(0xdeadbeef);
5623 ret
= pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
);
5624 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5625 err
= WSAGetLastError();
5626 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
5630 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
5631 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5633 dst
= socket(AF_INET
, SOCK_DGRAM
, 0);
5634 ok(dst
!= INVALID_SOCKET
, "socket() failed\n");
5636 memset(&sockaddr
, 0, sizeof(sockaddr
));
5637 sockaddr
.sin_family
= AF_INET
;
5638 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5639 ok(!bind(dst
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
)),
5640 "bind should have worked\n");
5642 /* read address to find out the port number to be used in send */
5643 memset(&sendaddr
, 0, sizeof(sendaddr
));
5644 addrlen
= sizeof(sendaddr
);
5645 ok(!getsockname(dst
, (struct sockaddr
*) &sendaddr
, &addrlen
),
5646 "getsockname should have worked\n");
5647 ok(sendaddr
.sin_port
, "socket port should be != 0\n");
5649 /* ensure the sending socket is not bound */
5650 WSASetLastError(0xdeadbeef);
5651 addrlen
= sizeof(sockaddr
);
5652 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
5653 ok(ret
== SOCKET_ERROR
, "getsockname should have failed\n");
5654 err
= WSAGetLastError();
5655 ok(err
== WSAEINVAL
, "expected 10022, got %d instead\n", err
);
5657 set_blocking(sock
, TRUE
);
5660 SetLastError(0xdeadbeef);
5661 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
5662 ok(!ret
, "WSASendMsg should have worked\n");
5663 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
5664 "Expected 0, got %d\n", GetLastError());
5665 ok(bytesSent
== iovec
[0].len
, "incorrect bytes sent, expected %d, sent %d\n",
5666 iovec
[0].len
, bytesSent
);
5669 addrlen
= sizeof(sockaddr
);
5670 memset(buffer
, 0, sizeof(buffer
));
5671 SetLastError(0xdeadbeef);
5672 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
5673 ok(ret
== bytesSent
, "got %d, expected %d\n",
5675 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5677 /* A successful call to WSASendMsg must have bound the socket */
5678 addrlen
= sizeof(sockaddr
);
5679 sockaddr
.sin_port
= 0;
5680 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5681 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
5682 ok(!ret
, "getsockname should have worked\n");
5683 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
5684 inet_ntoa(sockaddr
.sin_addr
));
5685 ok(sockaddr
.sin_port
, "sin_port should be != 0\n");
5687 msg
.dwBufferCount
= 2; /* send both buffers */
5690 SetLastError(0xdeadbeef);
5691 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
5692 ok(!ret
, "WSASendMsg should have worked\n");
5693 ok(bytesSent
== iovec
[0].len
+ iovec
[1].len
, "incorrect bytes sent, expected %d, sent %d\n",
5694 iovec
[0].len
+ iovec
[1].len
, bytesSent
);
5695 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
5696 "Expected 0, got %d\n", GetLastError());
5699 addrlen
= sizeof(sockaddr
);
5700 memset(buffer
, 0, sizeof(buffer
));
5701 SetLastError(0xdeadbeef);
5702 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
5703 ok(ret
== bytesSent
, "got %d, expected %d\n",
5705 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5710 /* a bad call to WSASendMsg will also bind the socket */
5711 addrlen
= sizeof(sockaddr
);
5712 sockaddr
.sin_port
= 0;
5713 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5714 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
5715 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5716 ok(pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
5718 ok(!getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have worked\n");
5719 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
5720 inet_ntoa(sockaddr
.sin_addr
));
5721 ok(sockaddr
.sin_port
, "sin_port should be > 0\n");
5725 /* a bad call without msg parameter will not trigger the auto-bind */
5726 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
5727 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5728 ok(pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
5729 ok(getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have failed\n");
5730 err
= WSAGetLastError();
5731 ok(err
== WSAEINVAL
, "expected 10022, got %d instead\n", err
);
5734 /* SOCK_STREAM sockets are not supported */
5736 sock
= socket(AF_INET
, SOCK_STREAM
, 0);
5737 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5738 SetLastError(0xdeadbeef);
5739 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
5740 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5741 err
= WSAGetLastError();
5743 ok(err
== WSAEINVAL
, "expected 10014, got %d instead\n", err
);
5747 static void test_WSASendTo(void)
5750 struct sockaddr_in addr
, ret_addr
;
5751 char buf
[12] = "hello world";
5756 addr
.sin_family
= AF_INET
;
5757 addr
.sin_port
= htons(139);
5758 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5759 data_buf
.len
= sizeof(buf
);
5762 s
= socket(AF_INET
, SOCK_DGRAM
, 0);
5763 ok(s
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
5765 WSASetLastError(12345);
5766 ret
= WSASendTo(INVALID_SOCKET
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
5767 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
5768 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
5770 len
= sizeof(ret_addr
);
5771 ret
= getsockname(s
, (struct sockaddr
*)&ret_addr
, &len
);
5772 ok(ret
== -1, "expected failure\n");
5773 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
5775 WSASetLastError(12345);
5776 ret
= WSASendTo(s
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
5777 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
5778 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
5780 WSASetLastError(12345);
5781 ret
= WSASendTo(s
, &data_buf
, 1, &bytesSent
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
5782 ok(!ret
, "expected success\n");
5783 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5785 len
= sizeof(ret_addr
);
5786 ret
= getsockname(s
, (struct sockaddr
*)&ret_addr
, &len
);
5787 ok(!ret
, "got error %u\n", WSAGetLastError());
5788 ok(ret_addr
.sin_family
== AF_INET
, "got family %u\n", ret_addr
.sin_family
);
5789 ok(ret_addr
.sin_port
, "expected nonzero port\n");
5792 static DWORD WINAPI
recv_thread(LPVOID arg
)
5794 SOCKET sock
= *(SOCKET
*)arg
;
5801 wsa
.len
= sizeof(buffer
);
5802 ov
.hEvent
= WSACreateEvent();
5803 WSARecv(sock
, &wsa
, 1, NULL
, &flags
, &ov
, NULL
);
5805 WaitForSingleObject(ov
.hEvent
, 1000);
5806 WSACloseEvent(ov
.hEvent
);
5810 static int completion_called
;
5812 static void WINAPI
io_completion(DWORD error
, DWORD transferred
, WSAOVERLAPPED
*overlapped
, DWORD flags
)
5814 completion_called
++;
5817 static void test_WSARecv(void)
5819 SOCKET src
, dest
, server
= INVALID_SOCKET
;
5823 DWORD bytesReturned
, flags
, id
;
5825 struct sockaddr_in addr
;
5829 HANDLE thread
, event
= NULL
, io_port
;
5831 tcp_socketpair(&src
, &dest
);
5833 memset(&ov
, 0, sizeof(ov
));
5838 /* Send 4 bytes and receive in two calls of 2 */
5839 SetLastError(0xdeadbeef);
5840 iret
= send(src
, "test", 4, 0);
5841 ok(iret
== 4, "Expected 4, got %d\n", iret
);
5842 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5843 SetLastError(0xdeadbeef);
5844 bytesReturned
= 0xdeadbeef;
5845 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
5846 ok(!iret
, "Expected 0, got %d\n", iret
);
5847 ok(bytesReturned
== 2, "Expected 2, got %d\n", bytesReturned
);
5848 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5849 SetLastError(0xdeadbeef);
5850 bytesReturned
= 0xdeadbeef;
5851 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
5852 ok(!iret
, "Expected 0, got %d\n", iret
);
5853 ok(bytesReturned
== 2, "Expected 2, got %d\n", bytesReturned
);
5854 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5857 SetLastError(0xdeadbeef);
5858 iret
= send(src
, "test", 4, 0);
5859 ok(iret
== 4, "Expected 4, got %d\n", iret
);
5860 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5861 SetLastError(0xdeadbeef);
5862 bytesReturned
= 0xdeadbeef;
5863 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
5864 ok(!iret
, "Expected 0, got %d\n", iret
);
5865 ok(bytesReturned
== 4, "Expected 4, got %d\n", bytesReturned
);
5866 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5868 /* Test 2 buffers */
5871 bufs
[1].buf
= buf
+ 10;
5872 SetLastError(0xdeadbeef);
5873 iret
= send(src
, "deadbeefs", 9, 0);
5874 ok(iret
== 9, "Expected 9, got %d\n", iret
);
5875 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5876 SetLastError(0xdeadbeef);
5877 bytesReturned
= 0xdeadbeef;
5878 iret
= WSARecv(dest
, bufs
, 2, &bytesReturned
, &flags
, NULL
, NULL
);
5879 ok(!iret
, "Expected 0, got %d\n", iret
);
5880 ok(bytesReturned
== 9, "Expected 9, got %d\n", bytesReturned
);
5881 bufs
[0].buf
[4] = '\0';
5882 bufs
[1].buf
[5] = '\0';
5883 ok(!strcmp(bufs
[0].buf
, "dead"), "buf[0] doesn't match: %s != dead\n", bufs
[0].buf
);
5884 ok(!strcmp(bufs
[1].buf
, "beefs"), "buf[1] doesn't match: %s != beefs\n", bufs
[1].buf
);
5885 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5887 bufs
[0].len
= sizeof(buf
);
5888 ov
.hEvent
= event
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5889 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
5895 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
5896 ok(!iret
, "Failed to set linger %d\n", GetLastError());
5898 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, NULL
);
5899 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
5901 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
5902 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
5905 src
= INVALID_SOCKET
;
5907 dwret
= WaitForSingleObject(ov
.hEvent
, 1000);
5908 ok(dwret
== WAIT_OBJECT_0
, "Waiting for disconnect event failed with %d + errno %d\n", dwret
, GetLastError());
5910 bret
= GetOverlappedResult((HANDLE
)dest
, &ov
, &bytesReturned
, FALSE
);
5911 todo_wine
ok(!bret
, "expected failure\n");
5912 todo_wine
ok(GetLastError() == ERROR_NETNAME_DELETED
, "got error %u\n", GetLastError());
5913 ok(bytesReturned
== 0, "Bytes received is %d\n", bytesReturned
);
5915 dest
= INVALID_SOCKET
;
5917 src
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
5918 ok(src
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
5919 if (src
== INVALID_SOCKET
) goto end
;
5921 server
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
5922 ok(server
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
5923 if (server
== INVALID_SOCKET
) goto end
;
5925 memset(&addr
, 0, sizeof(addr
));
5926 addr
.sin_family
= AF_INET
;
5927 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5928 iret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
5929 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
5932 iret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
5933 ok(!iret
, "failed to get address, error %u\n", WSAGetLastError());
5935 iret
= listen(server
, 1);
5936 ok(!iret
, "failed to listen, error %u\n", WSAGetLastError());
5938 iret
= connect(src
, (struct sockaddr
*)&addr
, sizeof(addr
));
5939 ok(!iret
, "failed to connect, error %u\n", WSAGetLastError());
5942 dest
= accept(server
, (struct sockaddr
*)&addr
, &len
);
5943 ok(dest
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
5944 if (dest
== INVALID_SOCKET
) goto end
;
5946 send(src
, "test message", sizeof("test message"), 0);
5947 thread
= CreateThread(NULL
, 0, recv_thread
, &dest
, 0, &id
);
5948 WaitForSingleObject(thread
, 3000);
5949 CloseHandle(thread
);
5951 memset(&ov
, 0, sizeof(ov
));
5954 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, io_completion
);
5955 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
5956 send(src
, "test message", sizeof("test message"), 0);
5958 completion_called
= 0;
5959 dwret
= SleepEx(1000, TRUE
);
5960 ok(dwret
== WAIT_IO_COMPLETION
, "got %u\n", dwret
);
5961 ok(completion_called
== 1, "completion not called\n");
5963 dwret
= WaitForSingleObject(event
, 1);
5964 ok(dwret
== WAIT_TIMEOUT
, "got %u\n", dwret
);
5966 io_port
= CreateIoCompletionPort( (HANDLE
)dest
, NULL
, 0, 0 );
5967 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
5969 /* Using completion function on socket associated with completion port is not allowed. */
5970 memset(&ov
, 0, sizeof(ov
));
5971 completion_called
= 0;
5972 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, io_completion
);
5973 ok(iret
== SOCKET_ERROR
&& GetLastError() == WSAEINVAL
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
5974 ok(!completion_called
, "completion called\n");
5976 CloseHandle(io_port
);
5979 if (server
!= INVALID_SOCKET
)
5980 closesocket(server
);
5981 if (dest
!= INVALID_SOCKET
)
5983 if (src
!= INVALID_SOCKET
)
5986 WSACloseEvent(event
);
5989 struct write_watch_thread_args
5998 static DWORD CALLBACK
write_watch_thread( void *arg
)
6000 struct write_watch_thread_args
*args
= arg
;
6001 struct sockaddr addr
;
6002 int addr_len
= sizeof(addr
), ret
;
6003 DWORD bytes
, flags
= 0;
6009 ret
= recv( args
->dest
, args
->base
, args
->size
, 0 );
6010 ok( ret
== strlen(args
->expect
) + 1, "wrong len %d\n", ret
);
6011 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
6014 ret
= recvfrom( args
->dest
, args
->base
, args
->size
, 0, &addr
, &addr_len
);
6015 ok( ret
== strlen(args
->expect
) + 1, "wrong len %d\n", ret
);
6016 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
6019 buf
[0].len
= args
->size
;
6020 buf
[0].buf
= args
->base
;
6021 ret
= WSARecv( args
->dest
, buf
, 1, &bytes
, &flags
, NULL
, NULL
);
6022 ok( !ret
, "WSARecv failed %u\n", GetLastError() );
6023 ok( bytes
== strlen(args
->expect
) + 1, "wrong len %d\n", bytes
);
6024 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
6027 buf
[0].len
= args
->size
;
6028 buf
[0].buf
= args
->base
;
6029 ret
= WSARecvFrom( args
->dest
, buf
, 1, &bytes
, &flags
, &addr
, &addr_len
, NULL
, NULL
);
6030 ok( !ret
, "WSARecvFrom failed %u\n", GetLastError() );
6031 ok( bytes
== strlen(args
->expect
) + 1, "wrong len %d\n", bytes
);
6032 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
6038 static void test_write_watch(void)
6043 struct write_watch_thread_args args
;
6044 DWORD bytesReturned
, flags
, size
;
6045 struct sockaddr addr
;
6047 HANDLE thread
, event
;
6052 UINT (WINAPI
*pGetWriteWatch
)(DWORD
,LPVOID
,SIZE_T
,LPVOID
*,ULONG_PTR
*,ULONG
*);
6054 pGetWriteWatch
= (void *)GetProcAddress( GetModuleHandleA("kernel32.dll"), "GetWriteWatch" );
6055 if (!pGetWriteWatch
)
6057 win_skip( "write watched not supported\n" );
6061 tcp_socketpair(&src
, &dest
);
6063 memset(&ov
, 0, sizeof(ov
));
6064 ov
.hEvent
= event
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
6065 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
6070 base
= VirtualAlloc( 0, size
, MEM_RESERVE
| MEM_COMMIT
| MEM_WRITE_WATCH
, PAGE_READWRITE
);
6071 ok( base
!= NULL
, "VirtualAlloc failed %u\n", GetLastError() );
6073 memset( base
, 0, size
);
6075 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6076 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6077 ok( count
== 16, "wrong count %lu\n", count
);
6081 bufs
[1].len
= 0x8000;
6082 bufs
[1].buf
= base
+ 0x4000;
6084 ret
= WSARecv( dest
, bufs
, 2, NULL
, &flags
, &ov
, NULL
);
6085 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
6086 "WSARecv failed - %d error %d\n", ret
, GetLastError());
6089 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6090 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6091 ok( count
== 9, "wrong count %lu\n", count
);
6092 ok( !base
[0], "data set\n" );
6094 send(src
, "test message", sizeof("test message"), 0);
6096 ret
= GetOverlappedResult( (HANDLE
)dest
, &ov
, &bytesReturned
, TRUE
);
6097 ok( ret
, "GetOverlappedResult failed %u\n", GetLastError() );
6098 ok( bytesReturned
== sizeof("test message"), "wrong size %u\n", bytesReturned
);
6099 ok( !memcmp( base
, "test ", 5 ), "wrong data %s\n", base
);
6100 ok( !memcmp( base
+ 0x4000, "message", 8 ), "wrong data %s\n", base
+ 0x4000 );
6103 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6104 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6105 ok( count
== 0, "wrong count %lu\n", count
);
6107 memset( base
, 0, size
);
6109 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6110 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6111 ok( count
== 16, "wrong count %lu\n", count
);
6113 bufs
[1].len
= 0x4000;
6114 bufs
[1].buf
= base
+ 0x2000;
6115 ret
= WSARecvFrom( dest
, bufs
, 2, NULL
, &flags
, &addr
, &addr_len
, &ov
, NULL
);
6116 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
6117 "WSARecv failed - %d error %d\n", ret
, GetLastError());
6120 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6121 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6122 ok( count
== 5, "wrong count %lu\n", count
);
6123 ok( !base
[0], "data set\n" );
6125 send(src
, "test message", sizeof("test message"), 0);
6127 ret
= GetOverlappedResult( (HANDLE
)dest
, &ov
, &bytesReturned
, TRUE
);
6128 ok( ret
, "GetOverlappedResult failed %u\n", GetLastError() );
6129 ok( bytesReturned
== sizeof("test message"), "wrong size %u\n", bytesReturned
);
6130 ok( !memcmp( base
, "test ", 5 ), "wrong data %s\n", base
);
6131 ok( !memcmp( base
+ 0x2000, "message", 8 ), "wrong data %s\n", base
+ 0x2000 );
6134 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6135 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6136 ok( count
== 0, "wrong count %lu\n", count
);
6138 memset( base
, 0, size
);
6140 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6141 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6142 ok( count
== 16, "wrong count %lu\n", count
);
6147 args
.expect
= "test message";
6148 for (args
.func
= 0; args
.func
< 4; args
.func
++)
6150 thread
= CreateThread( NULL
, 0, write_watch_thread
, &args
, 0, NULL
);
6154 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6155 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6156 ok( count
== 8, "wrong count %lu\n", count
);
6158 send(src
, "test message", sizeof("test message"), 0);
6159 WaitForSingleObject( thread
, 10000 );
6160 CloseHandle( thread
);
6163 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
6164 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
6165 ok( count
== 0, "wrong count %lu\n", count
);
6167 WSACloseEvent( event
);
6168 closesocket( dest
);
6170 VirtualFree( base
, 0, MEM_FREE
);
6173 static void test_WSAPoll(void)
6175 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
6177 SOCKET listener
, server
, client
;
6178 struct sockaddr_in address
;
6180 HANDLE thread_handle
;
6184 static const short invalid_flags
[] =
6185 {POLLERR
, POLLHUP
, POLLNVAL
, 0x8, POLLWRBAND
, 0x40, 0x80, POLLPRI
, 0x800, 0x1000, 0x2000, 0x4000, 0x8000};
6187 if (!pWSAPoll
) /* >= Vista */
6189 win_skip("WSAPoll is unsupported, some tests will be skipped.\n");
6193 /* Invalid parameters test */
6194 SetLastError(0xdeadbeef);
6195 ret
= pWSAPoll(NULL
, 0, 0);
6196 err
= GetLastError();
6197 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6198 ok(err
== WSAEINVAL
, "expected 10022, got %d\n", err
);
6199 SetLastError(0xdeadbeef);
6200 ret
= pWSAPoll(NULL
, 1, 0);
6201 err
= GetLastError();
6202 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6203 ok(err
== WSAEFAULT
, "expected 10014, got %d\n", err
);
6204 SetLastError(0xdeadbeef);
6205 ret
= pWSAPoll(NULL
, 0, 1);
6206 err
= GetLastError();
6207 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6208 ok(err
== WSAEINVAL
, "expected 10022, got %d\n", err
);
6209 SetLastError(0xdeadbeef);
6210 ret
= pWSAPoll(NULL
, 1, 1);
6211 err
= GetLastError();
6212 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6213 ok(err
== WSAEFAULT
, "expected 10014, got %d\n", err
);
6215 memset(&address
, 0, sizeof(address
));
6216 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6217 address
.sin_family
= AF_INET
;
6218 len
= sizeof(address
);
6219 listener
= setup_server_socket(&address
, &len
);
6221 for (i
= 0; i
< ARRAY_SIZE(invalid_flags
); ++i
)
6223 fds
[0].fd
= listener
;
6224 fds
[0].events
= invalid_flags
[i
];
6225 fds
[0].revents
= 0xdead;
6226 WSASetLastError(0xdeadbeef);
6227 ret
= pWSAPoll(fds
, 1, 0);
6228 todo_wine
ok(ret
== -1, "got %d\n", ret
);
6229 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6232 /* When no events are pending poll returns 0 with no error */
6233 fds
[0].fd
= listener
;
6234 fds
[0].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
6235 fds
[0].revents
= 0xdead;
6236 ret
= pWSAPoll(fds
, 1, 0);
6237 ok(ret
== 0, "got %d\n", ret
);
6238 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
6241 fds
[0].events
= POLLERR
;
6242 fds
[0].revents
= 0xdead;
6243 fds
[1].fd
= listener
;
6244 fds
[1].events
= POLLIN
;
6245 fds
[1].revents
= 0xdead;
6246 WSASetLastError(0xdeadbeef);
6247 ret
= pWSAPoll(fds
, 2, 0);
6248 ok(!ret
, "got %d\n", ret
);
6249 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
6250 ok(fds
[0].revents
== POLLNVAL
, "got events %#x\n", fds
[0].revents
);
6251 ok(!fds
[1].revents
, "got events %#x\n", fds
[1].revents
);
6253 fds
[0].fd
= listener
;
6254 fds
[0].events
= POLLIN
;
6255 fds
[0].revents
= 0xdead;
6256 fds
[1].fd
= 0xabacab;
6257 fds
[1].events
= POLLIN
;
6258 fds
[1].revents
= 0xdead;
6259 WSASetLastError(0xdeadbeef);
6260 ret
= pWSAPoll(fds
, 2, 0);
6261 ok(!ret
, "got %d\n", ret
);
6262 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
6263 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
6264 ok(fds
[1].revents
== POLLNVAL
, "got events %#x\n", fds
[1].revents
);
6266 fds
[0].fd
= listener
;
6267 fds
[0].events
= POLLIN
;
6268 fds
[0].revents
= 0xdead;
6269 fds
[1].fd
= 0xabacab;
6270 fds
[1].events
= POLLERR
;
6271 fds
[1].revents
= 0xdead;
6272 WSASetLastError(0xdeadbeef);
6273 ret
= pWSAPoll(fds
, 2, 0);
6274 todo_wine
ok(ret
== -1, "got %d\n", ret
);
6275 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6276 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
6277 todo_wine
ok(!fds
[1].revents
, "got events %#x\n", fds
[1].revents
);
6280 fds
[0].events
= POLLERR
;
6281 fds
[0].revents
= 0xdead;
6282 fds
[1].fd
= 0xabacab;
6283 fds
[1].events
= POLLERR
;
6284 fds
[1].revents
= 0xdead;
6285 WSASetLastError(0xdeadbeef);
6286 ret
= pWSAPoll(fds
, 2, 0);
6287 ok(ret
== -1, "got %d\n", ret
);
6288 ok(WSAGetLastError() == WSAENOTSOCK
, "got error %u\n", WSAGetLastError());
6289 ok(fds
[0].revents
== POLLNVAL
, "got events %#x\n", fds
[0].revents
);
6290 ok(fds
[1].revents
== POLLNVAL
, "got events %#x\n", fds
[1].revents
);
6292 /* Test listening socket connection attempt notifications */
6293 client
= setup_connector_socket(&address
, len
, TRUE
);
6295 fds
[0].fd
= listener
;
6296 fds
[0].events
= POLLIN
;
6297 fds
[0].revents
= 0xdead;
6298 ret
= pWSAPoll(fds
, 1, 100);
6299 ok(ret
== 1, "got %d\n", ret
);
6300 ok(fds
[0].revents
== POLLRDNORM
, "got events %#x\n", fds
[0].revents
);
6302 fds
[0].revents
= 0xdead;
6303 ret
= pWSAPoll(fds
, 1, 0);
6304 ok(ret
== 1, "got %d\n", ret
);
6305 ok(fds
[0].revents
== POLLRDNORM
, "got events %#x\n", fds
[0].revents
);
6307 fds
[0].events
= POLLRDBAND
| POLLWRNORM
;
6308 fds
[0].revents
= 0xdead;
6309 ret
= pWSAPoll(fds
, 1, 0);
6310 ok(ret
== 0, "got %d\n", ret
);
6311 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
6313 server
= accept(listener
, NULL
, NULL
);
6314 ok(server
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
6315 set_blocking(client
, FALSE
);
6316 set_blocking(server
, FALSE
);
6318 for (i
= 0; i
< ARRAY_SIZE(invalid_flags
); ++i
)
6321 fds
[0].events
= invalid_flags
[i
];
6322 fds
[0].revents
= 0xdead;
6323 WSASetLastError(0xdeadbeef);
6324 ret
= pWSAPoll(fds
, 1, 0);
6325 todo_wine
ok(ret
== -1, "got %d\n", ret
);
6326 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6329 /* Test flags exposed by connected sockets. */
6331 fds
[0].fd
= listener
;
6332 fds
[0].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
6333 fds
[0].revents
= 0xdead;
6335 fds
[1].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
6336 fds
[1].revents
= 0xdead;
6338 fds
[2].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
6339 fds
[2].revents
= 0xdead;
6340 ret
= pWSAPoll(fds
, 3, 0);
6341 ok(ret
== 2, "got %d\n", ret
);
6342 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
6343 ok(fds
[1].revents
== POLLWRNORM
, "got events %#x\n", fds
[1].revents
);
6344 ok(fds
[2].revents
== POLLWRNORM
, "got events %#x\n", fds
[2].revents
);
6346 /* Test data receiving notifications */
6348 ret
= send(server
, "1234", 4, 0);
6349 ok(ret
== 4, "got %d\n", ret
);
6351 check_poll_mask(client
, POLLRDNORM
| POLLRDBAND
, POLLRDNORM
);
6352 check_poll(client
, POLLRDNORM
| POLLWRNORM
);
6353 check_poll(server
, POLLWRNORM
);
6355 ret
= sync_recv(client
, buffer
, sizeof(buffer
), 0);
6356 ok(ret
== 4, "got %d\n", ret
);
6358 check_poll(client
, POLLWRNORM
);
6359 check_poll(server
, POLLWRNORM
);
6361 /* Because the kernel asynchronously buffers data, this test is not reliable. */
6365 static const int large_buffer_size
= 1024 * 1024;
6366 char *large_buffer
= malloc(large_buffer_size
);
6368 while (send(server
, large_buffer
, large_buffer_size
, 0) == large_buffer_size
);
6370 check_poll(client
, POLLWRNORM
| POLLRDNORM
);
6371 check_poll(server
, 0);
6373 while (recv(client
, large_buffer
, large_buffer_size
, 0) > 0);
6375 check_poll(client
, POLLWRNORM
);
6376 check_poll(server
, POLLWRNORM
);
6381 /* Test OOB data notifications */
6383 ret
= send(client
, "A", 1, MSG_OOB
);
6384 ok(ret
== 1, "got %d\n", ret
);
6386 check_poll(client
, POLLWRNORM
);
6387 check_poll_mask(server
, POLLRDNORM
| POLLRDBAND
, POLLRDBAND
);
6388 check_poll(server
, POLLWRNORM
| POLLRDBAND
);
6391 ret
= recv(server
, buffer
, 1, MSG_OOB
);
6392 ok(ret
== 1, "got %d\n", ret
);
6393 ok(buffer
[0] == 'A', "got %#x\n", buffer
[0]);
6395 check_poll(client
, POLLWRNORM
);
6396 check_poll(server
, POLLWRNORM
);
6398 /* If the socket is OOBINLINED the notification is like normal data */
6401 ret
= setsockopt(server
, SOL_SOCKET
, SO_OOBINLINE
, (char *)&ret
, sizeof(ret
));
6402 ok(!ret
, "got error %u\n", WSAGetLastError());
6403 ret
= send(client
, "A", 1, MSG_OOB
);
6404 ok(ret
== 1, "got %d\n", ret
);
6406 check_poll(client
, POLLWRNORM
);
6407 check_poll_mask(server
, POLLRDNORM
| POLLRDBAND
, POLLRDNORM
);
6408 check_poll(server
, POLLWRNORM
| POLLRDNORM
);
6411 ret
= recv(server
, buffer
, 1, 0);
6412 ok(ret
== 1, "got %d\n", ret
);
6413 ok(buffer
[0] == 'A', "got %#x\n", buffer
[0]);
6415 check_poll(client
, POLLWRNORM
);
6416 check_poll_todo(server
, POLLWRNORM
);
6418 /* Test shutdown. */
6420 ret
= shutdown(client
, SD_RECEIVE
);
6421 ok(!ret
, "got error %u\n", WSAGetLastError());
6423 check_poll(client
, POLLWRNORM
);
6424 check_poll_todo(server
, POLLWRNORM
);
6426 ret
= shutdown(client
, SD_SEND
);
6427 ok(!ret
, "got error %u\n", WSAGetLastError());
6429 check_poll(client
, POLLWRNORM
);
6430 check_poll_mask_todo(server
, 0, POLLHUP
);
6431 check_poll_todo(server
, POLLWRNORM
| POLLHUP
);
6433 closesocket(client
);
6434 closesocket(server
);
6436 /* Test shutdown via closesocket(). */
6438 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6439 ret
= connect(client
, (struct sockaddr
*)&address
, sizeof(address
));
6440 ok(!ret
, "got error %u\n", WSAGetLastError());
6441 server
= accept(listener
, NULL
, NULL
);
6442 ok(server
!= -1, "got error %u\n", WSAGetLastError());
6444 closesocket(client
);
6446 check_poll_mask(server
, 0, POLLHUP
);
6447 check_poll(server
, POLLWRNORM
| POLLHUP
);
6449 closesocket(server
);
6451 /* Test shutdown with data in the pipe. */
6453 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6454 ret
= connect(client
, (struct sockaddr
*)&address
, sizeof(address
));
6455 ok(!ret
, "got error %u\n", WSAGetLastError());
6456 server
= accept(listener
, NULL
, NULL
);
6457 ok(server
!= -1, "got error %u\n", WSAGetLastError());
6459 ret
= send(client
, "data", 5, 0);
6460 ok(ret
== 5, "got %d\n", ret
);
6462 check_poll(client
, POLLWRNORM
);
6463 check_poll_mask(server
, POLLRDNORM
| POLLRDBAND
, POLLRDNORM
);
6464 check_poll(server
, POLLWRNORM
| POLLRDNORM
);
6466 ret
= shutdown(client
, SD_SEND
);
6468 check_poll(client
, POLLWRNORM
);
6469 check_poll_mask_todo(server
, 0, POLLHUP
);
6470 check_poll_todo(server
, POLLWRNORM
| POLLRDNORM
| POLLHUP
);
6472 closesocket(client
);
6473 closesocket(server
);
6475 /* Test closing a socket while selecting on it. */
6477 tcp_socketpair(&client
, &server
);
6479 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &client
, 0, NULL
);
6481 fds
[0].events
= POLLRDNORM
| POLLRDBAND
;
6482 fds
[0].revents
= 0xdead;
6483 ret
= pWSAPoll(fds
, 1, 2000);
6484 ok(ret
== 1, "got %d\n", ret
);
6485 ok(fds
[0].revents
== POLLNVAL
, "got events %#x\n", fds
[0].revents
);
6486 ret
= WaitForSingleObject(thread_handle
, 1000);
6487 ok(!ret
, "wait failed\n");
6488 CloseHandle(thread_handle
);
6490 closesocket(server
);
6492 /* Test a failed connection.
6494 * The following WSAPoll() call times out on versions older than w10pro64,
6495 * but even on w10pro64 it takes over 2 seconds for an error to be reported,
6496 * so make the test interactive-only. */
6497 if (winetest_interactive
)
6499 const struct sockaddr_in invalid_addr
=
6501 .sin_family
= AF_INET
,
6502 .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
),
6507 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6508 set_blocking(client
, FALSE
);
6510 ret
= connect(client
, (const struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
6511 ok(ret
== -1, "got %d\n", ret
);
6512 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
6515 fds
[0].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
6516 fds
[0].revents
= 0xdead;
6517 ret
= pWSAPoll(fds
, 1, 10000);
6518 todo_wine
ok(ret
== 1, "got %d\n", ret
);
6519 todo_wine
ok(fds
[0].revents
== (POLLWRNORM
| POLLHUP
| POLLERR
), "got events %#x\n", fds
[0].revents
);
6523 ret
= getsockopt(client
, SOL_SOCKET
, SO_ERROR
, (char *)&err
, &len
);
6524 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
6525 ok(err
== WSAECONNREFUSED
, "got error %u\n", err
);
6529 ret
= getsockopt(client
, SOL_SOCKET
, SO_ERROR
, (char *)&err
, &len
);
6530 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
6531 ok(err
== WSAECONNREFUSED
, "got error %u\n", err
);
6533 check_poll_todo(client
, POLLWRNORM
| POLLHUP
| POLLERR
);
6535 closesocket(client
);
6537 /* test polling after a (synchronous) failure */
6539 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6541 ret
= connect(client
, (const struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
6542 ok(ret
== -1, "got %d\n", ret
);
6543 ok(WSAGetLastError() == WSAECONNREFUSED
, "got error %u\n", WSAGetLastError());
6545 check_poll_todo(client
, POLLWRNORM
| POLLHUP
| POLLERR
);
6549 ret
= getsockopt(client
, SOL_SOCKET
, SO_ERROR
, (char *)&err
, &len
);
6550 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
6551 todo_wine
ok(!err
, "got error %u\n", err
);
6553 closesocket(client
);
6556 closesocket(listener
);
6558 /* Test UDP sockets. */
6560 client
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
6561 server
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
6563 check_poll(client
, POLLWRNORM
);
6564 check_poll(server
, POLLWRNORM
);
6566 ret
= bind(client
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
6567 ok(!ret
, "got error %u\n", WSAGetLastError());
6568 len
= sizeof(address
);
6569 ret
= getsockname(client
, (struct sockaddr
*)&address
, &len
);
6570 ok(!ret
, "got error %u\n", WSAGetLastError());
6572 check_poll(client
, POLLWRNORM
);
6573 check_poll(server
, POLLWRNORM
);
6575 ret
= sendto(server
, "data", 5, 0, (struct sockaddr
*)&address
, sizeof(address
));
6576 ok(ret
== 5, "got %d\n", ret
);
6578 check_poll_mask(client
, POLLRDNORM
| POLLRDBAND
, POLLRDNORM
);
6579 check_poll(client
, POLLWRNORM
| POLLRDNORM
);
6580 check_poll(server
, POLLWRNORM
);
6582 closesocket(client
);
6583 closesocket(server
);
6586 static void test_connect(void)
6588 SOCKET listener
= INVALID_SOCKET
;
6589 SOCKET acceptor
= INVALID_SOCKET
;
6590 SOCKET connector
= INVALID_SOCKET
;
6591 struct sockaddr_in address
, conaddress
;
6593 OVERLAPPED overlapped
;
6594 LPFN_CONNECTEX pConnectEx
;
6595 GUID connectExGuid
= WSAID_CONNECTEX
;
6596 DWORD bytesReturned
;
6602 memset(&overlapped
, 0, sizeof(overlapped
));
6604 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
6605 ok(listener
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
6607 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
6608 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
6610 memset(&address
, 0, sizeof(address
));
6611 address
.sin_family
= AF_INET
;
6612 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6613 iret
= bind(listener
, (struct sockaddr
*)&address
, sizeof(address
));
6614 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
6616 addrlen
= sizeof(address
);
6617 iret
= getsockname(listener
, (struct sockaddr
*)&address
, &addrlen
);
6618 ok(!iret
, "failed to get address, error %u\n", WSAGetLastError());
6620 iret
= listen(listener
, 1);
6621 ok(!iret
, "failed to listen, error %u\n", WSAGetLastError());
6623 iret
= set_blocking(listener
, TRUE
);
6624 ok(!iret
, "failed to set nonblocking, error %u\n", WSAGetLastError());
6626 bytesReturned
= 0xdeadbeef;
6627 iret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectExGuid
, sizeof(connectExGuid
),
6628 &pConnectEx
, sizeof(pConnectEx
), &bytesReturned
, NULL
, NULL
);
6629 ok(!iret
, "failed to get ConnectEx, error %u\n", WSAGetLastError());
6631 ok(bytesReturned
== sizeof(pConnectEx
), "expected sizeof(pConnectEx), got %u\n", bytesReturned
);
6633 WSASetLastError(0xdeadbeef);
6634 iret
= connect(listener
, (struct sockaddr
*)&address
, sizeof(address
));
6635 ok(iret
== -1, "got %d\n", iret
);
6636 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6638 WSASetLastError(0xdeadbeef);
6639 overlapped
.Internal
= 0xdeadbeef;
6640 overlapped
.InternalHigh
= 0xdeadbeef;
6641 iret
= pConnectEx(listener
, (struct sockaddr
*)&address
, sizeof(address
), NULL
, 0, &bytesReturned
, &overlapped
);
6642 ok(!iret
, "got %d\n", iret
);
6643 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6644 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
6645 todo_wine
ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
6647 bret
= pConnectEx(INVALID_SOCKET
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
6648 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "ConnectEx on invalid socket "
6649 "returned %d + errno %d\n", bret
, WSAGetLastError());
6651 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
6652 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "ConnectEx on a unbound socket "
6653 "returned %d + errno %d\n", bret
, WSAGetLastError());
6655 /* ConnectEx needs a bound socket */
6656 memset(&conaddress
, 0, sizeof(conaddress
));
6657 conaddress
.sin_family
= AF_INET
;
6658 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6659 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
6660 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
6662 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, NULL
);
6663 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "ConnectEx on a NULL overlapped "
6664 "returned %d + errno %d\n", bret
, WSAGetLastError());
6666 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
6668 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
6669 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
6670 "returned %d + errno %d\n", bret
, WSAGetLastError());
6671 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
6672 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
6674 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
6675 ok(bret
, "Connecting failed, error %d\n", GetLastError());
6676 ok(bytesReturned
== 0, "Bytes sent is %d\n", bytesReturned
);
6678 closesocket(connector
);
6679 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
6680 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
6681 /* ConnectEx needs a bound socket */
6682 memset(&conaddress
, 0, sizeof(conaddress
));
6683 conaddress
.sin_family
= AF_INET
;
6684 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6685 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
6686 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
6688 acceptor
= accept(listener
, NULL
, NULL
);
6689 ok(acceptor
!= INVALID_SOCKET
, "failed to accept socket, error %u\n", WSAGetLastError());
6694 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, buffer
, 3, &bytesReturned
, &overlapped
);
6695 memset(buffer
, 0, 3);
6696 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
6697 "returned %d + errno %d\n", bret
, WSAGetLastError());
6698 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
6699 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
6701 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
6702 ok(bret
, "Connecting failed, error %d\n", GetLastError());
6703 ok(bytesReturned
== 3, "Bytes sent is %d\n", bytesReturned
);
6705 acceptor
= accept(listener
, NULL
, NULL
);
6706 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket error %d\n", WSAGetLastError());
6708 bytesReturned
= recv(acceptor
, buffer
, 3, 0);
6710 ok(bytesReturned
== 3, "Didn't get all sent data, got only %d\n", bytesReturned
);
6711 ok(buffer
[0] == '1' && buffer
[1] == '2' && buffer
[2] == '3',
6712 "Failed to get the right data, expected '123', got '%s'\n", buffer
);
6714 WSASetLastError(0xdeadbeef);
6715 iret
= connect(connector
, (struct sockaddr
*)&address
, sizeof(address
));
6716 ok(iret
== -1, "got %d\n", iret
);
6717 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6719 WSASetLastError(0xdeadbeef);
6720 iret
= connect(acceptor
, (struct sockaddr
*)&address
, sizeof(address
));
6721 ok(iret
== -1, "got %d\n", iret
);
6722 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
6724 WSASetLastError(0xdeadbeef);
6725 overlapped
.Internal
= 0xdeadbeef;
6726 overlapped
.InternalHigh
= 0xdeadbeef;
6727 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, sizeof(address
), NULL
, 0, &bytesReturned
, &overlapped
);
6728 ok(!bret
, "got %d\n", bret
);
6729 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
6730 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
6731 todo_wine
ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
6733 WSASetLastError(0xdeadbeef);
6734 overlapped
.Internal
= 0xdeadbeef;
6735 overlapped
.InternalHigh
= 0xdeadbeef;
6736 bret
= pConnectEx(acceptor
, (struct sockaddr
*)&address
, sizeof(address
), NULL
, 0, &bytesReturned
, &overlapped
);
6737 ok(!bret
, "got %d\n", bret
);
6738 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
6739 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
6740 todo_wine
ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
6742 closesocket(connector
);
6743 closesocket(acceptor
);
6744 closesocket(listener
);
6746 tcp_socketpair(&connector
, &acceptor
);
6748 WSASetLastError(0xdeadbeef);
6749 iret
= connect(connector
, (struct sockaddr
*)&address
, sizeof(address
));
6750 ok(iret
== -1, "got %d\n", iret
);
6751 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
6753 WSASetLastError(0xdeadbeef);
6754 iret
= connect(acceptor
, (struct sockaddr
*)&address
, sizeof(address
));
6755 ok(iret
== -1, "got %d\n", iret
);
6756 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
6758 WSASetLastError(0xdeadbeef);
6759 overlapped
.Internal
= 0xdeadbeef;
6760 overlapped
.InternalHigh
= 0xdeadbeef;
6761 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, sizeof(address
), NULL
, 0, &bytesReturned
, &overlapped
);
6762 ok(!bret
, "got %d\n", bret
);
6763 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
6764 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
6765 todo_wine
ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
6767 WSASetLastError(0xdeadbeef);
6768 overlapped
.Internal
= 0xdeadbeef;
6769 overlapped
.InternalHigh
= 0xdeadbeef;
6770 bret
= pConnectEx(acceptor
, (struct sockaddr
*)&address
, sizeof(address
), NULL
, 0, &bytesReturned
, &overlapped
);
6771 ok(!bret
, "got %d\n", bret
);
6772 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
6773 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
6774 todo_wine
ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
6776 closesocket(connector
);
6777 closesocket(acceptor
);
6779 /* Connect with error */
6781 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
6782 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
6783 /* ConnectEx needs a bound socket */
6784 memset(&conaddress
, 0, sizeof(conaddress
));
6785 conaddress
.sin_family
= AF_INET
;
6786 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6787 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
6788 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
6790 address
.sin_port
= htons(1);
6792 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
6793 ok(bret
== FALSE
&& GetLastError() == ERROR_IO_PENDING
, "ConnectEx to bad destination failed: "
6794 "returned %d + errno %d\n", bret
, GetLastError());
6795 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
6796 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
6798 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
6799 ok(bret
== FALSE
&& GetLastError() == ERROR_CONNECTION_REFUSED
,
6800 "Connecting to a disconnected host returned error %d - %d\n", bret
, WSAGetLastError());
6802 WSACloseEvent(overlapped
.hEvent
);
6803 closesocket(connector
);
6806 static void test_AcceptEx(void)
6808 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
6809 SOCKET listener
, acceptor
, acceptor2
, connector
, connector2
;
6810 struct sockaddr_in bindAddress
, peerAddress
, *readBindAddress
, *readRemoteAddress
;
6811 int socklen
, optlen
;
6812 GUID acceptExGuid
= WSAID_ACCEPTEX
, getAcceptExGuid
= WSAID_GETACCEPTEXSOCKADDRS
;
6813 GUID connectex_guid
= WSAID_CONNECTEX
;
6814 LPFN_ACCEPTEX pAcceptEx
= NULL
;
6815 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs
= NULL
;
6816 LPFN_CONNECTEX pConnectEx
= NULL
;
6817 fd_set fds_accept
, fds_send
;
6818 static const struct timeval timeout
= {1, 0};
6819 DWORD bytesReturned
, connect_time
;
6820 char buffer
[1024], ipbuffer
[32];
6821 OVERLAPPED overlapped
= {0}, overlapped2
= {0};
6822 int iret
, localSize
= sizeof(struct sockaddr_in
), remoteSize
= localSize
;
6826 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
6827 overlapped2
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
6829 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
6830 ok(listener
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
6832 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6833 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
6835 memset(&bindAddress
, 0, sizeof(bindAddress
));
6836 bindAddress
.sin_family
= AF_INET
;
6837 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6838 iret
= bind(listener
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6839 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
6841 socklen
= sizeof(bindAddress
);
6842 iret
= getsockname(listener
, (struct sockaddr
*)&bindAddress
, &socklen
);
6843 ok(!iret
, "failed to get address, error %u\n", WSAGetLastError());
6845 iret
= set_blocking(listener
, FALSE
);
6846 ok(!iret
, "Failed to set nonblocking, error %u\n", WSAGetLastError());
6848 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
6849 &pAcceptEx
, sizeof(pAcceptEx
), &bytesReturned
, NULL
, NULL
);
6850 ok(!iret
, "Failed to get AcceptEx, error %u\n", WSAGetLastError());
6852 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &getAcceptExGuid
, sizeof(getAcceptExGuid
),
6853 &pGetAcceptExSockaddrs
, sizeof(pGetAcceptExSockaddrs
), &bytesReturned
, NULL
, NULL
);
6854 ok(!iret
, "Failed to get GetAcceptExSockaddrs, error %u\n", WSAGetLastError());
6856 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectex_guid
, sizeof(connectex_guid
),
6857 &pConnectEx
, sizeof(pConnectEx
), &bytesReturned
, NULL
, NULL
);
6858 ok(!iret
, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
6860 overlapped
.Internal
= 0xdeadbeef;
6861 bret
= pAcceptEx(INVALID_SOCKET
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6862 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6863 &bytesReturned
, &overlapped
);
6864 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid listening socket "
6865 "returned %d + errno %d\n", bret
, WSAGetLastError());
6866 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6868 overlapped
.Internal
= 0xdeadbeef;
6869 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6870 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6871 &bytesReturned
, &overlapped
);
6873 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on a non-listening socket "
6874 "returned %d + errno %d\n", bret
, WSAGetLastError());
6875 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6876 if (!bret
&& WSAGetLastError() == ERROR_IO_PENDING
)
6877 CancelIo((HANDLE
)listener
);
6879 iret
= listen(listener
, 5);
6880 ok(!iret
, "failed to listen, error %u\n", GetLastError());
6882 overlapped
.Internal
= 0xdeadbeef;
6883 bret
= pAcceptEx(listener
, INVALID_SOCKET
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6884 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6885 &bytesReturned
, &overlapped
);
6886 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid accepting socket "
6887 "returned %d + errno %d\n", bret
, WSAGetLastError());
6888 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6890 overlapped
.Internal
= 0xdeadbeef;
6891 bret
= pAcceptEx(listener
, acceptor
, NULL
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6892 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6893 &bytesReturned
, &overlapped
);
6894 todo_wine
ok(bret
== FALSE
&& WSAGetLastError() == WSAEFAULT
,
6895 "AcceptEx on NULL buffer returned %d + errno %d\n", bret
, WSAGetLastError());
6896 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6898 overlapped
.Internal
= 0xdeadbeef;
6899 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16,
6900 &bytesReturned
, &overlapped
);
6901 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
,
6902 "AcceptEx on too small local address size returned %d + errno %d\n",
6903 bret
, WSAGetLastError());
6904 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6906 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6907 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6908 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6909 ok(!iret
, "failed to connect, error %u\n", WSAGetLastError());
6910 iret
= getsockname(connector
, (struct sockaddr
*)&peerAddress
, &remoteSize
);
6911 ok(!iret
, "getsockname failed, error %u\n", WSAGetLastError());
6913 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6914 ok(!dwret
, "wait failed\n");
6915 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6916 ok(bret
, "got error %u\n", GetLastError());
6917 ok(!(NTSTATUS
)overlapped
.Internal
, "got %#lx\n", overlapped
.Internal
);
6918 ok(!bytesReturned
, "got size %u\n", bytesReturned
);
6920 readBindAddress
= readRemoteAddress
= (struct sockaddr_in
*)0xdeadbeef;
6921 localSize
= remoteSize
= 0xdeadbeef;
6922 pGetAcceptExSockaddrs(buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16,
6923 (struct sockaddr
**)&readBindAddress
, &localSize
, (struct sockaddr
**)&readRemoteAddress
, &remoteSize
);
6924 todo_wine
ok(readBindAddress
== (struct sockaddr_in
*)0xdeadbeef, "got local addr %p\n", readBindAddress
);
6925 ok(!memcmp(readRemoteAddress
, &peerAddress
, sizeof(peerAddress
)), "remote addr didn't match\n");
6926 todo_wine
ok(localSize
== 0xdeadbeef, "got local size %u\n", localSize
);
6927 ok(remoteSize
== sizeof(struct sockaddr_in
), "got remote size %u\n", remoteSize
);
6929 closesocket(connector
);
6930 closesocket(acceptor
);
6932 /* A UDP socket cannot be accepted into. */
6934 acceptor
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
6936 overlapped
.Internal
= 0xdeadbeef;
6937 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
6938 ok(!bret
, "expected failure\n");
6939 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6940 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
6941 if (WSAGetLastError() == ERROR_IO_PENDING
)
6942 CancelIo((HANDLE
)listener
);
6944 closesocket(acceptor
);
6946 /* A bound socket cannot be accepted into. */
6948 acceptor
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6949 iret
= bind(acceptor
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
6950 ok(!iret
, "got error %u\n", WSAGetLastError());
6952 overlapped
.Internal
= 0xdeadbeef;
6953 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
6954 ok(!bret
, "expected failure\n");
6955 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6956 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
6957 if (WSAGetLastError() == ERROR_IO_PENDING
)
6958 CancelIo((HANDLE
)listener
);
6960 closesocket(acceptor
);
6962 /* A connected socket cannot be accepted into. */
6964 tcp_socketpair(&acceptor
, &acceptor2
);
6966 overlapped
.Internal
= 0xdeadbeef;
6967 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
6968 ok(!bret
, "expected failure\n");
6969 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6970 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
6971 if (WSAGetLastError() == ERROR_IO_PENDING
)
6972 CancelIo((HANDLE
)listener
);
6974 overlapped
.Internal
= 0xdeadbeef;
6975 bret
= pAcceptEx(listener
, acceptor2
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
6976 ok(!bret
, "expected failure\n");
6977 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6978 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
6979 if (WSAGetLastError() == ERROR_IO_PENDING
)
6980 CancelIo((HANDLE
)listener
);
6982 closesocket(acceptor
);
6983 closesocket(acceptor2
);
6985 /* Pass an insufficient local address size. */
6987 acceptor
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6988 ok(acceptor
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6990 overlapped
.Internal
= 0xdeadbeef;
6991 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 3,
6992 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
6993 ok(!bret
&& WSAGetLastError() == ERROR_IO_PENDING
, "got %d, error %u\n", bret
, WSAGetLastError());
6994 ok((NTSTATUS
)overlapped
.Internal
== STATUS_PENDING
, "got %#lx\n", overlapped
.Internal
);
6996 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6997 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6998 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6999 ok(!iret
, "failed to connect, error %u\n", WSAGetLastError());
7001 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7002 ok(!dwret
, "wait failed\n");
7003 bytesReturned
= 0xdeadbeef;
7004 SetLastError(0xdeadbeef);
7005 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7006 ok(!bret
, "expected failure\n");
7007 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER
, "got error %u\n", GetLastError());
7008 ok((NTSTATUS
)overlapped
.Internal
== STATUS_BUFFER_TOO_SMALL
, "got %#lx\n", overlapped
.Internal
);
7009 ok(!bytesReturned
, "got size %u\n", bytesReturned
);
7011 closesocket(acceptor
);
7013 /* The above connection request is not accepted. */
7014 acceptor
= accept(listener
, NULL
, NULL
);
7015 todo_wine
ok(acceptor
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
7016 closesocket(acceptor
);
7018 closesocket(connector
);
7020 acceptor
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
7021 ok(acceptor
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
7023 overlapped
.Internal
= 0xdeadbeef;
7024 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 4,
7025 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
7026 ok(!bret
&& WSAGetLastError() == ERROR_IO_PENDING
, "got %d, error %u\n", bret
, WSAGetLastError());
7027 ok((NTSTATUS
)overlapped
.Internal
== STATUS_PENDING
, "got %#lx\n", overlapped
.Internal
);
7029 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
7030 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
7031 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7032 ok(!iret
, "failed to connect, error %u\n", WSAGetLastError());
7034 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7035 ok(!dwret
, "wait failed\n");
7036 bytesReturned
= 0xdeadbeef;
7037 SetLastError(0xdeadbeef);
7038 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7039 todo_wine
ok(!bret
, "expected failure\n");
7040 todo_wine
ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER
, "got error %u\n", GetLastError());
7041 todo_wine
ok((NTSTATUS
)overlapped
.Internal
== STATUS_BUFFER_TOO_SMALL
, "got %#lx\n", overlapped
.Internal
);
7042 ok(!bytesReturned
, "got size %u\n", bytesReturned
);
7044 closesocket(acceptor
);
7046 /* The above connection request is not accepted. */
7047 acceptor
= accept(listener
, NULL
, NULL
);
7048 todo_wine
ok(acceptor
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
7049 closesocket(acceptor
);
7051 closesocket(connector
);
7053 acceptor
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
7054 ok(acceptor
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
7056 overlapped
.Internal
= 0xdeadbeef;
7057 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 15,
7058 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
7059 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx on too small local address "
7060 "size returned %d + errno %d\n",
7061 bret
, WSAGetLastError());
7062 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
7063 bret
= CancelIo((HANDLE
) listener
);
7064 ok(bret
, "Failed to cancel pending accept socket\n");
7066 overlapped
.Internal
= 0xdeadbeef;
7067 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16, 0,
7068 &bytesReturned
, &overlapped
);
7069 ok(bret
== FALSE
&& WSAGetLastError() == WSAEFAULT
,
7070 "AcceptEx on too small remote address size returned %d + errno %d\n", bret
, WSAGetLastError());
7071 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
7073 overlapped
.Internal
= 0xdeadbeef;
7074 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16,
7075 sizeof(struct sockaddr_in
) + 15, &bytesReturned
, &overlapped
);
7076 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
,
7077 "AcceptEx on too small remote address size returned %d + errno %d\n", bret
, WSAGetLastError());
7078 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
7079 bret
= CancelIo((HANDLE
) listener
);
7080 ok(bret
, "Failed to cancel pending accept socket\n");
7082 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
7083 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7084 &bytesReturned
, NULL
);
7085 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
7086 "returned %d + errno %d\n", bret
, WSAGetLastError());
7088 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, 0, &bytesReturned
, NULL
);
7089 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
7090 "returned %d + errno %d\n", bret
, WSAGetLastError());
7092 overlapped
.Internal
= 0xdeadbeef;
7093 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
7094 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7095 &bytesReturned
, &overlapped
);
7096 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7097 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
7099 /* try to accept into the same socket twice */
7100 overlapped
.Internal
= 0xdeadbeef;
7101 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
7102 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7103 &bytesReturned
, &overlapped
);
7104 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
,
7105 "AcceptEx on already pending socket returned %d + errno %d\n", bret
, WSAGetLastError());
7106 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
7108 /* try to connect a socket that's being accepted into */
7109 iret
= connect(acceptor
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7110 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEINVAL
,
7111 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret
, WSAGetLastError());
7113 bret
= pConnectEx(acceptor
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
),
7114 NULL
, 0, &bytesReturned
, &overlapped2
);
7115 ok(!bret
, "expected failure\n");
7116 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
7118 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
7119 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
7120 overlapped
.Internal
= 0xdeadbeef;
7121 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7122 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7124 dwret
= WaitForSingleObject(overlapped
.hEvent
, INFINITE
);
7125 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
7126 ok(overlapped
.Internal
== STATUS_SUCCESS
, "got %08x\n", (ULONG
)overlapped
.Internal
);
7128 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7129 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
7130 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
7132 closesocket(connector
);
7133 connector
= INVALID_SOCKET
;
7134 closesocket(acceptor
);
7136 /* Test short reads */
7138 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7139 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7140 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7141 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7142 overlapped
.Internal
= 0xdeadbeef;
7143 bret
= pAcceptEx(listener
, acceptor
, buffer
, 2,
7144 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7145 &bytesReturned
, &overlapped
);
7146 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7147 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
7149 connect_time
= 0xdeadbeef;
7150 optlen
= sizeof(connect_time
);
7151 iret
= getsockopt(connector
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
7152 ok(!iret
, "getsockopt failed %d\n", WSAGetLastError());
7153 ok(connect_time
== ~0u, "unexpected connect time %u\n", connect_time
);
7155 /* AcceptEx() still won't complete until we send data */
7156 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7157 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7159 connect_time
= 0xdeadbeef;
7160 optlen
= sizeof(connect_time
);
7161 iret
= getsockopt(connector
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
7162 ok(!iret
, "getsockopt failed %d\n", WSAGetLastError());
7163 ok(connect_time
< 0xdeadbeef, "unexpected connect time %u\n", connect_time
);
7165 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
7166 ok(dwret
== WAIT_TIMEOUT
, "Waiting for accept event timeout failed with %d + errno %d\n", dwret
, GetLastError());
7167 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
7169 iret
= getsockname( connector
, (struct sockaddr
*)&peerAddress
, &remoteSize
);
7170 ok( !iret
, "getsockname failed.\n");
7172 /* AcceptEx() could complete any time now */
7173 iret
= send(connector
, buffer
, 1, 0);
7174 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
7176 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7177 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
7178 ok(overlapped
.Internal
== STATUS_SUCCESS
, "got %08x\n", (ULONG
)overlapped
.Internal
);
7180 /* Check if the buffer from AcceptEx is decoded correctly */
7181 pGetAcceptExSockaddrs(buffer
, 2, sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7182 (struct sockaddr
**)&readBindAddress
, &localSize
,
7183 (struct sockaddr
**)&readRemoteAddress
, &remoteSize
);
7184 strcpy( ipbuffer
, inet_ntoa(readBindAddress
->sin_addr
));
7185 ok( readBindAddress
->sin_addr
.s_addr
== bindAddress
.sin_addr
.s_addr
,
7186 "Local socket address is different %s != %s\n",
7187 ipbuffer
, inet_ntoa(bindAddress
.sin_addr
));
7188 ok( readBindAddress
->sin_port
== bindAddress
.sin_port
,
7189 "Local socket port is different: %d != %d\n",
7190 readBindAddress
->sin_port
, bindAddress
.sin_port
);
7191 strcpy( ipbuffer
, inet_ntoa(readRemoteAddress
->sin_addr
));
7192 ok( readRemoteAddress
->sin_addr
.s_addr
== peerAddress
.sin_addr
.s_addr
,
7193 "Remote socket address is different %s != %s\n",
7194 ipbuffer
, inet_ntoa(peerAddress
.sin_addr
));
7195 ok( readRemoteAddress
->sin_port
== peerAddress
.sin_port
,
7196 "Remote socket port is different: %d != %d\n",
7197 readRemoteAddress
->sin_port
, peerAddress
.sin_port
);
7199 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7200 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
7201 ok(bytesReturned
== 1, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
7203 closesocket(connector
);
7204 connector
= INVALID_SOCKET
;
7205 closesocket(acceptor
);
7207 /* Test CF_DEFER & AcceptEx interaction */
7209 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7210 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7211 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7212 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7213 connector2
= socket(AF_INET
, SOCK_STREAM
, 0);
7214 ok(connector2
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7216 iret
= set_blocking(connector
, FALSE
);
7217 ok(!iret
, "failed to set nonblocking, error %u\n", GetLastError());
7218 iret
= set_blocking(connector2
, FALSE
);
7219 ok(!iret
, "failed to set nonblocking, error %u\n", GetLastError());
7221 /* Connect socket #1 */
7222 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7223 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7227 FD_ZERO(&fds_accept
);
7228 FD_SET(listener
, &fds_accept
);
7229 iret
= select(0, &fds_accept
, NULL
, NULL
, &timeout
);
7230 ok(iret
== 1, "wait timed out\n");
7232 acceptor2
= WSAAccept(listener
, NULL
, NULL
, AlwaysDeferConditionFunc
, 0);
7233 ok(acceptor2
== INVALID_SOCKET
, "expected failure\n");
7234 ok(WSAGetLastError() == WSATRY_AGAIN
, "got error %u\n", WSAGetLastError());
7235 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16,
7236 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
7237 ok(!bret
, "expected failure\n");
7238 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
7241 FD_SET(connector
, &fds_send
);
7242 iret
= select(0, NULL
, &fds_send
, NULL
, &timeout
);
7243 ok(iret
== 1, "wait timed out\n");
7245 iret
= send(connector
, "1", 1, 0);
7246 ok(iret
== 1, "got ret %d, error %u\n", iret
, WSAGetLastError());
7248 iret
= connect(connector2
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7249 ok(iret
== SOCKET_ERROR
, "expected failure\n");
7250 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
7252 iret
= select(0, &fds_accept
, NULL
, NULL
, &timeout
);
7253 ok(iret
== 1, "wait timed out\n");
7255 acceptor2
= accept(listener
, NULL
, NULL
);
7256 ok(acceptor2
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
7257 closesocket(acceptor2
);
7260 FD_SET(connector2
, &fds_send
);
7261 iret
= select(0, NULL
, &fds_send
, NULL
, &timeout
);
7262 ok(iret
== 1, "wait timed out\n");
7264 iret
= send(connector2
, "2", 1, 0);
7265 ok(iret
== 1, "got ret %d, error %u\n", iret
, WSAGetLastError());
7267 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
7268 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
7270 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7271 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
7272 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
7274 set_blocking(acceptor
, TRUE
);
7275 iret
= recv( acceptor
, buffer
, 2, 0);
7276 ok(iret
== 1, "Failed to get data, %d, errno: %d\n", iret
, WSAGetLastError());
7277 ok(buffer
[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer
[0]);
7279 closesocket(connector
);
7280 closesocket(connector2
);
7281 closesocket(acceptor
);
7283 /* clean up in case of failures */
7284 while ((acceptor
= accept(listener
, NULL
, NULL
)) != INVALID_SOCKET
)
7285 closesocket(acceptor
);
7287 /* Disconnect during receive? */
7289 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7290 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7291 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7292 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7293 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7294 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7295 &bytesReturned
, &overlapped
);
7296 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7298 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7299 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7301 closesocket(connector
);
7302 connector
= INVALID_SOCKET
;
7304 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7305 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
7307 bytesReturned
= 123456;
7308 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7309 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
7310 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
7312 closesocket(acceptor
);
7314 /* Test closing with pending requests */
7316 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7317 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7318 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7319 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7320 &bytesReturned
, &overlapped
);
7321 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7323 closesocket(acceptor
);
7325 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7326 ok(dwret
== WAIT_OBJECT_0
,
7327 "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
7328 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7329 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
7331 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7332 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7333 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7334 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7335 &bytesReturned
, &overlapped
);
7336 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7338 CancelIo((HANDLE
) acceptor
);
7340 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7341 ok(dwret
== WAIT_TIMEOUT
, "Waiting for timeout failed with %d + errno %d\n", dwret
, GetLastError());
7343 closesocket(acceptor
);
7345 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7346 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7347 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7348 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7349 &bytesReturned
, &overlapped
);
7350 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7352 closesocket(listener
);
7354 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7355 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
7357 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7358 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
7360 CloseHandle(overlapped
.hEvent
);
7361 CloseHandle(overlapped2
.hEvent
);
7362 closesocket(acceptor
);
7363 closesocket(connector2
);
7366 static void test_shutdown(void)
7368 struct sockaddr_in addr
, server_addr
, client_addr
;
7369 SOCKET listener
, client
, server
;
7370 OVERLAPPED overlapped
= {0};
7371 DWORD size
, flags
= 0;
7376 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
7377 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
7378 ok(listener
!= INVALID_SOCKET
, "failed to create listener socket, error %d\n", WSAGetLastError());
7380 memset(&addr
, 0, sizeof(addr
));
7381 addr
.sin_family
= AF_INET
;
7382 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7383 ret
= bind(listener
, (struct sockaddr
*)&addr
, sizeof(addr
));
7384 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
7385 addrlen
= sizeof(server_addr
);
7386 ret
= getsockname(listener
, (struct sockaddr
*)&server_addr
, &addrlen
);
7387 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
7389 ret
= listen(listener
, 1);
7390 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
7392 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
7393 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
7395 WSASetLastError(0xdeadbeef);
7396 ret
= shutdown(client
, SD_SEND
);
7397 ok(ret
== -1, "expected failure\n");
7398 ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
7400 WSASetLastError(0xdeadbeef);
7401 ret
= shutdown(client
, SD_RECEIVE
);
7402 ok(ret
== -1, "expected failure\n");
7403 ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
7405 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7406 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
7407 server
= accept(listener
, NULL
, NULL
);
7408 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
7409 set_blocking(client
, FALSE
);
7411 WSASetLastError(0xdeadbeef);
7412 ret
= shutdown(client
, SD_SEND
);
7413 ok(!ret
, "expected success\n");
7414 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7416 WSASetLastError(0xdeadbeef);
7417 ret
= shutdown(client
, SD_SEND
);
7418 ok(!ret
, "expected success\n");
7419 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7421 WSASetLastError(0xdeadbeef);
7422 ret
= send(client
, "test", 5, 0);
7423 ok(ret
== -1, "got %d\n", ret
);
7424 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7426 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
7427 ok(!ret
, "got %d\n", ret
);
7428 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
7429 ok(!ret
, "got %d\n", ret
);
7431 WSASetLastError(0xdeadbeef);
7432 ret
= shutdown(server
, SD_RECEIVE
);
7433 ok(!ret
, "expected success\n");
7434 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7436 WSASetLastError(0xdeadbeef);
7437 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
7438 todo_wine
ok(ret
== -1, "got %d\n", ret
);
7439 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7441 ret
= send(server
, "test", 5, 0);
7442 ok(ret
== 5, "got %d\n", ret
);
7444 ret
= sync_recv(client
, buffer
, sizeof(buffer
), 0);
7445 ok(ret
== 5, "got %d\n", ret
);
7446 ok(!strcmp(buffer
, "test"), "got %s\n", debugstr_an(buffer
, ret
));
7448 WSASetLastError(0xdeadbeef);
7449 ret
= shutdown(client
, SD_RECEIVE
);
7450 ok(!ret
, "expected success\n");
7451 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7453 WSASetLastError(0xdeadbeef);
7454 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
7455 ok(ret
== -1, "got %d\n", ret
);
7456 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7458 WSASetLastError(0xdeadbeef);
7459 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
7460 ok(ret
== -1, "got %d\n", ret
);
7461 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7463 WSASetLastError(0xdeadbeef);
7464 ret
= shutdown(server
, SD_SEND
);
7465 ok(!ret
, "expected success\n");
7466 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7468 WSASetLastError(0xdeadbeef);
7469 ret
= send(server
, "test", 5, 0);
7470 ok(ret
== -1, "got %d\n", ret
);
7471 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7473 addrlen
= sizeof(addr
);
7474 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &addrlen
);
7475 todo_wine
ok(!ret
, "got error %u\n", WSAGetLastError());
7476 todo_wine
ok(!memcmp(&addr
, &server_addr
, sizeof(server_addr
)), "address didn't match\n");
7478 addrlen
= sizeof(client_addr
);
7479 ret
= getsockname(client
, (struct sockaddr
*)&client_addr
, &addrlen
);
7480 ok(!ret
, "got error %u\n", WSAGetLastError());
7481 addrlen
= sizeof(addr
);
7482 ret
= getpeername(server
, (struct sockaddr
*)&addr
, &addrlen
);
7483 todo_wine
ok(!ret
, "got error %u\n", WSAGetLastError());
7484 todo_wine
ok(!memcmp(&addr
, &client_addr
, sizeof(addr
)), "address didn't match\n");
7486 WSASetLastError(0xdeadbeef);
7487 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7488 ok(ret
== -1, "got %d\n", ret
);
7489 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
7491 WSASetLastError(0xdeadbeef);
7492 ret
= shutdown(client
, 0xdeadbeef);
7493 ok(ret
== -1, "expected failure\n");
7494 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
7496 closesocket(client
);
7497 closesocket(server
);
7501 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
7502 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
7503 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7504 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
7505 server
= accept(listener
, NULL
, NULL
);
7506 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
7508 WSASetLastError(0xdeadbeef);
7509 ret
= shutdown(client
, SD_BOTH
);
7510 ok(!ret
, "expected success\n");
7511 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7513 WSASetLastError(0xdeadbeef);
7514 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
7515 ok(ret
== -1, "got %d\n", ret
);
7516 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7518 WSASetLastError(0xdeadbeef);
7519 ret
= send(client
, "test", 5, 0);
7520 ok(ret
== -1, "got %d\n", ret
);
7521 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7523 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
7524 ok(!ret
, "got %d\n", ret
);
7526 WSASetLastError(0xdeadbeef);
7527 ret
= shutdown(server
, SD_BOTH
);
7528 ok(!ret
, "expected success\n");
7529 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7531 WSASetLastError(0xdeadbeef);
7532 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
7533 todo_wine
ok(ret
== -1, "got %d\n", ret
);
7534 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7536 WSASetLastError(0xdeadbeef);
7537 ret
= send(server
, "test", 5, 0);
7538 ok(ret
== -1, "got %d\n", ret
);
7539 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7541 addrlen
= sizeof(addr
);
7542 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &addrlen
);
7543 todo_wine
ok(!ret
, "got error %u\n", WSAGetLastError());
7544 todo_wine
ok(!memcmp(&addr
, &server_addr
, sizeof(server_addr
)), "address didn't match\n");
7546 addrlen
= sizeof(client_addr
);
7547 ret
= getsockname(client
, (struct sockaddr
*)&client_addr
, &addrlen
);
7548 ok(!ret
, "got error %u\n", WSAGetLastError());
7549 addrlen
= sizeof(addr
);
7550 ret
= getpeername(server
, (struct sockaddr
*)&addr
, &addrlen
);
7551 todo_wine
ok(!ret
, "got error %u\n", WSAGetLastError());
7552 todo_wine
ok(!memcmp(&addr
, &client_addr
, sizeof(addr
)), "address didn't match\n");
7554 closesocket(client
);
7555 closesocket(server
);
7557 /* Test shutting down with async I/O pending. */
7559 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
7560 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
7561 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7562 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
7563 server
= accept(listener
, NULL
, NULL
);
7564 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
7565 set_blocking(client
, FALSE
);
7567 wsabuf
.buf
= buffer
;
7568 wsabuf
.len
= sizeof(buffer
);
7569 WSASetLastError(0xdeadbeef);
7570 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
7571 ok(ret
== -1, "got %d\n", ret
);
7572 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
7574 ret
= shutdown(client
, SD_RECEIVE
);
7575 ok(!ret
, "got error %u\n", WSAGetLastError());
7577 WSASetLastError(0xdeadbeef);
7578 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, NULL
, NULL
);
7579 ok(ret
== -1, "got %d\n", ret
);
7580 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7582 ret
= send(server
, "test", 5, 0);
7583 ok(ret
== 5, "got %d\n", ret
);
7585 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7586 ok(!ret
, "wait timed out\n");
7588 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
7589 ok(ret
, "got error %u\n", GetLastError());
7590 ok(size
== 5, "got size %u\n", size
);
7591 ok(!strcmp(buffer
, "test"), "got %s\n", debugstr_an(buffer
, size
));
7593 WSASetLastError(0xdeadbeef);
7594 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
7595 ok(ret
== -1, "got %d\n", ret
);
7596 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7598 WSASetLastError(0xdeadbeef);
7599 ret
= WSARecv(server
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
7600 ok(ret
== -1, "got %d\n", ret
);
7601 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
7603 ret
= shutdown(client
, SD_SEND
);
7604 ok(!ret
, "got error %u\n", WSAGetLastError());
7606 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7607 ok(!ret
, "wait timed out\n");
7609 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
7610 ok(ret
, "got error %u\n", GetLastError());
7611 ok(!size
, "got size %u\n", size
);
7613 closesocket(client
);
7614 closesocket(server
);
7616 /* Test shutting down a listening socket. */
7618 WSASetLastError(0xdeadbeef);
7619 ret
= shutdown(listener
, SD_SEND
);
7620 ok(ret
== -1, "expected failure\n");
7621 ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
7623 WSASetLastError(0xdeadbeef);
7624 ret
= shutdown(listener
, SD_RECEIVE
);
7625 ok(ret
== -1, "expected failure\n");
7626 ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
7628 closesocket(listener
);
7630 /* Test shutting down UDP sockets. */
7632 client
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
7633 server
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
7634 memset(&addr
, 0, sizeof(addr
));
7635 addr
.sin_family
= AF_INET
;
7636 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7637 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
7638 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
7639 addrlen
= sizeof(server_addr
);
7640 ret
= getsockname(server
, (struct sockaddr
*)&server_addr
, &addrlen
);
7641 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
7642 set_blocking(server
, FALSE
);
7644 WSASetLastError(0xdeadbeef);
7645 ret
= shutdown(server
, SD_RECEIVE
);
7646 ok(!ret
, "expected success\n");
7647 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7649 WSASetLastError(0xdeadbeef);
7650 ret
= recvfrom(server
, buffer
, sizeof(buffer
), 0, NULL
, NULL
);
7651 ok(ret
== -1, "got %d\n", ret
);
7652 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7654 ret
= sendto(client
, "test", 5, 0, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7655 ok(ret
== 5, "got %d\n", ret
);
7657 WSASetLastError(0xdeadbeef);
7658 ret
= shutdown(client
, SD_SEND
);
7659 ok(!ret
, "expected success\n");
7660 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7662 WSASetLastError(0xdeadbeef);
7663 ret
= shutdown(client
, SD_SEND
);
7664 ok(!ret
, "expected success\n");
7665 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7667 WSASetLastError(0xdeadbeef);
7668 ret
= sendto(client
, "test", 5, 0, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7669 ok(ret
== -1, "got %d\n", ret
);
7670 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7672 closesocket(client
);
7673 closesocket(server
);
7675 CloseHandle(overlapped
.hEvent
);
7678 static void test_DisconnectEx(void)
7680 struct sockaddr_in server_addr
, client_addr
, addr
;
7681 GUID disconnectex_guid
= WSAID_DISCONNECTEX
;
7682 SOCKET listener
, server
, client
;
7683 LPFN_DISCONNECTEX pDisconnectEx
;
7684 OVERLAPPED overlapped
= {0};
7689 overlapped
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
7691 client
= socket(AF_INET
, SOCK_STREAM
, 0);
7692 ok(client
!= INVALID_SOCKET
, "failed to create connector socket, error %u\n", WSAGetLastError());
7694 ret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &disconnectex_guid
, sizeof(disconnectex_guid
),
7695 &pDisconnectEx
, sizeof(pDisconnectEx
), &size
, NULL
, NULL
);
7698 win_skip("WSAIoctl failed to get DisconnectEx, error %d\n", WSAGetLastError());
7699 closesocket(client
);
7703 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
7704 ok(listener
!= INVALID_SOCKET
, "failed to create listener socket, error %d\n", WSAGetLastError());
7706 memset(&addr
, 0, sizeof(addr
));
7707 addr
.sin_family
= AF_INET
;
7708 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7709 ret
= bind(listener
, (struct sockaddr
*)&addr
, sizeof(addr
));
7710 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
7711 addrlen
= sizeof(server_addr
);
7712 ret
= getsockname(listener
, (struct sockaddr
*)&server_addr
, &addrlen
);
7713 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
7714 ret
= listen(listener
, 1);
7715 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
7717 WSASetLastError(0xdeadbeef);
7718 ret
= pDisconnectEx(INVALID_SOCKET
, &overlapped
, 0, 0);
7719 ok(!ret
, "expected failure\n");
7720 ok(WSAGetLastError() == WSAENOTSOCK
, "got error %u\n", WSAGetLastError());
7722 WSASetLastError(0xdeadbeef);
7723 ret
= pDisconnectEx(client
, &overlapped
, 0, 0);
7724 ok(!ret
, "expected failure\n");
7725 ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
7727 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7728 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
7729 server
= accept(listener
, NULL
, NULL
);
7730 ok(server
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
7732 WSASetLastError(0xdeadbeef);
7733 ret
= pDisconnectEx(client
, &overlapped
, 0, 0);
7734 ok(!ret
, "expected failure\n");
7735 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
7737 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7738 ok(!ret
, "wait timed out\n");
7740 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
7741 ok(ret
, "got error %u\n", GetLastError());
7742 ok(!size
, "got size %u\n", size
);
7744 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7745 ok(ret
== -1, "expected failure\n");
7746 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
7748 WSASetLastError(0xdeadbeef);
7749 ret
= send(client
, "test", 5, 0);
7750 ok(ret
== -1, "expected failure\n");
7751 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7753 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
7754 ok(!ret
, "got %d\n", ret
);
7756 ret
= send(server
, "test", 5, 0);
7757 ok(ret
== 5, "got %d\n", ret
);
7759 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
7760 ok(ret
== 5, "got %d\n", ret
);
7761 ok(!strcmp(buffer
, "test"), "got %s\n", debugstr_an(buffer
, ret
));
7763 addrlen
= sizeof(addr
);
7764 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &addrlen
);
7765 ok(!ret
, "got error %u\n", WSAGetLastError());
7766 ok(!memcmp(&addr
, &server_addr
, sizeof(server_addr
)), "address didn't match\n");
7768 addrlen
= sizeof(client_addr
);
7769 ret
= getsockname(client
, (struct sockaddr
*)&client_addr
, &addrlen
);
7770 ok(!ret
, "got error %u\n", WSAGetLastError());
7771 addrlen
= sizeof(addr
);
7772 ret
= getpeername(server
, (struct sockaddr
*)&addr
, &addrlen
);
7773 ok(!ret
, "got error %u\n", WSAGetLastError());
7774 ok(!memcmp(&addr
, &client_addr
, sizeof(addr
)), "address didn't match\n");
7776 closesocket(client
);
7777 closesocket(server
);
7779 /* Test the synchronous case. */
7781 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
7782 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
7783 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7784 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
7785 server
= accept(listener
, NULL
, NULL
);
7786 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
7788 WSASetLastError(0xdeadbeef);
7789 ret
= pDisconnectEx(client
, NULL
, 0, 0);
7790 ok(ret
, "expected success\n");
7791 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7793 WSASetLastError(0xdeadbeef);
7794 ret
= pDisconnectEx(client
, NULL
, 0, 0);
7795 ok(ret
, "expected success\n");
7796 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7798 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
7799 ok(ret
== -1, "expected failure\n");
7800 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
7802 WSASetLastError(0xdeadbeef);
7803 ret
= send(client
, "test", 5, 0);
7804 ok(ret
== -1, "expected failure\n");
7805 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
7807 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
7808 ok(!ret
, "got %d\n", ret
);
7810 ret
= send(server
, "test", 5, 0);
7811 ok(ret
== 5, "got %d\n", ret
);
7813 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
7814 ok(ret
== 5, "got %d\n", ret
);
7815 ok(!strcmp(buffer
, "test"), "got %s\n", debugstr_an(buffer
, ret
));
7817 addrlen
= sizeof(addr
);
7818 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &addrlen
);
7819 ok(!ret
, "got error %u\n", WSAGetLastError());
7820 ok(!memcmp(&addr
, &server_addr
, sizeof(server_addr
)), "address didn't match\n");
7822 addrlen
= sizeof(client_addr
);
7823 ret
= getsockname(client
, (struct sockaddr
*)&client_addr
, &addrlen
);
7824 ok(!ret
, "got error %u\n", WSAGetLastError());
7825 addrlen
= sizeof(addr
);
7826 ret
= getpeername(server
, (struct sockaddr
*)&addr
, &addrlen
);
7827 ok(!ret
, "got error %u\n", WSAGetLastError());
7828 ok(!memcmp(&addr
, &client_addr
, sizeof(addr
)), "address didn't match\n");
7830 closesocket(client
);
7831 closesocket(server
);
7833 closesocket(listener
);
7834 CloseHandle(overlapped
.hEvent
);
7837 #define compare_file(h,s,o) compare_file2(h,s,o,__FILE__,__LINE__)
7839 static void compare_file2(HANDLE handle
, SOCKET sock
, int offset
, const char *file
, int line
)
7841 char buf1
[256], buf2
[256];
7845 SetFilePointer(handle
, offset
, NULL
, FILE_BEGIN
);
7848 DWORD n1
= 0, n2
= 0;
7850 success
= ReadFile(handle
, buf1
, sizeof(buf1
), &n1
, NULL
);
7851 ok_(file
,line
)(success
, "Failed to read from file.\n");
7852 if (success
&& n1
== 0)
7856 n2
= recv(sock
, buf2
, n1
, 0);
7857 ok_(file
,line
)(n1
== n2
, "Block %d size mismatch (%d != %d)\n", i
, n1
, n2
);
7858 ok_(file
,line
)(memcmp(buf1
, buf2
, n2
) == 0, "Block %d failed\n", i
);
7863 static void test_TransmitFile(void)
7865 DWORD num_bytes
, err
, file_size
, total_sent
;
7866 GUID transmitFileGuid
= WSAID_TRANSMITFILE
;
7867 LPFN_TRANSMITFILE pTransmitFile
= NULL
;
7868 HANDLE file
= INVALID_HANDLE_VALUE
;
7869 char header_msg
[] = "hello world";
7870 char footer_msg
[] = "goodbye!!!";
7871 char system_ini_path
[MAX_PATH
];
7872 struct sockaddr_in bindAddress
;
7873 TRANSMIT_FILE_BUFFERS buffers
;
7874 SOCKET client
, server
, dest
;
7880 memset( &ov
, 0, sizeof(ov
) );
7882 /* Setup sockets for testing TransmitFile */
7883 client
= socket(AF_INET
, SOCK_STREAM
, 0);
7884 ok(client
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7885 server
= socket(AF_INET
, SOCK_STREAM
, 0);
7886 ok(server
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
7887 iret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &transmitFileGuid
, sizeof(transmitFileGuid
),
7888 &pTransmitFile
, sizeof(pTransmitFile
), &num_bytes
, NULL
, NULL
);
7889 ok(!iret
, "failed to get TransmitFile, error %u\n", GetLastError());
7890 GetSystemWindowsDirectoryA(system_ini_path
, MAX_PATH
);
7891 strcat(system_ini_path
, "\\system.ini");
7892 file
= CreateFileA(system_ini_path
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_ALWAYS
, 0x0, NULL
);
7893 ok(file
!= INVALID_HANDLE_VALUE
, "failed to open file, error %u\n", GetLastError());
7894 file_size
= GetFileSize(file
, NULL
);
7896 /* Test TransmitFile with an invalid socket */
7897 bret
= pTransmitFile(INVALID_SOCKET
, file
, 0, 0, NULL
, NULL
, 0);
7898 err
= WSAGetLastError();
7899 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
7900 ok(err
== WSAENOTSOCK
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTSOCK
);
7902 /* Test a bogus TransmitFile without a connected socket */
7903 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, TF_REUSE_SOCKET
);
7904 err
= WSAGetLastError();
7905 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
7906 ok(err
== WSAENOTCONN
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTCONN
);
7908 /* Setup a properly connected socket for transfers */
7909 memset(&bindAddress
, 0, sizeof(bindAddress
));
7910 bindAddress
.sin_family
= AF_INET
;
7911 bindAddress
.sin_port
= htons(SERVERPORT
+1);
7912 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7913 iret
= bind(server
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7914 ok(!iret
, "failed to bind socket, error %u\n", GetLastError());
7915 iret
= listen(server
, 1);
7916 ok(!iret
, "failed to listen, error %u\n", GetLastError());
7917 iret
= connect(client
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7918 ok(!iret
, "failed to connect, error %u\n", GetLastError());
7919 len
= sizeof(bindAddress
);
7920 dest
= accept(server
, (struct sockaddr
*)&bindAddress
, &len
);
7921 ok(dest
!= INVALID_SOCKET
, "failed to accept, error %u\n", GetLastError());
7922 iret
= set_blocking(dest
, FALSE
);
7923 ok(!iret
, "failed to set nonblocking, error %u\n", GetLastError());
7925 /* Test TransmitFile with no possible buffer */
7926 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, 0);
7927 ok(bret
, "TransmitFile failed unexpectedly.\n");
7928 iret
= recv(dest
, buf
, sizeof(buf
), 0);
7929 ok(iret
== -1, "Returned an unexpected buffer from TransmitFile (%d != -1).\n", iret
);
7931 /* Test TransmitFile with only buffer data */
7932 buffers
.Head
= &header_msg
[0];
7933 buffers
.HeadLength
= sizeof(header_msg
);
7934 buffers
.Tail
= &footer_msg
[0];
7935 buffers
.TailLength
= sizeof(footer_msg
);
7936 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, &buffers
, 0);
7937 ok(bret
, "TransmitFile failed unexpectedly.\n");
7938 iret
= recv(dest
, buf
, sizeof(buf
), 0);
7939 ok(iret
== sizeof(header_msg
)+sizeof(footer_msg
),
7940 "Returned an unexpected buffer from TransmitFile: %d\n", iret
);
7941 ok(memcmp(&buf
[0], &header_msg
[0], sizeof(header_msg
)) == 0,
7942 "TransmitFile header buffer did not match!\n");
7943 ok(memcmp(&buf
[sizeof(header_msg
)], &footer_msg
[0], sizeof(footer_msg
)) == 0,
7944 "TransmitFile footer buffer did not match!\n");
7946 /* Test TransmitFile with only file data */
7947 bret
= pTransmitFile(client
, file
, 0, 0, NULL
, NULL
, 0);
7948 ok(bret
, "TransmitFile failed unexpectedly.\n");
7949 compare_file(file
, dest
, 0);
7951 /* Test TransmitFile with both file and buffer data */
7952 buffers
.Head
= &header_msg
[0];
7953 buffers
.HeadLength
= sizeof(header_msg
);
7954 buffers
.Tail
= &footer_msg
[0];
7955 buffers
.TailLength
= sizeof(footer_msg
);
7956 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
7957 bret
= pTransmitFile(client
, file
, 0, 0, NULL
, &buffers
, 0);
7958 ok(bret
, "TransmitFile failed unexpectedly.\n");
7959 iret
= recv(dest
, buf
, sizeof(header_msg
), 0);
7960 ok(memcmp(buf
, &header_msg
[0], sizeof(header_msg
)) == 0,
7961 "TransmitFile header buffer did not match!\n");
7962 compare_file(file
, dest
, 0);
7963 iret
= recv(dest
, buf
, sizeof(footer_msg
), 0);
7964 ok(memcmp(buf
, &footer_msg
[0], sizeof(footer_msg
)) == 0,
7965 "TransmitFile footer buffer did not match!\n");
7967 /* Test overlapped TransmitFile */
7968 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
7969 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
7970 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, NULL
, 0);
7971 err
= WSAGetLastError();
7972 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
7973 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n",
7974 err
, ERROR_IO_PENDING
);
7975 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
7976 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
7977 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
7978 ok(total_sent
== file_size
,
7979 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
7980 total_sent
, file_size
);
7981 compare_file(file
, dest
, 0);
7983 /* Test overlapped TransmitFile w/ start offset */
7984 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
7985 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
7987 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, NULL
, 0);
7988 err
= WSAGetLastError();
7989 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
7990 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, ERROR_IO_PENDING
);
7991 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
7992 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
7993 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
7994 ok(total_sent
== (file_size
- ov
.Offset
),
7995 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
7996 total_sent
, file_size
- ov
.Offset
);
7997 compare_file(file
, dest
, ov
.Offset
);
7999 /* Test overlapped TransmitFile w/ file and buffer data */
8000 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
8001 buffers
.Head
= &header_msg
[0];
8002 buffers
.HeadLength
= sizeof(header_msg
);
8003 buffers
.Tail
= &footer_msg
[0];
8004 buffers
.TailLength
= sizeof(footer_msg
);
8005 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
8007 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, &buffers
, 0);
8008 err
= WSAGetLastError();
8009 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8010 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, ERROR_IO_PENDING
);
8011 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
8012 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
8013 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
8014 ok(total_sent
== (file_size
+ buffers
.HeadLength
+ buffers
.TailLength
),
8015 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8016 total_sent
, file_size
+ buffers
.HeadLength
+ buffers
.TailLength
);
8017 iret
= recv(dest
, buf
, sizeof(header_msg
), 0);
8018 ok(memcmp(buf
, &header_msg
[0], sizeof(header_msg
)) == 0,
8019 "TransmitFile header buffer did not match!\n");
8020 compare_file(file
, dest
, 0);
8021 iret
= recv(dest
, buf
, sizeof(footer_msg
), 0);
8022 ok(memcmp(buf
, &footer_msg
[0], sizeof(footer_msg
)) == 0,
8023 "TransmitFile footer buffer did not match!\n");
8025 /* Test TransmitFile with a UDP datagram socket */
8026 closesocket(client
);
8027 client
= socket(AF_INET
, SOCK_DGRAM
, 0);
8028 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, 0);
8029 err
= WSAGetLastError();
8030 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8031 ok(err
== WSAENOTCONN
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTCONN
);
8034 CloseHandle(ov
.hEvent
);
8035 closesocket(client
);
8036 closesocket(server
);
8039 static void test_getpeername(void)
8042 struct sockaddr_in sa
, sa_out
;
8043 SOCKADDR_STORAGE ss
;
8045 const char buf
[] = "hello world";
8048 /* Test the parameter validation order. */
8049 ret
= getpeername(INVALID_SOCKET
, NULL
, NULL
);
8050 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
8051 ok(WSAGetLastError() == WSAENOTSOCK
,
8052 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
8054 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
8055 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
8057 ret
= getpeername(sock
, NULL
, NULL
);
8058 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
8059 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
,
8060 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
8062 memset(&sa
, 0, sizeof(sa
));
8063 sa
.sin_family
= AF_INET
;
8064 sa
.sin_port
= htons(139);
8065 sa
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8067 /* sendto does not change a socket's connection state. */
8068 ret
= sendto(sock
, buf
, sizeof(buf
), 0, (struct sockaddr
*)&sa
, sizeof(sa
));
8069 ok(ret
!= SOCKET_ERROR
,
8070 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
8072 ret
= getpeername(sock
, NULL
, NULL
);
8073 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
8074 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
,
8075 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
8077 ret
= connect(sock
, (struct sockaddr
*)&sa
, sizeof(sa
));
8079 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
8081 ret
= getpeername(sock
, NULL
, NULL
);
8082 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
8083 ok(WSAGetLastError() == WSAEFAULT
,
8084 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8086 /* Test crashes on Wine. */
8089 ret
= getpeername(sock
, (void*)0xdeadbeef, (void*)0xcafebabe);
8090 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
8091 ok(WSAGetLastError() == WSAEFAULT
,
8092 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8095 ret
= getpeername(sock
, (struct sockaddr
*)&sa_out
, NULL
);
8096 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
8097 ok(WSAGetLastError() == WSAEFAULT
,
8098 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8101 ret
= getpeername(sock
, NULL
, &sa_len
);
8102 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
8103 ok(WSAGetLastError() == WSAEFAULT
,
8104 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8105 ok(!sa_len
, "got %d\n", sa_len
);
8108 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
8109 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
8110 ok(WSAGetLastError() == WSAEFAULT
,
8111 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8112 ok(!sa_len
, "got %d\n", sa_len
);
8114 sa_len
= sizeof(ss
);
8115 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
8116 ok(ret
== 0, "Expected getpeername to return 0, got %d\n", ret
);
8117 ok(!memcmp(&sa
, &ss
, sizeof(sa
)),
8118 "Expected the returned structure to be identical to the connect structure\n");
8119 ok(sa_len
== sizeof(sa
), "got %d\n", sa_len
);
8124 static void test_sioRoutingInterfaceQuery(void)
8126 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
8127 struct sockaddr_in in
= {0}, out
= {0};
8134 sock
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
8135 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
8136 port
= CreateIoCompletionPort((HANDLE
)sock
, NULL
, 123, 0);
8138 WSASetLastError(0xdeadbeef);
8139 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), NULL
, NULL
, NULL
);
8140 ok(ret
== -1, "expected failure\n");
8141 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
8144 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
) - 1, &out
, sizeof(out
), &size
, NULL
, NULL
);
8145 ok(ret
== -1, "expected failure\n");
8146 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
8147 ok(size
== 0xdeadbeef, "got size %u\n", size
);
8150 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, NULL
, sizeof(in
), &out
, sizeof(out
), &size
, NULL
, NULL
);
8151 ok(ret
== -1, "expected failure\n");
8152 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
8153 ok(size
== 0xdeadbeef, "got size %u\n", size
);
8156 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), &size
, NULL
, NULL
);
8157 ok(ret
== -1, "expected failure\n");
8158 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "got error %u\n", WSAGetLastError());
8159 ok(size
== 0xdeadbeef, "got size %u\n", size
);
8161 in
.sin_family
= AF_INET
;
8163 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), &size
, NULL
, NULL
);
8164 todo_wine
ok(ret
== -1, "expected failure\n");
8165 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
8166 todo_wine
ok(size
== 0xdeadbeef, "got size %u\n", size
);
8168 in
.sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
8169 WSASetLastError(0xdeadbeef);
8171 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), &size
, NULL
, NULL
);
8172 ok(!ret
, "expected failure\n");
8173 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
8174 ok(size
== sizeof(out
), "got size %u\n", size
);
8175 /* We expect the source address to be INADDR_LOOPBACK as well, but
8176 * there's no guarantee that a route to the loopback address exists,
8177 * so rather than introduce spurious test failures we do not test the
8182 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
) - 1, &size
, NULL
, NULL
);
8183 ok(ret
== -1, "expected failure\n");
8184 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
8185 todo_wine
ok(size
== sizeof(out
), "got size %u\n", size
);
8188 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), NULL
, sizeof(out
), &size
, NULL
, NULL
);
8189 ok(ret
== -1, "expected failure\n");
8190 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
8191 ok(size
== 0xdeadbeef, "got size %u\n", size
);
8193 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), NULL
, &overlapped
, NULL
);
8194 ok(ret
== -1, "expected failure\n");
8195 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
8196 ok(size
== 0xdeadbeef, "got size %u\n", size
);
8198 WSASetLastError(0xdeadbeef);
8200 overlapped
.Internal
= 0xdeadbeef;
8201 overlapped
.InternalHigh
= 0xdeadbeef;
8202 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), &size
, &overlapped
, NULL
);
8203 ok(!ret
, "expected failure\n");
8204 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
8205 ok(size
== sizeof(out
), "got size %u\n", size
);
8207 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
8208 ok(ret
, "got error %u\n", GetLastError());
8209 ok(!size
, "got size %u\n", size
);
8210 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
8211 ok(!overlapped
.Internal
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
8212 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
8217 sock
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
8219 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
),
8220 &out
, sizeof(out
), NULL
, &overlapped
, socket_apc
);
8221 ok(ret
== -1, "expected failure\n");
8222 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
8226 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
),
8227 &out
, sizeof(out
), &size
, &overlapped
, socket_apc
);
8228 ok(!ret
, "expected success\n");
8229 ok(size
== sizeof(out
), "got size %u\n", size
);
8231 ret
= SleepEx(0, TRUE
);
8232 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
8233 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
8234 ok(!apc_error
, "got APC error %u\n", apc_error
);
8235 ok(!apc_size
, "got APC size %u\n", apc_size
);
8236 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
8241 static void test_sioAddressListChange(void)
8243 struct sockaddr_in bindAddress
;
8244 struct in_addr net_address
;
8245 WSAOVERLAPPED overlapped
, *olp
;
8247 DWORD num_bytes
, error
, tick
;
8248 SOCKET sock
, sock2
, sock3
;
8249 WSAEVENT event2
, event3
;
8256 /* Use gethostbyname to find the list of local network interfaces */
8257 h
= gethostbyname("");
8258 ok(!!h
, "failed to get interface list, error %u\n", WSAGetLastError());
8259 for (acount
= 0; h
->h_addr_list
[acount
]; acount
++);
8262 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
8266 net_address
.s_addr
= *(ULONG
*) h
->h_addr_list
[0];
8268 sock
= socket(AF_INET
, 0, IPPROTO_TCP
);
8269 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
8271 memset(&bindAddress
, 0, sizeof(bindAddress
));
8272 bindAddress
.sin_family
= AF_INET
;
8273 bindAddress
.sin_addr
.s_addr
= net_address
.s_addr
;
8274 SetLastError(0xdeadbeef);
8275 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8276 ok (!ret
, "bind() failed with error %d\n", GetLastError());
8277 set_blocking(sock
, FALSE
);
8279 memset(&overlapped
, 0, sizeof(overlapped
));
8280 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8281 SetLastError(0xdeadbeef);
8282 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8283 error
= GetLastError();
8284 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
8285 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
8287 CloseHandle(overlapped
.hEvent
);
8290 sock
= socket(AF_INET
, 0, IPPROTO_TCP
);
8291 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
8293 SetLastError(0xdeadbeef);
8294 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8295 ok (!ret
, "bind() failed with error %d\n", GetLastError());
8296 set_blocking(sock
, TRUE
);
8298 memset(&overlapped
, 0, sizeof(overlapped
));
8299 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8300 SetLastError(0xdeadbeef);
8301 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8302 error
= GetLastError();
8303 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
8304 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
8306 CloseHandle(overlapped
.hEvent
);
8309 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8310 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
8312 SetLastError(0xdeadbeef);
8313 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8314 ok (!ret
, "bind() failed with error %d\n", GetLastError());
8315 set_blocking(sock
, FALSE
);
8317 memset(&overlapped
, 0, sizeof(overlapped
));
8318 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8319 SetLastError(0xdeadbeef);
8320 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8321 error
= GetLastError();
8322 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
8323 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
8325 CloseHandle(overlapped
.hEvent
);
8328 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8329 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
8331 SetLastError(0xdeadbeef);
8332 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8333 ok (!ret
, "bind() failed with error %d\n", GetLastError());
8334 set_blocking(sock
, TRUE
);
8336 memset(&overlapped
, 0, sizeof(overlapped
));
8337 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8338 SetLastError(0xdeadbeef);
8339 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8340 error
= GetLastError();
8341 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
8342 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
8344 CloseHandle(overlapped
.hEvent
);
8347 /* When the socket is overlapped non-blocking and the list change is requested without
8348 * an overlapped structure the error will be different. */
8349 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8350 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
8352 SetLastError(0xdeadbeef);
8353 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8354 ok (!ret
, "bind() failed with error %d\n", GetLastError());
8355 set_blocking(sock
, FALSE
);
8357 SetLastError(0xdeadbeef);
8358 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
8359 error
= GetLastError();
8360 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
8361 ok (error
== WSAEWOULDBLOCK
, "expected 10035, got %d\n", error
);
8363 io_port
= CreateIoCompletionPort( (HANDLE
)sock
, NULL
, 0, 0 );
8364 ok (io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8366 set_blocking(sock
, FALSE
);
8367 memset(&overlapped
, 0, sizeof(overlapped
));
8368 SetLastError(0xdeadbeef);
8369 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8370 error
= GetLastError();
8371 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %u\n", error
);
8372 ok (error
== ERROR_IO_PENDING
, "expected ERROR_IO_PENDING got %u\n", error
);
8374 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8375 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 0 );
8376 ok(!bret
, "failed to get completion status %u\n", bret
);
8377 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8378 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8382 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8383 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 0 );
8384 ok(!bret
, "failed to get completion status %u\n", bret
);
8385 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %u\n", GetLastError());
8386 ok(olp
== &overlapped
, "Overlapped structure is at %p\n", olp
);
8388 CloseHandle(io_port
);
8390 /* Misuse of the API by using a blocking socket and not using an overlapped structure,
8391 * this leads to a hang forever. */
8394 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8396 SetLastError(0xdeadbeef);
8397 bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8399 set_blocking(sock
, TRUE
);
8400 WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
8406 if (!winetest_interactive
)
8408 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
8412 /* Bind an overlapped socket to the first found network interface */
8413 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8414 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
8415 sock2
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8416 ok(sock2
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
8417 sock3
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8418 ok(sock3
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
8420 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8421 ok(!ret
, "bind failed unexpectedly\n");
8422 ret
= bind(sock2
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8423 ok(!ret
, "bind failed unexpectedly\n");
8424 ret
= bind(sock3
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8425 ok(!ret
, "bind failed unexpectedly\n");
8427 set_blocking(sock2
, FALSE
);
8428 set_blocking(sock3
, FALSE
);
8430 /* Wait for address changes, request that the user connects/disconnects an interface */
8431 memset(&overlapped
, 0, sizeof(overlapped
));
8432 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8433 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8434 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
8435 ok(WSAGetLastError() == WSA_IO_PENDING
, "Expected pending last error, got %d\n", WSAGetLastError());
8437 ret
= WSAIoctl(sock2
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
8438 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
8439 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "Expected would block last error, got %d\n", WSAGetLastError());
8441 event2
= WSACreateEvent();
8442 event3
= WSACreateEvent();
8443 ret
= WSAEventSelect (sock2
, event2
, FD_ADDRESS_LIST_CHANGE
);
8444 ok(!ret
, "WSAEventSelect failed with %d\n", WSAGetLastError());
8445 /* sock3 did not request SIO_ADDRESS_LIST_CHANGE but it is trying to wait anyway */
8446 ret
= WSAEventSelect (sock3
, event3
, FD_ADDRESS_LIST_CHANGE
);
8447 ok(!ret
, "WSAEventSelect failed with %d\n", WSAGetLastError());
8449 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
8450 " change the ipv4 address of any of the local network interfaces (15 second timeout).\n");
8451 tick
= GetTickCount();
8452 ret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
8453 ok(ret
== WAIT_OBJECT_0
, "failed to get overlapped event %u\n", ret
);
8455 ret
= WaitForSingleObject(event2
, 500);
8457 ok(ret
== WAIT_OBJECT_0
, "failed to get change event %u\n", ret
);
8459 ret
= WaitForSingleObject(event3
, 500);
8460 ok(ret
== WAIT_TIMEOUT
, "unexpected change event\n");
8462 trace("Spent %d ms waiting.\n", GetTickCount() - tick
);
8464 WSACloseEvent(event2
);
8465 WSACloseEvent(event3
);
8473 * Provide consistent initialization for the AcceptEx IOCP tests.
8475 static SOCKET
setup_iocp_src(struct sockaddr_in
*bindAddress
)
8480 src
= socket(AF_INET
, SOCK_STREAM
, 0);
8481 ok(src
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8483 memset(bindAddress
, 0, sizeof(*bindAddress
));
8484 bindAddress
->sin_family
= AF_INET
;
8485 bindAddress
->sin_addr
.s_addr
= inet_addr("127.0.0.1");
8486 iret
= bind(src
, (struct sockaddr
*)bindAddress
, sizeof(*bindAddress
));
8487 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
8489 socklen
= sizeof(*bindAddress
);
8490 iret
= getsockname(src
, (struct sockaddr
*)bindAddress
, &socklen
);
8491 ok(!iret
, "failed to get address, error %u\n", WSAGetLastError());
8493 iret
= set_blocking(src
, FALSE
);
8494 ok(!iret
, "failed to make socket non-blocking, error %u\n", WSAGetLastError());
8496 iret
= listen(src
, 5);
8497 ok(!iret
, "failed to listen, error %u\n", WSAGetLastError());
8502 static void test_completion_port(void)
8505 WSAOVERLAPPED ov
, *olp
;
8506 SOCKET src
, dest
, dup
, connector
= INVALID_SOCKET
;
8507 WSAPROTOCOL_INFOA info
;
8510 DWORD num_bytes
, flags
;
8515 struct sockaddr_in bindAddress
;
8516 GUID acceptExGuid
= WSAID_ACCEPTEX
;
8517 LPFN_ACCEPTEX pAcceptEx
= NULL
;
8520 memset(buf
, 0, sizeof(buf
));
8521 io_port
= CreateIoCompletionPort(INVALID_HANDLE_VALUE
, NULL
, 0, 0);
8522 ok( io_port
!= NULL
, "Failed to create completion port %u\n", GetLastError());
8524 memset(&ov
, 0, sizeof(ov
));
8526 tcp_socketpair(&src
, &dest
);
8528 bufs
.len
= sizeof(buf
);
8534 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
8535 ok(!iret
, "Failed to set linger %d\n", GetLastError());
8537 io_port
= CreateIoCompletionPort( (HANDLE
)dest
, io_port
, 125, 0 );
8538 ok(io_port
!= NULL
, "Failed to create completion port %u\n", GetLastError());
8540 SetLastError(0xdeadbeef);
8542 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
8543 ok(iret
== SOCKET_ERROR
, "WSARecv returned %d\n", iret
);
8544 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8549 src
= INVALID_SOCKET
;
8551 SetLastError(0xdeadbeef);
8553 num_bytes
= 0xdeadbeef;
8554 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8556 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8557 todo_wine
ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %d\n", bret
);
8558 todo_wine
ok(GetLastError() == ERROR_NETNAME_DELETED
, "Last error was %d\n", GetLastError());
8559 ok(key
== 125, "Key is %lu\n", key
);
8560 ok(num_bytes
== 0, "Number of bytes received is %u\n", num_bytes
);
8561 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
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
, "GetQueuedCompletionStatus returned %d\n", bret
);
8570 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8571 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8572 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8573 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8575 if (dest
!= INVALID_SOCKET
)
8578 memset(&ov
, 0, sizeof(ov
));
8580 tcp_socketpair(&src
, &dest
);
8582 bufs
.len
= sizeof(buf
);
8588 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
8589 ok(!iret
, "Failed to set linger %d\n", GetLastError());
8591 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 125, 0);
8592 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8594 set_blocking(dest
, FALSE
);
8597 src
= INVALID_SOCKET
;
8601 num_bytes
= 0xdeadbeef;
8602 SetLastError(0xdeadbeef);
8604 iret
= WSASend(dest
, &bufs
, 1, &num_bytes
, 0, &ov
, NULL
);
8605 ok(iret
== SOCKET_ERROR
, "WSASend failed - %d\n", iret
);
8606 ok(GetLastError() == WSAECONNRESET
, "Last error was %d\n", GetLastError());
8607 ok(num_bytes
== 0xdeadbeef, "Managed to send %d\n", num_bytes
);
8609 SetLastError(0xdeadbeef);
8611 num_bytes
= 0xdeadbeef;
8612 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8614 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8615 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
8616 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8617 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8618 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8619 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8621 if (dest
!= INVALID_SOCKET
)
8624 /* Test IOCP response on successful immediate read. */
8625 tcp_socketpair(&src
, &dest
);
8627 bufs
.len
= sizeof(buf
);
8630 SetLastError(0xdeadbeef);
8632 iret
= WSASend(src
, &bufs
, 1, &num_bytes
, 0, &ov
, NULL
);
8633 ok(!iret
, "WSASend failed - %d, last error %u\n", iret
, GetLastError());
8634 ok(num_bytes
== sizeof(buf
), "Managed to send %d\n", num_bytes
);
8636 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 125, 0);
8637 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8638 set_blocking(dest
, FALSE
);
8641 FD_SET(dest
, &fds_recv
);
8642 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
8644 num_bytes
= 0xdeadbeef;
8647 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
8648 ok(!iret
, "WSARecv failed - %d, last error %u\n", iret
, GetLastError());
8649 ok(num_bytes
== sizeof(buf
), "Managed to read %d\n", num_bytes
);
8651 SetLastError(0xdeadbeef);
8653 num_bytes
= 0xdeadbeef;
8654 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8656 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8657 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
8658 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
8659 ok(key
== 125, "Key is %lu\n", key
);
8660 ok(num_bytes
== sizeof(buf
), "Number of bytes transferred is %u\n", num_bytes
);
8661 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8663 /* Test IOCP response on graceful shutdown. */
8667 FD_SET(dest
, &fds_recv
);
8668 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
8670 num_bytes
= 0xdeadbeef;
8672 memset(&ov
, 0, sizeof(ov
));
8674 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
8675 ok(!iret
, "WSARecv failed - %d, last error %u\n", iret
, GetLastError());
8676 ok(!num_bytes
, "Managed to read %d\n", num_bytes
);
8678 SetLastError(0xdeadbeef);
8680 num_bytes
= 0xdeadbeef;
8681 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8683 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8684 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
8685 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
8686 ok(key
== 125, "Key is %lu\n", key
);
8687 ok(!num_bytes
, "Number of bytes transferred is %u\n", num_bytes
);
8688 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8691 src
= INVALID_SOCKET
;
8693 dest
= INVALID_SOCKET
;
8695 /* Test IOCP response on hard shutdown. This was the condition that triggered
8696 * a crash in an actual app (bug 38980). */
8697 tcp_socketpair(&src
, &dest
);
8699 bufs
.len
= sizeof(buf
);
8702 memset(&ov
, 0, sizeof(ov
));
8706 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
8707 ok(!iret
, "Failed to set linger %d\n", GetLastError());
8709 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 125, 0);
8710 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8711 set_blocking(dest
, FALSE
);
8714 src
= INVALID_SOCKET
;
8717 FD_SET(dest
, &fds_recv
);
8718 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
8720 num_bytes
= 0xdeadbeef;
8721 SetLastError(0xdeadbeef);
8723 /* Somehow a hard shutdown doesn't work on my Linux box. It seems SO_LINGER is ignored. */
8724 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
8725 todo_wine
ok(iret
== SOCKET_ERROR
, "WSARecv failed - %d\n", iret
);
8726 todo_wine
ok(GetLastError() == WSAECONNRESET
, "Last error was %d\n", GetLastError());
8727 todo_wine
ok(num_bytes
== 0xdeadbeef, "Managed to read %d\n", num_bytes
);
8729 SetLastError(0xdeadbeef);
8731 num_bytes
= 0xdeadbeef;
8732 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8734 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8735 todo_wine
ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
8736 todo_wine
ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8737 todo_wine
ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8738 todo_wine
ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8739 todo_wine
ok(!olp
, "Overlapped structure is at %p\n", olp
);
8743 /* Test reading from a non-connected socket, mostly because the above test is marked todo. */
8744 dest
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8745 ok(dest
!= INVALID_SOCKET
, "socket() failed\n");
8747 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 125, 0);
8748 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8749 set_blocking(dest
, FALSE
);
8751 num_bytes
= 0xdeadbeef;
8752 SetLastError(0xdeadbeef);
8753 memset(&ov
, 0, sizeof(ov
));
8755 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
8756 ok(iret
== SOCKET_ERROR
, "WSARecv failed - %d\n", iret
);
8757 ok(GetLastError() == WSAENOTCONN
, "Last error was %d\n", GetLastError());
8758 ok(num_bytes
== 0xdeadbeef, "Managed to read %d\n", num_bytes
);
8760 SetLastError(0xdeadbeef);
8762 num_bytes
= 0xdeadbeef;
8763 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8765 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8766 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
8767 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8768 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8769 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8770 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8772 num_bytes
= 0xdeadbeef;
8775 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
8776 ok(dest
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8778 iret
= WSAIoctl(dest
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
8779 &pAcceptEx
, sizeof(pAcceptEx
), &num_bytes
, NULL
, NULL
);
8780 ok(!iret
, "failed to get AcceptEx, error %u\n", WSAGetLastError());
8782 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
8784 src
= setup_iocp_src(&bindAddress
);
8786 SetLastError(0xdeadbeef);
8788 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8789 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8791 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8792 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8794 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8795 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8798 src
= INVALID_SOCKET
;
8800 SetLastError(0xdeadbeef);
8802 num_bytes
= 0xdeadbeef;
8803 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8805 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8806 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8807 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
8808 ok(key
== 125, "Key is %lu\n", key
);
8809 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
8810 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8811 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8813 SetLastError(0xdeadbeef);
8815 num_bytes
= 0xdeadbeef;
8816 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8817 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8818 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8819 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8820 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8821 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8822 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8824 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
8826 src
= setup_iocp_src(&bindAddress
);
8828 SetLastError(0xdeadbeef);
8830 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8831 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8833 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8834 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8836 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8837 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8840 src
= INVALID_SOCKET
;
8842 SetLastError(0xdeadbeef);
8844 num_bytes
= 0xdeadbeef;
8845 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8847 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8848 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8849 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
8850 ok(key
== 125, "Key is %lu\n", key
);
8851 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
8852 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8853 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8855 SetLastError(0xdeadbeef);
8857 num_bytes
= 0xdeadbeef;
8858 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8859 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8860 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8861 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8862 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8863 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8864 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8866 /* Test IOCP with duplicated handle */
8868 src
= setup_iocp_src(&bindAddress
);
8870 SetLastError(0xdeadbeef);
8872 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8873 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8875 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
8876 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
8877 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
8879 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8880 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8882 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8883 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8885 SetLastError(0xdeadbeef);
8887 num_bytes
= 0xdeadbeef;
8888 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8889 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8890 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8891 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8892 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8893 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8894 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8897 src
= INVALID_SOCKET
;
8899 dup
= INVALID_SOCKET
;
8901 SetLastError(0xdeadbeef);
8903 num_bytes
= 0xdeadbeef;
8904 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8905 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8906 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8907 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
8908 ok(key
== 125, "Key is %lu\n", key
);
8909 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
8910 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8911 ok(olp
&& olp
->Internal
== (ULONG
)STATUS_CANCELLED
, "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8913 SetLastError(0xdeadbeef);
8915 num_bytes
= 0xdeadbeef;
8916 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8917 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8918 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8919 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8920 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8921 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8922 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8924 /* Test IOCP with duplicated handle (closing duplicated handle) */
8926 src
= setup_iocp_src(&bindAddress
);
8928 SetLastError(0xdeadbeef);
8930 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8931 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8933 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
8934 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
8935 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
8937 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8938 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8940 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8941 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8944 dup
= INVALID_SOCKET
;
8946 SetLastError(0xdeadbeef);
8948 num_bytes
= 0xdeadbeef;
8949 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8950 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8951 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8952 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8953 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8954 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8955 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8957 SetLastError(0xdeadbeef);
8959 num_bytes
= 0xdeadbeef;
8960 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8961 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8962 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8963 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8964 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8965 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8966 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8969 src
= INVALID_SOCKET
;
8971 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8972 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8973 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
8974 ok(key
== 125, "Key is %lu\n", key
);
8975 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
8976 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8977 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8979 SetLastError(0xdeadbeef);
8981 num_bytes
= 0xdeadbeef;
8982 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8983 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8984 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8985 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8986 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8987 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8988 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8990 /* Test IOCP with duplicated handle (closing original handle) */
8992 src
= setup_iocp_src(&bindAddress
);
8994 SetLastError(0xdeadbeef);
8996 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8997 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8999 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
9000 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
9001 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
9003 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
9004 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9006 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
9007 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9010 src
= INVALID_SOCKET
;
9012 SetLastError(0xdeadbeef);
9014 num_bytes
= 0xdeadbeef;
9015 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9016 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9017 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9018 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9019 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9020 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9021 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9024 dup
= INVALID_SOCKET
;
9026 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9027 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9028 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
9029 ok(key
== 125, "Key is %lu\n", key
);
9030 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
9031 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9032 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
9034 SetLastError(0xdeadbeef);
9036 num_bytes
= 0xdeadbeef;
9037 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9038 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9039 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9040 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9041 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9042 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9043 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9045 /* Test IOCP without AcceptEx */
9047 src
= setup_iocp_src(&bindAddress
);
9049 SetLastError(0xdeadbeef);
9051 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
9052 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9055 src
= INVALID_SOCKET
;
9057 SetLastError(0xdeadbeef);
9059 num_bytes
= 0xdeadbeef;
9060 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9061 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9062 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9063 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9064 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9065 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9066 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9070 src
= setup_iocp_src(&bindAddress
);
9072 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
9073 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
9075 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
9076 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9078 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 236, 0);
9079 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9081 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
9082 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9084 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
9085 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9087 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9088 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
9090 closesocket(connector
);
9091 connector
= INVALID_SOCKET
;
9093 SetLastError(0xdeadbeef);
9095 num_bytes
= 0xdeadbeef;
9096 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9098 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9099 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
9100 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9101 ok(key
== 125, "Key is %lu\n", key
);
9102 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
9103 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9104 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
9106 SetLastError(0xdeadbeef);
9108 num_bytes
= 0xdeadbeef;
9109 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9110 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9111 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9112 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9113 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9114 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9115 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9117 if (dest
!= INVALID_SOCKET
)
9119 if (src
!= INVALID_SOCKET
)
9124 src
= setup_iocp_src(&bindAddress
);
9126 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
9127 ok(dest
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
9129 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
9130 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
9132 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
9133 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9135 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 236, 0);
9136 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9138 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
9139 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9141 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
9142 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9144 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9145 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
9147 iret
= send(connector
, buf
, 1, 0);
9148 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
9153 dest
= INVALID_SOCKET
;
9155 SetLastError(0xdeadbeef);
9157 num_bytes
= 0xdeadbeef;
9158 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9160 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9161 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
9162 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9163 ok(key
== 125, "Key is %lu\n", key
);
9164 ok(num_bytes
== 1, "Number of bytes transferred is %u\n", num_bytes
);
9165 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9166 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
9168 SetLastError(0xdeadbeef);
9170 num_bytes
= 0xdeadbeef;
9171 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9172 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9173 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9174 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9175 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9176 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9177 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9179 if (src
!= INVALID_SOCKET
)
9181 if (connector
!= INVALID_SOCKET
)
9182 closesocket(connector
);
9186 src
= setup_iocp_src(&bindAddress
);
9188 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
9189 ok(dest
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
9191 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
9192 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
9194 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
9195 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9197 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 236, 0);
9198 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9200 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
9201 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9203 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
9204 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9206 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9207 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
9211 SetLastError(0xdeadbeef);
9213 num_bytes
= 0xdeadbeef;
9214 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9216 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9217 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9218 ok(GetLastError() == ERROR_OPERATION_ABORTED
9219 || GetLastError() == ERROR_CONNECTION_ABORTED
, "got error %u\n", GetLastError());
9220 ok(key
== 125, "Key is %lu\n", key
);
9221 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
9222 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9223 ok((NTSTATUS
)olp
->Internal
== STATUS_CANCELLED
9224 || (NTSTATUS
)olp
->Internal
== STATUS_CONNECTION_ABORTED
, "got status %#lx\n", olp
->Internal
);
9226 SetLastError(0xdeadbeef);
9228 num_bytes
= 0xdeadbeef;
9229 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9230 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9231 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9232 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9233 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9234 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9235 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9238 closesocket(connector
);
9239 CloseHandle(io_port
);
9242 static void test_connect_completion_port(void)
9244 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
9245 GUID connectex_guid
= WSAID_CONNECTEX
;
9246 SOCKET connector
, listener
, acceptor
;
9247 struct sockaddr_in addr
, destaddr
;
9248 LPFN_CONNECTEX pConnectEx
;
9254 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
9256 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9257 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9259 memset(&addr
, 0, sizeof(addr
));
9260 addr
.sin_family
= AF_INET
;
9261 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
9262 ret
= bind(listener
, (struct sockaddr
*)&addr
, sizeof(addr
));
9263 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
9264 addrlen
= sizeof(destaddr
);
9265 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &addrlen
);
9266 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
9268 ret
= listen(listener
, 1);
9269 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
9271 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9272 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9274 ret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectex_guid
, sizeof(connectex_guid
),
9275 &pConnectEx
, sizeof(pConnectEx
), &size
, NULL
, NULL
);
9276 ok(!ret
, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
9278 /* connect() does not queue completion. */
9280 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
9281 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9283 ret
= connect(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
9284 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
9285 acceptor
= accept(listener
, NULL
, NULL
);
9286 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9287 closesocket(acceptor
);
9289 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9290 ok(!ret
, "expected failure\n");
9291 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
9293 closesocket(connector
);
9296 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9297 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9298 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
9299 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9300 set_blocking(connector
, FALSE
);
9302 ret
= connect(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
9303 ok(ret
== -1, "expected failure\n");
9304 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
9305 acceptor
= accept(listener
, NULL
, NULL
);
9306 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9307 closesocket(acceptor
);
9309 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9310 ok(!ret
, "expected failure\n");
9311 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
9313 closesocket(connector
);
9316 /* ConnectEx() queues completion. */
9318 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9319 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9320 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
9321 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9322 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
9323 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
9325 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
9326 NULL
, 0, &size
, &overlapped
);
9327 ok(!ret
, "expected failure\n");
9328 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
9329 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9330 ok(!ret
, "wait failed\n");
9331 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
9332 ok(ret
, "got error %u\n", GetLastError());
9333 ok(!size
, "got %u bytes\n", size
);
9334 acceptor
= accept(listener
, NULL
, NULL
);
9335 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9336 closesocket(acceptor
);
9340 overlapped_ptr
= NULL
;
9341 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9342 ok(ret
, "got error %u\n", GetLastError());
9343 ok(!key
, "got key %#Ix\n", key
);
9344 ok(!size
, "got %u bytes\n", size
);
9345 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
9347 closesocket(connector
);
9350 /* Test ConnectEx() with a non-empty buffer. */
9352 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9353 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9354 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
9355 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9356 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
9357 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
9359 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
9360 (void *)"one", 3, &size
, &overlapped
);
9361 ok(!ret
, "expected failure\n");
9362 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
9363 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9364 ok(!ret
, "wait failed\n");
9365 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
9366 ok(ret
, "got error %u\n", GetLastError());
9367 ok(size
== 3, "got %u bytes\n", size
);
9368 acceptor
= accept(listener
, NULL
, NULL
);
9369 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9370 closesocket(acceptor
);
9374 overlapped_ptr
= NULL
;
9375 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9376 ok(ret
, "got error %u\n", GetLastError());
9377 ok(!key
, "got key %#Ix\n", key
);
9378 ok(size
== 3, "got %u bytes\n", size
);
9379 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
9381 closesocket(connector
);
9384 /* Suppress completion by setting the low bit. */
9386 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9387 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9388 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
9389 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9390 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
9391 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
9393 overlapped
.hEvent
= (HANDLE
)((ULONG_PTR
)overlapped
.hEvent
| 1);
9395 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
9396 NULL
, 0, &size
, &overlapped
);
9397 ok(!ret
, "expected failure\n");
9398 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
9399 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9400 ok(!ret
, "wait failed\n");
9401 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
9402 ok(ret
, "got error %u\n", GetLastError());
9403 ok(!size
, "got %u bytes\n", size
);
9404 acceptor
= accept(listener
, NULL
, NULL
);
9405 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9406 closesocket(acceptor
);
9408 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9409 ok(!ret
, "expected failure\n");
9410 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
9412 closesocket(connector
);
9415 overlapped
.hEvent
= (HANDLE
)((ULONG_PTR
)overlapped
.hEvent
& ~1);
9417 /* Skip completion on success. */
9419 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9420 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9421 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
9422 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9423 ret
= SetFileCompletionNotificationModes((HANDLE
)connector
, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS
);
9424 ok(ret
, "got error %u\n", GetLastError());
9425 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
9426 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
9428 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
9429 NULL
, 0, &size
, &overlapped
);
9430 ok(!ret
, "expected failure\n");
9431 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
9432 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9433 ok(!ret
, "wait failed\n");
9434 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
9435 ok(ret
, "got error %u\n", GetLastError());
9436 ok(!size
, "got %u bytes\n", size
);
9437 acceptor
= accept(listener
, NULL
, NULL
);
9438 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9439 closesocket(acceptor
);
9443 overlapped_ptr
= NULL
;
9444 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9445 ok(ret
, "got error %u\n", GetLastError());
9446 ok(!key
, "got key %#Ix\n", key
);
9447 ok(!size
, "got %u bytes\n", size
);
9448 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
9450 closesocket(connector
);
9453 closesocket(listener
);
9455 /* Connect to an invalid address. */
9457 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9458 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9459 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
9460 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9461 ret
= SetFileCompletionNotificationModes((HANDLE
)connector
, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS
);
9462 ok(ret
, "got error %u\n", GetLastError());
9463 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
9464 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
9466 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
9467 NULL
, 0, &size
, &overlapped
);
9468 ok(!ret
, "expected failure\n");
9469 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
9470 ret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
9471 ok(!ret
, "wait failed\n");
9472 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
9473 ok(!ret
, "expected failure\n");
9474 ok(GetLastError() == ERROR_CONNECTION_REFUSED
, "got error %u\n", GetLastError());
9475 ok(!size
, "got %u bytes\n", size
);
9479 overlapped_ptr
= NULL
;
9480 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9481 ok(!ret
, "expected failure\n");
9482 ok(GetLastError() == ERROR_CONNECTION_REFUSED
, "got error %u\n", GetLastError());
9483 ok(!key
, "got key %#Ix\n", key
);
9484 ok(!size
, "got %u bytes\n", size
);
9485 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
9487 closesocket(connector
);
9491 static void test_shutdown_completion_port(void)
9493 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
9494 GUID disconnectex_guid
= WSAID_DISCONNECTEX
;
9495 struct sockaddr_in addr
, destaddr
;
9496 LPFN_DISCONNECTEX pDisconnectEx
;
9497 SOCKET listener
, server
, client
;
9503 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
9505 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9506 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9508 memset(&addr
, 0, sizeof(addr
));
9509 addr
.sin_family
= AF_INET
;
9510 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
9511 ret
= bind(listener
, (struct sockaddr
*)&addr
, sizeof(addr
));
9512 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
9513 addrlen
= sizeof(destaddr
);
9514 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &addrlen
);
9515 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
9517 ret
= listen(listener
, 1);
9518 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
9520 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9521 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9523 ret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &disconnectex_guid
, sizeof(disconnectex_guid
),
9524 &pDisconnectEx
, sizeof(pDisconnectEx
), &size
, NULL
, NULL
);
9525 ok(!ret
, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
9527 /* shutdown() does not queue completion. */
9529 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
9530 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9531 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
9532 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
9533 server
= accept(listener
, NULL
, NULL
);
9534 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9536 ret
= shutdown(client
, SD_BOTH
);
9537 ok(!ret
, "failed to shutdown, error %u\n", WSAGetLastError());
9539 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9540 ok(!ret
, "expected failure\n");
9541 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
9543 closesocket(server
);
9544 closesocket(client
);
9547 /* WSASendDisconnect() and WSARecvDisconnect() do not queue completion. */
9549 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9550 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9551 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
9552 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9553 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
9554 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
9555 server
= accept(listener
, NULL
, NULL
);
9556 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9558 ret
= WSASendDisconnect(client
, NULL
);
9559 ok(!ret
, "failed to shutdown, error %u\n", WSAGetLastError());
9561 ret
= WSARecvDisconnect(client
, NULL
);
9562 ok(!ret
, "failed to shutdown, error %u\n", WSAGetLastError());
9564 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9565 ok(!ret
, "expected failure\n");
9566 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
9568 closesocket(server
);
9569 closesocket(client
);
9572 /* DisconnectEx() queues completion. */
9574 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9575 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9576 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
9577 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9578 ret
= SetFileCompletionNotificationModes((HANDLE
)client
, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS
);
9579 ok(ret
, "got error %u\n", GetLastError());
9580 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
9581 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
9582 server
= accept(listener
, NULL
, NULL
);
9583 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9585 SetLastError(0xdeadbeef);
9586 ret
= pDisconnectEx(client
, &overlapped
, 0, 0);
9587 ok(!ret
, "expected failure\n");
9588 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
9590 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9591 ok(!ret
, "wait failed\n");
9594 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, TRUE
);
9595 ok(ret
, "got error %u\n", GetLastError());
9596 ok(!size
, "got %u bytes\n", size
);
9600 overlapped_ptr
= NULL
;
9601 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9602 todo_wine
ok(ret
, "got error %u\n", GetLastError());
9603 todo_wine
ok(!key
, "got key %#Ix\n", key
);
9604 todo_wine
ok(!size
, "got %u bytes\n", size
);
9605 todo_wine
ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
9607 closesocket(server
);
9608 closesocket(client
);
9611 /* Test passing a NULL overlapped structure to DisconnectEx(). */
9613 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9614 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9615 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
9616 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9617 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
9618 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
9619 server
= accept(listener
, NULL
, NULL
);
9620 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9622 SetLastError(0xdeadbeef);
9623 ret
= pDisconnectEx(client
, NULL
, 0, 0);
9624 ok(ret
, "expected success\n");
9625 ok(!GetLastError() || GetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", GetLastError());
9627 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9628 ok(!ret
, "expected failure\n");
9629 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
9631 closesocket(server
);
9632 closesocket(client
);
9635 /* Suppress completion by setting the low bit. */
9637 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9638 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9639 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
9640 ok(!!port
, "failed to create port, error %u\n", GetLastError());
9641 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
9642 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
9643 server
= accept(listener
, NULL
, NULL
);
9644 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9646 overlapped
.hEvent
= (HANDLE
)((ULONG_PTR
)overlapped
.hEvent
| 1);
9648 SetLastError(0xdeadbeef);
9649 ret
= pDisconnectEx(client
, &overlapped
, 0, 0);
9650 ok(!ret
, "expected failure\n");
9651 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
9653 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9654 ok(!ret
, "wait failed\n");
9657 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, TRUE
);
9658 ok(ret
, "got error %u\n", GetLastError());
9659 ok(!size
, "got %u bytes\n", size
);
9661 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9662 ok(!ret
, "expected failure\n");
9663 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
9665 closesocket(server
);
9666 closesocket(client
);
9669 overlapped
.hEvent
= (HANDLE
)((ULONG_PTR
)overlapped
.hEvent
& ~1);
9671 CloseHandle(overlapped
.hEvent
);
9674 static void test_address_list_query(void)
9677 SOCKET_ADDRESS_LIST
*address_list
= (SOCKET_ADDRESS_LIST
*)buffer
;
9678 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
9679 DWORD size
, expect_size
;
9686 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9687 ok(s
!= INVALID_SOCKET
, "Failed to create socket, error %d.\n", WSAGetLastError());
9688 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
9691 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, NULL
, 0, &size
, NULL
, NULL
);
9692 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
9693 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9694 ok(size
>= FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[0]), "Got unexpected size %u.\n", size
);
9698 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, sizeof(buffer
), &size
, NULL
, NULL
);
9699 ok(!ret
, "Got unexpected ret %d.\n", ret
);
9700 ok(!WSAGetLastError(), "Got unexpected error %d.\n", WSAGetLastError());
9701 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
9703 expect_size
= FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[address_list
->iAddressCount
]);
9704 for (i
= 0; i
< address_list
->iAddressCount
; ++i
)
9706 expect_size
+= address_list
->Address
[i
].iSockaddrLength
;
9708 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
9710 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, sizeof(buffer
), NULL
, NULL
, NULL
);
9711 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
9712 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9715 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, NULL
, sizeof(buffer
), &size
, NULL
, NULL
);
9716 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
9717 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9718 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
9721 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, 0, &size
, NULL
, NULL
);
9722 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
9723 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9724 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
9727 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, 1, &size
, NULL
, NULL
);
9728 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
9729 ok(WSAGetLastError() == WSAEINVAL
, "Got unexpected error %d.\n", WSAGetLastError());
9730 ok(!size
, "Got size %u.\n", size
);
9733 memset(buffer
, 0xcc, sizeof(buffer
));
9734 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
,
9735 FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[0]), &size
, NULL
, NULL
);
9736 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
9737 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9738 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
9739 ok(address_list
->iAddressCount
== 0xcccccccc, "Got %u addresses.\n", address_list
->iAddressCount
);
9741 WSASetLastError(0xdeadbeef);
9742 overlapped
.Internal
= 0xdeadbeef;
9743 overlapped
.InternalHigh
= 0xdeadbeef;
9745 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, 0, &size
, &overlapped
, NULL
);
9746 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
9747 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9748 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
9749 ok(overlapped
.Internal
== 0xdeadbeef, "Got status %#x.\n", (NTSTATUS
)overlapped
.Internal
);
9750 ok(overlapped
.InternalHigh
== 0xdeadbeef, "Got size %Iu.\n", overlapped
.InternalHigh
);
9752 overlapped
.Internal
= 0xdeadbeef;
9753 overlapped
.InternalHigh
= 0xdeadbeef;
9755 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, 1, &size
, &overlapped
, NULL
);
9756 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
9757 ok(WSAGetLastError() == WSAEINVAL
, "Got unexpected error %d.\n", WSAGetLastError());
9758 ok(!size
, "Expected size %u, got %u.\n", expect_size
, size
);
9759 ok(overlapped
.Internal
== 0xdeadbeef, "Got status %#x.\n", (NTSTATUS
)overlapped
.Internal
);
9760 ok(overlapped
.InternalHigh
== 0xdeadbeef, "Got size %Iu.\n", overlapped
.InternalHigh
);
9762 overlapped
.Internal
= 0xdeadbeef;
9763 overlapped
.InternalHigh
= 0xdeadbeef;
9765 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
,
9766 FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[0]), &size
, &overlapped
, NULL
);
9767 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
9768 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9769 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
9770 ok(overlapped
.Internal
== 0xdeadbeef, "Got status %#x.\n", (NTSTATUS
)overlapped
.Internal
);
9771 ok(overlapped
.InternalHigh
== 0xdeadbeef, "Got size %Iu.\n", overlapped
.InternalHigh
);
9772 ok(address_list
->iAddressCount
== 0xcccccccc, "Got %u addresses.\n", address_list
->iAddressCount
);
9774 overlapped
.Internal
= 0xdeadbeef;
9775 overlapped
.InternalHigh
= 0xdeadbeef;
9777 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, sizeof(buffer
), &size
, &overlapped
, NULL
);
9778 ok(!ret
, "Got unexpected ret %d.\n", ret
);
9779 ok(!WSAGetLastError(), "Got unexpected error %d.\n", WSAGetLastError());
9780 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
9782 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9783 ok(ret
, "Got error %u.\n", GetLastError());
9784 ok(!size
, "Got size %u.\n", size
);
9785 ok(overlapped_ptr
== &overlapped
, "Got overlapped %p.\n", overlapped_ptr
);
9786 ok(!overlapped
.Internal
, "Got status %#x.\n", (NTSTATUS
)overlapped
.Internal
);
9787 ok(!overlapped
.InternalHigh
, "Got size %Iu.\n", overlapped
.InternalHigh
);
9789 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
9790 ok(!ret
, "Expected failure.\n");
9791 ok(GetLastError() == WAIT_TIMEOUT
, "Got error %u.\n", GetLastError());
9796 /* Test with an APC. */
9798 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9800 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, sizeof(buffer
), NULL
, &overlapped
, socket_apc
);
9801 ok(ret
== -1, "expected failure\n");
9802 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
9806 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, sizeof(buffer
), &size
, &overlapped
, socket_apc
);
9807 ok(!ret
, "expected success\n");
9808 ok(size
== expect_size
, "got size %u\n", size
);
9810 ret
= SleepEx(0, TRUE
);
9811 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
9812 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
9813 ok(!apc_error
, "got APC error %u\n", apc_error
);
9814 ok(!apc_size
, "got APC size %u\n", apc_size
);
9815 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
9820 static void sync_read(SOCKET src
, SOCKET dst
)
9825 ret
= send(dst
, "Hello World!", 12, 0);
9826 ok(ret
== 12, "send returned %d\n", ret
);
9828 memset(data
, 0, sizeof(data
));
9829 ret
= recv(src
, data
, sizeof(data
), 0);
9830 ok(ret
== 12, "expected 12, got %d\n", ret
);
9831 ok(!memcmp(data
, "Hello World!", 12), "got %u bytes (%*s)\n", ret
, ret
, data
);
9834 static void iocp_async_read(SOCKET src
, SOCKET dst
)
9837 WSAOVERLAPPED ovl
, *ovl_iocp
;
9844 memset(data
, 0, sizeof(data
));
9845 memset(&ovl
, 0, sizeof(ovl
));
9847 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
9848 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
9850 buf
.len
= sizeof(data
);
9854 SetLastError(0xdeadbeef);
9855 ret
= WSARecv(src
, &buf
, 1, &bytes
, &flags
, &ovl
, NULL
);
9856 ok(ret
== SOCKET_ERROR
, "got %d\n", ret
);
9857 ok(GetLastError() == ERROR_IO_PENDING
, "got %u\n", GetLastError());
9858 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9862 ovl_iocp
= (void *)0xdeadbeef;
9863 SetLastError(0xdeadbeef);
9864 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9865 ok(!ret
, "got %d\n", ret
);
9866 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
9867 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9868 ok(key
== 0xdeadbeef, "got key %#lx\n", key
);
9869 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
9871 ret
= send(dst
, "Hello World!", 12, 0);
9872 ok(ret
== 12, "send returned %d\n", ret
);
9877 SetLastError(0xdeadbeef);
9878 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9879 ok(ret
, "got %d\n", ret
);
9880 ok(bytes
== 12, "got bytes %u\n", bytes
);
9881 ok(key
== 0x12345678, "got key %#lx\n", key
);
9882 ok(ovl_iocp
== &ovl
, "got ovl %p\n", ovl_iocp
);
9885 ok(ovl_iocp
->InternalHigh
== 12, "got %#lx\n", ovl_iocp
->InternalHigh
);
9886 ok(!ovl_iocp
->Internal
, "got %#lx\n", ovl_iocp
->Internal
);
9887 ok(!memcmp(data
, "Hello World!", 12), "got %u bytes (%*s)\n", bytes
, bytes
, data
);
9892 ovl_iocp
= (void *)0xdeadbeef;
9893 SetLastError(0xdeadbeef);
9894 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9895 ok(!ret
, "got %d\n", ret
);
9896 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
9897 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9898 ok(key
== 0xdeadbeef, "got key %#lx\n", key
);
9899 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
9904 static void iocp_async_read_closesocket(SOCKET src
, int how_to_close
)
9907 WSAOVERLAPPED ovl
, *ovl_iocp
;
9916 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
9917 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
9918 ok(hwnd
!= 0, "CreateWindowEx failed\n");
9920 ret
= WSAAsyncSelect(src
, hwnd
, WM_SOCKET
, FD_READ
| FD_WRITE
| FD_OOB
| FD_ACCEPT
| FD_CONNECT
| FD_CLOSE
);
9921 ok(!ret
, "got %d\n", ret
);
9924 memset(&msg
, 0, sizeof(msg
));
9925 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9926 ok(ret
, "got %d\n", ret
);
9927 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
9928 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
9929 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
9930 ok(msg
.lParam
== 2, "got %08lx\n", msg
.lParam
);
9932 memset(data
, 0, sizeof(data
));
9933 memset(&ovl
, 0, sizeof(ovl
));
9935 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
9936 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
9939 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9940 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9942 buf
.len
= sizeof(data
);
9946 SetLastError(0xdeadbeef);
9947 ret
= WSARecv(src
, &buf
, 1, &bytes
, &flags
, &ovl
, NULL
);
9948 ok(ret
== SOCKET_ERROR
, "got %d\n", ret
);
9949 ok(GetLastError() == ERROR_IO_PENDING
, "got %u\n", GetLastError());
9950 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9953 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9954 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9958 ovl_iocp
= (void *)0xdeadbeef;
9959 SetLastError(0xdeadbeef);
9960 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9961 ok(!ret
, "got %d\n", ret
);
9962 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
9963 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9964 ok(key
== 0xdeadbeef, "got key %#lx\n", key
);
9965 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
9968 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9969 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9971 switch (how_to_close
)
9977 CloseHandle((HANDLE
)src
);
9980 pNtClose((HANDLE
)src
);
9983 ok(0, "wrong value %d\n", how_to_close
);
9988 memset(&msg
, 0, sizeof(msg
));
9989 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9990 switch (how_to_close
)
9993 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9999 ok(ret
, "got %d\n", ret
);
10000 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
10001 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
10002 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
10003 ok(msg
.lParam
== 0x20, "got %08lx\n", msg
.lParam
);
10007 ok(0, "wrong value %d\n", how_to_close
);
10011 bytes
= 0xdeadbeef;
10014 SetLastError(0xdeadbeef);
10015 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10016 ok(!ret
, "got %d\n", ret
);
10018 ok(GetLastError() == ERROR_CONNECTION_ABORTED
|| GetLastError() == ERROR_NETNAME_DELETED
/* XP */, "got %u\n", GetLastError());
10019 ok(!bytes
, "got bytes %u\n", bytes
);
10020 ok(key
== 0x12345678, "got key %#lx\n", key
);
10021 ok(ovl_iocp
== &ovl
, "got ovl %p\n", ovl_iocp
);
10024 ok(!ovl_iocp
->InternalHigh
, "got %#lx\n", ovl_iocp
->InternalHigh
);
10026 ok(ovl_iocp
->Internal
== (ULONG
)STATUS_CONNECTION_ABORTED
|| ovl_iocp
->Internal
== (ULONG
)STATUS_LOCAL_DISCONNECT
/* XP */, "got %#lx\n", ovl_iocp
->Internal
);
10029 bytes
= 0xdeadbeef;
10031 ovl_iocp
= (void *)0xdeadbeef;
10032 SetLastError(0xdeadbeef);
10033 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10034 ok(!ret
, "got %d\n", ret
);
10035 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
10036 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
10037 ok(key
== 0xdeadbeef, "got key %#lx\n", key
);
10038 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
10042 DestroyWindow(hwnd
);
10045 static void iocp_async_closesocket(SOCKET src
)
10048 WSAOVERLAPPED
*ovl_iocp
;
10055 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
10056 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
10057 ok(hwnd
!= 0, "CreateWindowEx failed\n");
10059 ret
= WSAAsyncSelect(src
, hwnd
, WM_SOCKET
, FD_READ
| FD_WRITE
| FD_OOB
| FD_ACCEPT
| FD_CONNECT
| FD_CLOSE
);
10060 ok(!ret
, "got %d\n", ret
);
10063 memset(&msg
, 0, sizeof(msg
));
10064 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10065 ok(ret
, "got %d\n", ret
);
10066 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
10067 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
10068 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
10069 ok(msg
.lParam
== 2, "got %08lx\n", msg
.lParam
);
10071 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
10072 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
10075 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10076 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10078 bytes
= 0xdeadbeef;
10080 ovl_iocp
= (void *)0xdeadbeef;
10081 SetLastError(0xdeadbeef);
10082 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10083 ok(!ret
, "got %d\n", ret
);
10084 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
10085 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
10086 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
10087 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
10090 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10091 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10096 memset(&msg
, 0, sizeof(msg
));
10097 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10098 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10100 bytes
= 0xdeadbeef;
10102 ovl_iocp
= (void *)0xdeadbeef;
10103 SetLastError(0xdeadbeef);
10104 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10105 ok(!ret
, "got %d\n", ret
);
10106 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
10107 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
10108 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
10109 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
10113 DestroyWindow(hwnd
);
10116 struct wsa_async_select_info
10122 static DWORD WINAPI
wsa_async_select_thread(void *param
)
10124 struct wsa_async_select_info
*info
= param
;
10127 ret
= WSAAsyncSelect(info
->sock
, info
->hwnd
, WM_SOCKET
, FD_READ
| FD_WRITE
| FD_OOB
| FD_ACCEPT
| FD_CONNECT
| FD_CLOSE
);
10128 ok(!ret
, "got %d\n", ret
);
10133 struct wsa_recv_info
10140 static DWORD WINAPI
wsa_recv_thread(void *param
)
10142 struct wsa_recv_info
*info
= param
;
10144 DWORD flags
, bytes
;
10146 bytes
= 0xdeadbeef;
10148 SetLastError(0xdeadbeef);
10149 ret
= WSARecv(info
->sock
, &info
->wsa_buf
, 1, &bytes
, &flags
, &info
->ovl
, NULL
);
10150 ok(ret
== SOCKET_ERROR
, "got %d\n", ret
);
10151 ok(GetLastError() == ERROR_IO_PENDING
, "got %u\n", GetLastError());
10152 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
10157 static void iocp_async_read_thread_closesocket(SOCKET src
)
10159 struct wsa_async_select_info select_info
;
10160 struct wsa_recv_info recv_info
;
10161 HANDLE port
, thread
;
10162 WSAOVERLAPPED
*ovl_iocp
;
10170 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
10171 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
10172 ok(hwnd
!= 0, "CreateWindowEx failed\n");
10174 select_info
.sock
= src
;
10175 select_info
.hwnd
= hwnd
;
10176 thread
= CreateThread(NULL
, 0, wsa_async_select_thread
, &select_info
, 0, &tid
);
10177 ok(thread
!= 0, "CreateThread error %u\n", GetLastError());
10178 ret
= WaitForSingleObject(thread
, 10000);
10179 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
10182 memset(&msg
, 0, sizeof(msg
));
10183 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10184 ok(ret
, "got %d\n", ret
);
10185 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
10186 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
10187 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
10188 ok(msg
.lParam
== 2, "got %08lx\n", msg
.lParam
);
10190 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
10191 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
10194 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10195 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10197 memset(data
, 0, sizeof(data
));
10198 memset(&recv_info
.ovl
, 0, sizeof(recv_info
.ovl
));
10199 recv_info
.sock
= src
;
10200 recv_info
.wsa_buf
.len
= sizeof(data
);
10201 recv_info
.wsa_buf
.buf
= data
;
10202 thread
= CreateThread(NULL
, 0, wsa_recv_thread
, &recv_info
, 0, &tid
);
10203 ok(thread
!= 0, "CreateThread error %u\n", GetLastError());
10204 ret
= WaitForSingleObject(thread
, 10000);
10205 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
10208 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10209 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10211 bytes
= 0xdeadbeef;
10213 ovl_iocp
= (void *)0xdeadbeef;
10214 SetLastError(0xdeadbeef);
10215 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10216 ok(!ret
, "got %d\n", ret
);
10217 ok(GetLastError() == WAIT_TIMEOUT
|| broken(GetLastError() == ERROR_OPERATION_ABORTED
) /* XP */,
10218 "got %u\n", GetLastError());
10219 if (GetLastError() == WAIT_TIMEOUT
)
10221 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
10222 ok(key
== 0xdeadbeef, "got key %lx\n", key
);
10223 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
10225 else /* document XP behaviour */
10227 ok(!bytes
, "got bytes %u\n", bytes
);
10228 ok(key
== 0x12345678, "got key %#lx\n", key
);
10229 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
10232 ok(!ovl_iocp
->InternalHigh
, "got %#lx\n", ovl_iocp
->InternalHigh
);
10233 ok(ovl_iocp
->Internal
== STATUS_CANCELLED
, "got %#lx\n", ovl_iocp
->Internal
);
10241 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10242 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10247 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10248 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10250 bytes
= 0xdeadbeef;
10253 SetLastError(0xdeadbeef);
10254 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10255 ok(!ret
, "got %d\n", ret
);
10257 ok(GetLastError() == ERROR_CONNECTION_ABORTED
|| GetLastError() == ERROR_NETNAME_DELETED
/* XP */, "got %u\n", GetLastError());
10258 ok(!bytes
, "got bytes %u\n", bytes
);
10259 ok(key
== 0x12345678, "got key %#lx\n", key
);
10260 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
10263 ok(!ovl_iocp
->InternalHigh
, "got %#lx\n", ovl_iocp
->InternalHigh
);
10265 ok(ovl_iocp
->Internal
== (ULONG
)STATUS_CONNECTION_ABORTED
|| ovl_iocp
->Internal
== (ULONG
)STATUS_LOCAL_DISCONNECT
/* XP */, "got %#lx\n", ovl_iocp
->Internal
);
10269 bytes
= 0xdeadbeef;
10271 ovl_iocp
= (void *)0xdeadbeef;
10272 SetLastError(0xdeadbeef);
10273 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10274 ok(!ret
, "got %d\n", ret
);
10275 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
10276 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
10277 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
10278 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
10282 DestroyWindow(hwnd
);
10285 static void iocp_async_read_thread(SOCKET src
, SOCKET dst
)
10287 struct wsa_async_select_info select_info
;
10288 struct wsa_recv_info recv_info
;
10289 HANDLE port
, thread
;
10290 WSAOVERLAPPED
*ovl_iocp
;
10298 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
10299 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
10300 ok(hwnd
!= 0, "CreateWindowEx failed\n");
10302 select_info
.sock
= src
;
10303 select_info
.hwnd
= hwnd
;
10304 thread
= CreateThread(NULL
, 0, wsa_async_select_thread
, &select_info
, 0, &tid
);
10305 ok(thread
!= 0, "CreateThread error %u\n", GetLastError());
10306 ret
= WaitForSingleObject(thread
, 10000);
10307 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
10310 memset(&msg
, 0, sizeof(msg
));
10311 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10312 ok(ret
, "got %d\n", ret
);
10313 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
10314 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
10315 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
10316 ok(msg
.lParam
== 2, "got %08lx\n", msg
.lParam
);
10318 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
10319 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
10322 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10323 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10325 memset(data
, 0, sizeof(data
));
10326 memset(&recv_info
.ovl
, 0, sizeof(recv_info
.ovl
));
10327 recv_info
.sock
= src
;
10328 recv_info
.wsa_buf
.len
= sizeof(data
);
10329 recv_info
.wsa_buf
.buf
= data
;
10330 thread
= CreateThread(NULL
, 0, wsa_recv_thread
, &recv_info
, 0, &tid
);
10331 ok(thread
!= 0, "CreateThread error %u\n", GetLastError());
10332 ret
= WaitForSingleObject(thread
, 10000);
10333 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
10336 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10337 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10339 bytes
= 0xdeadbeef;
10341 ovl_iocp
= (void *)0xdeadbeef;
10342 SetLastError(0xdeadbeef);
10343 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10344 ok(!ret
, "got %d\n", ret
);
10345 ok(GetLastError() == WAIT_TIMEOUT
|| broken(GetLastError() == ERROR_OPERATION_ABORTED
) /* XP */, "got %u\n", GetLastError());
10346 if (GetLastError() == WAIT_TIMEOUT
)
10348 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
10349 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
10350 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
10352 else /* document XP behaviour */
10354 ok(bytes
== 0, "got bytes %u\n", bytes
);
10355 ok(key
== 0x12345678, "got key %#lx\n", key
);
10356 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
10359 ok(!ovl_iocp
->InternalHigh
, "got %#lx\n", ovl_iocp
->InternalHigh
);
10360 ok(ovl_iocp
->Internal
== STATUS_CANCELLED
, "got %#lx\n", ovl_iocp
->Internal
);
10365 memset(&msg
, 0, sizeof(msg
));
10366 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10367 ok(!ret
|| broken(msg
.hwnd
== hwnd
) /* XP */, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10368 if (ret
) /* document XP behaviour */
10370 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
10371 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
10372 ok(msg
.lParam
== 1, "got %08lx\n", msg
.lParam
);
10375 ret
= send(dst
, "Hello World!", 12, 0);
10376 ok(ret
== 12, "send returned %d\n", ret
);
10379 memset(&msg
, 0, sizeof(msg
));
10380 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
10381 ok(!ret
|| broken(msg
.hwnd
== hwnd
) /* XP */, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
10382 if (ret
) /* document XP behaviour */
10384 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
10385 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
10386 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
10387 ok(msg
.lParam
== 1, "got %08lx\n", msg
.lParam
);
10390 bytes
= 0xdeadbeef;
10392 ovl_iocp
= (void *)0xdeadbeef;
10393 SetLastError(0xdeadbeef);
10394 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
10395 ok(ret
|| broken(GetLastError() == WAIT_TIMEOUT
) /* XP */, "got %u\n", GetLastError());
10398 ok(bytes
== 12, "got bytes %u\n", bytes
);
10399 ok(key
== 0x12345678, "got key %#lx\n", key
);
10400 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
10403 ok(ovl_iocp
->InternalHigh
== 12, "got %#lx\n", ovl_iocp
->InternalHigh
);
10404 ok(!ovl_iocp
->Internal
, "got %#lx\n", ovl_iocp
->Internal
);
10405 ok(!memcmp(data
, "Hello World!", 12), "got %u bytes (%*s)\n", bytes
, bytes
, data
);
10408 else /* document XP behaviour */
10410 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
10411 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
10412 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
10417 DestroyWindow(hwnd
);
10420 static void test_iocp(void)
10425 tcp_socketpair(&src
, &dst
);
10426 sync_read(src
, dst
);
10427 iocp_async_read(src
, dst
);
10431 tcp_socketpair(&src
, &dst
);
10432 iocp_async_read_thread(src
, dst
);
10436 for (i
= 0; i
<= 2; i
++)
10438 tcp_socketpair(&src
, &dst
);
10439 iocp_async_read_closesocket(src
, i
);
10443 tcp_socketpair(&src
, &dst
);
10444 iocp_async_closesocket(src
);
10447 tcp_socketpair(&src
, &dst
);
10448 iocp_async_read_thread_closesocket(src
);
10452 static void test_get_interface_list(void)
10454 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
10455 DWORD size
, expect_size
;
10456 unsigned int i
, count
;
10457 INTERFACE_INFO
*info
;
10458 BOOL loopback_found
;
10465 s
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
10466 ok(s
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
10467 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
10470 WSASetLastError(0xdeadbeef);
10471 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(buffer
), &size
, NULL
, NULL
);
10472 ok(!ret
, "Got unexpected ret %d.\n", ret
);
10473 ok(!WSAGetLastError(), "Got error %u.\n", WSAGetLastError());
10474 ok(size
&& size
!= 0xdeadbeef && !(size
% sizeof(INTERFACE_INFO
)), "Got unexpected size %u.\n", size
);
10475 expect_size
= size
;
10478 overlapped
.Internal
= 0xdeadbeef;
10479 overlapped
.InternalHigh
= 0xdeadbeef;
10480 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(buffer
), &size
, &overlapped
, NULL
);
10481 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
10482 ok(WSAGetLastError() == ERROR_IO_PENDING
, "Got error %u.\n", WSAGetLastError());
10483 ok(size
== 0xdeadbeef, "Got size %u.\n", size
);
10485 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 100);
10486 ok(ret
, "Got error %u.\n", GetLastError());
10487 ok(size
== expect_size
, "Expected size %u, got %u.\n", expect_size
, size
);
10488 ok(key
== 123, "Got key %Iu.\n", key
);
10489 ok(overlapped_ptr
== &overlapped
, "Got overlapped %p.\n", overlapped_ptr
);
10490 ok(!overlapped
.Internal
, "Got status %#x.\n", (NTSTATUS
)overlapped
.Internal
);
10491 ok(overlapped
.InternalHigh
== expect_size
, "Expected size %u, got %Iu.\n", expect_size
, overlapped
.InternalHigh
);
10493 info
= (INTERFACE_INFO
*)buffer
;
10494 count
= size
/ sizeof(INTERFACE_INFO
);
10495 loopback_found
= FALSE
;
10496 for (i
= 0; i
< count
; ++i
)
10498 if (info
[i
].iiFlags
& IFF_LOOPBACK
)
10499 loopback_found
= TRUE
;
10501 ok(info
[i
].iiAddress
.AddressIn
.sin_family
== AF_INET
, "Got unexpected sin_family %#x.\n",
10502 info
[i
].iiAddress
.AddressIn
.sin_family
);
10503 ok(info
[i
].iiNetmask
.AddressIn
.sin_family
== AF_INET
, "Got unexpected sin_family %#x.\n",
10504 info
[i
].iiNetmask
.AddressIn
.sin_family
);
10505 ok(info
[i
].iiBroadcastAddress
.AddressIn
.sin_family
10506 == (info
[i
].iiFlags
& IFF_BROADCAST
) ? AF_INET
: 0, "Got unexpected sin_family %#x.\n",
10507 info
[i
].iiBroadcastAddress
.AddressIn
.sin_family
);
10508 ok(info
[i
].iiAddress
.AddressIn
.sin_addr
.S_un
.S_addr
, "Got zero iiAddress.\n");
10509 ok(info
[i
].iiNetmask
.AddressIn
.sin_addr
.S_un
.S_addr
, "Got zero iiNetmask.\n");
10510 ok((info
[i
].iiFlags
& IFF_BROADCAST
) ? info
[i
].iiBroadcastAddress
.AddressIn
.sin_addr
.S_un
.S_addr
10511 : !info
[i
].iiBroadcastAddress
.AddressIn
.sin_addr
.S_un
.S_addr
,
10512 "Got unexpected iiBroadcastAddress %s.\n", inet_ntoa(info
[i
].iiBroadcastAddress
.AddressIn
.sin_addr
));
10515 ok(loopback_found
, "Loopback interface not found.\n");
10518 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(INTERFACE_INFO
) - 1, &size
, NULL
, NULL
);
10519 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
10520 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
10521 ok(!size
, "Got unexpected size %u.\n", size
);
10524 overlapped
.Internal
= 0xdeadbeef;
10525 overlapped
.InternalHigh
= 0xdeadbeef;
10526 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(INTERFACE_INFO
) - 1, &size
, &overlapped
, NULL
);
10527 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
10528 ok(WSAGetLastError() == ERROR_IO_PENDING
, "Got error %u.\n", WSAGetLastError());
10529 ok(size
== 0xdeadbeef, "Got size %u.\n", size
);
10531 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 100);
10532 ok(!ret
, "Expected failure.\n");
10533 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER
, "Got error %u.\n", GetLastError());
10534 ok(!size
, "Got size %u.\n", size
);
10535 ok(key
== 123, "Got key %Iu.\n", key
);
10536 ok(overlapped_ptr
== &overlapped
, "Got overlapped %p.\n", overlapped_ptr
);
10537 ok((NTSTATUS
)overlapped
.Internal
== STATUS_BUFFER_TOO_SMALL
, "Got status %#x.\n", (NTSTATUS
)overlapped
.Internal
);
10538 ok(!overlapped
.InternalHigh
, "Got size %Iu.\n", overlapped
.InternalHigh
);
10540 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(buffer
), NULL
, NULL
, NULL
);
10541 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
10542 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
10547 /* Test with an APC. */
10549 s
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
10550 ok(s
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
10554 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
,
10555 sizeof(INTERFACE_INFO
) - 1, &size
, &overlapped
, socket_apc
);
10556 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
10557 ok(WSAGetLastError() == ERROR_IO_PENDING
, "Got error %u.\n", WSAGetLastError());
10558 ok(size
== 0xdeadbeef, "Got size %u.\n", size
);
10560 ret
= SleepEx(100, TRUE
);
10561 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
10562 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
10563 ok(apc_error
== WSAEFAULT
, "got APC error %u\n", apc_error
);
10564 ok(!apc_size
, "got APC size %u\n", apc_size
);
10565 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
10570 static void test_bind(void)
10572 const struct sockaddr_in invalid_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= inet_addr("192.0.2.0")};
10573 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
10574 IP_ADAPTER_ADDRESSES
*adapters
= NULL
, *adapter
;
10575 ULONG ip_addrs_size
= 0;
10576 struct sockaddr addr
;
10580 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
10582 WSASetLastError(0xdeadbeef);
10583 ret
= bind(s
, NULL
, 0);
10584 ok(ret
== -1, "expected failure\n");
10585 todo_wine
ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
10587 addr
.sa_family
= 0xdead;
10588 WSASetLastError(0xdeadbeef);
10589 ret
= bind(s
, &addr
, sizeof(addr
));
10590 ok(ret
== -1, "expected failure\n");
10591 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "got error %u\n", WSAGetLastError());
10593 WSASetLastError(0xdeadbeef);
10594 ret
= bind(s
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
) - 1);
10595 ok(ret
== -1, "expected failure\n");
10596 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
10598 WSASetLastError(0xdeadbeef);
10599 ret
= bind(s
, (const struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
10600 ok(ret
== -1, "expected failure\n");
10601 ok(WSAGetLastError() == WSAEADDRNOTAVAIL
, "got error %u\n", WSAGetLastError());
10603 WSASetLastError(0xdeadbeef);
10604 ret
= bind(s
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
10605 ok(!ret
, "expected success\n");
10606 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
10608 WSASetLastError(0xdeadbeef);
10609 ret
= bind(s
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
10610 ok(ret
== -1, "expected failure\n");
10611 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
10613 len
= sizeof(addr
);
10614 ret
= getsockname(s
, &addr
, &len
);
10615 ok(!ret
, "got error %u\n", WSAGetLastError());
10617 s2
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
10619 WSASetLastError(0xdeadbeef);
10620 ret
= bind(s2
, &addr
, sizeof(addr
));
10621 ok(ret
== -1, "expected failure\n");
10622 ok(WSAGetLastError() == WSAEADDRINUSE
, "got error %u\n", WSAGetLastError());
10627 s
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
10629 WSASetLastError(0xdeadbeef);
10630 ret
= bind(s
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
10631 ok(!ret
, "expected success\n");
10632 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
10636 ret
= GetAdaptersAddresses(AF_UNSPEC
, 0, NULL
, adapters
, &ip_addrs_size
);
10637 ok(ret
== ERROR_BUFFER_OVERFLOW
, "got error %u\n", ret
);
10638 adapters
= malloc(ip_addrs_size
);
10639 ret
= GetAdaptersAddresses(AF_UNSPEC
, 0, NULL
, adapters
, &ip_addrs_size
);
10640 ok(!ret
, "got error %u\n", ret
);
10642 for (adapter
= adapters
; adapter
!= NULL
; adapter
= adapter
->Next
)
10644 const IP_ADAPTER_UNICAST_ADDRESS
*unicast_addr
;
10646 for (unicast_addr
= adapter
->FirstUnicastAddress
; unicast_addr
!= NULL
; unicast_addr
= unicast_addr
->Next
)
10648 short family
= unicast_addr
->Address
.lpSockaddr
->sa_family
;
10650 s
= socket(family
, SOCK_STREAM
, IPPROTO_TCP
);
10651 ok(s
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
10653 ret
= bind(s
, unicast_addr
->Address
.lpSockaddr
, unicast_addr
->Address
.iSockaddrLength
);
10654 ok(!ret
, "got error %u\n", WSAGetLastError());
10658 if (family
== AF_INET6
)
10660 struct sockaddr_in6 addr6
, ret_addr6
;
10662 memcpy(&addr6
, unicast_addr
->Address
.lpSockaddr
, sizeof(addr6
));
10664 ok(unicast_addr
->Address
.iSockaddrLength
== sizeof(struct sockaddr_in6
),
10665 "got unexpected length %u\n", unicast_addr
->Address
.iSockaddrLength
);
10667 s
= socket(family
, SOCK_STREAM
, IPPROTO_TCP
);
10668 ok(s
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
10670 ret
= bind(s
, unicast_addr
->Address
.lpSockaddr
, sizeof(struct sockaddr_in6_old
));
10671 ok(ret
== -1, "expected failure\n");
10672 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
10674 addr6
.sin6_scope_id
= 0xabacab;
10675 ret
= bind(s
, (struct sockaddr
*)&addr6
, sizeof(addr6
));
10676 todo_wine_if (!((const struct sockaddr_in6
*)unicast_addr
->Address
.lpSockaddr
)->sin6_scope_id
)
10678 ok(ret
== -1, "expected failure\n");
10679 ok(WSAGetLastError() == WSAEADDRNOTAVAIL
, "got error %u\n", WSAGetLastError());
10682 addr6
.sin6_scope_id
= 0;
10683 ret
= bind(s
, (struct sockaddr
*)&addr6
, sizeof(addr6
));
10684 todo_wine_if (!((const struct sockaddr_in6
*)unicast_addr
->Address
.lpSockaddr
)->sin6_scope_id
)
10685 ok(!ret
, "got error %u\n", WSAGetLastError());
10687 memcpy(&addr6
, unicast_addr
->Address
.lpSockaddr
, sizeof(addr6
));
10689 len
= sizeof(struct sockaddr_in6_old
);
10690 ret
= getsockname(s
, (struct sockaddr
*)&ret_addr6
, &len
);
10691 ok(ret
== -1, "expected failure\n");
10692 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
10694 len
= sizeof(ret_addr6
);
10695 memset(&ret_addr6
, 0, sizeof(ret_addr6
));
10696 ret
= getsockname(s
, (struct sockaddr
*)&ret_addr6
, &len
);
10697 ok(!ret
, "got error %u\n", WSAGetLastError());
10698 ok(ret_addr6
.sin6_family
== AF_INET6
, "got family %u\n", ret_addr6
.sin6_family
);
10699 ok(ret_addr6
.sin6_port
!= 0, "expected nonzero port\n");
10700 ok(!memcmp(&ret_addr6
.sin6_addr
, &addr6
.sin6_addr
, sizeof(addr6
.sin6_addr
)), "address didn't match\n");
10701 ok(ret_addr6
.sin6_scope_id
== addr6
.sin6_scope_id
, "got scope %u\n", ret_addr6
.sin6_scope_id
);
10711 /* Test calling methods on a socket which is currently connecting. */
10712 static void test_connecting_socket(void)
10714 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_ANY
)};
10715 const struct sockaddr_in invalid_addr
=
10717 .sin_family
= AF_INET
,
10718 .sin_addr
.s_addr
= inet_addr("192.0.2.0"),
10721 OVERLAPPED overlapped
= {0}, overlapped2
= {0};
10722 GUID connectex_guid
= WSAID_CONNECTEX
;
10723 LPFN_CONNECTEX pConnectEx
;
10724 struct sockaddr_in addr
;
10730 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
10731 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
10732 set_blocking(client
, FALSE
);
10734 ret
= bind(client
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
10735 ok(!ret
, "expected success\n");
10736 ok(!WSAGetLastError(), "got %u\n", WSAGetLastError());
10738 ret
= connect(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
10739 ok(ret
== -1, "got %d\n", ret
);
10740 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got %u\n", WSAGetLastError());
10742 /* Mortal Kombat 11 connects to the same address twice and expects the
10743 * second to return WSAEALREADY. */
10744 ret
= connect(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
10745 ok(ret
== -1, "got %d\n", ret
);
10746 ok(WSAGetLastError() == WSAEALREADY
, "got %u\n", WSAGetLastError());
10748 ret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectex_guid
, sizeof(connectex_guid
),
10749 &pConnectEx
, sizeof(pConnectEx
), &size
, NULL
, NULL
);
10750 ok(!ret
, "failed to get ConnectEx, error %u\n", WSAGetLastError());
10751 overlapped
.Internal
= 0xdeadbeef;
10752 overlapped
.InternalHigh
= 0xdeadbeef;
10753 ret
= pConnectEx(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
), NULL
, 0, &size
, &overlapped
);
10754 ok(!ret
, "got %d\n", ret
);
10755 ok(WSAGetLastError() == WSAEINVAL
, "got %u\n", WSAGetLastError());
10756 ok((NTSTATUS
)overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
10757 todo_wine
ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
10759 len
= sizeof(addr
);
10760 ret
= getsockname(client
, (struct sockaddr
*)&addr
, &len
);
10761 ok(!ret
, "got error %u\n", WSAGetLastError());
10762 ok(addr
.sin_family
== AF_INET
, "got family %u\n", addr
.sin_family
);
10763 ok(addr
.sin_port
, "expected nonzero port\n");
10765 len
= sizeof(addr
);
10766 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &len
);
10767 todo_wine
ok(!ret
, "got error %u\n", WSAGetLastError());
10770 ok(addr
.sin_family
== AF_INET
, "got family %u\n", addr
.sin_family
);
10771 ok(addr
.sin_addr
.s_addr
== inet_addr("192.0.2.0"), "got address %#08x\n", addr
.sin_addr
.s_addr
);
10772 ok(addr
.sin_port
== 255, "expected nonzero port\n");
10775 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
10776 ok(ret
== -1, "got %d\n", ret
);
10777 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got %u\n", WSAGetLastError());
10779 ret
= send(client
, "data", 5, 0);
10780 ok(ret
== -1, "got %d\n", ret
);
10781 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got %u\n", WSAGetLastError());
10783 closesocket(client
);
10785 /* Test with ConnectEx(). */
10787 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
10788 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
10789 set_blocking(client
, FALSE
);
10791 ret
= bind(client
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
10792 ok(!ret
, "expected success\n");
10793 ok(!WSAGetLastError(), "got %u\n", WSAGetLastError());
10795 ret
= pConnectEx(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
), NULL
, 0, &size
, &overlapped2
);
10796 ok(!ret
, "got %d\n", ret
);
10797 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
10799 ret
= connect(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
10800 ok(ret
== -1, "got %d\n", ret
);
10801 ok(WSAGetLastError() == WSAEINVAL
, "got %u\n", WSAGetLastError());
10803 overlapped
.Internal
= 0xdeadbeef;
10804 overlapped
.InternalHigh
= 0xdeadbeef;
10805 ret
= pConnectEx(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
), NULL
, 0, &size
, &overlapped
);
10806 ok(!ret
, "got %d\n", ret
);
10807 ok(WSAGetLastError() == WSAEINVAL
, "got %u\n", WSAGetLastError());
10808 ok((NTSTATUS
)overlapped
.Internal
== STATUS_PENDING
, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
10809 todo_wine
ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
10811 len
= sizeof(addr
);
10812 ret
= getsockname(client
, (struct sockaddr
*)&addr
, &len
);
10813 ok(!ret
, "got error %u\n", WSAGetLastError());
10814 ok(addr
.sin_family
== AF_INET
, "got family %u\n", addr
.sin_family
);
10815 ok(addr
.sin_port
, "expected nonzero port\n");
10817 len
= sizeof(addr
);
10818 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &len
);
10819 ok(ret
== -1, "got %d\n", ret
);
10820 ok(WSAGetLastError() == WSAENOTCONN
, "got %u\n", WSAGetLastError());
10822 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
10823 ok(ret
== -1, "got %d\n", ret
);
10824 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got %u\n", WSAGetLastError());
10826 ret
= send(client
, "data", 5, 0);
10827 ok(ret
== -1, "got %d\n", ret
);
10828 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got %u\n", WSAGetLastError());
10830 closesocket(client
);
10833 static DWORD
map_status( NTSTATUS status
)
10835 static const struct
10842 {STATUS_PENDING
, ERROR_IO_INCOMPLETE
},
10844 {STATUS_BUFFER_OVERFLOW
, WSAEMSGSIZE
},
10846 {STATUS_NOT_IMPLEMENTED
, WSAEOPNOTSUPP
},
10847 {STATUS_ACCESS_VIOLATION
, WSAEFAULT
},
10848 {STATUS_PAGEFILE_QUOTA
, WSAENOBUFS
},
10849 {STATUS_INVALID_HANDLE
, WSAENOTSOCK
},
10850 {STATUS_NO_SUCH_DEVICE
, WSAENETDOWN
},
10851 {STATUS_NO_SUCH_FILE
, WSAENETDOWN
},
10852 {STATUS_NO_MEMORY
, WSAENOBUFS
},
10853 {STATUS_CONFLICTING_ADDRESSES
, WSAENOBUFS
},
10854 {STATUS_ACCESS_DENIED
, WSAEACCES
},
10855 {STATUS_BUFFER_TOO_SMALL
, WSAEFAULT
},
10856 {STATUS_OBJECT_TYPE_MISMATCH
, WSAENOTSOCK
},
10857 {STATUS_OBJECT_NAME_NOT_FOUND
, WSAENETDOWN
},
10858 {STATUS_OBJECT_PATH_NOT_FOUND
, WSAENETDOWN
},
10859 {STATUS_SHARING_VIOLATION
, WSAEADDRINUSE
},
10860 {STATUS_QUOTA_EXCEEDED
, WSAENOBUFS
},
10861 {STATUS_TOO_MANY_PAGING_FILES
, WSAENOBUFS
},
10862 {STATUS_INSUFFICIENT_RESOURCES
, WSAENOBUFS
},
10863 {STATUS_WORKING_SET_QUOTA
, WSAENOBUFS
},
10864 {STATUS_DEVICE_NOT_READY
, WSAEWOULDBLOCK
},
10865 {STATUS_PIPE_DISCONNECTED
, WSAESHUTDOWN
},
10866 {STATUS_IO_TIMEOUT
, WSAETIMEDOUT
},
10867 {STATUS_NOT_SUPPORTED
, WSAEOPNOTSUPP
},
10868 {STATUS_REMOTE_NOT_LISTENING
, WSAECONNREFUSED
},
10869 {STATUS_BAD_NETWORK_PATH
, WSAENETUNREACH
},
10870 {STATUS_NETWORK_BUSY
, WSAENETDOWN
},
10871 {STATUS_INVALID_NETWORK_RESPONSE
, WSAENETDOWN
},
10872 {STATUS_UNEXPECTED_NETWORK_ERROR
, WSAENETDOWN
},
10873 {STATUS_REQUEST_NOT_ACCEPTED
, WSAEWOULDBLOCK
},
10874 {STATUS_CANCELLED
, ERROR_OPERATION_ABORTED
},
10875 {STATUS_COMMITMENT_LIMIT
, WSAENOBUFS
},
10876 {STATUS_LOCAL_DISCONNECT
, WSAECONNABORTED
},
10877 {STATUS_REMOTE_DISCONNECT
, WSAECONNRESET
},
10878 {STATUS_REMOTE_RESOURCES
, WSAENOBUFS
},
10879 {STATUS_LINK_FAILED
, WSAECONNRESET
},
10880 {STATUS_LINK_TIMEOUT
, WSAETIMEDOUT
},
10881 {STATUS_INVALID_CONNECTION
, WSAENOTCONN
},
10882 {STATUS_INVALID_ADDRESS
, WSAEADDRNOTAVAIL
},
10883 {STATUS_INVALID_BUFFER_SIZE
, WSAEMSGSIZE
},
10884 {STATUS_INVALID_ADDRESS_COMPONENT
, WSAEADDRNOTAVAIL
},
10885 {STATUS_TOO_MANY_ADDRESSES
, WSAENOBUFS
},
10886 {STATUS_ADDRESS_ALREADY_EXISTS
, WSAEADDRINUSE
},
10887 {STATUS_CONNECTION_DISCONNECTED
, WSAECONNRESET
},
10888 {STATUS_CONNECTION_RESET
, WSAECONNRESET
},
10889 {STATUS_TRANSACTION_ABORTED
, WSAECONNABORTED
},
10890 {STATUS_CONNECTION_REFUSED
, WSAECONNREFUSED
},
10891 {STATUS_GRACEFUL_DISCONNECT
, WSAEDISCON
},
10892 {STATUS_CONNECTION_ACTIVE
, WSAEISCONN
},
10893 {STATUS_NETWORK_UNREACHABLE
, WSAENETUNREACH
},
10894 {STATUS_HOST_UNREACHABLE
, WSAEHOSTUNREACH
},
10895 {STATUS_PROTOCOL_UNREACHABLE
, WSAENETUNREACH
},
10896 {STATUS_PORT_UNREACHABLE
, WSAECONNRESET
},
10897 {STATUS_REQUEST_ABORTED
, WSAEINTR
},
10898 {STATUS_CONNECTION_ABORTED
, WSAECONNABORTED
},
10899 {STATUS_DATATYPE_MISALIGNMENT_ERROR
,WSAEFAULT
},
10900 {STATUS_HOST_DOWN
, WSAEHOSTDOWN
},
10901 {0x80070000 | ERROR_IO_INCOMPLETE
, ERROR_IO_INCOMPLETE
},
10902 {0xc0010000 | ERROR_IO_INCOMPLETE
, ERROR_IO_INCOMPLETE
},
10903 {0xc0070000 | ERROR_IO_INCOMPLETE
, ERROR_IO_INCOMPLETE
},
10908 for (i
= 0; i
< ARRAY_SIZE(errors
); ++i
)
10910 if (errors
[i
].status
== status
)
10911 return errors
[i
].error
;
10914 return NT_SUCCESS(status
) ? RtlNtStatusToDosErrorNoTeb(status
) : WSAEINVAL
;
10917 static void test_WSAGetOverlappedResult(void)
10919 OVERLAPPED overlapped
= {0};
10926 static const NTSTATUS ranges
[][2] =
10929 {0x40000000, 0x40001000},
10930 {0x80000000, 0x80001000},
10931 {0x80070000, 0x80080000},
10932 {0xc0000000, 0xc0001000},
10933 {0xc0070000, 0xc0080000},
10934 {0xd0000000, 0xd0001000},
10935 {0xd0070000, 0xd0080000},
10938 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
10940 for (i
= 0; i
< ARRAY_SIZE(ranges
); ++i
)
10942 for (status
= ranges
[i
][0]; status
< ranges
[i
][1]; ++status
)
10944 BOOL expect_ret
= NT_SUCCESS(status
) && status
!= STATUS_PENDING
;
10945 DWORD expect
= map_status(status
);
10947 overlapped
.Internal
= status
;
10948 WSASetLastError(0xdeadbeef);
10949 ret
= WSAGetOverlappedResult(s
, &overlapped
, &size
, FALSE
, &flags
);
10950 ok(ret
== expect_ret
, "status %#x: expected %d, got %d\n", status
, expect_ret
, ret
);
10953 ok(WSAGetLastError() == expect
/* >= win10 1809 */
10954 || !WSAGetLastError() /* < win10 1809 */
10955 || WSAGetLastError() == 0xdeadbeef, /* < win7 */
10956 "status %#x: expected error %u, got %u\n", status
, expect
, WSAGetLastError());
10960 ok(WSAGetLastError() == expect
10961 || (status
== (0xc0070000 | ERROR_IO_INCOMPLETE
) && WSAGetLastError() == WSAEINVAL
), /* < win8 */
10962 "status %#x: expected error %u, got %u\n", status
, expect
, WSAGetLastError());
10970 struct nonblocking_async_recv_params
10976 static DWORD CALLBACK
nonblocking_async_recv_thread(void *arg
)
10978 const struct nonblocking_async_recv_params
*params
= arg
;
10979 OVERLAPPED overlapped
= {0};
10980 DWORD flags
= 0, size
;
10985 overlapped
.hEvent
= params
->event
;
10986 wsabuf
.buf
= buffer
;
10987 wsabuf
.len
= sizeof(buffer
);
10988 memset(buffer
, 0, sizeof(buffer
));
10989 ret
= WSARecv(params
->client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
10990 ok(!ret
, "got %d\n", ret
);
10991 ret
= GetOverlappedResult((HANDLE
)params
->client
, &overlapped
, &size
, FALSE
);
10992 ok(ret
, "got error %u\n", GetLastError());
10993 ok(size
== 4, "got size %u\n", size
);
10994 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
10999 static void test_nonblocking_async_recv(void)
11001 struct nonblocking_async_recv_params params
;
11002 OVERLAPPED overlapped
= {0};
11003 SOCKET client
, server
;
11004 DWORD flags
= 0, size
;
11005 HANDLE thread
, event
;
11010 event
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
11011 wsabuf
.buf
= buffer
;
11012 wsabuf
.len
= sizeof(buffer
);
11014 tcp_socketpair(&client
, &server
);
11015 set_blocking(client
, FALSE
);
11016 set_blocking(server
, FALSE
);
11018 WSASetLastError(0xdeadbeef);
11019 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
11020 ok(ret
== -1, "got %d\n", ret
);
11021 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
11023 WSASetLastError(0xdeadbeef);
11024 overlapped
.Internal
= 0xdeadbeef;
11025 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, NULL
, NULL
);
11026 ok(ret
== -1, "got %d\n", ret
);
11027 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
11028 ok(overlapped
.Internal
== 0xdeadbeef, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
11030 /* Overlapped, with a NULL event. */
11032 overlapped
.hEvent
= NULL
;
11034 memset(buffer
, 0, sizeof(buffer
));
11035 WSASetLastError(0xdeadbeef);
11036 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
11037 ok(ret
== -1, "got %d\n", ret
);
11038 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
11039 ret
= WaitForSingleObject((HANDLE
)client
, 0);
11040 ok(ret
== WAIT_TIMEOUT
, "expected timeout\n");
11042 ret
= send(server
, "data", 4, 0);
11043 ok(ret
== 4, "got %d\n", ret
);
11045 ret
= WaitForSingleObject((HANDLE
)client
, 1000);
11046 ok(!ret
, "wait timed out\n");
11047 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
11048 ok(ret
, "got error %u\n", GetLastError());
11049 ok(size
== 4, "got size %u\n", size
);
11050 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
11052 /* Overlapped, with a non-NULL event. */
11054 overlapped
.hEvent
= event
;
11056 memset(buffer
, 0, sizeof(buffer
));
11057 WSASetLastError(0xdeadbeef);
11058 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
11059 ok(ret
== -1, "got %d\n", ret
);
11060 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
11061 ret
= WaitForSingleObject(event
, 0);
11062 ok(ret
== WAIT_TIMEOUT
, "expected timeout\n");
11064 ret
= send(server
, "data", 4, 0);
11065 ok(ret
== 4, "got %d\n", ret
);
11067 ret
= WaitForSingleObject(event
, 1000);
11068 ok(!ret
, "wait timed out\n");
11069 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
11070 ok(ret
, "got error %u\n", GetLastError());
11071 ok(size
== 4, "got size %u\n", size
);
11072 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
11074 /* With data already in the pipe; usually this does return 0 (but not
11077 ret
= send(server
, "data", 4, 0);
11078 ok(ret
== 4, "got %d\n", ret
);
11080 memset(buffer
, 0, sizeof(buffer
));
11081 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
11082 ok(!ret
|| WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
11083 ret
= WaitForSingleObject(event
, 1000);
11084 ok(!ret
, "wait timed out\n");
11085 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
11086 ok(ret
, "got error %u\n", GetLastError());
11087 ok(size
== 4, "got size %u\n", size
);
11088 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
11090 closesocket(client
);
11091 closesocket(server
);
11093 /* With a non-overlapped socket, WSARecv() always blocks when passed an
11094 * overlapped structure, but returns WSAEWOULDBLOCK otherwise. */
11096 tcp_socketpair_flags(&client
, &server
, 0);
11097 set_blocking(client
, FALSE
);
11098 set_blocking(server
, FALSE
);
11100 WSASetLastError(0xdeadbeef);
11101 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
11102 ok(ret
== -1, "got %d\n", ret
);
11103 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
11105 WSASetLastError(0xdeadbeef);
11106 overlapped
.Internal
= 0xdeadbeef;
11107 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, NULL
, NULL
);
11108 ok(ret
== -1, "got %d\n", ret
);
11109 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
11110 ok(overlapped
.Internal
== 0xdeadbeef, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
11112 /* Overlapped, with a NULL event. */
11114 params
.client
= client
;
11115 params
.event
= NULL
;
11116 thread
= CreateThread(NULL
, 0, nonblocking_async_recv_thread
, ¶ms
, 0, NULL
);
11118 ret
= WaitForSingleObject(thread
, 200);
11119 ok(ret
== WAIT_TIMEOUT
, "expected timeout\n");
11121 ret
= send(server
, "data", 4, 0);
11122 ok(ret
== 4, "got %d\n", ret
);
11124 ret
= WaitForSingleObject(thread
, 200);
11125 ok(!ret
, "wait timed out\n");
11126 CloseHandle(thread
);
11128 /* Overlapped, with a non-NULL event. */
11130 params
.client
= client
;
11131 params
.event
= event
;
11132 thread
= CreateThread(NULL
, 0, nonblocking_async_recv_thread
, ¶ms
, 0, NULL
);
11134 ret
= WaitForSingleObject(thread
, 200);
11135 ok(ret
== WAIT_TIMEOUT
, "expected timeout\n");
11137 ret
= send(server
, "data", 4, 0);
11138 ok(ret
== 4, "got %d\n", ret
);
11140 ret
= WaitForSingleObject(thread
, 200);
11141 ok(!ret
, "wait timed out\n");
11142 CloseHandle(thread
);
11144 /* With data already in the pipe. */
11146 ret
= send(server
, "data", 4, 0);
11147 ok(ret
== 4, "got %d\n", ret
);
11149 memset(buffer
, 0, sizeof(buffer
));
11150 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
11151 ok(!ret
, "got %d\n", ret
);
11152 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
11153 ok(ret
, "got error %u\n", GetLastError());
11154 ok(size
== 4, "got size %u\n", size
);
11155 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
11157 closesocket(client
);
11158 closesocket(server
);
11160 CloseHandle(overlapped
.hEvent
);
11163 static void test_empty_recv(void)
11165 OVERLAPPED overlapped
= {0};
11166 SOCKET client
, server
;
11167 DWORD size
, flags
= 0;
11172 overlapped
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
11173 tcp_socketpair(&client
, &server
);
11175 WSASetLastError(0xdeadbeef);
11176 ret
= WSARecv(client
, NULL
, 0, NULL
, &flags
, &overlapped
, NULL
);
11177 ok(ret
== -1, "expected failure\n");
11178 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
11180 wsabuf
.buf
= buffer
;
11182 WSASetLastError(0xdeadbeef);
11183 ret
= WSARecv(client
, &wsabuf
, 0, NULL
, &flags
, &overlapped
, NULL
);
11184 ok(ret
== -1, "expected failure\n");
11185 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
11187 WSASetLastError(0xdeadbeef);
11188 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
11189 ok(ret
== -1, "expected failure\n");
11190 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
11192 ret
= send(server
, "data", 5, 0);
11193 ok(ret
== 5, "got %d\n", ret
);
11195 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
11196 ok(!ret
, "wait failed\n");
11197 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
11198 ok(ret
, "got error %u\n", GetLastError());
11199 ok(!size
, "got size %u\n", size
);
11201 WSASetLastError(0xdeadbeef);
11202 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
11203 ok(!ret
, "got error %u\n", WSAGetLastError());
11204 ok(!size
, "got size %u\n", size
);
11206 ret
= recv(client
, NULL
, 0, 0);
11207 ok(!ret
, "got %d\n", ret
);
11209 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
11210 ok(ret
== 5, "got %d\n", ret
);
11211 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, ret
));
11213 closesocket(client
);
11214 closesocket(server
);
11215 CloseHandle(overlapped
.hEvent
);
11218 static void test_timeout(void)
11220 DWORD timeout
, flags
= 0, size
;
11221 OVERLAPPED overlapped
= {0};
11222 SOCKET client
, server
;
11227 tcp_socketpair(&client
, &server
);
11228 overlapped
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
11230 timeout
= 0xdeadbeef;
11231 len
= sizeof(timeout
);
11232 WSASetLastError(0xdeadbeef);
11233 ret
= getsockopt(client
, SOL_SOCKET
, SO_RCVTIMEO
, (char *)&timeout
, &len
);
11234 ok(!ret
, "expected success\n");
11235 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
11236 ok(len
== sizeof(timeout
), "got size %u\n", len
);
11237 ok(!timeout
, "got timeout %u\n", timeout
);
11240 WSASetLastError(0xdeadbeef);
11241 ret
= setsockopt(client
, SOL_SOCKET
, SO_RCVTIMEO
, (char *)&timeout
, sizeof(timeout
));
11242 ok(!ret
, "expected success\n");
11243 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
11245 timeout
= 0xdeadbeef;
11246 len
= sizeof(timeout
);
11247 WSASetLastError(0xdeadbeef);
11248 ret
= getsockopt(client
, SOL_SOCKET
, SO_RCVTIMEO
, (char *)&timeout
, &len
);
11249 ok(!ret
, "expected success\n");
11250 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
11251 ok(timeout
== 100, "got timeout %u\n", timeout
);
11253 WSASetLastError(0xdeadbeef);
11254 ret
= recv(client
, &buffer
, 1, 0);
11255 ok(ret
== -1, "got %d\n", ret
);
11256 ok(WSAGetLastError() == WSAETIMEDOUT
, "got error %u\n", WSAGetLastError());
11258 wsabuf
.buf
= &buffer
;
11260 WSASetLastError(0xdeadbeef);
11262 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, NULL
, NULL
);
11263 ok(ret
== -1, "got %d\n", ret
);
11264 ok(WSAGetLastError() == WSAETIMEDOUT
, "got error %u\n", WSAGetLastError());
11265 ok(size
== 0xdeadbeef, "got size %u\n", size
);
11267 wsabuf
.buf
= &buffer
;
11269 WSASetLastError(0xdeadbeef);
11271 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
11272 ok(ret
== -1, "got %d\n", ret
);
11273 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
11275 ret
= WaitForSingleObject(overlapped
.hEvent
, 200);
11276 ok(ret
== WAIT_TIMEOUT
, "got %d\n", ret
);
11278 ret
= send(server
, "a", 1, 0);
11279 ok(ret
== 1, "got %d\n", ret
);
11281 ret
= WaitForSingleObject(overlapped
.hEvent
, 200);
11282 ok(!ret
, "got %d\n", ret
);
11283 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
11284 ok(ret
, "got error %u\n", GetLastError());
11285 ok(size
== 1, "got size %u\n", size
);
11287 closesocket(client
);
11288 closesocket(server
);
11289 CloseHandle(overlapped
.hEvent
);
11292 static void test_so_debug(void)
11298 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11300 len
= sizeof(debug
);
11301 WSASetLastError(0xdeadbeef);
11302 debug
= 0xdeadbeef;
11303 ret
= getsockopt(s
, SOL_SOCKET
, SO_DEBUG
, (char *)&debug
, &len
);
11304 ok(!ret
, "got %d\n", ret
);
11305 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
11306 ok(len
== sizeof(debug
), "got len %u\n", len
);
11307 ok(!debug
, "got debug %u\n", debug
);
11309 WSASetLastError(0xdeadbeef);
11311 ret
= setsockopt(s
, SOL_SOCKET
, SO_DEBUG
, (char *)&debug
, sizeof(debug
));
11312 ok(!ret
, "got %d\n", ret
);
11313 todo_wine
ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
11315 len
= sizeof(debug
);
11316 WSASetLastError(0xdeadbeef);
11317 debug
= 0xdeadbeef;
11318 ret
= getsockopt(s
, SOL_SOCKET
, SO_DEBUG
, (char *)&debug
, &len
);
11319 ok(!ret
, "got %d\n", ret
);
11320 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
11321 ok(len
== sizeof(debug
), "got len %u\n", len
);
11322 todo_wine
ok(debug
== 1, "got debug %u\n", debug
);
11327 static void test_set_only_options(void)
11334 static const struct
11341 {IPPROTO_IP
, IP_ADD_MEMBERSHIP
},
11342 {IPPROTO_IP
, IP_DROP_MEMBERSHIP
},
11343 {IPPROTO_IPV6
, IPV6_ADD_MEMBERSHIP
},
11344 {IPPROTO_IPV6
, IPV6_DROP_MEMBERSHIP
},
11347 for (i
= 0; i
< ARRAY_SIZE(tests
); ++i
)
11349 if (tests
[i
].level
== IPPROTO_IPV6
)
11351 s
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
11352 if (s
== INVALID_SOCKET
) continue;
11356 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11359 len
= sizeof(value
);
11360 ret
= getsockopt(s
, tests
[i
].level
, tests
[i
].option
, (char *)&value
, &len
);
11361 ok(ret
== -1, "expected failure\n");
11362 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
11372 /* Leave these tests at the beginning. They depend on WSAStartup not having been
11373 * called, which is done by Init() below. */
11374 test_WithoutWSAStartup();
11375 test_WithWSAStartup();
11379 test_set_getsockopt();
11380 test_so_reuseaddr();
11382 test_extendedSocketOptions();
11384 test_set_only_options();
11386 for (i
= 0; i
< ARRAY_SIZE(tests
); i
++)
11387 do_test(&tests
[i
]);
11392 test_WSADuplicateSocket();
11393 test_WSAEnumNetworkEvents();
11399 test_getpeername();
11400 test_getsockname();
11402 test_address_list_query();
11404 test_fionread_siocatmark();
11405 test_get_extension_func();
11406 test_get_interface_list();
11407 test_keepalive_vals();
11408 test_sioRoutingInterfaceQuery();
11409 test_sioAddressListChange();
11410 test_base_handle();
11411 test_unsupported_ioctls();
11417 test_write_watch();
11423 test_TransmitFile();
11427 test_DisconnectEx();
11429 test_completion_port();
11430 test_connect_completion_port();
11431 test_shutdown_completion_port();
11433 test_connecting_socket();
11434 test_WSAGetOverlappedResult();
11435 test_nonblocking_async_recv();
11439 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */