?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wineps: Handle EMR_INVERTRGN record in spool files.
[wine.git] / dlls / ws2_32 / tests / sock.c
blob1125d4519d38682be86101cbbb0499755ba6c532
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
165 static void tcp_socketpair_flags(SOCKET *src, SOCKET *dst, DWORD flags)
166 {
167 SOCKET server = INVALID_SOCKET;
168 struct sockaddr_in addr;
169 int len, ret;
170
171 *src = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, flags);
172 ok(*src != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
173
174 server = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, flags);
175 ok(server != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
176
177 memset(&addr, 0, sizeof(addr));
178 addr.sin_family = AF_INET;
179 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
180 ret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
181 ok(!ret, "failed to bind socket, error %u\n", WSAGetLastError());
182
183 len = sizeof(addr);
184 ret = getsockname(server, (struct sockaddr *)&addr, &len);
185 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
186
187 ret = listen(server, 1);
188 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
189
190 ret = connect(*src, (struct sockaddr *)&addr, sizeof(addr));
191 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
192
193 len = sizeof(addr);
194 *dst = accept(server, (struct sockaddr *)&addr, &len);
195 ok(*dst != INVALID_SOCKET, "failed to accept socket, error %u\n", WSAGetLastError());
196
197 closesocket(server);
198 }
199
200 static void tcp_socketpair(SOCKET *src, SOCKET *dst)
201 {
202 tcp_socketpair_flags(src, dst, WSA_FLAG_OVERLAPPED);
203 }
204
205 static void WINAPI apc_func(ULONG_PTR apc_count)
206 {
207 ++*(unsigned int *)apc_count;
208 }
209
210 /* Set the linger timeout to zero and close the socket. This will trigger an
211 * RST on the connection on Windows as well as on Unix systems. */
212 static void close_with_rst(SOCKET s)
213 {
214 static const struct linger linger = {.l_onoff = 1};
215 int ret;
216
217 SetLastError(0xdeadbeef);
218 ret = setsockopt(s, SOL_SOCKET, SO_LINGER, (const char *)&linger, sizeof(linger));
219 ok(!ret, "got %d\n", ret);
220 ok(!GetLastError(), "got error %lu\n", GetLastError());
221
222 closesocket(s);
223 }
224
225 #define check_poll(a, b) check_poll_(__LINE__, a, POLLRDNORM | POLLRDBAND | POLLWRNORM, b, FALSE)
226 #define check_poll_todo(a, b) check_poll_(__LINE__, a, POLLRDNORM | POLLRDBAND | POLLWRNORM, b, TRUE)
227 #define check_poll_mask(a, b, c) check_poll_(__LINE__, a, b, c, FALSE)
228 #define check_poll_mask_todo(a, b, c) check_poll_(__LINE__, a, b, c, TRUE)
229 static void check_poll_(int line, SOCKET s, short mask, short expect, BOOL todo)
230 {
231 WSAPOLLFD pollfd;
232 int ret;
233
234 pollfd.fd = s;
235 pollfd.events = mask;
236 pollfd.revents = 0xdead;
237 ret = pWSAPoll(&pollfd, 1, 1000);
238 ok_(__FILE__, line)(ret == (pollfd.revents ? 1 : 0), "WSAPoll() returned %d\n", ret);
239 todo_wine_if (todo) ok_(__FILE__, line)(pollfd.revents == expect, "got wrong events %#x\n", pollfd.revents);
240 }
241
242 static DWORD WINAPI poll_async_thread(void *arg)
243 {
244 WSAPOLLFD *pollfd = arg;
245 int ret;
246
247 ret = pWSAPoll(pollfd, 1, 500);
248 ok(ret == (pollfd->revents ? 1 : 0), "WSAPoll() returned %d\n", ret);
249
250 return 0;
251 }
252
253 static void set_so_opentype ( BOOL overlapped )
254 {
255 int optval = !overlapped, newval, len = sizeof (int);
256
257 ok ( setsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
258 (LPVOID) &optval, sizeof (optval) ) == 0,
259 "setting SO_OPENTYPE failed\n" );
260 ok ( getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
261 (LPVOID) &newval, &len ) == 0,
262 "getting SO_OPENTYPE failed\n" );
263 ok ( optval == newval, "failed to set SO_OPENTYPE\n" );
264 }
265
266 static int set_blocking ( SOCKET s, BOOL blocking )
267 {
268 u_long val = !blocking;
269 return ioctlsocket ( s, FIONBIO, &val );
270 }
271
272 static void fill_buffer ( char *buf, int chunk_size, int n_chunks )
273 {
274 char c, *p;
275 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
276 memset ( p, c, chunk_size );
277 }
278
279 static int test_buffer ( char *buf, int chunk_size, int n_chunks )
280 {
281 char c, *p;
282 int i;
283 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
284 {
285 for ( i = 0; i < chunk_size; i++ )
286 if ( p[i] != c ) return i;
287 }
288 return -1;
289 }
290
291 /*
292 * This routine is called when a client / server does not expect any more data,
293 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
294 */
295 static void read_zero_bytes ( SOCKET s )
296 {
297 char buf[256];
298 int tmp, n = 0;
299 while ( ( tmp = recv ( s, buf, 256, 0 ) ) > 0 )
300 n += tmp;
301 ok ( n <= 0, "garbage data received: %d bytes\n", n );
302 }
303
304 static int do_synchronous_send ( SOCKET s, char *buf, int buflen, int flags, int sendlen )
305 {
306 char* last = buf + buflen, *p;
307 int n = 1;
308 for ( p = buf; n > 0 && p < last; )
309 {
310 n = send ( s, p, min ( sendlen, last - p ), flags );
311 if (n > 0) p += n;
312 }
313 wsa_ok ( n, 0 <=, "do_synchronous_send (%lx): error %d\n" );
314 return p - buf;
315 }
316
317 static int do_synchronous_recv ( SOCKET s, char *buf, int buflen, int flags, int recvlen )
318 {
319 char* last = buf + buflen, *p;
320 int n = 1;
321 for ( p = buf; n > 0 && p < last; )
322 {
323 n = recv ( s, p, min ( recvlen, last - p ), flags );
324 if (n > 0) p += n;
325 }
326 wsa_ok ( n, 0 <=, "do_synchronous_recv (%lx): error %d:\n" );
327 return p - buf;
328 }
329
330 static int do_synchronous_recvfrom ( SOCKET s, char *buf, int buflen, int flags, struct sockaddr *from, int *fromlen, int recvlen )
331 {
332 char* last = buf + buflen, *p;
333 int n = 1;
334 for ( p = buf; n > 0 && p < last; )
335 {
336 n = recvfrom ( s, p, min ( recvlen, last - p ), flags, from, fromlen );
337 if (n > 0) p += n;
338 }
339 wsa_ok ( n, 0 <=, "do_synchronous_recv (%lx): error %d:\n" );
340 return p - buf;
341 }
342
343 /*
344 * Call this routine right after thread startup.
345 * SO_OPENTYPE must by 0, regardless what the server did.
346 */
347 static void check_so_opentype (void)
348 {
349 int tmp = 1, len;
350 len = sizeof (tmp);
351 getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (LPVOID) &tmp, &len );
352 ok ( tmp == 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp );
353 }
354
355 /**************** Server utility functions ***************/
356
357 /*
358 * Even if we have closed our server socket cleanly,
359 * the OS may mark the address "in use" for some time -
360 * this happens with native Linux apps, too.
361 */
362 static void do_bind ( SOCKET s, struct sockaddr* addr, int addrlen )
363 {
364 int err, wsaerr = 0, n_try = BIND_TRIES;
365
366 while ( ( err = bind ( s, addr, addrlen ) ) != 0 &&
367 ( wsaerr = WSAGetLastError () ) == WSAEADDRINUSE &&
368 n_try-- >= 0)
369 {
370 trace ( "address in use, waiting ...\n" );
371 Sleep ( 1000 * BIND_SLEEP );
372 }
373 ok ( err == 0, "failed to bind: %d\n", wsaerr );
374 }
375
376 static void server_start ( server_params *par )
377 {
378 int i;
379 test_params *gen = par->general;
380 server_memory *mem = LocalAlloc ( LPTR, sizeof ( server_memory ) );
381
382 TlsSetValue ( tls, mem );
383 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
384 NULL, 0, par->sock_flags );
385 ok ( mem->s != INVALID_SOCKET, "Server: WSASocket failed\n" );
386
387 mem->addr.sin_family = AF_INET;
388 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
389 mem->addr.sin_port = htons ( gen->inet_port );
390
391 for (i = 0; i < MAX_CLIENTS; i++)
392 {
393 mem->sock[i].s = INVALID_SOCKET;
394 mem->sock[i].buf = LocalAlloc ( LPTR, gen->n_chunks * gen->chunk_size );
395 mem->sock[i].n_recvd = 0;
396 mem->sock[i].n_sent = 0;
397 }
398
399 if ( gen->sock_type == SOCK_STREAM )
400 do_bind ( mem->s, (struct sockaddr*) &mem->addr, sizeof (mem->addr) );
401 }
402
403 static void server_stop (void)
404 {
405 int i;
406 server_memory *mem = TlsGetValue ( tls );
407
408 for (i = 0; i < MAX_CLIENTS; i++ )
409 {
410 LocalFree ( mem->sock[i].buf );
411 if ( mem->sock[i].s != INVALID_SOCKET )
412 closesocket ( mem->sock[i].s );
413 }
414 ok ( closesocket ( mem->s ) == 0, "closesocket failed\n" );
415 LocalFree ( mem );
416 ExitThread ( GetCurrentThreadId () );
417 }
418
419 /**************** Client utilitiy functions ***************/
420
421 static void client_start ( client_params *par )
422 {
423 test_params *gen = par->general;
424 client_memory *mem = LocalAlloc (LPTR, sizeof (client_memory));
425
426 TlsSetValue ( tls, mem );
427
428 WaitForSingleObject ( server_ready, INFINITE );
429
430 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
431 NULL, 0, par->sock_flags );
432
433 mem->addr.sin_family = AF_INET;
434 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
435 mem->addr.sin_port = htons ( gen->inet_port );
436
437 ok ( mem->s != INVALID_SOCKET, "Client: WSASocket failed\n" );
438
439 mem->send_buf = LocalAlloc ( LPTR, 2 * gen->n_chunks * gen->chunk_size );
440 mem->recv_buf = mem->send_buf + gen->n_chunks * gen->chunk_size;
441 fill_buffer ( mem->send_buf, gen->chunk_size, gen->n_chunks );
442
443 SetEvent ( client_ready[client_id] );
444 /* Wait for the other clients to come up */
445 WaitForMultipleObjects ( min ( gen->n_clients, MAX_CLIENTS ), client_ready, TRUE, INFINITE );
446 }
447
448 static void client_stop (void)
449 {
450 client_memory *mem = TlsGetValue ( tls );
451 wsa_ok ( closesocket ( mem->s ), 0 ==, "closesocket error (%lx): %d\n" );
452 LocalFree ( mem->send_buf );
453 LocalFree ( mem );
454 ExitThread(0);
455 }
456
457 /**************** Servers ***************/
458
459 /*
460 * simple_server: A very basic server doing synchronous IO.
461 */
462 static VOID WINAPI simple_server ( server_params *par )
463 {
464 test_params *gen = par->general;
465 server_memory *mem;
466 int pos, n_recvd, n_sent, n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
467 id = GetCurrentThreadId();
468
469 set_so_opentype ( FALSE ); /* non-overlapped */
470 server_start ( par );
471 mem = TlsGetValue ( tls );
472
473 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "simple_server (%lx): failed to set blocking mode: %d\n");
474 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "simple_server (%lx): listen failed: %d\n");
475
476 SetEvent ( server_ready ); /* notify clients */
477
478 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
479 {
480 /* accept a single connection */
481 tmp = sizeof ( mem->sock[0].peer );
482 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
483 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "simple_server (%lx): accept failed: %d\n" );
484
485 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
486 "simple_server (%x): strange peer address\n", id );
487
488 /* Receive data & check it */
489 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
490 ok ( n_recvd == n_expected,
491 "simple_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
492 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
493 ok ( pos == -1, "simple_server (%x): test pattern error: %d\n", id, pos);
494
495 /* Echo data back */
496 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
497 ok ( n_sent == n_expected,
498 "simple_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
499
500 /* cleanup */
501 read_zero_bytes ( mem->sock[0].s );
502 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "simple_server (%lx): closesocket error: %d\n" );
503 mem->sock[0].s = INVALID_SOCKET;
504 }
505
506 server_stop ();
507 }
508
509 /*
510 * oob_server: A very basic server receiving out-of-band data.
511 */
512 static VOID WINAPI oob_server ( server_params *par )
513 {
514 test_params *gen = par->general;
515 server_memory *mem;
516 u_long atmark = 0;
517 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, tmp,
518 id = GetCurrentThreadId();
519
520 set_so_opentype ( FALSE ); /* non-overlapped */
521 server_start ( par );
522 mem = TlsGetValue ( tls );
523
524 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "oob_server (%lx): failed to set blocking mode: %d\n");
525 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "oob_server (%lx): listen failed: %d\n");
526
527 SetEvent ( server_ready ); /* notify clients */
528
529 /* accept a single connection */
530 tmp = sizeof ( mem->sock[0].peer );
531 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
532 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "oob_server (%lx): accept failed: %d\n" );
533
534 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
535 "oob_server (%x): strange peer address\n", id );
536
537 /* check initial atmark state */
538 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
539 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %li\n", id, atmark );
540
541 /* Receive normal data */
542 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
543 ok ( n_recvd == n_expected,
544 "oob_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
545 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
546 ok ( pos == -1, "oob_server (%x): test pattern error: %d\n", id, pos);
547
548 /* check atmark state */
549 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
550 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %li\n", id, atmark );
551
552 /* Echo data back */
553 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
554 ok ( n_sent == n_expected,
555 "oob_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
556
557 /* Receive a part of the out-of-band data and print atmark state */
558 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, 8, 0, par->buflen );
559 ok ( n_recvd == 8,
560 "oob_server (%x): received less data than expected: %d of %d\n", id, n_recvd, 8 );
561 n_expected -= 8;
562
563 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
564
565 /* Receive the rest of the out-of-band data and check atmark state */
566 do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
567
568 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
569 todo_wine ok ( atmark == 0, "oob_server (%x): not at the OOB mark: %li\n", id, atmark );
570
571 /* cleanup */
572 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "oob_server (%lx): closesocket error: %d\n" );
573 mem->sock[0].s = INVALID_SOCKET;
574
575 server_stop ();
576 }
577
578 /*
579 * select_server: A non-blocking server.
580 */
581 static VOID WINAPI select_server ( server_params *par )
582 {
583 test_params *gen = par->general;
584 server_memory *mem;
585 int n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
586 id = GetCurrentThreadId(), n_connections = 0, n_sent, n_recvd,
587 n_set, delta, n_ready;
588 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
589 fd_set fds_recv, fds_send, fds_openrecv, fds_opensend;
590
591 set_so_opentype ( FALSE ); /* non-overlapped */
592 server_start ( par );
593 mem = TlsGetValue ( tls );
594
595 wsa_ok ( set_blocking ( mem->s, FALSE ), 0 ==, "select_server (%lx): failed to set blocking mode: %d\n");
596 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "select_server (%lx): listen failed: %d\n");
597
598 SetEvent ( server_ready ); /* notify clients */
599
600 FD_ZERO ( &fds_openrecv );
601 FD_ZERO ( &fds_recv );
602 FD_ZERO ( &fds_send );
603 FD_ZERO ( &fds_opensend );
604
605 FD_SET ( mem->s, &fds_openrecv );
606
607 while(1)
608 {
609 fds_recv = fds_openrecv;
610 fds_send = fds_opensend;
611
612 n_set = 0;
613
614 wsa_ok ( ( n_ready = select ( 0, &fds_recv, &fds_send, NULL, &timeout ) ), SOCKET_ERROR !=,
615 "select_server (%lx): select() failed: %d\n" );
616
617 /* check for incoming requests */
618 if ( FD_ISSET ( mem->s, &fds_recv ) ) {
619 n_set += 1;
620
621 /* accept a single connection */
622 tmp = sizeof ( mem->sock[n_connections].peer );
623 mem->sock[n_connections].s = accept ( mem->s, (struct sockaddr*) &mem->sock[n_connections].peer, &tmp );
624 wsa_ok ( mem->sock[n_connections].s, INVALID_SOCKET !=, "select_server (%lx): accept() failed: %d\n" );
625
626 ok ( mem->sock[n_connections].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
627 "select_server (%x): strange peer address\n", id );
628
629 /* add to list of open connections */
630 FD_SET ( mem->sock[n_connections].s, &fds_openrecv );
631 FD_SET ( mem->sock[n_connections].s, &fds_opensend );
632
633 n_connections++;
634 }
635
636 /* handle open requests */
637
638 for ( i = 0; i < n_connections; i++ )
639 {
640 if ( FD_ISSET( mem->sock[i].s, &fds_recv ) ) {
641 n_set += 1;
642
643 if ( mem->sock[i].n_recvd < n_expected ) {
644 /* Receive data & check it */
645 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 );
646 ok ( n_recvd != SOCKET_ERROR, "select_server (%x): error in recv(): %d\n", id, WSAGetLastError() );
647 mem->sock[i].n_recvd += n_recvd;
648
649 if ( mem->sock[i].n_recvd == n_expected ) {
650 int pos = test_buffer ( mem->sock[i].buf, gen->chunk_size, gen->n_chunks );
651 ok ( pos == -1, "select_server (%x): test pattern error: %d\n", id, pos );
652 FD_CLR ( mem->sock[i].s, &fds_openrecv );
653 }
654
655 ok ( mem->sock[i].n_recvd <= n_expected, "select_server (%x): received too many bytes: %d\n", id, mem->sock[i].n_recvd );
656 }
657 }
658
659 /* only echo back what we've received */
660 delta = mem->sock[i].n_recvd - mem->sock[i].n_sent;
661
662 if ( FD_ISSET ( mem->sock[i].s, &fds_send ) ) {
663 n_set += 1;
664
665 if ( ( delta > 0 ) && ( mem->sock[i].n_sent < n_expected ) ) {
666 /* Echo data back */
667 n_sent = send ( mem->sock[i].s, mem->sock[i].buf + mem->sock[i].n_sent, min ( delta, par->buflen ), 0 );
668 ok ( n_sent != SOCKET_ERROR, "select_server (%x): error in send(): %d\n", id, WSAGetLastError() );
669 mem->sock[i].n_sent += n_sent;
670
671 if ( mem->sock[i].n_sent == n_expected ) {
672 FD_CLR ( mem->sock[i].s, &fds_opensend );
673 }
674
675 ok ( mem->sock[i].n_sent <= n_expected, "select_server (%x): sent too many bytes: %d\n", id, mem->sock[i].n_sent );
676 }
677 }
678 }
679
680 /* check that select returned the correct number of ready sockets */
681 ok ( ( n_set == n_ready ), "select_server (%x): select() returns wrong number of ready sockets\n", id );
682
683 /* check if all clients are done */
684 if ( ( fds_opensend.fd_count == 0 )
685 && ( fds_openrecv.fd_count == 1 ) /* initial socket that accepts clients */
686 && ( n_connections == min ( gen->n_clients, MAX_CLIENTS ) ) ) {
687 break;
688 }
689 }
690
691 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
692 {
693 /* cleanup */
694 read_zero_bytes ( mem->sock[i].s );
695 wsa_ok ( closesocket ( mem->sock[i].s ), 0 ==, "select_server (%lx): closesocket error: %d\n" );
696 mem->sock[i].s = INVALID_SOCKET;
697 }
698
699 server_stop ();
700 }
701
702 /**************** Clients ***************/
703
704 /*
705 * simple_client: A very basic client doing synchronous IO.
706 */
707 static VOID WINAPI simple_client ( client_params *par )
708 {
709 test_params *gen = par->general;
710 client_memory *mem;
711 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
712
713 id = GetCurrentThreadId();
714 /* wait here because we want to call set_so_opentype before creating a socket */
715 WaitForSingleObject ( server_ready, INFINITE );
716
717 check_so_opentype ();
718 set_so_opentype ( FALSE ); /* non-overlapped */
719 client_start ( par );
720 mem = TlsGetValue ( tls );
721
722 /* Connect */
723 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
724 0 ==, "simple_client (%lx): connect error: %d\n" );
725 ok ( set_blocking ( mem->s, TRUE ) == 0,
726 "simple_client (%x): failed to set blocking mode\n", id );
727
728 /* send data to server */
729 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
730 ok ( n_sent == n_expected,
731 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
732
733 /* shutdown send direction */
734 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%lx): shutdown failed: %d\n" );
735
736 /* Receive data echoed back & check it */
737 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, 0, par->buflen );
738 ok ( n_recvd == n_expected,
739 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
740
741 /* check data */
742 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
743 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
744
745 /* cleanup */
746 read_zero_bytes ( mem->s );
747 client_stop ();
748 }
749
750 /*
751 * oob_client: A very basic client sending out-of-band data.
752 */
753 static VOID WINAPI oob_client ( client_params *par )
754 {
755 test_params *gen = par->general;
756 client_memory *mem;
757 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
758
759 id = GetCurrentThreadId();
760 /* wait here because we want to call set_so_opentype before creating a socket */
761 WaitForSingleObject ( server_ready, INFINITE );
762
763 check_so_opentype ();
764 set_so_opentype ( FALSE ); /* non-overlapped */
765 client_start ( par );
766 mem = TlsGetValue ( tls );
767
768 /* Connect */
769 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
770 0 ==, "oob_client (%lx): connect error: %d\n" );
771 ok ( set_blocking ( mem->s, TRUE ) == 0,
772 "oob_client (%x): failed to set blocking mode\n", id );
773
774 /* send data to server */
775 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
776 ok ( n_sent == n_expected,
777 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
778
779 /* Receive data echoed back & check it */
780 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, 0, par->buflen );
781 ok ( n_recvd == n_expected,
782 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
783 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
784 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
785
786 /* send out-of-band data to server */
787 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, MSG_OOB, par->buflen );
788 ok ( n_sent == n_expected,
789 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
790
791 /* shutdown send direction */
792 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%lx): shutdown failed: %d\n" );
793
794 /* cleanup */
795 read_zero_bytes ( mem->s );
796 client_stop ();
797 }
798
799 /*
800 * simple_mixed_client: mixing send and recvfrom
801 */
802 static VOID WINAPI simple_mixed_client ( client_params *par )
803 {
804 test_params *gen = par->general;
805 client_memory *mem;
806 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
807 int fromLen = sizeof(mem->addr);
808 struct sockaddr test;
809
810 id = GetCurrentThreadId();
811 /* wait here because we want to call set_so_opentype before creating a socket */
812 WaitForSingleObject ( server_ready, INFINITE );
813
814 check_so_opentype ();
815 set_so_opentype ( FALSE ); /* non-overlapped */
816 client_start ( par );
817 mem = TlsGetValue ( tls );
818
819 /* Connect */
820 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
821 0 ==, "simple_client (%lx): connect error: %d\n" );
822 ok ( set_blocking ( mem->s, TRUE ) == 0,
823 "simple_client (%x): failed to set blocking mode\n", id );
824
825 /* send data to server */
826 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
827 ok ( n_sent == n_expected,
828 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
829
830 /* shutdown send direction */
831 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%lx): shutdown failed: %d\n" );
832
833 /* this shouldn't change, since lpFrom, is not updated on
834 connection oriented sockets - exposed by bug 11640
835 */
836 ((struct sockaddr_in*)&test)->sin_addr.s_addr = inet_addr("0.0.0.0");
837
838 /* Receive data echoed back & check it */
839 n_recvd = do_synchronous_recvfrom ( mem->s,
840 mem->recv_buf,
841 n_expected,
842 0,
843 (struct sockaddr *)&test,
844 &fromLen,
845 par->buflen );
846 ok ( n_recvd == n_expected,
847 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
848
849 /* check that lpFrom was not updated */
850 ok(0 ==
851 strcmp(
852 inet_ntoa(((struct sockaddr_in*)&test)->sin_addr),
853 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
854
855 /* check data */
856 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
857 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
858
859 /* cleanup */
860 read_zero_bytes ( mem->s );
861 client_stop ();
862 }
863
864 /*
865 * event_client: An event-driven client
866 */
867 static void WINAPI event_client ( client_params *par )
868 {
869 test_params *gen = par->general;
870 client_memory *mem;
871 int id = GetCurrentThreadId(), n_expected = gen->n_chunks * gen->chunk_size,
872 tmp, err, n;
873 HANDLE event;
874 WSANETWORKEVENTS wsa_events;
875 char *send_last, *recv_last, *send_p, *recv_p;
876 LONG mask = FD_READ | FD_WRITE | FD_CLOSE;
877
878 client_start ( par );
879
880 mem = TlsGetValue ( tls );
881
882 /* Prepare event notification for connect, makes socket nonblocking */
883 event = WSACreateEvent ();
884 WSAEventSelect ( mem->s, event, FD_CONNECT );
885 tmp = connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) );
886 if ( tmp != 0 ) {
887 err = WSAGetLastError ();
888 ok ( err == WSAEWOULDBLOCK, "event_client (%x): connect error: %d\n", id, err );
889 tmp = WaitForSingleObject ( event, INFINITE );
890 ok ( tmp == WAIT_OBJECT_0, "event_client (%x): wait for connect event failed: %d\n", id, tmp );
891 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
892 ok ( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
893 err = wsa_events.iErrorCode[ FD_CONNECT_BIT ];
894 ok ( err == 0, "event_client (%x): connect error: %d\n", id, err );
895 if ( err ) goto out;
896 }
897
898 WSAEventSelect ( mem->s, event, mask );
899
900 recv_p = mem->recv_buf;
901 recv_last = mem->recv_buf + n_expected;
902 send_p = mem->send_buf;
903 send_last = mem->send_buf + n_expected;
904
905 while ( TRUE )
906 {
907 err = WaitForSingleObject ( event, INFINITE );
908 ok ( err == WAIT_OBJECT_0, "event_client (%x): wait failed\n", id );
909
910 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
911 ok( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
912
913 if ( wsa_events.lNetworkEvents & FD_WRITE )
914 {
915 err = wsa_events.iErrorCode[ FD_WRITE_BIT ];
916 ok ( err == 0, "event_client (%x): FD_WRITE error code: %d\n", id, err );
917
918 if ( err== 0 )
919 do
920 {
921 n = send ( mem->s, send_p, min ( send_last - send_p, par->buflen ), 0 );
922 if ( n < 0 )
923 {
924 err = WSAGetLastError ();
925 ok ( err == WSAEWOULDBLOCK, "event_client (%x): send error: %d\n", id, err );
926 }
927 else
928 send_p += n;
929 }
930 while ( n >= 0 && send_p < send_last );
931
932 if ( send_p == send_last )
933 {
934 shutdown ( mem->s, SD_SEND );
935 mask &= ~FD_WRITE;
936 WSAEventSelect ( mem->s, event, mask );
937 }
938 }
939 if ( wsa_events.lNetworkEvents & FD_READ )
940 {
941 err = wsa_events.iErrorCode[ FD_READ_BIT ];
942 ok ( err == 0, "event_client (%x): FD_READ error code: %d\n", id, err );
943 if ( err != 0 ) break;
944
945 /* First read must succeed */
946 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
947 wsa_ok ( n, 0 <=, "event_client (%lx): recv error: %d\n" );
948
949 while ( n >= 0 ) {
950 recv_p += n;
951 if ( recv_p == recv_last )
952 {
953 mask &= ~FD_READ;
954 WSAEventSelect ( mem->s, event, mask );
955 break;
956 }
957 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
958 ok(n >= 0 || WSAGetLastError() == WSAEWOULDBLOCK,
959 "event_client (%x): got error %u\n", id, WSAGetLastError());
960
961 }
962 }
963 if ( wsa_events.lNetworkEvents & FD_CLOSE )
964 {
965 err = wsa_events.iErrorCode[ FD_CLOSE_BIT ];
966 ok ( err == 0, "event_client (%x): FD_CLOSE error code: %d\n", id, err );
967 break;
968 }
969 }
970
971 n = send_p - mem->send_buf;
972 ok ( send_p == send_last,
973 "simple_client (%x): sent less data than expected: %d of %d\n", id, n, n_expected );
974 n = recv_p - mem->recv_buf;
975 ok ( recv_p == recv_last,
976 "simple_client (%x): received less data than expected: %d of %d\n", id, n, n_expected );
977 n = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
978 ok ( n == -1, "event_client (%x): test pattern error: %d\n", id, n);
979
980 out:
981 WSACloseEvent ( event );
982 client_stop ();
983 }
984
985 /* Tests for WSAStartup */
986 static void test_WithoutWSAStartup(void)
987 {
988 DWORD err;
989
990 WSASetLastError(0xdeadbeef);
991 ok(WSASocketA(0, 0, 0, NULL, 0, 0) == INVALID_SOCKET, "WSASocketA should have failed\n");
992 err = WSAGetLastError();
993 ok(err == WSANOTINITIALISED, "Expected 10093, received %ld\n", err);
994
995 WSASetLastError(0xdeadbeef);
996 ok(gethostbyname("localhost") == NULL, "gethostbyname() succeeded unexpectedly\n");
997 err = WSAGetLastError();
998 ok(err == WSANOTINITIALISED, "Expected 10093, received %ld\n", err);
999 }
1000
1001 static void test_WithWSAStartup(void)
1002 {
1003 WSADATA data;
1004 WORD version = MAKEWORD( 2, 2 );
1005 INT res, socks, i, j;
1006 SOCKET sock;
1007 LPVOID ptr;
1008 struct
1009 {
1010 SOCKET src, dst, dup_src, dup_dst;
1011 } pairs[32];
1012 DWORD error;
1013
1014 res = WSAStartup( version, &data );
1015 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
1016
1017 ptr = gethostbyname("localhost");
1018 ok(ptr != NULL, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
1019
1020 /* Alloc some sockets to check if they are destroyed on WSACleanup */
1021 for (socks = 0; socks < ARRAY_SIZE(pairs); socks++)
1022 {
1023 WSAPROTOCOL_INFOA info;
1024 tcp_socketpair(&pairs[socks].src, &pairs[socks].dst);
1025
1026 memset(&info, 0, sizeof(info));
1027 ok(!WSADuplicateSocketA(pairs[socks].src, GetCurrentProcessId(), &info),
1028 "WSADuplicateSocketA should have worked\n");
1029 pairs[socks].dup_src = WSASocketA(0, 0, 0, &info, 0, 0);
1030 ok(pairs[socks].dup_src != SOCKET_ERROR, "expected != -1\n");
1031
1032 memset(&info, 0, sizeof(info));
1033 ok(!WSADuplicateSocketA(pairs[socks].dst, GetCurrentProcessId(), &info),
1034 "WSADuplicateSocketA should have worked\n");
1035 pairs[socks].dup_dst = WSASocketA(0, 0, 0, &info, 0, 0);
1036 ok(pairs[socks].dup_dst != SOCKET_ERROR, "expected != -1\n");
1037 }
1038
1039 res = send(pairs[0].src, "TEST", 4, 0);
1040 ok(res == 4, "send failed with error %d\n", WSAGetLastError());
1041
1042 WSACleanup();
1043
1044 res = WSAStartup( version, &data );
1045 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
1046
1047 /* show that sockets are destroyed automatically after WSACleanup */
1048 SetLastError(0xdeadbeef);
1049 res = send(pairs[0].src, "TEST", 4, 0);
1050 error = WSAGetLastError();
1051 ok(res == SOCKET_ERROR, "send should have failed\n");
1052 ok(error == WSAENOTSOCK, "expected 10038, got %ld\n", error);
1053
1054 SetLastError(0xdeadbeef);
1055 res = send(pairs[0].dst, "TEST", 4, 0);
1056 error = WSAGetLastError();
1057 ok(res == SOCKET_ERROR, "send should have failed\n");
1058 ok(error == WSAENOTSOCK, "expected 10038, got %ld\n", error);
1059
1060 /* Check that all sockets were destroyed */
1061 for (i = 0; i < socks; i++)
1062 {
1063 for (j = 0; j < 4; j++)
1064 {
1065 struct sockaddr_in saddr;
1066 int size = sizeof(saddr);
1067 switch(j)
1068 {
1069 case 0: sock = pairs[i].src; break;
1070 case 1: sock = pairs[i].dup_src; break;
1071 case 2: sock = pairs[i].dst; break;
1072 case 3: sock = pairs[i].dup_dst; break;
1073 }
1074
1075 SetLastError(0xdeadbeef);
1076 res = getsockname(sock, (struct sockaddr *)&saddr, &size);
1077 error = WSAGetLastError();
1078 ok(res == SOCKET_ERROR, "Test[%d]: getsockname should have failed\n", i);
1079 if (res == SOCKET_ERROR)
1080 ok(error == WSAENOTSOCK, "Test[%d]: expected 10038, got %ld\n", i, error);
1081 }
1082 }
1083
1084 /* While wine is not fixed, close all sockets manually */
1085 for (i = 0; i < socks; i++)
1086 {
1087 closesocket(pairs[i].src);
1088 closesocket(pairs[i].dst);
1089 closesocket(pairs[i].dup_src);
1090 closesocket(pairs[i].dup_dst);
1091 }
1092
1093 res = WSACleanup();
1094 ok(res == 0, "expected 0, got %d\n", res);
1095 WSASetLastError(0xdeadbeef);
1096 res = WSACleanup();
1097 error = WSAGetLastError();
1098 ok ( res == SOCKET_ERROR && error == WSANOTINITIALISED,
1099 "WSACleanup returned %d WSAGetLastError is %ld\n", res, error);
1100 }
1101
1102 /**************** Main program utility functions ***************/
1103
1104 static void Init (void)
1105 {
1106 WORD ver = MAKEWORD (2, 2);
1107 WSADATA data;
1108 HMODULE hws2_32 = GetModuleHandleA("ws2_32.dll"), ntdll;
1109
1110 pWSAPoll = (void *)GetProcAddress(hws2_32, "WSAPoll");
1111
1112 ntdll = LoadLibraryA("ntdll.dll");
1113 if (ntdll)
1114 pNtClose = (void *)GetProcAddress(ntdll, "NtClose");
1115
1116 ok ( WSAStartup ( ver, &data ) == 0, "WSAStartup failed\n" );
1117 tls = TlsAlloc();
1118 }
1119
1120 static void Exit (void)
1121 {
1122 INT ret, err;
1123 TlsFree ( tls );
1124 ret = WSACleanup();
1125 err = WSAGetLastError();
1126 ok ( ret == 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret, err);
1127 }
1128
1129 static void StartServer (LPTHREAD_START_ROUTINE routine,
1130 test_params *general, server_params *par)
1131 {
1132 par->general = general;
1133 thread[0] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[0] );
1134 ok ( thread[0] != NULL, "Failed to create server thread\n" );
1135 }
1136
1137 static void StartClients (LPTHREAD_START_ROUTINE routine,
1138 test_params *general, client_params *par)
1139 {
1140 int i;
1141 par->general = general;
1142 for ( i = 1; i <= min ( general->n_clients, MAX_CLIENTS ); i++ )
1143 {
1144 client_id = i - 1;
1145 thread[i] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[i] );
1146 ok ( thread[i] != NULL, "Failed to create client thread\n" );
1147 /* Make sure the client is up and running */
1148 WaitForSingleObject ( client_ready[client_id], INFINITE );
1149 };
1150 }
1151
1152 static void do_test( test_setup *test )
1153 {
1154 DWORD i, n = min (test->general.n_clients, MAX_CLIENTS);
1155 DWORD wait;
1156
1157 server_ready = CreateEventA ( NULL, TRUE, FALSE, NULL );
1158 for (i = 0; i <= n; i++)
1159 client_ready[i] = CreateEventA ( NULL, TRUE, FALSE, NULL );
1160
1161 StartServer ( test->srv, &test->general, &test->srv_params );
1162 StartClients ( test->clt, &test->general, &test->clt_params );
1163 WaitForSingleObject ( server_ready, INFINITE );
1164
1165 wait = WaitForMultipleObjects ( 1 + n, thread, TRUE, 1000 * TEST_TIMEOUT );
1166 ok(!wait, "wait failed, error %lu\n", wait);
1167
1168 CloseHandle ( server_ready );
1169 for (i = 0; i <= n; i++)
1170 CloseHandle ( client_ready[i] );
1171 }
1172
1173 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1174 /* optname = SO_LINGER */
1175 static const LINGER linger_testvals[] = {
1176 {0,0},
1177 {0,73},
1178 {1,0},
1179 {5,189}
1180 };
1181
1182 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1183 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1184 bug in the linux kernel (fixed in 2.6.8) */
1185 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1186
1187 static void test_set_getsockopt(void)
1188 {
1189 static struct
1190 {
1191 int af;
1192 int type;
1193 int level;
1194 int optname;
1195 BOOL accepts_short_len;
1196 unsigned int sizes[3];
1197 DWORD values[3];
1198 BOOL accepts_large_value;
1199 BOOL bool_value;
1200 }
1201 test_optsize[] =
1202 {
1203 {AF_INET, SOCK_DGRAM, SOL_SOCKET, SO_BROADCAST, TRUE, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE, TRUE},
1204 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_DONTLINGER, TRUE, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE, TRUE},
1205 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_LINGER, FALSE, {1, 2, 4}, {0xdeadbe00, 0xdead0000}, TRUE},
1206 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_OOBINLINE, TRUE, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE, TRUE},
1207 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_RCVBUF, FALSE, {1, 2, 4}, {0xdeadbe00, 0xdead0000}, TRUE},
1208 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_KEEPALIVE, TRUE, {1, 1, 1}, {0}, TRUE},
1209 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_DONTROUTE, TRUE, {1, 1, 1}, {0}, TRUE},
1210 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_RCVTIMEO, FALSE, {1, 2, 4}, {0}, TRUE},
1211 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR, TRUE, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE, TRUE},
1212 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, TRUE, {1, 1, 4}, {0, 0xdead0001, 0}, TRUE, TRUE},
1213 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_SNDBUF, FALSE, {1, 2, 4}, {0xdeadbe00, 0xdead0000}, TRUE},
1214 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_SNDTIMEO, FALSE, {1, 2, 4}, {0}, TRUE},
1215 {AF_INET, SOCK_STREAM, SOL_SOCKET, SO_OPENTYPE, FALSE, {1, 2, 4}, {0}, TRUE},
1216 {AF_INET, SOCK_STREAM, IPPROTO_TCP, TCP_NODELAY, TRUE, {1, 1, 1}, {0}, TRUE},
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;
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
1246 struct _prottest
1247 {
1248 int family, type, proto;
1249 } prottest[] = {
1250 {AF_INET, SOCK_STREAM, IPPROTO_TCP},
1251 {AF_INET, SOCK_DGRAM, IPPROTO_UDP},
1252 {AF_INET6, SOCK_STREAM, IPPROTO_TCP},
1253 {AF_INET6, SOCK_DGRAM, IPPROTO_UDP}
1254 };
1255 union _csspace
1256 {
1257 CSADDR_INFO cs;
1258 char space[128];
1259 } csinfoA, csinfoB;
1260
1261 s = socket(AF_INET, SOCK_STREAM, 0);
1262 ok(s!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1263 if( s == INVALID_SOCKET) return;
1264 /* SO_RCVTIMEO */
1265 timeout = SOCKTIMEOUT1;
1266 size = sizeof(timeout);
1267 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1268 if( !err)
1269 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1270 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1271 ok( timeout == SOCKTIMEOUT1, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1272
1273 timeout = 0;
1274 size = sizeof(timeout);
1275 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1276 if( !err)
1277 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1278 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1279 ok( timeout == 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1280
1281 /* SO_SNDTIMEO */
1282 timeout = SOCKTIMEOUT2; /* 997 seconds. See remark above */
1283 size = sizeof(timeout);
1284 err = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, size);
1285 if( !err)
1286 err = getsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, &size);
1287 ok( !err, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1288 ok( timeout == SOCKTIMEOUT2, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout);
1289
1290 /* SO_SNDBUF */
1291 value = 4096;
1292 size = sizeof(value);
1293 err = setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&value, size);
1294 ok( !err, "setsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1295 value = 0xdeadbeef;
1296 err = getsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&value, &size);
1297 ok( !err, "getsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1298 ok( value == 4096, "expected 4096, got %lu\n", value );
1299
1300 /* SO_RCVBUF */
1301 value = 4096;
1302 size = sizeof(value);
1303 err = setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, size);
1304 ok( !err, "setsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1305 value = 0xdeadbeef;
1306 err = getsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, &size);
1307 ok( !err, "getsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1308 ok( value == 4096, "expected 4096, got %lu\n", value );
1309
1310 /* SO_LINGER */
1311 for( i = 0; i < ARRAY_SIZE(linger_testvals);i++) {
1312 size = sizeof(lingval);
1313 lingval = linger_testvals[i];
1314 err = setsockopt(s, SOL_SOCKET, SO_LINGER, (char *)&lingval, size);
1315 ok(!err, "Test %u: failed to set SO_LINGER, error %u\n", i, WSAGetLastError());
1316 err = getsockopt(s, SOL_SOCKET, SO_LINGER, (char *)&lingval, &size);
1317 ok(!err, "Test %u: failed to get SO_LINGER, error %u\n", i, WSAGetLastError());
1318 ok(!lingval.l_onoff == !linger_testvals[i].l_onoff, "Test %u: expected %d, got %d\n",
1319 i, linger_testvals[i].l_onoff, lingval.l_onoff);
1320 if (lingval.l_onoff)
1321 ok(lingval.l_linger == linger_testvals[i].l_linger, "Test %u: expected %d, got %d\n",
1322 i, linger_testvals[i].l_linger, lingval.l_linger);
1323 }
1324
1325 size = sizeof(lingval);
1326 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, size);
1327 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1328 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1329 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, 0);
1330 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1331 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1332
1333 size = sizeof(BOOL);
1334 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, size);
1335 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1336 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1337 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, 0);
1338 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1339 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1340
1341 /* TCP_NODELAY: optlen doesn't matter on windows, it should work with any positive value */
1342 size = sizeof(value);
1343
1344 value = 1;
1345 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 1);
1346 ok (!err, "setsockopt TCP_NODELAY failed with optlen == 1\n");
1347 value = 0xff;
1348 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1349 ok(!err, "getsockopt TCP_NODELAY failed\n");
1350 ok(value == 1, "TCP_NODELAY should be 1\n");
1351 value = 0;
1352 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, sizeof(value));
1353 ok(!err, "Failed to reset TCP_NODELAY to 0\n");
1354
1355 value = 1;
1356 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 4);
1357 ok (!err, "setsockopt TCP_NODELAY failed with optlen == 4\n");
1358 value = 0xff;
1359 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1360 ok(!err, "getsockopt TCP_NODELAY failed\n");
1361 ok(value == 1, "TCP_NODELAY should be 1\n");
1362 value = 0;
1363 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, sizeof(value));
1364 ok(!err, "Failed to reset TCP_NODELAY to 0\n");
1365
1366 value = 1;
1367 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 42);
1368 ok (!err, "setsockopt TCP_NODELAY failed with optlen == 42\n");
1369 value = 0xff;
1370 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1371 ok(!err, "getsockopt TCP_NODELAY failed\n");
1372 ok(value == 1, "TCP_NODELAY should be 1\n");
1373 value = 0;
1374 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, sizeof(value));
1375 ok(!err, "Failed to reset TCP_NODELAY to 0\n");
1376
1377 value = 1;
1378 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 0);
1379 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1380 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1381 value = 0xff;
1382 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1383 ok(!err, "getsockopt TCP_NODELAY failed\n");
1384 ok(!value, "TCP_NODELAY should be 0\n");
1385
1386 value = 1;
1387 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, -1);
1388 /* On win 10 pro, this sets the error to WSAENOBUFS instead of WSAEFAULT */
1389 ok(err == SOCKET_ERROR && (WSAGetLastError() == WSAEFAULT || WSAGetLastError() == WSAENOBUFS),
1390 "got %d with %d (expected SOCKET_ERROR with either WSAEFAULT or WSAENOBUFS)\n", err, WSAGetLastError());
1391 value = 0xff;
1392 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1393 ok(!err, "getsockopt TCP_NODELAY failed\n");
1394 ok(!value, "TCP_NODELAY should be 0\n");
1395
1396 value = 0x100;
1397 err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 4);
1398 ok (!err, "setsockopt TCP_NODELAY failed with optlen == 4 and optvalue = 0x100\n");
1399 value = 0xff;
1400 err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size);
1401 ok(!err, "getsockopt TCP_NODELAY failed\n");
1402 ok(!value, "TCP_NODELAY should be 0\n");
1403
1404 /* Test for erroneously passing a value instead of a pointer as optval */
1405 size = sizeof(char);
1406 err = setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)1, size);
1407 ok(err == SOCKET_ERROR, "setsockopt with optval being a value passed "
1408 "instead of failing.\n");
1409 lasterr = WSAGetLastError();
1410 ok(lasterr == WSAEFAULT, "setsockopt with optval being a value "
1411 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1412 lasterr, WSAEFAULT);
1413
1414 /* SO_RCVTIMEO with invalid values for level */
1415 size = sizeof(timeout);
1416 timeout = SOCKTIMEOUT1;
1417 SetLastError(0xdeadbeef);
1418 err = setsockopt(s, 0xffffffff, SO_RCVTIMEO, (char *) &timeout, size);
1419 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1420 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1421 err, WSAGetLastError());
1422
1423 timeout = SOCKTIMEOUT1;
1424 SetLastError(0xdeadbeef);
1425 err = setsockopt(s, 0x00008000, SO_RCVTIMEO, (char *) &timeout, size);
1426 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1427 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1428 err, WSAGetLastError());
1429
1430 /* Test SO_ERROR set/get */
1431 SetLastError(0xdeadbeef);
1432 i = 1234;
1433 err = setsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, size);
1434 ok( !err && !WSAGetLastError(),
1435 "got %d with %d (expected 0 with 0)\n",
1436 err, WSAGetLastError());
1437
1438 SetLastError(0xdeadbeef);
1439 i = 4321;
1440 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1441 ok( !err && !WSAGetLastError(),
1442 "got %d with %d (expected 0 with 0)\n",
1443 err, WSAGetLastError());
1444 todo_wine
1445 ok (i == 1234, "got %d (expected 1234)\n", i);
1446
1447 /* Test invalid optlen */
1448 SetLastError(0xdeadbeef);
1449 size = 1;
1450 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1451 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEFAULT),
1452 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1453 err, WSAGetLastError());
1454
1455 closesocket(s);
1456
1457 /* Test option length. */
1458 for (i = 0; i < ARRAY_SIZE(test_optsize); ++i)
1459 {
1460 winetest_push_context("i %u, level %d, optname %d",
1461 i, test_optsize[i].level, test_optsize[i].optname);
1462
1463 s2 = socket( test_optsize[i].af, test_optsize[i].type, 0 );
1464 ok(s2 != INVALID_SOCKET, "socket() failed error %d\n", WSAGetLastError());
1465
1466 size = sizeof(save_value);
1467 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&save_value, &size);
1468 ok(!err, "Unexpected getsockopt result %d.\n", err);
1469
1470 value64 = 0xffffffff00000001;
1471 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char *)&value64, sizeof(value64));
1472 ok(!err, "Unexpected setsockopt result %d.\n", err);
1473 ok(!WSAGetLastError(), "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1474
1475 size = sizeof(value64);
1476 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value64, &size);
1477 ok(!err, "Unexpected getsockopt result %d.\n", err);
1478 ok(size == test_optsize[i].sizes[2], "Got unexpected size %d.\n", size);
1479 /* The behaviour regarding filling the high dword is different between options without the obvious
1480 * pattern, it is either left untouched (more often) or zeroed. Wine doesn't touch the high dword. */
1481
1482 if (test_optsize[i].sizes[2] == 1 || test_optsize[i].level != SOL_SOCKET)
1483 {
1484 expected_err = -1;
1485 expected_last_error = WSAENOBUFS;
1486 }
1487 else
1488 {
1489 expected_err = 0;
1490 expected_last_error = 0;
1491 }
1492
1493 value = 1;
1494 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char *)&value, -1);
1495 ok(err == expected_err, "Unexpected setsockopt result %d.\n", err);
1496 /* Broken between Win7 and Win10 21H1. */
1497 ok(WSAGetLastError() == expected_last_error || broken(expected_last_error && WSAGetLastError() == WSAEFAULT),
1498 "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1499
1500 size = -1;
1501 value = 0xdeadbeef;
1502 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, &size);
1503 if (test_optsize[i].optname == SO_OPENTYPE)
1504 {
1505 ok(!err, "Unexpected getsockopt result %d.\n", err);
1506 ok(!WSAGetLastError(), "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1507 }
1508 else
1509 {
1510 ok(err == -1, "Unexpected getsockopt result %d.\n", err);
1511 ok(WSAGetLastError() == WSAEFAULT, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1512 }
1513 ok(size == (test_optsize[i].optname == SO_OPENTYPE ? 4 : -1), "Got unexpected size %d.\n", size);
1514
1515 if (test_optsize[i].level == SOL_SOCKET && test_optsize[i].bool_value)
1516 {
1517 expected_err = 0;
1518 expected_last_error = 0;
1519 }
1520 else
1521 {
1522 expected_err = -1;
1523 expected_last_error = WSAEFAULT;
1524 }
1525 value = 1;
1526 SetLastError(0xdeadbeef);
1527 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, 0);
1528 ok(err == expected_err, "Unexpected setsockopt result %d.\n", err);
1529 ok(WSAGetLastError() == expected_last_error, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1530
1531 size = 0;
1532 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, &size);
1533 ok(err == -1, "Unexpected getsockopt result %d.\n", err);
1534 ok(WSAGetLastError() == WSAEFAULT, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1535
1536 expected_size = test_optsize[i].sizes[2];
1537 if (expected_size == 1)
1538 expected_value = 0xdeadbe00;
1539 else
1540 expected_value = test_optsize[i].bool_value ? 0x1 : 0x100;
1541 if (test_optsize[i].accepts_large_value)
1542 {
1543 expected_err = 0;
1544 expected_last_error = 0;
1545 }
1546 else
1547 {
1548 expected_err = -1;
1549 expected_last_error = WSAEINVAL;
1550 }
1551
1552 value = 0x100;
1553 SetLastError(0xdeadbeef);
1554 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, 4);
1555 ok(err == expected_err, "Unexpected setsockopt result %d.\n", err);
1556 ok(WSAGetLastError() == expected_last_error, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1557
1558 if (test_optsize[i].accepts_large_value)
1559 {
1560 value = 0xdeadbeef;
1561 SetLastError(0xdeadbeef);
1562 size = 4;
1563 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, &size);
1564 ok(err == expected_err, "Unexpected getsockopt result %d.\n", err);
1565 ok(WSAGetLastError() == expected_last_error, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1566 todo_wine_if(test_optsize[i].optname == SO_DONTROUTE || test_optsize[i].optname == SO_LINGER)
1567 ok(value == expected_value, "Got unexpected value %#lx, expected %#lx.\n", value, expected_value);
1568 ok(size == expected_size, "Got unexpected size %u, expected %u.\n", size, expected_size);
1569 }
1570
1571 winetest_pop_context();
1572
1573 for (j = 0; j < ARRAY_SIZE(test_optsize[i].sizes); ++j)
1574 {
1575 size = 1 << j;
1576 winetest_push_context("i %u, level %d, optname %d, len %u",
1577 i, test_optsize[i].level, test_optsize[i].optname, size);
1578
1579 value = 1;
1580 if (test_optsize[i].values[j])
1581 expected_value = test_optsize[i].values[j];
1582 else
1583 expected_value = 0xdeadbeef;
1584
1585 if (test_optsize[i].accepts_short_len || size == 4)
1586 {
1587 expected_err = 0;
1588 expected_last_error = 0;
1589 expected_size = test_optsize[i].sizes[j];
1590
1591 if (!test_optsize[i].values[j])
1592 memcpy(&expected_value, &value, expected_size);
1593 }
1594 else
1595 {
1596 expected_err = -1;
1597 expected_last_error = WSAEFAULT;
1598 expected_size = test_optsize[i].sizes[j];
1599 }
1600
1601 SetLastError(0xdeadbeef);
1602 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, size);
1603 ok(err == expected_err, "Unexpected setsockopt result %d.\n", err);
1604 ok(WSAGetLastError() == expected_last_error, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1605
1606 value = 0xdeadbeef;
1607 SetLastError(0xdeadbeef);
1608 err = getsockopt(s2, test_optsize[i].level, test_optsize[i].optname, (char*)&value, &size);
1609 ok(err == expected_err, "Unexpected getsockopt result %d.\n", err);
1610 ok(WSAGetLastError() == expected_last_error, "Unexpected WSAGetLastError() %u.\n", WSAGetLastError());
1611 ok(value == expected_value, "Got unexpected value %#lx, expected %#lx.\n", value, expected_value);
1612 ok(size == expected_size, "Got unexpected size %d, expected %d.\n", size, expected_size);
1613
1614 winetest_pop_context();
1615 }
1616
1617 err = setsockopt(s2, test_optsize[i].level, test_optsize[i].optname,
1618 (char*)&save_value, sizeof(save_value));
1619 ok(!err, "Unexpected getsockopt result %d.\n", err);
1620 closesocket(s2);
1621 }
1622
1623 /* Test with the closed socket */
1624 SetLastError(0xdeadbeef);
1625 size = sizeof(i);
1626 i = 1234;
1627 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1628 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAENOTSOCK),
1629 "got %d with %d (expected SOCKET_ERROR with WSAENOTSOCK)\n",
1630 err, WSAGetLastError());
1631 ok (i == 1234, "expected 1234, got %d\n", i);
1632
1633 /* Test WS_IP_MULTICAST_TTL with 8, 16, 24 and 32 bits values */
1634 s = socket(AF_INET, SOCK_DGRAM, 0);
1635 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1636 size = sizeof(i);
1637 i = 0x0000000a;
1638 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &i, size);
1639 if (!err)
1640 {
1641 for (i = 0; i < 4; i++)
1642 {
1643 int k, j;
1644 const int tests[] = {0xffffff0a, 0xffff000b, 0xff00000c, 0x0000000d};
1645 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &tests[i], i + 1);
1646 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1647 err = getsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &k, &size);
1648 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1649 j = i != 3 ? tests[i] & ((1 << (i + 1) * 8) - 1) : tests[i];
1650 ok(k == j, "Test [%d] Expected 0x%x, got 0x%x\n", i, j, k);
1651 }
1652 }
1653 else
1654 win_skip("IP_MULTICAST_TTL is unsupported\n");
1655 closesocket(s);
1656
1657 /* test SO_PROTOCOL_INFOA invalid parameters */
1658 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1659 "getsockopt should have failed\n");
1660 err = WSAGetLastError();
1661 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1662 size = sizeof(WSAPROTOCOL_INFOA);
1663 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1664 "getsockopt should have failed\n");
1665 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1666 err = WSAGetLastError();
1667 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1668 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1669 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1670 "getsockopt should have failed\n");
1671 err = WSAGetLastError();
1672 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1673 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, NULL),
1674 "getsockopt should have failed\n");
1675 err = WSAGetLastError();
1676 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1677 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, &size),
1678 "getsockopt should have failed\n");
1679 err = WSAGetLastError();
1680 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1681 size = sizeof(WSAPROTOCOL_INFOA) / 2;
1682 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1683 "getsockopt should have failed\n");
1684 err = WSAGetLastError();
1685 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1686 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1687 size = sizeof(WSAPROTOCOL_INFOA) * 2;
1688 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1689 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1690 ok(size == sizeof(WSAPROTOCOL_INFOA) * 2, "got size %d\n", size);
1691
1692 closesocket(s);
1693
1694 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1695 for (i = 0; i < ARRAY_SIZE(prottest); i++)
1696 {
1697 int k;
1698
1699 s = socket(prottest[i].family, prottest[i].type, prottest[i].proto);
1700 if (s == INVALID_SOCKET && prottest[i].family == AF_INET6) continue;
1701
1702 ok(s != INVALID_SOCKET, "Failed to create socket: %d\n",
1703 WSAGetLastError());
1704
1705 /* compare both A and W version */
1706 infoA.szProtocol[0] = 0;
1707 size = sizeof(WSAPROTOCOL_INFOA);
1708 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1709 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1710 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1711
1712 infoW.szProtocol[0] = 0;
1713 size = sizeof(WSAPROTOCOL_INFOW);
1714 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOW, (char *) &infoW, &size);
1715 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1716 ok(size == sizeof(WSAPROTOCOL_INFOW), "got size %d\n", size);
1717
1718 ok(infoA.szProtocol[0], "WSAPROTOCOL_INFOA was not filled\n");
1719 ok(infoW.szProtocol[0], "WSAPROTOCOL_INFOW was not filled\n");
1720
1721 WideCharToMultiByte(CP_ACP, 0, infoW.szProtocol, -1,
1722 providername, sizeof(providername), NULL, NULL);
1723 ok(!strcmp(infoA.szProtocol,providername),
1724 "different provider names '%s' != '%s'\n", infoA.szProtocol, providername);
1725
1726 ok(!memcmp(&infoA, &infoW, FIELD_OFFSET(WSAPROTOCOL_INFOA, szProtocol)),
1727 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1728
1729 /* Remove IF when WSAEnumProtocols support IPV6 data */
1730 ok(infoA.iAddressFamily == prottest[i].family, "socket family invalid, expected %d received %d\n",
1731 prottest[i].family, infoA.iAddressFamily);
1732 ok(infoA.iSocketType == prottest[i].type, "socket type invalid, expected %d received %d\n",
1733 prottest[i].type, infoA.iSocketType);
1734 ok(infoA.iProtocol == prottest[i].proto, "socket protocol invalid, expected %d received %d\n",
1735 prottest[i].proto, infoA.iProtocol);
1736
1737 /* IP_HDRINCL is supported only on SOCK_RAW but passed to SOCK_DGRAM by Impossible Creatures */
1738 size = sizeof(i);
1739 k = 1;
1740 SetLastError(0xdeadbeef);
1741 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1742 if (err == -1) /* >= Vista */
1743 {
1744 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %ld\n", GetLastError());
1745 k = 99;
1746 SetLastError(0xdeadbeef);
1747 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1748 ok(err == -1, "Expected -1, got %d\n", err);
1749 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %ld\n", GetLastError());
1750 ok(k == 99, "Expected 99, got %d\n", k);
1751
1752 size = sizeof(k);
1753 k = 0;
1754 SetLastError(0xdeadbeef);
1755 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1756 ok(err == -1, "Expected -1, got %d\n", err);
1757 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %ld\n", GetLastError());
1758 k = 99;
1759 SetLastError(0xdeadbeef);
1760 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1761 ok(err == -1, "Expected -1, got %d\n", err);
1762 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %ld\n", GetLastError());
1763 ok(k == 99, "Expected 99, got %d\n", k);
1764 }
1765 else /* <= 2003 the tests differ between TCP and UDP, UDP silently accepts */
1766 {
1767 SetLastError(0xdeadbeef);
1768 k = 99;
1769 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1770 if (prottest[i].type == SOCK_DGRAM)
1771 {
1772 ok(err == 0, "Expected 0, got %d\n", err);
1773 ok(k == 1, "Expected 1, got %d\n", k);
1774 }
1775 else
1776 {
1777 /* contratry to what we could expect the function returns error but k is changed */
1778 ok(err == -1, "Expected -1, got %d\n", err);
1779 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %ld\n", GetLastError());
1780 ok(k == 0, "Expected 0, got %d\n", k);
1781 }
1782
1783 k = 0;
1784 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1785 ok(err == 0, "Expected 0, got %d\n", err);
1786
1787 k = 99;
1788 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1789 if (prottest[i].type == SOCK_DGRAM)
1790 {
1791 ok(err == 0, "Expected 0, got %d\n", err);
1792 ok(k == 0, "Expected 0, got %d\n", k);
1793 }
1794 else
1795 {
1796 /* contratry to what we could expect the function returns error but k is changed */
1797 ok(err == -1, "Expected -1, got %d\n", err);
1798 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %ld\n", GetLastError());
1799 ok(k == 0, "Expected 0, got %d\n", k);
1800 }
1801 }
1802
1803 closesocket(s);
1804 }
1805
1806 /* Test SO_BSP_STATE - Present only in >= Win 2008 */
1807 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1808 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1809 s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1810 ok(s2 != INVALID_SOCKET, "Failed to create socket\n");
1811
1812 SetLastError(0xdeadbeef);
1813 size = sizeof(csinfoA);
1814 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1815 if (!err)
1816 {
1817 struct sockaddr_in saddr;
1818 memset(&saddr, 0, sizeof(saddr));
1819 saddr.sin_family = AF_INET;
1820 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1821
1822 /* Socket is not bound, no information provided */
1823 ok(!csinfoA.cs.LocalAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.LocalAddr.iSockaddrLength);
1824 ok(csinfoA.cs.LocalAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.LocalAddr.lpSockaddr);
1825 /* Socket is not connected, no information provided */
1826 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.RemoteAddr.iSockaddrLength);
1827 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.RemoteAddr.lpSockaddr);
1828
1829 err = bind(s, (struct sockaddr*)&saddr, sizeof(saddr));
1830 ok(!err, "Expected 0, got %d\n", err);
1831 size = sizeof(csinfoA);
1832 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1833 ok(!err, "Expected 0, got %d\n", err);
1834
1835 /* Socket is bound */
1836 ok(csinfoA.cs.LocalAddr.iSockaddrLength, "Expected non-zero\n");
1837 ok(csinfoA.cs.LocalAddr.lpSockaddr != NULL, "Expected non-null\n");
1838 /* Socket is not connected, no information provided */
1839 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.RemoteAddr.iSockaddrLength);
1840 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.RemoteAddr.lpSockaddr);
1841
1842 err = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1843 ok(!err, "Expected 0, got %d\n", err);
1844 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1845 ok(!err, "Expected 0, got %d\n", err);
1846 err = listen(s2, 1);
1847 ok(!err, "Expected 0, got %d\n", err);
1848 err = connect(s, (struct sockaddr*)&saddr, sizeof(saddr));
1849 ok(!err, "Expected 0, got %d\n", err);
1850 size = sizeof(saddr);
1851 err = accept(s2, (struct sockaddr*)&saddr, &size);
1852 ok(err != INVALID_SOCKET, "Failed to accept socket\n");
1853 closesocket(s2);
1854 s2 = err;
1855
1856 size = sizeof(csinfoA);
1857 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1858 ok(!err, "Expected 0, got %d\n", err);
1859 err = getsockopt(s2, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoB, &size);
1860 ok(!err, "Expected 0, got %d\n", err);
1861 ok(size == sizeof(csinfoA), "Got %d\n", size);
1862 size = sizeof(saddr);
1863 ok(size == csinfoA.cs.LocalAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1864 csinfoA.cs.LocalAddr.iSockaddrLength);
1865 ok(size == csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1866 csinfoA.cs.RemoteAddr.iSockaddrLength);
1867 ok(!memcmp(csinfoA.cs.LocalAddr.lpSockaddr, csinfoB.cs.RemoteAddr.lpSockaddr, size),
1868 "Expected matching addresses\n");
1869 ok(!memcmp(csinfoB.cs.LocalAddr.lpSockaddr, csinfoA.cs.RemoteAddr.lpSockaddr, size),
1870 "Expected matching addresses\n");
1871 ok(csinfoA.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1872 ok(csinfoB.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1873 ok(csinfoA.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1874 ok(csinfoB.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1875
1876 err = getpeername(s, (struct sockaddr *)&saddr, &size);
1877 ok(!err, "Expected 0, got %d\n", err);
1878 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1879 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1880 err = getpeername(s2, (struct sockaddr *)&saddr, &size);
1881 ok(!err, "Expected 0, got %d\n", err);
1882 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1883 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1884 err = getsockname(s, (struct sockaddr *)&saddr, &size);
1885 ok(!err, "Expected 0, got %d\n", err);
1886 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1887 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1888 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1889 ok(!err, "Expected 0, got %d\n", err);
1890 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1891 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1892
1893 SetLastError(0xdeadbeef);
1894 size = sizeof(CSADDR_INFO);
1895 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1896 ok(err, "Expected non-zero\n");
1897 ok(size == sizeof(CSADDR_INFO), "Got %d\n", size);
1898 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %ld\n", GetLastError());
1899
1900 /* At least for IPv4 the size is exactly 56 bytes */
1901 size = sizeof(*csinfoA.cs.LocalAddr.lpSockaddr) * 2 + sizeof(csinfoA.cs);
1902 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1903 ok(!err, "Expected 0, got %d\n", err);
1904 size--;
1905 SetLastError(0xdeadbeef);
1906 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1907 ok(err, "Expected non-zero\n");
1908 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %ld\n", GetLastError());
1909 }
1910 else
1911 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %ld\n", GetLastError());
1912
1913 closesocket(s);
1914 closesocket(s2);
1915
1916 for (i = 0; i < 2; i++)
1917 {
1918 int family, level;
1919
1920 if (i)
1921 {
1922 family = AF_INET6;
1923 level = IPPROTO_IPV6;
1924 }
1925 else
1926 {
1927 family = AF_INET;
1928 level = IPPROTO_IP;
1929 }
1930
1931 s = socket(family, SOCK_DGRAM, 0);
1932 if (s == INVALID_SOCKET && i)
1933 {
1934 skip("IPv6 is not supported\n");
1935 break;
1936 }
1937 ok(s != INVALID_SOCKET, "socket failed with error %ld\n", GetLastError());
1938
1939 size = sizeof(value);
1940 value = 0xdead;
1941 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1942 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
1943 ok(value == 0, "Expected 0, got %ld\n", value);
1944
1945 size = sizeof(value);
1946 value = 1;
1947 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
1948 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
1949
1950 value = 0xdead;
1951 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1952 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
1953 ok(value == 1, "Expected 1, got %ld\n", value);
1954
1955 size = sizeof(value);
1956 value = 0xdead;
1957 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
1958 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
1959
1960 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1961 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
1962 ok(value == 1, "Expected 1, got %ld\n", value);
1963
1964 closesocket(s);
1965
1966 s = socket(family, SOCK_STREAM, 0);
1967 ok(s != INVALID_SOCKET, "socket failed with error %ld\n", GetLastError());
1968
1969 size = sizeof(value);
1970 value = 0xdead;
1971 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1972 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
1973 ok(value == 1 || broken(value == 0) /* < vista */, "Expected 1, got %ld\n", value);
1974
1975 size = sizeof(value);
1976 value = 0;
1977 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
1978 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
1979
1980 value = 0xdead;
1981 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1982 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
1983 ok(value == 0, "Expected 0, got %ld\n", value);
1984
1985 closesocket(s);
1986
1987 s = socket(family, SOCK_RAW, 0);
1988 if (s == INVALID_SOCKET)
1989 {
1990 if (WSAGetLastError() == WSAEACCES) skip("SOCK_RAW is not available\n");
1991 else if (i) skip("IPv6 is not supported\n");
1992 break;
1993 }
1994 ok(s != INVALID_SOCKET, "socket failed with error %ld\n", GetLastError());
1995
1996 size = sizeof(value);
1997 value = 0xdead;
1998 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1999 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2000 ok(value == 0, "Expected 0, got %ld\n", value);
2001
2002 size = sizeof(value);
2003 value = 1;
2004 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
2005 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2006
2007 value = 0xdead;
2008 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
2009 ok(!err, "Expected 0, got %d with error %ld\n", err, GetLastError());
2010 ok(value == 1, "Expected 1, got %ld\n", value);
2011
2012 closesocket(s);
2013 }
2014 }
2015
2016 static void test_reuseaddr(void)
2017 {
2018 static struct sockaddr_in6 saddr_in6_any, saddr_in6_loopback;
2019 static struct sockaddr_in6 saddr_in6_any_v4mapped, saddr_in6_loopback_v4mapped;
2020 static struct sockaddr_in saddr_in_any, saddr_in_loopback;
2021
2022 static const struct
2023 {
2024 int domain;
2025 struct sockaddr *addr_any;
2026 struct sockaddr *addr_loopback;
2027 socklen_t addrlen;
2028 }
2029 tests[] =
2030 {
2031 { AF_INET, (struct sockaddr *)&saddr_in_any, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_any) },
2032 { AF_INET6, (struct sockaddr *)&saddr_in6_any, (struct sockaddr *)&saddr_in6_loopback, sizeof(saddr_in6_any) },
2033 };
2034 static const struct
2035 {
2036 struct
2037 {
2038 int domain;
2039 struct sockaddr *addr;
2040 socklen_t addrlen;
2041 BOOL exclusive;
2042 }
2043 s[2];
2044 int error;
2045 }
2046 tests_exclusive[] =
2047 {
2048 {
2049 {{ AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, },
2050 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, }},
2051 WSAEACCES,
2052 },
2053 {
2054 {{ AF_INET6, (struct sockaddr *)&saddr_in6_any, sizeof(saddr_in6_any), TRUE, },
2055 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, }},
2056 WSAEACCES,
2057 },
2058 {
2059 {{ AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, },
2060 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, }},
2061 NOERROR,
2062 },
2063 {
2064 {{ AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, },
2065 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, }},
2066 WSAEACCES,
2067 },
2068 {
2069 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, },
2070 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, }},
2071 NOERROR,
2072 },
2073 {
2074 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, },
2075 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, }},
2076 WSAEADDRINUSE,
2077 },
2078 {
2079 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, },
2080 { AF_INET6, (struct sockaddr *)&saddr_in6_any, sizeof(saddr_in6_any), TRUE, }},
2081 WSAEADDRINUSE,
2082 },
2083 {
2084 {{ AF_INET6, (struct sockaddr *)&saddr_in6_loopback, sizeof(saddr_in6_loopback), FALSE, },
2085 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, }},
2086 NOERROR,
2087 },
2088 {
2089 {{ AF_INET6, (struct sockaddr *)&saddr_in6_loopback, sizeof(saddr_in6_loopback), TRUE, },
2090 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, }},
2091 NOERROR,
2092 },
2093 {
2094 {{ AF_INET6, (struct sockaddr *)&saddr_in6_loopback_v4mapped, sizeof(saddr_in6_loopback_v4mapped), FALSE, },
2095 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, }},
2096 WSAEADDRINUSE,
2097 },
2098 {
2099 {{ AF_INET6, (struct sockaddr *)&saddr_in6_any, sizeof(saddr_in6_any), TRUE, },
2100 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, }},
2101 WSAEACCES,
2102 },
2103 {
2104 {{ AF_INET6, (struct sockaddr *)&saddr_in6_any, sizeof(saddr_in6_any), FALSE, },
2105 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, }},
2106 NOERROR,
2107 },
2108 {
2109 {{ AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, },
2110 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), TRUE, }},
2111 WSAEADDRINUSE,
2112 },
2113 {
2114 {{ AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, },
2115 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, }},
2116 WSAEADDRINUSE,
2117 },
2118 {
2119 {{ AF_INET6, (struct sockaddr *)&saddr_in6_any, sizeof(saddr_in6_any), FALSE, },
2120 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, }},
2121 NOERROR,
2122 },
2123 {
2124 {{ AF_INET6, (struct sockaddr *)&saddr_in6_any_v4mapped, sizeof(saddr_in6_any_v4mapped), FALSE, },
2125 { AF_INET, (struct sockaddr *)&saddr_in_any, sizeof(saddr_in_any), FALSE, }},
2126 WSAEADDRINUSE,
2127 },
2128 {
2129 {{ AF_INET6, (struct sockaddr *)&saddr_in6_loopback_v4mapped, sizeof(saddr_in6_loopback_v4mapped), FALSE, },
2130 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, }},
2131 WSAEADDRINUSE,
2132 },
2133 {
2134 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, },
2135 { AF_INET6, (struct sockaddr *)&saddr_in6_loopback_v4mapped, sizeof(saddr_in6_loopback_v4mapped), FALSE, }},
2136 WSAEADDRINUSE,
2137 },
2138 {
2139 {{ AF_INET6, (struct sockaddr *)&saddr_in6_loopback, sizeof(saddr_in6_loopback), TRUE, },
2140 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, }},
2141 NOERROR,
2142 },
2143 {
2144 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, },
2145 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, }},
2146 WSAEADDRINUSE,
2147 },
2148 {
2149 {{ AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), FALSE, },
2150 { AF_INET, (struct sockaddr *)&saddr_in_loopback, sizeof(saddr_in_loopback), TRUE, }},
2151 WSAEADDRINUSE,
2152 },
2153 };
2154
2155 unsigned int rc, reuse, value;
2156 struct sockaddr_storage saddr;
2157 SOCKET s1, s2, s3, s4;
2158 unsigned int i, j;
2159 int size;
2160
2161 saddr_in_any.sin_family = AF_INET;
2162 saddr_in_any.sin_port = htons(SERVERPORT + 1);
2163 saddr_in_any.sin_addr.s_addr = htonl(INADDR_ANY);
2164 saddr_in_loopback = saddr_in_any;
2165 saddr_in_loopback.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
2166
2167 saddr_in6_any.sin6_family = AF_INET6;
2168 saddr_in6_any.sin6_port = htons(SERVERPORT + 1);
2169 memset( &saddr_in6_any.sin6_addr, 0, sizeof(saddr_in6_any.sin6_addr) );
2170 saddr_in6_loopback = saddr_in6_any;
2171 inet_pton(AF_INET6, "::1", &saddr_in6_loopback.sin6_addr);
2172
2173 saddr_in6_loopback_v4mapped = saddr_in6_any;
2174 rc = inet_pton(AF_INET6, "::ffff:127.0.0.1", &saddr_in6_loopback_v4mapped.sin6_addr);
2175 ok(rc, "got error %d.\n", WSAGetLastError());
2176
2177 saddr_in6_any_v4mapped = saddr_in6_any;
2178 rc = inet_pton(AF_INET6, "::ffff:0.0.0.0", &saddr_in6_any_v4mapped.sin6_addr);
2179 ok(rc, "got error %d.\n", WSAGetLastError());
2180
2181 for (i = 0; i < ARRAY_SIZE(tests); ++i)
2182 {
2183 winetest_push_context("test %u", i);
2184
2185 /* Test with SO_REUSEADDR on second socket only. */
2186 s1=socket(tests[i].domain, SOCK_STREAM, 0);
2187 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2188
2189 rc = bind(s1, tests[i].addr_loopback, tests[i].addrlen);
2190 ok(!rc || (tests[i].domain == AF_INET6 && WSAGetLastError() == WSAEADDRNOTAVAIL), "got error %d.\n", WSAGetLastError());
2191 if (tests[i].domain == AF_INET6 && WSAGetLastError() == WSAEADDRNOTAVAIL)
2192 {
2193 skip("IPv6 not supported, skipping test\n");
2194 closesocket(s1);
2195 winetest_pop_context();
2196 continue;
2197 }
2198
2199 s2 = socket(tests[i].domain, SOCK_STREAM, 0);
2200 ok(s2 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2201
2202 reuse = 1;
2203 rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
2204 ok(!rc, "got error %d.\n", WSAGetLastError());
2205
2206 rc = bind(s2, tests[i].addr_loopback, tests[i].addrlen);
2207 ok(rc == SOCKET_ERROR, "got rc %d.\n", rc);
2208 ok(WSAGetLastError() == WSAEACCES, "got error %d.\n", WSAGetLastError());
2209
2210 closesocket(s1);
2211 closesocket(s2);
2212
2213 /* Test with SO_REUSEADDR on both sockets. */
2214 s1 = socket(tests[i].domain, SOCK_STREAM, 0);
2215 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2216
2217 reuse = 1;
2218 rc = setsockopt(s1, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
2219 ok(!rc, "got error %d.\n", WSAGetLastError());
2220
2221 rc = bind(s1, tests[i].addr_loopback, tests[i].addrlen);
2222 ok(!rc, "got error %d.\n", WSAGetLastError());
2223
2224 s2 = socket(tests[i].domain, SOCK_STREAM, 0);
2225 ok(s2 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2226
2227 reuse = 0x1234;
2228 size = sizeof(reuse);
2229 rc = getsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, &size);
2230 ok(!rc && !reuse,"got rc %d, reuse %d.\n", rc, reuse);
2231
2232 rc = bind(s2, tests[i].addr_loopback, tests[i].addrlen);
2233 ok(rc == SOCKET_ERROR, "got rc %d, error %d.\n", rc, WSAGetLastError());
2234
2235 reuse = 1;
2236 rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
2237 ok(!rc, "got error %d.\n", WSAGetLastError());
2238
2239 rc = bind(s2, tests[i].addr_loopback, tests[i].addrlen);
2240 ok(!rc, "got error %d.\n", WSAGetLastError());
2241
2242 s3 = socket(tests[i].domain, SOCK_STREAM, 0);
2243 ok(s3 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2244
2245 /* Test if we can really connect to one of them. */
2246 rc = listen(s1, 1);
2247 ok(!rc, "got error %d.\n", WSAGetLastError());
2248 rc = listen(s2, 1);
2249 todo_wine ok(!rc, "got error %d.\n", WSAGetLastError());
2250 rc = connect(s3, tests[i].addr_loopback, tests[i].addrlen);
2251 ok(!rc, "got error %d.\n", WSAGetLastError());
2252
2253 /* The connection is delivered to the first socket. */
2254 size = tests[i].addrlen;
2255 s4 = accept(s1, (struct sockaddr *)&saddr, &size);
2256 ok(s4 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2257
2258 closesocket(s1);
2259 closesocket(s2);
2260 closesocket(s3);
2261 closesocket(s4);
2262
2263 /* Test binding and listening on any addr together with loopback, any addr first. */
2264 s1 = socket(tests[i].domain, SOCK_STREAM, 0);
2265 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2266
2267 rc = bind(s1, tests[i].addr_any, tests[i].addrlen);
2268 ok(!rc, "got error %d.\n", WSAGetLastError());
2269
2270 rc = listen(s1, 1);
2271 ok(!rc, "got error %d.\n", WSAGetLastError());
2272
2273 s2 = socket(tests[i].domain, SOCK_STREAM, 0);
2274 ok(s2 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2275
2276 rc = bind(s2, tests[i].addr_loopback, tests[i].addrlen);
2277 todo_wine ok(!rc, "got error %d.\n", WSAGetLastError());
2278
2279 rc = listen(s2, 1);
2280 todo_wine ok(!rc, "got error %d.\n", WSAGetLastError());
2281
2282 s3 = socket(tests[i].domain, SOCK_STREAM, 0);
2283 ok(s3 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2284
2285 rc = connect(s3, tests[i].addr_loopback, tests[i].addrlen);
2286 ok(!rc, "got error %d.\n", WSAGetLastError());
2287
2288 size = tests[i].addrlen;
2289 s4 = accept(s2, (struct sockaddr *)&saddr, &size);
2290 todo_wine ok(s4 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2291
2292 closesocket(s1);
2293 closesocket(s2);
2294 closesocket(s3);
2295 closesocket(s4);
2296
2297 /* Test binding and listening on any addr together with loopback, loopback addr first. */
2298
2299 s1 = socket(tests[i].domain, SOCK_STREAM, 0);
2300 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2301
2302 rc = bind(s1, tests[i].addr_loopback, tests[i].addrlen);
2303 ok(!rc, "got error %d.\n", WSAGetLastError());
2304
2305 rc = listen(s1, 1);
2306 ok(!rc, "got error %d.\n", WSAGetLastError());
2307
2308 s2 = socket(tests[i].domain, SOCK_STREAM, 0);
2309 ok(s2 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2310
2311 rc = bind(s2, tests[i].addr_any, tests[i].addrlen);
2312 todo_wine ok(!rc, "got rc %d, error %d.\n", rc, WSAGetLastError());
2313
2314 rc = listen(s2, 1);
2315 todo_wine ok(!rc, "got error %d.\n", WSAGetLastError());
2316
2317 s3 = socket(tests[i].domain, SOCK_STREAM, 0);
2318 ok(s3 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2319
2320 rc = connect(s3, tests[i].addr_loopback, tests[i].addrlen);
2321 ok(!rc, "got error %d.\n", WSAGetLastError());
2322 size = tests[i].addrlen;
2323 s4 = accept(s1, (struct sockaddr *)&saddr, &size);
2324
2325 ok(s4 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2326
2327 closesocket(s1);
2328 closesocket(s2);
2329 closesocket(s3);
2330 closesocket(s4);
2331
2332 /* Test binding to INADDR_ANY on two sockets. */
2333 s1 = socket(tests[i].domain, SOCK_STREAM, 0);
2334 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2335
2336 rc = bind(s1, tests[i].addr_any, tests[i].addrlen);
2337 ok(!rc, "got error %d.\n", WSAGetLastError());
2338
2339 s2 = socket(tests[i].domain, SOCK_STREAM, 0);
2340 ok(s2 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2341
2342 rc = bind(s2, tests[i].addr_any, tests[i].addrlen);
2343 ok(rc == SOCKET_ERROR && WSAGetLastError() == WSAEADDRINUSE, "got rc %d, error %d.\n", rc, WSAGetLastError());
2344
2345 closesocket(s1);
2346 closesocket(s2);
2347
2348 winetest_pop_context();
2349 }
2350
2351 /* SO_REUSEADDR and SO_EXCLUSIVEADDRUSE are mutually exclusive. */
2352 s1 = socket(AF_INET, SOCK_STREAM, 0);
2353 ok(s1 != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2354
2355 value = 1;
2356 rc = setsockopt(s1, SOL_SOCKET, SO_REUSEADDR, (char*)&value, sizeof(value));
2357 ok(!rc, "got error %d.\n", WSAGetLastError());
2358
2359 value = 1;
2360 rc = setsockopt(s1, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&value, sizeof(value));
2361 ok(rc == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL, "got rc %d, error %d.\n", rc, WSAGetLastError());
2362
2363 value = 0;
2364 rc = setsockopt(s1, SOL_SOCKET, SO_REUSEADDR, (char*)&value, sizeof(value));
2365
2366 value = 1;
2367 rc = setsockopt(s1, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&value, sizeof(value));
2368 ok(!rc, "got error %d.\n", WSAGetLastError());
2369
2370 value = 1;
2371 rc = setsockopt(s1, SOL_SOCKET, SO_REUSEADDR, (char*)&value, sizeof(value));
2372 ok(rc == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL, "got rc %d, error %d.\n", rc, WSAGetLastError());
2373
2374 closesocket(s1);
2375
2376 /* Test SO_EXCLUSIVEADDRUSE. */
2377 for (i = 0; i < ARRAY_SIZE(tests_exclusive); ++i)
2378 {
2379 SOCKET s[2];
2380
2381 winetest_push_context("test %u", i);
2382
2383 for (j = 0; j < 2; ++j)
2384 {
2385 s[j] = socket(tests_exclusive[i].s[j].domain, SOCK_STREAM, 0);
2386 ok(s[j] != INVALID_SOCKET, "got error %d.\n", WSAGetLastError());
2387
2388 if (tests_exclusive[i].s[j].exclusive)
2389 {
2390 value = 1;
2391 rc = setsockopt(s[j], SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&value, sizeof(value));
2392 ok(!rc, "got error %d.\n", WSAGetLastError());
2393 }
2394 if (tests_exclusive[i].s[j].domain == AF_INET6)
2395 {
2396 value = 0;
2397 rc = setsockopt(s[j], IPPROTO_IPV6, IPV6_V6ONLY, (char*)&value, sizeof(value));
2398 ok(!rc, "got error %d.\n", WSAGetLastError());
2399 }
2400 }
2401 rc = bind(s[0], tests_exclusive[i].s[0].addr, tests_exclusive[i].s[0].addrlen);
2402 ok(!rc || (tests_exclusive[i].s[0].domain == AF_INET6 && WSAGetLastError() == WSAEADDRNOTAVAIL), "got error %d.\n", WSAGetLastError());
2403
2404 rc = bind(s[1], tests_exclusive[i].s[1].addr, tests_exclusive[i].s[1].addrlen);
2405
2406 if (tests_exclusive[i].error)
2407 ok(rc == SOCKET_ERROR && WSAGetLastError() == tests_exclusive[i].error,
2408 "got rc %d, error %d, expected error %d.\n", rc, WSAGetLastError(), tests_exclusive[i].error);
2409 else
2410 ok(!rc, "got error %d.\n", WSAGetLastError());
2411
2412 closesocket(s[0]);
2413 closesocket(s[1]);
2414 winetest_pop_context();
2415 }
2416 }
2417
2418 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
2419
2420 static unsigned int got_ip_pktinfo_apc;
2421
2422 static void WINAPI ip_pktinfo_apc(DWORD error, DWORD size, OVERLAPPED *overlapped, DWORD flags)
2423 {
2424 ok(error == WSAEMSGSIZE, "got error %lu\n", error);
2425 ok(size == 6, "got size %lu\n", size);
2426 ok(!flags, "got flags %#lx\n", flags);
2427 ++got_ip_pktinfo_apc;
2428 }
2429
2430 static void test_ip_pktinfo(void)
2431 {
2432 ULONG addresses[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY)};
2433 char recvbuf[10], pktbuf[512], msg[] = "HELLO";
2434 struct sockaddr_in s1addr, s2addr, s3addr;
2435 LPFN_WSARECVMSG pWSARecvMsg = NULL;
2436 unsigned int rc, yes = 1;
2437 BOOL foundhdr;
2438 DWORD dwBytes, dwSize, dwFlags;
2439 socklen_t addrlen;
2440 WSACMSGHDR *cmsg;
2441 WSAOVERLAPPED ov;
2442 WSABUF iovec[1];
2443 SOCKET s1, s2;
2444 WSAMSG hdr;
2445 int i, err;
2446
2447 memset(&ov, 0, sizeof(ov));
2448 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
2449
2450 memset(&hdr, 0x00, sizeof(hdr));
2451 s1addr.sin_family = AF_INET;
2452 s1addr.sin_port = htons(0);
2453 /* Note: s1addr.sin_addr is set below */
2454 iovec[0].buf = recvbuf;
2455 iovec[0].len = sizeof(recvbuf);
2456 hdr.name = (struct sockaddr*)&s3addr;
2457 hdr.namelen = sizeof(s3addr);
2458 hdr.lpBuffers = &iovec[0];
2459 hdr.dwBufferCount = 1;
2460 hdr.Control.buf = pktbuf;
2461 /* Note: hdr.Control.len is set below */
2462 hdr.dwFlags = 0;
2463
2464 for (i=0;i<ARRAY_SIZE(addresses);i++)
2465 {
2466 s1addr.sin_addr.s_addr = addresses[i];
2467
2468 /* Build "server" side socket */
2469 s1=socket(AF_INET, SOCK_DGRAM, 0);
2470 ok(s1 != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2471
2472 /* Obtain the WSARecvMsg function */
2473 rc = WSAIoctl(s1, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
2474 &pWSARecvMsg, sizeof(pWSARecvMsg), &dwBytes, NULL, NULL);
2475 ok(!rc, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
2476
2477 /* Setup the server side socket */
2478 rc=bind(s1, (struct sockaddr*)&s1addr, sizeof(s1addr));
2479 ok(rc != SOCKET_ERROR, "bind() failed error: %d\n", WSAGetLastError());
2480
2481 /* Build "client" side socket */
2482 addrlen = sizeof(s2addr);
2483 rc = getsockname(s1, (struct sockaddr *) &s2addr, &addrlen);
2484 ok(!rc, "failed to get address, error %u\n", WSAGetLastError());
2485 s2addr.sin_addr.s_addr = addresses[0]; /* Always target the local adapter address */
2486 s2=socket(AF_INET, SOCK_DGRAM, 0);
2487 ok(s2 != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2488
2489 /* Test an empty message header */
2490 rc=pWSARecvMsg(s1, NULL, NULL, NULL, NULL);
2491 err=WSAGetLastError();
2492 ok(rc == SOCKET_ERROR && err == WSAEFAULT, "WSARecvMsg() failed error: %d (ret = %d)\n", err, rc);
2493
2494 /* Test that when no control data arrives, a 0-length NULL-valued control buffer should succeed */
2495 SetLastError(0xdeadbeef);
2496 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2497 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2498 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
2499 hdr.Control.buf = NULL;
2500 hdr.Control.len = 0;
2501 rc=pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
2502 ok(rc == 0, "WSARecvMsg() failed error: %d\n", WSAGetLastError());
2503 hdr.Control.buf = pktbuf;
2504
2505 /* Now start IP_PKTINFO for future tests */
2506 rc=setsockopt(s1, IPPROTO_IP, IP_PKTINFO, (const char*)&yes, sizeof(yes));
2507 ok(rc == 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
2508
2509 /*
2510 * Send a packet from the client to the server and test for specifying
2511 * a short control header.
2512 */
2513 SetLastError(0xdeadbeef);
2514 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2515 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2516 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
2517 hdr.Control.len = 1;
2518 dwSize = 0xdeadbeef;
2519 rc = pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
2520 ok(rc == -1, "expected failure\n");
2521 ok(WSAGetLastError() == WSAEMSGSIZE, "got error %u\n", WSAGetLastError());
2522 todo_wine ok(dwSize == sizeof(msg), "got size %lu\n", dwSize);
2523 ok(hdr.dwFlags == MSG_CTRUNC, "got flags %#lx\n", hdr.dwFlags);
2524 hdr.dwFlags = 0; /* Reset flags */
2525
2526 /* Perform another short control header test, this time with an overlapped receive */
2527 hdr.Control.len = 1;
2528 ov.Internal = 0xdead1;
2529 ov.InternalHigh = 0xdead2;
2530 ov.Offset = 0xdead3;
2531 ov.OffsetHigh = 0xdead4;
2532 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
2533 err=WSAGetLastError();
2534 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
2535 SetLastError(0xdeadbeef);
2536 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2537 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2538 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
2539 ok(!WaitForSingleObject(ov.hEvent, 100), "wait failed\n");
2540 ok((NTSTATUS)ov.Internal == STATUS_BUFFER_OVERFLOW, "got status %#lx\n", (NTSTATUS)ov.Internal);
2541 ok(ov.InternalHigh == sizeof(msg), "got size %Iu\n", ov.InternalHigh);
2542 ok(ov.Offset == 0xdead3, "got Offset %lu\n", ov.Offset);
2543 ok(ov.OffsetHigh == 0xdead4, "got OffsetHigh %lu\n", ov.OffsetHigh);
2544 dwFlags = 0xdeadbeef;
2545 rc = WSAGetOverlappedResult(s1, &ov, &dwSize, FALSE, &dwFlags);
2546 ok(!rc, "expected failure\n");
2547 ok(WSAGetLastError() == WSAEMSGSIZE, "got error %u\n", WSAGetLastError());
2548 ok(dwSize == sizeof(msg), "got size %lu\n", dwSize);
2549 todo_wine ok(dwFlags == 0xdeadbeef, "got flags %#lx\n", dwFlags);
2550 ok(hdr.dwFlags == MSG_CTRUNC,
2551 "WSARecvMsg() overlapped operation set unexpected flags %ld.\n", hdr.dwFlags);
2552 hdr.dwFlags = 0; /* Reset flags */
2553
2554 /* And with an APC. */
2555
2556 SetLastError(0xdeadbeef);
2557 rc = sendto(s2, msg, sizeof(msg), 0, (struct sockaddr *)&s2addr, sizeof(s2addr));
2558 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2559 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
2560 hdr.Control.len = 1;
2561
2562 ov.Internal = 0xdead1;
2563 ov.InternalHigh = 0xdead2;
2564 ov.Offset = 0xdead3;
2565 ov.OffsetHigh = 0xdead4;
2566 dwSize = 0xdeadbeef;
2567 rc = pWSARecvMsg(s1, &hdr, NULL, &ov, ip_pktinfo_apc);
2568 ok(rc == -1, "expected failure\n");
2569 todo_wine ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
2570
2571 rc = SleepEx(1000, TRUE);
2572 ok(rc == WAIT_IO_COMPLETION, "got %d\n", rc);
2573 ok(got_ip_pktinfo_apc == 1, "apc was called %u times\n", got_ip_pktinfo_apc);
2574 ok(hdr.dwFlags == MSG_CTRUNC, "got flags %#lx\n", hdr.dwFlags);
2575 got_ip_pktinfo_apc = 0;
2576
2577 hdr.dwFlags = 0; /* Reset flags */
2578
2579 /*
2580 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
2581 * on the server end and check that the returned packet matches what was sent.
2582 */
2583 hdr.Control.len = sizeof(pktbuf);
2584 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
2585 err=WSAGetLastError();
2586 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
2587 ok(hdr.Control.len == sizeof(pktbuf),
2588 "WSARecvMsg() control length mismatch (%ld != sizeof pktbuf).\n", hdr.Control.len);
2589 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2590 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2591 ok(!WaitForSingleObject(ov.hEvent, 100), "wait failed\n");
2592 dwSize = 0;
2593 WSAGetOverlappedResult(s1, &ov, &dwSize, FALSE, NULL);
2594 ok(dwSize == sizeof(msg),
2595 "WSARecvMsg() buffer length does not match transmitted data!\n");
2596 ok(strncmp(iovec[0].buf, msg, sizeof(msg)) == 0,
2597 "WSARecvMsg() buffer does not match transmitted data!\n");
2598 ok(hdr.Control.len == IP_PKTINFO_LEN,
2599 "WSARecvMsg() control length mismatch (%ld).\n", hdr.Control.len);
2600
2601 /* Test for the expected IP_PKTINFO return information. */
2602 foundhdr = FALSE;
2603 for (cmsg = WSA_CMSG_FIRSTHDR(&hdr); cmsg != NULL; cmsg = WSA_CMSG_NXTHDR(&hdr, cmsg))
2604 {
2605 if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO)
2606 {
2607 struct in_pktinfo *pi = (struct in_pktinfo *)WSA_CMSG_DATA(cmsg);
2608
2609 ok(pi->ipi_addr.s_addr == s2addr.sin_addr.s_addr, "destination ip mismatch!\n");
2610 foundhdr = TRUE;
2611 }
2612 }
2613 ok(foundhdr, "IP_PKTINFO header information was not returned!\n");
2614
2615 closesocket(s2);
2616 closesocket(s1);
2617 }
2618
2619 CloseHandle(ov.hEvent);
2620 }
2621
2622 static void test_ipv4_cmsg(void)
2623 {
2624 static const DWORD off = 0;
2625 static const DWORD on = 1;
2626 SOCKADDR_IN localhost = {0};
2627 SOCKET client, server;
2628 char payload[] = "HELLO";
2629 char control[100];
2630 WSABUF payload_buf = {sizeof(payload), payload};
2631 WSAMSG msg = {NULL, 0, &payload_buf, 1, {sizeof(control), control}, 0};
2632 WSACMSGHDR *header = (WSACMSGHDR *)control;
2633 LPFN_WSARECVMSG pWSARecvMsg;
2634 INT *int_data = (INT *)WSA_CMSG_DATA(header);
2635 IN_PKTINFO *pkt_info = (IN_PKTINFO *)WSA_CMSG_DATA(header);
2636 DWORD count, state;
2637 int rc;
2638
2639 localhost.sin_family = AF_INET;
2640 localhost.sin_port = htons(SERVERPORT);
2641 inet_pton(AF_INET, "127.0.0.1", &localhost.sin_addr);
2642
2643 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
2644 ok(client != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2645 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
2646 ok(server != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2647
2648 rc = bind(server, (SOCKADDR *)&localhost, sizeof(localhost));
2649 ok(rc != SOCKET_ERROR, "bind failed, error %u\n", WSAGetLastError());
2650 rc = connect(client, (SOCKADDR *)&localhost, sizeof(localhost));
2651 ok(rc != SOCKET_ERROR, "connect failed, error %u\n", WSAGetLastError());
2652
2653 rc = WSAIoctl(server, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
2654 &pWSARecvMsg, sizeof(pWSARecvMsg), &count, NULL, NULL);
2655 ok(!rc, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
2656
2657 memset(control, 0, sizeof(control));
2658 msg.Control.len = sizeof(control);
2659 rc = setsockopt(server, IPPROTO_IP, IP_RECVTTL, (const char *)&on, sizeof(on));
2660 ok(!rc, "failed to set IP_RECVTTL, error %u\n", WSAGetLastError());
2661 state = 0;
2662 count = sizeof(state);
2663 rc = getsockopt(server, IPPROTO_IP, IP_RECVTTL, (char *)&state, (INT *)&count);
2664 ok(!rc, "failed to get IP_RECVTTL, error %u\n", WSAGetLastError());
2665 ok(state == 1, "expected 1, got %lu\n", state);
2666 rc = send(client, payload, sizeof(payload), 0);
2667 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2668 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2669 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2670 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2671 ok(header->cmsg_level == IPPROTO_IP, "expected IPPROTO_IP, got %i\n", header->cmsg_level);
2672 ok(header->cmsg_type == IP_TTL || broken(header->cmsg_type == IP_HOPLIMIT) /* <= win10 v1607 */,
2673 "expected IP_TTL, got %i\n", header->cmsg_type);
2674 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
2675 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(INT), header->cmsg_len);
2676 ok(*int_data >= 32, "expected at least 32, got %i\n", *int_data);
2677 setsockopt(server, IPPROTO_IP, IP_RECVTTL, (const char *)&off, sizeof(off));
2678 ok(!rc, "failed to clear IP_RECVTTL, error %u\n", WSAGetLastError());
2679
2680 memset(control, 0, sizeof(control));
2681 msg.Control.len = sizeof(control);
2682 rc = setsockopt(server, IPPROTO_IP, IP_PKTINFO, (const char *)&on, sizeof(on));
2683 ok(!rc, "failed to set IP_PKTINFO, error %u\n", WSAGetLastError());
2684 state = 0;
2685 count = sizeof(state);
2686 rc = getsockopt(server, IPPROTO_IP, IP_PKTINFO, (char *)&state, (INT *)&count);
2687 ok(!rc, "failed to get IP_PKTINFO, error %u\n", WSAGetLastError());
2688 ok(state == 1, "expected 1, got %lu\n", state);
2689 rc = send(client, payload, sizeof(payload), 0);
2690 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2691 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2692 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2693 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2694 ok(header->cmsg_level == IPPROTO_IP, "expected IPPROTO_IP, got %i\n", header->cmsg_level);
2695 ok(header->cmsg_type == IP_PKTINFO, "expected IP_PKTINFO, got %i\n", header->cmsg_type);
2696 ok(header->cmsg_len == sizeof(*header) + sizeof(IN_PKTINFO),
2697 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(IN_PKTINFO), header->cmsg_len);
2698 ok(!memcmp(&pkt_info->ipi_addr, &localhost.sin_addr, sizeof(IN_ADDR)), "expected 127.0.0.1\n");
2699 rc = setsockopt(server, IPPROTO_IP, IP_PKTINFO, (const char *)&off, sizeof(off));
2700 ok(!rc, "failed to clear IP_PKTINFO, error %u\n", WSAGetLastError());
2701
2702 memset(control, 0, sizeof(control));
2703 msg.Control.len = sizeof(control);
2704 rc = setsockopt(server, IPPROTO_IP, IP_RECVTOS, (const char *)&on, sizeof(on));
2705 ok(!rc, "failed to set IP_RECVTOS, error %u\n", WSAGetLastError());
2706 state = 0;
2707 count = sizeof(state);
2708 rc = getsockopt(server, IPPROTO_IP, IP_RECVTOS, (char *)&state, (INT *)&count);
2709 ok(!rc, "failed to get IP_RECVTOS, error %u\n", WSAGetLastError());
2710 ok(state == 1, "expected 1, got %lu\n", state);
2711 rc = send(client, payload, sizeof(payload), 0);
2712 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2713 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2714 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2715 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2716 ok(header->cmsg_level == IPPROTO_IP, "expected IPPROTO_IP, got %i\n", header->cmsg_level);
2717 ok(header->cmsg_type == IP_TOS || broken(header->cmsg_type == IP_TCLASS) /* <= win10 v1607 */,
2718 "expected IP_TOS, got %i\n", header->cmsg_type);
2719 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
2720 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(INT), header->cmsg_len);
2721 ok(*int_data == 0, "expected 0, got %i\n", *int_data);
2722 rc = setsockopt(server, IPPROTO_IP, IP_RECVTOS, (const char *)&off, sizeof(off));
2723 ok(!rc, "failed to clear IP_RECVTOS, error %u\n", WSAGetLastError());
2724
2725 closesocket(server);
2726 closesocket(client);
2727 }
2728
2729 static void test_ipv6_cmsg(void)
2730 {
2731 static const DWORD off = 0;
2732 static const DWORD on = 1;
2733 SOCKADDR_IN6 localhost = {0};
2734 SOCKET client, server;
2735 char payload[] = "HELLO";
2736 char control[100];
2737 WSABUF payload_buf = {sizeof(payload), payload};
2738 WSAMSG msg = {NULL, 0, &payload_buf, 1, {sizeof(control), control}, 0};
2739 WSACMSGHDR *header = (WSACMSGHDR *)control;
2740 LPFN_WSARECVMSG pWSARecvMsg;
2741 INT *int_data = (INT *)WSA_CMSG_DATA(header);
2742 IN6_PKTINFO *pkt_info = (IN6_PKTINFO *)WSA_CMSG_DATA(header);
2743 DWORD count, state;
2744 int rc;
2745
2746 localhost.sin6_family = AF_INET6;
2747 localhost.sin6_port = htons(SERVERPORT);
2748 inet_pton(AF_INET6, "::1", &localhost.sin6_addr);
2749
2750 client = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
2751 ok(client != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2752 server = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
2753 ok(server != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2754
2755 rc = bind(server, (SOCKADDR *)&localhost, sizeof(localhost));
2756 ok(rc != SOCKET_ERROR || WSAGetLastError() == WSAEADDRNOTAVAIL, "bind failed, error %u\n", WSAGetLastError());
2757 if (WSAGetLastError() == WSAEADDRNOTAVAIL)
2758 {
2759 skip("IPv6 not supported, skipping test\n");
2760 goto cleanup;
2761 }
2762 rc = connect(client, (SOCKADDR *)&localhost, sizeof(localhost));
2763 ok(rc != SOCKET_ERROR, "connect failed, error %u\n", WSAGetLastError());
2764
2765 rc = WSAIoctl(server, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
2766 &pWSARecvMsg, sizeof(pWSARecvMsg), &count, NULL, NULL);
2767 ok(!rc, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
2768
2769 memset(control, 0, sizeof(control));
2770 msg.Control.len = sizeof(control);
2771 rc = setsockopt(server, IPPROTO_IPV6, IPV6_HOPLIMIT, (const char *)&on, sizeof(on));
2772 ok(!rc, "failed to set IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2773 state = 0;
2774 count = sizeof(state);
2775 rc = getsockopt(server, IPPROTO_IPV6, IPV6_HOPLIMIT, (char *)&state, (INT *)&count);
2776 ok(!rc, "failed to get IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2777 ok(state == 1, "expected 1, got %lu\n", state);
2778 rc = send(client, payload, sizeof(payload), 0);
2779 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2780 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2781 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2782 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2783 ok(header->cmsg_level == IPPROTO_IPV6, "expected IPPROTO_IPV6, got %i\n", header->cmsg_level);
2784 ok(header->cmsg_type == IPV6_HOPLIMIT, "expected IPV6_HOPLIMIT, got %i\n", header->cmsg_type);
2785 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
2786 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(INT), header->cmsg_len);
2787 ok(*int_data >= 32, "expected at least 32, got %i\n", *int_data);
2788 setsockopt(server, IPPROTO_IPV6, IPV6_HOPLIMIT, (const char *)&off, sizeof(off));
2789 ok(!rc, "failed to clear IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2790
2791 memset(control, 0, sizeof(control));
2792 msg.Control.len = sizeof(control);
2793 rc = setsockopt(server, IPPROTO_IPV6, IPV6_PKTINFO, (const char *)&on, sizeof(on));
2794 ok(!rc, "failed to set IPV6_PKTINFO, error %u\n", WSAGetLastError());
2795 state = 0;
2796 count = sizeof(state);
2797 rc = getsockopt(server, IPPROTO_IPV6, IPV6_PKTINFO, (char *)&state, (INT *)&count);
2798 ok(!rc, "failed to get IPV6_PKTINFO, error %u\n", WSAGetLastError());
2799 ok(state == 1, "expected 1, got %lu\n", state);
2800 rc = send(client, payload, sizeof(payload), 0);
2801 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2802 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2803 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2804 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2805 ok(header->cmsg_level == IPPROTO_IPV6, "expected IPPROTO_IPV6, got %i\n", header->cmsg_level);
2806 ok(header->cmsg_type == IPV6_PKTINFO, "expected IPV6_PKTINFO, got %i\n", header->cmsg_type);
2807 ok(header->cmsg_len == sizeof(*header) + sizeof(IN6_PKTINFO),
2808 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(IN6_PKTINFO), header->cmsg_len);
2809 ok(!memcmp(&pkt_info->ipi6_addr, &localhost.sin6_addr, sizeof(IN6_ADDR)), "expected ::1\n");
2810 rc = setsockopt(server, IPPROTO_IPV6, IPV6_PKTINFO, (const char *)&off, sizeof(off));
2811 ok(!rc, "failed to clear IPV6_PKTINFO, error %u\n", WSAGetLastError());
2812
2813 memset(control, 0, sizeof(control));
2814 msg.Control.len = sizeof(control);
2815 rc = setsockopt(server, IPPROTO_IPV6, IPV6_RECVTCLASS, (const char *)&on, sizeof(on));
2816 ok(!rc, "failed to set IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
2817 state = 0;
2818 count = sizeof(state);
2819 rc = getsockopt(server, IPPROTO_IPV6, IPV6_RECVTCLASS, (char *)&state, (INT *)&count);
2820 ok(!rc, "failed to get IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
2821 ok(state == 1, "expected 1, got %lu\n", state);
2822 rc = send(client, payload, sizeof(payload), 0);
2823 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2824 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2825 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2826 ok(count == sizeof(payload), "expected length %Iu, got %lu\n", sizeof(payload), count);
2827 ok(header->cmsg_level == IPPROTO_IPV6, "expected IPPROTO_IPV6, got %i\n", header->cmsg_level);
2828 ok(header->cmsg_type == IPV6_TCLASS, "expected IPV6_TCLASS, got %i\n", header->cmsg_type);
2829 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
2830 "expected length %Iu, got %Iu\n", sizeof(*header) + sizeof(INT), header->cmsg_len);
2831 ok(*int_data == 0, "expected 0, got %i\n", *int_data);
2832 rc = setsockopt(server, IPPROTO_IPV6, IPV6_RECVTCLASS, (const char *)&off, sizeof(off));
2833 ok(!rc, "failed to clear IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
2834
2835 cleanup:
2836 closesocket(server);
2837 closesocket(client);
2838 }
2839
2840 /************* Array containing the tests to run **********/
2841
2842 #define STD_STREAM_SOCKET \
2843 SOCK_STREAM, \
2844 0, \
2845 SERVERIP, \
2846 SERVERPORT
2847
2848 static test_setup tests [] =
2849 {
2850 /* Test 0: synchronous client and server */
2851 {
2852 {
2853 STD_STREAM_SOCKET,
2854 2048,
2855 16,
2856 2
2857 },
2858 simple_server,
2859 {
2860 NULL,
2861 0,
2862 64
2863 },
2864 simple_client,
2865 {
2866 NULL,
2867 0,
2868 128
2869 }
2870 },
2871 /* Test 1: event-driven client, synchronous server */
2872 {
2873 {
2874 STD_STREAM_SOCKET,
2875 2048,
2876 16,
2877 2
2878 },
2879 simple_server,
2880 {
2881 NULL,
2882 0,
2883 64
2884 },
2885 event_client,
2886 {
2887 NULL,
2888 WSA_FLAG_OVERLAPPED,
2889 128
2890 }
2891 },
2892 /* Test 2: synchronous client, non-blocking server via select() */
2893 {
2894 {
2895 STD_STREAM_SOCKET,
2896 2048,
2897 16,
2898 2
2899 },
2900 select_server,
2901 {
2902 NULL,
2903 0,
2904 64
2905 },
2906 simple_client,
2907 {
2908 NULL,
2909 0,
2910 128
2911 }
2912 },
2913 /* Test 3: OOB client, OOB server */
2914 {
2915 {
2916 STD_STREAM_SOCKET,
2917 128,
2918 16,
2919 1
2920 },
2921 oob_server,
2922 {
2923 NULL,
2924 0,
2925 128
2926 },
2927 oob_client,
2928 {
2929 NULL,
2930 0,
2931 128
2932 }
2933 },
2934 /* Test 4: synchronous mixed client and server */
2935 {
2936 {
2937 STD_STREAM_SOCKET,
2938 2048,
2939 16,
2940 2
2941 },
2942 simple_server,
2943 {
2944 NULL,
2945 0,
2946 64
2947 },
2948 simple_mixed_client,
2949 {
2950 NULL,
2951 0,
2952 128
2953 }
2954 }
2955 };
2956
2957 static void test_UDP(void)
2958 {
2959 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
2960 possible that this test fails due to dropped packets. */
2961
2962 /* peer 0 receives data from all other peers */
2963 struct sock_info peer[NUM_UDP_PEERS];
2964 char buf[16];
2965 int ss, i, n_recv, n_sent;
2966
2967 memset (buf,0,sizeof(buf));
2968 for ( i = NUM_UDP_PEERS - 1; i >= 0; i-- ) {
2969 ok ( ( peer[i].s = socket ( AF_INET, SOCK_DGRAM, 0 ) ) != INVALID_SOCKET, "UDP: socket failed\n" );
2970
2971 peer[i].addr.sin_family = AF_INET;
2972 peer[i].addr.sin_addr.s_addr = inet_addr ( SERVERIP );
2973
2974 if ( i == 0 ) {
2975 peer[i].addr.sin_port = htons ( SERVERPORT );
2976 } else {
2977 peer[i].addr.sin_port = htons ( 0 );
2978 }
2979
2980 do_bind ( peer[i].s, (struct sockaddr *) &peer[i].addr, sizeof( peer[i].addr ) );
2981
2982 /* test getsockname() to get peer's port */
2983 ss = sizeof ( peer[i].addr );
2984 ok ( getsockname ( peer[i].s, (struct sockaddr *) &peer[i].addr, &ss ) != SOCKET_ERROR, "UDP: could not getsockname()\n" );
2985 ok ( peer[i].addr.sin_port != htons ( 0 ), "UDP: bind() did not associate port\n" );
2986 }
2987
2988 /* test getsockname() */
2989 ok ( peer[0].addr.sin_port == htons ( SERVERPORT ), "UDP: getsockname returned incorrect peer port\n" );
2990
2991 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
2992 /* send client's ip */
2993 memcpy( buf, &peer[i].addr.sin_port, sizeof(peer[i].addr.sin_port) );
2994 n_sent = sendto ( peer[i].s, buf, sizeof(buf), 0, (struct sockaddr*) &peer[0].addr, sizeof(peer[0].addr) );
2995 ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
2996 }
2997
2998 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
2999 n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0,(struct sockaddr *) &peer[0].peer, &ss );
3000 ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
3001 ok ( memcmp ( &peer[0].peer.sin_port, buf, sizeof(peer[0].addr.sin_port) ) == 0, "UDP: port numbers do not match\n" );
3002 }
3003 }
3004
3005 static void test_WSASocket(void)
3006 {
3007 SOCKET sock = INVALID_SOCKET;
3008 WSAPROTOCOL_INFOA *pi;
3009 int wsaproviders[] = {IPPROTO_TCP, IPPROTO_IP};
3010 int autoprotocols[] = {IPPROTO_TCP, IPPROTO_UDP};
3011 int items, err, size, socktype, i, j;
3012 DWORD pi_size;
3013
3014 static const struct
3015 {
3016 int family, type, protocol;
3017 DWORD error;
3018 int ret_family, ret_type, ret_protocol;
3019 int ret_family_alt;
3020 }
3021 tests[] =
3022 {
3023 /* 0 */
3024 {0xdead, SOCK_STREAM, IPPROTO_TCP, WSAEAFNOSUPPORT},
3025 {-1, SOCK_STREAM, IPPROTO_TCP, WSAEAFNOSUPPORT},
3026 {AF_INET, 0xdead, IPPROTO_TCP, WSAESOCKTNOSUPPORT},
3027 {AF_INET, -1, IPPROTO_TCP, WSAESOCKTNOSUPPORT},
3028 {AF_INET, SOCK_STREAM, 0xdead, WSAEPROTONOSUPPORT},
3029 {AF_INET, SOCK_STREAM, -1, WSAEPROTONOSUPPORT},
3030 {0xdead, 0xdead, IPPROTO_TCP, WSAESOCKTNOSUPPORT},
3031 {0xdead, SOCK_STREAM, 0xdead, WSAEAFNOSUPPORT},
3032 {AF_INET, 0xdead, 0xdead, WSAESOCKTNOSUPPORT},
3033 {0xdead, SOCK_STREAM, IPPROTO_UDP, WSAEAFNOSUPPORT},
3034
3035 /* 10 */
3036 {AF_INET, SOCK_STREAM, 0, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP},
3037 {AF_INET, SOCK_DGRAM, 0, 0, AF_INET, SOCK_DGRAM, IPPROTO_UDP},
3038 {AF_INET, 0xdead, 0, WSAESOCKTNOSUPPORT},
3039 {AF_INET, 0, IPPROTO_TCP, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP},
3040 {AF_INET, 0, IPPROTO_UDP, 0, AF_INET, SOCK_DGRAM, IPPROTO_UDP},
3041 {AF_INET, 0, 0xdead, WSAEPROTONOSUPPORT},
3042 {AF_INET, 0, 0, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP},
3043 {AF_INET, SOCK_STREAM, IPPROTO_UDP, WSAEPROTONOSUPPORT},
3044 {AF_INET, SOCK_DGRAM, IPPROTO_TCP, WSAEPROTONOSUPPORT},
3045
3046 /* 19 */
3047 {AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP, AF_INET6 /* win11 */},
3048 {AF_UNSPEC, SOCK_STREAM, 0xdead, WSAEPROTONOSUPPORT},
3049 {AF_UNSPEC, 0xdead, IPPROTO_UDP, WSAESOCKTNOSUPPORT},
3050 {AF_UNSPEC, SOCK_STREAM, 0, WSAEINVAL},
3051 {AF_UNSPEC, SOCK_DGRAM, 0, WSAEINVAL},
3052 {AF_UNSPEC, 0xdead, 0, WSAEINVAL},
3053 {AF_UNSPEC, 0, IPPROTO_TCP, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP, AF_INET6 /* win11 */},
3054 {AF_UNSPEC, 0, IPPROTO_UDP, 0, AF_INET, SOCK_DGRAM, IPPROTO_UDP, AF_INET6 /* win11 */},
3055 {AF_UNSPEC, 0, 0xdead, WSAEPROTONOSUPPORT},
3056 {AF_UNSPEC, 0, 0, WSAEINVAL},
3057 };
3058
3059 for (i = 0; i < ARRAY_SIZE(tests); ++i)
3060 {
3061 SetLastError( 0xdeadbeef );
3062 sock = WSASocketA( tests[i].family, tests[i].type, tests[i].protocol, NULL, 0, 0 );
3063 todo_wine_if (i == 7)
3064 ok(WSAGetLastError() == tests[i].error, "Test %u: got wrong error %u\n", i, WSAGetLastError());
3065 if (tests[i].error)
3066 {
3067 ok(sock == INVALID_SOCKET, "Test %u: expected failure\n", i);
3068 }
3069 else
3070 {
3071 WSAPROTOCOL_INFOA info;
3072
3073 ok(sock != INVALID_SOCKET, "Text %u: expected success\n", i);
3074
3075 size = sizeof(info);
3076 err = getsockopt( sock, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *)&info, &size );
3077 ok(!err, "Test %u: getsockopt failed, error %u\n", i, WSAGetLastError());
3078 ok(info.iAddressFamily == tests[i].ret_family ||
3079 (tests[i].ret_family_alt && info.iAddressFamily == tests[i].ret_family_alt),
3080 "Test %u: got wrong family %d\n", i, info.iAddressFamily);
3081 ok(info.iSocketType == tests[i].ret_type, "Test %u: got wrong type %d\n", i, info.iSocketType);
3082 ok(info.iProtocol == tests[i].ret_protocol, "Test %u: got wrong protocol %d\n", i, info.iProtocol);
3083
3084 closesocket( sock );
3085 }
3086 }
3087
3088 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
3089 * to avoid a crash on win98.
3090 */
3091 pi_size = 0;
3092 items = WSAEnumProtocolsA(wsaproviders, NULL, &pi_size);
3093 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
3094 items);
3095 err = WSAGetLastError();
3096 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
3097 err, WSAENOBUFS);
3098
3099 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
3100 ok(pi != NULL, "Failed to allocate memory\n");
3101
3102 items = WSAEnumProtocolsA(wsaproviders, pi, &pi_size);
3103 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
3104 WSAGetLastError());
3105
3106 if (items == 0) {
3107 skip("No protocols enumerated.\n");
3108 HeapFree(GetProcessHeap(), 0, pi);
3109 return;
3110 }
3111
3112 sock = WSASocketA(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
3113 FROM_PROTOCOL_INFO, &pi[0], 0, 0);
3114 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3115 WSAGetLastError());
3116 closesocket(sock);
3117
3118 /* find what parameters are used first: plain parameters or protocol info struct */
3119 pi[0].iProtocol = -1;
3120 pi[0].iSocketType = -1;
3121 pi[0].iAddressFamily = -1;
3122 ok(WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0) == INVALID_SOCKET,
3123 "WSASocketA should have failed\n");
3124 err = WSAGetLastError();
3125 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
3126
3127 pi[0].iProtocol = 0;
3128 pi[0].iSocketType = 0;
3129 pi[0].iAddressFamily = 0;
3130 sock = WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0);
3131 if(sock != INVALID_SOCKET)
3132 {
3133 win_skip("must work only in OS <= 2003\n");
3134 closesocket(sock);
3135 }
3136 else
3137 {
3138 err = WSAGetLastError();
3139 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
3140 }
3141
3142 pi[0].iProtocol = IPPROTO_UDP;
3143 pi[0].iSocketType = SOCK_DGRAM;
3144 pi[0].iAddressFamily = AF_INET;
3145 sock = WSASocketA(0, 0, 0, &pi[0], 0, 0);
3146 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3147 WSAGetLastError());
3148
3149 size = sizeof(socktype);
3150 socktype = 0xdead;
3151 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3152 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
3153 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
3154 SOCK_DGRAM, socktype);
3155
3156 socktype = SOCK_STREAM;
3157 WSASetLastError(0xdeadbeef);
3158 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
3159 ok(err == -1, "expected failure\n");
3160 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
3161
3162 socktype = SOCK_DGRAM;
3163 WSASetLastError(0xdeadbeef);
3164 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
3165 ok(err == -1, "expected failure\n");
3166 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
3167
3168 closesocket(sock);
3169
3170 sock = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, &pi[0], 0, 0);
3171 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3172 WSAGetLastError());
3173
3174 size = sizeof(socktype);
3175 socktype = 0xdead;
3176 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3177 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
3178 ok(socktype == SOCK_STREAM, "Wrong socket type, expected %d received %d\n",
3179 SOCK_STREAM, socktype);
3180
3181 socktype = SOCK_STREAM;
3182 WSASetLastError(0xdeadbeef);
3183 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
3184 ok(err == -1, "expected failure\n");
3185 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
3186
3187 socktype = SOCK_DGRAM;
3188 WSASetLastError(0xdeadbeef);
3189 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
3190 ok(err == -1, "expected failure\n");
3191 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
3192
3193 closesocket(sock);
3194
3195 HeapFree(GetProcessHeap(), 0, pi);
3196
3197 pi_size = 0;
3198 items = WSAEnumProtocolsA(NULL, NULL, &pi_size);
3199 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
3200 items);
3201 err = WSAGetLastError();
3202 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
3203 err, WSAENOBUFS);
3204
3205 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
3206 ok(pi != NULL, "Failed to allocate memory\n");
3207
3208 items = WSAEnumProtocolsA(NULL, pi, &pi_size);
3209 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
3210 WSAGetLastError());
3211
3212 /* when no protocol and socket type are specified the first entry
3213 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
3214 * is returned */
3215 sock = WSASocketA(AF_INET, 0, 0, NULL, 0, 0);
3216 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3217 WSAGetLastError());
3218
3219 size = sizeof(socktype);
3220 socktype = 0xdead;
3221 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3222 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3223 for(i = 0; i < items; i++)
3224 {
3225 if(pi[i].dwProviderFlags & PFL_MATCHES_PROTOCOL_ZERO)
3226 {
3227 ok(socktype == pi[i].iSocketType, "Wrong socket type, expected %d received %d\n",
3228 pi[i].iSocketType, socktype);
3229 break;
3230 }
3231 }
3232 ok(i != items, "Creating a socket without protocol and socket type didn't work\n");
3233 closesocket(sock);
3234
3235 /* when no socket type is specified the first entry from WSAEnumProtocols
3236 * that matches the protocol is returned */
3237 for (i = 0; i < ARRAY_SIZE(autoprotocols); i++)
3238 {
3239 sock = WSASocketA(0, 0, autoprotocols[i], NULL, 0, 0);
3240 ok(sock != INVALID_SOCKET, "Failed to create socket for protocol %d, received %d\n",
3241 autoprotocols[i], WSAGetLastError());
3242
3243 size = sizeof(socktype);
3244 socktype = 0xdead;
3245 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3246 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3247
3248 for (err = 1, j = 0; j < items; j++)
3249 {
3250 if (pi[j].iProtocol == autoprotocols[i])
3251 {
3252 ok(pi[j].iSocketType == socktype, "expected %d, got %d\n", socktype, pi[j].iSocketType);
3253 err = 0;
3254 break;
3255 }
3256 }
3257 ok(!err, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols[i]);
3258
3259 closesocket(sock);
3260 }
3261
3262 HeapFree(GetProcessHeap(), 0, pi);
3263
3264 SetLastError(0xdeadbeef);
3265 /* starting on vista the socket function returns error during the socket
3266 creation and no longer in the socket operations (sendto, readfrom) */
3267 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
3268 if (sock == INVALID_SOCKET)
3269 {
3270 err = WSAGetLastError();
3271 ok(err == WSAEACCES, "Expected 10013, received %d\n", err);
3272 skip("SOCK_RAW is not supported\n");
3273 }
3274 else
3275 {
3276 WSAPROTOCOL_INFOW info;
3277
3278 size = sizeof(socktype);
3279 socktype = 0xdead;
3280 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3281 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3282 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
3283 SOCK_RAW, socktype);
3284
3285 size = sizeof(info);
3286 err = getsockopt(sock, SOL_SOCKET, SO_PROTOCOL_INFOW, (char *) &info, &size);
3287 ok(!err,"got error %d\n", WSAGetLastError());
3288 /* Protocol name in info.szProtocol is not entirely consistent across Windows versions and
3289 * locales, so not testing it. */
3290 ok(info.iAddressFamily == AF_INET, "got iAddressFamily %d.\n", info.iAddressFamily);
3291 ok(info.iSocketType == SOCK_RAW, "got iSocketType %d.\n", info.iSocketType);
3292 ok(info.iMaxSockAddr == 0x10, "got iMaxSockAddr %d.\n", info.iMaxSockAddr);
3293 ok(info.iMinSockAddr == 0x10, "got iMinSockAddr %d.\n", info.iMinSockAddr);
3294 todo_wine ok(!info.iProtocol, "got iProtocol %d.\n", info.iProtocol);
3295 ok(info.iProtocolMaxOffset == 255, "got iProtocol %d.\n", info.iProtocolMaxOffset);
3296 ok(info.dwProviderFlags == (PFL_MATCHES_PROTOCOL_ZERO | PFL_HIDDEN), "got dwProviderFlags %#lx.\n",
3297 info.dwProviderFlags);
3298 ok(info.dwServiceFlags1 == (XP1_IFS_HANDLES | XP1_SUPPORT_BROADCAST | XP1_SUPPORT_MULTIPOINT
3299 | XP1_MESSAGE_ORIENTED | XP1_CONNECTIONLESS), "got dwServiceFlags1 %#lx.\n",
3300 info.dwServiceFlags1);
3301
3302 closesocket(sock);
3303
3304 sock = WSASocketA(0, 0, IPPROTO_RAW, NULL, 0, 0);
3305 if (sock != INVALID_SOCKET)
3306 {
3307 size = sizeof(socktype);
3308 socktype = 0xdead;
3309 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3310 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3311 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
3312 SOCK_RAW, socktype);
3313 closesocket(sock);
3314
3315 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_TCP, NULL, 0, 0);
3316 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3317 WSAGetLastError());
3318 size = sizeof(socktype);
3319 socktype = 0xdead;
3320 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3321 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3322 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
3323 SOCK_RAW, socktype);
3324 closesocket(sock);
3325 }
3326 else if (WSAGetLastError() == WSAEACCES)
3327 skip("SOCK_RAW is not available\n");
3328 else
3329 ok(0, "Failed to create socket: %d\n", WSAGetLastError());
3330
3331 }
3332
3333 /* IPX socket tests */
3334
3335 SetLastError(0xdeadbeef);
3336 sock = WSASocketA(AF_IPX, SOCK_DGRAM, NSPROTO_IPX, NULL, 0, 0);
3337 if (sock == INVALID_SOCKET)
3338 {
3339 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError());
3340 skip("IPX is not supported\n");
3341 }
3342 else
3343 {
3344 WSAPROTOCOL_INFOA info;
3345 closesocket(sock);
3346
3347 sock = WSASocketA(0, 0, NSPROTO_IPX, NULL, 0, 0);
3348 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3349 WSAGetLastError());
3350
3351 size = sizeof(socktype);
3352 socktype = 0xdead;
3353 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3354 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
3355 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
3356 SOCK_DGRAM, socktype);
3357
3358 /* check socket family, type and protocol */
3359 size = sizeof(WSAPROTOCOL_INFOA);
3360 err = getsockopt(sock, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &info, &size);
3361 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
3362 ok(info.iProtocol == NSPROTO_IPX, "expected protocol %d, received %d\n",
3363 NSPROTO_IPX, info.iProtocol);
3364 ok(info.iAddressFamily == AF_IPX, "expected family %d, received %d\n",
3365 AF_IPX, info.iProtocol);
3366 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
3367 SOCK_DGRAM, info.iSocketType);
3368 closesocket(sock);
3369
3370 /* SOCK_STREAM does not support NSPROTO_IPX */
3371 SetLastError(0xdeadbeef);
3372 ok(WSASocketA(AF_IPX, SOCK_STREAM, NSPROTO_IPX, NULL, 0, 0) == INVALID_SOCKET,
3373 "WSASocketA should have failed\n");
3374 err = WSAGetLastError();
3375 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
3376
3377 /* test extended IPX support - that is adding any number between 0 and 255
3378 * to the IPX protocol value will make it be used as IPX packet type */
3379 for(i = 0;i <= 255;i += 17)
3380 {
3381 SetLastError(0xdeadbeef);
3382 sock = WSASocketA(0, 0, NSPROTO_IPX + i, NULL, 0, 0);
3383 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
3384 WSAGetLastError());
3385
3386 size = sizeof(int);
3387 socktype = -1;
3388 err = getsockopt(sock, NSPROTO_IPX, IPX_PTYPE, (char *) &socktype, &size);
3389 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
3390 ok(socktype == i, "Wrong IPX packet type, expected %d received %d\n",
3391 i, socktype);
3392
3393 closesocket(sock);
3394 }
3395 }
3396 }
3397
3398 static void test_WSADuplicateSocket(void)
3399 {
3400 SOCKET source, dupsock;
3401 WSAPROTOCOL_INFOA info;
3402 DWORD err;
3403 struct sockaddr_in addr;
3404 int socktype, size, addrsize, ret;
3405 char teststr[] = "TEST", buffer[16];
3406
3407 source = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
3408 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3409
3410 /* test invalid parameters */
3411 SetLastError(0xdeadbeef);
3412 ok(WSADuplicateSocketA(0, 0, NULL), "WSADuplicateSocketA should have failed\n");
3413 err = WSAGetLastError();
3414 ok(err == WSAENOTSOCK, "expected 10038, received %ld\n", err);
3415
3416 SetLastError(0xdeadbeef);
3417 ok(WSADuplicateSocketA(source, 0, NULL),
3418 "WSADuplicateSocketA should have failed\n");
3419 err = WSAGetLastError();
3420 ok(err == WSAEINVAL, "expected 10022, received %ld\n", err);
3421
3422 SetLastError(0xdeadbeef);
3423 ok(WSADuplicateSocketA(source, ~0, &info),
3424 "WSADuplicateSocketA should have failed\n");
3425 err = WSAGetLastError();
3426 ok(err == WSAEINVAL, "expected 10022, received %ld\n", err);
3427
3428 SetLastError(0xdeadbeef);
3429 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info),
3430 "WSADuplicateSocketA should have failed\n");
3431 err = WSAGetLastError();
3432 ok(err == WSAENOTSOCK, "expected 10038, received %ld\n", err);
3433
3434 SetLastError(0xdeadbeef);
3435 ok(WSADuplicateSocketA(source, GetCurrentProcessId(), NULL),
3436 "WSADuplicateSocketA should have failed\n");
3437 err = WSAGetLastError();
3438 ok(err == WSAEFAULT, "expected 10014, received %ld\n", err);
3439
3440 /* test returned structure */
3441 memset(&info, 0, sizeof(info));
3442 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
3443 "WSADuplicateSocketA should have worked\n");
3444
3445 ok(info.iProtocol == IPPROTO_TCP, "expected protocol %d, received %d\n",
3446 IPPROTO_TCP, info.iProtocol);
3447 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
3448 AF_INET, info.iProtocol);
3449 ok(info.iSocketType == SOCK_STREAM, "expected type %d, received %d\n",
3450 SOCK_STREAM, info.iSocketType);
3451
3452 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
3453 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3454
3455 closesocket(dupsock);
3456 closesocket(source);
3457
3458 /* create a socket, bind it, duplicate it then send data on source and
3459 * receive in the duplicated socket */
3460 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
3461 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3462
3463 memset(&info, 0, sizeof(info));
3464 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
3465 "WSADuplicateSocketA should have worked\n");
3466
3467 ok(info.iProtocol == IPPROTO_UDP, "expected protocol %d, received %d\n",
3468 IPPROTO_UDP, info.iProtocol);
3469 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
3470 AF_INET, info.iProtocol);
3471 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
3472 SOCK_DGRAM, info.iSocketType);
3473
3474 memset(&addr, 0, sizeof(addr));
3475 addr.sin_family = AF_INET;
3476 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
3477 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
3478 "bind should have worked\n");
3479
3480 /* read address to find out the port number to be used in sendto */
3481 memset(&addr, 0, sizeof(addr));
3482 addrsize = sizeof(addr);
3483 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
3484 "getsockname should have worked\n");
3485 ok(addr.sin_port, "socket port should be != 0\n");
3486
3487 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
3488 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3489
3490 size = sizeof(int);
3491 ret = getsockopt(dupsock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
3492 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
3493 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
3494 SOCK_DGRAM, socktype);
3495
3496 set_blocking(source, TRUE);
3497
3498 /* send data on source socket */
3499 addrsize = sizeof(addr);
3500 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
3501 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
3502
3503 /* receive on duplicated socket */
3504 addrsize = sizeof(addr);
3505 memset(buffer, 0, sizeof(buffer));
3506 size = recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize);
3507 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
3508 buffer[sizeof(teststr) - 1] = 0;
3509 ok(!strcmp(buffer, teststr), "expected '%s', received '%s'\n", teststr, buffer);
3510
3511 closesocket(dupsock);
3512 closesocket(source);
3513
3514 /* show that the source socket need to be bound before the duplicated
3515 * socket is created */
3516 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
3517 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3518
3519 memset(&info, 0, sizeof(info));
3520 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
3521 "WSADuplicateSocketA should have worked\n");
3522
3523 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
3524 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
3525
3526 memset(&addr, 0, sizeof(addr));
3527 addr.sin_family = AF_INET;
3528 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
3529 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
3530 "bind should have worked\n");
3531
3532 /* read address to find out the port number to be used in sendto */
3533 memset(&addr, 0, sizeof(addr));
3534 addrsize = sizeof(addr);
3535 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
3536 "getsockname should have worked\n");
3537 ok(addr.sin_port, "socket port should be != 0\n");
3538
3539 set_blocking(source, TRUE);
3540
3541 addrsize = sizeof(addr);
3542 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
3543 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
3544
3545 SetLastError(0xdeadbeef);
3546 addrsize = sizeof(addr);
3547 memset(buffer, 0, sizeof(buffer));
3548 todo_wine {
3549 ok(recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize) == -1,
3550 "recvfrom should have failed\n");
3551 err = WSAGetLastError();
3552 ok(err == WSAEINVAL, "expected 10022, received %ld\n", err);
3553 }
3554
3555 closesocket(dupsock);
3556 closesocket(source);
3557 }
3558
3559 static void test_WSAConnectByName(void)
3560 {
3561 SOCKET s;
3562 SOCKADDR_IN local_addr = {0}, remote_addr = {0},
3563 sock_addr = {0}, peer_addr = {0};
3564 DWORD local_len, remote_len, conn_ctx;
3565 int ret, err, sock_len, peer_len;
3566 WSAOVERLAPPED overlap;
3567 struct addrinfo *first_addrinfo, first_hints;
3568
3569 conn_ctx = TRUE;
3570
3571 /* First call of getaddrinfo fails on w8adm */
3572 first_addrinfo = NULL;
3573 memset(&first_hints, 0, sizeof(struct addrinfo));
3574 first_hints.ai_socktype = SOCK_STREAM;
3575 first_hints.ai_family = AF_INET;
3576 first_hints.ai_protocol = IPPROTO_TCP;
3577 getaddrinfo("winehq.org", "http", &first_hints, &first_addrinfo);
3578 if (first_addrinfo)
3579 freeaddrinfo(first_addrinfo);
3580 SetLastError(0xdeadbeef);
3581
3582 /* Fill all fields */
3583 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3584 local_len = remote_len = sizeof(SOCKADDR_IN);
3585 ret = WSAConnectByNameA(s, "winehq.org", "http", &local_len, (struct sockaddr *)&local_addr,
3586 &remote_len, (struct sockaddr *)&remote_addr, NULL, NULL);
3587 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3588 setsockopt(s, SOL_SOCKET, SO_UPDATE_CONNECT_CONTEXT, (char *)&conn_ctx, sizeof(DWORD));
3589 sock_len = peer_len = sizeof(SOCKADDR_IN);
3590 ret = getsockname(s, (struct sockaddr *)&sock_addr, &sock_len);
3591 ok(!ret, "getsockname should have succeeded, error %u\n", WSAGetLastError());
3592 ret = getpeername(s, (struct sockaddr *)&peer_addr, &peer_len);
3593 ok(!ret, "getpeername should have succeeded, error %u\n", WSAGetLastError());
3594 ok(sock_len == sizeof(SOCKADDR_IN), "got sockname size of %d\n", sock_len);
3595 ok(peer_len == sizeof(SOCKADDR_IN), "got peername size of %d\n", peer_len);
3596 ok(local_len == sizeof(SOCKADDR_IN), "got local size of %lu\n", local_len);
3597 ok(remote_len == sizeof(SOCKADDR_IN), "got remote size of %lu\n", remote_len);
3598 ok(!local_addr.sin_port, "local_addr has non-zero sin_port: %hu.\n", local_addr.sin_port);
3599 ok(!memcmp(&sock_addr.sin_addr, &local_addr.sin_addr, sizeof(struct in_addr)),
3600 "local_addr did not receive data.\n");
3601 ok(!memcmp(&peer_addr, &remote_addr, sizeof(SOCKADDR_IN)), "remote_addr did not receive data.\n");
3602 closesocket(s);
3603
3604 /* Passing NULL length but a pointer to a sockaddr */
3605 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3606 local_len = remote_len = sizeof(SOCKADDR_IN);
3607 memset(&local_addr, 0, sizeof(SOCKADDR_IN));
3608 memset(&remote_addr, 0, sizeof(SOCKADDR_IN));
3609 memset(&sock_addr, 0, sizeof(SOCKADDR_IN));
3610 memset(&peer_addr, 0, sizeof(SOCKADDR_IN));
3611 ret = WSAConnectByNameA(s, "winehq.org", "http", NULL, (struct sockaddr *)&local_addr,
3612 NULL, (struct sockaddr *)&remote_addr, NULL, NULL);
3613 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3614 setsockopt(s, SOL_SOCKET, SO_UPDATE_CONNECT_CONTEXT, (char *)&conn_ctx, sizeof(DWORD));
3615 sock_len = peer_len = sizeof(SOCKADDR_IN);
3616 ret = getsockname(s, (struct sockaddr *)&sock_addr, &sock_len);
3617 ok(!ret, "getsockname should have succeeded, error %u\n", WSAGetLastError());
3618 ret = getpeername(s, (struct sockaddr *)&peer_addr, &peer_len);
3619 ok(!ret, "getpeername should have succeeded, error %u\n", WSAGetLastError());
3620 ok(sock_len == sizeof(SOCKADDR_IN), "got sockname size of %d\n", sock_len);
3621 ok(peer_len == sizeof(SOCKADDR_IN), "got peername size of %d\n", peer_len);
3622 ok(!local_addr.sin_family, "local_addr received data.\n");
3623 ok(!remote_addr.sin_family, "remote_addr received data.\n");
3624 closesocket(s);
3625
3626 /* Passing NULLs for node or service */
3627 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3628 ret = WSAConnectByNameA(s, NULL, "http", NULL, NULL, NULL, NULL, NULL, NULL);
3629 err = WSAGetLastError();
3630 ok(!ret, "WSAConnectByNameA should have failed\n");
3631 ok(err == WSAEINVAL, "expected error %u (WSAEINVAL), got %u\n", WSAEINVAL, err);
3632 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3633 closesocket(s);
3634 ret = WSAConnectByNameA(s, "winehq.org", NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3635 err = WSAGetLastError();
3636 ok(!ret, "WSAConnectByNameA should have failed\n");
3637 ok(err == WSAEINVAL, "expected error %u (WSAEINVAL), got %u\n", WSAEINVAL, err);
3638 closesocket(s);
3639
3640 /* Passing NULL for the addresses and address lengths */
3641 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3642 ret = WSAConnectByNameA(s, "winehq.org", "http", NULL, NULL, NULL, NULL, NULL, NULL);
3643 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3644 closesocket(s);
3645
3646 /* Passing NULL for the addresses and passing correct lengths */
3647 local_len = remote_len = sizeof(SOCKADDR_IN);
3648 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3649 ret = WSAConnectByNameA(s, "winehq.org", "http", &local_len, NULL,
3650 &remote_len, NULL, NULL, NULL);
3651 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3652 ok(local_len == sizeof(SOCKADDR_IN), "local_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN),
3653 local_len);
3654 ok(remote_len == sizeof(SOCKADDR_IN), "remote_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN),
3655 remote_len);
3656 closesocket(s);
3657
3658 /* Passing addresses and passing short lengths */
3659 local_len = remote_len = 3;
3660 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3661 ret = WSAConnectByNameA(s, "winehq.org", "http", &local_len, (struct sockaddr *)&local_addr,
3662 &remote_len, (struct sockaddr *)&remote_addr, NULL, NULL);
3663 err = WSAGetLastError();
3664 ok(!ret, "WSAConnectByNameA should have failed\n");
3665 ok(err == WSAEFAULT, "expected error %u (WSAEFAULT), got %u\n", WSAEFAULT, err);
3666 ok(local_len == 3, "local_len should have been 3, got %ld\n", local_len);
3667 ok(remote_len == 3, "remote_len should have been 3, got %ld\n", remote_len);
3668 closesocket(s);
3669
3670 /* Passing addresses and passing long lengths */
3671 local_len = remote_len = 50;
3672 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3673 ret = WSAConnectByNameA(s, "winehq.org", "http", &local_len, (struct sockaddr *)&local_addr,
3674 &remote_len, (struct sockaddr *)&remote_addr, NULL, NULL);
3675 ok(ret, "WSAConnectByNameA should have succeeded, error %u\n", WSAGetLastError());
3676 ok(local_len == sizeof(SOCKADDR_IN), "local_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN),
3677 local_len);
3678 ok(remote_len == sizeof(SOCKADDR_IN), "remote_len should have been %Iu, got %ld\n", sizeof(SOCKADDR_IN),
3679 remote_len);
3680 closesocket(s);
3681
3682 /* Unknown service */
3683 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3684 ret = WSAConnectByNameA(s, "winehq.org", "nonexistentservice", NULL, NULL, NULL, NULL, NULL, NULL);
3685 err = WSAGetLastError();
3686 ok(!ret, "WSAConnectByNameA should have failed\n");
3687 ok(err == WSATYPE_NOT_FOUND, "expected error %u (WSATYPE_NOT_FOUND), got %u\n",
3688 WSATYPE_NOT_FOUND, err);
3689 closesocket(s);
3690
3691 /* Connecting with a UDP socket */
3692 s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
3693 ret = WSAConnectByNameA(s, "winehq.org", "https", NULL, NULL, NULL, NULL, NULL, NULL);
3694 err = WSAGetLastError();
3695 ok(!ret, "WSAConnectByNameA should have failed\n");
3696 ok(err == WSAEINVAL || err == WSAEFAULT, "expected error %u (WSAEINVAL) or %u (WSAEFAULT), got %u\n",
3697 WSAEINVAL, WSAEFAULT, err); /* WSAEFAULT win10 >= 1809 */
3698 closesocket(s);
3699
3700 /* Passing non-null as the reserved parameter */
3701 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3702 ret = WSAConnectByNameA(s, "winehq.org", "http", NULL, NULL, NULL, NULL, NULL, &overlap);
3703 err = WSAGetLastError();
3704 ok(!ret, "WSAConnectByNameA should have failed\n");
3705 ok(err == WSAEINVAL, "expected error %u (WSAEINVAL), got %u\n", WSAEINVAL, err);
3706 closesocket(s);
3707 }
3708
3709 static void test_WSAEnumNetworkEvents(void)
3710 {
3711 SOCKET s, s2;
3712 int sock_type[] = {SOCK_STREAM, SOCK_DGRAM, SOCK_STREAM}, i, j, k, l;
3713 struct sockaddr_in address;
3714 HANDLE event;
3715 WSANETWORKEVENTS net_events;
3716
3717 memset(&address, 0, sizeof(address));
3718 address.sin_addr.s_addr = htonl(INADDR_ANY);
3719 address.sin_family = AF_INET;
3720
3721 /* This test follows the steps from bugs 10204 and 24946 */
3722 for (l = 0; l < 2; l++)
3723 {
3724 for (i = 0; i < ARRAY_SIZE(sock_type); i++)
3725 {
3726 if (i == 2)
3727 tcp_socketpair(&s, &s2);
3728 else
3729 {
3730 s = socket(AF_INET, sock_type[i], 0);
3731 ok (s != SOCKET_ERROR, "Test[%d]: failed to create socket\n", i);
3732 ok (!bind(s, (struct sockaddr*) &address, sizeof(address)), "Test[%d]: bind failed\n", i);
3733 }
3734 event = WSACreateEvent();
3735 ok (event != NULL, "Test[%d]: failed to create event\n", i);
3736 for (j = 0; j < 5; j++) /* Repeat sometimes and the result must be the same */
3737 {
3738 /* When the TCP socket is not connected NO events will be returned.
3739 * When connected and no data pending it will get the write event.
3740 * UDP sockets don't have connections so as soon as they are bound
3741 * they can read/write data. Since nobody is sendind us data only
3742 * the write event will be returned and ONLY once.
3743 */
3744 ok (!WSAEventSelect(s, event, FD_READ | FD_WRITE), "Test[%d]: WSAEventSelect failed\n", i);
3745 memset(&net_events, 0xAB, sizeof(net_events));
3746 ok (!WSAEnumNetworkEvents(s, l == 0 ? event : NULL, &net_events),
3747 "Test[%d]: WSAEnumNetworkEvents failed\n", i);
3748 if (i >= 1 && j == 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
3749 {
3750 ok (net_events.lNetworkEvents == FD_WRITE, "Test[%d]: expected 2, got %ld\n",
3751 i, net_events.lNetworkEvents);
3752 }
3753 else
3754 {
3755 ok (net_events.lNetworkEvents == 0, "Test[%d]: expected 0, got %ld\n",
3756 i, net_events.lNetworkEvents);
3757 }
3758 for (k = 0; k < FD_MAX_EVENTS; k++)
3759 {
3760 if (net_events.lNetworkEvents & (1 << k))
3761 {
3762 ok (net_events.iErrorCode[k] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
3763 i, k, net_events.iErrorCode[k]);
3764 }
3765 else
3766 {
3767 /* Bits that are not set in lNetworkEvents MUST not be changed */
3768 ok (net_events.iErrorCode[k] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
3769 i, k, net_events.iErrorCode[k]);
3770 }
3771 }
3772 }
3773 closesocket(s);
3774 WSACloseEvent(event);
3775 if (i == 2) closesocket(s2);
3776 }
3777 }
3778 }
3779
3780 static DWORD WINAPI SelectReadThread(void *param)
3781 {
3782 select_thread_params *par = param;
3783 fd_set readfds;
3784 int ret;
3785 struct sockaddr_in addr;
3786 struct timeval select_timeout;
3787
3788 FD_ZERO(&readfds);
3789 FD_SET(par->s, &readfds);
3790 select_timeout.tv_sec=5;
3791 select_timeout.tv_usec=0;
3792 addr.sin_family = AF_INET;
3793 addr.sin_addr.s_addr = inet_addr(SERVERIP);
3794 addr.sin_port = htons(SERVERPORT);
3795
3796 do_bind(par->s, (struct sockaddr *)&addr, sizeof(addr));
3797 wsa_ok(listen(par->s, SOMAXCONN ), 0 ==, "SelectReadThread (%lx): listen failed: %d\n");
3798
3799 SetEvent(server_ready);
3800 ret = select(par->s+1, &readfds, NULL, NULL, &select_timeout);
3801 par->ReadKilled = (ret == 1);
3802
3803 return 0;
3804 }
3805
3806 static DWORD WINAPI SelectCloseThread(void *param)
3807 {
3808 SOCKET s = *(SOCKET*)param;
3809 Sleep(500);
3810 closesocket(s);
3811 return 0;
3812 }
3813
3814 static void test_errors(void)
3815 {
3816 SOCKET sock;
3817 SOCKADDR_IN SockAddr;
3818 int ret, err;
3819
3820 WSASetLastError(NO_ERROR);
3821 sock = socket(PF_INET, SOCK_STREAM, 0);
3822 ok( (sock != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3823 memset(&SockAddr, 0, sizeof(SockAddr));
3824 SockAddr.sin_family = AF_INET;
3825 SockAddr.sin_port = htons(6924);
3826 SockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
3827
3828 ret = connect(sock, (PSOCKADDR)&SockAddr, sizeof(SockAddr));
3829 ok( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got: %d\n", ret );
3830 if (ret == SOCKET_ERROR)
3831 {
3832 err = WSAGetLastError();
3833 ok( (err == WSAECONNREFUSED), "expected WSAECONNREFUSED, got: %d\n", err );
3834 }
3835
3836 {
3837 TIMEVAL timeval;
3838 fd_set set = {1, {sock}};
3839
3840 timeval.tv_sec = 0;
3841 timeval.tv_usec = 50000;
3842
3843 ret = select(1, NULL, &set, NULL, &timeval);
3844 ok( (ret == 0), "expected 0 (timeout), got: %d\n", ret );
3845 }
3846
3847 ret = closesocket(sock);
3848 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
3849 }
3850
3851 static void test_listen(void)
3852 {
3853 SOCKET fdA, fdB;
3854 int ret, acceptc, olen = sizeof(acceptc);
3855 struct sockaddr_in address;
3856
3857 memset(&address, 0, sizeof(address));
3858 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3859 address.sin_family = AF_INET;
3860 address.sin_port = htons(SERVERPORT);
3861
3862 /* invalid socket tests */
3863 SetLastError(0xdeadbeef);
3864 ok ((listen(0, 0) == SOCKET_ERROR), "listen did not fail\n");
3865 ret = WSAGetLastError();
3866 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
3867
3868 SetLastError(0xdeadbeef);
3869 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR), "listen did not fail\n");
3870 ret = WSAGetLastError();
3871 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
3872
3873 /* tcp tests */
3874 fdA = socket(AF_INET, SOCK_STREAM, 0);
3875 ok ((fdA != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3876
3877 fdB = socket(AF_INET, SOCK_STREAM, 0);
3878 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3879
3880 SetLastError(0xdeadbeef);
3881 ok ((listen(fdA, -2) == SOCKET_ERROR), "listen did not fail\n");
3882 ret = WSAGetLastError();
3883 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3884
3885 SetLastError(0xdeadbeef);
3886 ok ((listen(fdA, 1) == SOCKET_ERROR), "listen did not fail\n");
3887 ret = WSAGetLastError();
3888 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3889
3890 SetLastError(0xdeadbeef);
3891 ok ((listen(fdA, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3892 ret = WSAGetLastError();
3893 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3894
3895 ok (!bind(fdA, (struct sockaddr*) &address, sizeof(address)), "bind failed\n");
3896
3897 SetLastError(0xdeadbeef);
3898 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3899 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3900
3901 acceptc = 0xdead;
3902 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3903 ok (!ret, "getsockopt failed\n");
3904 ok (acceptc == 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc);
3905
3906 acceptc = 1;
3907 WSASetLastError(0xdeadbeef);
3908 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
3909 ok(ret == -1, "expected failure\n");
3910 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
3911
3912 acceptc = 0;
3913 WSASetLastError(0xdeadbeef);
3914 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
3915 ok(ret == -1, "expected failure\n");
3916 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
3917
3918 ok (!listen(fdA, 0), "listen failed\n");
3919 ok (!listen(fdA, SOMAXCONN), "double listen failed\n");
3920
3921 acceptc = 0xdead;
3922 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3923 ok (!ret, "getsockopt failed\n");
3924 ok (acceptc == 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc);
3925
3926 acceptc = 1;
3927 WSASetLastError(0xdeadbeef);
3928 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
3929 ok(ret == -1, "expected failure\n");
3930 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
3931
3932 acceptc = 0;
3933 WSASetLastError(0xdeadbeef);
3934 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
3935 ok(ret == -1, "expected failure\n");
3936 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
3937
3938 SetLastError(0xdeadbeef);
3939 ok ((listen(fdB, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3940 ret = WSAGetLastError();
3941 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3942
3943 ret = closesocket(fdB);
3944 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3945
3946 fdB = socket(AF_INET, SOCK_STREAM, 0);
3947 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3948
3949 SetLastError(0xdeadbeef);
3950 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3951 ret = WSAGetLastError();
3952 ok (ret == WSAEADDRINUSE, "expected 10048, received %d\n", ret);
3953
3954 ret = closesocket(fdA);
3955 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3956 ret = closesocket(fdB);
3957 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3958 }
3959
3960 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
3961 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
3962 static void test_select(void)
3963 {
3964 static char tmp_buf[1024];
3965
3966 fd_set readfds, writefds, exceptfds, *alloc_fds;
3967 SOCKET fdListen, fdRead, fdWrite, sockets[200];
3968 int ret, len;
3969 char buffer;
3970 struct timeval select_timeout;
3971 struct sockaddr_in address;
3972 select_thread_params thread_params;
3973 HANDLE thread_handle;
3974 DWORD ticks, id, old_protect;
3975 unsigned int apc_count;
3976 unsigned int maxfd, i;
3977 char *page_pair;
3978
3979 fdRead = socket(AF_INET, SOCK_STREAM, 0);
3980 ok( (fdRead != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3981 fdWrite = socket(AF_INET, SOCK_STREAM, 0);
3982 ok( (fdWrite != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3983
3984 maxfd = fdRead;
3985 if (fdWrite > maxfd)
3986 maxfd = fdWrite;
3987
3988 FD_ZERO_ALL();
3989 FD_SET_ALL(fdRead);
3990 FD_SET_ALL(fdWrite);
3991 select_timeout.tv_sec=0;
3992 select_timeout.tv_usec=0;
3993
3994 ticks = GetTickCount();
3995 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3996 ticks = GetTickCount() - ticks;
3997 ok(ret == 0, "select should not return any socket handles\n");
3998 ok(ticks < 100, "select was blocking for %lu ms\n", ticks);
3999 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
4000 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
4001 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
4002 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
4003
4004 FD_ZERO_ALL();
4005 FD_SET_ALL(fdRead);
4006 FD_SET_ALL(fdWrite);
4007 select_timeout.tv_sec=0;
4008 select_timeout.tv_usec=500;
4009
4010 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4011 ok(ret == 0, "select should not return any socket handles\n");
4012 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
4013 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
4014 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
4015 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
4016
4017 ok ((listen(fdWrite, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
4018 ret = closesocket(fdWrite);
4019 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
4020
4021 thread_params.s = fdRead;
4022 thread_params.ReadKilled = FALSE;
4023 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
4024 thread_handle = CreateThread (NULL, 0, SelectReadThread, &thread_params, 0, &id );
4025 ok ( (thread_handle != NULL), "CreateThread failed unexpectedly: %ld\n", GetLastError());
4026
4027 WaitForSingleObject (server_ready, INFINITE);
4028 Sleep(200);
4029 ret = closesocket(fdRead);
4030 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
4031
4032 WaitForSingleObject (thread_handle, 1000);
4033 ok ( thread_params.ReadKilled, "closesocket did not wake up select\n");
4034 ret = recv(fdRead, &buffer, 1, MSG_PEEK);
4035 ok( (ret == -1), "peek at closed socket expected -1 got %d\n", ret);
4036
4037 /* Test selecting invalid handles */
4038 FD_ZERO_ALL();
4039
4040 SetLastError(0);
4041 ret = select(maxfd+1, 0, 0, 0, &select_timeout);
4042 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4043 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
4044
4045 SetLastError(0);
4046 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4047 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4048 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
4049
4050 FD_SET(INVALID_SOCKET, &readfds);
4051 SetLastError(0);
4052 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4053 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4054 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
4055 ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
4056
4057 FD_ZERO(&readfds);
4058 FD_SET(INVALID_SOCKET, &writefds);
4059 SetLastError(0);
4060 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4061 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4062 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
4063 ok ( !FD_ISSET(fdRead, &writefds), "FD should not be set\n");
4064
4065 FD_ZERO(&writefds);
4066 FD_SET(INVALID_SOCKET, &exceptfds);
4067 SetLastError(0);
4068 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
4069 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
4070 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
4071 ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
4072
4073 tcp_socketpair(&fdRead, &fdWrite);
4074 maxfd = fdRead;
4075 if(fdWrite > maxfd) maxfd = fdWrite;
4076
4077 FD_ZERO(&readfds);
4078 FD_SET(fdRead, &readfds);
4079 apc_count = 0;
4080 ret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
4081 ok(ret, "QueueUserAPC returned %d\n", ret);
4082 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
4083 ok(!ret, "select returned %d\n", ret);
4084 ok(apc_count == 1, "got apc_count %d.\n", apc_count);
4085
4086 FD_ZERO(&writefds);
4087 FD_SET(fdWrite, &writefds);
4088 apc_count = 0;
4089 ret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
4090 ok(ret, "QueueUserAPC returned %d\n", ret);
4091 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
4092 ok(ret == 1, "select returned %d\n", ret);
4093 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4094 ok(!apc_count, "APC was called\n");
4095 SleepEx(0, TRUE);
4096 ok(apc_count == 1, "got apc_count %d.\n", apc_count);
4097
4098 /* select the same socket twice */
4099 writefds.fd_count = 2;
4100 writefds.fd_array[0] = fdWrite;
4101 writefds.fd_array[1] = fdWrite;
4102 ret = select(0, NULL, &writefds, NULL, &select_timeout);
4103 ok(ret == 1, "select returned %d\n", ret);
4104 ok(writefds.fd_count == 1, "got count %u\n", writefds.fd_count);
4105 ok(writefds.fd_array[0] == fdWrite, "got fd %#Ix\n", writefds.fd_array[0]);
4106 ok(writefds.fd_array[1] == fdWrite, "got fd %#Ix\n", writefds.fd_array[1]);
4107
4108 /* tests for overlapping fd_set pointers */
4109 FD_ZERO(&readfds);
4110 FD_SET(fdWrite, &readfds);
4111 ret = select(fdWrite+1, &readfds, &readfds, NULL, &select_timeout);
4112 ok(ret == 1, "select returned %d\n", ret);
4113 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4114
4115 FD_ZERO(&readfds);
4116 FD_SET(fdWrite, &readfds);
4117 FD_SET(fdRead, &readfds);
4118 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
4119 ok(ret == 2, "select returned %d\n", ret);
4120 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4121 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4122
4123 ok(send(fdWrite, "test", 4, 0) == 4, "failed to send data\n");
4124 FD_ZERO(&readfds);
4125 FD_SET(fdRead, &readfds);
4126 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
4127 ok(ret == 1, "select returned %d\n", ret);
4128 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4129
4130 FD_ZERO(&readfds);
4131 FD_SET(fdWrite, &readfds);
4132 FD_SET(fdRead, &readfds);
4133 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
4134 ok(ret == 2, "select returned %d\n", ret);
4135 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4136 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4137
4138 while(1) {
4139 FD_ZERO(&writefds);
4140 FD_SET(fdWrite, &writefds);
4141 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
4142 if(!ret) break;
4143 ok(send(fdWrite, tmp_buf, sizeof(tmp_buf), 0) > 0, "failed to send data\n");
4144 }
4145 FD_ZERO(&readfds);
4146 FD_SET(fdWrite, &readfds);
4147 FD_SET(fdRead, &readfds);
4148 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
4149 ok(ret == 1, "select returned %d\n", ret);
4150 ok(!FD_ISSET(fdWrite, &readfds), "fdWrite socket is in the set\n");
4151 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4152
4153 ok(send(fdRead, "test", 4, 0) == 4, "failed to send data\n");
4154 Sleep(100);
4155 FD_ZERO(&readfds);
4156 FD_SET(fdWrite, &readfds);
4157 FD_SET(fdRead, &readfds);
4158 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
4159 ok(ret == 2, "select returned %d\n", ret);
4160 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4161 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4162
4163 page_pair = VirtualAlloc(NULL, 0x1000 * 2, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
4164 VirtualProtect(page_pair + 0x1000, 0x1000, PAGE_NOACCESS, &old_protect);
4165 alloc_fds = (fd_set *)((page_pair + 0x1000) - offsetof(fd_set, fd_array[1]));
4166 alloc_fds->fd_count = 1;
4167 alloc_fds->fd_array[0] = fdRead;
4168 ret = select(fdRead+1, alloc_fds, NULL, NULL, &select_timeout);
4169 ok(ret == 1, "select returned %d\n", ret);
4170 VirtualFree(page_pair, 0, MEM_RELEASE);
4171
4172 closesocket(fdRead);
4173 closesocket(fdWrite);
4174
4175 alloc_fds = malloc(offsetof(fd_set, fd_array[ARRAY_SIZE(sockets)]));
4176 alloc_fds->fd_count = ARRAY_SIZE(sockets);
4177 for (i = 0; i < ARRAY_SIZE(sockets); i += 2)
4178 {
4179 tcp_socketpair(&sockets[i], &sockets[i + 1]);
4180 alloc_fds->fd_array[i] = sockets[i];
4181 alloc_fds->fd_array[i + 1] = sockets[i + 1];
4182 }
4183 ret = select(0, NULL, alloc_fds, NULL, &select_timeout);
4184 ok(ret == ARRAY_SIZE(sockets), "got %d\n", ret);
4185 for (i = 0; i < ARRAY_SIZE(sockets); ++i)
4186 {
4187 ok(alloc_fds->fd_array[i] == sockets[i], "got socket %#Ix at index %u\n", alloc_fds->fd_array[i], i);
4188 closesocket(sockets[i]);
4189 }
4190 free(alloc_fds);
4191
4192 /* select() works in 3 distinct states:
4193 * - to check if a connection attempt ended with success or error;
4194 * - to check if a pending connection is waiting for acceptance;
4195 * - to check for data to read, availability for write and OOB data
4196 *
4197 * The tests below ensure that all conditions are tested.
4198 */
4199 memset(&address, 0, sizeof(address));
4200 address.sin_addr.s_addr = inet_addr("127.0.0.1");
4201 address.sin_family = AF_INET;
4202 len = sizeof(address);
4203 fdListen = setup_server_socket(&address, &len);
4204 select_timeout.tv_sec = 1;
4205 select_timeout.tv_usec = 250000;
4206
4207 /* When no events are pending select returns 0 with no error */
4208 FD_ZERO_ALL();
4209 FD_SET_ALL(fdListen);
4210 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4211 ok(ret == 0, "expected 0, got %d\n", ret);
4212
4213 /* When a socket is attempting to connect the listening socket receives the read descriptor */
4214 fdWrite = setup_connector_socket(&address, len, TRUE);
4215 FD_ZERO_ALL();
4216 FD_SET_ALL(fdListen);
4217 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4218 ok(ret == 1, "expected 1, got %d\n", ret);
4219 ok(FD_ISSET(fdListen, &readfds), "fdListen socket is not in the set\n");
4220 len = sizeof(address);
4221 fdRead = accept(fdListen, (struct sockaddr*) &address, &len);
4222 ok(fdRead != INVALID_SOCKET, "expected a valid socket\n");
4223
4224 /* The connector is signaled through the write descriptor */
4225 FD_ZERO_ALL();
4226 FD_SET_ALL(fdListen);
4227 FD_SET_ALL(fdRead);
4228 FD_SET_ALL(fdWrite);
4229 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4230 ok(ret == 2, "expected 2, got %d\n", ret);
4231 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4232 ok(FD_ISSET(fdRead, &writefds), "fdRead socket is not in the set\n");
4233 len = sizeof(id);
4234 id = 0xdeadbeef;
4235 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
4236 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4237 ok(id == 0, "expected 0, got %ld\n", id);
4238
4239 /* When data is received the receiver gets the read descriptor */
4240 ret = send(fdWrite, "1234", 4, 0);
4241 ok(ret == 4, "expected 4, got %d\n", ret);
4242 FD_ZERO_ALL();
4243 FD_SET_ALL(fdListen);
4244 FD_SET(fdRead, &readfds);
4245 FD_SET(fdRead, &exceptfds);
4246 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4247 ok(ret == 1, "expected 1, got %d\n", ret);
4248 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4249 ok(!FD_ISSET(fdRead, &exceptfds), "fdRead socket is in the set\n");
4250 FD_ZERO_ALL();
4251 FD_SET_ALL(fdRead);
4252 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4253 ok(ret == 2, "expected 1, got %d\n", ret);
4254 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4255 ok(FD_ISSET(fdRead, &writefds), "fdRead socket is not in the set\n");
4256 ok(!FD_ISSET(fdRead, &exceptfds), "fdRead socket is in the set\n");
4257 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
4258 ok(ret == 4, "expected 4, got %d\n", ret);
4259 ok(!strcmp(tmp_buf, "1234"), "data received differs from sent\n");
4260
4261 /* When OOB data is received the socket is set in the except descriptor */
4262 ret = send(fdWrite, "A", 1, MSG_OOB);
4263 ok(ret == 1, "expected 1, got %d\n", ret);
4264 FD_ZERO_ALL();
4265 FD_SET_ALL(fdListen);
4266 FD_SET(fdRead, &readfds);
4267 FD_SET(fdRead, &exceptfds);
4268 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4269 ok(ret == 1, "expected 1, got %d\n", ret);
4270 ok(FD_ISSET(fdRead, &exceptfds), "fdRead socket is not in the set\n");
4271 tmp_buf[0] = 0xAF;
4272 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
4273 ok(ret == 1, "expected 1, got %d\n", ret);
4274 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
4275
4276 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
4277 ret = 1;
4278 ret = setsockopt(fdRead, SOL_SOCKET, SO_OOBINLINE, (char*) &ret, sizeof(ret));
4279 ok(ret == 0, "expected 0, got %d\n", ret);
4280 ret = send(fdWrite, "A", 1, MSG_OOB);
4281 ok(ret == 1, "expected 1, got %d\n", ret);
4282 FD_ZERO_ALL();
4283 FD_SET_ALL(fdListen);
4284 FD_SET(fdRead, &readfds);
4285 FD_SET(fdRead, &exceptfds);
4286 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4287 ok(ret == 1, "expected 1, got %d\n", ret);
4288 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4289 tmp_buf[0] = 0xAF;
4290 SetLastError(0xdeadbeef);
4291 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
4292 ok(ret == SOCKET_ERROR, "expected SOCKET_ERROR, got %d\n", ret);
4293 ok(GetLastError() == WSAEINVAL, "expected 10022, got %ld\n", GetLastError());
4294 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
4295 ok(ret == 1, "expected 1, got %d\n", ret);
4296 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
4297
4298 /* When the connection is closed the socket is set in the read descriptor */
4299 ret = closesocket(fdRead);
4300 ok(ret == 0, "expected 0, got %d\n", ret);
4301 FD_ZERO_ALL();
4302 FD_SET_ALL(fdListen);
4303 FD_SET(fdWrite, &readfds);
4304 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4305 ok(ret == 1, "expected 1, got %d\n", ret);
4306 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4307 ret = recv(fdWrite, tmp_buf, sizeof(tmp_buf), 0);
4308 ok(ret == 0, "expected 0, got %d\n", ret);
4309 ret = closesocket(fdWrite);
4310 ok(ret == 0, "expected 0, got %d\n", ret);
4311
4312 /* w10pro64 sometimes takes over 2 seconds for an error to be reported. */
4313 if (winetest_interactive)
4314 {
4315 const struct sockaddr_in invalid_addr =
4316 {
4317 .sin_family = AF_INET,
4318 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
4319 .sin_port = 255,
4320 };
4321 SOCKET client2, server2;
4322
4323 fdWrite = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4324 set_blocking(fdWrite, FALSE);
4325
4326 ret = connect(fdWrite, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
4327 ok(ret == -1, "got %d\n", ret);
4328 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4329
4330 FD_ZERO_ALL();
4331 FD_SET(fdWrite, &readfds);
4332 FD_SET(fdWrite, &writefds);
4333 FD_SET(fdWrite, &exceptfds);
4334 select_timeout.tv_sec = 10;
4335 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4336 ok(ret == 1, "expected 1, got %d\n", ret);
4337 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4338 ok(select_timeout.tv_usec == 250000, "select timeout should not have changed\n");
4339
4340 len = sizeof(id);
4341 id = 0xdeadbeef;
4342 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4343 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4344 ok(id == WSAECONNREFUSED, "got error %lu\n", id);
4345
4346 len = sizeof(id);
4347 id = 0xdeadbeef;
4348 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4349 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4350 ok(id == WSAECONNREFUSED, "got error %lu\n", id);
4351
4352 FD_ZERO_ALL();
4353 FD_SET(fdWrite, &readfds);
4354 FD_SET(fdWrite, &writefds);
4355 FD_SET(fdWrite, &exceptfds);
4356 select_timeout.tv_sec = 10;
4357 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4358 ok(ret == 1, "got %d\n", ret);
4359 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4360
4361 /* Calling connect() doesn't reset the socket error, but a successful
4362 * connection does. This is kind of tricky to test, because while
4363 * Windows takes a couple seconds to actually fail the connection,
4364 * Linux will fail the connection almost immediately. */
4365
4366 ret = connect(fdWrite, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
4367 ok(ret == -1, "got %d\n", ret);
4368 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4369
4370 len = sizeof(id);
4371 id = 0xdeadbeef;
4372 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4373 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4374 ok(id == WSAECONNREFUSED, "got error %lu\n", id);
4375
4376 FD_ZERO_ALL();
4377 FD_SET(fdWrite, &readfds);
4378 FD_SET(fdWrite, &writefds);
4379 FD_SET(fdWrite, &exceptfds);
4380 select_timeout.tv_sec = 10;
4381 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4382 ok(ret == 1, "got %d\n", ret);
4383 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4384
4385 len = sizeof(address);
4386 ret = getsockname(fdListen, (struct sockaddr *)&address, &len);
4387 ok(!ret, "got error %u\n", WSAGetLastError());
4388 ret = connect(fdWrite, (const struct sockaddr *)&address, sizeof(address));
4389 ok(ret == -1, "got %d\n", ret);
4390 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4391
4392 FD_ZERO_ALL();
4393 FD_SET(fdWrite, &readfds);
4394 FD_SET(fdWrite, &writefds);
4395 FD_SET(fdWrite, &exceptfds);
4396 select_timeout.tv_sec = 1;
4397 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4398 ok(ret == 1, "expected 1, got %d\n", ret);
4399 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4400
4401 len = sizeof(id);
4402 id = 0xdeadbeef;
4403 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4404 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4405 ok(!id, "got error %lu\n", id);
4406
4407 closesocket(fdWrite);
4408
4409 /* Test listening after a failed connection. */
4410
4411 fdWrite = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4412 set_blocking(fdWrite, FALSE);
4413
4414 address.sin_family = AF_INET;
4415 address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
4416 address.sin_port = 0;
4417 ret = bind(fdWrite, (struct sockaddr *)&address, sizeof(address));
4418 ok(!ret, "got %d\n", ret);
4419
4420 ret = connect(fdWrite, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
4421 ok(ret == -1, "got %d\n", ret);
4422 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4423
4424 FD_ZERO(&exceptfds);
4425 FD_SET(fdWrite, &exceptfds);
4426 select_timeout.tv_sec = 10;
4427 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
4428 ok(ret == 1, "expected 1, got %d\n", ret);
4429
4430 len = sizeof(address);
4431 ret = getsockname(fdWrite, (struct sockaddr *)&address, &len);
4432 ok(!ret, "got error %lu\n", GetLastError());
4433
4434 /* Linux seems to forbid this. We'd need to replace the underlying fd. */
4435 ret = listen(fdWrite, 1);
4436 todo_wine ok(!ret, "got error %lu\n", GetLastError());
4437
4438 if (!ret)
4439 {
4440 client2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4441 ret = connect(client2, (struct sockaddr *)&address, sizeof(address));
4442 ok(!ret, "got error %lu\n", GetLastError());
4443
4444 server2 = accept(fdWrite, NULL, NULL);
4445 ok(server2 != INVALID_SOCKET, "got %d\n", ret);
4446
4447 closesocket(server2);
4448 closesocket(client2);
4449 }
4450
4451 len = sizeof(id);
4452 id = 0xdeadbeef;
4453 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4454 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4455 ok(id == WSAECONNREFUSED, "got error %lu\n", id);
4456
4457 FD_ZERO_ALL();
4458 FD_SET(fdWrite, &readfds);
4459 FD_SET(fdWrite, &writefds);
4460 FD_SET(fdWrite, &exceptfds);
4461 select_timeout.tv_sec = 0;
4462 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4463 ok(ret == 1, "got %d\n", ret);
4464 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4465
4466 closesocket(fdWrite);
4467
4468 /* test polling after a (synchronous) failure */
4469
4470 fdWrite = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4471
4472 ret = connect(fdWrite, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
4473 ok(ret == -1, "got %d\n", ret);
4474 ok(WSAGetLastError() == WSAECONNREFUSED, "got error %u\n", WSAGetLastError());
4475
4476 len = sizeof(id);
4477 id = 0xdeadbeef;
4478 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4479 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4480 todo_wine ok(!id, "got error %lu\n", id);
4481
4482 FD_ZERO_ALL();
4483 FD_SET(fdWrite, &readfds);
4484 FD_SET(fdWrite, &writefds);
4485 FD_SET(fdWrite, &exceptfds);
4486 select_timeout.tv_sec = 0;
4487 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4488 ok(ret == 1, "expected 1, got %d\n", ret);
4489 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4490
4491 len = sizeof(id);
4492 id = 0xdeadbeef;
4493 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
4494 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4495 todo_wine ok(!id, "got error %lu\n", id);
4496
4497 closesocket(fdWrite);
4498 }
4499
4500 ret = closesocket(fdListen);
4501 ok(ret == 0, "expected 0, got %d\n", ret);
4502
4503 select_timeout.tv_sec = 1;
4504 select_timeout.tv_usec = 250000;
4505
4506 /* Try select() on a closed socket after connection */
4507 tcp_socketpair(&fdRead, &fdWrite);
4508 closesocket(fdRead);
4509 FD_ZERO_ALL();
4510 FD_SET_ALL(fdWrite);
4511 FD_SET_ALL(fdRead);
4512 SetLastError(0xdeadbeef);
4513 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
4514 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4515 ok(GetLastError() == WSAENOTSOCK, "got %ld\n", GetLastError());
4516 /* descriptor sets are unchanged */
4517 ok(readfds.fd_count == 2, "expected 2, got %d\n", readfds.fd_count);
4518 ok(exceptfds.fd_count == 2, "expected 2, got %d\n", exceptfds.fd_count);
4519 closesocket(fdWrite);
4520
4521 /* Close the socket currently being selected in a thread - bug 38399 */
4522 tcp_socketpair(&fdRead, &fdWrite);
4523 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
4524 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %ld\n", GetLastError());
4525 FD_ZERO_ALL();
4526 FD_SET_ALL(fdWrite);
4527 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
4528 ok(ret == 1, "expected 1, got %d\n", ret);
4529 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4530 WaitForSingleObject (thread_handle, 1000);
4531 closesocket(fdRead);
4532 /* test again with only the except descriptor */
4533 tcp_socketpair(&fdRead, &fdWrite);
4534 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
4535 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %ld\n", GetLastError());
4536 FD_ZERO_ALL();
4537 FD_SET(fdWrite, &exceptfds);
4538 SetLastError(0xdeadbeef);
4539 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
4540 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4541 ok(GetLastError() == WSAENOTSOCK, "got %ld\n", GetLastError());
4542 ok(!FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is in the set\n");
4543 WaitForSingleObject (thread_handle, 1000);
4544 closesocket(fdRead);
4545
4546 /* test UDP behavior of unbound sockets */
4547 select_timeout.tv_sec = 0;
4548 select_timeout.tv_usec = 250000;
4549 fdWrite = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
4550 ok(fdWrite != INVALID_SOCKET, "socket call failed\n");
4551 FD_ZERO_ALL();
4552 FD_SET_ALL(fdWrite);
4553 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4554 ok(ret == 1, "expected 1, got %d\n", ret);
4555 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4556 closesocket(fdWrite);
4557 }
4558 #undef FD_SET_ALL
4559 #undef FD_ZERO_ALL
4560
4561 static DWORD WINAPI AcceptKillThread(void *param)
4562 {
4563 select_thread_params *par = param;
4564 struct sockaddr_in address;
4565 int len = sizeof(address);
4566 SOCKET client_socket;
4567
4568 SetEvent(server_ready);
4569 client_socket = accept(par->s, (struct sockaddr*) &address, &len);
4570 if (client_socket != INVALID_SOCKET)
4571 closesocket(client_socket);
4572 par->ReadKilled = (client_socket == INVALID_SOCKET);
4573 return 0;
4574 }
4575
4576
4577 static int CALLBACK AlwaysDeferConditionFunc(LPWSABUF lpCallerId, LPWSABUF lpCallerData, LPQOS pQos,
4578 LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,
4579 GROUP *g, DWORD_PTR dwCallbackData)
4580 {
4581 return CF_DEFER;
4582 }
4583
4584 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len)
4585 {
4586 int ret, val;
4587 SOCKET server_socket;
4588
4589 server_socket = socket(AF_INET, SOCK_STREAM, 0);
4590 ok(server_socket != INVALID_SOCKET, "failed to bind socket, error %u\n", WSAGetLastError());
4591
4592 val = 1;
4593 ret = setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
4594 ok(!ret, "failed to set SO_REUSEADDR, error %u\n", WSAGetLastError());
4595
4596 ret = bind(server_socket, (struct sockaddr *)addr, *len);
4597 ok(!ret, "failed to bind socket, error %u\n", WSAGetLastError());
4598
4599 ret = getsockname(server_socket, (struct sockaddr *)addr, len);
4600 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
4601
4602 ret = listen(server_socket, 5);
4603 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
4604
4605 return server_socket;
4606 }
4607
4608 static SOCKET setup_connector_socket(const struct sockaddr_in *addr, int len, BOOL nonblock)
4609 {
4610 int ret;
4611 SOCKET connector;
4612
4613 connector = socket(AF_INET, SOCK_STREAM, 0);
4614 ok(connector != INVALID_SOCKET, "failed to create connector socket %d\n", WSAGetLastError());
4615
4616 if (nonblock)
4617 set_blocking(connector, !nonblock);
4618
4619 ret = connect(connector, (const struct sockaddr *)addr, len);
4620 if (!nonblock)
4621 ok(!ret, "connecting to accepting socket failed %d\n", WSAGetLastError());
4622 else if (ret == SOCKET_ERROR)
4623 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
4624
4625 return connector;
4626 }
4627
4628 static void test_accept(void)
4629 {
4630 int ret;
4631 SOCKET server_socket, accepted = INVALID_SOCKET, connector;
4632 struct sockaddr_in address;
4633 SOCKADDR_STORAGE ss, ss_empty;
4634 int socklen;
4635 select_thread_params thread_params;
4636 HANDLE thread_handle = NULL;
4637 DWORD id;
4638
4639 memset(&address, 0, sizeof(address));
4640 address.sin_addr.s_addr = inet_addr("127.0.0.1");
4641 address.sin_family = AF_INET;
4642
4643 socklen = sizeof(address);
4644 server_socket = setup_server_socket(&address, &socklen);
4645
4646 connector = setup_connector_socket(&address, socklen, FALSE);
4647 if (connector == INVALID_SOCKET) goto done;
4648
4649 accepted = WSAAccept(server_socket, NULL, NULL, AlwaysDeferConditionFunc, 0);
4650 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
4651
4652 accepted = accept(server_socket, NULL, 0);
4653 ok(accepted != INVALID_SOCKET, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
4654
4655 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
4656
4657 thread_params.s = server_socket;
4658 thread_params.ReadKilled = FALSE;
4659 thread_handle = CreateThread(NULL, 0, AcceptKillThread, &thread_params, 0, &id);
4660
4661 WaitForSingleObject(server_ready, INFINITE);
4662 Sleep(200);
4663 ret = closesocket(server_socket);
4664 ok(!ret, "failed to close socket, error %u\n", WSAGetLastError());
4665
4666 WaitForSingleObject(thread_handle, 1000);
4667 ok(thread_params.ReadKilled, "closesocket did not wake up accept\n");
4668
4669 closesocket(accepted);
4670 closesocket(connector);
4671 accepted = connector = INVALID_SOCKET;
4672
4673 socklen = sizeof(address);
4674 server_socket = setup_server_socket(&address, &socklen);
4675
4676 connector = setup_connector_socket(&address, socklen, FALSE);
4677 if (connector == INVALID_SOCKET) goto done;
4678
4679 socklen = 0;
4680 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
4681 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
4682 ok(!socklen, "got %d\n", socklen);
4683 closesocket(connector);
4684 connector = INVALID_SOCKET;
4685
4686 socklen = sizeof(address);
4687 connector = setup_connector_socket(&address, socklen, FALSE);
4688 if (connector == INVALID_SOCKET) goto done;
4689
4690 accepted = WSAAccept(server_socket, NULL, NULL, NULL, 0);
4691 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4692 closesocket(accepted);
4693 closesocket(connector);
4694 accepted = connector = INVALID_SOCKET;
4695
4696 socklen = sizeof(address);
4697 connector = setup_connector_socket(&address, socklen, FALSE);
4698 if (connector == INVALID_SOCKET) goto done;
4699
4700 socklen = sizeof(ss);
4701 memset(&ss, 0, sizeof(ss));
4702 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
4703 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4704 ok(socklen != sizeof(ss), "unexpected length\n");
4705 ok(ss.ss_family, "family not set\n");
4706 closesocket(accepted);
4707 closesocket(connector);
4708 accepted = connector = INVALID_SOCKET;
4709
4710 socklen = sizeof(address);
4711 connector = setup_connector_socket(&address, socklen, FALSE);
4712 if (connector == INVALID_SOCKET) goto done;
4713
4714 socklen = 0;
4715 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4716 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
4717 ok(!socklen, "got %d\n", socklen);
4718 closesocket(connector);
4719 accepted = connector = INVALID_SOCKET;
4720
4721 socklen = sizeof(address);
4722 connector = setup_connector_socket(&address, socklen, FALSE);
4723 if (connector == INVALID_SOCKET) goto done;
4724
4725 accepted = accept(server_socket, NULL, NULL);
4726 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4727 closesocket(accepted);
4728 closesocket(connector);
4729 accepted = connector = INVALID_SOCKET;
4730
4731 socklen = sizeof(address);
4732 connector = setup_connector_socket(&address, socklen, FALSE);
4733 if (connector == INVALID_SOCKET) goto done;
4734
4735 socklen = sizeof(ss);
4736 memset(&ss, 0, sizeof(ss));
4737 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4738 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4739 ok(socklen != sizeof(ss), "unexpected length\n");
4740 ok(ss.ss_family, "family not set\n");
4741 closesocket(accepted);
4742 closesocket(connector);
4743 accepted = connector = INVALID_SOCKET;
4744
4745 socklen = sizeof(address);
4746 connector = setup_connector_socket(&address, socklen, FALSE);
4747 if (connector == INVALID_SOCKET) goto done;
4748
4749 memset(&ss, 0, sizeof(ss));
4750 memset(&ss_empty, 0, sizeof(ss_empty));
4751 accepted = accept(server_socket, (struct sockaddr *)&ss, NULL);
4752 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4753 ok(!memcmp(&ss, &ss_empty, sizeof(ss)), "structure is different\n");
4754
4755 done:
4756 if (accepted != INVALID_SOCKET)
4757 closesocket(accepted);
4758 if (connector != INVALID_SOCKET)
4759 closesocket(connector);
4760 if (thread_handle != NULL)
4761 CloseHandle(thread_handle);
4762 if (server_ready != INVALID_HANDLE_VALUE)
4763 CloseHandle(server_ready);
4764 if (server_socket != INVALID_SOCKET)
4765 closesocket(server_socket);
4766 }
4767
4768 /* Test what socket state is inherited from the listening socket by accept(). */
4769 static void test_accept_inheritance(void)
4770 {
4771 struct sockaddr_in addr, destaddr;
4772 SOCKET listener, server, client;
4773 struct linger linger;
4774 int ret, len, value;
4775 unsigned int i;
4776
4777 static const struct
4778 {
4779 int optname;
4780 int optval;
4781 int value;
4782 }
4783 int_tests[] =
4784 {
4785 {SOL_SOCKET, SO_REUSEADDR, 1},
4786 {SOL_SOCKET, SO_KEEPALIVE, 1},
4787 {SOL_SOCKET, SO_OOBINLINE, 1},
4788 {SOL_SOCKET, SO_SNDBUF, 0x123},
4789 {SOL_SOCKET, SO_RCVBUF, 0x123},
4790 {SOL_SOCKET, SO_SNDTIMEO, 0x123},
4791 {SOL_SOCKET, SO_RCVTIMEO, 0x123},
4792 {IPPROTO_TCP, TCP_NODELAY, 1},
4793 };
4794
4795 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4796 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
4797
4798 for (i = 0; i < ARRAY_SIZE(int_tests); ++i)
4799 {
4800 ret = setsockopt(listener, int_tests[i].optname, int_tests[i].optval,
4801 (char *)&int_tests[i].value, sizeof(int_tests[i].value));
4802 ok(!ret, "test %u: got error %u\n", i, WSAGetLastError());
4803 }
4804
4805 linger.l_onoff = 1;
4806 linger.l_linger = 555;
4807 ret = setsockopt(listener, SOL_SOCKET, SO_LINGER, (char *)&linger, sizeof(linger));
4808 ok(!ret, "got error %u\n", WSAGetLastError());
4809
4810 memset(&addr, 0, sizeof(addr));
4811 addr.sin_family = AF_INET;
4812 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
4813 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
4814 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
4815 len = sizeof(destaddr);
4816 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
4817 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
4818
4819 ret = listen(listener, 1);
4820 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
4821
4822 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4823 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
4824 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
4825 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
4826 server = accept(listener, NULL, NULL);
4827 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
4828
4829 for (i = 0; i < ARRAY_SIZE(int_tests); ++i)
4830 {
4831 value = 0;
4832 len = sizeof(value);
4833 ret = getsockopt(server, int_tests[i].optname, int_tests[i].optval, (char *)&value, &len);
4834 ok(!ret, "test %u: got error %u\n", i, WSAGetLastError());
4835 ok(value == int_tests[i].value, "test %u: got value %#x\n", i, value);
4836 }
4837
4838 len = sizeof(linger);
4839 memset(&linger, 0, sizeof(linger));
4840 ret = getsockopt(server, SOL_SOCKET, SO_LINGER, (char *)&linger, &len);
4841 ok(!ret, "got error %u\n", WSAGetLastError());
4842 ok(linger.l_onoff == 1, "got on/off %u\n", linger.l_onoff);
4843 ok(linger.l_linger == 555, "got linger %u\n", linger.l_onoff);
4844
4845 close(server);
4846 close(client);
4847 close(listener);
4848 }
4849
4850 static void test_extendedSocketOptions(void)
4851 {
4852 WSADATA wsa;
4853 SOCKET sock;
4854 struct sockaddr_in sa;
4855 int sa_len = sizeof(struct sockaddr_in);
4856 int optval, optlen = sizeof(int), ret;
4857 BOOL bool_opt_val;
4858 LINGER linger_val;
4859
4860 ret = WSAStartup(MAKEWORD(2,0), &wsa);
4861 ok(!ret, "failed to startup, error %u\n", WSAGetLastError());
4862
4863 memset(&sa, 0, sa_len);
4864
4865 sa.sin_family = AF_INET;
4866 sa.sin_port = htons(0);
4867 sa.sin_addr.s_addr = htonl(INADDR_ANY);
4868
4869 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
4870 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
4871
4872 ret = bind(sock, (struct sockaddr *) &sa, sa_len);
4873 ok(!ret, "failed to bind socket, error %u\n", WSAGetLastError());
4874
4875 ret = getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4876
4877 ok(ret == 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret);
4878 ok((optval == 65507) || (optval == 65527),
4879 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval);
4880
4881 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
4882 SetLastError(0xdeadbeef);
4883 optval = 0xdeadbeef;
4884 optlen = sizeof(int);
4885 ret = getsockopt(sock, 0xffffffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4886 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4887 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4888 ret, WSAGetLastError(), optval, optval);
4889
4890 /* more invalid values for level */
4891 SetLastError(0xdeadbeef);
4892 optval = 0xdeadbeef;
4893 optlen = sizeof(int);
4894 ret = getsockopt(sock, 0x1234ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4895 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4896 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4897 ret, WSAGetLastError(), optval, optval);
4898
4899 SetLastError(0xdeadbeef);
4900 optval = 0xdeadbeef;
4901 optlen = sizeof(int);
4902 ret = getsockopt(sock, 0x8000ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4903 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4904 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4905 ret, WSAGetLastError(), optval, optval);
4906
4907 SetLastError(0xdeadbeef);
4908 optval = 0xdeadbeef;
4909 optlen = sizeof(int);
4910 ret = getsockopt(sock, 0x00008000, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4911 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4912 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4913 ret, WSAGetLastError(), optval, optval);
4914
4915 SetLastError(0xdeadbeef);
4916 optval = 0xdeadbeef;
4917 optlen = sizeof(int);
4918 ret = getsockopt(sock, 0x00000800, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4919 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4920 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4921 ret, WSAGetLastError(), optval, optval);
4922
4923 SetLastError(0xdeadbeef);
4924 optlen = sizeof(LINGER);
4925 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
4926 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAENOPROTOOPT),
4927 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
4928 ret, WSAGetLastError());
4929 closesocket(sock);
4930
4931 sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
4932 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
4933
4934 ret = bind(sock, (struct sockaddr *) &sa, sa_len);
4935 ok(!ret, "failed to bind socket, error %u\n", WSAGetLastError());
4936
4937 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
4938 ok(ret == 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret);
4939
4940 optlen = sizeof(BOOL);
4941 ret = getsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *)&bool_opt_val, &optlen);
4942 ok(ret == 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret);
4943 ok((linger_val.l_onoff && !bool_opt_val) || (!linger_val.l_onoff && bool_opt_val),
4944 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
4945 bool_opt_val, linger_val.l_onoff);
4946
4947 closesocket(sock);
4948 WSACleanup();
4949 }
4950
4951 static void test_getsockname(void)
4952 {
4953 WSADATA wsa;
4954 SOCKET sock;
4955 struct sockaddr_in sa_set, sa_get;
4956 int sa_set_len = sizeof(struct sockaddr_in);
4957 int sa_get_len = sa_set_len;
4958 static const unsigned char null_padding[] = {0,0,0,0,0,0,0,0};
4959 int ret;
4960 struct hostent *h;
4961
4962 ret = WSAStartup(MAKEWORD(2,0), &wsa);
4963 ok(!ret, "failed to startup, error %u\n", WSAGetLastError());
4964
4965 memset(&sa_set, 0, sa_set_len);
4966
4967 sa_set.sin_family = AF_INET;
4968 sa_set.sin_port = htons(0);
4969 sa_set.sin_addr.s_addr = htonl(INADDR_ANY);
4970
4971 sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
4972 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
4973
4974 sa_get = sa_set;
4975 WSASetLastError(0xdeadbeef);
4976 ret = getsockname(sock, (struct sockaddr *)&sa_get, &sa_get_len);
4977 ok(ret == SOCKET_ERROR, "expected failure\n");
4978 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
4979 ok(!memcmp(&sa_get, &sa_set, sizeof(sa_get)), "address should not be changed\n");
4980
4981 ret = bind(sock, (struct sockaddr *) &sa_set, sa_set_len);
4982 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
4983
4984 WSASetLastError(0xdeadbeef);
4985 memset(&sa_get, 0, sizeof(sa_get));
4986 ret = getsockname(sock, (struct sockaddr *) &sa_get, &sa_get_len);
4987 ok(!ret, "got %d\n", ret);
4988 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
4989 ok(sa_get.sin_family == AF_INET, "got family %#x\n", sa_get.sin_family);
4990 ok(sa_get.sin_port != 0, "got zero port\n");
4991 ok(sa_get.sin_addr.s_addr == INADDR_ANY, "got addr %08lx\n", sa_get.sin_addr.s_addr);
4992
4993 ret = memcmp(sa_get.sin_zero, null_padding, 8);
4994 ok(ret == 0, "getsockname did not zero the sockaddr_in structure\n");
4995
4996 sa_get_len = sizeof(sa_get) - 1;
4997 WSASetLastError(0xdeadbeef);
4998 ret = getsockname(sock, (struct sockaddr *)&sa_get, &sa_get_len);
4999 ok(ret == -1, "expected failure\n");
5000 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5001 ok(sa_get_len == sizeof(sa_get) - 1, "got size %d\n", sa_get_len);
5002
5003 closesocket(sock);
5004
5005 h = gethostbyname("");
5006 if (h && h->h_length == 4) /* this test is only meaningful in IPv4 */
5007 {
5008 int i;
5009 for (i = 0; h->h_addr_list[i]; i++)
5010 {
5011 char ipstr[32];
5012 struct in_addr ip;
5013 ip.s_addr = *(ULONG *) h->h_addr_list[i];
5014
5015 sock = socket(AF_INET, SOCK_DGRAM, 0);
5016 ok(sock != INVALID_SOCKET, "socket failed with %ld\n", GetLastError());
5017
5018 memset(&sa_set, 0, sizeof(sa_set));
5019 sa_set.sin_family = AF_INET;
5020 sa_set.sin_addr.s_addr = ip.s_addr;
5021 /* The same address we bind must be the same address we get */
5022 ret = bind(sock, (struct sockaddr*)&sa_set, sizeof(sa_set));
5023 ok(ret == 0, "bind failed with %ld\n", GetLastError());
5024 sa_get_len = sizeof(sa_get);
5025 ret = getsockname(sock, (struct sockaddr*)&sa_get, &sa_get_len);
5026 ok(ret == 0, "getsockname failed with %ld\n", GetLastError());
5027 strcpy(ipstr, inet_ntoa(sa_get.sin_addr));
5028 ok(sa_get.sin_addr.s_addr == sa_set.sin_addr.s_addr,
5029 "address does not match: %s != %s\n", ipstr, inet_ntoa(sa_set.sin_addr));
5030
5031 closesocket(sock);
5032 }
5033 }
5034
5035 WSACleanup();
5036 }
5037
5038 static DWORD apc_error, apc_size;
5039 static OVERLAPPED *apc_overlapped;
5040 static unsigned int apc_count;
5041
5042 static void WINAPI socket_apc(DWORD error, DWORD size, OVERLAPPED *overlapped, DWORD flags)
5043 {
5044 ok(!flags, "got flags %#lx\n", flags);
5045 ++apc_count;
5046 apc_error = error;
5047 apc_size = size;
5048 apc_overlapped = overlapped;
5049 }
5050
5051 #define check_fionread_siocatmark(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, FALSE, FALSE)
5052 #define check_fionread_siocatmark_todo(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, TRUE, TRUE)
5053 #define check_fionread_siocatmark_todo_oob(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, FALSE, TRUE)
5054 static void check_fionread_siocatmark_(int line, SOCKET s, unsigned int normal, unsigned int oob,
5055 BOOL todo_normal, BOOL todo_oob)
5056 {
5057 int ret, value;
5058 DWORD size;
5059
5060 value = 0xdeadbeef;
5061 WSASetLastError(0xdeadbeef);
5062 ret = WSAIoctl(s, FIONREAD, NULL, 0, &value, sizeof(value), &size, NULL, NULL);
5063 ok_(__FILE__, line)(!ret, "expected success\n");
5064 ok_(__FILE__, line)(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5065 todo_wine_if (todo_normal) ok_(__FILE__, line)(value == normal, "FIONBIO returned %u\n", value);
5066
5067 value = 0xdeadbeef;
5068 WSASetLastError(0xdeadbeef);
5069 ret = WSAIoctl(s, SIOCATMARK, NULL, 0, &value, sizeof(value), &size, NULL, NULL);
5070 ok_(__FILE__, line)(!ret, "expected success\n");
5071 ok_(__FILE__, line)(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5072 todo_wine_if (todo_oob) ok_(__FILE__, line)(value == oob, "SIOCATMARK returned %u\n", value);
5073 }
5074
5075 static void test_fionread_siocatmark(void)
5076 {
5077 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
5078 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5079 SOCKET client, server;
5080 char buffer[5];
5081 int ret, value;
5082 ULONG_PTR key;
5083 HANDLE port;
5084 DWORD size;
5085
5086 tcp_socketpair(&client, &server);
5087 set_blocking(client, FALSE);
5088 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
5089
5090 WSASetLastError(0xdeadbeef);
5091 ret = ioctlsocket(client, FIONREAD, (u_long *)1);
5092 ok(ret == -1, "expected failure\n");
5093 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5094
5095 WSASetLastError(0xdeadbeef);
5096 ret = ioctlsocket(client, SIOCATMARK, (u_long *)1);
5097 ok(ret == -1, "expected failure\n");
5098 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5099
5100 WSASetLastError(0xdeadbeef);
5101 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value), NULL, NULL, NULL);
5102 ok(ret == -1, "expected failure\n");
5103 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5104
5105 WSASetLastError(0xdeadbeef);
5106 size = 0xdeadbeef;
5107 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value) - 1, &size, NULL, NULL);
5108 ok(ret == -1, "expected failure\n");
5109 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5110 ok(size == 0xdeadbeef, "got size %lu\n", size);
5111
5112 WSASetLastError(0xdeadbeef);
5113 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value), NULL, NULL, NULL);
5114 ok(ret == -1, "expected failure\n");
5115 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5116
5117 WSASetLastError(0xdeadbeef);
5118 size = 0xdeadbeef;
5119 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value) - 1, &size, NULL, NULL);
5120 ok(ret == -1, "expected failure\n");
5121 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5122 ok(size == 0xdeadbeef, "got size %lu\n", size);
5123
5124 check_fionread_siocatmark(client, 0, TRUE);
5125
5126 port = CreateIoCompletionPort((HANDLE)client, NULL, 123, 0);
5127
5128 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value), NULL, &overlapped, NULL);
5129 ok(ret == -1, "expected failure\n");
5130 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5131
5132 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value), NULL, &overlapped, NULL);
5133 ok(ret == -1, "expected failure\n");
5134 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5135
5136 WSASetLastError(0xdeadbeef);
5137 size = 0xdeadbeef;
5138 value = 0xdeadbeef;
5139 overlapped.Internal = 0xdeadbeef;
5140 overlapped.InternalHigh = 0xdeadbeef;
5141 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value), &size, &overlapped, NULL);
5142 ok(!ret, "expected success\n");
5143 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5144 ok(!value, "got %u\n", value);
5145 ok(size == sizeof(value), "got size %lu\n", size);
5146 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5147 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5148
5149 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5150 ok(ret, "got error %lu\n", GetLastError());
5151 ok(!size, "got size %lu\n", size);
5152 ok(key == 123, "got key %Iu\n", key);
5153 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5154
5155 WSASetLastError(0xdeadbeef);
5156 size = 0xdeadbeef;
5157 value = 0xdeadbeef;
5158 overlapped.Internal = 0xdeadbeef;
5159 overlapped.InternalHigh = 0xdeadbeef;
5160 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value), &size, &overlapped, NULL);
5161 ok(!ret, "expected success\n");
5162 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5163 ok(value == TRUE, "got %u\n", value);
5164 ok(size == sizeof(value), "got size %lu\n", size);
5165 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5166 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5167
5168 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5169 ok(ret, "got error %lu\n", GetLastError());
5170 ok(!size, "got size %lu\n", size);
5171 ok(key == 123, "got key %Iu\n", key);
5172 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5173
5174 ret = send(server, "data", 5, 0);
5175 ok(ret == 5, "got %d\n", ret);
5176
5177 /* wait for the data to be available */
5178 check_poll_mask(client, POLLRDNORM, POLLRDNORM);
5179
5180 check_fionread_siocatmark(client, 5, TRUE);
5181
5182 ret = send(server, "a", 1, MSG_OOB);
5183 ok(ret == 1, "got %d\n", ret);
5184
5185 /* wait for the data to be available */
5186 check_poll_mask(client, POLLRDBAND, POLLRDBAND);
5187
5188 check_fionread_siocatmark_todo_oob(client, 5, FALSE);
5189
5190 ret = send(server, "a", 1, MSG_OOB);
5191 ok(ret == 1, "got %d\n", ret);
5192
5193 check_fionread_siocatmark_todo(client, 5, FALSE);
5194
5195 ret = recv(client, buffer, 3, 0);
5196 ok(ret == 3, "got %d\n", ret);
5197
5198 check_fionread_siocatmark_todo(client, 2, FALSE);
5199
5200 ret = recv(client, buffer, 1, MSG_OOB);
5201 ok(ret == 1, "got %d\n", ret);
5202
5203 /* wait for the data to be available */
5204 check_poll_mask_todo(client, POLLRDBAND, POLLRDBAND);
5205
5206 check_fionread_siocatmark_todo(client, 2, FALSE);
5207
5208 ret = recv(client, buffer, 5, 0);
5209 todo_wine ok(ret == 2, "got %d\n", ret);
5210
5211 check_fionread_siocatmark(client, 0, FALSE);
5212
5213 ret = recv(client, buffer, 1, MSG_OOB);
5214 todo_wine ok(ret == 1, "got %d\n", ret);
5215
5216 check_fionread_siocatmark_todo_oob(client, 0, TRUE);
5217
5218 ret = send(server, "a", 1, MSG_OOB);
5219 ok(ret == 1, "got %d\n", ret);
5220
5221 /* wait for the data to be available */
5222 check_poll_mask(client, POLLRDBAND, POLLRDBAND);
5223
5224 ret = 1;
5225 ret = setsockopt(client, SOL_SOCKET, SO_OOBINLINE, (char *)&ret, sizeof(ret));
5226 ok(!ret, "got error %u\n", WSAGetLastError());
5227
5228 check_fionread_siocatmark_todo_oob(client, 1, FALSE);
5229
5230 ret = recv(client, buffer, 1, 0);
5231 ok(ret == 1, "got %d\n", ret);
5232
5233 check_fionread_siocatmark(client, 0, TRUE);
5234
5235 ret = send(server, "a", 1, MSG_OOB);
5236 ok(ret == 1, "got %d\n", ret);
5237
5238 /* wait for the data to be available */
5239 check_poll_mask(client, POLLRDNORM, POLLRDNORM);
5240
5241 check_fionread_siocatmark(client, 1, TRUE);
5242
5243 closesocket(client);
5244 closesocket(server);
5245
5246 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5247
5248 check_fionread_siocatmark(server, 0, TRUE);
5249
5250 ret = bind(server, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
5251 ok(!ret, "got error %u\n", WSAGetLastError());
5252
5253 check_fionread_siocatmark(server, 0, TRUE);
5254
5255 closesocket(server);
5256 CloseHandle(overlapped.hEvent);
5257
5258 /* test with APCs */
5259
5260 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5261
5262 ret = WSAIoctl(server, FIONREAD, NULL, 0, &value, sizeof(value), NULL, &overlapped, socket_apc);
5263 ok(ret == -1, "expected failure\n");
5264 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5265
5266 ret = WSAIoctl(server, SIOCATMARK, NULL, 0, &value, sizeof(value), NULL, &overlapped, socket_apc);
5267 ok(ret == -1, "expected failure\n");
5268 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5269
5270 apc_count = 0;
5271 size = 0xdeadbeef;
5272 ret = WSAIoctl(server, FIONREAD, NULL, 0, &value, sizeof(value), &size, &overlapped, socket_apc);
5273 ok(!ret, "expected success\n");
5274 ok(size == sizeof(value), "got size %lu\n", size);
5275
5276 ret = SleepEx(0, TRUE);
5277 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5278 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5279 ok(!apc_error, "got APC error %lu\n", apc_error);
5280 ok(!apc_size, "got APC size %lu\n", apc_size);
5281 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5282
5283 apc_count = 0;
5284 size = 0xdeadbeef;
5285 ret = WSAIoctl(server, SIOCATMARK, NULL, 0, &value, sizeof(value), &size, &overlapped, socket_apc);
5286 ok(!ret, "expected success\n");
5287 ok(size == sizeof(value), "got size %lu\n", size);
5288
5289 ret = SleepEx(0, TRUE);
5290 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5291 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5292 ok(!apc_error, "got APC error %lu\n", apc_error);
5293 ok(!apc_size, "got APC size %lu\n", apc_size);
5294 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5295
5296 closesocket(server);
5297 }
5298
5299 static void test_fionbio(void)
5300 {
5301 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5302 u_long one = 1, zero = 0;
5303 HANDLE port, event;
5304 ULONG_PTR key;
5305 void *output;
5306 DWORD size;
5307 SOCKET s;
5308 int ret;
5309
5310 event = CreateEventW(NULL, TRUE, FALSE, NULL);
5311 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5312 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
5313
5314 WSASetLastError(0xdeadbeef);
5315 ret = ioctlsocket(s, FIONBIO, (u_long *)1);
5316 ok(ret == -1, "expected failure\n");
5317 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5318
5319 WSASetLastError(0xdeadbeef);
5320 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, NULL, NULL, NULL);
5321 ok(ret == -1, "expected failure\n");
5322 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5323
5324 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one) - 1, NULL, 0, &size, &overlapped, NULL);
5325 ok(ret == -1, "expected failure\n");
5326 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5327
5328 size = 0xdeadbeef;
5329 WSASetLastError(0xdeadbeef);
5330 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, NULL, NULL);
5331 ok(!ret, "expected success\n");
5332 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5333 ok(!size, "got size %lu\n", size);
5334
5335 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one) + 1, NULL, 0, &size, NULL, NULL);
5336 ok(!ret, "got error %u\n", WSAGetLastError());
5337
5338 output = VirtualAlloc(NULL, 4, MEM_RESERVE | MEM_COMMIT, PAGE_NOACCESS);
5339 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one) + 1, output, 4, &size, NULL, NULL);
5340 ok(!ret, "got error %u\n", WSAGetLastError());
5341 VirtualFree(output, 0, MEM_FREE);
5342
5343 overlapped.Internal = 0xdeadbeef;
5344 overlapped.InternalHigh = 0xdeadbeef;
5345 size = 0xdeadbeef;
5346 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, &overlapped, NULL);
5347 ok(!ret, "expected success\n");
5348 ok(!size, "got size %lu\n", size);
5349
5350 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5351 ok(ret, "got error %lu\n", GetLastError());
5352 ok(!size, "got size %lu\n", size);
5353 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5354 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5355 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5356
5357 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, NULL, &overlapped, NULL);
5358 ok(ret == -1, "expected failure\n");
5359 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5360
5361 ret = WSAEventSelect(s, event, FD_READ);
5362 ok(!ret, "got error %u\n", WSAGetLastError());
5363
5364 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, NULL, NULL);
5365 ok(!ret, "got error %u\n", WSAGetLastError());
5366
5367 size = 0xdeadbeef;
5368 ret = WSAIoctl(s, FIONBIO, &zero, sizeof(zero), NULL, 0, &size, NULL, NULL);
5369 ok(ret == -1, "expected failure\n");
5370 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
5371 todo_wine ok(!size, "got size %lu\n", size);
5372
5373 CloseHandle(port);
5374 closesocket(s);
5375 CloseHandle(event);
5376
5377 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5378
5379 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, NULL, &overlapped, socket_apc);
5380 ok(ret == -1, "expected failure\n");
5381 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5382
5383 apc_count = 0;
5384 size = 0xdeadbeef;
5385 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, &overlapped, socket_apc);
5386 ok(!ret, "expected success\n");
5387 ok(!size, "got size %lu\n", size);
5388
5389 ret = SleepEx(0, TRUE);
5390 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5391 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5392 ok(!apc_error, "got APC error %lu\n", apc_error);
5393 ok(!apc_size, "got APC size %lu\n", apc_size);
5394 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5395
5396 closesocket(s);
5397 }
5398
5399 static void test_keepalive_vals(void)
5400 {
5401 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5402 struct tcp_keepalive kalive;
5403 ULONG_PTR key;
5404 HANDLE port;
5405 SOCKET sock;
5406 DWORD size;
5407 int ret;
5408
5409 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5410 ok(sock != INVALID_SOCKET, "Creating the socket failed: %d\n", WSAGetLastError());
5411 port = CreateIoCompletionPort((HANDLE)sock, NULL, 123, 0);
5412
5413 WSASetLastError(0xdeadbeef);
5414 size = 0xdeadbeef;
5415 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, 0, NULL, 0, &size, NULL, NULL);
5416 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5417 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5418 ok(!size, "got size %lu\n", size);
5419
5420 WSASetLastError(0xdeadbeef);
5421 size = 0xdeadbeef;
5422 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, NULL, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5423 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5424 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5425 ok(!size, "got size %lu\n", size);
5426
5427 WSASetLastError(0xdeadbeef);
5428 size = 0xdeadbeef;
5429 make_keepalive(kalive, 0, 0, 0);
5430 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5431 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5432 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5433 ok(!size, "got size %lu\n", size);
5434
5435 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, NULL, NULL, NULL);
5436 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5437 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5438
5439 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, NULL, &overlapped, NULL);
5440 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5441 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5442
5443 WSASetLastError(0xdeadbeef);
5444 size = 0xdeadbeef;
5445 overlapped.Internal = 0xdeadbeef;
5446 overlapped.InternalHigh = 0xdeadbeef;
5447 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive) - 1, NULL, 0, &size, &overlapped, NULL);
5448 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5449 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5450 ok(size == 0xdeadbeef, "got size %lu\n", size);
5451 todo_wine ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5452 ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
5453
5454 WSASetLastError(0xdeadbeef);
5455 size = 0xdeadbeef;
5456 overlapped.Internal = 0xdeadbeef;
5457 overlapped.InternalHigh = 0xdeadbeef;
5458 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, &overlapped, NULL);
5459 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5460 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5461 todo_wine ok(size == 0xdeadbeef, "got size %lu\n", size);
5462
5463 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5464 ok(ret, "got error %lu\n", GetLastError());
5465 ok(!size, "got size %lu\n", size);
5466 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5467 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5468 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5469
5470 make_keepalive(kalive, 1, 0, 0);
5471 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5472 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5473
5474 make_keepalive(kalive, 1, 1000, 1000);
5475 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5476 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5477
5478 make_keepalive(kalive, 1, 10000, 10000);
5479 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5480 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5481
5482 make_keepalive(kalive, 1, 100, 100);
5483 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5484 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5485
5486 make_keepalive(kalive, 0, 100, 100);
5487 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
5488 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5489
5490 CloseHandle(port);
5491 closesocket(sock);
5492
5493 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5494
5495 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, NULL, &overlapped, socket_apc);
5496 ok(ret == -1, "expected failure\n");
5497 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5498
5499 apc_count = 0;
5500 size = 0xdeadbeef;
5501 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, &overlapped, socket_apc);
5502 ok(!ret, "expected success\n");
5503 ok(!size, "got size %lu\n", size);
5504
5505 ret = SleepEx(0, TRUE);
5506 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5507 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5508 ok(!apc_error, "got APC error %lu\n", apc_error);
5509 ok(!apc_size, "got APC size %lu\n", apc_size);
5510 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5511
5512 closesocket(sock);
5513 }
5514
5515 static void test_unsupported_ioctls(void)
5516 {
5517 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5518 unsigned int i;
5519 ULONG_PTR key;
5520 HANDLE port;
5521 DWORD size;
5522 SOCKET s;
5523 int ret;
5524
5525 static const DWORD codes[] = {0xdeadbeef, FIOASYNC, 0x667e, SIO_FLUSH};
5526
5527 for (i = 0; i < ARRAY_SIZE(codes); ++i)
5528 {
5529 winetest_push_context("ioctl %#lx", codes[i]);
5530 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5531 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
5532
5533 WSASetLastError(0xdeadbeef);
5534 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, NULL, &overlapped, NULL);
5535 ok(ret == -1, "expected failure\n");
5536 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5537
5538 WSASetLastError(0xdeadbeef);
5539 size = 0xdeadbeef;
5540 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, &size, NULL, NULL);
5541 ok(ret == -1, "expected failure\n");
5542 ok(WSAGetLastError() == WSAEOPNOTSUPP, "got error %u\n", WSAGetLastError());
5543 ok(!size, "got size %lu\n", size);
5544
5545 WSASetLastError(0xdeadbeef);
5546 size = 0xdeadbeef;
5547 overlapped.Internal = 0xdeadbeef;
5548 overlapped.InternalHigh = 0xdeadbeef;
5549 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, &size, &overlapped, NULL);
5550 ok(ret == -1, "expected failure\n");
5551 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
5552 ok(size == 0xdeadbeef, "got size %lu\n", size);
5553
5554 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5555 ok(!ret, "expected failure\n");
5556 ok(GetLastError() == ERROR_NOT_SUPPORTED, "got error %lu\n", GetLastError());
5557 ok(!size, "got size %lu\n", size);
5558 ok(key == 123, "got key %Iu\n", key);
5559 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5560 ok((NTSTATUS)overlapped.Internal == STATUS_NOT_SUPPORTED,
5561 "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5562 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5563
5564 CloseHandle(port);
5565 closesocket(s);
5566
5567 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5568
5569 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, NULL, &overlapped, socket_apc);
5570 ok(ret == -1, "expected failure\n");
5571 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5572
5573 apc_count = 0;
5574 size = 0xdeadbeef;
5575 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, &size, &overlapped, socket_apc);
5576 ok(ret == -1, "expected failure\n");
5577 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
5578 ok(size == 0xdeadbeef, "got size %lu\n", size);
5579
5580 ret = SleepEx(0, TRUE);
5581 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5582 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5583 ok(apc_error == WSAEOPNOTSUPP, "got APC error %lu\n", apc_error);
5584 ok(!apc_size, "got APC size %lu\n", apc_size);
5585 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5586
5587 closesocket(s);
5588 winetest_pop_context();
5589 }
5590 }
5591
5592 static void test_get_extension_func(void)
5593 {
5594 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5595 GUID acceptex_guid = WSAID_ACCEPTEX;
5596 GUID bogus_guid = {0xdeadbeef};
5597 ULONG_PTR key;
5598 HANDLE port;
5599 DWORD size;
5600 void *func;
5601 SOCKET s;
5602 int ret;
5603
5604 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5605 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
5606
5607 WSASetLastError(0xdeadbeef);
5608 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5609 &func, sizeof(func), NULL, &overlapped, NULL);
5610 ok(ret == -1, "expected failure\n");
5611 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5612
5613 WSASetLastError(0xdeadbeef);
5614 size = 0xdeadbeef;
5615 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5616 &func, sizeof(func), &size, NULL, NULL);
5617 ok(!ret, "expected success\n");
5618 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5619 ok(size == sizeof(func), "got size %lu\n", size);
5620
5621 WSASetLastError(0xdeadbeef);
5622 size = 0xdeadbeef;
5623 overlapped.Internal = 0xdeadbeef;
5624 overlapped.InternalHigh = 0xdeadbeef;
5625 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5626 &func, sizeof(func), &size, &overlapped, NULL);
5627 ok(!ret, "expected success\n");
5628 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5629 ok(size == sizeof(func), "got size %lu\n", size);
5630
5631 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5632 ok(ret, "got error %lu\n", GetLastError());
5633 ok(!size, "got size %lu\n", size);
5634 ok(key == 123, "got key %Iu\n", key);
5635 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5636 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5637 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5638
5639 size = 0xdeadbeef;
5640 overlapped.Internal = 0xdeadbeef;
5641 overlapped.InternalHigh = 0xdeadbeef;
5642 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &bogus_guid, sizeof(GUID),
5643 &func, sizeof(func), &size, &overlapped, NULL);
5644 ok(ret == -1, "expected failure\n");
5645 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
5646 ok(size == 0xdeadbeef, "got size %lu\n", size);
5647 ok(overlapped.Internal == 0xdeadbeef, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5648 ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
5649
5650 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5651 ok(!ret, "expected failure\n");
5652 ok(GetLastError() == WAIT_TIMEOUT, "got error %u\n", WSAGetLastError());
5653
5654 CloseHandle(port);
5655 closesocket(s);
5656
5657 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5658
5659 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5660 &func, sizeof(func), NULL, &overlapped, socket_apc);
5661 ok(ret == -1, "expected failure\n");
5662 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5663
5664 apc_count = 0;
5665 size = 0xdeadbeef;
5666 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
5667 &func, sizeof(func), &size, &overlapped, socket_apc);
5668 ok(!ret, "got error %u\n", WSAGetLastError());
5669 ok(size == sizeof(func), "got size %lu\n", size);
5670
5671 ret = SleepEx(0, TRUE);
5672 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5673 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5674 ok(!apc_error, "got APC error %lu\n", apc_error);
5675 ok(!apc_size, "got APC size %lu\n", apc_size);
5676 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5677
5678 closesocket(s);
5679 }
5680
5681 static void test_backlog_query(void)
5682 {
5683 const struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
5684 GUID acceptex_guid = WSAID_ACCEPTEX;
5685 LPFN_ACCEPTEX pAcceptEx;
5686 struct sockaddr_in destaddr;
5687 DWORD size;
5688 SOCKET s, listener;
5689 int len, ret;
5690 ULONG backlog = 0;
5691
5692 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5693 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
5694
5695 ret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(acceptex_guid),
5696 &pAcceptEx, sizeof(pAcceptEx), &size, NULL, NULL);
5697 ok(!ret, "failed to get AcceptEx, error %u\n", WSAGetLastError());
5698
5699 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
5700 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
5701 len = sizeof(destaddr);
5702 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
5703 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
5704 ret = listen(listener, 2);
5705 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
5706
5707 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5708 ret = WSAIoctl(s, SIO_IDEAL_SEND_BACKLOG_QUERY, NULL, 0, &backlog, sizeof(backlog), &size, NULL, NULL);
5709 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTCONN,
5710 "WSAIoctl() failed: %d/%d\n", ret, WSAGetLastError());
5711
5712 ret = connect(s, (struct sockaddr *)&destaddr, sizeof(destaddr));
5713 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
5714 ret = WSAIoctl(s, SIO_IDEAL_SEND_BACKLOG_QUERY, NULL, 0, &backlog, sizeof(backlog), &size, NULL, NULL);
5715 ok(!ret, "WSAIoctl() failed: %d\n", WSAGetLastError());
5716 ok(backlog == 0x10000, "got %08lx\n", backlog);
5717
5718 closesocket(listener);
5719 closesocket(s);
5720
5721 s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
5722
5723 backlog = 0;
5724 ret = WSAIoctl(s, SIO_IDEAL_SEND_BACKLOG_QUERY, NULL, 0, &backlog, sizeof(backlog), &size, NULL, NULL);
5725 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEOPNOTSUPP,
5726 "WSAIoctl() failed: %d/%d\n", ret, WSAGetLastError());
5727 closesocket(s);
5728 }
5729
5730 static void test_base_handle(void)
5731 {
5732 OVERLAPPED overlapped = {0}, *overlapped_ptr;
5733 unsigned int i;
5734 SOCKET s, base;
5735 ULONG_PTR key;
5736 HANDLE port;
5737 DWORD size;
5738 int ret;
5739
5740 static const struct
5741 {
5742 int family, type, protocol;
5743 }
5744 tests[] =
5745 {
5746 {AF_INET, SOCK_STREAM, IPPROTO_TCP},
5747 {AF_INET, SOCK_DGRAM, IPPROTO_UDP},
5748 {AF_INET6, SOCK_STREAM, IPPROTO_TCP},
5749 {AF_INET6, SOCK_DGRAM, IPPROTO_UDP},
5750 };
5751
5752 for (i = 0; i < ARRAY_SIZE(tests); ++i)
5753 {
5754 s = socket(tests[i].family, tests[i].type, tests[i].protocol);
5755 if (s == INVALID_SOCKET) continue;
5756 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
5757
5758 WSASetLastError(0xdeadbeef);
5759 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), NULL, &overlapped, NULL);
5760 ok(ret == -1, "expected failure\n");
5761 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5762
5763 WSASetLastError(0xdeadbeef);
5764 size = 0xdeadbeef;
5765 base = 0xdeadbeef;
5766 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), &size, NULL, NULL);
5767 ok(!ret, "expected success\n");
5768 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5769 ok(size == sizeof(base), "got size %lu\n", size);
5770 ok(base == s, "expected %#Ix, got %#Ix\n", s, base);
5771
5772 WSASetLastError(0xdeadbeef);
5773 size = 0xdeadbeef;
5774 base = 0xdeadbeef;
5775 overlapped.Internal = 0xdeadbeef;
5776 overlapped.InternalHigh = 0xdeadbeef;
5777 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), &size, &overlapped, NULL);
5778 ok(ret == -1, "expected failure\n");
5779 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
5780 ok(size == 0xdeadbeef, "got size %lu\n", size);
5781
5782 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
5783 ok(!ret, "expected failure\n");
5784 ok(GetLastError() == ERROR_NOT_SUPPORTED, "got error %lu\n", GetLastError());
5785 ok(!size, "got size %lu\n", size);
5786 ok(key == 123, "got key %Iu\n", key);
5787 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
5788 ok((NTSTATUS)overlapped.Internal == STATUS_NOT_SUPPORTED, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
5789 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
5790 ok(base == 0xdeadbeef, "expected %#Ix, got %#Ix\n", s, base);
5791
5792 CloseHandle(port);
5793 closesocket(s);
5794
5795 s = socket(tests[i].family, tests[i].type, tests[i].protocol);
5796
5797 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), NULL, &overlapped, socket_apc);
5798 ok(ret == -1, "expected failure\n");
5799 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
5800
5801 apc_count = 0;
5802 size = 0xdeadbeef;
5803 base = 0xdeadbeef;
5804 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), &size, &overlapped, socket_apc);
5805 ok(ret == -1, "expected failure\n");
5806 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
5807 ok(size == 0xdeadbeef, "got size %lu\n", size);
5808
5809 ret = SleepEx(0, TRUE);
5810 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
5811 ok(apc_count == 1, "APC was called %u times\n", apc_count);
5812 ok(apc_error == WSAEOPNOTSUPP, "got APC error %lu\n", apc_error);
5813 ok(!apc_size, "got APC size %lu\n", apc_size);
5814 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
5815 ok(base == 0xdeadbeef, "expected %#Ix, got %#Ix\n", s, base);
5816
5817 closesocket(s);
5818 }
5819 }
5820
5821 static void test_circular_queueing(void)
5822 {
5823 SOCKET s;
5824 DWORD size;
5825 int ret;
5826
5827 s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
5828 ret = WSAIoctl(s, SIO_ENABLE_CIRCULAR_QUEUEING, NULL, 0, NULL, 0, &size, NULL, NULL);
5829 ok(!ret, "expected 0, got %d\n", ret);
5830
5831 closesocket(s);
5832 }
5833
5834 static BOOL drain_pause = FALSE;
5835 static DWORD WINAPI drain_socket_thread(LPVOID arg)
5836 {
5837 char buffer[1024];
5838 SOCKET sock = *(SOCKET*)arg;
5839 int ret;
5840
5841 while ((ret = recv(sock, buffer, sizeof(buffer), 0)) != 0)
5842 {
5843 if (ret < 0)
5844 {
5845 if (WSAGetLastError() == WSAEWOULDBLOCK)
5846 {
5847 fd_set readset;
5848 FD_ZERO(&readset);
5849 FD_SET(sock, &readset);
5850 select(sock+1, &readset, NULL, NULL, NULL);
5851 while (drain_pause)
5852 Sleep(100);
5853 }
5854 else
5855 break;
5856 }
5857 }
5858 return 0;
5859 }
5860
5861 static void test_send(void)
5862 {
5863 SOCKET src = INVALID_SOCKET;
5864 SOCKET dst = INVALID_SOCKET;
5865 HANDLE hThread = NULL;
5866 const int buflen = 1024*1024;
5867 char *buffer = NULL;
5868 int ret, i, zero = 0;
5869 WSABUF buf;
5870 OVERLAPPED ov;
5871 BOOL bret;
5872 DWORD id, bytes_sent, dwRet;
5873
5874 memset(&ov, 0, sizeof(ov));
5875
5876 tcp_socketpair(&src, &dst);
5877
5878 set_blocking(dst, FALSE);
5879 /* force disable buffering so we can get a pending overlapped request */
5880 ret = setsockopt(dst, SOL_SOCKET, SO_SNDBUF, (char *) &zero, sizeof(zero));
5881 ok(!ret, "setsockopt SO_SNDBUF failed: %d - %ld\n", ret, GetLastError());
5882
5883 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
5884
5885 buffer = HeapAlloc(GetProcessHeap(), 0, buflen);
5886
5887 /* fill the buffer with some nonsense */
5888 for (i = 0; i < buflen; ++i)
5889 {
5890 buffer[i] = (char) i;
5891 }
5892
5893 ret = send(src, buffer, buflen, 0);
5894 ok(ret == buflen, "send should have sent %d bytes, but it only sent %d\n", buflen, ret);
5895
5896 buf.buf = buffer;
5897 buf.len = buflen;
5898
5899 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5900 ok(ov.hEvent != NULL, "could not create event object, errno = %ld\n", GetLastError());
5901 if (!ov.hEvent)
5902 goto end;
5903
5904 bytes_sent = 0;
5905 WSASetLastError(12345);
5906 ret = WSASend(dst, &buf, 1, &bytes_sent, 0, &ov, NULL);
5907 ok(ret == SOCKET_ERROR, "expected failure\n");
5908 ok(WSAGetLastError() == ERROR_IO_PENDING, "wrong error %u\n", WSAGetLastError());
5909
5910 /* don't check for completion yet, we may need to drain the buffer while still sending */
5911 set_blocking(src, FALSE);
5912 for (i = 0; i < buflen; ++i)
5913 {
5914 int j = 0;
5915
5916 ret = recv(src, buffer, 1, 0);
5917 while (ret == SOCKET_ERROR && GetLastError() == WSAEWOULDBLOCK && j < 100)
5918 {
5919 j++;
5920 Sleep(50);
5921 ret = recv(src, buffer, 1, 0);
5922 }
5923
5924 ok(ret == 1, "Failed to receive data %d - %ld (got %d/%d)\n", ret, GetLastError(), i, buflen);
5925 if (ret != 1)
5926 break;
5927
5928 ok(buffer[0] == (char) i, "Received bad data at position %d\n", i);
5929 }
5930
5931 dwRet = WaitForSingleObject(ov.hEvent, 1000);
5932 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %ld - %ld\n", dwRet, GetLastError());
5933 if (dwRet == WAIT_OBJECT_0)
5934 {
5935 bret = GetOverlappedResult((HANDLE)dst, &ov, &bytes_sent, FALSE);
5936 ok(bret && bytes_sent == buflen,
5937 "Got %ld instead of %d (%d - %ld)\n", bytes_sent, buflen, bret, GetLastError());
5938 }
5939
5940 WSASetLastError(12345);
5941 ret = WSASend(INVALID_SOCKET, &buf, 1, NULL, 0, &ov, NULL);
5942 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
5943 "WSASend failed %d - %d\n", ret, WSAGetLastError());
5944
5945 WSASetLastError(12345);
5946 ret = WSASend(dst, &buf, 1, NULL, 0, &ov, NULL);
5947 ok(ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING,
5948 "Failed to start overlapped send %d - %d\n", ret, WSAGetLastError());
5949
5950 end:
5951 if (src != INVALID_SOCKET)
5952 closesocket(src);
5953 if (dst != INVALID_SOCKET)
5954 closesocket(dst);
5955 if (hThread != NULL)
5956 {
5957 dwRet = WaitForSingleObject(hThread, 500);
5958 ok(dwRet == WAIT_OBJECT_0, "failed to wait for thread termination: %ld\n", GetLastError());
5959 CloseHandle(hThread);
5960 }
5961 if (ov.hEvent)
5962 CloseHandle(ov.hEvent);
5963 HeapFree(GetProcessHeap(), 0, buffer);
5964 }
5965
5966 #define WM_SOCKET (WM_USER+100)
5967
5968 struct event_test_ctx
5969 {
5970 int is_message;
5971 SOCKET socket;
5972 HANDLE event;
5973 HWND window;
5974 };
5975
5976 static void select_events(struct event_test_ctx *ctx, SOCKET socket, LONG events)
5977 {
5978 int ret;
5979
5980 if (ctx->is_message)
5981 ret = WSAAsyncSelect(socket, ctx->window, WM_USER, events);
5982 else
5983 ret = WSAEventSelect(socket, ctx->event, events);
5984 ok(!ret, "failed to select, error %u\n", WSAGetLastError());
5985 ctx->socket = socket;
5986 }
5987
5988 #define check_events(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, FALSE)
5989 #define check_events_todo(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, TRUE)
5990 #define check_events_todo_event(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, FALSE)
5991 #define check_events_todo_msg(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, TRUE)
5992 static void check_events_(int line, struct event_test_ctx *ctx,
5993 LONG flag1, LONG flag2, DWORD timeout, BOOL todo_event, BOOL todo_msg)
5994 {
5995 int ret;
5996
5997 if (ctx->is_message)
5998 {
5999 BOOL any_fail = FALSE;
6000 MSG msg;
6001
6002 if (flag1)
6003 {
6004 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6005 while (!ret && !MsgWaitForMultipleObjects(0, NULL, FALSE, timeout, QS_POSTMESSAGE))
6006 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6007 todo_wine_if (todo_msg && !ret) ok_(__FILE__, line)(ret, "expected a message\n");
6008 if (ret)
6009 {
6010 ok_(__FILE__, line)(msg.wParam == ctx->socket,
6011 "expected wparam %#Ix, got %#Ix\n", ctx->socket, msg.wParam);
6012 todo_wine_if (todo_msg && msg.lParam != flag1)
6013 ok_(__FILE__, line)(msg.lParam == flag1, "got first event %#Ix\n", msg.lParam);
6014 if (msg.lParam != flag1) any_fail = TRUE;
6015 }
6016 else
6017 any_fail = TRUE;
6018 }
6019 if (flag2)
6020 {
6021 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6022 while (!ret && !MsgWaitForMultipleObjects(0, NULL, FALSE, timeout, QS_POSTMESSAGE))
6023 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6024 ok_(__FILE__, line)(ret, "expected a message\n");
6025 ok_(__FILE__, line)(msg.wParam == ctx->socket, "got wparam %#Ix\n", msg.wParam);
6026 todo_wine_if (todo_msg) ok_(__FILE__, line)(msg.lParam == flag2, "got second event %#Ix\n", msg.lParam);
6027 }
6028 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
6029 todo_wine_if (todo_msg && ret) ok_(__FILE__, line)(!ret, "got unexpected event %#Ix\n", msg.lParam);
6030 if (ret) any_fail = TRUE;
6031
6032 /* catch tests which succeed */
6033 todo_wine_if (todo_msg) ok_(__FILE__, line)(!any_fail, "event series matches\n");
6034 }
6035 else
6036 {
6037 WSANETWORKEVENTS events;
6038 unsigned int i;
6039
6040 memset(&events, 0xcc, sizeof(events));
6041 ret = WaitForSingleObject(ctx->event, timeout);
6042 if (flag1 | flag2)
6043 todo_wine_if (todo_event && ret) ok_(__FILE__, line)(!ret, "event wait timed out\n");
6044 else
6045 todo_wine_if (todo_event) ok_(__FILE__, line)(ret == WAIT_TIMEOUT, "expected timeout\n");
6046 ret = WSAEnumNetworkEvents(ctx->socket, ctx->event, &events);
6047 ok_(__FILE__, line)(!ret, "failed to get events, error %u\n", WSAGetLastError());
6048 todo_wine_if (todo_event)
6049 ok_(__FILE__, line)(events.lNetworkEvents == LOWORD(flag1 | flag2), "got events %#lx\n", events.lNetworkEvents);
6050 for (i = 0; i < ARRAY_SIZE(events.iErrorCode); ++i)
6051 {
6052 if ((1u << i) == LOWORD(flag1) && (events.lNetworkEvents & LOWORD(flag1)))
6053 todo_wine_if (HIWORD(flag1)) ok_(__FILE__, line)(events.iErrorCode[i] == HIWORD(flag1),
6054 "got error code %d for event %#x\n", events.iErrorCode[i], 1u << i);
6055 if ((1u << i) == LOWORD(flag2) && (events.lNetworkEvents & LOWORD(flag2)))
6056 ok_(__FILE__, line)(events.iErrorCode[i] == HIWORD(flag2),
6057 "got error code %d for event %#x\n", events.iErrorCode[i], 1u << i);
6058 }
6059 }
6060 }
6061
6062 static void test_accept_events(struct event_test_ctx *ctx)
6063 {
6064 const struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
6065 SOCKET listener, server, client, client2;
6066 GUID acceptex_guid = WSAID_ACCEPTEX;
6067 struct sockaddr_in destaddr;
6068 OVERLAPPED overlapped = {0};
6069 LPFN_ACCEPTEX pAcceptEx;
6070 char buffer[32];
6071 int len, ret;
6072 DWORD size;
6073
6074 overlapped.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
6075
6076 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6077 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
6078
6079 ret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(acceptex_guid),
6080 &pAcceptEx, sizeof(pAcceptEx), &size, NULL, NULL);
6081 ok(!ret, "failed to get AcceptEx, error %u\n", WSAGetLastError());
6082
6083 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6084
6085 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
6086 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6087 len = sizeof(destaddr);
6088 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
6089 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6090 ret = listen(listener, 2);
6091 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
6092
6093 check_events(ctx, 0, 0, 0);
6094
6095 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6096 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6097 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6098 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6099
6100 check_events(ctx, FD_ACCEPT, 0, 200);
6101 check_events(ctx, 0, 0, 0);
6102 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6103 if (ctx->is_message)
6104 check_events(ctx, FD_ACCEPT, 0, 200);
6105 check_events(ctx, 0, 0, 0);
6106 select_events(ctx, listener, 0);
6107 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6108 if (ctx->is_message)
6109 check_events(ctx, FD_ACCEPT, 0, 200);
6110 check_events(ctx, 0, 0, 0);
6111
6112 client2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6113 ok(client2 != -1, "failed to create socket, error %u\n", WSAGetLastError());
6114 ret = connect(client2, (struct sockaddr *)&destaddr, sizeof(destaddr));
6115 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6116
6117 if (!ctx->is_message)
6118 check_events_todo(ctx, FD_ACCEPT, 0, 200);
6119 check_events(ctx, 0, 0, 0);
6120
6121 server = accept(listener, NULL, NULL);
6122 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6123 closesocket(server);
6124
6125 check_events(ctx, FD_ACCEPT, 0, 200);
6126 check_events(ctx, 0, 0, 0);
6127
6128 server = accept(listener, NULL, NULL);
6129 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6130 closesocket(server);
6131
6132 check_events(ctx, 0, 0, 0);
6133
6134 closesocket(client2);
6135 closesocket(client);
6136
6137 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6138 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6139 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6140 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6141
6142 check_events(ctx, FD_ACCEPT, 0, 200);
6143
6144 server = accept(listener, NULL, NULL);
6145 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6146 closesocket(server);
6147 closesocket(client);
6148
6149 check_events(ctx, 0, 0, 200);
6150
6151 closesocket(listener);
6152
6153 /* Connect and then select. */
6154
6155 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6156 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
6157 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
6158 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6159 len = sizeof(destaddr);
6160 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
6161 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6162 ret = listen(listener, 2);
6163 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
6164
6165 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6166 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6167 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6168 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6169
6170 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6171
6172 check_events(ctx, FD_ACCEPT, 0, 200);
6173
6174 server = accept(listener, NULL, NULL);
6175 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6176 closesocket(server);
6177 closesocket(client);
6178
6179 /* As above, but select on a subset containing FD_ACCEPT first. */
6180
6181 if (!ctx->is_message)
6182 {
6183 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6184
6185 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6186 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6187 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6188 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6189
6190 ret = WaitForSingleObject(ctx->event, 200);
6191 ok(!ret, "wait timed out\n");
6192
6193 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
6194 ret = WaitForSingleObject(ctx->event, 0);
6195 ok(!ret, "wait timed out\n");
6196
6197 ResetEvent(ctx->event);
6198
6199 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
6200 ret = WaitForSingleObject(ctx->event, 0);
6201 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
6202
6203 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6204 ret = WaitForSingleObject(ctx->event, 0);
6205 ok(!ret, "wait timed out\n");
6206 check_events(ctx, FD_ACCEPT, 0, 0);
6207
6208 server = accept(listener, NULL, NULL);
6209 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6210 closesocket(server);
6211 closesocket(client);
6212 }
6213
6214 /* As above, but select on a subset not containing FD_ACCEPT first. */
6215
6216 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
6217
6218 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6219 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6220 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6221 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6222
6223 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6224 check_events(ctx, FD_ACCEPT, 0, 200);
6225
6226 server = accept(listener, NULL, NULL);
6227 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6228 closesocket(server);
6229 closesocket(client);
6230
6231 /* As above, but call accept() before selecting. */
6232
6233 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
6234
6235 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6236 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6237 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6238 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6239 Sleep(200);
6240 server = accept(listener, NULL, NULL);
6241 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6242
6243 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6244 check_events(ctx, 0, 0, 200);
6245
6246 closesocket(server);
6247 closesocket(client);
6248
6249 closesocket(listener);
6250
6251 /* The socket returned from accept() inherits the same parameters. */
6252
6253 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6254 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
6255 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
6256 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6257 len = sizeof(destaddr);
6258 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
6259 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6260 ret = listen(listener, 2);
6261 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
6262
6263 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6264 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6265 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6266 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6267
6268 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT | FD_WRITE);
6269 check_events(ctx, FD_ACCEPT, 0, 200);
6270
6271 server = accept(listener, NULL, NULL);
6272 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6273 ctx->socket = server;
6274 check_events(ctx, FD_WRITE, 0, 200);
6275 check_events(ctx, 0, 0, 0);
6276
6277 closesocket(server);
6278 closesocket(client);
6279
6280 /* Connect while there is a pending AcceptEx(). */
6281
6282 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
6283
6284 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6285 ret = pAcceptEx(listener, server, buffer, 0, 0, sizeof(buffer), NULL, &overlapped);
6286 ok(!ret, "got %d\n", ret);
6287 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
6288
6289 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6290 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6291 ok(!ret, "got error %u\n", WSAGetLastError());
6292
6293 ret = WaitForSingleObject(overlapped.hEvent, 200);
6294 ok(!ret, "got %d\n", ret);
6295 ret = GetOverlappedResult((HANDLE)listener, &overlapped, &size, FALSE);
6296 ok(ret, "got error %lu\n", GetLastError());
6297 ok(!size, "got size %lu\n", size);
6298
6299 check_events(ctx, 0, 0, 0);
6300
6301 closesocket(server);
6302 closesocket(client);
6303
6304 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6305 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6306 ok(!ret, "got error %u\n", WSAGetLastError());
6307
6308 check_events(ctx, FD_ACCEPT, 0, 200);
6309 check_events(ctx, 0, 0, 0);
6310
6311 server = accept(listener, NULL, NULL);
6312 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6313 closesocket(server);
6314 closesocket(client);
6315
6316 closesocket(listener);
6317 CloseHandle(overlapped.hEvent);
6318 }
6319
6320 static void test_connect_events(struct event_test_ctx *ctx)
6321 {
6322 const struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
6323 SOCKET listener, server, client;
6324 struct sockaddr_in destaddr;
6325 int len, ret;
6326
6327 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6328 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
6329 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
6330 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6331 len = sizeof(destaddr);
6332 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
6333 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6334 ret = listen(listener, 2);
6335 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
6336
6337 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6338 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6339
6340 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6341 check_events(ctx, 0, 0, 0);
6342
6343 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6344 ok(!ret || WSAGetLastError() == WSAEWOULDBLOCK, "failed to connect, error %u\n", WSAGetLastError());
6345
6346 check_events(ctx, FD_CONNECT, FD_WRITE, 200);
6347 check_events(ctx, 0, 0, 0);
6348 select_events(ctx, client, 0);
6349 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6350 if (ctx->is_message)
6351 check_events(ctx, FD_WRITE, 0, 200);
6352 check_events(ctx, 0, 0, 0);
6353
6354 server = accept(listener, NULL, NULL);
6355 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6356
6357 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6358 check_events(ctx, FD_WRITE, 0, 200);
6359
6360 closesocket(client);
6361 closesocket(server);
6362
6363 /* Connect and then select. */
6364
6365 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6366 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6367
6368 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6369 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
6370
6371 server = accept(listener, NULL, NULL);
6372 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6373
6374 ret = send(client, "data", 5, 0);
6375 ok(ret == 5, "got %d\n", ret);
6376
6377 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6378 if (ctx->is_message)
6379 check_events(ctx, FD_WRITE, 0, 200);
6380 else
6381 check_events(ctx, FD_CONNECT, FD_WRITE, 200);
6382
6383 closesocket(client);
6384 closesocket(server);
6385
6386 /* As above, but select on a subset not containing FD_CONNECT first. */
6387
6388 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6389 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
6390
6391 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_OOB | FD_READ | FD_WRITE);
6392
6393 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
6394 ok(!ret || WSAGetLastError() == WSAEWOULDBLOCK, "failed to connect, error %u\n", WSAGetLastError());
6395
6396 server = accept(listener, NULL, NULL);
6397 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
6398
6399 check_events(ctx, FD_WRITE, 0, 200);
6400
6401 select_events(ctx, client, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6402
6403 if (ctx->is_message)
6404 check_events(ctx, FD_WRITE, 0, 200);
6405 else
6406 check_events(ctx, FD_CONNECT, 0, 200);
6407
6408 closesocket(client);
6409 closesocket(server);
6410
6411 /* Test with UDP sockets. */
6412
6413 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
6414 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
6415
6416 select_events(ctx, client, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6417 if (ctx->is_message)
6418 check_events(ctx, FD_WRITE, 0, 200);
6419 check_events_todo_event(ctx, 0, 0, 0);
6420
6421 ret = bind(server, (const struct sockaddr *)&addr, sizeof(addr));
6422 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6423 len = sizeof(destaddr);
6424 ret = getsockname(server, (struct sockaddr *)&destaddr, &len);
6425 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
6426 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
6427 ok(!ret, "got error %lu\n", GetLastError());
6428
6429 if (ctx->is_message)
6430 check_events_todo(ctx, FD_WRITE, 0, 200);
6431 else
6432 check_events_todo(ctx, FD_CONNECT, FD_WRITE, 200);
6433 check_events(ctx, 0, 0, 0);
6434
6435 closesocket(client);
6436 closesocket(server);
6437
6438 closesocket(listener);
6439 }
6440
6441 /* perform a blocking recv() even on a nonblocking socket */
6442 static int sync_recv(SOCKET s, void *buffer, int len, DWORD flags)
6443 {
6444 OVERLAPPED overlapped = {0};
6445 WSABUF wsabuf;
6446 DWORD ret_len;
6447 int ret;
6448
6449 overlapped.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
6450 wsabuf.buf = buffer;
6451 wsabuf.len = len;
6452 ret = WSARecv(s, &wsabuf, 1, &ret_len, &flags, &overlapped, NULL);
6453 if (ret == -1 && WSAGetLastError() == ERROR_IO_PENDING)
6454 {
6455 ret = WaitForSingleObject(overlapped.hEvent, 1000);
6456 ok(!ret, "wait timed out\n");
6457 ret = WSAGetOverlappedResult(s, &overlapped, &ret_len, FALSE, &flags);
6458 ret = (ret ? 0 : -1);
6459 }
6460 CloseHandle(overlapped.hEvent);
6461 if (!ret) return ret_len;
6462 return -1;
6463 }
6464
6465 static void test_write_events(struct event_test_ctx *ctx)
6466 {
6467 static const int buffer_size = 1024 * 1024;
6468 SOCKET server, client;
6469 char *buffer;
6470 int ret;
6471
6472 buffer = malloc(buffer_size);
6473
6474 tcp_socketpair(&client, &server);
6475 set_blocking(client, FALSE);
6476
6477 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6478 check_events(ctx, FD_WRITE, 0, 200);
6479 check_events(ctx, 0, 0, 0);
6480 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6481 if (ctx->is_message)
6482 check_events(ctx, FD_WRITE, 0, 200);
6483 check_events(ctx, 0, 0, 0);
6484 select_events(ctx, server, 0);
6485 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6486 if (ctx->is_message)
6487 check_events(ctx, FD_WRITE, 0, 200);
6488 check_events(ctx, 0, 0, 0);
6489
6490 ret = send(server, "data", 5, 0);
6491 ok(ret == 5, "got %d\n", ret);
6492
6493 check_events(ctx, 0, 0, 0);
6494
6495 ret = sync_recv(client, buffer, buffer_size, 0);
6496 ok(ret == 5, "got %d\n", ret);
6497
6498 check_events(ctx, 0, 0, 0);
6499
6500 if (!broken(1))
6501 {
6502 /* Windows will never send less than buffer_size bytes here, but Linux
6503 * may do a short write. */
6504 while ((ret = send(server, buffer, buffer_size, 0)) > 0);
6505 ok(ret == -1, "got %d\n", ret);
6506 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
6507
6508 while (recv(client, buffer, buffer_size, 0) > 0);
6509 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
6510
6511 /* Broken on Windows versions older than win10v1607 (though sometimes
6512 * works regardless, for unclear reasons. */
6513 check_events(ctx, FD_WRITE, 0, 200);
6514 check_events(ctx, 0, 0, 0);
6515 select_events(ctx, server, 0);
6516 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6517 if (ctx->is_message)
6518 check_events(ctx, FD_WRITE, 0, 200);
6519 check_events(ctx, 0, 0, 0);
6520 }
6521
6522 closesocket(server);
6523 closesocket(client);
6524
6525 /* Select on a subset not containing FD_WRITE first. */
6526
6527 tcp_socketpair(&client, &server);
6528 set_blocking(client, FALSE);
6529
6530 ret = send(client, "data", 5, 0);
6531 ok(ret == 5, "got %d\n", ret);
6532
6533 select_events(ctx, client, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ);
6534 if (!ctx->is_message)
6535 check_events(ctx, FD_CONNECT, 0, 200);
6536 check_events(ctx, 0, 0, 0);
6537
6538 select_events(ctx, client, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6539 check_events(ctx, FD_WRITE, 0, 200);
6540 check_events(ctx, 0, 0, 0);
6541
6542 closesocket(client);
6543 closesocket(server);
6544
6545 /* Despite the documentation, and unlike FD_ACCEPT and FD_RECV, calling
6546 * send() doesn't clear the FD_WRITE bit. */
6547
6548 tcp_socketpair(&client, &server);
6549
6550 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6551
6552 ret = send(server, "data", 5, 0);
6553 ok(ret == 5, "got %d\n", ret);
6554
6555 check_events(ctx, FD_WRITE, 0, 200);
6556
6557 closesocket(server);
6558 closesocket(client);
6559
6560 free(buffer);
6561 }
6562
6563 static void test_read_events(struct event_test_ctx *ctx)
6564 {
6565 OVERLAPPED overlapped = {0};
6566 SOCKET server, client;
6567 DWORD size, flags = 0;
6568 WSAPOLLFD pollfd;
6569 unsigned int i;
6570 char buffer[8];
6571 WSABUF wsabuf;
6572 HANDLE thread;
6573 int ret;
6574
6575 overlapped.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
6576
6577 tcp_socketpair(&client, &server);
6578 set_blocking(client, FALSE);
6579
6580 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6581 check_events(ctx, 0, 0, 0);
6582
6583 ret = send(client, "data", 5, 0);
6584 ok(ret == 5, "got %d\n", ret);
6585
6586 check_events(ctx, FD_READ, 0, 200);
6587 check_events(ctx, 0, 0, 0);
6588 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6589 if (ctx->is_message)
6590 check_events(ctx, FD_READ, 0, 200);
6591 check_events(ctx, 0, 0, 0);
6592 select_events(ctx, server, 0);
6593 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6594 if (ctx->is_message)
6595 check_events(ctx, FD_READ, 0, 200);
6596 check_events(ctx, 0, 0, 0);
6597
6598 ret = send(client, "data", 5, 0);
6599 ok(ret == 5, "got %d\n", ret);
6600
6601 if (!ctx->is_message)
6602 check_events_todo(ctx, FD_READ, 0, 200);
6603 check_events(ctx, 0, 0, 0);
6604
6605 ret = recv(server, buffer, 2, 0);
6606 ok(ret == 2, "got %d\n", ret);
6607
6608 check_events(ctx, FD_READ, 0, 200);
6609 check_events(ctx, 0, 0, 0);
6610
6611 ret = recv(server, buffer, -1, 0);
6612 ok(ret == -1, "got %d\n", ret);
6613 ok(WSAGetLastError() == WSAEFAULT || WSAGetLastError() == WSAENOBUFS /* < Windows 7 */,
6614 "got error %u\n", WSAGetLastError());
6615
6616 if (ctx->is_message)
6617 check_events_todo_msg(ctx, FD_READ, 0, 200);
6618 check_events(ctx, 0, 0, 0);
6619
6620 for (i = 0; i < 8; ++i)
6621 {
6622 ret = sync_recv(server, buffer, 1, 0);
6623 ok(ret == 1, "got %d\n", ret);
6624
6625 if (i < 7)
6626 check_events(ctx, FD_READ, 0, 200);
6627 check_events(ctx, 0, 0, 0);
6628 }
6629
6630 /* Send data while we're not selecting. */
6631
6632 select_events(ctx, server, 0);
6633 ret = send(client, "data", 5, 0);
6634 ok(ret == 5, "got %d\n", ret);
6635 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6636
6637 check_events(ctx, FD_READ, 0, 200);
6638
6639 ret = recv(server, buffer, 5, 0);
6640 ok(ret == 5, "got %d\n", ret);
6641
6642 select_events(ctx, server, 0);
6643 ret = send(client, "data", 5, 0);
6644 ok(ret == 5, "got %d\n", ret);
6645 ret = sync_recv(server, buffer, 5, 0);
6646 ok(ret == 5, "got %d\n", ret);
6647 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ);
6648
6649 check_events(ctx, 0, 0, 200);
6650
6651 /* Send data while we're polling for data but not selecting for FD_READ. */
6652
6653 pollfd.fd = server;
6654 pollfd.events = POLLIN;
6655 thread = CreateThread(NULL, 0, poll_async_thread, &pollfd, 0, NULL);
6656
6657 select_events(ctx, server, 0);
6658 ret = send(client, "data", 5, 0);
6659 ok(ret == 5, "got %d\n", ret);
6660
6661 ret = WaitForSingleObject(thread, 1000);
6662 ok(!ret, "wait timed out\n");
6663 CloseHandle(thread);
6664
6665 /* And check events, to show that WSAEnumNetworkEvents() should not clear
6666 * events we are not currently selecting for. */
6667 check_events(ctx, 0, 0, 0);
6668
6669 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
6670 check_events(ctx, FD_READ, FD_WRITE, 200);
6671 check_events(ctx, 0, 0, 0);
6672
6673 ret = sync_recv(server, buffer, 5, 0);
6674 ok(ret == 5, "got %d\n", ret);
6675
6676 /* Send data while there is a pending WSARecv(). */
6677
6678 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6679
6680 wsabuf.buf = buffer;
6681 wsabuf.len = 1;
6682 ret = WSARecv(server, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
6683 ok(ret == -1, "got %d\n", ret);
6684 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
6685
6686 ret = send(client, "a", 1, 0);
6687 ok(ret == 1, "got %d\n", ret);
6688
6689 ret = WaitForSingleObject(overlapped.hEvent, 200);
6690 ok(!ret, "got %d\n", ret);
6691 ret = GetOverlappedResult((HANDLE)server, &overlapped, &size, FALSE);
6692 ok(ret, "got error %lu\n", GetLastError());
6693 ok(size == 1, "got size %lu\n", size);
6694
6695 check_events(ctx, 0, 0, 0);
6696
6697 ret = send(client, "a", 1, 0);
6698 ok(ret == 1, "got %d\n", ret);
6699
6700 check_events(ctx, FD_READ, 0, 200);
6701 check_events(ctx, 0, 0, 0);
6702
6703 closesocket(server);
6704 closesocket(client);
6705 CloseHandle(overlapped.hEvent);
6706 }
6707
6708 static void test_oob_events(struct event_test_ctx *ctx)
6709 {
6710 SOCKET server, client;
6711 char buffer[1];
6712 int ret;
6713
6714 tcp_socketpair(&client, &server);
6715 set_blocking(client, FALSE);
6716
6717 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6718 check_events(ctx, 0, 0, 0);
6719
6720 ret = send(client, "a", 1, MSG_OOB);
6721 ok(ret == 1, "got %d\n", ret);
6722
6723 check_events(ctx, FD_OOB, 0, 200);
6724 check_events(ctx, 0, 0, 0);
6725 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6726 if (ctx->is_message)
6727 check_events(ctx, FD_OOB, 0, 200);
6728 check_events(ctx, 0, 0, 0);
6729 select_events(ctx, server, 0);
6730 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6731 if (ctx->is_message)
6732 check_events(ctx, FD_OOB, 0, 200);
6733 check_events(ctx, 0, 0, 0);
6734
6735 ret = send(client, "b", 1, MSG_OOB);
6736 ok(ret == 1, "got %d\n", ret);
6737
6738 if (!ctx->is_message)
6739 check_events_todo_event(ctx, FD_OOB, 0, 200);
6740 check_events(ctx, 0, 0, 0);
6741
6742 ret = recv(server, buffer, 1, MSG_OOB);
6743 ok(ret == 1, "got %d\n", ret);
6744
6745 check_events_todo(ctx, FD_OOB, 0, 200);
6746 check_events(ctx, 0, 0, 0);
6747
6748 ret = recv(server, buffer, 1, MSG_OOB);
6749 todo_wine ok(ret == 1, "got %d\n", ret);
6750
6751 check_events(ctx, 0, 0, 0);
6752
6753 /* Send data while we're not selecting. */
6754
6755 select_events(ctx, server, 0);
6756 ret = send(client, "a", 1, MSG_OOB);
6757 ok(ret == 1, "got %d\n", ret);
6758 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6759
6760 check_events(ctx, FD_OOB, 0, 200);
6761
6762 ret = recv(server, buffer, 1, MSG_OOB);
6763 ok(ret == 1, "got %d\n", ret);
6764
6765 closesocket(server);
6766 closesocket(client);
6767 }
6768
6769 static void test_close_events(struct event_test_ctx *ctx)
6770 {
6771 SOCKET server, client;
6772 char buffer[5];
6773 int ret;
6774
6775 /* Test closesocket(). */
6776
6777 tcp_socketpair(&client, &server);
6778
6779 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6780
6781 closesocket(client);
6782
6783 check_events(ctx, FD_CLOSE, 0, 200);
6784 check_events(ctx, 0, 0, 0);
6785 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6786 if (ctx->is_message)
6787 check_events(ctx, FD_CLOSE, 0, 200);
6788 check_events(ctx, 0, 0, 0);
6789 select_events(ctx, server, 0);
6790 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6791 if (ctx->is_message)
6792 check_events(ctx, FD_CLOSE, 0, 200);
6793 check_events(ctx, 0, 0, 0);
6794
6795 ret = recv(server, buffer, 5, 0);
6796 ok(!ret, "got %d\n", ret);
6797
6798 check_events(ctx, 0, 0, 0);
6799
6800 closesocket(server);
6801
6802 /* Test shutdown(remote end, SD_SEND). */
6803
6804 tcp_socketpair(&client, &server);
6805
6806 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6807
6808 shutdown(client, SD_SEND);
6809
6810 check_events(ctx, FD_CLOSE, 0, 200);
6811 check_events(ctx, 0, 0, 0);
6812
6813 closesocket(client);
6814
6815 check_events(ctx, 0, 0, 0);
6816
6817 closesocket(server);
6818
6819 /* No other shutdown() call generates an event. */
6820
6821 tcp_socketpair(&client, &server);
6822
6823 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6824
6825 shutdown(client, SD_RECEIVE);
6826 shutdown(server, SD_BOTH);
6827
6828 check_events(ctx, 0, 0, 200);
6829
6830 shutdown(client, SD_SEND);
6831
6832 check_events_todo(ctx, FD_CLOSE, 0, 200);
6833 check_events(ctx, 0, 0, 0);
6834
6835 closesocket(server);
6836 closesocket(client);
6837
6838 /* Test sending data before calling closesocket(). */
6839
6840 tcp_socketpair(&client, &server);
6841
6842 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6843
6844 ret = send(client, "data", 5, 0);
6845 ok(ret == 5, "got %d\n", ret);
6846
6847 check_events(ctx, FD_READ, 0, 200);
6848
6849 closesocket(client);
6850
6851 check_events_todo(ctx, FD_CLOSE, 0, 200);
6852
6853 ret = recv(server, buffer, 3, 0);
6854 ok(ret == 3, "got %d\n", ret);
6855
6856 check_events(ctx, FD_READ, 0, 200);
6857
6858 ret = recv(server, buffer, 5, 0);
6859 ok(ret == 2, "got %d\n", ret);
6860
6861 check_events_todo(ctx, 0, 0, 0);
6862
6863 closesocket(server);
6864
6865 /* Close and then select. */
6866
6867 tcp_socketpair(&client, &server);
6868 closesocket(client);
6869
6870 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6871 check_events(ctx, FD_CLOSE, 0, 200);
6872
6873 closesocket(server);
6874
6875 /* As above, but select on a subset not containing FD_CLOSE first. */
6876
6877 tcp_socketpair(&client, &server);
6878
6879 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ);
6880
6881 closesocket(client);
6882
6883 check_events(ctx, 0, 0, 200);
6884 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6885 check_events(ctx, FD_CLOSE, 0, 200);
6886
6887 closesocket(server);
6888
6889 /* Trigger RST. */
6890
6891 tcp_socketpair(&client, &server);
6892
6893 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6894
6895 close_with_rst(client);
6896
6897 check_events_todo_msg(ctx, MAKELONG(FD_CLOSE, WSAECONNABORTED), 0, 200);
6898 check_events(ctx, 0, 0, 0);
6899 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6900 if (ctx->is_message)
6901 check_events_todo(ctx, MAKELONG(FD_CLOSE, WSAECONNABORTED), 0, 200);
6902 check_events(ctx, 0, 0, 0);
6903 select_events(ctx, server, 0);
6904 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
6905 if (ctx->is_message)
6906 check_events_todo(ctx, MAKELONG(FD_CLOSE, WSAECONNABORTED), 0, 200);
6907 check_events(ctx, 0, 0, 0);
6908
6909 closesocket(server);
6910 }
6911
6912 static void test_events(void)
6913 {
6914 struct event_test_ctx ctx;
6915
6916 ctx.is_message = FALSE;
6917 ctx.event = CreateEventW(NULL, TRUE, FALSE, NULL);
6918
6919 test_accept_events(&ctx);
6920 test_connect_events(&ctx);
6921 test_write_events(&ctx);
6922 test_read_events(&ctx);
6923 test_close_events(&ctx);
6924 test_oob_events(&ctx);
6925
6926 CloseHandle(ctx.event);
6927
6928 ctx.is_message = TRUE;
6929 ctx.window = CreateWindowA("Message", NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, NULL, NULL);
6930
6931 test_accept_events(&ctx);
6932 test_connect_events(&ctx);
6933 test_write_events(&ctx);
6934 test_read_events(&ctx);
6935 test_close_events(&ctx);
6936 test_oob_events(&ctx);
6937
6938 DestroyWindow(ctx.window);
6939 }
6940
6941 static void test_ipv6only(void)
6942 {
6943 SOCKET v4 = INVALID_SOCKET, v6;
6944 struct sockaddr_in sin4;
6945 struct sockaddr_in6 sin6;
6946 int ret, enabled, len = sizeof(enabled);
6947
6948 memset(&sin4, 0, sizeof(sin4));
6949 sin4.sin_family = AF_INET;
6950 sin4.sin_port = htons(SERVERPORT);
6951
6952 memset(&sin6, 0, sizeof(sin6));
6953 sin6.sin6_family = AF_INET6;
6954 sin6.sin6_port = htons(SERVERPORT);
6955
6956 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
6957 if (v6 == INVALID_SOCKET)
6958 {
6959 skip("Could not create IPv6 socket (LastError: %d)\n", WSAGetLastError());
6960 goto end;
6961 }
6962
6963 enabled = 2;
6964 ret = getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
6965 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
6966 ok(enabled == 1, "expected 1, got %d\n", enabled);
6967
6968 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
6969 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
6970
6971 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6972 ok(v4 != INVALID_SOCKET, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
6973
6974 todo_wine {
6975 enabled = 2;
6976 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
6977 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
6978 ok(enabled == 1, "expected 1, got %d\n", enabled);
6979 }
6980
6981 enabled = 0;
6982 len = sizeof(enabled);
6983 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
6984 ok(!ret, "setsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
6985
6986 todo_wine {
6987 enabled = 2;
6988 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
6989 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
6990 ok(!enabled, "expected 0, got %d\n", enabled);
6991 }
6992
6993 enabled = 1;
6994 len = sizeof(enabled);
6995 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
6996 ok(!ret, "setsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
6997
6998 /* bind on IPv4 socket should succeed - IPV6_V6ONLY is enabled by default */
6999 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
7000 ok(!ret, "Could not bind IPv4 address (LastError: %d)\n", WSAGetLastError());
7001
7002 todo_wine {
7003 enabled = 2;
7004 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7005 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7006 ok(enabled == 1, "expected 1, got %d\n", enabled);
7007 }
7008
7009 enabled = 0;
7010 len = sizeof(enabled);
7011 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7012 ok(ret, "setsockopt(IPV6_V6ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
7013
7014 todo_wine {
7015 enabled = 0;
7016 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7017 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7018 ok(enabled == 1, "expected 1, got %d\n", enabled);
7019 }
7020
7021 enabled = 1;
7022 len = sizeof(enabled);
7023 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7024 ok(ret, "setsockopt(IPV6_V6ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
7025
7026 closesocket(v4);
7027 closesocket(v6);
7028
7029 /* Test again, this time disabling IPV6_V6ONLY. */
7030 sin4.sin_port = htons(SERVERPORT+2);
7031 sin6.sin6_port = htons(SERVERPORT+2);
7032
7033 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
7034 ok(v6 != INVALID_SOCKET, "Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
7035 WSAGetLastError(), WSAEAFNOSUPPORT);
7036
7037 enabled = 0;
7038 ret = setsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
7039 ok(!ret, "Could not disable IPV6_V6ONLY (LastError: %d).\n", WSAGetLastError());
7040
7041 enabled = 2;
7042 ret = getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7043 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7044 ok(!enabled, "expected 0, got %d\n", enabled);
7045
7046 /*
7047 Observaition:
7048 On Windows, bind on both IPv4 and IPv6 with IPV6_V6ONLY disabled succeeds by default.
7049 Application must set SO_EXCLUSIVEADDRUSE on first socket to disallow another successful bind.
7050 In general, a standard application should not use SO_REUSEADDR.
7051 Setting both SO_EXCLUSIVEADDRUSE and SO_REUSEADDR on the same socket is not possible in
7052 either order, the later setsockopt call always fails.
7053 */
7054 enabled = 1;
7055 ret = setsockopt(v6, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&enabled, len);
7056 ok(!ret, "Could not set SO_EXCLUSIVEADDRUSE on IPv6 socket (LastError: %d)\n", WSAGetLastError());
7057
7058 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
7059 ok(!ret, "Could not bind IPv6 address (LastError: %d)\n", WSAGetLastError());
7060
7061 enabled = 2;
7062 len = sizeof(enabled);
7063 getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
7064 ok(!ret, "getsockopt(IPV6_V6ONLY) failed (LastError: %d)\n", WSAGetLastError());
7065 ok(!enabled, "IPV6_V6ONLY is enabled after bind\n");
7066
7067 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7068 ok(v4 != INVALID_SOCKET, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
7069
7070 enabled = 1;
7071 ret = setsockopt(v4, SOL_SOCKET, SO_REUSEADDR, (char*)&enabled, len);
7072 ok(!ret, "Could not set SO_REUSEADDR on IPv4 socket (LastError: %d)\n", WSAGetLastError());
7073
7074 WSASetLastError(0xdeadbeef);
7075 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
7076 ok(ret, "bind succeeded unexpectedly for the IPv4 socket\n");
7077 ok(WSAGetLastError() == WSAEACCES, "Expected 10013, got %d\n", WSAGetLastError());
7078
7079 end:
7080 if (v4 != INVALID_SOCKET)
7081 closesocket(v4);
7082 if (v6 != INVALID_SOCKET)
7083 closesocket(v6);
7084 }
7085
7086 static void test_WSASendMsg(void)
7087 {
7088 SOCKET sock, dst;
7089 struct sockaddr_in sendaddr, sockaddr;
7090 GUID WSASendMsg_GUID = WSAID_WSASENDMSG;
7091 LPFN_WSASENDMSG pWSASendMsg = NULL;
7092 char teststr[12] = "hello world", buffer[32];
7093 WSABUF iovec[2];
7094 WSAMSG msg;
7095 DWORD bytesSent, err;
7096 int ret, addrlen;
7097
7098 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
7099
7100 sock = socket(AF_INET, SOCK_DGRAM, 0);
7101 ok(sock != INVALID_SOCKET, "socket() failed\n");
7102
7103 /* Obtain the WSASendMsg function */
7104 WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSASendMsg_GUID, sizeof(WSASendMsg_GUID),
7105 &pWSASendMsg, sizeof(pWSASendMsg), &err, NULL, NULL);
7106 if (!pWSASendMsg)
7107 {
7108 closesocket(sock);
7109 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
7110 return;
7111 }
7112
7113 /* fake address for now */
7114 sendaddr.sin_family = AF_INET;
7115 sendaddr.sin_port = htons(139);
7116 sendaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
7117
7118 memset(&msg, 0, sizeof(msg));
7119 iovec[0].buf = teststr;
7120 iovec[0].len = sizeof(teststr);
7121 iovec[1].buf = teststr;
7122 iovec[1].len = sizeof(teststr) / 2;
7123 msg.name = (struct sockaddr *) &sendaddr;
7124 msg.namelen = sizeof(sendaddr);
7125 msg.lpBuffers = iovec;
7126 msg.dwBufferCount = 1; /* send only one buffer for now */
7127
7128 WSASetLastError(0xdeadbeef);
7129 ret = pWSASendMsg(INVALID_SOCKET, &msg, 0, NULL, NULL, NULL);
7130 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7131 err = WSAGetLastError();
7132 ok(err == WSAENOTSOCK, "expected 10038, got %ld instead\n", err);
7133
7134 WSASetLastError(0xdeadbeef);
7135 ret = pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL);
7136 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7137 err = WSAGetLastError();
7138 ok(err == WSAEFAULT, "expected 10014, got %ld instead\n", err);
7139
7140 WSASetLastError(0xdeadbeef);
7141 ret = pWSASendMsg(sock, NULL, 0, &bytesSent, NULL, NULL);
7142 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7143 err = WSAGetLastError();
7144 ok(err == WSAEFAULT, "expected 10014, got %ld instead\n", err);
7145
7146 WSASetLastError(0xdeadbeef);
7147 ret = pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL);
7148 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7149 err = WSAGetLastError();
7150 ok(err == WSAEFAULT, "expected 10014, got %ld instead\n", err);
7151
7152 closesocket(sock);
7153
7154 sock = socket(AF_INET, SOCK_DGRAM, 0);
7155 ok(sock != INVALID_SOCKET, "socket() failed\n");
7156
7157 dst = socket(AF_INET, SOCK_DGRAM, 0);
7158 ok(dst != INVALID_SOCKET, "socket() failed\n");
7159
7160 memset(&sockaddr, 0, sizeof(sockaddr));
7161 sockaddr.sin_family = AF_INET;
7162 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
7163 ok(!bind(dst, (struct sockaddr*)&sockaddr, sizeof(sockaddr)),
7164 "bind should have worked\n");
7165
7166 /* read address to find out the port number to be used in send */
7167 memset(&sendaddr, 0, sizeof(sendaddr));
7168 addrlen = sizeof(sendaddr);
7169 ok(!getsockname(dst, (struct sockaddr *) &sendaddr, &addrlen),
7170 "getsockname should have worked\n");
7171 ok(sendaddr.sin_port, "socket port should be != 0\n");
7172
7173 /* ensure the sending socket is not bound */
7174 WSASetLastError(0xdeadbeef);
7175 addrlen = sizeof(sockaddr);
7176 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
7177 ok(ret == SOCKET_ERROR, "getsockname should have failed\n");
7178 err = WSAGetLastError();
7179 ok(err == WSAEINVAL, "expected 10022, got %ld instead\n", err);
7180
7181 set_blocking(sock, TRUE);
7182
7183 bytesSent = 0;
7184 SetLastError(0xdeadbeef);
7185 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
7186 ok(!ret, "WSASendMsg should have worked\n");
7187 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
7188 "Expected 0, got %ld\n", GetLastError());
7189 ok(bytesSent == iovec[0].len, "incorrect bytes sent, expected %ld, sent %ld\n",
7190 iovec[0].len, bytesSent);
7191
7192 /* receive data */
7193 addrlen = sizeof(sockaddr);
7194 memset(buffer, 0, sizeof(buffer));
7195 SetLastError(0xdeadbeef);
7196 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
7197 ok(ret == bytesSent, "got %d, expected %ld\n",
7198 ret, bytesSent);
7199 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7200
7201 /* A successful call to WSASendMsg must have bound the socket */
7202 addrlen = sizeof(sockaddr);
7203 sockaddr.sin_port = 0;
7204 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
7205 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
7206 ok(!ret, "getsockname should have worked\n");
7207 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
7208 inet_ntoa(sockaddr.sin_addr));
7209 ok(sockaddr.sin_port, "sin_port should be != 0\n");
7210
7211 msg.dwBufferCount = 2; /* send both buffers */
7212
7213 bytesSent = 0;
7214 SetLastError(0xdeadbeef);
7215 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
7216 ok(!ret, "WSASendMsg should have worked\n");
7217 ok(bytesSent == iovec[0].len + iovec[1].len, "incorrect bytes sent, expected %ld, sent %ld\n",
7218 iovec[0].len + iovec[1].len, bytesSent);
7219 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
7220 "Expected 0, got %ld\n", GetLastError());
7221
7222 /* receive data */
7223 addrlen = sizeof(sockaddr);
7224 memset(buffer, 0, sizeof(buffer));
7225 SetLastError(0xdeadbeef);
7226 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
7227 ok(ret == bytesSent, "got %d, expected %ld\n",
7228 ret, bytesSent);
7229 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7230
7231 closesocket(sock);
7232 closesocket(dst);
7233
7234 /* a bad call to WSASendMsg will also bind the socket */
7235 addrlen = sizeof(sockaddr);
7236 sockaddr.sin_port = 0;
7237 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
7238 sock = socket(AF_INET, SOCK_DGRAM, 0);
7239 ok(sock != INVALID_SOCKET, "socket() failed\n");
7240 ok(pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
7241 todo_wine {
7242 ok(!getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have worked\n");
7243 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
7244 inet_ntoa(sockaddr.sin_addr));
7245 ok(sockaddr.sin_port, "sin_port should be > 0\n");
7246 }
7247 closesocket(sock);
7248
7249 /* a bad call without msg parameter will not trigger the auto-bind */
7250 sock = socket(AF_INET, SOCK_DGRAM, 0);
7251 ok(sock != INVALID_SOCKET, "socket() failed\n");
7252 ok(pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
7253 ok(getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have failed\n");
7254 err = WSAGetLastError();
7255 ok(err == WSAEINVAL, "expected 10022, got %ld instead\n", err);
7256 closesocket(sock);
7257
7258 /* SOCK_STREAM sockets are not supported */
7259 bytesSent = 0;
7260 sock = socket(AF_INET, SOCK_STREAM, 0);
7261 ok(sock != INVALID_SOCKET, "socket() failed\n");
7262 SetLastError(0xdeadbeef);
7263 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
7264 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
7265 err = WSAGetLastError();
7266 todo_wine
7267 ok(err == WSAEINVAL, "expected 10014, got %ld instead\n", err);
7268 closesocket(sock);
7269 }
7270
7271 static void test_WSASendTo(void)
7272 {
7273 SOCKET s;
7274 struct sockaddr_in addr, ret_addr;
7275 char buf[12] = "hello world";
7276 WSABUF data_buf;
7277 DWORD bytesSent;
7278 int ret, len;
7279
7280 addr.sin_family = AF_INET;
7281 addr.sin_port = htons(139);
7282 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
7283 data_buf.len = sizeof(buf);
7284 data_buf.buf = buf;
7285
7286 s = socket(AF_INET, SOCK_DGRAM, 0);
7287 ok(s != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
7288
7289 WSASetLastError(12345);
7290 ret = WSASendTo(INVALID_SOCKET, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
7291 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
7292 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
7293
7294 len = sizeof(ret_addr);
7295 ret = getsockname(s, (struct sockaddr *)&ret_addr, &len);
7296 ok(ret == -1, "expected failure\n");
7297 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
7298
7299 WSASetLastError(12345);
7300 ret = WSASendTo(s, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
7301 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
7302 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
7303
7304 WSASetLastError(12345);
7305 ret = WSASendTo(s, &data_buf, 1, &bytesSent, 0, (struct sockaddr *)&addr, sizeof(addr), NULL, NULL);
7306 ok(!ret, "expected success\n");
7307 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
7308
7309 len = sizeof(ret_addr);
7310 ret = getsockname(s, (struct sockaddr *)&ret_addr, &len);
7311 ok(!ret, "got error %u\n", WSAGetLastError());
7312 ok(ret_addr.sin_family == AF_INET, "got family %u\n", ret_addr.sin_family);
7313 ok(ret_addr.sin_port, "expected nonzero port\n");
7314 }
7315
7316 struct recv_thread_apc_param
7317 {
7318 SOCKET sock;
7319 unsigned int apc_count;
7320 };
7321
7322 static void WINAPI recv_thread_apc_func(ULONG_PTR param)
7323 {
7324 struct recv_thread_apc_param *p = (struct recv_thread_apc_param *)param;
7325 int ret;
7326
7327 ++p->apc_count;
7328
7329 ret = send(p->sock, "test", 4, 0);
7330 ok(ret == 4, "got %d.\n", ret);
7331 }
7332
7333 struct recv_thread_param
7334 {
7335 SOCKET sock;
7336 BOOL overlapped;
7337 };
7338
7339 static DWORD WINAPI recv_thread(LPVOID arg)
7340 {
7341 struct recv_thread_param *p = arg;
7342 SOCKET sock = p->sock;
7343 char buffer[32];
7344 WSABUF wsa;
7345 WSAOVERLAPPED ov;
7346 DWORD flags = 0;
7347 DWORD len;
7348 int ret;
7349
7350 wsa.buf = buffer;
7351 wsa.len = sizeof(buffer);
7352 if (p->overlapped)
7353 {
7354 ov.hEvent = WSACreateEvent();
7355 WSARecv(sock, &wsa, 1, NULL, &flags, &ov, NULL);
7356
7357 WaitForSingleObject(ov.hEvent, 1000);
7358 WSACloseEvent(ov.hEvent);
7359 }
7360 else
7361 {
7362 SetLastError(0xdeadbeef);
7363 ret = WSARecv(sock, &wsa, 1, &len, &flags, NULL, NULL);
7364 ok(!ret, "got ret %d.\n", ret);
7365 ok(WSAGetLastError() == 0, "got error %d.\n", WSAGetLastError());
7366 ok(len == 4, "got len %lu.\n", len);
7367 }
7368 return 0;
7369 }
7370
7371 static int completion_called;
7372
7373 static void WINAPI io_completion(DWORD error, DWORD transferred, WSAOVERLAPPED *overlapped, DWORD flags)
7374 {
7375 completion_called++;
7376 }
7377
7378 static void test_WSARecv(void)
7379 {
7380 SOCKET src, dest, server = INVALID_SOCKET;
7381 struct recv_thread_apc_param apc_param;
7382 struct recv_thread_param recv_param;
7383 char buf[20];
7384 WSABUF bufs[2];
7385 WSAOVERLAPPED ov;
7386 DWORD bytesReturned, flags, id;
7387 struct sockaddr_in addr;
7388 unsigned int apc_count;
7389 int iret, len;
7390 DWORD dwret;
7391 BOOL bret;
7392 HANDLE thread, event = NULL, io_port;
7393
7394 tcp_socketpair(&src, &dest);
7395
7396 memset(&ov, 0, sizeof(ov));
7397 flags = 0;
7398 bufs[0].len = 2;
7399 bufs[0].buf = buf;
7400
7401 /* Send 4 bytes and receive in two calls of 2 */
7402 SetLastError(0xdeadbeef);
7403 iret = send(src, "test", 4, 0);
7404 ok(iret == 4, "Expected 4, got %d\n", iret);
7405 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7406 SetLastError(0xdeadbeef);
7407 bytesReturned = 0xdeadbeef;
7408
7409 apc_count = 0;
7410 dwret = QueueUserAPC(apc_func, GetCurrentThread(), (ULONG_PTR)&apc_count);
7411 ok(dwret, "QueueUserAPC returned %lu\n", dwret);
7412
7413 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
7414 ok(!iret, "Expected 0, got %d\n", iret);
7415 ok(bytesReturned == 2, "Expected 2, got %ld\n", bytesReturned);
7416 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7417
7418 ok(!apc_count, "got apc_count %u.\n", apc_count);
7419 SleepEx(0, TRUE);
7420 ok(apc_count == 1, "got apc_count %u.\n", apc_count);
7421
7422 SetLastError(0xdeadbeef);
7423 bytesReturned = 0xdeadbeef;
7424 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
7425 ok(!iret, "Expected 0, got %d\n", iret);
7426 ok(bytesReturned == 2, "Expected 2, got %ld\n", bytesReturned);
7427 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7428
7429 bufs[0].len = 4;
7430 SetLastError(0xdeadbeef);
7431 iret = send(src, "test", 4, 0);
7432 ok(iret == 4, "Expected 4, got %d\n", iret);
7433 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7434 SetLastError(0xdeadbeef);
7435 bytesReturned = 0xdeadbeef;
7436 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
7437 ok(!iret, "Expected 0, got %d\n", iret);
7438 ok(bytesReturned == 4, "Expected 4, got %ld\n", bytesReturned);
7439 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7440
7441 /* Test 2 buffers */
7442 bufs[0].len = 4;
7443 bufs[1].len = 5;
7444 bufs[1].buf = buf + 10;
7445 SetLastError(0xdeadbeef);
7446 iret = send(src, "deadbeefs", 9, 0);
7447 ok(iret == 9, "Expected 9, got %d\n", iret);
7448 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7449 SetLastError(0xdeadbeef);
7450 bytesReturned = 0xdeadbeef;
7451 iret = WSARecv(dest, bufs, 2, &bytesReturned, &flags, NULL, NULL);
7452 ok(!iret, "Expected 0, got %d\n", iret);
7453 ok(bytesReturned == 9, "Expected 9, got %ld\n", bytesReturned);
7454 bufs[0].buf[4] = '\0';
7455 bufs[1].buf[5] = '\0';
7456 ok(!strcmp(bufs[0].buf, "dead"), "buf[0] doesn't match: %s != dead\n", bufs[0].buf);
7457 ok(!strcmp(bufs[1].buf, "beefs"), "buf[1] doesn't match: %s != beefs\n", bufs[1].buf);
7458 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %ld\n", GetLastError());
7459
7460 bufs[0].len = sizeof(buf);
7461 ov.hEvent = event = CreateEventA(NULL, FALSE, FALSE, NULL);
7462 ok(ov.hEvent != NULL, "could not create event object, errno = %ld\n", GetLastError());
7463 if (!event)
7464 goto end;
7465
7466 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, NULL);
7467 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %ld\n", iret, GetLastError());
7468
7469 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, &ov, NULL);
7470 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %ld\n", iret, GetLastError());
7471
7472 close_with_rst(src);
7473
7474 dwret = WaitForSingleObject(ov.hEvent, 1000);
7475 ok(dwret == WAIT_OBJECT_0, "Waiting for disconnect event failed with %ld + errno %ld\n", dwret, GetLastError());
7476
7477 bret = GetOverlappedResult((HANDLE)dest, &ov, &bytesReturned, FALSE);
7478 ok(!bret, "expected failure\n");
7479 ok(GetLastError() == ERROR_NETNAME_DELETED, "got error %lu\n", GetLastError());
7480 ok(bytesReturned == 0, "Bytes received is %ld\n", bytesReturned);
7481 closesocket(dest);
7482 dest = INVALID_SOCKET;
7483
7484 src = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
7485 ok(src != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
7486 if (src == INVALID_SOCKET) goto end;
7487
7488 server = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
7489 ok(server != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
7490 if (server == INVALID_SOCKET) goto end;
7491
7492 memset(&addr, 0, sizeof(addr));
7493 addr.sin_family = AF_INET;
7494 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
7495 iret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
7496 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
7497
7498 len = sizeof(addr);
7499 iret = getsockname(server, (struct sockaddr *)&addr, &len);
7500 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
7501
7502 iret = listen(server, 1);
7503 ok(!iret, "failed to listen, error %u\n", WSAGetLastError());
7504
7505 iret = connect(src, (struct sockaddr *)&addr, sizeof(addr));
7506 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
7507
7508 len = sizeof(addr);
7509 dest = accept(server, (struct sockaddr *)&addr, &len);
7510 ok(dest != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
7511 if (dest == INVALID_SOCKET) goto end;
7512
7513 send(src, "test message", sizeof("test message"), 0);
7514 recv_param.sock = dest;
7515 recv_param.overlapped = TRUE;
7516 thread = CreateThread(NULL, 0, recv_thread, &recv_param, 0, &id);
7517 WaitForSingleObject(thread, 3000);
7518 CloseHandle(thread);
7519
7520 recv_param.overlapped = FALSE;
7521 thread = CreateThread(NULL, 0, recv_thread, &recv_param, 0, &id);
7522 apc_param.apc_count = 0;
7523 apc_param.sock = src;
7524 dwret = QueueUserAPC(recv_thread_apc_func, thread, (ULONG_PTR)&apc_param);
7525 ok(dwret, "QueueUserAPC returned %lu\n", dwret);
7526 WaitForSingleObject(thread, 3000);
7527 ok(apc_param.apc_count == 1, "got apc_count %u.\n", apc_param.apc_count);
7528
7529 CloseHandle(thread);
7530
7531 memset(&ov, 0, sizeof(ov));
7532 ov.hEvent = event;
7533 ResetEvent(event);
7534 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, io_completion);
7535 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %ld\n", iret, GetLastError());
7536 send(src, "test message", sizeof("test message"), 0);
7537
7538 completion_called = 0;
7539 dwret = SleepEx(1000, TRUE);
7540 ok(dwret == WAIT_IO_COMPLETION, "got %lu\n", dwret);
7541 ok(completion_called == 1, "completion not called\n");
7542
7543 dwret = WaitForSingleObject(event, 1);
7544 ok(dwret == WAIT_TIMEOUT, "got %lu\n", dwret);
7545
7546 io_port = CreateIoCompletionPort( (HANDLE)dest, NULL, 0, 0 );
7547 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
7548
7549 /* Using completion function on socket associated with completion port is not allowed. */
7550 memset(&ov, 0, sizeof(ov));
7551 completion_called = 0;
7552 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, io_completion);
7553 ok(iret == SOCKET_ERROR && GetLastError() == WSAEINVAL, "WSARecv failed - %d error %ld\n", iret, GetLastError());
7554 ok(!completion_called, "completion called\n");
7555
7556 CloseHandle(io_port);
7557
7558 end:
7559 if (server != INVALID_SOCKET)
7560 closesocket(server);
7561 if (dest != INVALID_SOCKET)
7562 closesocket(dest);
7563 if (src != INVALID_SOCKET)
7564 closesocket(src);
7565 if (event)
7566 WSACloseEvent(event);
7567 }
7568
7569 struct write_watch_thread_args
7570 {
7571 int func;
7572 SOCKET dest;
7573 void *base;
7574 DWORD size;
7575 const char *expect;
7576 };
7577
7578 static DWORD CALLBACK write_watch_thread( void *arg )
7579 {
7580 struct write_watch_thread_args *args = arg;
7581 struct sockaddr addr;
7582 int addr_len = sizeof(addr), ret;
7583 DWORD bytes, flags = 0;
7584 WSABUF buf[1];
7585
7586 switch (args->func)
7587 {
7588 case 0:
7589 ret = recv( args->dest, args->base, args->size, 0 );
7590 ok( ret == strlen(args->expect) + 1, "wrong len %d\n", ret );
7591 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
7592 break;
7593 case 1:
7594 ret = recvfrom( args->dest, args->base, args->size, 0, &addr, &addr_len );
7595 ok( ret == strlen(args->expect) + 1, "wrong len %d\n", ret );
7596 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
7597 break;
7598 case 2:
7599 buf[0].len = args->size;
7600 buf[0].buf = args->base;
7601 ret = WSARecv( args->dest, buf, 1, &bytes, &flags, NULL, NULL );
7602 ok( !ret, "WSARecv failed %lu\n", GetLastError() );
7603 ok( bytes == strlen(args->expect) + 1, "wrong len %ld\n", bytes );
7604 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
7605 break;
7606 case 3:
7607 buf[0].len = args->size;
7608 buf[0].buf = args->base;
7609 ret = WSARecvFrom( args->dest, buf, 1, &bytes, &flags, &addr, &addr_len, NULL, NULL );
7610 ok( !ret, "WSARecvFrom failed %lu\n", GetLastError() );
7611 ok( bytes == strlen(args->expect) + 1, "wrong len %ld\n", bytes );
7612 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
7613 break;
7614 }
7615 return 0;
7616 }
7617
7618 static void test_write_watch(void)
7619 {
7620 SOCKET src, dest;
7621 WSABUF bufs[2];
7622 WSAOVERLAPPED ov;
7623 struct write_watch_thread_args args;
7624 DWORD bytesReturned, flags, size;
7625 struct sockaddr addr;
7626 int addr_len, ret;
7627 HANDLE thread, event;
7628 char *base;
7629 void *results[64];
7630 ULONG_PTR count;
7631 ULONG pagesize;
7632 UINT (WINAPI *pGetWriteWatch)(DWORD,LPVOID,SIZE_T,LPVOID*,ULONG_PTR*,ULONG*);
7633
7634 pGetWriteWatch = (void *)GetProcAddress( GetModuleHandleA("kernel32.dll"), "GetWriteWatch" );
7635 if (!pGetWriteWatch)
7636 {
7637 win_skip( "write watched not supported\n" );
7638 return;
7639 }
7640
7641 tcp_socketpair(&src, &dest);
7642
7643 memset(&ov, 0, sizeof(ov));
7644 ov.hEvent = event = CreateEventA(NULL, FALSE, FALSE, NULL);
7645 ok(ov.hEvent != NULL, "could not create event object, errno = %ld\n", GetLastError());
7646
7647 flags = 0;
7648
7649 size = 0x10000;
7650 base = VirtualAlloc( 0, size, MEM_RESERVE | MEM_COMMIT | MEM_WRITE_WATCH, PAGE_READWRITE );
7651 ok( base != NULL, "VirtualAlloc failed %lu\n", GetLastError() );
7652
7653 memset( base, 0, size );
7654 count = 64;
7655 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7656 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7657 ok( count == 16, "wrong count %Iu\n", count );
7658
7659 bufs[0].len = 5;
7660 bufs[0].buf = base;
7661 bufs[1].len = 0x8000;
7662 bufs[1].buf = base + 0x4000;
7663
7664 ret = WSARecv( dest, bufs, 2, NULL, &flags, &ov, NULL);
7665 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
7666 "WSARecv failed - %d error %ld\n", ret, GetLastError());
7667
7668 count = 64;
7669 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7670 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7671 ok( count == 9, "wrong count %Iu\n", count );
7672 ok( !base[0], "data set\n" );
7673
7674 send(src, "test message", sizeof("test message"), 0);
7675
7676 ret = GetOverlappedResult( (HANDLE)dest, &ov, &bytesReturned, TRUE );
7677 ok( ret, "GetOverlappedResult failed %lu\n", GetLastError() );
7678 ok( bytesReturned == sizeof("test message"), "wrong size %lu\n", bytesReturned );
7679 ok( !memcmp( base, "test ", 5 ), "wrong data %s\n", base );
7680 ok( !memcmp( base + 0x4000, "message", 8 ), "wrong data %s\n", base + 0x4000 );
7681
7682 count = 64;
7683 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7684 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7685 ok( count == 0, "wrong count %Iu\n", count );
7686
7687 memset( base, 0, size );
7688 count = 64;
7689 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7690 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7691 ok( count == 16, "wrong count %Iu\n", count );
7692
7693 bufs[1].len = 0x4000;
7694 bufs[1].buf = base + 0x2000;
7695 ret = WSARecvFrom( dest, bufs, 2, NULL, &flags, &addr, &addr_len, &ov, NULL);
7696 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
7697 "WSARecv failed - %d error %ld\n", ret, GetLastError());
7698
7699 count = 64;
7700 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7701 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7702 ok( count == 5, "wrong count %Iu\n", count );
7703 ok( !base[0], "data set\n" );
7704
7705 send(src, "test message", sizeof("test message"), 0);
7706
7707 ret = GetOverlappedResult( (HANDLE)dest, &ov, &bytesReturned, TRUE );
7708 ok( ret, "GetOverlappedResult failed %lu\n", GetLastError() );
7709 ok( bytesReturned == sizeof("test message"), "wrong size %lu\n", bytesReturned );
7710 ok( !memcmp( base, "test ", 5 ), "wrong data %s\n", base );
7711 ok( !memcmp( base + 0x2000, "message", 8 ), "wrong data %s\n", base + 0x2000 );
7712
7713 count = 64;
7714 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7715 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7716 ok( count == 0, "wrong count %Iu\n", count );
7717
7718 memset( base, 0, size );
7719 count = 64;
7720 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7721 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7722 ok( count == 16, "wrong count %Iu\n", count );
7723
7724 args.dest = dest;
7725 args.base = base;
7726 args.size = 0x7002;
7727 args.expect = "test message";
7728 for (args.func = 0; args.func < 4; args.func++)
7729 {
7730 thread = CreateThread( NULL, 0, write_watch_thread, &args, 0, NULL );
7731 Sleep( 200 );
7732
7733 count = 64;
7734 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7735 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7736 ok( count == 8, "wrong count %Iu\n", count );
7737
7738 send(src, "test message", sizeof("test message"), 0);
7739 WaitForSingleObject( thread, 10000 );
7740 CloseHandle( thread );
7741
7742 count = 64;
7743 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7744 ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
7745 ok( count == 0, "wrong count %Iu\n", count );
7746 }
7747 WSACloseEvent( event );
7748 closesocket( dest );
7749 closesocket( src );
7750 VirtualFree( base, 0, MEM_FREE );
7751 }
7752
7753 static void test_WSAPoll(void)
7754 {
7755 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
7756 int ret, err, len;
7757 SOCKET listener, server, client;
7758 struct sockaddr_in address;
7759 WSAPOLLFD fds[16];
7760 HANDLE thread_handle;
7761 unsigned int i;
7762 char buffer[6];
7763
7764 static const short invalid_flags[] =
7765 {POLLERR, POLLHUP, POLLNVAL, 0x8, POLLWRBAND, 0x40, 0x80, POLLPRI, 0x800, 0x1000, 0x2000, 0x4000, 0x8000};
7766
7767 if (!pWSAPoll) /* >= Vista */
7768 {
7769 win_skip("WSAPoll is unsupported, some tests will be skipped.\n");
7770 return;
7771 }
7772
7773 /* Invalid parameters test */
7774 SetLastError(0xdeadbeef);
7775 ret = pWSAPoll(NULL, 0, 0);
7776 err = GetLastError();
7777 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7778 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
7779 SetLastError(0xdeadbeef);
7780 ret = pWSAPoll(NULL, 1, 0);
7781 err = GetLastError();
7782 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7783 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
7784 SetLastError(0xdeadbeef);
7785 ret = pWSAPoll(NULL, 0, 1);
7786 err = GetLastError();
7787 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7788 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
7789 SetLastError(0xdeadbeef);
7790 ret = pWSAPoll(NULL, 1, 1);
7791 err = GetLastError();
7792 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7793 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
7794
7795 memset(&address, 0, sizeof(address));
7796 address.sin_addr.s_addr = inet_addr("127.0.0.1");
7797 address.sin_family = AF_INET;
7798 len = sizeof(address);
7799 listener = setup_server_socket(&address, &len);
7800
7801 for (i = 0; i < ARRAY_SIZE(invalid_flags); ++i)
7802 {
7803 fds[0].fd = listener;
7804 fds[0].events = invalid_flags[i];
7805 fds[0].revents = 0xdead;
7806 WSASetLastError(0xdeadbeef);
7807 ret = pWSAPoll(fds, 1, 0);
7808 todo_wine ok(ret == -1, "got %d\n", ret);
7809 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
7810 }
7811
7812 /* When no events are pending poll returns 0 with no error */
7813 fds[0].fd = listener;
7814 fds[0].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
7815 fds[0].revents = 0xdead;
7816 ret = pWSAPoll(fds, 1, 0);
7817 ok(ret == 0, "got %d\n", ret);
7818 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
7819
7820 fds[0].fd = -1;
7821 fds[0].events = POLLERR;
7822 fds[0].revents = 0xdead;
7823 fds[1].fd = listener;
7824 fds[1].events = POLLIN;
7825 fds[1].revents = 0xdead;
7826 WSASetLastError(0xdeadbeef);
7827 ret = pWSAPoll(fds, 2, 0);
7828 ok(!ret, "got %d\n", ret);
7829 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
7830 ok(fds[0].revents == POLLNVAL, "got events %#x\n", fds[0].revents);
7831 ok(!fds[1].revents, "got events %#x\n", fds[1].revents);
7832
7833 fds[0].fd = listener;
7834 fds[0].events = POLLIN;
7835 fds[0].revents = 0xdead;
7836 fds[1].fd = 0xabacab;
7837 fds[1].events = POLLIN;
7838 fds[1].revents = 0xdead;
7839 WSASetLastError(0xdeadbeef);
7840 ret = pWSAPoll(fds, 2, 0);
7841 ok(!ret, "got %d\n", ret);
7842 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
7843 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
7844 ok(fds[1].revents == POLLNVAL, "got events %#x\n", fds[1].revents);
7845
7846 fds[0].fd = listener;
7847 fds[0].events = POLLIN;
7848 fds[0].revents = 0xdead;
7849 fds[1].fd = 0xabacab;
7850 fds[1].events = POLLERR;
7851 fds[1].revents = 0xdead;
7852 WSASetLastError(0xdeadbeef);
7853 ret = pWSAPoll(fds, 2, 0);
7854 todo_wine ok(ret == -1, "got %d\n", ret);
7855 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
7856 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
7857 todo_wine ok(!fds[1].revents, "got events %#x\n", fds[1].revents);
7858
7859 fds[0].fd = -1;
7860 fds[0].events = POLLERR;
7861 fds[0].revents = 0xdead;
7862 fds[1].fd = 0xabacab;
7863 fds[1].events = POLLERR;
7864 fds[1].revents = 0xdead;
7865 WSASetLastError(0xdeadbeef);
7866 ret = pWSAPoll(fds, 2, 0);
7867 ok(ret == -1, "got %d\n", ret);
7868 ok(WSAGetLastError() == WSAENOTSOCK, "got error %u\n", WSAGetLastError());
7869 ok(fds[0].revents == POLLNVAL, "got events %#x\n", fds[0].revents);
7870 ok(fds[1].revents == POLLNVAL, "got events %#x\n", fds[1].revents);
7871
7872 /* Test listening socket connection attempt notifications */
7873 client = setup_connector_socket(&address, len, TRUE);
7874
7875 fds[0].fd = listener;
7876 fds[0].events = POLLIN;
7877 fds[0].revents = 0xdead;
7878 ret = pWSAPoll(fds, 1, 100);
7879 ok(ret == 1, "got %d\n", ret);
7880 ok(fds[0].revents == POLLRDNORM, "got events %#x\n", fds[0].revents);
7881
7882 fds[0].revents = 0xdead;
7883 ret = pWSAPoll(fds, 1, 0);
7884 ok(ret == 1, "got %d\n", ret);
7885 ok(fds[0].revents == POLLRDNORM, "got events %#x\n", fds[0].revents);
7886
7887 fds[0].events = POLLRDBAND | POLLWRNORM;
7888 fds[0].revents = 0xdead;
7889 ret = pWSAPoll(fds, 1, 0);
7890 ok(ret == 0, "got %d\n", ret);
7891 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
7892
7893 server = accept(listener, NULL, NULL);
7894 ok(server != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
7895 set_blocking(client, FALSE);
7896 set_blocking(server, FALSE);
7897
7898 for (i = 0; i < ARRAY_SIZE(invalid_flags); ++i)
7899 {
7900 fds[0].fd = server;
7901 fds[0].events = invalid_flags[i];
7902 fds[0].revents = 0xdead;
7903 WSASetLastError(0xdeadbeef);
7904 ret = pWSAPoll(fds, 1, 0);
7905 todo_wine ok(ret == -1, "got %d\n", ret);
7906 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
7907 }
7908
7909 /* Test flags exposed by connected sockets. */
7910
7911 fds[0].fd = listener;
7912 fds[0].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
7913 fds[0].revents = 0xdead;
7914 fds[1].fd = server;
7915 fds[1].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
7916 fds[1].revents = 0xdead;
7917 fds[2].fd = client;
7918 fds[2].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
7919 fds[2].revents = 0xdead;
7920 ret = pWSAPoll(fds, 3, 0);
7921 ok(ret == 2, "got %d\n", ret);
7922 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
7923 ok(fds[1].revents == POLLWRNORM, "got events %#x\n", fds[1].revents);
7924 ok(fds[2].revents == POLLWRNORM, "got events %#x\n", fds[2].revents);
7925
7926 /* Test data receiving notifications */
7927
7928 ret = send(server, "1234", 4, 0);
7929 ok(ret == 4, "got %d\n", ret);
7930
7931 check_poll_mask(client, POLLRDNORM | POLLRDBAND, POLLRDNORM);
7932 check_poll(client, POLLRDNORM | POLLWRNORM);
7933 check_poll(server, POLLWRNORM);
7934
7935 ret = sync_recv(client, buffer, sizeof(buffer), 0);
7936 ok(ret == 4, "got %d\n", ret);
7937
7938 check_poll(client, POLLWRNORM);
7939 check_poll(server, POLLWRNORM);
7940
7941 /* Because the kernel asynchronously buffers data, this test is not reliable. */
7942
7943 if (0)
7944 {
7945 static const int large_buffer_size = 1024 * 1024;
7946 char *large_buffer = malloc(large_buffer_size);
7947
7948 while (send(server, large_buffer, large_buffer_size, 0) == large_buffer_size);
7949
7950 check_poll(client, POLLWRNORM | POLLRDNORM);
7951 check_poll(server, 0);
7952
7953 while (recv(client, large_buffer, large_buffer_size, 0) > 0);
7954
7955 check_poll(client, POLLWRNORM);
7956 check_poll(server, POLLWRNORM);
7957
7958 free(large_buffer);
7959 }
7960
7961 /* Test OOB data notifications */
7962
7963 ret = send(client, "A", 1, MSG_OOB);
7964 ok(ret == 1, "got %d\n", ret);
7965
7966 check_poll(client, POLLWRNORM);
7967 check_poll_mask(server, POLLRDNORM | POLLRDBAND, POLLRDBAND);
7968 check_poll(server, POLLWRNORM | POLLRDBAND);
7969
7970 buffer[0] = 0xcc;
7971 ret = recv(server, buffer, 1, MSG_OOB);
7972 ok(ret == 1, "got %d\n", ret);
7973 ok(buffer[0] == 'A', "got %#x\n", buffer[0]);
7974
7975 check_poll(client, POLLWRNORM);
7976 check_poll(server, POLLWRNORM);
7977
7978 /* If the socket is OOBINLINED the notification is like normal data */
7979
7980 ret = 1;
7981 ret = setsockopt(server, SOL_SOCKET, SO_OOBINLINE, (char *)&ret, sizeof(ret));
7982 ok(!ret, "got error %u\n", WSAGetLastError());
7983 ret = send(client, "A", 1, MSG_OOB);
7984 ok(ret == 1, "got %d\n", ret);
7985
7986 check_poll(client, POLLWRNORM);
7987 check_poll_mask(server, POLLRDNORM | POLLRDBAND, POLLRDNORM);
7988 check_poll(server, POLLWRNORM | POLLRDNORM);
7989
7990 buffer[0] = 0xcc;
7991 ret = recv(server, buffer, 1, 0);
7992 ok(ret == 1, "got %d\n", ret);
7993 ok(buffer[0] == 'A', "got %#x\n", buffer[0]);
7994
7995 check_poll(client, POLLWRNORM);
7996 check_poll_todo(server, POLLWRNORM);
7997
7998 /* Test shutdown. */
7999
8000 ret = shutdown(client, SD_RECEIVE);
8001 ok(!ret, "got error %u\n", WSAGetLastError());
8002
8003 check_poll(client, POLLWRNORM);
8004 check_poll_todo(server, POLLWRNORM);
8005
8006 ret = shutdown(client, SD_SEND);
8007 ok(!ret, "got error %u\n", WSAGetLastError());
8008
8009 check_poll(client, POLLWRNORM);
8010 check_poll_mask_todo(server, 0, POLLHUP);
8011 check_poll_todo(server, POLLWRNORM | POLLHUP);
8012
8013 closesocket(client);
8014 closesocket(server);
8015
8016 /* Test shutdown via closesocket(). */
8017
8018 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8019 ret = connect(client, (struct sockaddr *)&address, sizeof(address));
8020 ok(!ret, "got error %u\n", WSAGetLastError());
8021 server = accept(listener, NULL, NULL);
8022 ok(server != -1, "got error %u\n", WSAGetLastError());
8023
8024 closesocket(client);
8025
8026 check_poll_mask(server, 0, POLLHUP);
8027 check_poll(server, POLLWRNORM | POLLHUP);
8028
8029 closesocket(server);
8030
8031 /* Test shutdown with data in the pipe. */
8032
8033 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8034 ret = connect(client, (struct sockaddr *)&address, sizeof(address));
8035 ok(!ret, "got error %u\n", WSAGetLastError());
8036 server = accept(listener, NULL, NULL);
8037 ok(server != -1, "got error %u\n", WSAGetLastError());
8038
8039 ret = send(client, "data", 5, 0);
8040 ok(ret == 5, "got %d\n", ret);
8041
8042 check_poll(client, POLLWRNORM);
8043 check_poll_mask(server, POLLRDNORM | POLLRDBAND, POLLRDNORM);
8044 check_poll(server, POLLWRNORM | POLLRDNORM);
8045
8046 ret = shutdown(client, SD_SEND);
8047
8048 check_poll(client, POLLWRNORM);
8049 check_poll_mask_todo(server, 0, POLLHUP);
8050 check_poll_todo(server, POLLWRNORM | POLLRDNORM | POLLHUP);
8051
8052 closesocket(client);
8053 closesocket(server);
8054
8055 /* Test closing a socket while selecting on it. */
8056
8057 tcp_socketpair(&client, &server);
8058
8059 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &client, 0, NULL);
8060 fds[0].fd = client;
8061 fds[0].events = POLLRDNORM | POLLRDBAND;
8062 fds[0].revents = 0xdead;
8063 ret = pWSAPoll(fds, 1, 2000);
8064 ok(ret == 1, "got %d\n", ret);
8065 ok(fds[0].revents == POLLNVAL, "got events %#x\n", fds[0].revents);
8066 ret = WaitForSingleObject(thread_handle, 1000);
8067 ok(!ret, "wait failed\n");
8068 CloseHandle(thread_handle);
8069
8070 closesocket(server);
8071
8072 /* Test a failed connection.
8073 *
8074 * The following WSAPoll() call times out on versions older than w10pro64,
8075 * but even on w10pro64 it takes over 2 seconds for an error to be reported,
8076 * so make the test interactive-only. */
8077 if (winetest_interactive)
8078 {
8079 const struct sockaddr_in invalid_addr =
8080 {
8081 .sin_family = AF_INET,
8082 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
8083 .sin_port = 255,
8084 };
8085 SOCKET client;
8086
8087 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8088 set_blocking(client, FALSE);
8089
8090 ret = connect(client, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
8091 ok(ret == -1, "got %d\n", ret);
8092 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
8093
8094 fds[0].fd = client;
8095 fds[0].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
8096 fds[0].revents = 0xdead;
8097 ret = pWSAPoll(fds, 1, 10000);
8098 ok(ret == 1, "got %d\n", ret);
8099 todo_wine ok(fds[0].revents == (POLLWRNORM | POLLHUP | POLLERR), "got events %#x\n", fds[0].revents);
8100
8101 len = sizeof(err);
8102 err = 0xdeadbeef;
8103 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
8104 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
8105 ok(err == WSAECONNREFUSED, "got error %u\n", err);
8106
8107 len = sizeof(err);
8108 err = 0xdeadbeef;
8109 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
8110 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
8111 ok(err == WSAECONNREFUSED, "got error %u\n", err);
8112
8113 check_poll_todo(client, POLLWRNORM | POLLHUP | POLLERR);
8114
8115 closesocket(client);
8116
8117 /* test polling after a (synchronous) failure */
8118
8119 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8120
8121 ret = connect(client, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
8122 ok(ret == -1, "got %d\n", ret);
8123 ok(WSAGetLastError() == WSAECONNREFUSED, "got error %u\n", WSAGetLastError());
8124
8125 check_poll_todo(client, POLLWRNORM | POLLHUP | POLLERR);
8126
8127 len = sizeof(err);
8128 err = 0xdeadbeef;
8129 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
8130 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
8131 todo_wine ok(!err, "got error %u\n", err);
8132
8133 closesocket(client);
8134 }
8135
8136 closesocket(listener);
8137
8138 /* Test UDP sockets. */
8139
8140 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
8141 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
8142
8143 check_poll(client, POLLWRNORM);
8144 check_poll(server, POLLWRNORM);
8145
8146 ret = bind(client, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
8147 ok(!ret, "got error %u\n", WSAGetLastError());
8148 len = sizeof(address);
8149 ret = getsockname(client, (struct sockaddr *)&address, &len);
8150 ok(!ret, "got error %u\n", WSAGetLastError());
8151
8152 check_poll(client, POLLWRNORM);
8153 check_poll(server, POLLWRNORM);
8154
8155 ret = sendto(server, "data", 5, 0, (struct sockaddr *)&address, sizeof(address));
8156 ok(ret == 5, "got %d\n", ret);
8157
8158 check_poll_mask(client, POLLRDNORM | POLLRDBAND, POLLRDNORM);
8159 check_poll(client, POLLWRNORM | POLLRDNORM);
8160 check_poll(server, POLLWRNORM);
8161
8162 closesocket(client);
8163 closesocket(server);
8164 }
8165
8166 static void test_connect(void)
8167 {
8168 SOCKET listener = INVALID_SOCKET;
8169 SOCKET acceptor = INVALID_SOCKET;
8170 SOCKET connector = INVALID_SOCKET;
8171 struct sockaddr_in address, conaddress;
8172 int addrlen;
8173 OVERLAPPED overlapped;
8174 LPFN_CONNECTEX pConnectEx;
8175 GUID connectExGuid = WSAID_CONNECTEX;
8176 DWORD bytesReturned;
8177 char buffer[1024];
8178 BOOL bret;
8179 DWORD dwret;
8180 int iret;
8181
8182 memset(&overlapped, 0, sizeof(overlapped));
8183
8184 listener = socket(AF_INET, SOCK_STREAM, 0);
8185 ok(listener != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8186
8187 connector = socket(AF_INET, SOCK_STREAM, 0);
8188 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8189
8190 memset(&address, 0, sizeof(address));
8191 address.sin_family = AF_INET;
8192 address.sin_addr.s_addr = inet_addr("127.0.0.1");
8193 iret = bind(listener, (struct sockaddr*)&address, sizeof(address));
8194 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8195
8196 addrlen = sizeof(address);
8197 iret = getsockname(listener, (struct sockaddr*)&address, &addrlen);
8198 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
8199
8200 iret = listen(listener, 1);
8201 ok(!iret, "failed to listen, error %u\n", WSAGetLastError());
8202
8203 iret = set_blocking(listener, TRUE);
8204 ok(!iret, "failed to set nonblocking, error %u\n", WSAGetLastError());
8205
8206 bytesReturned = 0xdeadbeef;
8207 iret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectExGuid, sizeof(connectExGuid),
8208 &pConnectEx, sizeof(pConnectEx), &bytesReturned, NULL, NULL);
8209 ok(!iret, "failed to get ConnectEx, error %u\n", WSAGetLastError());
8210
8211 ok(bytesReturned == sizeof(pConnectEx), "expected sizeof(pConnectEx), got %lu\n", bytesReturned);
8212
8213 WSASetLastError(0xdeadbeef);
8214 iret = connect(listener, (struct sockaddr *)&address, sizeof(address));
8215 ok(iret == -1, "got %d\n", iret);
8216 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8217
8218 WSASetLastError(0xdeadbeef);
8219 overlapped.Internal = 0xdeadbeef;
8220 overlapped.InternalHigh = 0xdeadbeef;
8221 iret = pConnectEx(listener, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8222 ok(!iret, "got %d\n", iret);
8223 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8224 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8225 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8226
8227 bret = pConnectEx(INVALID_SOCKET, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8228 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "ConnectEx on invalid socket "
8229 "returned %d + errno %d\n", bret, WSAGetLastError());
8230
8231 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8232 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "ConnectEx on a unbound socket "
8233 "returned %d + errno %d\n", bret, WSAGetLastError());
8234
8235 /* ConnectEx needs a bound socket */
8236 memset(&conaddress, 0, sizeof(conaddress));
8237 conaddress.sin_family = AF_INET;
8238 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8239 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8240 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8241
8242 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, NULL);
8243 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "ConnectEx on a NULL overlapped "
8244 "returned %d + errno %d\n", bret, WSAGetLastError());
8245
8246 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8247
8248 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8249 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
8250 "returned %d + errno %d\n", bret, WSAGetLastError());
8251 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8252 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %ld + errno %ld\n", dwret, GetLastError());
8253
8254 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8255 ok(bret, "Connecting failed, error %ld\n", GetLastError());
8256 ok(bytesReturned == 0, "Bytes sent is %ld\n", bytesReturned);
8257
8258 closesocket(connector);
8259 connector = socket(AF_INET, SOCK_STREAM, 0);
8260 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8261 /* ConnectEx needs a bound socket */
8262 memset(&conaddress, 0, sizeof(conaddress));
8263 conaddress.sin_family = AF_INET;
8264 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8265 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8266 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8267
8268 acceptor = accept(listener, NULL, NULL);
8269 ok(acceptor != INVALID_SOCKET, "failed to accept socket, error %u\n", WSAGetLastError());
8270
8271 buffer[0] = '1';
8272 buffer[1] = '2';
8273 buffer[2] = '3';
8274 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, buffer, 3, &bytesReturned, &overlapped);
8275 memset(buffer, 0, 3);
8276 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
8277 "returned %d + errno %d\n", bret, WSAGetLastError());
8278 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8279 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %ld + errno %ld\n", dwret, GetLastError());
8280
8281 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8282 ok(bret, "Connecting failed, error %ld\n", GetLastError());
8283 ok(bytesReturned == 3, "Bytes sent is %ld\n", bytesReturned);
8284
8285 acceptor = accept(listener, NULL, NULL);
8286 ok(acceptor != INVALID_SOCKET, "could not accept socket error %d\n", WSAGetLastError());
8287
8288 bytesReturned = recv(acceptor, buffer, 3, 0);
8289 buffer[4] = 0;
8290 ok(bytesReturned == 3, "Didn't get all sent data, got only %ld\n", bytesReturned);
8291 ok(buffer[0] == '1' && buffer[1] == '2' && buffer[2] == '3',
8292 "Failed to get the right data, expected '123', got '%s'\n", buffer);
8293
8294 WSASetLastError(0xdeadbeef);
8295 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8296 ok(iret == -1, "got %d\n", iret);
8297 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8298
8299 WSASetLastError(0xdeadbeef);
8300 iret = connect(acceptor, (struct sockaddr *)&address, sizeof(address));
8301 ok(iret == -1, "got %d\n", iret);
8302 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8303
8304 WSASetLastError(0xdeadbeef);
8305 overlapped.Internal = 0xdeadbeef;
8306 overlapped.InternalHigh = 0xdeadbeef;
8307 bret = pConnectEx(connector, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8308 ok(!bret, "got %d\n", bret);
8309 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8310 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8311 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8312
8313 WSASetLastError(0xdeadbeef);
8314 overlapped.Internal = 0xdeadbeef;
8315 overlapped.InternalHigh = 0xdeadbeef;
8316 bret = pConnectEx(acceptor, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8317 ok(!bret, "got %d\n", bret);
8318 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8319 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8320 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8321
8322 closesocket(connector);
8323 closesocket(acceptor);
8324
8325 tcp_socketpair(&connector, &acceptor);
8326
8327 WSASetLastError(0xdeadbeef);
8328 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8329 ok(iret == -1, "got %d\n", iret);
8330 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8331
8332 WSASetLastError(0xdeadbeef);
8333 iret = connect(acceptor, (struct sockaddr *)&address, sizeof(address));
8334 ok(iret == -1, "got %d\n", iret);
8335 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8336
8337 WSASetLastError(0xdeadbeef);
8338 overlapped.Internal = 0xdeadbeef;
8339 overlapped.InternalHigh = 0xdeadbeef;
8340 bret = pConnectEx(connector, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8341 ok(!bret, "got %d\n", bret);
8342 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8343 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8344 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8345
8346 WSASetLastError(0xdeadbeef);
8347 overlapped.Internal = 0xdeadbeef;
8348 overlapped.InternalHigh = 0xdeadbeef;
8349 bret = pConnectEx(acceptor, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
8350 ok(!bret, "got %d\n", bret);
8351 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
8352 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8353 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
8354
8355 closesocket(connector);
8356 closesocket(acceptor);
8357
8358 /* Connect with error */
8359
8360 connector = socket(AF_INET, SOCK_STREAM, 0);
8361 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8362 /* ConnectEx needs a bound socket */
8363 memset(&conaddress, 0, sizeof(conaddress));
8364 conaddress.sin_family = AF_INET;
8365 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8366 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8367 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8368
8369 address.sin_port = htons(1);
8370
8371 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8372 ok(bret == FALSE && GetLastError() == ERROR_IO_PENDING, "ConnectEx to bad destination failed: "
8373 "returned %d + errno %ld\n", bret, GetLastError());
8374 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8375 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %ld + errno %ld\n", dwret, GetLastError());
8376
8377 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8378 ok(bret == FALSE && GetLastError() == ERROR_CONNECTION_REFUSED,
8379 "Connecting to a disconnected host returned error %d - %d\n", bret, WSAGetLastError());
8380
8381 WSACloseEvent(overlapped.hEvent);
8382 closesocket(connector);
8383
8384 /* Test connect after previous connect attempt failure. */
8385 connector = socket(AF_INET, SOCK_STREAM, 0);
8386 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8387
8388 conaddress.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
8389 conaddress.sin_port = htons(255);
8390 iret = connect(connector, (struct sockaddr *)&conaddress, sizeof(conaddress));
8391 ok(iret == -1, "connection succeeded.\n");
8392
8393 ok(WSAGetLastError() == WSAECONNREFUSED, "got error %u\n", WSAGetLastError());
8394 set_blocking( connector, FALSE );
8395 iret = getsockname(listener, (struct sockaddr*)&address, &addrlen);
8396 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
8397
8398 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8399 ok(iret == -1 && WSAGetLastError() == WSAEWOULDBLOCK, "unexpected iret %d, error %d.\n",
8400 iret, WSAGetLastError());
8401 acceptor = accept(listener, NULL, NULL);
8402 ok(acceptor != INVALID_SOCKET, "could not accept socket error %d\n", WSAGetLastError());
8403
8404 closesocket(acceptor);
8405 closesocket(connector);
8406 closesocket(listener);
8407 }
8408
8409 static void test_AcceptEx(void)
8410 {
8411 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
8412 SOCKET listener, acceptor, acceptor2, connector, connector2;
8413 struct sockaddr_in bindAddress, peerAddress, *readBindAddress, *readRemoteAddress;
8414 int socklen, iret, localSize = sizeof(struct sockaddr_in), remoteSize = localSize;
8415 GUID acceptExGuid = WSAID_ACCEPTEX, getAcceptExGuid = WSAID_GETACCEPTEXSOCKADDRS;
8416 GUID connectex_guid = WSAID_CONNECTEX;
8417 LPFN_ACCEPTEX pAcceptEx = NULL;
8418 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs = NULL;
8419 LPFN_CONNECTEX pConnectEx = NULL;
8420 fd_set fds_accept, fds_send;
8421 static const struct timeval timeout = {1, 0};
8422 char buffer[1024], ipbuffer[32];
8423 OVERLAPPED overlapped = {0}, overlapped2 = {0};
8424 DWORD bytesReturned, dwret;
8425 BOOL bret;
8426
8427 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8428 overlapped2.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8429
8430 listener = socket(AF_INET, SOCK_STREAM, 0);
8431 ok(listener != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8432
8433 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8434 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8435
8436 memset(&bindAddress, 0, sizeof(bindAddress));
8437 bindAddress.sin_family = AF_INET;
8438 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8439 iret = bind(listener, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8440 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8441
8442 socklen = sizeof(bindAddress);
8443 iret = getsockname(listener, (struct sockaddr*)&bindAddress, &socklen);
8444 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
8445
8446 iret = set_blocking(listener, FALSE);
8447 ok(!iret, "Failed to set nonblocking, error %u\n", WSAGetLastError());
8448
8449 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
8450 &pAcceptEx, sizeof(pAcceptEx), &bytesReturned, NULL, NULL);
8451 ok(!iret, "Failed to get AcceptEx, error %u\n", WSAGetLastError());
8452
8453 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &getAcceptExGuid, sizeof(getAcceptExGuid),
8454 &pGetAcceptExSockaddrs, sizeof(pGetAcceptExSockaddrs), &bytesReturned, NULL, NULL);
8455 ok(!iret, "Failed to get GetAcceptExSockaddrs, error %u\n", WSAGetLastError());
8456
8457 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectex_guid, sizeof(connectex_guid),
8458 &pConnectEx, sizeof(pConnectEx), &bytesReturned, NULL, NULL);
8459 ok(!iret, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
8460
8461 overlapped.Internal = 0xdeadbeef;
8462 bret = pAcceptEx(INVALID_SOCKET, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8463 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8464 &bytesReturned, &overlapped);
8465 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid listening socket "
8466 "returned %d + errno %d\n", bret, WSAGetLastError());
8467 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8468
8469 overlapped.Internal = 0xdeadbeef;
8470 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8471 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8472 &bytesReturned, &overlapped);
8473 todo_wine
8474 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on a non-listening socket "
8475 "returned %d + errno %d\n", bret, WSAGetLastError());
8476 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8477 if (!bret && WSAGetLastError() == ERROR_IO_PENDING)
8478 CancelIo((HANDLE)listener);
8479
8480 iret = listen(listener, 5);
8481 ok(!iret, "failed to listen, error %lu\n", GetLastError());
8482
8483 overlapped.Internal = 0xdeadbeef;
8484 bret = pAcceptEx(listener, INVALID_SOCKET, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8485 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8486 &bytesReturned, &overlapped);
8487 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid accepting socket "
8488 "returned %d + errno %d\n", bret, WSAGetLastError());
8489 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8490
8491 overlapped.Internal = 0xdeadbeef;
8492 bret = pAcceptEx(listener, acceptor, NULL, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8493 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8494 &bytesReturned, &overlapped);
8495 todo_wine ok(bret == FALSE && WSAGetLastError() == WSAEFAULT,
8496 "AcceptEx on NULL buffer returned %d + errno %d\n", bret, WSAGetLastError());
8497 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8498
8499 overlapped.Internal = 0xdeadbeef;
8500 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
8501 &bytesReturned, &overlapped);
8502 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING,
8503 "AcceptEx on too small local address size returned %d + errno %d\n",
8504 bret, WSAGetLastError());
8505 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8506
8507 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8508 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
8509 iret = connect(connector, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
8510 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
8511 iret = getsockname(connector, (struct sockaddr *)&peerAddress, &remoteSize);
8512 ok(!iret, "getsockname failed, error %u\n", WSAGetLastError());
8513
8514 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8515 ok(!dwret, "wait failed\n");
8516 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8517 ok(bret, "got error %lu\n", GetLastError());
8518 ok(!(NTSTATUS)overlapped.Internal, "got %#Ix\n", overlapped.Internal);
8519 ok(!bytesReturned, "got size %lu\n", bytesReturned);
8520
8521 readBindAddress = readRemoteAddress = (struct sockaddr_in *)0xdeadbeef;
8522 localSize = remoteSize = 0xdeadbeef;
8523 pGetAcceptExSockaddrs(buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
8524 (struct sockaddr **)&readBindAddress, &localSize, (struct sockaddr **)&readRemoteAddress, &remoteSize);
8525 todo_wine ok(readBindAddress == (struct sockaddr_in *)0xdeadbeef, "got local addr %p\n", readBindAddress);
8526 ok(!memcmp(readRemoteAddress, &peerAddress, sizeof(peerAddress)), "remote addr didn't match\n");
8527 todo_wine ok(localSize == 0xdeadbeef, "got local size %u\n", localSize);
8528 ok(remoteSize == sizeof(struct sockaddr_in), "got remote size %u\n", remoteSize);
8529
8530 closesocket(connector);
8531 closesocket(acceptor);
8532
8533 /* A UDP socket cannot be accepted into. */
8534
8535 acceptor = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
8536
8537 overlapped.Internal = 0xdeadbeef;
8538 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8539 ok(!bret, "expected failure\n");
8540 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8541 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8542 if (WSAGetLastError() == ERROR_IO_PENDING)
8543 CancelIo((HANDLE)listener);
8544
8545 closesocket(acceptor);
8546
8547 /* A bound socket cannot be accepted into. */
8548
8549 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8550 iret = bind(acceptor, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
8551 ok(!iret, "got error %u\n", WSAGetLastError());
8552
8553 overlapped.Internal = 0xdeadbeef;
8554 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8555 ok(!bret, "expected failure\n");
8556 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8557 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8558 if (WSAGetLastError() == ERROR_IO_PENDING)
8559 CancelIo((HANDLE)listener);
8560
8561 closesocket(acceptor);
8562
8563 /* A connected socket cannot be accepted into. */
8564
8565 tcp_socketpair(&acceptor, &acceptor2);
8566
8567 overlapped.Internal = 0xdeadbeef;
8568 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8569 ok(!bret, "expected failure\n");
8570 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8571 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8572 if (WSAGetLastError() == ERROR_IO_PENDING)
8573 CancelIo((HANDLE)listener);
8574
8575 overlapped.Internal = 0xdeadbeef;
8576 bret = pAcceptEx(listener, acceptor2, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8577 ok(!bret, "expected failure\n");
8578 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8579 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
8580 if (WSAGetLastError() == ERROR_IO_PENDING)
8581 CancelIo((HANDLE)listener);
8582
8583 closesocket(acceptor);
8584 closesocket(acceptor2);
8585
8586 /* Pass an insufficient local address size. */
8587
8588 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8589 ok(acceptor != -1, "failed to create socket, error %u\n", WSAGetLastError());
8590
8591 overlapped.Internal = 0xdeadbeef;
8592 bret = pAcceptEx(listener, acceptor, buffer, 0, 3,
8593 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8594 ok(!bret && WSAGetLastError() == ERROR_IO_PENDING, "got %d, error %u\n", bret, WSAGetLastError());
8595 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got %#Ix\n", overlapped.Internal);
8596
8597 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8598 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
8599 iret = connect(connector, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
8600 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
8601
8602 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8603 ok(!dwret, "wait failed\n");
8604 bytesReturned = 0xdeadbeef;
8605 SetLastError(0xdeadbeef);
8606 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8607 ok(!bret, "expected failure\n");
8608 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got error %lu\n", GetLastError());
8609 ok((NTSTATUS)overlapped.Internal == STATUS_BUFFER_TOO_SMALL, "got %#Ix\n", overlapped.Internal);
8610 ok(!bytesReturned, "got size %lu\n", bytesReturned);
8611
8612 closesocket(acceptor);
8613
8614 /* The above connection request is not accepted. */
8615 acceptor = accept(listener, NULL, NULL);
8616 todo_wine ok(acceptor != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
8617 closesocket(acceptor);
8618
8619 closesocket(connector);
8620
8621 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8622 ok(acceptor != -1, "failed to create socket, error %u\n", WSAGetLastError());
8623
8624 overlapped.Internal = 0xdeadbeef;
8625 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 4,
8626 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8627 ok(!bret && WSAGetLastError() == ERROR_IO_PENDING, "got %d, error %u\n", bret, WSAGetLastError());
8628 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got %#Ix\n", overlapped.Internal);
8629
8630 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8631 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
8632 iret = connect(connector, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
8633 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
8634
8635 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8636 ok(!dwret, "wait failed\n");
8637 bytesReturned = 0xdeadbeef;
8638 SetLastError(0xdeadbeef);
8639 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8640 todo_wine ok(!bret, "expected failure\n");
8641 todo_wine ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got error %lu\n", GetLastError());
8642 todo_wine ok((NTSTATUS)overlapped.Internal == STATUS_BUFFER_TOO_SMALL, "got %#Ix\n", overlapped.Internal);
8643 ok(!bytesReturned, "got size %lu\n", bytesReturned);
8644
8645 closesocket(acceptor);
8646
8647 /* The above connection request is not accepted. */
8648 acceptor = accept(listener, NULL, NULL);
8649 todo_wine ok(acceptor != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
8650 closesocket(acceptor);
8651
8652 closesocket(connector);
8653
8654 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8655 ok(acceptor != -1, "failed to create socket, error %u\n", WSAGetLastError());
8656
8657 overlapped.Internal = 0xdeadbeef;
8658 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 15,
8659 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8660 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx on too small local address "
8661 "size returned %d + errno %d\n",
8662 bret, WSAGetLastError());
8663 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8664 bret = CancelIo((HANDLE) listener);
8665 ok(bret, "Failed to cancel pending accept socket\n");
8666
8667 overlapped.Internal = 0xdeadbeef;
8668 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16, 0,
8669 &bytesReturned, &overlapped);
8670 ok(bret == FALSE && WSAGetLastError() == WSAEFAULT,
8671 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
8672 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8673
8674 overlapped.Internal = 0xdeadbeef;
8675 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16,
8676 sizeof(struct sockaddr_in) + 15, &bytesReturned, &overlapped);
8677 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING,
8678 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
8679 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8680 bret = CancelIo((HANDLE) listener);
8681 ok(bret, "Failed to cancel pending accept socket\n");
8682
8683 bret = pAcceptEx(listener, acceptor, buffer, 0,
8684 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8685 &bytesReturned, NULL);
8686 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
8687 "returned %d + errno %d\n", bret, WSAGetLastError());
8688
8689 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, 0, &bytesReturned, NULL);
8690 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
8691 "returned %d + errno %d\n", bret, WSAGetLastError());
8692
8693 overlapped.Internal = 0xdeadbeef;
8694 bret = pAcceptEx(listener, acceptor, buffer, 0,
8695 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8696 &bytesReturned, &overlapped);
8697 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8698 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8699
8700 /* try to accept into the same socket twice */
8701 overlapped.Internal = 0xdeadbeef;
8702 bret = pAcceptEx(listener, acceptor, buffer, 0,
8703 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8704 &bytesReturned, &overlapped);
8705 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL,
8706 "AcceptEx on already pending socket returned %d + errno %d\n", bret, WSAGetLastError());
8707 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8708
8709 /* try to connect a socket that's being accepted into */
8710 iret = connect(acceptor, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8711 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL,
8712 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret, WSAGetLastError());
8713
8714 bret = pConnectEx(acceptor, (struct sockaddr *)&bindAddress, sizeof(bindAddress),
8715 NULL, 0, &bytesReturned, &overlapped2);
8716 ok(!bret, "expected failure\n");
8717 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8718
8719 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8720 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
8721 overlapped.Internal = 0xdeadbeef;
8722 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8723 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8724
8725 dwret = WaitForSingleObject(overlapped.hEvent, INFINITE);
8726 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
8727 ok(overlapped.Internal == STATUS_SUCCESS, "got %08lx\n", (ULONG)overlapped.Internal);
8728
8729 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8730 ok(bret, "GetOverlappedResult failed, error %ld\n", GetLastError());
8731 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %ld\n", bytesReturned);
8732
8733 /* Try to call getsockname on the acceptor socket.
8734 *
8735 * On Windows, this requires setting SO_UPDATE_ACCEPT_CONTEXT. */
8736 iret = setsockopt(acceptor, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, (char *)&listener, sizeof(SOCKET));
8737 ok(!iret, "Failed to set accept context %ld\n", GetLastError());
8738 iret = getsockname(acceptor, (struct sockaddr *)&peerAddress, &remoteSize);
8739 ok(!iret, "getsockname failed.\n");
8740 ok(remoteSize == sizeof(struct sockaddr_in), "got remote size %u\n", remoteSize);
8741
8742 closesocket(connector);
8743 connector = INVALID_SOCKET;
8744 closesocket(acceptor);
8745
8746 /* Test short reads */
8747
8748 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8749 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
8750 connector = socket(AF_INET, SOCK_STREAM, 0);
8751 ok(connector != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
8752 overlapped.Internal = 0xdeadbeef;
8753 bret = pAcceptEx(listener, acceptor, buffer, 2,
8754 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8755 &bytesReturned, &overlapped);
8756 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8757 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8758
8759 /* AcceptEx() still won't complete until we send data */
8760 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8761 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8762
8763 dwret = WaitForSingleObject(overlapped.hEvent, 0);
8764 ok(dwret == WAIT_TIMEOUT, "Waiting for accept event timeout failed with %ld + errno %ld\n", dwret, GetLastError());
8765 ok(overlapped.Internal == STATUS_PENDING, "got %08lx\n", (ULONG)overlapped.Internal);
8766
8767 iret = getsockname( connector, (struct sockaddr *)&peerAddress, &remoteSize);
8768 ok( !iret, "getsockname failed.\n");
8769
8770 /* AcceptEx() could complete any time now */
8771 iret = send(connector, buffer, 1, 0);
8772 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
8773
8774 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8775 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
8776 ok(overlapped.Internal == STATUS_SUCCESS, "got %08lx\n", (ULONG)overlapped.Internal);
8777
8778 /* Check if the buffer from AcceptEx is decoded correctly */
8779 pGetAcceptExSockaddrs(buffer, 2, sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8780 (struct sockaddr **)&readBindAddress, &localSize,
8781 (struct sockaddr **)&readRemoteAddress, &remoteSize);
8782 strcpy( ipbuffer, inet_ntoa(readBindAddress->sin_addr));
8783 ok( readBindAddress->sin_addr.s_addr == bindAddress.sin_addr.s_addr,
8784 "Local socket address is different %s != %s\n",
8785 ipbuffer, inet_ntoa(bindAddress.sin_addr));
8786 ok( readBindAddress->sin_port == bindAddress.sin_port,
8787 "Local socket port is different: %d != %d\n",
8788 readBindAddress->sin_port, bindAddress.sin_port);
8789 strcpy( ipbuffer, inet_ntoa(readRemoteAddress->sin_addr));
8790 ok( readRemoteAddress->sin_addr.s_addr == peerAddress.sin_addr.s_addr,
8791 "Remote socket address is different %s != %s\n",
8792 ipbuffer, inet_ntoa(peerAddress.sin_addr));
8793 ok( readRemoteAddress->sin_port == peerAddress.sin_port,
8794 "Remote socket port is different: %d != %d\n",
8795 readRemoteAddress->sin_port, peerAddress.sin_port);
8796
8797 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8798 ok(bret, "GetOverlappedResult failed, error %ld\n", GetLastError());
8799 ok(bytesReturned == 1, "bytesReturned isn't supposed to be %ld\n", bytesReturned);
8800
8801 closesocket(connector);
8802 connector = INVALID_SOCKET;
8803 closesocket(acceptor);
8804
8805 /* Test CF_DEFER & AcceptEx interaction */
8806
8807 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8808 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
8809 connector = socket(AF_INET, SOCK_STREAM, 0);
8810 ok(connector != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
8811 connector2 = socket(AF_INET, SOCK_STREAM, 0);
8812 ok(connector2 != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
8813
8814 iret = set_blocking(connector, FALSE);
8815 ok(!iret, "failed to set nonblocking, error %lu\n", GetLastError());
8816 iret = set_blocking(connector2, FALSE);
8817 ok(!iret, "failed to set nonblocking, error %lu\n", GetLastError());
8818
8819 /* Connect socket #1 */
8820 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8821 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8822
8823 buffer[0] = '0';
8824
8825 FD_ZERO(&fds_accept);
8826 FD_SET(listener, &fds_accept);
8827 iret = select(0, &fds_accept, NULL, NULL, &timeout);
8828 ok(iret == 1, "wait timed out\n");
8829
8830 acceptor2 = WSAAccept(listener, NULL, NULL, AlwaysDeferConditionFunc, 0);
8831 ok(acceptor2 == INVALID_SOCKET, "expected failure\n");
8832 ok(WSAGetLastError() == WSATRY_AGAIN, "got error %u\n", WSAGetLastError());
8833 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16,
8834 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8835 ok(!bret, "expected failure\n");
8836 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
8837
8838 FD_ZERO(&fds_send);
8839 FD_SET(connector, &fds_send);
8840 iret = select(0, NULL, &fds_send, NULL, &timeout);
8841 ok(iret == 1, "wait timed out\n");
8842
8843 iret = send(connector, "1", 1, 0);
8844 ok(iret == 1, "got ret %d, error %u\n", iret, WSAGetLastError());
8845
8846 iret = connect(connector2, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
8847 ok(iret == SOCKET_ERROR, "expected failure\n");
8848 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
8849
8850 iret = select(0, &fds_accept, NULL, NULL, &timeout);
8851 ok(iret == 1, "wait timed out\n");
8852
8853 acceptor2 = accept(listener, NULL, NULL);
8854 ok(acceptor2 != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
8855 closesocket(acceptor2);
8856
8857 FD_ZERO(&fds_send);
8858 FD_SET(connector2, &fds_send);
8859 iret = select(0, NULL, &fds_send, NULL, &timeout);
8860 ok(iret == 1, "wait timed out\n");
8861
8862 iret = send(connector2, "2", 1, 0);
8863 ok(iret == 1, "got ret %d, error %u\n", iret, WSAGetLastError());
8864
8865 dwret = WaitForSingleObject(overlapped.hEvent, 0);
8866 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
8867
8868 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8869 ok(bret, "GetOverlappedResult failed, error %ld\n", GetLastError());
8870 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %ld\n", bytesReturned);
8871
8872 set_blocking(acceptor, TRUE);
8873 iret = recv( acceptor, buffer, 2, 0);
8874 ok(iret == 1, "Failed to get data, %d, errno: %d\n", iret, WSAGetLastError());
8875 ok(buffer[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer[0]);
8876
8877 closesocket(connector);
8878 closesocket(connector2);
8879 closesocket(acceptor);
8880
8881 /* clean up in case of failures */
8882 while ((acceptor = accept(listener, NULL, NULL)) != INVALID_SOCKET)
8883 closesocket(acceptor);
8884
8885 /* Disconnect during receive? */
8886
8887 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8888 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
8889 connector = socket(AF_INET, SOCK_STREAM, 0);
8890 ok(connector != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
8891 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8892 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8893 &bytesReturned, &overlapped);
8894 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8895
8896 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8897 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8898
8899 closesocket(connector);
8900 connector = INVALID_SOCKET;
8901
8902 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8903 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
8904
8905 bytesReturned = 123456;
8906 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8907 ok(bret, "GetOverlappedResult failed, error %ld\n", GetLastError());
8908 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %ld\n", bytesReturned);
8909
8910 closesocket(acceptor);
8911
8912 /* Test closing with pending requests */
8913
8914 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8915 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
8916 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8917 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8918 &bytesReturned, &overlapped);
8919 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8920
8921 closesocket(acceptor);
8922
8923 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8924 ok(dwret == WAIT_OBJECT_0,
8925 "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
8926 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8927 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %ld\n", GetLastError());
8928
8929 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8930 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
8931 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8932 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8933 &bytesReturned, &overlapped);
8934 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8935
8936 CancelIo((HANDLE) acceptor);
8937
8938 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8939 ok(dwret == WAIT_TIMEOUT, "Waiting for timeout failed with %ld + errno %ld\n", dwret, GetLastError());
8940
8941 closesocket(acceptor);
8942
8943 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8944 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
8945 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8946 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8947 &bytesReturned, &overlapped);
8948 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8949
8950 closesocket(listener);
8951
8952 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8953 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %ld + errno %ld\n", dwret, GetLastError());
8954
8955 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8956 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %ld\n", GetLastError());
8957
8958 CloseHandle(overlapped.hEvent);
8959 CloseHandle(overlapped2.hEvent);
8960 closesocket(acceptor);
8961 closesocket(connector2);
8962 }
8963
8964 static void test_shutdown(void)
8965 {
8966 struct sockaddr_in addr, server_addr, client_addr;
8967 SOCKET listener, client, server;
8968 OVERLAPPED overlapped = {0};
8969 DWORD size, flags = 0;
8970 int ret, addrlen;
8971 char buffer[5];
8972 WSABUF wsabuf;
8973
8974 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8975 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8976 ok(listener != INVALID_SOCKET, "failed to create listener socket, error %d\n", WSAGetLastError());
8977
8978 memset(&addr, 0, sizeof(addr));
8979 addr.sin_family = AF_INET;
8980 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
8981 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
8982 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
8983 addrlen = sizeof(server_addr);
8984 ret = getsockname(listener, (struct sockaddr *)&server_addr, &addrlen);
8985 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
8986
8987 ret = listen(listener, 1);
8988 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
8989
8990 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8991 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
8992
8993 WSASetLastError(0xdeadbeef);
8994 ret = shutdown(client, SD_SEND);
8995 ok(ret == -1, "expected failure\n");
8996 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
8997
8998 WSASetLastError(0xdeadbeef);
8999 ret = shutdown(client, SD_RECEIVE);
9000 ok(ret == -1, "expected failure\n");
9001 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9002
9003 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9004 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9005 server = accept(listener, NULL, NULL);
9006 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9007 set_blocking(client, FALSE);
9008
9009 WSASetLastError(0xdeadbeef);
9010 ret = shutdown(client, SD_SEND);
9011 ok(!ret, "expected success\n");
9012 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9013
9014 WSASetLastError(0xdeadbeef);
9015 ret = shutdown(client, SD_SEND);
9016 ok(!ret, "expected success\n");
9017 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9018
9019 WSASetLastError(0xdeadbeef);
9020 ret = send(client, "test", 5, 0);
9021 ok(ret == -1, "got %d\n", ret);
9022 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9023
9024 ret = recv(server, buffer, sizeof(buffer), 0);
9025 ok(!ret, "got %d\n", ret);
9026 ret = recv(server, buffer, sizeof(buffer), 0);
9027 ok(!ret, "got %d\n", ret);
9028
9029 WSASetLastError(0xdeadbeef);
9030 ret = shutdown(server, SD_RECEIVE);
9031 ok(!ret, "expected success\n");
9032 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9033
9034 WSASetLastError(0xdeadbeef);
9035 ret = recv(server, buffer, sizeof(buffer), 0);
9036 ok(ret == -1, "got %d\n", ret);
9037 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9038
9039 ret = send(server, "test", 5, 0);
9040 ok(ret == 5, "got %d\n", ret);
9041
9042 ret = sync_recv(client, buffer, sizeof(buffer), 0);
9043 ok(ret == 5, "got %d\n", ret);
9044 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, ret));
9045
9046 WSASetLastError(0xdeadbeef);
9047 ret = shutdown(client, SD_RECEIVE);
9048 ok(!ret, "expected success\n");
9049 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9050
9051 WSASetLastError(0xdeadbeef);
9052 ret = recv(client, buffer, sizeof(buffer), 0);
9053 ok(ret == -1, "got %d\n", ret);
9054 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9055
9056 WSASetLastError(0xdeadbeef);
9057 ret = recv(client, buffer, sizeof(buffer), 0);
9058 ok(ret == -1, "got %d\n", ret);
9059 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9060
9061 WSASetLastError(0xdeadbeef);
9062 ret = shutdown(server, SD_SEND);
9063 ok(!ret, "expected success\n");
9064 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9065
9066 WSASetLastError(0xdeadbeef);
9067 ret = send(server, "test", 5, 0);
9068 ok(ret == -1, "got %d\n", ret);
9069 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9070
9071 addrlen = sizeof(addr);
9072 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
9073 todo_wine ok(!ret, "got error %u\n", WSAGetLastError());
9074 todo_wine ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
9075
9076 addrlen = sizeof(client_addr);
9077 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
9078 ok(!ret, "got error %u\n", WSAGetLastError());
9079 addrlen = sizeof(addr);
9080 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
9081 todo_wine ok(!ret, "got error %u\n", WSAGetLastError());
9082 todo_wine ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
9083
9084 WSASetLastError(0xdeadbeef);
9085 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9086 ok(ret == -1, "got %d\n", ret);
9087 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
9088
9089 WSASetLastError(0xdeadbeef);
9090 ret = shutdown(client, 0xdeadbeef);
9091 ok(ret == -1, "expected failure\n");
9092 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
9093
9094 closesocket(client);
9095 closesocket(server);
9096
9097 /* Test SD_BOTH. */
9098
9099 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9100 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9101 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9102 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9103 server = accept(listener, NULL, NULL);
9104 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9105
9106 WSASetLastError(0xdeadbeef);
9107 ret = shutdown(client, SD_BOTH);
9108 ok(!ret, "expected success\n");
9109 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9110
9111 WSASetLastError(0xdeadbeef);
9112 ret = recv(client, buffer, sizeof(buffer), 0);
9113 ok(ret == -1, "got %d\n", ret);
9114 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9115
9116 WSASetLastError(0xdeadbeef);
9117 ret = send(client, "test", 5, 0);
9118 ok(ret == -1, "got %d\n", ret);
9119 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9120
9121 ret = recv(server, buffer, sizeof(buffer), 0);
9122 ok(!ret, "got %d\n", ret);
9123
9124 WSASetLastError(0xdeadbeef);
9125 ret = shutdown(server, SD_BOTH);
9126 ok(!ret, "expected success\n");
9127 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9128
9129 WSASetLastError(0xdeadbeef);
9130 ret = recv(server, buffer, sizeof(buffer), 0);
9131 ok(ret == -1, "got %d\n", ret);
9132 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9133
9134 WSASetLastError(0xdeadbeef);
9135 ret = send(server, "test", 5, 0);
9136 ok(ret == -1, "got %d\n", ret);
9137 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9138
9139 addrlen = sizeof(addr);
9140 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
9141 todo_wine ok(!ret, "got error %u\n", WSAGetLastError());
9142 todo_wine ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
9143
9144 addrlen = sizeof(client_addr);
9145 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
9146 ok(!ret, "got error %u\n", WSAGetLastError());
9147 addrlen = sizeof(addr);
9148 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
9149 todo_wine ok(!ret, "got error %u\n", WSAGetLastError());
9150 todo_wine ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
9151
9152 closesocket(client);
9153 closesocket(server);
9154
9155 /* Test shutting down with async I/O pending. */
9156
9157 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9158 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9159 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9160 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9161 server = accept(listener, NULL, NULL);
9162 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9163 set_blocking(client, FALSE);
9164
9165 wsabuf.buf = buffer;
9166 wsabuf.len = sizeof(buffer);
9167 WSASetLastError(0xdeadbeef);
9168 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
9169 ok(ret == -1, "got %d\n", ret);
9170 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
9171
9172 ret = shutdown(client, SD_RECEIVE);
9173 ok(!ret, "got error %u\n", WSAGetLastError());
9174
9175 WSASetLastError(0xdeadbeef);
9176 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
9177 ok(ret == -1, "got %d\n", ret);
9178 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9179
9180 ret = send(server, "test", 5, 0);
9181 ok(ret == 5, "got %d\n", ret);
9182
9183 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9184 ok(!ret, "wait timed out\n");
9185 size = 0xdeadbeef;
9186 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
9187 ok(ret, "got error %lu\n", GetLastError());
9188 ok(size == 5, "got size %lu\n", size);
9189 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, size));
9190
9191 WSASetLastError(0xdeadbeef);
9192 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
9193 ok(ret == -1, "got %d\n", ret);
9194 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9195
9196 WSASetLastError(0xdeadbeef);
9197 ret = WSARecv(server, &wsabuf, 1, &size, &flags, &overlapped, NULL);
9198 ok(ret == -1, "got %d\n", ret);
9199 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
9200
9201 ret = shutdown(client, SD_SEND);
9202 ok(!ret, "got error %u\n", WSAGetLastError());
9203
9204 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9205 ok(!ret, "wait timed out\n");
9206 size = 0xdeadbeef;
9207 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
9208 ok(ret, "got error %lu\n", GetLastError());
9209 ok(!size, "got size %lu\n", size);
9210
9211 closesocket(client);
9212 closesocket(server);
9213
9214 /* Test shutting down a listening socket. */
9215
9216 WSASetLastError(0xdeadbeef);
9217 ret = shutdown(listener, SD_SEND);
9218 ok(ret == -1, "expected failure\n");
9219 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9220
9221 WSASetLastError(0xdeadbeef);
9222 ret = shutdown(listener, SD_RECEIVE);
9223 ok(ret == -1, "expected failure\n");
9224 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9225
9226 closesocket(listener);
9227
9228 /* Test shutting down UDP sockets. */
9229
9230 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
9231 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
9232 memset(&addr, 0, sizeof(addr));
9233 addr.sin_family = AF_INET;
9234 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
9235 ret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
9236 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9237 addrlen = sizeof(server_addr);
9238 ret = getsockname(server, (struct sockaddr *)&server_addr, &addrlen);
9239 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
9240 set_blocking(server, FALSE);
9241
9242 WSASetLastError(0xdeadbeef);
9243 ret = shutdown(server, SD_RECEIVE);
9244 ok(!ret, "expected success\n");
9245 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9246
9247 WSASetLastError(0xdeadbeef);
9248 ret = recvfrom(server, buffer, sizeof(buffer), 0, NULL, NULL);
9249 ok(ret == -1, "got %d\n", ret);
9250 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9251
9252 ret = sendto(client, "test", 5, 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
9253 ok(ret == 5, "got %d\n", ret);
9254
9255 WSASetLastError(0xdeadbeef);
9256 ret = shutdown(client, SD_SEND);
9257 ok(!ret, "expected success\n");
9258 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9259
9260 WSASetLastError(0xdeadbeef);
9261 ret = shutdown(client, SD_SEND);
9262 ok(!ret, "expected success\n");
9263 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9264
9265 WSASetLastError(0xdeadbeef);
9266 ret = sendto(client, "test", 5, 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
9267 ok(ret == -1, "got %d\n", ret);
9268 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9269
9270 closesocket(client);
9271 closesocket(server);
9272
9273 CloseHandle(overlapped.hEvent);
9274 }
9275
9276 static void test_DisconnectEx(void)
9277 {
9278 struct sockaddr_in server_addr, client_addr, addr;
9279 GUID disconnectex_guid = WSAID_DISCONNECTEX;
9280 SOCKET listener, server, client;
9281 LPFN_DISCONNECTEX pDisconnectEx;
9282 OVERLAPPED overlapped = {0};
9283 int addrlen, ret;
9284 char buffer[5];
9285 DWORD size;
9286
9287 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
9288
9289 client = socket(AF_INET, SOCK_STREAM, 0);
9290 ok(client != INVALID_SOCKET, "failed to create connector socket, error %u\n", WSAGetLastError());
9291
9292 ret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &disconnectex_guid, sizeof(disconnectex_guid),
9293 &pDisconnectEx, sizeof(pDisconnectEx), &size, NULL, NULL);
9294 if (ret)
9295 {
9296 win_skip("WSAIoctl failed to get DisconnectEx, error %d\n", WSAGetLastError());
9297 closesocket(client);
9298 return;
9299 }
9300
9301 listener = socket(AF_INET, SOCK_STREAM, 0);
9302 ok(listener != INVALID_SOCKET, "failed to create listener socket, error %d\n", WSAGetLastError());
9303
9304 memset(&addr, 0, sizeof(addr));
9305 addr.sin_family = AF_INET;
9306 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
9307 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
9308 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9309 addrlen = sizeof(server_addr);
9310 ret = getsockname(listener, (struct sockaddr *)&server_addr, &addrlen);
9311 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
9312 ret = listen(listener, 1);
9313 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
9314
9315 WSASetLastError(0xdeadbeef);
9316 ret = pDisconnectEx(INVALID_SOCKET, &overlapped, 0, 0);
9317 ok(!ret, "expected failure\n");
9318 ok(WSAGetLastError() == WSAENOTSOCK, "got error %u\n", WSAGetLastError());
9319
9320 WSASetLastError(0xdeadbeef);
9321 ret = pDisconnectEx(client, &overlapped, 0, 0);
9322 ok(!ret, "expected failure\n");
9323 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
9324
9325 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9326 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9327 server = accept(listener, NULL, NULL);
9328 ok(server != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
9329
9330 WSASetLastError(0xdeadbeef);
9331 ret = pDisconnectEx(client, &overlapped, 0, 0);
9332 ok(!ret, "expected failure\n");
9333 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
9334
9335 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9336 ok(!ret, "wait timed out\n");
9337 size = 0xdeadbeef;
9338 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
9339 ok(ret, "got error %lu\n", GetLastError());
9340 ok(!size, "got size %lu\n", size);
9341
9342 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9343 ok(ret == -1, "expected failure\n");
9344 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
9345
9346 WSASetLastError(0xdeadbeef);
9347 ret = send(client, "test", 5, 0);
9348 ok(ret == -1, "expected failure\n");
9349 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9350
9351 ret = recv(server, buffer, sizeof(buffer), 0);
9352 ok(!ret, "got %d\n", ret);
9353
9354 ret = send(server, "test", 5, 0);
9355 ok(ret == 5, "got %d\n", ret);
9356
9357 ret = recv(client, buffer, sizeof(buffer), 0);
9358 ok(ret == 5, "got %d\n", ret);
9359 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, ret));
9360
9361 addrlen = sizeof(addr);
9362 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
9363 ok(!ret, "got error %u\n", WSAGetLastError());
9364 ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
9365
9366 addrlen = sizeof(client_addr);
9367 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
9368 ok(!ret, "got error %u\n", WSAGetLastError());
9369 addrlen = sizeof(addr);
9370 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
9371 ok(!ret, "got error %u\n", WSAGetLastError());
9372 ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
9373
9374 closesocket(client);
9375 closesocket(server);
9376
9377 /* Test the synchronous case. */
9378
9379 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9380 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9381 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9382 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9383 server = accept(listener, NULL, NULL);
9384 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9385
9386 WSASetLastError(0xdeadbeef);
9387 ret = pDisconnectEx(client, NULL, 0, 0);
9388 ok(ret, "expected success\n");
9389 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9390
9391 WSASetLastError(0xdeadbeef);
9392 ret = pDisconnectEx(client, NULL, 0, 0);
9393 ok(ret, "expected success\n");
9394 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
9395
9396 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
9397 ok(ret == -1, "expected failure\n");
9398 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
9399
9400 WSASetLastError(0xdeadbeef);
9401 ret = send(client, "test", 5, 0);
9402 ok(ret == -1, "expected failure\n");
9403 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
9404
9405 ret = recv(server, buffer, sizeof(buffer), 0);
9406 ok(!ret, "got %d\n", ret);
9407
9408 ret = send(server, "test", 5, 0);
9409 ok(ret == 5, "got %d\n", ret);
9410
9411 ret = recv(client, buffer, sizeof(buffer), 0);
9412 ok(ret == 5, "got %d\n", ret);
9413 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, ret));
9414
9415 addrlen = sizeof(addr);
9416 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
9417 ok(!ret, "got error %u\n", WSAGetLastError());
9418 ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
9419
9420 addrlen = sizeof(client_addr);
9421 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
9422 ok(!ret, "got error %u\n", WSAGetLastError());
9423 addrlen = sizeof(addr);
9424 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
9425 ok(!ret, "got error %u\n", WSAGetLastError());
9426 ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
9427
9428 closesocket(client);
9429 closesocket(server);
9430
9431 closesocket(listener);
9432 CloseHandle(overlapped.hEvent);
9433 }
9434
9435 #define compare_file(h,s,o) compare_file2(h,s,o,__FILE__,__LINE__)
9436
9437 static void compare_file2(HANDLE handle, SOCKET sock, int offset, const char *file, int line)
9438 {
9439 char buf1[256], buf2[256];
9440 BOOL success;
9441 int i = 0;
9442
9443 SetFilePointer(handle, offset, NULL, FILE_BEGIN);
9444 while (1)
9445 {
9446 DWORD n1 = 0, n2 = 0;
9447
9448 success = ReadFile(handle, buf1, sizeof(buf1), &n1, NULL);
9449 ok_(file,line)(success, "Failed to read from file.\n");
9450 if (success && n1 == 0)
9451 break;
9452 else if(!success)
9453 return;
9454 n2 = recv(sock, buf2, n1, 0);
9455 ok_(file,line)(n1 == n2, "Block %d size mismatch (%ld != %ld)\n", i, n1, n2);
9456 ok_(file,line)(memcmp(buf1, buf2, n2) == 0, "Block %d failed\n", i);
9457 i++;
9458 }
9459 }
9460
9461 static void test_TransmitFile(void)
9462 {
9463 DWORD num_bytes, err, file_size, total_sent;
9464 GUID transmitFileGuid = WSAID_TRANSMITFILE;
9465 LPFN_TRANSMITFILE pTransmitFile = NULL;
9466 HANDLE file = INVALID_HANDLE_VALUE;
9467 char header_msg[] = "hello world";
9468 char footer_msg[] = "goodbye!!!";
9469 char system_ini_path[MAX_PATH];
9470 struct sockaddr_in bindAddress;
9471 TRANSMIT_FILE_BUFFERS buffers;
9472 SOCKET client, server, dest;
9473 WSAOVERLAPPED ov;
9474 char buf[256];
9475 int iret, len;
9476 BOOL bret;
9477
9478 memset( &ov, 0, sizeof(ov) );
9479
9480 /* Setup sockets for testing TransmitFile */
9481 client = socket(AF_INET, SOCK_STREAM, 0);
9482 ok(client != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9483 server = socket(AF_INET, SOCK_STREAM, 0);
9484 ok(server != INVALID_SOCKET, "failed to create socket, error %lu\n", GetLastError());
9485 iret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &transmitFileGuid, sizeof(transmitFileGuid),
9486 &pTransmitFile, sizeof(pTransmitFile), &num_bytes, NULL, NULL);
9487 ok(!iret, "failed to get TransmitFile, error %lu\n", GetLastError());
9488 GetSystemWindowsDirectoryA(system_ini_path, MAX_PATH );
9489 strcat(system_ini_path, "\\system.ini");
9490 file = CreateFileA(system_ini_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0x0, NULL);
9491 ok(file != INVALID_HANDLE_VALUE, "failed to open file, error %lu\n", GetLastError());
9492 file_size = GetFileSize(file, NULL);
9493
9494 /* Test TransmitFile with an invalid socket */
9495 bret = pTransmitFile(INVALID_SOCKET, file, 0, 0, NULL, NULL, 0);
9496 err = WSAGetLastError();
9497 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9498 ok(err == WSAENOTSOCK, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, WSAENOTSOCK);
9499
9500 /* Test a bogus TransmitFile without a connected socket */
9501 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, TF_REUSE_SOCKET);
9502 err = WSAGetLastError();
9503 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9504 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, WSAENOTCONN);
9505
9506 /* Setup a properly connected socket for transfers */
9507 memset(&bindAddress, 0, sizeof(bindAddress));
9508 bindAddress.sin_family = AF_INET;
9509 bindAddress.sin_port = htons(SERVERPORT+1);
9510 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
9511 iret = bind(server, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9512 ok(!iret, "failed to bind socket, error %lu\n", GetLastError());
9513 iret = listen(server, 1);
9514 ok(!iret, "failed to listen, error %lu\n", GetLastError());
9515 iret = connect(client, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9516 ok(!iret, "failed to connect, error %lu\n", GetLastError());
9517 len = sizeof(bindAddress);
9518 dest = accept(server, (struct sockaddr*)&bindAddress, &len);
9519 ok(dest != INVALID_SOCKET, "failed to accept, error %lu\n", GetLastError());
9520 iret = set_blocking(dest, FALSE);
9521 ok(!iret, "failed to set nonblocking, error %lu\n", GetLastError());
9522
9523 /* Test TransmitFile with no possible buffer */
9524 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
9525 ok(bret, "TransmitFile failed unexpectedly.\n");
9526 iret = recv(dest, buf, sizeof(buf), 0);
9527 ok(iret == -1, "Returned an unexpected buffer from TransmitFile (%d != -1).\n", iret);
9528
9529 /* Test TransmitFile with only buffer data */
9530 buffers.Head = &header_msg[0];
9531 buffers.HeadLength = sizeof(header_msg);
9532 buffers.Tail = &footer_msg[0];
9533 buffers.TailLength = sizeof(footer_msg);
9534 bret = pTransmitFile(client, NULL, 0, 0, NULL, &buffers, 0);
9535 ok(bret, "TransmitFile failed unexpectedly.\n");
9536 iret = recv(dest, buf, sizeof(buf), 0);
9537 ok(iret == sizeof(header_msg)+sizeof(footer_msg),
9538 "Returned an unexpected buffer from TransmitFile: %d\n", iret );
9539 ok(memcmp(&buf[0], &header_msg[0], sizeof(header_msg)) == 0,
9540 "TransmitFile header buffer did not match!\n");
9541 ok(memcmp(&buf[sizeof(header_msg)], &footer_msg[0], sizeof(footer_msg)) == 0,
9542 "TransmitFile footer buffer did not match!\n");
9543
9544 /* Test TransmitFile with only file data */
9545 bret = pTransmitFile(client, file, 0, 0, NULL, NULL, 0);
9546 ok(bret, "TransmitFile failed unexpectedly.\n");
9547 compare_file(file, dest, 0);
9548
9549 /* Test TransmitFile with both file and buffer data */
9550 buffers.Head = &header_msg[0];
9551 buffers.HeadLength = sizeof(header_msg);
9552 buffers.Tail = &footer_msg[0];
9553 buffers.TailLength = sizeof(footer_msg);
9554 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9555 bret = pTransmitFile(client, file, 0, 0, NULL, &buffers, 0);
9556 ok(bret, "TransmitFile failed unexpectedly.\n");
9557 iret = recv(dest, buf, sizeof(header_msg), 0);
9558 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)) == 0,
9559 "TransmitFile header buffer did not match!\n");
9560 compare_file(file, dest, 0);
9561 iret = recv(dest, buf, sizeof(footer_msg), 0);
9562 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)) == 0,
9563 "TransmitFile footer buffer did not match!\n");
9564
9565 /* Test overlapped TransmitFile */
9566 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
9567 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9568 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
9569 err = WSAGetLastError();
9570 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9571 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%ld != %d)\n",
9572 err, ERROR_IO_PENDING);
9573 iret = WaitForSingleObject(ov.hEvent, 2000);
9574 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
9575 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
9576 ok(total_sent == file_size,
9577 "Overlapped TransmitFile sent an unexpected number of bytes (%ld != %ld).\n",
9578 total_sent, file_size);
9579 compare_file(file, dest, 0);
9580
9581 /* Test overlapped TransmitFile w/ start offset */
9582 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
9583 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9584 ov.Offset = 10;
9585 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
9586 err = WSAGetLastError();
9587 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9588 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, ERROR_IO_PENDING);
9589 iret = WaitForSingleObject(ov.hEvent, 2000);
9590 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
9591 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
9592 ok(total_sent == (file_size - ov.Offset),
9593 "Overlapped TransmitFile sent an unexpected number of bytes (%ld != %ld).\n",
9594 total_sent, file_size - ov.Offset);
9595 compare_file(file, dest, ov.Offset);
9596
9597 /* Test overlapped TransmitFile w/ file and buffer data */
9598 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
9599 buffers.Head = &header_msg[0];
9600 buffers.HeadLength = sizeof(header_msg);
9601 buffers.Tail = &footer_msg[0];
9602 buffers.TailLength = sizeof(footer_msg);
9603 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9604 ov.Offset = 0;
9605 bret = pTransmitFile(client, file, 0, 0, &ov, &buffers, 0);
9606 err = WSAGetLastError();
9607 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9608 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, ERROR_IO_PENDING);
9609 iret = WaitForSingleObject(ov.hEvent, 2000);
9610 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
9611 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
9612 ok(total_sent == (file_size + buffers.HeadLength + buffers.TailLength),
9613 "Overlapped TransmitFile sent an unexpected number of bytes (%ld != %ld).\n",
9614 total_sent, file_size + buffers.HeadLength + buffers.TailLength);
9615 iret = recv(dest, buf, sizeof(header_msg), 0);
9616 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)) == 0,
9617 "TransmitFile header buffer did not match!\n");
9618 compare_file(file, dest, 0);
9619 iret = recv(dest, buf, sizeof(footer_msg), 0);
9620 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)) == 0,
9621 "TransmitFile footer buffer did not match!\n");
9622
9623 /* Test TransmitFile with a UDP datagram socket */
9624 closesocket(client);
9625 client = socket(AF_INET, SOCK_DGRAM, 0);
9626 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
9627 err = WSAGetLastError();
9628 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9629 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%ld != %d)\n", err, WSAENOTCONN);
9630
9631 CloseHandle(file);
9632 CloseHandle(ov.hEvent);
9633 closesocket(client);
9634 closesocket(server);
9635 }
9636
9637 static void test_getpeername(void)
9638 {
9639 SOCKET sock;
9640 struct sockaddr_in sa, sa_out;
9641 SOCKADDR_STORAGE ss;
9642 int sa_len;
9643 const char buf[] = "hello world";
9644 int ret;
9645
9646 /* Test the parameter validation order. */
9647 ret = getpeername(INVALID_SOCKET, NULL, NULL);
9648 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9649 ok(WSAGetLastError() == WSAENOTSOCK,
9650 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
9651
9652 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
9653 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
9654
9655 ret = getpeername(sock, NULL, NULL);
9656 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9657 todo_wine ok(WSAGetLastError() == WSAENOTCONN,
9658 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
9659
9660 memset(&sa, 0, sizeof(sa));
9661 sa.sin_family = AF_INET;
9662 sa.sin_port = htons(139);
9663 sa.sin_addr.s_addr = inet_addr("127.0.0.1");
9664
9665 /* sendto does not change a socket's connection state. */
9666 ret = sendto(sock, buf, sizeof(buf), 0, (struct sockaddr*)&sa, sizeof(sa));
9667 ok(ret != SOCKET_ERROR,
9668 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
9669
9670 ret = getpeername(sock, NULL, NULL);
9671 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9672 todo_wine ok(WSAGetLastError() == WSAENOTCONN,
9673 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
9674
9675 ret = connect(sock, (struct sockaddr*)&sa, sizeof(sa));
9676 ok(ret == 0,
9677 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
9678
9679 ret = getpeername(sock, NULL, NULL);
9680 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9681 ok(WSAGetLastError() == WSAEFAULT,
9682 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9683
9684 /* Test crashes on Wine. */
9685 if (0)
9686 {
9687 ret = getpeername(sock, (void*)0xdeadbeef, (void*)0xcafebabe);
9688 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9689 ok(WSAGetLastError() == WSAEFAULT,
9690 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9691 }
9692
9693 ret = getpeername(sock, (struct sockaddr*)&sa_out, NULL);
9694 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
9695 ok(WSAGetLastError() == WSAEFAULT,
9696 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9697
9698 sa_len = 0;
9699 ret = getpeername(sock, NULL, &sa_len);
9700 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
9701 ok(WSAGetLastError() == WSAEFAULT,
9702 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9703 ok(!sa_len, "got %d\n", sa_len);
9704
9705 sa_len = 0;
9706 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
9707 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
9708 ok(WSAGetLastError() == WSAEFAULT,
9709 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9710 ok(!sa_len, "got %d\n", sa_len);
9711
9712 sa_len = sizeof(ss);
9713 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
9714 ok(ret == 0, "Expected getpeername to return 0, got %d\n", ret);
9715 ok(!memcmp(&sa, &ss, sizeof(sa)),
9716 "Expected the returned structure to be identical to the connect structure\n");
9717 ok(sa_len == sizeof(sa), "got %d\n", sa_len);
9718
9719 closesocket(sock);
9720 }
9721
9722 static void test_sioRoutingInterfaceQuery(void)
9723 {
9724 OVERLAPPED overlapped = {0}, *overlapped_ptr;
9725 struct sockaddr_in in = {0}, out = {0};
9726 ULONG_PTR key;
9727 HANDLE port;
9728 SOCKET sock;
9729 DWORD size;
9730 int ret;
9731
9732 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
9733 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
9734 port = CreateIoCompletionPort((HANDLE)sock, NULL, 123, 0);
9735
9736 WSASetLastError(0xdeadbeef);
9737 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), NULL, NULL, NULL);
9738 ok(ret == -1, "expected failure\n");
9739 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
9740
9741 size = 0xdeadbeef;
9742 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in) - 1, &out, sizeof(out), &size, NULL, NULL);
9743 ok(ret == -1, "expected failure\n");
9744 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
9745 ok(size == 0xdeadbeef, "got size %lu\n", size);
9746
9747 size = 0xdeadbeef;
9748 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, NULL, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
9749 ok(ret == -1, "expected failure\n");
9750 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
9751 ok(size == 0xdeadbeef, "got size %lu\n", size);
9752
9753 size = 0xdeadbeef;
9754 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
9755 ok(ret == -1, "expected failure\n");
9756 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError());
9757 ok(size == 0xdeadbeef, "got size %lu\n", size);
9758
9759 in.sin_family = AF_INET;
9760 size = 0xdeadbeef;
9761 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
9762 todo_wine ok(ret == -1, "expected failure\n");
9763 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
9764 todo_wine ok(size == 0xdeadbeef, "got size %lu\n", size);
9765
9766 in.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
9767 WSASetLastError(0xdeadbeef);
9768 size = 0xdeadbeef;
9769 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
9770 ok(!ret, "expected failure\n");
9771 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
9772 ok(size == sizeof(out), "got size %lu\n", size);
9773 /* We expect the source address to be INADDR_LOOPBACK as well, but
9774 * there's no guarantee that a route to the loopback address exists,
9775 * so rather than introduce spurious test failures we do not test the
9776 * source address.
9777 */
9778
9779 size = 0xdeadbeef;
9780 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out) - 1, &size, NULL, NULL);
9781 ok(ret == -1, "expected failure\n");
9782 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
9783 todo_wine ok(size == sizeof(out), "got size %lu\n", size);
9784
9785 size = 0xdeadbeef;
9786 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), NULL, sizeof(out), &size, NULL, NULL);
9787 ok(ret == -1, "expected failure\n");
9788 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
9789 ok(size == 0xdeadbeef, "got size %lu\n", size);
9790
9791 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), NULL, &overlapped, NULL);
9792 ok(ret == -1, "expected failure\n");
9793 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
9794 ok(size == 0xdeadbeef, "got size %lu\n", size);
9795
9796 WSASetLastError(0xdeadbeef);
9797 size = 0xdeadbeef;
9798 overlapped.Internal = 0xdeadbeef;
9799 overlapped.InternalHigh = 0xdeadbeef;
9800 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, &overlapped, NULL);
9801 ok(!ret, "expected failure\n");
9802 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
9803 ok(size == sizeof(out), "got size %lu\n", size);
9804
9805 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
9806 ok(ret, "got error %lu\n", GetLastError());
9807 ok(!size, "got size %lu\n", size);
9808 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
9809 ok(!overlapped.Internal, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
9810 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
9811
9812 CloseHandle(port);
9813 closesocket(sock);
9814
9815 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
9816
9817 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in),
9818 &out, sizeof(out), NULL, &overlapped, socket_apc);
9819 ok(ret == -1, "expected failure\n");
9820 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
9821
9822 apc_count = 0;
9823 size = 0xdeadbeef;
9824 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in),
9825 &out, sizeof(out), &size, &overlapped, socket_apc);
9826 ok(!ret, "expected success\n");
9827 ok(size == sizeof(out), "got size %lu\n", size);
9828
9829 ret = SleepEx(0, TRUE);
9830 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
9831 ok(apc_count == 1, "APC was called %u times\n", apc_count);
9832 ok(!apc_error, "got APC error %lu\n", apc_error);
9833 ok(!apc_size, "got APC size %lu\n", apc_size);
9834 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
9835
9836 closesocket(sock);
9837 }
9838
9839 static void test_sioAddressListChange(void)
9840 {
9841 struct sockaddr_in bindAddress;
9842 struct in_addr net_address;
9843 WSAOVERLAPPED overlapped, *olp;
9844 struct hostent *h;
9845 DWORD num_bytes, error, tick;
9846 SOCKET sock, sock2, sock3;
9847 WSAEVENT event2, event3;
9848 HANDLE io_port;
9849 ULONG_PTR key;
9850 int acount;
9851 BOOL bret;
9852 int ret;
9853
9854 /* Use gethostbyname to find the list of local network interfaces */
9855 h = gethostbyname("");
9856 ok(!!h, "failed to get interface list, error %u\n", WSAGetLastError());
9857 for (acount = 0; h->h_addr_list[acount]; acount++);
9858 if (acount == 0)
9859 {
9860 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
9861 return;
9862 }
9863
9864 net_address.s_addr = *(ULONG *) h->h_addr_list[0];
9865
9866 sock = socket(AF_INET, 0, IPPROTO_TCP);
9867 ok(sock != INVALID_SOCKET, "socket() failed\n");
9868
9869 memset(&bindAddress, 0, sizeof(bindAddress));
9870 bindAddress.sin_family = AF_INET;
9871 bindAddress.sin_addr.s_addr = net_address.s_addr;
9872 SetLastError(0xdeadbeef);
9873 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9874 ok (!ret, "bind() failed with error %ld\n", GetLastError());
9875 set_blocking(sock, FALSE);
9876
9877 memset(&overlapped, 0, sizeof(overlapped));
9878 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9879 SetLastError(0xdeadbeef);
9880 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
9881 error = GetLastError();
9882 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
9883 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%lx\n", error);
9884
9885 CloseHandle(overlapped.hEvent);
9886 closesocket(sock);
9887
9888 sock = socket(AF_INET, 0, IPPROTO_TCP);
9889 ok(sock != INVALID_SOCKET, "socket() failed\n");
9890
9891 SetLastError(0xdeadbeef);
9892 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9893 ok (!ret, "bind() failed with error %ld\n", GetLastError());
9894 set_blocking(sock, TRUE);
9895
9896 memset(&overlapped, 0, sizeof(overlapped));
9897 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9898 SetLastError(0xdeadbeef);
9899 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
9900 error = GetLastError();
9901 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
9902 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%lx\n", error);
9903
9904 CloseHandle(overlapped.hEvent);
9905 closesocket(sock);
9906
9907 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9908 ok(sock != INVALID_SOCKET, "socket() failed\n");
9909
9910 SetLastError(0xdeadbeef);
9911 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9912 ok (!ret, "bind() failed with error %ld\n", GetLastError());
9913 set_blocking(sock, FALSE);
9914
9915 memset(&overlapped, 0, sizeof(overlapped));
9916 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9917 SetLastError(0xdeadbeef);
9918 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
9919 error = GetLastError();
9920 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
9921 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%lx\n", error);
9922
9923 CloseHandle(overlapped.hEvent);
9924 closesocket(sock);
9925
9926 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9927 ok(sock != INVALID_SOCKET, "socket() failed\n");
9928
9929 SetLastError(0xdeadbeef);
9930 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9931 ok (!ret, "bind() failed with error %ld\n", GetLastError());
9932 set_blocking(sock, TRUE);
9933
9934 memset(&overlapped, 0, sizeof(overlapped));
9935 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9936 SetLastError(0xdeadbeef);
9937 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
9938 error = GetLastError();
9939 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
9940 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%lx\n", error);
9941
9942 CloseHandle(overlapped.hEvent);
9943 closesocket(sock);
9944
9945 /* When the socket is overlapped non-blocking and the list change is requested without
9946 * an overlapped structure the error will be different. */
9947 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9948 ok(sock != INVALID_SOCKET, "socket() failed\n");
9949
9950 SetLastError(0xdeadbeef);
9951 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9952 ok (!ret, "bind() failed with error %ld\n", GetLastError());
9953 set_blocking(sock, FALSE);
9954
9955 SetLastError(0xdeadbeef);
9956 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
9957 error = GetLastError();
9958 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %ld\n", error);
9959 ok (error == WSAEWOULDBLOCK, "expected 10035, got %ld\n", error);
9960
9961 io_port = CreateIoCompletionPort( (HANDLE)sock, NULL, 0, 0 );
9962 ok (io_port != NULL, "failed to create completion port %lu\n", GetLastError());
9963
9964 set_blocking(sock, FALSE);
9965 memset(&overlapped, 0, sizeof(overlapped));
9966 SetLastError(0xdeadbeef);
9967 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
9968 error = GetLastError();
9969 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %lu\n", error);
9970 ok (error == ERROR_IO_PENDING, "expected ERROR_IO_PENDING got %lu\n", error);
9971
9972 olp = (WSAOVERLAPPED *)0xdeadbeef;
9973 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 0 );
9974 ok(!bret, "failed to get completion status %u\n", bret);
9975 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
9976 ok(!olp, "Overlapped structure is at %p\n", olp);
9977
9978 closesocket(sock);
9979
9980 olp = (WSAOVERLAPPED *)0xdeadbeef;
9981 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 0 );
9982 ok(!bret, "failed to get completion status %u\n", bret);
9983 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %lu\n", GetLastError());
9984 ok(olp == &overlapped, "Overlapped structure is at %p\n", olp);
9985
9986 CloseHandle(io_port);
9987
9988 /* Misuse of the API by using a blocking socket and not using an overlapped structure,
9989 * this leads to a hang forever. */
9990 if (0)
9991 {
9992 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9993
9994 SetLastError(0xdeadbeef);
9995 bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9996
9997 set_blocking(sock, TRUE);
9998 WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
9999 /* hang */
10000
10001 closesocket(sock);
10002 }
10003
10004 if (!winetest_interactive)
10005 {
10006 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
10007 return;
10008 }
10009
10010 /* Bind an overlapped socket to the first found network interface */
10011 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10012 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
10013 sock2 = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10014 ok(sock2 != INVALID_SOCKET, "Expected socket to return a valid socket\n");
10015 sock3 = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10016 ok(sock3 != INVALID_SOCKET, "Expected socket to return a valid socket\n");
10017
10018 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10019 ok(!ret, "bind failed unexpectedly\n");
10020 ret = bind(sock2, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10021 ok(!ret, "bind failed unexpectedly\n");
10022 ret = bind(sock3, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10023 ok(!ret, "bind failed unexpectedly\n");
10024
10025 set_blocking(sock2, FALSE);
10026 set_blocking(sock3, FALSE);
10027
10028 /* Wait for address changes, request that the user connects/disconnects an interface */
10029 memset(&overlapped, 0, sizeof(overlapped));
10030 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10031 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
10032 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
10033 ok(WSAGetLastError() == WSA_IO_PENDING, "Expected pending last error, got %d\n", WSAGetLastError());
10034
10035 ret = WSAIoctl(sock2, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
10036 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
10037 ok(WSAGetLastError() == WSAEWOULDBLOCK, "Expected would block last error, got %d\n", WSAGetLastError());
10038
10039 event2 = WSACreateEvent();
10040 event3 = WSACreateEvent();
10041 ret = WSAEventSelect (sock2, event2, FD_ADDRESS_LIST_CHANGE);
10042 ok(!ret, "WSAEventSelect failed with %d\n", WSAGetLastError());
10043 /* sock3 did not request SIO_ADDRESS_LIST_CHANGE but it is trying to wait anyway */
10044 ret = WSAEventSelect (sock3, event3, FD_ADDRESS_LIST_CHANGE);
10045 ok(!ret, "WSAEventSelect failed with %d\n", WSAGetLastError());
10046
10047 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
10048 " change the ipv4 address of any of the local network interfaces (15 second timeout).\n");
10049 tick = GetTickCount();
10050 ret = WaitForSingleObject(overlapped.hEvent, 15000);
10051 ok(ret == WAIT_OBJECT_0, "failed to get overlapped event %u\n", ret);
10052
10053 ret = WaitForSingleObject(event2, 500);
10054 todo_wine
10055 ok(ret == WAIT_OBJECT_0, "failed to get change event %u\n", ret);
10056
10057 ret = WaitForSingleObject(event3, 500);
10058 ok(ret == WAIT_TIMEOUT, "unexpected change event\n");
10059
10060 trace("Spent %ld ms waiting.\n", GetTickCount() - tick);
10061
10062 WSACloseEvent(event2);
10063 WSACloseEvent(event3);
10064
10065 closesocket(sock);
10066 closesocket(sock2);
10067 closesocket(sock3);
10068 }
10069
10070 /*
10071 * Provide consistent initialization for the AcceptEx IOCP tests.
10072 */
10073 static SOCKET setup_iocp_src(struct sockaddr_in *bindAddress)
10074 {
10075 SOCKET src;
10076 int iret, socklen;
10077
10078 src = socket(AF_INET, SOCK_STREAM, 0);
10079 ok(src != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10080
10081 memset(bindAddress, 0, sizeof(*bindAddress));
10082 bindAddress->sin_family = AF_INET;
10083 bindAddress->sin_addr.s_addr = inet_addr("127.0.0.1");
10084 iret = bind(src, (struct sockaddr*)bindAddress, sizeof(*bindAddress));
10085 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
10086
10087 socklen = sizeof(*bindAddress);
10088 iret = getsockname(src, (struct sockaddr*)bindAddress, &socklen);
10089 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
10090
10091 iret = set_blocking(src, FALSE);
10092 ok(!iret, "failed to make socket non-blocking, error %u\n", WSAGetLastError());
10093
10094 iret = listen(src, 5);
10095 ok(!iret, "failed to listen, error %u\n", WSAGetLastError());
10096
10097 return src;
10098 }
10099
10100 static void test_completion_port(void)
10101 {
10102 HANDLE io_port;
10103 WSAOVERLAPPED ov, *olp;
10104 SOCKET src, dest, dup, connector = INVALID_SOCKET;
10105 WSAPROTOCOL_INFOA info;
10106 char buf[1024];
10107 WSABUF bufs;
10108 DWORD num_bytes, flags;
10109 int iret;
10110 BOOL bret;
10111 ULONG_PTR key;
10112 struct sockaddr_in bindAddress;
10113 GUID acceptExGuid = WSAID_ACCEPTEX;
10114 LPFN_ACCEPTEX pAcceptEx = NULL;
10115 fd_set fds_recv;
10116
10117 memset(buf, 0, sizeof(buf));
10118 io_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
10119 ok( io_port != NULL, "Failed to create completion port %lu\n", GetLastError());
10120
10121 memset(&ov, 0, sizeof(ov));
10122
10123 tcp_socketpair(&src, &dest);
10124
10125 bufs.len = sizeof(buf);
10126 bufs.buf = buf;
10127 flags = 0;
10128
10129 io_port = CreateIoCompletionPort( (HANDLE)dest, io_port, 125, 0 );
10130 ok(io_port != NULL, "Failed to create completion port %lu\n", GetLastError());
10131
10132 SetLastError(0xdeadbeef);
10133
10134 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10135 ok(iret == SOCKET_ERROR, "WSARecv returned %d\n", iret);
10136 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10137
10138 Sleep(100);
10139
10140 close_with_rst(src);
10141
10142 SetLastError(0xdeadbeef);
10143 key = 0xdeadbeef;
10144 num_bytes = 0xdeadbeef;
10145 olp = (WSAOVERLAPPED *)0xdeadbeef;
10146
10147 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10148 ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret);
10149 ok(GetLastError() == ERROR_NETNAME_DELETED, "Last error was %ld\n", GetLastError());
10150 ok(key == 125, "Key is %Iu\n", key);
10151 ok(num_bytes == 0, "Number of bytes received is %lu\n", num_bytes);
10152 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10153
10154 SetLastError(0xdeadbeef);
10155 key = 0xdeadbeef;
10156 num_bytes = 0xdeadbeef;
10157 olp = (WSAOVERLAPPED *)0xdeadbeef;
10158
10159 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10160 ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret );
10161 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10162 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10163 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10164 ok(!olp, "Overlapped structure is at %p\n", olp);
10165
10166 if (dest != INVALID_SOCKET)
10167 closesocket(dest);
10168
10169 memset(&ov, 0, sizeof(ov));
10170
10171 tcp_socketpair(&src, &dest);
10172
10173 bufs.len = sizeof(buf);
10174 bufs.buf = buf;
10175 flags = 0;
10176
10177 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
10178 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10179
10180 set_blocking(dest, FALSE);
10181
10182 close_with_rst(src);
10183
10184 Sleep(100);
10185
10186 num_bytes = 0xdeadbeef;
10187 SetLastError(0xdeadbeef);
10188
10189 iret = WSASend(dest, &bufs, 1, &num_bytes, 0, &ov, NULL);
10190 ok(iret == SOCKET_ERROR, "WSASend failed - %d\n", iret);
10191 ok(GetLastError() == WSAECONNRESET, "Last error was %ld\n", GetLastError());
10192 ok(num_bytes == 0xdeadbeef, "Managed to send %ld\n", num_bytes);
10193
10194 SetLastError(0xdeadbeef);
10195 key = 0xdeadbeef;
10196 num_bytes = 0xdeadbeef;
10197 olp = (WSAOVERLAPPED *)0xdeadbeef;
10198
10199 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10200 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
10201 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10202 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10203 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10204 ok(!olp, "Overlapped structure is at %p\n", olp);
10205
10206 if (dest != INVALID_SOCKET)
10207 closesocket(dest);
10208
10209 /* Test IOCP response on successful immediate read. */
10210 tcp_socketpair(&src, &dest);
10211
10212 bufs.len = sizeof(buf);
10213 bufs.buf = buf;
10214 flags = 0;
10215 SetLastError(0xdeadbeef);
10216
10217 iret = WSASend(src, &bufs, 1, &num_bytes, 0, &ov, NULL);
10218 ok(!iret, "WSASend failed - %d, last error %lu\n", iret, GetLastError());
10219 ok(num_bytes == sizeof(buf), "Managed to send %ld\n", num_bytes);
10220
10221 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
10222 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10223 set_blocking(dest, FALSE);
10224
10225 FD_ZERO(&fds_recv);
10226 FD_SET(dest, &fds_recv);
10227 select(dest + 1, &fds_recv, NULL, NULL, NULL);
10228
10229 num_bytes = 0xdeadbeef;
10230 flags = 0;
10231
10232 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10233 ok(!iret, "WSARecv failed - %d, last error %lu\n", iret, GetLastError());
10234 ok(num_bytes == sizeof(buf), "Managed to read %ld\n", num_bytes);
10235
10236 SetLastError(0xdeadbeef);
10237 key = 0xdeadbeef;
10238 num_bytes = 0xdeadbeef;
10239 olp = (WSAOVERLAPPED *)0xdeadbeef;
10240
10241 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10242 ok(bret == TRUE, "failed to get completion status %u\n", bret);
10243 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
10244 ok(key == 125, "Key is %Iu\n", key);
10245 ok(num_bytes == sizeof(buf), "Number of bytes transferred is %lu\n", num_bytes);
10246 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10247
10248 /* Test IOCP response on graceful shutdown. */
10249 closesocket(src);
10250
10251 FD_ZERO(&fds_recv);
10252 FD_SET(dest, &fds_recv);
10253 select(dest + 1, &fds_recv, NULL, NULL, NULL);
10254
10255 num_bytes = 0xdeadbeef;
10256 flags = 0;
10257 memset(&ov, 0, sizeof(ov));
10258
10259 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10260 ok(!iret, "WSARecv failed - %d, last error %lu\n", iret, GetLastError());
10261 ok(!num_bytes, "Managed to read %ld\n", num_bytes);
10262
10263 SetLastError(0xdeadbeef);
10264 key = 0xdeadbeef;
10265 num_bytes = 0xdeadbeef;
10266 olp = (WSAOVERLAPPED *)0xdeadbeef;
10267
10268 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10269 ok(bret == TRUE, "failed to get completion status %u\n", bret);
10270 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
10271 ok(key == 125, "Key is %Iu\n", key);
10272 ok(!num_bytes, "Number of bytes transferred is %lu\n", num_bytes);
10273 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10274
10275 closesocket(src);
10276 src = INVALID_SOCKET;
10277 closesocket(dest);
10278 dest = INVALID_SOCKET;
10279
10280 /* Test IOCP response on hard shutdown. This was the condition that triggered
10281 * a crash in an actual app (bug 38980). */
10282 tcp_socketpair(&src, &dest);
10283
10284 bufs.len = sizeof(buf);
10285 bufs.buf = buf;
10286 flags = 0;
10287 memset(&ov, 0, sizeof(ov));
10288
10289 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
10290 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10291 set_blocking(dest, FALSE);
10292
10293 close_with_rst(src);
10294
10295 FD_ZERO(&fds_recv);
10296 FD_SET(dest, &fds_recv);
10297 select(dest + 1, &fds_recv, NULL, NULL, NULL);
10298
10299 num_bytes = 0xdeadbeef;
10300 SetLastError(0xdeadbeef);
10301
10302 /* Somehow a hard shutdown doesn't work on my Linux box. It seems SO_LINGER is ignored. */
10303 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10304 todo_wine ok(iret == SOCKET_ERROR, "WSARecv failed - %d\n", iret);
10305 todo_wine ok(GetLastError() == WSAECONNRESET, "Last error was %ld\n", GetLastError());
10306 todo_wine ok(num_bytes == 0xdeadbeef, "Managed to read %ld\n", num_bytes);
10307
10308 SetLastError(0xdeadbeef);
10309 key = 0xdeadbeef;
10310 num_bytes = 0xdeadbeef;
10311 olp = (WSAOVERLAPPED *)0xdeadbeef;
10312
10313 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10314 todo_wine ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
10315 todo_wine ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10316 todo_wine ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10317 todo_wine ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10318 todo_wine ok(!olp, "Overlapped structure is at %p\n", olp);
10319
10320 closesocket(dest);
10321
10322 /* Test reading from a non-connected socket, mostly because the above test is marked todo. */
10323 dest = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10324 ok(dest != INVALID_SOCKET, "socket() failed\n");
10325
10326 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
10327 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10328 set_blocking(dest, FALSE);
10329
10330 num_bytes = 0xdeadbeef;
10331 SetLastError(0xdeadbeef);
10332 memset(&ov, 0, sizeof(ov));
10333
10334 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10335 ok(iret == SOCKET_ERROR, "WSARecv failed - %d\n", iret);
10336 ok(GetLastError() == WSAENOTCONN, "Last error was %ld\n", GetLastError());
10337 ok(num_bytes == 0xdeadbeef, "Managed to read %ld\n", num_bytes);
10338
10339 SetLastError(0xdeadbeef);
10340 key = 0xdeadbeef;
10341 num_bytes = 0xdeadbeef;
10342 olp = (WSAOVERLAPPED *)0xdeadbeef;
10343
10344 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10345 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
10346 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10347 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10348 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10349 ok(!olp, "Overlapped structure is at %p\n", olp);
10350
10351 num_bytes = 0xdeadbeef;
10352 closesocket(dest);
10353
10354 dest = socket(AF_INET, SOCK_STREAM, 0);
10355 ok(dest != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10356
10357 iret = WSAIoctl(dest, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
10358 &pAcceptEx, sizeof(pAcceptEx), &num_bytes, NULL, NULL);
10359 ok(!iret, "failed to get AcceptEx, error %u\n", WSAGetLastError());
10360
10361 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
10362
10363 src = setup_iocp_src(&bindAddress);
10364
10365 SetLastError(0xdeadbeef);
10366
10367 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10368 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10369 &num_bytes, &ov);
10370 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10371 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10372
10373 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10374 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10375
10376 closesocket(src);
10377 src = INVALID_SOCKET;
10378
10379 SetLastError(0xdeadbeef);
10380 key = 0xdeadbeef;
10381 num_bytes = 0xdeadbeef;
10382 olp = (WSAOVERLAPPED *)0xdeadbeef;
10383
10384 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10385 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10386 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10387 ok(key == 125, "Key is %Iu\n", key);
10388 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10389 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10390 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10391
10392 SetLastError(0xdeadbeef);
10393 key = 0xdeadbeef;
10394 num_bytes = 0xdeadbeef;
10395 olp = (WSAOVERLAPPED *)0xdeadbeef;
10396 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10397 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10398 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10399 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10400 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10401 ok(!olp, "Overlapped structure is at %p\n", olp);
10402
10403 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
10404
10405 src = setup_iocp_src(&bindAddress);
10406
10407 SetLastError(0xdeadbeef);
10408
10409 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10410 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10411
10412 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10413 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10414 &num_bytes, &ov);
10415 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10416 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10417
10418 closesocket(src);
10419 src = INVALID_SOCKET;
10420
10421 SetLastError(0xdeadbeef);
10422 key = 0xdeadbeef;
10423 num_bytes = 0xdeadbeef;
10424 olp = (WSAOVERLAPPED *)0xdeadbeef;
10425
10426 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10427 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10428 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10429 ok(key == 125, "Key is %Iu\n", key);
10430 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10431 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10432 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10433
10434 SetLastError(0xdeadbeef);
10435 key = 0xdeadbeef;
10436 num_bytes = 0xdeadbeef;
10437 olp = (WSAOVERLAPPED *)0xdeadbeef;
10438 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10439 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10440 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10441 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10442 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10443 ok(!olp, "Overlapped structure is at %p\n", olp);
10444
10445 /* Test IOCP with duplicated handle */
10446
10447 src = setup_iocp_src(&bindAddress);
10448
10449 SetLastError(0xdeadbeef);
10450
10451 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10452 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10453
10454 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10455 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10456 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10457
10458 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10459 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10460 &num_bytes, &ov);
10461 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10462 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10463
10464 SetLastError(0xdeadbeef);
10465 key = 0xdeadbeef;
10466 num_bytes = 0xdeadbeef;
10467 olp = (WSAOVERLAPPED *)0xdeadbeef;
10468 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10469 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10470 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10471 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10472 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10473 ok(!olp, "Overlapped structure is at %p\n", olp);
10474
10475 closesocket(src);
10476 src = INVALID_SOCKET;
10477 closesocket(dup);
10478 dup = INVALID_SOCKET;
10479
10480 SetLastError(0xdeadbeef);
10481 key = 0xdeadbeef;
10482 num_bytes = 0xdeadbeef;
10483 olp = (WSAOVERLAPPED *)0xdeadbeef;
10484 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10485 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10486 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10487 ok(key == 125, "Key is %Iu\n", key);
10488 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10489 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10490 ok(olp && olp->Internal == (ULONG)STATUS_CANCELLED, "Internal status is %Ix\n", olp ? olp->Internal : 0);
10491
10492 SetLastError(0xdeadbeef);
10493 key = 0xdeadbeef;
10494 num_bytes = 0xdeadbeef;
10495 olp = (WSAOVERLAPPED *)0xdeadbeef;
10496 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10497 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10498 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10499 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10500 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10501 ok(!olp, "Overlapped structure is at %p\n", olp);
10502
10503 /* Test IOCP with duplicated handle (closing duplicated handle) */
10504
10505 src = setup_iocp_src(&bindAddress);
10506
10507 SetLastError(0xdeadbeef);
10508
10509 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10510 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10511
10512 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10513 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10514 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10515
10516 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10517 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10518 &num_bytes, &ov);
10519 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10520 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10521
10522 closesocket(dup);
10523 dup = INVALID_SOCKET;
10524
10525 SetLastError(0xdeadbeef);
10526 key = 0xdeadbeef;
10527 num_bytes = 0xdeadbeef;
10528 olp = (WSAOVERLAPPED *)0xdeadbeef;
10529 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10530 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10531 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10532 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10533 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10534 ok(!olp, "Overlapped structure is at %p\n", olp);
10535
10536 SetLastError(0xdeadbeef);
10537 key = 0xdeadbeef;
10538 num_bytes = 0xdeadbeef;
10539 olp = (WSAOVERLAPPED *)0xdeadbeef;
10540 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10541 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10542 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10543 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10544 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10545 ok(!olp, "Overlapped structure is at %p\n", olp);
10546
10547 closesocket(src);
10548 src = INVALID_SOCKET;
10549
10550 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10551 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10552 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10553 ok(key == 125, "Key is %Iu\n", key);
10554 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10555 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10556 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10557
10558 SetLastError(0xdeadbeef);
10559 key = 0xdeadbeef;
10560 num_bytes = 0xdeadbeef;
10561 olp = (WSAOVERLAPPED *)0xdeadbeef;
10562 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10563 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10564 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10565 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10566 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10567 ok(!olp, "Overlapped structure is at %p\n", olp);
10568
10569 /* Test IOCP with duplicated handle (closing original handle) */
10570
10571 src = setup_iocp_src(&bindAddress);
10572
10573 SetLastError(0xdeadbeef);
10574
10575 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10576 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10577
10578 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10579 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10580 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10581
10582 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10583 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10584 &num_bytes, &ov);
10585 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10586 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10587
10588 closesocket(src);
10589 src = INVALID_SOCKET;
10590
10591 SetLastError(0xdeadbeef);
10592 key = 0xdeadbeef;
10593 num_bytes = 0xdeadbeef;
10594 olp = (WSAOVERLAPPED *)0xdeadbeef;
10595 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10596 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10597 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10598 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10599 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10600 ok(!olp, "Overlapped structure is at %p\n", olp);
10601
10602 closesocket(dup);
10603 dup = INVALID_SOCKET;
10604
10605 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10606 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10607 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %ld\n", GetLastError());
10608 ok(key == 125, "Key is %Iu\n", key);
10609 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10610 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10611 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10612
10613 SetLastError(0xdeadbeef);
10614 key = 0xdeadbeef;
10615 num_bytes = 0xdeadbeef;
10616 olp = (WSAOVERLAPPED *)0xdeadbeef;
10617 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10618 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10619 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10620 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10621 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10622 ok(!olp, "Overlapped structure is at %p\n", olp);
10623
10624 /* Test IOCP without AcceptEx */
10625
10626 src = setup_iocp_src(&bindAddress);
10627
10628 SetLastError(0xdeadbeef);
10629
10630 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10631 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10632
10633 closesocket(src);
10634 src = INVALID_SOCKET;
10635
10636 SetLastError(0xdeadbeef);
10637 key = 0xdeadbeef;
10638 num_bytes = 0xdeadbeef;
10639 olp = (WSAOVERLAPPED *)0xdeadbeef;
10640 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10641 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10642 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10643 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10644 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10645 ok(!olp, "Overlapped structure is at %p\n", olp);
10646
10647 /* */
10648
10649 src = setup_iocp_src(&bindAddress);
10650
10651 connector = socket(AF_INET, SOCK_STREAM, 0);
10652 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10653
10654 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10655 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10656
10657 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 236, 0);
10658 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10659
10660 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10661 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10662 &num_bytes, &ov);
10663 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10664 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10665
10666 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10667 ok(iret == 0, "connecting to accepting socket failed, error %ld\n", GetLastError());
10668
10669 closesocket(connector);
10670 connector = INVALID_SOCKET;
10671
10672 SetLastError(0xdeadbeef);
10673 key = 0xdeadbeef;
10674 num_bytes = 0xdeadbeef;
10675 olp = (WSAOVERLAPPED *)0xdeadbeef;
10676
10677 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10678 ok(bret == TRUE, "failed to get completion status %u\n", bret);
10679 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
10680 ok(key == 125, "Key is %Iu\n", key);
10681 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10682 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10683 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10684
10685 SetLastError(0xdeadbeef);
10686 key = 0xdeadbeef;
10687 num_bytes = 0xdeadbeef;
10688 olp = (WSAOVERLAPPED *)0xdeadbeef;
10689 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10690 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10691 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10692 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10693 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10694 ok(!olp, "Overlapped structure is at %p\n", olp);
10695
10696 if (dest != INVALID_SOCKET)
10697 closesocket(dest);
10698 if (src != INVALID_SOCKET)
10699 closesocket(dest);
10700
10701 /* */
10702
10703 src = setup_iocp_src(&bindAddress);
10704
10705 dest = socket(AF_INET, SOCK_STREAM, 0);
10706 ok(dest != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10707
10708 connector = socket(AF_INET, SOCK_STREAM, 0);
10709 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10710
10711 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10712 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10713
10714 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 236, 0);
10715 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10716
10717 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10718 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10719 &num_bytes, &ov);
10720 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10721 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10722
10723 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10724 ok(iret == 0, "connecting to accepting socket failed, error %ld\n", GetLastError());
10725
10726 iret = send(connector, buf, 1, 0);
10727 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
10728
10729 Sleep(100);
10730
10731 closesocket(dest);
10732 dest = INVALID_SOCKET;
10733
10734 SetLastError(0xdeadbeef);
10735 key = 0xdeadbeef;
10736 num_bytes = 0xdeadbeef;
10737 olp = (WSAOVERLAPPED *)0xdeadbeef;
10738
10739 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10740 ok(bret == TRUE, "failed to get completion status %u\n", bret);
10741 ok(GetLastError() == 0xdeadbeef, "Last error was %ld\n", GetLastError());
10742 ok(key == 125, "Key is %Iu\n", key);
10743 ok(num_bytes == 1, "Number of bytes transferred is %lu\n", num_bytes);
10744 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10745 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %Ix\n", olp ? olp->Internal : 0);
10746
10747 SetLastError(0xdeadbeef);
10748 key = 0xdeadbeef;
10749 num_bytes = 0xdeadbeef;
10750 olp = (WSAOVERLAPPED *)0xdeadbeef;
10751 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10752 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10753 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10754 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10755 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10756 ok(!olp, "Overlapped structure is at %p\n", olp);
10757
10758 if (src != INVALID_SOCKET)
10759 closesocket(src);
10760 if (connector != INVALID_SOCKET)
10761 closesocket(connector);
10762
10763 /* */
10764
10765 src = setup_iocp_src(&bindAddress);
10766
10767 dest = socket(AF_INET, SOCK_STREAM, 0);
10768 ok(dest != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10769
10770 connector = socket(AF_INET, SOCK_STREAM, 0);
10771 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10772
10773 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
10774 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10775
10776 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 236, 0);
10777 ok(io_port != NULL, "failed to create completion port %lu\n", GetLastError());
10778
10779 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10780 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10781 &num_bytes, &ov);
10782 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10783 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %ld\n", GetLastError());
10784
10785 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10786 ok(iret == 0, "connecting to accepting socket failed, error %ld\n", GetLastError());
10787
10788 closesocket(dest);
10789
10790 SetLastError(0xdeadbeef);
10791 key = 0xdeadbeef;
10792 num_bytes = 0xdeadbeef;
10793 olp = (WSAOVERLAPPED *)0xdeadbeef;
10794
10795 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10796 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10797 ok(GetLastError() == ERROR_OPERATION_ABORTED
10798 || GetLastError() == ERROR_CONNECTION_ABORTED, "got error %lu\n", GetLastError());
10799 ok(key == 125, "Key is %Iu\n", key);
10800 ok(num_bytes == 0, "Number of bytes transferred is %lu\n", num_bytes);
10801 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10802 ok((NTSTATUS)olp->Internal == STATUS_CANCELLED
10803 || (NTSTATUS)olp->Internal == STATUS_CONNECTION_ABORTED, "got status %#Ix\n", olp->Internal);
10804
10805 SetLastError(0xdeadbeef);
10806 key = 0xdeadbeef;
10807 num_bytes = 0xdeadbeef;
10808 olp = (WSAOVERLAPPED *)0xdeadbeef;
10809 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10810 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10811 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %ld\n", GetLastError());
10812 ok(key == 0xdeadbeef, "Key is %Iu\n", key);
10813 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %lu\n", num_bytes);
10814 ok(!olp, "Overlapped structure is at %p\n", olp);
10815
10816 closesocket(src);
10817 closesocket(connector);
10818 CloseHandle(io_port);
10819 }
10820
10821 static void test_connect_completion_port(void)
10822 {
10823 OVERLAPPED overlapped = {0}, *overlapped_ptr;
10824 GUID connectex_guid = WSAID_CONNECTEX;
10825 SOCKET connector, listener, acceptor;
10826 struct sockaddr_in addr, destaddr;
10827 LPFN_CONNECTEX pConnectEx;
10828 int ret, addrlen;
10829 ULONG_PTR key;
10830 HANDLE port;
10831 DWORD size;
10832
10833 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
10834
10835 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10836 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
10837
10838 memset(&addr, 0, sizeof(addr));
10839 addr.sin_family = AF_INET;
10840 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
10841 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
10842 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
10843 addrlen = sizeof(destaddr);
10844 ret = getsockname(listener, (struct sockaddr *)&destaddr, &addrlen);
10845 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
10846
10847 ret = listen(listener, 1);
10848 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
10849
10850 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10851 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
10852
10853 ret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectex_guid, sizeof(connectex_guid),
10854 &pConnectEx, sizeof(pConnectEx), &size, NULL, NULL);
10855 ok(!ret, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
10856
10857 /* connect() does not queue completion. */
10858
10859 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
10860 ok(!!port, "failed to create port, error %lu\n", GetLastError());
10861
10862 ret = connect(connector, (struct sockaddr *)&destaddr, sizeof(destaddr));
10863 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
10864 acceptor = accept(listener, NULL, NULL);
10865 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
10866 closesocket(acceptor);
10867
10868 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
10869 ok(!ret, "expected failure\n");
10870 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
10871
10872 closesocket(connector);
10873 CloseHandle(port);
10874
10875 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10876 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
10877 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
10878 ok(!!port, "failed to create port, error %lu\n", GetLastError());
10879 set_blocking(connector, FALSE);
10880
10881 ret = connect(connector, (struct sockaddr *)&destaddr, sizeof(destaddr));
10882 ok(ret == -1, "expected failure\n");
10883 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
10884 acceptor = accept(listener, NULL, NULL);
10885 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
10886 closesocket(acceptor);
10887
10888 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
10889 ok(!ret, "expected failure\n");
10890 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
10891
10892 closesocket(connector);
10893 CloseHandle(port);
10894
10895 /* ConnectEx() queues completion. */
10896
10897 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10898 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
10899 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
10900 ok(!!port, "failed to create port, error %lu\n", GetLastError());
10901 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
10902 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
10903
10904 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
10905 NULL, 0, &size, &overlapped);
10906 ok(!ret, "expected failure\n");
10907 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
10908 ret = WaitForSingleObject(overlapped.hEvent, 1000);
10909 ok(!ret, "wait failed\n");
10910 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
10911 ok(ret, "got error %lu\n", GetLastError());
10912 ok(!size, "got %lu bytes\n", size);
10913 acceptor = accept(listener, NULL, NULL);
10914 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
10915 closesocket(acceptor);
10916
10917 size = 0xdeadbeef;
10918 key = 0xdeadbeef;
10919 overlapped_ptr = NULL;
10920 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
10921 ok(ret, "got error %lu\n", GetLastError());
10922 ok(!key, "got key %#Ix\n", key);
10923 ok(!size, "got %lu bytes\n", size);
10924 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
10925
10926 closesocket(connector);
10927 CloseHandle(port);
10928
10929 /* Test ConnectEx() with a non-empty buffer. */
10930
10931 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10932 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
10933 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
10934 ok(!!port, "failed to create port, error %lu\n", GetLastError());
10935 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
10936 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
10937
10938 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
10939 (void *)"one", 3, &size, &overlapped);
10940 ok(!ret, "expected failure\n");
10941 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
10942 ret = WaitForSingleObject(overlapped.hEvent, 1000);
10943 ok(!ret, "wait failed\n");
10944 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
10945 ok(ret, "got error %lu\n", GetLastError());
10946 ok(size == 3, "got %lu bytes\n", size);
10947 acceptor = accept(listener, NULL, NULL);
10948 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
10949 closesocket(acceptor);
10950
10951 size = 0xdeadbeef;
10952 key = 0xdeadbeef;
10953 overlapped_ptr = NULL;
10954 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
10955 ok(ret, "got error %lu\n", GetLastError());
10956 ok(!key, "got key %#Ix\n", key);
10957 ok(size == 3, "got %lu bytes\n", size);
10958 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
10959
10960 closesocket(connector);
10961 CloseHandle(port);
10962
10963 /* Suppress completion by setting the low bit. */
10964
10965 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10966 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
10967 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
10968 ok(!!port, "failed to create port, error %lu\n", GetLastError());
10969 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
10970 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
10971
10972 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent | 1);
10973
10974 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
10975 NULL, 0, &size, &overlapped);
10976 ok(!ret, "expected failure\n");
10977 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
10978 ret = WaitForSingleObject(overlapped.hEvent, 1000);
10979 ok(!ret, "wait failed\n");
10980 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
10981 ok(ret, "got error %lu\n", GetLastError());
10982 ok(!size, "got %lu bytes\n", size);
10983 acceptor = accept(listener, NULL, NULL);
10984 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
10985 closesocket(acceptor);
10986
10987 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
10988 ok(!ret, "expected failure\n");
10989 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
10990
10991 closesocket(connector);
10992 CloseHandle(port);
10993
10994 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent & ~1);
10995
10996 /* Skip completion on success. */
10997
10998 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10999 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11000 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11001 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11002 ret = SetFileCompletionNotificationModes((HANDLE)connector, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS);
11003 ok(ret, "got error %lu\n", GetLastError());
11004 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
11005 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11006
11007 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
11008 NULL, 0, &size, &overlapped);
11009 ok(!ret, "expected failure\n");
11010 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11011 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11012 ok(!ret, "wait failed\n");
11013 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
11014 ok(ret, "got error %lu\n", GetLastError());
11015 ok(!size, "got %lu bytes\n", size);
11016 acceptor = accept(listener, NULL, NULL);
11017 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
11018 closesocket(acceptor);
11019
11020 size = 0xdeadbeef;
11021 key = 0xdeadbeef;
11022 overlapped_ptr = NULL;
11023 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11024 ok(ret, "got error %lu\n", GetLastError());
11025 ok(!key, "got key %#Ix\n", key);
11026 ok(!size, "got %lu bytes\n", size);
11027 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11028
11029 closesocket(connector);
11030 CloseHandle(port);
11031
11032 closesocket(listener);
11033
11034 /* Connect to an invalid address. */
11035
11036 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11037 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
11038 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
11039 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11040 ret = SetFileCompletionNotificationModes((HANDLE)connector, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS);
11041 ok(ret, "got error %lu\n", GetLastError());
11042 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
11043 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11044
11045 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
11046 NULL, 0, &size, &overlapped);
11047 ok(!ret, "expected failure\n");
11048 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11049 ret = WaitForSingleObject(overlapped.hEvent, 15000);
11050 ok(!ret, "wait failed\n");
11051 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
11052 ok(!ret, "expected failure\n");
11053 ok(GetLastError() == ERROR_CONNECTION_REFUSED, "got error %lu\n", GetLastError());
11054 ok(!size, "got %lu bytes\n", size);
11055
11056 size = 0xdeadbeef;
11057 key = 0xdeadbeef;
11058 overlapped_ptr = NULL;
11059 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11060 ok(!ret, "expected failure\n");
11061 ok(GetLastError() == ERROR_CONNECTION_REFUSED, "got error %lu\n", GetLastError());
11062 ok(!key, "got key %#Ix\n", key);
11063 ok(!size, "got %lu bytes\n", size);
11064 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11065
11066 closesocket(connector);
11067 CloseHandle(port);
11068 }
11069
11070 static void test_shutdown_completion_port(void)
11071 {
11072 OVERLAPPED overlapped = {0}, *overlapped_ptr;
11073 GUID disconnectex_guid = WSAID_DISCONNECTEX;
11074 struct sockaddr_in addr, destaddr;
11075 LPFN_DISCONNECTEX pDisconnectEx;
11076 SOCKET listener, server, client;
11077 int ret, addrlen;
11078 ULONG_PTR key;
11079 HANDLE port;
11080 DWORD size;
11081
11082 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
11083
11084 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11085 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
11086
11087 memset(&addr, 0, sizeof(addr));
11088 addr.sin_family = AF_INET;
11089 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
11090 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
11091 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
11092 addrlen = sizeof(destaddr);
11093 ret = getsockname(listener, (struct sockaddr *)&destaddr, &addrlen);
11094 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
11095
11096 ret = listen(listener, 1);
11097 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
11098
11099 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11100 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11101
11102 ret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &disconnectex_guid, sizeof(disconnectex_guid),
11103 &pDisconnectEx, sizeof(pDisconnectEx), &size, NULL, NULL);
11104 ok(!ret, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
11105
11106 /* shutdown() does not queue completion. */
11107
11108 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11109 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11110 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11111 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11112 server = accept(listener, NULL, NULL);
11113 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11114
11115 ret = shutdown(client, SD_BOTH);
11116 ok(!ret, "failed to shutdown, error %u\n", WSAGetLastError());
11117
11118 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11119 ok(!ret, "expected failure\n");
11120 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11121
11122 closesocket(server);
11123 closesocket(client);
11124 CloseHandle(port);
11125
11126 /* WSASendDisconnect() and WSARecvDisconnect() do not queue completion. */
11127
11128 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11129 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11130 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11131 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11132 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11133 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11134 server = accept(listener, NULL, NULL);
11135 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11136
11137 ret = WSASendDisconnect(client, NULL);
11138 ok(!ret, "failed to shutdown, error %u\n", WSAGetLastError());
11139
11140 ret = WSARecvDisconnect(client, NULL);
11141 ok(!ret, "failed to shutdown, error %u\n", WSAGetLastError());
11142
11143 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11144 ok(!ret, "expected failure\n");
11145 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11146
11147 closesocket(server);
11148 closesocket(client);
11149 CloseHandle(port);
11150
11151 /* DisconnectEx() queues completion. */
11152
11153 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11154 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11155 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11156 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11157 ret = SetFileCompletionNotificationModes((HANDLE)client, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS);
11158 ok(ret, "got error %lu\n", GetLastError());
11159 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11160 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11161 server = accept(listener, NULL, NULL);
11162 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11163
11164 SetLastError(0xdeadbeef);
11165 ret = pDisconnectEx(client, &overlapped, 0, 0);
11166 ok(!ret, "expected failure\n");
11167 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11168
11169 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11170 ok(!ret, "wait failed\n");
11171
11172 size = 0xdeadbeef;
11173 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, TRUE);
11174 ok(ret, "got error %lu\n", GetLastError());
11175 ok(!size, "got %lu bytes\n", size);
11176
11177 size = 0xdeadbeef;
11178 key = 0xdeadbeef;
11179 overlapped_ptr = NULL;
11180 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11181 todo_wine ok(ret, "got error %lu\n", GetLastError());
11182 todo_wine ok(!key, "got key %#Ix\n", key);
11183 todo_wine ok(!size, "got %lu bytes\n", size);
11184 todo_wine ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
11185
11186 closesocket(server);
11187 closesocket(client);
11188 CloseHandle(port);
11189
11190 /* Test passing a NULL overlapped structure to DisconnectEx(). */
11191
11192 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11193 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11194 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11195 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11196 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11197 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11198 server = accept(listener, NULL, NULL);
11199 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11200
11201 SetLastError(0xdeadbeef);
11202 ret = pDisconnectEx(client, NULL, 0, 0);
11203 ok(ret, "expected success\n");
11204 ok(!GetLastError() || GetLastError() == 0xdeadbeef /* < 7 */, "got error %lu\n", GetLastError());
11205
11206 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11207 ok(!ret, "expected failure\n");
11208 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11209
11210 closesocket(server);
11211 closesocket(client);
11212 CloseHandle(port);
11213
11214 /* Suppress completion by setting the low bit. */
11215
11216 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11217 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
11218 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
11219 ok(!!port, "failed to create port, error %lu\n", GetLastError());
11220 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
11221 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
11222 server = accept(listener, NULL, NULL);
11223 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
11224
11225 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent | 1);
11226
11227 SetLastError(0xdeadbeef);
11228 ret = pDisconnectEx(client, &overlapped, 0, 0);
11229 ok(!ret, "expected failure\n");
11230 ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
11231
11232 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11233 ok(!ret, "wait failed\n");
11234
11235 size = 0xdeadbeef;
11236 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, TRUE);
11237 ok(ret, "got error %lu\n", GetLastError());
11238 ok(!size, "got %lu bytes\n", size);
11239
11240 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11241 ok(!ret, "expected failure\n");
11242 ok(GetLastError() == WAIT_TIMEOUT, "got error %lu\n", GetLastError());
11243
11244 closesocket(server);
11245 closesocket(client);
11246 CloseHandle(port);
11247
11248 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent & ~1);
11249
11250 CloseHandle(overlapped.hEvent);
11251 }
11252
11253 static void test_address_list_query(void)
11254 {
11255 char buffer[1024];
11256 SOCKET_ADDRESS_LIST *address_list = (SOCKET_ADDRESS_LIST *)buffer;
11257 OVERLAPPED overlapped = {0}, *overlapped_ptr;
11258 DWORD size, expect_size;
11259 unsigned int i;
11260 ULONG_PTR key;
11261 HANDLE port;
11262 SOCKET s;
11263 int ret;
11264
11265 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11266 ok(s != INVALID_SOCKET, "Failed to create socket, error %d.\n", WSAGetLastError());
11267 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
11268
11269 size = 0;
11270 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, 0, &size, NULL, NULL);
11271 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11272 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11273 ok(size >= FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), "Got unexpected size %lu.\n", size);
11274 expect_size = size;
11275
11276 size = 0;
11277 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), &size, NULL, NULL);
11278 ok(!ret, "Got unexpected ret %d.\n", ret);
11279 ok(!WSAGetLastError(), "Got unexpected error %d.\n", WSAGetLastError());
11280 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11281
11282 expect_size = FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[address_list->iAddressCount]);
11283 for (i = 0; i < address_list->iAddressCount; ++i)
11284 {
11285 expect_size += address_list->Address[i].iSockaddrLength;
11286 }
11287 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11288
11289 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), NULL, NULL, NULL);
11290 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11291 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11292
11293 size = 0xdeadbeef;
11294 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, sizeof(buffer), &size, NULL, NULL);
11295 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11296 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11297 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11298
11299 size = 0xdeadbeef;
11300 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 0, &size, NULL, NULL);
11301 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11302 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11303 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11304
11305 size = 0xdeadbeef;
11306 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 1, &size, NULL, NULL);
11307 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11308 ok(WSAGetLastError() == WSAEINVAL, "Got unexpected error %d.\n", WSAGetLastError());
11309 ok(!size, "Got size %lu.\n", size);
11310
11311 size = 0xdeadbeef;
11312 memset(buffer, 0xcc, sizeof(buffer));
11313 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer,
11314 FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), &size, NULL, NULL);
11315 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
11316 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11317 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11318 ok(address_list->iAddressCount == 0xcccccccc, "Got %u addresses.\n", address_list->iAddressCount);
11319
11320 WSASetLastError(0xdeadbeef);
11321 overlapped.Internal = 0xdeadbeef;
11322 overlapped.InternalHigh = 0xdeadbeef;
11323 size = 0xdeadbeef;
11324 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 0, &size, &overlapped, NULL);
11325 ok(ret == -1, "Got unexpected ret %d.\n", ret);
11326 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11327 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11328 ok(overlapped.Internal == 0xdeadbeef, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
11329 ok(overlapped.InternalHigh == 0xdeadbeef, "Got size %Iu.\n", overlapped.InternalHigh);
11330
11331 overlapped.Internal = 0xdeadbeef;
11332 overlapped.InternalHigh = 0xdeadbeef;
11333 size = 0xdeadbeef;
11334 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 1, &size, &overlapped, NULL);
11335 ok(ret == -1, "Got unexpected ret %d.\n", ret);
11336 ok(WSAGetLastError() == WSAEINVAL, "Got unexpected error %d.\n", WSAGetLastError());
11337 ok(!size, "Expected size %lu, got %lu.\n", expect_size, size);
11338 ok(overlapped.Internal == 0xdeadbeef, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
11339 ok(overlapped.InternalHigh == 0xdeadbeef, "Got size %Iu.\n", overlapped.InternalHigh);
11340
11341 overlapped.Internal = 0xdeadbeef;
11342 overlapped.InternalHigh = 0xdeadbeef;
11343 size = 0xdeadbeef;
11344 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer,
11345 FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), &size, &overlapped, NULL);
11346 ok(ret == -1, "Got unexpected ret %d.\n", ret);
11347 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
11348 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11349 ok(overlapped.Internal == 0xdeadbeef, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
11350 ok(overlapped.InternalHigh == 0xdeadbeef, "Got size %Iu.\n", overlapped.InternalHigh);
11351 ok(address_list->iAddressCount == 0xcccccccc, "Got %u addresses.\n", address_list->iAddressCount);
11352
11353 overlapped.Internal = 0xdeadbeef;
11354 overlapped.InternalHigh = 0xdeadbeef;
11355 size = 0xdeadbeef;
11356 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), &size, &overlapped, NULL);
11357 ok(!ret, "Got unexpected ret %d.\n", ret);
11358 ok(!WSAGetLastError(), "Got unexpected error %d.\n", WSAGetLastError());
11359 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
11360
11361 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11362 ok(ret, "Got error %lu.\n", GetLastError());
11363 ok(!size, "Got size %lu.\n", size);
11364 ok(overlapped_ptr == &overlapped, "Got overlapped %p.\n", overlapped_ptr);
11365 ok(!overlapped.Internal, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
11366 ok(!overlapped.InternalHigh, "Got size %Iu.\n", overlapped.InternalHigh);
11367
11368 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
11369 ok(!ret, "Expected failure.\n");
11370 ok(GetLastError() == WAIT_TIMEOUT, "Got error %lu.\n", GetLastError());
11371
11372 closesocket(s);
11373 CloseHandle(port);
11374
11375 /* Test with an APC. */
11376
11377 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11378
11379 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), NULL, &overlapped, socket_apc);
11380 ok(ret == -1, "expected failure\n");
11381 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
11382
11383 apc_count = 0;
11384 size = 0xdeadbeef;
11385 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), &size, &overlapped, socket_apc);
11386 ok(!ret, "expected success\n");
11387 ok(size == expect_size, "got size %lu\n", size);
11388
11389 ret = SleepEx(0, TRUE);
11390 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
11391 ok(apc_count == 1, "APC was called %u times\n", apc_count);
11392 ok(!apc_error, "got APC error %lu\n", apc_error);
11393 ok(!apc_size, "got APC size %lu\n", apc_size);
11394 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
11395
11396 closesocket(s);
11397 }
11398
11399 static void sync_read(SOCKET src, SOCKET dst)
11400 {
11401 int ret;
11402 char data[512];
11403
11404 ret = send(dst, "Hello World!", 12, 0);
11405 ok(ret == 12, "send returned %d\n", ret);
11406
11407 memset(data, 0, sizeof(data));
11408 ret = recv(src, data, sizeof(data), 0);
11409 ok(ret == 12, "expected 12, got %d\n", ret);
11410 ok(!memcmp(data, "Hello World!", 12), "got %u bytes (%*s)\n", ret, ret, data);
11411 }
11412
11413 static void iocp_async_read(SOCKET src, SOCKET dst)
11414 {
11415 HANDLE port;
11416 WSAOVERLAPPED ovl, *ovl_iocp;
11417 WSABUF buf;
11418 int ret;
11419 char data[512];
11420 DWORD flags, bytes;
11421 ULONG_PTR key;
11422
11423 memset(data, 0, sizeof(data));
11424 memset(&ovl, 0, sizeof(ovl));
11425
11426 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11427 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
11428
11429 buf.len = sizeof(data);
11430 buf.buf = data;
11431 bytes = 0xdeadbeef;
11432 flags = 0;
11433 SetLastError(0xdeadbeef);
11434 ret = WSARecv(src, &buf, 1, &bytes, &flags, &ovl, NULL);
11435 ok(ret == SOCKET_ERROR, "got %d\n", ret);
11436 ok(GetLastError() == ERROR_IO_PENDING, "got %lu\n", GetLastError());
11437 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11438
11439 bytes = 0xdeadbeef;
11440 key = 0xdeadbeef;
11441 ovl_iocp = (void *)0xdeadbeef;
11442 SetLastError(0xdeadbeef);
11443 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11444 ok(!ret, "got %d\n", ret);
11445 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11446 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11447 ok(key == 0xdeadbeef, "got key %#Ix\n", key);
11448 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11449
11450 ret = send(dst, "Hello World!", 12, 0);
11451 ok(ret == 12, "send returned %d\n", ret);
11452
11453 bytes = 0xdeadbeef;
11454 key = 0xdeadbeef;
11455 ovl_iocp = NULL;
11456 SetLastError(0xdeadbeef);
11457 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11458 ok(ret, "got %d\n", ret);
11459 ok(bytes == 12, "got bytes %lu\n", bytes);
11460 ok(key == 0x12345678, "got key %#Ix\n", key);
11461 ok(ovl_iocp == &ovl, "got ovl %p\n", ovl_iocp);
11462 if (ovl_iocp)
11463 {
11464 ok(ovl_iocp->InternalHigh == 12, "got %#Ix\n", ovl_iocp->InternalHigh);
11465 ok(!ovl_iocp->Internal , "got %#Ix\n", ovl_iocp->Internal);
11466 ok(!memcmp(data, "Hello World!", 12), "got %lu bytes (%*s)\n", bytes, (int)bytes, data);
11467 }
11468
11469 bytes = 0xdeadbeef;
11470 key = 0xdeadbeef;
11471 ovl_iocp = (void *)0xdeadbeef;
11472 SetLastError(0xdeadbeef);
11473 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11474 ok(!ret, "got %d\n", ret);
11475 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11476 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11477 ok(key == 0xdeadbeef, "got key %#Ix\n", key);
11478 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11479
11480 CloseHandle(port);
11481 }
11482
11483 static void iocp_async_read_closesocket(SOCKET src, int how_to_close)
11484 {
11485 HANDLE port;
11486 WSAOVERLAPPED ovl, *ovl_iocp;
11487 WSABUF buf;
11488 int ret;
11489 char data[512];
11490 DWORD flags, bytes;
11491 ULONG_PTR key;
11492 HWND hwnd;
11493 MSG msg;
11494
11495 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
11496 0, 0, 0, 0, NULL, NULL, 0, NULL);
11497 ok(hwnd != 0, "CreateWindowEx failed\n");
11498
11499 ret = WSAAsyncSelect(src, hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
11500 ok(!ret, "got %d\n", ret);
11501
11502 Sleep(100);
11503 memset(&msg, 0, sizeof(msg));
11504 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11505 ok(ret, "got %d\n", ret);
11506 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11507 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11508 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
11509 ok(msg.lParam == 2, "got %08Ix\n", msg.lParam);
11510
11511 memset(data, 0, sizeof(data));
11512 memset(&ovl, 0, sizeof(ovl));
11513
11514 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11515 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
11516
11517 Sleep(100);
11518 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11519 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11520
11521 buf.len = sizeof(data);
11522 buf.buf = data;
11523 bytes = 0xdeadbeef;
11524 flags = 0;
11525 SetLastError(0xdeadbeef);
11526 ret = WSARecv(src, &buf, 1, &bytes, &flags, &ovl, NULL);
11527 ok(ret == SOCKET_ERROR, "got %d\n", ret);
11528 ok(GetLastError() == ERROR_IO_PENDING, "got %lu\n", GetLastError());
11529 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11530
11531 Sleep(100);
11532 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11533 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11534
11535 bytes = 0xdeadbeef;
11536 key = 0xdeadbeef;
11537 ovl_iocp = (void *)0xdeadbeef;
11538 SetLastError(0xdeadbeef);
11539 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11540 ok(!ret, "got %d\n", ret);
11541 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11542 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11543 ok(key == 0xdeadbeef, "got key %#Ix\n", key);
11544 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11545
11546 Sleep(100);
11547 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11548 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11549
11550 switch (how_to_close)
11551 {
11552 case 0:
11553 closesocket(src);
11554 break;
11555 case 1:
11556 CloseHandle((HANDLE)src);
11557 break;
11558 case 2:
11559 pNtClose((HANDLE)src);
11560 break;
11561 default:
11562 ok(0, "wrong value %d\n", how_to_close);
11563 break;
11564 }
11565
11566 Sleep(200);
11567 memset(&msg, 0, sizeof(msg));
11568 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11569 switch (how_to_close)
11570 {
11571 case 0:
11572 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11573 break;
11574 case 1:
11575 case 2:
11576 todo_wine
11577 {
11578 ok(ret, "got %d\n", ret);
11579 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11580 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11581 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
11582 ok(msg.lParam == 0x20, "got %08Ix\n", msg.lParam);
11583 }
11584 break;
11585 default:
11586 ok(0, "wrong value %d\n", how_to_close);
11587 break;
11588 }
11589
11590 bytes = 0xdeadbeef;
11591 key = 0xdeadbeef;
11592 ovl_iocp = NULL;
11593 SetLastError(0xdeadbeef);
11594 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11595 ok(!ret, "got %d\n", ret);
11596 todo_wine
11597 ok(GetLastError() == ERROR_CONNECTION_ABORTED || GetLastError() == ERROR_NETNAME_DELETED /* XP */, "got %lu\n", GetLastError());
11598 ok(!bytes, "got bytes %lu\n", bytes);
11599 ok(key == 0x12345678, "got key %#Ix\n", key);
11600 ok(ovl_iocp == &ovl, "got ovl %p\n", ovl_iocp);
11601 if (ovl_iocp)
11602 {
11603 ok(!ovl_iocp->InternalHigh, "got %#Ix\n", ovl_iocp->InternalHigh);
11604 todo_wine
11605 ok(ovl_iocp->Internal == (ULONG)STATUS_CONNECTION_ABORTED || ovl_iocp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT /* XP */, "got %#Ix\n", ovl_iocp->Internal);
11606 }
11607
11608 bytes = 0xdeadbeef;
11609 key = 0xdeadbeef;
11610 ovl_iocp = (void *)0xdeadbeef;
11611 SetLastError(0xdeadbeef);
11612 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11613 ok(!ret, "got %d\n", ret);
11614 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11615 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11616 ok(key == 0xdeadbeef, "got key %#Ix\n", key);
11617 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11618
11619 CloseHandle(port);
11620
11621 DestroyWindow(hwnd);
11622 }
11623
11624 static void iocp_async_closesocket(SOCKET src)
11625 {
11626 HANDLE port;
11627 WSAOVERLAPPED *ovl_iocp;
11628 int ret;
11629 DWORD bytes;
11630 ULONG_PTR key;
11631 HWND hwnd;
11632 MSG msg;
11633
11634 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
11635 0, 0, 0, 0, NULL, NULL, 0, NULL);
11636 ok(hwnd != 0, "CreateWindowEx failed\n");
11637
11638 ret = WSAAsyncSelect(src, hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
11639 ok(!ret, "got %d\n", ret);
11640
11641 Sleep(100);
11642 memset(&msg, 0, sizeof(msg));
11643 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11644 ok(ret, "got %d\n", ret);
11645 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11646 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11647 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
11648 ok(msg.lParam == 2, "got %08Ix\n", msg.lParam);
11649
11650 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11651 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
11652
11653 Sleep(100);
11654 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11655 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11656
11657 bytes = 0xdeadbeef;
11658 key = 0xdeadbeef;
11659 ovl_iocp = (void *)0xdeadbeef;
11660 SetLastError(0xdeadbeef);
11661 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11662 ok(!ret, "got %d\n", ret);
11663 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11664 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11665 ok(key == 0xdeadbeef, "got key %Iu\n", key);
11666 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11667
11668 Sleep(100);
11669 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11670 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11671
11672 closesocket(src);
11673
11674 Sleep(100);
11675 memset(&msg, 0, sizeof(msg));
11676 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11677 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11678
11679 bytes = 0xdeadbeef;
11680 key = 0xdeadbeef;
11681 ovl_iocp = (void *)0xdeadbeef;
11682 SetLastError(0xdeadbeef);
11683 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11684 ok(!ret, "got %d\n", ret);
11685 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11686 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11687 ok(key == 0xdeadbeef, "got key %Iu\n", key);
11688 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11689
11690 CloseHandle(port);
11691
11692 DestroyWindow(hwnd);
11693 }
11694
11695 struct wsa_async_select_info
11696 {
11697 SOCKET sock;
11698 HWND hwnd;
11699 };
11700
11701 static DWORD WINAPI wsa_async_select_thread(void *param)
11702 {
11703 struct wsa_async_select_info *info = param;
11704 int ret;
11705
11706 ret = WSAAsyncSelect(info->sock, info->hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
11707 ok(!ret, "got %d\n", ret);
11708
11709 return 0;
11710 }
11711
11712 struct wsa_recv_info
11713 {
11714 SOCKET sock;
11715 WSABUF wsa_buf;
11716 WSAOVERLAPPED ovl;
11717 };
11718
11719 static DWORD WINAPI wsa_recv_thread(void *param)
11720 {
11721 struct wsa_recv_info *info = param;
11722 int ret;
11723 DWORD flags, bytes;
11724
11725 bytes = 0xdeadbeef;
11726 flags = 0;
11727 SetLastError(0xdeadbeef);
11728 ret = WSARecv(info->sock, &info->wsa_buf, 1, &bytes, &flags, &info->ovl, NULL);
11729 ok(ret == SOCKET_ERROR, "got %d\n", ret);
11730 ok(GetLastError() == ERROR_IO_PENDING, "got %lu\n", GetLastError());
11731 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11732
11733 return 0;
11734 }
11735
11736 static void iocp_async_read_thread_closesocket(SOCKET src)
11737 {
11738 struct wsa_async_select_info select_info;
11739 struct wsa_recv_info recv_info;
11740 HANDLE port, thread;
11741 WSAOVERLAPPED *ovl_iocp;
11742 int ret;
11743 char data[512];
11744 DWORD bytes, tid;
11745 ULONG_PTR key;
11746 HWND hwnd;
11747 MSG msg;
11748
11749 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
11750 0, 0, 0, 0, NULL, NULL, 0, NULL);
11751 ok(hwnd != 0, "CreateWindowEx failed\n");
11752
11753 select_info.sock = src;
11754 select_info.hwnd = hwnd;
11755 thread = CreateThread(NULL, 0, wsa_async_select_thread, &select_info, 0, &tid);
11756 ok(thread != 0, "CreateThread error %lu\n", GetLastError());
11757 ret = WaitForSingleObject(thread, 10000);
11758 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
11759
11760 Sleep(100);
11761 memset(&msg, 0, sizeof(msg));
11762 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11763 ok(ret, "got %d\n", ret);
11764 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11765 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11766 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
11767 ok(msg.lParam == 2, "got %08Ix\n", msg.lParam);
11768
11769 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11770 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
11771
11772 Sleep(100);
11773 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11774 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11775
11776 memset(data, 0, sizeof(data));
11777 memset(&recv_info.ovl, 0, sizeof(recv_info.ovl));
11778 recv_info.sock = src;
11779 recv_info.wsa_buf.len = sizeof(data);
11780 recv_info.wsa_buf.buf = data;
11781 thread = CreateThread(NULL, 0, wsa_recv_thread, &recv_info, 0, &tid);
11782 ok(thread != 0, "CreateThread error %lu\n", GetLastError());
11783 ret = WaitForSingleObject(thread, 10000);
11784 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
11785
11786 Sleep(100);
11787 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11788 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11789
11790 bytes = 0xdeadbeef;
11791 key = 0xdeadbeef;
11792 ovl_iocp = (void *)0xdeadbeef;
11793 SetLastError(0xdeadbeef);
11794 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11795 ok(!ret, "got %d\n", ret);
11796 ok(GetLastError() == WAIT_TIMEOUT || broken(GetLastError() == ERROR_OPERATION_ABORTED) /* XP */,
11797 "got %lu\n", GetLastError());
11798 if (GetLastError() == WAIT_TIMEOUT)
11799 {
11800 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11801 ok(key == 0xdeadbeef, "got key %Ix\n", key);
11802 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11803 }
11804 else /* document XP behaviour */
11805 {
11806 ok(!bytes, "got bytes %lu\n", bytes);
11807 ok(key == 0x12345678, "got key %#Ix\n", key);
11808 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
11809 if (ovl_iocp)
11810 {
11811 ok(!ovl_iocp->InternalHigh, "got %#Ix\n", ovl_iocp->InternalHigh);
11812 ok(ovl_iocp->Internal == STATUS_CANCELLED, "got %#Ix\n", ovl_iocp->Internal);
11813 }
11814
11815 closesocket(src);
11816 goto xp_is_broken;
11817 }
11818
11819 Sleep(100);
11820 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11821 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11822
11823 closesocket(src);
11824
11825 Sleep(100);
11826 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11827 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11828
11829 bytes = 0xdeadbeef;
11830 key = 0xdeadbeef;
11831 ovl_iocp = NULL;
11832 SetLastError(0xdeadbeef);
11833 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11834 ok(!ret, "got %d\n", ret);
11835 todo_wine
11836 ok(GetLastError() == ERROR_CONNECTION_ABORTED || GetLastError() == ERROR_NETNAME_DELETED /* XP */, "got %lu\n", GetLastError());
11837 ok(!bytes, "got bytes %lu\n", bytes);
11838 ok(key == 0x12345678, "got key %#Ix\n", key);
11839 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
11840 if (ovl_iocp)
11841 {
11842 ok(!ovl_iocp->InternalHigh, "got %#Ix\n", ovl_iocp->InternalHigh);
11843 todo_wine
11844 ok(ovl_iocp->Internal == (ULONG)STATUS_CONNECTION_ABORTED || ovl_iocp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT /* XP */, "got %#Ix\n", ovl_iocp->Internal);
11845 }
11846
11847 xp_is_broken:
11848 bytes = 0xdeadbeef;
11849 key = 0xdeadbeef;
11850 ovl_iocp = (void *)0xdeadbeef;
11851 SetLastError(0xdeadbeef);
11852 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11853 ok(!ret, "got %d\n", ret);
11854 ok(GetLastError() == WAIT_TIMEOUT, "got %lu\n", GetLastError());
11855 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11856 ok(key == 0xdeadbeef, "got key %Iu\n", key);
11857 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11858
11859 CloseHandle(port);
11860
11861 DestroyWindow(hwnd);
11862 }
11863
11864 static void iocp_async_read_thread(SOCKET src, SOCKET dst)
11865 {
11866 struct wsa_async_select_info select_info;
11867 struct wsa_recv_info recv_info;
11868 HANDLE port, thread;
11869 WSAOVERLAPPED *ovl_iocp;
11870 int ret;
11871 char data[512];
11872 DWORD bytes, tid;
11873 ULONG_PTR key;
11874 HWND hwnd;
11875 MSG msg;
11876
11877 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
11878 0, 0, 0, 0, NULL, NULL, 0, NULL);
11879 ok(hwnd != 0, "CreateWindowEx failed\n");
11880
11881 select_info.sock = src;
11882 select_info.hwnd = hwnd;
11883 thread = CreateThread(NULL, 0, wsa_async_select_thread, &select_info, 0, &tid);
11884 ok(thread != 0, "CreateThread error %lu\n", GetLastError());
11885 ret = WaitForSingleObject(thread, 10000);
11886 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
11887
11888 Sleep(100);
11889 memset(&msg, 0, sizeof(msg));
11890 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11891 ok(ret, "got %d\n", ret);
11892 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11893 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11894 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
11895 ok(msg.lParam == 2, "got %08Ix\n", msg.lParam);
11896
11897 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11898 ok(port != 0, "CreateIoCompletionPort error %lu\n", GetLastError());
11899
11900 Sleep(100);
11901 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11902 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11903
11904 memset(data, 0, sizeof(data));
11905 memset(&recv_info.ovl, 0, sizeof(recv_info.ovl));
11906 recv_info.sock = src;
11907 recv_info.wsa_buf.len = sizeof(data);
11908 recv_info.wsa_buf.buf = data;
11909 thread = CreateThread(NULL, 0, wsa_recv_thread, &recv_info, 0, &tid);
11910 ok(thread != 0, "CreateThread error %lu\n", GetLastError());
11911 ret = WaitForSingleObject(thread, 10000);
11912 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
11913
11914 Sleep(100);
11915 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11916 ok(!ret, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11917
11918 bytes = 0xdeadbeef;
11919 key = 0xdeadbeef;
11920 ovl_iocp = (void *)0xdeadbeef;
11921 SetLastError(0xdeadbeef);
11922 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11923 ok(!ret, "got %d\n", ret);
11924 ok(GetLastError() == WAIT_TIMEOUT || broken(GetLastError() == ERROR_OPERATION_ABORTED) /* XP */, "got %lu\n", GetLastError());
11925 if (GetLastError() == WAIT_TIMEOUT)
11926 {
11927 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11928 ok(key == 0xdeadbeef, "got key %Iu\n", key);
11929 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11930 }
11931 else /* document XP behaviour */
11932 {
11933 ok(bytes == 0, "got bytes %lu\n", bytes);
11934 ok(key == 0x12345678, "got key %#Ix\n", key);
11935 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
11936 if (ovl_iocp)
11937 {
11938 ok(!ovl_iocp->InternalHigh, "got %#Ix\n", ovl_iocp->InternalHigh);
11939 ok(ovl_iocp->Internal == STATUS_CANCELLED, "got %#Ix\n", ovl_iocp->Internal);
11940 }
11941 }
11942
11943 Sleep(100);
11944 memset(&msg, 0, sizeof(msg));
11945 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11946 ok(!ret || broken(msg.hwnd == hwnd) /* XP */, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11947 if (ret) /* document XP behaviour */
11948 {
11949 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11950 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
11951 ok(msg.lParam == 1, "got %08Ix\n", msg.lParam);
11952 }
11953
11954 ret = send(dst, "Hello World!", 12, 0);
11955 ok(ret == 12, "send returned %d\n", ret);
11956
11957 Sleep(100);
11958 memset(&msg, 0, sizeof(msg));
11959 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11960 ok(!ret || broken(msg.hwnd == hwnd) /* XP */, "got %04x,%08Ix,%08Ix\n", msg.message, msg.wParam, msg.lParam);
11961 if (ret) /* document XP behaviour */
11962 {
11963 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11964 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11965 ok(msg.wParam == src, "got %08Ix\n", msg.wParam);
11966 ok(msg.lParam == 1, "got %08Ix\n", msg.lParam);
11967 }
11968
11969 bytes = 0xdeadbeef;
11970 key = 0xdeadbeef;
11971 ovl_iocp = (void *)0xdeadbeef;
11972 SetLastError(0xdeadbeef);
11973 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11974 ok(ret || broken(GetLastError() == WAIT_TIMEOUT) /* XP */, "got %lu\n", GetLastError());
11975 if (ret)
11976 {
11977 ok(bytes == 12, "got bytes %lu\n", bytes);
11978 ok(key == 0x12345678, "got key %#Ix\n", key);
11979 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
11980 if (ovl_iocp)
11981 {
11982 ok(ovl_iocp->InternalHigh == 12, "got %#Ix\n", ovl_iocp->InternalHigh);
11983 ok(!ovl_iocp->Internal , "got %#Ix\n", ovl_iocp->Internal);
11984 ok(!memcmp(data, "Hello World!", 12), "got %lu bytes (%*s)\n", bytes, (int)bytes, data);
11985 }
11986 }
11987 else /* document XP behaviour */
11988 {
11989 ok(bytes == 0xdeadbeef, "got bytes %lu\n", bytes);
11990 ok(key == 0xdeadbeef, "got key %Iu\n", key);
11991 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11992 }
11993
11994 CloseHandle(port);
11995
11996 DestroyWindow(hwnd);
11997 }
11998
11999 static void test_iocp(void)
12000 {
12001 SOCKET src, dst;
12002 int i;
12003
12004 tcp_socketpair(&src, &dst);
12005 sync_read(src, dst);
12006 iocp_async_read(src, dst);
12007 closesocket(src);
12008 closesocket(dst);
12009
12010 tcp_socketpair(&src, &dst);
12011 iocp_async_read_thread(src, dst);
12012 closesocket(src);
12013 closesocket(dst);
12014
12015 for (i = 0; i <= 2; i++)
12016 {
12017 tcp_socketpair(&src, &dst);
12018 iocp_async_read_closesocket(src, i);
12019 closesocket(dst);
12020 }
12021
12022 tcp_socketpair(&src, &dst);
12023 iocp_async_closesocket(src);
12024 closesocket(dst);
12025
12026 tcp_socketpair(&src, &dst);
12027 iocp_async_read_thread_closesocket(src);
12028 closesocket(dst);
12029 }
12030
12031 static void test_get_interface_list(void)
12032 {
12033 OVERLAPPED overlapped = {0}, *overlapped_ptr;
12034 DWORD size, expect_size;
12035 unsigned int i, count;
12036 INTERFACE_INFO *info;
12037 BOOL loopback_found;
12038 char buffer[4096];
12039 ULONG_PTR key;
12040 HANDLE port;
12041 SOCKET s;
12042 int ret;
12043
12044 s = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
12045 ok(s != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
12046 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
12047
12048 size = 0xdeadbeef;
12049 WSASetLastError(0xdeadbeef);
12050 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(buffer), &size, NULL, NULL);
12051 ok(!ret, "Got unexpected ret %d.\n", ret);
12052 ok(!WSAGetLastError(), "Got error %u.\n", WSAGetLastError());
12053 ok(size && size != 0xdeadbeef && !(size % sizeof(INTERFACE_INFO)), "Got unexpected size %lu.\n", size);
12054 expect_size = size;
12055
12056 size = 0xdeadbeef;
12057 overlapped.Internal = 0xdeadbeef;
12058 overlapped.InternalHigh = 0xdeadbeef;
12059 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(buffer), &size, &overlapped, NULL);
12060 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12061 ok(WSAGetLastError() == ERROR_IO_PENDING, "Got error %u.\n", WSAGetLastError());
12062 ok(size == 0xdeadbeef, "Got size %lu.\n", size);
12063
12064 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 100);
12065 ok(ret, "Got error %lu.\n", GetLastError());
12066 ok(size == expect_size, "Expected size %lu, got %lu.\n", expect_size, size);
12067 ok(key == 123, "Got key %Iu.\n", key);
12068 ok(overlapped_ptr == &overlapped, "Got overlapped %p.\n", overlapped_ptr);
12069 ok(!overlapped.Internal, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
12070 ok(overlapped.InternalHigh == expect_size, "Expected size %lu, got %Iu.\n", expect_size, overlapped.InternalHigh);
12071
12072 info = (INTERFACE_INFO *)buffer;
12073 count = size / sizeof(INTERFACE_INFO);
12074 loopback_found = FALSE;
12075 for (i = 0; i < count; ++i)
12076 {
12077 if (info[i].iiFlags & IFF_LOOPBACK)
12078 loopback_found = TRUE;
12079
12080 ok(info[i].iiAddress.AddressIn.sin_family == AF_INET, "Got unexpected sin_family %#x.\n",
12081 info[i].iiAddress.AddressIn.sin_family);
12082 ok(info[i].iiNetmask.AddressIn.sin_family == AF_INET, "Got unexpected sin_family %#x.\n",
12083 info[i].iiNetmask.AddressIn.sin_family);
12084 ok(info[i].iiBroadcastAddress.AddressIn.sin_family
12085 == (info[i].iiFlags & IFF_BROADCAST) ? AF_INET : 0, "Got unexpected sin_family %#x.\n",
12086 info[i].iiBroadcastAddress.AddressIn.sin_family);
12087 ok(info[i].iiAddress.AddressIn.sin_addr.S_un.S_addr, "Got zero iiAddress.\n");
12088 ok(info[i].iiNetmask.AddressIn.sin_addr.S_un.S_addr, "Got zero iiNetmask.\n");
12089 ok((info[i].iiFlags & IFF_BROADCAST) ? info[i].iiBroadcastAddress.AddressIn.sin_addr.S_un.S_addr
12090 : !info[i].iiBroadcastAddress.AddressIn.sin_addr.S_un.S_addr,
12091 "Got unexpected iiBroadcastAddress %s.\n", inet_ntoa(info[i].iiBroadcastAddress.AddressIn.sin_addr));
12092 }
12093
12094 ok(loopback_found, "Loopback interface not found.\n");
12095
12096 size = 0xdeadbeef;
12097 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(INTERFACE_INFO) - 1, &size, NULL, NULL);
12098 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12099 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
12100 ok(!size, "Got unexpected size %lu.\n", size);
12101
12102 size = 0xdeadbeef;
12103 overlapped.Internal = 0xdeadbeef;
12104 overlapped.InternalHigh = 0xdeadbeef;
12105 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(INTERFACE_INFO) - 1, &size, &overlapped, NULL);
12106 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12107 ok(WSAGetLastError() == ERROR_IO_PENDING, "Got error %u.\n", WSAGetLastError());
12108 ok(size == 0xdeadbeef, "Got size %lu.\n", size);
12109
12110 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 100);
12111 ok(!ret, "Expected failure.\n");
12112 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Got error %lu.\n", GetLastError());
12113 ok(!size, "Got size %lu.\n", size);
12114 ok(key == 123, "Got key %Iu.\n", key);
12115 ok(overlapped_ptr == &overlapped, "Got overlapped %p.\n", overlapped_ptr);
12116 ok((NTSTATUS)overlapped.Internal == STATUS_BUFFER_TOO_SMALL, "Got status %#lx.\n", (NTSTATUS)overlapped.Internal);
12117 ok(!overlapped.InternalHigh, "Got size %Iu.\n", overlapped.InternalHigh);
12118
12119 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(buffer), NULL, NULL, NULL);
12120 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12121 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
12122
12123 CloseHandle(port);
12124 closesocket(s);
12125
12126 /* Test with an APC. */
12127
12128 s = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
12129 ok(s != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
12130
12131 size = 0xdeadbeef;
12132 apc_count = 0;
12133 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer,
12134 sizeof(INTERFACE_INFO) - 1, &size, &overlapped, socket_apc);
12135 ok(ret == -1, "Got unexpected ret %d.\n", ret);
12136 ok(WSAGetLastError() == ERROR_IO_PENDING, "Got error %u.\n", WSAGetLastError());
12137 ok(size == 0xdeadbeef, "Got size %lu.\n", size);
12138
12139 ret = SleepEx(100, TRUE);
12140 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
12141 ok(apc_count == 1, "APC was called %u times\n", apc_count);
12142 ok(apc_error == WSAEFAULT, "got APC error %lu\n", apc_error);
12143 ok(!apc_size, "got APC size %lu\n", apc_size);
12144 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
12145
12146 closesocket(s);
12147 }
12148
12149 static void test_bind(void)
12150 {
12151 const struct sockaddr_in invalid_addr = {.sin_family = AF_INET, .sin_addr.s_addr = inet_addr("192.0.2.0")};
12152 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
12153 IP_ADAPTER_ADDRESSES *adapters = NULL, *adapter;
12154 ULONG ip_addrs_size = 0;
12155 struct sockaddr addr;
12156 SOCKET s, s2;
12157 int ret, len;
12158
12159 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12160
12161 WSASetLastError(0xdeadbeef);
12162 ret = bind(s, NULL, 0);
12163 ok(ret == -1, "expected failure\n");
12164 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12165
12166 WSASetLastError(0xdeadbeef);
12167 ret = bind(s, NULL, sizeof(addr));
12168 ok(ret == -1, "expected failure\n");
12169 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12170
12171 addr.sa_family = AF_INET;
12172 WSASetLastError(0xdeadbeef);
12173 ret = bind(s, &addr, 0);
12174 ok(ret == -1, "expected failure\n");
12175 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12176
12177 addr.sa_family = 0xdead;
12178 WSASetLastError(0xdeadbeef);
12179 ret = bind(s, &addr, sizeof(addr));
12180 ok(ret == -1, "expected failure\n");
12181 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError());
12182
12183 WSASetLastError(0xdeadbeef);
12184 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr) - 1);
12185 ok(ret == -1, "expected failure\n");
12186 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12187
12188 WSASetLastError(0xdeadbeef);
12189 ret = bind(s, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
12190 ok(ret == -1, "expected failure\n");
12191 ok(WSAGetLastError() == WSAEADDRNOTAVAIL, "got error %u\n", WSAGetLastError());
12192
12193 WSASetLastError(0xdeadbeef);
12194 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12195 ok(!ret, "expected success\n");
12196 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
12197
12198 WSASetLastError(0xdeadbeef);
12199 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12200 ok(ret == -1, "expected failure\n");
12201 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
12202
12203 len = sizeof(addr);
12204 ret = getsockname(s, &addr, &len);
12205 ok(!ret, "got error %u\n", WSAGetLastError());
12206
12207 s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12208
12209 WSASetLastError(0xdeadbeef);
12210 ret = bind(s2, &addr, sizeof(addr));
12211 ok(ret == -1, "expected failure\n");
12212 ok(WSAGetLastError() == WSAEADDRINUSE, "got error %u\n", WSAGetLastError());
12213
12214 closesocket(s2);
12215 closesocket(s);
12216
12217 s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
12218
12219 WSASetLastError(0xdeadbeef);
12220 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12221 ok(!ret, "expected success\n");
12222 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
12223
12224 closesocket(s);
12225
12226 ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, adapters, &ip_addrs_size);
12227 ok(ret == ERROR_BUFFER_OVERFLOW, "got error %u\n", ret);
12228 adapters = malloc(ip_addrs_size);
12229 ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, adapters, &ip_addrs_size);
12230 ok(!ret, "got error %u\n", ret);
12231
12232 for (adapter = adapters; adapter != NULL; adapter = adapter->Next)
12233 {
12234 const IP_ADAPTER_UNICAST_ADDRESS *unicast_addr;
12235
12236 if (adapter->OperStatus != IfOperStatusUp) continue;
12237
12238 for (unicast_addr = adapter->FirstUnicastAddress; unicast_addr != NULL; unicast_addr = unicast_addr->Next)
12239 {
12240 short family = unicast_addr->Address.lpSockaddr->sa_family;
12241
12242 s = socket(family, SOCK_STREAM, IPPROTO_TCP);
12243 ok(s != -1, "failed to create socket, error %u\n", WSAGetLastError());
12244
12245 ret = bind(s, unicast_addr->Address.lpSockaddr, unicast_addr->Address.iSockaddrLength);
12246 ok(!ret, "got error %u\n", WSAGetLastError());
12247
12248 closesocket(s);
12249
12250 if (family == AF_INET6)
12251 {
12252 struct sockaddr_in6 addr6, ret_addr6;
12253
12254 memcpy(&addr6, unicast_addr->Address.lpSockaddr, sizeof(addr6));
12255
12256 ok(unicast_addr->Address.iSockaddrLength == sizeof(struct sockaddr_in6),
12257 "got unexpected length %u\n", unicast_addr->Address.iSockaddrLength);
12258
12259 s = socket(family, SOCK_STREAM, IPPROTO_TCP);
12260 ok(s != -1, "failed to create socket, error %u\n", WSAGetLastError());
12261
12262 ret = bind(s, unicast_addr->Address.lpSockaddr, sizeof(struct sockaddr_in6_old));
12263 ok(ret == -1, "expected failure\n");
12264 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12265
12266 addr6.sin6_scope_id = 0xabacab;
12267 ret = bind(s, (struct sockaddr *)&addr6, sizeof(addr6));
12268 todo_wine_if (!((const struct sockaddr_in6 *)unicast_addr->Address.lpSockaddr)->sin6_scope_id)
12269 {
12270 ok(ret == -1, "expected failure\n");
12271 ok(WSAGetLastError() == WSAEADDRNOTAVAIL, "got error %u\n", WSAGetLastError());
12272 }
12273
12274 addr6.sin6_scope_id = 0;
12275 ret = bind(s, (struct sockaddr *)&addr6, sizeof(addr6));
12276 todo_wine_if (!((const struct sockaddr_in6 *)unicast_addr->Address.lpSockaddr)->sin6_scope_id)
12277 ok(!ret, "got error %u\n", WSAGetLastError());
12278
12279 memcpy(&addr6, unicast_addr->Address.lpSockaddr, sizeof(addr6));
12280
12281 len = sizeof(struct sockaddr_in6_old);
12282 ret = getsockname(s, (struct sockaddr *)&ret_addr6, &len);
12283 ok(ret == -1, "expected failure\n");
12284 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
12285
12286 len = sizeof(ret_addr6);
12287 memset(&ret_addr6, 0, sizeof(ret_addr6));
12288 ret = getsockname(s, (struct sockaddr *)&ret_addr6, &len);
12289 ok(!ret, "got error %u\n", WSAGetLastError());
12290 ok(ret_addr6.sin6_family == AF_INET6, "got family %u\n", ret_addr6.sin6_family);
12291 ok(ret_addr6.sin6_port != 0, "expected nonzero port\n");
12292 ok(!memcmp(&ret_addr6.sin6_addr, &addr6.sin6_addr, sizeof(addr6.sin6_addr)), "address didn't match\n");
12293 ok(ret_addr6.sin6_scope_id == addr6.sin6_scope_id, "got scope %lu\n", ret_addr6.sin6_scope_id);
12294
12295 closesocket(s);
12296 }
12297 }
12298 }
12299
12300 free(adapters);
12301 }
12302
12303 /* Test calling methods on a socket which is currently connecting. */
12304 static void test_connecting_socket(void)
12305 {
12306 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_ANY)};
12307 const struct sockaddr_in invalid_addr =
12308 {
12309 .sin_family = AF_INET,
12310 .sin_addr.s_addr = inet_addr("192.0.2.0"),
12311 .sin_port = 255
12312 };
12313 OVERLAPPED overlapped = {0}, overlapped2 = {0};
12314 GUID connectex_guid = WSAID_CONNECTEX;
12315 LPFN_CONNECTEX pConnectEx;
12316 struct sockaddr_in addr;
12317 char buffer[4];
12318 SOCKET client;
12319 int ret, len;
12320 DWORD size;
12321
12322 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12323 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
12324 set_blocking(client, FALSE);
12325
12326 ret = bind(client, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12327 ok(!ret, "expected success\n");
12328 ok(!WSAGetLastError(), "got %u\n", WSAGetLastError());
12329
12330 ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
12331 ok(ret == -1, "got %d\n", ret);
12332 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got %u\n", WSAGetLastError());
12333
12334 /* Mortal Kombat 11 connects to the same address twice and expects the
12335 * second to return WSAEALREADY. */
12336 ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
12337 ok(ret == -1, "got %d\n", ret);
12338 ok(WSAGetLastError() == WSAEALREADY, "got %u\n", WSAGetLastError());
12339
12340 ret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectex_guid, sizeof(connectex_guid),
12341 &pConnectEx, sizeof(pConnectEx), &size, NULL, NULL);
12342 ok(!ret, "failed to get ConnectEx, error %u\n", WSAGetLastError());
12343 overlapped.Internal = 0xdeadbeef;
12344 overlapped.InternalHigh = 0xdeadbeef;
12345 ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped);
12346 ok(!ret, "got %d\n", ret);
12347 ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError());
12348 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
12349 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
12350
12351 len = sizeof(addr);
12352 ret = getsockname(client, (struct sockaddr *)&addr, &len);
12353 ok(!ret, "got error %u\n", WSAGetLastError());
12354 ok(addr.sin_family == AF_INET, "got family %u\n", addr.sin_family);
12355 ok(addr.sin_port, "expected nonzero port\n");
12356
12357 len = sizeof(addr);
12358 ret = getpeername(client, (struct sockaddr *)&addr, &len);
12359 todo_wine ok(!ret, "got error %u\n", WSAGetLastError());
12360 if (!ret)
12361 {
12362 ok(addr.sin_family == AF_INET, "got family %u\n", addr.sin_family);
12363 ok(addr.sin_addr.s_addr == inet_addr("192.0.2.0"), "got address %#08lx\n", addr.sin_addr.s_addr);
12364 ok(addr.sin_port == 255, "expected nonzero port\n");
12365 }
12366
12367 ret = recv(client, buffer, sizeof(buffer), 0);
12368 ok(ret == -1, "got %d\n", ret);
12369 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12370
12371 ret = send(client, "data", 5, 0);
12372 ok(ret == -1, "got %d\n", ret);
12373 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12374
12375 closesocket(client);
12376
12377 /* Test with ConnectEx(). */
12378
12379 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12380 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
12381 set_blocking(client, FALSE);
12382
12383 ret = bind(client, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
12384 ok(!ret, "expected success\n");
12385 ok(!WSAGetLastError(), "got %u\n", WSAGetLastError());
12386
12387 ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped2);
12388 ok(!ret, "got %d\n", ret);
12389 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
12390
12391 ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
12392 ok(ret == -1, "got %d\n", ret);
12393 ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError());
12394
12395 overlapped.Internal = 0xdeadbeef;
12396 overlapped.InternalHigh = 0xdeadbeef;
12397 ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped);
12398 ok(!ret, "got %d\n", ret);
12399 ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError());
12400 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
12401 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
12402
12403 len = sizeof(addr);
12404 ret = getsockname(client, (struct sockaddr *)&addr, &len);
12405 ok(!ret, "got error %u\n", WSAGetLastError());
12406 ok(addr.sin_family == AF_INET, "got family %u\n", addr.sin_family);
12407 ok(addr.sin_port, "expected nonzero port\n");
12408
12409 len = sizeof(addr);
12410 ret = getpeername(client, (struct sockaddr *)&addr, &len);
12411 ok(ret == -1, "got %d\n", ret);
12412 ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12413
12414 ret = recv(client, buffer, sizeof(buffer), 0);
12415 ok(ret == -1, "got %d\n", ret);
12416 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12417
12418 ret = send(client, "data", 5, 0);
12419 ok(ret == -1, "got %d\n", ret);
12420 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
12421
12422 closesocket(client);
12423 }
12424
12425 static DWORD map_status( NTSTATUS status )
12426 {
12427 static const struct
12428 {
12429 NTSTATUS status;
12430 DWORD error;
12431 }
12432 errors[] =
12433 {
12434 {STATUS_PENDING, ERROR_IO_INCOMPLETE},
12435
12436 {STATUS_BUFFER_OVERFLOW, WSAEMSGSIZE},
12437
12438 {STATUS_NOT_IMPLEMENTED, WSAEOPNOTSUPP},
12439 {STATUS_ACCESS_VIOLATION, WSAEFAULT},
12440 {STATUS_PAGEFILE_QUOTA, WSAENOBUFS},
12441 {STATUS_INVALID_HANDLE, WSAENOTSOCK},
12442 {STATUS_NO_SUCH_DEVICE, WSAENETDOWN},
12443 {STATUS_NO_SUCH_FILE, WSAENETDOWN},
12444 {STATUS_NO_MEMORY, WSAENOBUFS},
12445 {STATUS_CONFLICTING_ADDRESSES, WSAENOBUFS},
12446 {STATUS_ACCESS_DENIED, WSAEACCES},
12447 {STATUS_BUFFER_TOO_SMALL, WSAEFAULT},
12448 {STATUS_OBJECT_TYPE_MISMATCH, WSAENOTSOCK},
12449 {STATUS_OBJECT_NAME_NOT_FOUND, WSAENETDOWN},
12450 {STATUS_OBJECT_PATH_NOT_FOUND, WSAENETDOWN},
12451 {STATUS_SHARING_VIOLATION, WSAEADDRINUSE},
12452 {STATUS_QUOTA_EXCEEDED, WSAENOBUFS},
12453 {STATUS_TOO_MANY_PAGING_FILES, WSAENOBUFS},
12454 {STATUS_INSUFFICIENT_RESOURCES, WSAENOBUFS},
12455 {STATUS_WORKING_SET_QUOTA, WSAENOBUFS},
12456 {STATUS_DEVICE_NOT_READY, WSAEWOULDBLOCK},
12457 {STATUS_PIPE_DISCONNECTED, WSAESHUTDOWN},
12458 {STATUS_IO_TIMEOUT, WSAETIMEDOUT},
12459 {STATUS_NOT_SUPPORTED, WSAEOPNOTSUPP},
12460 {STATUS_REMOTE_NOT_LISTENING, WSAECONNREFUSED},
12461 {STATUS_BAD_NETWORK_PATH, WSAENETUNREACH},
12462 {STATUS_NETWORK_BUSY, WSAENETDOWN},
12463 {STATUS_INVALID_NETWORK_RESPONSE, WSAENETDOWN},
12464 {STATUS_UNEXPECTED_NETWORK_ERROR, WSAENETDOWN},
12465 {STATUS_REQUEST_NOT_ACCEPTED, WSAEWOULDBLOCK},
12466 {STATUS_CANCELLED, ERROR_OPERATION_ABORTED},
12467 {STATUS_COMMITMENT_LIMIT, WSAENOBUFS},
12468 {STATUS_LOCAL_DISCONNECT, WSAECONNABORTED},
12469 {STATUS_REMOTE_DISCONNECT, WSAECONNRESET},
12470 {STATUS_REMOTE_RESOURCES, WSAENOBUFS},
12471 {STATUS_LINK_FAILED, WSAECONNRESET},
12472 {STATUS_LINK_TIMEOUT, WSAETIMEDOUT},
12473 {STATUS_INVALID_CONNECTION, WSAENOTCONN},
12474 {STATUS_INVALID_ADDRESS, WSAEADDRNOTAVAIL},
12475 {STATUS_INVALID_BUFFER_SIZE, WSAEMSGSIZE},
12476 {STATUS_INVALID_ADDRESS_COMPONENT, WSAEADDRNOTAVAIL},
12477 {STATUS_TOO_MANY_ADDRESSES, WSAENOBUFS},
12478 {STATUS_ADDRESS_ALREADY_EXISTS, WSAEADDRINUSE},
12479 {STATUS_CONNECTION_DISCONNECTED, WSAECONNRESET},
12480 {STATUS_CONNECTION_RESET, WSAECONNRESET},
12481 {STATUS_TRANSACTION_ABORTED, WSAECONNABORTED},
12482 {STATUS_CONNECTION_REFUSED, WSAECONNREFUSED},
12483 {STATUS_GRACEFUL_DISCONNECT, WSAEDISCON},
12484 {STATUS_CONNECTION_ACTIVE, WSAEISCONN},
12485 {STATUS_NETWORK_UNREACHABLE, WSAENETUNREACH},
12486 {STATUS_HOST_UNREACHABLE, WSAEHOSTUNREACH},
12487 {STATUS_PROTOCOL_UNREACHABLE, WSAENETUNREACH},
12488 {STATUS_PORT_UNREACHABLE, WSAECONNRESET},
12489 {STATUS_REQUEST_ABORTED, WSAEINTR},
12490 {STATUS_CONNECTION_ABORTED, WSAECONNABORTED},
12491 {STATUS_DATATYPE_MISALIGNMENT_ERROR,WSAEFAULT},
12492 {STATUS_HOST_DOWN, WSAEHOSTDOWN},
12493 {0x80070000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
12494 {0xc0010000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
12495 {0xc0070000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
12496 };
12497
12498 unsigned int i;
12499
12500 for (i = 0; i < ARRAY_SIZE(errors); ++i)
12501 {
12502 if (errors[i].status == status)
12503 return errors[i].error;
12504 }
12505
12506 return NT_SUCCESS(status) ? RtlNtStatusToDosErrorNoTeb(status) : WSAEINVAL;
12507 }
12508
12509 static void test_WSAGetOverlappedResult(void)
12510 {
12511 OVERLAPPED overlapped = {0};
12512 DWORD size, flags;
12513 NTSTATUS status;
12514 unsigned int i;
12515 SOCKET s;
12516 HANDLE h;
12517 BOOL ret;
12518
12519 static const NTSTATUS ranges[][2] =
12520 {
12521 {0x0, 0x10000},
12522 {0x40000000, 0x40001000},
12523 {0x80000000, 0x80001000},
12524 {0x80070000, 0x80080000},
12525 {0xc0000000, 0xc0001000},
12526 {0xc0070000, 0xc0080000},
12527 {0xd0000000, 0xd0001000},
12528 {0xd0070000, 0xd0080000},
12529 };
12530
12531 WSASetLastError(0xdeadbeef);
12532 ret = WSAGetOverlappedResult(0xdeadbeef, &overlapped, &size, FALSE, &flags);
12533 ok(!ret, "got %d.\n", ret);
12534 ok(WSAGetLastError() == WSAENOTSOCK, "got %u.\n", WSAGetLastError());
12535
12536 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12537
12538 ret = DuplicateHandle(GetCurrentProcess(), (HANDLE)s, GetCurrentProcess(), &h, 0, FALSE, DUPLICATE_SAME_ACCESS);
12539 ok(ret, "got %d.\n", ret);
12540 ret = WSAGetOverlappedResult((SOCKET)h, &overlapped, &size, FALSE, &flags);
12541 ok(!ret, "got %d.\n", ret);
12542 ok(WSAGetLastError() == WSAENOTSOCK, "got %u.\n", WSAGetLastError());
12543 CloseHandle(h);
12544
12545 for (i = 0; i < ARRAY_SIZE(ranges); ++i)
12546 {
12547 for (status = ranges[i][0]; status < ranges[i][1]; ++status)
12548 {
12549 BOOL expect_ret = NT_SUCCESS(status) && status != STATUS_PENDING;
12550 DWORD expect = map_status(status);
12551
12552 overlapped.Internal = status;
12553 WSASetLastError(0xdeadbeef);
12554 ret = WSAGetOverlappedResult(s, &overlapped, &size, FALSE, &flags);
12555 ok(ret == expect_ret, "status %#lx: expected %d, got %d\n", status, expect_ret, ret);
12556 if (ret)
12557 {
12558 ok(WSAGetLastError() == expect /* >= win10 1809 */
12559 || !WSAGetLastError() /* < win10 1809 */
12560 || WSAGetLastError() == 0xdeadbeef, /* < win7 */
12561 "status %#lx: expected error %lu, got %u\n", status, expect, WSAGetLastError());
12562 }
12563 else
12564 {
12565 ok(WSAGetLastError() == expect
12566 || (status == (0xc0070000 | ERROR_IO_INCOMPLETE) && WSAGetLastError() == WSAEINVAL), /* < win8 */
12567 "status %#lx: expected error %lu, got %u\n", status, expect, WSAGetLastError());
12568 }
12569 }
12570 }
12571
12572 closesocket(s);
12573 }
12574
12575 struct nonblocking_async_recv_params
12576 {
12577 SOCKET client;
12578 HANDLE event;
12579 };
12580
12581 static DWORD CALLBACK nonblocking_async_recv_thread(void *arg)
12582 {
12583 const struct nonblocking_async_recv_params *params = arg;
12584 OVERLAPPED overlapped = {0};
12585 DWORD flags = 0, size;
12586 char buffer[5];
12587 WSABUF wsabuf;
12588 int ret;
12589
12590 overlapped.hEvent = params->event;
12591 wsabuf.buf = buffer;
12592 wsabuf.len = sizeof(buffer);
12593 memset(buffer, 0, sizeof(buffer));
12594 ret = WSARecv(params->client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
12595 ok(!ret, "got %d\n", ret);
12596 ret = GetOverlappedResult((HANDLE)params->client, &overlapped, &size, FALSE);
12597 ok(ret, "got error %lu\n", GetLastError());
12598 ok(size == 4, "got size %lu\n", size);
12599 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
12600
12601 return 0;
12602 }
12603
12604 static void test_nonblocking_async_recv(void)
12605 {
12606 struct nonblocking_async_recv_params params;
12607 OVERLAPPED overlapped = {0};
12608 SOCKET client, server;
12609 DWORD flags = 0, size;
12610 HANDLE thread, event;
12611 char buffer[5];
12612 WSABUF wsabuf;
12613 int ret;
12614
12615 event = CreateEventW(NULL, TRUE, FALSE, NULL);
12616 wsabuf.buf = buffer;
12617 wsabuf.len = sizeof(buffer);
12618
12619 tcp_socketpair(&client, &server);
12620 set_blocking(client, FALSE);
12621 set_blocking(server, FALSE);
12622
12623 WSASetLastError(0xdeadbeef);
12624 ret = recv(client, buffer, sizeof(buffer), 0);
12625 ok(ret == -1, "got %d\n", ret);
12626 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
12627
12628 WSASetLastError(0xdeadbeef);
12629 overlapped.Internal = 0xdeadbeef;
12630 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
12631 ok(ret == -1, "got %d\n", ret);
12632 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
12633 ok(overlapped.Internal == 0xdeadbeef, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
12634
12635 /* Overlapped, with a NULL event. */
12636
12637 overlapped.hEvent = NULL;
12638
12639 memset(buffer, 0, sizeof(buffer));
12640 WSASetLastError(0xdeadbeef);
12641 overlapped.Internal = 0xdeadbeef;
12642 overlapped.InternalHigh = 0xdeadbeef;
12643 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
12644 ok(ret == -1, "got %d\n", ret);
12645 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
12646 ret = WaitForSingleObject((HANDLE)client, 0);
12647 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
12648 ok(overlapped.Internal == STATUS_PENDING, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
12649 ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
12650
12651 ret = send(server, "data", 4, 0);
12652 ok(ret == 4, "got %d\n", ret);
12653
12654 ret = WaitForSingleObject((HANDLE)client, 1000);
12655 ok(!ret, "wait timed out\n");
12656 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
12657 ok(ret, "got error %lu\n", GetLastError());
12658 ok(size == 4, "got size %lu\n", size);
12659 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
12660
12661 /* Overlapped, with a non-NULL event. */
12662
12663 overlapped.hEvent = event;
12664
12665 memset(buffer, 0, sizeof(buffer));
12666 WSASetLastError(0xdeadbeef);
12667 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
12668 ok(ret == -1, "got %d\n", ret);
12669 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
12670 ret = WaitForSingleObject(event, 0);
12671 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
12672
12673 ret = send(server, "data", 4, 0);
12674 ok(ret == 4, "got %d\n", ret);
12675
12676 ret = WaitForSingleObject(event, 1000);
12677 ok(!ret, "wait timed out\n");
12678 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
12679 ok(ret, "got error %lu\n", GetLastError());
12680 ok(size == 4, "got size %lu\n", size);
12681 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
12682
12683 /* With data already in the pipe; usually this does return 0 (but not
12684 * reliably). */
12685
12686 ret = send(server, "data", 4, 0);
12687 ok(ret == 4, "got %d\n", ret);
12688
12689 memset(buffer, 0, sizeof(buffer));
12690 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
12691 ok(!ret || WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
12692 ret = WaitForSingleObject(event, 1000);
12693 ok(!ret, "wait timed out\n");
12694 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
12695 ok(ret, "got error %lu\n", GetLastError());
12696 ok(size == 4, "got size %lu\n", size);
12697 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
12698
12699 closesocket(client);
12700 closesocket(server);
12701
12702 /* With a non-overlapped socket, WSARecv() always blocks when passed an
12703 * overlapped structure, but returns WSAEWOULDBLOCK otherwise. */
12704
12705 tcp_socketpair_flags(&client, &server, 0);
12706 set_blocking(client, FALSE);
12707 set_blocking(server, FALSE);
12708
12709 WSASetLastError(0xdeadbeef);
12710 ret = recv(client, buffer, sizeof(buffer), 0);
12711 ok(ret == -1, "got %d\n", ret);
12712 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
12713
12714 WSASetLastError(0xdeadbeef);
12715 overlapped.Internal = 0xdeadbeef;
12716 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
12717 ok(ret == -1, "got %d\n", ret);
12718 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
12719 ok(overlapped.Internal == 0xdeadbeef, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
12720
12721 /* Overlapped, with a NULL event. */
12722
12723 params.client = client;
12724 params.event = NULL;
12725 thread = CreateThread(NULL, 0, nonblocking_async_recv_thread, &params, 0, NULL);
12726
12727 ret = WaitForSingleObject(thread, 200);
12728 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
12729
12730 ret = send(server, "data", 4, 0);
12731 ok(ret == 4, "got %d\n", ret);
12732
12733 ret = WaitForSingleObject(thread, 200);
12734 ok(!ret, "wait timed out\n");
12735 CloseHandle(thread);
12736
12737 /* Overlapped, with a non-NULL event. */
12738
12739 params.client = client;
12740 params.event = event;
12741 thread = CreateThread(NULL, 0, nonblocking_async_recv_thread, &params, 0, NULL);
12742
12743 ret = WaitForSingleObject(thread, 200);
12744 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
12745
12746 ret = send(server, "data", 4, 0);
12747 ok(ret == 4, "got %d\n", ret);
12748
12749 ret = WaitForSingleObject(thread, 200);
12750 ok(!ret, "wait timed out\n");
12751 CloseHandle(thread);
12752
12753 /* With data already in the pipe. */
12754
12755 ret = send(server, "data", 4, 0);
12756 ok(ret == 4, "got %d\n", ret);
12757
12758 memset(buffer, 0, sizeof(buffer));
12759 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
12760 ok(!ret, "got %d\n", ret);
12761 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
12762 ok(ret, "got error %lu\n", GetLastError());
12763 ok(size == 4, "got size %lu\n", size);
12764 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
12765
12766 closesocket(client);
12767 closesocket(server);
12768
12769 CloseHandle(overlapped.hEvent);
12770 }
12771
12772 static void test_simultaneous_async_recv(void)
12773 {
12774 SOCKET client, server;
12775 OVERLAPPED overlappeds[2] = {{0}};
12776 HANDLE events[2];
12777 WSABUF wsabufs[2];
12778 DWORD flags[2] = {0};
12779 size_t num_io = 2, stride = 16, i;
12780 char resbuf[32] = "";
12781 static const char msgstr[32] = "-- Lorem ipsum dolor sit amet -";
12782 int ret;
12783
12784 for (i = 0; i < num_io; i++) events[i] = CreateEventW(NULL, TRUE, FALSE, NULL);
12785
12786 tcp_socketpair(&client, &server);
12787
12788 for (i = 0; i < num_io; i++)
12789 {
12790 wsabufs[i].buf = resbuf + i * stride;
12791 wsabufs[i].len = stride;
12792 overlappeds[i].hEvent = events[i];
12793 ret = WSARecv(client, &wsabufs[i], 1, NULL, &flags[i], &overlappeds[i], NULL);
12794 ok(ret == -1, "got %d\n", ret);
12795 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
12796 }
12797
12798 ret = send(server, msgstr, sizeof(msgstr), 0);
12799 ok(ret == sizeof(msgstr), "got %d\n", ret);
12800
12801 for (i = 0; i < num_io; i++)
12802 {
12803 const void *expect = msgstr + i * stride;
12804 const void *actual = resbuf + i * stride;
12805 DWORD size;
12806
12807 ret = WaitForSingleObject(events[i], 1000);
12808 ok(!ret, "wait timed out\n");
12809
12810 size = 0;
12811 ret = GetOverlappedResult((HANDLE)client, &overlappeds[i], &size, FALSE);
12812 ok(ret, "got error %lu\n", GetLastError());
12813 ok(size == stride, "got size %lu\n", size);
12814 ok(!memcmp(expect, actual, stride), "expected %s, got %s\n", debugstr_an(expect, stride), debugstr_an(actual, stride));
12815 }
12816
12817 closesocket(client);
12818 closesocket(server);
12819
12820 for (i = 0; i < num_io; i++) CloseHandle(events[i]);
12821 }
12822
12823 static void test_empty_recv(void)
12824 {
12825 OVERLAPPED overlapped = {0};
12826 SOCKET client, server;
12827 DWORD size, flags = 0;
12828 char buffer[5];
12829 WSABUF wsabuf;
12830 int ret;
12831
12832 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
12833 tcp_socketpair(&client, &server);
12834
12835 WSASetLastError(0xdeadbeef);
12836 ret = WSARecv(client, NULL, 0, NULL, &flags, &overlapped, NULL);
12837 ok(ret == -1, "expected failure\n");
12838 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
12839
12840 wsabuf.buf = buffer;
12841 wsabuf.len = 0;
12842 WSASetLastError(0xdeadbeef);
12843 ret = WSARecv(client, &wsabuf, 0, NULL, &flags, &overlapped, NULL);
12844 ok(ret == -1, "expected failure\n");
12845 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
12846
12847 WSASetLastError(0xdeadbeef);
12848 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
12849 ok(ret == -1, "expected failure\n");
12850 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
12851
12852 ret = send(server, "data", 5, 0);
12853 ok(ret == 5, "got %d\n", ret);
12854
12855 ret = WaitForSingleObject(overlapped.hEvent, 1000);
12856 ok(!ret, "wait failed\n");
12857 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
12858 ok(ret, "got error %lu\n", GetLastError());
12859 ok(!size, "got size %lu\n", size);
12860
12861 WSASetLastError(0xdeadbeef);
12862 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
12863 ok(!ret, "got error %u\n", WSAGetLastError());
12864 ok(!size, "got size %lu\n", size);
12865
12866 ret = recv(client, NULL, 0, 0);
12867 ok(!ret, "got %d\n", ret);
12868
12869 ret = recv(client, buffer, sizeof(buffer), 0);
12870 ok(ret == 5, "got %d\n", ret);
12871 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, ret));
12872
12873 closesocket(client);
12874 closesocket(server);
12875 CloseHandle(overlapped.hEvent);
12876 }
12877
12878 static void test_timeout(void)
12879 {
12880 DWORD timeout, flags = 0, size;
12881 OVERLAPPED overlapped = {0};
12882 SOCKET client, server;
12883 WSABUF wsabuf;
12884 int ret, len;
12885 char buffer;
12886
12887 tcp_socketpair(&client, &server);
12888 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
12889
12890 timeout = 0xdeadbeef;
12891 len = sizeof(timeout);
12892 WSASetLastError(0xdeadbeef);
12893 ret = getsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, &len);
12894 ok(!ret, "expected success\n");
12895 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
12896 ok(len == sizeof(timeout), "got size %u\n", len);
12897 ok(!timeout, "got timeout %lu\n", timeout);
12898
12899 timeout = 100;
12900 WSASetLastError(0xdeadbeef);
12901 ret = setsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
12902 ok(!ret, "expected success\n");
12903 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
12904
12905 timeout = 0xdeadbeef;
12906 len = sizeof(timeout);
12907 WSASetLastError(0xdeadbeef);
12908 ret = getsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, &len);
12909 ok(!ret, "expected success\n");
12910 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
12911 ok(timeout == 100, "got timeout %lu\n", timeout);
12912
12913 WSASetLastError(0xdeadbeef);
12914 ret = recv(client, &buffer, 1, 0);
12915 ok(ret == -1, "got %d\n", ret);
12916 ok(WSAGetLastError() == WSAETIMEDOUT, "got error %u\n", WSAGetLastError());
12917
12918 wsabuf.buf = &buffer;
12919 wsabuf.len = 1;
12920 WSASetLastError(0xdeadbeef);
12921 size = 0xdeadbeef;
12922 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
12923 ok(ret == -1, "got %d\n", ret);
12924 ok(WSAGetLastError() == WSAETIMEDOUT, "got error %u\n", WSAGetLastError());
12925 ok(size == 0xdeadbeef, "got size %lu\n", size);
12926
12927 wsabuf.buf = &buffer;
12928 wsabuf.len = 1;
12929 WSASetLastError(0xdeadbeef);
12930 size = 0xdeadbeef;
12931 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
12932 ok(ret == -1, "got %d\n", ret);
12933 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
12934
12935 ret = WaitForSingleObject(overlapped.hEvent, 200);
12936 ok(ret == WAIT_TIMEOUT, "got %d\n", ret);
12937
12938 ret = send(server, "a", 1, 0);
12939 ok(ret == 1, "got %d\n", ret);
12940
12941 ret = WaitForSingleObject(overlapped.hEvent, 200);
12942 ok(!ret, "got %d\n", ret);
12943 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
12944 ok(ret, "got error %lu\n", GetLastError());
12945 ok(size == 1, "got size %lu\n", size);
12946
12947 closesocket(client);
12948 closesocket(server);
12949 CloseHandle(overlapped.hEvent);
12950 }
12951
12952 static void test_so_debug(void)
12953 {
12954 int ret, len;
12955 DWORD debug;
12956 SOCKET s;
12957
12958 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
12959
12960 len = sizeof(debug);
12961 WSASetLastError(0xdeadbeef);
12962 debug = 0xdeadbeef;
12963 ret = getsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&debug, &len);
12964 ok(!ret, "got %d\n", ret);
12965 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
12966 ok(len == sizeof(debug), "got len %u\n", len);
12967 ok(!debug, "got debug %lu\n", debug);
12968
12969 WSASetLastError(0xdeadbeef);
12970 debug = 2;
12971 ret = setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&debug, sizeof(debug));
12972 ok(!ret, "got %d\n", ret);
12973 todo_wine ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
12974
12975 len = sizeof(debug);
12976 WSASetLastError(0xdeadbeef);
12977 debug = 0xdeadbeef;
12978 ret = getsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&debug, &len);
12979 ok(!ret, "got %d\n", ret);
12980 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
12981 ok(len == sizeof(debug), "got len %u\n", len);
12982 todo_wine ok(debug == 1, "got debug %lu\n", debug);
12983
12984 closesocket(s);
12985 }
12986
12987 struct sockopt_validity_test
12988 {
12989 int opt;
12990 int get_error;
12991 int set_error;
12992 BOOL todo;
12993 };
12994
12995 static void do_sockopt_validity_tests(const char *type, SOCKET sock, int level,
12996 const struct sockopt_validity_test *tests)
12997 {
12998 char value[256];
12999 int count, rc, expected_rc, i;
13000
13001 for (i = 0; tests[i].opt; i++)
13002 {
13003 winetest_push_context("%s option %i", type, tests[i].opt);
13004 memset(value, 0, sizeof(value));
13005 count = sizeof(value);
13006
13007 WSASetLastError(0);
13008 rc = getsockopt(sock, level, tests[i].opt, value, &count);
13009 expected_rc = tests[i].get_error ? SOCKET_ERROR : 0;
13010 todo_wine_if(!tests[i].get_error && tests[i].todo)
13011 ok(rc == expected_rc || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
13012 "expected getsockopt to return %i, got %i\n", expected_rc, rc);
13013 todo_wine_if(tests[i].todo)
13014 ok(WSAGetLastError() == tests[i].get_error || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
13015 "expected getsockopt to set error %i, got %i\n", tests[i].get_error, WSAGetLastError());
13016
13017 if (tests[i].get_error)
13018 {
13019 winetest_pop_context();
13020 continue;
13021 }
13022
13023 WSASetLastError(0);
13024 rc = setsockopt(sock, level, tests[i].opt, value, count);
13025 expected_rc = tests[i].set_error ? SOCKET_ERROR : 0;
13026 todo_wine_if(!tests[i].set_error && tests[i].todo)
13027 ok(rc == expected_rc || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
13028 "expected setsockopt to return %i, got %i\n", expected_rc, rc);
13029 todo_wine_if(tests[i].todo)
13030 ok(WSAGetLastError() == tests[i].set_error || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
13031 "expected setsockopt to set error %i, got %i\n", tests[i].set_error, WSAGetLastError());
13032
13033 winetest_pop_context();
13034 }
13035 }
13036
13037 static void test_sockopt_validity(void)
13038 {
13039 static const struct sockopt_validity_test ipv4_tcp_tests[] =
13040 {
13041 { -1, WSAENOPROTOOPT },
13042 { IP_OPTIONS },
13043 { IP_HDRINCL, WSAEINVAL },
13044 { IP_TOS },
13045 { IP_TTL },
13046 { IP_MULTICAST_IF, WSAEINVAL },
13047 { IP_MULTICAST_TTL, WSAEINVAL },
13048 { IP_MULTICAST_LOOP, WSAEINVAL },
13049 { IP_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13050 { IP_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13051 { IP_DONTFRAGMENT },
13052 { IP_PKTINFO, WSAEINVAL },
13053 { IP_RECVTTL, WSAEINVAL },
13054 { IP_RECEIVE_BROADCAST, WSAEINVAL, 0, TRUE },
13055 { IP_RECVIF, WSAEINVAL, 0, TRUE },
13056 { IP_RECVDSTADDR, WSAEINVAL, 0, TRUE },
13057 { IP_IFLIST, 0, 0, TRUE },
13058 { IP_UNICAST_IF },
13059 { IP_RTHDR, 0, 0, TRUE },
13060 { IP_GET_IFLIST, WSAEINVAL, 0, TRUE },
13061 { IP_RECVRTHDR, WSAEINVAL, 0, TRUE },
13062 { IP_RECVTOS, WSAEINVAL },
13063 { IP_ORIGINAL_ARRIVAL_IF, WSAEINVAL, 0, TRUE },
13064 { IP_ECN, WSAEINVAL, 0, TRUE },
13065 { IP_PKTINFO_EX, WSAEINVAL, 0, TRUE },
13066 { IP_WFP_REDIRECT_RECORDS, WSAEINVAL, 0, TRUE },
13067 { IP_WFP_REDIRECT_CONTEXT, WSAEINVAL, 0, TRUE },
13068 { IP_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13069 { IP_MTU, WSAENOTCONN, 0, TRUE },
13070 { IP_RECVERR, WSAEINVAL, 0, TRUE },
13071 { IP_USER_MTU, 0, 0, TRUE },
13072 {}
13073 };
13074 static const struct sockopt_validity_test ipv4_udp_tests[] =
13075 {
13076 { -1, WSAENOPROTOOPT },
13077 { IP_OPTIONS },
13078 { IP_HDRINCL, WSAEINVAL },
13079 { IP_TOS },
13080 { IP_TTL },
13081 { IP_MULTICAST_IF },
13082 { IP_MULTICAST_TTL },
13083 { IP_MULTICAST_LOOP },
13084 { IP_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13085 { IP_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13086 { IP_DONTFRAGMENT },
13087 { IP_PKTINFO },
13088 { IP_RECVTTL },
13089 { IP_RECEIVE_BROADCAST, 0, 0, TRUE },
13090 { IP_RECVIF, 0, 0, TRUE },
13091 { IP_RECVDSTADDR, 0, 0, TRUE },
13092 { IP_IFLIST, 0, 0, TRUE },
13093 { IP_UNICAST_IF },
13094 { IP_RTHDR, 0, 0, TRUE },
13095 { IP_GET_IFLIST, WSAEINVAL, 0, TRUE },
13096 { IP_RECVRTHDR, 0, 0, TRUE },
13097 { IP_RECVTOS },
13098 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
13099 { IP_ECN, 0, 0, TRUE },
13100 { IP_PKTINFO_EX, 0, 0, TRUE },
13101 { IP_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
13102 { IP_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
13103 { IP_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13104 { IP_MTU, WSAENOTCONN, 0, TRUE },
13105 { IP_RECVERR, 0, 0, TRUE },
13106 { IP_USER_MTU, 0, 0, TRUE },
13107 {}
13108 };
13109 static const struct sockopt_validity_test ipv4_raw_tests[] =
13110 {
13111 { -1, WSAENOPROTOOPT },
13112 { IP_OPTIONS },
13113 { IP_HDRINCL, },
13114 { IP_TOS },
13115 { IP_TTL },
13116 { IP_MULTICAST_IF },
13117 { IP_MULTICAST_TTL },
13118 { IP_MULTICAST_LOOP },
13119 { IP_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13120 { IP_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13121 { IP_DONTFRAGMENT },
13122 { IP_PKTINFO },
13123 { IP_RECVTTL },
13124 { IP_RECEIVE_BROADCAST, 0, 0, TRUE },
13125 { IP_RECVIF, 0, 0, TRUE },
13126 { IP_RECVDSTADDR, 0, 0, TRUE },
13127 { IP_IFLIST, 0, 0, TRUE },
13128 { IP_UNICAST_IF },
13129 { IP_RTHDR, 0, 0, TRUE },
13130 { IP_GET_IFLIST, WSAEINVAL, 0, TRUE },
13131 { IP_RECVRTHDR, 0, 0, TRUE },
13132 { IP_RECVTOS },
13133 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
13134 { IP_ECN, 0, 0, TRUE },
13135 { IP_PKTINFO_EX, 0, 0, TRUE },
13136 { IP_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
13137 { IP_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
13138 { IP_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13139 { IP_MTU, WSAENOTCONN, 0, TRUE },
13140 { IP_RECVERR, WSAEINVAL, 0, TRUE },
13141 { IP_USER_MTU, 0, 0, TRUE },
13142 {}
13143 };
13144 static const struct sockopt_validity_test ipv6_tcp_tests[] =
13145 {
13146 { -1, WSAENOPROTOOPT },
13147 { IPV6_HOPOPTS, 0, 0, TRUE },
13148 { IPV6_HDRINCL, WSAEINVAL, 0, TRUE },
13149 { IPV6_UNICAST_HOPS },
13150 { IPV6_MULTICAST_IF, WSAEINVAL },
13151 { IPV6_MULTICAST_HOPS, WSAEINVAL },
13152 { IPV6_MULTICAST_LOOP, WSAEINVAL },
13153 { IPV6_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13154 { IPV6_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13155 { IPV6_DONTFRAG },
13156 { IPV6_PKTINFO, WSAEINVAL },
13157 { IPV6_HOPLIMIT, WSAEINVAL },
13158 { IPV6_PROTECTION_LEVEL },
13159 { IPV6_RECVIF, WSAEINVAL, 0, TRUE },
13160 { IPV6_RECVDSTADDR, WSAEINVAL, 0, TRUE },
13161 { IPV6_V6ONLY },
13162 { IPV6_IFLIST, 0, 0, TRUE },
13163 { IPV6_UNICAST_IF },
13164 { IPV6_RTHDR, 0, 0, TRUE },
13165 { IPV6_GET_IFLIST, WSAEINVAL, 0, TRUE },
13166 { IPV6_RECVRTHDR, WSAEINVAL, 0, TRUE },
13167 { IPV6_RECVTCLASS, WSAEINVAL },
13168 { IP_ORIGINAL_ARRIVAL_IF, WSAEINVAL, 0, TRUE },
13169 { IPV6_ECN, WSAEINVAL, 0, TRUE },
13170 { IPV6_PKTINFO_EX, WSAEINVAL, 0, TRUE },
13171 { IPV6_WFP_REDIRECT_RECORDS, WSAEINVAL, 0, TRUE },
13172 { IPV6_WFP_REDIRECT_CONTEXT, WSAEINVAL, 0, TRUE },
13173 { IPV6_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13174 { IPV6_MTU, WSAENOTCONN, 0, TRUE },
13175 { IPV6_RECVERR, WSAEINVAL, 0, TRUE },
13176 { IPV6_USER_MTU, 0, 0, TRUE },
13177 {}
13178 };
13179 static const struct sockopt_validity_test ipv6_udp_tests[] =
13180 {
13181 { -1, WSAENOPROTOOPT },
13182 { IPV6_HOPOPTS, 0, 0, TRUE },
13183 { IPV6_HDRINCL, WSAEINVAL, 0, TRUE },
13184 { IPV6_UNICAST_HOPS },
13185 { IPV6_MULTICAST_IF },
13186 { IPV6_MULTICAST_HOPS },
13187 { IPV6_MULTICAST_LOOP },
13188 { IPV6_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13189 { IPV6_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13190 { IPV6_DONTFRAG },
13191 { IPV6_PKTINFO },
13192 { IPV6_HOPLIMIT },
13193 { IPV6_PROTECTION_LEVEL },
13194 { IPV6_RECVIF, 0, 0, TRUE },
13195 { IPV6_RECVDSTADDR, 0, 0, TRUE },
13196 { IPV6_V6ONLY },
13197 { IPV6_IFLIST, 0, 0, TRUE },
13198 { IPV6_UNICAST_IF },
13199 { IPV6_RTHDR, 0, 0, TRUE },
13200 { IPV6_GET_IFLIST, WSAEINVAL, 0, TRUE },
13201 { IPV6_RECVRTHDR, 0, 0, TRUE },
13202 { IPV6_RECVTCLASS },
13203 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
13204 { IPV6_ECN, 0, 0, TRUE },
13205 { IPV6_PKTINFO_EX, 0, 0, TRUE },
13206 { IPV6_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
13207 { IPV6_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
13208 { IPV6_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13209 { IPV6_MTU, WSAENOTCONN, 0, TRUE },
13210 { IPV6_RECVERR, 0, 0, TRUE },
13211 { IPV6_USER_MTU, 0, 0, TRUE },
13212 {}
13213 };
13214 static const struct sockopt_validity_test ipv6_raw_tests[] =
13215 {
13216 { -1, WSAENOPROTOOPT },
13217 { IPV6_HOPOPTS, 0, 0, TRUE },
13218 { IPV6_HDRINCL, 0, 0, TRUE },
13219 { IPV6_UNICAST_HOPS },
13220 { IPV6_MULTICAST_IF },
13221 { IPV6_MULTICAST_HOPS },
13222 { IPV6_MULTICAST_LOOP },
13223 { IPV6_ADD_MEMBERSHIP, WSAENOPROTOOPT },
13224 { IPV6_DROP_MEMBERSHIP, WSAENOPROTOOPT },
13225 { IPV6_DONTFRAG },
13226 { IPV6_PKTINFO },
13227 { IPV6_HOPLIMIT },
13228 { IPV6_PROTECTION_LEVEL },
13229 { IPV6_RECVIF, 0, 0, TRUE },
13230 { IPV6_RECVDSTADDR, 0, 0, TRUE },
13231 { IPV6_V6ONLY },
13232 { IPV6_IFLIST, 0, 0, TRUE },
13233 { IPV6_UNICAST_IF },
13234 { IPV6_RTHDR, 0, 0, TRUE },
13235 { IPV6_GET_IFLIST, WSAEINVAL, 0, TRUE },
13236 { IPV6_RECVRTHDR, 0, 0, TRUE },
13237 { IPV6_RECVTCLASS },
13238 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
13239 { IPV6_ECN, 0, 0, TRUE },
13240 { IPV6_PKTINFO_EX, 0, 0, TRUE },
13241 { IPV6_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
13242 { IPV6_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
13243 { IPV6_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
13244 { IPV6_MTU, WSAENOTCONN, 0, TRUE },
13245 { IPV6_RECVERR, WSAEINVAL, 0, TRUE },
13246 { IPV6_USER_MTU, 0, 0, TRUE },
13247 {}
13248 };
13249 static const struct sockopt_validity_test file_handle_tests[] =
13250 {
13251 { -1, WSAENOTSOCK },
13252 { SO_TYPE, WSAENOTSOCK },
13253 { SO_OPENTYPE },
13254 {}
13255 };
13256 char path[MAX_PATH];
13257 HANDLE file;
13258 SOCKET sock;
13259
13260 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
13261 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13262 do_sockopt_validity_tests("IPv4 TCP", sock, IPPROTO_IP, ipv4_tcp_tests);
13263 closesocket(sock);
13264
13265 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
13266 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13267 do_sockopt_validity_tests("IPv4 UDP", sock, IPPROTO_IP, ipv4_udp_tests);
13268 closesocket(sock);
13269
13270 sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
13271 if (sock == INVALID_SOCKET && WSAGetLastError() == WSAEACCES)
13272 {
13273 skip("Raw IPv4 sockets are not available\n");
13274 }
13275 else
13276 {
13277 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13278 do_sockopt_validity_tests("IPv4 raw", sock, IPPROTO_IP, ipv4_raw_tests);
13279 closesocket(sock);
13280 }
13281
13282 sock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
13283 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13284 do_sockopt_validity_tests("IPv6 TCP", sock, IPPROTO_IPV6, ipv6_tcp_tests);
13285 closesocket(sock);
13286
13287 sock = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
13288 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13289 do_sockopt_validity_tests("IPv6 UDP", sock, IPPROTO_IPV6, ipv6_udp_tests);
13290 closesocket(sock);
13291
13292 sock = socket(AF_INET6, SOCK_RAW, IPPROTO_RAW);
13293 if (sock == INVALID_SOCKET && WSAGetLastError() == WSAEACCES)
13294 {
13295 skip("Raw IPv6 sockets are not available\n");
13296 }
13297 else
13298 {
13299 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
13300 do_sockopt_validity_tests("IPv6 raw", sock, IPPROTO_IPV6, ipv6_raw_tests);
13301 closesocket(sock);
13302 }
13303
13304 GetSystemWindowsDirectoryA(path, ARRAY_SIZE(path));
13305 strcat(path, "\\system.ini");
13306 file = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0x0, NULL);
13307 do_sockopt_validity_tests("file", (SOCKET)file, SOL_SOCKET, file_handle_tests);
13308 CloseHandle(file);
13309 }
13310
13311 static void test_tcp_reset(void)
13312 {
13313 static const struct timeval select_timeout;
13314 fd_set readfds, writefds, exceptfds;
13315 OVERLAPPED overlapped = {0};
13316 SOCKET client, server;
13317 DWORD size, flags = 0;
13318 int ret, len, error;
13319 char buffer[10];
13320 WSABUF wsabuf;
13321
13322 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
13323
13324 tcp_socketpair(&client, &server);
13325
13326 wsabuf.buf = buffer;
13327 wsabuf.len = sizeof(buffer);
13328 WSASetLastError(0xdeadbeef);
13329 size = 0xdeadbeef;
13330 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
13331 ok(ret == -1, "got %d\n", ret);
13332 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
13333
13334 close_with_rst(server);
13335
13336 ret = WaitForSingleObject(overlapped.hEvent, 1000);
13337 ok(!ret, "wait failed\n");
13338 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
13339 ok(!ret, "expected failure\n");
13340 ok(GetLastError() == ERROR_NETNAME_DELETED, "got error %lu\n", GetLastError());
13341 ok(!size, "got size %lu\n", size);
13342 ok((NTSTATUS)overlapped.Internal == STATUS_CONNECTION_RESET, "got status %#lx\n", (NTSTATUS)overlapped.Internal);
13343
13344 len = sizeof(error);
13345 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&error, &len);
13346 ok(!ret, "got error %u\n", WSAGetLastError());
13347 ok(!error, "got error %u\n", error);
13348
13349 wsabuf.buf = buffer;
13350 wsabuf.len = sizeof(buffer);
13351 WSASetLastError(0xdeadbeef);
13352 size = 0xdeadbeef;
13353 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
13354 todo_wine ok(ret == -1, "got %d\n", ret);
13355 todo_wine ok(WSAGetLastError() == WSAECONNRESET, "got error %u\n", WSAGetLastError());
13356
13357 check_poll(client, POLLERR | POLLHUP | POLLWRNORM);
13358
13359 FD_ZERO(&readfds);
13360 FD_ZERO(&writefds);
13361 FD_ZERO(&exceptfds);
13362 FD_SET(client, &readfds);
13363 FD_SET(client, &writefds);
13364 FD_SET(client, &exceptfds);
13365 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
13366 ok(ret == 2, "got %d\n", ret);
13367 ok(FD_ISSET(client, &readfds), "FD should be set\n");
13368 ok(FD_ISSET(client, &writefds), "FD should be set\n");
13369 ok(!FD_ISSET(client, &exceptfds), "FD should be set\n");
13370
13371 FD_ZERO(&exceptfds);
13372 FD_SET(client, &exceptfds);
13373 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
13374 ok(!ret, "got %d\n", ret);
13375 ok(!FD_ISSET(client, &exceptfds), "FD should be set\n");
13376
13377 closesocket(server);
13378 CloseHandle(overlapped.hEvent);
13379 }
13380
13381 struct icmp_hdr
13382 {
13383 BYTE type;
13384 BYTE code;
13385 UINT16 checksum;
13386 union
13387 {
13388 struct
13389 {
13390 UINT16 id;
13391 UINT16 sequence;
13392 } echo;
13393 } un;
13394 };
13395
13396 struct ip_hdr
13397 {
13398 BYTE v_hl; /* version << 4 | hdr_len */
13399 BYTE tos;
13400 UINT16 tot_len;
13401 UINT16 id;
13402 UINT16 frag_off;
13403 BYTE ttl;
13404 BYTE protocol;
13405 UINT16 checksum;
13406 ULONG saddr;
13407 ULONG daddr;
13408 };
13409
13410 /* rfc 1071 checksum */
13411 static unsigned short chksum(BYTE *data, unsigned int count)
13412 {
13413 unsigned int sum = 0, carry = 0;
13414 unsigned short check, s;
13415
13416 while (count > 1)
13417 {
13418 s = *(unsigned short *)data;
13419 data += 2;
13420 sum += carry;
13421 sum += s;
13422 carry = s > sum;
13423 count -= 2;
13424 }
13425 sum += carry; /* This won't produce another carry */
13426 sum = (sum & 0xffff) + (sum >> 16);
13427
13428 if (count) sum += *data; /* LE-only */
13429
13430 sum = (sum & 0xffff) + (sum >> 16);
13431 /* fold in any carry */
13432 sum = (sum & 0xffff) + (sum >> 16);
13433
13434 check = ~sum;
13435 return check;
13436 }
13437
13438 static void test_icmp(void)
13439 {
13440 static const unsigned int ping_data = 0xdeadbeef;
13441 struct icmp_hdr *icmp_h;
13442 BYTE send_buf[sizeof(struct icmp_hdr) + sizeof(ping_data)];
13443 UINT16 recv_checksum, checksum;
13444 unsigned int reply_data;
13445 struct sockaddr_in sa;
13446 struct ip_hdr *ip_h;
13447 struct in_addr addr;
13448 BYTE recv_buf[256];
13449 SOCKET s;
13450 int ret;
13451
13452 s = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
13453 if (s == INVALID_SOCKET)
13454 {
13455 ret = WSAGetLastError();
13456 ok(ret == WSAEACCES, "Expected 10013, received %d\n", ret);
13457 skip("SOCK_RAW is not supported\n");
13458 return;
13459 }
13460
13461 icmp_h = (struct icmp_hdr *)send_buf;
13462 icmp_h->type = ICMP4_ECHO_REQUEST;
13463 icmp_h->code = 0;
13464 icmp_h->checksum = 0;
13465 icmp_h->un.echo.id = 0xbeaf; /* will be overwritten for linux ping socks */
13466 icmp_h->un.echo.sequence = 1;
13467 *(unsigned int *)(icmp_h + 1) = ping_data;
13468 icmp_h->checksum = chksum(send_buf, sizeof(send_buf));
13469
13470 memset(&sa, 0, sizeof(sa));
13471 sa.sin_family = AF_INET;
13472 sa.sin_port = 0;
13473 sa.sin_addr.s_addr = inet_addr("127.0.0.1");
13474
13475 ret = sendto(s, (char *)send_buf, sizeof(send_buf), 0, (struct sockaddr*)&sa, sizeof(sa));
13476 ok(ret == sizeof(send_buf), "got %d, error %d.\n", ret, WSAGetLastError());
13477
13478 ret = recv(s, (char *)recv_buf, sizeof(struct ip_hdr) + sizeof(send_buf) - 1, 0);
13479 ok(ret == -1, "got %d\n", ret);
13480 ok(WSAGetLastError() == WSAEMSGSIZE, "got %d\n", WSAGetLastError());
13481
13482 icmp_h->un.echo.sequence = 2;
13483 icmp_h->checksum = 0;
13484 icmp_h->checksum = chksum(send_buf, sizeof(send_buf));
13485
13486 ret = sendto(s, (char *)send_buf, sizeof(send_buf), 0, (struct sockaddr*)&sa, sizeof(sa));
13487 ok(ret != SOCKET_ERROR, "got error %d.\n", WSAGetLastError());
13488
13489 memset(recv_buf, 0xcc, sizeof(recv_buf));
13490 ret = recv(s, (char *)recv_buf, sizeof(recv_buf), 0);
13491 ok(ret == sizeof(struct ip_hdr) + sizeof(send_buf), "got %d\n", ret);
13492
13493 ip_h = (struct ip_hdr *)recv_buf;
13494 icmp_h = (struct icmp_hdr *)(ip_h + 1);
13495 reply_data = *(unsigned int *)(icmp_h + 1);
13496
13497 ok(ip_h->v_hl == ((4 << 4) | (sizeof(*ip_h) >> 2)), "got v_hl %#x.\n", ip_h->v_hl);
13498 ok(ntohs(ip_h->tot_len) == sizeof(struct ip_hdr) + sizeof(send_buf),
13499 "got tot_len %#x.\n", ntohs(ip_h->tot_len));
13500
13501 recv_checksum = ip_h->checksum;
13502 ip_h->checksum = 0;
13503 checksum = chksum((BYTE *)ip_h, sizeof(*ip_h));
13504 /* Checksum is 0 for localhost ping on Windows but not for remote host ping. */
13505 ok(recv_checksum == checksum || !recv_checksum, "got checksum %#x, expected %#x.\n", recv_checksum, checksum);
13506
13507 ok(!ip_h->frag_off, "got id %#x.\n", ip_h->frag_off);
13508 addr.s_addr = ip_h->saddr;
13509 ok(ip_h->saddr == sa.sin_addr.s_addr, "got saddr %s.\n", inet_ntoa(addr));
13510 addr.s_addr = ip_h->daddr;
13511 ok(!!ip_h->daddr, "got daddr %s.\n", inet_ntoa(addr));
13512
13513 ok(ip_h->protocol == 1, "got protocol %#x.\n", ip_h->protocol);
13514
13515 ok(icmp_h->type == ICMP4_ECHO_REPLY, "got type %#x.\n", icmp_h->type);
13516 ok(!icmp_h->code, "got code %#x.\n", icmp_h->code);
13517 ok(icmp_h->un.echo.id == 0xbeaf, "got echo id %#x.\n", icmp_h->un.echo.id);
13518 ok(icmp_h->un.echo.sequence == 2, "got echo sequence %#x.\n", icmp_h->un.echo.sequence);
13519
13520 recv_checksum = icmp_h->checksum;
13521 icmp_h->checksum = 0;
13522 checksum = chksum((BYTE *)icmp_h, sizeof(send_buf));
13523 ok(recv_checksum == checksum, "got checksum %#x, expected %#x.\n", recv_checksum, checksum);
13524
13525 ok(reply_data == ping_data, "got reply_data %#x.\n", reply_data);
13526
13527 closesocket(s);
13528 }
13529
13530 static void test_connect_time(void)
13531 {
13532 struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
13533 SOCKET client, server;
13534 unsigned int time;
13535 int ret, len;
13536
13537 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
13538
13539 len = sizeof(time);
13540 SetLastError(0xdeadbeef);
13541 ret = getsockopt(client, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
13542 ok(!ret, "got %d\n", ret);
13543 ok(!GetLastError(), "got error %lu\n", GetLastError());
13544 ok(len == sizeof(time), "got len %d\n", len);
13545 ok(time == ~0u, "got time %u\n", time);
13546
13547 closesocket(client);
13548
13549 tcp_socketpair(&client, &server);
13550
13551 len = sizeof(time);
13552 SetLastError(0xdeadbeef);
13553 ret = getsockopt(client, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
13554 ok(!ret, "got %d\n", ret);
13555 ok(!GetLastError(), "got error %lu\n", GetLastError());
13556 ok(len == sizeof(time), "got len %d\n", len);
13557 ok(time == 0, "got time %u\n", time);
13558
13559 len = sizeof(time);
13560 SetLastError(0xdeadbeef);
13561 ret = getsockopt(server, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
13562 ok(!ret, "got %d\n", ret);
13563 ok(!GetLastError(), "got error %lu\n", GetLastError());
13564 ok(len == sizeof(time), "got len %d\n", len);
13565 ok(time == 0, "got time %u\n", time);
13566
13567 closesocket(client);
13568 closesocket(server);
13569
13570 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
13571 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
13572
13573 ret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
13574 ok(!ret, "got error %lu\n", GetLastError());
13575 len = sizeof(addr);
13576 ret = getsockname(server, (struct sockaddr *)&addr, &len);
13577 ok(!ret, "got error %lu\n", GetLastError());
13578 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
13579 ok(!ret, "got error %lu\n", GetLastError());
13580
13581 len = sizeof(time);
13582 SetLastError(0xdeadbeef);
13583 ret = getsockopt(client, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
13584 ok(!ret, "got %d\n", ret);
13585 ok(!GetLastError(), "got error %lu\n", GetLastError());
13586 ok(len == sizeof(time), "got len %d\n", len);
13587 ok(time == ~0u, "got time %u\n", time);
13588
13589 len = sizeof(time);
13590 SetLastError(0xdeadbeef);
13591 ret = getsockopt(server, SOL_SOCKET, SO_CONNECT_TIME, (char *)&time, &len);
13592 ok(!ret, "got %d\n", ret);
13593 ok(!GetLastError(), "got error %lu\n", GetLastError());
13594 ok(len == sizeof(time), "got len %d\n", len);
13595 ok(time == ~0u, "got time %u\n", time);
13596
13597 closesocket(server);
13598 closesocket(client);
13599 }
13600
13601 static void test_connect_udp(void)
13602 {
13603 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
13604 struct sockaddr_in addr, ret_addr;
13605 SOCKET client, server;
13606 char buffer[5];
13607 int ret, len;
13608
13609 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
13610 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
13611 set_blocking(client, FALSE);
13612 set_blocking(server, FALSE);
13613
13614 SetLastError(0xdeadbeef);
13615 ret = send(client, "data", 4, 0);
13616 ok(ret == -1, "got %d\n", ret);
13617 todo_wine ok(GetLastError() == WSAENOTCONN, "got error %lu\n", GetLastError());
13618
13619 SetLastError(0xdeadbeef);
13620 ret = recv(server, buffer, sizeof(buffer), 0);
13621 ok(ret == -1, "got %d\n", ret);
13622 todo_wine ok(GetLastError() == WSAEINVAL, "got error %lu\n", GetLastError());
13623
13624 ret = bind(server, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
13625 ok(!ret, "got error %lu\n", GetLastError());
13626 len = sizeof(addr);
13627 ret = getsockname(server, (struct sockaddr *)&addr, &len);
13628 ok(!ret, "got error %lu\n", GetLastError());
13629
13630 SetLastError(0xdeadbeef);
13631 ret = recv(server, buffer, sizeof(buffer), 0);
13632 ok(ret == -1, "got %d\n", ret);
13633 ok(GetLastError() == WSAEWOULDBLOCK, "got error %lu\n", GetLastError());
13634
13635 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
13636 ok(!ret, "got error %lu\n", GetLastError());
13637 ret = getpeername(client, (struct sockaddr *)&ret_addr, &len);
13638 ok(!ret, "got error %lu\n", GetLastError());
13639 ok(!memcmp(&ret_addr, &addr, sizeof(addr)), "addresses didn't match\n");
13640
13641 ret = getsockname(client, (struct sockaddr *)&ret_addr, &len);
13642 ok(!ret, "got error %lu\n", GetLastError());
13643
13644 SetLastError(0xdeadbeef);
13645 ret = getpeername(server, (struct sockaddr *)&ret_addr, &len);
13646 ok(ret == -1, "got %d\n", ret);
13647 ok(GetLastError() == WSAENOTCONN, "got error %lu\n", GetLastError());
13648
13649 ret = send(client, "data", 4, 0);
13650 ok(ret == 4, "got %d\n", ret);
13651
13652 memset(buffer, 0xcc, sizeof(buffer));
13653 ret = recv(server, buffer, sizeof(buffer), 0);
13654 ok(ret == 4, "got %d\n", ret);
13655 ok(!memcmp(buffer, "data", 4), "got %s\n", debugstr_an(buffer, ret));
13656
13657 SetLastError(0xdeadbeef);
13658 ret = recv(server, buffer, sizeof(buffer), 0);
13659 ok(ret == -1, "got %d\n", ret);
13660 ok(GetLastError() == WSAEWOULDBLOCK, "got error %lu\n", GetLastError());
13661
13662 SetLastError(0xdeadbeef);
13663 ret = send(server, "data", 4, 0);
13664 ok(ret == -1, "got %d\n", ret);
13665 todo_wine ok(GetLastError() == WSAENOTCONN, "got error %lu\n", GetLastError());
13666
13667 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
13668 ok(!ret, "got error %lu\n", GetLastError());
13669 ++addr.sin_port;
13670 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
13671 ok(!ret, "got error %lu\n", GetLastError());
13672
13673 memset(&addr, 0, sizeof(addr));
13674 addr.sin_family = AF_UNSPEC;
13675 ret = connect(client, (struct sockaddr *)&addr, sizeof(addr));
13676 ok(!ret, "got error %lu\n", GetLastError());
13677
13678 ret = getpeername(client, (struct sockaddr *)&ret_addr, &len);
13679 ok(ret == -1, "got %d\n", ret);
13680 ok(GetLastError() == WSAENOTCONN, "got error %lu\n", GetLastError());
13681
13682 closesocket(server);
13683 closesocket(client);
13684 }
13685
13686 START_TEST( sock )
13687 {
13688 int i;
13689
13690 /* Leave these tests at the beginning. They depend on WSAStartup not having been
13691 * called, which is done by Init() below. */
13692 test_WithoutWSAStartup();
13693 test_WithWSAStartup();
13694
13695 Init();
13696
13697 test_set_getsockopt();
13698 test_reuseaddr();
13699 test_ip_pktinfo();
13700 test_ipv4_cmsg();
13701 test_ipv6_cmsg();
13702 test_extendedSocketOptions();
13703 test_so_debug();
13704 test_sockopt_validity();
13705 test_connect_time();
13706
13707 for (i = 0; i < ARRAY_SIZE(tests); i++)
13708 do_test(&tests[i]);
13709
13710 test_UDP();
13711
13712 test_WSASocket();
13713 test_WSADuplicateSocket();
13714 test_WSAConnectByName();
13715 test_WSAEnumNetworkEvents();
13716
13717 test_errors();
13718 test_listen();
13719 test_select();
13720 test_accept();
13721 test_accept_inheritance();
13722 test_getpeername();
13723 test_getsockname();
13724
13725 test_address_list_query();
13726 test_fionbio();
13727 test_fionread_siocatmark();
13728 test_get_extension_func();
13729 test_backlog_query();
13730 test_get_interface_list();
13731 test_keepalive_vals();
13732 test_sioRoutingInterfaceQuery();
13733 test_sioAddressListChange();
13734 test_base_handle();
13735 test_circular_queueing();
13736 test_unsupported_ioctls();
13737
13738 test_WSASendMsg();
13739 test_WSASendTo();
13740 test_WSARecv();
13741 test_WSAPoll();
13742 test_write_watch();
13743 test_iocp();
13744
13745 test_events();
13746
13747 test_ipv6only();
13748 test_TransmitFile();
13749 test_AcceptEx();
13750 test_connect();
13751 test_shutdown();
13752 test_DisconnectEx();
13753
13754 test_completion_port();
13755 test_connect_completion_port();
13756 test_shutdown_completion_port();
13757 test_bind();
13758 test_connecting_socket();
13759 test_WSAGetOverlappedResult();
13760 test_nonblocking_async_recv();
13761 test_simultaneous_async_recv();
13762 test_empty_recv();
13763 test_timeout();
13764 test_tcp_reset();
13765 test_icmp();
13766 test_connect_udp();
13767
13768 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
13769 test_send();
13770
13771 Exit();
13772 }
Windows API implementation