?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ntdll: Buffer pagemap reads in fill_working_set_info().
[wine.git] / dlls / ws2_32 / tests / sock.c
blobe8c618cc0af76d23fcbedaf3ec03f4454058a7e5
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 BOOL allow_noprotoopt; /* for old windows only, must work on wine */
1197 }
1198 test_optsize[] =
1199 {
1200 {AF_INET, SOCK_DGRAM, SOL_SOCKET, SO_BROADCAST, TRUE, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE, TRUE},
1201 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_DONTLINGER, TRUE, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE, TRUE},
1202 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_LINGER, FALSE, {1, 2, 4}, {0xdeadbe00, 0xdead0000}, TRUE},
1203 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_OOBINLINE, TRUE, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE, TRUE},
1204 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_RCVBUF, FALSE, {1, 2, 4}, {0xdeadbe00, 0xdead0000}, TRUE},
1205 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_KEEPALIVE, TRUE, {1, 1, 1}, {0}, TRUE},
1206 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_DONTROUTE, TRUE, {1, 1, 1}, {0}, TRUE},
1207 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_RCVTIMEO, FALSE, {1, 2, 4}, {0}, TRUE},
1208 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR, TRUE, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE, TRUE},
1209 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, TRUE, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE, TRUE},
1210 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_SNDBUF, FALSE, {1, 2, 4}, {0xdeadbe00, 0xdead0000}, TRUE},
1211 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_SNDTIMEO, FALSE, {1, 2, 4}, {0}, TRUE},
1212 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_OPENTYPE, FALSE, {1, 2, 4}, {0}, TRUE},
1213 {AF_INET, SOCK_STREAM, IPPROTO_TCP, TCP_NODELAY, TRUE, {1, 1, 1}, {0}, TRUE},
1214 {AF_INET, SOCK_STREAM, IPPROTO_TCP, TCP_KEEPALIVE, FALSE, {0, 0, 4}, {0}, TRUE},
1215 {AF_INET, SOCK_STREAM, IPPROTO_TCP, TCP_KEEPCNT, FALSE, {0, 0, 4}, {0}, FALSE, FALSE, TRUE}, /* win10+ */
1216 {AF_INET, SOCK_STREAM, IPPROTO_TCP, TCP_KEEPINTVL, FALSE, {0, 0, 4}, {0}, TRUE, FALSE, TRUE}, /* win10+ */
1217 {AF_INET, SOCK_DGRAM, IPPROTO_IP, IP_MULTICAST_LOOP, TRUE, {1, 1, 4}, {0}, TRUE, TRUE},
1218 {AF_INET, SOCK_DGRAM, IPPROTO_IP, IP_MULTICAST_TTL, TRUE, {1, 1, 4}, {0}, FALSE},
1219 {AF_INET, SOCK_DGRAM, IPPROTO_IP, IP_PKTINFO, FALSE, {0, 0, 4}, {0}, TRUE, TRUE},
1220 {AF_INET, SOCK_DGRAM, IPPROTO_IP, IP_RECVTOS, FALSE, {0, 0, 4}, {0}, TRUE, TRUE},
1221 {AF_INET, SOCK_DGRAM, IPPROTO_IP, IP_RECVTTL, FALSE, {0, 0, 4}, {0}, TRUE, TRUE},
1222 {AF_INET, SOCK_DGRAM, IPPROTO_IP, IP_TOS, TRUE, {1, 1, 4}, {0}, FALSE},
1223 {AF_INET, SOCK_DGRAM, IPPROTO_IP, IP_TTL, TRUE, {1, 1, 4}, {0}, FALSE},
1224 {AF_INET6, SOCK_STREAM, IPPROTO_IPV6, IPV6_DONTFRAG, TRUE, {1, 1, 4}, {0}, TRUE, TRUE},
1225 {AF_INET6, SOCK_DGRAM, IPPROTO_IPV6, IPV6_HOPLIMIT, FALSE, {0, 0, 4}, {0}, TRUE, TRUE},
1226 {AF_INET6, SOCK_DGRAM, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, TRUE, {1, 1, 4}, {0}, FALSE},
1227 {AF_INET6, SOCK_DGRAM, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, TRUE, {1, 1, 4}, {0}, TRUE, TRUE},
1228 {AF_INET6, SOCK_DGRAM, IPPROTO_IPV6, IPV6_PKTINFO, FALSE, {0, 0, 4}, {0}, TRUE, TRUE},
1229 {AF_INET6, SOCK_DGRAM, IPPROTO_IPV6, IPV6_RECVTCLASS, FALSE, {0, 0, 4}, {0}, TRUE, TRUE},
1230 {AF_INET6, SOCK_DGRAM, IPPROTO_IPV6, IPV6_UNICAST_HOPS, TRUE, {1, 1, 4}, {0}, FALSE},
1231 {AF_INET6, SOCK_DGRAM, IPPROTO_IPV6, IPV6_V6ONLY, TRUE, {1, 1, 1}, {0}, TRUE},
1232 };
1233 SOCKET s, s2, src, dst;
1234 int i, j, err, lasterr;
1235 int timeout;
1236 LINGER lingval;
1237 int size;
1238 WSAPROTOCOL_INFOA infoA;
1239 WSAPROTOCOL_INFOW infoW;
1240 char providername[WSAPROTOCOL_LEN + 1];
1241 DWORD expected_last_error, expected_value;
1242 int expected_err, expected_size;
1243 DWORD value, save_value;
1244 UINT64 value64;
1245 char buffer[4096];
1246
1247 struct _prottest
1248 {
1249 int family, type, proto;
1250 } prottest[] = {
1251 {AF_INET, SOCK_STREAM, IPPROTO_TCP},
1252 {AF_INET, SOCK_DGRAM, IPPROTO_UDP},
1253 {AF_INET6, SOCK_STREAM, IPPROTO_TCP},
1254 {AF_INET6, SOCK_DGRAM, IPPROTO_UDP}
1255 };
1256 union _csspace
1257 {
1258 CSADDR_INFO cs;
1259 char space[128];
1260 } csinfoA, csinfoB;
1261
1262 s = socket(AF_INET, SOCK_STREAM, 0);
1263 ok(s!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1264 if( s == INVALID_SOCKET) return;
1265 /* SO_RCVTIMEO */
1266 timeout = SOCKTIMEOUT1;
1267 size = sizeof(timeout);
1268 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1269 if( !err)
1270 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1271 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1272 ok( timeout == SOCKTIMEOUT1, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1273
1274 timeout = 0;
1275 size = sizeof(timeout);
1276 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1277 if( !err)
1278 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1279 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1280 ok( timeout == 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1281
1282 /* SO_SNDTIMEO */
1283 timeout = SOCKTIMEOUT2; /* 997 seconds. See remark above */
1284 size = sizeof(timeout);
1285 err = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, size);
1286 if( !err)
1287 err = getsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, &size);
1288 ok( !err, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1289 ok( timeout == SOCKTIMEOUT2, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout);
1290
1291 /* SO_SNDBUF */
1292 value = 4096;
1293 size = sizeof(value);
1294 err = setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&value, size);
1295 ok( !err, "setsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1296 value = 0xdeadbeef;
1297 err = getsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&value, &size);
1298 ok( !err, "getsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1299 ok( value == 4096, "expected 4096, got %lu\n", value );
1300
1301 /* SO_RCVBUF */
1302 value = 4096;
1303 size = sizeof(value);
1304 err = setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, size);
1305 ok( !err, "setsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1306 value = 0xdeadbeef;
1307 err = getsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, &size);
1308 ok( !err, "getsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1309 ok( value == 4096, "expected 4096, got %lu\n", value );
1310
1311 value = 0;
1312 size = sizeof(value);
1313 err = setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, size);
1314 ok( !err, "setsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1315 value = 0xdeadbeef;
1316 err = getsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, &size);
1317 ok( !err, "getsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1318 ok( value == 0, "expected 0, got %lu\n", value );
1319
1320 /* Test non-blocking receive with too short SO_RCVBUF. */
1321 tcp_socketpair(&src, &dst);
1322 set_blocking(src, FALSE);
1323 set_blocking(dst, FALSE);
1324
1325 value = 0;
1326 size = sizeof(value);
1327 err = setsockopt(src, SOL_SOCKET, SO_SNDBUF, (char *)&value, size);
1328 ok( !err, "got %d, error %u.\n", err, WSAGetLastError() );
1329
1330 value = 0xdeadbeef;
1331 err = getsockopt(dst, SOL_SOCKET, SO_RCVBUF, (char *)&value, &size);
1332 ok( !err, "got %d, error %u.\n", err, WSAGetLastError() );
1333 if (value >= sizeof(buffer) * 3)
1334 {
1335 value = 1024;
1336 size = sizeof(value);
1337 err = setsockopt(dst, SOL_SOCKET, SO_RCVBUF, (char *)&value, size);
1338 ok( !err, "got %d, error %u.\n", err, WSAGetLastError() );
1339 value = 0xdeadbeef;
1340 err = getsockopt(dst, SOL_SOCKET, SO_RCVBUF, (char *)&value, &size);
1341 ok( !err, "got %d, error %u.\n", err, WSAGetLastError() );
1342 ok( value == 1024, "expected 0, got %lu\n", value );
1343
1344 err = send(src, buffer, sizeof(buffer), 0);
1345 ok(err == sizeof(buffer), "got %d\n", err);
1346 err = send(src, buffer, sizeof(buffer), 0);
1347 ok(err == sizeof(buffer), "got %d\n", err);
1348 err = send(src, buffer, sizeof(buffer), 0);
1349 ok(err == sizeof(buffer), "got %d\n", err);
1350
1351 err = sync_recv(dst, buffer, sizeof(buffer), 0);
1352 ok(err == sizeof(buffer), "got %d, error %u\n", err, WSAGetLastError());
1353 err = sync_recv(dst, buffer, sizeof(buffer), 0);
1354 ok(err == sizeof(buffer), "got %d, error %u\n", err, WSAGetLastError());
1355 err = sync_recv(dst, buffer, sizeof(buffer), 0);
1356 ok(err == sizeof(buffer), "got %d, error %u\n", err, WSAGetLastError());
1357 }
1358 else
1359 {
1360 skip("Default SO_RCVBUF %lu is too small, skipping test.\n", value);
1361 }
1362
1363 closesocket(src);
1364 closesocket(dst);
1365
1366 /* SO_LINGER */
1367 for( i = 0; i < ARRAY_SIZE(linger_testvals);i++) {
1368 size = sizeof(lingval);
1369 lingval = linger_testvals[i];
1370 err = setsockopt(s, SOL_SOCKET, SO_LINGER, (char *)&lingval, size);
1371 ok(!err, "Test %u: failed to set SO_LINGER, error %u\n", i, WSAGetLastError());
1372 err = getsockopt(s, SOL_SOCKET, SO_LINGER, (char *)&lingval, &size);
1373 ok(!err, "Test %u: failed to get SO_LINGER, error %u\n", i, WSAGetLastError());
1374 ok(!lingval.l_onoff == !linger_testvals[i].l_onoff, "Test %u: expected %d, got %d\n",
1375 i, linger_testvals[i].l_onoff, lingval.l_onoff);
1376 if (lingval.l_onoff)
1377 ok(lingval.l_linger == linger_testvals[i].l_linger, "Test %u: expected %d, got %d\n",
1378 i, linger_testvals[i].l_linger, lingval.l_linger);
1379 }
1380
1381 size = sizeof(lingval);
1382 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, size);
1383 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1384 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1385 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, 0);
1386 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1387 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1388
1389 size = sizeof(BOOL);
1390 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, size);
1391 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1392 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1393 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, 0);
1394 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1395 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1396
1397 /* TCP_NODELAY: optlen doesn't matter on windows, it should work with any positive value */
1398 size = sizeof(value);
1399
1400 value = 1;
1401 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 1);
1402 ok (!err, "setsockopt TCP_NODELAY failed with optlen == 1\n");
1403 value = 0xff;
1404 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1405 ok(!err, "getsockopt TCP_NODELAY failed\n");
1406 ok(value == 1, "TCP_NODELAY should be 1\n");
1407 value = 0;
1408 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, sizeof(value));
1409 ok(!err, "Failed to reset TCP_NODELAY to 0\n");
1410
1411 value = 1;
1412 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 4);
1413 ok (!err, "setsockopt TCP_NODELAY failed with optlen == 4\n");
1414 value = 0xff;
1415 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1416 ok(!err, "getsockopt TCP_NODELAY failed\n");
1417 ok(value == 1, "TCP_NODELAY should be 1\n");
1418 value = 0;
1419 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, sizeof(value));
1420 ok(!err, "Failed to reset TCP_NODELAY to 0\n");
1421
1422 value = 1;
1423 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 42);
1424 ok (!err, "setsockopt TCP_NODELAY failed with optlen == 42\n");
1425 value = 0xff;
1426 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1427 ok(!err, "getsockopt TCP_NODELAY failed\n");
1428 ok(value == 1, "TCP_NODELAY should be 1\n");
1429 value = 0;
1430 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, sizeof(value));
1431 ok(!err, "Failed to reset TCP_NODELAY to 0\n");
1432
1433 value = 1;
1434 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 0);
1435 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1436 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1437 value = 0xff;
1438 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1439 ok(!err, "getsockopt TCP_NODELAY failed\n");
1440 ok(!value, "TCP_NODELAY should be 0\n");
1441
1442 value = 1;
1443 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, -1);
1444 /* On win 10 pro, this sets the error to WSAENOBUFS instead of WSAEFAULT */
1445 ok(err == SOCKET_ERROR && (WSAGetLastError() == WSAEFAULT || WSAGetLastError() == WSAENOBUFS),
1446 "got %d with %d (expected SOCKET_ERROR with either WSAEFAULT or WSAENOBUFS)\n", err, WSAGetLastError());
1447 value = 0xff;
1448 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1449 ok(!err, "getsockopt TCP_NODELAY failed\n");
1450 ok(!value, "TCP_NODELAY should be 0\n");
1451
1452 value = 0x100;
1453 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 4);
1454 ok (!err, "setsockopt TCP_NODELAY failed with optlen == 4 and optvalue = 0x100\n");
1455 value = 0xff;
1456 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1457 ok(!err, "getsockopt TCP_NODELAY failed\n");
1458 ok(!value, "TCP_NODELAY should be 0\n");
1459
1460 size = sizeof(DWORD);
1461 value = 3600;
1462 err = setsockopt(s, IPPROTO_TCP, TCP_KEEPALIVE, (char*)&value, 4);
1463 ok(!err, "setsockopt TCP_KEEPALIVE failed\n");
1464 value = 0;
1465 err = getsockopt(s, IPPROTO_TCP, TCP_KEEPALIVE, (char*)&value, &size);
1466 ok(!err, "getsockopt TCP_KEEPALIVE failed\n");
1467 ok(value == 3600, "TCP_KEEPALIVE should be 3600, is %ld\n", value);
1468
1469 /* TCP_KEEPCNT and TCP_KEEPINTVL are supported on win10 and later */
1470 value = 5;
1471 err = setsockopt(s, IPPROTO_TCP, TCP_KEEPCNT, (char*)&value, 4);
1472 ok(!err || broken(WSAGetLastError() == WSAENOPROTOOPT),
1473 "setsockopt TCP_KEEPCNT failed: %d\n", WSAGetLastError());
1474
1475 if (!err)
1476 {
1477 value = 0;
1478 err = getsockopt(s, IPPROTO_TCP, TCP_KEEPCNT, (char*)&value, &size);
1479 ok(!err, "getsockopt TCP_KEEPCNT failed\n");
1480 ok(value == 5, "TCP_KEEPCNT should be 5, is %ld\n", value);
1481
1482 err = setsockopt(s, IPPROTO_TCP, TCP_KEEPINTVL, (char*)&value, 4);
1483 ok(!err, "setsockopt TCP_KEEPINTVL failed\n");
1484 value = 0;
1485 err = getsockopt(s, IPPROTO_TCP, TCP_KEEPINTVL, (char*)&value, &size);
1486 ok(!err, "getsockopt TCP_KEEPINTVL failed\n");
1487 ok(value == 5, "TCP_KEEPINTVL should be 5, is %ld\n", value);
1488 }
1489
1490 /* Test for erroneously passing a value instead of a pointer as optval */
1491 size = sizeof(char);
1492 err = setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)1, size);
1493 ok(err == SOCKET_ERROR, "setsockopt with optval being a value passed "
1494 "instead of failing.\n");
1495 lasterr = WSAGetLastError();
1496 ok(lasterr == WSAEFAULT, "setsockopt with optval being a value "
1497 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1498 lasterr, WSAEFAULT);
1499
1500 /* SO_RCVTIMEO with invalid values for level */
1501 size = sizeof(timeout);
1502 timeout = SOCKTIMEOUT1;
1503 SetLastError(0xdeadbeef);
1504 err = setsockopt(s, 0xffffffff, SO_RCVTIMEO, (char *) &timeout, size);
1505 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1506 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1507 err, WSAGetLastError());
1508
1509 timeout = SOCKTIMEOUT1;
1510 SetLastError(0xdeadbeef);
1511 err = setsockopt(s, 0x00008000, SO_RCVTIMEO, (char *) &timeout, size);
1512 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1513 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1514 err, WSAGetLastError());
1515
1516 /* Test SO_ERROR set/get */
1517 SetLastError(0xdeadbeef);
1518 i = 1234;
1519 err = setsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, size);
1520 ok( !err && !WSAGetLastError(),
1521 "got %d with %d (expected 0 with 0)\n",
1522 err, WSAGetLastError());
1523
1524 SetLastError(0xdeadbeef);
1525 i = 4321;
1526 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1527 ok( !err && !WSAGetLastError(),
1528 "got %d with %d (expected 0 with 0)\n",
1529 err, WSAGetLastError());
1530 todo_wine
1531 ok (i == 1234, "got %d (expected 1234)\n", i);
1532
1533 /* Test invalid optlen */
1534 SetLastError(0xdeadbeef);
1535 size = 1;
1536 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1537 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEFAULT),
1538 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1539 err, WSAGetLastError());
1540
1541 closesocket(s);
1542
1543 /* Test option length. */
1544 for (i = 0; i < ARRAY_SIZE(test_optsize); ++i)
1545 {
1546 winetest_push_context("i %u, level %d, optname %d",
1547 i, test_optsize[i].level, test_optsize[i].optname);
1548
1549 s2 = socket( test_optsize[i].af, test_optsize[i].type, 0 );
1550 ok(s2 != INVALID_SOCKET, "socket() failed error %d\n", WSAGetLastError());
1551
1552 size = sizeof(save_value);
1553 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&save_value, &size);
1554 ok(!err || broken(test_optsize[i].allow_noprotoopt && WSAGetLastError() == WSAENOPROTOOPT),
1555 "Unexpected getsockopt result %d.\n", err);
1556
1557 if (err)
1558 {
1559 closesocket(s2);
1560 winetest_pop_context();
1561 continue;
1562 }
1563
1564 value64 = 0xffffffff00000001;
1565 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char *)&value64, sizeof(value64));
1566 ok(!err, "Unexpected setsockopt result %d.\n", err);
1567 ok(!WSAGetLastError(), "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1568
1569 size = sizeof(value64);
1570 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value64, &size);
1571 ok(!err, "Unexpected getsockopt result %d.\n", err);
1572 ok(size == test_optsize[i].sizes[2], "Got unexpected size %d.\n", size);
1573 /* The behaviour regarding filling the high dword is different between options without the obvious
1574 * pattern, it is either left untouched (more often) or zeroed. Wine doesn't touch the high dword. */
1575
1576 if (test_optsize[i].sizes[2] == 1 || test_optsize[i].level != SOL_SOCKET)
1577 {
1578 expected_err = -1;
1579 expected_last_error = WSAENOBUFS;
1580 }
1581 else
1582 {
1583 expected_err = 0;
1584 expected_last_error = 0;
1585 }
1586
1587 value = 1;
1588 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char *)&value, -1);
1589 ok(err == expected_err, "Unexpected setsockopt result %d.\n", err);
1590 /* Broken between Win7 and Win10 21H1. */
1591 ok(WSAGetLastError() == expected_last_error || broken(expected_last_error && WSAGetLastError() == WSAEFAULT),
1592 "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1593
1594 size = -1;
1595 value = 0xdeadbeef;
1596 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, &size);
1597 if (test_optsize[i].optname == SO_OPENTYPE)
1598 {
1599 ok(!err, "Unexpected getsockopt result %d.\n", err);
1600 ok(!WSAGetLastError(), "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1601 }
1602 else
1603 {
1604 ok(err == -1, "Unexpected getsockopt result %d.\n", err);
1605 ok(WSAGetLastError() == WSAEFAULT, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1606 }
1607 ok(size == (test_optsize[i].optname == SO_OPENTYPE ? 4 : -1), "Got unexpected size %d.\n", size);
1608
1609 if (test_optsize[i].level == SOL_SOCKET && test_optsize[i].bool_value)
1610 {
1611 expected_err = 0;
1612 expected_last_error = 0;
1613 }
1614 else
1615 {
1616 expected_err = -1;
1617 expected_last_error = WSAEFAULT;
1618 }
1619 value = 1;
1620 SetLastError(0xdeadbeef);
1621 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, 0);
1622 ok(err == expected_err, "Unexpected setsockopt result %d.\n", err);
1623 ok(WSAGetLastError() == expected_last_error, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1624
1625 size = 0;
1626 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, &size);
1627 ok(err == -1, "Unexpected getsockopt result %d.\n", err);
1628 ok(WSAGetLastError() == WSAEFAULT, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1629
1630 expected_size = test_optsize[i].sizes[2];
1631 if (expected_size == 1)
1632 expected_value = 0xdeadbe00;
1633 else
1634 expected_value = test_optsize[i].bool_value ? 0x1 : 0x100;
1635 if (test_optsize[i].accepts_large_value)
1636 {
1637 expected_err = 0;
1638 expected_last_error = 0;
1639 }
1640 else
1641 {
1642 expected_err = -1;
1643 expected_last_error = WSAEINVAL;
1644 }
1645
1646 value = 0x100;
1647 SetLastError(0xdeadbeef);
1648 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, 4);
1649 ok(err == expected_err, "Unexpected setsockopt result %d.\n", err);
1650 ok(WSAGetLastError() == expected_last_error, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1651
1652 if (test_optsize[i].accepts_large_value)
1653 {
1654 value = 0xdeadbeef;
1655 SetLastError(0xdeadbeef);
1656 size = 4;
1657 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, &size);
1658 ok(err == expected_err, "Unexpected getsockopt result %d.\n", err);
1659 ok(WSAGetLastError() == expected_last_error, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1660 todo_wine_if(test_optsize[i].optname == SO_DONTROUTE || test_optsize[i].optname == SO_LINGER)
1661 ok(value == expected_value, "Got unexpected value %#lx, expected %#lx.\n", value, expected_value);
1662 ok(size == expected_size, "Got unexpected size %u, expected %u.\n", size, expected_size);
1663 }
1664
1665 winetest_pop_context();
1666
1667 for (j = 0; j < ARRAY_SIZE(test_optsize[i].sizes); ++j)
1668 {
1669 size = 1 << j;
1670 winetest_push_context("i %u, level %d, optname %d, len %u",
1671 i, test_optsize[i].level, test_optsize[i].optname, size);
1672
1673 value = 1;
1674 if (test_optsize[i].values[j])
1675 expected_value = test_optsize[i].values[j];
1676 else
1677 expected_value = 0xdeadbeef;
1678
1679 if (test_optsize[i].accepts_short_len || size == 4)
1680 {
1681 expected_err = 0;
1682 expected_last_error = 0;
1683 expected_size = test_optsize[i].sizes[j];
1684
1685 if (!test_optsize[i].values[j])
1686 memcpy(&expected_value, &value, expected_size);
1687 }
1688 else
1689 {
1690 expected_err = -1;
1691 expected_last_error = WSAEFAULT;
1692 expected_size = test_optsize[i].sizes[j];
1693 }
1694
1695 SetLastError(0xdeadbeef);
1696 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, size);
1697 ok(err == expected_err, "Unexpected setsockopt result %d.\n", err);
1698 ok(WSAGetLastError() == expected_last_error, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1699
1700 value = 0xdeadbeef;
1701 SetLastError(0xdeadbeef);
1702 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, &size);
1703 ok(err == expected_err, "Unexpected getsockopt result %d.\n", err);
1704 ok(WSAGetLastError() == expected_last_error, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1705 ok(value == expected_value, "Got unexpected value %#lx, expected %#lx.\n", value, expected_value);
1706 ok(size == expected_size, "Got unexpected size %d, expected %d.\n", size, expected_size);
1707
1708 winetest_pop_context();
1709 }
1710
1711 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname,
1712 (char*)&save_value, sizeof(save_value));
1713 ok(!err, "Unexpected getsockopt result %d.\n", err);
1714 closesocket(s2);
1715 }
1716
1717 /* Test with the closed socket */
1718 SetLastError(0xdeadbeef);
1719 size = sizeof(i);
1720 i = 1234;
1721 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1722 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAENOTSOCK),
1723 "got %d with %d (expected SOCKET_ERROR with WSAENOTSOCK)\n",
1724 err, WSAGetLastError());
1725 ok (i == 1234, "expected 1234, got %d\n", i);
1726
1727 /* Test WS_IP_MULTICAST_TTL with 8, 16, 24 and 32 bits values */
1728 s = socket(AF_INET, SOCK_DGRAM, 0);
1729 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1730 size = sizeof(i);
1731 i = 0x0000000a;
1732 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &i, size);
1733 if (!err)
1734 {
1735 for (i = 0; i < 4; i++)
1736 {
1737 int k, j;
1738 const int tests[] = {0xffffff0a, 0xffff000b, 0xff00000c, 0x0000000d};
1739 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &tests[i], i + 1);
1740 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1741 err = getsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &k, &size);
1742 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1743 j = i != 3 ? tests[i] & ((1 << (i + 1) * 8) - 1) : tests[i];
1744 ok(k == j, "Test [%d] Expected 0x%x, got 0x%x\n", i, j, k);
1745 }
1746 }
1747 else
1748 win_skip("IP_MULTICAST_TTL is unsupported\n");
1749 closesocket(s);
1750
1751 /* test SO_PROTOCOL_INFOA invalid parameters */
1752 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1753 "getsockopt should have failed\n");
1754 err = WSAGetLastError();
1755 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1756 size = sizeof(WSAPROTOCOL_INFOA);
1757 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1758 "getsockopt should have failed\n");
1759 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1760 err = WSAGetLastError();
1761 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1762 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1763 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1764 "getsockopt should have failed\n");
1765 err = WSAGetLastError();
1766 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1767 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, NULL),
1768 "getsockopt should have failed\n");
1769 err = WSAGetLastError();
1770 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1771 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, &size),
1772 "getsockopt should have failed\n");
1773 err = WSAGetLastError();
1774 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1775 size = sizeof(WSAPROTOCOL_INFOA) / 2;
1776 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1777 "getsockopt should have failed\n");
1778 err = WSAGetLastError();
1779 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1780 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1781 size = sizeof(WSAPROTOCOL_INFOA) * 2;
1782 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1783 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1784 ok(size == sizeof(WSAPROTOCOL_INFOA) * 2, "got size %d\n", size);
1785
1786 closesocket(s);
1787
1788 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1789 for (i = 0; i < ARRAY_SIZE(prottest); i++)
1790 {
1791 int k;
1792
1793 s = socket(prottest[i].family, prottest[i].type, prottest[i].proto);
1794 if (s == INVALID_SOCKET && prottest[i].family == AF_INET6) continue;
1795
1796 ok(s != INVALID_SOCKET, "Failed to create socket: %d\n",
1797 WSAGetLastError());
1798
1799 /* compare both A and W version */
1800 infoA.szProtocol[0] = 0;
1801 size = sizeof(WSAPROTOCOL_INFOA);
1802 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1803 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1804 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1805
1806 infoW.szProtocol[0] = 0;
1807 size = sizeof(WSAPROTOCOL_INFOW);
1808 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOW, (char *) &infoW, &size);
1809 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1810 ok(size == sizeof(WSAPROTOCOL_INFOW), "got size %d\n", size);
1811
1812 ok(infoA.szProtocol[0], "WSAPROTOCOL_INFOA was not filled\n");
1813 ok(infoW.szProtocol[0], "WSAPROTOCOL_INFOW was not filled\n");
1814
1815 WideCharToMultiByte(CP_ACP, 0, infoW.szProtocol, -1,
1816 providername, sizeof(providername), NULL, NULL);
1817 ok(!strcmp(infoA.szProtocol,providername),
1818 "different provider names '%s' != '%s'\n", infoA.szProtocol, providername);
1819
1820 ok(!memcmp(&infoA, &infoW, FIELD_OFFSET(WSAPROTOCOL_INFOA, szProtocol)),
1821 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1822
1823 /* Remove IF when WSAEnumProtocols support IPV6 data */
1824 ok(infoA.iAddressFamily == prottest[i].family, "socket family invalid, expected %d received %d\n",
1825 prottest[i].family, infoA.iAddressFamily);
1826 ok(infoA.iSocketType == prottest[i].type, "socket type invalid, expected %d received %d\n",
1827 prottest[i].type, infoA.iSocketType);
1828 ok(infoA.iProtocol == prottest[i].proto, "socket protocol invalid, expected %d received %d\n",
1829 prottest[i].proto, infoA.iProtocol);
1830
1831 /* IP_HDRINCL is supported only on SOCK_RAW but passed to SOCK_DGRAM by Impossible Creatures */
1832 size = sizeof(i);
1833 k = 1;
1834 SetLastError(0xdeadbeef);
1835 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1836 if (err == -1) /* >= Vista */
1837 {
1838 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %ld\n", GetLastError());
1839 k = 99;
1840 SetLastError(0xdeadbeef);
1841 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1842 ok(err == -1, "Expected -1, got %d\n", err);
1843 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %ld\n", GetLastError());
1844 ok(k == 99, "Expected 99, got %d\n", k);
1845
1846 size = sizeof(k);
1847 k = 0;
1848 SetLastError(0xdeadbeef);
1849 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1850 ok(err == -1, "Expected -1, got %d\n", err);
1851 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %ld\n", GetLastError());
1852 k = 99;
1853 SetLastError(0xdeadbeef);
1854 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1855 ok(err == -1, "Expected -1, got %d\n", err);
1856 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %ld\n", GetLastError());
1857 ok(k == 99, "Expected 99, got %d\n", k);
1858 }
1859 else /* <= 2003 the tests differ between TCP and UDP, UDP silently accepts */
1860 {
1861 SetLastError(0xdeadbeef);
1862 k = 99;
1863 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1864 if (prottest[i].type == SOCK_DGRAM)
1865 {
1866 ok(err == 0, "Expected 0, got %d\n", err);
1867 ok(k == 1, "Expected 1, got %d\n", k);
1868 }
1869 else
1870 {
1871 /* contratry to what we could expect the function returns error but k is changed */
1872 ok(err == -1, "Expected -1, got %d\n", err);
1873 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %ld\n", GetLastError());
1874 ok(k == 0, "Expected 0, got %d\n", k);
1875 }
1876
1877 k = 0;
1878 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1879 ok(err == 0, "Expected 0, got %d\n", err);
1880
1881 k = 99;
1882 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1883 if (prottest[i].type == SOCK_DGRAM)
1884 {
1885 ok(err == 0, "Expected 0, got %d\n", err);
1886 ok(k == 0, "Expected 0, got %d\n", k);
1887 }
1888 else
1889 {
1890 /* contratry to what we could expect the function returns error but k is changed */
1891 ok(err == -1, "Expected -1, got %d\n", err);
1892 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %ld\n", GetLastError());
1893 ok(k == 0, "Expected 0, got %d\n", k);
1894 }
1895 }
1896
1897 closesocket(s);
1898 }
1899
1900 /* Test SO_BSP_STATE - Present only in >= Win 2008 */
1901 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1902 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1903 s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1904 ok(s2 != INVALID_SOCKET, "Failed to create socket\n");
1905
1906 SetLastError(0xdeadbeef);
1907 size = sizeof(csinfoA);
1908 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1909 if (!err)
1910 {
1911 struct sockaddr_in saddr;
1912 memset(&saddr, 0, sizeof(saddr));
1913 saddr.sin_family = AF_INET;
1914 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1915
1916 /* Socket is not bound, no information provided */
1917 ok(!csinfoA.cs.LocalAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.LocalAddr.iSockaddrLength);
1918 ok(csinfoA.cs.LocalAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.LocalAddr.lpSockaddr);
1919 /* Socket is not connected, no information provided */
1920 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.RemoteAddr.iSockaddrLength);
1921 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.RemoteAddr.lpSockaddr);
1922
1923 err = bind(s, (struct sockaddr*)&saddr, sizeof(saddr));
1924 ok(!err, "Expected 0, got %d\n", err);
1925 size = sizeof(csinfoA);
1926 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1927 ok(!err, "Expected 0, got %d\n", err);
1928
1929 /* Socket is bound */
1930 ok(csinfoA.cs.LocalAddr.iSockaddrLength, "Expected non-zero\n");
1931 ok(csinfoA.cs.LocalAddr.lpSockaddr != NULL, "Expected non-null\n");
1932 /* Socket is not connected, no information provided */
1933 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.RemoteAddr.iSockaddrLength);
1934 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.RemoteAddr.lpSockaddr);
1935
1936 err = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1937 ok(!err, "Expected 0, got %d\n", err);
1938 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1939 ok(!err, "Expected 0, got %d\n", err);
1940 err = listen(s2, 1);
1941 ok(!err, "Expected 0, got %d\n", err);
1942 err = connect(s, (struct sockaddr*)&saddr, sizeof(saddr));
1943 ok(!err, "Expected 0, got %d\n", err);
1944 size = sizeof(saddr);
1945 err = accept(s2, (struct sockaddr*)&saddr, &size);
1946 ok(err != INVALID_SOCKET, "Failed to accept socket\n");
1947 closesocket(s2);
1948 s2 = err;
1949
1950 size = sizeof(csinfoA);
1951 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1952 ok(!err, "Expected 0, got %d\n", err);
1953 err = getsockopt(s2, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoB, &size);
1954 ok(!err, "Expected 0, got %d\n", err);
1955 ok(size == sizeof(csinfoA), "Got %d\n", size);
1956 size = sizeof(saddr);
1957 ok(size == csinfoA.cs.LocalAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1958 csinfoA.cs.LocalAddr.iSockaddrLength);
1959 ok(size == csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1960 csinfoA.cs.RemoteAddr.iSockaddrLength);
1961 ok(!memcmp(csinfoA.cs.LocalAddr.lpSockaddr, csinfoB.cs.RemoteAddr.lpSockaddr, size),
1962 "Expected matching addresses\n");
1963 ok(!memcmp(csinfoB.cs.LocalAddr.lpSockaddr, csinfoA.cs.RemoteAddr.lpSockaddr, size),
1964 "Expected matching addresses\n");
1965 ok(csinfoA.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1966 ok(csinfoB.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1967 ok(csinfoA.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1968 ok(csinfoB.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1969
1970 err = getpeername(s, (struct sockaddr *)&saddr, &size);
1971 ok(!err, "Expected 0, got %d\n", err);
1972 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1973 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1974 err = getpeername(s2, (struct sockaddr *)&saddr, &size);
1975 ok(!err, "Expected 0, got %d\n", err);
1976 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1977 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1978 err = getsockname(s, (struct sockaddr *)&saddr, &size);
1979 ok(!err, "Expected 0, got %d\n", err);
1980 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1981 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1982 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1983 ok(!err, "Expected 0, got %d\n", err);
1984 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1985 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1986
1987 SetLastError(0xdeadbeef);
1988 size = sizeof(CSADDR_INFO);
1989 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1990 ok(err, "Expected non-zero\n");
1991 ok(size == sizeof(CSADDR_INFO), "Got %d\n", size);
1992 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %ld\n", GetLastError());
1993
1994 /* At least for IPv4 the size is exactly 56 bytes */
1995 size = sizeof(*csinfoA.cs.LocalAddr.lpSockaddr) * 2 + sizeof(csinfoA.cs);
1996 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1997 ok(!err, "Expected 0, got %d\n", err);
1998 size--;
1999 SetLastError(0xdeadbeef);
2000 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
2001 ok(err, "Expected non-zero\n");
2002 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %ld\n", GetLastError());
2003 }
2004 else
2005 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %ld\n", GetLastError());
2006
2007 closesocket(s);
2008 closesocket(s2);
2009
2010 for (i = 0; i < 2; i++)
2011 {
2012 int family, level;
2013
2014 if (i)
2015 {
2016 family = AF_INET6;
2017 level = IPPROTO_IPV6;
2018 }
2019 else
2020 {
2021 family = AF_INET;
2022 level = IPPROTO_IP;
2023 }
2024
2025 s = socket(family, SOCK_DGRAM, 0);
2026 if (s == INVALID_SOCKET && i)
2027 {
2028 skip("IPv6 is not supported\n");
2029 break;
2030 }
2031 ok(s != INVALID_SOCKET, "socket failed with error %ld\n", GetLastError());
2032
2033 size = sizeof(value);
2034 value = 0xdead;
2035 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
2036 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2037 ok(value == 0, "Expected 0, got %ld\n", value);
2038
2039 size = sizeof(value);
2040 value = 1;
2041 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
2042 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2043
2044 value = 0xdead;
2045 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
2046 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2047 ok(value == 1, "Expected 1, got %ld\n", value);
2048
2049 size = sizeof(value);
2050 value = 0xdead;
2051 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
2052 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2053
2054 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
2055 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2056 ok(value == 1, "Expected 1, got %ld\n", value);
2057
2058 closesocket(s);
2059
2060 s = socket(family, SOCK_STREAM, 0);
2061 ok(s != INVALID_SOCKET, "socket failed with error %ld\n", GetLastError());
2062
2063 size = sizeof(value);
2064 value = 0xdead;
2065 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
2066 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2067 ok(value == 1 || broken(value == 0) /* < vista */, "Expected 1, got %ld\n", value);
2068
2069 size = sizeof(value);
2070 value = 0;
2071 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
2072 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2073
2074 value = 0xdead;
2075 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
2076 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2077 ok(value == 0, "Expected 0, got %ld\n", value);
2078
2079 closesocket(s);
2080
2081 s = socket(family, SOCK_RAW, 0);
2082 if (s == INVALID_SOCKET)
2083 {
2084 if (WSAGetLastError() == WSAEACCES) skip("SOCK_RAW is not available\n");
2085 else if (i) skip("IPv6 is not supported\n");
2086 break;
2087 }
2088 ok(s != INVALID_SOCKET, "socket failed with error %ld\n", GetLastError());
2089
2090 size = sizeof(value);
2091 value = 0xdead;
2092 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
2093 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2094 ok(value == 0, "Expected 0, got %ld\n", value);
2095
2096 size = sizeof(value);
2097 value = 1;
2098 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
2099 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2100
2101 value = 0xdead;
2102 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
2103 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2104 ok(value == 1, "Expected 1, got %ld\n", value);
2105
2106 closesocket(s);
2107 }
2108 }
2109
2110 static void test_reuseaddr(void)
2111 {
2112 static struct sockaddr_in6 saddr_in6_any, saddr_in6_loopback;
2113 static struct sockaddr_in6 saddr_in6_any_v4mapped, saddr_in6_loopback_v4mapped;
2114 static struct sockaddr_in saddr_in_any, saddr_in_loopback;
2115
2116 static const struct
2117 {
2118 int domain;
2119 struct sockaddr *addr_any;
2120 struct sockaddr *addr_loopback;
2121 socklen_t addrlen;
2122 }
2123 tests[] =
2124 {
2125 { AF_INET, (struct sockaddr *)&saddr_in_any, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_any) },
2126 { AF_INET6, (struct sockaddr *)&saddr_in6_any, (struct sockaddr *)&saddr_in6_loopback, sizeof(saddr_in6_any) },
2127 };
2128 static const struct
2129 {
2130 struct
2131 {
2132 int domain;
2133 struct sockaddr *addr;
2134 socklen_t addrlen;
2135 BOOL exclusive;
2136 }
2137 s[2];
2138 int error;
2139 }
2140 tests_exclusive[] =
2141 {
2142 {
2143 {{ AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, },
2144 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, }},
2145 WSAEACCES,
2146 },
2147 {
2148 {{ AF_INET6, (struct sockaddr *)&saddr_in6_any, sizeof(saddr_in6_any), TRUE, },
2149 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, }},
2150 WSAEACCES,
2151 },
2152 {
2153 {{ AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, },
2154 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, }},
2155 NOERROR,
2156 },
2157 {
2158 {{ AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, },
2159 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, }},
2160 WSAEACCES,
2161 },
2162 {
2163 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, },
2164 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, }},
2165 NOERROR,
2166 },
2167 {
2168 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, },
2169 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, }},
2170 WSAEADDRINUSE,
2171 },
2172 {
2173 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, },
2174 { AF_INET6, (struct sockaddr *)&saddr_in6_any, sizeof(saddr_in6_any), TRUE, }},
2175 WSAEADDRINUSE,
2176 },
2177 {
2178 {{ AF_INET6, (struct sockaddr *)&saddr_in6_loopback, sizeof(saddr_in6_loopback), FALSE, },
2179 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, }},
2180 NOERROR,
2181 },
2182 {
2183 {{ AF_INET6, (struct sockaddr *)&saddr_in6_loopback, sizeof(saddr_in6_loopback), TRUE, },
2184 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, }},
2185 NOERROR,
2186 },
2187 {
2188 {{ AF_INET6, (struct sockaddr *)&saddr_in6_loopback_v4mapped, sizeof(saddr_in6_loopback_v4mapped), FALSE, },
2189 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, }},
2190 WSAEADDRINUSE,
2191 },
2192 {
2193 {{ AF_INET6, (struct sockaddr *)&saddr_in6_any, sizeof(saddr_in6_any), TRUE, },
2194 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, }},
2195 WSAEACCES,
2196 },
2197 {
2198 {{ AF_INET6, (struct sockaddr *)&saddr_in6_any, sizeof(saddr_in6_any), FALSE, },
2199 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, }},
2200 NOERROR,
2201 },
2202 {
2203 {{ AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, },
2204 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, }},
2205 WSAEADDRINUSE,
2206 },
2207 {
2208 {{ AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, },
2209 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, }},
2210 WSAEADDRINUSE,
2211 },
2212 {
2213 {{ AF_INET6, (struct sockaddr *)&saddr_in6_any, sizeof(saddr_in6_any), FALSE, },
2214 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, }},
2215 NOERROR,
2216 },
2217 {
2218 {{ AF_INET6, (struct sockaddr *)&saddr_in6_any_v4mapped, sizeof(saddr_in6_any_v4mapped), FALSE, },
2219 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, }},
2220 WSAEADDRINUSE,
2221 },
2222 {
2223 {{ AF_INET6, (struct sockaddr *)&saddr_in6_loopback_v4mapped, sizeof(saddr_in6_loopback_v4mapped), FALSE, },
2224 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, }},
2225 WSAEADDRINUSE,
2226 },
2227 {
2228 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, },
2229 { AF_INET6, (struct sockaddr *)&saddr_in6_loopback_v4mapped, sizeof(saddr_in6_loopback_v4mapped), FALSE, }},
2230 WSAEADDRINUSE,
2231 },
2232 {
2233 {{ AF_INET6, (struct sockaddr *)&saddr_in6_loopback, sizeof(saddr_in6_loopback), TRUE, },
2234 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, }},
2235 NOERROR,
2236 },
2237 {
2238 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, },
2239 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, }},
2240 WSAEADDRINUSE,
2241 },
2242 {
2243 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, },
2244 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, }},
2245 WSAEADDRINUSE,
2246 },
2247 };
2248
2249 unsigned int rc, reuse, value;
2250 struct sockaddr_storage saddr;
2251 SOCKET s1, s2, s3, s4, s5, s6;
2252 unsigned int i, j;
2253 int size;
2254
2255 saddr_in_any.sin_family = AF_INET;
2256 saddr_in_any.sin_port = htons(SERVERPORT + 1);
2257 saddr_in_any.sin_addr.s_addr = htonl(INADDR_ANY);
2258 saddr_in_loopback = saddr_in_any;
2259 saddr_in_loopback.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
2260
2261 saddr_in6_any.sin6_family = AF_INET6;
2262 saddr_in6_any.sin6_port = htons(SERVERPORT + 1);
2263 memset( &saddr_in6_any.sin6_addr, 0, sizeof(saddr_in6_any.sin6_addr) );
2264 saddr_in6_loopback = saddr_in6_any;
2265 inet_pton(AF_INET6, "::1", &saddr_in6_loopback.sin6_addr);
2266
2267 saddr_in6_loopback_v4mapped = saddr_in6_any;
2268 rc = inet_pton(AF_INET6, "::ffff:127.0.0.1", &saddr_in6_loopback_v4mapped.sin6_addr);
2269 ok(rc, "got error %d.\n", WSAGetLastError());
2270
2271 saddr_in6_any_v4mapped = saddr_in6_any;
2272 rc = inet_pton(AF_INET6, "::ffff:0.0.0.0", &saddr_in6_any_v4mapped.sin6_addr);
2273 ok(rc, "got error %d.\n", WSAGetLastError());
2274
2275 for (i = 0; i < ARRAY_SIZE(tests); ++i)
2276 {
2277 winetest_push_context("test %u", i);
2278
2279 /* Test with SO_REUSEADDR on second socket only. */
2280 s1=socket(tests[i].domain, SOCK_STREAM, 0);
2281 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2282
2283 rc = bind(s1, tests[i].addr_loopback, tests[i].addrlen);
2284 ok(!rc || (tests[i].domain == AF_INET6 && WSAGetLastError() == WSAEADDRNOTAVAIL), "got error %d.\n", WSAGetLastError());
2285 if (tests[i].domain == AF_INET6 && WSAGetLastError() == WSAEADDRNOTAVAIL)
2286 {
2287 skip("IPv6 not supported, skipping test\n");
2288 closesocket(s1);
2289 winetest_pop_context();
2290 continue;
2291 }
2292
2293 s2 = socket(tests[i].domain, SOCK_STREAM, 0);
2294 ok(s2 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2295
2296 reuse = 1;
2297 rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
2298 ok(!rc, "got error %d.\n", WSAGetLastError());
2299
2300 rc = bind(s2, tests[i].addr_loopback, tests[i].addrlen);
2301 ok(rc == SOCKET_ERROR, "got rc %d.\n", rc);
2302 ok(WSAGetLastError() == WSAEACCES, "got error %d.\n", WSAGetLastError());
2303
2304 closesocket(s1);
2305 closesocket(s2);
2306
2307 /* Test with SO_REUSEADDR on both sockets. */
2308 s1 = socket(tests[i].domain, SOCK_STREAM, 0);
2309 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2310
2311 reuse = 1;
2312 rc = setsockopt(s1, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
2313 ok(!rc, "got error %d.\n", WSAGetLastError());
2314
2315 rc = bind(s1, tests[i].addr_loopback, tests[i].addrlen);
2316 ok(!rc, "got error %d.\n", WSAGetLastError());
2317
2318 s2 = socket(tests[i].domain, SOCK_STREAM, 0);
2319 ok(s2 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2320
2321 reuse = 0x1234;
2322 size = sizeof(reuse);
2323 rc = getsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, &size);
2324 ok(!rc && !reuse,"got rc %d, reuse %d.\n", rc, reuse);
2325
2326 rc = bind(s2, tests[i].addr_loopback, tests[i].addrlen);
2327 ok(rc == SOCKET_ERROR, "got rc %d, error %d.\n", rc, WSAGetLastError());
2328
2329 reuse = 1;
2330 rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
2331 ok(!rc, "got error %d.\n", WSAGetLastError());
2332
2333 rc = bind(s2, tests[i].addr_loopback, tests[i].addrlen);
2334 ok(!rc, "got error %d.\n", WSAGetLastError());
2335
2336 s3 = socket(tests[i].domain, SOCK_STREAM, 0);
2337 ok(s3 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2338
2339 /* Test if we can really connect to one of them. */
2340 rc = listen(s1, 1);
2341 ok(!rc, "got error %d.\n", WSAGetLastError());
2342 rc = listen(s2, 1);
2343 todo_wine ok(!rc, "got error %d.\n", WSAGetLastError());
2344 rc = connect(s3, tests[i].addr_loopback, tests[i].addrlen);
2345 ok(!rc, "got error %d.\n", WSAGetLastError());
2346
2347 /* The connection is delivered to the first socket. */
2348 size = tests[i].addrlen;
2349 s4 = accept(s1, (struct sockaddr *)&saddr, &size);
2350 ok(s4 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2351
2352 closesocket(s1);
2353 closesocket(s2);
2354 closesocket(s3);
2355 closesocket(s4);
2356
2357 /* Test binding and listening on any addr together with loopback, any addr first. */
2358 s1 = socket(tests[i].domain, SOCK_STREAM, 0);
2359 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2360
2361 rc = bind(s1, tests[i].addr_any, tests[i].addrlen);
2362 ok(!rc, "got error %d.\n", WSAGetLastError());
2363
2364 rc = listen(s1, 1);
2365 ok(!rc, "got error %d.\n", WSAGetLastError());
2366
2367 s2 = socket(tests[i].domain, SOCK_STREAM, 0);
2368 ok(s2 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2369
2370 rc = bind(s2, tests[i].addr_loopback, tests[i].addrlen);
2371 todo_wine ok(!rc, "got error %d.\n", WSAGetLastError());
2372
2373 rc = listen(s2, 1);
2374 todo_wine ok(!rc, "got error %d.\n", WSAGetLastError());
2375
2376 s3 = socket(tests[i].domain, SOCK_STREAM, 0);
2377 ok(s3 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2378
2379 rc = connect(s3, tests[i].addr_loopback, tests[i].addrlen);
2380 ok(!rc, "got error %d.\n", WSAGetLastError());
2381
2382 size = tests[i].addrlen;
2383 s4 = accept(s2, (struct sockaddr *)&saddr, &size);
2384 todo_wine ok(s4 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2385
2386 closesocket(s1);
2387 closesocket(s2);
2388 closesocket(s3);
2389 closesocket(s4);
2390
2391 /* Test binding and listening on any addr together with loopback, loopback addr first. */
2392
2393 s1 = socket(tests[i].domain, SOCK_STREAM, 0);
2394 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2395
2396 rc = bind(s1, tests[i].addr_loopback, tests[i].addrlen);
2397 ok(!rc, "got error %d.\n", WSAGetLastError());
2398
2399 rc = listen(s1, 1);
2400 ok(!rc, "got error %d.\n", WSAGetLastError());
2401
2402 s2 = socket(tests[i].domain, SOCK_STREAM, 0);
2403 ok(s2 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2404
2405 rc = bind(s2, tests[i].addr_any, tests[i].addrlen);
2406 todo_wine ok(!rc, "got rc %d, error %d.\n", rc, WSAGetLastError());
2407
2408 rc = listen(s2, 1);
2409 todo_wine ok(!rc, "got error %d.\n", WSAGetLastError());
2410
2411 s3 = socket(tests[i].domain, SOCK_STREAM, 0);
2412 ok(s3 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2413
2414 rc = connect(s3, tests[i].addr_loopback, tests[i].addrlen);
2415 ok(!rc, "got error %d.\n", WSAGetLastError());
2416 size = tests[i].addrlen;
2417 s4 = accept(s1, (struct sockaddr *)&saddr, &size);
2418
2419 ok(s4 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2420
2421 closesocket(s1);
2422 closesocket(s2);
2423 closesocket(s3);
2424 closesocket(s4);
2425
2426 /* Test binding to INADDR_ANY on two sockets. */
2427 s1 = socket(tests[i].domain, SOCK_STREAM, 0);
2428 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2429
2430 rc = bind(s1, tests[i].addr_any, tests[i].addrlen);
2431 ok(!rc, "got error %d.\n", WSAGetLastError());
2432
2433 s2 = socket(tests[i].domain, SOCK_STREAM, 0);
2434 ok(s2 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2435
2436 rc = bind(s2, tests[i].addr_any, tests[i].addrlen);
2437 ok(rc == SOCKET_ERROR && WSAGetLastError() == WSAEADDRINUSE, "got rc %d, error %d.\n", rc, WSAGetLastError());
2438
2439 closesocket(s1);
2440 closesocket(s2);
2441
2442 /* Test successive binds and bind-after-listen */
2443 reuse = 1;
2444 s1 = socket(tests[i].domain, SOCK_STREAM, 0);
2445 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2446 rc = setsockopt(s1, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
2447 ok(!rc, "got error %d.\n", WSAGetLastError());
2448
2449 s2 = socket(tests[i].domain, SOCK_STREAM, 0);
2450 ok(s2 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2451 rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
2452 ok(!rc, "got error %d.\n", WSAGetLastError());
2453
2454 s3 = socket(tests[i].domain, SOCK_STREAM, 0);
2455 ok(s3 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2456 rc = setsockopt(s3, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
2457 ok(!rc, "got error %d.\n", WSAGetLastError());
2458
2459 s4 = socket(tests[i].domain, SOCK_STREAM, 0);
2460 ok(s4 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2461 rc = setsockopt(s4, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
2462 ok(!rc, "got error %d.\n", WSAGetLastError());
2463
2464 rc = bind(s1, tests[i].addr_loopback, tests[i].addrlen);
2465 ok(!rc, "got error %d.\n", WSAGetLastError());
2466
2467 rc = bind(s2, tests[i].addr_loopback, tests[i].addrlen);
2468 ok(!rc, "got error %d.\n", WSAGetLastError());
2469
2470 s5 = socket(tests[i].domain, SOCK_STREAM, 0);
2471 ok(s5 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2472
2473 rc = listen(s1, 1);
2474 ok(!rc, "got error %d.\n", WSAGetLastError());
2475 rc = listen(s2, 1);
2476 todo_wine ok(!rc, "got error %d.\n", WSAGetLastError());
2477 rc = connect(s5, tests[i].addr_loopback, tests[i].addrlen);
2478 ok(!rc, "got error %d.\n", WSAGetLastError());
2479
2480 /* The connection is delivered to the first socket. */
2481 size = tests[i].addrlen;
2482 s6 = accept(s1, (struct sockaddr *)&saddr, &size);
2483 ok(s6 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2484
2485 closesocket(s1);
2486 closesocket(s5);
2487 closesocket(s6);
2488
2489 rc = bind(s3, tests[i].addr_loopback, tests[i].addrlen);
2490 ok(!rc, "got error %d.\n", WSAGetLastError());
2491
2492 s5 = socket(tests[i].domain, SOCK_STREAM, 0);
2493 ok(s5 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2494 rc = connect(s5, tests[i].addr_loopback, tests[i].addrlen);
2495 todo_wine ok(!rc, "got error %d.\n", WSAGetLastError());
2496
2497 /* The connection is delivered to the second socket. */
2498 size = tests[i].addrlen;
2499 s6 = accept(s2, (struct sockaddr *)&saddr, &size);
2500 todo_wine ok(s6 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2501
2502 closesocket(s2);
2503 closesocket(s5);
2504 closesocket(s6);
2505
2506 rc = bind(s4, tests[i].addr_loopback, tests[i].addrlen);
2507 ok(!rc, "got error %d.\n", WSAGetLastError());
2508 rc = listen(s3, 1);
2509 ok(!rc, "got error %d.\n", WSAGetLastError());
2510
2511 s5 = socket(tests[i].domain, SOCK_STREAM, 0);
2512 ok(s5 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2513 rc = connect(s5, tests[i].addr_loopback, tests[i].addrlen);
2514 ok(!rc, "got error %d.\n", WSAGetLastError());
2515
2516 /* The connection is delivered to the third socket. */
2517 size = tests[i].addrlen;
2518 s6 = accept(s3, (struct sockaddr *)&saddr, &size);
2519 ok(s6 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2520
2521 closesocket(s3);
2522 closesocket(s5);
2523 closesocket(s6);
2524
2525 rc = listen(s4, 1);
2526 ok(!rc, "got error %d.\n", WSAGetLastError());
2527
2528 s5 = socket(tests[i].domain, SOCK_STREAM, 0);
2529 ok(s5 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2530 rc = connect(s5, tests[i].addr_loopback, tests[i].addrlen);
2531 ok(!rc, "got error %d.\n", WSAGetLastError());
2532
2533 /* The connection is delivered to the fourth socket. */
2534 size = tests[i].addrlen;
2535 s6 = accept(s4, (struct sockaddr *)&saddr, &size);
2536 ok(s6 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2537
2538 closesocket(s4);
2539 closesocket(s5);
2540 closesocket(s6);
2541
2542 winetest_pop_context();
2543 }
2544
2545 /* SO_REUSEADDR and SO_EXCLUSIVEADDRUSE are mutually exclusive. */
2546 s1 = socket(AF_INET, SOCK_STREAM, 0);
2547 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2548
2549 value = 1;
2550 rc = setsockopt(s1, SOL_SOCKET, SO_REUSEADDR, (char*)&value, sizeof(value));
2551 ok(!rc, "got error %d.\n", WSAGetLastError());
2552
2553 value = 1;
2554 rc = setsockopt(s1, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&value, sizeof(value));
2555 ok(rc == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL, "got rc %d, error %d.\n", rc, WSAGetLastError());
2556
2557 value = 0;
2558 rc = setsockopt(s1, SOL_SOCKET, SO_REUSEADDR, (char*)&value, sizeof(value));
2559
2560 value = 1;
2561 rc = setsockopt(s1, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&value, sizeof(value));
2562 ok(!rc, "got error %d.\n", WSAGetLastError());
2563
2564 value = 1;
2565 rc = setsockopt(s1, SOL_SOCKET, SO_REUSEADDR, (char*)&value, sizeof(value));
2566 ok(rc == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL, "got rc %d, error %d.\n", rc, WSAGetLastError());
2567
2568 closesocket(s1);
2569
2570 /* Test SO_EXCLUSIVEADDRUSE. */
2571 for (i = 0; i < ARRAY_SIZE(tests_exclusive); ++i)
2572 {
2573 SOCKET s[2];
2574
2575 winetest_push_context("test %u", i);
2576
2577 for (j = 0; j < 2; ++j)
2578 {
2579 s[j] = socket(tests_exclusive[i].s[j].domain, SOCK_STREAM, 0);
2580 ok(s[j] != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2581
2582 if (tests_exclusive[i].s[j].exclusive)
2583 {
2584 value = 1;
2585 rc = setsockopt(s[j], SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&value, sizeof(value));
2586 ok(!rc, "got error %d.\n", WSAGetLastError());
2587 }
2588 if (tests_exclusive[i].s[j].domain == AF_INET6)
2589 {
2590 value = 0;
2591 rc = setsockopt(s[j], IPPROTO_IPV6, IPV6_V6ONLY, (char*)&value, sizeof(value));
2592 ok(!rc, "got error %d.\n", WSAGetLastError());
2593 }
2594 }
2595 rc = bind(s[0], tests_exclusive[i].s[0].addr, tests_exclusive[i].s[0].addrlen);
2596 ok(!rc || (tests_exclusive[i].s[0].domain == AF_INET6 && WSAGetLastError() == WSAEADDRNOTAVAIL), "got error %d.\n", WSAGetLastError());
2597
2598 rc = bind(s[1], tests_exclusive[i].s[1].addr, tests_exclusive[i].s[1].addrlen);
2599
2600 if (tests_exclusive[i].error)
2601 ok(rc == SOCKET_ERROR && WSAGetLastError() == tests_exclusive[i].error,
2602 "got rc %d, error %d, expected error %d.\n", rc, WSAGetLastError(), tests_exclusive[i].error);
2603 else
2604 ok(!rc, "got error %d.\n", WSAGetLastError());
2605
2606 closesocket(s[0]);
2607 closesocket(s[1]);
2608 winetest_pop_context();
2609 }
2610 }
2611
2612 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
2613
2614 static unsigned int got_ip_pktinfo_apc;
2615
2616 static void WINAPI ip_pktinfo_apc(DWORD error, DWORD size, OVERLAPPED *overlapped, DWORD flags)
2617 {
2618 ok(error == WSAEMSGSIZE, "got error %lu\n", error);
2619 ok(size == 6, "got size %lu\n", size);
2620 ok(!flags, "got flags %#lx\n", flags);
2621 ++got_ip_pktinfo_apc;
2622 }
2623
2624 static void test_ip_pktinfo(void)
2625 {
2626 ULONG addresses[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY)};
2627 char recvbuf[10], pktbuf[512], msg[] = "HELLO";
2628 struct sockaddr_in s1addr, s2addr, s3addr;
2629 LPFN_WSARECVMSG pWSARecvMsg = NULL;
2630 unsigned int rc, yes = 1;
2631 BOOL foundhdr;
2632 DWORD dwBytes, dwSize, dwFlags;
2633 socklen_t addrlen;
2634 WSACMSGHDR *cmsg;
2635 WSAOVERLAPPED ov;
2636 WSABUF iovec[1];
2637 SOCKET s1, s2;
2638 WSAMSG hdr;
2639 int i, err;
2640
2641 memset(&ov, 0, sizeof(ov));
2642 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
2643
2644 memset(&hdr, 0x00, sizeof(hdr));
2645 s1addr.sin_family = AF_INET;
2646 s1addr.sin_port = htons(0);
2647 /* Note: s1addr.sin_addr is set below */
2648 iovec[0].buf = recvbuf;
2649 iovec[0].len = sizeof(recvbuf);
2650 hdr.name = (struct sockaddr*)&s3addr;
2651 hdr.namelen = sizeof(s3addr);
2652 hdr.lpBuffers = &iovec[0];
2653 hdr.dwBufferCount = 1;
2654 hdr.Control.buf = pktbuf;
2655 /* Note: hdr.Control.len is set below */
2656 hdr.dwFlags = 0;
2657
2658 for (i=0;i<ARRAY_SIZE(addresses);i++)
2659 {
2660 s1addr.sin_addr.s_addr = addresses[i];
2661
2662 /* Build "server" side socket */
2663 s1=socket(AF_INET, SOCK_DGRAM, 0);
2664 ok(s1 != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2665
2666 /* Obtain the WSARecvMsg function */
2667 rc = WSAIoctl(s1, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
2668 &pWSARecvMsg, sizeof(pWSARecvMsg), &dwBytes, NULL, NULL);
2669 ok(!rc, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
2670
2671 /* Setup the server side socket */
2672 rc=bind(s1, (struct sockaddr*)&s1addr, sizeof(s1addr));
2673 ok(rc != SOCKET_ERROR, "bind() failed error: %d\n", WSAGetLastError());
2674
2675 /* Build "client" side socket */
2676 addrlen = sizeof(s2addr);
2677 rc = getsockname(s1, (struct sockaddr *) &s2addr, &addrlen);
2678 ok(!rc, "failed to get address, error %u\n", WSAGetLastError());
2679 s2addr.sin_addr.s_addr = addresses[0]; /* Always target the local adapter address */
2680 s2=socket(AF_INET, SOCK_DGRAM, 0);
2681 ok(s2 != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2682
2683 /* Test an empty message header */
2684 rc=pWSARecvMsg(s1, NULL, NULL, NULL, NULL);
2685 err=WSAGetLastError();
2686 ok(rc == SOCKET_ERROR && err == WSAEFAULT, "WSARecvMsg() failed error: %d (ret = %d)\n", err, rc);
2687
2688 /* Test that when no control data arrives, a 0-length NULL-valued control buffer should succeed */
2689 SetLastError(0xdeadbeef);
2690 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2691 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2692 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
2693 hdr.Control.buf = NULL;
2694 hdr.Control.len = 0;
2695 rc=pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
2696 ok(rc == 0, "WSARecvMsg() failed error: %d\n", WSAGetLastError());
2697 hdr.Control.buf = pktbuf;
2698
2699 /* Now start IP_PKTINFO for future tests */
2700 rc=setsockopt(s1, IPPROTO_IP, IP_PKTINFO, (const char*)&yes, sizeof(yes));
2701 ok(rc == 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
2702
2703 /*
2704 * Send a packet from the client to the server and test for specifying
2705 * a short control header.
2706 */
2707 SetLastError(0xdeadbeef);
2708 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2709 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2710 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
2711 hdr.Control.len = 1;
2712 dwSize = 0xdeadbeef;
2713 rc = pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
2714 ok(rc == -1, "expected failure\n");
2715 ok(WSAGetLastError() == WSAEMSGSIZE, "got error %u\n", WSAGetLastError());
2716 todo_wine ok(dwSize == sizeof(msg), "got size %lu\n", dwSize);
2717 ok(hdr.dwFlags == MSG_CTRUNC, "got flags %#lx\n", hdr.dwFlags);
2718 hdr.dwFlags = 0; /* Reset flags */
2719
2720 /* Perform another short control header test, this time with an overlapped receive */
2721 hdr.Control.len = 1;
2722 ov.Internal = 0xdead1;
2723 ov.InternalHigh = 0xdead2;
2724 ov.Offset = 0xdead3;
2725 ov.OffsetHigh = 0xdead4;
2726 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
2727 err=WSAGetLastError();
2728 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
2729 SetLastError(0xdeadbeef);
2730 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2731 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2732 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
2733 ok(!WaitForSingleObject(ov.hEvent, 100), "wait failed\n");
2734 ok((NTSTATUS)ov.Internal == STATUS_BUFFER_OVERFLOW, "got status %#lx\n", (NTSTATUS)ov.Internal);
2735 ok(ov.InternalHigh == sizeof(msg), "got size %Iu\n", ov.InternalHigh);
2736 ok(ov.Offset == 0xdead3, "got Offset %lu\n", ov.Offset);
2737 ok(ov.OffsetHigh == 0xdead4, "got OffsetHigh %lu\n", ov.OffsetHigh);
2738 dwFlags = 0xdeadbeef;
2739 rc = WSAGetOverlappedResult(s1, &ov, &dwSize, FALSE, &dwFlags);
2740 ok(!rc, "expected failure\n");
2741 ok(WSAGetLastError() == WSAEMSGSIZE, "got error %u\n", WSAGetLastError());
2742 ok(dwSize == sizeof(msg), "got size %lu\n", dwSize);
2743 todo_wine ok(dwFlags == 0xdeadbeef, "got flags %#lx\n", dwFlags);
2744 ok(hdr.dwFlags == MSG_CTRUNC,
2745 "WSARecvMsg() overlapped operation set unexpected flags %ld.\n", hdr.dwFlags);
2746 hdr.dwFlags = 0; /* Reset flags */
2747
2748 /* And with an APC. */
2749
2750 SetLastError(0xdeadbeef);
2751 rc = sendto(s2, msg, sizeof(msg), 0, (struct sockaddr *)&s2addr, sizeof(s2addr));
2752 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2753 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
2754 hdr.Control.len = 1;
2755
2756 ov.Internal = 0xdead1;
2757 ov.InternalHigh = 0xdead2;
2758 ov.Offset = 0xdead3;
2759 ov.OffsetHigh = 0xdead4;
2760 dwSize = 0xdeadbeef;
2761 rc = pWSARecvMsg(s1, &hdr, NULL, &ov, ip_pktinfo_apc);
2762 ok(rc == -1, "expected failure\n");
2763 todo_wine ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
2764
2765 rc = SleepEx(1000, TRUE);
2766 ok(rc == WAIT_IO_COMPLETION, "got %d\n", rc);
2767 ok(got_ip_pktinfo_apc == 1, "apc was called %u times\n", got_ip_pktinfo_apc);
2768 ok(hdr.dwFlags == MSG_CTRUNC, "got flags %#lx\n", hdr.dwFlags);
2769 got_ip_pktinfo_apc = 0;
2770
2771 hdr.dwFlags = 0; /* Reset flags */
2772
2773 /*
2774 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
2775 * on the server end and check that the returned packet matches what was sent.
2776 */
2777 hdr.Control.len = sizeof(pktbuf);
2778 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
2779 err=WSAGetLastError();
2780 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
2781 ok(hdr.Control.len == sizeof(pktbuf),
2782 "WSARecvMsg() control length mismatch (%ld != sizeof pktbuf).\n", hdr.Control.len);
2783 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2784 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2785 ok(!WaitForSingleObject(ov.hEvent, 100), "wait failed\n");
2786 dwSize = 0;
2787 WSAGetOverlappedResult(s1, &ov, &dwSize, FALSE, NULL);
2788 ok(dwSize == sizeof(msg),
2789 "WSARecvMsg() buffer length does not match transmitted data!\n");
2790 ok(strncmp(iovec[0].buf, msg, sizeof(msg)) == 0,
2791 "WSARecvMsg() buffer does not match transmitted data!\n");
2792 ok(hdr.Control.len == IP_PKTINFO_LEN,
2793 "WSARecvMsg() control length mismatch (%ld).\n", hdr.Control.len);
2794
2795 /* Test for the expected IP_PKTINFO return information. */
2796 foundhdr = FALSE;
2797 for (cmsg = WSA_CMSG_FIRSTHDR(&hdr); cmsg != NULL; cmsg = WSA_CMSG_NXTHDR(&hdr, cmsg))
2798 {
2799 if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO)
2800 {
2801 struct in_pktinfo *pi = (struct in_pktinfo *)WSA_CMSG_DATA(cmsg);
2802
2803 ok(pi->ipi_addr.s_addr == s2addr.sin_addr.s_addr, "destination ip mismatch!\n");
2804 foundhdr = TRUE;
2805 }
2806 }
2807 ok(foundhdr, "IP_PKTINFO header information was not returned!\n");
2808
2809 closesocket(s2);
2810 closesocket(s1);
2811 }
2812
2813 CloseHandle(ov.hEvent);
2814 }
2815
2816 static void test_ipv4_cmsg(void)
2817 {
2818 static const DWORD off = 0;
2819 static const DWORD on = 1;
2820 SOCKADDR_IN localhost = {0};
2821 SOCKET client, server;
2822 char payload[] = "HELLO";
2823 char control[100];
2824 WSABUF payload_buf = {sizeof(payload), payload};
2825 WSAMSG msg = {NULL, 0, &payload_buf, 1, {sizeof(control), control}, 0};
2826 WSACMSGHDR *header = (WSACMSGHDR *)control;
2827 LPFN_WSARECVMSG pWSARecvMsg;
2828 INT *int_data = (INT *)WSA_CMSG_DATA(header);
2829 IN_PKTINFO *pkt_info = (IN_PKTINFO *)WSA_CMSG_DATA(header);
2830 DWORD count, state;
2831 int rc;
2832
2833 localhost.sin_family = AF_INET;
2834 localhost.sin_port = htons(SERVERPORT);
2835 inet_pton(AF_INET, "127.0.0.1", &localhost.sin_addr);
2836
2837 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
2838 ok(client != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2839 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
2840 ok(server != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2841
2842 rc = bind(server, (SOCKADDR *)&localhost, sizeof(localhost));
2843 ok(rc != SOCKET_ERROR, "bind failed, error %u\n", WSAGetLastError());
2844 rc = connect(client, (SOCKADDR *)&localhost, sizeof(localhost));
2845 ok(rc != SOCKET_ERROR, "connect failed, error %u\n", WSAGetLastError());
2846
2847 rc = WSAIoctl(server, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
2848 &pWSARecvMsg, sizeof(pWSARecvMsg), &count, NULL, NULL);
2849 ok(!rc, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
2850
2851 memset(control, 0, sizeof(control));
2852 msg.Control.len = sizeof(control);
2853 rc = setsockopt(server, IPPROTO_IP, IP_RECVTTL, (const char *)&on, sizeof(on));
2854 ok(!rc, "failed to set IP_RECVTTL, error %u\n", WSAGetLastError());
2855 state = 0;
2856 count = sizeof(state);
2857 rc = getsockopt(server, IPPROTO_IP, IP_RECVTTL, (char *)&state, (INT *)&count);
2858 ok(!rc, "failed to get IP_RECVTTL, error %u\n", WSAGetLastError());
2859 ok(state == 1, "expected 1, got %lu\n", state);
2860 rc = send(client, payload, sizeof(payload), 0);
2861 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2862 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2863 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2864 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2865 ok(header->cmsg_level == IPPROTO_IP, "expected IPPROTO_IP, got %i\n", header->cmsg_level);
2866 ok(header->cmsg_type == IP_TTL || broken(header->cmsg_type == IP_HOPLIMIT) /* <= win10 v1607 */,
2867 "expected IP_TTL, got %i\n", header->cmsg_type);
2868 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
2869 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(INT), header->cmsg_len);
2870 ok(*int_data >= 32, "expected at least 32, got %i\n", *int_data);
2871 setsockopt(server, IPPROTO_IP, IP_RECVTTL, (const char *)&off, sizeof(off));
2872 ok(!rc, "failed to clear IP_RECVTTL, error %u\n", WSAGetLastError());
2873
2874 memset(control, 0, sizeof(control));
2875 msg.Control.len = sizeof(control);
2876 rc = setsockopt(server, IPPROTO_IP, IP_PKTINFO, (const char *)&on, sizeof(on));
2877 ok(!rc, "failed to set IP_PKTINFO, error %u\n", WSAGetLastError());
2878 state = 0;
2879 count = sizeof(state);
2880 rc = getsockopt(server, IPPROTO_IP, IP_PKTINFO, (char *)&state, (INT *)&count);
2881 ok(!rc, "failed to get IP_PKTINFO, error %u\n", WSAGetLastError());
2882 ok(state == 1, "expected 1, got %lu\n", state);
2883 rc = send(client, payload, sizeof(payload), 0);
2884 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2885 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2886 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2887 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2888 ok(header->cmsg_level == IPPROTO_IP, "expected IPPROTO_IP, got %i\n", header->cmsg_level);
2889 ok(header->cmsg_type == IP_PKTINFO, "expected IP_PKTINFO, got %i\n", header->cmsg_type);
2890 ok(header->cmsg_len == sizeof(*header) + sizeof(IN_PKTINFO),
2891 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(IN_PKTINFO), header->cmsg_len);
2892 ok(!memcmp(&pkt_info->ipi_addr, &localhost.sin_addr, sizeof(IN_ADDR)), "expected 127.0.0.1\n");
2893 rc = setsockopt(server, IPPROTO_IP, IP_PKTINFO, (const char *)&off, sizeof(off));
2894 ok(!rc, "failed to clear IP_PKTINFO, error %u\n", WSAGetLastError());
2895
2896 memset(control, 0, sizeof(control));
2897 msg.Control.len = sizeof(control);
2898 rc = setsockopt(server, IPPROTO_IP, IP_RECVTOS, (const char *)&on, sizeof(on));
2899 ok(!rc, "failed to set IP_RECVTOS, error %u\n", WSAGetLastError());
2900 state = 0;
2901 count = sizeof(state);
2902 rc = getsockopt(server, IPPROTO_IP, IP_RECVTOS, (char *)&state, (INT *)&count);
2903 ok(!rc, "failed to get IP_RECVTOS, error %u\n", WSAGetLastError());
2904 ok(state == 1, "expected 1, got %lu\n", state);
2905 rc = send(client, payload, sizeof(payload), 0);
2906 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2907 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2908 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2909 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2910 ok(header->cmsg_level == IPPROTO_IP, "expected IPPROTO_IP, got %i\n", header->cmsg_level);
2911 ok(header->cmsg_type == IP_TOS || broken(header->cmsg_type == IP_TCLASS) /* <= win10 v1607 */,
2912 "expected IP_TOS, got %i\n", header->cmsg_type);
2913 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
2914 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(INT), header->cmsg_len);
2915 ok(*int_data == 0, "expected 0, got %i\n", *int_data);
2916 rc = setsockopt(server, IPPROTO_IP, IP_RECVTOS, (const char *)&off, sizeof(off));
2917 ok(!rc, "failed to clear IP_RECVTOS, error %u\n", WSAGetLastError());
2918
2919 closesocket(server);
2920 closesocket(client);
2921 }
2922
2923 static void test_ipv6_cmsg(void)
2924 {
2925 static const DWORD off = 0;
2926 static const DWORD on = 1;
2927 SOCKADDR_IN6 localhost = {0};
2928 SOCKET client, server;
2929 char payload[] = "HELLO";
2930 char control[100];
2931 WSABUF payload_buf = {sizeof(payload), payload};
2932 WSAMSG msg = {NULL, 0, &payload_buf, 1, {sizeof(control), control}, 0};
2933 WSACMSGHDR *header = (WSACMSGHDR *)control;
2934 LPFN_WSARECVMSG pWSARecvMsg;
2935 INT *int_data = (INT *)WSA_CMSG_DATA(header);
2936 IN6_PKTINFO *pkt_info = (IN6_PKTINFO *)WSA_CMSG_DATA(header);
2937 DWORD count, state;
2938 int rc;
2939
2940 localhost.sin6_family = AF_INET6;
2941 localhost.sin6_port = htons(SERVERPORT);
2942 inet_pton(AF_INET6, "::1", &localhost.sin6_addr);
2943
2944 client = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
2945 ok(client != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2946 server = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
2947 ok(server != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2948
2949 rc = bind(server, (SOCKADDR *)&localhost, sizeof(localhost));
2950 ok(rc != SOCKET_ERROR || WSAGetLastError() == WSAEADDRNOTAVAIL, "bind failed, error %u\n", WSAGetLastError());
2951 if (WSAGetLastError() == WSAEADDRNOTAVAIL)
2952 {
2953 skip("IPv6 not supported, skipping test\n");
2954 goto cleanup;
2955 }
2956 rc = connect(client, (SOCKADDR *)&localhost, sizeof(localhost));
2957 ok(rc != SOCKET_ERROR, "connect failed, error %u\n", WSAGetLastError());
2958
2959 rc = WSAIoctl(server, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
2960 &pWSARecvMsg, sizeof(pWSARecvMsg), &count, NULL, NULL);
2961 ok(!rc, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
2962
2963 memset(control, 0, sizeof(control));
2964 msg.Control.len = sizeof(control);
2965 rc = setsockopt(server, IPPROTO_IPV6, IPV6_HOPLIMIT, (const char *)&on, sizeof(on));
2966 ok(!rc, "failed to set IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2967 state = 0;
2968 count = sizeof(state);
2969 rc = getsockopt(server, IPPROTO_IPV6, IPV6_HOPLIMIT, (char *)&state, (INT *)&count);
2970 ok(!rc, "failed to get IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2971 ok(state == 1, "expected 1, got %lu\n", state);
2972 rc = send(client, payload, sizeof(payload), 0);
2973 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2974 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2975 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2976 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2977 ok(header->cmsg_level == IPPROTO_IPV6, "expected IPPROTO_IPV6, got %i\n", header->cmsg_level);
2978 ok(header->cmsg_type == IPV6_HOPLIMIT, "expected IPV6_HOPLIMIT, got %i\n", header->cmsg_type);
2979 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
2980 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(INT), header->cmsg_len);
2981 ok(*int_data >= 32, "expected at least 32, got %i\n", *int_data);
2982 setsockopt(server, IPPROTO_IPV6, IPV6_HOPLIMIT, (const char *)&off, sizeof(off));
2983 ok(!rc, "failed to clear IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2984
2985 memset(control, 0, sizeof(control));
2986 msg.Control.len = sizeof(control);
2987 rc = setsockopt(server, IPPROTO_IPV6, IPV6_PKTINFO, (const char *)&on, sizeof(on));
2988 ok(!rc, "failed to set IPV6_PKTINFO, error %u\n", WSAGetLastError());
2989 state = 0;
2990 count = sizeof(state);
2991 rc = getsockopt(server, IPPROTO_IPV6, IPV6_PKTINFO, (char *)&state, (INT *)&count);
2992 ok(!rc, "failed to get IPV6_PKTINFO, error %u\n", WSAGetLastError());
2993 ok(state == 1, "expected 1, got %lu\n", state);
2994 rc = send(client, payload, sizeof(payload), 0);
2995 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2996 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2997 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2998 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2999 ok(header->cmsg_level == IPPROTO_IPV6, "expected IPPROTO_IPV6, got %i\n", header->cmsg_level);
3000 ok(header->cmsg_type == IPV6_PKTINFO, "expected IPV6_PKTINFO, got %i\n", header->cmsg_type);
3001 ok(header->cmsg_len == sizeof(*header) + sizeof(IN6_PKTINFO),
3002 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(IN6_PKTINFO), header->cmsg_len);
3003 ok(!memcmp(&pkt_info->ipi6_addr, &localhost.sin6_addr, sizeof(IN6_ADDR)), "expected ::1\n");
3004 rc = setsockopt(server, IPPROTO_IPV6, IPV6_PKTINFO, (const char *)&off, sizeof(off));
3005 ok(!rc, "failed to clear IPV6_PKTINFO, error %u\n", WSAGetLastError());
3006
3007 memset(control, 0, sizeof(control));
3008 msg.Control.len = sizeof(control);
3009 rc = setsockopt(server, IPPROTO_IPV6, IPV6_RECVTCLASS, (const char *)&on, sizeof(on));
3010 ok(!rc, "failed to set IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
3011 state = 0;
3012 count = sizeof(state);
3013 rc = getsockopt(server, IPPROTO_IPV6, IPV6_RECVTCLASS, (char *)&state, (INT *)&count);
3014 ok(!rc, "failed to get IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
3015 ok(state == 1, "expected 1, got %lu\n", state);
3016 rc = send(client, payload, sizeof(payload), 0);
3017 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
3018 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
3019 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
3020 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
3021 ok(header->cmsg_level == IPPROTO_IPV6, "expected IPPROTO_IPV6, got %i\n", header->cmsg_level);
3022 ok(header->cmsg_type == IPV6_TCLASS, "expected IPV6_TCLASS, got %i\n", header->cmsg_type);
3023 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
3024 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(INT), header->cmsg_len);
3025 ok(*int_data == 0, "expected 0, got %i\n", *int_data);
3026 rc = setsockopt(server, IPPROTO_IPV6, IPV6_RECVTCLASS, (const char *)&off, sizeof(off));
3027 ok(!rc, "failed to clear IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
3028
3029 cleanup:
3030 closesocket(server);
3031 closesocket(client);
3032 }
3033
3034 /************* Array containing the tests to run **********/
3035
3036 #define STD_STREAM_SOCKET \
3037 SOCK_STREAM, \
3038 0, \
3039 SERVERIP, \
3040 SERVERPORT
3041
3042 static test_setup tests [] =
3043 {
3044 /* Test 0: synchronous client and server */
3045 {
3046 {
3047 STD_STREAM_SOCKET,
3048 2048,
3049 16,
3050 2
3051 },
3052 simple_server,
3053 {
3054 NULL,
3055 0,
3056 64
3057 },
3058 simple_client,
3059 {
3060 NULL,
3061 0,
3062 128
3063 }
3064 },
3065 /* Test 1: event-driven client, synchronous server */
3066 {
3067 {
3068 STD_STREAM_SOCKET,
3069 2048,
3070 16,
3071 2
3072 },
3073 simple_server,
3074 {
3075 NULL,
3076 0,
3077 64
3078 },
3079 event_client,
3080 {
3081 NULL,
3082 WSA_FLAG_OVERLAPPED,
3083 128
3084 }
3085 },
3086 /* Test 2: synchronous client, non-blocking server via select() */
3087 {
3088 {
3089 STD_STREAM_SOCKET,
3090 2048,
3091 16,
3092 2
3093 },
3094 select_server,
3095 {
3096 NULL,
3097 0,
3098 64
3099 },
3100 simple_client,
3101 {
3102 NULL,
3103 0,
3104 128
3105 }
3106 },
3107 /* Test 3: OOB client, OOB server */
3108 {
3109 {
3110 STD_STREAM_SOCKET,
3111 128,
3112 16,
3113 1
3114 },
3115 oob_server,
3116 {
3117 NULL,
3118 0,
3119 128
3120 },
3121 oob_client,
3122 {
3123 NULL,
3124 0,
3125 128
3126 }
3127 },
3128 /* Test 4: synchronous mixed client and server */
3129 {
3130 {
3131 STD_STREAM_SOCKET,
3132 2048,
3133 16,
3134 2
3135 },
3136 simple_server,
3137 {
3138 NULL,
3139 0,
3140 64
3141 },
3142 simple_mixed_client,
3143 {
3144 NULL,
3145 0,
3146 128
3147 }
3148 }
3149 };
3150
3151 struct send_udp_thread_param
3152 {
3153 int sock;
3154 HANDLE start_event;
3155 };
3156
3157 static DWORD WINAPI send_udp_thread( void *param )
3158 {
3159 struct send_udp_thread_param *p = param;
3160 static const TIMEVAL timeout_zero = {0};
3161 static char buf[256];
3162 fd_set writefds;
3163 unsigned int i;
3164 int ret;
3165
3166 WaitForSingleObject( p->start_event, INFINITE );
3167 for (i = 0; i < 256; ++i)
3168 {
3169 FD_ZERO(&writefds);
3170 FD_SET(p->sock, &writefds);
3171 ret = select( 1, NULL, &writefds, NULL, &timeout_zero );
3172 ok( ret == 1, "got %d, i %u.\n", ret, i );
3173 ret = send( p->sock, buf, sizeof(buf), 0 );
3174 ok( ret == sizeof(buf), "got %d, error %u, i %u.\n", ret, WSAGetLastError(), i );
3175 }
3176
3177 return 0;
3178 }
3179
3180 static void test_UDP(void)
3181 {
3182 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
3183 possible that this test fails due to dropped packets. */
3184
3185 /* peer 0 receives data from all other peers */
3186 static const TIMEVAL timeout_zero = {0};
3187 struct sock_info peer[NUM_UDP_PEERS];
3188 char buf[16], sockaddr_buf[1024];
3189 int ss, i, n_recv, n_sent, ret;
3190 struct sockaddr_in addr;
3191 int sock;
3192 struct send_udp_thread_param udp_thread_param;
3193 HANDLE thread;
3194 fd_set writefds;
3195
3196
3197 memset (buf,0,sizeof(buf));
3198 for ( i = NUM_UDP_PEERS - 1; i >= 0; i-- ) {
3199 ok ( ( peer[i].s = socket ( AF_INET, SOCK_DGRAM, 0 ) ) != INVALID_SOCKET, "UDP: socket failed\n" );
3200
3201 peer[i].addr.sin_family = AF_INET;
3202 peer[i].addr.sin_addr.s_addr = inet_addr ( SERVERIP );
3203
3204 if ( i == 0 ) {
3205 peer[i].addr.sin_port = htons ( SERVERPORT );
3206 } else {
3207 peer[i].addr.sin_port = htons ( 0 );
3208 }
3209
3210 do_bind ( peer[i].s, (struct sockaddr *) &peer[i].addr, sizeof( peer[i].addr ) );
3211
3212 /* test getsockname() to get peer's port */
3213 ss = sizeof ( peer[i].addr );
3214 ok ( getsockname ( peer[i].s, (struct sockaddr *) &peer[i].addr, &ss ) != SOCKET_ERROR, "UDP: could not getsockname()\n" );
3215 ok ( peer[i].addr.sin_port != htons ( 0 ), "UDP: bind() did not associate port\n" );
3216 }
3217
3218 /* Test that specifying a too small fromlen for recvfrom() shouldn't write unnecessary data */
3219 n_sent = sendto ( peer[1].s, buf, sizeof(buf), 0, (struct sockaddr *)&peer[0].addr, sizeof(peer[0].addr) );
3220 ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
3221
3222 sockaddr_buf[0] = 'A';
3223 ss = 1;
3224 n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0, (struct sockaddr *)sockaddr_buf, &ss );
3225 todo_wine
3226 ok ( n_recv == SOCKET_ERROR, "UDP: recvfrom() succeeded\n" );
3227 ok ( sockaddr_buf[0] == 'A', "UDP: marker got overwritten\n" );
3228 if ( n_recv == SOCKET_ERROR )
3229 {
3230 ss = sizeof ( peer[0].addr );
3231 n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0, (struct sockaddr *)sockaddr_buf, &ss );
3232 ok ( n_recv == sizeof(buf), "UDP: recvfrom() failed\n" );
3233 }
3234
3235 /* Test that specifying a large fromlen for recvfrom() shouldn't write unnecessary data besides the socket address */
3236 n_sent = sendto ( peer[1].s, buf, sizeof(buf), 0, (struct sockaddr *)&peer[0].addr, sizeof(peer[0].addr) );
3237 ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
3238
3239 sockaddr_buf[1023] = 'B';
3240 ss = sizeof(sockaddr_buf);
3241 n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0, (struct sockaddr *)sockaddr_buf, &ss );
3242 ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
3243 ok ( sockaddr_buf[1023] == 'B', "UDP: marker got overwritten\n" );
3244
3245 /* test getsockname() */
3246 ok ( peer[0].addr.sin_port == htons ( SERVERPORT ), "UDP: getsockname returned incorrect peer port\n" );
3247
3248 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
3249 /* send client's port */
3250 memcpy( buf, &peer[i].addr.sin_port, sizeof(peer[i].addr.sin_port) );
3251 n_sent = sendto ( peer[i].s, buf, sizeof(buf), 0, (struct sockaddr*) &peer[0].addr, sizeof(peer[0].addr) );
3252 ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
3253 }
3254
3255 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
3256 n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0,(struct sockaddr *) &peer[0].peer, &ss );
3257 ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
3258 ok ( memcmp ( &peer[0].peer.sin_port, buf, sizeof(peer[0].addr.sin_port) ) == 0, "UDP: port numbers do not match\n" );
3259 }
3260
3261 sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP);
3262 ok( sock != INVALID_SOCKET, "got error %u.\n", WSAGetLastError() );
3263
3264 memset( &addr, 0, sizeof(addr) );
3265 addr.sin_family = AF_INET;
3266 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
3267 addr.sin_port = htons(255);
3268
3269 ret = connect( sock, (struct sockaddr *)&addr, sizeof(addr) );
3270 ok( !ret, "got error %u.\n", WSAGetLastError() );
3271
3272 /* Send to UDP socket succeeds even if the packets are not received and the network is replying with
3273 * "destination port unreachable" ICMP messages. */
3274 for (i = 0; i < 10; ++i)
3275 {
3276 ret = send( sock, buf, sizeof(buf), 0 );
3277 ok( ret == sizeof(buf), "got %d, error %u.\n", ret, WSAGetLastError() );
3278 }
3279
3280 /* Test sending packets in parallel (mostly a regression test for Wine async handling race conditions). */
3281 set_blocking( sock, FALSE );
3282
3283 udp_thread_param.sock = sock;
3284 udp_thread_param.start_event = CreateEventW( NULL, FALSE, FALSE, NULL );
3285 thread = CreateThread( NULL, 0, send_udp_thread, &udp_thread_param, 0, NULL );
3286 SetEvent( udp_thread_param.start_event );
3287 for (i = 0; i < 256; ++i)
3288 {
3289 ret = send( sock, buf, sizeof(buf), 0 );
3290 ok( ret == sizeof(buf), "got %d, error %u, i %u.\n", ret, WSAGetLastError(), i );
3291 FD_ZERO(&writefds);
3292 FD_SET(sock, &writefds);
3293 ret = select( 1, NULL, &writefds, NULL, &timeout_zero );
3294 ok( ret == 1, "got %d, i %u.\n", ret, i );
3295 }
3296 WaitForSingleObject( thread, INFINITE );
3297 CloseHandle( thread );
3298 CloseHandle( udp_thread_param.start_event );
3299
3300 closesocket(sock);
3301 }
3302
3303 static void test_WSASocket(void)
3304 {
3305 SOCKET sock = INVALID_SOCKET;
3306 WSAPROTOCOL_INFOA *pi;
3307 int wsaproviders[] = {IPPROTO_TCP, IPPROTO_IP};
3308 int autoprotocols[] = {IPPROTO_TCP, IPPROTO_UDP};
3309 int items, err, size, socktype, i, j;
3310 DWORD pi_size;
3311
3312 static const struct
3313 {
3314 int family, type, protocol;
3315 DWORD error;
3316 int ret_family, ret_type, ret_protocol;
3317 int ret_family_alt;
3318 }
3319 tests[] =
3320 {
3321 /* 0 */
3322 {0xdead, SOCK_STREAM, IPPROTO_TCP, WSAEAFNOSUPPORT},
3323 {-1, SOCK_STREAM, IPPROTO_TCP, WSAEAFNOSUPPORT},
3324 {AF_INET, 0xdead, IPPROTO_TCP, WSAESOCKTNOSUPPORT},
3325 {AF_INET, -1, IPPROTO_TCP, WSAESOCKTNOSUPPORT},
3326 {AF_INET, SOCK_STREAM, 0xdead, WSAEPROTONOSUPPORT},
3327 {AF_INET, SOCK_STREAM, -1, WSAEPROTONOSUPPORT},
3328 {0xdead, 0xdead, IPPROTO_TCP, WSAESOCKTNOSUPPORT},
3329 {0xdead, SOCK_STREAM, 0xdead, WSAEAFNOSUPPORT},
3330 {AF_INET, 0xdead, 0xdead, WSAESOCKTNOSUPPORT},
3331 {0xdead, SOCK_STREAM, IPPROTO_UDP, WSAEAFNOSUPPORT},
3332
3333 /* 10 */
3334 {AF_INET, SOCK_STREAM, 0, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP},
3335 {AF_INET, SOCK_DGRAM, 0, 0, AF_INET, SOCK_DGRAM, IPPROTO_UDP},
3336 {AF_INET, 0xdead, 0, WSAESOCKTNOSUPPORT},
3337 {AF_INET, 0, IPPROTO_TCP, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP},
3338 {AF_INET, 0, IPPROTO_UDP, 0, AF_INET, SOCK_DGRAM, IPPROTO_UDP},
3339 {AF_INET, 0, 0xdead, WSAEPROTONOSUPPORT},
3340 {AF_INET, 0, 0, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP},
3341 {AF_INET, SOCK_STREAM, IPPROTO_UDP, WSAEPROTONOSUPPORT},
3342 {AF_INET, SOCK_DGRAM, IPPROTO_TCP, WSAEPROTONOSUPPORT},
3343
3344 /* 19 */
3345 {AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP, AF_INET6 /* win11 */},
3346 {AF_UNSPEC, SOCK_STREAM, 0xdead, WSAEPROTONOSUPPORT},
3347 {AF_UNSPEC, 0xdead, IPPROTO_UDP, WSAESOCKTNOSUPPORT},
3348 {AF_UNSPEC, SOCK_STREAM, 0, WSAEINVAL},
3349 {AF_UNSPEC, SOCK_DGRAM, 0, WSAEINVAL},
3350 {AF_UNSPEC, 0xdead, 0, WSAEINVAL},
3351 {AF_UNSPEC, 0, IPPROTO_TCP, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP, AF_INET6 /* win11 */},
3352 {AF_UNSPEC, 0, IPPROTO_UDP, 0, AF_INET, SOCK_DGRAM, IPPROTO_UDP, AF_INET6 /* win11 */},
3353 {AF_UNSPEC, 0, 0xdead, WSAEPROTONOSUPPORT},
3354 {AF_UNSPEC, 0, 0, WSAEINVAL},
3355 };
3356
3357 for (i = 0; i < ARRAY_SIZE(tests); ++i)
3358 {
3359 SetLastError( 0xdeadbeef );
3360 sock = WSASocketA( tests[i].family, tests[i].type, tests[i].protocol, NULL, 0, 0 );
3361 todo_wine_if (i == 7)
3362 ok(WSAGetLastError() == tests[i].error, "Test %u: got wrong error %u\n", i, WSAGetLastError());
3363 if (tests[i].error)
3364 {
3365 ok(sock == INVALID_SOCKET, "Test %u: expected failure\n", i);
3366 }
3367 else
3368 {
3369 WSAPROTOCOL_INFOA info;
3370
3371 ok(sock != INVALID_SOCKET, "Text %u: expected success\n", i);
3372
3373 size = sizeof(info);
3374 err = getsockopt( sock, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *)&info, &size );
3375 ok(!err, "Test %u: getsockopt failed, error %u\n", i, WSAGetLastError());
3376 ok(info.iAddressFamily == tests[i].ret_family ||
3377 (tests[i].ret_family_alt && info.iAddressFamily == tests[i].ret_family_alt),
3378 "Test %u: got wrong family %d\n", i, info.iAddressFamily);
3379 ok(info.iSocketType == tests[i].ret_type, "Test %u: got wrong type %d\n", i, info.iSocketType);
3380 ok(info.iProtocol == tests[i].ret_protocol, "Test %u: got wrong protocol %d\n", i, info.iProtocol);
3381
3382 closesocket( sock );
3383 }
3384 }
3385
3386 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
3387 * to avoid a crash on win98.
3388 */
3389 pi_size = 0;
3390 items = WSAEnumProtocolsA(wsaproviders, NULL, &pi_size);
3391 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
3392 items);
3393 err = WSAGetLastError();
3394 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
3395 err, WSAENOBUFS);
3396
3397 pi = malloc(pi_size);
3398 ok(pi != NULL, "Failed to allocate memory\n");
3399
3400 items = WSAEnumProtocolsA(wsaproviders, pi, &pi_size);
3401 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
3402 WSAGetLastError());
3403
3404 if (items == 0) {
3405 skip("No protocols enumerated.\n");
3406 free(pi);
3407 return;
3408 }
3409
3410 sock = WSASocketA(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
3411 FROM_PROTOCOL_INFO, &pi[0], 0, 0);
3412 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3413 WSAGetLastError());
3414 closesocket(sock);
3415
3416 /* find what parameters are used first: plain parameters or protocol info struct */
3417 pi[0].iProtocol = -1;
3418 pi[0].iSocketType = -1;
3419 pi[0].iAddressFamily = -1;
3420 ok(WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0) == INVALID_SOCKET,
3421 "WSASocketA should have failed\n");
3422 err = WSAGetLastError();
3423 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
3424
3425 pi[0].iProtocol = 0;
3426 pi[0].iSocketType = 0;
3427 pi[0].iAddressFamily = 0;
3428 sock = WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0);
3429 if(sock != INVALID_SOCKET)
3430 {
3431 win_skip("must work only in OS <= 2003\n");
3432 closesocket(sock);
3433 }
3434 else
3435 {
3436 err = WSAGetLastError();
3437 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
3438 }
3439
3440 pi[0].iProtocol = IPPROTO_UDP;
3441 pi[0].iSocketType = SOCK_DGRAM;
3442 pi[0].iAddressFamily = AF_INET;
3443 sock = WSASocketA(0, 0, 0, &pi[0], 0, 0);
3444 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3445 WSAGetLastError());
3446
3447 size = sizeof(socktype);
3448 socktype = 0xdead;
3449 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3450 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
3451 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
3452 SOCK_DGRAM, socktype);
3453
3454 socktype = SOCK_STREAM;
3455 WSASetLastError(0xdeadbeef);
3456 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
3457 ok(err == -1, "expected failure\n");
3458 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
3459
3460 socktype = SOCK_DGRAM;
3461 WSASetLastError(0xdeadbeef);
3462 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
3463 ok(err == -1, "expected failure\n");
3464 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
3465
3466 closesocket(sock);
3467
3468 sock = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, &pi[0], 0, 0);
3469 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3470 WSAGetLastError());
3471
3472 size = sizeof(socktype);
3473 socktype = 0xdead;
3474 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3475 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
3476 ok(socktype == SOCK_STREAM, "Wrong socket type, expected %d received %d\n",
3477 SOCK_STREAM, socktype);
3478
3479 socktype = SOCK_STREAM;
3480 WSASetLastError(0xdeadbeef);
3481 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
3482 ok(err == -1, "expected failure\n");
3483 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
3484
3485 socktype = SOCK_DGRAM;
3486 WSASetLastError(0xdeadbeef);
3487 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
3488 ok(err == -1, "expected failure\n");
3489 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
3490
3491 closesocket(sock);
3492
3493 free(pi);
3494
3495 pi_size = 0;
3496 items = WSAEnumProtocolsA(NULL, NULL, &pi_size);
3497 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
3498 items);
3499 err = WSAGetLastError();
3500 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
3501 err, WSAENOBUFS);
3502
3503 pi = malloc(pi_size);
3504 ok(pi != NULL, "Failed to allocate memory\n");
3505
3506 items = WSAEnumProtocolsA(NULL, pi, &pi_size);
3507 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
3508 WSAGetLastError());
3509
3510 /* when no protocol and socket type are specified the first entry
3511 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
3512 * is returned */
3513 sock = WSASocketA(AF_INET, 0, 0, NULL, 0, 0);
3514 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3515 WSAGetLastError());
3516
3517 size = sizeof(socktype);
3518 socktype = 0xdead;
3519 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3520 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3521 for(i = 0; i < items; i++)
3522 {
3523 if(pi[i].dwProviderFlags & PFL_MATCHES_PROTOCOL_ZERO)
3524 {
3525 ok(socktype == pi[i].iSocketType, "Wrong socket type, expected %d received %d\n",
3526 pi[i].iSocketType, socktype);
3527 break;
3528 }
3529 }
3530 ok(i != items, "Creating a socket without protocol and socket type didn't work\n");
3531 closesocket(sock);
3532
3533 /* when no socket type is specified the first entry from WSAEnumProtocols
3534 * that matches the protocol is returned */
3535 for (i = 0; i < ARRAY_SIZE(autoprotocols); i++)
3536 {
3537 sock = WSASocketA(0, 0, autoprotocols[i], NULL, 0, 0);
3538 ok(sock != INVALID_SOCKET, "Failed to create socket for protocol %d, received %d\n",
3539 autoprotocols[i], WSAGetLastError());
3540
3541 size = sizeof(socktype);
3542 socktype = 0xdead;
3543 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3544 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3545
3546 for (err = 1, j = 0; j < items; j++)
3547 {
3548 if (pi[j].iProtocol == autoprotocols[i])
3549 {
3550 ok(pi[j].iSocketType == socktype, "expected %d, got %d\n", socktype, pi[j].iSocketType);
3551 err = 0;
3552 break;
3553 }
3554 }
3555 ok(!err, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols[i]);
3556
3557 closesocket(sock);
3558 }
3559
3560 free(pi);
3561
3562 SetLastError(0xdeadbeef);
3563 /* starting on vista the socket function returns error during the socket
3564 creation and no longer in the socket operations (sendto, readfrom) */
3565 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
3566 if (sock == INVALID_SOCKET)
3567 {
3568 err = WSAGetLastError();
3569 ok(err == WSAEACCES, "Expected 10013, received %d\n", err);
3570 skip("SOCK_RAW is not supported\n");
3571 }
3572 else
3573 {
3574 WSAPROTOCOL_INFOW info;
3575
3576 size = sizeof(socktype);
3577 socktype = 0xdead;
3578 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3579 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3580 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
3581 SOCK_RAW, socktype);
3582
3583 size = sizeof(info);
3584 err = getsockopt(sock, SOL_SOCKET, SO_PROTOCOL_INFOW, (char *) &info, &size);
3585 ok(!err,"got error %d\n", WSAGetLastError());
3586 /* Protocol name in info.szProtocol is not entirely consistent across Windows versions and
3587 * locales, so not testing it. */
3588 ok(info.iAddressFamily == AF_INET, "got iAddressFamily %d.\n", info.iAddressFamily);
3589 ok(info.iSocketType == SOCK_RAW, "got iSocketType %d.\n", info.iSocketType);
3590 ok(info.iMaxSockAddr == 0x10, "got iMaxSockAddr %d.\n", info.iMaxSockAddr);
3591 ok(info.iMinSockAddr == 0x10, "got iMinSockAddr %d.\n", info.iMinSockAddr);
3592 todo_wine ok(!info.iProtocol, "got iProtocol %d.\n", info.iProtocol);
3593 ok(info.iProtocolMaxOffset == 255, "got iProtocol %d.\n", info.iProtocolMaxOffset);
3594 ok(info.dwProviderFlags == (PFL_MATCHES_PROTOCOL_ZERO | PFL_HIDDEN), "got dwProviderFlags %#lx.\n",
3595 info.dwProviderFlags);
3596 ok(info.dwServiceFlags1 == (XP1_IFS_HANDLES | XP1_SUPPORT_BROADCAST | XP1_SUPPORT_MULTIPOINT
3597 | XP1_MESSAGE_ORIENTED | XP1_CONNECTIONLESS), "got dwServiceFlags1 %#lx.\n",
3598 info.dwServiceFlags1);
3599
3600 closesocket(sock);
3601
3602 sock = WSASocketA(0, 0, IPPROTO_RAW, NULL, 0, 0);
3603 if (sock != INVALID_SOCKET)
3604 {
3605 size = sizeof(socktype);
3606 socktype = 0xdead;
3607 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3608 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3609 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
3610 SOCK_RAW, socktype);
3611 closesocket(sock);
3612
3613 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_TCP, NULL, 0, 0);
3614 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3615 WSAGetLastError());
3616 size = sizeof(socktype);
3617 socktype = 0xdead;
3618 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3619 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3620 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
3621 SOCK_RAW, socktype);
3622 closesocket(sock);
3623 }
3624 else if (WSAGetLastError() == WSAEACCES)
3625 skip("SOCK_RAW is not available\n");
3626 else
3627 ok(0, "Failed to create socket: %d\n", WSAGetLastError());
3628
3629 }
3630
3631 /* IPX socket tests */
3632
3633 SetLastError(0xdeadbeef);
3634 sock = WSASocketA(AF_IPX, SOCK_DGRAM, NSPROTO_IPX, NULL, 0, 0);
3635 if (sock == INVALID_SOCKET)
3636 {
3637 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError());
3638 skip("IPX is not supported\n");
3639 }
3640 else
3641 {
3642 WSAPROTOCOL_INFOA info;
3643 closesocket(sock);
3644
3645 sock = WSASocketA(0, 0, NSPROTO_IPX, NULL, 0, 0);
3646 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3647 WSAGetLastError());
3648
3649 size = sizeof(socktype);
3650 socktype = 0xdead;
3651 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3652 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
3653 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
3654 SOCK_DGRAM, socktype);
3655
3656 /* check socket family, type and protocol */
3657 size = sizeof(WSAPROTOCOL_INFOA);
3658 err = getsockopt(sock, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &info, &size);
3659 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
3660 ok(info.iProtocol == NSPROTO_IPX, "expected protocol %d, received %d\n",
3661 NSPROTO_IPX, info.iProtocol);
3662 ok(info.iAddressFamily == AF_IPX, "expected family %d, received %d\n",
3663 AF_IPX, info.iProtocol);
3664 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
3665 SOCK_DGRAM, info.iSocketType);
3666 closesocket(sock);
3667
3668 /* SOCK_STREAM does not support NSPROTO_IPX */
3669 SetLastError(0xdeadbeef);
3670 ok(WSASocketA(AF_IPX, SOCK_STREAM, NSPROTO_IPX, NULL, 0, 0) == INVALID_SOCKET,
3671 "WSASocketA should have failed\n");
3672 err = WSAGetLastError();
3673 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
3674
3675 /* test extended IPX support - that is adding any number between 0 and 255
3676 * to the IPX protocol value will make it be used as IPX packet type */
3677 for(i = 0;i <= 255;i += 17)
3678 {
3679 SetLastError(0xdeadbeef);
3680 sock = WSASocketA(0, 0, NSPROTO_IPX + i, NULL, 0, 0);
3681 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3682 WSAGetLastError());
3683
3684 size = sizeof(int);
3685 socktype = -1;
3686 err = getsockopt(sock, NSPROTO_IPX, IPX_PTYPE, (char *) &socktype, &size);
3687 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3688 ok(socktype == i, "Wrong IPX packet type, expected %d received %d\n",
3689 i, socktype);
3690
3691 closesocket(sock);
3692 }
3693 }
3694 }
3695
3696 static void test_WSADuplicateSocket(void)
3697 {
3698 SOCKET source, dupsock;
3699 WSAPROTOCOL_INFOA info;
3700 DWORD err;
3701 struct sockaddr_in addr;
3702 int socktype, size, addrsize, ret;
3703 char teststr[] = "TEST", buffer[16];
3704
3705 source = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
3706 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3707
3708 /* test invalid parameters */
3709 SetLastError(0xdeadbeef);
3710 ok(WSADuplicateSocketA(0, 0, NULL), "WSADuplicateSocketA should have failed\n");
3711 err = WSAGetLastError();
3712 ok(err == WSAENOTSOCK, "expected 10038, received %ld\n", err);
3713
3714 SetLastError(0xdeadbeef);
3715 ok(WSADuplicateSocketA(source, 0, NULL),
3716 "WSADuplicateSocketA should have failed\n");
3717 err = WSAGetLastError();
3718 ok(err == WSAEINVAL, "expected 10022, received %ld\n", err);
3719
3720 SetLastError(0xdeadbeef);
3721 ok(WSADuplicateSocketA(source, ~0, &info),
3722 "WSADuplicateSocketA should have failed\n");
3723 err = WSAGetLastError();
3724 ok(err == WSAEINVAL, "expected 10022, received %ld\n", err);
3725
3726 SetLastError(0xdeadbeef);
3727 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info),
3728 "WSADuplicateSocketA should have failed\n");
3729 err = WSAGetLastError();
3730 ok(err == WSAENOTSOCK, "expected 10038, received %ld\n", err);
3731
3732 SetLastError(0xdeadbeef);
3733 ok(WSADuplicateSocketA(source, GetCurrentProcessId(), NULL),
3734 "WSADuplicateSocketA should have failed\n");
3735 err = WSAGetLastError();
3736 ok(err == WSAEFAULT, "expected 10014, received %ld\n", err);
3737
3738 /* test returned structure */
3739 memset(&info, 0, sizeof(info));
3740 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
3741 "WSADuplicateSocketA should have worked\n");
3742
3743 ok(info.iProtocol == IPPROTO_TCP, "expected protocol %d, received %d\n",
3744 IPPROTO_TCP, info.iProtocol);
3745 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
3746 AF_INET, info.iProtocol);
3747 ok(info.iSocketType == SOCK_STREAM, "expected type %d, received %d\n",
3748 SOCK_STREAM, info.iSocketType);
3749
3750 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
3751 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3752
3753 closesocket(dupsock);
3754 closesocket(source);
3755
3756 /* create a socket, bind it, duplicate it then send data on source and
3757 * receive in the duplicated socket */
3758 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
3759 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3760
3761 memset(&info, 0, sizeof(info));
3762 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
3763 "WSADuplicateSocketA should have worked\n");
3764
3765 ok(info.iProtocol == IPPROTO_UDP, "expected protocol %d, received %d\n",
3766 IPPROTO_UDP, info.iProtocol);
3767 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
3768 AF_INET, info.iProtocol);
3769 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
3770 SOCK_DGRAM, info.iSocketType);
3771
3772 memset(&addr, 0, sizeof(addr));
3773 addr.sin_family = AF_INET;
3774 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
3775 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
3776 "bind should have worked\n");
3777
3778 /* read address to find out the port number to be used in sendto */
3779 memset(&addr, 0, sizeof(addr));
3780 addrsize = sizeof(addr);
3781 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
3782 "getsockname should have worked\n");
3783 ok(addr.sin_port, "socket port should be != 0\n");
3784
3785 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
3786 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3787
3788 size = sizeof(int);
3789 ret = getsockopt(dupsock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3790 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
3791 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
3792 SOCK_DGRAM, socktype);
3793
3794 set_blocking(source, TRUE);
3795
3796 /* send data on source socket */
3797 addrsize = sizeof(addr);
3798 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
3799 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
3800
3801 /* receive on duplicated socket */
3802 addrsize = sizeof(addr);
3803 memset(buffer, 0, sizeof(buffer));
3804 size = recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize);
3805 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
3806 buffer[sizeof(teststr) - 1] = 0;
3807 ok(!strcmp(buffer, teststr), "expected '%s', received '%s'\n", teststr, buffer);
3808
3809 closesocket(dupsock);
3810 closesocket(source);
3811
3812 /* show that the source socket need to be bound before the duplicated
3813 * socket is created */
3814 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
3815 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3816
3817 memset(&info, 0, sizeof(info));
3818 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
3819 "WSADuplicateSocketA should have worked\n");
3820
3821 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
3822 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3823
3824 memset(&addr, 0, sizeof(addr));
3825 addr.sin_family = AF_INET;
3826 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
3827 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
3828 "bind should have worked\n");
3829
3830 /* read address to find out the port number to be used in sendto */
3831 memset(&addr, 0, sizeof(addr));
3832 addrsize = sizeof(addr);
3833 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
3834 "getsockname should have worked\n");
3835 ok(addr.sin_port, "socket port should be != 0\n");
3836
3837 set_blocking(source, TRUE);
3838
3839 addrsize = sizeof(addr);
3840 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
3841 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
3842
3843 SetLastError(0xdeadbeef);
3844 addrsize = sizeof(addr);
3845 memset(buffer, 0, sizeof(buffer));
3846 todo_wine {
3847 ok(recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize) == -1,
3848 "recvfrom should have failed\n");
3849 err = WSAGetLastError();
3850 ok(err == WSAEINVAL, "expected 10022, received %ld\n", err);
3851 }
3852
3853 closesocket(dupsock);
3854 closesocket(source);
3855 }
3856
3857 static void test_WSAConnectByName(void)
3858 {
3859 SOCKET s;
3860 SOCKADDR_IN local_addr = {0}, remote_addr = {0},
3861 sock_addr = {0}, peer_addr = {0};
3862 DWORD local_len, remote_len, conn_ctx;
3863 int ret, err, sock_len, peer_len;
3864 WSAOVERLAPPED overlap;
3865 struct addrinfo *first_addrinfo, first_hints;
3866
3867 conn_ctx = TRUE;
3868
3869 /* First call of getaddrinfo fails on w8adm */
3870 first_addrinfo = NULL;
3871 memset(&first_hints, 0, sizeof(struct addrinfo));
3872 first_hints.ai_socktype = SOCK_STREAM;
3873 first_hints.ai_family = AF_INET;
3874 first_hints.ai_protocol = IPPROTO_TCP;
3875 getaddrinfo("winehq.org", "http", &first_hints, &first_addrinfo);
3876 if (first_addrinfo)
3877 freeaddrinfo(first_addrinfo);
3878 SetLastError(0xdeadbeef);
3879
3880 /* Fill all fields */
3881 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3882 local_len = remote_len = sizeof(SOCKADDR_IN);
3883 ret = WSAConnectByNameA(s, "winehq.org", "http", &local_len, (struct sockaddr *)&local_addr,
3884 &remote_len, (struct sockaddr *)&remote_addr, NULL, NULL);
3885 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3886 setsockopt(s, SOL_SOCKET, SO_UPDATE_CONNECT_CONTEXT, (char *)&conn_ctx, sizeof(DWORD));
3887 sock_len = peer_len = sizeof(SOCKADDR_IN);
3888 ret = getsockname(s, (struct sockaddr *)&sock_addr, &sock_len);
3889 ok(!ret, "getsockname should have succeeded, error %u\n", WSAGetLastError());
3890 ret = getpeername(s, (struct sockaddr *)&peer_addr, &peer_len);
3891 ok(!ret, "getpeername should have succeeded, error %u\n", WSAGetLastError());
3892 ok(sock_len == sizeof(SOCKADDR_IN), "got sockname size of %d\n", sock_len);
3893 ok(peer_len == sizeof(SOCKADDR_IN), "got peername size of %d\n", peer_len);
3894 ok(local_len == sizeof(SOCKADDR_IN), "got local size of %lu\n", local_len);
3895 ok(remote_len == sizeof(SOCKADDR_IN), "got remote size of %lu\n", remote_len);
3896 ok(!local_addr.sin_port, "local_addr has non-zero sin_port: %hu.\n", local_addr.sin_port);
3897 ok(!memcmp(&sock_addr.sin_addr, &local_addr.sin_addr, sizeof(struct in_addr)),
3898 "local_addr did not receive data.\n");
3899 ok(!memcmp(&peer_addr, &remote_addr, sizeof(SOCKADDR_IN)), "remote_addr did not receive data.\n");
3900 closesocket(s);
3901
3902 /* Passing NULL length but a pointer to a sockaddr */
3903 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3904 local_len = remote_len = sizeof(SOCKADDR_IN);
3905 memset(&local_addr, 0, sizeof(SOCKADDR_IN));
3906 memset(&remote_addr, 0, sizeof(SOCKADDR_IN));
3907 memset(&sock_addr, 0, sizeof(SOCKADDR_IN));
3908 memset(&peer_addr, 0, sizeof(SOCKADDR_IN));
3909 ret = WSAConnectByNameA(s, "winehq.org", "http", NULL, (struct sockaddr *)&local_addr,
3910 NULL, (struct sockaddr *)&remote_addr, NULL, NULL);
3911 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3912 setsockopt(s, SOL_SOCKET, SO_UPDATE_CONNECT_CONTEXT, (char *)&conn_ctx, sizeof(DWORD));
3913 sock_len = peer_len = sizeof(SOCKADDR_IN);
3914 ret = getsockname(s, (struct sockaddr *)&sock_addr, &sock_len);
3915 ok(!ret, "getsockname should have succeeded, error %u\n", WSAGetLastError());
3916 ret = getpeername(s, (struct sockaddr *)&peer_addr, &peer_len);
3917 ok(!ret, "getpeername should have succeeded, error %u\n", WSAGetLastError());
3918 ok(sock_len == sizeof(SOCKADDR_IN), "got sockname size of %d\n", sock_len);
3919 ok(peer_len == sizeof(SOCKADDR_IN), "got peername size of %d\n", peer_len);
3920 ok(!local_addr.sin_family, "local_addr received data.\n");
3921 ok(!remote_addr.sin_family, "remote_addr received data.\n");
3922 closesocket(s);
3923
3924 /* Passing NULLs for node or service */
3925 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3926 ret = WSAConnectByNameA(s, NULL, "http", NULL, NULL, NULL, NULL, NULL, NULL);
3927 err = WSAGetLastError();
3928 ok(!ret, "WSAConnectByNameA should have failed\n");
3929 ok(err == WSAEINVAL, "expected error %u (WSAEINVAL), got %u\n", WSAEINVAL, err);
3930 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3931 closesocket(s);
3932 ret = WSAConnectByNameA(s, "winehq.org", NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3933 err = WSAGetLastError();
3934 ok(!ret, "WSAConnectByNameA should have failed\n");
3935 ok(err == WSAEINVAL, "expected error %u (WSAEINVAL), got %u\n", WSAEINVAL, err);
3936 closesocket(s);
3937
3938 /* Passing NULL for the addresses and address lengths */
3939 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3940 ret = WSAConnectByNameA(s, "winehq.org", "http", NULL, NULL, NULL, NULL, NULL, NULL);
3941 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3942 closesocket(s);
3943
3944 /* Passing NULL for the addresses and passing correct lengths */
3945 local_len = remote_len = sizeof(SOCKADDR_IN);
3946 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3947 ret = WSAConnectByNameA(s, "winehq.org", "http", &local_len, NULL,
3948 &remote_len, NULL, NULL, NULL);
3949 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3950 ok(local_len == sizeof(SOCKADDR_IN), "local_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN),
3951 local_len);
3952 ok(remote_len == sizeof(SOCKADDR_IN), "remote_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN),
3953 remote_len);
3954 closesocket(s);
3955
3956 /* Passing addresses and passing short lengths */
3957 local_len = remote_len = 3;
3958 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3959 ret = WSAConnectByNameA(s, "winehq.org", "http", &local_len, (struct sockaddr *)&local_addr,
3960 &remote_len, (struct sockaddr *)&remote_addr, NULL, NULL);
3961 err = WSAGetLastError();
3962 ok(!ret, "WSAConnectByNameA should have failed\n");
3963 ok(err == WSAEFAULT, "expected error %u (WSAEFAULT), got %u\n", WSAEFAULT, err);
3964 ok(local_len == 3, "local_len should have been 3, got %ld\n", local_len);
3965 ok(remote_len == 3, "remote_len should have been 3, got %ld\n", remote_len);
3966 closesocket(s);
3967
3968 /* Passing addresses and passing long lengths */
3969 local_len = remote_len = 50;
3970 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3971 ret = WSAConnectByNameA(s, "winehq.org", "http", &local_len, (struct sockaddr *)&local_addr,
3972 &remote_len, (struct sockaddr *)&remote_addr, NULL, NULL);
3973 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3974 ok(local_len == sizeof(SOCKADDR_IN), "local_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN),
3975 local_len);
3976 ok(remote_len == sizeof(SOCKADDR_IN), "remote_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN),
3977 remote_len);
3978 closesocket(s);
3979
3980 /* Unknown service */
3981 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3982 ret = WSAConnectByNameA(s, "winehq.org", "nonexistentservice", NULL, NULL, NULL, NULL, NULL, NULL);
3983 err = WSAGetLastError();
3984 ok(!ret, "WSAConnectByNameA should have failed\n");
3985 ok(err == WSATYPE_NOT_FOUND, "expected error %u (WSATYPE_NOT_FOUND), got %u\n",
3986 WSATYPE_NOT_FOUND, err);
3987 closesocket(s);
3988
3989 /* Connecting with a UDP socket */
3990 s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
3991 ret = WSAConnectByNameA(s, "winehq.org", "https", NULL, NULL, NULL, NULL, NULL, NULL);
3992 err = WSAGetLastError();
3993 ok(!ret, "WSAConnectByNameA should have failed\n");
3994 ok(err == WSAEINVAL || err == WSAEFAULT, "expected error %u (WSAEINVAL) or %u (WSAEFAULT), got %u\n",
3995 WSAEINVAL, WSAEFAULT, err); /* WSAEFAULT win10 >= 1809 */
3996 closesocket(s);
3997
3998 /* Passing non-null as the reserved parameter */
3999 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4000 ret = WSAConnectByNameA(s, "winehq.org", "http", NULL, NULL, NULL, NULL, NULL, &overlap);
4001 err = WSAGetLastError();
4002 ok(!ret, "WSAConnectByNameA should have failed\n");
4003 ok(err == WSAEINVAL, "expected error %u (WSAEINVAL), got %u\n", WSAEINVAL, err);
4004 closesocket(s);
4005 }
4006
4007 static void test_WSAEnumNetworkEvents(void)
4008 {
4009 SOCKET s, s2;
4010 int sock_type[] = {SOCK_STREAM, SOCK_DGRAM, SOCK_STREAM}, i, j, k, l;
4011 struct sockaddr_in address;
4012 HANDLE event;
4013 WSANETWORKEVENTS net_events;
4014
4015 memset(&address, 0, sizeof(address));
4016 address.sin_addr.s_addr = htonl(INADDR_ANY);
4017 address.sin_family = AF_INET;
4018
4019 /* This test follows the steps from bugs 10204 and 24946 */
4020 for (l = 0; l < 2; l++)
4021 {
4022 for (i = 0; i < ARRAY_SIZE(sock_type); i++)
4023 {
4024 if (i == 2)
4025 tcp_socketpair(&s, &s2);
4026 else
4027 {
4028 s = socket(AF_INET, sock_type[i], 0);
4029 ok (s != SOCKET_ERROR, "Test[%d]: failed to create socket\n", i);
4030 ok (!bind(s, (struct sockaddr*) &address, sizeof(address)), "Test[%d]: bind failed\n", i);
4031 }
4032 event = WSACreateEvent();
4033 ok (event != NULL, "Test[%d]: failed to create event\n", i);
4034 for (j = 0; j < 5; j++) /* Repeat sometimes and the result must be the same */
4035 {
4036 /* When the TCP socket is not connected NO events will be returned.
4037 * When connected and no data pending it will get the write event.
4038 * UDP sockets don't have connections so as soon as they are bound
4039 * they can read/write data. Since nobody is sendind us data only
4040 * the write event will be returned and ONLY once.
4041 */
4042 ok (!WSAEventSelect(s, event, FD_READ | FD_WRITE), "Test[%d]: WSAEventSelect failed\n", i);
4043 memset(&net_events, 0xAB, sizeof(net_events));
4044 ok (!WSAEnumNetworkEvents(s, l == 0 ? event : NULL, &net_events),
4045 "Test[%d]: WSAEnumNetworkEvents failed\n", i);
4046 if (i >= 1 && j == 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
4047 {
4048 ok (net_events.lNetworkEvents == FD_WRITE, "Test[%d]: expected 2, got %ld\n",
4049 i, net_events.lNetworkEvents);
4050 }
4051 else
4052 {
4053 ok (net_events.lNetworkEvents == 0, "Test[%d]: expected 0, got %ld\n",
4054 i, net_events.lNetworkEvents);
4055 }
4056 for (k = 0; k < FD_MAX_EVENTS; k++)
4057 {
4058 if (net_events.lNetworkEvents & (1 << k))
4059 {
4060 ok (net_events.iErrorCode[k] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
4061 i, k, net_events.iErrorCode[k]);
4062 }
4063 else
4064 {
4065 /* Bits that are not set in lNetworkEvents MUST not be changed */
4066 ok (net_events.iErrorCode[k] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
4067 i, k, net_events.iErrorCode[k]);
4068 }
4069 }
4070 }
4071 closesocket(s);
4072 WSACloseEvent(event);
4073 if (i == 2) closesocket(s2);
4074 }
4075 }
4076 }
4077
4078 static DWORD WINAPI SelectReadThread(void *param)
4079 {
4080 select_thread_params *par = param;
4081 fd_set readfds;
4082 int ret;
4083 struct sockaddr_in addr;
4084 struct timeval select_timeout;
4085
4086 FD_ZERO(&readfds);
4087 FD_SET(par->s, &readfds);
4088 select_timeout.tv_sec=5;
4089 select_timeout.tv_usec=0;
4090 addr.sin_family = AF_INET;
4091 addr.sin_addr.s_addr = inet_addr(SERVERIP);
4092 addr.sin_port = htons(SERVERPORT);
4093
4094 do_bind(par->s, (struct sockaddr *)&addr, sizeof(addr));
4095 wsa_ok(listen(par->s, SOMAXCONN ), 0 ==, "SelectReadThread (%lx): listen failed: %d\n");
4096
4097 SetEvent(server_ready);
4098 ret = select(par->s+1, &readfds, NULL, NULL, &select_timeout);
4099 par->ReadKilled = (ret == 1);
4100
4101 return 0;
4102 }
4103
4104 static DWORD WINAPI SelectCloseThread(void *param)
4105 {
4106 SOCKET s = *(SOCKET*)param;
4107 Sleep(500);
4108 closesocket(s);
4109 return 0;
4110 }
4111
4112 static void test_errors(void)
4113 {
4114 SOCKET sock;
4115 SOCKADDR_IN SockAddr;
4116 int ret, err;
4117
4118 WSASetLastError(NO_ERROR);
4119 sock = socket(PF_INET, SOCK_STREAM, 0);
4120 ok( (sock != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4121 memset(&SockAddr, 0, sizeof(SockAddr));
4122 SockAddr.sin_family = AF_INET;
4123 SockAddr.sin_port = htons(6924);
4124 SockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
4125
4126 ret = connect(sock, (PSOCKADDR)&SockAddr, sizeof(SockAddr));
4127 ok( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got: %d\n", ret );
4128 if (ret == SOCKET_ERROR)
4129 {
4130 err = WSAGetLastError();
4131 ok( (err == WSAECONNREFUSED), "expected WSAECONNREFUSED, got: %d\n", err );
4132 }
4133
4134 {
4135 TIMEVAL timeval;
4136 fd_set set = {1, {sock}};
4137
4138 timeval.tv_sec = 0;
4139 timeval.tv_usec = 50000;
4140
4141 ret = select(1, NULL, &set, NULL, &timeval);
4142 ok( (ret == 0), "expected 0 (timeout), got: %d\n", ret );
4143 }
4144
4145 ret = closesocket(sock);
4146 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
4147 }
4148
4149 static void test_listen(void)
4150 {
4151 SOCKET fdA, fdB;
4152 int ret, acceptc, olen = sizeof(acceptc);
4153 struct sockaddr_in address;
4154
4155 memset(&address, 0, sizeof(address));
4156 address.sin_addr.s_addr = inet_addr("127.0.0.1");
4157 address.sin_family = AF_INET;
4158 address.sin_port = htons(SERVERPORT);
4159
4160 /* invalid socket tests */
4161 SetLastError(0xdeadbeef);
4162 ok ((listen(0, 0) == SOCKET_ERROR), "listen did not fail\n");
4163 ret = WSAGetLastError();
4164 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
4165
4166 SetLastError(0xdeadbeef);
4167 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR), "listen did not fail\n");
4168 ret = WSAGetLastError();
4169 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
4170
4171 /* udp test */
4172 SetLastError(0xdeadbeef);
4173 fdA = socket(AF_INET, SOCK_DGRAM, 0);
4174 ok ((fdA != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4175
4176 ok ((listen(fdA, 1) == SOCKET_ERROR), "listen did not fail\n");
4177 ret = WSAGetLastError();
4178 ok (ret == WSAEOPNOTSUPP, "expected 10045, received %d\n", ret);
4179
4180 ret = closesocket(fdA);
4181 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
4182
4183 /* tcp tests */
4184 fdA = socket(AF_INET, SOCK_STREAM, 0);
4185 ok ((fdA != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4186
4187 fdB = socket(AF_INET, SOCK_STREAM, 0);
4188 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4189
4190 SetLastError(0xdeadbeef);
4191 ok ((listen(fdA, -2) == SOCKET_ERROR), "listen did not fail\n");
4192 ret = WSAGetLastError();
4193 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
4194
4195 SetLastError(0xdeadbeef);
4196 ok ((listen(fdA, 1) == SOCKET_ERROR), "listen did not fail\n");
4197 ret = WSAGetLastError();
4198 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
4199
4200 SetLastError(0xdeadbeef);
4201 ok ((listen(fdA, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
4202 ret = WSAGetLastError();
4203 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
4204
4205 ok (!bind(fdA, (struct sockaddr*) &address, sizeof(address)), "bind failed\n");
4206
4207 SetLastError(0xdeadbeef);
4208 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
4209 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
4210
4211 acceptc = 0xdead;
4212 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
4213 ok (!ret, "getsockopt failed\n");
4214 ok (acceptc == 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc);
4215
4216 acceptc = 1;
4217 WSASetLastError(0xdeadbeef);
4218 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
4219 ok(ret == -1, "expected failure\n");
4220 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
4221
4222 acceptc = 0;
4223 WSASetLastError(0xdeadbeef);
4224 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
4225 ok(ret == -1, "expected failure\n");
4226 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
4227
4228 ok (!listen(fdA, 0), "listen failed\n");
4229 ok (!listen(fdA, SOMAXCONN), "double listen failed\n");
4230
4231 acceptc = 0xdead;
4232 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
4233 ok (!ret, "getsockopt failed\n");
4234 ok (acceptc == 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc);
4235
4236 acceptc = 1;
4237 WSASetLastError(0xdeadbeef);
4238 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
4239 ok(ret == -1, "expected failure\n");
4240 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
4241
4242 acceptc = 0;
4243 WSASetLastError(0xdeadbeef);
4244 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
4245 ok(ret == -1, "expected failure\n");
4246 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
4247
4248 SetLastError(0xdeadbeef);
4249 ok ((listen(fdB, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
4250 ret = WSAGetLastError();
4251 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
4252
4253 ret = closesocket(fdB);
4254 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
4255
4256 fdB = socket(AF_INET, SOCK_STREAM, 0);
4257 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4258
4259 SetLastError(0xdeadbeef);
4260 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
4261 ret = WSAGetLastError();
4262 ok (ret == WSAEADDRINUSE, "expected 10048, received %d\n", ret);
4263
4264 ret = closesocket(fdA);
4265 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
4266 ret = closesocket(fdB);
4267 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
4268 }
4269
4270 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
4271 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
4272 static void test_select(void)
4273 {
4274 static char tmp_buf[1024];
4275
4276 fd_set readfds, writefds, exceptfds, *alloc_fds;
4277 SOCKET fdListen, fdRead, fdWrite, sockets[200];
4278 int ret, len;
4279 char buffer;
4280 struct timeval select_timeout;
4281 struct sockaddr_in address;
4282 select_thread_params thread_params;
4283 HANDLE thread_handle;
4284 DWORD ticks, id, old_protect;
4285 unsigned int apc_count;
4286 unsigned int maxfd, i;
4287 char *page_pair;
4288
4289 fdRead = socket(AF_INET, SOCK_STREAM, 0);
4290 ok( (fdRead != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4291 fdWrite = socket(AF_INET, SOCK_STREAM, 0);
4292 ok( (fdWrite != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
4293
4294 maxfd = fdRead;
4295 if (fdWrite > maxfd)
4296 maxfd = fdWrite;
4297
4298 FD_ZERO_ALL();
4299 FD_SET_ALL(fdRead);
4300 FD_SET_ALL(fdWrite);
4301 select_timeout.tv_sec=0;
4302 select_timeout.tv_usec=0;
4303
4304 ticks = GetTickCount();
4305 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4306 ticks = GetTickCount() - ticks;
4307 ok(ret == 0, "select should not return any socket handles\n");
4308 ok(ticks < 100, "select was blocking for %lu ms\n", ticks);
4309 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
4310 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
4311 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
4312 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
4313
4314 FD_ZERO_ALL();
4315 FD_SET_ALL(fdRead);
4316 FD_SET_ALL(fdWrite);
4317 select_timeout.tv_sec=0;
4318 select_timeout.tv_usec=500;
4319
4320 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4321 ok(ret == 0, "select should not return any socket handles\n");
4322 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
4323 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
4324 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
4325 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
4326
4327 ok ((listen(fdWrite, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
4328 ret = closesocket(fdWrite);
4329 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
4330
4331 thread_params.s = fdRead;
4332 thread_params.ReadKilled = FALSE;
4333 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
4334 thread_handle = CreateThread (NULL, 0, SelectReadThread, &thread_params, 0, &id );
4335 ok ( (thread_handle != NULL), "CreateThread failed unexpectedly: %ld\n", GetLastError());
4336
4337 WaitForSingleObject (server_ready, INFINITE);
4338 Sleep(200);
4339 ret = closesocket(fdRead);
4340 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
4341
4342 WaitForSingleObject (thread_handle, 1000);
4343 ok ( thread_params.ReadKilled, "closesocket did not wake up select\n");
4344 ret = recv(fdRead, &buffer, 1, MSG_PEEK);
4345 ok( (ret == -1), "peek at closed socket expected -1 got %d\n", ret);
4346
4347 /* Test selecting invalid handles */
4348 FD_ZERO_ALL();
4349
4350 SetLastError(0);
4351 ret = select(maxfd+1, 0, 0, 0, &select_timeout);
4352 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4353 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
4354
4355 SetLastError(0);
4356 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4357 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4358 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
4359
4360 FD_SET(INVALID_SOCKET, &readfds);
4361 SetLastError(0);
4362 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4363 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4364 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
4365 ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
4366
4367 FD_ZERO(&readfds);
4368 FD_SET(INVALID_SOCKET, &writefds);
4369 SetLastError(0);
4370 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4371 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4372 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
4373 ok ( !FD_ISSET(fdRead, &writefds), "FD should not be set\n");
4374
4375 FD_ZERO(&writefds);
4376 FD_SET(INVALID_SOCKET, &exceptfds);
4377 SetLastError(0);
4378 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4379 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4380 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
4381 ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
4382
4383 tcp_socketpair(&fdRead, &fdWrite);
4384 maxfd = fdRead;
4385 if(fdWrite > maxfd) maxfd = fdWrite;
4386
4387 FD_ZERO(&readfds);
4388 FD_SET(fdRead, &readfds);
4389 apc_count = 0;
4390 ret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
4391 ok(ret, "QueueUserAPC returned %d\n", ret);
4392 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
4393 ok(!ret, "select returned %d\n", ret);
4394 ok(apc_count == 1, "got apc_count %d.\n", apc_count);
4395
4396 FD_ZERO(&writefds);
4397 FD_SET(fdWrite, &writefds);
4398 apc_count = 0;
4399 ret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
4400 ok(ret, "QueueUserAPC returned %d\n", ret);
4401 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
4402 ok(ret == 1, "select returned %d\n", ret);
4403 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4404 ok(!apc_count, "APC was called\n");
4405 SleepEx(0, TRUE);
4406 ok(apc_count == 1, "got apc_count %d.\n", apc_count);
4407
4408 /* select the same socket twice */
4409 writefds.fd_count = 2;
4410 writefds.fd_array[0] = fdWrite;
4411 writefds.fd_array[1] = fdWrite;
4412 ret = select(0, NULL, &writefds, NULL, &select_timeout);
4413 ok(ret == 1, "select returned %d\n", ret);
4414 ok(writefds.fd_count == 1, "got count %u\n", writefds.fd_count);
4415 ok(writefds.fd_array[0] == fdWrite, "got fd %#Ix\n", writefds.fd_array[0]);
4416 ok(writefds.fd_array[1] == fdWrite, "got fd %#Ix\n", writefds.fd_array[1]);
4417
4418 /* tests for overlapping fd_set pointers */
4419 FD_ZERO(&readfds);
4420 FD_SET(fdWrite, &readfds);
4421 ret = select(fdWrite+1, &readfds, &readfds, NULL, &select_timeout);
4422 ok(ret == 1, "select returned %d\n", ret);
4423 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4424
4425 FD_ZERO(&readfds);
4426 FD_SET(fdWrite, &readfds);
4427 FD_SET(fdRead, &readfds);
4428 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
4429 ok(ret == 2, "select returned %d\n", ret);
4430 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4431 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4432
4433 ok(send(fdWrite, "test", 4, 0) == 4, "failed to send data\n");
4434 FD_ZERO(&readfds);
4435 FD_SET(fdRead, &readfds);
4436 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
4437 ok(ret == 1, "select returned %d\n", ret);
4438 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4439
4440 FD_ZERO(&readfds);
4441 FD_SET(fdWrite, &readfds);
4442 FD_SET(fdRead, &readfds);
4443 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
4444 ok(ret == 2, "select returned %d\n", ret);
4445 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4446 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4447
4448 while(1) {
4449 FD_ZERO(&writefds);
4450 FD_SET(fdWrite, &writefds);
4451 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
4452 if(!ret) break;
4453 ok(send(fdWrite, tmp_buf, sizeof(tmp_buf), 0) > 0, "failed to send data\n");
4454 }
4455 FD_ZERO(&readfds);
4456 FD_SET(fdWrite, &readfds);
4457 FD_SET(fdRead, &readfds);
4458 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
4459 ok(ret == 1, "select returned %d\n", ret);
4460 ok(!FD_ISSET(fdWrite, &readfds), "fdWrite socket is in the set\n");
4461 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4462
4463 ok(send(fdRead, "test", 4, 0) == 4, "failed to send data\n");
4464 Sleep(100);
4465 FD_ZERO(&readfds);
4466 FD_SET(fdWrite, &readfds);
4467 FD_SET(fdRead, &readfds);
4468 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
4469 ok(ret == 2, "select returned %d\n", ret);
4470 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4471 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4472
4473 page_pair = VirtualAlloc(NULL, 0x1000 * 2, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
4474 VirtualProtect(page_pair + 0x1000, 0x1000, PAGE_NOACCESS, &old_protect);
4475 alloc_fds = (fd_set *)((page_pair + 0x1000) - offsetof(fd_set, fd_array[1]));
4476 alloc_fds->fd_count = 1;
4477 alloc_fds->fd_array[0] = fdRead;
4478 ret = select(fdRead+1, alloc_fds, NULL, NULL, &select_timeout);
4479 ok(ret == 1, "select returned %d\n", ret);
4480 VirtualFree(page_pair, 0, MEM_RELEASE);
4481
4482 closesocket(fdRead);
4483 closesocket(fdWrite);
4484
4485 alloc_fds = malloc(offsetof(fd_set, fd_array[ARRAY_SIZE(sockets)]));
4486 alloc_fds->fd_count = ARRAY_SIZE(sockets);
4487 for (i = 0; i < ARRAY_SIZE(sockets); i += 2)
4488 {
4489 tcp_socketpair(&sockets[i], &sockets[i + 1]);
4490 alloc_fds->fd_array[i] = sockets[i];
4491 alloc_fds->fd_array[i + 1] = sockets[i + 1];
4492 }
4493 ret = select(0, NULL, alloc_fds, NULL, &select_timeout);
4494 ok(ret == ARRAY_SIZE(sockets), "got %d\n", ret);
4495 for (i = 0; i < ARRAY_SIZE(sockets); ++i)
4496 {
4497 ok(alloc_fds->fd_array[i] == sockets[i], "got socket %#Ix at index %u\n", alloc_fds->fd_array[i], i);
4498 closesocket(sockets[i]);
4499 }
4500 free(alloc_fds);
4501
4502 /* select() works in 3 distinct states:
4503 * - to check if a connection attempt ended with success or error;
4504 * - to check if a pending connection is waiting for acceptance;
4505 * - to check for data to read, availability for write and OOB data
4506 *
4507 * The tests below ensure that all conditions are tested.
4508 */
4509 memset(&address, 0, sizeof(address));
4510 address.sin_addr.s_addr = inet_addr("127.0.0.1");
4511 address.sin_family = AF_INET;
4512 len = sizeof(address);
4513 fdListen = setup_server_socket(&address, &len);
4514 select_timeout.tv_sec = 1;
4515 select_timeout.tv_usec = 250000;
4516
4517 /* When no events are pending select returns 0 with no error */
4518 FD_ZERO_ALL();
4519 FD_SET_ALL(fdListen);
4520 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4521 ok(ret == 0, "expected 0, got %d\n", ret);
4522
4523 /* When a socket is attempting to connect the listening socket receives the read descriptor */
4524 fdWrite = setup_connector_socket(&address, len, TRUE);
4525 FD_ZERO_ALL();
4526 FD_SET_ALL(fdListen);
4527 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4528 ok(ret == 1, "expected 1, got %d\n", ret);
4529 ok(FD_ISSET(fdListen, &readfds), "fdListen socket is not in the set\n");
4530 len = sizeof(address);
4531 fdRead = accept(fdListen, (struct sockaddr*) &address, &len);
4532 ok(fdRead != INVALID_SOCKET, "expected a valid socket\n");
4533
4534 /* The connector is signaled through the write descriptor */
4535 FD_ZERO_ALL();
4536 FD_SET_ALL(fdListen);
4537 FD_SET_ALL(fdRead);
4538 FD_SET_ALL(fdWrite);
4539 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4540 ok(ret == 2, "expected 2, got %d\n", ret);
4541 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4542 ok(FD_ISSET(fdRead, &writefds), "fdRead socket is not in the set\n");
4543 len = sizeof(id);
4544 id = 0xdeadbeef;
4545 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
4546 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4547 ok(id == 0, "expected 0, got %ld\n", id);
4548 set_blocking(fdRead, FALSE);
4549
4550 /* When data is received the receiver gets the read descriptor */
4551 ret = send(fdWrite, "1234", 4, 0);
4552 ok(ret == 4, "expected 4, got %d\n", ret);
4553 FD_ZERO_ALL();
4554 FD_SET_ALL(fdListen);
4555 FD_SET(fdRead, &readfds);
4556 FD_SET(fdRead, &exceptfds);
4557 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4558 ok(ret == 1, "expected 1, got %d\n", ret);
4559 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4560 ok(!FD_ISSET(fdRead, &exceptfds), "fdRead socket is in the set\n");
4561 FD_ZERO_ALL();
4562 FD_SET_ALL(fdRead);
4563 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4564 ok(ret == 2, "expected 1, got %d\n", ret);
4565 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4566 ok(FD_ISSET(fdRead, &writefds), "fdRead socket is not in the set\n");
4567 ok(!FD_ISSET(fdRead, &exceptfds), "fdRead socket is in the set\n");
4568 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
4569 ok(ret == 4, "expected 4, got %d\n", ret);
4570 ok(!strcmp(tmp_buf, "1234"), "data received differs from sent\n");
4571
4572 /* When OOB data is received the socket is set in the except descriptor */
4573 ret = send(fdWrite, "A", 1, MSG_OOB);
4574 ok(ret == 1, "expected 1, got %d\n", ret);
4575 FD_ZERO_ALL();
4576 FD_SET_ALL(fdListen);
4577 FD_SET(fdRead, &readfds);
4578 FD_SET(fdRead, &exceptfds);
4579 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4580 ok(ret == 1, "expected 1, got %d\n", ret);
4581 ok(FD_ISSET(fdRead, &exceptfds), "fdRead socket is not in the set\n");
4582 tmp_buf[0] = 0xAF;
4583 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
4584 ok(ret == 1, "expected 1, got %d\n", ret);
4585 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
4586
4587 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
4588 ret = 1;
4589 ret = setsockopt(fdRead, SOL_SOCKET, SO_OOBINLINE, (char*) &ret, sizeof(ret));
4590 ok(ret == 0, "expected 0, got %d\n", ret);
4591 ret = send(fdWrite, "A", 1, MSG_OOB);
4592 ok(ret == 1, "expected 1, got %d\n", ret);
4593 FD_ZERO_ALL();
4594 FD_SET_ALL(fdListen);
4595 FD_SET(fdRead, &readfds);
4596 FD_SET(fdRead, &exceptfds);
4597 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4598 ok(ret == 1, "expected 1, got %d\n", ret);
4599 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4600 tmp_buf[0] = 0xAF;
4601 SetLastError(0xdeadbeef);
4602 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
4603 ok(ret == SOCKET_ERROR, "expected SOCKET_ERROR, got %d\n", ret);
4604 ok(GetLastError() == WSAEINVAL, "expected 10022, got %ld\n", GetLastError());
4605 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
4606 ok(ret == 1, "expected 1, got %d\n", ret);
4607 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
4608
4609 /* Linux has some odd behaviour (probably a bug) where receiving OOB,
4610 * setting SO_OOBINLINE, and then calling recv() again will cause the same
4611 * data to be received twice. Avoid that messing with further tests by
4612 * calling recv() here. */
4613 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
4614 todo_wine ok(ret == -1, "got %d\n", ret);
4615 todo_wine ok(GetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4616
4617 /* When the connection is closed the socket is set in the read descriptor */
4618 ret = closesocket(fdRead);
4619 ok(ret == 0, "expected 0, got %d\n", ret);
4620 FD_ZERO_ALL();
4621 FD_SET_ALL(fdListen);
4622 FD_SET(fdWrite, &readfds);
4623 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4624 ok(ret == 1, "expected 1, got %d\n", ret);
4625 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4626 ret = recv(fdWrite, tmp_buf, sizeof(tmp_buf), 0);
4627 ok(ret == 0, "expected 0, got %d\n", ret);
4628 ret = closesocket(fdWrite);
4629 ok(ret == 0, "expected 0, got %d\n", ret);
4630
4631 /* w10pro64 sometimes takes over 2 seconds for an error to be reported. */
4632 if (winetest_interactive)
4633 {
4634 const struct sockaddr_in invalid_addr =
4635 {
4636 .sin_family = AF_INET,
4637 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
4638 .sin_port = 255,
4639 };
4640 SOCKET client2, server2;
4641
4642 fdWrite = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4643 set_blocking(fdWrite, FALSE);
4644
4645 ret = connect(fdWrite, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
4646 ok(ret == -1, "got %d\n", ret);
4647 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4648
4649 FD_ZERO_ALL();
4650 FD_SET(fdWrite, &readfds);
4651 FD_SET(fdWrite, &writefds);
4652 FD_SET(fdWrite, &exceptfds);
4653 select_timeout.tv_sec = 10;
4654 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4655 ok(ret == 1, "expected 1, got %d\n", ret);
4656 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4657 ok(select_timeout.tv_usec == 250000, "select timeout should not have changed\n");
4658
4659 len = sizeof(id);
4660 id = 0xdeadbeef;
4661 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4662 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4663 ok(id == WSAECONNREFUSED, "got error %lu\n", id);
4664
4665 len = sizeof(id);
4666 id = 0xdeadbeef;
4667 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4668 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4669 ok(id == WSAECONNREFUSED, "got error %lu\n", id);
4670
4671 FD_ZERO_ALL();
4672 FD_SET(fdWrite, &readfds);
4673 FD_SET(fdWrite, &writefds);
4674 FD_SET(fdWrite, &exceptfds);
4675 select_timeout.tv_sec = 10;
4676 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4677 ok(ret == 1, "got %d\n", ret);
4678 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4679
4680 /* Calling connect() doesn't reset the socket error, but a successful
4681 * connection does. This is kind of tricky to test, because while
4682 * Windows takes a couple seconds to actually fail the connection,
4683 * Linux will fail the connection almost immediately. */
4684
4685 ret = connect(fdWrite, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
4686 ok(ret == -1, "got %d\n", ret);
4687 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4688
4689 len = sizeof(id);
4690 id = 0xdeadbeef;
4691 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4692 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4693 ok(id == WSAECONNREFUSED, "got error %lu\n", id);
4694
4695 FD_ZERO_ALL();
4696 FD_SET(fdWrite, &readfds);
4697 FD_SET(fdWrite, &writefds);
4698 FD_SET(fdWrite, &exceptfds);
4699 select_timeout.tv_sec = 10;
4700 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4701 ok(ret == 1, "got %d\n", ret);
4702 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4703
4704 len = sizeof(address);
4705 ret = getsockname(fdListen, (struct sockaddr *)&address, &len);
4706 ok(!ret, "got error %u\n", WSAGetLastError());
4707 ret = connect(fdWrite, (const struct sockaddr *)&address, sizeof(address));
4708 ok(ret == -1, "got %d\n", ret);
4709 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4710
4711 FD_ZERO_ALL();
4712 FD_SET(fdWrite, &readfds);
4713 FD_SET(fdWrite, &writefds);
4714 FD_SET(fdWrite, &exceptfds);
4715 select_timeout.tv_sec = 1;
4716 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4717 ok(ret == 1, "expected 1, got %d\n", ret);
4718 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4719
4720 len = sizeof(id);
4721 id = 0xdeadbeef;
4722 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4723 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4724 ok(!id, "got error %lu\n", id);
4725
4726 closesocket(fdWrite);
4727
4728 /* Test listening after a failed connection. */
4729
4730 fdWrite = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4731 set_blocking(fdWrite, FALSE);
4732
4733 address.sin_family = AF_INET;
4734 address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
4735 address.sin_port = 0;
4736 ret = bind(fdWrite, (struct sockaddr *)&address, sizeof(address));
4737 ok(!ret, "got %d\n", ret);
4738
4739 ret = connect(fdWrite, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
4740 ok(ret == -1, "got %d\n", ret);
4741 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4742
4743 FD_ZERO(&exceptfds);
4744 FD_SET(fdWrite, &exceptfds);
4745 select_timeout.tv_sec = 10;
4746 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
4747 ok(ret == 1, "expected 1, got %d\n", ret);
4748
4749 len = sizeof(address);
4750 ret = getsockname(fdWrite, (struct sockaddr *)&address, &len);
4751 ok(!ret, "got error %lu\n", GetLastError());
4752
4753 /* Linux seems to forbid this. We'd need to replace the underlying fd. */
4754 ret = listen(fdWrite, 1);
4755 todo_wine ok(!ret, "got error %lu\n", GetLastError());
4756
4757 if (!ret)
4758 {
4759 client2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4760 ret = connect(client2, (struct sockaddr *)&address, sizeof(address));
4761 ok(!ret, "got error %lu\n", GetLastError());
4762
4763 server2 = accept(fdWrite, NULL, NULL);
4764 ok(server2 != INVALID_SOCKET, "got %d\n", ret);
4765
4766 closesocket(server2);
4767 closesocket(client2);
4768 }
4769
4770 len = sizeof(id);
4771 id = 0xdeadbeef;
4772 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4773 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4774 ok(id == WSAECONNREFUSED, "got error %lu\n", id);
4775
4776 FD_ZERO_ALL();
4777 FD_SET(fdWrite, &readfds);
4778 FD_SET(fdWrite, &writefds);
4779 FD_SET(fdWrite, &exceptfds);
4780 select_timeout.tv_sec = 0;
4781 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4782 ok(ret == 1, "got %d\n", ret);
4783 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4784
4785 closesocket(fdWrite);
4786
4787 /* test polling after a (synchronous) failure */
4788
4789 fdWrite = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4790
4791 ret = connect(fdWrite, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
4792 ok(ret == -1, "got %d\n", ret);
4793 ok(WSAGetLastError() == WSAECONNREFUSED, "got error %u\n", WSAGetLastError());
4794
4795 len = sizeof(id);
4796 id = 0xdeadbeef;
4797 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4798 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4799 todo_wine ok(!id, "got error %lu\n", id);
4800
4801 FD_ZERO_ALL();
4802 FD_SET(fdWrite, &readfds);
4803 FD_SET(fdWrite, &writefds);
4804 FD_SET(fdWrite, &exceptfds);
4805 select_timeout.tv_sec = 0;
4806 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4807 ok(ret == 1, "expected 1, got %d\n", ret);
4808 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4809
4810 len = sizeof(id);
4811 id = 0xdeadbeef;
4812 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4813 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4814 todo_wine ok(!id, "got error %lu\n", id);
4815
4816 closesocket(fdWrite);
4817 }
4818
4819 ret = closesocket(fdListen);
4820 ok(ret == 0, "expected 0, got %d\n", ret);
4821
4822 select_timeout.tv_sec = 1;
4823 select_timeout.tv_usec = 250000;
4824
4825 /* Try select() on a closed socket after connection */
4826 tcp_socketpair(&fdRead, &fdWrite);
4827 closesocket(fdRead);
4828 FD_ZERO_ALL();
4829 FD_SET_ALL(fdWrite);
4830 FD_SET_ALL(fdRead);
4831 SetLastError(0xdeadbeef);
4832 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
4833 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4834 ok(GetLastError() == WSAENOTSOCK, "got %ld\n", GetLastError());
4835 /* descriptor sets are unchanged */
4836 ok(readfds.fd_count == 2, "expected 2, got %d\n", readfds.fd_count);
4837 ok(exceptfds.fd_count == 2, "expected 2, got %d\n", exceptfds.fd_count);
4838 closesocket(fdWrite);
4839
4840 /* Close the socket currently being selected in a thread - bug 38399 */
4841 tcp_socketpair(&fdRead, &fdWrite);
4842 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
4843 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %ld\n", GetLastError());
4844 FD_ZERO_ALL();
4845 FD_SET_ALL(fdWrite);
4846 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
4847 ok(ret == 1, "expected 1, got %d\n", ret);
4848 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4849 WaitForSingleObject (thread_handle, 1000);
4850 closesocket(fdRead);
4851 /* test again with only the except descriptor */
4852 tcp_socketpair(&fdRead, &fdWrite);
4853 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
4854 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %ld\n", GetLastError());
4855 FD_ZERO_ALL();
4856 FD_SET(fdWrite, &exceptfds);
4857 SetLastError(0xdeadbeef);
4858 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
4859 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4860 ok(GetLastError() == WSAENOTSOCK, "got %ld\n", GetLastError());
4861 ok(!FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is in the set\n");
4862 WaitForSingleObject (thread_handle, 1000);
4863 closesocket(fdRead);
4864
4865 /* test UDP behavior of unbound sockets */
4866 select_timeout.tv_sec = 0;
4867 select_timeout.tv_usec = 250000;
4868 fdWrite = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
4869 ok(fdWrite != INVALID_SOCKET, "socket call failed\n");
4870 FD_ZERO_ALL();
4871 FD_SET_ALL(fdWrite);
4872 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4873 ok(ret == 1, "expected 1, got %d\n", ret);
4874 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4875 closesocket(fdWrite);
4876 }
4877 #undef FD_SET_ALL
4878 #undef FD_ZERO_ALL
4879
4880 static DWORD WINAPI AcceptKillThread(void *param)
4881 {
4882 select_thread_params *par = param;
4883 struct sockaddr_in address;
4884 int len = sizeof(address);
4885 SOCKET client_socket;
4886
4887 SetEvent(server_ready);
4888 client_socket = accept(par->s, (struct sockaddr*) &address, &len);
4889 if (client_socket != INVALID_SOCKET)
4890 closesocket(client_socket);
4891 par->ReadKilled = (client_socket == INVALID_SOCKET);
4892 return 0;
4893 }
4894
4895
4896 static int CALLBACK AlwaysDeferConditionFunc(LPWSABUF lpCallerId, LPWSABUF lpCallerData, LPQOS pQos,
4897 LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,
4898 GROUP *g, DWORD_PTR dwCallbackData)
4899 {
4900 return CF_DEFER;
4901 }
4902
4903 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len)
4904 {
4905 int ret, val;
4906 SOCKET server_socket;
4907
4908 server_socket = socket(AF_INET, SOCK_STREAM, 0);
4909 ok(server_socket != INVALID_SOCKET, "failed to bind socket, error %u\n", WSAGetLastError());
4910
4911 val = 1;
4912 ret = setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
4913 ok(!ret, "failed to set SO_REUSEADDR, error %u\n", WSAGetLastError());
4914
4915 ret = bind(server_socket, (struct sockaddr *)addr, *len);
4916 ok(!ret, "failed to bind socket, error %u\n", WSAGetLastError());
4917
4918 ret = getsockname(server_socket, (struct sockaddr *)addr, len);
4919 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
4920
4921 ret = listen(server_socket, 5);
4922 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
4923
4924 return server_socket;
4925 }
4926
4927 static SOCKET setup_connector_socket(const struct sockaddr_in *addr, int len, BOOL nonblock)
4928 {
4929 int ret;
4930 SOCKET connector;
4931
4932 connector = socket(AF_INET, SOCK_STREAM, 0);
4933 ok(connector != INVALID_SOCKET, "failed to create connector socket %d\n", WSAGetLastError());
4934
4935 if (nonblock)
4936 set_blocking(connector, !nonblock);
4937
4938 ret = connect(connector, (const struct sockaddr *)addr, len);
4939 if (!nonblock)
4940 ok(!ret, "connecting to accepting socket failed %d\n", WSAGetLastError());
4941 else if (ret == SOCKET_ERROR)
4942 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4943
4944 return connector;
4945 }
4946
4947 struct connect_apc_func_param
4948 {
4949 HANDLE event;
4950 struct sockaddr_in addr;
4951 SOCKET connector;
4952 unsigned int apc_count;
4953 };
4954
4955 static DWORD WINAPI test_accept_connect_thread(void *param)
4956 {
4957 struct connect_apc_func_param *p = (struct connect_apc_func_param *)param;
4958
4959 WaitForSingleObject(p->event, INFINITE);
4960 p->connector = setup_connector_socket(&p->addr, sizeof(p->addr), FALSE);
4961 ok(p->connector != INVALID_SOCKET, "failed connecting from APC func.\n");
4962 return 0;
4963 }
4964
4965 static void WINAPI connect_apc_func(ULONG_PTR param)
4966 {
4967 struct connect_apc_func_param *p = (struct connect_apc_func_param *)param;
4968
4969 ++p->apc_count;
4970 SetEvent(p->event);
4971 }
4972
4973 static void test_accept(void)
4974 {
4975 int ret;
4976 SOCKET server_socket, accepted = INVALID_SOCKET, connector;
4977 struct connect_apc_func_param apc_param;
4978 struct sockaddr_in address;
4979 SOCKADDR_STORAGE ss, ss_empty;
4980 int socklen;
4981 select_thread_params thread_params;
4982 HANDLE thread_handle = NULL;
4983 DWORD id;
4984
4985 memset(&address, 0, sizeof(address));
4986 address.sin_addr.s_addr = inet_addr("127.0.0.1");
4987 address.sin_family = AF_INET;
4988
4989 socklen = sizeof(address);
4990 server_socket = setup_server_socket(&address, &socklen);
4991
4992 memset(&apc_param, 0, sizeof(apc_param));
4993 apc_param.event = CreateEventW(NULL, FALSE, FALSE, NULL);
4994 apc_param.addr = address;
4995 /* Connecting directly from APC function randomly crashes on Windows for some reason,
4996 * so do it from a thread and only signal it from the APC when we are in accept() call. */
4997 thread_handle = CreateThread(NULL, 0, test_accept_connect_thread, &apc_param, 0, NULL);
4998 ret = QueueUserAPC(connect_apc_func, GetCurrentThread(), (ULONG_PTR)&apc_param);
4999 ok(ret, "QueueUserAPC returned %d\n", ret);
5000 accepted = accept(server_socket, NULL, NULL);
5001 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
5002 ok(apc_param.apc_count == 1, "APC was called %u times\n", apc_param.apc_count);
5003 closesocket(accepted);
5004 closesocket(apc_param.connector);
5005 WaitForSingleObject(thread_handle, INFINITE);
5006 CloseHandle(thread_handle);
5007 CloseHandle(apc_param.event);
5008
5009 connector = setup_connector_socket(&address, socklen, FALSE);
5010 if (connector == INVALID_SOCKET) goto done;
5011
5012 accepted = WSAAccept(server_socket, NULL, NULL, AlwaysDeferConditionFunc, 0);
5013 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
5014
5015 accepted = accept(server_socket, NULL, 0);
5016 ok(accepted != INVALID_SOCKET, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
5017
5018 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
5019
5020 thread_params.s = server_socket;
5021 thread_params.ReadKilled = FALSE;
5022 thread_handle = CreateThread(NULL, 0, AcceptKillThread, &thread_params, 0, &id);
5023
5024 WaitForSingleObject(server_ready, INFINITE);
5025 Sleep(200);
5026 ret = closesocket(server_socket);
5027 ok(!ret, "failed to close socket, error %u\n", WSAGetLastError());
5028
5029 WaitForSingleObject(thread_handle, 1000);
5030 ok(thread_params.ReadKilled, "closesocket did not wake up accept\n");
5031
5032 closesocket(accepted);
5033 closesocket(connector);
5034 accepted = connector = INVALID_SOCKET;
5035
5036 socklen = sizeof(address);
5037 server_socket = setup_server_socket(&address, &socklen);
5038
5039 connector = setup_connector_socket(&address, socklen, FALSE);
5040 if (connector == INVALID_SOCKET) goto done;
5041
5042 socklen = 0;
5043 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
5044 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
5045 ok(!socklen, "got %d\n", socklen);
5046 closesocket(connector);
5047 connector = INVALID_SOCKET;
5048
5049 socklen = sizeof(address);
5050 connector = setup_connector_socket(&address, socklen, FALSE);
5051 if (connector == INVALID_SOCKET) goto done;
5052
5053 accepted = WSAAccept(server_socket, NULL, NULL, NULL, 0);
5054 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
5055 closesocket(accepted);
5056 closesocket(connector);
5057 accepted = connector = INVALID_SOCKET;
5058
5059 socklen = sizeof(address);
5060 connector = setup_connector_socket(&address, socklen, FALSE);
5061 if (connector == INVALID_SOCKET) goto done;
5062
5063 socklen = sizeof(ss);
5064 memset(&ss, 0, sizeof(ss));
5065 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
5066 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
5067 ok(socklen != sizeof(ss), "unexpected length\n");
5068 ok(ss.ss_family, "family not set\n");
5069 closesocket(accepted);
5070 closesocket(connector);
5071 accepted = connector = INVALID_SOCKET;
5072
5073 socklen = sizeof(address);
5074 connector = setup_connector_socket(&address, socklen, FALSE);
5075 if (connector == INVALID_SOCKET) goto done;
5076
5077 socklen = 0;
5078 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
5079 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
5080 ok(!socklen, "got %d\n", socklen);
5081 closesocket(connector);
5082 accepted = connector = INVALID_SOCKET;
5083
5084 socklen = sizeof(address);
5085 connector = setup_connector_socket(&address, socklen, FALSE);
5086 if (connector == INVALID_SOCKET) goto done;
5087
5088 accepted = accept(server_socket, NULL, NULL);
5089 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
5090 closesocket(accepted);
5091 closesocket(connector);
5092 accepted = connector = INVALID_SOCKET;
5093
5094 socklen = sizeof(address);
5095 connector = setup_connector_socket(&address, socklen, FALSE);
5096 if (connector == INVALID_SOCKET) goto done;
5097
5098 socklen = sizeof(ss);
5099 memset(&ss, 0, sizeof(ss));
5100 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
5101 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
5102 ok(socklen != sizeof(ss), "unexpected length\n");
5103 ok(ss.ss_family, "family not set\n");
5104 closesocket(accepted);
5105 closesocket(connector);
5106 accepted = connector = INVALID_SOCKET;
5107
5108 socklen = sizeof(address);
5109 connector = setup_connector_socket(&address, socklen, FALSE);
5110 if (connector == INVALID_SOCKET) goto done;
5111
5112 memset(&ss, 0, sizeof(ss));
5113 memset(&ss_empty, 0, sizeof(ss_empty));
5114 accepted = accept(server_socket, (struct sockaddr *)&ss, NULL);
5115 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
5116 ok(!memcmp(&ss, &ss_empty, sizeof(ss)), "structure is different\n");
5117
5118 done:
5119 if (accepted != INVALID_SOCKET)
5120 closesocket(accepted);
5121 if (connector != INVALID_SOCKET)
5122 closesocket(connector);
5123 if (thread_handle != NULL)
5124 CloseHandle(thread_handle);
5125 if (server_ready != INVALID_HANDLE_VALUE)
5126 CloseHandle(server_ready);
5127 if (server_socket != INVALID_SOCKET)
5128 closesocket(server_socket);
5129 }
5130
5131 /* Test what socket state is inherited from the listening socket by accept(). */
5132 static void test_accept_inheritance(void)
5133 {
5134 struct sockaddr_in addr, destaddr;
5135 SOCKET listener, server, client;
5136 struct linger linger;
5137 int ret, len, value;
5138 unsigned int i;
5139
5140 static const struct
5141 {
5142 int optname;
5143 int optval;
5144 int value;
5145 }
5146 int_tests[] =
5147 {
5148 {SOL_SOCKET, SO_REUSEADDR, 1},
5149 {SOL_SOCKET, SO_KEEPALIVE, 1},
5150 {SOL_SOCKET, SO_OOBINLINE, 1},
5151 {SOL_SOCKET, SO_SNDBUF, 0x123},
5152 {SOL_SOCKET, SO_RCVBUF, 0x123},
5153 {SOL_SOCKET, SO_SNDTIMEO, 0x123},
5154 {SOL_SOCKET, SO_RCVTIMEO, 0x123},
5155 {IPPROTO_TCP, TCP_NODELAY, 1},
5156 };
5157
5158 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5159 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
5160
5161 for (i = 0; i < ARRAY_SIZE(int_tests); ++i)
5162 {
5163 ret = setsockopt(listener, int_tests[i].optname, int_tests[i].optval,
5164 (char *)&int_tests[i].value, sizeof(int_tests[i].value));
5165 ok(!ret, "test %u: got error %u\n", i, WSAGetLastError());
5166 }
5167
5168 linger.l_onoff = 1;
5169 linger.l_linger = 555;
5170 ret = setsockopt(listener, SOL_SOCKET, SO_LINGER, (char *)&linger, sizeof(linger));
5171 ok(!ret, "got error %u\n", WSAGetLastError());
5172
5173 memset(&addr, 0, sizeof(addr));
5174 addr.sin_family = AF_INET;
5175 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
5176 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
5177 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
5178 len = sizeof(destaddr);
5179 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
5180 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
5181
5182 ret = listen(listener, 1);
5183 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
5184
5185 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5186 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
5187 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
5188 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
5189 server = accept(listener, NULL, NULL);
5190 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
5191
5192 for (i = 0; i < ARRAY_SIZE(int_tests); ++i)
5193 {
5194 value = 0;
5195 len = sizeof(value);
5196 ret = getsockopt(server, int_tests[i].optname, int_tests[i].optval, (char *)&value, &len);
5197 ok(!ret, "test %u: got error %u\n", i, WSAGetLastError());
5198 ok(value == int_tests[i].value, "test %u: got value %#x\n", i, value);
5199 }
5200
5201 len = sizeof(linger);
5202 memset(&linger, 0, sizeof(linger));
5203 ret = getsockopt(server, SOL_SOCKET, SO_LINGER, (char *)&linger, &len);
5204 ok(!ret, "got error %u\n", WSAGetLastError());
5205 ok(linger.l_onoff == 1, "got on/off %u\n", linger.l_onoff);
5206 ok(linger.l_linger == 555, "got linger %u\n", linger.l_onoff);
5207
5208 closesocket(server);
5209 closesocket(client);
5210 closesocket(listener);
5211 }
5212
5213 static void test_extendedSocketOptions(void)
5214 {
5215 WSADATA wsa;
5216 SOCKET sock;
5217 struct sockaddr_in sa;
5218 int sa_len = sizeof(struct sockaddr_in);
5219 int optval, optlen = sizeof(int), ret;
5220 BOOL bool_opt_val;
5221 LINGER linger_val;
5222
5223 ret = WSAStartup(MAKEWORD(2,0), &wsa);
5224 ok(!ret, "failed to startup, error %u\n", WSAGetLastError());
5225
5226 memset(&sa, 0, sa_len);
5227
5228 sa.sin_family = AF_INET;
5229 sa.sin_port = htons(0);
5230 sa.sin_addr.s_addr = htonl(INADDR_ANY);
5231
5232 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
5233 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
5234
5235 ret = bind(sock, (struct sockaddr *) &sa, sa_len);
5236 ok(!ret, "failed to bind socket, error %u\n", WSAGetLastError());
5237
5238 ret = getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
5239
5240 ok(ret == 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret);
5241 ok((optval == 65507) || (optval == 65527),
5242 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval);
5243
5244 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
5245 SetLastError(0xdeadbeef);
5246 optval = 0xdeadbeef;
5247 optlen = sizeof(int);
5248 ret = getsockopt(sock, 0xffffffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
5249 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
5250 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5251 ret, WSAGetLastError(), optval, optval);
5252
5253 /* more invalid values for level */
5254 SetLastError(0xdeadbeef);
5255 optval = 0xdeadbeef;
5256 optlen = sizeof(int);
5257 ret = getsockopt(sock, 0x1234ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
5258 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
5259 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5260 ret, WSAGetLastError(), optval, optval);
5261
5262 SetLastError(0xdeadbeef);
5263 optval = 0xdeadbeef;
5264 optlen = sizeof(int);
5265 ret = getsockopt(sock, 0x8000ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
5266 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
5267 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5268 ret, WSAGetLastError(), optval, optval);
5269
5270 SetLastError(0xdeadbeef);
5271 optval = 0xdeadbeef;
5272 optlen = sizeof(int);
5273 ret = getsockopt(sock, 0x00008000, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
5274 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
5275 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5276 ret, WSAGetLastError(), optval, optval);
5277
5278 SetLastError(0xdeadbeef);
5279 optval = 0xdeadbeef;
5280 optlen = sizeof(int);
5281 ret = getsockopt(sock, 0x00000800, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
5282 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
5283 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
5284 ret, WSAGetLastError(), optval, optval);
5285
5286 SetLastError(0xdeadbeef);
5287 optlen = sizeof(LINGER);
5288 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
5289 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAENOPROTOOPT),
5290 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
5291 ret, WSAGetLastError());
5292 closesocket(sock);
5293
5294 sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
5295 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
5296
5297 ret = bind(sock, (struct sockaddr *) &sa, sa_len);
5298 ok(!ret, "failed to bind socket, error %u\n", WSAGetLastError());
5299
5300 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
5301 ok(ret == 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret);
5302
5303 optlen = sizeof(BOOL);
5304 ret = getsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *)&bool_opt_val, &optlen);
5305 ok(ret == 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret);
5306 ok((linger_val.l_onoff && !bool_opt_val) || (!linger_val.l_onoff && bool_opt_val),
5307 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
5308 bool_opt_val, linger_val.l_onoff);
5309
5310 closesocket(sock);
5311 WSACleanup();
5312 }
5313
5314 static void test_getsockname(void)
5315 {
5316 WSADATA wsa;
5317 SOCKET sock;
5318 struct sockaddr_in sa_set, sa_get;
5319 int sa_set_len = sizeof(struct sockaddr_in);
5320 int sa_get_len = sa_set_len;
5321 static const unsigned char null_padding[] = {0,0,0,0,0,0,0,0};
5322 int ret;
5323 struct hostent *h;
5324
5325 ret = WSAStartup(MAKEWORD(2,0), &wsa);
5326 ok(!ret, "failed to startup, error %u\n", WSAGetLastError());
5327
5328 memset(&sa_set, 0, sa_set_len);
5329
5330 sa_set.sin_family = AF_INET;
5331 sa_set.sin_port = htons(0);
5332 sa_set.sin_addr.s_addr = htonl(INADDR_ANY);
5333
5334 sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
5335 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
5336
5337 sa_get = sa_set;
5338 WSASetLastError(0xdeadbeef);
5339 ret = getsockname(sock, (struct sockaddr *)&sa_get, &sa_get_len);
5340 ok(ret == SOCKET_ERROR, "expected failure\n");
5341 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
5342 ok(!memcmp(&sa_get, &sa_set, sizeof(sa_get)), "address should not be changed\n");
5343
5344 ret = bind(sock, (struct sockaddr *) &sa_set, sa_set_len);
5345 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
5346
5347 WSASetLastError(0xdeadbeef);
5348 memset(&sa_get, 0, sizeof(sa_get));
5349 ret = getsockname(sock, (struct sockaddr *) &sa_get, &sa_get_len);
5350 ok(!ret, "got %d\n", ret);
5351 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
5352 ok(sa_get.sin_family == AF_INET, "got family %#x\n", sa_get.sin_family);
5353 ok(sa_get.sin_port != 0, "got zero port\n");
5354 ok(sa_get.sin_addr.s_addr == INADDR_ANY, "got addr %08lx\n", sa_get.sin_addr.s_addr);
5355
5356 ret = memcmp(sa_get.sin_zero, null_padding, 8);
5357 ok(ret == 0, "getsockname did not zero the sockaddr_in structure\n");
5358
5359 sa_get_len = sizeof(sa_get) - 1;
5360 WSASetLastError(0xdeadbeef);
5361 ret = getsockname(sock, (struct sockaddr *)&sa_get, &sa_get_len);
5362 ok(ret == -1, "expected failure\n");
5363 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5364 ok(sa_get_len == sizeof(sa_get) - 1, "got size %d\n", sa_get_len);
5365
5366 closesocket(sock);
5367
5368 h = gethostbyname("");
5369 if (h && h->h_length == 4) /* this test is only meaningful in IPv4 */
5370 {
5371 int i;
5372 for (i = 0; h->h_addr_list[i]; i++)
5373 {
5374 char ipstr[32];
5375 struct in_addr ip;
5376 ip.s_addr = *(ULONG *) h->h_addr_list[i];
5377
5378 sock = socket(AF_INET, SOCK_DGRAM, 0);
5379 ok(sock != INVALID_SOCKET, "socket failed with %ld\n", GetLastError());
5380
5381 memset(&sa_set, 0, sizeof(sa_set));
5382 sa_set.sin_family = AF_INET;
5383 sa_set.sin_addr.s_addr = ip.s_addr;
5384 /* The same address we bind must be the same address we get */
5385 ret = bind(sock, (struct sockaddr*)&sa_set, sizeof(sa_set));
5386 ok(ret == 0, "bind failed with %ld\n", GetLastError());
5387 sa_get_len = sizeof(sa_get);
5388 ret = getsockname(sock, (struct sockaddr*)&sa_get, &sa_get_len);
5389 ok(ret == 0, "getsockname failed with %ld\n", GetLastError());
5390 strcpy(ipstr, inet_ntoa(sa_get.sin_addr));
5391 ok(sa_get.sin_addr.s_addr == sa_set.sin_addr.s_addr,
5392 "address does not match: %s != %s\n", ipstr, inet_ntoa(sa_set.sin_addr));
5393
5394 closesocket(sock);
5395 }
5396 }
5397
5398 WSACleanup();
5399 }
5400
5401 static DWORD apc_error, apc_size;
5402 static OVERLAPPED *apc_overlapped;
5403 static unsigned int apc_count;
5404
5405 static void WINAPI socket_apc(DWORD error, DWORD size, OVERLAPPED *overlapped, DWORD flags)
5406 {
5407 ok(!flags, "got flags %#lx\n", flags);
5408 ++apc_count;
5409 apc_error = error;
5410 apc_size = size;
5411 apc_overlapped = overlapped;
5412 }
5413
5414 #define check_fionread_siocatmark(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, FALSE, FALSE)
5415 #define check_fionread_siocatmark_todo(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, TRUE, TRUE)
5416 #define check_fionread_siocatmark_todo_oob(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, FALSE, TRUE)
5417 static void check_fionread_siocatmark_(int line, SOCKET s, unsigned int normal, unsigned int oob,
5418 BOOL todo_normal, BOOL todo_oob)
5419 {
5420 int ret, value;
5421 DWORD size;
5422
5423 value = 0xdeadbeef;
5424 WSASetLastError(0xdeadbeef);
5425 ret = WSAIoctl(s, FIONREAD, NULL, 0, &value, sizeof(value), &size, NULL, NULL);
5426 ok_(__FILE__, line)(!ret, "expected success\n");
5427 ok_(__FILE__, line)(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5428 todo_wine_if (todo_normal) ok_(__FILE__, line)(value == normal, "FIONBIO returned %u\n", value);
5429
5430 value = 0xdeadbeef;
5431 WSASetLastError(0xdeadbeef);
5432 ret = WSAIoctl(s, SIOCATMARK, NULL, 0, &value, sizeof(value), &size, NULL, NULL);
5433 ok_(__FILE__, line)(!ret, "expected success\n");
5434 ok_(__FILE__, line)(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5435 todo_wine_if (todo_oob) ok_(__FILE__, line)(value == oob, "SIOCATMARK returned %u\n", value);
5436 }
5437
5438 static void test_fionread_siocatmark(void)
5439 {
5440 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
5441 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5442 SOCKET client, server;
5443 char buffer[5];
5444 int ret, value;
5445 ULONG_PTR key;
5446 HANDLE port;
5447 DWORD size;
5448
5449 tcp_socketpair(&client, &server);
5450 set_blocking(client, FALSE);
5451 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
5452
5453 WSASetLastError(0xdeadbeef);
5454 ret = ioctlsocket(client, FIONREAD, (u_long *)1);
5455 ok(ret == -1, "expected failure\n");
5456 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5457
5458 WSASetLastError(0xdeadbeef);
5459 ret = ioctlsocket(client, SIOCATMARK, (u_long *)1);
5460 ok(ret == -1, "expected failure\n");
5461 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5462
5463 WSASetLastError(0xdeadbeef);
5464 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value), NULL, NULL, NULL);
5465 ok(ret == -1, "expected failure\n");
5466 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5467
5468 WSASetLastError(0xdeadbeef);
5469 size = 0xdeadbeef;
5470 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value) - 1, &size, NULL, NULL);
5471 ok(ret == -1, "expected failure\n");
5472 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5473 ok(size == 0xdeadbeef, "got size %lu\n", size);
5474
5475 WSASetLastError(0xdeadbeef);
5476 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value), NULL, NULL, NULL);
5477 ok(ret == -1, "expected failure\n");
5478 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5479
5480 WSASetLastError(0xdeadbeef);
5481 size = 0xdeadbeef;
5482 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value) - 1, &size, NULL, NULL);
5483 ok(ret == -1, "expected failure\n");
5484 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5485 ok(size == 0xdeadbeef, "got size %lu\n", size);
5486
5487 check_fionread_siocatmark(client, 0, TRUE);
5488
5489 port = CreateIoCompletionPort((HANDLE)client, NULL, 123, 0);
5490
5491 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value), NULL, &overlapped, NULL);
5492 ok(ret == -1, "expected failure\n");
5493 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5494
5495 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value), NULL, &overlapped, NULL);
5496 ok(ret == -1, "expected failure\n");
5497 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5498
5499 WSASetLastError(0xdeadbeef);
5500 size = 0xdeadbeef;
5501 value = 0xdeadbeef;
5502 overlapped.Internal = 0xdeadbeef;
5503 overlapped.InternalHigh = 0xdeadbeef;
5504 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value), &size, &overlapped, NULL);
5505 ok(!ret, "expected success\n");
5506 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5507 ok(!value, "got %u\n", value);
5508 ok(size == sizeof(value), "got size %lu\n", size);
5509 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5510 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5511
5512 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5513 ok(ret, "got error %lu\n", GetLastError());
5514 ok(!size, "got size %lu\n", size);
5515 ok(key == 123, "got key %Iu\n", key);
5516 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5517
5518 WSASetLastError(0xdeadbeef);
5519 size = 0xdeadbeef;
5520 value = 0xdeadbeef;
5521 overlapped.Internal = 0xdeadbeef;
5522 overlapped.InternalHigh = 0xdeadbeef;
5523 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value), &size, &overlapped, NULL);
5524 ok(!ret, "expected success\n");
5525 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5526 ok(value == TRUE, "got %u\n", value);
5527 ok(size == sizeof(value), "got size %lu\n", size);
5528 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5529 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5530
5531 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5532 ok(ret, "got error %lu\n", GetLastError());
5533 ok(!size, "got size %lu\n", size);
5534 ok(key == 123, "got key %Iu\n", key);
5535 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5536
5537 ret = send(server, "data", 5, 0);
5538 ok(ret == 5, "got %d\n", ret);
5539
5540 /* wait for the data to be available */
5541 check_poll_mask(client, POLLRDNORM, POLLRDNORM);
5542
5543 check_fionread_siocatmark(client, 5, TRUE);
5544
5545 ret = send(server, "a", 1, MSG_OOB);
5546 ok(ret == 1, "got %d\n", ret);
5547
5548 /* wait for the data to be available */
5549 check_poll_mask(client, POLLRDBAND, POLLRDBAND);
5550
5551 check_fionread_siocatmark_todo_oob(client, 5, FALSE);
5552
5553 ret = send(server, "a", 1, MSG_OOB);
5554 ok(ret == 1, "got %d\n", ret);
5555
5556 check_fionread_siocatmark_todo(client, 5, FALSE);
5557
5558 ret = recv(client, buffer, 3, 0);
5559 ok(ret == 3, "got %d\n", ret);
5560
5561 check_fionread_siocatmark_todo(client, 2, FALSE);
5562
5563 ret = recv(client, buffer, 1, MSG_OOB);
5564 ok(ret == 1, "got %d\n", ret);
5565
5566 /* wait for the data to be available */
5567 check_poll_mask_todo(client, POLLRDBAND, POLLRDBAND);
5568
5569 check_fionread_siocatmark_todo(client, 2, FALSE);
5570
5571 ret = recv(client, buffer, 5, 0);
5572 todo_wine ok(ret == 2, "got %d\n", ret);
5573
5574 check_fionread_siocatmark(client, 0, FALSE);
5575
5576 ret = recv(client, buffer, 1, MSG_OOB);
5577 todo_wine ok(ret == 1, "got %d\n", ret);
5578
5579 check_fionread_siocatmark_todo_oob(client, 0, TRUE);
5580
5581 ret = send(server, "a", 1, MSG_OOB);
5582 ok(ret == 1, "got %d\n", ret);
5583
5584 /* wait for the data to be available */
5585 check_poll_mask(client, POLLRDBAND, POLLRDBAND);
5586
5587 ret = 1;
5588 ret = setsockopt(client, SOL_SOCKET, SO_OOBINLINE, (char *)&ret, sizeof(ret));
5589 ok(!ret, "got error %u\n", WSAGetLastError());
5590
5591 check_fionread_siocatmark_todo_oob(client, 1, FALSE);
5592
5593 ret = recv(client, buffer, 1, 0);
5594 ok(ret == 1, "got %d\n", ret);
5595
5596 check_fionread_siocatmark(client, 0, TRUE);
5597
5598 ret = send(server, "a", 1, MSG_OOB);
5599 ok(ret == 1, "got %d\n", ret);
5600
5601 /* wait for the data to be available */
5602 check_poll_mask(client, POLLRDNORM, POLLRDNORM);
5603
5604 check_fionread_siocatmark(client, 1, TRUE);
5605
5606 closesocket(client);
5607 closesocket(server);
5608
5609 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5610
5611 check_fionread_siocatmark(server, 0, TRUE);
5612
5613 ret = bind(server, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
5614 ok(!ret, "got error %u\n", WSAGetLastError());
5615
5616 check_fionread_siocatmark(server, 0, TRUE);
5617
5618 closesocket(server);
5619 CloseHandle(overlapped.hEvent);
5620
5621 /* test with APCs */
5622
5623 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5624
5625 ret = WSAIoctl(server, FIONREAD, NULL, 0, &value, sizeof(value), NULL, &overlapped, socket_apc);
5626 ok(ret == -1, "expected failure\n");
5627 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5628
5629 ret = WSAIoctl(server, SIOCATMARK, NULL, 0, &value, sizeof(value), NULL, &overlapped, socket_apc);
5630 ok(ret == -1, "expected failure\n");
5631 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5632
5633 apc_count = 0;
5634 size = 0xdeadbeef;
5635 ret = WSAIoctl(server, FIONREAD, NULL, 0, &value, sizeof(value), &size, &overlapped, socket_apc);
5636 ok(!ret, "expected success\n");
5637 ok(size == sizeof(value), "got size %lu\n", size);
5638
5639 ret = SleepEx(0, TRUE);
5640 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5641 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5642 ok(!apc_error, "got APC error %lu\n", apc_error);
5643 ok(!apc_size, "got APC size %lu\n", apc_size);
5644 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5645
5646 apc_count = 0;
5647 size = 0xdeadbeef;
5648 ret = WSAIoctl(server, SIOCATMARK, NULL, 0, &value, sizeof(value), &size, &overlapped, socket_apc);
5649 ok(!ret, "expected success\n");
5650 ok(size == sizeof(value), "got size %lu\n", size);
5651
5652 ret = SleepEx(0, TRUE);
5653 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5654 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5655 ok(!apc_error, "got APC error %lu\n", apc_error);
5656 ok(!apc_size, "got APC size %lu\n", apc_size);
5657 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5658
5659 closesocket(server);
5660 }
5661
5662 static void test_fionbio(void)
5663 {
5664 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5665 u_long one = 1, zero = 0;
5666 HANDLE port, event;
5667 ULONG_PTR key;
5668 void *output;
5669 DWORD size;
5670 SOCKET s;
5671 int ret;
5672
5673 event = CreateEventW(NULL, TRUE, FALSE, NULL);
5674 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5675 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
5676
5677 WSASetLastError(0xdeadbeef);
5678 ret = ioctlsocket(s, FIONBIO, (u_long *)1);
5679 ok(ret == -1, "expected failure\n");
5680 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5681
5682 WSASetLastError(0xdeadbeef);
5683 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, NULL, NULL, NULL);
5684 ok(ret == -1, "expected failure\n");
5685 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5686
5687 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one) - 1, NULL, 0, &size, &overlapped, NULL);
5688 ok(ret == -1, "expected failure\n");
5689 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5690
5691 size = 0xdeadbeef;
5692 WSASetLastError(0xdeadbeef);
5693 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, NULL, NULL);
5694 ok(!ret, "expected success\n");
5695 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5696 ok(!size, "got size %lu\n", size);
5697
5698 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one) + 1, NULL, 0, &size, NULL, NULL);
5699 ok(!ret, "got error %u\n", WSAGetLastError());
5700
5701 output = VirtualAlloc(NULL, 4, MEM_RESERVE | MEM_COMMIT, PAGE_NOACCESS);
5702 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one) + 1, output, 4, &size, NULL, NULL);
5703 ok(!ret, "got error %u\n", WSAGetLastError());
5704 VirtualFree(output, 0, MEM_FREE);
5705
5706 overlapped.Internal = 0xdeadbeef;
5707 overlapped.InternalHigh = 0xdeadbeef;
5708 size = 0xdeadbeef;
5709 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, &overlapped, NULL);
5710 ok(!ret, "expected success\n");
5711 ok(!size, "got size %lu\n", size);
5712
5713 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5714 ok(ret, "got error %lu\n", GetLastError());
5715 ok(!size, "got size %lu\n", size);
5716 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5717 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5718 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5719
5720 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, NULL, &overlapped, NULL);
5721 ok(ret == -1, "expected failure\n");
5722 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5723
5724 ret = WSAEventSelect(s, event, FD_READ);
5725 ok(!ret, "got error %u\n", WSAGetLastError());
5726
5727 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, NULL, NULL);
5728 ok(!ret, "got error %u\n", WSAGetLastError());
5729
5730 size = 0xdeadbeef;
5731 ret = WSAIoctl(s, FIONBIO, &zero, sizeof(zero), NULL, 0, &size, NULL, NULL);
5732 ok(ret == -1, "expected failure\n");
5733 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
5734 todo_wine ok(!size, "got size %lu\n", size);
5735
5736 CloseHandle(port);
5737 closesocket(s);
5738 CloseHandle(event);
5739
5740 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5741
5742 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, NULL, &overlapped, socket_apc);
5743 ok(ret == -1, "expected failure\n");
5744 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5745
5746 apc_count = 0;
5747 size = 0xdeadbeef;
5748 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, &overlapped, socket_apc);
5749 ok(!ret, "expected success\n");
5750 ok(!size, "got size %lu\n", size);
5751
5752 ret = SleepEx(0, TRUE);
5753 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5754 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5755 ok(!apc_error, "got APC error %lu\n", apc_error);
5756 ok(!apc_size, "got APC size %lu\n", apc_size);
5757 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5758
5759 closesocket(s);
5760 }
5761
5762 static void test_keepalive_vals(void)
5763 {
5764 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5765 struct tcp_keepalive kalive;
5766 ULONG_PTR key;
5767 HANDLE port;
5768 SOCKET sock;
5769 DWORD size;
5770 int ret;
5771
5772 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5773 ok(sock != INVALID_SOCKET, "Creating the socket failed: %d\n", WSAGetLastError());
5774 port = CreateIoCompletionPort((HANDLE)sock, NULL, 123, 0);
5775
5776 WSASetLastError(0xdeadbeef);
5777 size = 0xdeadbeef;
5778 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, 0, NULL, 0, &size, NULL, NULL);
5779 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5780 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5781 ok(!size, "got size %lu\n", size);
5782
5783 WSASetLastError(0xdeadbeef);
5784 size = 0xdeadbeef;
5785 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, NULL, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5786 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5787 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5788 ok(!size, "got size %lu\n", size);
5789
5790 WSASetLastError(0xdeadbeef);
5791 size = 0xdeadbeef;
5792 make_keepalive(kalive, 0, 0, 0);
5793 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5794 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5795 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5796 ok(!size, "got size %lu\n", size);
5797
5798 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, NULL, NULL, NULL);
5799 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5800 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5801
5802 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, NULL, &overlapped, NULL);
5803 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5804 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5805
5806 WSASetLastError(0xdeadbeef);
5807 size = 0xdeadbeef;
5808 overlapped.Internal = 0xdeadbeef;
5809 overlapped.InternalHigh = 0xdeadbeef;
5810 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive) - 1, NULL, 0, &size, &overlapped, NULL);
5811 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5812 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5813 ok(size == 0xdeadbeef, "got size %lu\n", size);
5814 todo_wine ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5815 ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
5816
5817 WSASetLastError(0xdeadbeef);
5818 size = 0xdeadbeef;
5819 overlapped.Internal = 0xdeadbeef;
5820 overlapped.InternalHigh = 0xdeadbeef;
5821 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, &overlapped, NULL);
5822 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5823 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5824 todo_wine ok(size == 0xdeadbeef, "got size %lu\n", size);
5825
5826 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5827 ok(ret, "got error %lu\n", GetLastError());
5828 ok(!size, "got size %lu\n", size);
5829 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5830 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5831 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5832
5833 make_keepalive(kalive, 1, 0, 0);
5834 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5835 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5836
5837 make_keepalive(kalive, 1, 1000, 1000);
5838 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5839 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5840
5841 make_keepalive(kalive, 1, 10000, 10000);
5842 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5843 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5844
5845 make_keepalive(kalive, 1, 100, 100);
5846 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5847 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5848
5849 make_keepalive(kalive, 0, 100, 100);
5850 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5851 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5852
5853 CloseHandle(port);
5854 closesocket(sock);
5855
5856 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5857
5858 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, NULL, &overlapped, socket_apc);
5859 ok(ret == -1, "expected failure\n");
5860 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5861
5862 apc_count = 0;
5863 size = 0xdeadbeef;
5864 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, &overlapped, socket_apc);
5865 ok(!ret, "expected success\n");
5866 ok(!size, "got size %lu\n", size);
5867
5868 ret = SleepEx(0, TRUE);
5869 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5870 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5871 ok(!apc_error, "got APC error %lu\n", apc_error);
5872 ok(!apc_size, "got APC size %lu\n", apc_size);
5873 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5874
5875 closesocket(sock);
5876 }
5877
5878 static void test_unsupported_ioctls(void)
5879 {
5880 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5881 unsigned int i;
5882 ULONG_PTR key;
5883 HANDLE port;
5884 DWORD size;
5885 SOCKET s;
5886 int ret;
5887
5888 static const DWORD codes[] = {0xdeadbeef, FIOASYNC, 0x667e, SIO_FLUSH};
5889
5890 for (i = 0; i < ARRAY_SIZE(codes); ++i)
5891 {
5892 winetest_push_context("ioctl %#lx", codes[i]);
5893 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5894 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
5895
5896 WSASetLastError(0xdeadbeef);
5897 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, NULL, &overlapped, NULL);
5898 ok(ret == -1, "expected failure\n");
5899 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5900
5901 WSASetLastError(0xdeadbeef);
5902 size = 0xdeadbeef;
5903 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, &size, NULL, NULL);
5904 ok(ret == -1, "expected failure\n");
5905 ok(WSAGetLastError() == WSAEOPNOTSUPP, "got error %u\n", WSAGetLastError());
5906 ok(!size, "got size %lu\n", size);
5907
5908 WSASetLastError(0xdeadbeef);
5909 size = 0xdeadbeef;
5910 overlapped.Internal = 0xdeadbeef;
5911 overlapped.InternalHigh = 0xdeadbeef;
5912 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, &size, &overlapped, NULL);
5913 ok(ret == -1, "expected failure\n");
5914 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
5915 ok(size == 0xdeadbeef, "got size %lu\n", size);
5916
5917 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5918 ok(!ret, "expected failure\n");
5919 ok(GetLastError() == ERROR_NOT_SUPPORTED, "got error %lu\n", GetLastError());
5920 ok(!size, "got size %lu\n", size);
5921 ok(key == 123, "got key %Iu\n", key);
5922 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5923 ok((NTSTATUS)overlapped.Internal == STATUS_NOT_SUPPORTED,
5924 "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5925 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5926
5927 CloseHandle(port);
5928 closesocket(s);
5929
5930 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5931
5932 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, NULL, &overlapped, socket_apc);
5933 ok(ret == -1, "expected failure\n");
5934 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5935
5936 apc_count = 0;
5937 size = 0xdeadbeef;
5938 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, &size, &overlapped, socket_apc);
5939 ok(ret == -1, "expected failure\n");
5940 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
5941 ok(size == 0xdeadbeef, "got size %lu\n", size);
5942
5943 ret = SleepEx(0, TRUE);
5944 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5945 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5946 ok(apc_error == WSAEOPNOTSUPP, "got APC error %lu\n", apc_error);
5947 ok(!apc_size, "got APC size %lu\n", apc_size);
5948 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5949
5950 closesocket(s);
5951 winetest_pop_context();
5952 }
5953 }
5954
5955 static void test_get_extension_func(void)
5956 {
5957 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5958 GUID acceptex_guid = WSAID_ACCEPTEX;
5959 GUID bogus_guid = {0xdeadbeef};
5960 ULONG_PTR key;
5961 HANDLE port;
5962 DWORD size;
5963 void *func;
5964 SOCKET s;
5965 int ret;
5966
5967 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5968 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
5969
5970 WSASetLastError(0xdeadbeef);
5971 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5972 &func, sizeof(func), NULL, &overlapped, NULL);
5973 ok(ret == -1, "expected failure\n");
5974 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5975
5976 WSASetLastError(0xdeadbeef);
5977 size = 0xdeadbeef;
5978 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5979 &func, sizeof(func), &size, NULL, NULL);
5980 ok(!ret, "expected success\n");
5981 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5982 ok(size == sizeof(func), "got size %lu\n", size);
5983
5984 WSASetLastError(0xdeadbeef);
5985 size = 0xdeadbeef;
5986 overlapped.Internal = 0xdeadbeef;
5987 overlapped.InternalHigh = 0xdeadbeef;
5988 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5989 &func, sizeof(func), &size, &overlapped, NULL);
5990 ok(!ret, "expected success\n");
5991 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5992 ok(size == sizeof(func), "got size %lu\n", size);
5993
5994 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5995 ok(ret, "got error %lu\n", GetLastError());
5996 ok(!size, "got size %lu\n", size);
5997 ok(key == 123, "got key %Iu\n", key);
5998 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5999 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
6000 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
6001
6002 size = 0xdeadbeef;
6003 overlapped.Internal = 0xdeadbeef;
6004 overlapped.InternalHigh = 0xdeadbeef;
6005 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &bogus_guid, sizeof(GUID),
6006 &func, sizeof(func), &size, &overlapped, NULL);
6007 ok(ret == -1, "expected failure\n");
6008 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
6009 ok(size == 0xdeadbeef, "got size %lu\n", size);
6010 ok(overlapped.Internal == 0xdeadbeef, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
6011 ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
6012
6013 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
6014 ok(!ret, "expected failure\n");
6015 ok(GetLastError() == WAIT_TIMEOUT, "got error %u\n", WSAGetLastError());
6016
6017 CloseHandle(port);
6018 closesocket(s);
6019
6020 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6021
6022 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
6023 &func, sizeof(func), NULL, &overlapped, socket_apc);
6024 ok(ret == -1, "expected failure\n");
6025 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
6026
6027 apc_count = 0;
6028 size = 0xdeadbeef;
6029 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
6030 &func, sizeof(func), &size, &overlapped, socket_apc);
6031 ok(!ret, "got error %u\n", WSAGetLastError());
6032 ok(size == sizeof(func), "got size %lu\n", size);
6033
6034 ret = SleepEx(0, TRUE);
6035 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
6036 ok(apc_count == 1, "APC was called %u times\n", apc_count);
6037 ok(!apc_error, "got APC error %lu\n", apc_error);
6038 ok(!apc_size, "got APC size %lu\n", apc_size);
6039 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
6040
6041 closesocket(s);
6042 }
6043
6044 static void test_backlog_query(void)
6045 {
6046 const struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
6047 GUID acceptex_guid = WSAID_ACCEPTEX;
6048 LPFN_ACCEPTEX pAcceptEx;
6049 struct sockaddr_in destaddr;
6050 DWORD size;
6051 SOCKET s, listener;
6052 int len, ret;
6053 ULONG backlog = 0;
6054
6055 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6056 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
6057
6058 ret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(acceptex_guid),
6059 &pAcceptEx, sizeof(pAcceptEx), &size, NULL, NULL);
6060 ok(!ret, "failed to get AcceptEx, error %u\n", WSAGetLastError());
6061
6062 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
6063 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6064 len = sizeof(destaddr);
6065 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
6066 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6067 ret = listen(listener, 2);
6068 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
6069
6070 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6071 ret = WSAIoctl(s, SIO_IDEAL_SEND_BACKLOG_QUERY, NULL, 0, &backlog, sizeof(backlog), &size, NULL, NULL);
6072 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTCONN,
6073 "WSAIoctl() failed: %d/%d\n", ret, WSAGetLastError());
6074
6075 ret = connect(s, (struct sockaddr *)&destaddr, sizeof(destaddr));
6076 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6077 ret = WSAIoctl(s, SIO_IDEAL_SEND_BACKLOG_QUERY, NULL, 0, &backlog, sizeof(backlog), &size, NULL, NULL);
6078 ok(!ret, "WSAIoctl() failed: %d\n", WSAGetLastError());
6079 ok(backlog == 0x10000, "got %08lx\n", backlog);
6080
6081 closesocket(listener);
6082 closesocket(s);
6083
6084 s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
6085
6086 backlog = 0;
6087 ret = WSAIoctl(s, SIO_IDEAL_SEND_BACKLOG_QUERY, NULL, 0, &backlog, sizeof(backlog), &size, NULL, NULL);
6088 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEOPNOTSUPP,
6089 "WSAIoctl() failed: %d/%d\n", ret, WSAGetLastError());
6090 closesocket(s);
6091 }
6092
6093 static void test_base_handle(void)
6094 {
6095 OVERLAPPED overlapped = {0}, *overlapped_ptr;
6096 unsigned int i;
6097 SOCKET s, base;
6098 ULONG_PTR key;
6099 HANDLE port;
6100 DWORD size;
6101 int ret;
6102
6103 static const struct
6104 {
6105 int family, type, protocol;
6106 }
6107 tests[] =
6108 {
6109 {AF_INET, SOCK_STREAM, IPPROTO_TCP},
6110 {AF_INET, SOCK_DGRAM, IPPROTO_UDP},
6111 {AF_INET6, SOCK_STREAM, IPPROTO_TCP},
6112 {AF_INET6, SOCK_DGRAM, IPPROTO_UDP},
6113 };
6114
6115 for (i = 0; i < ARRAY_SIZE(tests); ++i)
6116 {
6117 s = socket(tests[i].family, tests[i].type, tests[i].protocol);
6118 if (s == INVALID_SOCKET) continue;
6119 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
6120
6121 WSASetLastError(0xdeadbeef);
6122 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), NULL, &overlapped, NULL);
6123 ok(ret == -1, "expected failure\n");
6124 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
6125
6126 WSASetLastError(0xdeadbeef);
6127 size = 0xdeadbeef;
6128 base = 0xdeadbeef;
6129 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), &size, NULL, NULL);
6130 ok(!ret, "expected success\n");
6131 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
6132 ok(size == sizeof(base), "got size %lu\n", size);
6133 ok(base == s, "expected %#Ix, got %#Ix\n", s, base);
6134
6135 WSASetLastError(0xdeadbeef);
6136 size = 0xdeadbeef;
6137 base = 0xdeadbeef;
6138 overlapped.Internal = 0xdeadbeef;
6139 overlapped.InternalHigh = 0xdeadbeef;
6140 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), &size, &overlapped, NULL);
6141 ok(ret == -1, "expected failure\n");
6142 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
6143 ok(size == 0xdeadbeef, "got size %lu\n", size);
6144
6145 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
6146 ok(!ret, "expected failure\n");
6147 ok(GetLastError() == ERROR_NOT_SUPPORTED, "got error %lu\n", GetLastError());
6148 ok(!size, "got size %lu\n", size);
6149 ok(key == 123, "got key %Iu\n", key);
6150 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
6151 ok((NTSTATUS)overlapped.Internal == STATUS_NOT_SUPPORTED, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
6152 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
6153 ok(base == 0xdeadbeef, "expected %#Ix, got %#Ix\n", s, base);
6154
6155 CloseHandle(port);
6156 closesocket(s);
6157
6158 s = socket(tests[i].family, tests[i].type, tests[i].protocol);
6159
6160 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), NULL, &overlapped, socket_apc);
6161 ok(ret == -1, "expected failure\n");
6162 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
6163
6164 apc_count = 0;
6165 size = 0xdeadbeef;
6166 base = 0xdeadbeef;
6167 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), &size, &overlapped, socket_apc);
6168 ok(ret == -1, "expected failure\n");
6169 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
6170 ok(size == 0xdeadbeef, "got size %lu\n", size);
6171
6172 ret = SleepEx(0, TRUE);
6173 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
6174 ok(apc_count == 1, "APC was called %u times\n", apc_count);
6175 ok(apc_error == WSAEOPNOTSUPP, "got APC error %lu\n", apc_error);
6176 ok(!apc_size, "got APC size %lu\n", apc_size);
6177 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
6178 ok(base == 0xdeadbeef, "expected %#Ix, got %#Ix\n", s, base);
6179
6180 closesocket(s);
6181 }
6182 }
6183
6184 static void test_circular_queueing(void)
6185 {
6186 SOCKET s;
6187 DWORD size;
6188 int ret;
6189
6190 s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
6191 ret = WSAIoctl(s, SIO_ENABLE_CIRCULAR_QUEUEING, NULL, 0, NULL, 0, &size, NULL, NULL);
6192 ok(!ret, "expected 0, got %d\n", ret);
6193
6194 closesocket(s);
6195 }
6196
6197 static BOOL drain_pause = FALSE;
6198 static DWORD WINAPI drain_socket_thread(LPVOID arg)
6199 {
6200 char buffer[1024];
6201 SOCKET sock = *(SOCKET*)arg;
6202 int ret;
6203
6204 while ((ret = recv(sock, buffer, sizeof(buffer), 0)) != 0)
6205 {
6206 if (ret < 0)
6207 {
6208 if (WSAGetLastError() == WSAEWOULDBLOCK)
6209 {
6210 fd_set readset;
6211 FD_ZERO(&readset);
6212 FD_SET(sock, &readset);
6213 select(sock+1, &readset, NULL, NULL, NULL);
6214 while (drain_pause)
6215 Sleep(100);
6216 }
6217 else
6218 break;
6219 }
6220 }
6221 return 0;
6222 }
6223
6224 static void test_send(void)
6225 {
6226 SOCKET src = INVALID_SOCKET;
6227 SOCKET dst = INVALID_SOCKET;
6228 HANDLE hThread = NULL;
6229 const int buflen = 1024*1024;
6230 char *buffer = NULL;
6231 int ret, i, zero = 0;
6232 WSABUF buf;
6233 OVERLAPPED ov;
6234 BOOL bret;
6235 DWORD id, bytes_sent, dwRet;
6236
6237 memset(&ov, 0, sizeof(ov));
6238
6239 tcp_socketpair(&src, &dst);
6240
6241 set_blocking(dst, FALSE);
6242 /* force disable buffering so we can get a pending overlapped request */
6243 ret = setsockopt(dst, SOL_SOCKET, SO_SNDBUF, (char *) &zero, sizeof(zero));
6244 ok(!ret, "setsockopt SO_SNDBUF failed: %d - %ld\n", ret, GetLastError());
6245
6246 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
6247
6248 buffer = malloc(buflen);
6249
6250 /* fill the buffer with some nonsense */
6251 for (i = 0; i < buflen; ++i)
6252 {
6253 buffer[i] = (char) i;
6254 }
6255
6256 ret = send(src, buffer, buflen, 0);
6257 ok(ret == buflen, "send should have sent %d bytes, but it only sent %d\n", buflen, ret);
6258
6259 buf.buf = buffer;
6260 buf.len = buflen;
6261
6262 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
6263 ok(ov.hEvent != NULL, "could not create event object, errno = %ld\n", GetLastError());
6264 if (!ov.hEvent)
6265 goto end;
6266
6267 bytes_sent = 0;
6268 WSASetLastError(12345);
6269 ret = WSASend(dst, &buf, 1, &bytes_sent, 0, &ov, NULL);
6270 ok(ret == SOCKET_ERROR, "expected failure\n");
6271 ok(WSAGetLastError() == ERROR_IO_PENDING, "wrong error %u\n", WSAGetLastError());
6272
6273 /* don't check for completion yet, we may need to drain the buffer while still sending */
6274 set_blocking(src, FALSE);
6275 for (i = 0; i < buflen; ++i)
6276 {
6277 int j = 0;
6278
6279 ret = recv(src, buffer, 1, 0);
6280 while (ret == SOCKET_ERROR && GetLastError() == WSAEWOULDBLOCK && j < 100)
6281 {
6282 j++;
6283 Sleep(50);
6284 ret = recv(src, buffer, 1, 0);
6285 }
6286
6287 ok(ret == 1, "Failed to receive data %d - %ld (got %d/%d)\n", ret, GetLastError(), i, buflen);
6288 if (ret != 1)
6289 break;
6290
6291 ok(buffer[0] == (char) i, "Received bad data at position %d\n", i);
6292 }
6293
6294 dwRet = WaitForSingleObject(ov.hEvent, 1000);
6295 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %ld - %ld\n", dwRet, GetLastError());
6296 if (dwRet == WAIT_OBJECT_0)
6297 {
6298 bret = GetOverlappedResult((HANDLE)dst, &ov, &bytes_sent, FALSE);
6299 ok(bret && bytes_sent == buflen,
6300 "Got %ld instead of %d (%d - %ld)\n", bytes_sent, buflen, bret, GetLastError());
6301 }
6302
6303 WSASetLastError(12345);
6304 ret = WSASend(INVALID_SOCKET, &buf, 1, NULL, 0, &ov, NULL);
6305 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
6306 "WSASend failed %d - %d\n", ret, WSAGetLastError());
6307
6308 WSASetLastError(12345);
6309 ret = WSASend(dst, &buf, 1, NULL, 0, &ov, NULL);
6310 ok(ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING,
6311 "Failed to start overlapped send %d - %d\n", ret, WSAGetLastError());
6312
6313 end:
6314 if (src != INVALID_SOCKET)
6315 closesocket(src);
6316 if (dst != INVALID_SOCKET)
6317 closesocket(dst);
6318 if (hThread != NULL)
6319 {
6320 dwRet = WaitForSingleObject(hThread, 500);
6321 ok(dwRet == WAIT_OBJECT_0, "failed to wait for thread termination: %ld\n", GetLastError());
6322 CloseHandle(hThread);
6323 }
6324 if (ov.hEvent)
6325 CloseHandle(ov.hEvent);
6326 free(buffer);
6327 }
6328
6329 #define WM_SOCKET (WM_USER+100)
6330
6331 struct event_test_ctx
6332 {
6333 int is_message;
6334 SOCKET socket;
6335 HANDLE event;
6336 HWND window;
6337 };
6338
6339 static void select_events(struct event_test_ctx *ctx, SOCKET socket, LONG events)
6340 {
6341 int ret;
6342
6343 if (ctx->is_message)
6344 ret = WSAAsyncSelect(socket, ctx->window, WM_USER, events);
6345 else
6346 ret = WSAEventSelect(socket, ctx->event, events);
6347 ok(!ret, "failed to select, error %u\n", WSAGetLastError());
6348 ctx->socket = socket;
6349 }
6350
6351 #define check_events(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, FALSE)
6352 #define check_events_todo(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, TRUE)
6353 #define check_events_todo_event(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, FALSE)
6354 #define check_events_todo_msg(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, TRUE)
6355 static void check_events_(int line, struct event_test_ctx *ctx,
6356 LONG flag1, LONG flag2, DWORD timeout, BOOL todo_event, BOOL todo_msg)
6357 {
6358 int ret;
6359
6360 if (ctx->is_message)
6361 {
6362 BOOL any_fail = FALSE;
6363 MSG msg;
6364
6365 if (flag1)
6366 {
6367 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6368 while (!ret && !MsgWaitForMultipleObjects(0, NULL, FALSE, timeout, QS_POSTMESSAGE))
6369 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6370 todo_wine_if (todo_msg && !ret) ok_(__FILE__, line)(ret, "expected a message\n");
6371 if (ret)
6372 {
6373 ok_(__FILE__, line)(msg.wParam == ctx->socket,
6374 "expected wparam %#Ix, got %#Ix\n", ctx->socket, msg.wParam);
6375 todo_wine_if (todo_msg && msg.lParam != flag1)
6376 ok_(__FILE__, line)(msg.lParam == flag1, "got first event %#Ix\n", msg.lParam);
6377 if (msg.lParam != flag1) any_fail = TRUE;
6378 }
6379 else
6380 any_fail = TRUE;
6381 }
6382 if (flag2)
6383 {
6384 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6385 while (!ret && !MsgWaitForMultipleObjects(0, NULL, FALSE, timeout, QS_POSTMESSAGE))
6386 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6387 ok_(__FILE__, line)(ret, "expected a message\n");
6388 ok_(__FILE__, line)(msg.wParam == ctx->socket, "got wparam %#Ix\n", msg.wParam);
6389 todo_wine_if (todo_msg) ok_(__FILE__, line)(msg.lParam == flag2, "got second event %#Ix\n", msg.lParam);
6390 }
6391 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6392 todo_wine_if (todo_msg && ret) ok_(__FILE__, line)(!ret, "got unexpected event %#Ix\n", msg.lParam);
6393 if (ret) any_fail = TRUE;
6394
6395 /* catch tests which succeed */
6396 todo_wine_if (todo_msg) ok_(__FILE__, line)(!any_fail, "event series matches\n");
6397 }
6398 else
6399 {
6400 WSANETWORKEVENTS events;
6401 unsigned int i;
6402
6403 memset(&events, 0xcc, sizeof(events));
6404 ret = WaitForSingleObject(ctx->event, timeout);
6405 if (flag1 | flag2)
6406 todo_wine_if (todo_event && ret) ok_(__FILE__, line)(!ret, "event wait timed out\n");
6407 else
6408 todo_wine_if (todo_event) ok_(__FILE__, line)(ret == WAIT_TIMEOUT, "expected timeout\n");
6409 ret = WSAEnumNetworkEvents(ctx->socket, ctx->event, &events);
6410 ok_(__FILE__, line)(!ret, "failed to get events, error %u\n", WSAGetLastError());
6411 todo_wine_if (todo_event)
6412 ok_(__FILE__, line)(events.lNetworkEvents == LOWORD(flag1 | flag2), "got events %#lx\n", events.lNetworkEvents);
6413 for (i = 0; i < ARRAY_SIZE(events.iErrorCode); ++i)
6414 {
6415 if ((1u << i) == LOWORD(flag1) && (events.lNetworkEvents & LOWORD(flag1)))
6416 ok_(__FILE__, line)(events.iErrorCode[i] == HIWORD(flag1),
6417 "got error code %d for event %#x\n", events.iErrorCode[i], 1u << i);
6418 if ((1u << i) == LOWORD(flag2) && (events.lNetworkEvents & LOWORD(flag2)))
6419 ok_(__FILE__, line)(events.iErrorCode[i] == HIWORD(flag2),
6420 "got error code %d for event %#x\n", events.iErrorCode[i], 1u << i);
6421 }
6422 }
6423 }
6424
6425 static void test_accept_events(struct event_test_ctx *ctx)
6426 {
6427 const struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
6428 SOCKET listener, server, client, client2;
6429 GUID acceptex_guid = WSAID_ACCEPTEX;
6430 struct sockaddr_in destaddr;
6431 OVERLAPPED overlapped = {0};
6432 LPFN_ACCEPTEX pAcceptEx;
6433 char buffer[32];
6434 int len, ret;
6435 DWORD size;
6436
6437 overlapped.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
6438
6439 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6440 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
6441
6442 ret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(acceptex_guid),
6443 &pAcceptEx, sizeof(pAcceptEx), &size, NULL, NULL);
6444 ok(!ret, "failed to get AcceptEx, error %u\n", WSAGetLastError());
6445
6446 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6447
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 check_events(ctx, 0, 0, 0);
6457
6458 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6459 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6460 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6461 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6462
6463 check_events(ctx, FD_ACCEPT, 0, 200);
6464 check_events(ctx, 0, 0, 0);
6465 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6466 if (ctx->is_message)
6467 check_events(ctx, FD_ACCEPT, 0, 200);
6468 check_events(ctx, 0, 0, 0);
6469 select_events(ctx, listener, 0);
6470 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6471 if (ctx->is_message)
6472 check_events(ctx, FD_ACCEPT, 0, 200);
6473 check_events(ctx, 0, 0, 0);
6474
6475 client2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6476 ok(client2 != -1, "failed to create socket, error %u\n", WSAGetLastError());
6477 ret = connect(client2, (struct sockaddr *)&destaddr, sizeof(destaddr));
6478 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6479
6480 if (!ctx->is_message)
6481 check_events_todo(ctx, FD_ACCEPT, 0, 200);
6482 check_events(ctx, 0, 0, 0);
6483
6484 server = accept(listener, NULL, NULL);
6485 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6486 closesocket(server);
6487
6488 check_events(ctx, FD_ACCEPT, 0, 200);
6489 check_events(ctx, 0, 0, 0);
6490
6491 server = accept(listener, NULL, NULL);
6492 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6493 closesocket(server);
6494
6495 check_events(ctx, 0, 0, 0);
6496
6497 closesocket(client2);
6498 closesocket(client);
6499
6500 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6501 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6502 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6503 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6504
6505 check_events(ctx, FD_ACCEPT, 0, 200);
6506
6507 server = accept(listener, NULL, NULL);
6508 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6509 closesocket(server);
6510 closesocket(client);
6511
6512 check_events(ctx, 0, 0, 200);
6513
6514 closesocket(listener);
6515
6516 /* Connect and then select. */
6517
6518 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6519 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
6520 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
6521 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6522 len = sizeof(destaddr);
6523 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
6524 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6525 ret = listen(listener, 2);
6526 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
6527
6528 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6529 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6530 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6531 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6532
6533 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6534
6535 check_events(ctx, FD_ACCEPT, 0, 200);
6536
6537 server = accept(listener, NULL, NULL);
6538 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6539 closesocket(server);
6540 closesocket(client);
6541
6542 /* As above, but select on a subset containing FD_ACCEPT first. */
6543
6544 if (!ctx->is_message)
6545 {
6546 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6547
6548 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6549 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6550 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6551 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6552
6553 ret = WaitForSingleObject(ctx->event, 200);
6554 ok(!ret, "wait timed out\n");
6555
6556 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
6557 ret = WaitForSingleObject(ctx->event, 0);
6558 ok(!ret, "wait timed out\n");
6559
6560 ResetEvent(ctx->event);
6561
6562 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
6563 ret = WaitForSingleObject(ctx->event, 0);
6564 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
6565
6566 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6567 ret = WaitForSingleObject(ctx->event, 0);
6568 ok(!ret, "wait timed out\n");
6569 check_events(ctx, FD_ACCEPT, 0, 0);
6570
6571 server = accept(listener, NULL, NULL);
6572 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6573 closesocket(server);
6574 closesocket(client);
6575 }
6576
6577 /* As above, but select on a subset not containing FD_ACCEPT first. */
6578
6579 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
6580
6581 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6582 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6583 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6584 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6585
6586 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6587 check_events(ctx, FD_ACCEPT, 0, 200);
6588
6589 server = accept(listener, NULL, NULL);
6590 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6591 closesocket(server);
6592 closesocket(client);
6593
6594 /* As above, but call accept() before selecting. */
6595
6596 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
6597
6598 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6599 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6600 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6601 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6602 Sleep(200);
6603 server = accept(listener, NULL, NULL);
6604 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6605
6606 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6607 check_events(ctx, 0, 0, 200);
6608
6609 closesocket(server);
6610 closesocket(client);
6611
6612 closesocket(listener);
6613
6614 /* The socket returned from accept() inherits the same parameters. */
6615
6616 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6617 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
6618 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
6619 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6620 len = sizeof(destaddr);
6621 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
6622 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6623 ret = listen(listener, 2);
6624 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
6625
6626 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6627 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6628 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6629 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6630
6631 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT | FD_WRITE);
6632 check_events(ctx, FD_ACCEPT, 0, 200);
6633
6634 server = accept(listener, NULL, NULL);
6635 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6636 ctx->socket = server;
6637 check_events(ctx, FD_WRITE, 0, 200);
6638 check_events(ctx, 0, 0, 0);
6639
6640 closesocket(server);
6641 closesocket(client);
6642
6643 /* Connect while there is a pending AcceptEx(). */
6644
6645 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6646
6647 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6648 ret = pAcceptEx(listener, server, buffer, 0, 0, sizeof(buffer), NULL, &overlapped);
6649 ok(!ret, "got %d\n", ret);
6650 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
6651
6652 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6653 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6654 ok(!ret, "got error %u\n", WSAGetLastError());
6655
6656 ret = WaitForSingleObject(overlapped.hEvent, 200);
6657 ok(!ret, "got %d\n", ret);
6658 ret = GetOverlappedResult((HANDLE)listener, &overlapped, &size, FALSE);
6659 ok(ret, "got error %lu\n", GetLastError());
6660 ok(!size, "got size %lu\n", size);
6661
6662 check_events(ctx, 0, 0, 0);
6663
6664 closesocket(server);
6665 closesocket(client);
6666
6667 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6668 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6669 ok(!ret, "got error %u\n", WSAGetLastError());
6670
6671 check_events(ctx, FD_ACCEPT, 0, 200);
6672 check_events(ctx, 0, 0, 0);
6673
6674 server = accept(listener, NULL, NULL);
6675 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6676 closesocket(server);
6677 closesocket(client);
6678
6679 closesocket(listener);
6680 CloseHandle(overlapped.hEvent);
6681 }
6682
6683 static void test_connect_events(struct event_test_ctx *ctx)
6684 {
6685 const struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
6686 SOCKET listener, server, client;
6687 struct sockaddr_in destaddr;
6688 int len, ret;
6689
6690 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6691 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
6692 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
6693 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6694 len = sizeof(destaddr);
6695 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
6696 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6697 ret = listen(listener, 2);
6698 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
6699
6700 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6701 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6702
6703 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6704 check_events(ctx, 0, 0, 0);
6705
6706 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6707 ok(!ret || WSAGetLastError() == WSAEWOULDBLOCK, "failed to connect, error %u\n", WSAGetLastError());
6708
6709 check_events(ctx, FD_CONNECT, FD_WRITE, 200);
6710 check_events(ctx, 0, 0, 0);
6711 select_events(ctx, client, 0);
6712 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6713 if (ctx->is_message)
6714 check_events(ctx, FD_WRITE, 0, 200);
6715 check_events(ctx, 0, 0, 0);
6716
6717 server = accept(listener, NULL, NULL);
6718 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6719
6720 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6721 check_events(ctx, FD_WRITE, 0, 200);
6722
6723 closesocket(client);
6724 closesocket(server);
6725
6726 /* Connect and then select. */
6727
6728 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6729 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6730
6731 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6732 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6733
6734 server = accept(listener, NULL, NULL);
6735 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6736
6737 ret = send(client, "data", 5, 0);
6738 ok(ret == 5, "got %d\n", ret);
6739
6740 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6741 if (ctx->is_message)
6742 check_events(ctx, FD_WRITE, 0, 200);
6743 else
6744 check_events(ctx, FD_CONNECT, FD_WRITE, 200);
6745
6746 closesocket(client);
6747 closesocket(server);
6748
6749 /* As above, but select on a subset not containing FD_CONNECT first. */
6750
6751 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6752 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6753
6754 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_OOB | FD_READ | FD_WRITE);
6755
6756 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6757 ok(!ret || WSAGetLastError() == WSAEWOULDBLOCK, "failed to connect, error %u\n", WSAGetLastError());
6758
6759 server = accept(listener, NULL, NULL);
6760 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6761
6762 check_events(ctx, FD_WRITE, 0, 200);
6763
6764 select_events(ctx, client, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6765
6766 if (ctx->is_message)
6767 check_events(ctx, FD_WRITE, 0, 200);
6768 else
6769 check_events(ctx, FD_CONNECT, 0, 200);
6770
6771 closesocket(client);
6772 closesocket(server);
6773
6774 /* Test with UDP sockets. */
6775
6776 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
6777 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
6778
6779 select_events(ctx, client, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6780 if (ctx->is_message)
6781 check_events(ctx, FD_WRITE, 0, 200);
6782 check_events_todo_event(ctx, 0, 0, 0);
6783
6784 ret = bind(server, (const struct sockaddr *)&addr, sizeof(addr));
6785 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6786 len = sizeof(destaddr);
6787 ret = getsockname(server, (struct sockaddr *)&destaddr, &len);
6788 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6789 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
6790 ok(!ret, "got error %lu\n", GetLastError());
6791
6792 if (ctx->is_message)
6793 check_events_todo(ctx, FD_WRITE, 0, 200);
6794 else
6795 check_events_todo(ctx, FD_CONNECT, FD_WRITE, 200);
6796 check_events(ctx, 0, 0, 0);
6797
6798 closesocket(client);
6799 closesocket(server);
6800
6801 closesocket(listener);
6802 }
6803
6804 /* perform a blocking recv() even on a nonblocking socket */
6805 static int sync_recv(SOCKET s, void *buffer, int len, DWORD flags)
6806 {
6807 OVERLAPPED overlapped = {0};
6808 WSABUF wsabuf;
6809 DWORD ret_len;
6810 int ret;
6811
6812 overlapped.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
6813 wsabuf.buf = buffer;
6814 wsabuf.len = len;
6815 ret = WSARecv(s, &wsabuf, 1, &ret_len, &flags, &overlapped, NULL);
6816 if (ret == -1 && WSAGetLastError() == ERROR_IO_PENDING)
6817 {
6818 ret = WaitForSingleObject(overlapped.hEvent, 1000);
6819 ok(!ret, "wait timed out\n");
6820 ret = WSAGetOverlappedResult(s, &overlapped, &ret_len, FALSE, &flags);
6821 ret = (ret ? 0 : -1);
6822 }
6823 CloseHandle(overlapped.hEvent);
6824 if (!ret) return ret_len;
6825 return -1;
6826 }
6827
6828 static void test_write_events(struct event_test_ctx *ctx)
6829 {
6830 static const int buffer_size = 1024 * 1024;
6831 SOCKET server, client;
6832 char *buffer;
6833 int ret;
6834
6835 buffer = malloc(buffer_size);
6836
6837 tcp_socketpair(&client, &server);
6838 set_blocking(client, FALSE);
6839
6840 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6841 check_events(ctx, FD_WRITE, 0, 200);
6842 check_events(ctx, 0, 0, 0);
6843 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6844 if (ctx->is_message)
6845 check_events(ctx, FD_WRITE, 0, 200);
6846 check_events(ctx, 0, 0, 0);
6847 select_events(ctx, server, 0);
6848 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6849 if (ctx->is_message)
6850 check_events(ctx, FD_WRITE, 0, 200);
6851 check_events(ctx, 0, 0, 0);
6852
6853 ret = send(server, "data", 5, 0);
6854 ok(ret == 5, "got %d\n", ret);
6855
6856 check_events(ctx, 0, 0, 0);
6857
6858 ret = sync_recv(client, buffer, buffer_size, 0);
6859 ok(ret == 5, "got %d\n", ret);
6860
6861 check_events(ctx, 0, 0, 0);
6862
6863 if (!broken(1))
6864 {
6865 /* Windows will never send less than buffer_size bytes here, but Linux
6866 * may do a short write. */
6867 while ((ret = send(server, buffer, buffer_size, 0)) > 0);
6868 ok(ret == -1, "got %d\n", ret);
6869 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
6870
6871 while (recv(client, buffer, buffer_size, 0) > 0);
6872 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
6873
6874 /* Broken on Windows versions older than win10v1607 (though sometimes
6875 * works regardless, for unclear reasons. */
6876 check_events(ctx, FD_WRITE, 0, 200);
6877 check_events(ctx, 0, 0, 0);
6878 select_events(ctx, server, 0);
6879 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6880 if (ctx->is_message)
6881 check_events(ctx, FD_WRITE, 0, 200);
6882 check_events(ctx, 0, 0, 0);
6883 }
6884
6885 closesocket(server);
6886 closesocket(client);
6887
6888 /* Select on a subset not containing FD_WRITE first. */
6889
6890 tcp_socketpair(&client, &server);
6891 set_blocking(client, FALSE);
6892
6893 ret = send(client, "data", 5, 0);
6894 ok(ret == 5, "got %d\n", ret);
6895
6896 select_events(ctx, client, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ);
6897 if (!ctx->is_message)
6898 check_events(ctx, FD_CONNECT, 0, 200);
6899 check_events(ctx, 0, 0, 0);
6900
6901 select_events(ctx, client, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6902 check_events(ctx, FD_WRITE, 0, 200);
6903 check_events(ctx, 0, 0, 0);
6904
6905 closesocket(client);
6906 closesocket(server);
6907
6908 /* Despite the documentation, and unlike FD_ACCEPT and FD_RECV, calling
6909 * send() doesn't clear the FD_WRITE bit. */
6910
6911 tcp_socketpair(&client, &server);
6912
6913 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6914
6915 ret = send(server, "data", 5, 0);
6916 ok(ret == 5, "got %d\n", ret);
6917
6918 check_events(ctx, FD_WRITE, 0, 200);
6919
6920 closesocket(server);
6921 closesocket(client);
6922
6923 free(buffer);
6924 }
6925
6926 static void test_read_events(struct event_test_ctx *ctx)
6927 {
6928 OVERLAPPED overlapped = {0};
6929 SOCKET server, client;
6930 DWORD size, flags = 0;
6931 WSAPOLLFD pollfd;
6932 unsigned int i;
6933 char buffer[8];
6934 WSABUF wsabuf;
6935 HANDLE thread;
6936 int ret;
6937
6938 overlapped.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
6939
6940 tcp_socketpair(&client, &server);
6941 set_blocking(client, FALSE);
6942
6943 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6944 check_events(ctx, 0, 0, 0);
6945
6946 ret = send(client, "data", 5, 0);
6947 ok(ret == 5, "got %d\n", ret);
6948
6949 check_events(ctx, FD_READ, 0, 200);
6950 check_events(ctx, 0, 0, 0);
6951 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6952 if (ctx->is_message)
6953 check_events(ctx, FD_READ, 0, 200);
6954 check_events(ctx, 0, 0, 0);
6955 select_events(ctx, server, 0);
6956 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6957 if (ctx->is_message)
6958 check_events(ctx, FD_READ, 0, 200);
6959 check_events(ctx, 0, 0, 0);
6960
6961 ret = send(client, "data", 5, 0);
6962 ok(ret == 5, "got %d\n", ret);
6963
6964 if (!ctx->is_message)
6965 check_events_todo(ctx, FD_READ, 0, 200);
6966 check_events(ctx, 0, 0, 0);
6967
6968 ret = recv(server, buffer, 2, 0);
6969 ok(ret == 2, "got %d\n", ret);
6970
6971 check_events(ctx, FD_READ, 0, 200);
6972 check_events(ctx, 0, 0, 0);
6973
6974 ret = recv(server, buffer, -1, 0);
6975 ok(ret == -1, "got %d\n", ret);
6976 ok(WSAGetLastError() == WSAEFAULT || WSAGetLastError() == WSAENOBUFS /* < Windows 7 */,
6977 "got error %u\n", WSAGetLastError());
6978
6979 if (ctx->is_message)
6980 check_events_todo_msg(ctx, FD_READ, 0, 200);
6981 check_events(ctx, 0, 0, 0);
6982
6983 for (i = 0; i < 8; ++i)
6984 {
6985 ret = sync_recv(server, buffer, 1, 0);
6986 ok(ret == 1, "got %d\n", ret);
6987
6988 if (i < 7)
6989 check_events(ctx, FD_READ, 0, 200);
6990 check_events(ctx, 0, 0, 0);
6991 }
6992
6993 /* Send data while we're not selecting. */
6994
6995 select_events(ctx, server, 0);
6996 ret = send(client, "data", 5, 0);
6997 ok(ret == 5, "got %d\n", ret);
6998 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6999
7000 check_events(ctx, FD_READ, 0, 200);
7001
7002 ret = recv(server, buffer, 5, 0);
7003 ok(ret == 5, "got %d\n", ret);
7004
7005 select_events(ctx, server, 0);
7006 ret = send(client, "data", 5, 0);
7007 ok(ret == 5, "got %d\n", ret);
7008 ret = sync_recv(server, buffer, 5, 0);
7009 ok(ret == 5, "got %d\n", ret);
7010 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ);
7011
7012 check_events(ctx, 0, 0, 200);
7013
7014 /* Send data while we're polling for data but not selecting for FD_READ. */
7015
7016 pollfd.fd = server;
7017 pollfd.events = POLLIN;
7018 thread = CreateThread(NULL, 0, poll_async_thread, &pollfd, 0, NULL);
7019
7020 select_events(ctx, server, 0);
7021 ret = send(client, "data", 5, 0);
7022 ok(ret == 5, "got %d\n", ret);
7023
7024 ret = WaitForSingleObject(thread, 1000);
7025 ok(!ret, "wait timed out\n");
7026 CloseHandle(thread);
7027
7028 /* And check events, to show that WSAEnumNetworkEvents() should not clear
7029 * events we are not currently selecting for. */
7030 check_events(ctx, 0, 0, 0);
7031
7032 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
7033 check_events(ctx, FD_READ, FD_WRITE, 200);
7034 check_events(ctx, 0, 0, 0);
7035
7036 ret = sync_recv(server, buffer, 5, 0);
7037 ok(ret == 5, "got %d\n", ret);
7038
7039 /* Send data while there is a pending WSARecv(). */
7040
7041 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7042
7043 wsabuf.buf = buffer;
7044 wsabuf.len = 1;
7045 ret = WSARecv(server, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
7046 ok(ret == -1, "got %d\n", ret);
7047 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
7048
7049 ret = send(client, "a", 1, 0);
7050 ok(ret == 1, "got %d\n", ret);
7051
7052 ret = WaitForSingleObject(overlapped.hEvent, 200);
7053 ok(!ret, "got %d\n", ret);
7054 ret = GetOverlappedResult((HANDLE)server, &overlapped, &size, FALSE);
7055 ok(ret, "got error %lu\n", GetLastError());
7056 ok(size == 1, "got size %lu\n", size);
7057
7058 check_events(ctx, 0, 0, 0);
7059
7060 ret = send(client, "a", 1, 0);
7061 ok(ret == 1, "got %d\n", ret);
7062
7063 check_events(ctx, FD_READ, 0, 200);
7064 check_events(ctx, 0, 0, 0);
7065
7066 closesocket(server);
7067 closesocket(client);
7068 CloseHandle(overlapped.hEvent);
7069 }
7070
7071 static void test_oob_events(struct event_test_ctx *ctx)
7072 {
7073 SOCKET server, client;
7074 char buffer[1];
7075 int ret;
7076
7077 tcp_socketpair(&client, &server);
7078 set_blocking(client, FALSE);
7079
7080 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7081 check_events(ctx, 0, 0, 0);
7082
7083 ret = send(client, "a", 1, MSG_OOB);
7084 ok(ret == 1, "got %d\n", ret);
7085
7086 check_events(ctx, FD_OOB, 0, 200);
7087 check_events(ctx, 0, 0, 0);
7088 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7089 if (ctx->is_message)
7090 check_events(ctx, FD_OOB, 0, 200);
7091 check_events(ctx, 0, 0, 0);
7092 select_events(ctx, server, 0);
7093 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7094 if (ctx->is_message)
7095 check_events(ctx, FD_OOB, 0, 200);
7096 check_events(ctx, 0, 0, 0);
7097
7098 ret = send(client, "b", 1, MSG_OOB);
7099 ok(ret == 1, "got %d\n", ret);
7100
7101 if (!ctx->is_message)
7102 check_events_todo_event(ctx, FD_OOB, 0, 200);
7103 check_events(ctx, 0, 0, 0);
7104
7105 ret = recv(server, buffer, 1, MSG_OOB);
7106 ok(ret == 1, "got %d\n", ret);
7107
7108 check_events_todo(ctx, FD_OOB, 0, 200);
7109 check_events(ctx, 0, 0, 0);
7110
7111 ret = recv(server, buffer, 1, MSG_OOB);
7112 todo_wine ok(ret == 1, "got %d\n", ret);
7113
7114 check_events(ctx, 0, 0, 0);
7115
7116 /* Send data while we're not selecting. */
7117
7118 select_events(ctx, server, 0);
7119 ret = send(client, "a", 1, MSG_OOB);
7120 ok(ret == 1, "got %d\n", ret);
7121 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7122
7123 check_events(ctx, FD_OOB, 0, 200);
7124
7125 ret = recv(server, buffer, 1, MSG_OOB);
7126 ok(ret == 1, "got %d\n", ret);
7127
7128 closesocket(server);
7129 closesocket(client);
7130 }
7131
7132 static void test_close_events(struct event_test_ctx *ctx)
7133 {
7134 SOCKET server, client;
7135 char buffer[5];
7136 int ret;
7137
7138 /* Test closesocket(). */
7139
7140 tcp_socketpair(&client, &server);
7141
7142 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7143
7144 closesocket(client);
7145
7146 check_events(ctx, FD_CLOSE, 0, 1000);
7147 check_events(ctx, 0, 0, 0);
7148 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7149 if (ctx->is_message)
7150 check_events(ctx, FD_CLOSE, 0, 200);
7151 check_events(ctx, 0, 0, 0);
7152 select_events(ctx, server, 0);
7153 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7154 if (ctx->is_message)
7155 check_events(ctx, FD_CLOSE, 0, 200);
7156 check_events(ctx, 0, 0, 0);
7157
7158 ret = recv(server, buffer, 5, 0);
7159 ok(!ret, "got %d\n", ret);
7160
7161 check_events(ctx, 0, 0, 0);
7162
7163 closesocket(server);
7164
7165 /* Test shutdown(remote end, SD_SEND). */
7166
7167 tcp_socketpair(&client, &server);
7168
7169 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7170
7171 shutdown(client, SD_SEND);
7172
7173 check_events(ctx, FD_CLOSE, 0, 1000);
7174 check_events(ctx, 0, 0, 0);
7175
7176 closesocket(client);
7177
7178 check_events(ctx, 0, 0, 0);
7179
7180 closesocket(server);
7181
7182 /* No other shutdown() call generates an event. */
7183
7184 tcp_socketpair(&client, &server);
7185
7186 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7187
7188 shutdown(client, SD_RECEIVE);
7189 shutdown(server, SD_BOTH);
7190
7191 check_events(ctx, 0, 0, 200);
7192
7193 shutdown(client, SD_SEND);
7194
7195 check_events_todo(ctx, FD_CLOSE, 0, 200);
7196 check_events(ctx, 0, 0, 0);
7197
7198 closesocket(server);
7199 closesocket(client);
7200
7201 /* Test sending data before calling closesocket(). */
7202
7203 tcp_socketpair(&client, &server);
7204
7205 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7206
7207 ret = send(client, "data", 5, 0);
7208 ok(ret == 5, "got %d\n", ret);
7209
7210 check_events(ctx, FD_READ, 0, 200);
7211
7212 closesocket(client);
7213
7214 check_events_todo(ctx, FD_CLOSE, 0, 200);
7215
7216 ret = recv(server, buffer, 3, 0);
7217 ok(ret == 3, "got %d\n", ret);
7218
7219 check_events(ctx, FD_READ, 0, 200);
7220
7221 ret = recv(server, buffer, 5, 0);
7222 ok(ret == 2, "got %d\n", ret);
7223
7224 check_events_todo(ctx, 0, 0, !strcmp(winetest_platform, "wine") ? 200 : 0);
7225
7226 closesocket(server);
7227
7228 /* Close and then select. */
7229
7230 tcp_socketpair(&client, &server);
7231 closesocket(client);
7232
7233 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7234 check_events(ctx, FD_CLOSE, 0, 200);
7235
7236 closesocket(server);
7237
7238 /* As above, but select on a subset not containing FD_CLOSE first. */
7239
7240 tcp_socketpair(&client, &server);
7241
7242 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ);
7243
7244 closesocket(client);
7245
7246 check_events(ctx, 0, 0, 200);
7247 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7248 check_events(ctx, FD_CLOSE, 0, 200);
7249
7250 closesocket(server);
7251
7252 /* Trigger RST. */
7253
7254 tcp_socketpair(&client, &server);
7255
7256 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7257
7258 close_with_rst(client);
7259
7260 check_events(ctx, MAKELONG(FD_CLOSE, WSAECONNABORTED), 0, 200);
7261 check_events(ctx, 0, 0, 0);
7262 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7263 if (ctx->is_message)
7264 check_events_todo(ctx, MAKELONG(FD_CLOSE, WSAECONNABORTED), 0, 200);
7265 check_events(ctx, 0, 0, 0);
7266 select_events(ctx, server, 0);
7267 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
7268 if (ctx->is_message)
7269 check_events_todo(ctx, MAKELONG(FD_CLOSE, WSAECONNABORTED), 0, 200);
7270 check_events(ctx, 0, 0, 0);
7271
7272 closesocket(server);
7273 }
7274
7275 static void test_events(void)
7276 {
7277 struct event_test_ctx ctx;
7278
7279 ctx.is_message = FALSE;
7280 ctx.event = CreateEventW(NULL, TRUE, FALSE, NULL);
7281
7282 test_accept_events(&ctx);
7283 test_connect_events(&ctx);
7284 test_write_events(&ctx);
7285 test_read_events(&ctx);
7286 test_close_events(&ctx);
7287 test_oob_events(&ctx);
7288
7289 CloseHandle(ctx.event);
7290
7291 ctx.is_message = TRUE;
7292 ctx.window = CreateWindowA("Message", NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, NULL, NULL);
7293
7294 test_accept_events(&ctx);
7295 test_connect_events(&ctx);
7296 test_write_events(&ctx);
7297 test_read_events(&ctx);
7298 test_close_events(&ctx);
7299 test_oob_events(&ctx);
7300
7301 DestroyWindow(ctx.window);
7302 }
7303
7304 static void test_ipv6only(void)
7305 {
7306 SOCKET v4 = INVALID_SOCKET, v6;
7307 struct sockaddr_in sin4;
7308 struct sockaddr_in6 sin6;
7309 int ret, enabled, len = sizeof(enabled);
7310
7311 memset(&sin4, 0, sizeof(sin4));
7312 sin4.sin_family = AF_INET;
7313 sin4.sin_port = htons(SERVERPORT);
7314
7315 memset(&sin6, 0, sizeof(sin6));
7316 sin6.sin6_family = AF_INET6;
7317 sin6.sin6_port = htons(SERVERPORT);
7318
7319 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
7320 if (v6 == INVALID_SOCKET)
7321 {
7322 skip("Could not create IPv6 socket (LastError: %d)\n", WSAGetLastError());
7323 goto end;
7324 }
7325
7326 enabled = 2;
7327 ret = getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7328 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7329 ok(enabled == 1, "expected 1, got %d\n", enabled);
7330
7331 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
7332 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
7333
7334 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7335 ok(v4 != INVALID_SOCKET, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
7336
7337 todo_wine {
7338 enabled = 2;
7339 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7340 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7341 ok(enabled == 1, "expected 1, got %d\n", enabled);
7342 }
7343
7344 enabled = 0;
7345 len = sizeof(enabled);
7346 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7347 ok(!ret, "setsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7348
7349 todo_wine {
7350 enabled = 2;
7351 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7352 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7353 ok(!enabled, "expected 0, got %d\n", enabled);
7354 }
7355
7356 enabled = 1;
7357 len = sizeof(enabled);
7358 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7359 ok(!ret, "setsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7360
7361 /* bind on IPv4 socket should succeed - IPV6_V6ONLY is enabled by default */
7362 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
7363 ok(!ret, "Could not bind IPv4 address (LastError: %d)\n", WSAGetLastError());
7364
7365 todo_wine {
7366 enabled = 2;
7367 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7368 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7369 ok(enabled == 1, "expected 1, got %d\n", enabled);
7370 }
7371
7372 enabled = 0;
7373 len = sizeof(enabled);
7374 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7375 ok(ret, "setsockopt(IPV6_V6ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
7376
7377 todo_wine {
7378 enabled = 0;
7379 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7380 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7381 ok(enabled == 1, "expected 1, got %d\n", enabled);
7382 }
7383
7384 enabled = 1;
7385 len = sizeof(enabled);
7386 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7387 ok(ret, "setsockopt(IPV6_V6ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
7388
7389 closesocket(v4);
7390 closesocket(v6);
7391
7392 /* Test again, this time disabling IPV6_V6ONLY. */
7393 sin4.sin_port = htons(SERVERPORT+2);
7394 sin6.sin6_port = htons(SERVERPORT+2);
7395
7396 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
7397 ok(v6 != INVALID_SOCKET, "Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
7398 WSAGetLastError(), WSAEAFNOSUPPORT);
7399
7400 enabled = 0;
7401 ret = setsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7402 ok(!ret, "Could not disable IPV6_V6ONLY (LastError: %d).\n", WSAGetLastError());
7403
7404 enabled = 2;
7405 ret = getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7406 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7407 ok(!enabled, "expected 0, got %d\n", enabled);
7408
7409 /*
7410 Observaition:
7411 On Windows, bind on both IPv4 and IPv6 with IPV6_V6ONLY disabled succeeds by default.
7412 Application must set SO_EXCLUSIVEADDRUSE on first socket to disallow another successful bind.
7413 In general, a standard application should not use SO_REUSEADDR.
7414 Setting both SO_EXCLUSIVEADDRUSE and SO_REUSEADDR on the same socket is not possible in
7415 either order, the later setsockopt call always fails.
7416 */
7417 enabled = 1;
7418 ret = setsockopt(v6, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&enabled, len);
7419 ok(!ret, "Could not set SO_EXCLUSIVEADDRUSE on IPv6 socket (LastError: %d)\n", WSAGetLastError());
7420
7421 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
7422 ok(!ret, "Could not bind IPv6 address (LastError: %d)\n", WSAGetLastError());
7423
7424 enabled = 2;
7425 len = sizeof(enabled);
7426 getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7427 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7428 ok(!enabled, "IPV6_V6ONLY is enabled after bind\n");
7429
7430 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7431 ok(v4 != INVALID_SOCKET, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
7432
7433 enabled = 1;
7434 ret = setsockopt(v4, SOL_SOCKET, SO_REUSEADDR, (char*)&enabled, len);
7435 ok(!ret, "Could not set SO_REUSEADDR on IPv4 socket (LastError: %d)\n", WSAGetLastError());
7436
7437 WSASetLastError(0xdeadbeef);
7438 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
7439 ok(ret, "bind succeeded unexpectedly for the IPv4 socket\n");
7440 ok(WSAGetLastError() == WSAEACCES, "Expected 10013, got %d\n", WSAGetLastError());
7441
7442 end:
7443 if (v4 != INVALID_SOCKET)
7444 closesocket(v4);
7445 if (v6 != INVALID_SOCKET)
7446 closesocket(v6);
7447 }
7448
7449 static void test_WSASendMsg(void)
7450 {
7451 SOCKET sock, dst;
7452 struct sockaddr_in sendaddr, sockaddr;
7453 GUID WSASendMsg_GUID = WSAID_WSASENDMSG;
7454 LPFN_WSASENDMSG pWSASendMsg = NULL;
7455 char teststr[12] = "hello world", buffer[32];
7456 WSABUF iovec[2];
7457 WSAMSG msg;
7458 DWORD bytesSent, err;
7459 int ret, addrlen;
7460
7461 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
7462
7463 sock = socket(AF_INET, SOCK_DGRAM, 0);
7464 ok(sock != INVALID_SOCKET, "socket() failed\n");
7465
7466 /* Obtain the WSASendMsg function */
7467 WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSASendMsg_GUID, sizeof(WSASendMsg_GUID),
7468 &pWSASendMsg, sizeof(pWSASendMsg), &err, NULL, NULL);
7469 if (!pWSASendMsg)
7470 {
7471 closesocket(sock);
7472 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
7473 return;
7474 }
7475
7476 /* fake address for now */
7477 sendaddr.sin_family = AF_INET;
7478 sendaddr.sin_port = htons(139);
7479 sendaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
7480
7481 memset(&msg, 0, sizeof(msg));
7482 iovec[0].buf = teststr;
7483 iovec[0].len = sizeof(teststr);
7484 iovec[1].buf = teststr;
7485 iovec[1].len = sizeof(teststr) / 2;
7486 msg.name = (struct sockaddr *) &sendaddr;
7487 msg.namelen = sizeof(sendaddr);
7488 msg.lpBuffers = iovec;
7489 msg.dwBufferCount = 1; /* send only one buffer for now */
7490
7491 WSASetLastError(0xdeadbeef);
7492 ret = pWSASendMsg(INVALID_SOCKET, &msg, 0, NULL, NULL, NULL);
7493 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7494 err = WSAGetLastError();
7495 ok(err == WSAENOTSOCK, "expected 10038, got %ld instead\n", err);
7496
7497 WSASetLastError(0xdeadbeef);
7498 ret = pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL);
7499 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7500 err = WSAGetLastError();
7501 ok(err == WSAEFAULT, "expected 10014, got %ld instead\n", err);
7502
7503 WSASetLastError(0xdeadbeef);
7504 ret = pWSASendMsg(sock, NULL, 0, &bytesSent, NULL, NULL);
7505 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7506 err = WSAGetLastError();
7507 ok(err == WSAEFAULT, "expected 10014, got %ld instead\n", err);
7508
7509 WSASetLastError(0xdeadbeef);
7510 ret = pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL);
7511 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7512 err = WSAGetLastError();
7513 ok(err == WSAEFAULT, "expected 10014, got %ld instead\n", err);
7514
7515 closesocket(sock);
7516
7517 sock = socket(AF_INET, SOCK_DGRAM, 0);
7518 ok(sock != INVALID_SOCKET, "socket() failed\n");
7519
7520 dst = socket(AF_INET, SOCK_DGRAM, 0);
7521 ok(dst != INVALID_SOCKET, "socket() failed\n");
7522
7523 memset(&sockaddr, 0, sizeof(sockaddr));
7524 sockaddr.sin_family = AF_INET;
7525 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
7526 ok(!bind(dst, (struct sockaddr*)&sockaddr, sizeof(sockaddr)),
7527 "bind should have worked\n");
7528
7529 /* read address to find out the port number to be used in send */
7530 memset(&sendaddr, 0, sizeof(sendaddr));
7531 addrlen = sizeof(sendaddr);
7532 ok(!getsockname(dst, (struct sockaddr *) &sendaddr, &addrlen),
7533 "getsockname should have worked\n");
7534 ok(sendaddr.sin_port, "socket port should be != 0\n");
7535
7536 /* ensure the sending socket is not bound */
7537 WSASetLastError(0xdeadbeef);
7538 addrlen = sizeof(sockaddr);
7539 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
7540 ok(ret == SOCKET_ERROR, "getsockname should have failed\n");
7541 err = WSAGetLastError();
7542 ok(err == WSAEINVAL, "expected 10022, got %ld instead\n", err);
7543
7544 set_blocking(sock, TRUE);
7545
7546 bytesSent = 0;
7547 SetLastError(0xdeadbeef);
7548 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
7549 ok(!ret, "WSASendMsg should have worked\n");
7550 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
7551 "Expected 0, got %ld\n", GetLastError());
7552 ok(bytesSent == iovec[0].len, "incorrect bytes sent, expected %ld, sent %ld\n",
7553 iovec[0].len, bytesSent);
7554
7555 /* receive data */
7556 addrlen = sizeof(sockaddr);
7557 memset(buffer, 0, sizeof(buffer));
7558 SetLastError(0xdeadbeef);
7559 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
7560 ok(ret == bytesSent, "got %d, expected %ld\n",
7561 ret, bytesSent);
7562 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7563
7564 /* A successful call to WSASendMsg must have bound the socket */
7565 addrlen = sizeof(sockaddr);
7566 sockaddr.sin_port = 0;
7567 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
7568 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
7569 ok(!ret, "getsockname should have worked\n");
7570 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
7571 inet_ntoa(sockaddr.sin_addr));
7572 ok(sockaddr.sin_port, "sin_port should be != 0\n");
7573
7574 msg.dwBufferCount = 2; /* send both buffers */
7575
7576 bytesSent = 0;
7577 SetLastError(0xdeadbeef);
7578 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
7579 ok(!ret, "WSASendMsg should have worked\n");
7580 ok(bytesSent == iovec[0].len + iovec[1].len, "incorrect bytes sent, expected %ld, sent %ld\n",
7581 iovec[0].len + iovec[1].len, bytesSent);
7582 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
7583 "Expected 0, got %ld\n", GetLastError());
7584
7585 /* receive data */
7586 addrlen = sizeof(sockaddr);
7587 memset(buffer, 0, sizeof(buffer));
7588 SetLastError(0xdeadbeef);
7589 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
7590 ok(ret == bytesSent, "got %d, expected %ld\n",
7591 ret, bytesSent);
7592 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7593
7594 closesocket(sock);
7595 closesocket(dst);
7596
7597 /* a bad call to WSASendMsg will also bind the socket */
7598 addrlen = sizeof(sockaddr);
7599 sockaddr.sin_port = 0;
7600 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
7601 sock = socket(AF_INET, SOCK_DGRAM, 0);
7602 ok(sock != INVALID_SOCKET, "socket() failed\n");
7603 ok(pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
7604 todo_wine {
7605 ok(!getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have worked\n");
7606 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
7607 inet_ntoa(sockaddr.sin_addr));
7608 ok(sockaddr.sin_port, "sin_port should be > 0\n");
7609 }
7610 closesocket(sock);
7611
7612 /* a bad call without msg parameter will not trigger the auto-bind */
7613 sock = socket(AF_INET, SOCK_DGRAM, 0);
7614 ok(sock != INVALID_SOCKET, "socket() failed\n");
7615 ok(pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
7616 ok(getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have failed\n");
7617 err = WSAGetLastError();
7618 ok(err == WSAEINVAL, "expected 10022, got %ld instead\n", err);
7619 closesocket(sock);
7620
7621 /* SOCK_STREAM sockets are not supported */
7622 bytesSent = 0;
7623 sock = socket(AF_INET, SOCK_STREAM, 0);
7624 ok(sock != INVALID_SOCKET, "socket() failed\n");
7625 SetLastError(0xdeadbeef);
7626 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
7627 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7628 err = WSAGetLastError();
7629 todo_wine
7630 ok(err == WSAEINVAL, "expected 10014, got %ld instead\n", err);
7631 closesocket(sock);
7632 }
7633
7634 static void test_WSASendTo(void)
7635 {
7636 SOCKET s;
7637 struct sockaddr_in addr, ret_addr;
7638 char buf[12] = "hello world";
7639 WSABUF data_buf;
7640 DWORD bytesSent;
7641 int ret, len;
7642
7643 addr.sin_family = AF_INET;
7644 addr.sin_port = htons(139);
7645 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
7646 data_buf.len = sizeof(buf);
7647 data_buf.buf = buf;
7648
7649 s = socket(AF_INET, SOCK_DGRAM, 0);
7650 ok(s != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
7651
7652 WSASetLastError(12345);
7653 ret = WSASendTo(INVALID_SOCKET, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
7654 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
7655 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
7656
7657 len = sizeof(ret_addr);
7658 ret = getsockname(s, (struct sockaddr *)&ret_addr, &len);
7659 ok(ret == -1, "expected failure\n");
7660 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
7661
7662 WSASetLastError(12345);
7663 ret = WSASendTo(s, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
7664 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
7665 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
7666
7667 WSASetLastError(12345);
7668 ret = WSASendTo(s, &data_buf, 1, &bytesSent, 0, (struct sockaddr *)&addr, sizeof(addr), NULL, NULL);
7669 ok(!ret, "expected success\n");
7670 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
7671
7672 len = sizeof(ret_addr);
7673 ret = getsockname(s, (struct sockaddr *)&ret_addr, &len);
7674 ok(!ret, "got error %u\n", WSAGetLastError());
7675 ok(ret_addr.sin_family == AF_INET, "got family %u\n", ret_addr.sin_family);
7676 ok(ret_addr.sin_port, "expected nonzero port\n");
7677 }
7678
7679 struct recv_thread_apc_param
7680 {
7681 SOCKET sock;
7682 unsigned int apc_count;
7683 };
7684
7685 static void WINAPI recv_thread_apc_func(ULONG_PTR param)
7686 {
7687 struct recv_thread_apc_param *p = (struct recv_thread_apc_param *)param;
7688 int ret;
7689
7690 ++p->apc_count;
7691
7692 ret = send(p->sock, "test", 4, 0);
7693 ok(ret == 4, "got %d.\n", ret);
7694 }
7695
7696 struct recv_thread_param
7697 {
7698 SOCKET sock;
7699 BOOL overlapped;
7700 };
7701
7702 static DWORD WINAPI recv_thread(LPVOID arg)
7703 {
7704 struct recv_thread_param *p = arg;
7705 SOCKET sock = p->sock;
7706 char buffer[32];
7707 WSABUF wsa;
7708 WSAOVERLAPPED ov;
7709 DWORD flags = 0;
7710 DWORD len;
7711 int ret;
7712
7713 wsa.buf = buffer;
7714 wsa.len = sizeof(buffer);
7715 if (p->overlapped)
7716 {
7717 ov.hEvent = WSACreateEvent();
7718 WSARecv(sock, &wsa, 1, NULL, &flags, &ov, NULL);
7719
7720 WaitForSingleObject(ov.hEvent, 1000);
7721 WSACloseEvent(ov.hEvent);
7722 }
7723 else
7724 {
7725 SetLastError(0xdeadbeef);
7726 ret = WSARecv(sock, &wsa, 1, &len, &flags, NULL, NULL);
7727 ok(!ret, "got ret %d.\n", ret);
7728 ok(WSAGetLastError() == 0, "got error %d.\n", WSAGetLastError());
7729 ok(len == 4, "got len %lu.\n", len);
7730 }
7731 return 0;
7732 }
7733
7734 static int completion_called;
7735
7736 static void WINAPI io_completion(DWORD error, DWORD transferred, WSAOVERLAPPED *overlapped, DWORD flags)
7737 {
7738 completion_called++;
7739 }
7740
7741 static void test_WSARecv(void)
7742 {
7743 SOCKET src, dest, server = INVALID_SOCKET;
7744 struct recv_thread_apc_param apc_param;
7745 struct recv_thread_param recv_param;
7746 char buf[20];
7747 WSABUF bufs[2];
7748 WSAOVERLAPPED ov;
7749 DWORD bytesReturned, flags, id;
7750 struct sockaddr_in addr;
7751 unsigned int apc_count;
7752 int iret, len;
7753 DWORD dwret;
7754 BOOL bret;
7755 HANDLE thread, event = NULL, io_port;
7756
7757 tcp_socketpair(&src, &dest);
7758
7759 memset(&ov, 0, sizeof(ov));
7760 flags = 0;
7761 bufs[0].len = 1;
7762 bufs[0].buf = buf;
7763
7764 /* Send 2 bytes and receive in two calls of 1 */
7765 SetLastError(0xdeadbeef);
7766 iret = send(src, "ab", 2, 0);
7767 ok(iret == 2, "got %d\n", iret);
7768 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7769 SetLastError(0xdeadbeef);
7770 bytesReturned = 0xdeadbeef;
7771
7772 /* Non-overlapped WSARecv() performs an alertable wait (tested below), but
7773 * not if it completes synchronously. Make sure it completes synchronously
7774 * by polling for input. */
7775 check_poll_mask(dest, POLLRDNORM, POLLRDNORM);
7776
7777 apc_count = 0;
7778 dwret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
7779 ok(dwret, "QueueUserAPC returned %lu\n", dwret);
7780
7781 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
7782 ok(!iret, "Expected 0, got %d\n", iret);
7783 ok(bytesReturned == 1, "got %ld\n", bytesReturned);
7784 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7785
7786 ok(!apc_count, "got apc_count %u.\n", apc_count);
7787 SleepEx(0, TRUE);
7788 ok(apc_count == 1, "got apc_count %u.\n", apc_count);
7789
7790 SetLastError(0xdeadbeef);
7791 bytesReturned = 0xdeadbeef;
7792 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
7793 ok(!iret, "Expected 0, got %d\n", iret);
7794 ok(bytesReturned == 1, "got %ld\n", bytesReturned);
7795 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7796
7797 bufs[0].len = 4;
7798 SetLastError(0xdeadbeef);
7799 iret = send(src, "test", 4, 0);
7800 ok(iret == 4, "Expected 4, got %d\n", iret);
7801 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7802 SetLastError(0xdeadbeef);
7803 bytesReturned = 0xdeadbeef;
7804 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
7805 ok(!iret, "Expected 0, got %d\n", iret);
7806 ok(bytesReturned == 4, "Expected 4, got %ld\n", bytesReturned);
7807 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7808
7809 /* Test 2 buffers */
7810 bufs[0].len = 4;
7811 bufs[1].len = 5;
7812 bufs[1].buf = buf + 10;
7813 SetLastError(0xdeadbeef);
7814 iret = send(src, "deadbeefs", 9, 0);
7815 ok(iret == 9, "Expected 9, got %d\n", iret);
7816 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7817 SetLastError(0xdeadbeef);
7818 bytesReturned = 0xdeadbeef;
7819 iret = WSARecv(dest, bufs, 2, &bytesReturned, &flags, NULL, NULL);
7820 ok(!iret, "Expected 0, got %d\n", iret);
7821 ok(bytesReturned == 9, "Expected 9, got %ld\n", bytesReturned);
7822 bufs[0].buf[4] = '\0';
7823 bufs[1].buf[5] = '\0';
7824 ok(!strcmp(bufs[0].buf, "dead"), "buf[0] doesn't match: %s != dead\n", bufs[0].buf);
7825 ok(!strcmp(bufs[1].buf, "beefs"), "buf[1] doesn't match: %s != beefs\n", bufs[1].buf);
7826 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7827
7828 bufs[0].len = sizeof(buf);
7829 ov.hEvent = event = CreateEventA(NULL, FALSE, FALSE, NULL);
7830 ok(ov.hEvent != NULL, "could not create event object, errno = %ld\n", GetLastError());
7831 if (!event)
7832 goto end;
7833
7834 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, NULL);
7835 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %ld\n", iret, GetLastError());
7836
7837 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, &ov, NULL);
7838 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %ld\n", iret, GetLastError());
7839
7840 close_with_rst(src);
7841
7842 dwret = WaitForSingleObject(ov.hEvent, 1000);
7843 ok(dwret == WAIT_OBJECT_0, "Waiting for disconnect event failed with %ld + errno %ld\n", dwret, GetLastError());
7844
7845 bret = GetOverlappedResult((HANDLE)dest, &ov, &bytesReturned, FALSE);
7846 ok(!bret, "expected failure\n");
7847 ok(GetLastError() == ERROR_NETNAME_DELETED, "got error %lu\n", GetLastError());
7848 ok(bytesReturned == 0, "Bytes received is %ld\n", bytesReturned);
7849 closesocket(dest);
7850 dest = INVALID_SOCKET;
7851
7852 src = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
7853 ok(src != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
7854 if (src == INVALID_SOCKET) goto end;
7855
7856 server = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
7857 ok(server != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
7858 if (server == INVALID_SOCKET) goto end;
7859
7860 memset(&addr, 0, sizeof(addr));
7861 addr.sin_family = AF_INET;
7862 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
7863 iret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
7864 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
7865
7866 len = sizeof(addr);
7867 iret = getsockname(server, (struct sockaddr *)&addr, &len);
7868 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
7869
7870 iret = listen(server, 1);
7871 ok(!iret, "failed to listen, error %u\n", WSAGetLastError());
7872
7873 iret = connect(src, (struct sockaddr *)&addr, sizeof(addr));
7874 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
7875
7876 len = sizeof(addr);
7877 dest = accept(server, (struct sockaddr *)&addr, &len);
7878 ok(dest != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
7879 if (dest == INVALID_SOCKET) goto end;
7880
7881 send(src, "test message", sizeof("test message"), 0);
7882 recv_param.sock = dest;
7883 recv_param.overlapped = TRUE;
7884 thread = CreateThread(NULL, 0, recv_thread, &recv_param, 0, &id);
7885 WaitForSingleObject(thread, 3000);
7886 CloseHandle(thread);
7887
7888 recv_param.overlapped = FALSE;
7889 thread = CreateThread(NULL, 0, recv_thread, &recv_param, 0, &id);
7890 apc_param.apc_count = 0;
7891 apc_param.sock = src;
7892 dwret = QueueUserAPC(recv_thread_apc_func, thread, (ULONG_PTR)&apc_param);
7893 ok(dwret, "QueueUserAPC returned %lu\n", dwret);
7894 WaitForSingleObject(thread, 3000);
7895 ok(apc_param.apc_count == 1, "got apc_count %u.\n", apc_param.apc_count);
7896
7897 CloseHandle(thread);
7898
7899 memset(&ov, 0, sizeof(ov));
7900 ov.hEvent = event;
7901 ResetEvent(event);
7902 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, io_completion);
7903 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %ld\n", iret, GetLastError());
7904 send(src, "test message", sizeof("test message"), 0);
7905
7906 completion_called = 0;
7907 dwret = SleepEx(1000, TRUE);
7908 ok(dwret == WAIT_IO_COMPLETION, "got %lu\n", dwret);
7909 ok(completion_called == 1, "completion not called\n");
7910
7911 dwret = WaitForSingleObject(event, 1);
7912 ok(dwret == WAIT_TIMEOUT, "got %lu\n", dwret);
7913
7914 io_port = CreateIoCompletionPort( (HANDLE)dest, NULL, 0, 0 );
7915 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
7916
7917 /* Using completion function on socket associated with completion port is not allowed. */
7918 memset(&ov, 0, sizeof(ov));
7919 completion_called = 0;
7920 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, io_completion);
7921 ok(iret == SOCKET_ERROR && GetLastError() == WSAEINVAL, "WSARecv failed - %d error %ld\n", iret, GetLastError());
7922 ok(!completion_called, "completion called\n");
7923
7924 CloseHandle(io_port);
7925
7926 end:
7927 if (server != INVALID_SOCKET)
7928 closesocket(server);
7929 if (dest != INVALID_SOCKET)
7930 closesocket(dest);
7931 if (src != INVALID_SOCKET)
7932 closesocket(src);
7933 if (event)
7934 WSACloseEvent(event);
7935 }
7936
7937 struct write_watch_thread_args
7938 {
7939 int func;
7940 SOCKET dest;
7941 void *base;
7942 DWORD size;
7943 const char *expect;
7944 };
7945
7946 static DWORD CALLBACK write_watch_thread( void *arg )
7947 {
7948 struct write_watch_thread_args *args = arg;
7949 struct sockaddr addr;
7950 int addr_len = sizeof(addr), ret;
7951 DWORD bytes, flags = 0;
7952 WSABUF buf[1];
7953
7954 switch (args->func)
7955 {
7956 case 0:
7957 ret = recv( args->dest, args->base, args->size, 0 );
7958 ok( ret == strlen(args->expect) + 1, "wrong len %d\n", ret );
7959 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
7960 break;
7961 case 1:
7962 ret = recvfrom( args->dest, args->base, args->size, 0, &addr, &addr_len );
7963 ok( ret == strlen(args->expect) + 1, "wrong len %d\n", ret );
7964 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
7965 break;
7966 case 2:
7967 buf[0].len = args->size;
7968 buf[0].buf = args->base;
7969 ret = WSARecv( args->dest, buf, 1, &bytes, &flags, NULL, NULL );
7970 ok( !ret, "WSARecv failed %lu\n", GetLastError() );
7971 ok( bytes == strlen(args->expect) + 1, "wrong len %ld\n", bytes );
7972 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
7973 break;
7974 case 3:
7975 buf[0].len = args->size;
7976 buf[0].buf = args->base;
7977 ret = WSARecvFrom( args->dest, buf, 1, &bytes, &flags, &addr, &addr_len, NULL, NULL );
7978 ok( !ret, "WSARecvFrom failed %lu\n", GetLastError() );
7979 ok( bytes == strlen(args->expect) + 1, "wrong len %ld\n", bytes );
7980 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
7981 break;
7982 }
7983 return 0;
7984 }
7985
7986 static void test_write_watch(void)
7987 {
7988 SOCKET src, dest;
7989 WSABUF bufs[2];
7990 WSAOVERLAPPED ov;
7991 struct write_watch_thread_args args;
7992 DWORD bytesReturned, flags, size;
7993 struct sockaddr addr;
7994 int addr_len, ret;
7995 HANDLE thread, event;
7996 char *base;
7997 void *results[64];
7998 ULONG_PTR count;
7999 ULONG pagesize;
8000 UINT (WINAPI *pGetWriteWatch)(DWORD,LPVOID,SIZE_T,LPVOID*,ULONG_PTR*,ULONG*);
8001
8002 pGetWriteWatch = (void *)GetProcAddress( GetModuleHandleA("kernel32.dll"), "GetWriteWatch" );
8003 if (!pGetWriteWatch)
8004 {
8005 win_skip( "write watched not supported\n" );
8006 return;
8007 }
8008
8009 /* Windows 11 no longer triggers write watches anymore. */
8010
8011 tcp_socketpair(&src, &dest);
8012
8013 memset(&ov, 0, sizeof(ov));
8014 ov.hEvent = event = CreateEventA(NULL, FALSE, FALSE, NULL);
8015 ok(ov.hEvent != NULL, "could not create event object, errno = %ld\n", GetLastError());
8016
8017 flags = 0;
8018
8019 size = 0x10000;
8020 base = VirtualAlloc( 0, size, MEM_RESERVE | MEM_COMMIT | MEM_WRITE_WATCH, PAGE_READWRITE );
8021 ok( base != NULL, "VirtualAlloc failed %lu\n", GetLastError() );
8022
8023 memset( base, 0, size );
8024 count = 64;
8025 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
8026 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
8027 ok( count == 16, "wrong count %Iu\n", count );
8028
8029 bufs[0].len = 5;
8030 bufs[0].buf = base;
8031 bufs[1].len = 0x8000;
8032 bufs[1].buf = base + 0x4000;
8033
8034 ret = WSARecv( dest, bufs, 2, NULL, &flags, &ov, NULL);
8035 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
8036 "WSARecv failed - %d error %ld\n", ret, GetLastError());
8037
8038 count = 64;
8039 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
8040 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
8041 ok( count == 9 || !count /* Win 11 */, "wrong count %Iu\n", count );
8042 ok( !base[0], "data set\n" );
8043
8044 send(src, "test message", sizeof("test message"), 0);
8045
8046 ret = GetOverlappedResult( (HANDLE)dest, &ov, &bytesReturned, TRUE );
8047 ok( ret, "GetOverlappedResult failed %lu\n", GetLastError() );
8048 ok( bytesReturned == sizeof("test message"), "wrong size %lu\n", bytesReturned );
8049 ok( !memcmp( base, "test ", 5 ), "wrong data %s\n", base );
8050 ok( !memcmp( base + 0x4000, "message", 8 ), "wrong data %s\n", base + 0x4000 );
8051
8052 count = 64;
8053 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
8054 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
8055 ok( count == 0, "wrong count %Iu\n", count );
8056
8057 memset( base, 0, size );
8058 count = 64;
8059 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
8060 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
8061 ok( count == 16, "wrong count %Iu\n", count );
8062
8063 bufs[1].len = 0x4000;
8064 bufs[1].buf = base + 0x2000;
8065 ret = WSARecvFrom( dest, bufs, 2, NULL, &flags, &addr, &addr_len, &ov, NULL);
8066 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
8067 "WSARecv failed - %d error %ld\n", ret, GetLastError());
8068
8069 count = 64;
8070 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
8071 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
8072 ok( count == 5 || !count /* Win 11 */, "wrong count %Iu\n", count );
8073 ok( !base[0], "data set\n" );
8074
8075 send(src, "test message", sizeof("test message"), 0);
8076
8077 ret = GetOverlappedResult( (HANDLE)dest, &ov, &bytesReturned, TRUE );
8078 ok( ret, "GetOverlappedResult failed %lu\n", GetLastError() );
8079 ok( bytesReturned == sizeof("test message"), "wrong size %lu\n", bytesReturned );
8080 ok( !memcmp( base, "test ", 5 ), "wrong data %s\n", base );
8081 ok( !memcmp( base + 0x2000, "message", 8 ), "wrong data %s\n", base + 0x2000 );
8082
8083 count = 64;
8084 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
8085 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
8086 ok( count == 0, "wrong count %Iu\n", count );
8087
8088 memset( base, 0, size );
8089 count = 64;
8090 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
8091 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
8092 ok( count == 16, "wrong count %Iu\n", count );
8093
8094 args.dest = dest;
8095 args.base = base;
8096 args.size = 0x7002;
8097 args.expect = "test message";
8098 for (args.func = 0; args.func < 4; args.func++)
8099 {
8100 thread = CreateThread( NULL, 0, write_watch_thread, &args, 0, NULL );
8101 Sleep( 200 );
8102
8103 count = 64;
8104 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
8105 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
8106 ok( count == 8 || !count /* Win 11 */, "wrong count %Iu\n", count );
8107
8108 send(src, "test message", sizeof("test message"), 0);
8109 WaitForSingleObject( thread, 10000 );
8110 CloseHandle( thread );
8111
8112 count = 64;
8113 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
8114 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
8115 ok( count == 0, "wrong count %Iu\n", count );
8116 }
8117 WSACloseEvent( event );
8118 closesocket( dest );
8119 closesocket( src );
8120 VirtualFree( base, 0, MEM_FREE );
8121 }
8122
8123 static void test_WSAPoll(void)
8124 {
8125 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
8126 int ret, err, len;
8127 SOCKET listener, server, client;
8128 struct sockaddr_in address;
8129 WSAPOLLFD fds[16];
8130 HANDLE thread_handle;
8131 unsigned int i;
8132 char buffer[6];
8133
8134 static const short invalid_flags[] =
8135 {POLLERR, POLLHUP, POLLNVAL, 0x8, POLLWRBAND, 0x40, 0x80, POLLPRI, 0x800, 0x1000, 0x2000, 0x4000, 0x8000};
8136
8137 if (!pWSAPoll) /* >= Vista */
8138 {
8139 win_skip("WSAPoll is unsupported, some tests will be skipped.\n");
8140 return;
8141 }
8142
8143 /* Invalid parameters test */
8144 SetLastError(0xdeadbeef);
8145 ret = pWSAPoll(NULL, 0, 0);
8146 err = GetLastError();
8147 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
8148 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
8149 SetLastError(0xdeadbeef);
8150 ret = pWSAPoll(NULL, 1, 0);
8151 err = GetLastError();
8152 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
8153 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
8154 SetLastError(0xdeadbeef);
8155 ret = pWSAPoll(NULL, 0, 1);
8156 err = GetLastError();
8157 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
8158 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
8159 SetLastError(0xdeadbeef);
8160 ret = pWSAPoll(NULL, 1, 1);
8161 err = GetLastError();
8162 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
8163 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
8164
8165 memset(&address, 0, sizeof(address));
8166 address.sin_addr.s_addr = inet_addr("127.0.0.1");
8167 address.sin_family = AF_INET;
8168 len = sizeof(address);
8169 listener = setup_server_socket(&address, &len);
8170
8171 for (i = 0; i < ARRAY_SIZE(invalid_flags); ++i)
8172 {
8173 fds[0].fd = listener;
8174 fds[0].events = invalid_flags[i];
8175 fds[0].revents = 0xdead;
8176 WSASetLastError(0xdeadbeef);
8177 ret = pWSAPoll(fds, 1, 0);
8178 todo_wine ok(ret == -1, "got %d\n", ret);
8179 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8180 }
8181
8182 /* When no events are pending poll returns 0 with no error */
8183 fds[0].fd = listener;
8184 fds[0].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
8185 fds[0].revents = 0xdead;
8186 ret = pWSAPoll(fds, 1, 0);
8187 ok(ret == 0, "got %d\n", ret);
8188 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
8189
8190 fds[0].fd = -1;
8191 fds[0].events = POLLERR;
8192 fds[0].revents = 0xdead;
8193 fds[1].fd = listener;
8194 fds[1].events = POLLIN;
8195 fds[1].revents = 0xdead;
8196 WSASetLastError(0xdeadbeef);
8197 ret = pWSAPoll(fds, 2, 0);
8198 ok(!ret, "got %d\n", ret);
8199 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
8200 ok(fds[0].revents == POLLNVAL, "got events %#x\n", fds[0].revents);
8201 ok(!fds[1].revents, "got events %#x\n", fds[1].revents);
8202
8203 fds[0].fd = listener;
8204 fds[0].events = POLLIN;
8205 fds[0].revents = 0xdead;
8206 fds[1].fd = 0xabacab;
8207 fds[1].events = POLLIN;
8208 fds[1].revents = 0xdead;
8209 WSASetLastError(0xdeadbeef);
8210 ret = pWSAPoll(fds, 2, 0);
8211 ok(!ret, "got %d\n", ret);
8212 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
8213 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
8214 ok(fds[1].revents == POLLNVAL, "got events %#x\n", fds[1].revents);
8215
8216 fds[0].fd = listener;
8217 fds[0].events = POLLIN;
8218 fds[0].revents = 0xdead;
8219 fds[1].fd = 0xabacab;
8220 fds[1].events = POLLERR;
8221 fds[1].revents = 0xdead;
8222 WSASetLastError(0xdeadbeef);
8223 ret = pWSAPoll(fds, 2, 0);
8224 todo_wine ok(ret == -1, "got %d\n", ret);
8225 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8226 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
8227 todo_wine ok(!fds[1].revents, "got events %#x\n", fds[1].revents);
8228
8229 fds[0].fd = -1;
8230 fds[0].events = POLLERR;
8231 fds[0].revents = 0xdead;
8232 fds[1].fd = 0xabacab;
8233 fds[1].events = POLLERR;
8234 fds[1].revents = 0xdead;
8235 WSASetLastError(0xdeadbeef);
8236 ret = pWSAPoll(fds, 2, 0);
8237 ok(ret == -1, "got %d\n", ret);
8238 ok(WSAGetLastError() == WSAENOTSOCK, "got error %u\n", WSAGetLastError());
8239 ok(fds[0].revents == POLLNVAL, "got events %#x\n", fds[0].revents);
8240 ok(fds[1].revents == POLLNVAL, "got events %#x\n", fds[1].revents);
8241
8242 /* Test listening socket connection attempt notifications */
8243 client = setup_connector_socket(&address, len, TRUE);
8244
8245 fds[0].fd = listener;
8246 fds[0].events = POLLIN;
8247 fds[0].revents = 0xdead;
8248 ret = pWSAPoll(fds, 1, 100);
8249 ok(ret == 1, "got %d\n", ret);
8250 ok(fds[0].revents == POLLRDNORM, "got events %#x\n", fds[0].revents);
8251
8252 fds[0].revents = 0xdead;
8253 ret = pWSAPoll(fds, 1, 0);
8254 ok(ret == 1, "got %d\n", ret);
8255 ok(fds[0].revents == POLLRDNORM, "got events %#x\n", fds[0].revents);
8256
8257 fds[0].events = POLLRDBAND | POLLWRNORM;
8258 fds[0].revents = 0xdead;
8259 ret = pWSAPoll(fds, 1, 0);
8260 ok(ret == 0, "got %d\n", ret);
8261 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
8262
8263 server = accept(listener, NULL, NULL);
8264 ok(server != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
8265 set_blocking(client, FALSE);
8266 set_blocking(server, FALSE);
8267
8268 for (i = 0; i < ARRAY_SIZE(invalid_flags); ++i)
8269 {
8270 fds[0].fd = server;
8271 fds[0].events = invalid_flags[i];
8272 fds[0].revents = 0xdead;
8273 WSASetLastError(0xdeadbeef);
8274 ret = pWSAPoll(fds, 1, 0);
8275 todo_wine ok(ret == -1, "got %d\n", ret);
8276 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8277 }
8278
8279 /* Test flags exposed by connected sockets. */
8280
8281 fds[0].fd = listener;
8282 fds[0].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
8283 fds[0].revents = 0xdead;
8284 fds[1].fd = server;
8285 fds[1].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
8286 fds[1].revents = 0xdead;
8287 fds[2].fd = client;
8288 fds[2].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
8289 fds[2].revents = 0xdead;
8290 ret = pWSAPoll(fds, 3, 0);
8291 ok(ret == 2, "got %d\n", ret);
8292 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
8293 ok(fds[1].revents == POLLWRNORM, "got events %#x\n", fds[1].revents);
8294 ok(fds[2].revents == POLLWRNORM, "got events %#x\n", fds[2].revents);
8295
8296 /* Test data receiving notifications */
8297
8298 ret = send(server, "1234", 4, 0);
8299 ok(ret == 4, "got %d\n", ret);
8300
8301 check_poll_mask(client, POLLRDNORM | POLLRDBAND, POLLRDNORM);
8302 check_poll(client, POLLRDNORM | POLLWRNORM);
8303 check_poll(server, POLLWRNORM);
8304
8305 ret = sync_recv(client, buffer, sizeof(buffer), 0);
8306 ok(ret == 4, "got %d\n", ret);
8307
8308 check_poll(client, POLLWRNORM);
8309 check_poll(server, POLLWRNORM);
8310
8311 /* Because the kernel asynchronously buffers data, this test is not reliable. */
8312
8313 if (0)
8314 {
8315 static const int large_buffer_size = 1024 * 1024;
8316 char *large_buffer = malloc(large_buffer_size);
8317
8318 while (send(server, large_buffer, large_buffer_size, 0) == large_buffer_size);
8319
8320 check_poll(client, POLLWRNORM | POLLRDNORM);
8321 check_poll(server, 0);
8322
8323 while (recv(client, large_buffer, large_buffer_size, 0) > 0);
8324
8325 check_poll(client, POLLWRNORM);
8326 check_poll(server, POLLWRNORM);
8327
8328 free(large_buffer);
8329 }
8330
8331 /* Test OOB data notifications */
8332
8333 ret = send(client, "A", 1, MSG_OOB);
8334 ok(ret == 1, "got %d\n", ret);
8335
8336 check_poll(client, POLLWRNORM);
8337 check_poll_mask(server, POLLRDNORM | POLLRDBAND, POLLRDBAND);
8338 check_poll(server, POLLWRNORM | POLLRDBAND);
8339
8340 buffer[0] = 0xcc;
8341 ret = recv(server, buffer, 1, MSG_OOB);
8342 ok(ret == 1, "got %d\n", ret);
8343 ok(buffer[0] == 'A', "got %#x\n", buffer[0]);
8344
8345 check_poll(client, POLLWRNORM);
8346 check_poll(server, POLLWRNORM);
8347
8348 /* If the socket is OOBINLINED the notification is like normal data */
8349
8350 ret = 1;
8351 ret = setsockopt(server, SOL_SOCKET, SO_OOBINLINE, (char *)&ret, sizeof(ret));
8352 ok(!ret, "got error %u\n", WSAGetLastError());
8353 ret = send(client, "A", 1, MSG_OOB);
8354 ok(ret == 1, "got %d\n", ret);
8355
8356 check_poll(client, POLLWRNORM);
8357 check_poll_mask(server, POLLRDNORM | POLLRDBAND, POLLRDNORM);
8358 check_poll(server, POLLWRNORM | POLLRDNORM);
8359
8360 buffer[0] = 0xcc;
8361 ret = recv(server, buffer, 1, 0);
8362 ok(ret == 1, "got %d\n", ret);
8363 ok(buffer[0] == 'A', "got %#x\n", buffer[0]);
8364
8365 check_poll(client, POLLWRNORM);
8366 check_poll_todo(server, POLLWRNORM);
8367
8368 /* Test shutdown. */
8369
8370 ret = shutdown(client, SD_RECEIVE);
8371 ok(!ret, "got error %u\n", WSAGetLastError());
8372
8373 check_poll(client, POLLWRNORM);
8374 check_poll_todo(server, POLLWRNORM);
8375
8376 ret = shutdown(client, SD_SEND);
8377 ok(!ret, "got error %u\n", WSAGetLastError());
8378
8379 check_poll(client, POLLWRNORM);
8380 check_poll_mask_todo(server, 0, POLLHUP);
8381 check_poll_todo(server, POLLWRNORM | POLLHUP);
8382
8383 closesocket(client);
8384 closesocket(server);
8385
8386 /* Test shutdown via closesocket(). */
8387
8388 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8389 ret = connect(client, (struct sockaddr *)&address, sizeof(address));
8390 ok(!ret, "got error %u\n", WSAGetLastError());
8391 server = accept(listener, NULL, NULL);
8392 ok(server != -1, "got error %u\n", WSAGetLastError());
8393
8394 closesocket(client);
8395
8396 check_poll_mask(server, 0, POLLHUP);
8397 check_poll(server, POLLWRNORM | POLLHUP);
8398
8399 closesocket(server);
8400
8401 /* Test shutdown with data in the pipe. */
8402
8403 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8404 ret = connect(client, (struct sockaddr *)&address, sizeof(address));
8405 ok(!ret, "got error %u\n", WSAGetLastError());
8406 server = accept(listener, NULL, NULL);
8407 ok(server != -1, "got error %u\n", WSAGetLastError());
8408
8409 ret = send(client, "data", 5, 0);
8410 ok(ret == 5, "got %d\n", ret);
8411
8412 check_poll(client, POLLWRNORM);
8413 check_poll_mask(server, POLLRDNORM | POLLRDBAND, POLLRDNORM);
8414 check_poll(server, POLLWRNORM | POLLRDNORM);
8415
8416 ret = shutdown(client, SD_SEND);
8417
8418 check_poll(client, POLLWRNORM);
8419 check_poll_mask_todo(server, 0, POLLHUP);
8420 check_poll_todo(server, POLLWRNORM | POLLRDNORM | POLLHUP);
8421
8422 closesocket(client);
8423 closesocket(server);
8424
8425 /* Test closing a socket while selecting on it. */
8426
8427 tcp_socketpair(&client, &server);
8428
8429 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &client, 0, NULL);
8430 fds[0].fd = client;
8431 fds[0].events = POLLRDNORM | POLLRDBAND;
8432 fds[0].revents = 0xdead;
8433 apc_count = 0;
8434 ret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
8435 ok(ret, "QueueUserAPC returned %d\n", ret);
8436 ret = pWSAPoll(fds, 1, 2000);
8437 ok(apc_count == 1, "APC was called %u times\n", apc_count);
8438 ok(ret == 1, "got %d\n", ret);
8439 ok(fds[0].revents == POLLNVAL, "got events %#x\n", fds[0].revents);
8440 ret = WaitForSingleObject(thread_handle, 1000);
8441 ok(!ret, "wait failed\n");
8442 CloseHandle(thread_handle);
8443
8444 closesocket(server);
8445
8446 /* Test a failed connection.
8447 *
8448 * The following WSAPoll() call times out on versions older than w10pro64,
8449 * but even on w10pro64 it takes over 2 seconds for an error to be reported,
8450 * so make the test interactive-only. */
8451 if (winetest_interactive)
8452 {
8453 const struct sockaddr_in invalid_addr =
8454 {
8455 .sin_family = AF_INET,
8456 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
8457 .sin_port = 255,
8458 };
8459 SOCKET client;
8460
8461 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8462 set_blocking(client, FALSE);
8463
8464 ret = connect(client, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
8465 ok(ret == -1, "got %d\n", ret);
8466 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
8467
8468 fds[0].fd = client;
8469 fds[0].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
8470 fds[0].revents = 0xdead;
8471 ret = pWSAPoll(fds, 1, 10000);
8472 ok(ret == 1, "got %d\n", ret);
8473 todo_wine ok(fds[0].revents == (POLLWRNORM | POLLHUP | POLLERR), "got events %#x\n", fds[0].revents);
8474
8475 len = sizeof(err);
8476 err = 0xdeadbeef;
8477 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
8478 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
8479 ok(err == WSAECONNREFUSED, "got error %u\n", err);
8480
8481 len = sizeof(err);
8482 err = 0xdeadbeef;
8483 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
8484 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
8485 ok(err == WSAECONNREFUSED, "got error %u\n", err);
8486
8487 check_poll_todo(client, POLLWRNORM | POLLHUP | POLLERR);
8488
8489 closesocket(client);
8490
8491 /* test polling after a (synchronous) failure */
8492
8493 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8494
8495 ret = connect(client, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
8496 ok(ret == -1, "got %d\n", ret);
8497 ok(WSAGetLastError() == WSAECONNREFUSED, "got error %u\n", WSAGetLastError());
8498
8499 check_poll_todo(client, POLLWRNORM | POLLHUP | POLLERR);
8500
8501 len = sizeof(err);
8502 err = 0xdeadbeef;
8503 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
8504 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
8505 todo_wine ok(!err, "got error %u\n", err);
8506
8507 closesocket(client);
8508 }
8509
8510 closesocket(listener);
8511
8512 /* Test UDP sockets. */
8513
8514 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
8515 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
8516
8517 check_poll(client, POLLWRNORM);
8518 check_poll(server, POLLWRNORM);
8519
8520 ret = bind(client, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
8521 ok(!ret, "got error %u\n", WSAGetLastError());
8522 len = sizeof(address);
8523 ret = getsockname(client, (struct sockaddr *)&address, &len);
8524 ok(!ret, "got error %u\n", WSAGetLastError());
8525
8526 check_poll(client, POLLWRNORM);
8527 check_poll(server, POLLWRNORM);
8528
8529 ret = sendto(server, "data", 5, 0, (struct sockaddr *)&address, sizeof(address));
8530 ok(ret == 5, "got %d\n", ret);
8531
8532 check_poll_mask(client, POLLRDNORM | POLLRDBAND, POLLRDNORM);
8533 check_poll(client, POLLWRNORM | POLLRDNORM);
8534 check_poll(server, POLLWRNORM);
8535
8536 closesocket(client);
8537 closesocket(server);
8538 }
8539
8540 static void test_connect(void)
8541 {
8542 SOCKET listener = INVALID_SOCKET;
8543 SOCKET acceptor = INVALID_SOCKET;
8544 SOCKET connector = INVALID_SOCKET;
8545 struct sockaddr_in address, conaddress;
8546 int addrlen;
8547 OVERLAPPED overlapped;
8548 LPFN_CONNECTEX pConnectEx;
8549 GUID connectExGuid = WSAID_CONNECTEX;
8550 DWORD bytesReturned;
8551 char buffer[1024];
8552 BOOL bret;
8553 DWORD dwret;
8554 int iret;
8555
8556 memset(&overlapped, 0, sizeof(overlapped));
8557
8558 listener = socket(AF_INET, SOCK_STREAM, 0);
8559 ok(listener != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8560
8561 connector = socket(AF_INET, SOCK_STREAM, 0);
8562 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8563
8564 memset(&address, 0, sizeof(address));
8565 address.sin_family = AF_INET;
8566 address.sin_addr.s_addr = inet_addr("127.0.0.1");
8567 iret = bind(listener, (struct sockaddr*)&address, sizeof(address));
8568 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8569
8570 addrlen = sizeof(address);
8571 iret = getsockname(listener, (struct sockaddr*)&address, &addrlen);
8572 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
8573
8574 iret = listen(listener, 1);
8575 ok(!iret, "failed to listen, error %u\n", WSAGetLastError());
8576
8577 iret = set_blocking(listener, TRUE);
8578 ok(!iret, "failed to set nonblocking, error %u\n", WSAGetLastError());
8579
8580 bytesReturned = 0xdeadbeef;
8581 iret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectExGuid, sizeof(connectExGuid),
8582 &pConnectEx, sizeof(pConnectEx), &bytesReturned, NULL, NULL);
8583 ok(!iret, "failed to get ConnectEx, error %u\n", WSAGetLastError());
8584
8585 ok(bytesReturned == sizeof(pConnectEx), "expected sizeof(pConnectEx), got %lu\n", bytesReturned);
8586
8587 WSASetLastError(0xdeadbeef);
8588 iret = connect(listener, (struct sockaddr *)&address, sizeof(address));
8589 ok(iret == -1, "got %d\n", iret);
8590 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8591
8592 WSASetLastError(0xdeadbeef);
8593 overlapped.Internal = 0xdeadbeef;
8594 overlapped.InternalHigh = 0xdeadbeef;
8595 iret = pConnectEx(listener, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8596 ok(!iret, "got %d\n", iret);
8597 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8598 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8599 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8600
8601 bret = pConnectEx(INVALID_SOCKET, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8602 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "ConnectEx on invalid socket "
8603 "returned %d + errno %d\n", bret, WSAGetLastError());
8604
8605 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8606 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "ConnectEx on a unbound socket "
8607 "returned %d + errno %d\n", bret, WSAGetLastError());
8608
8609 /* ConnectEx needs a bound socket */
8610 memset(&conaddress, 0, sizeof(conaddress));
8611 conaddress.sin_family = AF_INET;
8612 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8613 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8614 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8615
8616 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, NULL);
8617 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "ConnectEx on a NULL overlapped "
8618 "returned %d + errno %d\n", bret, WSAGetLastError());
8619
8620 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8621
8622 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8623 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
8624 "returned %d + errno %d\n", bret, WSAGetLastError());
8625 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8626 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %ld + errno %ld\n", dwret, GetLastError());
8627
8628 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8629 ok(bret, "Connecting failed, error %ld\n", GetLastError());
8630 ok(bytesReturned == 0, "Bytes sent is %ld\n", bytesReturned);
8631
8632 closesocket(connector);
8633 connector = socket(AF_INET, SOCK_STREAM, 0);
8634 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8635 /* ConnectEx needs a bound socket */
8636 memset(&conaddress, 0, sizeof(conaddress));
8637 conaddress.sin_family = AF_INET;
8638 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8639 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8640 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8641
8642 acceptor = accept(listener, NULL, NULL);
8643 ok(acceptor != INVALID_SOCKET, "failed to accept socket, error %u\n", WSAGetLastError());
8644
8645 buffer[0] = '1';
8646 buffer[1] = '2';
8647 buffer[2] = '3';
8648 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, buffer, 3, &bytesReturned, &overlapped);
8649 memset(buffer, 0, 3);
8650 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
8651 "returned %d + errno %d\n", bret, WSAGetLastError());
8652 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8653 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %ld + errno %ld\n", dwret, GetLastError());
8654
8655 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8656 ok(bret, "Connecting failed, error %ld\n", GetLastError());
8657 ok(bytesReturned == 3, "Bytes sent is %ld\n", bytesReturned);
8658
8659 acceptor = accept(listener, NULL, NULL);
8660 ok(acceptor != INVALID_SOCKET, "could not accept socket error %d\n", WSAGetLastError());
8661
8662 bytesReturned = recv(acceptor, buffer, 3, 0);
8663 buffer[4] = 0;
8664 ok(bytesReturned == 3, "Didn't get all sent data, got only %ld\n", bytesReturned);
8665 ok(buffer[0] == '1' && buffer[1] == '2' && buffer[2] == '3',
8666 "Failed to get the right data, expected '123', got '%s'\n", buffer);
8667
8668 WSASetLastError(0xdeadbeef);
8669 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8670 ok(iret == -1, "got %d\n", iret);
8671 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8672
8673 WSASetLastError(0xdeadbeef);
8674 iret = connect(acceptor, (struct sockaddr *)&address, sizeof(address));
8675 ok(iret == -1, "got %d\n", iret);
8676 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8677
8678 WSASetLastError(0xdeadbeef);
8679 overlapped.Internal = 0xdeadbeef;
8680 overlapped.InternalHigh = 0xdeadbeef;
8681 bret = pConnectEx(connector, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8682 ok(!bret, "got %d\n", bret);
8683 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8684 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8685 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8686
8687 WSASetLastError(0xdeadbeef);
8688 overlapped.Internal = 0xdeadbeef;
8689 overlapped.InternalHigh = 0xdeadbeef;
8690 bret = pConnectEx(acceptor, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8691 ok(!bret, "got %d\n", bret);
8692 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8693 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8694 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8695
8696 closesocket(connector);
8697 closesocket(acceptor);
8698
8699 tcp_socketpair(&connector, &acceptor);
8700
8701 WSASetLastError(0xdeadbeef);
8702 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8703 ok(iret == -1, "got %d\n", iret);
8704 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8705
8706 WSASetLastError(0xdeadbeef);
8707 iret = connect(acceptor, (struct sockaddr *)&address, sizeof(address));
8708 ok(iret == -1, "got %d\n", iret);
8709 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8710
8711 WSASetLastError(0xdeadbeef);
8712 overlapped.Internal = 0xdeadbeef;
8713 overlapped.InternalHigh = 0xdeadbeef;
8714 bret = pConnectEx(connector, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8715 ok(!bret, "got %d\n", bret);
8716 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8717 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8718 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8719
8720 WSASetLastError(0xdeadbeef);
8721 overlapped.Internal = 0xdeadbeef;
8722 overlapped.InternalHigh = 0xdeadbeef;
8723 bret = pConnectEx(acceptor, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8724 ok(!bret, "got %d\n", bret);
8725 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8726 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8727 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8728
8729 closesocket(connector);
8730 closesocket(acceptor);
8731
8732 /* Connect with error */
8733
8734 connector = socket(AF_INET, SOCK_STREAM, 0);
8735 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8736 /* ConnectEx needs a bound socket */
8737 memset(&conaddress, 0, sizeof(conaddress));
8738 conaddress.sin_family = AF_INET;
8739 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8740 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8741 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8742
8743 address.sin_port = htons(1);
8744
8745 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8746 ok(bret == FALSE && GetLastError() == ERROR_IO_PENDING, "ConnectEx to bad destination failed: "
8747 "returned %d + errno %ld\n", bret, GetLastError());
8748 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8749 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %ld + errno %ld\n", dwret, GetLastError());
8750
8751 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8752 ok(bret == FALSE && GetLastError() == ERROR_CONNECTION_REFUSED,
8753 "Connecting to a disconnected host returned error %d - %d\n", bret, WSAGetLastError());
8754
8755 WSACloseEvent(overlapped.hEvent);
8756 closesocket(connector);
8757
8758 if (0)
8759 {
8760 /* Wait in connect() is alertable. This may take a very long time before connection fails,
8761 * so disable the test. Testing with localhost is unreliable as that may avoid waiting in
8762 * accept(). */
8763 connector = socket(AF_INET, SOCK_STREAM, 0);
8764 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8765 address.sin_addr.s_addr = inet_addr("8.8.8.8");
8766 address.sin_port = htons(255);
8767
8768 apc_count = 0;
8769 SleepEx(0, TRUE);
8770 ok(apc_count == 0, "got apc_count %d.\n", apc_count);
8771 bret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
8772 ok(bret, "QueueUserAPC returned %d\n", bret);
8773 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8774 ok(apc_count == 1, "got apc_count %d.\n", apc_count);
8775 ok(iret == -1 && (WSAGetLastError() == WSAECONNREFUSED || WSAGetLastError() == WSAETIMEDOUT),
8776 "unexpected iret %d, error %d.\n", iret, WSAGetLastError());
8777 closesocket(connector);
8778 }
8779
8780 /* Test connect after previous connect attempt failure. */
8781 connector = socket(AF_INET, SOCK_STREAM, 0);
8782 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8783
8784 conaddress.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
8785 conaddress.sin_port = htons(255);
8786 iret = connect(connector, (struct sockaddr *)&conaddress, sizeof(conaddress));
8787 ok(iret == -1, "connection succeeded.\n");
8788
8789 ok(WSAGetLastError() == WSAECONNREFUSED, "got error %u\n", WSAGetLastError());
8790 set_blocking( connector, FALSE );
8791 iret = getsockname(listener, (struct sockaddr*)&address, &addrlen);
8792 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
8793
8794 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8795 ok(iret == -1 && WSAGetLastError() == WSAEWOULDBLOCK, "unexpected iret %d, error %d.\n",
8796 iret, WSAGetLastError());
8797 acceptor = accept(listener, NULL, NULL);
8798 ok(acceptor != INVALID_SOCKET, "could not accept socket error %d\n", WSAGetLastError());
8799
8800 closesocket(acceptor);
8801 closesocket(connector);
8802 closesocket(listener);
8803 }
8804
8805 static void test_AcceptEx(void)
8806 {
8807 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
8808 SOCKET listener, acceptor, acceptor2, connector, connector2;
8809 struct sockaddr_in bindAddress, peerAddress, *readBindAddress, *readRemoteAddress;
8810 int socklen, iret, localSize = sizeof(struct sockaddr_in), remoteSize = localSize;
8811 GUID acceptExGuid = WSAID_ACCEPTEX, getAcceptExGuid = WSAID_GETACCEPTEXSOCKADDRS;
8812 GUID connectex_guid = WSAID_CONNECTEX;
8813 LPFN_ACCEPTEX pAcceptEx = NULL;
8814 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs = NULL;
8815 LPFN_CONNECTEX pConnectEx = NULL;
8816 fd_set fds_accept, fds_send;
8817 static const struct timeval timeout = {1, 0};
8818 char buffer[1024], ipbuffer[32];
8819 OVERLAPPED overlapped = {0}, overlapped2 = {0};
8820 DWORD bytesReturned, dwret;
8821 BOOL bret;
8822
8823 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8824 overlapped2.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8825
8826 listener = socket(AF_INET, SOCK_STREAM, 0);
8827 ok(listener != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8828
8829 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8830 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8831
8832 memset(&bindAddress, 0, sizeof(bindAddress));
8833 bindAddress.sin_family = AF_INET;
8834 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8835 iret = bind(listener, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8836 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8837
8838 socklen = sizeof(bindAddress);
8839 iret = getsockname(listener, (struct sockaddr*)&bindAddress, &socklen);
8840 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
8841
8842 iret = set_blocking(listener, FALSE);
8843 ok(!iret, "Failed to set nonblocking, error %u\n", WSAGetLastError());
8844
8845 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
8846 &pAcceptEx, sizeof(pAcceptEx), &bytesReturned, NULL, NULL);
8847 ok(!iret, "Failed to get AcceptEx, error %u\n", WSAGetLastError());
8848
8849 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &getAcceptExGuid, sizeof(getAcceptExGuid),
8850 &pGetAcceptExSockaddrs, sizeof(pGetAcceptExSockaddrs), &bytesReturned, NULL, NULL);
8851 ok(!iret, "Failed to get GetAcceptExSockaddrs, error %u\n", WSAGetLastError());
8852
8853 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectex_guid, sizeof(connectex_guid),
8854 &pConnectEx, sizeof(pConnectEx), &bytesReturned, NULL, NULL);
8855 ok(!iret, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
8856
8857 overlapped.Internal = 0xdeadbeef;
8858 bret = pAcceptEx(INVALID_SOCKET, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8859 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8860 &bytesReturned, &overlapped);
8861 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid listening socket "
8862 "returned %d + errno %d\n", bret, WSAGetLastError());
8863 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8864
8865 overlapped.Internal = 0xdeadbeef;
8866 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8867 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8868 &bytesReturned, &overlapped);
8869 todo_wine
8870 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on a non-listening socket "
8871 "returned %d + errno %d\n", bret, WSAGetLastError());
8872 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8873 if (!bret && WSAGetLastError() == ERROR_IO_PENDING)
8874 CancelIo((HANDLE)listener);
8875
8876 iret = listen(listener, 5);
8877 ok(!iret, "failed to listen, error %lu\n", GetLastError());
8878
8879 overlapped.Internal = 0xdeadbeef;
8880 bret = pAcceptEx(listener, INVALID_SOCKET, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8881 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8882 &bytesReturned, &overlapped);
8883 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid accepting socket "
8884 "returned %d + errno %d\n", bret, WSAGetLastError());
8885 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8886
8887 overlapped.Internal = 0xdeadbeef;
8888 bret = pAcceptEx(listener, acceptor, NULL, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8889 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8890 &bytesReturned, &overlapped);
8891 todo_wine ok(bret == FALSE && WSAGetLastError() == WSAEFAULT,
8892 "AcceptEx on NULL buffer returned %d + errno %d\n", bret, WSAGetLastError());
8893 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8894
8895 overlapped.Internal = 0xdeadbeef;
8896 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
8897 &bytesReturned, &overlapped);
8898 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING,
8899 "AcceptEx on too small local address size returned %d + errno %d\n",
8900 bret, WSAGetLastError());
8901 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8902
8903 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8904 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
8905 iret = connect(connector, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
8906 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
8907 iret = getsockname(connector, (struct sockaddr *)&peerAddress, &remoteSize);
8908 ok(!iret, "getsockname failed, error %u\n", WSAGetLastError());
8909
8910 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8911 ok(!dwret, "wait failed\n");
8912 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8913 ok(bret, "got error %lu\n", GetLastError());
8914 ok(!(NTSTATUS)overlapped.Internal, "got %#Ix\n", overlapped.Internal);
8915 ok(!bytesReturned, "got size %lu\n", bytesReturned);
8916
8917 readBindAddress = readRemoteAddress = (struct sockaddr_in *)0xdeadbeef;
8918 localSize = remoteSize = 0xdeadbeef;
8919 pGetAcceptExSockaddrs(buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
8920 (struct sockaddr **)&readBindAddress, &localSize, (struct sockaddr **)&readRemoteAddress, &remoteSize);
8921 todo_wine ok(readBindAddress == (struct sockaddr_in *)0xdeadbeef, "got local addr %p\n", readBindAddress);
8922 ok(!memcmp(readRemoteAddress, &peerAddress, sizeof(peerAddress)), "remote addr didn't match\n");
8923 todo_wine ok(localSize == 0xdeadbeef, "got local size %u\n", localSize);
8924 ok(remoteSize == sizeof(struct sockaddr_in), "got remote size %u\n", remoteSize);
8925
8926 closesocket(connector);
8927 closesocket(acceptor);
8928
8929 /* A UDP socket cannot be accepted into. */
8930
8931 acceptor = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
8932
8933 overlapped.Internal = 0xdeadbeef;
8934 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8935 ok(!bret, "expected failure\n");
8936 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8937 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8938 if (WSAGetLastError() == ERROR_IO_PENDING)
8939 CancelIo((HANDLE)listener);
8940
8941 closesocket(acceptor);
8942
8943 /* A bound socket cannot be accepted into. */
8944
8945 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8946 iret = bind(acceptor, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
8947 ok(!iret, "got error %u\n", WSAGetLastError());
8948
8949 overlapped.Internal = 0xdeadbeef;
8950 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8951 ok(!bret, "expected failure\n");
8952 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8953 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8954 if (WSAGetLastError() == ERROR_IO_PENDING)
8955 CancelIo((HANDLE)listener);
8956
8957 closesocket(acceptor);
8958
8959 /* A connected socket cannot be accepted into. */
8960
8961 tcp_socketpair(&acceptor, &acceptor2);
8962
8963 overlapped.Internal = 0xdeadbeef;
8964 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8965 ok(!bret, "expected failure\n");
8966 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8967 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8968 if (WSAGetLastError() == ERROR_IO_PENDING)
8969 CancelIo((HANDLE)listener);
8970
8971 overlapped.Internal = 0xdeadbeef;
8972 bret = pAcceptEx(listener, acceptor2, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8973 ok(!bret, "expected failure\n");
8974 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8975 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8976 if (WSAGetLastError() == ERROR_IO_PENDING)
8977 CancelIo((HANDLE)listener);
8978
8979 closesocket(acceptor);
8980 closesocket(acceptor2);
8981
8982 /* Pass an insufficient local address size. */
8983
8984 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8985 ok(acceptor != -1, "failed to create socket, error %u\n", WSAGetLastError());
8986
8987 overlapped.Internal = 0xdeadbeef;
8988 bret = pAcceptEx(listener, acceptor, buffer, 0, 3,
8989 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8990 ok(!bret && WSAGetLastError() == ERROR_IO_PENDING, "got %d, error %u\n", bret, WSAGetLastError());
8991 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got %#Ix\n", overlapped.Internal);
8992
8993 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8994 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
8995 iret = connect(connector, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
8996 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
8997
8998 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8999 ok(!dwret, "wait failed\n");
9000 bytesReturned = 0xdeadbeef;
9001 SetLastError(0xdeadbeef);
9002 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9003 ok(!bret, "expected failure\n");
9004 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got error %lu\n", GetLastError());
9005 ok((NTSTATUS)overlapped.Internal == STATUS_BUFFER_TOO_SMALL, "got %#Ix\n", overlapped.Internal);
9006 ok(!bytesReturned, "got size %lu\n", bytesReturned);
9007
9008 closesocket(acceptor);
9009
9010 /* The above connection request is not accepted. */
9011 acceptor = accept(listener, NULL, NULL);
9012 todo_wine ok(acceptor != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
9013 closesocket(acceptor);
9014
9015 closesocket(connector);
9016
9017 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9018 ok(acceptor != -1, "failed to create socket, error %u\n", WSAGetLastError());
9019
9020 overlapped.Internal = 0xdeadbeef;
9021 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 4,
9022 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
9023 ok(!bret && WSAGetLastError() == ERROR_IO_PENDING, "got %d, error %u\n", bret, WSAGetLastError());
9024 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got %#Ix\n", overlapped.Internal);
9025
9026 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9027 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
9028 iret = connect(connector, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
9029 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
9030
9031 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
9032 ok(!dwret, "wait failed\n");
9033 bytesReturned = 0xdeadbeef;
9034 SetLastError(0xdeadbeef);
9035 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9036 todo_wine ok(!bret, "expected failure\n");
9037 todo_wine ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got error %lu\n", GetLastError());
9038 todo_wine ok((NTSTATUS)overlapped.Internal == STATUS_BUFFER_TOO_SMALL, "got %#Ix\n", overlapped.Internal);
9039 ok(!bytesReturned, "got size %lu\n", bytesReturned);
9040
9041 closesocket(acceptor);
9042
9043 /* The above connection request is not accepted. */
9044 acceptor = accept(listener, NULL, NULL);
9045 todo_wine ok(acceptor != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
9046 closesocket(acceptor);
9047
9048 closesocket(connector);
9049
9050 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9051 ok(acceptor != -1, "failed to create socket, error %u\n", WSAGetLastError());
9052
9053 overlapped.Internal = 0xdeadbeef;
9054 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 15,
9055 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
9056 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx on too small local address "
9057 "size returned %d + errno %d\n",
9058 bret, WSAGetLastError());
9059 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
9060 bret = CancelIo((HANDLE) listener);
9061 ok(bret, "Failed to cancel pending accept socket\n");
9062
9063 overlapped.Internal = 0xdeadbeef;
9064 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16, 0,
9065 &bytesReturned, &overlapped);
9066 ok(bret == FALSE && WSAGetLastError() == WSAEFAULT,
9067 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
9068 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
9069
9070 overlapped.Internal = 0xdeadbeef;
9071 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16,
9072 sizeof(struct sockaddr_in) + 15, &bytesReturned, &overlapped);
9073 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING,
9074 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
9075 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
9076 bret = CancelIo((HANDLE) listener);
9077 ok(bret, "Failed to cancel pending accept socket\n");
9078
9079 bret = pAcceptEx(listener, acceptor, buffer, 0,
9080 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9081 &bytesReturned, NULL);
9082 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
9083 "returned %d + errno %d\n", bret, WSAGetLastError());
9084
9085 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, 0, &bytesReturned, NULL);
9086 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
9087 "returned %d + errno %d\n", bret, WSAGetLastError());
9088
9089 overlapped.Internal = 0xdeadbeef;
9090 bret = pAcceptEx(listener, acceptor, buffer, 0,
9091 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9092 &bytesReturned, &overlapped);
9093 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
9094 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
9095
9096 /* try to accept into the same socket twice */
9097 overlapped.Internal = 0xdeadbeef;
9098 bret = pAcceptEx(listener, acceptor, buffer, 0,
9099 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9100 &bytesReturned, &overlapped);
9101 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL,
9102 "AcceptEx on already pending socket returned %d + errno %d\n", bret, WSAGetLastError());
9103 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
9104
9105 /* try to connect a socket that's being accepted into */
9106 iret = connect(acceptor, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9107 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL,
9108 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret, WSAGetLastError());
9109
9110 bret = pConnectEx(acceptor, (struct sockaddr *)&bindAddress, sizeof(bindAddress),
9111 NULL, 0, &bytesReturned, &overlapped2);
9112 ok(!bret, "expected failure\n");
9113 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
9114
9115 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9116 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
9117 overlapped.Internal = 0xdeadbeef;
9118 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9119 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
9120
9121 dwret = WaitForSingleObject(overlapped.hEvent, INFINITE);
9122 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
9123 ok(overlapped.Internal == STATUS_SUCCESS, "got %08lx\n", (ULONG)overlapped.Internal);
9124
9125 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9126 ok(bret, "GetOverlappedResult failed, error %ld\n", GetLastError());
9127 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %ld\n", bytesReturned);
9128
9129 /* Try to call getsockname on the acceptor socket.
9130 *
9131 * On Windows, this requires setting SO_UPDATE_ACCEPT_CONTEXT. */
9132 iret = setsockopt(acceptor, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, (char *)&listener, sizeof(SOCKET));
9133 ok(!iret, "Failed to set accept context %ld\n", GetLastError());
9134 iret = getsockname(acceptor, (struct sockaddr *)&peerAddress, &remoteSize);
9135 ok(!iret, "getsockname failed.\n");
9136 ok(remoteSize == sizeof(struct sockaddr_in), "got remote size %u\n", remoteSize);
9137
9138 closesocket(connector);
9139 connector = INVALID_SOCKET;
9140 closesocket(acceptor);
9141
9142 /* Test short reads */
9143
9144 acceptor = socket(AF_INET, SOCK_STREAM, 0);
9145 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9146 connector = socket(AF_INET, SOCK_STREAM, 0);
9147 ok(connector != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9148 overlapped.Internal = 0xdeadbeef;
9149 bret = pAcceptEx(listener, acceptor, buffer, 2,
9150 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9151 &bytesReturned, &overlapped);
9152 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
9153 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
9154
9155 /* AcceptEx() still won't complete until we send data */
9156 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9157 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
9158
9159 dwret = WaitForSingleObject(overlapped.hEvent, 0);
9160 ok(dwret == WAIT_TIMEOUT, "Waiting for accept event timeout failed with %ld + errno %ld\n", dwret, GetLastError());
9161 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
9162
9163 iret = getsockname( connector, (struct sockaddr *)&peerAddress, &remoteSize);
9164 ok( !iret, "getsockname failed.\n");
9165
9166 /* AcceptEx() could complete any time now */
9167 iret = send(connector, buffer, 1, 0);
9168 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
9169
9170 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
9171 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
9172 ok(overlapped.Internal == STATUS_SUCCESS, "got %08lx\n", (ULONG)overlapped.Internal);
9173
9174 /* Check if the buffer from AcceptEx is decoded correctly */
9175 pGetAcceptExSockaddrs(buffer, 2, sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9176 (struct sockaddr **)&readBindAddress, &localSize,
9177 (struct sockaddr **)&readRemoteAddress, &remoteSize);
9178 strcpy( ipbuffer, inet_ntoa(readBindAddress->sin_addr));
9179 ok( readBindAddress->sin_addr.s_addr == bindAddress.sin_addr.s_addr,
9180 "Local socket address is different %s != %s\n",
9181 ipbuffer, inet_ntoa(bindAddress.sin_addr));
9182 ok( readBindAddress->sin_port == bindAddress.sin_port,
9183 "Local socket port is different: %d != %d\n",
9184 readBindAddress->sin_port, bindAddress.sin_port);
9185 strcpy( ipbuffer, inet_ntoa(readRemoteAddress->sin_addr));
9186 ok( readRemoteAddress->sin_addr.s_addr == peerAddress.sin_addr.s_addr,
9187 "Remote socket address is different %s != %s\n",
9188 ipbuffer, inet_ntoa(peerAddress.sin_addr));
9189 ok( readRemoteAddress->sin_port == peerAddress.sin_port,
9190 "Remote socket port is different: %d != %d\n",
9191 readRemoteAddress->sin_port, peerAddress.sin_port);
9192
9193 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9194 ok(bret, "GetOverlappedResult failed, error %ld\n", GetLastError());
9195 ok(bytesReturned == 1, "bytesReturned isn't supposed to be %ld\n", bytesReturned);
9196
9197 closesocket(connector);
9198 connector = INVALID_SOCKET;
9199 closesocket(acceptor);
9200
9201 /* Test CF_DEFER & AcceptEx interaction */
9202
9203 acceptor = socket(AF_INET, SOCK_STREAM, 0);
9204 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9205 connector = socket(AF_INET, SOCK_STREAM, 0);
9206 ok(connector != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9207 connector2 = socket(AF_INET, SOCK_STREAM, 0);
9208 ok(connector2 != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9209
9210 iret = set_blocking(connector, FALSE);
9211 ok(!iret, "failed to set nonblocking, error %lu\n", GetLastError());
9212 iret = set_blocking(connector2, FALSE);
9213 ok(!iret, "failed to set nonblocking, error %lu\n", GetLastError());
9214
9215 /* Connect socket #1 */
9216 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9217 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
9218
9219 buffer[0] = '0';
9220
9221 FD_ZERO(&fds_accept);
9222 FD_SET(listener, &fds_accept);
9223 iret = select(0, &fds_accept, NULL, NULL, &timeout);
9224 ok(iret == 1, "wait timed out\n");
9225
9226 acceptor2 = WSAAccept(listener, NULL, NULL, AlwaysDeferConditionFunc, 0);
9227 ok(acceptor2 == INVALID_SOCKET, "expected failure\n");
9228 ok(WSAGetLastError() == WSATRY_AGAIN, "got error %u\n", WSAGetLastError());
9229 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16,
9230 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
9231 ok(!bret, "expected failure\n");
9232 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
9233
9234 FD_ZERO(&fds_send);
9235 FD_SET(connector, &fds_send);
9236 iret = select(0, NULL, &fds_send, NULL, &timeout);
9237 ok(iret == 1, "wait timed out\n");
9238
9239 iret = send(connector, "1", 1, 0);
9240 ok(iret == 1, "got ret %d, error %u\n", iret, WSAGetLastError());
9241
9242 iret = connect(connector2, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
9243 ok(iret == SOCKET_ERROR, "expected failure\n");
9244 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
9245
9246 iret = select(0, &fds_accept, NULL, NULL, &timeout);
9247 ok(iret == 1, "wait timed out\n");
9248
9249 acceptor2 = accept(listener, NULL, NULL);
9250 ok(acceptor2 != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
9251 closesocket(acceptor2);
9252
9253 FD_ZERO(&fds_send);
9254 FD_SET(connector2, &fds_send);
9255 iret = select(0, NULL, &fds_send, NULL, &timeout);
9256 ok(iret == 1, "wait timed out\n");
9257
9258 iret = send(connector2, "2", 1, 0);
9259 ok(iret == 1, "got ret %d, error %u\n", iret, WSAGetLastError());
9260
9261 dwret = WaitForSingleObject(overlapped.hEvent, 0);
9262 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
9263
9264 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9265 ok(bret, "GetOverlappedResult failed, error %ld\n", GetLastError());
9266 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %ld\n", bytesReturned);
9267
9268 set_blocking(acceptor, TRUE);
9269 iret = recv( acceptor, buffer, 2, 0);
9270 ok(iret == 1, "Failed to get data, %d, errno: %d\n", iret, WSAGetLastError());
9271 ok(buffer[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer[0]);
9272
9273 closesocket(connector);
9274 closesocket(connector2);
9275 closesocket(acceptor);
9276
9277 /* clean up in case of failures */
9278 while ((acceptor = accept(listener, NULL, NULL)) != INVALID_SOCKET)
9279 closesocket(acceptor);
9280
9281 /* Disconnect during receive? */
9282
9283 acceptor = socket(AF_INET, SOCK_STREAM, 0);
9284 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9285 connector = socket(AF_INET, SOCK_STREAM, 0);
9286 ok(connector != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9287 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
9288 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9289 &bytesReturned, &overlapped);
9290 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
9291
9292 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9293 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
9294
9295 closesocket(connector);
9296 connector = INVALID_SOCKET;
9297
9298 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
9299 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
9300
9301 bytesReturned = 123456;
9302 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9303 ok(bret, "GetOverlappedResult failed, error %ld\n", GetLastError());
9304 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %ld\n", bytesReturned);
9305
9306 closesocket(acceptor);
9307
9308 /* Test closing with pending requests */
9309
9310 acceptor = socket(AF_INET, SOCK_STREAM, 0);
9311 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9312 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
9313 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9314 &bytesReturned, &overlapped);
9315 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
9316
9317 closesocket(acceptor);
9318
9319 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
9320 ok(dwret == WAIT_OBJECT_0,
9321 "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
9322 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9323 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %ld\n", GetLastError());
9324
9325 acceptor = socket(AF_INET, SOCK_STREAM, 0);
9326 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9327 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
9328 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9329 &bytesReturned, &overlapped);
9330 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
9331
9332 CancelIo((HANDLE) acceptor);
9333
9334 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
9335 ok(dwret == WAIT_TIMEOUT, "Waiting for timeout failed with %ld + errno %ld\n", dwret, GetLastError());
9336
9337 closesocket(acceptor);
9338
9339 acceptor = socket(AF_INET, SOCK_STREAM, 0);
9340 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9341 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
9342 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9343 &bytesReturned, &overlapped);
9344 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
9345
9346 closesocket(listener);
9347
9348 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
9349 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
9350
9351 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
9352 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %ld\n", GetLastError());
9353
9354 CloseHandle(overlapped.hEvent);
9355 CloseHandle(overlapped2.hEvent);
9356 closesocket(acceptor);
9357 closesocket(connector2);
9358 }
9359
9360 static void test_shutdown(void)
9361 {
9362 struct sockaddr_in addr, server_addr, client_addr;
9363 SOCKET listener, client, server;
9364 OVERLAPPED overlapped = {0};
9365 DWORD size, flags = 0;
9366 int ret, addrlen;
9367 char buffer[5];
9368 WSABUF wsabuf;
9369
9370 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9371 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9372 ok(listener != INVALID_SOCKET, "failed to create listener socket, error %d\n", WSAGetLastError());
9373
9374 memset(&addr, 0, sizeof(addr));
9375 addr.sin_family = AF_INET;
9376 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
9377 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
9378 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9379 addrlen = sizeof(server_addr);
9380 ret = getsockname(listener, (struct sockaddr *)&server_addr, &addrlen);
9381 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
9382
9383 ret = listen(listener, 1);
9384 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
9385
9386 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9387 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9388
9389 WSASetLastError(0xdeadbeef);
9390 ret = shutdown(client, SD_SEND);
9391 ok(ret == -1, "expected failure\n");
9392 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9393
9394 WSASetLastError(0xdeadbeef);
9395 ret = shutdown(client, SD_RECEIVE);
9396 ok(ret == -1, "expected failure\n");
9397 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9398
9399 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9400 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9401 server = accept(listener, NULL, NULL);
9402 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9403 set_blocking(client, FALSE);
9404
9405 WSASetLastError(0xdeadbeef);
9406 ret = shutdown(client, SD_SEND);
9407 ok(!ret, "expected success\n");
9408 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9409
9410 WSASetLastError(0xdeadbeef);
9411 ret = shutdown(client, SD_SEND);
9412 ok(!ret, "expected success\n");
9413 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9414
9415 WSASetLastError(0xdeadbeef);
9416 ret = send(client, "test", 5, 0);
9417 ok(ret == -1, "got %d\n", ret);
9418 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9419
9420 ret = recv(server, buffer, sizeof(buffer), 0);
9421 ok(!ret, "got %d\n", ret);
9422 ret = recv(server, buffer, sizeof(buffer), 0);
9423 ok(!ret, "got %d\n", ret);
9424
9425 WSASetLastError(0xdeadbeef);
9426 ret = shutdown(server, SD_RECEIVE);
9427 ok(!ret, "expected success\n");
9428 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9429
9430 WSASetLastError(0xdeadbeef);
9431 ret = recv(server, buffer, sizeof(buffer), 0);
9432 ok(ret == -1, "got %d\n", ret);
9433 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9434
9435 ret = send(server, "test", 5, 0);
9436 ok(ret == 5, "got %d\n", ret);
9437
9438 ret = sync_recv(client, buffer, sizeof(buffer), 0);
9439 ok(ret == 5, "got %d\n", ret);
9440 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, ret));
9441
9442 WSASetLastError(0xdeadbeef);
9443 ret = shutdown(client, SD_RECEIVE);
9444 ok(!ret, "expected success\n");
9445 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9446
9447 WSASetLastError(0xdeadbeef);
9448 ret = recv(client, buffer, sizeof(buffer), 0);
9449 ok(ret == -1, "got %d\n", ret);
9450 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9451
9452 WSASetLastError(0xdeadbeef);
9453 ret = recv(client, buffer, sizeof(buffer), 0);
9454 ok(ret == -1, "got %d\n", ret);
9455 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9456
9457 WSASetLastError(0xdeadbeef);
9458 ret = shutdown(server, SD_SEND);
9459 ok(!ret, "expected success\n");
9460 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9461
9462 WSASetLastError(0xdeadbeef);
9463 ret = send(server, "test", 5, 0);
9464 ok(ret == -1, "got %d\n", ret);
9465 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9466
9467 addrlen = sizeof(addr);
9468 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
9469 ok(!ret, "got error %u\n", WSAGetLastError());
9470 ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
9471
9472 addrlen = sizeof(client_addr);
9473 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
9474 ok(!ret, "got error %u\n", WSAGetLastError());
9475 addrlen = sizeof(addr);
9476 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
9477 ok(!ret, "got error %u\n", WSAGetLastError());
9478 ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
9479
9480 WSASetLastError(0xdeadbeef);
9481 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9482 ok(ret == -1, "got %d\n", ret);
9483 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
9484
9485 WSASetLastError(0xdeadbeef);
9486 ret = shutdown(client, 0xdeadbeef);
9487 ok(ret == -1, "expected failure\n");
9488 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
9489
9490 closesocket(client);
9491 closesocket(server);
9492
9493 /* Test SD_BOTH. */
9494
9495 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9496 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9497 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9498 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9499 server = accept(listener, NULL, NULL);
9500 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9501
9502 WSASetLastError(0xdeadbeef);
9503 ret = shutdown(client, SD_BOTH);
9504 ok(!ret, "expected success\n");
9505 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9506
9507 WSASetLastError(0xdeadbeef);
9508 ret = recv(client, buffer, sizeof(buffer), 0);
9509 ok(ret == -1, "got %d\n", ret);
9510 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9511
9512 WSASetLastError(0xdeadbeef);
9513 ret = send(client, "test", 5, 0);
9514 ok(ret == -1, "got %d\n", ret);
9515 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9516
9517 ret = recv(server, buffer, sizeof(buffer), 0);
9518 ok(!ret, "got %d\n", ret);
9519
9520 WSASetLastError(0xdeadbeef);
9521 ret = shutdown(server, SD_BOTH);
9522 ok(!ret, "expected success\n");
9523 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9524
9525 WSASetLastError(0xdeadbeef);
9526 ret = recv(server, buffer, sizeof(buffer), 0);
9527 ok(ret == -1, "got %d\n", ret);
9528 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9529
9530 WSASetLastError(0xdeadbeef);
9531 ret = send(server, "test", 5, 0);
9532 ok(ret == -1, "got %d\n", ret);
9533 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9534
9535 addrlen = sizeof(addr);
9536 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
9537 ok(!ret, "got error %u\n", WSAGetLastError());
9538 ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
9539
9540 addrlen = sizeof(client_addr);
9541 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
9542 ok(!ret, "got error %u\n", WSAGetLastError());
9543 addrlen = sizeof(addr);
9544 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
9545 ok(!ret, "got error %u\n", WSAGetLastError());
9546 ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
9547
9548 closesocket(client);
9549 closesocket(server);
9550
9551 /* Send data to a peer which is closed. */
9552
9553 tcp_socketpair(&client, &server);
9554
9555 WSASetLastError(0xdeadbeef);
9556 ret = shutdown(client, SD_SEND);
9557 ok(!ret, "expected success\n");
9558 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9559 closesocket(client);
9560
9561 ret = send(server, "test", 5, 0);
9562 ok(ret == 5, "got %d\n", ret);
9563
9564 WSASetLastError(0xdeadbeef);
9565 ret = recv(server, buffer, sizeof(buffer), 0);
9566 ok(ret == -1, "got %d\n", ret);
9567 todo_wine ok(WSAGetLastError() == WSAECONNABORTED, "got error %u\n", WSAGetLastError());
9568
9569 closesocket(server);
9570
9571 /* Test shutting down with async I/O pending. */
9572
9573 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9574 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9575 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9576 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9577 server = accept(listener, NULL, NULL);
9578 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9579 set_blocking(client, FALSE);
9580
9581 wsabuf.buf = buffer;
9582 wsabuf.len = sizeof(buffer);
9583 WSASetLastError(0xdeadbeef);
9584 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
9585 ok(ret == -1, "got %d\n", ret);
9586 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
9587
9588 ret = shutdown(client, SD_RECEIVE);
9589 ok(!ret, "got error %u\n", WSAGetLastError());
9590
9591 WSASetLastError(0xdeadbeef);
9592 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
9593 ok(ret == -1, "got %d\n", ret);
9594 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9595
9596 ret = send(server, "test", 5, 0);
9597 ok(ret == 5, "got %d\n", ret);
9598
9599 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9600 ok(!ret, "wait timed out\n");
9601 size = 0xdeadbeef;
9602 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
9603 ok(ret, "got error %lu\n", GetLastError());
9604 ok(size == 5, "got size %lu\n", size);
9605 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, size));
9606
9607 WSASetLastError(0xdeadbeef);
9608 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
9609 ok(ret == -1, "got %d\n", ret);
9610 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9611
9612 WSASetLastError(0xdeadbeef);
9613 ret = WSARecv(server, &wsabuf, 1, &size, &flags, &overlapped, NULL);
9614 ok(ret == -1, "got %d\n", ret);
9615 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
9616
9617 ret = shutdown(client, SD_SEND);
9618 ok(!ret, "got error %u\n", WSAGetLastError());
9619
9620 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9621 ok(!ret, "wait timed out\n");
9622 size = 0xdeadbeef;
9623 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
9624 ok(ret, "got error %lu\n", GetLastError());
9625 ok(!size, "got size %lu\n", size);
9626
9627 closesocket(client);
9628 closesocket(server);
9629
9630 /* Test shutting down a listening socket. */
9631
9632 WSASetLastError(0xdeadbeef);
9633 ret = shutdown(listener, SD_SEND);
9634 ok(ret == -1, "expected failure\n");
9635 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9636
9637 WSASetLastError(0xdeadbeef);
9638 ret = shutdown(listener, SD_RECEIVE);
9639 ok(ret == -1, "expected failure\n");
9640 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9641
9642 closesocket(listener);
9643
9644 /* Test shutting down UDP sockets. */
9645
9646 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
9647 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
9648 memset(&addr, 0, sizeof(addr));
9649 addr.sin_family = AF_INET;
9650 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
9651 ret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
9652 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9653 addrlen = sizeof(server_addr);
9654 ret = getsockname(server, (struct sockaddr *)&server_addr, &addrlen);
9655 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
9656 set_blocking(server, FALSE);
9657
9658 WSASetLastError(0xdeadbeef);
9659 ret = shutdown(server, SD_RECEIVE);
9660 ok(!ret, "expected success\n");
9661 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9662
9663 WSASetLastError(0xdeadbeef);
9664 ret = recvfrom(server, buffer, sizeof(buffer), 0, NULL, NULL);
9665 ok(ret == -1, "got %d\n", ret);
9666 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9667
9668 ret = sendto(client, "test", 5, 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
9669 ok(ret == 5, "got %d\n", ret);
9670
9671 WSASetLastError(0xdeadbeef);
9672 ret = shutdown(client, SD_SEND);
9673 ok(!ret, "expected success\n");
9674 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9675
9676 WSASetLastError(0xdeadbeef);
9677 ret = shutdown(client, SD_SEND);
9678 ok(!ret, "expected success\n");
9679 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9680
9681 WSASetLastError(0xdeadbeef);
9682 ret = sendto(client, "test", 5, 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
9683 ok(ret == -1, "got %d\n", ret);
9684 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9685
9686 closesocket(client);
9687 closesocket(server);
9688
9689 CloseHandle(overlapped.hEvent);
9690 }
9691
9692 static void test_DisconnectEx(void)
9693 {
9694 struct sockaddr_in server_addr, client_addr, addr;
9695 GUID disconnectex_guid = WSAID_DISCONNECTEX;
9696 SOCKET listener, server, client;
9697 LPFN_DISCONNECTEX pDisconnectEx;
9698 OVERLAPPED overlapped = {0};
9699 int addrlen, ret;
9700 char buffer[5];
9701 DWORD size;
9702
9703 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
9704
9705 client = socket(AF_INET, SOCK_STREAM, 0);
9706 ok(client != INVALID_SOCKET, "failed to create connector socket, error %u\n", WSAGetLastError());
9707
9708 ret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &disconnectex_guid, sizeof(disconnectex_guid),
9709 &pDisconnectEx, sizeof(pDisconnectEx), &size, NULL, NULL);
9710 if (ret)
9711 {
9712 win_skip("WSAIoctl failed to get DisconnectEx, error %d\n", WSAGetLastError());
9713 closesocket(client);
9714 return;
9715 }
9716
9717 listener = socket(AF_INET, SOCK_STREAM, 0);
9718 ok(listener != INVALID_SOCKET, "failed to create listener socket, error %d\n", WSAGetLastError());
9719
9720 memset(&addr, 0, sizeof(addr));
9721 addr.sin_family = AF_INET;
9722 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
9723 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
9724 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9725 addrlen = sizeof(server_addr);
9726 ret = getsockname(listener, (struct sockaddr *)&server_addr, &addrlen);
9727 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
9728 ret = listen(listener, 1);
9729 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
9730
9731 WSASetLastError(0xdeadbeef);
9732 ret = pDisconnectEx(INVALID_SOCKET, &overlapped, 0, 0);
9733 ok(!ret, "expected failure\n");
9734 ok(WSAGetLastError() == WSAENOTSOCK, "got error %u\n", WSAGetLastError());
9735
9736 WSASetLastError(0xdeadbeef);
9737 ret = pDisconnectEx(client, &overlapped, 0, 0);
9738 ok(!ret, "expected failure\n");
9739 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9740
9741 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9742 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9743 server = accept(listener, NULL, NULL);
9744 ok(server != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
9745
9746 WSASetLastError(0xdeadbeef);
9747 ret = pDisconnectEx(client, &overlapped, 0, 0);
9748 ok(!ret, "expected failure\n");
9749 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
9750
9751 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9752 ok(!ret, "wait timed out\n");
9753 size = 0xdeadbeef;
9754 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
9755 ok(ret, "got error %lu\n", GetLastError());
9756 ok(!size, "got size %lu\n", size);
9757
9758 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9759 ok(ret == -1, "expected failure\n");
9760 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
9761
9762 WSASetLastError(0xdeadbeef);
9763 ret = send(client, "test", 5, 0);
9764 ok(ret == -1, "expected failure\n");
9765 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9766
9767 ret = recv(server, buffer, sizeof(buffer), 0);
9768 ok(!ret, "got %d\n", ret);
9769
9770 ret = send(server, "test", 5, 0);
9771 ok(ret == 5, "got %d\n", ret);
9772
9773 ret = recv(client, buffer, sizeof(buffer), 0);
9774 ok(ret == 5, "got %d\n", ret);
9775 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, ret));
9776
9777 addrlen = sizeof(addr);
9778 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
9779 ok(!ret, "got error %u\n", WSAGetLastError());
9780 ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
9781
9782 addrlen = sizeof(client_addr);
9783 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
9784 ok(!ret, "got error %u\n", WSAGetLastError());
9785 addrlen = sizeof(addr);
9786 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
9787 ok(!ret, "got error %u\n", WSAGetLastError());
9788 ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
9789
9790 closesocket(client);
9791 closesocket(server);
9792
9793 /* Test the synchronous case. */
9794
9795 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9796 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9797 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9798 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9799 server = accept(listener, NULL, NULL);
9800 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9801
9802 WSASetLastError(0xdeadbeef);
9803 ret = pDisconnectEx(client, NULL, 0, 0);
9804 ok(ret, "expected success\n");
9805 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9806
9807 WSASetLastError(0xdeadbeef);
9808 ret = pDisconnectEx(client, NULL, 0, 0);
9809 ok(ret, "expected success\n");
9810 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9811
9812 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9813 ok(ret == -1, "expected failure\n");
9814 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
9815
9816 WSASetLastError(0xdeadbeef);
9817 ret = send(client, "test", 5, 0);
9818 ok(ret == -1, "expected failure\n");
9819 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9820
9821 ret = recv(server, buffer, sizeof(buffer), 0);
9822 ok(!ret, "got %d\n", ret);
9823
9824 ret = send(server, "test", 5, 0);
9825 ok(ret == 5, "got %d\n", ret);
9826
9827 ret = recv(client, buffer, sizeof(buffer), 0);
9828 ok(ret == 5, "got %d\n", ret);
9829 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, ret));
9830
9831 addrlen = sizeof(addr);
9832 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
9833 ok(!ret, "got error %u\n", WSAGetLastError());
9834 ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
9835
9836 addrlen = sizeof(client_addr);
9837 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
9838 ok(!ret, "got error %u\n", WSAGetLastError());
9839 addrlen = sizeof(addr);
9840 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
9841 ok(!ret, "got error %u\n", WSAGetLastError());
9842 ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
9843
9844 closesocket(client);
9845 closesocket(server);
9846
9847 closesocket(listener);
9848 CloseHandle(overlapped.hEvent);
9849 }
9850
9851 #define compare_file(h,s,o) compare_file2(h,s,o,__FILE__,__LINE__)
9852
9853 static void compare_file2(HANDLE handle, SOCKET sock, int offset, const char *file, int line)
9854 {
9855 char buf1[256], buf2[256];
9856 BOOL success;
9857 int i = 0;
9858
9859 SetFilePointer(handle, offset, NULL, FILE_BEGIN);
9860 while (1)
9861 {
9862 DWORD n1 = 0, n2 = 0;
9863
9864 success = ReadFile(handle, buf1, sizeof(buf1), &n1, NULL);
9865 ok_(file,line)(success, "Failed to read from file.\n");
9866 if (success && n1 == 0)
9867 break;
9868 else if(!success)
9869 return;
9870 n2 = recv(sock, buf2, n1, 0);
9871 ok_(file,line)(n1 == n2, "Block %d size mismatch (%ld != %ld)\n", i, n1, n2);
9872 ok_(file,line)(memcmp(buf1, buf2, n2) == 0, "Block %d failed\n", i);
9873 i++;
9874 }
9875 }
9876
9877 static void test_TransmitFile(void)
9878 {
9879 DWORD num_bytes, err, file_size, total_sent;
9880 GUID transmitFileGuid = WSAID_TRANSMITFILE;
9881 LPFN_TRANSMITFILE pTransmitFile = NULL;
9882 HANDLE file = INVALID_HANDLE_VALUE;
9883 char header_msg[] = "hello world";
9884 char footer_msg[] = "goodbye!!!";
9885 char system_ini_path[MAX_PATH];
9886 struct sockaddr_in bindAddress;
9887 TRANSMIT_FILE_BUFFERS buffers;
9888 SOCKET client, server, dest;
9889 WSAOVERLAPPED ov;
9890 char buf[256];
9891 int iret, len;
9892 BOOL bret;
9893
9894 memset( &ov, 0, sizeof(ov) );
9895
9896 /* Setup sockets for testing TransmitFile */
9897 client = socket(AF_INET, SOCK_STREAM, 0);
9898 ok(client != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9899 server = socket(AF_INET, SOCK_STREAM, 0);
9900 ok(server != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9901 iret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &transmitFileGuid, sizeof(transmitFileGuid),
9902 &pTransmitFile, sizeof(pTransmitFile), &num_bytes, NULL, NULL);
9903 ok(!iret, "failed to get TransmitFile, error %lu\n", GetLastError());
9904 GetSystemWindowsDirectoryA(system_ini_path, MAX_PATH );
9905 strcat(system_ini_path, "\\system.ini");
9906 file = CreateFileA(system_ini_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0x0, NULL);
9907 ok(file != INVALID_HANDLE_VALUE, "failed to open file, error %lu\n", GetLastError());
9908 file_size = GetFileSize(file, NULL);
9909
9910 /* Test TransmitFile with an invalid socket */
9911 bret = pTransmitFile(INVALID_SOCKET, file, 0, 0, NULL, NULL, 0);
9912 err = WSAGetLastError();
9913 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9914 ok(err == WSAENOTSOCK, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, WSAENOTSOCK);
9915
9916 /* Test a bogus TransmitFile without a connected socket */
9917 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, TF_REUSE_SOCKET);
9918 err = WSAGetLastError();
9919 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9920 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, WSAENOTCONN);
9921
9922 /* Setup a properly connected socket for transfers */
9923 memset(&bindAddress, 0, sizeof(bindAddress));
9924 bindAddress.sin_family = AF_INET;
9925 bindAddress.sin_port = htons(SERVERPORT+1);
9926 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
9927 iret = bind(server, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9928 ok(!iret, "failed to bind socket, error %lu\n", GetLastError());
9929 iret = listen(server, 1);
9930 ok(!iret, "failed to listen, error %lu\n", GetLastError());
9931 iret = connect(client, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9932 ok(!iret, "failed to connect, error %lu\n", GetLastError());
9933 len = sizeof(bindAddress);
9934 dest = accept(server, (struct sockaddr*)&bindAddress, &len);
9935 ok(dest != INVALID_SOCKET, "failed to accept, error %lu\n", GetLastError());
9936 iret = set_blocking(dest, FALSE);
9937 ok(!iret, "failed to set nonblocking, error %lu\n", GetLastError());
9938
9939 /* Test TransmitFile with no possible buffer */
9940 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
9941 ok(bret, "TransmitFile failed unexpectedly.\n");
9942 iret = recv(dest, buf, sizeof(buf), 0);
9943 ok(iret == -1, "Returned an unexpected buffer from TransmitFile (%d != -1).\n", iret);
9944
9945 /* Test TransmitFile with only buffer data */
9946 buffers.Head = &header_msg[0];
9947 buffers.HeadLength = sizeof(header_msg);
9948 buffers.Tail = &footer_msg[0];
9949 buffers.TailLength = sizeof(footer_msg);
9950 bret = pTransmitFile(client, NULL, 0, 0, NULL, &buffers, 0);
9951 ok(bret, "TransmitFile failed unexpectedly.\n");
9952 iret = recv(dest, buf, sizeof(buf), 0);
9953 ok(iret == sizeof(header_msg)+sizeof(footer_msg),
9954 "Returned an unexpected buffer from TransmitFile: %d\n", iret );
9955 ok(memcmp(&buf[0], &header_msg[0], sizeof(header_msg)) == 0,
9956 "TransmitFile header buffer did not match!\n");
9957 ok(memcmp(&buf[sizeof(header_msg)], &footer_msg[0], sizeof(footer_msg)) == 0,
9958 "TransmitFile footer buffer did not match!\n");
9959
9960 /* Test TransmitFile with only file data */
9961 bret = pTransmitFile(client, file, 0, 0, NULL, NULL, 0);
9962 ok(bret, "TransmitFile failed unexpectedly.\n");
9963 compare_file(file, dest, 0);
9964
9965 /* Test TransmitFile with both file and buffer data */
9966 buffers.Head = &header_msg[0];
9967 buffers.HeadLength = sizeof(header_msg);
9968 buffers.Tail = &footer_msg[0];
9969 buffers.TailLength = sizeof(footer_msg);
9970 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9971 bret = pTransmitFile(client, file, 0, 0, NULL, &buffers, 0);
9972 ok(bret, "TransmitFile failed unexpectedly.\n");
9973 iret = recv(dest, buf, sizeof(header_msg), 0);
9974 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)) == 0,
9975 "TransmitFile header buffer did not match!\n");
9976 compare_file(file, dest, 0);
9977 iret = recv(dest, buf, sizeof(footer_msg), 0);
9978 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)) == 0,
9979 "TransmitFile footer buffer did not match!\n");
9980
9981 /* Test overlapped TransmitFile */
9982 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
9983 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9984 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
9985 err = WSAGetLastError();
9986 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9987 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%ld != %d)\n",
9988 err, ERROR_IO_PENDING);
9989 iret = WaitForSingleObject(ov.hEvent, 2000);
9990 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
9991 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
9992 ok(total_sent == file_size,
9993 "Overlapped TransmitFile sent an unexpected number of bytes (%ld != %ld).\n",
9994 total_sent, file_size);
9995 compare_file(file, dest, 0);
9996
9997 /* Test overlapped TransmitFile w/ start offset */
9998 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
9999 SetFilePointer(file, 0, NULL, FILE_BEGIN);
10000 ov.Offset = 10;
10001 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
10002 err = WSAGetLastError();
10003 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
10004 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, ERROR_IO_PENDING);
10005 iret = WaitForSingleObject(ov.hEvent, 2000);
10006 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
10007 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
10008 ok(total_sent == (file_size - ov.Offset),
10009 "Overlapped TransmitFile sent an unexpected number of bytes (%ld != %ld).\n",
10010 total_sent, file_size - ov.Offset);
10011 compare_file(file, dest, ov.Offset);
10012
10013 /* Test overlapped TransmitFile w/ file and buffer data */
10014 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
10015 buffers.Head = &header_msg[0];
10016 buffers.HeadLength = sizeof(header_msg);
10017 buffers.Tail = &footer_msg[0];
10018 buffers.TailLength = sizeof(footer_msg);
10019 SetFilePointer(file, 0, NULL, FILE_BEGIN);
10020 ov.Offset = 0;
10021 bret = pTransmitFile(client, file, 0, 0, &ov, &buffers, 0);
10022 err = WSAGetLastError();
10023 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
10024 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, ERROR_IO_PENDING);
10025 iret = WaitForSingleObject(ov.hEvent, 2000);
10026 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
10027 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
10028 ok(total_sent == (file_size + buffers.HeadLength + buffers.TailLength),
10029 "Overlapped TransmitFile sent an unexpected number of bytes (%ld != %ld).\n",
10030 total_sent, file_size + buffers.HeadLength + buffers.TailLength);
10031 iret = recv(dest, buf, sizeof(header_msg), 0);
10032 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)) == 0,
10033 "TransmitFile header buffer did not match!\n");
10034 compare_file(file, dest, 0);
10035 iret = recv(dest, buf, sizeof(footer_msg), 0);
10036 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)) == 0,
10037 "TransmitFile footer buffer did not match!\n");
10038
10039 /* Test TransmitFile with a UDP datagram socket */
10040 closesocket(client);
10041 client = socket(AF_INET, SOCK_DGRAM, 0);
10042 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
10043 err = WSAGetLastError();
10044 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
10045 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, WSAENOTCONN);
10046
10047 CloseHandle(file);
10048 CloseHandle(ov.hEvent);
10049 closesocket(client);
10050 closesocket(server);
10051 }
10052
10053 static void test_getpeername(void)
10054 {
10055 SOCKET sock;
10056 struct sockaddr_in sa, sa_out;
10057 SOCKADDR_STORAGE ss;
10058 int sa_len;
10059 const char buf[] = "hello world";
10060 int ret;
10061
10062 /* Test the parameter validation order. */
10063 ret = getpeername(INVALID_SOCKET, NULL, NULL);
10064 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
10065 ok(WSAGetLastError() == WSAENOTSOCK,
10066 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
10067
10068 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
10069 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
10070
10071 ret = getpeername(sock, NULL, NULL);
10072 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
10073 ok(WSAGetLastError() == WSAENOTCONN,
10074 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
10075
10076 memset(&sa, 0, sizeof(sa));
10077 sa.sin_family = AF_INET;
10078 sa.sin_port = htons(139);
10079 sa.sin_addr.s_addr = inet_addr("127.0.0.1");
10080
10081 /* sendto does not change a socket's connection state. */
10082 ret = sendto(sock, buf, sizeof(buf), 0, (struct sockaddr*)&sa, sizeof(sa));
10083 ok(ret != SOCKET_ERROR,
10084 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
10085
10086 ret = getpeername(sock, NULL, NULL);
10087 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
10088 ok(WSAGetLastError() == WSAENOTCONN,
10089 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
10090
10091 ret = connect(sock, (struct sockaddr*)&sa, sizeof(sa));
10092 ok(ret == 0,
10093 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
10094
10095 ret = getpeername(sock, NULL, NULL);
10096 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
10097 ok(WSAGetLastError() == WSAEFAULT,
10098 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
10099
10100 /* Test crashes on Wine. */
10101 if (0)
10102 {
10103 ret = getpeername(sock, (void*)0xdeadbeef, (void*)0xcafebabe);
10104 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
10105 ok(WSAGetLastError() == WSAEFAULT,
10106 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
10107 }
10108
10109 ret = getpeername(sock, (struct sockaddr*)&sa_out, NULL);
10110 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
10111 ok(WSAGetLastError() == WSAEFAULT,
10112 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
10113
10114 sa_len = 0;
10115 ret = getpeername(sock, NULL, &sa_len);
10116 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
10117 ok(WSAGetLastError() == WSAEFAULT,
10118 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
10119 ok(!sa_len, "got %d\n", sa_len);
10120
10121 sa_len = 0;
10122 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
10123 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
10124 ok(WSAGetLastError() == WSAEFAULT,
10125 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
10126 ok(!sa_len, "got %d\n", sa_len);
10127
10128 sa_len = sizeof(ss);
10129 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
10130 ok(ret == 0, "Expected getpeername to return 0, got %d\n", ret);
10131 ok(!memcmp(&sa, &ss, sizeof(sa)),
10132 "Expected the returned structure to be identical to the connect structure\n");
10133 ok(sa_len == sizeof(sa), "got %d\n", sa_len);
10134
10135 closesocket(sock);
10136 }
10137
10138 static void test_sioRoutingInterfaceQuery(void)
10139 {
10140 OVERLAPPED overlapped = {0}, *overlapped_ptr;
10141 struct sockaddr_in in = {0}, out = {0};
10142 ULONG_PTR key;
10143 HANDLE port;
10144 SOCKET sock;
10145 DWORD size;
10146 int ret;
10147
10148 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
10149 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
10150 port = CreateIoCompletionPort((HANDLE)sock, NULL, 123, 0);
10151
10152 WSASetLastError(0xdeadbeef);
10153 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), NULL, NULL, NULL);
10154 ok(ret == -1, "expected failure\n");
10155 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
10156
10157 size = 0xdeadbeef;
10158 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in) - 1, &out, sizeof(out), &size, NULL, NULL);
10159 ok(ret == -1, "expected failure\n");
10160 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
10161 ok(size == 0xdeadbeef, "got size %lu\n", size);
10162
10163 size = 0xdeadbeef;
10164 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, NULL, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
10165 ok(ret == -1, "expected failure\n");
10166 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
10167 ok(size == 0xdeadbeef, "got size %lu\n", size);
10168
10169 size = 0xdeadbeef;
10170 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
10171 ok(ret == -1, "expected failure\n");
10172 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError());
10173 ok(size == 0xdeadbeef, "got size %lu\n", size);
10174
10175 in.sin_family = AF_INET;
10176 size = 0xdeadbeef;
10177 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
10178 todo_wine ok(ret == -1, "expected failure\n");
10179 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
10180 todo_wine ok(size == 0xdeadbeef, "got size %lu\n", size);
10181
10182 in.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
10183 WSASetLastError(0xdeadbeef);
10184 size = 0xdeadbeef;
10185 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
10186 ok(!ret, "expected failure\n");
10187 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
10188 ok(size == sizeof(out), "got size %lu\n", size);
10189 /* We expect the source address to be INADDR_LOOPBACK as well, but
10190 * there's no guarantee that a route to the loopback address exists,
10191 * so rather than introduce spurious test failures we do not test the
10192 * source address.
10193 */
10194
10195 size = 0xdeadbeef;
10196 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out) - 1, &size, NULL, NULL);
10197 ok(ret == -1, "expected failure\n");
10198 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
10199 todo_wine ok(size == sizeof(out), "got size %lu\n", size);
10200
10201 size = 0xdeadbeef;
10202 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), NULL, sizeof(out), &size, NULL, NULL);
10203 ok(ret == -1, "expected failure\n");
10204 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
10205 ok(size == 0xdeadbeef, "got size %lu\n", size);
10206
10207 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), NULL, &overlapped, NULL);
10208 ok(ret == -1, "expected failure\n");
10209 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
10210 ok(size == 0xdeadbeef, "got size %lu\n", size);
10211
10212 WSASetLastError(0xdeadbeef);
10213 size = 0xdeadbeef;
10214 overlapped.Internal = 0xdeadbeef;
10215 overlapped.InternalHigh = 0xdeadbeef;
10216 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, &overlapped, NULL);
10217 ok(!ret, "expected failure\n");
10218 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
10219 ok(size == sizeof(out), "got size %lu\n", size);
10220
10221 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
10222 ok(ret, "got error %lu\n", GetLastError());
10223 ok(!size, "got size %lu\n", size);
10224 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
10225 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
10226 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
10227
10228 CloseHandle(port);
10229 closesocket(sock);
10230
10231 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
10232
10233 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in),
10234 &out, sizeof(out), NULL, &overlapped, socket_apc);
10235 ok(ret == -1, "expected failure\n");
10236 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
10237
10238 apc_count = 0;
10239 size = 0xdeadbeef;
10240 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in),
10241 &out, sizeof(out), &size, &overlapped, socket_apc);
10242 ok(!ret, "expected success\n");
10243 ok(size == sizeof(out), "got size %lu\n", size);
10244
10245 ret = SleepEx(0, TRUE);
10246 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
10247 ok(apc_count == 1, "APC was called %u times\n", apc_count);
10248 ok(!apc_error, "got APC error %lu\n", apc_error);
10249 ok(!apc_size, "got APC size %lu\n", apc_size);
10250 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
10251
10252 closesocket(sock);
10253 }
10254
10255 static void test_sioAddressListChange(void)
10256 {
10257 struct sockaddr_in bindAddress;
10258 struct in_addr net_address;
10259 WSAOVERLAPPED overlapped, *olp;
10260 struct hostent *h;
10261 DWORD num_bytes, error, tick;
10262 SOCKET sock, sock2, sock3;
10263 WSAEVENT event2, event3;
10264 HANDLE io_port;
10265 ULONG_PTR key;
10266 int acount;
10267 BOOL bret;
10268 int ret;
10269
10270 /* Use gethostbyname to find the list of local network interfaces */
10271 h = gethostbyname("");
10272 ok(!!h, "failed to get interface list, error %u\n", WSAGetLastError());
10273 for (acount = 0; h->h_addr_list[acount]; acount++);
10274 if (acount == 0)
10275 {
10276 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
10277 return;
10278 }
10279
10280 net_address.s_addr = *(ULONG *) h->h_addr_list[0];
10281
10282 sock = socket(AF_INET, 0, IPPROTO_TCP);
10283 ok(sock != INVALID_SOCKET, "socket() failed\n");
10284
10285 memset(&bindAddress, 0, sizeof(bindAddress));
10286 bindAddress.sin_family = AF_INET;
10287 bindAddress.sin_addr.s_addr = net_address.s_addr;
10288 SetLastError(0xdeadbeef);
10289 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10290 ok (!ret, "bind() failed with error %ld\n", GetLastError());
10291 set_blocking(sock, FALSE);
10292
10293 memset(&overlapped, 0, sizeof(overlapped));
10294 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10295 SetLastError(0xdeadbeef);
10296 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10297 error = GetLastError();
10298 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
10299 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%lx\n", error);
10300
10301 CloseHandle(overlapped.hEvent);
10302 closesocket(sock);
10303
10304 sock = socket(AF_INET, 0, IPPROTO_TCP);
10305 ok(sock != INVALID_SOCKET, "socket() failed\n");
10306
10307 SetLastError(0xdeadbeef);
10308 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10309 ok (!ret, "bind() failed with error %ld\n", GetLastError());
10310 set_blocking(sock, TRUE);
10311
10312 memset(&overlapped, 0, sizeof(overlapped));
10313 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10314 SetLastError(0xdeadbeef);
10315 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10316 error = GetLastError();
10317 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
10318 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%lx\n", error);
10319
10320 CloseHandle(overlapped.hEvent);
10321 closesocket(sock);
10322
10323 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10324 ok(sock != INVALID_SOCKET, "socket() failed\n");
10325
10326 SetLastError(0xdeadbeef);
10327 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10328 ok (!ret, "bind() failed with error %ld\n", GetLastError());
10329 set_blocking(sock, FALSE);
10330
10331 memset(&overlapped, 0, sizeof(overlapped));
10332 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10333 SetLastError(0xdeadbeef);
10334 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10335 error = GetLastError();
10336 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
10337 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%lx\n", error);
10338
10339 CloseHandle(overlapped.hEvent);
10340 closesocket(sock);
10341
10342 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10343 ok(sock != INVALID_SOCKET, "socket() failed\n");
10344
10345 SetLastError(0xdeadbeef);
10346 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10347 ok (!ret, "bind() failed with error %ld\n", GetLastError());
10348 set_blocking(sock, TRUE);
10349
10350 memset(&overlapped, 0, sizeof(overlapped));
10351 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10352 SetLastError(0xdeadbeef);
10353 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10354 error = GetLastError();
10355 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
10356 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%lx\n", error);
10357
10358 CloseHandle(overlapped.hEvent);
10359 closesocket(sock);
10360
10361 /* When the socket is overlapped non-blocking and the list change is requested without
10362 * an overlapped structure the error will be different. */
10363 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10364 ok(sock != INVALID_SOCKET, "socket() failed\n");
10365
10366 SetLastError(0xdeadbeef);
10367 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10368 ok (!ret, "bind() failed with error %ld\n", GetLastError());
10369 set_blocking(sock, FALSE);
10370
10371 SetLastError(0xdeadbeef);
10372 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
10373 error = GetLastError();
10374 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
10375 ok (error == WSAEWOULDBLOCK, "expected 10035, got %ld\n", error);
10376
10377 io_port = CreateIoCompletionPort( (HANDLE)sock, NULL, 0, 0 );
10378 ok (io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10379
10380 set_blocking(sock, FALSE);
10381 memset(&overlapped, 0, sizeof(overlapped));
10382 SetLastError(0xdeadbeef);
10383 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10384 error = GetLastError();
10385 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %lu\n", error);
10386 ok (error == ERROR_IO_PENDING, "expected ERROR_IO_PENDING got %lu\n", error);
10387
10388 olp = (WSAOVERLAPPED *)0xdeadbeef;
10389 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 0 );
10390 ok(!bret, "failed to get completion status %u\n", bret);
10391 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10392 ok(!olp, "Overlapped structure is at %p\n", olp);
10393
10394 closesocket(sock);
10395
10396 olp = (WSAOVERLAPPED *)0xdeadbeef;
10397 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 0 );
10398 ok(!bret, "failed to get completion status %u\n", bret);
10399 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %lu\n", GetLastError());
10400 ok(olp == &overlapped, "Overlapped structure is at %p\n", olp);
10401
10402 CloseHandle(io_port);
10403
10404 /* Misuse of the API by using a blocking socket and not using an overlapped structure,
10405 * this leads to a hang forever. */
10406 if (0)
10407 {
10408 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10409
10410 SetLastError(0xdeadbeef);
10411 bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10412
10413 set_blocking(sock, TRUE);
10414 WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
10415 /* hang */
10416
10417 closesocket(sock);
10418 }
10419
10420 if (!winetest_interactive)
10421 {
10422 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
10423 return;
10424 }
10425
10426 /* Bind an overlapped socket to the first found network interface */
10427 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10428 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
10429 sock2 = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10430 ok(sock2 != INVALID_SOCKET, "Expected socket to return a valid socket\n");
10431 sock3 = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10432 ok(sock3 != INVALID_SOCKET, "Expected socket to return a valid socket\n");
10433
10434 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10435 ok(!ret, "bind failed unexpectedly\n");
10436 ret = bind(sock2, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10437 ok(!ret, "bind failed unexpectedly\n");
10438 ret = bind(sock3, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10439 ok(!ret, "bind failed unexpectedly\n");
10440
10441 set_blocking(sock2, FALSE);
10442 set_blocking(sock3, FALSE);
10443
10444 /* Wait for address changes, request that the user connects/disconnects an interface */
10445 memset(&overlapped, 0, sizeof(overlapped));
10446 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10447 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10448 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
10449 ok(WSAGetLastError() == WSA_IO_PENDING, "Expected pending last error, got %d\n", WSAGetLastError());
10450
10451 ret = WSAIoctl(sock2, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
10452 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
10453 ok(WSAGetLastError() == WSAEWOULDBLOCK, "Expected would block last error, got %d\n", WSAGetLastError());
10454
10455 event2 = WSACreateEvent();
10456 event3 = WSACreateEvent();
10457 ret = WSAEventSelect (sock2, event2, FD_ADDRESS_LIST_CHANGE);
10458 ok(!ret, "WSAEventSelect failed with %d\n", WSAGetLastError());
10459 /* sock3 did not request SIO_ADDRESS_LIST_CHANGE but it is trying to wait anyway */
10460 ret = WSAEventSelect (sock3, event3, FD_ADDRESS_LIST_CHANGE);
10461 ok(!ret, "WSAEventSelect failed with %d\n", WSAGetLastError());
10462
10463 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
10464 " change the ipv4 address of any of the local network interfaces (15 second timeout).\n");
10465 tick = GetTickCount();
10466 ret = WaitForSingleObject(overlapped.hEvent, 15000);
10467 ok(ret == WAIT_OBJECT_0, "failed to get overlapped event %u\n", ret);
10468
10469 ret = WaitForSingleObject(event2, 500);
10470 todo_wine
10471 ok(ret == WAIT_OBJECT_0, "failed to get change event %u\n", ret);
10472
10473 ret = WaitForSingleObject(event3, 500);
10474 ok(ret == WAIT_TIMEOUT, "unexpected change event\n");
10475
10476 trace("Spent %ld ms waiting.\n", GetTickCount() - tick);
10477
10478 WSACloseEvent(event2);
10479 WSACloseEvent(event3);
10480
10481 closesocket(sock);
10482 closesocket(sock2);
10483 closesocket(sock3);
10484 }
10485
10486 /*
10487 * Provide consistent initialization for the AcceptEx IOCP tests.
10488 */
10489 static SOCKET setup_iocp_src(struct sockaddr_in *bindAddress)
10490 {
10491 SOCKET src;
10492 int iret, socklen;
10493
10494 src = socket(AF_INET, SOCK_STREAM, 0);
10495 ok(src != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10496
10497 memset(bindAddress, 0, sizeof(*bindAddress));
10498 bindAddress->sin_family = AF_INET;
10499 bindAddress->sin_addr.s_addr = inet_addr("127.0.0.1");
10500 iret = bind(src, (struct sockaddr*)bindAddress, sizeof(*bindAddress));
10501 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
10502
10503 socklen = sizeof(*bindAddress);
10504 iret = getsockname(src, (struct sockaddr*)bindAddress, &socklen);
10505 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
10506
10507 iret = set_blocking(src, FALSE);
10508 ok(!iret, "failed to make socket non-blocking, error %u\n", WSAGetLastError());
10509
10510 iret = listen(src, 5);
10511 ok(!iret, "failed to listen, error %u\n", WSAGetLastError());
10512
10513 return src;
10514 }
10515
10516 static void test_completion_port(void)
10517 {
10518 HANDLE io_port;
10519 WSAOVERLAPPED ov, *olp;
10520 SOCKET src, dest, dup, connector = INVALID_SOCKET;
10521 WSAPROTOCOL_INFOA info;
10522 char buf[1024];
10523 WSABUF bufs;
10524 DWORD num_bytes, flags;
10525 int iret;
10526 BOOL bret;
10527 ULONG_PTR key;
10528 struct sockaddr_in bindAddress;
10529 GUID acceptExGuid = WSAID_ACCEPTEX;
10530 LPFN_ACCEPTEX pAcceptEx = NULL;
10531 fd_set fds_recv;
10532
10533 memset(buf, 0, sizeof(buf));
10534 io_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
10535 ok( io_port != NULL, "Failed to create completion port %lu\n", GetLastError());
10536
10537 memset(&ov, 0, sizeof(ov));
10538
10539 tcp_socketpair(&src, &dest);
10540
10541 bufs.len = sizeof(buf);
10542 bufs.buf = buf;
10543 flags = 0;
10544
10545 io_port = CreateIoCompletionPort( (HANDLE)dest, io_port, 125, 0 );
10546 ok(io_port != NULL, "Failed to create completion port %lu\n", GetLastError());
10547
10548 SetLastError(0xdeadbeef);
10549
10550 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10551 ok(iret == SOCKET_ERROR, "WSARecv returned %d\n", iret);
10552 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10553
10554 Sleep(100);
10555
10556 close_with_rst(src);
10557
10558 SetLastError(0xdeadbeef);
10559 key = 0xdeadbeef;
10560 num_bytes = 0xdeadbeef;
10561 olp = (WSAOVERLAPPED *)0xdeadbeef;
10562
10563 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10564 ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret);
10565 ok(GetLastError() == ERROR_NETNAME_DELETED, "Last error was %ld\n", GetLastError());
10566 ok(key == 125, "Key is %Iu\n", key);
10567 ok(num_bytes == 0, "Number of bytes received is %lu\n", num_bytes);
10568 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10569
10570 SetLastError(0xdeadbeef);
10571 key = 0xdeadbeef;
10572 num_bytes = 0xdeadbeef;
10573 olp = (WSAOVERLAPPED *)0xdeadbeef;
10574
10575 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10576 ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret );
10577 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10578 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10579 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10580 ok(!olp, "Overlapped structure is at %p\n", olp);
10581
10582 if (dest != INVALID_SOCKET)
10583 closesocket(dest);
10584
10585 memset(&ov, 0, sizeof(ov));
10586
10587 tcp_socketpair(&src, &dest);
10588
10589 bufs.len = sizeof(buf);
10590 bufs.buf = buf;
10591 flags = 0;
10592
10593 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
10594 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10595
10596 set_blocking(dest, FALSE);
10597
10598 close_with_rst(src);
10599
10600 Sleep(100);
10601
10602 num_bytes = 0xdeadbeef;
10603 SetLastError(0xdeadbeef);
10604
10605 iret = WSASend(dest, &bufs, 1, &num_bytes, 0, &ov, NULL);
10606 ok(iret == SOCKET_ERROR, "WSASend failed - %d\n", iret);
10607 ok(GetLastError() == WSAECONNRESET, "Last error was %ld\n", GetLastError());
10608 ok(num_bytes == 0xdeadbeef, "Managed to send %ld\n", num_bytes);
10609
10610 SetLastError(0xdeadbeef);
10611 key = 0xdeadbeef;
10612 num_bytes = 0xdeadbeef;
10613 olp = (WSAOVERLAPPED *)0xdeadbeef;
10614
10615 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10616 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
10617 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10618 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10619 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10620 ok(!olp, "Overlapped structure is at %p\n", olp);
10621
10622 if (dest != INVALID_SOCKET)
10623 closesocket(dest);
10624
10625 /* Test IOCP response on successful immediate read. */
10626 tcp_socketpair(&src, &dest);
10627
10628 bufs.len = sizeof(buf);
10629 bufs.buf = buf;
10630 flags = 0;
10631 SetLastError(0xdeadbeef);
10632
10633 iret = WSASend(src, &bufs, 1, &num_bytes, 0, &ov, NULL);
10634 ok(!iret, "WSASend failed - %d, last error %lu\n", iret, GetLastError());
10635 ok(num_bytes == sizeof(buf), "Managed to send %ld\n", num_bytes);
10636
10637 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
10638 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10639 set_blocking(dest, FALSE);
10640
10641 FD_ZERO(&fds_recv);
10642 FD_SET(dest, &fds_recv);
10643 select(dest + 1, &fds_recv, NULL, NULL, NULL);
10644
10645 num_bytes = 0xdeadbeef;
10646 flags = 0;
10647
10648 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10649 ok(!iret, "WSARecv failed - %d, last error %lu\n", iret, GetLastError());
10650 ok(num_bytes == sizeof(buf), "Managed to read %ld\n", num_bytes);
10651
10652 SetLastError(0xdeadbeef);
10653 key = 0xdeadbeef;
10654 num_bytes = 0xdeadbeef;
10655 olp = (WSAOVERLAPPED *)0xdeadbeef;
10656
10657 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10658 ok(bret == TRUE, "failed to get completion status %u\n", bret);
10659 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
10660 ok(key == 125, "Key is %Iu\n", key);
10661 ok(num_bytes == sizeof(buf), "Number of bytes transferred is %lu\n", num_bytes);
10662 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10663
10664 /* Test IOCP response on graceful shutdown. */
10665 closesocket(src);
10666
10667 FD_ZERO(&fds_recv);
10668 FD_SET(dest, &fds_recv);
10669 select(dest + 1, &fds_recv, NULL, NULL, NULL);
10670
10671 num_bytes = 0xdeadbeef;
10672 flags = 0;
10673 memset(&ov, 0, sizeof(ov));
10674
10675 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10676 ok(!iret, "WSARecv failed - %d, last error %lu\n", iret, GetLastError());
10677 ok(!num_bytes, "Managed to read %ld\n", num_bytes);
10678
10679 SetLastError(0xdeadbeef);
10680 key = 0xdeadbeef;
10681 num_bytes = 0xdeadbeef;
10682 olp = (WSAOVERLAPPED *)0xdeadbeef;
10683
10684 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10685 ok(bret == TRUE, "failed to get completion status %u\n", bret);
10686 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
10687 ok(key == 125, "Key is %Iu\n", key);
10688 ok(!num_bytes, "Number of bytes transferred is %lu\n", num_bytes);
10689 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10690
10691 closesocket(src);
10692 src = INVALID_SOCKET;
10693 closesocket(dest);
10694 dest = INVALID_SOCKET;
10695
10696 /* Test IOCP response on hard shutdown. This was the condition that triggered
10697 * a crash in an actual app (bug 38980). */
10698 tcp_socketpair(&src, &dest);
10699
10700 bufs.len = sizeof(buf);
10701 bufs.buf = buf;
10702 flags = 0;
10703 memset(&ov, 0, sizeof(ov));
10704
10705 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
10706 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10707 set_blocking(dest, FALSE);
10708
10709 close_with_rst(src);
10710
10711 FD_ZERO(&fds_recv);
10712 FD_SET(dest, &fds_recv);
10713 select(dest + 1, &fds_recv, NULL, NULL, NULL);
10714
10715 num_bytes = 0xdeadbeef;
10716 SetLastError(0xdeadbeef);
10717
10718 /* Somehow a hard shutdown doesn't work on my Linux box. It seems SO_LINGER is ignored. */
10719 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10720 ok(iret == SOCKET_ERROR, "WSARecv failed - %d\n", iret);
10721 ok(GetLastError() == WSAECONNRESET, "Last error was %ld\n", GetLastError());
10722 ok(num_bytes == 0xdeadbeef, "Managed to read %ld\n", num_bytes);
10723
10724 SetLastError(0xdeadbeef);
10725 key = 0xdeadbeef;
10726 num_bytes = 0xdeadbeef;
10727 olp = (WSAOVERLAPPED *)0xdeadbeef;
10728
10729 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10730 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
10731 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10732 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10733 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10734 ok(!olp, "Overlapped structure is at %p\n", olp);
10735
10736 closesocket(dest);
10737
10738 /* Test reading from a non-connected socket, mostly because the above test is marked todo. */
10739 dest = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10740 ok(dest != INVALID_SOCKET, "socket() failed\n");
10741
10742 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
10743 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10744 set_blocking(dest, FALSE);
10745
10746 num_bytes = 0xdeadbeef;
10747 SetLastError(0xdeadbeef);
10748 memset(&ov, 0, sizeof(ov));
10749
10750 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10751 ok(iret == SOCKET_ERROR, "WSARecv failed - %d\n", iret);
10752 ok(GetLastError() == WSAENOTCONN, "Last error was %ld\n", GetLastError());
10753 ok(num_bytes == 0xdeadbeef, "Managed to read %ld\n", num_bytes);
10754
10755 SetLastError(0xdeadbeef);
10756 key = 0xdeadbeef;
10757 num_bytes = 0xdeadbeef;
10758 olp = (WSAOVERLAPPED *)0xdeadbeef;
10759
10760 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10761 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
10762 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10763 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10764 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10765 ok(!olp, "Overlapped structure is at %p\n", olp);
10766
10767 num_bytes = 0xdeadbeef;
10768 closesocket(dest);
10769
10770 dest = socket(AF_INET, SOCK_STREAM, 0);
10771 ok(dest != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10772
10773 iret = WSAIoctl(dest, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
10774 &pAcceptEx, sizeof(pAcceptEx), &num_bytes, NULL, NULL);
10775 ok(!iret, "failed to get AcceptEx, error %u\n", WSAGetLastError());
10776
10777 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
10778
10779 src = setup_iocp_src(&bindAddress);
10780
10781 SetLastError(0xdeadbeef);
10782
10783 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10784 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10785 &num_bytes, &ov);
10786 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10787 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10788
10789 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10790 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10791
10792 closesocket(src);
10793 src = INVALID_SOCKET;
10794
10795 SetLastError(0xdeadbeef);
10796 key = 0xdeadbeef;
10797 num_bytes = 0xdeadbeef;
10798 olp = (WSAOVERLAPPED *)0xdeadbeef;
10799
10800 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10801 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10802 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10803 ok(key == 125, "Key is %Iu\n", key);
10804 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10805 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10806 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10807
10808 SetLastError(0xdeadbeef);
10809 key = 0xdeadbeef;
10810 num_bytes = 0xdeadbeef;
10811 olp = (WSAOVERLAPPED *)0xdeadbeef;
10812 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10813 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10814 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10815 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10816 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10817 ok(!olp, "Overlapped structure is at %p\n", olp);
10818
10819 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
10820
10821 src = setup_iocp_src(&bindAddress);
10822
10823 SetLastError(0xdeadbeef);
10824
10825 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10826 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10827
10828 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10829 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10830 &num_bytes, &ov);
10831 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10832 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10833
10834 closesocket(src);
10835 src = INVALID_SOCKET;
10836
10837 SetLastError(0xdeadbeef);
10838 key = 0xdeadbeef;
10839 num_bytes = 0xdeadbeef;
10840 olp = (WSAOVERLAPPED *)0xdeadbeef;
10841
10842 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10843 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10844 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10845 ok(key == 125, "Key is %Iu\n", key);
10846 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10847 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10848 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10849
10850 SetLastError(0xdeadbeef);
10851 key = 0xdeadbeef;
10852 num_bytes = 0xdeadbeef;
10853 olp = (WSAOVERLAPPED *)0xdeadbeef;
10854 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10855 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10856 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10857 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10858 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10859 ok(!olp, "Overlapped structure is at %p\n", olp);
10860
10861 /* Test IOCP with duplicated handle */
10862
10863 src = setup_iocp_src(&bindAddress);
10864
10865 SetLastError(0xdeadbeef);
10866
10867 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10868 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10869
10870 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10871 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10872 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10873
10874 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10875 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10876 &num_bytes, &ov);
10877 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10878 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10879
10880 SetLastError(0xdeadbeef);
10881 key = 0xdeadbeef;
10882 num_bytes = 0xdeadbeef;
10883 olp = (WSAOVERLAPPED *)0xdeadbeef;
10884 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10885 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10886 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10887 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10888 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10889 ok(!olp, "Overlapped structure is at %p\n", olp);
10890
10891 closesocket(src);
10892 src = INVALID_SOCKET;
10893 closesocket(dup);
10894 dup = INVALID_SOCKET;
10895
10896 SetLastError(0xdeadbeef);
10897 key = 0xdeadbeef;
10898 num_bytes = 0xdeadbeef;
10899 olp = (WSAOVERLAPPED *)0xdeadbeef;
10900 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10901 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10902 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10903 ok(key == 125, "Key is %Iu\n", key);
10904 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10905 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10906 ok(olp && olp->Internal == (ULONG)STATUS_CANCELLED, "Internal status is %Ix\n", olp ? olp->Internal : 0);
10907
10908 SetLastError(0xdeadbeef);
10909 key = 0xdeadbeef;
10910 num_bytes = 0xdeadbeef;
10911 olp = (WSAOVERLAPPED *)0xdeadbeef;
10912 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10913 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10914 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10915 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10916 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10917 ok(!olp, "Overlapped structure is at %p\n", olp);
10918
10919 /* Test IOCP with duplicated handle (closing duplicated handle) */
10920
10921 src = setup_iocp_src(&bindAddress);
10922
10923 SetLastError(0xdeadbeef);
10924
10925 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10926 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10927
10928 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10929 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10930 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10931
10932 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10933 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10934 &num_bytes, &ov);
10935 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10936 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10937
10938 closesocket(dup);
10939 dup = INVALID_SOCKET;
10940
10941 SetLastError(0xdeadbeef);
10942 key = 0xdeadbeef;
10943 num_bytes = 0xdeadbeef;
10944 olp = (WSAOVERLAPPED *)0xdeadbeef;
10945 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10946 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10947 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10948 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10949 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10950 ok(!olp, "Overlapped structure is at %p\n", olp);
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 src = INVALID_SOCKET;
10965
10966 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10967 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10968 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10969 ok(key == 125, "Key is %Iu\n", key);
10970 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10971 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10972 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10973
10974 SetLastError(0xdeadbeef);
10975 key = 0xdeadbeef;
10976 num_bytes = 0xdeadbeef;
10977 olp = (WSAOVERLAPPED *)0xdeadbeef;
10978 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10979 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10980 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10981 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10982 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10983 ok(!olp, "Overlapped structure is at %p\n", olp);
10984
10985 /* Test IOCP with duplicated handle (closing original handle) */
10986
10987 src = setup_iocp_src(&bindAddress);
10988
10989 SetLastError(0xdeadbeef);
10990
10991 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10992 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10993
10994 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10995 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10996 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10997
10998 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10999 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
11000 &num_bytes, &ov);
11001 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
11002 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
11003
11004 closesocket(src);
11005 src = INVALID_SOCKET;
11006
11007 SetLastError(0xdeadbeef);
11008 key = 0xdeadbeef;
11009 num_bytes = 0xdeadbeef;
11010 olp = (WSAOVERLAPPED *)0xdeadbeef;
11011 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
11012 ok(bret == FALSE, "failed to get completion status %u\n", bret);
11013 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
11014 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
11015 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
11016 ok(!olp, "Overlapped structure is at %p\n", olp);
11017
11018 closesocket(dup);
11019 dup = INVALID_SOCKET;
11020
11021 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
11022 ok(bret == FALSE, "failed to get completion status %u\n", bret);
11023 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
11024 ok(key == 125, "Key is %Iu\n", key);
11025 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
11026 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
11027 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %Ix\n", olp ? olp->Internal : 0);
11028
11029 SetLastError(0xdeadbeef);
11030 key = 0xdeadbeef;
11031 num_bytes = 0xdeadbeef;
11032 olp = (WSAOVERLAPPED *)0xdeadbeef;
11033 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
11034 ok(bret == FALSE, "failed to get completion status %u\n", bret);
11035 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
11036 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
11037 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
11038 ok(!olp, "Overlapped structure is at %p\n", olp);
11039
11040 /* Test IOCP without AcceptEx */
11041
11042 src = setup_iocp_src(&bindAddress);
11043
11044 SetLastError(0xdeadbeef);
11045
11046 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
11047 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
11048
11049 closesocket(src);
11050 src = INVALID_SOCKET;
11051
11052 SetLastError(0xdeadbeef);
11053 key = 0xdeadbeef;
11054 num_bytes = 0xdeadbeef;
11055 olp = (WSAOVERLAPPED *)0xdeadbeef;
11056 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
11057 ok(bret == FALSE, "failed to get completion status %u\n", bret);
11058 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
11059 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
11060 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
11061 ok(!olp, "Overlapped structure is at %p\n", olp);
11062
11063 /* */
11064
11065 src = setup_iocp_src(&bindAddress);
11066
11067 connector = socket(AF_INET, SOCK_STREAM, 0);
11068 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
11069
11070 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
11071 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
11072
11073 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 236, 0);
11074 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
11075
11076 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
11077 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
11078 &num_bytes, &ov);
11079 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
11080 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
11081
11082 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
11083 ok(iret == 0, "connecting to accepting socket failed, error %ld\n", GetLastError());
11084
11085 closesocket(connector);
11086 connector = INVALID_SOCKET;
11087
11088 SetLastError(0xdeadbeef);
11089 key = 0xdeadbeef;
11090 num_bytes = 0xdeadbeef;
11091 olp = (WSAOVERLAPPED *)0xdeadbeef;
11092
11093 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
11094 ok(bret == TRUE, "failed to get completion status %u\n", bret);
11095 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
11096 ok(key == 125, "Key is %Iu\n", key);
11097 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
11098 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
11099 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %Ix\n", olp ? olp->Internal : 0);
11100
11101 SetLastError(0xdeadbeef);
11102 key = 0xdeadbeef;
11103 num_bytes = 0xdeadbeef;
11104 olp = (WSAOVERLAPPED *)0xdeadbeef;
11105 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
11106 ok(bret == FALSE, "failed to get completion status %u\n", bret);
11107 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
11108 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
11109 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
11110 ok(!olp, "Overlapped structure is at %p\n", olp);
11111
11112 if (dest != INVALID_SOCKET)
11113 closesocket(dest);
11114 if (src != INVALID_SOCKET)
11115 closesocket(dest);
11116
11117 /* */
11118
11119 src = setup_iocp_src(&bindAddress);
11120
11121 dest = socket(AF_INET, SOCK_STREAM, 0);
11122 ok(dest != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
11123
11124 connector = socket(AF_INET, SOCK_STREAM, 0);
11125 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
11126
11127 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
11128 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
11129
11130 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 236, 0);
11131 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
11132
11133 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
11134 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
11135 &num_bytes, &ov);
11136 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
11137 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
11138
11139 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
11140 ok(iret == 0, "connecting to accepting socket failed, error %ld\n", GetLastError());
11141
11142 iret = send(connector, buf, 1, 0);
11143 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
11144
11145 Sleep(100);
11146
11147 closesocket(dest);
11148 dest = INVALID_SOCKET;
11149
11150 SetLastError(0xdeadbeef);
11151 key = 0xdeadbeef;
11152 num_bytes = 0xdeadbeef;
11153 olp = (WSAOVERLAPPED *)0xdeadbeef;
11154
11155 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
11156 ok(bret == TRUE, "failed to get completion status %u\n", bret);
11157 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
11158 ok(key == 125, "Key is %Iu\n", key);
11159 ok(num_bytes == 1, "Number of bytes transferred is %lu\n", num_bytes);
11160 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
11161 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %Ix\n", olp ? olp->Internal : 0);
11162
11163 SetLastError(0xdeadbeef);
11164 key = 0xdeadbeef;
11165 num_bytes = 0xdeadbeef;
11166 olp = (WSAOVERLAPPED *)0xdeadbeef;
11167 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
11168 ok(bret == FALSE, "failed to get completion status %u\n", bret);
11169 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
11170 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
11171 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
11172 ok(!olp, "Overlapped structure is at %p\n", olp);
11173
11174 if (src != INVALID_SOCKET)
11175 closesocket(src);
11176 if (connector != INVALID_SOCKET)
11177 closesocket(connector);
11178
11179 /* */
11180
11181 src = setup_iocp_src(&bindAddress);
11182
11183 dest = socket(AF_INET, SOCK_STREAM, 0);
11184 ok(dest != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
11185
11186 connector = socket(AF_INET, SOCK_STREAM, 0);
11187 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
11188
11189 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
11190 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
11191
11192 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 236, 0);
11193 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
11194
11195 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
11196 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
11197 &num_bytes, &ov);
11198 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
11199 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
11200
11201 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
11202 ok(iret == 0, "connecting to accepting socket failed, error %ld\n", GetLastError());
11203
11204 closesocket(dest);
11205
11206 SetLastError(0xdeadbeef);
11207 key = 0xdeadbeef;
11208 num_bytes = 0xdeadbeef;
11209 olp = (WSAOVERLAPPED *)0xdeadbeef;
11210
11211 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
11212 ok(bret == FALSE, "failed to get completion status %u\n", bret);
11213 ok(GetLastError() == ERROR_OPERATION_ABORTED
11214 || GetLastError() == ERROR_CONNECTION_ABORTED, "got error %lu\n", GetLastError());
11215 ok(key == 125, "Key is %Iu\n", key);
11216 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
11217 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
11218 ok((NTSTATUS)olp->Internal == STATUS_CANCELLED
11219 || (NTSTATUS)olp->Internal == STATUS_CONNECTION_ABORTED, "got status %#Ix\n", olp->Internal);
11220
11221 SetLastError(0xdeadbeef);
11222 key = 0xdeadbeef;
11223 num_bytes = 0xdeadbeef;
11224 olp = (WSAOVERLAPPED *)0xdeadbeef;
11225 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
11226 ok(bret == FALSE, "failed to get completion status %u\n", bret);
11227 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
11228 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
11229 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
11230 ok(!olp, "Overlapped structure is at %p\n", olp);
11231
11232 closesocket(src);
11233 closesocket(connector);
11234 CloseHandle(io_port);
11235 }
11236
11237 static void test_connect_completion_port(void)
11238 {
11239 OVERLAPPED overlapped = {0}, *overlapped_ptr;
11240 GUID connectex_guid = WSAID_CONNECTEX;
11241 SOCKET connector, listener, acceptor;
11242 struct sockaddr_in addr, destaddr;
11243 LPFN_CONNECTEX pConnectEx;
11244 int ret, addrlen;
11245 ULONG_PTR key;
11246 HANDLE port;
11247 DWORD size;
11248
11249 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
11250
11251 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11252 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
11253
11254 memset(&addr, 0, sizeof(addr));
11255 addr.sin_family = AF_INET;
11256 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
11257 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
11258 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11259 addrlen = sizeof(destaddr);
11260 ret = getsockname(listener, (struct sockaddr *)&destaddr, &addrlen);
11261 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
11262
11263 ret = listen(listener, 1);
11264 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
11265
11266 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11267 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11268
11269 ret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectex_guid, sizeof(connectex_guid),
11270 &pConnectEx, sizeof(pConnectEx), &size, NULL, NULL);
11271 ok(!ret, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
11272
11273 /* connect() does not queue completion. */
11274
11275 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11276 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11277
11278 ret = connect(connector, (struct sockaddr *)&destaddr, sizeof(destaddr));
11279 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11280 acceptor = accept(listener, NULL, NULL);
11281 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11282 closesocket(acceptor);
11283
11284 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11285 ok(!ret, "expected failure\n");
11286 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11287
11288 closesocket(connector);
11289 CloseHandle(port);
11290
11291 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11292 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11293 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11294 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11295 set_blocking(connector, FALSE);
11296
11297 ret = connect(connector, (struct sockaddr *)&destaddr, sizeof(destaddr));
11298 ok(ret == -1, "expected failure\n");
11299 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
11300 acceptor = accept(listener, NULL, NULL);
11301 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11302 closesocket(acceptor);
11303
11304 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11305 ok(!ret, "expected failure\n");
11306 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11307
11308 closesocket(connector);
11309 CloseHandle(port);
11310
11311 /* ConnectEx() queues completion. */
11312
11313 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11314 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11315 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11316 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11317 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
11318 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11319
11320 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
11321 NULL, 0, &size, &overlapped);
11322 ok(!ret, "expected failure\n");
11323 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11324 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11325 ok(!ret, "wait failed\n");
11326 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
11327 ok(ret, "got error %lu\n", GetLastError());
11328 ok(!size, "got %lu bytes\n", size);
11329 acceptor = accept(listener, NULL, NULL);
11330 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11331 closesocket(acceptor);
11332
11333 size = 0xdeadbeef;
11334 key = 0xdeadbeef;
11335 overlapped_ptr = NULL;
11336 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11337 ok(ret, "got error %lu\n", GetLastError());
11338 ok(!key, "got key %#Ix\n", key);
11339 ok(!size, "got %lu bytes\n", size);
11340 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11341
11342 closesocket(connector);
11343 CloseHandle(port);
11344
11345 /* Test ConnectEx() with a non-empty buffer. */
11346
11347 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11348 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11349 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11350 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11351 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
11352 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11353
11354 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
11355 (void *)"one", 3, &size, &overlapped);
11356 ok(!ret, "expected failure\n");
11357 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11358 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11359 ok(!ret, "wait failed\n");
11360 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
11361 ok(ret, "got error %lu\n", GetLastError());
11362 ok(size == 3, "got %lu bytes\n", size);
11363 acceptor = accept(listener, NULL, NULL);
11364 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11365 closesocket(acceptor);
11366
11367 size = 0xdeadbeef;
11368 key = 0xdeadbeef;
11369 overlapped_ptr = NULL;
11370 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11371 ok(ret, "got error %lu\n", GetLastError());
11372 ok(!key, "got key %#Ix\n", key);
11373 ok(size == 3, "got %lu bytes\n", size);
11374 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11375
11376 closesocket(connector);
11377 CloseHandle(port);
11378
11379 /* Suppress completion by setting the low bit. */
11380
11381 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11382 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11383 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11384 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11385 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
11386 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11387
11388 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent | 1);
11389
11390 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
11391 NULL, 0, &size, &overlapped);
11392 ok(!ret, "expected failure\n");
11393 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11394 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11395 ok(!ret, "wait failed\n");
11396 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
11397 ok(ret, "got error %lu\n", GetLastError());
11398 ok(!size, "got %lu bytes\n", size);
11399 acceptor = accept(listener, NULL, NULL);
11400 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11401 closesocket(acceptor);
11402
11403 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11404 ok(!ret, "expected failure\n");
11405 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11406
11407 closesocket(connector);
11408 CloseHandle(port);
11409
11410 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent & ~1);
11411
11412 /* Skip completion on success. */
11413
11414 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11415 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11416 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11417 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11418 ret = SetFileCompletionNotificationModes((HANDLE)connector, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS);
11419 ok(ret, "got error %lu\n", GetLastError());
11420 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
11421 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11422
11423 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
11424 NULL, 0, &size, &overlapped);
11425 ok(!ret, "expected failure\n");
11426 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11427 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11428 ok(!ret, "wait failed\n");
11429 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
11430 ok(ret, "got error %lu\n", GetLastError());
11431 ok(!size, "got %lu bytes\n", size);
11432 acceptor = accept(listener, NULL, NULL);
11433 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11434 closesocket(acceptor);
11435
11436 size = 0xdeadbeef;
11437 key = 0xdeadbeef;
11438 overlapped_ptr = NULL;
11439 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11440 ok(ret, "got error %lu\n", GetLastError());
11441 ok(!key, "got key %#Ix\n", key);
11442 ok(!size, "got %lu bytes\n", size);
11443 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11444
11445 closesocket(connector);
11446 CloseHandle(port);
11447
11448 closesocket(listener);
11449
11450 /* Connect to an invalid address. */
11451
11452 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11453 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11454 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11455 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11456 ret = SetFileCompletionNotificationModes((HANDLE)connector, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS);
11457 ok(ret, "got error %lu\n", GetLastError());
11458 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
11459 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11460
11461 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
11462 NULL, 0, &size, &overlapped);
11463 ok(!ret, "expected failure\n");
11464 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11465 ret = WaitForSingleObject(overlapped.hEvent, 15000);
11466 ok(!ret, "wait failed\n");
11467 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
11468 ok(!ret, "expected failure\n");
11469 ok(GetLastError() == ERROR_CONNECTION_REFUSED, "got error %lu\n", GetLastError());
11470 ok(!size, "got %lu bytes\n", size);
11471
11472 size = 0xdeadbeef;
11473 key = 0xdeadbeef;
11474 overlapped_ptr = NULL;
11475 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11476 ok(!ret, "expected failure\n");
11477 ok(GetLastError() == ERROR_CONNECTION_REFUSED, "got error %lu\n", GetLastError());
11478 ok(!key, "got key %#Ix\n", key);
11479 ok(!size, "got %lu bytes\n", size);
11480 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11481
11482 closesocket(connector);
11483 CloseHandle(port);
11484 }
11485
11486 static void test_shutdown_completion_port(void)
11487 {
11488 OVERLAPPED overlapped = {0}, *overlapped_ptr;
11489 GUID disconnectex_guid = WSAID_DISCONNECTEX;
11490 struct sockaddr_in addr, destaddr;
11491 LPFN_DISCONNECTEX pDisconnectEx;
11492 SOCKET listener, server, client;
11493 int ret, addrlen;
11494 ULONG_PTR key;
11495 HANDLE port;
11496 DWORD size;
11497
11498 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
11499
11500 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11501 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
11502
11503 memset(&addr, 0, sizeof(addr));
11504 addr.sin_family = AF_INET;
11505 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
11506 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
11507 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11508 addrlen = sizeof(destaddr);
11509 ret = getsockname(listener, (struct sockaddr *)&destaddr, &addrlen);
11510 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
11511
11512 ret = listen(listener, 1);
11513 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
11514
11515 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11516 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11517
11518 ret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &disconnectex_guid, sizeof(disconnectex_guid),
11519 &pDisconnectEx, sizeof(pDisconnectEx), &size, NULL, NULL);
11520 ok(!ret, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
11521
11522 /* shutdown() does not queue completion. */
11523
11524 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11525 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11526 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11527 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11528 server = accept(listener, NULL, NULL);
11529 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11530
11531 ret = shutdown(client, SD_BOTH);
11532 ok(!ret, "failed to shutdown, error %u\n", WSAGetLastError());
11533
11534 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11535 ok(!ret, "expected failure\n");
11536 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11537
11538 closesocket(server);
11539 closesocket(client);
11540 CloseHandle(port);
11541
11542 /* WSASendDisconnect() and WSARecvDisconnect() do not queue completion. */
11543
11544 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11545 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11546 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11547 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11548 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11549 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11550 server = accept(listener, NULL, NULL);
11551 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11552
11553 ret = WSASendDisconnect(client, NULL);
11554 ok(!ret, "failed to shutdown, error %u\n", WSAGetLastError());
11555
11556 ret = WSARecvDisconnect(client, NULL);
11557 ok(!ret, "failed to shutdown, error %u\n", WSAGetLastError());
11558
11559 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11560 ok(!ret, "expected failure\n");
11561 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11562
11563 closesocket(server);
11564 closesocket(client);
11565 CloseHandle(port);
11566
11567 /* DisconnectEx() queues completion. */
11568
11569 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11570 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11571 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11572 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11573 ret = SetFileCompletionNotificationModes((HANDLE)client, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS);
11574 ok(ret, "got error %lu\n", GetLastError());
11575 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11576 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11577 server = accept(listener, NULL, NULL);
11578 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11579
11580 SetLastError(0xdeadbeef);
11581 ret = pDisconnectEx(client, &overlapped, 0, 0);
11582 ok(!ret, "expected failure\n");
11583 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11584
11585 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11586 ok(!ret, "wait failed\n");
11587
11588 size = 0xdeadbeef;
11589 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, TRUE);
11590 ok(ret, "got error %lu\n", GetLastError());
11591 ok(!size, "got %lu bytes\n", size);
11592
11593 size = 0xdeadbeef;
11594 key = 0xdeadbeef;
11595 overlapped_ptr = NULL;
11596 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11597 todo_wine ok(ret, "got error %lu\n", GetLastError());
11598 todo_wine ok(!key, "got key %#Ix\n", key);
11599 todo_wine ok(!size, "got %lu bytes\n", size);
11600 todo_wine ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11601
11602 closesocket(server);
11603 closesocket(client);
11604 CloseHandle(port);
11605
11606 /* Test passing a NULL overlapped structure to DisconnectEx(). */
11607
11608 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11609 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11610 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11611 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11612 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11613 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11614 server = accept(listener, NULL, NULL);
11615 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11616
11617 SetLastError(0xdeadbeef);
11618 ret = pDisconnectEx(client, NULL, 0, 0);
11619 ok(ret, "expected success\n");
11620 ok(!GetLastError() || GetLastError() == 0xdeadbeef /* < 7 */, "got error %lu\n", GetLastError());
11621
11622 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11623 ok(!ret, "expected failure\n");
11624 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11625
11626 closesocket(server);
11627 closesocket(client);
11628 CloseHandle(port);
11629
11630 /* Suppress completion by setting the low bit. */
11631
11632 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11633 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11634 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11635 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11636 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11637 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11638 server = accept(listener, NULL, NULL);
11639 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11640
11641 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent | 1);
11642
11643 SetLastError(0xdeadbeef);
11644 ret = pDisconnectEx(client, &overlapped, 0, 0);
11645 ok(!ret, "expected failure\n");
11646 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11647
11648 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11649 ok(!ret, "wait failed\n");
11650
11651 size = 0xdeadbeef;
11652 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, TRUE);
11653 ok(ret, "got error %lu\n", GetLastError());
11654 ok(!size, "got %lu bytes\n", size);
11655
11656 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11657 ok(!ret, "expected failure\n");
11658 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11659
11660 closesocket(server);
11661 closesocket(client);
11662 CloseHandle(port);
11663
11664 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent & ~1);
11665
11666 CloseHandle(overlapped.hEvent);
11667 }
11668
11669 static void test_address_list_query(void)
11670 {
11671 char buffer[1024];
11672 SOCKET_ADDRESS_LIST *address_list = (SOCKET_ADDRESS_LIST *)buffer;
11673 OVERLAPPED overlapped = {0}, *overlapped_ptr;
11674 DWORD size, expect_size;
11675 unsigned int i;
11676 ULONG_PTR key;
11677 HANDLE port;
11678 SOCKET s;
11679 int ret;
11680
11681 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11682 ok(s != INVALID_SOCKET, "Failed to create socket, error %d.\n", WSAGetLastError());
11683 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
11684
11685 size = 0;
11686 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, 0, &size, NULL, NULL);
11687 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11688 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11689 ok(size >= FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), "Got unexpected size %lu.\n", size);
11690 expect_size = size;
11691
11692 size = 0;
11693 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), &size, NULL, NULL);
11694 ok(!ret, "Got unexpected ret %d.\n", ret);
11695 ok(!WSAGetLastError(), "Got unexpected error %d.\n", WSAGetLastError());
11696 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11697
11698 expect_size = FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[address_list->iAddressCount]);
11699 for (i = 0; i < address_list->iAddressCount; ++i)
11700 {
11701 expect_size += address_list->Address[i].iSockaddrLength;
11702 }
11703 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11704
11705 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), NULL, NULL, NULL);
11706 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11707 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11708
11709 size = 0xdeadbeef;
11710 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, sizeof(buffer), &size, NULL, NULL);
11711 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11712 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11713 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11714
11715 size = 0xdeadbeef;
11716 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 0, &size, NULL, NULL);
11717 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11718 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11719 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11720
11721 size = 0xdeadbeef;
11722 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 1, &size, NULL, NULL);
11723 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11724 ok(WSAGetLastError() == WSAEINVAL, "Got unexpected error %d.\n", WSAGetLastError());
11725 ok(!size, "Got size %lu.\n", size);
11726
11727 size = 0xdeadbeef;
11728 memset(buffer, 0xcc, sizeof(buffer));
11729 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer,
11730 FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), &size, NULL, NULL);
11731 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11732 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11733 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11734 ok(address_list->iAddressCount == 0xcccccccc, "Got %u addresses.\n", address_list->iAddressCount);
11735
11736 WSASetLastError(0xdeadbeef);
11737 overlapped.Internal = 0xdeadbeef;
11738 overlapped.InternalHigh = 0xdeadbeef;
11739 size = 0xdeadbeef;
11740 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 0, &size, &overlapped, NULL);
11741 ok(ret == -1, "Got unexpected ret %d.\n", ret);
11742 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11743 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11744 ok(overlapped.Internal == 0xdeadbeef, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
11745 ok(overlapped.InternalHigh == 0xdeadbeef, "Got size %Iu.\n", overlapped.InternalHigh);
11746
11747 overlapped.Internal = 0xdeadbeef;
11748 overlapped.InternalHigh = 0xdeadbeef;
11749 size = 0xdeadbeef;
11750 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 1, &size, &overlapped, NULL);
11751 ok(ret == -1, "Got unexpected ret %d.\n", ret);
11752 ok(WSAGetLastError() == WSAEINVAL, "Got unexpected error %d.\n", WSAGetLastError());
11753 ok(!size, "Expected size %lu, got %lu.\n", expect_size, size);
11754 ok(overlapped.Internal == 0xdeadbeef, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
11755 ok(overlapped.InternalHigh == 0xdeadbeef, "Got size %Iu.\n", overlapped.InternalHigh);
11756
11757 overlapped.Internal = 0xdeadbeef;
11758 overlapped.InternalHigh = 0xdeadbeef;
11759 size = 0xdeadbeef;
11760 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer,
11761 FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), &size, &overlapped, NULL);
11762 ok(ret == -1, "Got unexpected ret %d.\n", ret);
11763 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11764 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11765 ok(overlapped.Internal == 0xdeadbeef, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
11766 ok(overlapped.InternalHigh == 0xdeadbeef, "Got size %Iu.\n", overlapped.InternalHigh);
11767 ok(address_list->iAddressCount == 0xcccccccc, "Got %u addresses.\n", address_list->iAddressCount);
11768
11769 overlapped.Internal = 0xdeadbeef;
11770 overlapped.InternalHigh = 0xdeadbeef;
11771 size = 0xdeadbeef;
11772 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), &size, &overlapped, NULL);
11773 ok(!ret, "Got unexpected ret %d.\n", ret);
11774 ok(!WSAGetLastError(), "Got unexpected error %d.\n", WSAGetLastError());
11775 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11776
11777 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11778 ok(ret, "Got error %lu.\n", GetLastError());
11779 ok(!size, "Got size %lu.\n", size);
11780 ok(overlapped_ptr == &overlapped, "Got overlapped %p.\n", overlapped_ptr);
11781 ok(!overlapped.Internal, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
11782 ok(!overlapped.InternalHigh, "Got size %Iu.\n", overlapped.InternalHigh);
11783
11784 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11785 ok(!ret, "Expected failure.\n");
11786 ok(GetLastError() == WAIT_TIMEOUT, "Got error %lu.\n", GetLastError());
11787
11788 closesocket(s);
11789 CloseHandle(port);
11790
11791 /* Test with an APC. */
11792
11793 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11794
11795 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), NULL, &overlapped, socket_apc);
11796 ok(ret == -1, "expected failure\n");
11797 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
11798
11799 apc_count = 0;
11800 size = 0xdeadbeef;
11801 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), &size, &overlapped, socket_apc);
11802 ok(!ret, "expected success\n");
11803 ok(size == expect_size, "got size %lu\n", size);
11804
11805 ret = SleepEx(0, TRUE);
11806 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
11807 ok(apc_count == 1, "APC was called %u times\n", apc_count);
11808 ok(!apc_error, "got APC error %lu\n", apc_error);
11809 ok(!apc_size, "got APC size %lu\n", apc_size);
11810 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
11811
11812 closesocket(s);
11813 }
11814
11815 static void sync_read(SOCKET src, SOCKET dst)
11816 {
11817 int ret;
11818 char data[512];
11819
11820 ret = send(dst, "Hello World!", 12, 0);
11821 ok(ret == 12, "send returned %d\n", ret);
11822
11823 memset(data, 0, sizeof(data));
11824 ret = recv(src, data, sizeof(data), 0);
11825 ok(ret == 12, "expected 12, got %d\n", ret);
11826 ok(!memcmp(data, "Hello World!", 12), "got %u bytes (%*s)\n", ret, ret, data);
11827 }
11828
11829 static void iocp_async_read(SOCKET src, SOCKET dst)
11830 {
11831 HANDLE port;
11832 WSAOVERLAPPED ovl, *ovl_iocp;
11833 WSABUF buf;
11834 int ret;
11835 char data[512];
11836 DWORD flags, bytes;
11837 ULONG_PTR key;
11838
11839 memset(data, 0, sizeof(data));
11840 memset(&ovl, 0, sizeof(ovl));
11841
11842 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11843 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
11844
11845 buf.len = sizeof(data);
11846 buf.buf = data;
11847 bytes = 0xdeadbeef;
11848 flags = 0;
11849 SetLastError(0xdeadbeef);
11850 ret = WSARecv(src, &buf, 1, &bytes, &flags, &ovl, NULL);
11851 ok(ret == SOCKET_ERROR, "got %d\n", ret);
11852 ok(GetLastError() == ERROR_IO_PENDING, "got %lu\n", GetLastError());
11853 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11854
11855 bytes = 0xdeadbeef;
11856 key = 0xdeadbeef;
11857 ovl_iocp = (void *)0xdeadbeef;
11858 SetLastError(0xdeadbeef);
11859 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11860 ok(!ret, "got %d\n", ret);
11861 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11862 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11863 ok(key == 0xdeadbeef, "got key %#Ix\n", key);
11864 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11865
11866 ret = send(dst, "Hello World!", 12, 0);
11867 ok(ret == 12, "send returned %d\n", ret);
11868
11869 bytes = 0xdeadbeef;
11870 key = 0xdeadbeef;
11871 ovl_iocp = NULL;
11872 SetLastError(0xdeadbeef);
11873 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11874 ok(ret, "got %d\n", ret);
11875 ok(bytes == 12, "got bytes %lu\n", bytes);
11876 ok(key == 0x12345678, "got key %#Ix\n", key);
11877 ok(ovl_iocp == &ovl, "got ovl %p\n", ovl_iocp);
11878 if (ovl_iocp)
11879 {
11880 ok(ovl_iocp->InternalHigh == 12, "got %#Ix\n", ovl_iocp->InternalHigh);
11881 ok(!ovl_iocp->Internal , "got %#Ix\n", ovl_iocp->Internal);
11882 ok(!memcmp(data, "Hello World!", 12), "got %lu bytes (%*s)\n", bytes, (int)bytes, data);
11883 }
11884
11885 bytes = 0xdeadbeef;
11886 key = 0xdeadbeef;
11887 ovl_iocp = (void *)0xdeadbeef;
11888 SetLastError(0xdeadbeef);
11889 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11890 ok(!ret, "got %d\n", ret);
11891 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11892 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11893 ok(key == 0xdeadbeef, "got key %#Ix\n", key);
11894 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11895
11896 CloseHandle(port);
11897 }
11898
11899 static void iocp_async_read_closesocket(SOCKET src, int how_to_close)
11900 {
11901 HANDLE port;
11902 WSAOVERLAPPED ovl, *ovl_iocp;
11903 WSABUF buf;
11904 int ret;
11905 char data[512];
11906 DWORD flags, bytes;
11907 ULONG_PTR key;
11908 HWND hwnd;
11909 MSG msg;
11910
11911 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
11912 0, 0, 0, 0, NULL, NULL, 0, NULL);
11913 ok(hwnd != 0, "CreateWindowEx failed\n");
11914
11915 ret = WSAAsyncSelect(src, hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
11916 ok(!ret, "got %d\n", ret);
11917
11918 Sleep(100);
11919 memset(&msg, 0, sizeof(msg));
11920 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11921 ok(ret, "got %d\n", ret);
11922 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11923 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11924 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
11925 ok(msg.lParam == 2, "got %08Ix\n", msg.lParam);
11926
11927 memset(data, 0, sizeof(data));
11928 memset(&ovl, 0, sizeof(ovl));
11929
11930 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11931 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
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 buf.len = sizeof(data);
11938 buf.buf = data;
11939 bytes = 0xdeadbeef;
11940 flags = 0;
11941 SetLastError(0xdeadbeef);
11942 ret = WSARecv(src, &buf, 1, &bytes, &flags, &ovl, NULL);
11943 ok(ret == SOCKET_ERROR, "got %d\n", ret);
11944 ok(GetLastError() == ERROR_IO_PENDING, "got %lu\n", GetLastError());
11945 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11946
11947 Sleep(100);
11948 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11949 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11950
11951 bytes = 0xdeadbeef;
11952 key = 0xdeadbeef;
11953 ovl_iocp = (void *)0xdeadbeef;
11954 SetLastError(0xdeadbeef);
11955 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11956 ok(!ret, "got %d\n", ret);
11957 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11958 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11959 ok(key == 0xdeadbeef, "got key %#Ix\n", key);
11960 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11961
11962 Sleep(100);
11963 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11964 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11965
11966 switch (how_to_close)
11967 {
11968 case 0:
11969 closesocket(src);
11970 break;
11971 case 1:
11972 CloseHandle((HANDLE)src);
11973 break;
11974 case 2:
11975 pNtClose((HANDLE)src);
11976 break;
11977 default:
11978 ok(0, "wrong value %d\n", how_to_close);
11979 break;
11980 }
11981
11982 Sleep(200);
11983 memset(&msg, 0, sizeof(msg));
11984 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11985 switch (how_to_close)
11986 {
11987 case 0:
11988 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11989 break;
11990 case 1:
11991 case 2:
11992 todo_wine
11993 {
11994 ok(ret, "got %d\n", ret);
11995 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11996 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11997 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
11998 ok(msg.lParam == 0x20, "got %08Ix\n", msg.lParam);
11999 }
12000 break;
12001 default:
12002 ok(0, "wrong value %d\n", how_to_close);
12003 break;
12004 }
12005
12006 bytes = 0xdeadbeef;
12007 key = 0xdeadbeef;
12008 ovl_iocp = NULL;
12009 SetLastError(0xdeadbeef);
12010 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
12011 ok(!ret, "got %d\n", ret);
12012 todo_wine
12013 ok(GetLastError() == ERROR_CONNECTION_ABORTED || GetLastError() == ERROR_NETNAME_DELETED /* XP */, "got %lu\n", GetLastError());
12014 ok(!bytes, "got bytes %lu\n", bytes);
12015 ok(key == 0x12345678, "got key %#Ix\n", key);
12016 ok(ovl_iocp == &ovl, "got ovl %p\n", ovl_iocp);
12017 if (ovl_iocp)
12018 {
12019 ok(!ovl_iocp->InternalHigh, "got %#Ix\n", ovl_iocp->InternalHigh);
12020 todo_wine
12021 ok(ovl_iocp->Internal == (ULONG)STATUS_CONNECTION_ABORTED || ovl_iocp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT /* XP */, "got %#Ix\n", ovl_iocp->Internal);
12022 }
12023
12024 bytes = 0xdeadbeef;
12025 key = 0xdeadbeef;
12026 ovl_iocp = (void *)0xdeadbeef;
12027 SetLastError(0xdeadbeef);
12028 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
12029 ok(!ret, "got %d\n", ret);
12030 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
12031 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
12032 ok(key == 0xdeadbeef, "got key %#Ix\n", key);
12033 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
12034
12035 CloseHandle(port);
12036
12037 DestroyWindow(hwnd);
12038 }
12039
12040 static void iocp_async_closesocket(SOCKET src)
12041 {
12042 HANDLE port;
12043 WSAOVERLAPPED *ovl_iocp;
12044 int ret;
12045 DWORD bytes;
12046 ULONG_PTR key;
12047 HWND hwnd;
12048 MSG msg;
12049
12050 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
12051 0, 0, 0, 0, NULL, NULL, 0, NULL);
12052 ok(hwnd != 0, "CreateWindowEx failed\n");
12053
12054 ret = WSAAsyncSelect(src, hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
12055 ok(!ret, "got %d\n", ret);
12056
12057 Sleep(100);
12058 memset(&msg, 0, sizeof(msg));
12059 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12060 ok(ret, "got %d\n", ret);
12061 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
12062 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
12063 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
12064 ok(msg.lParam == 2, "got %08Ix\n", msg.lParam);
12065
12066 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
12067 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
12068
12069 Sleep(100);
12070 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12071 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12072
12073 bytes = 0xdeadbeef;
12074 key = 0xdeadbeef;
12075 ovl_iocp = (void *)0xdeadbeef;
12076 SetLastError(0xdeadbeef);
12077 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
12078 ok(!ret, "got %d\n", ret);
12079 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
12080 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
12081 ok(key == 0xdeadbeef, "got key %Iu\n", key);
12082 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
12083
12084 Sleep(100);
12085 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12086 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12087
12088 closesocket(src);
12089
12090 Sleep(100);
12091 memset(&msg, 0, sizeof(msg));
12092 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12093 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12094
12095 bytes = 0xdeadbeef;
12096 key = 0xdeadbeef;
12097 ovl_iocp = (void *)0xdeadbeef;
12098 SetLastError(0xdeadbeef);
12099 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
12100 ok(!ret, "got %d\n", ret);
12101 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
12102 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
12103 ok(key == 0xdeadbeef, "got key %Iu\n", key);
12104 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
12105
12106 CloseHandle(port);
12107
12108 DestroyWindow(hwnd);
12109 }
12110
12111 struct wsa_async_select_info
12112 {
12113 SOCKET sock;
12114 HWND hwnd;
12115 };
12116
12117 static DWORD WINAPI wsa_async_select_thread(void *param)
12118 {
12119 struct wsa_async_select_info *info = param;
12120 int ret;
12121
12122 ret = WSAAsyncSelect(info->sock, info->hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
12123 ok(!ret, "got %d\n", ret);
12124
12125 return 0;
12126 }
12127
12128 struct wsa_recv_info
12129 {
12130 SOCKET sock;
12131 WSABUF wsa_buf;
12132 WSAOVERLAPPED ovl;
12133 };
12134
12135 static DWORD WINAPI wsa_recv_thread(void *param)
12136 {
12137 struct wsa_recv_info *info = param;
12138 int ret;
12139 DWORD flags, bytes;
12140
12141 bytes = 0xdeadbeef;
12142 flags = 0;
12143 SetLastError(0xdeadbeef);
12144 ret = WSARecv(info->sock, &info->wsa_buf, 1, &bytes, &flags, &info->ovl, NULL);
12145 ok(ret == SOCKET_ERROR, "got %d\n", ret);
12146 ok(GetLastError() == ERROR_IO_PENDING, "got %lu\n", GetLastError());
12147 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
12148
12149 return 0;
12150 }
12151
12152 static void iocp_async_read_thread_closesocket(SOCKET src)
12153 {
12154 struct wsa_async_select_info select_info;
12155 struct wsa_recv_info recv_info;
12156 HANDLE port, thread;
12157 WSAOVERLAPPED *ovl_iocp;
12158 int ret;
12159 char data[512];
12160 DWORD bytes, tid;
12161 ULONG_PTR key;
12162 HWND hwnd;
12163 MSG msg;
12164
12165 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
12166 0, 0, 0, 0, NULL, NULL, 0, NULL);
12167 ok(hwnd != 0, "CreateWindowEx failed\n");
12168
12169 select_info.sock = src;
12170 select_info.hwnd = hwnd;
12171 thread = CreateThread(NULL, 0, wsa_async_select_thread, &select_info, 0, &tid);
12172 ok(thread != 0, "CreateThread error %lu\n", GetLastError());
12173 ret = WaitForSingleObject(thread, 10000);
12174 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
12175
12176 Sleep(100);
12177 memset(&msg, 0, sizeof(msg));
12178 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12179 ok(ret, "got %d\n", ret);
12180 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
12181 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
12182 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
12183 ok(msg.lParam == 2, "got %08Ix\n", msg.lParam);
12184
12185 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
12186 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
12187
12188 Sleep(100);
12189 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12190 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12191
12192 memset(data, 0, sizeof(data));
12193 memset(&recv_info.ovl, 0, sizeof(recv_info.ovl));
12194 recv_info.sock = src;
12195 recv_info.wsa_buf.len = sizeof(data);
12196 recv_info.wsa_buf.buf = data;
12197 thread = CreateThread(NULL, 0, wsa_recv_thread, &recv_info, 0, &tid);
12198 ok(thread != 0, "CreateThread error %lu\n", GetLastError());
12199 ret = WaitForSingleObject(thread, 10000);
12200 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
12201
12202 Sleep(100);
12203 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12204 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12205
12206 bytes = 0xdeadbeef;
12207 key = 0xdeadbeef;
12208 ovl_iocp = (void *)0xdeadbeef;
12209 SetLastError(0xdeadbeef);
12210 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
12211 ok(!ret, "got %d\n", ret);
12212 ok(GetLastError() == WAIT_TIMEOUT || broken(GetLastError() == ERROR_OPERATION_ABORTED) /* XP */,
12213 "got %lu\n", GetLastError());
12214 if (GetLastError() == WAIT_TIMEOUT)
12215 {
12216 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
12217 ok(key == 0xdeadbeef, "got key %Ix\n", key);
12218 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
12219 }
12220 else /* document XP behaviour */
12221 {
12222 ok(!bytes, "got bytes %lu\n", bytes);
12223 ok(key == 0x12345678, "got key %#Ix\n", key);
12224 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
12225 if (ovl_iocp)
12226 {
12227 ok(!ovl_iocp->InternalHigh, "got %#Ix\n", ovl_iocp->InternalHigh);
12228 ok(ovl_iocp->Internal == STATUS_CANCELLED, "got %#Ix\n", ovl_iocp->Internal);
12229 }
12230
12231 closesocket(src);
12232 goto xp_is_broken;
12233 }
12234
12235 Sleep(100);
12236 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12237 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12238
12239 closesocket(src);
12240
12241 Sleep(100);
12242 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12243 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12244
12245 bytes = 0xdeadbeef;
12246 key = 0xdeadbeef;
12247 ovl_iocp = NULL;
12248 SetLastError(0xdeadbeef);
12249 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
12250 ok(!ret, "got %d\n", ret);
12251 todo_wine
12252 ok(GetLastError() == ERROR_CONNECTION_ABORTED || GetLastError() == ERROR_NETNAME_DELETED /* XP */, "got %lu\n", GetLastError());
12253 ok(!bytes, "got bytes %lu\n", bytes);
12254 ok(key == 0x12345678, "got key %#Ix\n", key);
12255 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
12256 if (ovl_iocp)
12257 {
12258 ok(!ovl_iocp->InternalHigh, "got %#Ix\n", ovl_iocp->InternalHigh);
12259 todo_wine
12260 ok(ovl_iocp->Internal == (ULONG)STATUS_CONNECTION_ABORTED || ovl_iocp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT /* XP */, "got %#Ix\n", ovl_iocp->Internal);
12261 }
12262
12263 xp_is_broken:
12264 bytes = 0xdeadbeef;
12265 key = 0xdeadbeef;
12266 ovl_iocp = (void *)0xdeadbeef;
12267 SetLastError(0xdeadbeef);
12268 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
12269 ok(!ret, "got %d\n", ret);
12270 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
12271 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
12272 ok(key == 0xdeadbeef, "got key %Iu\n", key);
12273 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
12274
12275 CloseHandle(port);
12276
12277 DestroyWindow(hwnd);
12278 }
12279
12280 static void iocp_async_read_thread(SOCKET src, SOCKET dst)
12281 {
12282 struct wsa_async_select_info select_info;
12283 struct wsa_recv_info recv_info;
12284 HANDLE port, thread;
12285 WSAOVERLAPPED *ovl_iocp;
12286 int ret;
12287 char data[512];
12288 DWORD bytes, tid;
12289 ULONG_PTR key;
12290 HWND hwnd;
12291 MSG msg;
12292
12293 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
12294 0, 0, 0, 0, NULL, NULL, 0, NULL);
12295 ok(hwnd != 0, "CreateWindowEx failed\n");
12296
12297 select_info.sock = src;
12298 select_info.hwnd = hwnd;
12299 thread = CreateThread(NULL, 0, wsa_async_select_thread, &select_info, 0, &tid);
12300 ok(thread != 0, "CreateThread error %lu\n", GetLastError());
12301 ret = WaitForSingleObject(thread, 10000);
12302 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
12303
12304 Sleep(100);
12305 memset(&msg, 0, sizeof(msg));
12306 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12307 ok(ret, "got %d\n", ret);
12308 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
12309 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
12310 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
12311 ok(msg.lParam == 2, "got %08Ix\n", msg.lParam);
12312
12313 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
12314 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
12315
12316 Sleep(100);
12317 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12318 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12319
12320 memset(data, 0, sizeof(data));
12321 memset(&recv_info.ovl, 0, sizeof(recv_info.ovl));
12322 recv_info.sock = src;
12323 recv_info.wsa_buf.len = sizeof(data);
12324 recv_info.wsa_buf.buf = data;
12325 thread = CreateThread(NULL, 0, wsa_recv_thread, &recv_info, 0, &tid);
12326 ok(thread != 0, "CreateThread error %lu\n", GetLastError());
12327 ret = WaitForSingleObject(thread, 10000);
12328 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
12329
12330 Sleep(100);
12331 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12332 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12333
12334 bytes = 0xdeadbeef;
12335 key = 0xdeadbeef;
12336 ovl_iocp = (void *)0xdeadbeef;
12337 SetLastError(0xdeadbeef);
12338 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
12339 ok(!ret, "got %d\n", ret);
12340 ok(GetLastError() == WAIT_TIMEOUT || broken(GetLastError() == ERROR_OPERATION_ABORTED) /* XP */, "got %lu\n", GetLastError());
12341 if (GetLastError() == WAIT_TIMEOUT)
12342 {
12343 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
12344 ok(key == 0xdeadbeef, "got key %Iu\n", key);
12345 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
12346 }
12347 else /* document XP behaviour */
12348 {
12349 ok(bytes == 0, "got bytes %lu\n", bytes);
12350 ok(key == 0x12345678, "got key %#Ix\n", key);
12351 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
12352 if (ovl_iocp)
12353 {
12354 ok(!ovl_iocp->InternalHigh, "got %#Ix\n", ovl_iocp->InternalHigh);
12355 ok(ovl_iocp->Internal == STATUS_CANCELLED, "got %#Ix\n", ovl_iocp->Internal);
12356 }
12357 }
12358
12359 Sleep(100);
12360 memset(&msg, 0, sizeof(msg));
12361 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12362 ok(!ret || broken(msg.hwnd == hwnd) /* XP */, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12363 if (ret) /* document XP behaviour */
12364 {
12365 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
12366 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
12367 ok(msg.lParam == 1, "got %08Ix\n", msg.lParam);
12368 }
12369
12370 ret = send(dst, "Hello World!", 12, 0);
12371 ok(ret == 12, "send returned %d\n", ret);
12372
12373 Sleep(100);
12374 memset(&msg, 0, sizeof(msg));
12375 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
12376 ok(!ret || broken(msg.hwnd == hwnd) /* XP */, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
12377 if (ret) /* document XP behaviour */
12378 {
12379 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
12380 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
12381 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
12382 ok(msg.lParam == 1, "got %08Ix\n", msg.lParam);
12383 }
12384
12385 bytes = 0xdeadbeef;
12386 key = 0xdeadbeef;
12387 ovl_iocp = (void *)0xdeadbeef;
12388 SetLastError(0xdeadbeef);
12389 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
12390 ok(ret || broken(GetLastError() == WAIT_TIMEOUT) /* XP */, "got %lu\n", GetLastError());
12391 if (ret)
12392 {
12393 ok(bytes == 12, "got bytes %lu\n", bytes);
12394 ok(key == 0x12345678, "got key %#Ix\n", key);
12395 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
12396 if (ovl_iocp)
12397 {
12398 ok(ovl_iocp->InternalHigh == 12, "got %#Ix\n", ovl_iocp->InternalHigh);
12399 ok(!ovl_iocp->Internal , "got %#Ix\n", ovl_iocp->Internal);
12400 ok(!memcmp(data, "Hello World!", 12), "got %lu bytes (%*s)\n", bytes, (int)bytes, data);
12401 }
12402 }
12403 else /* document XP behaviour */
12404 {
12405 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
12406 ok(key == 0xdeadbeef, "got key %Iu\n", key);
12407 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
12408 }
12409
12410 CloseHandle(port);
12411
12412 DestroyWindow(hwnd);
12413 }
12414
12415 static void test_iocp(void)
12416 {
12417 SOCKET src, dst;
12418 int i;
12419
12420 tcp_socketpair(&src, &dst);
12421 sync_read(src, dst);
12422 iocp_async_read(src, dst);
12423 closesocket(src);
12424 closesocket(dst);
12425
12426 tcp_socketpair(&src, &dst);
12427 iocp_async_read_thread(src, dst);
12428 closesocket(src);
12429 closesocket(dst);
12430
12431 for (i = 0; i <= 2; i++)
12432 {
12433 tcp_socketpair(&src, &dst);
12434 iocp_async_read_closesocket(src, i);
12435 closesocket(dst);
12436 }
12437
12438 tcp_socketpair(&src, &dst);
12439 iocp_async_closesocket(src);
12440 closesocket(dst);
12441
12442 tcp_socketpair(&src, &dst);
12443 iocp_async_read_thread_closesocket(src);
12444 closesocket(dst);
12445 }
12446
12447 static void test_get_interface_list(void)
12448 {
12449 OVERLAPPED overlapped = {0}, *overlapped_ptr;
12450 DWORD size, expect_size;
12451 unsigned int i, count;
12452 INTERFACE_INFO *info;
12453 BOOL loopback_found;
12454 char buffer[4096];
12455 ULONG_PTR key;
12456 HANDLE port;
12457 SOCKET s;
12458 int ret;
12459
12460 s = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
12461 ok(s != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
12462 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
12463
12464 size = 0xdeadbeef;
12465 WSASetLastError(0xdeadbeef);
12466 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(buffer), &size, NULL, NULL);
12467 ok(!ret, "Got unexpected ret %d.\n", ret);
12468 ok(!WSAGetLastError(), "Got error %u.\n", WSAGetLastError());
12469 ok(size && size != 0xdeadbeef && !(size % sizeof(INTERFACE_INFO)), "Got unexpected size %lu.\n", size);
12470 expect_size = size;
12471
12472 size = 0xdeadbeef;
12473 overlapped.Internal = 0xdeadbeef;
12474 overlapped.InternalHigh = 0xdeadbeef;
12475 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(buffer), &size, &overlapped, NULL);
12476 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12477 ok(WSAGetLastError() == ERROR_IO_PENDING, "Got error %u.\n", WSAGetLastError());
12478 ok(size == 0xdeadbeef, "Got size %lu.\n", size);
12479
12480 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 100);
12481 ok(ret, "Got error %lu.\n", GetLastError());
12482 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
12483 ok(key == 123, "Got key %Iu.\n", key);
12484 ok(overlapped_ptr == &overlapped, "Got overlapped %p.\n", overlapped_ptr);
12485 ok(!overlapped.Internal, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
12486 ok(overlapped.InternalHigh == expect_size, "Expected size %lu, got %Iu.\n", expect_size, overlapped.InternalHigh);
12487
12488 info = (INTERFACE_INFO *)buffer;
12489 count = size / sizeof(INTERFACE_INFO);
12490 loopback_found = FALSE;
12491 for (i = 0; i < count; ++i)
12492 {
12493 if (info[i].iiFlags & IFF_LOOPBACK)
12494 loopback_found = TRUE;
12495
12496 ok(info[i].iiAddress.AddressIn.sin_family == AF_INET, "Got unexpected sin_family %#x.\n",
12497 info[i].iiAddress.AddressIn.sin_family);
12498 ok(info[i].iiNetmask.AddressIn.sin_family == AF_INET, "Got unexpected sin_family %#x.\n",
12499 info[i].iiNetmask.AddressIn.sin_family);
12500 ok(info[i].iiBroadcastAddress.AddressIn.sin_family
12501 == (info[i].iiFlags & IFF_BROADCAST) ? AF_INET : 0, "Got unexpected sin_family %#x.\n",
12502 info[i].iiBroadcastAddress.AddressIn.sin_family);
12503 ok(info[i].iiAddress.AddressIn.sin_addr.S_un.S_addr, "Got zero iiAddress.\n");
12504 ok(info[i].iiNetmask.AddressIn.sin_addr.S_un.S_addr, "Got zero iiNetmask.\n");
12505 ok((info[i].iiFlags & IFF_BROADCAST) ? info[i].iiBroadcastAddress.AddressIn.sin_addr.S_un.S_addr
12506 : !info[i].iiBroadcastAddress.AddressIn.sin_addr.S_un.S_addr,
12507 "Got unexpected iiBroadcastAddress %s.\n", inet_ntoa(info[i].iiBroadcastAddress.AddressIn.sin_addr));
12508 }
12509
12510 ok(loopback_found, "Loopback interface not found.\n");
12511
12512 size = 0xdeadbeef;
12513 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(INTERFACE_INFO) - 1, &size, NULL, NULL);
12514 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12515 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
12516 ok(!size, "Got unexpected size %lu.\n", size);
12517
12518 size = 0xdeadbeef;
12519 overlapped.Internal = 0xdeadbeef;
12520 overlapped.InternalHigh = 0xdeadbeef;
12521 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(INTERFACE_INFO) - 1, &size, &overlapped, NULL);
12522 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12523 ok(WSAGetLastError() == ERROR_IO_PENDING, "Got error %u.\n", WSAGetLastError());
12524 ok(size == 0xdeadbeef, "Got size %lu.\n", size);
12525
12526 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 100);
12527 ok(!ret, "Expected failure.\n");
12528 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Got error %lu.\n", GetLastError());
12529 ok(!size, "Got size %lu.\n", size);
12530 ok(key == 123, "Got key %Iu.\n", key);
12531 ok(overlapped_ptr == &overlapped, "Got overlapped %p.\n", overlapped_ptr);
12532 ok((NTSTATUS)overlapped.Internal == STATUS_BUFFER_TOO_SMALL, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
12533 ok(!overlapped.InternalHigh, "Got size %Iu.\n", overlapped.InternalHigh);
12534
12535 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(buffer), NULL, NULL, NULL);
12536 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12537 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
12538
12539 CloseHandle(port);
12540 closesocket(s);
12541
12542 /* Test with an APC. */
12543
12544 s = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
12545 ok(s != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
12546
12547 size = 0xdeadbeef;
12548 apc_count = 0;
12549 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer,
12550 sizeof(INTERFACE_INFO) - 1, &size, &overlapped, socket_apc);
12551 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12552 ok(WSAGetLastError() == ERROR_IO_PENDING, "Got error %u.\n", WSAGetLastError());
12553 ok(size == 0xdeadbeef, "Got size %lu.\n", size);
12554
12555 ret = SleepEx(100, TRUE);
12556 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
12557 ok(apc_count == 1, "APC was called %u times\n", apc_count);
12558 ok(apc_error == WSAEFAULT, "got APC error %lu\n", apc_error);
12559 ok(!apc_size, "got APC size %lu\n", apc_size);
12560 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
12561
12562 closesocket(s);
12563 }
12564
12565 static IP_ADAPTER_ADDRESSES *get_adapters(void)
12566 {
12567 ULONG err, size = 4096;
12568 IP_ADAPTER_ADDRESSES *tmp, *ret;
12569
12570 if (!(ret = malloc( size ))) return NULL;
12571 err = GetAdaptersAddresses( AF_UNSPEC, 0, NULL, ret, &size );
12572 while (err == ERROR_BUFFER_OVERFLOW)
12573 {
12574 if (!(tmp = realloc( ret, size ))) break;
12575 ret = tmp;
12576 err = GetAdaptersAddresses( AF_UNSPEC, 0, NULL, ret, &size );
12577 }
12578 if (err == ERROR_SUCCESS) return ret;
12579 free( ret );
12580 return NULL;
12581 }
12582
12583 static void test_bind(void)
12584 {
12585 const struct sockaddr_in invalid_addr = {.sin_family = AF_INET, .sin_addr.s_addr = inet_addr("192.0.2.0")};
12586 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
12587 IP_ADAPTER_ADDRESSES *adapters, *adapter;
12588 struct sockaddr addr;
12589 SOCKET s, s2;
12590 int ret, len;
12591
12592 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12593
12594 WSASetLastError(0xdeadbeef);
12595 ret = bind(s, NULL, 0);
12596 ok(ret == -1, "expected failure\n");
12597 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12598
12599 WSASetLastError(0xdeadbeef);
12600 ret = bind(s, NULL, sizeof(addr));
12601 ok(ret == -1, "expected failure\n");
12602 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12603
12604 addr.sa_family = AF_INET;
12605 WSASetLastError(0xdeadbeef);
12606 ret = bind(s, &addr, 0);
12607 ok(ret == -1, "expected failure\n");
12608 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12609
12610 addr.sa_family = 0xdead;
12611 WSASetLastError(0xdeadbeef);
12612 ret = bind(s, &addr, sizeof(addr));
12613 ok(ret == -1, "expected failure\n");
12614 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError());
12615
12616 WSASetLastError(0xdeadbeef);
12617 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr) - 1);
12618 ok(ret == -1, "expected failure\n");
12619 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12620
12621 WSASetLastError(0xdeadbeef);
12622 ret = bind(s, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
12623 ok(ret == -1, "expected failure\n");
12624 ok(WSAGetLastError() == WSAEADDRNOTAVAIL, "got error %u\n", WSAGetLastError());
12625
12626 WSASetLastError(0xdeadbeef);
12627 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12628 ok(!ret, "expected success\n");
12629 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
12630
12631 WSASetLastError(0xdeadbeef);
12632 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12633 ok(ret == -1, "expected failure\n");
12634 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
12635
12636 len = sizeof(addr);
12637 ret = getsockname(s, &addr, &len);
12638 ok(!ret, "got error %u\n", WSAGetLastError());
12639
12640 s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12641
12642 WSASetLastError(0xdeadbeef);
12643 ret = bind(s2, &addr, sizeof(addr));
12644 ok(ret == -1, "expected failure\n");
12645 ok(WSAGetLastError() == WSAEADDRINUSE, "got error %u\n", WSAGetLastError());
12646
12647 closesocket(s2);
12648 closesocket(s);
12649
12650 s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
12651
12652 WSASetLastError(0xdeadbeef);
12653 ret = bind(s, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
12654 ok(ret == -1, "expected failure\n");
12655 ok(WSAGetLastError() == WSAEADDRNOTAVAIL, "got error %u\n", WSAGetLastError());
12656
12657 WSASetLastError(0xdeadbeef);
12658 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12659 ok(!ret, "expected success\n");
12660 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
12661
12662 closesocket(s);
12663
12664 adapters = get_adapters();
12665 ok(adapters != NULL, "can't get adapters\n");
12666
12667 for (adapter = adapters; adapter != NULL; adapter = adapter->Next)
12668 {
12669 const IP_ADAPTER_UNICAST_ADDRESS *unicast_addr;
12670
12671 if (adapter->OperStatus != IfOperStatusUp) continue;
12672
12673 for (unicast_addr = adapter->FirstUnicastAddress; unicast_addr != NULL; unicast_addr = unicast_addr->Next)
12674 {
12675 short family = unicast_addr->Address.lpSockaddr->sa_family;
12676
12677 s = socket(family, SOCK_STREAM, IPPROTO_TCP);
12678 ok(s != -1, "failed to create socket, error %u\n", WSAGetLastError());
12679
12680 ret = bind(s, unicast_addr->Address.lpSockaddr, unicast_addr->Address.iSockaddrLength);
12681 ok(!ret, "got error %u\n", WSAGetLastError());
12682
12683 closesocket(s);
12684
12685 if (family == AF_INET6)
12686 {
12687 struct sockaddr_in6 addr6, ret_addr6;
12688
12689 memcpy(&addr6, unicast_addr->Address.lpSockaddr, sizeof(addr6));
12690
12691 ok(unicast_addr->Address.iSockaddrLength == sizeof(struct sockaddr_in6),
12692 "got unexpected length %u\n", unicast_addr->Address.iSockaddrLength);
12693
12694 s = socket(family, SOCK_STREAM, IPPROTO_TCP);
12695 ok(s != -1, "failed to create socket, error %u\n", WSAGetLastError());
12696
12697 ret = bind(s, unicast_addr->Address.lpSockaddr, sizeof(struct sockaddr_in6_old));
12698 ok(ret == -1, "expected failure\n");
12699 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12700
12701 addr6.sin6_scope_id = 0xabacab;
12702 ret = bind(s, (struct sockaddr *)&addr6, sizeof(addr6));
12703 todo_wine_if (!((const struct sockaddr_in6 *)unicast_addr->Address.lpSockaddr)->sin6_scope_id)
12704 {
12705 ok(ret == -1, "expected failure\n");
12706 ok(WSAGetLastError() == WSAEADDRNOTAVAIL, "got error %u\n", WSAGetLastError());
12707 }
12708
12709 addr6.sin6_scope_id = 0;
12710 ret = bind(s, (struct sockaddr *)&addr6, sizeof(addr6));
12711 todo_wine_if (!((const struct sockaddr_in6 *)unicast_addr->Address.lpSockaddr)->sin6_scope_id)
12712 ok(!ret, "got error %u\n", WSAGetLastError());
12713
12714 memcpy(&addr6, unicast_addr->Address.lpSockaddr, sizeof(addr6));
12715
12716 len = sizeof(struct sockaddr_in6_old);
12717 ret = getsockname(s, (struct sockaddr *)&ret_addr6, &len);
12718 ok(ret == -1, "expected failure\n");
12719 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12720
12721 len = sizeof(ret_addr6);
12722 memset(&ret_addr6, 0, sizeof(ret_addr6));
12723 ret = getsockname(s, (struct sockaddr *)&ret_addr6, &len);
12724 ok(!ret, "got error %u\n", WSAGetLastError());
12725 ok(ret_addr6.sin6_family == AF_INET6, "got family %u\n", ret_addr6.sin6_family);
12726 ok(ret_addr6.sin6_port != 0, "expected nonzero port\n");
12727 ok(!memcmp(&ret_addr6.sin6_addr, &addr6.sin6_addr, sizeof(addr6.sin6_addr)), "address didn't match\n");
12728 ok(ret_addr6.sin6_scope_id == addr6.sin6_scope_id, "got scope %lu\n", ret_addr6.sin6_scope_id);
12729
12730 closesocket(s);
12731 }
12732 }
12733 }
12734
12735 free(adapters);
12736 }
12737
12738 /* Test calling methods on a socket which is currently connecting. */
12739 static void test_connecting_socket(void)
12740 {
12741 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_ANY)};
12742 const struct sockaddr_in invalid_addr =
12743 {
12744 .sin_family = AF_INET,
12745 .sin_addr.s_addr = inet_addr("192.0.2.0"),
12746 .sin_port = 255
12747 };
12748 OVERLAPPED overlapped = {0}, overlapped2 = {0};
12749 GUID connectex_guid = WSAID_CONNECTEX;
12750 LPFN_CONNECTEX pConnectEx;
12751 struct sockaddr_in addr;
12752 char buffer[4];
12753 SOCKET client;
12754 int ret, len;
12755 DWORD size;
12756
12757 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12758 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
12759 set_blocking(client, FALSE);
12760
12761 ret = bind(client, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12762 ok(!ret, "expected success\n");
12763 ok(!WSAGetLastError(), "got %u\n", WSAGetLastError());
12764
12765 ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
12766 ok(ret == -1, "got %d\n", ret);
12767 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got %u\n", WSAGetLastError());
12768
12769 /* Mortal Kombat 11 connects to the same address twice and expects the
12770 * second to return WSAEALREADY. */
12771 ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
12772 ok(ret == -1, "got %d\n", ret);
12773 ok(WSAGetLastError() == WSAEALREADY, "got %u\n", WSAGetLastError());
12774
12775 ret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectex_guid, sizeof(connectex_guid),
12776 &pConnectEx, sizeof(pConnectEx), &size, NULL, NULL);
12777 ok(!ret, "failed to get ConnectEx, error %u\n", WSAGetLastError());
12778 overlapped.Internal = 0xdeadbeef;
12779 overlapped.InternalHigh = 0xdeadbeef;
12780 ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped);
12781 ok(!ret, "got %d\n", ret);
12782 ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError());
12783 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
12784 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
12785
12786 len = sizeof(addr);
12787 ret = getsockname(client, (struct sockaddr *)&addr, &len);
12788 ok(!ret, "got error %u\n", WSAGetLastError());
12789 ok(addr.sin_family == AF_INET, "got family %u\n", addr.sin_family);
12790 ok(addr.sin_port, "expected nonzero port\n");
12791
12792 len = sizeof(addr);
12793 ret = getpeername(client, (struct sockaddr *)&addr, &len);
12794 ok(!ret, "got error %u\n", WSAGetLastError());
12795
12796 ret = recv(client, buffer, sizeof(buffer), 0);
12797 ok(ret == -1, "got %d\n", ret);
12798 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12799
12800 ret = send(client, "data", 5, 0);
12801 ok(ret == -1, "got %d\n", ret);
12802 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12803
12804 closesocket(client);
12805
12806 /* Test with ConnectEx(). */
12807
12808 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12809 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
12810 set_blocking(client, FALSE);
12811
12812 ret = bind(client, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12813 ok(!ret, "expected success\n");
12814 ok(!WSAGetLastError(), "got %u\n", WSAGetLastError());
12815
12816 ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped2);
12817 ok(!ret, "got %d\n", ret);
12818 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
12819
12820 ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
12821 ok(ret == -1, "got %d\n", ret);
12822 ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError());
12823
12824 overlapped.Internal = 0xdeadbeef;
12825 overlapped.InternalHigh = 0xdeadbeef;
12826 ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped);
12827 ok(!ret, "got %d\n", ret);
12828 ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError());
12829 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
12830 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
12831
12832 len = sizeof(addr);
12833 ret = getsockname(client, (struct sockaddr *)&addr, &len);
12834 ok(!ret, "got error %u\n", WSAGetLastError());
12835 ok(addr.sin_family == AF_INET, "got family %u\n", addr.sin_family);
12836 ok(addr.sin_port, "expected nonzero port\n");
12837
12838 len = sizeof(addr);
12839 ret = getpeername(client, (struct sockaddr *)&addr, &len);
12840 ok(ret == -1, "got %d\n", ret);
12841 ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12842
12843 ret = recv(client, buffer, sizeof(buffer), 0);
12844 ok(ret == -1, "got %d\n", ret);
12845 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12846
12847 ret = send(client, "data", 5, 0);
12848 ok(ret == -1, "got %d\n", ret);
12849 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12850
12851 closesocket(client);
12852 }
12853
12854 static DWORD map_status( NTSTATUS status )
12855 {
12856 static const struct
12857 {
12858 NTSTATUS status;
12859 DWORD error;
12860 }
12861 errors[] =
12862 {
12863 {STATUS_PENDING, ERROR_IO_INCOMPLETE},
12864
12865 {STATUS_BUFFER_OVERFLOW, WSAEMSGSIZE},
12866
12867 {STATUS_NOT_IMPLEMENTED, WSAEOPNOTSUPP},
12868 {STATUS_ACCESS_VIOLATION, WSAEFAULT},
12869 {STATUS_PAGEFILE_QUOTA, WSAENOBUFS},
12870 {STATUS_INVALID_HANDLE, WSAENOTSOCK},
12871 {STATUS_NO_SUCH_DEVICE, WSAENETDOWN},
12872 {STATUS_NO_SUCH_FILE, WSAENETDOWN},
12873 {STATUS_NO_MEMORY, WSAENOBUFS},
12874 {STATUS_CONFLICTING_ADDRESSES, WSAENOBUFS},
12875 {STATUS_ACCESS_DENIED, WSAEACCES},
12876 {STATUS_BUFFER_TOO_SMALL, WSAEFAULT},
12877 {STATUS_OBJECT_TYPE_MISMATCH, WSAENOTSOCK},
12878 {STATUS_OBJECT_NAME_NOT_FOUND, WSAENETDOWN},
12879 {STATUS_OBJECT_PATH_NOT_FOUND, WSAENETDOWN},
12880 {STATUS_SHARING_VIOLATION, WSAEADDRINUSE},
12881 {STATUS_QUOTA_EXCEEDED, WSAENOBUFS},
12882 {STATUS_TOO_MANY_PAGING_FILES, WSAENOBUFS},
12883 {STATUS_INSUFFICIENT_RESOURCES, WSAENOBUFS},
12884 {STATUS_WORKING_SET_QUOTA, WSAENOBUFS},
12885 {STATUS_DEVICE_NOT_READY, WSAEWOULDBLOCK},
12886 {STATUS_PIPE_DISCONNECTED, WSAESHUTDOWN},
12887 {STATUS_IO_TIMEOUT, WSAETIMEDOUT},
12888 {STATUS_NOT_SUPPORTED, WSAEOPNOTSUPP},
12889 {STATUS_REMOTE_NOT_LISTENING, WSAECONNREFUSED},
12890 {STATUS_BAD_NETWORK_PATH, WSAENETUNREACH},
12891 {STATUS_NETWORK_BUSY, WSAENETDOWN},
12892 {STATUS_INVALID_NETWORK_RESPONSE, WSAENETDOWN},
12893 {STATUS_UNEXPECTED_NETWORK_ERROR, WSAENETDOWN},
12894 {STATUS_REQUEST_NOT_ACCEPTED, WSAEWOULDBLOCK},
12895 {STATUS_CANCELLED, ERROR_OPERATION_ABORTED},
12896 {STATUS_COMMITMENT_LIMIT, WSAENOBUFS},
12897 {STATUS_LOCAL_DISCONNECT, WSAECONNABORTED},
12898 {STATUS_REMOTE_DISCONNECT, WSAECONNRESET},
12899 {STATUS_REMOTE_RESOURCES, WSAENOBUFS},
12900 {STATUS_LINK_FAILED, WSAECONNRESET},
12901 {STATUS_LINK_TIMEOUT, WSAETIMEDOUT},
12902 {STATUS_INVALID_CONNECTION, WSAENOTCONN},
12903 {STATUS_INVALID_ADDRESS, WSAEADDRNOTAVAIL},
12904 {STATUS_INVALID_BUFFER_SIZE, WSAEMSGSIZE},
12905 {STATUS_INVALID_ADDRESS_COMPONENT, WSAEADDRNOTAVAIL},
12906 {STATUS_TOO_MANY_ADDRESSES, WSAENOBUFS},
12907 {STATUS_ADDRESS_ALREADY_EXISTS, WSAEADDRINUSE},
12908 {STATUS_CONNECTION_DISCONNECTED, WSAECONNRESET},
12909 {STATUS_CONNECTION_RESET, WSAECONNRESET},
12910 {STATUS_TRANSACTION_ABORTED, WSAECONNABORTED},
12911 {STATUS_CONNECTION_REFUSED, WSAECONNREFUSED},
12912 {STATUS_GRACEFUL_DISCONNECT, WSAEDISCON},
12913 {STATUS_CONNECTION_ACTIVE, WSAEISCONN},
12914 {STATUS_NETWORK_UNREACHABLE, WSAENETUNREACH},
12915 {STATUS_HOST_UNREACHABLE, WSAEHOSTUNREACH},
12916 {STATUS_PROTOCOL_UNREACHABLE, WSAENETUNREACH},
12917 {STATUS_PORT_UNREACHABLE, WSAECONNRESET},
12918 {STATUS_REQUEST_ABORTED, WSAEINTR},
12919 {STATUS_CONNECTION_ABORTED, WSAECONNABORTED},
12920 {STATUS_DATATYPE_MISALIGNMENT_ERROR,WSAEFAULT},
12921 {STATUS_HOST_DOWN, WSAEHOSTDOWN},
12922 {0x80070000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
12923 {0xc0010000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
12924 {0xc0070000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
12925 };
12926
12927 unsigned int i;
12928
12929 for (i = 0; i < ARRAY_SIZE(errors); ++i)
12930 {
12931 if (errors[i].status == status)
12932 return errors[i].error;
12933 }
12934
12935 return NT_SUCCESS(status) ? RtlNtStatusToDosErrorNoTeb(status) : WSAEINVAL;
12936 }
12937
12938 static void test_WSAGetOverlappedResult(void)
12939 {
12940 OVERLAPPED overlapped = {0};
12941 DWORD size, flags;
12942 NTSTATUS status;
12943 unsigned int i;
12944 SOCKET s;
12945 HANDLE h;
12946 BOOL ret;
12947
12948 static const NTSTATUS ranges[][2] =
12949 {
12950 {0x0, 0x10000},
12951 {0x40000000, 0x40001000},
12952 {0x80000000, 0x80001000},
12953 {0x80070000, 0x80080000},
12954 {0xc0000000, 0xc0001000},
12955 {0xc0070000, 0xc0080000},
12956 {0xd0000000, 0xd0001000},
12957 {0xd0070000, 0xd0080000},
12958 };
12959
12960 WSASetLastError(0xdeadbeef);
12961 ret = WSAGetOverlappedResult(0xdeadbeef, &overlapped, &size, FALSE, &flags);
12962 ok(!ret, "got %d.\n", ret);
12963 ok(WSAGetLastError() == WSAENOTSOCK, "got %u.\n", WSAGetLastError());
12964
12965 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12966
12967 ret = DuplicateHandle(GetCurrentProcess(), (HANDLE)s, GetCurrentProcess(), &h, 0, FALSE, DUPLICATE_SAME_ACCESS);
12968 ok(ret, "got %d.\n", ret);
12969 ret = WSAGetOverlappedResult((SOCKET)h, &overlapped, &size, FALSE, &flags);
12970 ok(!ret, "got %d.\n", ret);
12971 ok(WSAGetLastError() == WSAENOTSOCK, "got %u.\n", WSAGetLastError());
12972 CloseHandle(h);
12973
12974 for (i = 0; i < ARRAY_SIZE(ranges); ++i)
12975 {
12976 for (status = ranges[i][0]; status < ranges[i][1]; ++status)
12977 {
12978 BOOL expect_ret = NT_SUCCESS(status) && status != STATUS_PENDING;
12979 DWORD expect = map_status(status);
12980
12981 overlapped.Internal = status;
12982 WSASetLastError(0xdeadbeef);
12983 ret = WSAGetOverlappedResult(s, &overlapped, &size, FALSE, &flags);
12984 ok(ret == expect_ret, "status %#lx: expected %d, got %d\n", status, expect_ret, ret);
12985 if (ret)
12986 {
12987 ok(WSAGetLastError() == expect /* >= win10 1809 */
12988 || !WSAGetLastError() /* < win10 1809 */
12989 || WSAGetLastError() == 0xdeadbeef, /* < win7 */
12990 "status %#lx: expected error %lu, got %u\n", status, expect, WSAGetLastError());
12991 }
12992 else
12993 {
12994 ok(WSAGetLastError() == expect
12995 || (status == (0xc0070000 | ERROR_IO_INCOMPLETE) && WSAGetLastError() == WSAEINVAL), /* < win8 */
12996 "status %#lx: expected error %lu, got %u\n", status, expect, WSAGetLastError());
12997 }
12998 }
12999 }
13000
13001 overlapped.Internal = STATUS_PENDING;
13002 overlapped.hEvent = CreateEventW(NULL, TRUE, TRUE, NULL);
13003
13004 apc_count = 0;
13005 ret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
13006 ok(ret, "QueueUserAPC returned %d\n", ret);
13007 ret = WSAGetOverlappedResult(s, &overlapped, &size, TRUE, &flags);
13008 ok(ret && (GetLastError() == ERROR_IO_PENDING || !WSAGetLastError()),
13009 "Got ret %d, err %lu.\n", ret, GetLastError());
13010 ok(!apc_count, "got apc_count %d.\n", apc_count);
13011 SleepEx(0, TRUE);
13012 ok(apc_count == 1, "got apc_count %d.\n", apc_count);
13013
13014 CloseHandle(overlapped.hEvent);
13015 closesocket(s);
13016 }
13017
13018 struct nonblocking_async_recv_params
13019 {
13020 SOCKET client;
13021 HANDLE event;
13022 };
13023
13024 static DWORD CALLBACK nonblocking_async_recv_thread(void *arg)
13025 {
13026 const struct nonblocking_async_recv_params *params = arg;
13027 OVERLAPPED overlapped = {0};
13028 DWORD flags = 0, size;
13029 char buffer[5];
13030 WSABUF wsabuf;
13031 int ret;
13032
13033 overlapped.hEvent = params->event;
13034 wsabuf.buf = buffer;
13035 wsabuf.len = sizeof(buffer);
13036 memset(buffer, 0, sizeof(buffer));
13037 ret = WSARecv(params->client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
13038 ok(!ret, "got %d\n", ret);
13039 ret = GetOverlappedResult((HANDLE)params->client, &overlapped, &size, FALSE);
13040 ok(ret, "got error %lu\n", GetLastError());
13041 ok(size == 4, "got size %lu\n", size);
13042 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
13043
13044 return 0;
13045 }
13046
13047 static void test_nonblocking_async_recv(void)
13048 {
13049 struct nonblocking_async_recv_params params;
13050 OVERLAPPED overlapped = {0};
13051 SOCKET client, server;
13052 DWORD flags = 0, size;
13053 HANDLE thread, event;
13054 char buffer[5];
13055 WSABUF wsabuf;
13056 int ret;
13057
13058 event = CreateEventW(NULL, TRUE, FALSE, NULL);
13059 wsabuf.buf = buffer;
13060 wsabuf.len = sizeof(buffer);
13061
13062 tcp_socketpair(&client, &server);
13063 set_blocking(client, FALSE);
13064 set_blocking(server, FALSE);
13065
13066 WSASetLastError(0xdeadbeef);
13067 ret = recv(client, buffer, sizeof(buffer), 0);
13068 ok(ret == -1, "got %d\n", ret);
13069 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
13070
13071 WSASetLastError(0xdeadbeef);
13072 overlapped.Internal = 0xdeadbeef;
13073 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
13074 ok(ret == -1, "got %d\n", ret);
13075 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
13076 ok(overlapped.Internal == 0xdeadbeef, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
13077
13078 /* Overlapped, with a NULL event. */
13079
13080 overlapped.hEvent = NULL;
13081
13082 memset(buffer, 0, sizeof(buffer));
13083 WSASetLastError(0xdeadbeef);
13084 overlapped.Internal = 0xdeadbeef;
13085 overlapped.InternalHigh = 0xdeadbeef;
13086 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
13087 ok(ret == -1, "got %d\n", ret);
13088 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
13089 ret = WaitForSingleObject((HANDLE)client, 0);
13090 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
13091 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
13092 ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
13093
13094 ret = send(server, "data", 4, 0);
13095 ok(ret == 4, "got %d\n", ret);
13096
13097 ret = WaitForSingleObject((HANDLE)client, 1000);
13098 ok(!ret, "wait timed out\n");
13099 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
13100 ok(ret, "got error %lu\n", GetLastError());
13101 ok(size == 4, "got size %lu\n", size);
13102 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
13103
13104 /* Overlapped, with a non-NULL event. */
13105
13106 overlapped.hEvent = event;
13107
13108 memset(buffer, 0, sizeof(buffer));
13109 WSASetLastError(0xdeadbeef);
13110 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
13111 ok(ret == -1, "got %d\n", ret);
13112 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
13113 ret = WaitForSingleObject(event, 0);
13114 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
13115
13116 ret = send(server, "data", 4, 0);
13117 ok(ret == 4, "got %d\n", ret);
13118
13119 ret = WaitForSingleObject(event, 1000);
13120 ok(!ret, "wait timed out\n");
13121 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
13122 ok(ret, "got error %lu\n", GetLastError());
13123 ok(size == 4, "got size %lu\n", size);
13124 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
13125
13126 /* With data already in the pipe; usually this does return 0 (but not
13127 * reliably). */
13128
13129 ret = send(server, "data", 4, 0);
13130 ok(ret == 4, "got %d\n", ret);
13131
13132 memset(buffer, 0, sizeof(buffer));
13133 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
13134 ok(!ret || WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
13135 ret = WaitForSingleObject(event, 1000);
13136 ok(!ret, "wait timed out\n");
13137 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
13138 ok(ret, "got error %lu\n", GetLastError());
13139 ok(size == 4, "got size %lu\n", size);
13140 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
13141
13142 closesocket(client);
13143 closesocket(server);
13144
13145 /* With a non-overlapped socket, WSARecv() always blocks when passed an
13146 * overlapped structure, but returns WSAEWOULDBLOCK otherwise. */
13147
13148 tcp_socketpair_flags(&client, &server, 0);
13149 set_blocking(client, FALSE);
13150 set_blocking(server, FALSE);
13151
13152 WSASetLastError(0xdeadbeef);
13153 ret = recv(client, buffer, sizeof(buffer), 0);
13154 ok(ret == -1, "got %d\n", ret);
13155 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
13156
13157 WSASetLastError(0xdeadbeef);
13158 overlapped.Internal = 0xdeadbeef;
13159 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
13160 ok(ret == -1, "got %d\n", ret);
13161 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
13162 ok(overlapped.Internal == 0xdeadbeef, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
13163
13164 /* Overlapped, with a NULL event. */
13165
13166 params.client = client;
13167 params.event = NULL;
13168 thread = CreateThread(NULL, 0, nonblocking_async_recv_thread, &params, 0, NULL);
13169
13170 ret = WaitForSingleObject(thread, 200);
13171 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
13172
13173 ret = send(server, "data", 4, 0);
13174 ok(ret == 4, "got %d\n", ret);
13175
13176 ret = WaitForSingleObject(thread, 200);
13177 ok(!ret, "wait timed out\n");
13178 CloseHandle(thread);
13179
13180 /* Overlapped, with a non-NULL event. */
13181
13182 params.client = client;
13183 params.event = event;
13184 thread = CreateThread(NULL, 0, nonblocking_async_recv_thread, &params, 0, NULL);
13185
13186 ret = WaitForSingleObject(thread, 200);
13187 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
13188
13189 ret = send(server, "data", 4, 0);
13190 ok(ret == 4, "got %d\n", ret);
13191
13192 ret = WaitForSingleObject(thread, 200);
13193 ok(!ret, "wait timed out\n");
13194 CloseHandle(thread);
13195
13196 /* With data already in the pipe. */
13197
13198 ret = send(server, "data", 4, 0);
13199 ok(ret == 4, "got %d\n", ret);
13200
13201 memset(buffer, 0, sizeof(buffer));
13202 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
13203 ok(!ret, "got %d\n", ret);
13204 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
13205 ok(ret, "got error %lu\n", GetLastError());
13206 ok(size == 4, "got size %lu\n", size);
13207 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
13208
13209 closesocket(client);
13210 closesocket(server);
13211
13212 CloseHandle(overlapped.hEvent);
13213 }
13214
13215 static void test_simultaneous_async_recv(void)
13216 {
13217 SOCKET client, server;
13218 OVERLAPPED overlappeds[2] = {{0}};
13219 HANDLE events[2];
13220 WSABUF wsabufs[2];
13221 DWORD flags[2] = {0};
13222 size_t num_io = 2, stride = 16, i;
13223 char resbuf[32] = "";
13224 static const char msgstr[32] = "-- Lorem ipsum dolor sit amet -";
13225 int ret;
13226
13227 for (i = 0; i < num_io; i++) events[i] = CreateEventW(NULL, TRUE, FALSE, NULL);
13228
13229 tcp_socketpair(&client, &server);
13230
13231 for (i = 0; i < num_io; i++)
13232 {
13233 wsabufs[i].buf = resbuf + i * stride;
13234 wsabufs[i].len = stride;
13235 overlappeds[i].hEvent = events[i];
13236 ret = WSARecv(client, &wsabufs[i], 1, NULL, &flags[i], &overlappeds[i], NULL);
13237 ok(ret == -1, "got %d\n", ret);
13238 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
13239 }
13240
13241 ret = send(server, msgstr, sizeof(msgstr), 0);
13242 ok(ret == sizeof(msgstr), "got %d\n", ret);
13243
13244 for (i = 0; i < num_io; i++)
13245 {
13246 const void *expect = msgstr + i * stride;
13247 const void *actual = resbuf + i * stride;
13248 DWORD size;
13249
13250 ret = WaitForSingleObject(events[i], 1000);
13251 ok(!ret, "wait timed out\n");
13252
13253 size = 0;
13254 ret = GetOverlappedResult((HANDLE)client, &overlappeds[i], &size, FALSE);
13255 ok(ret, "got error %lu\n", GetLastError());
13256 ok(size == stride, "got size %lu\n", size);
13257 ok(!memcmp(expect, actual, stride), "expected %s, got %s\n", debugstr_an(expect, stride), debugstr_an(actual, stride));
13258 }
13259
13260 closesocket(client);
13261 closesocket(server);
13262
13263 for (i = 0; i < num_io; i++) CloseHandle(events[i]);
13264 }
13265
13266 static void test_empty_recv(void)
13267 {
13268 OVERLAPPED overlapped = {0};
13269 SOCKET client, server;
13270 DWORD size, flags = 0;
13271 char buffer[5];
13272 WSABUF wsabuf;
13273 int ret;
13274
13275 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
13276 tcp_socketpair(&client, &server);
13277
13278 WSASetLastError(0xdeadbeef);
13279 ret = WSARecv(client, NULL, 0, NULL, &flags, &overlapped, NULL);
13280 ok(ret == -1, "expected failure\n");
13281 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
13282
13283 wsabuf.buf = buffer;
13284 wsabuf.len = 0;
13285 WSASetLastError(0xdeadbeef);
13286 ret = WSARecv(client, &wsabuf, 0, NULL, &flags, &overlapped, NULL);
13287 ok(ret == -1, "expected failure\n");
13288 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
13289
13290 WSASetLastError(0xdeadbeef);
13291 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
13292 ok(ret == -1, "expected failure\n");
13293 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
13294
13295 ret = send(server, "data", 5, 0);
13296 ok(ret == 5, "got %d\n", ret);
13297
13298 ret = WaitForSingleObject(overlapped.hEvent, 1000);
13299 ok(!ret, "wait failed\n");
13300 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
13301 ok(ret, "got error %lu\n", GetLastError());
13302 ok(!size, "got size %lu\n", size);
13303
13304 WSASetLastError(0xdeadbeef);
13305 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
13306 ok(!ret, "got error %u\n", WSAGetLastError());
13307 ok(!size, "got size %lu\n", size);
13308
13309 ret = recv(client, NULL, 0, 0);
13310 ok(!ret, "got %d\n", ret);
13311
13312 ret = recv(client, buffer, sizeof(buffer), 0);
13313 ok(ret == 5, "got %d\n", ret);
13314 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, ret));
13315
13316 closesocket(client);
13317 closesocket(server);
13318 CloseHandle(overlapped.hEvent);
13319 }
13320
13321 static void test_timeout(void)
13322 {
13323 DWORD timeout, flags = 0, size;
13324 OVERLAPPED overlapped = {0};
13325 SOCKET client, server;
13326 WSABUF wsabuf;
13327 int ret, len;
13328 char buffer;
13329
13330 tcp_socketpair(&client, &server);
13331 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
13332
13333 timeout = 0xdeadbeef;
13334 len = sizeof(timeout);
13335 WSASetLastError(0xdeadbeef);
13336 ret = getsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, &len);
13337 ok(!ret, "expected success\n");
13338 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13339 ok(len == sizeof(timeout), "got size %u\n", len);
13340 ok(!timeout, "got timeout %lu\n", timeout);
13341
13342 timeout = 100;
13343 WSASetLastError(0xdeadbeef);
13344 ret = setsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
13345 ok(!ret, "expected success\n");
13346 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13347
13348 timeout = 0xdeadbeef;
13349 len = sizeof(timeout);
13350 WSASetLastError(0xdeadbeef);
13351 ret = getsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, &len);
13352 ok(!ret, "expected success\n");
13353 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13354 ok(timeout == 100, "got timeout %lu\n", timeout);
13355
13356 WSASetLastError(0xdeadbeef);
13357 ret = recv(client, &buffer, 1, 0);
13358 ok(ret == -1, "got %d\n", ret);
13359 ok(WSAGetLastError() == WSAETIMEDOUT, "got error %u\n", WSAGetLastError());
13360
13361 wsabuf.buf = &buffer;
13362 wsabuf.len = 1;
13363 WSASetLastError(0xdeadbeef);
13364 size = 0xdeadbeef;
13365 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
13366 ok(ret == -1, "got %d\n", ret);
13367 ok(WSAGetLastError() == WSAETIMEDOUT, "got error %u\n", WSAGetLastError());
13368 ok(size == 0xdeadbeef, "got size %lu\n", size);
13369
13370 wsabuf.buf = &buffer;
13371 wsabuf.len = 1;
13372 WSASetLastError(0xdeadbeef);
13373 size = 0xdeadbeef;
13374 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
13375 ok(ret == -1, "got %d\n", ret);
13376 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
13377
13378 ret = WaitForSingleObject(overlapped.hEvent, 200);
13379 ok(ret == WAIT_TIMEOUT, "got %d\n", ret);
13380
13381 ret = send(server, "a", 1, 0);
13382 ok(ret == 1, "got %d\n", ret);
13383
13384 ret = WaitForSingleObject(overlapped.hEvent, 200);
13385 ok(!ret, "got %d\n", ret);
13386 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
13387 ok(ret, "got error %lu\n", GetLastError());
13388 ok(size == 1, "got size %lu\n", size);
13389
13390 closesocket(client);
13391 closesocket(server);
13392 CloseHandle(overlapped.hEvent);
13393 }
13394
13395 static void test_so_debug(void)
13396 {
13397 int ret, len;
13398 DWORD debug;
13399 SOCKET s;
13400
13401 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
13402
13403 len = sizeof(debug);
13404 WSASetLastError(0xdeadbeef);
13405 debug = 0xdeadbeef;
13406 ret = getsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&debug, &len);
13407 ok(!ret, "got %d\n", ret);
13408 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13409 ok(len == sizeof(debug), "got len %u\n", len);
13410 ok(!debug, "got debug %lu\n", debug);
13411
13412 WSASetLastError(0xdeadbeef);
13413 debug = 2;
13414 ret = setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&debug, sizeof(debug));
13415 ok(!ret, "got %d\n", ret);
13416 todo_wine ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13417
13418 len = sizeof(debug);
13419 WSASetLastError(0xdeadbeef);
13420 debug = 0xdeadbeef;
13421 ret = getsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&debug, &len);
13422 ok(!ret, "got %d\n", ret);
13423 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
13424 ok(len == sizeof(debug), "got len %u\n", len);
13425 todo_wine ok(debug == 1, "got debug %lu\n", debug);
13426
13427 closesocket(s);
13428 }
13429
13430 struct sockopt_validity_test
13431 {
13432 int opt;
13433 int get_error;
13434 int set_error;
13435 BOOL todo;
13436 };
13437
13438 static void do_sockopt_validity_tests(const char *type, SOCKET sock, int level,
13439 const struct sockopt_validity_test *tests)
13440 {
13441 char value[256];
13442 int count, rc, expected_rc, i;
13443
13444 for (i = 0; tests[i].opt; i++)
13445 {
13446 winetest_push_context("%s option %i", type, tests[i].opt);
13447 memset(value, 0, sizeof(value));
13448 count = sizeof(value);
13449
13450 WSASetLastError(0);
13451 rc = getsockopt(sock, level, tests[i].opt, value, &count);
13452 expected_rc = tests[i].get_error ? SOCKET_ERROR : 0;
13453 todo_wine_if(!tests[i].get_error && tests[i].todo)
13454 ok(rc == expected_rc || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
13455 "expected getsockopt to return %i, got %i\n", expected_rc, rc);
13456 todo_wine_if(tests[i].todo)
13457 ok(WSAGetLastError() == tests[i].get_error || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
13458 "expected getsockopt to set error %i, got %i\n", tests[i].get_error, WSAGetLastError());
13459
13460 if (tests[i].get_error)
13461 {
13462 winetest_pop_context();
13463 continue;
13464 }
13465
13466 WSASetLastError(0);
13467 rc = setsockopt(sock, level, tests[i].opt, value, count);
13468 expected_rc = tests[i].set_error ? SOCKET_ERROR : 0;
13469 todo_wine_if(!tests[i].set_error && tests[i].todo)
13470 ok(rc == expected_rc || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
13471 "expected setsockopt to return %i, got %i\n", expected_rc, rc);
13472 todo_wine_if(tests[i].todo)
13473 ok(WSAGetLastError() == tests[i].set_error || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
13474 "expected setsockopt to set error %i, got %i\n", tests[i].set_error, WSAGetLastError());
13475
13476 winetest_pop_context();
13477 }
13478 }
13479
13480 static void test_sockopt_validity(void)
13481 {
13482 static const struct sockopt_validity_test ipv4_tcp_tests[] =
13483 {
13484 { -1, WSAENOPROTOOPT },
13485 { IP_OPTIONS },
13486 { IP_HDRINCL, WSAEINVAL },
13487 { IP_TOS },
13488 { IP_TTL },
13489 { IP_MULTICAST_IF, WSAEINVAL },
13490 { IP_MULTICAST_TTL, WSAEINVAL },
13491 { IP_MULTICAST_LOOP, WSAEINVAL },
13492 { IP_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13493 { IP_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13494 { IP_DONTFRAGMENT },
13495 { IP_PKTINFO, WSAEINVAL },
13496 { IP_RECVTTL, WSAEINVAL },
13497 { IP_RECEIVE_BROADCAST, WSAEINVAL, 0, TRUE },
13498 { IP_RECVIF, WSAEINVAL, 0, TRUE },
13499 { IP_RECVDSTADDR, WSAEINVAL, 0, TRUE },
13500 { IP_IFLIST, 0, 0, TRUE },
13501 { IP_UNICAST_IF },
13502 { IP_RTHDR, 0, 0, TRUE },
13503 { IP_GET_IFLIST, WSAEINVAL, 0, TRUE },
13504 { IP_RECVRTHDR, WSAEINVAL, 0, TRUE },
13505 { IP_RECVTOS, WSAEINVAL },
13506 { IP_ORIGINAL_ARRIVAL_IF, WSAEINVAL, 0, TRUE },
13507 { IP_ECN, WSAEINVAL, 0, TRUE },
13508 { IP_PKTINFO_EX, WSAEINVAL, 0, TRUE },
13509 { IP_WFP_REDIRECT_RECORDS, WSAEINVAL, 0, TRUE },
13510 { IP_WFP_REDIRECT_CONTEXT, WSAEINVAL, 0, TRUE },
13511 { IP_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13512 { IP_MTU, WSAENOTCONN, 0, TRUE },
13513 { IP_RECVERR, WSAEINVAL, 0, TRUE },
13514 { IP_USER_MTU, 0, 0, TRUE },
13515 {}
13516 };
13517 static const struct sockopt_validity_test ipv4_udp_tests[] =
13518 {
13519 { -1, WSAENOPROTOOPT },
13520 { IP_OPTIONS },
13521 { IP_HDRINCL, WSAEINVAL },
13522 { IP_TOS },
13523 { IP_TTL },
13524 { IP_MULTICAST_IF },
13525 { IP_MULTICAST_TTL },
13526 { IP_MULTICAST_LOOP },
13527 { IP_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13528 { IP_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13529 { IP_DONTFRAGMENT },
13530 { IP_PKTINFO },
13531 { IP_RECVTTL },
13532 { IP_RECEIVE_BROADCAST, 0, 0, TRUE },
13533 { IP_RECVIF, 0, 0, TRUE },
13534 { IP_RECVDSTADDR, 0, 0, TRUE },
13535 { IP_IFLIST, 0, 0, TRUE },
13536 { IP_UNICAST_IF },
13537 { IP_RTHDR, 0, 0, TRUE },
13538 { IP_GET_IFLIST, WSAEINVAL, 0, TRUE },
13539 { IP_RECVRTHDR, 0, 0, TRUE },
13540 { IP_RECVTOS },
13541 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
13542 { IP_ECN, 0, 0, TRUE },
13543 { IP_PKTINFO_EX, 0, 0, TRUE },
13544 { IP_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
13545 { IP_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
13546 { IP_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13547 { IP_MTU, WSAENOTCONN, 0, TRUE },
13548 { IP_RECVERR, 0, 0, TRUE },
13549 { IP_USER_MTU, 0, 0, TRUE },
13550 {}
13551 };
13552 static const struct sockopt_validity_test ipv4_raw_tests[] =
13553 {
13554 { -1, WSAENOPROTOOPT },
13555 { IP_OPTIONS },
13556 { IP_HDRINCL, },
13557 { IP_TOS },
13558 { IP_TTL },
13559 { IP_MULTICAST_IF },
13560 { IP_MULTICAST_TTL },
13561 { IP_MULTICAST_LOOP },
13562 { IP_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13563 { IP_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13564 { IP_DONTFRAGMENT },
13565 { IP_PKTINFO },
13566 { IP_RECVTTL },
13567 { IP_RECEIVE_BROADCAST, 0, 0, TRUE },
13568 { IP_RECVIF, 0, 0, TRUE },
13569 { IP_RECVDSTADDR, 0, 0, TRUE },
13570 { IP_IFLIST, 0, 0, TRUE },
13571 { IP_UNICAST_IF },
13572 { IP_RTHDR, 0, 0, TRUE },
13573 { IP_GET_IFLIST, WSAEINVAL, 0, TRUE },
13574 { IP_RECVRTHDR, 0, 0, TRUE },
13575 { IP_RECVTOS },
13576 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
13577 { IP_ECN, 0, 0, TRUE },
13578 { IP_PKTINFO_EX, 0, 0, TRUE },
13579 { IP_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
13580 { IP_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
13581 { IP_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13582 { IP_MTU, WSAENOTCONN, 0, TRUE },
13583 { IP_RECVERR, WSAEINVAL, 0, TRUE },
13584 { IP_USER_MTU, 0, 0, TRUE },
13585 {}
13586 };
13587 static const struct sockopt_validity_test ipv6_tcp_tests[] =
13588 {
13589 { -1, WSAENOPROTOOPT },
13590 { IPV6_HOPOPTS, 0, 0, TRUE },
13591 { IPV6_HDRINCL, WSAEINVAL, 0, TRUE },
13592 { IPV6_UNICAST_HOPS },
13593 { IPV6_MULTICAST_IF, WSAEINVAL },
13594 { IPV6_MULTICAST_HOPS, WSAEINVAL },
13595 { IPV6_MULTICAST_LOOP, WSAEINVAL },
13596 { IPV6_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13597 { IPV6_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13598 { IPV6_DONTFRAG },
13599 { IPV6_PKTINFO, WSAEINVAL },
13600 { IPV6_HOPLIMIT, WSAEINVAL },
13601 { IPV6_PROTECTION_LEVEL },
13602 { IPV6_RECVIF, WSAEINVAL, 0, TRUE },
13603 { IPV6_RECVDSTADDR, WSAEINVAL, 0, TRUE },
13604 { IPV6_V6ONLY },
13605 { IPV6_IFLIST, 0, 0, TRUE },
13606 { IPV6_UNICAST_IF },
13607 { IPV6_RTHDR, 0, 0, TRUE },
13608 { IPV6_GET_IFLIST, WSAEINVAL, 0, TRUE },
13609 { IPV6_RECVRTHDR, WSAEINVAL, 0, TRUE },
13610 { IPV6_RECVTCLASS, WSAEINVAL },
13611 { IP_ORIGINAL_ARRIVAL_IF, WSAEINVAL, 0, TRUE },
13612 { IPV6_ECN, WSAEINVAL, 0, TRUE },
13613 { IPV6_PKTINFO_EX, WSAEINVAL, 0, TRUE },
13614 { IPV6_WFP_REDIRECT_RECORDS, WSAEINVAL, 0, TRUE },
13615 { IPV6_WFP_REDIRECT_CONTEXT, WSAEINVAL, 0, TRUE },
13616 { IPV6_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13617 { IPV6_MTU, WSAENOTCONN, 0, TRUE },
13618 { IPV6_RECVERR, WSAEINVAL, 0, TRUE },
13619 { IPV6_USER_MTU, 0, 0, TRUE },
13620 {}
13621 };
13622 static const struct sockopt_validity_test ipv6_udp_tests[] =
13623 {
13624 { -1, WSAENOPROTOOPT },
13625 { IPV6_HOPOPTS, 0, 0, TRUE },
13626 { IPV6_HDRINCL, WSAEINVAL, 0, TRUE },
13627 { IPV6_UNICAST_HOPS },
13628 { IPV6_MULTICAST_IF },
13629 { IPV6_MULTICAST_HOPS },
13630 { IPV6_MULTICAST_LOOP },
13631 { IPV6_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13632 { IPV6_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13633 { IPV6_DONTFRAG },
13634 { IPV6_PKTINFO },
13635 { IPV6_HOPLIMIT },
13636 { IPV6_PROTECTION_LEVEL },
13637 { IPV6_RECVIF, 0, 0, TRUE },
13638 { IPV6_RECVDSTADDR, 0, 0, TRUE },
13639 { IPV6_V6ONLY },
13640 { IPV6_IFLIST, 0, 0, TRUE },
13641 { IPV6_UNICAST_IF },
13642 { IPV6_RTHDR, 0, 0, TRUE },
13643 { IPV6_GET_IFLIST, WSAEINVAL, 0, TRUE },
13644 { IPV6_RECVRTHDR, 0, 0, TRUE },
13645 { IPV6_RECVTCLASS },
13646 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
13647 { IPV6_ECN, 0, 0, TRUE },
13648 { IPV6_PKTINFO_EX, 0, 0, TRUE },
13649 { IPV6_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
13650 { IPV6_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
13651 { IPV6_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13652 { IPV6_MTU, WSAENOTCONN, 0, TRUE },
13653 { IPV6_RECVERR, 0, 0, TRUE },
13654 { IPV6_USER_MTU, 0, 0, TRUE },
13655 {}
13656 };
13657 static const struct sockopt_validity_test ipv6_raw_tests[] =
13658 {
13659 { -1, WSAENOPROTOOPT },
13660 { IPV6_HOPOPTS, 0, 0, TRUE },
13661 { IPV6_HDRINCL, 0, 0, TRUE },
13662 { IPV6_UNICAST_HOPS },
13663 { IPV6_MULTICAST_IF },
13664 { IPV6_MULTICAST_HOPS },
13665 { IPV6_MULTICAST_LOOP },
13666 { IPV6_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13667 { IPV6_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13668 { IPV6_DONTFRAG },
13669 { IPV6_PKTINFO },
13670 { IPV6_HOPLIMIT },
13671 { IPV6_PROTECTION_LEVEL },
13672 { IPV6_RECVIF, 0, 0, TRUE },
13673 { IPV6_RECVDSTADDR, 0, 0, TRUE },
13674 { IPV6_V6ONLY },
13675 { IPV6_IFLIST, 0, 0, TRUE },
13676 { IPV6_UNICAST_IF },
13677 { IPV6_RTHDR, 0, 0, TRUE },
13678 { IPV6_GET_IFLIST, WSAEINVAL, 0, TRUE },
13679 { IPV6_RECVRTHDR, 0, 0, TRUE },
13680 { IPV6_RECVTCLASS },
13681 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
13682 { IPV6_ECN, 0, 0, TRUE },
13683 { IPV6_PKTINFO_EX, 0, 0, TRUE },
13684 { IPV6_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
13685 { IPV6_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
13686 { IPV6_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13687 { IPV6_MTU, WSAENOTCONN, 0, TRUE },
13688 { IPV6_RECVERR, WSAEINVAL, 0, TRUE },
13689 { IPV6_USER_MTU, 0, 0, TRUE },
13690 {}
13691 };
13692 static const struct sockopt_validity_test file_handle_tests[] =
13693 {
13694 { -1, WSAENOTSOCK },
13695 { SO_TYPE, WSAENOTSOCK },
13696 { SO_OPENTYPE },
13697 {}
13698 };
13699 char path[MAX_PATH];
13700 HANDLE file;
13701 SOCKET sock;
13702
13703 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
13704 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13705 do_sockopt_validity_tests("IPv4 TCP", sock, IPPROTO_IP, ipv4_tcp_tests);
13706 closesocket(sock);
13707
13708 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
13709 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13710 do_sockopt_validity_tests("IPv4 UDP", sock, IPPROTO_IP, ipv4_udp_tests);
13711 closesocket(sock);
13712
13713 sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
13714 if (sock == INVALID_SOCKET && WSAGetLastError() == WSAEACCES)
13715 {
13716 skip("Raw IPv4 sockets are not available\n");
13717 }
13718 else
13719 {
13720 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13721 do_sockopt_validity_tests("IPv4 raw", sock, IPPROTO_IP, ipv4_raw_tests);
13722 closesocket(sock);
13723 }
13724
13725 sock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
13726 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13727 do_sockopt_validity_tests("IPv6 TCP", sock, IPPROTO_IPV6, ipv6_tcp_tests);
13728 closesocket(sock);
13729
13730 sock = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
13731 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13732 do_sockopt_validity_tests("IPv6 UDP", sock, IPPROTO_IPV6, ipv6_udp_tests);
13733 closesocket(sock);
13734
13735 sock = socket(AF_INET6, SOCK_RAW, IPPROTO_RAW);
13736 if (sock == INVALID_SOCKET && WSAGetLastError() == WSAEACCES)
13737 {
13738 skip("Raw IPv6 sockets are not available\n");
13739 }
13740 else
13741 {
13742 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13743 do_sockopt_validity_tests("IPv6 raw", sock, IPPROTO_IPV6, ipv6_raw_tests);
13744 closesocket(sock);
13745 }
13746
13747 GetSystemWindowsDirectoryA(path, ARRAY_SIZE(path));
13748 strcat(path, "\\system.ini");
13749 file = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0x0, NULL);
13750 do_sockopt_validity_tests("file", (SOCKET)file, SOL_SOCKET, file_handle_tests);
13751 CloseHandle(file);
13752 }
13753
13754 static void test_tcp_reset(void)
13755 {
13756 static const struct timeval select_timeout;
13757 fd_set readfds, writefds, exceptfds;
13758 OVERLAPPED overlapped = {0};
13759 SOCKET client, server;
13760 DWORD size, flags = 0;
13761 int ret, len, error;
13762 char buffer[10];
13763 WSABUF wsabuf;
13764
13765 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
13766
13767 tcp_socketpair(&client, &server);
13768
13769 wsabuf.buf = buffer;
13770 wsabuf.len = sizeof(buffer);
13771 WSASetLastError(0xdeadbeef);
13772 size = 0xdeadbeef;
13773 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
13774 ok(ret == -1, "got %d\n", ret);
13775 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
13776
13777 close_with_rst(server);
13778
13779 ret = WaitForSingleObject(overlapped.hEvent, 1000);
13780 ok(!ret, "wait failed\n");
13781 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
13782 ok(!ret, "expected failure\n");
13783 ok(GetLastError() == ERROR_NETNAME_DELETED, "got error %lu\n", GetLastError());
13784 ok(!size, "got size %lu\n", size);
13785 ok((NTSTATUS)overlapped.Internal == STATUS_CONNECTION_RESET, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
13786
13787 len = sizeof(error);
13788 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&error, &len);
13789 ok(!ret, "got error %u\n", WSAGetLastError());
13790 ok(!error, "got error %u\n", error);
13791
13792 wsabuf.buf = buffer;
13793 wsabuf.len = sizeof(buffer);
13794 WSASetLastError(0xdeadbeef);
13795 size = 0xdeadbeef;
13796 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
13797 ok(ret == -1, "got %d\n", ret);
13798 ok(WSAGetLastError() == WSAECONNRESET, "got error %u\n", WSAGetLastError());
13799
13800 WSASetLastError(0xdeadbeef);
13801 ret = send(client, "data", 5, 0);
13802 ok(ret == -1, "got %d\n", ret);
13803 ok(WSAGetLastError() == WSAECONNRESET, "got error %u\n", WSAGetLastError());
13804
13805 check_poll(client, POLLERR | POLLHUP | POLLWRNORM);
13806
13807 FD_ZERO(&readfds);
13808 FD_ZERO(&writefds);
13809 FD_ZERO(&exceptfds);
13810 FD_SET(client, &readfds);
13811 FD_SET(client, &writefds);
13812 FD_SET(client, &exceptfds);
13813 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
13814 ok(ret == 2, "got %d\n", ret);
13815 ok(FD_ISSET(client, &readfds), "FD should be set\n");
13816 ok(FD_ISSET(client, &writefds), "FD should be set\n");
13817 ok(!FD_ISSET(client, &exceptfds), "FD should be set\n");
13818
13819 FD_ZERO(&exceptfds);
13820 FD_SET(client, &exceptfds);
13821 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
13822 ok(!ret, "got %d\n", ret);
13823 ok(!FD_ISSET(client, &exceptfds), "FD should be set\n");
13824
13825 closesocket(server);
13826 CloseHandle(overlapped.hEvent);
13827 }
13828
13829 struct icmp_hdr
13830 {
13831 BYTE type;
13832 BYTE code;
13833 UINT16 checksum;
13834 union
13835 {
13836 struct
13837 {
13838 UINT16 id;
13839 UINT16 sequence;
13840 } echo;
13841 } un;
13842 };
13843
13844 struct ip_hdr
13845 {
13846 BYTE v_hl; /* version << 4 | hdr_len */
13847 BYTE tos;
13848 UINT16 tot_len;
13849 UINT16 id;
13850 UINT16 frag_off;
13851 BYTE ttl;
13852 BYTE protocol;
13853 UINT16 checksum;
13854 ULONG saddr;
13855 ULONG daddr;
13856 };
13857
13858 /* rfc 1071 checksum */
13859 static unsigned short chksum(BYTE *data, unsigned int count)
13860 {
13861 unsigned int sum = 0, carry = 0;
13862 unsigned short check, s;
13863
13864 while (count > 1)
13865 {
13866 s = *(unsigned short *)data;
13867 data += 2;
13868 sum += carry;
13869 sum += s;
13870 carry = s > sum;
13871 count -= 2;
13872 }
13873 sum += carry; /* This won't produce another carry */
13874 sum = (sum & 0xffff) + (sum >> 16);
13875
13876 if (count) sum += *data; /* LE-only */
13877
13878 sum = (sum & 0xffff) + (sum >> 16);
13879 /* fold in any carry */
13880 sum = (sum & 0xffff) + (sum >> 16);
13881
13882 check = ~sum;
13883 return check;
13884 }
13885
13886 static void test_icmp(void)
13887 {
13888 static const unsigned int ping_data = 0xdeadbeef;
13889 struct icmp_hdr *icmp_h;
13890 BYTE send_buf[sizeof(struct icmp_hdr) + sizeof(ping_data)];
13891 UINT16 recv_checksum, checksum;
13892 unsigned int reply_data;
13893 struct sockaddr_in sa;
13894 struct ip_hdr *ip_h;
13895 struct in_addr addr;
13896 BYTE recv_buf[256];
13897 SOCKET s;
13898 int ret;
13899
13900 s = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
13901 if (s == INVALID_SOCKET)
13902 {
13903 ret = WSAGetLastError();
13904 ok(ret == WSAEACCES, "Expected 10013, received %d\n", ret);
13905 skip("SOCK_RAW is not supported\n");
13906 return;
13907 }
13908
13909 icmp_h = (struct icmp_hdr *)send_buf;
13910 icmp_h->type = ICMP4_ECHO_REQUEST;
13911 icmp_h->code = 0;
13912 icmp_h->checksum = 0;
13913 icmp_h->un.echo.id = 0xbeaf; /* will be overwritten for linux ping socks */
13914 icmp_h->un.echo.sequence = 1;
13915 *(unsigned int *)(icmp_h + 1) = ping_data;
13916 icmp_h->checksum = chksum(send_buf, sizeof(send_buf));
13917
13918 memset(&sa, 0, sizeof(sa));
13919 sa.sin_family = AF_INET;
13920 sa.sin_port = 0;
13921 sa.sin_addr.s_addr = inet_addr("127.0.0.1");
13922
13923 ret = sendto(s, (char *)send_buf, sizeof(send_buf), 0, (struct sockaddr*)&sa, sizeof(sa));
13924 ok(ret == sizeof(send_buf), "got %d, error %d.\n", ret, WSAGetLastError());
13925
13926 ret = recv(s, (char *)recv_buf, sizeof(struct ip_hdr) + sizeof(send_buf) - 1, 0);
13927 ok(ret == -1, "got %d\n", ret);
13928 ok(WSAGetLastError() == WSAEMSGSIZE, "got %d\n", WSAGetLastError());
13929
13930 icmp_h->un.echo.sequence = 2;
13931 icmp_h->checksum = 0;
13932 icmp_h->checksum = chksum(send_buf, sizeof(send_buf));
13933
13934 ret = sendto(s, (char *)send_buf, sizeof(send_buf), 0, (struct sockaddr*)&sa, sizeof(sa));
13935 ok(ret != SOCKET_ERROR, "got error %d.\n", WSAGetLastError());
13936
13937 memset(recv_buf, 0xcc, sizeof(recv_buf));
13938 ret = recv(s, (char *)recv_buf, sizeof(recv_buf), 0);
13939 ok(ret == sizeof(struct ip_hdr) + sizeof(send_buf), "got %d\n", ret);
13940
13941 ip_h = (struct ip_hdr *)recv_buf;
13942 icmp_h = (struct icmp_hdr *)(ip_h + 1);
13943 reply_data = *(unsigned int *)(icmp_h + 1);
13944
13945 ok(ip_h->v_hl == ((4 << 4) | (sizeof(*ip_h) >> 2)), "got v_hl %#x.\n", ip_h->v_hl);
13946 ok(ntohs(ip_h->tot_len) == sizeof(struct ip_hdr) + sizeof(send_buf),
13947 "got tot_len %#x.\n", ntohs(ip_h->tot_len));
13948
13949 recv_checksum = ip_h->checksum;
13950 ip_h->checksum = 0;
13951 checksum = chksum((BYTE *)ip_h, sizeof(*ip_h));
13952 /* Checksum is 0 for localhost ping on Windows but not for remote host ping. */
13953 ok(recv_checksum == checksum || !recv_checksum, "got checksum %#x, expected %#x.\n", recv_checksum, checksum);
13954
13955 ok(!ip_h->frag_off, "got id %#x.\n", ip_h->frag_off);
13956 addr.s_addr = ip_h->saddr;
13957 ok(ip_h->saddr == sa.sin_addr.s_addr, "got saddr %s.\n", inet_ntoa(addr));
13958 addr.s_addr = ip_h->daddr;
13959 ok(!!ip_h->daddr, "got daddr %s.\n", inet_ntoa(addr));
13960
13961 ok(ip_h->protocol == 1, "got protocol %#x.\n", ip_h->protocol);
13962
13963 ok(icmp_h->type == ICMP4_ECHO_REPLY, "got type %#x.\n", icmp_h->type);
13964 ok(!icmp_h->code, "got code %#x.\n", icmp_h->code);
13965 ok(icmp_h->un.echo.id == 0xbeaf, "got echo id %#x.\n", icmp_h->un.echo.id);
13966 ok(icmp_h->un.echo.sequence == 2, "got echo sequence %#x.\n", icmp_h->un.echo.sequence);
13967
13968 recv_checksum = icmp_h->checksum;
13969 icmp_h->checksum = 0;
13970 checksum = chksum((BYTE *)icmp_h, sizeof(send_buf));
13971 ok(recv_checksum == checksum, "got checksum %#x, expected %#x.\n", recv_checksum, checksum);
13972
13973 ok(reply_data == ping_data, "got reply_data %#x.\n", reply_data);
13974
13975 closesocket(s);
13976 }
13977
13978 static void test_connect_time(void)
13979 {
13980 struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
13981 SOCKET client, server;
13982 unsigned int time;
13983 int ret, len;
13984
13985 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
13986
13987 len = sizeof(time);
13988 SetLastError(0xdeadbeef);
13989 ret = getsockopt(client, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
13990 ok(!ret, "got %d\n", ret);
13991 ok(!GetLastError(), "got error %lu\n", GetLastError());
13992 ok(len == sizeof(time), "got len %d\n", len);
13993 ok(time == ~0u, "got time %u\n", time);
13994
13995 closesocket(client);
13996
13997 tcp_socketpair(&client, &server);
13998
13999 len = sizeof(time);
14000 SetLastError(0xdeadbeef);
14001 ret = getsockopt(client, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
14002 ok(!ret, "got %d\n", ret);
14003 ok(!GetLastError(), "got error %lu\n", GetLastError());
14004 ok(len == sizeof(time), "got len %d\n", len);
14005 ok(time == 0, "got time %u\n", time);
14006
14007 len = sizeof(time);
14008 SetLastError(0xdeadbeef);
14009 ret = getsockopt(server, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
14010 ok(!ret, "got %d\n", ret);
14011 ok(!GetLastError(), "got error %lu\n", GetLastError());
14012 ok(len == sizeof(time), "got len %d\n", len);
14013 ok(time == 0, "got time %u\n", time);
14014
14015 closesocket(client);
14016 closesocket(server);
14017
14018 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
14019 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
14020
14021 ret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
14022 ok(!ret, "got error %lu\n", GetLastError());
14023 len = sizeof(addr);
14024 ret = getsockname(server, (struct sockaddr *)&addr, &len);
14025 ok(!ret, "got error %lu\n", GetLastError());
14026 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
14027 ok(!ret, "got error %lu\n", GetLastError());
14028
14029 len = sizeof(time);
14030 SetLastError(0xdeadbeef);
14031 ret = getsockopt(client, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
14032 ok(!ret, "got %d\n", ret);
14033 ok(!GetLastError(), "got error %lu\n", GetLastError());
14034 ok(len == sizeof(time), "got len %d\n", len);
14035 ok(time == ~0u, "got time %u\n", time);
14036
14037 len = sizeof(time);
14038 SetLastError(0xdeadbeef);
14039 ret = getsockopt(server, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
14040 ok(!ret, "got %d\n", ret);
14041 ok(!GetLastError(), "got error %lu\n", GetLastError());
14042 ok(len == sizeof(time), "got len %d\n", len);
14043 ok(time == ~0u, "got time %u\n", time);
14044
14045 closesocket(server);
14046 closesocket(client);
14047 }
14048
14049 static void test_connect_udp(void)
14050 {
14051 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
14052 struct sockaddr_in addr, ret_addr;
14053 SOCKET client, server;
14054 char buffer[5];
14055 int ret, len;
14056
14057 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
14058 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
14059 set_blocking(client, FALSE);
14060 set_blocking(server, FALSE);
14061
14062 SetLastError(0xdeadbeef);
14063 ret = send(client, "data", 4, 0);
14064 ok(ret == -1, "got %d\n", ret);
14065 ok(GetLastError() == WSAENOTCONN, "got error %lu\n", GetLastError());
14066
14067 SetLastError(0xdeadbeef);
14068 ret = recv(server, buffer, sizeof(buffer), 0);
14069 ok(ret == -1, "got %d\n", ret);
14070 todo_wine ok(GetLastError() == WSAEINVAL, "got error %lu\n", GetLastError());
14071
14072 ret = bind(server, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
14073 ok(!ret, "got error %lu\n", GetLastError());
14074 len = sizeof(addr);
14075 ret = getsockname(server, (struct sockaddr *)&addr, &len);
14076 ok(!ret, "got error %lu\n", GetLastError());
14077
14078 SetLastError(0xdeadbeef);
14079 ret = recv(server, buffer, sizeof(buffer), 0);
14080 ok(ret == -1, "got %d\n", ret);
14081 ok(GetLastError() == WSAEWOULDBLOCK, "got error %lu\n", GetLastError());
14082
14083 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
14084 ok(!ret, "got error %lu\n", GetLastError());
14085 ret = getpeername(client, (struct sockaddr *)&ret_addr, &len);
14086 ok(!ret, "got error %lu\n", GetLastError());
14087 ok(!memcmp(&ret_addr, &addr, sizeof(addr)), "addresses didn't match\n");
14088
14089 ret = getsockname(client, (struct sockaddr *)&ret_addr, &len);
14090 ok(!ret, "got error %lu\n", GetLastError());
14091
14092 SetLastError(0xdeadbeef);
14093 ret = getpeername(server, (struct sockaddr *)&ret_addr, &len);
14094 ok(ret == -1, "got %d\n", ret);
14095 ok(GetLastError() == WSAENOTCONN, "got error %lu\n", GetLastError());
14096
14097 ret = send(client, "data", 4, 0);
14098 ok(ret == 4, "got %d\n", ret);
14099
14100 memset(buffer, 0xcc, sizeof(buffer));
14101 ret = recv(server, buffer, sizeof(buffer), 0);
14102 ok(ret == 4, "got %d\n", ret);
14103 ok(!memcmp(buffer, "data", 4), "got %s\n", debugstr_an(buffer, ret));
14104
14105 SetLastError(0xdeadbeef);
14106 ret = recv(server, buffer, sizeof(buffer), 0);
14107 ok(ret == -1, "got %d\n", ret);
14108 ok(GetLastError() == WSAEWOULDBLOCK, "got error %lu\n", GetLastError());
14109
14110 SetLastError(0xdeadbeef);
14111 ret = send(server, "data", 4, 0);
14112 ok(ret == -1, "got %d\n", ret);
14113 ok(GetLastError() == WSAENOTCONN, "got error %lu\n", GetLastError());
14114
14115 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
14116 ok(!ret, "got error %lu\n", GetLastError());
14117 ++addr.sin_port;
14118 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
14119 ok(!ret, "got error %lu\n", GetLastError());
14120
14121 memset(&addr, 0, sizeof(addr));
14122 addr.sin_family = AF_UNSPEC;
14123 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
14124 ok(!ret, "got error %lu\n", GetLastError());
14125
14126 ret = getpeername(client, (struct sockaddr *)&ret_addr, &len);
14127 ok(ret == -1, "got %d\n", ret);
14128 ok(GetLastError() == WSAENOTCONN, "got error %lu\n", GetLastError());
14129
14130 closesocket(server);
14131 closesocket(client);
14132 }
14133
14134 static void test_tcp_sendto_recvfrom(void)
14135 {
14136 SOCKET client, server = 0;
14137 SOCKADDR_IN addr = { AF_INET, SERVERPORT };
14138 SOCKADDR_IN bad_addr, bad_addr_copy;
14139 const char serverMsg[] = "ws2_32/TCP socket test";
14140 char clientBuf[sizeof(serverMsg)] = { 0 };
14141 int to_len = 0xc0ffee11;
14142 int ret;
14143
14144 inet_pton(AF_INET, SERVERIP, &addr.sin_addr);
14145
14146 tcp_socketpair(&client, &server);
14147
14148 memset(&bad_addr, 0xfe, sizeof(bad_addr));
14149 memcpy(&bad_addr_copy, &bad_addr, sizeof(bad_addr_copy));
14150
14151 ret = sendto(server, serverMsg, sizeof(serverMsg), 0, (SOCKADDR *)&bad_addr, sizeof(bad_addr));
14152 ok(ret == sizeof(serverMsg), "Incorrect return value from sendto: %d (%d)\n", ret, WSAGetLastError());
14153 ok(!memcmp(&bad_addr, &bad_addr_copy, sizeof(bad_addr)), "Provided address modified by sendto\n");
14154 ok(to_len == 0xc0ffee11, "Provided size modified by sendto\n");
14155
14156 ret = recvfrom(client, clientBuf, sizeof(clientBuf), 0, (SOCKADDR *)&bad_addr, &to_len);
14157 ok(ret == sizeof(serverMsg), "Incorrect return value from recvfrom: %d (%d)\n", ret, WSAGetLastError());
14158 ok(!memcmp(&bad_addr, &bad_addr_copy, sizeof(bad_addr)), "Provided address modified by recvfrom\n");
14159 ok(to_len == 0xc0ffee11, "Provided size modified by recvfrom\n");
14160
14161 ok(!memcmp(serverMsg, clientBuf, sizeof(serverMsg)), "Data mismatch over TCP socket\n");
14162
14163 closesocket(client);
14164 closesocket(server);
14165 }
14166
14167 /* Regression test for an internal bug affecting wget.exe. */
14168 static void test_select_after_WSAEventSelect(void)
14169 {
14170 SOCKET client, server;
14171 HANDLE event;
14172 int ret;
14173
14174 tcp_socketpair(&client, &server);
14175 event = CreateEventA(NULL, FALSE, FALSE, NULL);
14176
14177 ret = WSAEventSelect(client, event, FD_READ);
14178 ok(!ret, "got error %u\n", WSAGetLastError());
14179
14180 ret = send(server, "data", 4, 0);
14181 ok(ret == 4, "got %d\n", ret);
14182
14183 ret = WaitForSingleObject(event, 1000);
14184 ok(!ret, "got %d\n", ret);
14185
14186 /* Poll. This must not trigger any events to be signalled again. */
14187 check_poll(client, POLLRDNORM | POLLWRNORM);
14188
14189 ret = WaitForSingleObject(event, 0);
14190 ok(ret == WAIT_TIMEOUT, "got %d\n", ret);
14191
14192 CloseHandle(event);
14193 closesocket(server);
14194 closesocket(client);
14195 }
14196
14197 START_TEST( sock )
14198 {
14199 int i;
14200
14201 /* Leave these tests at the beginning. They depend on WSAStartup not having been
14202 * called, which is done by Init() below. */
14203 test_WithoutWSAStartup();
14204 test_WithWSAStartup();
14205
14206 Init();
14207
14208 test_set_getsockopt();
14209 test_reuseaddr();
14210 test_ip_pktinfo();
14211 test_ipv4_cmsg();
14212 test_ipv6_cmsg();
14213 test_extendedSocketOptions();
14214 test_so_debug();
14215 test_sockopt_validity();
14216 test_connect_time();
14217
14218 for (i = 0; i < ARRAY_SIZE(tests); i++)
14219 do_test(&tests[i]);
14220
14221 test_UDP();
14222
14223 test_WSASocket();
14224 test_WSADuplicateSocket();
14225 test_WSAConnectByName();
14226 test_WSAEnumNetworkEvents();
14227
14228 test_errors();
14229 test_listen();
14230 test_select();
14231 test_accept();
14232 test_accept_inheritance();
14233 test_getpeername();
14234 test_getsockname();
14235
14236 test_address_list_query();
14237 test_fionbio();
14238 test_fionread_siocatmark();
14239 test_get_extension_func();
14240 test_backlog_query();
14241 test_get_interface_list();
14242 test_keepalive_vals();
14243 test_sioRoutingInterfaceQuery();
14244 test_sioAddressListChange();
14245 test_base_handle();
14246 test_circular_queueing();
14247 test_unsupported_ioctls();
14248
14249 test_WSASendMsg();
14250 test_WSASendTo();
14251 test_WSARecv();
14252 test_WSAPoll();
14253 test_write_watch();
14254
14255 test_events();
14256 test_select_after_WSAEventSelect();
14257
14258 test_ipv6only();
14259 test_TransmitFile();
14260 test_AcceptEx();
14261 test_connect();
14262 test_shutdown();
14263 test_DisconnectEx();
14264
14265 test_completion_port();
14266 test_connect_completion_port();
14267 test_shutdown_completion_port();
14268 test_bind();
14269 test_connecting_socket();
14270 test_WSAGetOverlappedResult();
14271 test_nonblocking_async_recv();
14272 test_simultaneous_async_recv();
14273 test_empty_recv();
14274 test_timeout();
14275 test_tcp_reset();
14276 test_icmp();
14277 test_connect_udp();
14278 test_tcp_sendto_recvfrom();
14279
14280 /* There is apparently an obscure interaction between this test and
14281 * test_WSAGetOverlappedResult().
14282 *
14283 * One thing this test does is to close socket handles through CloseHandle()
14284 * and NtClose(), to prove that that is sufficient to cancel I/O on the
14285 * socket. This has the obscure side effect that ws2_32.dll's internal
14286 * per-process list of sockets never has that socket removed.
14287 *
14288 * test_WSAGetOverlappedResult() effectively proves that the per-process
14289 * list of sockets exists, by calling DuplicateHandle() on a socket and then
14290 * passing it to a function which cares about socket handle validity, which
14291 * checks that handle against the internal list, finds it invalid, and
14292 * returns WSAENOTSOCK.
14293 *
14294 * The problem is that if we close an NT handle without removing it from the
14295 * ws2_32 list, then duplicate another handle, it *may* end up allocated to
14296 * the same handle value, and thus re-validate that handle right under the
14297 * nose of ws2_32. This causes the test_WSAGetOverlappedResult() test to
14298 * sometimes succeed where it's expected to fail with ENOTSOCK.
14299 *
14300 * In order to avoid this, make sure that this test—which is evidently
14301 * destructive to ws2_32 internal state in obscure ways—is executed last.
14302 */
14303 test_iocp();
14304
14305 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
14306 test_send();
14307
14308 Exit();
14309 }
Windows API implementation