2 * Unit test suite for winsock functions
4 * Copyright 2002 Martin Wilck
5 * Copyright 2005 Thomas Kho
6 * Copyright 2008 Jeff Zaroyko
7 * Copyright 2017 Dmitry Timoshkov
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #define WIN32_NO_STATUS
35 #include "wine/test.h"
37 #define MAX_CLIENTS 4 /* Max number of clients */
38 #define FIRST_CHAR 'A' /* First character in transferred pattern */
39 #define BIND_SLEEP 10 /* seconds to wait between attempts to bind() */
40 #define BIND_TRIES 6 /* Number of bind() attempts */
41 #define TEST_TIMEOUT 30 /* seconds to wait before killing child threads
42 after server initialization, if something hangs */
44 #define NUM_UDP_PEERS 3 /* Number of UDP sockets to create and test > 1 */
46 #define SERVERIP "127.0.0.1" /* IP to bind to */
47 #define SERVERPORT 9374 /* Port number to bind to */
49 #define wsa_ok(op, cond, msg) \
53 if ( !(cond tmp) ) err = WSAGetLastError(); \
54 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
57 #define make_keepalive(k, enable, time, interval) \
59 k.keepalivetime = time; \
60 k.keepaliveinterval = interval;
62 /* Function pointers */
63 static int (WINAPI
*pWSAPoll
)(WSAPOLLFD
*,ULONG
,INT
);
65 /* Function pointers from ntdll */
66 static DWORD (WINAPI
*pNtClose
)(HANDLE
);
68 /**************** Structs and typedefs ***************/
70 typedef struct thread_info
76 /* Information in the server about open client connections */
77 typedef struct sock_info
80 struct sockaddr_in addr
;
81 struct sockaddr_in peer
;
87 /* Test parameters for both server & client */
88 typedef struct test_params
92 const char *inet_addr
;
99 /* server-specific test parameters */
100 typedef struct server_params
102 test_params
*general
;
107 /* client-specific test parameters */
108 typedef struct client_params
110 test_params
*general
;
115 /* This type combines all information for setting up a test scenario */
116 typedef struct test_setup
120 server_params srv_params
;
122 client_params clt_params
;
125 /* Thread local storage for server */
126 typedef struct server_memory
129 struct sockaddr_in addr
;
130 sock_info sock
[MAX_CLIENTS
];
133 /* Thread local storage for client */
134 typedef struct client_memory
137 struct sockaddr_in addr
;
142 /* SelectReadThread thread parameters */
143 typedef struct select_thread_params
147 } select_thread_params
;
149 /**************** Static variables ***************/
151 static DWORD tls
; /* Thread local storage index */
152 static HANDLE thread
[1+MAX_CLIENTS
];
153 static DWORD thread_id
[1+MAX_CLIENTS
];
154 static HANDLE server_ready
;
155 static HANDLE client_ready
[MAX_CLIENTS
];
156 static int client_id
;
158 /**************** General utility functions ***************/
160 static SOCKET
setup_server_socket(struct sockaddr_in
*addr
, int *len
);
161 static SOCKET
setup_connector_socket(const struct sockaddr_in
*addr
, int len
, BOOL nonblock
);
163 static void tcp_socketpair_flags(SOCKET
*src
, SOCKET
*dst
, DWORD flags
)
165 SOCKET server
= INVALID_SOCKET
;
166 struct sockaddr_in addr
;
169 *src
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, flags
);
170 ok(*src
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
172 server
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, flags
);
173 ok(server
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
175 memset(&addr
, 0, sizeof(addr
));
176 addr
.sin_family
= AF_INET
;
177 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
178 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
179 ok(!ret
, "failed to bind socket, error %u\n", WSAGetLastError());
182 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
183 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
185 ret
= listen(server
, 1);
186 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
188 ret
= connect(*src
, (struct sockaddr
*)&addr
, sizeof(addr
));
189 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
192 *dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
193 ok(*dst
!= INVALID_SOCKET
, "failed to accept socket, error %u\n", WSAGetLastError());
198 static void tcp_socketpair(SOCKET
*src
, SOCKET
*dst
)
200 tcp_socketpair_flags(src
, dst
, WSA_FLAG_OVERLAPPED
);
203 static void set_so_opentype ( BOOL overlapped
)
205 int optval
= !overlapped
, newval
, len
= sizeof (int);
207 ok ( setsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
208 (LPVOID
) &optval
, sizeof (optval
) ) == 0,
209 "setting SO_OPENTYPE failed\n" );
210 ok ( getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
211 (LPVOID
) &newval
, &len
) == 0,
212 "getting SO_OPENTYPE failed\n" );
213 ok ( optval
== newval
, "failed to set SO_OPENTYPE\n" );
216 static int set_blocking ( SOCKET s
, BOOL blocking
)
218 u_long val
= !blocking
;
219 return ioctlsocket ( s
, FIONBIO
, &val
);
222 static void fill_buffer ( char *buf
, int chunk_size
, int n_chunks
)
225 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
226 memset ( p
, c
, chunk_size
);
229 static int test_buffer ( char *buf
, int chunk_size
, int n_chunks
)
233 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
235 for ( i
= 0; i
< chunk_size
; i
++ )
236 if ( p
[i
] != c
) return i
;
242 * This routine is called when a client / server does not expect any more data,
243 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
245 static void read_zero_bytes ( SOCKET s
)
249 while ( ( tmp
= recv ( s
, buf
, 256, 0 ) ) > 0 )
251 ok ( n
<= 0, "garbage data received: %d bytes\n", n
);
254 static int do_synchronous_send ( SOCKET s
, char *buf
, int buflen
, int flags
, int sendlen
)
256 char* last
= buf
+ buflen
, *p
;
258 for ( p
= buf
; n
> 0 && p
< last
; )
260 n
= send ( s
, p
, min ( sendlen
, last
- p
), flags
);
263 wsa_ok ( n
, 0 <=, "do_synchronous_send (%x): error %d\n" );
267 static int do_synchronous_recv ( SOCKET s
, char *buf
, int buflen
, int flags
, int recvlen
)
269 char* last
= buf
+ buflen
, *p
;
271 for ( p
= buf
; n
> 0 && p
< last
; )
273 n
= recv ( s
, p
, min ( recvlen
, last
- p
), flags
);
276 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
280 static int do_synchronous_recvfrom ( SOCKET s
, char *buf
, int buflen
, int flags
, struct sockaddr
*from
, int *fromlen
, int recvlen
)
282 char* last
= buf
+ buflen
, *p
;
284 for ( p
= buf
; n
> 0 && p
< last
; )
286 n
= recvfrom ( s
, p
, min ( recvlen
, last
- p
), flags
, from
, fromlen
);
289 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
294 * Call this routine right after thread startup.
295 * SO_OPENTYPE must by 0, regardless what the server did.
297 static void check_so_opentype (void)
301 getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
, (LPVOID
) &tmp
, &len
);
302 ok ( tmp
== 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp
);
305 /**************** Server utility functions ***************/
308 * Even if we have closed our server socket cleanly,
309 * the OS may mark the address "in use" for some time -
310 * this happens with native Linux apps, too.
312 static void do_bind ( SOCKET s
, struct sockaddr
* addr
, int addrlen
)
314 int err
, wsaerr
= 0, n_try
= BIND_TRIES
;
316 while ( ( err
= bind ( s
, addr
, addrlen
) ) != 0 &&
317 ( wsaerr
= WSAGetLastError () ) == WSAEADDRINUSE
&&
320 trace ( "address in use, waiting ...\n" );
321 Sleep ( 1000 * BIND_SLEEP
);
323 ok ( err
== 0, "failed to bind: %d\n", wsaerr
);
326 static void server_start ( server_params
*par
)
329 test_params
*gen
= par
->general
;
330 server_memory
*mem
= LocalAlloc ( LPTR
, sizeof ( server_memory
) );
332 TlsSetValue ( tls
, mem
);
333 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
334 NULL
, 0, par
->sock_flags
);
335 ok ( mem
->s
!= INVALID_SOCKET
, "Server: WSASocket failed\n" );
337 mem
->addr
.sin_family
= AF_INET
;
338 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
339 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
341 for (i
= 0; i
< MAX_CLIENTS
; i
++)
343 mem
->sock
[i
].s
= INVALID_SOCKET
;
344 mem
->sock
[i
].buf
= LocalAlloc ( LPTR
, gen
->n_chunks
* gen
->chunk_size
);
345 mem
->sock
[i
].n_recvd
= 0;
346 mem
->sock
[i
].n_sent
= 0;
349 if ( gen
->sock_type
== SOCK_STREAM
)
350 do_bind ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof (mem
->addr
) );
353 static void server_stop (void)
356 server_memory
*mem
= TlsGetValue ( tls
);
358 for (i
= 0; i
< MAX_CLIENTS
; i
++ )
360 LocalFree ( mem
->sock
[i
].buf
);
361 if ( mem
->sock
[i
].s
!= INVALID_SOCKET
)
362 closesocket ( mem
->sock
[i
].s
);
364 ok ( closesocket ( mem
->s
) == 0, "closesocket failed\n" );
366 ExitThread ( GetCurrentThreadId () );
369 /**************** Client utilitiy functions ***************/
371 static void client_start ( client_params
*par
)
373 test_params
*gen
= par
->general
;
374 client_memory
*mem
= LocalAlloc (LPTR
, sizeof (client_memory
));
376 TlsSetValue ( tls
, mem
);
378 WaitForSingleObject ( server_ready
, INFINITE
);
380 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
381 NULL
, 0, par
->sock_flags
);
383 mem
->addr
.sin_family
= AF_INET
;
384 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
385 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
387 ok ( mem
->s
!= INVALID_SOCKET
, "Client: WSASocket failed\n" );
389 mem
->send_buf
= LocalAlloc ( LPTR
, 2 * gen
->n_chunks
* gen
->chunk_size
);
390 mem
->recv_buf
= mem
->send_buf
+ gen
->n_chunks
* gen
->chunk_size
;
391 fill_buffer ( mem
->send_buf
, gen
->chunk_size
, gen
->n_chunks
);
393 SetEvent ( client_ready
[client_id
] );
394 /* Wait for the other clients to come up */
395 WaitForMultipleObjects ( min ( gen
->n_clients
, MAX_CLIENTS
), client_ready
, TRUE
, INFINITE
);
398 static void client_stop (void)
400 client_memory
*mem
= TlsGetValue ( tls
);
401 wsa_ok ( closesocket ( mem
->s
), 0 ==, "closesocket error (%x): %d\n" );
402 LocalFree ( mem
->send_buf
);
407 /**************** Servers ***************/
410 * simple_server: A very basic server doing synchronous IO.
412 static VOID WINAPI
simple_server ( server_params
*par
)
414 test_params
*gen
= par
->general
;
416 int pos
, n_recvd
, n_sent
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
417 id
= GetCurrentThreadId();
419 set_so_opentype ( FALSE
); /* non-overlapped */
420 server_start ( par
);
421 mem
= TlsGetValue ( tls
);
423 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
424 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "simple_server (%x): listen failed: %d\n");
426 SetEvent ( server_ready
); /* notify clients */
428 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
430 /* accept a single connection */
431 tmp
= sizeof ( mem
->sock
[0].peer
);
432 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
433 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "simple_server (%x): accept failed: %d\n" );
435 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
436 "simple_server (%x): strange peer address\n", id
);
438 /* Receive data & check it */
439 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
440 ok ( n_recvd
== n_expected
,
441 "simple_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
442 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
443 ok ( pos
== -1, "simple_server (%x): test pattern error: %d\n", id
, pos
);
446 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
447 ok ( n_sent
== n_expected
,
448 "simple_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
451 read_zero_bytes ( mem
->sock
[0].s
);
452 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "simple_server (%x): closesocket error: %d\n" );
453 mem
->sock
[0].s
= INVALID_SOCKET
;
460 * oob_server: A very basic server receiving out-of-band data.
462 static VOID WINAPI
oob_server ( server_params
*par
)
464 test_params
*gen
= par
->general
;
467 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
,
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 ==, "oob_server (%x): failed to set blocking mode: %d\n");
475 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "oob_server (%x): listen failed: %d\n");
477 SetEvent ( server_ready
); /* notify clients */
479 /* accept a single connection */
480 tmp
= sizeof ( mem
->sock
[0].peer
);
481 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
482 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "oob_server (%x): accept failed: %d\n" );
484 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
485 "oob_server (%x): strange peer address\n", id
);
487 /* check initial atmark state */
488 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
489 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
491 /* Receive normal data */
492 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
493 ok ( n_recvd
== n_expected
,
494 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
495 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
496 ok ( pos
== -1, "oob_server (%x): test pattern error: %d\n", id
, pos
);
498 /* check atmark state */
499 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
500 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
503 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
504 ok ( n_sent
== n_expected
,
505 "oob_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
507 /* Receive a part of the out-of-band data and print atmark state */
508 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, 8, 0, par
->buflen
);
510 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, 8 );
513 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
515 /* Receive the rest of the out-of-band data and check atmark state */
516 do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
518 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
519 todo_wine
ok ( atmark
== 0, "oob_server (%x): not at the OOB mark: %i\n", id
, atmark
);
522 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "oob_server (%x): closesocket error: %d\n" );
523 mem
->sock
[0].s
= INVALID_SOCKET
;
529 * select_server: A non-blocking server.
531 static VOID WINAPI
select_server ( server_params
*par
)
533 test_params
*gen
= par
->general
;
535 int n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
536 id
= GetCurrentThreadId(), n_connections
= 0, n_sent
, n_recvd
,
537 n_set
, delta
, n_ready
;
538 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
539 fd_set fds_recv
, fds_send
, fds_openrecv
, fds_opensend
;
541 set_so_opentype ( FALSE
); /* non-overlapped */
542 server_start ( par
);
543 mem
= TlsGetValue ( tls
);
545 wsa_ok ( set_blocking ( mem
->s
, FALSE
), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
546 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "select_server (%x): listen failed: %d\n");
548 SetEvent ( server_ready
); /* notify clients */
550 FD_ZERO ( &fds_openrecv
);
551 FD_ZERO ( &fds_recv
);
552 FD_ZERO ( &fds_send
);
553 FD_ZERO ( &fds_opensend
);
555 FD_SET ( mem
->s
, &fds_openrecv
);
559 fds_recv
= fds_openrecv
;
560 fds_send
= fds_opensend
;
564 wsa_ok ( ( n_ready
= select ( 0, &fds_recv
, &fds_send
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
565 "select_server (%x): select() failed: %d\n" );
567 /* check for incoming requests */
568 if ( FD_ISSET ( mem
->s
, &fds_recv
) ) {
571 /* accept a single connection */
572 tmp
= sizeof ( mem
->sock
[n_connections
].peer
);
573 mem
->sock
[n_connections
].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[n_connections
].peer
, &tmp
);
574 wsa_ok ( mem
->sock
[n_connections
].s
, INVALID_SOCKET
!=, "select_server (%x): accept() failed: %d\n" );
576 ok ( mem
->sock
[n_connections
].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
577 "select_server (%x): strange peer address\n", id
);
579 /* add to list of open connections */
580 FD_SET ( mem
->sock
[n_connections
].s
, &fds_openrecv
);
581 FD_SET ( mem
->sock
[n_connections
].s
, &fds_opensend
);
586 /* handle open requests */
588 for ( i
= 0; i
< n_connections
; i
++ )
590 if ( FD_ISSET( mem
->sock
[i
].s
, &fds_recv
) ) {
593 if ( mem
->sock
[i
].n_recvd
< n_expected
) {
594 /* Receive data & check it */
595 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 );
596 ok ( n_recvd
!= SOCKET_ERROR
, "select_server (%x): error in recv(): %d\n", id
, WSAGetLastError() );
597 mem
->sock
[i
].n_recvd
+= n_recvd
;
599 if ( mem
->sock
[i
].n_recvd
== n_expected
) {
600 int pos
= test_buffer ( mem
->sock
[i
].buf
, gen
->chunk_size
, gen
->n_chunks
);
601 ok ( pos
== -1, "select_server (%x): test pattern error: %d\n", id
, pos
);
602 FD_CLR ( mem
->sock
[i
].s
, &fds_openrecv
);
605 ok ( mem
->sock
[i
].n_recvd
<= n_expected
, "select_server (%x): received too many bytes: %d\n", id
, mem
->sock
[i
].n_recvd
);
609 /* only echo back what we've received */
610 delta
= mem
->sock
[i
].n_recvd
- mem
->sock
[i
].n_sent
;
612 if ( FD_ISSET ( mem
->sock
[i
].s
, &fds_send
) ) {
615 if ( ( delta
> 0 ) && ( mem
->sock
[i
].n_sent
< n_expected
) ) {
617 n_sent
= send ( mem
->sock
[i
].s
, mem
->sock
[i
].buf
+ mem
->sock
[i
].n_sent
, min ( delta
, par
->buflen
), 0 );
618 ok ( n_sent
!= SOCKET_ERROR
, "select_server (%x): error in send(): %d\n", id
, WSAGetLastError() );
619 mem
->sock
[i
].n_sent
+= n_sent
;
621 if ( mem
->sock
[i
].n_sent
== n_expected
) {
622 FD_CLR ( mem
->sock
[i
].s
, &fds_opensend
);
625 ok ( mem
->sock
[i
].n_sent
<= n_expected
, "select_server (%x): sent too many bytes: %d\n", id
, mem
->sock
[i
].n_sent
);
630 /* check that select returned the correct number of ready sockets */
631 ok ( ( n_set
== n_ready
), "select_server (%x): select() returns wrong number of ready sockets\n", id
);
633 /* check if all clients are done */
634 if ( ( fds_opensend
.fd_count
== 0 )
635 && ( fds_openrecv
.fd_count
== 1 ) /* initial socket that accepts clients */
636 && ( n_connections
== min ( gen
->n_clients
, MAX_CLIENTS
) ) ) {
641 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
644 read_zero_bytes ( mem
->sock
[i
].s
);
645 wsa_ok ( closesocket ( mem
->sock
[i
].s
), 0 ==, "select_server (%x): closesocket error: %d\n" );
646 mem
->sock
[i
].s
= INVALID_SOCKET
;
652 /**************** Clients ***************/
655 * simple_client: A very basic client doing synchronous IO.
657 static VOID WINAPI
simple_client ( client_params
*par
)
659 test_params
*gen
= par
->general
;
661 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
663 id
= GetCurrentThreadId();
664 /* wait here because we want to call set_so_opentype before creating a socket */
665 WaitForSingleObject ( server_ready
, INFINITE
);
667 check_so_opentype ();
668 set_so_opentype ( FALSE
); /* non-overlapped */
669 client_start ( par
);
670 mem
= TlsGetValue ( tls
);
673 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
674 0 ==, "simple_client (%x): connect error: %d\n" );
675 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
676 "simple_client (%x): failed to set blocking mode\n", id
);
678 /* send data to server */
679 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
680 ok ( n_sent
== n_expected
,
681 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
683 /* shutdown send direction */
684 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
686 /* Receive data echoed back & check it */
687 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, 0, par
->buflen
);
688 ok ( n_recvd
== n_expected
,
689 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
692 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
693 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
696 read_zero_bytes ( mem
->s
);
701 * oob_client: A very basic client sending out-of-band data.
703 static VOID WINAPI
oob_client ( client_params
*par
)
705 test_params
*gen
= par
->general
;
707 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
709 id
= GetCurrentThreadId();
710 /* wait here because we want to call set_so_opentype before creating a socket */
711 WaitForSingleObject ( server_ready
, INFINITE
);
713 check_so_opentype ();
714 set_so_opentype ( FALSE
); /* non-overlapped */
715 client_start ( par
);
716 mem
= TlsGetValue ( tls
);
719 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
720 0 ==, "oob_client (%x): connect error: %d\n" );
721 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
722 "oob_client (%x): failed to set blocking mode\n", id
);
724 /* send data to server */
725 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
726 ok ( n_sent
== n_expected
,
727 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
729 /* Receive data echoed back & check it */
730 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, 0, par
->buflen
);
731 ok ( n_recvd
== n_expected
,
732 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
733 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
734 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
736 /* send out-of-band data to server */
737 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, MSG_OOB
, par
->buflen
);
738 ok ( n_sent
== n_expected
,
739 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
741 /* shutdown send direction */
742 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
745 read_zero_bytes ( mem
->s
);
750 * simple_mixed_client: mixing send and recvfrom
752 static VOID WINAPI
simple_mixed_client ( client_params
*par
)
754 test_params
*gen
= par
->general
;
756 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
757 int fromLen
= sizeof(mem
->addr
);
758 struct sockaddr test
;
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 ==, "simple_client (%x): connect error: %d\n" );
772 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
773 "simple_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 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
780 /* shutdown send direction */
781 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
783 /* this shouldn't change, since lpFrom, is not updated on
784 connection oriented sockets - exposed by bug 11640
786 ((struct sockaddr_in
*)&test
)->sin_addr
.s_addr
= inet_addr("0.0.0.0");
788 /* Receive data echoed back & check it */
789 n_recvd
= do_synchronous_recvfrom ( mem
->s
,
793 (struct sockaddr
*)&test
,
796 ok ( n_recvd
== n_expected
,
797 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
799 /* check that lpFrom was not updated */
802 inet_ntoa(((struct sockaddr_in
*)&test
)->sin_addr
),
803 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
806 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
807 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
810 read_zero_bytes ( mem
->s
);
815 * event_client: An event-driven client
817 static void WINAPI
event_client ( client_params
*par
)
819 test_params
*gen
= par
->general
;
821 int id
= GetCurrentThreadId(), n_expected
= gen
->n_chunks
* gen
->chunk_size
,
824 WSANETWORKEVENTS wsa_events
;
825 char *send_last
, *recv_last
, *send_p
, *recv_p
;
826 LONG mask
= FD_READ
| FD_WRITE
| FD_CLOSE
;
828 client_start ( par
);
830 mem
= TlsGetValue ( tls
);
832 /* Prepare event notification for connect, makes socket nonblocking */
833 event
= WSACreateEvent ();
834 WSAEventSelect ( mem
->s
, event
, FD_CONNECT
);
835 tmp
= connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) );
837 err
= WSAGetLastError ();
838 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): connect error: %d\n", id
, err
);
839 tmp
= WaitForSingleObject ( event
, INFINITE
);
840 ok ( tmp
== WAIT_OBJECT_0
, "event_client (%x): wait for connect event failed: %d\n", id
, tmp
);
841 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
842 ok ( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
843 err
= wsa_events
.iErrorCode
[ FD_CONNECT_BIT
];
844 ok ( err
== 0, "event_client (%x): connect error: %d\n", id
, err
);
848 WSAEventSelect ( mem
->s
, event
, mask
);
850 recv_p
= mem
->recv_buf
;
851 recv_last
= mem
->recv_buf
+ n_expected
;
852 send_p
= mem
->send_buf
;
853 send_last
= mem
->send_buf
+ n_expected
;
857 err
= WaitForSingleObject ( event
, INFINITE
);
858 ok ( err
== WAIT_OBJECT_0
, "event_client (%x): wait failed\n", id
);
860 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
861 ok( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
863 if ( wsa_events
.lNetworkEvents
& FD_WRITE
)
865 err
= wsa_events
.iErrorCode
[ FD_WRITE_BIT
];
866 ok ( err
== 0, "event_client (%x): FD_WRITE error code: %d\n", id
, err
);
871 n
= send ( mem
->s
, send_p
, min ( send_last
- send_p
, par
->buflen
), 0 );
874 err
= WSAGetLastError ();
875 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): send error: %d\n", id
, err
);
880 while ( n
>= 0 && send_p
< send_last
);
882 if ( send_p
== send_last
)
884 shutdown ( mem
->s
, SD_SEND
);
886 WSAEventSelect ( mem
->s
, event
, mask
);
889 if ( wsa_events
.lNetworkEvents
& FD_READ
)
891 err
= wsa_events
.iErrorCode
[ FD_READ_BIT
];
892 ok ( err
== 0, "event_client (%x): FD_READ error code: %d\n", id
, err
);
893 if ( err
!= 0 ) break;
895 /* First read must succeed */
896 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
897 wsa_ok ( n
, 0 <=, "event_client (%x): recv error: %d\n" );
901 if ( recv_p
== recv_last
)
904 WSAEventSelect ( mem
->s
, event
, mask
);
907 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
908 ok(n
>= 0 || WSAGetLastError() == WSAEWOULDBLOCK
,
909 "event_client (%x): got error %u\n", id
, WSAGetLastError());
913 if ( wsa_events
.lNetworkEvents
& FD_CLOSE
)
915 err
= wsa_events
.iErrorCode
[ FD_CLOSE_BIT
];
916 ok ( err
== 0, "event_client (%x): FD_CLOSE error code: %d\n", id
, err
);
921 n
= send_p
- mem
->send_buf
;
922 ok ( send_p
== send_last
,
923 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n
, n_expected
);
924 n
= recv_p
- mem
->recv_buf
;
925 ok ( recv_p
== recv_last
,
926 "simple_client (%x): received less data than expected: %d of %d\n", id
, n
, n_expected
);
927 n
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
928 ok ( n
== -1, "event_client (%x): test pattern error: %d\n", id
, n
);
931 WSACloseEvent ( event
);
935 /* Tests for WSAStartup */
936 static void test_WithoutWSAStartup(void)
940 WSASetLastError(0xdeadbeef);
941 ok(WSASocketA(0, 0, 0, NULL
, 0, 0) == INVALID_SOCKET
, "WSASocketA should have failed\n");
942 err
= WSAGetLastError();
943 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %d\n", err
);
945 WSASetLastError(0xdeadbeef);
946 ok(gethostbyname("localhost") == NULL
, "gethostbyname() succeeded unexpectedly\n");
947 err
= WSAGetLastError();
948 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %d\n", err
);
951 static void test_WithWSAStartup(void)
954 WORD version
= MAKEWORD( 2, 2 );
955 INT res
, socks
, i
, j
;
960 SOCKET src
, dst
, dup_src
, dup_dst
;
964 res
= WSAStartup( version
, &data
);
965 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
967 ptr
= gethostbyname("localhost");
968 ok(ptr
!= NULL
, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
970 /* Alloc some sockets to check if they are destroyed on WSACleanup */
971 for (socks
= 0; socks
< ARRAY_SIZE(pairs
); socks
++)
973 WSAPROTOCOL_INFOA info
;
974 tcp_socketpair(&pairs
[socks
].src
, &pairs
[socks
].dst
);
976 memset(&info
, 0, sizeof(info
));
977 ok(!WSADuplicateSocketA(pairs
[socks
].src
, GetCurrentProcessId(), &info
),
978 "WSADuplicateSocketA should have worked\n");
979 pairs
[socks
].dup_src
= WSASocketA(0, 0, 0, &info
, 0, 0);
980 ok(pairs
[socks
].dup_src
!= SOCKET_ERROR
, "expected != -1\n");
982 memset(&info
, 0, sizeof(info
));
983 ok(!WSADuplicateSocketA(pairs
[socks
].dst
, GetCurrentProcessId(), &info
),
984 "WSADuplicateSocketA should have worked\n");
985 pairs
[socks
].dup_dst
= WSASocketA(0, 0, 0, &info
, 0, 0);
986 ok(pairs
[socks
].dup_dst
!= SOCKET_ERROR
, "expected != -1\n");
989 res
= send(pairs
[0].src
, "TEST", 4, 0);
990 ok(res
== 4, "send failed with error %d\n", WSAGetLastError());
994 res
= WSAStartup( version
, &data
);
995 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
997 /* show that sockets are destroyed automatically after WSACleanup */
998 SetLastError(0xdeadbeef);
999 res
= send(pairs
[0].src
, "TEST", 4, 0);
1000 error
= WSAGetLastError();
1001 ok(res
== SOCKET_ERROR
, "send should have failed\n");
1002 ok(error
== WSAENOTSOCK
, "expected 10038, got %d\n", error
);
1004 SetLastError(0xdeadbeef);
1005 res
= send(pairs
[0].dst
, "TEST", 4, 0);
1006 error
= WSAGetLastError();
1007 ok(res
== SOCKET_ERROR
, "send should have failed\n");
1008 ok(error
== WSAENOTSOCK
, "expected 10038, got %d\n", error
);
1010 /* Check that all sockets were destroyed */
1011 for (i
= 0; i
< socks
; i
++)
1013 for (j
= 0; j
< 4; j
++)
1015 struct sockaddr_in saddr
;
1016 int size
= sizeof(saddr
);
1019 case 0: sock
= pairs
[i
].src
; break;
1020 case 1: sock
= pairs
[i
].dup_src
; break;
1021 case 2: sock
= pairs
[i
].dst
; break;
1022 case 3: sock
= pairs
[i
].dup_dst
; break;
1025 SetLastError(0xdeadbeef);
1026 res
= getsockname(sock
, (struct sockaddr
*)&saddr
, &size
);
1027 error
= WSAGetLastError();
1028 ok(res
== SOCKET_ERROR
, "Test[%d]: getsockname should have failed\n", i
);
1029 if (res
== SOCKET_ERROR
)
1030 ok(error
== WSAENOTSOCK
, "Test[%d]: expected 10038, got %d\n", i
, error
);
1034 /* While wine is not fixed, close all sockets manually */
1035 for (i
= 0; i
< socks
; i
++)
1037 closesocket(pairs
[i
].src
);
1038 closesocket(pairs
[i
].dst
);
1039 closesocket(pairs
[i
].dup_src
);
1040 closesocket(pairs
[i
].dup_dst
);
1044 ok(res
== 0, "expected 0, got %d\n", res
);
1045 WSASetLastError(0xdeadbeef);
1047 error
= WSAGetLastError();
1048 ok ( res
== SOCKET_ERROR
&& error
== WSANOTINITIALISED
,
1049 "WSACleanup returned %d WSAGetLastError is %d\n", res
, error
);
1052 /**************** Main program utility functions ***************/
1054 static void Init (void)
1056 WORD ver
= MAKEWORD (2, 2);
1058 HMODULE hws2_32
= GetModuleHandleA("ws2_32.dll"), ntdll
;
1060 pWSAPoll
= (void *)GetProcAddress(hws2_32
, "WSAPoll");
1062 ntdll
= LoadLibraryA("ntdll.dll");
1064 pNtClose
= (void *)GetProcAddress(ntdll
, "NtClose");
1066 ok ( WSAStartup ( ver
, &data
) == 0, "WSAStartup failed\n" );
1070 static void Exit (void)
1075 err
= WSAGetLastError();
1076 ok ( ret
== 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret
, err
);
1079 static void StartServer (LPTHREAD_START_ROUTINE routine
,
1080 test_params
*general
, server_params
*par
)
1082 par
->general
= general
;
1083 thread
[0] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[0] );
1084 ok ( thread
[0] != NULL
, "Failed to create server thread\n" );
1087 static void StartClients (LPTHREAD_START_ROUTINE routine
,
1088 test_params
*general
, client_params
*par
)
1091 par
->general
= general
;
1092 for ( i
= 1; i
<= min ( general
->n_clients
, MAX_CLIENTS
); i
++ )
1095 thread
[i
] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[i
] );
1096 ok ( thread
[i
] != NULL
, "Failed to create client thread\n" );
1097 /* Make sure the client is up and running */
1098 WaitForSingleObject ( client_ready
[client_id
], INFINITE
);
1102 static void do_test( test_setup
*test
)
1104 DWORD i
, n
= min (test
->general
.n_clients
, MAX_CLIENTS
);
1107 server_ready
= CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1108 for (i
= 0; i
<= n
; i
++)
1109 client_ready
[i
] = CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1111 StartServer ( test
->srv
, &test
->general
, &test
->srv_params
);
1112 StartClients ( test
->clt
, &test
->general
, &test
->clt_params
);
1113 WaitForSingleObject ( server_ready
, INFINITE
);
1115 wait
= WaitForMultipleObjects ( 1 + n
, thread
, TRUE
, 1000 * TEST_TIMEOUT
);
1116 ok(!wait
, "wait failed, error %u\n", wait
);
1118 CloseHandle ( server_ready
);
1119 for (i
= 0; i
<= n
; i
++)
1120 CloseHandle ( client_ready
[i
] );
1123 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1124 /* optname = SO_LINGER */
1125 static const LINGER linger_testvals
[] = {
1132 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1133 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1134 bug in the linux kernel (fixed in 2.6.8) */
1135 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1137 static void test_set_getsockopt(void)
1140 int i
, err
, lasterr
;
1144 WSAPROTOCOL_INFOA infoA
;
1145 WSAPROTOCOL_INFOW infoW
;
1146 char providername
[WSAPROTOCOL_LEN
+ 1];
1150 int family
, type
, proto
;
1152 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
1153 {AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
1154 {AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
},
1155 {AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
}
1163 s
= socket(AF_INET
, SOCK_STREAM
, 0);
1164 ok(s
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1165 if( s
== INVALID_SOCKET
) return;
1167 timeout
= SOCKTIMEOUT1
;
1168 size
= sizeof(timeout
);
1169 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1171 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1172 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1173 ok( timeout
== SOCKTIMEOUT1
, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1176 size
= sizeof(timeout
);
1177 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1179 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1180 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1181 ok( timeout
== 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1184 timeout
= SOCKTIMEOUT2
; /* 997 seconds. See remark above */
1185 size
= sizeof(timeout
);
1186 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, size
);
1188 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, &size
);
1189 ok( !err
, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1190 ok( timeout
== SOCKTIMEOUT2
, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout
);
1194 size
= sizeof(value
);
1195 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDBUF
, (char *)&value
, size
);
1196 ok( !err
, "setsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1198 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDBUF
, (char *)&value
, &size
);
1199 ok( !err
, "getsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1200 todo_wine
ok( value
== 4096, "expected 4096, got %u\n", value
);
1204 size
= sizeof(value
);
1205 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, size
);
1206 ok( !err
, "setsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1208 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, &size
);
1209 ok( !err
, "getsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1210 todo_wine
ok( value
== 4096, "expected 4096, got %u\n", value
);
1213 for( i
= 0; i
< ARRAY_SIZE(linger_testvals
);i
++) {
1214 size
= sizeof(lingval
);
1215 lingval
= linger_testvals
[i
];
1216 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *)&lingval
, size
);
1217 ok(!err
, "Test %u: failed to set SO_LINGER, error %u\n", i
, WSAGetLastError());
1218 err
= getsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *)&lingval
, &size
);
1219 ok(!err
, "Test %u: failed to get SO_LINGER, error %u\n", i
, WSAGetLastError());
1220 ok(!lingval
.l_onoff
== !linger_testvals
[i
].l_onoff
, "Test %u: expected %d, got %d\n",
1221 i
, linger_testvals
[i
].l_onoff
, lingval
.l_onoff
);
1222 if (lingval
.l_onoff
)
1223 ok(lingval
.l_linger
== linger_testvals
[i
].l_linger
, "Test %u: expected %d, got %d\n",
1224 i
, linger_testvals
[i
].l_linger
, lingval
.l_linger
);
1227 size
= sizeof(lingval
);
1228 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, size
);
1229 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1230 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1231 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, 0);
1232 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1233 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1235 size
= sizeof(BOOL
);
1236 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, size
);
1237 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1238 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1239 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, 0);
1240 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1241 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1243 /* Test for erroneously passing a value instead of a pointer as optval */
1244 size
= sizeof(char);
1245 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTROUTE
, (char *)1, size
);
1246 ok(err
== SOCKET_ERROR
, "setsockopt with optval being a value passed "
1247 "instead of failing.\n");
1248 lasterr
= WSAGetLastError();
1249 ok(lasterr
== WSAEFAULT
, "setsockopt with optval being a value "
1250 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1251 lasterr
, WSAEFAULT
);
1253 /* SO_RCVTIMEO with invalid values for level */
1254 size
= sizeof(timeout
);
1255 timeout
= SOCKTIMEOUT1
;
1256 SetLastError(0xdeadbeef);
1257 err
= setsockopt(s
, 0xffffffff, SO_RCVTIMEO
, (char *) &timeout
, size
);
1258 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1259 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1260 err
, WSAGetLastError());
1262 timeout
= SOCKTIMEOUT1
;
1263 SetLastError(0xdeadbeef);
1264 err
= setsockopt(s
, 0x00008000, SO_RCVTIMEO
, (char *) &timeout
, size
);
1265 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1266 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1267 err
, WSAGetLastError());
1269 /* Test SO_ERROR set/get */
1270 SetLastError(0xdeadbeef);
1272 err
= setsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, size
);
1274 ok( !err
&& !WSAGetLastError(),
1275 "got %d with %d (expected 0 with 0)\n",
1276 err
, WSAGetLastError());
1278 SetLastError(0xdeadbeef);
1280 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1282 ok( !err
&& !WSAGetLastError(),
1283 "got %d with %d (expected 0 with 0)\n",
1284 err
, WSAGetLastError());
1286 ok (i
== 1234, "got %d (expected 1234)\n", i
);
1288 /* Test invalid optlen */
1289 SetLastError(0xdeadbeef);
1291 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1293 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEFAULT
),
1294 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1295 err
, WSAGetLastError());
1298 /* Test with the closed socket */
1299 SetLastError(0xdeadbeef);
1302 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1303 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAENOTSOCK
),
1304 "got %d with %d (expected SOCKET_ERROR with WSAENOTSOCK)\n",
1305 err
, WSAGetLastError());
1306 ok (i
== 1234, "expected 1234, got %d\n", i
);
1308 /* Test WS_IP_MULTICAST_TTL with 8, 16, 24 and 32 bits values */
1309 s
= socket(AF_INET
, SOCK_DGRAM
, 0);
1310 ok(s
!= INVALID_SOCKET
, "Failed to create socket\n");
1313 err
= setsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &i
, size
);
1316 for (i
= 0; i
< 4; i
++)
1319 const int tests
[] = {0xffffff0a, 0xffff000b, 0xff00000c, 0x0000000d};
1320 err
= setsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &tests
[i
], i
+ 1);
1321 ok(!err
, "Test [%d] Expected 0, got %d\n", i
, err
);
1322 err
= getsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &k
, &size
);
1323 ok(!err
, "Test [%d] Expected 0, got %d\n", i
, err
);
1324 j
= i
!= 3 ? tests
[i
] & ((1 << (i
+ 1) * 8) - 1) : tests
[i
];
1325 ok(k
== j
, "Test [%d] Expected 0x%x, got 0x%x\n", i
, j
, k
);
1329 win_skip("IP_MULTICAST_TTL is unsupported\n");
1332 /* test SO_PROTOCOL_INFOA invalid parameters */
1333 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1334 "getsockopt should have failed\n");
1335 err
= WSAGetLastError();
1336 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1337 size
= sizeof(WSAPROTOCOL_INFOA
);
1338 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1339 "getsockopt should have failed\n");
1340 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1341 err
= WSAGetLastError();
1342 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1343 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1344 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1345 "getsockopt should have failed\n");
1346 err
= WSAGetLastError();
1347 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1348 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, NULL
),
1349 "getsockopt should have failed\n");
1350 err
= WSAGetLastError();
1351 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1352 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, &size
),
1353 "getsockopt should have failed\n");
1354 err
= WSAGetLastError();
1355 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1356 size
= sizeof(WSAPROTOCOL_INFOA
) / 2;
1357 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1358 "getsockopt should have failed\n");
1359 err
= WSAGetLastError();
1360 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1361 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1362 size
= sizeof(WSAPROTOCOL_INFOA
) * 2;
1363 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1364 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1365 ok(size
== sizeof(WSAPROTOCOL_INFOA
) * 2, "got size %d\n", size
);
1369 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1370 for (i
= 0; i
< ARRAY_SIZE(prottest
); i
++)
1374 s
= socket(prottest
[i
].family
, prottest
[i
].type
, prottest
[i
].proto
);
1375 if (s
== INVALID_SOCKET
&& prottest
[i
].family
== AF_INET6
) continue;
1377 ok(s
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
1380 /* compare both A and W version */
1381 infoA
.szProtocol
[0] = 0;
1382 size
= sizeof(WSAPROTOCOL_INFOA
);
1383 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1384 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1385 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1387 infoW
.szProtocol
[0] = 0;
1388 size
= sizeof(WSAPROTOCOL_INFOW
);
1389 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOW
, (char *) &infoW
, &size
);
1390 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1391 ok(size
== sizeof(WSAPROTOCOL_INFOW
), "got size %d\n", size
);
1393 ok(infoA
.szProtocol
[0], "WSAPROTOCOL_INFOA was not filled\n");
1394 ok(infoW
.szProtocol
[0], "WSAPROTOCOL_INFOW was not filled\n");
1396 WideCharToMultiByte(CP_ACP
, 0, infoW
.szProtocol
, -1,
1397 providername
, sizeof(providername
), NULL
, NULL
);
1398 ok(!strcmp(infoA
.szProtocol
,providername
),
1399 "different provider names '%s' != '%s'\n", infoA
.szProtocol
, providername
);
1401 ok(!memcmp(&infoA
, &infoW
, FIELD_OFFSET(WSAPROTOCOL_INFOA
, szProtocol
)),
1402 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1404 /* Remove IF when WSAEnumProtocols support IPV6 data */
1405 ok(infoA
.iAddressFamily
== prottest
[i
].family
, "socket family invalid, expected %d received %d\n",
1406 prottest
[i
].family
, infoA
.iAddressFamily
);
1407 ok(infoA
.iSocketType
== prottest
[i
].type
, "socket type invalid, expected %d received %d\n",
1408 prottest
[i
].type
, infoA
.iSocketType
);
1409 ok(infoA
.iProtocol
== prottest
[i
].proto
, "socket protocol invalid, expected %d received %d\n",
1410 prottest
[i
].proto
, infoA
.iProtocol
);
1412 /* IP_HDRINCL is supported only on SOCK_RAW but passed to SOCK_DGRAM by Impossible Creatures */
1415 SetLastError(0xdeadbeef);
1416 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1417 if (err
== -1) /* >= Vista */
1420 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1422 SetLastError(0xdeadbeef);
1423 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1424 ok(err
== -1, "Expected -1, got %d\n", err
);
1425 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1426 ok(k
== 99, "Expected 99, got %d\n", k
);
1430 SetLastError(0xdeadbeef);
1431 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1433 ok(err
== -1, "Expected -1, got %d\n", err
);
1435 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1437 SetLastError(0xdeadbeef);
1438 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1439 ok(err
== -1, "Expected -1, got %d\n", err
);
1440 ok(GetLastError() == WSAEINVAL
, "Expected 10022, got %d\n", GetLastError());
1441 ok(k
== 99, "Expected 99, got %d\n", k
);
1444 else /* <= 2003 the tests differ between TCP and UDP, UDP silently accepts */
1446 SetLastError(0xdeadbeef);
1448 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1449 if (prottest
[i
].type
== SOCK_DGRAM
)
1451 ok(err
== 0, "Expected 0, got %d\n", err
);
1452 ok(k
== 1, "Expected 1, got %d\n", k
);
1456 /* contratry to what we could expect the function returns error but k is changed */
1457 ok(err
== -1, "Expected -1, got %d\n", err
);
1458 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %d\n", GetLastError());
1459 ok(k
== 0, "Expected 0, got %d\n", k
);
1463 err
= setsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, size
);
1464 ok(err
== 0, "Expected 0, got %d\n", err
);
1467 err
= getsockopt(s
, IPPROTO_IP
, IP_HDRINCL
, (char *) &k
, &size
);
1468 if (prottest
[i
].type
== SOCK_DGRAM
)
1470 ok(err
== 0, "Expected 0, got %d\n", err
);
1471 ok(k
== 0, "Expected 0, got %d\n", k
);
1475 /* contratry to what we could expect the function returns error but k is changed */
1476 ok(err
== -1, "Expected -1, got %d\n", err
);
1477 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %d\n", GetLastError());
1478 ok(k
== 0, "Expected 0, got %d\n", k
);
1485 /* Test SO_BSP_STATE - Present only in >= Win 2008 */
1486 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1487 ok(s
!= INVALID_SOCKET
, "Failed to create socket\n");
1488 s2
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1489 ok(s2
!= INVALID_SOCKET
, "Failed to create socket\n");
1491 SetLastError(0xdeadbeef);
1492 size
= sizeof(csinfoA
);
1493 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1496 struct sockaddr_in saddr
;
1497 memset(&saddr
, 0, sizeof(saddr
));
1498 saddr
.sin_family
= AF_INET
;
1499 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1501 /* Socket is not bound, no information provided */
1502 ok(!csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1503 ok(csinfoA
.cs
.LocalAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.LocalAddr
.lpSockaddr
);
1504 /* Socket is not connected, no information provided */
1505 ok(!csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.RemoteAddr
.iSockaddrLength
);
1506 ok(csinfoA
.cs
.RemoteAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.RemoteAddr
.lpSockaddr
);
1508 err
= bind(s
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1509 ok(!err
, "Expected 0, got %d\n", err
);
1510 size
= sizeof(csinfoA
);
1511 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1512 ok(!err
, "Expected 0, got %d\n", err
);
1514 /* Socket is bound */
1515 ok(csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected non-zero\n");
1516 ok(csinfoA
.cs
.LocalAddr
.lpSockaddr
!= NULL
, "Expected non-null\n");
1517 /* Socket is not connected, no information provided */
1518 ok(!csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.RemoteAddr
.iSockaddrLength
);
1519 ok(csinfoA
.cs
.RemoteAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.RemoteAddr
.lpSockaddr
);
1521 err
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1522 ok(!err
, "Expected 0, got %d\n", err
);
1523 err
= getsockname(s2
, (struct sockaddr
*)&saddr
, &size
);
1524 ok(!err
, "Expected 0, got %d\n", err
);
1525 err
= listen(s2
, 1);
1526 ok(!err
, "Expected 0, got %d\n", err
);
1527 err
= connect(s
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1528 ok(!err
, "Expected 0, got %d\n", err
);
1529 size
= sizeof(saddr
);
1530 err
= accept(s2
, (struct sockaddr
*)&saddr
, &size
);
1531 ok(err
!= INVALID_SOCKET
, "Failed to accept socket\n");
1535 size
= sizeof(csinfoA
);
1536 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1537 ok(!err
, "Expected 0, got %d\n", err
);
1538 err
= getsockopt(s2
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoB
, &size
);
1539 ok(!err
, "Expected 0, got %d\n", err
);
1540 ok(size
== sizeof(csinfoA
), "Got %d\n", size
);
1541 size
= sizeof(saddr
);
1542 ok(size
== csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected %d, got %d\n", size
,
1543 csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1544 ok(size
== csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected %d, got %d\n", size
,
1545 csinfoA
.cs
.RemoteAddr
.iSockaddrLength
);
1546 ok(!memcmp(csinfoA
.cs
.LocalAddr
.lpSockaddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
),
1547 "Expected matching addresses\n");
1548 ok(!memcmp(csinfoB
.cs
.LocalAddr
.lpSockaddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
),
1549 "Expected matching addresses\n");
1550 ok(csinfoA
.cs
.iSocketType
== SOCK_STREAM
, "Wrong socket type\n");
1551 ok(csinfoB
.cs
.iSocketType
== SOCK_STREAM
, "Wrong socket type\n");
1552 ok(csinfoA
.cs
.iProtocol
== IPPROTO_TCP
, "Wrong socket protocol\n");
1553 ok(csinfoB
.cs
.iProtocol
== IPPROTO_TCP
, "Wrong socket protocol\n");
1555 err
= getpeername(s
, (struct sockaddr
*)&saddr
, &size
);
1556 ok(!err
, "Expected 0, got %d\n", err
);
1557 ok(!memcmp(&saddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1558 ok(!memcmp(&saddr
, csinfoB
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1559 err
= getpeername(s2
, (struct sockaddr
*)&saddr
, &size
);
1560 ok(!err
, "Expected 0, got %d\n", err
);
1561 ok(!memcmp(&saddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1562 ok(!memcmp(&saddr
, csinfoA
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1563 err
= getsockname(s
, (struct sockaddr
*)&saddr
, &size
);
1564 ok(!err
, "Expected 0, got %d\n", err
);
1565 ok(!memcmp(&saddr
, csinfoA
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1566 ok(!memcmp(&saddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1567 err
= getsockname(s2
, (struct sockaddr
*)&saddr
, &size
);
1568 ok(!err
, "Expected 0, got %d\n", err
);
1569 ok(!memcmp(&saddr
, csinfoB
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1570 ok(!memcmp(&saddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1572 SetLastError(0xdeadbeef);
1573 size
= sizeof(CSADDR_INFO
);
1574 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1575 ok(err
, "Expected non-zero\n");
1576 ok(size
== sizeof(CSADDR_INFO
), "Got %d\n", size
);
1577 ok(GetLastError() == WSAEFAULT
, "Expected 10014, got %d\n", GetLastError());
1579 /* At least for IPv4 the size is exactly 56 bytes */
1580 size
= sizeof(*csinfoA
.cs
.LocalAddr
.lpSockaddr
) * 2 + sizeof(csinfoA
.cs
);
1581 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1582 ok(!err
, "Expected 0, got %d\n", err
);
1584 SetLastError(0xdeadbeef);
1585 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1586 ok(err
, "Expected non-zero\n");
1587 ok(GetLastError() == WSAEFAULT
, "Expected 10014, got %d\n", GetLastError());
1590 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %d\n", GetLastError());
1595 for (i
= 0; i
< 2; i
++)
1602 level
= IPPROTO_IPV6
;
1610 s
= socket(family
, SOCK_DGRAM
, 0);
1611 if (s
== INVALID_SOCKET
&& i
)
1613 skip("IPv6 is not supported\n");
1616 ok(s
!= INVALID_SOCKET
, "socket failed with error %d\n", GetLastError());
1618 size
= sizeof(value
);
1620 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1621 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1622 ok(value
== 0, "Expected 0, got %d\n", value
);
1624 size
= sizeof(value
);
1626 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
1627 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1630 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1631 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1632 ok(value
== 1, "Expected 1, got %d\n", value
);
1634 size
= sizeof(value
);
1636 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
1637 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1639 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1640 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1641 ok(value
== 1, "Expected 1, got %d\n", value
);
1645 s
= socket(family
, SOCK_STREAM
, 0);
1646 ok(s
!= INVALID_SOCKET
, "socket failed with error %d\n", GetLastError());
1648 size
= sizeof(value
);
1650 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1651 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1652 ok(value
== 1 || broken(value
== 0) /* < vista */, "Expected 1, got %d\n", value
);
1654 size
= sizeof(value
);
1656 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
1657 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1660 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1661 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1662 ok(value
== 0, "Expected 0, got %d\n", value
);
1666 s
= socket(family
, SOCK_RAW
, 0);
1667 if (s
== INVALID_SOCKET
)
1669 if (WSAGetLastError() == WSAEACCES
) skip("SOCK_RAW is not available\n");
1670 else if (i
) skip("IPv6 is not supported\n");
1673 ok(s
!= INVALID_SOCKET
, "socket failed with error %d\n", GetLastError());
1675 size
= sizeof(value
);
1677 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1678 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1679 ok(value
== 0, "Expected 0, got %d\n", value
);
1681 size
= sizeof(value
);
1683 err
= setsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, size
);
1684 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1687 err
= getsockopt(s
, level
, IP_DONTFRAGMENT
, (char *) &value
, &size
);
1688 ok(!err
, "Expected 0, got %d with error %d\n", err
, GetLastError());
1689 ok(value
== 1, "Expected 1, got %d\n", value
);
1695 static void test_so_reuseaddr(void)
1697 struct sockaddr_in saddr
;
1699 unsigned int rc
,reuse
;
1703 saddr
.sin_family
= AF_INET
;
1704 saddr
.sin_port
= htons(SERVERPORT
+1);
1705 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1707 s1
=socket(AF_INET
, SOCK_STREAM
, 0);
1708 ok(s1
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1709 rc
= bind(s1
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1710 ok(rc
!=SOCKET_ERROR
, "bind(s1) failed error: %d\n", WSAGetLastError());
1712 s2
=socket(AF_INET
, SOCK_STREAM
, 0);
1713 ok(s2
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1717 rc
=getsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, &size
);
1718 ok(rc
==0 && reuse
==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc
,reuse
);
1720 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1721 ok(rc
==SOCKET_ERROR
, "bind() succeeded\n");
1724 rc
= setsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
1725 ok(rc
==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1727 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1728 * a port immediately after closing another socket on that port, so
1729 * basically following the BSD socket semantics here. */
1730 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1733 int s3
=socket(AF_INET
, SOCK_STREAM
, 0), s4
;
1735 /* If we could bind again in the same port this is Windows version <= XP.
1736 * Lets test if we can really connect to one of them. */
1737 set_blocking(s1
, FALSE
);
1738 set_blocking(s2
, FALSE
);
1740 ok(!rc
, "listen() failed with error: %d\n", WSAGetLastError());
1742 ok(!rc
, "listen() failed with error: %d\n", WSAGetLastError());
1743 rc
= connect(s3
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1744 ok(!rc
, "connecting to accepting socket failed %d\n", WSAGetLastError());
1746 /* the delivery of the connection is random so we need to try on both sockets */
1747 size
= sizeof(saddr
);
1748 s4
= accept(s1
, (struct sockaddr
*)&saddr
, &size
);
1749 if(s4
== INVALID_SOCKET
)
1750 s4
= accept(s2
, (struct sockaddr
*)&saddr
, &size
);
1751 ok(s4
!= INVALID_SOCKET
, "none of the listening sockets could get the connection\n");
1759 err
= WSAGetLastError();
1760 ok(err
==WSAEACCES
, "expected 10013, got %d\n", err
);
1763 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1764 ok(rc
==0, "bind() failed error: %d\n", WSAGetLastError());
1770 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
1772 static void test_ip_pktinfo(void)
1774 ULONG addresses
[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY
)};
1775 char recvbuf
[10], pktbuf
[512], msg
[] = "HELLO";
1776 struct sockaddr_in s1addr
, s2addr
, s3addr
;
1777 GUID WSARecvMsg_GUID
= WSAID_WSARECVMSG
;
1778 LPFN_WSARECVMSG pWSARecvMsg
= NULL
;
1779 unsigned int rc
, yes
= 1;
1781 DWORD dwBytes
, dwSize
, dwFlags
;
1790 memset(&ov
, 0, sizeof(ov
));
1791 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
1793 memset(&hdr
, 0x00, sizeof(hdr
));
1794 s1addr
.sin_family
= AF_INET
;
1795 s1addr
.sin_port
= htons(0);
1796 /* Note: s1addr.sin_addr is set below */
1797 iovec
[0].buf
= recvbuf
;
1798 iovec
[0].len
= sizeof(recvbuf
);
1799 hdr
.name
= (struct sockaddr
*)&s3addr
;
1800 hdr
.namelen
= sizeof(s3addr
);
1801 hdr
.lpBuffers
= &iovec
[0];
1802 hdr
.dwBufferCount
= 1;
1803 hdr
.Control
.buf
= pktbuf
;
1804 /* Note: hdr.Control.len is set below */
1807 for (i
=0;i
<ARRAY_SIZE(addresses
);i
++)
1809 s1addr
.sin_addr
.s_addr
= addresses
[i
];
1811 /* Build "server" side socket */
1812 s1
=socket(AF_INET
, SOCK_DGRAM
, 0);
1813 ok(s1
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
1815 /* Obtain the WSARecvMsg function */
1816 rc
= WSAIoctl(s1
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSARecvMsg_GUID
, sizeof(WSARecvMsg_GUID
),
1817 &pWSARecvMsg
, sizeof(pWSARecvMsg
), &dwBytes
, NULL
, NULL
);
1818 ok(!rc
, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
1820 /* Setup the server side socket */
1821 rc
=bind(s1
, (struct sockaddr
*)&s1addr
, sizeof(s1addr
));
1822 ok(rc
!= SOCKET_ERROR
, "bind() failed error: %d\n", WSAGetLastError());
1824 /* Build "client" side socket */
1825 addrlen
= sizeof(s2addr
);
1826 rc
= getsockname(s1
, (struct sockaddr
*) &s2addr
, &addrlen
);
1827 ok(!rc
, "failed to get address, error %u\n", WSAGetLastError());
1828 s2addr
.sin_addr
.s_addr
= addresses
[0]; /* Always target the local adapter address */
1829 s2
=socket(AF_INET
, SOCK_DGRAM
, 0);
1830 ok(s2
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
1832 /* Test an empty message header */
1833 rc
=pWSARecvMsg(s1
, NULL
, NULL
, NULL
, NULL
);
1834 err
=WSAGetLastError();
1835 ok(rc
== SOCKET_ERROR
&& err
== WSAEFAULT
, "WSARecvMsg() failed error: %d (ret = %d)\n", err
, rc
);
1837 /* Test that when no control data arrives, a 0-length NULL-valued control buffer should succeed */
1838 SetLastError(0xdeadbeef);
1839 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1840 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1841 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
1842 hdr
.Control
.buf
= NULL
;
1843 hdr
.Control
.len
= 0;
1844 rc
=pWSARecvMsg(s1
, &hdr
, &dwSize
, NULL
, NULL
);
1845 ok(rc
== 0, "WSARecvMsg() failed error: %d\n", WSAGetLastError());
1846 hdr
.Control
.buf
= pktbuf
;
1848 /* Now start IP_PKTINFO for future tests */
1849 rc
=setsockopt(s1
, IPPROTO_IP
, IP_PKTINFO
, (const char*)&yes
, sizeof(yes
));
1850 ok(rc
== 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
1853 * Send a packet from the client to the server and test for specifying
1854 * a short control header.
1856 SetLastError(0xdeadbeef);
1857 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1858 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1859 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
1860 hdr
.Control
.len
= 1;
1861 rc
=pWSARecvMsg(s1
, &hdr
, &dwSize
, NULL
, NULL
);
1862 err
=WSAGetLastError();
1863 ok(rc
== SOCKET_ERROR
&& err
== WSAEMSGSIZE
&& (hdr
.dwFlags
& MSG_CTRUNC
),
1864 "WSARecvMsg() failed error: %d (ret: %d, flags: %d)\n", err
, rc
, hdr
.dwFlags
);
1865 hdr
.dwFlags
= 0; /* Reset flags */
1867 /* Perform another short control header test, this time with an overlapped receive */
1868 hdr
.Control
.len
= 1;
1869 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
1870 err
=WSAGetLastError();
1871 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
1872 SetLastError(0xdeadbeef);
1873 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1874 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1875 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
1876 ok(!WaitForSingleObject(ov
.hEvent
, 100), "wait failed\n");
1878 WSAGetOverlappedResult(s1
, &ov
, NULL
, FALSE
, &dwFlags
);
1880 "WSAGetOverlappedResult() returned unexpected flags %d!\n", dwFlags
);
1881 ok(hdr
.dwFlags
== MSG_CTRUNC
,
1882 "WSARecvMsg() overlapped operation set unexpected flags %d.\n", hdr
.dwFlags
);
1883 hdr
.dwFlags
= 0; /* Reset flags */
1886 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
1887 * on the server end and check that the returned packet matches what was sent.
1889 hdr
.Control
.len
= sizeof(pktbuf
);
1890 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
1891 err
=WSAGetLastError();
1892 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
1893 ok(hdr
.Control
.len
== sizeof(pktbuf
),
1894 "WSARecvMsg() control length mismatch (%d != sizeof pktbuf).\n", hdr
.Control
.len
);
1895 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1896 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1897 ok(!WaitForSingleObject(ov
.hEvent
, 100), "wait failed\n");
1899 WSAGetOverlappedResult(s1
, &ov
, &dwSize
, FALSE
, NULL
);
1900 ok(dwSize
== sizeof(msg
),
1901 "WSARecvMsg() buffer length does not match transmitted data!\n");
1902 ok(strncmp(iovec
[0].buf
, msg
, sizeof(msg
)) == 0,
1903 "WSARecvMsg() buffer does not match transmitted data!\n");
1904 ok(hdr
.Control
.len
== IP_PKTINFO_LEN
,
1905 "WSARecvMsg() control length mismatch (%d).\n", hdr
.Control
.len
);
1907 /* Test for the expected IP_PKTINFO return information. */
1909 for (cmsg
= WSA_CMSG_FIRSTHDR(&hdr
); cmsg
!= NULL
; cmsg
= WSA_CMSG_NXTHDR(&hdr
, cmsg
))
1911 if (cmsg
->cmsg_level
== IPPROTO_IP
&& cmsg
->cmsg_type
== IP_PKTINFO
)
1913 struct in_pktinfo
*pi
= (struct in_pktinfo
*)WSA_CMSG_DATA(cmsg
);
1915 ok(pi
->ipi_addr
.s_addr
== s2addr
.sin_addr
.s_addr
, "destination ip mismatch!\n");
1919 ok(foundhdr
, "IP_PKTINFO header information was not returned!\n");
1925 CloseHandle(ov
.hEvent
);
1928 /************* Array containing the tests to run **********/
1930 #define STD_STREAM_SOCKET \
1936 static test_setup tests
[] =
1938 /* Test 0: synchronous client and server */
1959 /* Test 1: event-driven client, synchronous server */
1976 WSA_FLAG_OVERLAPPED
,
1980 /* Test 2: synchronous client, non-blocking server via select() */
2001 /* Test 3: OOB client, OOB server */
2022 /* Test 4: synchronous mixed client and server */
2036 simple_mixed_client
,
2045 static void test_UDP(void)
2047 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
2048 possible that this test fails due to dropped packets. */
2050 /* peer 0 receives data from all other peers */
2051 struct sock_info peer
[NUM_UDP_PEERS
];
2053 int ss
, i
, n_recv
, n_sent
;
2055 memset (buf
,0,sizeof(buf
));
2056 for ( i
= NUM_UDP_PEERS
- 1; i
>= 0; i
-- ) {
2057 ok ( ( peer
[i
].s
= socket ( AF_INET
, SOCK_DGRAM
, 0 ) ) != INVALID_SOCKET
, "UDP: socket failed\n" );
2059 peer
[i
].addr
.sin_family
= AF_INET
;
2060 peer
[i
].addr
.sin_addr
.s_addr
= inet_addr ( SERVERIP
);
2063 peer
[i
].addr
.sin_port
= htons ( SERVERPORT
);
2065 peer
[i
].addr
.sin_port
= htons ( 0 );
2068 do_bind ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, sizeof( peer
[i
].addr
) );
2070 /* test getsockname() to get peer's port */
2071 ss
= sizeof ( peer
[i
].addr
);
2072 ok ( getsockname ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, &ss
) != SOCKET_ERROR
, "UDP: could not getsockname()\n" );
2073 ok ( peer
[i
].addr
.sin_port
!= htons ( 0 ), "UDP: bind() did not associate port\n" );
2076 /* test getsockname() */
2077 ok ( peer
[0].addr
.sin_port
== htons ( SERVERPORT
), "UDP: getsockname returned incorrect peer port\n" );
2079 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
2080 /* send client's ip */
2081 memcpy( buf
, &peer
[i
].addr
.sin_port
, sizeof(peer
[i
].addr
.sin_port
) );
2082 n_sent
= sendto ( peer
[i
].s
, buf
, sizeof(buf
), 0, (struct sockaddr
*) &peer
[0].addr
, sizeof(peer
[0].addr
) );
2083 ok ( n_sent
== sizeof(buf
), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent
);
2086 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
2087 n_recv
= recvfrom ( peer
[0].s
, buf
, sizeof(buf
), 0,(struct sockaddr
*) &peer
[0].peer
, &ss
);
2088 ok ( n_recv
== sizeof(buf
), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv
);
2089 ok ( memcmp ( &peer
[0].peer
.sin_port
, buf
, sizeof(peer
[0].addr
.sin_port
) ) == 0, "UDP: port numbers do not match\n" );
2093 static void test_WSASocket(void)
2095 SOCKET sock
= INVALID_SOCKET
;
2096 WSAPROTOCOL_INFOA
*pi
;
2097 int wsaproviders
[] = {IPPROTO_TCP
, IPPROTO_IP
};
2098 int autoprotocols
[] = {IPPROTO_TCP
, IPPROTO_UDP
};
2099 int items
, err
, size
, socktype
, i
, j
;
2104 int family
, type
, protocol
;
2106 int ret_family
, ret_type
, ret_protocol
;
2111 {0xdead, SOCK_STREAM
, IPPROTO_TCP
, WSAEAFNOSUPPORT
},
2112 {-1, SOCK_STREAM
, IPPROTO_TCP
, WSAEAFNOSUPPORT
},
2113 {AF_INET
, 0xdead, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
2114 {AF_INET
, -1, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
2115 {AF_INET
, SOCK_STREAM
, 0xdead, WSAEPROTONOSUPPORT
},
2116 {AF_INET
, SOCK_STREAM
, -1, WSAEPROTONOSUPPORT
},
2117 {0xdead, 0xdead, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
2118 {0xdead, SOCK_STREAM
, 0xdead, WSAEAFNOSUPPORT
},
2119 {AF_INET
, 0xdead, 0xdead, WSAESOCKTNOSUPPORT
},
2120 {0xdead, SOCK_STREAM
, IPPROTO_UDP
, WSAEAFNOSUPPORT
},
2123 {AF_INET
, SOCK_STREAM
, 0, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
2124 {AF_INET
, SOCK_DGRAM
, 0, 0, AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
2125 {AF_INET
, 0xdead, 0, WSAESOCKTNOSUPPORT
},
2126 {AF_INET
, 0, IPPROTO_TCP
, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
2127 {AF_INET
, 0, IPPROTO_UDP
, 0, AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
2128 {AF_INET
, 0, 0xdead, WSAEPROTONOSUPPORT
},
2129 {AF_INET
, 0, 0, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
2130 {AF_INET
, SOCK_STREAM
, IPPROTO_UDP
, WSAEPROTONOSUPPORT
},
2131 {AF_INET
, SOCK_DGRAM
, IPPROTO_TCP
, WSAEPROTONOSUPPORT
},
2134 {AF_UNSPEC
, SOCK_STREAM
, IPPROTO_TCP
, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
2135 {AF_UNSPEC
, SOCK_STREAM
, 0xdead, WSAEPROTONOSUPPORT
},
2136 {AF_UNSPEC
, 0xdead, IPPROTO_UDP
, WSAESOCKTNOSUPPORT
},
2137 {AF_UNSPEC
, SOCK_STREAM
, 0, WSAEINVAL
},
2138 {AF_UNSPEC
, SOCK_DGRAM
, 0, WSAEINVAL
},
2139 {AF_UNSPEC
, 0xdead, 0, WSAEINVAL
},
2140 {AF_UNSPEC
, 0, IPPROTO_TCP
, 0, AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
2141 {AF_UNSPEC
, 0, IPPROTO_UDP
, 0, AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
2142 {AF_UNSPEC
, 0, 0xdead, WSAEPROTONOSUPPORT
},
2143 {AF_UNSPEC
, 0, 0, WSAEINVAL
},
2146 for (i
= 0; i
< ARRAY_SIZE(tests
); ++i
)
2148 SetLastError( 0xdeadbeef );
2149 sock
= WSASocketA( tests
[i
].family
, tests
[i
].type
, tests
[i
].protocol
, NULL
, 0, 0 );
2150 todo_wine_if (!tests
[i
].error
|| i
== 7)
2151 ok(WSAGetLastError() == tests
[i
].error
, "Test %u: got wrong error %u\n", i
, WSAGetLastError());
2154 ok(sock
== INVALID_SOCKET
, "Test %u: expected failure\n", i
);
2158 WSAPROTOCOL_INFOA info
;
2160 ok(sock
!= INVALID_SOCKET
, "Text %u: expected success\n", i
);
2162 size
= sizeof(info
);
2163 err
= getsockopt( sock
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *)&info
, &size
);
2164 ok(!err
, "Test %u: getsockopt failed, error %u\n", i
, WSAGetLastError());
2165 ok(info
.iAddressFamily
== tests
[i
].ret_family
, "Test %u: got wrong family %d\n", i
, info
.iAddressFamily
);
2166 ok(info
.iSocketType
== tests
[i
].ret_type
, "Test %u: got wrong type %d\n", i
, info
.iSocketType
);
2167 ok(info
.iProtocol
== tests
[i
].ret_protocol
, "Test %u: got wrong protocol %d\n", i
, info
.iProtocol
);
2169 closesocket( sock
);
2173 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
2174 * to avoid a crash on win98.
2177 items
= WSAEnumProtocolsA(wsaproviders
, NULL
, &pi_size
);
2178 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
2180 err
= WSAGetLastError();
2181 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2184 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
2185 ok(pi
!= NULL
, "Failed to allocate memory\n");
2187 items
= WSAEnumProtocolsA(wsaproviders
, pi
, &pi_size
);
2188 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
2192 skip("No protocols enumerated.\n");
2193 HeapFree(GetProcessHeap(), 0, pi
);
2197 sock
= WSASocketA(FROM_PROTOCOL_INFO
, FROM_PROTOCOL_INFO
,
2198 FROM_PROTOCOL_INFO
, &pi
[0], 0, 0);
2199 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2203 /* find what parameters are used first: plain parameters or protocol info struct */
2204 pi
[0].iProtocol
= -1;
2205 pi
[0].iSocketType
= -1;
2206 pi
[0].iAddressFamily
= -1;
2207 ok(WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0) == INVALID_SOCKET
,
2208 "WSASocketA should have failed\n");
2209 err
= WSAGetLastError();
2210 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
2212 pi
[0].iProtocol
= 0;
2213 pi
[0].iSocketType
= 0;
2214 pi
[0].iAddressFamily
= 0;
2215 sock
= WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0);
2216 if(sock
!= INVALID_SOCKET
)
2218 win_skip("must work only in OS <= 2003\n");
2223 err
= WSAGetLastError();
2224 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
2227 pi
[0].iProtocol
= IPPROTO_UDP
;
2228 pi
[0].iSocketType
= SOCK_DGRAM
;
2229 pi
[0].iAddressFamily
= AF_INET
;
2230 sock
= WSASocketA(0, 0, 0, &pi
[0], 0, 0);
2231 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2233 size
= sizeof(socktype
);
2235 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2236 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2237 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2238 SOCK_DGRAM
, socktype
);
2241 sock
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, &pi
[0], 0, 0);
2242 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2244 size
= sizeof(socktype
);
2246 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2247 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2248 ok(socktype
== SOCK_STREAM
, "Wrong socket type, expected %d received %d\n",
2249 SOCK_STREAM
, socktype
);
2252 HeapFree(GetProcessHeap(), 0, pi
);
2255 items
= WSAEnumProtocolsA(NULL
, NULL
, &pi_size
);
2256 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
2258 err
= WSAGetLastError();
2259 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2262 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
2263 ok(pi
!= NULL
, "Failed to allocate memory\n");
2265 items
= WSAEnumProtocolsA(NULL
, pi
, &pi_size
);
2266 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
2269 /* when no protocol and socket type are specified the first entry
2270 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
2272 sock
= WSASocketA(AF_INET
, 0, 0, NULL
, 0, 0);
2273 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2276 size
= sizeof(socktype
);
2278 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2279 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2280 for(i
= 0; i
< items
; i
++)
2282 if(pi
[i
].dwProviderFlags
& PFL_MATCHES_PROTOCOL_ZERO
)
2284 ok(socktype
== pi
[i
].iSocketType
, "Wrong socket type, expected %d received %d\n",
2285 pi
[i
].iSocketType
, socktype
);
2289 ok(i
!= items
, "Creating a socket without protocol and socket type didn't work\n");
2292 /* when no socket type is specified the first entry from WSAEnumProtocols
2293 * that matches the protocol is returned */
2294 for (i
= 0; i
< ARRAY_SIZE(autoprotocols
); i
++)
2296 sock
= WSASocketA(0, 0, autoprotocols
[i
], NULL
, 0, 0);
2297 ok(sock
!= INVALID_SOCKET
, "Failed to create socket for protocol %d, received %d\n",
2298 autoprotocols
[i
], WSAGetLastError());
2300 size
= sizeof(socktype
);
2302 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2303 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2305 for (err
= 1, j
= 0; j
< items
; j
++)
2307 if (pi
[j
].iProtocol
== autoprotocols
[i
])
2309 ok(pi
[j
].iSocketType
== socktype
, "expected %d, got %d\n", socktype
, pi
[j
].iSocketType
);
2314 ok(!err
, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols
[i
]);
2319 HeapFree(GetProcessHeap(), 0, pi
);
2321 SetLastError(0xdeadbeef);
2322 /* starting on vista the socket function returns error during the socket
2323 creation and no longer in the socket operations (sendto, readfrom) */
2324 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_ICMP
, NULL
, 0, 0);
2325 if (sock
== INVALID_SOCKET
)
2327 err
= WSAGetLastError();
2328 ok(err
== WSAEACCES
, "Expected 10013, received %d\n", err
);
2329 skip("SOCK_RAW is not supported\n");
2333 size
= sizeof(socktype
);
2335 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2336 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2337 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2338 SOCK_RAW
, socktype
);
2341 sock
= WSASocketA(0, 0, IPPROTO_RAW
, NULL
, 0, 0);
2342 if (sock
!= INVALID_SOCKET
)
2345 size
= sizeof(socktype
);
2347 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2348 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2349 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2350 SOCK_RAW
, socktype
);
2354 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_TCP
, NULL
, 0, 0);
2355 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2357 size
= sizeof(socktype
);
2359 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2360 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2361 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2362 SOCK_RAW
, socktype
);
2365 else if (WSAGetLastError() == WSAEACCES
)
2366 skip("SOCK_RAW is not available\n");
2368 ok(0, "Failed to create socket: %d\n", WSAGetLastError());
2372 /* IPX socket tests */
2374 SetLastError(0xdeadbeef);
2375 sock
= WSASocketA(AF_IPX
, SOCK_DGRAM
, NSPROTO_IPX
, NULL
, 0, 0);
2376 if (sock
== INVALID_SOCKET
)
2378 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "got error %u\n", WSAGetLastError());
2379 skip("IPX is not supported\n");
2383 WSAPROTOCOL_INFOA info
;
2386 sock
= WSASocketA(0, 0, NSPROTO_IPX
, NULL
, 0, 0);
2387 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2390 size
= sizeof(socktype
);
2392 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2393 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2394 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2395 SOCK_DGRAM
, socktype
);
2397 /* check socket family, type and protocol */
2398 size
= sizeof(WSAPROTOCOL_INFOA
);
2399 err
= getsockopt(sock
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &info
, &size
);
2400 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2401 ok(info
.iProtocol
== NSPROTO_IPX
, "expected protocol %d, received %d\n",
2402 NSPROTO_IPX
, info
.iProtocol
);
2403 ok(info
.iAddressFamily
== AF_IPX
, "expected family %d, received %d\n",
2404 AF_IPX
, info
.iProtocol
);
2405 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
2406 SOCK_DGRAM
, info
.iSocketType
);
2409 /* SOCK_STREAM does not support NSPROTO_IPX */
2410 SetLastError(0xdeadbeef);
2411 ok(WSASocketA(AF_IPX
, SOCK_STREAM
, NSPROTO_IPX
, NULL
, 0, 0) == INVALID_SOCKET
,
2412 "WSASocketA should have failed\n");
2413 err
= WSAGetLastError();
2414 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2416 /* test extended IPX support - that is adding any number between 0 and 255
2417 * to the IPX protocol value will make it be used as IPX packet type */
2418 for(i
= 0;i
<= 255;i
+= 17)
2420 SetLastError(0xdeadbeef);
2421 sock
= WSASocketA(0, 0, NSPROTO_IPX
+ i
, NULL
, 0, 0);
2422 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2427 err
= getsockopt(sock
, NSPROTO_IPX
, IPX_PTYPE
, (char *) &socktype
, &size
);
2428 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2429 ok(socktype
== i
, "Wrong IPX packet type, expected %d received %d\n",
2437 static void test_WSADuplicateSocket(void)
2439 SOCKET source
, dupsock
;
2440 WSAPROTOCOL_INFOA info
;
2442 struct sockaddr_in addr
;
2443 int socktype
, size
, addrsize
, ret
;
2444 char teststr
[] = "TEST", buffer
[16];
2446 source
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
2447 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2449 /* test invalid parameters */
2450 SetLastError(0xdeadbeef);
2451 ok(WSADuplicateSocketA(0, 0, NULL
), "WSADuplicateSocketA should have failed\n");
2452 err
= WSAGetLastError();
2453 ok(err
== WSAENOTSOCK
, "expected 10038, received %d\n", err
);
2455 SetLastError(0xdeadbeef);
2456 ok(WSADuplicateSocketA(source
, 0, NULL
),
2457 "WSADuplicateSocketA should have failed\n");
2458 err
= WSAGetLastError();
2459 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2461 SetLastError(0xdeadbeef);
2462 ok(WSADuplicateSocketA(source
, ~0, &info
),
2463 "WSADuplicateSocketA should have failed\n");
2464 err
= WSAGetLastError();
2465 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2467 SetLastError(0xdeadbeef);
2468 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info
),
2469 "WSADuplicateSocketA should have failed\n");
2470 err
= WSAGetLastError();
2471 ok(err
== WSAENOTSOCK
, "expected 10038, received %d\n", err
);
2473 SetLastError(0xdeadbeef);
2474 ok(WSADuplicateSocketA(source
, GetCurrentProcessId(), NULL
),
2475 "WSADuplicateSocketA should have failed\n");
2476 err
= WSAGetLastError();
2477 ok(err
== WSAEFAULT
, "expected 10014, received %d\n", err
);
2479 /* test returned structure */
2480 memset(&info
, 0, sizeof(info
));
2481 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2482 "WSADuplicateSocketA should have worked\n");
2484 ok(info
.iProtocol
== IPPROTO_TCP
, "expected protocol %d, received %d\n",
2485 IPPROTO_TCP
, info
.iProtocol
);
2486 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
2487 AF_INET
, info
.iProtocol
);
2488 ok(info
.iSocketType
== SOCK_STREAM
, "expected type %d, received %d\n",
2489 SOCK_STREAM
, info
.iSocketType
);
2491 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2492 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2494 closesocket(dupsock
);
2495 closesocket(source
);
2497 /* create a socket, bind it, duplicate it then send data on source and
2498 * receive in the duplicated socket */
2499 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
2500 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2502 memset(&info
, 0, sizeof(info
));
2503 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2504 "WSADuplicateSocketA should have worked\n");
2506 ok(info
.iProtocol
== IPPROTO_UDP
, "expected protocol %d, received %d\n",
2507 IPPROTO_UDP
, info
.iProtocol
);
2508 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
2509 AF_INET
, info
.iProtocol
);
2510 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
2511 SOCK_DGRAM
, info
.iSocketType
);
2513 memset(&addr
, 0, sizeof(addr
));
2514 addr
.sin_family
= AF_INET
;
2515 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2516 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
2517 "bind should have worked\n");
2519 /* read address to find out the port number to be used in sendto */
2520 memset(&addr
, 0, sizeof(addr
));
2521 addrsize
= sizeof(addr
);
2522 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
2523 "getsockname should have worked\n");
2524 ok(addr
.sin_port
, "socket port should be != 0\n");
2526 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2527 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2530 ret
= getsockopt(dupsock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2531 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
2532 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2533 SOCK_DGRAM
, socktype
);
2535 set_blocking(source
, TRUE
);
2537 /* send data on source socket */
2538 addrsize
= sizeof(addr
);
2539 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
2540 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2542 /* receive on duplicated socket */
2543 addrsize
= sizeof(addr
);
2544 memset(buffer
, 0, sizeof(buffer
));
2545 size
= recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
);
2546 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2547 buffer
[sizeof(teststr
) - 1] = 0;
2548 ok(!strcmp(buffer
, teststr
), "expected '%s', received '%s'\n", teststr
, buffer
);
2550 closesocket(dupsock
);
2551 closesocket(source
);
2553 /* show that the source socket need to be bound before the duplicated
2554 * socket is created */
2555 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
2556 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2558 memset(&info
, 0, sizeof(info
));
2559 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2560 "WSADuplicateSocketA should have worked\n");
2562 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2563 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2565 memset(&addr
, 0, sizeof(addr
));
2566 addr
.sin_family
= AF_INET
;
2567 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2568 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
2569 "bind should have worked\n");
2571 /* read address to find out the port number to be used in sendto */
2572 memset(&addr
, 0, sizeof(addr
));
2573 addrsize
= sizeof(addr
);
2574 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
2575 "getsockname should have worked\n");
2576 ok(addr
.sin_port
, "socket port should be != 0\n");
2578 set_blocking(source
, TRUE
);
2580 addrsize
= sizeof(addr
);
2581 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
2582 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2584 SetLastError(0xdeadbeef);
2585 addrsize
= sizeof(addr
);
2586 memset(buffer
, 0, sizeof(buffer
));
2588 ok(recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
) == -1,
2589 "recvfrom should have failed\n");
2590 err
= WSAGetLastError();
2591 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2594 closesocket(dupsock
);
2595 closesocket(source
);
2598 static void test_WSAEnumNetworkEvents(void)
2601 int sock_type
[] = {SOCK_STREAM
, SOCK_DGRAM
, SOCK_STREAM
}, i
, j
, k
, l
;
2602 struct sockaddr_in address
;
2604 WSANETWORKEVENTS net_events
;
2606 memset(&address
, 0, sizeof(address
));
2607 address
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
2608 address
.sin_family
= AF_INET
;
2610 /* This test follows the steps from bugs 10204 and 24946 */
2611 for (l
= 0; l
< 2; l
++)
2613 for (i
= 0; i
< ARRAY_SIZE(sock_type
); i
++)
2616 tcp_socketpair(&s
, &s2
);
2619 s
= socket(AF_INET
, sock_type
[i
], 0);
2620 ok (s
!= SOCKET_ERROR
, "Test[%d]: failed to create socket\n", i
);
2621 ok (!bind(s
, (struct sockaddr
*) &address
, sizeof(address
)), "Test[%d]: bind failed\n", i
);
2623 event
= WSACreateEvent();
2624 ok (event
!= NULL
, "Test[%d]: failed to create event\n", i
);
2625 for (j
= 0; j
< 5; j
++) /* Repeat sometimes and the result must be the same */
2627 /* When the TCP socket is not connected NO events will be returned.
2628 * When connected and no data pending it will get the write event.
2629 * UDP sockets don't have connections so as soon as they are bound
2630 * they can read/write data. Since nobody is sendind us data only
2631 * the write event will be returned and ONLY once.
2633 ok (!WSAEventSelect(s
, event
, FD_READ
| FD_WRITE
), "Test[%d]: WSAEventSelect failed\n", i
);
2634 memset(&net_events
, 0xAB, sizeof(net_events
));
2635 ok (!WSAEnumNetworkEvents(s
, l
== 0 ? event
: NULL
, &net_events
),
2636 "Test[%d]: WSAEnumNetworkEvents failed\n", i
);
2637 if (i
>= 1 && j
== 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
2639 ok (net_events
.lNetworkEvents
== FD_WRITE
, "Test[%d]: expected 2, got %d\n",
2640 i
, net_events
.lNetworkEvents
);
2644 ok (net_events
.lNetworkEvents
== 0, "Test[%d]: expected 0, got %d\n",
2645 i
, net_events
.lNetworkEvents
);
2647 for (k
= 0; k
< FD_MAX_EVENTS
; k
++)
2649 if (net_events
.lNetworkEvents
& (1 << k
))
2651 ok (net_events
.iErrorCode
[k
] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
2652 i
, k
, net_events
.iErrorCode
[k
]);
2656 /* Bits that are not set in lNetworkEvents MUST not be changed */
2657 ok (net_events
.iErrorCode
[k
] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
2658 i
, k
, net_events
.iErrorCode
[k
]);
2663 WSACloseEvent(event
);
2664 if (i
== 2) closesocket(s2
);
2669 static DWORD WINAPI
SelectReadThread(void *param
)
2671 select_thread_params
*par
= param
;
2674 struct sockaddr_in addr
;
2675 struct timeval select_timeout
;
2678 FD_SET(par
->s
, &readfds
);
2679 select_timeout
.tv_sec
=5;
2680 select_timeout
.tv_usec
=0;
2681 addr
.sin_family
= AF_INET
;
2682 addr
.sin_addr
.s_addr
= inet_addr(SERVERIP
);
2683 addr
.sin_port
= htons(SERVERPORT
);
2685 do_bind(par
->s
, (struct sockaddr
*)&addr
, sizeof(addr
));
2686 wsa_ok(listen(par
->s
, SOMAXCONN
), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
2688 SetEvent(server_ready
);
2689 ret
= select(par
->s
+1, &readfds
, NULL
, NULL
, &select_timeout
);
2690 par
->ReadKilled
= (ret
== 1);
2695 static DWORD WINAPI
SelectCloseThread(void *param
)
2697 SOCKET s
= *(SOCKET
*)param
;
2703 static void test_errors(void)
2706 SOCKADDR_IN SockAddr
;
2709 WSASetLastError(NO_ERROR
);
2710 sock
= socket(PF_INET
, SOCK_STREAM
, 0);
2711 ok( (sock
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2712 memset(&SockAddr
, 0, sizeof(SockAddr
));
2713 SockAddr
.sin_family
= AF_INET
;
2714 SockAddr
.sin_port
= htons(6924);
2715 SockAddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2717 ret
= connect(sock
, (PSOCKADDR
)&SockAddr
, sizeof(SockAddr
));
2718 ok( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got: %d\n", ret
);
2719 if (ret
== SOCKET_ERROR
)
2721 err
= WSAGetLastError();
2722 ok( (err
== WSAECONNREFUSED
), "expected WSAECONNREFUSED, got: %d\n", err
);
2727 fd_set set
= {1, {sock
}};
2730 timeval
.tv_usec
= 50000;
2732 ret
= select(1, NULL
, &set
, NULL
, &timeval
);
2733 ok( (ret
== 0), "expected 0 (timeout), got: %d\n", ret
);
2736 ret
= closesocket(sock
);
2737 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
2740 static void test_listen(void)
2743 int ret
, acceptc
, olen
= sizeof(acceptc
);
2744 struct sockaddr_in address
;
2746 memset(&address
, 0, sizeof(address
));
2747 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2748 address
.sin_family
= AF_INET
;
2749 address
.sin_port
= htons(SERVERPORT
);
2751 /* invalid socket tests */
2752 SetLastError(0xdeadbeef);
2753 ok ((listen(0, 0) == SOCKET_ERROR
), "listen did not fail\n");
2754 ret
= WSAGetLastError();
2755 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
2757 SetLastError(0xdeadbeef);
2758 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR
), "listen did not fail\n");
2759 ret
= WSAGetLastError();
2760 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
2763 fdA
= socket(AF_INET
, SOCK_STREAM
, 0);
2764 ok ((fdA
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2766 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
2767 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2769 SetLastError(0xdeadbeef);
2770 ok ((listen(fdA
, -2) == SOCKET_ERROR
), "listen did not fail\n");
2771 ret
= WSAGetLastError();
2772 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
2774 SetLastError(0xdeadbeef);
2775 ok ((listen(fdA
, 1) == SOCKET_ERROR
), "listen did not fail\n");
2776 ret
= WSAGetLastError();
2777 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
2779 SetLastError(0xdeadbeef);
2780 ok ((listen(fdA
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
2781 ret
= WSAGetLastError();
2782 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
2784 ok (!bind(fdA
, (struct sockaddr
*) &address
, sizeof(address
)), "bind failed\n");
2786 SetLastError(0xdeadbeef);
2787 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
2788 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
2791 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
2792 ok (!ret
, "getsockopt failed\n");
2793 ok (acceptc
== 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc
);
2795 ok (!listen(fdA
, 0), "listen failed\n");
2796 ok (!listen(fdA
, SOMAXCONN
), "double listen failed\n");
2799 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
2800 ok (!ret
, "getsockopt failed\n");
2801 ok (acceptc
== 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc
);
2803 SetLastError(0xdeadbeef);
2804 ok ((listen(fdB
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
2805 ret
= WSAGetLastError();
2806 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
2808 ret
= closesocket(fdB
);
2809 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
2811 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
2812 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2814 SetLastError(0xdeadbeef);
2815 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
2816 ret
= WSAGetLastError();
2817 ok (ret
== WSAEADDRINUSE
, "expected 10048, received %d\n", ret
);
2819 ret
= closesocket(fdA
);
2820 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
2821 ret
= closesocket(fdB
);
2822 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
2825 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
2826 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
2827 static void test_select(void)
2829 static char tmp_buf
[1024];
2831 SOCKET fdListen
, fdRead
, fdWrite
;
2832 fd_set readfds
, writefds
, exceptfds
;
2836 struct timeval select_timeout
;
2837 struct sockaddr_in address
;
2838 select_thread_params thread_params
;
2839 HANDLE thread_handle
;
2842 fdRead
= socket(AF_INET
, SOCK_STREAM
, 0);
2843 ok( (fdRead
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2844 fdWrite
= socket(AF_INET
, SOCK_STREAM
, 0);
2845 ok( (fdWrite
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2848 if (fdWrite
> maxfd
)
2853 FD_SET_ALL(fdWrite
);
2854 select_timeout
.tv_sec
=0;
2855 select_timeout
.tv_usec
=0;
2857 ticks
= GetTickCount();
2858 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2859 ticks
= GetTickCount() - ticks
;
2860 ok(ret
== 0, "select should not return any socket handles\n");
2861 ok(ticks
< 10, "select was blocking for %u ms, expected < 10 ms\n", ticks
);
2862 ok(!FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
2863 ok(!FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
2864 ok(!FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
2865 ok(!FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
2869 FD_SET_ALL(fdWrite
);
2870 select_timeout
.tv_sec
=0;
2871 select_timeout
.tv_usec
=500;
2873 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2874 ok(ret
== 0, "select should not return any socket handles\n");
2875 ok(!FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
2876 ok(!FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
2877 ok(!FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
2878 ok(!FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
2880 ok ((listen(fdWrite
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
2881 ret
= closesocket(fdWrite
);
2882 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
2884 thread_params
.s
= fdRead
;
2885 thread_params
.ReadKilled
= FALSE
;
2886 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
2887 thread_handle
= CreateThread (NULL
, 0, SelectReadThread
, &thread_params
, 0, &id
);
2888 ok ( (thread_handle
!= NULL
), "CreateThread failed unexpectedly: %d\n", GetLastError());
2890 WaitForSingleObject (server_ready
, INFINITE
);
2892 ret
= closesocket(fdRead
);
2893 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
2895 WaitForSingleObject (thread_handle
, 1000);
2896 ok ( thread_params
.ReadKilled
, "closesocket did not wake up select\n");
2897 ret
= recv(fdRead
, &buffer
, 1, MSG_PEEK
);
2898 ok( (ret
== -1), "peek at closed socket expected -1 got %d\n", ret
);
2900 /* Test selecting invalid handles */
2904 ret
= select(maxfd
+1, 0, 0, 0, &select_timeout
);
2905 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
2906 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
2909 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2910 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
2911 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
2913 FD_SET(INVALID_SOCKET
, &readfds
);
2915 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2916 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
2917 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
2918 ok ( !FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
2921 FD_SET(INVALID_SOCKET
, &writefds
);
2923 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2924 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
2925 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
2926 ok ( !FD_ISSET(fdRead
, &writefds
), "FD should not be set\n");
2929 FD_SET(INVALID_SOCKET
, &exceptfds
);
2931 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2932 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
2933 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
2934 ok ( !FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
2936 tcp_socketpair(&fdRead
, &fdWrite
);
2938 if(fdWrite
> maxfd
) maxfd
= fdWrite
;
2941 FD_SET(fdRead
, &readfds
);
2942 ret
= select(fdRead
+1, &readfds
, NULL
, NULL
, &select_timeout
);
2943 ok(!ret
, "select returned %d\n", ret
);
2946 FD_SET(fdWrite
, &writefds
);
2947 ret
= select(fdWrite
+1, NULL
, &writefds
, NULL
, &select_timeout
);
2948 ok(ret
== 1, "select returned %d\n", ret
);
2949 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
2951 /* tests for overlapping fd_set pointers */
2953 FD_SET(fdWrite
, &readfds
);
2954 ret
= select(fdWrite
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
2955 ok(ret
== 1, "select returned %d\n", ret
);
2956 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
2959 FD_SET(fdWrite
, &readfds
);
2960 FD_SET(fdRead
, &readfds
);
2961 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
2962 ok(ret
== 2, "select returned %d\n", ret
);
2963 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
2964 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
2966 ok(send(fdWrite
, "test", 4, 0) == 4, "failed to send data\n");
2968 FD_SET(fdRead
, &readfds
);
2969 ret
= select(fdRead
+1, &readfds
, NULL
, NULL
, &select_timeout
);
2970 ok(ret
== 1, "select returned %d\n", ret
);
2971 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
2974 FD_SET(fdWrite
, &readfds
);
2975 FD_SET(fdRead
, &readfds
);
2976 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
2977 ok(ret
== 2, "select returned %d\n", ret
);
2978 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
2979 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
2983 FD_SET(fdWrite
, &writefds
);
2984 ret
= select(fdWrite
+1, NULL
, &writefds
, NULL
, &select_timeout
);
2986 ok(send(fdWrite
, tmp_buf
, sizeof(tmp_buf
), 0) > 0, "failed to send data\n");
2989 FD_SET(fdWrite
, &readfds
);
2990 FD_SET(fdRead
, &readfds
);
2991 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
2992 ok(ret
== 1, "select returned %d\n", ret
);
2993 ok(!FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is in the set\n");
2994 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
2996 ok(send(fdRead
, "test", 4, 0) == 4, "failed to send data\n");
2999 FD_SET(fdWrite
, &readfds
);
3000 FD_SET(fdRead
, &readfds
);
3001 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3002 ok(ret
== 2, "select returned %d\n", ret
);
3003 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3004 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3006 closesocket(fdRead
);
3007 closesocket(fdWrite
);
3009 /* select() works in 3 distinct states:
3010 * - to check if a connection attempt ended with success or error;
3011 * - to check if a pending connection is waiting for acceptance;
3012 * - to check for data to read, availability for write and OOB data
3014 * The tests below ensure that all conditions are tested.
3016 memset(&address
, 0, sizeof(address
));
3017 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3018 address
.sin_family
= AF_INET
;
3019 len
= sizeof(address
);
3020 fdListen
= setup_server_socket(&address
, &len
);
3021 select_timeout
.tv_sec
= 1;
3022 select_timeout
.tv_usec
= 250000;
3024 /* When no events are pending select returns 0 with no error */
3026 FD_SET_ALL(fdListen
);
3027 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3028 ok(ret
== 0, "expected 0, got %d\n", ret
);
3030 /* When a socket is attempting to connect the listening socket receives the read descriptor */
3031 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
3033 FD_SET_ALL(fdListen
);
3034 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3035 ok(ret
== 1, "expected 1, got %d\n", ret
);
3036 ok(FD_ISSET(fdListen
, &readfds
), "fdListen socket is not in the set\n");
3037 len
= sizeof(address
);
3038 fdRead
= accept(fdListen
, (struct sockaddr
*) &address
, &len
);
3039 ok(fdRead
!= INVALID_SOCKET
, "expected a valid socket\n");
3041 /* The connector is signaled through the write descriptor */
3043 FD_SET_ALL(fdListen
);
3045 FD_SET_ALL(fdWrite
);
3046 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3047 ok(ret
== 2, "expected 2, got %d\n", ret
);
3048 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
3049 ok(FD_ISSET(fdRead
, &writefds
), "fdRead socket is not in the set\n");
3052 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
3053 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
3054 ok(id
== 0, "expected 0, got %d\n", id
);
3056 /* When data is received the receiver gets the read descriptor */
3057 ret
= send(fdWrite
, "1234", 4, 0);
3058 ok(ret
== 4, "expected 4, got %d\n", ret
);
3060 FD_SET_ALL(fdListen
);
3061 FD_SET(fdRead
, &readfds
);
3062 FD_SET(fdRead
, &exceptfds
);
3063 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3064 ok(ret
== 1, "expected 1, got %d\n", ret
);
3065 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3066 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
3067 ok(ret
== 4, "expected 4, got %d\n", ret
);
3068 ok(!strcmp(tmp_buf
, "1234"), "data received differs from sent\n");
3070 /* When OOB data is received the socket is set in the except descriptor */
3071 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
3072 ok(ret
== 1, "expected 1, got %d\n", ret
);
3074 FD_SET_ALL(fdListen
);
3075 FD_SET(fdRead
, &readfds
);
3076 FD_SET(fdRead
, &exceptfds
);
3077 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3078 ok(ret
== 1, "expected 1, got %d\n", ret
);
3079 ok(FD_ISSET(fdRead
, &exceptfds
), "fdRead socket is not in the set\n");
3081 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
3082 ok(ret
== 1, "expected 1, got %d\n", ret
);
3083 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
3085 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
3087 ret
= setsockopt(fdRead
, SOL_SOCKET
, SO_OOBINLINE
, (char*) &ret
, sizeof(ret
));
3088 ok(ret
== 0, "expected 0, got %d\n", ret
);
3089 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
3090 ok(ret
== 1, "expected 1, got %d\n", ret
);
3092 FD_SET_ALL(fdListen
);
3093 FD_SET(fdRead
, &readfds
);
3094 FD_SET(fdRead
, &exceptfds
);
3095 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3096 ok(ret
== 1, "expected 1, got %d\n", ret
);
3097 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3099 SetLastError(0xdeadbeef);
3100 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
3101 ok(ret
== SOCKET_ERROR
, "expected SOCKET_ERROR, got %d\n", ret
);
3102 ok(GetLastError() == WSAEINVAL
, "expected 10022, got %d\n", GetLastError());
3103 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
3104 ok(ret
== 1, "expected 1, got %d\n", ret
);
3105 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
3107 /* When the connection is closed the socket is set in the read descriptor */
3108 ret
= closesocket(fdRead
);
3109 ok(ret
== 0, "expected 0, got %d\n", ret
);
3111 FD_SET_ALL(fdListen
);
3112 FD_SET(fdWrite
, &readfds
);
3113 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3114 ok(ret
== 1, "expected 1, got %d\n", ret
);
3115 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3116 ret
= recv(fdWrite
, tmp_buf
, sizeof(tmp_buf
), 0);
3117 ok(ret
== 0, "expected 0, got %d\n", ret
);
3118 ret
= closesocket(fdWrite
);
3119 ok(ret
== 0, "expected 0, got %d\n", ret
);
3120 ret
= closesocket(fdListen
);
3121 ok(ret
== 0, "expected 0, got %d\n", ret
);
3123 /* w10pro64 sometimes takes over 2 seconds for an error to be reported. */
3124 if (winetest_interactive
)
3126 len
= sizeof(address
);
3127 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
3129 FD_SET(fdWrite
, &writefds
);
3130 FD_SET(fdWrite
, &exceptfds
);
3131 select_timeout
.tv_sec
= 10;
3132 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3133 ok(ret
== 1, "expected 1, got %d\n", ret
);
3136 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
3137 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
3138 ok(id
== WSAECONNREFUSED
, "expected 10061, got %d\n", id
);
3139 ok(FD_ISSET(fdWrite
, &exceptfds
), "fdWrite socket is not in the set\n");
3140 ok(select_timeout
.tv_usec
== 250000, "select timeout should not have changed\n");
3141 closesocket(fdWrite
);
3144 /* Try select() on a closed socket after connection */
3145 tcp_socketpair(&fdRead
, &fdWrite
);
3146 closesocket(fdRead
);
3148 FD_SET_ALL(fdWrite
);
3150 SetLastError(0xdeadbeef);
3151 ret
= select(0, &readfds
, NULL
, &exceptfds
, &select_timeout
);
3152 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
3153 ok(GetLastError() == WSAENOTSOCK
, "got %d\n", GetLastError());
3154 /* descriptor sets are unchanged */
3155 ok(readfds
.fd_count
== 2, "expected 2, got %d\n", readfds
.fd_count
);
3156 ok(exceptfds
.fd_count
== 2, "expected 2, got %d\n", exceptfds
.fd_count
);
3157 closesocket(fdWrite
);
3159 /* Close the socket currently being selected in a thread - bug 38399 */
3160 tcp_socketpair(&fdRead
, &fdWrite
);
3161 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
3162 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
3164 FD_SET_ALL(fdWrite
);
3165 ret
= select(0, &readfds
, NULL
, &exceptfds
, &select_timeout
);
3166 ok(ret
== 1, "expected 1, got %d\n", ret
);
3167 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3168 WaitForSingleObject (thread_handle
, 1000);
3169 closesocket(fdRead
);
3170 /* test again with only the except descriptor */
3171 tcp_socketpair(&fdRead
, &fdWrite
);
3172 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
3173 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
3175 FD_SET(fdWrite
, &exceptfds
);
3176 SetLastError(0xdeadbeef);
3177 ret
= select(0, NULL
, NULL
, &exceptfds
, &select_timeout
);
3179 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
3180 ok(GetLastError() == WSAENOTSOCK
, "got %d\n", GetLastError());
3181 WaitForSingleObject (thread_handle
, 1000);
3182 closesocket(fdRead
);
3184 /* test UDP behavior of unbound sockets */
3185 select_timeout
.tv_sec
= 0;
3186 select_timeout
.tv_usec
= 250000;
3187 fdWrite
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
3188 ok(fdWrite
!= INVALID_SOCKET
, "socket call failed\n");
3190 FD_SET_ALL(fdWrite
);
3191 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3192 ok(ret
== 1, "expected 1, got %d\n", ret
);
3193 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
3194 closesocket(fdWrite
);
3199 static DWORD WINAPI
AcceptKillThread(void *param
)
3201 select_thread_params
*par
= param
;
3202 struct sockaddr_in address
;
3203 int len
= sizeof(address
);
3204 SOCKET client_socket
;
3206 SetEvent(server_ready
);
3207 client_socket
= accept(par
->s
, (struct sockaddr
*) &address
, &len
);
3208 if (client_socket
!= INVALID_SOCKET
)
3209 closesocket(client_socket
);
3210 par
->ReadKilled
= (client_socket
== INVALID_SOCKET
);
3215 static int CALLBACK
AlwaysDeferConditionFunc(LPWSABUF lpCallerId
, LPWSABUF lpCallerData
, LPQOS pQos
,
3216 LPQOS lpGQOS
, LPWSABUF lpCalleeId
, LPWSABUF lpCalleeData
,
3217 GROUP
*g
, DWORD_PTR dwCallbackData
)
3222 static SOCKET
setup_server_socket(struct sockaddr_in
*addr
, int *len
)
3225 SOCKET server_socket
;
3227 server_socket
= socket(AF_INET
, SOCK_STREAM
, 0);
3228 ok(server_socket
!= INVALID_SOCKET
, "failed to bind socket, error %u\n", WSAGetLastError());
3231 ret
= setsockopt(server_socket
, SOL_SOCKET
, SO_REUSEADDR
, (char *)&val
, sizeof(val
));
3232 ok(!ret
, "failed to set SO_REUSEADDR, error %u\n", WSAGetLastError());
3234 ret
= bind(server_socket
, (struct sockaddr
*)addr
, *len
);
3235 ok(!ret
, "failed to bind socket, error %u\n", WSAGetLastError());
3237 ret
= getsockname(server_socket
, (struct sockaddr
*)addr
, len
);
3238 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
3240 ret
= listen(server_socket
, 5);
3241 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
3243 return server_socket
;
3246 static SOCKET
setup_connector_socket(const struct sockaddr_in
*addr
, int len
, BOOL nonblock
)
3251 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
3252 ok(connector
!= INVALID_SOCKET
, "failed to create connector socket %d\n", WSAGetLastError());
3255 set_blocking(connector
, !nonblock
);
3257 ret
= connect(connector
, (const struct sockaddr
*)addr
, len
);
3259 ok(!ret
, "connecting to accepting socket failed %d\n", WSAGetLastError());
3260 else if (ret
== SOCKET_ERROR
)
3261 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
3266 static void test_accept(void)
3269 SOCKET server_socket
, accepted
= INVALID_SOCKET
, connector
;
3270 struct sockaddr_in address
;
3271 SOCKADDR_STORAGE ss
, ss_empty
;
3273 select_thread_params thread_params
;
3274 HANDLE thread_handle
= NULL
;
3277 memset(&address
, 0, sizeof(address
));
3278 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3279 address
.sin_family
= AF_INET
;
3281 socklen
= sizeof(address
);
3282 server_socket
= setup_server_socket(&address
, &socklen
);
3284 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3285 if (connector
== INVALID_SOCKET
) goto done
;
3287 accepted
= WSAAccept(server_socket
, NULL
, NULL
, AlwaysDeferConditionFunc
, 0);
3288 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
3290 accepted
= accept(server_socket
, NULL
, 0);
3291 ok(accepted
!= INVALID_SOCKET
, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
3293 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
3295 thread_params
.s
= server_socket
;
3296 thread_params
.ReadKilled
= FALSE
;
3297 thread_handle
= CreateThread(NULL
, 0, AcceptKillThread
, &thread_params
, 0, &id
);
3299 WaitForSingleObject(server_ready
, INFINITE
);
3301 ret
= closesocket(server_socket
);
3302 ok(!ret
, "failed to close socket, error %u\n", WSAGetLastError());
3304 WaitForSingleObject(thread_handle
, 1000);
3305 ok(thread_params
.ReadKilled
, "closesocket did not wake up accept\n");
3307 closesocket(accepted
);
3308 closesocket(connector
);
3309 accepted
= connector
= INVALID_SOCKET
;
3311 socklen
= sizeof(address
);
3312 server_socket
= setup_server_socket(&address
, &socklen
);
3314 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3315 if (connector
== INVALID_SOCKET
) goto done
;
3318 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
3319 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
3320 ok(!socklen
, "got %d\n", socklen
);
3321 closesocket(connector
);
3322 connector
= INVALID_SOCKET
;
3324 socklen
= sizeof(address
);
3325 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3326 if (connector
== INVALID_SOCKET
) goto done
;
3328 accepted
= WSAAccept(server_socket
, NULL
, NULL
, NULL
, 0);
3329 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3330 closesocket(accepted
);
3331 closesocket(connector
);
3332 accepted
= connector
= INVALID_SOCKET
;
3334 socklen
= sizeof(address
);
3335 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3336 if (connector
== INVALID_SOCKET
) goto done
;
3338 socklen
= sizeof(ss
);
3339 memset(&ss
, 0, sizeof(ss
));
3340 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
3341 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3342 ok(socklen
!= sizeof(ss
), "unexpected length\n");
3343 ok(ss
.ss_family
, "family not set\n");
3344 closesocket(accepted
);
3345 closesocket(connector
);
3346 accepted
= connector
= INVALID_SOCKET
;
3348 socklen
= sizeof(address
);
3349 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3350 if (connector
== INVALID_SOCKET
) goto done
;
3353 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
3354 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
3355 ok(!socklen
, "got %d\n", socklen
);
3356 closesocket(connector
);
3357 accepted
= connector
= INVALID_SOCKET
;
3359 socklen
= sizeof(address
);
3360 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3361 if (connector
== INVALID_SOCKET
) goto done
;
3363 accepted
= accept(server_socket
, NULL
, NULL
);
3364 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3365 closesocket(accepted
);
3366 closesocket(connector
);
3367 accepted
= connector
= INVALID_SOCKET
;
3369 socklen
= sizeof(address
);
3370 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3371 if (connector
== INVALID_SOCKET
) goto done
;
3373 socklen
= sizeof(ss
);
3374 memset(&ss
, 0, sizeof(ss
));
3375 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
3376 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3377 ok(socklen
!= sizeof(ss
), "unexpected length\n");
3378 ok(ss
.ss_family
, "family not set\n");
3379 closesocket(accepted
);
3380 closesocket(connector
);
3381 accepted
= connector
= INVALID_SOCKET
;
3383 socklen
= sizeof(address
);
3384 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
3385 if (connector
== INVALID_SOCKET
) goto done
;
3387 memset(&ss
, 0, sizeof(ss
));
3388 memset(&ss_empty
, 0, sizeof(ss_empty
));
3389 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, NULL
);
3390 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3391 ok(!memcmp(&ss
, &ss_empty
, sizeof(ss
)), "structure is different\n");
3394 if (accepted
!= INVALID_SOCKET
)
3395 closesocket(accepted
);
3396 if (connector
!= INVALID_SOCKET
)
3397 closesocket(connector
);
3398 if (thread_handle
!= NULL
)
3399 CloseHandle(thread_handle
);
3400 if (server_ready
!= INVALID_HANDLE_VALUE
)
3401 CloseHandle(server_ready
);
3402 if (server_socket
!= INVALID_SOCKET
)
3403 closesocket(server_socket
);
3406 static void test_extendedSocketOptions(void)
3410 struct sockaddr_in sa
;
3411 int sa_len
= sizeof(struct sockaddr_in
);
3412 int optval
, optlen
= sizeof(int), ret
;
3416 ret
= WSAStartup(MAKEWORD(2,0), &wsa
);
3417 ok(!ret
, "failed to startup, error %u\n", WSAGetLastError());
3419 memset(&sa
, 0, sa_len
);
3421 sa
.sin_family
= AF_INET
;
3422 sa
.sin_port
= htons(0);
3423 sa
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
3425 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
3426 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
3428 ret
= bind(sock
, (struct sockaddr
*) &sa
, sa_len
);
3429 ok(!ret
, "failed to bind socket, error %u\n", WSAGetLastError());
3431 ret
= getsockopt(sock
, SOL_SOCKET
, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3433 ok(ret
== 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret
);
3434 ok((optval
== 65507) || (optval
== 65527),
3435 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval
);
3437 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
3438 SetLastError(0xdeadbeef);
3439 optval
= 0xdeadbeef;
3440 optlen
= sizeof(int);
3441 ret
= getsockopt(sock
, 0xffffffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3442 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3443 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3444 ret
, WSAGetLastError(), optval
, optval
);
3446 /* more invalid values for level */
3447 SetLastError(0xdeadbeef);
3448 optval
= 0xdeadbeef;
3449 optlen
= sizeof(int);
3450 ret
= getsockopt(sock
, 0x1234ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3451 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3452 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3453 ret
, WSAGetLastError(), optval
, optval
);
3455 SetLastError(0xdeadbeef);
3456 optval
= 0xdeadbeef;
3457 optlen
= sizeof(int);
3458 ret
= getsockopt(sock
, 0x8000ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3459 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3460 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3461 ret
, WSAGetLastError(), optval
, optval
);
3463 SetLastError(0xdeadbeef);
3464 optval
= 0xdeadbeef;
3465 optlen
= sizeof(int);
3466 ret
= getsockopt(sock
, 0x00008000, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3467 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3468 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3469 ret
, WSAGetLastError(), optval
, optval
);
3471 SetLastError(0xdeadbeef);
3472 optval
= 0xdeadbeef;
3473 optlen
= sizeof(int);
3474 ret
= getsockopt(sock
, 0x00000800, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3475 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3476 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3477 ret
, WSAGetLastError(), optval
, optval
);
3479 SetLastError(0xdeadbeef);
3480 optlen
= sizeof(LINGER
);
3481 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
3482 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAENOPROTOOPT
),
3483 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
3484 ret
, WSAGetLastError());
3487 sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
);
3488 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
3490 ret
= bind(sock
, (struct sockaddr
*) &sa
, sa_len
);
3491 ok(!ret
, "failed to bind socket, error %u\n", WSAGetLastError());
3493 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
3494 ok(ret
== 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret
);
3496 optlen
= sizeof(BOOL
);
3497 ret
= getsockopt(sock
, SOL_SOCKET
, SO_DONTLINGER
, (char *)&bool_opt_val
, &optlen
);
3498 ok(ret
== 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret
);
3499 ok((linger_val
.l_onoff
&& !bool_opt_val
) || (!linger_val
.l_onoff
&& bool_opt_val
),
3500 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
3501 bool_opt_val
, linger_val
.l_onoff
);
3507 static void test_getsockname(void)
3511 struct sockaddr_in sa_set
, sa_get
;
3512 int sa_set_len
= sizeof(struct sockaddr_in
);
3513 int sa_get_len
= sa_set_len
;
3514 static const unsigned char null_padding
[] = {0,0,0,0,0,0,0,0};
3518 ret
= WSAStartup(MAKEWORD(2,0), &wsa
);
3519 ok(!ret
, "failed to startup, error %u\n", WSAGetLastError());
3521 memset(&sa_set
, 0, sa_set_len
);
3523 sa_set
.sin_family
= AF_INET
;
3524 sa_set
.sin_port
= htons(0);
3525 sa_set
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
3527 sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
);
3528 ok(sock
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
3531 ret
= getsockname(sock
, (struct sockaddr
*)&sa_get
, &sa_get_len
);
3532 ok(ret
== SOCKET_ERROR
, "expected failure\n");
3533 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
3534 ok(!memcmp(&sa_get
, &sa_set
, sizeof(sa_get
)), "address should not be changed\n");
3536 ret
= bind(sock
, (struct sockaddr
*) &sa_set
, sa_set_len
);
3537 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
3539 ret
= getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
);
3540 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
3542 ret
= memcmp(sa_get
.sin_zero
, null_padding
, 8);
3543 ok(ret
== 0, "getsockname did not zero the sockaddr_in structure\n");
3547 h
= gethostbyname("");
3548 if (h
&& h
->h_length
== 4) /* this test is only meaningful in IPv4 */
3551 for (i
= 0; h
->h_addr_list
[i
]; i
++)
3555 ip
.s_addr
= *(ULONG
*) h
->h_addr_list
[i
];
3557 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
3558 ok(sock
!= INVALID_SOCKET
, "socket failed with %d\n", GetLastError());
3560 memset(&sa_set
, 0, sizeof(sa_set
));
3561 sa_set
.sin_family
= AF_INET
;
3562 sa_set
.sin_addr
.s_addr
= ip
.s_addr
;
3563 /* The same address we bind must be the same address we get */
3564 ret
= bind(sock
, (struct sockaddr
*)&sa_set
, sizeof(sa_set
));
3565 ok(ret
== 0, "bind failed with %d\n", GetLastError());
3566 sa_get_len
= sizeof(sa_get
);
3567 ret
= getsockname(sock
, (struct sockaddr
*)&sa_get
, &sa_get_len
);
3568 ok(ret
== 0, "getsockname failed with %d\n", GetLastError());
3569 strcpy(ipstr
, inet_ntoa(sa_get
.sin_addr
));
3570 ok(sa_get
.sin_addr
.s_addr
== sa_set
.sin_addr
.s_addr
,
3571 "address does not match: %s != %s\n", ipstr
, inet_ntoa(sa_set
.sin_addr
));
3580 static void test_ioctlsocket(void)
3582 SOCKET sock
, src
, dst
;
3583 struct tcp_keepalive kalive
;
3584 struct sockaddr_in address
;
3586 static const LONG cmds
[] = {FIONBIO
, FIONREAD
, SIOCATMARK
};
3592 sock
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3593 ok(sock
!= INVALID_SOCKET
, "Creating the socket failed: %d\n", WSAGetLastError());
3595 for(i
= 0; i
< ARRAY_SIZE(cmds
); i
++)
3597 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
3598 ret
= ioctlsocket(sock
, cmds
[i
], (u_long
*)1);
3599 ok(ret
== SOCKET_ERROR
, "ioctlsocket succeeded unexpectedly\n");
3600 ret
= WSAGetLastError();
3601 ok(ret
== WSAEFAULT
, "expected WSAEFAULT, got %d instead\n", ret
);
3604 /* A fresh and not connected socket has no urgent data, this test shows
3605 * that normal(not urgent) data returns a non-zero value for SIOCATMARK. */
3607 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
3608 ok(ret
!= SOCKET_ERROR
, "ioctlsocket failed unexpectedly\n");
3609 ok(arg
, "SIOCATMARK expected a non-zero value\n");
3611 /* when SO_OOBINLINE is set SIOCATMARK must always return TRUE */
3613 ret
= setsockopt(sock
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&optval
, sizeof(optval
));
3614 ok(ret
!= SOCKET_ERROR
, "setsockopt failed unexpectedly\n");
3616 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
3617 ok(ret
!= SOCKET_ERROR
, "ioctlsocket failed unexpectedly\n");
3618 ok(arg
, "SIOCATMARK expected a non-zero value\n");
3620 /* disable SO_OOBINLINE and get the same old behavior */
3622 ret
= setsockopt(sock
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&optval
, sizeof(optval
));
3623 ok(ret
!= SOCKET_ERROR
, "setsockopt failed unexpectedly\n");
3625 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
3626 ok(ret
!= SOCKET_ERROR
, "ioctlsocket failed unexpectedly\n");
3627 ok(arg
, "SIOCATMARK expected a non-zero value\n");
3629 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &arg
, 0, NULL
, 0, &arg
, NULL
, NULL
);
3630 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
3631 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3633 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, NULL
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
3634 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
3635 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
3637 make_keepalive(kalive
, 0, 0, 0);
3638 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
3639 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
3641 make_keepalive(kalive
, 1, 0, 0);
3642 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
3643 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
3645 make_keepalive(kalive
, 1, 1000, 1000);
3646 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
3647 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
3649 make_keepalive(kalive
, 1, 10000, 10000);
3650 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
3651 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
3653 make_keepalive(kalive
, 1, 100, 100);
3654 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
3655 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
3657 make_keepalive(kalive
, 0, 100, 100);
3658 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
3659 ok(ret
== 0, "WSAIoctl failed unexpectedly\n");
3663 sock
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3664 ok(sock
!= INVALID_SOCKET
, "Creating the socket failed: %d\n", WSAGetLastError());
3666 /* test FIONREAD with a fresh and non-connected socket */
3668 ret
= ioctlsocket(sock
, FIONREAD
, &arg
);
3669 ok(ret
== 0, "ioctlsocket failed unexpectedly with error %d\n", WSAGetLastError());
3670 ok(arg
== 0, "expected 0, got %u\n", arg
);
3672 memset(&address
, 0, sizeof(address
));
3673 address
.sin_family
= AF_INET
;
3674 address
.sin_addr
.s_addr
= inet_addr( SERVERIP
);
3675 address
.sin_port
= htons( SERVERPORT
);
3676 ret
= bind(sock
, (struct sockaddr
*)&address
, sizeof(address
));
3677 ok(ret
== 0, "bind failed unexpectedly with error %d\n", WSAGetLastError());
3679 ret
= listen(sock
, SOMAXCONN
);
3680 ok(ret
== 0, "listen failed unexpectedly with error %d\n", WSAGetLastError());
3682 /* test FIONREAD with listening socket */
3684 ret
= ioctlsocket(sock
, FIONREAD
, &arg
);
3685 ok(ret
== 0, "ioctlsocket failed unexpectedly with error %d\n", WSAGetLastError());
3686 ok(arg
== 0, "expected 0, got %u\n", arg
);
3690 tcp_socketpair(&src
, &dst
);
3692 /* test FIONREAD on TCP sockets */
3693 optval
= 0xdeadbeef;
3694 ret
= WSAIoctl(dst
, FIONREAD
, NULL
, 0, &optval
, sizeof(optval
), &arg
, NULL
, NULL
);
3695 ok(ret
== 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
3696 ok(optval
== 0, "FIONREAD should have returned 0 bytes, got %d instead\n", optval
);
3698 optval
= 0xdeadbeef;
3699 ok(send(src
, "TEST", 4, 0) == 4, "failed to send test data\n");
3701 ret
= WSAIoctl(dst
, FIONREAD
, NULL
, 0, &optval
, sizeof(optval
), &arg
, NULL
, NULL
);
3702 ok(ret
== 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
3703 ok(optval
== 4, "FIONREAD should have returned 4 bytes, got %d instead\n", optval
);
3705 /* trying to read from an OOB inlined socket with MSG_OOB results in WSAEINVAL */
3706 set_blocking(dst
, FALSE
);
3708 SetLastError(0xdeadbeef);
3709 ret
= recv(dst
, &data
, 1, i
);
3710 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
3711 ret
= GetLastError();
3712 ok(ret
== WSAEWOULDBLOCK
, "expected 10035, got %d\n", ret
);
3713 bufs
.len
= sizeof(char);
3715 ret
= WSARecv(dst
, &bufs
, 1, &bytes_rec
, &i
, NULL
, NULL
);
3716 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
3717 ret
= GetLastError();
3718 ok(ret
== WSAEWOULDBLOCK
, "expected 10035, got %d\n", ret
);
3720 ret
= setsockopt(dst
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&optval
, sizeof(optval
));
3721 ok(ret
!= SOCKET_ERROR
, "setsockopt failed unexpectedly\n");
3723 SetLastError(0xdeadbeef);
3724 ret
= recv(dst
, &data
, 1, i
);
3725 ok(ret
== SOCKET_ERROR
, "expected SOCKET_ERROR, got %d\n", ret
);
3726 ret
= GetLastError();
3727 ok(ret
== WSAEINVAL
, "expected 10022, got %d\n", ret
);
3728 bufs
.len
= sizeof(char);
3730 ret
= WSARecv(dst
, &bufs
, 1, &bytes_rec
, &i
, NULL
, NULL
);
3731 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
3732 ret
= GetLastError();
3733 ok(ret
== WSAEINVAL
, "expected 10022, got %d\n", ret
);
3736 optval
= 0xdeadbeef;
3737 ret
= WSAIoctl(dst
, FIONREAD
, NULL
, 0, &optval
, sizeof(optval
), &arg
, NULL
, NULL
);
3738 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
3739 ok(optval
== 0xdeadbeef, "FIONREAD should not have changed last error, got %d instead\n", optval
);
3743 static BOOL drain_pause
= FALSE
;
3744 static DWORD WINAPI
drain_socket_thread(LPVOID arg
)
3747 SOCKET sock
= *(SOCKET
*)arg
;
3750 while ((ret
= recv(sock
, buffer
, sizeof(buffer
), 0)) != 0)
3754 if (WSAGetLastError() == WSAEWOULDBLOCK
)
3758 FD_SET(sock
, &readset
);
3759 select(sock
+1, &readset
, NULL
, NULL
, NULL
);
3770 static void test_send(void)
3772 SOCKET src
= INVALID_SOCKET
;
3773 SOCKET dst
= INVALID_SOCKET
;
3774 HANDLE hThread
= NULL
;
3775 const int buflen
= 1024*1024;
3776 char *buffer
= NULL
;
3777 int ret
, i
, zero
= 0;
3781 DWORD id
, bytes_sent
, dwRet
;
3783 memset(&ov
, 0, sizeof(ov
));
3785 tcp_socketpair(&src
, &dst
);
3787 set_blocking(dst
, FALSE
);
3788 /* force disable buffering so we can get a pending overlapped request */
3789 ret
= setsockopt(dst
, SOL_SOCKET
, SO_SNDBUF
, (char *) &zero
, sizeof(zero
));
3790 ok(!ret
, "setsockopt SO_SNDBUF failed: %d - %d\n", ret
, GetLastError());
3792 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
3794 buffer
= HeapAlloc(GetProcessHeap(), 0, buflen
);
3796 /* fill the buffer with some nonsense */
3797 for (i
= 0; i
< buflen
; ++i
)
3799 buffer
[i
] = (char) i
;
3802 ret
= send(src
, buffer
, buflen
, 0);
3803 ok(ret
== buflen
, "send should have sent %d bytes, but it only sent %d\n", buflen
, ret
);
3808 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
3809 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
3814 WSASetLastError(12345);
3815 ret
= WSASend(dst
, &buf
, 1, &bytes_sent
, 0, &ov
, NULL
);
3816 ok(ret
== SOCKET_ERROR
, "expected failure\n");
3817 ok(WSAGetLastError() == ERROR_IO_PENDING
, "wrong error %u\n", WSAGetLastError());
3819 /* don't check for completion yet, we may need to drain the buffer while still sending */
3820 set_blocking(src
, FALSE
);
3821 for (i
= 0; i
< buflen
; ++i
)
3825 ret
= recv(src
, buffer
, 1, 0);
3826 while (ret
== SOCKET_ERROR
&& GetLastError() == WSAEWOULDBLOCK
&& j
< 100)
3830 ret
= recv(src
, buffer
, 1, 0);
3833 ok(ret
== 1, "Failed to receive data %d - %d (got %d/%d)\n", ret
, GetLastError(), i
, buflen
);
3837 ok(buffer
[0] == (char) i
, "Received bad data at position %d\n", i
);
3840 dwRet
= WaitForSingleObject(ov
.hEvent
, 1000);
3841 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
3842 if (dwRet
== WAIT_OBJECT_0
)
3844 bret
= GetOverlappedResult((HANDLE
)dst
, &ov
, &bytes_sent
, FALSE
);
3845 ok(bret
&& bytes_sent
== buflen
,
3846 "Got %d instead of %d (%d - %d)\n", bytes_sent
, buflen
, bret
, GetLastError());
3849 WSASetLastError(12345);
3850 ret
= WSASend(INVALID_SOCKET
, &buf
, 1, NULL
, 0, &ov
, NULL
);
3851 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
3852 "WSASend failed %d - %d\n", ret
, WSAGetLastError());
3854 WSASetLastError(12345);
3855 ret
= WSASend(dst
, &buf
, 1, NULL
, 0, &ov
, NULL
);
3856 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == ERROR_IO_PENDING
,
3857 "Failed to start overlapped send %d - %d\n", ret
, WSAGetLastError());
3860 if (src
!= INVALID_SOCKET
)
3862 if (dst
!= INVALID_SOCKET
)
3864 if (hThread
!= NULL
)
3866 dwRet
= WaitForSingleObject(hThread
, 500);
3867 ok(dwRet
== WAIT_OBJECT_0
, "failed to wait for thread termination: %d\n", GetLastError());
3868 CloseHandle(hThread
);
3871 CloseHandle(ov
.hEvent
);
3872 HeapFree(GetProcessHeap(), 0, buffer
);
3875 #define WM_SOCKET (WM_USER+100)
3877 struct event_test_ctx
3885 static void select_events(struct event_test_ctx
*ctx
, SOCKET socket
, LONG events
)
3889 if (ctx
->is_message
)
3890 ret
= WSAAsyncSelect(socket
, ctx
->window
, WM_USER
, events
);
3892 ret
= WSAEventSelect(socket
, ctx
->event
, events
);
3893 ok(!ret
, "failed to select, error %u\n", WSAGetLastError());
3894 ctx
->socket
= socket
;
3897 #define check_events(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, FALSE)
3898 #define check_events_todo(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, TRUE)
3899 #define check_events_todo_event(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, FALSE)
3900 #define check_events_todo_msg(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, TRUE)
3901 static void check_events_(int line
, struct event_test_ctx
*ctx
,
3902 LONG flag1
, LONG flag2
, DWORD timeout
, BOOL todo_event
, BOOL todo_msg
)
3906 if (ctx
->is_message
)
3908 BOOL any_fail
= FALSE
;
3913 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
3914 while (!ret
&& !MsgWaitForMultipleObjects(0, NULL
, FALSE
, timeout
, QS_POSTMESSAGE
))
3915 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
3916 todo_wine_if (todo_msg
&& !ret
) ok_(__FILE__
, line
)(ret
, "expected a message\n");
3919 ok_(__FILE__
, line
)(msg
.wParam
== ctx
->socket
,
3920 "expected wparam %#Ix, got %#Ix\n", ctx
->socket
, msg
.wParam
);
3921 todo_wine_if (todo_msg
&& msg
.lParam
!= flag1
)
3922 ok_(__FILE__
, line
)(msg
.lParam
== flag1
, "got first event %#Ix\n", msg
.lParam
);
3923 if (msg
.lParam
!= flag1
) any_fail
= TRUE
;
3930 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
3931 while (!ret
&& !MsgWaitForMultipleObjects(0, NULL
, FALSE
, timeout
, QS_POSTMESSAGE
))
3932 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
3933 ok_(__FILE__
, line
)(ret
, "expected a message\n");
3934 ok_(__FILE__
, line
)(msg
.wParam
== ctx
->socket
, "got wparam %#Ix\n", msg
.wParam
);
3935 todo_wine_if (todo_msg
) ok_(__FILE__
, line
)(msg
.lParam
== flag2
, "got second event %#Ix\n", msg
.lParam
);
3937 ret
= PeekMessageA(&msg
, ctx
->window
, WM_USER
, WM_USER
, PM_REMOVE
);
3938 todo_wine_if (todo_msg
&& ret
) ok_(__FILE__
, line
)(!ret
, "got unexpected event %#Ix\n", msg
.lParam
);
3939 if (ret
) any_fail
= TRUE
;
3941 /* catch tests which succeed */
3942 todo_wine_if (todo_msg
) ok_(__FILE__
, line
)(!any_fail
, "event series matches\n");
3946 WSANETWORKEVENTS events
;
3948 ret
= WaitForSingleObject(ctx
->event
, timeout
);
3950 todo_wine_if (todo_event
&& ret
) ok_(__FILE__
, line
)(!ret
, "event wait timed out\n");
3952 todo_wine_if (todo_event
) ok_(__FILE__
, line
)(ret
== WAIT_TIMEOUT
, "expected timeout\n");
3953 ret
= WSAEnumNetworkEvents(ctx
->socket
, ctx
->event
, &events
);
3954 ok_(__FILE__
, line
)(!ret
, "failed to get events, error %u\n", WSAGetLastError());
3955 todo_wine_if (todo_event
)
3956 ok_(__FILE__
, line
)(events
.lNetworkEvents
== (flag1
| flag2
), "got events %#x\n", events
.lNetworkEvents
);
3960 static void test_accept_events(struct event_test_ctx
*ctx
)
3962 const struct sockaddr_in addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
3963 SOCKET listener
, server
, client
, client2
;
3964 struct sockaddr_in destaddr
;
3967 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3968 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
3970 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
3972 ret
= bind(listener
, (const struct sockaddr
*)&addr
, sizeof(addr
));
3973 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
3974 len
= sizeof(destaddr
);
3975 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &len
);
3976 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
3977 ret
= listen(listener
, 2);
3978 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
3980 check_events(ctx
, 0, 0, 0);
3982 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3983 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
3984 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
3985 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
3987 check_events(ctx
, FD_ACCEPT
, 0, 200);
3988 check_events(ctx
, 0, 0, 0);
3989 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
3990 if (ctx
->is_message
)
3991 check_events(ctx
, FD_ACCEPT
, 0, 200);
3992 check_events(ctx
, 0, 0, 0);
3993 select_events(ctx
, listener
, 0);
3994 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
3995 if (ctx
->is_message
)
3996 check_events(ctx
, FD_ACCEPT
, 0, 200);
3997 check_events(ctx
, 0, 0, 0);
3999 client2
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4000 ok(client2
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4001 ret
= connect(client2
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4002 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4004 if (!ctx
->is_message
)
4005 check_events_todo(ctx
, FD_ACCEPT
, 0, 200);
4006 check_events(ctx
, 0, 0, 0);
4008 server
= accept(listener
, NULL
, NULL
);
4009 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4010 closesocket(server
);
4012 check_events(ctx
, FD_ACCEPT
, 0, 200);
4013 check_events(ctx
, 0, 0, 0);
4015 server
= accept(listener
, NULL
, NULL
);
4016 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4017 closesocket(server
);
4019 check_events(ctx
, 0, 0, 0);
4021 closesocket(client2
);
4022 closesocket(client
);
4024 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4025 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4026 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4027 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4029 check_events(ctx
, FD_ACCEPT
, 0, 200);
4031 server
= accept(listener
, NULL
, NULL
);
4032 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4033 closesocket(server
);
4034 closesocket(client
);
4036 check_events(ctx
, 0, 0, 200);
4038 closesocket(listener
);
4040 /* Connect and then select. */
4042 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4043 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4044 ret
= bind(listener
, (const struct sockaddr
*)&addr
, sizeof(addr
));
4045 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
4046 len
= sizeof(destaddr
);
4047 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &len
);
4048 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
4049 ret
= listen(listener
, 2);
4050 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
4052 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4053 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4054 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4055 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4057 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
4059 check_events(ctx
, FD_ACCEPT
, 0, 200);
4061 server
= accept(listener
, NULL
, NULL
);
4062 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4063 closesocket(server
);
4064 closesocket(client
);
4066 /* As above, but select on a subset not containing FD_ACCEPT first. */
4068 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
);
4070 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4071 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4072 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4073 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4075 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
4076 check_events(ctx
, FD_ACCEPT
, 0, 200);
4078 server
= accept(listener
, NULL
, NULL
);
4079 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4080 closesocket(server
);
4081 closesocket(client
);
4083 /* As above, but call accept() before selecting. */
4085 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
);
4087 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4088 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4089 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4090 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4092 server
= accept(listener
, NULL
, NULL
);
4093 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4095 select_events(ctx
, listener
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_ACCEPT
);
4096 check_events(ctx
, 0, 0, 200);
4098 closesocket(server
);
4099 closesocket(client
);
4101 closesocket(listener
);
4104 static void test_connect_events(struct event_test_ctx
*ctx
)
4106 const struct sockaddr_in addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
4107 SOCKET listener
, server
, client
;
4108 struct sockaddr_in destaddr
;
4111 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4112 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4113 ret
= bind(listener
, (const struct sockaddr
*)&addr
, sizeof(addr
));
4114 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
4115 len
= sizeof(destaddr
);
4116 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &len
);
4117 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
4118 ret
= listen(listener
, 2);
4119 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
4121 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4122 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4124 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4125 check_events(ctx
, 0, 0, 0);
4127 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4128 ok(!ret
|| WSAGetLastError() == WSAEWOULDBLOCK
, "failed to connect, error %u\n", WSAGetLastError());
4130 check_events(ctx
, FD_CONNECT
, FD_WRITE
, 200);
4131 check_events(ctx
, 0, 0, 0);
4132 select_events(ctx
, client
, 0);
4133 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4134 if (ctx
->is_message
)
4135 check_events(ctx
, FD_WRITE
, 0, 200);
4136 check_events(ctx
, 0, 0, 0);
4138 server
= accept(listener
, NULL
, NULL
);
4139 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4141 closesocket(client
);
4142 closesocket(server
);
4144 /* Connect and then select. */
4146 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4147 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4149 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4150 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
4152 server
= accept(listener
, NULL
, NULL
);
4153 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4155 ret
= send(client
, "data", 5, 0);
4156 ok(ret
== 5, "got %d\n", ret
);
4158 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4159 if (ctx
->is_message
)
4160 check_events(ctx
, FD_WRITE
, 0, 200);
4162 check_events(ctx
, FD_CONNECT
, FD_WRITE
, 200);
4164 closesocket(client
);
4165 closesocket(server
);
4167 /* As above, but select on a subset not containing FD_CONNECT first. */
4169 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4170 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
4172 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_OOB
| FD_READ
| FD_WRITE
);
4174 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
4175 ok(!ret
|| WSAGetLastError() == WSAEWOULDBLOCK
, "failed to connect, error %u\n", WSAGetLastError());
4177 server
= accept(listener
, NULL
, NULL
);
4178 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
4180 check_events(ctx
, FD_WRITE
, 0, 200);
4182 select_events(ctx
, client
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4184 if (ctx
->is_message
)
4185 check_events(ctx
, FD_WRITE
, 0, 200);
4187 check_events_todo(ctx
, FD_CONNECT
, 0, 200);
4189 closesocket(client
);
4190 closesocket(server
);
4192 closesocket(listener
);
4195 /* perform a blocking recv() even on a nonblocking socket */
4196 static int sync_recv(SOCKET s
, void *buffer
, int len
, DWORD flags
)
4198 OVERLAPPED overlapped
= {0};
4203 overlapped
.hEvent
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
4204 wsabuf
.buf
= buffer
;
4206 ret
= WSARecv(s
, &wsabuf
, 1, &ret_len
, &flags
, &overlapped
, NULL
);
4207 if (ret
== -1 && WSAGetLastError() == ERROR_IO_PENDING
)
4209 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
4210 ok(!ret
, "wait timed out\n");
4211 ret
= WSAGetOverlappedResult(s
, &overlapped
, &ret_len
, FALSE
, &flags
);
4212 ret
= (ret
? 0 : -1);
4214 CloseHandle(overlapped
.hEvent
);
4215 if (!ret
) return ret_len
;
4219 static void test_write_events(struct event_test_ctx
*ctx
)
4221 static const int buffer_size
= 1024 * 1024;
4222 SOCKET server
, client
;
4226 buffer
= malloc(buffer_size
);
4228 tcp_socketpair(&client
, &server
);
4229 set_blocking(client
, FALSE
);
4231 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4232 check_events(ctx
, FD_WRITE
, 0, 200);
4233 check_events(ctx
, 0, 0, 0);
4234 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4235 if (ctx
->is_message
)
4236 check_events(ctx
, FD_WRITE
, 0, 200);
4237 check_events(ctx
, 0, 0, 0);
4238 select_events(ctx
, server
, 0);
4239 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4240 if (ctx
->is_message
)
4241 check_events(ctx
, FD_WRITE
, 0, 200);
4242 check_events(ctx
, 0, 0, 0);
4244 ret
= send(server
, "data", 5, 0);
4245 ok(ret
== 5, "got %d\n", ret
);
4247 check_events(ctx
, 0, 0, 0);
4249 ret
= sync_recv(client
, buffer
, buffer_size
, 0);
4250 ok(ret
== 5, "got %d\n", ret
);
4252 check_events(ctx
, 0, 0, 0);
4256 while (send(server
, buffer
, buffer_size
, 0) == buffer_size
);
4257 todo_wine
ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
4259 while (recv(client
, buffer
, buffer_size
, 0) > 0);
4260 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
4262 /* Broken on Windows versions older than win10v1607 (though sometimes
4263 * works regardless, for unclear reasons. */
4264 check_events(ctx
, FD_WRITE
, 0, 200);
4265 check_events(ctx
, 0, 0, 0);
4266 select_events(ctx
, server
, 0);
4267 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4268 if (ctx
->is_message
)
4269 check_events(ctx
, FD_WRITE
, 0, 200);
4270 check_events(ctx
, 0, 0, 0);
4273 closesocket(server
);
4274 closesocket(client
);
4276 /* Despite the documentation, and unlike FD_ACCEPT and FD_RECV, calling
4277 * send() doesn't clear the FD_WRITE bit. */
4279 tcp_socketpair(&client
, &server
);
4281 select_events(ctx
, server
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
| FD_WRITE
);
4283 ret
= send(server
, "data", 5, 0);
4284 ok(ret
== 5, "got %d\n", ret
);
4286 check_events(ctx
, FD_WRITE
, 0, 200);
4288 closesocket(server
);
4289 closesocket(client
);
4294 static void test_read_events(struct event_test_ctx
*ctx
)
4296 SOCKET server
, client
;
4301 tcp_socketpair(&client
, &server
);
4302 set_blocking(client
, FALSE
);
4304 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
4305 check_events(ctx
, 0, 0, 0);
4307 ret
= send(client
, "data", 5, 0);
4308 ok(ret
== 5, "got %d\n", ret
);
4310 check_events(ctx
, FD_READ
, 0, 200);
4311 check_events(ctx
, 0, 0, 0);
4312 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
4313 if (ctx
->is_message
)
4314 check_events(ctx
, FD_READ
, 0, 200);
4315 check_events(ctx
, 0, 0, 0);
4316 select_events(ctx
, server
, 0);
4317 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
4318 if (ctx
->is_message
)
4319 check_events(ctx
, FD_READ
, 0, 200);
4320 check_events(ctx
, 0, 0, 0);
4322 ret
= send(client
, "data", 5, 0);
4323 ok(ret
== 5, "got %d\n", ret
);
4325 if (!ctx
->is_message
)
4326 check_events_todo(ctx
, FD_READ
, 0, 200);
4327 check_events(ctx
, 0, 0, 0);
4329 ret
= recv(server
, buffer
, 2, 0);
4330 ok(ret
== 2, "got %d\n", ret
);
4332 check_events(ctx
, FD_READ
, 0, 200);
4333 check_events(ctx
, 0, 0, 0);
4335 ret
= recv(server
, buffer
, -1, 0);
4336 ok(ret
== -1, "got %d\n", ret
);
4337 ok(WSAGetLastError() == WSAEFAULT
|| WSAGetLastError() == WSAENOBUFS
/* < Windows 7 */,
4338 "got error %u\n", WSAGetLastError());
4340 if (ctx
->is_message
)
4341 check_events_todo_msg(ctx
, FD_READ
, 0, 200);
4342 check_events(ctx
, 0, 0, 0);
4344 for (i
= 0; i
< 8; ++i
)
4346 ret
= sync_recv(server
, buffer
, 1, 0);
4347 ok(ret
== 1, "got %d\n", ret
);
4350 check_events(ctx
, FD_READ
, 0, 200);
4351 check_events(ctx
, 0, 0, 0);
4354 /* Send data while we're not selecting. */
4356 select_events(ctx
, server
, 0);
4357 ret
= send(client
, "data", 5, 0);
4358 ok(ret
== 5, "got %d\n", ret
);
4359 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
4361 check_events(ctx
, FD_READ
, 0, 200);
4363 ret
= recv(server
, buffer
, 5, 0);
4364 ok(ret
== 5, "got %d\n", ret
);
4366 select_events(ctx
, server
, 0);
4367 ret
= send(client
, "data", 5, 0);
4368 ok(ret
== 5, "got %d\n", ret
);
4369 ret
= sync_recv(server
, buffer
, 5, 0);
4370 ok(ret
== 5, "got %d\n", ret
);
4371 select_events(ctx
, server
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
);
4373 check_events(ctx
, 0, 0, 200);
4375 closesocket(server
);
4376 closesocket(client
);
4379 static void test_oob_events(struct event_test_ctx
*ctx
)
4381 SOCKET server
, client
;
4385 tcp_socketpair(&client
, &server
);
4386 set_blocking(client
, FALSE
);
4388 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
4389 check_events(ctx
, 0, 0, 0);
4391 ret
= send(client
, "a", 1, MSG_OOB
);
4392 ok(ret
== 1, "got %d\n", ret
);
4394 check_events(ctx
, FD_OOB
, 0, 200);
4395 check_events(ctx
, 0, 0, 0);
4396 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
4397 if (ctx
->is_message
)
4398 check_events(ctx
, FD_OOB
, 0, 200);
4399 check_events(ctx
, 0, 0, 0);
4400 select_events(ctx
, server
, 0);
4401 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
4402 if (ctx
->is_message
)
4403 check_events(ctx
, FD_OOB
, 0, 200);
4404 check_events(ctx
, 0, 0, 0);
4406 ret
= send(client
, "b", 1, MSG_OOB
);
4407 ok(ret
== 1, "got %d\n", ret
);
4409 if (!ctx
->is_message
)
4410 check_events_todo_event(ctx
, FD_OOB
, 0, 200);
4411 check_events(ctx
, 0, 0, 0);
4413 ret
= recv(server
, buffer
, 1, MSG_OOB
);
4414 ok(ret
== 1, "got %d\n", ret
);
4416 check_events_todo(ctx
, FD_OOB
, 0, 200);
4417 check_events(ctx
, 0, 0, 0);
4419 ret
= recv(server
, buffer
, 1, MSG_OOB
);
4420 todo_wine
ok(ret
== 1, "got %d\n", ret
);
4422 check_events(ctx
, 0, 0, 0);
4424 /* Send data while we're not selecting. */
4426 select_events(ctx
, server
, 0);
4427 ret
= send(client
, "a", 1, MSG_OOB
);
4428 ok(ret
== 1, "got %d\n", ret
);
4429 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
4431 check_events(ctx
, FD_OOB
, 0, 200);
4433 ret
= recv(server
, buffer
, 1, MSG_OOB
);
4434 ok(ret
== 1, "got %d\n", ret
);
4436 closesocket(server
);
4437 closesocket(client
);
4440 static void test_close_events(struct event_test_ctx
*ctx
)
4442 SOCKET server
, client
;
4446 /* Test closesocket(). */
4448 tcp_socketpair(&client
, &server
);
4450 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
4452 closesocket(client
);
4454 check_events(ctx
, FD_CLOSE
, 0, 200);
4455 check_events(ctx
, 0, 0, 0);
4456 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
4457 if (ctx
->is_message
)
4458 check_events(ctx
, FD_CLOSE
, 0, 200);
4459 check_events(ctx
, 0, 0, 0);
4460 select_events(ctx
, server
, 0);
4461 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
4462 if (ctx
->is_message
)
4463 check_events(ctx
, FD_CLOSE
, 0, 200);
4464 check_events(ctx
, 0, 0, 0);
4466 ret
= recv(server
, buffer
, 5, 0);
4467 ok(!ret
, "got %d\n", ret
);
4469 check_events(ctx
, 0, 0, 0);
4471 closesocket(server
);
4473 /* Test shutdown(remote end, SD_SEND). */
4475 tcp_socketpair(&client
, &server
);
4477 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
4479 shutdown(client
, SD_SEND
);
4481 check_events(ctx
, FD_CLOSE
, 0, 200);
4482 check_events(ctx
, 0, 0, 0);
4484 closesocket(client
);
4486 check_events(ctx
, 0, 0, 0);
4488 closesocket(server
);
4490 /* No other shutdown() call generates an event. */
4492 tcp_socketpair(&client
, &server
);
4494 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
4496 shutdown(client
, SD_RECEIVE
);
4497 shutdown(server
, SD_BOTH
);
4499 check_events(ctx
, 0, 0, 200);
4501 shutdown(client
, SD_SEND
);
4503 check_events_todo(ctx
, FD_CLOSE
, 0, 200);
4504 check_events(ctx
, 0, 0, 0);
4506 closesocket(server
);
4507 closesocket(client
);
4509 /* Test sending data before calling closesocket(). */
4511 tcp_socketpair(&client
, &server
);
4513 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
4515 ret
= send(client
, "data", 5, 0);
4516 ok(ret
== 5, "got %d\n", ret
);
4518 check_events(ctx
, FD_READ
, 0, 200);
4520 closesocket(client
);
4522 check_events_todo(ctx
, FD_CLOSE
, 0, 200);
4524 ret
= recv(server
, buffer
, 3, 0);
4525 ok(ret
== 3, "got %d\n", ret
);
4527 check_events(ctx
, FD_READ
, 0, 200);
4529 ret
= recv(server
, buffer
, 5, 0);
4530 ok(ret
== 2, "got %d\n", ret
);
4532 check_events_todo(ctx
, 0, 0, 0);
4534 closesocket(server
);
4536 /* Close and then select. */
4538 tcp_socketpair(&client
, &server
);
4539 closesocket(client
);
4541 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
4542 check_events(ctx
, FD_CLOSE
, 0, 200);
4544 closesocket(server
);
4546 /* As above, but select on a subset not containing FD_CLOSE first. */
4548 tcp_socketpair(&client
, &server
);
4550 select_events(ctx
, server
, FD_ACCEPT
| FD_CONNECT
| FD_OOB
| FD_READ
);
4552 closesocket(client
);
4554 check_events(ctx
, 0, 0, 200);
4555 select_events(ctx
, server
, FD_ACCEPT
| FD_CLOSE
| FD_CONNECT
| FD_OOB
| FD_READ
);
4556 check_events_todo_event(ctx
, FD_CLOSE
, 0, 200);
4558 closesocket(server
);
4561 static void test_events(void)
4563 struct event_test_ctx ctx
;
4565 ctx
.is_message
= FALSE
;
4566 ctx
.event
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
4568 test_accept_events(&ctx
);
4569 test_connect_events(&ctx
);
4570 test_write_events(&ctx
);
4571 test_read_events(&ctx
);
4572 test_close_events(&ctx
);
4573 test_oob_events(&ctx
);
4575 CloseHandle(ctx
.event
);
4577 ctx
.is_message
= TRUE
;
4578 ctx
.window
= CreateWindowA("Message", NULL
, 0, 0, 0, 0, 0, HWND_MESSAGE
, NULL
, NULL
, NULL
);
4580 test_accept_events(&ctx
);
4581 test_connect_events(&ctx
);
4582 test_write_events(&ctx
);
4583 test_read_events(&ctx
);
4584 test_close_events(&ctx
);
4585 test_oob_events(&ctx
);
4587 DestroyWindow(ctx
.window
);
4590 static void test_ipv6only(void)
4592 SOCKET v4
= INVALID_SOCKET
, v6
;
4593 struct sockaddr_in sin4
;
4594 struct sockaddr_in6 sin6
;
4595 int ret
, enabled
, len
= sizeof(enabled
);
4597 memset(&sin4
, 0, sizeof(sin4
));
4598 sin4
.sin_family
= AF_INET
;
4599 sin4
.sin_port
= htons(SERVERPORT
);
4601 memset(&sin6
, 0, sizeof(sin6
));
4602 sin6
.sin6_family
= AF_INET6
;
4603 sin6
.sin6_port
= htons(SERVERPORT
);
4605 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
4606 if (v6
== INVALID_SOCKET
)
4608 skip("Could not create IPv6 socket (LastError: %d)\n", WSAGetLastError());
4613 ret
= getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
4614 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
4615 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
4617 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
4618 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
4620 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4621 ok(v4
!= INVALID_SOCKET
, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
4625 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
4626 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
4627 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
4631 len
= sizeof(enabled
);
4632 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
4633 ok(!ret
, "setsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
4637 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
4638 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
4639 ok(!enabled
, "expected 0, got %d\n", enabled
);
4643 len
= sizeof(enabled
);
4644 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
4645 ok(!ret
, "setsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
4647 /* bind on IPv4 socket should succeed - IPV6_V6ONLY is enabled by default */
4648 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
4649 ok(!ret
, "Could not bind IPv4 address (LastError: %d)\n", WSAGetLastError());
4653 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
4654 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
4655 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
4659 len
= sizeof(enabled
);
4660 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
4661 ok(ret
, "setsockopt(IPV6_ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
4665 ret
= getsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
4666 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
4667 ok(enabled
== 1, "expected 1, got %d\n", enabled
);
4671 len
= sizeof(enabled
);
4672 ret
= setsockopt(v4
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
4673 ok(ret
, "setsockopt(IPV6_ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
4678 /* Test again, this time disabling IPV6_V6ONLY. */
4679 sin4
.sin_port
= htons(SERVERPORT
+2);
4680 sin6
.sin6_port
= htons(SERVERPORT
+2);
4682 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
4683 ok(v6
!= INVALID_SOCKET
, "Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
4684 WSAGetLastError(), WSAEAFNOSUPPORT
);
4687 ret
= setsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, len
);
4688 ok(!ret
, "Could not disable IPV6_V6ONLY (LastError: %d).\n", WSAGetLastError());
4691 ret
= getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
4692 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
4693 ok(!enabled
, "expected 0, got %d\n", enabled
);
4697 On Windows, bind on both IPv4 and IPv6 with IPV6_V6ONLY disabled succeeds by default.
4698 Application must set SO_EXCLUSIVEADDRUSE on first socket to disallow another successful bind.
4699 In general, a standard application should not use SO_REUSEADDR.
4700 Setting both SO_EXCLUSIVEADDRUSE and SO_REUSEADDR on the same socket is not possible in
4701 either order, the later setsockopt call always fails.
4704 ret
= setsockopt(v6
, SOL_SOCKET
, SO_EXCLUSIVEADDRUSE
, (char*)&enabled
, len
);
4705 ok(!ret
, "Could not set SO_EXCLUSIVEADDRUSE on IPv6 socket (LastError: %d)\n", WSAGetLastError());
4707 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
4708 ok(!ret
, "Could not bind IPv6 address (LastError: %d)\n", WSAGetLastError());
4711 len
= sizeof(enabled
);
4712 getsockopt(v6
, IPPROTO_IPV6
, IPV6_V6ONLY
, (char*)&enabled
, &len
);
4713 ok(!ret
, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
4714 ok(!enabled
, "IPV6_V6ONLY is enabled after bind\n");
4716 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4717 ok(v4
!= INVALID_SOCKET
, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
4720 ret
= setsockopt(v4
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&enabled
, len
);
4721 ok(!ret
, "Could not set SO_REUSEADDR on IPv4 socket (LastError: %d)\n", WSAGetLastError());
4723 WSASetLastError(0xdeadbeef);
4724 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
4725 ok(ret
, "bind succeeded unexpectedly for the IPv4 socket\n");
4726 ok(WSAGetLastError() == WSAEACCES
, "Expected 10013, got %d\n", WSAGetLastError());
4729 if (v4
!= INVALID_SOCKET
)
4731 if (v6
!= INVALID_SOCKET
)
4735 static void test_WSASendMsg(void)
4738 struct sockaddr_in sendaddr
, sockaddr
;
4739 GUID WSASendMsg_GUID
= WSAID_WSASENDMSG
;
4740 LPFN_WSASENDMSG pWSASendMsg
= NULL
;
4741 char teststr
[12] = "hello world", buffer
[32];
4744 DWORD bytesSent
, err
;
4747 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
4749 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
4750 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
4752 /* Obtain the WSASendMsg function */
4753 WSAIoctl(sock
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSASendMsg_GUID
, sizeof(WSASendMsg_GUID
),
4754 &pWSASendMsg
, sizeof(pWSASendMsg
), &err
, NULL
, NULL
);
4758 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
4762 /* fake address for now */
4763 sendaddr
.sin_family
= AF_INET
;
4764 sendaddr
.sin_port
= htons(139);
4765 sendaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4767 memset(&msg
, 0, sizeof(msg
));
4768 iovec
[0].buf
= teststr
;
4769 iovec
[0].len
= sizeof(teststr
);
4770 iovec
[1].buf
= teststr
;
4771 iovec
[1].len
= sizeof(teststr
) / 2;
4772 msg
.name
= (struct sockaddr
*) &sendaddr
;
4773 msg
.namelen
= sizeof(sendaddr
);
4774 msg
.lpBuffers
= iovec
;
4775 msg
.dwBufferCount
= 1; /* send only one buffer for now */
4777 WSASetLastError(0xdeadbeef);
4778 ret
= pWSASendMsg(INVALID_SOCKET
, &msg
, 0, NULL
, NULL
, NULL
);
4779 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
4780 err
= WSAGetLastError();
4781 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
4783 WSASetLastError(0xdeadbeef);
4784 ret
= pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
);
4785 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
4786 err
= WSAGetLastError();
4787 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
4789 WSASetLastError(0xdeadbeef);
4790 ret
= pWSASendMsg(sock
, NULL
, 0, &bytesSent
, NULL
, NULL
);
4791 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
4792 err
= WSAGetLastError();
4793 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
4795 WSASetLastError(0xdeadbeef);
4796 ret
= pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
);
4797 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
4798 err
= WSAGetLastError();
4799 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
4803 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
4804 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
4806 dst
= socket(AF_INET
, SOCK_DGRAM
, 0);
4807 ok(dst
!= INVALID_SOCKET
, "socket() failed\n");
4809 memset(&sockaddr
, 0, sizeof(sockaddr
));
4810 sockaddr
.sin_family
= AF_INET
;
4811 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4812 ok(!bind(dst
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
)),
4813 "bind should have worked\n");
4815 /* read address to find out the port number to be used in send */
4816 memset(&sendaddr
, 0, sizeof(sendaddr
));
4817 addrlen
= sizeof(sendaddr
);
4818 ok(!getsockname(dst
, (struct sockaddr
*) &sendaddr
, &addrlen
),
4819 "getsockname should have worked\n");
4820 ok(sendaddr
.sin_port
, "socket port should be != 0\n");
4822 /* ensure the sending socket is not bound */
4823 WSASetLastError(0xdeadbeef);
4824 addrlen
= sizeof(sockaddr
);
4825 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
4826 ok(ret
== SOCKET_ERROR
, "getsockname should have failed\n");
4827 err
= WSAGetLastError();
4828 ok(err
== WSAEINVAL
, "expected 10022, got %d instead\n", err
);
4830 set_blocking(sock
, TRUE
);
4833 SetLastError(0xdeadbeef);
4834 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
4835 ok(!ret
, "WSASendMsg should have worked\n");
4836 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
4837 "Expected 0, got %d\n", GetLastError());
4838 ok(bytesSent
== iovec
[0].len
, "incorrect bytes sent, expected %d, sent %d\n",
4839 iovec
[0].len
, bytesSent
);
4842 addrlen
= sizeof(sockaddr
);
4843 memset(buffer
, 0, sizeof(buffer
));
4844 SetLastError(0xdeadbeef);
4845 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
4846 ok(ret
== bytesSent
, "got %d, expected %d\n",
4848 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
4850 /* A successful call to WSASendMsg must have bound the socket */
4851 addrlen
= sizeof(sockaddr
);
4852 sockaddr
.sin_port
= 0;
4853 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4854 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
4855 ok(!ret
, "getsockname should have worked\n");
4856 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
4857 inet_ntoa(sockaddr
.sin_addr
));
4858 ok(sockaddr
.sin_port
, "sin_port should be != 0\n");
4860 msg
.dwBufferCount
= 2; /* send both buffers */
4863 SetLastError(0xdeadbeef);
4864 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
4865 ok(!ret
, "WSASendMsg should have worked\n");
4866 ok(bytesSent
== iovec
[0].len
+ iovec
[1].len
, "incorrect bytes sent, expected %d, sent %d\n",
4867 iovec
[0].len
+ iovec
[1].len
, bytesSent
);
4868 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
4869 "Expected 0, got %d\n", GetLastError());
4872 addrlen
= sizeof(sockaddr
);
4873 memset(buffer
, 0, sizeof(buffer
));
4874 SetLastError(0xdeadbeef);
4875 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
4876 ok(ret
== bytesSent
, "got %d, expected %d\n",
4878 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
4883 /* a bad call to WSASendMsg will also bind the socket */
4884 addrlen
= sizeof(sockaddr
);
4885 sockaddr
.sin_port
= 0;
4886 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4887 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
4888 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
4889 ok(pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
4891 ok(!getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have worked\n");
4892 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
4893 inet_ntoa(sockaddr
.sin_addr
));
4894 ok(sockaddr
.sin_port
, "sin_port should be > 0\n");
4898 /* a bad call without msg parameter will not trigger the auto-bind */
4899 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
4900 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
4901 ok(pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
4902 ok(getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have failed\n");
4903 err
= WSAGetLastError();
4904 ok(err
== WSAEINVAL
, "expected 10022, got %d instead\n", err
);
4907 /* SOCK_STREAM sockets are not supported */
4909 sock
= socket(AF_INET
, SOCK_STREAM
, 0);
4910 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
4911 SetLastError(0xdeadbeef);
4912 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
4913 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
4914 err
= WSAGetLastError();
4916 ok(err
== WSAEINVAL
, "expected 10014, got %d instead\n", err
);
4920 static void test_WSASendTo(void)
4923 struct sockaddr_in addr
;
4924 char buf
[12] = "hello world";
4929 addr
.sin_family
= AF_INET
;
4930 addr
.sin_port
= htons(139);
4931 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4932 data_buf
.len
= sizeof(buf
);
4935 s
= socket(AF_INET
, SOCK_DGRAM
, 0);
4936 ok(s
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
4938 WSASetLastError(12345);
4939 ret
= WSASendTo(INVALID_SOCKET
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
4940 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
4941 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
4943 WSASetLastError(12345);
4944 ret
= WSASendTo(s
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
4945 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
4946 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
4948 WSASetLastError(12345);
4949 ret
= WSASendTo(s
, &data_buf
, 1, &bytesSent
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
4950 ok(!ret
, "expected success\n");
4951 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4954 static DWORD WINAPI
recv_thread(LPVOID arg
)
4956 SOCKET sock
= *(SOCKET
*)arg
;
4963 wsa
.len
= sizeof(buffer
);
4964 ov
.hEvent
= WSACreateEvent();
4965 WSARecv(sock
, &wsa
, 1, NULL
, &flags
, &ov
, NULL
);
4967 WaitForSingleObject(ov
.hEvent
, 1000);
4968 WSACloseEvent(ov
.hEvent
);
4972 static int completion_called
;
4974 static void WINAPI
io_completion(DWORD error
, DWORD transferred
, WSAOVERLAPPED
*overlapped
, DWORD flags
)
4976 completion_called
++;
4979 static void test_WSARecv(void)
4981 SOCKET src
, dest
, server
= INVALID_SOCKET
;
4985 DWORD bytesReturned
, flags
, id
;
4987 struct sockaddr_in addr
;
4991 HANDLE thread
, event
= NULL
, io_port
;
4993 tcp_socketpair(&src
, &dest
);
4995 memset(&ov
, 0, sizeof(ov
));
5000 /* Send 4 bytes and receive in two calls of 2 */
5001 SetLastError(0xdeadbeef);
5002 iret
= send(src
, "test", 4, 0);
5003 ok(iret
== 4, "Expected 4, got %d\n", iret
);
5004 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5005 SetLastError(0xdeadbeef);
5006 bytesReturned
= 0xdeadbeef;
5007 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
5008 ok(!iret
, "Expected 0, got %d\n", iret
);
5009 ok(bytesReturned
== 2, "Expected 2, got %d\n", bytesReturned
);
5010 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5011 SetLastError(0xdeadbeef);
5012 bytesReturned
= 0xdeadbeef;
5013 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
5014 ok(!iret
, "Expected 0, got %d\n", iret
);
5015 ok(bytesReturned
== 2, "Expected 2, got %d\n", bytesReturned
);
5016 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5019 SetLastError(0xdeadbeef);
5020 iret
= send(src
, "test", 4, 0);
5021 ok(iret
== 4, "Expected 4, got %d\n", iret
);
5022 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5023 SetLastError(0xdeadbeef);
5024 bytesReturned
= 0xdeadbeef;
5025 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
5026 ok(!iret
, "Expected 0, got %d\n", iret
);
5027 ok(bytesReturned
== 4, "Expected 4, got %d\n", bytesReturned
);
5028 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5030 /* Test 2 buffers */
5033 bufs
[1].buf
= buf
+ 10;
5034 SetLastError(0xdeadbeef);
5035 iret
= send(src
, "deadbeefs", 9, 0);
5036 ok(iret
== 9, "Expected 9, got %d\n", iret
);
5037 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5038 SetLastError(0xdeadbeef);
5039 bytesReturned
= 0xdeadbeef;
5040 iret
= WSARecv(dest
, bufs
, 2, &bytesReturned
, &flags
, NULL
, NULL
);
5041 ok(!iret
, "Expected 0, got %d\n", iret
);
5042 ok(bytesReturned
== 9, "Expected 9, got %d\n", bytesReturned
);
5043 bufs
[0].buf
[4] = '\0';
5044 bufs
[1].buf
[5] = '\0';
5045 ok(!strcmp(bufs
[0].buf
, "dead"), "buf[0] doesn't match: %s != dead\n", bufs
[0].buf
);
5046 ok(!strcmp(bufs
[1].buf
, "beefs"), "buf[1] doesn't match: %s != beefs\n", bufs
[1].buf
);
5047 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5049 bufs
[0].len
= sizeof(buf
);
5050 ov
.hEvent
= event
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5051 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
5057 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
5058 ok(!iret
, "Failed to set linger %d\n", GetLastError());
5060 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, NULL
);
5061 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
5063 iret
= WSARecv(dest
, bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
5064 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
5067 src
= INVALID_SOCKET
;
5069 dwret
= WaitForSingleObject(ov
.hEvent
, 1000);
5070 ok(dwret
== WAIT_OBJECT_0
, "Waiting for disconnect event failed with %d + errno %d\n", dwret
, GetLastError());
5072 bret
= GetOverlappedResult((HANDLE
)dest
, &ov
, &bytesReturned
, FALSE
);
5073 todo_wine
ok(!bret
, "expected failure\n");
5074 todo_wine
ok(GetLastError() == ERROR_NETNAME_DELETED
, "got error %u\n", GetLastError());
5075 ok(bytesReturned
== 0, "Bytes received is %d\n", bytesReturned
);
5077 dest
= INVALID_SOCKET
;
5079 src
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
5080 ok(src
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
5081 if (src
== INVALID_SOCKET
) goto end
;
5083 server
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
5084 ok(server
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
5085 if (server
== INVALID_SOCKET
) goto end
;
5087 memset(&addr
, 0, sizeof(addr
));
5088 addr
.sin_family
= AF_INET
;
5089 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5090 iret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
5091 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
5094 iret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
5095 ok(!iret
, "failed to get address, error %u\n", WSAGetLastError());
5097 iret
= listen(server
, 1);
5098 ok(!iret
, "failed to listen, error %u\n", WSAGetLastError());
5100 iret
= connect(src
, (struct sockaddr
*)&addr
, sizeof(addr
));
5101 ok(!iret
, "failed to connect, error %u\n", WSAGetLastError());
5104 dest
= accept(server
, (struct sockaddr
*)&addr
, &len
);
5105 ok(dest
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
5106 if (dest
== INVALID_SOCKET
) goto end
;
5108 send(src
, "test message", sizeof("test message"), 0);
5109 thread
= CreateThread(NULL
, 0, recv_thread
, &dest
, 0, &id
);
5110 WaitForSingleObject(thread
, 3000);
5111 CloseHandle(thread
);
5113 memset(&ov
, 0, sizeof(ov
));
5116 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, io_completion
);
5117 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
5118 send(src
, "test message", sizeof("test message"), 0);
5120 completion_called
= 0;
5121 dwret
= SleepEx(1000, TRUE
);
5122 ok(dwret
== WAIT_IO_COMPLETION
, "got %u\n", dwret
);
5123 ok(completion_called
== 1, "completion not called\n");
5125 dwret
= WaitForSingleObject(event
, 1);
5126 ok(dwret
== WAIT_TIMEOUT
, "got %u\n", dwret
);
5128 io_port
= CreateIoCompletionPort( (HANDLE
)dest
, NULL
, 0, 0 );
5129 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
5131 /* Using completion function on socket associated with completion port is not allowed. */
5132 memset(&ov
, 0, sizeof(ov
));
5133 completion_called
= 0;
5134 iret
= WSARecv(dest
, bufs
, 1, NULL
, &flags
, &ov
, io_completion
);
5135 ok(iret
== SOCKET_ERROR
&& GetLastError() == WSAEINVAL
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
5136 ok(!completion_called
, "completion called\n");
5138 CloseHandle(io_port
);
5141 if (server
!= INVALID_SOCKET
)
5142 closesocket(server
);
5143 if (dest
!= INVALID_SOCKET
)
5145 if (src
!= INVALID_SOCKET
)
5148 WSACloseEvent(event
);
5151 struct write_watch_thread_args
5160 static DWORD CALLBACK
write_watch_thread( void *arg
)
5162 struct write_watch_thread_args
*args
= arg
;
5163 struct sockaddr addr
;
5164 int addr_len
= sizeof(addr
), ret
;
5165 DWORD bytes
, flags
= 0;
5171 ret
= recv( args
->dest
, args
->base
, args
->size
, 0 );
5172 ok( ret
== strlen(args
->expect
) + 1, "wrong len %d\n", ret
);
5173 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
5176 ret
= recvfrom( args
->dest
, args
->base
, args
->size
, 0, &addr
, &addr_len
);
5177 ok( ret
== strlen(args
->expect
) + 1, "wrong len %d\n", ret
);
5178 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
5181 buf
[0].len
= args
->size
;
5182 buf
[0].buf
= args
->base
;
5183 ret
= WSARecv( args
->dest
, buf
, 1, &bytes
, &flags
, NULL
, NULL
);
5184 ok( !ret
, "WSARecv failed %u\n", GetLastError() );
5185 ok( bytes
== strlen(args
->expect
) + 1, "wrong len %d\n", bytes
);
5186 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
5189 buf
[0].len
= args
->size
;
5190 buf
[0].buf
= args
->base
;
5191 ret
= WSARecvFrom( args
->dest
, buf
, 1, &bytes
, &flags
, &addr
, &addr_len
, NULL
, NULL
);
5192 ok( !ret
, "WSARecvFrom failed %u\n", GetLastError() );
5193 ok( bytes
== strlen(args
->expect
) + 1, "wrong len %d\n", bytes
);
5194 ok( !strcmp( args
->base
, args
->expect
), "wrong data\n" );
5200 static void test_write_watch(void)
5205 struct write_watch_thread_args args
;
5206 DWORD bytesReturned
, flags
, size
;
5207 struct sockaddr addr
;
5209 HANDLE thread
, event
;
5214 UINT (WINAPI
*pGetWriteWatch
)(DWORD
,LPVOID
,SIZE_T
,LPVOID
*,ULONG_PTR
*,ULONG
*);
5216 pGetWriteWatch
= (void *)GetProcAddress( GetModuleHandleA("kernel32.dll"), "GetWriteWatch" );
5217 if (!pGetWriteWatch
)
5219 win_skip( "write watched not supported\n" );
5223 tcp_socketpair(&src
, &dest
);
5225 memset(&ov
, 0, sizeof(ov
));
5226 ov
.hEvent
= event
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5227 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
5232 base
= VirtualAlloc( 0, size
, MEM_RESERVE
| MEM_COMMIT
| MEM_WRITE_WATCH
, PAGE_READWRITE
);
5233 ok( base
!= NULL
, "VirtualAlloc failed %u\n", GetLastError() );
5235 memset( base
, 0, size
);
5237 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
5238 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
5239 ok( count
== 16, "wrong count %lu\n", count
);
5243 bufs
[1].len
= 0x8000;
5244 bufs
[1].buf
= base
+ 0x4000;
5246 ret
= WSARecv( dest
, bufs
, 2, NULL
, &flags
, &ov
, NULL
);
5247 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
5248 "WSARecv failed - %d error %d\n", ret
, GetLastError());
5251 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
5252 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
5253 ok( count
== 9, "wrong count %lu\n", count
);
5254 ok( !base
[0], "data set\n" );
5256 send(src
, "test message", sizeof("test message"), 0);
5258 ret
= GetOverlappedResult( (HANDLE
)dest
, &ov
, &bytesReturned
, TRUE
);
5259 ok( ret
, "GetOverlappedResult failed %u\n", GetLastError() );
5260 ok( bytesReturned
== sizeof("test message"), "wrong size %u\n", bytesReturned
);
5261 ok( !memcmp( base
, "test ", 5 ), "wrong data %s\n", base
);
5262 ok( !memcmp( base
+ 0x4000, "message", 8 ), "wrong data %s\n", base
+ 0x4000 );
5265 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
5266 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
5267 ok( count
== 0, "wrong count %lu\n", count
);
5269 memset( base
, 0, size
);
5271 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
5272 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
5273 ok( count
== 16, "wrong count %lu\n", count
);
5275 bufs
[1].len
= 0x4000;
5276 bufs
[1].buf
= base
+ 0x2000;
5277 ret
= WSARecvFrom( dest
, bufs
, 2, NULL
, &flags
, &addr
, &addr_len
, &ov
, NULL
);
5278 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
5279 "WSARecv failed - %d error %d\n", ret
, GetLastError());
5282 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
5283 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
5284 ok( count
== 5, "wrong count %lu\n", count
);
5285 ok( !base
[0], "data set\n" );
5287 send(src
, "test message", sizeof("test message"), 0);
5289 ret
= GetOverlappedResult( (HANDLE
)dest
, &ov
, &bytesReturned
, TRUE
);
5290 ok( ret
, "GetOverlappedResult failed %u\n", GetLastError() );
5291 ok( bytesReturned
== sizeof("test message"), "wrong size %u\n", bytesReturned
);
5292 ok( !memcmp( base
, "test ", 5 ), "wrong data %s\n", base
);
5293 ok( !memcmp( base
+ 0x2000, "message", 8 ), "wrong data %s\n", base
+ 0x2000 );
5296 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
5297 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
5298 ok( count
== 0, "wrong count %lu\n", count
);
5300 memset( base
, 0, size
);
5302 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
5303 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
5304 ok( count
== 16, "wrong count %lu\n", count
);
5309 args
.expect
= "test message";
5310 for (args
.func
= 0; args
.func
< 4; args
.func
++)
5312 thread
= CreateThread( NULL
, 0, write_watch_thread
, &args
, 0, NULL
);
5316 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
5317 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
5318 ok( count
== 8, "wrong count %lu\n", count
);
5320 send(src
, "test message", sizeof("test message"), 0);
5321 WaitForSingleObject( thread
, 10000 );
5322 CloseHandle( thread
);
5325 ret
= pGetWriteWatch( WRITE_WATCH_FLAG_RESET
, base
, size
, results
, &count
, &pagesize
);
5326 ok( !ret
, "GetWriteWatch failed %u\n", GetLastError() );
5327 ok( count
== 0, "wrong count %lu\n", count
);
5329 WSACloseEvent( event
);
5330 closesocket( dest
);
5332 VirtualFree( base
, 0, MEM_FREE
);
5335 #define check_poll(a, b) check_poll_(__LINE__, a, POLLRDNORM | POLLRDBAND | POLLWRNORM, b, FALSE)
5336 #define check_poll_todo(a, b) check_poll_(__LINE__, a, POLLRDNORM | POLLRDBAND | POLLWRNORM, b, TRUE)
5337 #define check_poll_mask(a, b, c) check_poll_(__LINE__, a, b, c, FALSE)
5338 #define check_poll_mask_todo(a, b, c) check_poll_(__LINE__, a, b, c, TRUE)
5339 static void check_poll_(int line
, SOCKET s
, short mask
, short expect
, BOOL todo
)
5345 pollfd
.events
= mask
;
5346 pollfd
.revents
= 0xdead;
5347 ret
= pWSAPoll(&pollfd
, 1, 1000);
5348 ok_(__FILE__
, line
)(ret
== (pollfd
.revents
? 1 : 0), "WSAPoll() returned %d\n", ret
);
5349 todo_wine_if (todo
) ok_(__FILE__
, line
)(pollfd
.revents
== expect
, "got wrong events %#x\n", pollfd
.revents
);
5352 static void test_WSAPoll(void)
5354 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
5356 SOCKET listener
, server
, client
;
5357 struct sockaddr_in address
;
5359 HANDLE thread_handle
;
5363 static const short invalid_flags
[] =
5364 {POLLERR
, POLLHUP
, POLLNVAL
, 0x8, POLLWRBAND
, 0x40, 0x80, POLLPRI
, 0x800, 0x1000, 0x2000, 0x4000, 0x8000};
5366 if (!pWSAPoll
) /* >= Vista */
5368 win_skip("WSAPoll is unsupported, some tests will be skipped.\n");
5372 /* Invalid parameters test */
5373 SetLastError(0xdeadbeef);
5374 ret
= pWSAPoll(NULL
, 0, 0);
5375 err
= GetLastError();
5376 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
5377 ok(err
== WSAEINVAL
, "expected 10022, got %d\n", err
);
5378 SetLastError(0xdeadbeef);
5379 ret
= pWSAPoll(NULL
, 1, 0);
5380 err
= GetLastError();
5381 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
5382 ok(err
== WSAEFAULT
, "expected 10014, got %d\n", err
);
5383 SetLastError(0xdeadbeef);
5384 ret
= pWSAPoll(NULL
, 0, 1);
5385 err
= GetLastError();
5386 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
5387 ok(err
== WSAEINVAL
, "expected 10022, got %d\n", err
);
5388 SetLastError(0xdeadbeef);
5389 ret
= pWSAPoll(NULL
, 1, 1);
5390 err
= GetLastError();
5391 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
5392 ok(err
== WSAEFAULT
, "expected 10014, got %d\n", err
);
5394 memset(&address
, 0, sizeof(address
));
5395 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5396 address
.sin_family
= AF_INET
;
5397 len
= sizeof(address
);
5398 listener
= setup_server_socket(&address
, &len
);
5400 for (i
= 0; i
< ARRAY_SIZE(invalid_flags
); ++i
)
5402 fds
[0].fd
= listener
;
5403 fds
[0].events
= invalid_flags
[i
];
5404 fds
[0].revents
= 0xdead;
5405 WSASetLastError(0xdeadbeef);
5406 ret
= pWSAPoll(fds
, 1, 0);
5407 todo_wine
ok(ret
== -1, "got %d\n", ret
);
5408 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
5411 /* When no events are pending poll returns 0 with no error */
5412 fds
[0].fd
= listener
;
5413 fds
[0].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
5414 fds
[0].revents
= 0xdead;
5415 ret
= pWSAPoll(fds
, 1, 0);
5416 ok(ret
== 0, "got %d\n", ret
);
5417 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
5420 fds
[0].events
= POLLERR
;
5421 fds
[0].revents
= 0xdead;
5422 fds
[1].fd
= listener
;
5423 fds
[1].events
= POLLIN
;
5424 fds
[1].revents
= 0xdead;
5425 WSASetLastError(0xdeadbeef);
5426 ret
= pWSAPoll(fds
, 2, 0);
5427 ok(!ret
, "got %d\n", ret
);
5428 todo_wine
ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5429 ok(fds
[0].revents
== POLLNVAL
, "got events %#x\n", fds
[0].revents
);
5430 ok(!fds
[1].revents
, "got events %#x\n", fds
[1].revents
);
5432 fds
[0].fd
= listener
;
5433 fds
[0].events
= POLLIN
;
5434 fds
[0].revents
= 0xdead;
5435 fds
[1].fd
= 0xabacab;
5436 fds
[1].events
= POLLIN
;
5437 fds
[1].revents
= 0xdead;
5438 WSASetLastError(0xdeadbeef);
5439 ret
= pWSAPoll(fds
, 2, 0);
5440 ok(!ret
, "got %d\n", ret
);
5441 todo_wine
ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5442 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
5443 ok(fds
[1].revents
== POLLNVAL
, "got events %#x\n", fds
[1].revents
);
5445 fds
[0].fd
= listener
;
5446 fds
[0].events
= POLLIN
;
5447 fds
[0].revents
= 0xdead;
5448 fds
[1].fd
= 0xabacab;
5449 fds
[1].events
= POLLERR
;
5450 fds
[1].revents
= 0xdead;
5451 WSASetLastError(0xdeadbeef);
5452 ret
= pWSAPoll(fds
, 2, 0);
5453 todo_wine
ok(ret
== -1, "got %d\n", ret
);
5454 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
5455 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
5456 todo_wine
ok(!fds
[1].revents
, "got events %#x\n", fds
[1].revents
);
5459 fds
[0].events
= POLLERR
;
5460 fds
[0].revents
= 0xdead;
5461 fds
[1].fd
= 0xabacab;
5462 fds
[1].events
= POLLERR
;
5463 fds
[1].revents
= 0xdead;
5464 WSASetLastError(0xdeadbeef);
5465 ret
= pWSAPoll(fds
, 2, 0);
5466 todo_wine
ok(ret
== -1, "got %d\n", ret
);
5467 ok(WSAGetLastError() == WSAENOTSOCK
, "got error %u\n", WSAGetLastError());
5468 ok(fds
[0].revents
== POLLNVAL
, "got events %#x\n", fds
[0].revents
);
5469 ok(fds
[1].revents
== POLLNVAL
, "got events %#x\n", fds
[1].revents
);
5471 /* Test listening socket connection attempt notifications */
5472 client
= setup_connector_socket(&address
, len
, TRUE
);
5474 fds
[0].fd
= listener
;
5475 fds
[0].events
= POLLIN
;
5476 fds
[0].revents
= 0xdead;
5477 ret
= pWSAPoll(fds
, 1, 100);
5478 ok(ret
== 1, "got %d\n", ret
);
5479 ok(fds
[0].revents
== POLLRDNORM
, "got events %#x\n", fds
[0].revents
);
5481 fds
[0].revents
= 0xdead;
5482 ret
= pWSAPoll(fds
, 1, 0);
5483 ok(ret
== 1, "got %d\n", ret
);
5484 ok(fds
[0].revents
== POLLRDNORM
, "got events %#x\n", fds
[0].revents
);
5486 fds
[0].events
= POLLRDBAND
| POLLWRNORM
;
5487 fds
[0].revents
= 0xdead;
5488 ret
= pWSAPoll(fds
, 1, 0);
5489 ok(ret
== 0, "got %d\n", ret
);
5490 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
5492 server
= accept(listener
, NULL
, NULL
);
5493 ok(server
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
5494 set_blocking(client
, FALSE
);
5495 set_blocking(server
, FALSE
);
5497 for (i
= 0; i
< ARRAY_SIZE(invalid_flags
); ++i
)
5500 fds
[0].events
= invalid_flags
[i
];
5501 fds
[0].revents
= 0xdead;
5502 WSASetLastError(0xdeadbeef);
5503 ret
= pWSAPoll(fds
, 1, 0);
5504 todo_wine
ok(ret
== -1, "got %d\n", ret
);
5505 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
5508 /* Test flags exposed by connected sockets. */
5510 fds
[0].fd
= listener
;
5511 fds
[0].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
5512 fds
[0].revents
= 0xdead;
5514 fds
[1].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
5515 fds
[1].revents
= 0xdead;
5517 fds
[2].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
5518 fds
[2].revents
= 0xdead;
5519 ret
= pWSAPoll(fds
, 3, 0);
5520 ok(ret
== 2, "got %d\n", ret
);
5521 ok(!fds
[0].revents
, "got events %#x\n", fds
[0].revents
);
5522 ok(fds
[1].revents
== POLLWRNORM
, "got events %#x\n", fds
[1].revents
);
5523 ok(fds
[2].revents
== POLLWRNORM
, "got events %#x\n", fds
[2].revents
);
5525 /* Test data receiving notifications */
5527 ret
= send(server
, "1234", 4, 0);
5528 ok(ret
== 4, "got %d\n", ret
);
5530 check_poll_mask(client
, POLLRDNORM
| POLLRDBAND
, POLLRDNORM
);
5531 check_poll(client
, POLLRDNORM
| POLLWRNORM
);
5532 check_poll(server
, POLLWRNORM
);
5534 ret
= sync_recv(client
, buffer
, sizeof(buffer
), 0);
5535 ok(ret
== 4, "got %d\n", ret
);
5537 check_poll(client
, POLLWRNORM
);
5538 check_poll(server
, POLLWRNORM
);
5540 /* Because the kernel asynchronously buffers data, this test is not reliable. */
5544 static const int large_buffer_size
= 1024 * 1024;
5545 char *large_buffer
= malloc(large_buffer_size
);
5547 while (send(server
, large_buffer
, large_buffer_size
, 0) == large_buffer_size
);
5549 check_poll(client
, POLLWRNORM
| POLLRDNORM
);
5550 check_poll(server
, 0);
5552 while (recv(client
, large_buffer
, large_buffer_size
, 0) > 0);
5554 check_poll(client
, POLLWRNORM
);
5555 check_poll(server
, POLLWRNORM
);
5560 /* Test OOB data notifications */
5562 ret
= send(client
, "A", 1, MSG_OOB
);
5563 ok(ret
== 1, "got %d\n", ret
);
5565 check_poll(client
, POLLWRNORM
);
5566 check_poll_mask(server
, POLLRDNORM
| POLLRDBAND
, POLLRDBAND
);
5567 check_poll(server
, POLLWRNORM
| POLLRDBAND
);
5570 ret
= recv(server
, buffer
, 1, MSG_OOB
);
5571 ok(ret
== 1, "got %d\n", ret
);
5572 ok(buffer
[0] == 'A', "got %#x\n", buffer
[0]);
5574 check_poll(client
, POLLWRNORM
);
5575 check_poll(server
, POLLWRNORM
);
5577 /* If the socket is OOBINLINED the notification is like normal data */
5580 ret
= setsockopt(server
, SOL_SOCKET
, SO_OOBINLINE
, (char *)&ret
, sizeof(ret
));
5581 ok(!ret
, "got error %u\n", WSAGetLastError());
5582 ret
= send(client
, "A", 1, MSG_OOB
);
5583 ok(ret
== 1, "got %d\n", ret
);
5585 check_poll(client
, POLLWRNORM
);
5586 check_poll_mask_todo(server
, POLLRDNORM
| POLLRDBAND
, POLLRDNORM
);
5587 check_poll_todo(server
, POLLWRNORM
| POLLRDNORM
);
5590 ret
= recv(server
, buffer
, 1, 0);
5591 ok(ret
== 1, "got %d\n", ret
);
5592 ok(buffer
[0] == 'A', "got %#x\n", buffer
[0]);
5594 check_poll(client
, POLLWRNORM
);
5595 check_poll_todo(server
, POLLWRNORM
);
5597 /* Test shutdown. */
5599 ret
= shutdown(client
, SD_RECEIVE
);
5600 ok(!ret
, "got error %u\n", WSAGetLastError());
5602 check_poll(client
, POLLWRNORM
);
5603 check_poll_todo(server
, POLLWRNORM
);
5605 ret
= shutdown(client
, SD_SEND
);
5606 ok(!ret
, "got error %u\n", WSAGetLastError());
5608 check_poll(client
, POLLWRNORM
);
5609 check_poll_mask_todo(server
, 0, POLLHUP
);
5610 check_poll_todo(server
, POLLWRNORM
| POLLHUP
);
5612 closesocket(client
);
5613 closesocket(server
);
5615 /* Test shutdown via closesocket(). */
5617 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5618 ret
= connect(client
, (struct sockaddr
*)&address
, sizeof(address
));
5619 ok(!ret
, "got error %u\n", WSAGetLastError());
5620 server
= accept(listener
, NULL
, NULL
);
5621 ok(server
!= -1, "got error %u\n", WSAGetLastError());
5623 closesocket(client
);
5625 check_poll_mask_todo(server
, 0, POLLHUP
);
5626 check_poll_todo(server
, POLLWRNORM
| POLLHUP
);
5628 closesocket(server
);
5630 /* Test shutdown with data in the pipe. */
5632 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5633 ret
= connect(client
, (struct sockaddr
*)&address
, sizeof(address
));
5634 ok(!ret
, "got error %u\n", WSAGetLastError());
5635 server
= accept(listener
, NULL
, NULL
);
5636 ok(server
!= -1, "got error %u\n", WSAGetLastError());
5638 ret
= send(client
, "data", 5, 0);
5639 ok(ret
== 5, "got %d\n", ret
);
5641 check_poll(client
, POLLWRNORM
);
5642 check_poll_mask(server
, POLLRDNORM
| POLLRDBAND
, POLLRDNORM
);
5643 check_poll(server
, POLLWRNORM
| POLLRDNORM
);
5645 ret
= shutdown(client
, SD_SEND
);
5647 check_poll(client
, POLLWRNORM
);
5648 check_poll_mask_todo(server
, 0, POLLHUP
);
5649 check_poll_todo(server
, POLLWRNORM
| POLLRDNORM
| POLLHUP
);
5651 closesocket(client
);
5652 closesocket(server
);
5654 /* Test closing a socket while selecting on it. */
5656 tcp_socketpair(&client
, &server
);
5658 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &client
, 0, NULL
);
5660 fds
[0].events
= POLLRDNORM
| POLLRDBAND
;
5661 fds
[0].revents
= 0xdead;
5662 ret
= pWSAPoll(fds
, 1, 2000);
5663 ok(ret
== 1, "got %d\n", ret
);
5664 ok(fds
[0].revents
== POLLNVAL
, "got events %#x\n", fds
[0].revents
);
5665 ret
= WaitForSingleObject(thread_handle
, 1000);
5666 ok(!ret
, "wait failed\n");
5667 CloseHandle(thread_handle
);
5669 closesocket(server
);
5671 /* Test a failed connection.
5673 * The following WSAPoll() call times out on versions older than w10pro64,
5674 * but even on w10pro64 it takes over 2 seconds for an error to be reported,
5675 * so make the test interactive-only. */
5676 if (winetest_interactive
)
5678 const struct sockaddr_in invalid_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= inet_addr("192.0.2.0")};
5680 client
= setup_connector_socket(&invalid_addr
, sizeof(invalid_addr
), TRUE
);
5683 fds
[0].events
= POLLRDNORM
| POLLRDBAND
| POLLWRNORM
;
5684 fds
[0].revents
= 0xdead;
5685 ret
= pWSAPoll(fds
, 1, 10000);
5686 ok(ret
== 1, "got %d\n", ret
);
5687 ok(fds
[0].revents
== POLLERR
, "got events %#x\n", fds
[0].revents
);
5691 ret
= getsockopt(client
, SOL_SOCKET
, SO_ERROR
, (char *)&err
, &len
);
5692 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
5693 ok(err
== WSAECONNREFUSED
, "expected 10061, got %d\n", err
);
5694 closesocket(client
);
5697 closesocket(listener
);
5699 /* Test UDP sockets. */
5701 client
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
5702 server
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
5704 check_poll(client
, POLLWRNORM
);
5705 check_poll(server
, POLLWRNORM
);
5707 ret
= bind(client
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
5708 ok(!ret
, "got error %u\n", WSAGetLastError());
5709 len
= sizeof(address
);
5710 ret
= getsockname(client
, (struct sockaddr
*)&address
, &len
);
5711 ok(!ret
, "got error %u\n", WSAGetLastError());
5713 check_poll(client
, POLLWRNORM
);
5714 check_poll(server
, POLLWRNORM
);
5716 ret
= sendto(server
, "data", 5, 0, (struct sockaddr
*)&address
, sizeof(address
));
5717 ok(ret
== 5, "got %d\n", ret
);
5719 check_poll_mask(client
, POLLRDNORM
| POLLRDBAND
, POLLRDNORM
);
5720 check_poll(client
, POLLWRNORM
| POLLRDNORM
);
5721 check_poll(server
, POLLWRNORM
);
5723 closesocket(client
);
5724 closesocket(server
);
5727 static void test_ConnectEx(void)
5729 SOCKET listener
= INVALID_SOCKET
;
5730 SOCKET acceptor
= INVALID_SOCKET
;
5731 SOCKET connector
= INVALID_SOCKET
;
5732 struct sockaddr_in address
, conaddress
;
5734 OVERLAPPED overlapped
;
5735 LPFN_CONNECTEX pConnectEx
;
5736 GUID connectExGuid
= WSAID_CONNECTEX
;
5737 DWORD bytesReturned
;
5743 memset(&overlapped
, 0, sizeof(overlapped
));
5745 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
5746 ok(listener
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
5748 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
5749 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
5751 memset(&address
, 0, sizeof(address
));
5752 address
.sin_family
= AF_INET
;
5753 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5754 iret
= bind(listener
, (struct sockaddr
*)&address
, sizeof(address
));
5755 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
5757 addrlen
= sizeof(address
);
5758 iret
= getsockname(listener
, (struct sockaddr
*)&address
, &addrlen
);
5759 ok(!iret
, "failed to get address, error %u\n", WSAGetLastError());
5761 iret
= set_blocking(listener
, TRUE
);
5762 ok(!iret
, "failed to set nonblocking, error %u\n", WSAGetLastError());
5764 bytesReturned
= 0xdeadbeef;
5765 iret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectExGuid
, sizeof(connectExGuid
),
5766 &pConnectEx
, sizeof(pConnectEx
), &bytesReturned
, NULL
, NULL
);
5767 ok(!iret
, "failed to get ConnectEx, error %u\n", WSAGetLastError());
5769 ok(bytesReturned
== sizeof(pConnectEx
), "expected sizeof(pConnectEx), got %u\n", bytesReturned
);
5771 bret
= pConnectEx(INVALID_SOCKET
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
5772 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "ConnectEx on invalid socket "
5773 "returned %d + errno %d\n", bret
, WSAGetLastError());
5775 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
5776 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "ConnectEx on a unbound socket "
5777 "returned %d + errno %d\n", bret
, WSAGetLastError());
5779 /* ConnectEx needs a bound socket */
5780 memset(&conaddress
, 0, sizeof(conaddress
));
5781 conaddress
.sin_family
= AF_INET
;
5782 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5783 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
5784 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
5786 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, NULL
);
5787 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "ConnectEx on a NULL overlapped "
5788 "returned %d + errno %d\n", bret
, WSAGetLastError());
5790 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5792 iret
= listen(listener
, 1);
5793 ok(!iret
, "failed to listen, error %u\n", WSAGetLastError());
5795 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
5796 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
5797 "returned %d + errno %d\n", bret
, WSAGetLastError());
5798 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
5799 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
5801 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
5802 ok(bret
, "Connecting failed, error %d\n", GetLastError());
5803 ok(bytesReturned
== 0, "Bytes sent is %d\n", bytesReturned
);
5805 closesocket(connector
);
5806 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
5807 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
5808 /* ConnectEx needs a bound socket */
5809 memset(&conaddress
, 0, sizeof(conaddress
));
5810 conaddress
.sin_family
= AF_INET
;
5811 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5812 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
5813 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
5815 acceptor
= accept(listener
, NULL
, NULL
);
5816 ok(acceptor
!= INVALID_SOCKET
, "failed to accept socket, error %u\n", WSAGetLastError());
5821 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, buffer
, 3, &bytesReturned
, &overlapped
);
5822 memset(buffer
, 0, 3);
5823 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
5824 "returned %d + errno %d\n", bret
, WSAGetLastError());
5825 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
5826 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
5828 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
5829 ok(bret
, "Connecting failed, error %d\n", GetLastError());
5830 ok(bytesReturned
== 3, "Bytes sent is %d\n", bytesReturned
);
5832 acceptor
= accept(listener
, NULL
, NULL
);
5833 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket error %d\n", WSAGetLastError());
5835 bytesReturned
= recv(acceptor
, buffer
, 3, 0);
5837 ok(bytesReturned
== 3, "Didn't get all sent data, got only %d\n", bytesReturned
);
5838 ok(buffer
[0] == '1' && buffer
[1] == '2' && buffer
[2] == '3',
5839 "Failed to get the right data, expected '123', got '%s'\n", buffer
);
5841 closesocket(connector
);
5842 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
5843 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
5844 /* ConnectEx needs a bound socket */
5845 memset(&conaddress
, 0, sizeof(conaddress
));
5846 conaddress
.sin_family
= AF_INET
;
5847 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5848 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
5849 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
5851 closesocket(acceptor
);
5852 closesocket(listener
);
5854 /* Connect with error */
5856 address
.sin_port
= htons(1);
5858 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
5859 ok(bret
== FALSE
&& GetLastError() == ERROR_IO_PENDING
, "ConnectEx to bad destination failed: "
5860 "returned %d + errno %d\n", bret
, GetLastError());
5861 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
5862 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
5864 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
5865 ok(bret
== FALSE
&& GetLastError() == ERROR_CONNECTION_REFUSED
,
5866 "Connecting to a disconnected host returned error %d - %d\n", bret
, WSAGetLastError());
5868 WSACloseEvent(overlapped
.hEvent
);
5869 closesocket(connector
);
5872 static void test_AcceptEx(void)
5874 SOCKET listener
, acceptor
, acceptor2
, connector
, connector2
;
5875 struct sockaddr_in bindAddress
, peerAddress
, *readBindAddress
, *readRemoteAddress
;
5876 int socklen
, optlen
;
5877 GUID acceptExGuid
= WSAID_ACCEPTEX
, getAcceptExGuid
= WSAID_GETACCEPTEXSOCKADDRS
;
5878 GUID connectex_guid
= WSAID_CONNECTEX
;
5879 LPFN_ACCEPTEX pAcceptEx
= NULL
;
5880 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs
= NULL
;
5881 LPFN_CONNECTEX pConnectEx
= NULL
;
5882 fd_set fds_accept
, fds_send
;
5883 static const struct timeval timeout
= {1, 0};
5884 DWORD bytesReturned
, connect_time
;
5885 char buffer
[1024], ipbuffer
[32];
5886 OVERLAPPED overlapped
= {0}, overlapped2
= {0};
5887 int iret
, localSize
= sizeof(struct sockaddr_in
), remoteSize
= localSize
;
5891 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5892 overlapped2
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5894 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
5895 ok(listener
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
5897 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
5898 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
5900 memset(&bindAddress
, 0, sizeof(bindAddress
));
5901 bindAddress
.sin_family
= AF_INET
;
5902 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5903 iret
= bind(listener
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
5904 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
5906 socklen
= sizeof(bindAddress
);
5907 iret
= getsockname(listener
, (struct sockaddr
*)&bindAddress
, &socklen
);
5908 ok(!iret
, "failed to get address, error %u\n", WSAGetLastError());
5910 iret
= set_blocking(listener
, FALSE
);
5911 ok(!iret
, "Failed to set nonblocking, error %u\n", WSAGetLastError());
5913 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
5914 &pAcceptEx
, sizeof(pAcceptEx
), &bytesReturned
, NULL
, NULL
);
5915 ok(!iret
, "Failed to get AcceptEx, error %u\n", WSAGetLastError());
5917 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &getAcceptExGuid
, sizeof(getAcceptExGuid
),
5918 &pGetAcceptExSockaddrs
, sizeof(pGetAcceptExSockaddrs
), &bytesReturned
, NULL
, NULL
);
5919 ok(!iret
, "Failed to get GetAcceptExSockaddrs, error %u\n", WSAGetLastError());
5921 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectex_guid
, sizeof(connectex_guid
),
5922 &pConnectEx
, sizeof(pConnectEx
), &bytesReturned
, NULL
, NULL
);
5923 ok(!iret
, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
5925 overlapped
.Internal
= 0xdeadbeef;
5926 bret
= pAcceptEx(INVALID_SOCKET
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
5927 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
5928 &bytesReturned
, &overlapped
);
5929 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid listening socket "
5930 "returned %d + errno %d\n", bret
, WSAGetLastError());
5931 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
5933 overlapped
.Internal
= 0xdeadbeef;
5934 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
5935 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
5936 &bytesReturned
, &overlapped
);
5938 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on a non-listening socket "
5939 "returned %d + errno %d\n", bret
, WSAGetLastError());
5940 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
5941 if (!bret
&& WSAGetLastError() == ERROR_IO_PENDING
)
5942 CancelIo((HANDLE
)listener
);
5944 iret
= listen(listener
, 5);
5945 ok(!iret
, "failed to listen, error %u\n", GetLastError());
5947 overlapped
.Internal
= 0xdeadbeef;
5948 bret
= pAcceptEx(listener
, INVALID_SOCKET
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
5949 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
5950 &bytesReturned
, &overlapped
);
5951 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid accepting socket "
5952 "returned %d + errno %d\n", bret
, WSAGetLastError());
5953 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
5955 overlapped
.Internal
= 0xdeadbeef;
5956 bret
= pAcceptEx(listener
, acceptor
, NULL
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
5957 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
5958 &bytesReturned
, &overlapped
);
5959 todo_wine
ok(bret
== FALSE
&& WSAGetLastError() == WSAEFAULT
,
5960 "AcceptEx on NULL buffer returned %d + errno %d\n", bret
, WSAGetLastError());
5961 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
5963 overlapped
.Internal
= 0xdeadbeef;
5964 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16,
5965 &bytesReturned
, &overlapped
);
5966 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
,
5967 "AcceptEx on too small local address size returned %d + errno %d\n",
5968 bret
, WSAGetLastError());
5969 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
5971 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5972 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
5973 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
5974 ok(!iret
, "failed to connect, error %u\n", WSAGetLastError());
5975 iret
= getsockname(connector
, (struct sockaddr
*)&peerAddress
, &remoteSize
);
5976 ok(!iret
, "getsockname failed, error %u\n", WSAGetLastError());
5978 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
5979 ok(!dwret
, "wait failed\n");
5980 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
5981 ok(bret
, "got error %u\n", GetLastError());
5982 ok(!(NTSTATUS
)overlapped
.Internal
, "got %#lx\n", overlapped
.Internal
);
5983 ok(!bytesReturned
, "got size %u\n", bytesReturned
);
5985 readBindAddress
= readRemoteAddress
= (struct sockaddr_in
*)0xdeadbeef;
5986 localSize
= remoteSize
= 0xdeadbeef;
5987 pGetAcceptExSockaddrs(buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16,
5988 (struct sockaddr
**)&readBindAddress
, &localSize
, (struct sockaddr
**)&readRemoteAddress
, &remoteSize
);
5989 todo_wine
ok(readBindAddress
== (struct sockaddr_in
*)0xdeadbeef, "got local addr %p\n", readBindAddress
);
5990 ok(!memcmp(readRemoteAddress
, &peerAddress
, sizeof(peerAddress
)), "remote addr didn't match\n");
5991 todo_wine
ok(localSize
== 0xdeadbeef, "got local size %u\n", localSize
);
5992 ok(remoteSize
== sizeof(struct sockaddr_in
), "got remote size %u\n", remoteSize
);
5994 closesocket(connector
);
5995 closesocket(acceptor
);
5997 acceptor
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5998 ok(acceptor
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6000 overlapped
.Internal
= 0xdeadbeef;
6001 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 3,
6002 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
6003 ok(!bret
&& WSAGetLastError() == ERROR_IO_PENDING
, "got %d, error %u\n", bret
, WSAGetLastError());
6004 ok((NTSTATUS
)overlapped
.Internal
== STATUS_PENDING
, "got %#lx\n", overlapped
.Internal
);
6006 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6007 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6008 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6009 ok(!iret
, "failed to connect, error %u\n", WSAGetLastError());
6011 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6012 ok(!dwret
, "wait failed\n");
6013 bytesReturned
= 0xdeadbeef;
6014 SetLastError(0xdeadbeef);
6015 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6016 ok(!bret
, "expected failure\n");
6017 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER
, "got error %u\n", GetLastError());
6018 ok((NTSTATUS
)overlapped
.Internal
== STATUS_BUFFER_TOO_SMALL
, "got %#lx\n", overlapped
.Internal
);
6019 ok(!bytesReturned
, "got size %u\n", bytesReturned
);
6021 closesocket(acceptor
);
6023 /* The above connection request is not accepted. */
6024 acceptor
= accept(listener
, NULL
, NULL
);
6025 todo_wine
ok(acceptor
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
6026 closesocket(acceptor
);
6028 closesocket(connector
);
6030 acceptor
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6031 ok(acceptor
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6033 overlapped
.Internal
= 0xdeadbeef;
6034 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 4,
6035 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
6036 ok(!bret
&& WSAGetLastError() == ERROR_IO_PENDING
, "got %d, error %u\n", bret
, WSAGetLastError());
6037 ok((NTSTATUS
)overlapped
.Internal
== STATUS_PENDING
, "got %#lx\n", overlapped
.Internal
);
6039 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6040 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6041 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6042 ok(!iret
, "failed to connect, error %u\n", WSAGetLastError());
6044 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6045 ok(!dwret
, "wait failed\n");
6046 bytesReturned
= 0xdeadbeef;
6047 SetLastError(0xdeadbeef);
6048 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6049 todo_wine
ok(!bret
, "expected failure\n");
6050 todo_wine
ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER
, "got error %u\n", GetLastError());
6051 todo_wine
ok((NTSTATUS
)overlapped
.Internal
== STATUS_BUFFER_TOO_SMALL
, "got %#lx\n", overlapped
.Internal
);
6052 ok(!bytesReturned
, "got size %u\n", bytesReturned
);
6054 closesocket(acceptor
);
6056 /* The above connection request is not accepted. */
6057 acceptor
= accept(listener
, NULL
, NULL
);
6058 todo_wine
ok(acceptor
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
6059 closesocket(acceptor
);
6061 closesocket(connector
);
6063 acceptor
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6064 ok(acceptor
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6066 overlapped
.Internal
= 0xdeadbeef;
6067 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 15,
6068 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
6069 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx on too small local address "
6070 "size returned %d + errno %d\n",
6071 bret
, WSAGetLastError());
6072 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6073 bret
= CancelIo((HANDLE
) listener
);
6074 ok(bret
, "Failed to cancel pending accept socket\n");
6076 overlapped
.Internal
= 0xdeadbeef;
6077 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16, 0,
6078 &bytesReturned
, &overlapped
);
6079 ok(bret
== FALSE
&& WSAGetLastError() == WSAEFAULT
,
6080 "AcceptEx on too small remote address size returned %d + errno %d\n", bret
, WSAGetLastError());
6081 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6083 overlapped
.Internal
= 0xdeadbeef;
6084 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16,
6085 sizeof(struct sockaddr_in
) + 15, &bytesReturned
, &overlapped
);
6086 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
,
6087 "AcceptEx on too small remote address size returned %d + errno %d\n", bret
, WSAGetLastError());
6088 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6089 bret
= CancelIo((HANDLE
) listener
);
6090 ok(bret
, "Failed to cancel pending accept socket\n");
6092 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
6093 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6094 &bytesReturned
, NULL
);
6095 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
6096 "returned %d + errno %d\n", bret
, WSAGetLastError());
6098 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, 0, &bytesReturned
, NULL
);
6099 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
6100 "returned %d + errno %d\n", bret
, WSAGetLastError());
6102 overlapped
.Internal
= 0xdeadbeef;
6103 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
6104 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6105 &bytesReturned
, &overlapped
);
6106 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6107 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6109 /* try to accept into the same socket twice */
6110 overlapped
.Internal
= 0xdeadbeef;
6111 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
6112 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6113 &bytesReturned
, &overlapped
);
6114 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
,
6115 "AcceptEx on already pending socket returned %d + errno %d\n", bret
, WSAGetLastError());
6116 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6118 /* try to connect a socket that's being accepted into */
6119 iret
= connect(acceptor
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6120 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEINVAL
,
6121 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret
, WSAGetLastError());
6123 bret
= pConnectEx(acceptor
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
),
6124 NULL
, 0, &bytesReturned
, &overlapped2
);
6125 ok(!bret
, "expected failure\n");
6126 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6128 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6129 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6130 overlapped
.Internal
= 0xdeadbeef;
6131 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6132 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6134 dwret
= WaitForSingleObject(overlapped
.hEvent
, INFINITE
);
6135 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6136 ok(overlapped
.Internal
== STATUS_SUCCESS
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6138 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6139 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
6140 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
6142 closesocket(connector
);
6143 connector
= INVALID_SOCKET
;
6144 closesocket(acceptor
);
6146 /* Test short reads */
6148 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6149 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
6150 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
6151 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
6152 overlapped
.Internal
= 0xdeadbeef;
6153 bret
= pAcceptEx(listener
, acceptor
, buffer
, 2,
6154 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6155 &bytesReturned
, &overlapped
);
6156 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6157 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6159 connect_time
= 0xdeadbeef;
6160 optlen
= sizeof(connect_time
);
6161 iret
= getsockopt(connector
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
6162 ok(!iret
, "getsockopt failed %d\n", WSAGetLastError());
6163 ok(connect_time
== ~0u, "unexpected connect time %u\n", connect_time
);
6165 /* AcceptEx() still won't complete until we send data */
6166 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6167 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6169 connect_time
= 0xdeadbeef;
6170 optlen
= sizeof(connect_time
);
6171 iret
= getsockopt(connector
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
6172 ok(!iret
, "getsockopt failed %d\n", WSAGetLastError());
6173 ok(connect_time
< 0xdeadbeef, "unexpected connect time %u\n", connect_time
);
6175 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
6176 ok(dwret
== WAIT_TIMEOUT
, "Waiting for accept event timeout failed with %d + errno %d\n", dwret
, GetLastError());
6177 ok(overlapped
.Internal
== STATUS_PENDING
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6179 iret
= getsockname( connector
, (struct sockaddr
*)&peerAddress
, &remoteSize
);
6180 ok( !iret
, "getsockname failed.\n");
6182 /* AcceptEx() could complete any time now */
6183 iret
= send(connector
, buffer
, 1, 0);
6184 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
6186 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6187 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6188 ok(overlapped
.Internal
== STATUS_SUCCESS
, "got %08x\n", (ULONG
)overlapped
.Internal
);
6190 /* Check if the buffer from AcceptEx is decoded correctly */
6191 pGetAcceptExSockaddrs(buffer
, 2, sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6192 (struct sockaddr
**)&readBindAddress
, &localSize
,
6193 (struct sockaddr
**)&readRemoteAddress
, &remoteSize
);
6194 strcpy( ipbuffer
, inet_ntoa(readBindAddress
->sin_addr
));
6195 ok( readBindAddress
->sin_addr
.s_addr
== bindAddress
.sin_addr
.s_addr
,
6196 "Local socket address is different %s != %s\n",
6197 ipbuffer
, inet_ntoa(bindAddress
.sin_addr
));
6198 ok( readBindAddress
->sin_port
== bindAddress
.sin_port
,
6199 "Local socket port is different: %d != %d\n",
6200 readBindAddress
->sin_port
, bindAddress
.sin_port
);
6201 strcpy( ipbuffer
, inet_ntoa(readRemoteAddress
->sin_addr
));
6202 ok( readRemoteAddress
->sin_addr
.s_addr
== peerAddress
.sin_addr
.s_addr
,
6203 "Remote socket address is different %s != %s\n",
6204 ipbuffer
, inet_ntoa(peerAddress
.sin_addr
));
6205 ok( readRemoteAddress
->sin_port
== peerAddress
.sin_port
,
6206 "Remote socket port is different: %d != %d\n",
6207 readRemoteAddress
->sin_port
, peerAddress
.sin_port
);
6209 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6210 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
6211 ok(bytesReturned
== 1, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
6213 closesocket(connector
);
6214 connector
= INVALID_SOCKET
;
6215 closesocket(acceptor
);
6217 /* Test CF_DEFER & AcceptEx interaction */
6219 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6220 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
6221 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
6222 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
6223 connector2
= socket(AF_INET
, SOCK_STREAM
, 0);
6224 ok(connector2
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
6226 iret
= set_blocking(connector
, FALSE
);
6227 ok(!iret
, "failed to set nonblocking, error %u\n", GetLastError());
6228 iret
= set_blocking(connector2
, FALSE
);
6229 ok(!iret
, "failed to set nonblocking, error %u\n", GetLastError());
6231 /* Connect socket #1 */
6232 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6233 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6237 FD_ZERO(&fds_accept
);
6238 FD_SET(listener
, &fds_accept
);
6239 iret
= select(0, &fds_accept
, NULL
, NULL
, &timeout
);
6240 ok(iret
== 1, "wait timed out\n");
6242 acceptor2
= WSAAccept(listener
, NULL
, NULL
, AlwaysDeferConditionFunc
, 0);
6243 ok(acceptor2
== INVALID_SOCKET
, "expected failure\n");
6244 ok(WSAGetLastError() == WSATRY_AGAIN
, "got error %u\n", WSAGetLastError());
6245 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16,
6246 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
6247 ok(!bret
, "expected failure\n");
6248 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
6251 FD_SET(connector
, &fds_send
);
6252 iret
= select(0, NULL
, &fds_send
, NULL
, &timeout
);
6253 ok(iret
== 1, "wait timed out\n");
6255 iret
= send(connector
, "1", 1, 0);
6256 ok(iret
== 1, "got ret %d, error %u\n", iret
, WSAGetLastError());
6258 iret
= connect(connector2
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6259 ok(iret
== SOCKET_ERROR
, "expected failure\n");
6260 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
6262 iret
= select(0, &fds_accept
, NULL
, NULL
, &timeout
);
6263 ok(iret
== 1, "wait timed out\n");
6265 acceptor2
= accept(listener
, NULL
, NULL
);
6266 ok(acceptor2
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
6267 closesocket(acceptor2
);
6270 FD_SET(connector2
, &fds_send
);
6271 iret
= select(0, NULL
, &fds_send
, NULL
, &timeout
);
6272 ok(iret
== 1, "wait timed out\n");
6274 iret
= send(connector2
, "2", 1, 0);
6275 ok(iret
== 1, "got ret %d, error %u\n", iret
, WSAGetLastError());
6277 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
6278 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6280 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6281 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
6282 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
6284 set_blocking(acceptor
, TRUE
);
6285 iret
= recv( acceptor
, buffer
, 2, 0);
6286 ok(iret
== 1, "Failed to get data, %d, errno: %d\n", iret
, WSAGetLastError());
6287 ok(buffer
[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer
[0]);
6289 closesocket(connector
);
6290 closesocket(connector2
);
6291 closesocket(acceptor
);
6293 /* clean up in case of failures */
6294 while ((acceptor
= accept(listener
, NULL
, NULL
)) != INVALID_SOCKET
)
6295 closesocket(acceptor
);
6297 /* Disconnect during receive? */
6299 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6300 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
6301 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
6302 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
6303 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6304 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6305 &bytesReturned
, &overlapped
);
6306 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6308 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6309 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6311 closesocket(connector
);
6312 connector
= INVALID_SOCKET
;
6314 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6315 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6317 bytesReturned
= 123456;
6318 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6319 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
6320 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
6322 closesocket(acceptor
);
6324 /* Test closing with pending requests */
6326 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6327 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
6328 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6329 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6330 &bytesReturned
, &overlapped
);
6331 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6333 closesocket(acceptor
);
6335 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6336 ok(dwret
== WAIT_OBJECT_0
,
6337 "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6338 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6339 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
6341 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6342 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
6343 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6344 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6345 &bytesReturned
, &overlapped
);
6346 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6348 CancelIo((HANDLE
) acceptor
);
6350 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6351 ok(dwret
== WAIT_TIMEOUT
, "Waiting for timeout failed with %d + errno %d\n", dwret
, GetLastError());
6353 closesocket(acceptor
);
6355 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6356 ok(acceptor
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
6357 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6358 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6359 &bytesReturned
, &overlapped
);
6360 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6362 closesocket(listener
);
6364 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6365 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6367 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6368 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
6370 CloseHandle(overlapped
.hEvent
);
6371 CloseHandle(overlapped2
.hEvent
);
6372 closesocket(acceptor
);
6373 closesocket(connector2
);
6376 static void test_shutdown(void)
6378 struct sockaddr_in addr
, server_addr
, client_addr
;
6379 SOCKET listener
, client
, server
;
6380 OVERLAPPED overlapped
= {0};
6381 DWORD size
, flags
= 0;
6386 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
6387 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6388 ok(listener
!= INVALID_SOCKET
, "failed to create listener socket, error %d\n", WSAGetLastError());
6390 memset(&addr
, 0, sizeof(addr
));
6391 addr
.sin_family
= AF_INET
;
6392 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6393 ret
= bind(listener
, (struct sockaddr
*)&addr
, sizeof(addr
));
6394 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
6395 addrlen
= sizeof(server_addr
);
6396 ret
= getsockname(listener
, (struct sockaddr
*)&server_addr
, &addrlen
);
6397 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
6399 ret
= listen(listener
, 1);
6400 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
6402 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6403 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6405 WSASetLastError(0xdeadbeef);
6406 ret
= shutdown(client
, SD_SEND
);
6407 ok(ret
== -1, "expected failure\n");
6408 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
6410 WSASetLastError(0xdeadbeef);
6411 ret
= shutdown(client
, SD_RECEIVE
);
6412 ok(ret
== -1, "expected failure\n");
6413 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
6415 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
6416 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
6417 server
= accept(listener
, NULL
, NULL
);
6418 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
6419 set_blocking(client
, FALSE
);
6421 WSASetLastError(0xdeadbeef);
6422 ret
= shutdown(client
, SD_SEND
);
6423 ok(!ret
, "expected success\n");
6424 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
6426 WSASetLastError(0xdeadbeef);
6427 ret
= shutdown(client
, SD_SEND
);
6428 todo_wine
ok(!ret
, "expected success\n");
6429 todo_wine
ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
6431 WSASetLastError(0xdeadbeef);
6432 ret
= send(client
, "test", 5, 0);
6433 ok(ret
== -1, "got %d\n", ret
);
6434 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
6436 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
6437 ok(!ret
, "got %d\n", ret
);
6438 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
6439 ok(!ret
, "got %d\n", ret
);
6441 WSASetLastError(0xdeadbeef);
6442 ret
= shutdown(server
, SD_RECEIVE
);
6443 ok(!ret
, "expected success\n");
6444 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
6446 WSASetLastError(0xdeadbeef);
6447 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
6448 todo_wine
ok(ret
== -1, "got %d\n", ret
);
6449 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
6451 ret
= send(server
, "test", 5, 0);
6452 ok(ret
== 5, "got %d\n", ret
);
6454 ret
= sync_recv(client
, buffer
, sizeof(buffer
), 0);
6455 ok(ret
== 5, "got %d\n", ret
);
6456 ok(!strcmp(buffer
, "test"), "got %s\n", debugstr_an(buffer
, ret
));
6458 WSASetLastError(0xdeadbeef);
6459 ret
= shutdown(client
, SD_RECEIVE
);
6460 ok(!ret
, "expected success\n");
6461 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
6463 WSASetLastError(0xdeadbeef);
6464 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
6465 ok(ret
== -1, "got %d\n", ret
);
6466 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
6468 WSASetLastError(0xdeadbeef);
6469 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
6470 ok(ret
== -1, "got %d\n", ret
);
6471 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
6473 WSASetLastError(0xdeadbeef);
6474 ret
= shutdown(server
, SD_SEND
);
6475 ok(!ret
, "expected success\n");
6476 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
6478 WSASetLastError(0xdeadbeef);
6479 ret
= send(server
, "test", 5, 0);
6480 ok(ret
== -1, "got %d\n", ret
);
6481 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
6483 addrlen
= sizeof(addr
);
6484 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &addrlen
);
6485 todo_wine
ok(!ret
, "got error %u\n", WSAGetLastError());
6486 todo_wine
ok(!memcmp(&addr
, &server_addr
, sizeof(server_addr
)), "address didn't match\n");
6488 addrlen
= sizeof(client_addr
);
6489 ret
= getsockname(client
, (struct sockaddr
*)&client_addr
, &addrlen
);
6490 ok(!ret
, "got error %u\n", WSAGetLastError());
6491 addrlen
= sizeof(addr
);
6492 ret
= getpeername(server
, (struct sockaddr
*)&addr
, &addrlen
);
6493 todo_wine
ok(!ret
, "got error %u\n", WSAGetLastError());
6494 todo_wine
ok(!memcmp(&addr
, &client_addr
, sizeof(addr
)), "address didn't match\n");
6496 WSASetLastError(0xdeadbeef);
6497 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
6498 ok(ret
== -1, "got %d\n", ret
);
6499 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
6501 WSASetLastError(0xdeadbeef);
6502 ret
= shutdown(client
, 0xdeadbeef);
6503 ok(ret
== -1, "expected failure\n");
6504 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
6506 closesocket(client
);
6507 closesocket(server
);
6511 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6512 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6513 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
6514 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
6515 server
= accept(listener
, NULL
, NULL
);
6516 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
6518 WSASetLastError(0xdeadbeef);
6519 ret
= shutdown(client
, SD_BOTH
);
6520 ok(!ret
, "expected success\n");
6521 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
6523 WSASetLastError(0xdeadbeef);
6524 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
6525 ok(ret
== -1, "got %d\n", ret
);
6526 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
6528 WSASetLastError(0xdeadbeef);
6529 ret
= send(client
, "test", 5, 0);
6530 ok(ret
== -1, "got %d\n", ret
);
6531 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
6533 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
6534 ok(!ret
, "got %d\n", ret
);
6536 WSASetLastError(0xdeadbeef);
6537 ret
= shutdown(server
, SD_BOTH
);
6538 ok(!ret
, "expected success\n");
6539 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
6541 WSASetLastError(0xdeadbeef);
6542 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
6543 todo_wine
ok(ret
== -1, "got %d\n", ret
);
6544 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
6546 WSASetLastError(0xdeadbeef);
6547 ret
= send(server
, "test", 5, 0);
6548 ok(ret
== -1, "got %d\n", ret
);
6549 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
6551 addrlen
= sizeof(addr
);
6552 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &addrlen
);
6553 todo_wine
ok(!ret
, "got error %u\n", WSAGetLastError());
6554 todo_wine
ok(!memcmp(&addr
, &server_addr
, sizeof(server_addr
)), "address didn't match\n");
6556 addrlen
= sizeof(client_addr
);
6557 ret
= getsockname(client
, (struct sockaddr
*)&client_addr
, &addrlen
);
6558 ok(!ret
, "got error %u\n", WSAGetLastError());
6559 addrlen
= sizeof(addr
);
6560 ret
= getpeername(server
, (struct sockaddr
*)&addr
, &addrlen
);
6561 todo_wine
ok(!ret
, "got error %u\n", WSAGetLastError());
6562 todo_wine
ok(!memcmp(&addr
, &client_addr
, sizeof(addr
)), "address didn't match\n");
6564 closesocket(client
);
6565 closesocket(server
);
6567 /* Test shutting down with async I/O pending. */
6569 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6570 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6571 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
6572 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
6573 server
= accept(listener
, NULL
, NULL
);
6574 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
6575 set_blocking(client
, FALSE
);
6577 wsabuf
.buf
= buffer
;
6578 wsabuf
.len
= sizeof(buffer
);
6579 WSASetLastError(0xdeadbeef);
6580 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
6581 ok(ret
== -1, "got %d\n", ret
);
6582 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
6584 ret
= shutdown(client
, SD_RECEIVE
);
6585 ok(!ret
, "got error %u\n", WSAGetLastError());
6587 WSASetLastError(0xdeadbeef);
6588 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, NULL
, NULL
);
6589 ok(ret
== -1, "got %d\n", ret
);
6590 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
6592 ret
= send(server
, "test", 5, 0);
6593 ok(ret
== 5, "got %d\n", ret
);
6595 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6596 ok(!ret
, "wait timed out\n");
6598 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
6599 ok(ret
, "got error %u\n", GetLastError());
6600 ok(size
== 5, "got size %u\n", size
);
6601 ok(!strcmp(buffer
, "test"), "got %s\n", debugstr_an(buffer
, size
));
6603 WSASetLastError(0xdeadbeef);
6604 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
6605 ok(ret
== -1, "got %d\n", ret
);
6606 ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
6608 WSASetLastError(0xdeadbeef);
6609 ret
= WSARecv(server
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
6610 ok(ret
== -1, "got %d\n", ret
);
6611 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
6613 ret
= shutdown(client
, SD_SEND
);
6614 ok(!ret
, "got error %u\n", WSAGetLastError());
6616 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6617 ok(!ret
, "wait timed out\n");
6619 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
6620 ok(ret
, "got error %u\n", GetLastError());
6621 ok(!size
, "got size %u\n", size
);
6623 closesocket(client
);
6624 closesocket(server
);
6626 /* Test shutting down a listening socket. */
6628 WSASetLastError(0xdeadbeef);
6629 ret
= shutdown(listener
, SD_SEND
);
6630 ok(ret
== -1, "expected failure\n");
6631 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
6633 WSASetLastError(0xdeadbeef);
6634 ret
= shutdown(listener
, SD_RECEIVE
);
6635 todo_wine
ok(ret
== -1, "expected failure\n");
6636 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
6638 closesocket(listener
);
6640 /* Test shutting down UDP sockets. */
6642 client
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
6643 server
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
6644 memset(&addr
, 0, sizeof(addr
));
6645 addr
.sin_family
= AF_INET
;
6646 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6647 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
6648 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
6649 addrlen
= sizeof(server_addr
);
6650 ret
= getsockname(server
, (struct sockaddr
*)&server_addr
, &addrlen
);
6651 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
6652 set_blocking(server
, FALSE
);
6654 WSASetLastError(0xdeadbeef);
6655 ret
= shutdown(server
, SD_RECEIVE
);
6656 ok(!ret
, "expected success\n");
6657 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
6659 WSASetLastError(0xdeadbeef);
6660 ret
= recvfrom(server
, buffer
, sizeof(buffer
), 0, NULL
, NULL
);
6661 ok(ret
== -1, "got %d\n", ret
);
6662 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
6664 ret
= sendto(client
, "test", 5, 0, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
6665 ok(ret
== 5, "got %d\n", ret
);
6667 WSASetLastError(0xdeadbeef);
6668 ret
= shutdown(client
, SD_SEND
);
6669 ok(!ret
, "expected success\n");
6670 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
6672 WSASetLastError(0xdeadbeef);
6673 ret
= shutdown(client
, SD_SEND
);
6674 todo_wine
ok(!ret
, "expected success\n");
6675 todo_wine
ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
6677 WSASetLastError(0xdeadbeef);
6678 ret
= sendto(client
, "test", 5, 0, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
6679 ok(ret
== -1, "got %d\n", ret
);
6680 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
6682 closesocket(client
);
6683 closesocket(server
);
6685 CloseHandle(overlapped
.hEvent
);
6688 static void test_DisconnectEx(void)
6690 struct sockaddr_in server_addr
, client_addr
, addr
;
6691 GUID disconnectex_guid
= WSAID_DISCONNECTEX
;
6692 SOCKET listener
, server
, client
;
6693 LPFN_DISCONNECTEX pDisconnectEx
;
6694 OVERLAPPED overlapped
= {0};
6699 overlapped
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
6701 client
= socket(AF_INET
, SOCK_STREAM
, 0);
6702 ok(client
!= INVALID_SOCKET
, "failed to create connector socket, error %u\n", WSAGetLastError());
6704 ret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &disconnectex_guid
, sizeof(disconnectex_guid
),
6705 &pDisconnectEx
, sizeof(pDisconnectEx
), &size
, NULL
, NULL
);
6708 win_skip("WSAIoctl failed to get DisconnectEx, error %d\n", WSAGetLastError());
6709 closesocket(client
);
6713 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
6714 ok(listener
!= INVALID_SOCKET
, "failed to create listener socket, error %d\n", WSAGetLastError());
6716 memset(&addr
, 0, sizeof(addr
));
6717 addr
.sin_family
= AF_INET
;
6718 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6719 ret
= bind(listener
, (struct sockaddr
*)&addr
, sizeof(addr
));
6720 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
6721 addrlen
= sizeof(server_addr
);
6722 ret
= getsockname(listener
, (struct sockaddr
*)&server_addr
, &addrlen
);
6723 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
6724 ret
= listen(listener
, 1);
6725 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
6727 WSASetLastError(0xdeadbeef);
6728 ret
= pDisconnectEx(INVALID_SOCKET
, &overlapped
, 0, 0);
6729 ok(!ret
, "expected failure\n");
6730 ok(WSAGetLastError() == WSAENOTSOCK
, "got error %u\n", WSAGetLastError());
6732 WSASetLastError(0xdeadbeef);
6733 ret
= pDisconnectEx(client
, &overlapped
, 0, 0);
6734 ok(!ret
, "expected failure\n");
6735 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got error %u\n", WSAGetLastError());
6737 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
6738 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
6739 server
= accept(listener
, NULL
, NULL
);
6740 ok(server
!= INVALID_SOCKET
, "failed to accept, error %u\n", WSAGetLastError());
6742 WSASetLastError(0xdeadbeef);
6743 ret
= pDisconnectEx(client
, &overlapped
, 0, 0);
6744 todo_wine
ok(!ret
, "expected failure\n");
6745 todo_wine
ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
6747 if (WSAGetLastError() == ERROR_IO_PENDING
)
6749 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6750 ok(!ret
, "wait timed out\n");
6752 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
6753 ok(ret
, "got error %u\n", GetLastError());
6754 ok(!size
, "got size %u\n", size
);
6757 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
6758 ok(ret
== -1, "expected failure\n");
6759 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
6761 WSASetLastError(0xdeadbeef);
6762 ret
= send(client
, "test", 5, 0);
6763 ok(ret
== -1, "expected failure\n");
6764 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
6766 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
6767 ok(!ret
, "got %d\n", ret
);
6769 ret
= send(server
, "test", 5, 0);
6770 ok(ret
== 5, "got %d\n", ret
);
6772 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
6773 ok(ret
== 5, "got %d\n", ret
);
6774 ok(!strcmp(buffer
, "test"), "got %s\n", debugstr_an(buffer
, ret
));
6776 addrlen
= sizeof(addr
);
6777 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &addrlen
);
6778 ok(!ret
, "got error %u\n", WSAGetLastError());
6779 ok(!memcmp(&addr
, &server_addr
, sizeof(server_addr
)), "address didn't match\n");
6781 addrlen
= sizeof(client_addr
);
6782 ret
= getsockname(client
, (struct sockaddr
*)&client_addr
, &addrlen
);
6783 ok(!ret
, "got error %u\n", WSAGetLastError());
6784 addrlen
= sizeof(addr
);
6785 ret
= getpeername(server
, (struct sockaddr
*)&addr
, &addrlen
);
6786 ok(!ret
, "got error %u\n", WSAGetLastError());
6787 ok(!memcmp(&addr
, &client_addr
, sizeof(addr
)), "address didn't match\n");
6789 closesocket(client
);
6790 closesocket(server
);
6792 /* Test the synchronous case. */
6794 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6795 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
6796 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
6797 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
6798 server
= accept(listener
, NULL
, NULL
);
6799 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
6801 WSASetLastError(0xdeadbeef);
6802 ret
= pDisconnectEx(client
, NULL
, 0, 0);
6803 ok(ret
, "expected success\n");
6804 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
6806 WSASetLastError(0xdeadbeef);
6807 ret
= pDisconnectEx(client
, NULL
, 0, 0);
6808 todo_wine
ok(ret
, "expected success\n");
6809 todo_wine
ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
6811 ret
= connect(client
, (struct sockaddr
*)&server_addr
, sizeof(server_addr
));
6812 ok(ret
== -1, "expected failure\n");
6813 ok(WSAGetLastError() == WSAEISCONN
, "got error %u\n", WSAGetLastError());
6815 WSASetLastError(0xdeadbeef);
6816 ret
= send(client
, "test", 5, 0);
6817 ok(ret
== -1, "expected failure\n");
6818 todo_wine
ok(WSAGetLastError() == WSAESHUTDOWN
, "got error %u\n", WSAGetLastError());
6820 ret
= recv(server
, buffer
, sizeof(buffer
), 0);
6821 ok(!ret
, "got %d\n", ret
);
6823 ret
= send(server
, "test", 5, 0);
6824 ok(ret
== 5, "got %d\n", ret
);
6826 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
6827 ok(ret
== 5, "got %d\n", ret
);
6828 ok(!strcmp(buffer
, "test"), "got %s\n", debugstr_an(buffer
, ret
));
6830 addrlen
= sizeof(addr
);
6831 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &addrlen
);
6832 ok(!ret
, "got error %u\n", WSAGetLastError());
6833 ok(!memcmp(&addr
, &server_addr
, sizeof(server_addr
)), "address didn't match\n");
6835 addrlen
= sizeof(client_addr
);
6836 ret
= getsockname(client
, (struct sockaddr
*)&client_addr
, &addrlen
);
6837 ok(!ret
, "got error %u\n", WSAGetLastError());
6838 addrlen
= sizeof(addr
);
6839 ret
= getpeername(server
, (struct sockaddr
*)&addr
, &addrlen
);
6840 ok(!ret
, "got error %u\n", WSAGetLastError());
6841 ok(!memcmp(&addr
, &client_addr
, sizeof(addr
)), "address didn't match\n");
6843 closesocket(client
);
6844 closesocket(server
);
6846 closesocket(listener
);
6847 CloseHandle(overlapped
.hEvent
);
6850 #define compare_file(h,s,o) compare_file2(h,s,o,__FILE__,__LINE__)
6852 static void compare_file2(HANDLE handle
, SOCKET sock
, int offset
, const char *file
, int line
)
6854 char buf1
[256], buf2
[256];
6858 SetFilePointer(handle
, offset
, NULL
, FILE_BEGIN
);
6861 DWORD n1
= 0, n2
= 0;
6863 success
= ReadFile(handle
, buf1
, sizeof(buf1
), &n1
, NULL
);
6864 ok_(file
,line
)(success
, "Failed to read from file.\n");
6865 if (success
&& n1
== 0)
6869 n2
= recv(sock
, buf2
, n1
, 0);
6870 ok_(file
,line
)(n1
== n2
, "Block %d size mismatch (%d != %d)\n", i
, n1
, n2
);
6871 ok_(file
,line
)(memcmp(buf1
, buf2
, n2
) == 0, "Block %d failed\n", i
);
6876 static void test_TransmitFile(void)
6878 DWORD num_bytes
, err
, file_size
, total_sent
;
6879 GUID transmitFileGuid
= WSAID_TRANSMITFILE
;
6880 LPFN_TRANSMITFILE pTransmitFile
= NULL
;
6881 HANDLE file
= INVALID_HANDLE_VALUE
;
6882 char header_msg
[] = "hello world";
6883 char footer_msg
[] = "goodbye!!!";
6884 char system_ini_path
[MAX_PATH
];
6885 struct sockaddr_in bindAddress
;
6886 TRANSMIT_FILE_BUFFERS buffers
;
6887 SOCKET client
, server
, dest
;
6893 memset( &ov
, 0, sizeof(ov
) );
6895 /* Setup sockets for testing TransmitFile */
6896 client
= socket(AF_INET
, SOCK_STREAM
, 0);
6897 ok(client
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
6898 server
= socket(AF_INET
, SOCK_STREAM
, 0);
6899 ok(server
!= INVALID_SOCKET
, "failed to create socket, error %u\n", GetLastError());
6900 iret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &transmitFileGuid
, sizeof(transmitFileGuid
),
6901 &pTransmitFile
, sizeof(pTransmitFile
), &num_bytes
, NULL
, NULL
);
6902 ok(!iret
, "failed to get TransmitFile, error %u\n", GetLastError());
6903 GetSystemWindowsDirectoryA(system_ini_path
, MAX_PATH
);
6904 strcat(system_ini_path
, "\\system.ini");
6905 file
= CreateFileA(system_ini_path
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_ALWAYS
, 0x0, NULL
);
6906 ok(file
!= INVALID_HANDLE_VALUE
, "failed to open file, error %u\n", GetLastError());
6907 file_size
= GetFileSize(file
, NULL
);
6909 /* Test TransmitFile with an invalid socket */
6910 bret
= pTransmitFile(INVALID_SOCKET
, file
, 0, 0, NULL
, NULL
, 0);
6911 err
= WSAGetLastError();
6912 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
6913 ok(err
== WSAENOTSOCK
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTSOCK
);
6915 /* Test a bogus TransmitFile without a connected socket */
6916 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, TF_REUSE_SOCKET
);
6917 err
= WSAGetLastError();
6918 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
6919 ok(err
== WSAENOTCONN
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTCONN
);
6921 /* Setup a properly connected socket for transfers */
6922 memset(&bindAddress
, 0, sizeof(bindAddress
));
6923 bindAddress
.sin_family
= AF_INET
;
6924 bindAddress
.sin_port
= htons(SERVERPORT
+1);
6925 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6926 iret
= bind(server
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6927 ok(!iret
, "failed to bind socket, error %u\n", GetLastError());
6928 iret
= listen(server
, 1);
6929 ok(!iret
, "failed to listen, error %u\n", GetLastError());
6930 iret
= connect(client
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6931 ok(!iret
, "failed to connect, error %u\n", GetLastError());
6932 len
= sizeof(bindAddress
);
6933 dest
= accept(server
, (struct sockaddr
*)&bindAddress
, &len
);
6934 ok(dest
!= INVALID_SOCKET
, "failed to accept, error %u\n", GetLastError());
6935 iret
= set_blocking(dest
, FALSE
);
6936 ok(!iret
, "failed to set nonblocking, error %u\n", GetLastError());
6938 /* Test TransmitFile with no possible buffer */
6939 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, 0);
6940 ok(bret
, "TransmitFile failed unexpectedly.\n");
6941 iret
= recv(dest
, buf
, sizeof(buf
), 0);
6942 ok(iret
== -1, "Returned an unexpected buffer from TransmitFile (%d != -1).\n", iret
);
6944 /* Test TransmitFile with only buffer data */
6945 buffers
.Head
= &header_msg
[0];
6946 buffers
.HeadLength
= sizeof(header_msg
);
6947 buffers
.Tail
= &footer_msg
[0];
6948 buffers
.TailLength
= sizeof(footer_msg
);
6949 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, &buffers
, 0);
6950 ok(bret
, "TransmitFile failed unexpectedly.\n");
6951 iret
= recv(dest
, buf
, sizeof(buf
), 0);
6952 ok(iret
== sizeof(header_msg
)+sizeof(footer_msg
),
6953 "Returned an unexpected buffer from TransmitFile: %d\n", iret
);
6954 ok(memcmp(&buf
[0], &header_msg
[0], sizeof(header_msg
)) == 0,
6955 "TransmitFile header buffer did not match!\n");
6956 ok(memcmp(&buf
[sizeof(header_msg
)], &footer_msg
[0], sizeof(footer_msg
)) == 0,
6957 "TransmitFile footer buffer did not match!\n");
6959 /* Test TransmitFile with only file data */
6960 bret
= pTransmitFile(client
, file
, 0, 0, NULL
, NULL
, 0);
6961 ok(bret
, "TransmitFile failed unexpectedly.\n");
6962 compare_file(file
, dest
, 0);
6964 /* Test TransmitFile with both file and buffer data */
6965 buffers
.Head
= &header_msg
[0];
6966 buffers
.HeadLength
= sizeof(header_msg
);
6967 buffers
.Tail
= &footer_msg
[0];
6968 buffers
.TailLength
= sizeof(footer_msg
);
6969 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
6970 bret
= pTransmitFile(client
, file
, 0, 0, NULL
, &buffers
, 0);
6971 ok(bret
, "TransmitFile failed unexpectedly.\n");
6972 iret
= recv(dest
, buf
, sizeof(header_msg
), 0);
6973 ok(memcmp(buf
, &header_msg
[0], sizeof(header_msg
)) == 0,
6974 "TransmitFile header buffer did not match!\n");
6975 compare_file(file
, dest
, 0);
6976 iret
= recv(dest
, buf
, sizeof(footer_msg
), 0);
6977 ok(memcmp(buf
, &footer_msg
[0], sizeof(footer_msg
)) == 0,
6978 "TransmitFile footer buffer did not match!\n");
6980 /* Test overlapped TransmitFile */
6981 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
6982 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
6983 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, NULL
, 0);
6984 err
= WSAGetLastError();
6985 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
6986 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n",
6987 err
, ERROR_IO_PENDING
);
6988 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
6989 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
6990 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
6991 ok(total_sent
== file_size
,
6992 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
6993 total_sent
, file_size
);
6994 compare_file(file
, dest
, 0);
6996 /* Test overlapped TransmitFile w/ start offset */
6997 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
6998 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
7000 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, NULL
, 0);
7001 err
= WSAGetLastError();
7002 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
7003 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, ERROR_IO_PENDING
);
7004 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
7005 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
7006 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
7007 ok(total_sent
== (file_size
- ov
.Offset
),
7008 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
7009 total_sent
, file_size
- ov
.Offset
);
7010 compare_file(file
, dest
, ov
.Offset
);
7012 /* Test overlapped TransmitFile w/ file and buffer data */
7013 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
7014 buffers
.Head
= &header_msg
[0];
7015 buffers
.HeadLength
= sizeof(header_msg
);
7016 buffers
.Tail
= &footer_msg
[0];
7017 buffers
.TailLength
= sizeof(footer_msg
);
7018 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
7020 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, &buffers
, 0);
7021 err
= WSAGetLastError();
7022 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
7023 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, ERROR_IO_PENDING
);
7024 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
7025 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
7026 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
7027 ok(total_sent
== (file_size
+ buffers
.HeadLength
+ buffers
.TailLength
),
7028 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
7029 total_sent
, file_size
+ buffers
.HeadLength
+ buffers
.TailLength
);
7030 iret
= recv(dest
, buf
, sizeof(header_msg
), 0);
7031 ok(memcmp(buf
, &header_msg
[0], sizeof(header_msg
)) == 0,
7032 "TransmitFile header buffer did not match!\n");
7033 compare_file(file
, dest
, 0);
7034 iret
= recv(dest
, buf
, sizeof(footer_msg
), 0);
7035 ok(memcmp(buf
, &footer_msg
[0], sizeof(footer_msg
)) == 0,
7036 "TransmitFile footer buffer did not match!\n");
7038 /* Test TransmitFile with a UDP datagram socket */
7039 closesocket(client
);
7040 client
= socket(AF_INET
, SOCK_DGRAM
, 0);
7041 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, 0);
7042 err
= WSAGetLastError();
7043 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
7044 ok(err
== WSAENOTCONN
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTCONN
);
7047 CloseHandle(ov
.hEvent
);
7048 closesocket(client
);
7049 closesocket(server
);
7052 static void test_getpeername(void)
7055 struct sockaddr_in sa
, sa_out
;
7056 SOCKADDR_STORAGE ss
;
7058 const char buf
[] = "hello world";
7061 /* Test the parameter validation order. */
7062 ret
= getpeername(INVALID_SOCKET
, NULL
, NULL
);
7063 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
7064 ok(WSAGetLastError() == WSAENOTSOCK
,
7065 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
7067 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
7068 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
7070 ret
= getpeername(sock
, NULL
, NULL
);
7071 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
7072 ok(WSAGetLastError() == WSAENOTCONN
,
7073 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
7075 memset(&sa
, 0, sizeof(sa
));
7076 sa
.sin_family
= AF_INET
;
7077 sa
.sin_port
= htons(139);
7078 sa
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7080 /* sendto does not change a socket's connection state. */
7081 ret
= sendto(sock
, buf
, sizeof(buf
), 0, (struct sockaddr
*)&sa
, sizeof(sa
));
7082 ok(ret
!= SOCKET_ERROR
,
7083 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
7085 ret
= getpeername(sock
, NULL
, NULL
);
7086 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
7087 ok(WSAGetLastError() == WSAENOTCONN
,
7088 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
7090 ret
= connect(sock
, (struct sockaddr
*)&sa
, sizeof(sa
));
7092 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
7094 ret
= getpeername(sock
, NULL
, NULL
);
7095 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
7096 ok(WSAGetLastError() == WSAEFAULT
,
7097 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7099 /* Test crashes on Wine. */
7102 ret
= getpeername(sock
, (void*)0xdeadbeef, (void*)0xcafebabe);
7103 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
7104 ok(WSAGetLastError() == WSAEFAULT
,
7105 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7108 ret
= getpeername(sock
, (struct sockaddr
*)&sa_out
, NULL
);
7109 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
7110 ok(WSAGetLastError() == WSAEFAULT
,
7111 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7114 ret
= getpeername(sock
, NULL
, &sa_len
);
7115 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
7116 ok(WSAGetLastError() == WSAEFAULT
,
7117 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7118 ok(!sa_len
, "got %d\n", sa_len
);
7121 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
7122 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
7123 ok(WSAGetLastError() == WSAEFAULT
,
7124 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7125 ok(!sa_len
, "got %d\n", sa_len
);
7127 sa_len
= sizeof(ss
);
7128 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
7129 ok(ret
== 0, "Expected getpeername to return 0, got %d\n", ret
);
7130 ok(!memcmp(&sa
, &ss
, sizeof(sa
)),
7131 "Expected the returned structure to be identical to the connect structure\n");
7132 ok(sa_len
== sizeof(sa
), "got %d\n", sa_len
);
7137 static void test_sioRoutingInterfaceQuery(void)
7141 SOCKADDR_IN sin
= { 0 }, sout
= { 0 };
7142 DWORD bytesReturned
;
7144 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
7145 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
7146 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, NULL
, 0, NULL
, 0, NULL
,
7148 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
7149 "expected WSAEFAULT, got %d\n", WSAGetLastError());
7150 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
7151 NULL
, 0, NULL
, NULL
, NULL
);
7152 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
7153 "expected WSAEFAULT, got %d\n", WSAGetLastError());
7154 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
7155 NULL
, 0, &bytesReturned
, NULL
, NULL
);
7156 todo_wine
ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEAFNOSUPPORT
,
7157 "expected WSAEAFNOSUPPORT, got %d\n", WSAGetLastError());
7158 sin
.sin_family
= AF_INET
;
7159 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
7160 NULL
, 0, &bytesReturned
, NULL
, NULL
);
7161 todo_wine
ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEINVAL
,
7162 "expected WSAEINVAL, got %d\n", WSAGetLastError());
7163 sin
.sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
7164 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
7165 NULL
, 0, &bytesReturned
, NULL
, NULL
);
7166 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
7167 "expected WSAEFAULT, got %d\n", WSAGetLastError());
7168 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
7169 &sout
, sizeof(sout
), &bytesReturned
, NULL
, NULL
);
7170 ok(!ret
, "WSAIoctl failed: %d\n", WSAGetLastError());
7171 ok(sout
.sin_family
== AF_INET
, "expected AF_INET, got %d\n", sout
.sin_family
);
7172 /* We expect the source address to be INADDR_LOOPBACK as well, but
7173 * there's no guarantee that a route to the loopback address exists,
7174 * so rather than introduce spurious test failures we do not test the
7180 static void test_sioAddressListChange(void)
7182 struct sockaddr_in bindAddress
;
7183 struct in_addr net_address
;
7184 WSAOVERLAPPED overlapped
, *olp
;
7186 DWORD num_bytes
, error
, tick
;
7187 SOCKET sock
, sock2
, sock3
;
7188 WSAEVENT event2
, event3
;
7195 /* Use gethostbyname to find the list of local network interfaces */
7196 h
= gethostbyname("");
7197 ok(!!h
, "failed to get interface list, error %u\n", WSAGetLastError());
7198 for (acount
= 0; h
->h_addr_list
[acount
]; acount
++);
7201 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
7205 net_address
.s_addr
= *(ULONG
*) h
->h_addr_list
[0];
7207 sock
= socket(AF_INET
, 0, IPPROTO_TCP
);
7208 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
7210 memset(&bindAddress
, 0, sizeof(bindAddress
));
7211 bindAddress
.sin_family
= AF_INET
;
7212 bindAddress
.sin_addr
.s_addr
= net_address
.s_addr
;
7213 SetLastError(0xdeadbeef);
7214 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7215 ok (!ret
, "bind() failed with error %d\n", GetLastError());
7216 set_blocking(sock
, FALSE
);
7218 memset(&overlapped
, 0, sizeof(overlapped
));
7219 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
7220 SetLastError(0xdeadbeef);
7221 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
7222 error
= GetLastError();
7223 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
7224 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
7226 CloseHandle(overlapped
.hEvent
);
7229 sock
= socket(AF_INET
, 0, IPPROTO_TCP
);
7230 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
7232 SetLastError(0xdeadbeef);
7233 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7234 ok (!ret
, "bind() failed with error %d\n", GetLastError());
7235 set_blocking(sock
, TRUE
);
7237 memset(&overlapped
, 0, sizeof(overlapped
));
7238 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
7239 SetLastError(0xdeadbeef);
7240 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
7241 error
= GetLastError();
7242 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
7243 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
7245 CloseHandle(overlapped
.hEvent
);
7248 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
7249 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
7251 SetLastError(0xdeadbeef);
7252 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7253 ok (!ret
, "bind() failed with error %d\n", GetLastError());
7254 set_blocking(sock
, FALSE
);
7256 memset(&overlapped
, 0, sizeof(overlapped
));
7257 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
7258 SetLastError(0xdeadbeef);
7259 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
7260 error
= GetLastError();
7261 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
7262 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
7264 CloseHandle(overlapped
.hEvent
);
7267 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
7268 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
7270 SetLastError(0xdeadbeef);
7271 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7272 ok (!ret
, "bind() failed with error %d\n", GetLastError());
7273 set_blocking(sock
, TRUE
);
7275 memset(&overlapped
, 0, sizeof(overlapped
));
7276 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
7277 SetLastError(0xdeadbeef);
7278 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
7279 error
= GetLastError();
7280 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
7281 ok (error
== ERROR_IO_PENDING
, "expected 0x3e5, got 0x%x\n", error
);
7283 CloseHandle(overlapped
.hEvent
);
7286 /* When the socket is overlapped non-blocking and the list change is requested without
7287 * an overlapped structure the error will be different. */
7288 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
7289 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
7291 SetLastError(0xdeadbeef);
7292 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7293 ok (!ret
, "bind() failed with error %d\n", GetLastError());
7294 set_blocking(sock
, FALSE
);
7296 SetLastError(0xdeadbeef);
7297 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
7298 error
= GetLastError();
7299 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error
);
7300 ok (error
== WSAEWOULDBLOCK
, "expected 10035, got %d\n", error
);
7302 io_port
= CreateIoCompletionPort( (HANDLE
)sock
, NULL
, 0, 0 );
7303 ok (io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7305 set_blocking(sock
, FALSE
);
7306 memset(&overlapped
, 0, sizeof(overlapped
));
7307 SetLastError(0xdeadbeef);
7308 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
7309 error
= GetLastError();
7310 ok (ret
== SOCKET_ERROR
, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %u\n", error
);
7311 ok (error
== ERROR_IO_PENDING
, "expected ERROR_IO_PENDING got %u\n", error
);
7313 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7314 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 0 );
7315 ok(!bret
, "failed to get completion status %u\n", bret
);
7316 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7317 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7321 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7322 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 0 );
7323 ok(!bret
, "failed to get completion status %u\n", bret
);
7324 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %u\n", GetLastError());
7325 ok(olp
== &overlapped
, "Overlapped structure is at %p\n", olp
);
7327 CloseHandle(io_port
);
7329 /* Misuse of the API by using a blocking socket and not using an overlapped structure,
7330 * this leads to a hang forever. */
7333 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
7335 SetLastError(0xdeadbeef);
7336 bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7338 set_blocking(sock
, TRUE
);
7339 WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
7345 if (!winetest_interactive
)
7347 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
7351 /* Bind an overlapped socket to the first found network interface */
7352 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
7353 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
7354 sock2
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
7355 ok(sock2
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
7356 sock3
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
7357 ok(sock3
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
7359 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7360 ok(!ret
, "bind failed unexpectedly\n");
7361 ret
= bind(sock2
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7362 ok(!ret
, "bind failed unexpectedly\n");
7363 ret
= bind(sock3
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7364 ok(!ret
, "bind failed unexpectedly\n");
7366 set_blocking(sock2
, FALSE
);
7367 set_blocking(sock3
, FALSE
);
7369 /* Wait for address changes, request that the user connects/disconnects an interface */
7370 memset(&overlapped
, 0, sizeof(overlapped
));
7371 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
7372 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
7373 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
7374 ok(WSAGetLastError() == WSA_IO_PENDING
, "Expected pending last error, got %d\n", WSAGetLastError());
7376 ret
= WSAIoctl(sock2
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, NULL
, NULL
);
7377 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
7378 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "Expected would block last error, got %d\n", WSAGetLastError());
7380 event2
= WSACreateEvent();
7381 event3
= WSACreateEvent();
7382 ret
= WSAEventSelect (sock2
, event2
, FD_ADDRESS_LIST_CHANGE
);
7383 ok(!ret
, "WSAEventSelect failed with %d\n", WSAGetLastError());
7384 /* sock3 did not request SIO_ADDRESS_LIST_CHANGE but it is trying to wait anyway */
7385 ret
= WSAEventSelect (sock3
, event3
, FD_ADDRESS_LIST_CHANGE
);
7386 ok(!ret
, "WSAEventSelect failed with %d\n", WSAGetLastError());
7388 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
7389 " change the ipv4 address of any of the local network interfaces (15 second timeout).\n");
7390 tick
= GetTickCount();
7391 ret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
7392 ok(ret
== WAIT_OBJECT_0
, "failed to get overlapped event %u\n", ret
);
7394 ret
= WaitForSingleObject(event2
, 500);
7396 ok(ret
== WAIT_OBJECT_0
, "failed to get change event %u\n", ret
);
7398 ret
= WaitForSingleObject(event3
, 500);
7399 ok(ret
== WAIT_TIMEOUT
, "unexpected change event\n");
7401 trace("Spent %d ms waiting.\n", GetTickCount() - tick
);
7403 WSACloseEvent(event2
);
7404 WSACloseEvent(event3
);
7411 static void test_synchronous_WSAIoctl(void)
7414 WSAOVERLAPPED overlapped
, *olp
;
7422 socket
= WSASocketW( AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
7423 ok( socket
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError() );
7425 io_port
= CreateIoCompletionPort( (HANDLE
)socket
, NULL
, 0, 0 );
7426 ok( io_port
!= NULL
, "failed to create completion port %u\n", GetLastError() );
7429 memset( &overlapped
, 0, sizeof(overlapped
) );
7430 res
= WSAIoctl( socket
, FIONBIO
, &on
, sizeof(on
), NULL
, 0, &num_bytes
, &overlapped
, NULL
);
7431 ok( !res
, "WSAIoctl failed %d\n", WSAGetLastError() );
7433 ret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 10000 );
7434 ok( ret
, "failed to get completion status %u\n", GetLastError() );
7436 CloseHandle( io_port
);
7437 closesocket( socket
);
7441 * Provide consistent initialization for the AcceptEx IOCP tests.
7443 static SOCKET
setup_iocp_src(struct sockaddr_in
*bindAddress
)
7448 src
= socket(AF_INET
, SOCK_STREAM
, 0);
7449 ok(src
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
7451 memset(bindAddress
, 0, sizeof(*bindAddress
));
7452 bindAddress
->sin_family
= AF_INET
;
7453 bindAddress
->sin_addr
.s_addr
= inet_addr("127.0.0.1");
7454 iret
= bind(src
, (struct sockaddr
*)bindAddress
, sizeof(*bindAddress
));
7455 ok(!iret
, "failed to bind, error %u\n", WSAGetLastError());
7457 socklen
= sizeof(*bindAddress
);
7458 iret
= getsockname(src
, (struct sockaddr
*)bindAddress
, &socklen
);
7459 ok(!iret
, "failed to get address, error %u\n", WSAGetLastError());
7461 iret
= set_blocking(src
, FALSE
);
7462 ok(!iret
, "failed to make socket non-blocking, error %u\n", WSAGetLastError());
7464 iret
= listen(src
, 5);
7465 ok(!iret
, "failed to listen, error %u\n", WSAGetLastError());
7470 static void test_completion_port(void)
7473 WSAOVERLAPPED ov
, *olp
;
7474 SOCKET src
, dest
, dup
, connector
= INVALID_SOCKET
;
7475 WSAPROTOCOL_INFOA info
;
7478 DWORD num_bytes
, flags
;
7483 struct sockaddr_in bindAddress
;
7484 GUID acceptExGuid
= WSAID_ACCEPTEX
;
7485 LPFN_ACCEPTEX pAcceptEx
= NULL
;
7488 memset(buf
, 0, sizeof(buf
));
7489 io_port
= CreateIoCompletionPort(INVALID_HANDLE_VALUE
, NULL
, 0, 0);
7490 ok( io_port
!= NULL
, "Failed to create completion port %u\n", GetLastError());
7492 memset(&ov
, 0, sizeof(ov
));
7494 tcp_socketpair(&src
, &dest
);
7496 bufs
.len
= sizeof(buf
);
7502 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
7503 ok(!iret
, "Failed to set linger %d\n", GetLastError());
7505 io_port
= CreateIoCompletionPort( (HANDLE
)dest
, io_port
, 125, 0 );
7506 ok(io_port
!= NULL
, "Failed to create completion port %u\n", GetLastError());
7508 SetLastError(0xdeadbeef);
7510 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
7511 ok(iret
== SOCKET_ERROR
, "WSARecv returned %d\n", iret
);
7512 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
7517 src
= INVALID_SOCKET
;
7519 SetLastError(0xdeadbeef);
7521 num_bytes
= 0xdeadbeef;
7522 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7524 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
7525 todo_wine
ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %d\n", bret
);
7526 todo_wine
ok(GetLastError() == ERROR_NETNAME_DELETED
, "Last error was %d\n", GetLastError());
7527 ok(key
== 125, "Key is %lu\n", key
);
7528 ok(num_bytes
== 0, "Number of bytes received is %u\n", num_bytes
);
7529 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7531 SetLastError(0xdeadbeef);
7533 num_bytes
= 0xdeadbeef;
7534 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7536 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
7537 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %d\n", bret
);
7538 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7539 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7540 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7541 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7543 if (dest
!= INVALID_SOCKET
)
7546 memset(&ov
, 0, sizeof(ov
));
7548 tcp_socketpair(&src
, &dest
);
7550 bufs
.len
= sizeof(buf
);
7556 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
7557 ok(!iret
, "Failed to set linger %d\n", GetLastError());
7559 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 125, 0);
7560 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7562 set_blocking(dest
, FALSE
);
7565 src
= INVALID_SOCKET
;
7569 num_bytes
= 0xdeadbeef;
7570 SetLastError(0xdeadbeef);
7572 iret
= WSASend(dest
, &bufs
, 1, &num_bytes
, 0, &ov
, NULL
);
7573 ok(iret
== SOCKET_ERROR
, "WSASend failed - %d\n", iret
);
7574 ok(GetLastError() == WSAECONNRESET
, "Last error was %d\n", GetLastError());
7575 ok(num_bytes
== 0xdeadbeef, "Managed to send %d\n", num_bytes
);
7577 SetLastError(0xdeadbeef);
7579 num_bytes
= 0xdeadbeef;
7580 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7582 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7583 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
7584 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7585 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7586 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7587 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7589 if (dest
!= INVALID_SOCKET
)
7592 /* Test IOCP response on successful immediate read. */
7593 tcp_socketpair(&src
, &dest
);
7595 bufs
.len
= sizeof(buf
);
7598 SetLastError(0xdeadbeef);
7600 iret
= WSASend(src
, &bufs
, 1, &num_bytes
, 0, &ov
, NULL
);
7601 ok(!iret
, "WSASend failed - %d, last error %u\n", iret
, GetLastError());
7602 ok(num_bytes
== sizeof(buf
), "Managed to send %d\n", num_bytes
);
7604 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 125, 0);
7605 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7606 set_blocking(dest
, FALSE
);
7609 FD_SET(dest
, &fds_recv
);
7610 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
7612 num_bytes
= 0xdeadbeef;
7615 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
7616 ok(!iret
, "WSARecv failed - %d, last error %u\n", iret
, GetLastError());
7617 ok(num_bytes
== sizeof(buf
), "Managed to read %d\n", num_bytes
);
7619 SetLastError(0xdeadbeef);
7621 num_bytes
= 0xdeadbeef;
7622 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7624 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7625 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
7626 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
7627 ok(key
== 125, "Key is %lu\n", key
);
7628 ok(num_bytes
== sizeof(buf
), "Number of bytes transferred is %u\n", num_bytes
);
7629 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7631 /* Test IOCP response on graceful shutdown. */
7635 FD_SET(dest
, &fds_recv
);
7636 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
7638 num_bytes
= 0xdeadbeef;
7640 memset(&ov
, 0, sizeof(ov
));
7642 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
7643 ok(!iret
, "WSARecv failed - %d, last error %u\n", iret
, GetLastError());
7644 ok(!num_bytes
, "Managed to read %d\n", num_bytes
);
7646 SetLastError(0xdeadbeef);
7648 num_bytes
= 0xdeadbeef;
7649 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7651 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7652 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
7653 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
7654 ok(key
== 125, "Key is %lu\n", key
);
7655 ok(!num_bytes
, "Number of bytes transferred is %u\n", num_bytes
);
7656 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7659 src
= INVALID_SOCKET
;
7661 dest
= INVALID_SOCKET
;
7663 /* Test IOCP response on hard shutdown. This was the condition that triggered
7664 * a crash in an actual app (bug 38980). */
7665 tcp_socketpair(&src
, &dest
);
7667 bufs
.len
= sizeof(buf
);
7670 memset(&ov
, 0, sizeof(ov
));
7674 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
7675 ok(!iret
, "Failed to set linger %d\n", GetLastError());
7677 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 125, 0);
7678 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7679 set_blocking(dest
, FALSE
);
7682 src
= INVALID_SOCKET
;
7685 FD_SET(dest
, &fds_recv
);
7686 select(dest
+ 1, &fds_recv
, NULL
, NULL
, NULL
);
7688 num_bytes
= 0xdeadbeef;
7689 SetLastError(0xdeadbeef);
7691 /* Somehow a hard shutdown doesn't work on my Linux box. It seems SO_LINGER is ignored. */
7692 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
7693 todo_wine
ok(iret
== SOCKET_ERROR
, "WSARecv failed - %d\n", iret
);
7694 todo_wine
ok(GetLastError() == WSAECONNRESET
, "Last error was %d\n", GetLastError());
7695 todo_wine
ok(num_bytes
== 0xdeadbeef, "Managed to read %d\n", num_bytes
);
7697 SetLastError(0xdeadbeef);
7699 num_bytes
= 0xdeadbeef;
7700 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7702 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7703 todo_wine
ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
7704 todo_wine
ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7705 todo_wine
ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7706 todo_wine
ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7707 todo_wine
ok(!olp
, "Overlapped structure is at %p\n", olp
);
7711 /* Test reading from a non-connected socket, mostly because the above test is marked todo. */
7712 dest
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
7713 ok(dest
!= INVALID_SOCKET
, "socket() failed\n");
7715 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 125, 0);
7716 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7717 set_blocking(dest
, FALSE
);
7719 num_bytes
= 0xdeadbeef;
7720 SetLastError(0xdeadbeef);
7721 memset(&ov
, 0, sizeof(ov
));
7723 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
7724 ok(iret
== SOCKET_ERROR
, "WSARecv failed - %d\n", iret
);
7725 ok(GetLastError() == WSAENOTCONN
, "Last error was %d\n", GetLastError());
7726 ok(num_bytes
== 0xdeadbeef, "Managed to read %d\n", num_bytes
);
7728 SetLastError(0xdeadbeef);
7730 num_bytes
= 0xdeadbeef;
7731 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7733 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7734 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
7735 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7736 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7737 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7738 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7740 num_bytes
= 0xdeadbeef;
7743 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
7744 ok(dest
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
7746 iret
= WSAIoctl(dest
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
7747 &pAcceptEx
, sizeof(pAcceptEx
), &num_bytes
, NULL
, NULL
);
7748 ok(!iret
, "failed to get AcceptEx, error %u\n", WSAGetLastError());
7750 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
7752 src
= setup_iocp_src(&bindAddress
);
7754 SetLastError(0xdeadbeef);
7756 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
7757 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7759 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
7760 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
7762 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
7763 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7766 src
= INVALID_SOCKET
;
7768 SetLastError(0xdeadbeef);
7770 num_bytes
= 0xdeadbeef;
7771 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7773 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
7774 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7775 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
7776 ok(key
== 125, "Key is %lu\n", key
);
7777 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
7778 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7779 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
7781 SetLastError(0xdeadbeef);
7783 num_bytes
= 0xdeadbeef;
7784 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7785 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7786 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7787 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7788 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7789 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7790 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7792 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
7794 src
= setup_iocp_src(&bindAddress
);
7796 SetLastError(0xdeadbeef);
7798 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
7799 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7801 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
7802 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7804 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
7805 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
7808 src
= INVALID_SOCKET
;
7810 SetLastError(0xdeadbeef);
7812 num_bytes
= 0xdeadbeef;
7813 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7815 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
7816 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7817 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
7818 ok(key
== 125, "Key is %lu\n", key
);
7819 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
7820 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7821 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
7823 SetLastError(0xdeadbeef);
7825 num_bytes
= 0xdeadbeef;
7826 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7827 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7828 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7829 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7830 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7831 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7832 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7834 /* Test IOCP with duplicated handle */
7836 src
= setup_iocp_src(&bindAddress
);
7838 SetLastError(0xdeadbeef);
7840 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
7841 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7843 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
7844 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
7845 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
7847 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
7848 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7850 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
7851 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
7853 SetLastError(0xdeadbeef);
7855 num_bytes
= 0xdeadbeef;
7856 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7857 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7858 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7859 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7860 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7861 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7862 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7865 src
= INVALID_SOCKET
;
7867 dup
= INVALID_SOCKET
;
7869 SetLastError(0xdeadbeef);
7871 num_bytes
= 0xdeadbeef;
7872 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7873 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
7874 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7875 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
7876 ok(key
== 125, "Key is %lu\n", key
);
7877 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
7878 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7879 ok(olp
&& olp
->Internal
== (ULONG
)STATUS_CANCELLED
, "Internal status is %lx\n", olp
? olp
->Internal
: 0);
7881 SetLastError(0xdeadbeef);
7883 num_bytes
= 0xdeadbeef;
7884 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7885 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7886 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7887 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7888 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7889 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7890 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7892 /* Test IOCP with duplicated handle (closing duplicated handle) */
7894 src
= setup_iocp_src(&bindAddress
);
7896 SetLastError(0xdeadbeef);
7898 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
7899 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7901 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
7902 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
7903 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
7905 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
7906 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7908 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
7909 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
7912 dup
= INVALID_SOCKET
;
7914 SetLastError(0xdeadbeef);
7916 num_bytes
= 0xdeadbeef;
7917 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7918 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7919 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7920 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7921 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7922 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7923 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7925 SetLastError(0xdeadbeef);
7927 num_bytes
= 0xdeadbeef;
7928 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7929 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7930 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7931 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7932 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7933 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7934 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7937 src
= INVALID_SOCKET
;
7939 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
7940 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7941 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
7942 ok(key
== 125, "Key is %lu\n", key
);
7943 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
7944 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7945 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
7947 SetLastError(0xdeadbeef);
7949 num_bytes
= 0xdeadbeef;
7950 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7951 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7952 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7953 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7954 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7955 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7956 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7958 /* Test IOCP with duplicated handle (closing original handle) */
7960 src
= setup_iocp_src(&bindAddress
);
7962 SetLastError(0xdeadbeef);
7964 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
7965 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7967 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
7968 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
7969 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
7971 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
7972 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7974 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
7975 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
7978 src
= INVALID_SOCKET
;
7980 SetLastError(0xdeadbeef);
7982 num_bytes
= 0xdeadbeef;
7983 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7984 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7985 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7986 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7987 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7988 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7989 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7992 dup
= INVALID_SOCKET
;
7994 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
7995 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7996 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
7997 ok(key
== 125, "Key is %lu\n", key
);
7998 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
7999 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8000 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8002 SetLastError(0xdeadbeef);
8004 num_bytes
= 0xdeadbeef;
8005 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8006 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8007 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8008 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8009 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8010 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8011 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8013 /* Test IOCP without AcceptEx */
8015 src
= setup_iocp_src(&bindAddress
);
8017 SetLastError(0xdeadbeef);
8019 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8020 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8023 src
= INVALID_SOCKET
;
8025 SetLastError(0xdeadbeef);
8027 num_bytes
= 0xdeadbeef;
8028 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8029 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8030 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8031 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8032 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8033 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8034 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8038 src
= setup_iocp_src(&bindAddress
);
8040 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8041 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8043 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8044 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8046 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 236, 0);
8047 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8049 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8050 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8052 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8053 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8055 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8056 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
8058 closesocket(connector
);
8059 connector
= INVALID_SOCKET
;
8061 SetLastError(0xdeadbeef);
8063 num_bytes
= 0xdeadbeef;
8064 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8066 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8067 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
8068 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
8069 ok(key
== 125, "Key is %lu\n", key
);
8070 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
8071 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8072 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8074 SetLastError(0xdeadbeef);
8076 num_bytes
= 0xdeadbeef;
8077 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8078 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8079 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8080 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8081 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8082 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8083 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8085 if (dest
!= INVALID_SOCKET
)
8087 if (src
!= INVALID_SOCKET
)
8092 src
= setup_iocp_src(&bindAddress
);
8094 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
8095 ok(dest
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8097 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8098 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8100 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8101 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8103 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 236, 0);
8104 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8106 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8107 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8109 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8110 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8112 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8113 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
8115 iret
= send(connector
, buf
, 1, 0);
8116 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
8121 dest
= INVALID_SOCKET
;
8123 SetLastError(0xdeadbeef);
8125 num_bytes
= 0xdeadbeef;
8126 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8128 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8129 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
8130 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
8131 ok(key
== 125, "Key is %lu\n", key
);
8132 ok(num_bytes
== 1, "Number of bytes transferred is %u\n", num_bytes
);
8133 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8134 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8136 SetLastError(0xdeadbeef);
8138 num_bytes
= 0xdeadbeef;
8139 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8140 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8141 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8142 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8143 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8144 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8145 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8147 if (src
!= INVALID_SOCKET
)
8149 if (connector
!= INVALID_SOCKET
)
8150 closesocket(connector
);
8154 src
= setup_iocp_src(&bindAddress
);
8156 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
8157 ok(dest
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8159 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
8160 ok(connector
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
8162 io_port
= CreateIoCompletionPort((HANDLE
)src
, io_port
, 125, 0);
8163 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8165 io_port
= CreateIoCompletionPort((HANDLE
)dest
, io_port
, 236, 0);
8166 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8168 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8169 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8171 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8172 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8174 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8175 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
8179 SetLastError(0xdeadbeef);
8181 num_bytes
= 0xdeadbeef;
8182 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8184 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8185 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8186 ok(GetLastError() == ERROR_OPERATION_ABORTED
8187 || GetLastError() == ERROR_CONNECTION_ABORTED
, "got error %u\n", GetLastError());
8188 ok(key
== 125, "Key is %lu\n", key
);
8189 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
8190 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8191 ok((NTSTATUS
)olp
->Internal
== STATUS_CANCELLED
8192 || (NTSTATUS
)olp
->Internal
== STATUS_CONNECTION_ABORTED
, "got status %#lx\n", olp
->Internal
);
8194 SetLastError(0xdeadbeef);
8196 num_bytes
= 0xdeadbeef;
8197 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8198 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8199 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8200 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8201 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8202 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8203 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8206 closesocket(connector
);
8207 CloseHandle(io_port
);
8210 static void test_connect_completion_port(void)
8212 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
8213 GUID connectex_guid
= WSAID_CONNECTEX
;
8214 SOCKET connector
, listener
, acceptor
;
8215 struct sockaddr_in addr
, destaddr
;
8216 LPFN_CONNECTEX pConnectEx
;
8222 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8224 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8225 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
8227 memset(&addr
, 0, sizeof(addr
));
8228 addr
.sin_family
= AF_INET
;
8229 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8230 ret
= bind(listener
, (struct sockaddr
*)&addr
, sizeof(addr
));
8231 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
8232 addrlen
= sizeof(destaddr
);
8233 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &addrlen
);
8234 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
8236 ret
= listen(listener
, 1);
8237 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
8239 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8240 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
8242 ret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectex_guid
, sizeof(connectex_guid
),
8243 &pConnectEx
, sizeof(pConnectEx
), &size
, NULL
, NULL
);
8244 ok(!ret
, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
8246 /* connect() does not queue completion. */
8248 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
8249 ok(!!port
, "failed to create port, error %u\n", GetLastError());
8251 ret
= connect(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
8252 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
8253 acceptor
= accept(listener
, NULL
, NULL
);
8254 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
8255 closesocket(acceptor
);
8257 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
8258 ok(!ret
, "expected failure\n");
8259 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
8261 closesocket(connector
);
8264 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8265 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
8266 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
8267 ok(!!port
, "failed to create port, error %u\n", GetLastError());
8268 set_blocking(connector
, FALSE
);
8270 ret
= connect(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
8271 ok(ret
== -1, "expected failure\n");
8272 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
8273 acceptor
= accept(listener
, NULL
, NULL
);
8274 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
8275 closesocket(acceptor
);
8277 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
8278 ok(!ret
, "expected failure\n");
8279 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
8281 closesocket(connector
);
8284 /* ConnectEx() queues completion. */
8286 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8287 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
8288 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
8289 ok(!!port
, "failed to create port, error %u\n", GetLastError());
8290 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
8291 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
8293 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
8294 NULL
, 0, &size
, &overlapped
);
8295 ok(!ret
, "expected failure\n");
8296 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
8297 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8298 ok(!ret
, "wait failed\n");
8299 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
8300 ok(ret
, "got error %u\n", GetLastError());
8301 ok(!size
, "got %u bytes\n", size
);
8302 acceptor
= accept(listener
, NULL
, NULL
);
8303 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
8304 closesocket(acceptor
);
8308 overlapped_ptr
= NULL
;
8309 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
8310 ok(ret
, "got error %u\n", GetLastError());
8311 ok(!key
, "got key %#Ix\n", key
);
8312 ok(!size
, "got %u bytes\n", size
);
8313 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
8315 closesocket(connector
);
8318 /* Test ConnectEx() with a non-empty buffer. */
8320 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8321 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
8322 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
8323 ok(!!port
, "failed to create port, error %u\n", GetLastError());
8324 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
8325 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
8327 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
8328 (void *)"one", 3, &size
, &overlapped
);
8329 ok(!ret
, "expected failure\n");
8330 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
8331 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8332 ok(!ret
, "wait failed\n");
8333 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
8334 ok(ret
, "got error %u\n", GetLastError());
8335 ok(size
== 3, "got %u bytes\n", size
);
8336 acceptor
= accept(listener
, NULL
, NULL
);
8337 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
8338 closesocket(acceptor
);
8342 overlapped_ptr
= NULL
;
8343 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
8344 ok(ret
, "got error %u\n", GetLastError());
8345 ok(!key
, "got key %#Ix\n", key
);
8346 ok(size
== 3, "got %u bytes\n", size
);
8347 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
8349 closesocket(connector
);
8352 /* Suppress completion by setting the low bit. */
8354 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8355 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
8356 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
8357 ok(!!port
, "failed to create port, error %u\n", GetLastError());
8358 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
8359 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
8361 overlapped
.hEvent
= (HANDLE
)((ULONG_PTR
)overlapped
.hEvent
| 1);
8363 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
8364 NULL
, 0, &size
, &overlapped
);
8365 ok(!ret
, "expected failure\n");
8366 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
8367 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8368 ok(!ret
, "wait failed\n");
8369 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
8370 ok(ret
, "got error %u\n", GetLastError());
8371 ok(!size
, "got %u bytes\n", size
);
8372 acceptor
= accept(listener
, NULL
, NULL
);
8373 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
8374 closesocket(acceptor
);
8376 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
8377 ok(!ret
, "expected failure\n");
8378 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
8380 closesocket(connector
);
8383 overlapped
.hEvent
= (HANDLE
)((ULONG_PTR
)overlapped
.hEvent
& ~1);
8385 /* Skip completion on success. */
8387 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8388 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
8389 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
8390 ok(!!port
, "failed to create port, error %u\n", GetLastError());
8391 ret
= SetFileCompletionNotificationModes((HANDLE
)connector
, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS
);
8392 ok(ret
, "got error %u\n", GetLastError());
8393 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
8394 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
8396 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
8397 NULL
, 0, &size
, &overlapped
);
8398 ok(!ret
, "expected failure\n");
8399 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
8400 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8401 ok(!ret
, "wait failed\n");
8402 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
8403 ok(ret
, "got error %u\n", GetLastError());
8404 ok(!size
, "got %u bytes\n", size
);
8405 acceptor
= accept(listener
, NULL
, NULL
);
8406 ok(acceptor
!= -1, "failed to accept, error %u\n", WSAGetLastError());
8407 closesocket(acceptor
);
8411 overlapped_ptr
= NULL
;
8412 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
8413 ok(ret
, "got error %u\n", GetLastError());
8414 ok(!key
, "got key %#Ix\n", key
);
8415 ok(!size
, "got %u bytes\n", size
);
8416 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
8418 closesocket(connector
);
8421 closesocket(listener
);
8423 /* Connect to an invalid address. */
8425 connector
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8426 ok(connector
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
8427 port
= CreateIoCompletionPort((HANDLE
)connector
, NULL
, 0, 0);
8428 ok(!!port
, "failed to create port, error %u\n", GetLastError());
8429 ret
= SetFileCompletionNotificationModes((HANDLE
)connector
, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS
);
8430 ok(ret
, "got error %u\n", GetLastError());
8431 ret
= bind(connector
, (struct sockaddr
*)&addr
, sizeof(addr
));
8432 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
8434 ret
= pConnectEx(connector
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
),
8435 NULL
, 0, &size
, &overlapped
);
8436 ok(!ret
, "expected failure\n");
8437 ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
8438 ret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
8439 ok(!ret
, "wait failed\n");
8440 ret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &size
, FALSE
);
8441 ok(!ret
, "expected failure\n");
8442 ok(GetLastError() == ERROR_CONNECTION_REFUSED
, "got error %u\n", GetLastError());
8443 ok(!size
, "got %u bytes\n", size
);
8447 overlapped_ptr
= NULL
;
8448 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
8449 ok(!ret
, "expected failure\n");
8450 ok(GetLastError() == ERROR_CONNECTION_REFUSED
, "got error %u\n", GetLastError());
8451 ok(!key
, "got key %#Ix\n", key
);
8452 ok(!size
, "got %u bytes\n", size
);
8453 ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
8455 closesocket(connector
);
8459 static void test_shutdown_completion_port(void)
8461 OVERLAPPED overlapped
= {0}, *overlapped_ptr
;
8462 GUID disconnectex_guid
= WSAID_DISCONNECTEX
;
8463 struct sockaddr_in addr
, destaddr
;
8464 LPFN_DISCONNECTEX pDisconnectEx
;
8465 SOCKET listener
, server
, client
;
8471 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8473 listener
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8474 ok(listener
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
8476 memset(&addr
, 0, sizeof(addr
));
8477 addr
.sin_family
= AF_INET
;
8478 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8479 ret
= bind(listener
, (struct sockaddr
*)&addr
, sizeof(addr
));
8480 ok(!ret
, "failed to bind, error %u\n", WSAGetLastError());
8481 addrlen
= sizeof(destaddr
);
8482 ret
= getsockname(listener
, (struct sockaddr
*)&destaddr
, &addrlen
);
8483 ok(!ret
, "failed to get address, error %u\n", WSAGetLastError());
8485 ret
= listen(listener
, 1);
8486 ok(!ret
, "failed to listen, error %u\n", WSAGetLastError());
8488 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8489 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
8491 ret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &disconnectex_guid
, sizeof(disconnectex_guid
),
8492 &pDisconnectEx
, sizeof(pDisconnectEx
), &size
, NULL
, NULL
);
8493 ok(!ret
, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
8495 /* shutdown() does not queue completion. */
8497 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
8498 ok(!!port
, "failed to create port, error %u\n", GetLastError());
8499 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
8500 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
8501 server
= accept(listener
, NULL
, NULL
);
8502 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
8504 ret
= shutdown(client
, SD_BOTH
);
8505 ok(!ret
, "failed to shutdown, error %u\n", WSAGetLastError());
8507 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
8508 ok(!ret
, "expected failure\n");
8509 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
8511 closesocket(server
);
8512 closesocket(client
);
8515 /* WSASendDisconnect() and WSARecvDisconnect() do not queue completion. */
8517 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8518 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
8519 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
8520 ok(!!port
, "failed to create port, error %u\n", GetLastError());
8521 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
8522 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
8523 server
= accept(listener
, NULL
, NULL
);
8524 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
8526 ret
= WSASendDisconnect(client
, NULL
);
8527 ok(!ret
, "failed to shutdown, error %u\n", WSAGetLastError());
8529 ret
= WSARecvDisconnect(client
, NULL
);
8530 ok(!ret
, "failed to shutdown, error %u\n", WSAGetLastError());
8532 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
8533 ok(!ret
, "expected failure\n");
8534 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
8536 closesocket(server
);
8537 closesocket(client
);
8540 /* DisconnectEx() queues completion. */
8542 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8543 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
8544 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
8545 ok(!!port
, "failed to create port, error %u\n", GetLastError());
8546 ret
= SetFileCompletionNotificationModes((HANDLE
)client
, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS
);
8547 ok(ret
, "got error %u\n", GetLastError());
8548 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
8549 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
8550 server
= accept(listener
, NULL
, NULL
);
8551 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
8553 SetLastError(0xdeadbeef);
8554 ret
= pDisconnectEx(client
, &overlapped
, 0, 0);
8555 todo_wine
ok(!ret
, "expected failure\n");
8556 todo_wine
ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
8557 if (GetLastError() == ERROR_IO_PENDING
)
8559 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8560 ok(!ret
, "wait failed\n");
8563 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, TRUE
);
8564 ok(ret
, "got error %u\n", GetLastError());
8565 ok(!size
, "got %u bytes\n", size
);
8570 overlapped_ptr
= NULL
;
8571 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
8572 todo_wine
ok(ret
, "got error %u\n", GetLastError());
8573 todo_wine
ok(!key
, "got key %#Ix\n", key
);
8574 todo_wine
ok(!size
, "got %u bytes\n", size
);
8575 todo_wine
ok(overlapped_ptr
== &overlapped
, "got overlapped %p\n", overlapped_ptr
);
8577 closesocket(server
);
8578 closesocket(client
);
8581 /* Test passing a NULL overlapped structure to DisconnectEx(). */
8583 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8584 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
8585 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
8586 ok(!!port
, "failed to create port, error %u\n", GetLastError());
8587 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
8588 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
8589 server
= accept(listener
, NULL
, NULL
);
8590 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
8592 SetLastError(0xdeadbeef);
8593 ret
= pDisconnectEx(client
, NULL
, 0, 0);
8594 ok(ret
, "expected success\n");
8595 ok(!GetLastError() || GetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", GetLastError());
8597 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
8598 ok(!ret
, "expected failure\n");
8599 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
8601 closesocket(server
);
8602 closesocket(client
);
8605 /* Suppress completion by setting the low bit. */
8607 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8608 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
8609 port
= CreateIoCompletionPort((HANDLE
)client
, NULL
, 0, 0);
8610 ok(!!port
, "failed to create port, error %u\n", GetLastError());
8611 ret
= connect(client
, (struct sockaddr
*)&destaddr
, sizeof(destaddr
));
8612 ok(!ret
, "failed to connect, error %u\n", WSAGetLastError());
8613 server
= accept(listener
, NULL
, NULL
);
8614 ok(server
!= -1, "failed to accept, error %u\n", WSAGetLastError());
8616 overlapped
.hEvent
= (HANDLE
)((ULONG_PTR
)overlapped
.hEvent
| 1);
8618 SetLastError(0xdeadbeef);
8619 ret
= pDisconnectEx(client
, &overlapped
, 0, 0);
8620 todo_wine
ok(!ret
, "expected failure\n");
8621 todo_wine
ok(GetLastError() == ERROR_IO_PENDING
, "got error %u\n", GetLastError());
8622 if (GetLastError() == ERROR_IO_PENDING
)
8624 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
8625 ok(!ret
, "wait failed\n");
8628 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, TRUE
);
8629 ok(ret
, "got error %u\n", GetLastError());
8630 ok(!size
, "got %u bytes\n", size
);
8633 ret
= GetQueuedCompletionStatus(port
, &size
, &key
, &overlapped_ptr
, 0);
8634 ok(!ret
, "expected failure\n");
8635 ok(GetLastError() == WAIT_TIMEOUT
, "got error %u\n", GetLastError());
8637 closesocket(server
);
8638 closesocket(client
);
8641 overlapped
.hEvent
= (HANDLE
)((ULONG_PTR
)overlapped
.hEvent
& ~1);
8643 CloseHandle(overlapped
.hEvent
);
8646 static void test_address_list_query(void)
8648 SOCKET_ADDRESS_LIST
*address_list
;
8649 DWORD bytes_returned
, size
;
8654 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
8655 ok(s
!= INVALID_SOCKET
, "Failed to create socket, error %d.\n", WSAGetLastError());
8658 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, NULL
, 0, &bytes_returned
, NULL
, NULL
);
8659 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
8660 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
8661 ok(bytes_returned
>= FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[0]),
8662 "Got unexpected bytes_returned %u.\n", bytes_returned
);
8664 size
= bytes_returned
;
8666 address_list
= HeapAlloc(GetProcessHeap(), 0, size
* 2);
8667 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, address_list
, size
* 2, &bytes_returned
, NULL
, NULL
);
8668 ok(!ret
, "Got unexpected ret %d, error %d.\n", ret
, WSAGetLastError());
8669 ok(bytes_returned
== size
, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned
, size
);
8671 bytes_returned
= FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[address_list
->iAddressCount
]);
8672 for (i
= 0; i
< address_list
->iAddressCount
; ++i
)
8674 bytes_returned
+= address_list
->Address
[i
].iSockaddrLength
;
8676 ok(size
== bytes_returned
, "Got unexpected size %u, expected %u.\n", size
, bytes_returned
);
8678 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, address_list
, size
, NULL
, NULL
, NULL
);
8679 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
8680 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
8682 bytes_returned
= 0xdeadbeef;
8683 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, NULL
, size
, &bytes_returned
, NULL
, NULL
);
8684 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
8685 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
8686 ok(bytes_returned
== size
, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned
, size
);
8688 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, address_list
, 1, &bytes_returned
, NULL
, NULL
);
8689 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
8690 ok(WSAGetLastError() == WSAEINVAL
, "Got unexpected error %d.\n", WSAGetLastError());
8691 ok(bytes_returned
== 0, "Got unexpected bytes_returned %u.\n", bytes_returned
);
8693 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, address_list
,
8694 FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[0]), &bytes_returned
, NULL
, NULL
);
8695 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
8696 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
8697 ok(bytes_returned
== size
, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned
, size
);
8699 HeapFree(GetProcessHeap(), 0, address_list
);
8703 static void sync_read(SOCKET src
, SOCKET dst
)
8708 ret
= send(dst
, "Hello World!", 12, 0);
8709 ok(ret
== 12, "send returned %d\n", ret
);
8711 memset(data
, 0, sizeof(data
));
8712 ret
= recv(src
, data
, sizeof(data
), 0);
8713 ok(ret
== 12, "expected 12, got %d\n", ret
);
8714 ok(!memcmp(data
, "Hello World!", 12), "got %u bytes (%*s)\n", ret
, ret
, data
);
8717 static void iocp_async_read(SOCKET src
, SOCKET dst
)
8720 WSAOVERLAPPED ovl
, *ovl_iocp
;
8727 memset(data
, 0, sizeof(data
));
8728 memset(&ovl
, 0, sizeof(ovl
));
8730 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
8731 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
8733 buf
.len
= sizeof(data
);
8737 SetLastError(0xdeadbeef);
8738 ret
= WSARecv(src
, &buf
, 1, &bytes
, &flags
, &ovl
, NULL
);
8739 ok(ret
== SOCKET_ERROR
, "got %d\n", ret
);
8740 ok(GetLastError() == ERROR_IO_PENDING
, "got %u\n", GetLastError());
8741 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
8745 ovl_iocp
= (void *)0xdeadbeef;
8746 SetLastError(0xdeadbeef);
8747 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
8748 ok(!ret
, "got %d\n", ret
);
8749 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
8750 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
8751 ok(key
== 0xdeadbeef, "got key %#lx\n", key
);
8752 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
8754 ret
= send(dst
, "Hello World!", 12, 0);
8755 ok(ret
== 12, "send returned %d\n", ret
);
8760 SetLastError(0xdeadbeef);
8761 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
8762 ok(ret
, "got %d\n", ret
);
8763 ok(bytes
== 12, "got bytes %u\n", bytes
);
8764 ok(key
== 0x12345678, "got key %#lx\n", key
);
8765 ok(ovl_iocp
== &ovl
, "got ovl %p\n", ovl_iocp
);
8768 ok(ovl_iocp
->InternalHigh
== 12, "got %#lx\n", ovl_iocp
->InternalHigh
);
8769 ok(!ovl_iocp
->Internal
, "got %#lx\n", ovl_iocp
->Internal
);
8770 ok(!memcmp(data
, "Hello World!", 12), "got %u bytes (%*s)\n", bytes
, bytes
, data
);
8775 ovl_iocp
= (void *)0xdeadbeef;
8776 SetLastError(0xdeadbeef);
8777 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
8778 ok(!ret
, "got %d\n", ret
);
8779 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
8780 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
8781 ok(key
== 0xdeadbeef, "got key %#lx\n", key
);
8782 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
8787 static void iocp_async_read_closesocket(SOCKET src
, int how_to_close
)
8790 WSAOVERLAPPED ovl
, *ovl_iocp
;
8799 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
8800 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
8801 ok(hwnd
!= 0, "CreateWindowEx failed\n");
8803 ret
= WSAAsyncSelect(src
, hwnd
, WM_SOCKET
, FD_READ
| FD_WRITE
| FD_OOB
| FD_ACCEPT
| FD_CONNECT
| FD_CLOSE
);
8804 ok(!ret
, "got %d\n", ret
);
8807 memset(&msg
, 0, sizeof(msg
));
8808 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
8809 ok(ret
, "got %d\n", ret
);
8810 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
8811 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
8812 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
8813 ok(msg
.lParam
== 2, "got %08lx\n", msg
.lParam
);
8815 memset(data
, 0, sizeof(data
));
8816 memset(&ovl
, 0, sizeof(ovl
));
8818 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
8819 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
8822 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
8823 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
8825 buf
.len
= sizeof(data
);
8829 SetLastError(0xdeadbeef);
8830 ret
= WSARecv(src
, &buf
, 1, &bytes
, &flags
, &ovl
, NULL
);
8831 ok(ret
== SOCKET_ERROR
, "got %d\n", ret
);
8832 ok(GetLastError() == ERROR_IO_PENDING
, "got %u\n", GetLastError());
8833 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
8836 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
8837 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
8841 ovl_iocp
= (void *)0xdeadbeef;
8842 SetLastError(0xdeadbeef);
8843 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
8844 ok(!ret
, "got %d\n", ret
);
8845 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
8846 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
8847 ok(key
== 0xdeadbeef, "got key %#lx\n", key
);
8848 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
8851 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
8852 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
8854 switch (how_to_close
)
8860 CloseHandle((HANDLE
)src
);
8863 pNtClose((HANDLE
)src
);
8866 ok(0, "wrong value %d\n", how_to_close
);
8871 memset(&msg
, 0, sizeof(msg
));
8872 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
8873 switch (how_to_close
)
8876 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
8882 ok(ret
, "got %d\n", ret
);
8883 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
8884 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
8885 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
8886 ok(msg
.lParam
== 0x20, "got %08lx\n", msg
.lParam
);
8890 ok(0, "wrong value %d\n", how_to_close
);
8897 SetLastError(0xdeadbeef);
8898 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
8899 ok(!ret
, "got %d\n", ret
);
8901 ok(GetLastError() == ERROR_CONNECTION_ABORTED
|| GetLastError() == ERROR_NETNAME_DELETED
/* XP */, "got %u\n", GetLastError());
8902 ok(!bytes
, "got bytes %u\n", bytes
);
8903 ok(key
== 0x12345678, "got key %#lx\n", key
);
8904 ok(ovl_iocp
== &ovl
, "got ovl %p\n", ovl_iocp
);
8907 ok(!ovl_iocp
->InternalHigh
, "got %#lx\n", ovl_iocp
->InternalHigh
);
8909 ok(ovl_iocp
->Internal
== (ULONG
)STATUS_CONNECTION_ABORTED
|| ovl_iocp
->Internal
== (ULONG
)STATUS_LOCAL_DISCONNECT
/* XP */, "got %#lx\n", ovl_iocp
->Internal
);
8914 ovl_iocp
= (void *)0xdeadbeef;
8915 SetLastError(0xdeadbeef);
8916 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
8917 ok(!ret
, "got %d\n", ret
);
8918 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
8919 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
8920 ok(key
== 0xdeadbeef, "got key %#lx\n", key
);
8921 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
8925 DestroyWindow(hwnd
);
8928 static void iocp_async_closesocket(SOCKET src
)
8931 WSAOVERLAPPED
*ovl_iocp
;
8938 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
8939 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
8940 ok(hwnd
!= 0, "CreateWindowEx failed\n");
8942 ret
= WSAAsyncSelect(src
, hwnd
, WM_SOCKET
, FD_READ
| FD_WRITE
| FD_OOB
| FD_ACCEPT
| FD_CONNECT
| FD_CLOSE
);
8943 ok(!ret
, "got %d\n", ret
);
8946 memset(&msg
, 0, sizeof(msg
));
8947 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
8948 ok(ret
, "got %d\n", ret
);
8949 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
8950 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
8951 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
8952 ok(msg
.lParam
== 2, "got %08lx\n", msg
.lParam
);
8954 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
8955 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
8958 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
8959 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
8963 ovl_iocp
= (void *)0xdeadbeef;
8964 SetLastError(0xdeadbeef);
8965 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
8966 ok(!ret
, "got %d\n", ret
);
8967 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
8968 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
8969 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
8970 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
8973 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
8974 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
8979 memset(&msg
, 0, sizeof(msg
));
8980 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
8981 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
8985 ovl_iocp
= (void *)0xdeadbeef;
8986 SetLastError(0xdeadbeef);
8987 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
8988 ok(!ret
, "got %d\n", ret
);
8989 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
8990 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
8991 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
8992 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
8996 DestroyWindow(hwnd
);
8999 struct wsa_async_select_info
9005 static DWORD WINAPI
wsa_async_select_thread(void *param
)
9007 struct wsa_async_select_info
*info
= param
;
9010 ret
= WSAAsyncSelect(info
->sock
, info
->hwnd
, WM_SOCKET
, FD_READ
| FD_WRITE
| FD_OOB
| FD_ACCEPT
| FD_CONNECT
| FD_CLOSE
);
9011 ok(!ret
, "got %d\n", ret
);
9016 struct wsa_recv_info
9023 static DWORD WINAPI
wsa_recv_thread(void *param
)
9025 struct wsa_recv_info
*info
= param
;
9031 SetLastError(0xdeadbeef);
9032 ret
= WSARecv(info
->sock
, &info
->wsa_buf
, 1, &bytes
, &flags
, &info
->ovl
, NULL
);
9033 ok(ret
== SOCKET_ERROR
, "got %d\n", ret
);
9034 ok(GetLastError() == ERROR_IO_PENDING
, "got %u\n", GetLastError());
9035 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9040 static void iocp_async_read_thread_closesocket(SOCKET src
)
9042 struct wsa_async_select_info select_info
;
9043 struct wsa_recv_info recv_info
;
9044 HANDLE port
, thread
;
9045 WSAOVERLAPPED
*ovl_iocp
;
9053 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
9054 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
9055 ok(hwnd
!= 0, "CreateWindowEx failed\n");
9057 select_info
.sock
= src
;
9058 select_info
.hwnd
= hwnd
;
9059 thread
= CreateThread(NULL
, 0, wsa_async_select_thread
, &select_info
, 0, &tid
);
9060 ok(thread
!= 0, "CreateThread error %u\n", GetLastError());
9061 ret
= WaitForSingleObject(thread
, 10000);
9062 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
9065 memset(&msg
, 0, sizeof(msg
));
9066 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9067 ok(ret
, "got %d\n", ret
);
9068 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
9069 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
9070 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
9071 ok(msg
.lParam
== 2, "got %08lx\n", msg
.lParam
);
9073 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
9074 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
9077 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9078 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9080 memset(data
, 0, sizeof(data
));
9081 memset(&recv_info
.ovl
, 0, sizeof(recv_info
.ovl
));
9082 recv_info
.sock
= src
;
9083 recv_info
.wsa_buf
.len
= sizeof(data
);
9084 recv_info
.wsa_buf
.buf
= data
;
9085 thread
= CreateThread(NULL
, 0, wsa_recv_thread
, &recv_info
, 0, &tid
);
9086 ok(thread
!= 0, "CreateThread error %u\n", GetLastError());
9087 ret
= WaitForSingleObject(thread
, 10000);
9088 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
9091 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9092 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9096 ovl_iocp
= (void *)0xdeadbeef;
9097 SetLastError(0xdeadbeef);
9098 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9099 ok(!ret
, "got %d\n", ret
);
9100 ok(GetLastError() == WAIT_TIMEOUT
|| broken(GetLastError() == ERROR_OPERATION_ABORTED
) /* XP */,
9101 "got %u\n", GetLastError());
9102 if (GetLastError() == WAIT_TIMEOUT
)
9104 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9105 ok(key
== 0xdeadbeef, "got key %lx\n", key
);
9106 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
9108 else /* document XP behaviour */
9110 ok(!bytes
, "got bytes %u\n", bytes
);
9111 ok(key
== 0x12345678, "got key %#lx\n", key
);
9112 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
9115 ok(!ovl_iocp
->InternalHigh
, "got %#lx\n", ovl_iocp
->InternalHigh
);
9116 ok(ovl_iocp
->Internal
== STATUS_CANCELLED
, "got %#lx\n", ovl_iocp
->Internal
);
9124 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9125 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9130 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9131 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9136 SetLastError(0xdeadbeef);
9137 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9138 ok(!ret
, "got %d\n", ret
);
9140 ok(GetLastError() == ERROR_CONNECTION_ABORTED
|| GetLastError() == ERROR_NETNAME_DELETED
/* XP */, "got %u\n", GetLastError());
9141 ok(!bytes
, "got bytes %u\n", bytes
);
9142 ok(key
== 0x12345678, "got key %#lx\n", key
);
9143 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
9146 ok(!ovl_iocp
->InternalHigh
, "got %#lx\n", ovl_iocp
->InternalHigh
);
9148 ok(ovl_iocp
->Internal
== (ULONG
)STATUS_CONNECTION_ABORTED
|| ovl_iocp
->Internal
== (ULONG
)STATUS_LOCAL_DISCONNECT
/* XP */, "got %#lx\n", ovl_iocp
->Internal
);
9154 ovl_iocp
= (void *)0xdeadbeef;
9155 SetLastError(0xdeadbeef);
9156 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9157 ok(!ret
, "got %d\n", ret
);
9158 ok(GetLastError() == WAIT_TIMEOUT
, "got %u\n", GetLastError());
9159 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9160 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
9161 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
9165 DestroyWindow(hwnd
);
9168 static void iocp_async_read_thread(SOCKET src
, SOCKET dst
)
9170 struct wsa_async_select_info select_info
;
9171 struct wsa_recv_info recv_info
;
9172 HANDLE port
, thread
;
9173 WSAOVERLAPPED
*ovl_iocp
;
9181 hwnd
= CreateWindowExA(0, "static", NULL
, WS_POPUP
,
9182 0, 0, 0, 0, NULL
, NULL
, 0, NULL
);
9183 ok(hwnd
!= 0, "CreateWindowEx failed\n");
9185 select_info
.sock
= src
;
9186 select_info
.hwnd
= hwnd
;
9187 thread
= CreateThread(NULL
, 0, wsa_async_select_thread
, &select_info
, 0, &tid
);
9188 ok(thread
!= 0, "CreateThread error %u\n", GetLastError());
9189 ret
= WaitForSingleObject(thread
, 10000);
9190 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
9193 memset(&msg
, 0, sizeof(msg
));
9194 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9195 ok(ret
, "got %d\n", ret
);
9196 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
9197 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
9198 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
9199 ok(msg
.lParam
== 2, "got %08lx\n", msg
.lParam
);
9201 port
= CreateIoCompletionPort((HANDLE
)src
, 0, 0x12345678, 0);
9202 ok(port
!= 0, "CreateIoCompletionPort error %u\n", GetLastError());
9205 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9206 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9208 memset(data
, 0, sizeof(data
));
9209 memset(&recv_info
.ovl
, 0, sizeof(recv_info
.ovl
));
9210 recv_info
.sock
= src
;
9211 recv_info
.wsa_buf
.len
= sizeof(data
);
9212 recv_info
.wsa_buf
.buf
= data
;
9213 thread
= CreateThread(NULL
, 0, wsa_recv_thread
, &recv_info
, 0, &tid
);
9214 ok(thread
!= 0, "CreateThread error %u\n", GetLastError());
9215 ret
= WaitForSingleObject(thread
, 10000);
9216 ok(ret
== WAIT_OBJECT_0
, "thread failed to terminate\n");
9219 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9220 ok(!ret
, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9224 ovl_iocp
= (void *)0xdeadbeef;
9225 SetLastError(0xdeadbeef);
9226 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9227 ok(!ret
, "got %d\n", ret
);
9228 ok(GetLastError() == WAIT_TIMEOUT
|| broken(GetLastError() == ERROR_OPERATION_ABORTED
) /* XP */, "got %u\n", GetLastError());
9229 if (GetLastError() == WAIT_TIMEOUT
)
9231 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9232 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
9233 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
9235 else /* document XP behaviour */
9237 ok(bytes
== 0, "got bytes %u\n", bytes
);
9238 ok(key
== 0x12345678, "got key %#lx\n", key
);
9239 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
9242 ok(!ovl_iocp
->InternalHigh
, "got %#lx\n", ovl_iocp
->InternalHigh
);
9243 ok(ovl_iocp
->Internal
== STATUS_CANCELLED
, "got %#lx\n", ovl_iocp
->Internal
);
9248 memset(&msg
, 0, sizeof(msg
));
9249 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9250 ok(!ret
|| broken(msg
.hwnd
== hwnd
) /* XP */, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9251 if (ret
) /* document XP behaviour */
9253 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
9254 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
9255 ok(msg
.lParam
== 1, "got %08lx\n", msg
.lParam
);
9258 ret
= send(dst
, "Hello World!", 12, 0);
9259 ok(ret
== 12, "send returned %d\n", ret
);
9262 memset(&msg
, 0, sizeof(msg
));
9263 ret
= PeekMessageA(&msg
, hwnd
, WM_SOCKET
, WM_SOCKET
, PM_REMOVE
);
9264 ok(!ret
|| broken(msg
.hwnd
== hwnd
) /* XP */, "got %04x,%08lx,%08lx\n", msg
.message
, msg
.wParam
, msg
.lParam
);
9265 if (ret
) /* document XP behaviour */
9267 ok(msg
.hwnd
== hwnd
, "got %p\n", msg
.hwnd
);
9268 ok(msg
.message
== WM_SOCKET
, "got %04x\n", msg
.message
);
9269 ok(msg
.wParam
== src
, "got %08lx\n", msg
.wParam
);
9270 ok(msg
.lParam
== 1, "got %08lx\n", msg
.lParam
);
9275 ovl_iocp
= (void *)0xdeadbeef;
9276 SetLastError(0xdeadbeef);
9277 ret
= GetQueuedCompletionStatus(port
, &bytes
, &key
, &ovl_iocp
, 100);
9278 ok(ret
|| broken(GetLastError() == WAIT_TIMEOUT
) /* XP */, "got %u\n", GetLastError());
9281 ok(bytes
== 12, "got bytes %u\n", bytes
);
9282 ok(key
== 0x12345678, "got key %#lx\n", key
);
9283 ok(ovl_iocp
== &recv_info
.ovl
, "got ovl %p\n", ovl_iocp
);
9286 ok(ovl_iocp
->InternalHigh
== 12, "got %#lx\n", ovl_iocp
->InternalHigh
);
9287 ok(!ovl_iocp
->Internal
, "got %#lx\n", ovl_iocp
->Internal
);
9288 ok(!memcmp(data
, "Hello World!", 12), "got %u bytes (%*s)\n", bytes
, bytes
, data
);
9291 else /* document XP behaviour */
9293 ok(bytes
== 0xdeadbeef, "got bytes %u\n", bytes
);
9294 ok(key
== 0xdeadbeef, "got key %lu\n", key
);
9295 ok(!ovl_iocp
, "got ovl %p\n", ovl_iocp
);
9300 DestroyWindow(hwnd
);
9303 static void test_iocp(void)
9308 tcp_socketpair(&src
, &dst
);
9309 sync_read(src
, dst
);
9310 iocp_async_read(src
, dst
);
9314 tcp_socketpair(&src
, &dst
);
9315 iocp_async_read_thread(src
, dst
);
9319 for (i
= 0; i
<= 2; i
++)
9321 tcp_socketpair(&src
, &dst
);
9322 iocp_async_read_closesocket(src
, i
);
9326 tcp_socketpair(&src
, &dst
);
9327 iocp_async_closesocket(src
);
9330 tcp_socketpair(&src
, &dst
);
9331 iocp_async_read_thread_closesocket(src
);
9335 static void test_wsaioctl(void)
9337 unsigned int i
, count
;
9338 INTERFACE_INFO
*info
;
9339 BOOL loopback_found
;
9345 s
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
9346 ok(s
!= INVALID_SOCKET
, "failed to create socket, error %u\n", WSAGetLastError());
9349 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(buffer
), &size
, NULL
, NULL
);
9350 ok(!ret
, "Got unexpected ret %d.\n", ret
);
9351 ok(size
&& size
!= 0xdeadbeef && !(size
% sizeof(INTERFACE_INFO
)), "Got unexpected size %u.\n", size
);
9353 info
= (INTERFACE_INFO
*)buffer
;
9354 count
= size
/ sizeof(INTERFACE_INFO
);
9355 loopback_found
= FALSE
;
9356 for (i
= 0; i
< count
; ++i
)
9358 if (info
[i
].iiFlags
& IFF_LOOPBACK
)
9359 loopback_found
= TRUE
;
9361 ok(info
[i
].iiAddress
.AddressIn
.sin_family
== AF_INET
, "Got unexpected sin_family %#x.\n",
9362 info
[i
].iiAddress
.AddressIn
.sin_family
);
9363 ok(info
[i
].iiNetmask
.AddressIn
.sin_family
== AF_INET
, "Got unexpected sin_family %#x.\n",
9364 info
[i
].iiNetmask
.AddressIn
.sin_family
);
9365 ok(info
[i
].iiBroadcastAddress
.AddressIn
.sin_family
9366 == (info
[i
].iiFlags
& IFF_BROADCAST
) ? AF_INET
: 0, "Got unexpected sin_family %#x.\n",
9367 info
[i
].iiBroadcastAddress
.AddressIn
.sin_family
);
9368 ok(info
[i
].iiAddress
.AddressIn
.sin_addr
.S_un
.S_addr
, "Got zero iiAddress.\n");
9369 ok(info
[i
].iiNetmask
.AddressIn
.sin_addr
.S_un
.S_addr
, "Got zero iiNetmask.\n");
9370 ok((info
[i
].iiFlags
& IFF_BROADCAST
) ? info
[i
].iiBroadcastAddress
.AddressIn
.sin_addr
.S_un
.S_addr
9371 : !info
[i
].iiBroadcastAddress
.AddressIn
.sin_addr
.S_un
.S_addr
,
9372 "Got unexpected iiBroadcastAddress %s.\n", inet_ntoa(info
[i
].iiBroadcastAddress
.AddressIn
.sin_addr
));
9375 ok(loopback_found
, "Loopback interface not found.\n");
9378 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(INTERFACE_INFO
) - 1, &size
, NULL
, NULL
);
9379 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
9380 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9381 ok(!size
, "Got unexpected size %u.\n", size
);
9383 ret
= WSAIoctl(s
, SIO_GET_INTERFACE_LIST
, NULL
, 0, buffer
, sizeof(buffer
), NULL
, NULL
, NULL
);
9384 ok(ret
== -1, "Got unexpected ret %d.\n", ret
);
9385 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9390 static void test_bind(void)
9392 const struct sockaddr_in invalid_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= inet_addr("192.0.2.0")};
9393 const struct sockaddr_in bind_addr
= {.sin_family
= AF_INET
, .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
)};
9394 struct sockaddr addr
;
9398 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9400 WSASetLastError(0xdeadbeef);
9401 ret
= bind(s
, NULL
, 0);
9402 ok(ret
== -1, "expected failure\n");
9403 todo_wine
ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
9405 addr
.sa_family
= 0xdead;
9406 WSASetLastError(0xdeadbeef);
9407 ret
= bind(s
, &addr
, sizeof(addr
));
9408 ok(ret
== -1, "expected failure\n");
9409 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "got error %u\n", WSAGetLastError());
9411 WSASetLastError(0xdeadbeef);
9412 ret
= bind(s
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
) - 1);
9413 ok(ret
== -1, "expected failure\n");
9414 ok(WSAGetLastError() == WSAEFAULT
, "got error %u\n", WSAGetLastError());
9416 WSASetLastError(0xdeadbeef);
9417 ret
= bind(s
, (const struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
9418 ok(ret
== -1, "expected failure\n");
9419 todo_wine
ok(WSAGetLastError() == WSAEADDRNOTAVAIL
, "got error %u\n", WSAGetLastError());
9421 WSASetLastError(0xdeadbeef);
9422 ret
= bind(s
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
9423 ok(!ret
, "expected success\n");
9424 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
9426 WSASetLastError(0xdeadbeef);
9427 ret
= bind(s
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
9428 ok(ret
== -1, "expected failure\n");
9429 ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
9432 ret
= getsockname(s
, &addr
, &len
);
9433 ok(!ret
, "got error %u\n", WSAGetLastError());
9435 s2
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9437 WSASetLastError(0xdeadbeef);
9438 ret
= bind(s2
, &addr
, sizeof(addr
));
9439 ok(ret
== -1, "expected failure\n");
9440 ok(WSAGetLastError() == WSAEADDRINUSE
, "got error %u\n", WSAGetLastError());
9445 s
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
9447 WSASetLastError(0xdeadbeef);
9448 ret
= bind(s
, (const struct sockaddr
*)&bind_addr
, sizeof(bind_addr
));
9449 ok(!ret
, "expected success\n");
9450 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
9455 /* Test calling methods on a socket which is currently connecting. */
9456 static void test_connecting_socket(void)
9458 const struct sockaddr_in invalid_addr
=
9460 .sin_family
= AF_INET
,
9461 .sin_addr
.s_addr
= inet_addr("192.0.2.0"),
9464 struct sockaddr_in addr
;
9469 client
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9470 ok(client
!= -1, "failed to create socket, error %u\n", WSAGetLastError());
9471 set_blocking(client
, FALSE
);
9473 ret
= connect(client
, (struct sockaddr
*)&invalid_addr
, sizeof(invalid_addr
));
9474 ok(ret
== -1, "got %d\n", ret
);
9475 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got %u\n", WSAGetLastError());
9478 ret
= getsockname(client
, (struct sockaddr
*)&addr
, &len
);
9479 ok(!ret
, "got error %u\n", WSAGetLastError());
9480 ok(addr
.sin_family
== AF_INET
, "got family %u\n", addr
.sin_family
);
9481 ok(addr
.sin_port
, "expected nonzero port\n");
9484 ret
= getpeername(client
, (struct sockaddr
*)&addr
, &len
);
9485 todo_wine
ok(!ret
, "got error %u\n", WSAGetLastError());
9488 ok(addr
.sin_family
== AF_INET
, "got family %u\n", addr
.sin_family
);
9489 ok(addr
.sin_addr
.s_addr
== inet_addr("192.0.2.0"), "got address %#08x\n", addr
.sin_addr
.s_addr
);
9490 ok(addr
.sin_port
== 255, "expected nonzero port\n");
9493 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
9494 ok(ret
== -1, "got %d\n", ret
);
9495 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got %u\n", WSAGetLastError());
9497 ret
= send(client
, "data", 5, 0);
9498 ok(ret
== -1, "got %d\n", ret
);
9499 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "got %u\n", WSAGetLastError());
9501 closesocket(client
);
9504 static DWORD
map_status( NTSTATUS status
)
9513 {STATUS_PENDING
, ERROR_IO_INCOMPLETE
},
9515 {STATUS_BUFFER_OVERFLOW
, WSAEMSGSIZE
},
9517 {STATUS_NOT_IMPLEMENTED
, WSAEOPNOTSUPP
},
9518 {STATUS_ACCESS_VIOLATION
, WSAEFAULT
},
9519 {STATUS_PAGEFILE_QUOTA
, WSAENOBUFS
},
9520 {STATUS_INVALID_HANDLE
, WSAENOTSOCK
},
9521 {STATUS_NO_SUCH_DEVICE
, WSAENETDOWN
},
9522 {STATUS_NO_SUCH_FILE
, WSAENETDOWN
},
9523 {STATUS_NO_MEMORY
, WSAENOBUFS
},
9524 {STATUS_CONFLICTING_ADDRESSES
, WSAENOBUFS
},
9525 {STATUS_ACCESS_DENIED
, WSAEACCES
},
9526 {STATUS_BUFFER_TOO_SMALL
, WSAEFAULT
},
9527 {STATUS_OBJECT_TYPE_MISMATCH
, WSAENOTSOCK
},
9528 {STATUS_OBJECT_NAME_NOT_FOUND
, WSAENETDOWN
},
9529 {STATUS_OBJECT_PATH_NOT_FOUND
, WSAENETDOWN
},
9530 {STATUS_SHARING_VIOLATION
, WSAEADDRINUSE
},
9531 {STATUS_QUOTA_EXCEEDED
, WSAENOBUFS
},
9532 {STATUS_TOO_MANY_PAGING_FILES
, WSAENOBUFS
},
9533 {STATUS_INSUFFICIENT_RESOURCES
, WSAENOBUFS
},
9534 {STATUS_WORKING_SET_QUOTA
, WSAENOBUFS
},
9535 {STATUS_DEVICE_NOT_READY
, WSAEWOULDBLOCK
},
9536 {STATUS_PIPE_DISCONNECTED
, WSAESHUTDOWN
},
9537 {STATUS_IO_TIMEOUT
, WSAETIMEDOUT
},
9538 {STATUS_NOT_SUPPORTED
, WSAEOPNOTSUPP
},
9539 {STATUS_REMOTE_NOT_LISTENING
, WSAECONNREFUSED
},
9540 {STATUS_BAD_NETWORK_PATH
, WSAENETUNREACH
},
9541 {STATUS_NETWORK_BUSY
, WSAENETDOWN
},
9542 {STATUS_INVALID_NETWORK_RESPONSE
, WSAENETDOWN
},
9543 {STATUS_UNEXPECTED_NETWORK_ERROR
, WSAENETDOWN
},
9544 {STATUS_REQUEST_NOT_ACCEPTED
, WSAEWOULDBLOCK
},
9545 {STATUS_CANCELLED
, ERROR_OPERATION_ABORTED
},
9546 {STATUS_COMMITMENT_LIMIT
, WSAENOBUFS
},
9547 {STATUS_LOCAL_DISCONNECT
, WSAECONNABORTED
},
9548 {STATUS_REMOTE_DISCONNECT
, WSAECONNRESET
},
9549 {STATUS_REMOTE_RESOURCES
, WSAENOBUFS
},
9550 {STATUS_LINK_FAILED
, WSAECONNRESET
},
9551 {STATUS_LINK_TIMEOUT
, WSAETIMEDOUT
},
9552 {STATUS_INVALID_CONNECTION
, WSAENOTCONN
},
9553 {STATUS_INVALID_ADDRESS
, WSAEADDRNOTAVAIL
},
9554 {STATUS_INVALID_BUFFER_SIZE
, WSAEMSGSIZE
},
9555 {STATUS_INVALID_ADDRESS_COMPONENT
, WSAEADDRNOTAVAIL
},
9556 {STATUS_TOO_MANY_ADDRESSES
, WSAENOBUFS
},
9557 {STATUS_ADDRESS_ALREADY_EXISTS
, WSAEADDRINUSE
},
9558 {STATUS_CONNECTION_DISCONNECTED
, WSAECONNRESET
},
9559 {STATUS_CONNECTION_RESET
, WSAECONNRESET
},
9560 {STATUS_TRANSACTION_ABORTED
, WSAECONNABORTED
},
9561 {STATUS_CONNECTION_REFUSED
, WSAECONNREFUSED
},
9562 {STATUS_GRACEFUL_DISCONNECT
, WSAEDISCON
},
9563 {STATUS_CONNECTION_ACTIVE
, WSAEISCONN
},
9564 {STATUS_NETWORK_UNREACHABLE
, WSAENETUNREACH
},
9565 {STATUS_HOST_UNREACHABLE
, WSAEHOSTUNREACH
},
9566 {STATUS_PROTOCOL_UNREACHABLE
, WSAENETUNREACH
},
9567 {STATUS_PORT_UNREACHABLE
, WSAECONNRESET
},
9568 {STATUS_REQUEST_ABORTED
, WSAEINTR
},
9569 {STATUS_CONNECTION_ABORTED
, WSAECONNABORTED
},
9570 {STATUS_DATATYPE_MISALIGNMENT_ERROR
,WSAEFAULT
},
9571 {STATUS_HOST_DOWN
, WSAEHOSTDOWN
},
9572 {0x80070000 | ERROR_IO_INCOMPLETE
, ERROR_IO_INCOMPLETE
},
9573 {0xc0010000 | ERROR_IO_INCOMPLETE
, ERROR_IO_INCOMPLETE
},
9574 {0xc0070000 | ERROR_IO_INCOMPLETE
, ERROR_IO_INCOMPLETE
},
9579 for (i
= 0; i
< ARRAY_SIZE(errors
); ++i
)
9581 if (errors
[i
].status
== status
)
9582 return errors
[i
].error
;
9585 return NT_SUCCESS(status
) ? RtlNtStatusToDosErrorNoTeb(status
) : WSAEINVAL
;
9588 static void test_WSAGetOverlappedResult(void)
9590 OVERLAPPED overlapped
= {0};
9597 static const NTSTATUS ranges
[][2] =
9600 {0x40000000, 0x40001000},
9601 {0x80000000, 0x80001000},
9602 {0x80070000, 0x80080000},
9603 {0xc0000000, 0xc0001000},
9604 {0xc0070000, 0xc0080000},
9605 {0xd0000000, 0xd0001000},
9606 {0xd0070000, 0xd0080000},
9609 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9611 for (i
= 0; i
< ARRAY_SIZE(ranges
); ++i
)
9613 for (status
= ranges
[i
][0]; status
< ranges
[i
][1]; ++status
)
9615 BOOL expect_ret
= NT_SUCCESS(status
) && status
!= STATUS_PENDING
;
9616 DWORD expect
= map_status(status
);
9618 overlapped
.Internal
= status
;
9619 WSASetLastError(0xdeadbeef);
9620 ret
= WSAGetOverlappedResult(s
, &overlapped
, &size
, FALSE
, &flags
);
9621 ok(ret
== expect_ret
, "status %#x: expected %d, got %d\n", status
, expect_ret
, ret
);
9624 ok(WSAGetLastError() == expect
/* >= win10 1809 */
9625 || !WSAGetLastError() /* < win10 1809 */
9626 || WSAGetLastError() == 0xdeadbeef, /* < win7 */
9627 "status %#x: expected error %u, got %u\n", status
, expect
, WSAGetLastError());
9631 ok(WSAGetLastError() == expect
9632 || (status
== (0xc0070000 | ERROR_IO_INCOMPLETE
) && WSAGetLastError() == WSAEINVAL
), /* < win8 */
9633 "status %#x: expected error %u, got %u\n", status
, expect
, WSAGetLastError());
9641 struct nonblocking_async_recv_params
9647 static DWORD CALLBACK
nonblocking_async_recv_thread(void *arg
)
9649 const struct nonblocking_async_recv_params
*params
= arg
;
9650 OVERLAPPED overlapped
= {0};
9651 DWORD flags
= 0, size
;
9656 overlapped
.hEvent
= params
->event
;
9657 wsabuf
.buf
= buffer
;
9658 wsabuf
.len
= sizeof(buffer
);
9659 memset(buffer
, 0, sizeof(buffer
));
9660 ret
= WSARecv(params
->client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
9661 todo_wine_if (!params
->event
) ok(!ret
, "got %d\n", ret
);
9662 ret
= GetOverlappedResult((HANDLE
)params
->client
, &overlapped
, &size
, FALSE
);
9663 ok(ret
, "got error %u\n", GetLastError());
9664 todo_wine
ok(size
== 4, "got size %u\n", size
);
9665 todo_wine_if (!params
->event
) ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
9670 static void test_nonblocking_async_recv(void)
9672 struct nonblocking_async_recv_params params
;
9673 OVERLAPPED overlapped
= {0};
9674 SOCKET client
, server
;
9675 DWORD flags
= 0, size
;
9676 HANDLE thread
, event
;
9681 event
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
9682 wsabuf
.buf
= buffer
;
9683 wsabuf
.len
= sizeof(buffer
);
9685 tcp_socketpair(&client
, &server
);
9686 set_blocking(client
, FALSE
);
9687 set_blocking(server
, FALSE
);
9689 WSASetLastError(0xdeadbeef);
9690 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
9691 ok(ret
== -1, "got %d\n", ret
);
9692 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
9694 WSASetLastError(0xdeadbeef);
9695 overlapped
.Internal
= 0xdeadbeef;
9696 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, NULL
, NULL
);
9697 ok(ret
== -1, "got %d\n", ret
);
9698 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
9699 ok(overlapped
.Internal
== 0xdeadbeef, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
9701 /* Overlapped, with a NULL event. */
9703 overlapped
.hEvent
= NULL
;
9705 memset(buffer
, 0, sizeof(buffer
));
9706 WSASetLastError(0xdeadbeef);
9707 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
9708 ok(ret
== -1, "got %d\n", ret
);
9709 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
9710 ret
= WaitForSingleObject((HANDLE
)client
, 0);
9711 ok(ret
== WAIT_TIMEOUT
, "expected timeout\n");
9713 ret
= send(server
, "data", 4, 0);
9714 ok(ret
== 4, "got %d\n", ret
);
9716 ret
= WaitForSingleObject((HANDLE
)client
, 1000);
9717 ok(!ret
, "wait timed out\n");
9718 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
9719 ok(ret
, "got error %u\n", GetLastError());
9720 ok(size
== 4, "got size %u\n", size
);
9721 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
9723 /* Overlapped, with a non-NULL event. */
9725 overlapped
.hEvent
= event
;
9727 memset(buffer
, 0, sizeof(buffer
));
9728 WSASetLastError(0xdeadbeef);
9729 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
9730 ok(ret
== -1, "got %d\n", ret
);
9731 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
9732 ret
= WaitForSingleObject(event
, 0);
9733 ok(ret
== WAIT_TIMEOUT
, "expected timeout\n");
9735 ret
= send(server
, "data", 4, 0);
9736 ok(ret
== 4, "got %d\n", ret
);
9738 ret
= WaitForSingleObject(event
, 1000);
9739 ok(!ret
, "wait timed out\n");
9740 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
9741 ok(ret
, "got error %u\n", GetLastError());
9742 ok(size
== 4, "got size %u\n", size
);
9743 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
9745 /* With data already in the pipe; usually this does return 0 (but not
9748 ret
= send(server
, "data", 4, 0);
9749 ok(ret
== 4, "got %d\n", ret
);
9751 memset(buffer
, 0, sizeof(buffer
));
9752 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
9753 ok(!ret
|| WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
9754 ret
= WaitForSingleObject(event
, 1000);
9755 ok(!ret
, "wait timed out\n");
9756 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
9757 ok(ret
, "got error %u\n", GetLastError());
9758 ok(size
== 4, "got size %u\n", size
);
9759 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
9761 closesocket(client
);
9762 closesocket(server
);
9764 /* With a non-overlapped socket, WSARecv() always blocks when passed an
9765 * overlapped structure, but returns WSAEWOULDBLOCK otherwise. */
9767 tcp_socketpair_flags(&client
, &server
, 0);
9768 set_blocking(client
, FALSE
);
9769 set_blocking(server
, FALSE
);
9771 WSASetLastError(0xdeadbeef);
9772 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
9773 ok(ret
== -1, "got %d\n", ret
);
9774 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
9776 WSASetLastError(0xdeadbeef);
9777 overlapped
.Internal
= 0xdeadbeef;
9778 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, NULL
, NULL
);
9779 ok(ret
== -1, "got %d\n", ret
);
9780 ok(WSAGetLastError() == WSAEWOULDBLOCK
, "got error %u\n", WSAGetLastError());
9781 ok(overlapped
.Internal
== 0xdeadbeef, "got status %#x\n", (NTSTATUS
)overlapped
.Internal
);
9783 /* Overlapped, with a NULL event. */
9785 params
.client
= client
;
9786 params
.event
= NULL
;
9787 thread
= CreateThread(NULL
, 0, nonblocking_async_recv_thread
, ¶ms
, 0, NULL
);
9789 ret
= WaitForSingleObject(thread
, 200);
9790 todo_wine
ok(ret
== WAIT_TIMEOUT
, "expected timeout\n");
9792 ret
= send(server
, "data", 4, 0);
9793 ok(ret
== 4, "got %d\n", ret
);
9795 ret
= WaitForSingleObject(thread
, 200);
9796 ok(!ret
, "wait timed out\n");
9797 CloseHandle(thread
);
9799 /* Overlapped, with a non-NULL event. */
9801 params
.client
= client
;
9802 params
.event
= event
;
9803 thread
= CreateThread(NULL
, 0, nonblocking_async_recv_thread
, ¶ms
, 0, NULL
);
9805 ret
= WaitForSingleObject(thread
, 200);
9806 todo_wine
ok(ret
== WAIT_TIMEOUT
, "expected timeout\n");
9808 ret
= send(server
, "data", 4, 0);
9809 ok(ret
== 4, "got %d\n", ret
);
9811 ret
= WaitForSingleObject(thread
, 200);
9812 ok(!ret
, "wait timed out\n");
9813 CloseHandle(thread
);
9815 /* With data already in the pipe. */
9817 ret
= send(server
, "data", 4, 0);
9818 ok(ret
== 4, "got %d\n", ret
);
9820 memset(buffer
, 0, sizeof(buffer
));
9821 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
9822 ok(!ret
, "got %d\n", ret
);
9823 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
9824 todo_wine
ok(ret
, "got error %u\n", GetLastError());
9825 ok(size
== 4, "got size %u\n", size
);
9826 todo_wine
ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, size
));
9828 closesocket(client
);
9829 closesocket(server
);
9831 CloseHandle(overlapped
.hEvent
);
9834 static void test_empty_recv(void)
9836 OVERLAPPED overlapped
= {0};
9837 SOCKET client
, server
;
9838 DWORD size
, flags
= 0;
9843 overlapped
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
9844 tcp_socketpair(&client
, &server
);
9846 WSASetLastError(0xdeadbeef);
9847 ret
= WSARecv(client
, NULL
, 0, NULL
, &flags
, &overlapped
, NULL
);
9848 ok(ret
== -1, "expected failure\n");
9849 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
9851 wsabuf
.buf
= buffer
;
9853 WSASetLastError(0xdeadbeef);
9854 ret
= WSARecv(client
, &wsabuf
, 0, NULL
, &flags
, &overlapped
, NULL
);
9855 ok(ret
== -1, "expected failure\n");
9856 todo_wine
ok(WSAGetLastError() == WSAEINVAL
, "got error %u\n", WSAGetLastError());
9858 WSASetLastError(0xdeadbeef);
9859 ret
= WSARecv(client
, &wsabuf
, 1, NULL
, &flags
, &overlapped
, NULL
);
9860 ok(ret
== -1, "expected failure\n");
9861 ok(WSAGetLastError() == ERROR_IO_PENDING
, "got error %u\n", WSAGetLastError());
9863 ret
= send(server
, "data", 5, 0);
9864 ok(ret
== 5, "got %d\n", ret
);
9866 ret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
9867 ok(!ret
, "wait failed\n");
9868 ret
= GetOverlappedResult((HANDLE
)client
, &overlapped
, &size
, FALSE
);
9869 ok(ret
, "got error %u\n", GetLastError());
9870 ok(!size
, "got size %u\n", size
);
9872 WSASetLastError(0xdeadbeef);
9873 ret
= WSARecv(client
, &wsabuf
, 1, &size
, &flags
, &overlapped
, NULL
);
9874 ok(!ret
, "got error %u\n", WSAGetLastError());
9875 ok(!size
, "got size %u\n", size
);
9877 ret
= recv(client
, NULL
, 0, 0);
9878 ok(!ret
, "got %d\n", ret
);
9880 ret
= recv(client
, buffer
, sizeof(buffer
), 0);
9881 ok(ret
== 5, "got %d\n", ret
);
9882 ok(!strcmp(buffer
, "data"), "got %s\n", debugstr_an(buffer
, ret
));
9884 closesocket(client
);
9885 closesocket(server
);
9886 CloseHandle(overlapped
.hEvent
);
9893 /* Leave these tests at the beginning. They depend on WSAStartup not having been
9894 * called, which is done by Init() below. */
9895 test_WithoutWSAStartup();
9896 test_WithWSAStartup();
9900 test_set_getsockopt();
9901 test_so_reuseaddr();
9903 test_extendedSocketOptions();
9905 for (i
= 0; i
< ARRAY_SIZE(tests
); i
++)
9911 test_WSADuplicateSocket();
9912 test_WSAEnumNetworkEvents();
9932 test_TransmitFile();
9936 test_DisconnectEx();
9938 test_sioRoutingInterfaceQuery();
9939 test_sioAddressListChange();
9941 test_completion_port();
9942 test_connect_completion_port();
9943 test_shutdown_completion_port();
9944 test_address_list_query();
9946 test_connecting_socket();
9947 test_WSAGetOverlappedResult();
9948 test_nonblocking_async_recv();
9951 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
9953 test_synchronous_WSAIoctl();