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
;
158 static GUID WSARecvMsg_GUID
= WSAID_WSARECVMSG
;
160 /**************** General utility functions ***************/
162 static SOCKET
setup_server_socket(struct sockaddr_in
*addr
, int *len
);
163 static SOCKET
setup_connector_socket(const struct sockaddr_in
*addr
, int len
, BOOL nonblock
);
164 static int sync_recv(SOCKET s
, void *buffer
, int len
, DWORD flags
);
166 static void tcp_socketpair_flags(SOCKET
*src
, SOCKET
*dst
, DWORD flags
)
168 SOCKET server
= INVALID_SOCKET
;
169 struct sockaddr_in addr
;
172 *src
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, flags
);
173 ok(*src
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
175 server
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, flags
);
176 ok(server
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
178 memset(&addr
, 0, sizeof(addr
));
179 addr
.sin_family
= AF_INET
;
180 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
181 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
182 ok(!ret
, "failed to bind socket, error %u\n", WSAGetLastError());
185 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
186 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
188 ret
= listen(server
, 1);
189 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
191 ret
= connect(*src
, (struct sockaddr
*)&addr
, sizeof(addr
));
192 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
195 *dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
196 ok(*dst
!= INVALID_SOCKET
, "failed to accept socket, error %u\n", WSAGetLastError());
201 static void tcp_socketpair(SOCKET
*src
, SOCKET
*dst
)
203 tcp_socketpair_flags(src
, dst
, WSA_FLAG_OVERLAPPED
);
206 static void WINAPI
apc_func(ULONG_PTR apc_count
)
208 ++*(unsigned int *)apc_count
;
211 /* Set the linger timeout to zero and close the socket. This will trigger an
212 * RST on the connection on Windows as well as on Unix systems. */
213 static void close_with_rst(SOCKET s
)
215 static const struct linger linger
= {.l_onoff
= 1};
218 SetLastError(0xdeadbeef);
219 ret
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, (const char *)&linger
, sizeof(linger
));
220 ok(!ret
, "got %d\n", ret
);
221 ok(!GetLastError(), "got error %lu\n", GetLastError());
226 #define check_poll(a, b) check_poll_(__LINE__, a, POLLRDNORM | POLLRDBAND | POLLWRNORM, b, FALSE)
227 #define check_poll_todo(a, b) check_poll_(__LINE__, a, POLLRDNORM | POLLRDBAND | POLLWRNORM, b, TRUE)
228 #define check_poll_mask(a, b, c) check_poll_(__LINE__, a, b, c, FALSE)
229 #define check_poll_mask_todo(a, b, c) check_poll_(__LINE__, a, b, c, TRUE)
230 static void check_poll_(int line
, SOCKET s
, short mask
, short expect
, BOOL todo
)
236 pollfd
.events
= mask
;
237 pollfd
.revents
= 0xdead;
238 ret
= pWSAPoll(&pollfd
, 1, 1000);
239 ok_(__FILE__
, line
)(ret
== (pollfd
.revents
? 1 : 0), "WSAPoll() returned %d\n", ret
);
240 todo_wine_if (todo
) ok_(__FILE__
, line
)(pollfd
.revents
== expect
, "got wrong events %#x\n", pollfd
.revents
);
243 static DWORD WINAPI
poll_async_thread(void *arg
)
245 WSAPOLLFD
*pollfd
= arg
;
248 ret
= pWSAPoll(pollfd
, 1, 500);
249 ok(ret
== (pollfd
->revents
? 1 : 0), "WSAPoll() returned %d\n", ret
);
254 static void set_so_opentype ( BOOL overlapped
)
256 int optval
= !overlapped
, newval
, len
= sizeof (int);
258 ok ( setsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
259 (LPVOID
) &optval
, sizeof (optval
) ) == 0,
260 "setting SO_OPENTYPE failed\n" );
261 ok ( getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
262 (LPVOID
) &newval
, &len
) == 0,
263 "getting SO_OPENTYPE failed\n" );
264 ok ( optval
== newval
, "failed to set SO_OPENTYPE\n" );
267 static int set_blocking ( SOCKET s
, BOOL blocking
)
269 u_long val
= !blocking
;
270 return ioctlsocket ( s
, FIONBIO
, &val
);
273 static void fill_buffer ( char *buf
, int chunk_size
, int n_chunks
)
276 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
277 memset ( p
, c
, chunk_size
);
280 static int test_buffer ( char *buf
, int chunk_size
, int n_chunks
)
284 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
286 for ( i
= 0; i
< chunk_size
; i
++ )
287 if ( p
[i
] != c
) return i
;
293 * This routine is called when a client / server does not expect any more data,
294 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
296 static void read_zero_bytes ( SOCKET s
)
300 while ( ( tmp
= recv ( s
, buf
, 256, 0 ) ) > 0 )
302 ok ( n
<= 0, "garbage data received: %d bytes\n", n
);
305 static int do_synchronous_send ( SOCKET s
, char *buf
, int buflen
, int flags
, int sendlen
)
307 char* last
= buf
+ buflen
, *p
;
309 for ( p
= buf
; n
> 0 && p
< last
; )
311 n
= send ( s
, p
, min ( sendlen
, last
- p
), flags
);
314 wsa_ok ( n
, 0 <=, "do_synchronous_send (%lx): error %d\n" );
318 static int do_synchronous_recv ( SOCKET s
, char *buf
, int buflen
, int flags
, int recvlen
)
320 char* last
= buf
+ buflen
, *p
;
322 for ( p
= buf
; n
> 0 && p
< last
; )
324 n
= recv ( s
, p
, min ( recvlen
, last
- p
), flags
);
327 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%lx): error %d:\n" );
331 static int do_synchronous_recvfrom ( SOCKET s
, char *buf
, int buflen
, int flags
, struct sockaddr
*from
, int *fromlen
, int recvlen
)
333 char* last
= buf
+ buflen
, *p
;
335 for ( p
= buf
; n
> 0 && p
< last
; )
337 n
= recvfrom ( s
, p
, min ( recvlen
, last
- p
), flags
, from
, fromlen
);
340 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%lx): error %d:\n" );
345 * Call this routine right after thread startup.
346 * SO_OPENTYPE must by 0, regardless what the server did.
348 static void check_so_opentype (void)
352 getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
, (LPVOID
) &tmp
, &len
);
353 ok ( tmp
== 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp
);
356 /**************** Server utility functions ***************/
359 * Even if we have closed our server socket cleanly,
360 * the OS may mark the address "in use" for some time -
361 * this happens with native Linux apps, too.
363 static void do_bind ( SOCKET s
, struct sockaddr
* addr
, int addrlen
)
365 int err
, wsaerr
= 0, n_try
= BIND_TRIES
;
367 while ( ( err
= bind ( s
, addr
, addrlen
) ) != 0 &&
368 ( wsaerr
= WSAGetLastError () ) == WSAEADDRINUSE
&&
371 trace ( "address in use, waiting ...\n" );
372 Sleep ( 1000 * BIND_SLEEP
);
374 ok ( err
== 0, "failed to bind: %d\n", wsaerr
);
377 static void server_start ( server_params
*par
)
380 test_params
*gen
= par
->general
;
381 server_memory
*mem
= LocalAlloc ( LPTR
, sizeof ( server_memory
) );
383 TlsSetValue ( tls
, mem
);
384 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
385 NULL
, 0, par
->sock_flags
);
386 ok ( mem
->s
!= INVALID_SOCKET
, "Server: WSASocket failed\n" );
388 mem
->addr
.sin_family
= AF_INET
;
389 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
390 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
392 for (i
= 0; i
< MAX_CLIENTS
; i
++)
394 mem
->sock
[i
].s
= INVALID_SOCKET
;
395 mem
->sock
[i
].buf
= LocalAlloc ( LPTR
, gen
->n_chunks
* gen
->chunk_size
);
396 mem
->sock
[i
].n_recvd
= 0;
397 mem
->sock
[i
].n_sent
= 0;
400 if ( gen
->sock_type
== SOCK_STREAM
)
401 do_bind ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof (mem
->addr
) );
404 static void server_stop (void)
407 server_memory
*mem
= TlsGetValue ( tls
);
409 for (i
= 0; i
< MAX_CLIENTS
; i
++ )
411 LocalFree ( mem
->sock
[i
].buf
);
412 if ( mem
->sock
[i
].s
!= INVALID_SOCKET
)
413 closesocket ( mem
->sock
[i
].s
);
415 ok ( closesocket ( mem
->s
) == 0, "closesocket failed\n" );
417 ExitThread ( GetCurrentThreadId () );
420 /**************** Client utilitiy functions ***************/
422 static void client_start ( client_params
*par
)
424 test_params
*gen
= par
->general
;
425 client_memory
*mem
= LocalAlloc (LPTR
, sizeof (client_memory
));
427 TlsSetValue ( tls
, mem
);
429 WaitForSingleObject ( server_ready
, INFINITE
);
431 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
432 NULL
, 0, par
->sock_flags
);
434 mem
->addr
.sin_family
= AF_INET
;
435 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
436 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
438 ok ( mem
->s
!= INVALID_SOCKET
, "Client: WSASocket failed\n" );
440 mem
->send_buf
= LocalAlloc ( LPTR
, 2 * gen
->n_chunks
* gen
->chunk_size
);
441 mem
->recv_buf
= mem
->send_buf
+ gen
->n_chunks
* gen
->chunk_size
;
442 fill_buffer ( mem
->send_buf
, gen
->chunk_size
, gen
->n_chunks
);
444 SetEvent ( client_ready
[client_id
] );
445 /* Wait for the other clients to come up */
446 WaitForMultipleObjects ( min ( gen
->n_clients
, MAX_CLIENTS
), client_ready
, TRUE
, INFINITE
);
449 static void client_stop (void)
451 client_memory
*mem
= TlsGetValue ( tls
);
452 wsa_ok ( closesocket ( mem
->s
), 0 ==, "closesocket error (%lx): %d\n" );
453 LocalFree ( mem
->send_buf
);
458 /**************** Servers ***************/
461 * simple_server: A very basic server doing synchronous IO.
463 static VOID WINAPI
simple_server ( server_params
*par
)
465 test_params
*gen
= par
->general
;
467 int pos
, n_recvd
, n_sent
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
468 id
= GetCurrentThreadId();
470 set_so_opentype ( FALSE
); /* non-overlapped */
471 server_start ( par
);
472 mem
= TlsGetValue ( tls
);
474 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "simple_server (%lx): failed to set blocking mode: %d\n");
475 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "simple_server (%lx): listen failed: %d\n");
477 SetEvent ( server_ready
); /* notify clients */
479 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
481 /* accept a single connection */
482 tmp
= sizeof ( mem
->sock
[0].peer
);
483 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
484 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "simple_server (%lx): accept failed: %d\n" );
486 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
487 "simple_server (%x): strange peer address\n", id
);
489 /* Receive data & check it */
490 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
491 ok ( n_recvd
== n_expected
,
492 "simple_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
493 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
494 ok ( pos
== -1, "simple_server (%x): test pattern error: %d\n", id
, pos
);
497 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
498 ok ( n_sent
== n_expected
,
499 "simple_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
502 read_zero_bytes ( mem
->sock
[0].s
);
503 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "simple_server (%lx): closesocket error: %d\n" );
504 mem
->sock
[0].s
= INVALID_SOCKET
;
511 * oob_server: A very basic server receiving out-of-band data.
513 static VOID WINAPI
oob_server ( server_params
*par
)
515 test_params
*gen
= par
->general
;
518 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
,
519 id
= GetCurrentThreadId();
521 set_so_opentype ( FALSE
); /* non-overlapped */
522 server_start ( par
);
523 mem
= TlsGetValue ( tls
);
525 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "oob_server (%lx): failed to set blocking mode: %d\n");
526 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "oob_server (%lx): listen failed: %d\n");
528 SetEvent ( server_ready
); /* notify clients */
530 /* accept a single connection */
531 tmp
= sizeof ( mem
->sock
[0].peer
);
532 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
533 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "oob_server (%lx): accept failed: %d\n" );
535 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
536 "oob_server (%x): strange peer address\n", id
);
538 /* check initial atmark state */
539 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
540 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %li\n", id
, atmark
);
542 /* Receive normal data */
543 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
544 ok ( n_recvd
== n_expected
,
545 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
546 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
547 ok ( pos
== -1, "oob_server (%x): test pattern error: %d\n", id
, pos
);
549 /* check atmark state */
550 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
551 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %li\n", id
, atmark
);
554 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
555 ok ( n_sent
== n_expected
,
556 "oob_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
558 /* Receive a part of the out-of-band data and print atmark state */
559 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, 8, 0, par
->buflen
);
561 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, 8 );
564 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
566 /* Receive the rest of the out-of-band data and check atmark state */
567 do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
569 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
570 todo_wine
ok ( atmark
== 0, "oob_server (%x): not at the OOB mark: %li\n", id
, atmark
);
573 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "oob_server (%lx): closesocket error: %d\n" );
574 mem
->sock
[0].s
= INVALID_SOCKET
;
580 * select_server: A non-blocking server.
582 static VOID WINAPI
select_server ( server_params
*par
)
584 test_params
*gen
= par
->general
;
586 int n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
587 id
= GetCurrentThreadId(), n_connections
= 0, n_sent
, n_recvd
,
588 n_set
, delta
, n_ready
;
589 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
590 fd_set fds_recv
, fds_send
, fds_openrecv
, fds_opensend
;
592 set_so_opentype ( FALSE
); /* non-overlapped */
593 server_start ( par
);
594 mem
= TlsGetValue ( tls
);
596 wsa_ok ( set_blocking ( mem
->s
, FALSE
), 0 ==, "select_server (%lx): failed to set blocking mode: %d\n");
597 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "select_server (%lx): listen failed: %d\n");
599 SetEvent ( server_ready
); /* notify clients */
601 FD_ZERO ( &fds_openrecv
);
602 FD_ZERO ( &fds_recv
);
603 FD_ZERO ( &fds_send
);
604 FD_ZERO ( &fds_opensend
);
606 FD_SET ( mem
->s
, &fds_openrecv
);
610 fds_recv
= fds_openrecv
;
611 fds_send
= fds_opensend
;
615 wsa_ok ( ( n_ready
= select ( 0, &fds_recv
, &fds_send
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
616 "select_server (%lx): select() failed: %d\n" );
618 /* check for incoming requests */
619 if ( FD_ISSET ( mem
->s
, &fds_recv
) ) {
622 /* accept a single connection */
623 tmp
= sizeof ( mem
->sock
[n_connections
].peer
);
624 mem
->sock
[n_connections
].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[n_connections
].peer
, &tmp
);
625 wsa_ok ( mem
->sock
[n_connections
].s
, INVALID_SOCKET
!=, "select_server (%lx): accept() failed: %d\n" );
627 ok ( mem
->sock
[n_connections
].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
628 "select_server (%x): strange peer address\n", id
);
630 /* add to list of open connections */
631 FD_SET ( mem
->sock
[n_connections
].s
, &fds_openrecv
);
632 FD_SET ( mem
->sock
[n_connections
].s
, &fds_opensend
);
637 /* handle open requests */
639 for ( i
= 0; i
< n_connections
; i
++ )
641 if ( FD_ISSET( mem
->sock
[i
].s
, &fds_recv
) ) {
644 if ( mem
->sock
[i
].n_recvd
< n_expected
) {
645 /* Receive data & check it */
646 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 );
647 ok ( n_recvd
!= SOCKET_ERROR
, "select_server (%x): error in recv(): %d\n", id
, WSAGetLastError() );
648 mem
->sock
[i
].n_recvd
+= n_recvd
;
650 if ( mem
->sock
[i
].n_recvd
== n_expected
) {
651 int pos
= test_buffer ( mem
->sock
[i
].buf
, gen
->chunk_size
, gen
->n_chunks
);
652 ok ( pos
== -1, "select_server (%x): test pattern error: %d\n", id
, pos
);
653 FD_CLR ( mem
->sock
[i
].s
, &fds_openrecv
);
656 ok ( mem
->sock
[i
].n_recvd
<= n_expected
, "select_server (%x): received too many bytes: %d\n", id
, mem
->sock
[i
].n_recvd
);
660 /* only echo back what we've received */
661 delta
= mem
->sock
[i
].n_recvd
- mem
->sock
[i
].n_sent
;
663 if ( FD_ISSET ( mem
->sock
[i
].s
, &fds_send
) ) {
666 if ( ( delta
> 0 ) && ( mem
->sock
[i
].n_sent
< n_expected
) ) {
668 n_sent
= send ( mem
->sock
[i
].s
, mem
->sock
[i
].buf
+ mem
->sock
[i
].n_sent
, min ( delta
, par
->buflen
), 0 );
669 ok ( n_sent
!= SOCKET_ERROR
, "select_server (%x): error in send(): %d\n", id
, WSAGetLastError() );
670 mem
->sock
[i
].n_sent
+= n_sent
;
672 if ( mem
->sock
[i
].n_sent
== n_expected
) {
673 FD_CLR ( mem
->sock
[i
].s
, &fds_opensend
);
676 ok ( mem
->sock
[i
].n_sent
<= n_expected
, "select_server (%x): sent too many bytes: %d\n", id
, mem
->sock
[i
].n_sent
);
681 /* check that select returned the correct number of ready sockets */
682 ok ( ( n_set
== n_ready
), "select_server (%x): select() returns wrong number of ready sockets\n", id
);
684 /* check if all clients are done */
685 if ( ( fds_opensend
.fd_count
== 0 )
686 && ( fds_openrecv
.fd_count
== 1 ) /* initial socket that accepts clients */
687 && ( n_connections
== min ( gen
->n_clients
, MAX_CLIENTS
) ) ) {
692 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
695 read_zero_bytes ( mem
->sock
[i
].s
);
696 wsa_ok ( closesocket ( mem
->sock
[i
].s
), 0 ==, "select_server (%lx): closesocket error: %d\n" );
697 mem
->sock
[i
].s
= INVALID_SOCKET
;
703 /**************** Clients ***************/
706 * simple_client: A very basic client doing synchronous IO.
708 static VOID WINAPI
simple_client ( client_params
*par
)
710 test_params
*gen
= par
->general
;
712 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
714 id
= GetCurrentThreadId();
715 /* wait here because we want to call set_so_opentype before creating a socket */
716 WaitForSingleObject ( server_ready
, INFINITE
);
718 check_so_opentype ();
719 set_so_opentype ( FALSE
); /* non-overlapped */
720 client_start ( par
);
721 mem
= TlsGetValue ( tls
);
724 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
725 0 ==, "simple_client (%lx): connect error: %d\n" );
726 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
727 "simple_client (%x): failed to set blocking mode\n", id
);
729 /* send data to server */
730 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
731 ok ( n_sent
== n_expected
,
732 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
734 /* shutdown send direction */
735 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%lx): shutdown failed: %d\n" );
737 /* Receive data echoed back & check it */
738 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, 0, par
->buflen
);
739 ok ( n_recvd
== n_expected
,
740 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
743 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
744 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
747 read_zero_bytes ( mem
->s
);
752 * oob_client: A very basic client sending out-of-band data.
754 static VOID WINAPI
oob_client ( client_params
*par
)
756 test_params
*gen
= par
->general
;
758 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
760 id
= GetCurrentThreadId();
761 /* wait here because we want to call set_so_opentype before creating a socket */
762 WaitForSingleObject ( server_ready
, INFINITE
);
764 check_so_opentype ();
765 set_so_opentype ( FALSE
); /* non-overlapped */
766 client_start ( par
);
767 mem
= TlsGetValue ( tls
);
770 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
771 0 ==, "oob_client (%lx): connect error: %d\n" );
772 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
773 "oob_client (%x): failed to set blocking mode\n", id
);
775 /* send data to server */
776 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
777 ok ( n_sent
== n_expected
,
778 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
780 /* Receive data echoed back & check it */
781 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, 0, par
->buflen
);
782 ok ( n_recvd
== n_expected
,
783 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
784 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
785 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
787 /* send out-of-band data to server */
788 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, MSG_OOB
, par
->buflen
);
789 ok ( n_sent
== n_expected
,
790 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
792 /* shutdown send direction */
793 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%lx): shutdown failed: %d\n" );
796 read_zero_bytes ( mem
->s
);
801 * simple_mixed_client: mixing send and recvfrom
803 static VOID WINAPI
simple_mixed_client ( client_params
*par
)
805 test_params
*gen
= par
->general
;
807 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
808 int fromLen
= sizeof(mem
->addr
);
809 struct sockaddr test
;
811 id
= GetCurrentThreadId();
812 /* wait here because we want to call set_so_opentype before creating a socket */
813 WaitForSingleObject ( server_ready
, INFINITE
);
815 check_so_opentype ();
816 set_so_opentype ( FALSE
); /* non-overlapped */
817 client_start ( par
);
818 mem
= TlsGetValue ( tls
);
821 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
822 0 ==, "simple_client (%lx): connect error: %d\n" );
823 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
824 "simple_client (%x): failed to set blocking mode\n", id
);
826 /* send data to server */
827 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
828 ok ( n_sent
== n_expected
,
829 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
831 /* shutdown send direction */
832 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%lx): shutdown failed: %d\n" );
834 /* this shouldn't change, since lpFrom, is not updated on
835 connection oriented sockets - exposed by bug 11640
837 ((struct sockaddr_in
*)&test
)->sin_addr
.s_addr
= inet_addr("0.0.0.0");
839 /* Receive data echoed back & check it */
840 n_recvd
= do_synchronous_recvfrom ( mem
->s
, mem
->recv_buf
, n_expected
, 0, &test
, &fromLen
,
842 ok ( n_recvd
== n_expected
,
843 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
845 /* check that lpFrom was not updated */
848 inet_ntoa(((struct sockaddr_in
*)&test
)->sin_addr
),
849 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
852 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
853 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
856 read_zero_bytes ( mem
->s
);
861 * event_client: An event-driven client
863 static void WINAPI
event_client ( client_params
*par
)
865 test_params
*gen
= par
->general
;
867 int id
= GetCurrentThreadId(), n_expected
= gen
->n_chunks
* gen
->chunk_size
,
870 WSANETWORKEVENTS wsa_events
;
871 char *send_last
, *recv_last
, *send_p
, *recv_p
;
872 LONG mask
= FD_READ
| FD_WRITE
| FD_CLOSE
;
874 client_start ( par
);
876 mem
= TlsGetValue ( tls
);
878 /* Prepare event notification for connect, makes socket nonblocking */
879 event
= WSACreateEvent ();
880 WSAEventSelect ( mem
->s
, event
, FD_CONNECT
);
881 tmp
= connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) );
883 err
= WSAGetLastError ();
884 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): connect error: %d\n", id
, err
);
885 tmp
= WaitForSingleObject ( event
, INFINITE
);
886 ok ( tmp
== WAIT_OBJECT_0
, "event_client (%x): wait for connect event failed: %d\n", id
, tmp
);
887 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
888 ok ( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
889 err
= wsa_events
.iErrorCode
[ FD_CONNECT_BIT
];
890 ok ( err
== 0, "event_client (%x): connect error: %d\n", id
, err
);
894 WSAEventSelect ( mem
->s
, event
, mask
);
896 recv_p
= mem
->recv_buf
;
897 recv_last
= mem
->recv_buf
+ n_expected
;
898 send_p
= mem
->send_buf
;
899 send_last
= mem
->send_buf
+ n_expected
;
903 err
= WaitForSingleObject ( event
, INFINITE
);
904 ok ( err
== WAIT_OBJECT_0
, "event_client (%x): wait failed\n", id
);
906 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
907 ok( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
909 if ( wsa_events
.lNetworkEvents
& FD_WRITE
)
911 err
= wsa_events
.iErrorCode
[ FD_WRITE_BIT
];
912 ok ( err
== 0, "event_client (%x): FD_WRITE error code: %d\n", id
, err
);
917 n
= send ( mem
->s
, send_p
, min ( send_last
- send_p
, par
->buflen
), 0 );
920 err
= WSAGetLastError ();
921 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): send error: %d\n", id
, err
);
926 while ( n
>= 0 && send_p
< send_last
);
928 if ( send_p
== send_last
)
930 shutdown ( mem
->s
, SD_SEND
);
932 WSAEventSelect ( mem
->s
, event
, mask
);
935 if ( wsa_events
.lNetworkEvents
& FD_READ
)
937 err
= wsa_events
.iErrorCode
[ FD_READ_BIT
];
938 ok ( err
== 0, "event_client (%x): FD_READ error code: %d\n", id
, err
);
939 if ( err
!= 0 ) break;
941 /* First read must succeed */
942 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
943 wsa_ok ( n
, 0 <=, "event_client (%lx): recv error: %d\n" );
947 if ( recv_p
== recv_last
)
950 WSAEventSelect ( mem
->s
, event
, mask
);
953 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
954 ok(n
>= 0 || WSAGetLastError() == WSAEWOULDBLOCK
,
955 "event_client (%x): got error %u\n", id
, WSAGetLastError());
959 if ( wsa_events
.lNetworkEvents
& FD_CLOSE
)
961 err
= wsa_events
.iErrorCode
[ FD_CLOSE_BIT
];
962 ok ( err
== 0, "event_client (%x): FD_CLOSE error code: %d\n", id
, err
);
967 n
= send_p
- mem
->send_buf
;
968 ok ( send_p
== send_last
,
969 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n
, n_expected
);
970 n
= recv_p
- mem
->recv_buf
;
971 ok ( recv_p
== recv_last
,
972 "simple_client (%x): received less data than expected: %d of %d\n", id
, n
, n_expected
);
973 n
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
974 ok ( n
== -1, "event_client (%x): test pattern error: %d\n", id
, n
);
977 WSACloseEvent ( event
);
981 /* Tests for WSAStartup */
982 static void test_WithoutWSAStartup(void)
986 WSASetLastError(0xdeadbeef);
987 ok(WSASocketA(0, 0, 0, NULL
, 0, 0) == INVALID_SOCKET
, "WSASocketA should have failed\n");
988 err
= WSAGetLastError();
989 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %ld\n", err
);
991 WSASetLastError(0xdeadbeef);
992 ok(gethostbyname("localhost") == NULL
, "gethostbyname() succeeded unexpectedly\n");
993 err
= WSAGetLastError();
994 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %ld\n", err
);
997 static void test_WithWSAStartup(void)
1000 WORD version
= MAKEWORD( 2, 2 );
1001 INT res
, socks
, i
, j
;
1006 SOCKET src
, dst
, dup_src
, dup_dst
;
1010 res
= WSAStartup( version
, &data
);
1011 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
1013 ptr
= gethostbyname("localhost");
1014 ok(ptr
!= NULL
, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
1016 /* Alloc some sockets to check if they are destroyed on WSACleanup */
1017 for (socks
= 0; socks
< ARRAY_SIZE(pairs
); socks
++)
1019 WSAPROTOCOL_INFOA info
;
1020 tcp_socketpair(&pairs
[socks
].src
, &pairs
[socks
].dst
);
1022 memset(&info
, 0, sizeof(info
));
1023 ok(!WSADuplicateSocketA(pairs
[socks
].src
, GetCurrentProcessId(), &info
),
1024 "WSADuplicateSocketA should have worked\n");
1025 pairs
[socks
].dup_src
= WSASocketA(0, 0, 0, &info
, 0, 0);
1026 ok(pairs
[socks
].dup_src
!= SOCKET_ERROR
, "expected != -1\n");
1028 memset(&info
, 0, sizeof(info
));
1029 ok(!WSADuplicateSocketA(pairs
[socks
].dst
, GetCurrentProcessId(), &info
),
1030 "WSADuplicateSocketA should have worked\n");
1031 pairs
[socks
].dup_dst
= WSASocketA(0, 0, 0, &info
, 0, 0);
1032 ok(pairs
[socks
].dup_dst
!= SOCKET_ERROR
, "expected != -1\n");
1035 res
= send(pairs
[0].src
, "TEST", 4, 0);
1036 ok(res
== 4, "send failed with error %d\n", WSAGetLastError());
1040 res
= WSAStartup( version
, &data
);
1041 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
1043 /* show that sockets are destroyed automatically after WSACleanup */
1044 SetLastError(0xdeadbeef);
1045 res
= send(pairs
[0].src
, "TEST", 4, 0);
1046 error
= WSAGetLastError();
1047 ok(res
== SOCKET_ERROR
, "send should have failed\n");
1048 ok(error
== WSAENOTSOCK
, "expected 10038, got %ld\n", error
);
1050 SetLastError(0xdeadbeef);
1051 res
= send(pairs
[0].dst
, "TEST", 4, 0);
1052 error
= WSAGetLastError();
1053 ok(res
== SOCKET_ERROR
, "send should have failed\n");
1054 ok(error
== WSAENOTSOCK
, "expected 10038, got %ld\n", error
);
1056 /* Check that all sockets were destroyed */
1057 for (i
= 0; i
< socks
; i
++)
1059 for (j
= 0; j
< 4; j
++)
1061 struct sockaddr_in saddr
;
1062 int size
= sizeof(saddr
);
1065 case 0: sock
= pairs
[i
].src
; break;
1066 case 1: sock
= pairs
[i
].dup_src
; break;
1067 case 2: sock
= pairs
[i
].dst
; break;
1068 case 3: sock
= pairs
[i
].dup_dst
; break;
1071 SetLastError(0xdeadbeef);
1072 res
= getsockname(sock
, (struct sockaddr
*)&saddr
, &size
);
1073 error
= WSAGetLastError();
1074 ok(res
== SOCKET_ERROR
, "Test[%d]: getsockname should have failed\n", i
);
1075 if (res
== SOCKET_ERROR
)
1076 ok(error
== WSAENOTSOCK
, "Test[%d]: expected 10038, got %ld\n", i
, error
);
1080 /* While wine is not fixed, close all sockets manually */
1081 for (i
= 0; i
< socks
; i
++)
1083 closesocket(pairs
[i
].src
);
1084 closesocket(pairs
[i
].dst
);
1085 closesocket(pairs
[i
].dup_src
);
1086 closesocket(pairs
[i
].dup_dst
);
1090 ok(res
== 0, "expected 0, got %d\n", res
);
1091 WSASetLastError(0xdeadbeef);
1093 error
= WSAGetLastError();
1094 ok ( res
== SOCKET_ERROR
&& error
== WSANOTINITIALISED
,
1095 "WSACleanup returned %d WSAGetLastError is %ld\n", res
, error
);
1098 /**************** Main program utility functions ***************/
1100 static void Init (void)
1102 WORD ver
= MAKEWORD (2, 2);
1104 HMODULE hws2_32
= GetModuleHandleA("ws2_32.dll"), ntdll
;
1106 pWSAPoll
= (void *)GetProcAddress(hws2_32
, "WSAPoll");
1108 ntdll
= LoadLibraryA("ntdll.dll");
1110 pNtClose
= (void *)GetProcAddress(ntdll
, "NtClose");
1112 ok ( WSAStartup ( ver
, &data
) == 0, "WSAStartup failed\n" );
1116 static void Exit (void)
1121 err
= WSAGetLastError();
1122 ok ( ret
== 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret
, err
);
1125 static void StartServer (LPTHREAD_START_ROUTINE routine
,
1126 test_params
*general
, server_params
*par
)
1128 par
->general
= general
;
1129 thread
[0] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[0] );
1130 ok ( thread
[0] != NULL
, "Failed to create server thread\n" );
1133 static void StartClients (LPTHREAD_START_ROUTINE routine
,
1134 test_params
*general
, client_params
*par
)
1137 par
->general
= general
;
1138 for ( i
= 1; i
<= min ( general
->n_clients
, MAX_CLIENTS
); i
++ )
1141 thread
[i
] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[i
] );
1142 ok ( thread
[i
] != NULL
, "Failed to create client thread\n" );
1143 /* Make sure the client is up and running */
1144 WaitForSingleObject ( client_ready
[client_id
], INFINITE
);
1148 static void do_test( test_setup
*test
)
1150 DWORD i
, n
= min (test
->general
.n_clients
, MAX_CLIENTS
);
1153 server_ready
= CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1154 for (i
= 0; i
<= n
; i
++)
1155 client_ready
[i
] = CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1157 StartServer ( test
->srv
, &test
->general
, &test
->srv_params
);
1158 StartClients ( test
->clt
, &test
->general
, &test
->clt_params
);
1159 WaitForSingleObject ( server_ready
, INFINITE
);
1161 wait
= WaitForMultipleObjects ( 1 + n
, thread
, TRUE
, 1000 * TEST_TIMEOUT
);
1162 ok(!wait
, "wait failed, error %lu\n", wait
);
1164 CloseHandle ( server_ready
);
1165 for (i
= 0; i
<= n
; i
++)
1166 CloseHandle ( client_ready
[i
] );
1169 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1170 /* optname = SO_LINGER */
1171 static const LINGER linger_testvals
[] = {
1178 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1179 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1180 bug in the linux kernel (fixed in 2.6.8) */
1181 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1183 static void test_set_getsockopt(void)
1191 BOOL accepts_short_len
;
1192 unsigned int sizes
[3];
1194 BOOL accepts_large_value
;
1196 BOOL allow_noprotoopt
; /* for old windows only, must work on wine */
1200 {AF_INET
, SOCK_DGRAM
, SOL_SOCKET
, SO_BROADCAST
, TRUE
, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE
, TRUE
},
1201 {AF_INET
, SOCK_STREAM
, SOL_SOCKET
, SO_DONTLINGER
, TRUE
, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE
, TRUE
},
1202 {AF_INET
, SOCK_STREAM
, SOL_SOCKET
, SO_LINGER
, FALSE
, {1, 2, 4}, {0xdeadbe00, 0xdead0000}, TRUE
},
1203 {AF_INET
, SOCK_STREAM
, SOL_SOCKET
, SO_OOBINLINE
, TRUE
, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE
, TRUE
},
1204 {AF_INET
, SOCK_STREAM
, SOL_SOCKET
, SO_RCVBUF
, FALSE
, {1, 2, 4}, {0xdeadbe00, 0xdead0000}, TRUE
},
1205 {AF_INET
, SOCK_STREAM
, SOL_SOCKET
, SO_KEEPALIVE
, TRUE
, {1, 1, 1}, {0}, TRUE
},
1206 {AF_INET
, SOCK_STREAM
, SOL_SOCKET
, SO_DONTROUTE
, TRUE
, {1, 1, 1}, {0}, TRUE
},
1207 {AF_INET
, SOCK_STREAM
, SOL_SOCKET
, SO_RCVTIMEO
, FALSE
, {1, 2, 4}, {0}, TRUE
},
1208 {AF_INET
, SOCK_STREAM
, SOL_SOCKET
, SO_REUSEADDR
, TRUE
, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE
, TRUE
},
1209 {AF_INET
, SOCK_STREAM
, SOL_SOCKET
, SO_EXCLUSIVEADDRUSE
, TRUE
, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE
, TRUE
},
1210 {AF_INET
, SOCK_STREAM
, SOL_SOCKET
, SO_SNDBUF
, FALSE
, {1, 2, 4}, {0xdeadbe00, 0xdead0000}, TRUE
},
1211 {AF_INET
, SOCK_STREAM
, SOL_SOCKET
, SO_SNDTIMEO
, FALSE
, {1, 2, 4}, {0}, TRUE
},
1212 {AF_INET
, SOCK_STREAM
, SOL_SOCKET
, SO_OPENTYPE
, FALSE
, {1, 2, 4}, {0}, TRUE
},
1213 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, TCP_NODELAY
, TRUE
, {1, 1, 1}, {0}, TRUE
},
1214 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, TCP_KEEPALIVE
, FALSE
, {0, 0, 4}, {0}, TRUE
},
1215 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, TCP_KEEPCNT
, FALSE
, {0, 0, 4}, {0}, FALSE
, FALSE
, TRUE
}, /* win10+ */
1216 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, TCP_KEEPINTVL
, FALSE
, {0, 0, 4}, {0}, TRUE
, FALSE
, TRUE
}, /* win10+ */
1217 {AF_INET
, SOCK_DGRAM
, IPPROTO_IP
, IP_MULTICAST_LOOP
, TRUE
, {1, 1, 4}, {0}, TRUE
, TRUE
},
1218 {AF_INET
, SOCK_DGRAM
, IPPROTO_IP
, IP_MULTICAST_TTL
, TRUE
, {1, 1, 4}, {0}, FALSE
},
1219 {AF_INET
, SOCK_DGRAM
, IPPROTO_IP
, IP_PKTINFO
, FALSE
, {0, 0, 4}, {0}, TRUE
, TRUE
},
1220 {AF_INET
, SOCK_DGRAM
, IPPROTO_IP
, IP_RECVTOS
, FALSE
, {0, 0, 4}, {0}, TRUE
, TRUE
},
1221 {AF_INET
, SOCK_DGRAM
, IPPROTO_IP
, IP_RECVTTL
, FALSE
, {0, 0, 4}, {0}, TRUE
, TRUE
},
1222 {AF_INET
, SOCK_DGRAM
, IPPROTO_IP
, IP_TOS
, TRUE
, {1, 1, 4}, {0}, FALSE
},
1223 {AF_INET
, SOCK_DGRAM
, IPPROTO_IP
, IP_TTL
, TRUE
, {1, 1, 4}, {0}, FALSE
},
1224 {AF_INET6
, SOCK_STREAM
, IPPROTO_IPV6
, IPV6_DONTFRAG
, TRUE
, {1, 1, 4}, {0}, TRUE
, TRUE
},
1225 {AF_INET6
, SOCK_DGRAM
, IPPROTO_IPV6
, IPV6_HOPLIMIT
, FALSE
, {0, 0, 4}, {0}, TRUE
, TRUE
},
1226 {AF_INET6
, SOCK_DGRAM
, IPPROTO_IPV6
, IPV6_MULTICAST_HOPS
, TRUE
, {1, 1, 4}, {0}, FALSE
},
1227 {AF_INET6
, SOCK_DGRAM
, IPPROTO_IPV6
, IPV6_MULTICAST_LOOP
, TRUE
, {1, 1, 4}, {0}, TRUE
, TRUE
},
1228 {AF_INET6
, SOCK_DGRAM
, IPPROTO_IPV6
, IPV6_PKTINFO
, FALSE
, {0, 0, 4}, {0}, TRUE
, TRUE
},
1229 {AF_INET6
, SOCK_DGRAM
, IPPROTO_IPV6
, IPV6_RECVTCLASS
, FALSE
, {0, 0, 4}, {0}, TRUE
, TRUE
},
1230 {AF_INET6
, SOCK_DGRAM
, IPPROTO_IPV6
, IPV6_UNICAST_HOPS
, TRUE
, {1, 1, 4}, {0}, FALSE
},
1231 {AF_INET6
, SOCK_DGRAM
, IPPROTO_IPV6
, IPV6_V6ONLY
, TRUE
, {1, 1, 1}, {0}, TRUE
},
1233 SOCKET s
, s2
, src
, dst
;
1234 int i
, j
, err
, lasterr
;
1238 WSAPROTOCOL_INFOA infoA
;
1239 WSAPROTOCOL_INFOW infoW
;
1240 char providername
[WSAPROTOCOL_LEN
+ 1];
1241 DWORD expected_last_error
, expected_value
;
1242 int expected_err
, expected_size
;
1243 DWORD value
, save_value
;
1249 int family
, type
, proto
;
1251 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
1252 {AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
1253 {AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
},
1254 {AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
}
1262 s
= socket(AF_INET
, SOCK_STREAM
, 0);
1263 ok(s
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1264 if( s
== INVALID_SOCKET
) return;
1266 timeout
= SOCKTIMEOUT1
;
1267 size
= sizeof(timeout
);
1268 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1270 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1271 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1272 ok( timeout
== SOCKTIMEOUT1
, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1275 size
= sizeof(timeout
);
1276 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1278 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1279 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1280 ok( timeout
== 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1283 timeout
= SOCKTIMEOUT2
; /* 997 seconds. See remark above */
1284 size
= sizeof(timeout
);
1285 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, size
);
1287 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, &size
);
1288 ok( !err
, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1289 ok( timeout
== SOCKTIMEOUT2
, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout
);
1293 size
= sizeof(value
);
1294 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDBUF
, (char *)&value
, size
);
1295 ok( !err
, "setsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1297 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDBUF
, (char *)&value
, &size
);
1298 ok( !err
, "getsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1299 ok( value
== 4096, "expected 4096, got %lu\n", value
);
1303 size
= sizeof(value
);
1304 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, size
);
1305 ok( !err
, "setsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1307 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, &size
);
1308 ok( !err
, "getsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1309 ok( value
== 4096, "expected 4096, got %lu\n", value
);
1312 size
= sizeof(value
);
1313 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, size
);
1314 ok( !err
, "setsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1316 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, &size
);
1317 ok( !err
, "getsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1318 ok( value
== 0, "expected 0, got %lu\n", value
);
1320 /* Test non-blocking receive with too short SO_RCVBUF. */
1321 tcp_socketpair(&src
, &dst
);
1322 set_blocking(src
, FALSE
);
1323 set_blocking(dst
, FALSE
);
1326 size
= sizeof(value
);
1327 err
= setsockopt(src
, SOL_SOCKET
, SO_SNDBUF
, (char *)&value
, size
);
1328 ok( !err
, "got %d, error %u.\n", err
, WSAGetLastError() );
1331 err
= getsockopt(dst
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, &size
);
1332 ok( !err
, "got %d, error %u.\n", err
, WSAGetLastError() );
1333 if (value
>= sizeof(buffer
) * 3)
1336 size
= sizeof(value
);
1337 err
= setsockopt(dst
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, size
);
1338 ok( !err
, "got %d, error %u.\n", err
, WSAGetLastError() );
1340 err
= getsockopt(dst
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, &size
);
1341 ok( !err
, "got %d, error %u.\n", err
, WSAGetLastError() );
1342 ok( value
== 1024, "expected 0, got %lu\n", value
);
1344 err
= send(src
, buffer
, sizeof(buffer
), 0);
1345 ok(err
== sizeof(buffer
), "got %d\n", err
);
1346 err
= send(src
, buffer
, sizeof(buffer
), 0);
1347 ok(err
== sizeof(buffer
), "got %d\n", err
);
1348 err
= send(src
, buffer
, sizeof(buffer
), 0);
1349 ok(err
== sizeof(buffer
), "got %d\n", err
);
1351 err
= sync_recv(dst
, buffer
, sizeof(buffer
), 0);
1352 ok(err
== sizeof(buffer
), "got %d, error %u\n", err
, WSAGetLastError());
1353 err
= sync_recv(dst
, buffer
, sizeof(buffer
), 0);
1354 ok(err
== sizeof(buffer
), "got %d, error %u\n", err
, WSAGetLastError());
1355 err
= sync_recv(dst
, buffer
, sizeof(buffer
), 0);
1356 ok(err
== sizeof(buffer
), "got %d, error %u\n", err
, WSAGetLastError());
1360 skip("Default SO_RCVBUF %lu is too small, skipping test.\n", value
);
1367 for( i
= 0; i
< ARRAY_SIZE(linger_testvals
);i
++) {
1368 size
= sizeof(lingval
);
1369 lingval
= linger_testvals
[i
];
1370 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *)&lingval
, size
);
1371 ok(!err
, "Test %u: failed to set SO_LINGER, error %u\n", i
, WSAGetLastError());
1372 err
= getsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *)&lingval
, &size
);
1373 ok(!err
, "Test %u: failed to get SO_LINGER, error %u\n", i
, WSAGetLastError());
1374 ok(!lingval
.l_onoff
== !linger_testvals
[i
].l_onoff
, "Test %u: expected %d, got %d\n",
1375 i
, linger_testvals
[i
].l_onoff
, lingval
.l_onoff
);
1376 if (lingval
.l_onoff
)
1377 ok(lingval
.l_linger
== linger_testvals
[i
].l_linger
, "Test %u: expected %d, got %d\n",
1378 i
, linger_testvals
[i
].l_linger
, lingval
.l_linger
);
1381 size
= sizeof(lingval
);
1382 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, size
);
1383 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1384 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1385 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, 0);
1386 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1387 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1389 size
= sizeof(BOOL
);
1390 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, size
);
1391 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1392 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1393 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, 0);
1394 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1395 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1397 /* TCP_NODELAY: optlen doesn't matter on windows, it should work with any positive value */
1398 size
= sizeof(value
);
1401 err
= setsockopt(s
, IPPROTO_TCP
, TCP_NODELAY
, (char*)&value
, 1);
1402 ok (!err
, "setsockopt TCP_NODELAY failed with optlen == 1\n");
1404 err
= getsockopt(s
, IPPROTO_TCP
, TCP_NODELAY
, (char*)&value
, &size
);
1405 ok(!err
, "getsockopt TCP_NODELAY failed\n");
1406 ok(value
== 1, "TCP_NODELAY should be 1\n");
1408 err
= setsockopt(s
, IPPROTO_TCP
, TCP_NODELAY
, (char*)&value
, sizeof(value
));
1409 ok(!err
, "Failed to reset TCP_NODELAY to 0\n");
1412 err
= setsockopt(s
, IPPROTO_TCP
, TCP_NODELAY
, (char*)&value
, 4);
1413 ok (!err
, "setsockopt TCP_NODELAY failed with optlen == 4\n");
1415 err
= getsockopt(s
, IPPROTO_TCP
, TCP_NODELAY
, (char*)&value
, &size
);
1416 ok(!err
, "getsockopt TCP_NODELAY failed\n");
1417 ok(value
== 1, "TCP_NODELAY should be 1\n");
1419 err
= setsockopt(s
, IPPROTO_TCP
, TCP_NODELAY
, (char*)&value
, sizeof(value
));
1420 ok(!err
, "Failed to reset TCP_NODELAY to 0\n");
1423 err
= setsockopt(s
, IPPROTO_TCP
, TCP_NODELAY
, (char*)&value
, 42);
1424 ok (!err
, "setsockopt TCP_NODELAY failed with optlen == 42\n");
1426 err
= getsockopt(s
, IPPROTO_TCP
, TCP_NODELAY
, (char*)&value
, &size
);
1427 ok(!err
, "getsockopt TCP_NODELAY failed\n");
1428 ok(value
== 1, "TCP_NODELAY should be 1\n");
1430 err
= setsockopt(s
, IPPROTO_TCP
, TCP_NODELAY
, (char*)&value
, sizeof(value
));
1431 ok(!err
, "Failed to reset TCP_NODELAY to 0\n");
1434 err
= setsockopt(s
, IPPROTO_TCP
, TCP_NODELAY
, (char*)&value
, 0);
1435 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1436 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1438 err
= getsockopt(s
, IPPROTO_TCP
, TCP_NODELAY
, (char*)&value
, &size
);
1439 ok(!err
, "getsockopt TCP_NODELAY failed\n");
1440 ok(!value
, "TCP_NODELAY should be 0\n");
1443 err
= setsockopt(s
, IPPROTO_TCP
, TCP_NODELAY
, (char*)&value
, -1);
1444 /* On win 10 pro, this sets the error to WSAENOBUFS instead of WSAEFAULT */
1445 ok(err
== SOCKET_ERROR
&& (WSAGetLastError() == WSAEFAULT
|| WSAGetLastError() == WSAENOBUFS
),
1446 "got %d with %d (expected SOCKET_ERROR with either WSAEFAULT or WSAENOBUFS)\n", err
, WSAGetLastError());
1448 err
= getsockopt(s
, IPPROTO_TCP
, TCP_NODELAY
, (char*)&value
, &size
);
1449 ok(!err
, "getsockopt TCP_NODELAY failed\n");
1450 ok(!value
, "TCP_NODELAY should be 0\n");
1453 err
= setsockopt(s
, IPPROTO_TCP
, TCP_NODELAY
, (char*)&value
, 4);
1454 ok (!err
, "setsockopt TCP_NODELAY failed with optlen == 4 and optvalue = 0x100\n");
1456 err
= getsockopt(s
, IPPROTO_TCP
, TCP_NODELAY
, (char*)&value
, &size
);
1457 ok(!err
, "getsockopt TCP_NODELAY failed\n");
1458 ok(!value
, "TCP_NODELAY should be 0\n");
1460 size
= sizeof(DWORD
);
1462 err
= setsockopt(s
, IPPROTO_TCP
, TCP_KEEPALIVE
, (char*)&value
, 4);
1463 ok(!err
, "setsockopt TCP_KEEPALIVE failed\n");
1465 err
= getsockopt(s
, IPPROTO_TCP
, TCP_KEEPALIVE
, (char*)&value
, &size
);
1466 ok(!err
, "getsockopt TCP_KEEPALIVE failed\n");
1467 ok(value
== 3600, "TCP_KEEPALIVE should be 3600, is %ld\n", value
);
1469 /* TCP_KEEPCNT and TCP_KEEPINTVL are supported on win10 and later */
1471 err
= setsockopt(s
, IPPROTO_TCP
, TCP_KEEPCNT
, (char*)&value
, 4);
1472 ok(!err
|| broken(WSAGetLastError() == WSAENOPROTOOPT
),
1473 "setsockopt TCP_KEEPCNT failed: %d\n", WSAGetLastError());
1478 err
= getsockopt(s
, IPPROTO_TCP
, TCP_KEEPCNT
, (char*)&value
, &size
);
1479 ok(!err
, "getsockopt TCP_KEEPCNT failed\n");
1480 ok(value
== 5, "TCP_KEEPCNT should be 5, is %ld\n", value
);
1482 err
= setsockopt(s
, IPPROTO_TCP
, TCP_KEEPINTVL
, (char*)&value
, 4);
1483 ok(!err
, "setsockopt TCP_KEEPINTVL failed\n");
1485 err
= getsockopt(s
, IPPROTO_TCP
, TCP_KEEPINTVL
, (char*)&value
, &size
);
1486 ok(!err
, "getsockopt TCP_KEEPINTVL failed\n");
1487 ok(value
== 5, "TCP_KEEPINTVL should be 5, is %ld\n", value
);
1490 /* Test for erroneously passing a value instead of a pointer as optval */
1491 size
= sizeof(char);
1492 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTROUTE
, (char *)1, size
);
1493 ok(err
== SOCKET_ERROR
, "setsockopt with optval being a value passed "
1494 "instead of failing.\n");
1495 lasterr
= WSAGetLastError();
1496 ok(lasterr
== WSAEFAULT
, "setsockopt with optval being a value "
1497 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1498 lasterr
, WSAEFAULT
);
1500 /* SO_RCVTIMEO with invalid values for level */
1501 size
= sizeof(timeout
);
1502 timeout
= SOCKTIMEOUT1
;
1503 SetLastError(0xdeadbeef);
1504 err
= setsockopt(s
, 0xffffffff, SO_RCVTIMEO
, (char *) &timeout
, size
);
1505 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1506 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1507 err
, WSAGetLastError());
1509 timeout
= SOCKTIMEOUT1
;
1510 SetLastError(0xdeadbeef);
1511 err
= setsockopt(s
, 0x00008000, SO_RCVTIMEO
, (char *) &timeout
, size
);
1512 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1513 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1514 err
, WSAGetLastError());
1516 /* Test SO_ERROR set/get */
1517 SetLastError(0xdeadbeef);
1519 err
= setsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, size
);
1520 ok( !err
&& !WSAGetLastError(),
1521 "got %d with %d (expected 0 with 0)\n",
1522 err
, WSAGetLastError());
1524 SetLastError(0xdeadbeef);
1526 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1527 ok( !err
&& !WSAGetLastError(),
1528 "got %d with %d (expected 0 with 0)\n",
1529 err
, WSAGetLastError());
1531 ok (i
== 1234, "got %d (expected 1234)\n", i
);
1533 /* Test invalid optlen */
1534 SetLastError(0xdeadbeef);
1536 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1537 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEFAULT
),
1538 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1539 err
, WSAGetLastError());
1543 /* Test option length. */
1544 for (i
= 0; i
< ARRAY_SIZE(test_optsize
); ++i
)
1546 winetest_push_context("i %u, level %d, optname %d",
1547 i
, test_optsize
[i
].level
, test_optsize
[i
].optname
);
1549 s2
= socket( test_optsize
[i
].af
, test_optsize
[i
].type
, 0 );
1550 ok(s2
!= INVALID_SOCKET
, "socket() failed error %d\n", WSAGetLastError());
1552 size
= sizeof(save_value
);
1553 err
= getsockopt(s2
, test_optsize
[i
].level
, test_optsize
[i
].optname
, (char*)&save_value
, &size
);
1554 ok(!err
|| broken(test_optsize
[i
].allow_noprotoopt
&& WSAGetLastError() == WSAENOPROTOOPT
),
1555 "Unexpected getsockopt result %d.\n", err
);
1560 winetest_pop_context();
1564 value64
= 0xffffffff00000001;
1565 err
= setsockopt(s2
, test_optsize
[i
].level
, test_optsize
[i
].optname
, (char *)&value64
, sizeof(value64
));
1566 ok(!err
, "Unexpected setsockopt result %d.\n", err
);
1567 ok(!WSAGetLastError(), "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1569 size
= sizeof(value64
);
1570 err
= getsockopt(s2
, test_optsize
[i
].level
, test_optsize
[i
].optname
, (char*)&value64
, &size
);
1571 ok(!err
, "Unexpected getsockopt result %d.\n", err
);
1572 ok(size
== test_optsize
[i
].sizes
[2], "Got unexpected size %d.\n", size
);
1573 /* The behaviour regarding filling the high dword is different between options without the obvious
1574 * pattern, it is either left untouched (more often) or zeroed. Wine doesn't touch the high dword. */
1576 if (test_optsize
[i
].sizes
[2] == 1 || test_optsize
[i
].level
!= SOL_SOCKET
)
1579 expected_last_error
= WSAENOBUFS
;
1584 expected_last_error
= 0;
1588 err
= setsockopt(s2
, test_optsize
[i
].level
, test_optsize
[i
].optname
, (char *)&value
, -1);
1589 ok(err
== expected_err
, "Unexpected setsockopt result %d.\n", err
);
1590 /* Broken between Win7 and Win10 21H1. */
1591 ok(WSAGetLastError() == expected_last_error
|| broken(expected_last_error
&& WSAGetLastError() == WSAEFAULT
),
1592 "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1596 err
= getsockopt(s2
, test_optsize
[i
].level
, test_optsize
[i
].optname
, (char*)&value
, &size
);
1597 if (test_optsize
[i
].optname
== SO_OPENTYPE
)
1599 ok(!err
, "Unexpected getsockopt result %d.\n", err
);
1600 ok(!WSAGetLastError(), "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1604 ok(err
== -1, "Unexpected getsockopt result %d.\n", err
);
1605 ok(WSAGetLastError() == WSAEFAULT
, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1607 ok(size
== (test_optsize
[i
].optname
== SO_OPENTYPE
? 4 : -1), "Got unexpected size %d.\n", size
);
1609 if (test_optsize
[i
].level
== SOL_SOCKET
&& test_optsize
[i
].bool_value
)
1612 expected_last_error
= 0;
1617 expected_last_error
= WSAEFAULT
;
1620 SetLastError(0xdeadbeef);
1621 err
= setsockopt(s2
, test_optsize
[i
].level
, test_optsize
[i
].optname
, (char*)&value
, 0);
1622 ok(err
== expected_err
, "Unexpected setsockopt result %d.\n", err
);
1623 ok(WSAGetLastError() == expected_last_error
, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1626 err
= getsockopt(s2
, test_optsize
[i
].level
, test_optsize
[i
].optname
, (char*)&value
, &size
);
1627 ok(err
== -1, "Unexpected getsockopt result %d.\n", err
);
1628 ok(WSAGetLastError() == WSAEFAULT
, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1630 expected_size
= test_optsize
[i
].sizes
[2];
1631 if (expected_size
== 1)
1632 expected_value
= 0xdeadbe00;
1634 expected_value
= test_optsize
[i
].bool_value
? 0x1 : 0x100;
1635 if (test_optsize
[i
].accepts_large_value
)
1638 expected_last_error
= 0;
1643 expected_last_error
= WSAEINVAL
;
1647 SetLastError(0xdeadbeef);
1648 err
= setsockopt(s2
, test_optsize
[i
].level
, test_optsize
[i
].optname
, (char*)&value
, 4);
1649 ok(err
== expected_err
, "Unexpected setsockopt result %d.\n", err
);
1650 ok(WSAGetLastError() == expected_last_error
, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1652 if (test_optsize
[i
].accepts_large_value
)
1655 SetLastError(0xdeadbeef);
1657 err
= getsockopt(s2
, test_optsize
[i
].level
, test_optsize
[i
].optname
, (char*)&value
, &size
);
1658 ok(err
== expected_err
, "Unexpected getsockopt result %d.\n", err
);
1659 ok(WSAGetLastError() == expected_last_error
, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1660 todo_wine_if(test_optsize
[i
].optname
== SO_DONTROUTE
|| test_optsize
[i
].optname
== SO_LINGER
)
1661 ok(value
== expected_value
, "Got unexpected value %#lx, expected %#lx.\n", value
, expected_value
);
1662 ok(size
== expected_size
, "Got unexpected size %u, expected %u.\n", size
, expected_size
);
1665 winetest_pop_context();
1667 for (j
= 0; j
< ARRAY_SIZE(test_optsize
[i
].sizes
); ++j
)
1670 winetest_push_context("i %u, level %d, optname %d, len %u",
1671 i
, test_optsize
[i
].level
, test_optsize
[i
].optname
, size
);
1674 if (test_optsize
[i
].values
[j
])
1675 expected_value
= test_optsize
[i
].values
[j
];
1677 expected_value
= 0xdeadbeef;
1679 if (test_optsize
[i
].accepts_short_len
|| size
== 4)
1682 expected_last_error
= 0;
1683 expected_size
= test_optsize
[i
].sizes
[j
];
1685 if (!test_optsize
[i
].values
[j
])
1686 memcpy(&expected_value
, &value
, expected_size
);
1691 expected_last_error
= WSAEFAULT
;
1692 expected_size
= test_optsize
[i
].sizes
[j
];
1695 SetLastError(0xdeadbeef);
1696 err
= setsockopt(s2
, test_optsize
[i
].level
, test_optsize
[i
].optname
, (char*)&value
, size
);
1697 ok(err
== expected_err
, "Unexpected setsockopt result %d.\n", err
);
1698 ok(WSAGetLastError() == expected_last_error
, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1701 SetLastError(0xdeadbeef);
1702 err
= getsockopt(s2
, test_optsize
[i
].level
, test_optsize
[i
].optname
, (char*)&value
, &size
);
1703 ok(err
== expected_err
, "Unexpected getsockopt result %d.\n", err
);
1704 ok(WSAGetLastError() == expected_last_error
, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1705 ok(value
== expected_value
, "Got unexpected value %#lx, expected %#lx.\n", value
, expected_value
);
1706 ok(size
== expected_size
, "Got unexpected size %d, expected %d.\n", size
, expected_size
);
1708 winetest_pop_context();
1711 err
= setsockopt(s2
, test_optsize
[i
].level
, test_optsize
[i
].optname
,
1712 (char*)&save_value
, sizeof(save_value
));
1713 ok(!err
, "Unexpected getsockopt result %d.\n", err
);
1717 /* Test with the closed socket */
1718 SetLastError(0xdeadbeef);
1721 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1722 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAENOTSOCK
),
1723 "got %d with %d (expected SOCKET_ERROR with WSAENOTSOCK)\n",
1724 err
, WSAGetLastError());
1725 ok (i
== 1234, "expected 1234, got %d\n", i
);
1727 /* Test WS_IP_MULTICAST_TTL with 8, 16, 24 and 32 bits values */
1728 s
= socket(AF_INET
, SOCK_DGRAM
, 0);
1729 ok(s
!= INVALID_SOCKET
, "Failed to create socket\n");
1732 err
= setsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &i
, size
);
1735 for (i
= 0; i
< 4; i
++)
1738 const int tests
[] = {0xffffff0a, 0xffff000b, 0xff00000c, 0x0000000d};
1739 err
= setsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &tests
[i
], i
+ 1);
1740 ok(!err
, "Test [%d] Expected 0, got %d\n", i
, err
);
1741 err
= getsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &k
, &size
);
1742 ok(!err
, "Test [%d] Expected 0, got %d\n", i
, err
);
1743 j
= i
!= 3 ? tests
[i
] & ((1 << (i
+ 1) * 8) - 1) : tests
[i
];
1744 ok(k
== j
, "Test [%d] Expected 0x%x, got 0x%x\n", i
, j
, k
);
1748 win_skip("IP_MULTICAST_TTL is unsupported\n");
1751 /* test SO_PROTOCOL_INFOA invalid parameters */
1752 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1753 "getsockopt should have failed\n");
1754 err
= WSAGetLastError();
1755 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1756 size
= sizeof(WSAPROTOCOL_INFOA
);
1757 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1758 "getsockopt should have failed\n");
1759 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1760 err
= WSAGetLastError();
1761 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1762 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1763 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1764 "getsockopt should have failed\n");
1765 err
= WSAGetLastError();
1766 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1767 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, NULL
),
1768 "getsockopt should have failed\n");
1769 err
= WSAGetLastError();
1770 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1771 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, &size
),
1772 "getsockopt should have failed\n");
1773 err
= WSAGetLastError();
1774 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1775 size
= sizeof(WSAPROTOCOL_INFOA
) / 2;
1776 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1777 "getsockopt should have failed\n");
1778 err
= WSAGetLastError();
1779 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1780 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1781 size
= sizeof(WSAPROTOCOL_INFOA
) * 2;
1782 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1783 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1784 ok(size
== sizeof(WSAPROTOCOL_INFOA
) * 2, "got size %d\n", size
);
1788 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1789 for (i
= 0; i
< ARRAY_SIZE(prottest
); i
++)
1793 s
= socket(prottest
[i
].family
, prottest
[i
].type
, prottest
[i
].proto
);
1794 if (s
== INVALID_SOCKET
&& prottest
[i
].family
== AF_INET6
) continue;
1796 ok(s
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
1799 /* compare both A and W version */
1800 infoA
.szProtocol
[0] = 0;
1801 size
= sizeof(WSAPROTOCOL_INFOA
);
1802 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1803 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1804 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1806 infoW
.szProtocol
[0] = 0;
1807 size
= sizeof(WSAPROTOCOL_INFOW
);
1808 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOW
, (char *) &infoW
, &size
);
1809 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1810 ok(size
== sizeof(WSAPROTOCOL_INFOW
), "got size %d\n", size
);
1812 ok(infoA
.szProtocol
[0], "WSAPROTOCOL_INFOA was not filled\n");
1813 ok(infoW
.szProtocol
[0], "WSAPROTOCOL_INFOW was not filled\n");
1815 WideCharToMultiByte(CP_ACP
, 0, infoW
.szProtocol
, -1,
1816 providername
, sizeof(providername
), NULL
, NULL
);
1817 ok(!strcmp(infoA
.szProtocol
,providername
),
1818 "different provider names '%s' != '%s'\n", infoA
.szProtocol
, providername
);
1820 ok(!memcmp(&infoA
, &infoW
, FIELD_OFFSET(WSAPROTOCOL_INFOA
, szProtocol
)),
1821 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1823 /* Remove IF when WSAEnumProtocols support IPV6 data */
1824 ok(infoA
.iAddressFamily
== prottest
[i
].family
, "socket family invalid, expected %d received %d\n",
1825 prottest
[i
].family
, infoA
.iAddressFamily
);
1826 ok(infoA
.iSocketType
== prottest
[i
].type
, "socket type invalid, expected %d received %d\n",
1827 prottest
[i
].type
, infoA
.iSocketType
);
1828 ok(infoA
.iProtocol
== prottest
[i
].proto
, "socket protocol invalid, expected %d received %d\n",
1829 prottest
[i
].proto
, infoA
.iProtocol
);
1831 /* IP_HDRINCL is supported only on SOCK_RAW but passed to SOCK_DGRAM by Impossible Creatures */
1834 SetLastError(0xdeadbeef);
1835 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1836 if (err
== -1) /* >= Vista */
1838 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %ld\n", GetLastError());
1840 SetLastError(0xdeadbeef);
1841 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1842 ok(err
== -1, "Expected -1, got %d\n", err
);
1843 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %ld\n", GetLastError());
1844 ok(k
== 99, "Expected 99, got %d\n", k
);
1848 SetLastError(0xdeadbeef);
1849 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1850 ok(err
== -1, "Expected -1, got %d\n", err
);
1851 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %ld\n", GetLastError());
1853 SetLastError(0xdeadbeef);
1854 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1855 ok(err
== -1, "Expected -1, got %d\n", err
);
1856 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %ld\n", GetLastError());
1857 ok(k
== 99, "Expected 99, got %d\n", k
);
1859 else /* <= 2003 the tests differ between TCP and UDP, UDP silently accepts */
1861 SetLastError(0xdeadbeef);
1863 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1864 if (prottest
[i
].type
== SOCK_DGRAM
)
1866 ok(err
== 0, "Expected 0, got %d\n", err
);
1867 ok(k
== 1, "Expected 1, got %d\n", k
);
1871 /* contratry to what we could expect the function returns error but k is changed */
1872 ok(err
== -1, "Expected -1, got %d\n", err
);
1873 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %ld\n", GetLastError());
1874 ok(k
== 0, "Expected 0, got %d\n", k
);
1878 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1879 ok(err
== 0, "Expected 0, got %d\n", err
);
1882 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1883 if (prottest
[i
].type
== SOCK_DGRAM
)
1885 ok(err
== 0, "Expected 0, got %d\n", err
);
1886 ok(k
== 0, "Expected 0, got %d\n", k
);
1890 /* contratry to what we could expect the function returns error but k is changed */
1891 ok(err
== -1, "Expected -1, got %d\n", err
);
1892 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %ld\n", GetLastError());
1893 ok(k
== 0, "Expected 0, got %d\n", k
);
1900 /* Test SO_BSP_STATE - Present only in >= Win 2008 */
1901 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1902 ok(s
!= INVALID_SOCKET
, "Failed to create socket\n");
1903 s2
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1904 ok(s2
!= INVALID_SOCKET
, "Failed to create socket\n");
1906 SetLastError(0xdeadbeef);
1907 size
= sizeof(csinfoA
);
1908 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1911 struct sockaddr_in saddr
;
1912 memset(&saddr
, 0, sizeof(saddr
));
1913 saddr
.sin_family
= AF_INET
;
1914 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1916 /* Socket is not bound, no information provided */
1917 ok(!csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1918 ok(csinfoA
.cs
.LocalAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.LocalAddr
.lpSockaddr
);
1919 /* Socket is not connected, no information provided */
1920 ok(!csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.RemoteAddr
.iSockaddrLength
);
1921 ok(csinfoA
.cs
.RemoteAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.RemoteAddr
.lpSockaddr
);
1923 err
= bind(s
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1924 ok(!err
, "Expected 0, got %d\n", err
);
1925 size
= sizeof(csinfoA
);
1926 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1927 ok(!err
, "Expected 0, got %d\n", err
);
1929 /* Socket is bound */
1930 ok(csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected non-zero\n");
1931 ok(csinfoA
.cs
.LocalAddr
.lpSockaddr
!= NULL
, "Expected non-null\n");
1932 /* Socket is not connected, no information provided */
1933 ok(!csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.RemoteAddr
.iSockaddrLength
);
1934 ok(csinfoA
.cs
.RemoteAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.RemoteAddr
.lpSockaddr
);
1936 err
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1937 ok(!err
, "Expected 0, got %d\n", err
);
1938 err
= getsockname(s2
, (struct sockaddr
*)&saddr
, &size
);
1939 ok(!err
, "Expected 0, got %d\n", err
);
1940 err
= listen(s2
, 1);
1941 ok(!err
, "Expected 0, got %d\n", err
);
1942 err
= connect(s
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1943 ok(!err
, "Expected 0, got %d\n", err
);
1944 size
= sizeof(saddr
);
1945 err
= accept(s2
, (struct sockaddr
*)&saddr
, &size
);
1946 ok(err
!= INVALID_SOCKET
, "Failed to accept socket\n");
1950 size
= sizeof(csinfoA
);
1951 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1952 ok(!err
, "Expected 0, got %d\n", err
);
1953 err
= getsockopt(s2
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoB
, &size
);
1954 ok(!err
, "Expected 0, got %d\n", err
);
1955 ok(size
== sizeof(csinfoA
), "Got %d\n", size
);
1956 size
= sizeof(saddr
);
1957 ok(size
== csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected %d, got %d\n", size
,
1958 csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1959 ok(size
== csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected %d, got %d\n", size
,
1960 csinfoA
.cs
.RemoteAddr
.iSockaddrLength
);
1961 ok(!memcmp(csinfoA
.cs
.LocalAddr
.lpSockaddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
),
1962 "Expected matching addresses\n");
1963 ok(!memcmp(csinfoB
.cs
.LocalAddr
.lpSockaddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
),
1964 "Expected matching addresses\n");
1965 ok(csinfoA
.cs
.iSocketType
== SOCK_STREAM
, "Wrong socket type\n");
1966 ok(csinfoB
.cs
.iSocketType
== SOCK_STREAM
, "Wrong socket type\n");
1967 ok(csinfoA
.cs
.iProtocol
== IPPROTO_TCP
, "Wrong socket protocol\n");
1968 ok(csinfoB
.cs
.iProtocol
== IPPROTO_TCP
, "Wrong socket protocol\n");
1970 err
= getpeername(s
, (struct sockaddr
*)&saddr
, &size
);
1971 ok(!err
, "Expected 0, got %d\n", err
);
1972 ok(!memcmp(&saddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1973 ok(!memcmp(&saddr
, csinfoB
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1974 err
= getpeername(s2
, (struct sockaddr
*)&saddr
, &size
);
1975 ok(!err
, "Expected 0, got %d\n", err
);
1976 ok(!memcmp(&saddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1977 ok(!memcmp(&saddr
, csinfoA
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1978 err
= getsockname(s
, (struct sockaddr
*)&saddr
, &size
);
1979 ok(!err
, "Expected 0, got %d\n", err
);
1980 ok(!memcmp(&saddr
, csinfoA
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1981 ok(!memcmp(&saddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1982 err
= getsockname(s2
, (struct sockaddr
*)&saddr
, &size
);
1983 ok(!err
, "Expected 0, got %d\n", err
);
1984 ok(!memcmp(&saddr
, csinfoB
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1985 ok(!memcmp(&saddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1987 SetLastError(0xdeadbeef);
1988 size
= sizeof(CSADDR_INFO
);
1989 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1990 ok(err
, "Expected non-zero\n");
1991 ok(size
== sizeof(CSADDR_INFO
), "Got %d\n", size
);
1992 ok(GetLastError() == WSAEFAULT
, "Expected 10014, got %ld\n", GetLastError());
1994 /* At least for IPv4 the size is exactly 56 bytes */
1995 size
= sizeof(*csinfoA
.cs
.LocalAddr
.lpSockaddr
) * 2 + sizeof(csinfoA
.cs
);
1996 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1997 ok(!err
, "Expected 0, got %d\n", err
);
1999 SetLastError(0xdeadbeef);
2000 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
2001 ok(err
, "Expected non-zero\n");
2002 ok(GetLastError() == WSAEFAULT
, "Expected 10014, got %ld\n", GetLastError());
2005 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %ld\n", GetLastError());
2010 for (i
= 0; i
< 2; i
++)
2017 level
= IPPROTO_IPV6
;
2025 s
= socket(family
, SOCK_DGRAM
, 0);
2026 if (s
== INVALID_SOCKET
&& i
)
2028 skip("IPv6 is not supported\n");
2031 ok(s
!= INVALID_SOCKET
, "socket failed with error %ld\n", GetLastError());
2033 size
= sizeof(value
);
2035 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
2036 ok(!err
, "Expected 0, got %d with error %ld\n", err
, GetLastError());
2037 ok(value
== 0, "Expected 0, got %ld\n", value
);
2039 size
= sizeof(value
);
2041 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
2042 ok(!err
, "Expected 0, got %d with error %ld\n", err
, GetLastError());
2045 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
2046 ok(!err
, "Expected 0, got %d with error %ld\n", err
, GetLastError());
2047 ok(value
== 1, "Expected 1, got %ld\n", value
);
2049 size
= sizeof(value
);
2051 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
2052 ok(!err
, "Expected 0, got %d with error %ld\n", err
, GetLastError());
2054 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
2055 ok(!err
, "Expected 0, got %d with error %ld\n", err
, GetLastError());
2056 ok(value
== 1, "Expected 1, got %ld\n", value
);
2060 s
= socket(family
, SOCK_STREAM
, 0);
2061 ok(s
!= INVALID_SOCKET
, "socket failed with error %ld\n", GetLastError());
2063 size
= sizeof(value
);
2065 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
2066 ok(!err
, "Expected 0, got %d with error %ld\n", err
, GetLastError());
2067 ok(value
== 1 || broken(value
== 0) /* < vista */, "Expected 1, got %ld\n", value
);
2069 size
= sizeof(value
);
2071 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
2072 ok(!err
, "Expected 0, got %d with error %ld\n", err
, GetLastError());
2075 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
2076 ok(!err
, "Expected 0, got %d with error %ld\n", err
, GetLastError());
2077 ok(value
== 0, "Expected 0, got %ld\n", value
);
2081 s
= socket(family
, SOCK_RAW
, 0);
2082 if (s
== INVALID_SOCKET
)
2084 if (WSAGetLastError() == WSAEACCES
) skip("SOCK_RAW is not available\n");
2085 else if (i
) skip("IPv6 is not supported\n");
2088 ok(s
!= INVALID_SOCKET
, "socket failed with error %ld\n", GetLastError());
2090 size
= sizeof(value
);
2092 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
2093 ok(!err
, "Expected 0, got %d with error %ld\n", err
, GetLastError());
2094 ok(value
== 0, "Expected 0, got %ld\n", value
);
2096 size
= sizeof(value
);
2098 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
2099 ok(!err
, "Expected 0, got %d with error %ld\n", err
, GetLastError());
2102 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
2103 ok(!err
, "Expected 0, got %d with error %ld\n", err
, GetLastError());
2104 ok(value
== 1, "Expected 1, got %ld\n", value
);
2110 static void test_reuseaddr(void)
2112 static struct sockaddr_in6 saddr_in6_any
, saddr_in6_loopback
;
2113 static struct sockaddr_in6 saddr_in6_any_v4mapped
, saddr_in6_loopback_v4mapped
;
2114 static struct sockaddr_in saddr_in_any
, saddr_in_loopback
;
2119 struct sockaddr
*addr_any
;
2120 struct sockaddr
*addr_loopback
;
2125 { AF_INET
, (struct sockaddr
*)&saddr_in_any
, (struct sockaddr
*)&saddr_in_loopback
, sizeof(saddr_in_any
) },
2126 { AF_INET6
, (struct sockaddr
*)&saddr_in6_any
, (struct sockaddr
*)&saddr_in6_loopback
, sizeof(saddr_in6_any
) },
2133 struct sockaddr
*addr
;
2143 {{ AF_INET
, (struct sockaddr
*)&saddr_in_any
, sizeof(saddr_in_any
), TRUE
, },
2144 { AF_INET
, (struct sockaddr
*)&saddr_in_loopback
, sizeof(saddr_in_loopback
), FALSE
, }},
2148 {{ AF_INET6
, (struct sockaddr
*)&saddr_in6_any
, sizeof(saddr_in6_any
), TRUE
, },
2149 { AF_INET
, (struct sockaddr
*)&saddr_in_loopback
, sizeof(saddr_in_loopback
), FALSE
, }},
2153 {{ AF_INET
, (struct sockaddr
*)&saddr_in_any
, sizeof(saddr_in_any
), FALSE
, },
2154 { AF_INET
, (struct sockaddr
*)&saddr_in_loopback
, sizeof(saddr_in_loopback
), TRUE
, }},
2158 {{ AF_INET
, (struct sockaddr
*)&saddr_in_any
, sizeof(saddr_in_any
), TRUE
, },
2159 { AF_INET
, (struct sockaddr
*)&saddr_in_loopback
, sizeof(saddr_in_loopback
), TRUE
, }},
2163 {{ AF_INET
, (struct sockaddr
*)&saddr_in_loopback
, sizeof(saddr_in_loopback
), TRUE
, },
2164 { AF_INET
, (struct sockaddr
*)&saddr_in_any
, sizeof(saddr_in_any
), FALSE
, }},
2168 {{ AF_INET
, (struct sockaddr
*)&saddr_in_loopback
, sizeof(saddr_in_loopback
), FALSE
, },
2169 { AF_INET
, (struct sockaddr
*)&saddr_in_any
, sizeof(saddr_in_any
), TRUE
, }},
2173 {{ AF_INET
, (struct sockaddr
*)&saddr_in_loopback
, sizeof(saddr_in_loopback
), FALSE
, },
2174 { AF_INET6
, (struct sockaddr
*)&saddr_in6_any
, sizeof(saddr_in6_any
), TRUE
, }},
2178 {{ AF_INET6
, (struct sockaddr
*)&saddr_in6_loopback
, sizeof(saddr_in6_loopback
), FALSE
, },
2179 { AF_INET
, (struct sockaddr
*)&saddr_in_any
, sizeof(saddr_in_any
), TRUE
, }},
2183 {{ AF_INET6
, (struct sockaddr
*)&saddr_in6_loopback
, sizeof(saddr_in6_loopback
), TRUE
, },
2184 { AF_INET
, (struct sockaddr
*)&saddr_in_loopback
, sizeof(saddr_in_loopback
), TRUE
, }},
2188 {{ AF_INET6
, (struct sockaddr
*)&saddr_in6_loopback_v4mapped
, sizeof(saddr_in6_loopback_v4mapped
), FALSE
, },
2189 { AF_INET
, (struct sockaddr
*)&saddr_in_any
, sizeof(saddr_in_any
), TRUE
, }},
2193 {{ AF_INET6
, (struct sockaddr
*)&saddr_in6_any
, sizeof(saddr_in6_any
), TRUE
, },
2194 { AF_INET
, (struct sockaddr
*)&saddr_in_any
, sizeof(saddr_in_any
), FALSE
, }},
2198 {{ AF_INET6
, (struct sockaddr
*)&saddr_in6_any
, sizeof(saddr_in6_any
), FALSE
, },
2199 { AF_INET
, (struct sockaddr
*)&saddr_in_any
, sizeof(saddr_in_any
), TRUE
, }},
2203 {{ AF_INET
, (struct sockaddr
*)&saddr_in_any
, sizeof(saddr_in_any
), FALSE
, },
2204 { AF_INET
, (struct sockaddr
*)&saddr_in_any
, sizeof(saddr_in_any
), TRUE
, }},
2208 {{ AF_INET
, (struct sockaddr
*)&saddr_in_any
, sizeof(saddr_in_any
), FALSE
, },
2209 { AF_INET
, (struct sockaddr
*)&saddr_in_any
, sizeof(saddr_in_any
), FALSE
, }},
2213 {{ AF_INET6
, (struct sockaddr
*)&saddr_in6_any
, sizeof(saddr_in6_any
), FALSE
, },
2214 { AF_INET
, (struct sockaddr
*)&saddr_in_any
, sizeof(saddr_in_any
), FALSE
, }},
2218 {{ AF_INET6
, (struct sockaddr
*)&saddr_in6_any_v4mapped
, sizeof(saddr_in6_any_v4mapped
), FALSE
, },
2219 { AF_INET
, (struct sockaddr
*)&saddr_in_any
, sizeof(saddr_in_any
), FALSE
, }},
2223 {{ AF_INET6
, (struct sockaddr
*)&saddr_in6_loopback_v4mapped
, sizeof(saddr_in6_loopback_v4mapped
), FALSE
, },
2224 { AF_INET
, (struct sockaddr
*)&saddr_in_loopback
, sizeof(saddr_in_loopback
), FALSE
, }},
2228 {{ AF_INET
, (struct sockaddr
*)&saddr_in_loopback
, sizeof(saddr_in_loopback
), FALSE
, },
2229 { AF_INET6
, (struct sockaddr
*)&saddr_in6_loopback_v4mapped
, sizeof(saddr_in6_loopback_v4mapped
), FALSE
, }},
2233 {{ AF_INET6
, (struct sockaddr
*)&saddr_in6_loopback
, sizeof(saddr_in6_loopback
), TRUE
, },
2234 { AF_INET
, (struct sockaddr
*)&saddr_in_loopback
, sizeof(saddr_in_loopback
), TRUE
, }},
2238 {{ AF_INET
, (struct sockaddr
*)&saddr_in_loopback
, sizeof(saddr_in_loopback
), TRUE
, },
2239 { AF_INET
, (struct sockaddr
*)&saddr_in_loopback
, sizeof(saddr_in_loopback
), FALSE
, }},
2243 {{ AF_INET
, (struct sockaddr
*)&saddr_in_loopback
, sizeof(saddr_in_loopback
), FALSE
, },
2244 { AF_INET
, (struct sockaddr
*)&saddr_in_loopback
, sizeof(saddr_in_loopback
), TRUE
, }},
2249 unsigned int rc
, reuse
, value
;
2250 struct sockaddr_storage saddr
;
2251 SOCKET s1
, s2
, s3
, s4
, s5
, s6
;
2255 saddr_in_any
.sin_family
= AF_INET
;
2256 saddr_in_any
.sin_port
= htons(SERVERPORT
+ 1);
2257 saddr_in_any
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
2258 saddr_in_loopback
= saddr_in_any
;
2259 saddr_in_loopback
.sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
2261 saddr_in6_any
.sin6_family
= AF_INET6
;
2262 saddr_in6_any
.sin6_port
= htons(SERVERPORT
+ 1);
2263 memset( &saddr_in6_any
.sin6_addr
, 0, sizeof(saddr_in6_any
.sin6_addr
) );
2264 saddr_in6_loopback
= saddr_in6_any
;
2265 inet_pton(AF_INET6
, "::1", &saddr_in6_loopback
.sin6_addr
);
2267 saddr_in6_loopback_v4mapped
= saddr_in6_any
;
2268 rc
= inet_pton(AF_INET6
, "::ffff:127.0.0.1", &saddr_in6_loopback_v4mapped
.sin6_addr
);
2269 ok(rc
, "got error %d.\n", WSAGetLastError());
2271 saddr_in6_any_v4mapped
= saddr_in6_any
;
2272 rc
= inet_pton(AF_INET6
, "::ffff:0.0.0.0", &saddr_in6_any_v4mapped
.sin6_addr
);
2273 ok(rc
, "got error %d.\n", WSAGetLastError());
2275 for (i
= 0; i
< ARRAY_SIZE(tests
); ++i
)
2277 winetest_push_context("test %u", i
);
2279 /* Test with SO_REUSEADDR on second socket only. */
2280 s1
=socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2281 ok(s1
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2283 rc
= bind(s1
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2284 ok(!rc
|| (tests
[i
].domain
== AF_INET6
&& WSAGetLastError() == WSAEADDRNOTAVAIL
), "got error %d.\n", WSAGetLastError());
2285 if (tests
[i
].domain
== AF_INET6
&& WSAGetLastError() == WSAEADDRNOTAVAIL
)
2287 skip("IPv6 not supported, skipping test\n");
2289 winetest_pop_context();
2293 s2
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2294 ok(s2
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2297 rc
= setsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
2298 ok(!rc
, "got error %d.\n", WSAGetLastError());
2300 rc
= bind(s2
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2301 ok(rc
== SOCKET_ERROR
, "got rc %d.\n", rc
);
2302 ok(WSAGetLastError() == WSAEACCES
, "got error %d.\n", WSAGetLastError());
2307 /* Test with SO_REUSEADDR on both sockets. */
2308 s1
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2309 ok(s1
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2312 rc
= setsockopt(s1
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
2313 ok(!rc
, "got error %d.\n", WSAGetLastError());
2315 rc
= bind(s1
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2316 ok(!rc
, "got error %d.\n", WSAGetLastError());
2318 s2
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2319 ok(s2
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2322 size
= sizeof(reuse
);
2323 rc
= getsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, &size
);
2324 ok(!rc
&& !reuse
,"got rc %d, reuse %d.\n", rc
, reuse
);
2326 rc
= bind(s2
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2327 ok(rc
== SOCKET_ERROR
, "got rc %d, error %d.\n", rc
, WSAGetLastError());
2330 rc
= setsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
2331 ok(!rc
, "got error %d.\n", WSAGetLastError());
2333 rc
= bind(s2
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2334 ok(!rc
, "got error %d.\n", WSAGetLastError());
2336 s3
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2337 ok(s3
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2339 /* Test if we can really connect to one of them. */
2341 ok(!rc
, "got error %d.\n", WSAGetLastError());
2343 todo_wine
ok(!rc
, "got error %d.\n", WSAGetLastError());
2344 rc
= connect(s3
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2345 ok(!rc
, "got error %d.\n", WSAGetLastError());
2347 /* The connection is delivered to the first socket. */
2348 size
= tests
[i
].addrlen
;
2349 s4
= accept(s1
, (struct sockaddr
*)&saddr
, &size
);
2350 ok(s4
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2357 /* Test binding and listening on any addr together with loopback, any addr first. */
2358 s1
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2359 ok(s1
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2361 rc
= bind(s1
, tests
[i
].addr_any
, tests
[i
].addrlen
);
2362 ok(!rc
, "got error %d.\n", WSAGetLastError());
2365 ok(!rc
, "got error %d.\n", WSAGetLastError());
2367 s2
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2368 ok(s2
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2370 rc
= bind(s2
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2371 todo_wine
ok(!rc
, "got error %d.\n", WSAGetLastError());
2374 todo_wine
ok(!rc
, "got error %d.\n", WSAGetLastError());
2376 s3
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2377 ok(s3
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2379 rc
= connect(s3
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2380 ok(!rc
, "got error %d.\n", WSAGetLastError());
2382 size
= tests
[i
].addrlen
;
2383 s4
= accept(s2
, (struct sockaddr
*)&saddr
, &size
);
2384 todo_wine
ok(s4
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2391 /* Test binding and listening on any addr together with loopback, loopback addr first. */
2393 s1
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2394 ok(s1
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2396 rc
= bind(s1
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2397 ok(!rc
, "got error %d.\n", WSAGetLastError());
2400 ok(!rc
, "got error %d.\n", WSAGetLastError());
2402 s2
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2403 ok(s2
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2405 rc
= bind(s2
, tests
[i
].addr_any
, tests
[i
].addrlen
);
2406 todo_wine
ok(!rc
, "got rc %d, error %d.\n", rc
, WSAGetLastError());
2409 todo_wine
ok(!rc
, "got error %d.\n", WSAGetLastError());
2411 s3
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2412 ok(s3
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2414 rc
= connect(s3
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2415 ok(!rc
, "got error %d.\n", WSAGetLastError());
2416 size
= tests
[i
].addrlen
;
2417 s4
= accept(s1
, (struct sockaddr
*)&saddr
, &size
);
2419 ok(s4
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2426 /* Test binding to INADDR_ANY on two sockets. */
2427 s1
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2428 ok(s1
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2430 rc
= bind(s1
, tests
[i
].addr_any
, tests
[i
].addrlen
);
2431 ok(!rc
, "got error %d.\n", WSAGetLastError());
2433 s2
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2434 ok(s2
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2436 rc
= bind(s2
, tests
[i
].addr_any
, tests
[i
].addrlen
);
2437 ok(rc
== SOCKET_ERROR
&& WSAGetLastError() == WSAEADDRINUSE
, "got rc %d, error %d.\n", rc
, WSAGetLastError());
2442 /* Test successive binds and bind-after-listen */
2444 s1
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2445 ok(s1
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2446 rc
= setsockopt(s1
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
2447 ok(!rc
, "got error %d.\n", WSAGetLastError());
2449 s2
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2450 ok(s2
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2451 rc
= setsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
2452 ok(!rc
, "got error %d.\n", WSAGetLastError());
2454 s3
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2455 ok(s3
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2456 rc
= setsockopt(s3
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
2457 ok(!rc
, "got error %d.\n", WSAGetLastError());
2459 s4
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2460 ok(s4
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2461 rc
= setsockopt(s4
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
2462 ok(!rc
, "got error %d.\n", WSAGetLastError());
2464 rc
= bind(s1
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2465 ok(!rc
, "got error %d.\n", WSAGetLastError());
2467 rc
= bind(s2
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2468 ok(!rc
, "got error %d.\n", WSAGetLastError());
2470 s5
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2471 ok(s5
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2474 ok(!rc
, "got error %d.\n", WSAGetLastError());
2476 todo_wine
ok(!rc
, "got error %d.\n", WSAGetLastError());
2477 rc
= connect(s5
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2478 ok(!rc
, "got error %d.\n", WSAGetLastError());
2480 /* The connection is delivered to the first socket. */
2481 size
= tests
[i
].addrlen
;
2482 s6
= accept(s1
, (struct sockaddr
*)&saddr
, &size
);
2483 ok(s6
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2489 rc
= bind(s3
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2490 ok(!rc
, "got error %d.\n", WSAGetLastError());
2492 s5
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2493 ok(s5
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2494 rc
= connect(s5
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2495 todo_wine
ok(!rc
, "got error %d.\n", WSAGetLastError());
2497 /* The connection is delivered to the second socket. */
2498 size
= tests
[i
].addrlen
;
2499 s6
= accept(s2
, (struct sockaddr
*)&saddr
, &size
);
2500 todo_wine
ok(s6
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2506 rc
= bind(s4
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2507 ok(!rc
, "got error %d.\n", WSAGetLastError());
2509 ok(!rc
, "got error %d.\n", WSAGetLastError());
2511 s5
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2512 ok(s5
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2513 rc
= connect(s5
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2514 ok(!rc
, "got error %d.\n", WSAGetLastError());
2516 /* The connection is delivered to the third socket. */
2517 size
= tests
[i
].addrlen
;
2518 s6
= accept(s3
, (struct sockaddr
*)&saddr
, &size
);
2519 ok(s6
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2526 ok(!rc
, "got error %d.\n", WSAGetLastError());
2528 s5
= socket(tests
[i
].domain
, SOCK_STREAM
, 0);
2529 ok(s5
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2530 rc
= connect(s5
, tests
[i
].addr_loopback
, tests
[i
].addrlen
);
2531 ok(!rc
, "got error %d.\n", WSAGetLastError());
2533 /* The connection is delivered to the fourth socket. */
2534 size
= tests
[i
].addrlen
;
2535 s6
= accept(s4
, (struct sockaddr
*)&saddr
, &size
);
2536 ok(s6
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2542 winetest_pop_context();
2545 /* SO_REUSEADDR and SO_EXCLUSIVEADDRUSE are mutually exclusive. */
2546 s1
= socket(AF_INET
, SOCK_STREAM
, 0);
2547 ok(s1
!= INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2550 rc
= setsockopt(s1
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&value
, sizeof(value
));
2551 ok(!rc
, "got error %d.\n", WSAGetLastError());
2554 rc
= setsockopt(s1
, SOL_SOCKET
, SO_EXCLUSIVEADDRUSE
, (char*)&value
, sizeof(value
));
2555 ok(rc
== SOCKET_ERROR
&& WSAGetLastError() == WSAEINVAL
, "got rc %d, error %d.\n", rc
, WSAGetLastError());
2558 rc
= setsockopt(s1
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&value
, sizeof(value
));
2561 rc
= setsockopt(s1
, SOL_SOCKET
, SO_EXCLUSIVEADDRUSE
, (char*)&value
, sizeof(value
));
2562 ok(!rc
, "got error %d.\n", WSAGetLastError());
2565 rc
= setsockopt(s1
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&value
, sizeof(value
));
2566 ok(rc
== SOCKET_ERROR
&& WSAGetLastError() == WSAEINVAL
, "got rc %d, error %d.\n", rc
, WSAGetLastError());
2570 /* Test SO_EXCLUSIVEADDRUSE. */
2571 for (i
= 0; i
< ARRAY_SIZE(tests_exclusive
); ++i
)
2575 winetest_push_context("test %u", i
);
2577 for (j
= 0; j
< 2; ++j
)
2579 s
[j
] = socket(tests_exclusive
[i
].s
[j
].domain
, SOCK_STREAM
, 0);
2580 ok(s
[j
] != INVALID_SOCKET
, "got error %d.\n", WSAGetLastError());
2582 if (tests_exclusive
[i
].s
[j
].exclusive
)
2585 rc
= setsockopt(s
[j
], SOL_SOCKET
, SO_EXCLUSIVEADDRUSE
, (char*)&value
, sizeof(value
));
2586 ok(!rc
, "got error %d.\n", WSAGetLastError());
2588 if (tests_exclusive
[i
].s
[j
].domain
== AF_INET6
)
2591 rc
= setsockopt(s
[j
], IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&value
, sizeof(value
));
2592 ok(!rc
, "got error %d.\n", WSAGetLastError());
2595 rc
= bind(s
[0], tests_exclusive
[i
].s
[0].addr
, tests_exclusive
[i
].s
[0].addrlen
);
2596 ok(!rc
|| (tests_exclusive
[i
].s
[0].domain
== AF_INET6
&& WSAGetLastError() == WSAEADDRNOTAVAIL
), "got error %d.\n", WSAGetLastError());
2598 rc
= bind(s
[1], tests_exclusive
[i
].s
[1].addr
, tests_exclusive
[i
].s
[1].addrlen
);
2600 if (tests_exclusive
[i
].error
)
2601 ok(rc
== SOCKET_ERROR
&& WSAGetLastError() == tests_exclusive
[i
].error
,
2602 "got rc %d, error %d, expected error %d.\n", rc
, WSAGetLastError(), tests_exclusive
[i
].error
);
2604 ok(!rc
, "got error %d.\n", WSAGetLastError());
2608 winetest_pop_context();
2612 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
2614 static unsigned int got_ip_pktinfo_apc
;
2616 static void WINAPI
ip_pktinfo_apc(DWORD error
, DWORD size
, OVERLAPPED
*overlapped
, DWORD flags
)
2618 ok(error
== WSAEMSGSIZE
, "got error %lu\n", error
);
2619 ok(size
== 6, "got size %lu\n", size
);
2620 ok(!flags
, "got flags %#lx\n", flags
);
2621 ++got_ip_pktinfo_apc
;
2624 static void test_ip_pktinfo(void)
2626 ULONG addresses
[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY
)};
2627 char recvbuf
[10], pktbuf
[512], msg
[] = "HELLO";
2628 struct sockaddr_in s1addr
, s2addr
, s3addr
;
2629 LPFN_WSARECVMSG pWSARecvMsg
= NULL
;
2630 unsigned int rc
, yes
= 1;
2632 DWORD dwBytes
, dwSize
, dwFlags
;
2641 memset(&ov
, 0, sizeof(ov
));
2642 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
2644 memset(&hdr
, 0x00, sizeof(hdr
));
2645 s1addr
.sin_family
= AF_INET
;
2646 s1addr
.sin_port
= htons(0);
2647 /* Note: s1addr.sin_addr is set below */
2648 iovec
[0].buf
= recvbuf
;
2649 iovec
[0].len
= sizeof(recvbuf
);
2650 hdr
.name
= (struct sockaddr
*)&s3addr
;
2651 hdr
.namelen
= sizeof(s3addr
);
2652 hdr
.lpBuffers
= &iovec
[0];
2653 hdr
.dwBufferCount
= 1;
2654 hdr
.Control
.buf
= pktbuf
;
2655 /* Note: hdr.Control.len is set below */
2658 for (i
=0;i
<ARRAY_SIZE(addresses
);i
++)
2660 s1addr
.sin_addr
.s_addr
= addresses
[i
];
2662 /* Build "server" side socket */
2663 s1
=socket(AF_INET
, SOCK_DGRAM
, 0);
2664 ok(s1
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
2666 /* Obtain the WSARecvMsg function */
2667 rc
= WSAIoctl(s1
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSARecvMsg_GUID
, sizeof(WSARecvMsg_GUID
),
2668 &pWSARecvMsg
, sizeof(pWSARecvMsg
), &dwBytes
, NULL
, NULL
);
2669 ok(!rc
, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
2671 /* Setup the server side socket */
2672 rc
=bind(s1
, (struct sockaddr
*)&s1addr
, sizeof(s1addr
));
2673 ok(rc
!= SOCKET_ERROR
, "bind() failed error: %d\n", WSAGetLastError());
2675 /* Build "client" side socket */
2676 addrlen
= sizeof(s2addr
);
2677 rc
= getsockname(s1
, (struct sockaddr
*) &s2addr
, &addrlen
);
2678 ok(!rc
, "failed to get address, error %u\n", WSAGetLastError());
2679 s2addr
.sin_addr
.s_addr
= addresses
[0]; /* Always target the local adapter address */
2680 s2
=socket(AF_INET
, SOCK_DGRAM
, 0);
2681 ok(s2
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
2683 /* Test an empty message header */
2684 rc
=pWSARecvMsg(s1
, NULL
, NULL
, NULL
, NULL
);
2685 err
=WSAGetLastError();
2686 ok(rc
== SOCKET_ERROR
&& err
== WSAEFAULT
, "WSARecvMsg() failed error: %d (ret = %d)\n", err
, rc
);
2688 /* Test that when no control data arrives, a 0-length NULL-valued control buffer should succeed */
2689 SetLastError(0xdeadbeef);
2690 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
2691 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
2692 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %ld\n", GetLastError());
2693 hdr
.Control
.buf
= NULL
;
2694 hdr
.Control
.len
= 0;
2695 rc
=pWSARecvMsg(s1
, &hdr
, &dwSize
, NULL
, NULL
);
2696 ok(rc
== 0, "WSARecvMsg() failed error: %d\n", WSAGetLastError());
2697 hdr
.Control
.buf
= pktbuf
;
2699 /* Now start IP_PKTINFO for future tests */
2700 rc
=setsockopt(s1
, IPPROTO_IP
, IP_PKTINFO
, (const char*)&yes
, sizeof(yes
));
2701 ok(rc
== 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
2704 * Send a packet from the client to the server and test for specifying
2705 * a short control header.
2707 SetLastError(0xdeadbeef);
2708 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
2709 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
2710 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %ld\n", GetLastError());
2711 hdr
.Control
.len
= 1;
2712 dwSize
= 0xdeadbeef;
2713 rc
= pWSARecvMsg(s1
, &hdr
, &dwSize
, NULL
, NULL
);
2714 ok(rc
== -1, "expected failure\n");
2715 ok(WSAGetLastError() == WSAEMSGSIZE
, "got error %u\n", WSAGetLastError());
2716 todo_wine
ok(dwSize
== sizeof(msg
), "got size %lu\n", dwSize
);
2717 ok(hdr
.dwFlags
== MSG_CTRUNC
, "got flags %#lx\n", hdr
.dwFlags
);
2718 hdr
.dwFlags
= 0; /* Reset flags */
2720 /* Perform another short control header test, this time with an overlapped receive */
2721 hdr
.Control
.len
= 1;
2722 ov
.Internal
= 0xdead1;
2723 ov
.InternalHigh
= 0xdead2;
2724 ov
.Offset
= 0xdead3;
2725 ov
.OffsetHigh
= 0xdead4;
2726 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
2727 err
=WSAGetLastError();
2728 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
2729 SetLastError(0xdeadbeef);
2730 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
2731 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
2732 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %ld\n", GetLastError());
2733 ok(!WaitForSingleObject(ov
.hEvent
, 100), "wait failed\n");
2734 ok((NTSTATUS
)ov
.Internal
== STATUS_BUFFER_OVERFLOW
, "got status %#lx\n", (NTSTATUS
)ov
.Internal
);
2735 ok(ov
.InternalHigh
== sizeof(msg
), "got size %Iu\n", ov
.InternalHigh
);
2736 ok(ov
.Offset
== 0xdead3, "got Offset %lu\n", ov
.Offset
);
2737 ok(ov
.OffsetHigh
== 0xdead4, "got OffsetHigh %lu\n", ov
.OffsetHigh
);
2738 dwFlags
= 0xdeadbeef;
2739 rc
= WSAGetOverlappedResult(s1
, &ov
, &dwSize
, FALSE
, &dwFlags
);
2740 ok(!rc
, "expected failure\n");
2741 ok(WSAGetLastError() == WSAEMSGSIZE
, "got error %u\n", WSAGetLastError());
2742 ok(dwSize
== sizeof(msg
), "got size %lu\n", dwSize
);
2743 todo_wine
ok(dwFlags
== 0xdeadbeef, "got flags %#lx\n", dwFlags
);
2744 ok(hdr
.dwFlags
== MSG_CTRUNC
,
2745 "WSARecvMsg() overlapped operation set unexpected flags %ld.\n", hdr
.dwFlags
);
2746 hdr
.dwFlags
= 0; /* Reset flags */
2748 /* And with an APC. */
2750 SetLastError(0xdeadbeef);
2751 rc
= sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
2752 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
2753 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %ld\n", GetLastError());
2754 hdr
.Control
.len
= 1;
2756 ov
.Internal
= 0xdead1;
2757 ov
.InternalHigh
= 0xdead2;
2758 ov
.Offset
= 0xdead3;
2759 ov
.OffsetHigh
= 0xdead4;
2760 dwSize
= 0xdeadbeef;
2761 rc
= pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, ip_pktinfo_apc
);
2762 ok(rc
== -1, "expected failure\n");
2763 todo_wine
ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
2765 rc
= SleepEx(1000, TRUE
);
2766 ok(rc
== WAIT_IO_COMPLETION
, "got %d\n", rc
);
2767 ok(got_ip_pktinfo_apc
== 1, "apc was called %u times\n", got_ip_pktinfo_apc
);
2768 ok(hdr
.dwFlags
== MSG_CTRUNC
, "got flags %#lx\n", hdr
.dwFlags
);
2769 got_ip_pktinfo_apc
= 0;
2771 hdr
.dwFlags
= 0; /* Reset flags */
2774 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
2775 * on the server end and check that the returned packet matches what was sent.
2777 hdr
.Control
.len
= sizeof(pktbuf
);
2778 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
2779 err
=WSAGetLastError();
2780 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
2781 ok(hdr
.Control
.len
== sizeof(pktbuf
),
2782 "WSARecvMsg() control length mismatch (%ld != sizeof pktbuf).\n", hdr
.Control
.len
);
2783 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
2784 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
2785 ok(!WaitForSingleObject(ov
.hEvent
, 100), "wait failed\n");
2787 WSAGetOverlappedResult(s1
, &ov
, &dwSize
, FALSE
, NULL
);
2788 ok(dwSize
== sizeof(msg
),
2789 "WSARecvMsg() buffer length does not match transmitted data!\n");
2790 ok(strncmp(iovec
[0].buf
, msg
, sizeof(msg
)) == 0,
2791 "WSARecvMsg() buffer does not match transmitted data!\n");
2792 ok(hdr
.Control
.len
== IP_PKTINFO_LEN
,
2793 "WSARecvMsg() control length mismatch (%ld).\n", hdr
.Control
.len
);
2795 /* Test for the expected IP_PKTINFO return information. */
2797 for (cmsg
= WSA_CMSG_FIRSTHDR(&hdr
); cmsg
!= NULL
; cmsg
= WSA_CMSG_NXTHDR(&hdr
, cmsg
))
2799 if (cmsg
->cmsg_level
== IPPROTO_IP
&& cmsg
->cmsg_type
== IP_PKTINFO
)
2801 struct in_pktinfo
*pi
= (struct in_pktinfo
*)WSA_CMSG_DATA(cmsg
);
2803 ok(pi
->ipi_addr
.s_addr
== s2addr
.sin_addr
.s_addr
, "destination ip mismatch!\n");
2807 ok(foundhdr
, "IP_PKTINFO header information was not returned!\n");
2813 CloseHandle(ov
.hEvent
);
2816 static void test_ipv4_cmsg(void)
2818 static const DWORD off
= 0;
2819 static const DWORD on
= 1;
2820 SOCKADDR_IN localhost
= {0};
2821 SOCKET client
, server
;
2822 char payload
[] = "HELLO";
2824 WSABUF payload_buf
= {sizeof(payload
), payload
};
2825 WSAMSG msg
= {NULL
, 0, &payload_buf
, 1, {sizeof(control
), control
}, 0};
2826 WSACMSGHDR
*header
= (WSACMSGHDR
*)control
;
2827 LPFN_WSARECVMSG pWSARecvMsg
;
2828 INT
*int_data
= (INT
*)WSA_CMSG_DATA(header
);
2829 IN_PKTINFO
*pkt_info
= (IN_PKTINFO
*)WSA_CMSG_DATA(header
);
2833 localhost
.sin_family
= AF_INET
;
2834 localhost
.sin_port
= htons(SERVERPORT
);
2835 inet_pton(AF_INET
, "127.0.0.1", &localhost
.sin_addr
);
2837 client
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
2838 ok(client
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
2839 server
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
2840 ok(server
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
2842 rc
= bind(server
, (SOCKADDR
*)&localhost
, sizeof(localhost
));
2843 ok(rc
!= SOCKET_ERROR
, "bind failed, error %u\n", WSAGetLastError());
2844 rc
= connect(client
, (SOCKADDR
*)&localhost
, sizeof(localhost
));
2845 ok(rc
!= SOCKET_ERROR
, "connect failed, error %u\n", WSAGetLastError());
2847 rc
= WSAIoctl(server
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSARecvMsg_GUID
, sizeof(WSARecvMsg_GUID
),
2848 &pWSARecvMsg
, sizeof(pWSARecvMsg
), &count
, NULL
, NULL
);
2849 ok(!rc
, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
2851 memset(control
, 0, sizeof(control
));
2852 msg
.Control
.len
= sizeof(control
);
2853 rc
= setsockopt(server
, IPPROTO_IP
, IP_RECVTTL
, (const char *)&on
, sizeof(on
));
2854 ok(!rc
, "failed to set IP_RECVTTL, error %u\n", WSAGetLastError());
2856 count
= sizeof(state
);
2857 rc
= getsockopt(server
, IPPROTO_IP
, IP_RECVTTL
, (char *)&state
, (INT
*)&count
);
2858 ok(!rc
, "failed to get IP_RECVTTL, error %u\n", WSAGetLastError());
2859 ok(state
== 1, "expected 1, got %lu\n", state
);
2860 rc
= send(client
, payload
, sizeof(payload
), 0);
2861 ok(rc
== sizeof(payload
), "send failed, error %u\n", WSAGetLastError());
2862 rc
= pWSARecvMsg(server
, &msg
, &count
, NULL
, NULL
);
2863 ok(!rc
, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2864 ok(count
== sizeof(payload
), "expected length %Iu, got %lu\n", sizeof(payload
), count
);
2865 ok(header
->cmsg_level
== IPPROTO_IP
, "expected IPPROTO_IP, got %i\n", header
->cmsg_level
);
2866 ok(header
->cmsg_type
== IP_TTL
|| broken(header
->cmsg_type
== IP_HOPLIMIT
) /* <= win10 v1607 */,
2867 "expected IP_TTL, got %i\n", header
->cmsg_type
);
2868 ok(header
->cmsg_len
== sizeof(*header
) + sizeof(INT
),
2869 "expected length %Iu, got %Iu\n", sizeof(*header
) + sizeof(INT
), header
->cmsg_len
);
2870 ok(*int_data
>= 32, "expected at least 32, got %i\n", *int_data
);
2871 setsockopt(server
, IPPROTO_IP
, IP_RECVTTL
, (const char *)&off
, sizeof(off
));
2872 ok(!rc
, "failed to clear IP_RECVTTL, error %u\n", WSAGetLastError());
2874 memset(control
, 0, sizeof(control
));
2875 msg
.Control
.len
= sizeof(control
);
2876 rc
= setsockopt(server
, IPPROTO_IP
, IP_PKTINFO
, (const char *)&on
, sizeof(on
));
2877 ok(!rc
, "failed to set IP_PKTINFO, error %u\n", WSAGetLastError());
2879 count
= sizeof(state
);
2880 rc
= getsockopt(server
, IPPROTO_IP
, IP_PKTINFO
, (char *)&state
, (INT
*)&count
);
2881 ok(!rc
, "failed to get IP_PKTINFO, error %u\n", WSAGetLastError());
2882 ok(state
== 1, "expected 1, got %lu\n", state
);
2883 rc
= send(client
, payload
, sizeof(payload
), 0);
2884 ok(rc
== sizeof(payload
), "send failed, error %u\n", WSAGetLastError());
2885 rc
= pWSARecvMsg(server
, &msg
, &count
, NULL
, NULL
);
2886 ok(!rc
, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2887 ok(count
== sizeof(payload
), "expected length %Iu, got %lu\n", sizeof(payload
), count
);
2888 ok(header
->cmsg_level
== IPPROTO_IP
, "expected IPPROTO_IP, got %i\n", header
->cmsg_level
);
2889 ok(header
->cmsg_type
== IP_PKTINFO
, "expected IP_PKTINFO, got %i\n", header
->cmsg_type
);
2890 ok(header
->cmsg_len
== sizeof(*header
) + sizeof(IN_PKTINFO
),
2891 "expected length %Iu, got %Iu\n", sizeof(*header
) + sizeof(IN_PKTINFO
), header
->cmsg_len
);
2892 ok(!memcmp(&pkt_info
->ipi_addr
, &localhost
.sin_addr
, sizeof(IN_ADDR
)), "expected 127.0.0.1\n");
2893 rc
= setsockopt(server
, IPPROTO_IP
, IP_PKTINFO
, (const char *)&off
, sizeof(off
));
2894 ok(!rc
, "failed to clear IP_PKTINFO, error %u\n", WSAGetLastError());
2896 memset(control
, 0, sizeof(control
));
2897 msg
.Control
.len
= sizeof(control
);
2898 rc
= setsockopt(server
, IPPROTO_IP
, IP_RECVTOS
, (const char *)&on
, sizeof(on
));
2899 ok(!rc
, "failed to set IP_RECVTOS, error %u\n", WSAGetLastError());
2901 count
= sizeof(state
);
2902 rc
= getsockopt(server
, IPPROTO_IP
, IP_RECVTOS
, (char *)&state
, (INT
*)&count
);
2903 ok(!rc
, "failed to get IP_RECVTOS, error %u\n", WSAGetLastError());
2904 ok(state
== 1, "expected 1, got %lu\n", state
);
2905 rc
= send(client
, payload
, sizeof(payload
), 0);
2906 ok(rc
== sizeof(payload
), "send failed, error %u\n", WSAGetLastError());
2907 rc
= pWSARecvMsg(server
, &msg
, &count
, NULL
, NULL
);
2908 ok(!rc
, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2909 ok(count
== sizeof(payload
), "expected length %Iu, got %lu\n", sizeof(payload
), count
);
2910 ok(header
->cmsg_level
== IPPROTO_IP
, "expected IPPROTO_IP, got %i\n", header
->cmsg_level
);
2911 ok(header
->cmsg_type
== IP_TOS
|| broken(header
->cmsg_type
== IP_TCLASS
) /* <= win10 v1607 */,
2912 "expected IP_TOS, got %i\n", header
->cmsg_type
);
2913 ok(header
->cmsg_len
== sizeof(*header
) + sizeof(INT
),
2914 "expected length %Iu, got %Iu\n", sizeof(*header
) + sizeof(INT
), header
->cmsg_len
);
2915 ok(*int_data
== 0, "expected 0, got %i\n", *int_data
);
2916 rc
= setsockopt(server
, IPPROTO_IP
, IP_RECVTOS
, (const char *)&off
, sizeof(off
));
2917 ok(!rc
, "failed to clear IP_RECVTOS, error %u\n", WSAGetLastError());
2919 closesocket(server
);
2920 closesocket(client
);
2923 static void test_ipv6_cmsg(void)
2925 static const DWORD off
= 0;
2926 static const DWORD on
= 1;
2927 SOCKADDR_IN6 localhost
= {0};
2928 SOCKET client
, server
;
2929 char payload
[] = "HELLO";
2931 WSABUF payload_buf
= {sizeof(payload
), payload
};
2932 WSAMSG msg
= {NULL
, 0, &payload_buf
, 1, {sizeof(control
), control
}, 0};
2933 WSACMSGHDR
*header
= (WSACMSGHDR
*)control
;
2934 LPFN_WSARECVMSG pWSARecvMsg
;
2935 INT
*int_data
= (INT
*)WSA_CMSG_DATA(header
);
2936 IN6_PKTINFO
*pkt_info
= (IN6_PKTINFO
*)WSA_CMSG_DATA(header
);
2940 localhost
.sin6_family
= AF_INET6
;
2941 localhost
.sin6_port
= htons(SERVERPORT
);
2942 inet_pton(AF_INET6
, "::1", &localhost
.sin6_addr
);
2944 client
= socket(AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
);
2945 ok(client
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
2946 server
= socket(AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
);
2947 ok(server
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
2949 rc
= bind(server
, (SOCKADDR
*)&localhost
, sizeof(localhost
));
2950 ok(rc
!= SOCKET_ERROR
|| WSAGetLastError() == WSAEADDRNOTAVAIL
, "bind failed, error %u\n", WSAGetLastError());
2951 if (WSAGetLastError() == WSAEADDRNOTAVAIL
)
2953 skip("IPv6 not supported, skipping test\n");
2956 rc
= connect(client
, (SOCKADDR
*)&localhost
, sizeof(localhost
));
2957 ok(rc
!= SOCKET_ERROR
, "connect failed, error %u\n", WSAGetLastError());
2959 rc
= WSAIoctl(server
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSARecvMsg_GUID
, sizeof(WSARecvMsg_GUID
),
2960 &pWSARecvMsg
, sizeof(pWSARecvMsg
), &count
, NULL
, NULL
);
2961 ok(!rc
, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
2963 memset(control
, 0, sizeof(control
));
2964 msg
.Control
.len
= sizeof(control
);
2965 rc
= setsockopt(server
, IPPROTO_IPV6
, IPV6_HOPLIMIT
, (const char *)&on
, sizeof(on
));
2966 ok(!rc
, "failed to set IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2968 count
= sizeof(state
);
2969 rc
= getsockopt(server
, IPPROTO_IPV6
, IPV6_HOPLIMIT
, (char *)&state
, (INT
*)&count
);
2970 ok(!rc
, "failed to get IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2971 ok(state
== 1, "expected 1, got %lu\n", state
);
2972 rc
= send(client
, payload
, sizeof(payload
), 0);
2973 ok(rc
== sizeof(payload
), "send failed, error %u\n", WSAGetLastError());
2974 rc
= pWSARecvMsg(server
, &msg
, &count
, NULL
, NULL
);
2975 ok(!rc
, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2976 ok(count
== sizeof(payload
), "expected length %Iu, got %lu\n", sizeof(payload
), count
);
2977 ok(header
->cmsg_level
== IPPROTO_IPV6
, "expected IPPROTO_IPV6, got %i\n", header
->cmsg_level
);
2978 ok(header
->cmsg_type
== IPV6_HOPLIMIT
, "expected IPV6_HOPLIMIT, got %i\n", header
->cmsg_type
);
2979 ok(header
->cmsg_len
== sizeof(*header
) + sizeof(INT
),
2980 "expected length %Iu, got %Iu\n", sizeof(*header
) + sizeof(INT
), header
->cmsg_len
);
2981 ok(*int_data
>= 32, "expected at least 32, got %i\n", *int_data
);
2982 setsockopt(server
, IPPROTO_IPV6
, IPV6_HOPLIMIT
, (const char *)&off
, sizeof(off
));
2983 ok(!rc
, "failed to clear IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2985 memset(control
, 0, sizeof(control
));
2986 msg
.Control
.len
= sizeof(control
);
2987 rc
= setsockopt(server
, IPPROTO_IPV6
, IPV6_PKTINFO
, (const char *)&on
, sizeof(on
));
2988 ok(!rc
, "failed to set IPV6_PKTINFO, error %u\n", WSAGetLastError());
2990 count
= sizeof(state
);
2991 rc
= getsockopt(server
, IPPROTO_IPV6
, IPV6_PKTINFO
, (char *)&state
, (INT
*)&count
);
2992 ok(!rc
, "failed to get IPV6_PKTINFO, error %u\n", WSAGetLastError());
2993 ok(state
== 1, "expected 1, got %lu\n", state
);
2994 rc
= send(client
, payload
, sizeof(payload
), 0);
2995 ok(rc
== sizeof(payload
), "send failed, error %u\n", WSAGetLastError());
2996 rc
= pWSARecvMsg(server
, &msg
, &count
, NULL
, NULL
);
2997 ok(!rc
, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2998 ok(count
== sizeof(payload
), "expected length %Iu, got %lu\n", sizeof(payload
), count
);
2999 ok(header
->cmsg_level
== IPPROTO_IPV6
, "expected IPPROTO_IPV6, got %i\n", header
->cmsg_level
);
3000 ok(header
->cmsg_type
== IPV6_PKTINFO
, "expected IPV6_PKTINFO, got %i\n", header
->cmsg_type
);
3001 ok(header
->cmsg_len
== sizeof(*header
) + sizeof(IN6_PKTINFO
),
3002 "expected length %Iu, got %Iu\n", sizeof(*header
) + sizeof(IN6_PKTINFO
), header
->cmsg_len
);
3003 ok(!memcmp(&pkt_info
->ipi6_addr
, &localhost
.sin6_addr
, sizeof(IN6_ADDR
)), "expected ::1\n");
3004 rc
= setsockopt(server
, IPPROTO_IPV6
, IPV6_PKTINFO
, (const char *)&off
, sizeof(off
));
3005 ok(!rc
, "failed to clear IPV6_PKTINFO, error %u\n", WSAGetLastError());
3007 memset(control
, 0, sizeof(control
));
3008 msg
.Control
.len
= sizeof(control
);
3009 rc
= setsockopt(server
, IPPROTO_IPV6
, IPV6_RECVTCLASS
, (const char *)&on
, sizeof(on
));
3010 ok(!rc
, "failed to set IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
3012 count
= sizeof(state
);
3013 rc
= getsockopt(server
, IPPROTO_IPV6
, IPV6_RECVTCLASS
, (char *)&state
, (INT
*)&count
);
3014 ok(!rc
, "failed to get IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
3015 ok(state
== 1, "expected 1, got %lu\n", state
);
3016 rc
= send(client
, payload
, sizeof(payload
), 0);
3017 ok(rc
== sizeof(payload
), "send failed, error %u\n", WSAGetLastError());
3018 rc
= pWSARecvMsg(server
, &msg
, &count
, NULL
, NULL
);
3019 ok(!rc
, "WSARecvMsg failed, error %u\n", WSAGetLastError());
3020 ok(count
== sizeof(payload
), "expected length %Iu, got %lu\n", sizeof(payload
), count
);
3021 ok(header
->cmsg_level
== IPPROTO_IPV6
, "expected IPPROTO_IPV6, got %i\n", header
->cmsg_level
);
3022 ok(header
->cmsg_type
== IPV6_TCLASS
, "expected IPV6_TCLASS, got %i\n", header
->cmsg_type
);
3023 ok(header
->cmsg_len
== sizeof(*header
) + sizeof(INT
),
3024 "expected length %Iu, got %Iu\n", sizeof(*header
) + sizeof(INT
), header
->cmsg_len
);
3025 ok(*int_data
== 0, "expected 0, got %i\n", *int_data
);
3026 rc
= setsockopt(server
, IPPROTO_IPV6
, IPV6_RECVTCLASS
, (const char *)&off
, sizeof(off
));
3027 ok(!rc
, "failed to clear IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
3030 closesocket(server
);
3031 closesocket(client
);
3034 /************* Array containing the tests to run **********/
3036 #define STD_STREAM_SOCKET \
3042 static test_setup tests
[] =
3044 /* Test 0: synchronous client and server */
3065 /* Test 1: event-driven client, synchronous server */
3082 WSA_FLAG_OVERLAPPED
,
3086 /* Test 2: synchronous client, non-blocking server via select() */
3107 /* Test 3: OOB client, OOB server */
3128 /* Test 4: synchronous mixed client and server */
3142 simple_mixed_client
,
3151 struct send_udp_thread_param
3157 static DWORD WINAPI
send_udp_thread( void *param
)
3159 struct send_udp_thread_param
*p
= param
;
3160 static const TIMEVAL timeout_zero
= {0};
3161 static char buf
[256];
3166 WaitForSingleObject( p
->start_event
, INFINITE
);
3167 for (i
= 0; i
< 256; ++i
)
3170 FD_SET(p
->sock
, &writefds
);
3171 ret
= select( 1, NULL
, &writefds
, NULL
, &timeout_zero
);
3172 ok( ret
== 1, "got %d, i %u.\n", ret
, i
);
3173 ret
= send( p
->sock
, buf
, sizeof(buf
), 0 );
3174 ok( ret
== sizeof(buf
), "got %d, error %u, i %u.\n", ret
, WSAGetLastError(), i
);
3180 static void test_UDP(void)
3182 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
3183 possible that this test fails due to dropped packets. */
3185 /* peer 0 receives data from all other peers */
3186 static const TIMEVAL timeout_zero
= {0};
3187 struct sock_info peer
[NUM_UDP_PEERS
];
3188 char buf
[16], sockaddr_buf
[1024];
3189 int ss
, i
, n_recv
, n_sent
, ret
;
3190 struct sockaddr_in addr
;
3192 struct send_udp_thread_param udp_thread_param
;
3197 memset (buf
,0,sizeof(buf
));
3198 for ( i
= NUM_UDP_PEERS
- 1; i
>= 0; i
-- ) {
3199 ok ( ( peer
[i
].s
= socket ( AF_INET
, SOCK_DGRAM
, 0 ) ) != INVALID_SOCKET
, "UDP: socket failed\n" );
3201 peer
[i
].addr
.sin_family
= AF_INET
;
3202 peer
[i
].addr
.sin_addr
.s_addr
= inet_addr ( SERVERIP
);
3205 peer
[i
].addr
.sin_port
= htons ( SERVERPORT
);
3207 peer
[i
].addr
.sin_port
= htons ( 0 );
3210 do_bind ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, sizeof( peer
[i
].addr
) );
3212 /* test getsockname() to get peer's port */
3213 ss
= sizeof ( peer
[i
].addr
);
3214 ok ( getsockname ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, &ss
) != SOCKET_ERROR
, "UDP: could not getsockname()\n" );
3215 ok ( peer
[i
].addr
.sin_port
!= htons ( 0 ), "UDP: bind() did not associate port\n" );
3218 /* Test that specifying a too small fromlen for recvfrom() shouldn't write unnecessary data */
3219 n_sent
= sendto ( peer
[1].s
, buf
, sizeof(buf
), 0, (struct sockaddr
*)&peer
[0].addr
, sizeof(peer
[0].addr
) );
3220 ok ( n_sent
== sizeof(buf
), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent
);
3222 sockaddr_buf
[0] = 'A';
3224 n_recv
= recvfrom ( peer
[0].s
, buf
, sizeof(buf
), 0, (struct sockaddr
*)sockaddr_buf
, &ss
);
3226 ok ( n_recv
== SOCKET_ERROR
, "UDP: recvfrom() succeeded\n" );
3227 ok ( sockaddr_buf
[0] == 'A', "UDP: marker got overwritten\n" );
3228 if ( n_recv
== SOCKET_ERROR
)
3230 ss
= sizeof ( peer
[0].addr
);
3231 n_recv
= recvfrom ( peer
[0].s
, buf
, sizeof(buf
), 0, (struct sockaddr
*)sockaddr_buf
, &ss
);
3232 ok ( n_recv
== sizeof(buf
), "UDP: recvfrom() failed\n" );
3235 /* Test that specifying a large fromlen for recvfrom() shouldn't write unnecessary data besides the socket address */
3236 n_sent
= sendto ( peer
[1].s
, buf
, sizeof(buf
), 0, (struct sockaddr
*)&peer
[0].addr
, sizeof(peer
[0].addr
) );
3237 ok ( n_sent
== sizeof(buf
), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent
);
3239 sockaddr_buf
[1023] = 'B';
3240 ss
= sizeof(sockaddr_buf
);
3241 n_recv
= recvfrom ( peer
[0].s
, buf
, sizeof(buf
), 0, (struct sockaddr
*)sockaddr_buf
, &ss
);
3242 ok ( n_recv
== sizeof(buf
), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv
);
3243 ok ( sockaddr_buf
[1023] == 'B', "UDP: marker got overwritten\n" );
3245 /* test getsockname() */
3246 ok ( peer
[0].addr
.sin_port
== htons ( SERVERPORT
), "UDP: getsockname returned incorrect peer port\n" );
3248 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
3249 /* send client's port */
3250 memcpy( buf
, &peer
[i
].addr
.sin_port
, sizeof(peer
[i
].addr
.sin_port
) );
3251 n_sent
= sendto ( peer
[i
].s
, buf
, sizeof(buf
), 0, (struct sockaddr
*) &peer
[0].addr
, sizeof(peer
[0].addr
) );
3252 ok ( n_sent
== sizeof(buf
), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent
);
3255 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
3256 n_recv
= recvfrom ( peer
[0].s
, buf
, sizeof(buf
), 0,(struct sockaddr
*) &peer
[0].peer
, &ss
);
3257 ok ( n_recv
== sizeof(buf
), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv
);
3258 ok ( memcmp ( &peer
[0].peer
.sin_port
, buf
, sizeof(peer
[0].addr
.sin_port
) ) == 0, "UDP: port numbers do not match\n" );
3261 sock
= socket( AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
3262 ok( sock
!= INVALID_SOCKET
, "got error %u.\n", WSAGetLastError() );
3264 memset( &addr
, 0, sizeof(addr
) );
3265 addr
.sin_family
= AF_INET
;
3266 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3267 addr
.sin_port
= htons(255);
3269 ret
= connect( sock
, (struct sockaddr
*)&addr
, sizeof(addr
) );
3270 ok( !ret
, "got error %u.\n", WSAGetLastError() );
3272 /* Send to UDP socket succeeds even if the packets are not received and the network is replying with
3273 * "destination port unreachable" ICMP messages. */
3274 for (i
= 0; i
< 10; ++i
)
3276 ret
= send( sock
, buf
, sizeof(buf
), 0 );
3277 ok( ret
== sizeof(buf
), "got %d, error %u.\n", ret
, WSAGetLastError() );
3280 /* Test sending packets in parallel (mostly a regression test for Wine async handling race conditions). */
3281 set_blocking( sock
, FALSE
);
3283 udp_thread_param
.sock
= sock
;
3284 udp_thread_param
.start_event
= CreateEventW( NULL
, FALSE
, FALSE
, NULL
);
3285 thread
= CreateThread( NULL
, 0, send_udp_thread
, &udp_thread_param
, 0, NULL
);
3286 SetEvent( udp_thread_param
.start_event
);
3287 for (i
= 0; i
< 256; ++i
)
3289 ret
= send( sock
, buf
, sizeof(buf
), 0 );
3290 ok( ret
== sizeof(buf
), "got %d, error %u, i %u.\n", ret
, WSAGetLastError(), i
);
3292 FD_SET(sock
, &writefds
);
3293 ret
= select( 1, NULL
, &writefds
, NULL
, &timeout_zero
);
3294 ok( ret
== 1, "got %d, i %u.\n", ret
, i
);
3296 WaitForSingleObject( thread
, INFINITE
);
3297 CloseHandle( thread
);
3298 CloseHandle( udp_thread_param
.start_event
);
3303 static void test_WSASocket(void)
3305 SOCKET sock
= INVALID_SOCKET
;
3306 WSAPROTOCOL_INFOA
*pi
;
3307 int wsaproviders
[] = {IPPROTO_TCP
, IPPROTO_IP
};
3308 int autoprotocols
[] = {IPPROTO_TCP
, IPPROTO_UDP
};
3309 int items
, err
, size
, socktype
, i
, j
;
3314 int family
, type
, protocol
;
3316 int ret_family
, ret_type
, ret_protocol
;
3322 {0xdead, SOCK_STREAM
, IPPROTO_TCP
, WSAEAFNOSUPPORT
},
3323 {-1, SOCK_STREAM
, IPPROTO_TCP
, WSAEAFNOSUPPORT
},
3324 {AF_INET
, 0xdead, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
3325 {AF_INET
, -1, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
3326 {AF_INET
, SOCK_STREAM
, 0xdead, WSAEPROTONOSUPPORT
},
3327 {AF_INET
, SOCK_STREAM
, -1, WSAEPROTONOSUPPORT
},
3328 {0xdead, 0xdead, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
3329 {0xdead, SOCK_STREAM
, 0xdead, WSAEAFNOSUPPORT
},
3330 {AF_INET
, 0xdead, 0xdead, WSAESOCKTNOSUPPORT
},
3331 {0xdead, SOCK_STREAM
, IPPROTO_UDP
, WSAEAFNOSUPPORT
},
3334 {AF_INET
, SOCK_STREAM
, 0, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
3335 {AF_INET
, SOCK_DGRAM
, 0, 0, AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
3336 {AF_INET
, 0xdead, 0, WSAESOCKTNOSUPPORT
},
3337 {AF_INET
, 0, IPPROTO_TCP
, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
3338 {AF_INET
, 0, IPPROTO_UDP
, 0, AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
3339 {AF_INET
, 0, 0xdead, WSAEPROTONOSUPPORT
},
3340 {AF_INET
, 0, 0, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
3341 {AF_INET
, SOCK_STREAM
, IPPROTO_UDP
, WSAEPROTONOSUPPORT
},
3342 {AF_INET
, SOCK_DGRAM
, IPPROTO_TCP
, WSAEPROTONOSUPPORT
},
3345 {AF_UNSPEC
, SOCK_STREAM
, IPPROTO_TCP
, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, AF_INET6
/* win11 */},
3346 {AF_UNSPEC
, SOCK_STREAM
, 0xdead, WSAEPROTONOSUPPORT
},
3347 {AF_UNSPEC
, 0xdead, IPPROTO_UDP
, WSAESOCKTNOSUPPORT
},
3348 {AF_UNSPEC
, SOCK_STREAM
, 0, WSAEINVAL
},
3349 {AF_UNSPEC
, SOCK_DGRAM
, 0, WSAEINVAL
},
3350 {AF_UNSPEC
, 0xdead, 0, WSAEINVAL
},
3351 {AF_UNSPEC
, 0, IPPROTO_TCP
, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, AF_INET6
/* win11 */},
3352 {AF_UNSPEC
, 0, IPPROTO_UDP
, 0, AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, AF_INET6
/* win11 */},
3353 {AF_UNSPEC
, 0, 0xdead, WSAEPROTONOSUPPORT
},
3354 {AF_UNSPEC
, 0, 0, WSAEINVAL
},
3357 for (i
= 0; i
< ARRAY_SIZE(tests
); ++i
)
3359 SetLastError( 0xdeadbeef );
3360 sock
= WSASocketA( tests
[i
].family
, tests
[i
].type
, tests
[i
].protocol
, NULL
, 0, 0 );
3361 todo_wine_if (i
== 7)
3362 ok(WSAGetLastError() == tests
[i
].error
, "Test %u: got wrong error %u\n", i
, WSAGetLastError());
3365 ok(sock
== INVALID_SOCKET
, "Test %u: expected failure\n", i
);
3369 WSAPROTOCOL_INFOA info
;
3371 ok(sock
!= INVALID_SOCKET
, "Text %u: expected success\n", i
);
3373 size
= sizeof(info
);
3374 err
= getsockopt( sock
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *)&info
, &size
);
3375 ok(!err
, "Test %u: getsockopt failed, error %u\n", i
, WSAGetLastError());
3376 ok(info
.iAddressFamily
== tests
[i
].ret_family
||
3377 (tests
[i
].ret_family_alt
&& info
.iAddressFamily
== tests
[i
].ret_family_alt
),
3378 "Test %u: got wrong family %d\n", i
, info
.iAddressFamily
);
3379 ok(info
.iSocketType
== tests
[i
].ret_type
, "Test %u: got wrong type %d\n", i
, info
.iSocketType
);
3380 ok(info
.iProtocol
== tests
[i
].ret_protocol
, "Test %u: got wrong protocol %d\n", i
, info
.iProtocol
);
3382 closesocket( sock
);
3386 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
3387 * to avoid a crash on win98.
3390 items
= WSAEnumProtocolsA(wsaproviders
, NULL
, &pi_size
);
3391 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
3393 err
= WSAGetLastError();
3394 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
3397 pi
= malloc(pi_size
);
3398 ok(pi
!= NULL
, "Failed to allocate memory\n");
3400 items
= WSAEnumProtocolsA(wsaproviders
, pi
, &pi_size
);
3401 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
3405 skip("No protocols enumerated.\n");
3410 sock
= WSASocketA(FROM_PROTOCOL_INFO
, FROM_PROTOCOL_INFO
,
3411 FROM_PROTOCOL_INFO
, &pi
[0], 0, 0);
3412 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
3416 /* find what parameters are used first: plain parameters or protocol info struct */
3417 pi
[0].iProtocol
= -1;
3418 pi
[0].iSocketType
= -1;
3419 pi
[0].iAddressFamily
= -1;
3420 ok(WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0) == INVALID_SOCKET
,
3421 "WSASocketA should have failed\n");
3422 err
= WSAGetLastError();
3423 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
3425 pi
[0].iProtocol
= 0;
3426 pi
[0].iSocketType
= 0;
3427 pi
[0].iAddressFamily
= 0;
3428 sock
= WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0);
3429 if(sock
!= INVALID_SOCKET
)
3431 win_skip("must work only in OS <= 2003\n");
3436 err
= WSAGetLastError();
3437 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
3440 pi
[0].iProtocol
= IPPROTO_UDP
;
3441 pi
[0].iSocketType
= SOCK_DGRAM
;
3442 pi
[0].iAddressFamily
= AF_INET
;
3443 sock
= WSASocketA(0, 0, 0, &pi
[0], 0, 0);
3444 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
3447 size
= sizeof(socktype
);
3449 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
3450 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
3451 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
3452 SOCK_DGRAM
, socktype
);
3454 socktype
= SOCK_STREAM
;
3455 WSASetLastError(0xdeadbeef);
3456 err
= setsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *)&socktype
, sizeof(socktype
));
3457 ok(err
== -1, "expected failure\n");
3458 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
3460 socktype
= SOCK_DGRAM
;
3461 WSASetLastError(0xdeadbeef);
3462 err
= setsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *)&socktype
, sizeof(socktype
));
3463 ok(err
== -1, "expected failure\n");
3464 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
3468 sock
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, &pi
[0], 0, 0);
3469 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
3472 size
= sizeof(socktype
);
3474 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
3475 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
3476 ok(socktype
== SOCK_STREAM
, "Wrong socket type, expected %d received %d\n",
3477 SOCK_STREAM
, socktype
);
3479 socktype
= SOCK_STREAM
;
3480 WSASetLastError(0xdeadbeef);
3481 err
= setsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *)&socktype
, sizeof(socktype
));
3482 ok(err
== -1, "expected failure\n");
3483 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
3485 socktype
= SOCK_DGRAM
;
3486 WSASetLastError(0xdeadbeef);
3487 err
= setsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *)&socktype
, sizeof(socktype
));
3488 ok(err
== -1, "expected failure\n");
3489 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
3496 items
= WSAEnumProtocolsA(NULL
, NULL
, &pi_size
);
3497 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
3499 err
= WSAGetLastError();
3500 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
3503 pi
= malloc(pi_size
);
3504 ok(pi
!= NULL
, "Failed to allocate memory\n");
3506 items
= WSAEnumProtocolsA(NULL
, pi
, &pi_size
);
3507 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
3510 /* when no protocol and socket type are specified the first entry
3511 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
3513 sock
= WSASocketA(AF_INET
, 0, 0, NULL
, 0, 0);
3514 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
3517 size
= sizeof(socktype
);
3519 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
3520 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
3521 for(i
= 0; i
< items
; i
++)
3523 if(pi
[i
].dwProviderFlags
& PFL_MATCHES_PROTOCOL_ZERO
)
3525 ok(socktype
== pi
[i
].iSocketType
, "Wrong socket type, expected %d received %d\n",
3526 pi
[i
].iSocketType
, socktype
);
3530 ok(i
!= items
, "Creating a socket without protocol and socket type didn't work\n");
3533 /* when no socket type is specified the first entry from WSAEnumProtocols
3534 * that matches the protocol is returned */
3535 for (i
= 0; i
< ARRAY_SIZE(autoprotocols
); i
++)
3537 sock
= WSASocketA(0, 0, autoprotocols
[i
], NULL
, 0, 0);
3538 ok(sock
!= INVALID_SOCKET
, "Failed to create socket for protocol %d, received %d\n",
3539 autoprotocols
[i
], WSAGetLastError());
3541 size
= sizeof(socktype
);
3543 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
3544 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
3546 for (err
= 1, j
= 0; j
< items
; j
++)
3548 if (pi
[j
].iProtocol
== autoprotocols
[i
])
3550 ok(pi
[j
].iSocketType
== socktype
, "expected %d, got %d\n", socktype
, pi
[j
].iSocketType
);
3555 ok(!err
, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols
[i
]);
3562 SetLastError(0xdeadbeef);
3563 /* starting on vista the socket function returns error during the socket
3564 creation and no longer in the socket operations (sendto, readfrom) */
3565 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_ICMP
, NULL
, 0, 0);
3566 if (sock
== INVALID_SOCKET
)
3568 err
= WSAGetLastError();
3569 ok(err
== WSAEACCES
, "Expected 10013, received %d\n", err
);
3570 skip("SOCK_RAW is not supported\n");
3574 WSAPROTOCOL_INFOW info
;
3576 size
= sizeof(socktype
);
3578 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
3579 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
3580 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
3581 SOCK_RAW
, socktype
);
3583 size
= sizeof(info
);
3584 err
= getsockopt(sock
, SOL_SOCKET
, SO_PROTOCOL_INFOW
, (char *) &info
, &size
);
3585 ok(!err
,"got error %d\n", WSAGetLastError());
3586 /* Protocol name in info.szProtocol is not entirely consistent across Windows versions and
3587 * locales, so not testing it. */
3588 ok(info
.iAddressFamily
== AF_INET
, "got iAddressFamily %d.\n", info
.iAddressFamily
);
3589 ok(info
.iSocketType
== SOCK_RAW
, "got iSocketType %d.\n", info
.iSocketType
);
3590 ok(info
.iMaxSockAddr
== 0x10, "got iMaxSockAddr %d.\n", info
.iMaxSockAddr
);
3591 ok(info
.iMinSockAddr
== 0x10, "got iMinSockAddr %d.\n", info
.iMinSockAddr
);
3592 todo_wine
ok(!info
.iProtocol
, "got iProtocol %d.\n", info
.iProtocol
);
3593 ok(info
.iProtocolMaxOffset
== 255, "got iProtocol %d.\n", info
.iProtocolMaxOffset
);
3594 ok(info
.dwProviderFlags
== (PFL_MATCHES_PROTOCOL_ZERO
| PFL_HIDDEN
), "got dwProviderFlags %#lx.\n",
3595 info
.dwProviderFlags
);
3596 ok(info
.dwServiceFlags1
== (XP1_IFS_HANDLES
| XP1_SUPPORT_BROADCAST
| XP1_SUPPORT_MULTIPOINT
3597 | XP1_MESSAGE_ORIENTED
| XP1_CONNECTIONLESS
), "got dwServiceFlags1 %#lx.\n",
3598 info
.dwServiceFlags1
);
3602 sock
= WSASocketA(0, 0, IPPROTO_RAW
, NULL
, 0, 0);
3603 if (sock
!= INVALID_SOCKET
)
3605 size
= sizeof(socktype
);
3607 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
3608 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
3609 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
3610 SOCK_RAW
, socktype
);
3613 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_TCP
, NULL
, 0, 0);
3614 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
3616 size
= sizeof(socktype
);
3618 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
3619 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
3620 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
3621 SOCK_RAW
, socktype
);
3624 else if (WSAGetLastError() == WSAEACCES
)
3625 skip("SOCK_RAW is not available\n");
3627 ok(0, "Failed to create socket: %d\n", WSAGetLastError());
3631 /* IPX socket tests */
3633 SetLastError(0xdeadbeef);
3634 sock
= WSASocketA(AF_IPX
, SOCK_DGRAM
, NSPROTO_IPX
, NULL
, 0, 0);
3635 if (sock
== INVALID_SOCKET
)
3637 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "got error %u\n", WSAGetLastError());
3638 skip("IPX is not supported\n");
3642 WSAPROTOCOL_INFOA info
;
3645 sock
= WSASocketA(0, 0, NSPROTO_IPX
, NULL
, 0, 0);
3646 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
3649 size
= sizeof(socktype
);
3651 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
3652 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
3653 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
3654 SOCK_DGRAM
, socktype
);
3656 /* check socket family, type and protocol */
3657 size
= sizeof(WSAPROTOCOL_INFOA
);
3658 err
= getsockopt(sock
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &info
, &size
);
3659 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
3660 ok(info
.iProtocol
== NSPROTO_IPX
, "expected protocol %d, received %d\n",
3661 NSPROTO_IPX
, info
.iProtocol
);
3662 ok(info
.iAddressFamily
== AF_IPX
, "expected family %d, received %d\n",
3663 AF_IPX
, info
.iProtocol
);
3664 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
3665 SOCK_DGRAM
, info
.iSocketType
);
3668 /* SOCK_STREAM does not support NSPROTO_IPX */
3669 SetLastError(0xdeadbeef);
3670 ok(WSASocketA(AF_IPX
, SOCK_STREAM
, NSPROTO_IPX
, NULL
, 0, 0) == INVALID_SOCKET
,
3671 "WSASocketA should have failed\n");
3672 err
= WSAGetLastError();
3673 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
3675 /* test extended IPX support - that is adding any number between 0 and 255
3676 * to the IPX protocol value will make it be used as IPX packet type */
3677 for(i
= 0;i
<= 255;i
+= 17)
3679 SetLastError(0xdeadbeef);
3680 sock
= WSASocketA(0, 0, NSPROTO_IPX
+ i
, NULL
, 0, 0);
3681 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
3686 err
= getsockopt(sock
, NSPROTO_IPX
, IPX_PTYPE
, (char *) &socktype
, &size
);
3687 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
3688 ok(socktype
== i
, "Wrong IPX packet type, expected %d received %d\n",
3696 static void test_WSADuplicateSocket(void)
3698 SOCKET source
, dupsock
;
3699 WSAPROTOCOL_INFOA info
;
3701 struct sockaddr_in addr
;
3702 int socktype
, size
, addrsize
, ret
;
3703 char teststr
[] = "TEST", buffer
[16];
3705 source
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
3706 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
3708 /* test invalid parameters */
3709 SetLastError(0xdeadbeef);
3710 ok(WSADuplicateSocketA(0, 0, NULL
), "WSADuplicateSocketA should have failed\n");
3711 err
= WSAGetLastError();
3712 ok(err
== WSAENOTSOCK
, "expected 10038, received %ld\n", err
);
3714 SetLastError(0xdeadbeef);
3715 ok(WSADuplicateSocketA(source
, 0, NULL
),
3716 "WSADuplicateSocketA should have failed\n");
3717 err
= WSAGetLastError();
3718 ok(err
== WSAEINVAL
, "expected 10022, received %ld\n", err
);
3720 SetLastError(0xdeadbeef);
3721 ok(WSADuplicateSocketA(source
, ~0, &info
),
3722 "WSADuplicateSocketA should have failed\n");
3723 err
= WSAGetLastError();
3724 ok(err
== WSAEINVAL
, "expected 10022, received %ld\n", err
);
3726 SetLastError(0xdeadbeef);
3727 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info
),
3728 "WSADuplicateSocketA should have failed\n");
3729 err
= WSAGetLastError();
3730 ok(err
== WSAENOTSOCK
, "expected 10038, received %ld\n", err
);
3732 SetLastError(0xdeadbeef);
3733 ok(WSADuplicateSocketA(source
, GetCurrentProcessId(), NULL
),
3734 "WSADuplicateSocketA should have failed\n");
3735 err
= WSAGetLastError();
3736 ok(err
== WSAEFAULT
, "expected 10014, received %ld\n", err
);
3738 /* test returned structure */
3739 memset(&info
, 0, sizeof(info
));
3740 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
3741 "WSADuplicateSocketA should have worked\n");
3743 ok(info
.iProtocol
== IPPROTO_TCP
, "expected protocol %d, received %d\n",
3744 IPPROTO_TCP
, info
.iProtocol
);
3745 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
3746 AF_INET
, info
.iProtocol
);
3747 ok(info
.iSocketType
== SOCK_STREAM
, "expected type %d, received %d\n",
3748 SOCK_STREAM
, info
.iSocketType
);
3750 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
3751 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
3753 closesocket(dupsock
);
3754 closesocket(source
);
3756 /* create a socket, bind it, duplicate it then send data on source and
3757 * receive in the duplicated socket */
3758 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
3759 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
3761 memset(&info
, 0, sizeof(info
));
3762 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
3763 "WSADuplicateSocketA should have worked\n");
3765 ok(info
.iProtocol
== IPPROTO_UDP
, "expected protocol %d, received %d\n",
3766 IPPROTO_UDP
, info
.iProtocol
);
3767 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
3768 AF_INET
, info
.iProtocol
);
3769 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
3770 SOCK_DGRAM
, info
.iSocketType
);
3772 memset(&addr
, 0, sizeof(addr
));
3773 addr
.sin_family
= AF_INET
;
3774 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3775 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
3776 "bind should have worked\n");
3778 /* read address to find out the port number to be used in sendto */
3779 memset(&addr
, 0, sizeof(addr
));
3780 addrsize
= sizeof(addr
);
3781 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
3782 "getsockname should have worked\n");
3783 ok(addr
.sin_port
, "socket port should be != 0\n");
3785 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
3786 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
3789 ret
= getsockopt(dupsock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
3790 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
3791 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
3792 SOCK_DGRAM
, socktype
);
3794 set_blocking(source
, TRUE
);
3796 /* send data on source socket */
3797 addrsize
= sizeof(addr
);
3798 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
3799 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
3801 /* receive on duplicated socket */
3802 addrsize
= sizeof(addr
);
3803 memset(buffer
, 0, sizeof(buffer
));
3804 size
= recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
);
3805 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
3806 buffer
[sizeof(teststr
) - 1] = 0;
3807 ok(!strcmp(buffer
, teststr
), "expected '%s', received '%s'\n", teststr
, buffer
);
3809 closesocket(dupsock
);
3810 closesocket(source
);
3812 /* show that the source socket need to be bound before the duplicated
3813 * socket is created */
3814 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
3815 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
3817 memset(&info
, 0, sizeof(info
));
3818 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
3819 "WSADuplicateSocketA should have worked\n");
3821 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
3822 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
3824 memset(&addr
, 0, sizeof(addr
));
3825 addr
.sin_family
= AF_INET
;
3826 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3827 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
3828 "bind should have worked\n");
3830 /* read address to find out the port number to be used in sendto */
3831 memset(&addr
, 0, sizeof(addr
));
3832 addrsize
= sizeof(addr
);
3833 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
3834 "getsockname should have worked\n");
3835 ok(addr
.sin_port
, "socket port should be != 0\n");
3837 set_blocking(source
, TRUE
);
3839 addrsize
= sizeof(addr
);
3840 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
3841 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
3843 SetLastError(0xdeadbeef);
3844 addrsize
= sizeof(addr
);
3845 memset(buffer
, 0, sizeof(buffer
));
3847 ok(recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
) == -1,
3848 "recvfrom should have failed\n");
3849 err
= WSAGetLastError();
3850 ok(err
== WSAEINVAL
, "expected 10022, received %ld\n", err
);
3853 closesocket(dupsock
);
3854 closesocket(source
);
3857 static void test_WSAConnectByName(void)
3860 SOCKADDR_IN local_addr
= {0}, remote_addr
= {0},
3861 sock_addr
= {0}, peer_addr
= {0};
3862 DWORD local_len
, remote_len
, conn_ctx
;
3863 int ret
, err
, sock_len
, peer_len
;
3864 WSAOVERLAPPED overlap
;
3865 struct addrinfo
*first_addrinfo
, first_hints
;
3869 /* First call of getaddrinfo fails on w8adm */
3870 first_addrinfo
= NULL
;
3871 memset(&first_hints
, 0, sizeof(struct addrinfo
));
3872 first_hints
.ai_socktype
= SOCK_STREAM
;
3873 first_hints
.ai_family
= AF_INET
;
3874 first_hints
.ai_protocol
= IPPROTO_TCP
;
3875 getaddrinfo("winehq.org", "http", &first_hints
, &first_addrinfo
);
3877 freeaddrinfo(first_addrinfo
);
3878 SetLastError(0xdeadbeef);
3880 /* Fill all fields */
3881 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3882 local_len
= remote_len
= sizeof(SOCKADDR_IN
);
3883 ret
= WSAConnectByNameA(s
, "winehq.org", "http", &local_len
, (struct sockaddr
*)&local_addr
,
3884 &remote_len
, (struct sockaddr
*)&remote_addr
, NULL
, NULL
);
3885 ok(ret
, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3886 setsockopt(s
, SOL_SOCKET
, SO_UPDATE_CONNECT_CONTEXT
, (char *)&conn_ctx
, sizeof(DWORD
));
3887 sock_len
= peer_len
= sizeof(SOCKADDR_IN
);
3888 ret
= getsockname(s
, (struct sockaddr
*)&sock_addr
, &sock_len
);
3889 ok(!ret
, "getsockname should have succeeded, error %u\n", WSAGetLastError());
3890 ret
= getpeername(s
, (struct sockaddr
*)&peer_addr
, &peer_len
);
3891 ok(!ret
, "getpeername should have succeeded, error %u\n", WSAGetLastError());
3892 ok(sock_len
== sizeof(SOCKADDR_IN
), "got sockname size of %d\n", sock_len
);
3893 ok(peer_len
== sizeof(SOCKADDR_IN
), "got peername size of %d\n", peer_len
);
3894 ok(local_len
== sizeof(SOCKADDR_IN
), "got local size of %lu\n", local_len
);
3895 ok(remote_len
== sizeof(SOCKADDR_IN
), "got remote size of %lu\n", remote_len
);
3896 ok(!local_addr
.sin_port
, "local_addr has non-zero sin_port: %hu.\n", local_addr
.sin_port
);
3897 ok(!memcmp(&sock_addr
.sin_addr
, &local_addr
.sin_addr
, sizeof(struct in_addr
)),
3898 "local_addr did not receive data.\n");
3899 ok(!memcmp(&peer_addr
, &remote_addr
, sizeof(SOCKADDR_IN
)), "remote_addr did not receive data.\n");
3902 /* Passing NULL length but a pointer to a sockaddr */
3903 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3904 local_len
= remote_len
= sizeof(SOCKADDR_IN
);
3905 memset(&local_addr
, 0, sizeof(SOCKADDR_IN
));
3906 memset(&remote_addr
, 0, sizeof(SOCKADDR_IN
));
3907 memset(&sock_addr
, 0, sizeof(SOCKADDR_IN
));
3908 memset(&peer_addr
, 0, sizeof(SOCKADDR_IN
));
3909 ret
= WSAConnectByNameA(s
, "winehq.org", "http", NULL
, (struct sockaddr
*)&local_addr
,
3910 NULL
, (struct sockaddr
*)&remote_addr
, NULL
, NULL
);
3911 ok(ret
, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3912 setsockopt(s
, SOL_SOCKET
, SO_UPDATE_CONNECT_CONTEXT
, (char *)&conn_ctx
, sizeof(DWORD
));
3913 sock_len
= peer_len
= sizeof(SOCKADDR_IN
);
3914 ret
= getsockname(s
, (struct sockaddr
*)&sock_addr
, &sock_len
);
3915 ok(!ret
, "getsockname should have succeeded, error %u\n", WSAGetLastError());
3916 ret
= getpeername(s
, (struct sockaddr
*)&peer_addr
, &peer_len
);
3917 ok(!ret
, "getpeername should have succeeded, error %u\n", WSAGetLastError());
3918 ok(sock_len
== sizeof(SOCKADDR_IN
), "got sockname size of %d\n", sock_len
);
3919 ok(peer_len
== sizeof(SOCKADDR_IN
), "got peername size of %d\n", peer_len
);
3920 ok(!local_addr
.sin_family
, "local_addr received data.\n");
3921 ok(!remote_addr
.sin_family
, "remote_addr received data.\n");
3924 /* Passing NULLs for node or service */
3925 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3926 ret
= WSAConnectByNameA(s
, NULL
, "http", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
3927 err
= WSAGetLastError();
3928 ok(!ret
, "WSAConnectByNameA should have failed\n");
3929 ok(err
== WSAEINVAL
, "expected error %u (WSAEINVAL), got %u\n", WSAEINVAL
, err
);
3930 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3932 ret
= WSAConnectByNameA(s
, "winehq.org", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
3933 err
= WSAGetLastError();
3934 ok(!ret
, "WSAConnectByNameA should have failed\n");
3935 ok(err
== WSAEINVAL
, "expected error %u (WSAEINVAL), got %u\n", WSAEINVAL
, err
);
3938 /* Passing NULL for the addresses and address lengths */
3939 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3940 ret
= WSAConnectByNameA(s
, "winehq.org", "http", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
3941 ok(ret
, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3944 /* Passing NULL for the addresses and passing correct lengths */
3945 local_len
= remote_len
= sizeof(SOCKADDR_IN
);
3946 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3947 ret
= WSAConnectByNameA(s
, "winehq.org", "http", &local_len
, NULL
,
3948 &remote_len
, NULL
, NULL
, NULL
);
3949 ok(ret
, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3950 ok(local_len
== sizeof(SOCKADDR_IN
), "local_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN
),
3952 ok(remote_len
== sizeof(SOCKADDR_IN
), "remote_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN
),
3956 /* Passing addresses and passing short lengths */
3957 local_len
= remote_len
= 3;
3958 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3959 ret
= WSAConnectByNameA(s
, "winehq.org", "http", &local_len
, (struct sockaddr
*)&local_addr
,
3960 &remote_len
, (struct sockaddr
*)&remote_addr
, NULL
, NULL
);
3961 err
= WSAGetLastError();
3962 ok(!ret
, "WSAConnectByNameA should have failed\n");
3963 ok(err
== WSAEFAULT
, "expected error %u (WSAEFAULT), got %u\n", WSAEFAULT
, err
);
3964 ok(local_len
== 3, "local_len should have been 3, got %ld\n", local_len
);
3965 ok(remote_len
== 3, "remote_len should have been 3, got %ld\n", remote_len
);
3968 /* Passing addresses and passing long lengths */
3969 local_len
= remote_len
= 50;
3970 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3971 ret
= WSAConnectByNameA(s
, "winehq.org", "http", &local_len
, (struct sockaddr
*)&local_addr
,
3972 &remote_len
, (struct sockaddr
*)&remote_addr
, NULL
, NULL
);
3973 ok(ret
, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3974 ok(local_len
== sizeof(SOCKADDR_IN
), "local_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN
),
3976 ok(remote_len
== sizeof(SOCKADDR_IN
), "remote_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN
),
3980 /* Unknown service */
3981 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3982 ret
= WSAConnectByNameA(s
, "winehq.org", "nonexistentservice", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
3983 err
= WSAGetLastError();
3984 ok(!ret
, "WSAConnectByNameA should have failed\n");
3985 ok(err
== WSATYPE_NOT_FOUND
, "expected error %u (WSATYPE_NOT_FOUND), got %u\n",
3986 WSATYPE_NOT_FOUND
, err
);
3989 /* Connecting with a UDP socket */
3990 s
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
3991 ret
= WSAConnectByNameA(s
, "winehq.org", "https", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
3992 err
= WSAGetLastError();
3993 ok(!ret
, "WSAConnectByNameA should have failed\n");
3994 ok(err
== WSAEINVAL
|| err
== WSAEFAULT
, "expected error %u (WSAEINVAL) or %u (WSAEFAULT), got %u\n",
3995 WSAEINVAL
, WSAEFAULT
, err
); /* WSAEFAULT win10 >= 1809 */
3998 /* Passing non-null as the reserved parameter */
3999 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4000 ret
= WSAConnectByNameA(s
, "winehq.org", "http", NULL
, NULL
, NULL
, NULL
, NULL
, &overlap
);
4001 err
= WSAGetLastError();
4002 ok(!ret
, "WSAConnectByNameA should have failed\n");
4003 ok(err
== WSAEINVAL
, "expected error %u (WSAEINVAL), got %u\n", WSAEINVAL
, err
);
4007 static void test_WSAEnumNetworkEvents(void)
4010 int sock_type
[] = {SOCK_STREAM
, SOCK_DGRAM
, SOCK_STREAM
}, i
, j
, k
, l
;
4011 struct sockaddr_in address
;
4013 WSANETWORKEVENTS net_events
;
4015 memset(&address
, 0, sizeof(address
));
4016 address
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
4017 address
.sin_family
= AF_INET
;
4019 /* This test follows the steps from bugs 10204 and 24946 */
4020 for (l
= 0; l
< 2; l
++)
4022 for (i
= 0; i
< ARRAY_SIZE(sock_type
); i
++)
4025 tcp_socketpair(&s
, &s2
);
4028 s
= socket(AF_INET
, sock_type
[i
], 0);
4029 ok (s
!= SOCKET_ERROR
, "Test[%d]: failed to create socket\n", i
);
4030 ok (!bind(s
, (struct sockaddr
*) &address
, sizeof(address
)), "Test[%d]: bind failed\n", i
);
4032 event
= WSACreateEvent();
4033 ok (event
!= NULL
, "Test[%d]: failed to create event\n", i
);
4034 for (j
= 0; j
< 5; j
++) /* Repeat sometimes and the result must be the same */
4036 /* When the TCP socket is not connected NO events will be returned.
4037 * When connected and no data pending it will get the write event.
4038 * UDP sockets don't have connections so as soon as they are bound
4039 * they can read/write data. Since nobody is sendind us data only
4040 * the write event will be returned and ONLY once.
4042 ok (!WSAEventSelect(s
, event
, FD_READ
| FD_WRITE
), "Test[%d]: WSAEventSelect failed\n", i
);
4043 memset(&net_events
, 0xAB, sizeof(net_events
));
4044 ok (!WSAEnumNetworkEvents(s
, l
== 0 ? event
: NULL
, &net_events
),
4045 "Test[%d]: WSAEnumNetworkEvents failed\n", i
);
4046 if (i
>= 1 && j
== 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
4048 ok (net_events
.lNetworkEvents
== FD_WRITE
, "Test[%d]: expected 2, got %ld\n",
4049 i
, net_events
.lNetworkEvents
);
4053 ok (net_events
.lNetworkEvents
== 0, "Test[%d]: expected 0, got %ld\n",
4054 i
, net_events
.lNetworkEvents
);
4056 for (k
= 0; k
< FD_MAX_EVENTS
; k
++)
4058 if (net_events
.lNetworkEvents
& (1 << k
))
4060 ok (net_events
.iErrorCode
[k
] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
4061 i
, k
, net_events
.iErrorCode
[k
]);
4065 /* Bits that are not set in lNetworkEvents MUST not be changed */
4066 ok (net_events
.iErrorCode
[k
] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
4067 i
, k
, net_events
.iErrorCode
[k
]);
4072 WSACloseEvent(event
);
4073 if (i
== 2) closesocket(s2
);
4078 static DWORD WINAPI
SelectReadThread(void *param
)
4080 select_thread_params
*par
= param
;
4083 struct sockaddr_in addr
;
4084 struct timeval select_timeout
;
4087 FD_SET(par
->s
, &readfds
);
4088 select_timeout
.tv_sec
=5;
4089 select_timeout
.tv_usec
=0;
4090 addr
.sin_family
= AF_INET
;
4091 addr
.sin_addr
.s_addr
= inet_addr(SERVERIP
);
4092 addr
.sin_port
= htons(SERVERPORT
);
4094 do_bind(par
->s
, (struct sockaddr
*)&addr
, sizeof(addr
));
4095 wsa_ok(listen(par
->s
, SOMAXCONN
), 0 ==, "SelectReadThread (%lx): listen failed: %d\n");
4097 SetEvent(server_ready
);
4098 ret
= select(par
->s
+1, &readfds
, NULL
, NULL
, &select_timeout
);
4099 par
->ReadKilled
= (ret
== 1);
4104 static DWORD WINAPI
SelectCloseThread(void *param
)
4106 SOCKET s
= *(SOCKET
*)param
;
4112 static void test_errors(void)
4115 SOCKADDR_IN SockAddr
;
4118 WSASetLastError(NO_ERROR
);
4119 sock
= socket(PF_INET
, SOCK_STREAM
, 0);
4120 ok( (sock
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4121 memset(&SockAddr
, 0, sizeof(SockAddr
));
4122 SockAddr
.sin_family
= AF_INET
;
4123 SockAddr
.sin_port
= htons(6924);
4124 SockAddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4126 ret
= connect(sock
, (PSOCKADDR
)&SockAddr
, sizeof(SockAddr
));
4127 ok( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got: %d\n", ret
);
4128 if (ret
== SOCKET_ERROR
)
4130 err
= WSAGetLastError();
4131 ok( (err
== WSAECONNREFUSED
), "expected WSAECONNREFUSED, got: %d\n", err
);
4136 fd_set set
= {1, {sock
}};
4139 timeval
.tv_usec
= 50000;
4141 ret
= select(1, NULL
, &set
, NULL
, &timeval
);
4142 ok( (ret
== 0), "expected 0 (timeout), got: %d\n", ret
);
4145 ret
= closesocket(sock
);
4146 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
4149 static void test_listen(void)
4152 int ret
, acceptc
, olen
= sizeof(acceptc
);
4153 struct sockaddr_in address
;
4155 memset(&address
, 0, sizeof(address
));
4156 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4157 address
.sin_family
= AF_INET
;
4158 address
.sin_port
= htons(SERVERPORT
);
4160 /* invalid socket tests */
4161 SetLastError(0xdeadbeef);
4162 ok ((listen(0, 0) == SOCKET_ERROR
), "listen did not fail\n");
4163 ret
= WSAGetLastError();
4164 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
4166 SetLastError(0xdeadbeef);
4167 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR
), "listen did not fail\n");
4168 ret
= WSAGetLastError();
4169 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
4172 SetLastError(0xdeadbeef);
4173 fdA
= socket(AF_INET
, SOCK_DGRAM
, 0);
4174 ok ((fdA
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4176 ok ((listen(fdA
, 1) == SOCKET_ERROR
), "listen did not fail\n");
4177 ret
= WSAGetLastError();
4178 ok (ret
== WSAEOPNOTSUPP
, "expected 10045, received %d\n", ret
);
4180 ret
= closesocket(fdA
);
4181 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
4184 fdA
= socket(AF_INET
, SOCK_STREAM
, 0);
4185 ok ((fdA
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4187 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
4188 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4190 SetLastError(0xdeadbeef);
4191 ok ((listen(fdA
, -2) == SOCKET_ERROR
), "listen did not fail\n");
4192 ret
= WSAGetLastError();
4193 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
4195 SetLastError(0xdeadbeef);
4196 ok ((listen(fdA
, 1) == SOCKET_ERROR
), "listen did not fail\n");
4197 ret
= WSAGetLastError();
4198 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
4200 SetLastError(0xdeadbeef);
4201 ok ((listen(fdA
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
4202 ret
= WSAGetLastError();
4203 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
4205 ok (!bind(fdA
, (struct sockaddr
*) &address
, sizeof(address
)), "bind failed\n");
4207 SetLastError(0xdeadbeef);
4208 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
4209 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
4212 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
4213 ok (!ret
, "getsockopt failed\n");
4214 ok (acceptc
== 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc
);
4217 WSASetLastError(0xdeadbeef);
4218 ret
= setsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char *)&acceptc
, sizeof(acceptc
));
4219 ok(ret
== -1, "expected failure\n");
4220 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
4223 WSASetLastError(0xdeadbeef);
4224 ret
= setsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char *)&acceptc
, sizeof(acceptc
));
4225 ok(ret
== -1, "expected failure\n");
4226 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
4228 ok (!listen(fdA
, 0), "listen failed\n");
4229 ok (!listen(fdA
, SOMAXCONN
), "double listen failed\n");
4232 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
4233 ok (!ret
, "getsockopt failed\n");
4234 ok (acceptc
== 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc
);
4237 WSASetLastError(0xdeadbeef);
4238 ret
= setsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char *)&acceptc
, sizeof(acceptc
));
4239 ok(ret
== -1, "expected failure\n");
4240 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
4243 WSASetLastError(0xdeadbeef);
4244 ret
= setsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char *)&acceptc
, sizeof(acceptc
));
4245 ok(ret
== -1, "expected failure\n");
4246 ok(WSAGetLastError() == WSAENOPROTOOPT
, "got error %u\n", WSAGetLastError());
4248 SetLastError(0xdeadbeef);
4249 ok ((listen(fdB
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
4250 ret
= WSAGetLastError();
4251 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
4253 ret
= closesocket(fdB
);
4254 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
4256 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
4257 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4259 SetLastError(0xdeadbeef);
4260 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
4261 ret
= WSAGetLastError();
4262 ok (ret
== WSAEADDRINUSE
, "expected 10048, received %d\n", ret
);
4264 ret
= closesocket(fdA
);
4265 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
4266 ret
= closesocket(fdB
);
4267 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
4270 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
4271 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
4272 static void test_select(void)
4274 static char tmp_buf
[1024];
4276 fd_set readfds
, writefds
, exceptfds
, *alloc_fds
;
4277 SOCKET fdListen
, fdRead
, fdWrite
, sockets
[200];
4280 struct timeval select_timeout
;
4281 struct sockaddr_in address
;
4282 select_thread_params thread_params
;
4283 HANDLE thread_handle
;
4284 DWORD ticks
, id
, old_protect
;
4285 unsigned int apc_count
;
4286 unsigned int maxfd
, i
;
4289 fdRead
= socket(AF_INET
, SOCK_STREAM
, 0);
4290 ok( (fdRead
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4291 fdWrite
= socket(AF_INET
, SOCK_STREAM
, 0);
4292 ok( (fdWrite
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4295 if (fdWrite
> maxfd
)
4300 FD_SET_ALL(fdWrite
);
4301 select_timeout
.tv_sec
=0;
4302 select_timeout
.tv_usec
=0;
4304 ticks
= GetTickCount();
4305 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4306 ticks
= GetTickCount() - ticks
;
4307 ok(ret
== 0, "select should not return any socket handles\n");
4308 ok(ticks
< 100, "select was blocking for %lu ms\n", ticks
);
4309 ok(!FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
4310 ok(!FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
4311 ok(!FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
4312 ok(!FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
4316 FD_SET_ALL(fdWrite
);
4317 select_timeout
.tv_sec
=0;
4318 select_timeout
.tv_usec
=500;
4320 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4321 ok(ret
== 0, "select should not return any socket handles\n");
4322 ok(!FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
4323 ok(!FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
4324 ok(!FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
4325 ok(!FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
4327 ok ((listen(fdWrite
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
4328 ret
= closesocket(fdWrite
);
4329 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
4331 thread_params
.s
= fdRead
;
4332 thread_params
.ReadKilled
= FALSE
;
4333 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
4334 thread_handle
= CreateThread (NULL
, 0, SelectReadThread
, &thread_params
, 0, &id
);
4335 ok ( (thread_handle
!= NULL
), "CreateThread failed unexpectedly: %ld\n", GetLastError());
4337 WaitForSingleObject (server_ready
, INFINITE
);
4339 ret
= closesocket(fdRead
);
4340 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
4342 WaitForSingleObject (thread_handle
, 1000);
4343 ok ( thread_params
.ReadKilled
, "closesocket did not wake up select\n");
4344 ret
= recv(fdRead
, &buffer
, 1, MSG_PEEK
);
4345 ok( (ret
== -1), "peek at closed socket expected -1 got %d\n", ret
);
4347 /* Test selecting invalid handles */
4351 ret
= select(maxfd
+1, 0, 0, 0, &select_timeout
);
4352 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
4353 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
4356 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4357 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
4358 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
4360 FD_SET(INVALID_SOCKET
, &readfds
);
4362 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4363 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
4364 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
4365 ok ( !FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
4368 FD_SET(INVALID_SOCKET
, &writefds
);
4370 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4371 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
4372 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
4373 ok ( !FD_ISSET(fdRead
, &writefds
), "FD should not be set\n");
4376 FD_SET(INVALID_SOCKET
, &exceptfds
);
4378 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4379 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
4380 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
4381 ok ( !FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
4383 tcp_socketpair(&fdRead
, &fdWrite
);
4385 if(fdWrite
> maxfd
) maxfd
= fdWrite
;
4388 FD_SET(fdRead
, &readfds
);
4390 ret
= QueueUserAPC(apc_func
, GetCurrentThread(), (ULONG_PTR
)&apc_count
);
4391 ok(ret
, "QueueUserAPC returned %d\n", ret
);
4392 ret
= select(fdRead
+1, &readfds
, NULL
, NULL
, &select_timeout
);
4393 ok(!ret
, "select returned %d\n", ret
);
4394 ok(apc_count
== 1, "got apc_count %d.\n", apc_count
);
4397 FD_SET(fdWrite
, &writefds
);
4399 ret
= QueueUserAPC(apc_func
, GetCurrentThread(), (ULONG_PTR
)&apc_count
);
4400 ok(ret
, "QueueUserAPC returned %d\n", ret
);
4401 ret
= select(fdWrite
+1, NULL
, &writefds
, NULL
, &select_timeout
);
4402 ok(ret
== 1, "select returned %d\n", ret
);
4403 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
4404 ok(!apc_count
, "APC was called\n");
4406 ok(apc_count
== 1, "got apc_count %d.\n", apc_count
);
4408 /* select the same socket twice */
4409 writefds
.fd_count
= 2;
4410 writefds
.fd_array
[0] = fdWrite
;
4411 writefds
.fd_array
[1] = fdWrite
;
4412 ret
= select(0, NULL
, &writefds
, NULL
, &select_timeout
);
4413 ok(ret
== 1, "select returned %d\n", ret
);
4414 ok(writefds
.fd_count
== 1, "got count %u\n", writefds
.fd_count
);
4415 ok(writefds
.fd_array
[0] == fdWrite
, "got fd %#Ix\n", writefds
.fd_array
[0]);
4416 ok(writefds
.fd_array
[1] == fdWrite
, "got fd %#Ix\n", writefds
.fd_array
[1]);
4418 /* tests for overlapping fd_set pointers */
4420 FD_SET(fdWrite
, &readfds
);
4421 ret
= select(fdWrite
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
4422 ok(ret
== 1, "select returned %d\n", ret
);
4423 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
4426 FD_SET(fdWrite
, &readfds
);
4427 FD_SET(fdRead
, &readfds
);
4428 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
4429 ok(ret
== 2, "select returned %d\n", ret
);
4430 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
4431 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
4433 ok(send(fdWrite
, "test", 4, 0) == 4, "failed to send data\n");
4435 FD_SET(fdRead
, &readfds
);
4436 ret
= select(fdRead
+1, &readfds
, NULL
, NULL
, &select_timeout
);
4437 ok(ret
== 1, "select returned %d\n", ret
);
4438 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
4441 FD_SET(fdWrite
, &readfds
);
4442 FD_SET(fdRead
, &readfds
);
4443 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
4444 ok(ret
== 2, "select returned %d\n", ret
);
4445 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
4446 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
4450 FD_SET(fdWrite
, &writefds
);
4451 ret
= select(fdWrite
+1, NULL
, &writefds
, NULL
, &select_timeout
);
4453 ok(send(fdWrite
, tmp_buf
, sizeof(tmp_buf
), 0) > 0, "failed to send data\n");
4456 FD_SET(fdWrite
, &readfds
);
4457 FD_SET(fdRead
, &readfds
);
4458 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
4459 ok(ret
== 1, "select returned %d\n", ret
);
4460 ok(!FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is in the set\n");
4461 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
4463 ok(send(fdRead
, "test", 4, 0) == 4, "failed to send data\n");
4466 FD_SET(fdWrite
, &readfds
);
4467 FD_SET(fdRead
, &readfds
);
4468 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
4469 ok(ret
== 2, "select returned %d\n", ret
);
4470 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
4471 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
4473 page_pair
= VirtualAlloc(NULL
, 0x1000 * 2, MEM_RESERVE
| MEM_COMMIT
, PAGE_READWRITE
);
4474 VirtualProtect(page_pair
+ 0x1000, 0x1000, PAGE_NOACCESS
, &old_protect
);
4475 alloc_fds
= (fd_set
*)((page_pair
+ 0x1000) - offsetof(fd_set
, fd_array
[1]));
4476 alloc_fds
->fd_count
= 1;
4477 alloc_fds
->fd_array
[0] = fdRead
;
4478 ret
= select(fdRead
+1, alloc_fds
, NULL
, NULL
, &select_timeout
);
4479 ok(ret
== 1, "select returned %d\n", ret
);
4480 VirtualFree(page_pair
, 0, MEM_RELEASE
);
4482 closesocket(fdRead
);
4483 closesocket(fdWrite
);
4485 alloc_fds
= malloc(offsetof(fd_set
, fd_array
[ARRAY_SIZE(sockets
)]));
4486 alloc_fds
->fd_count
= ARRAY_SIZE(sockets
);
4487 for (i
= 0; i
< ARRAY_SIZE(sockets
); i
+= 2)
4489 tcp_socketpair(&sockets
[i
], &sockets
[i
+ 1]);
4490 alloc_fds
->fd_array
[i
] = sockets
[i
];
4491 alloc_fds
->fd_array
[i
+ 1] = sockets
[i
+ 1];
4493 ret
= select(0, NULL
, alloc_fds
, NULL
, &select_timeout
);
4494 ok(ret
== ARRAY_SIZE(sockets
), "got %d\n", ret
);
4495 for (i
= 0; i
< ARRAY_SIZE(sockets
); ++i
)
4497 ok(alloc_fds
->fd_array
[i
] == sockets
[i
], "got socket %#Ix at index %u\n", alloc_fds
->fd_array
[i
], i
);
4498 closesocket(sockets
[i
]);
4502 /* select() works in 3 distinct states:
4503 * - to check if a connection attempt ended with success or error;
4504 * - to check if a pending connection is waiting for acceptance;
4505 * - to check for data to read, availability for write and OOB data
4507 * The tests below ensure that all conditions are tested.
4509 memset(&address
, 0, sizeof(address
));
4510 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4511 address
.sin_family
= AF_INET
;
4512 len
= sizeof(address
);
4513 fdListen
= setup_server_socket(&address
, &len
);
4514 select_timeout
.tv_sec
= 1;
4515 select_timeout
.tv_usec
= 250000;
4517 /* When no events are pending select returns 0 with no error */
4519 FD_SET_ALL(fdListen
);
4520 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4521 ok(ret
== 0, "expected 0, got %d\n", ret
);
4523 /* When a socket is attempting to connect the listening socket receives the read descriptor */
4524 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
4526 FD_SET_ALL(fdListen
);
4527 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4528 ok(ret
== 1, "expected 1, got %d\n", ret
);
4529 ok(FD_ISSET(fdListen
, &readfds
), "fdListen socket is not in the set\n");
4530 len
= sizeof(address
);
4531 fdRead
= accept(fdListen
, (struct sockaddr
*) &address
, &len
);
4532 ok(fdRead
!= INVALID_SOCKET
, "expected a valid socket\n");
4534 /* The connector is signaled through the write descriptor */
4536 FD_SET_ALL(fdListen
);
4538 FD_SET_ALL(fdWrite
);
4539 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4540 ok(ret
== 2, "expected 2, got %d\n", ret
);
4541 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
4542 ok(FD_ISSET(fdRead
, &writefds
), "fdRead socket is not in the set\n");
4545 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
4546 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
4547 ok(id
== 0, "expected 0, got %ld\n", id
);
4548 set_blocking(fdRead
, FALSE
);
4550 /* When data is received the receiver gets the read descriptor */
4551 ret
= send(fdWrite
, "1234", 4, 0);
4552 ok(ret
== 4, "expected 4, got %d\n", ret
);
4554 FD_SET_ALL(fdListen
);
4555 FD_SET(fdRead
, &readfds
);
4556 FD_SET(fdRead
, &exceptfds
);
4557 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4558 ok(ret
== 1, "expected 1, got %d\n", ret
);
4559 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
4560 ok(!FD_ISSET(fdRead
, &exceptfds
), "fdRead socket is in the set\n");
4563 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4564 ok(ret
== 2, "expected 1, got %d\n", ret
);
4565 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
4566 ok(FD_ISSET(fdRead
, &writefds
), "fdRead socket is not in the set\n");
4567 ok(!FD_ISSET(fdRead
, &exceptfds
), "fdRead socket is in the set\n");
4568 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
4569 ok(ret
== 4, "expected 4, got %d\n", ret
);
4570 ok(!strcmp(tmp_buf
, "1234"), "data received differs from sent\n");
4572 /* When OOB data is received the socket is set in the except descriptor */
4573 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
4574 ok(ret
== 1, "expected 1, got %d\n", ret
);
4576 FD_SET_ALL(fdListen
);
4577 FD_SET(fdRead
, &readfds
);
4578 FD_SET(fdRead
, &exceptfds
);
4579 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4580 ok(ret
== 1, "expected 1, got %d\n", ret
);
4581 ok(FD_ISSET(fdRead
, &exceptfds
), "fdRead socket is not in the set\n");
4583 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
4584 ok(ret
== 1, "expected 1, got %d\n", ret
);
4585 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
4587 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
4589 ret
= setsockopt(fdRead
, SOL_SOCKET
, SO_OOBINLINE
, (char*) &ret
, sizeof(ret
));
4590 ok(ret
== 0, "expected 0, got %d\n", ret
);
4591 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
4592 ok(ret
== 1, "expected 1, got %d\n", ret
);
4594 FD_SET_ALL(fdListen
);
4595 FD_SET(fdRead
, &readfds
);
4596 FD_SET(fdRead
, &exceptfds
);
4597 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4598 ok(ret
== 1, "expected 1, got %d\n", ret
);
4599 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
4601 SetLastError(0xdeadbeef);
4602 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
4603 ok(ret
== SOCKET_ERROR
, "expected SOCKET_ERROR, got %d\n", ret
);
4604 ok(GetLastError() == WSAEINVAL
, "expected 10022, got %ld\n", GetLastError());
4605 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
4606 ok(ret
== 1, "expected 1, got %d\n", ret
);
4607 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
4609 /* Linux has some odd behaviour (probably a bug) where receiving OOB,
4610 * setting SO_OOBINLINE, and then calling recv() again will cause the same
4611 * data to be received twice. Avoid that messing with further tests by
4612 * calling recv() here. */
4613 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
4614 todo_wine
ok(ret
== -1, "got %d\n", ret
);
4615 todo_wine
ok(GetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
4617 /* When the connection is closed the socket is set in the read descriptor */
4618 ret
= closesocket(fdRead
);
4619 ok(ret
== 0, "expected 0, got %d\n", ret
);
4621 FD_SET_ALL(fdListen
);
4622 FD_SET(fdWrite
, &readfds
);
4623 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4624 ok(ret
== 1, "expected 1, got %d\n", ret
);
4625 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
4626 ret
= recv(fdWrite
, tmp_buf
, sizeof(tmp_buf
), 0);
4627 ok(ret
== 0, "expected 0, got %d\n", ret
);
4628 ret
= closesocket(fdWrite
);
4629 ok(ret
== 0, "expected 0, got %d\n", ret
);
4631 /* w10pro64 sometimes takes over 2 seconds for an error to be reported. */
4632 if (winetest_interactive
)
4634 const struct sockaddr_in invalid_addr
=
4636 .sin_family
= AF_INET
,
4637 .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
),
4640 SOCKET client2
, server2
;
4642 fdWrite
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4643 set_blocking(fdWrite
, FALSE
);
4645 ret
= connect(fdWrite
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
4646 ok(ret
== -1, "got %d\n", ret
);
4647 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
4650 FD_SET(fdWrite
, &readfds
);
4651 FD_SET(fdWrite
, &writefds
);
4652 FD_SET(fdWrite
, &exceptfds
);
4653 select_timeout
.tv_sec
= 10;
4654 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4655 ok(ret
== 1, "expected 1, got %d\n", ret
);
4656 ok(FD_ISSET(fdWrite
, &exceptfds
), "fdWrite socket is not in the set\n");
4657 ok(select_timeout
.tv_usec
== 250000, "select timeout should not have changed\n");
4661 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char *)&id
, &len
);
4662 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
4663 ok(id
== WSAECONNREFUSED
, "got error %lu\n", id
);
4667 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char *)&id
, &len
);
4668 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
4669 ok(id
== WSAECONNREFUSED
, "got error %lu\n", id
);
4672 FD_SET(fdWrite
, &readfds
);
4673 FD_SET(fdWrite
, &writefds
);
4674 FD_SET(fdWrite
, &exceptfds
);
4675 select_timeout
.tv_sec
= 10;
4676 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4677 ok(ret
== 1, "got %d\n", ret
);
4678 ok(FD_ISSET(fdWrite
, &exceptfds
), "fdWrite socket is not in the set\n");
4680 /* Calling connect() doesn't reset the socket error, but a successful
4681 * connection does. This is kind of tricky to test, because while
4682 * Windows takes a couple seconds to actually fail the connection,
4683 * Linux will fail the connection almost immediately. */
4685 ret
= connect(fdWrite
, (const struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
4686 ok(ret
== -1, "got %d\n", ret
);
4687 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
4691 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char *)&id
, &len
);
4692 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
4693 ok(id
== WSAECONNREFUSED
, "got error %lu\n", id
);
4696 FD_SET(fdWrite
, &readfds
);
4697 FD_SET(fdWrite
, &writefds
);
4698 FD_SET(fdWrite
, &exceptfds
);
4699 select_timeout
.tv_sec
= 10;
4700 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4701 ok(ret
== 1, "got %d\n", ret
);
4702 ok(FD_ISSET(fdWrite
, &exceptfds
), "fdWrite socket is not in the set\n");
4704 len
= sizeof(address
);
4705 ret
= getsockname(fdListen
, (struct sockaddr
*)&address
, &len
);
4706 ok(!ret
, "got error %u\n", WSAGetLastError());
4707 ret
= connect(fdWrite
, (const struct sockaddr
*)&address
, sizeof(address
));
4708 ok(ret
== -1, "got %d\n", ret
);
4709 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
4712 FD_SET(fdWrite
, &readfds
);
4713 FD_SET(fdWrite
, &writefds
);
4714 FD_SET(fdWrite
, &exceptfds
);
4715 select_timeout
.tv_sec
= 1;
4716 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4717 ok(ret
== 1, "expected 1, got %d\n", ret
);
4718 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
4722 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char *)&id
, &len
);
4723 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
4724 ok(!id
, "got error %lu\n", id
);
4726 closesocket(fdWrite
);
4728 /* Test listening after a failed connection. */
4730 fdWrite
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4731 set_blocking(fdWrite
, FALSE
);
4733 address
.sin_family
= AF_INET
;
4734 address
.sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
4735 address
.sin_port
= 0;
4736 ret
= bind(fdWrite
, (struct sockaddr
*)&address
, sizeof(address
));
4737 ok(!ret
, "got %d\n", ret
);
4739 ret
= connect(fdWrite
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
4740 ok(ret
== -1, "got %d\n", ret
);
4741 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
4743 FD_ZERO(&exceptfds
);
4744 FD_SET(fdWrite
, &exceptfds
);
4745 select_timeout
.tv_sec
= 10;
4746 ret
= select(0, NULL
, NULL
, &exceptfds
, &select_timeout
);
4747 ok(ret
== 1, "expected 1, got %d\n", ret
);
4749 len
= sizeof(address
);
4750 ret
= getsockname(fdWrite
, (struct sockaddr
*)&address
, &len
);
4751 ok(!ret
, "got error %lu\n", GetLastError());
4753 /* Linux seems to forbid this. We'd need to replace the underlying fd. */
4754 ret
= listen(fdWrite
, 1);
4755 todo_wine
ok(!ret
, "got error %lu\n", GetLastError());
4759 client2
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4760 ret
= connect(client2
, (struct sockaddr
*)&address
, sizeof(address
));
4761 ok(!ret
, "got error %lu\n", GetLastError());
4763 server2
= accept(fdWrite
, NULL
, NULL
);
4764 ok(server2
!= INVALID_SOCKET
, "got %d\n", ret
);
4766 closesocket(server2
);
4767 closesocket(client2
);
4772 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char *)&id
, &len
);
4773 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
4774 ok(id
== WSAECONNREFUSED
, "got error %lu\n", id
);
4777 FD_SET(fdWrite
, &readfds
);
4778 FD_SET(fdWrite
, &writefds
);
4779 FD_SET(fdWrite
, &exceptfds
);
4780 select_timeout
.tv_sec
= 0;
4781 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4782 ok(ret
== 1, "got %d\n", ret
);
4783 ok(FD_ISSET(fdWrite
, &exceptfds
), "fdWrite socket is not in the set\n");
4785 closesocket(fdWrite
);
4787 /* test polling after a (synchronous) failure */
4789 fdWrite
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4791 ret
= connect(fdWrite
, (const struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
4792 ok(ret
== -1, "got %d\n", ret
);
4793 ok(WSAGetLastError() == WSAECONNREFUSED
, "got error %u\n", WSAGetLastError());
4797 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char *)&id
, &len
);
4798 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
4799 todo_wine
ok(!id
, "got error %lu\n", id
);
4802 FD_SET(fdWrite
, &readfds
);
4803 FD_SET(fdWrite
, &writefds
);
4804 FD_SET(fdWrite
, &exceptfds
);
4805 select_timeout
.tv_sec
= 0;
4806 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4807 ok(ret
== 1, "expected 1, got %d\n", ret
);
4808 ok(FD_ISSET(fdWrite
, &exceptfds
), "fdWrite socket is not in the set\n");
4812 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char *)&id
, &len
);
4813 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
4814 todo_wine
ok(!id
, "got error %lu\n", id
);
4816 closesocket(fdWrite
);
4819 ret
= closesocket(fdListen
);
4820 ok(ret
== 0, "expected 0, got %d\n", ret
);
4822 select_timeout
.tv_sec
= 1;
4823 select_timeout
.tv_usec
= 250000;
4825 /* Try select() on a closed socket after connection */
4826 tcp_socketpair(&fdRead
, &fdWrite
);
4827 closesocket(fdRead
);
4829 FD_SET_ALL(fdWrite
);
4831 SetLastError(0xdeadbeef);
4832 ret
= select(0, &readfds
, NULL
, &exceptfds
, &select_timeout
);
4833 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
4834 ok(GetLastError() == WSAENOTSOCK
, "got %ld\n", GetLastError());
4835 /* descriptor sets are unchanged */
4836 ok(readfds
.fd_count
== 2, "expected 2, got %d\n", readfds
.fd_count
);
4837 ok(exceptfds
.fd_count
== 2, "expected 2, got %d\n", exceptfds
.fd_count
);
4838 closesocket(fdWrite
);
4840 /* Close the socket currently being selected in a thread - bug 38399 */
4841 tcp_socketpair(&fdRead
, &fdWrite
);
4842 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
4843 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %ld\n", GetLastError());
4845 FD_SET_ALL(fdWrite
);
4846 ret
= select(0, &readfds
, NULL
, &exceptfds
, &select_timeout
);
4847 ok(ret
== 1, "expected 1, got %d\n", ret
);
4848 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
4849 WaitForSingleObject (thread_handle
, 1000);
4850 closesocket(fdRead
);
4851 /* test again with only the except descriptor */
4852 tcp_socketpair(&fdRead
, &fdWrite
);
4853 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
4854 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %ld\n", GetLastError());
4856 FD_SET(fdWrite
, &exceptfds
);
4857 SetLastError(0xdeadbeef);
4858 ret
= select(0, NULL
, NULL
, &exceptfds
, &select_timeout
);
4859 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
4860 ok(GetLastError() == WSAENOTSOCK
, "got %ld\n", GetLastError());
4861 ok(!FD_ISSET(fdWrite
, &exceptfds
), "fdWrite socket is in the set\n");
4862 WaitForSingleObject (thread_handle
, 1000);
4863 closesocket(fdRead
);
4865 /* test UDP behavior of unbound sockets */
4866 select_timeout
.tv_sec
= 0;
4867 select_timeout
.tv_usec
= 250000;
4868 fdWrite
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
4869 ok(fdWrite
!= INVALID_SOCKET
, "socket call failed\n");
4871 FD_SET_ALL(fdWrite
);
4872 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
4873 ok(ret
== 1, "expected 1, got %d\n", ret
);
4874 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
4875 closesocket(fdWrite
);
4880 static DWORD WINAPI
AcceptKillThread(void *param
)
4882 select_thread_params
*par
= param
;
4883 struct sockaddr_in address
;
4884 int len
= sizeof(address
);
4885 SOCKET client_socket
;
4887 SetEvent(server_ready
);
4888 client_socket
= accept(par
->s
, (struct sockaddr
*) &address
, &len
);
4889 if (client_socket
!= INVALID_SOCKET
)
4890 closesocket(client_socket
);
4891 par
->ReadKilled
= (client_socket
== INVALID_SOCKET
);
4896 static int CALLBACK
AlwaysDeferConditionFunc(LPWSABUF lpCallerId
, LPWSABUF lpCallerData
, LPQOS pQos
,
4897 LPQOS lpGQOS
, LPWSABUF lpCalleeId
, LPWSABUF lpCalleeData
,
4898 GROUP
*g
, DWORD_PTR dwCallbackData
)
4903 static SOCKET
setup_server_socket(struct sockaddr_in
*addr
, int *len
)
4906 SOCKET server_socket
;
4908 server_socket
= socket(AF_INET
, SOCK_STREAM
, 0);
4909 ok(server_socket
!= INVALID_SOCKET
, "failed to bind socket, error %u\n", WSAGetLastError());
4912 ret
= setsockopt(server_socket
, SOL_SOCKET
, SO_REUSEADDR
, (char *)&val
, sizeof(val
));
4913 ok(!ret
, "failed to set SO_REUSEADDR, error %u\n", WSAGetLastError());
4915 ret
= bind(server_socket
, (struct sockaddr
*)addr
, *len
);
4916 ok(!ret
, "failed to bind socket, error %u\n", WSAGetLastError());
4918 ret
= getsockname(server_socket
, (struct sockaddr
*)addr
, len
);
4919 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
4921 ret
= listen(server_socket
, 5);
4922 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
4924 return server_socket
;
4927 static SOCKET
setup_connector_socket(const struct sockaddr_in
*addr
, int len
, BOOL nonblock
)
4932 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
4933 ok(connector
!= INVALID_SOCKET
, "failed to create connector socket %d\n", WSAGetLastError());
4936 set_blocking(connector
, !nonblock
);
4938 ret
= connect(connector
, (const struct sockaddr
*)addr
, len
);
4940 ok(!ret
, "connecting to accepting socket failed %d\n", WSAGetLastError());
4941 else if (ret
== SOCKET_ERROR
)
4942 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
4947 struct connect_apc_func_param
4950 struct sockaddr_in addr
;
4952 unsigned int apc_count
;
4955 static DWORD WINAPI
test_accept_connect_thread(void *param
)
4957 struct connect_apc_func_param
*p
= (struct connect_apc_func_param
*)param
;
4959 WaitForSingleObject(p
->event
, INFINITE
);
4960 p
->connector
= setup_connector_socket(&p
->addr
, sizeof(p
->addr
), FALSE
);
4961 ok(p
->connector
!= INVALID_SOCKET
, "failed connecting from APC func.\n");
4965 static void WINAPI
connect_apc_func(ULONG_PTR param
)
4967 struct connect_apc_func_param
*p
= (struct connect_apc_func_param
*)param
;
4973 static void test_accept(void)
4976 SOCKET server_socket
, accepted
= INVALID_SOCKET
, connector
;
4977 struct connect_apc_func_param apc_param
;
4978 struct sockaddr_in address
;
4979 SOCKADDR_STORAGE ss
, ss_empty
;
4981 select_thread_params thread_params
;
4982 HANDLE thread_handle
= NULL
;
4985 memset(&address
, 0, sizeof(address
));
4986 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4987 address
.sin_family
= AF_INET
;
4989 socklen
= sizeof(address
);
4990 server_socket
= setup_server_socket(&address
, &socklen
);
4992 memset(&apc_param
, 0, sizeof(apc_param
));
4993 apc_param
.event
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
4994 apc_param
.addr
= address
;
4995 /* Connecting directly from APC function randomly crashes on Windows for some reason,
4996 * so do it from a thread and only signal it from the APC when we are in accept() call. */
4997 thread_handle
= CreateThread(NULL
, 0, test_accept_connect_thread
, &apc_param
, 0, NULL
);
4998 ret
= QueueUserAPC(connect_apc_func
, GetCurrentThread(), (ULONG_PTR
)&apc_param
);
4999 ok(ret
, "QueueUserAPC returned %d\n", ret
);
5000 accepted
= accept(server_socket
, NULL
, NULL
);
5001 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
5002 ok(apc_param
.apc_count
== 1, "APC was called %u times\n", apc_param
.apc_count
);
5003 closesocket(accepted
);
5004 closesocket(apc_param
.connector
);
5005 WaitForSingleObject(thread_handle
, INFINITE
);
5006 CloseHandle(thread_handle
);
5007 CloseHandle(apc_param
.event
);
5009 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
5010 if (connector
== INVALID_SOCKET
) goto done
;
5012 accepted
= WSAAccept(server_socket
, NULL
, NULL
, AlwaysDeferConditionFunc
, 0);
5013 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
5015 accepted
= accept(server_socket
, NULL
, 0);
5016 ok(accepted
!= INVALID_SOCKET
, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
5018 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
5020 thread_params
.s
= server_socket
;
5021 thread_params
.ReadKilled
= FALSE
;
5022 thread_handle
= CreateThread(NULL
, 0, AcceptKillThread
, &thread_params
, 0, &id
);
5024 WaitForSingleObject(server_ready
, INFINITE
);
5026 ret
= closesocket(server_socket
);
5027 ok(!ret
, "failed to close socket, error %u\n", WSAGetLastError());
5029 WaitForSingleObject(thread_handle
, 1000);
5030 ok(thread_params
.ReadKilled
, "closesocket did not wake up accept\n");
5032 closesocket(accepted
);
5033 closesocket(connector
);
5034 accepted
= connector
= INVALID_SOCKET
;
5036 socklen
= sizeof(address
);
5037 server_socket
= setup_server_socket(&address
, &socklen
);
5039 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
5040 if (connector
== INVALID_SOCKET
) goto done
;
5043 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
5044 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
5045 ok(!socklen
, "got %d\n", socklen
);
5046 closesocket(connector
);
5047 connector
= INVALID_SOCKET
;
5049 socklen
= sizeof(address
);
5050 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
5051 if (connector
== INVALID_SOCKET
) goto done
;
5053 accepted
= WSAAccept(server_socket
, NULL
, NULL
, NULL
, 0);
5054 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
5055 closesocket(accepted
);
5056 closesocket(connector
);
5057 accepted
= connector
= INVALID_SOCKET
;
5059 socklen
= sizeof(address
);
5060 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
5061 if (connector
== INVALID_SOCKET
) goto done
;
5063 socklen
= sizeof(ss
);
5064 memset(&ss
, 0, sizeof(ss
));
5065 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
5066 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
5067 ok(socklen
!= sizeof(ss
), "unexpected length\n");
5068 ok(ss
.ss_family
, "family not set\n");
5069 closesocket(accepted
);
5070 closesocket(connector
);
5071 accepted
= connector
= INVALID_SOCKET
;
5073 socklen
= sizeof(address
);
5074 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
5075 if (connector
== INVALID_SOCKET
) goto done
;
5078 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
5079 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
5080 ok(!socklen
, "got %d\n", socklen
);
5081 closesocket(connector
);
5082 accepted
= connector
= INVALID_SOCKET
;
5084 socklen
= sizeof(address
);
5085 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
5086 if (connector
== INVALID_SOCKET
) goto done
;
5088 accepted
= accept(server_socket
, NULL
, NULL
);
5089 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
5090 closesocket(accepted
);
5091 closesocket(connector
);
5092 accepted
= connector
= INVALID_SOCKET
;
5094 socklen
= sizeof(address
);
5095 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
5096 if (connector
== INVALID_SOCKET
) goto done
;
5098 socklen
= sizeof(ss
);
5099 memset(&ss
, 0, sizeof(ss
));
5100 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
5101 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
5102 ok(socklen
!= sizeof(ss
), "unexpected length\n");
5103 ok(ss
.ss_family
, "family not set\n");
5104 closesocket(accepted
);
5105 closesocket(connector
);
5106 accepted
= connector
= INVALID_SOCKET
;
5108 socklen
= sizeof(address
);
5109 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
5110 if (connector
== INVALID_SOCKET
) goto done
;
5112 memset(&ss
, 0, sizeof(ss
));
5113 memset(&ss_empty
, 0, sizeof(ss_empty
));
5114 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, NULL
);
5115 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
5116 ok(!memcmp(&ss
, &ss_empty
, sizeof(ss
)), "structure is different\n");
5119 if (accepted
!= INVALID_SOCKET
)
5120 closesocket(accepted
);
5121 if (connector
!= INVALID_SOCKET
)
5122 closesocket(connector
);
5123 if (thread_handle
!= NULL
)
5124 CloseHandle(thread_handle
);
5125 if (server_ready
!= INVALID_HANDLE_VALUE
)
5126 CloseHandle(server_ready
);
5127 if (server_socket
!= INVALID_SOCKET
)
5128 closesocket(server_socket
);
5131 /* Test what socket state is inherited from the listening socket by accept(). */
5132 static void test_accept_inheritance(void)
5134 struct sockaddr_in addr
, destaddr
;
5135 SOCKET listener
, server
, client
;
5136 struct linger linger
;
5137 int ret
, len
, value
;
5148 {SOL_SOCKET
, SO_REUSEADDR
, 1},
5149 {SOL_SOCKET
, SO_KEEPALIVE
, 1},
5150 {SOL_SOCKET
, SO_OOBINLINE
, 1},
5151 {SOL_SOCKET
, SO_SNDBUF
, 0x123},
5152 {SOL_SOCKET
, SO_RCVBUF
, 0x123},
5153 {SOL_SOCKET
, SO_SNDTIMEO
, 0x123},
5154 {SOL_SOCKET
, SO_RCVTIMEO
, 0x123},
5155 {IPPROTO_TCP
, TCP_NODELAY
, 1},
5158 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5159 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
5161 for (i
= 0; i
< ARRAY_SIZE(int_tests
); ++i
)
5163 ret
= setsockopt(listener
, int_tests
[i
].optname
, int_tests
[i
].optval
,
5164 (char *)&int_tests
[i
].value
, sizeof(int_tests
[i
].value
));
5165 ok(!ret
, "test %u: got error %u\n", i
, WSAGetLastError());
5169 linger
.l_linger
= 555;
5170 ret
= setsockopt(listener
, SOL_SOCKET
, SO_LINGER
, (char *)&linger
, sizeof(linger
));
5171 ok(!ret
, "got error %u\n", WSAGetLastError());
5173 memset(&addr
, 0, sizeof(addr
));
5174 addr
.sin_family
= AF_INET
;
5175 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5176 ret
= bind(listener
, (struct sockaddr
*)&addr
, sizeof(addr
));
5177 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
5178 len
= sizeof(destaddr
);
5179 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &len
);
5180 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
5182 ret
= listen(listener
, 1);
5183 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
5185 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5186 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
5187 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
5188 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
5189 server
= accept(listener
, NULL
, NULL
);
5190 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
5192 for (i
= 0; i
< ARRAY_SIZE(int_tests
); ++i
)
5195 len
= sizeof(value
);
5196 ret
= getsockopt(server
, int_tests
[i
].optname
, int_tests
[i
].optval
, (char *)&value
, &len
);
5197 ok(!ret
, "test %u: got error %u\n", i
, WSAGetLastError());
5198 ok(value
== int_tests
[i
].value
, "test %u: got value %#x\n", i
, value
);
5201 len
= sizeof(linger
);
5202 memset(&linger
, 0, sizeof(linger
));
5203 ret
= getsockopt(server
, SOL_SOCKET
, SO_LINGER
, (char *)&linger
, &len
);
5204 ok(!ret
, "got error %u\n", WSAGetLastError());
5205 ok(linger
.l_onoff
== 1, "got on/off %u\n", linger
.l_onoff
);
5206 ok(linger
.l_linger
== 555, "got linger %u\n", linger
.l_onoff
);
5208 closesocket(server
);
5209 closesocket(client
);
5210 closesocket(listener
);
5213 static void test_extendedSocketOptions(void)
5217 struct sockaddr_in sa
;
5218 int sa_len
= sizeof(struct sockaddr_in
);
5219 int optval
, optlen
= sizeof(int), ret
;
5223 ret
= WSAStartup(MAKEWORD(2,0), &wsa
);
5224 ok(!ret
, "failed to startup, error %u\n", WSAGetLastError());
5226 memset(&sa
, 0, sa_len
);
5228 sa
.sin_family
= AF_INET
;
5229 sa
.sin_port
= htons(0);
5230 sa
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
5232 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
5233 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
5235 ret
= bind(sock
, (struct sockaddr
*) &sa
, sa_len
);
5236 ok(!ret
, "failed to bind socket, error %u\n", WSAGetLastError());
5238 ret
= getsockopt(sock
, SOL_SOCKET
, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
5240 ok(ret
== 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret
);
5241 ok((optval
== 65507) || (optval
== 65527),
5242 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval
);
5244 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
5245 SetLastError(0xdeadbeef);
5246 optval
= 0xdeadbeef;
5247 optlen
= sizeof(int);
5248 ret
= getsockopt(sock
, 0xffffffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
5249 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
5250 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5251 ret
, WSAGetLastError(), optval
, optval
);
5253 /* more invalid values for level */
5254 SetLastError(0xdeadbeef);
5255 optval
= 0xdeadbeef;
5256 optlen
= sizeof(int);
5257 ret
= getsockopt(sock
, 0x1234ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
5258 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
5259 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5260 ret
, WSAGetLastError(), optval
, optval
);
5262 SetLastError(0xdeadbeef);
5263 optval
= 0xdeadbeef;
5264 optlen
= sizeof(int);
5265 ret
= getsockopt(sock
, 0x8000ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
5266 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
5267 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5268 ret
, WSAGetLastError(), optval
, optval
);
5270 SetLastError(0xdeadbeef);
5271 optval
= 0xdeadbeef;
5272 optlen
= sizeof(int);
5273 ret
= getsockopt(sock
, 0x00008000, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
5274 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
5275 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5276 ret
, WSAGetLastError(), optval
, optval
);
5278 SetLastError(0xdeadbeef);
5279 optval
= 0xdeadbeef;
5280 optlen
= sizeof(int);
5281 ret
= getsockopt(sock
, 0x00000800, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
5282 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
5283 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5284 ret
, WSAGetLastError(), optval
, optval
);
5286 SetLastError(0xdeadbeef);
5287 optlen
= sizeof(LINGER
);
5288 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
5289 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAENOPROTOOPT
),
5290 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
5291 ret
, WSAGetLastError());
5294 sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
);
5295 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
5297 ret
= bind(sock
, (struct sockaddr
*) &sa
, sa_len
);
5298 ok(!ret
, "failed to bind socket, error %u\n", WSAGetLastError());
5300 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
5301 ok(ret
== 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret
);
5303 optlen
= sizeof(BOOL
);
5304 ret
= getsockopt(sock
, SOL_SOCKET
, SO_DONTLINGER
, (char *)&bool_opt_val
, &optlen
);
5305 ok(ret
== 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret
);
5306 ok((linger_val
.l_onoff
&& !bool_opt_val
) || (!linger_val
.l_onoff
&& bool_opt_val
),
5307 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
5308 bool_opt_val
, linger_val
.l_onoff
);
5314 static void test_getsockname(void)
5318 struct sockaddr_in sa_set
, sa_get
;
5319 int sa_set_len
= sizeof(struct sockaddr_in
);
5320 int sa_get_len
= sa_set_len
;
5321 static const unsigned char null_padding
[] = {0,0,0,0,0,0,0,0};
5325 ret
= WSAStartup(MAKEWORD(2,0), &wsa
);
5326 ok(!ret
, "failed to startup, error %u\n", WSAGetLastError());
5328 memset(&sa_set
, 0, sa_set_len
);
5330 sa_set
.sin_family
= AF_INET
;
5331 sa_set
.sin_port
= htons(0);
5332 sa_set
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
5334 sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
);
5335 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
5338 WSASetLastError(0xdeadbeef);
5339 ret
= getsockname(sock
, (struct sockaddr
*)&sa_get
, &sa_get_len
);
5340 ok(ret
== SOCKET_ERROR
, "expected failure\n");
5341 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
5342 ok(!memcmp(&sa_get
, &sa_set
, sizeof(sa_get
)), "address should not be changed\n");
5344 ret
= bind(sock
, (struct sockaddr
*) &sa_set
, sa_set_len
);
5345 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
5347 WSASetLastError(0xdeadbeef);
5348 memset(&sa_get
, 0, sizeof(sa_get
));
5349 ret
= getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
);
5350 ok(!ret
, "got %d\n", ret
);
5351 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
5352 ok(sa_get
.sin_family
== AF_INET
, "got family %#x\n", sa_get
.sin_family
);
5353 ok(sa_get
.sin_port
!= 0, "got zero port\n");
5354 ok(sa_get
.sin_addr
.s_addr
== INADDR_ANY
, "got addr %08lx\n", sa_get
.sin_addr
.s_addr
);
5356 ret
= memcmp(sa_get
.sin_zero
, null_padding
, 8);
5357 ok(ret
== 0, "getsockname did not zero the sockaddr_in structure\n");
5359 sa_get_len
= sizeof(sa_get
) - 1;
5360 WSASetLastError(0xdeadbeef);
5361 ret
= getsockname(sock
, (struct sockaddr
*)&sa_get
, &sa_get_len
);
5362 ok(ret
== -1, "expected failure\n");
5363 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5364 ok(sa_get_len
== sizeof(sa_get
) - 1, "got size %d\n", sa_get_len
);
5368 h
= gethostbyname("");
5369 if (h
&& h
->h_length
== 4) /* this test is only meaningful in IPv4 */
5372 for (i
= 0; h
->h_addr_list
[i
]; i
++)
5376 ip
.s_addr
= *(ULONG
*) h
->h_addr_list
[i
];
5378 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
5379 ok(sock
!= INVALID_SOCKET
, "socket failed with %ld\n", GetLastError());
5381 memset(&sa_set
, 0, sizeof(sa_set
));
5382 sa_set
.sin_family
= AF_INET
;
5383 sa_set
.sin_addr
.s_addr
= ip
.s_addr
;
5384 /* The same address we bind must be the same address we get */
5385 ret
= bind(sock
, (struct sockaddr
*)&sa_set
, sizeof(sa_set
));
5386 ok(ret
== 0, "bind failed with %ld\n", GetLastError());
5387 sa_get_len
= sizeof(sa_get
);
5388 ret
= getsockname(sock
, (struct sockaddr
*)&sa_get
, &sa_get_len
);
5389 ok(ret
== 0, "getsockname failed with %ld\n", GetLastError());
5390 strcpy(ipstr
, inet_ntoa(sa_get
.sin_addr
));
5391 ok(sa_get
.sin_addr
.s_addr
== sa_set
.sin_addr
.s_addr
,
5392 "address does not match: %s != %s\n", ipstr
, inet_ntoa(sa_set
.sin_addr
));
5401 static DWORD apc_error
, apc_size
;
5402 static OVERLAPPED
*apc_overlapped
;
5403 static unsigned int apc_count
;
5405 static void WINAPI
socket_apc(DWORD error
, DWORD size
, OVERLAPPED
*overlapped
, DWORD flags
)
5407 ok(!flags
, "got flags %#lx\n", flags
);
5411 apc_overlapped
= overlapped
;
5414 #define check_fionread_siocatmark(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, FALSE, FALSE)
5415 #define check_fionread_siocatmark_todo(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, TRUE, TRUE)
5416 #define check_fionread_siocatmark_todo_oob(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, FALSE, TRUE)
5417 static void check_fionread_siocatmark_(int line
, SOCKET s
, unsigned int normal
, unsigned int oob
,
5418 BOOL todo_normal
, BOOL todo_oob
)
5424 WSASetLastError(0xdeadbeef);
5425 ret
= WSAIoctl(s
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), &size
, NULL
, NULL
);
5426 ok_(__FILE__
, line
)(!ret
, "expected success\n");
5427 ok_(__FILE__
, line
)(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5428 todo_wine_if (todo_normal
) ok_(__FILE__
, line
)(value
== normal
, "FIONBIO returned %u\n", value
);
5431 WSASetLastError(0xdeadbeef);
5432 ret
= WSAIoctl(s
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), &size
, NULL
, NULL
);
5433 ok_(__FILE__
, line
)(!ret
, "expected success\n");
5434 ok_(__FILE__
, line
)(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5435 todo_wine_if (todo_oob
) ok_(__FILE__
, line
)(value
== oob
, "SIOCATMARK returned %u\n", value
);
5438 static void test_fionread_siocatmark(void)
5440 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
5441 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
5442 SOCKET client
, server
;
5449 tcp_socketpair(&client
, &server
);
5450 set_blocking(client
, FALSE
);
5451 overlapped
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
5453 WSASetLastError(0xdeadbeef);
5454 ret
= ioctlsocket(client
, FIONREAD
, (u_long
*)1);
5455 ok(ret
== -1, "expected failure\n");
5456 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5458 WSASetLastError(0xdeadbeef);
5459 ret
= ioctlsocket(client
, SIOCATMARK
, (u_long
*)1);
5460 ok(ret
== -1, "expected failure\n");
5461 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5463 WSASetLastError(0xdeadbeef);
5464 ret
= WSAIoctl(client
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), NULL
, NULL
, NULL
);
5465 ok(ret
== -1, "expected failure\n");
5466 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5468 WSASetLastError(0xdeadbeef);
5470 ret
= WSAIoctl(client
, FIONREAD
, NULL
, 0, &value
, sizeof(value
) - 1, &size
, NULL
, NULL
);
5471 ok(ret
== -1, "expected failure\n");
5472 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5473 ok(size
== 0xdeadbeef, "got size %lu\n", size
);
5475 WSASetLastError(0xdeadbeef);
5476 ret
= WSAIoctl(client
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), NULL
, NULL
, NULL
);
5477 ok(ret
== -1, "expected failure\n");
5478 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5480 WSASetLastError(0xdeadbeef);
5482 ret
= WSAIoctl(client
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
) - 1, &size
, NULL
, NULL
);
5483 ok(ret
== -1, "expected failure\n");
5484 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5485 ok(size
== 0xdeadbeef, "got size %lu\n", size
);
5487 check_fionread_siocatmark(client
, 0, TRUE
);
5489 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 123, 0);
5491 ret
= WSAIoctl(client
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), NULL
, &overlapped
, NULL
);
5492 ok(ret
== -1, "expected failure\n");
5493 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5495 ret
= WSAIoctl(client
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), NULL
, &overlapped
, NULL
);
5496 ok(ret
== -1, "expected failure\n");
5497 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5499 WSASetLastError(0xdeadbeef);
5502 overlapped
.Internal
= 0xdeadbeef;
5503 overlapped
.InternalHigh
= 0xdeadbeef;
5504 ret
= WSAIoctl(client
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), &size
, &overlapped
, NULL
);
5505 ok(!ret
, "expected success\n");
5506 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5507 ok(!value
, "got %u\n", value
);
5508 ok(size
== sizeof(value
), "got size %lu\n", size
);
5509 ok(!overlapped
.Internal
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
5510 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
5512 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
5513 ok(ret
, "got error %lu\n", GetLastError());
5514 ok(!size
, "got size %lu\n", size
);
5515 ok(key
== 123, "got key %Iu\n", key
);
5516 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
5518 WSASetLastError(0xdeadbeef);
5521 overlapped
.Internal
= 0xdeadbeef;
5522 overlapped
.InternalHigh
= 0xdeadbeef;
5523 ret
= WSAIoctl(client
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), &size
, &overlapped
, NULL
);
5524 ok(!ret
, "expected success\n");
5525 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5526 ok(value
== TRUE
, "got %u\n", value
);
5527 ok(size
== sizeof(value
), "got size %lu\n", size
);
5528 ok(!overlapped
.Internal
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
5529 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
5531 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
5532 ok(ret
, "got error %lu\n", GetLastError());
5533 ok(!size
, "got size %lu\n", size
);
5534 ok(key
== 123, "got key %Iu\n", key
);
5535 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
5537 ret
= send(server
, "data", 5, 0);
5538 ok(ret
== 5, "got %d\n", ret
);
5540 /* wait for the data to be available */
5541 check_poll_mask(client
, POLLRDNORM
, POLLRDNORM
);
5543 check_fionread_siocatmark(client
, 5, TRUE
);
5545 ret
= send(server
, "a", 1, MSG_OOB
);
5546 ok(ret
== 1, "got %d\n", ret
);
5548 /* wait for the data to be available */
5549 check_poll_mask(client
, POLLRDBAND
, POLLRDBAND
);
5551 check_fionread_siocatmark_todo_oob(client
, 5, FALSE
);
5553 ret
= send(server
, "a", 1, MSG_OOB
);
5554 ok(ret
== 1, "got %d\n", ret
);
5556 check_fionread_siocatmark_todo(client
, 5, FALSE
);
5558 ret
= recv(client
, buffer
, 3, 0);
5559 ok(ret
== 3, "got %d\n", ret
);
5561 check_fionread_siocatmark_todo(client
, 2, FALSE
);
5563 ret
= recv(client
, buffer
, 1, MSG_OOB
);
5564 ok(ret
== 1, "got %d\n", ret
);
5566 /* wait for the data to be available */
5567 check_poll_mask_todo(client
, POLLRDBAND
, POLLRDBAND
);
5569 check_fionread_siocatmark_todo(client
, 2, FALSE
);
5571 ret
= recv(client
, buffer
, 5, 0);
5572 todo_wine
ok(ret
== 2, "got %d\n", ret
);
5574 check_fionread_siocatmark(client
, 0, FALSE
);
5576 ret
= recv(client
, buffer
, 1, MSG_OOB
);
5577 todo_wine
ok(ret
== 1, "got %d\n", ret
);
5579 check_fionread_siocatmark_todo_oob(client
, 0, TRUE
);
5581 ret
= send(server
, "a", 1, MSG_OOB
);
5582 ok(ret
== 1, "got %d\n", ret
);
5584 /* wait for the data to be available */
5585 check_poll_mask(client
, POLLRDBAND
, POLLRDBAND
);
5588 ret
= setsockopt(client
, SOL_SOCKET
, SO_OOBINLINE
, (char *)&ret
, sizeof(ret
));
5589 ok(!ret
, "got error %u\n", WSAGetLastError());
5591 check_fionread_siocatmark_todo_oob(client
, 1, FALSE
);
5593 ret
= recv(client
, buffer
, 1, 0);
5594 ok(ret
== 1, "got %d\n", ret
);
5596 check_fionread_siocatmark(client
, 0, TRUE
);
5598 ret
= send(server
, "a", 1, MSG_OOB
);
5599 ok(ret
== 1, "got %d\n", ret
);
5601 /* wait for the data to be available */
5602 check_poll_mask(client
, POLLRDNORM
, POLLRDNORM
);
5604 check_fionread_siocatmark(client
, 1, TRUE
);
5606 closesocket(client
);
5607 closesocket(server
);
5609 server
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5611 check_fionread_siocatmark(server
, 0, TRUE
);
5613 ret
= bind(server
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
5614 ok(!ret
, "got error %u\n", WSAGetLastError());
5616 check_fionread_siocatmark(server
, 0, TRUE
);
5618 closesocket(server
);
5619 CloseHandle(overlapped
.hEvent
);
5621 /* test with APCs */
5623 server
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5625 ret
= WSAIoctl(server
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), NULL
, &overlapped
, socket_apc
);
5626 ok(ret
== -1, "expected failure\n");
5627 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5629 ret
= WSAIoctl(server
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), NULL
, &overlapped
, socket_apc
);
5630 ok(ret
== -1, "expected failure\n");
5631 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5635 ret
= WSAIoctl(server
, FIONREAD
, NULL
, 0, &value
, sizeof(value
), &size
, &overlapped
, socket_apc
);
5636 ok(!ret
, "expected success\n");
5637 ok(size
== sizeof(value
), "got size %lu\n", size
);
5639 ret
= SleepEx(0, TRUE
);
5640 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
5641 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
5642 ok(!apc_error
, "got APC error %lu\n", apc_error
);
5643 ok(!apc_size
, "got APC size %lu\n", apc_size
);
5644 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
5648 ret
= WSAIoctl(server
, SIOCATMARK
, NULL
, 0, &value
, sizeof(value
), &size
, &overlapped
, socket_apc
);
5649 ok(!ret
, "expected success\n");
5650 ok(size
== sizeof(value
), "got size %lu\n", size
);
5652 ret
= SleepEx(0, TRUE
);
5653 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
5654 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
5655 ok(!apc_error
, "got APC error %lu\n", apc_error
);
5656 ok(!apc_size
, "got APC size %lu\n", apc_size
);
5657 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
5659 closesocket(server
);
5662 static void test_fionbio(void)
5664 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
5665 u_long one
= 1, zero
= 0;
5673 event
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
5674 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5675 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
5677 WSASetLastError(0xdeadbeef);
5678 ret
= ioctlsocket(s
, FIONBIO
, (u_long
*)1);
5679 ok(ret
== -1, "expected failure\n");
5680 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5682 WSASetLastError(0xdeadbeef);
5683 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, NULL
, NULL
, NULL
);
5684 ok(ret
== -1, "expected failure\n");
5685 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5687 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
) - 1, NULL
, 0, &size
, &overlapped
, NULL
);
5688 ok(ret
== -1, "expected failure\n");
5689 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5692 WSASetLastError(0xdeadbeef);
5693 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, &size
, NULL
, NULL
);
5694 ok(!ret
, "expected success\n");
5695 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5696 ok(!size
, "got size %lu\n", size
);
5698 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
) + 1, NULL
, 0, &size
, NULL
, NULL
);
5699 ok(!ret
, "got error %u\n", WSAGetLastError());
5701 output
= VirtualAlloc(NULL
, 4, MEM_RESERVE
| MEM_COMMIT
, PAGE_NOACCESS
);
5702 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
) + 1, output
, 4, &size
, NULL
, NULL
);
5703 ok(!ret
, "got error %u\n", WSAGetLastError());
5704 VirtualFree(output
, 0, MEM_FREE
);
5706 overlapped
.Internal
= 0xdeadbeef;
5707 overlapped
.InternalHigh
= 0xdeadbeef;
5709 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, &size
, &overlapped
, NULL
);
5710 ok(!ret
, "expected success\n");
5711 ok(!size
, "got size %lu\n", size
);
5713 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
5714 ok(ret
, "got error %lu\n", GetLastError());
5715 ok(!size
, "got size %lu\n", size
);
5716 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
5717 ok(!overlapped
.Internal
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
5718 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
5720 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, NULL
, &overlapped
, NULL
);
5721 ok(ret
== -1, "expected failure\n");
5722 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5724 ret
= WSAEventSelect(s
, event
, FD_READ
);
5725 ok(!ret
, "got error %u\n", WSAGetLastError());
5727 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, &size
, NULL
, NULL
);
5728 ok(!ret
, "got error %u\n", WSAGetLastError());
5731 ret
= WSAIoctl(s
, FIONBIO
, &zero
, sizeof(zero
), NULL
, 0, &size
, NULL
, NULL
);
5732 ok(ret
== -1, "expected failure\n");
5733 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
5734 todo_wine
ok(!size
, "got size %lu\n", size
);
5740 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5742 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, NULL
, &overlapped
, socket_apc
);
5743 ok(ret
== -1, "expected failure\n");
5744 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5748 ret
= WSAIoctl(s
, FIONBIO
, &one
, sizeof(one
), NULL
, 0, &size
, &overlapped
, socket_apc
);
5749 ok(!ret
, "expected success\n");
5750 ok(!size
, "got size %lu\n", size
);
5752 ret
= SleepEx(0, TRUE
);
5753 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
5754 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
5755 ok(!apc_error
, "got APC error %lu\n", apc_error
);
5756 ok(!apc_size
, "got APC size %lu\n", apc_size
);
5757 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
5762 static void test_keepalive_vals(void)
5764 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
5765 struct tcp_keepalive kalive
;
5772 sock
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5773 ok(sock
!= INVALID_SOCKET
, "Creating the socket failed: %d\n", WSAGetLastError());
5774 port
= CreateIoCompletionPort((HANDLE
)sock
, NULL
, 123, 0);
5776 WSASetLastError(0xdeadbeef);
5778 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, 0, NULL
, 0, &size
, NULL
, NULL
);
5779 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
5780 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5781 ok(!size
, "got size %lu\n", size
);
5783 WSASetLastError(0xdeadbeef);
5785 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, NULL
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
5786 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
5787 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5788 ok(!size
, "got size %lu\n", size
);
5790 WSASetLastError(0xdeadbeef);
5792 make_keepalive(kalive
, 0, 0, 0);
5793 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
5794 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
5795 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5796 ok(!size
, "got size %lu\n", size
);
5798 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, NULL
, NULL
, NULL
);
5799 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
5800 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5802 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, NULL
, &overlapped
, NULL
);
5803 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
5804 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5806 WSASetLastError(0xdeadbeef);
5808 overlapped
.Internal
= 0xdeadbeef;
5809 overlapped
.InternalHigh
= 0xdeadbeef;
5810 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
) - 1, NULL
, 0, &size
, &overlapped
, NULL
);
5811 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
5812 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5813 ok(size
== 0xdeadbeef, "got size %lu\n", size
);
5814 todo_wine
ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
5815 ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
5817 WSASetLastError(0xdeadbeef);
5819 overlapped
.Internal
= 0xdeadbeef;
5820 overlapped
.InternalHigh
= 0xdeadbeef;
5821 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, &overlapped
, NULL
);
5822 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
5823 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5824 todo_wine
ok(size
== 0xdeadbeef, "got size %lu\n", size
);
5826 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
5827 ok(ret
, "got error %lu\n", GetLastError());
5828 ok(!size
, "got size %lu\n", size
);
5829 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
5830 ok(!overlapped
.Internal
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
5831 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
5833 make_keepalive(kalive
, 1, 0, 0);
5834 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
5835 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
5837 make_keepalive(kalive
, 1, 1000, 1000);
5838 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
5839 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
5841 make_keepalive(kalive
, 1, 10000, 10000);
5842 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
5843 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
5845 make_keepalive(kalive
, 1, 100, 100);
5846 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
5847 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
5849 make_keepalive(kalive
, 0, 100, 100);
5850 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, NULL
, NULL
);
5851 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
5856 sock
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5858 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, NULL
, &overlapped
, socket_apc
);
5859 ok(ret
== -1, "expected failure\n");
5860 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5864 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(kalive
), NULL
, 0, &size
, &overlapped
, socket_apc
);
5865 ok(!ret
, "expected success\n");
5866 ok(!size
, "got size %lu\n", size
);
5868 ret
= SleepEx(0, TRUE
);
5869 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
5870 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
5871 ok(!apc_error
, "got APC error %lu\n", apc_error
);
5872 ok(!apc_size
, "got APC size %lu\n", apc_size
);
5873 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
5878 static void test_unsupported_ioctls(void)
5880 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
5888 static const DWORD codes
[] = {0xdeadbeef, FIOASYNC
, 0x667e, SIO_FLUSH
};
5890 for (i
= 0; i
< ARRAY_SIZE(codes
); ++i
)
5892 winetest_push_context("ioctl %#lx", codes
[i
]);
5893 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5894 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
5896 WSASetLastError(0xdeadbeef);
5897 ret
= WSAIoctl(s
, codes
[i
], NULL
, 0, NULL
, 0, NULL
, &overlapped
, NULL
);
5898 ok(ret
== -1, "expected failure\n");
5899 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5901 WSASetLastError(0xdeadbeef);
5903 ret
= WSAIoctl(s
, codes
[i
], NULL
, 0, NULL
, 0, &size
, NULL
, NULL
);
5904 ok(ret
== -1, "expected failure\n");
5905 ok(WSAGetLastError() == WSAEOPNOTSUPP
, "got error %u\n", WSAGetLastError());
5906 ok(!size
, "got size %lu\n", size
);
5908 WSASetLastError(0xdeadbeef);
5910 overlapped
.Internal
= 0xdeadbeef;
5911 overlapped
.InternalHigh
= 0xdeadbeef;
5912 ret
= WSAIoctl(s
, codes
[i
], NULL
, 0, NULL
, 0, &size
, &overlapped
, NULL
);
5913 ok(ret
== -1, "expected failure\n");
5914 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
5915 ok(size
== 0xdeadbeef, "got size %lu\n", size
);
5917 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
5918 ok(!ret
, "expected failure\n");
5919 ok(GetLastError() == ERROR_NOT_SUPPORTED
, "got error %lu\n", GetLastError());
5920 ok(!size
, "got size %lu\n", size
);
5921 ok(key
== 123, "got key %Iu\n", key
);
5922 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
5923 ok((NTSTATUS
)overlapped
.Internal
== STATUS_NOT_SUPPORTED
,
5924 "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
5925 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
5930 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5932 ret
= WSAIoctl(s
, codes
[i
], NULL
, 0, NULL
, 0, NULL
, &overlapped
, socket_apc
);
5933 ok(ret
== -1, "expected failure\n");
5934 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5938 ret
= WSAIoctl(s
, codes
[i
], NULL
, 0, NULL
, 0, &size
, &overlapped
, socket_apc
);
5939 ok(ret
== -1, "expected failure\n");
5940 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
5941 ok(size
== 0xdeadbeef, "got size %lu\n", size
);
5943 ret
= SleepEx(0, TRUE
);
5944 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
5945 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
5946 ok(apc_error
== WSAEOPNOTSUPP
, "got APC error %lu\n", apc_error
);
5947 ok(!apc_size
, "got APC size %lu\n", apc_size
);
5948 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
5951 winetest_pop_context();
5955 static void test_get_extension_func(void)
5957 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
5958 GUID acceptex_guid
= WSAID_ACCEPTEX
;
5959 GUID bogus_guid
= {0xdeadbeef};
5967 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5968 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
5970 WSASetLastError(0xdeadbeef);
5971 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptex_guid
, sizeof(GUID
),
5972 &func
, sizeof(func
), NULL
, &overlapped
, NULL
);
5973 ok(ret
== -1, "expected failure\n");
5974 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
5976 WSASetLastError(0xdeadbeef);
5978 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptex_guid
, sizeof(GUID
),
5979 &func
, sizeof(func
), &size
, NULL
, NULL
);
5980 ok(!ret
, "expected success\n");
5981 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5982 ok(size
== sizeof(func
), "got size %lu\n", size
);
5984 WSASetLastError(0xdeadbeef);
5986 overlapped
.Internal
= 0xdeadbeef;
5987 overlapped
.InternalHigh
= 0xdeadbeef;
5988 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptex_guid
, sizeof(GUID
),
5989 &func
, sizeof(func
), &size
, &overlapped
, NULL
);
5990 ok(!ret
, "expected success\n");
5991 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5992 ok(size
== sizeof(func
), "got size %lu\n", size
);
5994 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
5995 ok(ret
, "got error %lu\n", GetLastError());
5996 ok(!size
, "got size %lu\n", size
);
5997 ok(key
== 123, "got key %Iu\n", key
);
5998 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
5999 ok(!overlapped
.Internal
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
6000 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
6003 overlapped
.Internal
= 0xdeadbeef;
6004 overlapped
.InternalHigh
= 0xdeadbeef;
6005 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &bogus_guid
, sizeof(GUID
),
6006 &func
, sizeof(func
), &size
, &overlapped
, NULL
);
6007 ok(ret
== -1, "expected failure\n");
6008 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6009 ok(size
== 0xdeadbeef, "got size %lu\n", size
);
6010 ok(overlapped
.Internal
== 0xdeadbeef, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
6011 ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
6013 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
6014 ok(!ret
, "expected failure\n");
6015 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", WSAGetLastError());
6020 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6022 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptex_guid
, sizeof(GUID
),
6023 &func
, sizeof(func
), NULL
, &overlapped
, socket_apc
);
6024 ok(ret
== -1, "expected failure\n");
6025 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
6029 ret
= WSAIoctl(s
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptex_guid
, sizeof(GUID
),
6030 &func
, sizeof(func
), &size
, &overlapped
, socket_apc
);
6031 ok(!ret
, "got error %u\n", WSAGetLastError());
6032 ok(size
== sizeof(func
), "got size %lu\n", size
);
6034 ret
= SleepEx(0, TRUE
);
6035 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
6036 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
6037 ok(!apc_error
, "got APC error %lu\n", apc_error
);
6038 ok(!apc_size
, "got APC size %lu\n", apc_size
);
6039 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
6044 static void test_backlog_query(void)
6046 const struct sockaddr_in addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
6047 GUID acceptex_guid
= WSAID_ACCEPTEX
;
6048 LPFN_ACCEPTEX pAcceptEx
;
6049 struct sockaddr_in destaddr
;
6055 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6056 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6058 ret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptex_guid
, sizeof(acceptex_guid
),
6059 &pAcceptEx
, sizeof(pAcceptEx
), &size
, NULL
, NULL
);
6060 ok(!ret
, "failed to get AcceptEx, error %u\n", WSAGetLastError());
6062 ret
= bind(listener
, (const struct sockaddr
*)&addr
, sizeof(addr
));
6063 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
6064 len
= sizeof(destaddr
);
6065 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &len
);
6066 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
6067 ret
= listen(listener
, 2);
6068 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
6070 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6071 ret
= WSAIoctl(s
, SIO_IDEAL_SEND_BACKLOG_QUERY
, NULL
, 0, &backlog
, sizeof(backlog
), &size
, NULL
, NULL
);
6072 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTCONN
,
6073 "WSAIoctl() failed: %d/%d\n", ret
, WSAGetLastError());
6075 ret
= connect(s
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
6076 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
6077 ret
= WSAIoctl(s
, SIO_IDEAL_SEND_BACKLOG_QUERY
, NULL
, 0, &backlog
, sizeof(backlog
), &size
, NULL
, NULL
);
6078 ok(!ret
, "WSAIoctl() failed: %d\n", WSAGetLastError());
6079 ok(backlog
== 0x10000, "got %08lx\n", backlog
);
6081 closesocket(listener
);
6084 s
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
6087 ret
= WSAIoctl(s
, SIO_IDEAL_SEND_BACKLOG_QUERY
, NULL
, 0, &backlog
, sizeof(backlog
), &size
, NULL
, NULL
);
6088 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEOPNOTSUPP
,
6089 "WSAIoctl() failed: %d/%d\n", ret
, WSAGetLastError());
6093 static void test_base_handle(void)
6095 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
6105 int family
, type
, protocol
;
6109 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
6110 {AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
6111 {AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
},
6112 {AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
},
6115 for (i
= 0; i
< ARRAY_SIZE(tests
); ++i
)
6117 s
= socket(tests
[i
].family
, tests
[i
].type
, tests
[i
].protocol
);
6118 if (s
== INVALID_SOCKET
) continue;
6119 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
6121 WSASetLastError(0xdeadbeef);
6122 ret
= WSAIoctl(s
, SIO_BASE_HANDLE
, NULL
, 0, &base
, sizeof(base
), NULL
, &overlapped
, NULL
);
6123 ok(ret
== -1, "expected failure\n");
6124 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
6126 WSASetLastError(0xdeadbeef);
6129 ret
= WSAIoctl(s
, SIO_BASE_HANDLE
, NULL
, 0, &base
, sizeof(base
), &size
, NULL
, NULL
);
6130 ok(!ret
, "expected success\n");
6131 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
6132 ok(size
== sizeof(base
), "got size %lu\n", size
);
6133 ok(base
== s
, "expected %#Ix, got %#Ix\n", s
, base
);
6135 WSASetLastError(0xdeadbeef);
6138 overlapped
.Internal
= 0xdeadbeef;
6139 overlapped
.InternalHigh
= 0xdeadbeef;
6140 ret
= WSAIoctl(s
, SIO_BASE_HANDLE
, NULL
, 0, &base
, sizeof(base
), &size
, &overlapped
, NULL
);
6141 ok(ret
== -1, "expected failure\n");
6142 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
6143 ok(size
== 0xdeadbeef, "got size %lu\n", size
);
6145 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
6146 ok(!ret
, "expected failure\n");
6147 ok(GetLastError() == ERROR_NOT_SUPPORTED
, "got error %lu\n", GetLastError());
6148 ok(!size
, "got size %lu\n", size
);
6149 ok(key
== 123, "got key %Iu\n", key
);
6150 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
6151 ok((NTSTATUS
)overlapped
.Internal
== STATUS_NOT_SUPPORTED
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
6152 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
6153 ok(base
== 0xdeadbeef, "expected %#Ix, got %#Ix\n", s
, base
);
6158 s
= socket(tests
[i
].family
, tests
[i
].type
, tests
[i
].protocol
);
6160 ret
= WSAIoctl(s
, SIO_BASE_HANDLE
, NULL
, 0, &base
, sizeof(base
), NULL
, &overlapped
, socket_apc
);
6161 ok(ret
== -1, "expected failure\n");
6162 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
6167 ret
= WSAIoctl(s
, SIO_BASE_HANDLE
, NULL
, 0, &base
, sizeof(base
), &size
, &overlapped
, socket_apc
);
6168 ok(ret
== -1, "expected failure\n");
6169 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
6170 ok(size
== 0xdeadbeef, "got size %lu\n", size
);
6172 ret
= SleepEx(0, TRUE
);
6173 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
6174 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
6175 ok(apc_error
== WSAEOPNOTSUPP
, "got APC error %lu\n", apc_error
);
6176 ok(!apc_size
, "got APC size %lu\n", apc_size
);
6177 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
6178 ok(base
== 0xdeadbeef, "expected %#Ix, got %#Ix\n", s
, base
);
6184 static void test_circular_queueing(void)
6190 s
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
6191 ret
= WSAIoctl(s
, SIO_ENABLE_CIRCULAR_QUEUEING
, NULL
, 0, NULL
, 0, &size
, NULL
, NULL
);
6192 ok(!ret
, "expected 0, got %d\n", ret
);
6197 static BOOL drain_pause
= FALSE
;
6198 static DWORD WINAPI
drain_socket_thread(LPVOID arg
)
6201 SOCKET sock
= *(SOCKET
*)arg
;
6204 while ((ret
= recv(sock
, buffer
, sizeof(buffer
), 0)) != 0)
6208 if (WSAGetLastError() == WSAEWOULDBLOCK
)
6212 FD_SET(sock
, &readset
);
6213 select(sock
+1, &readset
, NULL
, NULL
, NULL
);
6224 static void test_send(void)
6226 SOCKET src
= INVALID_SOCKET
;
6227 SOCKET dst
= INVALID_SOCKET
;
6228 HANDLE hThread
= NULL
;
6229 const int buflen
= 1024*1024;
6230 char *buffer
= NULL
;
6231 int ret
, i
, zero
= 0;
6235 DWORD id
, bytes_sent
, dwRet
;
6237 memset(&ov
, 0, sizeof(ov
));
6239 tcp_socketpair(&src
, &dst
);
6241 set_blocking(dst
, FALSE
);
6242 /* force disable buffering so we can get a pending overlapped request */
6243 ret
= setsockopt(dst
, SOL_SOCKET
, SO_SNDBUF
, (char *) &zero
, sizeof(zero
));
6244 ok(!ret
, "setsockopt SO_SNDBUF failed: %d - %ld\n", ret
, GetLastError());
6246 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
6248 buffer
= malloc(buflen
);
6250 /* fill the buffer with some nonsense */
6251 for (i
= 0; i
< buflen
; ++i
)
6253 buffer
[i
] = (char) i
;
6256 ret
= send(src
, buffer
, buflen
, 0);
6257 ok(ret
== buflen
, "send should have sent %d bytes, but it only sent %d\n", buflen
, ret
);
6262 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
6263 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %ld\n", GetLastError());
6268 WSASetLastError(12345);
6269 ret
= WSASend(dst
, &buf
, 1, &bytes_sent
, 0, &ov
, NULL
);
6270 ok(ret
== SOCKET_ERROR
, "expected failure\n");
6271 ok(WSAGetLastError() == ERROR_IO_PENDING
, "wrong error %u\n", WSAGetLastError());
6273 /* don't check for completion yet, we may need to drain the buffer while still sending */
6274 set_blocking(src
, FALSE
);
6275 for (i
= 0; i
< buflen
; ++i
)
6279 ret
= recv(src
, buffer
, 1, 0);
6280 while (ret
== SOCKET_ERROR
&& GetLastError() == WSAEWOULDBLOCK
&& j
< 100)
6284 ret
= recv(src
, buffer
, 1, 0);
6287 ok(ret
== 1, "Failed to receive data %d - %ld (got %d/%d)\n", ret
, GetLastError(), i
, buflen
);
6291 ok(buffer
[0] == (char) i
, "Received bad data at position %d\n", i
);
6294 dwRet
= WaitForSingleObject(ov
.hEvent
, 1000);
6295 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %ld - %ld\n", dwRet
, GetLastError());
6296 if (dwRet
== WAIT_OBJECT_0
)
6298 bret
= GetOverlappedResult((HANDLE
)dst
, &ov
, &bytes_sent
, FALSE
);
6299 ok(bret
&& bytes_sent
== buflen
,
6300 "Got %ld instead of %d (%d - %ld)\n", bytes_sent
, buflen
, bret
, GetLastError());
6303 WSASetLastError(12345);
6304 ret
= WSASend(INVALID_SOCKET
, &buf
, 1, NULL
, 0, &ov
, NULL
);
6305 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
6306 "WSASend failed %d - %d\n", ret
, WSAGetLastError());
6308 WSASetLastError(12345);
6309 ret
= WSASend(dst
, &buf
, 1, NULL
, 0, &ov
, NULL
);
6310 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == ERROR_IO_PENDING
,
6311 "Failed to start overlapped send %d - %d\n", ret
, WSAGetLastError());
6314 if (src
!= INVALID_SOCKET
)
6316 if (dst
!= INVALID_SOCKET
)
6318 if (hThread
!= NULL
)
6320 dwRet
= WaitForSingleObject(hThread
, 500);
6321 ok(dwRet
== WAIT_OBJECT_0
, "failed to wait for thread termination: %ld\n", GetLastError());
6322 CloseHandle(hThread
);
6325 CloseHandle(ov
.hEvent
);
6329 #define WM_SOCKET (WM_USER+100)
6331 struct event_test_ctx
6339 static void select_events(struct event_test_ctx
*ctx
, SOCKET socket
, LONG events
)
6343 if (ctx
->is_message
)
6344 ret
= WSAAsyncSelect(socket
, ctx
->window
, WM_USER
, events
);
6346 ret
= WSAEventSelect(socket
, ctx
->event
, events
);
6347 ok(!ret
, "failed to select, error %u\n", WSAGetLastError());
6348 ctx
->socket
= socket
;
6351 #define check_events(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, FALSE)
6352 #define check_events_todo(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, TRUE)
6353 #define check_events_todo_event(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, FALSE)
6354 #define check_events_todo_msg(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, TRUE)
6355 static void check_events_(int line
, struct event_test_ctx
*ctx
,
6356 LONG flag1
, LONG flag2
, DWORD timeout
, BOOL todo_event
, BOOL todo_msg
)
6360 if (ctx
->is_message
)
6362 BOOL any_fail
= FALSE
;
6367 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
6368 while (!ret
&& !MsgWaitForMultipleObjects(0, NULL
, FALSE
, timeout
, QS_POSTMESSAGE
))
6369 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
6370 todo_wine_if (todo_msg
&& !ret
) ok_(__FILE__
, line
)(ret
, "expected a message\n");
6373 ok_(__FILE__
, line
)(msg
.wParam
== ctx
->socket
,
6374 "expected wparam %#Ix, got %#Ix\n", ctx
->socket
, msg
.wParam
);
6375 todo_wine_if (todo_msg
&& msg
.lParam
!= flag1
)
6376 ok_(__FILE__
, line
)(msg
.lParam
== flag1
, "got first event %#Ix\n", msg
.lParam
);
6377 if (msg
.lParam
!= flag1
) any_fail
= TRUE
;
6384 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
6385 while (!ret
&& !MsgWaitForMultipleObjects(0, NULL
, FALSE
, timeout
, QS_POSTMESSAGE
))
6386 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
6387 ok_(__FILE__
, line
)(ret
, "expected a message\n");
6388 ok_(__FILE__
, line
)(msg
.wParam
== ctx
->socket
, "got wparam %#Ix\n", msg
.wParam
);
6389 todo_wine_if (todo_msg
) ok_(__FILE__
, line
)(msg
.lParam
== flag2
, "got second event %#Ix\n", msg
.lParam
);
6391 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
6392 todo_wine_if (todo_msg
&& ret
) ok_(__FILE__
, line
)(!ret
, "got unexpected event %#Ix\n", msg
.lParam
);
6393 if (ret
) any_fail
= TRUE
;
6395 /* catch tests which succeed */
6396 todo_wine_if (todo_msg
) ok_(__FILE__
, line
)(!any_fail
, "event series matches\n");
6400 WSANETWORKEVENTS events
;
6403 memset(&events
, 0xcc, sizeof(events
));
6404 ret
= WaitForSingleObject(ctx
->event
, timeout
);
6406 todo_wine_if (todo_event
&& ret
) ok_(__FILE__
, line
)(!ret
, "event wait timed out\n");
6408 todo_wine_if (todo_event
) ok_(__FILE__
, line
)(ret
== WAIT_TIMEOUT
, "expected timeout\n");
6409 ret
= WSAEnumNetworkEvents(ctx
->socket
, ctx
->event
, &events
);
6410 ok_(__FILE__
, line
)(!ret
, "failed to get events, error %u\n", WSAGetLastError());
6411 todo_wine_if (todo_event
)
6412 ok_(__FILE__
, line
)(events
.lNetworkEvents
== LOWORD(flag1
| flag2
), "got events %#lx\n", events
.lNetworkEvents
);
6413 for (i
= 0; i
< ARRAY_SIZE(events
.iErrorCode
); ++i
)
6415 if ((1u << i
) == LOWORD(flag1
) && (events
.lNetworkEvents
& LOWORD(flag1
)))
6416 ok_(__FILE__
, line
)(events
.iErrorCode
[i
] == HIWORD(flag1
),
6417 "got error code %d for event %#x\n", events
.iErrorCode
[i
], 1u << i
);
6418 if ((1u << i
) == LOWORD(flag2
) && (events
.lNetworkEvents
& LOWORD(flag2
)))
6419 ok_(__FILE__
, line
)(events
.iErrorCode
[i
] == HIWORD(flag2
),
6420 "got error code %d for event %#x\n", events
.iErrorCode
[i
], 1u << i
);
6425 static void test_accept_events(struct event_test_ctx
*ctx
)
6427 const struct sockaddr_in addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
6428 SOCKET listener
, server
, client
, client2
;
6429 GUID acceptex_guid
= WSAID_ACCEPTEX
;
6430 struct sockaddr_in destaddr
;
6431 OVERLAPPED overlapped
= {0};
6432 LPFN_ACCEPTEX pAcceptEx
;
6437 overlapped
.hEvent
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
6439 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6440 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6442 ret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptex_guid
, sizeof(acceptex_guid
),
6443 &pAcceptEx
, sizeof(pAcceptEx
), &size
, NULL
, NULL
);
6444 ok(!ret
, "failed to get AcceptEx, error %u\n", WSAGetLastError());
6446 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
6448 ret
= bind(listener
, (const struct sockaddr
*)&addr
, sizeof(addr
));
6449 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
6450 len
= sizeof(destaddr
);
6451 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &len
);
6452 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
6453 ret
= listen(listener
, 2);
6454 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
6456 check_events(ctx
, 0, 0, 0);
6458 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6459 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6460 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
6461 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
6463 check_events(ctx
, FD_ACCEPT
, 0, 200);
6464 check_events(ctx
, 0, 0, 0);
6465 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
6466 if (ctx
->is_message
)
6467 check_events(ctx
, FD_ACCEPT
, 0, 200);
6468 check_events(ctx
, 0, 0, 0);
6469 select_events(ctx
, listener
, 0);
6470 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
6471 if (ctx
->is_message
)
6472 check_events(ctx
, FD_ACCEPT
, 0, 200);
6473 check_events(ctx
, 0, 0, 0);
6475 client2
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6476 ok(client2
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6477 ret
= connect(client2
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
6478 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
6480 if (!ctx
->is_message
)
6481 check_events_todo(ctx
, FD_ACCEPT
, 0, 200);
6482 check_events(ctx
, 0, 0, 0);
6484 server
= accept(listener
, NULL
, NULL
);
6485 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
6486 closesocket(server
);
6488 check_events(ctx
, FD_ACCEPT
, 0, 200);
6489 check_events(ctx
, 0, 0, 0);
6491 server
= accept(listener
, NULL
, NULL
);
6492 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
6493 closesocket(server
);
6495 check_events(ctx
, 0, 0, 0);
6497 closesocket(client2
);
6498 closesocket(client
);
6500 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6501 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6502 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
6503 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
6505 check_events(ctx
, FD_ACCEPT
, 0, 200);
6507 server
= accept(listener
, NULL
, NULL
);
6508 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
6509 closesocket(server
);
6510 closesocket(client
);
6512 check_events(ctx
, 0, 0, 200);
6514 closesocket(listener
);
6516 /* Connect and then select. */
6518 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6519 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6520 ret
= bind(listener
, (const struct sockaddr
*)&addr
, sizeof(addr
));
6521 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
6522 len
= sizeof(destaddr
);
6523 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &len
);
6524 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
6525 ret
= listen(listener
, 2);
6526 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
6528 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6529 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6530 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
6531 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
6533 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
6535 check_events(ctx
, FD_ACCEPT
, 0, 200);
6537 server
= accept(listener
, NULL
, NULL
);
6538 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
6539 closesocket(server
);
6540 closesocket(client
);
6542 /* As above, but select on a subset containing FD_ACCEPT first. */
6544 if (!ctx
->is_message
)
6546 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
6548 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6549 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6550 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
6551 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
6553 ret
= WaitForSingleObject(ctx
->event
, 200);
6554 ok(!ret
, "wait timed out\n");
6556 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
);
6557 ret
= WaitForSingleObject(ctx
->event
, 0);
6558 ok(!ret
, "wait timed out\n");
6560 ResetEvent(ctx
->event
);
6562 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
);
6563 ret
= WaitForSingleObject(ctx
->event
, 0);
6564 ok(ret
== WAIT_TIMEOUT
, "expected timeout\n");
6566 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
6567 ret
= WaitForSingleObject(ctx
->event
, 0);
6568 ok(!ret
, "wait timed out\n");
6569 check_events(ctx
, FD_ACCEPT
, 0, 0);
6571 server
= accept(listener
, NULL
, NULL
);
6572 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
6573 closesocket(server
);
6574 closesocket(client
);
6577 /* As above, but select on a subset not containing FD_ACCEPT first. */
6579 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
);
6581 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6582 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6583 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
6584 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
6586 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
6587 check_events(ctx
, FD_ACCEPT
, 0, 200);
6589 server
= accept(listener
, NULL
, NULL
);
6590 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
6591 closesocket(server
);
6592 closesocket(client
);
6594 /* As above, but call accept() before selecting. */
6596 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
);
6598 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6599 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6600 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
6601 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
6603 server
= accept(listener
, NULL
, NULL
);
6604 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
6606 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
6607 check_events(ctx
, 0, 0, 200);
6609 closesocket(server
);
6610 closesocket(client
);
6612 closesocket(listener
);
6614 /* The socket returned from accept() inherits the same parameters. */
6616 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6617 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6618 ret
= bind(listener
, (const struct sockaddr
*)&addr
, sizeof(addr
));
6619 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
6620 len
= sizeof(destaddr
);
6621 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &len
);
6622 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
6623 ret
= listen(listener
, 2);
6624 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
6626 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6627 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6628 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
6629 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
6631 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
| FD_WRITE
);
6632 check_events(ctx
, FD_ACCEPT
, 0, 200);
6634 server
= accept(listener
, NULL
, NULL
);
6635 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
6636 ctx
->socket
= server
;
6637 check_events(ctx
, FD_WRITE
, 0, 200);
6638 check_events(ctx
, 0, 0, 0);
6640 closesocket(server
);
6641 closesocket(client
);
6643 /* Connect while there is a pending AcceptEx(). */
6645 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
6647 server
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6648 ret
= pAcceptEx(listener
, server
, buffer
, 0, 0, sizeof(buffer
), NULL
, &overlapped
);
6649 ok(!ret
, "got %d\n", ret
);
6650 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
6652 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6653 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
6654 ok(!ret
, "got error %u\n", WSAGetLastError());
6656 ret
= WaitForSingleObject(overlapped
.hEvent
, 200);
6657 ok(!ret
, "got %d\n", ret
);
6658 ret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &size
, FALSE
);
6659 ok(ret
, "got error %lu\n", GetLastError());
6660 ok(!size
, "got size %lu\n", size
);
6662 check_events(ctx
, 0, 0, 0);
6664 closesocket(server
);
6665 closesocket(client
);
6667 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6668 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
6669 ok(!ret
, "got error %u\n", WSAGetLastError());
6671 check_events(ctx
, FD_ACCEPT
, 0, 200);
6672 check_events(ctx
, 0, 0, 0);
6674 server
= accept(listener
, NULL
, NULL
);
6675 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
6676 closesocket(server
);
6677 closesocket(client
);
6679 closesocket(listener
);
6680 CloseHandle(overlapped
.hEvent
);
6683 static void test_connect_events(struct event_test_ctx
*ctx
)
6685 const struct sockaddr_in addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
6686 SOCKET listener
, server
, client
;
6687 struct sockaddr_in destaddr
;
6690 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6691 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6692 ret
= bind(listener
, (const struct sockaddr
*)&addr
, sizeof(addr
));
6693 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
6694 len
= sizeof(destaddr
);
6695 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &len
);
6696 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
6697 ret
= listen(listener
, 2);
6698 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
6700 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6701 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6703 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
6704 check_events(ctx
, 0, 0, 0);
6706 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
6707 ok(!ret
|| WSAGetLastError() == WSAEWOULDBLOCK
, "failed to connect, error %u\n", WSAGetLastError());
6709 check_events(ctx
, FD_CONNECT
, FD_WRITE
, 200);
6710 check_events(ctx
, 0, 0, 0);
6711 select_events(ctx
, client
, 0);
6712 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
6713 if (ctx
->is_message
)
6714 check_events(ctx
, FD_WRITE
, 0, 200);
6715 check_events(ctx
, 0, 0, 0);
6717 server
= accept(listener
, NULL
, NULL
);
6718 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
6720 select_events(ctx
, server
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
6721 check_events(ctx
, FD_WRITE
, 0, 200);
6723 closesocket(client
);
6724 closesocket(server
);
6726 /* Connect and then select. */
6728 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6729 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6731 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
6732 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
6734 server
= accept(listener
, NULL
, NULL
);
6735 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
6737 ret
= send(client
, "data", 5, 0);
6738 ok(ret
== 5, "got %d\n", ret
);
6740 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
6741 if (ctx
->is_message
)
6742 check_events(ctx
, FD_WRITE
, 0, 200);
6744 check_events(ctx
, FD_CONNECT
, FD_WRITE
, 200);
6746 closesocket(client
);
6747 closesocket(server
);
6749 /* As above, but select on a subset not containing FD_CONNECT first. */
6751 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6752 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6754 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_OOB
| FD_READ
| FD_WRITE
);
6756 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
6757 ok(!ret
|| WSAGetLastError() == WSAEWOULDBLOCK
, "failed to connect, error %u\n", WSAGetLastError());
6759 server
= accept(listener
, NULL
, NULL
);
6760 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
6762 check_events(ctx
, FD_WRITE
, 0, 200);
6764 select_events(ctx
, client
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
6766 if (ctx
->is_message
)
6767 check_events(ctx
, FD_WRITE
, 0, 200);
6769 check_events(ctx
, FD_CONNECT
, 0, 200);
6771 closesocket(client
);
6772 closesocket(server
);
6774 /* Test with UDP sockets. */
6776 client
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
6777 server
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
6779 select_events(ctx
, client
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
6780 if (ctx
->is_message
)
6781 check_events(ctx
, FD_WRITE
, 0, 200);
6782 check_events_todo_event(ctx
, 0, 0, 0);
6784 ret
= bind(server
, (const struct sockaddr
*)&addr
, sizeof(addr
));
6785 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
6786 len
= sizeof(destaddr
);
6787 ret
= getsockname(server
, (struct sockaddr
*)&destaddr
, &len
);
6788 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
6789 ret
= connect(client
, (struct sockaddr
*)&addr
, sizeof(addr
));
6790 ok(!ret
, "got error %lu\n", GetLastError());
6792 if (ctx
->is_message
)
6793 check_events_todo(ctx
, FD_WRITE
, 0, 200);
6795 check_events_todo(ctx
, FD_CONNECT
, FD_WRITE
, 200);
6796 check_events(ctx
, 0, 0, 0);
6798 closesocket(client
);
6799 closesocket(server
);
6801 closesocket(listener
);
6804 /* perform a blocking recv() even on a nonblocking socket */
6805 static int sync_recv(SOCKET s
, void *buffer
, int len
, DWORD flags
)
6807 OVERLAPPED overlapped
= {0};
6812 overlapped
.hEvent
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
6813 wsabuf
.buf
= buffer
;
6815 ret
= WSARecv(s
, &wsabuf
, 1, &ret_len
, &flags
, &overlapped
, NULL
);
6816 if (ret
== -1 && WSAGetLastError() == ERROR_IO_PENDING
)
6818 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6819 ok(!ret
, "wait timed out\n");
6820 ret
= WSAGetOverlappedResult(s
, &overlapped
, &ret_len
, FALSE
, &flags
);
6821 ret
= (ret
? 0 : -1);
6823 CloseHandle(overlapped
.hEvent
);
6824 if (!ret
) return ret_len
;
6828 static void test_write_events(struct event_test_ctx
*ctx
)
6830 static const int buffer_size
= 1024 * 1024;
6831 SOCKET server
, client
;
6835 buffer
= malloc(buffer_size
);
6837 tcp_socketpair(&client
, &server
);
6838 set_blocking(client
, FALSE
);
6840 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
6841 check_events(ctx
, FD_WRITE
, 0, 200);
6842 check_events(ctx
, 0, 0, 0);
6843 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
6844 if (ctx
->is_message
)
6845 check_events(ctx
, FD_WRITE
, 0, 200);
6846 check_events(ctx
, 0, 0, 0);
6847 select_events(ctx
, server
, 0);
6848 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
6849 if (ctx
->is_message
)
6850 check_events(ctx
, FD_WRITE
, 0, 200);
6851 check_events(ctx
, 0, 0, 0);
6853 ret
= send(server
, "data", 5, 0);
6854 ok(ret
== 5, "got %d\n", ret
);
6856 check_events(ctx
, 0, 0, 0);
6858 ret
= sync_recv(client
, buffer
, buffer_size
, 0);
6859 ok(ret
== 5, "got %d\n", ret
);
6861 check_events(ctx
, 0, 0, 0);
6865 /* Windows will never send less than buffer_size bytes here, but Linux
6866 * may do a short write. */
6867 while ((ret
= send(server
, buffer
, buffer_size
, 0)) > 0);
6868 ok(ret
== -1, "got %d\n", ret
);
6869 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
6871 while (recv(client
, buffer
, buffer_size
, 0) > 0);
6872 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
6874 /* Broken on Windows versions older than win10v1607 (though sometimes
6875 * works regardless, for unclear reasons. */
6876 check_events(ctx
, FD_WRITE
, 0, 200);
6877 check_events(ctx
, 0, 0, 0);
6878 select_events(ctx
, server
, 0);
6879 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
6880 if (ctx
->is_message
)
6881 check_events(ctx
, FD_WRITE
, 0, 200);
6882 check_events(ctx
, 0, 0, 0);
6885 closesocket(server
);
6886 closesocket(client
);
6888 /* Select on a subset not containing FD_WRITE first. */
6890 tcp_socketpair(&client
, &server
);
6891 set_blocking(client
, FALSE
);
6893 ret
= send(client
, "data", 5, 0);
6894 ok(ret
== 5, "got %d\n", ret
);
6896 select_events(ctx
, client
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
);
6897 if (!ctx
->is_message
)
6898 check_events(ctx
, FD_CONNECT
, 0, 200);
6899 check_events(ctx
, 0, 0, 0);
6901 select_events(ctx
, client
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
6902 check_events(ctx
, FD_WRITE
, 0, 200);
6903 check_events(ctx
, 0, 0, 0);
6905 closesocket(client
);
6906 closesocket(server
);
6908 /* Despite the documentation, and unlike FD_ACCEPT and FD_RECV, calling
6909 * send() doesn't clear the FD_WRITE bit. */
6911 tcp_socketpair(&client
, &server
);
6913 select_events(ctx
, server
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
6915 ret
= send(server
, "data", 5, 0);
6916 ok(ret
== 5, "got %d\n", ret
);
6918 check_events(ctx
, FD_WRITE
, 0, 200);
6920 closesocket(server
);
6921 closesocket(client
);
6926 static void test_read_events(struct event_test_ctx
*ctx
)
6928 OVERLAPPED overlapped
= {0};
6929 SOCKET server
, client
;
6930 DWORD size
, flags
= 0;
6938 overlapped
.hEvent
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
6940 tcp_socketpair(&client
, &server
);
6941 set_blocking(client
, FALSE
);
6943 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
6944 check_events(ctx
, 0, 0, 0);
6946 ret
= send(client
, "data", 5, 0);
6947 ok(ret
== 5, "got %d\n", ret
);
6949 check_events(ctx
, FD_READ
, 0, 200);
6950 check_events(ctx
, 0, 0, 0);
6951 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
6952 if (ctx
->is_message
)
6953 check_events(ctx
, FD_READ
, 0, 200);
6954 check_events(ctx
, 0, 0, 0);
6955 select_events(ctx
, server
, 0);
6956 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
6957 if (ctx
->is_message
)
6958 check_events(ctx
, FD_READ
, 0, 200);
6959 check_events(ctx
, 0, 0, 0);
6961 ret
= send(client
, "data", 5, 0);
6962 ok(ret
== 5, "got %d\n", ret
);
6964 if (!ctx
->is_message
)
6965 check_events_todo(ctx
, FD_READ
, 0, 200);
6966 check_events(ctx
, 0, 0, 0);
6968 ret
= recv(server
, buffer
, 2, 0);
6969 ok(ret
== 2, "got %d\n", ret
);
6971 check_events(ctx
, FD_READ
, 0, 200);
6972 check_events(ctx
, 0, 0, 0);
6974 ret
= recv(server
, buffer
, -1, 0);
6975 ok(ret
== -1, "got %d\n", ret
);
6976 ok(WSAGetLastError() == WSAEFAULT
|| WSAGetLastError() == WSAENOBUFS
/* < Windows 7 */,
6977 "got error %u\n", WSAGetLastError());
6979 if (ctx
->is_message
)
6980 check_events_todo_msg(ctx
, FD_READ
, 0, 200);
6981 check_events(ctx
, 0, 0, 0);
6983 for (i
= 0; i
< 8; ++i
)
6985 ret
= sync_recv(server
, buffer
, 1, 0);
6986 ok(ret
== 1, "got %d\n", ret
);
6989 check_events(ctx
, FD_READ
, 0, 200);
6990 check_events(ctx
, 0, 0, 0);
6993 /* Send data while we're not selecting. */
6995 select_events(ctx
, server
, 0);
6996 ret
= send(client
, "data", 5, 0);
6997 ok(ret
== 5, "got %d\n", ret
);
6998 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
7000 check_events(ctx
, FD_READ
, 0, 200);
7002 ret
= recv(server
, buffer
, 5, 0);
7003 ok(ret
== 5, "got %d\n", ret
);
7005 select_events(ctx
, server
, 0);
7006 ret
= send(client
, "data", 5, 0);
7007 ok(ret
== 5, "got %d\n", ret
);
7008 ret
= sync_recv(server
, buffer
, 5, 0);
7009 ok(ret
== 5, "got %d\n", ret
);
7010 select_events(ctx
, server
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
);
7012 check_events(ctx
, 0, 0, 200);
7014 /* Send data while we're polling for data but not selecting for FD_READ. */
7017 pollfd
.events
= POLLIN
;
7018 thread
= CreateThread(NULL
, 0, poll_async_thread
, &pollfd
, 0, NULL
);
7020 select_events(ctx
, server
, 0);
7021 ret
= send(client
, "data", 5, 0);
7022 ok(ret
== 5, "got %d\n", ret
);
7024 ret
= WaitForSingleObject(thread
, 1000);
7025 ok(!ret
, "wait timed out\n");
7026 CloseHandle(thread
);
7028 /* And check events, to show that WSAEnumNetworkEvents() should not clear
7029 * events we are not currently selecting for. */
7030 check_events(ctx
, 0, 0, 0);
7032 select_events(ctx
, server
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
7033 check_events(ctx
, FD_READ
, FD_WRITE
, 200);
7034 check_events(ctx
, 0, 0, 0);
7036 ret
= sync_recv(server
, buffer
, 5, 0);
7037 ok(ret
== 5, "got %d\n", ret
);
7039 /* Send data while there is a pending WSARecv(). */
7041 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
7043 wsabuf
.buf
= buffer
;
7045 ret
= WSARecv(server
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
7046 ok(ret
== -1, "got %d\n", ret
);
7047 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
7049 ret
= send(client
, "a", 1, 0);
7050 ok(ret
== 1, "got %d\n", ret
);
7052 ret
= WaitForSingleObject(overlapped
.hEvent
, 200);
7053 ok(!ret
, "got %d\n", ret
);
7054 ret
= GetOverlappedResult((HANDLE
)server
, &overlapped
, &size
, FALSE
);
7055 ok(ret
, "got error %lu\n", GetLastError());
7056 ok(size
== 1, "got size %lu\n", size
);
7058 check_events(ctx
, 0, 0, 0);
7060 ret
= send(client
, "a", 1, 0);
7061 ok(ret
== 1, "got %d\n", ret
);
7063 check_events(ctx
, FD_READ
, 0, 200);
7064 check_events(ctx
, 0, 0, 0);
7066 closesocket(server
);
7067 closesocket(client
);
7068 CloseHandle(overlapped
.hEvent
);
7071 static void test_oob_events(struct event_test_ctx
*ctx
)
7073 SOCKET server
, client
;
7077 tcp_socketpair(&client
, &server
);
7078 set_blocking(client
, FALSE
);
7080 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
7081 check_events(ctx
, 0, 0, 0);
7083 ret
= send(client
, "a", 1, MSG_OOB
);
7084 ok(ret
== 1, "got %d\n", ret
);
7086 check_events(ctx
, FD_OOB
, 0, 200);
7087 check_events(ctx
, 0, 0, 0);
7088 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
7089 if (ctx
->is_message
)
7090 check_events(ctx
, FD_OOB
, 0, 200);
7091 check_events(ctx
, 0, 0, 0);
7092 select_events(ctx
, server
, 0);
7093 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
7094 if (ctx
->is_message
)
7095 check_events(ctx
, FD_OOB
, 0, 200);
7096 check_events(ctx
, 0, 0, 0);
7098 ret
= send(client
, "b", 1, MSG_OOB
);
7099 ok(ret
== 1, "got %d\n", ret
);
7101 if (!ctx
->is_message
)
7102 check_events_todo_event(ctx
, FD_OOB
, 0, 200);
7103 check_events(ctx
, 0, 0, 0);
7105 ret
= recv(server
, buffer
, 1, MSG_OOB
);
7106 ok(ret
== 1, "got %d\n", ret
);
7108 check_events_todo(ctx
, FD_OOB
, 0, 200);
7109 check_events(ctx
, 0, 0, 0);
7111 ret
= recv(server
, buffer
, 1, MSG_OOB
);
7112 todo_wine
ok(ret
== 1, "got %d\n", ret
);
7114 check_events(ctx
, 0, 0, 0);
7116 /* Send data while we're not selecting. */
7118 select_events(ctx
, server
, 0);
7119 ret
= send(client
, "a", 1, MSG_OOB
);
7120 ok(ret
== 1, "got %d\n", ret
);
7121 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
7123 check_events(ctx
, FD_OOB
, 0, 200);
7125 ret
= recv(server
, buffer
, 1, MSG_OOB
);
7126 ok(ret
== 1, "got %d\n", ret
);
7128 closesocket(server
);
7129 closesocket(client
);
7132 static void test_close_events(struct event_test_ctx
*ctx
)
7134 SOCKET server
, client
;
7138 /* Test closesocket(). */
7140 tcp_socketpair(&client
, &server
);
7142 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
7144 closesocket(client
);
7146 check_events(ctx
, FD_CLOSE
, 0, 1000);
7147 check_events(ctx
, 0, 0, 0);
7148 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
7149 if (ctx
->is_message
)
7150 check_events(ctx
, FD_CLOSE
, 0, 200);
7151 check_events(ctx
, 0, 0, 0);
7152 select_events(ctx
, server
, 0);
7153 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
7154 if (ctx
->is_message
)
7155 check_events(ctx
, FD_CLOSE
, 0, 200);
7156 check_events(ctx
, 0, 0, 0);
7158 ret
= recv(server
, buffer
, 5, 0);
7159 ok(!ret
, "got %d\n", ret
);
7161 check_events(ctx
, 0, 0, 0);
7163 closesocket(server
);
7165 /* Test shutdown(remote end, SD_SEND). */
7167 tcp_socketpair(&client
, &server
);
7169 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
7171 shutdown(client
, SD_SEND
);
7173 check_events(ctx
, FD_CLOSE
, 0, 1000);
7174 check_events(ctx
, 0, 0, 0);
7176 closesocket(client
);
7178 check_events(ctx
, 0, 0, 0);
7180 closesocket(server
);
7182 /* No other shutdown() call generates an event. */
7184 tcp_socketpair(&client
, &server
);
7186 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
7188 shutdown(client
, SD_RECEIVE
);
7189 shutdown(server
, SD_BOTH
);
7191 check_events(ctx
, 0, 0, 200);
7193 shutdown(client
, SD_SEND
);
7195 check_events_todo(ctx
, FD_CLOSE
, 0, 200);
7196 check_events(ctx
, 0, 0, 0);
7198 closesocket(server
);
7199 closesocket(client
);
7201 /* Test sending data before calling closesocket(). */
7203 tcp_socketpair(&client
, &server
);
7205 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
7207 ret
= send(client
, "data", 5, 0);
7208 ok(ret
== 5, "got %d\n", ret
);
7210 check_events(ctx
, FD_READ
, 0, 200);
7212 closesocket(client
);
7214 check_events_todo(ctx
, FD_CLOSE
, 0, 200);
7216 ret
= recv(server
, buffer
, 3, 0);
7217 ok(ret
== 3, "got %d\n", ret
);
7219 check_events(ctx
, FD_READ
, 0, 200);
7221 ret
= recv(server
, buffer
, 5, 0);
7222 ok(ret
== 2, "got %d\n", ret
);
7224 check_events_todo(ctx
, 0, 0, !strcmp(winetest_platform
, "wine") ? 200 : 0);
7226 closesocket(server
);
7228 /* Close and then select. */
7230 tcp_socketpair(&client
, &server
);
7231 closesocket(client
);
7233 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
7234 check_events(ctx
, FD_CLOSE
, 0, 200);
7236 closesocket(server
);
7238 /* As above, but select on a subset not containing FD_CLOSE first. */
7240 tcp_socketpair(&client
, &server
);
7242 select_events(ctx
, server
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
);
7244 closesocket(client
);
7246 check_events(ctx
, 0, 0, 200);
7247 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
7248 check_events(ctx
, FD_CLOSE
, 0, 200);
7250 closesocket(server
);
7254 tcp_socketpair(&client
, &server
);
7256 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
7258 close_with_rst(client
);
7260 check_events(ctx
, MAKELONG(FD_CLOSE
, WSAECONNABORTED
), 0, 200);
7261 check_events(ctx
, 0, 0, 0);
7262 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
7263 if (ctx
->is_message
)
7264 check_events_todo(ctx
, MAKELONG(FD_CLOSE
, WSAECONNABORTED
), 0, 200);
7265 check_events(ctx
, 0, 0, 0);
7266 select_events(ctx
, server
, 0);
7267 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
7268 if (ctx
->is_message
)
7269 check_events_todo(ctx
, MAKELONG(FD_CLOSE
, WSAECONNABORTED
), 0, 200);
7270 check_events(ctx
, 0, 0, 0);
7272 closesocket(server
);
7275 static void test_events(void)
7277 struct event_test_ctx ctx
;
7279 ctx
.is_message
= FALSE
;
7280 ctx
.event
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
7282 test_accept_events(&ctx
);
7283 test_connect_events(&ctx
);
7284 test_write_events(&ctx
);
7285 test_read_events(&ctx
);
7286 test_close_events(&ctx
);
7287 test_oob_events(&ctx
);
7289 CloseHandle(ctx
.event
);
7291 ctx
.is_message
= TRUE
;
7292 ctx
.window
= CreateWindowA("Message", NULL
, 0, 0, 0, 0, 0, HWND_MESSAGE
, NULL
, NULL
, NULL
);
7294 test_accept_events(&ctx
);
7295 test_connect_events(&ctx
);
7296 test_write_events(&ctx
);
7297 test_read_events(&ctx
);
7298 test_close_events(&ctx
);
7299 test_oob_events(&ctx
);
7301 DestroyWindow(ctx
.window
);
7304 static void test_ipv6only(void)
7306 SOCKET v4
= INVALID_SOCKET
, v6
;
7307 struct sockaddr_in sin4
;
7308 struct sockaddr_in6 sin6
;
7309 int ret
, enabled
, len
= sizeof(enabled
);
7311 memset(&sin4
, 0, sizeof(sin4
));
7312 sin4
.sin_family
= AF_INET
;
7313 sin4
.sin_port
= htons(SERVERPORT
);
7315 memset(&sin6
, 0, sizeof(sin6
));
7316 sin6
.sin6_family
= AF_INET6
;
7317 sin6
.sin6_port
= htons(SERVERPORT
);
7319 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
7320 if (v6
== INVALID_SOCKET
)
7322 skip("Could not create IPv6 socket (LastError: %d)\n", WSAGetLastError());
7327 ret
= getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
7328 ok(!ret
, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7329 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
7331 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
7332 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
7334 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
7335 ok(v4
!= INVALID_SOCKET
, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
7339 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
7340 ok(!ret
, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7341 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
7345 len
= sizeof(enabled
);
7346 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
7347 ok(!ret
, "setsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7351 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
7352 ok(!ret
, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7353 ok(!enabled
, "expected 0, got %d\n", enabled
);
7357 len
= sizeof(enabled
);
7358 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
7359 ok(!ret
, "setsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7361 /* bind on IPv4 socket should succeed - IPV6_V6ONLY is enabled by default */
7362 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
7363 ok(!ret
, "Could not bind IPv4 address (LastError: %d)\n", WSAGetLastError());
7367 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
7368 ok(!ret
, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7369 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
7373 len
= sizeof(enabled
);
7374 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
7375 ok(ret
, "setsockopt(IPV6_V6ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
7379 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
7380 ok(!ret
, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7381 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
7385 len
= sizeof(enabled
);
7386 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
7387 ok(ret
, "setsockopt(IPV6_V6ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
7392 /* Test again, this time disabling IPV6_V6ONLY. */
7393 sin4
.sin_port
= htons(SERVERPORT
+2);
7394 sin6
.sin6_port
= htons(SERVERPORT
+2);
7396 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
7397 ok(v6
!= INVALID_SOCKET
, "Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
7398 WSAGetLastError(), WSAEAFNOSUPPORT
);
7401 ret
= setsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
7402 ok(!ret
, "Could not disable IPV6_V6ONLY (LastError: %d).\n", WSAGetLastError());
7405 ret
= getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
7406 ok(!ret
, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7407 ok(!enabled
, "expected 0, got %d\n", enabled
);
7411 On Windows, bind on both IPv4 and IPv6 with IPV6_V6ONLY disabled succeeds by default.
7412 Application must set SO_EXCLUSIVEADDRUSE on first socket to disallow another successful bind.
7413 In general, a standard application should not use SO_REUSEADDR.
7414 Setting both SO_EXCLUSIVEADDRUSE and SO_REUSEADDR on the same socket is not possible in
7415 either order, the later setsockopt call always fails.
7418 ret
= setsockopt(v6
, SOL_SOCKET
, SO_EXCLUSIVEADDRUSE
, (char*)&enabled
, len
);
7419 ok(!ret
, "Could not set SO_EXCLUSIVEADDRUSE on IPv6 socket (LastError: %d)\n", WSAGetLastError());
7421 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
7422 ok(!ret
, "Could not bind IPv6 address (LastError: %d)\n", WSAGetLastError());
7425 len
= sizeof(enabled
);
7426 getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
7427 ok(!ret
, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7428 ok(!enabled
, "IPV6_V6ONLY is enabled after bind\n");
7430 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
7431 ok(v4
!= INVALID_SOCKET
, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
7434 ret
= setsockopt(v4
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&enabled
, len
);
7435 ok(!ret
, "Could not set SO_REUSEADDR on IPv4 socket (LastError: %d)\n", WSAGetLastError());
7437 WSASetLastError(0xdeadbeef);
7438 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
7439 ok(ret
, "bind succeeded unexpectedly for the IPv4 socket\n");
7440 ok(WSAGetLastError() == WSAEACCES
, "Expected 10013, got %d\n", WSAGetLastError());
7443 if (v4
!= INVALID_SOCKET
)
7445 if (v6
!= INVALID_SOCKET
)
7449 static void test_WSASendMsg(void)
7452 struct sockaddr_in sendaddr
, sockaddr
;
7453 GUID WSASendMsg_GUID
= WSAID_WSASENDMSG
;
7454 LPFN_WSASENDMSG pWSASendMsg
= NULL
;
7455 char teststr
[12] = "hello world", buffer
[32];
7458 DWORD bytesSent
, err
;
7461 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
7463 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
7464 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
7466 /* Obtain the WSASendMsg function */
7467 WSAIoctl(sock
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSASendMsg_GUID
, sizeof(WSASendMsg_GUID
),
7468 &pWSASendMsg
, sizeof(pWSASendMsg
), &err
, NULL
, NULL
);
7472 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
7476 /* fake address for now */
7477 sendaddr
.sin_family
= AF_INET
;
7478 sendaddr
.sin_port
= htons(139);
7479 sendaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7481 memset(&msg
, 0, sizeof(msg
));
7482 iovec
[0].buf
= teststr
;
7483 iovec
[0].len
= sizeof(teststr
);
7484 iovec
[1].buf
= teststr
;
7485 iovec
[1].len
= sizeof(teststr
) / 2;
7486 msg
.name
= (struct sockaddr
*) &sendaddr
;
7487 msg
.namelen
= sizeof(sendaddr
);
7488 msg
.lpBuffers
= iovec
;
7489 msg
.dwBufferCount
= 1; /* send only one buffer for now */
7491 WSASetLastError(0xdeadbeef);
7492 ret
= pWSASendMsg(INVALID_SOCKET
, &msg
, 0, NULL
, NULL
, NULL
);
7493 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
7494 err
= WSAGetLastError();
7495 ok(err
== WSAENOTSOCK
, "expected 10038, got %ld instead\n", err
);
7497 WSASetLastError(0xdeadbeef);
7498 ret
= pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
);
7499 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
7500 err
= WSAGetLastError();
7501 ok(err
== WSAEFAULT
, "expected 10014, got %ld instead\n", err
);
7503 WSASetLastError(0xdeadbeef);
7504 ret
= pWSASendMsg(sock
, NULL
, 0, &bytesSent
, NULL
, NULL
);
7505 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
7506 err
= WSAGetLastError();
7507 ok(err
== WSAEFAULT
, "expected 10014, got %ld instead\n", err
);
7509 WSASetLastError(0xdeadbeef);
7510 ret
= pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
);
7511 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
7512 err
= WSAGetLastError();
7513 ok(err
== WSAEFAULT
, "expected 10014, got %ld instead\n", err
);
7517 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
7518 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
7520 dst
= socket(AF_INET
, SOCK_DGRAM
, 0);
7521 ok(dst
!= INVALID_SOCKET
, "socket() failed\n");
7523 memset(&sockaddr
, 0, sizeof(sockaddr
));
7524 sockaddr
.sin_family
= AF_INET
;
7525 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7526 ok(!bind(dst
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
)),
7527 "bind should have worked\n");
7529 /* read address to find out the port number to be used in send */
7530 memset(&sendaddr
, 0, sizeof(sendaddr
));
7531 addrlen
= sizeof(sendaddr
);
7532 ok(!getsockname(dst
, (struct sockaddr
*) &sendaddr
, &addrlen
),
7533 "getsockname should have worked\n");
7534 ok(sendaddr
.sin_port
, "socket port should be != 0\n");
7536 /* ensure the sending socket is not bound */
7537 WSASetLastError(0xdeadbeef);
7538 addrlen
= sizeof(sockaddr
);
7539 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
7540 ok(ret
== SOCKET_ERROR
, "getsockname should have failed\n");
7541 err
= WSAGetLastError();
7542 ok(err
== WSAEINVAL
, "expected 10022, got %ld instead\n", err
);
7544 set_blocking(sock
, TRUE
);
7547 SetLastError(0xdeadbeef);
7548 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
7549 ok(!ret
, "WSASendMsg should have worked\n");
7550 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
7551 "Expected 0, got %ld\n", GetLastError());
7552 ok(bytesSent
== iovec
[0].len
, "incorrect bytes sent, expected %ld, sent %ld\n",
7553 iovec
[0].len
, bytesSent
);
7556 addrlen
= sizeof(sockaddr
);
7557 memset(buffer
, 0, sizeof(buffer
));
7558 SetLastError(0xdeadbeef);
7559 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
7560 ok(ret
== bytesSent
, "got %d, expected %ld\n",
7562 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %ld\n", GetLastError());
7564 /* A successful call to WSASendMsg must have bound the socket */
7565 addrlen
= sizeof(sockaddr
);
7566 sockaddr
.sin_port
= 0;
7567 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7568 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
7569 ok(!ret
, "getsockname should have worked\n");
7570 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
7571 inet_ntoa(sockaddr
.sin_addr
));
7572 ok(sockaddr
.sin_port
, "sin_port should be != 0\n");
7574 msg
.dwBufferCount
= 2; /* send both buffers */
7577 SetLastError(0xdeadbeef);
7578 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
7579 ok(!ret
, "WSASendMsg should have worked\n");
7580 ok(bytesSent
== iovec
[0].len
+ iovec
[1].len
, "incorrect bytes sent, expected %ld, sent %ld\n",
7581 iovec
[0].len
+ iovec
[1].len
, bytesSent
);
7582 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
7583 "Expected 0, got %ld\n", GetLastError());
7586 addrlen
= sizeof(sockaddr
);
7587 memset(buffer
, 0, sizeof(buffer
));
7588 SetLastError(0xdeadbeef);
7589 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
7590 ok(ret
== bytesSent
, "got %d, expected %ld\n",
7592 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %ld\n", GetLastError());
7597 /* a bad call to WSASendMsg will also bind the socket */
7598 addrlen
= sizeof(sockaddr
);
7599 sockaddr
.sin_port
= 0;
7600 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7601 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
7602 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
7603 ok(pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
7605 ok(!getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have worked\n");
7606 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
7607 inet_ntoa(sockaddr
.sin_addr
));
7608 ok(sockaddr
.sin_port
, "sin_port should be > 0\n");
7612 /* a bad call without msg parameter will not trigger the auto-bind */
7613 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
7614 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
7615 ok(pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
7616 ok(getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have failed\n");
7617 err
= WSAGetLastError();
7618 ok(err
== WSAEINVAL
, "expected 10022, got %ld instead\n", err
);
7621 /* SOCK_STREAM sockets are not supported */
7623 sock
= socket(AF_INET
, SOCK_STREAM
, 0);
7624 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
7625 SetLastError(0xdeadbeef);
7626 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
7627 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
7628 err
= WSAGetLastError();
7630 ok(err
== WSAEINVAL
, "expected 10014, got %ld instead\n", err
);
7634 static void test_WSASendTo(void)
7637 struct sockaddr_in addr
, ret_addr
;
7638 char buf
[12] = "hello world";
7643 addr
.sin_family
= AF_INET
;
7644 addr
.sin_port
= htons(139);
7645 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7646 data_buf
.len
= sizeof(buf
);
7649 s
= socket(AF_INET
, SOCK_DGRAM
, 0);
7650 ok(s
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
7652 WSASetLastError(12345);
7653 ret
= WSASendTo(INVALID_SOCKET
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
7654 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
7655 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
7657 len
= sizeof(ret_addr
);
7658 ret
= getsockname(s
, (struct sockaddr
*)&ret_addr
, &len
);
7659 ok(ret
== -1, "expected failure\n");
7660 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
7662 WSASetLastError(12345);
7663 ret
= WSASendTo(s
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
7664 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
7665 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
7667 WSASetLastError(12345);
7668 ret
= WSASendTo(s
, &data_buf
, 1, &bytesSent
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
7669 ok(!ret
, "expected success\n");
7670 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
7672 len
= sizeof(ret_addr
);
7673 ret
= getsockname(s
, (struct sockaddr
*)&ret_addr
, &len
);
7674 ok(!ret
, "got error %u\n", WSAGetLastError());
7675 ok(ret_addr
.sin_family
== AF_INET
, "got family %u\n", ret_addr
.sin_family
);
7676 ok(ret_addr
.sin_port
, "expected nonzero port\n");
7679 struct recv_thread_apc_param
7682 unsigned int apc_count
;
7685 static void WINAPI
recv_thread_apc_func(ULONG_PTR param
)
7687 struct recv_thread_apc_param
*p
= (struct recv_thread_apc_param
*)param
;
7692 ret
= send(p
->sock
, "test", 4, 0);
7693 ok(ret
== 4, "got %d.\n", ret
);
7696 struct recv_thread_param
7702 static DWORD WINAPI
recv_thread(LPVOID arg
)
7704 struct recv_thread_param
*p
= arg
;
7705 SOCKET sock
= p
->sock
;
7714 wsa
.len
= sizeof(buffer
);
7717 ov
.hEvent
= WSACreateEvent();
7718 WSARecv(sock
, &wsa
, 1, NULL
, &flags
, &ov
, NULL
);
7720 WaitForSingleObject(ov
.hEvent
, 1000);
7721 WSACloseEvent(ov
.hEvent
);
7725 SetLastError(0xdeadbeef);
7726 ret
= WSARecv(sock
, &wsa
, 1, &len
, &flags
, NULL
, NULL
);
7727 ok(!ret
, "got ret %d.\n", ret
);
7728 ok(WSAGetLastError() == 0, "got error %d.\n", WSAGetLastError());
7729 ok(len
== 4, "got len %lu.\n", len
);
7734 static int completion_called
;
7736 static void WINAPI
io_completion(DWORD error
, DWORD transferred
, WSAOVERLAPPED
*overlapped
, DWORD flags
)
7738 completion_called
++;
7741 static void test_WSARecv(void)
7743 SOCKET src
, dest
, server
= INVALID_SOCKET
;
7744 struct recv_thread_apc_param apc_param
;
7745 struct recv_thread_param recv_param
;
7749 DWORD bytesReturned
, flags
, id
;
7750 struct sockaddr_in addr
;
7751 unsigned int apc_count
;
7755 HANDLE thread
, event
= NULL
, io_port
;
7757 tcp_socketpair(&src
, &dest
);
7759 memset(&ov
, 0, sizeof(ov
));
7764 /* Send 2 bytes and receive in two calls of 1 */
7765 SetLastError(0xdeadbeef);
7766 iret
= send(src
, "ab", 2, 0);
7767 ok(iret
== 2, "got %d\n", iret
);
7768 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %ld\n", GetLastError());
7769 SetLastError(0xdeadbeef);
7770 bytesReturned
= 0xdeadbeef;
7772 /* Non-overlapped WSARecv() performs an alertable wait (tested below), but
7773 * not if it completes synchronously. Make sure it completes synchronously
7774 * by polling for input. */
7775 check_poll_mask(dest
, POLLRDNORM
, POLLRDNORM
);
7778 dwret
= QueueUserAPC(apc_func
, GetCurrentThread(), (ULONG_PTR
)&apc_count
);
7779 ok(dwret
, "QueueUserAPC returned %lu\n", dwret
);
7781 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
7782 ok(!iret
, "Expected 0, got %d\n", iret
);
7783 ok(bytesReturned
== 1, "got %ld\n", bytesReturned
);
7784 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %ld\n", GetLastError());
7786 ok(!apc_count
, "got apc_count %u.\n", apc_count
);
7788 ok(apc_count
== 1, "got apc_count %u.\n", apc_count
);
7790 SetLastError(0xdeadbeef);
7791 bytesReturned
= 0xdeadbeef;
7792 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
7793 ok(!iret
, "Expected 0, got %d\n", iret
);
7794 ok(bytesReturned
== 1, "got %ld\n", bytesReturned
);
7795 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %ld\n", GetLastError());
7798 SetLastError(0xdeadbeef);
7799 iret
= send(src
, "test", 4, 0);
7800 ok(iret
== 4, "Expected 4, got %d\n", iret
);
7801 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %ld\n", GetLastError());
7802 SetLastError(0xdeadbeef);
7803 bytesReturned
= 0xdeadbeef;
7804 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
7805 ok(!iret
, "Expected 0, got %d\n", iret
);
7806 ok(bytesReturned
== 4, "Expected 4, got %ld\n", bytesReturned
);
7807 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %ld\n", GetLastError());
7809 /* Test 2 buffers */
7812 bufs
[1].buf
= buf
+ 10;
7813 SetLastError(0xdeadbeef);
7814 iret
= send(src
, "deadbeefs", 9, 0);
7815 ok(iret
== 9, "Expected 9, got %d\n", iret
);
7816 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %ld\n", GetLastError());
7817 SetLastError(0xdeadbeef);
7818 bytesReturned
= 0xdeadbeef;
7819 iret
= WSARecv(dest
, bufs
, 2, &bytesReturned
, &flags
, NULL
, NULL
);
7820 ok(!iret
, "Expected 0, got %d\n", iret
);
7821 ok(bytesReturned
== 9, "Expected 9, got %ld\n", bytesReturned
);
7822 bufs
[0].buf
[4] = '\0';
7823 bufs
[1].buf
[5] = '\0';
7824 ok(!strcmp(bufs
[0].buf
, "dead"), "buf[0] doesn't match: %s != dead\n", bufs
[0].buf
);
7825 ok(!strcmp(bufs
[1].buf
, "beefs"), "buf[1] doesn't match: %s != beefs\n", bufs
[1].buf
);
7826 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %ld\n", GetLastError());
7828 bufs
[0].len
= sizeof(buf
);
7829 ov
.hEvent
= event
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
7830 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %ld\n", GetLastError());
7834 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, NULL
);
7835 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %ld\n", iret
, GetLastError());
7837 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
7838 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %ld\n", iret
, GetLastError());
7840 close_with_rst(src
);
7842 dwret
= WaitForSingleObject(ov
.hEvent
, 1000);
7843 ok(dwret
== WAIT_OBJECT_0
, "Waiting for disconnect event failed with %ld + errno %ld\n", dwret
, GetLastError());
7845 bret
= GetOverlappedResult((HANDLE
)dest
, &ov
, &bytesReturned
, FALSE
);
7846 ok(!bret
, "expected failure\n");
7847 ok(GetLastError() == ERROR_NETNAME_DELETED
, "got error %lu\n", GetLastError());
7848 ok(bytesReturned
== 0, "Bytes received is %ld\n", bytesReturned
);
7850 dest
= INVALID_SOCKET
;
7852 src
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
7853 ok(src
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
7854 if (src
== INVALID_SOCKET
) goto end
;
7856 server
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
7857 ok(server
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
7858 if (server
== INVALID_SOCKET
) goto end
;
7860 memset(&addr
, 0, sizeof(addr
));
7861 addr
.sin_family
= AF_INET
;
7862 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7863 iret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
7864 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
7867 iret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
7868 ok(!iret
, "failed to get address, error %u\n", WSAGetLastError());
7870 iret
= listen(server
, 1);
7871 ok(!iret
, "failed to listen, error %u\n", WSAGetLastError());
7873 iret
= connect(src
, (struct sockaddr
*)&addr
, sizeof(addr
));
7874 ok(!iret
, "failed to connect, error %u\n", WSAGetLastError());
7877 dest
= accept(server
, (struct sockaddr
*)&addr
, &len
);
7878 ok(dest
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
7879 if (dest
== INVALID_SOCKET
) goto end
;
7881 send(src
, "test message", sizeof("test message"), 0);
7882 recv_param
.sock
= dest
;
7883 recv_param
.overlapped
= TRUE
;
7884 thread
= CreateThread(NULL
, 0, recv_thread
, &recv_param
, 0, &id
);
7885 WaitForSingleObject(thread
, 3000);
7886 CloseHandle(thread
);
7888 recv_param
.overlapped
= FALSE
;
7889 thread
= CreateThread(NULL
, 0, recv_thread
, &recv_param
, 0, &id
);
7890 apc_param
.apc_count
= 0;
7891 apc_param
.sock
= src
;
7892 dwret
= QueueUserAPC(recv_thread_apc_func
, thread
, (ULONG_PTR
)&apc_param
);
7893 ok(dwret
, "QueueUserAPC returned %lu\n", dwret
);
7894 WaitForSingleObject(thread
, 3000);
7895 ok(apc_param
.apc_count
== 1, "got apc_count %u.\n", apc_param
.apc_count
);
7897 CloseHandle(thread
);
7899 memset(&ov
, 0, sizeof(ov
));
7902 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, io_completion
);
7903 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %ld\n", iret
, GetLastError());
7904 send(src
, "test message", sizeof("test message"), 0);
7906 completion_called
= 0;
7907 dwret
= SleepEx(1000, TRUE
);
7908 ok(dwret
== WAIT_IO_COMPLETION
, "got %lu\n", dwret
);
7909 ok(completion_called
== 1, "completion not called\n");
7911 dwret
= WaitForSingleObject(event
, 1);
7912 ok(dwret
== WAIT_TIMEOUT
, "got %lu\n", dwret
);
7914 io_port
= CreateIoCompletionPort( (HANDLE
)dest
, NULL
, 0, 0 );
7915 ok(io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
7917 /* Using completion function on socket associated with completion port is not allowed. */
7918 memset(&ov
, 0, sizeof(ov
));
7919 completion_called
= 0;
7920 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, io_completion
);
7921 ok(iret
== SOCKET_ERROR
&& GetLastError() == WSAEINVAL
, "WSARecv failed - %d error %ld\n", iret
, GetLastError());
7922 ok(!completion_called
, "completion called\n");
7924 CloseHandle(io_port
);
7927 if (server
!= INVALID_SOCKET
)
7928 closesocket(server
);
7929 if (dest
!= INVALID_SOCKET
)
7931 if (src
!= INVALID_SOCKET
)
7934 WSACloseEvent(event
);
7937 struct write_watch_thread_args
7946 static DWORD CALLBACK
write_watch_thread( void *arg
)
7948 struct write_watch_thread_args
*args
= arg
;
7949 struct sockaddr addr
;
7950 int addr_len
= sizeof(addr
), ret
;
7951 DWORD bytes
, flags
= 0;
7957 ret
= recv( args
->dest
, args
->base
, args
->size
, 0 );
7958 ok( ret
== strlen(args
->expect
) + 1, "wrong len %d\n", ret
);
7959 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
7962 ret
= recvfrom( args
->dest
, args
->base
, args
->size
, 0, &addr
, &addr_len
);
7963 ok( ret
== strlen(args
->expect
) + 1, "wrong len %d\n", ret
);
7964 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
7967 buf
[0].len
= args
->size
;
7968 buf
[0].buf
= args
->base
;
7969 ret
= WSARecv( args
->dest
, buf
, 1, &bytes
, &flags
, NULL
, NULL
);
7970 ok( !ret
, "WSARecv failed %lu\n", GetLastError() );
7971 ok( bytes
== strlen(args
->expect
) + 1, "wrong len %ld\n", bytes
);
7972 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
7975 buf
[0].len
= args
->size
;
7976 buf
[0].buf
= args
->base
;
7977 ret
= WSARecvFrom( args
->dest
, buf
, 1, &bytes
, &flags
, &addr
, &addr_len
, NULL
, NULL
);
7978 ok( !ret
, "WSARecvFrom failed %lu\n", GetLastError() );
7979 ok( bytes
== strlen(args
->expect
) + 1, "wrong len %ld\n", bytes
);
7980 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
7986 static void test_write_watch(void)
7991 struct write_watch_thread_args args
;
7992 DWORD bytesReturned
, flags
, size
;
7993 struct sockaddr addr
;
7995 HANDLE thread
, event
;
8000 UINT (WINAPI
*pGetWriteWatch
)(DWORD
,LPVOID
,SIZE_T
,LPVOID
*,ULONG_PTR
*,ULONG
*);
8002 pGetWriteWatch
= (void *)GetProcAddress( GetModuleHandleA("kernel32.dll"), "GetWriteWatch" );
8003 if (!pGetWriteWatch
)
8005 win_skip( "write watched not supported\n" );
8009 /* Windows 11 no longer triggers write watches anymore. */
8011 tcp_socketpair(&src
, &dest
);
8013 memset(&ov
, 0, sizeof(ov
));
8014 ov
.hEvent
= event
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8015 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %ld\n", GetLastError());
8020 base
= VirtualAlloc( 0, size
, MEM_RESERVE
| MEM_COMMIT
| MEM_WRITE_WATCH
, PAGE_READWRITE
);
8021 ok( base
!= NULL
, "VirtualAlloc failed %lu\n", GetLastError() );
8023 memset( base
, 0, size
);
8025 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
8026 ok( !ret
, "GetWriteWatch failed %lu\n", GetLastError() );
8027 ok( count
== 16, "wrong count %Iu\n", count
);
8031 bufs
[1].len
= 0x8000;
8032 bufs
[1].buf
= base
+ 0x4000;
8034 ret
= WSARecv( dest
, bufs
, 2, NULL
, &flags
, &ov
, NULL
);
8035 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
8036 "WSARecv failed - %d error %ld\n", ret
, GetLastError());
8039 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
8040 ok( !ret
, "GetWriteWatch failed %lu\n", GetLastError() );
8041 ok( count
== 9 || !count
/* Win 11 */, "wrong count %Iu\n", count
);
8042 ok( !base
[0], "data set\n" );
8044 send(src
, "test message", sizeof("test message"), 0);
8046 ret
= GetOverlappedResult( (HANDLE
)dest
, &ov
, &bytesReturned
, TRUE
);
8047 ok( ret
, "GetOverlappedResult failed %lu\n", GetLastError() );
8048 ok( bytesReturned
== sizeof("test message"), "wrong size %lu\n", bytesReturned
);
8049 ok( !memcmp( base
, "test ", 5 ), "wrong data %s\n", base
);
8050 ok( !memcmp( base
+ 0x4000, "message", 8 ), "wrong data %s\n", base
+ 0x4000 );
8053 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
8054 ok( !ret
, "GetWriteWatch failed %lu\n", GetLastError() );
8055 ok( count
== 0, "wrong count %Iu\n", count
);
8057 memset( base
, 0, size
);
8059 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
8060 ok( !ret
, "GetWriteWatch failed %lu\n", GetLastError() );
8061 ok( count
== 16, "wrong count %Iu\n", count
);
8063 bufs
[1].len
= 0x4000;
8064 bufs
[1].buf
= base
+ 0x2000;
8065 ret
= WSARecvFrom( dest
, bufs
, 2, NULL
, &flags
, &addr
, &addr_len
, &ov
, NULL
);
8066 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
8067 "WSARecv failed - %d error %ld\n", ret
, GetLastError());
8070 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
8071 ok( !ret
, "GetWriteWatch failed %lu\n", GetLastError() );
8072 ok( count
== 5 || !count
/* Win 11 */, "wrong count %Iu\n", count
);
8073 ok( !base
[0], "data set\n" );
8075 send(src
, "test message", sizeof("test message"), 0);
8077 ret
= GetOverlappedResult( (HANDLE
)dest
, &ov
, &bytesReturned
, TRUE
);
8078 ok( ret
, "GetOverlappedResult failed %lu\n", GetLastError() );
8079 ok( bytesReturned
== sizeof("test message"), "wrong size %lu\n", bytesReturned
);
8080 ok( !memcmp( base
, "test ", 5 ), "wrong data %s\n", base
);
8081 ok( !memcmp( base
+ 0x2000, "message", 8 ), "wrong data %s\n", base
+ 0x2000 );
8084 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
8085 ok( !ret
, "GetWriteWatch failed %lu\n", GetLastError() );
8086 ok( count
== 0, "wrong count %Iu\n", count
);
8088 memset( base
, 0, size
);
8090 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
8091 ok( !ret
, "GetWriteWatch failed %lu\n", GetLastError() );
8092 ok( count
== 16, "wrong count %Iu\n", count
);
8097 args
.expect
= "test message";
8098 for (args
.func
= 0; args
.func
< 4; args
.func
++)
8100 thread
= CreateThread( NULL
, 0, write_watch_thread
, &args
, 0, NULL
);
8104 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
8105 ok( !ret
, "GetWriteWatch failed %lu\n", GetLastError() );
8106 ok( count
== 8 || !count
/* Win 11 */, "wrong count %Iu\n", count
);
8108 send(src
, "test message", sizeof("test message"), 0);
8109 WaitForSingleObject( thread
, 10000 );
8110 CloseHandle( thread
);
8113 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
8114 ok( !ret
, "GetWriteWatch failed %lu\n", GetLastError() );
8115 ok( count
== 0, "wrong count %Iu\n", count
);
8117 WSACloseEvent( event
);
8118 closesocket( dest
);
8120 VirtualFree( base
, 0, MEM_FREE
);
8123 static void test_WSAPoll(void)
8125 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
8127 SOCKET listener
, server
, client
;
8128 struct sockaddr_in address
;
8130 HANDLE thread_handle
;
8134 static const short invalid_flags
[] =
8135 {POLLERR
, POLLHUP
, POLLNVAL
, 0x8, POLLWRBAND
, 0x40, 0x80, POLLPRI
, 0x800, 0x1000, 0x2000, 0x4000, 0x8000};
8137 if (!pWSAPoll
) /* >= Vista */
8139 win_skip("WSAPoll is unsupported, some tests will be skipped.\n");
8143 /* Invalid parameters test */
8144 SetLastError(0xdeadbeef);
8145 ret
= pWSAPoll(NULL
, 0, 0);
8146 err
= GetLastError();
8147 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
8148 ok(err
== WSAEINVAL
, "expected 10022, got %d\n", err
);
8149 SetLastError(0xdeadbeef);
8150 ret
= pWSAPoll(NULL
, 1, 0);
8151 err
= GetLastError();
8152 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
8153 ok(err
== WSAEFAULT
, "expected 10014, got %d\n", err
);
8154 SetLastError(0xdeadbeef);
8155 ret
= pWSAPoll(NULL
, 0, 1);
8156 err
= GetLastError();
8157 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
8158 ok(err
== WSAEINVAL
, "expected 10022, got %d\n", err
);
8159 SetLastError(0xdeadbeef);
8160 ret
= pWSAPoll(NULL
, 1, 1);
8161 err
= GetLastError();
8162 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
8163 ok(err
== WSAEFAULT
, "expected 10014, got %d\n", err
);
8165 memset(&address
, 0, sizeof(address
));
8166 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8167 address
.sin_family
= AF_INET
;
8168 len
= sizeof(address
);
8169 listener
= setup_server_socket(&address
, &len
);
8171 for (i
= 0; i
< ARRAY_SIZE(invalid_flags
); ++i
)
8173 fds
[0].fd
= listener
;
8174 fds
[0].events
= invalid_flags
[i
];
8175 fds
[0].revents
= 0xdead;
8176 WSASetLastError(0xdeadbeef);
8177 ret
= pWSAPoll(fds
, 1, 0);
8178 todo_wine
ok(ret
== -1, "got %d\n", ret
);
8179 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
8182 /* When no events are pending poll returns 0 with no error */
8183 fds
[0].fd
= listener
;
8184 fds
[0].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
8185 fds
[0].revents
= 0xdead;
8186 ret
= pWSAPoll(fds
, 1, 0);
8187 ok(ret
== 0, "got %d\n", ret
);
8188 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
8191 fds
[0].events
= POLLERR
;
8192 fds
[0].revents
= 0xdead;
8193 fds
[1].fd
= listener
;
8194 fds
[1].events
= POLLIN
;
8195 fds
[1].revents
= 0xdead;
8196 WSASetLastError(0xdeadbeef);
8197 ret
= pWSAPoll(fds
, 2, 0);
8198 ok(!ret
, "got %d\n", ret
);
8199 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
8200 ok(fds
[0].revents
== POLLNVAL
, "got events %#x\n", fds
[0].revents
);
8201 ok(!fds
[1].revents
, "got events %#x\n", fds
[1].revents
);
8203 fds
[0].fd
= listener
;
8204 fds
[0].events
= POLLIN
;
8205 fds
[0].revents
= 0xdead;
8206 fds
[1].fd
= 0xabacab;
8207 fds
[1].events
= POLLIN
;
8208 fds
[1].revents
= 0xdead;
8209 WSASetLastError(0xdeadbeef);
8210 ret
= pWSAPoll(fds
, 2, 0);
8211 ok(!ret
, "got %d\n", ret
);
8212 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
8213 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
8214 ok(fds
[1].revents
== POLLNVAL
, "got events %#x\n", fds
[1].revents
);
8216 fds
[0].fd
= listener
;
8217 fds
[0].events
= POLLIN
;
8218 fds
[0].revents
= 0xdead;
8219 fds
[1].fd
= 0xabacab;
8220 fds
[1].events
= POLLERR
;
8221 fds
[1].revents
= 0xdead;
8222 WSASetLastError(0xdeadbeef);
8223 ret
= pWSAPoll(fds
, 2, 0);
8224 todo_wine
ok(ret
== -1, "got %d\n", ret
);
8225 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
8226 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
8227 todo_wine
ok(!fds
[1].revents
, "got events %#x\n", fds
[1].revents
);
8230 fds
[0].events
= POLLERR
;
8231 fds
[0].revents
= 0xdead;
8232 fds
[1].fd
= 0xabacab;
8233 fds
[1].events
= POLLERR
;
8234 fds
[1].revents
= 0xdead;
8235 WSASetLastError(0xdeadbeef);
8236 ret
= pWSAPoll(fds
, 2, 0);
8237 ok(ret
== -1, "got %d\n", ret
);
8238 ok(WSAGetLastError() == WSAENOTSOCK
, "got error %u\n", WSAGetLastError());
8239 ok(fds
[0].revents
== POLLNVAL
, "got events %#x\n", fds
[0].revents
);
8240 ok(fds
[1].revents
== POLLNVAL
, "got events %#x\n", fds
[1].revents
);
8242 /* Test listening socket connection attempt notifications */
8243 client
= setup_connector_socket(&address
, len
, TRUE
);
8245 fds
[0].fd
= listener
;
8246 fds
[0].events
= POLLIN
;
8247 fds
[0].revents
= 0xdead;
8248 ret
= pWSAPoll(fds
, 1, 100);
8249 ok(ret
== 1, "got %d\n", ret
);
8250 ok(fds
[0].revents
== POLLRDNORM
, "got events %#x\n", fds
[0].revents
);
8252 fds
[0].revents
= 0xdead;
8253 ret
= pWSAPoll(fds
, 1, 0);
8254 ok(ret
== 1, "got %d\n", ret
);
8255 ok(fds
[0].revents
== POLLRDNORM
, "got events %#x\n", fds
[0].revents
);
8257 fds
[0].events
= POLLRDBAND
| POLLWRNORM
;
8258 fds
[0].revents
= 0xdead;
8259 ret
= pWSAPoll(fds
, 1, 0);
8260 ok(ret
== 0, "got %d\n", ret
);
8261 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
8263 server
= accept(listener
, NULL
, NULL
);
8264 ok(server
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
8265 set_blocking(client
, FALSE
);
8266 set_blocking(server
, FALSE
);
8268 for (i
= 0; i
< ARRAY_SIZE(invalid_flags
); ++i
)
8271 fds
[0].events
= invalid_flags
[i
];
8272 fds
[0].revents
= 0xdead;
8273 WSASetLastError(0xdeadbeef);
8274 ret
= pWSAPoll(fds
, 1, 0);
8275 todo_wine
ok(ret
== -1, "got %d\n", ret
);
8276 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
8279 /* Test flags exposed by connected sockets. */
8281 fds
[0].fd
= listener
;
8282 fds
[0].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
8283 fds
[0].revents
= 0xdead;
8285 fds
[1].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
8286 fds
[1].revents
= 0xdead;
8288 fds
[2].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
8289 fds
[2].revents
= 0xdead;
8290 ret
= pWSAPoll(fds
, 3, 0);
8291 ok(ret
== 2, "got %d\n", ret
);
8292 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
8293 ok(fds
[1].revents
== POLLWRNORM
, "got events %#x\n", fds
[1].revents
);
8294 ok(fds
[2].revents
== POLLWRNORM
, "got events %#x\n", fds
[2].revents
);
8296 /* Test data receiving notifications */
8298 ret
= send(server
, "1234", 4, 0);
8299 ok(ret
== 4, "got %d\n", ret
);
8301 check_poll_mask(client
, POLLRDNORM
| POLLRDBAND
, POLLRDNORM
);
8302 check_poll(client
, POLLRDNORM
| POLLWRNORM
);
8303 check_poll(server
, POLLWRNORM
);
8305 ret
= sync_recv(client
, buffer
, sizeof(buffer
), 0);
8306 ok(ret
== 4, "got %d\n", ret
);
8308 check_poll(client
, POLLWRNORM
);
8309 check_poll(server
, POLLWRNORM
);
8311 /* Because the kernel asynchronously buffers data, this test is not reliable. */
8315 static const int large_buffer_size
= 1024 * 1024;
8316 char *large_buffer
= malloc(large_buffer_size
);
8318 while (send(server
, large_buffer
, large_buffer_size
, 0) == large_buffer_size
);
8320 check_poll(client
, POLLWRNORM
| POLLRDNORM
);
8321 check_poll(server
, 0);
8323 while (recv(client
, large_buffer
, large_buffer_size
, 0) > 0);
8325 check_poll(client
, POLLWRNORM
);
8326 check_poll(server
, POLLWRNORM
);
8331 /* Test OOB data notifications */
8333 ret
= send(client
, "A", 1, MSG_OOB
);
8334 ok(ret
== 1, "got %d\n", ret
);
8336 check_poll(client
, POLLWRNORM
);
8337 check_poll_mask(server
, POLLRDNORM
| POLLRDBAND
, POLLRDBAND
);
8338 check_poll(server
, POLLWRNORM
| POLLRDBAND
);
8341 ret
= recv(server
, buffer
, 1, MSG_OOB
);
8342 ok(ret
== 1, "got %d\n", ret
);
8343 ok(buffer
[0] == 'A', "got %#x\n", buffer
[0]);
8345 check_poll(client
, POLLWRNORM
);
8346 check_poll(server
, POLLWRNORM
);
8348 /* If the socket is OOBINLINED the notification is like normal data */
8351 ret
= setsockopt(server
, SOL_SOCKET
, SO_OOBINLINE
, (char *)&ret
, sizeof(ret
));
8352 ok(!ret
, "got error %u\n", WSAGetLastError());
8353 ret
= send(client
, "A", 1, MSG_OOB
);
8354 ok(ret
== 1, "got %d\n", ret
);
8356 check_poll(client
, POLLWRNORM
);
8357 check_poll_mask(server
, POLLRDNORM
| POLLRDBAND
, POLLRDNORM
);
8358 check_poll(server
, POLLWRNORM
| POLLRDNORM
);
8361 ret
= recv(server
, buffer
, 1, 0);
8362 ok(ret
== 1, "got %d\n", ret
);
8363 ok(buffer
[0] == 'A', "got %#x\n", buffer
[0]);
8365 check_poll(client
, POLLWRNORM
);
8366 check_poll_todo(server
, POLLWRNORM
);
8368 /* Test shutdown. */
8370 ret
= shutdown(client
, SD_RECEIVE
);
8371 ok(!ret
, "got error %u\n", WSAGetLastError());
8373 check_poll(client
, POLLWRNORM
);
8374 check_poll_todo(server
, POLLWRNORM
);
8376 ret
= shutdown(client
, SD_SEND
);
8377 ok(!ret
, "got error %u\n", WSAGetLastError());
8379 check_poll(client
, POLLWRNORM
);
8380 check_poll_mask_todo(server
, 0, POLLHUP
);
8381 check_poll_todo(server
, POLLWRNORM
| POLLHUP
);
8383 closesocket(client
);
8384 closesocket(server
);
8386 /* Test shutdown via closesocket(). */
8388 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8389 ret
= connect(client
, (struct sockaddr
*)&address
, sizeof(address
));
8390 ok(!ret
, "got error %u\n", WSAGetLastError());
8391 server
= accept(listener
, NULL
, NULL
);
8392 ok(server
!= -1, "got error %u\n", WSAGetLastError());
8394 closesocket(client
);
8396 check_poll_mask(server
, 0, POLLHUP
);
8397 check_poll(server
, POLLWRNORM
| POLLHUP
);
8399 closesocket(server
);
8401 /* Test shutdown with data in the pipe. */
8403 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8404 ret
= connect(client
, (struct sockaddr
*)&address
, sizeof(address
));
8405 ok(!ret
, "got error %u\n", WSAGetLastError());
8406 server
= accept(listener
, NULL
, NULL
);
8407 ok(server
!= -1, "got error %u\n", WSAGetLastError());
8409 ret
= send(client
, "data", 5, 0);
8410 ok(ret
== 5, "got %d\n", ret
);
8412 check_poll(client
, POLLWRNORM
);
8413 check_poll_mask(server
, POLLRDNORM
| POLLRDBAND
, POLLRDNORM
);
8414 check_poll(server
, POLLWRNORM
| POLLRDNORM
);
8416 ret
= shutdown(client
, SD_SEND
);
8418 check_poll(client
, POLLWRNORM
);
8419 check_poll_mask_todo(server
, 0, POLLHUP
);
8420 check_poll_todo(server
, POLLWRNORM
| POLLRDNORM
| POLLHUP
);
8422 closesocket(client
);
8423 closesocket(server
);
8425 /* Test closing a socket while selecting on it. */
8427 tcp_socketpair(&client
, &server
);
8429 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &client
, 0, NULL
);
8431 fds
[0].events
= POLLRDNORM
| POLLRDBAND
;
8432 fds
[0].revents
= 0xdead;
8434 ret
= QueueUserAPC(apc_func
, GetCurrentThread(), (ULONG_PTR
)&apc_count
);
8435 ok(ret
, "QueueUserAPC returned %d\n", ret
);
8436 ret
= pWSAPoll(fds
, 1, 2000);
8437 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
8438 ok(ret
== 1, "got %d\n", ret
);
8439 ok(fds
[0].revents
== POLLNVAL
, "got events %#x\n", fds
[0].revents
);
8440 ret
= WaitForSingleObject(thread_handle
, 1000);
8441 ok(!ret
, "wait failed\n");
8442 CloseHandle(thread_handle
);
8444 closesocket(server
);
8446 /* Test a failed connection.
8448 * The following WSAPoll() call times out on versions older than w10pro64,
8449 * but even on w10pro64 it takes over 2 seconds for an error to be reported,
8450 * so make the test interactive-only. */
8451 if (winetest_interactive
)
8453 const struct sockaddr_in invalid_addr
=
8455 .sin_family
= AF_INET
,
8456 .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
),
8461 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8462 set_blocking(client
, FALSE
);
8464 ret
= connect(client
, (const struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
8465 ok(ret
== -1, "got %d\n", ret
);
8466 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
8469 fds
[0].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
8470 fds
[0].revents
= 0xdead;
8471 ret
= pWSAPoll(fds
, 1, 10000);
8472 ok(ret
== 1, "got %d\n", ret
);
8473 todo_wine
ok(fds
[0].revents
== (POLLWRNORM
| POLLHUP
| POLLERR
), "got events %#x\n", fds
[0].revents
);
8477 ret
= getsockopt(client
, SOL_SOCKET
, SO_ERROR
, (char *)&err
, &len
);
8478 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
8479 ok(err
== WSAECONNREFUSED
, "got error %u\n", err
);
8483 ret
= getsockopt(client
, SOL_SOCKET
, SO_ERROR
, (char *)&err
, &len
);
8484 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
8485 ok(err
== WSAECONNREFUSED
, "got error %u\n", err
);
8487 check_poll_todo(client
, POLLWRNORM
| POLLHUP
| POLLERR
);
8489 closesocket(client
);
8491 /* test polling after a (synchronous) failure */
8493 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8495 ret
= connect(client
, (const struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
8496 ok(ret
== -1, "got %d\n", ret
);
8497 ok(WSAGetLastError() == WSAECONNREFUSED
, "got error %u\n", WSAGetLastError());
8499 check_poll_todo(client
, POLLWRNORM
| POLLHUP
| POLLERR
);
8503 ret
= getsockopt(client
, SOL_SOCKET
, SO_ERROR
, (char *)&err
, &len
);
8504 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
8505 todo_wine
ok(!err
, "got error %u\n", err
);
8507 closesocket(client
);
8510 closesocket(listener
);
8512 /* Test UDP sockets. */
8514 client
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
8515 server
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
8517 check_poll(client
, POLLWRNORM
);
8518 check_poll(server
, POLLWRNORM
);
8520 ret
= bind(client
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
8521 ok(!ret
, "got error %u\n", WSAGetLastError());
8522 len
= sizeof(address
);
8523 ret
= getsockname(client
, (struct sockaddr
*)&address
, &len
);
8524 ok(!ret
, "got error %u\n", WSAGetLastError());
8526 check_poll(client
, POLLWRNORM
);
8527 check_poll(server
, POLLWRNORM
);
8529 ret
= sendto(server
, "data", 5, 0, (struct sockaddr
*)&address
, sizeof(address
));
8530 ok(ret
== 5, "got %d\n", ret
);
8532 check_poll_mask(client
, POLLRDNORM
| POLLRDBAND
, POLLRDNORM
);
8533 check_poll(client
, POLLWRNORM
| POLLRDNORM
);
8534 check_poll(server
, POLLWRNORM
);
8536 closesocket(client
);
8537 closesocket(server
);
8540 static void test_connect(void)
8542 SOCKET listener
= INVALID_SOCKET
;
8543 SOCKET acceptor
= INVALID_SOCKET
;
8544 SOCKET connector
= INVALID_SOCKET
;
8545 struct sockaddr_in address
, conaddress
;
8547 OVERLAPPED overlapped
;
8548 LPFN_CONNECTEX pConnectEx
;
8549 GUID connectExGuid
= WSAID_CONNECTEX
;
8550 DWORD bytesReturned
;
8556 memset(&overlapped
, 0, sizeof(overlapped
));
8558 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
8559 ok(listener
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8561 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8562 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8564 memset(&address
, 0, sizeof(address
));
8565 address
.sin_family
= AF_INET
;
8566 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8567 iret
= bind(listener
, (struct sockaddr
*)&address
, sizeof(address
));
8568 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
8570 addrlen
= sizeof(address
);
8571 iret
= getsockname(listener
, (struct sockaddr
*)&address
, &addrlen
);
8572 ok(!iret
, "failed to get address, error %u\n", WSAGetLastError());
8574 iret
= listen(listener
, 1);
8575 ok(!iret
, "failed to listen, error %u\n", WSAGetLastError());
8577 iret
= set_blocking(listener
, TRUE
);
8578 ok(!iret
, "failed to set nonblocking, error %u\n", WSAGetLastError());
8580 bytesReturned
= 0xdeadbeef;
8581 iret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectExGuid
, sizeof(connectExGuid
),
8582 &pConnectEx
, sizeof(pConnectEx
), &bytesReturned
, NULL
, NULL
);
8583 ok(!iret
, "failed to get ConnectEx, error %u\n", WSAGetLastError());
8585 ok(bytesReturned
== sizeof(pConnectEx
), "expected sizeof(pConnectEx), got %lu\n", bytesReturned
);
8587 WSASetLastError(0xdeadbeef);
8588 iret
= connect(listener
, (struct sockaddr
*)&address
, sizeof(address
));
8589 ok(iret
== -1, "got %d\n", iret
);
8590 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
8592 WSASetLastError(0xdeadbeef);
8593 overlapped
.Internal
= 0xdeadbeef;
8594 overlapped
.InternalHigh
= 0xdeadbeef;
8595 iret
= pConnectEx(listener
, (struct sockaddr
*)&address
, sizeof(address
), NULL
, 0, &bytesReturned
, &overlapped
);
8596 ok(!iret
, "got %d\n", iret
);
8597 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
8598 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
8599 todo_wine
ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
8601 bret
= pConnectEx(INVALID_SOCKET
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
8602 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "ConnectEx on invalid socket "
8603 "returned %d + errno %d\n", bret
, WSAGetLastError());
8605 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
8606 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "ConnectEx on a unbound socket "
8607 "returned %d + errno %d\n", bret
, WSAGetLastError());
8609 /* ConnectEx needs a bound socket */
8610 memset(&conaddress
, 0, sizeof(conaddress
));
8611 conaddress
.sin_family
= AF_INET
;
8612 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8613 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
8614 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
8616 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, NULL
);
8617 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "ConnectEx on a NULL overlapped "
8618 "returned %d + errno %d\n", bret
, WSAGetLastError());
8620 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8622 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
8623 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
8624 "returned %d + errno %d\n", bret
, WSAGetLastError());
8625 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
8626 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %ld + errno %ld\n", dwret
, GetLastError());
8628 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
8629 ok(bret
, "Connecting failed, error %ld\n", GetLastError());
8630 ok(bytesReturned
== 0, "Bytes sent is %ld\n", bytesReturned
);
8632 closesocket(connector
);
8633 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8634 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8635 /* ConnectEx needs a bound socket */
8636 memset(&conaddress
, 0, sizeof(conaddress
));
8637 conaddress
.sin_family
= AF_INET
;
8638 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8639 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
8640 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
8642 acceptor
= accept(listener
, NULL
, NULL
);
8643 ok(acceptor
!= INVALID_SOCKET
, "failed to accept socket, error %u\n", WSAGetLastError());
8648 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, buffer
, 3, &bytesReturned
, &overlapped
);
8649 memset(buffer
, 0, 3);
8650 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
8651 "returned %d + errno %d\n", bret
, WSAGetLastError());
8652 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
8653 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %ld + errno %ld\n", dwret
, GetLastError());
8655 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
8656 ok(bret
, "Connecting failed, error %ld\n", GetLastError());
8657 ok(bytesReturned
== 3, "Bytes sent is %ld\n", bytesReturned
);
8659 acceptor
= accept(listener
, NULL
, NULL
);
8660 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket error %d\n", WSAGetLastError());
8662 bytesReturned
= recv(acceptor
, buffer
, 3, 0);
8664 ok(bytesReturned
== 3, "Didn't get all sent data, got only %ld\n", bytesReturned
);
8665 ok(buffer
[0] == '1' && buffer
[1] == '2' && buffer
[2] == '3',
8666 "Failed to get the right data, expected '123', got '%s'\n", buffer
);
8668 WSASetLastError(0xdeadbeef);
8669 iret
= connect(connector
, (struct sockaddr
*)&address
, sizeof(address
));
8670 ok(iret
== -1, "got %d\n", iret
);
8671 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
8673 WSASetLastError(0xdeadbeef);
8674 iret
= connect(acceptor
, (struct sockaddr
*)&address
, sizeof(address
));
8675 ok(iret
== -1, "got %d\n", iret
);
8676 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
8678 WSASetLastError(0xdeadbeef);
8679 overlapped
.Internal
= 0xdeadbeef;
8680 overlapped
.InternalHigh
= 0xdeadbeef;
8681 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, sizeof(address
), NULL
, 0, &bytesReturned
, &overlapped
);
8682 ok(!bret
, "got %d\n", bret
);
8683 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
8684 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
8685 todo_wine
ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
8687 WSASetLastError(0xdeadbeef);
8688 overlapped
.Internal
= 0xdeadbeef;
8689 overlapped
.InternalHigh
= 0xdeadbeef;
8690 bret
= pConnectEx(acceptor
, (struct sockaddr
*)&address
, sizeof(address
), NULL
, 0, &bytesReturned
, &overlapped
);
8691 ok(!bret
, "got %d\n", bret
);
8692 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
8693 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
8694 todo_wine
ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
8696 closesocket(connector
);
8697 closesocket(acceptor
);
8699 tcp_socketpair(&connector
, &acceptor
);
8701 WSASetLastError(0xdeadbeef);
8702 iret
= connect(connector
, (struct sockaddr
*)&address
, sizeof(address
));
8703 ok(iret
== -1, "got %d\n", iret
);
8704 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
8706 WSASetLastError(0xdeadbeef);
8707 iret
= connect(acceptor
, (struct sockaddr
*)&address
, sizeof(address
));
8708 ok(iret
== -1, "got %d\n", iret
);
8709 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
8711 WSASetLastError(0xdeadbeef);
8712 overlapped
.Internal
= 0xdeadbeef;
8713 overlapped
.InternalHigh
= 0xdeadbeef;
8714 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, sizeof(address
), NULL
, 0, &bytesReturned
, &overlapped
);
8715 ok(!bret
, "got %d\n", bret
);
8716 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
8717 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
8718 todo_wine
ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
8720 WSASetLastError(0xdeadbeef);
8721 overlapped
.Internal
= 0xdeadbeef;
8722 overlapped
.InternalHigh
= 0xdeadbeef;
8723 bret
= pConnectEx(acceptor
, (struct sockaddr
*)&address
, sizeof(address
), NULL
, 0, &bytesReturned
, &overlapped
);
8724 ok(!bret
, "got %d\n", bret
);
8725 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
8726 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
8727 todo_wine
ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
8729 closesocket(connector
);
8730 closesocket(acceptor
);
8732 /* Connect with error */
8734 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8735 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8736 /* ConnectEx needs a bound socket */
8737 memset(&conaddress
, 0, sizeof(conaddress
));
8738 conaddress
.sin_family
= AF_INET
;
8739 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8740 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
8741 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
8743 address
.sin_port
= htons(1);
8745 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
8746 ok(bret
== FALSE
&& GetLastError() == ERROR_IO_PENDING
, "ConnectEx to bad destination failed: "
8747 "returned %d + errno %ld\n", bret
, GetLastError());
8748 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
8749 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %ld + errno %ld\n", dwret
, GetLastError());
8751 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
8752 ok(bret
== FALSE
&& GetLastError() == ERROR_CONNECTION_REFUSED
,
8753 "Connecting to a disconnected host returned error %d - %d\n", bret
, WSAGetLastError());
8755 WSACloseEvent(overlapped
.hEvent
);
8756 closesocket(connector
);
8760 /* Wait in connect() is alertable. This may take a very long time before connection fails,
8761 * so disable the test. Testing with localhost is unreliable as that may avoid waiting in
8763 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8764 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8765 address
.sin_addr
.s_addr
= inet_addr("8.8.8.8");
8766 address
.sin_port
= htons(255);
8770 ok(apc_count
== 0, "got apc_count %d.\n", apc_count
);
8771 bret
= QueueUserAPC(apc_func
, GetCurrentThread(), (ULONG_PTR
)&apc_count
);
8772 ok(bret
, "QueueUserAPC returned %d\n", bret
);
8773 iret
= connect(connector
, (struct sockaddr
*)&address
, sizeof(address
));
8774 ok(apc_count
== 1, "got apc_count %d.\n", apc_count
);
8775 ok(iret
== -1 && (WSAGetLastError() == WSAECONNREFUSED
|| WSAGetLastError() == WSAETIMEDOUT
),
8776 "unexpected iret %d, error %d.\n", iret
, WSAGetLastError());
8777 closesocket(connector
);
8780 /* Test connect after previous connect attempt failure. */
8781 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8782 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8784 conaddress
.sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
8785 conaddress
.sin_port
= htons(255);
8786 iret
= connect(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
8787 ok(iret
== -1, "connection succeeded.\n");
8789 ok(WSAGetLastError() == WSAECONNREFUSED
, "got error %u\n", WSAGetLastError());
8790 set_blocking( connector
, FALSE
);
8791 iret
= getsockname(listener
, (struct sockaddr
*)&address
, &addrlen
);
8792 ok(!iret
, "failed to get address, error %u\n", WSAGetLastError());
8794 iret
= connect(connector
, (struct sockaddr
*)&address
, sizeof(address
));
8795 ok(iret
== -1 && WSAGetLastError() == WSAEWOULDBLOCK
, "unexpected iret %d, error %d.\n",
8796 iret
, WSAGetLastError());
8797 acceptor
= accept(listener
, NULL
, NULL
);
8798 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket error %d\n", WSAGetLastError());
8800 closesocket(acceptor
);
8801 closesocket(connector
);
8802 closesocket(listener
);
8805 static void test_AcceptEx(void)
8807 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
8808 SOCKET listener
, acceptor
, acceptor2
, connector
, connector2
;
8809 struct sockaddr_in bindAddress
, peerAddress
, *readBindAddress
, *readRemoteAddress
;
8810 int socklen
, iret
, localSize
= sizeof(struct sockaddr_in
), remoteSize
= localSize
;
8811 GUID acceptExGuid
= WSAID_ACCEPTEX
, getAcceptExGuid
= WSAID_GETACCEPTEXSOCKADDRS
;
8812 GUID connectex_guid
= WSAID_CONNECTEX
;
8813 LPFN_ACCEPTEX pAcceptEx
= NULL
;
8814 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs
= NULL
;
8815 LPFN_CONNECTEX pConnectEx
= NULL
;
8816 fd_set fds_accept
, fds_send
;
8817 static const struct timeval timeout
= {1, 0};
8818 char buffer
[1024], ipbuffer
[32];
8819 OVERLAPPED overlapped
= {0}, overlapped2
= {0};
8820 DWORD bytesReturned
, dwret
;
8823 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8824 overlapped2
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8826 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
8827 ok(listener
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8829 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
8830 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8832 memset(&bindAddress
, 0, sizeof(bindAddress
));
8833 bindAddress
.sin_family
= AF_INET
;
8834 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8835 iret
= bind(listener
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8836 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
8838 socklen
= sizeof(bindAddress
);
8839 iret
= getsockname(listener
, (struct sockaddr
*)&bindAddress
, &socklen
);
8840 ok(!iret
, "failed to get address, error %u\n", WSAGetLastError());
8842 iret
= set_blocking(listener
, FALSE
);
8843 ok(!iret
, "Failed to set nonblocking, error %u\n", WSAGetLastError());
8845 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
8846 &pAcceptEx
, sizeof(pAcceptEx
), &bytesReturned
, NULL
, NULL
);
8847 ok(!iret
, "Failed to get AcceptEx, error %u\n", WSAGetLastError());
8849 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &getAcceptExGuid
, sizeof(getAcceptExGuid
),
8850 &pGetAcceptExSockaddrs
, sizeof(pGetAcceptExSockaddrs
), &bytesReturned
, NULL
, NULL
);
8851 ok(!iret
, "Failed to get GetAcceptExSockaddrs, error %u\n", WSAGetLastError());
8853 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectex_guid
, sizeof(connectex_guid
),
8854 &pConnectEx
, sizeof(pConnectEx
), &bytesReturned
, NULL
, NULL
);
8855 ok(!iret
, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
8857 overlapped
.Internal
= 0xdeadbeef;
8858 bret
= pAcceptEx(INVALID_SOCKET
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
8859 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8860 &bytesReturned
, &overlapped
);
8861 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid listening socket "
8862 "returned %d + errno %d\n", bret
, WSAGetLastError());
8863 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08lx\n", (ULONG
)overlapped
.Internal
);
8865 overlapped
.Internal
= 0xdeadbeef;
8866 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
8867 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8868 &bytesReturned
, &overlapped
);
8870 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on a non-listening socket "
8871 "returned %d + errno %d\n", bret
, WSAGetLastError());
8872 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08lx\n", (ULONG
)overlapped
.Internal
);
8873 if (!bret
&& WSAGetLastError() == ERROR_IO_PENDING
)
8874 CancelIo((HANDLE
)listener
);
8876 iret
= listen(listener
, 5);
8877 ok(!iret
, "failed to listen, error %lu\n", GetLastError());
8879 overlapped
.Internal
= 0xdeadbeef;
8880 bret
= pAcceptEx(listener
, INVALID_SOCKET
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
8881 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8882 &bytesReturned
, &overlapped
);
8883 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid accepting socket "
8884 "returned %d + errno %d\n", bret
, WSAGetLastError());
8885 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08lx\n", (ULONG
)overlapped
.Internal
);
8887 overlapped
.Internal
= 0xdeadbeef;
8888 bret
= pAcceptEx(listener
, acceptor
, NULL
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
8889 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8890 &bytesReturned
, &overlapped
);
8891 todo_wine
ok(bret
== FALSE
&& WSAGetLastError() == WSAEFAULT
,
8892 "AcceptEx on NULL buffer returned %d + errno %d\n", bret
, WSAGetLastError());
8893 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08lx\n", (ULONG
)overlapped
.Internal
);
8895 overlapped
.Internal
= 0xdeadbeef;
8896 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16,
8897 &bytesReturned
, &overlapped
);
8898 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
,
8899 "AcceptEx on too small local address size returned %d + errno %d\n",
8900 bret
, WSAGetLastError());
8901 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08lx\n", (ULONG
)overlapped
.Internal
);
8903 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8904 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
8905 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8906 ok(!iret
, "failed to connect, error %u\n", WSAGetLastError());
8907 iret
= getsockname(connector
, (struct sockaddr
*)&peerAddress
, &remoteSize
);
8908 ok(!iret
, "getsockname failed, error %u\n", WSAGetLastError());
8910 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8911 ok(!dwret
, "wait failed\n");
8912 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
8913 ok(bret
, "got error %lu\n", GetLastError());
8914 ok(!(NTSTATUS
)overlapped
.Internal
, "got %#Ix\n", overlapped
.Internal
);
8915 ok(!bytesReturned
, "got size %lu\n", bytesReturned
);
8917 readBindAddress
= readRemoteAddress
= (struct sockaddr_in
*)0xdeadbeef;
8918 localSize
= remoteSize
= 0xdeadbeef;
8919 pGetAcceptExSockaddrs(buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16,
8920 (struct sockaddr
**)&readBindAddress
, &localSize
, (struct sockaddr
**)&readRemoteAddress
, &remoteSize
);
8921 todo_wine
ok(readBindAddress
== (struct sockaddr_in
*)0xdeadbeef, "got local addr %p\n", readBindAddress
);
8922 ok(!memcmp(readRemoteAddress
, &peerAddress
, sizeof(peerAddress
)), "remote addr didn't match\n");
8923 todo_wine
ok(localSize
== 0xdeadbeef, "got local size %u\n", localSize
);
8924 ok(remoteSize
== sizeof(struct sockaddr_in
), "got remote size %u\n", remoteSize
);
8926 closesocket(connector
);
8927 closesocket(acceptor
);
8929 /* A UDP socket cannot be accepted into. */
8931 acceptor
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
8933 overlapped
.Internal
= 0xdeadbeef;
8934 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
8935 ok(!bret
, "expected failure\n");
8936 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
8937 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
8938 if (WSAGetLastError() == ERROR_IO_PENDING
)
8939 CancelIo((HANDLE
)listener
);
8941 closesocket(acceptor
);
8943 /* A bound socket cannot be accepted into. */
8945 acceptor
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8946 iret
= bind(acceptor
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
8947 ok(!iret
, "got error %u\n", WSAGetLastError());
8949 overlapped
.Internal
= 0xdeadbeef;
8950 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
8951 ok(!bret
, "expected failure\n");
8952 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
8953 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
8954 if (WSAGetLastError() == ERROR_IO_PENDING
)
8955 CancelIo((HANDLE
)listener
);
8957 closesocket(acceptor
);
8959 /* A connected socket cannot be accepted into. */
8961 tcp_socketpair(&acceptor
, &acceptor2
);
8963 overlapped
.Internal
= 0xdeadbeef;
8964 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
8965 ok(!bret
, "expected failure\n");
8966 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
8967 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
8968 if (WSAGetLastError() == ERROR_IO_PENDING
)
8969 CancelIo((HANDLE
)listener
);
8971 overlapped
.Internal
= 0xdeadbeef;
8972 bret
= pAcceptEx(listener
, acceptor2
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
8973 ok(!bret
, "expected failure\n");
8974 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
8975 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
8976 if (WSAGetLastError() == ERROR_IO_PENDING
)
8977 CancelIo((HANDLE
)listener
);
8979 closesocket(acceptor
);
8980 closesocket(acceptor2
);
8982 /* Pass an insufficient local address size. */
8984 acceptor
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8985 ok(acceptor
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
8987 overlapped
.Internal
= 0xdeadbeef;
8988 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 3,
8989 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
8990 ok(!bret
&& WSAGetLastError() == ERROR_IO_PENDING
, "got %d, error %u\n", bret
, WSAGetLastError());
8991 ok((NTSTATUS
)overlapped
.Internal
== STATUS_PENDING
, "got %#Ix\n", overlapped
.Internal
);
8993 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8994 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
8995 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8996 ok(!iret
, "failed to connect, error %u\n", WSAGetLastError());
8998 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8999 ok(!dwret
, "wait failed\n");
9000 bytesReturned
= 0xdeadbeef;
9001 SetLastError(0xdeadbeef);
9002 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
9003 ok(!bret
, "expected failure\n");
9004 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER
, "got error %lu\n", GetLastError());
9005 ok((NTSTATUS
)overlapped
.Internal
== STATUS_BUFFER_TOO_SMALL
, "got %#Ix\n", overlapped
.Internal
);
9006 ok(!bytesReturned
, "got size %lu\n", bytesReturned
);
9008 closesocket(acceptor
);
9010 /* The above connection request is not accepted. */
9011 acceptor
= accept(listener
, NULL
, NULL
);
9012 todo_wine
ok(acceptor
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
9013 closesocket(acceptor
);
9015 closesocket(connector
);
9017 acceptor
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9018 ok(acceptor
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9020 overlapped
.Internal
= 0xdeadbeef;
9021 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 4,
9022 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
9023 ok(!bret
&& WSAGetLastError() == ERROR_IO_PENDING
, "got %d, error %u\n", bret
, WSAGetLastError());
9024 ok((NTSTATUS
)overlapped
.Internal
== STATUS_PENDING
, "got %#Ix\n", overlapped
.Internal
);
9026 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9027 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9028 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9029 ok(!iret
, "failed to connect, error %u\n", WSAGetLastError());
9031 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9032 ok(!dwret
, "wait failed\n");
9033 bytesReturned
= 0xdeadbeef;
9034 SetLastError(0xdeadbeef);
9035 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
9036 todo_wine
ok(!bret
, "expected failure\n");
9037 todo_wine
ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER
, "got error %lu\n", GetLastError());
9038 todo_wine
ok((NTSTATUS
)overlapped
.Internal
== STATUS_BUFFER_TOO_SMALL
, "got %#Ix\n", overlapped
.Internal
);
9039 ok(!bytesReturned
, "got size %lu\n", bytesReturned
);
9041 closesocket(acceptor
);
9043 /* The above connection request is not accepted. */
9044 acceptor
= accept(listener
, NULL
, NULL
);
9045 todo_wine
ok(acceptor
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
9046 closesocket(acceptor
);
9048 closesocket(connector
);
9050 acceptor
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9051 ok(acceptor
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9053 overlapped
.Internal
= 0xdeadbeef;
9054 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 15,
9055 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
9056 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx on too small local address "
9057 "size returned %d + errno %d\n",
9058 bret
, WSAGetLastError());
9059 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08lx\n", (ULONG
)overlapped
.Internal
);
9060 bret
= CancelIo((HANDLE
) listener
);
9061 ok(bret
, "Failed to cancel pending accept socket\n");
9063 overlapped
.Internal
= 0xdeadbeef;
9064 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16, 0,
9065 &bytesReturned
, &overlapped
);
9066 ok(bret
== FALSE
&& WSAGetLastError() == WSAEFAULT
,
9067 "AcceptEx on too small remote address size returned %d + errno %d\n", bret
, WSAGetLastError());
9068 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08lx\n", (ULONG
)overlapped
.Internal
);
9070 overlapped
.Internal
= 0xdeadbeef;
9071 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16,
9072 sizeof(struct sockaddr_in
) + 15, &bytesReturned
, &overlapped
);
9073 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
,
9074 "AcceptEx on too small remote address size returned %d + errno %d\n", bret
, WSAGetLastError());
9075 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08lx\n", (ULONG
)overlapped
.Internal
);
9076 bret
= CancelIo((HANDLE
) listener
);
9077 ok(bret
, "Failed to cancel pending accept socket\n");
9079 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
9080 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9081 &bytesReturned
, NULL
);
9082 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
9083 "returned %d + errno %d\n", bret
, WSAGetLastError());
9085 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, 0, &bytesReturned
, NULL
);
9086 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
9087 "returned %d + errno %d\n", bret
, WSAGetLastError());
9089 overlapped
.Internal
= 0xdeadbeef;
9090 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
9091 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9092 &bytesReturned
, &overlapped
);
9093 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
9094 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08lx\n", (ULONG
)overlapped
.Internal
);
9096 /* try to accept into the same socket twice */
9097 overlapped
.Internal
= 0xdeadbeef;
9098 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
9099 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9100 &bytesReturned
, &overlapped
);
9101 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
,
9102 "AcceptEx on already pending socket returned %d + errno %d\n", bret
, WSAGetLastError());
9103 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08lx\n", (ULONG
)overlapped
.Internal
);
9105 /* try to connect a socket that's being accepted into */
9106 iret
= connect(acceptor
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9107 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEINVAL
,
9108 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret
, WSAGetLastError());
9110 bret
= pConnectEx(acceptor
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
),
9111 NULL
, 0, &bytesReturned
, &overlapped2
);
9112 ok(!bret
, "expected failure\n");
9113 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
9115 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9116 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9117 overlapped
.Internal
= 0xdeadbeef;
9118 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9119 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
9121 dwret
= WaitForSingleObject(overlapped
.hEvent
, INFINITE
);
9122 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %ld + errno %ld\n", dwret
, GetLastError());
9123 ok(overlapped
.Internal
== STATUS_SUCCESS
, "got %08lx\n", (ULONG
)overlapped
.Internal
);
9125 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
9126 ok(bret
, "GetOverlappedResult failed, error %ld\n", GetLastError());
9127 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %ld\n", bytesReturned
);
9129 /* Try to call getsockname on the acceptor socket.
9131 * On Windows, this requires setting SO_UPDATE_ACCEPT_CONTEXT. */
9132 iret
= setsockopt(acceptor
, SOL_SOCKET
, SO_UPDATE_ACCEPT_CONTEXT
, (char *)&listener
, sizeof(SOCKET
));
9133 ok(!iret
, "Failed to set accept context %ld\n", GetLastError());
9134 iret
= getsockname(acceptor
, (struct sockaddr
*)&peerAddress
, &remoteSize
);
9135 ok(!iret
, "getsockname failed.\n");
9136 ok(remoteSize
== sizeof(struct sockaddr_in
), "got remote size %u\n", remoteSize
);
9138 closesocket(connector
);
9139 connector
= INVALID_SOCKET
;
9140 closesocket(acceptor
);
9142 /* Test short reads */
9144 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
9145 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %lu\n", GetLastError());
9146 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
9147 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %lu\n", GetLastError());
9148 overlapped
.Internal
= 0xdeadbeef;
9149 bret
= pAcceptEx(listener
, acceptor
, buffer
, 2,
9150 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9151 &bytesReturned
, &overlapped
);
9152 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
9153 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08lx\n", (ULONG
)overlapped
.Internal
);
9155 /* AcceptEx() still won't complete until we send data */
9156 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9157 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
9159 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
9160 ok(dwret
== WAIT_TIMEOUT
, "Waiting for accept event timeout failed with %ld + errno %ld\n", dwret
, GetLastError());
9161 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08lx\n", (ULONG
)overlapped
.Internal
);
9163 iret
= getsockname( connector
, (struct sockaddr
*)&peerAddress
, &remoteSize
);
9164 ok( !iret
, "getsockname failed.\n");
9166 /* AcceptEx() could complete any time now */
9167 iret
= send(connector
, buffer
, 1, 0);
9168 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
9170 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9171 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %ld + errno %ld\n", dwret
, GetLastError());
9172 ok(overlapped
.Internal
== STATUS_SUCCESS
, "got %08lx\n", (ULONG
)overlapped
.Internal
);
9174 /* Check if the buffer from AcceptEx is decoded correctly */
9175 pGetAcceptExSockaddrs(buffer
, 2, sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9176 (struct sockaddr
**)&readBindAddress
, &localSize
,
9177 (struct sockaddr
**)&readRemoteAddress
, &remoteSize
);
9178 strcpy( ipbuffer
, inet_ntoa(readBindAddress
->sin_addr
));
9179 ok( readBindAddress
->sin_addr
.s_addr
== bindAddress
.sin_addr
.s_addr
,
9180 "Local socket address is different %s != %s\n",
9181 ipbuffer
, inet_ntoa(bindAddress
.sin_addr
));
9182 ok( readBindAddress
->sin_port
== bindAddress
.sin_port
,
9183 "Local socket port is different: %d != %d\n",
9184 readBindAddress
->sin_port
, bindAddress
.sin_port
);
9185 strcpy( ipbuffer
, inet_ntoa(readRemoteAddress
->sin_addr
));
9186 ok( readRemoteAddress
->sin_addr
.s_addr
== peerAddress
.sin_addr
.s_addr
,
9187 "Remote socket address is different %s != %s\n",
9188 ipbuffer
, inet_ntoa(peerAddress
.sin_addr
));
9189 ok( readRemoteAddress
->sin_port
== peerAddress
.sin_port
,
9190 "Remote socket port is different: %d != %d\n",
9191 readRemoteAddress
->sin_port
, peerAddress
.sin_port
);
9193 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
9194 ok(bret
, "GetOverlappedResult failed, error %ld\n", GetLastError());
9195 ok(bytesReturned
== 1, "bytesReturned isn't supposed to be %ld\n", bytesReturned
);
9197 closesocket(connector
);
9198 connector
= INVALID_SOCKET
;
9199 closesocket(acceptor
);
9201 /* Test CF_DEFER & AcceptEx interaction */
9203 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
9204 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %lu\n", GetLastError());
9205 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
9206 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %lu\n", GetLastError());
9207 connector2
= socket(AF_INET
, SOCK_STREAM
, 0);
9208 ok(connector2
!= INVALID_SOCKET
, "failed to create socket, error %lu\n", GetLastError());
9210 iret
= set_blocking(connector
, FALSE
);
9211 ok(!iret
, "failed to set nonblocking, error %lu\n", GetLastError());
9212 iret
= set_blocking(connector2
, FALSE
);
9213 ok(!iret
, "failed to set nonblocking, error %lu\n", GetLastError());
9215 /* Connect socket #1 */
9216 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9217 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
9221 FD_ZERO(&fds_accept
);
9222 FD_SET(listener
, &fds_accept
);
9223 iret
= select(0, &fds_accept
, NULL
, NULL
, &timeout
);
9224 ok(iret
== 1, "wait timed out\n");
9226 acceptor2
= WSAAccept(listener
, NULL
, NULL
, AlwaysDeferConditionFunc
, 0);
9227 ok(acceptor2
== INVALID_SOCKET
, "expected failure\n");
9228 ok(WSAGetLastError() == WSATRY_AGAIN
, "got error %u\n", WSAGetLastError());
9229 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16,
9230 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
9231 ok(!bret
, "expected failure\n");
9232 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
9235 FD_SET(connector
, &fds_send
);
9236 iret
= select(0, NULL
, &fds_send
, NULL
, &timeout
);
9237 ok(iret
== 1, "wait timed out\n");
9239 iret
= send(connector
, "1", 1, 0);
9240 ok(iret
== 1, "got ret %d, error %u\n", iret
, WSAGetLastError());
9242 iret
= connect(connector2
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9243 ok(iret
== SOCKET_ERROR
, "expected failure\n");
9244 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
9246 iret
= select(0, &fds_accept
, NULL
, NULL
, &timeout
);
9247 ok(iret
== 1, "wait timed out\n");
9249 acceptor2
= accept(listener
, NULL
, NULL
);
9250 ok(acceptor2
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
9251 closesocket(acceptor2
);
9254 FD_SET(connector2
, &fds_send
);
9255 iret
= select(0, NULL
, &fds_send
, NULL
, &timeout
);
9256 ok(iret
== 1, "wait timed out\n");
9258 iret
= send(connector2
, "2", 1, 0);
9259 ok(iret
== 1, "got ret %d, error %u\n", iret
, WSAGetLastError());
9261 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
9262 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %ld + errno %ld\n", dwret
, GetLastError());
9264 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
9265 ok(bret
, "GetOverlappedResult failed, error %ld\n", GetLastError());
9266 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %ld\n", bytesReturned
);
9268 set_blocking(acceptor
, TRUE
);
9269 iret
= recv( acceptor
, buffer
, 2, 0);
9270 ok(iret
== 1, "Failed to get data, %d, errno: %d\n", iret
, WSAGetLastError());
9271 ok(buffer
[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer
[0]);
9273 closesocket(connector
);
9274 closesocket(connector2
);
9275 closesocket(acceptor
);
9277 /* clean up in case of failures */
9278 while ((acceptor
= accept(listener
, NULL
, NULL
)) != INVALID_SOCKET
)
9279 closesocket(acceptor
);
9281 /* Disconnect during receive? */
9283 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
9284 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %lu\n", GetLastError());
9285 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
9286 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %lu\n", GetLastError());
9287 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
9288 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9289 &bytesReturned
, &overlapped
);
9290 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
9292 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9293 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
9295 closesocket(connector
);
9296 connector
= INVALID_SOCKET
;
9298 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9299 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %ld + errno %ld\n", dwret
, GetLastError());
9301 bytesReturned
= 123456;
9302 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
9303 ok(bret
, "GetOverlappedResult failed, error %ld\n", GetLastError());
9304 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %ld\n", bytesReturned
);
9306 closesocket(acceptor
);
9308 /* Test closing with pending requests */
9310 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
9311 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %lu\n", GetLastError());
9312 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
9313 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9314 &bytesReturned
, &overlapped
);
9315 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
9317 closesocket(acceptor
);
9319 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9320 ok(dwret
== WAIT_OBJECT_0
,
9321 "Waiting for accept event failed with %ld + errno %ld\n", dwret
, GetLastError());
9322 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
9323 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %ld\n", GetLastError());
9325 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
9326 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %lu\n", GetLastError());
9327 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
9328 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9329 &bytesReturned
, &overlapped
);
9330 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
9332 CancelIo((HANDLE
) acceptor
);
9334 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9335 ok(dwret
== WAIT_TIMEOUT
, "Waiting for timeout failed with %ld + errno %ld\n", dwret
, GetLastError());
9337 closesocket(acceptor
);
9339 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
9340 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %lu\n", GetLastError());
9341 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
9342 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9343 &bytesReturned
, &overlapped
);
9344 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
9346 closesocket(listener
);
9348 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9349 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %ld + errno %ld\n", dwret
, GetLastError());
9351 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
9352 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %ld\n", GetLastError());
9354 CloseHandle(overlapped
.hEvent
);
9355 CloseHandle(overlapped2
.hEvent
);
9356 closesocket(acceptor
);
9357 closesocket(connector2
);
9360 static void test_shutdown(void)
9362 struct sockaddr_in addr
, server_addr
, client_addr
;
9363 SOCKET listener
, client
, server
;
9364 OVERLAPPED overlapped
= {0};
9365 DWORD size
, flags
= 0;
9370 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
9371 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9372 ok(listener
!= INVALID_SOCKET
, "failed to create listener socket, error %d\n", WSAGetLastError());
9374 memset(&addr
, 0, sizeof(addr
));
9375 addr
.sin_family
= AF_INET
;
9376 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
9377 ret
= bind(listener
, (struct sockaddr
*)&addr
, sizeof(addr
));
9378 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
9379 addrlen
= sizeof(server_addr
);
9380 ret
= getsockname(listener
, (struct sockaddr
*)&server_addr
, &addrlen
);
9381 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
9383 ret
= listen(listener
, 1);
9384 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
9386 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9387 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9389 WSASetLastError(0xdeadbeef);
9390 ret
= shutdown(client
, SD_SEND
);
9391 ok(ret
== -1, "expected failure\n");
9392 ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
9394 WSASetLastError(0xdeadbeef);
9395 ret
= shutdown(client
, SD_RECEIVE
);
9396 ok(ret
== -1, "expected failure\n");
9397 ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
9399 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
9400 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
9401 server
= accept(listener
, NULL
, NULL
);
9402 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9403 set_blocking(client
, FALSE
);
9405 WSASetLastError(0xdeadbeef);
9406 ret
= shutdown(client
, SD_SEND
);
9407 ok(!ret
, "expected success\n");
9408 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9410 WSASetLastError(0xdeadbeef);
9411 ret
= shutdown(client
, SD_SEND
);
9412 ok(!ret
, "expected success\n");
9413 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9415 WSASetLastError(0xdeadbeef);
9416 ret
= send(client
, "test", 5, 0);
9417 ok(ret
== -1, "got %d\n", ret
);
9418 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
9420 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
9421 ok(!ret
, "got %d\n", ret
);
9422 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
9423 ok(!ret
, "got %d\n", ret
);
9425 WSASetLastError(0xdeadbeef);
9426 ret
= shutdown(server
, SD_RECEIVE
);
9427 ok(!ret
, "expected success\n");
9428 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9430 WSASetLastError(0xdeadbeef);
9431 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
9432 ok(ret
== -1, "got %d\n", ret
);
9433 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
9435 ret
= send(server
, "test", 5, 0);
9436 ok(ret
== 5, "got %d\n", ret
);
9438 ret
= sync_recv(client
, buffer
, sizeof(buffer
), 0);
9439 ok(ret
== 5, "got %d\n", ret
);
9440 ok(!strcmp(buffer
, "test"), "got %s\n", debugstr_an(buffer
, ret
));
9442 WSASetLastError(0xdeadbeef);
9443 ret
= shutdown(client
, SD_RECEIVE
);
9444 ok(!ret
, "expected success\n");
9445 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9447 WSASetLastError(0xdeadbeef);
9448 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
9449 ok(ret
== -1, "got %d\n", ret
);
9450 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
9452 WSASetLastError(0xdeadbeef);
9453 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
9454 ok(ret
== -1, "got %d\n", ret
);
9455 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
9457 WSASetLastError(0xdeadbeef);
9458 ret
= shutdown(server
, SD_SEND
);
9459 ok(!ret
, "expected success\n");
9460 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9462 WSASetLastError(0xdeadbeef);
9463 ret
= send(server
, "test", 5, 0);
9464 ok(ret
== -1, "got %d\n", ret
);
9465 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
9467 addrlen
= sizeof(addr
);
9468 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &addrlen
);
9469 ok(!ret
, "got error %u\n", WSAGetLastError());
9470 ok(!memcmp(&addr
, &server_addr
, sizeof(server_addr
)), "address didn't match\n");
9472 addrlen
= sizeof(client_addr
);
9473 ret
= getsockname(client
, (struct sockaddr
*)&client_addr
, &addrlen
);
9474 ok(!ret
, "got error %u\n", WSAGetLastError());
9475 addrlen
= sizeof(addr
);
9476 ret
= getpeername(server
, (struct sockaddr
*)&addr
, &addrlen
);
9477 ok(!ret
, "got error %u\n", WSAGetLastError());
9478 ok(!memcmp(&addr
, &client_addr
, sizeof(addr
)), "address didn't match\n");
9480 WSASetLastError(0xdeadbeef);
9481 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
9482 ok(ret
== -1, "got %d\n", ret
);
9483 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
9485 WSASetLastError(0xdeadbeef);
9486 ret
= shutdown(client
, 0xdeadbeef);
9487 ok(ret
== -1, "expected failure\n");
9488 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
9490 closesocket(client
);
9491 closesocket(server
);
9495 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9496 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9497 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
9498 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
9499 server
= accept(listener
, NULL
, NULL
);
9500 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9502 WSASetLastError(0xdeadbeef);
9503 ret
= shutdown(client
, SD_BOTH
);
9504 ok(!ret
, "expected success\n");
9505 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9507 WSASetLastError(0xdeadbeef);
9508 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
9509 ok(ret
== -1, "got %d\n", ret
);
9510 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
9512 WSASetLastError(0xdeadbeef);
9513 ret
= send(client
, "test", 5, 0);
9514 ok(ret
== -1, "got %d\n", ret
);
9515 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
9517 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
9518 ok(!ret
, "got %d\n", ret
);
9520 WSASetLastError(0xdeadbeef);
9521 ret
= shutdown(server
, SD_BOTH
);
9522 ok(!ret
, "expected success\n");
9523 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9525 WSASetLastError(0xdeadbeef);
9526 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
9527 ok(ret
== -1, "got %d\n", ret
);
9528 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
9530 WSASetLastError(0xdeadbeef);
9531 ret
= send(server
, "test", 5, 0);
9532 ok(ret
== -1, "got %d\n", ret
);
9533 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
9535 addrlen
= sizeof(addr
);
9536 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &addrlen
);
9537 ok(!ret
, "got error %u\n", WSAGetLastError());
9538 ok(!memcmp(&addr
, &server_addr
, sizeof(server_addr
)), "address didn't match\n");
9540 addrlen
= sizeof(client_addr
);
9541 ret
= getsockname(client
, (struct sockaddr
*)&client_addr
, &addrlen
);
9542 ok(!ret
, "got error %u\n", WSAGetLastError());
9543 addrlen
= sizeof(addr
);
9544 ret
= getpeername(server
, (struct sockaddr
*)&addr
, &addrlen
);
9545 ok(!ret
, "got error %u\n", WSAGetLastError());
9546 ok(!memcmp(&addr
, &client_addr
, sizeof(addr
)), "address didn't match\n");
9548 closesocket(client
);
9549 closesocket(server
);
9551 /* Send data to a peer which is closed. */
9553 tcp_socketpair(&client
, &server
);
9555 WSASetLastError(0xdeadbeef);
9556 ret
= shutdown(client
, SD_SEND
);
9557 ok(!ret
, "expected success\n");
9558 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9559 closesocket(client
);
9561 ret
= send(server
, "test", 5, 0);
9562 ok(ret
== 5, "got %d\n", ret
);
9564 WSASetLastError(0xdeadbeef);
9565 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
9566 ok(ret
== -1, "got %d\n", ret
);
9567 todo_wine
ok(WSAGetLastError() == WSAECONNABORTED
, "got error %u\n", WSAGetLastError());
9569 closesocket(server
);
9571 /* Test shutting down with async I/O pending. */
9573 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9574 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9575 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
9576 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
9577 server
= accept(listener
, NULL
, NULL
);
9578 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9579 set_blocking(client
, FALSE
);
9581 wsabuf
.buf
= buffer
;
9582 wsabuf
.len
= sizeof(buffer
);
9583 WSASetLastError(0xdeadbeef);
9584 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
9585 ok(ret
== -1, "got %d\n", ret
);
9586 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
9588 ret
= shutdown(client
, SD_RECEIVE
);
9589 ok(!ret
, "got error %u\n", WSAGetLastError());
9591 WSASetLastError(0xdeadbeef);
9592 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, NULL
, NULL
);
9593 ok(ret
== -1, "got %d\n", ret
);
9594 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
9596 ret
= send(server
, "test", 5, 0);
9597 ok(ret
== 5, "got %d\n", ret
);
9599 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9600 ok(!ret
, "wait timed out\n");
9602 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
9603 ok(ret
, "got error %lu\n", GetLastError());
9604 ok(size
== 5, "got size %lu\n", size
);
9605 ok(!strcmp(buffer
, "test"), "got %s\n", debugstr_an(buffer
, size
));
9607 WSASetLastError(0xdeadbeef);
9608 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
9609 ok(ret
== -1, "got %d\n", ret
);
9610 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
9612 WSASetLastError(0xdeadbeef);
9613 ret
= WSARecv(server
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
9614 ok(ret
== -1, "got %d\n", ret
);
9615 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
9617 ret
= shutdown(client
, SD_SEND
);
9618 ok(!ret
, "got error %u\n", WSAGetLastError());
9620 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9621 ok(!ret
, "wait timed out\n");
9623 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
9624 ok(ret
, "got error %lu\n", GetLastError());
9625 ok(!size
, "got size %lu\n", size
);
9627 closesocket(client
);
9628 closesocket(server
);
9630 /* Test shutting down a listening socket. */
9632 WSASetLastError(0xdeadbeef);
9633 ret
= shutdown(listener
, SD_SEND
);
9634 ok(ret
== -1, "expected failure\n");
9635 ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
9637 WSASetLastError(0xdeadbeef);
9638 ret
= shutdown(listener
, SD_RECEIVE
);
9639 ok(ret
== -1, "expected failure\n");
9640 ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
9642 closesocket(listener
);
9644 /* Test shutting down UDP sockets. */
9646 client
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
9647 server
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
9648 memset(&addr
, 0, sizeof(addr
));
9649 addr
.sin_family
= AF_INET
;
9650 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
9651 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
9652 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
9653 addrlen
= sizeof(server_addr
);
9654 ret
= getsockname(server
, (struct sockaddr
*)&server_addr
, &addrlen
);
9655 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
9656 set_blocking(server
, FALSE
);
9658 WSASetLastError(0xdeadbeef);
9659 ret
= shutdown(server
, SD_RECEIVE
);
9660 ok(!ret
, "expected success\n");
9661 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9663 WSASetLastError(0xdeadbeef);
9664 ret
= recvfrom(server
, buffer
, sizeof(buffer
), 0, NULL
, NULL
);
9665 ok(ret
== -1, "got %d\n", ret
);
9666 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
9668 ret
= sendto(client
, "test", 5, 0, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
9669 ok(ret
== 5, "got %d\n", ret
);
9671 WSASetLastError(0xdeadbeef);
9672 ret
= shutdown(client
, SD_SEND
);
9673 ok(!ret
, "expected success\n");
9674 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9676 WSASetLastError(0xdeadbeef);
9677 ret
= shutdown(client
, SD_SEND
);
9678 ok(!ret
, "expected success\n");
9679 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9681 WSASetLastError(0xdeadbeef);
9682 ret
= sendto(client
, "test", 5, 0, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
9683 ok(ret
== -1, "got %d\n", ret
);
9684 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
9686 closesocket(client
);
9687 closesocket(server
);
9689 CloseHandle(overlapped
.hEvent
);
9692 static void test_DisconnectEx(void)
9694 struct sockaddr_in server_addr
, client_addr
, addr
;
9695 GUID disconnectex_guid
= WSAID_DISCONNECTEX
;
9696 SOCKET listener
, server
, client
;
9697 LPFN_DISCONNECTEX pDisconnectEx
;
9698 OVERLAPPED overlapped
= {0};
9703 overlapped
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
9705 client
= socket(AF_INET
, SOCK_STREAM
, 0);
9706 ok(client
!= INVALID_SOCKET
, "failed to create connector socket, error %u\n", WSAGetLastError());
9708 ret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &disconnectex_guid
, sizeof(disconnectex_guid
),
9709 &pDisconnectEx
, sizeof(pDisconnectEx
), &size
, NULL
, NULL
);
9712 win_skip("WSAIoctl failed to get DisconnectEx, error %d\n", WSAGetLastError());
9713 closesocket(client
);
9717 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
9718 ok(listener
!= INVALID_SOCKET
, "failed to create listener socket, error %d\n", WSAGetLastError());
9720 memset(&addr
, 0, sizeof(addr
));
9721 addr
.sin_family
= AF_INET
;
9722 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
9723 ret
= bind(listener
, (struct sockaddr
*)&addr
, sizeof(addr
));
9724 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
9725 addrlen
= sizeof(server_addr
);
9726 ret
= getsockname(listener
, (struct sockaddr
*)&server_addr
, &addrlen
);
9727 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
9728 ret
= listen(listener
, 1);
9729 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
9731 WSASetLastError(0xdeadbeef);
9732 ret
= pDisconnectEx(INVALID_SOCKET
, &overlapped
, 0, 0);
9733 ok(!ret
, "expected failure\n");
9734 ok(WSAGetLastError() == WSAENOTSOCK
, "got error %u\n", WSAGetLastError());
9736 WSASetLastError(0xdeadbeef);
9737 ret
= pDisconnectEx(client
, &overlapped
, 0, 0);
9738 ok(!ret
, "expected failure\n");
9739 ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
9741 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
9742 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
9743 server
= accept(listener
, NULL
, NULL
);
9744 ok(server
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
9746 WSASetLastError(0xdeadbeef);
9747 ret
= pDisconnectEx(client
, &overlapped
, 0, 0);
9748 ok(!ret
, "expected failure\n");
9749 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
9751 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9752 ok(!ret
, "wait timed out\n");
9754 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
9755 ok(ret
, "got error %lu\n", GetLastError());
9756 ok(!size
, "got size %lu\n", size
);
9758 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
9759 ok(ret
== -1, "expected failure\n");
9760 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
9762 WSASetLastError(0xdeadbeef);
9763 ret
= send(client
, "test", 5, 0);
9764 ok(ret
== -1, "expected failure\n");
9765 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
9767 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
9768 ok(!ret
, "got %d\n", ret
);
9770 ret
= send(server
, "test", 5, 0);
9771 ok(ret
== 5, "got %d\n", ret
);
9773 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
9774 ok(ret
== 5, "got %d\n", ret
);
9775 ok(!strcmp(buffer
, "test"), "got %s\n", debugstr_an(buffer
, ret
));
9777 addrlen
= sizeof(addr
);
9778 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &addrlen
);
9779 ok(!ret
, "got error %u\n", WSAGetLastError());
9780 ok(!memcmp(&addr
, &server_addr
, sizeof(server_addr
)), "address didn't match\n");
9782 addrlen
= sizeof(client_addr
);
9783 ret
= getsockname(client
, (struct sockaddr
*)&client_addr
, &addrlen
);
9784 ok(!ret
, "got error %u\n", WSAGetLastError());
9785 addrlen
= sizeof(addr
);
9786 ret
= getpeername(server
, (struct sockaddr
*)&addr
, &addrlen
);
9787 ok(!ret
, "got error %u\n", WSAGetLastError());
9788 ok(!memcmp(&addr
, &client_addr
, sizeof(addr
)), "address didn't match\n");
9790 closesocket(client
);
9791 closesocket(server
);
9793 /* Test the synchronous case. */
9795 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9796 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9797 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
9798 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
9799 server
= accept(listener
, NULL
, NULL
);
9800 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
9802 WSASetLastError(0xdeadbeef);
9803 ret
= pDisconnectEx(client
, NULL
, 0, 0);
9804 ok(ret
, "expected success\n");
9805 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9807 WSASetLastError(0xdeadbeef);
9808 ret
= pDisconnectEx(client
, NULL
, 0, 0);
9809 ok(ret
, "expected success\n");
9810 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9812 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
9813 ok(ret
== -1, "expected failure\n");
9814 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
9816 WSASetLastError(0xdeadbeef);
9817 ret
= send(client
, "test", 5, 0);
9818 ok(ret
== -1, "expected failure\n");
9819 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
9821 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
9822 ok(!ret
, "got %d\n", ret
);
9824 ret
= send(server
, "test", 5, 0);
9825 ok(ret
== 5, "got %d\n", ret
);
9827 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
9828 ok(ret
== 5, "got %d\n", ret
);
9829 ok(!strcmp(buffer
, "test"), "got %s\n", debugstr_an(buffer
, ret
));
9831 addrlen
= sizeof(addr
);
9832 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &addrlen
);
9833 ok(!ret
, "got error %u\n", WSAGetLastError());
9834 ok(!memcmp(&addr
, &server_addr
, sizeof(server_addr
)), "address didn't match\n");
9836 addrlen
= sizeof(client_addr
);
9837 ret
= getsockname(client
, (struct sockaddr
*)&client_addr
, &addrlen
);
9838 ok(!ret
, "got error %u\n", WSAGetLastError());
9839 addrlen
= sizeof(addr
);
9840 ret
= getpeername(server
, (struct sockaddr
*)&addr
, &addrlen
);
9841 ok(!ret
, "got error %u\n", WSAGetLastError());
9842 ok(!memcmp(&addr
, &client_addr
, sizeof(addr
)), "address didn't match\n");
9844 closesocket(client
);
9845 closesocket(server
);
9847 closesocket(listener
);
9848 CloseHandle(overlapped
.hEvent
);
9851 #define compare_file(h,s,o) compare_file2(h,s,o,__FILE__,__LINE__)
9853 static void compare_file2(HANDLE handle
, SOCKET sock
, int offset
, const char *file
, int line
)
9855 char buf1
[256], buf2
[256];
9859 SetFilePointer(handle
, offset
, NULL
, FILE_BEGIN
);
9862 DWORD n1
= 0, n2
= 0;
9864 success
= ReadFile(handle
, buf1
, sizeof(buf1
), &n1
, NULL
);
9865 ok_(file
,line
)(success
, "Failed to read from file.\n");
9866 if (success
&& n1
== 0)
9870 n2
= recv(sock
, buf2
, n1
, 0);
9871 ok_(file
,line
)(n1
== n2
, "Block %d size mismatch (%ld != %ld)\n", i
, n1
, n2
);
9872 ok_(file
,line
)(memcmp(buf1
, buf2
, n2
) == 0, "Block %d failed\n", i
);
9877 static void test_TransmitFile(void)
9879 DWORD num_bytes
, err
, file_size
, total_sent
;
9880 GUID transmitFileGuid
= WSAID_TRANSMITFILE
;
9881 LPFN_TRANSMITFILE pTransmitFile
= NULL
;
9882 HANDLE file
= INVALID_HANDLE_VALUE
;
9883 char header_msg
[] = "hello world";
9884 char footer_msg
[] = "goodbye!!!";
9885 char system_ini_path
[MAX_PATH
];
9886 struct sockaddr_in bindAddress
;
9887 TRANSMIT_FILE_BUFFERS buffers
;
9888 SOCKET client
, server
, dest
;
9894 memset( &ov
, 0, sizeof(ov
) );
9896 /* Setup sockets for testing TransmitFile */
9897 client
= socket(AF_INET
, SOCK_STREAM
, 0);
9898 ok(client
!= INVALID_SOCKET
, "failed to create socket, error %lu\n", GetLastError());
9899 server
= socket(AF_INET
, SOCK_STREAM
, 0);
9900 ok(server
!= INVALID_SOCKET
, "failed to create socket, error %lu\n", GetLastError());
9901 iret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &transmitFileGuid
, sizeof(transmitFileGuid
),
9902 &pTransmitFile
, sizeof(pTransmitFile
), &num_bytes
, NULL
, NULL
);
9903 ok(!iret
, "failed to get TransmitFile, error %lu\n", GetLastError());
9904 GetSystemWindowsDirectoryA(system_ini_path
, MAX_PATH
);
9905 strcat(system_ini_path
, "\\system.ini");
9906 file
= CreateFileA(system_ini_path
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_ALWAYS
, 0x0, NULL
);
9907 ok(file
!= INVALID_HANDLE_VALUE
, "failed to open file, error %lu\n", GetLastError());
9908 file_size
= GetFileSize(file
, NULL
);
9910 /* Test TransmitFile with an invalid socket */
9911 bret
= pTransmitFile(INVALID_SOCKET
, file
, 0, 0, NULL
, NULL
, 0);
9912 err
= WSAGetLastError();
9913 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
9914 ok(err
== WSAENOTSOCK
, "TransmitFile triggered unexpected errno (%ld != %d)\n", err
, WSAENOTSOCK
);
9916 /* Test a bogus TransmitFile without a connected socket */
9917 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, TF_REUSE_SOCKET
);
9918 err
= WSAGetLastError();
9919 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
9920 ok(err
== WSAENOTCONN
, "TransmitFile triggered unexpected errno (%ld != %d)\n", err
, WSAENOTCONN
);
9922 /* Setup a properly connected socket for transfers */
9923 memset(&bindAddress
, 0, sizeof(bindAddress
));
9924 bindAddress
.sin_family
= AF_INET
;
9925 bindAddress
.sin_port
= htons(SERVERPORT
+1);
9926 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
9927 iret
= bind(server
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9928 ok(!iret
, "failed to bind socket, error %lu\n", GetLastError());
9929 iret
= listen(server
, 1);
9930 ok(!iret
, "failed to listen, error %lu\n", GetLastError());
9931 iret
= connect(client
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9932 ok(!iret
, "failed to connect, error %lu\n", GetLastError());
9933 len
= sizeof(bindAddress
);
9934 dest
= accept(server
, (struct sockaddr
*)&bindAddress
, &len
);
9935 ok(dest
!= INVALID_SOCKET
, "failed to accept, error %lu\n", GetLastError());
9936 iret
= set_blocking(dest
, FALSE
);
9937 ok(!iret
, "failed to set nonblocking, error %lu\n", GetLastError());
9939 /* Test TransmitFile with no possible buffer */
9940 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, 0);
9941 ok(bret
, "TransmitFile failed unexpectedly.\n");
9942 iret
= recv(dest
, buf
, sizeof(buf
), 0);
9943 ok(iret
== -1, "Returned an unexpected buffer from TransmitFile (%d != -1).\n", iret
);
9945 /* Test TransmitFile with only buffer data */
9946 buffers
.Head
= &header_msg
[0];
9947 buffers
.HeadLength
= sizeof(header_msg
);
9948 buffers
.Tail
= &footer_msg
[0];
9949 buffers
.TailLength
= sizeof(footer_msg
);
9950 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, &buffers
, 0);
9951 ok(bret
, "TransmitFile failed unexpectedly.\n");
9952 iret
= recv(dest
, buf
, sizeof(buf
), 0);
9953 ok(iret
== sizeof(header_msg
)+sizeof(footer_msg
),
9954 "Returned an unexpected buffer from TransmitFile: %d\n", iret
);
9955 ok(memcmp(&buf
[0], &header_msg
[0], sizeof(header_msg
)) == 0,
9956 "TransmitFile header buffer did not match!\n");
9957 ok(memcmp(&buf
[sizeof(header_msg
)], &footer_msg
[0], sizeof(footer_msg
)) == 0,
9958 "TransmitFile footer buffer did not match!\n");
9960 /* Test TransmitFile with only file data */
9961 bret
= pTransmitFile(client
, file
, 0, 0, NULL
, NULL
, 0);
9962 ok(bret
, "TransmitFile failed unexpectedly.\n");
9963 compare_file(file
, dest
, 0);
9965 /* Test TransmitFile with both file and buffer data */
9966 buffers
.Head
= &header_msg
[0];
9967 buffers
.HeadLength
= sizeof(header_msg
);
9968 buffers
.Tail
= &footer_msg
[0];
9969 buffers
.TailLength
= sizeof(footer_msg
);
9970 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
9971 bret
= pTransmitFile(client
, file
, 0, 0, NULL
, &buffers
, 0);
9972 ok(bret
, "TransmitFile failed unexpectedly.\n");
9973 iret
= recv(dest
, buf
, sizeof(header_msg
), 0);
9974 ok(memcmp(buf
, &header_msg
[0], sizeof(header_msg
)) == 0,
9975 "TransmitFile header buffer did not match!\n");
9976 compare_file(file
, dest
, 0);
9977 iret
= recv(dest
, buf
, sizeof(footer_msg
), 0);
9978 ok(memcmp(buf
, &footer_msg
[0], sizeof(footer_msg
)) == 0,
9979 "TransmitFile footer buffer did not match!\n");
9981 /* Test overlapped TransmitFile */
9982 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
9983 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
9984 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, NULL
, 0);
9985 err
= WSAGetLastError();
9986 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
9987 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%ld != %d)\n",
9988 err
, ERROR_IO_PENDING
);
9989 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
9990 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
9991 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
9992 ok(total_sent
== file_size
,
9993 "Overlapped TransmitFile sent an unexpected number of bytes (%ld != %ld).\n",
9994 total_sent
, file_size
);
9995 compare_file(file
, dest
, 0);
9997 /* Test overlapped TransmitFile w/ start offset */
9998 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
9999 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
10001 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, NULL
, 0);
10002 err
= WSAGetLastError();
10003 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
10004 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%ld != %d)\n", err
, ERROR_IO_PENDING
);
10005 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
10006 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
10007 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
10008 ok(total_sent
== (file_size
- ov
.Offset
),
10009 "Overlapped TransmitFile sent an unexpected number of bytes (%ld != %ld).\n",
10010 total_sent
, file_size
- ov
.Offset
);
10011 compare_file(file
, dest
, ov
.Offset
);
10013 /* Test overlapped TransmitFile w/ file and buffer data */
10014 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
10015 buffers
.Head
= &header_msg
[0];
10016 buffers
.HeadLength
= sizeof(header_msg
);
10017 buffers
.Tail
= &footer_msg
[0];
10018 buffers
.TailLength
= sizeof(footer_msg
);
10019 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
10021 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, &buffers
, 0);
10022 err
= WSAGetLastError();
10023 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
10024 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%ld != %d)\n", err
, ERROR_IO_PENDING
);
10025 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
10026 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
10027 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
10028 ok(total_sent
== (file_size
+ buffers
.HeadLength
+ buffers
.TailLength
),
10029 "Overlapped TransmitFile sent an unexpected number of bytes (%ld != %ld).\n",
10030 total_sent
, file_size
+ buffers
.HeadLength
+ buffers
.TailLength
);
10031 iret
= recv(dest
, buf
, sizeof(header_msg
), 0);
10032 ok(memcmp(buf
, &header_msg
[0], sizeof(header_msg
)) == 0,
10033 "TransmitFile header buffer did not match!\n");
10034 compare_file(file
, dest
, 0);
10035 iret
= recv(dest
, buf
, sizeof(footer_msg
), 0);
10036 ok(memcmp(buf
, &footer_msg
[0], sizeof(footer_msg
)) == 0,
10037 "TransmitFile footer buffer did not match!\n");
10039 /* Test TransmitFile with a UDP datagram socket */
10040 closesocket(client
);
10041 client
= socket(AF_INET
, SOCK_DGRAM
, 0);
10042 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, 0);
10043 err
= WSAGetLastError();
10044 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
10045 ok(err
== WSAENOTCONN
, "TransmitFile triggered unexpected errno (%ld != %d)\n", err
, WSAENOTCONN
);
10048 CloseHandle(ov
.hEvent
);
10049 closesocket(client
);
10050 closesocket(server
);
10053 static void test_getpeername(void)
10056 struct sockaddr_in sa
, sa_out
;
10057 SOCKADDR_STORAGE ss
;
10059 const char buf
[] = "hello world";
10062 /* Test the parameter validation order. */
10063 ret
= getpeername(INVALID_SOCKET
, NULL
, NULL
);
10064 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
10065 ok(WSAGetLastError() == WSAENOTSOCK
,
10066 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
10068 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
10069 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
10071 ret
= getpeername(sock
, NULL
, NULL
);
10072 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
10073 ok(WSAGetLastError() == WSAENOTCONN
,
10074 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
10076 memset(&sa
, 0, sizeof(sa
));
10077 sa
.sin_family
= AF_INET
;
10078 sa
.sin_port
= htons(139);
10079 sa
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
10081 /* sendto does not change a socket's connection state. */
10082 ret
= sendto(sock
, buf
, sizeof(buf
), 0, (struct sockaddr
*)&sa
, sizeof(sa
));
10083 ok(ret
!= SOCKET_ERROR
,
10084 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
10086 ret
= getpeername(sock
, NULL
, NULL
);
10087 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
10088 ok(WSAGetLastError() == WSAENOTCONN
,
10089 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
10091 ret
= connect(sock
, (struct sockaddr
*)&sa
, sizeof(sa
));
10093 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
10095 ret
= getpeername(sock
, NULL
, NULL
);
10096 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
10097 ok(WSAGetLastError() == WSAEFAULT
,
10098 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
10100 /* Test crashes on Wine. */
10103 ret
= getpeername(sock
, (void*)0xdeadbeef, (void*)0xcafebabe);
10104 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
10105 ok(WSAGetLastError() == WSAEFAULT
,
10106 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
10109 ret
= getpeername(sock
, (struct sockaddr
*)&sa_out
, NULL
);
10110 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
10111 ok(WSAGetLastError() == WSAEFAULT
,
10112 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
10115 ret
= getpeername(sock
, NULL
, &sa_len
);
10116 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
10117 ok(WSAGetLastError() == WSAEFAULT
,
10118 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
10119 ok(!sa_len
, "got %d\n", sa_len
);
10122 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
10123 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
10124 ok(WSAGetLastError() == WSAEFAULT
,
10125 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
10126 ok(!sa_len
, "got %d\n", sa_len
);
10128 sa_len
= sizeof(ss
);
10129 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
10130 ok(ret
== 0, "Expected getpeername to return 0, got %d\n", ret
);
10131 ok(!memcmp(&sa
, &ss
, sizeof(sa
)),
10132 "Expected the returned structure to be identical to the connect structure\n");
10133 ok(sa_len
== sizeof(sa
), "got %d\n", sa_len
);
10138 static void test_sioRoutingInterfaceQuery(void)
10140 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
10141 struct sockaddr_in in
= {0}, out
= {0};
10148 sock
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
10149 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
10150 port
= CreateIoCompletionPort((HANDLE
)sock
, NULL
, 123, 0);
10152 WSASetLastError(0xdeadbeef);
10153 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), NULL
, NULL
, NULL
);
10154 ok(ret
== -1, "expected failure\n");
10155 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
10158 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
) - 1, &out
, sizeof(out
), &size
, NULL
, NULL
);
10159 ok(ret
== -1, "expected failure\n");
10160 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
10161 ok(size
== 0xdeadbeef, "got size %lu\n", size
);
10164 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, NULL
, sizeof(in
), &out
, sizeof(out
), &size
, NULL
, NULL
);
10165 ok(ret
== -1, "expected failure\n");
10166 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
10167 ok(size
== 0xdeadbeef, "got size %lu\n", size
);
10170 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), &size
, NULL
, NULL
);
10171 ok(ret
== -1, "expected failure\n");
10172 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "got error %u\n", WSAGetLastError());
10173 ok(size
== 0xdeadbeef, "got size %lu\n", size
);
10175 in
.sin_family
= AF_INET
;
10177 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), &size
, NULL
, NULL
);
10178 todo_wine
ok(ret
== -1, "expected failure\n");
10179 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
10180 todo_wine
ok(size
== 0xdeadbeef, "got size %lu\n", size
);
10182 in
.sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
10183 WSASetLastError(0xdeadbeef);
10185 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), &size
, NULL
, NULL
);
10186 ok(!ret
, "expected failure\n");
10187 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
10188 ok(size
== sizeof(out
), "got size %lu\n", size
);
10189 /* We expect the source address to be INADDR_LOOPBACK as well, but
10190 * there's no guarantee that a route to the loopback address exists,
10191 * so rather than introduce spurious test failures we do not test the
10196 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
) - 1, &size
, NULL
, NULL
);
10197 ok(ret
== -1, "expected failure\n");
10198 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
10199 todo_wine
ok(size
== sizeof(out
), "got size %lu\n", size
);
10202 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), NULL
, sizeof(out
), &size
, NULL
, NULL
);
10203 ok(ret
== -1, "expected failure\n");
10204 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
10205 ok(size
== 0xdeadbeef, "got size %lu\n", size
);
10207 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), NULL
, &overlapped
, NULL
);
10208 ok(ret
== -1, "expected failure\n");
10209 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
10210 ok(size
== 0xdeadbeef, "got size %lu\n", size
);
10212 WSASetLastError(0xdeadbeef);
10214 overlapped
.Internal
= 0xdeadbeef;
10215 overlapped
.InternalHigh
= 0xdeadbeef;
10216 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
), &out
, sizeof(out
), &size
, &overlapped
, NULL
);
10217 ok(!ret
, "expected failure\n");
10218 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
10219 ok(size
== sizeof(out
), "got size %lu\n", size
);
10221 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
10222 ok(ret
, "got error %lu\n", GetLastError());
10223 ok(!size
, "got size %lu\n", size
);
10224 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
10225 ok(!overlapped
.Internal
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
10226 ok(!overlapped
.InternalHigh
, "got size %Iu\n", overlapped
.InternalHigh
);
10231 sock
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
10233 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
),
10234 &out
, sizeof(out
), NULL
, &overlapped
, socket_apc
);
10235 ok(ret
== -1, "expected failure\n");
10236 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
10240 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &in
, sizeof(in
),
10241 &out
, sizeof(out
), &size
, &overlapped
, socket_apc
);
10242 ok(!ret
, "expected success\n");
10243 ok(size
== sizeof(out
), "got size %lu\n", size
);
10245 ret
= SleepEx(0, TRUE
);
10246 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
10247 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
10248 ok(!apc_error
, "got APC error %lu\n", apc_error
);
10249 ok(!apc_size
, "got APC size %lu\n", apc_size
);
10250 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
10255 static void test_sioAddressListChange(void)
10257 struct sockaddr_in bindAddress
;
10258 struct in_addr net_address
;
10259 WSAOVERLAPPED overlapped
, *olp
;
10261 DWORD num_bytes
, error
, tick
;
10262 SOCKET sock
, sock2
, sock3
;
10263 WSAEVENT event2
, event3
;
10270 /* Use gethostbyname to find the list of local network interfaces */
10271 h
= gethostbyname("");
10272 ok(!!h
, "failed to get interface list, error %u\n", WSAGetLastError());
10273 for (acount
= 0; h
->h_addr_list
[acount
]; acount
++);
10276 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
10280 net_address
.s_addr
= *(ULONG
*) h
->h_addr_list
[0];
10282 sock
= socket(AF_INET
, 0, IPPROTO_TCP
);
10283 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
10285 memset(&bindAddress
, 0, sizeof(bindAddress
));
10286 bindAddress
.sin_family
= AF_INET
;
10287 bindAddress
.sin_addr
.s_addr
= net_address
.s_addr
;
10288 SetLastError(0xdeadbeef);
10289 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
10290 ok (!ret
, "bind() failed with error %ld\n", GetLastError());
10291 set_blocking(sock
, FALSE
);
10293 memset(&overlapped
, 0, sizeof(overlapped
));
10294 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
10295 SetLastError(0xdeadbeef);
10296 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
10297 error
= GetLastError();
10298 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error
);
10299 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%lx\n", error
);
10301 CloseHandle(overlapped
.hEvent
);
10304 sock
= socket(AF_INET
, 0, IPPROTO_TCP
);
10305 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
10307 SetLastError(0xdeadbeef);
10308 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
10309 ok (!ret
, "bind() failed with error %ld\n", GetLastError());
10310 set_blocking(sock
, TRUE
);
10312 memset(&overlapped
, 0, sizeof(overlapped
));
10313 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
10314 SetLastError(0xdeadbeef);
10315 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
10316 error
= GetLastError();
10317 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error
);
10318 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%lx\n", error
);
10320 CloseHandle(overlapped
.hEvent
);
10323 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
10324 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
10326 SetLastError(0xdeadbeef);
10327 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
10328 ok (!ret
, "bind() failed with error %ld\n", GetLastError());
10329 set_blocking(sock
, FALSE
);
10331 memset(&overlapped
, 0, sizeof(overlapped
));
10332 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
10333 SetLastError(0xdeadbeef);
10334 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
10335 error
= GetLastError();
10336 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error
);
10337 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%lx\n", error
);
10339 CloseHandle(overlapped
.hEvent
);
10342 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
10343 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
10345 SetLastError(0xdeadbeef);
10346 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
10347 ok (!ret
, "bind() failed with error %ld\n", GetLastError());
10348 set_blocking(sock
, TRUE
);
10350 memset(&overlapped
, 0, sizeof(overlapped
));
10351 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
10352 SetLastError(0xdeadbeef);
10353 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
10354 error
= GetLastError();
10355 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error
);
10356 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%lx\n", error
);
10358 CloseHandle(overlapped
.hEvent
);
10361 /* When the socket is overlapped non-blocking and the list change is requested without
10362 * an overlapped structure the error will be different. */
10363 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
10364 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
10366 SetLastError(0xdeadbeef);
10367 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
10368 ok (!ret
, "bind() failed with error %ld\n", GetLastError());
10369 set_blocking(sock
, FALSE
);
10371 SetLastError(0xdeadbeef);
10372 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
10373 error
= GetLastError();
10374 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error
);
10375 ok (error
== WSAEWOULDBLOCK
, "expected 10035, got %ld\n", error
);
10377 io_port
= CreateIoCompletionPort( (HANDLE
)sock
, NULL
, 0, 0 );
10378 ok (io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
10380 set_blocking(sock
, FALSE
);
10381 memset(&overlapped
, 0, sizeof(overlapped
));
10382 SetLastError(0xdeadbeef);
10383 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
10384 error
= GetLastError();
10385 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %lu\n", error
);
10386 ok (error
== ERROR_IO_PENDING
, "expected ERROR_IO_PENDING got %lu\n", error
);
10388 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10389 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 0 );
10390 ok(!bret
, "failed to get completion status %u\n", bret
);
10391 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
10392 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10396 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10397 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 0 );
10398 ok(!bret
, "failed to get completion status %u\n", bret
);
10399 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %lu\n", GetLastError());
10400 ok(olp
== &overlapped
, "Overlapped structure is at %p\n", olp
);
10402 CloseHandle(io_port
);
10404 /* Misuse of the API by using a blocking socket and not using an overlapped structure,
10405 * this leads to a hang forever. */
10408 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
10410 SetLastError(0xdeadbeef);
10411 bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
10413 set_blocking(sock
, TRUE
);
10414 WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
10420 if (!winetest_interactive
)
10422 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
10426 /* Bind an overlapped socket to the first found network interface */
10427 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
10428 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
10429 sock2
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
10430 ok(sock2
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
10431 sock3
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
10432 ok(sock3
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
10434 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
10435 ok(!ret
, "bind failed unexpectedly\n");
10436 ret
= bind(sock2
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
10437 ok(!ret
, "bind failed unexpectedly\n");
10438 ret
= bind(sock3
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
10439 ok(!ret
, "bind failed unexpectedly\n");
10441 set_blocking(sock2
, FALSE
);
10442 set_blocking(sock3
, FALSE
);
10444 /* Wait for address changes, request that the user connects/disconnects an interface */
10445 memset(&overlapped
, 0, sizeof(overlapped
));
10446 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
10447 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
10448 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
10449 ok(WSAGetLastError() == WSA_IO_PENDING
, "Expected pending last error, got %d\n", WSAGetLastError());
10451 ret
= WSAIoctl(sock2
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
10452 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
10453 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "Expected would block last error, got %d\n", WSAGetLastError());
10455 event2
= WSACreateEvent();
10456 event3
= WSACreateEvent();
10457 ret
= WSAEventSelect (sock2
, event2
, FD_ADDRESS_LIST_CHANGE
);
10458 ok(!ret
, "WSAEventSelect failed with %d\n", WSAGetLastError());
10459 /* sock3 did not request SIO_ADDRESS_LIST_CHANGE but it is trying to wait anyway */
10460 ret
= WSAEventSelect (sock3
, event3
, FD_ADDRESS_LIST_CHANGE
);
10461 ok(!ret
, "WSAEventSelect failed with %d\n", WSAGetLastError());
10463 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
10464 " change the ipv4 address of any of the local network interfaces (15 second timeout).\n");
10465 tick
= GetTickCount();
10466 ret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
10467 ok(ret
== WAIT_OBJECT_0
, "failed to get overlapped event %u\n", ret
);
10469 ret
= WaitForSingleObject(event2
, 500);
10471 ok(ret
== WAIT_OBJECT_0
, "failed to get change event %u\n", ret
);
10473 ret
= WaitForSingleObject(event3
, 500);
10474 ok(ret
== WAIT_TIMEOUT
, "unexpected change event\n");
10476 trace("Spent %ld ms waiting.\n", GetTickCount() - tick
);
10478 WSACloseEvent(event2
);
10479 WSACloseEvent(event3
);
10482 closesocket(sock2
);
10483 closesocket(sock3
);
10487 * Provide consistent initialization for the AcceptEx IOCP tests.
10489 static SOCKET
setup_iocp_src(struct sockaddr_in
*bindAddress
)
10494 src
= socket(AF_INET
, SOCK_STREAM
, 0);
10495 ok(src
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
10497 memset(bindAddress
, 0, sizeof(*bindAddress
));
10498 bindAddress
->sin_family
= AF_INET
;
10499 bindAddress
->sin_addr
.s_addr
= inet_addr("127.0.0.1");
10500 iret
= bind(src
, (struct sockaddr
*)bindAddress
, sizeof(*bindAddress
));
10501 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
10503 socklen
= sizeof(*bindAddress
);
10504 iret
= getsockname(src
, (struct sockaddr
*)bindAddress
, &socklen
);
10505 ok(!iret
, "failed to get address, error %u\n", WSAGetLastError());
10507 iret
= set_blocking(src
, FALSE
);
10508 ok(!iret
, "failed to make socket non-blocking, error %u\n", WSAGetLastError());
10510 iret
= listen(src
, 5);
10511 ok(!iret
, "failed to listen, error %u\n", WSAGetLastError());
10516 static void test_completion_port(void)
10519 WSAOVERLAPPED ov
, *olp
;
10520 SOCKET src
, dest
, dup
, connector
= INVALID_SOCKET
;
10521 WSAPROTOCOL_INFOA info
;
10524 DWORD num_bytes
, flags
;
10528 struct sockaddr_in bindAddress
;
10529 GUID acceptExGuid
= WSAID_ACCEPTEX
;
10530 LPFN_ACCEPTEX pAcceptEx
= NULL
;
10533 memset(buf
, 0, sizeof(buf
));
10534 io_port
= CreateIoCompletionPort(INVALID_HANDLE_VALUE
, NULL
, 0, 0);
10535 ok( io_port
!= NULL
, "Failed to create completion port %lu\n", GetLastError());
10537 memset(&ov
, 0, sizeof(ov
));
10539 tcp_socketpair(&src
, &dest
);
10541 bufs
.len
= sizeof(buf
);
10545 io_port
= CreateIoCompletionPort( (HANDLE
)dest
, io_port
, 125, 0 );
10546 ok(io_port
!= NULL
, "Failed to create completion port %lu\n", GetLastError());
10548 SetLastError(0xdeadbeef);
10550 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
10551 ok(iret
== SOCKET_ERROR
, "WSARecv returned %d\n", iret
);
10552 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %ld\n", GetLastError());
10556 close_with_rst(src
);
10558 SetLastError(0xdeadbeef);
10560 num_bytes
= 0xdeadbeef;
10561 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10563 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
10564 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %d\n", bret
);
10565 ok(GetLastError() == ERROR_NETNAME_DELETED
, "Last error was %ld\n", GetLastError());
10566 ok(key
== 125, "Key is %Iu\n", key
);
10567 ok(num_bytes
== 0, "Number of bytes received is %lu\n", num_bytes
);
10568 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
10570 SetLastError(0xdeadbeef);
10572 num_bytes
= 0xdeadbeef;
10573 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10575 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
10576 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %d\n", bret
);
10577 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
10578 ok(key
== 0xdeadbeef, "Key is %Iu\n", key
);
10579 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes
);
10580 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10582 if (dest
!= INVALID_SOCKET
)
10585 memset(&ov
, 0, sizeof(ov
));
10587 tcp_socketpair(&src
, &dest
);
10589 bufs
.len
= sizeof(buf
);
10593 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 125, 0);
10594 ok(io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
10596 set_blocking(dest
, FALSE
);
10598 close_with_rst(src
);
10602 num_bytes
= 0xdeadbeef;
10603 SetLastError(0xdeadbeef);
10605 iret
= WSASend(dest
, &bufs
, 1, &num_bytes
, 0, &ov
, NULL
);
10606 ok(iret
== SOCKET_ERROR
, "WSASend failed - %d\n", iret
);
10607 ok(GetLastError() == WSAECONNRESET
, "Last error was %ld\n", GetLastError());
10608 ok(num_bytes
== 0xdeadbeef, "Managed to send %ld\n", num_bytes
);
10610 SetLastError(0xdeadbeef);
10612 num_bytes
= 0xdeadbeef;
10613 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10615 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10616 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
10617 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
10618 ok(key
== 0xdeadbeef, "Key is %Iu\n", key
);
10619 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes
);
10620 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10622 if (dest
!= INVALID_SOCKET
)
10625 /* Test IOCP response on successful immediate read. */
10626 tcp_socketpair(&src
, &dest
);
10628 bufs
.len
= sizeof(buf
);
10631 SetLastError(0xdeadbeef);
10633 iret
= WSASend(src
, &bufs
, 1, &num_bytes
, 0, &ov
, NULL
);
10634 ok(!iret
, "WSASend failed - %d, last error %lu\n", iret
, GetLastError());
10635 ok(num_bytes
== sizeof(buf
), "Managed to send %ld\n", num_bytes
);
10637 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 125, 0);
10638 ok(io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
10639 set_blocking(dest
, FALSE
);
10641 FD_ZERO(&fds_recv
);
10642 FD_SET(dest
, &fds_recv
);
10643 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
10645 num_bytes
= 0xdeadbeef;
10648 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
10649 ok(!iret
, "WSARecv failed - %d, last error %lu\n", iret
, GetLastError());
10650 ok(num_bytes
== sizeof(buf
), "Managed to read %ld\n", num_bytes
);
10652 SetLastError(0xdeadbeef);
10654 num_bytes
= 0xdeadbeef;
10655 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10657 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10658 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
10659 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
10660 ok(key
== 125, "Key is %Iu\n", key
);
10661 ok(num_bytes
== sizeof(buf
), "Number of bytes transferred is %lu\n", num_bytes
);
10662 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
10664 /* Test IOCP response on graceful shutdown. */
10667 FD_ZERO(&fds_recv
);
10668 FD_SET(dest
, &fds_recv
);
10669 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
10671 num_bytes
= 0xdeadbeef;
10673 memset(&ov
, 0, sizeof(ov
));
10675 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
10676 ok(!iret
, "WSARecv failed - %d, last error %lu\n", iret
, GetLastError());
10677 ok(!num_bytes
, "Managed to read %ld\n", num_bytes
);
10679 SetLastError(0xdeadbeef);
10681 num_bytes
= 0xdeadbeef;
10682 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10684 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10685 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
10686 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
10687 ok(key
== 125, "Key is %Iu\n", key
);
10688 ok(!num_bytes
, "Number of bytes transferred is %lu\n", num_bytes
);
10689 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
10692 src
= INVALID_SOCKET
;
10694 dest
= INVALID_SOCKET
;
10696 /* Test IOCP response on hard shutdown. This was the condition that triggered
10697 * a crash in an actual app (bug 38980). */
10698 tcp_socketpair(&src
, &dest
);
10700 bufs
.len
= sizeof(buf
);
10703 memset(&ov
, 0, sizeof(ov
));
10705 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 125, 0);
10706 ok(io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
10707 set_blocking(dest
, FALSE
);
10709 close_with_rst(src
);
10711 FD_ZERO(&fds_recv
);
10712 FD_SET(dest
, &fds_recv
);
10713 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
10715 num_bytes
= 0xdeadbeef;
10716 SetLastError(0xdeadbeef);
10718 /* Somehow a hard shutdown doesn't work on my Linux box. It seems SO_LINGER is ignored. */
10719 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
10720 ok(iret
== SOCKET_ERROR
, "WSARecv failed - %d\n", iret
);
10721 ok(GetLastError() == WSAECONNRESET
, "Last error was %ld\n", GetLastError());
10722 ok(num_bytes
== 0xdeadbeef, "Managed to read %ld\n", num_bytes
);
10724 SetLastError(0xdeadbeef);
10726 num_bytes
= 0xdeadbeef;
10727 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10729 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10730 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
10731 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
10732 ok(key
== 0xdeadbeef, "Key is %Iu\n", key
);
10733 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes
);
10734 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10738 /* Test reading from a non-connected socket, mostly because the above test is marked todo. */
10739 dest
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
10740 ok(dest
!= INVALID_SOCKET
, "socket() failed\n");
10742 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 125, 0);
10743 ok(io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
10744 set_blocking(dest
, FALSE
);
10746 num_bytes
= 0xdeadbeef;
10747 SetLastError(0xdeadbeef);
10748 memset(&ov
, 0, sizeof(ov
));
10750 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
10751 ok(iret
== SOCKET_ERROR
, "WSARecv failed - %d\n", iret
);
10752 ok(GetLastError() == WSAENOTCONN
, "Last error was %ld\n", GetLastError());
10753 ok(num_bytes
== 0xdeadbeef, "Managed to read %ld\n", num_bytes
);
10755 SetLastError(0xdeadbeef);
10757 num_bytes
= 0xdeadbeef;
10758 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10760 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10761 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
10762 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
10763 ok(key
== 0xdeadbeef, "Key is %Iu\n", key
);
10764 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes
);
10765 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10767 num_bytes
= 0xdeadbeef;
10770 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
10771 ok(dest
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
10773 iret
= WSAIoctl(dest
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
10774 &pAcceptEx
, sizeof(pAcceptEx
), &num_bytes
, NULL
, NULL
);
10775 ok(!iret
, "failed to get AcceptEx, error %u\n", WSAGetLastError());
10777 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
10779 src
= setup_iocp_src(&bindAddress
);
10781 SetLastError(0xdeadbeef);
10783 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
10784 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
10786 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
10787 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %ld\n", GetLastError());
10789 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
10790 ok(io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
10793 src
= INVALID_SOCKET
;
10795 SetLastError(0xdeadbeef);
10797 num_bytes
= 0xdeadbeef;
10798 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10800 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
10801 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10802 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %ld\n", GetLastError());
10803 ok(key
== 125, "Key is %Iu\n", key
);
10804 ok(num_bytes
== 0, "Number of bytes transferred is %lu\n", num_bytes
);
10805 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
10806 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %Ix\n", olp
? olp
->Internal
: 0);
10808 SetLastError(0xdeadbeef);
10810 num_bytes
= 0xdeadbeef;
10811 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10812 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10813 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10814 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
10815 ok(key
== 0xdeadbeef, "Key is %Iu\n", key
);
10816 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes
);
10817 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10819 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
10821 src
= setup_iocp_src(&bindAddress
);
10823 SetLastError(0xdeadbeef);
10825 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
10826 ok(io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
10828 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
10829 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
10831 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
10832 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %ld\n", GetLastError());
10835 src
= INVALID_SOCKET
;
10837 SetLastError(0xdeadbeef);
10839 num_bytes
= 0xdeadbeef;
10840 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10842 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
10843 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10844 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %ld\n", GetLastError());
10845 ok(key
== 125, "Key is %Iu\n", key
);
10846 ok(num_bytes
== 0, "Number of bytes transferred is %lu\n", num_bytes
);
10847 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
10848 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %Ix\n", olp
? olp
->Internal
: 0);
10850 SetLastError(0xdeadbeef);
10852 num_bytes
= 0xdeadbeef;
10853 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10854 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10855 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10856 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
10857 ok(key
== 0xdeadbeef, "Key is %Iu\n", key
);
10858 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes
);
10859 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10861 /* Test IOCP with duplicated handle */
10863 src
= setup_iocp_src(&bindAddress
);
10865 SetLastError(0xdeadbeef);
10867 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
10868 ok(io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
10870 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
10871 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
10872 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
10874 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
10875 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
10877 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
10878 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %ld\n", GetLastError());
10880 SetLastError(0xdeadbeef);
10882 num_bytes
= 0xdeadbeef;
10883 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10884 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10885 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10886 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
10887 ok(key
== 0xdeadbeef, "Key is %Iu\n", key
);
10888 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes
);
10889 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10892 src
= INVALID_SOCKET
;
10894 dup
= INVALID_SOCKET
;
10896 SetLastError(0xdeadbeef);
10898 num_bytes
= 0xdeadbeef;
10899 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10900 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
10901 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10902 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %ld\n", GetLastError());
10903 ok(key
== 125, "Key is %Iu\n", key
);
10904 ok(num_bytes
== 0, "Number of bytes transferred is %lu\n", num_bytes
);
10905 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
10906 ok(olp
&& olp
->Internal
== (ULONG
)STATUS_CANCELLED
, "Internal status is %Ix\n", olp
? olp
->Internal
: 0);
10908 SetLastError(0xdeadbeef);
10910 num_bytes
= 0xdeadbeef;
10911 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10912 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10913 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10914 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
10915 ok(key
== 0xdeadbeef, "Key is %Iu\n", key
);
10916 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes
);
10917 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10919 /* Test IOCP with duplicated handle (closing duplicated handle) */
10921 src
= setup_iocp_src(&bindAddress
);
10923 SetLastError(0xdeadbeef);
10925 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
10926 ok(io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
10928 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
10929 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
10930 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
10932 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
10933 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
10935 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
10936 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %ld\n", GetLastError());
10939 dup
= INVALID_SOCKET
;
10941 SetLastError(0xdeadbeef);
10943 num_bytes
= 0xdeadbeef;
10944 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10945 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10946 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10947 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
10948 ok(key
== 0xdeadbeef, "Key is %Iu\n", key
);
10949 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes
);
10950 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10952 SetLastError(0xdeadbeef);
10954 num_bytes
= 0xdeadbeef;
10955 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10956 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10957 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10958 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
10959 ok(key
== 0xdeadbeef, "Key is %Iu\n", key
);
10960 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes
);
10961 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10964 src
= INVALID_SOCKET
;
10966 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
10967 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10968 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %ld\n", GetLastError());
10969 ok(key
== 125, "Key is %Iu\n", key
);
10970 ok(num_bytes
== 0, "Number of bytes transferred is %lu\n", num_bytes
);
10971 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
10972 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %Ix\n", olp
? olp
->Internal
: 0);
10974 SetLastError(0xdeadbeef);
10976 num_bytes
= 0xdeadbeef;
10977 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
10978 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
10979 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
10980 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
10981 ok(key
== 0xdeadbeef, "Key is %Iu\n", key
);
10982 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes
);
10983 ok(!olp
, "Overlapped structure is at %p\n", olp
);
10985 /* Test IOCP with duplicated handle (closing original handle) */
10987 src
= setup_iocp_src(&bindAddress
);
10989 SetLastError(0xdeadbeef);
10991 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
10992 ok(io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
10994 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
10995 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
10996 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
10998 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
10999 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
11001 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
11002 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %ld\n", GetLastError());
11005 src
= INVALID_SOCKET
;
11007 SetLastError(0xdeadbeef);
11009 num_bytes
= 0xdeadbeef;
11010 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
11011 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
11012 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
11013 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
11014 ok(key
== 0xdeadbeef, "Key is %Iu\n", key
);
11015 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes
);
11016 ok(!olp
, "Overlapped structure is at %p\n", olp
);
11019 dup
= INVALID_SOCKET
;
11021 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
11022 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
11023 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %ld\n", GetLastError());
11024 ok(key
== 125, "Key is %Iu\n", key
);
11025 ok(num_bytes
== 0, "Number of bytes transferred is %lu\n", num_bytes
);
11026 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
11027 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %Ix\n", olp
? olp
->Internal
: 0);
11029 SetLastError(0xdeadbeef);
11031 num_bytes
= 0xdeadbeef;
11032 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
11033 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
11034 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
11035 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
11036 ok(key
== 0xdeadbeef, "Key is %Iu\n", key
);
11037 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes
);
11038 ok(!olp
, "Overlapped structure is at %p\n", olp
);
11040 /* Test IOCP without AcceptEx */
11042 src
= setup_iocp_src(&bindAddress
);
11044 SetLastError(0xdeadbeef);
11046 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
11047 ok(io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
11050 src
= INVALID_SOCKET
;
11052 SetLastError(0xdeadbeef);
11054 num_bytes
= 0xdeadbeef;
11055 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
11056 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
11057 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
11058 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
11059 ok(key
== 0xdeadbeef, "Key is %Iu\n", key
);
11060 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes
);
11061 ok(!olp
, "Overlapped structure is at %p\n", olp
);
11065 src
= setup_iocp_src(&bindAddress
);
11067 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
11068 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
11070 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
11071 ok(io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
11073 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 236, 0);
11074 ok(io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
11076 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
11077 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
11079 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
11080 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %ld\n", GetLastError());
11082 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
11083 ok(iret
== 0, "connecting to accepting socket failed, error %ld\n", GetLastError());
11085 closesocket(connector
);
11086 connector
= INVALID_SOCKET
;
11088 SetLastError(0xdeadbeef);
11090 num_bytes
= 0xdeadbeef;
11091 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
11093 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
11094 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
11095 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
11096 ok(key
== 125, "Key is %Iu\n", key
);
11097 ok(num_bytes
== 0, "Number of bytes transferred is %lu\n", num_bytes
);
11098 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
11099 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %Ix\n", olp
? olp
->Internal
: 0);
11101 SetLastError(0xdeadbeef);
11103 num_bytes
= 0xdeadbeef;
11104 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
11105 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
11106 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
11107 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
11108 ok(key
== 0xdeadbeef, "Key is %Iu\n", key
);
11109 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes
);
11110 ok(!olp
, "Overlapped structure is at %p\n", olp
);
11112 if (dest
!= INVALID_SOCKET
)
11114 if (src
!= INVALID_SOCKET
)
11119 src
= setup_iocp_src(&bindAddress
);
11121 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
11122 ok(dest
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
11124 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
11125 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
11127 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
11128 ok(io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
11130 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 236, 0);
11131 ok(io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
11133 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
11134 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
11136 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
11137 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %ld\n", GetLastError());
11139 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
11140 ok(iret
== 0, "connecting to accepting socket failed, error %ld\n", GetLastError());
11142 iret
= send(connector
, buf
, 1, 0);
11143 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
11148 dest
= INVALID_SOCKET
;
11150 SetLastError(0xdeadbeef);
11152 num_bytes
= 0xdeadbeef;
11153 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
11155 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
11156 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
11157 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
11158 ok(key
== 125, "Key is %Iu\n", key
);
11159 ok(num_bytes
== 1, "Number of bytes transferred is %lu\n", num_bytes
);
11160 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
11161 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %Ix\n", olp
? olp
->Internal
: 0);
11163 SetLastError(0xdeadbeef);
11165 num_bytes
= 0xdeadbeef;
11166 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
11167 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
11168 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
11169 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
11170 ok(key
== 0xdeadbeef, "Key is %Iu\n", key
);
11171 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes
);
11172 ok(!olp
, "Overlapped structure is at %p\n", olp
);
11174 if (src
!= INVALID_SOCKET
)
11176 if (connector
!= INVALID_SOCKET
)
11177 closesocket(connector
);
11181 src
= setup_iocp_src(&bindAddress
);
11183 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
11184 ok(dest
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
11186 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
11187 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
11189 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
11190 ok(io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
11192 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 236, 0);
11193 ok(io_port
!= NULL
, "failed to create completion port %lu\n", GetLastError());
11195 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
11196 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
11198 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
11199 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %ld\n", GetLastError());
11201 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
11202 ok(iret
== 0, "connecting to accepting socket failed, error %ld\n", GetLastError());
11206 SetLastError(0xdeadbeef);
11208 num_bytes
= 0xdeadbeef;
11209 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
11211 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
11212 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
11213 ok(GetLastError() == ERROR_OPERATION_ABORTED
11214 || GetLastError() == ERROR_CONNECTION_ABORTED
, "got error %lu\n", GetLastError());
11215 ok(key
== 125, "Key is %Iu\n", key
);
11216 ok(num_bytes
== 0, "Number of bytes transferred is %lu\n", num_bytes
);
11217 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
11218 ok((NTSTATUS
)olp
->Internal
== STATUS_CANCELLED
11219 || (NTSTATUS
)olp
->Internal
== STATUS_CONNECTION_ABORTED
, "got status %#Ix\n", olp
->Internal
);
11221 SetLastError(0xdeadbeef);
11223 num_bytes
= 0xdeadbeef;
11224 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
11225 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
11226 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
11227 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %ld\n", GetLastError());
11228 ok(key
== 0xdeadbeef, "Key is %Iu\n", key
);
11229 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes
);
11230 ok(!olp
, "Overlapped structure is at %p\n", olp
);
11233 closesocket(connector
);
11234 CloseHandle(io_port
);
11237 static void test_connect_completion_port(void)
11239 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
11240 GUID connectex_guid
= WSAID_CONNECTEX
;
11241 SOCKET connector
, listener
, acceptor
;
11242 struct sockaddr_in addr
, destaddr
;
11243 LPFN_CONNECTEX pConnectEx
;
11249 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
11251 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11252 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
11254 memset(&addr
, 0, sizeof(addr
));
11255 addr
.sin_family
= AF_INET
;
11256 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
11257 ret
= bind(listener
, (struct sockaddr
*)&addr
, sizeof(addr
));
11258 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
11259 addrlen
= sizeof(destaddr
);
11260 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &addrlen
);
11261 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
11263 ret
= listen(listener
, 1);
11264 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
11266 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11267 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
11269 ret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectex_guid
, sizeof(connectex_guid
),
11270 &pConnectEx
, sizeof(pConnectEx
), &size
, NULL
, NULL
);
11271 ok(!ret
, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
11273 /* connect() does not queue completion. */
11275 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
11276 ok(!!port
, "failed to create port, error %lu\n", GetLastError());
11278 ret
= connect(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
11279 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
11280 acceptor
= accept(listener
, NULL
, NULL
);
11281 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
11282 closesocket(acceptor
);
11284 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
11285 ok(!ret
, "expected failure\n");
11286 ok(GetLastError() == WAIT_TIMEOUT
, "got error %lu\n", GetLastError());
11288 closesocket(connector
);
11291 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11292 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
11293 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
11294 ok(!!port
, "failed to create port, error %lu\n", GetLastError());
11295 set_blocking(connector
, FALSE
);
11297 ret
= connect(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
11298 ok(ret
== -1, "expected failure\n");
11299 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
11300 acceptor
= accept(listener
, NULL
, NULL
);
11301 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
11302 closesocket(acceptor
);
11304 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
11305 ok(!ret
, "expected failure\n");
11306 ok(GetLastError() == WAIT_TIMEOUT
, "got error %lu\n", GetLastError());
11308 closesocket(connector
);
11311 /* ConnectEx() queues completion. */
11313 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11314 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
11315 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
11316 ok(!!port
, "failed to create port, error %lu\n", GetLastError());
11317 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
11318 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
11320 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
11321 NULL
, 0, &size
, &overlapped
);
11322 ok(!ret
, "expected failure\n");
11323 ok(GetLastError() == ERROR_IO_PENDING
, "got error %lu\n", GetLastError());
11324 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
11325 ok(!ret
, "wait failed\n");
11326 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
11327 ok(ret
, "got error %lu\n", GetLastError());
11328 ok(!size
, "got %lu bytes\n", size
);
11329 acceptor
= accept(listener
, NULL
, NULL
);
11330 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
11331 closesocket(acceptor
);
11335 overlapped_ptr
= NULL
;
11336 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
11337 ok(ret
, "got error %lu\n", GetLastError());
11338 ok(!key
, "got key %#Ix\n", key
);
11339 ok(!size
, "got %lu bytes\n", size
);
11340 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
11342 closesocket(connector
);
11345 /* Test ConnectEx() with a non-empty buffer. */
11347 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11348 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
11349 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
11350 ok(!!port
, "failed to create port, error %lu\n", GetLastError());
11351 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
11352 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
11354 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
11355 (void *)"one", 3, &size
, &overlapped
);
11356 ok(!ret
, "expected failure\n");
11357 ok(GetLastError() == ERROR_IO_PENDING
, "got error %lu\n", GetLastError());
11358 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
11359 ok(!ret
, "wait failed\n");
11360 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
11361 ok(ret
, "got error %lu\n", GetLastError());
11362 ok(size
== 3, "got %lu bytes\n", size
);
11363 acceptor
= accept(listener
, NULL
, NULL
);
11364 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
11365 closesocket(acceptor
);
11369 overlapped_ptr
= NULL
;
11370 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
11371 ok(ret
, "got error %lu\n", GetLastError());
11372 ok(!key
, "got key %#Ix\n", key
);
11373 ok(size
== 3, "got %lu bytes\n", size
);
11374 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
11376 closesocket(connector
);
11379 /* Suppress completion by setting the low bit. */
11381 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11382 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
11383 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
11384 ok(!!port
, "failed to create port, error %lu\n", GetLastError());
11385 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
11386 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
11388 overlapped
.hEvent
= (HANDLE
)((ULONG_PTR
)overlapped
.hEvent
| 1);
11390 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
11391 NULL
, 0, &size
, &overlapped
);
11392 ok(!ret
, "expected failure\n");
11393 ok(GetLastError() == ERROR_IO_PENDING
, "got error %lu\n", GetLastError());
11394 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
11395 ok(!ret
, "wait failed\n");
11396 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
11397 ok(ret
, "got error %lu\n", GetLastError());
11398 ok(!size
, "got %lu bytes\n", size
);
11399 acceptor
= accept(listener
, NULL
, NULL
);
11400 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
11401 closesocket(acceptor
);
11403 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
11404 ok(!ret
, "expected failure\n");
11405 ok(GetLastError() == WAIT_TIMEOUT
, "got error %lu\n", GetLastError());
11407 closesocket(connector
);
11410 overlapped
.hEvent
= (HANDLE
)((ULONG_PTR
)overlapped
.hEvent
& ~1);
11412 /* Skip completion on success. */
11414 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11415 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
11416 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
11417 ok(!!port
, "failed to create port, error %lu\n", GetLastError());
11418 ret
= SetFileCompletionNotificationModes((HANDLE
)connector
, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS
);
11419 ok(ret
, "got error %lu\n", GetLastError());
11420 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
11421 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
11423 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
11424 NULL
, 0, &size
, &overlapped
);
11425 ok(!ret
, "expected failure\n");
11426 ok(GetLastError() == ERROR_IO_PENDING
, "got error %lu\n", GetLastError());
11427 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
11428 ok(!ret
, "wait failed\n");
11429 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
11430 ok(ret
, "got error %lu\n", GetLastError());
11431 ok(!size
, "got %lu bytes\n", size
);
11432 acceptor
= accept(listener
, NULL
, NULL
);
11433 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
11434 closesocket(acceptor
);
11438 overlapped_ptr
= NULL
;
11439 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
11440 ok(ret
, "got error %lu\n", GetLastError());
11441 ok(!key
, "got key %#Ix\n", key
);
11442 ok(!size
, "got %lu bytes\n", size
);
11443 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
11445 closesocket(connector
);
11448 closesocket(listener
);
11450 /* Connect to an invalid address. */
11452 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11453 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
11454 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
11455 ok(!!port
, "failed to create port, error %lu\n", GetLastError());
11456 ret
= SetFileCompletionNotificationModes((HANDLE
)connector
, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS
);
11457 ok(ret
, "got error %lu\n", GetLastError());
11458 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
11459 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
11461 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
11462 NULL
, 0, &size
, &overlapped
);
11463 ok(!ret
, "expected failure\n");
11464 ok(GetLastError() == ERROR_IO_PENDING
, "got error %lu\n", GetLastError());
11465 ret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
11466 ok(!ret
, "wait failed\n");
11467 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
11468 ok(!ret
, "expected failure\n");
11469 ok(GetLastError() == ERROR_CONNECTION_REFUSED
, "got error %lu\n", GetLastError());
11470 ok(!size
, "got %lu bytes\n", size
);
11474 overlapped_ptr
= NULL
;
11475 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
11476 ok(!ret
, "expected failure\n");
11477 ok(GetLastError() == ERROR_CONNECTION_REFUSED
, "got error %lu\n", GetLastError());
11478 ok(!key
, "got key %#Ix\n", key
);
11479 ok(!size
, "got %lu bytes\n", size
);
11480 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
11482 closesocket(connector
);
11486 static void test_shutdown_completion_port(void)
11488 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
11489 GUID disconnectex_guid
= WSAID_DISCONNECTEX
;
11490 struct sockaddr_in addr
, destaddr
;
11491 LPFN_DISCONNECTEX pDisconnectEx
;
11492 SOCKET listener
, server
, client
;
11498 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
11500 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11501 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
11503 memset(&addr
, 0, sizeof(addr
));
11504 addr
.sin_family
= AF_INET
;
11505 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
11506 ret
= bind(listener
, (struct sockaddr
*)&addr
, sizeof(addr
));
11507 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
11508 addrlen
= sizeof(destaddr
);
11509 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &addrlen
);
11510 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
11512 ret
= listen(listener
, 1);
11513 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
11515 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11516 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
11518 ret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &disconnectex_guid
, sizeof(disconnectex_guid
),
11519 &pDisconnectEx
, sizeof(pDisconnectEx
), &size
, NULL
, NULL
);
11520 ok(!ret
, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
11522 /* shutdown() does not queue completion. */
11524 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
11525 ok(!!port
, "failed to create port, error %lu\n", GetLastError());
11526 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
11527 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
11528 server
= accept(listener
, NULL
, NULL
);
11529 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
11531 ret
= shutdown(client
, SD_BOTH
);
11532 ok(!ret
, "failed to shutdown, error %u\n", WSAGetLastError());
11534 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
11535 ok(!ret
, "expected failure\n");
11536 ok(GetLastError() == WAIT_TIMEOUT
, "got error %lu\n", GetLastError());
11538 closesocket(server
);
11539 closesocket(client
);
11542 /* WSASendDisconnect() and WSARecvDisconnect() do not queue completion. */
11544 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11545 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
11546 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
11547 ok(!!port
, "failed to create port, error %lu\n", GetLastError());
11548 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
11549 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
11550 server
= accept(listener
, NULL
, NULL
);
11551 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
11553 ret
= WSASendDisconnect(client
, NULL
);
11554 ok(!ret
, "failed to shutdown, error %u\n", WSAGetLastError());
11556 ret
= WSARecvDisconnect(client
, NULL
);
11557 ok(!ret
, "failed to shutdown, error %u\n", WSAGetLastError());
11559 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
11560 ok(!ret
, "expected failure\n");
11561 ok(GetLastError() == WAIT_TIMEOUT
, "got error %lu\n", GetLastError());
11563 closesocket(server
);
11564 closesocket(client
);
11567 /* DisconnectEx() queues completion. */
11569 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11570 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
11571 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
11572 ok(!!port
, "failed to create port, error %lu\n", GetLastError());
11573 ret
= SetFileCompletionNotificationModes((HANDLE
)client
, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS
);
11574 ok(ret
, "got error %lu\n", GetLastError());
11575 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
11576 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
11577 server
= accept(listener
, NULL
, NULL
);
11578 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
11580 SetLastError(0xdeadbeef);
11581 ret
= pDisconnectEx(client
, &overlapped
, 0, 0);
11582 ok(!ret
, "expected failure\n");
11583 ok(GetLastError() == ERROR_IO_PENDING
, "got error %lu\n", GetLastError());
11585 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
11586 ok(!ret
, "wait failed\n");
11589 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, TRUE
);
11590 ok(ret
, "got error %lu\n", GetLastError());
11591 ok(!size
, "got %lu bytes\n", size
);
11595 overlapped_ptr
= NULL
;
11596 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
11597 todo_wine
ok(ret
, "got error %lu\n", GetLastError());
11598 todo_wine
ok(!key
, "got key %#Ix\n", key
);
11599 todo_wine
ok(!size
, "got %lu bytes\n", size
);
11600 todo_wine
ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
11602 closesocket(server
);
11603 closesocket(client
);
11606 /* Test passing a NULL overlapped structure to DisconnectEx(). */
11608 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11609 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
11610 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
11611 ok(!!port
, "failed to create port, error %lu\n", GetLastError());
11612 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
11613 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
11614 server
= accept(listener
, NULL
, NULL
);
11615 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
11617 SetLastError(0xdeadbeef);
11618 ret
= pDisconnectEx(client
, NULL
, 0, 0);
11619 ok(ret
, "expected success\n");
11620 ok(!GetLastError() || GetLastError() == 0xdeadbeef /* < 7 */, "got error %lu\n", GetLastError());
11622 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
11623 ok(!ret
, "expected failure\n");
11624 ok(GetLastError() == WAIT_TIMEOUT
, "got error %lu\n", GetLastError());
11626 closesocket(server
);
11627 closesocket(client
);
11630 /* Suppress completion by setting the low bit. */
11632 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11633 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
11634 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
11635 ok(!!port
, "failed to create port, error %lu\n", GetLastError());
11636 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
11637 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
11638 server
= accept(listener
, NULL
, NULL
);
11639 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
11641 overlapped
.hEvent
= (HANDLE
)((ULONG_PTR
)overlapped
.hEvent
| 1);
11643 SetLastError(0xdeadbeef);
11644 ret
= pDisconnectEx(client
, &overlapped
, 0, 0);
11645 ok(!ret
, "expected failure\n");
11646 ok(GetLastError() == ERROR_IO_PENDING
, "got error %lu\n", GetLastError());
11648 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
11649 ok(!ret
, "wait failed\n");
11652 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, TRUE
);
11653 ok(ret
, "got error %lu\n", GetLastError());
11654 ok(!size
, "got %lu bytes\n", size
);
11656 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
11657 ok(!ret
, "expected failure\n");
11658 ok(GetLastError() == WAIT_TIMEOUT
, "got error %lu\n", GetLastError());
11660 closesocket(server
);
11661 closesocket(client
);
11664 overlapped
.hEvent
= (HANDLE
)((ULONG_PTR
)overlapped
.hEvent
& ~1);
11666 CloseHandle(overlapped
.hEvent
);
11669 static void test_address_list_query(void)
11672 SOCKET_ADDRESS_LIST
*address_list
= (SOCKET_ADDRESS_LIST
*)buffer
;
11673 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
11674 DWORD size
, expect_size
;
11681 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11682 ok(s
!= INVALID_SOCKET
, "Failed to create socket, error %d.\n", WSAGetLastError());
11683 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
11686 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, NULL
, 0, &size
, NULL
, NULL
);
11687 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
11688 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
11689 ok(size
>= FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[0]), "Got unexpected size %lu.\n", size
);
11690 expect_size
= size
;
11693 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, sizeof(buffer
), &size
, NULL
, NULL
);
11694 ok(!ret
, "Got unexpected ret %d.\n", ret
);
11695 ok(!WSAGetLastError(), "Got unexpected error %d.\n", WSAGetLastError());
11696 ok(size
== expect_size
, "Expected size %lu, got %lu.\n", expect_size
, size
);
11698 expect_size
= FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[address_list
->iAddressCount
]);
11699 for (i
= 0; i
< address_list
->iAddressCount
; ++i
)
11701 expect_size
+= address_list
->Address
[i
].iSockaddrLength
;
11703 ok(size
== expect_size
, "Expected size %lu, got %lu.\n", expect_size
, size
);
11705 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, sizeof(buffer
), NULL
, NULL
, NULL
);
11706 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
11707 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
11710 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, NULL
, sizeof(buffer
), &size
, NULL
, NULL
);
11711 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
11712 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
11713 ok(size
== expect_size
, "Expected size %lu, got %lu.\n", expect_size
, size
);
11716 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, 0, &size
, NULL
, NULL
);
11717 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
11718 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
11719 ok(size
== expect_size
, "Expected size %lu, got %lu.\n", expect_size
, size
);
11722 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, 1, &size
, NULL
, NULL
);
11723 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
11724 ok(WSAGetLastError() == WSAEINVAL
, "Got unexpected error %d.\n", WSAGetLastError());
11725 ok(!size
, "Got size %lu.\n", size
);
11728 memset(buffer
, 0xcc, sizeof(buffer
));
11729 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
,
11730 FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[0]), &size
, NULL
, NULL
);
11731 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
11732 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
11733 ok(size
== expect_size
, "Expected size %lu, got %lu.\n", expect_size
, size
);
11734 ok(address_list
->iAddressCount
== 0xcccccccc, "Got %u addresses.\n", address_list
->iAddressCount
);
11736 WSASetLastError(0xdeadbeef);
11737 overlapped
.Internal
= 0xdeadbeef;
11738 overlapped
.InternalHigh
= 0xdeadbeef;
11740 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, 0, &size
, &overlapped
, NULL
);
11741 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
11742 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
11743 ok(size
== expect_size
, "Expected size %lu, got %lu.\n", expect_size
, size
);
11744 ok(overlapped
.Internal
== 0xdeadbeef, "Got status %#lx.\n", (NTSTATUS
)overlapped
.Internal
);
11745 ok(overlapped
.InternalHigh
== 0xdeadbeef, "Got size %Iu.\n", overlapped
.InternalHigh
);
11747 overlapped
.Internal
= 0xdeadbeef;
11748 overlapped
.InternalHigh
= 0xdeadbeef;
11750 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, 1, &size
, &overlapped
, NULL
);
11751 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
11752 ok(WSAGetLastError() == WSAEINVAL
, "Got unexpected error %d.\n", WSAGetLastError());
11753 ok(!size
, "Expected size %lu, got %lu.\n", expect_size
, size
);
11754 ok(overlapped
.Internal
== 0xdeadbeef, "Got status %#lx.\n", (NTSTATUS
)overlapped
.Internal
);
11755 ok(overlapped
.InternalHigh
== 0xdeadbeef, "Got size %Iu.\n", overlapped
.InternalHigh
);
11757 overlapped
.Internal
= 0xdeadbeef;
11758 overlapped
.InternalHigh
= 0xdeadbeef;
11760 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
,
11761 FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[0]), &size
, &overlapped
, NULL
);
11762 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
11763 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
11764 ok(size
== expect_size
, "Expected size %lu, got %lu.\n", expect_size
, size
);
11765 ok(overlapped
.Internal
== 0xdeadbeef, "Got status %#lx.\n", (NTSTATUS
)overlapped
.Internal
);
11766 ok(overlapped
.InternalHigh
== 0xdeadbeef, "Got size %Iu.\n", overlapped
.InternalHigh
);
11767 ok(address_list
->iAddressCount
== 0xcccccccc, "Got %u addresses.\n", address_list
->iAddressCount
);
11769 overlapped
.Internal
= 0xdeadbeef;
11770 overlapped
.InternalHigh
= 0xdeadbeef;
11772 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, sizeof(buffer
), &size
, &overlapped
, NULL
);
11773 ok(!ret
, "Got unexpected ret %d.\n", ret
);
11774 ok(!WSAGetLastError(), "Got unexpected error %d.\n", WSAGetLastError());
11775 ok(size
== expect_size
, "Expected size %lu, got %lu.\n", expect_size
, size
);
11777 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
11778 ok(ret
, "Got error %lu.\n", GetLastError());
11779 ok(!size
, "Got size %lu.\n", size
);
11780 ok(overlapped_ptr
== &overlapped
, "Got overlapped %p.\n", overlapped_ptr
);
11781 ok(!overlapped
.Internal
, "Got status %#lx.\n", (NTSTATUS
)overlapped
.Internal
);
11782 ok(!overlapped
.InternalHigh
, "Got size %Iu.\n", overlapped
.InternalHigh
);
11784 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
11785 ok(!ret
, "Expected failure.\n");
11786 ok(GetLastError() == WAIT_TIMEOUT
, "Got error %lu.\n", GetLastError());
11791 /* Test with an APC. */
11793 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
11795 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, sizeof(buffer
), NULL
, &overlapped
, socket_apc
);
11796 ok(ret
== -1, "expected failure\n");
11797 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
11801 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, buffer
, sizeof(buffer
), &size
, &overlapped
, socket_apc
);
11802 ok(!ret
, "expected success\n");
11803 ok(size
== expect_size
, "got size %lu\n", size
);
11805 ret
= SleepEx(0, TRUE
);
11806 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
11807 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
11808 ok(!apc_error
, "got APC error %lu\n", apc_error
);
11809 ok(!apc_size
, "got APC size %lu\n", apc_size
);
11810 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
11815 static void sync_read(SOCKET src
, SOCKET dst
)
11820 ret
= send(dst
, "Hello World!", 12, 0);
11821 ok(ret
== 12, "send returned %d\n", ret
);
11823 memset(data
, 0, sizeof(data
));
11824 ret
= recv(src
, data
, sizeof(data
), 0);
11825 ok(ret
== 12, "expected 12, got %d\n", ret
);
11826 ok(!memcmp(data
, "Hello World!", 12), "got %u bytes (%*s)\n", ret
, ret
, data
);
11829 static void iocp_async_read(SOCKET src
, SOCKET dst
)
11832 WSAOVERLAPPED ovl
, *ovl_iocp
;
11836 DWORD flags
, bytes
;
11839 memset(data
, 0, sizeof(data
));
11840 memset(&ovl
, 0, sizeof(ovl
));
11842 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
11843 ok(port
!= 0, "CreateIoCompletionPort error %lu\n", GetLastError());
11845 buf
.len
= sizeof(data
);
11847 bytes
= 0xdeadbeef;
11849 SetLastError(0xdeadbeef);
11850 ret
= WSARecv(src
, &buf
, 1, &bytes
, &flags
, &ovl
, NULL
);
11851 ok(ret
== SOCKET_ERROR
, "got %d\n", ret
);
11852 ok(GetLastError() == ERROR_IO_PENDING
, "got %lu\n", GetLastError());
11853 ok(bytes
== 0xdeadbeef, "got bytes %lu\n", bytes
);
11855 bytes
= 0xdeadbeef;
11857 ovl_iocp
= (void *)0xdeadbeef;
11858 SetLastError(0xdeadbeef);
11859 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
11860 ok(!ret
, "got %d\n", ret
);
11861 ok(GetLastError() == WAIT_TIMEOUT
, "got %lu\n", GetLastError());
11862 ok(bytes
== 0xdeadbeef, "got bytes %lu\n", bytes
);
11863 ok(key
== 0xdeadbeef, "got key %#Ix\n", key
);
11864 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
11866 ret
= send(dst
, "Hello World!", 12, 0);
11867 ok(ret
== 12, "send returned %d\n", ret
);
11869 bytes
= 0xdeadbeef;
11872 SetLastError(0xdeadbeef);
11873 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
11874 ok(ret
, "got %d\n", ret
);
11875 ok(bytes
== 12, "got bytes %lu\n", bytes
);
11876 ok(key
== 0x12345678, "got key %#Ix\n", key
);
11877 ok(ovl_iocp
== &ovl
, "got ovl %p\n", ovl_iocp
);
11880 ok(ovl_iocp
->InternalHigh
== 12, "got %#Ix\n", ovl_iocp
->InternalHigh
);
11881 ok(!ovl_iocp
->Internal
, "got %#Ix\n", ovl_iocp
->Internal
);
11882 ok(!memcmp(data
, "Hello World!", 12), "got %lu bytes (%*s)\n", bytes
, (int)bytes
, data
);
11885 bytes
= 0xdeadbeef;
11887 ovl_iocp
= (void *)0xdeadbeef;
11888 SetLastError(0xdeadbeef);
11889 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
11890 ok(!ret
, "got %d\n", ret
);
11891 ok(GetLastError() == WAIT_TIMEOUT
, "got %lu\n", GetLastError());
11892 ok(bytes
== 0xdeadbeef, "got bytes %lu\n", bytes
);
11893 ok(key
== 0xdeadbeef, "got key %#Ix\n", key
);
11894 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
11899 static void iocp_async_read_closesocket(SOCKET src
, int how_to_close
)
11902 WSAOVERLAPPED ovl
, *ovl_iocp
;
11906 DWORD flags
, bytes
;
11911 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
11912 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
11913 ok(hwnd
!= 0, "CreateWindowEx failed\n");
11915 ret
= WSAAsyncSelect(src
, hwnd
, WM_SOCKET
, FD_READ
| FD_WRITE
| FD_OOB
| FD_ACCEPT
| FD_CONNECT
| FD_CLOSE
);
11916 ok(!ret
, "got %d\n", ret
);
11919 memset(&msg
, 0, sizeof(msg
));
11920 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11921 ok(ret
, "got %d\n", ret
);
11922 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
11923 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
11924 ok(msg
.wParam
== src
, "got %08Ix\n", msg
.wParam
);
11925 ok(msg
.lParam
== 2, "got %08Ix\n", msg
.lParam
);
11927 memset(data
, 0, sizeof(data
));
11928 memset(&ovl
, 0, sizeof(ovl
));
11930 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
11931 ok(port
!= 0, "CreateIoCompletionPort error %lu\n", GetLastError());
11934 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11935 ok(!ret
, "got %04x,%08Ix,%08Ix\n", msg
.message
, msg
.wParam
, msg
.lParam
);
11937 buf
.len
= sizeof(data
);
11939 bytes
= 0xdeadbeef;
11941 SetLastError(0xdeadbeef);
11942 ret
= WSARecv(src
, &buf
, 1, &bytes
, &flags
, &ovl
, NULL
);
11943 ok(ret
== SOCKET_ERROR
, "got %d\n", ret
);
11944 ok(GetLastError() == ERROR_IO_PENDING
, "got %lu\n", GetLastError());
11945 ok(bytes
== 0xdeadbeef, "got bytes %lu\n", bytes
);
11948 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11949 ok(!ret
, "got %04x,%08Ix,%08Ix\n", msg
.message
, msg
.wParam
, msg
.lParam
);
11951 bytes
= 0xdeadbeef;
11953 ovl_iocp
= (void *)0xdeadbeef;
11954 SetLastError(0xdeadbeef);
11955 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
11956 ok(!ret
, "got %d\n", ret
);
11957 ok(GetLastError() == WAIT_TIMEOUT
, "got %lu\n", GetLastError());
11958 ok(bytes
== 0xdeadbeef, "got bytes %lu\n", bytes
);
11959 ok(key
== 0xdeadbeef, "got key %#Ix\n", key
);
11960 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
11963 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11964 ok(!ret
, "got %04x,%08Ix,%08Ix\n", msg
.message
, msg
.wParam
, msg
.lParam
);
11966 switch (how_to_close
)
11972 CloseHandle((HANDLE
)src
);
11975 pNtClose((HANDLE
)src
);
11978 ok(0, "wrong value %d\n", how_to_close
);
11983 memset(&msg
, 0, sizeof(msg
));
11984 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
11985 switch (how_to_close
)
11988 ok(!ret
, "got %04x,%08Ix,%08Ix\n", msg
.message
, msg
.wParam
, msg
.lParam
);
11994 ok(ret
, "got %d\n", ret
);
11995 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
11996 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
11997 ok(msg
.wParam
== src
, "got %08Ix\n", msg
.wParam
);
11998 ok(msg
.lParam
== 0x20, "got %08Ix\n", msg
.lParam
);
12002 ok(0, "wrong value %d\n", how_to_close
);
12006 bytes
= 0xdeadbeef;
12009 SetLastError(0xdeadbeef);
12010 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
12011 ok(!ret
, "got %d\n", ret
);
12013 ok(GetLastError() == ERROR_CONNECTION_ABORTED
|| GetLastError() == ERROR_NETNAME_DELETED
/* XP */, "got %lu\n", GetLastError());
12014 ok(!bytes
, "got bytes %lu\n", bytes
);
12015 ok(key
== 0x12345678, "got key %#Ix\n", key
);
12016 ok(ovl_iocp
== &ovl
, "got ovl %p\n", ovl_iocp
);
12019 ok(!ovl_iocp
->InternalHigh
, "got %#Ix\n", ovl_iocp
->InternalHigh
);
12021 ok(ovl_iocp
->Internal
== (ULONG
)STATUS_CONNECTION_ABORTED
|| ovl_iocp
->Internal
== (ULONG
)STATUS_LOCAL_DISCONNECT
/* XP */, "got %#Ix\n", ovl_iocp
->Internal
);
12024 bytes
= 0xdeadbeef;
12026 ovl_iocp
= (void *)0xdeadbeef;
12027 SetLastError(0xdeadbeef);
12028 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
12029 ok(!ret
, "got %d\n", ret
);
12030 ok(GetLastError() == WAIT_TIMEOUT
, "got %lu\n", GetLastError());
12031 ok(bytes
== 0xdeadbeef, "got bytes %lu\n", bytes
);
12032 ok(key
== 0xdeadbeef, "got key %#Ix\n", key
);
12033 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
12037 DestroyWindow(hwnd
);
12040 static void iocp_async_closesocket(SOCKET src
)
12043 WSAOVERLAPPED
*ovl_iocp
;
12050 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
12051 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
12052 ok(hwnd
!= 0, "CreateWindowEx failed\n");
12054 ret
= WSAAsyncSelect(src
, hwnd
, WM_SOCKET
, FD_READ
| FD_WRITE
| FD_OOB
| FD_ACCEPT
| FD_CONNECT
| FD_CLOSE
);
12055 ok(!ret
, "got %d\n", ret
);
12058 memset(&msg
, 0, sizeof(msg
));
12059 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
12060 ok(ret
, "got %d\n", ret
);
12061 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
12062 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
12063 ok(msg
.wParam
== src
, "got %08Ix\n", msg
.wParam
);
12064 ok(msg
.lParam
== 2, "got %08Ix\n", msg
.lParam
);
12066 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
12067 ok(port
!= 0, "CreateIoCompletionPort error %lu\n", GetLastError());
12070 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
12071 ok(!ret
, "got %04x,%08Ix,%08Ix\n", msg
.message
, msg
.wParam
, msg
.lParam
);
12073 bytes
= 0xdeadbeef;
12075 ovl_iocp
= (void *)0xdeadbeef;
12076 SetLastError(0xdeadbeef);
12077 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
12078 ok(!ret
, "got %d\n", ret
);
12079 ok(GetLastError() == WAIT_TIMEOUT
, "got %lu\n", GetLastError());
12080 ok(bytes
== 0xdeadbeef, "got bytes %lu\n", bytes
);
12081 ok(key
== 0xdeadbeef, "got key %Iu\n", key
);
12082 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
12085 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
12086 ok(!ret
, "got %04x,%08Ix,%08Ix\n", msg
.message
, msg
.wParam
, msg
.lParam
);
12091 memset(&msg
, 0, sizeof(msg
));
12092 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
12093 ok(!ret
, "got %04x,%08Ix,%08Ix\n", msg
.message
, msg
.wParam
, msg
.lParam
);
12095 bytes
= 0xdeadbeef;
12097 ovl_iocp
= (void *)0xdeadbeef;
12098 SetLastError(0xdeadbeef);
12099 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
12100 ok(!ret
, "got %d\n", ret
);
12101 ok(GetLastError() == WAIT_TIMEOUT
, "got %lu\n", GetLastError());
12102 ok(bytes
== 0xdeadbeef, "got bytes %lu\n", bytes
);
12103 ok(key
== 0xdeadbeef, "got key %Iu\n", key
);
12104 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
12108 DestroyWindow(hwnd
);
12111 struct wsa_async_select_info
12117 static DWORD WINAPI
wsa_async_select_thread(void *param
)
12119 struct wsa_async_select_info
*info
= param
;
12122 ret
= WSAAsyncSelect(info
->sock
, info
->hwnd
, WM_SOCKET
, FD_READ
| FD_WRITE
| FD_OOB
| FD_ACCEPT
| FD_CONNECT
| FD_CLOSE
);
12123 ok(!ret
, "got %d\n", ret
);
12128 struct wsa_recv_info
12135 static DWORD WINAPI
wsa_recv_thread(void *param
)
12137 struct wsa_recv_info
*info
= param
;
12139 DWORD flags
, bytes
;
12141 bytes
= 0xdeadbeef;
12143 SetLastError(0xdeadbeef);
12144 ret
= WSARecv(info
->sock
, &info
->wsa_buf
, 1, &bytes
, &flags
, &info
->ovl
, NULL
);
12145 ok(ret
== SOCKET_ERROR
, "got %d\n", ret
);
12146 ok(GetLastError() == ERROR_IO_PENDING
, "got %lu\n", GetLastError());
12147 ok(bytes
== 0xdeadbeef, "got bytes %lu\n", bytes
);
12152 static void iocp_async_read_thread_closesocket(SOCKET src
)
12154 struct wsa_async_select_info select_info
;
12155 struct wsa_recv_info recv_info
;
12156 HANDLE port
, thread
;
12157 WSAOVERLAPPED
*ovl_iocp
;
12165 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
12166 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
12167 ok(hwnd
!= 0, "CreateWindowEx failed\n");
12169 select_info
.sock
= src
;
12170 select_info
.hwnd
= hwnd
;
12171 thread
= CreateThread(NULL
, 0, wsa_async_select_thread
, &select_info
, 0, &tid
);
12172 ok(thread
!= 0, "CreateThread error %lu\n", GetLastError());
12173 ret
= WaitForSingleObject(thread
, 10000);
12174 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
12177 memset(&msg
, 0, sizeof(msg
));
12178 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
12179 ok(ret
, "got %d\n", ret
);
12180 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
12181 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
12182 ok(msg
.wParam
== src
, "got %08Ix\n", msg
.wParam
);
12183 ok(msg
.lParam
== 2, "got %08Ix\n", msg
.lParam
);
12185 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
12186 ok(port
!= 0, "CreateIoCompletionPort error %lu\n", GetLastError());
12189 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
12190 ok(!ret
, "got %04x,%08Ix,%08Ix\n", msg
.message
, msg
.wParam
, msg
.lParam
);
12192 memset(data
, 0, sizeof(data
));
12193 memset(&recv_info
.ovl
, 0, sizeof(recv_info
.ovl
));
12194 recv_info
.sock
= src
;
12195 recv_info
.wsa_buf
.len
= sizeof(data
);
12196 recv_info
.wsa_buf
.buf
= data
;
12197 thread
= CreateThread(NULL
, 0, wsa_recv_thread
, &recv_info
, 0, &tid
);
12198 ok(thread
!= 0, "CreateThread error %lu\n", GetLastError());
12199 ret
= WaitForSingleObject(thread
, 10000);
12200 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
12203 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
12204 ok(!ret
, "got %04x,%08Ix,%08Ix\n", msg
.message
, msg
.wParam
, msg
.lParam
);
12206 bytes
= 0xdeadbeef;
12208 ovl_iocp
= (void *)0xdeadbeef;
12209 SetLastError(0xdeadbeef);
12210 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
12211 ok(!ret
, "got %d\n", ret
);
12212 ok(GetLastError() == WAIT_TIMEOUT
|| broken(GetLastError() == ERROR_OPERATION_ABORTED
) /* XP */,
12213 "got %lu\n", GetLastError());
12214 if (GetLastError() == WAIT_TIMEOUT
)
12216 ok(bytes
== 0xdeadbeef, "got bytes %lu\n", bytes
);
12217 ok(key
== 0xdeadbeef, "got key %Ix\n", key
);
12218 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
12220 else /* document XP behaviour */
12222 ok(!bytes
, "got bytes %lu\n", bytes
);
12223 ok(key
== 0x12345678, "got key %#Ix\n", key
);
12224 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
12227 ok(!ovl_iocp
->InternalHigh
, "got %#Ix\n", ovl_iocp
->InternalHigh
);
12228 ok(ovl_iocp
->Internal
== STATUS_CANCELLED
, "got %#Ix\n", ovl_iocp
->Internal
);
12236 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
12237 ok(!ret
, "got %04x,%08Ix,%08Ix\n", msg
.message
, msg
.wParam
, msg
.lParam
);
12242 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
12243 ok(!ret
, "got %04x,%08Ix,%08Ix\n", msg
.message
, msg
.wParam
, msg
.lParam
);
12245 bytes
= 0xdeadbeef;
12248 SetLastError(0xdeadbeef);
12249 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
12250 ok(!ret
, "got %d\n", ret
);
12252 ok(GetLastError() == ERROR_CONNECTION_ABORTED
|| GetLastError() == ERROR_NETNAME_DELETED
/* XP */, "got %lu\n", GetLastError());
12253 ok(!bytes
, "got bytes %lu\n", bytes
);
12254 ok(key
== 0x12345678, "got key %#Ix\n", key
);
12255 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
12258 ok(!ovl_iocp
->InternalHigh
, "got %#Ix\n", ovl_iocp
->InternalHigh
);
12260 ok(ovl_iocp
->Internal
== (ULONG
)STATUS_CONNECTION_ABORTED
|| ovl_iocp
->Internal
== (ULONG
)STATUS_LOCAL_DISCONNECT
/* XP */, "got %#Ix\n", ovl_iocp
->Internal
);
12264 bytes
= 0xdeadbeef;
12266 ovl_iocp
= (void *)0xdeadbeef;
12267 SetLastError(0xdeadbeef);
12268 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
12269 ok(!ret
, "got %d\n", ret
);
12270 ok(GetLastError() == WAIT_TIMEOUT
, "got %lu\n", GetLastError());
12271 ok(bytes
== 0xdeadbeef, "got bytes %lu\n", bytes
);
12272 ok(key
== 0xdeadbeef, "got key %Iu\n", key
);
12273 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
12277 DestroyWindow(hwnd
);
12280 static void iocp_async_read_thread(SOCKET src
, SOCKET dst
)
12282 struct wsa_async_select_info select_info
;
12283 struct wsa_recv_info recv_info
;
12284 HANDLE port
, thread
;
12285 WSAOVERLAPPED
*ovl_iocp
;
12293 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
12294 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
12295 ok(hwnd
!= 0, "CreateWindowEx failed\n");
12297 select_info
.sock
= src
;
12298 select_info
.hwnd
= hwnd
;
12299 thread
= CreateThread(NULL
, 0, wsa_async_select_thread
, &select_info
, 0, &tid
);
12300 ok(thread
!= 0, "CreateThread error %lu\n", GetLastError());
12301 ret
= WaitForSingleObject(thread
, 10000);
12302 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
12305 memset(&msg
, 0, sizeof(msg
));
12306 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
12307 ok(ret
, "got %d\n", ret
);
12308 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
12309 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
12310 ok(msg
.wParam
== src
, "got %08Ix\n", msg
.wParam
);
12311 ok(msg
.lParam
== 2, "got %08Ix\n", msg
.lParam
);
12313 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
12314 ok(port
!= 0, "CreateIoCompletionPort error %lu\n", GetLastError());
12317 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
12318 ok(!ret
, "got %04x,%08Ix,%08Ix\n", msg
.message
, msg
.wParam
, msg
.lParam
);
12320 memset(data
, 0, sizeof(data
));
12321 memset(&recv_info
.ovl
, 0, sizeof(recv_info
.ovl
));
12322 recv_info
.sock
= src
;
12323 recv_info
.wsa_buf
.len
= sizeof(data
);
12324 recv_info
.wsa_buf
.buf
= data
;
12325 thread
= CreateThread(NULL
, 0, wsa_recv_thread
, &recv_info
, 0, &tid
);
12326 ok(thread
!= 0, "CreateThread error %lu\n", GetLastError());
12327 ret
= WaitForSingleObject(thread
, 10000);
12328 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
12331 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
12332 ok(!ret
, "got %04x,%08Ix,%08Ix\n", msg
.message
, msg
.wParam
, msg
.lParam
);
12334 bytes
= 0xdeadbeef;
12336 ovl_iocp
= (void *)0xdeadbeef;
12337 SetLastError(0xdeadbeef);
12338 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
12339 ok(!ret
, "got %d\n", ret
);
12340 ok(GetLastError() == WAIT_TIMEOUT
|| broken(GetLastError() == ERROR_OPERATION_ABORTED
) /* XP */, "got %lu\n", GetLastError());
12341 if (GetLastError() == WAIT_TIMEOUT
)
12343 ok(bytes
== 0xdeadbeef, "got bytes %lu\n", bytes
);
12344 ok(key
== 0xdeadbeef, "got key %Iu\n", key
);
12345 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
12347 else /* document XP behaviour */
12349 ok(bytes
== 0, "got bytes %lu\n", bytes
);
12350 ok(key
== 0x12345678, "got key %#Ix\n", key
);
12351 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
12354 ok(!ovl_iocp
->InternalHigh
, "got %#Ix\n", ovl_iocp
->InternalHigh
);
12355 ok(ovl_iocp
->Internal
== STATUS_CANCELLED
, "got %#Ix\n", ovl_iocp
->Internal
);
12360 memset(&msg
, 0, sizeof(msg
));
12361 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
12362 ok(!ret
|| broken(msg
.hwnd
== hwnd
) /* XP */, "got %04x,%08Ix,%08Ix\n", msg
.message
, msg
.wParam
, msg
.lParam
);
12363 if (ret
) /* document XP behaviour */
12365 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
12366 ok(msg
.wParam
== src
, "got %08Ix\n", msg
.wParam
);
12367 ok(msg
.lParam
== 1, "got %08Ix\n", msg
.lParam
);
12370 ret
= send(dst
, "Hello World!", 12, 0);
12371 ok(ret
== 12, "send returned %d\n", ret
);
12374 memset(&msg
, 0, sizeof(msg
));
12375 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
12376 ok(!ret
|| broken(msg
.hwnd
== hwnd
) /* XP */, "got %04x,%08Ix,%08Ix\n", msg
.message
, msg
.wParam
, msg
.lParam
);
12377 if (ret
) /* document XP behaviour */
12379 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
12380 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
12381 ok(msg
.wParam
== src
, "got %08Ix\n", msg
.wParam
);
12382 ok(msg
.lParam
== 1, "got %08Ix\n", msg
.lParam
);
12385 bytes
= 0xdeadbeef;
12387 ovl_iocp
= (void *)0xdeadbeef;
12388 SetLastError(0xdeadbeef);
12389 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
12390 ok(ret
|| broken(GetLastError() == WAIT_TIMEOUT
) /* XP */, "got %lu\n", GetLastError());
12393 ok(bytes
== 12, "got bytes %lu\n", bytes
);
12394 ok(key
== 0x12345678, "got key %#Ix\n", key
);
12395 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
12398 ok(ovl_iocp
->InternalHigh
== 12, "got %#Ix\n", ovl_iocp
->InternalHigh
);
12399 ok(!ovl_iocp
->Internal
, "got %#Ix\n", ovl_iocp
->Internal
);
12400 ok(!memcmp(data
, "Hello World!", 12), "got %lu bytes (%*s)\n", bytes
, (int)bytes
, data
);
12403 else /* document XP behaviour */
12405 ok(bytes
== 0xdeadbeef, "got bytes %lu\n", bytes
);
12406 ok(key
== 0xdeadbeef, "got key %Iu\n", key
);
12407 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
12412 DestroyWindow(hwnd
);
12415 static void test_iocp(void)
12420 tcp_socketpair(&src
, &dst
);
12421 sync_read(src
, dst
);
12422 iocp_async_read(src
, dst
);
12426 tcp_socketpair(&src
, &dst
);
12427 iocp_async_read_thread(src
, dst
);
12431 for (i
= 0; i
<= 2; i
++)
12433 tcp_socketpair(&src
, &dst
);
12434 iocp_async_read_closesocket(src
, i
);
12438 tcp_socketpair(&src
, &dst
);
12439 iocp_async_closesocket(src
);
12442 tcp_socketpair(&src
, &dst
);
12443 iocp_async_read_thread_closesocket(src
);
12447 static void test_get_interface_list(void)
12449 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
12450 DWORD size
, expect_size
;
12451 unsigned int i
, count
;
12452 INTERFACE_INFO
*info
;
12453 BOOL loopback_found
;
12460 s
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
12461 ok(s
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
12462 port
= CreateIoCompletionPort((HANDLE
)s
, NULL
, 123, 0);
12465 WSASetLastError(0xdeadbeef);
12466 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(buffer
), &size
, NULL
, NULL
);
12467 ok(!ret
, "Got unexpected ret %d.\n", ret
);
12468 ok(!WSAGetLastError(), "Got error %u.\n", WSAGetLastError());
12469 ok(size
&& size
!= 0xdeadbeef && !(size
% sizeof(INTERFACE_INFO
)), "Got unexpected size %lu.\n", size
);
12470 expect_size
= size
;
12473 overlapped
.Internal
= 0xdeadbeef;
12474 overlapped
.InternalHigh
= 0xdeadbeef;
12475 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(buffer
), &size
, &overlapped
, NULL
);
12476 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
12477 ok(WSAGetLastError() == ERROR_IO_PENDING
, "Got error %u.\n", WSAGetLastError());
12478 ok(size
== 0xdeadbeef, "Got size %lu.\n", size
);
12480 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 100);
12481 ok(ret
, "Got error %lu.\n", GetLastError());
12482 ok(size
== expect_size
, "Expected size %lu, got %lu.\n", expect_size
, size
);
12483 ok(key
== 123, "Got key %Iu.\n", key
);
12484 ok(overlapped_ptr
== &overlapped
, "Got overlapped %p.\n", overlapped_ptr
);
12485 ok(!overlapped
.Internal
, "Got status %#lx.\n", (NTSTATUS
)overlapped
.Internal
);
12486 ok(overlapped
.InternalHigh
== expect_size
, "Expected size %lu, got %Iu.\n", expect_size
, overlapped
.InternalHigh
);
12488 info
= (INTERFACE_INFO
*)buffer
;
12489 count
= size
/ sizeof(INTERFACE_INFO
);
12490 loopback_found
= FALSE
;
12491 for (i
= 0; i
< count
; ++i
)
12493 if (info
[i
].iiFlags
& IFF_LOOPBACK
)
12494 loopback_found
= TRUE
;
12496 ok(info
[i
].iiAddress
.AddressIn
.sin_family
== AF_INET
, "Got unexpected sin_family %#x.\n",
12497 info
[i
].iiAddress
.AddressIn
.sin_family
);
12498 ok(info
[i
].iiNetmask
.AddressIn
.sin_family
== AF_INET
, "Got unexpected sin_family %#x.\n",
12499 info
[i
].iiNetmask
.AddressIn
.sin_family
);
12500 ok(info
[i
].iiBroadcastAddress
.AddressIn
.sin_family
12501 == (info
[i
].iiFlags
& IFF_BROADCAST
) ? AF_INET
: 0, "Got unexpected sin_family %#x.\n",
12502 info
[i
].iiBroadcastAddress
.AddressIn
.sin_family
);
12503 ok(info
[i
].iiAddress
.AddressIn
.sin_addr
.S_un
.S_addr
, "Got zero iiAddress.\n");
12504 ok(info
[i
].iiNetmask
.AddressIn
.sin_addr
.S_un
.S_addr
, "Got zero iiNetmask.\n");
12505 ok((info
[i
].iiFlags
& IFF_BROADCAST
) ? info
[i
].iiBroadcastAddress
.AddressIn
.sin_addr
.S_un
.S_addr
12506 : !info
[i
].iiBroadcastAddress
.AddressIn
.sin_addr
.S_un
.S_addr
,
12507 "Got unexpected iiBroadcastAddress %s.\n", inet_ntoa(info
[i
].iiBroadcastAddress
.AddressIn
.sin_addr
));
12510 ok(loopback_found
, "Loopback interface not found.\n");
12513 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(INTERFACE_INFO
) - 1, &size
, NULL
, NULL
);
12514 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
12515 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
12516 ok(!size
, "Got unexpected size %lu.\n", size
);
12519 overlapped
.Internal
= 0xdeadbeef;
12520 overlapped
.InternalHigh
= 0xdeadbeef;
12521 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(INTERFACE_INFO
) - 1, &size
, &overlapped
, NULL
);
12522 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
12523 ok(WSAGetLastError() == ERROR_IO_PENDING
, "Got error %u.\n", WSAGetLastError());
12524 ok(size
== 0xdeadbeef, "Got size %lu.\n", size
);
12526 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 100);
12527 ok(!ret
, "Expected failure.\n");
12528 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER
, "Got error %lu.\n", GetLastError());
12529 ok(!size
, "Got size %lu.\n", size
);
12530 ok(key
== 123, "Got key %Iu.\n", key
);
12531 ok(overlapped_ptr
== &overlapped
, "Got overlapped %p.\n", overlapped_ptr
);
12532 ok((NTSTATUS
)overlapped
.Internal
== STATUS_BUFFER_TOO_SMALL
, "Got status %#lx.\n", (NTSTATUS
)overlapped
.Internal
);
12533 ok(!overlapped
.InternalHigh
, "Got size %Iu.\n", overlapped
.InternalHigh
);
12535 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(buffer
), NULL
, NULL
, NULL
);
12536 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
12537 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
12542 /* Test with an APC. */
12544 s
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
12545 ok(s
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
12549 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
,
12550 sizeof(INTERFACE_INFO
) - 1, &size
, &overlapped
, socket_apc
);
12551 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
12552 ok(WSAGetLastError() == ERROR_IO_PENDING
, "Got error %u.\n", WSAGetLastError());
12553 ok(size
== 0xdeadbeef, "Got size %lu.\n", size
);
12555 ret
= SleepEx(100, TRUE
);
12556 ok(ret
== WAIT_IO_COMPLETION
, "got %d\n", ret
);
12557 ok(apc_count
== 1, "APC was called %u times\n", apc_count
);
12558 ok(apc_error
== WSAEFAULT
, "got APC error %lu\n", apc_error
);
12559 ok(!apc_size
, "got APC size %lu\n", apc_size
);
12560 ok(apc_overlapped
== &overlapped
, "got APC overlapped %p\n", apc_overlapped
);
12565 static IP_ADAPTER_ADDRESSES
*get_adapters(void)
12567 ULONG err
, size
= 4096;
12568 IP_ADAPTER_ADDRESSES
*tmp
, *ret
;
12570 if (!(ret
= malloc( size
))) return NULL
;
12571 err
= GetAdaptersAddresses( AF_UNSPEC
, 0, NULL
, ret
, &size
);
12572 while (err
== ERROR_BUFFER_OVERFLOW
)
12574 if (!(tmp
= realloc( ret
, size
))) break;
12576 err
= GetAdaptersAddresses( AF_UNSPEC
, 0, NULL
, ret
, &size
);
12578 if (err
== ERROR_SUCCESS
) return ret
;
12583 static void test_bind(void)
12585 const struct sockaddr_in invalid_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= inet_addr("192.0.2.0")};
12586 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
12587 IP_ADAPTER_ADDRESSES
*adapters
, *adapter
;
12588 struct sockaddr addr
;
12592 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
12594 WSASetLastError(0xdeadbeef);
12595 ret
= bind(s
, NULL
, 0);
12596 ok(ret
== -1, "expected failure\n");
12597 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
12599 WSASetLastError(0xdeadbeef);
12600 ret
= bind(s
, NULL
, sizeof(addr
));
12601 ok(ret
== -1, "expected failure\n");
12602 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
12604 addr
.sa_family
= AF_INET
;
12605 WSASetLastError(0xdeadbeef);
12606 ret
= bind(s
, &addr
, 0);
12607 ok(ret
== -1, "expected failure\n");
12608 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
12610 addr
.sa_family
= 0xdead;
12611 WSASetLastError(0xdeadbeef);
12612 ret
= bind(s
, &addr
, sizeof(addr
));
12613 ok(ret
== -1, "expected failure\n");
12614 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "got error %u\n", WSAGetLastError());
12616 WSASetLastError(0xdeadbeef);
12617 ret
= bind(s
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
) - 1);
12618 ok(ret
== -1, "expected failure\n");
12619 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
12621 WSASetLastError(0xdeadbeef);
12622 ret
= bind(s
, (const struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
12623 ok(ret
== -1, "expected failure\n");
12624 ok(WSAGetLastError() == WSAEADDRNOTAVAIL
, "got error %u\n", WSAGetLastError());
12626 WSASetLastError(0xdeadbeef);
12627 ret
= bind(s
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
12628 ok(!ret
, "expected success\n");
12629 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
12631 WSASetLastError(0xdeadbeef);
12632 ret
= bind(s
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
12633 ok(ret
== -1, "expected failure\n");
12634 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
12636 len
= sizeof(addr
);
12637 ret
= getsockname(s
, &addr
, &len
);
12638 ok(!ret
, "got error %u\n", WSAGetLastError());
12640 s2
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
12642 WSASetLastError(0xdeadbeef);
12643 ret
= bind(s2
, &addr
, sizeof(addr
));
12644 ok(ret
== -1, "expected failure\n");
12645 ok(WSAGetLastError() == WSAEADDRINUSE
, "got error %u\n", WSAGetLastError());
12650 s
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
12652 WSASetLastError(0xdeadbeef);
12653 ret
= bind(s
, (const struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
12654 ok(ret
== -1, "expected failure\n");
12655 ok(WSAGetLastError() == WSAEADDRNOTAVAIL
, "got error %u\n", WSAGetLastError());
12657 WSASetLastError(0xdeadbeef);
12658 ret
= bind(s
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
12659 ok(!ret
, "expected success\n");
12660 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
12664 adapters
= get_adapters();
12665 ok(adapters
!= NULL
, "can't get adapters\n");
12667 for (adapter
= adapters
; adapter
!= NULL
; adapter
= adapter
->Next
)
12669 const IP_ADAPTER_UNICAST_ADDRESS
*unicast_addr
;
12671 if (adapter
->OperStatus
!= IfOperStatusUp
) continue;
12673 for (unicast_addr
= adapter
->FirstUnicastAddress
; unicast_addr
!= NULL
; unicast_addr
= unicast_addr
->Next
)
12675 short family
= unicast_addr
->Address
.lpSockaddr
->sa_family
;
12677 s
= socket(family
, SOCK_STREAM
, IPPROTO_TCP
);
12678 ok(s
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
12680 ret
= bind(s
, unicast_addr
->Address
.lpSockaddr
, unicast_addr
->Address
.iSockaddrLength
);
12681 ok(!ret
, "got error %u\n", WSAGetLastError());
12685 if (family
== AF_INET6
)
12687 struct sockaddr_in6 addr6
, ret_addr6
;
12689 memcpy(&addr6
, unicast_addr
->Address
.lpSockaddr
, sizeof(addr6
));
12691 ok(unicast_addr
->Address
.iSockaddrLength
== sizeof(struct sockaddr_in6
),
12692 "got unexpected length %u\n", unicast_addr
->Address
.iSockaddrLength
);
12694 s
= socket(family
, SOCK_STREAM
, IPPROTO_TCP
);
12695 ok(s
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
12697 ret
= bind(s
, unicast_addr
->Address
.lpSockaddr
, sizeof(struct sockaddr_in6_old
));
12698 ok(ret
== -1, "expected failure\n");
12699 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
12701 addr6
.sin6_scope_id
= 0xabacab;
12702 ret
= bind(s
, (struct sockaddr
*)&addr6
, sizeof(addr6
));
12703 todo_wine_if (!((const struct sockaddr_in6
*)unicast_addr
->Address
.lpSockaddr
)->sin6_scope_id
)
12705 ok(ret
== -1, "expected failure\n");
12706 ok(WSAGetLastError() == WSAEADDRNOTAVAIL
, "got error %u\n", WSAGetLastError());
12709 addr6
.sin6_scope_id
= 0;
12710 ret
= bind(s
, (struct sockaddr
*)&addr6
, sizeof(addr6
));
12711 todo_wine_if (!((const struct sockaddr_in6
*)unicast_addr
->Address
.lpSockaddr
)->sin6_scope_id
)
12712 ok(!ret
, "got error %u\n", WSAGetLastError());
12714 memcpy(&addr6
, unicast_addr
->Address
.lpSockaddr
, sizeof(addr6
));
12716 len
= sizeof(struct sockaddr_in6_old
);
12717 ret
= getsockname(s
, (struct sockaddr
*)&ret_addr6
, &len
);
12718 ok(ret
== -1, "expected failure\n");
12719 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
12721 len
= sizeof(ret_addr6
);
12722 memset(&ret_addr6
, 0, sizeof(ret_addr6
));
12723 ret
= getsockname(s
, (struct sockaddr
*)&ret_addr6
, &len
);
12724 ok(!ret
, "got error %u\n", WSAGetLastError());
12725 ok(ret_addr6
.sin6_family
== AF_INET6
, "got family %u\n", ret_addr6
.sin6_family
);
12726 ok(ret_addr6
.sin6_port
!= 0, "expected nonzero port\n");
12727 ok(!memcmp(&ret_addr6
.sin6_addr
, &addr6
.sin6_addr
, sizeof(addr6
.sin6_addr
)), "address didn't match\n");
12728 ok(ret_addr6
.sin6_scope_id
== addr6
.sin6_scope_id
, "got scope %lu\n", ret_addr6
.sin6_scope_id
);
12738 /* Test calling methods on a socket which is currently connecting. */
12739 static void test_connecting_socket(void)
12741 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_ANY
)};
12742 const struct sockaddr_in invalid_addr
=
12744 .sin_family
= AF_INET
,
12745 .sin_addr
.s_addr
= inet_addr("192.0.2.0"),
12748 OVERLAPPED overlapped
= {0}, overlapped2
= {0};
12749 GUID connectex_guid
= WSAID_CONNECTEX
;
12750 LPFN_CONNECTEX pConnectEx
;
12751 struct sockaddr_in addr
;
12757 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
12758 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
12759 set_blocking(client
, FALSE
);
12761 ret
= bind(client
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
12762 ok(!ret
, "expected success\n");
12763 ok(!WSAGetLastError(), "got %u\n", WSAGetLastError());
12765 ret
= connect(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
12766 ok(ret
== -1, "got %d\n", ret
);
12767 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got %u\n", WSAGetLastError());
12769 /* Mortal Kombat 11 connects to the same address twice and expects the
12770 * second to return WSAEALREADY. */
12771 ret
= connect(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
12772 ok(ret
== -1, "got %d\n", ret
);
12773 ok(WSAGetLastError() == WSAEALREADY
, "got %u\n", WSAGetLastError());
12775 ret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectex_guid
, sizeof(connectex_guid
),
12776 &pConnectEx
, sizeof(pConnectEx
), &size
, NULL
, NULL
);
12777 ok(!ret
, "failed to get ConnectEx, error %u\n", WSAGetLastError());
12778 overlapped
.Internal
= 0xdeadbeef;
12779 overlapped
.InternalHigh
= 0xdeadbeef;
12780 ret
= pConnectEx(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
), NULL
, 0, &size
, &overlapped
);
12781 ok(!ret
, "got %d\n", ret
);
12782 ok(WSAGetLastError() == WSAEINVAL
, "got %u\n", WSAGetLastError());
12783 ok((NTSTATUS
)overlapped
.Internal
== STATUS_PENDING
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
12784 todo_wine
ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
12786 len
= sizeof(addr
);
12787 ret
= getsockname(client
, (struct sockaddr
*)&addr
, &len
);
12788 ok(!ret
, "got error %u\n", WSAGetLastError());
12789 ok(addr
.sin_family
== AF_INET
, "got family %u\n", addr
.sin_family
);
12790 ok(addr
.sin_port
, "expected nonzero port\n");
12792 len
= sizeof(addr
);
12793 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &len
);
12794 ok(!ret
, "got error %u\n", WSAGetLastError());
12796 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
12797 ok(ret
== -1, "got %d\n", ret
);
12798 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got %u\n", WSAGetLastError());
12800 ret
= send(client
, "data", 5, 0);
12801 ok(ret
== -1, "got %d\n", ret
);
12802 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got %u\n", WSAGetLastError());
12804 closesocket(client
);
12806 /* Test with ConnectEx(). */
12808 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
12809 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
12810 set_blocking(client
, FALSE
);
12812 ret
= bind(client
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
12813 ok(!ret
, "expected success\n");
12814 ok(!WSAGetLastError(), "got %u\n", WSAGetLastError());
12816 ret
= pConnectEx(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
), NULL
, 0, &size
, &overlapped2
);
12817 ok(!ret
, "got %d\n", ret
);
12818 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
12820 ret
= connect(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
12821 ok(ret
== -1, "got %d\n", ret
);
12822 ok(WSAGetLastError() == WSAEINVAL
, "got %u\n", WSAGetLastError());
12824 overlapped
.Internal
= 0xdeadbeef;
12825 overlapped
.InternalHigh
= 0xdeadbeef;
12826 ret
= pConnectEx(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
), NULL
, 0, &size
, &overlapped
);
12827 ok(!ret
, "got %d\n", ret
);
12828 ok(WSAGetLastError() == WSAEINVAL
, "got %u\n", WSAGetLastError());
12829 ok((NTSTATUS
)overlapped
.Internal
== STATUS_PENDING
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
12830 todo_wine
ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
12832 len
= sizeof(addr
);
12833 ret
= getsockname(client
, (struct sockaddr
*)&addr
, &len
);
12834 ok(!ret
, "got error %u\n", WSAGetLastError());
12835 ok(addr
.sin_family
== AF_INET
, "got family %u\n", addr
.sin_family
);
12836 ok(addr
.sin_port
, "expected nonzero port\n");
12838 len
= sizeof(addr
);
12839 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &len
);
12840 ok(ret
== -1, "got %d\n", ret
);
12841 ok(WSAGetLastError() == WSAENOTCONN
, "got %u\n", WSAGetLastError());
12843 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
12844 ok(ret
== -1, "got %d\n", ret
);
12845 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got %u\n", WSAGetLastError());
12847 ret
= send(client
, "data", 5, 0);
12848 ok(ret
== -1, "got %d\n", ret
);
12849 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got %u\n", WSAGetLastError());
12851 closesocket(client
);
12854 static DWORD
map_status( NTSTATUS status
)
12856 static const struct
12863 {STATUS_PENDING
, ERROR_IO_INCOMPLETE
},
12865 {STATUS_BUFFER_OVERFLOW
, WSAEMSGSIZE
},
12867 {STATUS_NOT_IMPLEMENTED
, WSAEOPNOTSUPP
},
12868 {STATUS_ACCESS_VIOLATION
, WSAEFAULT
},
12869 {STATUS_PAGEFILE_QUOTA
, WSAENOBUFS
},
12870 {STATUS_INVALID_HANDLE
, WSAENOTSOCK
},
12871 {STATUS_NO_SUCH_DEVICE
, WSAENETDOWN
},
12872 {STATUS_NO_SUCH_FILE
, WSAENETDOWN
},
12873 {STATUS_NO_MEMORY
, WSAENOBUFS
},
12874 {STATUS_CONFLICTING_ADDRESSES
, WSAENOBUFS
},
12875 {STATUS_ACCESS_DENIED
, WSAEACCES
},
12876 {STATUS_BUFFER_TOO_SMALL
, WSAEFAULT
},
12877 {STATUS_OBJECT_TYPE_MISMATCH
, WSAENOTSOCK
},
12878 {STATUS_OBJECT_NAME_NOT_FOUND
, WSAENETDOWN
},
12879 {STATUS_OBJECT_PATH_NOT_FOUND
, WSAENETDOWN
},
12880 {STATUS_SHARING_VIOLATION
, WSAEADDRINUSE
},
12881 {STATUS_QUOTA_EXCEEDED
, WSAENOBUFS
},
12882 {STATUS_TOO_MANY_PAGING_FILES
, WSAENOBUFS
},
12883 {STATUS_INSUFFICIENT_RESOURCES
, WSAENOBUFS
},
12884 {STATUS_WORKING_SET_QUOTA
, WSAENOBUFS
},
12885 {STATUS_DEVICE_NOT_READY
, WSAEWOULDBLOCK
},
12886 {STATUS_PIPE_DISCONNECTED
, WSAESHUTDOWN
},
12887 {STATUS_IO_TIMEOUT
, WSAETIMEDOUT
},
12888 {STATUS_NOT_SUPPORTED
, WSAEOPNOTSUPP
},
12889 {STATUS_REMOTE_NOT_LISTENING
, WSAECONNREFUSED
},
12890 {STATUS_BAD_NETWORK_PATH
, WSAENETUNREACH
},
12891 {STATUS_NETWORK_BUSY
, WSAENETDOWN
},
12892 {STATUS_INVALID_NETWORK_RESPONSE
, WSAENETDOWN
},
12893 {STATUS_UNEXPECTED_NETWORK_ERROR
, WSAENETDOWN
},
12894 {STATUS_REQUEST_NOT_ACCEPTED
, WSAEWOULDBLOCK
},
12895 {STATUS_CANCELLED
, ERROR_OPERATION_ABORTED
},
12896 {STATUS_COMMITMENT_LIMIT
, WSAENOBUFS
},
12897 {STATUS_LOCAL_DISCONNECT
, WSAECONNABORTED
},
12898 {STATUS_REMOTE_DISCONNECT
, WSAECONNRESET
},
12899 {STATUS_REMOTE_RESOURCES
, WSAENOBUFS
},
12900 {STATUS_LINK_FAILED
, WSAECONNRESET
},
12901 {STATUS_LINK_TIMEOUT
, WSAETIMEDOUT
},
12902 {STATUS_INVALID_CONNECTION
, WSAENOTCONN
},
12903 {STATUS_INVALID_ADDRESS
, WSAEADDRNOTAVAIL
},
12904 {STATUS_INVALID_BUFFER_SIZE
, WSAEMSGSIZE
},
12905 {STATUS_INVALID_ADDRESS_COMPONENT
, WSAEADDRNOTAVAIL
},
12906 {STATUS_TOO_MANY_ADDRESSES
, WSAENOBUFS
},
12907 {STATUS_ADDRESS_ALREADY_EXISTS
, WSAEADDRINUSE
},
12908 {STATUS_CONNECTION_DISCONNECTED
, WSAECONNRESET
},
12909 {STATUS_CONNECTION_RESET
, WSAECONNRESET
},
12910 {STATUS_TRANSACTION_ABORTED
, WSAECONNABORTED
},
12911 {STATUS_CONNECTION_REFUSED
, WSAECONNREFUSED
},
12912 {STATUS_GRACEFUL_DISCONNECT
, WSAEDISCON
},
12913 {STATUS_CONNECTION_ACTIVE
, WSAEISCONN
},
12914 {STATUS_NETWORK_UNREACHABLE
, WSAENETUNREACH
},
12915 {STATUS_HOST_UNREACHABLE
, WSAEHOSTUNREACH
},
12916 {STATUS_PROTOCOL_UNREACHABLE
, WSAENETUNREACH
},
12917 {STATUS_PORT_UNREACHABLE
, WSAECONNRESET
},
12918 {STATUS_REQUEST_ABORTED
, WSAEINTR
},
12919 {STATUS_CONNECTION_ABORTED
, WSAECONNABORTED
},
12920 {STATUS_DATATYPE_MISALIGNMENT_ERROR
,WSAEFAULT
},
12921 {STATUS_HOST_DOWN
, WSAEHOSTDOWN
},
12922 {0x80070000 | ERROR_IO_INCOMPLETE
, ERROR_IO_INCOMPLETE
},
12923 {0xc0010000 | ERROR_IO_INCOMPLETE
, ERROR_IO_INCOMPLETE
},
12924 {0xc0070000 | ERROR_IO_INCOMPLETE
, ERROR_IO_INCOMPLETE
},
12929 for (i
= 0; i
< ARRAY_SIZE(errors
); ++i
)
12931 if (errors
[i
].status
== status
)
12932 return errors
[i
].error
;
12935 return NT_SUCCESS(status
) ? RtlNtStatusToDosErrorNoTeb(status
) : WSAEINVAL
;
12938 static void test_WSAGetOverlappedResult(void)
12940 OVERLAPPED overlapped
= {0};
12948 static const NTSTATUS ranges
[][2] =
12951 {0x40000000, 0x40001000},
12952 {0x80000000, 0x80001000},
12953 {0x80070000, 0x80080000},
12954 {0xc0000000, 0xc0001000},
12955 {0xc0070000, 0xc0080000},
12956 {0xd0000000, 0xd0001000},
12957 {0xd0070000, 0xd0080000},
12960 WSASetLastError(0xdeadbeef);
12961 ret
= WSAGetOverlappedResult(0xdeadbeef, &overlapped
, &size
, FALSE
, &flags
);
12962 ok(!ret
, "got %d.\n", ret
);
12963 ok(WSAGetLastError() == WSAENOTSOCK
, "got %u.\n", WSAGetLastError());
12965 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
12967 ret
= DuplicateHandle(GetCurrentProcess(), (HANDLE
)s
, GetCurrentProcess(), &h
, 0, FALSE
, DUPLICATE_SAME_ACCESS
);
12968 ok(ret
, "got %d.\n", ret
);
12969 ret
= WSAGetOverlappedResult((SOCKET
)h
, &overlapped
, &size
, FALSE
, &flags
);
12970 ok(!ret
, "got %d.\n", ret
);
12971 ok(WSAGetLastError() == WSAENOTSOCK
, "got %u.\n", WSAGetLastError());
12974 for (i
= 0; i
< ARRAY_SIZE(ranges
); ++i
)
12976 for (status
= ranges
[i
][0]; status
< ranges
[i
][1]; ++status
)
12978 BOOL expect_ret
= NT_SUCCESS(status
) && status
!= STATUS_PENDING
;
12979 DWORD expect
= map_status(status
);
12981 overlapped
.Internal
= status
;
12982 WSASetLastError(0xdeadbeef);
12983 ret
= WSAGetOverlappedResult(s
, &overlapped
, &size
, FALSE
, &flags
);
12984 ok(ret
== expect_ret
, "status %#lx: expected %d, got %d\n", status
, expect_ret
, ret
);
12987 ok(WSAGetLastError() == expect
/* >= win10 1809 */
12988 || !WSAGetLastError() /* < win10 1809 */
12989 || WSAGetLastError() == 0xdeadbeef, /* < win7 */
12990 "status %#lx: expected error %lu, got %u\n", status
, expect
, WSAGetLastError());
12994 ok(WSAGetLastError() == expect
12995 || (status
== (0xc0070000 | ERROR_IO_INCOMPLETE
) && WSAGetLastError() == WSAEINVAL
), /* < win8 */
12996 "status %#lx: expected error %lu, got %u\n", status
, expect
, WSAGetLastError());
13001 overlapped
.Internal
= STATUS_PENDING
;
13002 overlapped
.hEvent
= CreateEventW(NULL
, TRUE
, TRUE
, NULL
);
13005 ret
= QueueUserAPC(apc_func
, GetCurrentThread(), (ULONG_PTR
)&apc_count
);
13006 ok(ret
, "QueueUserAPC returned %d\n", ret
);
13007 ret
= WSAGetOverlappedResult(s
, &overlapped
, &size
, TRUE
, &flags
);
13008 ok(ret
&& (GetLastError() == ERROR_IO_PENDING
|| !WSAGetLastError()),
13009 "Got ret %d, err %lu.\n", ret
, GetLastError());
13010 ok(!apc_count
, "got apc_count %d.\n", apc_count
);
13012 ok(apc_count
== 1, "got apc_count %d.\n", apc_count
);
13014 CloseHandle(overlapped
.hEvent
);
13018 struct nonblocking_async_recv_params
13024 static DWORD CALLBACK
nonblocking_async_recv_thread(void *arg
)
13026 const struct nonblocking_async_recv_params
*params
= arg
;
13027 OVERLAPPED overlapped
= {0};
13028 DWORD flags
= 0, size
;
13033 overlapped
.hEvent
= params
->event
;
13034 wsabuf
.buf
= buffer
;
13035 wsabuf
.len
= sizeof(buffer
);
13036 memset(buffer
, 0, sizeof(buffer
));
13037 ret
= WSARecv(params
->client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
13038 ok(!ret
, "got %d\n", ret
);
13039 ret
= GetOverlappedResult((HANDLE
)params
->client
, &overlapped
, &size
, FALSE
);
13040 ok(ret
, "got error %lu\n", GetLastError());
13041 ok(size
== 4, "got size %lu\n", size
);
13042 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
13047 static void test_nonblocking_async_recv(void)
13049 struct nonblocking_async_recv_params params
;
13050 OVERLAPPED overlapped
= {0};
13051 SOCKET client
, server
;
13052 DWORD flags
= 0, size
;
13053 HANDLE thread
, event
;
13058 event
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
13059 wsabuf
.buf
= buffer
;
13060 wsabuf
.len
= sizeof(buffer
);
13062 tcp_socketpair(&client
, &server
);
13063 set_blocking(client
, FALSE
);
13064 set_blocking(server
, FALSE
);
13066 WSASetLastError(0xdeadbeef);
13067 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
13068 ok(ret
== -1, "got %d\n", ret
);
13069 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
13071 WSASetLastError(0xdeadbeef);
13072 overlapped
.Internal
= 0xdeadbeef;
13073 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, NULL
, NULL
);
13074 ok(ret
== -1, "got %d\n", ret
);
13075 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
13076 ok(overlapped
.Internal
== 0xdeadbeef, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
13078 /* Overlapped, with a NULL event. */
13080 overlapped
.hEvent
= NULL
;
13082 memset(buffer
, 0, sizeof(buffer
));
13083 WSASetLastError(0xdeadbeef);
13084 overlapped
.Internal
= 0xdeadbeef;
13085 overlapped
.InternalHigh
= 0xdeadbeef;
13086 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
13087 ok(ret
== -1, "got %d\n", ret
);
13088 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
13089 ret
= WaitForSingleObject((HANDLE
)client
, 0);
13090 ok(ret
== WAIT_TIMEOUT
, "expected timeout\n");
13091 ok(overlapped
.Internal
== STATUS_PENDING
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
13092 ok(overlapped
.InternalHigh
== 0xdeadbeef, "got size %Iu\n", overlapped
.InternalHigh
);
13094 ret
= send(server
, "data", 4, 0);
13095 ok(ret
== 4, "got %d\n", ret
);
13097 ret
= WaitForSingleObject((HANDLE
)client
, 1000);
13098 ok(!ret
, "wait timed out\n");
13099 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
13100 ok(ret
, "got error %lu\n", GetLastError());
13101 ok(size
== 4, "got size %lu\n", size
);
13102 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
13104 /* Overlapped, with a non-NULL event. */
13106 overlapped
.hEvent
= event
;
13108 memset(buffer
, 0, sizeof(buffer
));
13109 WSASetLastError(0xdeadbeef);
13110 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
13111 ok(ret
== -1, "got %d\n", ret
);
13112 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
13113 ret
= WaitForSingleObject(event
, 0);
13114 ok(ret
== WAIT_TIMEOUT
, "expected timeout\n");
13116 ret
= send(server
, "data", 4, 0);
13117 ok(ret
== 4, "got %d\n", ret
);
13119 ret
= WaitForSingleObject(event
, 1000);
13120 ok(!ret
, "wait timed out\n");
13121 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
13122 ok(ret
, "got error %lu\n", GetLastError());
13123 ok(size
== 4, "got size %lu\n", size
);
13124 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
13126 /* With data already in the pipe; usually this does return 0 (but not
13129 ret
= send(server
, "data", 4, 0);
13130 ok(ret
== 4, "got %d\n", ret
);
13132 memset(buffer
, 0, sizeof(buffer
));
13133 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
13134 ok(!ret
|| WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
13135 ret
= WaitForSingleObject(event
, 1000);
13136 ok(!ret
, "wait timed out\n");
13137 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
13138 ok(ret
, "got error %lu\n", GetLastError());
13139 ok(size
== 4, "got size %lu\n", size
);
13140 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
13142 closesocket(client
);
13143 closesocket(server
);
13145 /* With a non-overlapped socket, WSARecv() always blocks when passed an
13146 * overlapped structure, but returns WSAEWOULDBLOCK otherwise. */
13148 tcp_socketpair_flags(&client
, &server
, 0);
13149 set_blocking(client
, FALSE
);
13150 set_blocking(server
, FALSE
);
13152 WSASetLastError(0xdeadbeef);
13153 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
13154 ok(ret
== -1, "got %d\n", ret
);
13155 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
13157 WSASetLastError(0xdeadbeef);
13158 overlapped
.Internal
= 0xdeadbeef;
13159 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, NULL
, NULL
);
13160 ok(ret
== -1, "got %d\n", ret
);
13161 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
13162 ok(overlapped
.Internal
== 0xdeadbeef, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
13164 /* Overlapped, with a NULL event. */
13166 params
.client
= client
;
13167 params
.event
= NULL
;
13168 thread
= CreateThread(NULL
, 0, nonblocking_async_recv_thread
, ¶ms
, 0, NULL
);
13170 ret
= WaitForSingleObject(thread
, 200);
13171 ok(ret
== WAIT_TIMEOUT
, "expected timeout\n");
13173 ret
= send(server
, "data", 4, 0);
13174 ok(ret
== 4, "got %d\n", ret
);
13176 ret
= WaitForSingleObject(thread
, 200);
13177 ok(!ret
, "wait timed out\n");
13178 CloseHandle(thread
);
13180 /* Overlapped, with a non-NULL event. */
13182 params
.client
= client
;
13183 params
.event
= event
;
13184 thread
= CreateThread(NULL
, 0, nonblocking_async_recv_thread
, ¶ms
, 0, NULL
);
13186 ret
= WaitForSingleObject(thread
, 200);
13187 ok(ret
== WAIT_TIMEOUT
, "expected timeout\n");
13189 ret
= send(server
, "data", 4, 0);
13190 ok(ret
== 4, "got %d\n", ret
);
13192 ret
= WaitForSingleObject(thread
, 200);
13193 ok(!ret
, "wait timed out\n");
13194 CloseHandle(thread
);
13196 /* With data already in the pipe. */
13198 ret
= send(server
, "data", 4, 0);
13199 ok(ret
== 4, "got %d\n", ret
);
13201 memset(buffer
, 0, sizeof(buffer
));
13202 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
13203 ok(!ret
, "got %d\n", ret
);
13204 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
13205 ok(ret
, "got error %lu\n", GetLastError());
13206 ok(size
== 4, "got size %lu\n", size
);
13207 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
13209 closesocket(client
);
13210 closesocket(server
);
13212 CloseHandle(overlapped
.hEvent
);
13215 static void test_simultaneous_async_recv(void)
13217 SOCKET client
, server
;
13218 OVERLAPPED overlappeds
[2] = {{0}};
13221 DWORD flags
[2] = {0};
13222 size_t num_io
= 2, stride
= 16, i
;
13223 char resbuf
[32] = "";
13224 static const char msgstr
[32] = "-- Lorem ipsum dolor sit amet -";
13227 for (i
= 0; i
< num_io
; i
++) events
[i
] = CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
13229 tcp_socketpair(&client
, &server
);
13231 for (i
= 0; i
< num_io
; i
++)
13233 wsabufs
[i
].buf
= resbuf
+ i
* stride
;
13234 wsabufs
[i
].len
= stride
;
13235 overlappeds
[i
].hEvent
= events
[i
];
13236 ret
= WSARecv(client
, &wsabufs
[i
], 1, NULL
, &flags
[i
], &overlappeds
[i
], NULL
);
13237 ok(ret
== -1, "got %d\n", ret
);
13238 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
13241 ret
= send(server
, msgstr
, sizeof(msgstr
), 0);
13242 ok(ret
== sizeof(msgstr
), "got %d\n", ret
);
13244 for (i
= 0; i
< num_io
; i
++)
13246 const void *expect
= msgstr
+ i
* stride
;
13247 const void *actual
= resbuf
+ i
* stride
;
13250 ret
= WaitForSingleObject(events
[i
], 1000);
13251 ok(!ret
, "wait timed out\n");
13254 ret
= GetOverlappedResult((HANDLE
)client
, &overlappeds
[i
], &size
, FALSE
);
13255 ok(ret
, "got error %lu\n", GetLastError());
13256 ok(size
== stride
, "got size %lu\n", size
);
13257 ok(!memcmp(expect
, actual
, stride
), "expected %s, got %s\n", debugstr_an(expect
, stride
), debugstr_an(actual
, stride
));
13260 closesocket(client
);
13261 closesocket(server
);
13263 for (i
= 0; i
< num_io
; i
++) CloseHandle(events
[i
]);
13266 static void test_empty_recv(void)
13268 OVERLAPPED overlapped
= {0};
13269 SOCKET client
, server
;
13270 DWORD size
, flags
= 0;
13275 overlapped
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
13276 tcp_socketpair(&client
, &server
);
13278 WSASetLastError(0xdeadbeef);
13279 ret
= WSARecv(client
, NULL
, 0, NULL
, &flags
, &overlapped
, NULL
);
13280 ok(ret
== -1, "expected failure\n");
13281 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
13283 wsabuf
.buf
= buffer
;
13285 WSASetLastError(0xdeadbeef);
13286 ret
= WSARecv(client
, &wsabuf
, 0, NULL
, &flags
, &overlapped
, NULL
);
13287 ok(ret
== -1, "expected failure\n");
13288 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
13290 WSASetLastError(0xdeadbeef);
13291 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
13292 ok(ret
== -1, "expected failure\n");
13293 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
13295 ret
= send(server
, "data", 5, 0);
13296 ok(ret
== 5, "got %d\n", ret
);
13298 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
13299 ok(!ret
, "wait failed\n");
13300 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
13301 ok(ret
, "got error %lu\n", GetLastError());
13302 ok(!size
, "got size %lu\n", size
);
13304 WSASetLastError(0xdeadbeef);
13305 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
13306 ok(!ret
, "got error %u\n", WSAGetLastError());
13307 ok(!size
, "got size %lu\n", size
);
13309 ret
= recv(client
, NULL
, 0, 0);
13310 ok(!ret
, "got %d\n", ret
);
13312 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
13313 ok(ret
== 5, "got %d\n", ret
);
13314 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, ret
));
13316 closesocket(client
);
13317 closesocket(server
);
13318 CloseHandle(overlapped
.hEvent
);
13321 static void test_timeout(void)
13323 DWORD timeout
, flags
= 0, size
;
13324 OVERLAPPED overlapped
= {0};
13325 SOCKET client
, server
;
13330 tcp_socketpair(&client
, &server
);
13331 overlapped
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
13333 timeout
= 0xdeadbeef;
13334 len
= sizeof(timeout
);
13335 WSASetLastError(0xdeadbeef);
13336 ret
= getsockopt(client
, SOL_SOCKET
, SO_RCVTIMEO
, (char *)&timeout
, &len
);
13337 ok(!ret
, "expected success\n");
13338 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13339 ok(len
== sizeof(timeout
), "got size %u\n", len
);
13340 ok(!timeout
, "got timeout %lu\n", timeout
);
13343 WSASetLastError(0xdeadbeef);
13344 ret
= setsockopt(client
, SOL_SOCKET
, SO_RCVTIMEO
, (char *)&timeout
, sizeof(timeout
));
13345 ok(!ret
, "expected success\n");
13346 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13348 timeout
= 0xdeadbeef;
13349 len
= sizeof(timeout
);
13350 WSASetLastError(0xdeadbeef);
13351 ret
= getsockopt(client
, SOL_SOCKET
, SO_RCVTIMEO
, (char *)&timeout
, &len
);
13352 ok(!ret
, "expected success\n");
13353 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13354 ok(timeout
== 100, "got timeout %lu\n", timeout
);
13356 WSASetLastError(0xdeadbeef);
13357 ret
= recv(client
, &buffer
, 1, 0);
13358 ok(ret
== -1, "got %d\n", ret
);
13359 ok(WSAGetLastError() == WSAETIMEDOUT
, "got error %u\n", WSAGetLastError());
13361 wsabuf
.buf
= &buffer
;
13363 WSASetLastError(0xdeadbeef);
13365 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, NULL
, NULL
);
13366 ok(ret
== -1, "got %d\n", ret
);
13367 ok(WSAGetLastError() == WSAETIMEDOUT
, "got error %u\n", WSAGetLastError());
13368 ok(size
== 0xdeadbeef, "got size %lu\n", size
);
13370 wsabuf
.buf
= &buffer
;
13372 WSASetLastError(0xdeadbeef);
13374 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
13375 ok(ret
== -1, "got %d\n", ret
);
13376 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
13378 ret
= WaitForSingleObject(overlapped
.hEvent
, 200);
13379 ok(ret
== WAIT_TIMEOUT
, "got %d\n", ret
);
13381 ret
= send(server
, "a", 1, 0);
13382 ok(ret
== 1, "got %d\n", ret
);
13384 ret
= WaitForSingleObject(overlapped
.hEvent
, 200);
13385 ok(!ret
, "got %d\n", ret
);
13386 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
13387 ok(ret
, "got error %lu\n", GetLastError());
13388 ok(size
== 1, "got size %lu\n", size
);
13390 closesocket(client
);
13391 closesocket(server
);
13392 CloseHandle(overlapped
.hEvent
);
13395 static void test_so_debug(void)
13401 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
13403 len
= sizeof(debug
);
13404 WSASetLastError(0xdeadbeef);
13405 debug
= 0xdeadbeef;
13406 ret
= getsockopt(s
, SOL_SOCKET
, SO_DEBUG
, (char *)&debug
, &len
);
13407 ok(!ret
, "got %d\n", ret
);
13408 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13409 ok(len
== sizeof(debug
), "got len %u\n", len
);
13410 ok(!debug
, "got debug %lu\n", debug
);
13412 WSASetLastError(0xdeadbeef);
13414 ret
= setsockopt(s
, SOL_SOCKET
, SO_DEBUG
, (char *)&debug
, sizeof(debug
));
13415 ok(!ret
, "got %d\n", ret
);
13416 todo_wine
ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13418 len
= sizeof(debug
);
13419 WSASetLastError(0xdeadbeef);
13420 debug
= 0xdeadbeef;
13421 ret
= getsockopt(s
, SOL_SOCKET
, SO_DEBUG
, (char *)&debug
, &len
);
13422 ok(!ret
, "got %d\n", ret
);
13423 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13424 ok(len
== sizeof(debug
), "got len %u\n", len
);
13425 todo_wine
ok(debug
== 1, "got debug %lu\n", debug
);
13430 struct sockopt_validity_test
13438 static void do_sockopt_validity_tests(const char *type
, SOCKET sock
, int level
,
13439 const struct sockopt_validity_test
*tests
)
13442 int count
, rc
, expected_rc
, i
;
13444 for (i
= 0; tests
[i
].opt
; i
++)
13446 winetest_push_context("%s option %i", type
, tests
[i
].opt
);
13447 memset(value
, 0, sizeof(value
));
13448 count
= sizeof(value
);
13450 WSASetLastError(0);
13451 rc
= getsockopt(sock
, level
, tests
[i
].opt
, value
, &count
);
13452 expected_rc
= tests
[i
].get_error
? SOCKET_ERROR
: 0;
13453 todo_wine_if(!tests
[i
].get_error
&& tests
[i
].todo
)
13454 ok(rc
== expected_rc
|| broken(rc
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOPROTOOPT
),
13455 "expected getsockopt to return %i, got %i\n", expected_rc
, rc
);
13456 todo_wine_if(tests
[i
].todo
)
13457 ok(WSAGetLastError() == tests
[i
].get_error
|| broken(rc
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOPROTOOPT
),
13458 "expected getsockopt to set error %i, got %i\n", tests
[i
].get_error
, WSAGetLastError());
13460 if (tests
[i
].get_error
)
13462 winetest_pop_context();
13466 WSASetLastError(0);
13467 rc
= setsockopt(sock
, level
, tests
[i
].opt
, value
, count
);
13468 expected_rc
= tests
[i
].set_error
? SOCKET_ERROR
: 0;
13469 todo_wine_if(!tests
[i
].set_error
&& tests
[i
].todo
)
13470 ok(rc
== expected_rc
|| broken(rc
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOPROTOOPT
),
13471 "expected setsockopt to return %i, got %i\n", expected_rc
, rc
);
13472 todo_wine_if(tests
[i
].todo
)
13473 ok(WSAGetLastError() == tests
[i
].set_error
|| broken(rc
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOPROTOOPT
),
13474 "expected setsockopt to set error %i, got %i\n", tests
[i
].set_error
, WSAGetLastError());
13476 winetest_pop_context();
13480 static void test_sockopt_validity(void)
13482 static const struct sockopt_validity_test ipv4_tcp_tests
[] =
13484 { -1, WSAENOPROTOOPT
},
13486 { IP_HDRINCL
, WSAEINVAL
},
13489 { IP_MULTICAST_IF
, WSAEINVAL
},
13490 { IP_MULTICAST_TTL
, WSAEINVAL
},
13491 { IP_MULTICAST_LOOP
, WSAEINVAL
},
13492 { IP_ADD_MEMBERSHIP
, WSAENOPROTOOPT
},
13493 { IP_DROP_MEMBERSHIP
, WSAENOPROTOOPT
},
13494 { IP_DONTFRAGMENT
},
13495 { IP_PKTINFO
, WSAEINVAL
},
13496 { IP_RECVTTL
, WSAEINVAL
},
13497 { IP_RECEIVE_BROADCAST
, WSAEINVAL
, 0, TRUE
},
13498 { IP_RECVIF
, WSAEINVAL
, 0, TRUE
},
13499 { IP_RECVDSTADDR
, WSAEINVAL
, 0, TRUE
},
13500 { IP_IFLIST
, 0, 0, TRUE
},
13502 { IP_RTHDR
, 0, 0, TRUE
},
13503 { IP_GET_IFLIST
, WSAEINVAL
, 0, TRUE
},
13504 { IP_RECVRTHDR
, WSAEINVAL
, 0, TRUE
},
13505 { IP_RECVTOS
, WSAEINVAL
},
13506 { IP_ORIGINAL_ARRIVAL_IF
, WSAEINVAL
, 0, TRUE
},
13507 { IP_ECN
, WSAEINVAL
, 0, TRUE
},
13508 { IP_PKTINFO_EX
, WSAEINVAL
, 0, TRUE
},
13509 { IP_WFP_REDIRECT_RECORDS
, WSAEINVAL
, 0, TRUE
},
13510 { IP_WFP_REDIRECT_CONTEXT
, WSAEINVAL
, 0, TRUE
},
13511 { IP_MTU_DISCOVER
, 0, WSAEINVAL
, TRUE
},
13512 { IP_MTU
, WSAENOTCONN
, 0, TRUE
},
13513 { IP_RECVERR
, WSAEINVAL
, 0, TRUE
},
13514 { IP_USER_MTU
, 0, 0, TRUE
},
13517 static const struct sockopt_validity_test ipv4_udp_tests
[] =
13519 { -1, WSAENOPROTOOPT
},
13521 { IP_HDRINCL
, WSAEINVAL
},
13524 { IP_MULTICAST_IF
},
13525 { IP_MULTICAST_TTL
},
13526 { IP_MULTICAST_LOOP
},
13527 { IP_ADD_MEMBERSHIP
, WSAENOPROTOOPT
},
13528 { IP_DROP_MEMBERSHIP
, WSAENOPROTOOPT
},
13529 { IP_DONTFRAGMENT
},
13532 { IP_RECEIVE_BROADCAST
, 0, 0, TRUE
},
13533 { IP_RECVIF
, 0, 0, TRUE
},
13534 { IP_RECVDSTADDR
, 0, 0, TRUE
},
13535 { IP_IFLIST
, 0, 0, TRUE
},
13537 { IP_RTHDR
, 0, 0, TRUE
},
13538 { IP_GET_IFLIST
, WSAEINVAL
, 0, TRUE
},
13539 { IP_RECVRTHDR
, 0, 0, TRUE
},
13541 { IP_ORIGINAL_ARRIVAL_IF
, 0, 0, TRUE
},
13542 { IP_ECN
, 0, 0, TRUE
},
13543 { IP_PKTINFO_EX
, 0, 0, TRUE
},
13544 { IP_WFP_REDIRECT_RECORDS
, 0, 0, TRUE
},
13545 { IP_WFP_REDIRECT_CONTEXT
, 0, 0, TRUE
},
13546 { IP_MTU_DISCOVER
, 0, WSAEINVAL
, TRUE
},
13547 { IP_MTU
, WSAENOTCONN
, 0, TRUE
},
13548 { IP_RECVERR
, 0, 0, TRUE
},
13549 { IP_USER_MTU
, 0, 0, TRUE
},
13552 static const struct sockopt_validity_test ipv4_raw_tests
[] =
13554 { -1, WSAENOPROTOOPT
},
13559 { IP_MULTICAST_IF
},
13560 { IP_MULTICAST_TTL
},
13561 { IP_MULTICAST_LOOP
},
13562 { IP_ADD_MEMBERSHIP
, WSAENOPROTOOPT
},
13563 { IP_DROP_MEMBERSHIP
, WSAENOPROTOOPT
},
13564 { IP_DONTFRAGMENT
},
13567 { IP_RECEIVE_BROADCAST
, 0, 0, TRUE
},
13568 { IP_RECVIF
, 0, 0, TRUE
},
13569 { IP_RECVDSTADDR
, 0, 0, TRUE
},
13570 { IP_IFLIST
, 0, 0, TRUE
},
13572 { IP_RTHDR
, 0, 0, TRUE
},
13573 { IP_GET_IFLIST
, WSAEINVAL
, 0, TRUE
},
13574 { IP_RECVRTHDR
, 0, 0, TRUE
},
13576 { IP_ORIGINAL_ARRIVAL_IF
, 0, 0, TRUE
},
13577 { IP_ECN
, 0, 0, TRUE
},
13578 { IP_PKTINFO_EX
, 0, 0, TRUE
},
13579 { IP_WFP_REDIRECT_RECORDS
, 0, 0, TRUE
},
13580 { IP_WFP_REDIRECT_CONTEXT
, 0, 0, TRUE
},
13581 { IP_MTU_DISCOVER
, 0, WSAEINVAL
, TRUE
},
13582 { IP_MTU
, WSAENOTCONN
, 0, TRUE
},
13583 { IP_RECVERR
, WSAEINVAL
, 0, TRUE
},
13584 { IP_USER_MTU
, 0, 0, TRUE
},
13587 static const struct sockopt_validity_test ipv6_tcp_tests
[] =
13589 { -1, WSAENOPROTOOPT
},
13590 { IPV6_HOPOPTS
, 0, 0, TRUE
},
13591 { IPV6_HDRINCL
, WSAEINVAL
, 0, TRUE
},
13592 { IPV6_UNICAST_HOPS
},
13593 { IPV6_MULTICAST_IF
, WSAEINVAL
},
13594 { IPV6_MULTICAST_HOPS
, WSAEINVAL
},
13595 { IPV6_MULTICAST_LOOP
, WSAEINVAL
},
13596 { IPV6_ADD_MEMBERSHIP
, WSAENOPROTOOPT
},
13597 { IPV6_DROP_MEMBERSHIP
, WSAENOPROTOOPT
},
13599 { IPV6_PKTINFO
, WSAEINVAL
},
13600 { IPV6_HOPLIMIT
, WSAEINVAL
},
13601 { IPV6_PROTECTION_LEVEL
},
13602 { IPV6_RECVIF
, WSAEINVAL
, 0, TRUE
},
13603 { IPV6_RECVDSTADDR
, WSAEINVAL
, 0, TRUE
},
13605 { IPV6_IFLIST
, 0, 0, TRUE
},
13606 { IPV6_UNICAST_IF
},
13607 { IPV6_RTHDR
, 0, 0, TRUE
},
13608 { IPV6_GET_IFLIST
, WSAEINVAL
, 0, TRUE
},
13609 { IPV6_RECVRTHDR
, WSAEINVAL
, 0, TRUE
},
13610 { IPV6_RECVTCLASS
, WSAEINVAL
},
13611 { IP_ORIGINAL_ARRIVAL_IF
, WSAEINVAL
, 0, TRUE
},
13612 { IPV6_ECN
, WSAEINVAL
, 0, TRUE
},
13613 { IPV6_PKTINFO_EX
, WSAEINVAL
, 0, TRUE
},
13614 { IPV6_WFP_REDIRECT_RECORDS
, WSAEINVAL
, 0, TRUE
},
13615 { IPV6_WFP_REDIRECT_CONTEXT
, WSAEINVAL
, 0, TRUE
},
13616 { IPV6_MTU_DISCOVER
, 0, WSAEINVAL
, TRUE
},
13617 { IPV6_MTU
, WSAENOTCONN
, 0, TRUE
},
13618 { IPV6_RECVERR
, WSAEINVAL
, 0, TRUE
},
13619 { IPV6_USER_MTU
, 0, 0, TRUE
},
13622 static const struct sockopt_validity_test ipv6_udp_tests
[] =
13624 { -1, WSAENOPROTOOPT
},
13625 { IPV6_HOPOPTS
, 0, 0, TRUE
},
13626 { IPV6_HDRINCL
, WSAEINVAL
, 0, TRUE
},
13627 { IPV6_UNICAST_HOPS
},
13628 { IPV6_MULTICAST_IF
},
13629 { IPV6_MULTICAST_HOPS
},
13630 { IPV6_MULTICAST_LOOP
},
13631 { IPV6_ADD_MEMBERSHIP
, WSAENOPROTOOPT
},
13632 { IPV6_DROP_MEMBERSHIP
, WSAENOPROTOOPT
},
13636 { IPV6_PROTECTION_LEVEL
},
13637 { IPV6_RECVIF
, 0, 0, TRUE
},
13638 { IPV6_RECVDSTADDR
, 0, 0, TRUE
},
13640 { IPV6_IFLIST
, 0, 0, TRUE
},
13641 { IPV6_UNICAST_IF
},
13642 { IPV6_RTHDR
, 0, 0, TRUE
},
13643 { IPV6_GET_IFLIST
, WSAEINVAL
, 0, TRUE
},
13644 { IPV6_RECVRTHDR
, 0, 0, TRUE
},
13645 { IPV6_RECVTCLASS
},
13646 { IP_ORIGINAL_ARRIVAL_IF
, 0, 0, TRUE
},
13647 { IPV6_ECN
, 0, 0, TRUE
},
13648 { IPV6_PKTINFO_EX
, 0, 0, TRUE
},
13649 { IPV6_WFP_REDIRECT_RECORDS
, 0, 0, TRUE
},
13650 { IPV6_WFP_REDIRECT_CONTEXT
, 0, 0, TRUE
},
13651 { IPV6_MTU_DISCOVER
, 0, WSAEINVAL
, TRUE
},
13652 { IPV6_MTU
, WSAENOTCONN
, 0, TRUE
},
13653 { IPV6_RECVERR
, 0, 0, TRUE
},
13654 { IPV6_USER_MTU
, 0, 0, TRUE
},
13657 static const struct sockopt_validity_test ipv6_raw_tests
[] =
13659 { -1, WSAENOPROTOOPT
},
13660 { IPV6_HOPOPTS
, 0, 0, TRUE
},
13661 { IPV6_HDRINCL
, 0, 0, TRUE
},
13662 { IPV6_UNICAST_HOPS
},
13663 { IPV6_MULTICAST_IF
},
13664 { IPV6_MULTICAST_HOPS
},
13665 { IPV6_MULTICAST_LOOP
},
13666 { IPV6_ADD_MEMBERSHIP
, WSAENOPROTOOPT
},
13667 { IPV6_DROP_MEMBERSHIP
, WSAENOPROTOOPT
},
13671 { IPV6_PROTECTION_LEVEL
},
13672 { IPV6_RECVIF
, 0, 0, TRUE
},
13673 { IPV6_RECVDSTADDR
, 0, 0, TRUE
},
13675 { IPV6_IFLIST
, 0, 0, TRUE
},
13676 { IPV6_UNICAST_IF
},
13677 { IPV6_RTHDR
, 0, 0, TRUE
},
13678 { IPV6_GET_IFLIST
, WSAEINVAL
, 0, TRUE
},
13679 { IPV6_RECVRTHDR
, 0, 0, TRUE
},
13680 { IPV6_RECVTCLASS
},
13681 { IP_ORIGINAL_ARRIVAL_IF
, 0, 0, TRUE
},
13682 { IPV6_ECN
, 0, 0, TRUE
},
13683 { IPV6_PKTINFO_EX
, 0, 0, TRUE
},
13684 { IPV6_WFP_REDIRECT_RECORDS
, 0, 0, TRUE
},
13685 { IPV6_WFP_REDIRECT_CONTEXT
, 0, 0, TRUE
},
13686 { IPV6_MTU_DISCOVER
, 0, WSAEINVAL
, TRUE
},
13687 { IPV6_MTU
, WSAENOTCONN
, 0, TRUE
},
13688 { IPV6_RECVERR
, WSAEINVAL
, 0, TRUE
},
13689 { IPV6_USER_MTU
, 0, 0, TRUE
},
13692 static const struct sockopt_validity_test file_handle_tests
[] =
13694 { -1, WSAENOTSOCK
},
13695 { SO_TYPE
, WSAENOTSOCK
},
13699 char path
[MAX_PATH
];
13703 sock
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
13704 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
13705 do_sockopt_validity_tests("IPv4 TCP", sock
, IPPROTO_IP
, ipv4_tcp_tests
);
13708 sock
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
13709 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
13710 do_sockopt_validity_tests("IPv4 UDP", sock
, IPPROTO_IP
, ipv4_udp_tests
);
13713 sock
= socket(AF_INET
, SOCK_RAW
, IPPROTO_RAW
);
13714 if (sock
== INVALID_SOCKET
&& WSAGetLastError() == WSAEACCES
)
13716 skip("Raw IPv4 sockets are not available\n");
13720 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
13721 do_sockopt_validity_tests("IPv4 raw", sock
, IPPROTO_IP
, ipv4_raw_tests
);
13725 sock
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
13726 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
13727 do_sockopt_validity_tests("IPv6 TCP", sock
, IPPROTO_IPV6
, ipv6_tcp_tests
);
13730 sock
= socket(AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
);
13731 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
13732 do_sockopt_validity_tests("IPv6 UDP", sock
, IPPROTO_IPV6
, ipv6_udp_tests
);
13735 sock
= socket(AF_INET6
, SOCK_RAW
, IPPROTO_RAW
);
13736 if (sock
== INVALID_SOCKET
&& WSAGetLastError() == WSAEACCES
)
13738 skip("Raw IPv6 sockets are not available\n");
13742 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
13743 do_sockopt_validity_tests("IPv6 raw", sock
, IPPROTO_IPV6
, ipv6_raw_tests
);
13747 GetSystemWindowsDirectoryA(path
, ARRAY_SIZE(path
));
13748 strcat(path
, "\\system.ini");
13749 file
= CreateFileA(path
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_ALWAYS
, 0x0, NULL
);
13750 do_sockopt_validity_tests("file", (SOCKET
)file
, SOL_SOCKET
, file_handle_tests
);
13754 static void test_tcp_reset(void)
13756 static const struct timeval select_timeout
;
13757 fd_set readfds
, writefds
, exceptfds
;
13758 OVERLAPPED overlapped
= {0};
13759 SOCKET client
, server
;
13760 DWORD size
, flags
= 0;
13761 int ret
, len
, error
;
13765 overlapped
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
13767 tcp_socketpair(&client
, &server
);
13769 wsabuf
.buf
= buffer
;
13770 wsabuf
.len
= sizeof(buffer
);
13771 WSASetLastError(0xdeadbeef);
13773 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
13774 ok(ret
== -1, "got %d\n", ret
);
13775 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
13777 close_with_rst(server
);
13779 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
13780 ok(!ret
, "wait failed\n");
13781 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
13782 ok(!ret
, "expected failure\n");
13783 ok(GetLastError() == ERROR_NETNAME_DELETED
, "got error %lu\n", GetLastError());
13784 ok(!size
, "got size %lu\n", size
);
13785 ok((NTSTATUS
)overlapped
.Internal
== STATUS_CONNECTION_RESET
, "got status %#lx\n", (NTSTATUS
)overlapped
.Internal
);
13787 len
= sizeof(error
);
13788 ret
= getsockopt(client
, SOL_SOCKET
, SO_ERROR
, (char *)&error
, &len
);
13789 ok(!ret
, "got error %u\n", WSAGetLastError());
13790 ok(!error
, "got error %u\n", error
);
13792 wsabuf
.buf
= buffer
;
13793 wsabuf
.len
= sizeof(buffer
);
13794 WSASetLastError(0xdeadbeef);
13796 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
13797 ok(ret
== -1, "got %d\n", ret
);
13798 ok(WSAGetLastError() == WSAECONNRESET
, "got error %u\n", WSAGetLastError());
13800 WSASetLastError(0xdeadbeef);
13801 ret
= send(client
, "data", 5, 0);
13802 ok(ret
== -1, "got %d\n", ret
);
13803 ok(WSAGetLastError() == WSAECONNRESET
, "got error %u\n", WSAGetLastError());
13805 check_poll(client
, POLLERR
| POLLHUP
| POLLWRNORM
);
13808 FD_ZERO(&writefds
);
13809 FD_ZERO(&exceptfds
);
13810 FD_SET(client
, &readfds
);
13811 FD_SET(client
, &writefds
);
13812 FD_SET(client
, &exceptfds
);
13813 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
13814 ok(ret
== 2, "got %d\n", ret
);
13815 ok(FD_ISSET(client
, &readfds
), "FD should be set\n");
13816 ok(FD_ISSET(client
, &writefds
), "FD should be set\n");
13817 ok(!FD_ISSET(client
, &exceptfds
), "FD should be set\n");
13819 FD_ZERO(&exceptfds
);
13820 FD_SET(client
, &exceptfds
);
13821 ret
= select(0, NULL
, NULL
, &exceptfds
, &select_timeout
);
13822 ok(!ret
, "got %d\n", ret
);
13823 ok(!FD_ISSET(client
, &exceptfds
), "FD should be set\n");
13825 closesocket(server
);
13826 CloseHandle(overlapped
.hEvent
);
13846 BYTE v_hl
; /* version << 4 | hdr_len */
13858 /* rfc 1071 checksum */
13859 static unsigned short chksum(BYTE
*data
, unsigned int count
)
13861 unsigned int sum
= 0, carry
= 0;
13862 unsigned short check
, s
;
13866 s
= *(unsigned short *)data
;
13873 sum
+= carry
; /* This won't produce another carry */
13874 sum
= (sum
& 0xffff) + (sum
>> 16);
13876 if (count
) sum
+= *data
; /* LE-only */
13878 sum
= (sum
& 0xffff) + (sum
>> 16);
13879 /* fold in any carry */
13880 sum
= (sum
& 0xffff) + (sum
>> 16);
13886 static void test_icmp(void)
13888 static const unsigned int ping_data
= 0xdeadbeef;
13889 struct icmp_hdr
*icmp_h
;
13890 BYTE send_buf
[sizeof(struct icmp_hdr
) + sizeof(ping_data
)];
13891 UINT16 recv_checksum
, checksum
;
13892 unsigned int reply_data
;
13893 struct sockaddr_in sa
;
13894 struct ip_hdr
*ip_h
;
13895 struct in_addr addr
;
13896 BYTE recv_buf
[256];
13900 s
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_ICMP
, NULL
, 0, 0);
13901 if (s
== INVALID_SOCKET
)
13903 ret
= WSAGetLastError();
13904 ok(ret
== WSAEACCES
, "Expected 10013, received %d\n", ret
);
13905 skip("SOCK_RAW is not supported\n");
13909 icmp_h
= (struct icmp_hdr
*)send_buf
;
13910 icmp_h
->type
= ICMP4_ECHO_REQUEST
;
13912 icmp_h
->checksum
= 0;
13913 icmp_h
->un
.echo
.id
= 0xbeaf; /* will be overwritten for linux ping socks */
13914 icmp_h
->un
.echo
.sequence
= 1;
13915 *(unsigned int *)(icmp_h
+ 1) = ping_data
;
13916 icmp_h
->checksum
= chksum(send_buf
, sizeof(send_buf
));
13918 memset(&sa
, 0, sizeof(sa
));
13919 sa
.sin_family
= AF_INET
;
13921 sa
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
13923 ret
= sendto(s
, (char *)send_buf
, sizeof(send_buf
), 0, (struct sockaddr
*)&sa
, sizeof(sa
));
13924 ok(ret
== sizeof(send_buf
), "got %d, error %d.\n", ret
, WSAGetLastError());
13926 ret
= recv(s
, (char *)recv_buf
, sizeof(struct ip_hdr
) + sizeof(send_buf
) - 1, 0);
13927 ok(ret
== -1, "got %d\n", ret
);
13928 ok(WSAGetLastError() == WSAEMSGSIZE
, "got %d\n", WSAGetLastError());
13930 icmp_h
->un
.echo
.sequence
= 2;
13931 icmp_h
->checksum
= 0;
13932 icmp_h
->checksum
= chksum(send_buf
, sizeof(send_buf
));
13934 ret
= sendto(s
, (char *)send_buf
, sizeof(send_buf
), 0, (struct sockaddr
*)&sa
, sizeof(sa
));
13935 ok(ret
!= SOCKET_ERROR
, "got error %d.\n", WSAGetLastError());
13937 memset(recv_buf
, 0xcc, sizeof(recv_buf
));
13938 ret
= recv(s
, (char *)recv_buf
, sizeof(recv_buf
), 0);
13939 ok(ret
== sizeof(struct ip_hdr
) + sizeof(send_buf
), "got %d\n", ret
);
13941 ip_h
= (struct ip_hdr
*)recv_buf
;
13942 icmp_h
= (struct icmp_hdr
*)(ip_h
+ 1);
13943 reply_data
= *(unsigned int *)(icmp_h
+ 1);
13945 ok(ip_h
->v_hl
== ((4 << 4) | (sizeof(*ip_h
) >> 2)), "got v_hl %#x.\n", ip_h
->v_hl
);
13946 ok(ntohs(ip_h
->tot_len
) == sizeof(struct ip_hdr
) + sizeof(send_buf
),
13947 "got tot_len %#x.\n", ntohs(ip_h
->tot_len
));
13949 recv_checksum
= ip_h
->checksum
;
13950 ip_h
->checksum
= 0;
13951 checksum
= chksum((BYTE
*)ip_h
, sizeof(*ip_h
));
13952 /* Checksum is 0 for localhost ping on Windows but not for remote host ping. */
13953 ok(recv_checksum
== checksum
|| !recv_checksum
, "got checksum %#x, expected %#x.\n", recv_checksum
, checksum
);
13955 ok(!ip_h
->frag_off
, "got id %#x.\n", ip_h
->frag_off
);
13956 addr
.s_addr
= ip_h
->saddr
;
13957 ok(ip_h
->saddr
== sa
.sin_addr
.s_addr
, "got saddr %s.\n", inet_ntoa(addr
));
13958 addr
.s_addr
= ip_h
->daddr
;
13959 ok(!!ip_h
->daddr
, "got daddr %s.\n", inet_ntoa(addr
));
13961 ok(ip_h
->protocol
== 1, "got protocol %#x.\n", ip_h
->protocol
);
13963 ok(icmp_h
->type
== ICMP4_ECHO_REPLY
, "got type %#x.\n", icmp_h
->type
);
13964 ok(!icmp_h
->code
, "got code %#x.\n", icmp_h
->code
);
13965 ok(icmp_h
->un
.echo
.id
== 0xbeaf, "got echo id %#x.\n", icmp_h
->un
.echo
.id
);
13966 ok(icmp_h
->un
.echo
.sequence
== 2, "got echo sequence %#x.\n", icmp_h
->un
.echo
.sequence
);
13968 recv_checksum
= icmp_h
->checksum
;
13969 icmp_h
->checksum
= 0;
13970 checksum
= chksum((BYTE
*)icmp_h
, sizeof(send_buf
));
13971 ok(recv_checksum
== checksum
, "got checksum %#x, expected %#x.\n", recv_checksum
, checksum
);
13973 ok(reply_data
== ping_data
, "got reply_data %#x.\n", reply_data
);
13978 static void test_connect_time(void)
13980 struct sockaddr_in addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
13981 SOCKET client
, server
;
13985 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
13987 len
= sizeof(time
);
13988 SetLastError(0xdeadbeef);
13989 ret
= getsockopt(client
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&time
, &len
);
13990 ok(!ret
, "got %d\n", ret
);
13991 ok(!GetLastError(), "got error %lu\n", GetLastError());
13992 ok(len
== sizeof(time
), "got len %d\n", len
);
13993 ok(time
== ~0u, "got time %u\n", time
);
13995 closesocket(client
);
13997 tcp_socketpair(&client
, &server
);
13999 len
= sizeof(time
);
14000 SetLastError(0xdeadbeef);
14001 ret
= getsockopt(client
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&time
, &len
);
14002 ok(!ret
, "got %d\n", ret
);
14003 ok(!GetLastError(), "got error %lu\n", GetLastError());
14004 ok(len
== sizeof(time
), "got len %d\n", len
);
14005 ok(time
== 0, "got time %u\n", time
);
14007 len
= sizeof(time
);
14008 SetLastError(0xdeadbeef);
14009 ret
= getsockopt(server
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&time
, &len
);
14010 ok(!ret
, "got %d\n", ret
);
14011 ok(!GetLastError(), "got error %lu\n", GetLastError());
14012 ok(len
== sizeof(time
), "got len %d\n", len
);
14013 ok(time
== 0, "got time %u\n", time
);
14015 closesocket(client
);
14016 closesocket(server
);
14018 client
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
14019 server
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
14021 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
14022 ok(!ret
, "got error %lu\n", GetLastError());
14023 len
= sizeof(addr
);
14024 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
14025 ok(!ret
, "got error %lu\n", GetLastError());
14026 ret
= connect(client
, (struct sockaddr
*)&addr
, sizeof(addr
));
14027 ok(!ret
, "got error %lu\n", GetLastError());
14029 len
= sizeof(time
);
14030 SetLastError(0xdeadbeef);
14031 ret
= getsockopt(client
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&time
, &len
);
14032 ok(!ret
, "got %d\n", ret
);
14033 ok(!GetLastError(), "got error %lu\n", GetLastError());
14034 ok(len
== sizeof(time
), "got len %d\n", len
);
14035 ok(time
== ~0u, "got time %u\n", time
);
14037 len
= sizeof(time
);
14038 SetLastError(0xdeadbeef);
14039 ret
= getsockopt(server
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&time
, &len
);
14040 ok(!ret
, "got %d\n", ret
);
14041 ok(!GetLastError(), "got error %lu\n", GetLastError());
14042 ok(len
== sizeof(time
), "got len %d\n", len
);
14043 ok(time
== ~0u, "got time %u\n", time
);
14045 closesocket(server
);
14046 closesocket(client
);
14049 static void test_connect_udp(void)
14051 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
14052 struct sockaddr_in addr
, ret_addr
;
14053 SOCKET client
, server
;
14057 client
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
14058 server
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
14059 set_blocking(client
, FALSE
);
14060 set_blocking(server
, FALSE
);
14062 SetLastError(0xdeadbeef);
14063 ret
= send(client
, "data", 4, 0);
14064 ok(ret
== -1, "got %d\n", ret
);
14065 ok(GetLastError() == WSAENOTCONN
, "got error %lu\n", GetLastError());
14067 SetLastError(0xdeadbeef);
14068 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
14069 ok(ret
== -1, "got %d\n", ret
);
14070 todo_wine
ok(GetLastError() == WSAEINVAL
, "got error %lu\n", GetLastError());
14072 ret
= bind(server
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
14073 ok(!ret
, "got error %lu\n", GetLastError());
14074 len
= sizeof(addr
);
14075 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
14076 ok(!ret
, "got error %lu\n", GetLastError());
14078 SetLastError(0xdeadbeef);
14079 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
14080 ok(ret
== -1, "got %d\n", ret
);
14081 ok(GetLastError() == WSAEWOULDBLOCK
, "got error %lu\n", GetLastError());
14083 ret
= connect(client
, (struct sockaddr
*)&addr
, sizeof(addr
));
14084 ok(!ret
, "got error %lu\n", GetLastError());
14085 ret
= getpeername(client
, (struct sockaddr
*)&ret_addr
, &len
);
14086 ok(!ret
, "got error %lu\n", GetLastError());
14087 ok(!memcmp(&ret_addr
, &addr
, sizeof(addr
)), "addresses didn't match\n");
14089 ret
= getsockname(client
, (struct sockaddr
*)&ret_addr
, &len
);
14090 ok(!ret
, "got error %lu\n", GetLastError());
14092 SetLastError(0xdeadbeef);
14093 ret
= getpeername(server
, (struct sockaddr
*)&ret_addr
, &len
);
14094 ok(ret
== -1, "got %d\n", ret
);
14095 ok(GetLastError() == WSAENOTCONN
, "got error %lu\n", GetLastError());
14097 ret
= send(client
, "data", 4, 0);
14098 ok(ret
== 4, "got %d\n", ret
);
14100 memset(buffer
, 0xcc, sizeof(buffer
));
14101 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
14102 ok(ret
== 4, "got %d\n", ret
);
14103 ok(!memcmp(buffer
, "data", 4), "got %s\n", debugstr_an(buffer
, ret
));
14105 SetLastError(0xdeadbeef);
14106 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
14107 ok(ret
== -1, "got %d\n", ret
);
14108 ok(GetLastError() == WSAEWOULDBLOCK
, "got error %lu\n", GetLastError());
14110 SetLastError(0xdeadbeef);
14111 ret
= send(server
, "data", 4, 0);
14112 ok(ret
== -1, "got %d\n", ret
);
14113 ok(GetLastError() == WSAENOTCONN
, "got error %lu\n", GetLastError());
14115 ret
= connect(client
, (struct sockaddr
*)&addr
, sizeof(addr
));
14116 ok(!ret
, "got error %lu\n", GetLastError());
14118 ret
= connect(client
, (struct sockaddr
*)&addr
, sizeof(addr
));
14119 ok(!ret
, "got error %lu\n", GetLastError());
14121 memset(&addr
, 0, sizeof(addr
));
14122 addr
.sin_family
= AF_UNSPEC
;
14123 ret
= connect(client
, (struct sockaddr
*)&addr
, sizeof(addr
));
14124 ok(!ret
, "got error %lu\n", GetLastError());
14126 ret
= getpeername(client
, (struct sockaddr
*)&ret_addr
, &len
);
14127 ok(ret
== -1, "got %d\n", ret
);
14128 ok(GetLastError() == WSAENOTCONN
, "got error %lu\n", GetLastError());
14130 closesocket(server
);
14131 closesocket(client
);
14134 static void test_tcp_sendto_recvfrom(void)
14136 SOCKET client
, server
= 0;
14137 SOCKADDR_IN addr
= { AF_INET
, SERVERPORT
};
14138 SOCKADDR_IN bad_addr
, bad_addr_copy
;
14139 const char serverMsg
[] = "ws2_32/TCP socket test";
14140 char clientBuf
[sizeof(serverMsg
)] = { 0 };
14141 int to_len
= 0xc0ffee11;
14144 inet_pton(AF_INET
, SERVERIP
, &addr
.sin_addr
);
14146 tcp_socketpair(&client
, &server
);
14148 memset(&bad_addr
, 0xfe, sizeof(bad_addr
));
14149 memcpy(&bad_addr_copy
, &bad_addr
, sizeof(bad_addr_copy
));
14151 ret
= sendto(server
, serverMsg
, sizeof(serverMsg
), 0, (SOCKADDR
*)&bad_addr
, sizeof(bad_addr
));
14152 ok(ret
== sizeof(serverMsg
), "Incorrect return value from sendto: %d (%d)\n", ret
, WSAGetLastError());
14153 ok(!memcmp(&bad_addr
, &bad_addr_copy
, sizeof(bad_addr
)), "Provided address modified by sendto\n");
14154 ok(to_len
== 0xc0ffee11, "Provided size modified by sendto\n");
14156 ret
= recvfrom(client
, clientBuf
, sizeof(clientBuf
), 0, (SOCKADDR
*)&bad_addr
, &to_len
);
14157 ok(ret
== sizeof(serverMsg
), "Incorrect return value from recvfrom: %d (%d)\n", ret
, WSAGetLastError());
14158 ok(!memcmp(&bad_addr
, &bad_addr_copy
, sizeof(bad_addr
)), "Provided address modified by recvfrom\n");
14159 ok(to_len
== 0xc0ffee11, "Provided size modified by recvfrom\n");
14161 ok(!memcmp(serverMsg
, clientBuf
, sizeof(serverMsg
)), "Data mismatch over TCP socket\n");
14163 closesocket(client
);
14164 closesocket(server
);
14167 /* Regression test for an internal bug affecting wget.exe. */
14168 static void test_select_after_WSAEventSelect(void)
14170 SOCKET client
, server
;
14174 tcp_socketpair(&client
, &server
);
14175 event
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
14177 ret
= WSAEventSelect(client
, event
, FD_READ
);
14178 ok(!ret
, "got error %u\n", WSAGetLastError());
14180 ret
= send(server
, "data", 4, 0);
14181 ok(ret
== 4, "got %d\n", ret
);
14183 ret
= WaitForSingleObject(event
, 1000);
14184 ok(!ret
, "got %d\n", ret
);
14186 /* Poll. This must not trigger any events to be signalled again. */
14187 check_poll(client
, POLLRDNORM
| POLLWRNORM
);
14189 ret
= WaitForSingleObject(event
, 0);
14190 ok(ret
== WAIT_TIMEOUT
, "got %d\n", ret
);
14192 CloseHandle(event
);
14193 closesocket(server
);
14194 closesocket(client
);
14201 /* Leave these tests at the beginning. They depend on WSAStartup not having been
14202 * called, which is done by Init() below. */
14203 test_WithoutWSAStartup();
14204 test_WithWSAStartup();
14208 test_set_getsockopt();
14213 test_extendedSocketOptions();
14215 test_sockopt_validity();
14216 test_connect_time();
14218 for (i
= 0; i
< ARRAY_SIZE(tests
); i
++)
14219 do_test(&tests
[i
]);
14224 test_WSADuplicateSocket();
14225 test_WSAConnectByName();
14226 test_WSAEnumNetworkEvents();
14232 test_accept_inheritance();
14233 test_getpeername();
14234 test_getsockname();
14236 test_address_list_query();
14238 test_fionread_siocatmark();
14239 test_get_extension_func();
14240 test_backlog_query();
14241 test_get_interface_list();
14242 test_keepalive_vals();
14243 test_sioRoutingInterfaceQuery();
14244 test_sioAddressListChange();
14245 test_base_handle();
14246 test_circular_queueing();
14247 test_unsupported_ioctls();
14253 test_write_watch();
14256 test_select_after_WSAEventSelect();
14259 test_TransmitFile();
14263 test_DisconnectEx();
14265 test_completion_port();
14266 test_connect_completion_port();
14267 test_shutdown_completion_port();
14269 test_connecting_socket();
14270 test_WSAGetOverlappedResult();
14271 test_nonblocking_async_recv();
14272 test_simultaneous_async_recv();
14277 test_connect_udp();
14278 test_tcp_sendto_recvfrom();
14280 /* There is apparently an obscure interaction between this test and
14281 * test_WSAGetOverlappedResult().
14283 * One thing this test does is to close socket handles through CloseHandle()
14284 * and NtClose(), to prove that that is sufficient to cancel I/O on the
14285 * socket. This has the obscure side effect that ws2_32.dll's internal
14286 * per-process list of sockets never has that socket removed.
14288 * test_WSAGetOverlappedResult() effectively proves that the per-process
14289 * list of sockets exists, by calling DuplicateHandle() on a socket and then
14290 * passing it to a function which cares about socket handle validity, which
14291 * checks that handle against the internal list, finds it invalid, and
14292 * returns WSAENOTSOCK.
14294 * The problem is that if we close an NT handle without removing it from the
14295 * ws2_32 list, then duplicate another handle, it *may* end up allocated to
14296 * the same handle value, and thus re-validate that handle right under the
14297 * nose of ws2_32. This causes the test_WSAGetOverlappedResult() test to
14298 * sometimes succeed where it's expected to fail with ENOTSOCK.
14300 * In order to avoid this, make sure that this test—which is evidently
14301 * destructive to ws2_32 internal state in obscure ways—is executed last.
14305 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */