?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
server: Don't set SO_RCVBUF below Windows default value on Unix socket.
[wine.git] / dlls / ws2_32 / tests / sock.c
blob31dff1a11c79f94f42a89ae5dbb0ef81f6bb9367
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;
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 winetest_pop_context();
2401 }
2402
2403 /* SO_REUSEADDR and SO_EXCLUSIVEADDRUSE are mutually exclusive. */
2404 s1 = socket(AF_INET, SOCK_STREAM, 0);
2405 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2406
2407 value = 1;
2408 rc = setsockopt(s1, SOL_SOCKET, SO_REUSEADDR, (char*)&value, sizeof(value));
2409 ok(!rc, "got error %d.\n", WSAGetLastError());
2410
2411 value = 1;
2412 rc = setsockopt(s1, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&value, sizeof(value));
2413 ok(rc == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL, "got rc %d, error %d.\n", rc, WSAGetLastError());
2414
2415 value = 0;
2416 rc = setsockopt(s1, SOL_SOCKET, SO_REUSEADDR, (char*)&value, sizeof(value));
2417
2418 value = 1;
2419 rc = setsockopt(s1, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&value, sizeof(value));
2420 ok(!rc, "got error %d.\n", WSAGetLastError());
2421
2422 value = 1;
2423 rc = setsockopt(s1, SOL_SOCKET, SO_REUSEADDR, (char*)&value, sizeof(value));
2424 ok(rc == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL, "got rc %d, error %d.\n", rc, WSAGetLastError());
2425
2426 closesocket(s1);
2427
2428 /* Test SO_EXCLUSIVEADDRUSE. */
2429 for (i = 0; i < ARRAY_SIZE(tests_exclusive); ++i)
2430 {
2431 SOCKET s[2];
2432
2433 winetest_push_context("test %u", i);
2434
2435 for (j = 0; j < 2; ++j)
2436 {
2437 s[j] = socket(tests_exclusive[i].s[j].domain, SOCK_STREAM, 0);
2438 ok(s[j] != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2439
2440 if (tests_exclusive[i].s[j].exclusive)
2441 {
2442 value = 1;
2443 rc = setsockopt(s[j], SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&value, sizeof(value));
2444 ok(!rc, "got error %d.\n", WSAGetLastError());
2445 }
2446 if (tests_exclusive[i].s[j].domain == AF_INET6)
2447 {
2448 value = 0;
2449 rc = setsockopt(s[j], IPPROTO_IPV6, IPV6_V6ONLY, (char*)&value, sizeof(value));
2450 ok(!rc, "got error %d.\n", WSAGetLastError());
2451 }
2452 }
2453 rc = bind(s[0], tests_exclusive[i].s[0].addr, tests_exclusive[i].s[0].addrlen);
2454 ok(!rc || (tests_exclusive[i].s[0].domain == AF_INET6 && WSAGetLastError() == WSAEADDRNOTAVAIL), "got error %d.\n", WSAGetLastError());
2455
2456 rc = bind(s[1], tests_exclusive[i].s[1].addr, tests_exclusive[i].s[1].addrlen);
2457
2458 if (tests_exclusive[i].error)
2459 ok(rc == SOCKET_ERROR && WSAGetLastError() == tests_exclusive[i].error,
2460 "got rc %d, error %d, expected error %d.\n", rc, WSAGetLastError(), tests_exclusive[i].error);
2461 else
2462 ok(!rc, "got error %d.\n", WSAGetLastError());
2463
2464 closesocket(s[0]);
2465 closesocket(s[1]);
2466 winetest_pop_context();
2467 }
2468 }
2469
2470 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
2471
2472 static unsigned int got_ip_pktinfo_apc;
2473
2474 static void WINAPI ip_pktinfo_apc(DWORD error, DWORD size, OVERLAPPED *overlapped, DWORD flags)
2475 {
2476 ok(error == WSAEMSGSIZE, "got error %lu\n", error);
2477 ok(size == 6, "got size %lu\n", size);
2478 ok(!flags, "got flags %#lx\n", flags);
2479 ++got_ip_pktinfo_apc;
2480 }
2481
2482 static void test_ip_pktinfo(void)
2483 {
2484 ULONG addresses[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY)};
2485 char recvbuf[10], pktbuf[512], msg[] = "HELLO";
2486 struct sockaddr_in s1addr, s2addr, s3addr;
2487 LPFN_WSARECVMSG pWSARecvMsg = NULL;
2488 unsigned int rc, yes = 1;
2489 BOOL foundhdr;
2490 DWORD dwBytes, dwSize, dwFlags;
2491 socklen_t addrlen;
2492 WSACMSGHDR *cmsg;
2493 WSAOVERLAPPED ov;
2494 WSABUF iovec[1];
2495 SOCKET s1, s2;
2496 WSAMSG hdr;
2497 int i, err;
2498
2499 memset(&ov, 0, sizeof(ov));
2500 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
2501
2502 memset(&hdr, 0x00, sizeof(hdr));
2503 s1addr.sin_family = AF_INET;
2504 s1addr.sin_port = htons(0);
2505 /* Note: s1addr.sin_addr is set below */
2506 iovec[0].buf = recvbuf;
2507 iovec[0].len = sizeof(recvbuf);
2508 hdr.name = (struct sockaddr*)&s3addr;
2509 hdr.namelen = sizeof(s3addr);
2510 hdr.lpBuffers = &iovec[0];
2511 hdr.dwBufferCount = 1;
2512 hdr.Control.buf = pktbuf;
2513 /* Note: hdr.Control.len is set below */
2514 hdr.dwFlags = 0;
2515
2516 for (i=0;i<ARRAY_SIZE(addresses);i++)
2517 {
2518 s1addr.sin_addr.s_addr = addresses[i];
2519
2520 /* Build "server" side socket */
2521 s1=socket(AF_INET, SOCK_DGRAM, 0);
2522 ok(s1 != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2523
2524 /* Obtain the WSARecvMsg function */
2525 rc = WSAIoctl(s1, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
2526 &pWSARecvMsg, sizeof(pWSARecvMsg), &dwBytes, NULL, NULL);
2527 ok(!rc, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
2528
2529 /* Setup the server side socket */
2530 rc=bind(s1, (struct sockaddr*)&s1addr, sizeof(s1addr));
2531 ok(rc != SOCKET_ERROR, "bind() failed error: %d\n", WSAGetLastError());
2532
2533 /* Build "client" side socket */
2534 addrlen = sizeof(s2addr);
2535 rc = getsockname(s1, (struct sockaddr *) &s2addr, &addrlen);
2536 ok(!rc, "failed to get address, error %u\n", WSAGetLastError());
2537 s2addr.sin_addr.s_addr = addresses[0]; /* Always target the local adapter address */
2538 s2=socket(AF_INET, SOCK_DGRAM, 0);
2539 ok(s2 != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2540
2541 /* Test an empty message header */
2542 rc=pWSARecvMsg(s1, NULL, NULL, NULL, NULL);
2543 err=WSAGetLastError();
2544 ok(rc == SOCKET_ERROR && err == WSAEFAULT, "WSARecvMsg() failed error: %d (ret = %d)\n", err, rc);
2545
2546 /* Test that when no control data arrives, a 0-length NULL-valued control buffer should succeed */
2547 SetLastError(0xdeadbeef);
2548 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2549 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2550 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
2551 hdr.Control.buf = NULL;
2552 hdr.Control.len = 0;
2553 rc=pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
2554 ok(rc == 0, "WSARecvMsg() failed error: %d\n", WSAGetLastError());
2555 hdr.Control.buf = pktbuf;
2556
2557 /* Now start IP_PKTINFO for future tests */
2558 rc=setsockopt(s1, IPPROTO_IP, IP_PKTINFO, (const char*)&yes, sizeof(yes));
2559 ok(rc == 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
2560
2561 /*
2562 * Send a packet from the client to the server and test for specifying
2563 * a short control header.
2564 */
2565 SetLastError(0xdeadbeef);
2566 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2567 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2568 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
2569 hdr.Control.len = 1;
2570 dwSize = 0xdeadbeef;
2571 rc = pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
2572 ok(rc == -1, "expected failure\n");
2573 ok(WSAGetLastError() == WSAEMSGSIZE, "got error %u\n", WSAGetLastError());
2574 todo_wine ok(dwSize == sizeof(msg), "got size %lu\n", dwSize);
2575 ok(hdr.dwFlags == MSG_CTRUNC, "got flags %#lx\n", hdr.dwFlags);
2576 hdr.dwFlags = 0; /* Reset flags */
2577
2578 /* Perform another short control header test, this time with an overlapped receive */
2579 hdr.Control.len = 1;
2580 ov.Internal = 0xdead1;
2581 ov.InternalHigh = 0xdead2;
2582 ov.Offset = 0xdead3;
2583 ov.OffsetHigh = 0xdead4;
2584 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
2585 err=WSAGetLastError();
2586 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
2587 SetLastError(0xdeadbeef);
2588 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2589 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2590 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
2591 ok(!WaitForSingleObject(ov.hEvent, 100), "wait failed\n");
2592 ok((NTSTATUS)ov.Internal == STATUS_BUFFER_OVERFLOW, "got status %#lx\n", (NTSTATUS)ov.Internal);
2593 ok(ov.InternalHigh == sizeof(msg), "got size %Iu\n", ov.InternalHigh);
2594 ok(ov.Offset == 0xdead3, "got Offset %lu\n", ov.Offset);
2595 ok(ov.OffsetHigh == 0xdead4, "got OffsetHigh %lu\n", ov.OffsetHigh);
2596 dwFlags = 0xdeadbeef;
2597 rc = WSAGetOverlappedResult(s1, &ov, &dwSize, FALSE, &dwFlags);
2598 ok(!rc, "expected failure\n");
2599 ok(WSAGetLastError() == WSAEMSGSIZE, "got error %u\n", WSAGetLastError());
2600 ok(dwSize == sizeof(msg), "got size %lu\n", dwSize);
2601 todo_wine ok(dwFlags == 0xdeadbeef, "got flags %#lx\n", dwFlags);
2602 ok(hdr.dwFlags == MSG_CTRUNC,
2603 "WSARecvMsg() overlapped operation set unexpected flags %ld.\n", hdr.dwFlags);
2604 hdr.dwFlags = 0; /* Reset flags */
2605
2606 /* And with an APC. */
2607
2608 SetLastError(0xdeadbeef);
2609 rc = sendto(s2, msg, sizeof(msg), 0, (struct sockaddr *)&s2addr, sizeof(s2addr));
2610 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2611 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
2612 hdr.Control.len = 1;
2613
2614 ov.Internal = 0xdead1;
2615 ov.InternalHigh = 0xdead2;
2616 ov.Offset = 0xdead3;
2617 ov.OffsetHigh = 0xdead4;
2618 dwSize = 0xdeadbeef;
2619 rc = pWSARecvMsg(s1, &hdr, NULL, &ov, ip_pktinfo_apc);
2620 ok(rc == -1, "expected failure\n");
2621 todo_wine ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
2622
2623 rc = SleepEx(1000, TRUE);
2624 ok(rc == WAIT_IO_COMPLETION, "got %d\n", rc);
2625 ok(got_ip_pktinfo_apc == 1, "apc was called %u times\n", got_ip_pktinfo_apc);
2626 ok(hdr.dwFlags == MSG_CTRUNC, "got flags %#lx\n", hdr.dwFlags);
2627 got_ip_pktinfo_apc = 0;
2628
2629 hdr.dwFlags = 0; /* Reset flags */
2630
2631 /*
2632 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
2633 * on the server end and check that the returned packet matches what was sent.
2634 */
2635 hdr.Control.len = sizeof(pktbuf);
2636 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
2637 err=WSAGetLastError();
2638 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
2639 ok(hdr.Control.len == sizeof(pktbuf),
2640 "WSARecvMsg() control length mismatch (%ld != sizeof pktbuf).\n", hdr.Control.len);
2641 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2642 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2643 ok(!WaitForSingleObject(ov.hEvent, 100), "wait failed\n");
2644 dwSize = 0;
2645 WSAGetOverlappedResult(s1, &ov, &dwSize, FALSE, NULL);
2646 ok(dwSize == sizeof(msg),
2647 "WSARecvMsg() buffer length does not match transmitted data!\n");
2648 ok(strncmp(iovec[0].buf, msg, sizeof(msg)) == 0,
2649 "WSARecvMsg() buffer does not match transmitted data!\n");
2650 ok(hdr.Control.len == IP_PKTINFO_LEN,
2651 "WSARecvMsg() control length mismatch (%ld).\n", hdr.Control.len);
2652
2653 /* Test for the expected IP_PKTINFO return information. */
2654 foundhdr = FALSE;
2655 for (cmsg = WSA_CMSG_FIRSTHDR(&hdr); cmsg != NULL; cmsg = WSA_CMSG_NXTHDR(&hdr, cmsg))
2656 {
2657 if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO)
2658 {
2659 struct in_pktinfo *pi = (struct in_pktinfo *)WSA_CMSG_DATA(cmsg);
2660
2661 ok(pi->ipi_addr.s_addr == s2addr.sin_addr.s_addr, "destination ip mismatch!\n");
2662 foundhdr = TRUE;
2663 }
2664 }
2665 ok(foundhdr, "IP_PKTINFO header information was not returned!\n");
2666
2667 closesocket(s2);
2668 closesocket(s1);
2669 }
2670
2671 CloseHandle(ov.hEvent);
2672 }
2673
2674 static void test_ipv4_cmsg(void)
2675 {
2676 static const DWORD off = 0;
2677 static const DWORD on = 1;
2678 SOCKADDR_IN localhost = {0};
2679 SOCKET client, server;
2680 char payload[] = "HELLO";
2681 char control[100];
2682 WSABUF payload_buf = {sizeof(payload), payload};
2683 WSAMSG msg = {NULL, 0, &payload_buf, 1, {sizeof(control), control}, 0};
2684 WSACMSGHDR *header = (WSACMSGHDR *)control;
2685 LPFN_WSARECVMSG pWSARecvMsg;
2686 INT *int_data = (INT *)WSA_CMSG_DATA(header);
2687 IN_PKTINFO *pkt_info = (IN_PKTINFO *)WSA_CMSG_DATA(header);
2688 DWORD count, state;
2689 int rc;
2690
2691 localhost.sin_family = AF_INET;
2692 localhost.sin_port = htons(SERVERPORT);
2693 inet_pton(AF_INET, "127.0.0.1", &localhost.sin_addr);
2694
2695 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
2696 ok(client != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2697 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
2698 ok(server != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2699
2700 rc = bind(server, (SOCKADDR *)&localhost, sizeof(localhost));
2701 ok(rc != SOCKET_ERROR, "bind failed, error %u\n", WSAGetLastError());
2702 rc = connect(client, (SOCKADDR *)&localhost, sizeof(localhost));
2703 ok(rc != SOCKET_ERROR, "connect failed, error %u\n", WSAGetLastError());
2704
2705 rc = WSAIoctl(server, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
2706 &pWSARecvMsg, sizeof(pWSARecvMsg), &count, NULL, NULL);
2707 ok(!rc, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
2708
2709 memset(control, 0, sizeof(control));
2710 msg.Control.len = sizeof(control);
2711 rc = setsockopt(server, IPPROTO_IP, IP_RECVTTL, (const char *)&on, sizeof(on));
2712 ok(!rc, "failed to set IP_RECVTTL, error %u\n", WSAGetLastError());
2713 state = 0;
2714 count = sizeof(state);
2715 rc = getsockopt(server, IPPROTO_IP, IP_RECVTTL, (char *)&state, (INT *)&count);
2716 ok(!rc, "failed to get IP_RECVTTL, error %u\n", WSAGetLastError());
2717 ok(state == 1, "expected 1, got %lu\n", state);
2718 rc = send(client, payload, sizeof(payload), 0);
2719 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2720 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2721 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2722 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2723 ok(header->cmsg_level == IPPROTO_IP, "expected IPPROTO_IP, got %i\n", header->cmsg_level);
2724 ok(header->cmsg_type == IP_TTL || broken(header->cmsg_type == IP_HOPLIMIT) /* <= win10 v1607 */,
2725 "expected IP_TTL, got %i\n", header->cmsg_type);
2726 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
2727 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(INT), header->cmsg_len);
2728 ok(*int_data >= 32, "expected at least 32, got %i\n", *int_data);
2729 setsockopt(server, IPPROTO_IP, IP_RECVTTL, (const char *)&off, sizeof(off));
2730 ok(!rc, "failed to clear IP_RECVTTL, error %u\n", WSAGetLastError());
2731
2732 memset(control, 0, sizeof(control));
2733 msg.Control.len = sizeof(control);
2734 rc = setsockopt(server, IPPROTO_IP, IP_PKTINFO, (const char *)&on, sizeof(on));
2735 ok(!rc, "failed to set IP_PKTINFO, error %u\n", WSAGetLastError());
2736 state = 0;
2737 count = sizeof(state);
2738 rc = getsockopt(server, IPPROTO_IP, IP_PKTINFO, (char *)&state, (INT *)&count);
2739 ok(!rc, "failed to get IP_PKTINFO, error %u\n", WSAGetLastError());
2740 ok(state == 1, "expected 1, got %lu\n", state);
2741 rc = send(client, payload, sizeof(payload), 0);
2742 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2743 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2744 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2745 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2746 ok(header->cmsg_level == IPPROTO_IP, "expected IPPROTO_IP, got %i\n", header->cmsg_level);
2747 ok(header->cmsg_type == IP_PKTINFO, "expected IP_PKTINFO, got %i\n", header->cmsg_type);
2748 ok(header->cmsg_len == sizeof(*header) + sizeof(IN_PKTINFO),
2749 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(IN_PKTINFO), header->cmsg_len);
2750 ok(!memcmp(&pkt_info->ipi_addr, &localhost.sin_addr, sizeof(IN_ADDR)), "expected 127.0.0.1\n");
2751 rc = setsockopt(server, IPPROTO_IP, IP_PKTINFO, (const char *)&off, sizeof(off));
2752 ok(!rc, "failed to clear IP_PKTINFO, error %u\n", WSAGetLastError());
2753
2754 memset(control, 0, sizeof(control));
2755 msg.Control.len = sizeof(control);
2756 rc = setsockopt(server, IPPROTO_IP, IP_RECVTOS, (const char *)&on, sizeof(on));
2757 ok(!rc, "failed to set IP_RECVTOS, error %u\n", WSAGetLastError());
2758 state = 0;
2759 count = sizeof(state);
2760 rc = getsockopt(server, IPPROTO_IP, IP_RECVTOS, (char *)&state, (INT *)&count);
2761 ok(!rc, "failed to get IP_RECVTOS, error %u\n", WSAGetLastError());
2762 ok(state == 1, "expected 1, got %lu\n", state);
2763 rc = send(client, payload, sizeof(payload), 0);
2764 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2765 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2766 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2767 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2768 ok(header->cmsg_level == IPPROTO_IP, "expected IPPROTO_IP, got %i\n", header->cmsg_level);
2769 ok(header->cmsg_type == IP_TOS || broken(header->cmsg_type == IP_TCLASS) /* <= win10 v1607 */,
2770 "expected IP_TOS, got %i\n", header->cmsg_type);
2771 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
2772 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(INT), header->cmsg_len);
2773 ok(*int_data == 0, "expected 0, got %i\n", *int_data);
2774 rc = setsockopt(server, IPPROTO_IP, IP_RECVTOS, (const char *)&off, sizeof(off));
2775 ok(!rc, "failed to clear IP_RECVTOS, error %u\n", WSAGetLastError());
2776
2777 closesocket(server);
2778 closesocket(client);
2779 }
2780
2781 static void test_ipv6_cmsg(void)
2782 {
2783 static const DWORD off = 0;
2784 static const DWORD on = 1;
2785 SOCKADDR_IN6 localhost = {0};
2786 SOCKET client, server;
2787 char payload[] = "HELLO";
2788 char control[100];
2789 WSABUF payload_buf = {sizeof(payload), payload};
2790 WSAMSG msg = {NULL, 0, &payload_buf, 1, {sizeof(control), control}, 0};
2791 WSACMSGHDR *header = (WSACMSGHDR *)control;
2792 LPFN_WSARECVMSG pWSARecvMsg;
2793 INT *int_data = (INT *)WSA_CMSG_DATA(header);
2794 IN6_PKTINFO *pkt_info = (IN6_PKTINFO *)WSA_CMSG_DATA(header);
2795 DWORD count, state;
2796 int rc;
2797
2798 localhost.sin6_family = AF_INET6;
2799 localhost.sin6_port = htons(SERVERPORT);
2800 inet_pton(AF_INET6, "::1", &localhost.sin6_addr);
2801
2802 client = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
2803 ok(client != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2804 server = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
2805 ok(server != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2806
2807 rc = bind(server, (SOCKADDR *)&localhost, sizeof(localhost));
2808 ok(rc != SOCKET_ERROR || WSAGetLastError() == WSAEADDRNOTAVAIL, "bind failed, error %u\n", WSAGetLastError());
2809 if (WSAGetLastError() == WSAEADDRNOTAVAIL)
2810 {
2811 skip("IPv6 not supported, skipping test\n");
2812 goto cleanup;
2813 }
2814 rc = connect(client, (SOCKADDR *)&localhost, sizeof(localhost));
2815 ok(rc != SOCKET_ERROR, "connect failed, error %u\n", WSAGetLastError());
2816
2817 rc = WSAIoctl(server, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
2818 &pWSARecvMsg, sizeof(pWSARecvMsg), &count, NULL, NULL);
2819 ok(!rc, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
2820
2821 memset(control, 0, sizeof(control));
2822 msg.Control.len = sizeof(control);
2823 rc = setsockopt(server, IPPROTO_IPV6, IPV6_HOPLIMIT, (const char *)&on, sizeof(on));
2824 ok(!rc, "failed to set IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2825 state = 0;
2826 count = sizeof(state);
2827 rc = getsockopt(server, IPPROTO_IPV6, IPV6_HOPLIMIT, (char *)&state, (INT *)&count);
2828 ok(!rc, "failed to get IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2829 ok(state == 1, "expected 1, got %lu\n", state);
2830 rc = send(client, payload, sizeof(payload), 0);
2831 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2832 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2833 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2834 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2835 ok(header->cmsg_level == IPPROTO_IPV6, "expected IPPROTO_IPV6, got %i\n", header->cmsg_level);
2836 ok(header->cmsg_type == IPV6_HOPLIMIT, "expected IPV6_HOPLIMIT, got %i\n", header->cmsg_type);
2837 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
2838 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(INT), header->cmsg_len);
2839 ok(*int_data >= 32, "expected at least 32, got %i\n", *int_data);
2840 setsockopt(server, IPPROTO_IPV6, IPV6_HOPLIMIT, (const char *)&off, sizeof(off));
2841 ok(!rc, "failed to clear IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2842
2843 memset(control, 0, sizeof(control));
2844 msg.Control.len = sizeof(control);
2845 rc = setsockopt(server, IPPROTO_IPV6, IPV6_PKTINFO, (const char *)&on, sizeof(on));
2846 ok(!rc, "failed to set IPV6_PKTINFO, error %u\n", WSAGetLastError());
2847 state = 0;
2848 count = sizeof(state);
2849 rc = getsockopt(server, IPPROTO_IPV6, IPV6_PKTINFO, (char *)&state, (INT *)&count);
2850 ok(!rc, "failed to get IPV6_PKTINFO, error %u\n", WSAGetLastError());
2851 ok(state == 1, "expected 1, got %lu\n", state);
2852 rc = send(client, payload, sizeof(payload), 0);
2853 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2854 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2855 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2856 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2857 ok(header->cmsg_level == IPPROTO_IPV6, "expected IPPROTO_IPV6, got %i\n", header->cmsg_level);
2858 ok(header->cmsg_type == IPV6_PKTINFO, "expected IPV6_PKTINFO, got %i\n", header->cmsg_type);
2859 ok(header->cmsg_len == sizeof(*header) + sizeof(IN6_PKTINFO),
2860 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(IN6_PKTINFO), header->cmsg_len);
2861 ok(!memcmp(&pkt_info->ipi6_addr, &localhost.sin6_addr, sizeof(IN6_ADDR)), "expected ::1\n");
2862 rc = setsockopt(server, IPPROTO_IPV6, IPV6_PKTINFO, (const char *)&off, sizeof(off));
2863 ok(!rc, "failed to clear IPV6_PKTINFO, error %u\n", WSAGetLastError());
2864
2865 memset(control, 0, sizeof(control));
2866 msg.Control.len = sizeof(control);
2867 rc = setsockopt(server, IPPROTO_IPV6, IPV6_RECVTCLASS, (const char *)&on, sizeof(on));
2868 ok(!rc, "failed to set IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
2869 state = 0;
2870 count = sizeof(state);
2871 rc = getsockopt(server, IPPROTO_IPV6, IPV6_RECVTCLASS, (char *)&state, (INT *)&count);
2872 ok(!rc, "failed to get IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
2873 ok(state == 1, "expected 1, got %lu\n", state);
2874 rc = send(client, payload, sizeof(payload), 0);
2875 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2876 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2877 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2878 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2879 ok(header->cmsg_level == IPPROTO_IPV6, "expected IPPROTO_IPV6, got %i\n", header->cmsg_level);
2880 ok(header->cmsg_type == IPV6_TCLASS, "expected IPV6_TCLASS, got %i\n", header->cmsg_type);
2881 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
2882 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(INT), header->cmsg_len);
2883 ok(*int_data == 0, "expected 0, got %i\n", *int_data);
2884 rc = setsockopt(server, IPPROTO_IPV6, IPV6_RECVTCLASS, (const char *)&off, sizeof(off));
2885 ok(!rc, "failed to clear IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
2886
2887 cleanup:
2888 closesocket(server);
2889 closesocket(client);
2890 }
2891
2892 /************* Array containing the tests to run **********/
2893
2894 #define STD_STREAM_SOCKET \
2895 SOCK_STREAM, \
2896 0, \
2897 SERVERIP, \
2898 SERVERPORT
2899
2900 static test_setup tests [] =
2901 {
2902 /* Test 0: synchronous client and server */
2903 {
2904 {
2905 STD_STREAM_SOCKET,
2906 2048,
2907 16,
2908 2
2909 },
2910 simple_server,
2911 {
2912 NULL,
2913 0,
2914 64
2915 },
2916 simple_client,
2917 {
2918 NULL,
2919 0,
2920 128
2921 }
2922 },
2923 /* Test 1: event-driven client, synchronous server */
2924 {
2925 {
2926 STD_STREAM_SOCKET,
2927 2048,
2928 16,
2929 2
2930 },
2931 simple_server,
2932 {
2933 NULL,
2934 0,
2935 64
2936 },
2937 event_client,
2938 {
2939 NULL,
2940 WSA_FLAG_OVERLAPPED,
2941 128
2942 }
2943 },
2944 /* Test 2: synchronous client, non-blocking server via select() */
2945 {
2946 {
2947 STD_STREAM_SOCKET,
2948 2048,
2949 16,
2950 2
2951 },
2952 select_server,
2953 {
2954 NULL,
2955 0,
2956 64
2957 },
2958 simple_client,
2959 {
2960 NULL,
2961 0,
2962 128
2963 }
2964 },
2965 /* Test 3: OOB client, OOB server */
2966 {
2967 {
2968 STD_STREAM_SOCKET,
2969 128,
2970 16,
2971 1
2972 },
2973 oob_server,
2974 {
2975 NULL,
2976 0,
2977 128
2978 },
2979 oob_client,
2980 {
2981 NULL,
2982 0,
2983 128
2984 }
2985 },
2986 /* Test 4: synchronous mixed client and server */
2987 {
2988 {
2989 STD_STREAM_SOCKET,
2990 2048,
2991 16,
2992 2
2993 },
2994 simple_server,
2995 {
2996 NULL,
2997 0,
2998 64
2999 },
3000 simple_mixed_client,
3001 {
3002 NULL,
3003 0,
3004 128
3005 }
3006 }
3007 };
3008
3009 static void test_UDP(void)
3010 {
3011 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
3012 possible that this test fails due to dropped packets. */
3013
3014 /* peer 0 receives data from all other peers */
3015 struct sock_info peer[NUM_UDP_PEERS];
3016 char buf[16];
3017 int ss, i, n_recv, n_sent, ret;
3018 struct sockaddr_in addr;
3019 int sock;
3020
3021 memset (buf,0,sizeof(buf));
3022 for ( i = NUM_UDP_PEERS - 1; i >= 0; i-- ) {
3023 ok ( ( peer[i].s = socket ( AF_INET, SOCK_DGRAM, 0 ) ) != INVALID_SOCKET, "UDP: socket failed\n" );
3024
3025 peer[i].addr.sin_family = AF_INET;
3026 peer[i].addr.sin_addr.s_addr = inet_addr ( SERVERIP );
3027
3028 if ( i == 0 ) {
3029 peer[i].addr.sin_port = htons ( SERVERPORT );
3030 } else {
3031 peer[i].addr.sin_port = htons ( 0 );
3032 }
3033
3034 do_bind ( peer[i].s, (struct sockaddr *) &peer[i].addr, sizeof( peer[i].addr ) );
3035
3036 /* test getsockname() to get peer's port */
3037 ss = sizeof ( peer[i].addr );
3038 ok ( getsockname ( peer[i].s, (struct sockaddr *) &peer[i].addr, &ss ) != SOCKET_ERROR, "UDP: could not getsockname()\n" );
3039 ok ( peer[i].addr.sin_port != htons ( 0 ), "UDP: bind() did not associate port\n" );
3040 }
3041
3042 /* test getsockname() */
3043 ok ( peer[0].addr.sin_port == htons ( SERVERPORT ), "UDP: getsockname returned incorrect peer port\n" );
3044
3045 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
3046 /* send client's ip */
3047 memcpy( buf, &peer[i].addr.sin_port, sizeof(peer[i].addr.sin_port) );
3048 n_sent = sendto ( peer[i].s, buf, sizeof(buf), 0, (struct sockaddr*) &peer[0].addr, sizeof(peer[0].addr) );
3049 ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
3050 }
3051
3052 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
3053 n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0,(struct sockaddr *) &peer[0].peer, &ss );
3054 ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
3055 ok ( memcmp ( &peer[0].peer.sin_port, buf, sizeof(peer[0].addr.sin_port) ) == 0, "UDP: port numbers do not match\n" );
3056 }
3057
3058 sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP);
3059 ok( sock != INVALID_SOCKET, "got error %u.\n", WSAGetLastError() );
3060
3061 memset( &addr, 0, sizeof(addr) );
3062 addr.sin_family = AF_INET;
3063 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
3064 addr.sin_port = htons(255);
3065
3066 ret = connect( sock, (struct sockaddr *)&addr, sizeof(addr) );
3067 ok( !ret, "got error %u.\n", WSAGetLastError() );
3068
3069 /* Send to UDP socket succeeds even if the packets are not received and the network is replying with
3070 * "destination port unreachable" ICMP messages. */
3071 for (i = 0; i < 10; ++i)
3072 {
3073 ret = send( sock, buf, sizeof(buf), 0 );
3074 ok( ret == sizeof(buf), "got %d, error %u.\n", ret, WSAGetLastError() );
3075 }
3076
3077 closesocket(sock);
3078 }
3079
3080 static void test_WSASocket(void)
3081 {
3082 SOCKET sock = INVALID_SOCKET;
3083 WSAPROTOCOL_INFOA *pi;
3084 int wsaproviders[] = {IPPROTO_TCP, IPPROTO_IP};
3085 int autoprotocols[] = {IPPROTO_TCP, IPPROTO_UDP};
3086 int items, err, size, socktype, i, j;
3087 DWORD pi_size;
3088
3089 static const struct
3090 {
3091 int family, type, protocol;
3092 DWORD error;
3093 int ret_family, ret_type, ret_protocol;
3094 int ret_family_alt;
3095 }
3096 tests[] =
3097 {
3098 /* 0 */
3099 {0xdead, SOCK_STREAM, IPPROTO_TCP, WSAEAFNOSUPPORT},
3100 {-1, SOCK_STREAM, IPPROTO_TCP, WSAEAFNOSUPPORT},
3101 {AF_INET, 0xdead, IPPROTO_TCP, WSAESOCKTNOSUPPORT},
3102 {AF_INET, -1, IPPROTO_TCP, WSAESOCKTNOSUPPORT},
3103 {AF_INET, SOCK_STREAM, 0xdead, WSAEPROTONOSUPPORT},
3104 {AF_INET, SOCK_STREAM, -1, WSAEPROTONOSUPPORT},
3105 {0xdead, 0xdead, IPPROTO_TCP, WSAESOCKTNOSUPPORT},
3106 {0xdead, SOCK_STREAM, 0xdead, WSAEAFNOSUPPORT},
3107 {AF_INET, 0xdead, 0xdead, WSAESOCKTNOSUPPORT},
3108 {0xdead, SOCK_STREAM, IPPROTO_UDP, WSAEAFNOSUPPORT},
3109
3110 /* 10 */
3111 {AF_INET, SOCK_STREAM, 0, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP},
3112 {AF_INET, SOCK_DGRAM, 0, 0, AF_INET, SOCK_DGRAM, IPPROTO_UDP},
3113 {AF_INET, 0xdead, 0, WSAESOCKTNOSUPPORT},
3114 {AF_INET, 0, IPPROTO_TCP, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP},
3115 {AF_INET, 0, IPPROTO_UDP, 0, AF_INET, SOCK_DGRAM, IPPROTO_UDP},
3116 {AF_INET, 0, 0xdead, WSAEPROTONOSUPPORT},
3117 {AF_INET, 0, 0, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP},
3118 {AF_INET, SOCK_STREAM, IPPROTO_UDP, WSAEPROTONOSUPPORT},
3119 {AF_INET, SOCK_DGRAM, IPPROTO_TCP, WSAEPROTONOSUPPORT},
3120
3121 /* 19 */
3122 {AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP, AF_INET6 /* win11 */},
3123 {AF_UNSPEC, SOCK_STREAM, 0xdead, WSAEPROTONOSUPPORT},
3124 {AF_UNSPEC, 0xdead, IPPROTO_UDP, WSAESOCKTNOSUPPORT},
3125 {AF_UNSPEC, SOCK_STREAM, 0, WSAEINVAL},
3126 {AF_UNSPEC, SOCK_DGRAM, 0, WSAEINVAL},
3127 {AF_UNSPEC, 0xdead, 0, WSAEINVAL},
3128 {AF_UNSPEC, 0, IPPROTO_TCP, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP, AF_INET6 /* win11 */},
3129 {AF_UNSPEC, 0, IPPROTO_UDP, 0, AF_INET, SOCK_DGRAM, IPPROTO_UDP, AF_INET6 /* win11 */},
3130 {AF_UNSPEC, 0, 0xdead, WSAEPROTONOSUPPORT},
3131 {AF_UNSPEC, 0, 0, WSAEINVAL},
3132 };
3133
3134 for (i = 0; i < ARRAY_SIZE(tests); ++i)
3135 {
3136 SetLastError( 0xdeadbeef );
3137 sock = WSASocketA( tests[i].family, tests[i].type, tests[i].protocol, NULL, 0, 0 );
3138 todo_wine_if (i == 7)
3139 ok(WSAGetLastError() == tests[i].error, "Test %u: got wrong error %u\n", i, WSAGetLastError());
3140 if (tests[i].error)
3141 {
3142 ok(sock == INVALID_SOCKET, "Test %u: expected failure\n", i);
3143 }
3144 else
3145 {
3146 WSAPROTOCOL_INFOA info;
3147
3148 ok(sock != INVALID_SOCKET, "Text %u: expected success\n", i);
3149
3150 size = sizeof(info);
3151 err = getsockopt( sock, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *)&info, &size );
3152 ok(!err, "Test %u: getsockopt failed, error %u\n", i, WSAGetLastError());
3153 ok(info.iAddressFamily == tests[i].ret_family ||
3154 (tests[i].ret_family_alt && info.iAddressFamily == tests[i].ret_family_alt),
3155 "Test %u: got wrong family %d\n", i, info.iAddressFamily);
3156 ok(info.iSocketType == tests[i].ret_type, "Test %u: got wrong type %d\n", i, info.iSocketType);
3157 ok(info.iProtocol == tests[i].ret_protocol, "Test %u: got wrong protocol %d\n", i, info.iProtocol);
3158
3159 closesocket( sock );
3160 }
3161 }
3162
3163 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
3164 * to avoid a crash on win98.
3165 */
3166 pi_size = 0;
3167 items = WSAEnumProtocolsA(wsaproviders, NULL, &pi_size);
3168 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
3169 items);
3170 err = WSAGetLastError();
3171 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
3172 err, WSAENOBUFS);
3173
3174 pi = malloc(pi_size);
3175 ok(pi != NULL, "Failed to allocate memory\n");
3176
3177 items = WSAEnumProtocolsA(wsaproviders, pi, &pi_size);
3178 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
3179 WSAGetLastError());
3180
3181 if (items == 0) {
3182 skip("No protocols enumerated.\n");
3183 free(pi);
3184 return;
3185 }
3186
3187 sock = WSASocketA(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
3188 FROM_PROTOCOL_INFO, &pi[0], 0, 0);
3189 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3190 WSAGetLastError());
3191 closesocket(sock);
3192
3193 /* find what parameters are used first: plain parameters or protocol info struct */
3194 pi[0].iProtocol = -1;
3195 pi[0].iSocketType = -1;
3196 pi[0].iAddressFamily = -1;
3197 ok(WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0) == INVALID_SOCKET,
3198 "WSASocketA should have failed\n");
3199 err = WSAGetLastError();
3200 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
3201
3202 pi[0].iProtocol = 0;
3203 pi[0].iSocketType = 0;
3204 pi[0].iAddressFamily = 0;
3205 sock = WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0);
3206 if(sock != INVALID_SOCKET)
3207 {
3208 win_skip("must work only in OS <= 2003\n");
3209 closesocket(sock);
3210 }
3211 else
3212 {
3213 err = WSAGetLastError();
3214 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
3215 }
3216
3217 pi[0].iProtocol = IPPROTO_UDP;
3218 pi[0].iSocketType = SOCK_DGRAM;
3219 pi[0].iAddressFamily = AF_INET;
3220 sock = WSASocketA(0, 0, 0, &pi[0], 0, 0);
3221 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3222 WSAGetLastError());
3223
3224 size = sizeof(socktype);
3225 socktype = 0xdead;
3226 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3227 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
3228 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
3229 SOCK_DGRAM, socktype);
3230
3231 socktype = SOCK_STREAM;
3232 WSASetLastError(0xdeadbeef);
3233 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
3234 ok(err == -1, "expected failure\n");
3235 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
3236
3237 socktype = SOCK_DGRAM;
3238 WSASetLastError(0xdeadbeef);
3239 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
3240 ok(err == -1, "expected failure\n");
3241 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
3242
3243 closesocket(sock);
3244
3245 sock = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, &pi[0], 0, 0);
3246 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3247 WSAGetLastError());
3248
3249 size = sizeof(socktype);
3250 socktype = 0xdead;
3251 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3252 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
3253 ok(socktype == SOCK_STREAM, "Wrong socket type, expected %d received %d\n",
3254 SOCK_STREAM, socktype);
3255
3256 socktype = SOCK_STREAM;
3257 WSASetLastError(0xdeadbeef);
3258 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
3259 ok(err == -1, "expected failure\n");
3260 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
3261
3262 socktype = SOCK_DGRAM;
3263 WSASetLastError(0xdeadbeef);
3264 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
3265 ok(err == -1, "expected failure\n");
3266 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
3267
3268 closesocket(sock);
3269
3270 free(pi);
3271
3272 pi_size = 0;
3273 items = WSAEnumProtocolsA(NULL, NULL, &pi_size);
3274 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
3275 items);
3276 err = WSAGetLastError();
3277 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
3278 err, WSAENOBUFS);
3279
3280 pi = malloc(pi_size);
3281 ok(pi != NULL, "Failed to allocate memory\n");
3282
3283 items = WSAEnumProtocolsA(NULL, pi, &pi_size);
3284 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
3285 WSAGetLastError());
3286
3287 /* when no protocol and socket type are specified the first entry
3288 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
3289 * is returned */
3290 sock = WSASocketA(AF_INET, 0, 0, NULL, 0, 0);
3291 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3292 WSAGetLastError());
3293
3294 size = sizeof(socktype);
3295 socktype = 0xdead;
3296 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3297 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3298 for(i = 0; i < items; i++)
3299 {
3300 if(pi[i].dwProviderFlags & PFL_MATCHES_PROTOCOL_ZERO)
3301 {
3302 ok(socktype == pi[i].iSocketType, "Wrong socket type, expected %d received %d\n",
3303 pi[i].iSocketType, socktype);
3304 break;
3305 }
3306 }
3307 ok(i != items, "Creating a socket without protocol and socket type didn't work\n");
3308 closesocket(sock);
3309
3310 /* when no socket type is specified the first entry from WSAEnumProtocols
3311 * that matches the protocol is returned */
3312 for (i = 0; i < ARRAY_SIZE(autoprotocols); i++)
3313 {
3314 sock = WSASocketA(0, 0, autoprotocols[i], NULL, 0, 0);
3315 ok(sock != INVALID_SOCKET, "Failed to create socket for protocol %d, received %d\n",
3316 autoprotocols[i], WSAGetLastError());
3317
3318 size = sizeof(socktype);
3319 socktype = 0xdead;
3320 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3321 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3322
3323 for (err = 1, j = 0; j < items; j++)
3324 {
3325 if (pi[j].iProtocol == autoprotocols[i])
3326 {
3327 ok(pi[j].iSocketType == socktype, "expected %d, got %d\n", socktype, pi[j].iSocketType);
3328 err = 0;
3329 break;
3330 }
3331 }
3332 ok(!err, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols[i]);
3333
3334 closesocket(sock);
3335 }
3336
3337 free(pi);
3338
3339 SetLastError(0xdeadbeef);
3340 /* starting on vista the socket function returns error during the socket
3341 creation and no longer in the socket operations (sendto, readfrom) */
3342 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
3343 if (sock == INVALID_SOCKET)
3344 {
3345 err = WSAGetLastError();
3346 ok(err == WSAEACCES, "Expected 10013, received %d\n", err);
3347 skip("SOCK_RAW is not supported\n");
3348 }
3349 else
3350 {
3351 WSAPROTOCOL_INFOW info;
3352
3353 size = sizeof(socktype);
3354 socktype = 0xdead;
3355 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3356 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3357 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
3358 SOCK_RAW, socktype);
3359
3360 size = sizeof(info);
3361 err = getsockopt(sock, SOL_SOCKET, SO_PROTOCOL_INFOW, (char *) &info, &size);
3362 ok(!err,"got error %d\n", WSAGetLastError());
3363 /* Protocol name in info.szProtocol is not entirely consistent across Windows versions and
3364 * locales, so not testing it. */
3365 ok(info.iAddressFamily == AF_INET, "got iAddressFamily %d.\n", info.iAddressFamily);
3366 ok(info.iSocketType == SOCK_RAW, "got iSocketType %d.\n", info.iSocketType);
3367 ok(info.iMaxSockAddr == 0x10, "got iMaxSockAddr %d.\n", info.iMaxSockAddr);
3368 ok(info.iMinSockAddr == 0x10, "got iMinSockAddr %d.\n", info.iMinSockAddr);
3369 todo_wine ok(!info.iProtocol, "got iProtocol %d.\n", info.iProtocol);
3370 ok(info.iProtocolMaxOffset == 255, "got iProtocol %d.\n", info.iProtocolMaxOffset);
3371 ok(info.dwProviderFlags == (PFL_MATCHES_PROTOCOL_ZERO | PFL_HIDDEN), "got dwProviderFlags %#lx.\n",
3372 info.dwProviderFlags);
3373 ok(info.dwServiceFlags1 == (XP1_IFS_HANDLES | XP1_SUPPORT_BROADCAST | XP1_SUPPORT_MULTIPOINT
3374 | XP1_MESSAGE_ORIENTED | XP1_CONNECTIONLESS), "got dwServiceFlags1 %#lx.\n",
3375 info.dwServiceFlags1);
3376
3377 closesocket(sock);
3378
3379 sock = WSASocketA(0, 0, IPPROTO_RAW, NULL, 0, 0);
3380 if (sock != INVALID_SOCKET)
3381 {
3382 size = sizeof(socktype);
3383 socktype = 0xdead;
3384 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3385 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3386 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
3387 SOCK_RAW, socktype);
3388 closesocket(sock);
3389
3390 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_TCP, NULL, 0, 0);
3391 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3392 WSAGetLastError());
3393 size = sizeof(socktype);
3394 socktype = 0xdead;
3395 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3396 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3397 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
3398 SOCK_RAW, socktype);
3399 closesocket(sock);
3400 }
3401 else if (WSAGetLastError() == WSAEACCES)
3402 skip("SOCK_RAW is not available\n");
3403 else
3404 ok(0, "Failed to create socket: %d\n", WSAGetLastError());
3405
3406 }
3407
3408 /* IPX socket tests */
3409
3410 SetLastError(0xdeadbeef);
3411 sock = WSASocketA(AF_IPX, SOCK_DGRAM, NSPROTO_IPX, NULL, 0, 0);
3412 if (sock == INVALID_SOCKET)
3413 {
3414 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError());
3415 skip("IPX is not supported\n");
3416 }
3417 else
3418 {
3419 WSAPROTOCOL_INFOA info;
3420 closesocket(sock);
3421
3422 sock = WSASocketA(0, 0, NSPROTO_IPX, NULL, 0, 0);
3423 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3424 WSAGetLastError());
3425
3426 size = sizeof(socktype);
3427 socktype = 0xdead;
3428 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3429 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
3430 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
3431 SOCK_DGRAM, socktype);
3432
3433 /* check socket family, type and protocol */
3434 size = sizeof(WSAPROTOCOL_INFOA);
3435 err = getsockopt(sock, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &info, &size);
3436 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
3437 ok(info.iProtocol == NSPROTO_IPX, "expected protocol %d, received %d\n",
3438 NSPROTO_IPX, info.iProtocol);
3439 ok(info.iAddressFamily == AF_IPX, "expected family %d, received %d\n",
3440 AF_IPX, info.iProtocol);
3441 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
3442 SOCK_DGRAM, info.iSocketType);
3443 closesocket(sock);
3444
3445 /* SOCK_STREAM does not support NSPROTO_IPX */
3446 SetLastError(0xdeadbeef);
3447 ok(WSASocketA(AF_IPX, SOCK_STREAM, NSPROTO_IPX, NULL, 0, 0) == INVALID_SOCKET,
3448 "WSASocketA should have failed\n");
3449 err = WSAGetLastError();
3450 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
3451
3452 /* test extended IPX support - that is adding any number between 0 and 255
3453 * to the IPX protocol value will make it be used as IPX packet type */
3454 for(i = 0;i <= 255;i += 17)
3455 {
3456 SetLastError(0xdeadbeef);
3457 sock = WSASocketA(0, 0, NSPROTO_IPX + i, NULL, 0, 0);
3458 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3459 WSAGetLastError());
3460
3461 size = sizeof(int);
3462 socktype = -1;
3463 err = getsockopt(sock, NSPROTO_IPX, IPX_PTYPE, (char *) &socktype, &size);
3464 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3465 ok(socktype == i, "Wrong IPX packet type, expected %d received %d\n",
3466 i, socktype);
3467
3468 closesocket(sock);
3469 }
3470 }
3471 }
3472
3473 static void test_WSADuplicateSocket(void)
3474 {
3475 SOCKET source, dupsock;
3476 WSAPROTOCOL_INFOA info;
3477 DWORD err;
3478 struct sockaddr_in addr;
3479 int socktype, size, addrsize, ret;
3480 char teststr[] = "TEST", buffer[16];
3481
3482 source = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
3483 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3484
3485 /* test invalid parameters */
3486 SetLastError(0xdeadbeef);
3487 ok(WSADuplicateSocketA(0, 0, NULL), "WSADuplicateSocketA should have failed\n");
3488 err = WSAGetLastError();
3489 ok(err == WSAENOTSOCK, "expected 10038, received %ld\n", err);
3490
3491 SetLastError(0xdeadbeef);
3492 ok(WSADuplicateSocketA(source, 0, NULL),
3493 "WSADuplicateSocketA should have failed\n");
3494 err = WSAGetLastError();
3495 ok(err == WSAEINVAL, "expected 10022, received %ld\n", err);
3496
3497 SetLastError(0xdeadbeef);
3498 ok(WSADuplicateSocketA(source, ~0, &info),
3499 "WSADuplicateSocketA should have failed\n");
3500 err = WSAGetLastError();
3501 ok(err == WSAEINVAL, "expected 10022, received %ld\n", err);
3502
3503 SetLastError(0xdeadbeef);
3504 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info),
3505 "WSADuplicateSocketA should have failed\n");
3506 err = WSAGetLastError();
3507 ok(err == WSAENOTSOCK, "expected 10038, received %ld\n", err);
3508
3509 SetLastError(0xdeadbeef);
3510 ok(WSADuplicateSocketA(source, GetCurrentProcessId(), NULL),
3511 "WSADuplicateSocketA should have failed\n");
3512 err = WSAGetLastError();
3513 ok(err == WSAEFAULT, "expected 10014, received %ld\n", err);
3514
3515 /* test returned structure */
3516 memset(&info, 0, sizeof(info));
3517 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
3518 "WSADuplicateSocketA should have worked\n");
3519
3520 ok(info.iProtocol == IPPROTO_TCP, "expected protocol %d, received %d\n",
3521 IPPROTO_TCP, info.iProtocol);
3522 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
3523 AF_INET, info.iProtocol);
3524 ok(info.iSocketType == SOCK_STREAM, "expected type %d, received %d\n",
3525 SOCK_STREAM, info.iSocketType);
3526
3527 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
3528 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3529
3530 closesocket(dupsock);
3531 closesocket(source);
3532
3533 /* create a socket, bind it, duplicate it then send data on source and
3534 * receive in the duplicated socket */
3535 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
3536 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3537
3538 memset(&info, 0, sizeof(info));
3539 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
3540 "WSADuplicateSocketA should have worked\n");
3541
3542 ok(info.iProtocol == IPPROTO_UDP, "expected protocol %d, received %d\n",
3543 IPPROTO_UDP, info.iProtocol);
3544 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
3545 AF_INET, info.iProtocol);
3546 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
3547 SOCK_DGRAM, info.iSocketType);
3548
3549 memset(&addr, 0, sizeof(addr));
3550 addr.sin_family = AF_INET;
3551 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
3552 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
3553 "bind should have worked\n");
3554
3555 /* read address to find out the port number to be used in sendto */
3556 memset(&addr, 0, sizeof(addr));
3557 addrsize = sizeof(addr);
3558 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
3559 "getsockname should have worked\n");
3560 ok(addr.sin_port, "socket port should be != 0\n");
3561
3562 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
3563 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3564
3565 size = sizeof(int);
3566 ret = getsockopt(dupsock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3567 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
3568 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
3569 SOCK_DGRAM, socktype);
3570
3571 set_blocking(source, TRUE);
3572
3573 /* send data on source socket */
3574 addrsize = sizeof(addr);
3575 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
3576 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
3577
3578 /* receive on duplicated socket */
3579 addrsize = sizeof(addr);
3580 memset(buffer, 0, sizeof(buffer));
3581 size = recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize);
3582 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
3583 buffer[sizeof(teststr) - 1] = 0;
3584 ok(!strcmp(buffer, teststr), "expected '%s', received '%s'\n", teststr, buffer);
3585
3586 closesocket(dupsock);
3587 closesocket(source);
3588
3589 /* show that the source socket need to be bound before the duplicated
3590 * socket is created */
3591 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
3592 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3593
3594 memset(&info, 0, sizeof(info));
3595 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
3596 "WSADuplicateSocketA should have worked\n");
3597
3598 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
3599 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3600
3601 memset(&addr, 0, sizeof(addr));
3602 addr.sin_family = AF_INET;
3603 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
3604 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
3605 "bind should have worked\n");
3606
3607 /* read address to find out the port number to be used in sendto */
3608 memset(&addr, 0, sizeof(addr));
3609 addrsize = sizeof(addr);
3610 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
3611 "getsockname should have worked\n");
3612 ok(addr.sin_port, "socket port should be != 0\n");
3613
3614 set_blocking(source, TRUE);
3615
3616 addrsize = sizeof(addr);
3617 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
3618 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
3619
3620 SetLastError(0xdeadbeef);
3621 addrsize = sizeof(addr);
3622 memset(buffer, 0, sizeof(buffer));
3623 todo_wine {
3624 ok(recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize) == -1,
3625 "recvfrom should have failed\n");
3626 err = WSAGetLastError();
3627 ok(err == WSAEINVAL, "expected 10022, received %ld\n", err);
3628 }
3629
3630 closesocket(dupsock);
3631 closesocket(source);
3632 }
3633
3634 static void test_WSAConnectByName(void)
3635 {
3636 SOCKET s;
3637 SOCKADDR_IN local_addr = {0}, remote_addr = {0},
3638 sock_addr = {0}, peer_addr = {0};
3639 DWORD local_len, remote_len, conn_ctx;
3640 int ret, err, sock_len, peer_len;
3641 WSAOVERLAPPED overlap;
3642 struct addrinfo *first_addrinfo, first_hints;
3643
3644 conn_ctx = TRUE;
3645
3646 /* First call of getaddrinfo fails on w8adm */
3647 first_addrinfo = NULL;
3648 memset(&first_hints, 0, sizeof(struct addrinfo));
3649 first_hints.ai_socktype = SOCK_STREAM;
3650 first_hints.ai_family = AF_INET;
3651 first_hints.ai_protocol = IPPROTO_TCP;
3652 getaddrinfo("winehq.org", "http", &first_hints, &first_addrinfo);
3653 if (first_addrinfo)
3654 freeaddrinfo(first_addrinfo);
3655 SetLastError(0xdeadbeef);
3656
3657 /* Fill all fields */
3658 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3659 local_len = remote_len = sizeof(SOCKADDR_IN);
3660 ret = WSAConnectByNameA(s, "winehq.org", "http", &local_len, (struct sockaddr *)&local_addr,
3661 &remote_len, (struct sockaddr *)&remote_addr, NULL, NULL);
3662 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3663 setsockopt(s, SOL_SOCKET, SO_UPDATE_CONNECT_CONTEXT, (char *)&conn_ctx, sizeof(DWORD));
3664 sock_len = peer_len = sizeof(SOCKADDR_IN);
3665 ret = getsockname(s, (struct sockaddr *)&sock_addr, &sock_len);
3666 ok(!ret, "getsockname should have succeeded, error %u\n", WSAGetLastError());
3667 ret = getpeername(s, (struct sockaddr *)&peer_addr, &peer_len);
3668 ok(!ret, "getpeername should have succeeded, error %u\n", WSAGetLastError());
3669 ok(sock_len == sizeof(SOCKADDR_IN), "got sockname size of %d\n", sock_len);
3670 ok(peer_len == sizeof(SOCKADDR_IN), "got peername size of %d\n", peer_len);
3671 ok(local_len == sizeof(SOCKADDR_IN), "got local size of %lu\n", local_len);
3672 ok(remote_len == sizeof(SOCKADDR_IN), "got remote size of %lu\n", remote_len);
3673 ok(!local_addr.sin_port, "local_addr has non-zero sin_port: %hu.\n", local_addr.sin_port);
3674 ok(!memcmp(&sock_addr.sin_addr, &local_addr.sin_addr, sizeof(struct in_addr)),
3675 "local_addr did not receive data.\n");
3676 ok(!memcmp(&peer_addr, &remote_addr, sizeof(SOCKADDR_IN)), "remote_addr did not receive data.\n");
3677 closesocket(s);
3678
3679 /* Passing NULL length but a pointer to a sockaddr */
3680 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3681 local_len = remote_len = sizeof(SOCKADDR_IN);
3682 memset(&local_addr, 0, sizeof(SOCKADDR_IN));
3683 memset(&remote_addr, 0, sizeof(SOCKADDR_IN));
3684 memset(&sock_addr, 0, sizeof(SOCKADDR_IN));
3685 memset(&peer_addr, 0, sizeof(SOCKADDR_IN));
3686 ret = WSAConnectByNameA(s, "winehq.org", "http", NULL, (struct sockaddr *)&local_addr,
3687 NULL, (struct sockaddr *)&remote_addr, NULL, NULL);
3688 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3689 setsockopt(s, SOL_SOCKET, SO_UPDATE_CONNECT_CONTEXT, (char *)&conn_ctx, sizeof(DWORD));
3690 sock_len = peer_len = sizeof(SOCKADDR_IN);
3691 ret = getsockname(s, (struct sockaddr *)&sock_addr, &sock_len);
3692 ok(!ret, "getsockname should have succeeded, error %u\n", WSAGetLastError());
3693 ret = getpeername(s, (struct sockaddr *)&peer_addr, &peer_len);
3694 ok(!ret, "getpeername should have succeeded, error %u\n", WSAGetLastError());
3695 ok(sock_len == sizeof(SOCKADDR_IN), "got sockname size of %d\n", sock_len);
3696 ok(peer_len == sizeof(SOCKADDR_IN), "got peername size of %d\n", peer_len);
3697 ok(!local_addr.sin_family, "local_addr received data.\n");
3698 ok(!remote_addr.sin_family, "remote_addr received data.\n");
3699 closesocket(s);
3700
3701 /* Passing NULLs for node or service */
3702 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3703 ret = WSAConnectByNameA(s, NULL, "http", NULL, NULL, NULL, NULL, NULL, NULL);
3704 err = WSAGetLastError();
3705 ok(!ret, "WSAConnectByNameA should have failed\n");
3706 ok(err == WSAEINVAL, "expected error %u (WSAEINVAL), got %u\n", WSAEINVAL, err);
3707 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3708 closesocket(s);
3709 ret = WSAConnectByNameA(s, "winehq.org", NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3710 err = WSAGetLastError();
3711 ok(!ret, "WSAConnectByNameA should have failed\n");
3712 ok(err == WSAEINVAL, "expected error %u (WSAEINVAL), got %u\n", WSAEINVAL, err);
3713 closesocket(s);
3714
3715 /* Passing NULL for the addresses and address lengths */
3716 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3717 ret = WSAConnectByNameA(s, "winehq.org", "http", NULL, NULL, NULL, NULL, NULL, NULL);
3718 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3719 closesocket(s);
3720
3721 /* Passing NULL for the addresses and passing correct lengths */
3722 local_len = remote_len = sizeof(SOCKADDR_IN);
3723 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3724 ret = WSAConnectByNameA(s, "winehq.org", "http", &local_len, NULL,
3725 &remote_len, NULL, NULL, NULL);
3726 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3727 ok(local_len == sizeof(SOCKADDR_IN), "local_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN),
3728 local_len);
3729 ok(remote_len == sizeof(SOCKADDR_IN), "remote_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN),
3730 remote_len);
3731 closesocket(s);
3732
3733 /* Passing addresses and passing short lengths */
3734 local_len = remote_len = 3;
3735 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3736 ret = WSAConnectByNameA(s, "winehq.org", "http", &local_len, (struct sockaddr *)&local_addr,
3737 &remote_len, (struct sockaddr *)&remote_addr, NULL, NULL);
3738 err = WSAGetLastError();
3739 ok(!ret, "WSAConnectByNameA should have failed\n");
3740 ok(err == WSAEFAULT, "expected error %u (WSAEFAULT), got %u\n", WSAEFAULT, err);
3741 ok(local_len == 3, "local_len should have been 3, got %ld\n", local_len);
3742 ok(remote_len == 3, "remote_len should have been 3, got %ld\n", remote_len);
3743 closesocket(s);
3744
3745 /* Passing addresses and passing long lengths */
3746 local_len = remote_len = 50;
3747 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3748 ret = WSAConnectByNameA(s, "winehq.org", "http", &local_len, (struct sockaddr *)&local_addr,
3749 &remote_len, (struct sockaddr *)&remote_addr, NULL, NULL);
3750 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3751 ok(local_len == sizeof(SOCKADDR_IN), "local_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN),
3752 local_len);
3753 ok(remote_len == sizeof(SOCKADDR_IN), "remote_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN),
3754 remote_len);
3755 closesocket(s);
3756
3757 /* Unknown service */
3758 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3759 ret = WSAConnectByNameA(s, "winehq.org", "nonexistentservice", NULL, NULL, NULL, NULL, NULL, NULL);
3760 err = WSAGetLastError();
3761 ok(!ret, "WSAConnectByNameA should have failed\n");
3762 ok(err == WSATYPE_NOT_FOUND, "expected error %u (WSATYPE_NOT_FOUND), got %u\n",
3763 WSATYPE_NOT_FOUND, err);
3764 closesocket(s);
3765
3766 /* Connecting with a UDP socket */
3767 s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
3768 ret = WSAConnectByNameA(s, "winehq.org", "https", NULL, NULL, NULL, NULL, NULL, NULL);
3769 err = WSAGetLastError();
3770 ok(!ret, "WSAConnectByNameA should have failed\n");
3771 ok(err == WSAEINVAL || err == WSAEFAULT, "expected error %u (WSAEINVAL) or %u (WSAEFAULT), got %u\n",
3772 WSAEINVAL, WSAEFAULT, err); /* WSAEFAULT win10 >= 1809 */
3773 closesocket(s);
3774
3775 /* Passing non-null as the reserved parameter */
3776 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3777 ret = WSAConnectByNameA(s, "winehq.org", "http", NULL, NULL, NULL, NULL, NULL, &overlap);
3778 err = WSAGetLastError();
3779 ok(!ret, "WSAConnectByNameA should have failed\n");
3780 ok(err == WSAEINVAL, "expected error %u (WSAEINVAL), got %u\n", WSAEINVAL, err);
3781 closesocket(s);
3782 }
3783
3784 static void test_WSAEnumNetworkEvents(void)
3785 {
3786 SOCKET s, s2;
3787 int sock_type[] = {SOCK_STREAM, SOCK_DGRAM, SOCK_STREAM}, i, j, k, l;
3788 struct sockaddr_in address;
3789 HANDLE event;
3790 WSANETWORKEVENTS net_events;
3791
3792 memset(&address, 0, sizeof(address));
3793 address.sin_addr.s_addr = htonl(INADDR_ANY);
3794 address.sin_family = AF_INET;
3795
3796 /* This test follows the steps from bugs 10204 and 24946 */
3797 for (l = 0; l < 2; l++)
3798 {
3799 for (i = 0; i < ARRAY_SIZE(sock_type); i++)
3800 {
3801 if (i == 2)
3802 tcp_socketpair(&s, &s2);
3803 else
3804 {
3805 s = socket(AF_INET, sock_type[i], 0);
3806 ok (s != SOCKET_ERROR, "Test[%d]: failed to create socket\n", i);
3807 ok (!bind(s, (struct sockaddr*) &address, sizeof(address)), "Test[%d]: bind failed\n", i);
3808 }
3809 event = WSACreateEvent();
3810 ok (event != NULL, "Test[%d]: failed to create event\n", i);
3811 for (j = 0; j < 5; j++) /* Repeat sometimes and the result must be the same */
3812 {
3813 /* When the TCP socket is not connected NO events will be returned.
3814 * When connected and no data pending it will get the write event.
3815 * UDP sockets don't have connections so as soon as they are bound
3816 * they can read/write data. Since nobody is sendind us data only
3817 * the write event will be returned and ONLY once.
3818 */
3819 ok (!WSAEventSelect(s, event, FD_READ | FD_WRITE), "Test[%d]: WSAEventSelect failed\n", i);
3820 memset(&net_events, 0xAB, sizeof(net_events));
3821 ok (!WSAEnumNetworkEvents(s, l == 0 ? event : NULL, &net_events),
3822 "Test[%d]: WSAEnumNetworkEvents failed\n", i);
3823 if (i >= 1 && j == 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
3824 {
3825 ok (net_events.lNetworkEvents == FD_WRITE, "Test[%d]: expected 2, got %ld\n",
3826 i, net_events.lNetworkEvents);
3827 }
3828 else
3829 {
3830 ok (net_events.lNetworkEvents == 0, "Test[%d]: expected 0, got %ld\n",
3831 i, net_events.lNetworkEvents);
3832 }
3833 for (k = 0; k < FD_MAX_EVENTS; k++)
3834 {
3835 if (net_events.lNetworkEvents & (1 << k))
3836 {
3837 ok (net_events.iErrorCode[k] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
3838 i, k, net_events.iErrorCode[k]);
3839 }
3840 else
3841 {
3842 /* Bits that are not set in lNetworkEvents MUST not be changed */
3843 ok (net_events.iErrorCode[k] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
3844 i, k, net_events.iErrorCode[k]);
3845 }
3846 }
3847 }
3848 closesocket(s);
3849 WSACloseEvent(event);
3850 if (i == 2) closesocket(s2);
3851 }
3852 }
3853 }
3854
3855 static DWORD WINAPI SelectReadThread(void *param)
3856 {
3857 select_thread_params *par = param;
3858 fd_set readfds;
3859 int ret;
3860 struct sockaddr_in addr;
3861 struct timeval select_timeout;
3862
3863 FD_ZERO(&readfds);
3864 FD_SET(par->s, &readfds);
3865 select_timeout.tv_sec=5;
3866 select_timeout.tv_usec=0;
3867 addr.sin_family = AF_INET;
3868 addr.sin_addr.s_addr = inet_addr(SERVERIP);
3869 addr.sin_port = htons(SERVERPORT);
3870
3871 do_bind(par->s, (struct sockaddr *)&addr, sizeof(addr));
3872 wsa_ok(listen(par->s, SOMAXCONN ), 0 ==, "SelectReadThread (%lx): listen failed: %d\n");
3873
3874 SetEvent(server_ready);
3875 ret = select(par->s+1, &readfds, NULL, NULL, &select_timeout);
3876 par->ReadKilled = (ret == 1);
3877
3878 return 0;
3879 }
3880
3881 static DWORD WINAPI SelectCloseThread(void *param)
3882 {
3883 SOCKET s = *(SOCKET*)param;
3884 Sleep(500);
3885 closesocket(s);
3886 return 0;
3887 }
3888
3889 static void test_errors(void)
3890 {
3891 SOCKET sock;
3892 SOCKADDR_IN SockAddr;
3893 int ret, err;
3894
3895 WSASetLastError(NO_ERROR);
3896 sock = socket(PF_INET, SOCK_STREAM, 0);
3897 ok( (sock != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3898 memset(&SockAddr, 0, sizeof(SockAddr));
3899 SockAddr.sin_family = AF_INET;
3900 SockAddr.sin_port = htons(6924);
3901 SockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
3902
3903 ret = connect(sock, (PSOCKADDR)&SockAddr, sizeof(SockAddr));
3904 ok( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got: %d\n", ret );
3905 if (ret == SOCKET_ERROR)
3906 {
3907 err = WSAGetLastError();
3908 ok( (err == WSAECONNREFUSED), "expected WSAECONNREFUSED, got: %d\n", err );
3909 }
3910
3911 {
3912 TIMEVAL timeval;
3913 fd_set set = {1, {sock}};
3914
3915 timeval.tv_sec = 0;
3916 timeval.tv_usec = 50000;
3917
3918 ret = select(1, NULL, &set, NULL, &timeval);
3919 ok( (ret == 0), "expected 0 (timeout), got: %d\n", ret );
3920 }
3921
3922 ret = closesocket(sock);
3923 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
3924 }
3925
3926 static void test_listen(void)
3927 {
3928 SOCKET fdA, fdB;
3929 int ret, acceptc, olen = sizeof(acceptc);
3930 struct sockaddr_in address;
3931
3932 memset(&address, 0, sizeof(address));
3933 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3934 address.sin_family = AF_INET;
3935 address.sin_port = htons(SERVERPORT);
3936
3937 /* invalid socket tests */
3938 SetLastError(0xdeadbeef);
3939 ok ((listen(0, 0) == SOCKET_ERROR), "listen did not fail\n");
3940 ret = WSAGetLastError();
3941 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
3942
3943 SetLastError(0xdeadbeef);
3944 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR), "listen did not fail\n");
3945 ret = WSAGetLastError();
3946 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
3947
3948 /* tcp tests */
3949 fdA = socket(AF_INET, SOCK_STREAM, 0);
3950 ok ((fdA != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3951
3952 fdB = socket(AF_INET, SOCK_STREAM, 0);
3953 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3954
3955 SetLastError(0xdeadbeef);
3956 ok ((listen(fdA, -2) == SOCKET_ERROR), "listen did not fail\n");
3957 ret = WSAGetLastError();
3958 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3959
3960 SetLastError(0xdeadbeef);
3961 ok ((listen(fdA, 1) == SOCKET_ERROR), "listen did not fail\n");
3962 ret = WSAGetLastError();
3963 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3964
3965 SetLastError(0xdeadbeef);
3966 ok ((listen(fdA, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3967 ret = WSAGetLastError();
3968 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3969
3970 ok (!bind(fdA, (struct sockaddr*) &address, sizeof(address)), "bind failed\n");
3971
3972 SetLastError(0xdeadbeef);
3973 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3974 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3975
3976 acceptc = 0xdead;
3977 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3978 ok (!ret, "getsockopt failed\n");
3979 ok (acceptc == 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc);
3980
3981 acceptc = 1;
3982 WSASetLastError(0xdeadbeef);
3983 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
3984 ok(ret == -1, "expected failure\n");
3985 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
3986
3987 acceptc = 0;
3988 WSASetLastError(0xdeadbeef);
3989 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
3990 ok(ret == -1, "expected failure\n");
3991 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
3992
3993 ok (!listen(fdA, 0), "listen failed\n");
3994 ok (!listen(fdA, SOMAXCONN), "double listen failed\n");
3995
3996 acceptc = 0xdead;
3997 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3998 ok (!ret, "getsockopt failed\n");
3999 ok (acceptc == 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc);
4000
4001 acceptc = 1;
4002 WSASetLastError(0xdeadbeef);
4003 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
4004 ok(ret == -1, "expected failure\n");
4005 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
4006
4007 acceptc = 0;
4008 WSASetLastError(0xdeadbeef);
4009 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
4010 ok(ret == -1, "expected failure\n");
4011 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
4012
4013 SetLastError(0xdeadbeef);
4014 ok ((listen(fdB, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
4015 ret = WSAGetLastError();
4016 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
4017
4018 ret = closesocket(fdB);
4019 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
4020
4021 fdB = socket(AF_INET, SOCK_STREAM, 0);
4022 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4023
4024 SetLastError(0xdeadbeef);
4025 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
4026 ret = WSAGetLastError();
4027 ok (ret == WSAEADDRINUSE, "expected 10048, received %d\n", ret);
4028
4029 ret = closesocket(fdA);
4030 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
4031 ret = closesocket(fdB);
4032 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
4033 }
4034
4035 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
4036 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
4037 static void test_select(void)
4038 {
4039 static char tmp_buf[1024];
4040
4041 fd_set readfds, writefds, exceptfds, *alloc_fds;
4042 SOCKET fdListen, fdRead, fdWrite, sockets[200];
4043 int ret, len;
4044 char buffer;
4045 struct timeval select_timeout;
4046 struct sockaddr_in address;
4047 select_thread_params thread_params;
4048 HANDLE thread_handle;
4049 DWORD ticks, id, old_protect;
4050 unsigned int apc_count;
4051 unsigned int maxfd, i;
4052 char *page_pair;
4053
4054 fdRead = socket(AF_INET, SOCK_STREAM, 0);
4055 ok( (fdRead != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4056 fdWrite = socket(AF_INET, SOCK_STREAM, 0);
4057 ok( (fdWrite != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4058
4059 maxfd = fdRead;
4060 if (fdWrite > maxfd)
4061 maxfd = fdWrite;
4062
4063 FD_ZERO_ALL();
4064 FD_SET_ALL(fdRead);
4065 FD_SET_ALL(fdWrite);
4066 select_timeout.tv_sec=0;
4067 select_timeout.tv_usec=0;
4068
4069 ticks = GetTickCount();
4070 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4071 ticks = GetTickCount() - ticks;
4072 ok(ret == 0, "select should not return any socket handles\n");
4073 ok(ticks < 100, "select was blocking for %lu ms\n", ticks);
4074 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
4075 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
4076 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
4077 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
4078
4079 FD_ZERO_ALL();
4080 FD_SET_ALL(fdRead);
4081 FD_SET_ALL(fdWrite);
4082 select_timeout.tv_sec=0;
4083 select_timeout.tv_usec=500;
4084
4085 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4086 ok(ret == 0, "select should not return any socket handles\n");
4087 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
4088 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
4089 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
4090 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
4091
4092 ok ((listen(fdWrite, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
4093 ret = closesocket(fdWrite);
4094 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
4095
4096 thread_params.s = fdRead;
4097 thread_params.ReadKilled = FALSE;
4098 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
4099 thread_handle = CreateThread (NULL, 0, SelectReadThread, &thread_params, 0, &id );
4100 ok ( (thread_handle != NULL), "CreateThread failed unexpectedly: %ld\n", GetLastError());
4101
4102 WaitForSingleObject (server_ready, INFINITE);
4103 Sleep(200);
4104 ret = closesocket(fdRead);
4105 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
4106
4107 WaitForSingleObject (thread_handle, 1000);
4108 ok ( thread_params.ReadKilled, "closesocket did not wake up select\n");
4109 ret = recv(fdRead, &buffer, 1, MSG_PEEK);
4110 ok( (ret == -1), "peek at closed socket expected -1 got %d\n", ret);
4111
4112 /* Test selecting invalid handles */
4113 FD_ZERO_ALL();
4114
4115 SetLastError(0);
4116 ret = select(maxfd+1, 0, 0, 0, &select_timeout);
4117 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4118 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
4119
4120 SetLastError(0);
4121 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4122 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4123 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
4124
4125 FD_SET(INVALID_SOCKET, &readfds);
4126 SetLastError(0);
4127 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4128 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4129 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
4130 ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
4131
4132 FD_ZERO(&readfds);
4133 FD_SET(INVALID_SOCKET, &writefds);
4134 SetLastError(0);
4135 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4136 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4137 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
4138 ok ( !FD_ISSET(fdRead, &writefds), "FD should not be set\n");
4139
4140 FD_ZERO(&writefds);
4141 FD_SET(INVALID_SOCKET, &exceptfds);
4142 SetLastError(0);
4143 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4144 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4145 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
4146 ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
4147
4148 tcp_socketpair(&fdRead, &fdWrite);
4149 maxfd = fdRead;
4150 if(fdWrite > maxfd) maxfd = fdWrite;
4151
4152 FD_ZERO(&readfds);
4153 FD_SET(fdRead, &readfds);
4154 apc_count = 0;
4155 ret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
4156 ok(ret, "QueueUserAPC returned %d\n", ret);
4157 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
4158 ok(!ret, "select returned %d\n", ret);
4159 ok(apc_count == 1, "got apc_count %d.\n", apc_count);
4160
4161 FD_ZERO(&writefds);
4162 FD_SET(fdWrite, &writefds);
4163 apc_count = 0;
4164 ret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
4165 ok(ret, "QueueUserAPC returned %d\n", ret);
4166 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
4167 ok(ret == 1, "select returned %d\n", ret);
4168 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4169 ok(!apc_count, "APC was called\n");
4170 SleepEx(0, TRUE);
4171 ok(apc_count == 1, "got apc_count %d.\n", apc_count);
4172
4173 /* select the same socket twice */
4174 writefds.fd_count = 2;
4175 writefds.fd_array[0] = fdWrite;
4176 writefds.fd_array[1] = fdWrite;
4177 ret = select(0, NULL, &writefds, NULL, &select_timeout);
4178 ok(ret == 1, "select returned %d\n", ret);
4179 ok(writefds.fd_count == 1, "got count %u\n", writefds.fd_count);
4180 ok(writefds.fd_array[0] == fdWrite, "got fd %#Ix\n", writefds.fd_array[0]);
4181 ok(writefds.fd_array[1] == fdWrite, "got fd %#Ix\n", writefds.fd_array[1]);
4182
4183 /* tests for overlapping fd_set pointers */
4184 FD_ZERO(&readfds);
4185 FD_SET(fdWrite, &readfds);
4186 ret = select(fdWrite+1, &readfds, &readfds, NULL, &select_timeout);
4187 ok(ret == 1, "select returned %d\n", ret);
4188 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4189
4190 FD_ZERO(&readfds);
4191 FD_SET(fdWrite, &readfds);
4192 FD_SET(fdRead, &readfds);
4193 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
4194 ok(ret == 2, "select returned %d\n", ret);
4195 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4196 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4197
4198 ok(send(fdWrite, "test", 4, 0) == 4, "failed to send data\n");
4199 FD_ZERO(&readfds);
4200 FD_SET(fdRead, &readfds);
4201 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
4202 ok(ret == 1, "select returned %d\n", ret);
4203 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4204
4205 FD_ZERO(&readfds);
4206 FD_SET(fdWrite, &readfds);
4207 FD_SET(fdRead, &readfds);
4208 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
4209 ok(ret == 2, "select returned %d\n", ret);
4210 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4211 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4212
4213 while(1) {
4214 FD_ZERO(&writefds);
4215 FD_SET(fdWrite, &writefds);
4216 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
4217 if(!ret) break;
4218 ok(send(fdWrite, tmp_buf, sizeof(tmp_buf), 0) > 0, "failed to send data\n");
4219 }
4220 FD_ZERO(&readfds);
4221 FD_SET(fdWrite, &readfds);
4222 FD_SET(fdRead, &readfds);
4223 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
4224 ok(ret == 1, "select returned %d\n", ret);
4225 ok(!FD_ISSET(fdWrite, &readfds), "fdWrite socket is in the set\n");
4226 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4227
4228 ok(send(fdRead, "test", 4, 0) == 4, "failed to send data\n");
4229 Sleep(100);
4230 FD_ZERO(&readfds);
4231 FD_SET(fdWrite, &readfds);
4232 FD_SET(fdRead, &readfds);
4233 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
4234 ok(ret == 2, "select returned %d\n", ret);
4235 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4236 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4237
4238 page_pair = VirtualAlloc(NULL, 0x1000 * 2, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
4239 VirtualProtect(page_pair + 0x1000, 0x1000, PAGE_NOACCESS, &old_protect);
4240 alloc_fds = (fd_set *)((page_pair + 0x1000) - offsetof(fd_set, fd_array[1]));
4241 alloc_fds->fd_count = 1;
4242 alloc_fds->fd_array[0] = fdRead;
4243 ret = select(fdRead+1, alloc_fds, NULL, NULL, &select_timeout);
4244 ok(ret == 1, "select returned %d\n", ret);
4245 VirtualFree(page_pair, 0, MEM_RELEASE);
4246
4247 closesocket(fdRead);
4248 closesocket(fdWrite);
4249
4250 alloc_fds = malloc(offsetof(fd_set, fd_array[ARRAY_SIZE(sockets)]));
4251 alloc_fds->fd_count = ARRAY_SIZE(sockets);
4252 for (i = 0; i < ARRAY_SIZE(sockets); i += 2)
4253 {
4254 tcp_socketpair(&sockets[i], &sockets[i + 1]);
4255 alloc_fds->fd_array[i] = sockets[i];
4256 alloc_fds->fd_array[i + 1] = sockets[i + 1];
4257 }
4258 ret = select(0, NULL, alloc_fds, NULL, &select_timeout);
4259 ok(ret == ARRAY_SIZE(sockets), "got %d\n", ret);
4260 for (i = 0; i < ARRAY_SIZE(sockets); ++i)
4261 {
4262 ok(alloc_fds->fd_array[i] == sockets[i], "got socket %#Ix at index %u\n", alloc_fds->fd_array[i], i);
4263 closesocket(sockets[i]);
4264 }
4265 free(alloc_fds);
4266
4267 /* select() works in 3 distinct states:
4268 * - to check if a connection attempt ended with success or error;
4269 * - to check if a pending connection is waiting for acceptance;
4270 * - to check for data to read, availability for write and OOB data
4271 *
4272 * The tests below ensure that all conditions are tested.
4273 */
4274 memset(&address, 0, sizeof(address));
4275 address.sin_addr.s_addr = inet_addr("127.0.0.1");
4276 address.sin_family = AF_INET;
4277 len = sizeof(address);
4278 fdListen = setup_server_socket(&address, &len);
4279 select_timeout.tv_sec = 1;
4280 select_timeout.tv_usec = 250000;
4281
4282 /* When no events are pending select returns 0 with no error */
4283 FD_ZERO_ALL();
4284 FD_SET_ALL(fdListen);
4285 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4286 ok(ret == 0, "expected 0, got %d\n", ret);
4287
4288 /* When a socket is attempting to connect the listening socket receives the read descriptor */
4289 fdWrite = setup_connector_socket(&address, len, TRUE);
4290 FD_ZERO_ALL();
4291 FD_SET_ALL(fdListen);
4292 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4293 ok(ret == 1, "expected 1, got %d\n", ret);
4294 ok(FD_ISSET(fdListen, &readfds), "fdListen socket is not in the set\n");
4295 len = sizeof(address);
4296 fdRead = accept(fdListen, (struct sockaddr*) &address, &len);
4297 ok(fdRead != INVALID_SOCKET, "expected a valid socket\n");
4298
4299 /* The connector is signaled through the write descriptor */
4300 FD_ZERO_ALL();
4301 FD_SET_ALL(fdListen);
4302 FD_SET_ALL(fdRead);
4303 FD_SET_ALL(fdWrite);
4304 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4305 ok(ret == 2, "expected 2, got %d\n", ret);
4306 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4307 ok(FD_ISSET(fdRead, &writefds), "fdRead socket is not in the set\n");
4308 len = sizeof(id);
4309 id = 0xdeadbeef;
4310 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
4311 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4312 ok(id == 0, "expected 0, got %ld\n", id);
4313
4314 /* When data is received the receiver gets the read descriptor */
4315 ret = send(fdWrite, "1234", 4, 0);
4316 ok(ret == 4, "expected 4, got %d\n", ret);
4317 FD_ZERO_ALL();
4318 FD_SET_ALL(fdListen);
4319 FD_SET(fdRead, &readfds);
4320 FD_SET(fdRead, &exceptfds);
4321 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4322 ok(ret == 1, "expected 1, got %d\n", ret);
4323 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4324 ok(!FD_ISSET(fdRead, &exceptfds), "fdRead socket is in the set\n");
4325 FD_ZERO_ALL();
4326 FD_SET_ALL(fdRead);
4327 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4328 ok(ret == 2, "expected 1, got %d\n", ret);
4329 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4330 ok(FD_ISSET(fdRead, &writefds), "fdRead socket is not in the set\n");
4331 ok(!FD_ISSET(fdRead, &exceptfds), "fdRead socket is in the set\n");
4332 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
4333 ok(ret == 4, "expected 4, got %d\n", ret);
4334 ok(!strcmp(tmp_buf, "1234"), "data received differs from sent\n");
4335
4336 /* When OOB data is received the socket is set in the except descriptor */
4337 ret = send(fdWrite, "A", 1, MSG_OOB);
4338 ok(ret == 1, "expected 1, got %d\n", ret);
4339 FD_ZERO_ALL();
4340 FD_SET_ALL(fdListen);
4341 FD_SET(fdRead, &readfds);
4342 FD_SET(fdRead, &exceptfds);
4343 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4344 ok(ret == 1, "expected 1, got %d\n", ret);
4345 ok(FD_ISSET(fdRead, &exceptfds), "fdRead socket is not in the set\n");
4346 tmp_buf[0] = 0xAF;
4347 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
4348 ok(ret == 1, "expected 1, got %d\n", ret);
4349 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
4350
4351 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
4352 ret = 1;
4353 ret = setsockopt(fdRead, SOL_SOCKET, SO_OOBINLINE, (char*) &ret, sizeof(ret));
4354 ok(ret == 0, "expected 0, got %d\n", ret);
4355 ret = send(fdWrite, "A", 1, MSG_OOB);
4356 ok(ret == 1, "expected 1, got %d\n", ret);
4357 FD_ZERO_ALL();
4358 FD_SET_ALL(fdListen);
4359 FD_SET(fdRead, &readfds);
4360 FD_SET(fdRead, &exceptfds);
4361 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4362 ok(ret == 1, "expected 1, got %d\n", ret);
4363 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4364 tmp_buf[0] = 0xAF;
4365 SetLastError(0xdeadbeef);
4366 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
4367 ok(ret == SOCKET_ERROR, "expected SOCKET_ERROR, got %d\n", ret);
4368 ok(GetLastError() == WSAEINVAL, "expected 10022, got %ld\n", GetLastError());
4369 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
4370 ok(ret == 1, "expected 1, got %d\n", ret);
4371 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
4372
4373 /* When the connection is closed the socket is set in the read descriptor */
4374 ret = closesocket(fdRead);
4375 ok(ret == 0, "expected 0, got %d\n", ret);
4376 FD_ZERO_ALL();
4377 FD_SET_ALL(fdListen);
4378 FD_SET(fdWrite, &readfds);
4379 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4380 ok(ret == 1, "expected 1, got %d\n", ret);
4381 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4382 ret = recv(fdWrite, tmp_buf, sizeof(tmp_buf), 0);
4383 ok(ret == 0, "expected 0, got %d\n", ret);
4384 ret = closesocket(fdWrite);
4385 ok(ret == 0, "expected 0, got %d\n", ret);
4386
4387 /* w10pro64 sometimes takes over 2 seconds for an error to be reported. */
4388 if (winetest_interactive)
4389 {
4390 const struct sockaddr_in invalid_addr =
4391 {
4392 .sin_family = AF_INET,
4393 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
4394 .sin_port = 255,
4395 };
4396 SOCKET client2, server2;
4397
4398 fdWrite = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4399 set_blocking(fdWrite, FALSE);
4400
4401 ret = connect(fdWrite, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
4402 ok(ret == -1, "got %d\n", ret);
4403 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4404
4405 FD_ZERO_ALL();
4406 FD_SET(fdWrite, &readfds);
4407 FD_SET(fdWrite, &writefds);
4408 FD_SET(fdWrite, &exceptfds);
4409 select_timeout.tv_sec = 10;
4410 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4411 ok(ret == 1, "expected 1, got %d\n", ret);
4412 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4413 ok(select_timeout.tv_usec == 250000, "select timeout should not have changed\n");
4414
4415 len = sizeof(id);
4416 id = 0xdeadbeef;
4417 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4418 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4419 ok(id == WSAECONNREFUSED, "got error %lu\n", id);
4420
4421 len = sizeof(id);
4422 id = 0xdeadbeef;
4423 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4424 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4425 ok(id == WSAECONNREFUSED, "got error %lu\n", id);
4426
4427 FD_ZERO_ALL();
4428 FD_SET(fdWrite, &readfds);
4429 FD_SET(fdWrite, &writefds);
4430 FD_SET(fdWrite, &exceptfds);
4431 select_timeout.tv_sec = 10;
4432 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4433 ok(ret == 1, "got %d\n", ret);
4434 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4435
4436 /* Calling connect() doesn't reset the socket error, but a successful
4437 * connection does. This is kind of tricky to test, because while
4438 * Windows takes a couple seconds to actually fail the connection,
4439 * Linux will fail the connection almost immediately. */
4440
4441 ret = connect(fdWrite, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
4442 ok(ret == -1, "got %d\n", ret);
4443 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4444
4445 len = sizeof(id);
4446 id = 0xdeadbeef;
4447 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4448 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4449 ok(id == WSAECONNREFUSED, "got error %lu\n", id);
4450
4451 FD_ZERO_ALL();
4452 FD_SET(fdWrite, &readfds);
4453 FD_SET(fdWrite, &writefds);
4454 FD_SET(fdWrite, &exceptfds);
4455 select_timeout.tv_sec = 10;
4456 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4457 ok(ret == 1, "got %d\n", ret);
4458 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4459
4460 len = sizeof(address);
4461 ret = getsockname(fdListen, (struct sockaddr *)&address, &len);
4462 ok(!ret, "got error %u\n", WSAGetLastError());
4463 ret = connect(fdWrite, (const struct sockaddr *)&address, sizeof(address));
4464 ok(ret == -1, "got %d\n", ret);
4465 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4466
4467 FD_ZERO_ALL();
4468 FD_SET(fdWrite, &readfds);
4469 FD_SET(fdWrite, &writefds);
4470 FD_SET(fdWrite, &exceptfds);
4471 select_timeout.tv_sec = 1;
4472 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4473 ok(ret == 1, "expected 1, got %d\n", ret);
4474 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4475
4476 len = sizeof(id);
4477 id = 0xdeadbeef;
4478 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4479 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4480 ok(!id, "got error %lu\n", id);
4481
4482 closesocket(fdWrite);
4483
4484 /* Test listening after a failed connection. */
4485
4486 fdWrite = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4487 set_blocking(fdWrite, FALSE);
4488
4489 address.sin_family = AF_INET;
4490 address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
4491 address.sin_port = 0;
4492 ret = bind(fdWrite, (struct sockaddr *)&address, sizeof(address));
4493 ok(!ret, "got %d\n", ret);
4494
4495 ret = connect(fdWrite, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
4496 ok(ret == -1, "got %d\n", ret);
4497 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4498
4499 FD_ZERO(&exceptfds);
4500 FD_SET(fdWrite, &exceptfds);
4501 select_timeout.tv_sec = 10;
4502 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
4503 ok(ret == 1, "expected 1, got %d\n", ret);
4504
4505 len = sizeof(address);
4506 ret = getsockname(fdWrite, (struct sockaddr *)&address, &len);
4507 ok(!ret, "got error %lu\n", GetLastError());
4508
4509 /* Linux seems to forbid this. We'd need to replace the underlying fd. */
4510 ret = listen(fdWrite, 1);
4511 todo_wine ok(!ret, "got error %lu\n", GetLastError());
4512
4513 if (!ret)
4514 {
4515 client2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4516 ret = connect(client2, (struct sockaddr *)&address, sizeof(address));
4517 ok(!ret, "got error %lu\n", GetLastError());
4518
4519 server2 = accept(fdWrite, NULL, NULL);
4520 ok(server2 != INVALID_SOCKET, "got %d\n", ret);
4521
4522 closesocket(server2);
4523 closesocket(client2);
4524 }
4525
4526 len = sizeof(id);
4527 id = 0xdeadbeef;
4528 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4529 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4530 ok(id == WSAECONNREFUSED, "got error %lu\n", id);
4531
4532 FD_ZERO_ALL();
4533 FD_SET(fdWrite, &readfds);
4534 FD_SET(fdWrite, &writefds);
4535 FD_SET(fdWrite, &exceptfds);
4536 select_timeout.tv_sec = 0;
4537 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4538 ok(ret == 1, "got %d\n", ret);
4539 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4540
4541 closesocket(fdWrite);
4542
4543 /* test polling after a (synchronous) failure */
4544
4545 fdWrite = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4546
4547 ret = connect(fdWrite, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
4548 ok(ret == -1, "got %d\n", ret);
4549 ok(WSAGetLastError() == WSAECONNREFUSED, "got error %u\n", WSAGetLastError());
4550
4551 len = sizeof(id);
4552 id = 0xdeadbeef;
4553 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4554 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4555 todo_wine ok(!id, "got error %lu\n", id);
4556
4557 FD_ZERO_ALL();
4558 FD_SET(fdWrite, &readfds);
4559 FD_SET(fdWrite, &writefds);
4560 FD_SET(fdWrite, &exceptfds);
4561 select_timeout.tv_sec = 0;
4562 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4563 ok(ret == 1, "expected 1, got %d\n", ret);
4564 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
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 todo_wine ok(!id, "got error %lu\n", id);
4571
4572 closesocket(fdWrite);
4573 }
4574
4575 ret = closesocket(fdListen);
4576 ok(ret == 0, "expected 0, got %d\n", ret);
4577
4578 select_timeout.tv_sec = 1;
4579 select_timeout.tv_usec = 250000;
4580
4581 /* Try select() on a closed socket after connection */
4582 tcp_socketpair(&fdRead, &fdWrite);
4583 closesocket(fdRead);
4584 FD_ZERO_ALL();
4585 FD_SET_ALL(fdWrite);
4586 FD_SET_ALL(fdRead);
4587 SetLastError(0xdeadbeef);
4588 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
4589 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4590 ok(GetLastError() == WSAENOTSOCK, "got %ld\n", GetLastError());
4591 /* descriptor sets are unchanged */
4592 ok(readfds.fd_count == 2, "expected 2, got %d\n", readfds.fd_count);
4593 ok(exceptfds.fd_count == 2, "expected 2, got %d\n", exceptfds.fd_count);
4594 closesocket(fdWrite);
4595
4596 /* Close the socket currently being selected in a thread - bug 38399 */
4597 tcp_socketpair(&fdRead, &fdWrite);
4598 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
4599 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %ld\n", GetLastError());
4600 FD_ZERO_ALL();
4601 FD_SET_ALL(fdWrite);
4602 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
4603 ok(ret == 1, "expected 1, got %d\n", ret);
4604 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4605 WaitForSingleObject (thread_handle, 1000);
4606 closesocket(fdRead);
4607 /* test again with only the except descriptor */
4608 tcp_socketpair(&fdRead, &fdWrite);
4609 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
4610 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %ld\n", GetLastError());
4611 FD_ZERO_ALL();
4612 FD_SET(fdWrite, &exceptfds);
4613 SetLastError(0xdeadbeef);
4614 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
4615 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4616 ok(GetLastError() == WSAENOTSOCK, "got %ld\n", GetLastError());
4617 ok(!FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is in the set\n");
4618 WaitForSingleObject (thread_handle, 1000);
4619 closesocket(fdRead);
4620
4621 /* test UDP behavior of unbound sockets */
4622 select_timeout.tv_sec = 0;
4623 select_timeout.tv_usec = 250000;
4624 fdWrite = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
4625 ok(fdWrite != INVALID_SOCKET, "socket call failed\n");
4626 FD_ZERO_ALL();
4627 FD_SET_ALL(fdWrite);
4628 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4629 ok(ret == 1, "expected 1, got %d\n", ret);
4630 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4631 closesocket(fdWrite);
4632 }
4633 #undef FD_SET_ALL
4634 #undef FD_ZERO_ALL
4635
4636 static DWORD WINAPI AcceptKillThread(void *param)
4637 {
4638 select_thread_params *par = param;
4639 struct sockaddr_in address;
4640 int len = sizeof(address);
4641 SOCKET client_socket;
4642
4643 SetEvent(server_ready);
4644 client_socket = accept(par->s, (struct sockaddr*) &address, &len);
4645 if (client_socket != INVALID_SOCKET)
4646 closesocket(client_socket);
4647 par->ReadKilled = (client_socket == INVALID_SOCKET);
4648 return 0;
4649 }
4650
4651
4652 static int CALLBACK AlwaysDeferConditionFunc(LPWSABUF lpCallerId, LPWSABUF lpCallerData, LPQOS pQos,
4653 LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,
4654 GROUP *g, DWORD_PTR dwCallbackData)
4655 {
4656 return CF_DEFER;
4657 }
4658
4659 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len)
4660 {
4661 int ret, val;
4662 SOCKET server_socket;
4663
4664 server_socket = socket(AF_INET, SOCK_STREAM, 0);
4665 ok(server_socket != INVALID_SOCKET, "failed to bind socket, error %u\n", WSAGetLastError());
4666
4667 val = 1;
4668 ret = setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
4669 ok(!ret, "failed to set SO_REUSEADDR, error %u\n", WSAGetLastError());
4670
4671 ret = bind(server_socket, (struct sockaddr *)addr, *len);
4672 ok(!ret, "failed to bind socket, error %u\n", WSAGetLastError());
4673
4674 ret = getsockname(server_socket, (struct sockaddr *)addr, len);
4675 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
4676
4677 ret = listen(server_socket, 5);
4678 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
4679
4680 return server_socket;
4681 }
4682
4683 static SOCKET setup_connector_socket(const struct sockaddr_in *addr, int len, BOOL nonblock)
4684 {
4685 int ret;
4686 SOCKET connector;
4687
4688 connector = socket(AF_INET, SOCK_STREAM, 0);
4689 ok(connector != INVALID_SOCKET, "failed to create connector socket %d\n", WSAGetLastError());
4690
4691 if (nonblock)
4692 set_blocking(connector, !nonblock);
4693
4694 ret = connect(connector, (const struct sockaddr *)addr, len);
4695 if (!nonblock)
4696 ok(!ret, "connecting to accepting socket failed %d\n", WSAGetLastError());
4697 else if (ret == SOCKET_ERROR)
4698 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4699
4700 return connector;
4701 }
4702
4703 struct connect_apc_func_param
4704 {
4705 HANDLE event;
4706 struct sockaddr_in addr;
4707 SOCKET connector;
4708 unsigned int apc_count;
4709 };
4710
4711 static DWORD WINAPI test_accept_connect_thread(void *param)
4712 {
4713 struct connect_apc_func_param *p = (struct connect_apc_func_param *)param;
4714
4715 WaitForSingleObject(p->event, INFINITE);
4716 p->connector = setup_connector_socket(&p->addr, sizeof(p->addr), FALSE);
4717 ok(p->connector != INVALID_SOCKET, "failed connecting from APC func.\n");
4718 return 0;
4719 }
4720
4721 static void WINAPI connect_apc_func(ULONG_PTR param)
4722 {
4723 struct connect_apc_func_param *p = (struct connect_apc_func_param *)param;
4724
4725 ++p->apc_count;
4726 SetEvent(p->event);
4727 }
4728
4729 static void test_accept(void)
4730 {
4731 int ret;
4732 SOCKET server_socket, accepted = INVALID_SOCKET, connector;
4733 struct connect_apc_func_param apc_param;
4734 struct sockaddr_in address;
4735 SOCKADDR_STORAGE ss, ss_empty;
4736 int socklen;
4737 select_thread_params thread_params;
4738 HANDLE thread_handle = NULL;
4739 DWORD id;
4740
4741 memset(&address, 0, sizeof(address));
4742 address.sin_addr.s_addr = inet_addr("127.0.0.1");
4743 address.sin_family = AF_INET;
4744
4745 socklen = sizeof(address);
4746 server_socket = setup_server_socket(&address, &socklen);
4747
4748 memset(&apc_param, 0, sizeof(apc_param));
4749 apc_param.event = CreateEventW(NULL, FALSE, FALSE, NULL);
4750 apc_param.addr = address;
4751 /* Connecting directly from APC function randomly crashes on Windows for some reason,
4752 * so do it from a thread and only signal it from the APC when we are in accept() call. */
4753 thread_handle = CreateThread(NULL, 0, test_accept_connect_thread, &apc_param, 0, NULL);
4754 ret = QueueUserAPC(connect_apc_func, GetCurrentThread(), (ULONG_PTR)&apc_param);
4755 ok(ret, "QueueUserAPC returned %d\n", ret);
4756 accepted = accept(server_socket, NULL, NULL);
4757 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4758 ok(apc_param.apc_count == 1, "APC was called %u times\n", apc_param.apc_count);
4759 closesocket(accepted);
4760 closesocket(apc_param.connector);
4761 WaitForSingleObject(thread_handle, INFINITE);
4762 CloseHandle(thread_handle);
4763 CloseHandle(apc_param.event);
4764
4765 connector = setup_connector_socket(&address, socklen, FALSE);
4766 if (connector == INVALID_SOCKET) goto done;
4767
4768 accepted = WSAAccept(server_socket, NULL, NULL, AlwaysDeferConditionFunc, 0);
4769 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
4770
4771 accepted = accept(server_socket, NULL, 0);
4772 ok(accepted != INVALID_SOCKET, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
4773
4774 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
4775
4776 thread_params.s = server_socket;
4777 thread_params.ReadKilled = FALSE;
4778 thread_handle = CreateThread(NULL, 0, AcceptKillThread, &thread_params, 0, &id);
4779
4780 WaitForSingleObject(server_ready, INFINITE);
4781 Sleep(200);
4782 ret = closesocket(server_socket);
4783 ok(!ret, "failed to close socket, error %u\n", WSAGetLastError());
4784
4785 WaitForSingleObject(thread_handle, 1000);
4786 ok(thread_params.ReadKilled, "closesocket did not wake up accept\n");
4787
4788 closesocket(accepted);
4789 closesocket(connector);
4790 accepted = connector = INVALID_SOCKET;
4791
4792 socklen = sizeof(address);
4793 server_socket = setup_server_socket(&address, &socklen);
4794
4795 connector = setup_connector_socket(&address, socklen, FALSE);
4796 if (connector == INVALID_SOCKET) goto done;
4797
4798 socklen = 0;
4799 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
4800 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
4801 ok(!socklen, "got %d\n", socklen);
4802 closesocket(connector);
4803 connector = INVALID_SOCKET;
4804
4805 socklen = sizeof(address);
4806 connector = setup_connector_socket(&address, socklen, FALSE);
4807 if (connector == INVALID_SOCKET) goto done;
4808
4809 accepted = WSAAccept(server_socket, NULL, NULL, NULL, 0);
4810 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4811 closesocket(accepted);
4812 closesocket(connector);
4813 accepted = connector = INVALID_SOCKET;
4814
4815 socklen = sizeof(address);
4816 connector = setup_connector_socket(&address, socklen, FALSE);
4817 if (connector == INVALID_SOCKET) goto done;
4818
4819 socklen = sizeof(ss);
4820 memset(&ss, 0, sizeof(ss));
4821 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
4822 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4823 ok(socklen != sizeof(ss), "unexpected length\n");
4824 ok(ss.ss_family, "family not set\n");
4825 closesocket(accepted);
4826 closesocket(connector);
4827 accepted = connector = INVALID_SOCKET;
4828
4829 socklen = sizeof(address);
4830 connector = setup_connector_socket(&address, socklen, FALSE);
4831 if (connector == INVALID_SOCKET) goto done;
4832
4833 socklen = 0;
4834 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4835 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
4836 ok(!socklen, "got %d\n", socklen);
4837 closesocket(connector);
4838 accepted = connector = INVALID_SOCKET;
4839
4840 socklen = sizeof(address);
4841 connector = setup_connector_socket(&address, socklen, FALSE);
4842 if (connector == INVALID_SOCKET) goto done;
4843
4844 accepted = accept(server_socket, NULL, NULL);
4845 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4846 closesocket(accepted);
4847 closesocket(connector);
4848 accepted = connector = INVALID_SOCKET;
4849
4850 socklen = sizeof(address);
4851 connector = setup_connector_socket(&address, socklen, FALSE);
4852 if (connector == INVALID_SOCKET) goto done;
4853
4854 socklen = sizeof(ss);
4855 memset(&ss, 0, sizeof(ss));
4856 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4857 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4858 ok(socklen != sizeof(ss), "unexpected length\n");
4859 ok(ss.ss_family, "family not set\n");
4860 closesocket(accepted);
4861 closesocket(connector);
4862 accepted = connector = INVALID_SOCKET;
4863
4864 socklen = sizeof(address);
4865 connector = setup_connector_socket(&address, socklen, FALSE);
4866 if (connector == INVALID_SOCKET) goto done;
4867
4868 memset(&ss, 0, sizeof(ss));
4869 memset(&ss_empty, 0, sizeof(ss_empty));
4870 accepted = accept(server_socket, (struct sockaddr *)&ss, NULL);
4871 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4872 ok(!memcmp(&ss, &ss_empty, sizeof(ss)), "structure is different\n");
4873
4874 done:
4875 if (accepted != INVALID_SOCKET)
4876 closesocket(accepted);
4877 if (connector != INVALID_SOCKET)
4878 closesocket(connector);
4879 if (thread_handle != NULL)
4880 CloseHandle(thread_handle);
4881 if (server_ready != INVALID_HANDLE_VALUE)
4882 CloseHandle(server_ready);
4883 if (server_socket != INVALID_SOCKET)
4884 closesocket(server_socket);
4885 }
4886
4887 /* Test what socket state is inherited from the listening socket by accept(). */
4888 static void test_accept_inheritance(void)
4889 {
4890 struct sockaddr_in addr, destaddr;
4891 SOCKET listener, server, client;
4892 struct linger linger;
4893 int ret, len, value;
4894 unsigned int i;
4895
4896 static const struct
4897 {
4898 int optname;
4899 int optval;
4900 int value;
4901 }
4902 int_tests[] =
4903 {
4904 {SOL_SOCKET, SO_REUSEADDR, 1},
4905 {SOL_SOCKET, SO_KEEPALIVE, 1},
4906 {SOL_SOCKET, SO_OOBINLINE, 1},
4907 {SOL_SOCKET, SO_SNDBUF, 0x123},
4908 {SOL_SOCKET, SO_RCVBUF, 0x123},
4909 {SOL_SOCKET, SO_SNDTIMEO, 0x123},
4910 {SOL_SOCKET, SO_RCVTIMEO, 0x123},
4911 {IPPROTO_TCP, TCP_NODELAY, 1},
4912 };
4913
4914 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4915 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
4916
4917 for (i = 0; i < ARRAY_SIZE(int_tests); ++i)
4918 {
4919 ret = setsockopt(listener, int_tests[i].optname, int_tests[i].optval,
4920 (char *)&int_tests[i].value, sizeof(int_tests[i].value));
4921 ok(!ret, "test %u: got error %u\n", i, WSAGetLastError());
4922 }
4923
4924 linger.l_onoff = 1;
4925 linger.l_linger = 555;
4926 ret = setsockopt(listener, SOL_SOCKET, SO_LINGER, (char *)&linger, sizeof(linger));
4927 ok(!ret, "got error %u\n", WSAGetLastError());
4928
4929 memset(&addr, 0, sizeof(addr));
4930 addr.sin_family = AF_INET;
4931 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
4932 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
4933 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
4934 len = sizeof(destaddr);
4935 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
4936 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
4937
4938 ret = listen(listener, 1);
4939 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
4940
4941 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4942 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
4943 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
4944 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
4945 server = accept(listener, NULL, NULL);
4946 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
4947
4948 for (i = 0; i < ARRAY_SIZE(int_tests); ++i)
4949 {
4950 value = 0;
4951 len = sizeof(value);
4952 ret = getsockopt(server, int_tests[i].optname, int_tests[i].optval, (char *)&value, &len);
4953 ok(!ret, "test %u: got error %u\n", i, WSAGetLastError());
4954 ok(value == int_tests[i].value, "test %u: got value %#x\n", i, value);
4955 }
4956
4957 len = sizeof(linger);
4958 memset(&linger, 0, sizeof(linger));
4959 ret = getsockopt(server, SOL_SOCKET, SO_LINGER, (char *)&linger, &len);
4960 ok(!ret, "got error %u\n", WSAGetLastError());
4961 ok(linger.l_onoff == 1, "got on/off %u\n", linger.l_onoff);
4962 ok(linger.l_linger == 555, "got linger %u\n", linger.l_onoff);
4963
4964 closesocket(server);
4965 closesocket(client);
4966 closesocket(listener);
4967 }
4968
4969 static void test_extendedSocketOptions(void)
4970 {
4971 WSADATA wsa;
4972 SOCKET sock;
4973 struct sockaddr_in sa;
4974 int sa_len = sizeof(struct sockaddr_in);
4975 int optval, optlen = sizeof(int), ret;
4976 BOOL bool_opt_val;
4977 LINGER linger_val;
4978
4979 ret = WSAStartup(MAKEWORD(2,0), &wsa);
4980 ok(!ret, "failed to startup, error %u\n", WSAGetLastError());
4981
4982 memset(&sa, 0, sa_len);
4983
4984 sa.sin_family = AF_INET;
4985 sa.sin_port = htons(0);
4986 sa.sin_addr.s_addr = htonl(INADDR_ANY);
4987
4988 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
4989 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
4990
4991 ret = bind(sock, (struct sockaddr *) &sa, sa_len);
4992 ok(!ret, "failed to bind socket, error %u\n", WSAGetLastError());
4993
4994 ret = getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4995
4996 ok(ret == 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret);
4997 ok((optval == 65507) || (optval == 65527),
4998 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval);
4999
5000 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
5001 SetLastError(0xdeadbeef);
5002 optval = 0xdeadbeef;
5003 optlen = sizeof(int);
5004 ret = getsockopt(sock, 0xffffffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
5005 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
5006 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5007 ret, WSAGetLastError(), optval, optval);
5008
5009 /* more invalid values for level */
5010 SetLastError(0xdeadbeef);
5011 optval = 0xdeadbeef;
5012 optlen = sizeof(int);
5013 ret = getsockopt(sock, 0x1234ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
5014 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
5015 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5016 ret, WSAGetLastError(), optval, optval);
5017
5018 SetLastError(0xdeadbeef);
5019 optval = 0xdeadbeef;
5020 optlen = sizeof(int);
5021 ret = getsockopt(sock, 0x8000ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
5022 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
5023 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5024 ret, WSAGetLastError(), optval, optval);
5025
5026 SetLastError(0xdeadbeef);
5027 optval = 0xdeadbeef;
5028 optlen = sizeof(int);
5029 ret = getsockopt(sock, 0x00008000, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
5030 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
5031 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5032 ret, WSAGetLastError(), optval, optval);
5033
5034 SetLastError(0xdeadbeef);
5035 optval = 0xdeadbeef;
5036 optlen = sizeof(int);
5037 ret = getsockopt(sock, 0x00000800, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
5038 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
5039 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5040 ret, WSAGetLastError(), optval, optval);
5041
5042 SetLastError(0xdeadbeef);
5043 optlen = sizeof(LINGER);
5044 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
5045 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAENOPROTOOPT),
5046 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
5047 ret, WSAGetLastError());
5048 closesocket(sock);
5049
5050 sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
5051 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
5052
5053 ret = bind(sock, (struct sockaddr *) &sa, sa_len);
5054 ok(!ret, "failed to bind socket, error %u\n", WSAGetLastError());
5055
5056 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
5057 ok(ret == 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret);
5058
5059 optlen = sizeof(BOOL);
5060 ret = getsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *)&bool_opt_val, &optlen);
5061 ok(ret == 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret);
5062 ok((linger_val.l_onoff && !bool_opt_val) || (!linger_val.l_onoff && bool_opt_val),
5063 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
5064 bool_opt_val, linger_val.l_onoff);
5065
5066 closesocket(sock);
5067 WSACleanup();
5068 }
5069
5070 static void test_getsockname(void)
5071 {
5072 WSADATA wsa;
5073 SOCKET sock;
5074 struct sockaddr_in sa_set, sa_get;
5075 int sa_set_len = sizeof(struct sockaddr_in);
5076 int sa_get_len = sa_set_len;
5077 static const unsigned char null_padding[] = {0,0,0,0,0,0,0,0};
5078 int ret;
5079 struct hostent *h;
5080
5081 ret = WSAStartup(MAKEWORD(2,0), &wsa);
5082 ok(!ret, "failed to startup, error %u\n", WSAGetLastError());
5083
5084 memset(&sa_set, 0, sa_set_len);
5085
5086 sa_set.sin_family = AF_INET;
5087 sa_set.sin_port = htons(0);
5088 sa_set.sin_addr.s_addr = htonl(INADDR_ANY);
5089
5090 sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
5091 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
5092
5093 sa_get = sa_set;
5094 WSASetLastError(0xdeadbeef);
5095 ret = getsockname(sock, (struct sockaddr *)&sa_get, &sa_get_len);
5096 ok(ret == SOCKET_ERROR, "expected failure\n");
5097 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
5098 ok(!memcmp(&sa_get, &sa_set, sizeof(sa_get)), "address should not be changed\n");
5099
5100 ret = bind(sock, (struct sockaddr *) &sa_set, sa_set_len);
5101 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
5102
5103 WSASetLastError(0xdeadbeef);
5104 memset(&sa_get, 0, sizeof(sa_get));
5105 ret = getsockname(sock, (struct sockaddr *) &sa_get, &sa_get_len);
5106 ok(!ret, "got %d\n", ret);
5107 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
5108 ok(sa_get.sin_family == AF_INET, "got family %#x\n", sa_get.sin_family);
5109 ok(sa_get.sin_port != 0, "got zero port\n");
5110 ok(sa_get.sin_addr.s_addr == INADDR_ANY, "got addr %08lx\n", sa_get.sin_addr.s_addr);
5111
5112 ret = memcmp(sa_get.sin_zero, null_padding, 8);
5113 ok(ret == 0, "getsockname did not zero the sockaddr_in structure\n");
5114
5115 sa_get_len = sizeof(sa_get) - 1;
5116 WSASetLastError(0xdeadbeef);
5117 ret = getsockname(sock, (struct sockaddr *)&sa_get, &sa_get_len);
5118 ok(ret == -1, "expected failure\n");
5119 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5120 ok(sa_get_len == sizeof(sa_get) - 1, "got size %d\n", sa_get_len);
5121
5122 closesocket(sock);
5123
5124 h = gethostbyname("");
5125 if (h && h->h_length == 4) /* this test is only meaningful in IPv4 */
5126 {
5127 int i;
5128 for (i = 0; h->h_addr_list[i]; i++)
5129 {
5130 char ipstr[32];
5131 struct in_addr ip;
5132 ip.s_addr = *(ULONG *) h->h_addr_list[i];
5133
5134 sock = socket(AF_INET, SOCK_DGRAM, 0);
5135 ok(sock != INVALID_SOCKET, "socket failed with %ld\n", GetLastError());
5136
5137 memset(&sa_set, 0, sizeof(sa_set));
5138 sa_set.sin_family = AF_INET;
5139 sa_set.sin_addr.s_addr = ip.s_addr;
5140 /* The same address we bind must be the same address we get */
5141 ret = bind(sock, (struct sockaddr*)&sa_set, sizeof(sa_set));
5142 ok(ret == 0, "bind failed with %ld\n", GetLastError());
5143 sa_get_len = sizeof(sa_get);
5144 ret = getsockname(sock, (struct sockaddr*)&sa_get, &sa_get_len);
5145 ok(ret == 0, "getsockname failed with %ld\n", GetLastError());
5146 strcpy(ipstr, inet_ntoa(sa_get.sin_addr));
5147 ok(sa_get.sin_addr.s_addr == sa_set.sin_addr.s_addr,
5148 "address does not match: %s != %s\n", ipstr, inet_ntoa(sa_set.sin_addr));
5149
5150 closesocket(sock);
5151 }
5152 }
5153
5154 WSACleanup();
5155 }
5156
5157 static DWORD apc_error, apc_size;
5158 static OVERLAPPED *apc_overlapped;
5159 static unsigned int apc_count;
5160
5161 static void WINAPI socket_apc(DWORD error, DWORD size, OVERLAPPED *overlapped, DWORD flags)
5162 {
5163 ok(!flags, "got flags %#lx\n", flags);
5164 ++apc_count;
5165 apc_error = error;
5166 apc_size = size;
5167 apc_overlapped = overlapped;
5168 }
5169
5170 #define check_fionread_siocatmark(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, FALSE, FALSE)
5171 #define check_fionread_siocatmark_todo(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, TRUE, TRUE)
5172 #define check_fionread_siocatmark_todo_oob(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, FALSE, TRUE)
5173 static void check_fionread_siocatmark_(int line, SOCKET s, unsigned int normal, unsigned int oob,
5174 BOOL todo_normal, BOOL todo_oob)
5175 {
5176 int ret, value;
5177 DWORD size;
5178
5179 value = 0xdeadbeef;
5180 WSASetLastError(0xdeadbeef);
5181 ret = WSAIoctl(s, FIONREAD, NULL, 0, &value, sizeof(value), &size, NULL, NULL);
5182 ok_(__FILE__, line)(!ret, "expected success\n");
5183 ok_(__FILE__, line)(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5184 todo_wine_if (todo_normal) ok_(__FILE__, line)(value == normal, "FIONBIO returned %u\n", value);
5185
5186 value = 0xdeadbeef;
5187 WSASetLastError(0xdeadbeef);
5188 ret = WSAIoctl(s, SIOCATMARK, NULL, 0, &value, sizeof(value), &size, NULL, NULL);
5189 ok_(__FILE__, line)(!ret, "expected success\n");
5190 ok_(__FILE__, line)(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5191 todo_wine_if (todo_oob) ok_(__FILE__, line)(value == oob, "SIOCATMARK returned %u\n", value);
5192 }
5193
5194 static void test_fionread_siocatmark(void)
5195 {
5196 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
5197 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5198 SOCKET client, server;
5199 char buffer[5];
5200 int ret, value;
5201 ULONG_PTR key;
5202 HANDLE port;
5203 DWORD size;
5204
5205 tcp_socketpair(&client, &server);
5206 set_blocking(client, FALSE);
5207 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
5208
5209 WSASetLastError(0xdeadbeef);
5210 ret = ioctlsocket(client, FIONREAD, (u_long *)1);
5211 ok(ret == -1, "expected failure\n");
5212 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5213
5214 WSASetLastError(0xdeadbeef);
5215 ret = ioctlsocket(client, SIOCATMARK, (u_long *)1);
5216 ok(ret == -1, "expected failure\n");
5217 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5218
5219 WSASetLastError(0xdeadbeef);
5220 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value), NULL, NULL, NULL);
5221 ok(ret == -1, "expected failure\n");
5222 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5223
5224 WSASetLastError(0xdeadbeef);
5225 size = 0xdeadbeef;
5226 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value) - 1, &size, NULL, NULL);
5227 ok(ret == -1, "expected failure\n");
5228 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5229 ok(size == 0xdeadbeef, "got size %lu\n", size);
5230
5231 WSASetLastError(0xdeadbeef);
5232 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value), NULL, NULL, NULL);
5233 ok(ret == -1, "expected failure\n");
5234 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5235
5236 WSASetLastError(0xdeadbeef);
5237 size = 0xdeadbeef;
5238 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value) - 1, &size, NULL, NULL);
5239 ok(ret == -1, "expected failure\n");
5240 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5241 ok(size == 0xdeadbeef, "got size %lu\n", size);
5242
5243 check_fionread_siocatmark(client, 0, TRUE);
5244
5245 port = CreateIoCompletionPort((HANDLE)client, NULL, 123, 0);
5246
5247 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value), NULL, &overlapped, NULL);
5248 ok(ret == -1, "expected failure\n");
5249 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5250
5251 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value), NULL, &overlapped, NULL);
5252 ok(ret == -1, "expected failure\n");
5253 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5254
5255 WSASetLastError(0xdeadbeef);
5256 size = 0xdeadbeef;
5257 value = 0xdeadbeef;
5258 overlapped.Internal = 0xdeadbeef;
5259 overlapped.InternalHigh = 0xdeadbeef;
5260 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value), &size, &overlapped, NULL);
5261 ok(!ret, "expected success\n");
5262 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5263 ok(!value, "got %u\n", value);
5264 ok(size == sizeof(value), "got size %lu\n", size);
5265 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5266 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5267
5268 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5269 ok(ret, "got error %lu\n", GetLastError());
5270 ok(!size, "got size %lu\n", size);
5271 ok(key == 123, "got key %Iu\n", key);
5272 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5273
5274 WSASetLastError(0xdeadbeef);
5275 size = 0xdeadbeef;
5276 value = 0xdeadbeef;
5277 overlapped.Internal = 0xdeadbeef;
5278 overlapped.InternalHigh = 0xdeadbeef;
5279 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value), &size, &overlapped, NULL);
5280 ok(!ret, "expected success\n");
5281 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5282 ok(value == TRUE, "got %u\n", value);
5283 ok(size == sizeof(value), "got size %lu\n", size);
5284 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5285 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5286
5287 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5288 ok(ret, "got error %lu\n", GetLastError());
5289 ok(!size, "got size %lu\n", size);
5290 ok(key == 123, "got key %Iu\n", key);
5291 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5292
5293 ret = send(server, "data", 5, 0);
5294 ok(ret == 5, "got %d\n", ret);
5295
5296 /* wait for the data to be available */
5297 check_poll_mask(client, POLLRDNORM, POLLRDNORM);
5298
5299 check_fionread_siocatmark(client, 5, TRUE);
5300
5301 ret = send(server, "a", 1, MSG_OOB);
5302 ok(ret == 1, "got %d\n", ret);
5303
5304 /* wait for the data to be available */
5305 check_poll_mask(client, POLLRDBAND, POLLRDBAND);
5306
5307 check_fionread_siocatmark_todo_oob(client, 5, FALSE);
5308
5309 ret = send(server, "a", 1, MSG_OOB);
5310 ok(ret == 1, "got %d\n", ret);
5311
5312 check_fionread_siocatmark_todo(client, 5, FALSE);
5313
5314 ret = recv(client, buffer, 3, 0);
5315 ok(ret == 3, "got %d\n", ret);
5316
5317 check_fionread_siocatmark_todo(client, 2, FALSE);
5318
5319 ret = recv(client, buffer, 1, MSG_OOB);
5320 ok(ret == 1, "got %d\n", ret);
5321
5322 /* wait for the data to be available */
5323 check_poll_mask_todo(client, POLLRDBAND, POLLRDBAND);
5324
5325 check_fionread_siocatmark_todo(client, 2, FALSE);
5326
5327 ret = recv(client, buffer, 5, 0);
5328 todo_wine ok(ret == 2, "got %d\n", ret);
5329
5330 check_fionread_siocatmark(client, 0, FALSE);
5331
5332 ret = recv(client, buffer, 1, MSG_OOB);
5333 todo_wine ok(ret == 1, "got %d\n", ret);
5334
5335 check_fionread_siocatmark_todo_oob(client, 0, TRUE);
5336
5337 ret = send(server, "a", 1, MSG_OOB);
5338 ok(ret == 1, "got %d\n", ret);
5339
5340 /* wait for the data to be available */
5341 check_poll_mask(client, POLLRDBAND, POLLRDBAND);
5342
5343 ret = 1;
5344 ret = setsockopt(client, SOL_SOCKET, SO_OOBINLINE, (char *)&ret, sizeof(ret));
5345 ok(!ret, "got error %u\n", WSAGetLastError());
5346
5347 check_fionread_siocatmark_todo_oob(client, 1, FALSE);
5348
5349 ret = recv(client, buffer, 1, 0);
5350 ok(ret == 1, "got %d\n", ret);
5351
5352 check_fionread_siocatmark(client, 0, TRUE);
5353
5354 ret = send(server, "a", 1, MSG_OOB);
5355 ok(ret == 1, "got %d\n", ret);
5356
5357 /* wait for the data to be available */
5358 check_poll_mask(client, POLLRDNORM, POLLRDNORM);
5359
5360 check_fionread_siocatmark(client, 1, TRUE);
5361
5362 closesocket(client);
5363 closesocket(server);
5364
5365 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5366
5367 check_fionread_siocatmark(server, 0, TRUE);
5368
5369 ret = bind(server, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
5370 ok(!ret, "got error %u\n", WSAGetLastError());
5371
5372 check_fionread_siocatmark(server, 0, TRUE);
5373
5374 closesocket(server);
5375 CloseHandle(overlapped.hEvent);
5376
5377 /* test with APCs */
5378
5379 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5380
5381 ret = WSAIoctl(server, FIONREAD, NULL, 0, &value, sizeof(value), NULL, &overlapped, socket_apc);
5382 ok(ret == -1, "expected failure\n");
5383 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5384
5385 ret = WSAIoctl(server, SIOCATMARK, NULL, 0, &value, sizeof(value), NULL, &overlapped, socket_apc);
5386 ok(ret == -1, "expected failure\n");
5387 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5388
5389 apc_count = 0;
5390 size = 0xdeadbeef;
5391 ret = WSAIoctl(server, FIONREAD, NULL, 0, &value, sizeof(value), &size, &overlapped, socket_apc);
5392 ok(!ret, "expected success\n");
5393 ok(size == sizeof(value), "got size %lu\n", size);
5394
5395 ret = SleepEx(0, TRUE);
5396 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5397 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5398 ok(!apc_error, "got APC error %lu\n", apc_error);
5399 ok(!apc_size, "got APC size %lu\n", apc_size);
5400 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5401
5402 apc_count = 0;
5403 size = 0xdeadbeef;
5404 ret = WSAIoctl(server, SIOCATMARK, NULL, 0, &value, sizeof(value), &size, &overlapped, socket_apc);
5405 ok(!ret, "expected success\n");
5406 ok(size == sizeof(value), "got size %lu\n", size);
5407
5408 ret = SleepEx(0, TRUE);
5409 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5410 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5411 ok(!apc_error, "got APC error %lu\n", apc_error);
5412 ok(!apc_size, "got APC size %lu\n", apc_size);
5413 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5414
5415 closesocket(server);
5416 }
5417
5418 static void test_fionbio(void)
5419 {
5420 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5421 u_long one = 1, zero = 0;
5422 HANDLE port, event;
5423 ULONG_PTR key;
5424 void *output;
5425 DWORD size;
5426 SOCKET s;
5427 int ret;
5428
5429 event = CreateEventW(NULL, TRUE, FALSE, NULL);
5430 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5431 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
5432
5433 WSASetLastError(0xdeadbeef);
5434 ret = ioctlsocket(s, FIONBIO, (u_long *)1);
5435 ok(ret == -1, "expected failure\n");
5436 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5437
5438 WSASetLastError(0xdeadbeef);
5439 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, NULL, NULL, NULL);
5440 ok(ret == -1, "expected failure\n");
5441 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5442
5443 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one) - 1, NULL, 0, &size, &overlapped, NULL);
5444 ok(ret == -1, "expected failure\n");
5445 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5446
5447 size = 0xdeadbeef;
5448 WSASetLastError(0xdeadbeef);
5449 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, NULL, NULL);
5450 ok(!ret, "expected success\n");
5451 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5452 ok(!size, "got size %lu\n", size);
5453
5454 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one) + 1, NULL, 0, &size, NULL, NULL);
5455 ok(!ret, "got error %u\n", WSAGetLastError());
5456
5457 output = VirtualAlloc(NULL, 4, MEM_RESERVE | MEM_COMMIT, PAGE_NOACCESS);
5458 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one) + 1, output, 4, &size, NULL, NULL);
5459 ok(!ret, "got error %u\n", WSAGetLastError());
5460 VirtualFree(output, 0, MEM_FREE);
5461
5462 overlapped.Internal = 0xdeadbeef;
5463 overlapped.InternalHigh = 0xdeadbeef;
5464 size = 0xdeadbeef;
5465 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, &overlapped, NULL);
5466 ok(!ret, "expected success\n");
5467 ok(!size, "got size %lu\n", size);
5468
5469 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5470 ok(ret, "got error %lu\n", GetLastError());
5471 ok(!size, "got size %lu\n", size);
5472 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5473 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5474 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5475
5476 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, NULL, &overlapped, NULL);
5477 ok(ret == -1, "expected failure\n");
5478 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5479
5480 ret = WSAEventSelect(s, event, FD_READ);
5481 ok(!ret, "got error %u\n", WSAGetLastError());
5482
5483 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, NULL, NULL);
5484 ok(!ret, "got error %u\n", WSAGetLastError());
5485
5486 size = 0xdeadbeef;
5487 ret = WSAIoctl(s, FIONBIO, &zero, sizeof(zero), NULL, 0, &size, NULL, NULL);
5488 ok(ret == -1, "expected failure\n");
5489 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
5490 todo_wine ok(!size, "got size %lu\n", size);
5491
5492 CloseHandle(port);
5493 closesocket(s);
5494 CloseHandle(event);
5495
5496 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5497
5498 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, NULL, &overlapped, socket_apc);
5499 ok(ret == -1, "expected failure\n");
5500 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5501
5502 apc_count = 0;
5503 size = 0xdeadbeef;
5504 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, &overlapped, socket_apc);
5505 ok(!ret, "expected success\n");
5506 ok(!size, "got size %lu\n", size);
5507
5508 ret = SleepEx(0, TRUE);
5509 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5510 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5511 ok(!apc_error, "got APC error %lu\n", apc_error);
5512 ok(!apc_size, "got APC size %lu\n", apc_size);
5513 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5514
5515 closesocket(s);
5516 }
5517
5518 static void test_keepalive_vals(void)
5519 {
5520 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5521 struct tcp_keepalive kalive;
5522 ULONG_PTR key;
5523 HANDLE port;
5524 SOCKET sock;
5525 DWORD size;
5526 int ret;
5527
5528 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5529 ok(sock != INVALID_SOCKET, "Creating the socket failed: %d\n", WSAGetLastError());
5530 port = CreateIoCompletionPort((HANDLE)sock, NULL, 123, 0);
5531
5532 WSASetLastError(0xdeadbeef);
5533 size = 0xdeadbeef;
5534 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, 0, NULL, 0, &size, NULL, NULL);
5535 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5536 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5537 ok(!size, "got size %lu\n", size);
5538
5539 WSASetLastError(0xdeadbeef);
5540 size = 0xdeadbeef;
5541 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, NULL, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5542 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5543 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5544 ok(!size, "got size %lu\n", size);
5545
5546 WSASetLastError(0xdeadbeef);
5547 size = 0xdeadbeef;
5548 make_keepalive(kalive, 0, 0, 0);
5549 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5550 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5551 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5552 ok(!size, "got size %lu\n", size);
5553
5554 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, NULL, NULL, NULL);
5555 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5556 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5557
5558 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, NULL, &overlapped, NULL);
5559 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5560 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5561
5562 WSASetLastError(0xdeadbeef);
5563 size = 0xdeadbeef;
5564 overlapped.Internal = 0xdeadbeef;
5565 overlapped.InternalHigh = 0xdeadbeef;
5566 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive) - 1, NULL, 0, &size, &overlapped, NULL);
5567 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5568 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5569 ok(size == 0xdeadbeef, "got size %lu\n", size);
5570 todo_wine ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5571 ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
5572
5573 WSASetLastError(0xdeadbeef);
5574 size = 0xdeadbeef;
5575 overlapped.Internal = 0xdeadbeef;
5576 overlapped.InternalHigh = 0xdeadbeef;
5577 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, &overlapped, NULL);
5578 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5579 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5580 todo_wine ok(size == 0xdeadbeef, "got size %lu\n", size);
5581
5582 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5583 ok(ret, "got error %lu\n", GetLastError());
5584 ok(!size, "got size %lu\n", size);
5585 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5586 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5587 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5588
5589 make_keepalive(kalive, 1, 0, 0);
5590 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5591 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5592
5593 make_keepalive(kalive, 1, 1000, 1000);
5594 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5595 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5596
5597 make_keepalive(kalive, 1, 10000, 10000);
5598 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5599 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5600
5601 make_keepalive(kalive, 1, 100, 100);
5602 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5603 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5604
5605 make_keepalive(kalive, 0, 100, 100);
5606 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5607 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5608
5609 CloseHandle(port);
5610 closesocket(sock);
5611
5612 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5613
5614 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, NULL, &overlapped, socket_apc);
5615 ok(ret == -1, "expected failure\n");
5616 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5617
5618 apc_count = 0;
5619 size = 0xdeadbeef;
5620 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, &overlapped, socket_apc);
5621 ok(!ret, "expected success\n");
5622 ok(!size, "got size %lu\n", size);
5623
5624 ret = SleepEx(0, TRUE);
5625 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5626 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5627 ok(!apc_error, "got APC error %lu\n", apc_error);
5628 ok(!apc_size, "got APC size %lu\n", apc_size);
5629 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5630
5631 closesocket(sock);
5632 }
5633
5634 static void test_unsupported_ioctls(void)
5635 {
5636 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5637 unsigned int i;
5638 ULONG_PTR key;
5639 HANDLE port;
5640 DWORD size;
5641 SOCKET s;
5642 int ret;
5643
5644 static const DWORD codes[] = {0xdeadbeef, FIOASYNC, 0x667e, SIO_FLUSH};
5645
5646 for (i = 0; i < ARRAY_SIZE(codes); ++i)
5647 {
5648 winetest_push_context("ioctl %#lx", codes[i]);
5649 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5650 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
5651
5652 WSASetLastError(0xdeadbeef);
5653 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, NULL, &overlapped, NULL);
5654 ok(ret == -1, "expected failure\n");
5655 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5656
5657 WSASetLastError(0xdeadbeef);
5658 size = 0xdeadbeef;
5659 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, &size, NULL, NULL);
5660 ok(ret == -1, "expected failure\n");
5661 ok(WSAGetLastError() == WSAEOPNOTSUPP, "got error %u\n", WSAGetLastError());
5662 ok(!size, "got size %lu\n", size);
5663
5664 WSASetLastError(0xdeadbeef);
5665 size = 0xdeadbeef;
5666 overlapped.Internal = 0xdeadbeef;
5667 overlapped.InternalHigh = 0xdeadbeef;
5668 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, &size, &overlapped, NULL);
5669 ok(ret == -1, "expected failure\n");
5670 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
5671 ok(size == 0xdeadbeef, "got size %lu\n", size);
5672
5673 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5674 ok(!ret, "expected failure\n");
5675 ok(GetLastError() == ERROR_NOT_SUPPORTED, "got error %lu\n", GetLastError());
5676 ok(!size, "got size %lu\n", size);
5677 ok(key == 123, "got key %Iu\n", key);
5678 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5679 ok((NTSTATUS)overlapped.Internal == STATUS_NOT_SUPPORTED,
5680 "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5681 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5682
5683 CloseHandle(port);
5684 closesocket(s);
5685
5686 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5687
5688 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, NULL, &overlapped, socket_apc);
5689 ok(ret == -1, "expected failure\n");
5690 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5691
5692 apc_count = 0;
5693 size = 0xdeadbeef;
5694 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, &size, &overlapped, socket_apc);
5695 ok(ret == -1, "expected failure\n");
5696 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
5697 ok(size == 0xdeadbeef, "got size %lu\n", size);
5698
5699 ret = SleepEx(0, TRUE);
5700 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5701 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5702 ok(apc_error == WSAEOPNOTSUPP, "got APC error %lu\n", apc_error);
5703 ok(!apc_size, "got APC size %lu\n", apc_size);
5704 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5705
5706 closesocket(s);
5707 winetest_pop_context();
5708 }
5709 }
5710
5711 static void test_get_extension_func(void)
5712 {
5713 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5714 GUID acceptex_guid = WSAID_ACCEPTEX;
5715 GUID bogus_guid = {0xdeadbeef};
5716 ULONG_PTR key;
5717 HANDLE port;
5718 DWORD size;
5719 void *func;
5720 SOCKET s;
5721 int ret;
5722
5723 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5724 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
5725
5726 WSASetLastError(0xdeadbeef);
5727 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5728 &func, sizeof(func), NULL, &overlapped, NULL);
5729 ok(ret == -1, "expected failure\n");
5730 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5731
5732 WSASetLastError(0xdeadbeef);
5733 size = 0xdeadbeef;
5734 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5735 &func, sizeof(func), &size, NULL, NULL);
5736 ok(!ret, "expected success\n");
5737 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5738 ok(size == sizeof(func), "got size %lu\n", size);
5739
5740 WSASetLastError(0xdeadbeef);
5741 size = 0xdeadbeef;
5742 overlapped.Internal = 0xdeadbeef;
5743 overlapped.InternalHigh = 0xdeadbeef;
5744 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5745 &func, sizeof(func), &size, &overlapped, NULL);
5746 ok(!ret, "expected success\n");
5747 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5748 ok(size == sizeof(func), "got size %lu\n", size);
5749
5750 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5751 ok(ret, "got error %lu\n", GetLastError());
5752 ok(!size, "got size %lu\n", size);
5753 ok(key == 123, "got key %Iu\n", key);
5754 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5755 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5756 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5757
5758 size = 0xdeadbeef;
5759 overlapped.Internal = 0xdeadbeef;
5760 overlapped.InternalHigh = 0xdeadbeef;
5761 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &bogus_guid, sizeof(GUID),
5762 &func, sizeof(func), &size, &overlapped, NULL);
5763 ok(ret == -1, "expected failure\n");
5764 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
5765 ok(size == 0xdeadbeef, "got size %lu\n", size);
5766 ok(overlapped.Internal == 0xdeadbeef, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5767 ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
5768
5769 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5770 ok(!ret, "expected failure\n");
5771 ok(GetLastError() == WAIT_TIMEOUT, "got error %u\n", WSAGetLastError());
5772
5773 CloseHandle(port);
5774 closesocket(s);
5775
5776 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5777
5778 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5779 &func, sizeof(func), NULL, &overlapped, socket_apc);
5780 ok(ret == -1, "expected failure\n");
5781 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5782
5783 apc_count = 0;
5784 size = 0xdeadbeef;
5785 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5786 &func, sizeof(func), &size, &overlapped, socket_apc);
5787 ok(!ret, "got error %u\n", WSAGetLastError());
5788 ok(size == sizeof(func), "got size %lu\n", size);
5789
5790 ret = SleepEx(0, TRUE);
5791 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5792 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5793 ok(!apc_error, "got APC error %lu\n", apc_error);
5794 ok(!apc_size, "got APC size %lu\n", apc_size);
5795 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5796
5797 closesocket(s);
5798 }
5799
5800 static void test_backlog_query(void)
5801 {
5802 const struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
5803 GUID acceptex_guid = WSAID_ACCEPTEX;
5804 LPFN_ACCEPTEX pAcceptEx;
5805 struct sockaddr_in destaddr;
5806 DWORD size;
5807 SOCKET s, listener;
5808 int len, ret;
5809 ULONG backlog = 0;
5810
5811 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5812 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
5813
5814 ret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(acceptex_guid),
5815 &pAcceptEx, sizeof(pAcceptEx), &size, NULL, NULL);
5816 ok(!ret, "failed to get AcceptEx, error %u\n", WSAGetLastError());
5817
5818 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
5819 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
5820 len = sizeof(destaddr);
5821 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
5822 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
5823 ret = listen(listener, 2);
5824 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
5825
5826 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5827 ret = WSAIoctl(s, SIO_IDEAL_SEND_BACKLOG_QUERY, NULL, 0, &backlog, sizeof(backlog), &size, NULL, NULL);
5828 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTCONN,
5829 "WSAIoctl() failed: %d/%d\n", ret, WSAGetLastError());
5830
5831 ret = connect(s, (struct sockaddr *)&destaddr, sizeof(destaddr));
5832 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
5833 ret = WSAIoctl(s, SIO_IDEAL_SEND_BACKLOG_QUERY, NULL, 0, &backlog, sizeof(backlog), &size, NULL, NULL);
5834 ok(!ret, "WSAIoctl() failed: %d\n", WSAGetLastError());
5835 ok(backlog == 0x10000, "got %08lx\n", backlog);
5836
5837 closesocket(listener);
5838 closesocket(s);
5839
5840 s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
5841
5842 backlog = 0;
5843 ret = WSAIoctl(s, SIO_IDEAL_SEND_BACKLOG_QUERY, NULL, 0, &backlog, sizeof(backlog), &size, NULL, NULL);
5844 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEOPNOTSUPP,
5845 "WSAIoctl() failed: %d/%d\n", ret, WSAGetLastError());
5846 closesocket(s);
5847 }
5848
5849 static void test_base_handle(void)
5850 {
5851 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5852 unsigned int i;
5853 SOCKET s, base;
5854 ULONG_PTR key;
5855 HANDLE port;
5856 DWORD size;
5857 int ret;
5858
5859 static const struct
5860 {
5861 int family, type, protocol;
5862 }
5863 tests[] =
5864 {
5865 {AF_INET, SOCK_STREAM, IPPROTO_TCP},
5866 {AF_INET, SOCK_DGRAM, IPPROTO_UDP},
5867 {AF_INET6, SOCK_STREAM, IPPROTO_TCP},
5868 {AF_INET6, SOCK_DGRAM, IPPROTO_UDP},
5869 };
5870
5871 for (i = 0; i < ARRAY_SIZE(tests); ++i)
5872 {
5873 s = socket(tests[i].family, tests[i].type, tests[i].protocol);
5874 if (s == INVALID_SOCKET) continue;
5875 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
5876
5877 WSASetLastError(0xdeadbeef);
5878 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), NULL, &overlapped, NULL);
5879 ok(ret == -1, "expected failure\n");
5880 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5881
5882 WSASetLastError(0xdeadbeef);
5883 size = 0xdeadbeef;
5884 base = 0xdeadbeef;
5885 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), &size, NULL, NULL);
5886 ok(!ret, "expected success\n");
5887 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5888 ok(size == sizeof(base), "got size %lu\n", size);
5889 ok(base == s, "expected %#Ix, got %#Ix\n", s, base);
5890
5891 WSASetLastError(0xdeadbeef);
5892 size = 0xdeadbeef;
5893 base = 0xdeadbeef;
5894 overlapped.Internal = 0xdeadbeef;
5895 overlapped.InternalHigh = 0xdeadbeef;
5896 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), &size, &overlapped, NULL);
5897 ok(ret == -1, "expected failure\n");
5898 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
5899 ok(size == 0xdeadbeef, "got size %lu\n", size);
5900
5901 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5902 ok(!ret, "expected failure\n");
5903 ok(GetLastError() == ERROR_NOT_SUPPORTED, "got error %lu\n", GetLastError());
5904 ok(!size, "got size %lu\n", size);
5905 ok(key == 123, "got key %Iu\n", key);
5906 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5907 ok((NTSTATUS)overlapped.Internal == STATUS_NOT_SUPPORTED, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5908 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5909 ok(base == 0xdeadbeef, "expected %#Ix, got %#Ix\n", s, base);
5910
5911 CloseHandle(port);
5912 closesocket(s);
5913
5914 s = socket(tests[i].family, tests[i].type, tests[i].protocol);
5915
5916 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), NULL, &overlapped, socket_apc);
5917 ok(ret == -1, "expected failure\n");
5918 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5919
5920 apc_count = 0;
5921 size = 0xdeadbeef;
5922 base = 0xdeadbeef;
5923 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), &size, &overlapped, socket_apc);
5924 ok(ret == -1, "expected failure\n");
5925 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
5926 ok(size == 0xdeadbeef, "got size %lu\n", size);
5927
5928 ret = SleepEx(0, TRUE);
5929 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5930 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5931 ok(apc_error == WSAEOPNOTSUPP, "got APC error %lu\n", apc_error);
5932 ok(!apc_size, "got APC size %lu\n", apc_size);
5933 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5934 ok(base == 0xdeadbeef, "expected %#Ix, got %#Ix\n", s, base);
5935
5936 closesocket(s);
5937 }
5938 }
5939
5940 static void test_circular_queueing(void)
5941 {
5942 SOCKET s;
5943 DWORD size;
5944 int ret;
5945
5946 s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
5947 ret = WSAIoctl(s, SIO_ENABLE_CIRCULAR_QUEUEING, NULL, 0, NULL, 0, &size, NULL, NULL);
5948 ok(!ret, "expected 0, got %d\n", ret);
5949
5950 closesocket(s);
5951 }
5952
5953 static BOOL drain_pause = FALSE;
5954 static DWORD WINAPI drain_socket_thread(LPVOID arg)
5955 {
5956 char buffer[1024];
5957 SOCKET sock = *(SOCKET*)arg;
5958 int ret;
5959
5960 while ((ret = recv(sock, buffer, sizeof(buffer), 0)) != 0)
5961 {
5962 if (ret < 0)
5963 {
5964 if (WSAGetLastError() == WSAEWOULDBLOCK)
5965 {
5966 fd_set readset;
5967 FD_ZERO(&readset);
5968 FD_SET(sock, &readset);
5969 select(sock+1, &readset, NULL, NULL, NULL);
5970 while (drain_pause)
5971 Sleep(100);
5972 }
5973 else
5974 break;
5975 }
5976 }
5977 return 0;
5978 }
5979
5980 static void test_send(void)
5981 {
5982 SOCKET src = INVALID_SOCKET;
5983 SOCKET dst = INVALID_SOCKET;
5984 HANDLE hThread = NULL;
5985 const int buflen = 1024*1024;
5986 char *buffer = NULL;
5987 int ret, i, zero = 0;
5988 WSABUF buf;
5989 OVERLAPPED ov;
5990 BOOL bret;
5991 DWORD id, bytes_sent, dwRet;
5992
5993 memset(&ov, 0, sizeof(ov));
5994
5995 tcp_socketpair(&src, &dst);
5996
5997 set_blocking(dst, FALSE);
5998 /* force disable buffering so we can get a pending overlapped request */
5999 ret = setsockopt(dst, SOL_SOCKET, SO_SNDBUF, (char *) &zero, sizeof(zero));
6000 ok(!ret, "setsockopt SO_SNDBUF failed: %d - %ld\n", ret, GetLastError());
6001
6002 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
6003
6004 buffer = malloc(buflen);
6005
6006 /* fill the buffer with some nonsense */
6007 for (i = 0; i < buflen; ++i)
6008 {
6009 buffer[i] = (char) i;
6010 }
6011
6012 ret = send(src, buffer, buflen, 0);
6013 ok(ret == buflen, "send should have sent %d bytes, but it only sent %d\n", buflen, ret);
6014
6015 buf.buf = buffer;
6016 buf.len = buflen;
6017
6018 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
6019 ok(ov.hEvent != NULL, "could not create event object, errno = %ld\n", GetLastError());
6020 if (!ov.hEvent)
6021 goto end;
6022
6023 bytes_sent = 0;
6024 WSASetLastError(12345);
6025 ret = WSASend(dst, &buf, 1, &bytes_sent, 0, &ov, NULL);
6026 ok(ret == SOCKET_ERROR, "expected failure\n");
6027 ok(WSAGetLastError() == ERROR_IO_PENDING, "wrong error %u\n", WSAGetLastError());
6028
6029 /* don't check for completion yet, we may need to drain the buffer while still sending */
6030 set_blocking(src, FALSE);
6031 for (i = 0; i < buflen; ++i)
6032 {
6033 int j = 0;
6034
6035 ret = recv(src, buffer, 1, 0);
6036 while (ret == SOCKET_ERROR && GetLastError() == WSAEWOULDBLOCK && j < 100)
6037 {
6038 j++;
6039 Sleep(50);
6040 ret = recv(src, buffer, 1, 0);
6041 }
6042
6043 ok(ret == 1, "Failed to receive data %d - %ld (got %d/%d)\n", ret, GetLastError(), i, buflen);
6044 if (ret != 1)
6045 break;
6046
6047 ok(buffer[0] == (char) i, "Received bad data at position %d\n", i);
6048 }
6049
6050 dwRet = WaitForSingleObject(ov.hEvent, 1000);
6051 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %ld - %ld\n", dwRet, GetLastError());
6052 if (dwRet == WAIT_OBJECT_0)
6053 {
6054 bret = GetOverlappedResult((HANDLE)dst, &ov, &bytes_sent, FALSE);
6055 ok(bret && bytes_sent == buflen,
6056 "Got %ld instead of %d (%d - %ld)\n", bytes_sent, buflen, bret, GetLastError());
6057 }
6058
6059 WSASetLastError(12345);
6060 ret = WSASend(INVALID_SOCKET, &buf, 1, NULL, 0, &ov, NULL);
6061 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
6062 "WSASend failed %d - %d\n", ret, WSAGetLastError());
6063
6064 WSASetLastError(12345);
6065 ret = WSASend(dst, &buf, 1, NULL, 0, &ov, NULL);
6066 ok(ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING,
6067 "Failed to start overlapped send %d - %d\n", ret, WSAGetLastError());
6068
6069 end:
6070 if (src != INVALID_SOCKET)
6071 closesocket(src);
6072 if (dst != INVALID_SOCKET)
6073 closesocket(dst);
6074 if (hThread != NULL)
6075 {
6076 dwRet = WaitForSingleObject(hThread, 500);
6077 ok(dwRet == WAIT_OBJECT_0, "failed to wait for thread termination: %ld\n", GetLastError());
6078 CloseHandle(hThread);
6079 }
6080 if (ov.hEvent)
6081 CloseHandle(ov.hEvent);
6082 free(buffer);
6083 }
6084
6085 #define WM_SOCKET (WM_USER+100)
6086
6087 struct event_test_ctx
6088 {
6089 int is_message;
6090 SOCKET socket;
6091 HANDLE event;
6092 HWND window;
6093 };
6094
6095 static void select_events(struct event_test_ctx *ctx, SOCKET socket, LONG events)
6096 {
6097 int ret;
6098
6099 if (ctx->is_message)
6100 ret = WSAAsyncSelect(socket, ctx->window, WM_USER, events);
6101 else
6102 ret = WSAEventSelect(socket, ctx->event, events);
6103 ok(!ret, "failed to select, error %u\n", WSAGetLastError());
6104 ctx->socket = socket;
6105 }
6106
6107 #define check_events(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, FALSE)
6108 #define check_events_todo(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, TRUE)
6109 #define check_events_todo_event(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, FALSE)
6110 #define check_events_todo_msg(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, TRUE)
6111 static void check_events_(int line, struct event_test_ctx *ctx,
6112 LONG flag1, LONG flag2, DWORD timeout, BOOL todo_event, BOOL todo_msg)
6113 {
6114 int ret;
6115
6116 if (ctx->is_message)
6117 {
6118 BOOL any_fail = FALSE;
6119 MSG msg;
6120
6121 if (flag1)
6122 {
6123 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6124 while (!ret && !MsgWaitForMultipleObjects(0, NULL, FALSE, timeout, QS_POSTMESSAGE))
6125 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6126 todo_wine_if (todo_msg && !ret) ok_(__FILE__, line)(ret, "expected a message\n");
6127 if (ret)
6128 {
6129 ok_(__FILE__, line)(msg.wParam == ctx->socket,
6130 "expected wparam %#Ix, got %#Ix\n", ctx->socket, msg.wParam);
6131 todo_wine_if (todo_msg && msg.lParam != flag1)
6132 ok_(__FILE__, line)(msg.lParam == flag1, "got first event %#Ix\n", msg.lParam);
6133 if (msg.lParam != flag1) any_fail = TRUE;
6134 }
6135 else
6136 any_fail = TRUE;
6137 }
6138 if (flag2)
6139 {
6140 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6141 while (!ret && !MsgWaitForMultipleObjects(0, NULL, FALSE, timeout, QS_POSTMESSAGE))
6142 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6143 ok_(__FILE__, line)(ret, "expected a message\n");
6144 ok_(__FILE__, line)(msg.wParam == ctx->socket, "got wparam %#Ix\n", msg.wParam);
6145 todo_wine_if (todo_msg) ok_(__FILE__, line)(msg.lParam == flag2, "got second event %#Ix\n", msg.lParam);
6146 }
6147 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6148 todo_wine_if (todo_msg && ret) ok_(__FILE__, line)(!ret, "got unexpected event %#Ix\n", msg.lParam);
6149 if (ret) any_fail = TRUE;
6150
6151 /* catch tests which succeed */
6152 todo_wine_if (todo_msg) ok_(__FILE__, line)(!any_fail, "event series matches\n");
6153 }
6154 else
6155 {
6156 WSANETWORKEVENTS events;
6157 unsigned int i;
6158
6159 memset(&events, 0xcc, sizeof(events));
6160 ret = WaitForSingleObject(ctx->event, timeout);
6161 if (flag1 | flag2)
6162 todo_wine_if (todo_event && ret) ok_(__FILE__, line)(!ret, "event wait timed out\n");
6163 else
6164 todo_wine_if (todo_event) ok_(__FILE__, line)(ret == WAIT_TIMEOUT, "expected timeout\n");
6165 ret = WSAEnumNetworkEvents(ctx->socket, ctx->event, &events);
6166 ok_(__FILE__, line)(!ret, "failed to get events, error %u\n", WSAGetLastError());
6167 todo_wine_if (todo_event)
6168 ok_(__FILE__, line)(events.lNetworkEvents == LOWORD(flag1 | flag2), "got events %#lx\n", events.lNetworkEvents);
6169 for (i = 0; i < ARRAY_SIZE(events.iErrorCode); ++i)
6170 {
6171 if ((1u << i) == LOWORD(flag1) && (events.lNetworkEvents & LOWORD(flag1)))
6172 todo_wine_if (HIWORD(flag1)) ok_(__FILE__, line)(events.iErrorCode[i] == HIWORD(flag1),
6173 "got error code %d for event %#x\n", events.iErrorCode[i], 1u << i);
6174 if ((1u << i) == LOWORD(flag2) && (events.lNetworkEvents & LOWORD(flag2)))
6175 ok_(__FILE__, line)(events.iErrorCode[i] == HIWORD(flag2),
6176 "got error code %d for event %#x\n", events.iErrorCode[i], 1u << i);
6177 }
6178 }
6179 }
6180
6181 static void test_accept_events(struct event_test_ctx *ctx)
6182 {
6183 const struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
6184 SOCKET listener, server, client, client2;
6185 GUID acceptex_guid = WSAID_ACCEPTEX;
6186 struct sockaddr_in destaddr;
6187 OVERLAPPED overlapped = {0};
6188 LPFN_ACCEPTEX pAcceptEx;
6189 char buffer[32];
6190 int len, ret;
6191 DWORD size;
6192
6193 overlapped.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
6194
6195 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6196 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
6197
6198 ret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(acceptex_guid),
6199 &pAcceptEx, sizeof(pAcceptEx), &size, NULL, NULL);
6200 ok(!ret, "failed to get AcceptEx, error %u\n", WSAGetLastError());
6201
6202 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6203
6204 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
6205 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6206 len = sizeof(destaddr);
6207 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
6208 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6209 ret = listen(listener, 2);
6210 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
6211
6212 check_events(ctx, 0, 0, 0);
6213
6214 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6215 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6216 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6217 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6218
6219 check_events(ctx, FD_ACCEPT, 0, 200);
6220 check_events(ctx, 0, 0, 0);
6221 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6222 if (ctx->is_message)
6223 check_events(ctx, FD_ACCEPT, 0, 200);
6224 check_events(ctx, 0, 0, 0);
6225 select_events(ctx, listener, 0);
6226 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6227 if (ctx->is_message)
6228 check_events(ctx, FD_ACCEPT, 0, 200);
6229 check_events(ctx, 0, 0, 0);
6230
6231 client2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6232 ok(client2 != -1, "failed to create socket, error %u\n", WSAGetLastError());
6233 ret = connect(client2, (struct sockaddr *)&destaddr, sizeof(destaddr));
6234 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6235
6236 if (!ctx->is_message)
6237 check_events_todo(ctx, FD_ACCEPT, 0, 200);
6238 check_events(ctx, 0, 0, 0);
6239
6240 server = accept(listener, NULL, NULL);
6241 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6242 closesocket(server);
6243
6244 check_events(ctx, FD_ACCEPT, 0, 200);
6245 check_events(ctx, 0, 0, 0);
6246
6247 server = accept(listener, NULL, NULL);
6248 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6249 closesocket(server);
6250
6251 check_events(ctx, 0, 0, 0);
6252
6253 closesocket(client2);
6254 closesocket(client);
6255
6256 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6257 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6258 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6259 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6260
6261 check_events(ctx, FD_ACCEPT, 0, 200);
6262
6263 server = accept(listener, NULL, NULL);
6264 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6265 closesocket(server);
6266 closesocket(client);
6267
6268 check_events(ctx, 0, 0, 200);
6269
6270 closesocket(listener);
6271
6272 /* Connect and then select. */
6273
6274 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6275 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
6276 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
6277 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6278 len = sizeof(destaddr);
6279 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
6280 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6281 ret = listen(listener, 2);
6282 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
6283
6284 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6285 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6286 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6287 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6288
6289 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6290
6291 check_events(ctx, FD_ACCEPT, 0, 200);
6292
6293 server = accept(listener, NULL, NULL);
6294 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6295 closesocket(server);
6296 closesocket(client);
6297
6298 /* As above, but select on a subset containing FD_ACCEPT first. */
6299
6300 if (!ctx->is_message)
6301 {
6302 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6303
6304 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6305 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6306 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6307 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6308
6309 ret = WaitForSingleObject(ctx->event, 200);
6310 ok(!ret, "wait timed out\n");
6311
6312 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
6313 ret = WaitForSingleObject(ctx->event, 0);
6314 ok(!ret, "wait timed out\n");
6315
6316 ResetEvent(ctx->event);
6317
6318 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
6319 ret = WaitForSingleObject(ctx->event, 0);
6320 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
6321
6322 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6323 ret = WaitForSingleObject(ctx->event, 0);
6324 ok(!ret, "wait timed out\n");
6325 check_events(ctx, FD_ACCEPT, 0, 0);
6326
6327 server = accept(listener, NULL, NULL);
6328 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6329 closesocket(server);
6330 closesocket(client);
6331 }
6332
6333 /* As above, but select on a subset not containing FD_ACCEPT first. */
6334
6335 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
6336
6337 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6338 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6339 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6340 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6341
6342 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6343 check_events(ctx, FD_ACCEPT, 0, 200);
6344
6345 server = accept(listener, NULL, NULL);
6346 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6347 closesocket(server);
6348 closesocket(client);
6349
6350 /* As above, but call accept() before selecting. */
6351
6352 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
6353
6354 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6355 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6356 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6357 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6358 Sleep(200);
6359 server = accept(listener, NULL, NULL);
6360 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6361
6362 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6363 check_events(ctx, 0, 0, 200);
6364
6365 closesocket(server);
6366 closesocket(client);
6367
6368 closesocket(listener);
6369
6370 /* The socket returned from accept() inherits the same parameters. */
6371
6372 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6373 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
6374 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
6375 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6376 len = sizeof(destaddr);
6377 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
6378 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6379 ret = listen(listener, 2);
6380 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
6381
6382 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6383 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6384 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6385 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6386
6387 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT | FD_WRITE);
6388 check_events(ctx, FD_ACCEPT, 0, 200);
6389
6390 server = accept(listener, NULL, NULL);
6391 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6392 ctx->socket = server;
6393 check_events(ctx, FD_WRITE, 0, 200);
6394 check_events(ctx, 0, 0, 0);
6395
6396 closesocket(server);
6397 closesocket(client);
6398
6399 /* Connect while there is a pending AcceptEx(). */
6400
6401 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6402
6403 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6404 ret = pAcceptEx(listener, server, buffer, 0, 0, sizeof(buffer), NULL, &overlapped);
6405 ok(!ret, "got %d\n", ret);
6406 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
6407
6408 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6409 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6410 ok(!ret, "got error %u\n", WSAGetLastError());
6411
6412 ret = WaitForSingleObject(overlapped.hEvent, 200);
6413 ok(!ret, "got %d\n", ret);
6414 ret = GetOverlappedResult((HANDLE)listener, &overlapped, &size, FALSE);
6415 ok(ret, "got error %lu\n", GetLastError());
6416 ok(!size, "got size %lu\n", size);
6417
6418 check_events(ctx, 0, 0, 0);
6419
6420 closesocket(server);
6421 closesocket(client);
6422
6423 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6424 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6425 ok(!ret, "got error %u\n", WSAGetLastError());
6426
6427 check_events(ctx, FD_ACCEPT, 0, 200);
6428 check_events(ctx, 0, 0, 0);
6429
6430 server = accept(listener, NULL, NULL);
6431 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6432 closesocket(server);
6433 closesocket(client);
6434
6435 closesocket(listener);
6436 CloseHandle(overlapped.hEvent);
6437 }
6438
6439 static void test_connect_events(struct event_test_ctx *ctx)
6440 {
6441 const struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
6442 SOCKET listener, server, client;
6443 struct sockaddr_in destaddr;
6444 int len, ret;
6445
6446 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6447 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
6448 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
6449 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6450 len = sizeof(destaddr);
6451 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
6452 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6453 ret = listen(listener, 2);
6454 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
6455
6456 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6457 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6458
6459 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6460 check_events(ctx, 0, 0, 0);
6461
6462 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6463 ok(!ret || WSAGetLastError() == WSAEWOULDBLOCK, "failed to connect, error %u\n", WSAGetLastError());
6464
6465 check_events(ctx, FD_CONNECT, FD_WRITE, 200);
6466 check_events(ctx, 0, 0, 0);
6467 select_events(ctx, client, 0);
6468 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6469 if (ctx->is_message)
6470 check_events(ctx, FD_WRITE, 0, 200);
6471 check_events(ctx, 0, 0, 0);
6472
6473 server = accept(listener, NULL, NULL);
6474 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6475
6476 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6477 check_events(ctx, FD_WRITE, 0, 200);
6478
6479 closesocket(client);
6480 closesocket(server);
6481
6482 /* Connect and then select. */
6483
6484 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6485 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6486
6487 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6488 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6489
6490 server = accept(listener, NULL, NULL);
6491 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6492
6493 ret = send(client, "data", 5, 0);
6494 ok(ret == 5, "got %d\n", ret);
6495
6496 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6497 if (ctx->is_message)
6498 check_events(ctx, FD_WRITE, 0, 200);
6499 else
6500 check_events(ctx, FD_CONNECT, FD_WRITE, 200);
6501
6502 closesocket(client);
6503 closesocket(server);
6504
6505 /* As above, but select on a subset not containing FD_CONNECT first. */
6506
6507 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6508 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6509
6510 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_OOB | FD_READ | FD_WRITE);
6511
6512 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6513 ok(!ret || WSAGetLastError() == WSAEWOULDBLOCK, "failed to connect, error %u\n", WSAGetLastError());
6514
6515 server = accept(listener, NULL, NULL);
6516 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6517
6518 check_events(ctx, FD_WRITE, 0, 200);
6519
6520 select_events(ctx, client, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6521
6522 if (ctx->is_message)
6523 check_events(ctx, FD_WRITE, 0, 200);
6524 else
6525 check_events(ctx, FD_CONNECT, 0, 200);
6526
6527 closesocket(client);
6528 closesocket(server);
6529
6530 /* Test with UDP sockets. */
6531
6532 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
6533 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
6534
6535 select_events(ctx, client, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6536 if (ctx->is_message)
6537 check_events(ctx, FD_WRITE, 0, 200);
6538 check_events_todo_event(ctx, 0, 0, 0);
6539
6540 ret = bind(server, (const struct sockaddr *)&addr, sizeof(addr));
6541 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6542 len = sizeof(destaddr);
6543 ret = getsockname(server, (struct sockaddr *)&destaddr, &len);
6544 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6545 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
6546 ok(!ret, "got error %lu\n", GetLastError());
6547
6548 if (ctx->is_message)
6549 check_events_todo(ctx, FD_WRITE, 0, 200);
6550 else
6551 check_events_todo(ctx, FD_CONNECT, FD_WRITE, 200);
6552 check_events(ctx, 0, 0, 0);
6553
6554 closesocket(client);
6555 closesocket(server);
6556
6557 closesocket(listener);
6558 }
6559
6560 /* perform a blocking recv() even on a nonblocking socket */
6561 static int sync_recv(SOCKET s, void *buffer, int len, DWORD flags)
6562 {
6563 OVERLAPPED overlapped = {0};
6564 WSABUF wsabuf;
6565 DWORD ret_len;
6566 int ret;
6567
6568 overlapped.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
6569 wsabuf.buf = buffer;
6570 wsabuf.len = len;
6571 ret = WSARecv(s, &wsabuf, 1, &ret_len, &flags, &overlapped, NULL);
6572 if (ret == -1 && WSAGetLastError() == ERROR_IO_PENDING)
6573 {
6574 ret = WaitForSingleObject(overlapped.hEvent, 1000);
6575 ok(!ret, "wait timed out\n");
6576 ret = WSAGetOverlappedResult(s, &overlapped, &ret_len, FALSE, &flags);
6577 ret = (ret ? 0 : -1);
6578 }
6579 CloseHandle(overlapped.hEvent);
6580 if (!ret) return ret_len;
6581 return -1;
6582 }
6583
6584 static void test_write_events(struct event_test_ctx *ctx)
6585 {
6586 static const int buffer_size = 1024 * 1024;
6587 SOCKET server, client;
6588 char *buffer;
6589 int ret;
6590
6591 buffer = malloc(buffer_size);
6592
6593 tcp_socketpair(&client, &server);
6594 set_blocking(client, FALSE);
6595
6596 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6597 check_events(ctx, FD_WRITE, 0, 200);
6598 check_events(ctx, 0, 0, 0);
6599 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6600 if (ctx->is_message)
6601 check_events(ctx, FD_WRITE, 0, 200);
6602 check_events(ctx, 0, 0, 0);
6603 select_events(ctx, server, 0);
6604 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6605 if (ctx->is_message)
6606 check_events(ctx, FD_WRITE, 0, 200);
6607 check_events(ctx, 0, 0, 0);
6608
6609 ret = send(server, "data", 5, 0);
6610 ok(ret == 5, "got %d\n", ret);
6611
6612 check_events(ctx, 0, 0, 0);
6613
6614 ret = sync_recv(client, buffer, buffer_size, 0);
6615 ok(ret == 5, "got %d\n", ret);
6616
6617 check_events(ctx, 0, 0, 0);
6618
6619 if (!broken(1))
6620 {
6621 /* Windows will never send less than buffer_size bytes here, but Linux
6622 * may do a short write. */
6623 while ((ret = send(server, buffer, buffer_size, 0)) > 0);
6624 ok(ret == -1, "got %d\n", ret);
6625 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
6626
6627 while (recv(client, buffer, buffer_size, 0) > 0);
6628 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
6629
6630 /* Broken on Windows versions older than win10v1607 (though sometimes
6631 * works regardless, for unclear reasons. */
6632 check_events(ctx, FD_WRITE, 0, 200);
6633 check_events(ctx, 0, 0, 0);
6634 select_events(ctx, server, 0);
6635 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6636 if (ctx->is_message)
6637 check_events(ctx, FD_WRITE, 0, 200);
6638 check_events(ctx, 0, 0, 0);
6639 }
6640
6641 closesocket(server);
6642 closesocket(client);
6643
6644 /* Select on a subset not containing FD_WRITE first. */
6645
6646 tcp_socketpair(&client, &server);
6647 set_blocking(client, FALSE);
6648
6649 ret = send(client, "data", 5, 0);
6650 ok(ret == 5, "got %d\n", ret);
6651
6652 select_events(ctx, client, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ);
6653 if (!ctx->is_message)
6654 check_events(ctx, FD_CONNECT, 0, 200);
6655 check_events(ctx, 0, 0, 0);
6656
6657 select_events(ctx, client, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6658 check_events(ctx, FD_WRITE, 0, 200);
6659 check_events(ctx, 0, 0, 0);
6660
6661 closesocket(client);
6662 closesocket(server);
6663
6664 /* Despite the documentation, and unlike FD_ACCEPT and FD_RECV, calling
6665 * send() doesn't clear the FD_WRITE bit. */
6666
6667 tcp_socketpair(&client, &server);
6668
6669 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6670
6671 ret = send(server, "data", 5, 0);
6672 ok(ret == 5, "got %d\n", ret);
6673
6674 check_events(ctx, FD_WRITE, 0, 200);
6675
6676 closesocket(server);
6677 closesocket(client);
6678
6679 free(buffer);
6680 }
6681
6682 static void test_read_events(struct event_test_ctx *ctx)
6683 {
6684 OVERLAPPED overlapped = {0};
6685 SOCKET server, client;
6686 DWORD size, flags = 0;
6687 WSAPOLLFD pollfd;
6688 unsigned int i;
6689 char buffer[8];
6690 WSABUF wsabuf;
6691 HANDLE thread;
6692 int ret;
6693
6694 overlapped.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
6695
6696 tcp_socketpair(&client, &server);
6697 set_blocking(client, FALSE);
6698
6699 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6700 check_events(ctx, 0, 0, 0);
6701
6702 ret = send(client, "data", 5, 0);
6703 ok(ret == 5, "got %d\n", ret);
6704
6705 check_events(ctx, FD_READ, 0, 200);
6706 check_events(ctx, 0, 0, 0);
6707 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6708 if (ctx->is_message)
6709 check_events(ctx, FD_READ, 0, 200);
6710 check_events(ctx, 0, 0, 0);
6711 select_events(ctx, server, 0);
6712 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6713 if (ctx->is_message)
6714 check_events(ctx, FD_READ, 0, 200);
6715 check_events(ctx, 0, 0, 0);
6716
6717 ret = send(client, "data", 5, 0);
6718 ok(ret == 5, "got %d\n", ret);
6719
6720 if (!ctx->is_message)
6721 check_events_todo(ctx, FD_READ, 0, 200);
6722 check_events(ctx, 0, 0, 0);
6723
6724 ret = recv(server, buffer, 2, 0);
6725 ok(ret == 2, "got %d\n", ret);
6726
6727 check_events(ctx, FD_READ, 0, 200);
6728 check_events(ctx, 0, 0, 0);
6729
6730 ret = recv(server, buffer, -1, 0);
6731 ok(ret == -1, "got %d\n", ret);
6732 ok(WSAGetLastError() == WSAEFAULT || WSAGetLastError() == WSAENOBUFS /* < Windows 7 */,
6733 "got error %u\n", WSAGetLastError());
6734
6735 if (ctx->is_message)
6736 check_events_todo_msg(ctx, FD_READ, 0, 200);
6737 check_events(ctx, 0, 0, 0);
6738
6739 for (i = 0; i < 8; ++i)
6740 {
6741 ret = sync_recv(server, buffer, 1, 0);
6742 ok(ret == 1, "got %d\n", ret);
6743
6744 if (i < 7)
6745 check_events(ctx, FD_READ, 0, 200);
6746 check_events(ctx, 0, 0, 0);
6747 }
6748
6749 /* Send data while we're not selecting. */
6750
6751 select_events(ctx, server, 0);
6752 ret = send(client, "data", 5, 0);
6753 ok(ret == 5, "got %d\n", ret);
6754 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6755
6756 check_events(ctx, FD_READ, 0, 200);
6757
6758 ret = recv(server, buffer, 5, 0);
6759 ok(ret == 5, "got %d\n", ret);
6760
6761 select_events(ctx, server, 0);
6762 ret = send(client, "data", 5, 0);
6763 ok(ret == 5, "got %d\n", ret);
6764 ret = sync_recv(server, buffer, 5, 0);
6765 ok(ret == 5, "got %d\n", ret);
6766 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ);
6767
6768 check_events(ctx, 0, 0, 200);
6769
6770 /* Send data while we're polling for data but not selecting for FD_READ. */
6771
6772 pollfd.fd = server;
6773 pollfd.events = POLLIN;
6774 thread = CreateThread(NULL, 0, poll_async_thread, &pollfd, 0, NULL);
6775
6776 select_events(ctx, server, 0);
6777 ret = send(client, "data", 5, 0);
6778 ok(ret == 5, "got %d\n", ret);
6779
6780 ret = WaitForSingleObject(thread, 1000);
6781 ok(!ret, "wait timed out\n");
6782 CloseHandle(thread);
6783
6784 /* And check events, to show that WSAEnumNetworkEvents() should not clear
6785 * events we are not currently selecting for. */
6786 check_events(ctx, 0, 0, 0);
6787
6788 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6789 check_events(ctx, FD_READ, FD_WRITE, 200);
6790 check_events(ctx, 0, 0, 0);
6791
6792 ret = sync_recv(server, buffer, 5, 0);
6793 ok(ret == 5, "got %d\n", ret);
6794
6795 /* Send data while there is a pending WSARecv(). */
6796
6797 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6798
6799 wsabuf.buf = buffer;
6800 wsabuf.len = 1;
6801 ret = WSARecv(server, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
6802 ok(ret == -1, "got %d\n", ret);
6803 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
6804
6805 ret = send(client, "a", 1, 0);
6806 ok(ret == 1, "got %d\n", ret);
6807
6808 ret = WaitForSingleObject(overlapped.hEvent, 200);
6809 ok(!ret, "got %d\n", ret);
6810 ret = GetOverlappedResult((HANDLE)server, &overlapped, &size, FALSE);
6811 ok(ret, "got error %lu\n", GetLastError());
6812 ok(size == 1, "got size %lu\n", size);
6813
6814 check_events(ctx, 0, 0, 0);
6815
6816 ret = send(client, "a", 1, 0);
6817 ok(ret == 1, "got %d\n", ret);
6818
6819 check_events(ctx, FD_READ, 0, 200);
6820 check_events(ctx, 0, 0, 0);
6821
6822 closesocket(server);
6823 closesocket(client);
6824 CloseHandle(overlapped.hEvent);
6825 }
6826
6827 static void test_oob_events(struct event_test_ctx *ctx)
6828 {
6829 SOCKET server, client;
6830 char buffer[1];
6831 int ret;
6832
6833 tcp_socketpair(&client, &server);
6834 set_blocking(client, FALSE);
6835
6836 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6837 check_events(ctx, 0, 0, 0);
6838
6839 ret = send(client, "a", 1, MSG_OOB);
6840 ok(ret == 1, "got %d\n", ret);
6841
6842 check_events(ctx, FD_OOB, 0, 200);
6843 check_events(ctx, 0, 0, 0);
6844 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6845 if (ctx->is_message)
6846 check_events(ctx, FD_OOB, 0, 200);
6847 check_events(ctx, 0, 0, 0);
6848 select_events(ctx, server, 0);
6849 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6850 if (ctx->is_message)
6851 check_events(ctx, FD_OOB, 0, 200);
6852 check_events(ctx, 0, 0, 0);
6853
6854 ret = send(client, "b", 1, MSG_OOB);
6855 ok(ret == 1, "got %d\n", ret);
6856
6857 if (!ctx->is_message)
6858 check_events_todo_event(ctx, FD_OOB, 0, 200);
6859 check_events(ctx, 0, 0, 0);
6860
6861 ret = recv(server, buffer, 1, MSG_OOB);
6862 ok(ret == 1, "got %d\n", ret);
6863
6864 check_events_todo(ctx, FD_OOB, 0, 200);
6865 check_events(ctx, 0, 0, 0);
6866
6867 ret = recv(server, buffer, 1, MSG_OOB);
6868 todo_wine ok(ret == 1, "got %d\n", ret);
6869
6870 check_events(ctx, 0, 0, 0);
6871
6872 /* Send data while we're not selecting. */
6873
6874 select_events(ctx, server, 0);
6875 ret = send(client, "a", 1, MSG_OOB);
6876 ok(ret == 1, "got %d\n", ret);
6877 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6878
6879 check_events(ctx, FD_OOB, 0, 200);
6880
6881 ret = recv(server, buffer, 1, MSG_OOB);
6882 ok(ret == 1, "got %d\n", ret);
6883
6884 closesocket(server);
6885 closesocket(client);
6886 }
6887
6888 static void test_close_events(struct event_test_ctx *ctx)
6889 {
6890 SOCKET server, client;
6891 char buffer[5];
6892 int ret;
6893
6894 /* Test closesocket(). */
6895
6896 tcp_socketpair(&client, &server);
6897
6898 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6899
6900 closesocket(client);
6901
6902 check_events(ctx, FD_CLOSE, 0, 1000);
6903 check_events(ctx, 0, 0, 0);
6904 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6905 if (ctx->is_message)
6906 check_events(ctx, FD_CLOSE, 0, 200);
6907 check_events(ctx, 0, 0, 0);
6908 select_events(ctx, server, 0);
6909 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6910 if (ctx->is_message)
6911 check_events(ctx, FD_CLOSE, 0, 200);
6912 check_events(ctx, 0, 0, 0);
6913
6914 ret = recv(server, buffer, 5, 0);
6915 ok(!ret, "got %d\n", ret);
6916
6917 check_events(ctx, 0, 0, 0);
6918
6919 closesocket(server);
6920
6921 /* Test shutdown(remote end, SD_SEND). */
6922
6923 tcp_socketpair(&client, &server);
6924
6925 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6926
6927 shutdown(client, SD_SEND);
6928
6929 check_events(ctx, FD_CLOSE, 0, 1000);
6930 check_events(ctx, 0, 0, 0);
6931
6932 closesocket(client);
6933
6934 check_events(ctx, 0, 0, 0);
6935
6936 closesocket(server);
6937
6938 /* No other shutdown() call generates an event. */
6939
6940 tcp_socketpair(&client, &server);
6941
6942 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6943
6944 shutdown(client, SD_RECEIVE);
6945 shutdown(server, SD_BOTH);
6946
6947 check_events(ctx, 0, 0, 200);
6948
6949 shutdown(client, SD_SEND);
6950
6951 check_events_todo(ctx, FD_CLOSE, 0, 200);
6952 check_events(ctx, 0, 0, 0);
6953
6954 closesocket(server);
6955 closesocket(client);
6956
6957 /* Test sending data before calling closesocket(). */
6958
6959 tcp_socketpair(&client, &server);
6960
6961 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6962
6963 ret = send(client, "data", 5, 0);
6964 ok(ret == 5, "got %d\n", ret);
6965
6966 check_events(ctx, FD_READ, 0, 200);
6967
6968 closesocket(client);
6969
6970 check_events_todo(ctx, FD_CLOSE, 0, 200);
6971
6972 ret = recv(server, buffer, 3, 0);
6973 ok(ret == 3, "got %d\n", ret);
6974
6975 check_events(ctx, FD_READ, 0, 200);
6976
6977 ret = recv(server, buffer, 5, 0);
6978 ok(ret == 2, "got %d\n", ret);
6979
6980 check_events_todo(ctx, 0, 0, !strcmp(winetest_platform, "wine") ? 200 : 0);
6981
6982 closesocket(server);
6983
6984 /* Close and then select. */
6985
6986 tcp_socketpair(&client, &server);
6987 closesocket(client);
6988
6989 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6990 check_events(ctx, FD_CLOSE, 0, 200);
6991
6992 closesocket(server);
6993
6994 /* As above, but select on a subset not containing FD_CLOSE first. */
6995
6996 tcp_socketpair(&client, &server);
6997
6998 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ);
6999
7000 closesocket(client);
7001
7002 check_events(ctx, 0, 0, 200);
7003 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7004 check_events(ctx, FD_CLOSE, 0, 200);
7005
7006 closesocket(server);
7007
7008 /* Trigger RST. */
7009
7010 tcp_socketpair(&client, &server);
7011
7012 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7013
7014 close_with_rst(client);
7015
7016 check_events_todo_msg(ctx, MAKELONG(FD_CLOSE, WSAECONNABORTED), 0, 200);
7017 check_events(ctx, 0, 0, 0);
7018 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7019 if (ctx->is_message)
7020 check_events_todo(ctx, MAKELONG(FD_CLOSE, WSAECONNABORTED), 0, 200);
7021 check_events(ctx, 0, 0, 0);
7022 select_events(ctx, server, 0);
7023 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7024 if (ctx->is_message)
7025 check_events_todo(ctx, MAKELONG(FD_CLOSE, WSAECONNABORTED), 0, 200);
7026 check_events(ctx, 0, 0, 0);
7027
7028 closesocket(server);
7029 }
7030
7031 static void test_events(void)
7032 {
7033 struct event_test_ctx ctx;
7034
7035 ctx.is_message = FALSE;
7036 ctx.event = CreateEventW(NULL, TRUE, FALSE, NULL);
7037
7038 test_accept_events(&ctx);
7039 test_connect_events(&ctx);
7040 test_write_events(&ctx);
7041 test_read_events(&ctx);
7042 test_close_events(&ctx);
7043 test_oob_events(&ctx);
7044
7045 CloseHandle(ctx.event);
7046
7047 ctx.is_message = TRUE;
7048 ctx.window = CreateWindowA("Message", NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, NULL, NULL);
7049
7050 test_accept_events(&ctx);
7051 test_connect_events(&ctx);
7052 test_write_events(&ctx);
7053 test_read_events(&ctx);
7054 test_close_events(&ctx);
7055 test_oob_events(&ctx);
7056
7057 DestroyWindow(ctx.window);
7058 }
7059
7060 static void test_ipv6only(void)
7061 {
7062 SOCKET v4 = INVALID_SOCKET, v6;
7063 struct sockaddr_in sin4;
7064 struct sockaddr_in6 sin6;
7065 int ret, enabled, len = sizeof(enabled);
7066
7067 memset(&sin4, 0, sizeof(sin4));
7068 sin4.sin_family = AF_INET;
7069 sin4.sin_port = htons(SERVERPORT);
7070
7071 memset(&sin6, 0, sizeof(sin6));
7072 sin6.sin6_family = AF_INET6;
7073 sin6.sin6_port = htons(SERVERPORT);
7074
7075 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
7076 if (v6 == INVALID_SOCKET)
7077 {
7078 skip("Could not create IPv6 socket (LastError: %d)\n", WSAGetLastError());
7079 goto end;
7080 }
7081
7082 enabled = 2;
7083 ret = getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7084 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7085 ok(enabled == 1, "expected 1, got %d\n", enabled);
7086
7087 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
7088 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
7089
7090 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7091 ok(v4 != INVALID_SOCKET, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
7092
7093 todo_wine {
7094 enabled = 2;
7095 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7096 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7097 ok(enabled == 1, "expected 1, got %d\n", enabled);
7098 }
7099
7100 enabled = 0;
7101 len = sizeof(enabled);
7102 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7103 ok(!ret, "setsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7104
7105 todo_wine {
7106 enabled = 2;
7107 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7108 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7109 ok(!enabled, "expected 0, got %d\n", enabled);
7110 }
7111
7112 enabled = 1;
7113 len = sizeof(enabled);
7114 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7115 ok(!ret, "setsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7116
7117 /* bind on IPv4 socket should succeed - IPV6_V6ONLY is enabled by default */
7118 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
7119 ok(!ret, "Could not bind IPv4 address (LastError: %d)\n", WSAGetLastError());
7120
7121 todo_wine {
7122 enabled = 2;
7123 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7124 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7125 ok(enabled == 1, "expected 1, got %d\n", enabled);
7126 }
7127
7128 enabled = 0;
7129 len = sizeof(enabled);
7130 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7131 ok(ret, "setsockopt(IPV6_V6ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
7132
7133 todo_wine {
7134 enabled = 0;
7135 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7136 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7137 ok(enabled == 1, "expected 1, got %d\n", enabled);
7138 }
7139
7140 enabled = 1;
7141 len = sizeof(enabled);
7142 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7143 ok(ret, "setsockopt(IPV6_V6ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
7144
7145 closesocket(v4);
7146 closesocket(v6);
7147
7148 /* Test again, this time disabling IPV6_V6ONLY. */
7149 sin4.sin_port = htons(SERVERPORT+2);
7150 sin6.sin6_port = htons(SERVERPORT+2);
7151
7152 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
7153 ok(v6 != INVALID_SOCKET, "Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
7154 WSAGetLastError(), WSAEAFNOSUPPORT);
7155
7156 enabled = 0;
7157 ret = setsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7158 ok(!ret, "Could not disable IPV6_V6ONLY (LastError: %d).\n", WSAGetLastError());
7159
7160 enabled = 2;
7161 ret = getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7162 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7163 ok(!enabled, "expected 0, got %d\n", enabled);
7164
7165 /*
7166 Observaition:
7167 On Windows, bind on both IPv4 and IPv6 with IPV6_V6ONLY disabled succeeds by default.
7168 Application must set SO_EXCLUSIVEADDRUSE on first socket to disallow another successful bind.
7169 In general, a standard application should not use SO_REUSEADDR.
7170 Setting both SO_EXCLUSIVEADDRUSE and SO_REUSEADDR on the same socket is not possible in
7171 either order, the later setsockopt call always fails.
7172 */
7173 enabled = 1;
7174 ret = setsockopt(v6, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&enabled, len);
7175 ok(!ret, "Could not set SO_EXCLUSIVEADDRUSE on IPv6 socket (LastError: %d)\n", WSAGetLastError());
7176
7177 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
7178 ok(!ret, "Could not bind IPv6 address (LastError: %d)\n", WSAGetLastError());
7179
7180 enabled = 2;
7181 len = sizeof(enabled);
7182 getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7183 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7184 ok(!enabled, "IPV6_V6ONLY is enabled after bind\n");
7185
7186 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7187 ok(v4 != INVALID_SOCKET, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
7188
7189 enabled = 1;
7190 ret = setsockopt(v4, SOL_SOCKET, SO_REUSEADDR, (char*)&enabled, len);
7191 ok(!ret, "Could not set SO_REUSEADDR on IPv4 socket (LastError: %d)\n", WSAGetLastError());
7192
7193 WSASetLastError(0xdeadbeef);
7194 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
7195 ok(ret, "bind succeeded unexpectedly for the IPv4 socket\n");
7196 ok(WSAGetLastError() == WSAEACCES, "Expected 10013, got %d\n", WSAGetLastError());
7197
7198 end:
7199 if (v4 != INVALID_SOCKET)
7200 closesocket(v4);
7201 if (v6 != INVALID_SOCKET)
7202 closesocket(v6);
7203 }
7204
7205 static void test_WSASendMsg(void)
7206 {
7207 SOCKET sock, dst;
7208 struct sockaddr_in sendaddr, sockaddr;
7209 GUID WSASendMsg_GUID = WSAID_WSASENDMSG;
7210 LPFN_WSASENDMSG pWSASendMsg = NULL;
7211 char teststr[12] = "hello world", buffer[32];
7212 WSABUF iovec[2];
7213 WSAMSG msg;
7214 DWORD bytesSent, err;
7215 int ret, addrlen;
7216
7217 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
7218
7219 sock = socket(AF_INET, SOCK_DGRAM, 0);
7220 ok(sock != INVALID_SOCKET, "socket() failed\n");
7221
7222 /* Obtain the WSASendMsg function */
7223 WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSASendMsg_GUID, sizeof(WSASendMsg_GUID),
7224 &pWSASendMsg, sizeof(pWSASendMsg), &err, NULL, NULL);
7225 if (!pWSASendMsg)
7226 {
7227 closesocket(sock);
7228 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
7229 return;
7230 }
7231
7232 /* fake address for now */
7233 sendaddr.sin_family = AF_INET;
7234 sendaddr.sin_port = htons(139);
7235 sendaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
7236
7237 memset(&msg, 0, sizeof(msg));
7238 iovec[0].buf = teststr;
7239 iovec[0].len = sizeof(teststr);
7240 iovec[1].buf = teststr;
7241 iovec[1].len = sizeof(teststr) / 2;
7242 msg.name = (struct sockaddr *) &sendaddr;
7243 msg.namelen = sizeof(sendaddr);
7244 msg.lpBuffers = iovec;
7245 msg.dwBufferCount = 1; /* send only one buffer for now */
7246
7247 WSASetLastError(0xdeadbeef);
7248 ret = pWSASendMsg(INVALID_SOCKET, &msg, 0, NULL, NULL, NULL);
7249 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7250 err = WSAGetLastError();
7251 ok(err == WSAENOTSOCK, "expected 10038, got %ld instead\n", err);
7252
7253 WSASetLastError(0xdeadbeef);
7254 ret = pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL);
7255 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7256 err = WSAGetLastError();
7257 ok(err == WSAEFAULT, "expected 10014, got %ld instead\n", err);
7258
7259 WSASetLastError(0xdeadbeef);
7260 ret = pWSASendMsg(sock, NULL, 0, &bytesSent, NULL, NULL);
7261 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7262 err = WSAGetLastError();
7263 ok(err == WSAEFAULT, "expected 10014, got %ld instead\n", err);
7264
7265 WSASetLastError(0xdeadbeef);
7266 ret = pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL);
7267 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7268 err = WSAGetLastError();
7269 ok(err == WSAEFAULT, "expected 10014, got %ld instead\n", err);
7270
7271 closesocket(sock);
7272
7273 sock = socket(AF_INET, SOCK_DGRAM, 0);
7274 ok(sock != INVALID_SOCKET, "socket() failed\n");
7275
7276 dst = socket(AF_INET, SOCK_DGRAM, 0);
7277 ok(dst != INVALID_SOCKET, "socket() failed\n");
7278
7279 memset(&sockaddr, 0, sizeof(sockaddr));
7280 sockaddr.sin_family = AF_INET;
7281 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
7282 ok(!bind(dst, (struct sockaddr*)&sockaddr, sizeof(sockaddr)),
7283 "bind should have worked\n");
7284
7285 /* read address to find out the port number to be used in send */
7286 memset(&sendaddr, 0, sizeof(sendaddr));
7287 addrlen = sizeof(sendaddr);
7288 ok(!getsockname(dst, (struct sockaddr *) &sendaddr, &addrlen),
7289 "getsockname should have worked\n");
7290 ok(sendaddr.sin_port, "socket port should be != 0\n");
7291
7292 /* ensure the sending socket is not bound */
7293 WSASetLastError(0xdeadbeef);
7294 addrlen = sizeof(sockaddr);
7295 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
7296 ok(ret == SOCKET_ERROR, "getsockname should have failed\n");
7297 err = WSAGetLastError();
7298 ok(err == WSAEINVAL, "expected 10022, got %ld instead\n", err);
7299
7300 set_blocking(sock, TRUE);
7301
7302 bytesSent = 0;
7303 SetLastError(0xdeadbeef);
7304 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
7305 ok(!ret, "WSASendMsg should have worked\n");
7306 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
7307 "Expected 0, got %ld\n", GetLastError());
7308 ok(bytesSent == iovec[0].len, "incorrect bytes sent, expected %ld, sent %ld\n",
7309 iovec[0].len, bytesSent);
7310
7311 /* receive data */
7312 addrlen = sizeof(sockaddr);
7313 memset(buffer, 0, sizeof(buffer));
7314 SetLastError(0xdeadbeef);
7315 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
7316 ok(ret == bytesSent, "got %d, expected %ld\n",
7317 ret, bytesSent);
7318 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7319
7320 /* A successful call to WSASendMsg must have bound the socket */
7321 addrlen = sizeof(sockaddr);
7322 sockaddr.sin_port = 0;
7323 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
7324 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
7325 ok(!ret, "getsockname should have worked\n");
7326 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
7327 inet_ntoa(sockaddr.sin_addr));
7328 ok(sockaddr.sin_port, "sin_port should be != 0\n");
7329
7330 msg.dwBufferCount = 2; /* send both buffers */
7331
7332 bytesSent = 0;
7333 SetLastError(0xdeadbeef);
7334 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
7335 ok(!ret, "WSASendMsg should have worked\n");
7336 ok(bytesSent == iovec[0].len + iovec[1].len, "incorrect bytes sent, expected %ld, sent %ld\n",
7337 iovec[0].len + iovec[1].len, bytesSent);
7338 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
7339 "Expected 0, got %ld\n", GetLastError());
7340
7341 /* receive data */
7342 addrlen = sizeof(sockaddr);
7343 memset(buffer, 0, sizeof(buffer));
7344 SetLastError(0xdeadbeef);
7345 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
7346 ok(ret == bytesSent, "got %d, expected %ld\n",
7347 ret, bytesSent);
7348 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7349
7350 closesocket(sock);
7351 closesocket(dst);
7352
7353 /* a bad call to WSASendMsg will also bind the socket */
7354 addrlen = sizeof(sockaddr);
7355 sockaddr.sin_port = 0;
7356 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
7357 sock = socket(AF_INET, SOCK_DGRAM, 0);
7358 ok(sock != INVALID_SOCKET, "socket() failed\n");
7359 ok(pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
7360 todo_wine {
7361 ok(!getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have worked\n");
7362 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
7363 inet_ntoa(sockaddr.sin_addr));
7364 ok(sockaddr.sin_port, "sin_port should be > 0\n");
7365 }
7366 closesocket(sock);
7367
7368 /* a bad call without msg parameter will not trigger the auto-bind */
7369 sock = socket(AF_INET, SOCK_DGRAM, 0);
7370 ok(sock != INVALID_SOCKET, "socket() failed\n");
7371 ok(pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
7372 ok(getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have failed\n");
7373 err = WSAGetLastError();
7374 ok(err == WSAEINVAL, "expected 10022, got %ld instead\n", err);
7375 closesocket(sock);
7376
7377 /* SOCK_STREAM sockets are not supported */
7378 bytesSent = 0;
7379 sock = socket(AF_INET, SOCK_STREAM, 0);
7380 ok(sock != INVALID_SOCKET, "socket() failed\n");
7381 SetLastError(0xdeadbeef);
7382 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
7383 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7384 err = WSAGetLastError();
7385 todo_wine
7386 ok(err == WSAEINVAL, "expected 10014, got %ld instead\n", err);
7387 closesocket(sock);
7388 }
7389
7390 static void test_WSASendTo(void)
7391 {
7392 SOCKET s;
7393 struct sockaddr_in addr, ret_addr;
7394 char buf[12] = "hello world";
7395 WSABUF data_buf;
7396 DWORD bytesSent;
7397 int ret, len;
7398
7399 addr.sin_family = AF_INET;
7400 addr.sin_port = htons(139);
7401 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
7402 data_buf.len = sizeof(buf);
7403 data_buf.buf = buf;
7404
7405 s = socket(AF_INET, SOCK_DGRAM, 0);
7406 ok(s != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
7407
7408 WSASetLastError(12345);
7409 ret = WSASendTo(INVALID_SOCKET, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
7410 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
7411 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
7412
7413 len = sizeof(ret_addr);
7414 ret = getsockname(s, (struct sockaddr *)&ret_addr, &len);
7415 ok(ret == -1, "expected failure\n");
7416 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
7417
7418 WSASetLastError(12345);
7419 ret = WSASendTo(s, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
7420 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
7421 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
7422
7423 WSASetLastError(12345);
7424 ret = WSASendTo(s, &data_buf, 1, &bytesSent, 0, (struct sockaddr *)&addr, sizeof(addr), NULL, NULL);
7425 ok(!ret, "expected success\n");
7426 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
7427
7428 len = sizeof(ret_addr);
7429 ret = getsockname(s, (struct sockaddr *)&ret_addr, &len);
7430 ok(!ret, "got error %u\n", WSAGetLastError());
7431 ok(ret_addr.sin_family == AF_INET, "got family %u\n", ret_addr.sin_family);
7432 ok(ret_addr.sin_port, "expected nonzero port\n");
7433 }
7434
7435 struct recv_thread_apc_param
7436 {
7437 SOCKET sock;
7438 unsigned int apc_count;
7439 };
7440
7441 static void WINAPI recv_thread_apc_func(ULONG_PTR param)
7442 {
7443 struct recv_thread_apc_param *p = (struct recv_thread_apc_param *)param;
7444 int ret;
7445
7446 ++p->apc_count;
7447
7448 ret = send(p->sock, "test", 4, 0);
7449 ok(ret == 4, "got %d.\n", ret);
7450 }
7451
7452 struct recv_thread_param
7453 {
7454 SOCKET sock;
7455 BOOL overlapped;
7456 };
7457
7458 static DWORD WINAPI recv_thread(LPVOID arg)
7459 {
7460 struct recv_thread_param *p = arg;
7461 SOCKET sock = p->sock;
7462 char buffer[32];
7463 WSABUF wsa;
7464 WSAOVERLAPPED ov;
7465 DWORD flags = 0;
7466 DWORD len;
7467 int ret;
7468
7469 wsa.buf = buffer;
7470 wsa.len = sizeof(buffer);
7471 if (p->overlapped)
7472 {
7473 ov.hEvent = WSACreateEvent();
7474 WSARecv(sock, &wsa, 1, NULL, &flags, &ov, NULL);
7475
7476 WaitForSingleObject(ov.hEvent, 1000);
7477 WSACloseEvent(ov.hEvent);
7478 }
7479 else
7480 {
7481 SetLastError(0xdeadbeef);
7482 ret = WSARecv(sock, &wsa, 1, &len, &flags, NULL, NULL);
7483 ok(!ret, "got ret %d.\n", ret);
7484 ok(WSAGetLastError() == 0, "got error %d.\n", WSAGetLastError());
7485 ok(len == 4, "got len %lu.\n", len);
7486 }
7487 return 0;
7488 }
7489
7490 static int completion_called;
7491
7492 static void WINAPI io_completion(DWORD error, DWORD transferred, WSAOVERLAPPED *overlapped, DWORD flags)
7493 {
7494 completion_called++;
7495 }
7496
7497 static void test_WSARecv(void)
7498 {
7499 SOCKET src, dest, server = INVALID_SOCKET;
7500 struct recv_thread_apc_param apc_param;
7501 struct recv_thread_param recv_param;
7502 char buf[20];
7503 WSABUF bufs[2];
7504 WSAOVERLAPPED ov;
7505 DWORD bytesReturned, flags, id;
7506 struct sockaddr_in addr;
7507 unsigned int apc_count;
7508 int iret, len;
7509 DWORD dwret;
7510 BOOL bret;
7511 HANDLE thread, event = NULL, io_port;
7512
7513 tcp_socketpair(&src, &dest);
7514
7515 memset(&ov, 0, sizeof(ov));
7516 flags = 0;
7517 bufs[0].len = 2;
7518 bufs[0].buf = buf;
7519
7520 /* Send 4 bytes and receive in two calls of 2 */
7521 SetLastError(0xdeadbeef);
7522 iret = send(src, "test", 4, 0);
7523 ok(iret == 4, "Expected 4, got %d\n", iret);
7524 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7525 SetLastError(0xdeadbeef);
7526 bytesReturned = 0xdeadbeef;
7527
7528 apc_count = 0;
7529 dwret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
7530 ok(dwret, "QueueUserAPC returned %lu\n", dwret);
7531
7532 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
7533 ok(!iret, "Expected 0, got %d\n", iret);
7534 ok(bytesReturned == 2, "Expected 2, got %ld\n", bytesReturned);
7535 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7536
7537 ok(!apc_count, "got apc_count %u.\n", apc_count);
7538 SleepEx(0, TRUE);
7539 ok(apc_count == 1, "got apc_count %u.\n", apc_count);
7540
7541 SetLastError(0xdeadbeef);
7542 bytesReturned = 0xdeadbeef;
7543 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
7544 ok(!iret, "Expected 0, got %d\n", iret);
7545 ok(bytesReturned == 2, "Expected 2, got %ld\n", bytesReturned);
7546 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7547
7548 bufs[0].len = 4;
7549 SetLastError(0xdeadbeef);
7550 iret = send(src, "test", 4, 0);
7551 ok(iret == 4, "Expected 4, got %d\n", iret);
7552 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7553 SetLastError(0xdeadbeef);
7554 bytesReturned = 0xdeadbeef;
7555 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
7556 ok(!iret, "Expected 0, got %d\n", iret);
7557 ok(bytesReturned == 4, "Expected 4, got %ld\n", bytesReturned);
7558 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7559
7560 /* Test 2 buffers */
7561 bufs[0].len = 4;
7562 bufs[1].len = 5;
7563 bufs[1].buf = buf + 10;
7564 SetLastError(0xdeadbeef);
7565 iret = send(src, "deadbeefs", 9, 0);
7566 ok(iret == 9, "Expected 9, got %d\n", iret);
7567 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7568 SetLastError(0xdeadbeef);
7569 bytesReturned = 0xdeadbeef;
7570 iret = WSARecv(dest, bufs, 2, &bytesReturned, &flags, NULL, NULL);
7571 ok(!iret, "Expected 0, got %d\n", iret);
7572 ok(bytesReturned == 9, "Expected 9, got %ld\n", bytesReturned);
7573 bufs[0].buf[4] = '\0';
7574 bufs[1].buf[5] = '\0';
7575 ok(!strcmp(bufs[0].buf, "dead"), "buf[0] doesn't match: %s != dead\n", bufs[0].buf);
7576 ok(!strcmp(bufs[1].buf, "beefs"), "buf[1] doesn't match: %s != beefs\n", bufs[1].buf);
7577 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7578
7579 bufs[0].len = sizeof(buf);
7580 ov.hEvent = event = CreateEventA(NULL, FALSE, FALSE, NULL);
7581 ok(ov.hEvent != NULL, "could not create event object, errno = %ld\n", GetLastError());
7582 if (!event)
7583 goto end;
7584
7585 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, NULL);
7586 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %ld\n", iret, GetLastError());
7587
7588 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, &ov, NULL);
7589 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %ld\n", iret, GetLastError());
7590
7591 close_with_rst(src);
7592
7593 dwret = WaitForSingleObject(ov.hEvent, 1000);
7594 ok(dwret == WAIT_OBJECT_0, "Waiting for disconnect event failed with %ld + errno %ld\n", dwret, GetLastError());
7595
7596 bret = GetOverlappedResult((HANDLE)dest, &ov, &bytesReturned, FALSE);
7597 ok(!bret, "expected failure\n");
7598 ok(GetLastError() == ERROR_NETNAME_DELETED, "got error %lu\n", GetLastError());
7599 ok(bytesReturned == 0, "Bytes received is %ld\n", bytesReturned);
7600 closesocket(dest);
7601 dest = INVALID_SOCKET;
7602
7603 src = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
7604 ok(src != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
7605 if (src == INVALID_SOCKET) goto end;
7606
7607 server = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
7608 ok(server != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
7609 if (server == INVALID_SOCKET) goto end;
7610
7611 memset(&addr, 0, sizeof(addr));
7612 addr.sin_family = AF_INET;
7613 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
7614 iret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
7615 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
7616
7617 len = sizeof(addr);
7618 iret = getsockname(server, (struct sockaddr *)&addr, &len);
7619 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
7620
7621 iret = listen(server, 1);
7622 ok(!iret, "failed to listen, error %u\n", WSAGetLastError());
7623
7624 iret = connect(src, (struct sockaddr *)&addr, sizeof(addr));
7625 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
7626
7627 len = sizeof(addr);
7628 dest = accept(server, (struct sockaddr *)&addr, &len);
7629 ok(dest != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
7630 if (dest == INVALID_SOCKET) goto end;
7631
7632 send(src, "test message", sizeof("test message"), 0);
7633 recv_param.sock = dest;
7634 recv_param.overlapped = TRUE;
7635 thread = CreateThread(NULL, 0, recv_thread, &recv_param, 0, &id);
7636 WaitForSingleObject(thread, 3000);
7637 CloseHandle(thread);
7638
7639 recv_param.overlapped = FALSE;
7640 thread = CreateThread(NULL, 0, recv_thread, &recv_param, 0, &id);
7641 apc_param.apc_count = 0;
7642 apc_param.sock = src;
7643 dwret = QueueUserAPC(recv_thread_apc_func, thread, (ULONG_PTR)&apc_param);
7644 ok(dwret, "QueueUserAPC returned %lu\n", dwret);
7645 WaitForSingleObject(thread, 3000);
7646 ok(apc_param.apc_count == 1, "got apc_count %u.\n", apc_param.apc_count);
7647
7648 CloseHandle(thread);
7649
7650 memset(&ov, 0, sizeof(ov));
7651 ov.hEvent = event;
7652 ResetEvent(event);
7653 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, io_completion);
7654 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %ld\n", iret, GetLastError());
7655 send(src, "test message", sizeof("test message"), 0);
7656
7657 completion_called = 0;
7658 dwret = SleepEx(1000, TRUE);
7659 ok(dwret == WAIT_IO_COMPLETION, "got %lu\n", dwret);
7660 ok(completion_called == 1, "completion not called\n");
7661
7662 dwret = WaitForSingleObject(event, 1);
7663 ok(dwret == WAIT_TIMEOUT, "got %lu\n", dwret);
7664
7665 io_port = CreateIoCompletionPort( (HANDLE)dest, NULL, 0, 0 );
7666 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
7667
7668 /* Using completion function on socket associated with completion port is not allowed. */
7669 memset(&ov, 0, sizeof(ov));
7670 completion_called = 0;
7671 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, io_completion);
7672 ok(iret == SOCKET_ERROR && GetLastError() == WSAEINVAL, "WSARecv failed - %d error %ld\n", iret, GetLastError());
7673 ok(!completion_called, "completion called\n");
7674
7675 CloseHandle(io_port);
7676
7677 end:
7678 if (server != INVALID_SOCKET)
7679 closesocket(server);
7680 if (dest != INVALID_SOCKET)
7681 closesocket(dest);
7682 if (src != INVALID_SOCKET)
7683 closesocket(src);
7684 if (event)
7685 WSACloseEvent(event);
7686 }
7687
7688 struct write_watch_thread_args
7689 {
7690 int func;
7691 SOCKET dest;
7692 void *base;
7693 DWORD size;
7694 const char *expect;
7695 };
7696
7697 static DWORD CALLBACK write_watch_thread( void *arg )
7698 {
7699 struct write_watch_thread_args *args = arg;
7700 struct sockaddr addr;
7701 int addr_len = sizeof(addr), ret;
7702 DWORD bytes, flags = 0;
7703 WSABUF buf[1];
7704
7705 switch (args->func)
7706 {
7707 case 0:
7708 ret = recv( args->dest, args->base, args->size, 0 );
7709 ok( ret == strlen(args->expect) + 1, "wrong len %d\n", ret );
7710 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
7711 break;
7712 case 1:
7713 ret = recvfrom( args->dest, args->base, args->size, 0, &addr, &addr_len );
7714 ok( ret == strlen(args->expect) + 1, "wrong len %d\n", ret );
7715 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
7716 break;
7717 case 2:
7718 buf[0].len = args->size;
7719 buf[0].buf = args->base;
7720 ret = WSARecv( args->dest, buf, 1, &bytes, &flags, NULL, NULL );
7721 ok( !ret, "WSARecv failed %lu\n", GetLastError() );
7722 ok( bytes == strlen(args->expect) + 1, "wrong len %ld\n", bytes );
7723 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
7724 break;
7725 case 3:
7726 buf[0].len = args->size;
7727 buf[0].buf = args->base;
7728 ret = WSARecvFrom( args->dest, buf, 1, &bytes, &flags, &addr, &addr_len, NULL, NULL );
7729 ok( !ret, "WSARecvFrom failed %lu\n", GetLastError() );
7730 ok( bytes == strlen(args->expect) + 1, "wrong len %ld\n", bytes );
7731 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
7732 break;
7733 }
7734 return 0;
7735 }
7736
7737 static void test_write_watch(void)
7738 {
7739 SOCKET src, dest;
7740 WSABUF bufs[2];
7741 WSAOVERLAPPED ov;
7742 struct write_watch_thread_args args;
7743 DWORD bytesReturned, flags, size;
7744 struct sockaddr addr;
7745 int addr_len, ret;
7746 HANDLE thread, event;
7747 char *base;
7748 void *results[64];
7749 ULONG_PTR count;
7750 ULONG pagesize;
7751 UINT (WINAPI *pGetWriteWatch)(DWORD,LPVOID,SIZE_T,LPVOID*,ULONG_PTR*,ULONG*);
7752
7753 pGetWriteWatch = (void *)GetProcAddress( GetModuleHandleA("kernel32.dll"), "GetWriteWatch" );
7754 if (!pGetWriteWatch)
7755 {
7756 win_skip( "write watched not supported\n" );
7757 return;
7758 }
7759
7760 /* Windows 11 no longer triggers write watches anymore. */
7761
7762 tcp_socketpair(&src, &dest);
7763
7764 memset(&ov, 0, sizeof(ov));
7765 ov.hEvent = event = CreateEventA(NULL, FALSE, FALSE, NULL);
7766 ok(ov.hEvent != NULL, "could not create event object, errno = %ld\n", GetLastError());
7767
7768 flags = 0;
7769
7770 size = 0x10000;
7771 base = VirtualAlloc( 0, size, MEM_RESERVE | MEM_COMMIT | MEM_WRITE_WATCH, PAGE_READWRITE );
7772 ok( base != NULL, "VirtualAlloc failed %lu\n", GetLastError() );
7773
7774 memset( base, 0, size );
7775 count = 64;
7776 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7777 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7778 ok( count == 16, "wrong count %Iu\n", count );
7779
7780 bufs[0].len = 5;
7781 bufs[0].buf = base;
7782 bufs[1].len = 0x8000;
7783 bufs[1].buf = base + 0x4000;
7784
7785 ret = WSARecv( dest, bufs, 2, NULL, &flags, &ov, NULL);
7786 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
7787 "WSARecv failed - %d error %ld\n", ret, GetLastError());
7788
7789 count = 64;
7790 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7791 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7792 ok( count == 9 || !count /* Win 11 */, "wrong count %Iu\n", count );
7793 ok( !base[0], "data set\n" );
7794
7795 send(src, "test message", sizeof("test message"), 0);
7796
7797 ret = GetOverlappedResult( (HANDLE)dest, &ov, &bytesReturned, TRUE );
7798 ok( ret, "GetOverlappedResult failed %lu\n", GetLastError() );
7799 ok( bytesReturned == sizeof("test message"), "wrong size %lu\n", bytesReturned );
7800 ok( !memcmp( base, "test ", 5 ), "wrong data %s\n", base );
7801 ok( !memcmp( base + 0x4000, "message", 8 ), "wrong data %s\n", base + 0x4000 );
7802
7803 count = 64;
7804 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7805 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7806 ok( count == 0, "wrong count %Iu\n", count );
7807
7808 memset( base, 0, size );
7809 count = 64;
7810 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7811 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7812 ok( count == 16, "wrong count %Iu\n", count );
7813
7814 bufs[1].len = 0x4000;
7815 bufs[1].buf = base + 0x2000;
7816 ret = WSARecvFrom( dest, bufs, 2, NULL, &flags, &addr, &addr_len, &ov, NULL);
7817 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
7818 "WSARecv failed - %d error %ld\n", ret, GetLastError());
7819
7820 count = 64;
7821 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7822 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7823 ok( count == 5 || !count /* Win 11 */, "wrong count %Iu\n", count );
7824 ok( !base[0], "data set\n" );
7825
7826 send(src, "test message", sizeof("test message"), 0);
7827
7828 ret = GetOverlappedResult( (HANDLE)dest, &ov, &bytesReturned, TRUE );
7829 ok( ret, "GetOverlappedResult failed %lu\n", GetLastError() );
7830 ok( bytesReturned == sizeof("test message"), "wrong size %lu\n", bytesReturned );
7831 ok( !memcmp( base, "test ", 5 ), "wrong data %s\n", base );
7832 ok( !memcmp( base + 0x2000, "message", 8 ), "wrong data %s\n", base + 0x2000 );
7833
7834 count = 64;
7835 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7836 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7837 ok( count == 0, "wrong count %Iu\n", count );
7838
7839 memset( base, 0, size );
7840 count = 64;
7841 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7842 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7843 ok( count == 16, "wrong count %Iu\n", count );
7844
7845 args.dest = dest;
7846 args.base = base;
7847 args.size = 0x7002;
7848 args.expect = "test message";
7849 for (args.func = 0; args.func < 4; args.func++)
7850 {
7851 thread = CreateThread( NULL, 0, write_watch_thread, &args, 0, NULL );
7852 Sleep( 200 );
7853
7854 count = 64;
7855 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7856 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7857 ok( count == 8 || !count /* Win 11 */, "wrong count %Iu\n", count );
7858
7859 send(src, "test message", sizeof("test message"), 0);
7860 WaitForSingleObject( thread, 10000 );
7861 CloseHandle( thread );
7862
7863 count = 64;
7864 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7865 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7866 ok( count == 0, "wrong count %Iu\n", count );
7867 }
7868 WSACloseEvent( event );
7869 closesocket( dest );
7870 closesocket( src );
7871 VirtualFree( base, 0, MEM_FREE );
7872 }
7873
7874 static void test_WSAPoll(void)
7875 {
7876 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
7877 int ret, err, len;
7878 SOCKET listener, server, client;
7879 struct sockaddr_in address;
7880 WSAPOLLFD fds[16];
7881 HANDLE thread_handle;
7882 unsigned int i;
7883 char buffer[6];
7884
7885 static const short invalid_flags[] =
7886 {POLLERR, POLLHUP, POLLNVAL, 0x8, POLLWRBAND, 0x40, 0x80, POLLPRI, 0x800, 0x1000, 0x2000, 0x4000, 0x8000};
7887
7888 if (!pWSAPoll) /* >= Vista */
7889 {
7890 win_skip("WSAPoll is unsupported, some tests will be skipped.\n");
7891 return;
7892 }
7893
7894 /* Invalid parameters test */
7895 SetLastError(0xdeadbeef);
7896 ret = pWSAPoll(NULL, 0, 0);
7897 err = GetLastError();
7898 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7899 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
7900 SetLastError(0xdeadbeef);
7901 ret = pWSAPoll(NULL, 1, 0);
7902 err = GetLastError();
7903 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7904 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
7905 SetLastError(0xdeadbeef);
7906 ret = pWSAPoll(NULL, 0, 1);
7907 err = GetLastError();
7908 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7909 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
7910 SetLastError(0xdeadbeef);
7911 ret = pWSAPoll(NULL, 1, 1);
7912 err = GetLastError();
7913 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7914 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
7915
7916 memset(&address, 0, sizeof(address));
7917 address.sin_addr.s_addr = inet_addr("127.0.0.1");
7918 address.sin_family = AF_INET;
7919 len = sizeof(address);
7920 listener = setup_server_socket(&address, &len);
7921
7922 for (i = 0; i < ARRAY_SIZE(invalid_flags); ++i)
7923 {
7924 fds[0].fd = listener;
7925 fds[0].events = invalid_flags[i];
7926 fds[0].revents = 0xdead;
7927 WSASetLastError(0xdeadbeef);
7928 ret = pWSAPoll(fds, 1, 0);
7929 todo_wine ok(ret == -1, "got %d\n", ret);
7930 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
7931 }
7932
7933 /* When no events are pending poll returns 0 with no error */
7934 fds[0].fd = listener;
7935 fds[0].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
7936 fds[0].revents = 0xdead;
7937 ret = pWSAPoll(fds, 1, 0);
7938 ok(ret == 0, "got %d\n", ret);
7939 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
7940
7941 fds[0].fd = -1;
7942 fds[0].events = POLLERR;
7943 fds[0].revents = 0xdead;
7944 fds[1].fd = listener;
7945 fds[1].events = POLLIN;
7946 fds[1].revents = 0xdead;
7947 WSASetLastError(0xdeadbeef);
7948 ret = pWSAPoll(fds, 2, 0);
7949 ok(!ret, "got %d\n", ret);
7950 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
7951 ok(fds[0].revents == POLLNVAL, "got events %#x\n", fds[0].revents);
7952 ok(!fds[1].revents, "got events %#x\n", fds[1].revents);
7953
7954 fds[0].fd = listener;
7955 fds[0].events = POLLIN;
7956 fds[0].revents = 0xdead;
7957 fds[1].fd = 0xabacab;
7958 fds[1].events = POLLIN;
7959 fds[1].revents = 0xdead;
7960 WSASetLastError(0xdeadbeef);
7961 ret = pWSAPoll(fds, 2, 0);
7962 ok(!ret, "got %d\n", ret);
7963 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
7964 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
7965 ok(fds[1].revents == POLLNVAL, "got events %#x\n", fds[1].revents);
7966
7967 fds[0].fd = listener;
7968 fds[0].events = POLLIN;
7969 fds[0].revents = 0xdead;
7970 fds[1].fd = 0xabacab;
7971 fds[1].events = POLLERR;
7972 fds[1].revents = 0xdead;
7973 WSASetLastError(0xdeadbeef);
7974 ret = pWSAPoll(fds, 2, 0);
7975 todo_wine ok(ret == -1, "got %d\n", ret);
7976 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
7977 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
7978 todo_wine ok(!fds[1].revents, "got events %#x\n", fds[1].revents);
7979
7980 fds[0].fd = -1;
7981 fds[0].events = POLLERR;
7982 fds[0].revents = 0xdead;
7983 fds[1].fd = 0xabacab;
7984 fds[1].events = POLLERR;
7985 fds[1].revents = 0xdead;
7986 WSASetLastError(0xdeadbeef);
7987 ret = pWSAPoll(fds, 2, 0);
7988 ok(ret == -1, "got %d\n", ret);
7989 ok(WSAGetLastError() == WSAENOTSOCK, "got error %u\n", WSAGetLastError());
7990 ok(fds[0].revents == POLLNVAL, "got events %#x\n", fds[0].revents);
7991 ok(fds[1].revents == POLLNVAL, "got events %#x\n", fds[1].revents);
7992
7993 /* Test listening socket connection attempt notifications */
7994 client = setup_connector_socket(&address, len, TRUE);
7995
7996 fds[0].fd = listener;
7997 fds[0].events = POLLIN;
7998 fds[0].revents = 0xdead;
7999 ret = pWSAPoll(fds, 1, 100);
8000 ok(ret == 1, "got %d\n", ret);
8001 ok(fds[0].revents == POLLRDNORM, "got events %#x\n", fds[0].revents);
8002
8003 fds[0].revents = 0xdead;
8004 ret = pWSAPoll(fds, 1, 0);
8005 ok(ret == 1, "got %d\n", ret);
8006 ok(fds[0].revents == POLLRDNORM, "got events %#x\n", fds[0].revents);
8007
8008 fds[0].events = POLLRDBAND | POLLWRNORM;
8009 fds[0].revents = 0xdead;
8010 ret = pWSAPoll(fds, 1, 0);
8011 ok(ret == 0, "got %d\n", ret);
8012 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
8013
8014 server = accept(listener, NULL, NULL);
8015 ok(server != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
8016 set_blocking(client, FALSE);
8017 set_blocking(server, FALSE);
8018
8019 for (i = 0; i < ARRAY_SIZE(invalid_flags); ++i)
8020 {
8021 fds[0].fd = server;
8022 fds[0].events = invalid_flags[i];
8023 fds[0].revents = 0xdead;
8024 WSASetLastError(0xdeadbeef);
8025 ret = pWSAPoll(fds, 1, 0);
8026 todo_wine ok(ret == -1, "got %d\n", ret);
8027 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8028 }
8029
8030 /* Test flags exposed by connected sockets. */
8031
8032 fds[0].fd = listener;
8033 fds[0].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
8034 fds[0].revents = 0xdead;
8035 fds[1].fd = server;
8036 fds[1].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
8037 fds[1].revents = 0xdead;
8038 fds[2].fd = client;
8039 fds[2].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
8040 fds[2].revents = 0xdead;
8041 ret = pWSAPoll(fds, 3, 0);
8042 ok(ret == 2, "got %d\n", ret);
8043 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
8044 ok(fds[1].revents == POLLWRNORM, "got events %#x\n", fds[1].revents);
8045 ok(fds[2].revents == POLLWRNORM, "got events %#x\n", fds[2].revents);
8046
8047 /* Test data receiving notifications */
8048
8049 ret = send(server, "1234", 4, 0);
8050 ok(ret == 4, "got %d\n", ret);
8051
8052 check_poll_mask(client, POLLRDNORM | POLLRDBAND, POLLRDNORM);
8053 check_poll(client, POLLRDNORM | POLLWRNORM);
8054 check_poll(server, POLLWRNORM);
8055
8056 ret = sync_recv(client, buffer, sizeof(buffer), 0);
8057 ok(ret == 4, "got %d\n", ret);
8058
8059 check_poll(client, POLLWRNORM);
8060 check_poll(server, POLLWRNORM);
8061
8062 /* Because the kernel asynchronously buffers data, this test is not reliable. */
8063
8064 if (0)
8065 {
8066 static const int large_buffer_size = 1024 * 1024;
8067 char *large_buffer = malloc(large_buffer_size);
8068
8069 while (send(server, large_buffer, large_buffer_size, 0) == large_buffer_size);
8070
8071 check_poll(client, POLLWRNORM | POLLRDNORM);
8072 check_poll(server, 0);
8073
8074 while (recv(client, large_buffer, large_buffer_size, 0) > 0);
8075
8076 check_poll(client, POLLWRNORM);
8077 check_poll(server, POLLWRNORM);
8078
8079 free(large_buffer);
8080 }
8081
8082 /* Test OOB data notifications */
8083
8084 ret = send(client, "A", 1, MSG_OOB);
8085 ok(ret == 1, "got %d\n", ret);
8086
8087 check_poll(client, POLLWRNORM);
8088 check_poll_mask(server, POLLRDNORM | POLLRDBAND, POLLRDBAND);
8089 check_poll(server, POLLWRNORM | POLLRDBAND);
8090
8091 buffer[0] = 0xcc;
8092 ret = recv(server, buffer, 1, MSG_OOB);
8093 ok(ret == 1, "got %d\n", ret);
8094 ok(buffer[0] == 'A', "got %#x\n", buffer[0]);
8095
8096 check_poll(client, POLLWRNORM);
8097 check_poll(server, POLLWRNORM);
8098
8099 /* If the socket is OOBINLINED the notification is like normal data */
8100
8101 ret = 1;
8102 ret = setsockopt(server, SOL_SOCKET, SO_OOBINLINE, (char *)&ret, sizeof(ret));
8103 ok(!ret, "got error %u\n", WSAGetLastError());
8104 ret = send(client, "A", 1, MSG_OOB);
8105 ok(ret == 1, "got %d\n", ret);
8106
8107 check_poll(client, POLLWRNORM);
8108 check_poll_mask(server, POLLRDNORM | POLLRDBAND, POLLRDNORM);
8109 check_poll(server, POLLWRNORM | POLLRDNORM);
8110
8111 buffer[0] = 0xcc;
8112 ret = recv(server, buffer, 1, 0);
8113 ok(ret == 1, "got %d\n", ret);
8114 ok(buffer[0] == 'A', "got %#x\n", buffer[0]);
8115
8116 check_poll(client, POLLWRNORM);
8117 check_poll_todo(server, POLLWRNORM);
8118
8119 /* Test shutdown. */
8120
8121 ret = shutdown(client, SD_RECEIVE);
8122 ok(!ret, "got error %u\n", WSAGetLastError());
8123
8124 check_poll(client, POLLWRNORM);
8125 check_poll_todo(server, POLLWRNORM);
8126
8127 ret = shutdown(client, SD_SEND);
8128 ok(!ret, "got error %u\n", WSAGetLastError());
8129
8130 check_poll(client, POLLWRNORM);
8131 check_poll_mask_todo(server, 0, POLLHUP);
8132 check_poll_todo(server, POLLWRNORM | POLLHUP);
8133
8134 closesocket(client);
8135 closesocket(server);
8136
8137 /* Test shutdown via closesocket(). */
8138
8139 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8140 ret = connect(client, (struct sockaddr *)&address, sizeof(address));
8141 ok(!ret, "got error %u\n", WSAGetLastError());
8142 server = accept(listener, NULL, NULL);
8143 ok(server != -1, "got error %u\n", WSAGetLastError());
8144
8145 closesocket(client);
8146
8147 check_poll_mask(server, 0, POLLHUP);
8148 check_poll(server, POLLWRNORM | POLLHUP);
8149
8150 closesocket(server);
8151
8152 /* Test shutdown with data in the pipe. */
8153
8154 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8155 ret = connect(client, (struct sockaddr *)&address, sizeof(address));
8156 ok(!ret, "got error %u\n", WSAGetLastError());
8157 server = accept(listener, NULL, NULL);
8158 ok(server != -1, "got error %u\n", WSAGetLastError());
8159
8160 ret = send(client, "data", 5, 0);
8161 ok(ret == 5, "got %d\n", ret);
8162
8163 check_poll(client, POLLWRNORM);
8164 check_poll_mask(server, POLLRDNORM | POLLRDBAND, POLLRDNORM);
8165 check_poll(server, POLLWRNORM | POLLRDNORM);
8166
8167 ret = shutdown(client, SD_SEND);
8168
8169 check_poll(client, POLLWRNORM);
8170 check_poll_mask_todo(server, 0, POLLHUP);
8171 check_poll_todo(server, POLLWRNORM | POLLRDNORM | POLLHUP);
8172
8173 closesocket(client);
8174 closesocket(server);
8175
8176 /* Test closing a socket while selecting on it. */
8177
8178 tcp_socketpair(&client, &server);
8179
8180 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &client, 0, NULL);
8181 fds[0].fd = client;
8182 fds[0].events = POLLRDNORM | POLLRDBAND;
8183 fds[0].revents = 0xdead;
8184 apc_count = 0;
8185 ret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
8186 ok(ret, "QueueUserAPC returned %d\n", ret);
8187 ret = pWSAPoll(fds, 1, 2000);
8188 ok(apc_count == 1, "APC was called %u times\n", apc_count);
8189 ok(ret == 1, "got %d\n", ret);
8190 ok(fds[0].revents == POLLNVAL, "got events %#x\n", fds[0].revents);
8191 ret = WaitForSingleObject(thread_handle, 1000);
8192 ok(!ret, "wait failed\n");
8193 CloseHandle(thread_handle);
8194
8195 closesocket(server);
8196
8197 /* Test a failed connection.
8198 *
8199 * The following WSAPoll() call times out on versions older than w10pro64,
8200 * but even on w10pro64 it takes over 2 seconds for an error to be reported,
8201 * so make the test interactive-only. */
8202 if (winetest_interactive)
8203 {
8204 const struct sockaddr_in invalid_addr =
8205 {
8206 .sin_family = AF_INET,
8207 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
8208 .sin_port = 255,
8209 };
8210 SOCKET client;
8211
8212 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8213 set_blocking(client, FALSE);
8214
8215 ret = connect(client, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
8216 ok(ret == -1, "got %d\n", ret);
8217 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
8218
8219 fds[0].fd = client;
8220 fds[0].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
8221 fds[0].revents = 0xdead;
8222 ret = pWSAPoll(fds, 1, 10000);
8223 ok(ret == 1, "got %d\n", ret);
8224 todo_wine ok(fds[0].revents == (POLLWRNORM | POLLHUP | POLLERR), "got events %#x\n", fds[0].revents);
8225
8226 len = sizeof(err);
8227 err = 0xdeadbeef;
8228 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
8229 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
8230 ok(err == WSAECONNREFUSED, "got error %u\n", err);
8231
8232 len = sizeof(err);
8233 err = 0xdeadbeef;
8234 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
8235 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
8236 ok(err == WSAECONNREFUSED, "got error %u\n", err);
8237
8238 check_poll_todo(client, POLLWRNORM | POLLHUP | POLLERR);
8239
8240 closesocket(client);
8241
8242 /* test polling after a (synchronous) failure */
8243
8244 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8245
8246 ret = connect(client, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
8247 ok(ret == -1, "got %d\n", ret);
8248 ok(WSAGetLastError() == WSAECONNREFUSED, "got error %u\n", WSAGetLastError());
8249
8250 check_poll_todo(client, POLLWRNORM | POLLHUP | POLLERR);
8251
8252 len = sizeof(err);
8253 err = 0xdeadbeef;
8254 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
8255 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
8256 todo_wine ok(!err, "got error %u\n", err);
8257
8258 closesocket(client);
8259 }
8260
8261 closesocket(listener);
8262
8263 /* Test UDP sockets. */
8264
8265 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
8266 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
8267
8268 check_poll(client, POLLWRNORM);
8269 check_poll(server, POLLWRNORM);
8270
8271 ret = bind(client, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
8272 ok(!ret, "got error %u\n", WSAGetLastError());
8273 len = sizeof(address);
8274 ret = getsockname(client, (struct sockaddr *)&address, &len);
8275 ok(!ret, "got error %u\n", WSAGetLastError());
8276
8277 check_poll(client, POLLWRNORM);
8278 check_poll(server, POLLWRNORM);
8279
8280 ret = sendto(server, "data", 5, 0, (struct sockaddr *)&address, sizeof(address));
8281 ok(ret == 5, "got %d\n", ret);
8282
8283 check_poll_mask(client, POLLRDNORM | POLLRDBAND, POLLRDNORM);
8284 check_poll(client, POLLWRNORM | POLLRDNORM);
8285 check_poll(server, POLLWRNORM);
8286
8287 closesocket(client);
8288 closesocket(server);
8289 }
8290
8291 static void test_connect(void)
8292 {
8293 SOCKET listener = INVALID_SOCKET;
8294 SOCKET acceptor = INVALID_SOCKET;
8295 SOCKET connector = INVALID_SOCKET;
8296 struct sockaddr_in address, conaddress;
8297 int addrlen;
8298 OVERLAPPED overlapped;
8299 LPFN_CONNECTEX pConnectEx;
8300 GUID connectExGuid = WSAID_CONNECTEX;
8301 DWORD bytesReturned;
8302 char buffer[1024];
8303 BOOL bret;
8304 DWORD dwret;
8305 int iret;
8306
8307 memset(&overlapped, 0, sizeof(overlapped));
8308
8309 listener = socket(AF_INET, SOCK_STREAM, 0);
8310 ok(listener != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8311
8312 connector = socket(AF_INET, SOCK_STREAM, 0);
8313 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8314
8315 memset(&address, 0, sizeof(address));
8316 address.sin_family = AF_INET;
8317 address.sin_addr.s_addr = inet_addr("127.0.0.1");
8318 iret = bind(listener, (struct sockaddr*)&address, sizeof(address));
8319 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8320
8321 addrlen = sizeof(address);
8322 iret = getsockname(listener, (struct sockaddr*)&address, &addrlen);
8323 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
8324
8325 iret = listen(listener, 1);
8326 ok(!iret, "failed to listen, error %u\n", WSAGetLastError());
8327
8328 iret = set_blocking(listener, TRUE);
8329 ok(!iret, "failed to set nonblocking, error %u\n", WSAGetLastError());
8330
8331 bytesReturned = 0xdeadbeef;
8332 iret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectExGuid, sizeof(connectExGuid),
8333 &pConnectEx, sizeof(pConnectEx), &bytesReturned, NULL, NULL);
8334 ok(!iret, "failed to get ConnectEx, error %u\n", WSAGetLastError());
8335
8336 ok(bytesReturned == sizeof(pConnectEx), "expected sizeof(pConnectEx), got %lu\n", bytesReturned);
8337
8338 WSASetLastError(0xdeadbeef);
8339 iret = connect(listener, (struct sockaddr *)&address, sizeof(address));
8340 ok(iret == -1, "got %d\n", iret);
8341 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8342
8343 WSASetLastError(0xdeadbeef);
8344 overlapped.Internal = 0xdeadbeef;
8345 overlapped.InternalHigh = 0xdeadbeef;
8346 iret = pConnectEx(listener, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8347 ok(!iret, "got %d\n", iret);
8348 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8349 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8350 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8351
8352 bret = pConnectEx(INVALID_SOCKET, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8353 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "ConnectEx on invalid socket "
8354 "returned %d + errno %d\n", bret, WSAGetLastError());
8355
8356 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8357 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "ConnectEx on a unbound socket "
8358 "returned %d + errno %d\n", bret, WSAGetLastError());
8359
8360 /* ConnectEx needs a bound socket */
8361 memset(&conaddress, 0, sizeof(conaddress));
8362 conaddress.sin_family = AF_INET;
8363 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8364 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8365 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8366
8367 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, NULL);
8368 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "ConnectEx on a NULL overlapped "
8369 "returned %d + errno %d\n", bret, WSAGetLastError());
8370
8371 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8372
8373 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8374 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
8375 "returned %d + errno %d\n", bret, WSAGetLastError());
8376 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8377 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %ld + errno %ld\n", dwret, GetLastError());
8378
8379 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8380 ok(bret, "Connecting failed, error %ld\n", GetLastError());
8381 ok(bytesReturned == 0, "Bytes sent is %ld\n", bytesReturned);
8382
8383 closesocket(connector);
8384 connector = socket(AF_INET, SOCK_STREAM, 0);
8385 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8386 /* ConnectEx needs a bound socket */
8387 memset(&conaddress, 0, sizeof(conaddress));
8388 conaddress.sin_family = AF_INET;
8389 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8390 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8391 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8392
8393 acceptor = accept(listener, NULL, NULL);
8394 ok(acceptor != INVALID_SOCKET, "failed to accept socket, error %u\n", WSAGetLastError());
8395
8396 buffer[0] = '1';
8397 buffer[1] = '2';
8398 buffer[2] = '3';
8399 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, buffer, 3, &bytesReturned, &overlapped);
8400 memset(buffer, 0, 3);
8401 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
8402 "returned %d + errno %d\n", bret, WSAGetLastError());
8403 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8404 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %ld + errno %ld\n", dwret, GetLastError());
8405
8406 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8407 ok(bret, "Connecting failed, error %ld\n", GetLastError());
8408 ok(bytesReturned == 3, "Bytes sent is %ld\n", bytesReturned);
8409
8410 acceptor = accept(listener, NULL, NULL);
8411 ok(acceptor != INVALID_SOCKET, "could not accept socket error %d\n", WSAGetLastError());
8412
8413 bytesReturned = recv(acceptor, buffer, 3, 0);
8414 buffer[4] = 0;
8415 ok(bytesReturned == 3, "Didn't get all sent data, got only %ld\n", bytesReturned);
8416 ok(buffer[0] == '1' && buffer[1] == '2' && buffer[2] == '3',
8417 "Failed to get the right data, expected '123', got '%s'\n", buffer);
8418
8419 WSASetLastError(0xdeadbeef);
8420 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8421 ok(iret == -1, "got %d\n", iret);
8422 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8423
8424 WSASetLastError(0xdeadbeef);
8425 iret = connect(acceptor, (struct sockaddr *)&address, sizeof(address));
8426 ok(iret == -1, "got %d\n", iret);
8427 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8428
8429 WSASetLastError(0xdeadbeef);
8430 overlapped.Internal = 0xdeadbeef;
8431 overlapped.InternalHigh = 0xdeadbeef;
8432 bret = pConnectEx(connector, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8433 ok(!bret, "got %d\n", bret);
8434 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8435 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8436 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8437
8438 WSASetLastError(0xdeadbeef);
8439 overlapped.Internal = 0xdeadbeef;
8440 overlapped.InternalHigh = 0xdeadbeef;
8441 bret = pConnectEx(acceptor, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8442 ok(!bret, "got %d\n", bret);
8443 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8444 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8445 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8446
8447 closesocket(connector);
8448 closesocket(acceptor);
8449
8450 tcp_socketpair(&connector, &acceptor);
8451
8452 WSASetLastError(0xdeadbeef);
8453 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8454 ok(iret == -1, "got %d\n", iret);
8455 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8456
8457 WSASetLastError(0xdeadbeef);
8458 iret = connect(acceptor, (struct sockaddr *)&address, sizeof(address));
8459 ok(iret == -1, "got %d\n", iret);
8460 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8461
8462 WSASetLastError(0xdeadbeef);
8463 overlapped.Internal = 0xdeadbeef;
8464 overlapped.InternalHigh = 0xdeadbeef;
8465 bret = pConnectEx(connector, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8466 ok(!bret, "got %d\n", bret);
8467 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8468 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8469 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8470
8471 WSASetLastError(0xdeadbeef);
8472 overlapped.Internal = 0xdeadbeef;
8473 overlapped.InternalHigh = 0xdeadbeef;
8474 bret = pConnectEx(acceptor, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8475 ok(!bret, "got %d\n", bret);
8476 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8477 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8478 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8479
8480 closesocket(connector);
8481 closesocket(acceptor);
8482
8483 /* Connect with error */
8484
8485 connector = socket(AF_INET, SOCK_STREAM, 0);
8486 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8487 /* ConnectEx needs a bound socket */
8488 memset(&conaddress, 0, sizeof(conaddress));
8489 conaddress.sin_family = AF_INET;
8490 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8491 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8492 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8493
8494 address.sin_port = htons(1);
8495
8496 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8497 ok(bret == FALSE && GetLastError() == ERROR_IO_PENDING, "ConnectEx to bad destination failed: "
8498 "returned %d + errno %ld\n", bret, GetLastError());
8499 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8500 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %ld + errno %ld\n", dwret, GetLastError());
8501
8502 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8503 ok(bret == FALSE && GetLastError() == ERROR_CONNECTION_REFUSED,
8504 "Connecting to a disconnected host returned error %d - %d\n", bret, WSAGetLastError());
8505
8506 WSACloseEvent(overlapped.hEvent);
8507 closesocket(connector);
8508
8509 if (0)
8510 {
8511 /* Wait in connect() is alertable. This may take a very long time before connection fails,
8512 * so disable the test. Testing with localhost is unreliable as that may avoid waiting in
8513 * accept(). */
8514 connector = socket(AF_INET, SOCK_STREAM, 0);
8515 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8516 address.sin_addr.s_addr = inet_addr("8.8.8.8");
8517 address.sin_port = htons(255);
8518
8519 apc_count = 0;
8520 SleepEx(0, TRUE);
8521 ok(apc_count == 0, "got apc_count %d.\n", apc_count);
8522 bret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
8523 ok(bret, "QueueUserAPC returned %d\n", bret);
8524 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8525 ok(apc_count == 1, "got apc_count %d.\n", apc_count);
8526 ok(iret == -1 && (WSAGetLastError() == WSAECONNREFUSED || WSAGetLastError() == WSAETIMEDOUT),
8527 "unexpected iret %d, error %d.\n", iret, WSAGetLastError());
8528 closesocket(connector);
8529 }
8530
8531 /* Test connect after previous connect attempt failure. */
8532 connector = socket(AF_INET, SOCK_STREAM, 0);
8533 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8534
8535 conaddress.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
8536 conaddress.sin_port = htons(255);
8537 iret = connect(connector, (struct sockaddr *)&conaddress, sizeof(conaddress));
8538 ok(iret == -1, "connection succeeded.\n");
8539
8540 ok(WSAGetLastError() == WSAECONNREFUSED, "got error %u\n", WSAGetLastError());
8541 set_blocking( connector, FALSE );
8542 iret = getsockname(listener, (struct sockaddr*)&address, &addrlen);
8543 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
8544
8545 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8546 ok(iret == -1 && WSAGetLastError() == WSAEWOULDBLOCK, "unexpected iret %d, error %d.\n",
8547 iret, WSAGetLastError());
8548 acceptor = accept(listener, NULL, NULL);
8549 ok(acceptor != INVALID_SOCKET, "could not accept socket error %d\n", WSAGetLastError());
8550
8551 closesocket(acceptor);
8552 closesocket(connector);
8553 closesocket(listener);
8554 }
8555
8556 static void test_AcceptEx(void)
8557 {
8558 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
8559 SOCKET listener, acceptor, acceptor2, connector, connector2;
8560 struct sockaddr_in bindAddress, peerAddress, *readBindAddress, *readRemoteAddress;
8561 int socklen, iret, localSize = sizeof(struct sockaddr_in), remoteSize = localSize;
8562 GUID acceptExGuid = WSAID_ACCEPTEX, getAcceptExGuid = WSAID_GETACCEPTEXSOCKADDRS;
8563 GUID connectex_guid = WSAID_CONNECTEX;
8564 LPFN_ACCEPTEX pAcceptEx = NULL;
8565 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs = NULL;
8566 LPFN_CONNECTEX pConnectEx = NULL;
8567 fd_set fds_accept, fds_send;
8568 static const struct timeval timeout = {1, 0};
8569 char buffer[1024], ipbuffer[32];
8570 OVERLAPPED overlapped = {0}, overlapped2 = {0};
8571 DWORD bytesReturned, dwret;
8572 BOOL bret;
8573
8574 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8575 overlapped2.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8576
8577 listener = socket(AF_INET, SOCK_STREAM, 0);
8578 ok(listener != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8579
8580 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8581 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8582
8583 memset(&bindAddress, 0, sizeof(bindAddress));
8584 bindAddress.sin_family = AF_INET;
8585 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8586 iret = bind(listener, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8587 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8588
8589 socklen = sizeof(bindAddress);
8590 iret = getsockname(listener, (struct sockaddr*)&bindAddress, &socklen);
8591 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
8592
8593 iret = set_blocking(listener, FALSE);
8594 ok(!iret, "Failed to set nonblocking, error %u\n", WSAGetLastError());
8595
8596 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
8597 &pAcceptEx, sizeof(pAcceptEx), &bytesReturned, NULL, NULL);
8598 ok(!iret, "Failed to get AcceptEx, error %u\n", WSAGetLastError());
8599
8600 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &getAcceptExGuid, sizeof(getAcceptExGuid),
8601 &pGetAcceptExSockaddrs, sizeof(pGetAcceptExSockaddrs), &bytesReturned, NULL, NULL);
8602 ok(!iret, "Failed to get GetAcceptExSockaddrs, error %u\n", WSAGetLastError());
8603
8604 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectex_guid, sizeof(connectex_guid),
8605 &pConnectEx, sizeof(pConnectEx), &bytesReturned, NULL, NULL);
8606 ok(!iret, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
8607
8608 overlapped.Internal = 0xdeadbeef;
8609 bret = pAcceptEx(INVALID_SOCKET, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8610 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8611 &bytesReturned, &overlapped);
8612 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid listening socket "
8613 "returned %d + errno %d\n", bret, WSAGetLastError());
8614 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8615
8616 overlapped.Internal = 0xdeadbeef;
8617 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8618 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8619 &bytesReturned, &overlapped);
8620 todo_wine
8621 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on a non-listening socket "
8622 "returned %d + errno %d\n", bret, WSAGetLastError());
8623 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8624 if (!bret && WSAGetLastError() == ERROR_IO_PENDING)
8625 CancelIo((HANDLE)listener);
8626
8627 iret = listen(listener, 5);
8628 ok(!iret, "failed to listen, error %lu\n", GetLastError());
8629
8630 overlapped.Internal = 0xdeadbeef;
8631 bret = pAcceptEx(listener, INVALID_SOCKET, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8632 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8633 &bytesReturned, &overlapped);
8634 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid accepting socket "
8635 "returned %d + errno %d\n", bret, WSAGetLastError());
8636 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8637
8638 overlapped.Internal = 0xdeadbeef;
8639 bret = pAcceptEx(listener, acceptor, NULL, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8640 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8641 &bytesReturned, &overlapped);
8642 todo_wine ok(bret == FALSE && WSAGetLastError() == WSAEFAULT,
8643 "AcceptEx on NULL buffer returned %d + errno %d\n", bret, WSAGetLastError());
8644 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8645
8646 overlapped.Internal = 0xdeadbeef;
8647 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
8648 &bytesReturned, &overlapped);
8649 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING,
8650 "AcceptEx on too small local address size returned %d + errno %d\n",
8651 bret, WSAGetLastError());
8652 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8653
8654 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8655 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
8656 iret = connect(connector, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
8657 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
8658 iret = getsockname(connector, (struct sockaddr *)&peerAddress, &remoteSize);
8659 ok(!iret, "getsockname failed, error %u\n", WSAGetLastError());
8660
8661 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8662 ok(!dwret, "wait failed\n");
8663 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8664 ok(bret, "got error %lu\n", GetLastError());
8665 ok(!(NTSTATUS)overlapped.Internal, "got %#Ix\n", overlapped.Internal);
8666 ok(!bytesReturned, "got size %lu\n", bytesReturned);
8667
8668 readBindAddress = readRemoteAddress = (struct sockaddr_in *)0xdeadbeef;
8669 localSize = remoteSize = 0xdeadbeef;
8670 pGetAcceptExSockaddrs(buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
8671 (struct sockaddr **)&readBindAddress, &localSize, (struct sockaddr **)&readRemoteAddress, &remoteSize);
8672 todo_wine ok(readBindAddress == (struct sockaddr_in *)0xdeadbeef, "got local addr %p\n", readBindAddress);
8673 ok(!memcmp(readRemoteAddress, &peerAddress, sizeof(peerAddress)), "remote addr didn't match\n");
8674 todo_wine ok(localSize == 0xdeadbeef, "got local size %u\n", localSize);
8675 ok(remoteSize == sizeof(struct sockaddr_in), "got remote size %u\n", remoteSize);
8676
8677 closesocket(connector);
8678 closesocket(acceptor);
8679
8680 /* A UDP socket cannot be accepted into. */
8681
8682 acceptor = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
8683
8684 overlapped.Internal = 0xdeadbeef;
8685 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8686 ok(!bret, "expected failure\n");
8687 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8688 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8689 if (WSAGetLastError() == ERROR_IO_PENDING)
8690 CancelIo((HANDLE)listener);
8691
8692 closesocket(acceptor);
8693
8694 /* A bound socket cannot be accepted into. */
8695
8696 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8697 iret = bind(acceptor, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
8698 ok(!iret, "got error %u\n", WSAGetLastError());
8699
8700 overlapped.Internal = 0xdeadbeef;
8701 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8702 ok(!bret, "expected failure\n");
8703 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8704 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8705 if (WSAGetLastError() == ERROR_IO_PENDING)
8706 CancelIo((HANDLE)listener);
8707
8708 closesocket(acceptor);
8709
8710 /* A connected socket cannot be accepted into. */
8711
8712 tcp_socketpair(&acceptor, &acceptor2);
8713
8714 overlapped.Internal = 0xdeadbeef;
8715 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8716 ok(!bret, "expected failure\n");
8717 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8718 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8719 if (WSAGetLastError() == ERROR_IO_PENDING)
8720 CancelIo((HANDLE)listener);
8721
8722 overlapped.Internal = 0xdeadbeef;
8723 bret = pAcceptEx(listener, acceptor2, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8724 ok(!bret, "expected failure\n");
8725 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8726 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8727 if (WSAGetLastError() == ERROR_IO_PENDING)
8728 CancelIo((HANDLE)listener);
8729
8730 closesocket(acceptor);
8731 closesocket(acceptor2);
8732
8733 /* Pass an insufficient local address size. */
8734
8735 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8736 ok(acceptor != -1, "failed to create socket, error %u\n", WSAGetLastError());
8737
8738 overlapped.Internal = 0xdeadbeef;
8739 bret = pAcceptEx(listener, acceptor, buffer, 0, 3,
8740 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8741 ok(!bret && WSAGetLastError() == ERROR_IO_PENDING, "got %d, error %u\n", bret, WSAGetLastError());
8742 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got %#Ix\n", overlapped.Internal);
8743
8744 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8745 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
8746 iret = connect(connector, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
8747 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
8748
8749 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8750 ok(!dwret, "wait failed\n");
8751 bytesReturned = 0xdeadbeef;
8752 SetLastError(0xdeadbeef);
8753 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8754 ok(!bret, "expected failure\n");
8755 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got error %lu\n", GetLastError());
8756 ok((NTSTATUS)overlapped.Internal == STATUS_BUFFER_TOO_SMALL, "got %#Ix\n", overlapped.Internal);
8757 ok(!bytesReturned, "got size %lu\n", bytesReturned);
8758
8759 closesocket(acceptor);
8760
8761 /* The above connection request is not accepted. */
8762 acceptor = accept(listener, NULL, NULL);
8763 todo_wine ok(acceptor != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
8764 closesocket(acceptor);
8765
8766 closesocket(connector);
8767
8768 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8769 ok(acceptor != -1, "failed to create socket, error %u\n", WSAGetLastError());
8770
8771 overlapped.Internal = 0xdeadbeef;
8772 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 4,
8773 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8774 ok(!bret && WSAGetLastError() == ERROR_IO_PENDING, "got %d, error %u\n", bret, WSAGetLastError());
8775 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got %#Ix\n", overlapped.Internal);
8776
8777 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8778 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
8779 iret = connect(connector, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
8780 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
8781
8782 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8783 ok(!dwret, "wait failed\n");
8784 bytesReturned = 0xdeadbeef;
8785 SetLastError(0xdeadbeef);
8786 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8787 todo_wine ok(!bret, "expected failure\n");
8788 todo_wine ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got error %lu\n", GetLastError());
8789 todo_wine ok((NTSTATUS)overlapped.Internal == STATUS_BUFFER_TOO_SMALL, "got %#Ix\n", overlapped.Internal);
8790 ok(!bytesReturned, "got size %lu\n", bytesReturned);
8791
8792 closesocket(acceptor);
8793
8794 /* The above connection request is not accepted. */
8795 acceptor = accept(listener, NULL, NULL);
8796 todo_wine ok(acceptor != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
8797 closesocket(acceptor);
8798
8799 closesocket(connector);
8800
8801 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8802 ok(acceptor != -1, "failed to create socket, error %u\n", WSAGetLastError());
8803
8804 overlapped.Internal = 0xdeadbeef;
8805 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 15,
8806 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8807 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx on too small local address "
8808 "size returned %d + errno %d\n",
8809 bret, WSAGetLastError());
8810 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8811 bret = CancelIo((HANDLE) listener);
8812 ok(bret, "Failed to cancel pending accept socket\n");
8813
8814 overlapped.Internal = 0xdeadbeef;
8815 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16, 0,
8816 &bytesReturned, &overlapped);
8817 ok(bret == FALSE && WSAGetLastError() == WSAEFAULT,
8818 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
8819 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8820
8821 overlapped.Internal = 0xdeadbeef;
8822 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16,
8823 sizeof(struct sockaddr_in) + 15, &bytesReturned, &overlapped);
8824 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING,
8825 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
8826 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8827 bret = CancelIo((HANDLE) listener);
8828 ok(bret, "Failed to cancel pending accept socket\n");
8829
8830 bret = pAcceptEx(listener, acceptor, buffer, 0,
8831 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8832 &bytesReturned, NULL);
8833 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
8834 "returned %d + errno %d\n", bret, WSAGetLastError());
8835
8836 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, 0, &bytesReturned, NULL);
8837 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
8838 "returned %d + errno %d\n", bret, WSAGetLastError());
8839
8840 overlapped.Internal = 0xdeadbeef;
8841 bret = pAcceptEx(listener, acceptor, buffer, 0,
8842 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8843 &bytesReturned, &overlapped);
8844 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8845 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8846
8847 /* try to accept into the same socket twice */
8848 overlapped.Internal = 0xdeadbeef;
8849 bret = pAcceptEx(listener, acceptor, buffer, 0,
8850 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8851 &bytesReturned, &overlapped);
8852 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL,
8853 "AcceptEx on already pending socket returned %d + errno %d\n", bret, WSAGetLastError());
8854 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8855
8856 /* try to connect a socket that's being accepted into */
8857 iret = connect(acceptor, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8858 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL,
8859 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret, WSAGetLastError());
8860
8861 bret = pConnectEx(acceptor, (struct sockaddr *)&bindAddress, sizeof(bindAddress),
8862 NULL, 0, &bytesReturned, &overlapped2);
8863 ok(!bret, "expected failure\n");
8864 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8865
8866 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8867 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
8868 overlapped.Internal = 0xdeadbeef;
8869 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8870 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8871
8872 dwret = WaitForSingleObject(overlapped.hEvent, INFINITE);
8873 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
8874 ok(overlapped.Internal == STATUS_SUCCESS, "got %08lx\n", (ULONG)overlapped.Internal);
8875
8876 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8877 ok(bret, "GetOverlappedResult failed, error %ld\n", GetLastError());
8878 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %ld\n", bytesReturned);
8879
8880 /* Try to call getsockname on the acceptor socket.
8881 *
8882 * On Windows, this requires setting SO_UPDATE_ACCEPT_CONTEXT. */
8883 iret = setsockopt(acceptor, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, (char *)&listener, sizeof(SOCKET));
8884 ok(!iret, "Failed to set accept context %ld\n", GetLastError());
8885 iret = getsockname(acceptor, (struct sockaddr *)&peerAddress, &remoteSize);
8886 ok(!iret, "getsockname failed.\n");
8887 ok(remoteSize == sizeof(struct sockaddr_in), "got remote size %u\n", remoteSize);
8888
8889 closesocket(connector);
8890 connector = INVALID_SOCKET;
8891 closesocket(acceptor);
8892
8893 /* Test short reads */
8894
8895 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8896 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
8897 connector = socket(AF_INET, SOCK_STREAM, 0);
8898 ok(connector != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
8899 overlapped.Internal = 0xdeadbeef;
8900 bret = pAcceptEx(listener, acceptor, buffer, 2,
8901 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8902 &bytesReturned, &overlapped);
8903 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8904 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8905
8906 /* AcceptEx() still won't complete until we send data */
8907 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8908 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8909
8910 dwret = WaitForSingleObject(overlapped.hEvent, 0);
8911 ok(dwret == WAIT_TIMEOUT, "Waiting for accept event timeout failed with %ld + errno %ld\n", dwret, GetLastError());
8912 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8913
8914 iret = getsockname( connector, (struct sockaddr *)&peerAddress, &remoteSize);
8915 ok( !iret, "getsockname failed.\n");
8916
8917 /* AcceptEx() could complete any time now */
8918 iret = send(connector, buffer, 1, 0);
8919 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
8920
8921 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8922 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
8923 ok(overlapped.Internal == STATUS_SUCCESS, "got %08lx\n", (ULONG)overlapped.Internal);
8924
8925 /* Check if the buffer from AcceptEx is decoded correctly */
8926 pGetAcceptExSockaddrs(buffer, 2, sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8927 (struct sockaddr **)&readBindAddress, &localSize,
8928 (struct sockaddr **)&readRemoteAddress, &remoteSize);
8929 strcpy( ipbuffer, inet_ntoa(readBindAddress->sin_addr));
8930 ok( readBindAddress->sin_addr.s_addr == bindAddress.sin_addr.s_addr,
8931 "Local socket address is different %s != %s\n",
8932 ipbuffer, inet_ntoa(bindAddress.sin_addr));
8933 ok( readBindAddress->sin_port == bindAddress.sin_port,
8934 "Local socket port is different: %d != %d\n",
8935 readBindAddress->sin_port, bindAddress.sin_port);
8936 strcpy( ipbuffer, inet_ntoa(readRemoteAddress->sin_addr));
8937 ok( readRemoteAddress->sin_addr.s_addr == peerAddress.sin_addr.s_addr,
8938 "Remote socket address is different %s != %s\n",
8939 ipbuffer, inet_ntoa(peerAddress.sin_addr));
8940 ok( readRemoteAddress->sin_port == peerAddress.sin_port,
8941 "Remote socket port is different: %d != %d\n",
8942 readRemoteAddress->sin_port, peerAddress.sin_port);
8943
8944 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8945 ok(bret, "GetOverlappedResult failed, error %ld\n", GetLastError());
8946 ok(bytesReturned == 1, "bytesReturned isn't supposed to be %ld\n", bytesReturned);
8947
8948 closesocket(connector);
8949 connector = INVALID_SOCKET;
8950 closesocket(acceptor);
8951
8952 /* Test CF_DEFER & AcceptEx interaction */
8953
8954 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8955 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
8956 connector = socket(AF_INET, SOCK_STREAM, 0);
8957 ok(connector != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
8958 connector2 = socket(AF_INET, SOCK_STREAM, 0);
8959 ok(connector2 != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
8960
8961 iret = set_blocking(connector, FALSE);
8962 ok(!iret, "failed to set nonblocking, error %lu\n", GetLastError());
8963 iret = set_blocking(connector2, FALSE);
8964 ok(!iret, "failed to set nonblocking, error %lu\n", GetLastError());
8965
8966 /* Connect socket #1 */
8967 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8968 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8969
8970 buffer[0] = '0';
8971
8972 FD_ZERO(&fds_accept);
8973 FD_SET(listener, &fds_accept);
8974 iret = select(0, &fds_accept, NULL, NULL, &timeout);
8975 ok(iret == 1, "wait timed out\n");
8976
8977 acceptor2 = WSAAccept(listener, NULL, NULL, AlwaysDeferConditionFunc, 0);
8978 ok(acceptor2 == INVALID_SOCKET, "expected failure\n");
8979 ok(WSAGetLastError() == WSATRY_AGAIN, "got error %u\n", WSAGetLastError());
8980 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16,
8981 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8982 ok(!bret, "expected failure\n");
8983 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
8984
8985 FD_ZERO(&fds_send);
8986 FD_SET(connector, &fds_send);
8987 iret = select(0, NULL, &fds_send, NULL, &timeout);
8988 ok(iret == 1, "wait timed out\n");
8989
8990 iret = send(connector, "1", 1, 0);
8991 ok(iret == 1, "got ret %d, error %u\n", iret, WSAGetLastError());
8992
8993 iret = connect(connector2, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
8994 ok(iret == SOCKET_ERROR, "expected failure\n");
8995 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
8996
8997 iret = select(0, &fds_accept, NULL, NULL, &timeout);
8998 ok(iret == 1, "wait timed out\n");
8999
9000 acceptor2 = accept(listener, NULL, NULL);
9001 ok(acceptor2 != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
9002 closesocket(acceptor2);
9003
9004 FD_ZERO(&fds_send);
9005 FD_SET(connector2, &fds_send);
9006 iret = select(0, NULL, &fds_send, NULL, &timeout);
9007 ok(iret == 1, "wait timed out\n");
9008
9009 iret = send(connector2, "2", 1, 0);
9010 ok(iret == 1, "got ret %d, error %u\n", iret, WSAGetLastError());
9011
9012 dwret = WaitForSingleObject(overlapped.hEvent, 0);
9013 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
9014
9015 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9016 ok(bret, "GetOverlappedResult failed, error %ld\n", GetLastError());
9017 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %ld\n", bytesReturned);
9018
9019 set_blocking(acceptor, TRUE);
9020 iret = recv( acceptor, buffer, 2, 0);
9021 ok(iret == 1, "Failed to get data, %d, errno: %d\n", iret, WSAGetLastError());
9022 ok(buffer[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer[0]);
9023
9024 closesocket(connector);
9025 closesocket(connector2);
9026 closesocket(acceptor);
9027
9028 /* clean up in case of failures */
9029 while ((acceptor = accept(listener, NULL, NULL)) != INVALID_SOCKET)
9030 closesocket(acceptor);
9031
9032 /* Disconnect during receive? */
9033
9034 acceptor = socket(AF_INET, SOCK_STREAM, 0);
9035 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9036 connector = socket(AF_INET, SOCK_STREAM, 0);
9037 ok(connector != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9038 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
9039 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9040 &bytesReturned, &overlapped);
9041 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
9042
9043 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9044 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
9045
9046 closesocket(connector);
9047 connector = INVALID_SOCKET;
9048
9049 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
9050 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
9051
9052 bytesReturned = 123456;
9053 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9054 ok(bret, "GetOverlappedResult failed, error %ld\n", GetLastError());
9055 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %ld\n", bytesReturned);
9056
9057 closesocket(acceptor);
9058
9059 /* Test closing with pending requests */
9060
9061 acceptor = socket(AF_INET, SOCK_STREAM, 0);
9062 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9063 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
9064 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9065 &bytesReturned, &overlapped);
9066 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
9067
9068 closesocket(acceptor);
9069
9070 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
9071 ok(dwret == WAIT_OBJECT_0,
9072 "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
9073 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9074 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %ld\n", GetLastError());
9075
9076 acceptor = socket(AF_INET, SOCK_STREAM, 0);
9077 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9078 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
9079 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9080 &bytesReturned, &overlapped);
9081 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
9082
9083 CancelIo((HANDLE) acceptor);
9084
9085 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
9086 ok(dwret == WAIT_TIMEOUT, "Waiting for timeout failed with %ld + errno %ld\n", dwret, GetLastError());
9087
9088 closesocket(acceptor);
9089
9090 acceptor = socket(AF_INET, SOCK_STREAM, 0);
9091 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9092 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
9093 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9094 &bytesReturned, &overlapped);
9095 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
9096
9097 closesocket(listener);
9098
9099 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
9100 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
9101
9102 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9103 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %ld\n", GetLastError());
9104
9105 CloseHandle(overlapped.hEvent);
9106 CloseHandle(overlapped2.hEvent);
9107 closesocket(acceptor);
9108 closesocket(connector2);
9109 }
9110
9111 static void test_shutdown(void)
9112 {
9113 struct sockaddr_in addr, server_addr, client_addr;
9114 SOCKET listener, client, server;
9115 OVERLAPPED overlapped = {0};
9116 DWORD size, flags = 0;
9117 int ret, addrlen;
9118 char buffer[5];
9119 WSABUF wsabuf;
9120
9121 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9122 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9123 ok(listener != INVALID_SOCKET, "failed to create listener socket, error %d\n", WSAGetLastError());
9124
9125 memset(&addr, 0, sizeof(addr));
9126 addr.sin_family = AF_INET;
9127 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
9128 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
9129 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9130 addrlen = sizeof(server_addr);
9131 ret = getsockname(listener, (struct sockaddr *)&server_addr, &addrlen);
9132 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
9133
9134 ret = listen(listener, 1);
9135 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
9136
9137 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9138 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9139
9140 WSASetLastError(0xdeadbeef);
9141 ret = shutdown(client, SD_SEND);
9142 ok(ret == -1, "expected failure\n");
9143 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9144
9145 WSASetLastError(0xdeadbeef);
9146 ret = shutdown(client, SD_RECEIVE);
9147 ok(ret == -1, "expected failure\n");
9148 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9149
9150 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9151 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9152 server = accept(listener, NULL, NULL);
9153 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9154 set_blocking(client, FALSE);
9155
9156 WSASetLastError(0xdeadbeef);
9157 ret = shutdown(client, SD_SEND);
9158 ok(!ret, "expected success\n");
9159 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9160
9161 WSASetLastError(0xdeadbeef);
9162 ret = shutdown(client, SD_SEND);
9163 ok(!ret, "expected success\n");
9164 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9165
9166 WSASetLastError(0xdeadbeef);
9167 ret = send(client, "test", 5, 0);
9168 ok(ret == -1, "got %d\n", ret);
9169 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9170
9171 ret = recv(server, buffer, sizeof(buffer), 0);
9172 ok(!ret, "got %d\n", ret);
9173 ret = recv(server, buffer, sizeof(buffer), 0);
9174 ok(!ret, "got %d\n", ret);
9175
9176 WSASetLastError(0xdeadbeef);
9177 ret = shutdown(server, SD_RECEIVE);
9178 ok(!ret, "expected success\n");
9179 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9180
9181 WSASetLastError(0xdeadbeef);
9182 ret = recv(server, buffer, sizeof(buffer), 0);
9183 ok(ret == -1, "got %d\n", ret);
9184 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9185
9186 ret = send(server, "test", 5, 0);
9187 ok(ret == 5, "got %d\n", ret);
9188
9189 ret = sync_recv(client, buffer, sizeof(buffer), 0);
9190 ok(ret == 5, "got %d\n", ret);
9191 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, ret));
9192
9193 WSASetLastError(0xdeadbeef);
9194 ret = shutdown(client, SD_RECEIVE);
9195 ok(!ret, "expected success\n");
9196 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9197
9198 WSASetLastError(0xdeadbeef);
9199 ret = recv(client, buffer, sizeof(buffer), 0);
9200 ok(ret == -1, "got %d\n", ret);
9201 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9202
9203 WSASetLastError(0xdeadbeef);
9204 ret = recv(client, buffer, sizeof(buffer), 0);
9205 ok(ret == -1, "got %d\n", ret);
9206 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9207
9208 WSASetLastError(0xdeadbeef);
9209 ret = shutdown(server, SD_SEND);
9210 ok(!ret, "expected success\n");
9211 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9212
9213 WSASetLastError(0xdeadbeef);
9214 ret = send(server, "test", 5, 0);
9215 ok(ret == -1, "got %d\n", ret);
9216 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9217
9218 addrlen = sizeof(addr);
9219 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
9220 todo_wine ok(!ret, "got error %u\n", WSAGetLastError());
9221 todo_wine ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
9222
9223 addrlen = sizeof(client_addr);
9224 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
9225 ok(!ret, "got error %u\n", WSAGetLastError());
9226 addrlen = sizeof(addr);
9227 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
9228 todo_wine ok(!ret, "got error %u\n", WSAGetLastError());
9229 todo_wine ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
9230
9231 WSASetLastError(0xdeadbeef);
9232 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9233 ok(ret == -1, "got %d\n", ret);
9234 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
9235
9236 WSASetLastError(0xdeadbeef);
9237 ret = shutdown(client, 0xdeadbeef);
9238 ok(ret == -1, "expected failure\n");
9239 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
9240
9241 closesocket(client);
9242 closesocket(server);
9243
9244 /* Test SD_BOTH. */
9245
9246 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9247 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9248 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9249 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9250 server = accept(listener, NULL, NULL);
9251 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9252
9253 WSASetLastError(0xdeadbeef);
9254 ret = shutdown(client, SD_BOTH);
9255 ok(!ret, "expected success\n");
9256 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9257
9258 WSASetLastError(0xdeadbeef);
9259 ret = recv(client, buffer, sizeof(buffer), 0);
9260 ok(ret == -1, "got %d\n", ret);
9261 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9262
9263 WSASetLastError(0xdeadbeef);
9264 ret = send(client, "test", 5, 0);
9265 ok(ret == -1, "got %d\n", ret);
9266 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9267
9268 ret = recv(server, buffer, sizeof(buffer), 0);
9269 ok(!ret, "got %d\n", ret);
9270
9271 WSASetLastError(0xdeadbeef);
9272 ret = shutdown(server, SD_BOTH);
9273 ok(!ret, "expected success\n");
9274 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9275
9276 WSASetLastError(0xdeadbeef);
9277 ret = recv(server, buffer, sizeof(buffer), 0);
9278 ok(ret == -1, "got %d\n", ret);
9279 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9280
9281 WSASetLastError(0xdeadbeef);
9282 ret = send(server, "test", 5, 0);
9283 ok(ret == -1, "got %d\n", ret);
9284 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9285
9286 addrlen = sizeof(addr);
9287 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
9288 todo_wine ok(!ret, "got error %u\n", WSAGetLastError());
9289 todo_wine ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
9290
9291 addrlen = sizeof(client_addr);
9292 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
9293 ok(!ret, "got error %u\n", WSAGetLastError());
9294 addrlen = sizeof(addr);
9295 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
9296 todo_wine ok(!ret, "got error %u\n", WSAGetLastError());
9297 todo_wine ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
9298
9299 closesocket(client);
9300 closesocket(server);
9301
9302 /* Test shutting down with async I/O pending. */
9303
9304 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9305 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9306 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9307 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9308 server = accept(listener, NULL, NULL);
9309 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9310 set_blocking(client, FALSE);
9311
9312 wsabuf.buf = buffer;
9313 wsabuf.len = sizeof(buffer);
9314 WSASetLastError(0xdeadbeef);
9315 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
9316 ok(ret == -1, "got %d\n", ret);
9317 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
9318
9319 ret = shutdown(client, SD_RECEIVE);
9320 ok(!ret, "got error %u\n", WSAGetLastError());
9321
9322 WSASetLastError(0xdeadbeef);
9323 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
9324 ok(ret == -1, "got %d\n", ret);
9325 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9326
9327 ret = send(server, "test", 5, 0);
9328 ok(ret == 5, "got %d\n", ret);
9329
9330 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9331 ok(!ret, "wait timed out\n");
9332 size = 0xdeadbeef;
9333 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
9334 ok(ret, "got error %lu\n", GetLastError());
9335 ok(size == 5, "got size %lu\n", size);
9336 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, size));
9337
9338 WSASetLastError(0xdeadbeef);
9339 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
9340 ok(ret == -1, "got %d\n", ret);
9341 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9342
9343 WSASetLastError(0xdeadbeef);
9344 ret = WSARecv(server, &wsabuf, 1, &size, &flags, &overlapped, NULL);
9345 ok(ret == -1, "got %d\n", ret);
9346 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
9347
9348 ret = shutdown(client, SD_SEND);
9349 ok(!ret, "got error %u\n", WSAGetLastError());
9350
9351 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9352 ok(!ret, "wait timed out\n");
9353 size = 0xdeadbeef;
9354 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
9355 ok(ret, "got error %lu\n", GetLastError());
9356 ok(!size, "got size %lu\n", size);
9357
9358 closesocket(client);
9359 closesocket(server);
9360
9361 /* Test shutting down a listening socket. */
9362
9363 WSASetLastError(0xdeadbeef);
9364 ret = shutdown(listener, SD_SEND);
9365 ok(ret == -1, "expected failure\n");
9366 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9367
9368 WSASetLastError(0xdeadbeef);
9369 ret = shutdown(listener, SD_RECEIVE);
9370 ok(ret == -1, "expected failure\n");
9371 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9372
9373 closesocket(listener);
9374
9375 /* Test shutting down UDP sockets. */
9376
9377 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
9378 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
9379 memset(&addr, 0, sizeof(addr));
9380 addr.sin_family = AF_INET;
9381 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
9382 ret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
9383 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9384 addrlen = sizeof(server_addr);
9385 ret = getsockname(server, (struct sockaddr *)&server_addr, &addrlen);
9386 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
9387 set_blocking(server, FALSE);
9388
9389 WSASetLastError(0xdeadbeef);
9390 ret = shutdown(server, SD_RECEIVE);
9391 ok(!ret, "expected success\n");
9392 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9393
9394 WSASetLastError(0xdeadbeef);
9395 ret = recvfrom(server, buffer, sizeof(buffer), 0, NULL, NULL);
9396 ok(ret == -1, "got %d\n", ret);
9397 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9398
9399 ret = sendto(client, "test", 5, 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
9400 ok(ret == 5, "got %d\n", ret);
9401
9402 WSASetLastError(0xdeadbeef);
9403 ret = shutdown(client, SD_SEND);
9404 ok(!ret, "expected success\n");
9405 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9406
9407 WSASetLastError(0xdeadbeef);
9408 ret = shutdown(client, SD_SEND);
9409 ok(!ret, "expected success\n");
9410 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9411
9412 WSASetLastError(0xdeadbeef);
9413 ret = sendto(client, "test", 5, 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
9414 ok(ret == -1, "got %d\n", ret);
9415 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9416
9417 closesocket(client);
9418 closesocket(server);
9419
9420 CloseHandle(overlapped.hEvent);
9421 }
9422
9423 static void test_DisconnectEx(void)
9424 {
9425 struct sockaddr_in server_addr, client_addr, addr;
9426 GUID disconnectex_guid = WSAID_DISCONNECTEX;
9427 SOCKET listener, server, client;
9428 LPFN_DISCONNECTEX pDisconnectEx;
9429 OVERLAPPED overlapped = {0};
9430 int addrlen, ret;
9431 char buffer[5];
9432 DWORD size;
9433
9434 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
9435
9436 client = socket(AF_INET, SOCK_STREAM, 0);
9437 ok(client != INVALID_SOCKET, "failed to create connector socket, error %u\n", WSAGetLastError());
9438
9439 ret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &disconnectex_guid, sizeof(disconnectex_guid),
9440 &pDisconnectEx, sizeof(pDisconnectEx), &size, NULL, NULL);
9441 if (ret)
9442 {
9443 win_skip("WSAIoctl failed to get DisconnectEx, error %d\n", WSAGetLastError());
9444 closesocket(client);
9445 return;
9446 }
9447
9448 listener = socket(AF_INET, SOCK_STREAM, 0);
9449 ok(listener != INVALID_SOCKET, "failed to create listener socket, error %d\n", WSAGetLastError());
9450
9451 memset(&addr, 0, sizeof(addr));
9452 addr.sin_family = AF_INET;
9453 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
9454 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
9455 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9456 addrlen = sizeof(server_addr);
9457 ret = getsockname(listener, (struct sockaddr *)&server_addr, &addrlen);
9458 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
9459 ret = listen(listener, 1);
9460 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
9461
9462 WSASetLastError(0xdeadbeef);
9463 ret = pDisconnectEx(INVALID_SOCKET, &overlapped, 0, 0);
9464 ok(!ret, "expected failure\n");
9465 ok(WSAGetLastError() == WSAENOTSOCK, "got error %u\n", WSAGetLastError());
9466
9467 WSASetLastError(0xdeadbeef);
9468 ret = pDisconnectEx(client, &overlapped, 0, 0);
9469 ok(!ret, "expected failure\n");
9470 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9471
9472 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9473 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9474 server = accept(listener, NULL, NULL);
9475 ok(server != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
9476
9477 WSASetLastError(0xdeadbeef);
9478 ret = pDisconnectEx(client, &overlapped, 0, 0);
9479 ok(!ret, "expected failure\n");
9480 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
9481
9482 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9483 ok(!ret, "wait timed out\n");
9484 size = 0xdeadbeef;
9485 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
9486 ok(ret, "got error %lu\n", GetLastError());
9487 ok(!size, "got size %lu\n", size);
9488
9489 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9490 ok(ret == -1, "expected failure\n");
9491 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
9492
9493 WSASetLastError(0xdeadbeef);
9494 ret = send(client, "test", 5, 0);
9495 ok(ret == -1, "expected failure\n");
9496 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9497
9498 ret = recv(server, buffer, sizeof(buffer), 0);
9499 ok(!ret, "got %d\n", ret);
9500
9501 ret = send(server, "test", 5, 0);
9502 ok(ret == 5, "got %d\n", ret);
9503
9504 ret = recv(client, buffer, sizeof(buffer), 0);
9505 ok(ret == 5, "got %d\n", ret);
9506 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, ret));
9507
9508 addrlen = sizeof(addr);
9509 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
9510 ok(!ret, "got error %u\n", WSAGetLastError());
9511 ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
9512
9513 addrlen = sizeof(client_addr);
9514 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
9515 ok(!ret, "got error %u\n", WSAGetLastError());
9516 addrlen = sizeof(addr);
9517 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
9518 ok(!ret, "got error %u\n", WSAGetLastError());
9519 ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
9520
9521 closesocket(client);
9522 closesocket(server);
9523
9524 /* Test the synchronous case. */
9525
9526 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9527 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9528 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9529 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9530 server = accept(listener, NULL, NULL);
9531 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9532
9533 WSASetLastError(0xdeadbeef);
9534 ret = pDisconnectEx(client, NULL, 0, 0);
9535 ok(ret, "expected success\n");
9536 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9537
9538 WSASetLastError(0xdeadbeef);
9539 ret = pDisconnectEx(client, NULL, 0, 0);
9540 ok(ret, "expected success\n");
9541 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9542
9543 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9544 ok(ret == -1, "expected failure\n");
9545 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
9546
9547 WSASetLastError(0xdeadbeef);
9548 ret = send(client, "test", 5, 0);
9549 ok(ret == -1, "expected failure\n");
9550 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9551
9552 ret = recv(server, buffer, sizeof(buffer), 0);
9553 ok(!ret, "got %d\n", ret);
9554
9555 ret = send(server, "test", 5, 0);
9556 ok(ret == 5, "got %d\n", ret);
9557
9558 ret = recv(client, buffer, sizeof(buffer), 0);
9559 ok(ret == 5, "got %d\n", ret);
9560 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, ret));
9561
9562 addrlen = sizeof(addr);
9563 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
9564 ok(!ret, "got error %u\n", WSAGetLastError());
9565 ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
9566
9567 addrlen = sizeof(client_addr);
9568 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
9569 ok(!ret, "got error %u\n", WSAGetLastError());
9570 addrlen = sizeof(addr);
9571 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
9572 ok(!ret, "got error %u\n", WSAGetLastError());
9573 ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
9574
9575 closesocket(client);
9576 closesocket(server);
9577
9578 closesocket(listener);
9579 CloseHandle(overlapped.hEvent);
9580 }
9581
9582 #define compare_file(h,s,o) compare_file2(h,s,o,__FILE__,__LINE__)
9583
9584 static void compare_file2(HANDLE handle, SOCKET sock, int offset, const char *file, int line)
9585 {
9586 char buf1[256], buf2[256];
9587 BOOL success;
9588 int i = 0;
9589
9590 SetFilePointer(handle, offset, NULL, FILE_BEGIN);
9591 while (1)
9592 {
9593 DWORD n1 = 0, n2 = 0;
9594
9595 success = ReadFile(handle, buf1, sizeof(buf1), &n1, NULL);
9596 ok_(file,line)(success, "Failed to read from file.\n");
9597 if (success && n1 == 0)
9598 break;
9599 else if(!success)
9600 return;
9601 n2 = recv(sock, buf2, n1, 0);
9602 ok_(file,line)(n1 == n2, "Block %d size mismatch (%ld != %ld)\n", i, n1, n2);
9603 ok_(file,line)(memcmp(buf1, buf2, n2) == 0, "Block %d failed\n", i);
9604 i++;
9605 }
9606 }
9607
9608 static void test_TransmitFile(void)
9609 {
9610 DWORD num_bytes, err, file_size, total_sent;
9611 GUID transmitFileGuid = WSAID_TRANSMITFILE;
9612 LPFN_TRANSMITFILE pTransmitFile = NULL;
9613 HANDLE file = INVALID_HANDLE_VALUE;
9614 char header_msg[] = "hello world";
9615 char footer_msg[] = "goodbye!!!";
9616 char system_ini_path[MAX_PATH];
9617 struct sockaddr_in bindAddress;
9618 TRANSMIT_FILE_BUFFERS buffers;
9619 SOCKET client, server, dest;
9620 WSAOVERLAPPED ov;
9621 char buf[256];
9622 int iret, len;
9623 BOOL bret;
9624
9625 memset( &ov, 0, sizeof(ov) );
9626
9627 /* Setup sockets for testing TransmitFile */
9628 client = socket(AF_INET, SOCK_STREAM, 0);
9629 ok(client != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9630 server = socket(AF_INET, SOCK_STREAM, 0);
9631 ok(server != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9632 iret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &transmitFileGuid, sizeof(transmitFileGuid),
9633 &pTransmitFile, sizeof(pTransmitFile), &num_bytes, NULL, NULL);
9634 ok(!iret, "failed to get TransmitFile, error %lu\n", GetLastError());
9635 GetSystemWindowsDirectoryA(system_ini_path, MAX_PATH );
9636 strcat(system_ini_path, "\\system.ini");
9637 file = CreateFileA(system_ini_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0x0, NULL);
9638 ok(file != INVALID_HANDLE_VALUE, "failed to open file, error %lu\n", GetLastError());
9639 file_size = GetFileSize(file, NULL);
9640
9641 /* Test TransmitFile with an invalid socket */
9642 bret = pTransmitFile(INVALID_SOCKET, file, 0, 0, NULL, NULL, 0);
9643 err = WSAGetLastError();
9644 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9645 ok(err == WSAENOTSOCK, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, WSAENOTSOCK);
9646
9647 /* Test a bogus TransmitFile without a connected socket */
9648 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, TF_REUSE_SOCKET);
9649 err = WSAGetLastError();
9650 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9651 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, WSAENOTCONN);
9652
9653 /* Setup a properly connected socket for transfers */
9654 memset(&bindAddress, 0, sizeof(bindAddress));
9655 bindAddress.sin_family = AF_INET;
9656 bindAddress.sin_port = htons(SERVERPORT+1);
9657 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
9658 iret = bind(server, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9659 ok(!iret, "failed to bind socket, error %lu\n", GetLastError());
9660 iret = listen(server, 1);
9661 ok(!iret, "failed to listen, error %lu\n", GetLastError());
9662 iret = connect(client, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9663 ok(!iret, "failed to connect, error %lu\n", GetLastError());
9664 len = sizeof(bindAddress);
9665 dest = accept(server, (struct sockaddr*)&bindAddress, &len);
9666 ok(dest != INVALID_SOCKET, "failed to accept, error %lu\n", GetLastError());
9667 iret = set_blocking(dest, FALSE);
9668 ok(!iret, "failed to set nonblocking, error %lu\n", GetLastError());
9669
9670 /* Test TransmitFile with no possible buffer */
9671 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
9672 ok(bret, "TransmitFile failed unexpectedly.\n");
9673 iret = recv(dest, buf, sizeof(buf), 0);
9674 ok(iret == -1, "Returned an unexpected buffer from TransmitFile (%d != -1).\n", iret);
9675
9676 /* Test TransmitFile with only buffer data */
9677 buffers.Head = &header_msg[0];
9678 buffers.HeadLength = sizeof(header_msg);
9679 buffers.Tail = &footer_msg[0];
9680 buffers.TailLength = sizeof(footer_msg);
9681 bret = pTransmitFile(client, NULL, 0, 0, NULL, &buffers, 0);
9682 ok(bret, "TransmitFile failed unexpectedly.\n");
9683 iret = recv(dest, buf, sizeof(buf), 0);
9684 ok(iret == sizeof(header_msg)+sizeof(footer_msg),
9685 "Returned an unexpected buffer from TransmitFile: %d\n", iret );
9686 ok(memcmp(&buf[0], &header_msg[0], sizeof(header_msg)) == 0,
9687 "TransmitFile header buffer did not match!\n");
9688 ok(memcmp(&buf[sizeof(header_msg)], &footer_msg[0], sizeof(footer_msg)) == 0,
9689 "TransmitFile footer buffer did not match!\n");
9690
9691 /* Test TransmitFile with only file data */
9692 bret = pTransmitFile(client, file, 0, 0, NULL, NULL, 0);
9693 ok(bret, "TransmitFile failed unexpectedly.\n");
9694 compare_file(file, dest, 0);
9695
9696 /* Test TransmitFile with both file and buffer data */
9697 buffers.Head = &header_msg[0];
9698 buffers.HeadLength = sizeof(header_msg);
9699 buffers.Tail = &footer_msg[0];
9700 buffers.TailLength = sizeof(footer_msg);
9701 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9702 bret = pTransmitFile(client, file, 0, 0, NULL, &buffers, 0);
9703 ok(bret, "TransmitFile failed unexpectedly.\n");
9704 iret = recv(dest, buf, sizeof(header_msg), 0);
9705 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)) == 0,
9706 "TransmitFile header buffer did not match!\n");
9707 compare_file(file, dest, 0);
9708 iret = recv(dest, buf, sizeof(footer_msg), 0);
9709 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)) == 0,
9710 "TransmitFile footer buffer did not match!\n");
9711
9712 /* Test overlapped TransmitFile */
9713 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
9714 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9715 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
9716 err = WSAGetLastError();
9717 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9718 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%ld != %d)\n",
9719 err, ERROR_IO_PENDING);
9720 iret = WaitForSingleObject(ov.hEvent, 2000);
9721 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
9722 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
9723 ok(total_sent == file_size,
9724 "Overlapped TransmitFile sent an unexpected number of bytes (%ld != %ld).\n",
9725 total_sent, file_size);
9726 compare_file(file, dest, 0);
9727
9728 /* Test overlapped TransmitFile w/ start offset */
9729 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
9730 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9731 ov.Offset = 10;
9732 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
9733 err = WSAGetLastError();
9734 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9735 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, ERROR_IO_PENDING);
9736 iret = WaitForSingleObject(ov.hEvent, 2000);
9737 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
9738 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
9739 ok(total_sent == (file_size - ov.Offset),
9740 "Overlapped TransmitFile sent an unexpected number of bytes (%ld != %ld).\n",
9741 total_sent, file_size - ov.Offset);
9742 compare_file(file, dest, ov.Offset);
9743
9744 /* Test overlapped TransmitFile w/ file and buffer data */
9745 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
9746 buffers.Head = &header_msg[0];
9747 buffers.HeadLength = sizeof(header_msg);
9748 buffers.Tail = &footer_msg[0];
9749 buffers.TailLength = sizeof(footer_msg);
9750 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9751 ov.Offset = 0;
9752 bret = pTransmitFile(client, file, 0, 0, &ov, &buffers, 0);
9753 err = WSAGetLastError();
9754 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9755 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, ERROR_IO_PENDING);
9756 iret = WaitForSingleObject(ov.hEvent, 2000);
9757 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
9758 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
9759 ok(total_sent == (file_size + buffers.HeadLength + buffers.TailLength),
9760 "Overlapped TransmitFile sent an unexpected number of bytes (%ld != %ld).\n",
9761 total_sent, file_size + buffers.HeadLength + buffers.TailLength);
9762 iret = recv(dest, buf, sizeof(header_msg), 0);
9763 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)) == 0,
9764 "TransmitFile header buffer did not match!\n");
9765 compare_file(file, dest, 0);
9766 iret = recv(dest, buf, sizeof(footer_msg), 0);
9767 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)) == 0,
9768 "TransmitFile footer buffer did not match!\n");
9769
9770 /* Test TransmitFile with a UDP datagram socket */
9771 closesocket(client);
9772 client = socket(AF_INET, SOCK_DGRAM, 0);
9773 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
9774 err = WSAGetLastError();
9775 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9776 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, WSAENOTCONN);
9777
9778 CloseHandle(file);
9779 CloseHandle(ov.hEvent);
9780 closesocket(client);
9781 closesocket(server);
9782 }
9783
9784 static void test_getpeername(void)
9785 {
9786 SOCKET sock;
9787 struct sockaddr_in sa, sa_out;
9788 SOCKADDR_STORAGE ss;
9789 int sa_len;
9790 const char buf[] = "hello world";
9791 int ret;
9792
9793 /* Test the parameter validation order. */
9794 ret = getpeername(INVALID_SOCKET, NULL, NULL);
9795 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9796 ok(WSAGetLastError() == WSAENOTSOCK,
9797 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
9798
9799 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
9800 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
9801
9802 ret = getpeername(sock, NULL, NULL);
9803 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9804 todo_wine ok(WSAGetLastError() == WSAENOTCONN,
9805 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
9806
9807 memset(&sa, 0, sizeof(sa));
9808 sa.sin_family = AF_INET;
9809 sa.sin_port = htons(139);
9810 sa.sin_addr.s_addr = inet_addr("127.0.0.1");
9811
9812 /* sendto does not change a socket's connection state. */
9813 ret = sendto(sock, buf, sizeof(buf), 0, (struct sockaddr*)&sa, sizeof(sa));
9814 ok(ret != SOCKET_ERROR,
9815 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
9816
9817 ret = getpeername(sock, NULL, NULL);
9818 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9819 todo_wine ok(WSAGetLastError() == WSAENOTCONN,
9820 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
9821
9822 ret = connect(sock, (struct sockaddr*)&sa, sizeof(sa));
9823 ok(ret == 0,
9824 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
9825
9826 ret = getpeername(sock, NULL, NULL);
9827 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9828 ok(WSAGetLastError() == WSAEFAULT,
9829 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9830
9831 /* Test crashes on Wine. */
9832 if (0)
9833 {
9834 ret = getpeername(sock, (void*)0xdeadbeef, (void*)0xcafebabe);
9835 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9836 ok(WSAGetLastError() == WSAEFAULT,
9837 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9838 }
9839
9840 ret = getpeername(sock, (struct sockaddr*)&sa_out, NULL);
9841 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
9842 ok(WSAGetLastError() == WSAEFAULT,
9843 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9844
9845 sa_len = 0;
9846 ret = getpeername(sock, NULL, &sa_len);
9847 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
9848 ok(WSAGetLastError() == WSAEFAULT,
9849 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9850 ok(!sa_len, "got %d\n", sa_len);
9851
9852 sa_len = 0;
9853 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
9854 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
9855 ok(WSAGetLastError() == WSAEFAULT,
9856 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9857 ok(!sa_len, "got %d\n", sa_len);
9858
9859 sa_len = sizeof(ss);
9860 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
9861 ok(ret == 0, "Expected getpeername to return 0, got %d\n", ret);
9862 ok(!memcmp(&sa, &ss, sizeof(sa)),
9863 "Expected the returned structure to be identical to the connect structure\n");
9864 ok(sa_len == sizeof(sa), "got %d\n", sa_len);
9865
9866 closesocket(sock);
9867 }
9868
9869 static void test_sioRoutingInterfaceQuery(void)
9870 {
9871 OVERLAPPED overlapped = {0}, *overlapped_ptr;
9872 struct sockaddr_in in = {0}, out = {0};
9873 ULONG_PTR key;
9874 HANDLE port;
9875 SOCKET sock;
9876 DWORD size;
9877 int ret;
9878
9879 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
9880 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
9881 port = CreateIoCompletionPort((HANDLE)sock, NULL, 123, 0);
9882
9883 WSASetLastError(0xdeadbeef);
9884 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), NULL, NULL, NULL);
9885 ok(ret == -1, "expected failure\n");
9886 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
9887
9888 size = 0xdeadbeef;
9889 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in) - 1, &out, sizeof(out), &size, NULL, NULL);
9890 ok(ret == -1, "expected failure\n");
9891 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
9892 ok(size == 0xdeadbeef, "got size %lu\n", size);
9893
9894 size = 0xdeadbeef;
9895 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, NULL, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
9896 ok(ret == -1, "expected failure\n");
9897 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
9898 ok(size == 0xdeadbeef, "got size %lu\n", size);
9899
9900 size = 0xdeadbeef;
9901 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
9902 ok(ret == -1, "expected failure\n");
9903 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError());
9904 ok(size == 0xdeadbeef, "got size %lu\n", size);
9905
9906 in.sin_family = AF_INET;
9907 size = 0xdeadbeef;
9908 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
9909 todo_wine ok(ret == -1, "expected failure\n");
9910 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
9911 todo_wine ok(size == 0xdeadbeef, "got size %lu\n", size);
9912
9913 in.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
9914 WSASetLastError(0xdeadbeef);
9915 size = 0xdeadbeef;
9916 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
9917 ok(!ret, "expected failure\n");
9918 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
9919 ok(size == sizeof(out), "got size %lu\n", size);
9920 /* We expect the source address to be INADDR_LOOPBACK as well, but
9921 * there's no guarantee that a route to the loopback address exists,
9922 * so rather than introduce spurious test failures we do not test the
9923 * source address.
9924 */
9925
9926 size = 0xdeadbeef;
9927 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out) - 1, &size, NULL, NULL);
9928 ok(ret == -1, "expected failure\n");
9929 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
9930 todo_wine ok(size == sizeof(out), "got size %lu\n", size);
9931
9932 size = 0xdeadbeef;
9933 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), NULL, sizeof(out), &size, NULL, NULL);
9934 ok(ret == -1, "expected failure\n");
9935 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
9936 ok(size == 0xdeadbeef, "got size %lu\n", size);
9937
9938 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), NULL, &overlapped, NULL);
9939 ok(ret == -1, "expected failure\n");
9940 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
9941 ok(size == 0xdeadbeef, "got size %lu\n", size);
9942
9943 WSASetLastError(0xdeadbeef);
9944 size = 0xdeadbeef;
9945 overlapped.Internal = 0xdeadbeef;
9946 overlapped.InternalHigh = 0xdeadbeef;
9947 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, &overlapped, NULL);
9948 ok(!ret, "expected failure\n");
9949 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
9950 ok(size == sizeof(out), "got size %lu\n", size);
9951
9952 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
9953 ok(ret, "got error %lu\n", GetLastError());
9954 ok(!size, "got size %lu\n", size);
9955 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
9956 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
9957 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
9958
9959 CloseHandle(port);
9960 closesocket(sock);
9961
9962 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
9963
9964 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in),
9965 &out, sizeof(out), NULL, &overlapped, socket_apc);
9966 ok(ret == -1, "expected failure\n");
9967 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
9968
9969 apc_count = 0;
9970 size = 0xdeadbeef;
9971 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in),
9972 &out, sizeof(out), &size, &overlapped, socket_apc);
9973 ok(!ret, "expected success\n");
9974 ok(size == sizeof(out), "got size %lu\n", size);
9975
9976 ret = SleepEx(0, TRUE);
9977 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
9978 ok(apc_count == 1, "APC was called %u times\n", apc_count);
9979 ok(!apc_error, "got APC error %lu\n", apc_error);
9980 ok(!apc_size, "got APC size %lu\n", apc_size);
9981 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
9982
9983 closesocket(sock);
9984 }
9985
9986 static void test_sioAddressListChange(void)
9987 {
9988 struct sockaddr_in bindAddress;
9989 struct in_addr net_address;
9990 WSAOVERLAPPED overlapped, *olp;
9991 struct hostent *h;
9992 DWORD num_bytes, error, tick;
9993 SOCKET sock, sock2, sock3;
9994 WSAEVENT event2, event3;
9995 HANDLE io_port;
9996 ULONG_PTR key;
9997 int acount;
9998 BOOL bret;
9999 int ret;
10000
10001 /* Use gethostbyname to find the list of local network interfaces */
10002 h = gethostbyname("");
10003 ok(!!h, "failed to get interface list, error %u\n", WSAGetLastError());
10004 for (acount = 0; h->h_addr_list[acount]; acount++);
10005 if (acount == 0)
10006 {
10007 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
10008 return;
10009 }
10010
10011 net_address.s_addr = *(ULONG *) h->h_addr_list[0];
10012
10013 sock = socket(AF_INET, 0, IPPROTO_TCP);
10014 ok(sock != INVALID_SOCKET, "socket() failed\n");
10015
10016 memset(&bindAddress, 0, sizeof(bindAddress));
10017 bindAddress.sin_family = AF_INET;
10018 bindAddress.sin_addr.s_addr = net_address.s_addr;
10019 SetLastError(0xdeadbeef);
10020 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10021 ok (!ret, "bind() failed with error %ld\n", GetLastError());
10022 set_blocking(sock, FALSE);
10023
10024 memset(&overlapped, 0, sizeof(overlapped));
10025 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10026 SetLastError(0xdeadbeef);
10027 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10028 error = GetLastError();
10029 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
10030 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%lx\n", error);
10031
10032 CloseHandle(overlapped.hEvent);
10033 closesocket(sock);
10034
10035 sock = socket(AF_INET, 0, IPPROTO_TCP);
10036 ok(sock != INVALID_SOCKET, "socket() failed\n");
10037
10038 SetLastError(0xdeadbeef);
10039 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10040 ok (!ret, "bind() failed with error %ld\n", GetLastError());
10041 set_blocking(sock, TRUE);
10042
10043 memset(&overlapped, 0, sizeof(overlapped));
10044 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10045 SetLastError(0xdeadbeef);
10046 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10047 error = GetLastError();
10048 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
10049 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%lx\n", error);
10050
10051 CloseHandle(overlapped.hEvent);
10052 closesocket(sock);
10053
10054 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10055 ok(sock != INVALID_SOCKET, "socket() failed\n");
10056
10057 SetLastError(0xdeadbeef);
10058 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10059 ok (!ret, "bind() failed with error %ld\n", GetLastError());
10060 set_blocking(sock, FALSE);
10061
10062 memset(&overlapped, 0, sizeof(overlapped));
10063 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10064 SetLastError(0xdeadbeef);
10065 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10066 error = GetLastError();
10067 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
10068 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%lx\n", error);
10069
10070 CloseHandle(overlapped.hEvent);
10071 closesocket(sock);
10072
10073 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10074 ok(sock != INVALID_SOCKET, "socket() failed\n");
10075
10076 SetLastError(0xdeadbeef);
10077 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10078 ok (!ret, "bind() failed with error %ld\n", GetLastError());
10079 set_blocking(sock, TRUE);
10080
10081 memset(&overlapped, 0, sizeof(overlapped));
10082 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10083 SetLastError(0xdeadbeef);
10084 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10085 error = GetLastError();
10086 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
10087 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%lx\n", error);
10088
10089 CloseHandle(overlapped.hEvent);
10090 closesocket(sock);
10091
10092 /* When the socket is overlapped non-blocking and the list change is requested without
10093 * an overlapped structure the error will be different. */
10094 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10095 ok(sock != INVALID_SOCKET, "socket() failed\n");
10096
10097 SetLastError(0xdeadbeef);
10098 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10099 ok (!ret, "bind() failed with error %ld\n", GetLastError());
10100 set_blocking(sock, FALSE);
10101
10102 SetLastError(0xdeadbeef);
10103 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
10104 error = GetLastError();
10105 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
10106 ok (error == WSAEWOULDBLOCK, "expected 10035, got %ld\n", error);
10107
10108 io_port = CreateIoCompletionPort( (HANDLE)sock, NULL, 0, 0 );
10109 ok (io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10110
10111 set_blocking(sock, FALSE);
10112 memset(&overlapped, 0, sizeof(overlapped));
10113 SetLastError(0xdeadbeef);
10114 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10115 error = GetLastError();
10116 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %lu\n", error);
10117 ok (error == ERROR_IO_PENDING, "expected ERROR_IO_PENDING got %lu\n", error);
10118
10119 olp = (WSAOVERLAPPED *)0xdeadbeef;
10120 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 0 );
10121 ok(!bret, "failed to get completion status %u\n", bret);
10122 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10123 ok(!olp, "Overlapped structure is at %p\n", olp);
10124
10125 closesocket(sock);
10126
10127 olp = (WSAOVERLAPPED *)0xdeadbeef;
10128 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 0 );
10129 ok(!bret, "failed to get completion status %u\n", bret);
10130 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %lu\n", GetLastError());
10131 ok(olp == &overlapped, "Overlapped structure is at %p\n", olp);
10132
10133 CloseHandle(io_port);
10134
10135 /* Misuse of the API by using a blocking socket and not using an overlapped structure,
10136 * this leads to a hang forever. */
10137 if (0)
10138 {
10139 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10140
10141 SetLastError(0xdeadbeef);
10142 bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10143
10144 set_blocking(sock, TRUE);
10145 WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
10146 /* hang */
10147
10148 closesocket(sock);
10149 }
10150
10151 if (!winetest_interactive)
10152 {
10153 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
10154 return;
10155 }
10156
10157 /* Bind an overlapped socket to the first found network interface */
10158 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10159 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
10160 sock2 = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10161 ok(sock2 != INVALID_SOCKET, "Expected socket to return a valid socket\n");
10162 sock3 = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10163 ok(sock3 != INVALID_SOCKET, "Expected socket to return a valid socket\n");
10164
10165 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10166 ok(!ret, "bind failed unexpectedly\n");
10167 ret = bind(sock2, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10168 ok(!ret, "bind failed unexpectedly\n");
10169 ret = bind(sock3, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10170 ok(!ret, "bind failed unexpectedly\n");
10171
10172 set_blocking(sock2, FALSE);
10173 set_blocking(sock3, FALSE);
10174
10175 /* Wait for address changes, request that the user connects/disconnects an interface */
10176 memset(&overlapped, 0, sizeof(overlapped));
10177 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10178 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10179 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
10180 ok(WSAGetLastError() == WSA_IO_PENDING, "Expected pending last error, got %d\n", WSAGetLastError());
10181
10182 ret = WSAIoctl(sock2, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
10183 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
10184 ok(WSAGetLastError() == WSAEWOULDBLOCK, "Expected would block last error, got %d\n", WSAGetLastError());
10185
10186 event2 = WSACreateEvent();
10187 event3 = WSACreateEvent();
10188 ret = WSAEventSelect (sock2, event2, FD_ADDRESS_LIST_CHANGE);
10189 ok(!ret, "WSAEventSelect failed with %d\n", WSAGetLastError());
10190 /* sock3 did not request SIO_ADDRESS_LIST_CHANGE but it is trying to wait anyway */
10191 ret = WSAEventSelect (sock3, event3, FD_ADDRESS_LIST_CHANGE);
10192 ok(!ret, "WSAEventSelect failed with %d\n", WSAGetLastError());
10193
10194 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
10195 " change the ipv4 address of any of the local network interfaces (15 second timeout).\n");
10196 tick = GetTickCount();
10197 ret = WaitForSingleObject(overlapped.hEvent, 15000);
10198 ok(ret == WAIT_OBJECT_0, "failed to get overlapped event %u\n", ret);
10199
10200 ret = WaitForSingleObject(event2, 500);
10201 todo_wine
10202 ok(ret == WAIT_OBJECT_0, "failed to get change event %u\n", ret);
10203
10204 ret = WaitForSingleObject(event3, 500);
10205 ok(ret == WAIT_TIMEOUT, "unexpected change event\n");
10206
10207 trace("Spent %ld ms waiting.\n", GetTickCount() - tick);
10208
10209 WSACloseEvent(event2);
10210 WSACloseEvent(event3);
10211
10212 closesocket(sock);
10213 closesocket(sock2);
10214 closesocket(sock3);
10215 }
10216
10217 /*
10218 * Provide consistent initialization for the AcceptEx IOCP tests.
10219 */
10220 static SOCKET setup_iocp_src(struct sockaddr_in *bindAddress)
10221 {
10222 SOCKET src;
10223 int iret, socklen;
10224
10225 src = socket(AF_INET, SOCK_STREAM, 0);
10226 ok(src != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10227
10228 memset(bindAddress, 0, sizeof(*bindAddress));
10229 bindAddress->sin_family = AF_INET;
10230 bindAddress->sin_addr.s_addr = inet_addr("127.0.0.1");
10231 iret = bind(src, (struct sockaddr*)bindAddress, sizeof(*bindAddress));
10232 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
10233
10234 socklen = sizeof(*bindAddress);
10235 iret = getsockname(src, (struct sockaddr*)bindAddress, &socklen);
10236 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
10237
10238 iret = set_blocking(src, FALSE);
10239 ok(!iret, "failed to make socket non-blocking, error %u\n", WSAGetLastError());
10240
10241 iret = listen(src, 5);
10242 ok(!iret, "failed to listen, error %u\n", WSAGetLastError());
10243
10244 return src;
10245 }
10246
10247 static void test_completion_port(void)
10248 {
10249 HANDLE io_port;
10250 WSAOVERLAPPED ov, *olp;
10251 SOCKET src, dest, dup, connector = INVALID_SOCKET;
10252 WSAPROTOCOL_INFOA info;
10253 char buf[1024];
10254 WSABUF bufs;
10255 DWORD num_bytes, flags;
10256 int iret;
10257 BOOL bret;
10258 ULONG_PTR key;
10259 struct sockaddr_in bindAddress;
10260 GUID acceptExGuid = WSAID_ACCEPTEX;
10261 LPFN_ACCEPTEX pAcceptEx = NULL;
10262 fd_set fds_recv;
10263
10264 memset(buf, 0, sizeof(buf));
10265 io_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
10266 ok( io_port != NULL, "Failed to create completion port %lu\n", GetLastError());
10267
10268 memset(&ov, 0, sizeof(ov));
10269
10270 tcp_socketpair(&src, &dest);
10271
10272 bufs.len = sizeof(buf);
10273 bufs.buf = buf;
10274 flags = 0;
10275
10276 io_port = CreateIoCompletionPort( (HANDLE)dest, io_port, 125, 0 );
10277 ok(io_port != NULL, "Failed to create completion port %lu\n", GetLastError());
10278
10279 SetLastError(0xdeadbeef);
10280
10281 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10282 ok(iret == SOCKET_ERROR, "WSARecv returned %d\n", iret);
10283 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10284
10285 Sleep(100);
10286
10287 close_with_rst(src);
10288
10289 SetLastError(0xdeadbeef);
10290 key = 0xdeadbeef;
10291 num_bytes = 0xdeadbeef;
10292 olp = (WSAOVERLAPPED *)0xdeadbeef;
10293
10294 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10295 ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret);
10296 ok(GetLastError() == ERROR_NETNAME_DELETED, "Last error was %ld\n", GetLastError());
10297 ok(key == 125, "Key is %Iu\n", key);
10298 ok(num_bytes == 0, "Number of bytes received is %lu\n", num_bytes);
10299 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10300
10301 SetLastError(0xdeadbeef);
10302 key = 0xdeadbeef;
10303 num_bytes = 0xdeadbeef;
10304 olp = (WSAOVERLAPPED *)0xdeadbeef;
10305
10306 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10307 ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret );
10308 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10309 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10310 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10311 ok(!olp, "Overlapped structure is at %p\n", olp);
10312
10313 if (dest != INVALID_SOCKET)
10314 closesocket(dest);
10315
10316 memset(&ov, 0, sizeof(ov));
10317
10318 tcp_socketpair(&src, &dest);
10319
10320 bufs.len = sizeof(buf);
10321 bufs.buf = buf;
10322 flags = 0;
10323
10324 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
10325 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10326
10327 set_blocking(dest, FALSE);
10328
10329 close_with_rst(src);
10330
10331 Sleep(100);
10332
10333 num_bytes = 0xdeadbeef;
10334 SetLastError(0xdeadbeef);
10335
10336 iret = WSASend(dest, &bufs, 1, &num_bytes, 0, &ov, NULL);
10337 ok(iret == SOCKET_ERROR, "WSASend failed - %d\n", iret);
10338 ok(GetLastError() == WSAECONNRESET, "Last error was %ld\n", GetLastError());
10339 ok(num_bytes == 0xdeadbeef, "Managed to send %ld\n", num_bytes);
10340
10341 SetLastError(0xdeadbeef);
10342 key = 0xdeadbeef;
10343 num_bytes = 0xdeadbeef;
10344 olp = (WSAOVERLAPPED *)0xdeadbeef;
10345
10346 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10347 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
10348 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10349 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10350 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10351 ok(!olp, "Overlapped structure is at %p\n", olp);
10352
10353 if (dest != INVALID_SOCKET)
10354 closesocket(dest);
10355
10356 /* Test IOCP response on successful immediate read. */
10357 tcp_socketpair(&src, &dest);
10358
10359 bufs.len = sizeof(buf);
10360 bufs.buf = buf;
10361 flags = 0;
10362 SetLastError(0xdeadbeef);
10363
10364 iret = WSASend(src, &bufs, 1, &num_bytes, 0, &ov, NULL);
10365 ok(!iret, "WSASend failed - %d, last error %lu\n", iret, GetLastError());
10366 ok(num_bytes == sizeof(buf), "Managed to send %ld\n", num_bytes);
10367
10368 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
10369 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10370 set_blocking(dest, FALSE);
10371
10372 FD_ZERO(&fds_recv);
10373 FD_SET(dest, &fds_recv);
10374 select(dest + 1, &fds_recv, NULL, NULL, NULL);
10375
10376 num_bytes = 0xdeadbeef;
10377 flags = 0;
10378
10379 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10380 ok(!iret, "WSARecv failed - %d, last error %lu\n", iret, GetLastError());
10381 ok(num_bytes == sizeof(buf), "Managed to read %ld\n", num_bytes);
10382
10383 SetLastError(0xdeadbeef);
10384 key = 0xdeadbeef;
10385 num_bytes = 0xdeadbeef;
10386 olp = (WSAOVERLAPPED *)0xdeadbeef;
10387
10388 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10389 ok(bret == TRUE, "failed to get completion status %u\n", bret);
10390 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
10391 ok(key == 125, "Key is %Iu\n", key);
10392 ok(num_bytes == sizeof(buf), "Number of bytes transferred is %lu\n", num_bytes);
10393 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10394
10395 /* Test IOCP response on graceful shutdown. */
10396 closesocket(src);
10397
10398 FD_ZERO(&fds_recv);
10399 FD_SET(dest, &fds_recv);
10400 select(dest + 1, &fds_recv, NULL, NULL, NULL);
10401
10402 num_bytes = 0xdeadbeef;
10403 flags = 0;
10404 memset(&ov, 0, sizeof(ov));
10405
10406 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10407 ok(!iret, "WSARecv failed - %d, last error %lu\n", iret, GetLastError());
10408 ok(!num_bytes, "Managed to read %ld\n", num_bytes);
10409
10410 SetLastError(0xdeadbeef);
10411 key = 0xdeadbeef;
10412 num_bytes = 0xdeadbeef;
10413 olp = (WSAOVERLAPPED *)0xdeadbeef;
10414
10415 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10416 ok(bret == TRUE, "failed to get completion status %u\n", bret);
10417 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
10418 ok(key == 125, "Key is %Iu\n", key);
10419 ok(!num_bytes, "Number of bytes transferred is %lu\n", num_bytes);
10420 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10421
10422 closesocket(src);
10423 src = INVALID_SOCKET;
10424 closesocket(dest);
10425 dest = INVALID_SOCKET;
10426
10427 /* Test IOCP response on hard shutdown. This was the condition that triggered
10428 * a crash in an actual app (bug 38980). */
10429 tcp_socketpair(&src, &dest);
10430
10431 bufs.len = sizeof(buf);
10432 bufs.buf = buf;
10433 flags = 0;
10434 memset(&ov, 0, sizeof(ov));
10435
10436 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
10437 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10438 set_blocking(dest, FALSE);
10439
10440 close_with_rst(src);
10441
10442 FD_ZERO(&fds_recv);
10443 FD_SET(dest, &fds_recv);
10444 select(dest + 1, &fds_recv, NULL, NULL, NULL);
10445
10446 num_bytes = 0xdeadbeef;
10447 SetLastError(0xdeadbeef);
10448
10449 /* Somehow a hard shutdown doesn't work on my Linux box. It seems SO_LINGER is ignored. */
10450 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10451 todo_wine ok(iret == SOCKET_ERROR, "WSARecv failed - %d\n", iret);
10452 todo_wine ok(GetLastError() == WSAECONNRESET, "Last error was %ld\n", GetLastError());
10453 todo_wine ok(num_bytes == 0xdeadbeef, "Managed to read %ld\n", num_bytes);
10454
10455 SetLastError(0xdeadbeef);
10456 key = 0xdeadbeef;
10457 num_bytes = 0xdeadbeef;
10458 olp = (WSAOVERLAPPED *)0xdeadbeef;
10459
10460 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10461 todo_wine ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
10462 todo_wine ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10463 todo_wine ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10464 todo_wine ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10465 todo_wine ok(!olp, "Overlapped structure is at %p\n", olp);
10466
10467 closesocket(dest);
10468
10469 /* Test reading from a non-connected socket, mostly because the above test is marked todo. */
10470 dest = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10471 ok(dest != INVALID_SOCKET, "socket() failed\n");
10472
10473 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
10474 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10475 set_blocking(dest, FALSE);
10476
10477 num_bytes = 0xdeadbeef;
10478 SetLastError(0xdeadbeef);
10479 memset(&ov, 0, sizeof(ov));
10480
10481 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10482 ok(iret == SOCKET_ERROR, "WSARecv failed - %d\n", iret);
10483 ok(GetLastError() == WSAENOTCONN, "Last error was %ld\n", GetLastError());
10484 ok(num_bytes == 0xdeadbeef, "Managed to read %ld\n", num_bytes);
10485
10486 SetLastError(0xdeadbeef);
10487 key = 0xdeadbeef;
10488 num_bytes = 0xdeadbeef;
10489 olp = (WSAOVERLAPPED *)0xdeadbeef;
10490
10491 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10492 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
10493 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10494 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10495 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10496 ok(!olp, "Overlapped structure is at %p\n", olp);
10497
10498 num_bytes = 0xdeadbeef;
10499 closesocket(dest);
10500
10501 dest = socket(AF_INET, SOCK_STREAM, 0);
10502 ok(dest != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10503
10504 iret = WSAIoctl(dest, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
10505 &pAcceptEx, sizeof(pAcceptEx), &num_bytes, NULL, NULL);
10506 ok(!iret, "failed to get AcceptEx, error %u\n", WSAGetLastError());
10507
10508 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
10509
10510 src = setup_iocp_src(&bindAddress);
10511
10512 SetLastError(0xdeadbeef);
10513
10514 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10515 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10516 &num_bytes, &ov);
10517 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10518 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10519
10520 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10521 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10522
10523 closesocket(src);
10524 src = INVALID_SOCKET;
10525
10526 SetLastError(0xdeadbeef);
10527 key = 0xdeadbeef;
10528 num_bytes = 0xdeadbeef;
10529 olp = (WSAOVERLAPPED *)0xdeadbeef;
10530
10531 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10532 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10533 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10534 ok(key == 125, "Key is %Iu\n", key);
10535 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10536 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10537 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10538
10539 SetLastError(0xdeadbeef);
10540 key = 0xdeadbeef;
10541 num_bytes = 0xdeadbeef;
10542 olp = (WSAOVERLAPPED *)0xdeadbeef;
10543 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10544 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10545 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10546 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10547 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10548 ok(!olp, "Overlapped structure is at %p\n", olp);
10549
10550 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
10551
10552 src = setup_iocp_src(&bindAddress);
10553
10554 SetLastError(0xdeadbeef);
10555
10556 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10557 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10558
10559 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10560 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10561 &num_bytes, &ov);
10562 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10563 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10564
10565 closesocket(src);
10566 src = INVALID_SOCKET;
10567
10568 SetLastError(0xdeadbeef);
10569 key = 0xdeadbeef;
10570 num_bytes = 0xdeadbeef;
10571 olp = (WSAOVERLAPPED *)0xdeadbeef;
10572
10573 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10574 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10575 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10576 ok(key == 125, "Key is %Iu\n", key);
10577 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10578 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10579 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10580
10581 SetLastError(0xdeadbeef);
10582 key = 0xdeadbeef;
10583 num_bytes = 0xdeadbeef;
10584 olp = (WSAOVERLAPPED *)0xdeadbeef;
10585 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10586 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10587 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10588 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10589 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10590 ok(!olp, "Overlapped structure is at %p\n", olp);
10591
10592 /* Test IOCP with duplicated handle */
10593
10594 src = setup_iocp_src(&bindAddress);
10595
10596 SetLastError(0xdeadbeef);
10597
10598 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10599 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10600
10601 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10602 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10603 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10604
10605 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10606 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10607 &num_bytes, &ov);
10608 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10609 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10610
10611 SetLastError(0xdeadbeef);
10612 key = 0xdeadbeef;
10613 num_bytes = 0xdeadbeef;
10614 olp = (WSAOVERLAPPED *)0xdeadbeef;
10615 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10616 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10617 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10618 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10619 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10620 ok(!olp, "Overlapped structure is at %p\n", olp);
10621
10622 closesocket(src);
10623 src = INVALID_SOCKET;
10624 closesocket(dup);
10625 dup = INVALID_SOCKET;
10626
10627 SetLastError(0xdeadbeef);
10628 key = 0xdeadbeef;
10629 num_bytes = 0xdeadbeef;
10630 olp = (WSAOVERLAPPED *)0xdeadbeef;
10631 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10632 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10633 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10634 ok(key == 125, "Key is %Iu\n", key);
10635 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10636 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10637 ok(olp && olp->Internal == (ULONG)STATUS_CANCELLED, "Internal status is %Ix\n", olp ? olp->Internal : 0);
10638
10639 SetLastError(0xdeadbeef);
10640 key = 0xdeadbeef;
10641 num_bytes = 0xdeadbeef;
10642 olp = (WSAOVERLAPPED *)0xdeadbeef;
10643 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10644 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10645 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10646 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10647 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10648 ok(!olp, "Overlapped structure is at %p\n", olp);
10649
10650 /* Test IOCP with duplicated handle (closing duplicated handle) */
10651
10652 src = setup_iocp_src(&bindAddress);
10653
10654 SetLastError(0xdeadbeef);
10655
10656 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10657 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10658
10659 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10660 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10661 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10662
10663 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10664 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10665 &num_bytes, &ov);
10666 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10667 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10668
10669 closesocket(dup);
10670 dup = INVALID_SOCKET;
10671
10672 SetLastError(0xdeadbeef);
10673 key = 0xdeadbeef;
10674 num_bytes = 0xdeadbeef;
10675 olp = (WSAOVERLAPPED *)0xdeadbeef;
10676 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10677 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10678 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10679 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10680 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10681 ok(!olp, "Overlapped structure is at %p\n", olp);
10682
10683 SetLastError(0xdeadbeef);
10684 key = 0xdeadbeef;
10685 num_bytes = 0xdeadbeef;
10686 olp = (WSAOVERLAPPED *)0xdeadbeef;
10687 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10688 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10689 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10690 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10691 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10692 ok(!olp, "Overlapped structure is at %p\n", olp);
10693
10694 closesocket(src);
10695 src = INVALID_SOCKET;
10696
10697 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10698 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10699 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10700 ok(key == 125, "Key is %Iu\n", key);
10701 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10702 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10703 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10704
10705 SetLastError(0xdeadbeef);
10706 key = 0xdeadbeef;
10707 num_bytes = 0xdeadbeef;
10708 olp = (WSAOVERLAPPED *)0xdeadbeef;
10709 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10710 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10711 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10712 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10713 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10714 ok(!olp, "Overlapped structure is at %p\n", olp);
10715
10716 /* Test IOCP with duplicated handle (closing original handle) */
10717
10718 src = setup_iocp_src(&bindAddress);
10719
10720 SetLastError(0xdeadbeef);
10721
10722 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10723 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10724
10725 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10726 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10727 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10728
10729 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10730 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10731 &num_bytes, &ov);
10732 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10733 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10734
10735 closesocket(src);
10736 src = INVALID_SOCKET;
10737
10738 SetLastError(0xdeadbeef);
10739 key = 0xdeadbeef;
10740 num_bytes = 0xdeadbeef;
10741 olp = (WSAOVERLAPPED *)0xdeadbeef;
10742 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10743 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10744 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10745 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10746 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10747 ok(!olp, "Overlapped structure is at %p\n", olp);
10748
10749 closesocket(dup);
10750 dup = INVALID_SOCKET;
10751
10752 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10753 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10754 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10755 ok(key == 125, "Key is %Iu\n", key);
10756 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10757 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10758 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10759
10760 SetLastError(0xdeadbeef);
10761 key = 0xdeadbeef;
10762 num_bytes = 0xdeadbeef;
10763 olp = (WSAOVERLAPPED *)0xdeadbeef;
10764 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10765 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10766 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10767 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10768 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10769 ok(!olp, "Overlapped structure is at %p\n", olp);
10770
10771 /* Test IOCP without AcceptEx */
10772
10773 src = setup_iocp_src(&bindAddress);
10774
10775 SetLastError(0xdeadbeef);
10776
10777 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10778 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10779
10780 closesocket(src);
10781 src = INVALID_SOCKET;
10782
10783 SetLastError(0xdeadbeef);
10784 key = 0xdeadbeef;
10785 num_bytes = 0xdeadbeef;
10786 olp = (WSAOVERLAPPED *)0xdeadbeef;
10787 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10788 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10789 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10790 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10791 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10792 ok(!olp, "Overlapped structure is at %p\n", olp);
10793
10794 /* */
10795
10796 src = setup_iocp_src(&bindAddress);
10797
10798 connector = socket(AF_INET, SOCK_STREAM, 0);
10799 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10800
10801 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10802 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10803
10804 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 236, 0);
10805 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10806
10807 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10808 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10809 &num_bytes, &ov);
10810 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10811 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10812
10813 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10814 ok(iret == 0, "connecting to accepting socket failed, error %ld\n", GetLastError());
10815
10816 closesocket(connector);
10817 connector = INVALID_SOCKET;
10818
10819 SetLastError(0xdeadbeef);
10820 key = 0xdeadbeef;
10821 num_bytes = 0xdeadbeef;
10822 olp = (WSAOVERLAPPED *)0xdeadbeef;
10823
10824 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10825 ok(bret == TRUE, "failed to get completion status %u\n", bret);
10826 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
10827 ok(key == 125, "Key is %Iu\n", key);
10828 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10829 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10830 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10831
10832 SetLastError(0xdeadbeef);
10833 key = 0xdeadbeef;
10834 num_bytes = 0xdeadbeef;
10835 olp = (WSAOVERLAPPED *)0xdeadbeef;
10836 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10837 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10838 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10839 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10840 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10841 ok(!olp, "Overlapped structure is at %p\n", olp);
10842
10843 if (dest != INVALID_SOCKET)
10844 closesocket(dest);
10845 if (src != INVALID_SOCKET)
10846 closesocket(dest);
10847
10848 /* */
10849
10850 src = setup_iocp_src(&bindAddress);
10851
10852 dest = socket(AF_INET, SOCK_STREAM, 0);
10853 ok(dest != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10854
10855 connector = socket(AF_INET, SOCK_STREAM, 0);
10856 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10857
10858 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10859 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10860
10861 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 236, 0);
10862 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10863
10864 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10865 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10866 &num_bytes, &ov);
10867 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10868 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10869
10870 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10871 ok(iret == 0, "connecting to accepting socket failed, error %ld\n", GetLastError());
10872
10873 iret = send(connector, buf, 1, 0);
10874 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
10875
10876 Sleep(100);
10877
10878 closesocket(dest);
10879 dest = INVALID_SOCKET;
10880
10881 SetLastError(0xdeadbeef);
10882 key = 0xdeadbeef;
10883 num_bytes = 0xdeadbeef;
10884 olp = (WSAOVERLAPPED *)0xdeadbeef;
10885
10886 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10887 ok(bret == TRUE, "failed to get completion status %u\n", bret);
10888 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
10889 ok(key == 125, "Key is %Iu\n", key);
10890 ok(num_bytes == 1, "Number of bytes transferred is %lu\n", num_bytes);
10891 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10892 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10893
10894 SetLastError(0xdeadbeef);
10895 key = 0xdeadbeef;
10896 num_bytes = 0xdeadbeef;
10897 olp = (WSAOVERLAPPED *)0xdeadbeef;
10898 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10899 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10900 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10901 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10902 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10903 ok(!olp, "Overlapped structure is at %p\n", olp);
10904
10905 if (src != INVALID_SOCKET)
10906 closesocket(src);
10907 if (connector != INVALID_SOCKET)
10908 closesocket(connector);
10909
10910 /* */
10911
10912 src = setup_iocp_src(&bindAddress);
10913
10914 dest = socket(AF_INET, SOCK_STREAM, 0);
10915 ok(dest != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10916
10917 connector = socket(AF_INET, SOCK_STREAM, 0);
10918 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10919
10920 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10921 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10922
10923 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 236, 0);
10924 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10925
10926 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10927 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10928 &num_bytes, &ov);
10929 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10930 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10931
10932 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10933 ok(iret == 0, "connecting to accepting socket failed, error %ld\n", GetLastError());
10934
10935 closesocket(dest);
10936
10937 SetLastError(0xdeadbeef);
10938 key = 0xdeadbeef;
10939 num_bytes = 0xdeadbeef;
10940 olp = (WSAOVERLAPPED *)0xdeadbeef;
10941
10942 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10943 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10944 ok(GetLastError() == ERROR_OPERATION_ABORTED
10945 || GetLastError() == ERROR_CONNECTION_ABORTED, "got error %lu\n", GetLastError());
10946 ok(key == 125, "Key is %Iu\n", key);
10947 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10948 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10949 ok((NTSTATUS)olp->Internal == STATUS_CANCELLED
10950 || (NTSTATUS)olp->Internal == STATUS_CONNECTION_ABORTED, "got status %#Ix\n", olp->Internal);
10951
10952 SetLastError(0xdeadbeef);
10953 key = 0xdeadbeef;
10954 num_bytes = 0xdeadbeef;
10955 olp = (WSAOVERLAPPED *)0xdeadbeef;
10956 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10957 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10958 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10959 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10960 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10961 ok(!olp, "Overlapped structure is at %p\n", olp);
10962
10963 closesocket(src);
10964 closesocket(connector);
10965 CloseHandle(io_port);
10966 }
10967
10968 static void test_connect_completion_port(void)
10969 {
10970 OVERLAPPED overlapped = {0}, *overlapped_ptr;
10971 GUID connectex_guid = WSAID_CONNECTEX;
10972 SOCKET connector, listener, acceptor;
10973 struct sockaddr_in addr, destaddr;
10974 LPFN_CONNECTEX pConnectEx;
10975 int ret, addrlen;
10976 ULONG_PTR key;
10977 HANDLE port;
10978 DWORD size;
10979
10980 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10981
10982 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10983 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
10984
10985 memset(&addr, 0, sizeof(addr));
10986 addr.sin_family = AF_INET;
10987 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
10988 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
10989 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
10990 addrlen = sizeof(destaddr);
10991 ret = getsockname(listener, (struct sockaddr *)&destaddr, &addrlen);
10992 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
10993
10994 ret = listen(listener, 1);
10995 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
10996
10997 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10998 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
10999
11000 ret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectex_guid, sizeof(connectex_guid),
11001 &pConnectEx, sizeof(pConnectEx), &size, NULL, NULL);
11002 ok(!ret, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
11003
11004 /* connect() does not queue completion. */
11005
11006 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11007 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11008
11009 ret = connect(connector, (struct sockaddr *)&destaddr, sizeof(destaddr));
11010 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11011 acceptor = accept(listener, NULL, NULL);
11012 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11013 closesocket(acceptor);
11014
11015 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11016 ok(!ret, "expected failure\n");
11017 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11018
11019 closesocket(connector);
11020 CloseHandle(port);
11021
11022 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11023 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11024 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11025 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11026 set_blocking(connector, FALSE);
11027
11028 ret = connect(connector, (struct sockaddr *)&destaddr, sizeof(destaddr));
11029 ok(ret == -1, "expected failure\n");
11030 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
11031 acceptor = accept(listener, NULL, NULL);
11032 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11033 closesocket(acceptor);
11034
11035 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11036 ok(!ret, "expected failure\n");
11037 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11038
11039 closesocket(connector);
11040 CloseHandle(port);
11041
11042 /* ConnectEx() queues completion. */
11043
11044 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11045 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11046 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11047 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11048 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
11049 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11050
11051 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
11052 NULL, 0, &size, &overlapped);
11053 ok(!ret, "expected failure\n");
11054 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11055 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11056 ok(!ret, "wait failed\n");
11057 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
11058 ok(ret, "got error %lu\n", GetLastError());
11059 ok(!size, "got %lu bytes\n", size);
11060 acceptor = accept(listener, NULL, NULL);
11061 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11062 closesocket(acceptor);
11063
11064 size = 0xdeadbeef;
11065 key = 0xdeadbeef;
11066 overlapped_ptr = NULL;
11067 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11068 ok(ret, "got error %lu\n", GetLastError());
11069 ok(!key, "got key %#Ix\n", key);
11070 ok(!size, "got %lu bytes\n", size);
11071 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11072
11073 closesocket(connector);
11074 CloseHandle(port);
11075
11076 /* Test ConnectEx() with a non-empty buffer. */
11077
11078 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11079 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11080 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11081 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11082 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
11083 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11084
11085 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
11086 (void *)"one", 3, &size, &overlapped);
11087 ok(!ret, "expected failure\n");
11088 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11089 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11090 ok(!ret, "wait failed\n");
11091 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
11092 ok(ret, "got error %lu\n", GetLastError());
11093 ok(size == 3, "got %lu bytes\n", size);
11094 acceptor = accept(listener, NULL, NULL);
11095 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11096 closesocket(acceptor);
11097
11098 size = 0xdeadbeef;
11099 key = 0xdeadbeef;
11100 overlapped_ptr = NULL;
11101 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11102 ok(ret, "got error %lu\n", GetLastError());
11103 ok(!key, "got key %#Ix\n", key);
11104 ok(size == 3, "got %lu bytes\n", size);
11105 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11106
11107 closesocket(connector);
11108 CloseHandle(port);
11109
11110 /* Suppress completion by setting the low bit. */
11111
11112 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11113 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11114 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11115 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11116 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
11117 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11118
11119 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent | 1);
11120
11121 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
11122 NULL, 0, &size, &overlapped);
11123 ok(!ret, "expected failure\n");
11124 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11125 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11126 ok(!ret, "wait failed\n");
11127 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
11128 ok(ret, "got error %lu\n", GetLastError());
11129 ok(!size, "got %lu bytes\n", size);
11130 acceptor = accept(listener, NULL, NULL);
11131 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11132 closesocket(acceptor);
11133
11134 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11135 ok(!ret, "expected failure\n");
11136 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11137
11138 closesocket(connector);
11139 CloseHandle(port);
11140
11141 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent & ~1);
11142
11143 /* Skip completion on success. */
11144
11145 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11146 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11147 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11148 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11149 ret = SetFileCompletionNotificationModes((HANDLE)connector, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS);
11150 ok(ret, "got error %lu\n", GetLastError());
11151 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
11152 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11153
11154 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
11155 NULL, 0, &size, &overlapped);
11156 ok(!ret, "expected failure\n");
11157 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11158 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11159 ok(!ret, "wait failed\n");
11160 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
11161 ok(ret, "got error %lu\n", GetLastError());
11162 ok(!size, "got %lu bytes\n", size);
11163 acceptor = accept(listener, NULL, NULL);
11164 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11165 closesocket(acceptor);
11166
11167 size = 0xdeadbeef;
11168 key = 0xdeadbeef;
11169 overlapped_ptr = NULL;
11170 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11171 ok(ret, "got error %lu\n", GetLastError());
11172 ok(!key, "got key %#Ix\n", key);
11173 ok(!size, "got %lu bytes\n", size);
11174 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11175
11176 closesocket(connector);
11177 CloseHandle(port);
11178
11179 closesocket(listener);
11180
11181 /* Connect to an invalid address. */
11182
11183 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11184 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11185 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11186 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11187 ret = SetFileCompletionNotificationModes((HANDLE)connector, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS);
11188 ok(ret, "got error %lu\n", GetLastError());
11189 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
11190 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11191
11192 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
11193 NULL, 0, &size, &overlapped);
11194 ok(!ret, "expected failure\n");
11195 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11196 ret = WaitForSingleObject(overlapped.hEvent, 15000);
11197 ok(!ret, "wait failed\n");
11198 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
11199 ok(!ret, "expected failure\n");
11200 ok(GetLastError() == ERROR_CONNECTION_REFUSED, "got error %lu\n", GetLastError());
11201 ok(!size, "got %lu bytes\n", size);
11202
11203 size = 0xdeadbeef;
11204 key = 0xdeadbeef;
11205 overlapped_ptr = NULL;
11206 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11207 ok(!ret, "expected failure\n");
11208 ok(GetLastError() == ERROR_CONNECTION_REFUSED, "got error %lu\n", GetLastError());
11209 ok(!key, "got key %#Ix\n", key);
11210 ok(!size, "got %lu bytes\n", size);
11211 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11212
11213 closesocket(connector);
11214 CloseHandle(port);
11215 }
11216
11217 static void test_shutdown_completion_port(void)
11218 {
11219 OVERLAPPED overlapped = {0}, *overlapped_ptr;
11220 GUID disconnectex_guid = WSAID_DISCONNECTEX;
11221 struct sockaddr_in addr, destaddr;
11222 LPFN_DISCONNECTEX pDisconnectEx;
11223 SOCKET listener, server, client;
11224 int ret, addrlen;
11225 ULONG_PTR key;
11226 HANDLE port;
11227 DWORD size;
11228
11229 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
11230
11231 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11232 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
11233
11234 memset(&addr, 0, sizeof(addr));
11235 addr.sin_family = AF_INET;
11236 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
11237 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
11238 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11239 addrlen = sizeof(destaddr);
11240 ret = getsockname(listener, (struct sockaddr *)&destaddr, &addrlen);
11241 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
11242
11243 ret = listen(listener, 1);
11244 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
11245
11246 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11247 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11248
11249 ret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &disconnectex_guid, sizeof(disconnectex_guid),
11250 &pDisconnectEx, sizeof(pDisconnectEx), &size, NULL, NULL);
11251 ok(!ret, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
11252
11253 /* shutdown() does not queue completion. */
11254
11255 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11256 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11257 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11258 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11259 server = accept(listener, NULL, NULL);
11260 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11261
11262 ret = shutdown(client, SD_BOTH);
11263 ok(!ret, "failed to shutdown, error %u\n", WSAGetLastError());
11264
11265 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11266 ok(!ret, "expected failure\n");
11267 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11268
11269 closesocket(server);
11270 closesocket(client);
11271 CloseHandle(port);
11272
11273 /* WSASendDisconnect() and WSARecvDisconnect() do not queue completion. */
11274
11275 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11276 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11277 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11278 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11279 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11280 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11281 server = accept(listener, NULL, NULL);
11282 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11283
11284 ret = WSASendDisconnect(client, NULL);
11285 ok(!ret, "failed to shutdown, error %u\n", WSAGetLastError());
11286
11287 ret = WSARecvDisconnect(client, NULL);
11288 ok(!ret, "failed to shutdown, error %u\n", WSAGetLastError());
11289
11290 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11291 ok(!ret, "expected failure\n");
11292 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11293
11294 closesocket(server);
11295 closesocket(client);
11296 CloseHandle(port);
11297
11298 /* DisconnectEx() queues completion. */
11299
11300 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11301 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11302 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11303 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11304 ret = SetFileCompletionNotificationModes((HANDLE)client, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS);
11305 ok(ret, "got error %lu\n", GetLastError());
11306 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11307 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11308 server = accept(listener, NULL, NULL);
11309 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11310
11311 SetLastError(0xdeadbeef);
11312 ret = pDisconnectEx(client, &overlapped, 0, 0);
11313 ok(!ret, "expected failure\n");
11314 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11315
11316 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11317 ok(!ret, "wait failed\n");
11318
11319 size = 0xdeadbeef;
11320 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, TRUE);
11321 ok(ret, "got error %lu\n", GetLastError());
11322 ok(!size, "got %lu bytes\n", size);
11323
11324 size = 0xdeadbeef;
11325 key = 0xdeadbeef;
11326 overlapped_ptr = NULL;
11327 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11328 todo_wine ok(ret, "got error %lu\n", GetLastError());
11329 todo_wine ok(!key, "got key %#Ix\n", key);
11330 todo_wine ok(!size, "got %lu bytes\n", size);
11331 todo_wine ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11332
11333 closesocket(server);
11334 closesocket(client);
11335 CloseHandle(port);
11336
11337 /* Test passing a NULL overlapped structure to DisconnectEx(). */
11338
11339 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11340 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11341 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11342 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11343 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11344 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11345 server = accept(listener, NULL, NULL);
11346 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11347
11348 SetLastError(0xdeadbeef);
11349 ret = pDisconnectEx(client, NULL, 0, 0);
11350 ok(ret, "expected success\n");
11351 ok(!GetLastError() || GetLastError() == 0xdeadbeef /* < 7 */, "got error %lu\n", GetLastError());
11352
11353 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11354 ok(!ret, "expected failure\n");
11355 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11356
11357 closesocket(server);
11358 closesocket(client);
11359 CloseHandle(port);
11360
11361 /* Suppress completion by setting the low bit. */
11362
11363 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11364 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11365 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11366 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11367 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11368 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11369 server = accept(listener, NULL, NULL);
11370 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11371
11372 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent | 1);
11373
11374 SetLastError(0xdeadbeef);
11375 ret = pDisconnectEx(client, &overlapped, 0, 0);
11376 ok(!ret, "expected failure\n");
11377 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11378
11379 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11380 ok(!ret, "wait failed\n");
11381
11382 size = 0xdeadbeef;
11383 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, TRUE);
11384 ok(ret, "got error %lu\n", GetLastError());
11385 ok(!size, "got %lu bytes\n", size);
11386
11387 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11388 ok(!ret, "expected failure\n");
11389 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11390
11391 closesocket(server);
11392 closesocket(client);
11393 CloseHandle(port);
11394
11395 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent & ~1);
11396
11397 CloseHandle(overlapped.hEvent);
11398 }
11399
11400 static void test_address_list_query(void)
11401 {
11402 char buffer[1024];
11403 SOCKET_ADDRESS_LIST *address_list = (SOCKET_ADDRESS_LIST *)buffer;
11404 OVERLAPPED overlapped = {0}, *overlapped_ptr;
11405 DWORD size, expect_size;
11406 unsigned int i;
11407 ULONG_PTR key;
11408 HANDLE port;
11409 SOCKET s;
11410 int ret;
11411
11412 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11413 ok(s != INVALID_SOCKET, "Failed to create socket, error %d.\n", WSAGetLastError());
11414 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
11415
11416 size = 0;
11417 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, 0, &size, NULL, NULL);
11418 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11419 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11420 ok(size >= FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), "Got unexpected size %lu.\n", size);
11421 expect_size = size;
11422
11423 size = 0;
11424 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), &size, NULL, NULL);
11425 ok(!ret, "Got unexpected ret %d.\n", ret);
11426 ok(!WSAGetLastError(), "Got unexpected error %d.\n", WSAGetLastError());
11427 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11428
11429 expect_size = FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[address_list->iAddressCount]);
11430 for (i = 0; i < address_list->iAddressCount; ++i)
11431 {
11432 expect_size += address_list->Address[i].iSockaddrLength;
11433 }
11434 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11435
11436 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), NULL, NULL, NULL);
11437 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11438 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11439
11440 size = 0xdeadbeef;
11441 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, sizeof(buffer), &size, NULL, NULL);
11442 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11443 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11444 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11445
11446 size = 0xdeadbeef;
11447 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 0, &size, NULL, NULL);
11448 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11449 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11450 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11451
11452 size = 0xdeadbeef;
11453 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 1, &size, NULL, NULL);
11454 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11455 ok(WSAGetLastError() == WSAEINVAL, "Got unexpected error %d.\n", WSAGetLastError());
11456 ok(!size, "Got size %lu.\n", size);
11457
11458 size = 0xdeadbeef;
11459 memset(buffer, 0xcc, sizeof(buffer));
11460 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer,
11461 FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), &size, NULL, NULL);
11462 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11463 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11464 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11465 ok(address_list->iAddressCount == 0xcccccccc, "Got %u addresses.\n", address_list->iAddressCount);
11466
11467 WSASetLastError(0xdeadbeef);
11468 overlapped.Internal = 0xdeadbeef;
11469 overlapped.InternalHigh = 0xdeadbeef;
11470 size = 0xdeadbeef;
11471 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 0, &size, &overlapped, NULL);
11472 ok(ret == -1, "Got unexpected ret %d.\n", ret);
11473 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11474 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11475 ok(overlapped.Internal == 0xdeadbeef, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
11476 ok(overlapped.InternalHigh == 0xdeadbeef, "Got size %Iu.\n", overlapped.InternalHigh);
11477
11478 overlapped.Internal = 0xdeadbeef;
11479 overlapped.InternalHigh = 0xdeadbeef;
11480 size = 0xdeadbeef;
11481 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 1, &size, &overlapped, NULL);
11482 ok(ret == -1, "Got unexpected ret %d.\n", ret);
11483 ok(WSAGetLastError() == WSAEINVAL, "Got unexpected error %d.\n", WSAGetLastError());
11484 ok(!size, "Expected size %lu, got %lu.\n", expect_size, size);
11485 ok(overlapped.Internal == 0xdeadbeef, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
11486 ok(overlapped.InternalHigh == 0xdeadbeef, "Got size %Iu.\n", overlapped.InternalHigh);
11487
11488 overlapped.Internal = 0xdeadbeef;
11489 overlapped.InternalHigh = 0xdeadbeef;
11490 size = 0xdeadbeef;
11491 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer,
11492 FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), &size, &overlapped, NULL);
11493 ok(ret == -1, "Got unexpected ret %d.\n", ret);
11494 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11495 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11496 ok(overlapped.Internal == 0xdeadbeef, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
11497 ok(overlapped.InternalHigh == 0xdeadbeef, "Got size %Iu.\n", overlapped.InternalHigh);
11498 ok(address_list->iAddressCount == 0xcccccccc, "Got %u addresses.\n", address_list->iAddressCount);
11499
11500 overlapped.Internal = 0xdeadbeef;
11501 overlapped.InternalHigh = 0xdeadbeef;
11502 size = 0xdeadbeef;
11503 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), &size, &overlapped, NULL);
11504 ok(!ret, "Got unexpected ret %d.\n", ret);
11505 ok(!WSAGetLastError(), "Got unexpected error %d.\n", WSAGetLastError());
11506 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11507
11508 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11509 ok(ret, "Got error %lu.\n", GetLastError());
11510 ok(!size, "Got size %lu.\n", size);
11511 ok(overlapped_ptr == &overlapped, "Got overlapped %p.\n", overlapped_ptr);
11512 ok(!overlapped.Internal, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
11513 ok(!overlapped.InternalHigh, "Got size %Iu.\n", overlapped.InternalHigh);
11514
11515 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11516 ok(!ret, "Expected failure.\n");
11517 ok(GetLastError() == WAIT_TIMEOUT, "Got error %lu.\n", GetLastError());
11518
11519 closesocket(s);
11520 CloseHandle(port);
11521
11522 /* Test with an APC. */
11523
11524 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11525
11526 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), NULL, &overlapped, socket_apc);
11527 ok(ret == -1, "expected failure\n");
11528 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
11529
11530 apc_count = 0;
11531 size = 0xdeadbeef;
11532 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), &size, &overlapped, socket_apc);
11533 ok(!ret, "expected success\n");
11534 ok(size == expect_size, "got size %lu\n", size);
11535
11536 ret = SleepEx(0, TRUE);
11537 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
11538 ok(apc_count == 1, "APC was called %u times\n", apc_count);
11539 ok(!apc_error, "got APC error %lu\n", apc_error);
11540 ok(!apc_size, "got APC size %lu\n", apc_size);
11541 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
11542
11543 closesocket(s);
11544 }
11545
11546 static void sync_read(SOCKET src, SOCKET dst)
11547 {
11548 int ret;
11549 char data[512];
11550
11551 ret = send(dst, "Hello World!", 12, 0);
11552 ok(ret == 12, "send returned %d\n", ret);
11553
11554 memset(data, 0, sizeof(data));
11555 ret = recv(src, data, sizeof(data), 0);
11556 ok(ret == 12, "expected 12, got %d\n", ret);
11557 ok(!memcmp(data, "Hello World!", 12), "got %u bytes (%*s)\n", ret, ret, data);
11558 }
11559
11560 static void iocp_async_read(SOCKET src, SOCKET dst)
11561 {
11562 HANDLE port;
11563 WSAOVERLAPPED ovl, *ovl_iocp;
11564 WSABUF buf;
11565 int ret;
11566 char data[512];
11567 DWORD flags, bytes;
11568 ULONG_PTR key;
11569
11570 memset(data, 0, sizeof(data));
11571 memset(&ovl, 0, sizeof(ovl));
11572
11573 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11574 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
11575
11576 buf.len = sizeof(data);
11577 buf.buf = data;
11578 bytes = 0xdeadbeef;
11579 flags = 0;
11580 SetLastError(0xdeadbeef);
11581 ret = WSARecv(src, &buf, 1, &bytes, &flags, &ovl, NULL);
11582 ok(ret == SOCKET_ERROR, "got %d\n", ret);
11583 ok(GetLastError() == ERROR_IO_PENDING, "got %lu\n", GetLastError());
11584 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11585
11586 bytes = 0xdeadbeef;
11587 key = 0xdeadbeef;
11588 ovl_iocp = (void *)0xdeadbeef;
11589 SetLastError(0xdeadbeef);
11590 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11591 ok(!ret, "got %d\n", ret);
11592 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11593 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11594 ok(key == 0xdeadbeef, "got key %#Ix\n", key);
11595 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11596
11597 ret = send(dst, "Hello World!", 12, 0);
11598 ok(ret == 12, "send returned %d\n", ret);
11599
11600 bytes = 0xdeadbeef;
11601 key = 0xdeadbeef;
11602 ovl_iocp = NULL;
11603 SetLastError(0xdeadbeef);
11604 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11605 ok(ret, "got %d\n", ret);
11606 ok(bytes == 12, "got bytes %lu\n", bytes);
11607 ok(key == 0x12345678, "got key %#Ix\n", key);
11608 ok(ovl_iocp == &ovl, "got ovl %p\n", ovl_iocp);
11609 if (ovl_iocp)
11610 {
11611 ok(ovl_iocp->InternalHigh == 12, "got %#Ix\n", ovl_iocp->InternalHigh);
11612 ok(!ovl_iocp->Internal , "got %#Ix\n", ovl_iocp->Internal);
11613 ok(!memcmp(data, "Hello World!", 12), "got %lu bytes (%*s)\n", bytes, (int)bytes, data);
11614 }
11615
11616 bytes = 0xdeadbeef;
11617 key = 0xdeadbeef;
11618 ovl_iocp = (void *)0xdeadbeef;
11619 SetLastError(0xdeadbeef);
11620 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11621 ok(!ret, "got %d\n", ret);
11622 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11623 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11624 ok(key == 0xdeadbeef, "got key %#Ix\n", key);
11625 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11626
11627 CloseHandle(port);
11628 }
11629
11630 static void iocp_async_read_closesocket(SOCKET src, int how_to_close)
11631 {
11632 HANDLE port;
11633 WSAOVERLAPPED ovl, *ovl_iocp;
11634 WSABUF buf;
11635 int ret;
11636 char data[512];
11637 DWORD flags, bytes;
11638 ULONG_PTR key;
11639 HWND hwnd;
11640 MSG msg;
11641
11642 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
11643 0, 0, 0, 0, NULL, NULL, 0, NULL);
11644 ok(hwnd != 0, "CreateWindowEx failed\n");
11645
11646 ret = WSAAsyncSelect(src, hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
11647 ok(!ret, "got %d\n", ret);
11648
11649 Sleep(100);
11650 memset(&msg, 0, sizeof(msg));
11651 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11652 ok(ret, "got %d\n", ret);
11653 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11654 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11655 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
11656 ok(msg.lParam == 2, "got %08Ix\n", msg.lParam);
11657
11658 memset(data, 0, sizeof(data));
11659 memset(&ovl, 0, sizeof(ovl));
11660
11661 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11662 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
11663
11664 Sleep(100);
11665 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11666 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11667
11668 buf.len = sizeof(data);
11669 buf.buf = data;
11670 bytes = 0xdeadbeef;
11671 flags = 0;
11672 SetLastError(0xdeadbeef);
11673 ret = WSARecv(src, &buf, 1, &bytes, &flags, &ovl, NULL);
11674 ok(ret == SOCKET_ERROR, "got %d\n", ret);
11675 ok(GetLastError() == ERROR_IO_PENDING, "got %lu\n", GetLastError());
11676 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11677
11678 Sleep(100);
11679 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11680 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11681
11682 bytes = 0xdeadbeef;
11683 key = 0xdeadbeef;
11684 ovl_iocp = (void *)0xdeadbeef;
11685 SetLastError(0xdeadbeef);
11686 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11687 ok(!ret, "got %d\n", ret);
11688 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11689 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11690 ok(key == 0xdeadbeef, "got key %#Ix\n", key);
11691 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11692
11693 Sleep(100);
11694 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11695 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11696
11697 switch (how_to_close)
11698 {
11699 case 0:
11700 closesocket(src);
11701 break;
11702 case 1:
11703 CloseHandle((HANDLE)src);
11704 break;
11705 case 2:
11706 pNtClose((HANDLE)src);
11707 break;
11708 default:
11709 ok(0, "wrong value %d\n", how_to_close);
11710 break;
11711 }
11712
11713 Sleep(200);
11714 memset(&msg, 0, sizeof(msg));
11715 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11716 switch (how_to_close)
11717 {
11718 case 0:
11719 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11720 break;
11721 case 1:
11722 case 2:
11723 todo_wine
11724 {
11725 ok(ret, "got %d\n", ret);
11726 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11727 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11728 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
11729 ok(msg.lParam == 0x20, "got %08Ix\n", msg.lParam);
11730 }
11731 break;
11732 default:
11733 ok(0, "wrong value %d\n", how_to_close);
11734 break;
11735 }
11736
11737 bytes = 0xdeadbeef;
11738 key = 0xdeadbeef;
11739 ovl_iocp = NULL;
11740 SetLastError(0xdeadbeef);
11741 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11742 ok(!ret, "got %d\n", ret);
11743 todo_wine
11744 ok(GetLastError() == ERROR_CONNECTION_ABORTED || GetLastError() == ERROR_NETNAME_DELETED /* XP */, "got %lu\n", GetLastError());
11745 ok(!bytes, "got bytes %lu\n", bytes);
11746 ok(key == 0x12345678, "got key %#Ix\n", key);
11747 ok(ovl_iocp == &ovl, "got ovl %p\n", ovl_iocp);
11748 if (ovl_iocp)
11749 {
11750 ok(!ovl_iocp->InternalHigh, "got %#Ix\n", ovl_iocp->InternalHigh);
11751 todo_wine
11752 ok(ovl_iocp->Internal == (ULONG)STATUS_CONNECTION_ABORTED || ovl_iocp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT /* XP */, "got %#Ix\n", ovl_iocp->Internal);
11753 }
11754
11755 bytes = 0xdeadbeef;
11756 key = 0xdeadbeef;
11757 ovl_iocp = (void *)0xdeadbeef;
11758 SetLastError(0xdeadbeef);
11759 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11760 ok(!ret, "got %d\n", ret);
11761 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11762 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11763 ok(key == 0xdeadbeef, "got key %#Ix\n", key);
11764 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11765
11766 CloseHandle(port);
11767
11768 DestroyWindow(hwnd);
11769 }
11770
11771 static void iocp_async_closesocket(SOCKET src)
11772 {
11773 HANDLE port;
11774 WSAOVERLAPPED *ovl_iocp;
11775 int ret;
11776 DWORD bytes;
11777 ULONG_PTR key;
11778 HWND hwnd;
11779 MSG msg;
11780
11781 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
11782 0, 0, 0, 0, NULL, NULL, 0, NULL);
11783 ok(hwnd != 0, "CreateWindowEx failed\n");
11784
11785 ret = WSAAsyncSelect(src, hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
11786 ok(!ret, "got %d\n", ret);
11787
11788 Sleep(100);
11789 memset(&msg, 0, sizeof(msg));
11790 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11791 ok(ret, "got %d\n", ret);
11792 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11793 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11794 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
11795 ok(msg.lParam == 2, "got %08Ix\n", msg.lParam);
11796
11797 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11798 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
11799
11800 Sleep(100);
11801 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11802 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11803
11804 bytes = 0xdeadbeef;
11805 key = 0xdeadbeef;
11806 ovl_iocp = (void *)0xdeadbeef;
11807 SetLastError(0xdeadbeef);
11808 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11809 ok(!ret, "got %d\n", ret);
11810 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11811 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11812 ok(key == 0xdeadbeef, "got key %Iu\n", key);
11813 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11814
11815 Sleep(100);
11816 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11817 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11818
11819 closesocket(src);
11820
11821 Sleep(100);
11822 memset(&msg, 0, sizeof(msg));
11823 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11824 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11825
11826 bytes = 0xdeadbeef;
11827 key = 0xdeadbeef;
11828 ovl_iocp = (void *)0xdeadbeef;
11829 SetLastError(0xdeadbeef);
11830 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11831 ok(!ret, "got %d\n", ret);
11832 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11833 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11834 ok(key == 0xdeadbeef, "got key %Iu\n", key);
11835 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11836
11837 CloseHandle(port);
11838
11839 DestroyWindow(hwnd);
11840 }
11841
11842 struct wsa_async_select_info
11843 {
11844 SOCKET sock;
11845 HWND hwnd;
11846 };
11847
11848 static DWORD WINAPI wsa_async_select_thread(void *param)
11849 {
11850 struct wsa_async_select_info *info = param;
11851 int ret;
11852
11853 ret = WSAAsyncSelect(info->sock, info->hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
11854 ok(!ret, "got %d\n", ret);
11855
11856 return 0;
11857 }
11858
11859 struct wsa_recv_info
11860 {
11861 SOCKET sock;
11862 WSABUF wsa_buf;
11863 WSAOVERLAPPED ovl;
11864 };
11865
11866 static DWORD WINAPI wsa_recv_thread(void *param)
11867 {
11868 struct wsa_recv_info *info = param;
11869 int ret;
11870 DWORD flags, bytes;
11871
11872 bytes = 0xdeadbeef;
11873 flags = 0;
11874 SetLastError(0xdeadbeef);
11875 ret = WSARecv(info->sock, &info->wsa_buf, 1, &bytes, &flags, &info->ovl, NULL);
11876 ok(ret == SOCKET_ERROR, "got %d\n", ret);
11877 ok(GetLastError() == ERROR_IO_PENDING, "got %lu\n", GetLastError());
11878 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11879
11880 return 0;
11881 }
11882
11883 static void iocp_async_read_thread_closesocket(SOCKET src)
11884 {
11885 struct wsa_async_select_info select_info;
11886 struct wsa_recv_info recv_info;
11887 HANDLE port, thread;
11888 WSAOVERLAPPED *ovl_iocp;
11889 int ret;
11890 char data[512];
11891 DWORD bytes, tid;
11892 ULONG_PTR key;
11893 HWND hwnd;
11894 MSG msg;
11895
11896 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
11897 0, 0, 0, 0, NULL, NULL, 0, NULL);
11898 ok(hwnd != 0, "CreateWindowEx failed\n");
11899
11900 select_info.sock = src;
11901 select_info.hwnd = hwnd;
11902 thread = CreateThread(NULL, 0, wsa_async_select_thread, &select_info, 0, &tid);
11903 ok(thread != 0, "CreateThread error %lu\n", GetLastError());
11904 ret = WaitForSingleObject(thread, 10000);
11905 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
11906
11907 Sleep(100);
11908 memset(&msg, 0, sizeof(msg));
11909 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11910 ok(ret, "got %d\n", ret);
11911 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11912 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11913 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
11914 ok(msg.lParam == 2, "got %08Ix\n", msg.lParam);
11915
11916 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11917 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
11918
11919 Sleep(100);
11920 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11921 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11922
11923 memset(data, 0, sizeof(data));
11924 memset(&recv_info.ovl, 0, sizeof(recv_info.ovl));
11925 recv_info.sock = src;
11926 recv_info.wsa_buf.len = sizeof(data);
11927 recv_info.wsa_buf.buf = data;
11928 thread = CreateThread(NULL, 0, wsa_recv_thread, &recv_info, 0, &tid);
11929 ok(thread != 0, "CreateThread error %lu\n", GetLastError());
11930 ret = WaitForSingleObject(thread, 10000);
11931 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
11932
11933 Sleep(100);
11934 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11935 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11936
11937 bytes = 0xdeadbeef;
11938 key = 0xdeadbeef;
11939 ovl_iocp = (void *)0xdeadbeef;
11940 SetLastError(0xdeadbeef);
11941 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11942 ok(!ret, "got %d\n", ret);
11943 ok(GetLastError() == WAIT_TIMEOUT || broken(GetLastError() == ERROR_OPERATION_ABORTED) /* XP */,
11944 "got %lu\n", GetLastError());
11945 if (GetLastError() == WAIT_TIMEOUT)
11946 {
11947 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11948 ok(key == 0xdeadbeef, "got key %Ix\n", key);
11949 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11950 }
11951 else /* document XP behaviour */
11952 {
11953 ok(!bytes, "got bytes %lu\n", bytes);
11954 ok(key == 0x12345678, "got key %#Ix\n", key);
11955 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
11956 if (ovl_iocp)
11957 {
11958 ok(!ovl_iocp->InternalHigh, "got %#Ix\n", ovl_iocp->InternalHigh);
11959 ok(ovl_iocp->Internal == STATUS_CANCELLED, "got %#Ix\n", ovl_iocp->Internal);
11960 }
11961
11962 closesocket(src);
11963 goto xp_is_broken;
11964 }
11965
11966 Sleep(100);
11967 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11968 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11969
11970 closesocket(src);
11971
11972 Sleep(100);
11973 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11974 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11975
11976 bytes = 0xdeadbeef;
11977 key = 0xdeadbeef;
11978 ovl_iocp = NULL;
11979 SetLastError(0xdeadbeef);
11980 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11981 ok(!ret, "got %d\n", ret);
11982 todo_wine
11983 ok(GetLastError() == ERROR_CONNECTION_ABORTED || GetLastError() == ERROR_NETNAME_DELETED /* XP */, "got %lu\n", GetLastError());
11984 ok(!bytes, "got bytes %lu\n", bytes);
11985 ok(key == 0x12345678, "got key %#Ix\n", key);
11986 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
11987 if (ovl_iocp)
11988 {
11989 ok(!ovl_iocp->InternalHigh, "got %#Ix\n", ovl_iocp->InternalHigh);
11990 todo_wine
11991 ok(ovl_iocp->Internal == (ULONG)STATUS_CONNECTION_ABORTED || ovl_iocp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT /* XP */, "got %#Ix\n", ovl_iocp->Internal);
11992 }
11993
11994 xp_is_broken:
11995 bytes = 0xdeadbeef;
11996 key = 0xdeadbeef;
11997 ovl_iocp = (void *)0xdeadbeef;
11998 SetLastError(0xdeadbeef);
11999 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
12000 ok(!ret, "got %d\n", ret);
12001 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
12002 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
12003 ok(key == 0xdeadbeef, "got key %Iu\n", key);
12004 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
12005
12006 CloseHandle(port);
12007
12008 DestroyWindow(hwnd);
12009 }
12010
12011 static void iocp_async_read_thread(SOCKET src, SOCKET dst)
12012 {
12013 struct wsa_async_select_info select_info;
12014 struct wsa_recv_info recv_info;
12015 HANDLE port, thread;
12016 WSAOVERLAPPED *ovl_iocp;
12017 int ret;
12018 char data[512];
12019 DWORD bytes, tid;
12020 ULONG_PTR key;
12021 HWND hwnd;
12022 MSG msg;
12023
12024 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
12025 0, 0, 0, 0, NULL, NULL, 0, NULL);
12026 ok(hwnd != 0, "CreateWindowEx failed\n");
12027
12028 select_info.sock = src;
12029 select_info.hwnd = hwnd;
12030 thread = CreateThread(NULL, 0, wsa_async_select_thread, &select_info, 0, &tid);
12031 ok(thread != 0, "CreateThread error %lu\n", GetLastError());
12032 ret = WaitForSingleObject(thread, 10000);
12033 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
12034
12035 Sleep(100);
12036 memset(&msg, 0, sizeof(msg));
12037 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12038 ok(ret, "got %d\n", ret);
12039 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
12040 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
12041 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
12042 ok(msg.lParam == 2, "got %08Ix\n", msg.lParam);
12043
12044 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
12045 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
12046
12047 Sleep(100);
12048 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12049 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12050
12051 memset(data, 0, sizeof(data));
12052 memset(&recv_info.ovl, 0, sizeof(recv_info.ovl));
12053 recv_info.sock = src;
12054 recv_info.wsa_buf.len = sizeof(data);
12055 recv_info.wsa_buf.buf = data;
12056 thread = CreateThread(NULL, 0, wsa_recv_thread, &recv_info, 0, &tid);
12057 ok(thread != 0, "CreateThread error %lu\n", GetLastError());
12058 ret = WaitForSingleObject(thread, 10000);
12059 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
12060
12061 Sleep(100);
12062 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12063 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12064
12065 bytes = 0xdeadbeef;
12066 key = 0xdeadbeef;
12067 ovl_iocp = (void *)0xdeadbeef;
12068 SetLastError(0xdeadbeef);
12069 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
12070 ok(!ret, "got %d\n", ret);
12071 ok(GetLastError() == WAIT_TIMEOUT || broken(GetLastError() == ERROR_OPERATION_ABORTED) /* XP */, "got %lu\n", GetLastError());
12072 if (GetLastError() == WAIT_TIMEOUT)
12073 {
12074 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
12075 ok(key == 0xdeadbeef, "got key %Iu\n", key);
12076 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
12077 }
12078 else /* document XP behaviour */
12079 {
12080 ok(bytes == 0, "got bytes %lu\n", bytes);
12081 ok(key == 0x12345678, "got key %#Ix\n", key);
12082 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
12083 if (ovl_iocp)
12084 {
12085 ok(!ovl_iocp->InternalHigh, "got %#Ix\n", ovl_iocp->InternalHigh);
12086 ok(ovl_iocp->Internal == STATUS_CANCELLED, "got %#Ix\n", ovl_iocp->Internal);
12087 }
12088 }
12089
12090 Sleep(100);
12091 memset(&msg, 0, sizeof(msg));
12092 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12093 ok(!ret || broken(msg.hwnd == hwnd) /* XP */, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12094 if (ret) /* document XP behaviour */
12095 {
12096 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
12097 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
12098 ok(msg.lParam == 1, "got %08Ix\n", msg.lParam);
12099 }
12100
12101 ret = send(dst, "Hello World!", 12, 0);
12102 ok(ret == 12, "send returned %d\n", ret);
12103
12104 Sleep(100);
12105 memset(&msg, 0, sizeof(msg));
12106 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12107 ok(!ret || broken(msg.hwnd == hwnd) /* XP */, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12108 if (ret) /* document XP behaviour */
12109 {
12110 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
12111 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
12112 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
12113 ok(msg.lParam == 1, "got %08Ix\n", msg.lParam);
12114 }
12115
12116 bytes = 0xdeadbeef;
12117 key = 0xdeadbeef;
12118 ovl_iocp = (void *)0xdeadbeef;
12119 SetLastError(0xdeadbeef);
12120 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
12121 ok(ret || broken(GetLastError() == WAIT_TIMEOUT) /* XP */, "got %lu\n", GetLastError());
12122 if (ret)
12123 {
12124 ok(bytes == 12, "got bytes %lu\n", bytes);
12125 ok(key == 0x12345678, "got key %#Ix\n", key);
12126 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
12127 if (ovl_iocp)
12128 {
12129 ok(ovl_iocp->InternalHigh == 12, "got %#Ix\n", ovl_iocp->InternalHigh);
12130 ok(!ovl_iocp->Internal , "got %#Ix\n", ovl_iocp->Internal);
12131 ok(!memcmp(data, "Hello World!", 12), "got %lu bytes (%*s)\n", bytes, (int)bytes, data);
12132 }
12133 }
12134 else /* document XP behaviour */
12135 {
12136 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
12137 ok(key == 0xdeadbeef, "got key %Iu\n", key);
12138 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
12139 }
12140
12141 CloseHandle(port);
12142
12143 DestroyWindow(hwnd);
12144 }
12145
12146 static void test_iocp(void)
12147 {
12148 SOCKET src, dst;
12149 int i;
12150
12151 tcp_socketpair(&src, &dst);
12152 sync_read(src, dst);
12153 iocp_async_read(src, dst);
12154 closesocket(src);
12155 closesocket(dst);
12156
12157 tcp_socketpair(&src, &dst);
12158 iocp_async_read_thread(src, dst);
12159 closesocket(src);
12160 closesocket(dst);
12161
12162 for (i = 0; i <= 2; i++)
12163 {
12164 tcp_socketpair(&src, &dst);
12165 iocp_async_read_closesocket(src, i);
12166 closesocket(dst);
12167 }
12168
12169 tcp_socketpair(&src, &dst);
12170 iocp_async_closesocket(src);
12171 closesocket(dst);
12172
12173 tcp_socketpair(&src, &dst);
12174 iocp_async_read_thread_closesocket(src);
12175 closesocket(dst);
12176 }
12177
12178 static void test_get_interface_list(void)
12179 {
12180 OVERLAPPED overlapped = {0}, *overlapped_ptr;
12181 DWORD size, expect_size;
12182 unsigned int i, count;
12183 INTERFACE_INFO *info;
12184 BOOL loopback_found;
12185 char buffer[4096];
12186 ULONG_PTR key;
12187 HANDLE port;
12188 SOCKET s;
12189 int ret;
12190
12191 s = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
12192 ok(s != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
12193 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
12194
12195 size = 0xdeadbeef;
12196 WSASetLastError(0xdeadbeef);
12197 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(buffer), &size, NULL, NULL);
12198 ok(!ret, "Got unexpected ret %d.\n", ret);
12199 ok(!WSAGetLastError(), "Got error %u.\n", WSAGetLastError());
12200 ok(size && size != 0xdeadbeef && !(size % sizeof(INTERFACE_INFO)), "Got unexpected size %lu.\n", size);
12201 expect_size = size;
12202
12203 size = 0xdeadbeef;
12204 overlapped.Internal = 0xdeadbeef;
12205 overlapped.InternalHigh = 0xdeadbeef;
12206 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(buffer), &size, &overlapped, NULL);
12207 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12208 ok(WSAGetLastError() == ERROR_IO_PENDING, "Got error %u.\n", WSAGetLastError());
12209 ok(size == 0xdeadbeef, "Got size %lu.\n", size);
12210
12211 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 100);
12212 ok(ret, "Got error %lu.\n", GetLastError());
12213 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
12214 ok(key == 123, "Got key %Iu.\n", key);
12215 ok(overlapped_ptr == &overlapped, "Got overlapped %p.\n", overlapped_ptr);
12216 ok(!overlapped.Internal, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
12217 ok(overlapped.InternalHigh == expect_size, "Expected size %lu, got %Iu.\n", expect_size, overlapped.InternalHigh);
12218
12219 info = (INTERFACE_INFO *)buffer;
12220 count = size / sizeof(INTERFACE_INFO);
12221 loopback_found = FALSE;
12222 for (i = 0; i < count; ++i)
12223 {
12224 if (info[i].iiFlags & IFF_LOOPBACK)
12225 loopback_found = TRUE;
12226
12227 ok(info[i].iiAddress.AddressIn.sin_family == AF_INET, "Got unexpected sin_family %#x.\n",
12228 info[i].iiAddress.AddressIn.sin_family);
12229 ok(info[i].iiNetmask.AddressIn.sin_family == AF_INET, "Got unexpected sin_family %#x.\n",
12230 info[i].iiNetmask.AddressIn.sin_family);
12231 ok(info[i].iiBroadcastAddress.AddressIn.sin_family
12232 == (info[i].iiFlags & IFF_BROADCAST) ? AF_INET : 0, "Got unexpected sin_family %#x.\n",
12233 info[i].iiBroadcastAddress.AddressIn.sin_family);
12234 ok(info[i].iiAddress.AddressIn.sin_addr.S_un.S_addr, "Got zero iiAddress.\n");
12235 ok(info[i].iiNetmask.AddressIn.sin_addr.S_un.S_addr, "Got zero iiNetmask.\n");
12236 ok((info[i].iiFlags & IFF_BROADCAST) ? info[i].iiBroadcastAddress.AddressIn.sin_addr.S_un.S_addr
12237 : !info[i].iiBroadcastAddress.AddressIn.sin_addr.S_un.S_addr,
12238 "Got unexpected iiBroadcastAddress %s.\n", inet_ntoa(info[i].iiBroadcastAddress.AddressIn.sin_addr));
12239 }
12240
12241 ok(loopback_found, "Loopback interface not found.\n");
12242
12243 size = 0xdeadbeef;
12244 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(INTERFACE_INFO) - 1, &size, NULL, NULL);
12245 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12246 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
12247 ok(!size, "Got unexpected size %lu.\n", size);
12248
12249 size = 0xdeadbeef;
12250 overlapped.Internal = 0xdeadbeef;
12251 overlapped.InternalHigh = 0xdeadbeef;
12252 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(INTERFACE_INFO) - 1, &size, &overlapped, NULL);
12253 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12254 ok(WSAGetLastError() == ERROR_IO_PENDING, "Got error %u.\n", WSAGetLastError());
12255 ok(size == 0xdeadbeef, "Got size %lu.\n", size);
12256
12257 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 100);
12258 ok(!ret, "Expected failure.\n");
12259 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Got error %lu.\n", GetLastError());
12260 ok(!size, "Got size %lu.\n", size);
12261 ok(key == 123, "Got key %Iu.\n", key);
12262 ok(overlapped_ptr == &overlapped, "Got overlapped %p.\n", overlapped_ptr);
12263 ok((NTSTATUS)overlapped.Internal == STATUS_BUFFER_TOO_SMALL, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
12264 ok(!overlapped.InternalHigh, "Got size %Iu.\n", overlapped.InternalHigh);
12265
12266 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(buffer), NULL, NULL, NULL);
12267 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12268 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
12269
12270 CloseHandle(port);
12271 closesocket(s);
12272
12273 /* Test with an APC. */
12274
12275 s = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
12276 ok(s != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
12277
12278 size = 0xdeadbeef;
12279 apc_count = 0;
12280 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer,
12281 sizeof(INTERFACE_INFO) - 1, &size, &overlapped, socket_apc);
12282 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12283 ok(WSAGetLastError() == ERROR_IO_PENDING, "Got error %u.\n", WSAGetLastError());
12284 ok(size == 0xdeadbeef, "Got size %lu.\n", size);
12285
12286 ret = SleepEx(100, TRUE);
12287 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
12288 ok(apc_count == 1, "APC was called %u times\n", apc_count);
12289 ok(apc_error == WSAEFAULT, "got APC error %lu\n", apc_error);
12290 ok(!apc_size, "got APC size %lu\n", apc_size);
12291 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
12292
12293 closesocket(s);
12294 }
12295
12296 static IP_ADAPTER_ADDRESSES *get_adapters(void)
12297 {
12298 ULONG err, size = 4096;
12299 IP_ADAPTER_ADDRESSES *tmp, *ret;
12300
12301 if (!(ret = malloc( size ))) return NULL;
12302 err = GetAdaptersAddresses( AF_UNSPEC, 0, NULL, ret, &size );
12303 while (err == ERROR_BUFFER_OVERFLOW)
12304 {
12305 if (!(tmp = realloc( ret, size ))) break;
12306 ret = tmp;
12307 err = GetAdaptersAddresses( AF_UNSPEC, 0, NULL, ret, &size );
12308 }
12309 if (err == ERROR_SUCCESS) return ret;
12310 free( ret );
12311 return NULL;
12312 }
12313
12314 static void test_bind(void)
12315 {
12316 const struct sockaddr_in invalid_addr = {.sin_family = AF_INET, .sin_addr.s_addr = inet_addr("192.0.2.0")};
12317 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
12318 IP_ADAPTER_ADDRESSES *adapters, *adapter;
12319 struct sockaddr addr;
12320 SOCKET s, s2;
12321 int ret, len;
12322
12323 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12324
12325 WSASetLastError(0xdeadbeef);
12326 ret = bind(s, NULL, 0);
12327 ok(ret == -1, "expected failure\n");
12328 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12329
12330 WSASetLastError(0xdeadbeef);
12331 ret = bind(s, NULL, sizeof(addr));
12332 ok(ret == -1, "expected failure\n");
12333 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12334
12335 addr.sa_family = AF_INET;
12336 WSASetLastError(0xdeadbeef);
12337 ret = bind(s, &addr, 0);
12338 ok(ret == -1, "expected failure\n");
12339 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12340
12341 addr.sa_family = 0xdead;
12342 WSASetLastError(0xdeadbeef);
12343 ret = bind(s, &addr, sizeof(addr));
12344 ok(ret == -1, "expected failure\n");
12345 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError());
12346
12347 WSASetLastError(0xdeadbeef);
12348 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr) - 1);
12349 ok(ret == -1, "expected failure\n");
12350 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12351
12352 WSASetLastError(0xdeadbeef);
12353 ret = bind(s, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
12354 ok(ret == -1, "expected failure\n");
12355 ok(WSAGetLastError() == WSAEADDRNOTAVAIL, "got error %u\n", WSAGetLastError());
12356
12357 WSASetLastError(0xdeadbeef);
12358 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12359 ok(!ret, "expected success\n");
12360 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
12361
12362 WSASetLastError(0xdeadbeef);
12363 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12364 ok(ret == -1, "expected failure\n");
12365 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
12366
12367 len = sizeof(addr);
12368 ret = getsockname(s, &addr, &len);
12369 ok(!ret, "got error %u\n", WSAGetLastError());
12370
12371 s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12372
12373 WSASetLastError(0xdeadbeef);
12374 ret = bind(s2, &addr, sizeof(addr));
12375 ok(ret == -1, "expected failure\n");
12376 ok(WSAGetLastError() == WSAEADDRINUSE, "got error %u\n", WSAGetLastError());
12377
12378 closesocket(s2);
12379 closesocket(s);
12380
12381 s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
12382
12383 WSASetLastError(0xdeadbeef);
12384 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12385 ok(!ret, "expected success\n");
12386 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
12387
12388 closesocket(s);
12389
12390 adapters = get_adapters();
12391 ok(adapters != NULL, "can't get adapters\n");
12392
12393 for (adapter = adapters; adapter != NULL; adapter = adapter->Next)
12394 {
12395 const IP_ADAPTER_UNICAST_ADDRESS *unicast_addr;
12396
12397 if (adapter->OperStatus != IfOperStatusUp) continue;
12398
12399 for (unicast_addr = adapter->FirstUnicastAddress; unicast_addr != NULL; unicast_addr = unicast_addr->Next)
12400 {
12401 short family = unicast_addr->Address.lpSockaddr->sa_family;
12402
12403 s = socket(family, SOCK_STREAM, IPPROTO_TCP);
12404 ok(s != -1, "failed to create socket, error %u\n", WSAGetLastError());
12405
12406 ret = bind(s, unicast_addr->Address.lpSockaddr, unicast_addr->Address.iSockaddrLength);
12407 ok(!ret, "got error %u\n", WSAGetLastError());
12408
12409 closesocket(s);
12410
12411 if (family == AF_INET6)
12412 {
12413 struct sockaddr_in6 addr6, ret_addr6;
12414
12415 memcpy(&addr6, unicast_addr->Address.lpSockaddr, sizeof(addr6));
12416
12417 ok(unicast_addr->Address.iSockaddrLength == sizeof(struct sockaddr_in6),
12418 "got unexpected length %u\n", unicast_addr->Address.iSockaddrLength);
12419
12420 s = socket(family, SOCK_STREAM, IPPROTO_TCP);
12421 ok(s != -1, "failed to create socket, error %u\n", WSAGetLastError());
12422
12423 ret = bind(s, unicast_addr->Address.lpSockaddr, sizeof(struct sockaddr_in6_old));
12424 ok(ret == -1, "expected failure\n");
12425 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12426
12427 addr6.sin6_scope_id = 0xabacab;
12428 ret = bind(s, (struct sockaddr *)&addr6, sizeof(addr6));
12429 todo_wine_if (!((const struct sockaddr_in6 *)unicast_addr->Address.lpSockaddr)->sin6_scope_id)
12430 {
12431 ok(ret == -1, "expected failure\n");
12432 ok(WSAGetLastError() == WSAEADDRNOTAVAIL, "got error %u\n", WSAGetLastError());
12433 }
12434
12435 addr6.sin6_scope_id = 0;
12436 ret = bind(s, (struct sockaddr *)&addr6, sizeof(addr6));
12437 todo_wine_if (!((const struct sockaddr_in6 *)unicast_addr->Address.lpSockaddr)->sin6_scope_id)
12438 ok(!ret, "got error %u\n", WSAGetLastError());
12439
12440 memcpy(&addr6, unicast_addr->Address.lpSockaddr, sizeof(addr6));
12441
12442 len = sizeof(struct sockaddr_in6_old);
12443 ret = getsockname(s, (struct sockaddr *)&ret_addr6, &len);
12444 ok(ret == -1, "expected failure\n");
12445 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12446
12447 len = sizeof(ret_addr6);
12448 memset(&ret_addr6, 0, sizeof(ret_addr6));
12449 ret = getsockname(s, (struct sockaddr *)&ret_addr6, &len);
12450 ok(!ret, "got error %u\n", WSAGetLastError());
12451 ok(ret_addr6.sin6_family == AF_INET6, "got family %u\n", ret_addr6.sin6_family);
12452 ok(ret_addr6.sin6_port != 0, "expected nonzero port\n");
12453 ok(!memcmp(&ret_addr6.sin6_addr, &addr6.sin6_addr, sizeof(addr6.sin6_addr)), "address didn't match\n");
12454 ok(ret_addr6.sin6_scope_id == addr6.sin6_scope_id, "got scope %lu\n", ret_addr6.sin6_scope_id);
12455
12456 closesocket(s);
12457 }
12458 }
12459 }
12460
12461 free(adapters);
12462 }
12463
12464 /* Test calling methods on a socket which is currently connecting. */
12465 static void test_connecting_socket(void)
12466 {
12467 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_ANY)};
12468 const struct sockaddr_in invalid_addr =
12469 {
12470 .sin_family = AF_INET,
12471 .sin_addr.s_addr = inet_addr("192.0.2.0"),
12472 .sin_port = 255
12473 };
12474 OVERLAPPED overlapped = {0}, overlapped2 = {0};
12475 GUID connectex_guid = WSAID_CONNECTEX;
12476 LPFN_CONNECTEX pConnectEx;
12477 struct sockaddr_in addr;
12478 char buffer[4];
12479 SOCKET client;
12480 int ret, len;
12481 DWORD size;
12482
12483 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12484 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
12485 set_blocking(client, FALSE);
12486
12487 ret = bind(client, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12488 ok(!ret, "expected success\n");
12489 ok(!WSAGetLastError(), "got %u\n", WSAGetLastError());
12490
12491 ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
12492 ok(ret == -1, "got %d\n", ret);
12493 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got %u\n", WSAGetLastError());
12494
12495 /* Mortal Kombat 11 connects to the same address twice and expects the
12496 * second to return WSAEALREADY. */
12497 ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
12498 ok(ret == -1, "got %d\n", ret);
12499 ok(WSAGetLastError() == WSAEALREADY, "got %u\n", WSAGetLastError());
12500
12501 ret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectex_guid, sizeof(connectex_guid),
12502 &pConnectEx, sizeof(pConnectEx), &size, NULL, NULL);
12503 ok(!ret, "failed to get ConnectEx, error %u\n", WSAGetLastError());
12504 overlapped.Internal = 0xdeadbeef;
12505 overlapped.InternalHigh = 0xdeadbeef;
12506 ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped);
12507 ok(!ret, "got %d\n", ret);
12508 ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError());
12509 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
12510 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
12511
12512 len = sizeof(addr);
12513 ret = getsockname(client, (struct sockaddr *)&addr, &len);
12514 ok(!ret, "got error %u\n", WSAGetLastError());
12515 ok(addr.sin_family == AF_INET, "got family %u\n", addr.sin_family);
12516 ok(addr.sin_port, "expected nonzero port\n");
12517
12518 len = sizeof(addr);
12519 ret = getpeername(client, (struct sockaddr *)&addr, &len);
12520 todo_wine ok(!ret, "got error %u\n", WSAGetLastError());
12521 if (!ret)
12522 {
12523 ok(addr.sin_family == AF_INET, "got family %u\n", addr.sin_family);
12524 ok(addr.sin_addr.s_addr == inet_addr("192.0.2.0"), "got address %#08lx\n", addr.sin_addr.s_addr);
12525 ok(addr.sin_port == 255, "expected nonzero port\n");
12526 }
12527
12528 ret = recv(client, buffer, sizeof(buffer), 0);
12529 ok(ret == -1, "got %d\n", ret);
12530 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12531
12532 ret = send(client, "data", 5, 0);
12533 ok(ret == -1, "got %d\n", ret);
12534 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12535
12536 closesocket(client);
12537
12538 /* Test with ConnectEx(). */
12539
12540 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12541 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
12542 set_blocking(client, FALSE);
12543
12544 ret = bind(client, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12545 ok(!ret, "expected success\n");
12546 ok(!WSAGetLastError(), "got %u\n", WSAGetLastError());
12547
12548 ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped2);
12549 ok(!ret, "got %d\n", ret);
12550 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
12551
12552 ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
12553 ok(ret == -1, "got %d\n", ret);
12554 ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError());
12555
12556 overlapped.Internal = 0xdeadbeef;
12557 overlapped.InternalHigh = 0xdeadbeef;
12558 ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped);
12559 ok(!ret, "got %d\n", ret);
12560 ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError());
12561 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
12562 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
12563
12564 len = sizeof(addr);
12565 ret = getsockname(client, (struct sockaddr *)&addr, &len);
12566 ok(!ret, "got error %u\n", WSAGetLastError());
12567 ok(addr.sin_family == AF_INET, "got family %u\n", addr.sin_family);
12568 ok(addr.sin_port, "expected nonzero port\n");
12569
12570 len = sizeof(addr);
12571 ret = getpeername(client, (struct sockaddr *)&addr, &len);
12572 ok(ret == -1, "got %d\n", ret);
12573 ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12574
12575 ret = recv(client, buffer, sizeof(buffer), 0);
12576 ok(ret == -1, "got %d\n", ret);
12577 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12578
12579 ret = send(client, "data", 5, 0);
12580 ok(ret == -1, "got %d\n", ret);
12581 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12582
12583 closesocket(client);
12584 }
12585
12586 static DWORD map_status( NTSTATUS status )
12587 {
12588 static const struct
12589 {
12590 NTSTATUS status;
12591 DWORD error;
12592 }
12593 errors[] =
12594 {
12595 {STATUS_PENDING, ERROR_IO_INCOMPLETE},
12596
12597 {STATUS_BUFFER_OVERFLOW, WSAEMSGSIZE},
12598
12599 {STATUS_NOT_IMPLEMENTED, WSAEOPNOTSUPP},
12600 {STATUS_ACCESS_VIOLATION, WSAEFAULT},
12601 {STATUS_PAGEFILE_QUOTA, WSAENOBUFS},
12602 {STATUS_INVALID_HANDLE, WSAENOTSOCK},
12603 {STATUS_NO_SUCH_DEVICE, WSAENETDOWN},
12604 {STATUS_NO_SUCH_FILE, WSAENETDOWN},
12605 {STATUS_NO_MEMORY, WSAENOBUFS},
12606 {STATUS_CONFLICTING_ADDRESSES, WSAENOBUFS},
12607 {STATUS_ACCESS_DENIED, WSAEACCES},
12608 {STATUS_BUFFER_TOO_SMALL, WSAEFAULT},
12609 {STATUS_OBJECT_TYPE_MISMATCH, WSAENOTSOCK},
12610 {STATUS_OBJECT_NAME_NOT_FOUND, WSAENETDOWN},
12611 {STATUS_OBJECT_PATH_NOT_FOUND, WSAENETDOWN},
12612 {STATUS_SHARING_VIOLATION, WSAEADDRINUSE},
12613 {STATUS_QUOTA_EXCEEDED, WSAENOBUFS},
12614 {STATUS_TOO_MANY_PAGING_FILES, WSAENOBUFS},
12615 {STATUS_INSUFFICIENT_RESOURCES, WSAENOBUFS},
12616 {STATUS_WORKING_SET_QUOTA, WSAENOBUFS},
12617 {STATUS_DEVICE_NOT_READY, WSAEWOULDBLOCK},
12618 {STATUS_PIPE_DISCONNECTED, WSAESHUTDOWN},
12619 {STATUS_IO_TIMEOUT, WSAETIMEDOUT},
12620 {STATUS_NOT_SUPPORTED, WSAEOPNOTSUPP},
12621 {STATUS_REMOTE_NOT_LISTENING, WSAECONNREFUSED},
12622 {STATUS_BAD_NETWORK_PATH, WSAENETUNREACH},
12623 {STATUS_NETWORK_BUSY, WSAENETDOWN},
12624 {STATUS_INVALID_NETWORK_RESPONSE, WSAENETDOWN},
12625 {STATUS_UNEXPECTED_NETWORK_ERROR, WSAENETDOWN},
12626 {STATUS_REQUEST_NOT_ACCEPTED, WSAEWOULDBLOCK},
12627 {STATUS_CANCELLED, ERROR_OPERATION_ABORTED},
12628 {STATUS_COMMITMENT_LIMIT, WSAENOBUFS},
12629 {STATUS_LOCAL_DISCONNECT, WSAECONNABORTED},
12630 {STATUS_REMOTE_DISCONNECT, WSAECONNRESET},
12631 {STATUS_REMOTE_RESOURCES, WSAENOBUFS},
12632 {STATUS_LINK_FAILED, WSAECONNRESET},
12633 {STATUS_LINK_TIMEOUT, WSAETIMEDOUT},
12634 {STATUS_INVALID_CONNECTION, WSAENOTCONN},
12635 {STATUS_INVALID_ADDRESS, WSAEADDRNOTAVAIL},
12636 {STATUS_INVALID_BUFFER_SIZE, WSAEMSGSIZE},
12637 {STATUS_INVALID_ADDRESS_COMPONENT, WSAEADDRNOTAVAIL},
12638 {STATUS_TOO_MANY_ADDRESSES, WSAENOBUFS},
12639 {STATUS_ADDRESS_ALREADY_EXISTS, WSAEADDRINUSE},
12640 {STATUS_CONNECTION_DISCONNECTED, WSAECONNRESET},
12641 {STATUS_CONNECTION_RESET, WSAECONNRESET},
12642 {STATUS_TRANSACTION_ABORTED, WSAECONNABORTED},
12643 {STATUS_CONNECTION_REFUSED, WSAECONNREFUSED},
12644 {STATUS_GRACEFUL_DISCONNECT, WSAEDISCON},
12645 {STATUS_CONNECTION_ACTIVE, WSAEISCONN},
12646 {STATUS_NETWORK_UNREACHABLE, WSAENETUNREACH},
12647 {STATUS_HOST_UNREACHABLE, WSAEHOSTUNREACH},
12648 {STATUS_PROTOCOL_UNREACHABLE, WSAENETUNREACH},
12649 {STATUS_PORT_UNREACHABLE, WSAECONNRESET},
12650 {STATUS_REQUEST_ABORTED, WSAEINTR},
12651 {STATUS_CONNECTION_ABORTED, WSAECONNABORTED},
12652 {STATUS_DATATYPE_MISALIGNMENT_ERROR,WSAEFAULT},
12653 {STATUS_HOST_DOWN, WSAEHOSTDOWN},
12654 {0x80070000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
12655 {0xc0010000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
12656 {0xc0070000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
12657 };
12658
12659 unsigned int i;
12660
12661 for (i = 0; i < ARRAY_SIZE(errors); ++i)
12662 {
12663 if (errors[i].status == status)
12664 return errors[i].error;
12665 }
12666
12667 return NT_SUCCESS(status) ? RtlNtStatusToDosErrorNoTeb(status) : WSAEINVAL;
12668 }
12669
12670 static void test_WSAGetOverlappedResult(void)
12671 {
12672 OVERLAPPED overlapped = {0};
12673 DWORD size, flags;
12674 NTSTATUS status;
12675 unsigned int i;
12676 SOCKET s;
12677 HANDLE h;
12678 BOOL ret;
12679
12680 static const NTSTATUS ranges[][2] =
12681 {
12682 {0x0, 0x10000},
12683 {0x40000000, 0x40001000},
12684 {0x80000000, 0x80001000},
12685 {0x80070000, 0x80080000},
12686 {0xc0000000, 0xc0001000},
12687 {0xc0070000, 0xc0080000},
12688 {0xd0000000, 0xd0001000},
12689 {0xd0070000, 0xd0080000},
12690 };
12691
12692 WSASetLastError(0xdeadbeef);
12693 ret = WSAGetOverlappedResult(0xdeadbeef, &overlapped, &size, FALSE, &flags);
12694 ok(!ret, "got %d.\n", ret);
12695 ok(WSAGetLastError() == WSAENOTSOCK, "got %u.\n", WSAGetLastError());
12696
12697 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12698
12699 ret = DuplicateHandle(GetCurrentProcess(), (HANDLE)s, GetCurrentProcess(), &h, 0, FALSE, DUPLICATE_SAME_ACCESS);
12700 ok(ret, "got %d.\n", ret);
12701 ret = WSAGetOverlappedResult((SOCKET)h, &overlapped, &size, FALSE, &flags);
12702 ok(!ret, "got %d.\n", ret);
12703 ok(WSAGetLastError() == WSAENOTSOCK, "got %u.\n", WSAGetLastError());
12704 CloseHandle(h);
12705
12706 for (i = 0; i < ARRAY_SIZE(ranges); ++i)
12707 {
12708 for (status = ranges[i][0]; status < ranges[i][1]; ++status)
12709 {
12710 BOOL expect_ret = NT_SUCCESS(status) && status != STATUS_PENDING;
12711 DWORD expect = map_status(status);
12712
12713 overlapped.Internal = status;
12714 WSASetLastError(0xdeadbeef);
12715 ret = WSAGetOverlappedResult(s, &overlapped, &size, FALSE, &flags);
12716 ok(ret == expect_ret, "status %#lx: expected %d, got %d\n", status, expect_ret, ret);
12717 if (ret)
12718 {
12719 ok(WSAGetLastError() == expect /* >= win10 1809 */
12720 || !WSAGetLastError() /* < win10 1809 */
12721 || WSAGetLastError() == 0xdeadbeef, /* < win7 */
12722 "status %#lx: expected error %lu, got %u\n", status, expect, WSAGetLastError());
12723 }
12724 else
12725 {
12726 ok(WSAGetLastError() == expect
12727 || (status == (0xc0070000 | ERROR_IO_INCOMPLETE) && WSAGetLastError() == WSAEINVAL), /* < win8 */
12728 "status %#lx: expected error %lu, got %u\n", status, expect, WSAGetLastError());
12729 }
12730 }
12731 }
12732
12733 overlapped.Internal = STATUS_PENDING;
12734 overlapped.hEvent = CreateEventW(NULL, TRUE, TRUE, NULL);
12735
12736 apc_count = 0;
12737 ret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
12738 ok(ret, "QueueUserAPC returned %d\n", ret);
12739 ret = WSAGetOverlappedResult(s, &overlapped, &size, TRUE, &flags);
12740 ok(ret && (GetLastError() == ERROR_IO_PENDING || !WSAGetLastError()),
12741 "Got ret %d, err %lu.\n", ret, GetLastError());
12742 ok(!apc_count, "got apc_count %d.\n", apc_count);
12743 SleepEx(0, TRUE);
12744 ok(apc_count == 1, "got apc_count %d.\n", apc_count);
12745
12746 CloseHandle(overlapped.hEvent);
12747 closesocket(s);
12748 }
12749
12750 struct nonblocking_async_recv_params
12751 {
12752 SOCKET client;
12753 HANDLE event;
12754 };
12755
12756 static DWORD CALLBACK nonblocking_async_recv_thread(void *arg)
12757 {
12758 const struct nonblocking_async_recv_params *params = arg;
12759 OVERLAPPED overlapped = {0};
12760 DWORD flags = 0, size;
12761 char buffer[5];
12762 WSABUF wsabuf;
12763 int ret;
12764
12765 overlapped.hEvent = params->event;
12766 wsabuf.buf = buffer;
12767 wsabuf.len = sizeof(buffer);
12768 memset(buffer, 0, sizeof(buffer));
12769 ret = WSARecv(params->client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
12770 ok(!ret, "got %d\n", ret);
12771 ret = GetOverlappedResult((HANDLE)params->client, &overlapped, &size, FALSE);
12772 ok(ret, "got error %lu\n", GetLastError());
12773 ok(size == 4, "got size %lu\n", size);
12774 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
12775
12776 return 0;
12777 }
12778
12779 static void test_nonblocking_async_recv(void)
12780 {
12781 struct nonblocking_async_recv_params params;
12782 OVERLAPPED overlapped = {0};
12783 SOCKET client, server;
12784 DWORD flags = 0, size;
12785 HANDLE thread, event;
12786 char buffer[5];
12787 WSABUF wsabuf;
12788 int ret;
12789
12790 event = CreateEventW(NULL, TRUE, FALSE, NULL);
12791 wsabuf.buf = buffer;
12792 wsabuf.len = sizeof(buffer);
12793
12794 tcp_socketpair(&client, &server);
12795 set_blocking(client, FALSE);
12796 set_blocking(server, FALSE);
12797
12798 WSASetLastError(0xdeadbeef);
12799 ret = recv(client, buffer, sizeof(buffer), 0);
12800 ok(ret == -1, "got %d\n", ret);
12801 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
12802
12803 WSASetLastError(0xdeadbeef);
12804 overlapped.Internal = 0xdeadbeef;
12805 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
12806 ok(ret == -1, "got %d\n", ret);
12807 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
12808 ok(overlapped.Internal == 0xdeadbeef, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
12809
12810 /* Overlapped, with a NULL event. */
12811
12812 overlapped.hEvent = NULL;
12813
12814 memset(buffer, 0, sizeof(buffer));
12815 WSASetLastError(0xdeadbeef);
12816 overlapped.Internal = 0xdeadbeef;
12817 overlapped.InternalHigh = 0xdeadbeef;
12818 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
12819 ok(ret == -1, "got %d\n", ret);
12820 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
12821 ret = WaitForSingleObject((HANDLE)client, 0);
12822 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
12823 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
12824 ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
12825
12826 ret = send(server, "data", 4, 0);
12827 ok(ret == 4, "got %d\n", ret);
12828
12829 ret = WaitForSingleObject((HANDLE)client, 1000);
12830 ok(!ret, "wait timed out\n");
12831 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
12832 ok(ret, "got error %lu\n", GetLastError());
12833 ok(size == 4, "got size %lu\n", size);
12834 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
12835
12836 /* Overlapped, with a non-NULL event. */
12837
12838 overlapped.hEvent = event;
12839
12840 memset(buffer, 0, sizeof(buffer));
12841 WSASetLastError(0xdeadbeef);
12842 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
12843 ok(ret == -1, "got %d\n", ret);
12844 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
12845 ret = WaitForSingleObject(event, 0);
12846 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
12847
12848 ret = send(server, "data", 4, 0);
12849 ok(ret == 4, "got %d\n", ret);
12850
12851 ret = WaitForSingleObject(event, 1000);
12852 ok(!ret, "wait timed out\n");
12853 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
12854 ok(ret, "got error %lu\n", GetLastError());
12855 ok(size == 4, "got size %lu\n", size);
12856 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
12857
12858 /* With data already in the pipe; usually this does return 0 (but not
12859 * reliably). */
12860
12861 ret = send(server, "data", 4, 0);
12862 ok(ret == 4, "got %d\n", ret);
12863
12864 memset(buffer, 0, sizeof(buffer));
12865 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
12866 ok(!ret || WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
12867 ret = WaitForSingleObject(event, 1000);
12868 ok(!ret, "wait timed out\n");
12869 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
12870 ok(ret, "got error %lu\n", GetLastError());
12871 ok(size == 4, "got size %lu\n", size);
12872 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
12873
12874 closesocket(client);
12875 closesocket(server);
12876
12877 /* With a non-overlapped socket, WSARecv() always blocks when passed an
12878 * overlapped structure, but returns WSAEWOULDBLOCK otherwise. */
12879
12880 tcp_socketpair_flags(&client, &server, 0);
12881 set_blocking(client, FALSE);
12882 set_blocking(server, FALSE);
12883
12884 WSASetLastError(0xdeadbeef);
12885 ret = recv(client, buffer, sizeof(buffer), 0);
12886 ok(ret == -1, "got %d\n", ret);
12887 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
12888
12889 WSASetLastError(0xdeadbeef);
12890 overlapped.Internal = 0xdeadbeef;
12891 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
12892 ok(ret == -1, "got %d\n", ret);
12893 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
12894 ok(overlapped.Internal == 0xdeadbeef, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
12895
12896 /* Overlapped, with a NULL event. */
12897
12898 params.client = client;
12899 params.event = NULL;
12900 thread = CreateThread(NULL, 0, nonblocking_async_recv_thread, &params, 0, NULL);
12901
12902 ret = WaitForSingleObject(thread, 200);
12903 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
12904
12905 ret = send(server, "data", 4, 0);
12906 ok(ret == 4, "got %d\n", ret);
12907
12908 ret = WaitForSingleObject(thread, 200);
12909 ok(!ret, "wait timed out\n");
12910 CloseHandle(thread);
12911
12912 /* Overlapped, with a non-NULL event. */
12913
12914 params.client = client;
12915 params.event = event;
12916 thread = CreateThread(NULL, 0, nonblocking_async_recv_thread, &params, 0, NULL);
12917
12918 ret = WaitForSingleObject(thread, 200);
12919 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
12920
12921 ret = send(server, "data", 4, 0);
12922 ok(ret == 4, "got %d\n", ret);
12923
12924 ret = WaitForSingleObject(thread, 200);
12925 ok(!ret, "wait timed out\n");
12926 CloseHandle(thread);
12927
12928 /* With data already in the pipe. */
12929
12930 ret = send(server, "data", 4, 0);
12931 ok(ret == 4, "got %d\n", ret);
12932
12933 memset(buffer, 0, sizeof(buffer));
12934 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
12935 ok(!ret, "got %d\n", ret);
12936 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
12937 ok(ret, "got error %lu\n", GetLastError());
12938 ok(size == 4, "got size %lu\n", size);
12939 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
12940
12941 closesocket(client);
12942 closesocket(server);
12943
12944 CloseHandle(overlapped.hEvent);
12945 }
12946
12947 static void test_simultaneous_async_recv(void)
12948 {
12949 SOCKET client, server;
12950 OVERLAPPED overlappeds[2] = {{0}};
12951 HANDLE events[2];
12952 WSABUF wsabufs[2];
12953 DWORD flags[2] = {0};
12954 size_t num_io = 2, stride = 16, i;
12955 char resbuf[32] = "";
12956 static const char msgstr[32] = "-- Lorem ipsum dolor sit amet -";
12957 int ret;
12958
12959 for (i = 0; i < num_io; i++) events[i] = CreateEventW(NULL, TRUE, FALSE, NULL);
12960
12961 tcp_socketpair(&client, &server);
12962
12963 for (i = 0; i < num_io; i++)
12964 {
12965 wsabufs[i].buf = resbuf + i * stride;
12966 wsabufs[i].len = stride;
12967 overlappeds[i].hEvent = events[i];
12968 ret = WSARecv(client, &wsabufs[i], 1, NULL, &flags[i], &overlappeds[i], NULL);
12969 ok(ret == -1, "got %d\n", ret);
12970 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
12971 }
12972
12973 ret = send(server, msgstr, sizeof(msgstr), 0);
12974 ok(ret == sizeof(msgstr), "got %d\n", ret);
12975
12976 for (i = 0; i < num_io; i++)
12977 {
12978 const void *expect = msgstr + i * stride;
12979 const void *actual = resbuf + i * stride;
12980 DWORD size;
12981
12982 ret = WaitForSingleObject(events[i], 1000);
12983 ok(!ret, "wait timed out\n");
12984
12985 size = 0;
12986 ret = GetOverlappedResult((HANDLE)client, &overlappeds[i], &size, FALSE);
12987 ok(ret, "got error %lu\n", GetLastError());
12988 ok(size == stride, "got size %lu\n", size);
12989 ok(!memcmp(expect, actual, stride), "expected %s, got %s\n", debugstr_an(expect, stride), debugstr_an(actual, stride));
12990 }
12991
12992 closesocket(client);
12993 closesocket(server);
12994
12995 for (i = 0; i < num_io; i++) CloseHandle(events[i]);
12996 }
12997
12998 static void test_empty_recv(void)
12999 {
13000 OVERLAPPED overlapped = {0};
13001 SOCKET client, server;
13002 DWORD size, flags = 0;
13003 char buffer[5];
13004 WSABUF wsabuf;
13005 int ret;
13006
13007 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
13008 tcp_socketpair(&client, &server);
13009
13010 WSASetLastError(0xdeadbeef);
13011 ret = WSARecv(client, NULL, 0, NULL, &flags, &overlapped, NULL);
13012 ok(ret == -1, "expected failure\n");
13013 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
13014
13015 wsabuf.buf = buffer;
13016 wsabuf.len = 0;
13017 WSASetLastError(0xdeadbeef);
13018 ret = WSARecv(client, &wsabuf, 0, NULL, &flags, &overlapped, NULL);
13019 ok(ret == -1, "expected failure\n");
13020 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
13021
13022 WSASetLastError(0xdeadbeef);
13023 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
13024 ok(ret == -1, "expected failure\n");
13025 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
13026
13027 ret = send(server, "data", 5, 0);
13028 ok(ret == 5, "got %d\n", ret);
13029
13030 ret = WaitForSingleObject(overlapped.hEvent, 1000);
13031 ok(!ret, "wait failed\n");
13032 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
13033 ok(ret, "got error %lu\n", GetLastError());
13034 ok(!size, "got size %lu\n", size);
13035
13036 WSASetLastError(0xdeadbeef);
13037 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
13038 ok(!ret, "got error %u\n", WSAGetLastError());
13039 ok(!size, "got size %lu\n", size);
13040
13041 ret = recv(client, NULL, 0, 0);
13042 ok(!ret, "got %d\n", ret);
13043
13044 ret = recv(client, buffer, sizeof(buffer), 0);
13045 ok(ret == 5, "got %d\n", ret);
13046 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, ret));
13047
13048 closesocket(client);
13049 closesocket(server);
13050 CloseHandle(overlapped.hEvent);
13051 }
13052
13053 static void test_timeout(void)
13054 {
13055 DWORD timeout, flags = 0, size;
13056 OVERLAPPED overlapped = {0};
13057 SOCKET client, server;
13058 WSABUF wsabuf;
13059 int ret, len;
13060 char buffer;
13061
13062 tcp_socketpair(&client, &server);
13063 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
13064
13065 timeout = 0xdeadbeef;
13066 len = sizeof(timeout);
13067 WSASetLastError(0xdeadbeef);
13068 ret = getsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, &len);
13069 ok(!ret, "expected success\n");
13070 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13071 ok(len == sizeof(timeout), "got size %u\n", len);
13072 ok(!timeout, "got timeout %lu\n", timeout);
13073
13074 timeout = 100;
13075 WSASetLastError(0xdeadbeef);
13076 ret = setsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
13077 ok(!ret, "expected success\n");
13078 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13079
13080 timeout = 0xdeadbeef;
13081 len = sizeof(timeout);
13082 WSASetLastError(0xdeadbeef);
13083 ret = getsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, &len);
13084 ok(!ret, "expected success\n");
13085 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13086 ok(timeout == 100, "got timeout %lu\n", timeout);
13087
13088 WSASetLastError(0xdeadbeef);
13089 ret = recv(client, &buffer, 1, 0);
13090 ok(ret == -1, "got %d\n", ret);
13091 ok(WSAGetLastError() == WSAETIMEDOUT, "got error %u\n", WSAGetLastError());
13092
13093 wsabuf.buf = &buffer;
13094 wsabuf.len = 1;
13095 WSASetLastError(0xdeadbeef);
13096 size = 0xdeadbeef;
13097 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
13098 ok(ret == -1, "got %d\n", ret);
13099 ok(WSAGetLastError() == WSAETIMEDOUT, "got error %u\n", WSAGetLastError());
13100 ok(size == 0xdeadbeef, "got size %lu\n", size);
13101
13102 wsabuf.buf = &buffer;
13103 wsabuf.len = 1;
13104 WSASetLastError(0xdeadbeef);
13105 size = 0xdeadbeef;
13106 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
13107 ok(ret == -1, "got %d\n", ret);
13108 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
13109
13110 ret = WaitForSingleObject(overlapped.hEvent, 200);
13111 ok(ret == WAIT_TIMEOUT, "got %d\n", ret);
13112
13113 ret = send(server, "a", 1, 0);
13114 ok(ret == 1, "got %d\n", ret);
13115
13116 ret = WaitForSingleObject(overlapped.hEvent, 200);
13117 ok(!ret, "got %d\n", ret);
13118 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
13119 ok(ret, "got error %lu\n", GetLastError());
13120 ok(size == 1, "got size %lu\n", size);
13121
13122 closesocket(client);
13123 closesocket(server);
13124 CloseHandle(overlapped.hEvent);
13125 }
13126
13127 static void test_so_debug(void)
13128 {
13129 int ret, len;
13130 DWORD debug;
13131 SOCKET s;
13132
13133 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
13134
13135 len = sizeof(debug);
13136 WSASetLastError(0xdeadbeef);
13137 debug = 0xdeadbeef;
13138 ret = getsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&debug, &len);
13139 ok(!ret, "got %d\n", ret);
13140 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13141 ok(len == sizeof(debug), "got len %u\n", len);
13142 ok(!debug, "got debug %lu\n", debug);
13143
13144 WSASetLastError(0xdeadbeef);
13145 debug = 2;
13146 ret = setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&debug, sizeof(debug));
13147 ok(!ret, "got %d\n", ret);
13148 todo_wine ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13149
13150 len = sizeof(debug);
13151 WSASetLastError(0xdeadbeef);
13152 debug = 0xdeadbeef;
13153 ret = getsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&debug, &len);
13154 ok(!ret, "got %d\n", ret);
13155 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13156 ok(len == sizeof(debug), "got len %u\n", len);
13157 todo_wine ok(debug == 1, "got debug %lu\n", debug);
13158
13159 closesocket(s);
13160 }
13161
13162 struct sockopt_validity_test
13163 {
13164 int opt;
13165 int get_error;
13166 int set_error;
13167 BOOL todo;
13168 };
13169
13170 static void do_sockopt_validity_tests(const char *type, SOCKET sock, int level,
13171 const struct sockopt_validity_test *tests)
13172 {
13173 char value[256];
13174 int count, rc, expected_rc, i;
13175
13176 for (i = 0; tests[i].opt; i++)
13177 {
13178 winetest_push_context("%s option %i", type, tests[i].opt);
13179 memset(value, 0, sizeof(value));
13180 count = sizeof(value);
13181
13182 WSASetLastError(0);
13183 rc = getsockopt(sock, level, tests[i].opt, value, &count);
13184 expected_rc = tests[i].get_error ? SOCKET_ERROR : 0;
13185 todo_wine_if(!tests[i].get_error && tests[i].todo)
13186 ok(rc == expected_rc || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
13187 "expected getsockopt to return %i, got %i\n", expected_rc, rc);
13188 todo_wine_if(tests[i].todo)
13189 ok(WSAGetLastError() == tests[i].get_error || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
13190 "expected getsockopt to set error %i, got %i\n", tests[i].get_error, WSAGetLastError());
13191
13192 if (tests[i].get_error)
13193 {
13194 winetest_pop_context();
13195 continue;
13196 }
13197
13198 WSASetLastError(0);
13199 rc = setsockopt(sock, level, tests[i].opt, value, count);
13200 expected_rc = tests[i].set_error ? SOCKET_ERROR : 0;
13201 todo_wine_if(!tests[i].set_error && tests[i].todo)
13202 ok(rc == expected_rc || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
13203 "expected setsockopt to return %i, got %i\n", expected_rc, rc);
13204 todo_wine_if(tests[i].todo)
13205 ok(WSAGetLastError() == tests[i].set_error || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
13206 "expected setsockopt to set error %i, got %i\n", tests[i].set_error, WSAGetLastError());
13207
13208 winetest_pop_context();
13209 }
13210 }
13211
13212 static void test_sockopt_validity(void)
13213 {
13214 static const struct sockopt_validity_test ipv4_tcp_tests[] =
13215 {
13216 { -1, WSAENOPROTOOPT },
13217 { IP_OPTIONS },
13218 { IP_HDRINCL, WSAEINVAL },
13219 { IP_TOS },
13220 { IP_TTL },
13221 { IP_MULTICAST_IF, WSAEINVAL },
13222 { IP_MULTICAST_TTL, WSAEINVAL },
13223 { IP_MULTICAST_LOOP, WSAEINVAL },
13224 { IP_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13225 { IP_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13226 { IP_DONTFRAGMENT },
13227 { IP_PKTINFO, WSAEINVAL },
13228 { IP_RECVTTL, WSAEINVAL },
13229 { IP_RECEIVE_BROADCAST, WSAEINVAL, 0, TRUE },
13230 { IP_RECVIF, WSAEINVAL, 0, TRUE },
13231 { IP_RECVDSTADDR, WSAEINVAL, 0, TRUE },
13232 { IP_IFLIST, 0, 0, TRUE },
13233 { IP_UNICAST_IF },
13234 { IP_RTHDR, 0, 0, TRUE },
13235 { IP_GET_IFLIST, WSAEINVAL, 0, TRUE },
13236 { IP_RECVRTHDR, WSAEINVAL, 0, TRUE },
13237 { IP_RECVTOS, WSAEINVAL },
13238 { IP_ORIGINAL_ARRIVAL_IF, WSAEINVAL, 0, TRUE },
13239 { IP_ECN, WSAEINVAL, 0, TRUE },
13240 { IP_PKTINFO_EX, WSAEINVAL, 0, TRUE },
13241 { IP_WFP_REDIRECT_RECORDS, WSAEINVAL, 0, TRUE },
13242 { IP_WFP_REDIRECT_CONTEXT, WSAEINVAL, 0, TRUE },
13243 { IP_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13244 { IP_MTU, WSAENOTCONN, 0, TRUE },
13245 { IP_RECVERR, WSAEINVAL, 0, TRUE },
13246 { IP_USER_MTU, 0, 0, TRUE },
13247 {}
13248 };
13249 static const struct sockopt_validity_test ipv4_udp_tests[] =
13250 {
13251 { -1, WSAENOPROTOOPT },
13252 { IP_OPTIONS },
13253 { IP_HDRINCL, WSAEINVAL },
13254 { IP_TOS },
13255 { IP_TTL },
13256 { IP_MULTICAST_IF },
13257 { IP_MULTICAST_TTL },
13258 { IP_MULTICAST_LOOP },
13259 { IP_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13260 { IP_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13261 { IP_DONTFRAGMENT },
13262 { IP_PKTINFO },
13263 { IP_RECVTTL },
13264 { IP_RECEIVE_BROADCAST, 0, 0, TRUE },
13265 { IP_RECVIF, 0, 0, TRUE },
13266 { IP_RECVDSTADDR, 0, 0, TRUE },
13267 { IP_IFLIST, 0, 0, TRUE },
13268 { IP_UNICAST_IF },
13269 { IP_RTHDR, 0, 0, TRUE },
13270 { IP_GET_IFLIST, WSAEINVAL, 0, TRUE },
13271 { IP_RECVRTHDR, 0, 0, TRUE },
13272 { IP_RECVTOS },
13273 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
13274 { IP_ECN, 0, 0, TRUE },
13275 { IP_PKTINFO_EX, 0, 0, TRUE },
13276 { IP_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
13277 { IP_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
13278 { IP_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13279 { IP_MTU, WSAENOTCONN, 0, TRUE },
13280 { IP_RECVERR, 0, 0, TRUE },
13281 { IP_USER_MTU, 0, 0, TRUE },
13282 {}
13283 };
13284 static const struct sockopt_validity_test ipv4_raw_tests[] =
13285 {
13286 { -1, WSAENOPROTOOPT },
13287 { IP_OPTIONS },
13288 { IP_HDRINCL, },
13289 { IP_TOS },
13290 { IP_TTL },
13291 { IP_MULTICAST_IF },
13292 { IP_MULTICAST_TTL },
13293 { IP_MULTICAST_LOOP },
13294 { IP_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13295 { IP_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13296 { IP_DONTFRAGMENT },
13297 { IP_PKTINFO },
13298 { IP_RECVTTL },
13299 { IP_RECEIVE_BROADCAST, 0, 0, TRUE },
13300 { IP_RECVIF, 0, 0, TRUE },
13301 { IP_RECVDSTADDR, 0, 0, TRUE },
13302 { IP_IFLIST, 0, 0, TRUE },
13303 { IP_UNICAST_IF },
13304 { IP_RTHDR, 0, 0, TRUE },
13305 { IP_GET_IFLIST, WSAEINVAL, 0, TRUE },
13306 { IP_RECVRTHDR, 0, 0, TRUE },
13307 { IP_RECVTOS },
13308 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
13309 { IP_ECN, 0, 0, TRUE },
13310 { IP_PKTINFO_EX, 0, 0, TRUE },
13311 { IP_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
13312 { IP_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
13313 { IP_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13314 { IP_MTU, WSAENOTCONN, 0, TRUE },
13315 { IP_RECVERR, WSAEINVAL, 0, TRUE },
13316 { IP_USER_MTU, 0, 0, TRUE },
13317 {}
13318 };
13319 static const struct sockopt_validity_test ipv6_tcp_tests[] =
13320 {
13321 { -1, WSAENOPROTOOPT },
13322 { IPV6_HOPOPTS, 0, 0, TRUE },
13323 { IPV6_HDRINCL, WSAEINVAL, 0, TRUE },
13324 { IPV6_UNICAST_HOPS },
13325 { IPV6_MULTICAST_IF, WSAEINVAL },
13326 { IPV6_MULTICAST_HOPS, WSAEINVAL },
13327 { IPV6_MULTICAST_LOOP, WSAEINVAL },
13328 { IPV6_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13329 { IPV6_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13330 { IPV6_DONTFRAG },
13331 { IPV6_PKTINFO, WSAEINVAL },
13332 { IPV6_HOPLIMIT, WSAEINVAL },
13333 { IPV6_PROTECTION_LEVEL },
13334 { IPV6_RECVIF, WSAEINVAL, 0, TRUE },
13335 { IPV6_RECVDSTADDR, WSAEINVAL, 0, TRUE },
13336 { IPV6_V6ONLY },
13337 { IPV6_IFLIST, 0, 0, TRUE },
13338 { IPV6_UNICAST_IF },
13339 { IPV6_RTHDR, 0, 0, TRUE },
13340 { IPV6_GET_IFLIST, WSAEINVAL, 0, TRUE },
13341 { IPV6_RECVRTHDR, WSAEINVAL, 0, TRUE },
13342 { IPV6_RECVTCLASS, WSAEINVAL },
13343 { IP_ORIGINAL_ARRIVAL_IF, WSAEINVAL, 0, TRUE },
13344 { IPV6_ECN, WSAEINVAL, 0, TRUE },
13345 { IPV6_PKTINFO_EX, WSAEINVAL, 0, TRUE },
13346 { IPV6_WFP_REDIRECT_RECORDS, WSAEINVAL, 0, TRUE },
13347 { IPV6_WFP_REDIRECT_CONTEXT, WSAEINVAL, 0, TRUE },
13348 { IPV6_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13349 { IPV6_MTU, WSAENOTCONN, 0, TRUE },
13350 { IPV6_RECVERR, WSAEINVAL, 0, TRUE },
13351 { IPV6_USER_MTU, 0, 0, TRUE },
13352 {}
13353 };
13354 static const struct sockopt_validity_test ipv6_udp_tests[] =
13355 {
13356 { -1, WSAENOPROTOOPT },
13357 { IPV6_HOPOPTS, 0, 0, TRUE },
13358 { IPV6_HDRINCL, WSAEINVAL, 0, TRUE },
13359 { IPV6_UNICAST_HOPS },
13360 { IPV6_MULTICAST_IF },
13361 { IPV6_MULTICAST_HOPS },
13362 { IPV6_MULTICAST_LOOP },
13363 { IPV6_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13364 { IPV6_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13365 { IPV6_DONTFRAG },
13366 { IPV6_PKTINFO },
13367 { IPV6_HOPLIMIT },
13368 { IPV6_PROTECTION_LEVEL },
13369 { IPV6_RECVIF, 0, 0, TRUE },
13370 { IPV6_RECVDSTADDR, 0, 0, TRUE },
13371 { IPV6_V6ONLY },
13372 { IPV6_IFLIST, 0, 0, TRUE },
13373 { IPV6_UNICAST_IF },
13374 { IPV6_RTHDR, 0, 0, TRUE },
13375 { IPV6_GET_IFLIST, WSAEINVAL, 0, TRUE },
13376 { IPV6_RECVRTHDR, 0, 0, TRUE },
13377 { IPV6_RECVTCLASS },
13378 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
13379 { IPV6_ECN, 0, 0, TRUE },
13380 { IPV6_PKTINFO_EX, 0, 0, TRUE },
13381 { IPV6_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
13382 { IPV6_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
13383 { IPV6_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13384 { IPV6_MTU, WSAENOTCONN, 0, TRUE },
13385 { IPV6_RECVERR, 0, 0, TRUE },
13386 { IPV6_USER_MTU, 0, 0, TRUE },
13387 {}
13388 };
13389 static const struct sockopt_validity_test ipv6_raw_tests[] =
13390 {
13391 { -1, WSAENOPROTOOPT },
13392 { IPV6_HOPOPTS, 0, 0, TRUE },
13393 { IPV6_HDRINCL, 0, 0, TRUE },
13394 { IPV6_UNICAST_HOPS },
13395 { IPV6_MULTICAST_IF },
13396 { IPV6_MULTICAST_HOPS },
13397 { IPV6_MULTICAST_LOOP },
13398 { IPV6_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13399 { IPV6_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13400 { IPV6_DONTFRAG },
13401 { IPV6_PKTINFO },
13402 { IPV6_HOPLIMIT },
13403 { IPV6_PROTECTION_LEVEL },
13404 { IPV6_RECVIF, 0, 0, TRUE },
13405 { IPV6_RECVDSTADDR, 0, 0, TRUE },
13406 { IPV6_V6ONLY },
13407 { IPV6_IFLIST, 0, 0, TRUE },
13408 { IPV6_UNICAST_IF },
13409 { IPV6_RTHDR, 0, 0, TRUE },
13410 { IPV6_GET_IFLIST, WSAEINVAL, 0, TRUE },
13411 { IPV6_RECVRTHDR, 0, 0, TRUE },
13412 { IPV6_RECVTCLASS },
13413 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
13414 { IPV6_ECN, 0, 0, TRUE },
13415 { IPV6_PKTINFO_EX, 0, 0, TRUE },
13416 { IPV6_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
13417 { IPV6_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
13418 { IPV6_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13419 { IPV6_MTU, WSAENOTCONN, 0, TRUE },
13420 { IPV6_RECVERR, WSAEINVAL, 0, TRUE },
13421 { IPV6_USER_MTU, 0, 0, TRUE },
13422 {}
13423 };
13424 static const struct sockopt_validity_test file_handle_tests[] =
13425 {
13426 { -1, WSAENOTSOCK },
13427 { SO_TYPE, WSAENOTSOCK },
13428 { SO_OPENTYPE },
13429 {}
13430 };
13431 char path[MAX_PATH];
13432 HANDLE file;
13433 SOCKET sock;
13434
13435 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
13436 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13437 do_sockopt_validity_tests("IPv4 TCP", sock, IPPROTO_IP, ipv4_tcp_tests);
13438 closesocket(sock);
13439
13440 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
13441 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13442 do_sockopt_validity_tests("IPv4 UDP", sock, IPPROTO_IP, ipv4_udp_tests);
13443 closesocket(sock);
13444
13445 sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
13446 if (sock == INVALID_SOCKET && WSAGetLastError() == WSAEACCES)
13447 {
13448 skip("Raw IPv4 sockets are not available\n");
13449 }
13450 else
13451 {
13452 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13453 do_sockopt_validity_tests("IPv4 raw", sock, IPPROTO_IP, ipv4_raw_tests);
13454 closesocket(sock);
13455 }
13456
13457 sock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
13458 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13459 do_sockopt_validity_tests("IPv6 TCP", sock, IPPROTO_IPV6, ipv6_tcp_tests);
13460 closesocket(sock);
13461
13462 sock = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
13463 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13464 do_sockopt_validity_tests("IPv6 UDP", sock, IPPROTO_IPV6, ipv6_udp_tests);
13465 closesocket(sock);
13466
13467 sock = socket(AF_INET6, SOCK_RAW, IPPROTO_RAW);
13468 if (sock == INVALID_SOCKET && WSAGetLastError() == WSAEACCES)
13469 {
13470 skip("Raw IPv6 sockets are not available\n");
13471 }
13472 else
13473 {
13474 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13475 do_sockopt_validity_tests("IPv6 raw", sock, IPPROTO_IPV6, ipv6_raw_tests);
13476 closesocket(sock);
13477 }
13478
13479 GetSystemWindowsDirectoryA(path, ARRAY_SIZE(path));
13480 strcat(path, "\\system.ini");
13481 file = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0x0, NULL);
13482 do_sockopt_validity_tests("file", (SOCKET)file, SOL_SOCKET, file_handle_tests);
13483 CloseHandle(file);
13484 }
13485
13486 static void test_tcp_reset(void)
13487 {
13488 static const struct timeval select_timeout;
13489 fd_set readfds, writefds, exceptfds;
13490 OVERLAPPED overlapped = {0};
13491 SOCKET client, server;
13492 DWORD size, flags = 0;
13493 int ret, len, error;
13494 char buffer[10];
13495 WSABUF wsabuf;
13496
13497 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
13498
13499 tcp_socketpair(&client, &server);
13500
13501 wsabuf.buf = buffer;
13502 wsabuf.len = sizeof(buffer);
13503 WSASetLastError(0xdeadbeef);
13504 size = 0xdeadbeef;
13505 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
13506 ok(ret == -1, "got %d\n", ret);
13507 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
13508
13509 close_with_rst(server);
13510
13511 ret = WaitForSingleObject(overlapped.hEvent, 1000);
13512 ok(!ret, "wait failed\n");
13513 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
13514 ok(!ret, "expected failure\n");
13515 ok(GetLastError() == ERROR_NETNAME_DELETED, "got error %lu\n", GetLastError());
13516 ok(!size, "got size %lu\n", size);
13517 ok((NTSTATUS)overlapped.Internal == STATUS_CONNECTION_RESET, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
13518
13519 len = sizeof(error);
13520 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&error, &len);
13521 ok(!ret, "got error %u\n", WSAGetLastError());
13522 ok(!error, "got error %u\n", error);
13523
13524 wsabuf.buf = buffer;
13525 wsabuf.len = sizeof(buffer);
13526 WSASetLastError(0xdeadbeef);
13527 size = 0xdeadbeef;
13528 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
13529 todo_wine ok(ret == -1, "got %d\n", ret);
13530 todo_wine ok(WSAGetLastError() == WSAECONNRESET, "got error %u\n", WSAGetLastError());
13531
13532 check_poll(client, POLLERR | POLLHUP | POLLWRNORM);
13533
13534 FD_ZERO(&readfds);
13535 FD_ZERO(&writefds);
13536 FD_ZERO(&exceptfds);
13537 FD_SET(client, &readfds);
13538 FD_SET(client, &writefds);
13539 FD_SET(client, &exceptfds);
13540 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
13541 ok(ret == 2, "got %d\n", ret);
13542 ok(FD_ISSET(client, &readfds), "FD should be set\n");
13543 ok(FD_ISSET(client, &writefds), "FD should be set\n");
13544 ok(!FD_ISSET(client, &exceptfds), "FD should be set\n");
13545
13546 FD_ZERO(&exceptfds);
13547 FD_SET(client, &exceptfds);
13548 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
13549 ok(!ret, "got %d\n", ret);
13550 ok(!FD_ISSET(client, &exceptfds), "FD should be set\n");
13551
13552 closesocket(server);
13553 CloseHandle(overlapped.hEvent);
13554 }
13555
13556 struct icmp_hdr
13557 {
13558 BYTE type;
13559 BYTE code;
13560 UINT16 checksum;
13561 union
13562 {
13563 struct
13564 {
13565 UINT16 id;
13566 UINT16 sequence;
13567 } echo;
13568 } un;
13569 };
13570
13571 struct ip_hdr
13572 {
13573 BYTE v_hl; /* version << 4 | hdr_len */
13574 BYTE tos;
13575 UINT16 tot_len;
13576 UINT16 id;
13577 UINT16 frag_off;
13578 BYTE ttl;
13579 BYTE protocol;
13580 UINT16 checksum;
13581 ULONG saddr;
13582 ULONG daddr;
13583 };
13584
13585 /* rfc 1071 checksum */
13586 static unsigned short chksum(BYTE *data, unsigned int count)
13587 {
13588 unsigned int sum = 0, carry = 0;
13589 unsigned short check, s;
13590
13591 while (count > 1)
13592 {
13593 s = *(unsigned short *)data;
13594 data += 2;
13595 sum += carry;
13596 sum += s;
13597 carry = s > sum;
13598 count -= 2;
13599 }
13600 sum += carry; /* This won't produce another carry */
13601 sum = (sum & 0xffff) + (sum >> 16);
13602
13603 if (count) sum += *data; /* LE-only */
13604
13605 sum = (sum & 0xffff) + (sum >> 16);
13606 /* fold in any carry */
13607 sum = (sum & 0xffff) + (sum >> 16);
13608
13609 check = ~sum;
13610 return check;
13611 }
13612
13613 static void test_icmp(void)
13614 {
13615 static const unsigned int ping_data = 0xdeadbeef;
13616 struct icmp_hdr *icmp_h;
13617 BYTE send_buf[sizeof(struct icmp_hdr) + sizeof(ping_data)];
13618 UINT16 recv_checksum, checksum;
13619 unsigned int reply_data;
13620 struct sockaddr_in sa;
13621 struct ip_hdr *ip_h;
13622 struct in_addr addr;
13623 BYTE recv_buf[256];
13624 SOCKET s;
13625 int ret;
13626
13627 s = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
13628 if (s == INVALID_SOCKET)
13629 {
13630 ret = WSAGetLastError();
13631 ok(ret == WSAEACCES, "Expected 10013, received %d\n", ret);
13632 skip("SOCK_RAW is not supported\n");
13633 return;
13634 }
13635
13636 icmp_h = (struct icmp_hdr *)send_buf;
13637 icmp_h->type = ICMP4_ECHO_REQUEST;
13638 icmp_h->code = 0;
13639 icmp_h->checksum = 0;
13640 icmp_h->un.echo.id = 0xbeaf; /* will be overwritten for linux ping socks */
13641 icmp_h->un.echo.sequence = 1;
13642 *(unsigned int *)(icmp_h + 1) = ping_data;
13643 icmp_h->checksum = chksum(send_buf, sizeof(send_buf));
13644
13645 memset(&sa, 0, sizeof(sa));
13646 sa.sin_family = AF_INET;
13647 sa.sin_port = 0;
13648 sa.sin_addr.s_addr = inet_addr("127.0.0.1");
13649
13650 ret = sendto(s, (char *)send_buf, sizeof(send_buf), 0, (struct sockaddr*)&sa, sizeof(sa));
13651 ok(ret == sizeof(send_buf), "got %d, error %d.\n", ret, WSAGetLastError());
13652
13653 ret = recv(s, (char *)recv_buf, sizeof(struct ip_hdr) + sizeof(send_buf) - 1, 0);
13654 ok(ret == -1, "got %d\n", ret);
13655 ok(WSAGetLastError() == WSAEMSGSIZE, "got %d\n", WSAGetLastError());
13656
13657 icmp_h->un.echo.sequence = 2;
13658 icmp_h->checksum = 0;
13659 icmp_h->checksum = chksum(send_buf, sizeof(send_buf));
13660
13661 ret = sendto(s, (char *)send_buf, sizeof(send_buf), 0, (struct sockaddr*)&sa, sizeof(sa));
13662 ok(ret != SOCKET_ERROR, "got error %d.\n", WSAGetLastError());
13663
13664 memset(recv_buf, 0xcc, sizeof(recv_buf));
13665 ret = recv(s, (char *)recv_buf, sizeof(recv_buf), 0);
13666 ok(ret == sizeof(struct ip_hdr) + sizeof(send_buf), "got %d\n", ret);
13667
13668 ip_h = (struct ip_hdr *)recv_buf;
13669 icmp_h = (struct icmp_hdr *)(ip_h + 1);
13670 reply_data = *(unsigned int *)(icmp_h + 1);
13671
13672 ok(ip_h->v_hl == ((4 << 4) | (sizeof(*ip_h) >> 2)), "got v_hl %#x.\n", ip_h->v_hl);
13673 ok(ntohs(ip_h->tot_len) == sizeof(struct ip_hdr) + sizeof(send_buf),
13674 "got tot_len %#x.\n", ntohs(ip_h->tot_len));
13675
13676 recv_checksum = ip_h->checksum;
13677 ip_h->checksum = 0;
13678 checksum = chksum((BYTE *)ip_h, sizeof(*ip_h));
13679 /* Checksum is 0 for localhost ping on Windows but not for remote host ping. */
13680 ok(recv_checksum == checksum || !recv_checksum, "got checksum %#x, expected %#x.\n", recv_checksum, checksum);
13681
13682 ok(!ip_h->frag_off, "got id %#x.\n", ip_h->frag_off);
13683 addr.s_addr = ip_h->saddr;
13684 ok(ip_h->saddr == sa.sin_addr.s_addr, "got saddr %s.\n", inet_ntoa(addr));
13685 addr.s_addr = ip_h->daddr;
13686 ok(!!ip_h->daddr, "got daddr %s.\n", inet_ntoa(addr));
13687
13688 ok(ip_h->protocol == 1, "got protocol %#x.\n", ip_h->protocol);
13689
13690 ok(icmp_h->type == ICMP4_ECHO_REPLY, "got type %#x.\n", icmp_h->type);
13691 ok(!icmp_h->code, "got code %#x.\n", icmp_h->code);
13692 ok(icmp_h->un.echo.id == 0xbeaf, "got echo id %#x.\n", icmp_h->un.echo.id);
13693 ok(icmp_h->un.echo.sequence == 2, "got echo sequence %#x.\n", icmp_h->un.echo.sequence);
13694
13695 recv_checksum = icmp_h->checksum;
13696 icmp_h->checksum = 0;
13697 checksum = chksum((BYTE *)icmp_h, sizeof(send_buf));
13698 ok(recv_checksum == checksum, "got checksum %#x, expected %#x.\n", recv_checksum, checksum);
13699
13700 ok(reply_data == ping_data, "got reply_data %#x.\n", reply_data);
13701
13702 closesocket(s);
13703 }
13704
13705 static void test_connect_time(void)
13706 {
13707 struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
13708 SOCKET client, server;
13709 unsigned int time;
13710 int ret, len;
13711
13712 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
13713
13714 len = sizeof(time);
13715 SetLastError(0xdeadbeef);
13716 ret = getsockopt(client, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
13717 ok(!ret, "got %d\n", ret);
13718 ok(!GetLastError(), "got error %lu\n", GetLastError());
13719 ok(len == sizeof(time), "got len %d\n", len);
13720 ok(time == ~0u, "got time %u\n", time);
13721
13722 closesocket(client);
13723
13724 tcp_socketpair(&client, &server);
13725
13726 len = sizeof(time);
13727 SetLastError(0xdeadbeef);
13728 ret = getsockopt(client, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
13729 ok(!ret, "got %d\n", ret);
13730 ok(!GetLastError(), "got error %lu\n", GetLastError());
13731 ok(len == sizeof(time), "got len %d\n", len);
13732 ok(time == 0, "got time %u\n", time);
13733
13734 len = sizeof(time);
13735 SetLastError(0xdeadbeef);
13736 ret = getsockopt(server, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
13737 ok(!ret, "got %d\n", ret);
13738 ok(!GetLastError(), "got error %lu\n", GetLastError());
13739 ok(len == sizeof(time), "got len %d\n", len);
13740 ok(time == 0, "got time %u\n", time);
13741
13742 closesocket(client);
13743 closesocket(server);
13744
13745 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
13746 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
13747
13748 ret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
13749 ok(!ret, "got error %lu\n", GetLastError());
13750 len = sizeof(addr);
13751 ret = getsockname(server, (struct sockaddr *)&addr, &len);
13752 ok(!ret, "got error %lu\n", GetLastError());
13753 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
13754 ok(!ret, "got error %lu\n", GetLastError());
13755
13756 len = sizeof(time);
13757 SetLastError(0xdeadbeef);
13758 ret = getsockopt(client, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
13759 ok(!ret, "got %d\n", ret);
13760 ok(!GetLastError(), "got error %lu\n", GetLastError());
13761 ok(len == sizeof(time), "got len %d\n", len);
13762 ok(time == ~0u, "got time %u\n", time);
13763
13764 len = sizeof(time);
13765 SetLastError(0xdeadbeef);
13766 ret = getsockopt(server, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
13767 ok(!ret, "got %d\n", ret);
13768 ok(!GetLastError(), "got error %lu\n", GetLastError());
13769 ok(len == sizeof(time), "got len %d\n", len);
13770 ok(time == ~0u, "got time %u\n", time);
13771
13772 closesocket(server);
13773 closesocket(client);
13774 }
13775
13776 static void test_connect_udp(void)
13777 {
13778 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
13779 struct sockaddr_in addr, ret_addr;
13780 SOCKET client, server;
13781 char buffer[5];
13782 int ret, len;
13783
13784 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
13785 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
13786 set_blocking(client, FALSE);
13787 set_blocking(server, FALSE);
13788
13789 SetLastError(0xdeadbeef);
13790 ret = send(client, "data", 4, 0);
13791 ok(ret == -1, "got %d\n", ret);
13792 todo_wine ok(GetLastError() == WSAENOTCONN, "got error %lu\n", GetLastError());
13793
13794 SetLastError(0xdeadbeef);
13795 ret = recv(server, buffer, sizeof(buffer), 0);
13796 ok(ret == -1, "got %d\n", ret);
13797 todo_wine ok(GetLastError() == WSAEINVAL, "got error %lu\n", GetLastError());
13798
13799 ret = bind(server, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
13800 ok(!ret, "got error %lu\n", GetLastError());
13801 len = sizeof(addr);
13802 ret = getsockname(server, (struct sockaddr *)&addr, &len);
13803 ok(!ret, "got error %lu\n", GetLastError());
13804
13805 SetLastError(0xdeadbeef);
13806 ret = recv(server, buffer, sizeof(buffer), 0);
13807 ok(ret == -1, "got %d\n", ret);
13808 ok(GetLastError() == WSAEWOULDBLOCK, "got error %lu\n", GetLastError());
13809
13810 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
13811 ok(!ret, "got error %lu\n", GetLastError());
13812 ret = getpeername(client, (struct sockaddr *)&ret_addr, &len);
13813 ok(!ret, "got error %lu\n", GetLastError());
13814 ok(!memcmp(&ret_addr, &addr, sizeof(addr)), "addresses didn't match\n");
13815
13816 ret = getsockname(client, (struct sockaddr *)&ret_addr, &len);
13817 ok(!ret, "got error %lu\n", GetLastError());
13818
13819 SetLastError(0xdeadbeef);
13820 ret = getpeername(server, (struct sockaddr *)&ret_addr, &len);
13821 ok(ret == -1, "got %d\n", ret);
13822 ok(GetLastError() == WSAENOTCONN, "got error %lu\n", GetLastError());
13823
13824 ret = send(client, "data", 4, 0);
13825 ok(ret == 4, "got %d\n", ret);
13826
13827 memset(buffer, 0xcc, sizeof(buffer));
13828 ret = recv(server, buffer, sizeof(buffer), 0);
13829 ok(ret == 4, "got %d\n", ret);
13830 ok(!memcmp(buffer, "data", 4), "got %s\n", debugstr_an(buffer, ret));
13831
13832 SetLastError(0xdeadbeef);
13833 ret = recv(server, buffer, sizeof(buffer), 0);
13834 ok(ret == -1, "got %d\n", ret);
13835 ok(GetLastError() == WSAEWOULDBLOCK, "got error %lu\n", GetLastError());
13836
13837 SetLastError(0xdeadbeef);
13838 ret = send(server, "data", 4, 0);
13839 ok(ret == -1, "got %d\n", ret);
13840 todo_wine ok(GetLastError() == WSAENOTCONN, "got error %lu\n", GetLastError());
13841
13842 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
13843 ok(!ret, "got error %lu\n", GetLastError());
13844 ++addr.sin_port;
13845 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
13846 ok(!ret, "got error %lu\n", GetLastError());
13847
13848 memset(&addr, 0, sizeof(addr));
13849 addr.sin_family = AF_UNSPEC;
13850 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
13851 ok(!ret, "got error %lu\n", GetLastError());
13852
13853 ret = getpeername(client, (struct sockaddr *)&ret_addr, &len);
13854 ok(ret == -1, "got %d\n", ret);
13855 ok(GetLastError() == WSAENOTCONN, "got error %lu\n", GetLastError());
13856
13857 closesocket(server);
13858 closesocket(client);
13859 }
13860
13861 static void test_tcp_sendto_recvfrom(void)
13862 {
13863 SOCKET client, server = 0;
13864 SOCKADDR_IN addr = { AF_INET, SERVERPORT };
13865 SOCKADDR_IN bad_addr, bad_addr_copy;
13866 const char serverMsg[] = "ws2_32/TCP socket test";
13867 char clientBuf[sizeof(serverMsg)] = { 0 };
13868 int to_len = 0xc0ffee11;
13869 int ret;
13870
13871 inet_pton(AF_INET, SERVERIP, &addr.sin_addr);
13872
13873 tcp_socketpair(&client, &server);
13874
13875 memset(&bad_addr, 0xfe, sizeof(bad_addr));
13876 memcpy(&bad_addr_copy, &bad_addr, sizeof(bad_addr_copy));
13877
13878 ret = sendto(server, serverMsg, sizeof(serverMsg), 0, (SOCKADDR *)&bad_addr, sizeof(bad_addr));
13879 ok(ret == sizeof(serverMsg), "Incorrect return value from sendto: %d (%d)\n", ret, WSAGetLastError());
13880 ok(!memcmp(&bad_addr, &bad_addr_copy, sizeof(bad_addr)), "Provided address modified by sendto\n");
13881 ok(to_len == 0xc0ffee11, "Provided size modified by sendto\n");
13882
13883 ret = recvfrom(client, clientBuf, sizeof(clientBuf), 0, (SOCKADDR *)&bad_addr, &to_len);
13884 ok(ret == sizeof(serverMsg), "Incorrect return value from recvfrom: %d (%d)\n", ret, WSAGetLastError());
13885 ok(!memcmp(&bad_addr, &bad_addr_copy, sizeof(bad_addr)), "Provided address modified by recvfrom\n");
13886 ok(to_len == 0xc0ffee11, "Provided size modified by recvfrom\n");
13887
13888 ok(!memcmp(serverMsg, clientBuf, sizeof(serverMsg)), "Data mismatch over TCP socket\n");
13889
13890 closesocket(client);
13891 closesocket(server);
13892 }
13893
13894 START_TEST( sock )
13895 {
13896 int i;
13897
13898 /* Leave these tests at the beginning. They depend on WSAStartup not having been
13899 * called, which is done by Init() below. */
13900 test_WithoutWSAStartup();
13901 test_WithWSAStartup();
13902
13903 Init();
13904
13905 test_set_getsockopt();
13906 test_reuseaddr();
13907 test_ip_pktinfo();
13908 test_ipv4_cmsg();
13909 test_ipv6_cmsg();
13910 test_extendedSocketOptions();
13911 test_so_debug();
13912 test_sockopt_validity();
13913 test_connect_time();
13914
13915 for (i = 0; i < ARRAY_SIZE(tests); i++)
13916 do_test(&tests[i]);
13917
13918 test_UDP();
13919
13920 test_WSASocket();
13921 test_WSADuplicateSocket();
13922 test_WSAConnectByName();
13923 test_WSAEnumNetworkEvents();
13924
13925 test_errors();
13926 test_listen();
13927 test_select();
13928 test_accept();
13929 test_accept_inheritance();
13930 test_getpeername();
13931 test_getsockname();
13932
13933 test_address_list_query();
13934 test_fionbio();
13935 test_fionread_siocatmark();
13936 test_get_extension_func();
13937 test_backlog_query();
13938 test_get_interface_list();
13939 test_keepalive_vals();
13940 test_sioRoutingInterfaceQuery();
13941 test_sioAddressListChange();
13942 test_base_handle();
13943 test_circular_queueing();
13944 test_unsupported_ioctls();
13945
13946 test_WSASendMsg();
13947 test_WSASendTo();
13948 test_WSARecv();
13949 test_WSAPoll();
13950 test_write_watch();
13951
13952 test_events();
13953
13954 test_ipv6only();
13955 test_TransmitFile();
13956 test_AcceptEx();
13957 test_connect();
13958 test_shutdown();
13959 test_DisconnectEx();
13960
13961 test_completion_port();
13962 test_connect_completion_port();
13963 test_shutdown_completion_port();
13964 test_bind();
13965 test_connecting_socket();
13966 test_WSAGetOverlappedResult();
13967 test_nonblocking_async_recv();
13968 test_simultaneous_async_recv();
13969 test_empty_recv();
13970 test_timeout();
13971 test_tcp_reset();
13972 test_icmp();
13973 test_connect_udp();
13974 test_tcp_sendto_recvfrom();
13975
13976 /* There is apparently an obscure interaction between this test and
13977 * test_WSAGetOverlappedResult().
13978 *
13979 * One thing this test does is to close socket handles through CloseHandle()
13980 * and NtClose(), to prove that that is sufficient to cancel I/O on the
13981 * socket. This has the obscure side effect that ws2_32.dll's internal
13982 * per-process list of sockets never has that socket removed.
13983 *
13984 * test_WSAGetOverlappedResult() effectively proves that the per-process
13985 * list of sockets exists, by calling DuplicateHandle() on a socket and then
13986 * passing it to a function which cares about socket handle validity, which
13987 * checks that handle against the internal list, finds it invalid, and
13988 * returns WSAENOTSOCK.
13989 *
13990 * The problem is that if we close an NT handle without removing it from the
13991 * ws2_32 list, then duplicate another handle, it *may* end up allocated to
13992 * the same handle value, and thus re-validate that handle right under the
13993 * nose of ws2_32. This causes the test_WSAGetOverlappedResult() test to
13994 * sometimes succeed where it's expected to fail with ENOTSOCK.
13995 *
13996 * In order to avoid this, make sure that this test—which is evidently
13997 * destructive to ws2_32 internal state in obscure ways—is executed last.
13998 */
13999 test_iocp();
14000
14001 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
14002 test_send();
14003
14004 Exit();
14005 }
Windows API implementation