?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
server: Return ERROR_CONNECTION_RESET when trying to recv() on a reset socket.
[wine.git] / dlls / ws2_32 / tests / sock.c
blob8530d80d3d996c536897f5901445a533e48a0db0
1 /*
2 * Unit test suite for winsock functions
3 *
4 * Copyright 2002 Martin Wilck
5 * Copyright 2005 Thomas Kho
6 * Copyright 2008 Jeff Zaroyko
7 * Copyright 2017 Dmitry Timoshkov
8 *
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.
13 *
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.
18 *
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
22 */
23
24 #include <ntstatus.h>
25 #define WIN32_NO_STATUS
26 #include <winsock2.h>
27 #include <windows.h>
28 #include <winternl.h>
29 #include <iphlpapi.h>
30 #include <ws2tcpip.h>
31 #include <wsipx.h>
32 #include <wsnwlink.h>
33 #include <mswsock.h>
34 #include <mstcpip.h>
35 #include <stdio.h>
36 #include "wine/test.h"
37
38 #define MAX_CLIENTS 4 /* Max number of clients */
39 #define FIRST_CHAR 'A' /* First character in transferred pattern */
40 #define BIND_SLEEP 10 /* seconds to wait between attempts to bind() */
41 #define BIND_TRIES 6 /* Number of bind() attempts */
42 #define TEST_TIMEOUT 30 /* seconds to wait before killing child threads
43 after server initialization, if something hangs */
44
45 #define NUM_UDP_PEERS 3 /* Number of UDP sockets to create and test > 1 */
46
47 #define SERVERIP "127.0.0.1" /* IP to bind to */
48 #define SERVERPORT 9374 /* Port number to bind to */
49
50 #define wsa_ok(op, cond, msg) \
51 do { \
52 int tmp, err = 0; \
53 tmp = op; \
54 if ( !(cond tmp) ) err = WSAGetLastError(); \
55 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
56 } while (0);
57
58 #define make_keepalive(k, enable, time, interval) \
59 k.onoff = enable; \
60 k.keepalivetime = time; \
61 k.keepaliveinterval = interval;
62
63 /* Function pointers */
64 static int (WINAPI *pWSAPoll)(WSAPOLLFD *,ULONG,INT);
65
66 /* Function pointers from ntdll */
67 static DWORD (WINAPI *pNtClose)(HANDLE);
68
69 /**************** Structs and typedefs ***************/
70
71 typedef struct thread_info
72 {
73 HANDLE thread;
74 DWORD id;
75 } thread_info;
76
77 /* Information in the server about open client connections */
78 typedef struct sock_info
79 {
80 SOCKET s;
81 struct sockaddr_in addr;
82 struct sockaddr_in peer;
83 char *buf;
84 int n_recvd;
85 int n_sent;
86 } sock_info;
87
88 /* Test parameters for both server & client */
89 typedef struct test_params
90 {
91 int sock_type;
92 int sock_prot;
93 const char *inet_addr;
94 short inet_port;
95 int chunk_size;
96 int n_chunks;
97 int n_clients;
98 } test_params;
99
100 /* server-specific test parameters */
101 typedef struct server_params
102 {
103 test_params *general;
104 DWORD sock_flags;
105 int buflen;
106 } server_params;
107
108 /* client-specific test parameters */
109 typedef struct client_params
110 {
111 test_params *general;
112 DWORD sock_flags;
113 int buflen;
114 } client_params;
115
116 /* This type combines all information for setting up a test scenario */
117 typedef struct test_setup
118 {
119 test_params general;
120 LPVOID srv;
121 server_params srv_params;
122 LPVOID clt;
123 client_params clt_params;
124 } test_setup;
125
126 /* Thread local storage for server */
127 typedef struct server_memory
128 {
129 SOCKET s;
130 struct sockaddr_in addr;
131 sock_info sock[MAX_CLIENTS];
132 } server_memory;
133
134 /* Thread local storage for client */
135 typedef struct client_memory
136 {
137 SOCKET s;
138 struct sockaddr_in addr;
139 char *send_buf;
140 char *recv_buf;
141 } client_memory;
142
143 /* SelectReadThread thread parameters */
144 typedef struct select_thread_params
145 {
146 SOCKET s;
147 BOOL ReadKilled;
148 } select_thread_params;
149
150 /**************** Static variables ***************/
151
152 static DWORD tls; /* Thread local storage index */
153 static HANDLE thread[1+MAX_CLIENTS];
154 static DWORD thread_id[1+MAX_CLIENTS];
155 static HANDLE server_ready;
156 static HANDLE client_ready[MAX_CLIENTS];
157 static int client_id;
158 static GUID WSARecvMsg_GUID = WSAID_WSARECVMSG;
159
160 /**************** General utility functions ***************/
161
162 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len);
163 static SOCKET setup_connector_socket(const struct sockaddr_in *addr, int len, BOOL nonblock);
164 static int sync_recv(SOCKET s, void *buffer, int len, DWORD flags);
165
166 static void tcp_socketpair_flags(SOCKET *src, SOCKET *dst, DWORD flags)
167 {
168 SOCKET server = INVALID_SOCKET;
169 struct sockaddr_in addr;
170 int len, ret;
171
172 *src = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, flags);
173 ok(*src != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
174
175 server = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, flags);
176 ok(server != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
177
178 memset(&addr, 0, sizeof(addr));
179 addr.sin_family = AF_INET;
180 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
181 ret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
182 ok(!ret, "failed to bind socket, error %u\n", WSAGetLastError());
183
184 len = sizeof(addr);
185 ret = getsockname(server, (struct sockaddr *)&addr, &len);
186 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
187
188 ret = listen(server, 1);
189 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
190
191 ret = connect(*src, (struct sockaddr *)&addr, sizeof(addr));
192 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
193
194 len = sizeof(addr);
195 *dst = accept(server, (struct sockaddr *)&addr, &len);
196 ok(*dst != INVALID_SOCKET, "failed to accept socket, error %u\n", WSAGetLastError());
197
198 closesocket(server);
199 }
200
201 static void tcp_socketpair(SOCKET *src, SOCKET *dst)
202 {
203 tcp_socketpair_flags(src, dst, WSA_FLAG_OVERLAPPED);
204 }
205
206 static void WINAPI apc_func(ULONG_PTR apc_count)
207 {
208 ++*(unsigned int *)apc_count;
209 }
210
211 /* Set the linger timeout to zero and close the socket. This will trigger an
212 * RST on the connection on Windows as well as on Unix systems. */
213 static void close_with_rst(SOCKET s)
214 {
215 static const struct linger linger = {.l_onoff = 1};
216 int ret;
217
218 SetLastError(0xdeadbeef);
219 ret = setsockopt(s, SOL_SOCKET, SO_LINGER, (const char *)&linger, sizeof(linger));
220 ok(!ret, "got %d\n", ret);
221 ok(!GetLastError(), "got error %lu\n", GetLastError());
222
223 closesocket(s);
224 }
225
226 #define check_poll(a, b) check_poll_(__LINE__, a, POLLRDNORM | POLLRDBAND | POLLWRNORM, b, FALSE)
227 #define check_poll_todo(a, b) check_poll_(__LINE__, a, POLLRDNORM | POLLRDBAND | POLLWRNORM, b, TRUE)
228 #define check_poll_mask(a, b, c) check_poll_(__LINE__, a, b, c, FALSE)
229 #define check_poll_mask_todo(a, b, c) check_poll_(__LINE__, a, b, c, TRUE)
230 static void check_poll_(int line, SOCKET s, short mask, short expect, BOOL todo)
231 {
232 WSAPOLLFD pollfd;
233 int ret;
234
235 pollfd.fd = s;
236 pollfd.events = mask;
237 pollfd.revents = 0xdead;
238 ret = pWSAPoll(&pollfd, 1, 1000);
239 ok_(__FILE__, line)(ret == (pollfd.revents ? 1 : 0), "WSAPoll() returned %d\n", ret);
240 todo_wine_if (todo) ok_(__FILE__, line)(pollfd.revents == expect, "got wrong events %#x\n", pollfd.revents);
241 }
242
243 static DWORD WINAPI poll_async_thread(void *arg)
244 {
245 WSAPOLLFD *pollfd = arg;
246 int ret;
247
248 ret = pWSAPoll(pollfd, 1, 500);
249 ok(ret == (pollfd->revents ? 1 : 0), "WSAPoll() returned %d\n", ret);
250
251 return 0;
252 }
253
254 static void set_so_opentype ( BOOL overlapped )
255 {
256 int optval = !overlapped, newval, len = sizeof (int);
257
258 ok ( setsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
259 (LPVOID) &optval, sizeof (optval) ) == 0,
260 "setting SO_OPENTYPE failed\n" );
261 ok ( getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
262 (LPVOID) &newval, &len ) == 0,
263 "getting SO_OPENTYPE failed\n" );
264 ok ( optval == newval, "failed to set SO_OPENTYPE\n" );
265 }
266
267 static int set_blocking ( SOCKET s, BOOL blocking )
268 {
269 u_long val = !blocking;
270 return ioctlsocket ( s, FIONBIO, &val );
271 }
272
273 static void fill_buffer ( char *buf, int chunk_size, int n_chunks )
274 {
275 char c, *p;
276 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
277 memset ( p, c, chunk_size );
278 }
279
280 static int test_buffer ( char *buf, int chunk_size, int n_chunks )
281 {
282 char c, *p;
283 int i;
284 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
285 {
286 for ( i = 0; i < chunk_size; i++ )
287 if ( p[i] != c ) return i;
288 }
289 return -1;
290 }
291
292 /*
293 * This routine is called when a client / server does not expect any more data,
294 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
295 */
296 static void read_zero_bytes ( SOCKET s )
297 {
298 char buf[256];
299 int tmp, n = 0;
300 while ( ( tmp = recv ( s, buf, 256, 0 ) ) > 0 )
301 n += tmp;
302 ok ( n <= 0, "garbage data received: %d bytes\n", n );
303 }
304
305 static int do_synchronous_send ( SOCKET s, char *buf, int buflen, int flags, int sendlen )
306 {
307 char* last = buf + buflen, *p;
308 int n = 1;
309 for ( p = buf; n > 0 && p < last; )
310 {
311 n = send ( s, p, min ( sendlen, last - p ), flags );
312 if (n > 0) p += n;
313 }
314 wsa_ok ( n, 0 <=, "do_synchronous_send (%lx): error %d\n" );
315 return p - buf;
316 }
317
318 static int do_synchronous_recv ( SOCKET s, char *buf, int buflen, int flags, int recvlen )
319 {
320 char* last = buf + buflen, *p;
321 int n = 1;
322 for ( p = buf; n > 0 && p < last; )
323 {
324 n = recv ( s, p, min ( recvlen, last - p ), flags );
325 if (n > 0) p += n;
326 }
327 wsa_ok ( n, 0 <=, "do_synchronous_recv (%lx): error %d:\n" );
328 return p - buf;
329 }
330
331 static int do_synchronous_recvfrom ( SOCKET s, char *buf, int buflen, int flags, struct sockaddr *from, int *fromlen, int recvlen )
332 {
333 char* last = buf + buflen, *p;
334 int n = 1;
335 for ( p = buf; n > 0 && p < last; )
336 {
337 n = recvfrom ( s, p, min ( recvlen, last - p ), flags, from, fromlen );
338 if (n > 0) p += n;
339 }
340 wsa_ok ( n, 0 <=, "do_synchronous_recv (%lx): error %d:\n" );
341 return p - buf;
342 }
343
344 /*
345 * Call this routine right after thread startup.
346 * SO_OPENTYPE must by 0, regardless what the server did.
347 */
348 static void check_so_opentype (void)
349 {
350 int tmp = 1, len;
351 len = sizeof (tmp);
352 getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (LPVOID) &tmp, &len );
353 ok ( tmp == 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp );
354 }
355
356 /**************** Server utility functions ***************/
357
358 /*
359 * Even if we have closed our server socket cleanly,
360 * the OS may mark the address "in use" for some time -
361 * this happens with native Linux apps, too.
362 */
363 static void do_bind ( SOCKET s, struct sockaddr* addr, int addrlen )
364 {
365 int err, wsaerr = 0, n_try = BIND_TRIES;
366
367 while ( ( err = bind ( s, addr, addrlen ) ) != 0 &&
368 ( wsaerr = WSAGetLastError () ) == WSAEADDRINUSE &&
369 n_try-- >= 0)
370 {
371 trace ( "address in use, waiting ...\n" );
372 Sleep ( 1000 * BIND_SLEEP );
373 }
374 ok ( err == 0, "failed to bind: %d\n", wsaerr );
375 }
376
377 static void server_start ( server_params *par )
378 {
379 int i;
380 test_params *gen = par->general;
381 server_memory *mem = LocalAlloc ( LPTR, sizeof ( server_memory ) );
382
383 TlsSetValue ( tls, mem );
384 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
385 NULL, 0, par->sock_flags );
386 ok ( mem->s != INVALID_SOCKET, "Server: WSASocket failed\n" );
387
388 mem->addr.sin_family = AF_INET;
389 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
390 mem->addr.sin_port = htons ( gen->inet_port );
391
392 for (i = 0; i < MAX_CLIENTS; i++)
393 {
394 mem->sock[i].s = INVALID_SOCKET;
395 mem->sock[i].buf = LocalAlloc ( LPTR, gen->n_chunks * gen->chunk_size );
396 mem->sock[i].n_recvd = 0;
397 mem->sock[i].n_sent = 0;
398 }
399
400 if ( gen->sock_type == SOCK_STREAM )
401 do_bind ( mem->s, (struct sockaddr*) &mem->addr, sizeof (mem->addr) );
402 }
403
404 static void server_stop (void)
405 {
406 int i;
407 server_memory *mem = TlsGetValue ( tls );
408
409 for (i = 0; i < MAX_CLIENTS; i++ )
410 {
411 LocalFree ( mem->sock[i].buf );
412 if ( mem->sock[i].s != INVALID_SOCKET )
413 closesocket ( mem->sock[i].s );
414 }
415 ok ( closesocket ( mem->s ) == 0, "closesocket failed\n" );
416 LocalFree ( mem );
417 ExitThread ( GetCurrentThreadId () );
418 }
419
420 /**************** Client utilitiy functions ***************/
421
422 static void client_start ( client_params *par )
423 {
424 test_params *gen = par->general;
425 client_memory *mem = LocalAlloc (LPTR, sizeof (client_memory));
426
427 TlsSetValue ( tls, mem );
428
429 WaitForSingleObject ( server_ready, INFINITE );
430
431 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
432 NULL, 0, par->sock_flags );
433
434 mem->addr.sin_family = AF_INET;
435 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
436 mem->addr.sin_port = htons ( gen->inet_port );
437
438 ok ( mem->s != INVALID_SOCKET, "Client: WSASocket failed\n" );
439
440 mem->send_buf = LocalAlloc ( LPTR, 2 * gen->n_chunks * gen->chunk_size );
441 mem->recv_buf = mem->send_buf + gen->n_chunks * gen->chunk_size;
442 fill_buffer ( mem->send_buf, gen->chunk_size, gen->n_chunks );
443
444 SetEvent ( client_ready[client_id] );
445 /* Wait for the other clients to come up */
446 WaitForMultipleObjects ( min ( gen->n_clients, MAX_CLIENTS ), client_ready, TRUE, INFINITE );
447 }
448
449 static void client_stop (void)
450 {
451 client_memory *mem = TlsGetValue ( tls );
452 wsa_ok ( closesocket ( mem->s ), 0 ==, "closesocket error (%lx): %d\n" );
453 LocalFree ( mem->send_buf );
454 LocalFree ( mem );
455 ExitThread(0);
456 }
457
458 /**************** Servers ***************/
459
460 /*
461 * simple_server: A very basic server doing synchronous IO.
462 */
463 static VOID WINAPI simple_server ( server_params *par )
464 {
465 test_params *gen = par->general;
466 server_memory *mem;
467 int pos, n_recvd, n_sent, n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
468 id = GetCurrentThreadId();
469
470 set_so_opentype ( FALSE ); /* non-overlapped */
471 server_start ( par );
472 mem = TlsGetValue ( tls );
473
474 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "simple_server (%lx): failed to set blocking mode: %d\n");
475 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "simple_server (%lx): listen failed: %d\n");
476
477 SetEvent ( server_ready ); /* notify clients */
478
479 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
480 {
481 /* accept a single connection */
482 tmp = sizeof ( mem->sock[0].peer );
483 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
484 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "simple_server (%lx): accept failed: %d\n" );
485
486 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
487 "simple_server (%x): strange peer address\n", id );
488
489 /* Receive data & check it */
490 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
491 ok ( n_recvd == n_expected,
492 "simple_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
493 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
494 ok ( pos == -1, "simple_server (%x): test pattern error: %d\n", id, pos);
495
496 /* Echo data back */
497 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
498 ok ( n_sent == n_expected,
499 "simple_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
500
501 /* cleanup */
502 read_zero_bytes ( mem->sock[0].s );
503 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "simple_server (%lx): closesocket error: %d\n" );
504 mem->sock[0].s = INVALID_SOCKET;
505 }
506
507 server_stop ();
508 }
509
510 /*
511 * oob_server: A very basic server receiving out-of-band data.
512 */
513 static VOID WINAPI oob_server ( server_params *par )
514 {
515 test_params *gen = par->general;
516 server_memory *mem;
517 u_long atmark = 0;
518 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, tmp,
519 id = GetCurrentThreadId();
520
521 set_so_opentype ( FALSE ); /* non-overlapped */
522 server_start ( par );
523 mem = TlsGetValue ( tls );
524
525 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "oob_server (%lx): failed to set blocking mode: %d\n");
526 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "oob_server (%lx): listen failed: %d\n");
527
528 SetEvent ( server_ready ); /* notify clients */
529
530 /* accept a single connection */
531 tmp = sizeof ( mem->sock[0].peer );
532 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
533 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "oob_server (%lx): accept failed: %d\n" );
534
535 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
536 "oob_server (%x): strange peer address\n", id );
537
538 /* check initial atmark state */
539 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
540 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %li\n", id, atmark );
541
542 /* Receive normal data */
543 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
544 ok ( n_recvd == n_expected,
545 "oob_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
546 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
547 ok ( pos == -1, "oob_server (%x): test pattern error: %d\n", id, pos);
548
549 /* check atmark state */
550 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
551 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %li\n", id, atmark );
552
553 /* Echo data back */
554 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
555 ok ( n_sent == n_expected,
556 "oob_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
557
558 /* Receive a part of the out-of-band data and print atmark state */
559 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, 8, 0, par->buflen );
560 ok ( n_recvd == 8,
561 "oob_server (%x): received less data than expected: %d of %d\n", id, n_recvd, 8 );
562 n_expected -= 8;
563
564 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
565
566 /* Receive the rest of the out-of-band data and check atmark state */
567 do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
568
569 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
570 todo_wine ok ( atmark == 0, "oob_server (%x): not at the OOB mark: %li\n", id, atmark );
571
572 /* cleanup */
573 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "oob_server (%lx): closesocket error: %d\n" );
574 mem->sock[0].s = INVALID_SOCKET;
575
576 server_stop ();
577 }
578
579 /*
580 * select_server: A non-blocking server.
581 */
582 static VOID WINAPI select_server ( server_params *par )
583 {
584 test_params *gen = par->general;
585 server_memory *mem;
586 int n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
587 id = GetCurrentThreadId(), n_connections = 0, n_sent, n_recvd,
588 n_set, delta, n_ready;
589 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
590 fd_set fds_recv, fds_send, fds_openrecv, fds_opensend;
591
592 set_so_opentype ( FALSE ); /* non-overlapped */
593 server_start ( par );
594 mem = TlsGetValue ( tls );
595
596 wsa_ok ( set_blocking ( mem->s, FALSE ), 0 ==, "select_server (%lx): failed to set blocking mode: %d\n");
597 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "select_server (%lx): listen failed: %d\n");
598
599 SetEvent ( server_ready ); /* notify clients */
600
601 FD_ZERO ( &fds_openrecv );
602 FD_ZERO ( &fds_recv );
603 FD_ZERO ( &fds_send );
604 FD_ZERO ( &fds_opensend );
605
606 FD_SET ( mem->s, &fds_openrecv );
607
608 while(1)
609 {
610 fds_recv = fds_openrecv;
611 fds_send = fds_opensend;
612
613 n_set = 0;
614
615 wsa_ok ( ( n_ready = select ( 0, &fds_recv, &fds_send, NULL, &timeout ) ), SOCKET_ERROR !=,
616 "select_server (%lx): select() failed: %d\n" );
617
618 /* check for incoming requests */
619 if ( FD_ISSET ( mem->s, &fds_recv ) ) {
620 n_set += 1;
621
622 /* accept a single connection */
623 tmp = sizeof ( mem->sock[n_connections].peer );
624 mem->sock[n_connections].s = accept ( mem->s, (struct sockaddr*) &mem->sock[n_connections].peer, &tmp );
625 wsa_ok ( mem->sock[n_connections].s, INVALID_SOCKET !=, "select_server (%lx): accept() failed: %d\n" );
626
627 ok ( mem->sock[n_connections].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
628 "select_server (%x): strange peer address\n", id );
629
630 /* add to list of open connections */
631 FD_SET ( mem->sock[n_connections].s, &fds_openrecv );
632 FD_SET ( mem->sock[n_connections].s, &fds_opensend );
633
634 n_connections++;
635 }
636
637 /* handle open requests */
638
639 for ( i = 0; i < n_connections; i++ )
640 {
641 if ( FD_ISSET( mem->sock[i].s, &fds_recv ) ) {
642 n_set += 1;
643
644 if ( mem->sock[i].n_recvd < n_expected ) {
645 /* Receive data & check it */
646 n_recvd = recv ( mem->sock[i].s, mem->sock[i].buf + mem->sock[i].n_recvd, min ( n_expected - mem->sock[i].n_recvd, par->buflen ), 0 );
647 ok ( n_recvd != SOCKET_ERROR, "select_server (%x): error in recv(): %d\n", id, WSAGetLastError() );
648 mem->sock[i].n_recvd += n_recvd;
649
650 if ( mem->sock[i].n_recvd == n_expected ) {
651 int pos = test_buffer ( mem->sock[i].buf, gen->chunk_size, gen->n_chunks );
652 ok ( pos == -1, "select_server (%x): test pattern error: %d\n", id, pos );
653 FD_CLR ( mem->sock[i].s, &fds_openrecv );
654 }
655
656 ok ( mem->sock[i].n_recvd <= n_expected, "select_server (%x): received too many bytes: %d\n", id, mem->sock[i].n_recvd );
657 }
658 }
659
660 /* only echo back what we've received */
661 delta = mem->sock[i].n_recvd - mem->sock[i].n_sent;
662
663 if ( FD_ISSET ( mem->sock[i].s, &fds_send ) ) {
664 n_set += 1;
665
666 if ( ( delta > 0 ) && ( mem->sock[i].n_sent < n_expected ) ) {
667 /* Echo data back */
668 n_sent = send ( mem->sock[i].s, mem->sock[i].buf + mem->sock[i].n_sent, min ( delta, par->buflen ), 0 );
669 ok ( n_sent != SOCKET_ERROR, "select_server (%x): error in send(): %d\n", id, WSAGetLastError() );
670 mem->sock[i].n_sent += n_sent;
671
672 if ( mem->sock[i].n_sent == n_expected ) {
673 FD_CLR ( mem->sock[i].s, &fds_opensend );
674 }
675
676 ok ( mem->sock[i].n_sent <= n_expected, "select_server (%x): sent too many bytes: %d\n", id, mem->sock[i].n_sent );
677 }
678 }
679 }
680
681 /* check that select returned the correct number of ready sockets */
682 ok ( ( n_set == n_ready ), "select_server (%x): select() returns wrong number of ready sockets\n", id );
683
684 /* check if all clients are done */
685 if ( ( fds_opensend.fd_count == 0 )
686 && ( fds_openrecv.fd_count == 1 ) /* initial socket that accepts clients */
687 && ( n_connections == min ( gen->n_clients, MAX_CLIENTS ) ) ) {
688 break;
689 }
690 }
691
692 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
693 {
694 /* cleanup */
695 read_zero_bytes ( mem->sock[i].s );
696 wsa_ok ( closesocket ( mem->sock[i].s ), 0 ==, "select_server (%lx): closesocket error: %d\n" );
697 mem->sock[i].s = INVALID_SOCKET;
698 }
699
700 server_stop ();
701 }
702
703 /**************** Clients ***************/
704
705 /*
706 * simple_client: A very basic client doing synchronous IO.
707 */
708 static VOID WINAPI simple_client ( client_params *par )
709 {
710 test_params *gen = par->general;
711 client_memory *mem;
712 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
713
714 id = GetCurrentThreadId();
715 /* wait here because we want to call set_so_opentype before creating a socket */
716 WaitForSingleObject ( server_ready, INFINITE );
717
718 check_so_opentype ();
719 set_so_opentype ( FALSE ); /* non-overlapped */
720 client_start ( par );
721 mem = TlsGetValue ( tls );
722
723 /* Connect */
724 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
725 0 ==, "simple_client (%lx): connect error: %d\n" );
726 ok ( set_blocking ( mem->s, TRUE ) == 0,
727 "simple_client (%x): failed to set blocking mode\n", id );
728
729 /* send data to server */
730 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
731 ok ( n_sent == n_expected,
732 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
733
734 /* shutdown send direction */
735 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%lx): shutdown failed: %d\n" );
736
737 /* Receive data echoed back & check it */
738 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, 0, par->buflen );
739 ok ( n_recvd == n_expected,
740 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
741
742 /* check data */
743 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
744 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
745
746 /* cleanup */
747 read_zero_bytes ( mem->s );
748 client_stop ();
749 }
750
751 /*
752 * oob_client: A very basic client sending out-of-band data.
753 */
754 static VOID WINAPI oob_client ( client_params *par )
755 {
756 test_params *gen = par->general;
757 client_memory *mem;
758 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
759
760 id = GetCurrentThreadId();
761 /* wait here because we want to call set_so_opentype before creating a socket */
762 WaitForSingleObject ( server_ready, INFINITE );
763
764 check_so_opentype ();
765 set_so_opentype ( FALSE ); /* non-overlapped */
766 client_start ( par );
767 mem = TlsGetValue ( tls );
768
769 /* Connect */
770 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
771 0 ==, "oob_client (%lx): connect error: %d\n" );
772 ok ( set_blocking ( mem->s, TRUE ) == 0,
773 "oob_client (%x): failed to set blocking mode\n", id );
774
775 /* send data to server */
776 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
777 ok ( n_sent == n_expected,
778 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
779
780 /* Receive data echoed back & check it */
781 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, 0, par->buflen );
782 ok ( n_recvd == n_expected,
783 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
784 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
785 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
786
787 /* send out-of-band data to server */
788 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, MSG_OOB, par->buflen );
789 ok ( n_sent == n_expected,
790 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
791
792 /* shutdown send direction */
793 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%lx): shutdown failed: %d\n" );
794
795 /* cleanup */
796 read_zero_bytes ( mem->s );
797 client_stop ();
798 }
799
800 /*
801 * simple_mixed_client: mixing send and recvfrom
802 */
803 static VOID WINAPI simple_mixed_client ( client_params *par )
804 {
805 test_params *gen = par->general;
806 client_memory *mem;
807 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
808 int fromLen = sizeof(mem->addr);
809 struct sockaddr test;
810
811 id = GetCurrentThreadId();
812 /* wait here because we want to call set_so_opentype before creating a socket */
813 WaitForSingleObject ( server_ready, INFINITE );
814
815 check_so_opentype ();
816 set_so_opentype ( FALSE ); /* non-overlapped */
817 client_start ( par );
818 mem = TlsGetValue ( tls );
819
820 /* Connect */
821 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
822 0 ==, "simple_client (%lx): connect error: %d\n" );
823 ok ( set_blocking ( mem->s, TRUE ) == 0,
824 "simple_client (%x): failed to set blocking mode\n", id );
825
826 /* send data to server */
827 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
828 ok ( n_sent == n_expected,
829 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
830
831 /* shutdown send direction */
832 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%lx): shutdown failed: %d\n" );
833
834 /* this shouldn't change, since lpFrom, is not updated on
835 connection oriented sockets - exposed by bug 11640
836 */
837 ((struct sockaddr_in*)&test)->sin_addr.s_addr = inet_addr("0.0.0.0");
838
839 /* Receive data echoed back & check it */
840 n_recvd = do_synchronous_recvfrom ( mem->s, mem->recv_buf, n_expected, 0, &test, &fromLen,
841 par->buflen );
842 ok ( n_recvd == n_expected,
843 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
844
845 /* check that lpFrom was not updated */
846 ok(0 ==
847 strcmp(
848 inet_ntoa(((struct sockaddr_in*)&test)->sin_addr),
849 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
850
851 /* check data */
852 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
853 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
854
855 /* cleanup */
856 read_zero_bytes ( mem->s );
857 client_stop ();
858 }
859
860 /*
861 * event_client: An event-driven client
862 */
863 static void WINAPI event_client ( client_params *par )
864 {
865 test_params *gen = par->general;
866 client_memory *mem;
867 int id = GetCurrentThreadId(), n_expected = gen->n_chunks * gen->chunk_size,
868 tmp, err, n;
869 HANDLE event;
870 WSANETWORKEVENTS wsa_events;
871 char *send_last, *recv_last, *send_p, *recv_p;
872 LONG mask = FD_READ | FD_WRITE | FD_CLOSE;
873
874 client_start ( par );
875
876 mem = TlsGetValue ( tls );
877
878 /* Prepare event notification for connect, makes socket nonblocking */
879 event = WSACreateEvent ();
880 WSAEventSelect ( mem->s, event, FD_CONNECT );
881 tmp = connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) );
882 if ( tmp != 0 ) {
883 err = WSAGetLastError ();
884 ok ( err == WSAEWOULDBLOCK, "event_client (%x): connect error: %d\n", id, err );
885 tmp = WaitForSingleObject ( event, INFINITE );
886 ok ( tmp == WAIT_OBJECT_0, "event_client (%x): wait for connect event failed: %d\n", id, tmp );
887 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
888 ok ( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
889 err = wsa_events.iErrorCode[ FD_CONNECT_BIT ];
890 ok ( err == 0, "event_client (%x): connect error: %d\n", id, err );
891 if ( err ) goto out;
892 }
893
894 WSAEventSelect ( mem->s, event, mask );
895
896 recv_p = mem->recv_buf;
897 recv_last = mem->recv_buf + n_expected;
898 send_p = mem->send_buf;
899 send_last = mem->send_buf + n_expected;
900
901 while ( TRUE )
902 {
903 err = WaitForSingleObject ( event, INFINITE );
904 ok ( err == WAIT_OBJECT_0, "event_client (%x): wait failed\n", id );
905
906 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
907 ok( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
908
909 if ( wsa_events.lNetworkEvents & FD_WRITE )
910 {
911 err = wsa_events.iErrorCode[ FD_WRITE_BIT ];
912 ok ( err == 0, "event_client (%x): FD_WRITE error code: %d\n", id, err );
913
914 if ( err== 0 )
915 do
916 {
917 n = send ( mem->s, send_p, min ( send_last - send_p, par->buflen ), 0 );
918 if ( n < 0 )
919 {
920 err = WSAGetLastError ();
921 ok ( err == WSAEWOULDBLOCK, "event_client (%x): send error: %d\n", id, err );
922 }
923 else
924 send_p += n;
925 }
926 while ( n >= 0 && send_p < send_last );
927
928 if ( send_p == send_last )
929 {
930 shutdown ( mem->s, SD_SEND );
931 mask &= ~FD_WRITE;
932 WSAEventSelect ( mem->s, event, mask );
933 }
934 }
935 if ( wsa_events.lNetworkEvents & FD_READ )
936 {
937 err = wsa_events.iErrorCode[ FD_READ_BIT ];
938 ok ( err == 0, "event_client (%x): FD_READ error code: %d\n", id, err );
939 if ( err != 0 ) break;
940
941 /* First read must succeed */
942 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
943 wsa_ok ( n, 0 <=, "event_client (%lx): recv error: %d\n" );
944
945 while ( n >= 0 ) {
946 recv_p += n;
947 if ( recv_p == recv_last )
948 {
949 mask &= ~FD_READ;
950 WSAEventSelect ( mem->s, event, mask );
951 break;
952 }
953 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
954 ok(n >= 0 || WSAGetLastError() == WSAEWOULDBLOCK,
955 "event_client (%x): got error %u\n", id, WSAGetLastError());
956
957 }
958 }
959 if ( wsa_events.lNetworkEvents & FD_CLOSE )
960 {
961 err = wsa_events.iErrorCode[ FD_CLOSE_BIT ];
962 ok ( err == 0, "event_client (%x): FD_CLOSE error code: %d\n", id, err );
963 break;
964 }
965 }
966
967 n = send_p - mem->send_buf;
968 ok ( send_p == send_last,
969 "simple_client (%x): sent less data than expected: %d of %d\n", id, n, n_expected );
970 n = recv_p - mem->recv_buf;
971 ok ( recv_p == recv_last,
972 "simple_client (%x): received less data than expected: %d of %d\n", id, n, n_expected );
973 n = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
974 ok ( n == -1, "event_client (%x): test pattern error: %d\n", id, n);
975
976 out:
977 WSACloseEvent ( event );
978 client_stop ();
979 }
980
981 /* Tests for WSAStartup */
982 static void test_WithoutWSAStartup(void)
983 {
984 DWORD err;
985
986 WSASetLastError(0xdeadbeef);
987 ok(WSASocketA(0, 0, 0, NULL, 0, 0) == INVALID_SOCKET, "WSASocketA should have failed\n");
988 err = WSAGetLastError();
989 ok(err == WSANOTINITIALISED, "Expected 10093, received %ld\n", err);
990
991 WSASetLastError(0xdeadbeef);
992 ok(gethostbyname("localhost") == NULL, "gethostbyname() succeeded unexpectedly\n");
993 err = WSAGetLastError();
994 ok(err == WSANOTINITIALISED, "Expected 10093, received %ld\n", err);
995 }
996
997 static void test_WithWSAStartup(void)
998 {
999 WSADATA data;
1000 WORD version = MAKEWORD( 2, 2 );
1001 INT res, socks, i, j;
1002 SOCKET sock;
1003 LPVOID ptr;
1004 struct
1005 {
1006 SOCKET src, dst, dup_src, dup_dst;
1007 } pairs[32];
1008 DWORD error;
1009
1010 res = WSAStartup( version, &data );
1011 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
1012
1013 ptr = gethostbyname("localhost");
1014 ok(ptr != NULL, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
1015
1016 /* Alloc some sockets to check if they are destroyed on WSACleanup */
1017 for (socks = 0; socks < ARRAY_SIZE(pairs); socks++)
1018 {
1019 WSAPROTOCOL_INFOA info;
1020 tcp_socketpair(&pairs[socks].src, &pairs[socks].dst);
1021
1022 memset(&info, 0, sizeof(info));
1023 ok(!WSADuplicateSocketA(pairs[socks].src, GetCurrentProcessId(), &info),
1024 "WSADuplicateSocketA should have worked\n");
1025 pairs[socks].dup_src = WSASocketA(0, 0, 0, &info, 0, 0);
1026 ok(pairs[socks].dup_src != SOCKET_ERROR, "expected != -1\n");
1027
1028 memset(&info, 0, sizeof(info));
1029 ok(!WSADuplicateSocketA(pairs[socks].dst, GetCurrentProcessId(), &info),
1030 "WSADuplicateSocketA should have worked\n");
1031 pairs[socks].dup_dst = WSASocketA(0, 0, 0, &info, 0, 0);
1032 ok(pairs[socks].dup_dst != SOCKET_ERROR, "expected != -1\n");
1033 }
1034
1035 res = send(pairs[0].src, "TEST", 4, 0);
1036 ok(res == 4, "send failed with error %d\n", WSAGetLastError());
1037
1038 WSACleanup();
1039
1040 res = WSAStartup( version, &data );
1041 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
1042
1043 /* show that sockets are destroyed automatically after WSACleanup */
1044 SetLastError(0xdeadbeef);
1045 res = send(pairs[0].src, "TEST", 4, 0);
1046 error = WSAGetLastError();
1047 ok(res == SOCKET_ERROR, "send should have failed\n");
1048 ok(error == WSAENOTSOCK, "expected 10038, got %ld\n", error);
1049
1050 SetLastError(0xdeadbeef);
1051 res = send(pairs[0].dst, "TEST", 4, 0);
1052 error = WSAGetLastError();
1053 ok(res == SOCKET_ERROR, "send should have failed\n");
1054 ok(error == WSAENOTSOCK, "expected 10038, got %ld\n", error);
1055
1056 /* Check that all sockets were destroyed */
1057 for (i = 0; i < socks; i++)
1058 {
1059 for (j = 0; j < 4; j++)
1060 {
1061 struct sockaddr_in saddr;
1062 int size = sizeof(saddr);
1063 switch(j)
1064 {
1065 case 0: sock = pairs[i].src; break;
1066 case 1: sock = pairs[i].dup_src; break;
1067 case 2: sock = pairs[i].dst; break;
1068 case 3: sock = pairs[i].dup_dst; break;
1069 }
1070
1071 SetLastError(0xdeadbeef);
1072 res = getsockname(sock, (struct sockaddr *)&saddr, &size);
1073 error = WSAGetLastError();
1074 ok(res == SOCKET_ERROR, "Test[%d]: getsockname should have failed\n", i);
1075 if (res == SOCKET_ERROR)
1076 ok(error == WSAENOTSOCK, "Test[%d]: expected 10038, got %ld\n", i, error);
1077 }
1078 }
1079
1080 /* While wine is not fixed, close all sockets manually */
1081 for (i = 0; i < socks; i++)
1082 {
1083 closesocket(pairs[i].src);
1084 closesocket(pairs[i].dst);
1085 closesocket(pairs[i].dup_src);
1086 closesocket(pairs[i].dup_dst);
1087 }
1088
1089 res = WSACleanup();
1090 ok(res == 0, "expected 0, got %d\n", res);
1091 WSASetLastError(0xdeadbeef);
1092 res = WSACleanup();
1093 error = WSAGetLastError();
1094 ok ( res == SOCKET_ERROR && error == WSANOTINITIALISED,
1095 "WSACleanup returned %d WSAGetLastError is %ld\n", res, error);
1096 }
1097
1098 /**************** Main program utility functions ***************/
1099
1100 static void Init (void)
1101 {
1102 WORD ver = MAKEWORD (2, 2);
1103 WSADATA data;
1104 HMODULE hws2_32 = GetModuleHandleA("ws2_32.dll"), ntdll;
1105
1106 pWSAPoll = (void *)GetProcAddress(hws2_32, "WSAPoll");
1107
1108 ntdll = LoadLibraryA("ntdll.dll");
1109 if (ntdll)
1110 pNtClose = (void *)GetProcAddress(ntdll, "NtClose");
1111
1112 ok ( WSAStartup ( ver, &data ) == 0, "WSAStartup failed\n" );
1113 tls = TlsAlloc();
1114 }
1115
1116 static void Exit (void)
1117 {
1118 INT ret, err;
1119 TlsFree ( tls );
1120 ret = WSACleanup();
1121 err = WSAGetLastError();
1122 ok ( ret == 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret, err);
1123 }
1124
1125 static void StartServer (LPTHREAD_START_ROUTINE routine,
1126 test_params *general, server_params *par)
1127 {
1128 par->general = general;
1129 thread[0] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[0] );
1130 ok ( thread[0] != NULL, "Failed to create server thread\n" );
1131 }
1132
1133 static void StartClients (LPTHREAD_START_ROUTINE routine,
1134 test_params *general, client_params *par)
1135 {
1136 int i;
1137 par->general = general;
1138 for ( i = 1; i <= min ( general->n_clients, MAX_CLIENTS ); i++ )
1139 {
1140 client_id = i - 1;
1141 thread[i] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[i] );
1142 ok ( thread[i] != NULL, "Failed to create client thread\n" );
1143 /* Make sure the client is up and running */
1144 WaitForSingleObject ( client_ready[client_id], INFINITE );
1145 };
1146 }
1147
1148 static void do_test( test_setup *test )
1149 {
1150 DWORD i, n = min (test->general.n_clients, MAX_CLIENTS);
1151 DWORD wait;
1152
1153 server_ready = CreateEventA ( NULL, TRUE, FALSE, NULL );
1154 for (i = 0; i <= n; i++)
1155 client_ready[i] = CreateEventA ( NULL, TRUE, FALSE, NULL );
1156
1157 StartServer ( test->srv, &test->general, &test->srv_params );
1158 StartClients ( test->clt, &test->general, &test->clt_params );
1159 WaitForSingleObject ( server_ready, INFINITE );
1160
1161 wait = WaitForMultipleObjects ( 1 + n, thread, TRUE, 1000 * TEST_TIMEOUT );
1162 ok(!wait, "wait failed, error %lu\n", wait);
1163
1164 CloseHandle ( server_ready );
1165 for (i = 0; i <= n; i++)
1166 CloseHandle ( client_ready[i] );
1167 }
1168
1169 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1170 /* optname = SO_LINGER */
1171 static const LINGER linger_testvals[] = {
1172 {0,0},
1173 {0,73},
1174 {1,0},
1175 {5,189}
1176 };
1177
1178 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1179 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1180 bug in the linux kernel (fixed in 2.6.8) */
1181 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1182
1183 static void test_set_getsockopt(void)
1184 {
1185 static struct
1186 {
1187 int af;
1188 int type;
1189 int level;
1190 int optname;
1191 BOOL accepts_short_len;
1192 unsigned int sizes[3];
1193 DWORD values[3];
1194 BOOL accepts_large_value;
1195 BOOL bool_value;
1196 }
1197 test_optsize[] =
1198 {
1199 {AF_INET, SOCK_DGRAM, SOL_SOCKET, SO_BROADCAST, TRUE, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE, TRUE},
1200 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_DONTLINGER, TRUE, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE, TRUE},
1201 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_LINGER, FALSE, {1, 2, 4}, {0xdeadbe00, 0xdead0000}, TRUE},
1202 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_OOBINLINE, TRUE, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE, TRUE},
1203 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_RCVBUF, FALSE, {1, 2, 4}, {0xdeadbe00, 0xdead0000}, TRUE},
1204 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_KEEPALIVE, TRUE, {1, 1, 1}, {0}, TRUE},
1205 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_DONTROUTE, TRUE, {1, 1, 1}, {0}, TRUE},
1206 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_RCVTIMEO, FALSE, {1, 2, 4}, {0}, TRUE},
1207 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR, TRUE, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE, TRUE},
1208 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, TRUE, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE, TRUE},
1209 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_SNDBUF, FALSE, {1, 2, 4}, {0xdeadbe00, 0xdead0000}, TRUE},
1210 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_SNDTIMEO, FALSE, {1, 2, 4}, {0}, TRUE},
1211 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_OPENTYPE, FALSE, {1, 2, 4}, {0}, TRUE},
1212 {AF_INET, SOCK_STREAM, IPPROTO_TCP, TCP_NODELAY, TRUE, {1, 1, 1}, {0}, TRUE},
1213 {AF_INET, SOCK_DGRAM, IPPROTO_IP, IP_MULTICAST_LOOP, TRUE, {1, 1, 4}, {0}, TRUE, TRUE},
1214 {AF_INET, SOCK_DGRAM, IPPROTO_IP, IP_MULTICAST_TTL, TRUE, {1, 1, 4}, {0}, FALSE},
1215 {AF_INET, SOCK_DGRAM, IPPROTO_IP, IP_PKTINFO, FALSE, {0, 0, 4}, {0}, TRUE, TRUE},
1216 {AF_INET, SOCK_DGRAM, IPPROTO_IP, IP_RECVTOS, FALSE, {0, 0, 4}, {0}, TRUE, TRUE},
1217 {AF_INET, SOCK_DGRAM, IPPROTO_IP, IP_RECVTTL, FALSE, {0, 0, 4}, {0}, TRUE, TRUE},
1218 {AF_INET, SOCK_DGRAM, IPPROTO_IP, IP_TOS, TRUE, {1, 1, 4}, {0}, FALSE},
1219 {AF_INET, SOCK_DGRAM, IPPROTO_IP, IP_TTL, TRUE, {1, 1, 4}, {0}, FALSE},
1220 {AF_INET6, SOCK_STREAM, IPPROTO_IPV6, IPV6_DONTFRAG, TRUE, {1, 1, 4}, {0}, TRUE, TRUE},
1221 {AF_INET6, SOCK_DGRAM, IPPROTO_IPV6, IPV6_HOPLIMIT, FALSE, {0, 0, 4}, {0}, TRUE, TRUE},
1222 {AF_INET6, SOCK_DGRAM, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, TRUE, {1, 1, 4}, {0}, FALSE},
1223 {AF_INET6, SOCK_DGRAM, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, TRUE, {1, 1, 4}, {0}, TRUE, TRUE},
1224 {AF_INET6, SOCK_DGRAM, IPPROTO_IPV6, IPV6_PKTINFO, FALSE, {0, 0, 4}, {0}, TRUE, TRUE},
1225 {AF_INET6, SOCK_DGRAM, IPPROTO_IPV6, IPV6_RECVTCLASS, FALSE, {0, 0, 4}, {0}, TRUE, TRUE},
1226 {AF_INET6, SOCK_DGRAM, IPPROTO_IPV6, IPV6_UNICAST_HOPS, TRUE, {1, 1, 4}, {0}, FALSE},
1227 {AF_INET6, SOCK_DGRAM, IPPROTO_IPV6, IPV6_V6ONLY, TRUE, {1, 1, 1}, {0}, TRUE},
1228 };
1229 SOCKET s, s2, src, dst;
1230 int i, j, err, lasterr;
1231 int timeout;
1232 LINGER lingval;
1233 int size;
1234 WSAPROTOCOL_INFOA infoA;
1235 WSAPROTOCOL_INFOW infoW;
1236 char providername[WSAPROTOCOL_LEN + 1];
1237 DWORD expected_last_error, expected_value;
1238 int expected_err, expected_size;
1239 DWORD value, save_value;
1240 UINT64 value64;
1241 char buffer[4096];
1242
1243 struct _prottest
1244 {
1245 int family, type, proto;
1246 } prottest[] = {
1247 {AF_INET, SOCK_STREAM, IPPROTO_TCP},
1248 {AF_INET, SOCK_DGRAM, IPPROTO_UDP},
1249 {AF_INET6, SOCK_STREAM, IPPROTO_TCP},
1250 {AF_INET6, SOCK_DGRAM, IPPROTO_UDP}
1251 };
1252 union _csspace
1253 {
1254 CSADDR_INFO cs;
1255 char space[128];
1256 } csinfoA, csinfoB;
1257
1258 s = socket(AF_INET, SOCK_STREAM, 0);
1259 ok(s!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1260 if( s == INVALID_SOCKET) return;
1261 /* SO_RCVTIMEO */
1262 timeout = SOCKTIMEOUT1;
1263 size = sizeof(timeout);
1264 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1265 if( !err)
1266 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1267 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1268 ok( timeout == SOCKTIMEOUT1, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1269
1270 timeout = 0;
1271 size = sizeof(timeout);
1272 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1273 if( !err)
1274 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1275 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1276 ok( timeout == 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1277
1278 /* SO_SNDTIMEO */
1279 timeout = SOCKTIMEOUT2; /* 997 seconds. See remark above */
1280 size = sizeof(timeout);
1281 err = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, size);
1282 if( !err)
1283 err = getsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, &size);
1284 ok( !err, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1285 ok( timeout == SOCKTIMEOUT2, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout);
1286
1287 /* SO_SNDBUF */
1288 value = 4096;
1289 size = sizeof(value);
1290 err = setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&value, size);
1291 ok( !err, "setsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1292 value = 0xdeadbeef;
1293 err = getsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&value, &size);
1294 ok( !err, "getsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1295 ok( value == 4096, "expected 4096, got %lu\n", value );
1296
1297 /* SO_RCVBUF */
1298 value = 4096;
1299 size = sizeof(value);
1300 err = setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, size);
1301 ok( !err, "setsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1302 value = 0xdeadbeef;
1303 err = getsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, &size);
1304 ok( !err, "getsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1305 ok( value == 4096, "expected 4096, got %lu\n", value );
1306
1307 value = 0;
1308 size = sizeof(value);
1309 err = setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, size);
1310 ok( !err, "setsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1311 value = 0xdeadbeef;
1312 err = getsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, &size);
1313 ok( !err, "getsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1314 ok( value == 0, "expected 0, got %lu\n", value );
1315
1316 /* Test non-blocking receive with too short SO_RCVBUF. */
1317 tcp_socketpair(&src, &dst);
1318 set_blocking(src, FALSE);
1319 set_blocking(dst, FALSE);
1320
1321 value = 0;
1322 size = sizeof(value);
1323 err = setsockopt(src, SOL_SOCKET, SO_SNDBUF, (char *)&value, size);
1324 ok( !err, "got %d, error %u.\n", err, WSAGetLastError() );
1325
1326 value = 0xdeadbeef;
1327 err = getsockopt(dst, SOL_SOCKET, SO_RCVBUF, (char *)&value, &size);
1328 ok( !err, "got %d, error %u.\n", err, WSAGetLastError() );
1329 if (value >= sizeof(buffer) * 3)
1330 {
1331 value = 1024;
1332 size = sizeof(value);
1333 err = setsockopt(dst, SOL_SOCKET, SO_RCVBUF, (char *)&value, size);
1334 ok( !err, "got %d, error %u.\n", err, WSAGetLastError() );
1335 value = 0xdeadbeef;
1336 err = getsockopt(dst, SOL_SOCKET, SO_RCVBUF, (char *)&value, &size);
1337 ok( !err, "got %d, error %u.\n", err, WSAGetLastError() );
1338 ok( value == 1024, "expected 0, got %lu\n", value );
1339
1340 err = send(src, buffer, sizeof(buffer), 0);
1341 ok(err == sizeof(buffer), "got %d\n", err);
1342 err = send(src, buffer, sizeof(buffer), 0);
1343 ok(err == sizeof(buffer), "got %d\n", err);
1344 err = send(src, buffer, sizeof(buffer), 0);
1345 ok(err == sizeof(buffer), "got %d\n", err);
1346
1347 err = sync_recv(dst, buffer, sizeof(buffer), 0);
1348 ok(err == sizeof(buffer), "got %d, error %u\n", err, WSAGetLastError());
1349 err = sync_recv(dst, buffer, sizeof(buffer), 0);
1350 ok(err == sizeof(buffer), "got %d, error %u\n", err, WSAGetLastError());
1351 err = sync_recv(dst, buffer, sizeof(buffer), 0);
1352 ok(err == sizeof(buffer), "got %d, error %u\n", err, WSAGetLastError());
1353 }
1354 else
1355 {
1356 skip("Default SO_RCVBUF %lu is too small, skipping test.\n", value);
1357 }
1358
1359 closesocket(src);
1360 closesocket(dst);
1361
1362 /* SO_LINGER */
1363 for( i = 0; i < ARRAY_SIZE(linger_testvals);i++) {
1364 size = sizeof(lingval);
1365 lingval = linger_testvals[i];
1366 err = setsockopt(s, SOL_SOCKET, SO_LINGER, (char *)&lingval, size);
1367 ok(!err, "Test %u: failed to set SO_LINGER, error %u\n", i, WSAGetLastError());
1368 err = getsockopt(s, SOL_SOCKET, SO_LINGER, (char *)&lingval, &size);
1369 ok(!err, "Test %u: failed to get SO_LINGER, error %u\n", i, WSAGetLastError());
1370 ok(!lingval.l_onoff == !linger_testvals[i].l_onoff, "Test %u: expected %d, got %d\n",
1371 i, linger_testvals[i].l_onoff, lingval.l_onoff);
1372 if (lingval.l_onoff)
1373 ok(lingval.l_linger == linger_testvals[i].l_linger, "Test %u: expected %d, got %d\n",
1374 i, linger_testvals[i].l_linger, lingval.l_linger);
1375 }
1376
1377 size = sizeof(lingval);
1378 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, size);
1379 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1380 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1381 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, 0);
1382 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1383 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1384
1385 size = sizeof(BOOL);
1386 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, size);
1387 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1388 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1389 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, 0);
1390 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1391 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1392
1393 /* TCP_NODELAY: optlen doesn't matter on windows, it should work with any positive value */
1394 size = sizeof(value);
1395
1396 value = 1;
1397 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 1);
1398 ok (!err, "setsockopt TCP_NODELAY failed with optlen == 1\n");
1399 value = 0xff;
1400 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1401 ok(!err, "getsockopt TCP_NODELAY failed\n");
1402 ok(value == 1, "TCP_NODELAY should be 1\n");
1403 value = 0;
1404 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, sizeof(value));
1405 ok(!err, "Failed to reset TCP_NODELAY to 0\n");
1406
1407 value = 1;
1408 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 4);
1409 ok (!err, "setsockopt TCP_NODELAY failed with optlen == 4\n");
1410 value = 0xff;
1411 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1412 ok(!err, "getsockopt TCP_NODELAY failed\n");
1413 ok(value == 1, "TCP_NODELAY should be 1\n");
1414 value = 0;
1415 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, sizeof(value));
1416 ok(!err, "Failed to reset TCP_NODELAY to 0\n");
1417
1418 value = 1;
1419 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 42);
1420 ok (!err, "setsockopt TCP_NODELAY failed with optlen == 42\n");
1421 value = 0xff;
1422 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1423 ok(!err, "getsockopt TCP_NODELAY failed\n");
1424 ok(value == 1, "TCP_NODELAY should be 1\n");
1425 value = 0;
1426 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, sizeof(value));
1427 ok(!err, "Failed to reset TCP_NODELAY to 0\n");
1428
1429 value = 1;
1430 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 0);
1431 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1432 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1433 value = 0xff;
1434 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1435 ok(!err, "getsockopt TCP_NODELAY failed\n");
1436 ok(!value, "TCP_NODELAY should be 0\n");
1437
1438 value = 1;
1439 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, -1);
1440 /* On win 10 pro, this sets the error to WSAENOBUFS instead of WSAEFAULT */
1441 ok(err == SOCKET_ERROR && (WSAGetLastError() == WSAEFAULT || WSAGetLastError() == WSAENOBUFS),
1442 "got %d with %d (expected SOCKET_ERROR with either WSAEFAULT or WSAENOBUFS)\n", err, WSAGetLastError());
1443 value = 0xff;
1444 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1445 ok(!err, "getsockopt TCP_NODELAY failed\n");
1446 ok(!value, "TCP_NODELAY should be 0\n");
1447
1448 value = 0x100;
1449 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 4);
1450 ok (!err, "setsockopt TCP_NODELAY failed with optlen == 4 and optvalue = 0x100\n");
1451 value = 0xff;
1452 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1453 ok(!err, "getsockopt TCP_NODELAY failed\n");
1454 ok(!value, "TCP_NODELAY should be 0\n");
1455
1456 /* Test for erroneously passing a value instead of a pointer as optval */
1457 size = sizeof(char);
1458 err = setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)1, size);
1459 ok(err == SOCKET_ERROR, "setsockopt with optval being a value passed "
1460 "instead of failing.\n");
1461 lasterr = WSAGetLastError();
1462 ok(lasterr == WSAEFAULT, "setsockopt with optval being a value "
1463 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1464 lasterr, WSAEFAULT);
1465
1466 /* SO_RCVTIMEO with invalid values for level */
1467 size = sizeof(timeout);
1468 timeout = SOCKTIMEOUT1;
1469 SetLastError(0xdeadbeef);
1470 err = setsockopt(s, 0xffffffff, SO_RCVTIMEO, (char *) &timeout, size);
1471 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1472 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1473 err, WSAGetLastError());
1474
1475 timeout = SOCKTIMEOUT1;
1476 SetLastError(0xdeadbeef);
1477 err = setsockopt(s, 0x00008000, SO_RCVTIMEO, (char *) &timeout, size);
1478 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1479 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1480 err, WSAGetLastError());
1481
1482 /* Test SO_ERROR set/get */
1483 SetLastError(0xdeadbeef);
1484 i = 1234;
1485 err = setsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, size);
1486 ok( !err && !WSAGetLastError(),
1487 "got %d with %d (expected 0 with 0)\n",
1488 err, WSAGetLastError());
1489
1490 SetLastError(0xdeadbeef);
1491 i = 4321;
1492 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1493 ok( !err && !WSAGetLastError(),
1494 "got %d with %d (expected 0 with 0)\n",
1495 err, WSAGetLastError());
1496 todo_wine
1497 ok (i == 1234, "got %d (expected 1234)\n", i);
1498
1499 /* Test invalid optlen */
1500 SetLastError(0xdeadbeef);
1501 size = 1;
1502 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1503 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEFAULT),
1504 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1505 err, WSAGetLastError());
1506
1507 closesocket(s);
1508
1509 /* Test option length. */
1510 for (i = 0; i < ARRAY_SIZE(test_optsize); ++i)
1511 {
1512 winetest_push_context("i %u, level %d, optname %d",
1513 i, test_optsize[i].level, test_optsize[i].optname);
1514
1515 s2 = socket( test_optsize[i].af, test_optsize[i].type, 0 );
1516 ok(s2 != INVALID_SOCKET, "socket() failed error %d\n", WSAGetLastError());
1517
1518 size = sizeof(save_value);
1519 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&save_value, &size);
1520 ok(!err, "Unexpected getsockopt result %d.\n", err);
1521
1522 value64 = 0xffffffff00000001;
1523 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char *)&value64, sizeof(value64));
1524 ok(!err, "Unexpected setsockopt result %d.\n", err);
1525 ok(!WSAGetLastError(), "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1526
1527 size = sizeof(value64);
1528 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value64, &size);
1529 ok(!err, "Unexpected getsockopt result %d.\n", err);
1530 ok(size == test_optsize[i].sizes[2], "Got unexpected size %d.\n", size);
1531 /* The behaviour regarding filling the high dword is different between options without the obvious
1532 * pattern, it is either left untouched (more often) or zeroed. Wine doesn't touch the high dword. */
1533
1534 if (test_optsize[i].sizes[2] == 1 || test_optsize[i].level != SOL_SOCKET)
1535 {
1536 expected_err = -1;
1537 expected_last_error = WSAENOBUFS;
1538 }
1539 else
1540 {
1541 expected_err = 0;
1542 expected_last_error = 0;
1543 }
1544
1545 value = 1;
1546 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char *)&value, -1);
1547 ok(err == expected_err, "Unexpected setsockopt result %d.\n", err);
1548 /* Broken between Win7 and Win10 21H1. */
1549 ok(WSAGetLastError() == expected_last_error || broken(expected_last_error && WSAGetLastError() == WSAEFAULT),
1550 "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1551
1552 size = -1;
1553 value = 0xdeadbeef;
1554 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, &size);
1555 if (test_optsize[i].optname == SO_OPENTYPE)
1556 {
1557 ok(!err, "Unexpected getsockopt result %d.\n", err);
1558 ok(!WSAGetLastError(), "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1559 }
1560 else
1561 {
1562 ok(err == -1, "Unexpected getsockopt result %d.\n", err);
1563 ok(WSAGetLastError() == WSAEFAULT, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1564 }
1565 ok(size == (test_optsize[i].optname == SO_OPENTYPE ? 4 : -1), "Got unexpected size %d.\n", size);
1566
1567 if (test_optsize[i].level == SOL_SOCKET && test_optsize[i].bool_value)
1568 {
1569 expected_err = 0;
1570 expected_last_error = 0;
1571 }
1572 else
1573 {
1574 expected_err = -1;
1575 expected_last_error = WSAEFAULT;
1576 }
1577 value = 1;
1578 SetLastError(0xdeadbeef);
1579 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, 0);
1580 ok(err == expected_err, "Unexpected setsockopt result %d.\n", err);
1581 ok(WSAGetLastError() == expected_last_error, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1582
1583 size = 0;
1584 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, &size);
1585 ok(err == -1, "Unexpected getsockopt result %d.\n", err);
1586 ok(WSAGetLastError() == WSAEFAULT, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1587
1588 expected_size = test_optsize[i].sizes[2];
1589 if (expected_size == 1)
1590 expected_value = 0xdeadbe00;
1591 else
1592 expected_value = test_optsize[i].bool_value ? 0x1 : 0x100;
1593 if (test_optsize[i].accepts_large_value)
1594 {
1595 expected_err = 0;
1596 expected_last_error = 0;
1597 }
1598 else
1599 {
1600 expected_err = -1;
1601 expected_last_error = WSAEINVAL;
1602 }
1603
1604 value = 0x100;
1605 SetLastError(0xdeadbeef);
1606 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, 4);
1607 ok(err == expected_err, "Unexpected setsockopt result %d.\n", err);
1608 ok(WSAGetLastError() == expected_last_error, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1609
1610 if (test_optsize[i].accepts_large_value)
1611 {
1612 value = 0xdeadbeef;
1613 SetLastError(0xdeadbeef);
1614 size = 4;
1615 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, &size);
1616 ok(err == expected_err, "Unexpected getsockopt result %d.\n", err);
1617 ok(WSAGetLastError() == expected_last_error, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1618 todo_wine_if(test_optsize[i].optname == SO_DONTROUTE || test_optsize[i].optname == SO_LINGER)
1619 ok(value == expected_value, "Got unexpected value %#lx, expected %#lx.\n", value, expected_value);
1620 ok(size == expected_size, "Got unexpected size %u, expected %u.\n", size, expected_size);
1621 }
1622
1623 winetest_pop_context();
1624
1625 for (j = 0; j < ARRAY_SIZE(test_optsize[i].sizes); ++j)
1626 {
1627 size = 1 << j;
1628 winetest_push_context("i %u, level %d, optname %d, len %u",
1629 i, test_optsize[i].level, test_optsize[i].optname, size);
1630
1631 value = 1;
1632 if (test_optsize[i].values[j])
1633 expected_value = test_optsize[i].values[j];
1634 else
1635 expected_value = 0xdeadbeef;
1636
1637 if (test_optsize[i].accepts_short_len || size == 4)
1638 {
1639 expected_err = 0;
1640 expected_last_error = 0;
1641 expected_size = test_optsize[i].sizes[j];
1642
1643 if (!test_optsize[i].values[j])
1644 memcpy(&expected_value, &value, expected_size);
1645 }
1646 else
1647 {
1648 expected_err = -1;
1649 expected_last_error = WSAEFAULT;
1650 expected_size = test_optsize[i].sizes[j];
1651 }
1652
1653 SetLastError(0xdeadbeef);
1654 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, size);
1655 ok(err == expected_err, "Unexpected setsockopt result %d.\n", err);
1656 ok(WSAGetLastError() == expected_last_error, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1657
1658 value = 0xdeadbeef;
1659 SetLastError(0xdeadbeef);
1660 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, &size);
1661 ok(err == expected_err, "Unexpected getsockopt result %d.\n", err);
1662 ok(WSAGetLastError() == expected_last_error, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1663 ok(value == expected_value, "Got unexpected value %#lx, expected %#lx.\n", value, expected_value);
1664 ok(size == expected_size, "Got unexpected size %d, expected %d.\n", size, expected_size);
1665
1666 winetest_pop_context();
1667 }
1668
1669 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname,
1670 (char*)&save_value, sizeof(save_value));
1671 ok(!err, "Unexpected getsockopt result %d.\n", err);
1672 closesocket(s2);
1673 }
1674
1675 /* Test with the closed socket */
1676 SetLastError(0xdeadbeef);
1677 size = sizeof(i);
1678 i = 1234;
1679 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1680 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAENOTSOCK),
1681 "got %d with %d (expected SOCKET_ERROR with WSAENOTSOCK)\n",
1682 err, WSAGetLastError());
1683 ok (i == 1234, "expected 1234, got %d\n", i);
1684
1685 /* Test WS_IP_MULTICAST_TTL with 8, 16, 24 and 32 bits values */
1686 s = socket(AF_INET, SOCK_DGRAM, 0);
1687 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1688 size = sizeof(i);
1689 i = 0x0000000a;
1690 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &i, size);
1691 if (!err)
1692 {
1693 for (i = 0; i < 4; i++)
1694 {
1695 int k, j;
1696 const int tests[] = {0xffffff0a, 0xffff000b, 0xff00000c, 0x0000000d};
1697 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &tests[i], i + 1);
1698 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1699 err = getsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &k, &size);
1700 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1701 j = i != 3 ? tests[i] & ((1 << (i + 1) * 8) - 1) : tests[i];
1702 ok(k == j, "Test [%d] Expected 0x%x, got 0x%x\n", i, j, k);
1703 }
1704 }
1705 else
1706 win_skip("IP_MULTICAST_TTL is unsupported\n");
1707 closesocket(s);
1708
1709 /* test SO_PROTOCOL_INFOA invalid parameters */
1710 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1711 "getsockopt should have failed\n");
1712 err = WSAGetLastError();
1713 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1714 size = sizeof(WSAPROTOCOL_INFOA);
1715 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1716 "getsockopt should have failed\n");
1717 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1718 err = WSAGetLastError();
1719 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1720 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1721 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1722 "getsockopt should have failed\n");
1723 err = WSAGetLastError();
1724 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1725 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, NULL),
1726 "getsockopt should have failed\n");
1727 err = WSAGetLastError();
1728 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1729 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, &size),
1730 "getsockopt should have failed\n");
1731 err = WSAGetLastError();
1732 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1733 size = sizeof(WSAPROTOCOL_INFOA) / 2;
1734 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1735 "getsockopt should have failed\n");
1736 err = WSAGetLastError();
1737 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1738 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1739 size = sizeof(WSAPROTOCOL_INFOA) * 2;
1740 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1741 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1742 ok(size == sizeof(WSAPROTOCOL_INFOA) * 2, "got size %d\n", size);
1743
1744 closesocket(s);
1745
1746 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1747 for (i = 0; i < ARRAY_SIZE(prottest); i++)
1748 {
1749 int k;
1750
1751 s = socket(prottest[i].family, prottest[i].type, prottest[i].proto);
1752 if (s == INVALID_SOCKET && prottest[i].family == AF_INET6) continue;
1753
1754 ok(s != INVALID_SOCKET, "Failed to create socket: %d\n",
1755 WSAGetLastError());
1756
1757 /* compare both A and W version */
1758 infoA.szProtocol[0] = 0;
1759 size = sizeof(WSAPROTOCOL_INFOA);
1760 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1761 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1762 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1763
1764 infoW.szProtocol[0] = 0;
1765 size = sizeof(WSAPROTOCOL_INFOW);
1766 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOW, (char *) &infoW, &size);
1767 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1768 ok(size == sizeof(WSAPROTOCOL_INFOW), "got size %d\n", size);
1769
1770 ok(infoA.szProtocol[0], "WSAPROTOCOL_INFOA was not filled\n");
1771 ok(infoW.szProtocol[0], "WSAPROTOCOL_INFOW was not filled\n");
1772
1773 WideCharToMultiByte(CP_ACP, 0, infoW.szProtocol, -1,
1774 providername, sizeof(providername), NULL, NULL);
1775 ok(!strcmp(infoA.szProtocol,providername),
1776 "different provider names '%s' != '%s'\n", infoA.szProtocol, providername);
1777
1778 ok(!memcmp(&infoA, &infoW, FIELD_OFFSET(WSAPROTOCOL_INFOA, szProtocol)),
1779 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1780
1781 /* Remove IF when WSAEnumProtocols support IPV6 data */
1782 ok(infoA.iAddressFamily == prottest[i].family, "socket family invalid, expected %d received %d\n",
1783 prottest[i].family, infoA.iAddressFamily);
1784 ok(infoA.iSocketType == prottest[i].type, "socket type invalid, expected %d received %d\n",
1785 prottest[i].type, infoA.iSocketType);
1786 ok(infoA.iProtocol == prottest[i].proto, "socket protocol invalid, expected %d received %d\n",
1787 prottest[i].proto, infoA.iProtocol);
1788
1789 /* IP_HDRINCL is supported only on SOCK_RAW but passed to SOCK_DGRAM by Impossible Creatures */
1790 size = sizeof(i);
1791 k = 1;
1792 SetLastError(0xdeadbeef);
1793 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1794 if (err == -1) /* >= Vista */
1795 {
1796 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %ld\n", GetLastError());
1797 k = 99;
1798 SetLastError(0xdeadbeef);
1799 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1800 ok(err == -1, "Expected -1, got %d\n", err);
1801 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %ld\n", GetLastError());
1802 ok(k == 99, "Expected 99, got %d\n", k);
1803
1804 size = sizeof(k);
1805 k = 0;
1806 SetLastError(0xdeadbeef);
1807 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1808 ok(err == -1, "Expected -1, got %d\n", err);
1809 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %ld\n", GetLastError());
1810 k = 99;
1811 SetLastError(0xdeadbeef);
1812 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1813 ok(err == -1, "Expected -1, got %d\n", err);
1814 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %ld\n", GetLastError());
1815 ok(k == 99, "Expected 99, got %d\n", k);
1816 }
1817 else /* <= 2003 the tests differ between TCP and UDP, UDP silently accepts */
1818 {
1819 SetLastError(0xdeadbeef);
1820 k = 99;
1821 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1822 if (prottest[i].type == SOCK_DGRAM)
1823 {
1824 ok(err == 0, "Expected 0, got %d\n", err);
1825 ok(k == 1, "Expected 1, got %d\n", k);
1826 }
1827 else
1828 {
1829 /* contratry to what we could expect the function returns error but k is changed */
1830 ok(err == -1, "Expected -1, got %d\n", err);
1831 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %ld\n", GetLastError());
1832 ok(k == 0, "Expected 0, got %d\n", k);
1833 }
1834
1835 k = 0;
1836 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1837 ok(err == 0, "Expected 0, got %d\n", err);
1838
1839 k = 99;
1840 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1841 if (prottest[i].type == SOCK_DGRAM)
1842 {
1843 ok(err == 0, "Expected 0, got %d\n", err);
1844 ok(k == 0, "Expected 0, got %d\n", k);
1845 }
1846 else
1847 {
1848 /* contratry to what we could expect the function returns error but k is changed */
1849 ok(err == -1, "Expected -1, got %d\n", err);
1850 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %ld\n", GetLastError());
1851 ok(k == 0, "Expected 0, got %d\n", k);
1852 }
1853 }
1854
1855 closesocket(s);
1856 }
1857
1858 /* Test SO_BSP_STATE - Present only in >= Win 2008 */
1859 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1860 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1861 s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1862 ok(s2 != INVALID_SOCKET, "Failed to create socket\n");
1863
1864 SetLastError(0xdeadbeef);
1865 size = sizeof(csinfoA);
1866 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1867 if (!err)
1868 {
1869 struct sockaddr_in saddr;
1870 memset(&saddr, 0, sizeof(saddr));
1871 saddr.sin_family = AF_INET;
1872 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1873
1874 /* Socket is not bound, no information provided */
1875 ok(!csinfoA.cs.LocalAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.LocalAddr.iSockaddrLength);
1876 ok(csinfoA.cs.LocalAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.LocalAddr.lpSockaddr);
1877 /* Socket is not connected, no information provided */
1878 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.RemoteAddr.iSockaddrLength);
1879 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.RemoteAddr.lpSockaddr);
1880
1881 err = bind(s, (struct sockaddr*)&saddr, sizeof(saddr));
1882 ok(!err, "Expected 0, got %d\n", err);
1883 size = sizeof(csinfoA);
1884 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1885 ok(!err, "Expected 0, got %d\n", err);
1886
1887 /* Socket is bound */
1888 ok(csinfoA.cs.LocalAddr.iSockaddrLength, "Expected non-zero\n");
1889 ok(csinfoA.cs.LocalAddr.lpSockaddr != NULL, "Expected non-null\n");
1890 /* Socket is not connected, no information provided */
1891 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.RemoteAddr.iSockaddrLength);
1892 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.RemoteAddr.lpSockaddr);
1893
1894 err = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1895 ok(!err, "Expected 0, got %d\n", err);
1896 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1897 ok(!err, "Expected 0, got %d\n", err);
1898 err = listen(s2, 1);
1899 ok(!err, "Expected 0, got %d\n", err);
1900 err = connect(s, (struct sockaddr*)&saddr, sizeof(saddr));
1901 ok(!err, "Expected 0, got %d\n", err);
1902 size = sizeof(saddr);
1903 err = accept(s2, (struct sockaddr*)&saddr, &size);
1904 ok(err != INVALID_SOCKET, "Failed to accept socket\n");
1905 closesocket(s2);
1906 s2 = err;
1907
1908 size = sizeof(csinfoA);
1909 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1910 ok(!err, "Expected 0, got %d\n", err);
1911 err = getsockopt(s2, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoB, &size);
1912 ok(!err, "Expected 0, got %d\n", err);
1913 ok(size == sizeof(csinfoA), "Got %d\n", size);
1914 size = sizeof(saddr);
1915 ok(size == csinfoA.cs.LocalAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1916 csinfoA.cs.LocalAddr.iSockaddrLength);
1917 ok(size == csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1918 csinfoA.cs.RemoteAddr.iSockaddrLength);
1919 ok(!memcmp(csinfoA.cs.LocalAddr.lpSockaddr, csinfoB.cs.RemoteAddr.lpSockaddr, size),
1920 "Expected matching addresses\n");
1921 ok(!memcmp(csinfoB.cs.LocalAddr.lpSockaddr, csinfoA.cs.RemoteAddr.lpSockaddr, size),
1922 "Expected matching addresses\n");
1923 ok(csinfoA.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1924 ok(csinfoB.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1925 ok(csinfoA.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1926 ok(csinfoB.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1927
1928 err = getpeername(s, (struct sockaddr *)&saddr, &size);
1929 ok(!err, "Expected 0, got %d\n", err);
1930 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1931 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1932 err = getpeername(s2, (struct sockaddr *)&saddr, &size);
1933 ok(!err, "Expected 0, got %d\n", err);
1934 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1935 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1936 err = getsockname(s, (struct sockaddr *)&saddr, &size);
1937 ok(!err, "Expected 0, got %d\n", err);
1938 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1939 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1940 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1941 ok(!err, "Expected 0, got %d\n", err);
1942 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1943 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1944
1945 SetLastError(0xdeadbeef);
1946 size = sizeof(CSADDR_INFO);
1947 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1948 ok(err, "Expected non-zero\n");
1949 ok(size == sizeof(CSADDR_INFO), "Got %d\n", size);
1950 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %ld\n", GetLastError());
1951
1952 /* At least for IPv4 the size is exactly 56 bytes */
1953 size = sizeof(*csinfoA.cs.LocalAddr.lpSockaddr) * 2 + sizeof(csinfoA.cs);
1954 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1955 ok(!err, "Expected 0, got %d\n", err);
1956 size--;
1957 SetLastError(0xdeadbeef);
1958 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1959 ok(err, "Expected non-zero\n");
1960 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %ld\n", GetLastError());
1961 }
1962 else
1963 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %ld\n", GetLastError());
1964
1965 closesocket(s);
1966 closesocket(s2);
1967
1968 for (i = 0; i < 2; i++)
1969 {
1970 int family, level;
1971
1972 if (i)
1973 {
1974 family = AF_INET6;
1975 level = IPPROTO_IPV6;
1976 }
1977 else
1978 {
1979 family = AF_INET;
1980 level = IPPROTO_IP;
1981 }
1982
1983 s = socket(family, SOCK_DGRAM, 0);
1984 if (s == INVALID_SOCKET && i)
1985 {
1986 skip("IPv6 is not supported\n");
1987 break;
1988 }
1989 ok(s != INVALID_SOCKET, "socket failed with error %ld\n", GetLastError());
1990
1991 size = sizeof(value);
1992 value = 0xdead;
1993 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1994 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
1995 ok(value == 0, "Expected 0, got %ld\n", value);
1996
1997 size = sizeof(value);
1998 value = 1;
1999 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
2000 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2001
2002 value = 0xdead;
2003 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
2004 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2005 ok(value == 1, "Expected 1, got %ld\n", value);
2006
2007 size = sizeof(value);
2008 value = 0xdead;
2009 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
2010 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2011
2012 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
2013 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2014 ok(value == 1, "Expected 1, got %ld\n", value);
2015
2016 closesocket(s);
2017
2018 s = socket(family, SOCK_STREAM, 0);
2019 ok(s != INVALID_SOCKET, "socket failed with error %ld\n", GetLastError());
2020
2021 size = sizeof(value);
2022 value = 0xdead;
2023 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
2024 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2025 ok(value == 1 || broken(value == 0) /* < vista */, "Expected 1, got %ld\n", value);
2026
2027 size = sizeof(value);
2028 value = 0;
2029 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
2030 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2031
2032 value = 0xdead;
2033 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
2034 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2035 ok(value == 0, "Expected 0, got %ld\n", value);
2036
2037 closesocket(s);
2038
2039 s = socket(family, SOCK_RAW, 0);
2040 if (s == INVALID_SOCKET)
2041 {
2042 if (WSAGetLastError() == WSAEACCES) skip("SOCK_RAW is not available\n");
2043 else if (i) skip("IPv6 is not supported\n");
2044 break;
2045 }
2046 ok(s != INVALID_SOCKET, "socket failed with error %ld\n", GetLastError());
2047
2048 size = sizeof(value);
2049 value = 0xdead;
2050 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
2051 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2052 ok(value == 0, "Expected 0, got %ld\n", value);
2053
2054 size = sizeof(value);
2055 value = 1;
2056 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
2057 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2058
2059 value = 0xdead;
2060 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
2061 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2062 ok(value == 1, "Expected 1, got %ld\n", value);
2063
2064 closesocket(s);
2065 }
2066 }
2067
2068 static void test_reuseaddr(void)
2069 {
2070 static struct sockaddr_in6 saddr_in6_any, saddr_in6_loopback;
2071 static struct sockaddr_in6 saddr_in6_any_v4mapped, saddr_in6_loopback_v4mapped;
2072 static struct sockaddr_in saddr_in_any, saddr_in_loopback;
2073
2074 static const struct
2075 {
2076 int domain;
2077 struct sockaddr *addr_any;
2078 struct sockaddr *addr_loopback;
2079 socklen_t addrlen;
2080 }
2081 tests[] =
2082 {
2083 { AF_INET, (struct sockaddr *)&saddr_in_any, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_any) },
2084 { AF_INET6, (struct sockaddr *)&saddr_in6_any, (struct sockaddr *)&saddr_in6_loopback, sizeof(saddr_in6_any) },
2085 };
2086 static const struct
2087 {
2088 struct
2089 {
2090 int domain;
2091 struct sockaddr *addr;
2092 socklen_t addrlen;
2093 BOOL exclusive;
2094 }
2095 s[2];
2096 int error;
2097 }
2098 tests_exclusive[] =
2099 {
2100 {
2101 {{ AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, },
2102 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, }},
2103 WSAEACCES,
2104 },
2105 {
2106 {{ AF_INET6, (struct sockaddr *)&saddr_in6_any, sizeof(saddr_in6_any), TRUE, },
2107 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, }},
2108 WSAEACCES,
2109 },
2110 {
2111 {{ AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, },
2112 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, }},
2113 NOERROR,
2114 },
2115 {
2116 {{ AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, },
2117 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, }},
2118 WSAEACCES,
2119 },
2120 {
2121 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, },
2122 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, }},
2123 NOERROR,
2124 },
2125 {
2126 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, },
2127 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, }},
2128 WSAEADDRINUSE,
2129 },
2130 {
2131 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, },
2132 { AF_INET6, (struct sockaddr *)&saddr_in6_any, sizeof(saddr_in6_any), TRUE, }},
2133 WSAEADDRINUSE,
2134 },
2135 {
2136 {{ AF_INET6, (struct sockaddr *)&saddr_in6_loopback, sizeof(saddr_in6_loopback), FALSE, },
2137 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, }},
2138 NOERROR,
2139 },
2140 {
2141 {{ AF_INET6, (struct sockaddr *)&saddr_in6_loopback, sizeof(saddr_in6_loopback), TRUE, },
2142 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, }},
2143 NOERROR,
2144 },
2145 {
2146 {{ AF_INET6, (struct sockaddr *)&saddr_in6_loopback_v4mapped, sizeof(saddr_in6_loopback_v4mapped), FALSE, },
2147 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, }},
2148 WSAEADDRINUSE,
2149 },
2150 {
2151 {{ AF_INET6, (struct sockaddr *)&saddr_in6_any, sizeof(saddr_in6_any), TRUE, },
2152 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, }},
2153 WSAEACCES,
2154 },
2155 {
2156 {{ AF_INET6, (struct sockaddr *)&saddr_in6_any, sizeof(saddr_in6_any), FALSE, },
2157 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, }},
2158 NOERROR,
2159 },
2160 {
2161 {{ AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, },
2162 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, }},
2163 WSAEADDRINUSE,
2164 },
2165 {
2166 {{ AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, },
2167 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, }},
2168 WSAEADDRINUSE,
2169 },
2170 {
2171 {{ AF_INET6, (struct sockaddr *)&saddr_in6_any, sizeof(saddr_in6_any), FALSE, },
2172 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, }},
2173 NOERROR,
2174 },
2175 {
2176 {{ AF_INET6, (struct sockaddr *)&saddr_in6_any_v4mapped, sizeof(saddr_in6_any_v4mapped), FALSE, },
2177 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, }},
2178 WSAEADDRINUSE,
2179 },
2180 {
2181 {{ AF_INET6, (struct sockaddr *)&saddr_in6_loopback_v4mapped, sizeof(saddr_in6_loopback_v4mapped), FALSE, },
2182 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, }},
2183 WSAEADDRINUSE,
2184 },
2185 {
2186 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, },
2187 { AF_INET6, (struct sockaddr *)&saddr_in6_loopback_v4mapped, sizeof(saddr_in6_loopback_v4mapped), FALSE, }},
2188 WSAEADDRINUSE,
2189 },
2190 {
2191 {{ AF_INET6, (struct sockaddr *)&saddr_in6_loopback, sizeof(saddr_in6_loopback), TRUE, },
2192 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, }},
2193 NOERROR,
2194 },
2195 {
2196 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, },
2197 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, }},
2198 WSAEADDRINUSE,
2199 },
2200 {
2201 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, },
2202 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, }},
2203 WSAEADDRINUSE,
2204 },
2205 };
2206
2207 unsigned int rc, reuse, value;
2208 struct sockaddr_storage saddr;
2209 SOCKET s1, s2, s3, s4, s5, s6;
2210 unsigned int i, j;
2211 int size;
2212
2213 saddr_in_any.sin_family = AF_INET;
2214 saddr_in_any.sin_port = htons(SERVERPORT + 1);
2215 saddr_in_any.sin_addr.s_addr = htonl(INADDR_ANY);
2216 saddr_in_loopback = saddr_in_any;
2217 saddr_in_loopback.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
2218
2219 saddr_in6_any.sin6_family = AF_INET6;
2220 saddr_in6_any.sin6_port = htons(SERVERPORT + 1);
2221 memset( &saddr_in6_any.sin6_addr, 0, sizeof(saddr_in6_any.sin6_addr) );
2222 saddr_in6_loopback = saddr_in6_any;
2223 inet_pton(AF_INET6, "::1", &saddr_in6_loopback.sin6_addr);
2224
2225 saddr_in6_loopback_v4mapped = saddr_in6_any;
2226 rc = inet_pton(AF_INET6, "::ffff:127.0.0.1", &saddr_in6_loopback_v4mapped.sin6_addr);
2227 ok(rc, "got error %d.\n", WSAGetLastError());
2228
2229 saddr_in6_any_v4mapped = saddr_in6_any;
2230 rc = inet_pton(AF_INET6, "::ffff:0.0.0.0", &saddr_in6_any_v4mapped.sin6_addr);
2231 ok(rc, "got error %d.\n", WSAGetLastError());
2232
2233 for (i = 0; i < ARRAY_SIZE(tests); ++i)
2234 {
2235 winetest_push_context("test %u", i);
2236
2237 /* Test with SO_REUSEADDR on second socket only. */
2238 s1=socket(tests[i].domain, SOCK_STREAM, 0);
2239 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2240
2241 rc = bind(s1, tests[i].addr_loopback, tests[i].addrlen);
2242 ok(!rc || (tests[i].domain == AF_INET6 && WSAGetLastError() == WSAEADDRNOTAVAIL), "got error %d.\n", WSAGetLastError());
2243 if (tests[i].domain == AF_INET6 && WSAGetLastError() == WSAEADDRNOTAVAIL)
2244 {
2245 skip("IPv6 not supported, skipping test\n");
2246 closesocket(s1);
2247 winetest_pop_context();
2248 continue;
2249 }
2250
2251 s2 = socket(tests[i].domain, SOCK_STREAM, 0);
2252 ok(s2 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2253
2254 reuse = 1;
2255 rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
2256 ok(!rc, "got error %d.\n", WSAGetLastError());
2257
2258 rc = bind(s2, tests[i].addr_loopback, tests[i].addrlen);
2259 ok(rc == SOCKET_ERROR, "got rc %d.\n", rc);
2260 ok(WSAGetLastError() == WSAEACCES, "got error %d.\n", WSAGetLastError());
2261
2262 closesocket(s1);
2263 closesocket(s2);
2264
2265 /* Test with SO_REUSEADDR on both sockets. */
2266 s1 = socket(tests[i].domain, SOCK_STREAM, 0);
2267 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2268
2269 reuse = 1;
2270 rc = setsockopt(s1, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
2271 ok(!rc, "got error %d.\n", WSAGetLastError());
2272
2273 rc = bind(s1, tests[i].addr_loopback, tests[i].addrlen);
2274 ok(!rc, "got error %d.\n", WSAGetLastError());
2275
2276 s2 = socket(tests[i].domain, SOCK_STREAM, 0);
2277 ok(s2 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2278
2279 reuse = 0x1234;
2280 size = sizeof(reuse);
2281 rc = getsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, &size);
2282 ok(!rc && !reuse,"got rc %d, reuse %d.\n", rc, reuse);
2283
2284 rc = bind(s2, tests[i].addr_loopback, tests[i].addrlen);
2285 ok(rc == SOCKET_ERROR, "got rc %d, error %d.\n", rc, WSAGetLastError());
2286
2287 reuse = 1;
2288 rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
2289 ok(!rc, "got error %d.\n", WSAGetLastError());
2290
2291 rc = bind(s2, tests[i].addr_loopback, tests[i].addrlen);
2292 ok(!rc, "got error %d.\n", WSAGetLastError());
2293
2294 s3 = socket(tests[i].domain, SOCK_STREAM, 0);
2295 ok(s3 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2296
2297 /* Test if we can really connect to one of them. */
2298 rc = listen(s1, 1);
2299 ok(!rc, "got error %d.\n", WSAGetLastError());
2300 rc = listen(s2, 1);
2301 todo_wine ok(!rc, "got error %d.\n", WSAGetLastError());
2302 rc = connect(s3, tests[i].addr_loopback, tests[i].addrlen);
2303 ok(!rc, "got error %d.\n", WSAGetLastError());
2304
2305 /* The connection is delivered to the first socket. */
2306 size = tests[i].addrlen;
2307 s4 = accept(s1, (struct sockaddr *)&saddr, &size);
2308 ok(s4 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2309
2310 closesocket(s1);
2311 closesocket(s2);
2312 closesocket(s3);
2313 closesocket(s4);
2314
2315 /* Test binding and listening on any addr together with loopback, any addr first. */
2316 s1 = socket(tests[i].domain, SOCK_STREAM, 0);
2317 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2318
2319 rc = bind(s1, tests[i].addr_any, tests[i].addrlen);
2320 ok(!rc, "got error %d.\n", WSAGetLastError());
2321
2322 rc = listen(s1, 1);
2323 ok(!rc, "got error %d.\n", WSAGetLastError());
2324
2325 s2 = socket(tests[i].domain, SOCK_STREAM, 0);
2326 ok(s2 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2327
2328 rc = bind(s2, tests[i].addr_loopback, tests[i].addrlen);
2329 todo_wine ok(!rc, "got error %d.\n", WSAGetLastError());
2330
2331 rc = listen(s2, 1);
2332 todo_wine ok(!rc, "got error %d.\n", WSAGetLastError());
2333
2334 s3 = socket(tests[i].domain, SOCK_STREAM, 0);
2335 ok(s3 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2336
2337 rc = connect(s3, tests[i].addr_loopback, tests[i].addrlen);
2338 ok(!rc, "got error %d.\n", WSAGetLastError());
2339
2340 size = tests[i].addrlen;
2341 s4 = accept(s2, (struct sockaddr *)&saddr, &size);
2342 todo_wine ok(s4 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2343
2344 closesocket(s1);
2345 closesocket(s2);
2346 closesocket(s3);
2347 closesocket(s4);
2348
2349 /* Test binding and listening on any addr together with loopback, loopback addr first. */
2350
2351 s1 = socket(tests[i].domain, SOCK_STREAM, 0);
2352 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2353
2354 rc = bind(s1, tests[i].addr_loopback, tests[i].addrlen);
2355 ok(!rc, "got error %d.\n", WSAGetLastError());
2356
2357 rc = listen(s1, 1);
2358 ok(!rc, "got error %d.\n", WSAGetLastError());
2359
2360 s2 = socket(tests[i].domain, SOCK_STREAM, 0);
2361 ok(s2 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2362
2363 rc = bind(s2, tests[i].addr_any, tests[i].addrlen);
2364 todo_wine ok(!rc, "got rc %d, error %d.\n", rc, WSAGetLastError());
2365
2366 rc = listen(s2, 1);
2367 todo_wine ok(!rc, "got error %d.\n", WSAGetLastError());
2368
2369 s3 = socket(tests[i].domain, SOCK_STREAM, 0);
2370 ok(s3 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2371
2372 rc = connect(s3, tests[i].addr_loopback, tests[i].addrlen);
2373 ok(!rc, "got error %d.\n", WSAGetLastError());
2374 size = tests[i].addrlen;
2375 s4 = accept(s1, (struct sockaddr *)&saddr, &size);
2376
2377 ok(s4 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2378
2379 closesocket(s1);
2380 closesocket(s2);
2381 closesocket(s3);
2382 closesocket(s4);
2383
2384 /* Test binding to INADDR_ANY on two sockets. */
2385 s1 = socket(tests[i].domain, SOCK_STREAM, 0);
2386 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2387
2388 rc = bind(s1, tests[i].addr_any, tests[i].addrlen);
2389 ok(!rc, "got error %d.\n", WSAGetLastError());
2390
2391 s2 = socket(tests[i].domain, SOCK_STREAM, 0);
2392 ok(s2 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2393
2394 rc = bind(s2, tests[i].addr_any, tests[i].addrlen);
2395 ok(rc == SOCKET_ERROR && WSAGetLastError() == WSAEADDRINUSE, "got rc %d, error %d.\n", rc, WSAGetLastError());
2396
2397 closesocket(s1);
2398 closesocket(s2);
2399
2400 /* Test successive binds and bind-after-listen */
2401 reuse = 1;
2402 s1 = socket(tests[i].domain, SOCK_STREAM, 0);
2403 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2404 rc = setsockopt(s1, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
2405 ok(!rc, "got error %d.\n", WSAGetLastError());
2406
2407 s2 = socket(tests[i].domain, SOCK_STREAM, 0);
2408 ok(s2 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2409 rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
2410 ok(!rc, "got error %d.\n", WSAGetLastError());
2411
2412 s3 = socket(tests[i].domain, SOCK_STREAM, 0);
2413 ok(s3 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2414 rc = setsockopt(s3, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
2415 ok(!rc, "got error %d.\n", WSAGetLastError());
2416
2417 s4 = socket(tests[i].domain, SOCK_STREAM, 0);
2418 ok(s4 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2419 rc = setsockopt(s4, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
2420 ok(!rc, "got error %d.\n", WSAGetLastError());
2421
2422 rc = bind(s1, tests[i].addr_loopback, tests[i].addrlen);
2423 ok(!rc, "got error %d.\n", WSAGetLastError());
2424
2425 rc = bind(s2, tests[i].addr_loopback, tests[i].addrlen);
2426 ok(!rc, "got error %d.\n", WSAGetLastError());
2427
2428 s5 = socket(tests[i].domain, SOCK_STREAM, 0);
2429 ok(s5 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2430
2431 rc = listen(s1, 1);
2432 ok(!rc, "got error %d.\n", WSAGetLastError());
2433 rc = listen(s2, 1);
2434 todo_wine ok(!rc, "got error %d.\n", WSAGetLastError());
2435 rc = connect(s5, tests[i].addr_loopback, tests[i].addrlen);
2436 ok(!rc, "got error %d.\n", WSAGetLastError());
2437
2438 /* The connection is delivered to the first socket. */
2439 size = tests[i].addrlen;
2440 s6 = accept(s1, (struct sockaddr *)&saddr, &size);
2441 ok(s6 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2442
2443 closesocket(s1);
2444 closesocket(s5);
2445 closesocket(s6);
2446
2447 rc = bind(s3, tests[i].addr_loopback, tests[i].addrlen);
2448 ok(!rc, "got error %d.\n", WSAGetLastError());
2449
2450 s5 = socket(tests[i].domain, SOCK_STREAM, 0);
2451 ok(s5 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2452 rc = connect(s5, tests[i].addr_loopback, tests[i].addrlen);
2453 todo_wine ok(!rc, "got error %d.\n", WSAGetLastError());
2454
2455 /* The connection is delivered to the second socket. */
2456 size = tests[i].addrlen;
2457 s6 = accept(s2, (struct sockaddr *)&saddr, &size);
2458 todo_wine ok(s6 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2459
2460 closesocket(s2);
2461 closesocket(s5);
2462 closesocket(s6);
2463
2464 rc = bind(s4, tests[i].addr_loopback, tests[i].addrlen);
2465 ok(!rc, "got error %d.\n", WSAGetLastError());
2466 rc = listen(s3, 1);
2467 ok(!rc, "got error %d.\n", WSAGetLastError());
2468
2469 s5 = socket(tests[i].domain, SOCK_STREAM, 0);
2470 ok(s5 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2471 rc = connect(s5, tests[i].addr_loopback, tests[i].addrlen);
2472 ok(!rc, "got error %d.\n", WSAGetLastError());
2473
2474 /* The connection is delivered to the third socket. */
2475 size = tests[i].addrlen;
2476 s6 = accept(s3, (struct sockaddr *)&saddr, &size);
2477 ok(s6 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2478
2479 closesocket(s3);
2480 closesocket(s5);
2481 closesocket(s6);
2482
2483 rc = listen(s4, 1);
2484 ok(!rc, "got error %d.\n", WSAGetLastError());
2485
2486 s5 = socket(tests[i].domain, SOCK_STREAM, 0);
2487 ok(s5 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2488 rc = connect(s5, tests[i].addr_loopback, tests[i].addrlen);
2489 ok(!rc, "got error %d.\n", WSAGetLastError());
2490
2491 /* The connection is delivered to the fourth socket. */
2492 size = tests[i].addrlen;
2493 s6 = accept(s4, (struct sockaddr *)&saddr, &size);
2494 ok(s6 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2495
2496 closesocket(s4);
2497 closesocket(s5);
2498 closesocket(s6);
2499
2500 winetest_pop_context();
2501 }
2502
2503 /* SO_REUSEADDR and SO_EXCLUSIVEADDRUSE are mutually exclusive. */
2504 s1 = socket(AF_INET, SOCK_STREAM, 0);
2505 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2506
2507 value = 1;
2508 rc = setsockopt(s1, SOL_SOCKET, SO_REUSEADDR, (char*)&value, sizeof(value));
2509 ok(!rc, "got error %d.\n", WSAGetLastError());
2510
2511 value = 1;
2512 rc = setsockopt(s1, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&value, sizeof(value));
2513 ok(rc == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL, "got rc %d, error %d.\n", rc, WSAGetLastError());
2514
2515 value = 0;
2516 rc = setsockopt(s1, SOL_SOCKET, SO_REUSEADDR, (char*)&value, sizeof(value));
2517
2518 value = 1;
2519 rc = setsockopt(s1, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&value, sizeof(value));
2520 ok(!rc, "got error %d.\n", WSAGetLastError());
2521
2522 value = 1;
2523 rc = setsockopt(s1, SOL_SOCKET, SO_REUSEADDR, (char*)&value, sizeof(value));
2524 ok(rc == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL, "got rc %d, error %d.\n", rc, WSAGetLastError());
2525
2526 closesocket(s1);
2527
2528 /* Test SO_EXCLUSIVEADDRUSE. */
2529 for (i = 0; i < ARRAY_SIZE(tests_exclusive); ++i)
2530 {
2531 SOCKET s[2];
2532
2533 winetest_push_context("test %u", i);
2534
2535 for (j = 0; j < 2; ++j)
2536 {
2537 s[j] = socket(tests_exclusive[i].s[j].domain, SOCK_STREAM, 0);
2538 ok(s[j] != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2539
2540 if (tests_exclusive[i].s[j].exclusive)
2541 {
2542 value = 1;
2543 rc = setsockopt(s[j], SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&value, sizeof(value));
2544 ok(!rc, "got error %d.\n", WSAGetLastError());
2545 }
2546 if (tests_exclusive[i].s[j].domain == AF_INET6)
2547 {
2548 value = 0;
2549 rc = setsockopt(s[j], IPPROTO_IPV6, IPV6_V6ONLY, (char*)&value, sizeof(value));
2550 ok(!rc, "got error %d.\n", WSAGetLastError());
2551 }
2552 }
2553 rc = bind(s[0], tests_exclusive[i].s[0].addr, tests_exclusive[i].s[0].addrlen);
2554 ok(!rc || (tests_exclusive[i].s[0].domain == AF_INET6 && WSAGetLastError() == WSAEADDRNOTAVAIL), "got error %d.\n", WSAGetLastError());
2555
2556 rc = bind(s[1], tests_exclusive[i].s[1].addr, tests_exclusive[i].s[1].addrlen);
2557
2558 if (tests_exclusive[i].error)
2559 ok(rc == SOCKET_ERROR && WSAGetLastError() == tests_exclusive[i].error,
2560 "got rc %d, error %d, expected error %d.\n", rc, WSAGetLastError(), tests_exclusive[i].error);
2561 else
2562 ok(!rc, "got error %d.\n", WSAGetLastError());
2563
2564 closesocket(s[0]);
2565 closesocket(s[1]);
2566 winetest_pop_context();
2567 }
2568 }
2569
2570 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
2571
2572 static unsigned int got_ip_pktinfo_apc;
2573
2574 static void WINAPI ip_pktinfo_apc(DWORD error, DWORD size, OVERLAPPED *overlapped, DWORD flags)
2575 {
2576 ok(error == WSAEMSGSIZE, "got error %lu\n", error);
2577 ok(size == 6, "got size %lu\n", size);
2578 ok(!flags, "got flags %#lx\n", flags);
2579 ++got_ip_pktinfo_apc;
2580 }
2581
2582 static void test_ip_pktinfo(void)
2583 {
2584 ULONG addresses[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY)};
2585 char recvbuf[10], pktbuf[512], msg[] = "HELLO";
2586 struct sockaddr_in s1addr, s2addr, s3addr;
2587 LPFN_WSARECVMSG pWSARecvMsg = NULL;
2588 unsigned int rc, yes = 1;
2589 BOOL foundhdr;
2590 DWORD dwBytes, dwSize, dwFlags;
2591 socklen_t addrlen;
2592 WSACMSGHDR *cmsg;
2593 WSAOVERLAPPED ov;
2594 WSABUF iovec[1];
2595 SOCKET s1, s2;
2596 WSAMSG hdr;
2597 int i, err;
2598
2599 memset(&ov, 0, sizeof(ov));
2600 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
2601
2602 memset(&hdr, 0x00, sizeof(hdr));
2603 s1addr.sin_family = AF_INET;
2604 s1addr.sin_port = htons(0);
2605 /* Note: s1addr.sin_addr is set below */
2606 iovec[0].buf = recvbuf;
2607 iovec[0].len = sizeof(recvbuf);
2608 hdr.name = (struct sockaddr*)&s3addr;
2609 hdr.namelen = sizeof(s3addr);
2610 hdr.lpBuffers = &iovec[0];
2611 hdr.dwBufferCount = 1;
2612 hdr.Control.buf = pktbuf;
2613 /* Note: hdr.Control.len is set below */
2614 hdr.dwFlags = 0;
2615
2616 for (i=0;i<ARRAY_SIZE(addresses);i++)
2617 {
2618 s1addr.sin_addr.s_addr = addresses[i];
2619
2620 /* Build "server" side socket */
2621 s1=socket(AF_INET, SOCK_DGRAM, 0);
2622 ok(s1 != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2623
2624 /* Obtain the WSARecvMsg function */
2625 rc = WSAIoctl(s1, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
2626 &pWSARecvMsg, sizeof(pWSARecvMsg), &dwBytes, NULL, NULL);
2627 ok(!rc, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
2628
2629 /* Setup the server side socket */
2630 rc=bind(s1, (struct sockaddr*)&s1addr, sizeof(s1addr));
2631 ok(rc != SOCKET_ERROR, "bind() failed error: %d\n", WSAGetLastError());
2632
2633 /* Build "client" side socket */
2634 addrlen = sizeof(s2addr);
2635 rc = getsockname(s1, (struct sockaddr *) &s2addr, &addrlen);
2636 ok(!rc, "failed to get address, error %u\n", WSAGetLastError());
2637 s2addr.sin_addr.s_addr = addresses[0]; /* Always target the local adapter address */
2638 s2=socket(AF_INET, SOCK_DGRAM, 0);
2639 ok(s2 != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2640
2641 /* Test an empty message header */
2642 rc=pWSARecvMsg(s1, NULL, NULL, NULL, NULL);
2643 err=WSAGetLastError();
2644 ok(rc == SOCKET_ERROR && err == WSAEFAULT, "WSARecvMsg() failed error: %d (ret = %d)\n", err, rc);
2645
2646 /* Test that when no control data arrives, a 0-length NULL-valued control buffer should succeed */
2647 SetLastError(0xdeadbeef);
2648 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2649 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2650 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
2651 hdr.Control.buf = NULL;
2652 hdr.Control.len = 0;
2653 rc=pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
2654 ok(rc == 0, "WSARecvMsg() failed error: %d\n", WSAGetLastError());
2655 hdr.Control.buf = pktbuf;
2656
2657 /* Now start IP_PKTINFO for future tests */
2658 rc=setsockopt(s1, IPPROTO_IP, IP_PKTINFO, (const char*)&yes, sizeof(yes));
2659 ok(rc == 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
2660
2661 /*
2662 * Send a packet from the client to the server and test for specifying
2663 * a short control header.
2664 */
2665 SetLastError(0xdeadbeef);
2666 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2667 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2668 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
2669 hdr.Control.len = 1;
2670 dwSize = 0xdeadbeef;
2671 rc = pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
2672 ok(rc == -1, "expected failure\n");
2673 ok(WSAGetLastError() == WSAEMSGSIZE, "got error %u\n", WSAGetLastError());
2674 todo_wine ok(dwSize == sizeof(msg), "got size %lu\n", dwSize);
2675 ok(hdr.dwFlags == MSG_CTRUNC, "got flags %#lx\n", hdr.dwFlags);
2676 hdr.dwFlags = 0; /* Reset flags */
2677
2678 /* Perform another short control header test, this time with an overlapped receive */
2679 hdr.Control.len = 1;
2680 ov.Internal = 0xdead1;
2681 ov.InternalHigh = 0xdead2;
2682 ov.Offset = 0xdead3;
2683 ov.OffsetHigh = 0xdead4;
2684 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
2685 err=WSAGetLastError();
2686 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
2687 SetLastError(0xdeadbeef);
2688 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2689 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2690 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
2691 ok(!WaitForSingleObject(ov.hEvent, 100), "wait failed\n");
2692 ok((NTSTATUS)ov.Internal == STATUS_BUFFER_OVERFLOW, "got status %#lx\n", (NTSTATUS)ov.Internal);
2693 ok(ov.InternalHigh == sizeof(msg), "got size %Iu\n", ov.InternalHigh);
2694 ok(ov.Offset == 0xdead3, "got Offset %lu\n", ov.Offset);
2695 ok(ov.OffsetHigh == 0xdead4, "got OffsetHigh %lu\n", ov.OffsetHigh);
2696 dwFlags = 0xdeadbeef;
2697 rc = WSAGetOverlappedResult(s1, &ov, &dwSize, FALSE, &dwFlags);
2698 ok(!rc, "expected failure\n");
2699 ok(WSAGetLastError() == WSAEMSGSIZE, "got error %u\n", WSAGetLastError());
2700 ok(dwSize == sizeof(msg), "got size %lu\n", dwSize);
2701 todo_wine ok(dwFlags == 0xdeadbeef, "got flags %#lx\n", dwFlags);
2702 ok(hdr.dwFlags == MSG_CTRUNC,
2703 "WSARecvMsg() overlapped operation set unexpected flags %ld.\n", hdr.dwFlags);
2704 hdr.dwFlags = 0; /* Reset flags */
2705
2706 /* And with an APC. */
2707
2708 SetLastError(0xdeadbeef);
2709 rc = sendto(s2, msg, sizeof(msg), 0, (struct sockaddr *)&s2addr, sizeof(s2addr));
2710 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2711 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
2712 hdr.Control.len = 1;
2713
2714 ov.Internal = 0xdead1;
2715 ov.InternalHigh = 0xdead2;
2716 ov.Offset = 0xdead3;
2717 ov.OffsetHigh = 0xdead4;
2718 dwSize = 0xdeadbeef;
2719 rc = pWSARecvMsg(s1, &hdr, NULL, &ov, ip_pktinfo_apc);
2720 ok(rc == -1, "expected failure\n");
2721 todo_wine ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
2722
2723 rc = SleepEx(1000, TRUE);
2724 ok(rc == WAIT_IO_COMPLETION, "got %d\n", rc);
2725 ok(got_ip_pktinfo_apc == 1, "apc was called %u times\n", got_ip_pktinfo_apc);
2726 ok(hdr.dwFlags == MSG_CTRUNC, "got flags %#lx\n", hdr.dwFlags);
2727 got_ip_pktinfo_apc = 0;
2728
2729 hdr.dwFlags = 0; /* Reset flags */
2730
2731 /*
2732 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
2733 * on the server end and check that the returned packet matches what was sent.
2734 */
2735 hdr.Control.len = sizeof(pktbuf);
2736 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
2737 err=WSAGetLastError();
2738 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
2739 ok(hdr.Control.len == sizeof(pktbuf),
2740 "WSARecvMsg() control length mismatch (%ld != sizeof pktbuf).\n", hdr.Control.len);
2741 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2742 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2743 ok(!WaitForSingleObject(ov.hEvent, 100), "wait failed\n");
2744 dwSize = 0;
2745 WSAGetOverlappedResult(s1, &ov, &dwSize, FALSE, NULL);
2746 ok(dwSize == sizeof(msg),
2747 "WSARecvMsg() buffer length does not match transmitted data!\n");
2748 ok(strncmp(iovec[0].buf, msg, sizeof(msg)) == 0,
2749 "WSARecvMsg() buffer does not match transmitted data!\n");
2750 ok(hdr.Control.len == IP_PKTINFO_LEN,
2751 "WSARecvMsg() control length mismatch (%ld).\n", hdr.Control.len);
2752
2753 /* Test for the expected IP_PKTINFO return information. */
2754 foundhdr = FALSE;
2755 for (cmsg = WSA_CMSG_FIRSTHDR(&hdr); cmsg != NULL; cmsg = WSA_CMSG_NXTHDR(&hdr, cmsg))
2756 {
2757 if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO)
2758 {
2759 struct in_pktinfo *pi = (struct in_pktinfo *)WSA_CMSG_DATA(cmsg);
2760
2761 ok(pi->ipi_addr.s_addr == s2addr.sin_addr.s_addr, "destination ip mismatch!\n");
2762 foundhdr = TRUE;
2763 }
2764 }
2765 ok(foundhdr, "IP_PKTINFO header information was not returned!\n");
2766
2767 closesocket(s2);
2768 closesocket(s1);
2769 }
2770
2771 CloseHandle(ov.hEvent);
2772 }
2773
2774 static void test_ipv4_cmsg(void)
2775 {
2776 static const DWORD off = 0;
2777 static const DWORD on = 1;
2778 SOCKADDR_IN localhost = {0};
2779 SOCKET client, server;
2780 char payload[] = "HELLO";
2781 char control[100];
2782 WSABUF payload_buf = {sizeof(payload), payload};
2783 WSAMSG msg = {NULL, 0, &payload_buf, 1, {sizeof(control), control}, 0};
2784 WSACMSGHDR *header = (WSACMSGHDR *)control;
2785 LPFN_WSARECVMSG pWSARecvMsg;
2786 INT *int_data = (INT *)WSA_CMSG_DATA(header);
2787 IN_PKTINFO *pkt_info = (IN_PKTINFO *)WSA_CMSG_DATA(header);
2788 DWORD count, state;
2789 int rc;
2790
2791 localhost.sin_family = AF_INET;
2792 localhost.sin_port = htons(SERVERPORT);
2793 inet_pton(AF_INET, "127.0.0.1", &localhost.sin_addr);
2794
2795 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
2796 ok(client != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2797 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
2798 ok(server != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2799
2800 rc = bind(server, (SOCKADDR *)&localhost, sizeof(localhost));
2801 ok(rc != SOCKET_ERROR, "bind failed, error %u\n", WSAGetLastError());
2802 rc = connect(client, (SOCKADDR *)&localhost, sizeof(localhost));
2803 ok(rc != SOCKET_ERROR, "connect failed, error %u\n", WSAGetLastError());
2804
2805 rc = WSAIoctl(server, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
2806 &pWSARecvMsg, sizeof(pWSARecvMsg), &count, NULL, NULL);
2807 ok(!rc, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
2808
2809 memset(control, 0, sizeof(control));
2810 msg.Control.len = sizeof(control);
2811 rc = setsockopt(server, IPPROTO_IP, IP_RECVTTL, (const char *)&on, sizeof(on));
2812 ok(!rc, "failed to set IP_RECVTTL, error %u\n", WSAGetLastError());
2813 state = 0;
2814 count = sizeof(state);
2815 rc = getsockopt(server, IPPROTO_IP, IP_RECVTTL, (char *)&state, (INT *)&count);
2816 ok(!rc, "failed to get IP_RECVTTL, error %u\n", WSAGetLastError());
2817 ok(state == 1, "expected 1, got %lu\n", state);
2818 rc = send(client, payload, sizeof(payload), 0);
2819 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2820 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2821 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2822 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2823 ok(header->cmsg_level == IPPROTO_IP, "expected IPPROTO_IP, got %i\n", header->cmsg_level);
2824 ok(header->cmsg_type == IP_TTL || broken(header->cmsg_type == IP_HOPLIMIT) /* <= win10 v1607 */,
2825 "expected IP_TTL, got %i\n", header->cmsg_type);
2826 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
2827 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(INT), header->cmsg_len);
2828 ok(*int_data >= 32, "expected at least 32, got %i\n", *int_data);
2829 setsockopt(server, IPPROTO_IP, IP_RECVTTL, (const char *)&off, sizeof(off));
2830 ok(!rc, "failed to clear IP_RECVTTL, error %u\n", WSAGetLastError());
2831
2832 memset(control, 0, sizeof(control));
2833 msg.Control.len = sizeof(control);
2834 rc = setsockopt(server, IPPROTO_IP, IP_PKTINFO, (const char *)&on, sizeof(on));
2835 ok(!rc, "failed to set IP_PKTINFO, error %u\n", WSAGetLastError());
2836 state = 0;
2837 count = sizeof(state);
2838 rc = getsockopt(server, IPPROTO_IP, IP_PKTINFO, (char *)&state, (INT *)&count);
2839 ok(!rc, "failed to get IP_PKTINFO, error %u\n", WSAGetLastError());
2840 ok(state == 1, "expected 1, got %lu\n", state);
2841 rc = send(client, payload, sizeof(payload), 0);
2842 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2843 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2844 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2845 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2846 ok(header->cmsg_level == IPPROTO_IP, "expected IPPROTO_IP, got %i\n", header->cmsg_level);
2847 ok(header->cmsg_type == IP_PKTINFO, "expected IP_PKTINFO, got %i\n", header->cmsg_type);
2848 ok(header->cmsg_len == sizeof(*header) + sizeof(IN_PKTINFO),
2849 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(IN_PKTINFO), header->cmsg_len);
2850 ok(!memcmp(&pkt_info->ipi_addr, &localhost.sin_addr, sizeof(IN_ADDR)), "expected 127.0.0.1\n");
2851 rc = setsockopt(server, IPPROTO_IP, IP_PKTINFO, (const char *)&off, sizeof(off));
2852 ok(!rc, "failed to clear IP_PKTINFO, error %u\n", WSAGetLastError());
2853
2854 memset(control, 0, sizeof(control));
2855 msg.Control.len = sizeof(control);
2856 rc = setsockopt(server, IPPROTO_IP, IP_RECVTOS, (const char *)&on, sizeof(on));
2857 ok(!rc, "failed to set IP_RECVTOS, error %u\n", WSAGetLastError());
2858 state = 0;
2859 count = sizeof(state);
2860 rc = getsockopt(server, IPPROTO_IP, IP_RECVTOS, (char *)&state, (INT *)&count);
2861 ok(!rc, "failed to get IP_RECVTOS, error %u\n", WSAGetLastError());
2862 ok(state == 1, "expected 1, got %lu\n", state);
2863 rc = send(client, payload, sizeof(payload), 0);
2864 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2865 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2866 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2867 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2868 ok(header->cmsg_level == IPPROTO_IP, "expected IPPROTO_IP, got %i\n", header->cmsg_level);
2869 ok(header->cmsg_type == IP_TOS || broken(header->cmsg_type == IP_TCLASS) /* <= win10 v1607 */,
2870 "expected IP_TOS, got %i\n", header->cmsg_type);
2871 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
2872 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(INT), header->cmsg_len);
2873 ok(*int_data == 0, "expected 0, got %i\n", *int_data);
2874 rc = setsockopt(server, IPPROTO_IP, IP_RECVTOS, (const char *)&off, sizeof(off));
2875 ok(!rc, "failed to clear IP_RECVTOS, error %u\n", WSAGetLastError());
2876
2877 closesocket(server);
2878 closesocket(client);
2879 }
2880
2881 static void test_ipv6_cmsg(void)
2882 {
2883 static const DWORD off = 0;
2884 static const DWORD on = 1;
2885 SOCKADDR_IN6 localhost = {0};
2886 SOCKET client, server;
2887 char payload[] = "HELLO";
2888 char control[100];
2889 WSABUF payload_buf = {sizeof(payload), payload};
2890 WSAMSG msg = {NULL, 0, &payload_buf, 1, {sizeof(control), control}, 0};
2891 WSACMSGHDR *header = (WSACMSGHDR *)control;
2892 LPFN_WSARECVMSG pWSARecvMsg;
2893 INT *int_data = (INT *)WSA_CMSG_DATA(header);
2894 IN6_PKTINFO *pkt_info = (IN6_PKTINFO *)WSA_CMSG_DATA(header);
2895 DWORD count, state;
2896 int rc;
2897
2898 localhost.sin6_family = AF_INET6;
2899 localhost.sin6_port = htons(SERVERPORT);
2900 inet_pton(AF_INET6, "::1", &localhost.sin6_addr);
2901
2902 client = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
2903 ok(client != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2904 server = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
2905 ok(server != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2906
2907 rc = bind(server, (SOCKADDR *)&localhost, sizeof(localhost));
2908 ok(rc != SOCKET_ERROR || WSAGetLastError() == WSAEADDRNOTAVAIL, "bind failed, error %u\n", WSAGetLastError());
2909 if (WSAGetLastError() == WSAEADDRNOTAVAIL)
2910 {
2911 skip("IPv6 not supported, skipping test\n");
2912 goto cleanup;
2913 }
2914 rc = connect(client, (SOCKADDR *)&localhost, sizeof(localhost));
2915 ok(rc != SOCKET_ERROR, "connect failed, error %u\n", WSAGetLastError());
2916
2917 rc = WSAIoctl(server, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
2918 &pWSARecvMsg, sizeof(pWSARecvMsg), &count, NULL, NULL);
2919 ok(!rc, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
2920
2921 memset(control, 0, sizeof(control));
2922 msg.Control.len = sizeof(control);
2923 rc = setsockopt(server, IPPROTO_IPV6, IPV6_HOPLIMIT, (const char *)&on, sizeof(on));
2924 ok(!rc, "failed to set IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2925 state = 0;
2926 count = sizeof(state);
2927 rc = getsockopt(server, IPPROTO_IPV6, IPV6_HOPLIMIT, (char *)&state, (INT *)&count);
2928 ok(!rc, "failed to get IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2929 ok(state == 1, "expected 1, got %lu\n", state);
2930 rc = send(client, payload, sizeof(payload), 0);
2931 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2932 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2933 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2934 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2935 ok(header->cmsg_level == IPPROTO_IPV6, "expected IPPROTO_IPV6, got %i\n", header->cmsg_level);
2936 ok(header->cmsg_type == IPV6_HOPLIMIT, "expected IPV6_HOPLIMIT, got %i\n", header->cmsg_type);
2937 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
2938 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(INT), header->cmsg_len);
2939 ok(*int_data >= 32, "expected at least 32, got %i\n", *int_data);
2940 setsockopt(server, IPPROTO_IPV6, IPV6_HOPLIMIT, (const char *)&off, sizeof(off));
2941 ok(!rc, "failed to clear IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2942
2943 memset(control, 0, sizeof(control));
2944 msg.Control.len = sizeof(control);
2945 rc = setsockopt(server, IPPROTO_IPV6, IPV6_PKTINFO, (const char *)&on, sizeof(on));
2946 ok(!rc, "failed to set IPV6_PKTINFO, error %u\n", WSAGetLastError());
2947 state = 0;
2948 count = sizeof(state);
2949 rc = getsockopt(server, IPPROTO_IPV6, IPV6_PKTINFO, (char *)&state, (INT *)&count);
2950 ok(!rc, "failed to get IPV6_PKTINFO, error %u\n", WSAGetLastError());
2951 ok(state == 1, "expected 1, got %lu\n", state);
2952 rc = send(client, payload, sizeof(payload), 0);
2953 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2954 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2955 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2956 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2957 ok(header->cmsg_level == IPPROTO_IPV6, "expected IPPROTO_IPV6, got %i\n", header->cmsg_level);
2958 ok(header->cmsg_type == IPV6_PKTINFO, "expected IPV6_PKTINFO, got %i\n", header->cmsg_type);
2959 ok(header->cmsg_len == sizeof(*header) + sizeof(IN6_PKTINFO),
2960 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(IN6_PKTINFO), header->cmsg_len);
2961 ok(!memcmp(&pkt_info->ipi6_addr, &localhost.sin6_addr, sizeof(IN6_ADDR)), "expected ::1\n");
2962 rc = setsockopt(server, IPPROTO_IPV6, IPV6_PKTINFO, (const char *)&off, sizeof(off));
2963 ok(!rc, "failed to clear IPV6_PKTINFO, error %u\n", WSAGetLastError());
2964
2965 memset(control, 0, sizeof(control));
2966 msg.Control.len = sizeof(control);
2967 rc = setsockopt(server, IPPROTO_IPV6, IPV6_RECVTCLASS, (const char *)&on, sizeof(on));
2968 ok(!rc, "failed to set IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
2969 state = 0;
2970 count = sizeof(state);
2971 rc = getsockopt(server, IPPROTO_IPV6, IPV6_RECVTCLASS, (char *)&state, (INT *)&count);
2972 ok(!rc, "failed to get IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
2973 ok(state == 1, "expected 1, got %lu\n", state);
2974 rc = send(client, payload, sizeof(payload), 0);
2975 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2976 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2977 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2978 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2979 ok(header->cmsg_level == IPPROTO_IPV6, "expected IPPROTO_IPV6, got %i\n", header->cmsg_level);
2980 ok(header->cmsg_type == IPV6_TCLASS, "expected IPV6_TCLASS, got %i\n", header->cmsg_type);
2981 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
2982 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(INT), header->cmsg_len);
2983 ok(*int_data == 0, "expected 0, got %i\n", *int_data);
2984 rc = setsockopt(server, IPPROTO_IPV6, IPV6_RECVTCLASS, (const char *)&off, sizeof(off));
2985 ok(!rc, "failed to clear IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
2986
2987 cleanup:
2988 closesocket(server);
2989 closesocket(client);
2990 }
2991
2992 /************* Array containing the tests to run **********/
2993
2994 #define STD_STREAM_SOCKET \
2995 SOCK_STREAM, \
2996 0, \
2997 SERVERIP, \
2998 SERVERPORT
2999
3000 static test_setup tests [] =
3001 {
3002 /* Test 0: synchronous client and server */
3003 {
3004 {
3005 STD_STREAM_SOCKET,
3006 2048,
3007 16,
3008 2
3009 },
3010 simple_server,
3011 {
3012 NULL,
3013 0,
3014 64
3015 },
3016 simple_client,
3017 {
3018 NULL,
3019 0,
3020 128
3021 }
3022 },
3023 /* Test 1: event-driven client, synchronous server */
3024 {
3025 {
3026 STD_STREAM_SOCKET,
3027 2048,
3028 16,
3029 2
3030 },
3031 simple_server,
3032 {
3033 NULL,
3034 0,
3035 64
3036 },
3037 event_client,
3038 {
3039 NULL,
3040 WSA_FLAG_OVERLAPPED,
3041 128
3042 }
3043 },
3044 /* Test 2: synchronous client, non-blocking server via select() */
3045 {
3046 {
3047 STD_STREAM_SOCKET,
3048 2048,
3049 16,
3050 2
3051 },
3052 select_server,
3053 {
3054 NULL,
3055 0,
3056 64
3057 },
3058 simple_client,
3059 {
3060 NULL,
3061 0,
3062 128
3063 }
3064 },
3065 /* Test 3: OOB client, OOB server */
3066 {
3067 {
3068 STD_STREAM_SOCKET,
3069 128,
3070 16,
3071 1
3072 },
3073 oob_server,
3074 {
3075 NULL,
3076 0,
3077 128
3078 },
3079 oob_client,
3080 {
3081 NULL,
3082 0,
3083 128
3084 }
3085 },
3086 /* Test 4: synchronous mixed client and server */
3087 {
3088 {
3089 STD_STREAM_SOCKET,
3090 2048,
3091 16,
3092 2
3093 },
3094 simple_server,
3095 {
3096 NULL,
3097 0,
3098 64
3099 },
3100 simple_mixed_client,
3101 {
3102 NULL,
3103 0,
3104 128
3105 }
3106 }
3107 };
3108
3109 static void test_UDP(void)
3110 {
3111 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
3112 possible that this test fails due to dropped packets. */
3113
3114 /* peer 0 receives data from all other peers */
3115 struct sock_info peer[NUM_UDP_PEERS];
3116 char buf[16];
3117 int ss, i, n_recv, n_sent, ret;
3118 struct sockaddr_in addr;
3119 int sock;
3120
3121 memset (buf,0,sizeof(buf));
3122 for ( i = NUM_UDP_PEERS - 1; i >= 0; i-- ) {
3123 ok ( ( peer[i].s = socket ( AF_INET, SOCK_DGRAM, 0 ) ) != INVALID_SOCKET, "UDP: socket failed\n" );
3124
3125 peer[i].addr.sin_family = AF_INET;
3126 peer[i].addr.sin_addr.s_addr = inet_addr ( SERVERIP );
3127
3128 if ( i == 0 ) {
3129 peer[i].addr.sin_port = htons ( SERVERPORT );
3130 } else {
3131 peer[i].addr.sin_port = htons ( 0 );
3132 }
3133
3134 do_bind ( peer[i].s, (struct sockaddr *) &peer[i].addr, sizeof( peer[i].addr ) );
3135
3136 /* test getsockname() to get peer's port */
3137 ss = sizeof ( peer[i].addr );
3138 ok ( getsockname ( peer[i].s, (struct sockaddr *) &peer[i].addr, &ss ) != SOCKET_ERROR, "UDP: could not getsockname()\n" );
3139 ok ( peer[i].addr.sin_port != htons ( 0 ), "UDP: bind() did not associate port\n" );
3140 }
3141
3142 /* test getsockname() */
3143 ok ( peer[0].addr.sin_port == htons ( SERVERPORT ), "UDP: getsockname returned incorrect peer port\n" );
3144
3145 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
3146 /* send client's ip */
3147 memcpy( buf, &peer[i].addr.sin_port, sizeof(peer[i].addr.sin_port) );
3148 n_sent = sendto ( peer[i].s, buf, sizeof(buf), 0, (struct sockaddr*) &peer[0].addr, sizeof(peer[0].addr) );
3149 ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
3150 }
3151
3152 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
3153 n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0,(struct sockaddr *) &peer[0].peer, &ss );
3154 ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
3155 ok ( memcmp ( &peer[0].peer.sin_port, buf, sizeof(peer[0].addr.sin_port) ) == 0, "UDP: port numbers do not match\n" );
3156 }
3157
3158 sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP);
3159 ok( sock != INVALID_SOCKET, "got error %u.\n", WSAGetLastError() );
3160
3161 memset( &addr, 0, sizeof(addr) );
3162 addr.sin_family = AF_INET;
3163 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
3164 addr.sin_port = htons(255);
3165
3166 ret = connect( sock, (struct sockaddr *)&addr, sizeof(addr) );
3167 ok( !ret, "got error %u.\n", WSAGetLastError() );
3168
3169 /* Send to UDP socket succeeds even if the packets are not received and the network is replying with
3170 * "destination port unreachable" ICMP messages. */
3171 for (i = 0; i < 10; ++i)
3172 {
3173 ret = send( sock, buf, sizeof(buf), 0 );
3174 ok( ret == sizeof(buf), "got %d, error %u.\n", ret, WSAGetLastError() );
3175 }
3176
3177 closesocket(sock);
3178 }
3179
3180 static void test_WSASocket(void)
3181 {
3182 SOCKET sock = INVALID_SOCKET;
3183 WSAPROTOCOL_INFOA *pi;
3184 int wsaproviders[] = {IPPROTO_TCP, IPPROTO_IP};
3185 int autoprotocols[] = {IPPROTO_TCP, IPPROTO_UDP};
3186 int items, err, size, socktype, i, j;
3187 DWORD pi_size;
3188
3189 static const struct
3190 {
3191 int family, type, protocol;
3192 DWORD error;
3193 int ret_family, ret_type, ret_protocol;
3194 int ret_family_alt;
3195 }
3196 tests[] =
3197 {
3198 /* 0 */
3199 {0xdead, SOCK_STREAM, IPPROTO_TCP, WSAEAFNOSUPPORT},
3200 {-1, SOCK_STREAM, IPPROTO_TCP, WSAEAFNOSUPPORT},
3201 {AF_INET, 0xdead, IPPROTO_TCP, WSAESOCKTNOSUPPORT},
3202 {AF_INET, -1, IPPROTO_TCP, WSAESOCKTNOSUPPORT},
3203 {AF_INET, SOCK_STREAM, 0xdead, WSAEPROTONOSUPPORT},
3204 {AF_INET, SOCK_STREAM, -1, WSAEPROTONOSUPPORT},
3205 {0xdead, 0xdead, IPPROTO_TCP, WSAESOCKTNOSUPPORT},
3206 {0xdead, SOCK_STREAM, 0xdead, WSAEAFNOSUPPORT},
3207 {AF_INET, 0xdead, 0xdead, WSAESOCKTNOSUPPORT},
3208 {0xdead, SOCK_STREAM, IPPROTO_UDP, WSAEAFNOSUPPORT},
3209
3210 /* 10 */
3211 {AF_INET, SOCK_STREAM, 0, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP},
3212 {AF_INET, SOCK_DGRAM, 0, 0, AF_INET, SOCK_DGRAM, IPPROTO_UDP},
3213 {AF_INET, 0xdead, 0, WSAESOCKTNOSUPPORT},
3214 {AF_INET, 0, IPPROTO_TCP, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP},
3215 {AF_INET, 0, IPPROTO_UDP, 0, AF_INET, SOCK_DGRAM, IPPROTO_UDP},
3216 {AF_INET, 0, 0xdead, WSAEPROTONOSUPPORT},
3217 {AF_INET, 0, 0, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP},
3218 {AF_INET, SOCK_STREAM, IPPROTO_UDP, WSAEPROTONOSUPPORT},
3219 {AF_INET, SOCK_DGRAM, IPPROTO_TCP, WSAEPROTONOSUPPORT},
3220
3221 /* 19 */
3222 {AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP, AF_INET6 /* win11 */},
3223 {AF_UNSPEC, SOCK_STREAM, 0xdead, WSAEPROTONOSUPPORT},
3224 {AF_UNSPEC, 0xdead, IPPROTO_UDP, WSAESOCKTNOSUPPORT},
3225 {AF_UNSPEC, SOCK_STREAM, 0, WSAEINVAL},
3226 {AF_UNSPEC, SOCK_DGRAM, 0, WSAEINVAL},
3227 {AF_UNSPEC, 0xdead, 0, WSAEINVAL},
3228 {AF_UNSPEC, 0, IPPROTO_TCP, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP, AF_INET6 /* win11 */},
3229 {AF_UNSPEC, 0, IPPROTO_UDP, 0, AF_INET, SOCK_DGRAM, IPPROTO_UDP, AF_INET6 /* win11 */},
3230 {AF_UNSPEC, 0, 0xdead, WSAEPROTONOSUPPORT},
3231 {AF_UNSPEC, 0, 0, WSAEINVAL},
3232 };
3233
3234 for (i = 0; i < ARRAY_SIZE(tests); ++i)
3235 {
3236 SetLastError( 0xdeadbeef );
3237 sock = WSASocketA( tests[i].family, tests[i].type, tests[i].protocol, NULL, 0, 0 );
3238 todo_wine_if (i == 7)
3239 ok(WSAGetLastError() == tests[i].error, "Test %u: got wrong error %u\n", i, WSAGetLastError());
3240 if (tests[i].error)
3241 {
3242 ok(sock == INVALID_SOCKET, "Test %u: expected failure\n", i);
3243 }
3244 else
3245 {
3246 WSAPROTOCOL_INFOA info;
3247
3248 ok(sock != INVALID_SOCKET, "Text %u: expected success\n", i);
3249
3250 size = sizeof(info);
3251 err = getsockopt( sock, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *)&info, &size );
3252 ok(!err, "Test %u: getsockopt failed, error %u\n", i, WSAGetLastError());
3253 ok(info.iAddressFamily == tests[i].ret_family ||
3254 (tests[i].ret_family_alt && info.iAddressFamily == tests[i].ret_family_alt),
3255 "Test %u: got wrong family %d\n", i, info.iAddressFamily);
3256 ok(info.iSocketType == tests[i].ret_type, "Test %u: got wrong type %d\n", i, info.iSocketType);
3257 ok(info.iProtocol == tests[i].ret_protocol, "Test %u: got wrong protocol %d\n", i, info.iProtocol);
3258
3259 closesocket( sock );
3260 }
3261 }
3262
3263 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
3264 * to avoid a crash on win98.
3265 */
3266 pi_size = 0;
3267 items = WSAEnumProtocolsA(wsaproviders, NULL, &pi_size);
3268 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
3269 items);
3270 err = WSAGetLastError();
3271 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
3272 err, WSAENOBUFS);
3273
3274 pi = malloc(pi_size);
3275 ok(pi != NULL, "Failed to allocate memory\n");
3276
3277 items = WSAEnumProtocolsA(wsaproviders, pi, &pi_size);
3278 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
3279 WSAGetLastError());
3280
3281 if (items == 0) {
3282 skip("No protocols enumerated.\n");
3283 free(pi);
3284 return;
3285 }
3286
3287 sock = WSASocketA(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
3288 FROM_PROTOCOL_INFO, &pi[0], 0, 0);
3289 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3290 WSAGetLastError());
3291 closesocket(sock);
3292
3293 /* find what parameters are used first: plain parameters or protocol info struct */
3294 pi[0].iProtocol = -1;
3295 pi[0].iSocketType = -1;
3296 pi[0].iAddressFamily = -1;
3297 ok(WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0) == INVALID_SOCKET,
3298 "WSASocketA should have failed\n");
3299 err = WSAGetLastError();
3300 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
3301
3302 pi[0].iProtocol = 0;
3303 pi[0].iSocketType = 0;
3304 pi[0].iAddressFamily = 0;
3305 sock = WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0);
3306 if(sock != INVALID_SOCKET)
3307 {
3308 win_skip("must work only in OS <= 2003\n");
3309 closesocket(sock);
3310 }
3311 else
3312 {
3313 err = WSAGetLastError();
3314 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
3315 }
3316
3317 pi[0].iProtocol = IPPROTO_UDP;
3318 pi[0].iSocketType = SOCK_DGRAM;
3319 pi[0].iAddressFamily = AF_INET;
3320 sock = WSASocketA(0, 0, 0, &pi[0], 0, 0);
3321 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3322 WSAGetLastError());
3323
3324 size = sizeof(socktype);
3325 socktype = 0xdead;
3326 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3327 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
3328 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
3329 SOCK_DGRAM, socktype);
3330
3331 socktype = SOCK_STREAM;
3332 WSASetLastError(0xdeadbeef);
3333 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
3334 ok(err == -1, "expected failure\n");
3335 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
3336
3337 socktype = SOCK_DGRAM;
3338 WSASetLastError(0xdeadbeef);
3339 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
3340 ok(err == -1, "expected failure\n");
3341 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
3342
3343 closesocket(sock);
3344
3345 sock = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, &pi[0], 0, 0);
3346 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3347 WSAGetLastError());
3348
3349 size = sizeof(socktype);
3350 socktype = 0xdead;
3351 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3352 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
3353 ok(socktype == SOCK_STREAM, "Wrong socket type, expected %d received %d\n",
3354 SOCK_STREAM, socktype);
3355
3356 socktype = SOCK_STREAM;
3357 WSASetLastError(0xdeadbeef);
3358 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
3359 ok(err == -1, "expected failure\n");
3360 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
3361
3362 socktype = SOCK_DGRAM;
3363 WSASetLastError(0xdeadbeef);
3364 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
3365 ok(err == -1, "expected failure\n");
3366 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
3367
3368 closesocket(sock);
3369
3370 free(pi);
3371
3372 pi_size = 0;
3373 items = WSAEnumProtocolsA(NULL, NULL, &pi_size);
3374 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
3375 items);
3376 err = WSAGetLastError();
3377 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
3378 err, WSAENOBUFS);
3379
3380 pi = malloc(pi_size);
3381 ok(pi != NULL, "Failed to allocate memory\n");
3382
3383 items = WSAEnumProtocolsA(NULL, pi, &pi_size);
3384 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
3385 WSAGetLastError());
3386
3387 /* when no protocol and socket type are specified the first entry
3388 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
3389 * is returned */
3390 sock = WSASocketA(AF_INET, 0, 0, NULL, 0, 0);
3391 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3392 WSAGetLastError());
3393
3394 size = sizeof(socktype);
3395 socktype = 0xdead;
3396 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3397 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3398 for(i = 0; i < items; i++)
3399 {
3400 if(pi[i].dwProviderFlags & PFL_MATCHES_PROTOCOL_ZERO)
3401 {
3402 ok(socktype == pi[i].iSocketType, "Wrong socket type, expected %d received %d\n",
3403 pi[i].iSocketType, socktype);
3404 break;
3405 }
3406 }
3407 ok(i != items, "Creating a socket without protocol and socket type didn't work\n");
3408 closesocket(sock);
3409
3410 /* when no socket type is specified the first entry from WSAEnumProtocols
3411 * that matches the protocol is returned */
3412 for (i = 0; i < ARRAY_SIZE(autoprotocols); i++)
3413 {
3414 sock = WSASocketA(0, 0, autoprotocols[i], NULL, 0, 0);
3415 ok(sock != INVALID_SOCKET, "Failed to create socket for protocol %d, received %d\n",
3416 autoprotocols[i], WSAGetLastError());
3417
3418 size = sizeof(socktype);
3419 socktype = 0xdead;
3420 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3421 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3422
3423 for (err = 1, j = 0; j < items; j++)
3424 {
3425 if (pi[j].iProtocol == autoprotocols[i])
3426 {
3427 ok(pi[j].iSocketType == socktype, "expected %d, got %d\n", socktype, pi[j].iSocketType);
3428 err = 0;
3429 break;
3430 }
3431 }
3432 ok(!err, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols[i]);
3433
3434 closesocket(sock);
3435 }
3436
3437 free(pi);
3438
3439 SetLastError(0xdeadbeef);
3440 /* starting on vista the socket function returns error during the socket
3441 creation and no longer in the socket operations (sendto, readfrom) */
3442 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
3443 if (sock == INVALID_SOCKET)
3444 {
3445 err = WSAGetLastError();
3446 ok(err == WSAEACCES, "Expected 10013, received %d\n", err);
3447 skip("SOCK_RAW is not supported\n");
3448 }
3449 else
3450 {
3451 WSAPROTOCOL_INFOW info;
3452
3453 size = sizeof(socktype);
3454 socktype = 0xdead;
3455 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3456 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3457 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
3458 SOCK_RAW, socktype);
3459
3460 size = sizeof(info);
3461 err = getsockopt(sock, SOL_SOCKET, SO_PROTOCOL_INFOW, (char *) &info, &size);
3462 ok(!err,"got error %d\n", WSAGetLastError());
3463 /* Protocol name in info.szProtocol is not entirely consistent across Windows versions and
3464 * locales, so not testing it. */
3465 ok(info.iAddressFamily == AF_INET, "got iAddressFamily %d.\n", info.iAddressFamily);
3466 ok(info.iSocketType == SOCK_RAW, "got iSocketType %d.\n", info.iSocketType);
3467 ok(info.iMaxSockAddr == 0x10, "got iMaxSockAddr %d.\n", info.iMaxSockAddr);
3468 ok(info.iMinSockAddr == 0x10, "got iMinSockAddr %d.\n", info.iMinSockAddr);
3469 todo_wine ok(!info.iProtocol, "got iProtocol %d.\n", info.iProtocol);
3470 ok(info.iProtocolMaxOffset == 255, "got iProtocol %d.\n", info.iProtocolMaxOffset);
3471 ok(info.dwProviderFlags == (PFL_MATCHES_PROTOCOL_ZERO | PFL_HIDDEN), "got dwProviderFlags %#lx.\n",
3472 info.dwProviderFlags);
3473 ok(info.dwServiceFlags1 == (XP1_IFS_HANDLES | XP1_SUPPORT_BROADCAST | XP1_SUPPORT_MULTIPOINT
3474 | XP1_MESSAGE_ORIENTED | XP1_CONNECTIONLESS), "got dwServiceFlags1 %#lx.\n",
3475 info.dwServiceFlags1);
3476
3477 closesocket(sock);
3478
3479 sock = WSASocketA(0, 0, IPPROTO_RAW, NULL, 0, 0);
3480 if (sock != INVALID_SOCKET)
3481 {
3482 size = sizeof(socktype);
3483 socktype = 0xdead;
3484 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3485 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3486 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
3487 SOCK_RAW, socktype);
3488 closesocket(sock);
3489
3490 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_TCP, NULL, 0, 0);
3491 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3492 WSAGetLastError());
3493 size = sizeof(socktype);
3494 socktype = 0xdead;
3495 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3496 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3497 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
3498 SOCK_RAW, socktype);
3499 closesocket(sock);
3500 }
3501 else if (WSAGetLastError() == WSAEACCES)
3502 skip("SOCK_RAW is not available\n");
3503 else
3504 ok(0, "Failed to create socket: %d\n", WSAGetLastError());
3505
3506 }
3507
3508 /* IPX socket tests */
3509
3510 SetLastError(0xdeadbeef);
3511 sock = WSASocketA(AF_IPX, SOCK_DGRAM, NSPROTO_IPX, NULL, 0, 0);
3512 if (sock == INVALID_SOCKET)
3513 {
3514 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError());
3515 skip("IPX is not supported\n");
3516 }
3517 else
3518 {
3519 WSAPROTOCOL_INFOA info;
3520 closesocket(sock);
3521
3522 sock = WSASocketA(0, 0, NSPROTO_IPX, NULL, 0, 0);
3523 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3524 WSAGetLastError());
3525
3526 size = sizeof(socktype);
3527 socktype = 0xdead;
3528 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3529 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
3530 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
3531 SOCK_DGRAM, socktype);
3532
3533 /* check socket family, type and protocol */
3534 size = sizeof(WSAPROTOCOL_INFOA);
3535 err = getsockopt(sock, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &info, &size);
3536 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
3537 ok(info.iProtocol == NSPROTO_IPX, "expected protocol %d, received %d\n",
3538 NSPROTO_IPX, info.iProtocol);
3539 ok(info.iAddressFamily == AF_IPX, "expected family %d, received %d\n",
3540 AF_IPX, info.iProtocol);
3541 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
3542 SOCK_DGRAM, info.iSocketType);
3543 closesocket(sock);
3544
3545 /* SOCK_STREAM does not support NSPROTO_IPX */
3546 SetLastError(0xdeadbeef);
3547 ok(WSASocketA(AF_IPX, SOCK_STREAM, NSPROTO_IPX, NULL, 0, 0) == INVALID_SOCKET,
3548 "WSASocketA should have failed\n");
3549 err = WSAGetLastError();
3550 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
3551
3552 /* test extended IPX support - that is adding any number between 0 and 255
3553 * to the IPX protocol value will make it be used as IPX packet type */
3554 for(i = 0;i <= 255;i += 17)
3555 {
3556 SetLastError(0xdeadbeef);
3557 sock = WSASocketA(0, 0, NSPROTO_IPX + i, NULL, 0, 0);
3558 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3559 WSAGetLastError());
3560
3561 size = sizeof(int);
3562 socktype = -1;
3563 err = getsockopt(sock, NSPROTO_IPX, IPX_PTYPE, (char *) &socktype, &size);
3564 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3565 ok(socktype == i, "Wrong IPX packet type, expected %d received %d\n",
3566 i, socktype);
3567
3568 closesocket(sock);
3569 }
3570 }
3571 }
3572
3573 static void test_WSADuplicateSocket(void)
3574 {
3575 SOCKET source, dupsock;
3576 WSAPROTOCOL_INFOA info;
3577 DWORD err;
3578 struct sockaddr_in addr;
3579 int socktype, size, addrsize, ret;
3580 char teststr[] = "TEST", buffer[16];
3581
3582 source = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
3583 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3584
3585 /* test invalid parameters */
3586 SetLastError(0xdeadbeef);
3587 ok(WSADuplicateSocketA(0, 0, NULL), "WSADuplicateSocketA should have failed\n");
3588 err = WSAGetLastError();
3589 ok(err == WSAENOTSOCK, "expected 10038, received %ld\n", err);
3590
3591 SetLastError(0xdeadbeef);
3592 ok(WSADuplicateSocketA(source, 0, NULL),
3593 "WSADuplicateSocketA should have failed\n");
3594 err = WSAGetLastError();
3595 ok(err == WSAEINVAL, "expected 10022, received %ld\n", err);
3596
3597 SetLastError(0xdeadbeef);
3598 ok(WSADuplicateSocketA(source, ~0, &info),
3599 "WSADuplicateSocketA should have failed\n");
3600 err = WSAGetLastError();
3601 ok(err == WSAEINVAL, "expected 10022, received %ld\n", err);
3602
3603 SetLastError(0xdeadbeef);
3604 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info),
3605 "WSADuplicateSocketA should have failed\n");
3606 err = WSAGetLastError();
3607 ok(err == WSAENOTSOCK, "expected 10038, received %ld\n", err);
3608
3609 SetLastError(0xdeadbeef);
3610 ok(WSADuplicateSocketA(source, GetCurrentProcessId(), NULL),
3611 "WSADuplicateSocketA should have failed\n");
3612 err = WSAGetLastError();
3613 ok(err == WSAEFAULT, "expected 10014, received %ld\n", err);
3614
3615 /* test returned structure */
3616 memset(&info, 0, sizeof(info));
3617 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
3618 "WSADuplicateSocketA should have worked\n");
3619
3620 ok(info.iProtocol == IPPROTO_TCP, "expected protocol %d, received %d\n",
3621 IPPROTO_TCP, info.iProtocol);
3622 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
3623 AF_INET, info.iProtocol);
3624 ok(info.iSocketType == SOCK_STREAM, "expected type %d, received %d\n",
3625 SOCK_STREAM, info.iSocketType);
3626
3627 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
3628 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3629
3630 closesocket(dupsock);
3631 closesocket(source);
3632
3633 /* create a socket, bind it, duplicate it then send data on source and
3634 * receive in the duplicated socket */
3635 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
3636 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3637
3638 memset(&info, 0, sizeof(info));
3639 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
3640 "WSADuplicateSocketA should have worked\n");
3641
3642 ok(info.iProtocol == IPPROTO_UDP, "expected protocol %d, received %d\n",
3643 IPPROTO_UDP, info.iProtocol);
3644 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
3645 AF_INET, info.iProtocol);
3646 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
3647 SOCK_DGRAM, info.iSocketType);
3648
3649 memset(&addr, 0, sizeof(addr));
3650 addr.sin_family = AF_INET;
3651 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
3652 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
3653 "bind should have worked\n");
3654
3655 /* read address to find out the port number to be used in sendto */
3656 memset(&addr, 0, sizeof(addr));
3657 addrsize = sizeof(addr);
3658 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
3659 "getsockname should have worked\n");
3660 ok(addr.sin_port, "socket port should be != 0\n");
3661
3662 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
3663 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3664
3665 size = sizeof(int);
3666 ret = getsockopt(dupsock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3667 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
3668 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
3669 SOCK_DGRAM, socktype);
3670
3671 set_blocking(source, TRUE);
3672
3673 /* send data on source socket */
3674 addrsize = sizeof(addr);
3675 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
3676 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
3677
3678 /* receive on duplicated socket */
3679 addrsize = sizeof(addr);
3680 memset(buffer, 0, sizeof(buffer));
3681 size = recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize);
3682 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
3683 buffer[sizeof(teststr) - 1] = 0;
3684 ok(!strcmp(buffer, teststr), "expected '%s', received '%s'\n", teststr, buffer);
3685
3686 closesocket(dupsock);
3687 closesocket(source);
3688
3689 /* show that the source socket need to be bound before the duplicated
3690 * socket is created */
3691 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
3692 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3693
3694 memset(&info, 0, sizeof(info));
3695 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
3696 "WSADuplicateSocketA should have worked\n");
3697
3698 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
3699 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3700
3701 memset(&addr, 0, sizeof(addr));
3702 addr.sin_family = AF_INET;
3703 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
3704 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
3705 "bind should have worked\n");
3706
3707 /* read address to find out the port number to be used in sendto */
3708 memset(&addr, 0, sizeof(addr));
3709 addrsize = sizeof(addr);
3710 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
3711 "getsockname should have worked\n");
3712 ok(addr.sin_port, "socket port should be != 0\n");
3713
3714 set_blocking(source, TRUE);
3715
3716 addrsize = sizeof(addr);
3717 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
3718 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
3719
3720 SetLastError(0xdeadbeef);
3721 addrsize = sizeof(addr);
3722 memset(buffer, 0, sizeof(buffer));
3723 todo_wine {
3724 ok(recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize) == -1,
3725 "recvfrom should have failed\n");
3726 err = WSAGetLastError();
3727 ok(err == WSAEINVAL, "expected 10022, received %ld\n", err);
3728 }
3729
3730 closesocket(dupsock);
3731 closesocket(source);
3732 }
3733
3734 static void test_WSAConnectByName(void)
3735 {
3736 SOCKET s;
3737 SOCKADDR_IN local_addr = {0}, remote_addr = {0},
3738 sock_addr = {0}, peer_addr = {0};
3739 DWORD local_len, remote_len, conn_ctx;
3740 int ret, err, sock_len, peer_len;
3741 WSAOVERLAPPED overlap;
3742 struct addrinfo *first_addrinfo, first_hints;
3743
3744 conn_ctx = TRUE;
3745
3746 /* First call of getaddrinfo fails on w8adm */
3747 first_addrinfo = NULL;
3748 memset(&first_hints, 0, sizeof(struct addrinfo));
3749 first_hints.ai_socktype = SOCK_STREAM;
3750 first_hints.ai_family = AF_INET;
3751 first_hints.ai_protocol = IPPROTO_TCP;
3752 getaddrinfo("winehq.org", "http", &first_hints, &first_addrinfo);
3753 if (first_addrinfo)
3754 freeaddrinfo(first_addrinfo);
3755 SetLastError(0xdeadbeef);
3756
3757 /* Fill all fields */
3758 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3759 local_len = remote_len = sizeof(SOCKADDR_IN);
3760 ret = WSAConnectByNameA(s, "winehq.org", "http", &local_len, (struct sockaddr *)&local_addr,
3761 &remote_len, (struct sockaddr *)&remote_addr, NULL, NULL);
3762 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3763 setsockopt(s, SOL_SOCKET, SO_UPDATE_CONNECT_CONTEXT, (char *)&conn_ctx, sizeof(DWORD));
3764 sock_len = peer_len = sizeof(SOCKADDR_IN);
3765 ret = getsockname(s, (struct sockaddr *)&sock_addr, &sock_len);
3766 ok(!ret, "getsockname should have succeeded, error %u\n", WSAGetLastError());
3767 ret = getpeername(s, (struct sockaddr *)&peer_addr, &peer_len);
3768 ok(!ret, "getpeername should have succeeded, error %u\n", WSAGetLastError());
3769 ok(sock_len == sizeof(SOCKADDR_IN), "got sockname size of %d\n", sock_len);
3770 ok(peer_len == sizeof(SOCKADDR_IN), "got peername size of %d\n", peer_len);
3771 ok(local_len == sizeof(SOCKADDR_IN), "got local size of %lu\n", local_len);
3772 ok(remote_len == sizeof(SOCKADDR_IN), "got remote size of %lu\n", remote_len);
3773 ok(!local_addr.sin_port, "local_addr has non-zero sin_port: %hu.\n", local_addr.sin_port);
3774 ok(!memcmp(&sock_addr.sin_addr, &local_addr.sin_addr, sizeof(struct in_addr)),
3775 "local_addr did not receive data.\n");
3776 ok(!memcmp(&peer_addr, &remote_addr, sizeof(SOCKADDR_IN)), "remote_addr did not receive data.\n");
3777 closesocket(s);
3778
3779 /* Passing NULL length but a pointer to a sockaddr */
3780 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3781 local_len = remote_len = sizeof(SOCKADDR_IN);
3782 memset(&local_addr, 0, sizeof(SOCKADDR_IN));
3783 memset(&remote_addr, 0, sizeof(SOCKADDR_IN));
3784 memset(&sock_addr, 0, sizeof(SOCKADDR_IN));
3785 memset(&peer_addr, 0, sizeof(SOCKADDR_IN));
3786 ret = WSAConnectByNameA(s, "winehq.org", "http", NULL, (struct sockaddr *)&local_addr,
3787 NULL, (struct sockaddr *)&remote_addr, NULL, NULL);
3788 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3789 setsockopt(s, SOL_SOCKET, SO_UPDATE_CONNECT_CONTEXT, (char *)&conn_ctx, sizeof(DWORD));
3790 sock_len = peer_len = sizeof(SOCKADDR_IN);
3791 ret = getsockname(s, (struct sockaddr *)&sock_addr, &sock_len);
3792 ok(!ret, "getsockname should have succeeded, error %u\n", WSAGetLastError());
3793 ret = getpeername(s, (struct sockaddr *)&peer_addr, &peer_len);
3794 ok(!ret, "getpeername should have succeeded, error %u\n", WSAGetLastError());
3795 ok(sock_len == sizeof(SOCKADDR_IN), "got sockname size of %d\n", sock_len);
3796 ok(peer_len == sizeof(SOCKADDR_IN), "got peername size of %d\n", peer_len);
3797 ok(!local_addr.sin_family, "local_addr received data.\n");
3798 ok(!remote_addr.sin_family, "remote_addr received data.\n");
3799 closesocket(s);
3800
3801 /* Passing NULLs for node or service */
3802 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3803 ret = WSAConnectByNameA(s, NULL, "http", NULL, NULL, NULL, NULL, NULL, NULL);
3804 err = WSAGetLastError();
3805 ok(!ret, "WSAConnectByNameA should have failed\n");
3806 ok(err == WSAEINVAL, "expected error %u (WSAEINVAL), got %u\n", WSAEINVAL, err);
3807 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3808 closesocket(s);
3809 ret = WSAConnectByNameA(s, "winehq.org", NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3810 err = WSAGetLastError();
3811 ok(!ret, "WSAConnectByNameA should have failed\n");
3812 ok(err == WSAEINVAL, "expected error %u (WSAEINVAL), got %u\n", WSAEINVAL, err);
3813 closesocket(s);
3814
3815 /* Passing NULL for the addresses and address lengths */
3816 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3817 ret = WSAConnectByNameA(s, "winehq.org", "http", NULL, NULL, NULL, NULL, NULL, NULL);
3818 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3819 closesocket(s);
3820
3821 /* Passing NULL for the addresses and passing correct lengths */
3822 local_len = remote_len = sizeof(SOCKADDR_IN);
3823 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3824 ret = WSAConnectByNameA(s, "winehq.org", "http", &local_len, NULL,
3825 &remote_len, NULL, NULL, NULL);
3826 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3827 ok(local_len == sizeof(SOCKADDR_IN), "local_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN),
3828 local_len);
3829 ok(remote_len == sizeof(SOCKADDR_IN), "remote_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN),
3830 remote_len);
3831 closesocket(s);
3832
3833 /* Passing addresses and passing short lengths */
3834 local_len = remote_len = 3;
3835 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3836 ret = WSAConnectByNameA(s, "winehq.org", "http", &local_len, (struct sockaddr *)&local_addr,
3837 &remote_len, (struct sockaddr *)&remote_addr, NULL, NULL);
3838 err = WSAGetLastError();
3839 ok(!ret, "WSAConnectByNameA should have failed\n");
3840 ok(err == WSAEFAULT, "expected error %u (WSAEFAULT), got %u\n", WSAEFAULT, err);
3841 ok(local_len == 3, "local_len should have been 3, got %ld\n", local_len);
3842 ok(remote_len == 3, "remote_len should have been 3, got %ld\n", remote_len);
3843 closesocket(s);
3844
3845 /* Passing addresses and passing long lengths */
3846 local_len = remote_len = 50;
3847 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3848 ret = WSAConnectByNameA(s, "winehq.org", "http", &local_len, (struct sockaddr *)&local_addr,
3849 &remote_len, (struct sockaddr *)&remote_addr, NULL, NULL);
3850 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3851 ok(local_len == sizeof(SOCKADDR_IN), "local_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN),
3852 local_len);
3853 ok(remote_len == sizeof(SOCKADDR_IN), "remote_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN),
3854 remote_len);
3855 closesocket(s);
3856
3857 /* Unknown service */
3858 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3859 ret = WSAConnectByNameA(s, "winehq.org", "nonexistentservice", NULL, NULL, NULL, NULL, NULL, NULL);
3860 err = WSAGetLastError();
3861 ok(!ret, "WSAConnectByNameA should have failed\n");
3862 ok(err == WSATYPE_NOT_FOUND, "expected error %u (WSATYPE_NOT_FOUND), got %u\n",
3863 WSATYPE_NOT_FOUND, err);
3864 closesocket(s);
3865
3866 /* Connecting with a UDP socket */
3867 s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
3868 ret = WSAConnectByNameA(s, "winehq.org", "https", NULL, NULL, NULL, NULL, NULL, NULL);
3869 err = WSAGetLastError();
3870 ok(!ret, "WSAConnectByNameA should have failed\n");
3871 ok(err == WSAEINVAL || err == WSAEFAULT, "expected error %u (WSAEINVAL) or %u (WSAEFAULT), got %u\n",
3872 WSAEINVAL, WSAEFAULT, err); /* WSAEFAULT win10 >= 1809 */
3873 closesocket(s);
3874
3875 /* Passing non-null as the reserved parameter */
3876 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3877 ret = WSAConnectByNameA(s, "winehq.org", "http", NULL, NULL, NULL, NULL, NULL, &overlap);
3878 err = WSAGetLastError();
3879 ok(!ret, "WSAConnectByNameA should have failed\n");
3880 ok(err == WSAEINVAL, "expected error %u (WSAEINVAL), got %u\n", WSAEINVAL, err);
3881 closesocket(s);
3882 }
3883
3884 static void test_WSAEnumNetworkEvents(void)
3885 {
3886 SOCKET s, s2;
3887 int sock_type[] = {SOCK_STREAM, SOCK_DGRAM, SOCK_STREAM}, i, j, k, l;
3888 struct sockaddr_in address;
3889 HANDLE event;
3890 WSANETWORKEVENTS net_events;
3891
3892 memset(&address, 0, sizeof(address));
3893 address.sin_addr.s_addr = htonl(INADDR_ANY);
3894 address.sin_family = AF_INET;
3895
3896 /* This test follows the steps from bugs 10204 and 24946 */
3897 for (l = 0; l < 2; l++)
3898 {
3899 for (i = 0; i < ARRAY_SIZE(sock_type); i++)
3900 {
3901 if (i == 2)
3902 tcp_socketpair(&s, &s2);
3903 else
3904 {
3905 s = socket(AF_INET, sock_type[i], 0);
3906 ok (s != SOCKET_ERROR, "Test[%d]: failed to create socket\n", i);
3907 ok (!bind(s, (struct sockaddr*) &address, sizeof(address)), "Test[%d]: bind failed\n", i);
3908 }
3909 event = WSACreateEvent();
3910 ok (event != NULL, "Test[%d]: failed to create event\n", i);
3911 for (j = 0; j < 5; j++) /* Repeat sometimes and the result must be the same */
3912 {
3913 /* When the TCP socket is not connected NO events will be returned.
3914 * When connected and no data pending it will get the write event.
3915 * UDP sockets don't have connections so as soon as they are bound
3916 * they can read/write data. Since nobody is sendind us data only
3917 * the write event will be returned and ONLY once.
3918 */
3919 ok (!WSAEventSelect(s, event, FD_READ | FD_WRITE), "Test[%d]: WSAEventSelect failed\n", i);
3920 memset(&net_events, 0xAB, sizeof(net_events));
3921 ok (!WSAEnumNetworkEvents(s, l == 0 ? event : NULL, &net_events),
3922 "Test[%d]: WSAEnumNetworkEvents failed\n", i);
3923 if (i >= 1 && j == 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
3924 {
3925 ok (net_events.lNetworkEvents == FD_WRITE, "Test[%d]: expected 2, got %ld\n",
3926 i, net_events.lNetworkEvents);
3927 }
3928 else
3929 {
3930 ok (net_events.lNetworkEvents == 0, "Test[%d]: expected 0, got %ld\n",
3931 i, net_events.lNetworkEvents);
3932 }
3933 for (k = 0; k < FD_MAX_EVENTS; k++)
3934 {
3935 if (net_events.lNetworkEvents & (1 << k))
3936 {
3937 ok (net_events.iErrorCode[k] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
3938 i, k, net_events.iErrorCode[k]);
3939 }
3940 else
3941 {
3942 /* Bits that are not set in lNetworkEvents MUST not be changed */
3943 ok (net_events.iErrorCode[k] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
3944 i, k, net_events.iErrorCode[k]);
3945 }
3946 }
3947 }
3948 closesocket(s);
3949 WSACloseEvent(event);
3950 if (i == 2) closesocket(s2);
3951 }
3952 }
3953 }
3954
3955 static DWORD WINAPI SelectReadThread(void *param)
3956 {
3957 select_thread_params *par = param;
3958 fd_set readfds;
3959 int ret;
3960 struct sockaddr_in addr;
3961 struct timeval select_timeout;
3962
3963 FD_ZERO(&readfds);
3964 FD_SET(par->s, &readfds);
3965 select_timeout.tv_sec=5;
3966 select_timeout.tv_usec=0;
3967 addr.sin_family = AF_INET;
3968 addr.sin_addr.s_addr = inet_addr(SERVERIP);
3969 addr.sin_port = htons(SERVERPORT);
3970
3971 do_bind(par->s, (struct sockaddr *)&addr, sizeof(addr));
3972 wsa_ok(listen(par->s, SOMAXCONN ), 0 ==, "SelectReadThread (%lx): listen failed: %d\n");
3973
3974 SetEvent(server_ready);
3975 ret = select(par->s+1, &readfds, NULL, NULL, &select_timeout);
3976 par->ReadKilled = (ret == 1);
3977
3978 return 0;
3979 }
3980
3981 static DWORD WINAPI SelectCloseThread(void *param)
3982 {
3983 SOCKET s = *(SOCKET*)param;
3984 Sleep(500);
3985 closesocket(s);
3986 return 0;
3987 }
3988
3989 static void test_errors(void)
3990 {
3991 SOCKET sock;
3992 SOCKADDR_IN SockAddr;
3993 int ret, err;
3994
3995 WSASetLastError(NO_ERROR);
3996 sock = socket(PF_INET, SOCK_STREAM, 0);
3997 ok( (sock != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3998 memset(&SockAddr, 0, sizeof(SockAddr));
3999 SockAddr.sin_family = AF_INET;
4000 SockAddr.sin_port = htons(6924);
4001 SockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
4002
4003 ret = connect(sock, (PSOCKADDR)&SockAddr, sizeof(SockAddr));
4004 ok( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got: %d\n", ret );
4005 if (ret == SOCKET_ERROR)
4006 {
4007 err = WSAGetLastError();
4008 ok( (err == WSAECONNREFUSED), "expected WSAECONNREFUSED, got: %d\n", err );
4009 }
4010
4011 {
4012 TIMEVAL timeval;
4013 fd_set set = {1, {sock}};
4014
4015 timeval.tv_sec = 0;
4016 timeval.tv_usec = 50000;
4017
4018 ret = select(1, NULL, &set, NULL, &timeval);
4019 ok( (ret == 0), "expected 0 (timeout), got: %d\n", ret );
4020 }
4021
4022 ret = closesocket(sock);
4023 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
4024 }
4025
4026 static void test_listen(void)
4027 {
4028 SOCKET fdA, fdB;
4029 int ret, acceptc, olen = sizeof(acceptc);
4030 struct sockaddr_in address;
4031
4032 memset(&address, 0, sizeof(address));
4033 address.sin_addr.s_addr = inet_addr("127.0.0.1");
4034 address.sin_family = AF_INET;
4035 address.sin_port = htons(SERVERPORT);
4036
4037 /* invalid socket tests */
4038 SetLastError(0xdeadbeef);
4039 ok ((listen(0, 0) == SOCKET_ERROR), "listen did not fail\n");
4040 ret = WSAGetLastError();
4041 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
4042
4043 SetLastError(0xdeadbeef);
4044 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR), "listen did not fail\n");
4045 ret = WSAGetLastError();
4046 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
4047
4048 /* udp test */
4049 SetLastError(0xdeadbeef);
4050 fdA = socket(AF_INET, SOCK_DGRAM, 0);
4051 ok ((fdA != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4052
4053 ok ((listen(fdA, 1) == SOCKET_ERROR), "listen did not fail\n");
4054 ret = WSAGetLastError();
4055 ok (ret == WSAEOPNOTSUPP, "expected 10045, received %d\n", ret);
4056
4057 ret = closesocket(fdA);
4058 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
4059
4060 /* tcp tests */
4061 fdA = socket(AF_INET, SOCK_STREAM, 0);
4062 ok ((fdA != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4063
4064 fdB = socket(AF_INET, SOCK_STREAM, 0);
4065 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4066
4067 SetLastError(0xdeadbeef);
4068 ok ((listen(fdA, -2) == SOCKET_ERROR), "listen did not fail\n");
4069 ret = WSAGetLastError();
4070 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
4071
4072 SetLastError(0xdeadbeef);
4073 ok ((listen(fdA, 1) == SOCKET_ERROR), "listen did not fail\n");
4074 ret = WSAGetLastError();
4075 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
4076
4077 SetLastError(0xdeadbeef);
4078 ok ((listen(fdA, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
4079 ret = WSAGetLastError();
4080 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
4081
4082 ok (!bind(fdA, (struct sockaddr*) &address, sizeof(address)), "bind failed\n");
4083
4084 SetLastError(0xdeadbeef);
4085 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
4086 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
4087
4088 acceptc = 0xdead;
4089 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
4090 ok (!ret, "getsockopt failed\n");
4091 ok (acceptc == 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc);
4092
4093 acceptc = 1;
4094 WSASetLastError(0xdeadbeef);
4095 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
4096 ok(ret == -1, "expected failure\n");
4097 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
4098
4099 acceptc = 0;
4100 WSASetLastError(0xdeadbeef);
4101 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
4102 ok(ret == -1, "expected failure\n");
4103 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
4104
4105 ok (!listen(fdA, 0), "listen failed\n");
4106 ok (!listen(fdA, SOMAXCONN), "double listen failed\n");
4107
4108 acceptc = 0xdead;
4109 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
4110 ok (!ret, "getsockopt failed\n");
4111 ok (acceptc == 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc);
4112
4113 acceptc = 1;
4114 WSASetLastError(0xdeadbeef);
4115 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
4116 ok(ret == -1, "expected failure\n");
4117 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
4118
4119 acceptc = 0;
4120 WSASetLastError(0xdeadbeef);
4121 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
4122 ok(ret == -1, "expected failure\n");
4123 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
4124
4125 SetLastError(0xdeadbeef);
4126 ok ((listen(fdB, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
4127 ret = WSAGetLastError();
4128 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
4129
4130 ret = closesocket(fdB);
4131 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
4132
4133 fdB = socket(AF_INET, SOCK_STREAM, 0);
4134 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4135
4136 SetLastError(0xdeadbeef);
4137 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
4138 ret = WSAGetLastError();
4139 ok (ret == WSAEADDRINUSE, "expected 10048, received %d\n", ret);
4140
4141 ret = closesocket(fdA);
4142 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
4143 ret = closesocket(fdB);
4144 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
4145 }
4146
4147 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
4148 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
4149 static void test_select(void)
4150 {
4151 static char tmp_buf[1024];
4152
4153 fd_set readfds, writefds, exceptfds, *alloc_fds;
4154 SOCKET fdListen, fdRead, fdWrite, sockets[200];
4155 int ret, len;
4156 char buffer;
4157 struct timeval select_timeout;
4158 struct sockaddr_in address;
4159 select_thread_params thread_params;
4160 HANDLE thread_handle;
4161 DWORD ticks, id, old_protect;
4162 unsigned int apc_count;
4163 unsigned int maxfd, i;
4164 char *page_pair;
4165
4166 fdRead = socket(AF_INET, SOCK_STREAM, 0);
4167 ok( (fdRead != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4168 fdWrite = socket(AF_INET, SOCK_STREAM, 0);
4169 ok( (fdWrite != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4170
4171 maxfd = fdRead;
4172 if (fdWrite > maxfd)
4173 maxfd = fdWrite;
4174
4175 FD_ZERO_ALL();
4176 FD_SET_ALL(fdRead);
4177 FD_SET_ALL(fdWrite);
4178 select_timeout.tv_sec=0;
4179 select_timeout.tv_usec=0;
4180
4181 ticks = GetTickCount();
4182 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4183 ticks = GetTickCount() - ticks;
4184 ok(ret == 0, "select should not return any socket handles\n");
4185 ok(ticks < 100, "select was blocking for %lu ms\n", ticks);
4186 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
4187 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
4188 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
4189 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
4190
4191 FD_ZERO_ALL();
4192 FD_SET_ALL(fdRead);
4193 FD_SET_ALL(fdWrite);
4194 select_timeout.tv_sec=0;
4195 select_timeout.tv_usec=500;
4196
4197 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4198 ok(ret == 0, "select should not return any socket handles\n");
4199 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
4200 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
4201 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
4202 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
4203
4204 ok ((listen(fdWrite, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
4205 ret = closesocket(fdWrite);
4206 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
4207
4208 thread_params.s = fdRead;
4209 thread_params.ReadKilled = FALSE;
4210 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
4211 thread_handle = CreateThread (NULL, 0, SelectReadThread, &thread_params, 0, &id );
4212 ok ( (thread_handle != NULL), "CreateThread failed unexpectedly: %ld\n", GetLastError());
4213
4214 WaitForSingleObject (server_ready, INFINITE);
4215 Sleep(200);
4216 ret = closesocket(fdRead);
4217 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
4218
4219 WaitForSingleObject (thread_handle, 1000);
4220 ok ( thread_params.ReadKilled, "closesocket did not wake up select\n");
4221 ret = recv(fdRead, &buffer, 1, MSG_PEEK);
4222 ok( (ret == -1), "peek at closed socket expected -1 got %d\n", ret);
4223
4224 /* Test selecting invalid handles */
4225 FD_ZERO_ALL();
4226
4227 SetLastError(0);
4228 ret = select(maxfd+1, 0, 0, 0, &select_timeout);
4229 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4230 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
4231
4232 SetLastError(0);
4233 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4234 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4235 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
4236
4237 FD_SET(INVALID_SOCKET, &readfds);
4238 SetLastError(0);
4239 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4240 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4241 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
4242 ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
4243
4244 FD_ZERO(&readfds);
4245 FD_SET(INVALID_SOCKET, &writefds);
4246 SetLastError(0);
4247 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4248 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4249 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
4250 ok ( !FD_ISSET(fdRead, &writefds), "FD should not be set\n");
4251
4252 FD_ZERO(&writefds);
4253 FD_SET(INVALID_SOCKET, &exceptfds);
4254 SetLastError(0);
4255 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4256 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4257 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
4258 ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
4259
4260 tcp_socketpair(&fdRead, &fdWrite);
4261 maxfd = fdRead;
4262 if(fdWrite > maxfd) maxfd = fdWrite;
4263
4264 FD_ZERO(&readfds);
4265 FD_SET(fdRead, &readfds);
4266 apc_count = 0;
4267 ret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
4268 ok(ret, "QueueUserAPC returned %d\n", ret);
4269 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
4270 ok(!ret, "select returned %d\n", ret);
4271 ok(apc_count == 1, "got apc_count %d.\n", apc_count);
4272
4273 FD_ZERO(&writefds);
4274 FD_SET(fdWrite, &writefds);
4275 apc_count = 0;
4276 ret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
4277 ok(ret, "QueueUserAPC returned %d\n", ret);
4278 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
4279 ok(ret == 1, "select returned %d\n", ret);
4280 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4281 ok(!apc_count, "APC was called\n");
4282 SleepEx(0, TRUE);
4283 ok(apc_count == 1, "got apc_count %d.\n", apc_count);
4284
4285 /* select the same socket twice */
4286 writefds.fd_count = 2;
4287 writefds.fd_array[0] = fdWrite;
4288 writefds.fd_array[1] = fdWrite;
4289 ret = select(0, NULL, &writefds, NULL, &select_timeout);
4290 ok(ret == 1, "select returned %d\n", ret);
4291 ok(writefds.fd_count == 1, "got count %u\n", writefds.fd_count);
4292 ok(writefds.fd_array[0] == fdWrite, "got fd %#Ix\n", writefds.fd_array[0]);
4293 ok(writefds.fd_array[1] == fdWrite, "got fd %#Ix\n", writefds.fd_array[1]);
4294
4295 /* tests for overlapping fd_set pointers */
4296 FD_ZERO(&readfds);
4297 FD_SET(fdWrite, &readfds);
4298 ret = select(fdWrite+1, &readfds, &readfds, NULL, &select_timeout);
4299 ok(ret == 1, "select returned %d\n", ret);
4300 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4301
4302 FD_ZERO(&readfds);
4303 FD_SET(fdWrite, &readfds);
4304 FD_SET(fdRead, &readfds);
4305 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
4306 ok(ret == 2, "select returned %d\n", ret);
4307 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4308 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4309
4310 ok(send(fdWrite, "test", 4, 0) == 4, "failed to send data\n");
4311 FD_ZERO(&readfds);
4312 FD_SET(fdRead, &readfds);
4313 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
4314 ok(ret == 1, "select returned %d\n", ret);
4315 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4316
4317 FD_ZERO(&readfds);
4318 FD_SET(fdWrite, &readfds);
4319 FD_SET(fdRead, &readfds);
4320 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
4321 ok(ret == 2, "select returned %d\n", ret);
4322 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4323 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4324
4325 while(1) {
4326 FD_ZERO(&writefds);
4327 FD_SET(fdWrite, &writefds);
4328 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
4329 if(!ret) break;
4330 ok(send(fdWrite, tmp_buf, sizeof(tmp_buf), 0) > 0, "failed to send data\n");
4331 }
4332 FD_ZERO(&readfds);
4333 FD_SET(fdWrite, &readfds);
4334 FD_SET(fdRead, &readfds);
4335 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
4336 ok(ret == 1, "select returned %d\n", ret);
4337 ok(!FD_ISSET(fdWrite, &readfds), "fdWrite socket is in the set\n");
4338 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4339
4340 ok(send(fdRead, "test", 4, 0) == 4, "failed to send data\n");
4341 Sleep(100);
4342 FD_ZERO(&readfds);
4343 FD_SET(fdWrite, &readfds);
4344 FD_SET(fdRead, &readfds);
4345 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
4346 ok(ret == 2, "select returned %d\n", ret);
4347 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4348 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4349
4350 page_pair = VirtualAlloc(NULL, 0x1000 * 2, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
4351 VirtualProtect(page_pair + 0x1000, 0x1000, PAGE_NOACCESS, &old_protect);
4352 alloc_fds = (fd_set *)((page_pair + 0x1000) - offsetof(fd_set, fd_array[1]));
4353 alloc_fds->fd_count = 1;
4354 alloc_fds->fd_array[0] = fdRead;
4355 ret = select(fdRead+1, alloc_fds, NULL, NULL, &select_timeout);
4356 ok(ret == 1, "select returned %d\n", ret);
4357 VirtualFree(page_pair, 0, MEM_RELEASE);
4358
4359 closesocket(fdRead);
4360 closesocket(fdWrite);
4361
4362 alloc_fds = malloc(offsetof(fd_set, fd_array[ARRAY_SIZE(sockets)]));
4363 alloc_fds->fd_count = ARRAY_SIZE(sockets);
4364 for (i = 0; i < ARRAY_SIZE(sockets); i += 2)
4365 {
4366 tcp_socketpair(&sockets[i], &sockets[i + 1]);
4367 alloc_fds->fd_array[i] = sockets[i];
4368 alloc_fds->fd_array[i + 1] = sockets[i + 1];
4369 }
4370 ret = select(0, NULL, alloc_fds, NULL, &select_timeout);
4371 ok(ret == ARRAY_SIZE(sockets), "got %d\n", ret);
4372 for (i = 0; i < ARRAY_SIZE(sockets); ++i)
4373 {
4374 ok(alloc_fds->fd_array[i] == sockets[i], "got socket %#Ix at index %u\n", alloc_fds->fd_array[i], i);
4375 closesocket(sockets[i]);
4376 }
4377 free(alloc_fds);
4378
4379 /* select() works in 3 distinct states:
4380 * - to check if a connection attempt ended with success or error;
4381 * - to check if a pending connection is waiting for acceptance;
4382 * - to check for data to read, availability for write and OOB data
4383 *
4384 * The tests below ensure that all conditions are tested.
4385 */
4386 memset(&address, 0, sizeof(address));
4387 address.sin_addr.s_addr = inet_addr("127.0.0.1");
4388 address.sin_family = AF_INET;
4389 len = sizeof(address);
4390 fdListen = setup_server_socket(&address, &len);
4391 select_timeout.tv_sec = 1;
4392 select_timeout.tv_usec = 250000;
4393
4394 /* When no events are pending select returns 0 with no error */
4395 FD_ZERO_ALL();
4396 FD_SET_ALL(fdListen);
4397 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4398 ok(ret == 0, "expected 0, got %d\n", ret);
4399
4400 /* When a socket is attempting to connect the listening socket receives the read descriptor */
4401 fdWrite = setup_connector_socket(&address, len, TRUE);
4402 FD_ZERO_ALL();
4403 FD_SET_ALL(fdListen);
4404 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4405 ok(ret == 1, "expected 1, got %d\n", ret);
4406 ok(FD_ISSET(fdListen, &readfds), "fdListen socket is not in the set\n");
4407 len = sizeof(address);
4408 fdRead = accept(fdListen, (struct sockaddr*) &address, &len);
4409 ok(fdRead != INVALID_SOCKET, "expected a valid socket\n");
4410
4411 /* The connector is signaled through the write descriptor */
4412 FD_ZERO_ALL();
4413 FD_SET_ALL(fdListen);
4414 FD_SET_ALL(fdRead);
4415 FD_SET_ALL(fdWrite);
4416 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4417 ok(ret == 2, "expected 2, got %d\n", ret);
4418 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4419 ok(FD_ISSET(fdRead, &writefds), "fdRead socket is not in the set\n");
4420 len = sizeof(id);
4421 id = 0xdeadbeef;
4422 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
4423 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4424 ok(id == 0, "expected 0, got %ld\n", id);
4425 set_blocking(fdRead, FALSE);
4426
4427 /* When data is received the receiver gets the read descriptor */
4428 ret = send(fdWrite, "1234", 4, 0);
4429 ok(ret == 4, "expected 4, got %d\n", ret);
4430 FD_ZERO_ALL();
4431 FD_SET_ALL(fdListen);
4432 FD_SET(fdRead, &readfds);
4433 FD_SET(fdRead, &exceptfds);
4434 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4435 ok(ret == 1, "expected 1, got %d\n", ret);
4436 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4437 ok(!FD_ISSET(fdRead, &exceptfds), "fdRead socket is in the set\n");
4438 FD_ZERO_ALL();
4439 FD_SET_ALL(fdRead);
4440 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4441 ok(ret == 2, "expected 1, got %d\n", ret);
4442 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4443 ok(FD_ISSET(fdRead, &writefds), "fdRead socket is not in the set\n");
4444 ok(!FD_ISSET(fdRead, &exceptfds), "fdRead socket is in the set\n");
4445 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
4446 ok(ret == 4, "expected 4, got %d\n", ret);
4447 ok(!strcmp(tmp_buf, "1234"), "data received differs from sent\n");
4448
4449 /* When OOB data is received the socket is set in the except descriptor */
4450 ret = send(fdWrite, "A", 1, MSG_OOB);
4451 ok(ret == 1, "expected 1, got %d\n", ret);
4452 FD_ZERO_ALL();
4453 FD_SET_ALL(fdListen);
4454 FD_SET(fdRead, &readfds);
4455 FD_SET(fdRead, &exceptfds);
4456 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4457 ok(ret == 1, "expected 1, got %d\n", ret);
4458 ok(FD_ISSET(fdRead, &exceptfds), "fdRead socket is not in the set\n");
4459 tmp_buf[0] = 0xAF;
4460 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
4461 ok(ret == 1, "expected 1, got %d\n", ret);
4462 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
4463
4464 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
4465 ret = 1;
4466 ret = setsockopt(fdRead, SOL_SOCKET, SO_OOBINLINE, (char*) &ret, sizeof(ret));
4467 ok(ret == 0, "expected 0, got %d\n", ret);
4468 ret = send(fdWrite, "A", 1, MSG_OOB);
4469 ok(ret == 1, "expected 1, got %d\n", ret);
4470 FD_ZERO_ALL();
4471 FD_SET_ALL(fdListen);
4472 FD_SET(fdRead, &readfds);
4473 FD_SET(fdRead, &exceptfds);
4474 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4475 ok(ret == 1, "expected 1, got %d\n", ret);
4476 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4477 tmp_buf[0] = 0xAF;
4478 SetLastError(0xdeadbeef);
4479 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
4480 ok(ret == SOCKET_ERROR, "expected SOCKET_ERROR, got %d\n", ret);
4481 ok(GetLastError() == WSAEINVAL, "expected 10022, got %ld\n", GetLastError());
4482 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
4483 ok(ret == 1, "expected 1, got %d\n", ret);
4484 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
4485
4486 /* Linux has some odd behaviour (probably a bug) where receiving OOB,
4487 * setting SO_OOBINLINE, and then calling recv() again will cause the same
4488 * data to be received twice. Avoid that messing with further tests by
4489 * calling recv() here. */
4490 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
4491 todo_wine ok(ret == -1, "got %d\n", ret);
4492 todo_wine ok(GetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4493
4494 /* When the connection is closed the socket is set in the read descriptor */
4495 ret = closesocket(fdRead);
4496 ok(ret == 0, "expected 0, got %d\n", ret);
4497 FD_ZERO_ALL();
4498 FD_SET_ALL(fdListen);
4499 FD_SET(fdWrite, &readfds);
4500 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4501 ok(ret == 1, "expected 1, got %d\n", ret);
4502 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4503 ret = recv(fdWrite, tmp_buf, sizeof(tmp_buf), 0);
4504 ok(ret == 0, "expected 0, got %d\n", ret);
4505 ret = closesocket(fdWrite);
4506 ok(ret == 0, "expected 0, got %d\n", ret);
4507
4508 /* w10pro64 sometimes takes over 2 seconds for an error to be reported. */
4509 if (winetest_interactive)
4510 {
4511 const struct sockaddr_in invalid_addr =
4512 {
4513 .sin_family = AF_INET,
4514 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
4515 .sin_port = 255,
4516 };
4517 SOCKET client2, server2;
4518
4519 fdWrite = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4520 set_blocking(fdWrite, FALSE);
4521
4522 ret = connect(fdWrite, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
4523 ok(ret == -1, "got %d\n", ret);
4524 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4525
4526 FD_ZERO_ALL();
4527 FD_SET(fdWrite, &readfds);
4528 FD_SET(fdWrite, &writefds);
4529 FD_SET(fdWrite, &exceptfds);
4530 select_timeout.tv_sec = 10;
4531 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4532 ok(ret == 1, "expected 1, got %d\n", ret);
4533 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4534 ok(select_timeout.tv_usec == 250000, "select timeout should not have changed\n");
4535
4536 len = sizeof(id);
4537 id = 0xdeadbeef;
4538 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4539 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4540 ok(id == WSAECONNREFUSED, "got error %lu\n", id);
4541
4542 len = sizeof(id);
4543 id = 0xdeadbeef;
4544 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4545 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4546 ok(id == WSAECONNREFUSED, "got error %lu\n", id);
4547
4548 FD_ZERO_ALL();
4549 FD_SET(fdWrite, &readfds);
4550 FD_SET(fdWrite, &writefds);
4551 FD_SET(fdWrite, &exceptfds);
4552 select_timeout.tv_sec = 10;
4553 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4554 ok(ret == 1, "got %d\n", ret);
4555 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4556
4557 /* Calling connect() doesn't reset the socket error, but a successful
4558 * connection does. This is kind of tricky to test, because while
4559 * Windows takes a couple seconds to actually fail the connection,
4560 * Linux will fail the connection almost immediately. */
4561
4562 ret = connect(fdWrite, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
4563 ok(ret == -1, "got %d\n", ret);
4564 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4565
4566 len = sizeof(id);
4567 id = 0xdeadbeef;
4568 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4569 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4570 ok(id == WSAECONNREFUSED, "got error %lu\n", id);
4571
4572 FD_ZERO_ALL();
4573 FD_SET(fdWrite, &readfds);
4574 FD_SET(fdWrite, &writefds);
4575 FD_SET(fdWrite, &exceptfds);
4576 select_timeout.tv_sec = 10;
4577 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4578 ok(ret == 1, "got %d\n", ret);
4579 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4580
4581 len = sizeof(address);
4582 ret = getsockname(fdListen, (struct sockaddr *)&address, &len);
4583 ok(!ret, "got error %u\n", WSAGetLastError());
4584 ret = connect(fdWrite, (const struct sockaddr *)&address, sizeof(address));
4585 ok(ret == -1, "got %d\n", ret);
4586 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4587
4588 FD_ZERO_ALL();
4589 FD_SET(fdWrite, &readfds);
4590 FD_SET(fdWrite, &writefds);
4591 FD_SET(fdWrite, &exceptfds);
4592 select_timeout.tv_sec = 1;
4593 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4594 ok(ret == 1, "expected 1, got %d\n", ret);
4595 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4596
4597 len = sizeof(id);
4598 id = 0xdeadbeef;
4599 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4600 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4601 ok(!id, "got error %lu\n", id);
4602
4603 closesocket(fdWrite);
4604
4605 /* Test listening after a failed connection. */
4606
4607 fdWrite = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4608 set_blocking(fdWrite, FALSE);
4609
4610 address.sin_family = AF_INET;
4611 address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
4612 address.sin_port = 0;
4613 ret = bind(fdWrite, (struct sockaddr *)&address, sizeof(address));
4614 ok(!ret, "got %d\n", ret);
4615
4616 ret = connect(fdWrite, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
4617 ok(ret == -1, "got %d\n", ret);
4618 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4619
4620 FD_ZERO(&exceptfds);
4621 FD_SET(fdWrite, &exceptfds);
4622 select_timeout.tv_sec = 10;
4623 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
4624 ok(ret == 1, "expected 1, got %d\n", ret);
4625
4626 len = sizeof(address);
4627 ret = getsockname(fdWrite, (struct sockaddr *)&address, &len);
4628 ok(!ret, "got error %lu\n", GetLastError());
4629
4630 /* Linux seems to forbid this. We'd need to replace the underlying fd. */
4631 ret = listen(fdWrite, 1);
4632 todo_wine ok(!ret, "got error %lu\n", GetLastError());
4633
4634 if (!ret)
4635 {
4636 client2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4637 ret = connect(client2, (struct sockaddr *)&address, sizeof(address));
4638 ok(!ret, "got error %lu\n", GetLastError());
4639
4640 server2 = accept(fdWrite, NULL, NULL);
4641 ok(server2 != INVALID_SOCKET, "got %d\n", ret);
4642
4643 closesocket(server2);
4644 closesocket(client2);
4645 }
4646
4647 len = sizeof(id);
4648 id = 0xdeadbeef;
4649 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4650 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4651 ok(id == WSAECONNREFUSED, "got error %lu\n", id);
4652
4653 FD_ZERO_ALL();
4654 FD_SET(fdWrite, &readfds);
4655 FD_SET(fdWrite, &writefds);
4656 FD_SET(fdWrite, &exceptfds);
4657 select_timeout.tv_sec = 0;
4658 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4659 ok(ret == 1, "got %d\n", ret);
4660 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4661
4662 closesocket(fdWrite);
4663
4664 /* test polling after a (synchronous) failure */
4665
4666 fdWrite = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4667
4668 ret = connect(fdWrite, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
4669 ok(ret == -1, "got %d\n", ret);
4670 ok(WSAGetLastError() == WSAECONNREFUSED, "got error %u\n", WSAGetLastError());
4671
4672 len = sizeof(id);
4673 id = 0xdeadbeef;
4674 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4675 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4676 todo_wine ok(!id, "got error %lu\n", id);
4677
4678 FD_ZERO_ALL();
4679 FD_SET(fdWrite, &readfds);
4680 FD_SET(fdWrite, &writefds);
4681 FD_SET(fdWrite, &exceptfds);
4682 select_timeout.tv_sec = 0;
4683 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4684 ok(ret == 1, "expected 1, got %d\n", ret);
4685 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4686
4687 len = sizeof(id);
4688 id = 0xdeadbeef;
4689 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4690 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4691 todo_wine ok(!id, "got error %lu\n", id);
4692
4693 closesocket(fdWrite);
4694 }
4695
4696 ret = closesocket(fdListen);
4697 ok(ret == 0, "expected 0, got %d\n", ret);
4698
4699 select_timeout.tv_sec = 1;
4700 select_timeout.tv_usec = 250000;
4701
4702 /* Try select() on a closed socket after connection */
4703 tcp_socketpair(&fdRead, &fdWrite);
4704 closesocket(fdRead);
4705 FD_ZERO_ALL();
4706 FD_SET_ALL(fdWrite);
4707 FD_SET_ALL(fdRead);
4708 SetLastError(0xdeadbeef);
4709 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
4710 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4711 ok(GetLastError() == WSAENOTSOCK, "got %ld\n", GetLastError());
4712 /* descriptor sets are unchanged */
4713 ok(readfds.fd_count == 2, "expected 2, got %d\n", readfds.fd_count);
4714 ok(exceptfds.fd_count == 2, "expected 2, got %d\n", exceptfds.fd_count);
4715 closesocket(fdWrite);
4716
4717 /* Close the socket currently being selected in a thread - bug 38399 */
4718 tcp_socketpair(&fdRead, &fdWrite);
4719 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
4720 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %ld\n", GetLastError());
4721 FD_ZERO_ALL();
4722 FD_SET_ALL(fdWrite);
4723 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
4724 ok(ret == 1, "expected 1, got %d\n", ret);
4725 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4726 WaitForSingleObject (thread_handle, 1000);
4727 closesocket(fdRead);
4728 /* test again with only the except descriptor */
4729 tcp_socketpair(&fdRead, &fdWrite);
4730 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
4731 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %ld\n", GetLastError());
4732 FD_ZERO_ALL();
4733 FD_SET(fdWrite, &exceptfds);
4734 SetLastError(0xdeadbeef);
4735 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
4736 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4737 ok(GetLastError() == WSAENOTSOCK, "got %ld\n", GetLastError());
4738 ok(!FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is in the set\n");
4739 WaitForSingleObject (thread_handle, 1000);
4740 closesocket(fdRead);
4741
4742 /* test UDP behavior of unbound sockets */
4743 select_timeout.tv_sec = 0;
4744 select_timeout.tv_usec = 250000;
4745 fdWrite = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
4746 ok(fdWrite != INVALID_SOCKET, "socket call failed\n");
4747 FD_ZERO_ALL();
4748 FD_SET_ALL(fdWrite);
4749 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4750 ok(ret == 1, "expected 1, got %d\n", ret);
4751 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4752 closesocket(fdWrite);
4753 }
4754 #undef FD_SET_ALL
4755 #undef FD_ZERO_ALL
4756
4757 static DWORD WINAPI AcceptKillThread(void *param)
4758 {
4759 select_thread_params *par = param;
4760 struct sockaddr_in address;
4761 int len = sizeof(address);
4762 SOCKET client_socket;
4763
4764 SetEvent(server_ready);
4765 client_socket = accept(par->s, (struct sockaddr*) &address, &len);
4766 if (client_socket != INVALID_SOCKET)
4767 closesocket(client_socket);
4768 par->ReadKilled = (client_socket == INVALID_SOCKET);
4769 return 0;
4770 }
4771
4772
4773 static int CALLBACK AlwaysDeferConditionFunc(LPWSABUF lpCallerId, LPWSABUF lpCallerData, LPQOS pQos,
4774 LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,
4775 GROUP *g, DWORD_PTR dwCallbackData)
4776 {
4777 return CF_DEFER;
4778 }
4779
4780 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len)
4781 {
4782 int ret, val;
4783 SOCKET server_socket;
4784
4785 server_socket = socket(AF_INET, SOCK_STREAM, 0);
4786 ok(server_socket != INVALID_SOCKET, "failed to bind socket, error %u\n", WSAGetLastError());
4787
4788 val = 1;
4789 ret = setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
4790 ok(!ret, "failed to set SO_REUSEADDR, error %u\n", WSAGetLastError());
4791
4792 ret = bind(server_socket, (struct sockaddr *)addr, *len);
4793 ok(!ret, "failed to bind socket, error %u\n", WSAGetLastError());
4794
4795 ret = getsockname(server_socket, (struct sockaddr *)addr, len);
4796 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
4797
4798 ret = listen(server_socket, 5);
4799 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
4800
4801 return server_socket;
4802 }
4803
4804 static SOCKET setup_connector_socket(const struct sockaddr_in *addr, int len, BOOL nonblock)
4805 {
4806 int ret;
4807 SOCKET connector;
4808
4809 connector = socket(AF_INET, SOCK_STREAM, 0);
4810 ok(connector != INVALID_SOCKET, "failed to create connector socket %d\n", WSAGetLastError());
4811
4812 if (nonblock)
4813 set_blocking(connector, !nonblock);
4814
4815 ret = connect(connector, (const struct sockaddr *)addr, len);
4816 if (!nonblock)
4817 ok(!ret, "connecting to accepting socket failed %d\n", WSAGetLastError());
4818 else if (ret == SOCKET_ERROR)
4819 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4820
4821 return connector;
4822 }
4823
4824 struct connect_apc_func_param
4825 {
4826 HANDLE event;
4827 struct sockaddr_in addr;
4828 SOCKET connector;
4829 unsigned int apc_count;
4830 };
4831
4832 static DWORD WINAPI test_accept_connect_thread(void *param)
4833 {
4834 struct connect_apc_func_param *p = (struct connect_apc_func_param *)param;
4835
4836 WaitForSingleObject(p->event, INFINITE);
4837 p->connector = setup_connector_socket(&p->addr, sizeof(p->addr), FALSE);
4838 ok(p->connector != INVALID_SOCKET, "failed connecting from APC func.\n");
4839 return 0;
4840 }
4841
4842 static void WINAPI connect_apc_func(ULONG_PTR param)
4843 {
4844 struct connect_apc_func_param *p = (struct connect_apc_func_param *)param;
4845
4846 ++p->apc_count;
4847 SetEvent(p->event);
4848 }
4849
4850 static void test_accept(void)
4851 {
4852 int ret;
4853 SOCKET server_socket, accepted = INVALID_SOCKET, connector;
4854 struct connect_apc_func_param apc_param;
4855 struct sockaddr_in address;
4856 SOCKADDR_STORAGE ss, ss_empty;
4857 int socklen;
4858 select_thread_params thread_params;
4859 HANDLE thread_handle = NULL;
4860 DWORD id;
4861
4862 memset(&address, 0, sizeof(address));
4863 address.sin_addr.s_addr = inet_addr("127.0.0.1");
4864 address.sin_family = AF_INET;
4865
4866 socklen = sizeof(address);
4867 server_socket = setup_server_socket(&address, &socklen);
4868
4869 memset(&apc_param, 0, sizeof(apc_param));
4870 apc_param.event = CreateEventW(NULL, FALSE, FALSE, NULL);
4871 apc_param.addr = address;
4872 /* Connecting directly from APC function randomly crashes on Windows for some reason,
4873 * so do it from a thread and only signal it from the APC when we are in accept() call. */
4874 thread_handle = CreateThread(NULL, 0, test_accept_connect_thread, &apc_param, 0, NULL);
4875 ret = QueueUserAPC(connect_apc_func, GetCurrentThread(), (ULONG_PTR)&apc_param);
4876 ok(ret, "QueueUserAPC returned %d\n", ret);
4877 accepted = accept(server_socket, NULL, NULL);
4878 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4879 ok(apc_param.apc_count == 1, "APC was called %u times\n", apc_param.apc_count);
4880 closesocket(accepted);
4881 closesocket(apc_param.connector);
4882 WaitForSingleObject(thread_handle, INFINITE);
4883 CloseHandle(thread_handle);
4884 CloseHandle(apc_param.event);
4885
4886 connector = setup_connector_socket(&address, socklen, FALSE);
4887 if (connector == INVALID_SOCKET) goto done;
4888
4889 accepted = WSAAccept(server_socket, NULL, NULL, AlwaysDeferConditionFunc, 0);
4890 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
4891
4892 accepted = accept(server_socket, NULL, 0);
4893 ok(accepted != INVALID_SOCKET, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
4894
4895 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
4896
4897 thread_params.s = server_socket;
4898 thread_params.ReadKilled = FALSE;
4899 thread_handle = CreateThread(NULL, 0, AcceptKillThread, &thread_params, 0, &id);
4900
4901 WaitForSingleObject(server_ready, INFINITE);
4902 Sleep(200);
4903 ret = closesocket(server_socket);
4904 ok(!ret, "failed to close socket, error %u\n", WSAGetLastError());
4905
4906 WaitForSingleObject(thread_handle, 1000);
4907 ok(thread_params.ReadKilled, "closesocket did not wake up accept\n");
4908
4909 closesocket(accepted);
4910 closesocket(connector);
4911 accepted = connector = INVALID_SOCKET;
4912
4913 socklen = sizeof(address);
4914 server_socket = setup_server_socket(&address, &socklen);
4915
4916 connector = setup_connector_socket(&address, socklen, FALSE);
4917 if (connector == INVALID_SOCKET) goto done;
4918
4919 socklen = 0;
4920 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
4921 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
4922 ok(!socklen, "got %d\n", socklen);
4923 closesocket(connector);
4924 connector = INVALID_SOCKET;
4925
4926 socklen = sizeof(address);
4927 connector = setup_connector_socket(&address, socklen, FALSE);
4928 if (connector == INVALID_SOCKET) goto done;
4929
4930 accepted = WSAAccept(server_socket, NULL, NULL, NULL, 0);
4931 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4932 closesocket(accepted);
4933 closesocket(connector);
4934 accepted = connector = INVALID_SOCKET;
4935
4936 socklen = sizeof(address);
4937 connector = setup_connector_socket(&address, socklen, FALSE);
4938 if (connector == INVALID_SOCKET) goto done;
4939
4940 socklen = sizeof(ss);
4941 memset(&ss, 0, sizeof(ss));
4942 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
4943 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4944 ok(socklen != sizeof(ss), "unexpected length\n");
4945 ok(ss.ss_family, "family not set\n");
4946 closesocket(accepted);
4947 closesocket(connector);
4948 accepted = connector = INVALID_SOCKET;
4949
4950 socklen = sizeof(address);
4951 connector = setup_connector_socket(&address, socklen, FALSE);
4952 if (connector == INVALID_SOCKET) goto done;
4953
4954 socklen = 0;
4955 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4956 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
4957 ok(!socklen, "got %d\n", socklen);
4958 closesocket(connector);
4959 accepted = connector = INVALID_SOCKET;
4960
4961 socklen = sizeof(address);
4962 connector = setup_connector_socket(&address, socklen, FALSE);
4963 if (connector == INVALID_SOCKET) goto done;
4964
4965 accepted = accept(server_socket, NULL, NULL);
4966 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4967 closesocket(accepted);
4968 closesocket(connector);
4969 accepted = connector = INVALID_SOCKET;
4970
4971 socklen = sizeof(address);
4972 connector = setup_connector_socket(&address, socklen, FALSE);
4973 if (connector == INVALID_SOCKET) goto done;
4974
4975 socklen = sizeof(ss);
4976 memset(&ss, 0, sizeof(ss));
4977 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4978 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4979 ok(socklen != sizeof(ss), "unexpected length\n");
4980 ok(ss.ss_family, "family not set\n");
4981 closesocket(accepted);
4982 closesocket(connector);
4983 accepted = connector = INVALID_SOCKET;
4984
4985 socklen = sizeof(address);
4986 connector = setup_connector_socket(&address, socklen, FALSE);
4987 if (connector == INVALID_SOCKET) goto done;
4988
4989 memset(&ss, 0, sizeof(ss));
4990 memset(&ss_empty, 0, sizeof(ss_empty));
4991 accepted = accept(server_socket, (struct sockaddr *)&ss, NULL);
4992 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4993 ok(!memcmp(&ss, &ss_empty, sizeof(ss)), "structure is different\n");
4994
4995 done:
4996 if (accepted != INVALID_SOCKET)
4997 closesocket(accepted);
4998 if (connector != INVALID_SOCKET)
4999 closesocket(connector);
5000 if (thread_handle != NULL)
5001 CloseHandle(thread_handle);
5002 if (server_ready != INVALID_HANDLE_VALUE)
5003 CloseHandle(server_ready);
5004 if (server_socket != INVALID_SOCKET)
5005 closesocket(server_socket);
5006 }
5007
5008 /* Test what socket state is inherited from the listening socket by accept(). */
5009 static void test_accept_inheritance(void)
5010 {
5011 struct sockaddr_in addr, destaddr;
5012 SOCKET listener, server, client;
5013 struct linger linger;
5014 int ret, len, value;
5015 unsigned int i;
5016
5017 static const struct
5018 {
5019 int optname;
5020 int optval;
5021 int value;
5022 }
5023 int_tests[] =
5024 {
5025 {SOL_SOCKET, SO_REUSEADDR, 1},
5026 {SOL_SOCKET, SO_KEEPALIVE, 1},
5027 {SOL_SOCKET, SO_OOBINLINE, 1},
5028 {SOL_SOCKET, SO_SNDBUF, 0x123},
5029 {SOL_SOCKET, SO_RCVBUF, 0x123},
5030 {SOL_SOCKET, SO_SNDTIMEO, 0x123},
5031 {SOL_SOCKET, SO_RCVTIMEO, 0x123},
5032 {IPPROTO_TCP, TCP_NODELAY, 1},
5033 };
5034
5035 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5036 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
5037
5038 for (i = 0; i < ARRAY_SIZE(int_tests); ++i)
5039 {
5040 ret = setsockopt(listener, int_tests[i].optname, int_tests[i].optval,
5041 (char *)&int_tests[i].value, sizeof(int_tests[i].value));
5042 ok(!ret, "test %u: got error %u\n", i, WSAGetLastError());
5043 }
5044
5045 linger.l_onoff = 1;
5046 linger.l_linger = 555;
5047 ret = setsockopt(listener, SOL_SOCKET, SO_LINGER, (char *)&linger, sizeof(linger));
5048 ok(!ret, "got error %u\n", WSAGetLastError());
5049
5050 memset(&addr, 0, sizeof(addr));
5051 addr.sin_family = AF_INET;
5052 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
5053 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
5054 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
5055 len = sizeof(destaddr);
5056 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
5057 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
5058
5059 ret = listen(listener, 1);
5060 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
5061
5062 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5063 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
5064 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
5065 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
5066 server = accept(listener, NULL, NULL);
5067 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
5068
5069 for (i = 0; i < ARRAY_SIZE(int_tests); ++i)
5070 {
5071 value = 0;
5072 len = sizeof(value);
5073 ret = getsockopt(server, int_tests[i].optname, int_tests[i].optval, (char *)&value, &len);
5074 ok(!ret, "test %u: got error %u\n", i, WSAGetLastError());
5075 ok(value == int_tests[i].value, "test %u: got value %#x\n", i, value);
5076 }
5077
5078 len = sizeof(linger);
5079 memset(&linger, 0, sizeof(linger));
5080 ret = getsockopt(server, SOL_SOCKET, SO_LINGER, (char *)&linger, &len);
5081 ok(!ret, "got error %u\n", WSAGetLastError());
5082 ok(linger.l_onoff == 1, "got on/off %u\n", linger.l_onoff);
5083 ok(linger.l_linger == 555, "got linger %u\n", linger.l_onoff);
5084
5085 closesocket(server);
5086 closesocket(client);
5087 closesocket(listener);
5088 }
5089
5090 static void test_extendedSocketOptions(void)
5091 {
5092 WSADATA wsa;
5093 SOCKET sock;
5094 struct sockaddr_in sa;
5095 int sa_len = sizeof(struct sockaddr_in);
5096 int optval, optlen = sizeof(int), ret;
5097 BOOL bool_opt_val;
5098 LINGER linger_val;
5099
5100 ret = WSAStartup(MAKEWORD(2,0), &wsa);
5101 ok(!ret, "failed to startup, error %u\n", WSAGetLastError());
5102
5103 memset(&sa, 0, sa_len);
5104
5105 sa.sin_family = AF_INET;
5106 sa.sin_port = htons(0);
5107 sa.sin_addr.s_addr = htonl(INADDR_ANY);
5108
5109 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
5110 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
5111
5112 ret = bind(sock, (struct sockaddr *) &sa, sa_len);
5113 ok(!ret, "failed to bind socket, error %u\n", WSAGetLastError());
5114
5115 ret = getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
5116
5117 ok(ret == 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret);
5118 ok((optval == 65507) || (optval == 65527),
5119 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval);
5120
5121 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
5122 SetLastError(0xdeadbeef);
5123 optval = 0xdeadbeef;
5124 optlen = sizeof(int);
5125 ret = getsockopt(sock, 0xffffffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
5126 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
5127 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5128 ret, WSAGetLastError(), optval, optval);
5129
5130 /* more invalid values for level */
5131 SetLastError(0xdeadbeef);
5132 optval = 0xdeadbeef;
5133 optlen = sizeof(int);
5134 ret = getsockopt(sock, 0x1234ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
5135 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
5136 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5137 ret, WSAGetLastError(), optval, optval);
5138
5139 SetLastError(0xdeadbeef);
5140 optval = 0xdeadbeef;
5141 optlen = sizeof(int);
5142 ret = getsockopt(sock, 0x8000ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
5143 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
5144 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5145 ret, WSAGetLastError(), optval, optval);
5146
5147 SetLastError(0xdeadbeef);
5148 optval = 0xdeadbeef;
5149 optlen = sizeof(int);
5150 ret = getsockopt(sock, 0x00008000, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
5151 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
5152 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5153 ret, WSAGetLastError(), optval, optval);
5154
5155 SetLastError(0xdeadbeef);
5156 optval = 0xdeadbeef;
5157 optlen = sizeof(int);
5158 ret = getsockopt(sock, 0x00000800, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
5159 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
5160 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5161 ret, WSAGetLastError(), optval, optval);
5162
5163 SetLastError(0xdeadbeef);
5164 optlen = sizeof(LINGER);
5165 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
5166 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAENOPROTOOPT),
5167 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
5168 ret, WSAGetLastError());
5169 closesocket(sock);
5170
5171 sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
5172 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
5173
5174 ret = bind(sock, (struct sockaddr *) &sa, sa_len);
5175 ok(!ret, "failed to bind socket, error %u\n", WSAGetLastError());
5176
5177 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
5178 ok(ret == 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret);
5179
5180 optlen = sizeof(BOOL);
5181 ret = getsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *)&bool_opt_val, &optlen);
5182 ok(ret == 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret);
5183 ok((linger_val.l_onoff && !bool_opt_val) || (!linger_val.l_onoff && bool_opt_val),
5184 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
5185 bool_opt_val, linger_val.l_onoff);
5186
5187 closesocket(sock);
5188 WSACleanup();
5189 }
5190
5191 static void test_getsockname(void)
5192 {
5193 WSADATA wsa;
5194 SOCKET sock;
5195 struct sockaddr_in sa_set, sa_get;
5196 int sa_set_len = sizeof(struct sockaddr_in);
5197 int sa_get_len = sa_set_len;
5198 static const unsigned char null_padding[] = {0,0,0,0,0,0,0,0};
5199 int ret;
5200 struct hostent *h;
5201
5202 ret = WSAStartup(MAKEWORD(2,0), &wsa);
5203 ok(!ret, "failed to startup, error %u\n", WSAGetLastError());
5204
5205 memset(&sa_set, 0, sa_set_len);
5206
5207 sa_set.sin_family = AF_INET;
5208 sa_set.sin_port = htons(0);
5209 sa_set.sin_addr.s_addr = htonl(INADDR_ANY);
5210
5211 sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
5212 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
5213
5214 sa_get = sa_set;
5215 WSASetLastError(0xdeadbeef);
5216 ret = getsockname(sock, (struct sockaddr *)&sa_get, &sa_get_len);
5217 ok(ret == SOCKET_ERROR, "expected failure\n");
5218 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
5219 ok(!memcmp(&sa_get, &sa_set, sizeof(sa_get)), "address should not be changed\n");
5220
5221 ret = bind(sock, (struct sockaddr *) &sa_set, sa_set_len);
5222 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
5223
5224 WSASetLastError(0xdeadbeef);
5225 memset(&sa_get, 0, sizeof(sa_get));
5226 ret = getsockname(sock, (struct sockaddr *) &sa_get, &sa_get_len);
5227 ok(!ret, "got %d\n", ret);
5228 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
5229 ok(sa_get.sin_family == AF_INET, "got family %#x\n", sa_get.sin_family);
5230 ok(sa_get.sin_port != 0, "got zero port\n");
5231 ok(sa_get.sin_addr.s_addr == INADDR_ANY, "got addr %08lx\n", sa_get.sin_addr.s_addr);
5232
5233 ret = memcmp(sa_get.sin_zero, null_padding, 8);
5234 ok(ret == 0, "getsockname did not zero the sockaddr_in structure\n");
5235
5236 sa_get_len = sizeof(sa_get) - 1;
5237 WSASetLastError(0xdeadbeef);
5238 ret = getsockname(sock, (struct sockaddr *)&sa_get, &sa_get_len);
5239 ok(ret == -1, "expected failure\n");
5240 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5241 ok(sa_get_len == sizeof(sa_get) - 1, "got size %d\n", sa_get_len);
5242
5243 closesocket(sock);
5244
5245 h = gethostbyname("");
5246 if (h && h->h_length == 4) /* this test is only meaningful in IPv4 */
5247 {
5248 int i;
5249 for (i = 0; h->h_addr_list[i]; i++)
5250 {
5251 char ipstr[32];
5252 struct in_addr ip;
5253 ip.s_addr = *(ULONG *) h->h_addr_list[i];
5254
5255 sock = socket(AF_INET, SOCK_DGRAM, 0);
5256 ok(sock != INVALID_SOCKET, "socket failed with %ld\n", GetLastError());
5257
5258 memset(&sa_set, 0, sizeof(sa_set));
5259 sa_set.sin_family = AF_INET;
5260 sa_set.sin_addr.s_addr = ip.s_addr;
5261 /* The same address we bind must be the same address we get */
5262 ret = bind(sock, (struct sockaddr*)&sa_set, sizeof(sa_set));
5263 ok(ret == 0, "bind failed with %ld\n", GetLastError());
5264 sa_get_len = sizeof(sa_get);
5265 ret = getsockname(sock, (struct sockaddr*)&sa_get, &sa_get_len);
5266 ok(ret == 0, "getsockname failed with %ld\n", GetLastError());
5267 strcpy(ipstr, inet_ntoa(sa_get.sin_addr));
5268 ok(sa_get.sin_addr.s_addr == sa_set.sin_addr.s_addr,
5269 "address does not match: %s != %s\n", ipstr, inet_ntoa(sa_set.sin_addr));
5270
5271 closesocket(sock);
5272 }
5273 }
5274
5275 WSACleanup();
5276 }
5277
5278 static DWORD apc_error, apc_size;
5279 static OVERLAPPED *apc_overlapped;
5280 static unsigned int apc_count;
5281
5282 static void WINAPI socket_apc(DWORD error, DWORD size, OVERLAPPED *overlapped, DWORD flags)
5283 {
5284 ok(!flags, "got flags %#lx\n", flags);
5285 ++apc_count;
5286 apc_error = error;
5287 apc_size = size;
5288 apc_overlapped = overlapped;
5289 }
5290
5291 #define check_fionread_siocatmark(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, FALSE, FALSE)
5292 #define check_fionread_siocatmark_todo(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, TRUE, TRUE)
5293 #define check_fionread_siocatmark_todo_oob(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, FALSE, TRUE)
5294 static void check_fionread_siocatmark_(int line, SOCKET s, unsigned int normal, unsigned int oob,
5295 BOOL todo_normal, BOOL todo_oob)
5296 {
5297 int ret, value;
5298 DWORD size;
5299
5300 value = 0xdeadbeef;
5301 WSASetLastError(0xdeadbeef);
5302 ret = WSAIoctl(s, FIONREAD, NULL, 0, &value, sizeof(value), &size, NULL, NULL);
5303 ok_(__FILE__, line)(!ret, "expected success\n");
5304 ok_(__FILE__, line)(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5305 todo_wine_if (todo_normal) ok_(__FILE__, line)(value == normal, "FIONBIO returned %u\n", value);
5306
5307 value = 0xdeadbeef;
5308 WSASetLastError(0xdeadbeef);
5309 ret = WSAIoctl(s, SIOCATMARK, NULL, 0, &value, sizeof(value), &size, NULL, NULL);
5310 ok_(__FILE__, line)(!ret, "expected success\n");
5311 ok_(__FILE__, line)(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5312 todo_wine_if (todo_oob) ok_(__FILE__, line)(value == oob, "SIOCATMARK returned %u\n", value);
5313 }
5314
5315 static void test_fionread_siocatmark(void)
5316 {
5317 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
5318 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5319 SOCKET client, server;
5320 char buffer[5];
5321 int ret, value;
5322 ULONG_PTR key;
5323 HANDLE port;
5324 DWORD size;
5325
5326 tcp_socketpair(&client, &server);
5327 set_blocking(client, FALSE);
5328 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
5329
5330 WSASetLastError(0xdeadbeef);
5331 ret = ioctlsocket(client, FIONREAD, (u_long *)1);
5332 ok(ret == -1, "expected failure\n");
5333 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5334
5335 WSASetLastError(0xdeadbeef);
5336 ret = ioctlsocket(client, SIOCATMARK, (u_long *)1);
5337 ok(ret == -1, "expected failure\n");
5338 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5339
5340 WSASetLastError(0xdeadbeef);
5341 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value), NULL, NULL, NULL);
5342 ok(ret == -1, "expected failure\n");
5343 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5344
5345 WSASetLastError(0xdeadbeef);
5346 size = 0xdeadbeef;
5347 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value) - 1, &size, NULL, NULL);
5348 ok(ret == -1, "expected failure\n");
5349 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5350 ok(size == 0xdeadbeef, "got size %lu\n", size);
5351
5352 WSASetLastError(0xdeadbeef);
5353 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value), NULL, NULL, NULL);
5354 ok(ret == -1, "expected failure\n");
5355 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5356
5357 WSASetLastError(0xdeadbeef);
5358 size = 0xdeadbeef;
5359 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value) - 1, &size, NULL, NULL);
5360 ok(ret == -1, "expected failure\n");
5361 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5362 ok(size == 0xdeadbeef, "got size %lu\n", size);
5363
5364 check_fionread_siocatmark(client, 0, TRUE);
5365
5366 port = CreateIoCompletionPort((HANDLE)client, NULL, 123, 0);
5367
5368 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value), NULL, &overlapped, NULL);
5369 ok(ret == -1, "expected failure\n");
5370 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5371
5372 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value), NULL, &overlapped, NULL);
5373 ok(ret == -1, "expected failure\n");
5374 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5375
5376 WSASetLastError(0xdeadbeef);
5377 size = 0xdeadbeef;
5378 value = 0xdeadbeef;
5379 overlapped.Internal = 0xdeadbeef;
5380 overlapped.InternalHigh = 0xdeadbeef;
5381 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value), &size, &overlapped, NULL);
5382 ok(!ret, "expected success\n");
5383 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5384 ok(!value, "got %u\n", value);
5385 ok(size == sizeof(value), "got size %lu\n", size);
5386 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5387 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5388
5389 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5390 ok(ret, "got error %lu\n", GetLastError());
5391 ok(!size, "got size %lu\n", size);
5392 ok(key == 123, "got key %Iu\n", key);
5393 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5394
5395 WSASetLastError(0xdeadbeef);
5396 size = 0xdeadbeef;
5397 value = 0xdeadbeef;
5398 overlapped.Internal = 0xdeadbeef;
5399 overlapped.InternalHigh = 0xdeadbeef;
5400 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value), &size, &overlapped, NULL);
5401 ok(!ret, "expected success\n");
5402 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5403 ok(value == TRUE, "got %u\n", value);
5404 ok(size == sizeof(value), "got size %lu\n", size);
5405 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5406 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5407
5408 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5409 ok(ret, "got error %lu\n", GetLastError());
5410 ok(!size, "got size %lu\n", size);
5411 ok(key == 123, "got key %Iu\n", key);
5412 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5413
5414 ret = send(server, "data", 5, 0);
5415 ok(ret == 5, "got %d\n", ret);
5416
5417 /* wait for the data to be available */
5418 check_poll_mask(client, POLLRDNORM, POLLRDNORM);
5419
5420 check_fionread_siocatmark(client, 5, TRUE);
5421
5422 ret = send(server, "a", 1, MSG_OOB);
5423 ok(ret == 1, "got %d\n", ret);
5424
5425 /* wait for the data to be available */
5426 check_poll_mask(client, POLLRDBAND, POLLRDBAND);
5427
5428 check_fionread_siocatmark_todo_oob(client, 5, FALSE);
5429
5430 ret = send(server, "a", 1, MSG_OOB);
5431 ok(ret == 1, "got %d\n", ret);
5432
5433 check_fionread_siocatmark_todo(client, 5, FALSE);
5434
5435 ret = recv(client, buffer, 3, 0);
5436 ok(ret == 3, "got %d\n", ret);
5437
5438 check_fionread_siocatmark_todo(client, 2, FALSE);
5439
5440 ret = recv(client, buffer, 1, MSG_OOB);
5441 ok(ret == 1, "got %d\n", ret);
5442
5443 /* wait for the data to be available */
5444 check_poll_mask_todo(client, POLLRDBAND, POLLRDBAND);
5445
5446 check_fionread_siocatmark_todo(client, 2, FALSE);
5447
5448 ret = recv(client, buffer, 5, 0);
5449 todo_wine ok(ret == 2, "got %d\n", ret);
5450
5451 check_fionread_siocatmark(client, 0, FALSE);
5452
5453 ret = recv(client, buffer, 1, MSG_OOB);
5454 todo_wine ok(ret == 1, "got %d\n", ret);
5455
5456 check_fionread_siocatmark_todo_oob(client, 0, TRUE);
5457
5458 ret = send(server, "a", 1, MSG_OOB);
5459 ok(ret == 1, "got %d\n", ret);
5460
5461 /* wait for the data to be available */
5462 check_poll_mask(client, POLLRDBAND, POLLRDBAND);
5463
5464 ret = 1;
5465 ret = setsockopt(client, SOL_SOCKET, SO_OOBINLINE, (char *)&ret, sizeof(ret));
5466 ok(!ret, "got error %u\n", WSAGetLastError());
5467
5468 check_fionread_siocatmark_todo_oob(client, 1, FALSE);
5469
5470 ret = recv(client, buffer, 1, 0);
5471 ok(ret == 1, "got %d\n", ret);
5472
5473 check_fionread_siocatmark(client, 0, TRUE);
5474
5475 ret = send(server, "a", 1, MSG_OOB);
5476 ok(ret == 1, "got %d\n", ret);
5477
5478 /* wait for the data to be available */
5479 check_poll_mask(client, POLLRDNORM, POLLRDNORM);
5480
5481 check_fionread_siocatmark(client, 1, TRUE);
5482
5483 closesocket(client);
5484 closesocket(server);
5485
5486 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5487
5488 check_fionread_siocatmark(server, 0, TRUE);
5489
5490 ret = bind(server, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
5491 ok(!ret, "got error %u\n", WSAGetLastError());
5492
5493 check_fionread_siocatmark(server, 0, TRUE);
5494
5495 closesocket(server);
5496 CloseHandle(overlapped.hEvent);
5497
5498 /* test with APCs */
5499
5500 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5501
5502 ret = WSAIoctl(server, FIONREAD, NULL, 0, &value, sizeof(value), NULL, &overlapped, socket_apc);
5503 ok(ret == -1, "expected failure\n");
5504 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5505
5506 ret = WSAIoctl(server, SIOCATMARK, NULL, 0, &value, sizeof(value), NULL, &overlapped, socket_apc);
5507 ok(ret == -1, "expected failure\n");
5508 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5509
5510 apc_count = 0;
5511 size = 0xdeadbeef;
5512 ret = WSAIoctl(server, FIONREAD, NULL, 0, &value, sizeof(value), &size, &overlapped, socket_apc);
5513 ok(!ret, "expected success\n");
5514 ok(size == sizeof(value), "got size %lu\n", size);
5515
5516 ret = SleepEx(0, TRUE);
5517 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5518 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5519 ok(!apc_error, "got APC error %lu\n", apc_error);
5520 ok(!apc_size, "got APC size %lu\n", apc_size);
5521 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5522
5523 apc_count = 0;
5524 size = 0xdeadbeef;
5525 ret = WSAIoctl(server, SIOCATMARK, NULL, 0, &value, sizeof(value), &size, &overlapped, socket_apc);
5526 ok(!ret, "expected success\n");
5527 ok(size == sizeof(value), "got size %lu\n", size);
5528
5529 ret = SleepEx(0, TRUE);
5530 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5531 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5532 ok(!apc_error, "got APC error %lu\n", apc_error);
5533 ok(!apc_size, "got APC size %lu\n", apc_size);
5534 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5535
5536 closesocket(server);
5537 }
5538
5539 static void test_fionbio(void)
5540 {
5541 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5542 u_long one = 1, zero = 0;
5543 HANDLE port, event;
5544 ULONG_PTR key;
5545 void *output;
5546 DWORD size;
5547 SOCKET s;
5548 int ret;
5549
5550 event = CreateEventW(NULL, TRUE, FALSE, NULL);
5551 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5552 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
5553
5554 WSASetLastError(0xdeadbeef);
5555 ret = ioctlsocket(s, FIONBIO, (u_long *)1);
5556 ok(ret == -1, "expected failure\n");
5557 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5558
5559 WSASetLastError(0xdeadbeef);
5560 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, NULL, NULL, NULL);
5561 ok(ret == -1, "expected failure\n");
5562 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5563
5564 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one) - 1, NULL, 0, &size, &overlapped, NULL);
5565 ok(ret == -1, "expected failure\n");
5566 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5567
5568 size = 0xdeadbeef;
5569 WSASetLastError(0xdeadbeef);
5570 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, NULL, NULL);
5571 ok(!ret, "expected success\n");
5572 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5573 ok(!size, "got size %lu\n", size);
5574
5575 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one) + 1, NULL, 0, &size, NULL, NULL);
5576 ok(!ret, "got error %u\n", WSAGetLastError());
5577
5578 output = VirtualAlloc(NULL, 4, MEM_RESERVE | MEM_COMMIT, PAGE_NOACCESS);
5579 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one) + 1, output, 4, &size, NULL, NULL);
5580 ok(!ret, "got error %u\n", WSAGetLastError());
5581 VirtualFree(output, 0, MEM_FREE);
5582
5583 overlapped.Internal = 0xdeadbeef;
5584 overlapped.InternalHigh = 0xdeadbeef;
5585 size = 0xdeadbeef;
5586 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, &overlapped, NULL);
5587 ok(!ret, "expected success\n");
5588 ok(!size, "got size %lu\n", size);
5589
5590 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5591 ok(ret, "got error %lu\n", GetLastError());
5592 ok(!size, "got size %lu\n", size);
5593 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5594 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5595 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5596
5597 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, NULL, &overlapped, NULL);
5598 ok(ret == -1, "expected failure\n");
5599 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5600
5601 ret = WSAEventSelect(s, event, FD_READ);
5602 ok(!ret, "got error %u\n", WSAGetLastError());
5603
5604 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, NULL, NULL);
5605 ok(!ret, "got error %u\n", WSAGetLastError());
5606
5607 size = 0xdeadbeef;
5608 ret = WSAIoctl(s, FIONBIO, &zero, sizeof(zero), NULL, 0, &size, NULL, NULL);
5609 ok(ret == -1, "expected failure\n");
5610 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
5611 todo_wine ok(!size, "got size %lu\n", size);
5612
5613 CloseHandle(port);
5614 closesocket(s);
5615 CloseHandle(event);
5616
5617 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5618
5619 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, NULL, &overlapped, socket_apc);
5620 ok(ret == -1, "expected failure\n");
5621 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5622
5623 apc_count = 0;
5624 size = 0xdeadbeef;
5625 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, &overlapped, socket_apc);
5626 ok(!ret, "expected success\n");
5627 ok(!size, "got size %lu\n", size);
5628
5629 ret = SleepEx(0, TRUE);
5630 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5631 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5632 ok(!apc_error, "got APC error %lu\n", apc_error);
5633 ok(!apc_size, "got APC size %lu\n", apc_size);
5634 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5635
5636 closesocket(s);
5637 }
5638
5639 static void test_keepalive_vals(void)
5640 {
5641 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5642 struct tcp_keepalive kalive;
5643 ULONG_PTR key;
5644 HANDLE port;
5645 SOCKET sock;
5646 DWORD size;
5647 int ret;
5648
5649 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5650 ok(sock != INVALID_SOCKET, "Creating the socket failed: %d\n", WSAGetLastError());
5651 port = CreateIoCompletionPort((HANDLE)sock, NULL, 123, 0);
5652
5653 WSASetLastError(0xdeadbeef);
5654 size = 0xdeadbeef;
5655 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, 0, NULL, 0, &size, NULL, NULL);
5656 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5657 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5658 ok(!size, "got size %lu\n", size);
5659
5660 WSASetLastError(0xdeadbeef);
5661 size = 0xdeadbeef;
5662 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, NULL, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5663 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5664 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5665 ok(!size, "got size %lu\n", size);
5666
5667 WSASetLastError(0xdeadbeef);
5668 size = 0xdeadbeef;
5669 make_keepalive(kalive, 0, 0, 0);
5670 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5671 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5672 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5673 ok(!size, "got size %lu\n", size);
5674
5675 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, NULL, NULL, NULL);
5676 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5677 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5678
5679 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, NULL, &overlapped, NULL);
5680 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5681 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5682
5683 WSASetLastError(0xdeadbeef);
5684 size = 0xdeadbeef;
5685 overlapped.Internal = 0xdeadbeef;
5686 overlapped.InternalHigh = 0xdeadbeef;
5687 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive) - 1, NULL, 0, &size, &overlapped, NULL);
5688 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5689 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5690 ok(size == 0xdeadbeef, "got size %lu\n", size);
5691 todo_wine ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5692 ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
5693
5694 WSASetLastError(0xdeadbeef);
5695 size = 0xdeadbeef;
5696 overlapped.Internal = 0xdeadbeef;
5697 overlapped.InternalHigh = 0xdeadbeef;
5698 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, &overlapped, NULL);
5699 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5700 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5701 todo_wine ok(size == 0xdeadbeef, "got size %lu\n", size);
5702
5703 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5704 ok(ret, "got error %lu\n", GetLastError());
5705 ok(!size, "got size %lu\n", size);
5706 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5707 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5708 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5709
5710 make_keepalive(kalive, 1, 0, 0);
5711 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5712 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5713
5714 make_keepalive(kalive, 1, 1000, 1000);
5715 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5716 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5717
5718 make_keepalive(kalive, 1, 10000, 10000);
5719 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5720 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5721
5722 make_keepalive(kalive, 1, 100, 100);
5723 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5724 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5725
5726 make_keepalive(kalive, 0, 100, 100);
5727 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5728 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5729
5730 CloseHandle(port);
5731 closesocket(sock);
5732
5733 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5734
5735 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, NULL, &overlapped, socket_apc);
5736 ok(ret == -1, "expected failure\n");
5737 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5738
5739 apc_count = 0;
5740 size = 0xdeadbeef;
5741 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, &overlapped, socket_apc);
5742 ok(!ret, "expected success\n");
5743 ok(!size, "got size %lu\n", size);
5744
5745 ret = SleepEx(0, TRUE);
5746 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5747 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5748 ok(!apc_error, "got APC error %lu\n", apc_error);
5749 ok(!apc_size, "got APC size %lu\n", apc_size);
5750 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5751
5752 closesocket(sock);
5753 }
5754
5755 static void test_unsupported_ioctls(void)
5756 {
5757 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5758 unsigned int i;
5759 ULONG_PTR key;
5760 HANDLE port;
5761 DWORD size;
5762 SOCKET s;
5763 int ret;
5764
5765 static const DWORD codes[] = {0xdeadbeef, FIOASYNC, 0x667e, SIO_FLUSH};
5766
5767 for (i = 0; i < ARRAY_SIZE(codes); ++i)
5768 {
5769 winetest_push_context("ioctl %#lx", codes[i]);
5770 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5771 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
5772
5773 WSASetLastError(0xdeadbeef);
5774 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, NULL, &overlapped, NULL);
5775 ok(ret == -1, "expected failure\n");
5776 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5777
5778 WSASetLastError(0xdeadbeef);
5779 size = 0xdeadbeef;
5780 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, &size, NULL, NULL);
5781 ok(ret == -1, "expected failure\n");
5782 ok(WSAGetLastError() == WSAEOPNOTSUPP, "got error %u\n", WSAGetLastError());
5783 ok(!size, "got size %lu\n", size);
5784
5785 WSASetLastError(0xdeadbeef);
5786 size = 0xdeadbeef;
5787 overlapped.Internal = 0xdeadbeef;
5788 overlapped.InternalHigh = 0xdeadbeef;
5789 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, &size, &overlapped, NULL);
5790 ok(ret == -1, "expected failure\n");
5791 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
5792 ok(size == 0xdeadbeef, "got size %lu\n", size);
5793
5794 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5795 ok(!ret, "expected failure\n");
5796 ok(GetLastError() == ERROR_NOT_SUPPORTED, "got error %lu\n", GetLastError());
5797 ok(!size, "got size %lu\n", size);
5798 ok(key == 123, "got key %Iu\n", key);
5799 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5800 ok((NTSTATUS)overlapped.Internal == STATUS_NOT_SUPPORTED,
5801 "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5802 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5803
5804 CloseHandle(port);
5805 closesocket(s);
5806
5807 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5808
5809 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, NULL, &overlapped, socket_apc);
5810 ok(ret == -1, "expected failure\n");
5811 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5812
5813 apc_count = 0;
5814 size = 0xdeadbeef;
5815 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, &size, &overlapped, socket_apc);
5816 ok(ret == -1, "expected failure\n");
5817 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
5818 ok(size == 0xdeadbeef, "got size %lu\n", size);
5819
5820 ret = SleepEx(0, TRUE);
5821 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5822 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5823 ok(apc_error == WSAEOPNOTSUPP, "got APC error %lu\n", apc_error);
5824 ok(!apc_size, "got APC size %lu\n", apc_size);
5825 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5826
5827 closesocket(s);
5828 winetest_pop_context();
5829 }
5830 }
5831
5832 static void test_get_extension_func(void)
5833 {
5834 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5835 GUID acceptex_guid = WSAID_ACCEPTEX;
5836 GUID bogus_guid = {0xdeadbeef};
5837 ULONG_PTR key;
5838 HANDLE port;
5839 DWORD size;
5840 void *func;
5841 SOCKET s;
5842 int ret;
5843
5844 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5845 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
5846
5847 WSASetLastError(0xdeadbeef);
5848 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5849 &func, sizeof(func), NULL, &overlapped, NULL);
5850 ok(ret == -1, "expected failure\n");
5851 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5852
5853 WSASetLastError(0xdeadbeef);
5854 size = 0xdeadbeef;
5855 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5856 &func, sizeof(func), &size, NULL, NULL);
5857 ok(!ret, "expected success\n");
5858 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5859 ok(size == sizeof(func), "got size %lu\n", size);
5860
5861 WSASetLastError(0xdeadbeef);
5862 size = 0xdeadbeef;
5863 overlapped.Internal = 0xdeadbeef;
5864 overlapped.InternalHigh = 0xdeadbeef;
5865 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5866 &func, sizeof(func), &size, &overlapped, NULL);
5867 ok(!ret, "expected success\n");
5868 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5869 ok(size == sizeof(func), "got size %lu\n", size);
5870
5871 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5872 ok(ret, "got error %lu\n", GetLastError());
5873 ok(!size, "got size %lu\n", size);
5874 ok(key == 123, "got key %Iu\n", key);
5875 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5876 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5877 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5878
5879 size = 0xdeadbeef;
5880 overlapped.Internal = 0xdeadbeef;
5881 overlapped.InternalHigh = 0xdeadbeef;
5882 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &bogus_guid, sizeof(GUID),
5883 &func, sizeof(func), &size, &overlapped, NULL);
5884 ok(ret == -1, "expected failure\n");
5885 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
5886 ok(size == 0xdeadbeef, "got size %lu\n", size);
5887 ok(overlapped.Internal == 0xdeadbeef, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5888 ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
5889
5890 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5891 ok(!ret, "expected failure\n");
5892 ok(GetLastError() == WAIT_TIMEOUT, "got error %u\n", WSAGetLastError());
5893
5894 CloseHandle(port);
5895 closesocket(s);
5896
5897 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5898
5899 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5900 &func, sizeof(func), NULL, &overlapped, socket_apc);
5901 ok(ret == -1, "expected failure\n");
5902 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5903
5904 apc_count = 0;
5905 size = 0xdeadbeef;
5906 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5907 &func, sizeof(func), &size, &overlapped, socket_apc);
5908 ok(!ret, "got error %u\n", WSAGetLastError());
5909 ok(size == sizeof(func), "got size %lu\n", size);
5910
5911 ret = SleepEx(0, TRUE);
5912 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5913 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5914 ok(!apc_error, "got APC error %lu\n", apc_error);
5915 ok(!apc_size, "got APC size %lu\n", apc_size);
5916 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5917
5918 closesocket(s);
5919 }
5920
5921 static void test_backlog_query(void)
5922 {
5923 const struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
5924 GUID acceptex_guid = WSAID_ACCEPTEX;
5925 LPFN_ACCEPTEX pAcceptEx;
5926 struct sockaddr_in destaddr;
5927 DWORD size;
5928 SOCKET s, listener;
5929 int len, ret;
5930 ULONG backlog = 0;
5931
5932 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5933 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
5934
5935 ret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(acceptex_guid),
5936 &pAcceptEx, sizeof(pAcceptEx), &size, NULL, NULL);
5937 ok(!ret, "failed to get AcceptEx, error %u\n", WSAGetLastError());
5938
5939 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
5940 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
5941 len = sizeof(destaddr);
5942 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
5943 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
5944 ret = listen(listener, 2);
5945 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
5946
5947 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5948 ret = WSAIoctl(s, SIO_IDEAL_SEND_BACKLOG_QUERY, NULL, 0, &backlog, sizeof(backlog), &size, NULL, NULL);
5949 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTCONN,
5950 "WSAIoctl() failed: %d/%d\n", ret, WSAGetLastError());
5951
5952 ret = connect(s, (struct sockaddr *)&destaddr, sizeof(destaddr));
5953 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
5954 ret = WSAIoctl(s, SIO_IDEAL_SEND_BACKLOG_QUERY, NULL, 0, &backlog, sizeof(backlog), &size, NULL, NULL);
5955 ok(!ret, "WSAIoctl() failed: %d\n", WSAGetLastError());
5956 ok(backlog == 0x10000, "got %08lx\n", backlog);
5957
5958 closesocket(listener);
5959 closesocket(s);
5960
5961 s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
5962
5963 backlog = 0;
5964 ret = WSAIoctl(s, SIO_IDEAL_SEND_BACKLOG_QUERY, NULL, 0, &backlog, sizeof(backlog), &size, NULL, NULL);
5965 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEOPNOTSUPP,
5966 "WSAIoctl() failed: %d/%d\n", ret, WSAGetLastError());
5967 closesocket(s);
5968 }
5969
5970 static void test_base_handle(void)
5971 {
5972 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5973 unsigned int i;
5974 SOCKET s, base;
5975 ULONG_PTR key;
5976 HANDLE port;
5977 DWORD size;
5978 int ret;
5979
5980 static const struct
5981 {
5982 int family, type, protocol;
5983 }
5984 tests[] =
5985 {
5986 {AF_INET, SOCK_STREAM, IPPROTO_TCP},
5987 {AF_INET, SOCK_DGRAM, IPPROTO_UDP},
5988 {AF_INET6, SOCK_STREAM, IPPROTO_TCP},
5989 {AF_INET6, SOCK_DGRAM, IPPROTO_UDP},
5990 };
5991
5992 for (i = 0; i < ARRAY_SIZE(tests); ++i)
5993 {
5994 s = socket(tests[i].family, tests[i].type, tests[i].protocol);
5995 if (s == INVALID_SOCKET) continue;
5996 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
5997
5998 WSASetLastError(0xdeadbeef);
5999 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), NULL, &overlapped, NULL);
6000 ok(ret == -1, "expected failure\n");
6001 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
6002
6003 WSASetLastError(0xdeadbeef);
6004 size = 0xdeadbeef;
6005 base = 0xdeadbeef;
6006 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), &size, NULL, NULL);
6007 ok(!ret, "expected success\n");
6008 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
6009 ok(size == sizeof(base), "got size %lu\n", size);
6010 ok(base == s, "expected %#Ix, got %#Ix\n", s, base);
6011
6012 WSASetLastError(0xdeadbeef);
6013 size = 0xdeadbeef;
6014 base = 0xdeadbeef;
6015 overlapped.Internal = 0xdeadbeef;
6016 overlapped.InternalHigh = 0xdeadbeef;
6017 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), &size, &overlapped, NULL);
6018 ok(ret == -1, "expected failure\n");
6019 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
6020 ok(size == 0xdeadbeef, "got size %lu\n", size);
6021
6022 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
6023 ok(!ret, "expected failure\n");
6024 ok(GetLastError() == ERROR_NOT_SUPPORTED, "got error %lu\n", GetLastError());
6025 ok(!size, "got size %lu\n", size);
6026 ok(key == 123, "got key %Iu\n", key);
6027 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
6028 ok((NTSTATUS)overlapped.Internal == STATUS_NOT_SUPPORTED, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
6029 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
6030 ok(base == 0xdeadbeef, "expected %#Ix, got %#Ix\n", s, base);
6031
6032 CloseHandle(port);
6033 closesocket(s);
6034
6035 s = socket(tests[i].family, tests[i].type, tests[i].protocol);
6036
6037 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), NULL, &overlapped, socket_apc);
6038 ok(ret == -1, "expected failure\n");
6039 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
6040
6041 apc_count = 0;
6042 size = 0xdeadbeef;
6043 base = 0xdeadbeef;
6044 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), &size, &overlapped, socket_apc);
6045 ok(ret == -1, "expected failure\n");
6046 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
6047 ok(size == 0xdeadbeef, "got size %lu\n", size);
6048
6049 ret = SleepEx(0, TRUE);
6050 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
6051 ok(apc_count == 1, "APC was called %u times\n", apc_count);
6052 ok(apc_error == WSAEOPNOTSUPP, "got APC error %lu\n", apc_error);
6053 ok(!apc_size, "got APC size %lu\n", apc_size);
6054 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
6055 ok(base == 0xdeadbeef, "expected %#Ix, got %#Ix\n", s, base);
6056
6057 closesocket(s);
6058 }
6059 }
6060
6061 static void test_circular_queueing(void)
6062 {
6063 SOCKET s;
6064 DWORD size;
6065 int ret;
6066
6067 s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
6068 ret = WSAIoctl(s, SIO_ENABLE_CIRCULAR_QUEUEING, NULL, 0, NULL, 0, &size, NULL, NULL);
6069 ok(!ret, "expected 0, got %d\n", ret);
6070
6071 closesocket(s);
6072 }
6073
6074 static BOOL drain_pause = FALSE;
6075 static DWORD WINAPI drain_socket_thread(LPVOID arg)
6076 {
6077 char buffer[1024];
6078 SOCKET sock = *(SOCKET*)arg;
6079 int ret;
6080
6081 while ((ret = recv(sock, buffer, sizeof(buffer), 0)) != 0)
6082 {
6083 if (ret < 0)
6084 {
6085 if (WSAGetLastError() == WSAEWOULDBLOCK)
6086 {
6087 fd_set readset;
6088 FD_ZERO(&readset);
6089 FD_SET(sock, &readset);
6090 select(sock+1, &readset, NULL, NULL, NULL);
6091 while (drain_pause)
6092 Sleep(100);
6093 }
6094 else
6095 break;
6096 }
6097 }
6098 return 0;
6099 }
6100
6101 static void test_send(void)
6102 {
6103 SOCKET src = INVALID_SOCKET;
6104 SOCKET dst = INVALID_SOCKET;
6105 HANDLE hThread = NULL;
6106 const int buflen = 1024*1024;
6107 char *buffer = NULL;
6108 int ret, i, zero = 0;
6109 WSABUF buf;
6110 OVERLAPPED ov;
6111 BOOL bret;
6112 DWORD id, bytes_sent, dwRet;
6113
6114 memset(&ov, 0, sizeof(ov));
6115
6116 tcp_socketpair(&src, &dst);
6117
6118 set_blocking(dst, FALSE);
6119 /* force disable buffering so we can get a pending overlapped request */
6120 ret = setsockopt(dst, SOL_SOCKET, SO_SNDBUF, (char *) &zero, sizeof(zero));
6121 ok(!ret, "setsockopt SO_SNDBUF failed: %d - %ld\n", ret, GetLastError());
6122
6123 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
6124
6125 buffer = malloc(buflen);
6126
6127 /* fill the buffer with some nonsense */
6128 for (i = 0; i < buflen; ++i)
6129 {
6130 buffer[i] = (char) i;
6131 }
6132
6133 ret = send(src, buffer, buflen, 0);
6134 ok(ret == buflen, "send should have sent %d bytes, but it only sent %d\n", buflen, ret);
6135
6136 buf.buf = buffer;
6137 buf.len = buflen;
6138
6139 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
6140 ok(ov.hEvent != NULL, "could not create event object, errno = %ld\n", GetLastError());
6141 if (!ov.hEvent)
6142 goto end;
6143
6144 bytes_sent = 0;
6145 WSASetLastError(12345);
6146 ret = WSASend(dst, &buf, 1, &bytes_sent, 0, &ov, NULL);
6147 ok(ret == SOCKET_ERROR, "expected failure\n");
6148 ok(WSAGetLastError() == ERROR_IO_PENDING, "wrong error %u\n", WSAGetLastError());
6149
6150 /* don't check for completion yet, we may need to drain the buffer while still sending */
6151 set_blocking(src, FALSE);
6152 for (i = 0; i < buflen; ++i)
6153 {
6154 int j = 0;
6155
6156 ret = recv(src, buffer, 1, 0);
6157 while (ret == SOCKET_ERROR && GetLastError() == WSAEWOULDBLOCK && j < 100)
6158 {
6159 j++;
6160 Sleep(50);
6161 ret = recv(src, buffer, 1, 0);
6162 }
6163
6164 ok(ret == 1, "Failed to receive data %d - %ld (got %d/%d)\n", ret, GetLastError(), i, buflen);
6165 if (ret != 1)
6166 break;
6167
6168 ok(buffer[0] == (char) i, "Received bad data at position %d\n", i);
6169 }
6170
6171 dwRet = WaitForSingleObject(ov.hEvent, 1000);
6172 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %ld - %ld\n", dwRet, GetLastError());
6173 if (dwRet == WAIT_OBJECT_0)
6174 {
6175 bret = GetOverlappedResult((HANDLE)dst, &ov, &bytes_sent, FALSE);
6176 ok(bret && bytes_sent == buflen,
6177 "Got %ld instead of %d (%d - %ld)\n", bytes_sent, buflen, bret, GetLastError());
6178 }
6179
6180 WSASetLastError(12345);
6181 ret = WSASend(INVALID_SOCKET, &buf, 1, NULL, 0, &ov, NULL);
6182 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
6183 "WSASend failed %d - %d\n", ret, WSAGetLastError());
6184
6185 WSASetLastError(12345);
6186 ret = WSASend(dst, &buf, 1, NULL, 0, &ov, NULL);
6187 ok(ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING,
6188 "Failed to start overlapped send %d - %d\n", ret, WSAGetLastError());
6189
6190 end:
6191 if (src != INVALID_SOCKET)
6192 closesocket(src);
6193 if (dst != INVALID_SOCKET)
6194 closesocket(dst);
6195 if (hThread != NULL)
6196 {
6197 dwRet = WaitForSingleObject(hThread, 500);
6198 ok(dwRet == WAIT_OBJECT_0, "failed to wait for thread termination: %ld\n", GetLastError());
6199 CloseHandle(hThread);
6200 }
6201 if (ov.hEvent)
6202 CloseHandle(ov.hEvent);
6203 free(buffer);
6204 }
6205
6206 #define WM_SOCKET (WM_USER+100)
6207
6208 struct event_test_ctx
6209 {
6210 int is_message;
6211 SOCKET socket;
6212 HANDLE event;
6213 HWND window;
6214 };
6215
6216 static void select_events(struct event_test_ctx *ctx, SOCKET socket, LONG events)
6217 {
6218 int ret;
6219
6220 if (ctx->is_message)
6221 ret = WSAAsyncSelect(socket, ctx->window, WM_USER, events);
6222 else
6223 ret = WSAEventSelect(socket, ctx->event, events);
6224 ok(!ret, "failed to select, error %u\n", WSAGetLastError());
6225 ctx->socket = socket;
6226 }
6227
6228 #define check_events(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, FALSE)
6229 #define check_events_todo(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, TRUE)
6230 #define check_events_todo_event(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, FALSE)
6231 #define check_events_todo_msg(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, TRUE)
6232 static void check_events_(int line, struct event_test_ctx *ctx,
6233 LONG flag1, LONG flag2, DWORD timeout, BOOL todo_event, BOOL todo_msg)
6234 {
6235 int ret;
6236
6237 if (ctx->is_message)
6238 {
6239 BOOL any_fail = FALSE;
6240 MSG msg;
6241
6242 if (flag1)
6243 {
6244 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6245 while (!ret && !MsgWaitForMultipleObjects(0, NULL, FALSE, timeout, QS_POSTMESSAGE))
6246 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6247 todo_wine_if (todo_msg && !ret) ok_(__FILE__, line)(ret, "expected a message\n");
6248 if (ret)
6249 {
6250 ok_(__FILE__, line)(msg.wParam == ctx->socket,
6251 "expected wparam %#Ix, got %#Ix\n", ctx->socket, msg.wParam);
6252 todo_wine_if (todo_msg && msg.lParam != flag1)
6253 ok_(__FILE__, line)(msg.lParam == flag1, "got first event %#Ix\n", msg.lParam);
6254 if (msg.lParam != flag1) any_fail = TRUE;
6255 }
6256 else
6257 any_fail = TRUE;
6258 }
6259 if (flag2)
6260 {
6261 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6262 while (!ret && !MsgWaitForMultipleObjects(0, NULL, FALSE, timeout, QS_POSTMESSAGE))
6263 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6264 ok_(__FILE__, line)(ret, "expected a message\n");
6265 ok_(__FILE__, line)(msg.wParam == ctx->socket, "got wparam %#Ix\n", msg.wParam);
6266 todo_wine_if (todo_msg) ok_(__FILE__, line)(msg.lParam == flag2, "got second event %#Ix\n", msg.lParam);
6267 }
6268 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6269 todo_wine_if (todo_msg && ret) ok_(__FILE__, line)(!ret, "got unexpected event %#Ix\n", msg.lParam);
6270 if (ret) any_fail = TRUE;
6271
6272 /* catch tests which succeed */
6273 todo_wine_if (todo_msg) ok_(__FILE__, line)(!any_fail, "event series matches\n");
6274 }
6275 else
6276 {
6277 WSANETWORKEVENTS events;
6278 unsigned int i;
6279
6280 memset(&events, 0xcc, sizeof(events));
6281 ret = WaitForSingleObject(ctx->event, timeout);
6282 if (flag1 | flag2)
6283 todo_wine_if (todo_event && ret) ok_(__FILE__, line)(!ret, "event wait timed out\n");
6284 else
6285 todo_wine_if (todo_event) ok_(__FILE__, line)(ret == WAIT_TIMEOUT, "expected timeout\n");
6286 ret = WSAEnumNetworkEvents(ctx->socket, ctx->event, &events);
6287 ok_(__FILE__, line)(!ret, "failed to get events, error %u\n", WSAGetLastError());
6288 todo_wine_if (todo_event)
6289 ok_(__FILE__, line)(events.lNetworkEvents == LOWORD(flag1 | flag2), "got events %#lx\n", events.lNetworkEvents);
6290 for (i = 0; i < ARRAY_SIZE(events.iErrorCode); ++i)
6291 {
6292 if ((1u << i) == LOWORD(flag1) && (events.lNetworkEvents & LOWORD(flag1)))
6293 todo_wine_if (HIWORD(flag1)) ok_(__FILE__, line)(events.iErrorCode[i] == HIWORD(flag1),
6294 "got error code %d for event %#x\n", events.iErrorCode[i], 1u << i);
6295 if ((1u << i) == LOWORD(flag2) && (events.lNetworkEvents & LOWORD(flag2)))
6296 ok_(__FILE__, line)(events.iErrorCode[i] == HIWORD(flag2),
6297 "got error code %d for event %#x\n", events.iErrorCode[i], 1u << i);
6298 }
6299 }
6300 }
6301
6302 static void test_accept_events(struct event_test_ctx *ctx)
6303 {
6304 const struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
6305 SOCKET listener, server, client, client2;
6306 GUID acceptex_guid = WSAID_ACCEPTEX;
6307 struct sockaddr_in destaddr;
6308 OVERLAPPED overlapped = {0};
6309 LPFN_ACCEPTEX pAcceptEx;
6310 char buffer[32];
6311 int len, ret;
6312 DWORD size;
6313
6314 overlapped.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
6315
6316 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6317 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
6318
6319 ret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(acceptex_guid),
6320 &pAcceptEx, sizeof(pAcceptEx), &size, NULL, NULL);
6321 ok(!ret, "failed to get AcceptEx, error %u\n", WSAGetLastError());
6322
6323 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6324
6325 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
6326 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6327 len = sizeof(destaddr);
6328 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
6329 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6330 ret = listen(listener, 2);
6331 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
6332
6333 check_events(ctx, 0, 0, 0);
6334
6335 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6336 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6337 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6338 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6339
6340 check_events(ctx, FD_ACCEPT, 0, 200);
6341 check_events(ctx, 0, 0, 0);
6342 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6343 if (ctx->is_message)
6344 check_events(ctx, FD_ACCEPT, 0, 200);
6345 check_events(ctx, 0, 0, 0);
6346 select_events(ctx, listener, 0);
6347 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6348 if (ctx->is_message)
6349 check_events(ctx, FD_ACCEPT, 0, 200);
6350 check_events(ctx, 0, 0, 0);
6351
6352 client2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6353 ok(client2 != -1, "failed to create socket, error %u\n", WSAGetLastError());
6354 ret = connect(client2, (struct sockaddr *)&destaddr, sizeof(destaddr));
6355 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6356
6357 if (!ctx->is_message)
6358 check_events_todo(ctx, FD_ACCEPT, 0, 200);
6359 check_events(ctx, 0, 0, 0);
6360
6361 server = accept(listener, NULL, NULL);
6362 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6363 closesocket(server);
6364
6365 check_events(ctx, FD_ACCEPT, 0, 200);
6366 check_events(ctx, 0, 0, 0);
6367
6368 server = accept(listener, NULL, NULL);
6369 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6370 closesocket(server);
6371
6372 check_events(ctx, 0, 0, 0);
6373
6374 closesocket(client2);
6375 closesocket(client);
6376
6377 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6378 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6379 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6380 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6381
6382 check_events(ctx, FD_ACCEPT, 0, 200);
6383
6384 server = accept(listener, NULL, NULL);
6385 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6386 closesocket(server);
6387 closesocket(client);
6388
6389 check_events(ctx, 0, 0, 200);
6390
6391 closesocket(listener);
6392
6393 /* Connect and then select. */
6394
6395 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6396 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
6397 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
6398 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6399 len = sizeof(destaddr);
6400 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
6401 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6402 ret = listen(listener, 2);
6403 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
6404
6405 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6406 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6407 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6408 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6409
6410 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6411
6412 check_events(ctx, FD_ACCEPT, 0, 200);
6413
6414 server = accept(listener, NULL, NULL);
6415 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6416 closesocket(server);
6417 closesocket(client);
6418
6419 /* As above, but select on a subset containing FD_ACCEPT first. */
6420
6421 if (!ctx->is_message)
6422 {
6423 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6424
6425 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6426 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6427 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6428 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6429
6430 ret = WaitForSingleObject(ctx->event, 200);
6431 ok(!ret, "wait timed out\n");
6432
6433 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
6434 ret = WaitForSingleObject(ctx->event, 0);
6435 ok(!ret, "wait timed out\n");
6436
6437 ResetEvent(ctx->event);
6438
6439 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
6440 ret = WaitForSingleObject(ctx->event, 0);
6441 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
6442
6443 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6444 ret = WaitForSingleObject(ctx->event, 0);
6445 ok(!ret, "wait timed out\n");
6446 check_events(ctx, FD_ACCEPT, 0, 0);
6447
6448 server = accept(listener, NULL, NULL);
6449 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6450 closesocket(server);
6451 closesocket(client);
6452 }
6453
6454 /* As above, but select on a subset not containing FD_ACCEPT first. */
6455
6456 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
6457
6458 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6459 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6460 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6461 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6462
6463 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6464 check_events(ctx, FD_ACCEPT, 0, 200);
6465
6466 server = accept(listener, NULL, NULL);
6467 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6468 closesocket(server);
6469 closesocket(client);
6470
6471 /* As above, but call accept() before selecting. */
6472
6473 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
6474
6475 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6476 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6477 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6478 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6479 Sleep(200);
6480 server = accept(listener, NULL, NULL);
6481 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6482
6483 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6484 check_events(ctx, 0, 0, 200);
6485
6486 closesocket(server);
6487 closesocket(client);
6488
6489 closesocket(listener);
6490
6491 /* The socket returned from accept() inherits the same parameters. */
6492
6493 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6494 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
6495 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
6496 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6497 len = sizeof(destaddr);
6498 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
6499 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6500 ret = listen(listener, 2);
6501 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
6502
6503 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6504 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6505 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6506 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6507
6508 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT | FD_WRITE);
6509 check_events(ctx, FD_ACCEPT, 0, 200);
6510
6511 server = accept(listener, NULL, NULL);
6512 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6513 ctx->socket = server;
6514 check_events(ctx, FD_WRITE, 0, 200);
6515 check_events(ctx, 0, 0, 0);
6516
6517 closesocket(server);
6518 closesocket(client);
6519
6520 /* Connect while there is a pending AcceptEx(). */
6521
6522 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6523
6524 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6525 ret = pAcceptEx(listener, server, buffer, 0, 0, sizeof(buffer), NULL, &overlapped);
6526 ok(!ret, "got %d\n", ret);
6527 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
6528
6529 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6530 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6531 ok(!ret, "got error %u\n", WSAGetLastError());
6532
6533 ret = WaitForSingleObject(overlapped.hEvent, 200);
6534 ok(!ret, "got %d\n", ret);
6535 ret = GetOverlappedResult((HANDLE)listener, &overlapped, &size, FALSE);
6536 ok(ret, "got error %lu\n", GetLastError());
6537 ok(!size, "got size %lu\n", size);
6538
6539 check_events(ctx, 0, 0, 0);
6540
6541 closesocket(server);
6542 closesocket(client);
6543
6544 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6545 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6546 ok(!ret, "got error %u\n", WSAGetLastError());
6547
6548 check_events(ctx, FD_ACCEPT, 0, 200);
6549 check_events(ctx, 0, 0, 0);
6550
6551 server = accept(listener, NULL, NULL);
6552 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6553 closesocket(server);
6554 closesocket(client);
6555
6556 closesocket(listener);
6557 CloseHandle(overlapped.hEvent);
6558 }
6559
6560 static void test_connect_events(struct event_test_ctx *ctx)
6561 {
6562 const struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
6563 SOCKET listener, server, client;
6564 struct sockaddr_in destaddr;
6565 int len, ret;
6566
6567 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6568 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
6569 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
6570 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6571 len = sizeof(destaddr);
6572 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
6573 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6574 ret = listen(listener, 2);
6575 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
6576
6577 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6578 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6579
6580 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6581 check_events(ctx, 0, 0, 0);
6582
6583 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6584 ok(!ret || WSAGetLastError() == WSAEWOULDBLOCK, "failed to connect, error %u\n", WSAGetLastError());
6585
6586 check_events(ctx, FD_CONNECT, FD_WRITE, 200);
6587 check_events(ctx, 0, 0, 0);
6588 select_events(ctx, client, 0);
6589 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6590 if (ctx->is_message)
6591 check_events(ctx, FD_WRITE, 0, 200);
6592 check_events(ctx, 0, 0, 0);
6593
6594 server = accept(listener, NULL, NULL);
6595 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6596
6597 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6598 check_events(ctx, FD_WRITE, 0, 200);
6599
6600 closesocket(client);
6601 closesocket(server);
6602
6603 /* Connect and then select. */
6604
6605 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6606 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6607
6608 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6609 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6610
6611 server = accept(listener, NULL, NULL);
6612 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6613
6614 ret = send(client, "data", 5, 0);
6615 ok(ret == 5, "got %d\n", ret);
6616
6617 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6618 if (ctx->is_message)
6619 check_events(ctx, FD_WRITE, 0, 200);
6620 else
6621 check_events(ctx, FD_CONNECT, FD_WRITE, 200);
6622
6623 closesocket(client);
6624 closesocket(server);
6625
6626 /* As above, but select on a subset not containing FD_CONNECT first. */
6627
6628 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6629 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6630
6631 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_OOB | FD_READ | FD_WRITE);
6632
6633 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6634 ok(!ret || WSAGetLastError() == WSAEWOULDBLOCK, "failed to connect, error %u\n", WSAGetLastError());
6635
6636 server = accept(listener, NULL, NULL);
6637 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6638
6639 check_events(ctx, FD_WRITE, 0, 200);
6640
6641 select_events(ctx, client, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6642
6643 if (ctx->is_message)
6644 check_events(ctx, FD_WRITE, 0, 200);
6645 else
6646 check_events(ctx, FD_CONNECT, 0, 200);
6647
6648 closesocket(client);
6649 closesocket(server);
6650
6651 /* Test with UDP sockets. */
6652
6653 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
6654 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
6655
6656 select_events(ctx, client, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6657 if (ctx->is_message)
6658 check_events(ctx, FD_WRITE, 0, 200);
6659 check_events_todo_event(ctx, 0, 0, 0);
6660
6661 ret = bind(server, (const struct sockaddr *)&addr, sizeof(addr));
6662 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6663 len = sizeof(destaddr);
6664 ret = getsockname(server, (struct sockaddr *)&destaddr, &len);
6665 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6666 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
6667 ok(!ret, "got error %lu\n", GetLastError());
6668
6669 if (ctx->is_message)
6670 check_events_todo(ctx, FD_WRITE, 0, 200);
6671 else
6672 check_events_todo(ctx, FD_CONNECT, FD_WRITE, 200);
6673 check_events(ctx, 0, 0, 0);
6674
6675 closesocket(client);
6676 closesocket(server);
6677
6678 closesocket(listener);
6679 }
6680
6681 /* perform a blocking recv() even on a nonblocking socket */
6682 static int sync_recv(SOCKET s, void *buffer, int len, DWORD flags)
6683 {
6684 OVERLAPPED overlapped = {0};
6685 WSABUF wsabuf;
6686 DWORD ret_len;
6687 int ret;
6688
6689 overlapped.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
6690 wsabuf.buf = buffer;
6691 wsabuf.len = len;
6692 ret = WSARecv(s, &wsabuf, 1, &ret_len, &flags, &overlapped, NULL);
6693 if (ret == -1 && WSAGetLastError() == ERROR_IO_PENDING)
6694 {
6695 ret = WaitForSingleObject(overlapped.hEvent, 1000);
6696 ok(!ret, "wait timed out\n");
6697 ret = WSAGetOverlappedResult(s, &overlapped, &ret_len, FALSE, &flags);
6698 ret = (ret ? 0 : -1);
6699 }
6700 CloseHandle(overlapped.hEvent);
6701 if (!ret) return ret_len;
6702 return -1;
6703 }
6704
6705 static void test_write_events(struct event_test_ctx *ctx)
6706 {
6707 static const int buffer_size = 1024 * 1024;
6708 SOCKET server, client;
6709 char *buffer;
6710 int ret;
6711
6712 buffer = malloc(buffer_size);
6713
6714 tcp_socketpair(&client, &server);
6715 set_blocking(client, FALSE);
6716
6717 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6718 check_events(ctx, FD_WRITE, 0, 200);
6719 check_events(ctx, 0, 0, 0);
6720 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6721 if (ctx->is_message)
6722 check_events(ctx, FD_WRITE, 0, 200);
6723 check_events(ctx, 0, 0, 0);
6724 select_events(ctx, server, 0);
6725 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6726 if (ctx->is_message)
6727 check_events(ctx, FD_WRITE, 0, 200);
6728 check_events(ctx, 0, 0, 0);
6729
6730 ret = send(server, "data", 5, 0);
6731 ok(ret == 5, "got %d\n", ret);
6732
6733 check_events(ctx, 0, 0, 0);
6734
6735 ret = sync_recv(client, buffer, buffer_size, 0);
6736 ok(ret == 5, "got %d\n", ret);
6737
6738 check_events(ctx, 0, 0, 0);
6739
6740 if (!broken(1))
6741 {
6742 /* Windows will never send less than buffer_size bytes here, but Linux
6743 * may do a short write. */
6744 while ((ret = send(server, buffer, buffer_size, 0)) > 0);
6745 ok(ret == -1, "got %d\n", ret);
6746 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
6747
6748 while (recv(client, buffer, buffer_size, 0) > 0);
6749 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
6750
6751 /* Broken on Windows versions older than win10v1607 (though sometimes
6752 * works regardless, for unclear reasons. */
6753 check_events(ctx, FD_WRITE, 0, 200);
6754 check_events(ctx, 0, 0, 0);
6755 select_events(ctx, server, 0);
6756 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6757 if (ctx->is_message)
6758 check_events(ctx, FD_WRITE, 0, 200);
6759 check_events(ctx, 0, 0, 0);
6760 }
6761
6762 closesocket(server);
6763 closesocket(client);
6764
6765 /* Select on a subset not containing FD_WRITE first. */
6766
6767 tcp_socketpair(&client, &server);
6768 set_blocking(client, FALSE);
6769
6770 ret = send(client, "data", 5, 0);
6771 ok(ret == 5, "got %d\n", ret);
6772
6773 select_events(ctx, client, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ);
6774 if (!ctx->is_message)
6775 check_events(ctx, FD_CONNECT, 0, 200);
6776 check_events(ctx, 0, 0, 0);
6777
6778 select_events(ctx, client, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6779 check_events(ctx, FD_WRITE, 0, 200);
6780 check_events(ctx, 0, 0, 0);
6781
6782 closesocket(client);
6783 closesocket(server);
6784
6785 /* Despite the documentation, and unlike FD_ACCEPT and FD_RECV, calling
6786 * send() doesn't clear the FD_WRITE bit. */
6787
6788 tcp_socketpair(&client, &server);
6789
6790 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6791
6792 ret = send(server, "data", 5, 0);
6793 ok(ret == 5, "got %d\n", ret);
6794
6795 check_events(ctx, FD_WRITE, 0, 200);
6796
6797 closesocket(server);
6798 closesocket(client);
6799
6800 free(buffer);
6801 }
6802
6803 static void test_read_events(struct event_test_ctx *ctx)
6804 {
6805 OVERLAPPED overlapped = {0};
6806 SOCKET server, client;
6807 DWORD size, flags = 0;
6808 WSAPOLLFD pollfd;
6809 unsigned int i;
6810 char buffer[8];
6811 WSABUF wsabuf;
6812 HANDLE thread;
6813 int ret;
6814
6815 overlapped.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
6816
6817 tcp_socketpair(&client, &server);
6818 set_blocking(client, FALSE);
6819
6820 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6821 check_events(ctx, 0, 0, 0);
6822
6823 ret = send(client, "data", 5, 0);
6824 ok(ret == 5, "got %d\n", ret);
6825
6826 check_events(ctx, FD_READ, 0, 200);
6827 check_events(ctx, 0, 0, 0);
6828 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6829 if (ctx->is_message)
6830 check_events(ctx, FD_READ, 0, 200);
6831 check_events(ctx, 0, 0, 0);
6832 select_events(ctx, server, 0);
6833 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6834 if (ctx->is_message)
6835 check_events(ctx, FD_READ, 0, 200);
6836 check_events(ctx, 0, 0, 0);
6837
6838 ret = send(client, "data", 5, 0);
6839 ok(ret == 5, "got %d\n", ret);
6840
6841 if (!ctx->is_message)
6842 check_events_todo(ctx, FD_READ, 0, 200);
6843 check_events(ctx, 0, 0, 0);
6844
6845 ret = recv(server, buffer, 2, 0);
6846 ok(ret == 2, "got %d\n", ret);
6847
6848 check_events(ctx, FD_READ, 0, 200);
6849 check_events(ctx, 0, 0, 0);
6850
6851 ret = recv(server, buffer, -1, 0);
6852 ok(ret == -1, "got %d\n", ret);
6853 ok(WSAGetLastError() == WSAEFAULT || WSAGetLastError() == WSAENOBUFS /* < Windows 7 */,
6854 "got error %u\n", WSAGetLastError());
6855
6856 if (ctx->is_message)
6857 check_events_todo_msg(ctx, FD_READ, 0, 200);
6858 check_events(ctx, 0, 0, 0);
6859
6860 for (i = 0; i < 8; ++i)
6861 {
6862 ret = sync_recv(server, buffer, 1, 0);
6863 ok(ret == 1, "got %d\n", ret);
6864
6865 if (i < 7)
6866 check_events(ctx, FD_READ, 0, 200);
6867 check_events(ctx, 0, 0, 0);
6868 }
6869
6870 /* Send data while we're not selecting. */
6871
6872 select_events(ctx, server, 0);
6873 ret = send(client, "data", 5, 0);
6874 ok(ret == 5, "got %d\n", ret);
6875 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6876
6877 check_events(ctx, FD_READ, 0, 200);
6878
6879 ret = recv(server, buffer, 5, 0);
6880 ok(ret == 5, "got %d\n", ret);
6881
6882 select_events(ctx, server, 0);
6883 ret = send(client, "data", 5, 0);
6884 ok(ret == 5, "got %d\n", ret);
6885 ret = sync_recv(server, buffer, 5, 0);
6886 ok(ret == 5, "got %d\n", ret);
6887 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ);
6888
6889 check_events(ctx, 0, 0, 200);
6890
6891 /* Send data while we're polling for data but not selecting for FD_READ. */
6892
6893 pollfd.fd = server;
6894 pollfd.events = POLLIN;
6895 thread = CreateThread(NULL, 0, poll_async_thread, &pollfd, 0, NULL);
6896
6897 select_events(ctx, server, 0);
6898 ret = send(client, "data", 5, 0);
6899 ok(ret == 5, "got %d\n", ret);
6900
6901 ret = WaitForSingleObject(thread, 1000);
6902 ok(!ret, "wait timed out\n");
6903 CloseHandle(thread);
6904
6905 /* And check events, to show that WSAEnumNetworkEvents() should not clear
6906 * events we are not currently selecting for. */
6907 check_events(ctx, 0, 0, 0);
6908
6909 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6910 check_events(ctx, FD_READ, FD_WRITE, 200);
6911 check_events(ctx, 0, 0, 0);
6912
6913 ret = sync_recv(server, buffer, 5, 0);
6914 ok(ret == 5, "got %d\n", ret);
6915
6916 /* Send data while there is a pending WSARecv(). */
6917
6918 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6919
6920 wsabuf.buf = buffer;
6921 wsabuf.len = 1;
6922 ret = WSARecv(server, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
6923 ok(ret == -1, "got %d\n", ret);
6924 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
6925
6926 ret = send(client, "a", 1, 0);
6927 ok(ret == 1, "got %d\n", ret);
6928
6929 ret = WaitForSingleObject(overlapped.hEvent, 200);
6930 ok(!ret, "got %d\n", ret);
6931 ret = GetOverlappedResult((HANDLE)server, &overlapped, &size, FALSE);
6932 ok(ret, "got error %lu\n", GetLastError());
6933 ok(size == 1, "got size %lu\n", size);
6934
6935 check_events(ctx, 0, 0, 0);
6936
6937 ret = send(client, "a", 1, 0);
6938 ok(ret == 1, "got %d\n", ret);
6939
6940 check_events(ctx, FD_READ, 0, 200);
6941 check_events(ctx, 0, 0, 0);
6942
6943 closesocket(server);
6944 closesocket(client);
6945 CloseHandle(overlapped.hEvent);
6946 }
6947
6948 static void test_oob_events(struct event_test_ctx *ctx)
6949 {
6950 SOCKET server, client;
6951 char buffer[1];
6952 int ret;
6953
6954 tcp_socketpair(&client, &server);
6955 set_blocking(client, FALSE);
6956
6957 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6958 check_events(ctx, 0, 0, 0);
6959
6960 ret = send(client, "a", 1, MSG_OOB);
6961 ok(ret == 1, "got %d\n", ret);
6962
6963 check_events(ctx, FD_OOB, 0, 200);
6964 check_events(ctx, 0, 0, 0);
6965 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6966 if (ctx->is_message)
6967 check_events(ctx, FD_OOB, 0, 200);
6968 check_events(ctx, 0, 0, 0);
6969 select_events(ctx, server, 0);
6970 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6971 if (ctx->is_message)
6972 check_events(ctx, FD_OOB, 0, 200);
6973 check_events(ctx, 0, 0, 0);
6974
6975 ret = send(client, "b", 1, MSG_OOB);
6976 ok(ret == 1, "got %d\n", ret);
6977
6978 if (!ctx->is_message)
6979 check_events_todo_event(ctx, FD_OOB, 0, 200);
6980 check_events(ctx, 0, 0, 0);
6981
6982 ret = recv(server, buffer, 1, MSG_OOB);
6983 ok(ret == 1, "got %d\n", ret);
6984
6985 check_events_todo(ctx, FD_OOB, 0, 200);
6986 check_events(ctx, 0, 0, 0);
6987
6988 ret = recv(server, buffer, 1, MSG_OOB);
6989 todo_wine ok(ret == 1, "got %d\n", ret);
6990
6991 check_events(ctx, 0, 0, 0);
6992
6993 /* Send data while we're not selecting. */
6994
6995 select_events(ctx, server, 0);
6996 ret = send(client, "a", 1, MSG_OOB);
6997 ok(ret == 1, "got %d\n", ret);
6998 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6999
7000 check_events(ctx, FD_OOB, 0, 200);
7001
7002 ret = recv(server, buffer, 1, MSG_OOB);
7003 ok(ret == 1, "got %d\n", ret);
7004
7005 closesocket(server);
7006 closesocket(client);
7007 }
7008
7009 static void test_close_events(struct event_test_ctx *ctx)
7010 {
7011 SOCKET server, client;
7012 char buffer[5];
7013 int ret;
7014
7015 /* Test closesocket(). */
7016
7017 tcp_socketpair(&client, &server);
7018
7019 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7020
7021 closesocket(client);
7022
7023 check_events(ctx, FD_CLOSE, 0, 1000);
7024 check_events(ctx, 0, 0, 0);
7025 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7026 if (ctx->is_message)
7027 check_events(ctx, FD_CLOSE, 0, 200);
7028 check_events(ctx, 0, 0, 0);
7029 select_events(ctx, server, 0);
7030 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7031 if (ctx->is_message)
7032 check_events(ctx, FD_CLOSE, 0, 200);
7033 check_events(ctx, 0, 0, 0);
7034
7035 ret = recv(server, buffer, 5, 0);
7036 ok(!ret, "got %d\n", ret);
7037
7038 check_events(ctx, 0, 0, 0);
7039
7040 closesocket(server);
7041
7042 /* Test shutdown(remote end, SD_SEND). */
7043
7044 tcp_socketpair(&client, &server);
7045
7046 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7047
7048 shutdown(client, SD_SEND);
7049
7050 check_events(ctx, FD_CLOSE, 0, 1000);
7051 check_events(ctx, 0, 0, 0);
7052
7053 closesocket(client);
7054
7055 check_events(ctx, 0, 0, 0);
7056
7057 closesocket(server);
7058
7059 /* No other shutdown() call generates an event. */
7060
7061 tcp_socketpair(&client, &server);
7062
7063 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7064
7065 shutdown(client, SD_RECEIVE);
7066 shutdown(server, SD_BOTH);
7067
7068 check_events(ctx, 0, 0, 200);
7069
7070 shutdown(client, SD_SEND);
7071
7072 check_events_todo(ctx, FD_CLOSE, 0, 200);
7073 check_events(ctx, 0, 0, 0);
7074
7075 closesocket(server);
7076 closesocket(client);
7077
7078 /* Test sending data before calling closesocket(). */
7079
7080 tcp_socketpair(&client, &server);
7081
7082 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7083
7084 ret = send(client, "data", 5, 0);
7085 ok(ret == 5, "got %d\n", ret);
7086
7087 check_events(ctx, FD_READ, 0, 200);
7088
7089 closesocket(client);
7090
7091 check_events_todo(ctx, FD_CLOSE, 0, 200);
7092
7093 ret = recv(server, buffer, 3, 0);
7094 ok(ret == 3, "got %d\n", ret);
7095
7096 check_events(ctx, FD_READ, 0, 200);
7097
7098 ret = recv(server, buffer, 5, 0);
7099 ok(ret == 2, "got %d\n", ret);
7100
7101 check_events_todo(ctx, 0, 0, !strcmp(winetest_platform, "wine") ? 200 : 0);
7102
7103 closesocket(server);
7104
7105 /* Close and then select. */
7106
7107 tcp_socketpair(&client, &server);
7108 closesocket(client);
7109
7110 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7111 check_events(ctx, FD_CLOSE, 0, 200);
7112
7113 closesocket(server);
7114
7115 /* As above, but select on a subset not containing FD_CLOSE first. */
7116
7117 tcp_socketpair(&client, &server);
7118
7119 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ);
7120
7121 closesocket(client);
7122
7123 check_events(ctx, 0, 0, 200);
7124 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7125 check_events(ctx, FD_CLOSE, 0, 200);
7126
7127 closesocket(server);
7128
7129 /* Trigger RST. */
7130
7131 tcp_socketpair(&client, &server);
7132
7133 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7134
7135 close_with_rst(client);
7136
7137 check_events_todo_msg(ctx, MAKELONG(FD_CLOSE, WSAECONNABORTED), 0, 200);
7138 check_events(ctx, 0, 0, 0);
7139 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7140 if (ctx->is_message)
7141 check_events_todo(ctx, MAKELONG(FD_CLOSE, WSAECONNABORTED), 0, 200);
7142 check_events(ctx, 0, 0, 0);
7143 select_events(ctx, server, 0);
7144 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7145 if (ctx->is_message)
7146 check_events_todo(ctx, MAKELONG(FD_CLOSE, WSAECONNABORTED), 0, 200);
7147 check_events(ctx, 0, 0, 0);
7148
7149 closesocket(server);
7150 }
7151
7152 static void test_events(void)
7153 {
7154 struct event_test_ctx ctx;
7155
7156 ctx.is_message = FALSE;
7157 ctx.event = CreateEventW(NULL, TRUE, FALSE, NULL);
7158
7159 test_accept_events(&ctx);
7160 test_connect_events(&ctx);
7161 test_write_events(&ctx);
7162 test_read_events(&ctx);
7163 test_close_events(&ctx);
7164 test_oob_events(&ctx);
7165
7166 CloseHandle(ctx.event);
7167
7168 ctx.is_message = TRUE;
7169 ctx.window = CreateWindowA("Message", NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, NULL, NULL);
7170
7171 test_accept_events(&ctx);
7172 test_connect_events(&ctx);
7173 test_write_events(&ctx);
7174 test_read_events(&ctx);
7175 test_close_events(&ctx);
7176 test_oob_events(&ctx);
7177
7178 DestroyWindow(ctx.window);
7179 }
7180
7181 static void test_ipv6only(void)
7182 {
7183 SOCKET v4 = INVALID_SOCKET, v6;
7184 struct sockaddr_in sin4;
7185 struct sockaddr_in6 sin6;
7186 int ret, enabled, len = sizeof(enabled);
7187
7188 memset(&sin4, 0, sizeof(sin4));
7189 sin4.sin_family = AF_INET;
7190 sin4.sin_port = htons(SERVERPORT);
7191
7192 memset(&sin6, 0, sizeof(sin6));
7193 sin6.sin6_family = AF_INET6;
7194 sin6.sin6_port = htons(SERVERPORT);
7195
7196 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
7197 if (v6 == INVALID_SOCKET)
7198 {
7199 skip("Could not create IPv6 socket (LastError: %d)\n", WSAGetLastError());
7200 goto end;
7201 }
7202
7203 enabled = 2;
7204 ret = getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7205 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7206 ok(enabled == 1, "expected 1, got %d\n", enabled);
7207
7208 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
7209 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
7210
7211 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7212 ok(v4 != INVALID_SOCKET, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
7213
7214 todo_wine {
7215 enabled = 2;
7216 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7217 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7218 ok(enabled == 1, "expected 1, got %d\n", enabled);
7219 }
7220
7221 enabled = 0;
7222 len = sizeof(enabled);
7223 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7224 ok(!ret, "setsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7225
7226 todo_wine {
7227 enabled = 2;
7228 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7229 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7230 ok(!enabled, "expected 0, got %d\n", enabled);
7231 }
7232
7233 enabled = 1;
7234 len = sizeof(enabled);
7235 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7236 ok(!ret, "setsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7237
7238 /* bind on IPv4 socket should succeed - IPV6_V6ONLY is enabled by default */
7239 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
7240 ok(!ret, "Could not bind IPv4 address (LastError: %d)\n", WSAGetLastError());
7241
7242 todo_wine {
7243 enabled = 2;
7244 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7245 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7246 ok(enabled == 1, "expected 1, got %d\n", enabled);
7247 }
7248
7249 enabled = 0;
7250 len = sizeof(enabled);
7251 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7252 ok(ret, "setsockopt(IPV6_V6ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
7253
7254 todo_wine {
7255 enabled = 0;
7256 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7257 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7258 ok(enabled == 1, "expected 1, got %d\n", enabled);
7259 }
7260
7261 enabled = 1;
7262 len = sizeof(enabled);
7263 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7264 ok(ret, "setsockopt(IPV6_V6ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
7265
7266 closesocket(v4);
7267 closesocket(v6);
7268
7269 /* Test again, this time disabling IPV6_V6ONLY. */
7270 sin4.sin_port = htons(SERVERPORT+2);
7271 sin6.sin6_port = htons(SERVERPORT+2);
7272
7273 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
7274 ok(v6 != INVALID_SOCKET, "Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
7275 WSAGetLastError(), WSAEAFNOSUPPORT);
7276
7277 enabled = 0;
7278 ret = setsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7279 ok(!ret, "Could not disable IPV6_V6ONLY (LastError: %d).\n", WSAGetLastError());
7280
7281 enabled = 2;
7282 ret = getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7283 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7284 ok(!enabled, "expected 0, got %d\n", enabled);
7285
7286 /*
7287 Observaition:
7288 On Windows, bind on both IPv4 and IPv6 with IPV6_V6ONLY disabled succeeds by default.
7289 Application must set SO_EXCLUSIVEADDRUSE on first socket to disallow another successful bind.
7290 In general, a standard application should not use SO_REUSEADDR.
7291 Setting both SO_EXCLUSIVEADDRUSE and SO_REUSEADDR on the same socket is not possible in
7292 either order, the later setsockopt call always fails.
7293 */
7294 enabled = 1;
7295 ret = setsockopt(v6, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&enabled, len);
7296 ok(!ret, "Could not set SO_EXCLUSIVEADDRUSE on IPv6 socket (LastError: %d)\n", WSAGetLastError());
7297
7298 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
7299 ok(!ret, "Could not bind IPv6 address (LastError: %d)\n", WSAGetLastError());
7300
7301 enabled = 2;
7302 len = sizeof(enabled);
7303 getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7304 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7305 ok(!enabled, "IPV6_V6ONLY is enabled after bind\n");
7306
7307 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7308 ok(v4 != INVALID_SOCKET, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
7309
7310 enabled = 1;
7311 ret = setsockopt(v4, SOL_SOCKET, SO_REUSEADDR, (char*)&enabled, len);
7312 ok(!ret, "Could not set SO_REUSEADDR on IPv4 socket (LastError: %d)\n", WSAGetLastError());
7313
7314 WSASetLastError(0xdeadbeef);
7315 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
7316 ok(ret, "bind succeeded unexpectedly for the IPv4 socket\n");
7317 ok(WSAGetLastError() == WSAEACCES, "Expected 10013, got %d\n", WSAGetLastError());
7318
7319 end:
7320 if (v4 != INVALID_SOCKET)
7321 closesocket(v4);
7322 if (v6 != INVALID_SOCKET)
7323 closesocket(v6);
7324 }
7325
7326 static void test_WSASendMsg(void)
7327 {
7328 SOCKET sock, dst;
7329 struct sockaddr_in sendaddr, sockaddr;
7330 GUID WSASendMsg_GUID = WSAID_WSASENDMSG;
7331 LPFN_WSASENDMSG pWSASendMsg = NULL;
7332 char teststr[12] = "hello world", buffer[32];
7333 WSABUF iovec[2];
7334 WSAMSG msg;
7335 DWORD bytesSent, err;
7336 int ret, addrlen;
7337
7338 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
7339
7340 sock = socket(AF_INET, SOCK_DGRAM, 0);
7341 ok(sock != INVALID_SOCKET, "socket() failed\n");
7342
7343 /* Obtain the WSASendMsg function */
7344 WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSASendMsg_GUID, sizeof(WSASendMsg_GUID),
7345 &pWSASendMsg, sizeof(pWSASendMsg), &err, NULL, NULL);
7346 if (!pWSASendMsg)
7347 {
7348 closesocket(sock);
7349 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
7350 return;
7351 }
7352
7353 /* fake address for now */
7354 sendaddr.sin_family = AF_INET;
7355 sendaddr.sin_port = htons(139);
7356 sendaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
7357
7358 memset(&msg, 0, sizeof(msg));
7359 iovec[0].buf = teststr;
7360 iovec[0].len = sizeof(teststr);
7361 iovec[1].buf = teststr;
7362 iovec[1].len = sizeof(teststr) / 2;
7363 msg.name = (struct sockaddr *) &sendaddr;
7364 msg.namelen = sizeof(sendaddr);
7365 msg.lpBuffers = iovec;
7366 msg.dwBufferCount = 1; /* send only one buffer for now */
7367
7368 WSASetLastError(0xdeadbeef);
7369 ret = pWSASendMsg(INVALID_SOCKET, &msg, 0, NULL, NULL, NULL);
7370 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7371 err = WSAGetLastError();
7372 ok(err == WSAENOTSOCK, "expected 10038, got %ld instead\n", err);
7373
7374 WSASetLastError(0xdeadbeef);
7375 ret = pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL);
7376 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7377 err = WSAGetLastError();
7378 ok(err == WSAEFAULT, "expected 10014, got %ld instead\n", err);
7379
7380 WSASetLastError(0xdeadbeef);
7381 ret = pWSASendMsg(sock, NULL, 0, &bytesSent, NULL, NULL);
7382 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7383 err = WSAGetLastError();
7384 ok(err == WSAEFAULT, "expected 10014, got %ld instead\n", err);
7385
7386 WSASetLastError(0xdeadbeef);
7387 ret = pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL);
7388 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7389 err = WSAGetLastError();
7390 ok(err == WSAEFAULT, "expected 10014, got %ld instead\n", err);
7391
7392 closesocket(sock);
7393
7394 sock = socket(AF_INET, SOCK_DGRAM, 0);
7395 ok(sock != INVALID_SOCKET, "socket() failed\n");
7396
7397 dst = socket(AF_INET, SOCK_DGRAM, 0);
7398 ok(dst != INVALID_SOCKET, "socket() failed\n");
7399
7400 memset(&sockaddr, 0, sizeof(sockaddr));
7401 sockaddr.sin_family = AF_INET;
7402 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
7403 ok(!bind(dst, (struct sockaddr*)&sockaddr, sizeof(sockaddr)),
7404 "bind should have worked\n");
7405
7406 /* read address to find out the port number to be used in send */
7407 memset(&sendaddr, 0, sizeof(sendaddr));
7408 addrlen = sizeof(sendaddr);
7409 ok(!getsockname(dst, (struct sockaddr *) &sendaddr, &addrlen),
7410 "getsockname should have worked\n");
7411 ok(sendaddr.sin_port, "socket port should be != 0\n");
7412
7413 /* ensure the sending socket is not bound */
7414 WSASetLastError(0xdeadbeef);
7415 addrlen = sizeof(sockaddr);
7416 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
7417 ok(ret == SOCKET_ERROR, "getsockname should have failed\n");
7418 err = WSAGetLastError();
7419 ok(err == WSAEINVAL, "expected 10022, got %ld instead\n", err);
7420
7421 set_blocking(sock, TRUE);
7422
7423 bytesSent = 0;
7424 SetLastError(0xdeadbeef);
7425 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
7426 ok(!ret, "WSASendMsg should have worked\n");
7427 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
7428 "Expected 0, got %ld\n", GetLastError());
7429 ok(bytesSent == iovec[0].len, "incorrect bytes sent, expected %ld, sent %ld\n",
7430 iovec[0].len, bytesSent);
7431
7432 /* receive data */
7433 addrlen = sizeof(sockaddr);
7434 memset(buffer, 0, sizeof(buffer));
7435 SetLastError(0xdeadbeef);
7436 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
7437 ok(ret == bytesSent, "got %d, expected %ld\n",
7438 ret, bytesSent);
7439 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7440
7441 /* A successful call to WSASendMsg must have bound the socket */
7442 addrlen = sizeof(sockaddr);
7443 sockaddr.sin_port = 0;
7444 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
7445 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
7446 ok(!ret, "getsockname should have worked\n");
7447 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
7448 inet_ntoa(sockaddr.sin_addr));
7449 ok(sockaddr.sin_port, "sin_port should be != 0\n");
7450
7451 msg.dwBufferCount = 2; /* send both buffers */
7452
7453 bytesSent = 0;
7454 SetLastError(0xdeadbeef);
7455 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
7456 ok(!ret, "WSASendMsg should have worked\n");
7457 ok(bytesSent == iovec[0].len + iovec[1].len, "incorrect bytes sent, expected %ld, sent %ld\n",
7458 iovec[0].len + iovec[1].len, bytesSent);
7459 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
7460 "Expected 0, got %ld\n", GetLastError());
7461
7462 /* receive data */
7463 addrlen = sizeof(sockaddr);
7464 memset(buffer, 0, sizeof(buffer));
7465 SetLastError(0xdeadbeef);
7466 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
7467 ok(ret == bytesSent, "got %d, expected %ld\n",
7468 ret, bytesSent);
7469 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7470
7471 closesocket(sock);
7472 closesocket(dst);
7473
7474 /* a bad call to WSASendMsg will also bind the socket */
7475 addrlen = sizeof(sockaddr);
7476 sockaddr.sin_port = 0;
7477 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
7478 sock = socket(AF_INET, SOCK_DGRAM, 0);
7479 ok(sock != INVALID_SOCKET, "socket() failed\n");
7480 ok(pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
7481 todo_wine {
7482 ok(!getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have worked\n");
7483 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
7484 inet_ntoa(sockaddr.sin_addr));
7485 ok(sockaddr.sin_port, "sin_port should be > 0\n");
7486 }
7487 closesocket(sock);
7488
7489 /* a bad call without msg parameter will not trigger the auto-bind */
7490 sock = socket(AF_INET, SOCK_DGRAM, 0);
7491 ok(sock != INVALID_SOCKET, "socket() failed\n");
7492 ok(pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
7493 ok(getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have failed\n");
7494 err = WSAGetLastError();
7495 ok(err == WSAEINVAL, "expected 10022, got %ld instead\n", err);
7496 closesocket(sock);
7497
7498 /* SOCK_STREAM sockets are not supported */
7499 bytesSent = 0;
7500 sock = socket(AF_INET, SOCK_STREAM, 0);
7501 ok(sock != INVALID_SOCKET, "socket() failed\n");
7502 SetLastError(0xdeadbeef);
7503 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
7504 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7505 err = WSAGetLastError();
7506 todo_wine
7507 ok(err == WSAEINVAL, "expected 10014, got %ld instead\n", err);
7508 closesocket(sock);
7509 }
7510
7511 static void test_WSASendTo(void)
7512 {
7513 SOCKET s;
7514 struct sockaddr_in addr, ret_addr;
7515 char buf[12] = "hello world";
7516 WSABUF data_buf;
7517 DWORD bytesSent;
7518 int ret, len;
7519
7520 addr.sin_family = AF_INET;
7521 addr.sin_port = htons(139);
7522 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
7523 data_buf.len = sizeof(buf);
7524 data_buf.buf = buf;
7525
7526 s = socket(AF_INET, SOCK_DGRAM, 0);
7527 ok(s != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
7528
7529 WSASetLastError(12345);
7530 ret = WSASendTo(INVALID_SOCKET, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
7531 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
7532 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
7533
7534 len = sizeof(ret_addr);
7535 ret = getsockname(s, (struct sockaddr *)&ret_addr, &len);
7536 ok(ret == -1, "expected failure\n");
7537 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
7538
7539 WSASetLastError(12345);
7540 ret = WSASendTo(s, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
7541 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
7542 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
7543
7544 WSASetLastError(12345);
7545 ret = WSASendTo(s, &data_buf, 1, &bytesSent, 0, (struct sockaddr *)&addr, sizeof(addr), NULL, NULL);
7546 ok(!ret, "expected success\n");
7547 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
7548
7549 len = sizeof(ret_addr);
7550 ret = getsockname(s, (struct sockaddr *)&ret_addr, &len);
7551 ok(!ret, "got error %u\n", WSAGetLastError());
7552 ok(ret_addr.sin_family == AF_INET, "got family %u\n", ret_addr.sin_family);
7553 ok(ret_addr.sin_port, "expected nonzero port\n");
7554 }
7555
7556 struct recv_thread_apc_param
7557 {
7558 SOCKET sock;
7559 unsigned int apc_count;
7560 };
7561
7562 static void WINAPI recv_thread_apc_func(ULONG_PTR param)
7563 {
7564 struct recv_thread_apc_param *p = (struct recv_thread_apc_param *)param;
7565 int ret;
7566
7567 ++p->apc_count;
7568
7569 ret = send(p->sock, "test", 4, 0);
7570 ok(ret == 4, "got %d.\n", ret);
7571 }
7572
7573 struct recv_thread_param
7574 {
7575 SOCKET sock;
7576 BOOL overlapped;
7577 };
7578
7579 static DWORD WINAPI recv_thread(LPVOID arg)
7580 {
7581 struct recv_thread_param *p = arg;
7582 SOCKET sock = p->sock;
7583 char buffer[32];
7584 WSABUF wsa;
7585 WSAOVERLAPPED ov;
7586 DWORD flags = 0;
7587 DWORD len;
7588 int ret;
7589
7590 wsa.buf = buffer;
7591 wsa.len = sizeof(buffer);
7592 if (p->overlapped)
7593 {
7594 ov.hEvent = WSACreateEvent();
7595 WSARecv(sock, &wsa, 1, NULL, &flags, &ov, NULL);
7596
7597 WaitForSingleObject(ov.hEvent, 1000);
7598 WSACloseEvent(ov.hEvent);
7599 }
7600 else
7601 {
7602 SetLastError(0xdeadbeef);
7603 ret = WSARecv(sock, &wsa, 1, &len, &flags, NULL, NULL);
7604 ok(!ret, "got ret %d.\n", ret);
7605 ok(WSAGetLastError() == 0, "got error %d.\n", WSAGetLastError());
7606 ok(len == 4, "got len %lu.\n", len);
7607 }
7608 return 0;
7609 }
7610
7611 static int completion_called;
7612
7613 static void WINAPI io_completion(DWORD error, DWORD transferred, WSAOVERLAPPED *overlapped, DWORD flags)
7614 {
7615 completion_called++;
7616 }
7617
7618 static void test_WSARecv(void)
7619 {
7620 SOCKET src, dest, server = INVALID_SOCKET;
7621 struct recv_thread_apc_param apc_param;
7622 struct recv_thread_param recv_param;
7623 char buf[20];
7624 WSABUF bufs[2];
7625 WSAOVERLAPPED ov;
7626 DWORD bytesReturned, flags, id;
7627 struct sockaddr_in addr;
7628 unsigned int apc_count;
7629 int iret, len;
7630 DWORD dwret;
7631 BOOL bret;
7632 HANDLE thread, event = NULL, io_port;
7633
7634 tcp_socketpair(&src, &dest);
7635
7636 memset(&ov, 0, sizeof(ov));
7637 flags = 0;
7638 bufs[0].len = 1;
7639 bufs[0].buf = buf;
7640
7641 /* Send 2 bytes and receive in two calls of 1 */
7642 SetLastError(0xdeadbeef);
7643 iret = send(src, "ab", 2, 0);
7644 ok(iret == 2, "got %d\n", iret);
7645 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7646 SetLastError(0xdeadbeef);
7647 bytesReturned = 0xdeadbeef;
7648
7649 /* Non-overlapped WSARecv() performs an alertable wait (tested below), but
7650 * not if it completes synchronously. Make sure it completes synchronously
7651 * by polling for input. */
7652 check_poll_mask(dest, POLLRDNORM, POLLRDNORM);
7653
7654 apc_count = 0;
7655 dwret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
7656 ok(dwret, "QueueUserAPC returned %lu\n", dwret);
7657
7658 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
7659 ok(!iret, "Expected 0, got %d\n", iret);
7660 ok(bytesReturned == 1, "got %ld\n", bytesReturned);
7661 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7662
7663 ok(!apc_count, "got apc_count %u.\n", apc_count);
7664 SleepEx(0, TRUE);
7665 ok(apc_count == 1, "got apc_count %u.\n", apc_count);
7666
7667 SetLastError(0xdeadbeef);
7668 bytesReturned = 0xdeadbeef;
7669 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
7670 ok(!iret, "Expected 0, got %d\n", iret);
7671 ok(bytesReturned == 1, "got %ld\n", bytesReturned);
7672 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7673
7674 bufs[0].len = 4;
7675 SetLastError(0xdeadbeef);
7676 iret = send(src, "test", 4, 0);
7677 ok(iret == 4, "Expected 4, got %d\n", iret);
7678 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7679 SetLastError(0xdeadbeef);
7680 bytesReturned = 0xdeadbeef;
7681 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
7682 ok(!iret, "Expected 0, got %d\n", iret);
7683 ok(bytesReturned == 4, "Expected 4, got %ld\n", bytesReturned);
7684 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7685
7686 /* Test 2 buffers */
7687 bufs[0].len = 4;
7688 bufs[1].len = 5;
7689 bufs[1].buf = buf + 10;
7690 SetLastError(0xdeadbeef);
7691 iret = send(src, "deadbeefs", 9, 0);
7692 ok(iret == 9, "Expected 9, got %d\n", iret);
7693 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7694 SetLastError(0xdeadbeef);
7695 bytesReturned = 0xdeadbeef;
7696 iret = WSARecv(dest, bufs, 2, &bytesReturned, &flags, NULL, NULL);
7697 ok(!iret, "Expected 0, got %d\n", iret);
7698 ok(bytesReturned == 9, "Expected 9, got %ld\n", bytesReturned);
7699 bufs[0].buf[4] = '\0';
7700 bufs[1].buf[5] = '\0';
7701 ok(!strcmp(bufs[0].buf, "dead"), "buf[0] doesn't match: %s != dead\n", bufs[0].buf);
7702 ok(!strcmp(bufs[1].buf, "beefs"), "buf[1] doesn't match: %s != beefs\n", bufs[1].buf);
7703 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7704
7705 bufs[0].len = sizeof(buf);
7706 ov.hEvent = event = CreateEventA(NULL, FALSE, FALSE, NULL);
7707 ok(ov.hEvent != NULL, "could not create event object, errno = %ld\n", GetLastError());
7708 if (!event)
7709 goto end;
7710
7711 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, NULL);
7712 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %ld\n", iret, GetLastError());
7713
7714 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, &ov, NULL);
7715 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %ld\n", iret, GetLastError());
7716
7717 close_with_rst(src);
7718
7719 dwret = WaitForSingleObject(ov.hEvent, 1000);
7720 ok(dwret == WAIT_OBJECT_0, "Waiting for disconnect event failed with %ld + errno %ld\n", dwret, GetLastError());
7721
7722 bret = GetOverlappedResult((HANDLE)dest, &ov, &bytesReturned, FALSE);
7723 ok(!bret, "expected failure\n");
7724 ok(GetLastError() == ERROR_NETNAME_DELETED, "got error %lu\n", GetLastError());
7725 ok(bytesReturned == 0, "Bytes received is %ld\n", bytesReturned);
7726 closesocket(dest);
7727 dest = INVALID_SOCKET;
7728
7729 src = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
7730 ok(src != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
7731 if (src == INVALID_SOCKET) goto end;
7732
7733 server = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
7734 ok(server != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
7735 if (server == INVALID_SOCKET) goto end;
7736
7737 memset(&addr, 0, sizeof(addr));
7738 addr.sin_family = AF_INET;
7739 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
7740 iret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
7741 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
7742
7743 len = sizeof(addr);
7744 iret = getsockname(server, (struct sockaddr *)&addr, &len);
7745 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
7746
7747 iret = listen(server, 1);
7748 ok(!iret, "failed to listen, error %u\n", WSAGetLastError());
7749
7750 iret = connect(src, (struct sockaddr *)&addr, sizeof(addr));
7751 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
7752
7753 len = sizeof(addr);
7754 dest = accept(server, (struct sockaddr *)&addr, &len);
7755 ok(dest != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
7756 if (dest == INVALID_SOCKET) goto end;
7757
7758 send(src, "test message", sizeof("test message"), 0);
7759 recv_param.sock = dest;
7760 recv_param.overlapped = TRUE;
7761 thread = CreateThread(NULL, 0, recv_thread, &recv_param, 0, &id);
7762 WaitForSingleObject(thread, 3000);
7763 CloseHandle(thread);
7764
7765 recv_param.overlapped = FALSE;
7766 thread = CreateThread(NULL, 0, recv_thread, &recv_param, 0, &id);
7767 apc_param.apc_count = 0;
7768 apc_param.sock = src;
7769 dwret = QueueUserAPC(recv_thread_apc_func, thread, (ULONG_PTR)&apc_param);
7770 ok(dwret, "QueueUserAPC returned %lu\n", dwret);
7771 WaitForSingleObject(thread, 3000);
7772 ok(apc_param.apc_count == 1, "got apc_count %u.\n", apc_param.apc_count);
7773
7774 CloseHandle(thread);
7775
7776 memset(&ov, 0, sizeof(ov));
7777 ov.hEvent = event;
7778 ResetEvent(event);
7779 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, io_completion);
7780 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %ld\n", iret, GetLastError());
7781 send(src, "test message", sizeof("test message"), 0);
7782
7783 completion_called = 0;
7784 dwret = SleepEx(1000, TRUE);
7785 ok(dwret == WAIT_IO_COMPLETION, "got %lu\n", dwret);
7786 ok(completion_called == 1, "completion not called\n");
7787
7788 dwret = WaitForSingleObject(event, 1);
7789 ok(dwret == WAIT_TIMEOUT, "got %lu\n", dwret);
7790
7791 io_port = CreateIoCompletionPort( (HANDLE)dest, NULL, 0, 0 );
7792 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
7793
7794 /* Using completion function on socket associated with completion port is not allowed. */
7795 memset(&ov, 0, sizeof(ov));
7796 completion_called = 0;
7797 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, io_completion);
7798 ok(iret == SOCKET_ERROR && GetLastError() == WSAEINVAL, "WSARecv failed - %d error %ld\n", iret, GetLastError());
7799 ok(!completion_called, "completion called\n");
7800
7801 CloseHandle(io_port);
7802
7803 end:
7804 if (server != INVALID_SOCKET)
7805 closesocket(server);
7806 if (dest != INVALID_SOCKET)
7807 closesocket(dest);
7808 if (src != INVALID_SOCKET)
7809 closesocket(src);
7810 if (event)
7811 WSACloseEvent(event);
7812 }
7813
7814 struct write_watch_thread_args
7815 {
7816 int func;
7817 SOCKET dest;
7818 void *base;
7819 DWORD size;
7820 const char *expect;
7821 };
7822
7823 static DWORD CALLBACK write_watch_thread( void *arg )
7824 {
7825 struct write_watch_thread_args *args = arg;
7826 struct sockaddr addr;
7827 int addr_len = sizeof(addr), ret;
7828 DWORD bytes, flags = 0;
7829 WSABUF buf[1];
7830
7831 switch (args->func)
7832 {
7833 case 0:
7834 ret = recv( args->dest, args->base, args->size, 0 );
7835 ok( ret == strlen(args->expect) + 1, "wrong len %d\n", ret );
7836 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
7837 break;
7838 case 1:
7839 ret = recvfrom( args->dest, args->base, args->size, 0, &addr, &addr_len );
7840 ok( ret == strlen(args->expect) + 1, "wrong len %d\n", ret );
7841 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
7842 break;
7843 case 2:
7844 buf[0].len = args->size;
7845 buf[0].buf = args->base;
7846 ret = WSARecv( args->dest, buf, 1, &bytes, &flags, NULL, NULL );
7847 ok( !ret, "WSARecv failed %lu\n", GetLastError() );
7848 ok( bytes == strlen(args->expect) + 1, "wrong len %ld\n", bytes );
7849 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
7850 break;
7851 case 3:
7852 buf[0].len = args->size;
7853 buf[0].buf = args->base;
7854 ret = WSARecvFrom( args->dest, buf, 1, &bytes, &flags, &addr, &addr_len, NULL, NULL );
7855 ok( !ret, "WSARecvFrom failed %lu\n", GetLastError() );
7856 ok( bytes == strlen(args->expect) + 1, "wrong len %ld\n", bytes );
7857 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
7858 break;
7859 }
7860 return 0;
7861 }
7862
7863 static void test_write_watch(void)
7864 {
7865 SOCKET src, dest;
7866 WSABUF bufs[2];
7867 WSAOVERLAPPED ov;
7868 struct write_watch_thread_args args;
7869 DWORD bytesReturned, flags, size;
7870 struct sockaddr addr;
7871 int addr_len, ret;
7872 HANDLE thread, event;
7873 char *base;
7874 void *results[64];
7875 ULONG_PTR count;
7876 ULONG pagesize;
7877 UINT (WINAPI *pGetWriteWatch)(DWORD,LPVOID,SIZE_T,LPVOID*,ULONG_PTR*,ULONG*);
7878
7879 pGetWriteWatch = (void *)GetProcAddress( GetModuleHandleA("kernel32.dll"), "GetWriteWatch" );
7880 if (!pGetWriteWatch)
7881 {
7882 win_skip( "write watched not supported\n" );
7883 return;
7884 }
7885
7886 /* Windows 11 no longer triggers write watches anymore. */
7887
7888 tcp_socketpair(&src, &dest);
7889
7890 memset(&ov, 0, sizeof(ov));
7891 ov.hEvent = event = CreateEventA(NULL, FALSE, FALSE, NULL);
7892 ok(ov.hEvent != NULL, "could not create event object, errno = %ld\n", GetLastError());
7893
7894 flags = 0;
7895
7896 size = 0x10000;
7897 base = VirtualAlloc( 0, size, MEM_RESERVE | MEM_COMMIT | MEM_WRITE_WATCH, PAGE_READWRITE );
7898 ok( base != NULL, "VirtualAlloc failed %lu\n", GetLastError() );
7899
7900 memset( base, 0, size );
7901 count = 64;
7902 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7903 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7904 ok( count == 16, "wrong count %Iu\n", count );
7905
7906 bufs[0].len = 5;
7907 bufs[0].buf = base;
7908 bufs[1].len = 0x8000;
7909 bufs[1].buf = base + 0x4000;
7910
7911 ret = WSARecv( dest, bufs, 2, NULL, &flags, &ov, NULL);
7912 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
7913 "WSARecv failed - %d error %ld\n", ret, GetLastError());
7914
7915 count = 64;
7916 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7917 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7918 ok( count == 9 || !count /* Win 11 */, "wrong count %Iu\n", count );
7919 ok( !base[0], "data set\n" );
7920
7921 send(src, "test message", sizeof("test message"), 0);
7922
7923 ret = GetOverlappedResult( (HANDLE)dest, &ov, &bytesReturned, TRUE );
7924 ok( ret, "GetOverlappedResult failed %lu\n", GetLastError() );
7925 ok( bytesReturned == sizeof("test message"), "wrong size %lu\n", bytesReturned );
7926 ok( !memcmp( base, "test ", 5 ), "wrong data %s\n", base );
7927 ok( !memcmp( base + 0x4000, "message", 8 ), "wrong data %s\n", base + 0x4000 );
7928
7929 count = 64;
7930 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7931 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7932 ok( count == 0, "wrong count %Iu\n", count );
7933
7934 memset( base, 0, size );
7935 count = 64;
7936 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7937 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7938 ok( count == 16, "wrong count %Iu\n", count );
7939
7940 bufs[1].len = 0x4000;
7941 bufs[1].buf = base + 0x2000;
7942 ret = WSARecvFrom( dest, bufs, 2, NULL, &flags, &addr, &addr_len, &ov, NULL);
7943 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
7944 "WSARecv failed - %d error %ld\n", ret, GetLastError());
7945
7946 count = 64;
7947 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7948 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7949 ok( count == 5 || !count /* Win 11 */, "wrong count %Iu\n", count );
7950 ok( !base[0], "data set\n" );
7951
7952 send(src, "test message", sizeof("test message"), 0);
7953
7954 ret = GetOverlappedResult( (HANDLE)dest, &ov, &bytesReturned, TRUE );
7955 ok( ret, "GetOverlappedResult failed %lu\n", GetLastError() );
7956 ok( bytesReturned == sizeof("test message"), "wrong size %lu\n", bytesReturned );
7957 ok( !memcmp( base, "test ", 5 ), "wrong data %s\n", base );
7958 ok( !memcmp( base + 0x2000, "message", 8 ), "wrong data %s\n", base + 0x2000 );
7959
7960 count = 64;
7961 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7962 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7963 ok( count == 0, "wrong count %Iu\n", count );
7964
7965 memset( base, 0, size );
7966 count = 64;
7967 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7968 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7969 ok( count == 16, "wrong count %Iu\n", count );
7970
7971 args.dest = dest;
7972 args.base = base;
7973 args.size = 0x7002;
7974 args.expect = "test message";
7975 for (args.func = 0; args.func < 4; args.func++)
7976 {
7977 thread = CreateThread( NULL, 0, write_watch_thread, &args, 0, NULL );
7978 Sleep( 200 );
7979
7980 count = 64;
7981 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7982 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7983 ok( count == 8 || !count /* Win 11 */, "wrong count %Iu\n", count );
7984
7985 send(src, "test message", sizeof("test message"), 0);
7986 WaitForSingleObject( thread, 10000 );
7987 CloseHandle( thread );
7988
7989 count = 64;
7990 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7991 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7992 ok( count == 0, "wrong count %Iu\n", count );
7993 }
7994 WSACloseEvent( event );
7995 closesocket( dest );
7996 closesocket( src );
7997 VirtualFree( base, 0, MEM_FREE );
7998 }
7999
8000 static void test_WSAPoll(void)
8001 {
8002 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
8003 int ret, err, len;
8004 SOCKET listener, server, client;
8005 struct sockaddr_in address;
8006 WSAPOLLFD fds[16];
8007 HANDLE thread_handle;
8008 unsigned int i;
8009 char buffer[6];
8010
8011 static const short invalid_flags[] =
8012 {POLLERR, POLLHUP, POLLNVAL, 0x8, POLLWRBAND, 0x40, 0x80, POLLPRI, 0x800, 0x1000, 0x2000, 0x4000, 0x8000};
8013
8014 if (!pWSAPoll) /* >= Vista */
8015 {
8016 win_skip("WSAPoll is unsupported, some tests will be skipped.\n");
8017 return;
8018 }
8019
8020 /* Invalid parameters test */
8021 SetLastError(0xdeadbeef);
8022 ret = pWSAPoll(NULL, 0, 0);
8023 err = GetLastError();
8024 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
8025 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
8026 SetLastError(0xdeadbeef);
8027 ret = pWSAPoll(NULL, 1, 0);
8028 err = GetLastError();
8029 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
8030 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
8031 SetLastError(0xdeadbeef);
8032 ret = pWSAPoll(NULL, 0, 1);
8033 err = GetLastError();
8034 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
8035 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
8036 SetLastError(0xdeadbeef);
8037 ret = pWSAPoll(NULL, 1, 1);
8038 err = GetLastError();
8039 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
8040 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
8041
8042 memset(&address, 0, sizeof(address));
8043 address.sin_addr.s_addr = inet_addr("127.0.0.1");
8044 address.sin_family = AF_INET;
8045 len = sizeof(address);
8046 listener = setup_server_socket(&address, &len);
8047
8048 for (i = 0; i < ARRAY_SIZE(invalid_flags); ++i)
8049 {
8050 fds[0].fd = listener;
8051 fds[0].events = invalid_flags[i];
8052 fds[0].revents = 0xdead;
8053 WSASetLastError(0xdeadbeef);
8054 ret = pWSAPoll(fds, 1, 0);
8055 todo_wine ok(ret == -1, "got %d\n", ret);
8056 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8057 }
8058
8059 /* When no events are pending poll returns 0 with no error */
8060 fds[0].fd = listener;
8061 fds[0].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
8062 fds[0].revents = 0xdead;
8063 ret = pWSAPoll(fds, 1, 0);
8064 ok(ret == 0, "got %d\n", ret);
8065 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
8066
8067 fds[0].fd = -1;
8068 fds[0].events = POLLERR;
8069 fds[0].revents = 0xdead;
8070 fds[1].fd = listener;
8071 fds[1].events = POLLIN;
8072 fds[1].revents = 0xdead;
8073 WSASetLastError(0xdeadbeef);
8074 ret = pWSAPoll(fds, 2, 0);
8075 ok(!ret, "got %d\n", ret);
8076 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
8077 ok(fds[0].revents == POLLNVAL, "got events %#x\n", fds[0].revents);
8078 ok(!fds[1].revents, "got events %#x\n", fds[1].revents);
8079
8080 fds[0].fd = listener;
8081 fds[0].events = POLLIN;
8082 fds[0].revents = 0xdead;
8083 fds[1].fd = 0xabacab;
8084 fds[1].events = POLLIN;
8085 fds[1].revents = 0xdead;
8086 WSASetLastError(0xdeadbeef);
8087 ret = pWSAPoll(fds, 2, 0);
8088 ok(!ret, "got %d\n", ret);
8089 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
8090 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
8091 ok(fds[1].revents == POLLNVAL, "got events %#x\n", fds[1].revents);
8092
8093 fds[0].fd = listener;
8094 fds[0].events = POLLIN;
8095 fds[0].revents = 0xdead;
8096 fds[1].fd = 0xabacab;
8097 fds[1].events = POLLERR;
8098 fds[1].revents = 0xdead;
8099 WSASetLastError(0xdeadbeef);
8100 ret = pWSAPoll(fds, 2, 0);
8101 todo_wine ok(ret == -1, "got %d\n", ret);
8102 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8103 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
8104 todo_wine ok(!fds[1].revents, "got events %#x\n", fds[1].revents);
8105
8106 fds[0].fd = -1;
8107 fds[0].events = POLLERR;
8108 fds[0].revents = 0xdead;
8109 fds[1].fd = 0xabacab;
8110 fds[1].events = POLLERR;
8111 fds[1].revents = 0xdead;
8112 WSASetLastError(0xdeadbeef);
8113 ret = pWSAPoll(fds, 2, 0);
8114 ok(ret == -1, "got %d\n", ret);
8115 ok(WSAGetLastError() == WSAENOTSOCK, "got error %u\n", WSAGetLastError());
8116 ok(fds[0].revents == POLLNVAL, "got events %#x\n", fds[0].revents);
8117 ok(fds[1].revents == POLLNVAL, "got events %#x\n", fds[1].revents);
8118
8119 /* Test listening socket connection attempt notifications */
8120 client = setup_connector_socket(&address, len, TRUE);
8121
8122 fds[0].fd = listener;
8123 fds[0].events = POLLIN;
8124 fds[0].revents = 0xdead;
8125 ret = pWSAPoll(fds, 1, 100);
8126 ok(ret == 1, "got %d\n", ret);
8127 ok(fds[0].revents == POLLRDNORM, "got events %#x\n", fds[0].revents);
8128
8129 fds[0].revents = 0xdead;
8130 ret = pWSAPoll(fds, 1, 0);
8131 ok(ret == 1, "got %d\n", ret);
8132 ok(fds[0].revents == POLLRDNORM, "got events %#x\n", fds[0].revents);
8133
8134 fds[0].events = POLLRDBAND | POLLWRNORM;
8135 fds[0].revents = 0xdead;
8136 ret = pWSAPoll(fds, 1, 0);
8137 ok(ret == 0, "got %d\n", ret);
8138 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
8139
8140 server = accept(listener, NULL, NULL);
8141 ok(server != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
8142 set_blocking(client, FALSE);
8143 set_blocking(server, FALSE);
8144
8145 for (i = 0; i < ARRAY_SIZE(invalid_flags); ++i)
8146 {
8147 fds[0].fd = server;
8148 fds[0].events = invalid_flags[i];
8149 fds[0].revents = 0xdead;
8150 WSASetLastError(0xdeadbeef);
8151 ret = pWSAPoll(fds, 1, 0);
8152 todo_wine ok(ret == -1, "got %d\n", ret);
8153 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8154 }
8155
8156 /* Test flags exposed by connected sockets. */
8157
8158 fds[0].fd = listener;
8159 fds[0].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
8160 fds[0].revents = 0xdead;
8161 fds[1].fd = server;
8162 fds[1].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
8163 fds[1].revents = 0xdead;
8164 fds[2].fd = client;
8165 fds[2].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
8166 fds[2].revents = 0xdead;
8167 ret = pWSAPoll(fds, 3, 0);
8168 ok(ret == 2, "got %d\n", ret);
8169 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
8170 ok(fds[1].revents == POLLWRNORM, "got events %#x\n", fds[1].revents);
8171 ok(fds[2].revents == POLLWRNORM, "got events %#x\n", fds[2].revents);
8172
8173 /* Test data receiving notifications */
8174
8175 ret = send(server, "1234", 4, 0);
8176 ok(ret == 4, "got %d\n", ret);
8177
8178 check_poll_mask(client, POLLRDNORM | POLLRDBAND, POLLRDNORM);
8179 check_poll(client, POLLRDNORM | POLLWRNORM);
8180 check_poll(server, POLLWRNORM);
8181
8182 ret = sync_recv(client, buffer, sizeof(buffer), 0);
8183 ok(ret == 4, "got %d\n", ret);
8184
8185 check_poll(client, POLLWRNORM);
8186 check_poll(server, POLLWRNORM);
8187
8188 /* Because the kernel asynchronously buffers data, this test is not reliable. */
8189
8190 if (0)
8191 {
8192 static const int large_buffer_size = 1024 * 1024;
8193 char *large_buffer = malloc(large_buffer_size);
8194
8195 while (send(server, large_buffer, large_buffer_size, 0) == large_buffer_size);
8196
8197 check_poll(client, POLLWRNORM | POLLRDNORM);
8198 check_poll(server, 0);
8199
8200 while (recv(client, large_buffer, large_buffer_size, 0) > 0);
8201
8202 check_poll(client, POLLWRNORM);
8203 check_poll(server, POLLWRNORM);
8204
8205 free(large_buffer);
8206 }
8207
8208 /* Test OOB data notifications */
8209
8210 ret = send(client, "A", 1, MSG_OOB);
8211 ok(ret == 1, "got %d\n", ret);
8212
8213 check_poll(client, POLLWRNORM);
8214 check_poll_mask(server, POLLRDNORM | POLLRDBAND, POLLRDBAND);
8215 check_poll(server, POLLWRNORM | POLLRDBAND);
8216
8217 buffer[0] = 0xcc;
8218 ret = recv(server, buffer, 1, MSG_OOB);
8219 ok(ret == 1, "got %d\n", ret);
8220 ok(buffer[0] == 'A', "got %#x\n", buffer[0]);
8221
8222 check_poll(client, POLLWRNORM);
8223 check_poll(server, POLLWRNORM);
8224
8225 /* If the socket is OOBINLINED the notification is like normal data */
8226
8227 ret = 1;
8228 ret = setsockopt(server, SOL_SOCKET, SO_OOBINLINE, (char *)&ret, sizeof(ret));
8229 ok(!ret, "got error %u\n", WSAGetLastError());
8230 ret = send(client, "A", 1, MSG_OOB);
8231 ok(ret == 1, "got %d\n", ret);
8232
8233 check_poll(client, POLLWRNORM);
8234 check_poll_mask(server, POLLRDNORM | POLLRDBAND, POLLRDNORM);
8235 check_poll(server, POLLWRNORM | POLLRDNORM);
8236
8237 buffer[0] = 0xcc;
8238 ret = recv(server, buffer, 1, 0);
8239 ok(ret == 1, "got %d\n", ret);
8240 ok(buffer[0] == 'A', "got %#x\n", buffer[0]);
8241
8242 check_poll(client, POLLWRNORM);
8243 check_poll_todo(server, POLLWRNORM);
8244
8245 /* Test shutdown. */
8246
8247 ret = shutdown(client, SD_RECEIVE);
8248 ok(!ret, "got error %u\n", WSAGetLastError());
8249
8250 check_poll(client, POLLWRNORM);
8251 check_poll_todo(server, POLLWRNORM);
8252
8253 ret = shutdown(client, SD_SEND);
8254 ok(!ret, "got error %u\n", WSAGetLastError());
8255
8256 check_poll(client, POLLWRNORM);
8257 check_poll_mask_todo(server, 0, POLLHUP);
8258 check_poll_todo(server, POLLWRNORM | POLLHUP);
8259
8260 closesocket(client);
8261 closesocket(server);
8262
8263 /* Test shutdown via closesocket(). */
8264
8265 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8266 ret = connect(client, (struct sockaddr *)&address, sizeof(address));
8267 ok(!ret, "got error %u\n", WSAGetLastError());
8268 server = accept(listener, NULL, NULL);
8269 ok(server != -1, "got error %u\n", WSAGetLastError());
8270
8271 closesocket(client);
8272
8273 check_poll_mask(server, 0, POLLHUP);
8274 check_poll(server, POLLWRNORM | POLLHUP);
8275
8276 closesocket(server);
8277
8278 /* Test shutdown with data in the pipe. */
8279
8280 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8281 ret = connect(client, (struct sockaddr *)&address, sizeof(address));
8282 ok(!ret, "got error %u\n", WSAGetLastError());
8283 server = accept(listener, NULL, NULL);
8284 ok(server != -1, "got error %u\n", WSAGetLastError());
8285
8286 ret = send(client, "data", 5, 0);
8287 ok(ret == 5, "got %d\n", ret);
8288
8289 check_poll(client, POLLWRNORM);
8290 check_poll_mask(server, POLLRDNORM | POLLRDBAND, POLLRDNORM);
8291 check_poll(server, POLLWRNORM | POLLRDNORM);
8292
8293 ret = shutdown(client, SD_SEND);
8294
8295 check_poll(client, POLLWRNORM);
8296 check_poll_mask_todo(server, 0, POLLHUP);
8297 check_poll_todo(server, POLLWRNORM | POLLRDNORM | POLLHUP);
8298
8299 closesocket(client);
8300 closesocket(server);
8301
8302 /* Test closing a socket while selecting on it. */
8303
8304 tcp_socketpair(&client, &server);
8305
8306 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &client, 0, NULL);
8307 fds[0].fd = client;
8308 fds[0].events = POLLRDNORM | POLLRDBAND;
8309 fds[0].revents = 0xdead;
8310 apc_count = 0;
8311 ret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
8312 ok(ret, "QueueUserAPC returned %d\n", ret);
8313 ret = pWSAPoll(fds, 1, 2000);
8314 ok(apc_count == 1, "APC was called %u times\n", apc_count);
8315 ok(ret == 1, "got %d\n", ret);
8316 ok(fds[0].revents == POLLNVAL, "got events %#x\n", fds[0].revents);
8317 ret = WaitForSingleObject(thread_handle, 1000);
8318 ok(!ret, "wait failed\n");
8319 CloseHandle(thread_handle);
8320
8321 closesocket(server);
8322
8323 /* Test a failed connection.
8324 *
8325 * The following WSAPoll() call times out on versions older than w10pro64,
8326 * but even on w10pro64 it takes over 2 seconds for an error to be reported,
8327 * so make the test interactive-only. */
8328 if (winetest_interactive)
8329 {
8330 const struct sockaddr_in invalid_addr =
8331 {
8332 .sin_family = AF_INET,
8333 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
8334 .sin_port = 255,
8335 };
8336 SOCKET client;
8337
8338 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8339 set_blocking(client, FALSE);
8340
8341 ret = connect(client, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
8342 ok(ret == -1, "got %d\n", ret);
8343 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
8344
8345 fds[0].fd = client;
8346 fds[0].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
8347 fds[0].revents = 0xdead;
8348 ret = pWSAPoll(fds, 1, 10000);
8349 ok(ret == 1, "got %d\n", ret);
8350 todo_wine ok(fds[0].revents == (POLLWRNORM | POLLHUP | POLLERR), "got events %#x\n", fds[0].revents);
8351
8352 len = sizeof(err);
8353 err = 0xdeadbeef;
8354 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
8355 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
8356 ok(err == WSAECONNREFUSED, "got error %u\n", err);
8357
8358 len = sizeof(err);
8359 err = 0xdeadbeef;
8360 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
8361 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
8362 ok(err == WSAECONNREFUSED, "got error %u\n", err);
8363
8364 check_poll_todo(client, POLLWRNORM | POLLHUP | POLLERR);
8365
8366 closesocket(client);
8367
8368 /* test polling after a (synchronous) failure */
8369
8370 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8371
8372 ret = connect(client, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
8373 ok(ret == -1, "got %d\n", ret);
8374 ok(WSAGetLastError() == WSAECONNREFUSED, "got error %u\n", WSAGetLastError());
8375
8376 check_poll_todo(client, POLLWRNORM | POLLHUP | POLLERR);
8377
8378 len = sizeof(err);
8379 err = 0xdeadbeef;
8380 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
8381 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
8382 todo_wine ok(!err, "got error %u\n", err);
8383
8384 closesocket(client);
8385 }
8386
8387 closesocket(listener);
8388
8389 /* Test UDP sockets. */
8390
8391 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
8392 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
8393
8394 check_poll(client, POLLWRNORM);
8395 check_poll(server, POLLWRNORM);
8396
8397 ret = bind(client, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
8398 ok(!ret, "got error %u\n", WSAGetLastError());
8399 len = sizeof(address);
8400 ret = getsockname(client, (struct sockaddr *)&address, &len);
8401 ok(!ret, "got error %u\n", WSAGetLastError());
8402
8403 check_poll(client, POLLWRNORM);
8404 check_poll(server, POLLWRNORM);
8405
8406 ret = sendto(server, "data", 5, 0, (struct sockaddr *)&address, sizeof(address));
8407 ok(ret == 5, "got %d\n", ret);
8408
8409 check_poll_mask(client, POLLRDNORM | POLLRDBAND, POLLRDNORM);
8410 check_poll(client, POLLWRNORM | POLLRDNORM);
8411 check_poll(server, POLLWRNORM);
8412
8413 closesocket(client);
8414 closesocket(server);
8415 }
8416
8417 static void test_connect(void)
8418 {
8419 SOCKET listener = INVALID_SOCKET;
8420 SOCKET acceptor = INVALID_SOCKET;
8421 SOCKET connector = INVALID_SOCKET;
8422 struct sockaddr_in address, conaddress;
8423 int addrlen;
8424 OVERLAPPED overlapped;
8425 LPFN_CONNECTEX pConnectEx;
8426 GUID connectExGuid = WSAID_CONNECTEX;
8427 DWORD bytesReturned;
8428 char buffer[1024];
8429 BOOL bret;
8430 DWORD dwret;
8431 int iret;
8432
8433 memset(&overlapped, 0, sizeof(overlapped));
8434
8435 listener = socket(AF_INET, SOCK_STREAM, 0);
8436 ok(listener != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8437
8438 connector = socket(AF_INET, SOCK_STREAM, 0);
8439 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8440
8441 memset(&address, 0, sizeof(address));
8442 address.sin_family = AF_INET;
8443 address.sin_addr.s_addr = inet_addr("127.0.0.1");
8444 iret = bind(listener, (struct sockaddr*)&address, sizeof(address));
8445 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8446
8447 addrlen = sizeof(address);
8448 iret = getsockname(listener, (struct sockaddr*)&address, &addrlen);
8449 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
8450
8451 iret = listen(listener, 1);
8452 ok(!iret, "failed to listen, error %u\n", WSAGetLastError());
8453
8454 iret = set_blocking(listener, TRUE);
8455 ok(!iret, "failed to set nonblocking, error %u\n", WSAGetLastError());
8456
8457 bytesReturned = 0xdeadbeef;
8458 iret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectExGuid, sizeof(connectExGuid),
8459 &pConnectEx, sizeof(pConnectEx), &bytesReturned, NULL, NULL);
8460 ok(!iret, "failed to get ConnectEx, error %u\n", WSAGetLastError());
8461
8462 ok(bytesReturned == sizeof(pConnectEx), "expected sizeof(pConnectEx), got %lu\n", bytesReturned);
8463
8464 WSASetLastError(0xdeadbeef);
8465 iret = connect(listener, (struct sockaddr *)&address, sizeof(address));
8466 ok(iret == -1, "got %d\n", iret);
8467 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8468
8469 WSASetLastError(0xdeadbeef);
8470 overlapped.Internal = 0xdeadbeef;
8471 overlapped.InternalHigh = 0xdeadbeef;
8472 iret = pConnectEx(listener, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8473 ok(!iret, "got %d\n", iret);
8474 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8475 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8476 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8477
8478 bret = pConnectEx(INVALID_SOCKET, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8479 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "ConnectEx on invalid socket "
8480 "returned %d + errno %d\n", bret, WSAGetLastError());
8481
8482 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8483 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "ConnectEx on a unbound socket "
8484 "returned %d + errno %d\n", bret, WSAGetLastError());
8485
8486 /* ConnectEx needs a bound socket */
8487 memset(&conaddress, 0, sizeof(conaddress));
8488 conaddress.sin_family = AF_INET;
8489 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8490 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8491 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8492
8493 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, NULL);
8494 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "ConnectEx on a NULL overlapped "
8495 "returned %d + errno %d\n", bret, WSAGetLastError());
8496
8497 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8498
8499 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8500 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
8501 "returned %d + errno %d\n", bret, WSAGetLastError());
8502 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8503 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %ld + errno %ld\n", dwret, GetLastError());
8504
8505 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8506 ok(bret, "Connecting failed, error %ld\n", GetLastError());
8507 ok(bytesReturned == 0, "Bytes sent is %ld\n", bytesReturned);
8508
8509 closesocket(connector);
8510 connector = socket(AF_INET, SOCK_STREAM, 0);
8511 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8512 /* ConnectEx needs a bound socket */
8513 memset(&conaddress, 0, sizeof(conaddress));
8514 conaddress.sin_family = AF_INET;
8515 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8516 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8517 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8518
8519 acceptor = accept(listener, NULL, NULL);
8520 ok(acceptor != INVALID_SOCKET, "failed to accept socket, error %u\n", WSAGetLastError());
8521
8522 buffer[0] = '1';
8523 buffer[1] = '2';
8524 buffer[2] = '3';
8525 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, buffer, 3, &bytesReturned, &overlapped);
8526 memset(buffer, 0, 3);
8527 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
8528 "returned %d + errno %d\n", bret, WSAGetLastError());
8529 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8530 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %ld + errno %ld\n", dwret, GetLastError());
8531
8532 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8533 ok(bret, "Connecting failed, error %ld\n", GetLastError());
8534 ok(bytesReturned == 3, "Bytes sent is %ld\n", bytesReturned);
8535
8536 acceptor = accept(listener, NULL, NULL);
8537 ok(acceptor != INVALID_SOCKET, "could not accept socket error %d\n", WSAGetLastError());
8538
8539 bytesReturned = recv(acceptor, buffer, 3, 0);
8540 buffer[4] = 0;
8541 ok(bytesReturned == 3, "Didn't get all sent data, got only %ld\n", bytesReturned);
8542 ok(buffer[0] == '1' && buffer[1] == '2' && buffer[2] == '3',
8543 "Failed to get the right data, expected '123', got '%s'\n", buffer);
8544
8545 WSASetLastError(0xdeadbeef);
8546 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8547 ok(iret == -1, "got %d\n", iret);
8548 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8549
8550 WSASetLastError(0xdeadbeef);
8551 iret = connect(acceptor, (struct sockaddr *)&address, sizeof(address));
8552 ok(iret == -1, "got %d\n", iret);
8553 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8554
8555 WSASetLastError(0xdeadbeef);
8556 overlapped.Internal = 0xdeadbeef;
8557 overlapped.InternalHigh = 0xdeadbeef;
8558 bret = pConnectEx(connector, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8559 ok(!bret, "got %d\n", bret);
8560 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8561 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8562 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8563
8564 WSASetLastError(0xdeadbeef);
8565 overlapped.Internal = 0xdeadbeef;
8566 overlapped.InternalHigh = 0xdeadbeef;
8567 bret = pConnectEx(acceptor, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8568 ok(!bret, "got %d\n", bret);
8569 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8570 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8571 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8572
8573 closesocket(connector);
8574 closesocket(acceptor);
8575
8576 tcp_socketpair(&connector, &acceptor);
8577
8578 WSASetLastError(0xdeadbeef);
8579 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8580 ok(iret == -1, "got %d\n", iret);
8581 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8582
8583 WSASetLastError(0xdeadbeef);
8584 iret = connect(acceptor, (struct sockaddr *)&address, sizeof(address));
8585 ok(iret == -1, "got %d\n", iret);
8586 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8587
8588 WSASetLastError(0xdeadbeef);
8589 overlapped.Internal = 0xdeadbeef;
8590 overlapped.InternalHigh = 0xdeadbeef;
8591 bret = pConnectEx(connector, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8592 ok(!bret, "got %d\n", bret);
8593 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8594 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8595 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8596
8597 WSASetLastError(0xdeadbeef);
8598 overlapped.Internal = 0xdeadbeef;
8599 overlapped.InternalHigh = 0xdeadbeef;
8600 bret = pConnectEx(acceptor, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8601 ok(!bret, "got %d\n", bret);
8602 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8603 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8604 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8605
8606 closesocket(connector);
8607 closesocket(acceptor);
8608
8609 /* Connect with error */
8610
8611 connector = socket(AF_INET, SOCK_STREAM, 0);
8612 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8613 /* ConnectEx needs a bound socket */
8614 memset(&conaddress, 0, sizeof(conaddress));
8615 conaddress.sin_family = AF_INET;
8616 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8617 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8618 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8619
8620 address.sin_port = htons(1);
8621
8622 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8623 ok(bret == FALSE && GetLastError() == ERROR_IO_PENDING, "ConnectEx to bad destination failed: "
8624 "returned %d + errno %ld\n", bret, GetLastError());
8625 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8626 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %ld + errno %ld\n", dwret, GetLastError());
8627
8628 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8629 ok(bret == FALSE && GetLastError() == ERROR_CONNECTION_REFUSED,
8630 "Connecting to a disconnected host returned error %d - %d\n", bret, WSAGetLastError());
8631
8632 WSACloseEvent(overlapped.hEvent);
8633 closesocket(connector);
8634
8635 if (0)
8636 {
8637 /* Wait in connect() is alertable. This may take a very long time before connection fails,
8638 * so disable the test. Testing with localhost is unreliable as that may avoid waiting in
8639 * accept(). */
8640 connector = socket(AF_INET, SOCK_STREAM, 0);
8641 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8642 address.sin_addr.s_addr = inet_addr("8.8.8.8");
8643 address.sin_port = htons(255);
8644
8645 apc_count = 0;
8646 SleepEx(0, TRUE);
8647 ok(apc_count == 0, "got apc_count %d.\n", apc_count);
8648 bret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
8649 ok(bret, "QueueUserAPC returned %d\n", bret);
8650 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8651 ok(apc_count == 1, "got apc_count %d.\n", apc_count);
8652 ok(iret == -1 && (WSAGetLastError() == WSAECONNREFUSED || WSAGetLastError() == WSAETIMEDOUT),
8653 "unexpected iret %d, error %d.\n", iret, WSAGetLastError());
8654 closesocket(connector);
8655 }
8656
8657 /* Test connect after previous connect attempt failure. */
8658 connector = socket(AF_INET, SOCK_STREAM, 0);
8659 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8660
8661 conaddress.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
8662 conaddress.sin_port = htons(255);
8663 iret = connect(connector, (struct sockaddr *)&conaddress, sizeof(conaddress));
8664 ok(iret == -1, "connection succeeded.\n");
8665
8666 ok(WSAGetLastError() == WSAECONNREFUSED, "got error %u\n", WSAGetLastError());
8667 set_blocking( connector, FALSE );
8668 iret = getsockname(listener, (struct sockaddr*)&address, &addrlen);
8669 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
8670
8671 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8672 ok(iret == -1 && WSAGetLastError() == WSAEWOULDBLOCK, "unexpected iret %d, error %d.\n",
8673 iret, WSAGetLastError());
8674 acceptor = accept(listener, NULL, NULL);
8675 ok(acceptor != INVALID_SOCKET, "could not accept socket error %d\n", WSAGetLastError());
8676
8677 closesocket(acceptor);
8678 closesocket(connector);
8679 closesocket(listener);
8680 }
8681
8682 static void test_AcceptEx(void)
8683 {
8684 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
8685 SOCKET listener, acceptor, acceptor2, connector, connector2;
8686 struct sockaddr_in bindAddress, peerAddress, *readBindAddress, *readRemoteAddress;
8687 int socklen, iret, localSize = sizeof(struct sockaddr_in), remoteSize = localSize;
8688 GUID acceptExGuid = WSAID_ACCEPTEX, getAcceptExGuid = WSAID_GETACCEPTEXSOCKADDRS;
8689 GUID connectex_guid = WSAID_CONNECTEX;
8690 LPFN_ACCEPTEX pAcceptEx = NULL;
8691 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs = NULL;
8692 LPFN_CONNECTEX pConnectEx = NULL;
8693 fd_set fds_accept, fds_send;
8694 static const struct timeval timeout = {1, 0};
8695 char buffer[1024], ipbuffer[32];
8696 OVERLAPPED overlapped = {0}, overlapped2 = {0};
8697 DWORD bytesReturned, dwret;
8698 BOOL bret;
8699
8700 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8701 overlapped2.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8702
8703 listener = socket(AF_INET, SOCK_STREAM, 0);
8704 ok(listener != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8705
8706 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8707 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8708
8709 memset(&bindAddress, 0, sizeof(bindAddress));
8710 bindAddress.sin_family = AF_INET;
8711 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8712 iret = bind(listener, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8713 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8714
8715 socklen = sizeof(bindAddress);
8716 iret = getsockname(listener, (struct sockaddr*)&bindAddress, &socklen);
8717 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
8718
8719 iret = set_blocking(listener, FALSE);
8720 ok(!iret, "Failed to set nonblocking, error %u\n", WSAGetLastError());
8721
8722 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
8723 &pAcceptEx, sizeof(pAcceptEx), &bytesReturned, NULL, NULL);
8724 ok(!iret, "Failed to get AcceptEx, error %u\n", WSAGetLastError());
8725
8726 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &getAcceptExGuid, sizeof(getAcceptExGuid),
8727 &pGetAcceptExSockaddrs, sizeof(pGetAcceptExSockaddrs), &bytesReturned, NULL, NULL);
8728 ok(!iret, "Failed to get GetAcceptExSockaddrs, error %u\n", WSAGetLastError());
8729
8730 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectex_guid, sizeof(connectex_guid),
8731 &pConnectEx, sizeof(pConnectEx), &bytesReturned, NULL, NULL);
8732 ok(!iret, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
8733
8734 overlapped.Internal = 0xdeadbeef;
8735 bret = pAcceptEx(INVALID_SOCKET, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8736 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8737 &bytesReturned, &overlapped);
8738 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid listening socket "
8739 "returned %d + errno %d\n", bret, WSAGetLastError());
8740 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8741
8742 overlapped.Internal = 0xdeadbeef;
8743 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8744 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8745 &bytesReturned, &overlapped);
8746 todo_wine
8747 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on a non-listening socket "
8748 "returned %d + errno %d\n", bret, WSAGetLastError());
8749 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8750 if (!bret && WSAGetLastError() == ERROR_IO_PENDING)
8751 CancelIo((HANDLE)listener);
8752
8753 iret = listen(listener, 5);
8754 ok(!iret, "failed to listen, error %lu\n", GetLastError());
8755
8756 overlapped.Internal = 0xdeadbeef;
8757 bret = pAcceptEx(listener, INVALID_SOCKET, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8758 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8759 &bytesReturned, &overlapped);
8760 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid accepting socket "
8761 "returned %d + errno %d\n", bret, WSAGetLastError());
8762 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8763
8764 overlapped.Internal = 0xdeadbeef;
8765 bret = pAcceptEx(listener, acceptor, NULL, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8766 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8767 &bytesReturned, &overlapped);
8768 todo_wine ok(bret == FALSE && WSAGetLastError() == WSAEFAULT,
8769 "AcceptEx on NULL buffer returned %d + errno %d\n", bret, WSAGetLastError());
8770 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8771
8772 overlapped.Internal = 0xdeadbeef;
8773 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
8774 &bytesReturned, &overlapped);
8775 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING,
8776 "AcceptEx on too small local address size returned %d + errno %d\n",
8777 bret, WSAGetLastError());
8778 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8779
8780 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8781 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
8782 iret = connect(connector, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
8783 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
8784 iret = getsockname(connector, (struct sockaddr *)&peerAddress, &remoteSize);
8785 ok(!iret, "getsockname failed, error %u\n", WSAGetLastError());
8786
8787 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8788 ok(!dwret, "wait failed\n");
8789 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8790 ok(bret, "got error %lu\n", GetLastError());
8791 ok(!(NTSTATUS)overlapped.Internal, "got %#Ix\n", overlapped.Internal);
8792 ok(!bytesReturned, "got size %lu\n", bytesReturned);
8793
8794 readBindAddress = readRemoteAddress = (struct sockaddr_in *)0xdeadbeef;
8795 localSize = remoteSize = 0xdeadbeef;
8796 pGetAcceptExSockaddrs(buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
8797 (struct sockaddr **)&readBindAddress, &localSize, (struct sockaddr **)&readRemoteAddress, &remoteSize);
8798 todo_wine ok(readBindAddress == (struct sockaddr_in *)0xdeadbeef, "got local addr %p\n", readBindAddress);
8799 ok(!memcmp(readRemoteAddress, &peerAddress, sizeof(peerAddress)), "remote addr didn't match\n");
8800 todo_wine ok(localSize == 0xdeadbeef, "got local size %u\n", localSize);
8801 ok(remoteSize == sizeof(struct sockaddr_in), "got remote size %u\n", remoteSize);
8802
8803 closesocket(connector);
8804 closesocket(acceptor);
8805
8806 /* A UDP socket cannot be accepted into. */
8807
8808 acceptor = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
8809
8810 overlapped.Internal = 0xdeadbeef;
8811 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8812 ok(!bret, "expected failure\n");
8813 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8814 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8815 if (WSAGetLastError() == ERROR_IO_PENDING)
8816 CancelIo((HANDLE)listener);
8817
8818 closesocket(acceptor);
8819
8820 /* A bound socket cannot be accepted into. */
8821
8822 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8823 iret = bind(acceptor, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
8824 ok(!iret, "got error %u\n", WSAGetLastError());
8825
8826 overlapped.Internal = 0xdeadbeef;
8827 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8828 ok(!bret, "expected failure\n");
8829 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8830 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8831 if (WSAGetLastError() == ERROR_IO_PENDING)
8832 CancelIo((HANDLE)listener);
8833
8834 closesocket(acceptor);
8835
8836 /* A connected socket cannot be accepted into. */
8837
8838 tcp_socketpair(&acceptor, &acceptor2);
8839
8840 overlapped.Internal = 0xdeadbeef;
8841 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8842 ok(!bret, "expected failure\n");
8843 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8844 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8845 if (WSAGetLastError() == ERROR_IO_PENDING)
8846 CancelIo((HANDLE)listener);
8847
8848 overlapped.Internal = 0xdeadbeef;
8849 bret = pAcceptEx(listener, acceptor2, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8850 ok(!bret, "expected failure\n");
8851 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8852 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8853 if (WSAGetLastError() == ERROR_IO_PENDING)
8854 CancelIo((HANDLE)listener);
8855
8856 closesocket(acceptor);
8857 closesocket(acceptor2);
8858
8859 /* Pass an insufficient local address size. */
8860
8861 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8862 ok(acceptor != -1, "failed to create socket, error %u\n", WSAGetLastError());
8863
8864 overlapped.Internal = 0xdeadbeef;
8865 bret = pAcceptEx(listener, acceptor, buffer, 0, 3,
8866 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8867 ok(!bret && WSAGetLastError() == ERROR_IO_PENDING, "got %d, error %u\n", bret, WSAGetLastError());
8868 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got %#Ix\n", overlapped.Internal);
8869
8870 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8871 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
8872 iret = connect(connector, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
8873 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
8874
8875 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8876 ok(!dwret, "wait failed\n");
8877 bytesReturned = 0xdeadbeef;
8878 SetLastError(0xdeadbeef);
8879 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8880 ok(!bret, "expected failure\n");
8881 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got error %lu\n", GetLastError());
8882 ok((NTSTATUS)overlapped.Internal == STATUS_BUFFER_TOO_SMALL, "got %#Ix\n", overlapped.Internal);
8883 ok(!bytesReturned, "got size %lu\n", bytesReturned);
8884
8885 closesocket(acceptor);
8886
8887 /* The above connection request is not accepted. */
8888 acceptor = accept(listener, NULL, NULL);
8889 todo_wine ok(acceptor != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
8890 closesocket(acceptor);
8891
8892 closesocket(connector);
8893
8894 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8895 ok(acceptor != -1, "failed to create socket, error %u\n", WSAGetLastError());
8896
8897 overlapped.Internal = 0xdeadbeef;
8898 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 4,
8899 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8900 ok(!bret && WSAGetLastError() == ERROR_IO_PENDING, "got %d, error %u\n", bret, WSAGetLastError());
8901 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got %#Ix\n", overlapped.Internal);
8902
8903 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8904 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
8905 iret = connect(connector, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
8906 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
8907
8908 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8909 ok(!dwret, "wait failed\n");
8910 bytesReturned = 0xdeadbeef;
8911 SetLastError(0xdeadbeef);
8912 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8913 todo_wine ok(!bret, "expected failure\n");
8914 todo_wine ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got error %lu\n", GetLastError());
8915 todo_wine ok((NTSTATUS)overlapped.Internal == STATUS_BUFFER_TOO_SMALL, "got %#Ix\n", overlapped.Internal);
8916 ok(!bytesReturned, "got size %lu\n", bytesReturned);
8917
8918 closesocket(acceptor);
8919
8920 /* The above connection request is not accepted. */
8921 acceptor = accept(listener, NULL, NULL);
8922 todo_wine ok(acceptor != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
8923 closesocket(acceptor);
8924
8925 closesocket(connector);
8926
8927 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8928 ok(acceptor != -1, "failed to create socket, error %u\n", WSAGetLastError());
8929
8930 overlapped.Internal = 0xdeadbeef;
8931 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 15,
8932 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8933 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx on too small local address "
8934 "size returned %d + errno %d\n",
8935 bret, WSAGetLastError());
8936 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8937 bret = CancelIo((HANDLE) listener);
8938 ok(bret, "Failed to cancel pending accept socket\n");
8939
8940 overlapped.Internal = 0xdeadbeef;
8941 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16, 0,
8942 &bytesReturned, &overlapped);
8943 ok(bret == FALSE && WSAGetLastError() == WSAEFAULT,
8944 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
8945 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8946
8947 overlapped.Internal = 0xdeadbeef;
8948 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16,
8949 sizeof(struct sockaddr_in) + 15, &bytesReturned, &overlapped);
8950 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING,
8951 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
8952 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8953 bret = CancelIo((HANDLE) listener);
8954 ok(bret, "Failed to cancel pending accept socket\n");
8955
8956 bret = pAcceptEx(listener, acceptor, buffer, 0,
8957 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8958 &bytesReturned, NULL);
8959 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
8960 "returned %d + errno %d\n", bret, WSAGetLastError());
8961
8962 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, 0, &bytesReturned, NULL);
8963 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
8964 "returned %d + errno %d\n", bret, WSAGetLastError());
8965
8966 overlapped.Internal = 0xdeadbeef;
8967 bret = pAcceptEx(listener, acceptor, buffer, 0,
8968 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8969 &bytesReturned, &overlapped);
8970 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8971 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8972
8973 /* try to accept into the same socket twice */
8974 overlapped.Internal = 0xdeadbeef;
8975 bret = pAcceptEx(listener, acceptor, buffer, 0,
8976 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8977 &bytesReturned, &overlapped);
8978 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL,
8979 "AcceptEx on already pending socket returned %d + errno %d\n", bret, WSAGetLastError());
8980 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8981
8982 /* try to connect a socket that's being accepted into */
8983 iret = connect(acceptor, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8984 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL,
8985 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret, WSAGetLastError());
8986
8987 bret = pConnectEx(acceptor, (struct sockaddr *)&bindAddress, sizeof(bindAddress),
8988 NULL, 0, &bytesReturned, &overlapped2);
8989 ok(!bret, "expected failure\n");
8990 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8991
8992 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8993 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
8994 overlapped.Internal = 0xdeadbeef;
8995 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8996 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8997
8998 dwret = WaitForSingleObject(overlapped.hEvent, INFINITE);
8999 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
9000 ok(overlapped.Internal == STATUS_SUCCESS, "got %08lx\n", (ULONG)overlapped.Internal);
9001
9002 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9003 ok(bret, "GetOverlappedResult failed, error %ld\n", GetLastError());
9004 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %ld\n", bytesReturned);
9005
9006 /* Try to call getsockname on the acceptor socket.
9007 *
9008 * On Windows, this requires setting SO_UPDATE_ACCEPT_CONTEXT. */
9009 iret = setsockopt(acceptor, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, (char *)&listener, sizeof(SOCKET));
9010 ok(!iret, "Failed to set accept context %ld\n", GetLastError());
9011 iret = getsockname(acceptor, (struct sockaddr *)&peerAddress, &remoteSize);
9012 ok(!iret, "getsockname failed.\n");
9013 ok(remoteSize == sizeof(struct sockaddr_in), "got remote size %u\n", remoteSize);
9014
9015 closesocket(connector);
9016 connector = INVALID_SOCKET;
9017 closesocket(acceptor);
9018
9019 /* Test short reads */
9020
9021 acceptor = socket(AF_INET, SOCK_STREAM, 0);
9022 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9023 connector = socket(AF_INET, SOCK_STREAM, 0);
9024 ok(connector != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9025 overlapped.Internal = 0xdeadbeef;
9026 bret = pAcceptEx(listener, acceptor, buffer, 2,
9027 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9028 &bytesReturned, &overlapped);
9029 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
9030 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
9031
9032 /* AcceptEx() still won't complete until we send data */
9033 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9034 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
9035
9036 dwret = WaitForSingleObject(overlapped.hEvent, 0);
9037 ok(dwret == WAIT_TIMEOUT, "Waiting for accept event timeout failed with %ld + errno %ld\n", dwret, GetLastError());
9038 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
9039
9040 iret = getsockname( connector, (struct sockaddr *)&peerAddress, &remoteSize);
9041 ok( !iret, "getsockname failed.\n");
9042
9043 /* AcceptEx() could complete any time now */
9044 iret = send(connector, buffer, 1, 0);
9045 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
9046
9047 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
9048 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
9049 ok(overlapped.Internal == STATUS_SUCCESS, "got %08lx\n", (ULONG)overlapped.Internal);
9050
9051 /* Check if the buffer from AcceptEx is decoded correctly */
9052 pGetAcceptExSockaddrs(buffer, 2, sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9053 (struct sockaddr **)&readBindAddress, &localSize,
9054 (struct sockaddr **)&readRemoteAddress, &remoteSize);
9055 strcpy( ipbuffer, inet_ntoa(readBindAddress->sin_addr));
9056 ok( readBindAddress->sin_addr.s_addr == bindAddress.sin_addr.s_addr,
9057 "Local socket address is different %s != %s\n",
9058 ipbuffer, inet_ntoa(bindAddress.sin_addr));
9059 ok( readBindAddress->sin_port == bindAddress.sin_port,
9060 "Local socket port is different: %d != %d\n",
9061 readBindAddress->sin_port, bindAddress.sin_port);
9062 strcpy( ipbuffer, inet_ntoa(readRemoteAddress->sin_addr));
9063 ok( readRemoteAddress->sin_addr.s_addr == peerAddress.sin_addr.s_addr,
9064 "Remote socket address is different %s != %s\n",
9065 ipbuffer, inet_ntoa(peerAddress.sin_addr));
9066 ok( readRemoteAddress->sin_port == peerAddress.sin_port,
9067 "Remote socket port is different: %d != %d\n",
9068 readRemoteAddress->sin_port, peerAddress.sin_port);
9069
9070 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9071 ok(bret, "GetOverlappedResult failed, error %ld\n", GetLastError());
9072 ok(bytesReturned == 1, "bytesReturned isn't supposed to be %ld\n", bytesReturned);
9073
9074 closesocket(connector);
9075 connector = INVALID_SOCKET;
9076 closesocket(acceptor);
9077
9078 /* Test CF_DEFER & AcceptEx interaction */
9079
9080 acceptor = socket(AF_INET, SOCK_STREAM, 0);
9081 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9082 connector = socket(AF_INET, SOCK_STREAM, 0);
9083 ok(connector != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9084 connector2 = socket(AF_INET, SOCK_STREAM, 0);
9085 ok(connector2 != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9086
9087 iret = set_blocking(connector, FALSE);
9088 ok(!iret, "failed to set nonblocking, error %lu\n", GetLastError());
9089 iret = set_blocking(connector2, FALSE);
9090 ok(!iret, "failed to set nonblocking, error %lu\n", GetLastError());
9091
9092 /* Connect socket #1 */
9093 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9094 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
9095
9096 buffer[0] = '0';
9097
9098 FD_ZERO(&fds_accept);
9099 FD_SET(listener, &fds_accept);
9100 iret = select(0, &fds_accept, NULL, NULL, &timeout);
9101 ok(iret == 1, "wait timed out\n");
9102
9103 acceptor2 = WSAAccept(listener, NULL, NULL, AlwaysDeferConditionFunc, 0);
9104 ok(acceptor2 == INVALID_SOCKET, "expected failure\n");
9105 ok(WSAGetLastError() == WSATRY_AGAIN, "got error %u\n", WSAGetLastError());
9106 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16,
9107 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
9108 ok(!bret, "expected failure\n");
9109 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
9110
9111 FD_ZERO(&fds_send);
9112 FD_SET(connector, &fds_send);
9113 iret = select(0, NULL, &fds_send, NULL, &timeout);
9114 ok(iret == 1, "wait timed out\n");
9115
9116 iret = send(connector, "1", 1, 0);
9117 ok(iret == 1, "got ret %d, error %u\n", iret, WSAGetLastError());
9118
9119 iret = connect(connector2, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
9120 ok(iret == SOCKET_ERROR, "expected failure\n");
9121 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
9122
9123 iret = select(0, &fds_accept, NULL, NULL, &timeout);
9124 ok(iret == 1, "wait timed out\n");
9125
9126 acceptor2 = accept(listener, NULL, NULL);
9127 ok(acceptor2 != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
9128 closesocket(acceptor2);
9129
9130 FD_ZERO(&fds_send);
9131 FD_SET(connector2, &fds_send);
9132 iret = select(0, NULL, &fds_send, NULL, &timeout);
9133 ok(iret == 1, "wait timed out\n");
9134
9135 iret = send(connector2, "2", 1, 0);
9136 ok(iret == 1, "got ret %d, error %u\n", iret, WSAGetLastError());
9137
9138 dwret = WaitForSingleObject(overlapped.hEvent, 0);
9139 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
9140
9141 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9142 ok(bret, "GetOverlappedResult failed, error %ld\n", GetLastError());
9143 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %ld\n", bytesReturned);
9144
9145 set_blocking(acceptor, TRUE);
9146 iret = recv( acceptor, buffer, 2, 0);
9147 ok(iret == 1, "Failed to get data, %d, errno: %d\n", iret, WSAGetLastError());
9148 ok(buffer[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer[0]);
9149
9150 closesocket(connector);
9151 closesocket(connector2);
9152 closesocket(acceptor);
9153
9154 /* clean up in case of failures */
9155 while ((acceptor = accept(listener, NULL, NULL)) != INVALID_SOCKET)
9156 closesocket(acceptor);
9157
9158 /* Disconnect during receive? */
9159
9160 acceptor = socket(AF_INET, SOCK_STREAM, 0);
9161 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9162 connector = socket(AF_INET, SOCK_STREAM, 0);
9163 ok(connector != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9164 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
9165 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9166 &bytesReturned, &overlapped);
9167 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
9168
9169 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9170 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
9171
9172 closesocket(connector);
9173 connector = INVALID_SOCKET;
9174
9175 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
9176 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
9177
9178 bytesReturned = 123456;
9179 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9180 ok(bret, "GetOverlappedResult failed, error %ld\n", GetLastError());
9181 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %ld\n", bytesReturned);
9182
9183 closesocket(acceptor);
9184
9185 /* Test closing with pending requests */
9186
9187 acceptor = socket(AF_INET, SOCK_STREAM, 0);
9188 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9189 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
9190 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9191 &bytesReturned, &overlapped);
9192 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
9193
9194 closesocket(acceptor);
9195
9196 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
9197 ok(dwret == WAIT_OBJECT_0,
9198 "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
9199 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9200 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %ld\n", GetLastError());
9201
9202 acceptor = socket(AF_INET, SOCK_STREAM, 0);
9203 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9204 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
9205 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9206 &bytesReturned, &overlapped);
9207 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
9208
9209 CancelIo((HANDLE) acceptor);
9210
9211 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
9212 ok(dwret == WAIT_TIMEOUT, "Waiting for timeout failed with %ld + errno %ld\n", dwret, GetLastError());
9213
9214 closesocket(acceptor);
9215
9216 acceptor = socket(AF_INET, SOCK_STREAM, 0);
9217 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9218 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
9219 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9220 &bytesReturned, &overlapped);
9221 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
9222
9223 closesocket(listener);
9224
9225 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
9226 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
9227
9228 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9229 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %ld\n", GetLastError());
9230
9231 CloseHandle(overlapped.hEvent);
9232 CloseHandle(overlapped2.hEvent);
9233 closesocket(acceptor);
9234 closesocket(connector2);
9235 }
9236
9237 static void test_shutdown(void)
9238 {
9239 struct sockaddr_in addr, server_addr, client_addr;
9240 SOCKET listener, client, server;
9241 OVERLAPPED overlapped = {0};
9242 DWORD size, flags = 0;
9243 int ret, addrlen;
9244 char buffer[5];
9245 WSABUF wsabuf;
9246
9247 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9248 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9249 ok(listener != INVALID_SOCKET, "failed to create listener socket, error %d\n", WSAGetLastError());
9250
9251 memset(&addr, 0, sizeof(addr));
9252 addr.sin_family = AF_INET;
9253 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
9254 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
9255 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9256 addrlen = sizeof(server_addr);
9257 ret = getsockname(listener, (struct sockaddr *)&server_addr, &addrlen);
9258 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
9259
9260 ret = listen(listener, 1);
9261 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
9262
9263 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9264 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9265
9266 WSASetLastError(0xdeadbeef);
9267 ret = shutdown(client, SD_SEND);
9268 ok(ret == -1, "expected failure\n");
9269 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9270
9271 WSASetLastError(0xdeadbeef);
9272 ret = shutdown(client, SD_RECEIVE);
9273 ok(ret == -1, "expected failure\n");
9274 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9275
9276 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9277 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9278 server = accept(listener, NULL, NULL);
9279 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9280 set_blocking(client, FALSE);
9281
9282 WSASetLastError(0xdeadbeef);
9283 ret = shutdown(client, SD_SEND);
9284 ok(!ret, "expected success\n");
9285 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9286
9287 WSASetLastError(0xdeadbeef);
9288 ret = shutdown(client, SD_SEND);
9289 ok(!ret, "expected success\n");
9290 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9291
9292 WSASetLastError(0xdeadbeef);
9293 ret = send(client, "test", 5, 0);
9294 ok(ret == -1, "got %d\n", ret);
9295 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9296
9297 ret = recv(server, buffer, sizeof(buffer), 0);
9298 ok(!ret, "got %d\n", ret);
9299 ret = recv(server, buffer, sizeof(buffer), 0);
9300 ok(!ret, "got %d\n", ret);
9301
9302 WSASetLastError(0xdeadbeef);
9303 ret = shutdown(server, SD_RECEIVE);
9304 ok(!ret, "expected success\n");
9305 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9306
9307 WSASetLastError(0xdeadbeef);
9308 ret = recv(server, buffer, sizeof(buffer), 0);
9309 ok(ret == -1, "got %d\n", ret);
9310 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9311
9312 ret = send(server, "test", 5, 0);
9313 ok(ret == 5, "got %d\n", ret);
9314
9315 ret = sync_recv(client, buffer, sizeof(buffer), 0);
9316 ok(ret == 5, "got %d\n", ret);
9317 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, ret));
9318
9319 WSASetLastError(0xdeadbeef);
9320 ret = shutdown(client, SD_RECEIVE);
9321 ok(!ret, "expected success\n");
9322 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9323
9324 WSASetLastError(0xdeadbeef);
9325 ret = recv(client, buffer, sizeof(buffer), 0);
9326 ok(ret == -1, "got %d\n", ret);
9327 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9328
9329 WSASetLastError(0xdeadbeef);
9330 ret = recv(client, buffer, sizeof(buffer), 0);
9331 ok(ret == -1, "got %d\n", ret);
9332 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9333
9334 WSASetLastError(0xdeadbeef);
9335 ret = shutdown(server, SD_SEND);
9336 ok(!ret, "expected success\n");
9337 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9338
9339 WSASetLastError(0xdeadbeef);
9340 ret = send(server, "test", 5, 0);
9341 ok(ret == -1, "got %d\n", ret);
9342 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9343
9344 addrlen = sizeof(addr);
9345 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
9346 ok(!ret, "got error %u\n", WSAGetLastError());
9347 ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
9348
9349 addrlen = sizeof(client_addr);
9350 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
9351 ok(!ret, "got error %u\n", WSAGetLastError());
9352 addrlen = sizeof(addr);
9353 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
9354 ok(!ret, "got error %u\n", WSAGetLastError());
9355 ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
9356
9357 WSASetLastError(0xdeadbeef);
9358 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9359 ok(ret == -1, "got %d\n", ret);
9360 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
9361
9362 WSASetLastError(0xdeadbeef);
9363 ret = shutdown(client, 0xdeadbeef);
9364 ok(ret == -1, "expected failure\n");
9365 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
9366
9367 closesocket(client);
9368 closesocket(server);
9369
9370 /* Test SD_BOTH. */
9371
9372 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9373 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9374 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9375 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9376 server = accept(listener, NULL, NULL);
9377 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9378
9379 WSASetLastError(0xdeadbeef);
9380 ret = shutdown(client, SD_BOTH);
9381 ok(!ret, "expected success\n");
9382 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9383
9384 WSASetLastError(0xdeadbeef);
9385 ret = recv(client, buffer, sizeof(buffer), 0);
9386 ok(ret == -1, "got %d\n", ret);
9387 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9388
9389 WSASetLastError(0xdeadbeef);
9390 ret = send(client, "test", 5, 0);
9391 ok(ret == -1, "got %d\n", ret);
9392 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9393
9394 ret = recv(server, buffer, sizeof(buffer), 0);
9395 ok(!ret, "got %d\n", ret);
9396
9397 WSASetLastError(0xdeadbeef);
9398 ret = shutdown(server, SD_BOTH);
9399 ok(!ret, "expected success\n");
9400 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9401
9402 WSASetLastError(0xdeadbeef);
9403 ret = recv(server, buffer, sizeof(buffer), 0);
9404 ok(ret == -1, "got %d\n", ret);
9405 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9406
9407 WSASetLastError(0xdeadbeef);
9408 ret = send(server, "test", 5, 0);
9409 ok(ret == -1, "got %d\n", ret);
9410 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9411
9412 addrlen = sizeof(addr);
9413 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
9414 ok(!ret, "got error %u\n", WSAGetLastError());
9415 ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
9416
9417 addrlen = sizeof(client_addr);
9418 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
9419 ok(!ret, "got error %u\n", WSAGetLastError());
9420 addrlen = sizeof(addr);
9421 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
9422 ok(!ret, "got error %u\n", WSAGetLastError());
9423 ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
9424
9425 closesocket(client);
9426 closesocket(server);
9427
9428 /* Send data to a peer which is closed. */
9429
9430 tcp_socketpair(&client, &server);
9431
9432 WSASetLastError(0xdeadbeef);
9433 ret = shutdown(client, SD_SEND);
9434 ok(!ret, "expected success\n");
9435 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9436 closesocket(client);
9437
9438 ret = send(server, "test", 5, 0);
9439 ok(ret == 5, "got %d\n", ret);
9440
9441 WSASetLastError(0xdeadbeef);
9442 ret = recv(server, buffer, sizeof(buffer), 0);
9443 ok(ret == -1, "got %d\n", ret);
9444 todo_wine ok(WSAGetLastError() == WSAECONNABORTED, "got error %u\n", WSAGetLastError());
9445
9446 closesocket(server);
9447
9448 /* Test shutting down with async I/O pending. */
9449
9450 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9451 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9452 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9453 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9454 server = accept(listener, NULL, NULL);
9455 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9456 set_blocking(client, FALSE);
9457
9458 wsabuf.buf = buffer;
9459 wsabuf.len = sizeof(buffer);
9460 WSASetLastError(0xdeadbeef);
9461 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
9462 ok(ret == -1, "got %d\n", ret);
9463 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
9464
9465 ret = shutdown(client, SD_RECEIVE);
9466 ok(!ret, "got error %u\n", WSAGetLastError());
9467
9468 WSASetLastError(0xdeadbeef);
9469 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
9470 ok(ret == -1, "got %d\n", ret);
9471 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9472
9473 ret = send(server, "test", 5, 0);
9474 ok(ret == 5, "got %d\n", ret);
9475
9476 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9477 ok(!ret, "wait timed out\n");
9478 size = 0xdeadbeef;
9479 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
9480 ok(ret, "got error %lu\n", GetLastError());
9481 ok(size == 5, "got size %lu\n", size);
9482 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, size));
9483
9484 WSASetLastError(0xdeadbeef);
9485 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
9486 ok(ret == -1, "got %d\n", ret);
9487 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9488
9489 WSASetLastError(0xdeadbeef);
9490 ret = WSARecv(server, &wsabuf, 1, &size, &flags, &overlapped, NULL);
9491 ok(ret == -1, "got %d\n", ret);
9492 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
9493
9494 ret = shutdown(client, SD_SEND);
9495 ok(!ret, "got error %u\n", WSAGetLastError());
9496
9497 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9498 ok(!ret, "wait timed out\n");
9499 size = 0xdeadbeef;
9500 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
9501 ok(ret, "got error %lu\n", GetLastError());
9502 ok(!size, "got size %lu\n", size);
9503
9504 closesocket(client);
9505 closesocket(server);
9506
9507 /* Test shutting down a listening socket. */
9508
9509 WSASetLastError(0xdeadbeef);
9510 ret = shutdown(listener, SD_SEND);
9511 ok(ret == -1, "expected failure\n");
9512 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9513
9514 WSASetLastError(0xdeadbeef);
9515 ret = shutdown(listener, SD_RECEIVE);
9516 ok(ret == -1, "expected failure\n");
9517 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9518
9519 closesocket(listener);
9520
9521 /* Test shutting down UDP sockets. */
9522
9523 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
9524 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
9525 memset(&addr, 0, sizeof(addr));
9526 addr.sin_family = AF_INET;
9527 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
9528 ret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
9529 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9530 addrlen = sizeof(server_addr);
9531 ret = getsockname(server, (struct sockaddr *)&server_addr, &addrlen);
9532 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
9533 set_blocking(server, FALSE);
9534
9535 WSASetLastError(0xdeadbeef);
9536 ret = shutdown(server, SD_RECEIVE);
9537 ok(!ret, "expected success\n");
9538 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9539
9540 WSASetLastError(0xdeadbeef);
9541 ret = recvfrom(server, buffer, sizeof(buffer), 0, NULL, NULL);
9542 ok(ret == -1, "got %d\n", ret);
9543 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9544
9545 ret = sendto(client, "test", 5, 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
9546 ok(ret == 5, "got %d\n", ret);
9547
9548 WSASetLastError(0xdeadbeef);
9549 ret = shutdown(client, SD_SEND);
9550 ok(!ret, "expected success\n");
9551 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9552
9553 WSASetLastError(0xdeadbeef);
9554 ret = shutdown(client, SD_SEND);
9555 ok(!ret, "expected success\n");
9556 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9557
9558 WSASetLastError(0xdeadbeef);
9559 ret = sendto(client, "test", 5, 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
9560 ok(ret == -1, "got %d\n", ret);
9561 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9562
9563 closesocket(client);
9564 closesocket(server);
9565
9566 CloseHandle(overlapped.hEvent);
9567 }
9568
9569 static void test_DisconnectEx(void)
9570 {
9571 struct sockaddr_in server_addr, client_addr, addr;
9572 GUID disconnectex_guid = WSAID_DISCONNECTEX;
9573 SOCKET listener, server, client;
9574 LPFN_DISCONNECTEX pDisconnectEx;
9575 OVERLAPPED overlapped = {0};
9576 int addrlen, ret;
9577 char buffer[5];
9578 DWORD size;
9579
9580 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
9581
9582 client = socket(AF_INET, SOCK_STREAM, 0);
9583 ok(client != INVALID_SOCKET, "failed to create connector socket, error %u\n", WSAGetLastError());
9584
9585 ret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &disconnectex_guid, sizeof(disconnectex_guid),
9586 &pDisconnectEx, sizeof(pDisconnectEx), &size, NULL, NULL);
9587 if (ret)
9588 {
9589 win_skip("WSAIoctl failed to get DisconnectEx, error %d\n", WSAGetLastError());
9590 closesocket(client);
9591 return;
9592 }
9593
9594 listener = socket(AF_INET, SOCK_STREAM, 0);
9595 ok(listener != INVALID_SOCKET, "failed to create listener socket, error %d\n", WSAGetLastError());
9596
9597 memset(&addr, 0, sizeof(addr));
9598 addr.sin_family = AF_INET;
9599 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
9600 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
9601 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9602 addrlen = sizeof(server_addr);
9603 ret = getsockname(listener, (struct sockaddr *)&server_addr, &addrlen);
9604 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
9605 ret = listen(listener, 1);
9606 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
9607
9608 WSASetLastError(0xdeadbeef);
9609 ret = pDisconnectEx(INVALID_SOCKET, &overlapped, 0, 0);
9610 ok(!ret, "expected failure\n");
9611 ok(WSAGetLastError() == WSAENOTSOCK, "got error %u\n", WSAGetLastError());
9612
9613 WSASetLastError(0xdeadbeef);
9614 ret = pDisconnectEx(client, &overlapped, 0, 0);
9615 ok(!ret, "expected failure\n");
9616 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9617
9618 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9619 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9620 server = accept(listener, NULL, NULL);
9621 ok(server != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
9622
9623 WSASetLastError(0xdeadbeef);
9624 ret = pDisconnectEx(client, &overlapped, 0, 0);
9625 ok(!ret, "expected failure\n");
9626 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
9627
9628 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9629 ok(!ret, "wait timed out\n");
9630 size = 0xdeadbeef;
9631 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
9632 ok(ret, "got error %lu\n", GetLastError());
9633 ok(!size, "got size %lu\n", size);
9634
9635 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9636 ok(ret == -1, "expected failure\n");
9637 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
9638
9639 WSASetLastError(0xdeadbeef);
9640 ret = send(client, "test", 5, 0);
9641 ok(ret == -1, "expected failure\n");
9642 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9643
9644 ret = recv(server, buffer, sizeof(buffer), 0);
9645 ok(!ret, "got %d\n", ret);
9646
9647 ret = send(server, "test", 5, 0);
9648 ok(ret == 5, "got %d\n", ret);
9649
9650 ret = recv(client, buffer, sizeof(buffer), 0);
9651 ok(ret == 5, "got %d\n", ret);
9652 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, ret));
9653
9654 addrlen = sizeof(addr);
9655 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
9656 ok(!ret, "got error %u\n", WSAGetLastError());
9657 ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
9658
9659 addrlen = sizeof(client_addr);
9660 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
9661 ok(!ret, "got error %u\n", WSAGetLastError());
9662 addrlen = sizeof(addr);
9663 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
9664 ok(!ret, "got error %u\n", WSAGetLastError());
9665 ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
9666
9667 closesocket(client);
9668 closesocket(server);
9669
9670 /* Test the synchronous case. */
9671
9672 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9673 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9674 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9675 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9676 server = accept(listener, NULL, NULL);
9677 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9678
9679 WSASetLastError(0xdeadbeef);
9680 ret = pDisconnectEx(client, NULL, 0, 0);
9681 ok(ret, "expected success\n");
9682 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9683
9684 WSASetLastError(0xdeadbeef);
9685 ret = pDisconnectEx(client, NULL, 0, 0);
9686 ok(ret, "expected success\n");
9687 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9688
9689 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9690 ok(ret == -1, "expected failure\n");
9691 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
9692
9693 WSASetLastError(0xdeadbeef);
9694 ret = send(client, "test", 5, 0);
9695 ok(ret == -1, "expected failure\n");
9696 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9697
9698 ret = recv(server, buffer, sizeof(buffer), 0);
9699 ok(!ret, "got %d\n", ret);
9700
9701 ret = send(server, "test", 5, 0);
9702 ok(ret == 5, "got %d\n", ret);
9703
9704 ret = recv(client, buffer, sizeof(buffer), 0);
9705 ok(ret == 5, "got %d\n", ret);
9706 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, ret));
9707
9708 addrlen = sizeof(addr);
9709 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
9710 ok(!ret, "got error %u\n", WSAGetLastError());
9711 ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
9712
9713 addrlen = sizeof(client_addr);
9714 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
9715 ok(!ret, "got error %u\n", WSAGetLastError());
9716 addrlen = sizeof(addr);
9717 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
9718 ok(!ret, "got error %u\n", WSAGetLastError());
9719 ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
9720
9721 closesocket(client);
9722 closesocket(server);
9723
9724 closesocket(listener);
9725 CloseHandle(overlapped.hEvent);
9726 }
9727
9728 #define compare_file(h,s,o) compare_file2(h,s,o,__FILE__,__LINE__)
9729
9730 static void compare_file2(HANDLE handle, SOCKET sock, int offset, const char *file, int line)
9731 {
9732 char buf1[256], buf2[256];
9733 BOOL success;
9734 int i = 0;
9735
9736 SetFilePointer(handle, offset, NULL, FILE_BEGIN);
9737 while (1)
9738 {
9739 DWORD n1 = 0, n2 = 0;
9740
9741 success = ReadFile(handle, buf1, sizeof(buf1), &n1, NULL);
9742 ok_(file,line)(success, "Failed to read from file.\n");
9743 if (success && n1 == 0)
9744 break;
9745 else if(!success)
9746 return;
9747 n2 = recv(sock, buf2, n1, 0);
9748 ok_(file,line)(n1 == n2, "Block %d size mismatch (%ld != %ld)\n", i, n1, n2);
9749 ok_(file,line)(memcmp(buf1, buf2, n2) == 0, "Block %d failed\n", i);
9750 i++;
9751 }
9752 }
9753
9754 static void test_TransmitFile(void)
9755 {
9756 DWORD num_bytes, err, file_size, total_sent;
9757 GUID transmitFileGuid = WSAID_TRANSMITFILE;
9758 LPFN_TRANSMITFILE pTransmitFile = NULL;
9759 HANDLE file = INVALID_HANDLE_VALUE;
9760 char header_msg[] = "hello world";
9761 char footer_msg[] = "goodbye!!!";
9762 char system_ini_path[MAX_PATH];
9763 struct sockaddr_in bindAddress;
9764 TRANSMIT_FILE_BUFFERS buffers;
9765 SOCKET client, server, dest;
9766 WSAOVERLAPPED ov;
9767 char buf[256];
9768 int iret, len;
9769 BOOL bret;
9770
9771 memset( &ov, 0, sizeof(ov) );
9772
9773 /* Setup sockets for testing TransmitFile */
9774 client = socket(AF_INET, SOCK_STREAM, 0);
9775 ok(client != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9776 server = socket(AF_INET, SOCK_STREAM, 0);
9777 ok(server != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9778 iret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &transmitFileGuid, sizeof(transmitFileGuid),
9779 &pTransmitFile, sizeof(pTransmitFile), &num_bytes, NULL, NULL);
9780 ok(!iret, "failed to get TransmitFile, error %lu\n", GetLastError());
9781 GetSystemWindowsDirectoryA(system_ini_path, MAX_PATH );
9782 strcat(system_ini_path, "\\system.ini");
9783 file = CreateFileA(system_ini_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0x0, NULL);
9784 ok(file != INVALID_HANDLE_VALUE, "failed to open file, error %lu\n", GetLastError());
9785 file_size = GetFileSize(file, NULL);
9786
9787 /* Test TransmitFile with an invalid socket */
9788 bret = pTransmitFile(INVALID_SOCKET, file, 0, 0, NULL, NULL, 0);
9789 err = WSAGetLastError();
9790 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9791 ok(err == WSAENOTSOCK, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, WSAENOTSOCK);
9792
9793 /* Test a bogus TransmitFile without a connected socket */
9794 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, TF_REUSE_SOCKET);
9795 err = WSAGetLastError();
9796 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9797 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, WSAENOTCONN);
9798
9799 /* Setup a properly connected socket for transfers */
9800 memset(&bindAddress, 0, sizeof(bindAddress));
9801 bindAddress.sin_family = AF_INET;
9802 bindAddress.sin_port = htons(SERVERPORT+1);
9803 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
9804 iret = bind(server, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9805 ok(!iret, "failed to bind socket, error %lu\n", GetLastError());
9806 iret = listen(server, 1);
9807 ok(!iret, "failed to listen, error %lu\n", GetLastError());
9808 iret = connect(client, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9809 ok(!iret, "failed to connect, error %lu\n", GetLastError());
9810 len = sizeof(bindAddress);
9811 dest = accept(server, (struct sockaddr*)&bindAddress, &len);
9812 ok(dest != INVALID_SOCKET, "failed to accept, error %lu\n", GetLastError());
9813 iret = set_blocking(dest, FALSE);
9814 ok(!iret, "failed to set nonblocking, error %lu\n", GetLastError());
9815
9816 /* Test TransmitFile with no possible buffer */
9817 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
9818 ok(bret, "TransmitFile failed unexpectedly.\n");
9819 iret = recv(dest, buf, sizeof(buf), 0);
9820 ok(iret == -1, "Returned an unexpected buffer from TransmitFile (%d != -1).\n", iret);
9821
9822 /* Test TransmitFile with only buffer data */
9823 buffers.Head = &header_msg[0];
9824 buffers.HeadLength = sizeof(header_msg);
9825 buffers.Tail = &footer_msg[0];
9826 buffers.TailLength = sizeof(footer_msg);
9827 bret = pTransmitFile(client, NULL, 0, 0, NULL, &buffers, 0);
9828 ok(bret, "TransmitFile failed unexpectedly.\n");
9829 iret = recv(dest, buf, sizeof(buf), 0);
9830 ok(iret == sizeof(header_msg)+sizeof(footer_msg),
9831 "Returned an unexpected buffer from TransmitFile: %d\n", iret );
9832 ok(memcmp(&buf[0], &header_msg[0], sizeof(header_msg)) == 0,
9833 "TransmitFile header buffer did not match!\n");
9834 ok(memcmp(&buf[sizeof(header_msg)], &footer_msg[0], sizeof(footer_msg)) == 0,
9835 "TransmitFile footer buffer did not match!\n");
9836
9837 /* Test TransmitFile with only file data */
9838 bret = pTransmitFile(client, file, 0, 0, NULL, NULL, 0);
9839 ok(bret, "TransmitFile failed unexpectedly.\n");
9840 compare_file(file, dest, 0);
9841
9842 /* Test TransmitFile with both file and buffer data */
9843 buffers.Head = &header_msg[0];
9844 buffers.HeadLength = sizeof(header_msg);
9845 buffers.Tail = &footer_msg[0];
9846 buffers.TailLength = sizeof(footer_msg);
9847 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9848 bret = pTransmitFile(client, file, 0, 0, NULL, &buffers, 0);
9849 ok(bret, "TransmitFile failed unexpectedly.\n");
9850 iret = recv(dest, buf, sizeof(header_msg), 0);
9851 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)) == 0,
9852 "TransmitFile header buffer did not match!\n");
9853 compare_file(file, dest, 0);
9854 iret = recv(dest, buf, sizeof(footer_msg), 0);
9855 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)) == 0,
9856 "TransmitFile footer buffer did not match!\n");
9857
9858 /* Test overlapped TransmitFile */
9859 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
9860 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9861 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
9862 err = WSAGetLastError();
9863 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9864 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%ld != %d)\n",
9865 err, ERROR_IO_PENDING);
9866 iret = WaitForSingleObject(ov.hEvent, 2000);
9867 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
9868 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
9869 ok(total_sent == file_size,
9870 "Overlapped TransmitFile sent an unexpected number of bytes (%ld != %ld).\n",
9871 total_sent, file_size);
9872 compare_file(file, dest, 0);
9873
9874 /* Test overlapped TransmitFile w/ start offset */
9875 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
9876 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9877 ov.Offset = 10;
9878 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
9879 err = WSAGetLastError();
9880 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9881 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, ERROR_IO_PENDING);
9882 iret = WaitForSingleObject(ov.hEvent, 2000);
9883 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
9884 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
9885 ok(total_sent == (file_size - ov.Offset),
9886 "Overlapped TransmitFile sent an unexpected number of bytes (%ld != %ld).\n",
9887 total_sent, file_size - ov.Offset);
9888 compare_file(file, dest, ov.Offset);
9889
9890 /* Test overlapped TransmitFile w/ file and buffer data */
9891 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
9892 buffers.Head = &header_msg[0];
9893 buffers.HeadLength = sizeof(header_msg);
9894 buffers.Tail = &footer_msg[0];
9895 buffers.TailLength = sizeof(footer_msg);
9896 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9897 ov.Offset = 0;
9898 bret = pTransmitFile(client, file, 0, 0, &ov, &buffers, 0);
9899 err = WSAGetLastError();
9900 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9901 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, ERROR_IO_PENDING);
9902 iret = WaitForSingleObject(ov.hEvent, 2000);
9903 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
9904 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
9905 ok(total_sent == (file_size + buffers.HeadLength + buffers.TailLength),
9906 "Overlapped TransmitFile sent an unexpected number of bytes (%ld != %ld).\n",
9907 total_sent, file_size + buffers.HeadLength + buffers.TailLength);
9908 iret = recv(dest, buf, sizeof(header_msg), 0);
9909 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)) == 0,
9910 "TransmitFile header buffer did not match!\n");
9911 compare_file(file, dest, 0);
9912 iret = recv(dest, buf, sizeof(footer_msg), 0);
9913 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)) == 0,
9914 "TransmitFile footer buffer did not match!\n");
9915
9916 /* Test TransmitFile with a UDP datagram socket */
9917 closesocket(client);
9918 client = socket(AF_INET, SOCK_DGRAM, 0);
9919 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
9920 err = WSAGetLastError();
9921 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9922 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, WSAENOTCONN);
9923
9924 CloseHandle(file);
9925 CloseHandle(ov.hEvent);
9926 closesocket(client);
9927 closesocket(server);
9928 }
9929
9930 static void test_getpeername(void)
9931 {
9932 SOCKET sock;
9933 struct sockaddr_in sa, sa_out;
9934 SOCKADDR_STORAGE ss;
9935 int sa_len;
9936 const char buf[] = "hello world";
9937 int ret;
9938
9939 /* Test the parameter validation order. */
9940 ret = getpeername(INVALID_SOCKET, NULL, NULL);
9941 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9942 ok(WSAGetLastError() == WSAENOTSOCK,
9943 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
9944
9945 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
9946 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
9947
9948 ret = getpeername(sock, NULL, NULL);
9949 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9950 ok(WSAGetLastError() == WSAENOTCONN,
9951 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
9952
9953 memset(&sa, 0, sizeof(sa));
9954 sa.sin_family = AF_INET;
9955 sa.sin_port = htons(139);
9956 sa.sin_addr.s_addr = inet_addr("127.0.0.1");
9957
9958 /* sendto does not change a socket's connection state. */
9959 ret = sendto(sock, buf, sizeof(buf), 0, (struct sockaddr*)&sa, sizeof(sa));
9960 ok(ret != SOCKET_ERROR,
9961 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
9962
9963 ret = getpeername(sock, NULL, NULL);
9964 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9965 ok(WSAGetLastError() == WSAENOTCONN,
9966 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
9967
9968 ret = connect(sock, (struct sockaddr*)&sa, sizeof(sa));
9969 ok(ret == 0,
9970 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
9971
9972 ret = getpeername(sock, NULL, NULL);
9973 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9974 ok(WSAGetLastError() == WSAEFAULT,
9975 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9976
9977 /* Test crashes on Wine. */
9978 if (0)
9979 {
9980 ret = getpeername(sock, (void*)0xdeadbeef, (void*)0xcafebabe);
9981 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9982 ok(WSAGetLastError() == WSAEFAULT,
9983 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9984 }
9985
9986 ret = getpeername(sock, (struct sockaddr*)&sa_out, NULL);
9987 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
9988 ok(WSAGetLastError() == WSAEFAULT,
9989 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9990
9991 sa_len = 0;
9992 ret = getpeername(sock, NULL, &sa_len);
9993 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
9994 ok(WSAGetLastError() == WSAEFAULT,
9995 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9996 ok(!sa_len, "got %d\n", sa_len);
9997
9998 sa_len = 0;
9999 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
10000 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
10001 ok(WSAGetLastError() == WSAEFAULT,
10002 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
10003 ok(!sa_len, "got %d\n", sa_len);
10004
10005 sa_len = sizeof(ss);
10006 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
10007 ok(ret == 0, "Expected getpeername to return 0, got %d\n", ret);
10008 ok(!memcmp(&sa, &ss, sizeof(sa)),
10009 "Expected the returned structure to be identical to the connect structure\n");
10010 ok(sa_len == sizeof(sa), "got %d\n", sa_len);
10011
10012 closesocket(sock);
10013 }
10014
10015 static void test_sioRoutingInterfaceQuery(void)
10016 {
10017 OVERLAPPED overlapped = {0}, *overlapped_ptr;
10018 struct sockaddr_in in = {0}, out = {0};
10019 ULONG_PTR key;
10020 HANDLE port;
10021 SOCKET sock;
10022 DWORD size;
10023 int ret;
10024
10025 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
10026 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
10027 port = CreateIoCompletionPort((HANDLE)sock, NULL, 123, 0);
10028
10029 WSASetLastError(0xdeadbeef);
10030 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), NULL, NULL, NULL);
10031 ok(ret == -1, "expected failure\n");
10032 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
10033
10034 size = 0xdeadbeef;
10035 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in) - 1, &out, sizeof(out), &size, NULL, NULL);
10036 ok(ret == -1, "expected failure\n");
10037 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
10038 ok(size == 0xdeadbeef, "got size %lu\n", size);
10039
10040 size = 0xdeadbeef;
10041 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, NULL, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
10042 ok(ret == -1, "expected failure\n");
10043 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
10044 ok(size == 0xdeadbeef, "got size %lu\n", size);
10045
10046 size = 0xdeadbeef;
10047 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
10048 ok(ret == -1, "expected failure\n");
10049 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError());
10050 ok(size == 0xdeadbeef, "got size %lu\n", size);
10051
10052 in.sin_family = AF_INET;
10053 size = 0xdeadbeef;
10054 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
10055 todo_wine ok(ret == -1, "expected failure\n");
10056 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
10057 todo_wine ok(size == 0xdeadbeef, "got size %lu\n", size);
10058
10059 in.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
10060 WSASetLastError(0xdeadbeef);
10061 size = 0xdeadbeef;
10062 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
10063 ok(!ret, "expected failure\n");
10064 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
10065 ok(size == sizeof(out), "got size %lu\n", size);
10066 /* We expect the source address to be INADDR_LOOPBACK as well, but
10067 * there's no guarantee that a route to the loopback address exists,
10068 * so rather than introduce spurious test failures we do not test the
10069 * source address.
10070 */
10071
10072 size = 0xdeadbeef;
10073 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out) - 1, &size, NULL, NULL);
10074 ok(ret == -1, "expected failure\n");
10075 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
10076 todo_wine ok(size == sizeof(out), "got size %lu\n", size);
10077
10078 size = 0xdeadbeef;
10079 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), NULL, sizeof(out), &size, NULL, NULL);
10080 ok(ret == -1, "expected failure\n");
10081 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
10082 ok(size == 0xdeadbeef, "got size %lu\n", size);
10083
10084 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), NULL, &overlapped, NULL);
10085 ok(ret == -1, "expected failure\n");
10086 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
10087 ok(size == 0xdeadbeef, "got size %lu\n", size);
10088
10089 WSASetLastError(0xdeadbeef);
10090 size = 0xdeadbeef;
10091 overlapped.Internal = 0xdeadbeef;
10092 overlapped.InternalHigh = 0xdeadbeef;
10093 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, &overlapped, NULL);
10094 ok(!ret, "expected failure\n");
10095 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
10096 ok(size == sizeof(out), "got size %lu\n", size);
10097
10098 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
10099 ok(ret, "got error %lu\n", GetLastError());
10100 ok(!size, "got size %lu\n", size);
10101 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
10102 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
10103 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
10104
10105 CloseHandle(port);
10106 closesocket(sock);
10107
10108 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
10109
10110 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in),
10111 &out, sizeof(out), NULL, &overlapped, socket_apc);
10112 ok(ret == -1, "expected failure\n");
10113 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
10114
10115 apc_count = 0;
10116 size = 0xdeadbeef;
10117 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in),
10118 &out, sizeof(out), &size, &overlapped, socket_apc);
10119 ok(!ret, "expected success\n");
10120 ok(size == sizeof(out), "got size %lu\n", size);
10121
10122 ret = SleepEx(0, TRUE);
10123 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
10124 ok(apc_count == 1, "APC was called %u times\n", apc_count);
10125 ok(!apc_error, "got APC error %lu\n", apc_error);
10126 ok(!apc_size, "got APC size %lu\n", apc_size);
10127 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
10128
10129 closesocket(sock);
10130 }
10131
10132 static void test_sioAddressListChange(void)
10133 {
10134 struct sockaddr_in bindAddress;
10135 struct in_addr net_address;
10136 WSAOVERLAPPED overlapped, *olp;
10137 struct hostent *h;
10138 DWORD num_bytes, error, tick;
10139 SOCKET sock, sock2, sock3;
10140 WSAEVENT event2, event3;
10141 HANDLE io_port;
10142 ULONG_PTR key;
10143 int acount;
10144 BOOL bret;
10145 int ret;
10146
10147 /* Use gethostbyname to find the list of local network interfaces */
10148 h = gethostbyname("");
10149 ok(!!h, "failed to get interface list, error %u\n", WSAGetLastError());
10150 for (acount = 0; h->h_addr_list[acount]; acount++);
10151 if (acount == 0)
10152 {
10153 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
10154 return;
10155 }
10156
10157 net_address.s_addr = *(ULONG *) h->h_addr_list[0];
10158
10159 sock = socket(AF_INET, 0, IPPROTO_TCP);
10160 ok(sock != INVALID_SOCKET, "socket() failed\n");
10161
10162 memset(&bindAddress, 0, sizeof(bindAddress));
10163 bindAddress.sin_family = AF_INET;
10164 bindAddress.sin_addr.s_addr = net_address.s_addr;
10165 SetLastError(0xdeadbeef);
10166 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10167 ok (!ret, "bind() failed with error %ld\n", GetLastError());
10168 set_blocking(sock, FALSE);
10169
10170 memset(&overlapped, 0, sizeof(overlapped));
10171 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10172 SetLastError(0xdeadbeef);
10173 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10174 error = GetLastError();
10175 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
10176 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%lx\n", error);
10177
10178 CloseHandle(overlapped.hEvent);
10179 closesocket(sock);
10180
10181 sock = socket(AF_INET, 0, IPPROTO_TCP);
10182 ok(sock != INVALID_SOCKET, "socket() failed\n");
10183
10184 SetLastError(0xdeadbeef);
10185 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10186 ok (!ret, "bind() failed with error %ld\n", GetLastError());
10187 set_blocking(sock, TRUE);
10188
10189 memset(&overlapped, 0, sizeof(overlapped));
10190 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10191 SetLastError(0xdeadbeef);
10192 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10193 error = GetLastError();
10194 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
10195 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%lx\n", error);
10196
10197 CloseHandle(overlapped.hEvent);
10198 closesocket(sock);
10199
10200 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10201 ok(sock != INVALID_SOCKET, "socket() failed\n");
10202
10203 SetLastError(0xdeadbeef);
10204 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10205 ok (!ret, "bind() failed with error %ld\n", GetLastError());
10206 set_blocking(sock, FALSE);
10207
10208 memset(&overlapped, 0, sizeof(overlapped));
10209 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10210 SetLastError(0xdeadbeef);
10211 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10212 error = GetLastError();
10213 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
10214 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%lx\n", error);
10215
10216 CloseHandle(overlapped.hEvent);
10217 closesocket(sock);
10218
10219 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10220 ok(sock != INVALID_SOCKET, "socket() failed\n");
10221
10222 SetLastError(0xdeadbeef);
10223 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10224 ok (!ret, "bind() failed with error %ld\n", GetLastError());
10225 set_blocking(sock, TRUE);
10226
10227 memset(&overlapped, 0, sizeof(overlapped));
10228 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10229 SetLastError(0xdeadbeef);
10230 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10231 error = GetLastError();
10232 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
10233 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%lx\n", error);
10234
10235 CloseHandle(overlapped.hEvent);
10236 closesocket(sock);
10237
10238 /* When the socket is overlapped non-blocking and the list change is requested without
10239 * an overlapped structure the error will be different. */
10240 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10241 ok(sock != INVALID_SOCKET, "socket() failed\n");
10242
10243 SetLastError(0xdeadbeef);
10244 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10245 ok (!ret, "bind() failed with error %ld\n", GetLastError());
10246 set_blocking(sock, FALSE);
10247
10248 SetLastError(0xdeadbeef);
10249 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
10250 error = GetLastError();
10251 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
10252 ok (error == WSAEWOULDBLOCK, "expected 10035, got %ld\n", error);
10253
10254 io_port = CreateIoCompletionPort( (HANDLE)sock, NULL, 0, 0 );
10255 ok (io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10256
10257 set_blocking(sock, FALSE);
10258 memset(&overlapped, 0, sizeof(overlapped));
10259 SetLastError(0xdeadbeef);
10260 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10261 error = GetLastError();
10262 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %lu\n", error);
10263 ok (error == ERROR_IO_PENDING, "expected ERROR_IO_PENDING got %lu\n", error);
10264
10265 olp = (WSAOVERLAPPED *)0xdeadbeef;
10266 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 0 );
10267 ok(!bret, "failed to get completion status %u\n", bret);
10268 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10269 ok(!olp, "Overlapped structure is at %p\n", olp);
10270
10271 closesocket(sock);
10272
10273 olp = (WSAOVERLAPPED *)0xdeadbeef;
10274 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 0 );
10275 ok(!bret, "failed to get completion status %u\n", bret);
10276 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %lu\n", GetLastError());
10277 ok(olp == &overlapped, "Overlapped structure is at %p\n", olp);
10278
10279 CloseHandle(io_port);
10280
10281 /* Misuse of the API by using a blocking socket and not using an overlapped structure,
10282 * this leads to a hang forever. */
10283 if (0)
10284 {
10285 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10286
10287 SetLastError(0xdeadbeef);
10288 bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10289
10290 set_blocking(sock, TRUE);
10291 WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
10292 /* hang */
10293
10294 closesocket(sock);
10295 }
10296
10297 if (!winetest_interactive)
10298 {
10299 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
10300 return;
10301 }
10302
10303 /* Bind an overlapped socket to the first found network interface */
10304 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10305 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
10306 sock2 = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10307 ok(sock2 != INVALID_SOCKET, "Expected socket to return a valid socket\n");
10308 sock3 = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10309 ok(sock3 != INVALID_SOCKET, "Expected socket to return a valid socket\n");
10310
10311 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10312 ok(!ret, "bind failed unexpectedly\n");
10313 ret = bind(sock2, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10314 ok(!ret, "bind failed unexpectedly\n");
10315 ret = bind(sock3, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10316 ok(!ret, "bind failed unexpectedly\n");
10317
10318 set_blocking(sock2, FALSE);
10319 set_blocking(sock3, FALSE);
10320
10321 /* Wait for address changes, request that the user connects/disconnects an interface */
10322 memset(&overlapped, 0, sizeof(overlapped));
10323 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10324 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10325 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
10326 ok(WSAGetLastError() == WSA_IO_PENDING, "Expected pending last error, got %d\n", WSAGetLastError());
10327
10328 ret = WSAIoctl(sock2, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
10329 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
10330 ok(WSAGetLastError() == WSAEWOULDBLOCK, "Expected would block last error, got %d\n", WSAGetLastError());
10331
10332 event2 = WSACreateEvent();
10333 event3 = WSACreateEvent();
10334 ret = WSAEventSelect (sock2, event2, FD_ADDRESS_LIST_CHANGE);
10335 ok(!ret, "WSAEventSelect failed with %d\n", WSAGetLastError());
10336 /* sock3 did not request SIO_ADDRESS_LIST_CHANGE but it is trying to wait anyway */
10337 ret = WSAEventSelect (sock3, event3, FD_ADDRESS_LIST_CHANGE);
10338 ok(!ret, "WSAEventSelect failed with %d\n", WSAGetLastError());
10339
10340 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
10341 " change the ipv4 address of any of the local network interfaces (15 second timeout).\n");
10342 tick = GetTickCount();
10343 ret = WaitForSingleObject(overlapped.hEvent, 15000);
10344 ok(ret == WAIT_OBJECT_0, "failed to get overlapped event %u\n", ret);
10345
10346 ret = WaitForSingleObject(event2, 500);
10347 todo_wine
10348 ok(ret == WAIT_OBJECT_0, "failed to get change event %u\n", ret);
10349
10350 ret = WaitForSingleObject(event3, 500);
10351 ok(ret == WAIT_TIMEOUT, "unexpected change event\n");
10352
10353 trace("Spent %ld ms waiting.\n", GetTickCount() - tick);
10354
10355 WSACloseEvent(event2);
10356 WSACloseEvent(event3);
10357
10358 closesocket(sock);
10359 closesocket(sock2);
10360 closesocket(sock3);
10361 }
10362
10363 /*
10364 * Provide consistent initialization for the AcceptEx IOCP tests.
10365 */
10366 static SOCKET setup_iocp_src(struct sockaddr_in *bindAddress)
10367 {
10368 SOCKET src;
10369 int iret, socklen;
10370
10371 src = socket(AF_INET, SOCK_STREAM, 0);
10372 ok(src != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10373
10374 memset(bindAddress, 0, sizeof(*bindAddress));
10375 bindAddress->sin_family = AF_INET;
10376 bindAddress->sin_addr.s_addr = inet_addr("127.0.0.1");
10377 iret = bind(src, (struct sockaddr*)bindAddress, sizeof(*bindAddress));
10378 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
10379
10380 socklen = sizeof(*bindAddress);
10381 iret = getsockname(src, (struct sockaddr*)bindAddress, &socklen);
10382 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
10383
10384 iret = set_blocking(src, FALSE);
10385 ok(!iret, "failed to make socket non-blocking, error %u\n", WSAGetLastError());
10386
10387 iret = listen(src, 5);
10388 ok(!iret, "failed to listen, error %u\n", WSAGetLastError());
10389
10390 return src;
10391 }
10392
10393 static void test_completion_port(void)
10394 {
10395 HANDLE io_port;
10396 WSAOVERLAPPED ov, *olp;
10397 SOCKET src, dest, dup, connector = INVALID_SOCKET;
10398 WSAPROTOCOL_INFOA info;
10399 char buf[1024];
10400 WSABUF bufs;
10401 DWORD num_bytes, flags;
10402 int iret;
10403 BOOL bret;
10404 ULONG_PTR key;
10405 struct sockaddr_in bindAddress;
10406 GUID acceptExGuid = WSAID_ACCEPTEX;
10407 LPFN_ACCEPTEX pAcceptEx = NULL;
10408 fd_set fds_recv;
10409
10410 memset(buf, 0, sizeof(buf));
10411 io_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
10412 ok( io_port != NULL, "Failed to create completion port %lu\n", GetLastError());
10413
10414 memset(&ov, 0, sizeof(ov));
10415
10416 tcp_socketpair(&src, &dest);
10417
10418 bufs.len = sizeof(buf);
10419 bufs.buf = buf;
10420 flags = 0;
10421
10422 io_port = CreateIoCompletionPort( (HANDLE)dest, io_port, 125, 0 );
10423 ok(io_port != NULL, "Failed to create completion port %lu\n", GetLastError());
10424
10425 SetLastError(0xdeadbeef);
10426
10427 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10428 ok(iret == SOCKET_ERROR, "WSARecv returned %d\n", iret);
10429 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10430
10431 Sleep(100);
10432
10433 close_with_rst(src);
10434
10435 SetLastError(0xdeadbeef);
10436 key = 0xdeadbeef;
10437 num_bytes = 0xdeadbeef;
10438 olp = (WSAOVERLAPPED *)0xdeadbeef;
10439
10440 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10441 ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret);
10442 ok(GetLastError() == ERROR_NETNAME_DELETED, "Last error was %ld\n", GetLastError());
10443 ok(key == 125, "Key is %Iu\n", key);
10444 ok(num_bytes == 0, "Number of bytes received is %lu\n", num_bytes);
10445 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10446
10447 SetLastError(0xdeadbeef);
10448 key = 0xdeadbeef;
10449 num_bytes = 0xdeadbeef;
10450 olp = (WSAOVERLAPPED *)0xdeadbeef;
10451
10452 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10453 ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret );
10454 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10455 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10456 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10457 ok(!olp, "Overlapped structure is at %p\n", olp);
10458
10459 if (dest != INVALID_SOCKET)
10460 closesocket(dest);
10461
10462 memset(&ov, 0, sizeof(ov));
10463
10464 tcp_socketpair(&src, &dest);
10465
10466 bufs.len = sizeof(buf);
10467 bufs.buf = buf;
10468 flags = 0;
10469
10470 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
10471 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10472
10473 set_blocking(dest, FALSE);
10474
10475 close_with_rst(src);
10476
10477 Sleep(100);
10478
10479 num_bytes = 0xdeadbeef;
10480 SetLastError(0xdeadbeef);
10481
10482 iret = WSASend(dest, &bufs, 1, &num_bytes, 0, &ov, NULL);
10483 ok(iret == SOCKET_ERROR, "WSASend failed - %d\n", iret);
10484 ok(GetLastError() == WSAECONNRESET, "Last error was %ld\n", GetLastError());
10485 ok(num_bytes == 0xdeadbeef, "Managed to send %ld\n", num_bytes);
10486
10487 SetLastError(0xdeadbeef);
10488 key = 0xdeadbeef;
10489 num_bytes = 0xdeadbeef;
10490 olp = (WSAOVERLAPPED *)0xdeadbeef;
10491
10492 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10493 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
10494 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10495 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10496 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10497 ok(!olp, "Overlapped structure is at %p\n", olp);
10498
10499 if (dest != INVALID_SOCKET)
10500 closesocket(dest);
10501
10502 /* Test IOCP response on successful immediate read. */
10503 tcp_socketpair(&src, &dest);
10504
10505 bufs.len = sizeof(buf);
10506 bufs.buf = buf;
10507 flags = 0;
10508 SetLastError(0xdeadbeef);
10509
10510 iret = WSASend(src, &bufs, 1, &num_bytes, 0, &ov, NULL);
10511 ok(!iret, "WSASend failed - %d, last error %lu\n", iret, GetLastError());
10512 ok(num_bytes == sizeof(buf), "Managed to send %ld\n", num_bytes);
10513
10514 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
10515 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10516 set_blocking(dest, FALSE);
10517
10518 FD_ZERO(&fds_recv);
10519 FD_SET(dest, &fds_recv);
10520 select(dest + 1, &fds_recv, NULL, NULL, NULL);
10521
10522 num_bytes = 0xdeadbeef;
10523 flags = 0;
10524
10525 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10526 ok(!iret, "WSARecv failed - %d, last error %lu\n", iret, GetLastError());
10527 ok(num_bytes == sizeof(buf), "Managed to read %ld\n", num_bytes);
10528
10529 SetLastError(0xdeadbeef);
10530 key = 0xdeadbeef;
10531 num_bytes = 0xdeadbeef;
10532 olp = (WSAOVERLAPPED *)0xdeadbeef;
10533
10534 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10535 ok(bret == TRUE, "failed to get completion status %u\n", bret);
10536 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
10537 ok(key == 125, "Key is %Iu\n", key);
10538 ok(num_bytes == sizeof(buf), "Number of bytes transferred is %lu\n", num_bytes);
10539 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10540
10541 /* Test IOCP response on graceful shutdown. */
10542 closesocket(src);
10543
10544 FD_ZERO(&fds_recv);
10545 FD_SET(dest, &fds_recv);
10546 select(dest + 1, &fds_recv, NULL, NULL, NULL);
10547
10548 num_bytes = 0xdeadbeef;
10549 flags = 0;
10550 memset(&ov, 0, sizeof(ov));
10551
10552 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10553 ok(!iret, "WSARecv failed - %d, last error %lu\n", iret, GetLastError());
10554 ok(!num_bytes, "Managed to read %ld\n", num_bytes);
10555
10556 SetLastError(0xdeadbeef);
10557 key = 0xdeadbeef;
10558 num_bytes = 0xdeadbeef;
10559 olp = (WSAOVERLAPPED *)0xdeadbeef;
10560
10561 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10562 ok(bret == TRUE, "failed to get completion status %u\n", bret);
10563 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
10564 ok(key == 125, "Key is %Iu\n", key);
10565 ok(!num_bytes, "Number of bytes transferred is %lu\n", num_bytes);
10566 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10567
10568 closesocket(src);
10569 src = INVALID_SOCKET;
10570 closesocket(dest);
10571 dest = INVALID_SOCKET;
10572
10573 /* Test IOCP response on hard shutdown. This was the condition that triggered
10574 * a crash in an actual app (bug 38980). */
10575 tcp_socketpair(&src, &dest);
10576
10577 bufs.len = sizeof(buf);
10578 bufs.buf = buf;
10579 flags = 0;
10580 memset(&ov, 0, sizeof(ov));
10581
10582 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
10583 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10584 set_blocking(dest, FALSE);
10585
10586 close_with_rst(src);
10587
10588 FD_ZERO(&fds_recv);
10589 FD_SET(dest, &fds_recv);
10590 select(dest + 1, &fds_recv, NULL, NULL, NULL);
10591
10592 num_bytes = 0xdeadbeef;
10593 SetLastError(0xdeadbeef);
10594
10595 /* Somehow a hard shutdown doesn't work on my Linux box. It seems SO_LINGER is ignored. */
10596 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10597 ok(iret == SOCKET_ERROR, "WSARecv failed - %d\n", iret);
10598 ok(GetLastError() == WSAECONNRESET, "Last error was %ld\n", GetLastError());
10599 ok(num_bytes == 0xdeadbeef, "Managed to read %ld\n", num_bytes);
10600
10601 SetLastError(0xdeadbeef);
10602 key = 0xdeadbeef;
10603 num_bytes = 0xdeadbeef;
10604 olp = (WSAOVERLAPPED *)0xdeadbeef;
10605
10606 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10607 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
10608 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10609 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10610 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10611 ok(!olp, "Overlapped structure is at %p\n", olp);
10612
10613 closesocket(dest);
10614
10615 /* Test reading from a non-connected socket, mostly because the above test is marked todo. */
10616 dest = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10617 ok(dest != INVALID_SOCKET, "socket() failed\n");
10618
10619 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
10620 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10621 set_blocking(dest, FALSE);
10622
10623 num_bytes = 0xdeadbeef;
10624 SetLastError(0xdeadbeef);
10625 memset(&ov, 0, sizeof(ov));
10626
10627 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10628 ok(iret == SOCKET_ERROR, "WSARecv failed - %d\n", iret);
10629 ok(GetLastError() == WSAENOTCONN, "Last error was %ld\n", GetLastError());
10630 ok(num_bytes == 0xdeadbeef, "Managed to read %ld\n", num_bytes);
10631
10632 SetLastError(0xdeadbeef);
10633 key = 0xdeadbeef;
10634 num_bytes = 0xdeadbeef;
10635 olp = (WSAOVERLAPPED *)0xdeadbeef;
10636
10637 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10638 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
10639 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10640 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10641 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10642 ok(!olp, "Overlapped structure is at %p\n", olp);
10643
10644 num_bytes = 0xdeadbeef;
10645 closesocket(dest);
10646
10647 dest = socket(AF_INET, SOCK_STREAM, 0);
10648 ok(dest != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10649
10650 iret = WSAIoctl(dest, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
10651 &pAcceptEx, sizeof(pAcceptEx), &num_bytes, NULL, NULL);
10652 ok(!iret, "failed to get AcceptEx, error %u\n", WSAGetLastError());
10653
10654 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
10655
10656 src = setup_iocp_src(&bindAddress);
10657
10658 SetLastError(0xdeadbeef);
10659
10660 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10661 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10662 &num_bytes, &ov);
10663 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10664 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10665
10666 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10667 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10668
10669 closesocket(src);
10670 src = INVALID_SOCKET;
10671
10672 SetLastError(0xdeadbeef);
10673 key = 0xdeadbeef;
10674 num_bytes = 0xdeadbeef;
10675 olp = (WSAOVERLAPPED *)0xdeadbeef;
10676
10677 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10678 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10679 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10680 ok(key == 125, "Key is %Iu\n", key);
10681 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10682 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10683 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10684
10685 SetLastError(0xdeadbeef);
10686 key = 0xdeadbeef;
10687 num_bytes = 0xdeadbeef;
10688 olp = (WSAOVERLAPPED *)0xdeadbeef;
10689 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10690 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10691 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10692 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10693 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10694 ok(!olp, "Overlapped structure is at %p\n", olp);
10695
10696 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
10697
10698 src = setup_iocp_src(&bindAddress);
10699
10700 SetLastError(0xdeadbeef);
10701
10702 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10703 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10704
10705 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10706 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10707 &num_bytes, &ov);
10708 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10709 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10710
10711 closesocket(src);
10712 src = INVALID_SOCKET;
10713
10714 SetLastError(0xdeadbeef);
10715 key = 0xdeadbeef;
10716 num_bytes = 0xdeadbeef;
10717 olp = (WSAOVERLAPPED *)0xdeadbeef;
10718
10719 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10720 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10721 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10722 ok(key == 125, "Key is %Iu\n", key);
10723 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10724 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10725 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10726
10727 SetLastError(0xdeadbeef);
10728 key = 0xdeadbeef;
10729 num_bytes = 0xdeadbeef;
10730 olp = (WSAOVERLAPPED *)0xdeadbeef;
10731 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10732 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10733 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10734 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10735 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10736 ok(!olp, "Overlapped structure is at %p\n", olp);
10737
10738 /* Test IOCP with duplicated handle */
10739
10740 src = setup_iocp_src(&bindAddress);
10741
10742 SetLastError(0xdeadbeef);
10743
10744 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10745 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10746
10747 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10748 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10749 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10750
10751 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10752 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10753 &num_bytes, &ov);
10754 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10755 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10756
10757 SetLastError(0xdeadbeef);
10758 key = 0xdeadbeef;
10759 num_bytes = 0xdeadbeef;
10760 olp = (WSAOVERLAPPED *)0xdeadbeef;
10761 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10762 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10763 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10764 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10765 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10766 ok(!olp, "Overlapped structure is at %p\n", olp);
10767
10768 closesocket(src);
10769 src = INVALID_SOCKET;
10770 closesocket(dup);
10771 dup = INVALID_SOCKET;
10772
10773 SetLastError(0xdeadbeef);
10774 key = 0xdeadbeef;
10775 num_bytes = 0xdeadbeef;
10776 olp = (WSAOVERLAPPED *)0xdeadbeef;
10777 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10778 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10779 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10780 ok(key == 125, "Key is %Iu\n", key);
10781 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10782 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10783 ok(olp && olp->Internal == (ULONG)STATUS_CANCELLED, "Internal status is %Ix\n", olp ? olp->Internal : 0);
10784
10785 SetLastError(0xdeadbeef);
10786 key = 0xdeadbeef;
10787 num_bytes = 0xdeadbeef;
10788 olp = (WSAOVERLAPPED *)0xdeadbeef;
10789 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10790 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10791 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10792 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10793 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10794 ok(!olp, "Overlapped structure is at %p\n", olp);
10795
10796 /* Test IOCP with duplicated handle (closing duplicated handle) */
10797
10798 src = setup_iocp_src(&bindAddress);
10799
10800 SetLastError(0xdeadbeef);
10801
10802 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10803 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10804
10805 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10806 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10807 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10808
10809 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10810 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10811 &num_bytes, &ov);
10812 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10813 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10814
10815 closesocket(dup);
10816 dup = INVALID_SOCKET;
10817
10818 SetLastError(0xdeadbeef);
10819 key = 0xdeadbeef;
10820 num_bytes = 0xdeadbeef;
10821 olp = (WSAOVERLAPPED *)0xdeadbeef;
10822 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10823 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10824 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10825 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10826 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10827 ok(!olp, "Overlapped structure is at %p\n", olp);
10828
10829 SetLastError(0xdeadbeef);
10830 key = 0xdeadbeef;
10831 num_bytes = 0xdeadbeef;
10832 olp = (WSAOVERLAPPED *)0xdeadbeef;
10833 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10834 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10835 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10836 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10837 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10838 ok(!olp, "Overlapped structure is at %p\n", olp);
10839
10840 closesocket(src);
10841 src = INVALID_SOCKET;
10842
10843 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10844 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10845 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10846 ok(key == 125, "Key is %Iu\n", key);
10847 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10848 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10849 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10850
10851 SetLastError(0xdeadbeef);
10852 key = 0xdeadbeef;
10853 num_bytes = 0xdeadbeef;
10854 olp = (WSAOVERLAPPED *)0xdeadbeef;
10855 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10856 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10857 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10858 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10859 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10860 ok(!olp, "Overlapped structure is at %p\n", olp);
10861
10862 /* Test IOCP with duplicated handle (closing original handle) */
10863
10864 src = setup_iocp_src(&bindAddress);
10865
10866 SetLastError(0xdeadbeef);
10867
10868 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10869 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10870
10871 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10872 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10873 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10874
10875 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10876 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10877 &num_bytes, &ov);
10878 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10879 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10880
10881 closesocket(src);
10882 src = INVALID_SOCKET;
10883
10884 SetLastError(0xdeadbeef);
10885 key = 0xdeadbeef;
10886 num_bytes = 0xdeadbeef;
10887 olp = (WSAOVERLAPPED *)0xdeadbeef;
10888 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10889 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10890 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10891 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10892 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10893 ok(!olp, "Overlapped structure is at %p\n", olp);
10894
10895 closesocket(dup);
10896 dup = INVALID_SOCKET;
10897
10898 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10899 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10900 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10901 ok(key == 125, "Key is %Iu\n", key);
10902 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10903 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10904 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10905
10906 SetLastError(0xdeadbeef);
10907 key = 0xdeadbeef;
10908 num_bytes = 0xdeadbeef;
10909 olp = (WSAOVERLAPPED *)0xdeadbeef;
10910 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10911 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10912 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10913 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10914 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10915 ok(!olp, "Overlapped structure is at %p\n", olp);
10916
10917 /* Test IOCP without AcceptEx */
10918
10919 src = setup_iocp_src(&bindAddress);
10920
10921 SetLastError(0xdeadbeef);
10922
10923 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10924 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10925
10926 closesocket(src);
10927 src = INVALID_SOCKET;
10928
10929 SetLastError(0xdeadbeef);
10930 key = 0xdeadbeef;
10931 num_bytes = 0xdeadbeef;
10932 olp = (WSAOVERLAPPED *)0xdeadbeef;
10933 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10934 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10935 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10936 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10937 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10938 ok(!olp, "Overlapped structure is at %p\n", olp);
10939
10940 /* */
10941
10942 src = setup_iocp_src(&bindAddress);
10943
10944 connector = socket(AF_INET, SOCK_STREAM, 0);
10945 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10946
10947 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10948 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10949
10950 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 236, 0);
10951 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10952
10953 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10954 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10955 &num_bytes, &ov);
10956 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10957 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10958
10959 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10960 ok(iret == 0, "connecting to accepting socket failed, error %ld\n", GetLastError());
10961
10962 closesocket(connector);
10963 connector = INVALID_SOCKET;
10964
10965 SetLastError(0xdeadbeef);
10966 key = 0xdeadbeef;
10967 num_bytes = 0xdeadbeef;
10968 olp = (WSAOVERLAPPED *)0xdeadbeef;
10969
10970 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10971 ok(bret == TRUE, "failed to get completion status %u\n", bret);
10972 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
10973 ok(key == 125, "Key is %Iu\n", key);
10974 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10975 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10976 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10977
10978 SetLastError(0xdeadbeef);
10979 key = 0xdeadbeef;
10980 num_bytes = 0xdeadbeef;
10981 olp = (WSAOVERLAPPED *)0xdeadbeef;
10982 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10983 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10984 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10985 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10986 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10987 ok(!olp, "Overlapped structure is at %p\n", olp);
10988
10989 if (dest != INVALID_SOCKET)
10990 closesocket(dest);
10991 if (src != INVALID_SOCKET)
10992 closesocket(dest);
10993
10994 /* */
10995
10996 src = setup_iocp_src(&bindAddress);
10997
10998 dest = socket(AF_INET, SOCK_STREAM, 0);
10999 ok(dest != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
11000
11001 connector = socket(AF_INET, SOCK_STREAM, 0);
11002 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
11003
11004 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
11005 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
11006
11007 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 236, 0);
11008 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
11009
11010 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
11011 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
11012 &num_bytes, &ov);
11013 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
11014 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
11015
11016 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
11017 ok(iret == 0, "connecting to accepting socket failed, error %ld\n", GetLastError());
11018
11019 iret = send(connector, buf, 1, 0);
11020 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
11021
11022 Sleep(100);
11023
11024 closesocket(dest);
11025 dest = INVALID_SOCKET;
11026
11027 SetLastError(0xdeadbeef);
11028 key = 0xdeadbeef;
11029 num_bytes = 0xdeadbeef;
11030 olp = (WSAOVERLAPPED *)0xdeadbeef;
11031
11032 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
11033 ok(bret == TRUE, "failed to get completion status %u\n", bret);
11034 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
11035 ok(key == 125, "Key is %Iu\n", key);
11036 ok(num_bytes == 1, "Number of bytes transferred is %lu\n", num_bytes);
11037 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
11038 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %Ix\n", olp ? olp->Internal : 0);
11039
11040 SetLastError(0xdeadbeef);
11041 key = 0xdeadbeef;
11042 num_bytes = 0xdeadbeef;
11043 olp = (WSAOVERLAPPED *)0xdeadbeef;
11044 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
11045 ok(bret == FALSE, "failed to get completion status %u\n", bret);
11046 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
11047 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
11048 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
11049 ok(!olp, "Overlapped structure is at %p\n", olp);
11050
11051 if (src != INVALID_SOCKET)
11052 closesocket(src);
11053 if (connector != INVALID_SOCKET)
11054 closesocket(connector);
11055
11056 /* */
11057
11058 src = setup_iocp_src(&bindAddress);
11059
11060 dest = socket(AF_INET, SOCK_STREAM, 0);
11061 ok(dest != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
11062
11063 connector = socket(AF_INET, SOCK_STREAM, 0);
11064 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
11065
11066 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
11067 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
11068
11069 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 236, 0);
11070 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
11071
11072 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
11073 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
11074 &num_bytes, &ov);
11075 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
11076 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
11077
11078 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
11079 ok(iret == 0, "connecting to accepting socket failed, error %ld\n", GetLastError());
11080
11081 closesocket(dest);
11082
11083 SetLastError(0xdeadbeef);
11084 key = 0xdeadbeef;
11085 num_bytes = 0xdeadbeef;
11086 olp = (WSAOVERLAPPED *)0xdeadbeef;
11087
11088 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
11089 ok(bret == FALSE, "failed to get completion status %u\n", bret);
11090 ok(GetLastError() == ERROR_OPERATION_ABORTED
11091 || GetLastError() == ERROR_CONNECTION_ABORTED, "got error %lu\n", GetLastError());
11092 ok(key == 125, "Key is %Iu\n", key);
11093 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
11094 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
11095 ok((NTSTATUS)olp->Internal == STATUS_CANCELLED
11096 || (NTSTATUS)olp->Internal == STATUS_CONNECTION_ABORTED, "got status %#Ix\n", olp->Internal);
11097
11098 SetLastError(0xdeadbeef);
11099 key = 0xdeadbeef;
11100 num_bytes = 0xdeadbeef;
11101 olp = (WSAOVERLAPPED *)0xdeadbeef;
11102 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
11103 ok(bret == FALSE, "failed to get completion status %u\n", bret);
11104 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
11105 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
11106 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
11107 ok(!olp, "Overlapped structure is at %p\n", olp);
11108
11109 closesocket(src);
11110 closesocket(connector);
11111 CloseHandle(io_port);
11112 }
11113
11114 static void test_connect_completion_port(void)
11115 {
11116 OVERLAPPED overlapped = {0}, *overlapped_ptr;
11117 GUID connectex_guid = WSAID_CONNECTEX;
11118 SOCKET connector, listener, acceptor;
11119 struct sockaddr_in addr, destaddr;
11120 LPFN_CONNECTEX pConnectEx;
11121 int ret, addrlen;
11122 ULONG_PTR key;
11123 HANDLE port;
11124 DWORD size;
11125
11126 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
11127
11128 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11129 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
11130
11131 memset(&addr, 0, sizeof(addr));
11132 addr.sin_family = AF_INET;
11133 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
11134 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
11135 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11136 addrlen = sizeof(destaddr);
11137 ret = getsockname(listener, (struct sockaddr *)&destaddr, &addrlen);
11138 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
11139
11140 ret = listen(listener, 1);
11141 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
11142
11143 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11144 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11145
11146 ret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectex_guid, sizeof(connectex_guid),
11147 &pConnectEx, sizeof(pConnectEx), &size, NULL, NULL);
11148 ok(!ret, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
11149
11150 /* connect() does not queue completion. */
11151
11152 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11153 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11154
11155 ret = connect(connector, (struct sockaddr *)&destaddr, sizeof(destaddr));
11156 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11157 acceptor = accept(listener, NULL, NULL);
11158 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11159 closesocket(acceptor);
11160
11161 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11162 ok(!ret, "expected failure\n");
11163 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11164
11165 closesocket(connector);
11166 CloseHandle(port);
11167
11168 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11169 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11170 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11171 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11172 set_blocking(connector, FALSE);
11173
11174 ret = connect(connector, (struct sockaddr *)&destaddr, sizeof(destaddr));
11175 ok(ret == -1, "expected failure\n");
11176 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
11177 acceptor = accept(listener, NULL, NULL);
11178 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11179 closesocket(acceptor);
11180
11181 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11182 ok(!ret, "expected failure\n");
11183 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11184
11185 closesocket(connector);
11186 CloseHandle(port);
11187
11188 /* ConnectEx() queues completion. */
11189
11190 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11191 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11192 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11193 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11194 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
11195 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11196
11197 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
11198 NULL, 0, &size, &overlapped);
11199 ok(!ret, "expected failure\n");
11200 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11201 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11202 ok(!ret, "wait failed\n");
11203 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
11204 ok(ret, "got error %lu\n", GetLastError());
11205 ok(!size, "got %lu bytes\n", size);
11206 acceptor = accept(listener, NULL, NULL);
11207 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11208 closesocket(acceptor);
11209
11210 size = 0xdeadbeef;
11211 key = 0xdeadbeef;
11212 overlapped_ptr = NULL;
11213 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11214 ok(ret, "got error %lu\n", GetLastError());
11215 ok(!key, "got key %#Ix\n", key);
11216 ok(!size, "got %lu bytes\n", size);
11217 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11218
11219 closesocket(connector);
11220 CloseHandle(port);
11221
11222 /* Test ConnectEx() with a non-empty buffer. */
11223
11224 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11225 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11226 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11227 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11228 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
11229 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11230
11231 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
11232 (void *)"one", 3, &size, &overlapped);
11233 ok(!ret, "expected failure\n");
11234 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11235 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11236 ok(!ret, "wait failed\n");
11237 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
11238 ok(ret, "got error %lu\n", GetLastError());
11239 ok(size == 3, "got %lu bytes\n", size);
11240 acceptor = accept(listener, NULL, NULL);
11241 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11242 closesocket(acceptor);
11243
11244 size = 0xdeadbeef;
11245 key = 0xdeadbeef;
11246 overlapped_ptr = NULL;
11247 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11248 ok(ret, "got error %lu\n", GetLastError());
11249 ok(!key, "got key %#Ix\n", key);
11250 ok(size == 3, "got %lu bytes\n", size);
11251 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11252
11253 closesocket(connector);
11254 CloseHandle(port);
11255
11256 /* Suppress completion by setting the low bit. */
11257
11258 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11259 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11260 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11261 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11262 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
11263 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11264
11265 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent | 1);
11266
11267 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
11268 NULL, 0, &size, &overlapped);
11269 ok(!ret, "expected failure\n");
11270 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11271 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11272 ok(!ret, "wait failed\n");
11273 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
11274 ok(ret, "got error %lu\n", GetLastError());
11275 ok(!size, "got %lu bytes\n", size);
11276 acceptor = accept(listener, NULL, NULL);
11277 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11278 closesocket(acceptor);
11279
11280 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11281 ok(!ret, "expected failure\n");
11282 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11283
11284 closesocket(connector);
11285 CloseHandle(port);
11286
11287 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent & ~1);
11288
11289 /* Skip completion on success. */
11290
11291 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11292 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11293 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11294 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11295 ret = SetFileCompletionNotificationModes((HANDLE)connector, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS);
11296 ok(ret, "got error %lu\n", GetLastError());
11297 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
11298 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11299
11300 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
11301 NULL, 0, &size, &overlapped);
11302 ok(!ret, "expected failure\n");
11303 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11304 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11305 ok(!ret, "wait failed\n");
11306 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
11307 ok(ret, "got error %lu\n", GetLastError());
11308 ok(!size, "got %lu bytes\n", size);
11309 acceptor = accept(listener, NULL, NULL);
11310 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11311 closesocket(acceptor);
11312
11313 size = 0xdeadbeef;
11314 key = 0xdeadbeef;
11315 overlapped_ptr = NULL;
11316 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11317 ok(ret, "got error %lu\n", GetLastError());
11318 ok(!key, "got key %#Ix\n", key);
11319 ok(!size, "got %lu bytes\n", size);
11320 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11321
11322 closesocket(connector);
11323 CloseHandle(port);
11324
11325 closesocket(listener);
11326
11327 /* Connect to an invalid address. */
11328
11329 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11330 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11331 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11332 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11333 ret = SetFileCompletionNotificationModes((HANDLE)connector, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS);
11334 ok(ret, "got error %lu\n", GetLastError());
11335 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
11336 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11337
11338 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
11339 NULL, 0, &size, &overlapped);
11340 ok(!ret, "expected failure\n");
11341 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11342 ret = WaitForSingleObject(overlapped.hEvent, 15000);
11343 ok(!ret, "wait failed\n");
11344 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
11345 ok(!ret, "expected failure\n");
11346 ok(GetLastError() == ERROR_CONNECTION_REFUSED, "got error %lu\n", GetLastError());
11347 ok(!size, "got %lu bytes\n", size);
11348
11349 size = 0xdeadbeef;
11350 key = 0xdeadbeef;
11351 overlapped_ptr = NULL;
11352 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11353 ok(!ret, "expected failure\n");
11354 ok(GetLastError() == ERROR_CONNECTION_REFUSED, "got error %lu\n", GetLastError());
11355 ok(!key, "got key %#Ix\n", key);
11356 ok(!size, "got %lu bytes\n", size);
11357 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11358
11359 closesocket(connector);
11360 CloseHandle(port);
11361 }
11362
11363 static void test_shutdown_completion_port(void)
11364 {
11365 OVERLAPPED overlapped = {0}, *overlapped_ptr;
11366 GUID disconnectex_guid = WSAID_DISCONNECTEX;
11367 struct sockaddr_in addr, destaddr;
11368 LPFN_DISCONNECTEX pDisconnectEx;
11369 SOCKET listener, server, client;
11370 int ret, addrlen;
11371 ULONG_PTR key;
11372 HANDLE port;
11373 DWORD size;
11374
11375 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
11376
11377 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11378 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
11379
11380 memset(&addr, 0, sizeof(addr));
11381 addr.sin_family = AF_INET;
11382 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
11383 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
11384 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11385 addrlen = sizeof(destaddr);
11386 ret = getsockname(listener, (struct sockaddr *)&destaddr, &addrlen);
11387 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
11388
11389 ret = listen(listener, 1);
11390 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
11391
11392 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11393 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11394
11395 ret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &disconnectex_guid, sizeof(disconnectex_guid),
11396 &pDisconnectEx, sizeof(pDisconnectEx), &size, NULL, NULL);
11397 ok(!ret, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
11398
11399 /* shutdown() does not queue completion. */
11400
11401 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11402 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11403 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11404 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11405 server = accept(listener, NULL, NULL);
11406 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11407
11408 ret = shutdown(client, SD_BOTH);
11409 ok(!ret, "failed to shutdown, error %u\n", WSAGetLastError());
11410
11411 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11412 ok(!ret, "expected failure\n");
11413 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11414
11415 closesocket(server);
11416 closesocket(client);
11417 CloseHandle(port);
11418
11419 /* WSASendDisconnect() and WSARecvDisconnect() do not queue completion. */
11420
11421 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11422 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11423 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11424 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11425 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11426 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11427 server = accept(listener, NULL, NULL);
11428 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11429
11430 ret = WSASendDisconnect(client, NULL);
11431 ok(!ret, "failed to shutdown, error %u\n", WSAGetLastError());
11432
11433 ret = WSARecvDisconnect(client, NULL);
11434 ok(!ret, "failed to shutdown, error %u\n", WSAGetLastError());
11435
11436 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11437 ok(!ret, "expected failure\n");
11438 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11439
11440 closesocket(server);
11441 closesocket(client);
11442 CloseHandle(port);
11443
11444 /* DisconnectEx() queues completion. */
11445
11446 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11447 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11448 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11449 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11450 ret = SetFileCompletionNotificationModes((HANDLE)client, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS);
11451 ok(ret, "got error %lu\n", GetLastError());
11452 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11453 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11454 server = accept(listener, NULL, NULL);
11455 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11456
11457 SetLastError(0xdeadbeef);
11458 ret = pDisconnectEx(client, &overlapped, 0, 0);
11459 ok(!ret, "expected failure\n");
11460 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11461
11462 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11463 ok(!ret, "wait failed\n");
11464
11465 size = 0xdeadbeef;
11466 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, TRUE);
11467 ok(ret, "got error %lu\n", GetLastError());
11468 ok(!size, "got %lu bytes\n", size);
11469
11470 size = 0xdeadbeef;
11471 key = 0xdeadbeef;
11472 overlapped_ptr = NULL;
11473 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11474 todo_wine ok(ret, "got error %lu\n", GetLastError());
11475 todo_wine ok(!key, "got key %#Ix\n", key);
11476 todo_wine ok(!size, "got %lu bytes\n", size);
11477 todo_wine ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11478
11479 closesocket(server);
11480 closesocket(client);
11481 CloseHandle(port);
11482
11483 /* Test passing a NULL overlapped structure to DisconnectEx(). */
11484
11485 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11486 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11487 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11488 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11489 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11490 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11491 server = accept(listener, NULL, NULL);
11492 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11493
11494 SetLastError(0xdeadbeef);
11495 ret = pDisconnectEx(client, NULL, 0, 0);
11496 ok(ret, "expected success\n");
11497 ok(!GetLastError() || GetLastError() == 0xdeadbeef /* < 7 */, "got error %lu\n", GetLastError());
11498
11499 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11500 ok(!ret, "expected failure\n");
11501 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11502
11503 closesocket(server);
11504 closesocket(client);
11505 CloseHandle(port);
11506
11507 /* Suppress completion by setting the low bit. */
11508
11509 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11510 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11511 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11512 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11513 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11514 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11515 server = accept(listener, NULL, NULL);
11516 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11517
11518 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent | 1);
11519
11520 SetLastError(0xdeadbeef);
11521 ret = pDisconnectEx(client, &overlapped, 0, 0);
11522 ok(!ret, "expected failure\n");
11523 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11524
11525 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11526 ok(!ret, "wait failed\n");
11527
11528 size = 0xdeadbeef;
11529 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, TRUE);
11530 ok(ret, "got error %lu\n", GetLastError());
11531 ok(!size, "got %lu bytes\n", size);
11532
11533 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11534 ok(!ret, "expected failure\n");
11535 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11536
11537 closesocket(server);
11538 closesocket(client);
11539 CloseHandle(port);
11540
11541 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent & ~1);
11542
11543 CloseHandle(overlapped.hEvent);
11544 }
11545
11546 static void test_address_list_query(void)
11547 {
11548 char buffer[1024];
11549 SOCKET_ADDRESS_LIST *address_list = (SOCKET_ADDRESS_LIST *)buffer;
11550 OVERLAPPED overlapped = {0}, *overlapped_ptr;
11551 DWORD size, expect_size;
11552 unsigned int i;
11553 ULONG_PTR key;
11554 HANDLE port;
11555 SOCKET s;
11556 int ret;
11557
11558 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11559 ok(s != INVALID_SOCKET, "Failed to create socket, error %d.\n", WSAGetLastError());
11560 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
11561
11562 size = 0;
11563 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, 0, &size, NULL, NULL);
11564 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11565 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11566 ok(size >= FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), "Got unexpected size %lu.\n", size);
11567 expect_size = size;
11568
11569 size = 0;
11570 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), &size, NULL, NULL);
11571 ok(!ret, "Got unexpected ret %d.\n", ret);
11572 ok(!WSAGetLastError(), "Got unexpected error %d.\n", WSAGetLastError());
11573 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11574
11575 expect_size = FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[address_list->iAddressCount]);
11576 for (i = 0; i < address_list->iAddressCount; ++i)
11577 {
11578 expect_size += address_list->Address[i].iSockaddrLength;
11579 }
11580 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11581
11582 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), NULL, NULL, NULL);
11583 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11584 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11585
11586 size = 0xdeadbeef;
11587 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, sizeof(buffer), &size, NULL, NULL);
11588 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11589 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11590 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11591
11592 size = 0xdeadbeef;
11593 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 0, &size, NULL, NULL);
11594 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11595 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11596 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11597
11598 size = 0xdeadbeef;
11599 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 1, &size, NULL, NULL);
11600 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11601 ok(WSAGetLastError() == WSAEINVAL, "Got unexpected error %d.\n", WSAGetLastError());
11602 ok(!size, "Got size %lu.\n", size);
11603
11604 size = 0xdeadbeef;
11605 memset(buffer, 0xcc, sizeof(buffer));
11606 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer,
11607 FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), &size, NULL, NULL);
11608 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11609 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11610 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11611 ok(address_list->iAddressCount == 0xcccccccc, "Got %u addresses.\n", address_list->iAddressCount);
11612
11613 WSASetLastError(0xdeadbeef);
11614 overlapped.Internal = 0xdeadbeef;
11615 overlapped.InternalHigh = 0xdeadbeef;
11616 size = 0xdeadbeef;
11617 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 0, &size, &overlapped, NULL);
11618 ok(ret == -1, "Got unexpected ret %d.\n", ret);
11619 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11620 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11621 ok(overlapped.Internal == 0xdeadbeef, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
11622 ok(overlapped.InternalHigh == 0xdeadbeef, "Got size %Iu.\n", overlapped.InternalHigh);
11623
11624 overlapped.Internal = 0xdeadbeef;
11625 overlapped.InternalHigh = 0xdeadbeef;
11626 size = 0xdeadbeef;
11627 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 1, &size, &overlapped, NULL);
11628 ok(ret == -1, "Got unexpected ret %d.\n", ret);
11629 ok(WSAGetLastError() == WSAEINVAL, "Got unexpected error %d.\n", WSAGetLastError());
11630 ok(!size, "Expected size %lu, got %lu.\n", expect_size, size);
11631 ok(overlapped.Internal == 0xdeadbeef, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
11632 ok(overlapped.InternalHigh == 0xdeadbeef, "Got size %Iu.\n", overlapped.InternalHigh);
11633
11634 overlapped.Internal = 0xdeadbeef;
11635 overlapped.InternalHigh = 0xdeadbeef;
11636 size = 0xdeadbeef;
11637 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer,
11638 FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), &size, &overlapped, NULL);
11639 ok(ret == -1, "Got unexpected ret %d.\n", ret);
11640 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11641 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11642 ok(overlapped.Internal == 0xdeadbeef, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
11643 ok(overlapped.InternalHigh == 0xdeadbeef, "Got size %Iu.\n", overlapped.InternalHigh);
11644 ok(address_list->iAddressCount == 0xcccccccc, "Got %u addresses.\n", address_list->iAddressCount);
11645
11646 overlapped.Internal = 0xdeadbeef;
11647 overlapped.InternalHigh = 0xdeadbeef;
11648 size = 0xdeadbeef;
11649 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), &size, &overlapped, NULL);
11650 ok(!ret, "Got unexpected ret %d.\n", ret);
11651 ok(!WSAGetLastError(), "Got unexpected error %d.\n", WSAGetLastError());
11652 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11653
11654 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11655 ok(ret, "Got error %lu.\n", GetLastError());
11656 ok(!size, "Got size %lu.\n", size);
11657 ok(overlapped_ptr == &overlapped, "Got overlapped %p.\n", overlapped_ptr);
11658 ok(!overlapped.Internal, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
11659 ok(!overlapped.InternalHigh, "Got size %Iu.\n", overlapped.InternalHigh);
11660
11661 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11662 ok(!ret, "Expected failure.\n");
11663 ok(GetLastError() == WAIT_TIMEOUT, "Got error %lu.\n", GetLastError());
11664
11665 closesocket(s);
11666 CloseHandle(port);
11667
11668 /* Test with an APC. */
11669
11670 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11671
11672 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), NULL, &overlapped, socket_apc);
11673 ok(ret == -1, "expected failure\n");
11674 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
11675
11676 apc_count = 0;
11677 size = 0xdeadbeef;
11678 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), &size, &overlapped, socket_apc);
11679 ok(!ret, "expected success\n");
11680 ok(size == expect_size, "got size %lu\n", size);
11681
11682 ret = SleepEx(0, TRUE);
11683 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
11684 ok(apc_count == 1, "APC was called %u times\n", apc_count);
11685 ok(!apc_error, "got APC error %lu\n", apc_error);
11686 ok(!apc_size, "got APC size %lu\n", apc_size);
11687 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
11688
11689 closesocket(s);
11690 }
11691
11692 static void sync_read(SOCKET src, SOCKET dst)
11693 {
11694 int ret;
11695 char data[512];
11696
11697 ret = send(dst, "Hello World!", 12, 0);
11698 ok(ret == 12, "send returned %d\n", ret);
11699
11700 memset(data, 0, sizeof(data));
11701 ret = recv(src, data, sizeof(data), 0);
11702 ok(ret == 12, "expected 12, got %d\n", ret);
11703 ok(!memcmp(data, "Hello World!", 12), "got %u bytes (%*s)\n", ret, ret, data);
11704 }
11705
11706 static void iocp_async_read(SOCKET src, SOCKET dst)
11707 {
11708 HANDLE port;
11709 WSAOVERLAPPED ovl, *ovl_iocp;
11710 WSABUF buf;
11711 int ret;
11712 char data[512];
11713 DWORD flags, bytes;
11714 ULONG_PTR key;
11715
11716 memset(data, 0, sizeof(data));
11717 memset(&ovl, 0, sizeof(ovl));
11718
11719 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11720 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
11721
11722 buf.len = sizeof(data);
11723 buf.buf = data;
11724 bytes = 0xdeadbeef;
11725 flags = 0;
11726 SetLastError(0xdeadbeef);
11727 ret = WSARecv(src, &buf, 1, &bytes, &flags, &ovl, NULL);
11728 ok(ret == SOCKET_ERROR, "got %d\n", ret);
11729 ok(GetLastError() == ERROR_IO_PENDING, "got %lu\n", GetLastError());
11730 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11731
11732 bytes = 0xdeadbeef;
11733 key = 0xdeadbeef;
11734 ovl_iocp = (void *)0xdeadbeef;
11735 SetLastError(0xdeadbeef);
11736 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11737 ok(!ret, "got %d\n", ret);
11738 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11739 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11740 ok(key == 0xdeadbeef, "got key %#Ix\n", key);
11741 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11742
11743 ret = send(dst, "Hello World!", 12, 0);
11744 ok(ret == 12, "send returned %d\n", ret);
11745
11746 bytes = 0xdeadbeef;
11747 key = 0xdeadbeef;
11748 ovl_iocp = NULL;
11749 SetLastError(0xdeadbeef);
11750 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11751 ok(ret, "got %d\n", ret);
11752 ok(bytes == 12, "got bytes %lu\n", bytes);
11753 ok(key == 0x12345678, "got key %#Ix\n", key);
11754 ok(ovl_iocp == &ovl, "got ovl %p\n", ovl_iocp);
11755 if (ovl_iocp)
11756 {
11757 ok(ovl_iocp->InternalHigh == 12, "got %#Ix\n", ovl_iocp->InternalHigh);
11758 ok(!ovl_iocp->Internal , "got %#Ix\n", ovl_iocp->Internal);
11759 ok(!memcmp(data, "Hello World!", 12), "got %lu bytes (%*s)\n", bytes, (int)bytes, data);
11760 }
11761
11762 bytes = 0xdeadbeef;
11763 key = 0xdeadbeef;
11764 ovl_iocp = (void *)0xdeadbeef;
11765 SetLastError(0xdeadbeef);
11766 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11767 ok(!ret, "got %d\n", ret);
11768 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11769 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11770 ok(key == 0xdeadbeef, "got key %#Ix\n", key);
11771 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11772
11773 CloseHandle(port);
11774 }
11775
11776 static void iocp_async_read_closesocket(SOCKET src, int how_to_close)
11777 {
11778 HANDLE port;
11779 WSAOVERLAPPED ovl, *ovl_iocp;
11780 WSABUF buf;
11781 int ret;
11782 char data[512];
11783 DWORD flags, bytes;
11784 ULONG_PTR key;
11785 HWND hwnd;
11786 MSG msg;
11787
11788 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
11789 0, 0, 0, 0, NULL, NULL, 0, NULL);
11790 ok(hwnd != 0, "CreateWindowEx failed\n");
11791
11792 ret = WSAAsyncSelect(src, hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
11793 ok(!ret, "got %d\n", ret);
11794
11795 Sleep(100);
11796 memset(&msg, 0, sizeof(msg));
11797 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11798 ok(ret, "got %d\n", ret);
11799 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11800 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11801 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
11802 ok(msg.lParam == 2, "got %08Ix\n", msg.lParam);
11803
11804 memset(data, 0, sizeof(data));
11805 memset(&ovl, 0, sizeof(ovl));
11806
11807 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11808 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
11809
11810 Sleep(100);
11811 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11812 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11813
11814 buf.len = sizeof(data);
11815 buf.buf = data;
11816 bytes = 0xdeadbeef;
11817 flags = 0;
11818 SetLastError(0xdeadbeef);
11819 ret = WSARecv(src, &buf, 1, &bytes, &flags, &ovl, NULL);
11820 ok(ret == SOCKET_ERROR, "got %d\n", ret);
11821 ok(GetLastError() == ERROR_IO_PENDING, "got %lu\n", GetLastError());
11822 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11823
11824 Sleep(100);
11825 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11826 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11827
11828 bytes = 0xdeadbeef;
11829 key = 0xdeadbeef;
11830 ovl_iocp = (void *)0xdeadbeef;
11831 SetLastError(0xdeadbeef);
11832 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11833 ok(!ret, "got %d\n", ret);
11834 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11835 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11836 ok(key == 0xdeadbeef, "got key %#Ix\n", key);
11837 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11838
11839 Sleep(100);
11840 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11841 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11842
11843 switch (how_to_close)
11844 {
11845 case 0:
11846 closesocket(src);
11847 break;
11848 case 1:
11849 CloseHandle((HANDLE)src);
11850 break;
11851 case 2:
11852 pNtClose((HANDLE)src);
11853 break;
11854 default:
11855 ok(0, "wrong value %d\n", how_to_close);
11856 break;
11857 }
11858
11859 Sleep(200);
11860 memset(&msg, 0, sizeof(msg));
11861 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11862 switch (how_to_close)
11863 {
11864 case 0:
11865 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11866 break;
11867 case 1:
11868 case 2:
11869 todo_wine
11870 {
11871 ok(ret, "got %d\n", ret);
11872 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11873 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11874 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
11875 ok(msg.lParam == 0x20, "got %08Ix\n", msg.lParam);
11876 }
11877 break;
11878 default:
11879 ok(0, "wrong value %d\n", how_to_close);
11880 break;
11881 }
11882
11883 bytes = 0xdeadbeef;
11884 key = 0xdeadbeef;
11885 ovl_iocp = NULL;
11886 SetLastError(0xdeadbeef);
11887 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11888 ok(!ret, "got %d\n", ret);
11889 todo_wine
11890 ok(GetLastError() == ERROR_CONNECTION_ABORTED || GetLastError() == ERROR_NETNAME_DELETED /* XP */, "got %lu\n", GetLastError());
11891 ok(!bytes, "got bytes %lu\n", bytes);
11892 ok(key == 0x12345678, "got key %#Ix\n", key);
11893 ok(ovl_iocp == &ovl, "got ovl %p\n", ovl_iocp);
11894 if (ovl_iocp)
11895 {
11896 ok(!ovl_iocp->InternalHigh, "got %#Ix\n", ovl_iocp->InternalHigh);
11897 todo_wine
11898 ok(ovl_iocp->Internal == (ULONG)STATUS_CONNECTION_ABORTED || ovl_iocp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT /* XP */, "got %#Ix\n", ovl_iocp->Internal);
11899 }
11900
11901 bytes = 0xdeadbeef;
11902 key = 0xdeadbeef;
11903 ovl_iocp = (void *)0xdeadbeef;
11904 SetLastError(0xdeadbeef);
11905 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11906 ok(!ret, "got %d\n", ret);
11907 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11908 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11909 ok(key == 0xdeadbeef, "got key %#Ix\n", key);
11910 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11911
11912 CloseHandle(port);
11913
11914 DestroyWindow(hwnd);
11915 }
11916
11917 static void iocp_async_closesocket(SOCKET src)
11918 {
11919 HANDLE port;
11920 WSAOVERLAPPED *ovl_iocp;
11921 int ret;
11922 DWORD bytes;
11923 ULONG_PTR key;
11924 HWND hwnd;
11925 MSG msg;
11926
11927 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
11928 0, 0, 0, 0, NULL, NULL, 0, NULL);
11929 ok(hwnd != 0, "CreateWindowEx failed\n");
11930
11931 ret = WSAAsyncSelect(src, hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
11932 ok(!ret, "got %d\n", ret);
11933
11934 Sleep(100);
11935 memset(&msg, 0, sizeof(msg));
11936 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11937 ok(ret, "got %d\n", ret);
11938 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11939 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11940 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
11941 ok(msg.lParam == 2, "got %08Ix\n", msg.lParam);
11942
11943 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11944 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
11945
11946 Sleep(100);
11947 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11948 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11949
11950 bytes = 0xdeadbeef;
11951 key = 0xdeadbeef;
11952 ovl_iocp = (void *)0xdeadbeef;
11953 SetLastError(0xdeadbeef);
11954 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11955 ok(!ret, "got %d\n", ret);
11956 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11957 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11958 ok(key == 0xdeadbeef, "got key %Iu\n", key);
11959 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11960
11961 Sleep(100);
11962 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11963 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11964
11965 closesocket(src);
11966
11967 Sleep(100);
11968 memset(&msg, 0, sizeof(msg));
11969 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11970 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11971
11972 bytes = 0xdeadbeef;
11973 key = 0xdeadbeef;
11974 ovl_iocp = (void *)0xdeadbeef;
11975 SetLastError(0xdeadbeef);
11976 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11977 ok(!ret, "got %d\n", ret);
11978 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11979 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11980 ok(key == 0xdeadbeef, "got key %Iu\n", key);
11981 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11982
11983 CloseHandle(port);
11984
11985 DestroyWindow(hwnd);
11986 }
11987
11988 struct wsa_async_select_info
11989 {
11990 SOCKET sock;
11991 HWND hwnd;
11992 };
11993
11994 static DWORD WINAPI wsa_async_select_thread(void *param)
11995 {
11996 struct wsa_async_select_info *info = param;
11997 int ret;
11998
11999 ret = WSAAsyncSelect(info->sock, info->hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
12000 ok(!ret, "got %d\n", ret);
12001
12002 return 0;
12003 }
12004
12005 struct wsa_recv_info
12006 {
12007 SOCKET sock;
12008 WSABUF wsa_buf;
12009 WSAOVERLAPPED ovl;
12010 };
12011
12012 static DWORD WINAPI wsa_recv_thread(void *param)
12013 {
12014 struct wsa_recv_info *info = param;
12015 int ret;
12016 DWORD flags, bytes;
12017
12018 bytes = 0xdeadbeef;
12019 flags = 0;
12020 SetLastError(0xdeadbeef);
12021 ret = WSARecv(info->sock, &info->wsa_buf, 1, &bytes, &flags, &info->ovl, NULL);
12022 ok(ret == SOCKET_ERROR, "got %d\n", ret);
12023 ok(GetLastError() == ERROR_IO_PENDING, "got %lu\n", GetLastError());
12024 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
12025
12026 return 0;
12027 }
12028
12029 static void iocp_async_read_thread_closesocket(SOCKET src)
12030 {
12031 struct wsa_async_select_info select_info;
12032 struct wsa_recv_info recv_info;
12033 HANDLE port, thread;
12034 WSAOVERLAPPED *ovl_iocp;
12035 int ret;
12036 char data[512];
12037 DWORD bytes, tid;
12038 ULONG_PTR key;
12039 HWND hwnd;
12040 MSG msg;
12041
12042 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
12043 0, 0, 0, 0, NULL, NULL, 0, NULL);
12044 ok(hwnd != 0, "CreateWindowEx failed\n");
12045
12046 select_info.sock = src;
12047 select_info.hwnd = hwnd;
12048 thread = CreateThread(NULL, 0, wsa_async_select_thread, &select_info, 0, &tid);
12049 ok(thread != 0, "CreateThread error %lu\n", GetLastError());
12050 ret = WaitForSingleObject(thread, 10000);
12051 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
12052
12053 Sleep(100);
12054 memset(&msg, 0, sizeof(msg));
12055 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12056 ok(ret, "got %d\n", ret);
12057 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
12058 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
12059 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
12060 ok(msg.lParam == 2, "got %08Ix\n", msg.lParam);
12061
12062 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
12063 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
12064
12065 Sleep(100);
12066 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12067 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12068
12069 memset(data, 0, sizeof(data));
12070 memset(&recv_info.ovl, 0, sizeof(recv_info.ovl));
12071 recv_info.sock = src;
12072 recv_info.wsa_buf.len = sizeof(data);
12073 recv_info.wsa_buf.buf = data;
12074 thread = CreateThread(NULL, 0, wsa_recv_thread, &recv_info, 0, &tid);
12075 ok(thread != 0, "CreateThread error %lu\n", GetLastError());
12076 ret = WaitForSingleObject(thread, 10000);
12077 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
12078
12079 Sleep(100);
12080 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12081 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12082
12083 bytes = 0xdeadbeef;
12084 key = 0xdeadbeef;
12085 ovl_iocp = (void *)0xdeadbeef;
12086 SetLastError(0xdeadbeef);
12087 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
12088 ok(!ret, "got %d\n", ret);
12089 ok(GetLastError() == WAIT_TIMEOUT || broken(GetLastError() == ERROR_OPERATION_ABORTED) /* XP */,
12090 "got %lu\n", GetLastError());
12091 if (GetLastError() == WAIT_TIMEOUT)
12092 {
12093 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
12094 ok(key == 0xdeadbeef, "got key %Ix\n", key);
12095 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
12096 }
12097 else /* document XP behaviour */
12098 {
12099 ok(!bytes, "got bytes %lu\n", bytes);
12100 ok(key == 0x12345678, "got key %#Ix\n", key);
12101 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
12102 if (ovl_iocp)
12103 {
12104 ok(!ovl_iocp->InternalHigh, "got %#Ix\n", ovl_iocp->InternalHigh);
12105 ok(ovl_iocp->Internal == STATUS_CANCELLED, "got %#Ix\n", ovl_iocp->Internal);
12106 }
12107
12108 closesocket(src);
12109 goto xp_is_broken;
12110 }
12111
12112 Sleep(100);
12113 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12114 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12115
12116 closesocket(src);
12117
12118 Sleep(100);
12119 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12120 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12121
12122 bytes = 0xdeadbeef;
12123 key = 0xdeadbeef;
12124 ovl_iocp = NULL;
12125 SetLastError(0xdeadbeef);
12126 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
12127 ok(!ret, "got %d\n", ret);
12128 todo_wine
12129 ok(GetLastError() == ERROR_CONNECTION_ABORTED || GetLastError() == ERROR_NETNAME_DELETED /* XP */, "got %lu\n", GetLastError());
12130 ok(!bytes, "got bytes %lu\n", bytes);
12131 ok(key == 0x12345678, "got key %#Ix\n", key);
12132 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
12133 if (ovl_iocp)
12134 {
12135 ok(!ovl_iocp->InternalHigh, "got %#Ix\n", ovl_iocp->InternalHigh);
12136 todo_wine
12137 ok(ovl_iocp->Internal == (ULONG)STATUS_CONNECTION_ABORTED || ovl_iocp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT /* XP */, "got %#Ix\n", ovl_iocp->Internal);
12138 }
12139
12140 xp_is_broken:
12141 bytes = 0xdeadbeef;
12142 key = 0xdeadbeef;
12143 ovl_iocp = (void *)0xdeadbeef;
12144 SetLastError(0xdeadbeef);
12145 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
12146 ok(!ret, "got %d\n", ret);
12147 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
12148 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
12149 ok(key == 0xdeadbeef, "got key %Iu\n", key);
12150 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
12151
12152 CloseHandle(port);
12153
12154 DestroyWindow(hwnd);
12155 }
12156
12157 static void iocp_async_read_thread(SOCKET src, SOCKET dst)
12158 {
12159 struct wsa_async_select_info select_info;
12160 struct wsa_recv_info recv_info;
12161 HANDLE port, thread;
12162 WSAOVERLAPPED *ovl_iocp;
12163 int ret;
12164 char data[512];
12165 DWORD bytes, tid;
12166 ULONG_PTR key;
12167 HWND hwnd;
12168 MSG msg;
12169
12170 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
12171 0, 0, 0, 0, NULL, NULL, 0, NULL);
12172 ok(hwnd != 0, "CreateWindowEx failed\n");
12173
12174 select_info.sock = src;
12175 select_info.hwnd = hwnd;
12176 thread = CreateThread(NULL, 0, wsa_async_select_thread, &select_info, 0, &tid);
12177 ok(thread != 0, "CreateThread error %lu\n", GetLastError());
12178 ret = WaitForSingleObject(thread, 10000);
12179 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
12180
12181 Sleep(100);
12182 memset(&msg, 0, sizeof(msg));
12183 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12184 ok(ret, "got %d\n", ret);
12185 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
12186 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
12187 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
12188 ok(msg.lParam == 2, "got %08Ix\n", msg.lParam);
12189
12190 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
12191 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
12192
12193 Sleep(100);
12194 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12195 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12196
12197 memset(data, 0, sizeof(data));
12198 memset(&recv_info.ovl, 0, sizeof(recv_info.ovl));
12199 recv_info.sock = src;
12200 recv_info.wsa_buf.len = sizeof(data);
12201 recv_info.wsa_buf.buf = data;
12202 thread = CreateThread(NULL, 0, wsa_recv_thread, &recv_info, 0, &tid);
12203 ok(thread != 0, "CreateThread error %lu\n", GetLastError());
12204 ret = WaitForSingleObject(thread, 10000);
12205 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
12206
12207 Sleep(100);
12208 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12209 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12210
12211 bytes = 0xdeadbeef;
12212 key = 0xdeadbeef;
12213 ovl_iocp = (void *)0xdeadbeef;
12214 SetLastError(0xdeadbeef);
12215 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
12216 ok(!ret, "got %d\n", ret);
12217 ok(GetLastError() == WAIT_TIMEOUT || broken(GetLastError() == ERROR_OPERATION_ABORTED) /* XP */, "got %lu\n", GetLastError());
12218 if (GetLastError() == WAIT_TIMEOUT)
12219 {
12220 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
12221 ok(key == 0xdeadbeef, "got key %Iu\n", key);
12222 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
12223 }
12224 else /* document XP behaviour */
12225 {
12226 ok(bytes == 0, "got bytes %lu\n", bytes);
12227 ok(key == 0x12345678, "got key %#Ix\n", key);
12228 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
12229 if (ovl_iocp)
12230 {
12231 ok(!ovl_iocp->InternalHigh, "got %#Ix\n", ovl_iocp->InternalHigh);
12232 ok(ovl_iocp->Internal == STATUS_CANCELLED, "got %#Ix\n", ovl_iocp->Internal);
12233 }
12234 }
12235
12236 Sleep(100);
12237 memset(&msg, 0, sizeof(msg));
12238 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12239 ok(!ret || broken(msg.hwnd == hwnd) /* XP */, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12240 if (ret) /* document XP behaviour */
12241 {
12242 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
12243 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
12244 ok(msg.lParam == 1, "got %08Ix\n", msg.lParam);
12245 }
12246
12247 ret = send(dst, "Hello World!", 12, 0);
12248 ok(ret == 12, "send returned %d\n", ret);
12249
12250 Sleep(100);
12251 memset(&msg, 0, sizeof(msg));
12252 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12253 ok(!ret || broken(msg.hwnd == hwnd) /* XP */, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12254 if (ret) /* document XP behaviour */
12255 {
12256 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
12257 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
12258 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
12259 ok(msg.lParam == 1, "got %08Ix\n", msg.lParam);
12260 }
12261
12262 bytes = 0xdeadbeef;
12263 key = 0xdeadbeef;
12264 ovl_iocp = (void *)0xdeadbeef;
12265 SetLastError(0xdeadbeef);
12266 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
12267 ok(ret || broken(GetLastError() == WAIT_TIMEOUT) /* XP */, "got %lu\n", GetLastError());
12268 if (ret)
12269 {
12270 ok(bytes == 12, "got bytes %lu\n", bytes);
12271 ok(key == 0x12345678, "got key %#Ix\n", key);
12272 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
12273 if (ovl_iocp)
12274 {
12275 ok(ovl_iocp->InternalHigh == 12, "got %#Ix\n", ovl_iocp->InternalHigh);
12276 ok(!ovl_iocp->Internal , "got %#Ix\n", ovl_iocp->Internal);
12277 ok(!memcmp(data, "Hello World!", 12), "got %lu bytes (%*s)\n", bytes, (int)bytes, data);
12278 }
12279 }
12280 else /* document XP behaviour */
12281 {
12282 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
12283 ok(key == 0xdeadbeef, "got key %Iu\n", key);
12284 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
12285 }
12286
12287 CloseHandle(port);
12288
12289 DestroyWindow(hwnd);
12290 }
12291
12292 static void test_iocp(void)
12293 {
12294 SOCKET src, dst;
12295 int i;
12296
12297 tcp_socketpair(&src, &dst);
12298 sync_read(src, dst);
12299 iocp_async_read(src, dst);
12300 closesocket(src);
12301 closesocket(dst);
12302
12303 tcp_socketpair(&src, &dst);
12304 iocp_async_read_thread(src, dst);
12305 closesocket(src);
12306 closesocket(dst);
12307
12308 for (i = 0; i <= 2; i++)
12309 {
12310 tcp_socketpair(&src, &dst);
12311 iocp_async_read_closesocket(src, i);
12312 closesocket(dst);
12313 }
12314
12315 tcp_socketpair(&src, &dst);
12316 iocp_async_closesocket(src);
12317 closesocket(dst);
12318
12319 tcp_socketpair(&src, &dst);
12320 iocp_async_read_thread_closesocket(src);
12321 closesocket(dst);
12322 }
12323
12324 static void test_get_interface_list(void)
12325 {
12326 OVERLAPPED overlapped = {0}, *overlapped_ptr;
12327 DWORD size, expect_size;
12328 unsigned int i, count;
12329 INTERFACE_INFO *info;
12330 BOOL loopback_found;
12331 char buffer[4096];
12332 ULONG_PTR key;
12333 HANDLE port;
12334 SOCKET s;
12335 int ret;
12336
12337 s = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
12338 ok(s != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
12339 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
12340
12341 size = 0xdeadbeef;
12342 WSASetLastError(0xdeadbeef);
12343 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(buffer), &size, NULL, NULL);
12344 ok(!ret, "Got unexpected ret %d.\n", ret);
12345 ok(!WSAGetLastError(), "Got error %u.\n", WSAGetLastError());
12346 ok(size && size != 0xdeadbeef && !(size % sizeof(INTERFACE_INFO)), "Got unexpected size %lu.\n", size);
12347 expect_size = size;
12348
12349 size = 0xdeadbeef;
12350 overlapped.Internal = 0xdeadbeef;
12351 overlapped.InternalHigh = 0xdeadbeef;
12352 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(buffer), &size, &overlapped, NULL);
12353 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12354 ok(WSAGetLastError() == ERROR_IO_PENDING, "Got error %u.\n", WSAGetLastError());
12355 ok(size == 0xdeadbeef, "Got size %lu.\n", size);
12356
12357 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 100);
12358 ok(ret, "Got error %lu.\n", GetLastError());
12359 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
12360 ok(key == 123, "Got key %Iu.\n", key);
12361 ok(overlapped_ptr == &overlapped, "Got overlapped %p.\n", overlapped_ptr);
12362 ok(!overlapped.Internal, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
12363 ok(overlapped.InternalHigh == expect_size, "Expected size %lu, got %Iu.\n", expect_size, overlapped.InternalHigh);
12364
12365 info = (INTERFACE_INFO *)buffer;
12366 count = size / sizeof(INTERFACE_INFO);
12367 loopback_found = FALSE;
12368 for (i = 0; i < count; ++i)
12369 {
12370 if (info[i].iiFlags & IFF_LOOPBACK)
12371 loopback_found = TRUE;
12372
12373 ok(info[i].iiAddress.AddressIn.sin_family == AF_INET, "Got unexpected sin_family %#x.\n",
12374 info[i].iiAddress.AddressIn.sin_family);
12375 ok(info[i].iiNetmask.AddressIn.sin_family == AF_INET, "Got unexpected sin_family %#x.\n",
12376 info[i].iiNetmask.AddressIn.sin_family);
12377 ok(info[i].iiBroadcastAddress.AddressIn.sin_family
12378 == (info[i].iiFlags & IFF_BROADCAST) ? AF_INET : 0, "Got unexpected sin_family %#x.\n",
12379 info[i].iiBroadcastAddress.AddressIn.sin_family);
12380 ok(info[i].iiAddress.AddressIn.sin_addr.S_un.S_addr, "Got zero iiAddress.\n");
12381 ok(info[i].iiNetmask.AddressIn.sin_addr.S_un.S_addr, "Got zero iiNetmask.\n");
12382 ok((info[i].iiFlags & IFF_BROADCAST) ? info[i].iiBroadcastAddress.AddressIn.sin_addr.S_un.S_addr
12383 : !info[i].iiBroadcastAddress.AddressIn.sin_addr.S_un.S_addr,
12384 "Got unexpected iiBroadcastAddress %s.\n", inet_ntoa(info[i].iiBroadcastAddress.AddressIn.sin_addr));
12385 }
12386
12387 ok(loopback_found, "Loopback interface not found.\n");
12388
12389 size = 0xdeadbeef;
12390 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(INTERFACE_INFO) - 1, &size, NULL, NULL);
12391 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12392 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
12393 ok(!size, "Got unexpected size %lu.\n", size);
12394
12395 size = 0xdeadbeef;
12396 overlapped.Internal = 0xdeadbeef;
12397 overlapped.InternalHigh = 0xdeadbeef;
12398 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(INTERFACE_INFO) - 1, &size, &overlapped, NULL);
12399 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12400 ok(WSAGetLastError() == ERROR_IO_PENDING, "Got error %u.\n", WSAGetLastError());
12401 ok(size == 0xdeadbeef, "Got size %lu.\n", size);
12402
12403 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 100);
12404 ok(!ret, "Expected failure.\n");
12405 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Got error %lu.\n", GetLastError());
12406 ok(!size, "Got size %lu.\n", size);
12407 ok(key == 123, "Got key %Iu.\n", key);
12408 ok(overlapped_ptr == &overlapped, "Got overlapped %p.\n", overlapped_ptr);
12409 ok((NTSTATUS)overlapped.Internal == STATUS_BUFFER_TOO_SMALL, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
12410 ok(!overlapped.InternalHigh, "Got size %Iu.\n", overlapped.InternalHigh);
12411
12412 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(buffer), NULL, NULL, NULL);
12413 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12414 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
12415
12416 CloseHandle(port);
12417 closesocket(s);
12418
12419 /* Test with an APC. */
12420
12421 s = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
12422 ok(s != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
12423
12424 size = 0xdeadbeef;
12425 apc_count = 0;
12426 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer,
12427 sizeof(INTERFACE_INFO) - 1, &size, &overlapped, socket_apc);
12428 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12429 ok(WSAGetLastError() == ERROR_IO_PENDING, "Got error %u.\n", WSAGetLastError());
12430 ok(size == 0xdeadbeef, "Got size %lu.\n", size);
12431
12432 ret = SleepEx(100, TRUE);
12433 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
12434 ok(apc_count == 1, "APC was called %u times\n", apc_count);
12435 ok(apc_error == WSAEFAULT, "got APC error %lu\n", apc_error);
12436 ok(!apc_size, "got APC size %lu\n", apc_size);
12437 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
12438
12439 closesocket(s);
12440 }
12441
12442 static IP_ADAPTER_ADDRESSES *get_adapters(void)
12443 {
12444 ULONG err, size = 4096;
12445 IP_ADAPTER_ADDRESSES *tmp, *ret;
12446
12447 if (!(ret = malloc( size ))) return NULL;
12448 err = GetAdaptersAddresses( AF_UNSPEC, 0, NULL, ret, &size );
12449 while (err == ERROR_BUFFER_OVERFLOW)
12450 {
12451 if (!(tmp = realloc( ret, size ))) break;
12452 ret = tmp;
12453 err = GetAdaptersAddresses( AF_UNSPEC, 0, NULL, ret, &size );
12454 }
12455 if (err == ERROR_SUCCESS) return ret;
12456 free( ret );
12457 return NULL;
12458 }
12459
12460 static void test_bind(void)
12461 {
12462 const struct sockaddr_in invalid_addr = {.sin_family = AF_INET, .sin_addr.s_addr = inet_addr("192.0.2.0")};
12463 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
12464 IP_ADAPTER_ADDRESSES *adapters, *adapter;
12465 struct sockaddr addr;
12466 SOCKET s, s2;
12467 int ret, len;
12468
12469 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12470
12471 WSASetLastError(0xdeadbeef);
12472 ret = bind(s, NULL, 0);
12473 ok(ret == -1, "expected failure\n");
12474 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12475
12476 WSASetLastError(0xdeadbeef);
12477 ret = bind(s, NULL, sizeof(addr));
12478 ok(ret == -1, "expected failure\n");
12479 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12480
12481 addr.sa_family = AF_INET;
12482 WSASetLastError(0xdeadbeef);
12483 ret = bind(s, &addr, 0);
12484 ok(ret == -1, "expected failure\n");
12485 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12486
12487 addr.sa_family = 0xdead;
12488 WSASetLastError(0xdeadbeef);
12489 ret = bind(s, &addr, sizeof(addr));
12490 ok(ret == -1, "expected failure\n");
12491 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError());
12492
12493 WSASetLastError(0xdeadbeef);
12494 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr) - 1);
12495 ok(ret == -1, "expected failure\n");
12496 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12497
12498 WSASetLastError(0xdeadbeef);
12499 ret = bind(s, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
12500 ok(ret == -1, "expected failure\n");
12501 ok(WSAGetLastError() == WSAEADDRNOTAVAIL, "got error %u\n", WSAGetLastError());
12502
12503 WSASetLastError(0xdeadbeef);
12504 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12505 ok(!ret, "expected success\n");
12506 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
12507
12508 WSASetLastError(0xdeadbeef);
12509 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12510 ok(ret == -1, "expected failure\n");
12511 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
12512
12513 len = sizeof(addr);
12514 ret = getsockname(s, &addr, &len);
12515 ok(!ret, "got error %u\n", WSAGetLastError());
12516
12517 s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12518
12519 WSASetLastError(0xdeadbeef);
12520 ret = bind(s2, &addr, sizeof(addr));
12521 ok(ret == -1, "expected failure\n");
12522 ok(WSAGetLastError() == WSAEADDRINUSE, "got error %u\n", WSAGetLastError());
12523
12524 closesocket(s2);
12525 closesocket(s);
12526
12527 s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
12528
12529 WSASetLastError(0xdeadbeef);
12530 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12531 ok(!ret, "expected success\n");
12532 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
12533
12534 closesocket(s);
12535
12536 adapters = get_adapters();
12537 ok(adapters != NULL, "can't get adapters\n");
12538
12539 for (adapter = adapters; adapter != NULL; adapter = adapter->Next)
12540 {
12541 const IP_ADAPTER_UNICAST_ADDRESS *unicast_addr;
12542
12543 if (adapter->OperStatus != IfOperStatusUp) continue;
12544
12545 for (unicast_addr = adapter->FirstUnicastAddress; unicast_addr != NULL; unicast_addr = unicast_addr->Next)
12546 {
12547 short family = unicast_addr->Address.lpSockaddr->sa_family;
12548
12549 s = socket(family, SOCK_STREAM, IPPROTO_TCP);
12550 ok(s != -1, "failed to create socket, error %u\n", WSAGetLastError());
12551
12552 ret = bind(s, unicast_addr->Address.lpSockaddr, unicast_addr->Address.iSockaddrLength);
12553 ok(!ret, "got error %u\n", WSAGetLastError());
12554
12555 closesocket(s);
12556
12557 if (family == AF_INET6)
12558 {
12559 struct sockaddr_in6 addr6, ret_addr6;
12560
12561 memcpy(&addr6, unicast_addr->Address.lpSockaddr, sizeof(addr6));
12562
12563 ok(unicast_addr->Address.iSockaddrLength == sizeof(struct sockaddr_in6),
12564 "got unexpected length %u\n", unicast_addr->Address.iSockaddrLength);
12565
12566 s = socket(family, SOCK_STREAM, IPPROTO_TCP);
12567 ok(s != -1, "failed to create socket, error %u\n", WSAGetLastError());
12568
12569 ret = bind(s, unicast_addr->Address.lpSockaddr, sizeof(struct sockaddr_in6_old));
12570 ok(ret == -1, "expected failure\n");
12571 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12572
12573 addr6.sin6_scope_id = 0xabacab;
12574 ret = bind(s, (struct sockaddr *)&addr6, sizeof(addr6));
12575 todo_wine_if (!((const struct sockaddr_in6 *)unicast_addr->Address.lpSockaddr)->sin6_scope_id)
12576 {
12577 ok(ret == -1, "expected failure\n");
12578 ok(WSAGetLastError() == WSAEADDRNOTAVAIL, "got error %u\n", WSAGetLastError());
12579 }
12580
12581 addr6.sin6_scope_id = 0;
12582 ret = bind(s, (struct sockaddr *)&addr6, sizeof(addr6));
12583 todo_wine_if (!((const struct sockaddr_in6 *)unicast_addr->Address.lpSockaddr)->sin6_scope_id)
12584 ok(!ret, "got error %u\n", WSAGetLastError());
12585
12586 memcpy(&addr6, unicast_addr->Address.lpSockaddr, sizeof(addr6));
12587
12588 len = sizeof(struct sockaddr_in6_old);
12589 ret = getsockname(s, (struct sockaddr *)&ret_addr6, &len);
12590 ok(ret == -1, "expected failure\n");
12591 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12592
12593 len = sizeof(ret_addr6);
12594 memset(&ret_addr6, 0, sizeof(ret_addr6));
12595 ret = getsockname(s, (struct sockaddr *)&ret_addr6, &len);
12596 ok(!ret, "got error %u\n", WSAGetLastError());
12597 ok(ret_addr6.sin6_family == AF_INET6, "got family %u\n", ret_addr6.sin6_family);
12598 ok(ret_addr6.sin6_port != 0, "expected nonzero port\n");
12599 ok(!memcmp(&ret_addr6.sin6_addr, &addr6.sin6_addr, sizeof(addr6.sin6_addr)), "address didn't match\n");
12600 ok(ret_addr6.sin6_scope_id == addr6.sin6_scope_id, "got scope %lu\n", ret_addr6.sin6_scope_id);
12601
12602 closesocket(s);
12603 }
12604 }
12605 }
12606
12607 free(adapters);
12608 }
12609
12610 /* Test calling methods on a socket which is currently connecting. */
12611 static void test_connecting_socket(void)
12612 {
12613 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_ANY)};
12614 const struct sockaddr_in invalid_addr =
12615 {
12616 .sin_family = AF_INET,
12617 .sin_addr.s_addr = inet_addr("192.0.2.0"),
12618 .sin_port = 255
12619 };
12620 OVERLAPPED overlapped = {0}, overlapped2 = {0};
12621 GUID connectex_guid = WSAID_CONNECTEX;
12622 LPFN_CONNECTEX pConnectEx;
12623 struct sockaddr_in addr;
12624 char buffer[4];
12625 SOCKET client;
12626 int ret, len;
12627 DWORD size;
12628
12629 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12630 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
12631 set_blocking(client, FALSE);
12632
12633 ret = bind(client, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12634 ok(!ret, "expected success\n");
12635 ok(!WSAGetLastError(), "got %u\n", WSAGetLastError());
12636
12637 ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
12638 ok(ret == -1, "got %d\n", ret);
12639 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got %u\n", WSAGetLastError());
12640
12641 /* Mortal Kombat 11 connects to the same address twice and expects the
12642 * second to return WSAEALREADY. */
12643 ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
12644 ok(ret == -1, "got %d\n", ret);
12645 ok(WSAGetLastError() == WSAEALREADY, "got %u\n", WSAGetLastError());
12646
12647 ret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectex_guid, sizeof(connectex_guid),
12648 &pConnectEx, sizeof(pConnectEx), &size, NULL, NULL);
12649 ok(!ret, "failed to get ConnectEx, error %u\n", WSAGetLastError());
12650 overlapped.Internal = 0xdeadbeef;
12651 overlapped.InternalHigh = 0xdeadbeef;
12652 ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped);
12653 ok(!ret, "got %d\n", ret);
12654 ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError());
12655 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
12656 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
12657
12658 len = sizeof(addr);
12659 ret = getsockname(client, (struct sockaddr *)&addr, &len);
12660 ok(!ret, "got error %u\n", WSAGetLastError());
12661 ok(addr.sin_family == AF_INET, "got family %u\n", addr.sin_family);
12662 ok(addr.sin_port, "expected nonzero port\n");
12663
12664 len = sizeof(addr);
12665 ret = getpeername(client, (struct sockaddr *)&addr, &len);
12666 ok(!ret, "got error %u\n", WSAGetLastError());
12667
12668 ret = recv(client, buffer, sizeof(buffer), 0);
12669 ok(ret == -1, "got %d\n", ret);
12670 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12671
12672 ret = send(client, "data", 5, 0);
12673 ok(ret == -1, "got %d\n", ret);
12674 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12675
12676 closesocket(client);
12677
12678 /* Test with ConnectEx(). */
12679
12680 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12681 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
12682 set_blocking(client, FALSE);
12683
12684 ret = bind(client, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12685 ok(!ret, "expected success\n");
12686 ok(!WSAGetLastError(), "got %u\n", WSAGetLastError());
12687
12688 ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped2);
12689 ok(!ret, "got %d\n", ret);
12690 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
12691
12692 ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
12693 ok(ret == -1, "got %d\n", ret);
12694 ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError());
12695
12696 overlapped.Internal = 0xdeadbeef;
12697 overlapped.InternalHigh = 0xdeadbeef;
12698 ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped);
12699 ok(!ret, "got %d\n", ret);
12700 ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError());
12701 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
12702 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
12703
12704 len = sizeof(addr);
12705 ret = getsockname(client, (struct sockaddr *)&addr, &len);
12706 ok(!ret, "got error %u\n", WSAGetLastError());
12707 ok(addr.sin_family == AF_INET, "got family %u\n", addr.sin_family);
12708 ok(addr.sin_port, "expected nonzero port\n");
12709
12710 len = sizeof(addr);
12711 ret = getpeername(client, (struct sockaddr *)&addr, &len);
12712 ok(ret == -1, "got %d\n", ret);
12713 ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12714
12715 ret = recv(client, buffer, sizeof(buffer), 0);
12716 ok(ret == -1, "got %d\n", ret);
12717 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12718
12719 ret = send(client, "data", 5, 0);
12720 ok(ret == -1, "got %d\n", ret);
12721 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12722
12723 closesocket(client);
12724 }
12725
12726 static DWORD map_status( NTSTATUS status )
12727 {
12728 static const struct
12729 {
12730 NTSTATUS status;
12731 DWORD error;
12732 }
12733 errors[] =
12734 {
12735 {STATUS_PENDING, ERROR_IO_INCOMPLETE},
12736
12737 {STATUS_BUFFER_OVERFLOW, WSAEMSGSIZE},
12738
12739 {STATUS_NOT_IMPLEMENTED, WSAEOPNOTSUPP},
12740 {STATUS_ACCESS_VIOLATION, WSAEFAULT},
12741 {STATUS_PAGEFILE_QUOTA, WSAENOBUFS},
12742 {STATUS_INVALID_HANDLE, WSAENOTSOCK},
12743 {STATUS_NO_SUCH_DEVICE, WSAENETDOWN},
12744 {STATUS_NO_SUCH_FILE, WSAENETDOWN},
12745 {STATUS_NO_MEMORY, WSAENOBUFS},
12746 {STATUS_CONFLICTING_ADDRESSES, WSAENOBUFS},
12747 {STATUS_ACCESS_DENIED, WSAEACCES},
12748 {STATUS_BUFFER_TOO_SMALL, WSAEFAULT},
12749 {STATUS_OBJECT_TYPE_MISMATCH, WSAENOTSOCK},
12750 {STATUS_OBJECT_NAME_NOT_FOUND, WSAENETDOWN},
12751 {STATUS_OBJECT_PATH_NOT_FOUND, WSAENETDOWN},
12752 {STATUS_SHARING_VIOLATION, WSAEADDRINUSE},
12753 {STATUS_QUOTA_EXCEEDED, WSAENOBUFS},
12754 {STATUS_TOO_MANY_PAGING_FILES, WSAENOBUFS},
12755 {STATUS_INSUFFICIENT_RESOURCES, WSAENOBUFS},
12756 {STATUS_WORKING_SET_QUOTA, WSAENOBUFS},
12757 {STATUS_DEVICE_NOT_READY, WSAEWOULDBLOCK},
12758 {STATUS_PIPE_DISCONNECTED, WSAESHUTDOWN},
12759 {STATUS_IO_TIMEOUT, WSAETIMEDOUT},
12760 {STATUS_NOT_SUPPORTED, WSAEOPNOTSUPP},
12761 {STATUS_REMOTE_NOT_LISTENING, WSAECONNREFUSED},
12762 {STATUS_BAD_NETWORK_PATH, WSAENETUNREACH},
12763 {STATUS_NETWORK_BUSY, WSAENETDOWN},
12764 {STATUS_INVALID_NETWORK_RESPONSE, WSAENETDOWN},
12765 {STATUS_UNEXPECTED_NETWORK_ERROR, WSAENETDOWN},
12766 {STATUS_REQUEST_NOT_ACCEPTED, WSAEWOULDBLOCK},
12767 {STATUS_CANCELLED, ERROR_OPERATION_ABORTED},
12768 {STATUS_COMMITMENT_LIMIT, WSAENOBUFS},
12769 {STATUS_LOCAL_DISCONNECT, WSAECONNABORTED},
12770 {STATUS_REMOTE_DISCONNECT, WSAECONNRESET},
12771 {STATUS_REMOTE_RESOURCES, WSAENOBUFS},
12772 {STATUS_LINK_FAILED, WSAECONNRESET},
12773 {STATUS_LINK_TIMEOUT, WSAETIMEDOUT},
12774 {STATUS_INVALID_CONNECTION, WSAENOTCONN},
12775 {STATUS_INVALID_ADDRESS, WSAEADDRNOTAVAIL},
12776 {STATUS_INVALID_BUFFER_SIZE, WSAEMSGSIZE},
12777 {STATUS_INVALID_ADDRESS_COMPONENT, WSAEADDRNOTAVAIL},
12778 {STATUS_TOO_MANY_ADDRESSES, WSAENOBUFS},
12779 {STATUS_ADDRESS_ALREADY_EXISTS, WSAEADDRINUSE},
12780 {STATUS_CONNECTION_DISCONNECTED, WSAECONNRESET},
12781 {STATUS_CONNECTION_RESET, WSAECONNRESET},
12782 {STATUS_TRANSACTION_ABORTED, WSAECONNABORTED},
12783 {STATUS_CONNECTION_REFUSED, WSAECONNREFUSED},
12784 {STATUS_GRACEFUL_DISCONNECT, WSAEDISCON},
12785 {STATUS_CONNECTION_ACTIVE, WSAEISCONN},
12786 {STATUS_NETWORK_UNREACHABLE, WSAENETUNREACH},
12787 {STATUS_HOST_UNREACHABLE, WSAEHOSTUNREACH},
12788 {STATUS_PROTOCOL_UNREACHABLE, WSAENETUNREACH},
12789 {STATUS_PORT_UNREACHABLE, WSAECONNRESET},
12790 {STATUS_REQUEST_ABORTED, WSAEINTR},
12791 {STATUS_CONNECTION_ABORTED, WSAECONNABORTED},
12792 {STATUS_DATATYPE_MISALIGNMENT_ERROR,WSAEFAULT},
12793 {STATUS_HOST_DOWN, WSAEHOSTDOWN},
12794 {0x80070000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
12795 {0xc0010000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
12796 {0xc0070000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
12797 };
12798
12799 unsigned int i;
12800
12801 for (i = 0; i < ARRAY_SIZE(errors); ++i)
12802 {
12803 if (errors[i].status == status)
12804 return errors[i].error;
12805 }
12806
12807 return NT_SUCCESS(status) ? RtlNtStatusToDosErrorNoTeb(status) : WSAEINVAL;
12808 }
12809
12810 static void test_WSAGetOverlappedResult(void)
12811 {
12812 OVERLAPPED overlapped = {0};
12813 DWORD size, flags;
12814 NTSTATUS status;
12815 unsigned int i;
12816 SOCKET s;
12817 HANDLE h;
12818 BOOL ret;
12819
12820 static const NTSTATUS ranges[][2] =
12821 {
12822 {0x0, 0x10000},
12823 {0x40000000, 0x40001000},
12824 {0x80000000, 0x80001000},
12825 {0x80070000, 0x80080000},
12826 {0xc0000000, 0xc0001000},
12827 {0xc0070000, 0xc0080000},
12828 {0xd0000000, 0xd0001000},
12829 {0xd0070000, 0xd0080000},
12830 };
12831
12832 WSASetLastError(0xdeadbeef);
12833 ret = WSAGetOverlappedResult(0xdeadbeef, &overlapped, &size, FALSE, &flags);
12834 ok(!ret, "got %d.\n", ret);
12835 ok(WSAGetLastError() == WSAENOTSOCK, "got %u.\n", WSAGetLastError());
12836
12837 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12838
12839 ret = DuplicateHandle(GetCurrentProcess(), (HANDLE)s, GetCurrentProcess(), &h, 0, FALSE, DUPLICATE_SAME_ACCESS);
12840 ok(ret, "got %d.\n", ret);
12841 ret = WSAGetOverlappedResult((SOCKET)h, &overlapped, &size, FALSE, &flags);
12842 ok(!ret, "got %d.\n", ret);
12843 ok(WSAGetLastError() == WSAENOTSOCK, "got %u.\n", WSAGetLastError());
12844 CloseHandle(h);
12845
12846 for (i = 0; i < ARRAY_SIZE(ranges); ++i)
12847 {
12848 for (status = ranges[i][0]; status < ranges[i][1]; ++status)
12849 {
12850 BOOL expect_ret = NT_SUCCESS(status) && status != STATUS_PENDING;
12851 DWORD expect = map_status(status);
12852
12853 overlapped.Internal = status;
12854 WSASetLastError(0xdeadbeef);
12855 ret = WSAGetOverlappedResult(s, &overlapped, &size, FALSE, &flags);
12856 ok(ret == expect_ret, "status %#lx: expected %d, got %d\n", status, expect_ret, ret);
12857 if (ret)
12858 {
12859 ok(WSAGetLastError() == expect /* >= win10 1809 */
12860 || !WSAGetLastError() /* < win10 1809 */
12861 || WSAGetLastError() == 0xdeadbeef, /* < win7 */
12862 "status %#lx: expected error %lu, got %u\n", status, expect, WSAGetLastError());
12863 }
12864 else
12865 {
12866 ok(WSAGetLastError() == expect
12867 || (status == (0xc0070000 | ERROR_IO_INCOMPLETE) && WSAGetLastError() == WSAEINVAL), /* < win8 */
12868 "status %#lx: expected error %lu, got %u\n", status, expect, WSAGetLastError());
12869 }
12870 }
12871 }
12872
12873 overlapped.Internal = STATUS_PENDING;
12874 overlapped.hEvent = CreateEventW(NULL, TRUE, TRUE, NULL);
12875
12876 apc_count = 0;
12877 ret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
12878 ok(ret, "QueueUserAPC returned %d\n", ret);
12879 ret = WSAGetOverlappedResult(s, &overlapped, &size, TRUE, &flags);
12880 ok(ret && (GetLastError() == ERROR_IO_PENDING || !WSAGetLastError()),
12881 "Got ret %d, err %lu.\n", ret, GetLastError());
12882 ok(!apc_count, "got apc_count %d.\n", apc_count);
12883 SleepEx(0, TRUE);
12884 ok(apc_count == 1, "got apc_count %d.\n", apc_count);
12885
12886 CloseHandle(overlapped.hEvent);
12887 closesocket(s);
12888 }
12889
12890 struct nonblocking_async_recv_params
12891 {
12892 SOCKET client;
12893 HANDLE event;
12894 };
12895
12896 static DWORD CALLBACK nonblocking_async_recv_thread(void *arg)
12897 {
12898 const struct nonblocking_async_recv_params *params = arg;
12899 OVERLAPPED overlapped = {0};
12900 DWORD flags = 0, size;
12901 char buffer[5];
12902 WSABUF wsabuf;
12903 int ret;
12904
12905 overlapped.hEvent = params->event;
12906 wsabuf.buf = buffer;
12907 wsabuf.len = sizeof(buffer);
12908 memset(buffer, 0, sizeof(buffer));
12909 ret = WSARecv(params->client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
12910 ok(!ret, "got %d\n", ret);
12911 ret = GetOverlappedResult((HANDLE)params->client, &overlapped, &size, FALSE);
12912 ok(ret, "got error %lu\n", GetLastError());
12913 ok(size == 4, "got size %lu\n", size);
12914 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
12915
12916 return 0;
12917 }
12918
12919 static void test_nonblocking_async_recv(void)
12920 {
12921 struct nonblocking_async_recv_params params;
12922 OVERLAPPED overlapped = {0};
12923 SOCKET client, server;
12924 DWORD flags = 0, size;
12925 HANDLE thread, event;
12926 char buffer[5];
12927 WSABUF wsabuf;
12928 int ret;
12929
12930 event = CreateEventW(NULL, TRUE, FALSE, NULL);
12931 wsabuf.buf = buffer;
12932 wsabuf.len = sizeof(buffer);
12933
12934 tcp_socketpair(&client, &server);
12935 set_blocking(client, FALSE);
12936 set_blocking(server, FALSE);
12937
12938 WSASetLastError(0xdeadbeef);
12939 ret = recv(client, buffer, sizeof(buffer), 0);
12940 ok(ret == -1, "got %d\n", ret);
12941 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
12942
12943 WSASetLastError(0xdeadbeef);
12944 overlapped.Internal = 0xdeadbeef;
12945 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
12946 ok(ret == -1, "got %d\n", ret);
12947 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
12948 ok(overlapped.Internal == 0xdeadbeef, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
12949
12950 /* Overlapped, with a NULL event. */
12951
12952 overlapped.hEvent = NULL;
12953
12954 memset(buffer, 0, sizeof(buffer));
12955 WSASetLastError(0xdeadbeef);
12956 overlapped.Internal = 0xdeadbeef;
12957 overlapped.InternalHigh = 0xdeadbeef;
12958 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
12959 ok(ret == -1, "got %d\n", ret);
12960 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
12961 ret = WaitForSingleObject((HANDLE)client, 0);
12962 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
12963 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
12964 ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
12965
12966 ret = send(server, "data", 4, 0);
12967 ok(ret == 4, "got %d\n", ret);
12968
12969 ret = WaitForSingleObject((HANDLE)client, 1000);
12970 ok(!ret, "wait timed out\n");
12971 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
12972 ok(ret, "got error %lu\n", GetLastError());
12973 ok(size == 4, "got size %lu\n", size);
12974 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
12975
12976 /* Overlapped, with a non-NULL event. */
12977
12978 overlapped.hEvent = event;
12979
12980 memset(buffer, 0, sizeof(buffer));
12981 WSASetLastError(0xdeadbeef);
12982 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
12983 ok(ret == -1, "got %d\n", ret);
12984 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
12985 ret = WaitForSingleObject(event, 0);
12986 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
12987
12988 ret = send(server, "data", 4, 0);
12989 ok(ret == 4, "got %d\n", ret);
12990
12991 ret = WaitForSingleObject(event, 1000);
12992 ok(!ret, "wait timed out\n");
12993 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
12994 ok(ret, "got error %lu\n", GetLastError());
12995 ok(size == 4, "got size %lu\n", size);
12996 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
12997
12998 /* With data already in the pipe; usually this does return 0 (but not
12999 * reliably). */
13000
13001 ret = send(server, "data", 4, 0);
13002 ok(ret == 4, "got %d\n", ret);
13003
13004 memset(buffer, 0, sizeof(buffer));
13005 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
13006 ok(!ret || WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
13007 ret = WaitForSingleObject(event, 1000);
13008 ok(!ret, "wait timed out\n");
13009 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
13010 ok(ret, "got error %lu\n", GetLastError());
13011 ok(size == 4, "got size %lu\n", size);
13012 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
13013
13014 closesocket(client);
13015 closesocket(server);
13016
13017 /* With a non-overlapped socket, WSARecv() always blocks when passed an
13018 * overlapped structure, but returns WSAEWOULDBLOCK otherwise. */
13019
13020 tcp_socketpair_flags(&client, &server, 0);
13021 set_blocking(client, FALSE);
13022 set_blocking(server, FALSE);
13023
13024 WSASetLastError(0xdeadbeef);
13025 ret = recv(client, buffer, sizeof(buffer), 0);
13026 ok(ret == -1, "got %d\n", ret);
13027 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
13028
13029 WSASetLastError(0xdeadbeef);
13030 overlapped.Internal = 0xdeadbeef;
13031 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
13032 ok(ret == -1, "got %d\n", ret);
13033 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
13034 ok(overlapped.Internal == 0xdeadbeef, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
13035
13036 /* Overlapped, with a NULL event. */
13037
13038 params.client = client;
13039 params.event = NULL;
13040 thread = CreateThread(NULL, 0, nonblocking_async_recv_thread, &params, 0, NULL);
13041
13042 ret = WaitForSingleObject(thread, 200);
13043 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
13044
13045 ret = send(server, "data", 4, 0);
13046 ok(ret == 4, "got %d\n", ret);
13047
13048 ret = WaitForSingleObject(thread, 200);
13049 ok(!ret, "wait timed out\n");
13050 CloseHandle(thread);
13051
13052 /* Overlapped, with a non-NULL event. */
13053
13054 params.client = client;
13055 params.event = event;
13056 thread = CreateThread(NULL, 0, nonblocking_async_recv_thread, &params, 0, NULL);
13057
13058 ret = WaitForSingleObject(thread, 200);
13059 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
13060
13061 ret = send(server, "data", 4, 0);
13062 ok(ret == 4, "got %d\n", ret);
13063
13064 ret = WaitForSingleObject(thread, 200);
13065 ok(!ret, "wait timed out\n");
13066 CloseHandle(thread);
13067
13068 /* With data already in the pipe. */
13069
13070 ret = send(server, "data", 4, 0);
13071 ok(ret == 4, "got %d\n", ret);
13072
13073 memset(buffer, 0, sizeof(buffer));
13074 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
13075 ok(!ret, "got %d\n", ret);
13076 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
13077 ok(ret, "got error %lu\n", GetLastError());
13078 ok(size == 4, "got size %lu\n", size);
13079 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
13080
13081 closesocket(client);
13082 closesocket(server);
13083
13084 CloseHandle(overlapped.hEvent);
13085 }
13086
13087 static void test_simultaneous_async_recv(void)
13088 {
13089 SOCKET client, server;
13090 OVERLAPPED overlappeds[2] = {{0}};
13091 HANDLE events[2];
13092 WSABUF wsabufs[2];
13093 DWORD flags[2] = {0};
13094 size_t num_io = 2, stride = 16, i;
13095 char resbuf[32] = "";
13096 static const char msgstr[32] = "-- Lorem ipsum dolor sit amet -";
13097 int ret;
13098
13099 for (i = 0; i < num_io; i++) events[i] = CreateEventW(NULL, TRUE, FALSE, NULL);
13100
13101 tcp_socketpair(&client, &server);
13102
13103 for (i = 0; i < num_io; i++)
13104 {
13105 wsabufs[i].buf = resbuf + i * stride;
13106 wsabufs[i].len = stride;
13107 overlappeds[i].hEvent = events[i];
13108 ret = WSARecv(client, &wsabufs[i], 1, NULL, &flags[i], &overlappeds[i], NULL);
13109 ok(ret == -1, "got %d\n", ret);
13110 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
13111 }
13112
13113 ret = send(server, msgstr, sizeof(msgstr), 0);
13114 ok(ret == sizeof(msgstr), "got %d\n", ret);
13115
13116 for (i = 0; i < num_io; i++)
13117 {
13118 const void *expect = msgstr + i * stride;
13119 const void *actual = resbuf + i * stride;
13120 DWORD size;
13121
13122 ret = WaitForSingleObject(events[i], 1000);
13123 ok(!ret, "wait timed out\n");
13124
13125 size = 0;
13126 ret = GetOverlappedResult((HANDLE)client, &overlappeds[i], &size, FALSE);
13127 ok(ret, "got error %lu\n", GetLastError());
13128 ok(size == stride, "got size %lu\n", size);
13129 ok(!memcmp(expect, actual, stride), "expected %s, got %s\n", debugstr_an(expect, stride), debugstr_an(actual, stride));
13130 }
13131
13132 closesocket(client);
13133 closesocket(server);
13134
13135 for (i = 0; i < num_io; i++) CloseHandle(events[i]);
13136 }
13137
13138 static void test_empty_recv(void)
13139 {
13140 OVERLAPPED overlapped = {0};
13141 SOCKET client, server;
13142 DWORD size, flags = 0;
13143 char buffer[5];
13144 WSABUF wsabuf;
13145 int ret;
13146
13147 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
13148 tcp_socketpair(&client, &server);
13149
13150 WSASetLastError(0xdeadbeef);
13151 ret = WSARecv(client, NULL, 0, NULL, &flags, &overlapped, NULL);
13152 ok(ret == -1, "expected failure\n");
13153 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
13154
13155 wsabuf.buf = buffer;
13156 wsabuf.len = 0;
13157 WSASetLastError(0xdeadbeef);
13158 ret = WSARecv(client, &wsabuf, 0, NULL, &flags, &overlapped, NULL);
13159 ok(ret == -1, "expected failure\n");
13160 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
13161
13162 WSASetLastError(0xdeadbeef);
13163 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
13164 ok(ret == -1, "expected failure\n");
13165 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
13166
13167 ret = send(server, "data", 5, 0);
13168 ok(ret == 5, "got %d\n", ret);
13169
13170 ret = WaitForSingleObject(overlapped.hEvent, 1000);
13171 ok(!ret, "wait failed\n");
13172 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
13173 ok(ret, "got error %lu\n", GetLastError());
13174 ok(!size, "got size %lu\n", size);
13175
13176 WSASetLastError(0xdeadbeef);
13177 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
13178 ok(!ret, "got error %u\n", WSAGetLastError());
13179 ok(!size, "got size %lu\n", size);
13180
13181 ret = recv(client, NULL, 0, 0);
13182 ok(!ret, "got %d\n", ret);
13183
13184 ret = recv(client, buffer, sizeof(buffer), 0);
13185 ok(ret == 5, "got %d\n", ret);
13186 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, ret));
13187
13188 closesocket(client);
13189 closesocket(server);
13190 CloseHandle(overlapped.hEvent);
13191 }
13192
13193 static void test_timeout(void)
13194 {
13195 DWORD timeout, flags = 0, size;
13196 OVERLAPPED overlapped = {0};
13197 SOCKET client, server;
13198 WSABUF wsabuf;
13199 int ret, len;
13200 char buffer;
13201
13202 tcp_socketpair(&client, &server);
13203 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
13204
13205 timeout = 0xdeadbeef;
13206 len = sizeof(timeout);
13207 WSASetLastError(0xdeadbeef);
13208 ret = getsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, &len);
13209 ok(!ret, "expected success\n");
13210 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13211 ok(len == sizeof(timeout), "got size %u\n", len);
13212 ok(!timeout, "got timeout %lu\n", timeout);
13213
13214 timeout = 100;
13215 WSASetLastError(0xdeadbeef);
13216 ret = setsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
13217 ok(!ret, "expected success\n");
13218 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13219
13220 timeout = 0xdeadbeef;
13221 len = sizeof(timeout);
13222 WSASetLastError(0xdeadbeef);
13223 ret = getsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, &len);
13224 ok(!ret, "expected success\n");
13225 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13226 ok(timeout == 100, "got timeout %lu\n", timeout);
13227
13228 WSASetLastError(0xdeadbeef);
13229 ret = recv(client, &buffer, 1, 0);
13230 ok(ret == -1, "got %d\n", ret);
13231 ok(WSAGetLastError() == WSAETIMEDOUT, "got error %u\n", WSAGetLastError());
13232
13233 wsabuf.buf = &buffer;
13234 wsabuf.len = 1;
13235 WSASetLastError(0xdeadbeef);
13236 size = 0xdeadbeef;
13237 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
13238 ok(ret == -1, "got %d\n", ret);
13239 ok(WSAGetLastError() == WSAETIMEDOUT, "got error %u\n", WSAGetLastError());
13240 ok(size == 0xdeadbeef, "got size %lu\n", size);
13241
13242 wsabuf.buf = &buffer;
13243 wsabuf.len = 1;
13244 WSASetLastError(0xdeadbeef);
13245 size = 0xdeadbeef;
13246 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
13247 ok(ret == -1, "got %d\n", ret);
13248 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
13249
13250 ret = WaitForSingleObject(overlapped.hEvent, 200);
13251 ok(ret == WAIT_TIMEOUT, "got %d\n", ret);
13252
13253 ret = send(server, "a", 1, 0);
13254 ok(ret == 1, "got %d\n", ret);
13255
13256 ret = WaitForSingleObject(overlapped.hEvent, 200);
13257 ok(!ret, "got %d\n", ret);
13258 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
13259 ok(ret, "got error %lu\n", GetLastError());
13260 ok(size == 1, "got size %lu\n", size);
13261
13262 closesocket(client);
13263 closesocket(server);
13264 CloseHandle(overlapped.hEvent);
13265 }
13266
13267 static void test_so_debug(void)
13268 {
13269 int ret, len;
13270 DWORD debug;
13271 SOCKET s;
13272
13273 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
13274
13275 len = sizeof(debug);
13276 WSASetLastError(0xdeadbeef);
13277 debug = 0xdeadbeef;
13278 ret = getsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&debug, &len);
13279 ok(!ret, "got %d\n", ret);
13280 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13281 ok(len == sizeof(debug), "got len %u\n", len);
13282 ok(!debug, "got debug %lu\n", debug);
13283
13284 WSASetLastError(0xdeadbeef);
13285 debug = 2;
13286 ret = setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&debug, sizeof(debug));
13287 ok(!ret, "got %d\n", ret);
13288 todo_wine ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13289
13290 len = sizeof(debug);
13291 WSASetLastError(0xdeadbeef);
13292 debug = 0xdeadbeef;
13293 ret = getsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&debug, &len);
13294 ok(!ret, "got %d\n", ret);
13295 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13296 ok(len == sizeof(debug), "got len %u\n", len);
13297 todo_wine ok(debug == 1, "got debug %lu\n", debug);
13298
13299 closesocket(s);
13300 }
13301
13302 struct sockopt_validity_test
13303 {
13304 int opt;
13305 int get_error;
13306 int set_error;
13307 BOOL todo;
13308 };
13309
13310 static void do_sockopt_validity_tests(const char *type, SOCKET sock, int level,
13311 const struct sockopt_validity_test *tests)
13312 {
13313 char value[256];
13314 int count, rc, expected_rc, i;
13315
13316 for (i = 0; tests[i].opt; i++)
13317 {
13318 winetest_push_context("%s option %i", type, tests[i].opt);
13319 memset(value, 0, sizeof(value));
13320 count = sizeof(value);
13321
13322 WSASetLastError(0);
13323 rc = getsockopt(sock, level, tests[i].opt, value, &count);
13324 expected_rc = tests[i].get_error ? SOCKET_ERROR : 0;
13325 todo_wine_if(!tests[i].get_error && tests[i].todo)
13326 ok(rc == expected_rc || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
13327 "expected getsockopt to return %i, got %i\n", expected_rc, rc);
13328 todo_wine_if(tests[i].todo)
13329 ok(WSAGetLastError() == tests[i].get_error || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
13330 "expected getsockopt to set error %i, got %i\n", tests[i].get_error, WSAGetLastError());
13331
13332 if (tests[i].get_error)
13333 {
13334 winetest_pop_context();
13335 continue;
13336 }
13337
13338 WSASetLastError(0);
13339 rc = setsockopt(sock, level, tests[i].opt, value, count);
13340 expected_rc = tests[i].set_error ? SOCKET_ERROR : 0;
13341 todo_wine_if(!tests[i].set_error && tests[i].todo)
13342 ok(rc == expected_rc || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
13343 "expected setsockopt to return %i, got %i\n", expected_rc, rc);
13344 todo_wine_if(tests[i].todo)
13345 ok(WSAGetLastError() == tests[i].set_error || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
13346 "expected setsockopt to set error %i, got %i\n", tests[i].set_error, WSAGetLastError());
13347
13348 winetest_pop_context();
13349 }
13350 }
13351
13352 static void test_sockopt_validity(void)
13353 {
13354 static const struct sockopt_validity_test ipv4_tcp_tests[] =
13355 {
13356 { -1, WSAENOPROTOOPT },
13357 { IP_OPTIONS },
13358 { IP_HDRINCL, WSAEINVAL },
13359 { IP_TOS },
13360 { IP_TTL },
13361 { IP_MULTICAST_IF, WSAEINVAL },
13362 { IP_MULTICAST_TTL, WSAEINVAL },
13363 { IP_MULTICAST_LOOP, WSAEINVAL },
13364 { IP_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13365 { IP_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13366 { IP_DONTFRAGMENT },
13367 { IP_PKTINFO, WSAEINVAL },
13368 { IP_RECVTTL, WSAEINVAL },
13369 { IP_RECEIVE_BROADCAST, WSAEINVAL, 0, TRUE },
13370 { IP_RECVIF, WSAEINVAL, 0, TRUE },
13371 { IP_RECVDSTADDR, WSAEINVAL, 0, TRUE },
13372 { IP_IFLIST, 0, 0, TRUE },
13373 { IP_UNICAST_IF },
13374 { IP_RTHDR, 0, 0, TRUE },
13375 { IP_GET_IFLIST, WSAEINVAL, 0, TRUE },
13376 { IP_RECVRTHDR, WSAEINVAL, 0, TRUE },
13377 { IP_RECVTOS, WSAEINVAL },
13378 { IP_ORIGINAL_ARRIVAL_IF, WSAEINVAL, 0, TRUE },
13379 { IP_ECN, WSAEINVAL, 0, TRUE },
13380 { IP_PKTINFO_EX, WSAEINVAL, 0, TRUE },
13381 { IP_WFP_REDIRECT_RECORDS, WSAEINVAL, 0, TRUE },
13382 { IP_WFP_REDIRECT_CONTEXT, WSAEINVAL, 0, TRUE },
13383 { IP_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13384 { IP_MTU, WSAENOTCONN, 0, TRUE },
13385 { IP_RECVERR, WSAEINVAL, 0, TRUE },
13386 { IP_USER_MTU, 0, 0, TRUE },
13387 {}
13388 };
13389 static const struct sockopt_validity_test ipv4_udp_tests[] =
13390 {
13391 { -1, WSAENOPROTOOPT },
13392 { IP_OPTIONS },
13393 { IP_HDRINCL, WSAEINVAL },
13394 { IP_TOS },
13395 { IP_TTL },
13396 { IP_MULTICAST_IF },
13397 { IP_MULTICAST_TTL },
13398 { IP_MULTICAST_LOOP },
13399 { IP_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13400 { IP_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13401 { IP_DONTFRAGMENT },
13402 { IP_PKTINFO },
13403 { IP_RECVTTL },
13404 { IP_RECEIVE_BROADCAST, 0, 0, TRUE },
13405 { IP_RECVIF, 0, 0, TRUE },
13406 { IP_RECVDSTADDR, 0, 0, TRUE },
13407 { IP_IFLIST, 0, 0, TRUE },
13408 { IP_UNICAST_IF },
13409 { IP_RTHDR, 0, 0, TRUE },
13410 { IP_GET_IFLIST, WSAEINVAL, 0, TRUE },
13411 { IP_RECVRTHDR, 0, 0, TRUE },
13412 { IP_RECVTOS },
13413 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
13414 { IP_ECN, 0, 0, TRUE },
13415 { IP_PKTINFO_EX, 0, 0, TRUE },
13416 { IP_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
13417 { IP_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
13418 { IP_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13419 { IP_MTU, WSAENOTCONN, 0, TRUE },
13420 { IP_RECVERR, 0, 0, TRUE },
13421 { IP_USER_MTU, 0, 0, TRUE },
13422 {}
13423 };
13424 static const struct sockopt_validity_test ipv4_raw_tests[] =
13425 {
13426 { -1, WSAENOPROTOOPT },
13427 { IP_OPTIONS },
13428 { IP_HDRINCL, },
13429 { IP_TOS },
13430 { IP_TTL },
13431 { IP_MULTICAST_IF },
13432 { IP_MULTICAST_TTL },
13433 { IP_MULTICAST_LOOP },
13434 { IP_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13435 { IP_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13436 { IP_DONTFRAGMENT },
13437 { IP_PKTINFO },
13438 { IP_RECVTTL },
13439 { IP_RECEIVE_BROADCAST, 0, 0, TRUE },
13440 { IP_RECVIF, 0, 0, TRUE },
13441 { IP_RECVDSTADDR, 0, 0, TRUE },
13442 { IP_IFLIST, 0, 0, TRUE },
13443 { IP_UNICAST_IF },
13444 { IP_RTHDR, 0, 0, TRUE },
13445 { IP_GET_IFLIST, WSAEINVAL, 0, TRUE },
13446 { IP_RECVRTHDR, 0, 0, TRUE },
13447 { IP_RECVTOS },
13448 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
13449 { IP_ECN, 0, 0, TRUE },
13450 { IP_PKTINFO_EX, 0, 0, TRUE },
13451 { IP_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
13452 { IP_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
13453 { IP_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13454 { IP_MTU, WSAENOTCONN, 0, TRUE },
13455 { IP_RECVERR, WSAEINVAL, 0, TRUE },
13456 { IP_USER_MTU, 0, 0, TRUE },
13457 {}
13458 };
13459 static const struct sockopt_validity_test ipv6_tcp_tests[] =
13460 {
13461 { -1, WSAENOPROTOOPT },
13462 { IPV6_HOPOPTS, 0, 0, TRUE },
13463 { IPV6_HDRINCL, WSAEINVAL, 0, TRUE },
13464 { IPV6_UNICAST_HOPS },
13465 { IPV6_MULTICAST_IF, WSAEINVAL },
13466 { IPV6_MULTICAST_HOPS, WSAEINVAL },
13467 { IPV6_MULTICAST_LOOP, WSAEINVAL },
13468 { IPV6_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13469 { IPV6_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13470 { IPV6_DONTFRAG },
13471 { IPV6_PKTINFO, WSAEINVAL },
13472 { IPV6_HOPLIMIT, WSAEINVAL },
13473 { IPV6_PROTECTION_LEVEL },
13474 { IPV6_RECVIF, WSAEINVAL, 0, TRUE },
13475 { IPV6_RECVDSTADDR, WSAEINVAL, 0, TRUE },
13476 { IPV6_V6ONLY },
13477 { IPV6_IFLIST, 0, 0, TRUE },
13478 { IPV6_UNICAST_IF },
13479 { IPV6_RTHDR, 0, 0, TRUE },
13480 { IPV6_GET_IFLIST, WSAEINVAL, 0, TRUE },
13481 { IPV6_RECVRTHDR, WSAEINVAL, 0, TRUE },
13482 { IPV6_RECVTCLASS, WSAEINVAL },
13483 { IP_ORIGINAL_ARRIVAL_IF, WSAEINVAL, 0, TRUE },
13484 { IPV6_ECN, WSAEINVAL, 0, TRUE },
13485 { IPV6_PKTINFO_EX, WSAEINVAL, 0, TRUE },
13486 { IPV6_WFP_REDIRECT_RECORDS, WSAEINVAL, 0, TRUE },
13487 { IPV6_WFP_REDIRECT_CONTEXT, WSAEINVAL, 0, TRUE },
13488 { IPV6_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13489 { IPV6_MTU, WSAENOTCONN, 0, TRUE },
13490 { IPV6_RECVERR, WSAEINVAL, 0, TRUE },
13491 { IPV6_USER_MTU, 0, 0, TRUE },
13492 {}
13493 };
13494 static const struct sockopt_validity_test ipv6_udp_tests[] =
13495 {
13496 { -1, WSAENOPROTOOPT },
13497 { IPV6_HOPOPTS, 0, 0, TRUE },
13498 { IPV6_HDRINCL, WSAEINVAL, 0, TRUE },
13499 { IPV6_UNICAST_HOPS },
13500 { IPV6_MULTICAST_IF },
13501 { IPV6_MULTICAST_HOPS },
13502 { IPV6_MULTICAST_LOOP },
13503 { IPV6_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13504 { IPV6_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13505 { IPV6_DONTFRAG },
13506 { IPV6_PKTINFO },
13507 { IPV6_HOPLIMIT },
13508 { IPV6_PROTECTION_LEVEL },
13509 { IPV6_RECVIF, 0, 0, TRUE },
13510 { IPV6_RECVDSTADDR, 0, 0, TRUE },
13511 { IPV6_V6ONLY },
13512 { IPV6_IFLIST, 0, 0, TRUE },
13513 { IPV6_UNICAST_IF },
13514 { IPV6_RTHDR, 0, 0, TRUE },
13515 { IPV6_GET_IFLIST, WSAEINVAL, 0, TRUE },
13516 { IPV6_RECVRTHDR, 0, 0, TRUE },
13517 { IPV6_RECVTCLASS },
13518 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
13519 { IPV6_ECN, 0, 0, TRUE },
13520 { IPV6_PKTINFO_EX, 0, 0, TRUE },
13521 { IPV6_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
13522 { IPV6_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
13523 { IPV6_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13524 { IPV6_MTU, WSAENOTCONN, 0, TRUE },
13525 { IPV6_RECVERR, 0, 0, TRUE },
13526 { IPV6_USER_MTU, 0, 0, TRUE },
13527 {}
13528 };
13529 static const struct sockopt_validity_test ipv6_raw_tests[] =
13530 {
13531 { -1, WSAENOPROTOOPT },
13532 { IPV6_HOPOPTS, 0, 0, TRUE },
13533 { IPV6_HDRINCL, 0, 0, TRUE },
13534 { IPV6_UNICAST_HOPS },
13535 { IPV6_MULTICAST_IF },
13536 { IPV6_MULTICAST_HOPS },
13537 { IPV6_MULTICAST_LOOP },
13538 { IPV6_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13539 { IPV6_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13540 { IPV6_DONTFRAG },
13541 { IPV6_PKTINFO },
13542 { IPV6_HOPLIMIT },
13543 { IPV6_PROTECTION_LEVEL },
13544 { IPV6_RECVIF, 0, 0, TRUE },
13545 { IPV6_RECVDSTADDR, 0, 0, TRUE },
13546 { IPV6_V6ONLY },
13547 { IPV6_IFLIST, 0, 0, TRUE },
13548 { IPV6_UNICAST_IF },
13549 { IPV6_RTHDR, 0, 0, TRUE },
13550 { IPV6_GET_IFLIST, WSAEINVAL, 0, TRUE },
13551 { IPV6_RECVRTHDR, 0, 0, TRUE },
13552 { IPV6_RECVTCLASS },
13553 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
13554 { IPV6_ECN, 0, 0, TRUE },
13555 { IPV6_PKTINFO_EX, 0, 0, TRUE },
13556 { IPV6_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
13557 { IPV6_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
13558 { IPV6_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13559 { IPV6_MTU, WSAENOTCONN, 0, TRUE },
13560 { IPV6_RECVERR, WSAEINVAL, 0, TRUE },
13561 { IPV6_USER_MTU, 0, 0, TRUE },
13562 {}
13563 };
13564 static const struct sockopt_validity_test file_handle_tests[] =
13565 {
13566 { -1, WSAENOTSOCK },
13567 { SO_TYPE, WSAENOTSOCK },
13568 { SO_OPENTYPE },
13569 {}
13570 };
13571 char path[MAX_PATH];
13572 HANDLE file;
13573 SOCKET sock;
13574
13575 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
13576 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13577 do_sockopt_validity_tests("IPv4 TCP", sock, IPPROTO_IP, ipv4_tcp_tests);
13578 closesocket(sock);
13579
13580 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
13581 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13582 do_sockopt_validity_tests("IPv4 UDP", sock, IPPROTO_IP, ipv4_udp_tests);
13583 closesocket(sock);
13584
13585 sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
13586 if (sock == INVALID_SOCKET && WSAGetLastError() == WSAEACCES)
13587 {
13588 skip("Raw IPv4 sockets are not available\n");
13589 }
13590 else
13591 {
13592 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13593 do_sockopt_validity_tests("IPv4 raw", sock, IPPROTO_IP, ipv4_raw_tests);
13594 closesocket(sock);
13595 }
13596
13597 sock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
13598 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13599 do_sockopt_validity_tests("IPv6 TCP", sock, IPPROTO_IPV6, ipv6_tcp_tests);
13600 closesocket(sock);
13601
13602 sock = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
13603 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13604 do_sockopt_validity_tests("IPv6 UDP", sock, IPPROTO_IPV6, ipv6_udp_tests);
13605 closesocket(sock);
13606
13607 sock = socket(AF_INET6, SOCK_RAW, IPPROTO_RAW);
13608 if (sock == INVALID_SOCKET && WSAGetLastError() == WSAEACCES)
13609 {
13610 skip("Raw IPv6 sockets are not available\n");
13611 }
13612 else
13613 {
13614 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13615 do_sockopt_validity_tests("IPv6 raw", sock, IPPROTO_IPV6, ipv6_raw_tests);
13616 closesocket(sock);
13617 }
13618
13619 GetSystemWindowsDirectoryA(path, ARRAY_SIZE(path));
13620 strcat(path, "\\system.ini");
13621 file = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0x0, NULL);
13622 do_sockopt_validity_tests("file", (SOCKET)file, SOL_SOCKET, file_handle_tests);
13623 CloseHandle(file);
13624 }
13625
13626 static void test_tcp_reset(void)
13627 {
13628 static const struct timeval select_timeout;
13629 fd_set readfds, writefds, exceptfds;
13630 OVERLAPPED overlapped = {0};
13631 SOCKET client, server;
13632 DWORD size, flags = 0;
13633 int ret, len, error;
13634 char buffer[10];
13635 WSABUF wsabuf;
13636
13637 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
13638
13639 tcp_socketpair(&client, &server);
13640
13641 wsabuf.buf = buffer;
13642 wsabuf.len = sizeof(buffer);
13643 WSASetLastError(0xdeadbeef);
13644 size = 0xdeadbeef;
13645 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
13646 ok(ret == -1, "got %d\n", ret);
13647 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
13648
13649 close_with_rst(server);
13650
13651 ret = WaitForSingleObject(overlapped.hEvent, 1000);
13652 ok(!ret, "wait failed\n");
13653 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
13654 ok(!ret, "expected failure\n");
13655 ok(GetLastError() == ERROR_NETNAME_DELETED, "got error %lu\n", GetLastError());
13656 ok(!size, "got size %lu\n", size);
13657 ok((NTSTATUS)overlapped.Internal == STATUS_CONNECTION_RESET, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
13658
13659 len = sizeof(error);
13660 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&error, &len);
13661 ok(!ret, "got error %u\n", WSAGetLastError());
13662 ok(!error, "got error %u\n", error);
13663
13664 wsabuf.buf = buffer;
13665 wsabuf.len = sizeof(buffer);
13666 WSASetLastError(0xdeadbeef);
13667 size = 0xdeadbeef;
13668 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
13669 ok(ret == -1, "got %d\n", ret);
13670 ok(WSAGetLastError() == WSAECONNRESET, "got error %u\n", WSAGetLastError());
13671
13672 WSASetLastError(0xdeadbeef);
13673 ret = send(client, "data", 5, 0);
13674 ok(ret == -1, "got %d\n", ret);
13675 ok(WSAGetLastError() == WSAECONNRESET, "got error %u\n", WSAGetLastError());
13676
13677 check_poll(client, POLLERR | POLLHUP | POLLWRNORM);
13678
13679 FD_ZERO(&readfds);
13680 FD_ZERO(&writefds);
13681 FD_ZERO(&exceptfds);
13682 FD_SET(client, &readfds);
13683 FD_SET(client, &writefds);
13684 FD_SET(client, &exceptfds);
13685 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
13686 ok(ret == 2, "got %d\n", ret);
13687 ok(FD_ISSET(client, &readfds), "FD should be set\n");
13688 ok(FD_ISSET(client, &writefds), "FD should be set\n");
13689 ok(!FD_ISSET(client, &exceptfds), "FD should be set\n");
13690
13691 FD_ZERO(&exceptfds);
13692 FD_SET(client, &exceptfds);
13693 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
13694 ok(!ret, "got %d\n", ret);
13695 ok(!FD_ISSET(client, &exceptfds), "FD should be set\n");
13696
13697 closesocket(server);
13698 CloseHandle(overlapped.hEvent);
13699 }
13700
13701 struct icmp_hdr
13702 {
13703 BYTE type;
13704 BYTE code;
13705 UINT16 checksum;
13706 union
13707 {
13708 struct
13709 {
13710 UINT16 id;
13711 UINT16 sequence;
13712 } echo;
13713 } un;
13714 };
13715
13716 struct ip_hdr
13717 {
13718 BYTE v_hl; /* version << 4 | hdr_len */
13719 BYTE tos;
13720 UINT16 tot_len;
13721 UINT16 id;
13722 UINT16 frag_off;
13723 BYTE ttl;
13724 BYTE protocol;
13725 UINT16 checksum;
13726 ULONG saddr;
13727 ULONG daddr;
13728 };
13729
13730 /* rfc 1071 checksum */
13731 static unsigned short chksum(BYTE *data, unsigned int count)
13732 {
13733 unsigned int sum = 0, carry = 0;
13734 unsigned short check, s;
13735
13736 while (count > 1)
13737 {
13738 s = *(unsigned short *)data;
13739 data += 2;
13740 sum += carry;
13741 sum += s;
13742 carry = s > sum;
13743 count -= 2;
13744 }
13745 sum += carry; /* This won't produce another carry */
13746 sum = (sum & 0xffff) + (sum >> 16);
13747
13748 if (count) sum += *data; /* LE-only */
13749
13750 sum = (sum & 0xffff) + (sum >> 16);
13751 /* fold in any carry */
13752 sum = (sum & 0xffff) + (sum >> 16);
13753
13754 check = ~sum;
13755 return check;
13756 }
13757
13758 static void test_icmp(void)
13759 {
13760 static const unsigned int ping_data = 0xdeadbeef;
13761 struct icmp_hdr *icmp_h;
13762 BYTE send_buf[sizeof(struct icmp_hdr) + sizeof(ping_data)];
13763 UINT16 recv_checksum, checksum;
13764 unsigned int reply_data;
13765 struct sockaddr_in sa;
13766 struct ip_hdr *ip_h;
13767 struct in_addr addr;
13768 BYTE recv_buf[256];
13769 SOCKET s;
13770 int ret;
13771
13772 s = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
13773 if (s == INVALID_SOCKET)
13774 {
13775 ret = WSAGetLastError();
13776 ok(ret == WSAEACCES, "Expected 10013, received %d\n", ret);
13777 skip("SOCK_RAW is not supported\n");
13778 return;
13779 }
13780
13781 icmp_h = (struct icmp_hdr *)send_buf;
13782 icmp_h->type = ICMP4_ECHO_REQUEST;
13783 icmp_h->code = 0;
13784 icmp_h->checksum = 0;
13785 icmp_h->un.echo.id = 0xbeaf; /* will be overwritten for linux ping socks */
13786 icmp_h->un.echo.sequence = 1;
13787 *(unsigned int *)(icmp_h + 1) = ping_data;
13788 icmp_h->checksum = chksum(send_buf, sizeof(send_buf));
13789
13790 memset(&sa, 0, sizeof(sa));
13791 sa.sin_family = AF_INET;
13792 sa.sin_port = 0;
13793 sa.sin_addr.s_addr = inet_addr("127.0.0.1");
13794
13795 ret = sendto(s, (char *)send_buf, sizeof(send_buf), 0, (struct sockaddr*)&sa, sizeof(sa));
13796 ok(ret == sizeof(send_buf), "got %d, error %d.\n", ret, WSAGetLastError());
13797
13798 ret = recv(s, (char *)recv_buf, sizeof(struct ip_hdr) + sizeof(send_buf) - 1, 0);
13799 ok(ret == -1, "got %d\n", ret);
13800 ok(WSAGetLastError() == WSAEMSGSIZE, "got %d\n", WSAGetLastError());
13801
13802 icmp_h->un.echo.sequence = 2;
13803 icmp_h->checksum = 0;
13804 icmp_h->checksum = chksum(send_buf, sizeof(send_buf));
13805
13806 ret = sendto(s, (char *)send_buf, sizeof(send_buf), 0, (struct sockaddr*)&sa, sizeof(sa));
13807 ok(ret != SOCKET_ERROR, "got error %d.\n", WSAGetLastError());
13808
13809 memset(recv_buf, 0xcc, sizeof(recv_buf));
13810 ret = recv(s, (char *)recv_buf, sizeof(recv_buf), 0);
13811 ok(ret == sizeof(struct ip_hdr) + sizeof(send_buf), "got %d\n", ret);
13812
13813 ip_h = (struct ip_hdr *)recv_buf;
13814 icmp_h = (struct icmp_hdr *)(ip_h + 1);
13815 reply_data = *(unsigned int *)(icmp_h + 1);
13816
13817 ok(ip_h->v_hl == ((4 << 4) | (sizeof(*ip_h) >> 2)), "got v_hl %#x.\n", ip_h->v_hl);
13818 ok(ntohs(ip_h->tot_len) == sizeof(struct ip_hdr) + sizeof(send_buf),
13819 "got tot_len %#x.\n", ntohs(ip_h->tot_len));
13820
13821 recv_checksum = ip_h->checksum;
13822 ip_h->checksum = 0;
13823 checksum = chksum((BYTE *)ip_h, sizeof(*ip_h));
13824 /* Checksum is 0 for localhost ping on Windows but not for remote host ping. */
13825 ok(recv_checksum == checksum || !recv_checksum, "got checksum %#x, expected %#x.\n", recv_checksum, checksum);
13826
13827 ok(!ip_h->frag_off, "got id %#x.\n", ip_h->frag_off);
13828 addr.s_addr = ip_h->saddr;
13829 ok(ip_h->saddr == sa.sin_addr.s_addr, "got saddr %s.\n", inet_ntoa(addr));
13830 addr.s_addr = ip_h->daddr;
13831 ok(!!ip_h->daddr, "got daddr %s.\n", inet_ntoa(addr));
13832
13833 ok(ip_h->protocol == 1, "got protocol %#x.\n", ip_h->protocol);
13834
13835 ok(icmp_h->type == ICMP4_ECHO_REPLY, "got type %#x.\n", icmp_h->type);
13836 ok(!icmp_h->code, "got code %#x.\n", icmp_h->code);
13837 ok(icmp_h->un.echo.id == 0xbeaf, "got echo id %#x.\n", icmp_h->un.echo.id);
13838 ok(icmp_h->un.echo.sequence == 2, "got echo sequence %#x.\n", icmp_h->un.echo.sequence);
13839
13840 recv_checksum = icmp_h->checksum;
13841 icmp_h->checksum = 0;
13842 checksum = chksum((BYTE *)icmp_h, sizeof(send_buf));
13843 ok(recv_checksum == checksum, "got checksum %#x, expected %#x.\n", recv_checksum, checksum);
13844
13845 ok(reply_data == ping_data, "got reply_data %#x.\n", reply_data);
13846
13847 closesocket(s);
13848 }
13849
13850 static void test_connect_time(void)
13851 {
13852 struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
13853 SOCKET client, server;
13854 unsigned int time;
13855 int ret, len;
13856
13857 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
13858
13859 len = sizeof(time);
13860 SetLastError(0xdeadbeef);
13861 ret = getsockopt(client, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
13862 ok(!ret, "got %d\n", ret);
13863 ok(!GetLastError(), "got error %lu\n", GetLastError());
13864 ok(len == sizeof(time), "got len %d\n", len);
13865 ok(time == ~0u, "got time %u\n", time);
13866
13867 closesocket(client);
13868
13869 tcp_socketpair(&client, &server);
13870
13871 len = sizeof(time);
13872 SetLastError(0xdeadbeef);
13873 ret = getsockopt(client, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
13874 ok(!ret, "got %d\n", ret);
13875 ok(!GetLastError(), "got error %lu\n", GetLastError());
13876 ok(len == sizeof(time), "got len %d\n", len);
13877 ok(time == 0, "got time %u\n", time);
13878
13879 len = sizeof(time);
13880 SetLastError(0xdeadbeef);
13881 ret = getsockopt(server, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
13882 ok(!ret, "got %d\n", ret);
13883 ok(!GetLastError(), "got error %lu\n", GetLastError());
13884 ok(len == sizeof(time), "got len %d\n", len);
13885 ok(time == 0, "got time %u\n", time);
13886
13887 closesocket(client);
13888 closesocket(server);
13889
13890 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
13891 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
13892
13893 ret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
13894 ok(!ret, "got error %lu\n", GetLastError());
13895 len = sizeof(addr);
13896 ret = getsockname(server, (struct sockaddr *)&addr, &len);
13897 ok(!ret, "got error %lu\n", GetLastError());
13898 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
13899 ok(!ret, "got error %lu\n", GetLastError());
13900
13901 len = sizeof(time);
13902 SetLastError(0xdeadbeef);
13903 ret = getsockopt(client, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
13904 ok(!ret, "got %d\n", ret);
13905 ok(!GetLastError(), "got error %lu\n", GetLastError());
13906 ok(len == sizeof(time), "got len %d\n", len);
13907 ok(time == ~0u, "got time %u\n", time);
13908
13909 len = sizeof(time);
13910 SetLastError(0xdeadbeef);
13911 ret = getsockopt(server, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
13912 ok(!ret, "got %d\n", ret);
13913 ok(!GetLastError(), "got error %lu\n", GetLastError());
13914 ok(len == sizeof(time), "got len %d\n", len);
13915 ok(time == ~0u, "got time %u\n", time);
13916
13917 closesocket(server);
13918 closesocket(client);
13919 }
13920
13921 static void test_connect_udp(void)
13922 {
13923 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
13924 struct sockaddr_in addr, ret_addr;
13925 SOCKET client, server;
13926 char buffer[5];
13927 int ret, len;
13928
13929 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
13930 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
13931 set_blocking(client, FALSE);
13932 set_blocking(server, FALSE);
13933
13934 SetLastError(0xdeadbeef);
13935 ret = send(client, "data", 4, 0);
13936 ok(ret == -1, "got %d\n", ret);
13937 ok(GetLastError() == WSAENOTCONN, "got error %lu\n", GetLastError());
13938
13939 SetLastError(0xdeadbeef);
13940 ret = recv(server, buffer, sizeof(buffer), 0);
13941 ok(ret == -1, "got %d\n", ret);
13942 todo_wine ok(GetLastError() == WSAEINVAL, "got error %lu\n", GetLastError());
13943
13944 ret = bind(server, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
13945 ok(!ret, "got error %lu\n", GetLastError());
13946 len = sizeof(addr);
13947 ret = getsockname(server, (struct sockaddr *)&addr, &len);
13948 ok(!ret, "got error %lu\n", GetLastError());
13949
13950 SetLastError(0xdeadbeef);
13951 ret = recv(server, buffer, sizeof(buffer), 0);
13952 ok(ret == -1, "got %d\n", ret);
13953 ok(GetLastError() == WSAEWOULDBLOCK, "got error %lu\n", GetLastError());
13954
13955 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
13956 ok(!ret, "got error %lu\n", GetLastError());
13957 ret = getpeername(client, (struct sockaddr *)&ret_addr, &len);
13958 ok(!ret, "got error %lu\n", GetLastError());
13959 ok(!memcmp(&ret_addr, &addr, sizeof(addr)), "addresses didn't match\n");
13960
13961 ret = getsockname(client, (struct sockaddr *)&ret_addr, &len);
13962 ok(!ret, "got error %lu\n", GetLastError());
13963
13964 SetLastError(0xdeadbeef);
13965 ret = getpeername(server, (struct sockaddr *)&ret_addr, &len);
13966 ok(ret == -1, "got %d\n", ret);
13967 ok(GetLastError() == WSAENOTCONN, "got error %lu\n", GetLastError());
13968
13969 ret = send(client, "data", 4, 0);
13970 ok(ret == 4, "got %d\n", ret);
13971
13972 memset(buffer, 0xcc, sizeof(buffer));
13973 ret = recv(server, buffer, sizeof(buffer), 0);
13974 ok(ret == 4, "got %d\n", ret);
13975 ok(!memcmp(buffer, "data", 4), "got %s\n", debugstr_an(buffer, ret));
13976
13977 SetLastError(0xdeadbeef);
13978 ret = recv(server, buffer, sizeof(buffer), 0);
13979 ok(ret == -1, "got %d\n", ret);
13980 ok(GetLastError() == WSAEWOULDBLOCK, "got error %lu\n", GetLastError());
13981
13982 SetLastError(0xdeadbeef);
13983 ret = send(server, "data", 4, 0);
13984 ok(ret == -1, "got %d\n", ret);
13985 ok(GetLastError() == WSAENOTCONN, "got error %lu\n", GetLastError());
13986
13987 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
13988 ok(!ret, "got error %lu\n", GetLastError());
13989 ++addr.sin_port;
13990 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
13991 ok(!ret, "got error %lu\n", GetLastError());
13992
13993 memset(&addr, 0, sizeof(addr));
13994 addr.sin_family = AF_UNSPEC;
13995 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
13996 ok(!ret, "got error %lu\n", GetLastError());
13997
13998 ret = getpeername(client, (struct sockaddr *)&ret_addr, &len);
13999 ok(ret == -1, "got %d\n", ret);
14000 ok(GetLastError() == WSAENOTCONN, "got error %lu\n", GetLastError());
14001
14002 closesocket(server);
14003 closesocket(client);
14004 }
14005
14006 static void test_tcp_sendto_recvfrom(void)
14007 {
14008 SOCKET client, server = 0;
14009 SOCKADDR_IN addr = { AF_INET, SERVERPORT };
14010 SOCKADDR_IN bad_addr, bad_addr_copy;
14011 const char serverMsg[] = "ws2_32/TCP socket test";
14012 char clientBuf[sizeof(serverMsg)] = { 0 };
14013 int to_len = 0xc0ffee11;
14014 int ret;
14015
14016 inet_pton(AF_INET, SERVERIP, &addr.sin_addr);
14017
14018 tcp_socketpair(&client, &server);
14019
14020 memset(&bad_addr, 0xfe, sizeof(bad_addr));
14021 memcpy(&bad_addr_copy, &bad_addr, sizeof(bad_addr_copy));
14022
14023 ret = sendto(server, serverMsg, sizeof(serverMsg), 0, (SOCKADDR *)&bad_addr, sizeof(bad_addr));
14024 ok(ret == sizeof(serverMsg), "Incorrect return value from sendto: %d (%d)\n", ret, WSAGetLastError());
14025 ok(!memcmp(&bad_addr, &bad_addr_copy, sizeof(bad_addr)), "Provided address modified by sendto\n");
14026 ok(to_len == 0xc0ffee11, "Provided size modified by sendto\n");
14027
14028 ret = recvfrom(client, clientBuf, sizeof(clientBuf), 0, (SOCKADDR *)&bad_addr, &to_len);
14029 ok(ret == sizeof(serverMsg), "Incorrect return value from recvfrom: %d (%d)\n", ret, WSAGetLastError());
14030 ok(!memcmp(&bad_addr, &bad_addr_copy, sizeof(bad_addr)), "Provided address modified by recvfrom\n");
14031 ok(to_len == 0xc0ffee11, "Provided size modified by recvfrom\n");
14032
14033 ok(!memcmp(serverMsg, clientBuf, sizeof(serverMsg)), "Data mismatch over TCP socket\n");
14034
14035 closesocket(client);
14036 closesocket(server);
14037 }
14038
14039 /* Regression test for an internal bug affecting wget.exe. */
14040 static void test_select_after_WSAEventSelect(void)
14041 {
14042 SOCKET client, server;
14043 HANDLE event;
14044 int ret;
14045
14046 tcp_socketpair(&client, &server);
14047 event = CreateEventA(NULL, FALSE, FALSE, NULL);
14048
14049 ret = WSAEventSelect(client, event, FD_READ);
14050 ok(!ret, "got error %u\n", WSAGetLastError());
14051
14052 ret = send(server, "data", 4, 0);
14053 ok(ret == 4, "got %d\n", ret);
14054
14055 ret = WaitForSingleObject(event, 1000);
14056 ok(!ret, "got %d\n", ret);
14057
14058 /* Poll. This must not trigger any events to be signalled again. */
14059 check_poll(client, POLLRDNORM | POLLWRNORM);
14060
14061 ret = WaitForSingleObject(event, 0);
14062 ok(ret == WAIT_TIMEOUT, "got %d\n", ret);
14063
14064 CloseHandle(event);
14065 closesocket(server);
14066 closesocket(client);
14067 }
14068
14069 START_TEST( sock )
14070 {
14071 int i;
14072
14073 /* Leave these tests at the beginning. They depend on WSAStartup not having been
14074 * called, which is done by Init() below. */
14075 test_WithoutWSAStartup();
14076 test_WithWSAStartup();
14077
14078 Init();
14079
14080 test_set_getsockopt();
14081 test_reuseaddr();
14082 test_ip_pktinfo();
14083 test_ipv4_cmsg();
14084 test_ipv6_cmsg();
14085 test_extendedSocketOptions();
14086 test_so_debug();
14087 test_sockopt_validity();
14088 test_connect_time();
14089
14090 for (i = 0; i < ARRAY_SIZE(tests); i++)
14091 do_test(&tests[i]);
14092
14093 test_UDP();
14094
14095 test_WSASocket();
14096 test_WSADuplicateSocket();
14097 test_WSAConnectByName();
14098 test_WSAEnumNetworkEvents();
14099
14100 test_errors();
14101 test_listen();
14102 test_select();
14103 test_accept();
14104 test_accept_inheritance();
14105 test_getpeername();
14106 test_getsockname();
14107
14108 test_address_list_query();
14109 test_fionbio();
14110 test_fionread_siocatmark();
14111 test_get_extension_func();
14112 test_backlog_query();
14113 test_get_interface_list();
14114 test_keepalive_vals();
14115 test_sioRoutingInterfaceQuery();
14116 test_sioAddressListChange();
14117 test_base_handle();
14118 test_circular_queueing();
14119 test_unsupported_ioctls();
14120
14121 test_WSASendMsg();
14122 test_WSASendTo();
14123 test_WSARecv();
14124 test_WSAPoll();
14125 test_write_watch();
14126
14127 test_events();
14128 test_select_after_WSAEventSelect();
14129
14130 test_ipv6only();
14131 test_TransmitFile();
14132 test_AcceptEx();
14133 test_connect();
14134 test_shutdown();
14135 test_DisconnectEx();
14136
14137 test_completion_port();
14138 test_connect_completion_port();
14139 test_shutdown_completion_port();
14140 test_bind();
14141 test_connecting_socket();
14142 test_WSAGetOverlappedResult();
14143 test_nonblocking_async_recv();
14144 test_simultaneous_async_recv();
14145 test_empty_recv();
14146 test_timeout();
14147 test_tcp_reset();
14148 test_icmp();
14149 test_connect_udp();
14150 test_tcp_sendto_recvfrom();
14151
14152 /* There is apparently an obscure interaction between this test and
14153 * test_WSAGetOverlappedResult().
14154 *
14155 * One thing this test does is to close socket handles through CloseHandle()
14156 * and NtClose(), to prove that that is sufficient to cancel I/O on the
14157 * socket. This has the obscure side effect that ws2_32.dll's internal
14158 * per-process list of sockets never has that socket removed.
14159 *
14160 * test_WSAGetOverlappedResult() effectively proves that the per-process
14161 * list of sockets exists, by calling DuplicateHandle() on a socket and then
14162 * passing it to a function which cares about socket handle validity, which
14163 * checks that handle against the internal list, finds it invalid, and
14164 * returns WSAENOTSOCK.
14165 *
14166 * The problem is that if we close an NT handle without removing it from the
14167 * ws2_32 list, then duplicate another handle, it *may* end up allocated to
14168 * the same handle value, and thus re-validate that handle right under the
14169 * nose of ws2_32. This causes the test_WSAGetOverlappedResult() test to
14170 * sometimes succeed where it's expected to fail with ENOTSOCK.
14171 *
14172 * In order to avoid this, make sure that this test—which is evidently
14173 * destructive to ws2_32 internal state in obscure ways—is executed last.
14174 */
14175 test_iocp();
14176
14177 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
14178 test_send();
14179
14180 Exit();
14181 }
Windows API implementation