?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ws2_32/tests: Add socket option validity tests for a file handle.
[wine.git] / dlls / ws2_32 / tests / sock.c
blobd3f2459aa3af6fbaaab5697c16212786e9c6915b
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 #define check_poll(a, b) check_poll_(__LINE__, a, POLLRDNORM | POLLRDBAND | POLLWRNORM, b, FALSE)
206 #define check_poll_todo(a, b) check_poll_(__LINE__, a, POLLRDNORM | POLLRDBAND | POLLWRNORM, b, TRUE)
207 #define check_poll_mask(a, b, c) check_poll_(__LINE__, a, b, c, FALSE)
208 #define check_poll_mask_todo(a, b, c) check_poll_(__LINE__, a, b, c, TRUE)
209 static void check_poll_(int line, SOCKET s, short mask, short expect, BOOL todo)
210 {
211 WSAPOLLFD pollfd;
212 int ret;
213
214 pollfd.fd = s;
215 pollfd.events = mask;
216 pollfd.revents = 0xdead;
217 ret = pWSAPoll(&pollfd, 1, 1000);
218 ok_(__FILE__, line)(ret == (pollfd.revents ? 1 : 0), "WSAPoll() returned %d\n", ret);
219 todo_wine_if (todo) ok_(__FILE__, line)(pollfd.revents == expect, "got wrong events %#x\n", pollfd.revents);
220 }
221
222 static void set_so_opentype ( BOOL overlapped )
223 {
224 int optval = !overlapped, newval, len = sizeof (int);
225
226 ok ( setsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
227 (LPVOID) &optval, sizeof (optval) ) == 0,
228 "setting SO_OPENTYPE failed\n" );
229 ok ( getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
230 (LPVOID) &newval, &len ) == 0,
231 "getting SO_OPENTYPE failed\n" );
232 ok ( optval == newval, "failed to set SO_OPENTYPE\n" );
233 }
234
235 static int set_blocking ( SOCKET s, BOOL blocking )
236 {
237 u_long val = !blocking;
238 return ioctlsocket ( s, FIONBIO, &val );
239 }
240
241 static void fill_buffer ( char *buf, int chunk_size, int n_chunks )
242 {
243 char c, *p;
244 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
245 memset ( p, c, chunk_size );
246 }
247
248 static int test_buffer ( char *buf, int chunk_size, int n_chunks )
249 {
250 char c, *p;
251 int i;
252 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
253 {
254 for ( i = 0; i < chunk_size; i++ )
255 if ( p[i] != c ) return i;
256 }
257 return -1;
258 }
259
260 /*
261 * This routine is called when a client / server does not expect any more data,
262 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
263 */
264 static void read_zero_bytes ( SOCKET s )
265 {
266 char buf[256];
267 int tmp, n = 0;
268 while ( ( tmp = recv ( s, buf, 256, 0 ) ) > 0 )
269 n += tmp;
270 ok ( n <= 0, "garbage data received: %d bytes\n", n );
271 }
272
273 static int do_synchronous_send ( SOCKET s, char *buf, int buflen, int flags, int sendlen )
274 {
275 char* last = buf + buflen, *p;
276 int n = 1;
277 for ( p = buf; n > 0 && p < last; )
278 {
279 n = send ( s, p, min ( sendlen, last - p ), flags );
280 if (n > 0) p += n;
281 }
282 wsa_ok ( n, 0 <=, "do_synchronous_send (%x): error %d\n" );
283 return p - buf;
284 }
285
286 static int do_synchronous_recv ( SOCKET s, char *buf, int buflen, int flags, int recvlen )
287 {
288 char* last = buf + buflen, *p;
289 int n = 1;
290 for ( p = buf; n > 0 && p < last; )
291 {
292 n = recv ( s, p, min ( recvlen, last - p ), flags );
293 if (n > 0) p += n;
294 }
295 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
296 return p - buf;
297 }
298
299 static int do_synchronous_recvfrom ( SOCKET s, char *buf, int buflen, int flags, struct sockaddr *from, int *fromlen, int recvlen )
300 {
301 char* last = buf + buflen, *p;
302 int n = 1;
303 for ( p = buf; n > 0 && p < last; )
304 {
305 n = recvfrom ( s, p, min ( recvlen, last - p ), flags, from, fromlen );
306 if (n > 0) p += n;
307 }
308 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
309 return p - buf;
310 }
311
312 /*
313 * Call this routine right after thread startup.
314 * SO_OPENTYPE must by 0, regardless what the server did.
315 */
316 static void check_so_opentype (void)
317 {
318 int tmp = 1, len;
319 len = sizeof (tmp);
320 getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (LPVOID) &tmp, &len );
321 ok ( tmp == 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp );
322 }
323
324 /**************** Server utility functions ***************/
325
326 /*
327 * Even if we have closed our server socket cleanly,
328 * the OS may mark the address "in use" for some time -
329 * this happens with native Linux apps, too.
330 */
331 static void do_bind ( SOCKET s, struct sockaddr* addr, int addrlen )
332 {
333 int err, wsaerr = 0, n_try = BIND_TRIES;
334
335 while ( ( err = bind ( s, addr, addrlen ) ) != 0 &&
336 ( wsaerr = WSAGetLastError () ) == WSAEADDRINUSE &&
337 n_try-- >= 0)
338 {
339 trace ( "address in use, waiting ...\n" );
340 Sleep ( 1000 * BIND_SLEEP );
341 }
342 ok ( err == 0, "failed to bind: %d\n", wsaerr );
343 }
344
345 static void server_start ( server_params *par )
346 {
347 int i;
348 test_params *gen = par->general;
349 server_memory *mem = LocalAlloc ( LPTR, sizeof ( server_memory ) );
350
351 TlsSetValue ( tls, mem );
352 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
353 NULL, 0, par->sock_flags );
354 ok ( mem->s != INVALID_SOCKET, "Server: WSASocket failed\n" );
355
356 mem->addr.sin_family = AF_INET;
357 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
358 mem->addr.sin_port = htons ( gen->inet_port );
359
360 for (i = 0; i < MAX_CLIENTS; i++)
361 {
362 mem->sock[i].s = INVALID_SOCKET;
363 mem->sock[i].buf = LocalAlloc ( LPTR, gen->n_chunks * gen->chunk_size );
364 mem->sock[i].n_recvd = 0;
365 mem->sock[i].n_sent = 0;
366 }
367
368 if ( gen->sock_type == SOCK_STREAM )
369 do_bind ( mem->s, (struct sockaddr*) &mem->addr, sizeof (mem->addr) );
370 }
371
372 static void server_stop (void)
373 {
374 int i;
375 server_memory *mem = TlsGetValue ( tls );
376
377 for (i = 0; i < MAX_CLIENTS; i++ )
378 {
379 LocalFree ( mem->sock[i].buf );
380 if ( mem->sock[i].s != INVALID_SOCKET )
381 closesocket ( mem->sock[i].s );
382 }
383 ok ( closesocket ( mem->s ) == 0, "closesocket failed\n" );
384 LocalFree ( mem );
385 ExitThread ( GetCurrentThreadId () );
386 }
387
388 /**************** Client utilitiy functions ***************/
389
390 static void client_start ( client_params *par )
391 {
392 test_params *gen = par->general;
393 client_memory *mem = LocalAlloc (LPTR, sizeof (client_memory));
394
395 TlsSetValue ( tls, mem );
396
397 WaitForSingleObject ( server_ready, INFINITE );
398
399 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
400 NULL, 0, par->sock_flags );
401
402 mem->addr.sin_family = AF_INET;
403 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
404 mem->addr.sin_port = htons ( gen->inet_port );
405
406 ok ( mem->s != INVALID_SOCKET, "Client: WSASocket failed\n" );
407
408 mem->send_buf = LocalAlloc ( LPTR, 2 * gen->n_chunks * gen->chunk_size );
409 mem->recv_buf = mem->send_buf + gen->n_chunks * gen->chunk_size;
410 fill_buffer ( mem->send_buf, gen->chunk_size, gen->n_chunks );
411
412 SetEvent ( client_ready[client_id] );
413 /* Wait for the other clients to come up */
414 WaitForMultipleObjects ( min ( gen->n_clients, MAX_CLIENTS ), client_ready, TRUE, INFINITE );
415 }
416
417 static void client_stop (void)
418 {
419 client_memory *mem = TlsGetValue ( tls );
420 wsa_ok ( closesocket ( mem->s ), 0 ==, "closesocket error (%x): %d\n" );
421 LocalFree ( mem->send_buf );
422 LocalFree ( mem );
423 ExitThread(0);
424 }
425
426 /**************** Servers ***************/
427
428 /*
429 * simple_server: A very basic server doing synchronous IO.
430 */
431 static VOID WINAPI simple_server ( server_params *par )
432 {
433 test_params *gen = par->general;
434 server_memory *mem;
435 int pos, n_recvd, n_sent, n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
436 id = GetCurrentThreadId();
437
438 set_so_opentype ( FALSE ); /* non-overlapped */
439 server_start ( par );
440 mem = TlsGetValue ( tls );
441
442 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
443 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "simple_server (%x): listen failed: %d\n");
444
445 SetEvent ( server_ready ); /* notify clients */
446
447 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
448 {
449 /* accept a single connection */
450 tmp = sizeof ( mem->sock[0].peer );
451 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
452 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "simple_server (%x): accept failed: %d\n" );
453
454 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
455 "simple_server (%x): strange peer address\n", id );
456
457 /* Receive data & check it */
458 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
459 ok ( n_recvd == n_expected,
460 "simple_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
461 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
462 ok ( pos == -1, "simple_server (%x): test pattern error: %d\n", id, pos);
463
464 /* Echo data back */
465 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
466 ok ( n_sent == n_expected,
467 "simple_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
468
469 /* cleanup */
470 read_zero_bytes ( mem->sock[0].s );
471 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "simple_server (%x): closesocket error: %d\n" );
472 mem->sock[0].s = INVALID_SOCKET;
473 }
474
475 server_stop ();
476 }
477
478 /*
479 * oob_server: A very basic server receiving out-of-band data.
480 */
481 static VOID WINAPI oob_server ( server_params *par )
482 {
483 test_params *gen = par->general;
484 server_memory *mem;
485 u_long atmark = 0;
486 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, tmp,
487 id = GetCurrentThreadId();
488
489 set_so_opentype ( FALSE ); /* non-overlapped */
490 server_start ( par );
491 mem = TlsGetValue ( tls );
492
493 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "oob_server (%x): failed to set blocking mode: %d\n");
494 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "oob_server (%x): listen failed: %d\n");
495
496 SetEvent ( server_ready ); /* notify clients */
497
498 /* accept a single connection */
499 tmp = sizeof ( mem->sock[0].peer );
500 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
501 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "oob_server (%x): accept failed: %d\n" );
502
503 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
504 "oob_server (%x): strange peer address\n", id );
505
506 /* check initial atmark state */
507 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
508 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id, atmark );
509
510 /* Receive normal data */
511 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
512 ok ( n_recvd == n_expected,
513 "oob_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
514 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
515 ok ( pos == -1, "oob_server (%x): test pattern error: %d\n", id, pos);
516
517 /* check atmark state */
518 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
519 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id, atmark );
520
521 /* Echo data back */
522 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
523 ok ( n_sent == n_expected,
524 "oob_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
525
526 /* Receive a part of the out-of-band data and print atmark state */
527 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, 8, 0, par->buflen );
528 ok ( n_recvd == 8,
529 "oob_server (%x): received less data than expected: %d of %d\n", id, n_recvd, 8 );
530 n_expected -= 8;
531
532 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
533
534 /* Receive the rest of the out-of-band data and check atmark state */
535 do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
536
537 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
538 todo_wine ok ( atmark == 0, "oob_server (%x): not at the OOB mark: %i\n", id, atmark );
539
540 /* cleanup */
541 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "oob_server (%x): closesocket error: %d\n" );
542 mem->sock[0].s = INVALID_SOCKET;
543
544 server_stop ();
545 }
546
547 /*
548 * select_server: A non-blocking server.
549 */
550 static VOID WINAPI select_server ( server_params *par )
551 {
552 test_params *gen = par->general;
553 server_memory *mem;
554 int n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
555 id = GetCurrentThreadId(), n_connections = 0, n_sent, n_recvd,
556 n_set, delta, n_ready;
557 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
558 fd_set fds_recv, fds_send, fds_openrecv, fds_opensend;
559
560 set_so_opentype ( FALSE ); /* non-overlapped */
561 server_start ( par );
562 mem = TlsGetValue ( tls );
563
564 wsa_ok ( set_blocking ( mem->s, FALSE ), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
565 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "select_server (%x): listen failed: %d\n");
566
567 SetEvent ( server_ready ); /* notify clients */
568
569 FD_ZERO ( &fds_openrecv );
570 FD_ZERO ( &fds_recv );
571 FD_ZERO ( &fds_send );
572 FD_ZERO ( &fds_opensend );
573
574 FD_SET ( mem->s, &fds_openrecv );
575
576 while(1)
577 {
578 fds_recv = fds_openrecv;
579 fds_send = fds_opensend;
580
581 n_set = 0;
582
583 wsa_ok ( ( n_ready = select ( 0, &fds_recv, &fds_send, NULL, &timeout ) ), SOCKET_ERROR !=,
584 "select_server (%x): select() failed: %d\n" );
585
586 /* check for incoming requests */
587 if ( FD_ISSET ( mem->s, &fds_recv ) ) {
588 n_set += 1;
589
590 /* accept a single connection */
591 tmp = sizeof ( mem->sock[n_connections].peer );
592 mem->sock[n_connections].s = accept ( mem->s, (struct sockaddr*) &mem->sock[n_connections].peer, &tmp );
593 wsa_ok ( mem->sock[n_connections].s, INVALID_SOCKET !=, "select_server (%x): accept() failed: %d\n" );
594
595 ok ( mem->sock[n_connections].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
596 "select_server (%x): strange peer address\n", id );
597
598 /* add to list of open connections */
599 FD_SET ( mem->sock[n_connections].s, &fds_openrecv );
600 FD_SET ( mem->sock[n_connections].s, &fds_opensend );
601
602 n_connections++;
603 }
604
605 /* handle open requests */
606
607 for ( i = 0; i < n_connections; i++ )
608 {
609 if ( FD_ISSET( mem->sock[i].s, &fds_recv ) ) {
610 n_set += 1;
611
612 if ( mem->sock[i].n_recvd < n_expected ) {
613 /* Receive data & check it */
614 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 );
615 ok ( n_recvd != SOCKET_ERROR, "select_server (%x): error in recv(): %d\n", id, WSAGetLastError() );
616 mem->sock[i].n_recvd += n_recvd;
617
618 if ( mem->sock[i].n_recvd == n_expected ) {
619 int pos = test_buffer ( mem->sock[i].buf, gen->chunk_size, gen->n_chunks );
620 ok ( pos == -1, "select_server (%x): test pattern error: %d\n", id, pos );
621 FD_CLR ( mem->sock[i].s, &fds_openrecv );
622 }
623
624 ok ( mem->sock[i].n_recvd <= n_expected, "select_server (%x): received too many bytes: %d\n", id, mem->sock[i].n_recvd );
625 }
626 }
627
628 /* only echo back what we've received */
629 delta = mem->sock[i].n_recvd - mem->sock[i].n_sent;
630
631 if ( FD_ISSET ( mem->sock[i].s, &fds_send ) ) {
632 n_set += 1;
633
634 if ( ( delta > 0 ) && ( mem->sock[i].n_sent < n_expected ) ) {
635 /* Echo data back */
636 n_sent = send ( mem->sock[i].s, mem->sock[i].buf + mem->sock[i].n_sent, min ( delta, par->buflen ), 0 );
637 ok ( n_sent != SOCKET_ERROR, "select_server (%x): error in send(): %d\n", id, WSAGetLastError() );
638 mem->sock[i].n_sent += n_sent;
639
640 if ( mem->sock[i].n_sent == n_expected ) {
641 FD_CLR ( mem->sock[i].s, &fds_opensend );
642 }
643
644 ok ( mem->sock[i].n_sent <= n_expected, "select_server (%x): sent too many bytes: %d\n", id, mem->sock[i].n_sent );
645 }
646 }
647 }
648
649 /* check that select returned the correct number of ready sockets */
650 ok ( ( n_set == n_ready ), "select_server (%x): select() returns wrong number of ready sockets\n", id );
651
652 /* check if all clients are done */
653 if ( ( fds_opensend.fd_count == 0 )
654 && ( fds_openrecv.fd_count == 1 ) /* initial socket that accepts clients */
655 && ( n_connections == min ( gen->n_clients, MAX_CLIENTS ) ) ) {
656 break;
657 }
658 }
659
660 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
661 {
662 /* cleanup */
663 read_zero_bytes ( mem->sock[i].s );
664 wsa_ok ( closesocket ( mem->sock[i].s ), 0 ==, "select_server (%x): closesocket error: %d\n" );
665 mem->sock[i].s = INVALID_SOCKET;
666 }
667
668 server_stop ();
669 }
670
671 /**************** Clients ***************/
672
673 /*
674 * simple_client: A very basic client doing synchronous IO.
675 */
676 static VOID WINAPI simple_client ( client_params *par )
677 {
678 test_params *gen = par->general;
679 client_memory *mem;
680 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
681
682 id = GetCurrentThreadId();
683 /* wait here because we want to call set_so_opentype before creating a socket */
684 WaitForSingleObject ( server_ready, INFINITE );
685
686 check_so_opentype ();
687 set_so_opentype ( FALSE ); /* non-overlapped */
688 client_start ( par );
689 mem = TlsGetValue ( tls );
690
691 /* Connect */
692 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
693 0 ==, "simple_client (%x): connect error: %d\n" );
694 ok ( set_blocking ( mem->s, TRUE ) == 0,
695 "simple_client (%x): failed to set blocking mode\n", id );
696
697 /* send data to server */
698 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
699 ok ( n_sent == n_expected,
700 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
701
702 /* shutdown send direction */
703 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
704
705 /* Receive data echoed back & check it */
706 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, 0, par->buflen );
707 ok ( n_recvd == n_expected,
708 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
709
710 /* check data */
711 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
712 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
713
714 /* cleanup */
715 read_zero_bytes ( mem->s );
716 client_stop ();
717 }
718
719 /*
720 * oob_client: A very basic client sending out-of-band data.
721 */
722 static VOID WINAPI oob_client ( client_params *par )
723 {
724 test_params *gen = par->general;
725 client_memory *mem;
726 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
727
728 id = GetCurrentThreadId();
729 /* wait here because we want to call set_so_opentype before creating a socket */
730 WaitForSingleObject ( server_ready, INFINITE );
731
732 check_so_opentype ();
733 set_so_opentype ( FALSE ); /* non-overlapped */
734 client_start ( par );
735 mem = TlsGetValue ( tls );
736
737 /* Connect */
738 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
739 0 ==, "oob_client (%x): connect error: %d\n" );
740 ok ( set_blocking ( mem->s, TRUE ) == 0,
741 "oob_client (%x): failed to set blocking mode\n", id );
742
743 /* send data to server */
744 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
745 ok ( n_sent == n_expected,
746 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
747
748 /* Receive data echoed back & check it */
749 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, 0, par->buflen );
750 ok ( n_recvd == n_expected,
751 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
752 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
753 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
754
755 /* send out-of-band data to server */
756 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, MSG_OOB, par->buflen );
757 ok ( n_sent == n_expected,
758 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
759
760 /* shutdown send direction */
761 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
762
763 /* cleanup */
764 read_zero_bytes ( mem->s );
765 client_stop ();
766 }
767
768 /*
769 * simple_mixed_client: mixing send and recvfrom
770 */
771 static VOID WINAPI simple_mixed_client ( client_params *par )
772 {
773 test_params *gen = par->general;
774 client_memory *mem;
775 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
776 int fromLen = sizeof(mem->addr);
777 struct sockaddr test;
778
779 id = GetCurrentThreadId();
780 /* wait here because we want to call set_so_opentype before creating a socket */
781 WaitForSingleObject ( server_ready, INFINITE );
782
783 check_so_opentype ();
784 set_so_opentype ( FALSE ); /* non-overlapped */
785 client_start ( par );
786 mem = TlsGetValue ( tls );
787
788 /* Connect */
789 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
790 0 ==, "simple_client (%x): connect error: %d\n" );
791 ok ( set_blocking ( mem->s, TRUE ) == 0,
792 "simple_client (%x): failed to set blocking mode\n", id );
793
794 /* send data to server */
795 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
796 ok ( n_sent == n_expected,
797 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
798
799 /* shutdown send direction */
800 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
801
802 /* this shouldn't change, since lpFrom, is not updated on
803 connection oriented sockets - exposed by bug 11640
804 */
805 ((struct sockaddr_in*)&test)->sin_addr.s_addr = inet_addr("0.0.0.0");
806
807 /* Receive data echoed back & check it */
808 n_recvd = do_synchronous_recvfrom ( mem->s,
809 mem->recv_buf,
810 n_expected,
811 0,
812 (struct sockaddr *)&test,
813 &fromLen,
814 par->buflen );
815 ok ( n_recvd == n_expected,
816 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
817
818 /* check that lpFrom was not updated */
819 ok(0 ==
820 strcmp(
821 inet_ntoa(((struct sockaddr_in*)&test)->sin_addr),
822 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
823
824 /* check data */
825 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
826 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
827
828 /* cleanup */
829 read_zero_bytes ( mem->s );
830 client_stop ();
831 }
832
833 /*
834 * event_client: An event-driven client
835 */
836 static void WINAPI event_client ( client_params *par )
837 {
838 test_params *gen = par->general;
839 client_memory *mem;
840 int id = GetCurrentThreadId(), n_expected = gen->n_chunks * gen->chunk_size,
841 tmp, err, n;
842 HANDLE event;
843 WSANETWORKEVENTS wsa_events;
844 char *send_last, *recv_last, *send_p, *recv_p;
845 LONG mask = FD_READ | FD_WRITE | FD_CLOSE;
846
847 client_start ( par );
848
849 mem = TlsGetValue ( tls );
850
851 /* Prepare event notification for connect, makes socket nonblocking */
852 event = WSACreateEvent ();
853 WSAEventSelect ( mem->s, event, FD_CONNECT );
854 tmp = connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) );
855 if ( tmp != 0 ) {
856 err = WSAGetLastError ();
857 ok ( err == WSAEWOULDBLOCK, "event_client (%x): connect error: %d\n", id, err );
858 tmp = WaitForSingleObject ( event, INFINITE );
859 ok ( tmp == WAIT_OBJECT_0, "event_client (%x): wait for connect event failed: %d\n", id, tmp );
860 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
861 ok ( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
862 err = wsa_events.iErrorCode[ FD_CONNECT_BIT ];
863 ok ( err == 0, "event_client (%x): connect error: %d\n", id, err );
864 if ( err ) goto out;
865 }
866
867 WSAEventSelect ( mem->s, event, mask );
868
869 recv_p = mem->recv_buf;
870 recv_last = mem->recv_buf + n_expected;
871 send_p = mem->send_buf;
872 send_last = mem->send_buf + n_expected;
873
874 while ( TRUE )
875 {
876 err = WaitForSingleObject ( event, INFINITE );
877 ok ( err == WAIT_OBJECT_0, "event_client (%x): wait failed\n", id );
878
879 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
880 ok( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
881
882 if ( wsa_events.lNetworkEvents & FD_WRITE )
883 {
884 err = wsa_events.iErrorCode[ FD_WRITE_BIT ];
885 ok ( err == 0, "event_client (%x): FD_WRITE error code: %d\n", id, err );
886
887 if ( err== 0 )
888 do
889 {
890 n = send ( mem->s, send_p, min ( send_last - send_p, par->buflen ), 0 );
891 if ( n < 0 )
892 {
893 err = WSAGetLastError ();
894 ok ( err == WSAEWOULDBLOCK, "event_client (%x): send error: %d\n", id, err );
895 }
896 else
897 send_p += n;
898 }
899 while ( n >= 0 && send_p < send_last );
900
901 if ( send_p == send_last )
902 {
903 shutdown ( mem->s, SD_SEND );
904 mask &= ~FD_WRITE;
905 WSAEventSelect ( mem->s, event, mask );
906 }
907 }
908 if ( wsa_events.lNetworkEvents & FD_READ )
909 {
910 err = wsa_events.iErrorCode[ FD_READ_BIT ];
911 ok ( err == 0, "event_client (%x): FD_READ error code: %d\n", id, err );
912 if ( err != 0 ) break;
913
914 /* First read must succeed */
915 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
916 wsa_ok ( n, 0 <=, "event_client (%x): recv error: %d\n" );
917
918 while ( n >= 0 ) {
919 recv_p += n;
920 if ( recv_p == recv_last )
921 {
922 mask &= ~FD_READ;
923 WSAEventSelect ( mem->s, event, mask );
924 break;
925 }
926 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
927 ok(n >= 0 || WSAGetLastError() == WSAEWOULDBLOCK,
928 "event_client (%x): got error %u\n", id, WSAGetLastError());
929
930 }
931 }
932 if ( wsa_events.lNetworkEvents & FD_CLOSE )
933 {
934 err = wsa_events.iErrorCode[ FD_CLOSE_BIT ];
935 ok ( err == 0, "event_client (%x): FD_CLOSE error code: %d\n", id, err );
936 break;
937 }
938 }
939
940 n = send_p - mem->send_buf;
941 ok ( send_p == send_last,
942 "simple_client (%x): sent less data than expected: %d of %d\n", id, n, n_expected );
943 n = recv_p - mem->recv_buf;
944 ok ( recv_p == recv_last,
945 "simple_client (%x): received less data than expected: %d of %d\n", id, n, n_expected );
946 n = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
947 ok ( n == -1, "event_client (%x): test pattern error: %d\n", id, n);
948
949 out:
950 WSACloseEvent ( event );
951 client_stop ();
952 }
953
954 /* Tests for WSAStartup */
955 static void test_WithoutWSAStartup(void)
956 {
957 DWORD err;
958
959 WSASetLastError(0xdeadbeef);
960 ok(WSASocketA(0, 0, 0, NULL, 0, 0) == INVALID_SOCKET, "WSASocketA should have failed\n");
961 err = WSAGetLastError();
962 ok(err == WSANOTINITIALISED, "Expected 10093, received %d\n", err);
963
964 WSASetLastError(0xdeadbeef);
965 ok(gethostbyname("localhost") == NULL, "gethostbyname() succeeded unexpectedly\n");
966 err = WSAGetLastError();
967 ok(err == WSANOTINITIALISED, "Expected 10093, received %d\n", err);
968 }
969
970 static void test_WithWSAStartup(void)
971 {
972 WSADATA data;
973 WORD version = MAKEWORD( 2, 2 );
974 INT res, socks, i, j;
975 SOCKET sock;
976 LPVOID ptr;
977 struct
978 {
979 SOCKET src, dst, dup_src, dup_dst;
980 } pairs[32];
981 DWORD error;
982
983 res = WSAStartup( version, &data );
984 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
985
986 ptr = gethostbyname("localhost");
987 ok(ptr != NULL, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
988
989 /* Alloc some sockets to check if they are destroyed on WSACleanup */
990 for (socks = 0; socks < ARRAY_SIZE(pairs); socks++)
991 {
992 WSAPROTOCOL_INFOA info;
993 tcp_socketpair(&pairs[socks].src, &pairs[socks].dst);
994
995 memset(&info, 0, sizeof(info));
996 ok(!WSADuplicateSocketA(pairs[socks].src, GetCurrentProcessId(), &info),
997 "WSADuplicateSocketA should have worked\n");
998 pairs[socks].dup_src = WSASocketA(0, 0, 0, &info, 0, 0);
999 ok(pairs[socks].dup_src != SOCKET_ERROR, "expected != -1\n");
1000
1001 memset(&info, 0, sizeof(info));
1002 ok(!WSADuplicateSocketA(pairs[socks].dst, GetCurrentProcessId(), &info),
1003 "WSADuplicateSocketA should have worked\n");
1004 pairs[socks].dup_dst = WSASocketA(0, 0, 0, &info, 0, 0);
1005 ok(pairs[socks].dup_dst != SOCKET_ERROR, "expected != -1\n");
1006 }
1007
1008 res = send(pairs[0].src, "TEST", 4, 0);
1009 ok(res == 4, "send failed with error %d\n", WSAGetLastError());
1010
1011 WSACleanup();
1012
1013 res = WSAStartup( version, &data );
1014 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
1015
1016 /* show that sockets are destroyed automatically after WSACleanup */
1017 SetLastError(0xdeadbeef);
1018 res = send(pairs[0].src, "TEST", 4, 0);
1019 error = WSAGetLastError();
1020 ok(res == SOCKET_ERROR, "send should have failed\n");
1021 ok(error == WSAENOTSOCK, "expected 10038, got %d\n", error);
1022
1023 SetLastError(0xdeadbeef);
1024 res = send(pairs[0].dst, "TEST", 4, 0);
1025 error = WSAGetLastError();
1026 ok(res == SOCKET_ERROR, "send should have failed\n");
1027 ok(error == WSAENOTSOCK, "expected 10038, got %d\n", error);
1028
1029 /* Check that all sockets were destroyed */
1030 for (i = 0; i < socks; i++)
1031 {
1032 for (j = 0; j < 4; j++)
1033 {
1034 struct sockaddr_in saddr;
1035 int size = sizeof(saddr);
1036 switch(j)
1037 {
1038 case 0: sock = pairs[i].src; break;
1039 case 1: sock = pairs[i].dup_src; break;
1040 case 2: sock = pairs[i].dst; break;
1041 case 3: sock = pairs[i].dup_dst; break;
1042 }
1043
1044 SetLastError(0xdeadbeef);
1045 res = getsockname(sock, (struct sockaddr *)&saddr, &size);
1046 error = WSAGetLastError();
1047 ok(res == SOCKET_ERROR, "Test[%d]: getsockname should have failed\n", i);
1048 if (res == SOCKET_ERROR)
1049 ok(error == WSAENOTSOCK, "Test[%d]: expected 10038, got %d\n", i, error);
1050 }
1051 }
1052
1053 /* While wine is not fixed, close all sockets manually */
1054 for (i = 0; i < socks; i++)
1055 {
1056 closesocket(pairs[i].src);
1057 closesocket(pairs[i].dst);
1058 closesocket(pairs[i].dup_src);
1059 closesocket(pairs[i].dup_dst);
1060 }
1061
1062 res = WSACleanup();
1063 ok(res == 0, "expected 0, got %d\n", res);
1064 WSASetLastError(0xdeadbeef);
1065 res = WSACleanup();
1066 error = WSAGetLastError();
1067 ok ( res == SOCKET_ERROR && error == WSANOTINITIALISED,
1068 "WSACleanup returned %d WSAGetLastError is %d\n", res, error);
1069 }
1070
1071 /**************** Main program utility functions ***************/
1072
1073 static void Init (void)
1074 {
1075 WORD ver = MAKEWORD (2, 2);
1076 WSADATA data;
1077 HMODULE hws2_32 = GetModuleHandleA("ws2_32.dll"), ntdll;
1078
1079 pWSAPoll = (void *)GetProcAddress(hws2_32, "WSAPoll");
1080
1081 ntdll = LoadLibraryA("ntdll.dll");
1082 if (ntdll)
1083 pNtClose = (void *)GetProcAddress(ntdll, "NtClose");
1084
1085 ok ( WSAStartup ( ver, &data ) == 0, "WSAStartup failed\n" );
1086 tls = TlsAlloc();
1087 }
1088
1089 static void Exit (void)
1090 {
1091 INT ret, err;
1092 TlsFree ( tls );
1093 ret = WSACleanup();
1094 err = WSAGetLastError();
1095 ok ( ret == 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret, err);
1096 }
1097
1098 static void StartServer (LPTHREAD_START_ROUTINE routine,
1099 test_params *general, server_params *par)
1100 {
1101 par->general = general;
1102 thread[0] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[0] );
1103 ok ( thread[0] != NULL, "Failed to create server thread\n" );
1104 }
1105
1106 static void StartClients (LPTHREAD_START_ROUTINE routine,
1107 test_params *general, client_params *par)
1108 {
1109 int i;
1110 par->general = general;
1111 for ( i = 1; i <= min ( general->n_clients, MAX_CLIENTS ); i++ )
1112 {
1113 client_id = i - 1;
1114 thread[i] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[i] );
1115 ok ( thread[i] != NULL, "Failed to create client thread\n" );
1116 /* Make sure the client is up and running */
1117 WaitForSingleObject ( client_ready[client_id], INFINITE );
1118 };
1119 }
1120
1121 static void do_test( test_setup *test )
1122 {
1123 DWORD i, n = min (test->general.n_clients, MAX_CLIENTS);
1124 DWORD wait;
1125
1126 server_ready = CreateEventA ( NULL, TRUE, FALSE, NULL );
1127 for (i = 0; i <= n; i++)
1128 client_ready[i] = CreateEventA ( NULL, TRUE, FALSE, NULL );
1129
1130 StartServer ( test->srv, &test->general, &test->srv_params );
1131 StartClients ( test->clt, &test->general, &test->clt_params );
1132 WaitForSingleObject ( server_ready, INFINITE );
1133
1134 wait = WaitForMultipleObjects ( 1 + n, thread, TRUE, 1000 * TEST_TIMEOUT );
1135 ok(!wait, "wait failed, error %u\n", wait);
1136
1137 CloseHandle ( server_ready );
1138 for (i = 0; i <= n; i++)
1139 CloseHandle ( client_ready[i] );
1140 }
1141
1142 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1143 /* optname = SO_LINGER */
1144 static const LINGER linger_testvals[] = {
1145 {0,0},
1146 {0,73},
1147 {1,0},
1148 {5,189}
1149 };
1150
1151 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1152 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1153 bug in the linux kernel (fixed in 2.6.8) */
1154 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1155
1156 static void test_set_getsockopt(void)
1157 {
1158 SOCKET s, s2;
1159 int i, err, lasterr;
1160 int timeout;
1161 LINGER lingval;
1162 int size;
1163 WSAPROTOCOL_INFOA infoA;
1164 WSAPROTOCOL_INFOW infoW;
1165 char providername[WSAPROTOCOL_LEN + 1];
1166 DWORD value;
1167 struct _prottest
1168 {
1169 int family, type, proto;
1170 } prottest[] = {
1171 {AF_INET, SOCK_STREAM, IPPROTO_TCP},
1172 {AF_INET, SOCK_DGRAM, IPPROTO_UDP},
1173 {AF_INET6, SOCK_STREAM, IPPROTO_TCP},
1174 {AF_INET6, SOCK_DGRAM, IPPROTO_UDP}
1175 };
1176 union _csspace
1177 {
1178 CSADDR_INFO cs;
1179 char space[128];
1180 } csinfoA, csinfoB;
1181
1182 s = socket(AF_INET, SOCK_STREAM, 0);
1183 ok(s!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1184 if( s == INVALID_SOCKET) return;
1185 /* SO_RCVTIMEO */
1186 timeout = SOCKTIMEOUT1;
1187 size = sizeof(timeout);
1188 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1189 if( !err)
1190 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1191 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1192 ok( timeout == SOCKTIMEOUT1, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1193
1194 timeout = 0;
1195 size = sizeof(timeout);
1196 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1197 if( !err)
1198 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1199 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1200 ok( timeout == 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1201
1202 /* SO_SNDTIMEO */
1203 timeout = SOCKTIMEOUT2; /* 997 seconds. See remark above */
1204 size = sizeof(timeout);
1205 err = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, size);
1206 if( !err)
1207 err = getsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, &size);
1208 ok( !err, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1209 ok( timeout == SOCKTIMEOUT2, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout);
1210
1211 /* SO_SNDBUF */
1212 value = 4096;
1213 size = sizeof(value);
1214 err = setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&value, size);
1215 ok( !err, "setsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1216 value = 0xdeadbeef;
1217 err = getsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&value, &size);
1218 ok( !err, "getsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1219 ok( value == 4096, "expected 4096, got %u\n", value );
1220
1221 /* SO_RCVBUF */
1222 value = 4096;
1223 size = sizeof(value);
1224 err = setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, size);
1225 ok( !err, "setsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1226 value = 0xdeadbeef;
1227 err = getsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, &size);
1228 ok( !err, "getsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1229 ok( value == 4096, "expected 4096, got %u\n", value );
1230
1231 /* SO_LINGER */
1232 for( i = 0; i < ARRAY_SIZE(linger_testvals);i++) {
1233 size = sizeof(lingval);
1234 lingval = linger_testvals[i];
1235 err = setsockopt(s, SOL_SOCKET, SO_LINGER, (char *)&lingval, size);
1236 ok(!err, "Test %u: failed to set SO_LINGER, error %u\n", i, WSAGetLastError());
1237 err = getsockopt(s, SOL_SOCKET, SO_LINGER, (char *)&lingval, &size);
1238 ok(!err, "Test %u: failed to get SO_LINGER, error %u\n", i, WSAGetLastError());
1239 ok(!lingval.l_onoff == !linger_testvals[i].l_onoff, "Test %u: expected %d, got %d\n",
1240 i, linger_testvals[i].l_onoff, lingval.l_onoff);
1241 if (lingval.l_onoff)
1242 ok(lingval.l_linger == linger_testvals[i].l_linger, "Test %u: expected %d, got %d\n",
1243 i, linger_testvals[i].l_linger, lingval.l_linger);
1244 }
1245
1246 size = sizeof(lingval);
1247 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, size);
1248 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1249 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1250 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, 0);
1251 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1252 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1253
1254 size = sizeof(BOOL);
1255 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, size);
1256 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1257 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1258 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, 0);
1259 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1260 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1261
1262 /* Test for erroneously passing a value instead of a pointer as optval */
1263 size = sizeof(char);
1264 err = setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)1, size);
1265 ok(err == SOCKET_ERROR, "setsockopt with optval being a value passed "
1266 "instead of failing.\n");
1267 lasterr = WSAGetLastError();
1268 ok(lasterr == WSAEFAULT, "setsockopt with optval being a value "
1269 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1270 lasterr, WSAEFAULT);
1271
1272 /* SO_RCVTIMEO with invalid values for level */
1273 size = sizeof(timeout);
1274 timeout = SOCKTIMEOUT1;
1275 SetLastError(0xdeadbeef);
1276 err = setsockopt(s, 0xffffffff, SO_RCVTIMEO, (char *) &timeout, size);
1277 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1278 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1279 err, WSAGetLastError());
1280
1281 timeout = SOCKTIMEOUT1;
1282 SetLastError(0xdeadbeef);
1283 err = setsockopt(s, 0x00008000, SO_RCVTIMEO, (char *) &timeout, size);
1284 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1285 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1286 err, WSAGetLastError());
1287
1288 /* Test SO_ERROR set/get */
1289 SetLastError(0xdeadbeef);
1290 i = 1234;
1291 err = setsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, size);
1292 todo_wine
1293 ok( !err && !WSAGetLastError(),
1294 "got %d with %d (expected 0 with 0)\n",
1295 err, WSAGetLastError());
1296
1297 SetLastError(0xdeadbeef);
1298 i = 4321;
1299 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1300 ok( !err && !WSAGetLastError(),
1301 "got %d with %d (expected 0 with 0)\n",
1302 err, WSAGetLastError());
1303 todo_wine
1304 ok (i == 1234, "got %d (expected 1234)\n", i);
1305
1306 /* Test invalid optlen */
1307 SetLastError(0xdeadbeef);
1308 size = 1;
1309 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1310 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEFAULT),
1311 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1312 err, WSAGetLastError());
1313
1314 closesocket(s);
1315 /* Test with the closed socket */
1316 SetLastError(0xdeadbeef);
1317 size = sizeof(i);
1318 i = 1234;
1319 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1320 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAENOTSOCK),
1321 "got %d with %d (expected SOCKET_ERROR with WSAENOTSOCK)\n",
1322 err, WSAGetLastError());
1323 ok (i == 1234, "expected 1234, got %d\n", i);
1324
1325 /* Test WS_IP_MULTICAST_TTL with 8, 16, 24 and 32 bits values */
1326 s = socket(AF_INET, SOCK_DGRAM, 0);
1327 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1328 size = sizeof(i);
1329 i = 0x0000000a;
1330 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &i, size);
1331 if (!err)
1332 {
1333 for (i = 0; i < 4; i++)
1334 {
1335 int k, j;
1336 const int tests[] = {0xffffff0a, 0xffff000b, 0xff00000c, 0x0000000d};
1337 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &tests[i], i + 1);
1338 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1339 err = getsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &k, &size);
1340 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1341 j = i != 3 ? tests[i] & ((1 << (i + 1) * 8) - 1) : tests[i];
1342 ok(k == j, "Test [%d] Expected 0x%x, got 0x%x\n", i, j, k);
1343 }
1344 }
1345 else
1346 win_skip("IP_MULTICAST_TTL is unsupported\n");
1347 closesocket(s);
1348
1349 /* test SO_PROTOCOL_INFOA invalid parameters */
1350 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1351 "getsockopt should have failed\n");
1352 err = WSAGetLastError();
1353 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1354 size = sizeof(WSAPROTOCOL_INFOA);
1355 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1356 "getsockopt should have failed\n");
1357 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1358 err = WSAGetLastError();
1359 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1360 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1361 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1362 "getsockopt should have failed\n");
1363 err = WSAGetLastError();
1364 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1365 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, NULL),
1366 "getsockopt should have failed\n");
1367 err = WSAGetLastError();
1368 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1369 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, &size),
1370 "getsockopt should have failed\n");
1371 err = WSAGetLastError();
1372 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1373 size = sizeof(WSAPROTOCOL_INFOA) / 2;
1374 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1375 "getsockopt should have failed\n");
1376 err = WSAGetLastError();
1377 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1378 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1379 size = sizeof(WSAPROTOCOL_INFOA) * 2;
1380 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1381 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1382 ok(size == sizeof(WSAPROTOCOL_INFOA) * 2, "got size %d\n", size);
1383
1384 closesocket(s);
1385
1386 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1387 for (i = 0; i < ARRAY_SIZE(prottest); i++)
1388 {
1389 int k;
1390
1391 s = socket(prottest[i].family, prottest[i].type, prottest[i].proto);
1392 if (s == INVALID_SOCKET && prottest[i].family == AF_INET6) continue;
1393
1394 ok(s != INVALID_SOCKET, "Failed to create socket: %d\n",
1395 WSAGetLastError());
1396
1397 /* compare both A and W version */
1398 infoA.szProtocol[0] = 0;
1399 size = sizeof(WSAPROTOCOL_INFOA);
1400 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1401 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1402 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1403
1404 infoW.szProtocol[0] = 0;
1405 size = sizeof(WSAPROTOCOL_INFOW);
1406 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOW, (char *) &infoW, &size);
1407 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1408 ok(size == sizeof(WSAPROTOCOL_INFOW), "got size %d\n", size);
1409
1410 ok(infoA.szProtocol[0], "WSAPROTOCOL_INFOA was not filled\n");
1411 ok(infoW.szProtocol[0], "WSAPROTOCOL_INFOW was not filled\n");
1412
1413 WideCharToMultiByte(CP_ACP, 0, infoW.szProtocol, -1,
1414 providername, sizeof(providername), NULL, NULL);
1415 ok(!strcmp(infoA.szProtocol,providername),
1416 "different provider names '%s' != '%s'\n", infoA.szProtocol, providername);
1417
1418 ok(!memcmp(&infoA, &infoW, FIELD_OFFSET(WSAPROTOCOL_INFOA, szProtocol)),
1419 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1420
1421 /* Remove IF when WSAEnumProtocols support IPV6 data */
1422 ok(infoA.iAddressFamily == prottest[i].family, "socket family invalid, expected %d received %d\n",
1423 prottest[i].family, infoA.iAddressFamily);
1424 ok(infoA.iSocketType == prottest[i].type, "socket type invalid, expected %d received %d\n",
1425 prottest[i].type, infoA.iSocketType);
1426 ok(infoA.iProtocol == prottest[i].proto, "socket protocol invalid, expected %d received %d\n",
1427 prottest[i].proto, infoA.iProtocol);
1428
1429 /* IP_HDRINCL is supported only on SOCK_RAW but passed to SOCK_DGRAM by Impossible Creatures */
1430 size = sizeof(i);
1431 k = 1;
1432 SetLastError(0xdeadbeef);
1433 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1434 if (err == -1) /* >= Vista */
1435 {
1436 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %d\n", GetLastError());
1437 k = 99;
1438 SetLastError(0xdeadbeef);
1439 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1440 ok(err == -1, "Expected -1, got %d\n", err);
1441 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %d\n", GetLastError());
1442 ok(k == 99, "Expected 99, got %d\n", k);
1443
1444 size = sizeof(k);
1445 k = 0;
1446 SetLastError(0xdeadbeef);
1447 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1448 ok(err == -1, "Expected -1, got %d\n", err);
1449 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %d\n", GetLastError());
1450 k = 99;
1451 SetLastError(0xdeadbeef);
1452 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1453 ok(err == -1, "Expected -1, got %d\n", err);
1454 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %d\n", GetLastError());
1455 ok(k == 99, "Expected 99, got %d\n", k);
1456 }
1457 else /* <= 2003 the tests differ between TCP and UDP, UDP silently accepts */
1458 {
1459 SetLastError(0xdeadbeef);
1460 k = 99;
1461 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1462 if (prottest[i].type == SOCK_DGRAM)
1463 {
1464 ok(err == 0, "Expected 0, got %d\n", err);
1465 ok(k == 1, "Expected 1, got %d\n", k);
1466 }
1467 else
1468 {
1469 /* contratry to what we could expect the function returns error but k is changed */
1470 ok(err == -1, "Expected -1, got %d\n", err);
1471 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %d\n", GetLastError());
1472 ok(k == 0, "Expected 0, got %d\n", k);
1473 }
1474
1475 k = 0;
1476 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1477 ok(err == 0, "Expected 0, got %d\n", err);
1478
1479 k = 99;
1480 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1481 if (prottest[i].type == SOCK_DGRAM)
1482 {
1483 ok(err == 0, "Expected 0, got %d\n", err);
1484 ok(k == 0, "Expected 0, got %d\n", k);
1485 }
1486 else
1487 {
1488 /* contratry to what we could expect the function returns error but k is changed */
1489 ok(err == -1, "Expected -1, got %d\n", err);
1490 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %d\n", GetLastError());
1491 ok(k == 0, "Expected 0, got %d\n", k);
1492 }
1493 }
1494
1495 closesocket(s);
1496 }
1497
1498 /* Test SO_BSP_STATE - Present only in >= Win 2008 */
1499 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1500 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1501 s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1502 ok(s2 != INVALID_SOCKET, "Failed to create socket\n");
1503
1504 SetLastError(0xdeadbeef);
1505 size = sizeof(csinfoA);
1506 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1507 if (!err)
1508 {
1509 struct sockaddr_in saddr;
1510 memset(&saddr, 0, sizeof(saddr));
1511 saddr.sin_family = AF_INET;
1512 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1513
1514 /* Socket is not bound, no information provided */
1515 ok(!csinfoA.cs.LocalAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.LocalAddr.iSockaddrLength);
1516 ok(csinfoA.cs.LocalAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.LocalAddr.lpSockaddr);
1517 /* Socket is not connected, no information provided */
1518 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.RemoteAddr.iSockaddrLength);
1519 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.RemoteAddr.lpSockaddr);
1520
1521 err = bind(s, (struct sockaddr*)&saddr, sizeof(saddr));
1522 ok(!err, "Expected 0, got %d\n", err);
1523 size = sizeof(csinfoA);
1524 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1525 ok(!err, "Expected 0, got %d\n", err);
1526
1527 /* Socket is bound */
1528 ok(csinfoA.cs.LocalAddr.iSockaddrLength, "Expected non-zero\n");
1529 ok(csinfoA.cs.LocalAddr.lpSockaddr != NULL, "Expected non-null\n");
1530 /* Socket is not connected, no information provided */
1531 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.RemoteAddr.iSockaddrLength);
1532 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.RemoteAddr.lpSockaddr);
1533
1534 err = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1535 ok(!err, "Expected 0, got %d\n", err);
1536 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1537 ok(!err, "Expected 0, got %d\n", err);
1538 err = listen(s2, 1);
1539 ok(!err, "Expected 0, got %d\n", err);
1540 err = connect(s, (struct sockaddr*)&saddr, sizeof(saddr));
1541 ok(!err, "Expected 0, got %d\n", err);
1542 size = sizeof(saddr);
1543 err = accept(s2, (struct sockaddr*)&saddr, &size);
1544 ok(err != INVALID_SOCKET, "Failed to accept socket\n");
1545 closesocket(s2);
1546 s2 = err;
1547
1548 size = sizeof(csinfoA);
1549 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1550 ok(!err, "Expected 0, got %d\n", err);
1551 err = getsockopt(s2, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoB, &size);
1552 ok(!err, "Expected 0, got %d\n", err);
1553 ok(size == sizeof(csinfoA), "Got %d\n", size);
1554 size = sizeof(saddr);
1555 ok(size == csinfoA.cs.LocalAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1556 csinfoA.cs.LocalAddr.iSockaddrLength);
1557 ok(size == csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1558 csinfoA.cs.RemoteAddr.iSockaddrLength);
1559 ok(!memcmp(csinfoA.cs.LocalAddr.lpSockaddr, csinfoB.cs.RemoteAddr.lpSockaddr, size),
1560 "Expected matching addresses\n");
1561 ok(!memcmp(csinfoB.cs.LocalAddr.lpSockaddr, csinfoA.cs.RemoteAddr.lpSockaddr, size),
1562 "Expected matching addresses\n");
1563 ok(csinfoA.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1564 ok(csinfoB.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1565 ok(csinfoA.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1566 ok(csinfoB.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1567
1568 err = getpeername(s, (struct sockaddr *)&saddr, &size);
1569 ok(!err, "Expected 0, got %d\n", err);
1570 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1571 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1572 err = getpeername(s2, (struct sockaddr *)&saddr, &size);
1573 ok(!err, "Expected 0, got %d\n", err);
1574 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1575 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1576 err = getsockname(s, (struct sockaddr *)&saddr, &size);
1577 ok(!err, "Expected 0, got %d\n", err);
1578 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1579 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1580 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1581 ok(!err, "Expected 0, got %d\n", err);
1582 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1583 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1584
1585 SetLastError(0xdeadbeef);
1586 size = sizeof(CSADDR_INFO);
1587 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1588 ok(err, "Expected non-zero\n");
1589 ok(size == sizeof(CSADDR_INFO), "Got %d\n", size);
1590 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %d\n", GetLastError());
1591
1592 /* At least for IPv4 the size is exactly 56 bytes */
1593 size = sizeof(*csinfoA.cs.LocalAddr.lpSockaddr) * 2 + sizeof(csinfoA.cs);
1594 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1595 ok(!err, "Expected 0, got %d\n", err);
1596 size--;
1597 SetLastError(0xdeadbeef);
1598 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1599 ok(err, "Expected non-zero\n");
1600 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %d\n", GetLastError());
1601 }
1602 else
1603 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %d\n", GetLastError());
1604
1605 closesocket(s);
1606 closesocket(s2);
1607
1608 for (i = 0; i < 2; i++)
1609 {
1610 int family, level;
1611
1612 if (i)
1613 {
1614 family = AF_INET6;
1615 level = IPPROTO_IPV6;
1616 }
1617 else
1618 {
1619 family = AF_INET;
1620 level = IPPROTO_IP;
1621 }
1622
1623 s = socket(family, SOCK_DGRAM, 0);
1624 if (s == INVALID_SOCKET && i)
1625 {
1626 skip("IPv6 is not supported\n");
1627 break;
1628 }
1629 ok(s != INVALID_SOCKET, "socket failed with error %d\n", GetLastError());
1630
1631 size = sizeof(value);
1632 value = 0xdead;
1633 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1634 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1635 ok(value == 0, "Expected 0, got %d\n", value);
1636
1637 size = sizeof(value);
1638 value = 1;
1639 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
1640 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1641
1642 value = 0xdead;
1643 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1644 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1645 ok(value == 1, "Expected 1, got %d\n", value);
1646
1647 size = sizeof(value);
1648 value = 0xdead;
1649 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
1650 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1651
1652 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1653 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1654 ok(value == 1, "Expected 1, got %d\n", value);
1655
1656 closesocket(s);
1657
1658 s = socket(family, SOCK_STREAM, 0);
1659 ok(s != INVALID_SOCKET, "socket failed with error %d\n", GetLastError());
1660
1661 size = sizeof(value);
1662 value = 0xdead;
1663 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1664 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1665 ok(value == 1 || broken(value == 0) /* < vista */, "Expected 1, got %d\n", value);
1666
1667 size = sizeof(value);
1668 value = 0;
1669 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
1670 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1671
1672 value = 0xdead;
1673 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1674 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1675 ok(value == 0, "Expected 0, got %d\n", value);
1676
1677 closesocket(s);
1678
1679 s = socket(family, SOCK_RAW, 0);
1680 if (s == INVALID_SOCKET)
1681 {
1682 if (WSAGetLastError() == WSAEACCES) skip("SOCK_RAW is not available\n");
1683 else if (i) skip("IPv6 is not supported\n");
1684 break;
1685 }
1686 ok(s != INVALID_SOCKET, "socket failed with error %d\n", GetLastError());
1687
1688 size = sizeof(value);
1689 value = 0xdead;
1690 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1691 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1692 ok(value == 0, "Expected 0, got %d\n", value);
1693
1694 size = sizeof(value);
1695 value = 1;
1696 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
1697 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1698
1699 value = 0xdead;
1700 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1701 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1702 ok(value == 1, "Expected 1, got %d\n", value);
1703
1704 closesocket(s);
1705 }
1706 }
1707
1708 static void test_so_reuseaddr(void)
1709 {
1710 struct sockaddr_in saddr;
1711 SOCKET s1,s2;
1712 unsigned int rc,reuse;
1713 int size;
1714 DWORD err;
1715
1716 saddr.sin_family = AF_INET;
1717 saddr.sin_port = htons(SERVERPORT+1);
1718 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1719
1720 s1=socket(AF_INET, SOCK_STREAM, 0);
1721 ok(s1!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1722 rc = bind(s1, (struct sockaddr*)&saddr, sizeof(saddr));
1723 ok(rc!=SOCKET_ERROR, "bind(s1) failed error: %d\n", WSAGetLastError());
1724
1725 s2=socket(AF_INET, SOCK_STREAM, 0);
1726 ok(s2!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1727
1728 reuse=0x1234;
1729 size=sizeof(reuse);
1730 rc=getsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, &size );
1731 ok(rc==0 && reuse==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc,reuse);
1732
1733 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1734 ok(rc==SOCKET_ERROR, "bind() succeeded\n");
1735
1736 reuse = 1;
1737 rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
1738 ok(rc==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1739
1740 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1741 * a port immediately after closing another socket on that port, so
1742 * basically following the BSD socket semantics here. */
1743 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1744 if(rc==0)
1745 {
1746 int s3=socket(AF_INET, SOCK_STREAM, 0), s4;
1747
1748 /* If we could bind again in the same port this is Windows version <= XP.
1749 * Lets test if we can really connect to one of them. */
1750 set_blocking(s1, FALSE);
1751 set_blocking(s2, FALSE);
1752 rc = listen(s1, 1);
1753 ok(!rc, "listen() failed with error: %d\n", WSAGetLastError());
1754 rc = listen(s2, 1);
1755 ok(!rc, "listen() failed with error: %d\n", WSAGetLastError());
1756 rc = connect(s3, (struct sockaddr*)&saddr, sizeof(saddr));
1757 ok(!rc, "connecting to accepting socket failed %d\n", WSAGetLastError());
1758
1759 /* the delivery of the connection is random so we need to try on both sockets */
1760 size = sizeof(saddr);
1761 s4 = accept(s1, (struct sockaddr*)&saddr, &size);
1762 if(s4 == INVALID_SOCKET)
1763 s4 = accept(s2, (struct sockaddr*)&saddr, &size);
1764 ok(s4 != INVALID_SOCKET, "none of the listening sockets could get the connection\n");
1765
1766 closesocket(s1);
1767 closesocket(s3);
1768 closesocket(s4);
1769 }
1770 else
1771 {
1772 err = WSAGetLastError();
1773 ok(err==WSAEACCES, "expected 10013, got %d\n", err);
1774
1775 closesocket(s1);
1776 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1777 ok(rc==0, "bind() failed error: %d\n", WSAGetLastError());
1778 }
1779
1780 closesocket(s2);
1781 }
1782
1783 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
1784
1785 static unsigned int got_ip_pktinfo_apc;
1786
1787 static void WINAPI ip_pktinfo_apc(DWORD error, DWORD size, OVERLAPPED *overlapped, DWORD flags)
1788 {
1789 ok(error == WSAEMSGSIZE, "got error %u\n", error);
1790 ok(size == 6, "got size %u\n", size);
1791 ok(!flags, "got flags %#x\n", flags);
1792 ++got_ip_pktinfo_apc;
1793 }
1794
1795 static void test_ip_pktinfo(void)
1796 {
1797 ULONG addresses[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY)};
1798 char recvbuf[10], pktbuf[512], msg[] = "HELLO";
1799 struct sockaddr_in s1addr, s2addr, s3addr;
1800 LPFN_WSARECVMSG pWSARecvMsg = NULL;
1801 unsigned int rc, yes = 1;
1802 BOOL foundhdr;
1803 DWORD dwBytes, dwSize, dwFlags;
1804 socklen_t addrlen;
1805 WSACMSGHDR *cmsg;
1806 WSAOVERLAPPED ov;
1807 WSABUF iovec[1];
1808 SOCKET s1, s2;
1809 WSAMSG hdr;
1810 int i, err;
1811
1812 memset(&ov, 0, sizeof(ov));
1813 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
1814
1815 memset(&hdr, 0x00, sizeof(hdr));
1816 s1addr.sin_family = AF_INET;
1817 s1addr.sin_port = htons(0);
1818 /* Note: s1addr.sin_addr is set below */
1819 iovec[0].buf = recvbuf;
1820 iovec[0].len = sizeof(recvbuf);
1821 hdr.name = (struct sockaddr*)&s3addr;
1822 hdr.namelen = sizeof(s3addr);
1823 hdr.lpBuffers = &iovec[0];
1824 hdr.dwBufferCount = 1;
1825 hdr.Control.buf = pktbuf;
1826 /* Note: hdr.Control.len is set below */
1827 hdr.dwFlags = 0;
1828
1829 for (i=0;i<ARRAY_SIZE(addresses);i++)
1830 {
1831 s1addr.sin_addr.s_addr = addresses[i];
1832
1833 /* Build "server" side socket */
1834 s1=socket(AF_INET, SOCK_DGRAM, 0);
1835 ok(s1 != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
1836
1837 /* Obtain the WSARecvMsg function */
1838 rc = WSAIoctl(s1, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
1839 &pWSARecvMsg, sizeof(pWSARecvMsg), &dwBytes, NULL, NULL);
1840 ok(!rc, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
1841
1842 /* Setup the server side socket */
1843 rc=bind(s1, (struct sockaddr*)&s1addr, sizeof(s1addr));
1844 ok(rc != SOCKET_ERROR, "bind() failed error: %d\n", WSAGetLastError());
1845
1846 /* Build "client" side socket */
1847 addrlen = sizeof(s2addr);
1848 rc = getsockname(s1, (struct sockaddr *) &s2addr, &addrlen);
1849 ok(!rc, "failed to get address, error %u\n", WSAGetLastError());
1850 s2addr.sin_addr.s_addr = addresses[0]; /* Always target the local adapter address */
1851 s2=socket(AF_INET, SOCK_DGRAM, 0);
1852 ok(s2 != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
1853
1854 /* Test an empty message header */
1855 rc=pWSARecvMsg(s1, NULL, NULL, NULL, NULL);
1856 err=WSAGetLastError();
1857 ok(rc == SOCKET_ERROR && err == WSAEFAULT, "WSARecvMsg() failed error: %d (ret = %d)\n", err, rc);
1858
1859 /* Test that when no control data arrives, a 0-length NULL-valued control buffer should succeed */
1860 SetLastError(0xdeadbeef);
1861 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
1862 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
1863 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
1864 hdr.Control.buf = NULL;
1865 hdr.Control.len = 0;
1866 rc=pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
1867 ok(rc == 0, "WSARecvMsg() failed error: %d\n", WSAGetLastError());
1868 hdr.Control.buf = pktbuf;
1869
1870 /* Now start IP_PKTINFO for future tests */
1871 rc=setsockopt(s1, IPPROTO_IP, IP_PKTINFO, (const char*)&yes, sizeof(yes));
1872 ok(rc == 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
1873
1874 /*
1875 * Send a packet from the client to the server and test for specifying
1876 * a short control header.
1877 */
1878 SetLastError(0xdeadbeef);
1879 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
1880 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
1881 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
1882 hdr.Control.len = 1;
1883 dwSize = 0xdeadbeef;
1884 rc = pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
1885 ok(rc == -1, "expected failure\n");
1886 ok(WSAGetLastError() == WSAEMSGSIZE, "got error %u\n", WSAGetLastError());
1887 todo_wine ok(dwSize == sizeof(msg), "got size %u\n", dwSize);
1888 ok(hdr.dwFlags == MSG_CTRUNC, "got flags %#x\n", hdr.dwFlags);
1889 hdr.dwFlags = 0; /* Reset flags */
1890
1891 /* Perform another short control header test, this time with an overlapped receive */
1892 hdr.Control.len = 1;
1893 ov.Internal = 0xdead1;
1894 ov.InternalHigh = 0xdead2;
1895 ov.Offset = 0xdead3;
1896 ov.OffsetHigh = 0xdead4;
1897 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
1898 err=WSAGetLastError();
1899 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
1900 SetLastError(0xdeadbeef);
1901 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
1902 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
1903 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
1904 ok(!WaitForSingleObject(ov.hEvent, 100), "wait failed\n");
1905 ok((NTSTATUS)ov.Internal == STATUS_BUFFER_OVERFLOW, "got status %#x\n", (NTSTATUS)ov.Internal);
1906 ok(ov.InternalHigh == sizeof(msg), "got size %Iu\n", ov.InternalHigh);
1907 ok(ov.Offset == 0xdead3, "got Offset %Iu\n", ov.Offset);
1908 ok(ov.OffsetHigh == 0xdead4, "got OffsetHigh %Iu\n", ov.OffsetHigh);
1909 dwFlags = 0xdeadbeef;
1910 rc = WSAGetOverlappedResult(s1, &ov, &dwSize, FALSE, &dwFlags);
1911 ok(!rc, "expected failure\n");
1912 ok(WSAGetLastError() == WSAEMSGSIZE, "got error %u\n", WSAGetLastError());
1913 ok(dwSize == sizeof(msg), "got size %u\n", dwSize);
1914 todo_wine ok(dwFlags == 0xdeadbeef, "got flags %#x\n", dwFlags);
1915 ok(hdr.dwFlags == MSG_CTRUNC,
1916 "WSARecvMsg() overlapped operation set unexpected flags %d.\n", hdr.dwFlags);
1917 hdr.dwFlags = 0; /* Reset flags */
1918
1919 /* And with an APC. */
1920
1921 SetLastError(0xdeadbeef);
1922 rc = sendto(s2, msg, sizeof(msg), 0, (struct sockaddr *)&s2addr, sizeof(s2addr));
1923 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
1924 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
1925 hdr.Control.len = 1;
1926
1927 ov.Internal = 0xdead1;
1928 ov.InternalHigh = 0xdead2;
1929 ov.Offset = 0xdead3;
1930 ov.OffsetHigh = 0xdead4;
1931 dwSize = 0xdeadbeef;
1932 rc = pWSARecvMsg(s1, &hdr, NULL, &ov, ip_pktinfo_apc);
1933 ok(rc == -1, "expected failure\n");
1934 todo_wine ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
1935
1936 rc = SleepEx(1000, TRUE);
1937 todo_wine ok(rc == WAIT_IO_COMPLETION, "got %d\n", rc);
1938 todo_wine ok(got_ip_pktinfo_apc == 1, "apc was called %u times\n", got_ip_pktinfo_apc);
1939 ok(hdr.dwFlags == MSG_CTRUNC, "got flags %#x\n", hdr.dwFlags);
1940 got_ip_pktinfo_apc = 0;
1941
1942 hdr.dwFlags = 0; /* Reset flags */
1943
1944 /*
1945 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
1946 * on the server end and check that the returned packet matches what was sent.
1947 */
1948 hdr.Control.len = sizeof(pktbuf);
1949 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
1950 err=WSAGetLastError();
1951 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
1952 ok(hdr.Control.len == sizeof(pktbuf),
1953 "WSARecvMsg() control length mismatch (%d != sizeof pktbuf).\n", hdr.Control.len);
1954 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
1955 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
1956 ok(!WaitForSingleObject(ov.hEvent, 100), "wait failed\n");
1957 dwSize = 0;
1958 WSAGetOverlappedResult(s1, &ov, &dwSize, FALSE, NULL);
1959 ok(dwSize == sizeof(msg),
1960 "WSARecvMsg() buffer length does not match transmitted data!\n");
1961 ok(strncmp(iovec[0].buf, msg, sizeof(msg)) == 0,
1962 "WSARecvMsg() buffer does not match transmitted data!\n");
1963 ok(hdr.Control.len == IP_PKTINFO_LEN,
1964 "WSARecvMsg() control length mismatch (%d).\n", hdr.Control.len);
1965
1966 /* Test for the expected IP_PKTINFO return information. */
1967 foundhdr = FALSE;
1968 for (cmsg = WSA_CMSG_FIRSTHDR(&hdr); cmsg != NULL; cmsg = WSA_CMSG_NXTHDR(&hdr, cmsg))
1969 {
1970 if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO)
1971 {
1972 struct in_pktinfo *pi = (struct in_pktinfo *)WSA_CMSG_DATA(cmsg);
1973
1974 ok(pi->ipi_addr.s_addr == s2addr.sin_addr.s_addr, "destination ip mismatch!\n");
1975 foundhdr = TRUE;
1976 }
1977 }
1978 ok(foundhdr, "IP_PKTINFO header information was not returned!\n");
1979
1980 closesocket(s2);
1981 closesocket(s1);
1982 }
1983
1984 CloseHandle(ov.hEvent);
1985 }
1986
1987 static void test_ipv6_cmsg(void)
1988 {
1989 static const DWORD off = 0;
1990 static const DWORD on = 1;
1991 SOCKADDR_IN6 localhost = {0};
1992 SOCKET client, server;
1993 char payload[] = "HELLO";
1994 char control[100];
1995 WSABUF payload_buf = {sizeof(payload), payload};
1996 WSAMSG msg = {NULL, 0, &payload_buf, 1, {sizeof(control), control}, 0};
1997 WSACMSGHDR *header = (WSACMSGHDR *)control;
1998 LPFN_WSARECVMSG pWSARecvMsg;
1999 INT *int_data = (INT *)WSA_CMSG_DATA(header);
2000 IN6_PKTINFO *pkt_info = (IN6_PKTINFO *)WSA_CMSG_DATA(header);
2001 DWORD count, state;
2002 int rc;
2003
2004 localhost.sin6_family = AF_INET6;
2005 localhost.sin6_port = htons(SERVERPORT);
2006 inet_pton(AF_INET6, "::1", &localhost.sin6_addr);
2007
2008 client = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
2009 ok(client != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2010 server = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
2011 ok(server != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
2012
2013 rc = bind(server, (SOCKADDR *)&localhost, sizeof(localhost));
2014 ok(rc != SOCKET_ERROR, "bind failed, error %u\n", WSAGetLastError());
2015 rc = connect(client, (SOCKADDR *)&localhost, sizeof(localhost));
2016 ok(rc != SOCKET_ERROR, "connect failed, error %u\n", WSAGetLastError());
2017
2018 rc = WSAIoctl(server, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
2019 &pWSARecvMsg, sizeof(pWSARecvMsg), &count, NULL, NULL);
2020 ok(!rc, "failed to get WSARecvMsg, error %u\n", WSAGetLastError());
2021
2022 memset(control, 0, sizeof(control));
2023 msg.Control.len = sizeof(control);
2024 rc = setsockopt(server, IPPROTO_IPV6, IPV6_HOPLIMIT, (const char *)&on, sizeof(on));
2025 ok(!rc, "failed to set IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2026 state = 0;
2027 count = sizeof(state);
2028 rc = getsockopt(server, IPPROTO_IPV6, IPV6_HOPLIMIT, (char *)&state, (INT *)&count);
2029 ok(!rc, "failed to get IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2030 ok(state == 1, "expected 1, got %u\n", state);
2031 rc = send(client, payload, sizeof(payload), 0);
2032 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2033 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2034 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2035 ok(count == sizeof(payload), "expected length %i, got %i\n", (INT)sizeof(payload), count);
2036 ok(header->cmsg_level == IPPROTO_IPV6, "expected IPPROTO_IPV6, got %i\n", header->cmsg_level);
2037 ok(header->cmsg_type == IPV6_HOPLIMIT, "expected IPV6_HOPLIMIT, got %i\n", header->cmsg_type);
2038 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
2039 "expected length %i, got %i\n", (INT)(sizeof(*header) + sizeof(INT)), (INT)header->cmsg_len);
2040 ok(*int_data >= 32, "expected at least 32, got %i\n", *int_data);
2041 setsockopt(server, IPPROTO_IPV6, IPV6_HOPLIMIT, (const char *)&off, sizeof(off));
2042 ok(!rc, "failed to clear IPV6_HOPLIMIT, error %u\n", WSAGetLastError());
2043
2044 memset(control, 0, sizeof(control));
2045 msg.Control.len = sizeof(control);
2046 rc = setsockopt(server, IPPROTO_IPV6, IPV6_PKTINFO, (const char *)&on, sizeof(on));
2047 ok(!rc, "failed to set IPV6_PKTINFO, error %u\n", WSAGetLastError());
2048 state = 0;
2049 count = sizeof(state);
2050 rc = getsockopt(server, IPPROTO_IPV6, IPV6_PKTINFO, (char *)&state, (INT *)&count);
2051 ok(!rc, "failed to get IPV6_PKTINFO, error %u\n", WSAGetLastError());
2052 ok(state == 1, "expected 1, got %u\n", state);
2053 rc = send(client, payload, sizeof(payload), 0);
2054 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2055 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2056 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2057 ok(count == sizeof(payload), "expected length %i, got %i\n", (INT)sizeof(payload), count);
2058 ok(header->cmsg_level == IPPROTO_IPV6, "expected IPPROTO_IPV6, got %i\n", header->cmsg_level);
2059 ok(header->cmsg_type == IPV6_PKTINFO, "expected IPV6_PKTINFO, got %i\n", header->cmsg_type);
2060 ok(header->cmsg_len == sizeof(*header) + sizeof(IN6_PKTINFO),
2061 "expected length %i, got %i\n", (INT)(sizeof(*header) + sizeof(IN6_PKTINFO)), (INT)header->cmsg_len);
2062 ok(!memcmp(&pkt_info->ipi6_addr, &localhost.sin6_addr, sizeof(IN6_ADDR)), "expected ::1\n");
2063 rc = setsockopt(server, IPPROTO_IPV6, IPV6_PKTINFO, (const char *)&off, sizeof(off));
2064 ok(!rc, "failed to clear IPV6_PKTINFO, error %u\n", WSAGetLastError());
2065
2066 memset(control, 0, sizeof(control));
2067 msg.Control.len = sizeof(control);
2068 rc = setsockopt(server, IPPROTO_IPV6, IPV6_RECVTCLASS, (const char *)&on, sizeof(on));
2069 ok(!rc, "failed to set IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
2070 state = 0;
2071 count = sizeof(state);
2072 rc = getsockopt(server, IPPROTO_IPV6, IPV6_RECVTCLASS, (char *)&state, (INT *)&count);
2073 ok(!rc, "failed to get IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
2074 ok(state == 1, "expected 1, got %u\n", state);
2075 rc = send(client, payload, sizeof(payload), 0);
2076 ok(rc == sizeof(payload), "send failed, error %u\n", WSAGetLastError());
2077 rc = pWSARecvMsg(server, &msg, &count, NULL, NULL);
2078 ok(!rc, "WSARecvMsg failed, error %u\n", WSAGetLastError());
2079 ok(count == sizeof(payload), "expected length %i, got %i\n", (INT)sizeof(payload), count);
2080 ok(header->cmsg_level == IPPROTO_IPV6, "expected IPPROTO_IPV6, got %i\n", header->cmsg_level);
2081 ok(header->cmsg_type == IPV6_TCLASS, "expected IPV6_TCLASS, got %i\n", header->cmsg_type);
2082 ok(header->cmsg_len == sizeof(*header) + sizeof(INT),
2083 "expected length %i, got %i\n", (INT)(sizeof(*header) + sizeof(INT)), (INT)header->cmsg_len);
2084 ok(*int_data == 0, "expected 0, got %i\n", *int_data);
2085 rc = setsockopt(server, IPPROTO_IPV6, IPV6_RECVTCLASS, (const char *)&off, sizeof(off));
2086 ok(!rc, "failed to clear IPV6_RECVTCLASS, error %u\n", WSAGetLastError());
2087
2088 closesocket(server);
2089 closesocket(client);
2090 }
2091
2092 /************* Array containing the tests to run **********/
2093
2094 #define STD_STREAM_SOCKET \
2095 SOCK_STREAM, \
2096 0, \
2097 SERVERIP, \
2098 SERVERPORT
2099
2100 static test_setup tests [] =
2101 {
2102 /* Test 0: synchronous client and server */
2103 {
2104 {
2105 STD_STREAM_SOCKET,
2106 2048,
2107 16,
2108 2
2109 },
2110 simple_server,
2111 {
2112 NULL,
2113 0,
2114 64
2115 },
2116 simple_client,
2117 {
2118 NULL,
2119 0,
2120 128
2121 }
2122 },
2123 /* Test 1: event-driven client, synchronous server */
2124 {
2125 {
2126 STD_STREAM_SOCKET,
2127 2048,
2128 16,
2129 2
2130 },
2131 simple_server,
2132 {
2133 NULL,
2134 0,
2135 64
2136 },
2137 event_client,
2138 {
2139 NULL,
2140 WSA_FLAG_OVERLAPPED,
2141 128
2142 }
2143 },
2144 /* Test 2: synchronous client, non-blocking server via select() */
2145 {
2146 {
2147 STD_STREAM_SOCKET,
2148 2048,
2149 16,
2150 2
2151 },
2152 select_server,
2153 {
2154 NULL,
2155 0,
2156 64
2157 },
2158 simple_client,
2159 {
2160 NULL,
2161 0,
2162 128
2163 }
2164 },
2165 /* Test 3: OOB client, OOB server */
2166 {
2167 {
2168 STD_STREAM_SOCKET,
2169 128,
2170 16,
2171 1
2172 },
2173 oob_server,
2174 {
2175 NULL,
2176 0,
2177 128
2178 },
2179 oob_client,
2180 {
2181 NULL,
2182 0,
2183 128
2184 }
2185 },
2186 /* Test 4: synchronous mixed client and server */
2187 {
2188 {
2189 STD_STREAM_SOCKET,
2190 2048,
2191 16,
2192 2
2193 },
2194 simple_server,
2195 {
2196 NULL,
2197 0,
2198 64
2199 },
2200 simple_mixed_client,
2201 {
2202 NULL,
2203 0,
2204 128
2205 }
2206 }
2207 };
2208
2209 static void test_UDP(void)
2210 {
2211 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
2212 possible that this test fails due to dropped packets. */
2213
2214 /* peer 0 receives data from all other peers */
2215 struct sock_info peer[NUM_UDP_PEERS];
2216 char buf[16];
2217 int ss, i, n_recv, n_sent;
2218
2219 memset (buf,0,sizeof(buf));
2220 for ( i = NUM_UDP_PEERS - 1; i >= 0; i-- ) {
2221 ok ( ( peer[i].s = socket ( AF_INET, SOCK_DGRAM, 0 ) ) != INVALID_SOCKET, "UDP: socket failed\n" );
2222
2223 peer[i].addr.sin_family = AF_INET;
2224 peer[i].addr.sin_addr.s_addr = inet_addr ( SERVERIP );
2225
2226 if ( i == 0 ) {
2227 peer[i].addr.sin_port = htons ( SERVERPORT );
2228 } else {
2229 peer[i].addr.sin_port = htons ( 0 );
2230 }
2231
2232 do_bind ( peer[i].s, (struct sockaddr *) &peer[i].addr, sizeof( peer[i].addr ) );
2233
2234 /* test getsockname() to get peer's port */
2235 ss = sizeof ( peer[i].addr );
2236 ok ( getsockname ( peer[i].s, (struct sockaddr *) &peer[i].addr, &ss ) != SOCKET_ERROR, "UDP: could not getsockname()\n" );
2237 ok ( peer[i].addr.sin_port != htons ( 0 ), "UDP: bind() did not associate port\n" );
2238 }
2239
2240 /* test getsockname() */
2241 ok ( peer[0].addr.sin_port == htons ( SERVERPORT ), "UDP: getsockname returned incorrect peer port\n" );
2242
2243 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
2244 /* send client's ip */
2245 memcpy( buf, &peer[i].addr.sin_port, sizeof(peer[i].addr.sin_port) );
2246 n_sent = sendto ( peer[i].s, buf, sizeof(buf), 0, (struct sockaddr*) &peer[0].addr, sizeof(peer[0].addr) );
2247 ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
2248 }
2249
2250 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
2251 n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0,(struct sockaddr *) &peer[0].peer, &ss );
2252 ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
2253 ok ( memcmp ( &peer[0].peer.sin_port, buf, sizeof(peer[0].addr.sin_port) ) == 0, "UDP: port numbers do not match\n" );
2254 }
2255 }
2256
2257 static void test_WSASocket(void)
2258 {
2259 SOCKET sock = INVALID_SOCKET;
2260 WSAPROTOCOL_INFOA *pi;
2261 int wsaproviders[] = {IPPROTO_TCP, IPPROTO_IP};
2262 int autoprotocols[] = {IPPROTO_TCP, IPPROTO_UDP};
2263 int items, err, size, socktype, i, j;
2264 UINT pi_size;
2265
2266 static const struct
2267 {
2268 int family, type, protocol;
2269 DWORD error;
2270 int ret_family, ret_type, ret_protocol;
2271 }
2272 tests[] =
2273 {
2274 /* 0 */
2275 {0xdead, SOCK_STREAM, IPPROTO_TCP, WSAEAFNOSUPPORT},
2276 {-1, SOCK_STREAM, IPPROTO_TCP, WSAEAFNOSUPPORT},
2277 {AF_INET, 0xdead, IPPROTO_TCP, WSAESOCKTNOSUPPORT},
2278 {AF_INET, -1, IPPROTO_TCP, WSAESOCKTNOSUPPORT},
2279 {AF_INET, SOCK_STREAM, 0xdead, WSAEPROTONOSUPPORT},
2280 {AF_INET, SOCK_STREAM, -1, WSAEPROTONOSUPPORT},
2281 {0xdead, 0xdead, IPPROTO_TCP, WSAESOCKTNOSUPPORT},
2282 {0xdead, SOCK_STREAM, 0xdead, WSAEAFNOSUPPORT},
2283 {AF_INET, 0xdead, 0xdead, WSAESOCKTNOSUPPORT},
2284 {0xdead, SOCK_STREAM, IPPROTO_UDP, WSAEAFNOSUPPORT},
2285
2286 /* 10 */
2287 {AF_INET, SOCK_STREAM, 0, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP},
2288 {AF_INET, SOCK_DGRAM, 0, 0, AF_INET, SOCK_DGRAM, IPPROTO_UDP},
2289 {AF_INET, 0xdead, 0, WSAESOCKTNOSUPPORT},
2290 {AF_INET, 0, IPPROTO_TCP, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP},
2291 {AF_INET, 0, IPPROTO_UDP, 0, AF_INET, SOCK_DGRAM, IPPROTO_UDP},
2292 {AF_INET, 0, 0xdead, WSAEPROTONOSUPPORT},
2293 {AF_INET, 0, 0, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP},
2294 {AF_INET, SOCK_STREAM, IPPROTO_UDP, WSAEPROTONOSUPPORT},
2295 {AF_INET, SOCK_DGRAM, IPPROTO_TCP, WSAEPROTONOSUPPORT},
2296
2297 /* 19 */
2298 {AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP},
2299 {AF_UNSPEC, SOCK_STREAM, 0xdead, WSAEPROTONOSUPPORT},
2300 {AF_UNSPEC, 0xdead, IPPROTO_UDP, WSAESOCKTNOSUPPORT},
2301 {AF_UNSPEC, SOCK_STREAM, 0, WSAEINVAL},
2302 {AF_UNSPEC, SOCK_DGRAM, 0, WSAEINVAL},
2303 {AF_UNSPEC, 0xdead, 0, WSAEINVAL},
2304 {AF_UNSPEC, 0, IPPROTO_TCP, 0, AF_INET, SOCK_STREAM, IPPROTO_TCP},
2305 {AF_UNSPEC, 0, IPPROTO_UDP, 0, AF_INET, SOCK_DGRAM, IPPROTO_UDP},
2306 {AF_UNSPEC, 0, 0xdead, WSAEPROTONOSUPPORT},
2307 {AF_UNSPEC, 0, 0, WSAEINVAL},
2308 };
2309
2310 for (i = 0; i < ARRAY_SIZE(tests); ++i)
2311 {
2312 SetLastError( 0xdeadbeef );
2313 sock = WSASocketA( tests[i].family, tests[i].type, tests[i].protocol, NULL, 0, 0 );
2314 todo_wine_if (!tests[i].error || i == 7)
2315 ok(WSAGetLastError() == tests[i].error, "Test %u: got wrong error %u\n", i, WSAGetLastError());
2316 if (tests[i].error)
2317 {
2318 ok(sock == INVALID_SOCKET, "Test %u: expected failure\n", i);
2319 }
2320 else
2321 {
2322 WSAPROTOCOL_INFOA info;
2323
2324 ok(sock != INVALID_SOCKET, "Text %u: expected success\n", i);
2325
2326 size = sizeof(info);
2327 err = getsockopt( sock, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *)&info, &size );
2328 ok(!err, "Test %u: getsockopt failed, error %u\n", i, WSAGetLastError());
2329 ok(info.iAddressFamily == tests[i].ret_family, "Test %u: got wrong family %d\n", i, info.iAddressFamily);
2330 ok(info.iSocketType == tests[i].ret_type, "Test %u: got wrong type %d\n", i, info.iSocketType);
2331 ok(info.iProtocol == tests[i].ret_protocol, "Test %u: got wrong protocol %d\n", i, info.iProtocol);
2332
2333 closesocket( sock );
2334 }
2335 }
2336
2337 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
2338 * to avoid a crash on win98.
2339 */
2340 pi_size = 0;
2341 items = WSAEnumProtocolsA(wsaproviders, NULL, &pi_size);
2342 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
2343 items);
2344 err = WSAGetLastError();
2345 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2346 err, WSAENOBUFS);
2347
2348 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
2349 ok(pi != NULL, "Failed to allocate memory\n");
2350
2351 items = WSAEnumProtocolsA(wsaproviders, pi, &pi_size);
2352 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
2353 WSAGetLastError());
2354
2355 if (items == 0) {
2356 skip("No protocols enumerated.\n");
2357 HeapFree(GetProcessHeap(), 0, pi);
2358 return;
2359 }
2360
2361 sock = WSASocketA(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
2362 FROM_PROTOCOL_INFO, &pi[0], 0, 0);
2363 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2364 WSAGetLastError());
2365 closesocket(sock);
2366
2367 /* find what parameters are used first: plain parameters or protocol info struct */
2368 pi[0].iProtocol = -1;
2369 pi[0].iSocketType = -1;
2370 pi[0].iAddressFamily = -1;
2371 ok(WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0) == INVALID_SOCKET,
2372 "WSASocketA should have failed\n");
2373 err = WSAGetLastError();
2374 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
2375
2376 pi[0].iProtocol = 0;
2377 pi[0].iSocketType = 0;
2378 pi[0].iAddressFamily = 0;
2379 sock = WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0);
2380 if(sock != INVALID_SOCKET)
2381 {
2382 win_skip("must work only in OS <= 2003\n");
2383 closesocket(sock);
2384 }
2385 else
2386 {
2387 err = WSAGetLastError();
2388 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
2389 }
2390
2391 pi[0].iProtocol = IPPROTO_UDP;
2392 pi[0].iSocketType = SOCK_DGRAM;
2393 pi[0].iAddressFamily = AF_INET;
2394 sock = WSASocketA(0, 0, 0, &pi[0], 0, 0);
2395 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2396 WSAGetLastError());
2397
2398 size = sizeof(socktype);
2399 socktype = 0xdead;
2400 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2401 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2402 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2403 SOCK_DGRAM, socktype);
2404
2405 socktype = SOCK_STREAM;
2406 WSASetLastError(0xdeadbeef);
2407 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
2408 ok(err == -1, "expected failure\n");
2409 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
2410
2411 socktype = SOCK_DGRAM;
2412 WSASetLastError(0xdeadbeef);
2413 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
2414 ok(err == -1, "expected failure\n");
2415 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
2416
2417 closesocket(sock);
2418
2419 sock = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, &pi[0], 0, 0);
2420 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2421 WSAGetLastError());
2422
2423 size = sizeof(socktype);
2424 socktype = 0xdead;
2425 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2426 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2427 ok(socktype == SOCK_STREAM, "Wrong socket type, expected %d received %d\n",
2428 SOCK_STREAM, socktype);
2429
2430 socktype = SOCK_STREAM;
2431 WSASetLastError(0xdeadbeef);
2432 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
2433 ok(err == -1, "expected failure\n");
2434 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
2435
2436 socktype = SOCK_DGRAM;
2437 WSASetLastError(0xdeadbeef);
2438 err = setsockopt(sock, SOL_SOCKET, SO_TYPE, (char *)&socktype, sizeof(socktype));
2439 ok(err == -1, "expected failure\n");
2440 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
2441
2442 closesocket(sock);
2443
2444 HeapFree(GetProcessHeap(), 0, pi);
2445
2446 pi_size = 0;
2447 items = WSAEnumProtocolsA(NULL, NULL, &pi_size);
2448 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
2449 items);
2450 err = WSAGetLastError();
2451 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2452 err, WSAENOBUFS);
2453
2454 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
2455 ok(pi != NULL, "Failed to allocate memory\n");
2456
2457 items = WSAEnumProtocolsA(NULL, pi, &pi_size);
2458 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
2459 WSAGetLastError());
2460
2461 /* when no protocol and socket type are specified the first entry
2462 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
2463 * is returned */
2464 sock = WSASocketA(AF_INET, 0, 0, NULL, 0, 0);
2465 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2466 WSAGetLastError());
2467
2468 size = sizeof(socktype);
2469 socktype = 0xdead;
2470 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2471 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2472 for(i = 0; i < items; i++)
2473 {
2474 if(pi[i].dwProviderFlags & PFL_MATCHES_PROTOCOL_ZERO)
2475 {
2476 ok(socktype == pi[i].iSocketType, "Wrong socket type, expected %d received %d\n",
2477 pi[i].iSocketType, socktype);
2478 break;
2479 }
2480 }
2481 ok(i != items, "Creating a socket without protocol and socket type didn't work\n");
2482 closesocket(sock);
2483
2484 /* when no socket type is specified the first entry from WSAEnumProtocols
2485 * that matches the protocol is returned */
2486 for (i = 0; i < ARRAY_SIZE(autoprotocols); i++)
2487 {
2488 sock = WSASocketA(0, 0, autoprotocols[i], NULL, 0, 0);
2489 ok(sock != INVALID_SOCKET, "Failed to create socket for protocol %d, received %d\n",
2490 autoprotocols[i], WSAGetLastError());
2491
2492 size = sizeof(socktype);
2493 socktype = 0xdead;
2494 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2495 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2496
2497 for (err = 1, j = 0; j < items; j++)
2498 {
2499 if (pi[j].iProtocol == autoprotocols[i])
2500 {
2501 ok(pi[j].iSocketType == socktype, "expected %d, got %d\n", socktype, pi[j].iSocketType);
2502 err = 0;
2503 break;
2504 }
2505 }
2506 ok(!err, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols[i]);
2507
2508 closesocket(sock);
2509 }
2510
2511 HeapFree(GetProcessHeap(), 0, pi);
2512
2513 SetLastError(0xdeadbeef);
2514 /* starting on vista the socket function returns error during the socket
2515 creation and no longer in the socket operations (sendto, readfrom) */
2516 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
2517 if (sock == INVALID_SOCKET)
2518 {
2519 err = WSAGetLastError();
2520 ok(err == WSAEACCES, "Expected 10013, received %d\n", err);
2521 skip("SOCK_RAW is not supported\n");
2522 }
2523 else
2524 {
2525 size = sizeof(socktype);
2526 socktype = 0xdead;
2527 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2528 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2529 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2530 SOCK_RAW, socktype);
2531 closesocket(sock);
2532
2533 sock = WSASocketA(0, 0, IPPROTO_RAW, NULL, 0, 0);
2534 if (sock != INVALID_SOCKET)
2535 {
2536 todo_wine {
2537 size = sizeof(socktype);
2538 socktype = 0xdead;
2539 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2540 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2541 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2542 SOCK_RAW, socktype);
2543 closesocket(sock);
2544 }
2545
2546 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_TCP, NULL, 0, 0);
2547 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2548 WSAGetLastError());
2549 size = sizeof(socktype);
2550 socktype = 0xdead;
2551 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2552 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2553 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2554 SOCK_RAW, socktype);
2555 closesocket(sock);
2556 }
2557 else if (WSAGetLastError() == WSAEACCES)
2558 skip("SOCK_RAW is not available\n");
2559 else
2560 ok(0, "Failed to create socket: %d\n", WSAGetLastError());
2561
2562 }
2563
2564 /* IPX socket tests */
2565
2566 SetLastError(0xdeadbeef);
2567 sock = WSASocketA(AF_IPX, SOCK_DGRAM, NSPROTO_IPX, NULL, 0, 0);
2568 if (sock == INVALID_SOCKET)
2569 {
2570 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError());
2571 skip("IPX is not supported\n");
2572 }
2573 else
2574 {
2575 WSAPROTOCOL_INFOA info;
2576 closesocket(sock);
2577
2578 sock = WSASocketA(0, 0, NSPROTO_IPX, NULL, 0, 0);
2579 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2580 WSAGetLastError());
2581
2582 size = sizeof(socktype);
2583 socktype = 0xdead;
2584 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2585 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2586 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2587 SOCK_DGRAM, socktype);
2588
2589 /* check socket family, type and protocol */
2590 size = sizeof(WSAPROTOCOL_INFOA);
2591 err = getsockopt(sock, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &info, &size);
2592 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2593 ok(info.iProtocol == NSPROTO_IPX, "expected protocol %d, received %d\n",
2594 NSPROTO_IPX, info.iProtocol);
2595 ok(info.iAddressFamily == AF_IPX, "expected family %d, received %d\n",
2596 AF_IPX, info.iProtocol);
2597 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
2598 SOCK_DGRAM, info.iSocketType);
2599 closesocket(sock);
2600
2601 /* SOCK_STREAM does not support NSPROTO_IPX */
2602 SetLastError(0xdeadbeef);
2603 ok(WSASocketA(AF_IPX, SOCK_STREAM, NSPROTO_IPX, NULL, 0, 0) == INVALID_SOCKET,
2604 "WSASocketA should have failed\n");
2605 err = WSAGetLastError();
2606 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2607
2608 /* test extended IPX support - that is adding any number between 0 and 255
2609 * to the IPX protocol value will make it be used as IPX packet type */
2610 for(i = 0;i <= 255;i += 17)
2611 {
2612 SetLastError(0xdeadbeef);
2613 sock = WSASocketA(0, 0, NSPROTO_IPX + i, NULL, 0, 0);
2614 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2615 WSAGetLastError());
2616
2617 size = sizeof(int);
2618 socktype = -1;
2619 err = getsockopt(sock, NSPROTO_IPX, IPX_PTYPE, (char *) &socktype, &size);
2620 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2621 ok(socktype == i, "Wrong IPX packet type, expected %d received %d\n",
2622 i, socktype);
2623
2624 closesocket(sock);
2625 }
2626 }
2627 }
2628
2629 static void test_WSADuplicateSocket(void)
2630 {
2631 SOCKET source, dupsock;
2632 WSAPROTOCOL_INFOA info;
2633 DWORD err;
2634 struct sockaddr_in addr;
2635 int socktype, size, addrsize, ret;
2636 char teststr[] = "TEST", buffer[16];
2637
2638 source = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
2639 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2640
2641 /* test invalid parameters */
2642 SetLastError(0xdeadbeef);
2643 ok(WSADuplicateSocketA(0, 0, NULL), "WSADuplicateSocketA should have failed\n");
2644 err = WSAGetLastError();
2645 ok(err == WSAENOTSOCK, "expected 10038, received %d\n", err);
2646
2647 SetLastError(0xdeadbeef);
2648 ok(WSADuplicateSocketA(source, 0, NULL),
2649 "WSADuplicateSocketA should have failed\n");
2650 err = WSAGetLastError();
2651 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2652
2653 SetLastError(0xdeadbeef);
2654 ok(WSADuplicateSocketA(source, ~0, &info),
2655 "WSADuplicateSocketA should have failed\n");
2656 err = WSAGetLastError();
2657 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2658
2659 SetLastError(0xdeadbeef);
2660 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info),
2661 "WSADuplicateSocketA should have failed\n");
2662 err = WSAGetLastError();
2663 ok(err == WSAENOTSOCK, "expected 10038, received %d\n", err);
2664
2665 SetLastError(0xdeadbeef);
2666 ok(WSADuplicateSocketA(source, GetCurrentProcessId(), NULL),
2667 "WSADuplicateSocketA should have failed\n");
2668 err = WSAGetLastError();
2669 ok(err == WSAEFAULT, "expected 10014, received %d\n", err);
2670
2671 /* test returned structure */
2672 memset(&info, 0, sizeof(info));
2673 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2674 "WSADuplicateSocketA should have worked\n");
2675
2676 ok(info.iProtocol == IPPROTO_TCP, "expected protocol %d, received %d\n",
2677 IPPROTO_TCP, info.iProtocol);
2678 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
2679 AF_INET, info.iProtocol);
2680 ok(info.iSocketType == SOCK_STREAM, "expected type %d, received %d\n",
2681 SOCK_STREAM, info.iSocketType);
2682
2683 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2684 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2685
2686 closesocket(dupsock);
2687 closesocket(source);
2688
2689 /* create a socket, bind it, duplicate it then send data on source and
2690 * receive in the duplicated socket */
2691 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
2692 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2693
2694 memset(&info, 0, sizeof(info));
2695 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2696 "WSADuplicateSocketA should have worked\n");
2697
2698 ok(info.iProtocol == IPPROTO_UDP, "expected protocol %d, received %d\n",
2699 IPPROTO_UDP, info.iProtocol);
2700 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
2701 AF_INET, info.iProtocol);
2702 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
2703 SOCK_DGRAM, info.iSocketType);
2704
2705 memset(&addr, 0, sizeof(addr));
2706 addr.sin_family = AF_INET;
2707 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2708 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
2709 "bind should have worked\n");
2710
2711 /* read address to find out the port number to be used in sendto */
2712 memset(&addr, 0, sizeof(addr));
2713 addrsize = sizeof(addr);
2714 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
2715 "getsockname should have worked\n");
2716 ok(addr.sin_port, "socket port should be != 0\n");
2717
2718 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2719 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2720
2721 size = sizeof(int);
2722 ret = getsockopt(dupsock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2723 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
2724 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2725 SOCK_DGRAM, socktype);
2726
2727 set_blocking(source, TRUE);
2728
2729 /* send data on source socket */
2730 addrsize = sizeof(addr);
2731 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
2732 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2733
2734 /* receive on duplicated socket */
2735 addrsize = sizeof(addr);
2736 memset(buffer, 0, sizeof(buffer));
2737 size = recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize);
2738 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2739 buffer[sizeof(teststr) - 1] = 0;
2740 ok(!strcmp(buffer, teststr), "expected '%s', received '%s'\n", teststr, buffer);
2741
2742 closesocket(dupsock);
2743 closesocket(source);
2744
2745 /* show that the source socket need to be bound before the duplicated
2746 * socket is created */
2747 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
2748 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2749
2750 memset(&info, 0, sizeof(info));
2751 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2752 "WSADuplicateSocketA should have worked\n");
2753
2754 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2755 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2756
2757 memset(&addr, 0, sizeof(addr));
2758 addr.sin_family = AF_INET;
2759 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2760 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
2761 "bind should have worked\n");
2762
2763 /* read address to find out the port number to be used in sendto */
2764 memset(&addr, 0, sizeof(addr));
2765 addrsize = sizeof(addr);
2766 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
2767 "getsockname should have worked\n");
2768 ok(addr.sin_port, "socket port should be != 0\n");
2769
2770 set_blocking(source, TRUE);
2771
2772 addrsize = sizeof(addr);
2773 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
2774 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2775
2776 SetLastError(0xdeadbeef);
2777 addrsize = sizeof(addr);
2778 memset(buffer, 0, sizeof(buffer));
2779 todo_wine {
2780 ok(recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize) == -1,
2781 "recvfrom should have failed\n");
2782 err = WSAGetLastError();
2783 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2784 }
2785
2786 closesocket(dupsock);
2787 closesocket(source);
2788 }
2789
2790 static void test_WSAEnumNetworkEvents(void)
2791 {
2792 SOCKET s, s2;
2793 int sock_type[] = {SOCK_STREAM, SOCK_DGRAM, SOCK_STREAM}, i, j, k, l;
2794 struct sockaddr_in address;
2795 HANDLE event;
2796 WSANETWORKEVENTS net_events;
2797
2798 memset(&address, 0, sizeof(address));
2799 address.sin_addr.s_addr = htonl(INADDR_ANY);
2800 address.sin_family = AF_INET;
2801
2802 /* This test follows the steps from bugs 10204 and 24946 */
2803 for (l = 0; l < 2; l++)
2804 {
2805 for (i = 0; i < ARRAY_SIZE(sock_type); i++)
2806 {
2807 if (i == 2)
2808 tcp_socketpair(&s, &s2);
2809 else
2810 {
2811 s = socket(AF_INET, sock_type[i], 0);
2812 ok (s != SOCKET_ERROR, "Test[%d]: failed to create socket\n", i);
2813 ok (!bind(s, (struct sockaddr*) &address, sizeof(address)), "Test[%d]: bind failed\n", i);
2814 }
2815 event = WSACreateEvent();
2816 ok (event != NULL, "Test[%d]: failed to create event\n", i);
2817 for (j = 0; j < 5; j++) /* Repeat sometimes and the result must be the same */
2818 {
2819 /* When the TCP socket is not connected NO events will be returned.
2820 * When connected and no data pending it will get the write event.
2821 * UDP sockets don't have connections so as soon as they are bound
2822 * they can read/write data. Since nobody is sendind us data only
2823 * the write event will be returned and ONLY once.
2824 */
2825 ok (!WSAEventSelect(s, event, FD_READ | FD_WRITE), "Test[%d]: WSAEventSelect failed\n", i);
2826 memset(&net_events, 0xAB, sizeof(net_events));
2827 ok (!WSAEnumNetworkEvents(s, l == 0 ? event : NULL, &net_events),
2828 "Test[%d]: WSAEnumNetworkEvents failed\n", i);
2829 if (i >= 1 && j == 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
2830 {
2831 ok (net_events.lNetworkEvents == FD_WRITE, "Test[%d]: expected 2, got %d\n",
2832 i, net_events.lNetworkEvents);
2833 }
2834 else
2835 {
2836 ok (net_events.lNetworkEvents == 0, "Test[%d]: expected 0, got %d\n",
2837 i, net_events.lNetworkEvents);
2838 }
2839 for (k = 0; k < FD_MAX_EVENTS; k++)
2840 {
2841 if (net_events.lNetworkEvents & (1 << k))
2842 {
2843 ok (net_events.iErrorCode[k] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
2844 i, k, net_events.iErrorCode[k]);
2845 }
2846 else
2847 {
2848 /* Bits that are not set in lNetworkEvents MUST not be changed */
2849 ok (net_events.iErrorCode[k] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
2850 i, k, net_events.iErrorCode[k]);
2851 }
2852 }
2853 }
2854 closesocket(s);
2855 WSACloseEvent(event);
2856 if (i == 2) closesocket(s2);
2857 }
2858 }
2859 }
2860
2861 static DWORD WINAPI SelectReadThread(void *param)
2862 {
2863 select_thread_params *par = param;
2864 fd_set readfds;
2865 int ret;
2866 struct sockaddr_in addr;
2867 struct timeval select_timeout;
2868
2869 FD_ZERO(&readfds);
2870 FD_SET(par->s, &readfds);
2871 select_timeout.tv_sec=5;
2872 select_timeout.tv_usec=0;
2873 addr.sin_family = AF_INET;
2874 addr.sin_addr.s_addr = inet_addr(SERVERIP);
2875 addr.sin_port = htons(SERVERPORT);
2876
2877 do_bind(par->s, (struct sockaddr *)&addr, sizeof(addr));
2878 wsa_ok(listen(par->s, SOMAXCONN ), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
2879
2880 SetEvent(server_ready);
2881 ret = select(par->s+1, &readfds, NULL, NULL, &select_timeout);
2882 par->ReadKilled = (ret == 1);
2883
2884 return 0;
2885 }
2886
2887 static DWORD WINAPI SelectCloseThread(void *param)
2888 {
2889 SOCKET s = *(SOCKET*)param;
2890 Sleep(500);
2891 closesocket(s);
2892 return 0;
2893 }
2894
2895 static void test_errors(void)
2896 {
2897 SOCKET sock;
2898 SOCKADDR_IN SockAddr;
2899 int ret, err;
2900
2901 WSASetLastError(NO_ERROR);
2902 sock = socket(PF_INET, SOCK_STREAM, 0);
2903 ok( (sock != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2904 memset(&SockAddr, 0, sizeof(SockAddr));
2905 SockAddr.sin_family = AF_INET;
2906 SockAddr.sin_port = htons(6924);
2907 SockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
2908
2909 ret = connect(sock, (PSOCKADDR)&SockAddr, sizeof(SockAddr));
2910 ok( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got: %d\n", ret );
2911 if (ret == SOCKET_ERROR)
2912 {
2913 err = WSAGetLastError();
2914 ok( (err == WSAECONNREFUSED), "expected WSAECONNREFUSED, got: %d\n", err );
2915 }
2916
2917 {
2918 TIMEVAL timeval;
2919 fd_set set = {1, {sock}};
2920
2921 timeval.tv_sec = 0;
2922 timeval.tv_usec = 50000;
2923
2924 ret = select(1, NULL, &set, NULL, &timeval);
2925 ok( (ret == 0), "expected 0 (timeout), got: %d\n", ret );
2926 }
2927
2928 ret = closesocket(sock);
2929 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
2930 }
2931
2932 static void test_listen(void)
2933 {
2934 SOCKET fdA, fdB;
2935 int ret, acceptc, olen = sizeof(acceptc);
2936 struct sockaddr_in address;
2937
2938 memset(&address, 0, sizeof(address));
2939 address.sin_addr.s_addr = inet_addr("127.0.0.1");
2940 address.sin_family = AF_INET;
2941 address.sin_port = htons(SERVERPORT);
2942
2943 /* invalid socket tests */
2944 SetLastError(0xdeadbeef);
2945 ok ((listen(0, 0) == SOCKET_ERROR), "listen did not fail\n");
2946 ret = WSAGetLastError();
2947 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
2948
2949 SetLastError(0xdeadbeef);
2950 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR), "listen did not fail\n");
2951 ret = WSAGetLastError();
2952 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
2953
2954 /* tcp tests */
2955 fdA = socket(AF_INET, SOCK_STREAM, 0);
2956 ok ((fdA != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2957
2958 fdB = socket(AF_INET, SOCK_STREAM, 0);
2959 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2960
2961 SetLastError(0xdeadbeef);
2962 ok ((listen(fdA, -2) == SOCKET_ERROR), "listen did not fail\n");
2963 ret = WSAGetLastError();
2964 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
2965
2966 SetLastError(0xdeadbeef);
2967 ok ((listen(fdA, 1) == SOCKET_ERROR), "listen did not fail\n");
2968 ret = WSAGetLastError();
2969 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
2970
2971 SetLastError(0xdeadbeef);
2972 ok ((listen(fdA, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
2973 ret = WSAGetLastError();
2974 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
2975
2976 ok (!bind(fdA, (struct sockaddr*) &address, sizeof(address)), "bind failed\n");
2977
2978 SetLastError(0xdeadbeef);
2979 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
2980 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
2981
2982 acceptc = 0xdead;
2983 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
2984 ok (!ret, "getsockopt failed\n");
2985 ok (acceptc == 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc);
2986
2987 acceptc = 1;
2988 WSASetLastError(0xdeadbeef);
2989 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
2990 ok(ret == -1, "expected failure\n");
2991 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
2992
2993 acceptc = 0;
2994 WSASetLastError(0xdeadbeef);
2995 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
2996 ok(ret == -1, "expected failure\n");
2997 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
2998
2999 ok (!listen(fdA, 0), "listen failed\n");
3000 ok (!listen(fdA, SOMAXCONN), "double listen failed\n");
3001
3002 acceptc = 0xdead;
3003 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3004 ok (!ret, "getsockopt failed\n");
3005 ok (acceptc == 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc);
3006
3007 acceptc = 1;
3008 WSASetLastError(0xdeadbeef);
3009 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
3010 ok(ret == -1, "expected failure\n");
3011 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
3012
3013 acceptc = 0;
3014 WSASetLastError(0xdeadbeef);
3015 ret = setsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char *)&acceptc, sizeof(acceptc));
3016 ok(ret == -1, "expected failure\n");
3017 ok(WSAGetLastError() == WSAENOPROTOOPT, "got error %u\n", WSAGetLastError());
3018
3019 SetLastError(0xdeadbeef);
3020 ok ((listen(fdB, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3021 ret = WSAGetLastError();
3022 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3023
3024 ret = closesocket(fdB);
3025 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3026
3027 fdB = socket(AF_INET, SOCK_STREAM, 0);
3028 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3029
3030 SetLastError(0xdeadbeef);
3031 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3032 ret = WSAGetLastError();
3033 ok (ret == WSAEADDRINUSE, "expected 10048, received %d\n", ret);
3034
3035 ret = closesocket(fdA);
3036 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3037 ret = closesocket(fdB);
3038 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3039 }
3040
3041 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
3042 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
3043 static void test_select(void)
3044 {
3045 static char tmp_buf[1024];
3046
3047 SOCKET fdListen, fdRead, fdWrite;
3048 fd_set readfds, writefds, exceptfds;
3049 unsigned int maxfd;
3050 int ret, len;
3051 char buffer;
3052 struct timeval select_timeout;
3053 struct sockaddr_in address;
3054 select_thread_params thread_params;
3055 HANDLE thread_handle;
3056 DWORD ticks, id;
3057
3058 fdRead = socket(AF_INET, SOCK_STREAM, 0);
3059 ok( (fdRead != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3060 fdWrite = socket(AF_INET, SOCK_STREAM, 0);
3061 ok( (fdWrite != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3062
3063 maxfd = fdRead;
3064 if (fdWrite > maxfd)
3065 maxfd = fdWrite;
3066
3067 FD_ZERO_ALL();
3068 FD_SET_ALL(fdRead);
3069 FD_SET_ALL(fdWrite);
3070 select_timeout.tv_sec=0;
3071 select_timeout.tv_usec=0;
3072
3073 ticks = GetTickCount();
3074 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3075 ticks = GetTickCount() - ticks;
3076 ok(ret == 0, "select should not return any socket handles\n");
3077 ok(ticks < 10, "select was blocking for %u ms, expected < 10 ms\n", ticks);
3078 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3079 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
3080 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3081 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
3082
3083 FD_ZERO_ALL();
3084 FD_SET_ALL(fdRead);
3085 FD_SET_ALL(fdWrite);
3086 select_timeout.tv_sec=0;
3087 select_timeout.tv_usec=500;
3088
3089 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3090 ok(ret == 0, "select should not return any socket handles\n");
3091 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3092 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
3093 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3094 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
3095
3096 ok ((listen(fdWrite, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3097 ret = closesocket(fdWrite);
3098 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
3099
3100 thread_params.s = fdRead;
3101 thread_params.ReadKilled = FALSE;
3102 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
3103 thread_handle = CreateThread (NULL, 0, SelectReadThread, &thread_params, 0, &id );
3104 ok ( (thread_handle != NULL), "CreateThread failed unexpectedly: %d\n", GetLastError());
3105
3106 WaitForSingleObject (server_ready, INFINITE);
3107 Sleep(200);
3108 ret = closesocket(fdRead);
3109 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
3110
3111 WaitForSingleObject (thread_handle, 1000);
3112 ok ( thread_params.ReadKilled, "closesocket did not wake up select\n");
3113 ret = recv(fdRead, &buffer, 1, MSG_PEEK);
3114 ok( (ret == -1), "peek at closed socket expected -1 got %d\n", ret);
3115
3116 /* Test selecting invalid handles */
3117 FD_ZERO_ALL();
3118
3119 SetLastError(0);
3120 ret = select(maxfd+1, 0, 0, 0, &select_timeout);
3121 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3122 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3123
3124 SetLastError(0);
3125 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3126 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3127 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3128
3129 FD_SET(INVALID_SOCKET, &readfds);
3130 SetLastError(0);
3131 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3132 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3133 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3134 ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3135
3136 FD_ZERO(&readfds);
3137 FD_SET(INVALID_SOCKET, &writefds);
3138 SetLastError(0);
3139 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3140 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3141 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3142 ok ( !FD_ISSET(fdRead, &writefds), "FD should not be set\n");
3143
3144 FD_ZERO(&writefds);
3145 FD_SET(INVALID_SOCKET, &exceptfds);
3146 SetLastError(0);
3147 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3148 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3149 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3150 ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3151
3152 tcp_socketpair(&fdRead, &fdWrite);
3153 maxfd = fdRead;
3154 if(fdWrite > maxfd) maxfd = fdWrite;
3155
3156 FD_ZERO(&readfds);
3157 FD_SET(fdRead, &readfds);
3158 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
3159 ok(!ret, "select returned %d\n", ret);
3160
3161 FD_ZERO(&writefds);
3162 FD_SET(fdWrite, &writefds);
3163 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
3164 ok(ret == 1, "select returned %d\n", ret);
3165 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3166
3167 /* tests for overlapping fd_set pointers */
3168 FD_ZERO(&readfds);
3169 FD_SET(fdWrite, &readfds);
3170 ret = select(fdWrite+1, &readfds, &readfds, NULL, &select_timeout);
3171 ok(ret == 1, "select returned %d\n", ret);
3172 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3173
3174 FD_ZERO(&readfds);
3175 FD_SET(fdWrite, &readfds);
3176 FD_SET(fdRead, &readfds);
3177 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3178 ok(ret == 2, "select returned %d\n", ret);
3179 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3180 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3181
3182 ok(send(fdWrite, "test", 4, 0) == 4, "failed to send data\n");
3183 FD_ZERO(&readfds);
3184 FD_SET(fdRead, &readfds);
3185 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
3186 ok(ret == 1, "select returned %d\n", ret);
3187 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3188
3189 FD_ZERO(&readfds);
3190 FD_SET(fdWrite, &readfds);
3191 FD_SET(fdRead, &readfds);
3192 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3193 ok(ret == 2, "select returned %d\n", ret);
3194 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3195 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3196
3197 while(1) {
3198 FD_ZERO(&writefds);
3199 FD_SET(fdWrite, &writefds);
3200 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
3201 if(!ret) break;
3202 ok(send(fdWrite, tmp_buf, sizeof(tmp_buf), 0) > 0, "failed to send data\n");
3203 }
3204 FD_ZERO(&readfds);
3205 FD_SET(fdWrite, &readfds);
3206 FD_SET(fdRead, &readfds);
3207 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3208 ok(ret == 1, "select returned %d\n", ret);
3209 ok(!FD_ISSET(fdWrite, &readfds), "fdWrite socket is in the set\n");
3210 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3211
3212 ok(send(fdRead, "test", 4, 0) == 4, "failed to send data\n");
3213 Sleep(100);
3214 FD_ZERO(&readfds);
3215 FD_SET(fdWrite, &readfds);
3216 FD_SET(fdRead, &readfds);
3217 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3218 ok(ret == 2, "select returned %d\n", ret);
3219 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3220 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3221
3222 closesocket(fdRead);
3223 closesocket(fdWrite);
3224
3225 /* select() works in 3 distinct states:
3226 * - to check if a connection attempt ended with success or error;
3227 * - to check if a pending connection is waiting for acceptance;
3228 * - to check for data to read, availability for write and OOB data
3229 *
3230 * The tests below ensure that all conditions are tested.
3231 */
3232 memset(&address, 0, sizeof(address));
3233 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3234 address.sin_family = AF_INET;
3235 len = sizeof(address);
3236 fdListen = setup_server_socket(&address, &len);
3237 select_timeout.tv_sec = 1;
3238 select_timeout.tv_usec = 250000;
3239
3240 /* When no events are pending select returns 0 with no error */
3241 FD_ZERO_ALL();
3242 FD_SET_ALL(fdListen);
3243 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3244 ok(ret == 0, "expected 0, got %d\n", ret);
3245
3246 /* When a socket is attempting to connect the listening socket receives the read descriptor */
3247 fdWrite = setup_connector_socket(&address, len, TRUE);
3248 FD_ZERO_ALL();
3249 FD_SET_ALL(fdListen);
3250 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3251 ok(ret == 1, "expected 1, got %d\n", ret);
3252 ok(FD_ISSET(fdListen, &readfds), "fdListen socket is not in the set\n");
3253 len = sizeof(address);
3254 fdRead = accept(fdListen, (struct sockaddr*) &address, &len);
3255 ok(fdRead != INVALID_SOCKET, "expected a valid socket\n");
3256
3257 /* The connector is signaled through the write descriptor */
3258 FD_ZERO_ALL();
3259 FD_SET_ALL(fdListen);
3260 FD_SET_ALL(fdRead);
3261 FD_SET_ALL(fdWrite);
3262 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3263 ok(ret == 2, "expected 2, got %d\n", ret);
3264 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3265 ok(FD_ISSET(fdRead, &writefds), "fdRead socket is not in the set\n");
3266 len = sizeof(id);
3267 id = 0xdeadbeef;
3268 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
3269 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
3270 ok(id == 0, "expected 0, got %d\n", id);
3271
3272 /* When data is received the receiver gets the read descriptor */
3273 ret = send(fdWrite, "1234", 4, 0);
3274 ok(ret == 4, "expected 4, got %d\n", ret);
3275 FD_ZERO_ALL();
3276 FD_SET_ALL(fdListen);
3277 FD_SET(fdRead, &readfds);
3278 FD_SET(fdRead, &exceptfds);
3279 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3280 ok(ret == 1, "expected 1, got %d\n", ret);
3281 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3282 ok(!FD_ISSET(fdRead, &exceptfds), "fdRead socket is in the set\n");
3283 FD_ZERO_ALL();
3284 FD_SET_ALL(fdRead);
3285 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3286 ok(ret == 2, "expected 1, got %d\n", ret);
3287 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3288 ok(FD_ISSET(fdRead, &writefds), "fdRead socket is not in the set\n");
3289 ok(!FD_ISSET(fdRead, &exceptfds), "fdRead socket is in the set\n");
3290 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
3291 ok(ret == 4, "expected 4, got %d\n", ret);
3292 ok(!strcmp(tmp_buf, "1234"), "data received differs from sent\n");
3293
3294 /* When OOB data is received the socket is set in the except descriptor */
3295 ret = send(fdWrite, "A", 1, MSG_OOB);
3296 ok(ret == 1, "expected 1, got %d\n", ret);
3297 FD_ZERO_ALL();
3298 FD_SET_ALL(fdListen);
3299 FD_SET(fdRead, &readfds);
3300 FD_SET(fdRead, &exceptfds);
3301 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3302 ok(ret == 1, "expected 1, got %d\n", ret);
3303 ok(FD_ISSET(fdRead, &exceptfds), "fdRead socket is not in the set\n");
3304 tmp_buf[0] = 0xAF;
3305 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
3306 ok(ret == 1, "expected 1, got %d\n", ret);
3307 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
3308
3309 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
3310 ret = 1;
3311 ret = setsockopt(fdRead, SOL_SOCKET, SO_OOBINLINE, (char*) &ret, sizeof(ret));
3312 ok(ret == 0, "expected 0, got %d\n", ret);
3313 ret = send(fdWrite, "A", 1, MSG_OOB);
3314 ok(ret == 1, "expected 1, got %d\n", ret);
3315 FD_ZERO_ALL();
3316 FD_SET_ALL(fdListen);
3317 FD_SET(fdRead, &readfds);
3318 FD_SET(fdRead, &exceptfds);
3319 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3320 ok(ret == 1, "expected 1, got %d\n", ret);
3321 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3322 tmp_buf[0] = 0xAF;
3323 SetLastError(0xdeadbeef);
3324 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
3325 ok(ret == SOCKET_ERROR, "expected SOCKET_ERROR, got %d\n", ret);
3326 ok(GetLastError() == WSAEINVAL, "expected 10022, got %d\n", GetLastError());
3327 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
3328 ok(ret == 1, "expected 1, got %d\n", ret);
3329 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
3330
3331 /* When the connection is closed the socket is set in the read descriptor */
3332 ret = closesocket(fdRead);
3333 ok(ret == 0, "expected 0, got %d\n", ret);
3334 FD_ZERO_ALL();
3335 FD_SET_ALL(fdListen);
3336 FD_SET(fdWrite, &readfds);
3337 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3338 ok(ret == 1, "expected 1, got %d\n", ret);
3339 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3340 ret = recv(fdWrite, tmp_buf, sizeof(tmp_buf), 0);
3341 ok(ret == 0, "expected 0, got %d\n", ret);
3342 ret = closesocket(fdWrite);
3343 ok(ret == 0, "expected 0, got %d\n", ret);
3344
3345 /* w10pro64 sometimes takes over 2 seconds for an error to be reported. */
3346 if (winetest_interactive)
3347 {
3348 const struct sockaddr_in invalid_addr =
3349 {
3350 .sin_family = AF_INET,
3351 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
3352 .sin_port = 255,
3353 };
3354
3355 fdWrite = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3356 set_blocking(fdWrite, FALSE);
3357
3358 ret = connect(fdWrite, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
3359 ok(ret == -1, "got %d\n", ret);
3360 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
3361
3362 FD_ZERO_ALL();
3363 FD_SET(fdWrite, &readfds);
3364 FD_SET(fdWrite, &writefds);
3365 FD_SET(fdWrite, &exceptfds);
3366 select_timeout.tv_sec = 10;
3367 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3368 ok(ret == 1, "expected 1, got %d\n", ret);
3369 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
3370 ok(select_timeout.tv_usec == 250000, "select timeout should not have changed\n");
3371
3372 len = sizeof(id);
3373 id = 0xdeadbeef;
3374 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
3375 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
3376 ok(id == WSAECONNREFUSED, "got error %u\n", id);
3377
3378 len = sizeof(id);
3379 id = 0xdeadbeef;
3380 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
3381 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
3382 ok(id == WSAECONNREFUSED, "got error %u\n", id);
3383
3384 FD_ZERO_ALL();
3385 FD_SET(fdWrite, &readfds);
3386 FD_SET(fdWrite, &writefds);
3387 FD_SET(fdWrite, &exceptfds);
3388 select_timeout.tv_sec = 10;
3389 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3390 ok(ret == 1, "got %d\n", ret);
3391 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
3392
3393 /* Calling connect() doesn't reset the socket error, but a successful
3394 * connection does. This is kind of tricky to test, because while
3395 * Windows takes a couple seconds to actually fail the connection,
3396 * Linux will fail the connection almost immediately. */
3397
3398 ret = connect(fdWrite, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
3399 ok(ret == -1, "got %d\n", ret);
3400 todo_wine ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
3401 if (WSAGetLastError() == WSAECONNABORTED)
3402 {
3403 ret = connect(fdWrite, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
3404 ok(ret == -1, "got %d\n", ret);
3405 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
3406 }
3407
3408 len = sizeof(id);
3409 id = 0xdeadbeef;
3410 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
3411 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
3412 ok(id == WSAECONNREFUSED, "got error %u\n", id);
3413
3414 FD_ZERO_ALL();
3415 FD_SET(fdWrite, &readfds);
3416 FD_SET(fdWrite, &writefds);
3417 FD_SET(fdWrite, &exceptfds);
3418 select_timeout.tv_sec = 10;
3419 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3420 ok(ret == 1, "got %d\n", ret);
3421 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
3422
3423 len = sizeof(address);
3424 ret = getsockname(fdListen, (struct sockaddr *)&address, &len);
3425 ok(!ret, "got error %u\n", WSAGetLastError());
3426 ret = connect(fdWrite, (const struct sockaddr *)&address, sizeof(address));
3427 ok(ret == -1, "got %d\n", ret);
3428 todo_wine ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
3429 if (WSAGetLastError() == WSAECONNABORTED)
3430 {
3431 ret = connect(fdWrite, (const struct sockaddr *)&address, sizeof(address));
3432 ok(ret == -1, "got %d\n", ret);
3433 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
3434 }
3435
3436 FD_ZERO_ALL();
3437 FD_SET(fdWrite, &readfds);
3438 FD_SET(fdWrite, &writefds);
3439 FD_SET(fdWrite, &exceptfds);
3440 select_timeout.tv_sec = 1;
3441 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3442 ok(ret == 1, "expected 1, got %d\n", ret);
3443 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3444
3445 len = sizeof(id);
3446 id = 0xdeadbeef;
3447 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
3448 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
3449 ok(!id, "got error %u\n", id);
3450
3451 closesocket(fdWrite);
3452
3453 /* test polling after a (synchronous) failure */
3454
3455 fdWrite = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3456
3457 ret = connect(fdWrite, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
3458 ok(ret == -1, "got %d\n", ret);
3459 ok(WSAGetLastError() == WSAECONNREFUSED, "got error %u\n", WSAGetLastError());
3460
3461 FD_ZERO_ALL();
3462 FD_SET(fdWrite, &readfds);
3463 FD_SET(fdWrite, &writefds);
3464 FD_SET(fdWrite, &exceptfds);
3465 select_timeout.tv_sec = 0;
3466 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3467 ok(ret == 1, "expected 1, got %d\n", ret);
3468 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
3469
3470 len = sizeof(id);
3471 id = 0xdeadbeef;
3472 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char *)&id, &len);
3473 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
3474 todo_wine ok(!id, "got error %u\n", id);
3475
3476 closesocket(fdWrite);
3477 }
3478
3479 ret = closesocket(fdListen);
3480 ok(ret == 0, "expected 0, got %d\n", ret);
3481
3482 select_timeout.tv_sec = 1;
3483 select_timeout.tv_usec = 250000;
3484
3485 /* Try select() on a closed socket after connection */
3486 tcp_socketpair(&fdRead, &fdWrite);
3487 closesocket(fdRead);
3488 FD_ZERO_ALL();
3489 FD_SET_ALL(fdWrite);
3490 FD_SET_ALL(fdRead);
3491 SetLastError(0xdeadbeef);
3492 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
3493 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
3494 ok(GetLastError() == WSAENOTSOCK, "got %d\n", GetLastError());
3495 /* descriptor sets are unchanged */
3496 ok(readfds.fd_count == 2, "expected 2, got %d\n", readfds.fd_count);
3497 ok(exceptfds.fd_count == 2, "expected 2, got %d\n", exceptfds.fd_count);
3498 closesocket(fdWrite);
3499
3500 /* Close the socket currently being selected in a thread - bug 38399 */
3501 tcp_socketpair(&fdRead, &fdWrite);
3502 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
3503 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
3504 FD_ZERO_ALL();
3505 FD_SET_ALL(fdWrite);
3506 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
3507 ok(ret == 1, "expected 1, got %d\n", ret);
3508 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3509 WaitForSingleObject (thread_handle, 1000);
3510 closesocket(fdRead);
3511 /* test again with only the except descriptor */
3512 tcp_socketpair(&fdRead, &fdWrite);
3513 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
3514 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
3515 FD_ZERO_ALL();
3516 FD_SET(fdWrite, &exceptfds);
3517 SetLastError(0xdeadbeef);
3518 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
3519 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
3520 ok(GetLastError() == WSAENOTSOCK, "got %d\n", GetLastError());
3521 ok(!FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is in the set\n");
3522 WaitForSingleObject (thread_handle, 1000);
3523 closesocket(fdRead);
3524
3525 /* test UDP behavior of unbound sockets */
3526 select_timeout.tv_sec = 0;
3527 select_timeout.tv_usec = 250000;
3528 fdWrite = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
3529 ok(fdWrite != INVALID_SOCKET, "socket call failed\n");
3530 FD_ZERO_ALL();
3531 FD_SET_ALL(fdWrite);
3532 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3533 ok(ret == 1, "expected 1, got %d\n", ret);
3534 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3535 closesocket(fdWrite);
3536 }
3537 #undef FD_SET_ALL
3538 #undef FD_ZERO_ALL
3539
3540 static DWORD WINAPI AcceptKillThread(void *param)
3541 {
3542 select_thread_params *par = param;
3543 struct sockaddr_in address;
3544 int len = sizeof(address);
3545 SOCKET client_socket;
3546
3547 SetEvent(server_ready);
3548 client_socket = accept(par->s, (struct sockaddr*) &address, &len);
3549 if (client_socket != INVALID_SOCKET)
3550 closesocket(client_socket);
3551 par->ReadKilled = (client_socket == INVALID_SOCKET);
3552 return 0;
3553 }
3554
3555
3556 static int CALLBACK AlwaysDeferConditionFunc(LPWSABUF lpCallerId, LPWSABUF lpCallerData, LPQOS pQos,
3557 LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,
3558 GROUP *g, DWORD_PTR dwCallbackData)
3559 {
3560 return CF_DEFER;
3561 }
3562
3563 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len)
3564 {
3565 int ret, val;
3566 SOCKET server_socket;
3567
3568 server_socket = socket(AF_INET, SOCK_STREAM, 0);
3569 ok(server_socket != INVALID_SOCKET, "failed to bind socket, error %u\n", WSAGetLastError());
3570
3571 val = 1;
3572 ret = setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
3573 ok(!ret, "failed to set SO_REUSEADDR, error %u\n", WSAGetLastError());
3574
3575 ret = bind(server_socket, (struct sockaddr *)addr, *len);
3576 ok(!ret, "failed to bind socket, error %u\n", WSAGetLastError());
3577
3578 ret = getsockname(server_socket, (struct sockaddr *)addr, len);
3579 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
3580
3581 ret = listen(server_socket, 5);
3582 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
3583
3584 return server_socket;
3585 }
3586
3587 static SOCKET setup_connector_socket(const struct sockaddr_in *addr, int len, BOOL nonblock)
3588 {
3589 int ret;
3590 SOCKET connector;
3591
3592 connector = socket(AF_INET, SOCK_STREAM, 0);
3593 ok(connector != INVALID_SOCKET, "failed to create connector socket %d\n", WSAGetLastError());
3594
3595 if (nonblock)
3596 set_blocking(connector, !nonblock);
3597
3598 ret = connect(connector, (const struct sockaddr *)addr, len);
3599 if (!nonblock)
3600 ok(!ret, "connecting to accepting socket failed %d\n", WSAGetLastError());
3601 else if (ret == SOCKET_ERROR)
3602 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
3603
3604 return connector;
3605 }
3606
3607 static void test_accept(void)
3608 {
3609 int ret;
3610 SOCKET server_socket, accepted = INVALID_SOCKET, connector;
3611 struct sockaddr_in address;
3612 SOCKADDR_STORAGE ss, ss_empty;
3613 int socklen;
3614 select_thread_params thread_params;
3615 HANDLE thread_handle = NULL;
3616 DWORD id;
3617
3618 memset(&address, 0, sizeof(address));
3619 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3620 address.sin_family = AF_INET;
3621
3622 socklen = sizeof(address);
3623 server_socket = setup_server_socket(&address, &socklen);
3624
3625 connector = setup_connector_socket(&address, socklen, FALSE);
3626 if (connector == INVALID_SOCKET) goto done;
3627
3628 accepted = WSAAccept(server_socket, NULL, NULL, AlwaysDeferConditionFunc, 0);
3629 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
3630
3631 accepted = accept(server_socket, NULL, 0);
3632 ok(accepted != INVALID_SOCKET, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
3633
3634 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
3635
3636 thread_params.s = server_socket;
3637 thread_params.ReadKilled = FALSE;
3638 thread_handle = CreateThread(NULL, 0, AcceptKillThread, &thread_params, 0, &id);
3639
3640 WaitForSingleObject(server_ready, INFINITE);
3641 Sleep(200);
3642 ret = closesocket(server_socket);
3643 ok(!ret, "failed to close socket, error %u\n", WSAGetLastError());
3644
3645 WaitForSingleObject(thread_handle, 1000);
3646 ok(thread_params.ReadKilled, "closesocket did not wake up accept\n");
3647
3648 closesocket(accepted);
3649 closesocket(connector);
3650 accepted = connector = INVALID_SOCKET;
3651
3652 socklen = sizeof(address);
3653 server_socket = setup_server_socket(&address, &socklen);
3654
3655 connector = setup_connector_socket(&address, socklen, FALSE);
3656 if (connector == INVALID_SOCKET) goto done;
3657
3658 socklen = 0;
3659 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
3660 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
3661 ok(!socklen, "got %d\n", socklen);
3662 closesocket(connector);
3663 connector = INVALID_SOCKET;
3664
3665 socklen = sizeof(address);
3666 connector = setup_connector_socket(&address, socklen, FALSE);
3667 if (connector == INVALID_SOCKET) goto done;
3668
3669 accepted = WSAAccept(server_socket, NULL, NULL, NULL, 0);
3670 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
3671 closesocket(accepted);
3672 closesocket(connector);
3673 accepted = connector = INVALID_SOCKET;
3674
3675 socklen = sizeof(address);
3676 connector = setup_connector_socket(&address, socklen, FALSE);
3677 if (connector == INVALID_SOCKET) goto done;
3678
3679 socklen = sizeof(ss);
3680 memset(&ss, 0, sizeof(ss));
3681 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
3682 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
3683 ok(socklen != sizeof(ss), "unexpected length\n");
3684 ok(ss.ss_family, "family not set\n");
3685 closesocket(accepted);
3686 closesocket(connector);
3687 accepted = connector = INVALID_SOCKET;
3688
3689 socklen = sizeof(address);
3690 connector = setup_connector_socket(&address, socklen, FALSE);
3691 if (connector == INVALID_SOCKET) goto done;
3692
3693 socklen = 0;
3694 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
3695 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
3696 ok(!socklen, "got %d\n", socklen);
3697 closesocket(connector);
3698 accepted = connector = INVALID_SOCKET;
3699
3700 socklen = sizeof(address);
3701 connector = setup_connector_socket(&address, socklen, FALSE);
3702 if (connector == INVALID_SOCKET) goto done;
3703
3704 accepted = accept(server_socket, NULL, NULL);
3705 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
3706 closesocket(accepted);
3707 closesocket(connector);
3708 accepted = connector = INVALID_SOCKET;
3709
3710 socklen = sizeof(address);
3711 connector = setup_connector_socket(&address, socklen, FALSE);
3712 if (connector == INVALID_SOCKET) goto done;
3713
3714 socklen = sizeof(ss);
3715 memset(&ss, 0, sizeof(ss));
3716 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
3717 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
3718 ok(socklen != sizeof(ss), "unexpected length\n");
3719 ok(ss.ss_family, "family not set\n");
3720 closesocket(accepted);
3721 closesocket(connector);
3722 accepted = connector = INVALID_SOCKET;
3723
3724 socklen = sizeof(address);
3725 connector = setup_connector_socket(&address, socklen, FALSE);
3726 if (connector == INVALID_SOCKET) goto done;
3727
3728 memset(&ss, 0, sizeof(ss));
3729 memset(&ss_empty, 0, sizeof(ss_empty));
3730 accepted = accept(server_socket, (struct sockaddr *)&ss, NULL);
3731 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
3732 ok(!memcmp(&ss, &ss_empty, sizeof(ss)), "structure is different\n");
3733
3734 done:
3735 if (accepted != INVALID_SOCKET)
3736 closesocket(accepted);
3737 if (connector != INVALID_SOCKET)
3738 closesocket(connector);
3739 if (thread_handle != NULL)
3740 CloseHandle(thread_handle);
3741 if (server_ready != INVALID_HANDLE_VALUE)
3742 CloseHandle(server_ready);
3743 if (server_socket != INVALID_SOCKET)
3744 closesocket(server_socket);
3745 }
3746
3747 static void test_extendedSocketOptions(void)
3748 {
3749 WSADATA wsa;
3750 SOCKET sock;
3751 struct sockaddr_in sa;
3752 int sa_len = sizeof(struct sockaddr_in);
3753 int optval, optlen = sizeof(int), ret;
3754 BOOL bool_opt_val;
3755 LINGER linger_val;
3756
3757 ret = WSAStartup(MAKEWORD(2,0), &wsa);
3758 ok(!ret, "failed to startup, error %u\n", WSAGetLastError());
3759
3760 memset(&sa, 0, sa_len);
3761
3762 sa.sin_family = AF_INET;
3763 sa.sin_port = htons(0);
3764 sa.sin_addr.s_addr = htonl(INADDR_ANY);
3765
3766 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
3767 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
3768
3769 ret = bind(sock, (struct sockaddr *) &sa, sa_len);
3770 ok(!ret, "failed to bind socket, error %u\n", WSAGetLastError());
3771
3772 ret = getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
3773
3774 ok(ret == 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret);
3775 ok((optval == 65507) || (optval == 65527),
3776 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval);
3777
3778 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
3779 SetLastError(0xdeadbeef);
3780 optval = 0xdeadbeef;
3781 optlen = sizeof(int);
3782 ret = getsockopt(sock, 0xffffffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
3783 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
3784 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3785 ret, WSAGetLastError(), optval, optval);
3786
3787 /* more invalid values for level */
3788 SetLastError(0xdeadbeef);
3789 optval = 0xdeadbeef;
3790 optlen = sizeof(int);
3791 ret = getsockopt(sock, 0x1234ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
3792 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
3793 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3794 ret, WSAGetLastError(), optval, optval);
3795
3796 SetLastError(0xdeadbeef);
3797 optval = 0xdeadbeef;
3798 optlen = sizeof(int);
3799 ret = getsockopt(sock, 0x8000ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
3800 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
3801 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3802 ret, WSAGetLastError(), optval, optval);
3803
3804 SetLastError(0xdeadbeef);
3805 optval = 0xdeadbeef;
3806 optlen = sizeof(int);
3807 ret = getsockopt(sock, 0x00008000, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
3808 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
3809 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3810 ret, WSAGetLastError(), optval, optval);
3811
3812 SetLastError(0xdeadbeef);
3813 optval = 0xdeadbeef;
3814 optlen = sizeof(int);
3815 ret = getsockopt(sock, 0x00000800, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
3816 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
3817 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3818 ret, WSAGetLastError(), optval, optval);
3819
3820 SetLastError(0xdeadbeef);
3821 optlen = sizeof(LINGER);
3822 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
3823 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAENOPROTOOPT),
3824 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
3825 ret, WSAGetLastError());
3826 closesocket(sock);
3827
3828 sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
3829 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
3830
3831 ret = bind(sock, (struct sockaddr *) &sa, sa_len);
3832 ok(!ret, "failed to bind socket, error %u\n", WSAGetLastError());
3833
3834 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
3835 ok(ret == 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret);
3836
3837 optlen = sizeof(BOOL);
3838 ret = getsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *)&bool_opt_val, &optlen);
3839 ok(ret == 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret);
3840 ok((linger_val.l_onoff && !bool_opt_val) || (!linger_val.l_onoff && bool_opt_val),
3841 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
3842 bool_opt_val, linger_val.l_onoff);
3843
3844 closesocket(sock);
3845 WSACleanup();
3846 }
3847
3848 static void test_getsockname(void)
3849 {
3850 WSADATA wsa;
3851 SOCKET sock;
3852 struct sockaddr_in sa_set, sa_get;
3853 int sa_set_len = sizeof(struct sockaddr_in);
3854 int sa_get_len = sa_set_len;
3855 static const unsigned char null_padding[] = {0,0,0,0,0,0,0,0};
3856 int ret;
3857 struct hostent *h;
3858
3859 ret = WSAStartup(MAKEWORD(2,0), &wsa);
3860 ok(!ret, "failed to startup, error %u\n", WSAGetLastError());
3861
3862 memset(&sa_set, 0, sa_set_len);
3863
3864 sa_set.sin_family = AF_INET;
3865 sa_set.sin_port = htons(0);
3866 sa_set.sin_addr.s_addr = htonl(INADDR_ANY);
3867
3868 sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
3869 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
3870
3871 sa_get = sa_set;
3872 WSASetLastError(0xdeadbeef);
3873 ret = getsockname(sock, (struct sockaddr *)&sa_get, &sa_get_len);
3874 ok(ret == SOCKET_ERROR, "expected failure\n");
3875 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
3876 ok(!memcmp(&sa_get, &sa_set, sizeof(sa_get)), "address should not be changed\n");
3877
3878 ret = bind(sock, (struct sockaddr *) &sa_set, sa_set_len);
3879 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
3880
3881 WSASetLastError(0xdeadbeef);
3882 memset(&sa_get, 0, sizeof(sa_get));
3883 ret = getsockname(sock, (struct sockaddr *) &sa_get, &sa_get_len);
3884 ok(!ret, "got %d\n", ret);
3885 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
3886 ok(sa_get.sin_family == AF_INET, "got family %#x\n", sa_get.sin_family);
3887 ok(sa_get.sin_port != 0, "got zero port\n");
3888 ok(sa_get.sin_addr.s_addr == INADDR_ANY, "got addr %08x\n", sa_get.sin_addr.s_addr);
3889
3890 ret = memcmp(sa_get.sin_zero, null_padding, 8);
3891 ok(ret == 0, "getsockname did not zero the sockaddr_in structure\n");
3892
3893 sa_get_len = sizeof(sa_get) - 1;
3894 WSASetLastError(0xdeadbeef);
3895 ret = getsockname(sock, (struct sockaddr *)&sa_get, &sa_get_len);
3896 ok(ret == -1, "expected failure\n");
3897 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
3898 ok(sa_get_len == sizeof(sa_get) - 1, "got size %d\n", sa_get_len);
3899
3900 closesocket(sock);
3901
3902 h = gethostbyname("");
3903 if (h && h->h_length == 4) /* this test is only meaningful in IPv4 */
3904 {
3905 int i;
3906 for (i = 0; h->h_addr_list[i]; i++)
3907 {
3908 char ipstr[32];
3909 struct in_addr ip;
3910 ip.s_addr = *(ULONG *) h->h_addr_list[i];
3911
3912 sock = socket(AF_INET, SOCK_DGRAM, 0);
3913 ok(sock != INVALID_SOCKET, "socket failed with %d\n", GetLastError());
3914
3915 memset(&sa_set, 0, sizeof(sa_set));
3916 sa_set.sin_family = AF_INET;
3917 sa_set.sin_addr.s_addr = ip.s_addr;
3918 /* The same address we bind must be the same address we get */
3919 ret = bind(sock, (struct sockaddr*)&sa_set, sizeof(sa_set));
3920 ok(ret == 0, "bind failed with %d\n", GetLastError());
3921 sa_get_len = sizeof(sa_get);
3922 ret = getsockname(sock, (struct sockaddr*)&sa_get, &sa_get_len);
3923 ok(ret == 0, "getsockname failed with %d\n", GetLastError());
3924 strcpy(ipstr, inet_ntoa(sa_get.sin_addr));
3925 ok(sa_get.sin_addr.s_addr == sa_set.sin_addr.s_addr,
3926 "address does not match: %s != %s\n", ipstr, inet_ntoa(sa_set.sin_addr));
3927
3928 closesocket(sock);
3929 }
3930 }
3931
3932 WSACleanup();
3933 }
3934
3935 static DWORD apc_error, apc_size;
3936 static OVERLAPPED *apc_overlapped;
3937 static unsigned int apc_count;
3938
3939 static void WINAPI socket_apc(DWORD error, DWORD size, OVERLAPPED *overlapped, DWORD flags)
3940 {
3941 ok(!flags, "got flags %#x\n", flags);
3942 ++apc_count;
3943 apc_error = error;
3944 apc_size = size;
3945 apc_overlapped = overlapped;
3946 }
3947
3948 #define check_fionread_siocatmark(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, FALSE, FALSE)
3949 #define check_fionread_siocatmark_todo(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, TRUE, TRUE)
3950 #define check_fionread_siocatmark_todo_oob(a, b, c) check_fionread_siocatmark_(__LINE__, a, b, c, FALSE, TRUE)
3951 static void check_fionread_siocatmark_(int line, SOCKET s, unsigned int normal, unsigned int oob,
3952 BOOL todo_normal, BOOL todo_oob)
3953 {
3954 int ret, value;
3955 DWORD size;
3956
3957 value = 0xdeadbeef;
3958 WSASetLastError(0xdeadbeef);
3959 ret = WSAIoctl(s, FIONREAD, NULL, 0, &value, sizeof(value), &size, NULL, NULL);
3960 ok_(__FILE__, line)(!ret, "expected success\n");
3961 ok_(__FILE__, line)(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
3962 todo_wine_if (todo_normal) ok_(__FILE__, line)(value == normal, "FIONBIO returned %u\n", value);
3963
3964 value = 0xdeadbeef;
3965 WSASetLastError(0xdeadbeef);
3966 ret = WSAIoctl(s, SIOCATMARK, NULL, 0, &value, sizeof(value), &size, NULL, NULL);
3967 ok_(__FILE__, line)(!ret, "expected success\n");
3968 ok_(__FILE__, line)(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
3969 todo_wine_if (todo_oob) ok_(__FILE__, line)(value == oob, "SIOCATMARK returned %u\n", value);
3970 }
3971
3972 static void test_fionread_siocatmark(void)
3973 {
3974 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
3975 OVERLAPPED overlapped = {0}, *overlapped_ptr;
3976 SOCKET client, server;
3977 char buffer[5];
3978 int ret, value;
3979 ULONG_PTR key;
3980 HANDLE port;
3981 DWORD size;
3982
3983 tcp_socketpair(&client, &server);
3984 set_blocking(client, FALSE);
3985 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
3986
3987 WSASetLastError(0xdeadbeef);
3988 ret = ioctlsocket(client, FIONREAD, (u_long *)1);
3989 ok(ret == -1, "expected failure\n");
3990 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
3991
3992 WSASetLastError(0xdeadbeef);
3993 ret = ioctlsocket(client, SIOCATMARK, (u_long *)1);
3994 ok(ret == -1, "expected failure\n");
3995 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
3996
3997 WSASetLastError(0xdeadbeef);
3998 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value), NULL, NULL, NULL);
3999 ok(ret == -1, "expected failure\n");
4000 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4001
4002 WSASetLastError(0xdeadbeef);
4003 size = 0xdeadbeef;
4004 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value) - 1, &size, NULL, NULL);
4005 ok(ret == -1, "expected failure\n");
4006 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4007 ok(size == 0xdeadbeef, "got size %u\n", size);
4008
4009 WSASetLastError(0xdeadbeef);
4010 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value), NULL, NULL, NULL);
4011 ok(ret == -1, "expected failure\n");
4012 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4013
4014 WSASetLastError(0xdeadbeef);
4015 size = 0xdeadbeef;
4016 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value) - 1, &size, NULL, NULL);
4017 ok(ret == -1, "expected failure\n");
4018 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4019 ok(size == 0xdeadbeef, "got size %u\n", size);
4020
4021 check_fionread_siocatmark(client, 0, TRUE);
4022
4023 port = CreateIoCompletionPort((HANDLE)client, NULL, 123, 0);
4024
4025 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value), NULL, &overlapped, NULL);
4026 ok(ret == -1, "expected failure\n");
4027 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4028
4029 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value), NULL, &overlapped, NULL);
4030 ok(ret == -1, "expected failure\n");
4031 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4032
4033 WSASetLastError(0xdeadbeef);
4034 size = 0xdeadbeef;
4035 value = 0xdeadbeef;
4036 overlapped.Internal = 0xdeadbeef;
4037 overlapped.InternalHigh = 0xdeadbeef;
4038 ret = WSAIoctl(client, FIONREAD, NULL, 0, &value, sizeof(value), &size, &overlapped, NULL);
4039 ok(!ret, "expected success\n");
4040 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4041 ok(!value, "got %u\n", value);
4042 ok(size == sizeof(value), "got size %u\n", size);
4043 ok(!overlapped.Internal, "got status %#x\n", (NTSTATUS)overlapped.Internal);
4044 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
4045
4046 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
4047 ok(ret, "got error %u\n", GetLastError());
4048 ok(!size, "got size %u\n", size);
4049 ok(key == 123, "got key %Iu\n", key);
4050 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
4051
4052 WSASetLastError(0xdeadbeef);
4053 size = 0xdeadbeef;
4054 value = 0xdeadbeef;
4055 overlapped.Internal = 0xdeadbeef;
4056 overlapped.InternalHigh = 0xdeadbeef;
4057 ret = WSAIoctl(client, SIOCATMARK, NULL, 0, &value, sizeof(value), &size, &overlapped, NULL);
4058 ok(!ret, "expected success\n");
4059 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4060 ok(value == TRUE, "got %u\n", value);
4061 ok(size == sizeof(value), "got size %u\n", size);
4062 ok(!overlapped.Internal, "got status %#x\n", (NTSTATUS)overlapped.Internal);
4063 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
4064
4065 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
4066 ok(ret, "got error %u\n", GetLastError());
4067 ok(!size, "got size %u\n", size);
4068 ok(key == 123, "got key %Iu\n", key);
4069 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
4070
4071 ret = send(server, "data", 5, 0);
4072 ok(ret == 5, "got %d\n", ret);
4073
4074 /* wait for the data to be available */
4075 check_poll_mask(client, POLLRDNORM, POLLRDNORM);
4076
4077 check_fionread_siocatmark(client, 5, TRUE);
4078
4079 ret = send(server, "a", 1, MSG_OOB);
4080 ok(ret == 1, "got %d\n", ret);
4081
4082 /* wait for the data to be available */
4083 check_poll_mask(client, POLLRDBAND, POLLRDBAND);
4084
4085 check_fionread_siocatmark_todo_oob(client, 5, FALSE);
4086
4087 ret = send(server, "a", 1, MSG_OOB);
4088 ok(ret == 1, "got %d\n", ret);
4089
4090 check_fionread_siocatmark_todo(client, 5, FALSE);
4091
4092 ret = recv(client, buffer, 3, 0);
4093 ok(ret == 3, "got %d\n", ret);
4094
4095 check_fionread_siocatmark_todo(client, 2, FALSE);
4096
4097 ret = recv(client, buffer, 1, MSG_OOB);
4098 ok(ret == 1, "got %d\n", ret);
4099
4100 /* wait for the data to be available */
4101 check_poll_mask_todo(client, POLLRDBAND, POLLRDBAND);
4102
4103 check_fionread_siocatmark_todo(client, 2, FALSE);
4104
4105 ret = recv(client, buffer, 5, 0);
4106 todo_wine ok(ret == 2, "got %d\n", ret);
4107
4108 check_fionread_siocatmark(client, 0, FALSE);
4109
4110 ret = recv(client, buffer, 1, MSG_OOB);
4111 todo_wine ok(ret == 1, "got %d\n", ret);
4112
4113 check_fionread_siocatmark_todo_oob(client, 0, TRUE);
4114
4115 ret = send(server, "a", 1, MSG_OOB);
4116 ok(ret == 1, "got %d\n", ret);
4117
4118 /* wait for the data to be available */
4119 check_poll_mask(client, POLLRDBAND, POLLRDBAND);
4120
4121 ret = 1;
4122 ret = setsockopt(client, SOL_SOCKET, SO_OOBINLINE, (char *)&ret, sizeof(ret));
4123 ok(!ret, "got error %u\n", WSAGetLastError());
4124
4125 check_fionread_siocatmark_todo_oob(client, 1, FALSE);
4126
4127 ret = recv(client, buffer, 1, 0);
4128 ok(ret == 1, "got %d\n", ret);
4129
4130 check_fionread_siocatmark(client, 0, TRUE);
4131
4132 ret = send(server, "a", 1, MSG_OOB);
4133 ok(ret == 1, "got %d\n", ret);
4134
4135 /* wait for the data to be available */
4136 check_poll_mask(client, POLLRDNORM, POLLRDNORM);
4137
4138 check_fionread_siocatmark(client, 1, TRUE);
4139
4140 closesocket(client);
4141 closesocket(server);
4142
4143 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4144
4145 check_fionread_siocatmark(server, 0, TRUE);
4146
4147 ret = bind(server, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
4148 ok(!ret, "got error %u\n", WSAGetLastError());
4149
4150 check_fionread_siocatmark(server, 0, TRUE);
4151
4152 closesocket(server);
4153 CloseHandle(overlapped.hEvent);
4154
4155 /* test with APCs */
4156
4157 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4158
4159 ret = WSAIoctl(server, FIONREAD, NULL, 0, &value, sizeof(value), NULL, &overlapped, socket_apc);
4160 ok(ret == -1, "expected failure\n");
4161 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4162
4163 ret = WSAIoctl(server, SIOCATMARK, NULL, 0, &value, sizeof(value), NULL, &overlapped, socket_apc);
4164 ok(ret == -1, "expected failure\n");
4165 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4166
4167 apc_count = 0;
4168 size = 0xdeadbeef;
4169 ret = WSAIoctl(server, FIONREAD, NULL, 0, &value, sizeof(value), &size, &overlapped, socket_apc);
4170 ok(!ret, "expected success\n");
4171 ok(size == sizeof(value), "got size %u\n", size);
4172
4173 ret = SleepEx(0, TRUE);
4174 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
4175 ok(apc_count == 1, "APC was called %u times\n", apc_count);
4176 ok(!apc_error, "got APC error %u\n", apc_error);
4177 ok(!apc_size, "got APC size %u\n", apc_size);
4178 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
4179
4180 apc_count = 0;
4181 size = 0xdeadbeef;
4182 ret = WSAIoctl(server, SIOCATMARK, NULL, 0, &value, sizeof(value), &size, &overlapped, socket_apc);
4183 ok(!ret, "expected success\n");
4184 ok(size == sizeof(value), "got size %u\n", size);
4185
4186 ret = SleepEx(0, TRUE);
4187 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
4188 ok(apc_count == 1, "APC was called %u times\n", apc_count);
4189 ok(!apc_error, "got APC error %u\n", apc_error);
4190 ok(!apc_size, "got APC size %u\n", apc_size);
4191 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
4192
4193 closesocket(server);
4194 }
4195
4196 static void test_fionbio(void)
4197 {
4198 OVERLAPPED overlapped = {0}, *overlapped_ptr;
4199 u_long one = 1, zero = 0;
4200 HANDLE port, event;
4201 ULONG_PTR key;
4202 void *output;
4203 DWORD size;
4204 SOCKET s;
4205 int ret;
4206
4207 event = CreateEventW(NULL, TRUE, FALSE, NULL);
4208 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4209 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
4210
4211 WSASetLastError(0xdeadbeef);
4212 ret = ioctlsocket(s, FIONBIO, (u_long *)1);
4213 ok(ret == -1, "expected failure\n");
4214 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4215
4216 WSASetLastError(0xdeadbeef);
4217 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, NULL, NULL, NULL);
4218 ok(ret == -1, "expected failure\n");
4219 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4220
4221 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one) - 1, NULL, 0, &size, &overlapped, NULL);
4222 ok(ret == -1, "expected failure\n");
4223 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4224
4225 size = 0xdeadbeef;
4226 WSASetLastError(0xdeadbeef);
4227 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, NULL, NULL);
4228 ok(!ret, "expected success\n");
4229 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4230 ok(!size, "got size %u\n", size);
4231
4232 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one) + 1, NULL, 0, &size, NULL, NULL);
4233 ok(!ret, "got error %u\n", WSAGetLastError());
4234
4235 output = VirtualAlloc(NULL, 4, MEM_RESERVE | MEM_COMMIT, PAGE_NOACCESS);
4236 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one) + 1, output, 4, &size, NULL, NULL);
4237 ok(!ret, "got error %u\n", WSAGetLastError());
4238 VirtualFree(output, 0, MEM_FREE);
4239
4240 overlapped.Internal = 0xdeadbeef;
4241 overlapped.InternalHigh = 0xdeadbeef;
4242 size = 0xdeadbeef;
4243 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, &overlapped, NULL);
4244 ok(!ret, "expected success\n");
4245 ok(!size, "got size %u\n", size);
4246
4247 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
4248 ok(ret, "got error %u\n", GetLastError());
4249 ok(!size, "got size %u\n", size);
4250 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
4251 ok(!overlapped.Internal, "got status %#x\n", (NTSTATUS)overlapped.Internal);
4252 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
4253
4254 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, NULL, &overlapped, NULL);
4255 ok(ret == -1, "expected failure\n");
4256 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4257
4258 ret = WSAEventSelect(s, event, FD_READ);
4259 ok(!ret, "got error %u\n", WSAGetLastError());
4260
4261 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, NULL, NULL);
4262 ok(!ret, "got error %u\n", WSAGetLastError());
4263
4264 size = 0xdeadbeef;
4265 ret = WSAIoctl(s, FIONBIO, &zero, sizeof(zero), NULL, 0, &size, NULL, NULL);
4266 ok(ret == -1, "expected failure\n");
4267 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
4268 todo_wine ok(!size, "got size %u\n", size);
4269
4270 CloseHandle(port);
4271 closesocket(s);
4272 CloseHandle(event);
4273
4274 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4275
4276 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, NULL, &overlapped, socket_apc);
4277 ok(ret == -1, "expected failure\n");
4278 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4279
4280 apc_count = 0;
4281 size = 0xdeadbeef;
4282 ret = WSAIoctl(s, FIONBIO, &one, sizeof(one), NULL, 0, &size, &overlapped, socket_apc);
4283 ok(!ret, "expected success\n");
4284 ok(!size, "got size %u\n", size);
4285
4286 ret = SleepEx(0, TRUE);
4287 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
4288 ok(apc_count == 1, "APC was called %u times\n", apc_count);
4289 ok(!apc_error, "got APC error %u\n", apc_error);
4290 ok(!apc_size, "got APC size %u\n", apc_size);
4291 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
4292
4293 closesocket(s);
4294 }
4295
4296 static void test_keepalive_vals(void)
4297 {
4298 OVERLAPPED overlapped = {0}, *overlapped_ptr;
4299 struct tcp_keepalive kalive;
4300 ULONG_PTR key;
4301 HANDLE port;
4302 SOCKET sock;
4303 DWORD size;
4304 int ret;
4305
4306 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4307 ok(sock != INVALID_SOCKET, "Creating the socket failed: %d\n", WSAGetLastError());
4308 port = CreateIoCompletionPort((HANDLE)sock, NULL, 123, 0);
4309
4310 WSASetLastError(0xdeadbeef);
4311 size = 0xdeadbeef;
4312 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, 0, NULL, 0, &size, NULL, NULL);
4313 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
4314 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4315 ok(!size, "got size %u\n", size);
4316
4317 WSASetLastError(0xdeadbeef);
4318 size = 0xdeadbeef;
4319 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, NULL, sizeof(kalive), NULL, 0, &size, NULL, NULL);
4320 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
4321 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4322 ok(!size, "got size %u\n", size);
4323
4324 WSASetLastError(0xdeadbeef);
4325 size = 0xdeadbeef;
4326 make_keepalive(kalive, 0, 0, 0);
4327 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
4328 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
4329 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4330 ok(!size, "got size %u\n", size);
4331
4332 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, NULL, NULL, NULL);
4333 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
4334 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4335
4336 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, NULL, &overlapped, NULL);
4337 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
4338 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4339
4340 WSASetLastError(0xdeadbeef);
4341 size = 0xdeadbeef;
4342 overlapped.Internal = 0xdeadbeef;
4343 overlapped.InternalHigh = 0xdeadbeef;
4344 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive) - 1, NULL, 0, &size, &overlapped, NULL);
4345 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
4346 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4347 ok(size == 0xdeadbeef, "got size %u\n", size);
4348 todo_wine ok(overlapped.Internal == STATUS_PENDING, "got status %#x\n", (NTSTATUS)overlapped.Internal);
4349 ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
4350
4351 WSASetLastError(0xdeadbeef);
4352 size = 0xdeadbeef;
4353 overlapped.Internal = 0xdeadbeef;
4354 overlapped.InternalHigh = 0xdeadbeef;
4355 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, &overlapped, NULL);
4356 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
4357 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4358 todo_wine ok(size == 0xdeadbeef, "got size %u\n", size);
4359
4360 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
4361 ok(ret, "got error %u\n", GetLastError());
4362 ok(!size, "got size %u\n", size);
4363 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
4364 ok(!overlapped.Internal, "got status %#x\n", (NTSTATUS)overlapped.Internal);
4365 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
4366
4367 make_keepalive(kalive, 1, 0, 0);
4368 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
4369 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
4370
4371 make_keepalive(kalive, 1, 1000, 1000);
4372 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
4373 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
4374
4375 make_keepalive(kalive, 1, 10000, 10000);
4376 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
4377 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
4378
4379 make_keepalive(kalive, 1, 100, 100);
4380 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
4381 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
4382
4383 make_keepalive(kalive, 0, 100, 100);
4384 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, NULL, NULL);
4385 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
4386
4387 CloseHandle(port);
4388 closesocket(sock);
4389
4390 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4391
4392 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, NULL, &overlapped, socket_apc);
4393 ok(ret == -1, "expected failure\n");
4394 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4395
4396 apc_count = 0;
4397 size = 0xdeadbeef;
4398 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(kalive), NULL, 0, &size, &overlapped, socket_apc);
4399 ok(!ret, "expected success\n");
4400 ok(!size, "got size %u\n", size);
4401
4402 ret = SleepEx(0, TRUE);
4403 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
4404 ok(apc_count == 1, "APC was called %u times\n", apc_count);
4405 ok(!apc_error, "got APC error %u\n", apc_error);
4406 ok(!apc_size, "got APC size %u\n", apc_size);
4407 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
4408
4409 closesocket(sock);
4410 }
4411
4412 static void test_unsupported_ioctls(void)
4413 {
4414 OVERLAPPED overlapped = {0}, *overlapped_ptr;
4415 unsigned int i;
4416 ULONG_PTR key;
4417 HANDLE port;
4418 DWORD size;
4419 SOCKET s;
4420 int ret;
4421
4422 static const DWORD codes[] = {0xdeadbeef, FIOASYNC, 0x667e, SIO_FLUSH};
4423
4424 for (i = 0; i < ARRAY_SIZE(codes); ++i)
4425 {
4426 winetest_push_context("ioctl %#x", codes[i]);
4427 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4428 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
4429
4430 WSASetLastError(0xdeadbeef);
4431 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, NULL, &overlapped, NULL);
4432 ok(ret == -1, "expected failure\n");
4433 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4434
4435 WSASetLastError(0xdeadbeef);
4436 size = 0xdeadbeef;
4437 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, &size, NULL, NULL);
4438 ok(ret == -1, "expected failure\n");
4439 ok(WSAGetLastError() == WSAEOPNOTSUPP, "got error %u\n", WSAGetLastError());
4440 ok(!size, "got size %u\n", size);
4441
4442 WSASetLastError(0xdeadbeef);
4443 size = 0xdeadbeef;
4444 overlapped.Internal = 0xdeadbeef;
4445 overlapped.InternalHigh = 0xdeadbeef;
4446 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, &size, &overlapped, NULL);
4447 ok(ret == -1, "expected failure\n");
4448 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
4449 ok(size == 0xdeadbeef, "got size %u\n", size);
4450
4451 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
4452 ok(!ret, "expected failure\n");
4453 ok(GetLastError() == ERROR_NOT_SUPPORTED, "got error %u\n", GetLastError());
4454 ok(!size, "got size %u\n", size);
4455 ok(key == 123, "got key %Iu\n", key);
4456 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
4457 ok((NTSTATUS)overlapped.Internal == STATUS_NOT_SUPPORTED,
4458 "got status %#x\n", (NTSTATUS)overlapped.Internal);
4459 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
4460
4461 CloseHandle(port);
4462 closesocket(s);
4463
4464 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4465
4466 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, NULL, &overlapped, socket_apc);
4467 ok(ret == -1, "expected failure\n");
4468 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4469
4470 apc_count = 0;
4471 size = 0xdeadbeef;
4472 ret = WSAIoctl(s, codes[i], NULL, 0, NULL, 0, &size, &overlapped, socket_apc);
4473 ok(ret == -1, "expected failure\n");
4474 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
4475 ok(size == 0xdeadbeef, "got size %u\n", size);
4476
4477 ret = SleepEx(0, TRUE);
4478 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
4479 ok(apc_count == 1, "APC was called %u times\n", apc_count);
4480 ok(apc_error == WSAEOPNOTSUPP, "got APC error %u\n", apc_error);
4481 ok(!apc_size, "got APC size %u\n", apc_size);
4482 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
4483
4484 closesocket(s);
4485 winetest_pop_context();
4486 }
4487 }
4488
4489 static void test_get_extension_func(void)
4490 {
4491 OVERLAPPED overlapped = {0}, *overlapped_ptr;
4492 GUID acceptex_guid = WSAID_ACCEPTEX;
4493 GUID bogus_guid = {0xdeadbeef};
4494 ULONG_PTR key;
4495 HANDLE port;
4496 DWORD size;
4497 void *func;
4498 SOCKET s;
4499 int ret;
4500
4501 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4502 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
4503
4504 WSASetLastError(0xdeadbeef);
4505 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
4506 &func, sizeof(func), NULL, &overlapped, NULL);
4507 ok(ret == -1, "expected failure\n");
4508 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4509
4510 WSASetLastError(0xdeadbeef);
4511 size = 0xdeadbeef;
4512 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
4513 &func, sizeof(func), &size, NULL, NULL);
4514 ok(!ret, "expected success\n");
4515 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4516 ok(size == sizeof(func), "got size %u\n", size);
4517
4518 WSASetLastError(0xdeadbeef);
4519 size = 0xdeadbeef;
4520 overlapped.Internal = 0xdeadbeef;
4521 overlapped.InternalHigh = 0xdeadbeef;
4522 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
4523 &func, sizeof(func), &size, &overlapped, NULL);
4524 ok(!ret, "expected success\n");
4525 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4526 ok(size == sizeof(func), "got size %u\n", size);
4527
4528 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
4529 ok(ret, "got error %u\n", GetLastError());
4530 ok(!size, "got size %u\n", size);
4531 ok(key == 123, "got key %Iu\n", key);
4532 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
4533 ok(!overlapped.Internal, "got status %#x\n", (NTSTATUS)overlapped.Internal);
4534 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
4535
4536 size = 0xdeadbeef;
4537 overlapped.Internal = 0xdeadbeef;
4538 overlapped.InternalHigh = 0xdeadbeef;
4539 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &bogus_guid, sizeof(GUID),
4540 &func, sizeof(func), &size, &overlapped, NULL);
4541 ok(ret == -1, "expected failure\n");
4542 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
4543 ok(size == 0xdeadbeef, "got size %u\n", size);
4544 ok(overlapped.Internal == 0xdeadbeef, "got status %#x\n", (NTSTATUS)overlapped.Internal);
4545 ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
4546
4547 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
4548 ok(!ret, "expected failure\n");
4549 ok(GetLastError() == WAIT_TIMEOUT, "got error %u\n", WSAGetLastError());
4550
4551 CloseHandle(port);
4552 closesocket(s);
4553
4554 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4555
4556 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
4557 &func, sizeof(func), NULL, &overlapped, socket_apc);
4558 ok(ret == -1, "expected failure\n");
4559 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4560
4561 apc_count = 0;
4562 size = 0xdeadbeef;
4563 ret = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(GUID),
4564 &func, sizeof(func), &size, &overlapped, socket_apc);
4565 ok(!ret, "got error %u\n", WSAGetLastError());
4566 ok(size == sizeof(func), "got size %u\n", size);
4567
4568 ret = SleepEx(0, TRUE);
4569 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
4570 ok(apc_count == 1, "APC was called %u times\n", apc_count);
4571 ok(!apc_error, "got APC error %u\n", apc_error);
4572 ok(!apc_size, "got APC size %u\n", apc_size);
4573 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
4574
4575 closesocket(s);
4576 }
4577
4578 static void test_base_handle(void)
4579 {
4580 OVERLAPPED overlapped = {0}, *overlapped_ptr;
4581 unsigned int i;
4582 SOCKET s, base;
4583 ULONG_PTR key;
4584 HANDLE port;
4585 DWORD size;
4586 int ret;
4587
4588 static const struct
4589 {
4590 int family, type, protocol;
4591 }
4592 tests[] =
4593 {
4594 {AF_INET, SOCK_STREAM, IPPROTO_TCP},
4595 {AF_INET, SOCK_DGRAM, IPPROTO_UDP},
4596 {AF_INET6, SOCK_STREAM, IPPROTO_TCP},
4597 {AF_INET6, SOCK_DGRAM, IPPROTO_UDP},
4598 };
4599
4600 for (i = 0; i < ARRAY_SIZE(tests); ++i)
4601 {
4602 s = socket(tests[i].family, tests[i].type, tests[i].protocol);
4603 if (s == INVALID_SOCKET) continue;
4604 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
4605
4606 WSASetLastError(0xdeadbeef);
4607 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), NULL, &overlapped, NULL);
4608 ok(ret == -1, "expected failure\n");
4609 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4610
4611 WSASetLastError(0xdeadbeef);
4612 size = 0xdeadbeef;
4613 base = 0xdeadbeef;
4614 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), &size, NULL, NULL);
4615 ok(!ret, "expected success\n");
4616 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
4617 ok(size == sizeof(base), "got size %u\n", size);
4618 ok(base == s, "expected %#Ix, got %#Ix\n", s, base);
4619
4620 WSASetLastError(0xdeadbeef);
4621 size = 0xdeadbeef;
4622 base = 0xdeadbeef;
4623 overlapped.Internal = 0xdeadbeef;
4624 overlapped.InternalHigh = 0xdeadbeef;
4625 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), &size, &overlapped, NULL);
4626 ok(ret == -1, "expected failure\n");
4627 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
4628 ok(size == 0xdeadbeef, "got size %u\n", size);
4629
4630 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
4631 ok(!ret, "expected failure\n");
4632 ok(GetLastError() == ERROR_NOT_SUPPORTED, "got error %u\n", GetLastError());
4633 ok(!size, "got size %u\n", size);
4634 ok(key == 123, "got key %Iu\n", key);
4635 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
4636 ok((NTSTATUS)overlapped.Internal == STATUS_NOT_SUPPORTED, "got status %#x\n", (NTSTATUS)overlapped.Internal);
4637 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
4638 ok(base == 0xdeadbeef, "expected %#Ix, got %#Ix\n", s, base);
4639
4640 CloseHandle(port);
4641 closesocket(s);
4642
4643 s = socket(tests[i].family, tests[i].type, tests[i].protocol);
4644
4645 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), NULL, &overlapped, socket_apc);
4646 ok(ret == -1, "expected failure\n");
4647 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
4648
4649 apc_count = 0;
4650 size = 0xdeadbeef;
4651 base = 0xdeadbeef;
4652 ret = WSAIoctl(s, SIO_BASE_HANDLE, NULL, 0, &base, sizeof(base), &size, &overlapped, socket_apc);
4653 ok(ret == -1, "expected failure\n");
4654 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
4655 ok(size == 0xdeadbeef, "got size %u\n", size);
4656
4657 ret = SleepEx(0, TRUE);
4658 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
4659 ok(apc_count == 1, "APC was called %u times\n", apc_count);
4660 ok(apc_error == WSAEOPNOTSUPP, "got APC error %u\n", apc_error);
4661 ok(!apc_size, "got APC size %u\n", apc_size);
4662 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
4663 ok(base == 0xdeadbeef, "expected %#Ix, got %#Ix\n", s, base);
4664
4665 closesocket(s);
4666 }
4667 }
4668
4669 static BOOL drain_pause = FALSE;
4670 static DWORD WINAPI drain_socket_thread(LPVOID arg)
4671 {
4672 char buffer[1024];
4673 SOCKET sock = *(SOCKET*)arg;
4674 int ret;
4675
4676 while ((ret = recv(sock, buffer, sizeof(buffer), 0)) != 0)
4677 {
4678 if (ret < 0)
4679 {
4680 if (WSAGetLastError() == WSAEWOULDBLOCK)
4681 {
4682 fd_set readset;
4683 FD_ZERO(&readset);
4684 FD_SET(sock, &readset);
4685 select(sock+1, &readset, NULL, NULL, NULL);
4686 while (drain_pause)
4687 Sleep(100);
4688 }
4689 else
4690 break;
4691 }
4692 }
4693 return 0;
4694 }
4695
4696 static void test_send(void)
4697 {
4698 SOCKET src = INVALID_SOCKET;
4699 SOCKET dst = INVALID_SOCKET;
4700 HANDLE hThread = NULL;
4701 const int buflen = 1024*1024;
4702 char *buffer = NULL;
4703 int ret, i, zero = 0;
4704 WSABUF buf;
4705 OVERLAPPED ov;
4706 BOOL bret;
4707 DWORD id, bytes_sent, dwRet;
4708
4709 memset(&ov, 0, sizeof(ov));
4710
4711 tcp_socketpair(&src, &dst);
4712
4713 set_blocking(dst, FALSE);
4714 /* force disable buffering so we can get a pending overlapped request */
4715 ret = setsockopt(dst, SOL_SOCKET, SO_SNDBUF, (char *) &zero, sizeof(zero));
4716 ok(!ret, "setsockopt SO_SNDBUF failed: %d - %d\n", ret, GetLastError());
4717
4718 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
4719
4720 buffer = HeapAlloc(GetProcessHeap(), 0, buflen);
4721
4722 /* fill the buffer with some nonsense */
4723 for (i = 0; i < buflen; ++i)
4724 {
4725 buffer[i] = (char) i;
4726 }
4727
4728 ret = send(src, buffer, buflen, 0);
4729 ok(ret == buflen, "send should have sent %d bytes, but it only sent %d\n", buflen, ret);
4730
4731 buf.buf = buffer;
4732 buf.len = buflen;
4733
4734 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
4735 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
4736 if (!ov.hEvent)
4737 goto end;
4738
4739 bytes_sent = 0;
4740 WSASetLastError(12345);
4741 ret = WSASend(dst, &buf, 1, &bytes_sent, 0, &ov, NULL);
4742 ok(ret == SOCKET_ERROR, "expected failure\n");
4743 ok(WSAGetLastError() == ERROR_IO_PENDING, "wrong error %u\n", WSAGetLastError());
4744
4745 /* don't check for completion yet, we may need to drain the buffer while still sending */
4746 set_blocking(src, FALSE);
4747 for (i = 0; i < buflen; ++i)
4748 {
4749 int j = 0;
4750
4751 ret = recv(src, buffer, 1, 0);
4752 while (ret == SOCKET_ERROR && GetLastError() == WSAEWOULDBLOCK && j < 100)
4753 {
4754 j++;
4755 Sleep(50);
4756 ret = recv(src, buffer, 1, 0);
4757 }
4758
4759 ok(ret == 1, "Failed to receive data %d - %d (got %d/%d)\n", ret, GetLastError(), i, buflen);
4760 if (ret != 1)
4761 break;
4762
4763 ok(buffer[0] == (char) i, "Received bad data at position %d\n", i);
4764 }
4765
4766 dwRet = WaitForSingleObject(ov.hEvent, 1000);
4767 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
4768 if (dwRet == WAIT_OBJECT_0)
4769 {
4770 bret = GetOverlappedResult((HANDLE)dst, &ov, &bytes_sent, FALSE);
4771 ok(bret && bytes_sent == buflen,
4772 "Got %d instead of %d (%d - %d)\n", bytes_sent, buflen, bret, GetLastError());
4773 }
4774
4775 WSASetLastError(12345);
4776 ret = WSASend(INVALID_SOCKET, &buf, 1, NULL, 0, &ov, NULL);
4777 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
4778 "WSASend failed %d - %d\n", ret, WSAGetLastError());
4779
4780 WSASetLastError(12345);
4781 ret = WSASend(dst, &buf, 1, NULL, 0, &ov, NULL);
4782 ok(ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING,
4783 "Failed to start overlapped send %d - %d\n", ret, WSAGetLastError());
4784
4785 end:
4786 if (src != INVALID_SOCKET)
4787 closesocket(src);
4788 if (dst != INVALID_SOCKET)
4789 closesocket(dst);
4790 if (hThread != NULL)
4791 {
4792 dwRet = WaitForSingleObject(hThread, 500);
4793 ok(dwRet == WAIT_OBJECT_0, "failed to wait for thread termination: %d\n", GetLastError());
4794 CloseHandle(hThread);
4795 }
4796 if (ov.hEvent)
4797 CloseHandle(ov.hEvent);
4798 HeapFree(GetProcessHeap(), 0, buffer);
4799 }
4800
4801 #define WM_SOCKET (WM_USER+100)
4802
4803 struct event_test_ctx
4804 {
4805 int is_message;
4806 SOCKET socket;
4807 HANDLE event;
4808 HWND window;
4809 };
4810
4811 static void select_events(struct event_test_ctx *ctx, SOCKET socket, LONG events)
4812 {
4813 int ret;
4814
4815 if (ctx->is_message)
4816 ret = WSAAsyncSelect(socket, ctx->window, WM_USER, events);
4817 else
4818 ret = WSAEventSelect(socket, ctx->event, events);
4819 ok(!ret, "failed to select, error %u\n", WSAGetLastError());
4820 ctx->socket = socket;
4821 }
4822
4823 #define check_events(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, FALSE)
4824 #define check_events_todo(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, TRUE)
4825 #define check_events_todo_event(a, b, c, d) check_events_(__LINE__, a, b, c, d, TRUE, FALSE)
4826 #define check_events_todo_msg(a, b, c, d) check_events_(__LINE__, a, b, c, d, FALSE, TRUE)
4827 static void check_events_(int line, struct event_test_ctx *ctx,
4828 LONG flag1, LONG flag2, DWORD timeout, BOOL todo_event, BOOL todo_msg)
4829 {
4830 int ret;
4831
4832 if (ctx->is_message)
4833 {
4834 BOOL any_fail = FALSE;
4835 MSG msg;
4836
4837 if (flag1)
4838 {
4839 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
4840 while (!ret && !MsgWaitForMultipleObjects(0, NULL, FALSE, timeout, QS_POSTMESSAGE))
4841 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
4842 todo_wine_if (todo_msg && !ret) ok_(__FILE__, line)(ret, "expected a message\n");
4843 if (ret)
4844 {
4845 ok_(__FILE__, line)(msg.wParam == ctx->socket,
4846 "expected wparam %#Ix, got %#Ix\n", ctx->socket, msg.wParam);
4847 todo_wine_if (todo_msg && msg.lParam != flag1)
4848 ok_(__FILE__, line)(msg.lParam == flag1, "got first event %#Ix\n", msg.lParam);
4849 if (msg.lParam != flag1) any_fail = TRUE;
4850 }
4851 else
4852 any_fail = TRUE;
4853 }
4854 if (flag2)
4855 {
4856 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
4857 while (!ret && !MsgWaitForMultipleObjects(0, NULL, FALSE, timeout, QS_POSTMESSAGE))
4858 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
4859 ok_(__FILE__, line)(ret, "expected a message\n");
4860 ok_(__FILE__, line)(msg.wParam == ctx->socket, "got wparam %#Ix\n", msg.wParam);
4861 todo_wine_if (todo_msg) ok_(__FILE__, line)(msg.lParam == flag2, "got second event %#Ix\n", msg.lParam);
4862 }
4863 ret = PeekMessageA(&msg, ctx->window, WM_USER, WM_USER, PM_REMOVE);
4864 todo_wine_if (todo_msg && ret) ok_(__FILE__, line)(!ret, "got unexpected event %#Ix\n", msg.lParam);
4865 if (ret) any_fail = TRUE;
4866
4867 /* catch tests which succeed */
4868 todo_wine_if (todo_msg) ok_(__FILE__, line)(!any_fail, "event series matches\n");
4869 }
4870 else
4871 {
4872 WSANETWORKEVENTS events;
4873
4874 ret = WaitForSingleObject(ctx->event, timeout);
4875 if (flag1 | flag2)
4876 todo_wine_if (todo_event && ret) ok_(__FILE__, line)(!ret, "event wait timed out\n");
4877 else
4878 todo_wine_if (todo_event) ok_(__FILE__, line)(ret == WAIT_TIMEOUT, "expected timeout\n");
4879 ret = WSAEnumNetworkEvents(ctx->socket, ctx->event, &events);
4880 ok_(__FILE__, line)(!ret, "failed to get events, error %u\n", WSAGetLastError());
4881 todo_wine_if (todo_event)
4882 ok_(__FILE__, line)(events.lNetworkEvents == (flag1 | flag2), "got events %#x\n", events.lNetworkEvents);
4883 }
4884 }
4885
4886 static void test_accept_events(struct event_test_ctx *ctx)
4887 {
4888 const struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
4889 SOCKET listener, server, client, client2;
4890 struct sockaddr_in destaddr;
4891 int len, ret;
4892
4893 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4894 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
4895
4896 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
4897
4898 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
4899 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
4900 len = sizeof(destaddr);
4901 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
4902 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
4903 ret = listen(listener, 2);
4904 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
4905
4906 check_events(ctx, 0, 0, 0);
4907
4908 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4909 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
4910 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
4911 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
4912
4913 check_events(ctx, FD_ACCEPT, 0, 200);
4914 check_events(ctx, 0, 0, 0);
4915 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
4916 if (ctx->is_message)
4917 check_events(ctx, FD_ACCEPT, 0, 200);
4918 check_events(ctx, 0, 0, 0);
4919 select_events(ctx, listener, 0);
4920 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
4921 if (ctx->is_message)
4922 check_events(ctx, FD_ACCEPT, 0, 200);
4923 check_events(ctx, 0, 0, 0);
4924
4925 client2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4926 ok(client2 != -1, "failed to create socket, error %u\n", WSAGetLastError());
4927 ret = connect(client2, (struct sockaddr *)&destaddr, sizeof(destaddr));
4928 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
4929
4930 if (!ctx->is_message)
4931 check_events_todo(ctx, FD_ACCEPT, 0, 200);
4932 check_events(ctx, 0, 0, 0);
4933
4934 server = accept(listener, NULL, NULL);
4935 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
4936 closesocket(server);
4937
4938 check_events(ctx, FD_ACCEPT, 0, 200);
4939 check_events(ctx, 0, 0, 0);
4940
4941 server = accept(listener, NULL, NULL);
4942 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
4943 closesocket(server);
4944
4945 check_events(ctx, 0, 0, 0);
4946
4947 closesocket(client2);
4948 closesocket(client);
4949
4950 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4951 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
4952 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
4953 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
4954
4955 check_events(ctx, FD_ACCEPT, 0, 200);
4956
4957 server = accept(listener, NULL, NULL);
4958 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
4959 closesocket(server);
4960 closesocket(client);
4961
4962 check_events(ctx, 0, 0, 200);
4963
4964 closesocket(listener);
4965
4966 /* Connect and then select. */
4967
4968 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4969 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
4970 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
4971 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
4972 len = sizeof(destaddr);
4973 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
4974 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
4975 ret = listen(listener, 2);
4976 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
4977
4978 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4979 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
4980 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
4981 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
4982
4983 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
4984
4985 check_events(ctx, FD_ACCEPT, 0, 200);
4986
4987 server = accept(listener, NULL, NULL);
4988 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
4989 closesocket(server);
4990 closesocket(client);
4991
4992 /* As above, but select on a subset not containing FD_ACCEPT first. */
4993
4994 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
4995
4996 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4997 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
4998 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
4999 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
5000
5001 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
5002 check_events(ctx, FD_ACCEPT, 0, 200);
5003
5004 server = accept(listener, NULL, NULL);
5005 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
5006 closesocket(server);
5007 closesocket(client);
5008
5009 /* As above, but call accept() before selecting. */
5010
5011 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB);
5012
5013 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5014 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
5015 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
5016 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
5017 Sleep(200);
5018 server = accept(listener, NULL, NULL);
5019 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
5020
5021 select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT);
5022 check_events(ctx, 0, 0, 200);
5023
5024 closesocket(server);
5025 closesocket(client);
5026
5027 closesocket(listener);
5028 }
5029
5030 static void test_connect_events(struct event_test_ctx *ctx)
5031 {
5032 const struct sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
5033 SOCKET listener, server, client;
5034 struct sockaddr_in destaddr;
5035 int len, ret;
5036
5037 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5038 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
5039 ret = bind(listener, (const struct sockaddr *)&addr, sizeof(addr));
5040 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
5041 len = sizeof(destaddr);
5042 ret = getsockname(listener, (struct sockaddr *)&destaddr, &len);
5043 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
5044 ret = listen(listener, 2);
5045 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
5046
5047 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5048 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
5049
5050 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
5051 check_events(ctx, 0, 0, 0);
5052
5053 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
5054 ok(!ret || WSAGetLastError() == WSAEWOULDBLOCK, "failed to connect, error %u\n", WSAGetLastError());
5055
5056 check_events(ctx, FD_CONNECT, FD_WRITE, 200);
5057 check_events(ctx, 0, 0, 0);
5058 select_events(ctx, client, 0);
5059 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
5060 if (ctx->is_message)
5061 check_events(ctx, FD_WRITE, 0, 200);
5062 check_events(ctx, 0, 0, 0);
5063
5064 server = accept(listener, NULL, NULL);
5065 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
5066
5067 closesocket(client);
5068 closesocket(server);
5069
5070 /* Connect and then select. */
5071
5072 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5073 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
5074
5075 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
5076 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
5077
5078 server = accept(listener, NULL, NULL);
5079 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
5080
5081 ret = send(client, "data", 5, 0);
5082 ok(ret == 5, "got %d\n", ret);
5083
5084 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
5085 if (ctx->is_message)
5086 check_events(ctx, FD_WRITE, 0, 200);
5087 else
5088 check_events(ctx, FD_CONNECT, FD_WRITE, 200);
5089
5090 closesocket(client);
5091 closesocket(server);
5092
5093 /* As above, but select on a subset not containing FD_CONNECT first. */
5094
5095 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5096 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
5097
5098 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_OOB | FD_READ | FD_WRITE);
5099
5100 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
5101 ok(!ret || WSAGetLastError() == WSAEWOULDBLOCK, "failed to connect, error %u\n", WSAGetLastError());
5102
5103 server = accept(listener, NULL, NULL);
5104 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
5105
5106 check_events(ctx, FD_WRITE, 0, 200);
5107
5108 select_events(ctx, client, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
5109
5110 if (ctx->is_message)
5111 check_events(ctx, FD_WRITE, 0, 200);
5112 else
5113 check_events_todo(ctx, FD_CONNECT, 0, 200);
5114
5115 closesocket(client);
5116 closesocket(server);
5117
5118 closesocket(listener);
5119 }
5120
5121 /* perform a blocking recv() even on a nonblocking socket */
5122 static int sync_recv(SOCKET s, void *buffer, int len, DWORD flags)
5123 {
5124 OVERLAPPED overlapped = {0};
5125 WSABUF wsabuf;
5126 DWORD ret_len;
5127 int ret;
5128
5129 overlapped.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
5130 wsabuf.buf = buffer;
5131 wsabuf.len = len;
5132 ret = WSARecv(s, &wsabuf, 1, &ret_len, &flags, &overlapped, NULL);
5133 if (ret == -1 && WSAGetLastError() == ERROR_IO_PENDING)
5134 {
5135 ret = WaitForSingleObject(overlapped.hEvent, 1000);
5136 ok(!ret, "wait timed out\n");
5137 ret = WSAGetOverlappedResult(s, &overlapped, &ret_len, FALSE, &flags);
5138 ret = (ret ? 0 : -1);
5139 }
5140 CloseHandle(overlapped.hEvent);
5141 if (!ret) return ret_len;
5142 return -1;
5143 }
5144
5145 static void test_write_events(struct event_test_ctx *ctx)
5146 {
5147 static const int buffer_size = 1024 * 1024;
5148 SOCKET server, client;
5149 char *buffer;
5150 int ret;
5151
5152 buffer = malloc(buffer_size);
5153
5154 tcp_socketpair(&client, &server);
5155 set_blocking(client, FALSE);
5156
5157 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
5158 check_events(ctx, FD_WRITE, 0, 200);
5159 check_events(ctx, 0, 0, 0);
5160 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
5161 if (ctx->is_message)
5162 check_events(ctx, FD_WRITE, 0, 200);
5163 check_events(ctx, 0, 0, 0);
5164 select_events(ctx, server, 0);
5165 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
5166 if (ctx->is_message)
5167 check_events(ctx, FD_WRITE, 0, 200);
5168 check_events(ctx, 0, 0, 0);
5169
5170 ret = send(server, "data", 5, 0);
5171 ok(ret == 5, "got %d\n", ret);
5172
5173 check_events(ctx, 0, 0, 0);
5174
5175 ret = sync_recv(client, buffer, buffer_size, 0);
5176 ok(ret == 5, "got %d\n", ret);
5177
5178 check_events(ctx, 0, 0, 0);
5179
5180 if (!broken(1))
5181 {
5182 while ((ret = send(server, buffer, buffer_size, 0)) == buffer_size);
5183 /* Windows will never send less than buffer_size bytes here, but Linux
5184 * may do a short write. */
5185 todo_wine_if (ret > 0)
5186 {
5187 ok(ret == -1, "got %d\n", ret);
5188 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
5189 }
5190
5191 while (recv(client, buffer, buffer_size, 0) > 0);
5192 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
5193
5194 /* Broken on Windows versions older than win10v1607 (though sometimes
5195 * works regardless, for unclear reasons. */
5196 check_events(ctx, FD_WRITE, 0, 200);
5197 check_events(ctx, 0, 0, 0);
5198 select_events(ctx, server, 0);
5199 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
5200 if (ctx->is_message)
5201 check_events(ctx, FD_WRITE, 0, 200);
5202 check_events(ctx, 0, 0, 0);
5203 }
5204
5205 closesocket(server);
5206 closesocket(client);
5207
5208 /* Despite the documentation, and unlike FD_ACCEPT and FD_RECV, calling
5209 * send() doesn't clear the FD_WRITE bit. */
5210
5211 tcp_socketpair(&client, &server);
5212
5213 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ | FD_WRITE);
5214
5215 ret = send(server, "data", 5, 0);
5216 ok(ret == 5, "got %d\n", ret);
5217
5218 check_events(ctx, FD_WRITE, 0, 200);
5219
5220 closesocket(server);
5221 closesocket(client);
5222
5223 free(buffer);
5224 }
5225
5226 static void test_read_events(struct event_test_ctx *ctx)
5227 {
5228 SOCKET server, client;
5229 unsigned int i;
5230 char buffer[8];
5231 int ret;
5232
5233 tcp_socketpair(&client, &server);
5234 set_blocking(client, FALSE);
5235
5236 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
5237 check_events(ctx, 0, 0, 0);
5238
5239 ret = send(client, "data", 5, 0);
5240 ok(ret == 5, "got %d\n", ret);
5241
5242 check_events(ctx, FD_READ, 0, 200);
5243 check_events(ctx, 0, 0, 0);
5244 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
5245 if (ctx->is_message)
5246 check_events(ctx, FD_READ, 0, 200);
5247 check_events(ctx, 0, 0, 0);
5248 select_events(ctx, server, 0);
5249 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
5250 if (ctx->is_message)
5251 check_events(ctx, FD_READ, 0, 200);
5252 check_events(ctx, 0, 0, 0);
5253
5254 ret = send(client, "data", 5, 0);
5255 ok(ret == 5, "got %d\n", ret);
5256
5257 if (!ctx->is_message)
5258 check_events_todo(ctx, FD_READ, 0, 200);
5259 check_events(ctx, 0, 0, 0);
5260
5261 ret = recv(server, buffer, 2, 0);
5262 ok(ret == 2, "got %d\n", ret);
5263
5264 check_events(ctx, FD_READ, 0, 200);
5265 check_events(ctx, 0, 0, 0);
5266
5267 ret = recv(server, buffer, -1, 0);
5268 ok(ret == -1, "got %d\n", ret);
5269 ok(WSAGetLastError() == WSAEFAULT || WSAGetLastError() == WSAENOBUFS /* < Windows 7 */,
5270 "got error %u\n", WSAGetLastError());
5271
5272 if (ctx->is_message)
5273 check_events_todo_msg(ctx, FD_READ, 0, 200);
5274 check_events(ctx, 0, 0, 0);
5275
5276 for (i = 0; i < 8; ++i)
5277 {
5278 ret = sync_recv(server, buffer, 1, 0);
5279 ok(ret == 1, "got %d\n", ret);
5280
5281 if (i < 7)
5282 check_events(ctx, FD_READ, 0, 200);
5283 check_events(ctx, 0, 0, 0);
5284 }
5285
5286 /* Send data while we're not selecting. */
5287
5288 select_events(ctx, server, 0);
5289 ret = send(client, "data", 5, 0);
5290 ok(ret == 5, "got %d\n", ret);
5291 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
5292
5293 check_events(ctx, FD_READ, 0, 200);
5294
5295 ret = recv(server, buffer, 5, 0);
5296 ok(ret == 5, "got %d\n", ret);
5297
5298 select_events(ctx, server, 0);
5299 ret = send(client, "data", 5, 0);
5300 ok(ret == 5, "got %d\n", ret);
5301 ret = sync_recv(server, buffer, 5, 0);
5302 ok(ret == 5, "got %d\n", ret);
5303 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ);
5304
5305 check_events(ctx, 0, 0, 200);
5306
5307 closesocket(server);
5308 closesocket(client);
5309 }
5310
5311 static void test_oob_events(struct event_test_ctx *ctx)
5312 {
5313 SOCKET server, client;
5314 char buffer[1];
5315 int ret;
5316
5317 tcp_socketpair(&client, &server);
5318 set_blocking(client, FALSE);
5319
5320 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
5321 check_events(ctx, 0, 0, 0);
5322
5323 ret = send(client, "a", 1, MSG_OOB);
5324 ok(ret == 1, "got %d\n", ret);
5325
5326 check_events(ctx, FD_OOB, 0, 200);
5327 check_events(ctx, 0, 0, 0);
5328 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
5329 if (ctx->is_message)
5330 check_events(ctx, FD_OOB, 0, 200);
5331 check_events(ctx, 0, 0, 0);
5332 select_events(ctx, server, 0);
5333 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
5334 if (ctx->is_message)
5335 check_events(ctx, FD_OOB, 0, 200);
5336 check_events(ctx, 0, 0, 0);
5337
5338 ret = send(client, "b", 1, MSG_OOB);
5339 ok(ret == 1, "got %d\n", ret);
5340
5341 if (!ctx->is_message)
5342 check_events_todo_event(ctx, FD_OOB, 0, 200);
5343 check_events(ctx, 0, 0, 0);
5344
5345 ret = recv(server, buffer, 1, MSG_OOB);
5346 ok(ret == 1, "got %d\n", ret);
5347
5348 check_events_todo(ctx, FD_OOB, 0, 200);
5349 check_events(ctx, 0, 0, 0);
5350
5351 ret = recv(server, buffer, 1, MSG_OOB);
5352 todo_wine ok(ret == 1, "got %d\n", ret);
5353
5354 check_events(ctx, 0, 0, 0);
5355
5356 /* Send data while we're not selecting. */
5357
5358 select_events(ctx, server, 0);
5359 ret = send(client, "a", 1, MSG_OOB);
5360 ok(ret == 1, "got %d\n", ret);
5361 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
5362
5363 check_events(ctx, FD_OOB, 0, 200);
5364
5365 ret = recv(server, buffer, 1, MSG_OOB);
5366 ok(ret == 1, "got %d\n", ret);
5367
5368 closesocket(server);
5369 closesocket(client);
5370 }
5371
5372 static void test_close_events(struct event_test_ctx *ctx)
5373 {
5374 SOCKET server, client;
5375 char buffer[5];
5376 int ret;
5377
5378 /* Test closesocket(). */
5379
5380 tcp_socketpair(&client, &server);
5381
5382 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
5383
5384 closesocket(client);
5385
5386 check_events(ctx, FD_CLOSE, 0, 200);
5387 check_events(ctx, 0, 0, 0);
5388 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
5389 if (ctx->is_message)
5390 check_events(ctx, FD_CLOSE, 0, 200);
5391 check_events(ctx, 0, 0, 0);
5392 select_events(ctx, server, 0);
5393 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
5394 if (ctx->is_message)
5395 check_events(ctx, FD_CLOSE, 0, 200);
5396 check_events(ctx, 0, 0, 0);
5397
5398 ret = recv(server, buffer, 5, 0);
5399 ok(!ret, "got %d\n", ret);
5400
5401 check_events(ctx, 0, 0, 0);
5402
5403 closesocket(server);
5404
5405 /* Test shutdown(remote end, SD_SEND). */
5406
5407 tcp_socketpair(&client, &server);
5408
5409 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
5410
5411 shutdown(client, SD_SEND);
5412
5413 check_events(ctx, FD_CLOSE, 0, 200);
5414 check_events(ctx, 0, 0, 0);
5415
5416 closesocket(client);
5417
5418 check_events(ctx, 0, 0, 0);
5419
5420 closesocket(server);
5421
5422 /* No other shutdown() call generates an event. */
5423
5424 tcp_socketpair(&client, &server);
5425
5426 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
5427
5428 shutdown(client, SD_RECEIVE);
5429 shutdown(server, SD_BOTH);
5430
5431 check_events(ctx, 0, 0, 200);
5432
5433 shutdown(client, SD_SEND);
5434
5435 check_events_todo(ctx, FD_CLOSE, 0, 200);
5436 check_events(ctx, 0, 0, 0);
5437
5438 closesocket(server);
5439 closesocket(client);
5440
5441 /* Test sending data before calling closesocket(). */
5442
5443 tcp_socketpair(&client, &server);
5444
5445 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
5446
5447 ret = send(client, "data", 5, 0);
5448 ok(ret == 5, "got %d\n", ret);
5449
5450 check_events(ctx, FD_READ, 0, 200);
5451
5452 closesocket(client);
5453
5454 check_events_todo(ctx, FD_CLOSE, 0, 200);
5455
5456 ret = recv(server, buffer, 3, 0);
5457 ok(ret == 3, "got %d\n", ret);
5458
5459 check_events(ctx, FD_READ, 0, 200);
5460
5461 ret = recv(server, buffer, 5, 0);
5462 ok(ret == 2, "got %d\n", ret);
5463
5464 check_events_todo(ctx, 0, 0, 0);
5465
5466 closesocket(server);
5467
5468 /* Close and then select. */
5469
5470 tcp_socketpair(&client, &server);
5471 closesocket(client);
5472
5473 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
5474 check_events(ctx, FD_CLOSE, 0, 200);
5475
5476 closesocket(server);
5477
5478 /* As above, but select on a subset not containing FD_CLOSE first. */
5479
5480 tcp_socketpair(&client, &server);
5481
5482 select_events(ctx, server, FD_ACCEPT | FD_CONNECT | FD_OOB | FD_READ);
5483
5484 closesocket(client);
5485
5486 check_events(ctx, 0, 0, 200);
5487 select_events(ctx, server, FD_ACCEPT | FD_CLOSE | FD_CONNECT | FD_OOB | FD_READ);
5488 check_events_todo_event(ctx, FD_CLOSE, 0, 200);
5489
5490 closesocket(server);
5491 }
5492
5493 static void test_events(void)
5494 {
5495 struct event_test_ctx ctx;
5496
5497 ctx.is_message = FALSE;
5498 ctx.event = CreateEventW(NULL, TRUE, FALSE, NULL);
5499
5500 test_accept_events(&ctx);
5501 test_connect_events(&ctx);
5502 test_write_events(&ctx);
5503 test_read_events(&ctx);
5504 test_close_events(&ctx);
5505 test_oob_events(&ctx);
5506
5507 CloseHandle(ctx.event);
5508
5509 ctx.is_message = TRUE;
5510 ctx.window = CreateWindowA("Message", NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, NULL, NULL);
5511
5512 test_accept_events(&ctx);
5513 test_connect_events(&ctx);
5514 test_write_events(&ctx);
5515 test_read_events(&ctx);
5516 test_close_events(&ctx);
5517 test_oob_events(&ctx);
5518
5519 DestroyWindow(ctx.window);
5520 }
5521
5522 static void test_ipv6only(void)
5523 {
5524 SOCKET v4 = INVALID_SOCKET, v6;
5525 struct sockaddr_in sin4;
5526 struct sockaddr_in6 sin6;
5527 int ret, enabled, len = sizeof(enabled);
5528
5529 memset(&sin4, 0, sizeof(sin4));
5530 sin4.sin_family = AF_INET;
5531 sin4.sin_port = htons(SERVERPORT);
5532
5533 memset(&sin6, 0, sizeof(sin6));
5534 sin6.sin6_family = AF_INET6;
5535 sin6.sin6_port = htons(SERVERPORT);
5536
5537 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
5538 if (v6 == INVALID_SOCKET)
5539 {
5540 skip("Could not create IPv6 socket (LastError: %d)\n", WSAGetLastError());
5541 goto end;
5542 }
5543
5544 enabled = 2;
5545 ret = getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
5546 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5547 ok(enabled == 1, "expected 1, got %d\n", enabled);
5548
5549 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
5550 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
5551
5552 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5553 ok(v4 != INVALID_SOCKET, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
5554
5555 todo_wine {
5556 enabled = 2;
5557 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
5558 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5559 ok(enabled == 1, "expected 1, got %d\n", enabled);
5560 }
5561
5562 enabled = 0;
5563 len = sizeof(enabled);
5564 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
5565 ok(!ret, "setsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5566
5567 todo_wine {
5568 enabled = 2;
5569 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
5570 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5571 ok(!enabled, "expected 0, got %d\n", enabled);
5572 }
5573
5574 enabled = 1;
5575 len = sizeof(enabled);
5576 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
5577 ok(!ret, "setsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5578
5579 /* bind on IPv4 socket should succeed - IPV6_V6ONLY is enabled by default */
5580 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
5581 ok(!ret, "Could not bind IPv4 address (LastError: %d)\n", WSAGetLastError());
5582
5583 todo_wine {
5584 enabled = 2;
5585 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
5586 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5587 ok(enabled == 1, "expected 1, got %d\n", enabled);
5588 }
5589
5590 enabled = 0;
5591 len = sizeof(enabled);
5592 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
5593 ok(ret, "setsockopt(IPV6_ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
5594
5595 todo_wine {
5596 enabled = 0;
5597 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
5598 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5599 ok(enabled == 1, "expected 1, got %d\n", enabled);
5600 }
5601
5602 enabled = 1;
5603 len = sizeof(enabled);
5604 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
5605 ok(ret, "setsockopt(IPV6_ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
5606
5607 closesocket(v4);
5608 closesocket(v6);
5609
5610 /* Test again, this time disabling IPV6_V6ONLY. */
5611 sin4.sin_port = htons(SERVERPORT+2);
5612 sin6.sin6_port = htons(SERVERPORT+2);
5613
5614 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
5615 ok(v6 != INVALID_SOCKET, "Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
5616 WSAGetLastError(), WSAEAFNOSUPPORT);
5617
5618 enabled = 0;
5619 ret = setsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
5620 ok(!ret, "Could not disable IPV6_V6ONLY (LastError: %d).\n", WSAGetLastError());
5621
5622 enabled = 2;
5623 ret = getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
5624 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5625 ok(!enabled, "expected 0, got %d\n", enabled);
5626
5627 /*
5628 Observaition:
5629 On Windows, bind on both IPv4 and IPv6 with IPV6_V6ONLY disabled succeeds by default.
5630 Application must set SO_EXCLUSIVEADDRUSE on first socket to disallow another successful bind.
5631 In general, a standard application should not use SO_REUSEADDR.
5632 Setting both SO_EXCLUSIVEADDRUSE and SO_REUSEADDR on the same socket is not possible in
5633 either order, the later setsockopt call always fails.
5634 */
5635 enabled = 1;
5636 ret = setsockopt(v6, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&enabled, len);
5637 ok(!ret, "Could not set SO_EXCLUSIVEADDRUSE on IPv6 socket (LastError: %d)\n", WSAGetLastError());
5638
5639 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
5640 ok(!ret, "Could not bind IPv6 address (LastError: %d)\n", WSAGetLastError());
5641
5642 enabled = 2;
5643 len = sizeof(enabled);
5644 getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
5645 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
5646 ok(!enabled, "IPV6_V6ONLY is enabled after bind\n");
5647
5648 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5649 ok(v4 != INVALID_SOCKET, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
5650
5651 enabled = 1;
5652 ret = setsockopt(v4, SOL_SOCKET, SO_REUSEADDR, (char*)&enabled, len);
5653 ok(!ret, "Could not set SO_REUSEADDR on IPv4 socket (LastError: %d)\n", WSAGetLastError());
5654
5655 WSASetLastError(0xdeadbeef);
5656 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
5657 ok(ret, "bind succeeded unexpectedly for the IPv4 socket\n");
5658 ok(WSAGetLastError() == WSAEACCES, "Expected 10013, got %d\n", WSAGetLastError());
5659
5660 end:
5661 if (v4 != INVALID_SOCKET)
5662 closesocket(v4);
5663 if (v6 != INVALID_SOCKET)
5664 closesocket(v6);
5665 }
5666
5667 static void test_WSASendMsg(void)
5668 {
5669 SOCKET sock, dst;
5670 struct sockaddr_in sendaddr, sockaddr;
5671 GUID WSASendMsg_GUID = WSAID_WSASENDMSG;
5672 LPFN_WSASENDMSG pWSASendMsg = NULL;
5673 char teststr[12] = "hello world", buffer[32];
5674 WSABUF iovec[2];
5675 WSAMSG msg;
5676 DWORD bytesSent, err;
5677 int ret, addrlen;
5678
5679 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
5680
5681 sock = socket(AF_INET, SOCK_DGRAM, 0);
5682 ok(sock != INVALID_SOCKET, "socket() failed\n");
5683
5684 /* Obtain the WSASendMsg function */
5685 WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSASendMsg_GUID, sizeof(WSASendMsg_GUID),
5686 &pWSASendMsg, sizeof(pWSASendMsg), &err, NULL, NULL);
5687 if (!pWSASendMsg)
5688 {
5689 closesocket(sock);
5690 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
5691 return;
5692 }
5693
5694 /* fake address for now */
5695 sendaddr.sin_family = AF_INET;
5696 sendaddr.sin_port = htons(139);
5697 sendaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
5698
5699 memset(&msg, 0, sizeof(msg));
5700 iovec[0].buf = teststr;
5701 iovec[0].len = sizeof(teststr);
5702 iovec[1].buf = teststr;
5703 iovec[1].len = sizeof(teststr) / 2;
5704 msg.name = (struct sockaddr *) &sendaddr;
5705 msg.namelen = sizeof(sendaddr);
5706 msg.lpBuffers = iovec;
5707 msg.dwBufferCount = 1; /* send only one buffer for now */
5708
5709 WSASetLastError(0xdeadbeef);
5710 ret = pWSASendMsg(INVALID_SOCKET, &msg, 0, NULL, NULL, NULL);
5711 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
5712 err = WSAGetLastError();
5713 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
5714
5715 WSASetLastError(0xdeadbeef);
5716 ret = pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL);
5717 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
5718 err = WSAGetLastError();
5719 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
5720
5721 WSASetLastError(0xdeadbeef);
5722 ret = pWSASendMsg(sock, NULL, 0, &bytesSent, NULL, NULL);
5723 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
5724 err = WSAGetLastError();
5725 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
5726
5727 WSASetLastError(0xdeadbeef);
5728 ret = pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL);
5729 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
5730 err = WSAGetLastError();
5731 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
5732
5733 closesocket(sock);
5734
5735 sock = socket(AF_INET, SOCK_DGRAM, 0);
5736 ok(sock != INVALID_SOCKET, "socket() failed\n");
5737
5738 dst = socket(AF_INET, SOCK_DGRAM, 0);
5739 ok(dst != INVALID_SOCKET, "socket() failed\n");
5740
5741 memset(&sockaddr, 0, sizeof(sockaddr));
5742 sockaddr.sin_family = AF_INET;
5743 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
5744 ok(!bind(dst, (struct sockaddr*)&sockaddr, sizeof(sockaddr)),
5745 "bind should have worked\n");
5746
5747 /* read address to find out the port number to be used in send */
5748 memset(&sendaddr, 0, sizeof(sendaddr));
5749 addrlen = sizeof(sendaddr);
5750 ok(!getsockname(dst, (struct sockaddr *) &sendaddr, &addrlen),
5751 "getsockname should have worked\n");
5752 ok(sendaddr.sin_port, "socket port should be != 0\n");
5753
5754 /* ensure the sending socket is not bound */
5755 WSASetLastError(0xdeadbeef);
5756 addrlen = sizeof(sockaddr);
5757 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
5758 ok(ret == SOCKET_ERROR, "getsockname should have failed\n");
5759 err = WSAGetLastError();
5760 ok(err == WSAEINVAL, "expected 10022, got %d instead\n", err);
5761
5762 set_blocking(sock, TRUE);
5763
5764 bytesSent = 0;
5765 SetLastError(0xdeadbeef);
5766 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
5767 ok(!ret, "WSASendMsg should have worked\n");
5768 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
5769 "Expected 0, got %d\n", GetLastError());
5770 ok(bytesSent == iovec[0].len, "incorrect bytes sent, expected %d, sent %d\n",
5771 iovec[0].len, bytesSent);
5772
5773 /* receive data */
5774 addrlen = sizeof(sockaddr);
5775 memset(buffer, 0, sizeof(buffer));
5776 SetLastError(0xdeadbeef);
5777 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
5778 ok(ret == bytesSent, "got %d, expected %d\n",
5779 ret, bytesSent);
5780 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5781
5782 /* A successful call to WSASendMsg must have bound the socket */
5783 addrlen = sizeof(sockaddr);
5784 sockaddr.sin_port = 0;
5785 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
5786 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
5787 ok(!ret, "getsockname should have worked\n");
5788 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
5789 inet_ntoa(sockaddr.sin_addr));
5790 ok(sockaddr.sin_port, "sin_port should be != 0\n");
5791
5792 msg.dwBufferCount = 2; /* send both buffers */
5793
5794 bytesSent = 0;
5795 SetLastError(0xdeadbeef);
5796 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
5797 ok(!ret, "WSASendMsg should have worked\n");
5798 ok(bytesSent == iovec[0].len + iovec[1].len, "incorrect bytes sent, expected %d, sent %d\n",
5799 iovec[0].len + iovec[1].len, bytesSent);
5800 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
5801 "Expected 0, got %d\n", GetLastError());
5802
5803 /* receive data */
5804 addrlen = sizeof(sockaddr);
5805 memset(buffer, 0, sizeof(buffer));
5806 SetLastError(0xdeadbeef);
5807 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
5808 ok(ret == bytesSent, "got %d, expected %d\n",
5809 ret, bytesSent);
5810 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5811
5812 closesocket(sock);
5813 closesocket(dst);
5814
5815 /* a bad call to WSASendMsg will also bind the socket */
5816 addrlen = sizeof(sockaddr);
5817 sockaddr.sin_port = 0;
5818 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
5819 sock = socket(AF_INET, SOCK_DGRAM, 0);
5820 ok(sock != INVALID_SOCKET, "socket() failed\n");
5821 ok(pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
5822 todo_wine {
5823 ok(!getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have worked\n");
5824 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
5825 inet_ntoa(sockaddr.sin_addr));
5826 ok(sockaddr.sin_port, "sin_port should be > 0\n");
5827 }
5828 closesocket(sock);
5829
5830 /* a bad call without msg parameter will not trigger the auto-bind */
5831 sock = socket(AF_INET, SOCK_DGRAM, 0);
5832 ok(sock != INVALID_SOCKET, "socket() failed\n");
5833 ok(pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
5834 ok(getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have failed\n");
5835 err = WSAGetLastError();
5836 ok(err == WSAEINVAL, "expected 10022, got %d instead\n", err);
5837 closesocket(sock);
5838
5839 /* SOCK_STREAM sockets are not supported */
5840 bytesSent = 0;
5841 sock = socket(AF_INET, SOCK_STREAM, 0);
5842 ok(sock != INVALID_SOCKET, "socket() failed\n");
5843 SetLastError(0xdeadbeef);
5844 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
5845 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
5846 err = WSAGetLastError();
5847 todo_wine
5848 ok(err == WSAEINVAL, "expected 10014, got %d instead\n", err);
5849 closesocket(sock);
5850 }
5851
5852 static void test_WSASendTo(void)
5853 {
5854 SOCKET s;
5855 struct sockaddr_in addr, ret_addr;
5856 char buf[12] = "hello world";
5857 WSABUF data_buf;
5858 DWORD bytesSent;
5859 int ret, len;
5860
5861 addr.sin_family = AF_INET;
5862 addr.sin_port = htons(139);
5863 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
5864 data_buf.len = sizeof(buf);
5865 data_buf.buf = buf;
5866
5867 s = socket(AF_INET, SOCK_DGRAM, 0);
5868 ok(s != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
5869
5870 WSASetLastError(12345);
5871 ret = WSASendTo(INVALID_SOCKET, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
5872 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
5873 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
5874
5875 len = sizeof(ret_addr);
5876 ret = getsockname(s, (struct sockaddr *)&ret_addr, &len);
5877 ok(ret == -1, "expected failure\n");
5878 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
5879
5880 WSASetLastError(12345);
5881 ret = WSASendTo(s, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
5882 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
5883 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
5884
5885 WSASetLastError(12345);
5886 ret = WSASendTo(s, &data_buf, 1, &bytesSent, 0, (struct sockaddr *)&addr, sizeof(addr), NULL, NULL);
5887 ok(!ret, "expected success\n");
5888 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
5889
5890 len = sizeof(ret_addr);
5891 ret = getsockname(s, (struct sockaddr *)&ret_addr, &len);
5892 ok(!ret, "got error %u\n", WSAGetLastError());
5893 ok(ret_addr.sin_family == AF_INET, "got family %u\n", ret_addr.sin_family);
5894 ok(ret_addr.sin_port, "expected nonzero port\n");
5895 }
5896
5897 static DWORD WINAPI recv_thread(LPVOID arg)
5898 {
5899 SOCKET sock = *(SOCKET *)arg;
5900 char buffer[32];
5901 WSABUF wsa;
5902 WSAOVERLAPPED ov;
5903 DWORD flags = 0;
5904
5905 wsa.buf = buffer;
5906 wsa.len = sizeof(buffer);
5907 ov.hEvent = WSACreateEvent();
5908 WSARecv(sock, &wsa, 1, NULL, &flags, &ov, NULL);
5909
5910 WaitForSingleObject(ov.hEvent, 1000);
5911 WSACloseEvent(ov.hEvent);
5912 return 0;
5913 }
5914
5915 static int completion_called;
5916
5917 static void WINAPI io_completion(DWORD error, DWORD transferred, WSAOVERLAPPED *overlapped, DWORD flags)
5918 {
5919 completion_called++;
5920 }
5921
5922 static void test_WSARecv(void)
5923 {
5924 SOCKET src, dest, server = INVALID_SOCKET;
5925 char buf[20];
5926 WSABUF bufs[2];
5927 WSAOVERLAPPED ov;
5928 DWORD bytesReturned, flags, id;
5929 struct linger ling;
5930 struct sockaddr_in addr;
5931 int iret, len;
5932 DWORD dwret;
5933 BOOL bret;
5934 HANDLE thread, event = NULL, io_port;
5935
5936 tcp_socketpair(&src, &dest);
5937
5938 memset(&ov, 0, sizeof(ov));
5939 flags = 0;
5940 bufs[0].len = 2;
5941 bufs[0].buf = buf;
5942
5943 /* Send 4 bytes and receive in two calls of 2 */
5944 SetLastError(0xdeadbeef);
5945 iret = send(src, "test", 4, 0);
5946 ok(iret == 4, "Expected 4, got %d\n", iret);
5947 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5948 SetLastError(0xdeadbeef);
5949 bytesReturned = 0xdeadbeef;
5950 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
5951 ok(!iret, "Expected 0, got %d\n", iret);
5952 ok(bytesReturned == 2, "Expected 2, got %d\n", bytesReturned);
5953 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5954 SetLastError(0xdeadbeef);
5955 bytesReturned = 0xdeadbeef;
5956 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
5957 ok(!iret, "Expected 0, got %d\n", iret);
5958 ok(bytesReturned == 2, "Expected 2, got %d\n", bytesReturned);
5959 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5960
5961 bufs[0].len = 4;
5962 SetLastError(0xdeadbeef);
5963 iret = send(src, "test", 4, 0);
5964 ok(iret == 4, "Expected 4, got %d\n", iret);
5965 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5966 SetLastError(0xdeadbeef);
5967 bytesReturned = 0xdeadbeef;
5968 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
5969 ok(!iret, "Expected 0, got %d\n", iret);
5970 ok(bytesReturned == 4, "Expected 4, got %d\n", bytesReturned);
5971 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5972
5973 /* Test 2 buffers */
5974 bufs[0].len = 4;
5975 bufs[1].len = 5;
5976 bufs[1].buf = buf + 10;
5977 SetLastError(0xdeadbeef);
5978 iret = send(src, "deadbeefs", 9, 0);
5979 ok(iret == 9, "Expected 9, got %d\n", iret);
5980 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5981 SetLastError(0xdeadbeef);
5982 bytesReturned = 0xdeadbeef;
5983 iret = WSARecv(dest, bufs, 2, &bytesReturned, &flags, NULL, NULL);
5984 ok(!iret, "Expected 0, got %d\n", iret);
5985 ok(bytesReturned == 9, "Expected 9, got %d\n", bytesReturned);
5986 bufs[0].buf[4] = '\0';
5987 bufs[1].buf[5] = '\0';
5988 ok(!strcmp(bufs[0].buf, "dead"), "buf[0] doesn't match: %s != dead\n", bufs[0].buf);
5989 ok(!strcmp(bufs[1].buf, "beefs"), "buf[1] doesn't match: %s != beefs\n", bufs[1].buf);
5990 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5991
5992 bufs[0].len = sizeof(buf);
5993 ov.hEvent = event = CreateEventA(NULL, FALSE, FALSE, NULL);
5994 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
5995 if (!event)
5996 goto end;
5997
5998 ling.l_onoff = 1;
5999 ling.l_linger = 0;
6000 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
6001 ok(!iret, "Failed to set linger %d\n", GetLastError());
6002
6003 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, NULL);
6004 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
6005
6006 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, &ov, NULL);
6007 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
6008
6009 closesocket(src);
6010 src = INVALID_SOCKET;
6011
6012 dwret = WaitForSingleObject(ov.hEvent, 1000);
6013 ok(dwret == WAIT_OBJECT_0, "Waiting for disconnect event failed with %d + errno %d\n", dwret, GetLastError());
6014
6015 bret = GetOverlappedResult((HANDLE)dest, &ov, &bytesReturned, FALSE);
6016 todo_wine ok(!bret, "expected failure\n");
6017 todo_wine ok(GetLastError() == ERROR_NETNAME_DELETED, "got error %u\n", GetLastError());
6018 ok(bytesReturned == 0, "Bytes received is %d\n", bytesReturned);
6019 closesocket(dest);
6020 dest = INVALID_SOCKET;
6021
6022 src = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
6023 ok(src != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6024 if (src == INVALID_SOCKET) goto end;
6025
6026 server = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
6027 ok(server != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6028 if (server == INVALID_SOCKET) goto end;
6029
6030 memset(&addr, 0, sizeof(addr));
6031 addr.sin_family = AF_INET;
6032 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
6033 iret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
6034 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
6035
6036 len = sizeof(addr);
6037 iret = getsockname(server, (struct sockaddr *)&addr, &len);
6038 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
6039
6040 iret = listen(server, 1);
6041 ok(!iret, "failed to listen, error %u\n", WSAGetLastError());
6042
6043 iret = connect(src, (struct sockaddr *)&addr, sizeof(addr));
6044 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
6045
6046 len = sizeof(addr);
6047 dest = accept(server, (struct sockaddr *)&addr, &len);
6048 ok(dest != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6049 if (dest == INVALID_SOCKET) goto end;
6050
6051 send(src, "test message", sizeof("test message"), 0);
6052 thread = CreateThread(NULL, 0, recv_thread, &dest, 0, &id);
6053 WaitForSingleObject(thread, 3000);
6054 CloseHandle(thread);
6055
6056 memset(&ov, 0, sizeof(ov));
6057 ov.hEvent = event;
6058 ResetEvent(event);
6059 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, io_completion);
6060 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
6061 send(src, "test message", sizeof("test message"), 0);
6062
6063 completion_called = 0;
6064 dwret = SleepEx(1000, TRUE);
6065 ok(dwret == WAIT_IO_COMPLETION, "got %u\n", dwret);
6066 ok(completion_called == 1, "completion not called\n");
6067
6068 dwret = WaitForSingleObject(event, 1);
6069 ok(dwret == WAIT_TIMEOUT, "got %u\n", dwret);
6070
6071 io_port = CreateIoCompletionPort( (HANDLE)dest, NULL, 0, 0 );
6072 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
6073
6074 /* Using completion function on socket associated with completion port is not allowed. */
6075 memset(&ov, 0, sizeof(ov));
6076 completion_called = 0;
6077 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, io_completion);
6078 ok(iret == SOCKET_ERROR && GetLastError() == WSAEINVAL, "WSARecv failed - %d error %d\n", iret, GetLastError());
6079 ok(!completion_called, "completion called\n");
6080
6081 CloseHandle(io_port);
6082
6083 end:
6084 if (server != INVALID_SOCKET)
6085 closesocket(server);
6086 if (dest != INVALID_SOCKET)
6087 closesocket(dest);
6088 if (src != INVALID_SOCKET)
6089 closesocket(src);
6090 if (event)
6091 WSACloseEvent(event);
6092 }
6093
6094 struct write_watch_thread_args
6095 {
6096 int func;
6097 SOCKET dest;
6098 void *base;
6099 DWORD size;
6100 const char *expect;
6101 };
6102
6103 static DWORD CALLBACK write_watch_thread( void *arg )
6104 {
6105 struct write_watch_thread_args *args = arg;
6106 struct sockaddr addr;
6107 int addr_len = sizeof(addr), ret;
6108 DWORD bytes, flags = 0;
6109 WSABUF buf[1];
6110
6111 switch (args->func)
6112 {
6113 case 0:
6114 ret = recv( args->dest, args->base, args->size, 0 );
6115 ok( ret == strlen(args->expect) + 1, "wrong len %d\n", ret );
6116 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
6117 break;
6118 case 1:
6119 ret = recvfrom( args->dest, args->base, args->size, 0, &addr, &addr_len );
6120 ok( ret == strlen(args->expect) + 1, "wrong len %d\n", ret );
6121 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
6122 break;
6123 case 2:
6124 buf[0].len = args->size;
6125 buf[0].buf = args->base;
6126 ret = WSARecv( args->dest, buf, 1, &bytes, &flags, NULL, NULL );
6127 ok( !ret, "WSARecv failed %u\n", GetLastError() );
6128 ok( bytes == strlen(args->expect) + 1, "wrong len %d\n", bytes );
6129 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
6130 break;
6131 case 3:
6132 buf[0].len = args->size;
6133 buf[0].buf = args->base;
6134 ret = WSARecvFrom( args->dest, buf, 1, &bytes, &flags, &addr, &addr_len, NULL, NULL );
6135 ok( !ret, "WSARecvFrom failed %u\n", GetLastError() );
6136 ok( bytes == strlen(args->expect) + 1, "wrong len %d\n", bytes );
6137 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
6138 break;
6139 }
6140 return 0;
6141 }
6142
6143 static void test_write_watch(void)
6144 {
6145 SOCKET src, dest;
6146 WSABUF bufs[2];
6147 WSAOVERLAPPED ov;
6148 struct write_watch_thread_args args;
6149 DWORD bytesReturned, flags, size;
6150 struct sockaddr addr;
6151 int addr_len, ret;
6152 HANDLE thread, event;
6153 char *base;
6154 void *results[64];
6155 ULONG_PTR count;
6156 ULONG pagesize;
6157 UINT (WINAPI *pGetWriteWatch)(DWORD,LPVOID,SIZE_T,LPVOID*,ULONG_PTR*,ULONG*);
6158
6159 pGetWriteWatch = (void *)GetProcAddress( GetModuleHandleA("kernel32.dll"), "GetWriteWatch" );
6160 if (!pGetWriteWatch)
6161 {
6162 win_skip( "write watched not supported\n" );
6163 return;
6164 }
6165
6166 tcp_socketpair(&src, &dest);
6167
6168 memset(&ov, 0, sizeof(ov));
6169 ov.hEvent = event = CreateEventA(NULL, FALSE, FALSE, NULL);
6170 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
6171
6172 flags = 0;
6173
6174 size = 0x10000;
6175 base = VirtualAlloc( 0, size, MEM_RESERVE | MEM_COMMIT | MEM_WRITE_WATCH, PAGE_READWRITE );
6176 ok( base != NULL, "VirtualAlloc failed %u\n", GetLastError() );
6177
6178 memset( base, 0, size );
6179 count = 64;
6180 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
6181 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
6182 ok( count == 16, "wrong count %lu\n", count );
6183
6184 bufs[0].len = 5;
6185 bufs[0].buf = base;
6186 bufs[1].len = 0x8000;
6187 bufs[1].buf = base + 0x4000;
6188
6189 ret = WSARecv( dest, bufs, 2, NULL, &flags, &ov, NULL);
6190 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
6191 "WSARecv failed - %d error %d\n", ret, GetLastError());
6192
6193 count = 64;
6194 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
6195 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
6196 ok( count == 9, "wrong count %lu\n", count );
6197 ok( !base[0], "data set\n" );
6198
6199 send(src, "test message", sizeof("test message"), 0);
6200
6201 ret = GetOverlappedResult( (HANDLE)dest, &ov, &bytesReturned, TRUE );
6202 ok( ret, "GetOverlappedResult failed %u\n", GetLastError() );
6203 ok( bytesReturned == sizeof("test message"), "wrong size %u\n", bytesReturned );
6204 ok( !memcmp( base, "test ", 5 ), "wrong data %s\n", base );
6205 ok( !memcmp( base + 0x4000, "message", 8 ), "wrong data %s\n", base + 0x4000 );
6206
6207 count = 64;
6208 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
6209 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
6210 ok( count == 0, "wrong count %lu\n", count );
6211
6212 memset( base, 0, size );
6213 count = 64;
6214 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
6215 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
6216 ok( count == 16, "wrong count %lu\n", count );
6217
6218 bufs[1].len = 0x4000;
6219 bufs[1].buf = base + 0x2000;
6220 ret = WSARecvFrom( dest, bufs, 2, NULL, &flags, &addr, &addr_len, &ov, NULL);
6221 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
6222 "WSARecv failed - %d error %d\n", ret, GetLastError());
6223
6224 count = 64;
6225 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
6226 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
6227 ok( count == 5, "wrong count %lu\n", count );
6228 ok( !base[0], "data set\n" );
6229
6230 send(src, "test message", sizeof("test message"), 0);
6231
6232 ret = GetOverlappedResult( (HANDLE)dest, &ov, &bytesReturned, TRUE );
6233 ok( ret, "GetOverlappedResult failed %u\n", GetLastError() );
6234 ok( bytesReturned == sizeof("test message"), "wrong size %u\n", bytesReturned );
6235 ok( !memcmp( base, "test ", 5 ), "wrong data %s\n", base );
6236 ok( !memcmp( base + 0x2000, "message", 8 ), "wrong data %s\n", base + 0x2000 );
6237
6238 count = 64;
6239 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
6240 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
6241 ok( count == 0, "wrong count %lu\n", count );
6242
6243 memset( base, 0, size );
6244 count = 64;
6245 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
6246 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
6247 ok( count == 16, "wrong count %lu\n", count );
6248
6249 args.dest = dest;
6250 args.base = base;
6251 args.size = 0x7002;
6252 args.expect = "test message";
6253 for (args.func = 0; args.func < 4; args.func++)
6254 {
6255 thread = CreateThread( NULL, 0, write_watch_thread, &args, 0, NULL );
6256 Sleep( 200 );
6257
6258 count = 64;
6259 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
6260 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
6261 ok( count == 8, "wrong count %lu\n", count );
6262
6263 send(src, "test message", sizeof("test message"), 0);
6264 WaitForSingleObject( thread, 10000 );
6265 CloseHandle( thread );
6266
6267 count = 64;
6268 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
6269 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
6270 ok( count == 0, "wrong count %lu\n", count );
6271 }
6272 WSACloseEvent( event );
6273 closesocket( dest );
6274 closesocket( src );
6275 VirtualFree( base, 0, MEM_FREE );
6276 }
6277
6278 static void test_WSAPoll(void)
6279 {
6280 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
6281 int ret, err, len;
6282 SOCKET listener, server, client;
6283 struct sockaddr_in address;
6284 WSAPOLLFD fds[16];
6285 HANDLE thread_handle;
6286 unsigned int i;
6287 char buffer[6];
6288
6289 static const short invalid_flags[] =
6290 {POLLERR, POLLHUP, POLLNVAL, 0x8, POLLWRBAND, 0x40, 0x80, POLLPRI, 0x800, 0x1000, 0x2000, 0x4000, 0x8000};
6291
6292 if (!pWSAPoll) /* >= Vista */
6293 {
6294 win_skip("WSAPoll is unsupported, some tests will be skipped.\n");
6295 return;
6296 }
6297
6298 /* Invalid parameters test */
6299 SetLastError(0xdeadbeef);
6300 ret = pWSAPoll(NULL, 0, 0);
6301 err = GetLastError();
6302 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
6303 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
6304 SetLastError(0xdeadbeef);
6305 ret = pWSAPoll(NULL, 1, 0);
6306 err = GetLastError();
6307 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
6308 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
6309 SetLastError(0xdeadbeef);
6310 ret = pWSAPoll(NULL, 0, 1);
6311 err = GetLastError();
6312 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
6313 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
6314 SetLastError(0xdeadbeef);
6315 ret = pWSAPoll(NULL, 1, 1);
6316 err = GetLastError();
6317 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
6318 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
6319
6320 memset(&address, 0, sizeof(address));
6321 address.sin_addr.s_addr = inet_addr("127.0.0.1");
6322 address.sin_family = AF_INET;
6323 len = sizeof(address);
6324 listener = setup_server_socket(&address, &len);
6325
6326 for (i = 0; i < ARRAY_SIZE(invalid_flags); ++i)
6327 {
6328 fds[0].fd = listener;
6329 fds[0].events = invalid_flags[i];
6330 fds[0].revents = 0xdead;
6331 WSASetLastError(0xdeadbeef);
6332 ret = pWSAPoll(fds, 1, 0);
6333 todo_wine ok(ret == -1, "got %d\n", ret);
6334 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
6335 }
6336
6337 /* When no events are pending poll returns 0 with no error */
6338 fds[0].fd = listener;
6339 fds[0].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
6340 fds[0].revents = 0xdead;
6341 ret = pWSAPoll(fds, 1, 0);
6342 ok(ret == 0, "got %d\n", ret);
6343 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
6344
6345 fds[0].fd = -1;
6346 fds[0].events = POLLERR;
6347 fds[0].revents = 0xdead;
6348 fds[1].fd = listener;
6349 fds[1].events = POLLIN;
6350 fds[1].revents = 0xdead;
6351 WSASetLastError(0xdeadbeef);
6352 ret = pWSAPoll(fds, 2, 0);
6353 ok(!ret, "got %d\n", ret);
6354 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
6355 ok(fds[0].revents == POLLNVAL, "got events %#x\n", fds[0].revents);
6356 ok(!fds[1].revents, "got events %#x\n", fds[1].revents);
6357
6358 fds[0].fd = listener;
6359 fds[0].events = POLLIN;
6360 fds[0].revents = 0xdead;
6361 fds[1].fd = 0xabacab;
6362 fds[1].events = POLLIN;
6363 fds[1].revents = 0xdead;
6364 WSASetLastError(0xdeadbeef);
6365 ret = pWSAPoll(fds, 2, 0);
6366 ok(!ret, "got %d\n", ret);
6367 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
6368 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
6369 ok(fds[1].revents == POLLNVAL, "got events %#x\n", fds[1].revents);
6370
6371 fds[0].fd = listener;
6372 fds[0].events = POLLIN;
6373 fds[0].revents = 0xdead;
6374 fds[1].fd = 0xabacab;
6375 fds[1].events = POLLERR;
6376 fds[1].revents = 0xdead;
6377 WSASetLastError(0xdeadbeef);
6378 ret = pWSAPoll(fds, 2, 0);
6379 todo_wine ok(ret == -1, "got %d\n", ret);
6380 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
6381 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
6382 todo_wine ok(!fds[1].revents, "got events %#x\n", fds[1].revents);
6383
6384 fds[0].fd = -1;
6385 fds[0].events = POLLERR;
6386 fds[0].revents = 0xdead;
6387 fds[1].fd = 0xabacab;
6388 fds[1].events = POLLERR;
6389 fds[1].revents = 0xdead;
6390 WSASetLastError(0xdeadbeef);
6391 ret = pWSAPoll(fds, 2, 0);
6392 ok(ret == -1, "got %d\n", ret);
6393 ok(WSAGetLastError() == WSAENOTSOCK, "got error %u\n", WSAGetLastError());
6394 ok(fds[0].revents == POLLNVAL, "got events %#x\n", fds[0].revents);
6395 ok(fds[1].revents == POLLNVAL, "got events %#x\n", fds[1].revents);
6396
6397 /* Test listening socket connection attempt notifications */
6398 client = setup_connector_socket(&address, len, TRUE);
6399
6400 fds[0].fd = listener;
6401 fds[0].events = POLLIN;
6402 fds[0].revents = 0xdead;
6403 ret = pWSAPoll(fds, 1, 100);
6404 ok(ret == 1, "got %d\n", ret);
6405 ok(fds[0].revents == POLLRDNORM, "got events %#x\n", fds[0].revents);
6406
6407 fds[0].revents = 0xdead;
6408 ret = pWSAPoll(fds, 1, 0);
6409 ok(ret == 1, "got %d\n", ret);
6410 ok(fds[0].revents == POLLRDNORM, "got events %#x\n", fds[0].revents);
6411
6412 fds[0].events = POLLRDBAND | POLLWRNORM;
6413 fds[0].revents = 0xdead;
6414 ret = pWSAPoll(fds, 1, 0);
6415 ok(ret == 0, "got %d\n", ret);
6416 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
6417
6418 server = accept(listener, NULL, NULL);
6419 ok(server != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
6420 set_blocking(client, FALSE);
6421 set_blocking(server, FALSE);
6422
6423 for (i = 0; i < ARRAY_SIZE(invalid_flags); ++i)
6424 {
6425 fds[0].fd = server;
6426 fds[0].events = invalid_flags[i];
6427 fds[0].revents = 0xdead;
6428 WSASetLastError(0xdeadbeef);
6429 ret = pWSAPoll(fds, 1, 0);
6430 todo_wine ok(ret == -1, "got %d\n", ret);
6431 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
6432 }
6433
6434 /* Test flags exposed by connected sockets. */
6435
6436 fds[0].fd = listener;
6437 fds[0].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
6438 fds[0].revents = 0xdead;
6439 fds[1].fd = server;
6440 fds[1].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
6441 fds[1].revents = 0xdead;
6442 fds[2].fd = client;
6443 fds[2].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
6444 fds[2].revents = 0xdead;
6445 ret = pWSAPoll(fds, 3, 0);
6446 ok(ret == 2, "got %d\n", ret);
6447 ok(!fds[0].revents, "got events %#x\n", fds[0].revents);
6448 ok(fds[1].revents == POLLWRNORM, "got events %#x\n", fds[1].revents);
6449 ok(fds[2].revents == POLLWRNORM, "got events %#x\n", fds[2].revents);
6450
6451 /* Test data receiving notifications */
6452
6453 ret = send(server, "1234", 4, 0);
6454 ok(ret == 4, "got %d\n", ret);
6455
6456 check_poll_mask(client, POLLRDNORM | POLLRDBAND, POLLRDNORM);
6457 check_poll(client, POLLRDNORM | POLLWRNORM);
6458 check_poll(server, POLLWRNORM);
6459
6460 ret = sync_recv(client, buffer, sizeof(buffer), 0);
6461 ok(ret == 4, "got %d\n", ret);
6462
6463 check_poll(client, POLLWRNORM);
6464 check_poll(server, POLLWRNORM);
6465
6466 /* Because the kernel asynchronously buffers data, this test is not reliable. */
6467
6468 if (0)
6469 {
6470 static const int large_buffer_size = 1024 * 1024;
6471 char *large_buffer = malloc(large_buffer_size);
6472
6473 while (send(server, large_buffer, large_buffer_size, 0) == large_buffer_size);
6474
6475 check_poll(client, POLLWRNORM | POLLRDNORM);
6476 check_poll(server, 0);
6477
6478 while (recv(client, large_buffer, large_buffer_size, 0) > 0);
6479
6480 check_poll(client, POLLWRNORM);
6481 check_poll(server, POLLWRNORM);
6482
6483 free(large_buffer);
6484 }
6485
6486 /* Test OOB data notifications */
6487
6488 ret = send(client, "A", 1, MSG_OOB);
6489 ok(ret == 1, "got %d\n", ret);
6490
6491 check_poll(client, POLLWRNORM);
6492 check_poll_mask(server, POLLRDNORM | POLLRDBAND, POLLRDBAND);
6493 check_poll(server, POLLWRNORM | POLLRDBAND);
6494
6495 buffer[0] = 0xcc;
6496 ret = recv(server, buffer, 1, MSG_OOB);
6497 ok(ret == 1, "got %d\n", ret);
6498 ok(buffer[0] == 'A', "got %#x\n", buffer[0]);
6499
6500 check_poll(client, POLLWRNORM);
6501 check_poll(server, POLLWRNORM);
6502
6503 /* If the socket is OOBINLINED the notification is like normal data */
6504
6505 ret = 1;
6506 ret = setsockopt(server, SOL_SOCKET, SO_OOBINLINE, (char *)&ret, sizeof(ret));
6507 ok(!ret, "got error %u\n", WSAGetLastError());
6508 ret = send(client, "A", 1, MSG_OOB);
6509 ok(ret == 1, "got %d\n", ret);
6510
6511 check_poll(client, POLLWRNORM);
6512 check_poll_mask(server, POLLRDNORM | POLLRDBAND, POLLRDNORM);
6513 check_poll(server, POLLWRNORM | POLLRDNORM);
6514
6515 buffer[0] = 0xcc;
6516 ret = recv(server, buffer, 1, 0);
6517 ok(ret == 1, "got %d\n", ret);
6518 ok(buffer[0] == 'A', "got %#x\n", buffer[0]);
6519
6520 check_poll(client, POLLWRNORM);
6521 check_poll_todo(server, POLLWRNORM);
6522
6523 /* Test shutdown. */
6524
6525 ret = shutdown(client, SD_RECEIVE);
6526 ok(!ret, "got error %u\n", WSAGetLastError());
6527
6528 check_poll(client, POLLWRNORM);
6529 check_poll_todo(server, POLLWRNORM);
6530
6531 ret = shutdown(client, SD_SEND);
6532 ok(!ret, "got error %u\n", WSAGetLastError());
6533
6534 check_poll(client, POLLWRNORM);
6535 check_poll_mask_todo(server, 0, POLLHUP);
6536 check_poll_todo(server, POLLWRNORM | POLLHUP);
6537
6538 closesocket(client);
6539 closesocket(server);
6540
6541 /* Test shutdown via closesocket(). */
6542
6543 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6544 ret = connect(client, (struct sockaddr *)&address, sizeof(address));
6545 ok(!ret, "got error %u\n", WSAGetLastError());
6546 server = accept(listener, NULL, NULL);
6547 ok(server != -1, "got error %u\n", WSAGetLastError());
6548
6549 closesocket(client);
6550
6551 check_poll_mask(server, 0, POLLHUP);
6552 check_poll(server, POLLWRNORM | POLLHUP);
6553
6554 closesocket(server);
6555
6556 /* Test shutdown with data in the pipe. */
6557
6558 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6559 ret = connect(client, (struct sockaddr *)&address, sizeof(address));
6560 ok(!ret, "got error %u\n", WSAGetLastError());
6561 server = accept(listener, NULL, NULL);
6562 ok(server != -1, "got error %u\n", WSAGetLastError());
6563
6564 ret = send(client, "data", 5, 0);
6565 ok(ret == 5, "got %d\n", ret);
6566
6567 check_poll(client, POLLWRNORM);
6568 check_poll_mask(server, POLLRDNORM | POLLRDBAND, POLLRDNORM);
6569 check_poll(server, POLLWRNORM | POLLRDNORM);
6570
6571 ret = shutdown(client, SD_SEND);
6572
6573 check_poll(client, POLLWRNORM);
6574 check_poll_mask_todo(server, 0, POLLHUP);
6575 check_poll_todo(server, POLLWRNORM | POLLRDNORM | POLLHUP);
6576
6577 closesocket(client);
6578 closesocket(server);
6579
6580 /* Test closing a socket while selecting on it. */
6581
6582 tcp_socketpair(&client, &server);
6583
6584 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &client, 0, NULL);
6585 fds[0].fd = client;
6586 fds[0].events = POLLRDNORM | POLLRDBAND;
6587 fds[0].revents = 0xdead;
6588 ret = pWSAPoll(fds, 1, 2000);
6589 ok(ret == 1, "got %d\n", ret);
6590 ok(fds[0].revents == POLLNVAL, "got events %#x\n", fds[0].revents);
6591 ret = WaitForSingleObject(thread_handle, 1000);
6592 ok(!ret, "wait failed\n");
6593 CloseHandle(thread_handle);
6594
6595 closesocket(server);
6596
6597 /* Test a failed connection.
6598 *
6599 * The following WSAPoll() call times out on versions older than w10pro64,
6600 * but even on w10pro64 it takes over 2 seconds for an error to be reported,
6601 * so make the test interactive-only. */
6602 if (winetest_interactive)
6603 {
6604 const struct sockaddr_in invalid_addr =
6605 {
6606 .sin_family = AF_INET,
6607 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
6608 .sin_port = 255,
6609 };
6610 SOCKET client;
6611
6612 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6613 set_blocking(client, FALSE);
6614
6615 ret = connect(client, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
6616 ok(ret == -1, "got %d\n", ret);
6617 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
6618
6619 fds[0].fd = client;
6620 fds[0].events = POLLRDNORM | POLLRDBAND | POLLWRNORM;
6621 fds[0].revents = 0xdead;
6622 ret = pWSAPoll(fds, 1, 10000);
6623 todo_wine ok(ret == 1, "got %d\n", ret);
6624 todo_wine ok(fds[0].revents == (POLLWRNORM | POLLHUP | POLLERR), "got events %#x\n", fds[0].revents);
6625
6626 len = sizeof(err);
6627 err = 0xdeadbeef;
6628 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
6629 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
6630 ok(err == WSAECONNREFUSED, "got error %u\n", err);
6631
6632 len = sizeof(err);
6633 err = 0xdeadbeef;
6634 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
6635 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
6636 ok(err == WSAECONNREFUSED, "got error %u\n", err);
6637
6638 check_poll_todo(client, POLLWRNORM | POLLHUP | POLLERR);
6639
6640 closesocket(client);
6641
6642 /* test polling after a (synchronous) failure */
6643
6644 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6645
6646 ret = connect(client, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
6647 ok(ret == -1, "got %d\n", ret);
6648 ok(WSAGetLastError() == WSAECONNREFUSED, "got error %u\n", WSAGetLastError());
6649
6650 check_poll_todo(client, POLLWRNORM | POLLHUP | POLLERR);
6651
6652 len = sizeof(err);
6653 err = 0xdeadbeef;
6654 ret = getsockopt(client, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
6655 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
6656 todo_wine ok(!err, "got error %u\n", err);
6657
6658 closesocket(client);
6659 }
6660
6661 closesocket(listener);
6662
6663 /* Test UDP sockets. */
6664
6665 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
6666 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
6667
6668 check_poll(client, POLLWRNORM);
6669 check_poll(server, POLLWRNORM);
6670
6671 ret = bind(client, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
6672 ok(!ret, "got error %u\n", WSAGetLastError());
6673 len = sizeof(address);
6674 ret = getsockname(client, (struct sockaddr *)&address, &len);
6675 ok(!ret, "got error %u\n", WSAGetLastError());
6676
6677 check_poll(client, POLLWRNORM);
6678 check_poll(server, POLLWRNORM);
6679
6680 ret = sendto(server, "data", 5, 0, (struct sockaddr *)&address, sizeof(address));
6681 ok(ret == 5, "got %d\n", ret);
6682
6683 check_poll_mask(client, POLLRDNORM | POLLRDBAND, POLLRDNORM);
6684 check_poll(client, POLLWRNORM | POLLRDNORM);
6685 check_poll(server, POLLWRNORM);
6686
6687 closesocket(client);
6688 closesocket(server);
6689 }
6690
6691 static void test_connect(void)
6692 {
6693 SOCKET listener = INVALID_SOCKET;
6694 SOCKET acceptor = INVALID_SOCKET;
6695 SOCKET connector = INVALID_SOCKET;
6696 struct sockaddr_in address, conaddress;
6697 int addrlen;
6698 OVERLAPPED overlapped;
6699 LPFN_CONNECTEX pConnectEx;
6700 GUID connectExGuid = WSAID_CONNECTEX;
6701 DWORD bytesReturned;
6702 char buffer[1024];
6703 BOOL bret;
6704 DWORD dwret;
6705 int iret;
6706
6707 memset(&overlapped, 0, sizeof(overlapped));
6708
6709 listener = socket(AF_INET, SOCK_STREAM, 0);
6710 ok(listener != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
6711
6712 connector = socket(AF_INET, SOCK_STREAM, 0);
6713 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
6714
6715 memset(&address, 0, sizeof(address));
6716 address.sin_family = AF_INET;
6717 address.sin_addr.s_addr = inet_addr("127.0.0.1");
6718 iret = bind(listener, (struct sockaddr*)&address, sizeof(address));
6719 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
6720
6721 addrlen = sizeof(address);
6722 iret = getsockname(listener, (struct sockaddr*)&address, &addrlen);
6723 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
6724
6725 iret = listen(listener, 1);
6726 ok(!iret, "failed to listen, error %u\n", WSAGetLastError());
6727
6728 iret = set_blocking(listener, TRUE);
6729 ok(!iret, "failed to set nonblocking, error %u\n", WSAGetLastError());
6730
6731 bytesReturned = 0xdeadbeef;
6732 iret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectExGuid, sizeof(connectExGuid),
6733 &pConnectEx, sizeof(pConnectEx), &bytesReturned, NULL, NULL);
6734 ok(!iret, "failed to get ConnectEx, error %u\n", WSAGetLastError());
6735
6736 ok(bytesReturned == sizeof(pConnectEx), "expected sizeof(pConnectEx), got %u\n", bytesReturned);
6737
6738 WSASetLastError(0xdeadbeef);
6739 iret = connect(listener, (struct sockaddr *)&address, sizeof(address));
6740 ok(iret == -1, "got %d\n", iret);
6741 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
6742
6743 WSASetLastError(0xdeadbeef);
6744 overlapped.Internal = 0xdeadbeef;
6745 overlapped.InternalHigh = 0xdeadbeef;
6746 iret = pConnectEx(listener, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
6747 ok(!iret, "got %d\n", iret);
6748 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
6749 ok(overlapped.Internal == STATUS_PENDING, "got status %#x\n", (NTSTATUS)overlapped.Internal);
6750 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
6751
6752 bret = pConnectEx(INVALID_SOCKET, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
6753 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "ConnectEx on invalid socket "
6754 "returned %d + errno %d\n", bret, WSAGetLastError());
6755
6756 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
6757 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "ConnectEx on a unbound socket "
6758 "returned %d + errno %d\n", bret, WSAGetLastError());
6759
6760 /* ConnectEx needs a bound socket */
6761 memset(&conaddress, 0, sizeof(conaddress));
6762 conaddress.sin_family = AF_INET;
6763 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
6764 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
6765 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
6766
6767 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, NULL);
6768 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "ConnectEx on a NULL overlapped "
6769 "returned %d + errno %d\n", bret, WSAGetLastError());
6770
6771 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
6772
6773 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
6774 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
6775 "returned %d + errno %d\n", bret, WSAGetLastError());
6776 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
6777 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
6778
6779 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
6780 ok(bret, "Connecting failed, error %d\n", GetLastError());
6781 ok(bytesReturned == 0, "Bytes sent is %d\n", bytesReturned);
6782
6783 closesocket(connector);
6784 connector = socket(AF_INET, SOCK_STREAM, 0);
6785 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
6786 /* ConnectEx needs a bound socket */
6787 memset(&conaddress, 0, sizeof(conaddress));
6788 conaddress.sin_family = AF_INET;
6789 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
6790 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
6791 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
6792
6793 acceptor = accept(listener, NULL, NULL);
6794 ok(acceptor != INVALID_SOCKET, "failed to accept socket, error %u\n", WSAGetLastError());
6795
6796 buffer[0] = '1';
6797 buffer[1] = '2';
6798 buffer[2] = '3';
6799 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, buffer, 3, &bytesReturned, &overlapped);
6800 memset(buffer, 0, 3);
6801 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
6802 "returned %d + errno %d\n", bret, WSAGetLastError());
6803 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
6804 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
6805
6806 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
6807 ok(bret, "Connecting failed, error %d\n", GetLastError());
6808 ok(bytesReturned == 3, "Bytes sent is %d\n", bytesReturned);
6809
6810 acceptor = accept(listener, NULL, NULL);
6811 ok(acceptor != INVALID_SOCKET, "could not accept socket error %d\n", WSAGetLastError());
6812
6813 bytesReturned = recv(acceptor, buffer, 3, 0);
6814 buffer[4] = 0;
6815 ok(bytesReturned == 3, "Didn't get all sent data, got only %d\n", bytesReturned);
6816 ok(buffer[0] == '1' && buffer[1] == '2' && buffer[2] == '3',
6817 "Failed to get the right data, expected '123', got '%s'\n", buffer);
6818
6819 WSASetLastError(0xdeadbeef);
6820 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
6821 ok(iret == -1, "got %d\n", iret);
6822 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
6823
6824 WSASetLastError(0xdeadbeef);
6825 iret = connect(acceptor, (struct sockaddr *)&address, sizeof(address));
6826 ok(iret == -1, "got %d\n", iret);
6827 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
6828
6829 WSASetLastError(0xdeadbeef);
6830 overlapped.Internal = 0xdeadbeef;
6831 overlapped.InternalHigh = 0xdeadbeef;
6832 bret = pConnectEx(connector, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
6833 ok(!bret, "got %d\n", bret);
6834 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
6835 ok(overlapped.Internal == STATUS_PENDING, "got status %#x\n", (NTSTATUS)overlapped.Internal);
6836 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
6837
6838 WSASetLastError(0xdeadbeef);
6839 overlapped.Internal = 0xdeadbeef;
6840 overlapped.InternalHigh = 0xdeadbeef;
6841 bret = pConnectEx(acceptor, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
6842 ok(!bret, "got %d\n", bret);
6843 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
6844 ok(overlapped.Internal == STATUS_PENDING, "got status %#x\n", (NTSTATUS)overlapped.Internal);
6845 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
6846
6847 closesocket(connector);
6848 closesocket(acceptor);
6849 closesocket(listener);
6850
6851 tcp_socketpair(&connector, &acceptor);
6852
6853 WSASetLastError(0xdeadbeef);
6854 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
6855 ok(iret == -1, "got %d\n", iret);
6856 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
6857
6858 WSASetLastError(0xdeadbeef);
6859 iret = connect(acceptor, (struct sockaddr *)&address, sizeof(address));
6860 ok(iret == -1, "got %d\n", iret);
6861 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
6862
6863 WSASetLastError(0xdeadbeef);
6864 overlapped.Internal = 0xdeadbeef;
6865 overlapped.InternalHigh = 0xdeadbeef;
6866 bret = pConnectEx(connector, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
6867 ok(!bret, "got %d\n", bret);
6868 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
6869 ok(overlapped.Internal == STATUS_PENDING, "got status %#x\n", (NTSTATUS)overlapped.Internal);
6870 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
6871
6872 WSASetLastError(0xdeadbeef);
6873 overlapped.Internal = 0xdeadbeef;
6874 overlapped.InternalHigh = 0xdeadbeef;
6875 bret = pConnectEx(acceptor, (struct sockaddr *)&address, sizeof(address), NULL, 0, &bytesReturned, &overlapped);
6876 ok(!bret, "got %d\n", bret);
6877 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
6878 ok(overlapped.Internal == STATUS_PENDING, "got status %#x\n", (NTSTATUS)overlapped.Internal);
6879 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
6880
6881 closesocket(connector);
6882 closesocket(acceptor);
6883
6884 /* Connect with error */
6885
6886 connector = socket(AF_INET, SOCK_STREAM, 0);
6887 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
6888 /* ConnectEx needs a bound socket */
6889 memset(&conaddress, 0, sizeof(conaddress));
6890 conaddress.sin_family = AF_INET;
6891 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
6892 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
6893 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
6894
6895 address.sin_port = htons(1);
6896
6897 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
6898 ok(bret == FALSE && GetLastError() == ERROR_IO_PENDING, "ConnectEx to bad destination failed: "
6899 "returned %d + errno %d\n", bret, GetLastError());
6900 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
6901 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
6902
6903 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
6904 ok(bret == FALSE && GetLastError() == ERROR_CONNECTION_REFUSED,
6905 "Connecting to a disconnected host returned error %d - %d\n", bret, WSAGetLastError());
6906
6907 WSACloseEvent(overlapped.hEvent);
6908 closesocket(connector);
6909 }
6910
6911 static void test_AcceptEx(void)
6912 {
6913 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
6914 SOCKET listener, acceptor, acceptor2, connector, connector2;
6915 struct sockaddr_in bindAddress, peerAddress, *readBindAddress, *readRemoteAddress;
6916 int socklen, optlen;
6917 GUID acceptExGuid = WSAID_ACCEPTEX, getAcceptExGuid = WSAID_GETACCEPTEXSOCKADDRS;
6918 GUID connectex_guid = WSAID_CONNECTEX;
6919 LPFN_ACCEPTEX pAcceptEx = NULL;
6920 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs = NULL;
6921 LPFN_CONNECTEX pConnectEx = NULL;
6922 fd_set fds_accept, fds_send;
6923 static const struct timeval timeout = {1, 0};
6924 DWORD bytesReturned, connect_time;
6925 char buffer[1024], ipbuffer[32];
6926 OVERLAPPED overlapped = {0}, overlapped2 = {0};
6927 int iret, localSize = sizeof(struct sockaddr_in), remoteSize = localSize;
6928 BOOL bret;
6929 DWORD dwret;
6930
6931 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
6932 overlapped2.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
6933
6934 listener = socket(AF_INET, SOCK_STREAM, 0);
6935 ok(listener != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
6936
6937 acceptor = socket(AF_INET, SOCK_STREAM, 0);
6938 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
6939
6940 memset(&bindAddress, 0, sizeof(bindAddress));
6941 bindAddress.sin_family = AF_INET;
6942 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
6943 iret = bind(listener, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
6944 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
6945
6946 socklen = sizeof(bindAddress);
6947 iret = getsockname(listener, (struct sockaddr*)&bindAddress, &socklen);
6948 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
6949
6950 iret = set_blocking(listener, FALSE);
6951 ok(!iret, "Failed to set nonblocking, error %u\n", WSAGetLastError());
6952
6953 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
6954 &pAcceptEx, sizeof(pAcceptEx), &bytesReturned, NULL, NULL);
6955 ok(!iret, "Failed to get AcceptEx, error %u\n", WSAGetLastError());
6956
6957 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &getAcceptExGuid, sizeof(getAcceptExGuid),
6958 &pGetAcceptExSockaddrs, sizeof(pGetAcceptExSockaddrs), &bytesReturned, NULL, NULL);
6959 ok(!iret, "Failed to get GetAcceptExSockaddrs, error %u\n", WSAGetLastError());
6960
6961 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectex_guid, sizeof(connectex_guid),
6962 &pConnectEx, sizeof(pConnectEx), &bytesReturned, NULL, NULL);
6963 ok(!iret, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
6964
6965 overlapped.Internal = 0xdeadbeef;
6966 bret = pAcceptEx(INVALID_SOCKET, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
6967 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6968 &bytesReturned, &overlapped);
6969 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid listening socket "
6970 "returned %d + errno %d\n", bret, WSAGetLastError());
6971 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
6972
6973 overlapped.Internal = 0xdeadbeef;
6974 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
6975 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6976 &bytesReturned, &overlapped);
6977 todo_wine
6978 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on a non-listening socket "
6979 "returned %d + errno %d\n", bret, WSAGetLastError());
6980 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
6981 if (!bret && WSAGetLastError() == ERROR_IO_PENDING)
6982 CancelIo((HANDLE)listener);
6983
6984 iret = listen(listener, 5);
6985 ok(!iret, "failed to listen, error %u\n", GetLastError());
6986
6987 overlapped.Internal = 0xdeadbeef;
6988 bret = pAcceptEx(listener, INVALID_SOCKET, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
6989 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6990 &bytesReturned, &overlapped);
6991 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid accepting socket "
6992 "returned %d + errno %d\n", bret, WSAGetLastError());
6993 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
6994
6995 overlapped.Internal = 0xdeadbeef;
6996 bret = pAcceptEx(listener, acceptor, NULL, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
6997 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6998 &bytesReturned, &overlapped);
6999 todo_wine ok(bret == FALSE && WSAGetLastError() == WSAEFAULT,
7000 "AcceptEx on NULL buffer returned %d + errno %d\n", bret, WSAGetLastError());
7001 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
7002
7003 overlapped.Internal = 0xdeadbeef;
7004 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
7005 &bytesReturned, &overlapped);
7006 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING,
7007 "AcceptEx on too small local address size returned %d + errno %d\n",
7008 bret, WSAGetLastError());
7009 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
7010
7011 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7012 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
7013 iret = connect(connector, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
7014 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
7015 iret = getsockname(connector, (struct sockaddr *)&peerAddress, &remoteSize);
7016 ok(!iret, "getsockname failed, error %u\n", WSAGetLastError());
7017
7018 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7019 ok(!dwret, "wait failed\n");
7020 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7021 ok(bret, "got error %u\n", GetLastError());
7022 ok(!(NTSTATUS)overlapped.Internal, "got %#lx\n", overlapped.Internal);
7023 ok(!bytesReturned, "got size %u\n", bytesReturned);
7024
7025 readBindAddress = readRemoteAddress = (struct sockaddr_in *)0xdeadbeef;
7026 localSize = remoteSize = 0xdeadbeef;
7027 pGetAcceptExSockaddrs(buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
7028 (struct sockaddr **)&readBindAddress, &localSize, (struct sockaddr **)&readRemoteAddress, &remoteSize);
7029 todo_wine ok(readBindAddress == (struct sockaddr_in *)0xdeadbeef, "got local addr %p\n", readBindAddress);
7030 ok(!memcmp(readRemoteAddress, &peerAddress, sizeof(peerAddress)), "remote addr didn't match\n");
7031 todo_wine ok(localSize == 0xdeadbeef, "got local size %u\n", localSize);
7032 ok(remoteSize == sizeof(struct sockaddr_in), "got remote size %u\n", remoteSize);
7033
7034 closesocket(connector);
7035 closesocket(acceptor);
7036
7037 /* A UDP socket cannot be accepted into. */
7038
7039 acceptor = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
7040
7041 overlapped.Internal = 0xdeadbeef;
7042 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
7043 ok(!bret, "expected failure\n");
7044 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
7045 ok(overlapped.Internal == STATUS_PENDING, "got status %#x\n", (NTSTATUS)overlapped.Internal);
7046 if (WSAGetLastError() == ERROR_IO_PENDING)
7047 CancelIo((HANDLE)listener);
7048
7049 closesocket(acceptor);
7050
7051 /* A bound socket cannot be accepted into. */
7052
7053 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7054 iret = bind(acceptor, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
7055 ok(!iret, "got error %u\n", WSAGetLastError());
7056
7057 overlapped.Internal = 0xdeadbeef;
7058 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
7059 ok(!bret, "expected failure\n");
7060 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
7061 ok(overlapped.Internal == STATUS_PENDING, "got status %#x\n", (NTSTATUS)overlapped.Internal);
7062 if (WSAGetLastError() == ERROR_IO_PENDING)
7063 CancelIo((HANDLE)listener);
7064
7065 closesocket(acceptor);
7066
7067 /* A connected socket cannot be accepted into. */
7068
7069 tcp_socketpair(&acceptor, &acceptor2);
7070
7071 overlapped.Internal = 0xdeadbeef;
7072 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
7073 ok(!bret, "expected failure\n");
7074 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
7075 ok(overlapped.Internal == STATUS_PENDING, "got status %#x\n", (NTSTATUS)overlapped.Internal);
7076 if (WSAGetLastError() == ERROR_IO_PENDING)
7077 CancelIo((HANDLE)listener);
7078
7079 overlapped.Internal = 0xdeadbeef;
7080 bret = pAcceptEx(listener, acceptor2, buffer, 0, 0, sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
7081 ok(!bret, "expected failure\n");
7082 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
7083 ok(overlapped.Internal == STATUS_PENDING, "got status %#x\n", (NTSTATUS)overlapped.Internal);
7084 if (WSAGetLastError() == ERROR_IO_PENDING)
7085 CancelIo((HANDLE)listener);
7086
7087 closesocket(acceptor);
7088 closesocket(acceptor2);
7089
7090 /* Pass an insufficient local address size. */
7091
7092 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7093 ok(acceptor != -1, "failed to create socket, error %u\n", WSAGetLastError());
7094
7095 overlapped.Internal = 0xdeadbeef;
7096 bret = pAcceptEx(listener, acceptor, buffer, 0, 3,
7097 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
7098 ok(!bret && WSAGetLastError() == ERROR_IO_PENDING, "got %d, error %u\n", bret, WSAGetLastError());
7099 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got %#lx\n", overlapped.Internal);
7100
7101 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7102 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
7103 iret = connect(connector, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
7104 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
7105
7106 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7107 ok(!dwret, "wait failed\n");
7108 bytesReturned = 0xdeadbeef;
7109 SetLastError(0xdeadbeef);
7110 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7111 ok(!bret, "expected failure\n");
7112 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got error %u\n", GetLastError());
7113 ok((NTSTATUS)overlapped.Internal == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", overlapped.Internal);
7114 ok(!bytesReturned, "got size %u\n", bytesReturned);
7115
7116 closesocket(acceptor);
7117
7118 /* The above connection request is not accepted. */
7119 acceptor = accept(listener, NULL, NULL);
7120 todo_wine ok(acceptor != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
7121 closesocket(acceptor);
7122
7123 closesocket(connector);
7124
7125 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7126 ok(acceptor != -1, "failed to create socket, error %u\n", WSAGetLastError());
7127
7128 overlapped.Internal = 0xdeadbeef;
7129 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 4,
7130 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
7131 ok(!bret && WSAGetLastError() == ERROR_IO_PENDING, "got %d, error %u\n", bret, WSAGetLastError());
7132 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got %#lx\n", overlapped.Internal);
7133
7134 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7135 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
7136 iret = connect(connector, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
7137 ok(!iret, "failed to connect, error %u\n", WSAGetLastError());
7138
7139 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7140 ok(!dwret, "wait failed\n");
7141 bytesReturned = 0xdeadbeef;
7142 SetLastError(0xdeadbeef);
7143 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7144 todo_wine ok(!bret, "expected failure\n");
7145 todo_wine ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got error %u\n", GetLastError());
7146 todo_wine ok((NTSTATUS)overlapped.Internal == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", overlapped.Internal);
7147 ok(!bytesReturned, "got size %u\n", bytesReturned);
7148
7149 closesocket(acceptor);
7150
7151 /* The above connection request is not accepted. */
7152 acceptor = accept(listener, NULL, NULL);
7153 todo_wine ok(acceptor != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
7154 closesocket(acceptor);
7155
7156 closesocket(connector);
7157
7158 acceptor = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7159 ok(acceptor != -1, "failed to create socket, error %u\n", WSAGetLastError());
7160
7161 overlapped.Internal = 0xdeadbeef;
7162 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 15,
7163 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
7164 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx on too small local address "
7165 "size returned %d + errno %d\n",
7166 bret, WSAGetLastError());
7167 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
7168 bret = CancelIo((HANDLE) listener);
7169 ok(bret, "Failed to cancel pending accept socket\n");
7170
7171 overlapped.Internal = 0xdeadbeef;
7172 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16, 0,
7173 &bytesReturned, &overlapped);
7174 ok(bret == FALSE && WSAGetLastError() == WSAEFAULT,
7175 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
7176 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
7177
7178 overlapped.Internal = 0xdeadbeef;
7179 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16,
7180 sizeof(struct sockaddr_in) + 15, &bytesReturned, &overlapped);
7181 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING,
7182 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
7183 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
7184 bret = CancelIo((HANDLE) listener);
7185 ok(bret, "Failed to cancel pending accept socket\n");
7186
7187 bret = pAcceptEx(listener, acceptor, buffer, 0,
7188 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7189 &bytesReturned, NULL);
7190 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
7191 "returned %d + errno %d\n", bret, WSAGetLastError());
7192
7193 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, 0, &bytesReturned, NULL);
7194 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
7195 "returned %d + errno %d\n", bret, WSAGetLastError());
7196
7197 overlapped.Internal = 0xdeadbeef;
7198 bret = pAcceptEx(listener, acceptor, buffer, 0,
7199 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7200 &bytesReturned, &overlapped);
7201 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7202 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
7203
7204 /* try to accept into the same socket twice */
7205 overlapped.Internal = 0xdeadbeef;
7206 bret = pAcceptEx(listener, acceptor, buffer, 0,
7207 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7208 &bytesReturned, &overlapped);
7209 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL,
7210 "AcceptEx on already pending socket returned %d + errno %d\n", bret, WSAGetLastError());
7211 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
7212
7213 /* try to connect a socket that's being accepted into */
7214 iret = connect(acceptor, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7215 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL,
7216 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret, WSAGetLastError());
7217
7218 bret = pConnectEx(acceptor, (struct sockaddr *)&bindAddress, sizeof(bindAddress),
7219 NULL, 0, &bytesReturned, &overlapped2);
7220 ok(!bret, "expected failure\n");
7221 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
7222
7223 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7224 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
7225 overlapped.Internal = 0xdeadbeef;
7226 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7227 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7228
7229 dwret = WaitForSingleObject(overlapped.hEvent, INFINITE);
7230 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7231 ok(overlapped.Internal == STATUS_SUCCESS, "got %08x\n", (ULONG)overlapped.Internal);
7232
7233 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7234 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7235 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7236
7237 closesocket(connector);
7238 connector = INVALID_SOCKET;
7239 closesocket(acceptor);
7240
7241 /* Test short reads */
7242
7243 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7244 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %u\n", GetLastError());
7245 connector = socket(AF_INET, SOCK_STREAM, 0);
7246 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", GetLastError());
7247 overlapped.Internal = 0xdeadbeef;
7248 bret = pAcceptEx(listener, acceptor, buffer, 2,
7249 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7250 &bytesReturned, &overlapped);
7251 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7252 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
7253
7254 connect_time = 0xdeadbeef;
7255 optlen = sizeof(connect_time);
7256 iret = getsockopt(connector, SOL_SOCKET, SO_CONNECT_TIME, (char *)&connect_time, &optlen);
7257 ok(!iret, "getsockopt failed %d\n", WSAGetLastError());
7258 ok(connect_time == ~0u, "unexpected connect time %u\n", connect_time);
7259
7260 /* AcceptEx() still won't complete until we send data */
7261 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7262 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7263
7264 connect_time = 0xdeadbeef;
7265 optlen = sizeof(connect_time);
7266 iret = getsockopt(connector, SOL_SOCKET, SO_CONNECT_TIME, (char *)&connect_time, &optlen);
7267 ok(!iret, "getsockopt failed %d\n", WSAGetLastError());
7268 ok(connect_time < 0xdeadbeef, "unexpected connect time %u\n", connect_time);
7269
7270 dwret = WaitForSingleObject(overlapped.hEvent, 0);
7271 ok(dwret == WAIT_TIMEOUT, "Waiting for accept event timeout failed with %d + errno %d\n", dwret, GetLastError());
7272 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
7273
7274 iret = getsockname( connector, (struct sockaddr *)&peerAddress, &remoteSize);
7275 ok( !iret, "getsockname failed.\n");
7276
7277 /* AcceptEx() could complete any time now */
7278 iret = send(connector, buffer, 1, 0);
7279 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
7280
7281 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7282 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7283 ok(overlapped.Internal == STATUS_SUCCESS, "got %08x\n", (ULONG)overlapped.Internal);
7284
7285 /* Check if the buffer from AcceptEx is decoded correctly */
7286 pGetAcceptExSockaddrs(buffer, 2, sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7287 (struct sockaddr **)&readBindAddress, &localSize,
7288 (struct sockaddr **)&readRemoteAddress, &remoteSize);
7289 strcpy( ipbuffer, inet_ntoa(readBindAddress->sin_addr));
7290 ok( readBindAddress->sin_addr.s_addr == bindAddress.sin_addr.s_addr,
7291 "Local socket address is different %s != %s\n",
7292 ipbuffer, inet_ntoa(bindAddress.sin_addr));
7293 ok( readBindAddress->sin_port == bindAddress.sin_port,
7294 "Local socket port is different: %d != %d\n",
7295 readBindAddress->sin_port, bindAddress.sin_port);
7296 strcpy( ipbuffer, inet_ntoa(readRemoteAddress->sin_addr));
7297 ok( readRemoteAddress->sin_addr.s_addr == peerAddress.sin_addr.s_addr,
7298 "Remote socket address is different %s != %s\n",
7299 ipbuffer, inet_ntoa(peerAddress.sin_addr));
7300 ok( readRemoteAddress->sin_port == peerAddress.sin_port,
7301 "Remote socket port is different: %d != %d\n",
7302 readRemoteAddress->sin_port, peerAddress.sin_port);
7303
7304 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7305 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7306 ok(bytesReturned == 1, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7307
7308 closesocket(connector);
7309 connector = INVALID_SOCKET;
7310 closesocket(acceptor);
7311
7312 /* Test CF_DEFER & AcceptEx interaction */
7313
7314 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7315 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %u\n", GetLastError());
7316 connector = socket(AF_INET, SOCK_STREAM, 0);
7317 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", GetLastError());
7318 connector2 = socket(AF_INET, SOCK_STREAM, 0);
7319 ok(connector2 != INVALID_SOCKET, "failed to create socket, error %u\n", GetLastError());
7320
7321 iret = set_blocking(connector, FALSE);
7322 ok(!iret, "failed to set nonblocking, error %u\n", GetLastError());
7323 iret = set_blocking(connector2, FALSE);
7324 ok(!iret, "failed to set nonblocking, error %u\n", GetLastError());
7325
7326 /* Connect socket #1 */
7327 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7328 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7329
7330 buffer[0] = '0';
7331
7332 FD_ZERO(&fds_accept);
7333 FD_SET(listener, &fds_accept);
7334 iret = select(0, &fds_accept, NULL, NULL, &timeout);
7335 ok(iret == 1, "wait timed out\n");
7336
7337 acceptor2 = WSAAccept(listener, NULL, NULL, AlwaysDeferConditionFunc, 0);
7338 ok(acceptor2 == INVALID_SOCKET, "expected failure\n");
7339 ok(WSAGetLastError() == WSATRY_AGAIN, "got error %u\n", WSAGetLastError());
7340 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16,
7341 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
7342 ok(!bret, "expected failure\n");
7343 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
7344
7345 FD_ZERO(&fds_send);
7346 FD_SET(connector, &fds_send);
7347 iret = select(0, NULL, &fds_send, NULL, &timeout);
7348 ok(iret == 1, "wait timed out\n");
7349
7350 iret = send(connector, "1", 1, 0);
7351 ok(iret == 1, "got ret %d, error %u\n", iret, WSAGetLastError());
7352
7353 iret = connect(connector2, (struct sockaddr *)&bindAddress, sizeof(bindAddress));
7354 ok(iret == SOCKET_ERROR, "expected failure\n");
7355 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
7356
7357 iret = select(0, &fds_accept, NULL, NULL, &timeout);
7358 ok(iret == 1, "wait timed out\n");
7359
7360 acceptor2 = accept(listener, NULL, NULL);
7361 ok(acceptor2 != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
7362 closesocket(acceptor2);
7363
7364 FD_ZERO(&fds_send);
7365 FD_SET(connector2, &fds_send);
7366 iret = select(0, NULL, &fds_send, NULL, &timeout);
7367 ok(iret == 1, "wait timed out\n");
7368
7369 iret = send(connector2, "2", 1, 0);
7370 ok(iret == 1, "got ret %d, error %u\n", iret, WSAGetLastError());
7371
7372 dwret = WaitForSingleObject(overlapped.hEvent, 0);
7373 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7374
7375 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7376 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7377 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7378
7379 set_blocking(acceptor, TRUE);
7380 iret = recv( acceptor, buffer, 2, 0);
7381 ok(iret == 1, "Failed to get data, %d, errno: %d\n", iret, WSAGetLastError());
7382 ok(buffer[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer[0]);
7383
7384 closesocket(connector);
7385 closesocket(connector2);
7386 closesocket(acceptor);
7387
7388 /* clean up in case of failures */
7389 while ((acceptor = accept(listener, NULL, NULL)) != INVALID_SOCKET)
7390 closesocket(acceptor);
7391
7392 /* Disconnect during receive? */
7393
7394 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7395 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %u\n", GetLastError());
7396 connector = socket(AF_INET, SOCK_STREAM, 0);
7397 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", GetLastError());
7398 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7399 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7400 &bytesReturned, &overlapped);
7401 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7402
7403 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7404 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7405
7406 closesocket(connector);
7407 connector = INVALID_SOCKET;
7408
7409 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7410 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7411
7412 bytesReturned = 123456;
7413 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7414 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7415 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7416
7417 closesocket(acceptor);
7418
7419 /* Test closing with pending requests */
7420
7421 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7422 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %u\n", GetLastError());
7423 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7424 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7425 &bytesReturned, &overlapped);
7426 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7427
7428 closesocket(acceptor);
7429
7430 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7431 ok(dwret == WAIT_OBJECT_0,
7432 "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7433 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7434 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
7435
7436 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7437 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %u\n", GetLastError());
7438 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7439 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7440 &bytesReturned, &overlapped);
7441 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7442
7443 CancelIo((HANDLE) acceptor);
7444
7445 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7446 ok(dwret == WAIT_TIMEOUT, "Waiting for timeout failed with %d + errno %d\n", dwret, GetLastError());
7447
7448 closesocket(acceptor);
7449
7450 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7451 ok(acceptor != INVALID_SOCKET, "failed to create socket, error %u\n", GetLastError());
7452 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7453 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7454 &bytesReturned, &overlapped);
7455 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7456
7457 closesocket(listener);
7458
7459 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7460 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7461
7462 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7463 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
7464
7465 CloseHandle(overlapped.hEvent);
7466 CloseHandle(overlapped2.hEvent);
7467 closesocket(acceptor);
7468 closesocket(connector2);
7469 }
7470
7471 static void test_shutdown(void)
7472 {
7473 struct sockaddr_in addr, server_addr, client_addr;
7474 SOCKET listener, client, server;
7475 OVERLAPPED overlapped = {0};
7476 DWORD size, flags = 0;
7477 int ret, addrlen;
7478 char buffer[5];
7479 WSABUF wsabuf;
7480
7481 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
7482 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7483 ok(listener != INVALID_SOCKET, "failed to create listener socket, error %d\n", WSAGetLastError());
7484
7485 memset(&addr, 0, sizeof(addr));
7486 addr.sin_family = AF_INET;
7487 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
7488 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
7489 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
7490 addrlen = sizeof(server_addr);
7491 ret = getsockname(listener, (struct sockaddr *)&server_addr, &addrlen);
7492 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
7493
7494 ret = listen(listener, 1);
7495 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
7496
7497 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7498 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
7499
7500 WSASetLastError(0xdeadbeef);
7501 ret = shutdown(client, SD_SEND);
7502 ok(ret == -1, "expected failure\n");
7503 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
7504
7505 WSASetLastError(0xdeadbeef);
7506 ret = shutdown(client, SD_RECEIVE);
7507 ok(ret == -1, "expected failure\n");
7508 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
7509
7510 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
7511 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
7512 server = accept(listener, NULL, NULL);
7513 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
7514 set_blocking(client, FALSE);
7515
7516 WSASetLastError(0xdeadbeef);
7517 ret = shutdown(client, SD_SEND);
7518 ok(!ret, "expected success\n");
7519 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7520
7521 WSASetLastError(0xdeadbeef);
7522 ret = shutdown(client, SD_SEND);
7523 ok(!ret, "expected success\n");
7524 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7525
7526 WSASetLastError(0xdeadbeef);
7527 ret = send(client, "test", 5, 0);
7528 ok(ret == -1, "got %d\n", ret);
7529 todo_wine ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
7530
7531 ret = recv(server, buffer, sizeof(buffer), 0);
7532 ok(!ret, "got %d\n", ret);
7533 ret = recv(server, buffer, sizeof(buffer), 0);
7534 ok(!ret, "got %d\n", ret);
7535
7536 WSASetLastError(0xdeadbeef);
7537 ret = shutdown(server, SD_RECEIVE);
7538 ok(!ret, "expected success\n");
7539 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7540
7541 WSASetLastError(0xdeadbeef);
7542 ret = recv(server, buffer, sizeof(buffer), 0);
7543 todo_wine ok(ret == -1, "got %d\n", ret);
7544 todo_wine ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
7545
7546 ret = send(server, "test", 5, 0);
7547 ok(ret == 5, "got %d\n", ret);
7548
7549 ret = sync_recv(client, buffer, sizeof(buffer), 0);
7550 ok(ret == 5, "got %d\n", ret);
7551 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, ret));
7552
7553 WSASetLastError(0xdeadbeef);
7554 ret = shutdown(client, SD_RECEIVE);
7555 ok(!ret, "expected success\n");
7556 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7557
7558 WSASetLastError(0xdeadbeef);
7559 ret = recv(client, buffer, sizeof(buffer), 0);
7560 ok(ret == -1, "got %d\n", ret);
7561 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
7562
7563 WSASetLastError(0xdeadbeef);
7564 ret = recv(client, buffer, sizeof(buffer), 0);
7565 ok(ret == -1, "got %d\n", ret);
7566 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
7567
7568 WSASetLastError(0xdeadbeef);
7569 ret = shutdown(server, SD_SEND);
7570 ok(!ret, "expected success\n");
7571 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7572
7573 WSASetLastError(0xdeadbeef);
7574 ret = send(server, "test", 5, 0);
7575 ok(ret == -1, "got %d\n", ret);
7576 todo_wine ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
7577
7578 addrlen = sizeof(addr);
7579 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
7580 todo_wine ok(!ret, "got error %u\n", WSAGetLastError());
7581 todo_wine ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
7582
7583 addrlen = sizeof(client_addr);
7584 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
7585 ok(!ret, "got error %u\n", WSAGetLastError());
7586 addrlen = sizeof(addr);
7587 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
7588 todo_wine ok(!ret, "got error %u\n", WSAGetLastError());
7589 todo_wine ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
7590
7591 WSASetLastError(0xdeadbeef);
7592 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
7593 ok(ret == -1, "got %d\n", ret);
7594 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
7595
7596 WSASetLastError(0xdeadbeef);
7597 ret = shutdown(client, 0xdeadbeef);
7598 ok(ret == -1, "expected failure\n");
7599 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
7600
7601 closesocket(client);
7602 closesocket(server);
7603
7604 /* Test SD_BOTH. */
7605
7606 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7607 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
7608 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
7609 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
7610 server = accept(listener, NULL, NULL);
7611 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
7612
7613 WSASetLastError(0xdeadbeef);
7614 ret = shutdown(client, SD_BOTH);
7615 ok(!ret, "expected success\n");
7616 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7617
7618 WSASetLastError(0xdeadbeef);
7619 ret = recv(client, buffer, sizeof(buffer), 0);
7620 ok(ret == -1, "got %d\n", ret);
7621 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
7622
7623 WSASetLastError(0xdeadbeef);
7624 ret = send(client, "test", 5, 0);
7625 ok(ret == -1, "got %d\n", ret);
7626 todo_wine ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
7627
7628 ret = recv(server, buffer, sizeof(buffer), 0);
7629 ok(!ret, "got %d\n", ret);
7630
7631 WSASetLastError(0xdeadbeef);
7632 ret = shutdown(server, SD_BOTH);
7633 ok(!ret, "expected success\n");
7634 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7635
7636 WSASetLastError(0xdeadbeef);
7637 ret = recv(server, buffer, sizeof(buffer), 0);
7638 todo_wine ok(ret == -1, "got %d\n", ret);
7639 todo_wine ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
7640
7641 WSASetLastError(0xdeadbeef);
7642 ret = send(server, "test", 5, 0);
7643 ok(ret == -1, "got %d\n", ret);
7644 todo_wine ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
7645
7646 addrlen = sizeof(addr);
7647 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
7648 todo_wine ok(!ret, "got error %u\n", WSAGetLastError());
7649 todo_wine ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
7650
7651 addrlen = sizeof(client_addr);
7652 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
7653 ok(!ret, "got error %u\n", WSAGetLastError());
7654 addrlen = sizeof(addr);
7655 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
7656 todo_wine ok(!ret, "got error %u\n", WSAGetLastError());
7657 todo_wine ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
7658
7659 closesocket(client);
7660 closesocket(server);
7661
7662 /* Test shutting down with async I/O pending. */
7663
7664 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7665 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
7666 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
7667 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
7668 server = accept(listener, NULL, NULL);
7669 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
7670 set_blocking(client, FALSE);
7671
7672 wsabuf.buf = buffer;
7673 wsabuf.len = sizeof(buffer);
7674 WSASetLastError(0xdeadbeef);
7675 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
7676 ok(ret == -1, "got %d\n", ret);
7677 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
7678
7679 ret = shutdown(client, SD_RECEIVE);
7680 ok(!ret, "got error %u\n", WSAGetLastError());
7681
7682 WSASetLastError(0xdeadbeef);
7683 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
7684 ok(ret == -1, "got %d\n", ret);
7685 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
7686
7687 ret = send(server, "test", 5, 0);
7688 ok(ret == 5, "got %d\n", ret);
7689
7690 ret = WaitForSingleObject(overlapped.hEvent, 1000);
7691 ok(!ret, "wait timed out\n");
7692 size = 0xdeadbeef;
7693 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
7694 ok(ret, "got error %u\n", GetLastError());
7695 ok(size == 5, "got size %u\n", size);
7696 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, size));
7697
7698 WSASetLastError(0xdeadbeef);
7699 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
7700 ok(ret == -1, "got %d\n", ret);
7701 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
7702
7703 WSASetLastError(0xdeadbeef);
7704 ret = WSARecv(server, &wsabuf, 1, &size, &flags, &overlapped, NULL);
7705 ok(ret == -1, "got %d\n", ret);
7706 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
7707
7708 ret = shutdown(client, SD_SEND);
7709 ok(!ret, "got error %u\n", WSAGetLastError());
7710
7711 ret = WaitForSingleObject(overlapped.hEvent, 1000);
7712 ok(!ret, "wait timed out\n");
7713 size = 0xdeadbeef;
7714 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
7715 ok(ret, "got error %u\n", GetLastError());
7716 ok(!size, "got size %u\n", size);
7717
7718 closesocket(client);
7719 closesocket(server);
7720
7721 /* Test shutting down a listening socket. */
7722
7723 WSASetLastError(0xdeadbeef);
7724 ret = shutdown(listener, SD_SEND);
7725 ok(ret == -1, "expected failure\n");
7726 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
7727
7728 WSASetLastError(0xdeadbeef);
7729 ret = shutdown(listener, SD_RECEIVE);
7730 ok(ret == -1, "expected failure\n");
7731 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
7732
7733 closesocket(listener);
7734
7735 /* Test shutting down UDP sockets. */
7736
7737 client = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
7738 server = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
7739 memset(&addr, 0, sizeof(addr));
7740 addr.sin_family = AF_INET;
7741 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
7742 ret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
7743 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
7744 addrlen = sizeof(server_addr);
7745 ret = getsockname(server, (struct sockaddr *)&server_addr, &addrlen);
7746 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
7747 set_blocking(server, FALSE);
7748
7749 WSASetLastError(0xdeadbeef);
7750 ret = shutdown(server, SD_RECEIVE);
7751 ok(!ret, "expected success\n");
7752 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7753
7754 WSASetLastError(0xdeadbeef);
7755 ret = recvfrom(server, buffer, sizeof(buffer), 0, NULL, NULL);
7756 ok(ret == -1, "got %d\n", ret);
7757 ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
7758
7759 ret = sendto(client, "test", 5, 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
7760 ok(ret == 5, "got %d\n", ret);
7761
7762 WSASetLastError(0xdeadbeef);
7763 ret = shutdown(client, SD_SEND);
7764 ok(!ret, "expected success\n");
7765 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7766
7767 WSASetLastError(0xdeadbeef);
7768 ret = shutdown(client, SD_SEND);
7769 ok(!ret, "expected success\n");
7770 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7771
7772 WSASetLastError(0xdeadbeef);
7773 ret = sendto(client, "test", 5, 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
7774 ok(ret == -1, "got %d\n", ret);
7775 todo_wine ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
7776
7777 closesocket(client);
7778 closesocket(server);
7779
7780 CloseHandle(overlapped.hEvent);
7781 }
7782
7783 static void test_DisconnectEx(void)
7784 {
7785 struct sockaddr_in server_addr, client_addr, addr;
7786 GUID disconnectex_guid = WSAID_DISCONNECTEX;
7787 SOCKET listener, server, client;
7788 LPFN_DISCONNECTEX pDisconnectEx;
7789 OVERLAPPED overlapped = {0};
7790 int addrlen, ret;
7791 char buffer[5];
7792 DWORD size;
7793
7794 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
7795
7796 client = socket(AF_INET, SOCK_STREAM, 0);
7797 ok(client != INVALID_SOCKET, "failed to create connector socket, error %u\n", WSAGetLastError());
7798
7799 ret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &disconnectex_guid, sizeof(disconnectex_guid),
7800 &pDisconnectEx, sizeof(pDisconnectEx), &size, NULL, NULL);
7801 if (ret)
7802 {
7803 win_skip("WSAIoctl failed to get DisconnectEx, error %d\n", WSAGetLastError());
7804 closesocket(client);
7805 return;
7806 }
7807
7808 listener = socket(AF_INET, SOCK_STREAM, 0);
7809 ok(listener != INVALID_SOCKET, "failed to create listener socket, error %d\n", WSAGetLastError());
7810
7811 memset(&addr, 0, sizeof(addr));
7812 addr.sin_family = AF_INET;
7813 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
7814 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
7815 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
7816 addrlen = sizeof(server_addr);
7817 ret = getsockname(listener, (struct sockaddr *)&server_addr, &addrlen);
7818 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
7819 ret = listen(listener, 1);
7820 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
7821
7822 WSASetLastError(0xdeadbeef);
7823 ret = pDisconnectEx(INVALID_SOCKET, &overlapped, 0, 0);
7824 ok(!ret, "expected failure\n");
7825 ok(WSAGetLastError() == WSAENOTSOCK, "got error %u\n", WSAGetLastError());
7826
7827 WSASetLastError(0xdeadbeef);
7828 ret = pDisconnectEx(client, &overlapped, 0, 0);
7829 ok(!ret, "expected failure\n");
7830 ok(WSAGetLastError() == WSAENOTCONN, "got error %u\n", WSAGetLastError());
7831
7832 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
7833 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
7834 server = accept(listener, NULL, NULL);
7835 ok(server != INVALID_SOCKET, "failed to accept, error %u\n", WSAGetLastError());
7836
7837 WSASetLastError(0xdeadbeef);
7838 ret = pDisconnectEx(client, &overlapped, 0, 0);
7839 ok(!ret, "expected failure\n");
7840 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
7841
7842 ret = WaitForSingleObject(overlapped.hEvent, 1000);
7843 ok(!ret, "wait timed out\n");
7844 size = 0xdeadbeef;
7845 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
7846 ok(ret, "got error %u\n", GetLastError());
7847 ok(!size, "got size %u\n", size);
7848
7849 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
7850 ok(ret == -1, "expected failure\n");
7851 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
7852
7853 WSASetLastError(0xdeadbeef);
7854 ret = send(client, "test", 5, 0);
7855 ok(ret == -1, "expected failure\n");
7856 todo_wine ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
7857
7858 ret = recv(server, buffer, sizeof(buffer), 0);
7859 ok(!ret, "got %d\n", ret);
7860
7861 ret = send(server, "test", 5, 0);
7862 ok(ret == 5, "got %d\n", ret);
7863
7864 ret = recv(client, buffer, sizeof(buffer), 0);
7865 ok(ret == 5, "got %d\n", ret);
7866 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, ret));
7867
7868 addrlen = sizeof(addr);
7869 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
7870 ok(!ret, "got error %u\n", WSAGetLastError());
7871 ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
7872
7873 addrlen = sizeof(client_addr);
7874 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
7875 ok(!ret, "got error %u\n", WSAGetLastError());
7876 addrlen = sizeof(addr);
7877 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
7878 ok(!ret, "got error %u\n", WSAGetLastError());
7879 ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
7880
7881 closesocket(client);
7882 closesocket(server);
7883
7884 /* Test the synchronous case. */
7885
7886 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
7887 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
7888 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
7889 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
7890 server = accept(listener, NULL, NULL);
7891 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
7892
7893 WSASetLastError(0xdeadbeef);
7894 ret = pDisconnectEx(client, NULL, 0, 0);
7895 ok(ret, "expected success\n");
7896 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7897
7898 WSASetLastError(0xdeadbeef);
7899 ret = pDisconnectEx(client, NULL, 0, 0);
7900 ok(ret, "expected success\n");
7901 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", WSAGetLastError());
7902
7903 ret = connect(client, (struct sockaddr *)&server_addr, sizeof(server_addr));
7904 ok(ret == -1, "expected failure\n");
7905 ok(WSAGetLastError() == WSAEISCONN, "got error %u\n", WSAGetLastError());
7906
7907 WSASetLastError(0xdeadbeef);
7908 ret = send(client, "test", 5, 0);
7909 ok(ret == -1, "expected failure\n");
7910 todo_wine ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError());
7911
7912 ret = recv(server, buffer, sizeof(buffer), 0);
7913 ok(!ret, "got %d\n", ret);
7914
7915 ret = send(server, "test", 5, 0);
7916 ok(ret == 5, "got %d\n", ret);
7917
7918 ret = recv(client, buffer, sizeof(buffer), 0);
7919 ok(ret == 5, "got %d\n", ret);
7920 ok(!strcmp(buffer, "test"), "got %s\n", debugstr_an(buffer, ret));
7921
7922 addrlen = sizeof(addr);
7923 ret = getpeername(client, (struct sockaddr *)&addr, &addrlen);
7924 ok(!ret, "got error %u\n", WSAGetLastError());
7925 ok(!memcmp(&addr, &server_addr, sizeof(server_addr)), "address didn't match\n");
7926
7927 addrlen = sizeof(client_addr);
7928 ret = getsockname(client, (struct sockaddr *)&client_addr, &addrlen);
7929 ok(!ret, "got error %u\n", WSAGetLastError());
7930 addrlen = sizeof(addr);
7931 ret = getpeername(server, (struct sockaddr *)&addr, &addrlen);
7932 ok(!ret, "got error %u\n", WSAGetLastError());
7933 ok(!memcmp(&addr, &client_addr, sizeof(addr)), "address didn't match\n");
7934
7935 closesocket(client);
7936 closesocket(server);
7937
7938 closesocket(listener);
7939 CloseHandle(overlapped.hEvent);
7940 }
7941
7942 #define compare_file(h,s,o) compare_file2(h,s,o,__FILE__,__LINE__)
7943
7944 static void compare_file2(HANDLE handle, SOCKET sock, int offset, const char *file, int line)
7945 {
7946 char buf1[256], buf2[256];
7947 BOOL success;
7948 int i = 0;
7949
7950 SetFilePointer(handle, offset, NULL, FILE_BEGIN);
7951 while (1)
7952 {
7953 DWORD n1 = 0, n2 = 0;
7954
7955 success = ReadFile(handle, buf1, sizeof(buf1), &n1, NULL);
7956 ok_(file,line)(success, "Failed to read from file.\n");
7957 if (success && n1 == 0)
7958 break;
7959 else if(!success)
7960 return;
7961 n2 = recv(sock, buf2, n1, 0);
7962 ok_(file,line)(n1 == n2, "Block %d size mismatch (%d != %d)\n", i, n1, n2);
7963 ok_(file,line)(memcmp(buf1, buf2, n2) == 0, "Block %d failed\n", i);
7964 i++;
7965 }
7966 }
7967
7968 static void test_TransmitFile(void)
7969 {
7970 DWORD num_bytes, err, file_size, total_sent;
7971 GUID transmitFileGuid = WSAID_TRANSMITFILE;
7972 LPFN_TRANSMITFILE pTransmitFile = NULL;
7973 HANDLE file = INVALID_HANDLE_VALUE;
7974 char header_msg[] = "hello world";
7975 char footer_msg[] = "goodbye!!!";
7976 char system_ini_path[MAX_PATH];
7977 struct sockaddr_in bindAddress;
7978 TRANSMIT_FILE_BUFFERS buffers;
7979 SOCKET client, server, dest;
7980 WSAOVERLAPPED ov;
7981 char buf[256];
7982 int iret, len;
7983 BOOL bret;
7984
7985 memset( &ov, 0, sizeof(ov) );
7986
7987 /* Setup sockets for testing TransmitFile */
7988 client = socket(AF_INET, SOCK_STREAM, 0);
7989 ok(client != INVALID_SOCKET, "failed to create socket, error %u\n", GetLastError());
7990 server = socket(AF_INET, SOCK_STREAM, 0);
7991 ok(server != INVALID_SOCKET, "failed to create socket, error %u\n", GetLastError());
7992 iret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &transmitFileGuid, sizeof(transmitFileGuid),
7993 &pTransmitFile, sizeof(pTransmitFile), &num_bytes, NULL, NULL);
7994 ok(!iret, "failed to get TransmitFile, error %u\n", GetLastError());
7995 GetSystemWindowsDirectoryA(system_ini_path, MAX_PATH );
7996 strcat(system_ini_path, "\\system.ini");
7997 file = CreateFileA(system_ini_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0x0, NULL);
7998 ok(file != INVALID_HANDLE_VALUE, "failed to open file, error %u\n", GetLastError());
7999 file_size = GetFileSize(file, NULL);
8000
8001 /* Test TransmitFile with an invalid socket */
8002 bret = pTransmitFile(INVALID_SOCKET, file, 0, 0, NULL, NULL, 0);
8003 err = WSAGetLastError();
8004 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8005 ok(err == WSAENOTSOCK, "TransmitFile triggered unexpected errno (%d != %d)\n", err, WSAENOTSOCK);
8006
8007 /* Test a bogus TransmitFile without a connected socket */
8008 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, TF_REUSE_SOCKET);
8009 err = WSAGetLastError();
8010 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8011 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%d != %d)\n", err, WSAENOTCONN);
8012
8013 /* Setup a properly connected socket for transfers */
8014 memset(&bindAddress, 0, sizeof(bindAddress));
8015 bindAddress.sin_family = AF_INET;
8016 bindAddress.sin_port = htons(SERVERPORT+1);
8017 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8018 iret = bind(server, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8019 ok(!iret, "failed to bind socket, error %u\n", GetLastError());
8020 iret = listen(server, 1);
8021 ok(!iret, "failed to listen, error %u\n", GetLastError());
8022 iret = connect(client, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8023 ok(!iret, "failed to connect, error %u\n", GetLastError());
8024 len = sizeof(bindAddress);
8025 dest = accept(server, (struct sockaddr*)&bindAddress, &len);
8026 ok(dest != INVALID_SOCKET, "failed to accept, error %u\n", GetLastError());
8027 iret = set_blocking(dest, FALSE);
8028 ok(!iret, "failed to set nonblocking, error %u\n", GetLastError());
8029
8030 /* Test TransmitFile with no possible buffer */
8031 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
8032 ok(bret, "TransmitFile failed unexpectedly.\n");
8033 iret = recv(dest, buf, sizeof(buf), 0);
8034 ok(iret == -1, "Returned an unexpected buffer from TransmitFile (%d != -1).\n", iret);
8035
8036 /* Test TransmitFile with only buffer data */
8037 buffers.Head = &header_msg[0];
8038 buffers.HeadLength = sizeof(header_msg);
8039 buffers.Tail = &footer_msg[0];
8040 buffers.TailLength = sizeof(footer_msg);
8041 bret = pTransmitFile(client, NULL, 0, 0, NULL, &buffers, 0);
8042 ok(bret, "TransmitFile failed unexpectedly.\n");
8043 iret = recv(dest, buf, sizeof(buf), 0);
8044 ok(iret == sizeof(header_msg)+sizeof(footer_msg),
8045 "Returned an unexpected buffer from TransmitFile: %d\n", iret );
8046 ok(memcmp(&buf[0], &header_msg[0], sizeof(header_msg)) == 0,
8047 "TransmitFile header buffer did not match!\n");
8048 ok(memcmp(&buf[sizeof(header_msg)], &footer_msg[0], sizeof(footer_msg)) == 0,
8049 "TransmitFile footer buffer did not match!\n");
8050
8051 /* Test TransmitFile with only file data */
8052 bret = pTransmitFile(client, file, 0, 0, NULL, NULL, 0);
8053 ok(bret, "TransmitFile failed unexpectedly.\n");
8054 compare_file(file, dest, 0);
8055
8056 /* Test TransmitFile with both file and buffer data */
8057 buffers.Head = &header_msg[0];
8058 buffers.HeadLength = sizeof(header_msg);
8059 buffers.Tail = &footer_msg[0];
8060 buffers.TailLength = sizeof(footer_msg);
8061 SetFilePointer(file, 0, NULL, FILE_BEGIN);
8062 bret = pTransmitFile(client, file, 0, 0, NULL, &buffers, 0);
8063 ok(bret, "TransmitFile failed unexpectedly.\n");
8064 iret = recv(dest, buf, sizeof(header_msg), 0);
8065 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)) == 0,
8066 "TransmitFile header buffer did not match!\n");
8067 compare_file(file, dest, 0);
8068 iret = recv(dest, buf, sizeof(footer_msg), 0);
8069 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)) == 0,
8070 "TransmitFile footer buffer did not match!\n");
8071
8072 /* Test overlapped TransmitFile */
8073 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
8074 SetFilePointer(file, 0, NULL, FILE_BEGIN);
8075 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
8076 err = WSAGetLastError();
8077 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8078 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%d != %d)\n",
8079 err, ERROR_IO_PENDING);
8080 iret = WaitForSingleObject(ov.hEvent, 2000);
8081 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
8082 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
8083 ok(total_sent == file_size,
8084 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8085 total_sent, file_size);
8086 compare_file(file, dest, 0);
8087
8088 /* Test overlapped TransmitFile w/ start offset */
8089 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
8090 SetFilePointer(file, 0, NULL, FILE_BEGIN);
8091 ov.Offset = 10;
8092 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
8093 err = WSAGetLastError();
8094 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8095 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%d != %d)\n", err, ERROR_IO_PENDING);
8096 iret = WaitForSingleObject(ov.hEvent, 2000);
8097 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
8098 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
8099 ok(total_sent == (file_size - ov.Offset),
8100 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8101 total_sent, file_size - ov.Offset);
8102 compare_file(file, dest, ov.Offset);
8103
8104 /* Test overlapped TransmitFile w/ file and buffer data */
8105 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
8106 buffers.Head = &header_msg[0];
8107 buffers.HeadLength = sizeof(header_msg);
8108 buffers.Tail = &footer_msg[0];
8109 buffers.TailLength = sizeof(footer_msg);
8110 SetFilePointer(file, 0, NULL, FILE_BEGIN);
8111 ov.Offset = 0;
8112 bret = pTransmitFile(client, file, 0, 0, &ov, &buffers, 0);
8113 err = WSAGetLastError();
8114 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8115 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%d != %d)\n", err, ERROR_IO_PENDING);
8116 iret = WaitForSingleObject(ov.hEvent, 2000);
8117 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
8118 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
8119 ok(total_sent == (file_size + buffers.HeadLength + buffers.TailLength),
8120 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8121 total_sent, file_size + buffers.HeadLength + buffers.TailLength);
8122 iret = recv(dest, buf, sizeof(header_msg), 0);
8123 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)) == 0,
8124 "TransmitFile header buffer did not match!\n");
8125 compare_file(file, dest, 0);
8126 iret = recv(dest, buf, sizeof(footer_msg), 0);
8127 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)) == 0,
8128 "TransmitFile footer buffer did not match!\n");
8129
8130 /* Test TransmitFile with a UDP datagram socket */
8131 closesocket(client);
8132 client = socket(AF_INET, SOCK_DGRAM, 0);
8133 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
8134 err = WSAGetLastError();
8135 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8136 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%d != %d)\n", err, WSAENOTCONN);
8137
8138 CloseHandle(file);
8139 CloseHandle(ov.hEvent);
8140 closesocket(client);
8141 closesocket(server);
8142 }
8143
8144 static void test_getpeername(void)
8145 {
8146 SOCKET sock;
8147 struct sockaddr_in sa, sa_out;
8148 SOCKADDR_STORAGE ss;
8149 int sa_len;
8150 const char buf[] = "hello world";
8151 int ret;
8152
8153 /* Test the parameter validation order. */
8154 ret = getpeername(INVALID_SOCKET, NULL, NULL);
8155 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
8156 ok(WSAGetLastError() == WSAENOTSOCK,
8157 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
8158
8159 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
8160 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
8161
8162 ret = getpeername(sock, NULL, NULL);
8163 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
8164 todo_wine ok(WSAGetLastError() == WSAENOTCONN,
8165 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
8166
8167 memset(&sa, 0, sizeof(sa));
8168 sa.sin_family = AF_INET;
8169 sa.sin_port = htons(139);
8170 sa.sin_addr.s_addr = inet_addr("127.0.0.1");
8171
8172 /* sendto does not change a socket's connection state. */
8173 ret = sendto(sock, buf, sizeof(buf), 0, (struct sockaddr*)&sa, sizeof(sa));
8174 ok(ret != SOCKET_ERROR,
8175 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
8176
8177 ret = getpeername(sock, NULL, NULL);
8178 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
8179 todo_wine ok(WSAGetLastError() == WSAENOTCONN,
8180 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
8181
8182 ret = connect(sock, (struct sockaddr*)&sa, sizeof(sa));
8183 ok(ret == 0,
8184 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
8185
8186 ret = getpeername(sock, NULL, NULL);
8187 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
8188 ok(WSAGetLastError() == WSAEFAULT,
8189 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8190
8191 /* Test crashes on Wine. */
8192 if (0)
8193 {
8194 ret = getpeername(sock, (void*)0xdeadbeef, (void*)0xcafebabe);
8195 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
8196 ok(WSAGetLastError() == WSAEFAULT,
8197 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8198 }
8199
8200 ret = getpeername(sock, (struct sockaddr*)&sa_out, NULL);
8201 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
8202 ok(WSAGetLastError() == WSAEFAULT,
8203 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8204
8205 sa_len = 0;
8206 ret = getpeername(sock, NULL, &sa_len);
8207 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
8208 ok(WSAGetLastError() == WSAEFAULT,
8209 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8210 ok(!sa_len, "got %d\n", sa_len);
8211
8212 sa_len = 0;
8213 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
8214 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
8215 ok(WSAGetLastError() == WSAEFAULT,
8216 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8217 ok(!sa_len, "got %d\n", sa_len);
8218
8219 sa_len = sizeof(ss);
8220 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
8221 ok(ret == 0, "Expected getpeername to return 0, got %d\n", ret);
8222 ok(!memcmp(&sa, &ss, sizeof(sa)),
8223 "Expected the returned structure to be identical to the connect structure\n");
8224 ok(sa_len == sizeof(sa), "got %d\n", sa_len);
8225
8226 closesocket(sock);
8227 }
8228
8229 static void test_sioRoutingInterfaceQuery(void)
8230 {
8231 OVERLAPPED overlapped = {0}, *overlapped_ptr;
8232 struct sockaddr_in in = {0}, out = {0};
8233 ULONG_PTR key;
8234 HANDLE port;
8235 SOCKET sock;
8236 DWORD size;
8237 int ret;
8238
8239 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
8240 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
8241 port = CreateIoCompletionPort((HANDLE)sock, NULL, 123, 0);
8242
8243 WSASetLastError(0xdeadbeef);
8244 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), NULL, NULL, NULL);
8245 ok(ret == -1, "expected failure\n");
8246 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
8247
8248 size = 0xdeadbeef;
8249 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in) - 1, &out, sizeof(out), &size, NULL, NULL);
8250 ok(ret == -1, "expected failure\n");
8251 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8252 ok(size == 0xdeadbeef, "got size %u\n", size);
8253
8254 size = 0xdeadbeef;
8255 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, NULL, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
8256 ok(ret == -1, "expected failure\n");
8257 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8258 ok(size == 0xdeadbeef, "got size %u\n", size);
8259
8260 size = 0xdeadbeef;
8261 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
8262 ok(ret == -1, "expected failure\n");
8263 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError());
8264 ok(size == 0xdeadbeef, "got size %u\n", size);
8265
8266 in.sin_family = AF_INET;
8267 size = 0xdeadbeef;
8268 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
8269 todo_wine ok(ret == -1, "expected failure\n");
8270 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
8271 todo_wine ok(size == 0xdeadbeef, "got size %u\n", size);
8272
8273 in.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
8274 WSASetLastError(0xdeadbeef);
8275 size = 0xdeadbeef;
8276 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, NULL, NULL);
8277 ok(!ret, "expected failure\n");
8278 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
8279 ok(size == sizeof(out), "got size %u\n", size);
8280 /* We expect the source address to be INADDR_LOOPBACK as well, but
8281 * there's no guarantee that a route to the loopback address exists,
8282 * so rather than introduce spurious test failures we do not test the
8283 * source address.
8284 */
8285
8286 size = 0xdeadbeef;
8287 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out) - 1, &size, NULL, NULL);
8288 ok(ret == -1, "expected failure\n");
8289 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
8290 todo_wine ok(size == sizeof(out), "got size %u\n", size);
8291
8292 size = 0xdeadbeef;
8293 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), NULL, sizeof(out), &size, NULL, NULL);
8294 ok(ret == -1, "expected failure\n");
8295 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
8296 ok(size == 0xdeadbeef, "got size %u\n", size);
8297
8298 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), NULL, &overlapped, NULL);
8299 ok(ret == -1, "expected failure\n");
8300 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
8301 ok(size == 0xdeadbeef, "got size %u\n", size);
8302
8303 WSASetLastError(0xdeadbeef);
8304 size = 0xdeadbeef;
8305 overlapped.Internal = 0xdeadbeef;
8306 overlapped.InternalHigh = 0xdeadbeef;
8307 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in), &out, sizeof(out), &size, &overlapped, NULL);
8308 ok(!ret, "expected failure\n");
8309 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
8310 ok(size == sizeof(out), "got size %u\n", size);
8311
8312 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
8313 ok(ret, "got error %u\n", GetLastError());
8314 ok(!size, "got size %u\n", size);
8315 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
8316 ok(!overlapped.Internal, "got status %#x\n", (NTSTATUS)overlapped.Internal);
8317 ok(!overlapped.InternalHigh, "got size %Iu\n", overlapped.InternalHigh);
8318
8319 CloseHandle(port);
8320 closesocket(sock);
8321
8322 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
8323
8324 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in),
8325 &out, sizeof(out), NULL, &overlapped, socket_apc);
8326 ok(ret == -1, "expected failure\n");
8327 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
8328
8329 apc_count = 0;
8330 size = 0xdeadbeef;
8331 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &in, sizeof(in),
8332 &out, sizeof(out), &size, &overlapped, socket_apc);
8333 ok(!ret, "expected success\n");
8334 ok(size == sizeof(out), "got size %u\n", size);
8335
8336 ret = SleepEx(0, TRUE);
8337 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
8338 ok(apc_count == 1, "APC was called %u times\n", apc_count);
8339 ok(!apc_error, "got APC error %u\n", apc_error);
8340 ok(!apc_size, "got APC size %u\n", apc_size);
8341 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
8342
8343 closesocket(sock);
8344 }
8345
8346 static void test_sioAddressListChange(void)
8347 {
8348 struct sockaddr_in bindAddress;
8349 struct in_addr net_address;
8350 WSAOVERLAPPED overlapped, *olp;
8351 struct hostent *h;
8352 DWORD num_bytes, error, tick;
8353 SOCKET sock, sock2, sock3;
8354 WSAEVENT event2, event3;
8355 HANDLE io_port;
8356 ULONG_PTR key;
8357 int acount;
8358 BOOL bret;
8359 int ret;
8360
8361 /* Use gethostbyname to find the list of local network interfaces */
8362 h = gethostbyname("");
8363 ok(!!h, "failed to get interface list, error %u\n", WSAGetLastError());
8364 for (acount = 0; h->h_addr_list[acount]; acount++);
8365 if (acount == 0)
8366 {
8367 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
8368 return;
8369 }
8370
8371 net_address.s_addr = *(ULONG *) h->h_addr_list[0];
8372
8373 sock = socket(AF_INET, 0, IPPROTO_TCP);
8374 ok(sock != INVALID_SOCKET, "socket() failed\n");
8375
8376 memset(&bindAddress, 0, sizeof(bindAddress));
8377 bindAddress.sin_family = AF_INET;
8378 bindAddress.sin_addr.s_addr = net_address.s_addr;
8379 SetLastError(0xdeadbeef);
8380 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8381 ok (!ret, "bind() failed with error %d\n", GetLastError());
8382 set_blocking(sock, FALSE);
8383
8384 memset(&overlapped, 0, sizeof(overlapped));
8385 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8386 SetLastError(0xdeadbeef);
8387 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
8388 error = GetLastError();
8389 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error);
8390 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%x\n", error);
8391
8392 CloseHandle(overlapped.hEvent);
8393 closesocket(sock);
8394
8395 sock = socket(AF_INET, 0, IPPROTO_TCP);
8396 ok(sock != INVALID_SOCKET, "socket() failed\n");
8397
8398 SetLastError(0xdeadbeef);
8399 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8400 ok (!ret, "bind() failed with error %d\n", GetLastError());
8401 set_blocking(sock, TRUE);
8402
8403 memset(&overlapped, 0, sizeof(overlapped));
8404 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8405 SetLastError(0xdeadbeef);
8406 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
8407 error = GetLastError();
8408 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error);
8409 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%x\n", error);
8410
8411 CloseHandle(overlapped.hEvent);
8412 closesocket(sock);
8413
8414 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
8415 ok(sock != INVALID_SOCKET, "socket() failed\n");
8416
8417 SetLastError(0xdeadbeef);
8418 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8419 ok (!ret, "bind() failed with error %d\n", GetLastError());
8420 set_blocking(sock, FALSE);
8421
8422 memset(&overlapped, 0, sizeof(overlapped));
8423 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8424 SetLastError(0xdeadbeef);
8425 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
8426 error = GetLastError();
8427 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error);
8428 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%x\n", error);
8429
8430 CloseHandle(overlapped.hEvent);
8431 closesocket(sock);
8432
8433 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
8434 ok(sock != INVALID_SOCKET, "socket() failed\n");
8435
8436 SetLastError(0xdeadbeef);
8437 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8438 ok (!ret, "bind() failed with error %d\n", GetLastError());
8439 set_blocking(sock, TRUE);
8440
8441 memset(&overlapped, 0, sizeof(overlapped));
8442 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8443 SetLastError(0xdeadbeef);
8444 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
8445 error = GetLastError();
8446 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error);
8447 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%x\n", error);
8448
8449 CloseHandle(overlapped.hEvent);
8450 closesocket(sock);
8451
8452 /* When the socket is overlapped non-blocking and the list change is requested without
8453 * an overlapped structure the error will be different. */
8454 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
8455 ok(sock != INVALID_SOCKET, "socket() failed\n");
8456
8457 SetLastError(0xdeadbeef);
8458 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8459 ok (!ret, "bind() failed with error %d\n", GetLastError());
8460 set_blocking(sock, FALSE);
8461
8462 SetLastError(0xdeadbeef);
8463 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
8464 error = GetLastError();
8465 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error);
8466 ok (error == WSAEWOULDBLOCK, "expected 10035, got %d\n", error);
8467
8468 io_port = CreateIoCompletionPort( (HANDLE)sock, NULL, 0, 0 );
8469 ok (io_port != NULL, "failed to create completion port %u\n", GetLastError());
8470
8471 set_blocking(sock, FALSE);
8472 memset(&overlapped, 0, sizeof(overlapped));
8473 SetLastError(0xdeadbeef);
8474 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
8475 error = GetLastError();
8476 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %u\n", error);
8477 ok (error == ERROR_IO_PENDING, "expected ERROR_IO_PENDING got %u\n", error);
8478
8479 olp = (WSAOVERLAPPED *)0xdeadbeef;
8480 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 0 );
8481 ok(!bret, "failed to get completion status %u\n", bret);
8482 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8483 ok(!olp, "Overlapped structure is at %p\n", olp);
8484
8485 closesocket(sock);
8486
8487 olp = (WSAOVERLAPPED *)0xdeadbeef;
8488 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 0 );
8489 ok(!bret, "failed to get completion status %u\n", bret);
8490 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %u\n", GetLastError());
8491 ok(olp == &overlapped, "Overlapped structure is at %p\n", olp);
8492
8493 CloseHandle(io_port);
8494
8495 /* Misuse of the API by using a blocking socket and not using an overlapped structure,
8496 * this leads to a hang forever. */
8497 if (0)
8498 {
8499 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
8500
8501 SetLastError(0xdeadbeef);
8502 bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8503
8504 set_blocking(sock, TRUE);
8505 WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
8506 /* hang */
8507
8508 closesocket(sock);
8509 }
8510
8511 if (!winetest_interactive)
8512 {
8513 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
8514 return;
8515 }
8516
8517 /* Bind an overlapped socket to the first found network interface */
8518 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
8519 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
8520 sock2 = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
8521 ok(sock2 != INVALID_SOCKET, "Expected socket to return a valid socket\n");
8522 sock3 = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
8523 ok(sock3 != INVALID_SOCKET, "Expected socket to return a valid socket\n");
8524
8525 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8526 ok(!ret, "bind failed unexpectedly\n");
8527 ret = bind(sock2, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8528 ok(!ret, "bind failed unexpectedly\n");
8529 ret = bind(sock3, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8530 ok(!ret, "bind failed unexpectedly\n");
8531
8532 set_blocking(sock2, FALSE);
8533 set_blocking(sock3, FALSE);
8534
8535 /* Wait for address changes, request that the user connects/disconnects an interface */
8536 memset(&overlapped, 0, sizeof(overlapped));
8537 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8538 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
8539 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
8540 ok(WSAGetLastError() == WSA_IO_PENDING, "Expected pending last error, got %d\n", WSAGetLastError());
8541
8542 ret = WSAIoctl(sock2, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
8543 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
8544 ok(WSAGetLastError() == WSAEWOULDBLOCK, "Expected would block last error, got %d\n", WSAGetLastError());
8545
8546 event2 = WSACreateEvent();
8547 event3 = WSACreateEvent();
8548 ret = WSAEventSelect (sock2, event2, FD_ADDRESS_LIST_CHANGE);
8549 ok(!ret, "WSAEventSelect failed with %d\n", WSAGetLastError());
8550 /* sock3 did not request SIO_ADDRESS_LIST_CHANGE but it is trying to wait anyway */
8551 ret = WSAEventSelect (sock3, event3, FD_ADDRESS_LIST_CHANGE);
8552 ok(!ret, "WSAEventSelect failed with %d\n", WSAGetLastError());
8553
8554 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
8555 " change the ipv4 address of any of the local network interfaces (15 second timeout).\n");
8556 tick = GetTickCount();
8557 ret = WaitForSingleObject(overlapped.hEvent, 15000);
8558 ok(ret == WAIT_OBJECT_0, "failed to get overlapped event %u\n", ret);
8559
8560 ret = WaitForSingleObject(event2, 500);
8561 todo_wine
8562 ok(ret == WAIT_OBJECT_0, "failed to get change event %u\n", ret);
8563
8564 ret = WaitForSingleObject(event3, 500);
8565 ok(ret == WAIT_TIMEOUT, "unexpected change event\n");
8566
8567 trace("Spent %d ms waiting.\n", GetTickCount() - tick);
8568
8569 WSACloseEvent(event2);
8570 WSACloseEvent(event3);
8571
8572 closesocket(sock);
8573 closesocket(sock2);
8574 closesocket(sock3);
8575 }
8576
8577 /*
8578 * Provide consistent initialization for the AcceptEx IOCP tests.
8579 */
8580 static SOCKET setup_iocp_src(struct sockaddr_in *bindAddress)
8581 {
8582 SOCKET src;
8583 int iret, socklen;
8584
8585 src = socket(AF_INET, SOCK_STREAM, 0);
8586 ok(src != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8587
8588 memset(bindAddress, 0, sizeof(*bindAddress));
8589 bindAddress->sin_family = AF_INET;
8590 bindAddress->sin_addr.s_addr = inet_addr("127.0.0.1");
8591 iret = bind(src, (struct sockaddr*)bindAddress, sizeof(*bindAddress));
8592 ok(!iret, "failed to bind, error %u\n", WSAGetLastError());
8593
8594 socklen = sizeof(*bindAddress);
8595 iret = getsockname(src, (struct sockaddr*)bindAddress, &socklen);
8596 ok(!iret, "failed to get address, error %u\n", WSAGetLastError());
8597
8598 iret = set_blocking(src, FALSE);
8599 ok(!iret, "failed to make socket non-blocking, error %u\n", WSAGetLastError());
8600
8601 iret = listen(src, 5);
8602 ok(!iret, "failed to listen, error %u\n", WSAGetLastError());
8603
8604 return src;
8605 }
8606
8607 static void test_completion_port(void)
8608 {
8609 HANDLE io_port;
8610 WSAOVERLAPPED ov, *olp;
8611 SOCKET src, dest, dup, connector = INVALID_SOCKET;
8612 WSAPROTOCOL_INFOA info;
8613 char buf[1024];
8614 WSABUF bufs;
8615 DWORD num_bytes, flags;
8616 struct linger ling;
8617 int iret;
8618 BOOL bret;
8619 ULONG_PTR key;
8620 struct sockaddr_in bindAddress;
8621 GUID acceptExGuid = WSAID_ACCEPTEX;
8622 LPFN_ACCEPTEX pAcceptEx = NULL;
8623 fd_set fds_recv;
8624
8625 memset(buf, 0, sizeof(buf));
8626 io_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
8627 ok( io_port != NULL, "Failed to create completion port %u\n", GetLastError());
8628
8629 memset(&ov, 0, sizeof(ov));
8630
8631 tcp_socketpair(&src, &dest);
8632
8633 bufs.len = sizeof(buf);
8634 bufs.buf = buf;
8635 flags = 0;
8636
8637 ling.l_onoff = 1;
8638 ling.l_linger = 0;
8639 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
8640 ok(!iret, "Failed to set linger %d\n", GetLastError());
8641
8642 io_port = CreateIoCompletionPort( (HANDLE)dest, io_port, 125, 0 );
8643 ok(io_port != NULL, "Failed to create completion port %u\n", GetLastError());
8644
8645 SetLastError(0xdeadbeef);
8646
8647 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
8648 ok(iret == SOCKET_ERROR, "WSARecv returned %d\n", iret);
8649 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8650
8651 Sleep(100);
8652
8653 closesocket(src);
8654 src = INVALID_SOCKET;
8655
8656 SetLastError(0xdeadbeef);
8657 key = 0xdeadbeef;
8658 num_bytes = 0xdeadbeef;
8659 olp = (WSAOVERLAPPED *)0xdeadbeef;
8660
8661 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8662 todo_wine ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret);
8663 todo_wine ok(GetLastError() == ERROR_NETNAME_DELETED, "Last error was %d\n", GetLastError());
8664 ok(key == 125, "Key is %lu\n", key);
8665 ok(num_bytes == 0, "Number of bytes received is %u\n", num_bytes);
8666 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8667
8668 SetLastError(0xdeadbeef);
8669 key = 0xdeadbeef;
8670 num_bytes = 0xdeadbeef;
8671 olp = (WSAOVERLAPPED *)0xdeadbeef;
8672
8673 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8674 ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret );
8675 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8676 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8677 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8678 ok(!olp, "Overlapped structure is at %p\n", olp);
8679
8680 if (dest != INVALID_SOCKET)
8681 closesocket(dest);
8682
8683 memset(&ov, 0, sizeof(ov));
8684
8685 tcp_socketpair(&src, &dest);
8686
8687 bufs.len = sizeof(buf);
8688 bufs.buf = buf;
8689 flags = 0;
8690
8691 ling.l_onoff = 1;
8692 ling.l_linger = 0;
8693 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
8694 ok(!iret, "Failed to set linger %d\n", GetLastError());
8695
8696 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
8697 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8698
8699 set_blocking(dest, FALSE);
8700
8701 closesocket(src);
8702 src = INVALID_SOCKET;
8703
8704 Sleep(100);
8705
8706 num_bytes = 0xdeadbeef;
8707 SetLastError(0xdeadbeef);
8708
8709 iret = WSASend(dest, &bufs, 1, &num_bytes, 0, &ov, NULL);
8710 ok(iret == SOCKET_ERROR, "WSASend failed - %d\n", iret);
8711 ok(GetLastError() == WSAECONNRESET, "Last error was %d\n", GetLastError());
8712 ok(num_bytes == 0xdeadbeef, "Managed to send %d\n", num_bytes);
8713
8714 SetLastError(0xdeadbeef);
8715 key = 0xdeadbeef;
8716 num_bytes = 0xdeadbeef;
8717 olp = (WSAOVERLAPPED *)0xdeadbeef;
8718
8719 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8720 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
8721 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8722 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8723 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8724 ok(!olp, "Overlapped structure is at %p\n", olp);
8725
8726 if (dest != INVALID_SOCKET)
8727 closesocket(dest);
8728
8729 /* Test IOCP response on successful immediate read. */
8730 tcp_socketpair(&src, &dest);
8731
8732 bufs.len = sizeof(buf);
8733 bufs.buf = buf;
8734 flags = 0;
8735 SetLastError(0xdeadbeef);
8736
8737 iret = WSASend(src, &bufs, 1, &num_bytes, 0, &ov, NULL);
8738 ok(!iret, "WSASend failed - %d, last error %u\n", iret, GetLastError());
8739 ok(num_bytes == sizeof(buf), "Managed to send %d\n", num_bytes);
8740
8741 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
8742 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8743 set_blocking(dest, FALSE);
8744
8745 FD_ZERO(&fds_recv);
8746 FD_SET(dest, &fds_recv);
8747 select(dest + 1, &fds_recv, NULL, NULL, NULL);
8748
8749 num_bytes = 0xdeadbeef;
8750 flags = 0;
8751
8752 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
8753 ok(!iret, "WSARecv failed - %d, last error %u\n", iret, GetLastError());
8754 ok(num_bytes == sizeof(buf), "Managed to read %d\n", num_bytes);
8755
8756 SetLastError(0xdeadbeef);
8757 key = 0xdeadbeef;
8758 num_bytes = 0xdeadbeef;
8759 olp = (WSAOVERLAPPED *)0xdeadbeef;
8760
8761 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8762 ok(bret == TRUE, "failed to get completion status %u\n", bret);
8763 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
8764 ok(key == 125, "Key is %lu\n", key);
8765 ok(num_bytes == sizeof(buf), "Number of bytes transferred is %u\n", num_bytes);
8766 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8767
8768 /* Test IOCP response on graceful shutdown. */
8769 closesocket(src);
8770
8771 FD_ZERO(&fds_recv);
8772 FD_SET(dest, &fds_recv);
8773 select(dest + 1, &fds_recv, NULL, NULL, NULL);
8774
8775 num_bytes = 0xdeadbeef;
8776 flags = 0;
8777 memset(&ov, 0, sizeof(ov));
8778
8779 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
8780 ok(!iret, "WSARecv failed - %d, last error %u\n", iret, GetLastError());
8781 ok(!num_bytes, "Managed to read %d\n", num_bytes);
8782
8783 SetLastError(0xdeadbeef);
8784 key = 0xdeadbeef;
8785 num_bytes = 0xdeadbeef;
8786 olp = (WSAOVERLAPPED *)0xdeadbeef;
8787
8788 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8789 ok(bret == TRUE, "failed to get completion status %u\n", bret);
8790 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
8791 ok(key == 125, "Key is %lu\n", key);
8792 ok(!num_bytes, "Number of bytes transferred is %u\n", num_bytes);
8793 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8794
8795 closesocket(src);
8796 src = INVALID_SOCKET;
8797 closesocket(dest);
8798 dest = INVALID_SOCKET;
8799
8800 /* Test IOCP response on hard shutdown. This was the condition that triggered
8801 * a crash in an actual app (bug 38980). */
8802 tcp_socketpair(&src, &dest);
8803
8804 bufs.len = sizeof(buf);
8805 bufs.buf = buf;
8806 flags = 0;
8807 memset(&ov, 0, sizeof(ov));
8808
8809 ling.l_onoff = 1;
8810 ling.l_linger = 0;
8811 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
8812 ok(!iret, "Failed to set linger %d\n", GetLastError());
8813
8814 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
8815 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8816 set_blocking(dest, FALSE);
8817
8818 closesocket(src);
8819 src = INVALID_SOCKET;
8820
8821 FD_ZERO(&fds_recv);
8822 FD_SET(dest, &fds_recv);
8823 select(dest + 1, &fds_recv, NULL, NULL, NULL);
8824
8825 num_bytes = 0xdeadbeef;
8826 SetLastError(0xdeadbeef);
8827
8828 /* Somehow a hard shutdown doesn't work on my Linux box. It seems SO_LINGER is ignored. */
8829 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
8830 todo_wine ok(iret == SOCKET_ERROR, "WSARecv failed - %d\n", iret);
8831 todo_wine ok(GetLastError() == WSAECONNRESET, "Last error was %d\n", GetLastError());
8832 todo_wine ok(num_bytes == 0xdeadbeef, "Managed to read %d\n", num_bytes);
8833
8834 SetLastError(0xdeadbeef);
8835 key = 0xdeadbeef;
8836 num_bytes = 0xdeadbeef;
8837 olp = (WSAOVERLAPPED *)0xdeadbeef;
8838
8839 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8840 todo_wine ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
8841 todo_wine ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8842 todo_wine ok(key == 0xdeadbeef, "Key is %lu\n", key);
8843 todo_wine ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8844 todo_wine ok(!olp, "Overlapped structure is at %p\n", olp);
8845
8846 closesocket(dest);
8847
8848 /* Test reading from a non-connected socket, mostly because the above test is marked todo. */
8849 dest = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8850 ok(dest != INVALID_SOCKET, "socket() failed\n");
8851
8852 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 125, 0);
8853 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8854 set_blocking(dest, FALSE);
8855
8856 num_bytes = 0xdeadbeef;
8857 SetLastError(0xdeadbeef);
8858 memset(&ov, 0, sizeof(ov));
8859
8860 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
8861 ok(iret == SOCKET_ERROR, "WSARecv failed - %d\n", iret);
8862 ok(GetLastError() == WSAENOTCONN, "Last error was %d\n", GetLastError());
8863 ok(num_bytes == 0xdeadbeef, "Managed to read %d\n", num_bytes);
8864
8865 SetLastError(0xdeadbeef);
8866 key = 0xdeadbeef;
8867 num_bytes = 0xdeadbeef;
8868 olp = (WSAOVERLAPPED *)0xdeadbeef;
8869
8870 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8871 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
8872 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8873 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8874 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8875 ok(!olp, "Overlapped structure is at %p\n", olp);
8876
8877 num_bytes = 0xdeadbeef;
8878 closesocket(dest);
8879
8880 dest = socket(AF_INET, SOCK_STREAM, 0);
8881 ok(dest != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
8882
8883 iret = WSAIoctl(dest, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
8884 &pAcceptEx, sizeof(pAcceptEx), &num_bytes, NULL, NULL);
8885 ok(!iret, "failed to get AcceptEx, error %u\n", WSAGetLastError());
8886
8887 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
8888
8889 src = setup_iocp_src(&bindAddress);
8890
8891 SetLastError(0xdeadbeef);
8892
8893 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8894 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8895 &num_bytes, &ov);
8896 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8897 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8898
8899 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
8900 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8901
8902 closesocket(src);
8903 src = INVALID_SOCKET;
8904
8905 SetLastError(0xdeadbeef);
8906 key = 0xdeadbeef;
8907 num_bytes = 0xdeadbeef;
8908 olp = (WSAOVERLAPPED *)0xdeadbeef;
8909
8910 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8911 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8912 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
8913 ok(key == 125, "Key is %lu\n", key);
8914 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8915 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8916 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
8917
8918 SetLastError(0xdeadbeef);
8919 key = 0xdeadbeef;
8920 num_bytes = 0xdeadbeef;
8921 olp = (WSAOVERLAPPED *)0xdeadbeef;
8922 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8923 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8924 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8925 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8926 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8927 ok(!olp, "Overlapped structure is at %p\n", olp);
8928
8929 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
8930
8931 src = setup_iocp_src(&bindAddress);
8932
8933 SetLastError(0xdeadbeef);
8934
8935 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
8936 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8937
8938 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8939 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8940 &num_bytes, &ov);
8941 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8942 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8943
8944 closesocket(src);
8945 src = INVALID_SOCKET;
8946
8947 SetLastError(0xdeadbeef);
8948 key = 0xdeadbeef;
8949 num_bytes = 0xdeadbeef;
8950 olp = (WSAOVERLAPPED *)0xdeadbeef;
8951
8952 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8953 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8954 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
8955 ok(key == 125, "Key is %lu\n", key);
8956 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8957 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8958 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
8959
8960 SetLastError(0xdeadbeef);
8961 key = 0xdeadbeef;
8962 num_bytes = 0xdeadbeef;
8963 olp = (WSAOVERLAPPED *)0xdeadbeef;
8964 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8965 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8966 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8967 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8968 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8969 ok(!olp, "Overlapped structure is at %p\n", olp);
8970
8971 /* Test IOCP with duplicated handle */
8972
8973 src = setup_iocp_src(&bindAddress);
8974
8975 SetLastError(0xdeadbeef);
8976
8977 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
8978 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8979
8980 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
8981 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
8982 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
8983
8984 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8985 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8986 &num_bytes, &ov);
8987 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8988 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8989
8990 SetLastError(0xdeadbeef);
8991 key = 0xdeadbeef;
8992 num_bytes = 0xdeadbeef;
8993 olp = (WSAOVERLAPPED *)0xdeadbeef;
8994 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8995 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8996 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8997 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8998 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8999 ok(!olp, "Overlapped structure is at %p\n", olp);
9000
9001 closesocket(src);
9002 src = INVALID_SOCKET;
9003 closesocket(dup);
9004 dup = INVALID_SOCKET;
9005
9006 SetLastError(0xdeadbeef);
9007 key = 0xdeadbeef;
9008 num_bytes = 0xdeadbeef;
9009 olp = (WSAOVERLAPPED *)0xdeadbeef;
9010 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
9011 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9012 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
9013 ok(key == 125, "Key is %lu\n", key);
9014 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
9015 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
9016 ok(olp && olp->Internal == (ULONG)STATUS_CANCELLED, "Internal status is %lx\n", olp ? olp->Internal : 0);
9017
9018 SetLastError(0xdeadbeef);
9019 key = 0xdeadbeef;
9020 num_bytes = 0xdeadbeef;
9021 olp = (WSAOVERLAPPED *)0xdeadbeef;
9022 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9023 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9024 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9025 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9026 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9027 ok(!olp, "Overlapped structure is at %p\n", olp);
9028
9029 /* Test IOCP with duplicated handle (closing duplicated handle) */
9030
9031 src = setup_iocp_src(&bindAddress);
9032
9033 SetLastError(0xdeadbeef);
9034
9035 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
9036 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9037
9038 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
9039 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
9040 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
9041
9042 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
9043 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9044 &num_bytes, &ov);
9045 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
9046 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
9047
9048 closesocket(dup);
9049 dup = INVALID_SOCKET;
9050
9051 SetLastError(0xdeadbeef);
9052 key = 0xdeadbeef;
9053 num_bytes = 0xdeadbeef;
9054 olp = (WSAOVERLAPPED *)0xdeadbeef;
9055 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9056 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9057 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9058 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9059 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9060 ok(!olp, "Overlapped structure is at %p\n", olp);
9061
9062 SetLastError(0xdeadbeef);
9063 key = 0xdeadbeef;
9064 num_bytes = 0xdeadbeef;
9065 olp = (WSAOVERLAPPED *)0xdeadbeef;
9066 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9067 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9068 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9069 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9070 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9071 ok(!olp, "Overlapped structure is at %p\n", olp);
9072
9073 closesocket(src);
9074 src = INVALID_SOCKET;
9075
9076 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
9077 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9078 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
9079 ok(key == 125, "Key is %lu\n", key);
9080 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
9081 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
9082 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
9083
9084 SetLastError(0xdeadbeef);
9085 key = 0xdeadbeef;
9086 num_bytes = 0xdeadbeef;
9087 olp = (WSAOVERLAPPED *)0xdeadbeef;
9088 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9089 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9090 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9091 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9092 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9093 ok(!olp, "Overlapped structure is at %p\n", olp);
9094
9095 /* Test IOCP with duplicated handle (closing original handle) */
9096
9097 src = setup_iocp_src(&bindAddress);
9098
9099 SetLastError(0xdeadbeef);
9100
9101 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
9102 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9103
9104 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
9105 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
9106 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
9107
9108 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
9109 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9110 &num_bytes, &ov);
9111 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
9112 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
9113
9114 closesocket(src);
9115 src = INVALID_SOCKET;
9116
9117 SetLastError(0xdeadbeef);
9118 key = 0xdeadbeef;
9119 num_bytes = 0xdeadbeef;
9120 olp = (WSAOVERLAPPED *)0xdeadbeef;
9121 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9122 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9123 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9124 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9125 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9126 ok(!olp, "Overlapped structure is at %p\n", olp);
9127
9128 closesocket(dup);
9129 dup = INVALID_SOCKET;
9130
9131 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
9132 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9133 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
9134 ok(key == 125, "Key is %lu\n", key);
9135 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
9136 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
9137 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
9138
9139 SetLastError(0xdeadbeef);
9140 key = 0xdeadbeef;
9141 num_bytes = 0xdeadbeef;
9142 olp = (WSAOVERLAPPED *)0xdeadbeef;
9143 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9144 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9145 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9146 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9147 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9148 ok(!olp, "Overlapped structure is at %p\n", olp);
9149
9150 /* Test IOCP without AcceptEx */
9151
9152 src = setup_iocp_src(&bindAddress);
9153
9154 SetLastError(0xdeadbeef);
9155
9156 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
9157 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9158
9159 closesocket(src);
9160 src = INVALID_SOCKET;
9161
9162 SetLastError(0xdeadbeef);
9163 key = 0xdeadbeef;
9164 num_bytes = 0xdeadbeef;
9165 olp = (WSAOVERLAPPED *)0xdeadbeef;
9166 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9167 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9168 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9169 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9170 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9171 ok(!olp, "Overlapped structure is at %p\n", olp);
9172
9173 /* */
9174
9175 src = setup_iocp_src(&bindAddress);
9176
9177 connector = socket(AF_INET, SOCK_STREAM, 0);
9178 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
9179
9180 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
9181 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9182
9183 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 236, 0);
9184 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9185
9186 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
9187 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9188 &num_bytes, &ov);
9189 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
9190 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
9191
9192 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9193 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
9194
9195 closesocket(connector);
9196 connector = INVALID_SOCKET;
9197
9198 SetLastError(0xdeadbeef);
9199 key = 0xdeadbeef;
9200 num_bytes = 0xdeadbeef;
9201 olp = (WSAOVERLAPPED *)0xdeadbeef;
9202
9203 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
9204 ok(bret == TRUE, "failed to get completion status %u\n", bret);
9205 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9206 ok(key == 125, "Key is %lu\n", key);
9207 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
9208 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
9209 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %lx\n", olp ? olp->Internal : 0);
9210
9211 SetLastError(0xdeadbeef);
9212 key = 0xdeadbeef;
9213 num_bytes = 0xdeadbeef;
9214 olp = (WSAOVERLAPPED *)0xdeadbeef;
9215 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9216 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9217 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9218 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9219 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9220 ok(!olp, "Overlapped structure is at %p\n", olp);
9221
9222 if (dest != INVALID_SOCKET)
9223 closesocket(dest);
9224 if (src != INVALID_SOCKET)
9225 closesocket(dest);
9226
9227 /* */
9228
9229 src = setup_iocp_src(&bindAddress);
9230
9231 dest = socket(AF_INET, SOCK_STREAM, 0);
9232 ok(dest != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
9233
9234 connector = socket(AF_INET, SOCK_STREAM, 0);
9235 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
9236
9237 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
9238 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9239
9240 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 236, 0);
9241 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9242
9243 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
9244 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9245 &num_bytes, &ov);
9246 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
9247 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
9248
9249 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9250 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
9251
9252 iret = send(connector, buf, 1, 0);
9253 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
9254
9255 Sleep(100);
9256
9257 closesocket(dest);
9258 dest = INVALID_SOCKET;
9259
9260 SetLastError(0xdeadbeef);
9261 key = 0xdeadbeef;
9262 num_bytes = 0xdeadbeef;
9263 olp = (WSAOVERLAPPED *)0xdeadbeef;
9264
9265 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
9266 ok(bret == TRUE, "failed to get completion status %u\n", bret);
9267 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9268 ok(key == 125, "Key is %lu\n", key);
9269 ok(num_bytes == 1, "Number of bytes transferred is %u\n", num_bytes);
9270 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
9271 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %lx\n", olp ? olp->Internal : 0);
9272
9273 SetLastError(0xdeadbeef);
9274 key = 0xdeadbeef;
9275 num_bytes = 0xdeadbeef;
9276 olp = (WSAOVERLAPPED *)0xdeadbeef;
9277 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9278 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9279 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9280 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9281 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9282 ok(!olp, "Overlapped structure is at %p\n", olp);
9283
9284 if (src != INVALID_SOCKET)
9285 closesocket(src);
9286 if (connector != INVALID_SOCKET)
9287 closesocket(connector);
9288
9289 /* */
9290
9291 src = setup_iocp_src(&bindAddress);
9292
9293 dest = socket(AF_INET, SOCK_STREAM, 0);
9294 ok(dest != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
9295
9296 connector = socket(AF_INET, SOCK_STREAM, 0);
9297 ok(connector != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
9298
9299 io_port = CreateIoCompletionPort((HANDLE)src, io_port, 125, 0);
9300 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9301
9302 io_port = CreateIoCompletionPort((HANDLE)dest, io_port, 236, 0);
9303 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9304
9305 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
9306 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9307 &num_bytes, &ov);
9308 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
9309 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
9310
9311 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9312 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
9313
9314 closesocket(dest);
9315
9316 SetLastError(0xdeadbeef);
9317 key = 0xdeadbeef;
9318 num_bytes = 0xdeadbeef;
9319 olp = (WSAOVERLAPPED *)0xdeadbeef;
9320
9321 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
9322 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9323 ok(GetLastError() == ERROR_OPERATION_ABORTED
9324 || GetLastError() == ERROR_CONNECTION_ABORTED, "got error %u\n", GetLastError());
9325 ok(key == 125, "Key is %lu\n", key);
9326 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
9327 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
9328 ok((NTSTATUS)olp->Internal == STATUS_CANCELLED
9329 || (NTSTATUS)olp->Internal == STATUS_CONNECTION_ABORTED, "got status %#lx\n", olp->Internal);
9330
9331 SetLastError(0xdeadbeef);
9332 key = 0xdeadbeef;
9333 num_bytes = 0xdeadbeef;
9334 olp = (WSAOVERLAPPED *)0xdeadbeef;
9335 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9336 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9337 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9338 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9339 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9340 ok(!olp, "Overlapped structure is at %p\n", olp);
9341
9342 closesocket(src);
9343 closesocket(connector);
9344 CloseHandle(io_port);
9345 }
9346
9347 static void test_connect_completion_port(void)
9348 {
9349 OVERLAPPED overlapped = {0}, *overlapped_ptr;
9350 GUID connectex_guid = WSAID_CONNECTEX;
9351 SOCKET connector, listener, acceptor;
9352 struct sockaddr_in addr, destaddr;
9353 LPFN_CONNECTEX pConnectEx;
9354 int ret, addrlen;
9355 ULONG_PTR key;
9356 HANDLE port;
9357 DWORD size;
9358
9359 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9360
9361 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9362 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
9363
9364 memset(&addr, 0, sizeof(addr));
9365 addr.sin_family = AF_INET;
9366 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
9367 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
9368 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9369 addrlen = sizeof(destaddr);
9370 ret = getsockname(listener, (struct sockaddr *)&destaddr, &addrlen);
9371 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
9372
9373 ret = listen(listener, 1);
9374 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
9375
9376 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9377 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
9378
9379 ret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectex_guid, sizeof(connectex_guid),
9380 &pConnectEx, sizeof(pConnectEx), &size, NULL, NULL);
9381 ok(!ret, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
9382
9383 /* connect() does not queue completion. */
9384
9385 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
9386 ok(!!port, "failed to create port, error %u\n", GetLastError());
9387
9388 ret = connect(connector, (struct sockaddr *)&destaddr, sizeof(destaddr));
9389 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9390 acceptor = accept(listener, NULL, NULL);
9391 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
9392 closesocket(acceptor);
9393
9394 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
9395 ok(!ret, "expected failure\n");
9396 ok(GetLastError() == WAIT_TIMEOUT, "got error %u\n", GetLastError());
9397
9398 closesocket(connector);
9399 CloseHandle(port);
9400
9401 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9402 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
9403 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
9404 ok(!!port, "failed to create port, error %u\n", GetLastError());
9405 set_blocking(connector, FALSE);
9406
9407 ret = connect(connector, (struct sockaddr *)&destaddr, sizeof(destaddr));
9408 ok(ret == -1, "expected failure\n");
9409 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
9410 acceptor = accept(listener, NULL, NULL);
9411 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
9412 closesocket(acceptor);
9413
9414 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
9415 ok(!ret, "expected failure\n");
9416 ok(GetLastError() == WAIT_TIMEOUT, "got error %u\n", GetLastError());
9417
9418 closesocket(connector);
9419 CloseHandle(port);
9420
9421 /* ConnectEx() queues completion. */
9422
9423 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9424 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
9425 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
9426 ok(!!port, "failed to create port, error %u\n", GetLastError());
9427 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
9428 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9429
9430 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
9431 NULL, 0, &size, &overlapped);
9432 ok(!ret, "expected failure\n");
9433 ok(GetLastError() == ERROR_IO_PENDING, "got error %u\n", GetLastError());
9434 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9435 ok(!ret, "wait failed\n");
9436 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
9437 ok(ret, "got error %u\n", GetLastError());
9438 ok(!size, "got %u bytes\n", size);
9439 acceptor = accept(listener, NULL, NULL);
9440 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
9441 closesocket(acceptor);
9442
9443 size = 0xdeadbeef;
9444 key = 0xdeadbeef;
9445 overlapped_ptr = NULL;
9446 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
9447 ok(ret, "got error %u\n", GetLastError());
9448 ok(!key, "got key %#Ix\n", key);
9449 ok(!size, "got %u bytes\n", size);
9450 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
9451
9452 closesocket(connector);
9453 CloseHandle(port);
9454
9455 /* Test ConnectEx() with a non-empty buffer. */
9456
9457 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9458 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
9459 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
9460 ok(!!port, "failed to create port, error %u\n", GetLastError());
9461 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
9462 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9463
9464 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
9465 (void *)"one", 3, &size, &overlapped);
9466 ok(!ret, "expected failure\n");
9467 ok(GetLastError() == ERROR_IO_PENDING, "got error %u\n", GetLastError());
9468 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9469 ok(!ret, "wait failed\n");
9470 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
9471 ok(ret, "got error %u\n", GetLastError());
9472 ok(size == 3, "got %u bytes\n", size);
9473 acceptor = accept(listener, NULL, NULL);
9474 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
9475 closesocket(acceptor);
9476
9477 size = 0xdeadbeef;
9478 key = 0xdeadbeef;
9479 overlapped_ptr = NULL;
9480 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
9481 ok(ret, "got error %u\n", GetLastError());
9482 ok(!key, "got key %#Ix\n", key);
9483 ok(size == 3, "got %u bytes\n", size);
9484 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
9485
9486 closesocket(connector);
9487 CloseHandle(port);
9488
9489 /* Suppress completion by setting the low bit. */
9490
9491 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9492 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
9493 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
9494 ok(!!port, "failed to create port, error %u\n", GetLastError());
9495 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
9496 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9497
9498 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent | 1);
9499
9500 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
9501 NULL, 0, &size, &overlapped);
9502 ok(!ret, "expected failure\n");
9503 ok(GetLastError() == ERROR_IO_PENDING, "got error %u\n", GetLastError());
9504 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9505 ok(!ret, "wait failed\n");
9506 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
9507 ok(ret, "got error %u\n", GetLastError());
9508 ok(!size, "got %u bytes\n", size);
9509 acceptor = accept(listener, NULL, NULL);
9510 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
9511 closesocket(acceptor);
9512
9513 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
9514 ok(!ret, "expected failure\n");
9515 ok(GetLastError() == WAIT_TIMEOUT, "got error %u\n", GetLastError());
9516
9517 closesocket(connector);
9518 CloseHandle(port);
9519
9520 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent & ~1);
9521
9522 /* Skip completion on success. */
9523
9524 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9525 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
9526 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
9527 ok(!!port, "failed to create port, error %u\n", GetLastError());
9528 ret = SetFileCompletionNotificationModes((HANDLE)connector, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS);
9529 ok(ret, "got error %u\n", GetLastError());
9530 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
9531 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9532
9533 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
9534 NULL, 0, &size, &overlapped);
9535 ok(!ret, "expected failure\n");
9536 ok(GetLastError() == ERROR_IO_PENDING, "got error %u\n", GetLastError());
9537 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9538 ok(!ret, "wait failed\n");
9539 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
9540 ok(ret, "got error %u\n", GetLastError());
9541 ok(!size, "got %u bytes\n", size);
9542 acceptor = accept(listener, NULL, NULL);
9543 ok(acceptor != -1, "failed to accept, error %u\n", WSAGetLastError());
9544 closesocket(acceptor);
9545
9546 size = 0xdeadbeef;
9547 key = 0xdeadbeef;
9548 overlapped_ptr = NULL;
9549 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
9550 ok(ret, "got error %u\n", GetLastError());
9551 ok(!key, "got key %#Ix\n", key);
9552 ok(!size, "got %u bytes\n", size);
9553 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
9554
9555 closesocket(connector);
9556 CloseHandle(port);
9557
9558 closesocket(listener);
9559
9560 /* Connect to an invalid address. */
9561
9562 connector = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9563 ok(connector != -1, "failed to create socket, error %u\n", WSAGetLastError());
9564 port = CreateIoCompletionPort((HANDLE)connector, NULL, 0, 0);
9565 ok(!!port, "failed to create port, error %u\n", GetLastError());
9566 ret = SetFileCompletionNotificationModes((HANDLE)connector, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS);
9567 ok(ret, "got error %u\n", GetLastError());
9568 ret = bind(connector, (struct sockaddr *)&addr, sizeof(addr));
9569 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9570
9571 ret = pConnectEx(connector, (struct sockaddr *)&destaddr, sizeof(destaddr),
9572 NULL, 0, &size, &overlapped);
9573 ok(!ret, "expected failure\n");
9574 ok(GetLastError() == ERROR_IO_PENDING, "got error %u\n", GetLastError());
9575 ret = WaitForSingleObject(overlapped.hEvent, 15000);
9576 ok(!ret, "wait failed\n");
9577 ret = GetOverlappedResult((HANDLE)connector, &overlapped, &size, FALSE);
9578 ok(!ret, "expected failure\n");
9579 ok(GetLastError() == ERROR_CONNECTION_REFUSED, "got error %u\n", GetLastError());
9580 ok(!size, "got %u bytes\n", size);
9581
9582 size = 0xdeadbeef;
9583 key = 0xdeadbeef;
9584 overlapped_ptr = NULL;
9585 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
9586 ok(!ret, "expected failure\n");
9587 ok(GetLastError() == ERROR_CONNECTION_REFUSED, "got error %u\n", GetLastError());
9588 ok(!key, "got key %#Ix\n", key);
9589 ok(!size, "got %u bytes\n", size);
9590 ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
9591
9592 closesocket(connector);
9593 CloseHandle(port);
9594 }
9595
9596 static void test_shutdown_completion_port(void)
9597 {
9598 OVERLAPPED overlapped = {0}, *overlapped_ptr;
9599 GUID disconnectex_guid = WSAID_DISCONNECTEX;
9600 struct sockaddr_in addr, destaddr;
9601 LPFN_DISCONNECTEX pDisconnectEx;
9602 SOCKET listener, server, client;
9603 int ret, addrlen;
9604 ULONG_PTR key;
9605 HANDLE port;
9606 DWORD size;
9607
9608 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9609
9610 listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9611 ok(listener != -1, "failed to create socket, error %u\n", WSAGetLastError());
9612
9613 memset(&addr, 0, sizeof(addr));
9614 addr.sin_family = AF_INET;
9615 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
9616 ret = bind(listener, (struct sockaddr *)&addr, sizeof(addr));
9617 ok(!ret, "failed to bind, error %u\n", WSAGetLastError());
9618 addrlen = sizeof(destaddr);
9619 ret = getsockname(listener, (struct sockaddr *)&destaddr, &addrlen);
9620 ok(!ret, "failed to get address, error %u\n", WSAGetLastError());
9621
9622 ret = listen(listener, 1);
9623 ok(!ret, "failed to listen, error %u\n", WSAGetLastError());
9624
9625 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9626 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9627
9628 ret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &disconnectex_guid, sizeof(disconnectex_guid),
9629 &pDisconnectEx, sizeof(pDisconnectEx), &size, NULL, NULL);
9630 ok(!ret, "Failed to get ConnectEx, error %u\n", WSAGetLastError());
9631
9632 /* shutdown() does not queue completion. */
9633
9634 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
9635 ok(!!port, "failed to create port, error %u\n", GetLastError());
9636 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
9637 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9638 server = accept(listener, NULL, NULL);
9639 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9640
9641 ret = shutdown(client, SD_BOTH);
9642 ok(!ret, "failed to shutdown, error %u\n", WSAGetLastError());
9643
9644 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
9645 ok(!ret, "expected failure\n");
9646 ok(GetLastError() == WAIT_TIMEOUT, "got error %u\n", GetLastError());
9647
9648 closesocket(server);
9649 closesocket(client);
9650 CloseHandle(port);
9651
9652 /* WSASendDisconnect() and WSARecvDisconnect() do not queue completion. */
9653
9654 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9655 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9656 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
9657 ok(!!port, "failed to create port, error %u\n", GetLastError());
9658 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
9659 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9660 server = accept(listener, NULL, NULL);
9661 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9662
9663 ret = WSASendDisconnect(client, NULL);
9664 ok(!ret, "failed to shutdown, error %u\n", WSAGetLastError());
9665
9666 ret = WSARecvDisconnect(client, NULL);
9667 ok(!ret, "failed to shutdown, error %u\n", WSAGetLastError());
9668
9669 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
9670 ok(!ret, "expected failure\n");
9671 ok(GetLastError() == WAIT_TIMEOUT, "got error %u\n", GetLastError());
9672
9673 closesocket(server);
9674 closesocket(client);
9675 CloseHandle(port);
9676
9677 /* DisconnectEx() queues completion. */
9678
9679 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9680 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9681 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
9682 ok(!!port, "failed to create port, error %u\n", GetLastError());
9683 ret = SetFileCompletionNotificationModes((HANDLE)client, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS);
9684 ok(ret, "got error %u\n", GetLastError());
9685 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
9686 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9687 server = accept(listener, NULL, NULL);
9688 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9689
9690 SetLastError(0xdeadbeef);
9691 ret = pDisconnectEx(client, &overlapped, 0, 0);
9692 ok(!ret, "expected failure\n");
9693 ok(GetLastError() == ERROR_IO_PENDING, "got error %u\n", GetLastError());
9694
9695 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9696 ok(!ret, "wait failed\n");
9697
9698 size = 0xdeadbeef;
9699 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, TRUE);
9700 ok(ret, "got error %u\n", GetLastError());
9701 ok(!size, "got %u bytes\n", size);
9702
9703 size = 0xdeadbeef;
9704 key = 0xdeadbeef;
9705 overlapped_ptr = NULL;
9706 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
9707 todo_wine ok(ret, "got error %u\n", GetLastError());
9708 todo_wine ok(!key, "got key %#Ix\n", key);
9709 todo_wine ok(!size, "got %u bytes\n", size);
9710 todo_wine ok(overlapped_ptr == &overlapped, "got overlapped %p\n", overlapped_ptr);
9711
9712 closesocket(server);
9713 closesocket(client);
9714 CloseHandle(port);
9715
9716 /* Test passing a NULL overlapped structure to DisconnectEx(). */
9717
9718 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9719 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9720 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
9721 ok(!!port, "failed to create port, error %u\n", GetLastError());
9722 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
9723 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9724 server = accept(listener, NULL, NULL);
9725 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9726
9727 SetLastError(0xdeadbeef);
9728 ret = pDisconnectEx(client, NULL, 0, 0);
9729 ok(ret, "expected success\n");
9730 ok(!GetLastError() || GetLastError() == 0xdeadbeef /* < 7 */, "got error %u\n", GetLastError());
9731
9732 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
9733 ok(!ret, "expected failure\n");
9734 ok(GetLastError() == WAIT_TIMEOUT, "got error %u\n", GetLastError());
9735
9736 closesocket(server);
9737 closesocket(client);
9738 CloseHandle(port);
9739
9740 /* Suppress completion by setting the low bit. */
9741
9742 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9743 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
9744 port = CreateIoCompletionPort((HANDLE)client, NULL, 0, 0);
9745 ok(!!port, "failed to create port, error %u\n", GetLastError());
9746 ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr));
9747 ok(!ret, "failed to connect, error %u\n", WSAGetLastError());
9748 server = accept(listener, NULL, NULL);
9749 ok(server != -1, "failed to accept, error %u\n", WSAGetLastError());
9750
9751 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent | 1);
9752
9753 SetLastError(0xdeadbeef);
9754 ret = pDisconnectEx(client, &overlapped, 0, 0);
9755 ok(!ret, "expected failure\n");
9756 ok(GetLastError() == ERROR_IO_PENDING, "got error %u\n", GetLastError());
9757
9758 ret = WaitForSingleObject(overlapped.hEvent, 1000);
9759 ok(!ret, "wait failed\n");
9760
9761 size = 0xdeadbeef;
9762 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, TRUE);
9763 ok(ret, "got error %u\n", GetLastError());
9764 ok(!size, "got %u bytes\n", size);
9765
9766 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
9767 ok(!ret, "expected failure\n");
9768 ok(GetLastError() == WAIT_TIMEOUT, "got error %u\n", GetLastError());
9769
9770 closesocket(server);
9771 closesocket(client);
9772 CloseHandle(port);
9773
9774 overlapped.hEvent = (HANDLE)((ULONG_PTR)overlapped.hEvent & ~1);
9775
9776 CloseHandle(overlapped.hEvent);
9777 }
9778
9779 static void test_address_list_query(void)
9780 {
9781 char buffer[1024];
9782 SOCKET_ADDRESS_LIST *address_list = (SOCKET_ADDRESS_LIST *)buffer;
9783 OVERLAPPED overlapped = {0}, *overlapped_ptr;
9784 DWORD size, expect_size;
9785 unsigned int i;
9786 ULONG_PTR key;
9787 HANDLE port;
9788 SOCKET s;
9789 int ret;
9790
9791 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9792 ok(s != INVALID_SOCKET, "Failed to create socket, error %d.\n", WSAGetLastError());
9793 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
9794
9795 size = 0;
9796 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, 0, &size, NULL, NULL);
9797 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
9798 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
9799 ok(size >= FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), "Got unexpected size %u.\n", size);
9800 expect_size = size;
9801
9802 size = 0;
9803 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), &size, NULL, NULL);
9804 ok(!ret, "Got unexpected ret %d.\n", ret);
9805 ok(!WSAGetLastError(), "Got unexpected error %d.\n", WSAGetLastError());
9806 ok(size == expect_size, "Expected size %u, got %u.\n", expect_size, size);
9807
9808 expect_size = FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[address_list->iAddressCount]);
9809 for (i = 0; i < address_list->iAddressCount; ++i)
9810 {
9811 expect_size += address_list->Address[i].iSockaddrLength;
9812 }
9813 ok(size == expect_size, "Expected size %u, got %u.\n", expect_size, size);
9814
9815 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), NULL, NULL, NULL);
9816 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
9817 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
9818
9819 size = 0xdeadbeef;
9820 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, sizeof(buffer), &size, NULL, NULL);
9821 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
9822 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
9823 ok(size == expect_size, "Expected size %u, got %u.\n", expect_size, size);
9824
9825 size = 0xdeadbeef;
9826 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 0, &size, NULL, NULL);
9827 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
9828 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
9829 ok(size == expect_size, "Expected size %u, got %u.\n", expect_size, size);
9830
9831 size = 0xdeadbeef;
9832 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 1, &size, NULL, NULL);
9833 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
9834 ok(WSAGetLastError() == WSAEINVAL, "Got unexpected error %d.\n", WSAGetLastError());
9835 ok(!size, "Got size %u.\n", size);
9836
9837 size = 0xdeadbeef;
9838 memset(buffer, 0xcc, sizeof(buffer));
9839 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer,
9840 FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), &size, NULL, NULL);
9841 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
9842 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
9843 ok(size == expect_size, "Expected size %u, got %u.\n", expect_size, size);
9844 ok(address_list->iAddressCount == 0xcccccccc, "Got %u addresses.\n", address_list->iAddressCount);
9845
9846 WSASetLastError(0xdeadbeef);
9847 overlapped.Internal = 0xdeadbeef;
9848 overlapped.InternalHigh = 0xdeadbeef;
9849 size = 0xdeadbeef;
9850 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 0, &size, &overlapped, NULL);
9851 ok(ret == -1, "Got unexpected ret %d.\n", ret);
9852 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
9853 ok(size == expect_size, "Expected size %u, got %u.\n", expect_size, size);
9854 ok(overlapped.Internal == 0xdeadbeef, "Got status %#x.\n", (NTSTATUS)overlapped.Internal);
9855 ok(overlapped.InternalHigh == 0xdeadbeef, "Got size %Iu.\n", overlapped.InternalHigh);
9856
9857 overlapped.Internal = 0xdeadbeef;
9858 overlapped.InternalHigh = 0xdeadbeef;
9859 size = 0xdeadbeef;
9860 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, 1, &size, &overlapped, NULL);
9861 ok(ret == -1, "Got unexpected ret %d.\n", ret);
9862 ok(WSAGetLastError() == WSAEINVAL, "Got unexpected error %d.\n", WSAGetLastError());
9863 ok(!size, "Expected size %u, got %u.\n", expect_size, size);
9864 ok(overlapped.Internal == 0xdeadbeef, "Got status %#x.\n", (NTSTATUS)overlapped.Internal);
9865 ok(overlapped.InternalHigh == 0xdeadbeef, "Got size %Iu.\n", overlapped.InternalHigh);
9866
9867 overlapped.Internal = 0xdeadbeef;
9868 overlapped.InternalHigh = 0xdeadbeef;
9869 size = 0xdeadbeef;
9870 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer,
9871 FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), &size, &overlapped, NULL);
9872 ok(ret == -1, "Got unexpected ret %d.\n", ret);
9873 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
9874 ok(size == expect_size, "Expected size %u, got %u.\n", expect_size, size);
9875 ok(overlapped.Internal == 0xdeadbeef, "Got status %#x.\n", (NTSTATUS)overlapped.Internal);
9876 ok(overlapped.InternalHigh == 0xdeadbeef, "Got size %Iu.\n", overlapped.InternalHigh);
9877 ok(address_list->iAddressCount == 0xcccccccc, "Got %u addresses.\n", address_list->iAddressCount);
9878
9879 overlapped.Internal = 0xdeadbeef;
9880 overlapped.InternalHigh = 0xdeadbeef;
9881 size = 0xdeadbeef;
9882 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), &size, &overlapped, NULL);
9883 ok(!ret, "Got unexpected ret %d.\n", ret);
9884 ok(!WSAGetLastError(), "Got unexpected error %d.\n", WSAGetLastError());
9885 ok(size == expect_size, "Expected size %u, got %u.\n", expect_size, size);
9886
9887 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
9888 ok(ret, "Got error %u.\n", GetLastError());
9889 ok(!size, "Got size %u.\n", size);
9890 ok(overlapped_ptr == &overlapped, "Got overlapped %p.\n", overlapped_ptr);
9891 ok(!overlapped.Internal, "Got status %#x.\n", (NTSTATUS)overlapped.Internal);
9892 ok(!overlapped.InternalHigh, "Got size %Iu.\n", overlapped.InternalHigh);
9893
9894 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 0);
9895 ok(!ret, "Expected failure.\n");
9896 ok(GetLastError() == WAIT_TIMEOUT, "Got error %u.\n", GetLastError());
9897
9898 closesocket(s);
9899 CloseHandle(port);
9900
9901 /* Test with an APC. */
9902
9903 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9904
9905 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), NULL, &overlapped, socket_apc);
9906 ok(ret == -1, "expected failure\n");
9907 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
9908
9909 apc_count = 0;
9910 size = 0xdeadbeef;
9911 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, buffer, sizeof(buffer), &size, &overlapped, socket_apc);
9912 ok(!ret, "expected success\n");
9913 ok(size == expect_size, "got size %u\n", size);
9914
9915 ret = SleepEx(0, TRUE);
9916 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
9917 ok(apc_count == 1, "APC was called %u times\n", apc_count);
9918 ok(!apc_error, "got APC error %u\n", apc_error);
9919 ok(!apc_size, "got APC size %u\n", apc_size);
9920 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
9921
9922 closesocket(s);
9923 }
9924
9925 static void sync_read(SOCKET src, SOCKET dst)
9926 {
9927 int ret;
9928 char data[512];
9929
9930 ret = send(dst, "Hello World!", 12, 0);
9931 ok(ret == 12, "send returned %d\n", ret);
9932
9933 memset(data, 0, sizeof(data));
9934 ret = recv(src, data, sizeof(data), 0);
9935 ok(ret == 12, "expected 12, got %d\n", ret);
9936 ok(!memcmp(data, "Hello World!", 12), "got %u bytes (%*s)\n", ret, ret, data);
9937 }
9938
9939 static void iocp_async_read(SOCKET src, SOCKET dst)
9940 {
9941 HANDLE port;
9942 WSAOVERLAPPED ovl, *ovl_iocp;
9943 WSABUF buf;
9944 int ret;
9945 char data[512];
9946 DWORD flags, bytes;
9947 ULONG_PTR key;
9948
9949 memset(data, 0, sizeof(data));
9950 memset(&ovl, 0, sizeof(ovl));
9951
9952 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
9953 ok(port != 0, "CreateIoCompletionPort error %u\n", GetLastError());
9954
9955 buf.len = sizeof(data);
9956 buf.buf = data;
9957 bytes = 0xdeadbeef;
9958 flags = 0;
9959 SetLastError(0xdeadbeef);
9960 ret = WSARecv(src, &buf, 1, &bytes, &flags, &ovl, NULL);
9961 ok(ret == SOCKET_ERROR, "got %d\n", ret);
9962 ok(GetLastError() == ERROR_IO_PENDING, "got %u\n", GetLastError());
9963 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
9964
9965 bytes = 0xdeadbeef;
9966 key = 0xdeadbeef;
9967 ovl_iocp = (void *)0xdeadbeef;
9968 SetLastError(0xdeadbeef);
9969 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
9970 ok(!ret, "got %d\n", ret);
9971 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
9972 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
9973 ok(key == 0xdeadbeef, "got key %#lx\n", key);
9974 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
9975
9976 ret = send(dst, "Hello World!", 12, 0);
9977 ok(ret == 12, "send returned %d\n", ret);
9978
9979 bytes = 0xdeadbeef;
9980 key = 0xdeadbeef;
9981 ovl_iocp = NULL;
9982 SetLastError(0xdeadbeef);
9983 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
9984 ok(ret, "got %d\n", ret);
9985 ok(bytes == 12, "got bytes %u\n", bytes);
9986 ok(key == 0x12345678, "got key %#lx\n", key);
9987 ok(ovl_iocp == &ovl, "got ovl %p\n", ovl_iocp);
9988 if (ovl_iocp)
9989 {
9990 ok(ovl_iocp->InternalHigh == 12, "got %#lx\n", ovl_iocp->InternalHigh);
9991 ok(!ovl_iocp->Internal , "got %#lx\n", ovl_iocp->Internal);
9992 ok(!memcmp(data, "Hello World!", 12), "got %u bytes (%*s)\n", bytes, bytes, data);
9993 }
9994
9995 bytes = 0xdeadbeef;
9996 key = 0xdeadbeef;
9997 ovl_iocp = (void *)0xdeadbeef;
9998 SetLastError(0xdeadbeef);
9999 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
10000 ok(!ret, "got %d\n", ret);
10001 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
10002 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
10003 ok(key == 0xdeadbeef, "got key %#lx\n", key);
10004 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
10005
10006 CloseHandle(port);
10007 }
10008
10009 static void iocp_async_read_closesocket(SOCKET src, int how_to_close)
10010 {
10011 HANDLE port;
10012 WSAOVERLAPPED ovl, *ovl_iocp;
10013 WSABUF buf;
10014 int ret;
10015 char data[512];
10016 DWORD flags, bytes;
10017 ULONG_PTR key;
10018 HWND hwnd;
10019 MSG msg;
10020
10021 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
10022 0, 0, 0, 0, NULL, NULL, 0, NULL);
10023 ok(hwnd != 0, "CreateWindowEx failed\n");
10024
10025 ret = WSAAsyncSelect(src, hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
10026 ok(!ret, "got %d\n", ret);
10027
10028 Sleep(100);
10029 memset(&msg, 0, sizeof(msg));
10030 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10031 ok(ret, "got %d\n", ret);
10032 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
10033 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
10034 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
10035 ok(msg.lParam == 2, "got %08lx\n", msg.lParam);
10036
10037 memset(data, 0, sizeof(data));
10038 memset(&ovl, 0, sizeof(ovl));
10039
10040 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
10041 ok(port != 0, "CreateIoCompletionPort error %u\n", GetLastError());
10042
10043 Sleep(100);
10044 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10045 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
10046
10047 buf.len = sizeof(data);
10048 buf.buf = data;
10049 bytes = 0xdeadbeef;
10050 flags = 0;
10051 SetLastError(0xdeadbeef);
10052 ret = WSARecv(src, &buf, 1, &bytes, &flags, &ovl, NULL);
10053 ok(ret == SOCKET_ERROR, "got %d\n", ret);
10054 ok(GetLastError() == ERROR_IO_PENDING, "got %u\n", GetLastError());
10055 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
10056
10057 Sleep(100);
10058 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10059 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
10060
10061 bytes = 0xdeadbeef;
10062 key = 0xdeadbeef;
10063 ovl_iocp = (void *)0xdeadbeef;
10064 SetLastError(0xdeadbeef);
10065 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
10066 ok(!ret, "got %d\n", ret);
10067 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
10068 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
10069 ok(key == 0xdeadbeef, "got key %#lx\n", key);
10070 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
10071
10072 Sleep(100);
10073 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10074 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
10075
10076 switch (how_to_close)
10077 {
10078 case 0:
10079 closesocket(src);
10080 break;
10081 case 1:
10082 CloseHandle((HANDLE)src);
10083 break;
10084 case 2:
10085 pNtClose((HANDLE)src);
10086 break;
10087 default:
10088 ok(0, "wrong value %d\n", how_to_close);
10089 break;
10090 }
10091
10092 Sleep(200);
10093 memset(&msg, 0, sizeof(msg));
10094 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10095 switch (how_to_close)
10096 {
10097 case 0:
10098 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
10099 break;
10100 case 1:
10101 case 2:
10102 todo_wine
10103 {
10104 ok(ret, "got %d\n", ret);
10105 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
10106 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
10107 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
10108 ok(msg.lParam == 0x20, "got %08lx\n", msg.lParam);
10109 }
10110 break;
10111 default:
10112 ok(0, "wrong value %d\n", how_to_close);
10113 break;
10114 }
10115
10116 bytes = 0xdeadbeef;
10117 key = 0xdeadbeef;
10118 ovl_iocp = NULL;
10119 SetLastError(0xdeadbeef);
10120 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
10121 ok(!ret, "got %d\n", ret);
10122 todo_wine
10123 ok(GetLastError() == ERROR_CONNECTION_ABORTED || GetLastError() == ERROR_NETNAME_DELETED /* XP */, "got %u\n", GetLastError());
10124 ok(!bytes, "got bytes %u\n", bytes);
10125 ok(key == 0x12345678, "got key %#lx\n", key);
10126 ok(ovl_iocp == &ovl, "got ovl %p\n", ovl_iocp);
10127 if (ovl_iocp)
10128 {
10129 ok(!ovl_iocp->InternalHigh, "got %#lx\n", ovl_iocp->InternalHigh);
10130 todo_wine
10131 ok(ovl_iocp->Internal == (ULONG)STATUS_CONNECTION_ABORTED || ovl_iocp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT /* XP */, "got %#lx\n", ovl_iocp->Internal);
10132 }
10133
10134 bytes = 0xdeadbeef;
10135 key = 0xdeadbeef;
10136 ovl_iocp = (void *)0xdeadbeef;
10137 SetLastError(0xdeadbeef);
10138 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
10139 ok(!ret, "got %d\n", ret);
10140 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
10141 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
10142 ok(key == 0xdeadbeef, "got key %#lx\n", key);
10143 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
10144
10145 CloseHandle(port);
10146
10147 DestroyWindow(hwnd);
10148 }
10149
10150 static void iocp_async_closesocket(SOCKET src)
10151 {
10152 HANDLE port;
10153 WSAOVERLAPPED *ovl_iocp;
10154 int ret;
10155 DWORD bytes;
10156 ULONG_PTR key;
10157 HWND hwnd;
10158 MSG msg;
10159
10160 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
10161 0, 0, 0, 0, NULL, NULL, 0, NULL);
10162 ok(hwnd != 0, "CreateWindowEx failed\n");
10163
10164 ret = WSAAsyncSelect(src, hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
10165 ok(!ret, "got %d\n", ret);
10166
10167 Sleep(100);
10168 memset(&msg, 0, sizeof(msg));
10169 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10170 ok(ret, "got %d\n", ret);
10171 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
10172 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
10173 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
10174 ok(msg.lParam == 2, "got %08lx\n", msg.lParam);
10175
10176 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
10177 ok(port != 0, "CreateIoCompletionPort error %u\n", GetLastError());
10178
10179 Sleep(100);
10180 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10181 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
10182
10183 bytes = 0xdeadbeef;
10184 key = 0xdeadbeef;
10185 ovl_iocp = (void *)0xdeadbeef;
10186 SetLastError(0xdeadbeef);
10187 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
10188 ok(!ret, "got %d\n", ret);
10189 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
10190 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
10191 ok(key == 0xdeadbeef, "got key %lu\n", key);
10192 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
10193
10194 Sleep(100);
10195 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10196 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
10197
10198 closesocket(src);
10199
10200 Sleep(100);
10201 memset(&msg, 0, sizeof(msg));
10202 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10203 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
10204
10205 bytes = 0xdeadbeef;
10206 key = 0xdeadbeef;
10207 ovl_iocp = (void *)0xdeadbeef;
10208 SetLastError(0xdeadbeef);
10209 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
10210 ok(!ret, "got %d\n", ret);
10211 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
10212 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
10213 ok(key == 0xdeadbeef, "got key %lu\n", key);
10214 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
10215
10216 CloseHandle(port);
10217
10218 DestroyWindow(hwnd);
10219 }
10220
10221 struct wsa_async_select_info
10222 {
10223 SOCKET sock;
10224 HWND hwnd;
10225 };
10226
10227 static DWORD WINAPI wsa_async_select_thread(void *param)
10228 {
10229 struct wsa_async_select_info *info = param;
10230 int ret;
10231
10232 ret = WSAAsyncSelect(info->sock, info->hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
10233 ok(!ret, "got %d\n", ret);
10234
10235 return 0;
10236 }
10237
10238 struct wsa_recv_info
10239 {
10240 SOCKET sock;
10241 WSABUF wsa_buf;
10242 WSAOVERLAPPED ovl;
10243 };
10244
10245 static DWORD WINAPI wsa_recv_thread(void *param)
10246 {
10247 struct wsa_recv_info *info = param;
10248 int ret;
10249 DWORD flags, bytes;
10250
10251 bytes = 0xdeadbeef;
10252 flags = 0;
10253 SetLastError(0xdeadbeef);
10254 ret = WSARecv(info->sock, &info->wsa_buf, 1, &bytes, &flags, &info->ovl, NULL);
10255 ok(ret == SOCKET_ERROR, "got %d\n", ret);
10256 ok(GetLastError() == ERROR_IO_PENDING, "got %u\n", GetLastError());
10257 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
10258
10259 return 0;
10260 }
10261
10262 static void iocp_async_read_thread_closesocket(SOCKET src)
10263 {
10264 struct wsa_async_select_info select_info;
10265 struct wsa_recv_info recv_info;
10266 HANDLE port, thread;
10267 WSAOVERLAPPED *ovl_iocp;
10268 int ret;
10269 char data[512];
10270 DWORD bytes, tid;
10271 ULONG_PTR key;
10272 HWND hwnd;
10273 MSG msg;
10274
10275 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
10276 0, 0, 0, 0, NULL, NULL, 0, NULL);
10277 ok(hwnd != 0, "CreateWindowEx failed\n");
10278
10279 select_info.sock = src;
10280 select_info.hwnd = hwnd;
10281 thread = CreateThread(NULL, 0, wsa_async_select_thread, &select_info, 0, &tid);
10282 ok(thread != 0, "CreateThread error %u\n", GetLastError());
10283 ret = WaitForSingleObject(thread, 10000);
10284 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
10285
10286 Sleep(100);
10287 memset(&msg, 0, sizeof(msg));
10288 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10289 ok(ret, "got %d\n", ret);
10290 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
10291 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
10292 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
10293 ok(msg.lParam == 2, "got %08lx\n", msg.lParam);
10294
10295 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
10296 ok(port != 0, "CreateIoCompletionPort error %u\n", GetLastError());
10297
10298 Sleep(100);
10299 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10300 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
10301
10302 memset(data, 0, sizeof(data));
10303 memset(&recv_info.ovl, 0, sizeof(recv_info.ovl));
10304 recv_info.sock = src;
10305 recv_info.wsa_buf.len = sizeof(data);
10306 recv_info.wsa_buf.buf = data;
10307 thread = CreateThread(NULL, 0, wsa_recv_thread, &recv_info, 0, &tid);
10308 ok(thread != 0, "CreateThread error %u\n", GetLastError());
10309 ret = WaitForSingleObject(thread, 10000);
10310 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
10311
10312 Sleep(100);
10313 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10314 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
10315
10316 bytes = 0xdeadbeef;
10317 key = 0xdeadbeef;
10318 ovl_iocp = (void *)0xdeadbeef;
10319 SetLastError(0xdeadbeef);
10320 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
10321 ok(!ret, "got %d\n", ret);
10322 ok(GetLastError() == WAIT_TIMEOUT || broken(GetLastError() == ERROR_OPERATION_ABORTED) /* XP */,
10323 "got %u\n", GetLastError());
10324 if (GetLastError() == WAIT_TIMEOUT)
10325 {
10326 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
10327 ok(key == 0xdeadbeef, "got key %lx\n", key);
10328 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
10329 }
10330 else /* document XP behaviour */
10331 {
10332 ok(!bytes, "got bytes %u\n", bytes);
10333 ok(key == 0x12345678, "got key %#lx\n", key);
10334 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
10335 if (ovl_iocp)
10336 {
10337 ok(!ovl_iocp->InternalHigh, "got %#lx\n", ovl_iocp->InternalHigh);
10338 ok(ovl_iocp->Internal == STATUS_CANCELLED, "got %#lx\n", ovl_iocp->Internal);
10339 }
10340
10341 closesocket(src);
10342 goto xp_is_broken;
10343 }
10344
10345 Sleep(100);
10346 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10347 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
10348
10349 closesocket(src);
10350
10351 Sleep(100);
10352 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10353 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
10354
10355 bytes = 0xdeadbeef;
10356 key = 0xdeadbeef;
10357 ovl_iocp = NULL;
10358 SetLastError(0xdeadbeef);
10359 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
10360 ok(!ret, "got %d\n", ret);
10361 todo_wine
10362 ok(GetLastError() == ERROR_CONNECTION_ABORTED || GetLastError() == ERROR_NETNAME_DELETED /* XP */, "got %u\n", GetLastError());
10363 ok(!bytes, "got bytes %u\n", bytes);
10364 ok(key == 0x12345678, "got key %#lx\n", key);
10365 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
10366 if (ovl_iocp)
10367 {
10368 ok(!ovl_iocp->InternalHigh, "got %#lx\n", ovl_iocp->InternalHigh);
10369 todo_wine
10370 ok(ovl_iocp->Internal == (ULONG)STATUS_CONNECTION_ABORTED || ovl_iocp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT /* XP */, "got %#lx\n", ovl_iocp->Internal);
10371 }
10372
10373 xp_is_broken:
10374 bytes = 0xdeadbeef;
10375 key = 0xdeadbeef;
10376 ovl_iocp = (void *)0xdeadbeef;
10377 SetLastError(0xdeadbeef);
10378 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
10379 ok(!ret, "got %d\n", ret);
10380 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
10381 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
10382 ok(key == 0xdeadbeef, "got key %lu\n", key);
10383 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
10384
10385 CloseHandle(port);
10386
10387 DestroyWindow(hwnd);
10388 }
10389
10390 static void iocp_async_read_thread(SOCKET src, SOCKET dst)
10391 {
10392 struct wsa_async_select_info select_info;
10393 struct wsa_recv_info recv_info;
10394 HANDLE port, thread;
10395 WSAOVERLAPPED *ovl_iocp;
10396 int ret;
10397 char data[512];
10398 DWORD bytes, tid;
10399 ULONG_PTR key;
10400 HWND hwnd;
10401 MSG msg;
10402
10403 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
10404 0, 0, 0, 0, NULL, NULL, 0, NULL);
10405 ok(hwnd != 0, "CreateWindowEx failed\n");
10406
10407 select_info.sock = src;
10408 select_info.hwnd = hwnd;
10409 thread = CreateThread(NULL, 0, wsa_async_select_thread, &select_info, 0, &tid);
10410 ok(thread != 0, "CreateThread error %u\n", GetLastError());
10411 ret = WaitForSingleObject(thread, 10000);
10412 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
10413
10414 Sleep(100);
10415 memset(&msg, 0, sizeof(msg));
10416 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10417 ok(ret, "got %d\n", ret);
10418 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
10419 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
10420 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
10421 ok(msg.lParam == 2, "got %08lx\n", msg.lParam);
10422
10423 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
10424 ok(port != 0, "CreateIoCompletionPort error %u\n", GetLastError());
10425
10426 Sleep(100);
10427 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10428 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
10429
10430 memset(data, 0, sizeof(data));
10431 memset(&recv_info.ovl, 0, sizeof(recv_info.ovl));
10432 recv_info.sock = src;
10433 recv_info.wsa_buf.len = sizeof(data);
10434 recv_info.wsa_buf.buf = data;
10435 thread = CreateThread(NULL, 0, wsa_recv_thread, &recv_info, 0, &tid);
10436 ok(thread != 0, "CreateThread error %u\n", GetLastError());
10437 ret = WaitForSingleObject(thread, 10000);
10438 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
10439
10440 Sleep(100);
10441 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10442 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
10443
10444 bytes = 0xdeadbeef;
10445 key = 0xdeadbeef;
10446 ovl_iocp = (void *)0xdeadbeef;
10447 SetLastError(0xdeadbeef);
10448 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
10449 ok(!ret, "got %d\n", ret);
10450 ok(GetLastError() == WAIT_TIMEOUT || broken(GetLastError() == ERROR_OPERATION_ABORTED) /* XP */, "got %u\n", GetLastError());
10451 if (GetLastError() == WAIT_TIMEOUT)
10452 {
10453 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
10454 ok(key == 0xdeadbeef, "got key %lu\n", key);
10455 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
10456 }
10457 else /* document XP behaviour */
10458 {
10459 ok(bytes == 0, "got bytes %u\n", bytes);
10460 ok(key == 0x12345678, "got key %#lx\n", key);
10461 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
10462 if (ovl_iocp)
10463 {
10464 ok(!ovl_iocp->InternalHigh, "got %#lx\n", ovl_iocp->InternalHigh);
10465 ok(ovl_iocp->Internal == STATUS_CANCELLED, "got %#lx\n", ovl_iocp->Internal);
10466 }
10467 }
10468
10469 Sleep(100);
10470 memset(&msg, 0, sizeof(msg));
10471 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10472 ok(!ret || broken(msg.hwnd == hwnd) /* XP */, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
10473 if (ret) /* document XP behaviour */
10474 {
10475 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
10476 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
10477 ok(msg.lParam == 1, "got %08lx\n", msg.lParam);
10478 }
10479
10480 ret = send(dst, "Hello World!", 12, 0);
10481 ok(ret == 12, "send returned %d\n", ret);
10482
10483 Sleep(100);
10484 memset(&msg, 0, sizeof(msg));
10485 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10486 ok(!ret || broken(msg.hwnd == hwnd) /* XP */, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
10487 if (ret) /* document XP behaviour */
10488 {
10489 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
10490 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
10491 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
10492 ok(msg.lParam == 1, "got %08lx\n", msg.lParam);
10493 }
10494
10495 bytes = 0xdeadbeef;
10496 key = 0xdeadbeef;
10497 ovl_iocp = (void *)0xdeadbeef;
10498 SetLastError(0xdeadbeef);
10499 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
10500 ok(ret || broken(GetLastError() == WAIT_TIMEOUT) /* XP */, "got %u\n", GetLastError());
10501 if (ret)
10502 {
10503 ok(bytes == 12, "got bytes %u\n", bytes);
10504 ok(key == 0x12345678, "got key %#lx\n", key);
10505 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
10506 if (ovl_iocp)
10507 {
10508 ok(ovl_iocp->InternalHigh == 12, "got %#lx\n", ovl_iocp->InternalHigh);
10509 ok(!ovl_iocp->Internal , "got %#lx\n", ovl_iocp->Internal);
10510 ok(!memcmp(data, "Hello World!", 12), "got %u bytes (%*s)\n", bytes, bytes, data);
10511 }
10512 }
10513 else /* document XP behaviour */
10514 {
10515 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
10516 ok(key == 0xdeadbeef, "got key %lu\n", key);
10517 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
10518 }
10519
10520 CloseHandle(port);
10521
10522 DestroyWindow(hwnd);
10523 }
10524
10525 static void test_iocp(void)
10526 {
10527 SOCKET src, dst;
10528 int i;
10529
10530 tcp_socketpair(&src, &dst);
10531 sync_read(src, dst);
10532 iocp_async_read(src, dst);
10533 closesocket(src);
10534 closesocket(dst);
10535
10536 tcp_socketpair(&src, &dst);
10537 iocp_async_read_thread(src, dst);
10538 closesocket(src);
10539 closesocket(dst);
10540
10541 for (i = 0; i <= 2; i++)
10542 {
10543 tcp_socketpair(&src, &dst);
10544 iocp_async_read_closesocket(src, i);
10545 closesocket(dst);
10546 }
10547
10548 tcp_socketpair(&src, &dst);
10549 iocp_async_closesocket(src);
10550 closesocket(dst);
10551
10552 tcp_socketpair(&src, &dst);
10553 iocp_async_read_thread_closesocket(src);
10554 closesocket(dst);
10555 }
10556
10557 static void test_get_interface_list(void)
10558 {
10559 OVERLAPPED overlapped = {0}, *overlapped_ptr;
10560 DWORD size, expect_size;
10561 unsigned int i, count;
10562 INTERFACE_INFO *info;
10563 BOOL loopback_found;
10564 char buffer[4096];
10565 ULONG_PTR key;
10566 HANDLE port;
10567 SOCKET s;
10568 int ret;
10569
10570 s = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10571 ok(s != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10572 port = CreateIoCompletionPort((HANDLE)s, NULL, 123, 0);
10573
10574 size = 0xdeadbeef;
10575 WSASetLastError(0xdeadbeef);
10576 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(buffer), &size, NULL, NULL);
10577 ok(!ret, "Got unexpected ret %d.\n", ret);
10578 ok(!WSAGetLastError(), "Got error %u.\n", WSAGetLastError());
10579 ok(size && size != 0xdeadbeef && !(size % sizeof(INTERFACE_INFO)), "Got unexpected size %u.\n", size);
10580 expect_size = size;
10581
10582 size = 0xdeadbeef;
10583 overlapped.Internal = 0xdeadbeef;
10584 overlapped.InternalHigh = 0xdeadbeef;
10585 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(buffer), &size, &overlapped, NULL);
10586 ok(ret == -1, "Got unexpected ret %d.\n", ret);
10587 ok(WSAGetLastError() == ERROR_IO_PENDING, "Got error %u.\n", WSAGetLastError());
10588 ok(size == 0xdeadbeef, "Got size %u.\n", size);
10589
10590 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 100);
10591 ok(ret, "Got error %u.\n", GetLastError());
10592 ok(size == expect_size, "Expected size %u, got %u.\n", expect_size, size);
10593 ok(key == 123, "Got key %Iu.\n", key);
10594 ok(overlapped_ptr == &overlapped, "Got overlapped %p.\n", overlapped_ptr);
10595 ok(!overlapped.Internal, "Got status %#x.\n", (NTSTATUS)overlapped.Internal);
10596 ok(overlapped.InternalHigh == expect_size, "Expected size %u, got %Iu.\n", expect_size, overlapped.InternalHigh);
10597
10598 info = (INTERFACE_INFO *)buffer;
10599 count = size / sizeof(INTERFACE_INFO);
10600 loopback_found = FALSE;
10601 for (i = 0; i < count; ++i)
10602 {
10603 if (info[i].iiFlags & IFF_LOOPBACK)
10604 loopback_found = TRUE;
10605
10606 ok(info[i].iiAddress.AddressIn.sin_family == AF_INET, "Got unexpected sin_family %#x.\n",
10607 info[i].iiAddress.AddressIn.sin_family);
10608 ok(info[i].iiNetmask.AddressIn.sin_family == AF_INET, "Got unexpected sin_family %#x.\n",
10609 info[i].iiNetmask.AddressIn.sin_family);
10610 ok(info[i].iiBroadcastAddress.AddressIn.sin_family
10611 == (info[i].iiFlags & IFF_BROADCAST) ? AF_INET : 0, "Got unexpected sin_family %#x.\n",
10612 info[i].iiBroadcastAddress.AddressIn.sin_family);
10613 ok(info[i].iiAddress.AddressIn.sin_addr.S_un.S_addr, "Got zero iiAddress.\n");
10614 ok(info[i].iiNetmask.AddressIn.sin_addr.S_un.S_addr, "Got zero iiNetmask.\n");
10615 ok((info[i].iiFlags & IFF_BROADCAST) ? info[i].iiBroadcastAddress.AddressIn.sin_addr.S_un.S_addr
10616 : !info[i].iiBroadcastAddress.AddressIn.sin_addr.S_un.S_addr,
10617 "Got unexpected iiBroadcastAddress %s.\n", inet_ntoa(info[i].iiBroadcastAddress.AddressIn.sin_addr));
10618 }
10619
10620 ok(loopback_found, "Loopback interface not found.\n");
10621
10622 size = 0xdeadbeef;
10623 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(INTERFACE_INFO) - 1, &size, NULL, NULL);
10624 ok(ret == -1, "Got unexpected ret %d.\n", ret);
10625 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
10626 ok(!size, "Got unexpected size %u.\n", size);
10627
10628 size = 0xdeadbeef;
10629 overlapped.Internal = 0xdeadbeef;
10630 overlapped.InternalHigh = 0xdeadbeef;
10631 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(INTERFACE_INFO) - 1, &size, &overlapped, NULL);
10632 ok(ret == -1, "Got unexpected ret %d.\n", ret);
10633 ok(WSAGetLastError() == ERROR_IO_PENDING, "Got error %u.\n", WSAGetLastError());
10634 ok(size == 0xdeadbeef, "Got size %u.\n", size);
10635
10636 ret = GetQueuedCompletionStatus(port, &size, &key, &overlapped_ptr, 100);
10637 ok(!ret, "Expected failure.\n");
10638 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Got error %u.\n", GetLastError());
10639 ok(!size, "Got size %u.\n", size);
10640 ok(key == 123, "Got key %Iu.\n", key);
10641 ok(overlapped_ptr == &overlapped, "Got overlapped %p.\n", overlapped_ptr);
10642 ok((NTSTATUS)overlapped.Internal == STATUS_BUFFER_TOO_SMALL, "Got status %#x.\n", (NTSTATUS)overlapped.Internal);
10643 ok(!overlapped.InternalHigh, "Got size %Iu.\n", overlapped.InternalHigh);
10644
10645 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, sizeof(buffer), NULL, NULL, NULL);
10646 ok(ret == -1, "Got unexpected ret %d.\n", ret);
10647 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
10648
10649 CloseHandle(port);
10650 closesocket(s);
10651
10652 /* Test with an APC. */
10653
10654 s = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
10655 ok(s != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
10656
10657 size = 0xdeadbeef;
10658 apc_count = 0;
10659 ret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, buffer,
10660 sizeof(INTERFACE_INFO) - 1, &size, &overlapped, socket_apc);
10661 ok(ret == -1, "Got unexpected ret %d.\n", ret);
10662 ok(WSAGetLastError() == ERROR_IO_PENDING, "Got error %u.\n", WSAGetLastError());
10663 ok(size == 0xdeadbeef, "Got size %u.\n", size);
10664
10665 ret = SleepEx(100, TRUE);
10666 ok(ret == WAIT_IO_COMPLETION, "got %d\n", ret);
10667 ok(apc_count == 1, "APC was called %u times\n", apc_count);
10668 ok(apc_error == WSAEFAULT, "got APC error %u\n", apc_error);
10669 ok(!apc_size, "got APC size %u\n", apc_size);
10670 ok(apc_overlapped == &overlapped, "got APC overlapped %p\n", apc_overlapped);
10671
10672 closesocket(s);
10673 }
10674
10675 static void test_bind(void)
10676 {
10677 const struct sockaddr_in invalid_addr = {.sin_family = AF_INET, .sin_addr.s_addr = inet_addr("192.0.2.0")};
10678 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
10679 IP_ADAPTER_ADDRESSES *adapters = NULL, *adapter;
10680 ULONG ip_addrs_size = 0;
10681 struct sockaddr addr;
10682 SOCKET s, s2;
10683 int ret, len;
10684
10685 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10686
10687 WSASetLastError(0xdeadbeef);
10688 ret = bind(s, NULL, 0);
10689 ok(ret == -1, "expected failure\n");
10690 todo_wine ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
10691
10692 addr.sa_family = 0xdead;
10693 WSASetLastError(0xdeadbeef);
10694 ret = bind(s, &addr, sizeof(addr));
10695 ok(ret == -1, "expected failure\n");
10696 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError());
10697
10698 WSASetLastError(0xdeadbeef);
10699 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr) - 1);
10700 ok(ret == -1, "expected failure\n");
10701 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
10702
10703 WSASetLastError(0xdeadbeef);
10704 ret = bind(s, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
10705 ok(ret == -1, "expected failure\n");
10706 ok(WSAGetLastError() == WSAEADDRNOTAVAIL, "got error %u\n", WSAGetLastError());
10707
10708 WSASetLastError(0xdeadbeef);
10709 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
10710 ok(!ret, "expected success\n");
10711 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
10712
10713 WSASetLastError(0xdeadbeef);
10714 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
10715 ok(ret == -1, "expected failure\n");
10716 ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
10717
10718 len = sizeof(addr);
10719 ret = getsockname(s, &addr, &len);
10720 ok(!ret, "got error %u\n", WSAGetLastError());
10721
10722 s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10723
10724 WSASetLastError(0xdeadbeef);
10725 ret = bind(s2, &addr, sizeof(addr));
10726 ok(ret == -1, "expected failure\n");
10727 ok(WSAGetLastError() == WSAEADDRINUSE, "got error %u\n", WSAGetLastError());
10728
10729 closesocket(s2);
10730 closesocket(s);
10731
10732 s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
10733
10734 WSASetLastError(0xdeadbeef);
10735 ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
10736 ok(!ret, "expected success\n");
10737 ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError());
10738
10739 closesocket(s);
10740
10741 ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, adapters, &ip_addrs_size);
10742 ok(ret == ERROR_BUFFER_OVERFLOW, "got error %u\n", ret);
10743 adapters = malloc(ip_addrs_size);
10744 ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, adapters, &ip_addrs_size);
10745 ok(!ret, "got error %u\n", ret);
10746
10747 for (adapter = adapters; adapter != NULL; adapter = adapter->Next)
10748 {
10749 const IP_ADAPTER_UNICAST_ADDRESS *unicast_addr;
10750
10751 for (unicast_addr = adapter->FirstUnicastAddress; unicast_addr != NULL; unicast_addr = unicast_addr->Next)
10752 {
10753 short family = unicast_addr->Address.lpSockaddr->sa_family;
10754
10755 s = socket(family, SOCK_STREAM, IPPROTO_TCP);
10756 ok(s != -1, "failed to create socket, error %u\n", WSAGetLastError());
10757
10758 ret = bind(s, unicast_addr->Address.lpSockaddr, unicast_addr->Address.iSockaddrLength);
10759 ok(!ret, "got error %u\n", WSAGetLastError());
10760
10761 closesocket(s);
10762
10763 if (family == AF_INET6)
10764 {
10765 struct sockaddr_in6 addr6, ret_addr6;
10766
10767 memcpy(&addr6, unicast_addr->Address.lpSockaddr, sizeof(addr6));
10768
10769 ok(unicast_addr->Address.iSockaddrLength == sizeof(struct sockaddr_in6),
10770 "got unexpected length %u\n", unicast_addr->Address.iSockaddrLength);
10771
10772 s = socket(family, SOCK_STREAM, IPPROTO_TCP);
10773 ok(s != -1, "failed to create socket, error %u\n", WSAGetLastError());
10774
10775 ret = bind(s, unicast_addr->Address.lpSockaddr, sizeof(struct sockaddr_in6_old));
10776 ok(ret == -1, "expected failure\n");
10777 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
10778
10779 addr6.sin6_scope_id = 0xabacab;
10780 ret = bind(s, (struct sockaddr *)&addr6, sizeof(addr6));
10781 todo_wine_if (!((const struct sockaddr_in6 *)unicast_addr->Address.lpSockaddr)->sin6_scope_id)
10782 {
10783 ok(ret == -1, "expected failure\n");
10784 ok(WSAGetLastError() == WSAEADDRNOTAVAIL, "got error %u\n", WSAGetLastError());
10785 }
10786
10787 addr6.sin6_scope_id = 0;
10788 ret = bind(s, (struct sockaddr *)&addr6, sizeof(addr6));
10789 todo_wine_if (!((const struct sockaddr_in6 *)unicast_addr->Address.lpSockaddr)->sin6_scope_id)
10790 ok(!ret, "got error %u\n", WSAGetLastError());
10791
10792 memcpy(&addr6, unicast_addr->Address.lpSockaddr, sizeof(addr6));
10793
10794 len = sizeof(struct sockaddr_in6_old);
10795 ret = getsockname(s, (struct sockaddr *)&ret_addr6, &len);
10796 ok(ret == -1, "expected failure\n");
10797 ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError());
10798
10799 len = sizeof(ret_addr6);
10800 memset(&ret_addr6, 0, sizeof(ret_addr6));
10801 ret = getsockname(s, (struct sockaddr *)&ret_addr6, &len);
10802 ok(!ret, "got error %u\n", WSAGetLastError());
10803 ok(ret_addr6.sin6_family == AF_INET6, "got family %u\n", ret_addr6.sin6_family);
10804 ok(ret_addr6.sin6_port != 0, "expected nonzero port\n");
10805 ok(!memcmp(&ret_addr6.sin6_addr, &addr6.sin6_addr, sizeof(addr6.sin6_addr)), "address didn't match\n");
10806 ok(ret_addr6.sin6_scope_id == addr6.sin6_scope_id, "got scope %u\n", ret_addr6.sin6_scope_id);
10807
10808 closesocket(s);
10809 }
10810 }
10811 }
10812
10813 free(adapters);
10814 }
10815
10816 /* Test calling methods on a socket which is currently connecting. */
10817 static void test_connecting_socket(void)
10818 {
10819 const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_ANY)};
10820 const struct sockaddr_in invalid_addr =
10821 {
10822 .sin_family = AF_INET,
10823 .sin_addr.s_addr = inet_addr("192.0.2.0"),
10824 .sin_port = 255
10825 };
10826 OVERLAPPED overlapped = {0}, overlapped2 = {0};
10827 GUID connectex_guid = WSAID_CONNECTEX;
10828 LPFN_CONNECTEX pConnectEx;
10829 struct sockaddr_in addr;
10830 char buffer[4];
10831 SOCKET client;
10832 int ret, len;
10833 DWORD size;
10834
10835 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10836 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
10837 set_blocking(client, FALSE);
10838
10839 ret = bind(client, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
10840 ok(!ret, "expected success\n");
10841 ok(!WSAGetLastError(), "got %u\n", WSAGetLastError());
10842
10843 ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
10844 ok(ret == -1, "got %d\n", ret);
10845 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got %u\n", WSAGetLastError());
10846
10847 /* Mortal Kombat 11 connects to the same address twice and expects the
10848 * second to return WSAEALREADY. */
10849 ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
10850 ok(ret == -1, "got %d\n", ret);
10851 ok(WSAGetLastError() == WSAEALREADY, "got %u\n", WSAGetLastError());
10852
10853 ret = WSAIoctl(client, 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 overlapped.Internal = 0xdeadbeef;
10857 overlapped.InternalHigh = 0xdeadbeef;
10858 ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped);
10859 ok(!ret, "got %d\n", ret);
10860 ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError());
10861 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got status %#x\n", (NTSTATUS)overlapped.Internal);
10862 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
10863
10864 len = sizeof(addr);
10865 ret = getsockname(client, (struct sockaddr *)&addr, &len);
10866 ok(!ret, "got error %u\n", WSAGetLastError());
10867 ok(addr.sin_family == AF_INET, "got family %u\n", addr.sin_family);
10868 ok(addr.sin_port, "expected nonzero port\n");
10869
10870 len = sizeof(addr);
10871 ret = getpeername(client, (struct sockaddr *)&addr, &len);
10872 todo_wine ok(!ret, "got error %u\n", WSAGetLastError());
10873 if (!ret)
10874 {
10875 ok(addr.sin_family == AF_INET, "got family %u\n", addr.sin_family);
10876 ok(addr.sin_addr.s_addr == inet_addr("192.0.2.0"), "got address %#08x\n", addr.sin_addr.s_addr);
10877 ok(addr.sin_port == 255, "expected nonzero port\n");
10878 }
10879
10880 ret = recv(client, buffer, sizeof(buffer), 0);
10881 ok(ret == -1, "got %d\n", ret);
10882 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
10883
10884 ret = send(client, "data", 5, 0);
10885 ok(ret == -1, "got %d\n", ret);
10886 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
10887
10888 closesocket(client);
10889
10890 /* Test with ConnectEx(). */
10891
10892 client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10893 ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError());
10894 set_blocking(client, FALSE);
10895
10896 ret = bind(client, (const struct sockaddr *)&bind_addr, sizeof(bind_addr));
10897 ok(!ret, "expected success\n");
10898 ok(!WSAGetLastError(), "got %u\n", WSAGetLastError());
10899
10900 ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped2);
10901 ok(!ret, "got %d\n", ret);
10902 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
10903
10904 ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr));
10905 ok(ret == -1, "got %d\n", ret);
10906 ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError());
10907
10908 overlapped.Internal = 0xdeadbeef;
10909 overlapped.InternalHigh = 0xdeadbeef;
10910 ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped);
10911 ok(!ret, "got %d\n", ret);
10912 ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError());
10913 ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got status %#x\n", (NTSTATUS)overlapped.Internal);
10914 todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh);
10915
10916 len = sizeof(addr);
10917 ret = getsockname(client, (struct sockaddr *)&addr, &len);
10918 ok(!ret, "got error %u\n", WSAGetLastError());
10919 ok(addr.sin_family == AF_INET, "got family %u\n", addr.sin_family);
10920 ok(addr.sin_port, "expected nonzero port\n");
10921
10922 len = sizeof(addr);
10923 ret = getpeername(client, (struct sockaddr *)&addr, &len);
10924 ok(ret == -1, "got %d\n", ret);
10925 ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
10926
10927 ret = recv(client, buffer, sizeof(buffer), 0);
10928 ok(ret == -1, "got %d\n", ret);
10929 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
10930
10931 ret = send(client, "data", 5, 0);
10932 ok(ret == -1, "got %d\n", ret);
10933 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError());
10934
10935 closesocket(client);
10936 }
10937
10938 static DWORD map_status( NTSTATUS status )
10939 {
10940 static const struct
10941 {
10942 NTSTATUS status;
10943 DWORD error;
10944 }
10945 errors[] =
10946 {
10947 {STATUS_PENDING, ERROR_IO_INCOMPLETE},
10948
10949 {STATUS_BUFFER_OVERFLOW, WSAEMSGSIZE},
10950
10951 {STATUS_NOT_IMPLEMENTED, WSAEOPNOTSUPP},
10952 {STATUS_ACCESS_VIOLATION, WSAEFAULT},
10953 {STATUS_PAGEFILE_QUOTA, WSAENOBUFS},
10954 {STATUS_INVALID_HANDLE, WSAENOTSOCK},
10955 {STATUS_NO_SUCH_DEVICE, WSAENETDOWN},
10956 {STATUS_NO_SUCH_FILE, WSAENETDOWN},
10957 {STATUS_NO_MEMORY, WSAENOBUFS},
10958 {STATUS_CONFLICTING_ADDRESSES, WSAENOBUFS},
10959 {STATUS_ACCESS_DENIED, WSAEACCES},
10960 {STATUS_BUFFER_TOO_SMALL, WSAEFAULT},
10961 {STATUS_OBJECT_TYPE_MISMATCH, WSAENOTSOCK},
10962 {STATUS_OBJECT_NAME_NOT_FOUND, WSAENETDOWN},
10963 {STATUS_OBJECT_PATH_NOT_FOUND, WSAENETDOWN},
10964 {STATUS_SHARING_VIOLATION, WSAEADDRINUSE},
10965 {STATUS_QUOTA_EXCEEDED, WSAENOBUFS},
10966 {STATUS_TOO_MANY_PAGING_FILES, WSAENOBUFS},
10967 {STATUS_INSUFFICIENT_RESOURCES, WSAENOBUFS},
10968 {STATUS_WORKING_SET_QUOTA, WSAENOBUFS},
10969 {STATUS_DEVICE_NOT_READY, WSAEWOULDBLOCK},
10970 {STATUS_PIPE_DISCONNECTED, WSAESHUTDOWN},
10971 {STATUS_IO_TIMEOUT, WSAETIMEDOUT},
10972 {STATUS_NOT_SUPPORTED, WSAEOPNOTSUPP},
10973 {STATUS_REMOTE_NOT_LISTENING, WSAECONNREFUSED},
10974 {STATUS_BAD_NETWORK_PATH, WSAENETUNREACH},
10975 {STATUS_NETWORK_BUSY, WSAENETDOWN},
10976 {STATUS_INVALID_NETWORK_RESPONSE, WSAENETDOWN},
10977 {STATUS_UNEXPECTED_NETWORK_ERROR, WSAENETDOWN},
10978 {STATUS_REQUEST_NOT_ACCEPTED, WSAEWOULDBLOCK},
10979 {STATUS_CANCELLED, ERROR_OPERATION_ABORTED},
10980 {STATUS_COMMITMENT_LIMIT, WSAENOBUFS},
10981 {STATUS_LOCAL_DISCONNECT, WSAECONNABORTED},
10982 {STATUS_REMOTE_DISCONNECT, WSAECONNRESET},
10983 {STATUS_REMOTE_RESOURCES, WSAENOBUFS},
10984 {STATUS_LINK_FAILED, WSAECONNRESET},
10985 {STATUS_LINK_TIMEOUT, WSAETIMEDOUT},
10986 {STATUS_INVALID_CONNECTION, WSAENOTCONN},
10987 {STATUS_INVALID_ADDRESS, WSAEADDRNOTAVAIL},
10988 {STATUS_INVALID_BUFFER_SIZE, WSAEMSGSIZE},
10989 {STATUS_INVALID_ADDRESS_COMPONENT, WSAEADDRNOTAVAIL},
10990 {STATUS_TOO_MANY_ADDRESSES, WSAENOBUFS},
10991 {STATUS_ADDRESS_ALREADY_EXISTS, WSAEADDRINUSE},
10992 {STATUS_CONNECTION_DISCONNECTED, WSAECONNRESET},
10993 {STATUS_CONNECTION_RESET, WSAECONNRESET},
10994 {STATUS_TRANSACTION_ABORTED, WSAECONNABORTED},
10995 {STATUS_CONNECTION_REFUSED, WSAECONNREFUSED},
10996 {STATUS_GRACEFUL_DISCONNECT, WSAEDISCON},
10997 {STATUS_CONNECTION_ACTIVE, WSAEISCONN},
10998 {STATUS_NETWORK_UNREACHABLE, WSAENETUNREACH},
10999 {STATUS_HOST_UNREACHABLE, WSAEHOSTUNREACH},
11000 {STATUS_PROTOCOL_UNREACHABLE, WSAENETUNREACH},
11001 {STATUS_PORT_UNREACHABLE, WSAECONNRESET},
11002 {STATUS_REQUEST_ABORTED, WSAEINTR},
11003 {STATUS_CONNECTION_ABORTED, WSAECONNABORTED},
11004 {STATUS_DATATYPE_MISALIGNMENT_ERROR,WSAEFAULT},
11005 {STATUS_HOST_DOWN, WSAEHOSTDOWN},
11006 {0x80070000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
11007 {0xc0010000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
11008 {0xc0070000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
11009 };
11010
11011 unsigned int i;
11012
11013 for (i = 0; i < ARRAY_SIZE(errors); ++i)
11014 {
11015 if (errors[i].status == status)
11016 return errors[i].error;
11017 }
11018
11019 return NT_SUCCESS(status) ? RtlNtStatusToDosErrorNoTeb(status) : WSAEINVAL;
11020 }
11021
11022 static void test_WSAGetOverlappedResult(void)
11023 {
11024 OVERLAPPED overlapped = {0};
11025 DWORD size, flags;
11026 NTSTATUS status;
11027 unsigned int i;
11028 SOCKET s;
11029 BOOL ret;
11030
11031 static const NTSTATUS ranges[][2] =
11032 {
11033 {0x0, 0x10000},
11034 {0x40000000, 0x40001000},
11035 {0x80000000, 0x80001000},
11036 {0x80070000, 0x80080000},
11037 {0xc0000000, 0xc0001000},
11038 {0xc0070000, 0xc0080000},
11039 {0xd0000000, 0xd0001000},
11040 {0xd0070000, 0xd0080000},
11041 };
11042
11043 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11044
11045 for (i = 0; i < ARRAY_SIZE(ranges); ++i)
11046 {
11047 for (status = ranges[i][0]; status < ranges[i][1]; ++status)
11048 {
11049 BOOL expect_ret = NT_SUCCESS(status) && status != STATUS_PENDING;
11050 DWORD expect = map_status(status);
11051
11052 overlapped.Internal = status;
11053 WSASetLastError(0xdeadbeef);
11054 ret = WSAGetOverlappedResult(s, &overlapped, &size, FALSE, &flags);
11055 ok(ret == expect_ret, "status %#x: expected %d, got %d\n", status, expect_ret, ret);
11056 if (ret)
11057 {
11058 ok(WSAGetLastError() == expect /* >= win10 1809 */
11059 || !WSAGetLastError() /* < win10 1809 */
11060 || WSAGetLastError() == 0xdeadbeef, /* < win7 */
11061 "status %#x: expected error %u, got %u\n", status, expect, WSAGetLastError());
11062 }
11063 else
11064 {
11065 ok(WSAGetLastError() == expect
11066 || (status == (0xc0070000 | ERROR_IO_INCOMPLETE) && WSAGetLastError() == WSAEINVAL), /* < win8 */
11067 "status %#x: expected error %u, got %u\n", status, expect, WSAGetLastError());
11068 }
11069 }
11070 }
11071
11072 closesocket(s);
11073 }
11074
11075 struct nonblocking_async_recv_params
11076 {
11077 SOCKET client;
11078 HANDLE event;
11079 };
11080
11081 static DWORD CALLBACK nonblocking_async_recv_thread(void *arg)
11082 {
11083 const struct nonblocking_async_recv_params *params = arg;
11084 OVERLAPPED overlapped = {0};
11085 DWORD flags = 0, size;
11086 char buffer[5];
11087 WSABUF wsabuf;
11088 int ret;
11089
11090 overlapped.hEvent = params->event;
11091 wsabuf.buf = buffer;
11092 wsabuf.len = sizeof(buffer);
11093 memset(buffer, 0, sizeof(buffer));
11094 ret = WSARecv(params->client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
11095 ok(!ret, "got %d\n", ret);
11096 ret = GetOverlappedResult((HANDLE)params->client, &overlapped, &size, FALSE);
11097 ok(ret, "got error %u\n", GetLastError());
11098 ok(size == 4, "got size %u\n", size);
11099 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
11100
11101 return 0;
11102 }
11103
11104 static void test_nonblocking_async_recv(void)
11105 {
11106 struct nonblocking_async_recv_params params;
11107 OVERLAPPED overlapped = {0};
11108 SOCKET client, server;
11109 DWORD flags = 0, size;
11110 HANDLE thread, event;
11111 char buffer[5];
11112 WSABUF wsabuf;
11113 int ret;
11114
11115 event = CreateEventW(NULL, TRUE, FALSE, NULL);
11116 wsabuf.buf = buffer;
11117 wsabuf.len = sizeof(buffer);
11118
11119 tcp_socketpair(&client, &server);
11120 set_blocking(client, FALSE);
11121 set_blocking(server, FALSE);
11122
11123 WSASetLastError(0xdeadbeef);
11124 ret = recv(client, buffer, sizeof(buffer), 0);
11125 ok(ret == -1, "got %d\n", ret);
11126 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
11127
11128 WSASetLastError(0xdeadbeef);
11129 overlapped.Internal = 0xdeadbeef;
11130 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
11131 ok(ret == -1, "got %d\n", ret);
11132 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
11133 ok(overlapped.Internal == 0xdeadbeef, "got status %#x\n", (NTSTATUS)overlapped.Internal);
11134
11135 /* Overlapped, with a NULL event. */
11136
11137 overlapped.hEvent = NULL;
11138
11139 memset(buffer, 0, sizeof(buffer));
11140 WSASetLastError(0xdeadbeef);
11141 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
11142 ok(ret == -1, "got %d\n", ret);
11143 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
11144 ret = WaitForSingleObject((HANDLE)client, 0);
11145 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
11146
11147 ret = send(server, "data", 4, 0);
11148 ok(ret == 4, "got %d\n", ret);
11149
11150 ret = WaitForSingleObject((HANDLE)client, 1000);
11151 ok(!ret, "wait timed out\n");
11152 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
11153 ok(ret, "got error %u\n", GetLastError());
11154 ok(size == 4, "got size %u\n", size);
11155 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
11156
11157 /* Overlapped, with a non-NULL event. */
11158
11159 overlapped.hEvent = event;
11160
11161 memset(buffer, 0, sizeof(buffer));
11162 WSASetLastError(0xdeadbeef);
11163 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
11164 ok(ret == -1, "got %d\n", ret);
11165 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
11166 ret = WaitForSingleObject(event, 0);
11167 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
11168
11169 ret = send(server, "data", 4, 0);
11170 ok(ret == 4, "got %d\n", ret);
11171
11172 ret = WaitForSingleObject(event, 1000);
11173 ok(!ret, "wait timed out\n");
11174 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
11175 ok(ret, "got error %u\n", GetLastError());
11176 ok(size == 4, "got size %u\n", size);
11177 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
11178
11179 /* With data already in the pipe; usually this does return 0 (but not
11180 * reliably). */
11181
11182 ret = send(server, "data", 4, 0);
11183 ok(ret == 4, "got %d\n", ret);
11184
11185 memset(buffer, 0, sizeof(buffer));
11186 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
11187 ok(!ret || WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
11188 ret = WaitForSingleObject(event, 1000);
11189 ok(!ret, "wait timed out\n");
11190 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
11191 ok(ret, "got error %u\n", GetLastError());
11192 ok(size == 4, "got size %u\n", size);
11193 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
11194
11195 closesocket(client);
11196 closesocket(server);
11197
11198 /* With a non-overlapped socket, WSARecv() always blocks when passed an
11199 * overlapped structure, but returns WSAEWOULDBLOCK otherwise. */
11200
11201 tcp_socketpair_flags(&client, &server, 0);
11202 set_blocking(client, FALSE);
11203 set_blocking(server, FALSE);
11204
11205 WSASetLastError(0xdeadbeef);
11206 ret = recv(client, buffer, sizeof(buffer), 0);
11207 ok(ret == -1, "got %d\n", ret);
11208 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
11209
11210 WSASetLastError(0xdeadbeef);
11211 overlapped.Internal = 0xdeadbeef;
11212 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
11213 ok(ret == -1, "got %d\n", ret);
11214 ok(WSAGetLastError() == WSAEWOULDBLOCK, "got error %u\n", WSAGetLastError());
11215 ok(overlapped.Internal == 0xdeadbeef, "got status %#x\n", (NTSTATUS)overlapped.Internal);
11216
11217 /* Overlapped, with a NULL event. */
11218
11219 params.client = client;
11220 params.event = NULL;
11221 thread = CreateThread(NULL, 0, nonblocking_async_recv_thread, &params, 0, NULL);
11222
11223 ret = WaitForSingleObject(thread, 200);
11224 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
11225
11226 ret = send(server, "data", 4, 0);
11227 ok(ret == 4, "got %d\n", ret);
11228
11229 ret = WaitForSingleObject(thread, 200);
11230 ok(!ret, "wait timed out\n");
11231 CloseHandle(thread);
11232
11233 /* Overlapped, with a non-NULL event. */
11234
11235 params.client = client;
11236 params.event = event;
11237 thread = CreateThread(NULL, 0, nonblocking_async_recv_thread, &params, 0, NULL);
11238
11239 ret = WaitForSingleObject(thread, 200);
11240 ok(ret == WAIT_TIMEOUT, "expected timeout\n");
11241
11242 ret = send(server, "data", 4, 0);
11243 ok(ret == 4, "got %d\n", ret);
11244
11245 ret = WaitForSingleObject(thread, 200);
11246 ok(!ret, "wait timed out\n");
11247 CloseHandle(thread);
11248
11249 /* With data already in the pipe. */
11250
11251 ret = send(server, "data", 4, 0);
11252 ok(ret == 4, "got %d\n", ret);
11253
11254 memset(buffer, 0, sizeof(buffer));
11255 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
11256 ok(!ret, "got %d\n", ret);
11257 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
11258 ok(ret, "got error %u\n", GetLastError());
11259 ok(size == 4, "got size %u\n", size);
11260 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, size));
11261
11262 closesocket(client);
11263 closesocket(server);
11264
11265 CloseHandle(overlapped.hEvent);
11266 }
11267
11268 static void test_empty_recv(void)
11269 {
11270 OVERLAPPED overlapped = {0};
11271 SOCKET client, server;
11272 DWORD size, flags = 0;
11273 char buffer[5];
11274 WSABUF wsabuf;
11275 int ret;
11276
11277 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
11278 tcp_socketpair(&client, &server);
11279
11280 WSASetLastError(0xdeadbeef);
11281 ret = WSARecv(client, NULL, 0, NULL, &flags, &overlapped, NULL);
11282 ok(ret == -1, "expected failure\n");
11283 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
11284
11285 wsabuf.buf = buffer;
11286 wsabuf.len = 0;
11287 WSASetLastError(0xdeadbeef);
11288 ret = WSARecv(client, &wsabuf, 0, NULL, &flags, &overlapped, NULL);
11289 ok(ret == -1, "expected failure\n");
11290 todo_wine ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError());
11291
11292 WSASetLastError(0xdeadbeef);
11293 ret = WSARecv(client, &wsabuf, 1, NULL, &flags, &overlapped, NULL);
11294 ok(ret == -1, "expected failure\n");
11295 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
11296
11297 ret = send(server, "data", 5, 0);
11298 ok(ret == 5, "got %d\n", ret);
11299
11300 ret = WaitForSingleObject(overlapped.hEvent, 1000);
11301 ok(!ret, "wait failed\n");
11302 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
11303 ok(ret, "got error %u\n", GetLastError());
11304 ok(!size, "got size %u\n", size);
11305
11306 WSASetLastError(0xdeadbeef);
11307 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
11308 ok(!ret, "got error %u\n", WSAGetLastError());
11309 ok(!size, "got size %u\n", size);
11310
11311 ret = recv(client, NULL, 0, 0);
11312 ok(!ret, "got %d\n", ret);
11313
11314 ret = recv(client, buffer, sizeof(buffer), 0);
11315 ok(ret == 5, "got %d\n", ret);
11316 ok(!strcmp(buffer, "data"), "got %s\n", debugstr_an(buffer, ret));
11317
11318 closesocket(client);
11319 closesocket(server);
11320 CloseHandle(overlapped.hEvent);
11321 }
11322
11323 static void test_timeout(void)
11324 {
11325 DWORD timeout, flags = 0, size;
11326 OVERLAPPED overlapped = {0};
11327 SOCKET client, server;
11328 WSABUF wsabuf;
11329 int ret, len;
11330 char buffer;
11331
11332 tcp_socketpair(&client, &server);
11333 overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
11334
11335 timeout = 0xdeadbeef;
11336 len = sizeof(timeout);
11337 WSASetLastError(0xdeadbeef);
11338 ret = getsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, &len);
11339 ok(!ret, "expected success\n");
11340 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
11341 ok(len == sizeof(timeout), "got size %u\n", len);
11342 ok(!timeout, "got timeout %u\n", timeout);
11343
11344 timeout = 100;
11345 WSASetLastError(0xdeadbeef);
11346 ret = setsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
11347 ok(!ret, "expected success\n");
11348 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
11349
11350 timeout = 0xdeadbeef;
11351 len = sizeof(timeout);
11352 WSASetLastError(0xdeadbeef);
11353 ret = getsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, &len);
11354 ok(!ret, "expected success\n");
11355 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
11356 ok(timeout == 100, "got timeout %u\n", timeout);
11357
11358 WSASetLastError(0xdeadbeef);
11359 ret = recv(client, &buffer, 1, 0);
11360 ok(ret == -1, "got %d\n", ret);
11361 ok(WSAGetLastError() == WSAETIMEDOUT, "got error %u\n", WSAGetLastError());
11362
11363 wsabuf.buf = &buffer;
11364 wsabuf.len = 1;
11365 WSASetLastError(0xdeadbeef);
11366 size = 0xdeadbeef;
11367 ret = WSARecv(client, &wsabuf, 1, &size, &flags, NULL, NULL);
11368 ok(ret == -1, "got %d\n", ret);
11369 ok(WSAGetLastError() == WSAETIMEDOUT, "got error %u\n", WSAGetLastError());
11370 ok(size == 0xdeadbeef, "got size %u\n", size);
11371
11372 wsabuf.buf = &buffer;
11373 wsabuf.len = 1;
11374 WSASetLastError(0xdeadbeef);
11375 size = 0xdeadbeef;
11376 ret = WSARecv(client, &wsabuf, 1, &size, &flags, &overlapped, NULL);
11377 ok(ret == -1, "got %d\n", ret);
11378 ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError());
11379
11380 ret = WaitForSingleObject(overlapped.hEvent, 200);
11381 ok(ret == WAIT_TIMEOUT, "got %d\n", ret);
11382
11383 ret = send(server, "a", 1, 0);
11384 ok(ret == 1, "got %d\n", ret);
11385
11386 ret = WaitForSingleObject(overlapped.hEvent, 200);
11387 ok(!ret, "got %d\n", ret);
11388 ret = GetOverlappedResult((HANDLE)client, &overlapped, &size, FALSE);
11389 ok(ret, "got error %u\n", GetLastError());
11390 ok(size == 1, "got size %u\n", size);
11391
11392 closesocket(client);
11393 closesocket(server);
11394 CloseHandle(overlapped.hEvent);
11395 }
11396
11397 static void test_so_debug(void)
11398 {
11399 int ret, len;
11400 DWORD debug;
11401 SOCKET s;
11402
11403 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11404
11405 len = sizeof(debug);
11406 WSASetLastError(0xdeadbeef);
11407 debug = 0xdeadbeef;
11408 ret = getsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&debug, &len);
11409 ok(!ret, "got %d\n", ret);
11410 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
11411 ok(len == sizeof(debug), "got len %u\n", len);
11412 ok(!debug, "got debug %u\n", debug);
11413
11414 WSASetLastError(0xdeadbeef);
11415 debug = 2;
11416 ret = setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&debug, sizeof(debug));
11417 ok(!ret, "got %d\n", ret);
11418 todo_wine ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
11419
11420 len = sizeof(debug);
11421 WSASetLastError(0xdeadbeef);
11422 debug = 0xdeadbeef;
11423 ret = getsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&debug, &len);
11424 ok(!ret, "got %d\n", ret);
11425 ok(!WSAGetLastError(), "got error %u\n", WSAGetLastError());
11426 ok(len == sizeof(debug), "got len %u\n", len);
11427 todo_wine ok(debug == 1, "got debug %u\n", debug);
11428
11429 closesocket(s);
11430 }
11431
11432 struct sockopt_validity_test
11433 {
11434 int opt;
11435 int get_error;
11436 int set_error;
11437 BOOL todo;
11438 };
11439
11440 static void do_sockopt_validity_tests(const char *type, SOCKET sock, int level,
11441 const struct sockopt_validity_test *tests)
11442 {
11443 char value[256];
11444 int count, rc, expected_rc, i;
11445
11446 for (i = 0; tests[i].opt; i++)
11447 {
11448 winetest_push_context("%s option %i", type, tests[i].opt);
11449 memset(value, 0, sizeof(value));
11450 count = sizeof(value);
11451
11452 WSASetLastError(0);
11453 rc = getsockopt(sock, level, tests[i].opt, value, &count);
11454 expected_rc = tests[i].get_error ? SOCKET_ERROR : 0;
11455 todo_wine_if(!tests[i].get_error && tests[i].todo)
11456 ok(rc == expected_rc || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
11457 "expected getsockopt to return %i, got %i\n", expected_rc, rc);
11458 todo_wine_if(tests[i].todo)
11459 ok(WSAGetLastError() == tests[i].get_error || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
11460 "expected getsockopt to set error %i, got %i\n", tests[i].get_error, WSAGetLastError());
11461
11462 if (tests[i].get_error)
11463 {
11464 winetest_pop_context();
11465 continue;
11466 }
11467
11468 WSASetLastError(0);
11469 rc = setsockopt(sock, level, tests[i].opt, value, count);
11470 expected_rc = tests[i].set_error ? SOCKET_ERROR : 0;
11471 todo_wine_if(!tests[i].set_error && tests[i].todo)
11472 ok(rc == expected_rc || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
11473 "expected setsockopt to return %i, got %i\n", expected_rc, rc);
11474 todo_wine_if(tests[i].todo)
11475 ok(WSAGetLastError() == tests[i].set_error || broken(rc == SOCKET_ERROR && WSAGetLastError() == WSAENOPROTOOPT),
11476 "expected setsockopt to set error %i, got %i\n", tests[i].set_error, WSAGetLastError());
11477
11478 winetest_pop_context();
11479 }
11480 }
11481
11482 static void test_sockopt_validity(void)
11483 {
11484 static const struct sockopt_validity_test ipv4_tcp_tests[] =
11485 {
11486 { -1, WSAENOPROTOOPT },
11487 { IP_OPTIONS },
11488 { IP_HDRINCL, WSAEINVAL },
11489 { IP_TOS },
11490 { IP_TTL },
11491 { IP_MULTICAST_IF, WSAEINVAL },
11492 { IP_MULTICAST_TTL, WSAEINVAL },
11493 { IP_MULTICAST_LOOP, WSAEINVAL },
11494 { IP_ADD_MEMBERSHIP, WSAENOPROTOOPT },
11495 { IP_DROP_MEMBERSHIP, WSAENOPROTOOPT },
11496 { IP_DONTFRAGMENT },
11497 { IP_PKTINFO, WSAEINVAL },
11498 { IP_RECVTTL, WSAEINVAL, 0, TRUE },
11499 { IP_RECEIVE_BROADCAST, WSAEINVAL, 0, TRUE },
11500 { IP_RECVIF, WSAEINVAL, 0, TRUE },
11501 { IP_RECVDSTADDR, WSAEINVAL, 0, TRUE },
11502 { IP_IFLIST, 0, 0, TRUE },
11503 { IP_UNICAST_IF },
11504 { IP_RTHDR, 0, 0, TRUE },
11505 { IP_GET_IFLIST, WSAEINVAL, 0, TRUE },
11506 { IP_RECVRTHDR, WSAEINVAL, 0, TRUE },
11507 { IP_RECVTCLASS, WSAEINVAL, 0, TRUE },
11508 { IP_ORIGINAL_ARRIVAL_IF, WSAEINVAL, 0, TRUE },
11509 { IP_ECN, WSAEINVAL, 0, TRUE },
11510 { IP_PKTINFO_EX, WSAEINVAL, 0, TRUE },
11511 { IP_WFP_REDIRECT_RECORDS, WSAEINVAL, 0, TRUE },
11512 { IP_WFP_REDIRECT_CONTEXT, WSAEINVAL, 0, TRUE },
11513 { IP_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
11514 { IP_MTU, WSAENOTCONN, 0, TRUE },
11515 { IP_RECVERR, WSAEINVAL, 0, TRUE },
11516 { IP_USER_MTU, 0, 0, TRUE },
11517 {}
11518 };
11519 static const struct sockopt_validity_test ipv4_udp_tests[] =
11520 {
11521 { -1, WSAENOPROTOOPT },
11522 { IP_OPTIONS },
11523 { IP_HDRINCL, WSAEINVAL },
11524 { IP_TOS },
11525 { IP_TTL },
11526 { IP_MULTICAST_IF },
11527 { IP_MULTICAST_TTL },
11528 { IP_MULTICAST_LOOP },
11529 { IP_ADD_MEMBERSHIP, WSAENOPROTOOPT },
11530 { IP_DROP_MEMBERSHIP, WSAENOPROTOOPT },
11531 { IP_DONTFRAGMENT },
11532 { IP_PKTINFO },
11533 { IP_RECVTTL, 0, 0, TRUE },
11534 { IP_RECEIVE_BROADCAST, 0, 0, TRUE },
11535 { IP_RECVIF, 0, 0, TRUE },
11536 { IP_RECVDSTADDR, 0, 0, TRUE },
11537 { IP_IFLIST, 0, 0, TRUE },
11538 { IP_UNICAST_IF },
11539 { IP_RTHDR, 0, 0, TRUE },
11540 { IP_GET_IFLIST, WSAEINVAL, 0, TRUE },
11541 { IP_RECVRTHDR, 0, 0, TRUE },
11542 { IP_RECVTCLASS, 0, 0, TRUE },
11543 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
11544 { IP_ECN, 0, 0, TRUE },
11545 { IP_PKTINFO_EX, 0, 0, TRUE },
11546 { IP_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
11547 { IP_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
11548 { IP_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
11549 { IP_MTU, WSAENOTCONN, 0, TRUE },
11550 { IP_RECVERR, 0, 0, TRUE },
11551 { IP_USER_MTU, 0, 0, TRUE },
11552 {}
11553 };
11554 static const struct sockopt_validity_test ipv4_raw_tests[] =
11555 {
11556 { -1, WSAENOPROTOOPT },
11557 { IP_OPTIONS },
11558 { IP_HDRINCL, },
11559 { IP_TOS },
11560 { IP_TTL },
11561 { IP_MULTICAST_IF },
11562 { IP_MULTICAST_TTL },
11563 { IP_MULTICAST_LOOP },
11564 { IP_ADD_MEMBERSHIP, WSAENOPROTOOPT },
11565 { IP_DROP_MEMBERSHIP, WSAENOPROTOOPT },
11566 { IP_DONTFRAGMENT },
11567 { IP_PKTINFO },
11568 { IP_RECVTTL, 0, 0, TRUE },
11569 { IP_RECEIVE_BROADCAST, 0, 0, TRUE },
11570 { IP_RECVIF, 0, 0, TRUE },
11571 { IP_RECVDSTADDR, 0, 0, TRUE },
11572 { IP_IFLIST, 0, 0, TRUE },
11573 { IP_UNICAST_IF },
11574 { IP_RTHDR, 0, 0, TRUE },
11575 { IP_GET_IFLIST, WSAEINVAL, 0, TRUE },
11576 { IP_RECVRTHDR, 0, 0, TRUE },
11577 { IP_RECVTCLASS, 0, 0, TRUE },
11578 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
11579 { IP_ECN, 0, 0, TRUE },
11580 { IP_PKTINFO_EX, 0, 0, TRUE },
11581 { IP_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
11582 { IP_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
11583 { IP_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
11584 { IP_MTU, WSAENOTCONN, 0, TRUE },
11585 { IP_RECVERR, WSAEINVAL, 0, TRUE },
11586 { IP_USER_MTU, 0, 0, TRUE },
11587 {}
11588 };
11589 static const struct sockopt_validity_test ipv6_tcp_tests[] =
11590 {
11591 { -1, WSAENOPROTOOPT },
11592 { IPV6_HOPOPTS, 0, 0, TRUE },
11593 { IPV6_HDRINCL, WSAEINVAL, 0, TRUE },
11594 { IPV6_UNICAST_HOPS },
11595 { IPV6_MULTICAST_IF, WSAEINVAL },
11596 { IPV6_MULTICAST_HOPS, WSAEINVAL },
11597 { IPV6_MULTICAST_LOOP, WSAEINVAL },
11598 { IPV6_ADD_MEMBERSHIP, WSAENOPROTOOPT },
11599 { IPV6_DROP_MEMBERSHIP, WSAENOPROTOOPT },
11600 { IPV6_DONTFRAG },
11601 { IPV6_PKTINFO, WSAEINVAL },
11602 { IPV6_HOPLIMIT, WSAEINVAL },
11603 { IPV6_PROTECTION_LEVEL },
11604 { IPV6_RECVIF, WSAEINVAL, 0, TRUE },
11605 { IPV6_RECVDSTADDR, WSAEINVAL, 0, TRUE },
11606 { IPV6_V6ONLY },
11607 { IPV6_IFLIST, 0, 0, TRUE },
11608 { IPV6_UNICAST_IF },
11609 { IPV6_RTHDR, 0, 0, TRUE },
11610 { IPV6_GET_IFLIST, WSAEINVAL, 0, TRUE },
11611 { IPV6_RECVRTHDR, WSAEINVAL, 0, TRUE },
11612 { IPV6_RECVTCLASS, WSAEINVAL },
11613 { IP_ORIGINAL_ARRIVAL_IF, WSAEINVAL, 0, TRUE },
11614 { IPV6_ECN, WSAEINVAL, 0, TRUE },
11615 { IPV6_PKTINFO_EX, WSAEINVAL, 0, TRUE },
11616 { IPV6_WFP_REDIRECT_RECORDS, WSAEINVAL, 0, TRUE },
11617 { IPV6_WFP_REDIRECT_CONTEXT, WSAEINVAL, 0, TRUE },
11618 { IPV6_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
11619 { IPV6_MTU, WSAENOTCONN, 0, TRUE },
11620 { IPV6_RECVERR, WSAEINVAL, 0, TRUE },
11621 { IPV6_USER_MTU, 0, 0, TRUE },
11622 {}
11623 };
11624 static const struct sockopt_validity_test ipv6_udp_tests[] =
11625 {
11626 { -1, WSAENOPROTOOPT },
11627 { IPV6_HOPOPTS, 0, 0, TRUE },
11628 { IPV6_HDRINCL, WSAEINVAL, 0, TRUE },
11629 { IPV6_UNICAST_HOPS },
11630 { IPV6_MULTICAST_IF },
11631 { IPV6_MULTICAST_HOPS },
11632 { IPV6_MULTICAST_LOOP },
11633 { IPV6_ADD_MEMBERSHIP, WSAENOPROTOOPT },
11634 { IPV6_DROP_MEMBERSHIP, WSAENOPROTOOPT },
11635 { IPV6_DONTFRAG },
11636 { IPV6_PKTINFO },
11637 { IPV6_HOPLIMIT },
11638 { IPV6_PROTECTION_LEVEL },
11639 { IPV6_RECVIF, 0, 0, TRUE },
11640 { IPV6_RECVDSTADDR, 0, 0, TRUE },
11641 { IPV6_V6ONLY },
11642 { IPV6_IFLIST, 0, 0, TRUE },
11643 { IPV6_UNICAST_IF },
11644 { IPV6_RTHDR, 0, 0, TRUE },
11645 { IPV6_GET_IFLIST, WSAEINVAL, 0, TRUE },
11646 { IPV6_RECVRTHDR, 0, 0, TRUE },
11647 { IPV6_RECVTCLASS },
11648 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
11649 { IPV6_ECN, 0, 0, TRUE },
11650 { IPV6_PKTINFO_EX, 0, 0, TRUE },
11651 { IPV6_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
11652 { IPV6_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
11653 { IPV6_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
11654 { IPV6_MTU, WSAENOTCONN, 0, TRUE },
11655 { IPV6_RECVERR, 0, 0, TRUE },
11656 { IPV6_USER_MTU, 0, 0, TRUE },
11657 {}
11658 };
11659 static const struct sockopt_validity_test ipv6_raw_tests[] =
11660 {
11661 { -1, WSAENOPROTOOPT },
11662 { IPV6_HOPOPTS, 0, 0, TRUE },
11663 { IPV6_HDRINCL, 0, 0, TRUE },
11664 { IPV6_UNICAST_HOPS },
11665 { IPV6_MULTICAST_IF },
11666 { IPV6_MULTICAST_HOPS },
11667 { IPV6_MULTICAST_LOOP },
11668 { IPV6_ADD_MEMBERSHIP, WSAENOPROTOOPT },
11669 { IPV6_DROP_MEMBERSHIP, WSAENOPROTOOPT },
11670 { IPV6_DONTFRAG },
11671 { IPV6_PKTINFO },
11672 { IPV6_HOPLIMIT },
11673 { IPV6_PROTECTION_LEVEL },
11674 { IPV6_RECVIF, 0, 0, TRUE },
11675 { IPV6_RECVDSTADDR, 0, 0, TRUE },
11676 { IPV6_V6ONLY },
11677 { IPV6_IFLIST, 0, 0, TRUE },
11678 { IPV6_UNICAST_IF },
11679 { IPV6_RTHDR, 0, 0, TRUE },
11680 { IPV6_GET_IFLIST, WSAEINVAL, 0, TRUE },
11681 { IPV6_RECVRTHDR, 0, 0, TRUE },
11682 { IPV6_RECVTCLASS },
11683 { IP_ORIGINAL_ARRIVAL_IF, 0, 0, TRUE },
11684 { IPV6_ECN, 0, 0, TRUE },
11685 { IPV6_PKTINFO_EX, 0, 0, TRUE },
11686 { IPV6_WFP_REDIRECT_RECORDS, 0, 0, TRUE },
11687 { IPV6_WFP_REDIRECT_CONTEXT, 0, 0, TRUE },
11688 { IPV6_MTU_DISCOVER, 0, WSAEINVAL, TRUE },
11689 { IPV6_MTU, WSAENOTCONN, 0, TRUE },
11690 { IPV6_RECVERR, WSAEINVAL, 0, TRUE },
11691 { IPV6_USER_MTU, 0, 0, TRUE },
11692 {}
11693 };
11694 static const struct sockopt_validity_test file_handle_tests[] =
11695 {
11696 { -1, WSAENOTSOCK, 0, TRUE },
11697 { SO_TYPE, WSAENOTSOCK, 0, TRUE },
11698 { SO_OPENTYPE },
11699 {}
11700 };
11701 char path[MAX_PATH];
11702 HANDLE file;
11703 SOCKET sock;
11704
11705 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
11706 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
11707 do_sockopt_validity_tests("IPv4 TCP", sock, IPPROTO_IP, ipv4_tcp_tests);
11708 closesocket(sock);
11709
11710 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
11711 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
11712 do_sockopt_validity_tests("IPv4 UDP", sock, IPPROTO_IP, ipv4_udp_tests);
11713 closesocket(sock);
11714
11715 sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
11716 if (sock == INVALID_SOCKET && WSAGetLastError() == WSAEACCES)
11717 {
11718 skip("Raw IPv4 sockets are not available\n");
11719 }
11720 else
11721 {
11722 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
11723 do_sockopt_validity_tests("IPv4 raw", sock, IPPROTO_IP, ipv4_raw_tests);
11724 closesocket(sock);
11725 }
11726
11727 sock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
11728 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
11729 do_sockopt_validity_tests("IPv6 TCP", sock, IPPROTO_IPV6, ipv6_tcp_tests);
11730 closesocket(sock);
11731
11732 sock = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
11733 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
11734 do_sockopt_validity_tests("IPv6 UDP", sock, IPPROTO_IPV6, ipv6_udp_tests);
11735 closesocket(sock);
11736
11737 sock = socket(AF_INET6, SOCK_RAW, IPPROTO_RAW);
11738 if (sock == INVALID_SOCKET && WSAGetLastError() == WSAEACCES)
11739 {
11740 skip("Raw IPv6 sockets are not available\n");
11741 }
11742 else
11743 {
11744 ok(sock != INVALID_SOCKET, "failed to create socket, error %u\n", WSAGetLastError());
11745 do_sockopt_validity_tests("IPv6 raw", sock, IPPROTO_IPV6, ipv6_raw_tests);
11746 closesocket(sock);
11747 }
11748
11749 GetSystemWindowsDirectoryA(path, ARRAY_SIZE(path));
11750 strcat(path, "\\system.ini");
11751 file = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0x0, NULL);
11752 do_sockopt_validity_tests("file", (SOCKET)file, SOL_SOCKET, file_handle_tests);
11753 CloseHandle(file);
11754 }
11755
11756 START_TEST( sock )
11757 {
11758 int i;
11759
11760 /* Leave these tests at the beginning. They depend on WSAStartup not having been
11761 * called, which is done by Init() below. */
11762 test_WithoutWSAStartup();
11763 test_WithWSAStartup();
11764
11765 Init();
11766
11767 test_set_getsockopt();
11768 test_so_reuseaddr();
11769 test_ip_pktinfo();
11770 test_ipv6_cmsg();
11771 test_extendedSocketOptions();
11772 test_so_debug();
11773 test_sockopt_validity();
11774
11775 for (i = 0; i < ARRAY_SIZE(tests); i++)
11776 do_test(&tests[i]);
11777
11778 test_UDP();
11779
11780 test_WSASocket();
11781 test_WSADuplicateSocket();
11782 test_WSAEnumNetworkEvents();
11783
11784 test_errors();
11785 test_listen();
11786 test_select();
11787 test_accept();
11788 test_getpeername();
11789 test_getsockname();
11790
11791 test_address_list_query();
11792 test_fionbio();
11793 test_fionread_siocatmark();
11794 test_get_extension_func();
11795 test_get_interface_list();
11796 test_keepalive_vals();
11797 test_sioRoutingInterfaceQuery();
11798 test_sioAddressListChange();
11799 test_base_handle();
11800 test_unsupported_ioctls();
11801
11802 test_WSASendMsg();
11803 test_WSASendTo();
11804 test_WSARecv();
11805 test_WSAPoll();
11806 test_write_watch();
11807 test_iocp();
11808
11809 test_events();
11810
11811 test_ipv6only();
11812 test_TransmitFile();
11813 test_AcceptEx();
11814 test_connect();
11815 test_shutdown();
11816 test_DisconnectEx();
11817
11818 test_completion_port();
11819 test_connect_completion_port();
11820 test_shutdown_completion_port();
11821 test_bind();
11822 test_connecting_socket();
11823 test_WSAGetOverlappedResult();
11824 test_nonblocking_async_recv();
11825 test_empty_recv();
11826 test_timeout();
11827
11828 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
11829 test_send();
11830
11831 Exit();
11832 }
Windows API implementation