?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ws2_32: Don't set output length in WSAStringToAddress on error.
[wine.git] / dlls / ws2_32 / tests / sock.c
blobc72dc7a77a1c8f8d2b88d49b8594b49e82fe08a7
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 <ws2tcpip.h>
30 #include <ws2spi.h>
31 #include <wsipx.h>
32 #include <wsnwlink.h>
33 #include <mswsock.h>
34 #include <mstcpip.h>
35 #include <iphlpapi.h>
36 #include <stdio.h>
37 #include "wine/test.h"
38
39 #define MAX_CLIENTS 4 /* Max number of clients */
40 #define FIRST_CHAR 'A' /* First character in transferred pattern */
41 #define BIND_SLEEP 10 /* seconds to wait between attempts to bind() */
42 #define BIND_TRIES 6 /* Number of bind() attempts */
43 #define TEST_TIMEOUT 30 /* seconds to wait before killing child threads
44 after server initialization, if something hangs */
45
46 #define NUM_UDP_PEERS 3 /* Number of UDP sockets to create and test > 1 */
47
48 #define NUM_THREADS 3 /* Number of threads to run getservbyname */
49 #define NUM_QUERIES 250 /* Number of getservbyname queries per thread */
50
51 #define SERVERIP "127.0.0.1" /* IP to bind to */
52 #define SERVERPORT 9374 /* Port number to bind to */
53
54 #define wsa_ok(op, cond, msg) \
55 do { \
56 int tmp, err = 0; \
57 tmp = op; \
58 if ( !(cond tmp) ) err = WSAGetLastError(); \
59 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
60 } while (0);
61
62 #define make_keepalive(k, enable, time, interval) \
63 k.onoff = enable; \
64 k.keepalivetime = time; \
65 k.keepaliveinterval = interval;
66
67 /* Function pointers */
68 static void (WINAPI *pfreeaddrinfo)(struct addrinfo *);
69 static int (WINAPI *pgetaddrinfo)(LPCSTR,LPCSTR,const struct addrinfo *,struct addrinfo **);
70 static void (WINAPI *pFreeAddrInfoW)(PADDRINFOW);
71 static void (WINAPI *pFreeAddrInfoExW)(ADDRINFOEXW *ai);
72 static int (WINAPI *pGetAddrInfoW)(LPCWSTR,LPCWSTR,const ADDRINFOW *,PADDRINFOW *);
73 static int (WINAPI *pGetAddrInfoExW)(const WCHAR *name, const WCHAR *servname, DWORD namespace,
74 GUID *namespace_id, const ADDRINFOEXW *hints, ADDRINFOEXW **result,
75 struct timeval *timeout, OVERLAPPED *overlapped,
76 LPLOOKUPSERVICE_COMPLETION_ROUTINE completion_routine, HANDLE *handle);
77 static int (WINAPI *pGetAddrInfoExOverlappedResult)(OVERLAPPED *overlapped);
78 static PCSTR (WINAPI *pInetNtop)(INT,LPVOID,LPSTR,ULONG);
79 static PCWSTR(WINAPI *pInetNtopW)(INT,LPVOID,LPWSTR,ULONG);
80 static int (WINAPI *pInetPtonA)(INT,LPCSTR,LPVOID);
81 static int (WINAPI *pInetPtonW)(INT,LPWSTR,LPVOID);
82 static int (WINAPI *pWSALookupServiceBeginW)(LPWSAQUERYSETW,DWORD,LPHANDLE);
83 static int (WINAPI *pWSALookupServiceEnd)(HANDLE);
84 static int (WINAPI *pWSALookupServiceNextW)(HANDLE,DWORD,LPDWORD,LPWSAQUERYSETW);
85 static int (WINAPI *pWSAEnumNameSpaceProvidersA)(LPDWORD,LPWSANAMESPACE_INFOA);
86 static int (WINAPI *pWSAEnumNameSpaceProvidersW)(LPDWORD,LPWSANAMESPACE_INFOW);
87 static int (WINAPI *pWSAPoll)(WSAPOLLFD *,ULONG,INT);
88 static int (WINAPI *pWSCGetProviderInfo)(LPGUID,WSC_PROVIDER_INFO_TYPE,PBYTE,size_t*,DWORD,LPINT);
89
90 /* Function pointers from iphlpapi */
91 static DWORD (WINAPI *pGetAdaptersInfo)(PIP_ADAPTER_INFO,PULONG);
92 static DWORD (WINAPI *pGetIpForwardTable)(PMIB_IPFORWARDTABLE,PULONG,BOOL);
93
94 /* Function pointers from ntdll */
95 static DWORD (WINAPI *pNtClose)(HANDLE);
96
97 /**************** Structs and typedefs ***************/
98
99 typedef struct thread_info
100 {
101 HANDLE thread;
102 DWORD id;
103 } thread_info;
104
105 /* Information in the server about open client connections */
106 typedef struct sock_info
107 {
108 SOCKET s;
109 struct sockaddr_in addr;
110 struct sockaddr_in peer;
111 char *buf;
112 int n_recvd;
113 int n_sent;
114 } sock_info;
115
116 /* Test parameters for both server & client */
117 typedef struct test_params
118 {
119 int sock_type;
120 int sock_prot;
121 const char *inet_addr;
122 short inet_port;
123 int chunk_size;
124 int n_chunks;
125 int n_clients;
126 } test_params;
127
128 /* server-specific test parameters */
129 typedef struct server_params
130 {
131 test_params *general;
132 DWORD sock_flags;
133 int buflen;
134 } server_params;
135
136 /* client-specific test parameters */
137 typedef struct client_params
138 {
139 test_params *general;
140 DWORD sock_flags;
141 int buflen;
142 } client_params;
143
144 /* This type combines all information for setting up a test scenario */
145 typedef struct test_setup
146 {
147 test_params general;
148 LPVOID srv;
149 server_params srv_params;
150 LPVOID clt;
151 client_params clt_params;
152 } test_setup;
153
154 /* Thread local storage for server */
155 typedef struct server_memory
156 {
157 SOCKET s;
158 struct sockaddr_in addr;
159 sock_info sock[MAX_CLIENTS];
160 } server_memory;
161
162 /* Thread local storage for client */
163 typedef struct client_memory
164 {
165 SOCKET s;
166 struct sockaddr_in addr;
167 char *send_buf;
168 char *recv_buf;
169 } client_memory;
170
171 /* SelectReadThread thread parameters */
172 typedef struct select_thread_params
173 {
174 SOCKET s;
175 BOOL ReadKilled;
176 } select_thread_params;
177
178 /* Tests used in both getaddrinfo and GetAddrInfoW */
179 static const struct addr_hint_tests
180 {
181 int family, socktype, protocol;
182 DWORD error;
183 } hinttests[] = {
184 {AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, 0 },
185 {AF_UNSPEC, SOCK_STREAM, IPPROTO_UDP, 0 },
186 {AF_UNSPEC, SOCK_STREAM, IPPROTO_IPV6,0 },
187 {AF_UNSPEC, SOCK_DGRAM, IPPROTO_TCP, 0 },
188 {AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP, 0 },
189 {AF_UNSPEC, SOCK_DGRAM, IPPROTO_IPV6,0 },
190 {AF_INET, SOCK_STREAM, IPPROTO_TCP, 0 },
191 {AF_INET, SOCK_STREAM, IPPROTO_UDP, 0 },
192 {AF_INET, SOCK_STREAM, IPPROTO_IPV6,0 },
193 {AF_INET, SOCK_DGRAM, IPPROTO_TCP, 0 },
194 {AF_INET, SOCK_DGRAM, IPPROTO_UDP, 0 },
195 {AF_INET, SOCK_DGRAM, IPPROTO_IPV6,0 },
196 {AF_UNSPEC, 0, IPPROTO_TCP, 0 },
197 {AF_UNSPEC, 0, IPPROTO_UDP, 0 },
198 {AF_UNSPEC, 0, IPPROTO_IPV6,0 },
199 {AF_UNSPEC, SOCK_STREAM, 0, 0 },
200 {AF_UNSPEC, SOCK_DGRAM, 0, 0 },
201 {AF_INET, 0, IPPROTO_TCP, 0 },
202 {AF_INET, 0, IPPROTO_UDP, 0 },
203 {AF_INET, 0, IPPROTO_IPV6,0 },
204 {AF_INET, SOCK_STREAM, 0, 0 },
205 {AF_INET, SOCK_DGRAM, 0, 0 },
206 {AF_UNSPEC, 999, IPPROTO_TCP, WSAESOCKTNOSUPPORT },
207 {AF_UNSPEC, 999, IPPROTO_UDP, WSAESOCKTNOSUPPORT },
208 {AF_UNSPEC, 999, IPPROTO_IPV6,WSAESOCKTNOSUPPORT },
209 {AF_INET, 999, IPPROTO_TCP, WSAESOCKTNOSUPPORT },
210 {AF_INET, 999, IPPROTO_UDP, WSAESOCKTNOSUPPORT },
211 {AF_INET, 999, IPPROTO_IPV6,WSAESOCKTNOSUPPORT },
212 {AF_UNSPEC, SOCK_STREAM, 999, 0 },
213 {AF_UNSPEC, SOCK_STREAM, 999, 0 },
214 {AF_INET, SOCK_DGRAM, 999, 0 },
215 {AF_INET, SOCK_DGRAM, 999, 0 },
216 };
217
218 /**************** Static variables ***************/
219
220 static DWORD tls; /* Thread local storage index */
221 static HANDLE thread[1+MAX_CLIENTS];
222 static DWORD thread_id[1+MAX_CLIENTS];
223 static HANDLE server_ready;
224 static HANDLE client_ready[MAX_CLIENTS];
225 static int client_id;
226
227 /**************** General utility functions ***************/
228
229 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len);
230 static SOCKET setup_connector_socket(struct sockaddr_in *addr, int len, BOOL nonblock);
231
232 static int tcp_socketpair(SOCKET *src, SOCKET *dst)
233 {
234 SOCKET server = INVALID_SOCKET;
235 struct sockaddr_in addr;
236 int len;
237 int ret;
238
239 *src = INVALID_SOCKET;
240 *dst = INVALID_SOCKET;
241
242 *src = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
243 if (*src == INVALID_SOCKET)
244 goto end;
245
246 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
247 if (server == INVALID_SOCKET)
248 goto end;
249
250 memset(&addr, 0, sizeof(addr));
251 addr.sin_family = AF_INET;
252 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
253 ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
254 if (ret != 0)
255 goto end;
256
257 len = sizeof(addr);
258 ret = getsockname(server, (struct sockaddr*)&addr, &len);
259 if (ret != 0)
260 goto end;
261
262 ret = listen(server, 1);
263 if (ret != 0)
264 goto end;
265
266 ret = connect(*src, (struct sockaddr*)&addr, sizeof(addr));
267 if (ret != 0)
268 goto end;
269
270 len = sizeof(addr);
271 *dst = accept(server, (struct sockaddr*)&addr, &len);
272
273 end:
274 if (server != INVALID_SOCKET)
275 closesocket(server);
276 if (*src != INVALID_SOCKET && *dst != INVALID_SOCKET)
277 return 0;
278 closesocket(*src);
279 closesocket(*dst);
280 return -1;
281 }
282
283 static int tcp_socketpair_ovl(SOCKET *src, SOCKET *dst)
284 {
285 SOCKET server = INVALID_SOCKET;
286 struct sockaddr_in addr;
287 int len, ret;
288
289 *src = INVALID_SOCKET;
290 *dst = INVALID_SOCKET;
291
292 *src = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
293 if (*src == INVALID_SOCKET)
294 goto end;
295
296 server = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
297 if (server == INVALID_SOCKET)
298 goto end;
299
300 memset(&addr, 0, sizeof(addr));
301 addr.sin_family = AF_INET;
302 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
303 ret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
304 if (ret != 0)
305 goto end;
306
307 len = sizeof(addr);
308 ret = getsockname(server, (struct sockaddr *)&addr, &len);
309 if (ret != 0)
310 goto end;
311
312 ret = listen(server, 1);
313 if (ret != 0)
314 goto end;
315
316 ret = connect(*src, (struct sockaddr *)&addr, sizeof(addr));
317 if (ret != 0)
318 goto end;
319
320 len = sizeof(addr);
321 *dst = accept(server, (struct sockaddr *)&addr, &len);
322
323 end:
324 if (server != INVALID_SOCKET)
325 closesocket(server);
326 if (*src != INVALID_SOCKET && *dst != INVALID_SOCKET)
327 return 0;
328 closesocket(*src);
329 closesocket(*dst);
330 return -1;
331 }
332
333 static void set_so_opentype ( BOOL overlapped )
334 {
335 int optval = !overlapped, newval, len = sizeof (int);
336
337 ok ( setsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
338 (LPVOID) &optval, sizeof (optval) ) == 0,
339 "setting SO_OPENTYPE failed\n" );
340 ok ( getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
341 (LPVOID) &newval, &len ) == 0,
342 "getting SO_OPENTYPE failed\n" );
343 ok ( optval == newval, "failed to set SO_OPENTYPE\n" );
344 }
345
346 static int set_blocking ( SOCKET s, BOOL blocking )
347 {
348 u_long val = !blocking;
349 return ioctlsocket ( s, FIONBIO, &val );
350 }
351
352 static void fill_buffer ( char *buf, int chunk_size, int n_chunks )
353 {
354 char c, *p;
355 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
356 memset ( p, c, chunk_size );
357 }
358
359 static int test_buffer ( char *buf, int chunk_size, int n_chunks )
360 {
361 char c, *p;
362 int i;
363 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
364 {
365 for ( i = 0; i < chunk_size; i++ )
366 if ( p[i] != c ) return i;
367 }
368 return -1;
369 }
370
371 /*
372 * This routine is called when a client / server does not expect any more data,
373 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
374 */
375 static void read_zero_bytes ( SOCKET s )
376 {
377 char buf[256];
378 int tmp, n = 0;
379 while ( ( tmp = recv ( s, buf, 256, 0 ) ) > 0 )
380 n += tmp;
381 ok ( n <= 0, "garbage data received: %d bytes\n", n );
382 }
383
384 static int do_synchronous_send ( SOCKET s, char *buf, int buflen, int flags, int sendlen )
385 {
386 char* last = buf + buflen, *p;
387 int n = 1;
388 for ( p = buf; n > 0 && p < last; )
389 {
390 n = send ( s, p, min ( sendlen, last - p ), flags );
391 if (n > 0) p += n;
392 }
393 wsa_ok ( n, 0 <=, "do_synchronous_send (%x): error %d\n" );
394 return p - buf;
395 }
396
397 static int do_synchronous_recv ( SOCKET s, char *buf, int buflen, int flags, int recvlen )
398 {
399 char* last = buf + buflen, *p;
400 int n = 1;
401 for ( p = buf; n > 0 && p < last; )
402 {
403 n = recv ( s, p, min ( recvlen, last - p ), flags );
404 if (n > 0) p += n;
405 }
406 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
407 return p - buf;
408 }
409
410 static int do_synchronous_recvfrom ( SOCKET s, char *buf, int buflen, int flags, struct sockaddr *from, int *fromlen, int recvlen )
411 {
412 char* last = buf + buflen, *p;
413 int n = 1;
414 for ( p = buf; n > 0 && p < last; )
415 {
416 n = recvfrom ( s, p, min ( recvlen, last - p ), flags, from, fromlen );
417 if (n > 0) p += n;
418 }
419 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
420 return p - buf;
421 }
422
423 /*
424 * Call this routine right after thread startup.
425 * SO_OPENTYPE must by 0, regardless what the server did.
426 */
427 static void check_so_opentype (void)
428 {
429 int tmp = 1, len;
430 len = sizeof (tmp);
431 getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (LPVOID) &tmp, &len );
432 ok ( tmp == 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp );
433 }
434
435 static void compare_addrinfo (ADDRINFO *a, ADDRINFO *b)
436 {
437 for (; a && b ; a = a->ai_next, b = b->ai_next)
438 {
439 ok(a->ai_flags == b->ai_flags,
440 "Wrong flags %d != %d\n", a->ai_flags, b->ai_flags);
441 ok(a->ai_family == b->ai_family,
442 "Wrong family %d != %d\n", a->ai_family, b->ai_family);
443 ok(a->ai_socktype == b->ai_socktype,
444 "Wrong socktype %d != %d\n", a->ai_socktype, b->ai_socktype);
445 ok(a->ai_protocol == b->ai_protocol,
446 "Wrong protocol %d != %d\n", a->ai_protocol, b->ai_protocol);
447 ok(a->ai_addrlen == b->ai_addrlen,
448 "Wrong addrlen %lu != %lu\n", a->ai_addrlen, b->ai_addrlen);
449 ok(!memcmp(a->ai_addr, b->ai_addr, min(a->ai_addrlen, b->ai_addrlen)),
450 "Wrong address data\n");
451 if (a->ai_canonname && b->ai_canonname)
452 {
453 ok(!strcmp(a->ai_canonname, b->ai_canonname), "Wrong canonical name '%s' != '%s'\n",
454 a->ai_canonname, b->ai_canonname);
455 }
456 else
457 ok(!a->ai_canonname && !b->ai_canonname, "Expected both names absent (%p != %p)\n",
458 a->ai_canonname, b->ai_canonname);
459 }
460 ok(!a && !b, "Expected both addresses null (%p != %p)\n", a, b);
461 }
462
463 static void compare_addrinfow (ADDRINFOW *a, ADDRINFOW *b)
464 {
465 for (; a && b ; a = a->ai_next, b = b->ai_next)
466 {
467 ok(a->ai_flags == b->ai_flags,
468 "Wrong flags %d != %d\n", a->ai_flags, b->ai_flags);
469 ok(a->ai_family == b->ai_family,
470 "Wrong family %d != %d\n", a->ai_family, b->ai_family);
471 ok(a->ai_socktype == b->ai_socktype,
472 "Wrong socktype %d != %d\n", a->ai_socktype, b->ai_socktype);
473 ok(a->ai_protocol == b->ai_protocol,
474 "Wrong protocol %d != %d\n", a->ai_protocol, b->ai_protocol);
475 ok(a->ai_addrlen == b->ai_addrlen,
476 "Wrong addrlen %lu != %lu\n", a->ai_addrlen, b->ai_addrlen);
477 ok(!memcmp(a->ai_addr, b->ai_addr, min(a->ai_addrlen, b->ai_addrlen)),
478 "Wrong address data\n");
479 if (a->ai_canonname && b->ai_canonname)
480 {
481 ok(!lstrcmpW(a->ai_canonname, b->ai_canonname), "Wrong canonical name '%s' != '%s'\n",
482 wine_dbgstr_w(a->ai_canonname), wine_dbgstr_w(b->ai_canonname));
483 }
484 else
485 ok(!a->ai_canonname && !b->ai_canonname, "Expected both names absent (%p != %p)\n",
486 a->ai_canonname, b->ai_canonname);
487 }
488 ok(!a && !b, "Expected both addresses null (%p != %p)\n", a, b);
489 }
490
491 /**************** Server utility functions ***************/
492
493 /*
494 * Even if we have closed our server socket cleanly,
495 * the OS may mark the address "in use" for some time -
496 * this happens with native Linux apps, too.
497 */
498 static void do_bind ( SOCKET s, struct sockaddr* addr, int addrlen )
499 {
500 int err, wsaerr = 0, n_try = BIND_TRIES;
501
502 while ( ( err = bind ( s, addr, addrlen ) ) != 0 &&
503 ( wsaerr = WSAGetLastError () ) == WSAEADDRINUSE &&
504 n_try-- >= 0)
505 {
506 trace ( "address in use, waiting ...\n" );
507 Sleep ( 1000 * BIND_SLEEP );
508 }
509 ok ( err == 0, "failed to bind: %d\n", wsaerr );
510 }
511
512 static void server_start ( server_params *par )
513 {
514 int i;
515 test_params *gen = par->general;
516 server_memory *mem = LocalAlloc ( LPTR, sizeof ( server_memory ) );
517
518 TlsSetValue ( tls, mem );
519 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
520 NULL, 0, par->sock_flags );
521 ok ( mem->s != INVALID_SOCKET, "Server: WSASocket failed\n" );
522
523 mem->addr.sin_family = AF_INET;
524 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
525 mem->addr.sin_port = htons ( gen->inet_port );
526
527 for (i = 0; i < MAX_CLIENTS; i++)
528 {
529 mem->sock[i].s = INVALID_SOCKET;
530 mem->sock[i].buf = LocalAlloc ( LPTR, gen->n_chunks * gen->chunk_size );
531 mem->sock[i].n_recvd = 0;
532 mem->sock[i].n_sent = 0;
533 }
534
535 if ( gen->sock_type == SOCK_STREAM )
536 do_bind ( mem->s, (struct sockaddr*) &mem->addr, sizeof (mem->addr) );
537 }
538
539 static void server_stop (void)
540 {
541 int i;
542 server_memory *mem = TlsGetValue ( tls );
543
544 for (i = 0; i < MAX_CLIENTS; i++ )
545 {
546 LocalFree ( mem->sock[i].buf );
547 if ( mem->sock[i].s != INVALID_SOCKET )
548 closesocket ( mem->sock[i].s );
549 }
550 ok ( closesocket ( mem->s ) == 0, "closesocket failed\n" );
551 LocalFree ( mem );
552 ExitThread ( GetCurrentThreadId () );
553 }
554
555 /**************** Client utilitiy functions ***************/
556
557 static void client_start ( client_params *par )
558 {
559 test_params *gen = par->general;
560 client_memory *mem = LocalAlloc (LPTR, sizeof (client_memory));
561
562 TlsSetValue ( tls, mem );
563
564 WaitForSingleObject ( server_ready, INFINITE );
565
566 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
567 NULL, 0, par->sock_flags );
568
569 mem->addr.sin_family = AF_INET;
570 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
571 mem->addr.sin_port = htons ( gen->inet_port );
572
573 ok ( mem->s != INVALID_SOCKET, "Client: WSASocket failed\n" );
574
575 mem->send_buf = LocalAlloc ( LPTR, 2 * gen->n_chunks * gen->chunk_size );
576 mem->recv_buf = mem->send_buf + gen->n_chunks * gen->chunk_size;
577 fill_buffer ( mem->send_buf, gen->chunk_size, gen->n_chunks );
578
579 SetEvent ( client_ready[client_id] );
580 /* Wait for the other clients to come up */
581 WaitForMultipleObjects ( min ( gen->n_clients, MAX_CLIENTS ), client_ready, TRUE, INFINITE );
582 }
583
584 static void client_stop (void)
585 {
586 client_memory *mem = TlsGetValue ( tls );
587 wsa_ok ( closesocket ( mem->s ), 0 ==, "closesocket error (%x): %d\n" );
588 LocalFree ( mem->send_buf );
589 LocalFree ( mem );
590 ExitThread(0);
591 }
592
593 /**************** Servers ***************/
594
595 /*
596 * simple_server: A very basic server doing synchronous IO.
597 */
598 static VOID WINAPI simple_server ( server_params *par )
599 {
600 test_params *gen = par->general;
601 server_memory *mem;
602 int pos, n_recvd, n_sent, n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
603 id = GetCurrentThreadId();
604
605 trace ( "simple_server (%x) starting\n", id );
606
607 set_so_opentype ( FALSE ); /* non-overlapped */
608 server_start ( par );
609 mem = TlsGetValue ( tls );
610
611 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
612 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "simple_server (%x): listen failed: %d\n");
613
614 trace ( "simple_server (%x) ready\n", id );
615 SetEvent ( server_ready ); /* notify clients */
616
617 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
618 {
619 trace ( "simple_server (%x): waiting for client\n", id );
620
621 /* accept a single connection */
622 tmp = sizeof ( mem->sock[0].peer );
623 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
624 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "simple_server (%x): accept failed: %d\n" );
625
626 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
627 "simple_server (%x): strange peer address\n", id );
628
629 /* Receive data & check it */
630 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
631 ok ( n_recvd == n_expected,
632 "simple_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
633 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
634 ok ( pos == -1, "simple_server (%x): test pattern error: %d\n", id, pos);
635
636 /* Echo data back */
637 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
638 ok ( n_sent == n_expected,
639 "simple_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
640
641 /* cleanup */
642 read_zero_bytes ( mem->sock[0].s );
643 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "simple_server (%x): closesocket error: %d\n" );
644 mem->sock[0].s = INVALID_SOCKET;
645 }
646
647 trace ( "simple_server (%x) exiting\n", id );
648 server_stop ();
649 }
650
651 /*
652 * oob_server: A very basic server receiving out-of-band data.
653 */
654 static VOID WINAPI oob_server ( server_params *par )
655 {
656 test_params *gen = par->general;
657 server_memory *mem;
658 u_long atmark = 0;
659 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, tmp,
660 id = GetCurrentThreadId();
661
662 trace ( "oob_server (%x) starting\n", id );
663
664 set_so_opentype ( FALSE ); /* non-overlapped */
665 server_start ( par );
666 mem = TlsGetValue ( tls );
667
668 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "oob_server (%x): failed to set blocking mode: %d\n");
669 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "oob_server (%x): listen failed: %d\n");
670
671 trace ( "oob_server (%x) ready\n", id );
672 SetEvent ( server_ready ); /* notify clients */
673
674 trace ( "oob_server (%x): waiting for client\n", id );
675
676 /* accept a single connection */
677 tmp = sizeof ( mem->sock[0].peer );
678 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
679 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "oob_server (%x): accept failed: %d\n" );
680
681 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
682 "oob_server (%x): strange peer address\n", id );
683
684 /* check initial atmark state */
685 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
686 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id, atmark );
687
688 /* Receive normal data */
689 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
690 ok ( n_recvd == n_expected,
691 "oob_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
692 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
693 ok ( pos == -1, "oob_server (%x): test pattern error: %d\n", id, pos);
694
695 /* check atmark state */
696 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
697 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id, atmark );
698
699 /* Echo data back */
700 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
701 ok ( n_sent == n_expected,
702 "oob_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
703
704 /* Receive a part of the out-of-band data and print atmark state */
705 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, 8, 0, par->buflen );
706 ok ( n_recvd == 8,
707 "oob_server (%x): received less data than expected: %d of %d\n", id, n_recvd, 8 );
708 n_expected -= 8;
709
710 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
711 trace( "oob_server (%x): %s the OOB mark: %i\n", id, atmark == 1 ? "not at" : "at", atmark );
712
713 /* Receive the rest of the out-of-band data and check atmark state */
714 do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
715
716 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
717 todo_wine ok ( atmark == 0, "oob_server (%x): not at the OOB mark: %i\n", id, atmark );
718
719 /* cleanup */
720 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "oob_server (%x): closesocket error: %d\n" );
721 mem->sock[0].s = INVALID_SOCKET;
722
723 trace ( "oob_server (%x) exiting\n", id );
724 server_stop ();
725 }
726
727 /*
728 * select_server: A non-blocking server.
729 */
730 static VOID WINAPI select_server ( server_params *par )
731 {
732 test_params *gen = par->general;
733 server_memory *mem;
734 int n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
735 id = GetCurrentThreadId(), n_connections = 0, n_sent, n_recvd,
736 n_set, delta, n_ready;
737 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
738 fd_set fds_recv, fds_send, fds_openrecv, fds_opensend;
739
740 trace ( "select_server (%x) starting\n", id );
741
742 set_so_opentype ( FALSE ); /* non-overlapped */
743 server_start ( par );
744 mem = TlsGetValue ( tls );
745
746 wsa_ok ( set_blocking ( mem->s, FALSE ), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
747 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "select_server (%x): listen failed: %d\n");
748
749 trace ( "select_server (%x) ready\n", id );
750 SetEvent ( server_ready ); /* notify clients */
751
752 FD_ZERO ( &fds_openrecv );
753 FD_ZERO ( &fds_recv );
754 FD_ZERO ( &fds_send );
755 FD_ZERO ( &fds_opensend );
756
757 FD_SET ( mem->s, &fds_openrecv );
758
759 while(1)
760 {
761 fds_recv = fds_openrecv;
762 fds_send = fds_opensend;
763
764 n_set = 0;
765
766 wsa_ok ( ( n_ready = select ( 0, &fds_recv, &fds_send, NULL, &timeout ) ), SOCKET_ERROR !=,
767 "select_server (%x): select() failed: %d\n" );
768
769 /* check for incoming requests */
770 if ( FD_ISSET ( mem->s, &fds_recv ) ) {
771 n_set += 1;
772
773 trace ( "select_server (%x): accepting client connection\n", id );
774
775 /* accept a single connection */
776 tmp = sizeof ( mem->sock[n_connections].peer );
777 mem->sock[n_connections].s = accept ( mem->s, (struct sockaddr*) &mem->sock[n_connections].peer, &tmp );
778 wsa_ok ( mem->sock[n_connections].s, INVALID_SOCKET !=, "select_server (%x): accept() failed: %d\n" );
779
780 ok ( mem->sock[n_connections].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
781 "select_server (%x): strange peer address\n", id );
782
783 /* add to list of open connections */
784 FD_SET ( mem->sock[n_connections].s, &fds_openrecv );
785 FD_SET ( mem->sock[n_connections].s, &fds_opensend );
786
787 n_connections++;
788 }
789
790 /* handle open requests */
791
792 for ( i = 0; i < n_connections; i++ )
793 {
794 if ( FD_ISSET( mem->sock[i].s, &fds_recv ) ) {
795 n_set += 1;
796
797 if ( mem->sock[i].n_recvd < n_expected ) {
798 /* Receive data & check it */
799 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 );
800 ok ( n_recvd != SOCKET_ERROR, "select_server (%x): error in recv(): %d\n", id, WSAGetLastError() );
801 mem->sock[i].n_recvd += n_recvd;
802
803 if ( mem->sock[i].n_recvd == n_expected ) {
804 int pos = test_buffer ( mem->sock[i].buf, gen->chunk_size, gen->n_chunks );
805 ok ( pos == -1, "select_server (%x): test pattern error: %d\n", id, pos );
806 FD_CLR ( mem->sock[i].s, &fds_openrecv );
807 }
808
809 ok ( mem->sock[i].n_recvd <= n_expected, "select_server (%x): received too many bytes: %d\n", id, mem->sock[i].n_recvd );
810 }
811 }
812
813 /* only echo back what we've received */
814 delta = mem->sock[i].n_recvd - mem->sock[i].n_sent;
815
816 if ( FD_ISSET ( mem->sock[i].s, &fds_send ) ) {
817 n_set += 1;
818
819 if ( ( delta > 0 ) && ( mem->sock[i].n_sent < n_expected ) ) {
820 /* Echo data back */
821 n_sent = send ( mem->sock[i].s, mem->sock[i].buf + mem->sock[i].n_sent, min ( delta, par->buflen ), 0 );
822 ok ( n_sent != SOCKET_ERROR, "select_server (%x): error in send(): %d\n", id, WSAGetLastError() );
823 mem->sock[i].n_sent += n_sent;
824
825 if ( mem->sock[i].n_sent == n_expected ) {
826 FD_CLR ( mem->sock[i].s, &fds_opensend );
827 }
828
829 ok ( mem->sock[i].n_sent <= n_expected, "select_server (%x): sent too many bytes: %d\n", id, mem->sock[i].n_sent );
830 }
831 }
832 }
833
834 /* check that select returned the correct number of ready sockets */
835 ok ( ( n_set == n_ready ), "select_server (%x): select() returns wrong number of ready sockets\n", id );
836
837 /* check if all clients are done */
838 if ( ( fds_opensend.fd_count == 0 )
839 && ( fds_openrecv.fd_count == 1 ) /* initial socket that accepts clients */
840 && ( n_connections == min ( gen->n_clients, MAX_CLIENTS ) ) ) {
841 break;
842 }
843 }
844
845 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
846 {
847 /* cleanup */
848 read_zero_bytes ( mem->sock[i].s );
849 wsa_ok ( closesocket ( mem->sock[i].s ), 0 ==, "select_server (%x): closesocket error: %d\n" );
850 mem->sock[i].s = INVALID_SOCKET;
851 }
852
853 trace ( "select_server (%x) exiting\n", id );
854 server_stop ();
855 }
856
857 /**************** Clients ***************/
858
859 /*
860 * simple_client: A very basic client doing synchronous IO.
861 */
862 static VOID WINAPI simple_client ( client_params *par )
863 {
864 test_params *gen = par->general;
865 client_memory *mem;
866 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
867
868 id = GetCurrentThreadId();
869 trace ( "simple_client (%x): starting\n", id );
870 /* wait here because we want to call set_so_opentype before creating a socket */
871 WaitForSingleObject ( server_ready, INFINITE );
872 trace ( "simple_client (%x): server ready\n", id );
873
874 check_so_opentype ();
875 set_so_opentype ( FALSE ); /* non-overlapped */
876 client_start ( par );
877 mem = TlsGetValue ( tls );
878
879 /* Connect */
880 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
881 0 ==, "simple_client (%x): connect error: %d\n" );
882 ok ( set_blocking ( mem->s, TRUE ) == 0,
883 "simple_client (%x): failed to set blocking mode\n", id );
884 trace ( "simple_client (%x) connected\n", id );
885
886 /* send data to server */
887 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
888 ok ( n_sent == n_expected,
889 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
890
891 /* shutdown send direction */
892 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
893
894 /* Receive data echoed back & check it */
895 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, 0, par->buflen );
896 ok ( n_recvd == n_expected,
897 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
898
899 /* check data */
900 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
901 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
902
903 /* cleanup */
904 read_zero_bytes ( mem->s );
905 trace ( "simple_client (%x) exiting\n", id );
906 client_stop ();
907 }
908
909 /*
910 * oob_client: A very basic client sending out-of-band data.
911 */
912 static VOID WINAPI oob_client ( client_params *par )
913 {
914 test_params *gen = par->general;
915 client_memory *mem;
916 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
917
918 id = GetCurrentThreadId();
919 trace ( "oob_client (%x): starting\n", id );
920 /* wait here because we want to call set_so_opentype before creating a socket */
921 WaitForSingleObject ( server_ready, INFINITE );
922 trace ( "oob_client (%x): server ready\n", id );
923
924 check_so_opentype ();
925 set_so_opentype ( FALSE ); /* non-overlapped */
926 client_start ( par );
927 mem = TlsGetValue ( tls );
928
929 /* Connect */
930 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
931 0 ==, "oob_client (%x): connect error: %d\n" );
932 ok ( set_blocking ( mem->s, TRUE ) == 0,
933 "oob_client (%x): failed to set blocking mode\n", id );
934 trace ( "oob_client (%x) connected\n", id );
935
936 /* send data to server */
937 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
938 ok ( n_sent == n_expected,
939 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
940
941 /* Receive data echoed back & check it */
942 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, 0, par->buflen );
943 ok ( n_recvd == n_expected,
944 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
945 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
946 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
947
948 /* send out-of-band data to server */
949 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, MSG_OOB, par->buflen );
950 ok ( n_sent == n_expected,
951 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
952
953 /* shutdown send direction */
954 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
955
956 /* cleanup */
957 read_zero_bytes ( mem->s );
958 trace ( "oob_client (%x) exiting\n", id );
959 client_stop ();
960 }
961
962 /*
963 * simple_mixed_client: mixing send and recvfrom
964 */
965 static VOID WINAPI simple_mixed_client ( client_params *par )
966 {
967 test_params *gen = par->general;
968 client_memory *mem;
969 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
970 int fromLen = sizeof(mem->addr);
971 struct sockaddr test;
972
973 id = GetCurrentThreadId();
974 trace ( "simple_client (%x): starting\n", id );
975 /* wait here because we want to call set_so_opentype before creating a socket */
976 WaitForSingleObject ( server_ready, INFINITE );
977 trace ( "simple_client (%x): server ready\n", id );
978
979 check_so_opentype ();
980 set_so_opentype ( FALSE ); /* non-overlapped */
981 client_start ( par );
982 mem = TlsGetValue ( tls );
983
984 /* Connect */
985 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
986 0 ==, "simple_client (%x): connect error: %d\n" );
987 ok ( set_blocking ( mem->s, TRUE ) == 0,
988 "simple_client (%x): failed to set blocking mode\n", id );
989 trace ( "simple_client (%x) connected\n", id );
990
991 /* send data to server */
992 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
993 ok ( n_sent == n_expected,
994 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
995
996 /* shutdown send direction */
997 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
998
999 /* this shouldn't change, since lpFrom, is not updated on
1000 connection oriented sockets - exposed by bug 11640
1001 */
1002 ((struct sockaddr_in*)&test)->sin_addr.s_addr = inet_addr("0.0.0.0");
1003
1004 /* Receive data echoed back & check it */
1005 n_recvd = do_synchronous_recvfrom ( mem->s,
1006 mem->recv_buf,
1007 n_expected,
1008 0,
1009 (struct sockaddr *)&test,
1010 &fromLen,
1011 par->buflen );
1012 ok ( n_recvd == n_expected,
1013 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
1014
1015 /* check that lpFrom was not updated */
1016 ok(0 ==
1017 strcmp(
1018 inet_ntoa(((struct sockaddr_in*)&test)->sin_addr),
1019 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
1020
1021 /* check data */
1022 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
1023 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
1024
1025 /* cleanup */
1026 read_zero_bytes ( mem->s );
1027 trace ( "simple_client (%x) exiting\n", id );
1028 client_stop ();
1029 }
1030
1031 /*
1032 * event_client: An event-driven client
1033 */
1034 static void WINAPI event_client ( client_params *par )
1035 {
1036 test_params *gen = par->general;
1037 client_memory *mem;
1038 int id = GetCurrentThreadId(), n_expected = gen->n_chunks * gen->chunk_size,
1039 tmp, err, n;
1040 HANDLE event;
1041 WSANETWORKEVENTS wsa_events;
1042 char *send_last, *recv_last, *send_p, *recv_p;
1043 LONG mask = FD_READ | FD_WRITE | FD_CLOSE;
1044
1045 trace ( "event_client (%x): starting\n", id );
1046 client_start ( par );
1047 trace ( "event_client (%x): server ready\n", id );
1048
1049 mem = TlsGetValue ( tls );
1050
1051 /* Prepare event notification for connect, makes socket nonblocking */
1052 event = WSACreateEvent ();
1053 WSAEventSelect ( mem->s, event, FD_CONNECT );
1054 tmp = connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) );
1055 if ( tmp != 0 ) {
1056 err = WSAGetLastError ();
1057 ok ( err == WSAEWOULDBLOCK, "event_client (%x): connect error: %d\n", id, err );
1058 tmp = WaitForSingleObject ( event, INFINITE );
1059 ok ( tmp == WAIT_OBJECT_0, "event_client (%x): wait for connect event failed: %d\n", id, tmp );
1060 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
1061 ok ( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
1062 err = wsa_events.iErrorCode[ FD_CONNECT_BIT ];
1063 ok ( err == 0, "event_client (%x): connect error: %d\n", id, err );
1064 if ( err ) goto out;
1065 }
1066
1067 trace ( "event_client (%x) connected\n", id );
1068
1069 WSAEventSelect ( mem->s, event, mask );
1070
1071 recv_p = mem->recv_buf;
1072 recv_last = mem->recv_buf + n_expected;
1073 send_p = mem->send_buf;
1074 send_last = mem->send_buf + n_expected;
1075
1076 while ( TRUE )
1077 {
1078 err = WaitForSingleObject ( event, INFINITE );
1079 ok ( err == WAIT_OBJECT_0, "event_client (%x): wait failed\n", id );
1080
1081 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
1082 ok( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
1083
1084 if ( wsa_events.lNetworkEvents & FD_WRITE )
1085 {
1086 err = wsa_events.iErrorCode[ FD_WRITE_BIT ];
1087 ok ( err == 0, "event_client (%x): FD_WRITE error code: %d\n", id, err );
1088
1089 if ( err== 0 )
1090 do
1091 {
1092 n = send ( mem->s, send_p, min ( send_last - send_p, par->buflen ), 0 );
1093 if ( n < 0 )
1094 {
1095 err = WSAGetLastError ();
1096 ok ( err == WSAEWOULDBLOCK, "event_client (%x): send error: %d\n", id, err );
1097 }
1098 else
1099 send_p += n;
1100 }
1101 while ( n >= 0 && send_p < send_last );
1102
1103 if ( send_p == send_last )
1104 {
1105 trace ( "event_client (%x): all data sent - shutdown\n", id );
1106 shutdown ( mem->s, SD_SEND );
1107 mask &= ~FD_WRITE;
1108 WSAEventSelect ( mem->s, event, mask );
1109 }
1110 }
1111 if ( wsa_events.lNetworkEvents & FD_READ )
1112 {
1113 err = wsa_events.iErrorCode[ FD_READ_BIT ];
1114 ok ( err == 0, "event_client (%x): FD_READ error code: %d\n", id, err );
1115 if ( err != 0 ) break;
1116
1117 /* First read must succeed */
1118 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
1119 wsa_ok ( n, 0 <=, "event_client (%x): recv error: %d\n" );
1120
1121 while ( n >= 0 ) {
1122 recv_p += n;
1123 if ( recv_p == recv_last )
1124 {
1125 mask &= ~FD_READ;
1126 trace ( "event_client (%x): all data received\n", id );
1127 WSAEventSelect ( mem->s, event, mask );
1128 break;
1129 }
1130 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
1131 if ( n < 0 && ( err = WSAGetLastError()) != WSAEWOULDBLOCK )
1132 ok ( 0, "event_client (%x): read error: %d\n", id, err );
1133
1134 }
1135 }
1136 if ( wsa_events.lNetworkEvents & FD_CLOSE )
1137 {
1138 trace ( "event_client (%x): close event\n", id );
1139 err = wsa_events.iErrorCode[ FD_CLOSE_BIT ];
1140 ok ( err == 0, "event_client (%x): FD_CLOSE error code: %d\n", id, err );
1141 break;
1142 }
1143 }
1144
1145 n = send_p - mem->send_buf;
1146 ok ( send_p == send_last,
1147 "simple_client (%x): sent less data than expected: %d of %d\n", id, n, n_expected );
1148 n = recv_p - mem->recv_buf;
1149 ok ( recv_p == recv_last,
1150 "simple_client (%x): received less data than expected: %d of %d\n", id, n, n_expected );
1151 n = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
1152 ok ( n == -1, "event_client (%x): test pattern error: %d\n", id, n);
1153
1154 out:
1155 WSACloseEvent ( event );
1156 trace ( "event_client (%x) exiting\n", id );
1157 client_stop ();
1158 }
1159
1160 /* Tests for WSAStartup */
1161 static void test_WithoutWSAStartup(void)
1162 {
1163 DWORD err;
1164
1165 WSASetLastError(0xdeadbeef);
1166 ok(WSASocketA(0, 0, 0, NULL, 0, 0) == INVALID_SOCKET, "WSASocketA should have failed\n");
1167 err = WSAGetLastError();
1168 ok(err == WSANOTINITIALISED, "Expected 10093, received %d\n", err);
1169
1170 WSASetLastError(0xdeadbeef);
1171 ok(gethostbyname("localhost") == NULL, "gethostbyname() succeeded unexpectedly\n");
1172 err = WSAGetLastError();
1173 ok(err == WSANOTINITIALISED, "Expected 10093, received %d\n", err);
1174 }
1175
1176 static void test_WithWSAStartup(void)
1177 {
1178 WSADATA data;
1179 WORD version = MAKEWORD( 2, 2 );
1180 INT res, socks, i, j;
1181 SOCKET sock;
1182 LPVOID ptr;
1183 struct
1184 {
1185 SOCKET src, dst, dup_src, dup_dst;
1186 } pairs[32];
1187 DWORD error;
1188
1189 res = WSAStartup( version, &data );
1190 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
1191
1192 ptr = gethostbyname("localhost");
1193 ok(ptr != NULL, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
1194
1195 /* Alloc some sockets to check if they are destroyed on WSACleanup */
1196 for (socks = 0; socks < ARRAY_SIZE(pairs); socks++)
1197 {
1198 WSAPROTOCOL_INFOA info;
1199 if (tcp_socketpair(&pairs[socks].src, &pairs[socks].dst)) break;
1200
1201 memset(&info, 0, sizeof(info));
1202 ok(!WSADuplicateSocketA(pairs[socks].src, GetCurrentProcessId(), &info),
1203 "WSADuplicateSocketA should have worked\n");
1204 pairs[socks].dup_src = WSASocketA(0, 0, 0, &info, 0, 0);
1205 ok(pairs[socks].dup_src != SOCKET_ERROR, "expected != -1\n");
1206
1207 memset(&info, 0, sizeof(info));
1208 ok(!WSADuplicateSocketA(pairs[socks].dst, GetCurrentProcessId(), &info),
1209 "WSADuplicateSocketA should have worked\n");
1210 pairs[socks].dup_dst = WSASocketA(0, 0, 0, &info, 0, 0);
1211 ok(pairs[socks].dup_dst != SOCKET_ERROR, "expected != -1\n");
1212 }
1213
1214 res = send(pairs[0].src, "TEST", 4, 0);
1215 ok(res == 4, "send failed with error %d\n", WSAGetLastError());
1216
1217 WSACleanup();
1218
1219 res = WSAStartup( version, &data );
1220 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
1221
1222 /* show that sockets are destroyed automatically after WSACleanup */
1223 todo_wine {
1224 SetLastError(0xdeadbeef);
1225 res = send(pairs[0].src, "TEST", 4, 0);
1226 error = WSAGetLastError();
1227 ok(res == SOCKET_ERROR, "send should have failed\n");
1228 ok(error == WSAENOTSOCK, "expected 10038, got %d\n", error);
1229
1230 SetLastError(0xdeadbeef);
1231 res = send(pairs[0].dst, "TEST", 4, 0);
1232 error = WSAGetLastError();
1233 ok(res == SOCKET_ERROR, "send should have failed\n");
1234 ok(error == WSAENOTSOCK, "expected 10038, got %d\n", error);
1235
1236 /* Check that all sockets were destroyed */
1237 for (i = 0; i < socks; i++)
1238 {
1239 for (j = 0; j < 4; j++)
1240 {
1241 struct sockaddr_in saddr;
1242 int size = sizeof(saddr);
1243 switch(j)
1244 {
1245 case 0: sock = pairs[i].src; break;
1246 case 1: sock = pairs[i].dup_src; break;
1247 case 2: sock = pairs[i].dst; break;
1248 case 3: sock = pairs[i].dup_dst; break;
1249 }
1250
1251 SetLastError(0xdeadbeef);
1252 res = getsockname(sock, (struct sockaddr *)&saddr, &size);
1253 error = WSAGetLastError();
1254 ok(res == SOCKET_ERROR, "Test[%d]: getsockname should have failed\n", i);
1255 if (res == SOCKET_ERROR)
1256 ok(error == WSAENOTSOCK, "Test[%d]: expected 10038, got %d\n", i, error);
1257 }
1258 }
1259
1260 }
1261
1262 /* While wine is not fixed, close all sockets manually */
1263 for (i = 0; i < socks; i++)
1264 {
1265 closesocket(pairs[i].src);
1266 closesocket(pairs[i].dst);
1267 closesocket(pairs[i].dup_src);
1268 closesocket(pairs[i].dup_dst);
1269 }
1270
1271 res = WSACleanup();
1272 ok(res == 0, "expected 0, got %d\n", res);
1273 WSASetLastError(0xdeadbeef);
1274 res = WSACleanup();
1275 error = WSAGetLastError();
1276 ok ( res == SOCKET_ERROR && error == WSANOTINITIALISED,
1277 "WSACleanup returned %d WSAGetLastError is %d\n", res, error);
1278 }
1279
1280 /**************** Main program utility functions ***************/
1281
1282 static void Init (void)
1283 {
1284 WORD ver = MAKEWORD (2, 2);
1285 WSADATA data;
1286 HMODULE hws2_32 = GetModuleHandleA("ws2_32.dll"), hiphlpapi, ntdll;
1287
1288 pfreeaddrinfo = (void *)GetProcAddress(hws2_32, "freeaddrinfo");
1289 pgetaddrinfo = (void *)GetProcAddress(hws2_32, "getaddrinfo");
1290 pFreeAddrInfoW = (void *)GetProcAddress(hws2_32, "FreeAddrInfoW");
1291 pFreeAddrInfoExW = (void *)GetProcAddress(hws2_32, "FreeAddrInfoExW");
1292 pGetAddrInfoW = (void *)GetProcAddress(hws2_32, "GetAddrInfoW");
1293 pGetAddrInfoExW = (void *)GetProcAddress(hws2_32, "GetAddrInfoExW");
1294 pGetAddrInfoExOverlappedResult = (void *)GetProcAddress(hws2_32, "GetAddrInfoExOverlappedResult");
1295 pInetNtop = (void *)GetProcAddress(hws2_32, "inet_ntop");
1296 pInetNtopW = (void *)GetProcAddress(hws2_32, "InetNtopW");
1297 pInetPtonA = (void *)GetProcAddress(hws2_32, "inet_pton");
1298 pInetPtonW = (void *)GetProcAddress(hws2_32, "InetPtonW");
1299 pWSALookupServiceBeginW = (void *)GetProcAddress(hws2_32, "WSALookupServiceBeginW");
1300 pWSALookupServiceEnd = (void *)GetProcAddress(hws2_32, "WSALookupServiceEnd");
1301 pWSALookupServiceNextW = (void *)GetProcAddress(hws2_32, "WSALookupServiceNextW");
1302 pWSAEnumNameSpaceProvidersA = (void *)GetProcAddress(hws2_32, "WSAEnumNameSpaceProvidersA");
1303 pWSAEnumNameSpaceProvidersW = (void *)GetProcAddress(hws2_32, "WSAEnumNameSpaceProvidersW");
1304 pWSAPoll = (void *)GetProcAddress(hws2_32, "WSAPoll");
1305 pWSCGetProviderInfo = (void *)GetProcAddress(hws2_32, "WSCGetProviderInfo");
1306
1307 hiphlpapi = LoadLibraryA("iphlpapi.dll");
1308 if (hiphlpapi)
1309 {
1310 pGetIpForwardTable = (void *)GetProcAddress(hiphlpapi, "GetIpForwardTable");
1311 pGetAdaptersInfo = (void *)GetProcAddress(hiphlpapi, "GetAdaptersInfo");
1312 }
1313
1314 ntdll = LoadLibraryA("ntdll.dll");
1315 if (ntdll)
1316 pNtClose = (void *)GetProcAddress(ntdll, "NtClose");
1317
1318 ok ( WSAStartup ( ver, &data ) == 0, "WSAStartup failed\n" );
1319 tls = TlsAlloc();
1320 }
1321
1322 static void Exit (void)
1323 {
1324 INT ret, err;
1325 TlsFree ( tls );
1326 ret = WSACleanup();
1327 err = WSAGetLastError();
1328 ok ( ret == 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret, err);
1329 }
1330
1331 static void StartServer (LPTHREAD_START_ROUTINE routine,
1332 test_params *general, server_params *par)
1333 {
1334 par->general = general;
1335 thread[0] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[0] );
1336 ok ( thread[0] != NULL, "Failed to create server thread\n" );
1337 }
1338
1339 static void StartClients (LPTHREAD_START_ROUTINE routine,
1340 test_params *general, client_params *par)
1341 {
1342 int i;
1343 par->general = general;
1344 for ( i = 1; i <= min ( general->n_clients, MAX_CLIENTS ); i++ )
1345 {
1346 client_id = i - 1;
1347 thread[i] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[i] );
1348 ok ( thread[i] != NULL, "Failed to create client thread\n" );
1349 /* Make sure the client is up and running */
1350 WaitForSingleObject ( client_ready[client_id], INFINITE );
1351 };
1352 }
1353
1354 static void do_test( test_setup *test )
1355 {
1356 DWORD i, n = min (test->general.n_clients, MAX_CLIENTS);
1357 DWORD wait;
1358
1359 server_ready = CreateEventA ( NULL, TRUE, FALSE, NULL );
1360 for (i = 0; i <= n; i++)
1361 client_ready[i] = CreateEventA ( NULL, TRUE, FALSE, NULL );
1362
1363 StartServer ( test->srv, &test->general, &test->srv_params );
1364 StartClients ( test->clt, &test->general, &test->clt_params );
1365 WaitForSingleObject ( server_ready, INFINITE );
1366
1367 wait = WaitForMultipleObjects ( 1 + n, thread, TRUE, 1000 * TEST_TIMEOUT );
1368 ok ( wait <= WAIT_OBJECT_0 + n ,
1369 "some threads have not completed: %x\n", wait );
1370
1371 if ( ! ( wait <= WAIT_OBJECT_0 + n ) )
1372 {
1373 for (i = 0; i <= n; i++)
1374 {
1375 if ( WaitForSingleObject ( thread[i], 0 ) != WAIT_OBJECT_0 )
1376 {
1377 trace ("terminating thread %08x\n", thread_id[i]);
1378 TerminateThread ( thread [i], 0 );
1379 }
1380 }
1381 }
1382 CloseHandle ( server_ready );
1383 for (i = 0; i <= n; i++)
1384 CloseHandle ( client_ready[i] );
1385 }
1386
1387 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1388 /* optname = SO_LINGER */
1389 static const LINGER linger_testvals[] = {
1390 {0,0},
1391 {0,73},
1392 {1,0},
1393 {5,189}
1394 };
1395
1396 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1397 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1398 bug in the linux kernel (fixed in 2.6.8) */
1399 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1400
1401 static void test_set_getsockopt(void)
1402 {
1403 SOCKET s, s2;
1404 int i, err, lasterr;
1405 int timeout;
1406 LINGER lingval;
1407 int size;
1408 WSAPROTOCOL_INFOA infoA;
1409 WSAPROTOCOL_INFOW infoW;
1410 char providername[WSAPROTOCOL_LEN + 1];
1411 DWORD value;
1412 struct _prottest
1413 {
1414 int family, type, proto;
1415 } prottest[] = {
1416 {AF_INET, SOCK_STREAM, IPPROTO_TCP},
1417 {AF_INET, SOCK_DGRAM, IPPROTO_UDP},
1418 {AF_INET6, SOCK_STREAM, IPPROTO_TCP},
1419 {AF_INET6, SOCK_DGRAM, IPPROTO_UDP}
1420 };
1421 union _csspace
1422 {
1423 CSADDR_INFO cs;
1424 char space[128];
1425 } csinfoA, csinfoB;
1426
1427 s = socket(AF_INET, SOCK_STREAM, 0);
1428 ok(s!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1429 if( s == INVALID_SOCKET) return;
1430 /* SO_RCVTIMEO */
1431 timeout = SOCKTIMEOUT1;
1432 size = sizeof(timeout);
1433 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1434 if( !err)
1435 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1436 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1437 ok( timeout == SOCKTIMEOUT1, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1438
1439 timeout = 0;
1440 size = sizeof(timeout);
1441 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1442 if( !err)
1443 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1444 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1445 ok( timeout == 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1446
1447 /* SO_SNDTIMEO */
1448 timeout = SOCKTIMEOUT2; /* 997 seconds. See remark above */
1449 size = sizeof(timeout);
1450 err = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, size);
1451 if( !err)
1452 err = getsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, &size);
1453 ok( !err, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1454 ok( timeout == SOCKTIMEOUT2, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout);
1455
1456 /* SO_SNDBUF */
1457 value = 4096;
1458 size = sizeof(value);
1459 err = setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&value, size);
1460 ok( !err, "setsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1461 value = 0xdeadbeef;
1462 err = getsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&value, &size);
1463 ok( !err, "getsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1464 todo_wine ok( value == 4096, "expected 4096, got %u\n", value );
1465
1466 /* SO_RCVBUF */
1467 value = 4096;
1468 size = sizeof(value);
1469 err = setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, size);
1470 ok( !err, "setsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1471 value = 0xdeadbeef;
1472 err = getsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, &size);
1473 ok( !err, "getsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1474 todo_wine ok( value == 4096, "expected 4096, got %u\n", value );
1475
1476 /* SO_LINGER */
1477 for( i = 0; i < ARRAY_SIZE(linger_testvals);i++) {
1478 size = sizeof(lingval);
1479 lingval = linger_testvals[i];
1480 err = setsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, size);
1481 if( !err)
1482 err = getsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, &size);
1483 ok( !err, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
1484 ok( !lingval.l_onoff == !linger_testvals[i].l_onoff &&
1485 (lingval.l_linger == linger_testvals[i].l_linger ||
1486 (!lingval.l_linger && !linger_testvals[i].l_onoff))
1487 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i,
1488 lingval.l_onoff, lingval.l_linger,
1489 linger_testvals[i].l_onoff, linger_testvals[i].l_linger);
1490 }
1491
1492 size = sizeof(lingval);
1493 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, size);
1494 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1495 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1496 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, 0);
1497 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1498 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1499
1500 size = sizeof(BOOL);
1501 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, size);
1502 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1503 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1504 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, 0);
1505 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1506 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1507
1508 /* Test for erroneously passing a value instead of a pointer as optval */
1509 size = sizeof(char);
1510 err = setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)1, size);
1511 ok(err == SOCKET_ERROR, "setsockopt with optval being a value passed "
1512 "instead of failing.\n");
1513 lasterr = WSAGetLastError();
1514 ok(lasterr == WSAEFAULT, "setsockopt with optval being a value "
1515 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1516 lasterr, WSAEFAULT);
1517
1518 /* SO_RCVTIMEO with invalid values for level */
1519 size = sizeof(timeout);
1520 timeout = SOCKTIMEOUT1;
1521 SetLastError(0xdeadbeef);
1522 err = setsockopt(s, 0xffffffff, SO_RCVTIMEO, (char *) &timeout, size);
1523 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1524 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1525 err, WSAGetLastError());
1526
1527 timeout = SOCKTIMEOUT1;
1528 SetLastError(0xdeadbeef);
1529 err = setsockopt(s, 0x00008000, SO_RCVTIMEO, (char *) &timeout, size);
1530 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1531 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1532 err, WSAGetLastError());
1533
1534 /* Test SO_ERROR set/get */
1535 SetLastError(0xdeadbeef);
1536 i = 1234;
1537 err = setsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, size);
1538 todo_wine
1539 ok( !err && !WSAGetLastError(),
1540 "got %d with %d (expected 0 with 0)\n",
1541 err, WSAGetLastError());
1542
1543 SetLastError(0xdeadbeef);
1544 i = 4321;
1545 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1546 todo_wine
1547 ok( !err && !WSAGetLastError(),
1548 "got %d with %d (expected 0 with 0)\n",
1549 err, WSAGetLastError());
1550 todo_wine
1551 ok (i == 1234, "got %d (expected 1234)\n", i);
1552
1553 /* Test invalid optlen */
1554 SetLastError(0xdeadbeef);
1555 size = 1;
1556 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1557 todo_wine
1558 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEFAULT),
1559 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1560 err, WSAGetLastError());
1561
1562 closesocket(s);
1563 /* Test with the closed socket */
1564 SetLastError(0xdeadbeef);
1565 size = sizeof(i);
1566 i = 1234;
1567 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1568 todo_wine
1569 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAENOTSOCK),
1570 "got %d with %d (expected SOCKET_ERROR with WSAENOTSOCK)\n",
1571 err, WSAGetLastError());
1572 ok (i == 1234, "expected 1234, got %d\n", i);
1573
1574 /* Test WS_IP_MULTICAST_TTL with 8, 16, 24 and 32 bits values */
1575 s = socket(AF_INET, SOCK_DGRAM, 0);
1576 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1577 size = sizeof(i);
1578 i = 0x0000000a;
1579 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &i, size);
1580 if (!err)
1581 {
1582 for (i = 0; i < 4; i++)
1583 {
1584 int k, j;
1585 const int tests[] = {0xffffff0a, 0xffff000b, 0xff00000c, 0x0000000d};
1586 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &tests[i], i + 1);
1587 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1588 err = getsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &k, &size);
1589 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1590 j = i != 3 ? tests[i] & ((1 << (i + 1) * 8) - 1) : tests[i];
1591 ok(k == j, "Test [%d] Expected 0x%x, got 0x%x\n", i, j, k);
1592 }
1593 }
1594 else
1595 win_skip("IP_MULTICAST_TTL is unsupported\n");
1596 closesocket(s);
1597
1598 /* test SO_PROTOCOL_INFOA invalid parameters */
1599 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1600 "getsockopt should have failed\n");
1601 err = WSAGetLastError();
1602 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1603 size = sizeof(WSAPROTOCOL_INFOA);
1604 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1605 "getsockopt should have failed\n");
1606 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1607 err = WSAGetLastError();
1608 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1609 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1610 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1611 "getsockopt should have failed\n");
1612 err = WSAGetLastError();
1613 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1614 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, NULL),
1615 "getsockopt should have failed\n");
1616 err = WSAGetLastError();
1617 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1618 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, &size),
1619 "getsockopt should have failed\n");
1620 err = WSAGetLastError();
1621 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1622 size = sizeof(WSAPROTOCOL_INFOA) / 2;
1623 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1624 "getsockopt should have failed\n");
1625 err = WSAGetLastError();
1626 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1627 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1628 size = sizeof(WSAPROTOCOL_INFOA) * 2;
1629 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1630 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1631 ok(size == sizeof(WSAPROTOCOL_INFOA) * 2, "got size %d\n", size);
1632
1633 closesocket(s);
1634
1635 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1636 for (i = 0; i < ARRAY_SIZE(prottest); i++)
1637 {
1638 int k;
1639
1640 s = socket(prottest[i].family, prottest[i].type, prottest[i].proto);
1641 if (s == INVALID_SOCKET && prottest[i].family == AF_INET6) continue;
1642
1643 ok(s != INVALID_SOCKET, "Failed to create socket: %d\n",
1644 WSAGetLastError());
1645
1646 /* compare both A and W version */
1647 infoA.szProtocol[0] = 0;
1648 size = sizeof(WSAPROTOCOL_INFOA);
1649 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1650 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1651 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1652
1653 infoW.szProtocol[0] = 0;
1654 size = sizeof(WSAPROTOCOL_INFOW);
1655 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOW, (char *) &infoW, &size);
1656 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1657 ok(size == sizeof(WSAPROTOCOL_INFOW), "got size %d\n", size);
1658
1659 trace("provider name '%s', family %d, type %d, proto %d\n",
1660 infoA.szProtocol, prottest[i].family, prottest[i].type, prottest[i].proto);
1661
1662 ok(infoA.szProtocol[0], "WSAPROTOCOL_INFOA was not filled\n");
1663 ok(infoW.szProtocol[0], "WSAPROTOCOL_INFOW was not filled\n");
1664
1665 WideCharToMultiByte(CP_ACP, 0, infoW.szProtocol, -1,
1666 providername, sizeof(providername), NULL, NULL);
1667 ok(!strcmp(infoA.szProtocol,providername),
1668 "different provider names '%s' != '%s'\n", infoA.szProtocol, providername);
1669
1670 ok(!memcmp(&infoA, &infoW, FIELD_OFFSET(WSAPROTOCOL_INFOA, szProtocol)),
1671 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1672
1673 /* Remove IF when WSAEnumProtocols support IPV6 data */
1674 ok(infoA.iAddressFamily == prottest[i].family, "socket family invalid, expected %d received %d\n",
1675 prottest[i].family, infoA.iAddressFamily);
1676 ok(infoA.iSocketType == prottest[i].type, "socket type invalid, expected %d received %d\n",
1677 prottest[i].type, infoA.iSocketType);
1678 ok(infoA.iProtocol == prottest[i].proto, "socket protocol invalid, expected %d received %d\n",
1679 prottest[i].proto, infoA.iProtocol);
1680
1681 /* IP_HDRINCL is supported only on SOCK_RAW but passed to SOCK_DGRAM by Impossible Creatures */
1682 size = sizeof(i);
1683 k = 1;
1684 SetLastError(0xdeadbeef);
1685 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1686 if (err == -1) /* >= Vista */
1687 {
1688 todo_wine {
1689 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %d\n", GetLastError());
1690 k = 99;
1691 SetLastError(0xdeadbeef);
1692 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1693 ok(err == -1, "Expected -1, got %d\n", err);
1694 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %d\n", GetLastError());
1695 ok(k == 99, "Expected 99, got %d\n", k);
1696
1697 size = sizeof(k);
1698 k = 0;
1699 SetLastError(0xdeadbeef);
1700 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1701 }
1702 ok(err == -1, "Expected -1, got %d\n", err);
1703 todo_wine {
1704 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %d\n", GetLastError());
1705 k = 99;
1706 SetLastError(0xdeadbeef);
1707 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1708 ok(err == -1, "Expected -1, got %d\n", err);
1709 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %d\n", GetLastError());
1710 ok(k == 99, "Expected 99, got %d\n", k);
1711 }
1712 }
1713 else /* <= 2003 the tests differ between TCP and UDP, UDP silently accepts */
1714 {
1715 SetLastError(0xdeadbeef);
1716 k = 99;
1717 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1718 if (prottest[i].type == SOCK_DGRAM)
1719 {
1720 ok(err == 0, "Expected 0, got %d\n", err);
1721 ok(k == 1, "Expected 1, got %d\n", k);
1722 }
1723 else
1724 {
1725 /* contratry to what we could expect the function returns error but k is changed */
1726 ok(err == -1, "Expected -1, got %d\n", err);
1727 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %d\n", GetLastError());
1728 ok(k == 0, "Expected 0, got %d\n", k);
1729 }
1730
1731 k = 0;
1732 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1733 ok(err == 0, "Expected 0, got %d\n", err);
1734
1735 k = 99;
1736 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1737 if (prottest[i].type == SOCK_DGRAM)
1738 {
1739 ok(err == 0, "Expected 0, got %d\n", err);
1740 ok(k == 0, "Expected 0, got %d\n", k);
1741 }
1742 else
1743 {
1744 /* contratry to what we could expect the function returns error but k is changed */
1745 ok(err == -1, "Expected -1, got %d\n", err);
1746 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %d\n", GetLastError());
1747 ok(k == 0, "Expected 0, got %d\n", k);
1748 }
1749 }
1750
1751 closesocket(s);
1752 }
1753
1754 /* Test SO_BSP_STATE - Present only in >= Win 2008 */
1755 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1756 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1757 s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1758 ok(s2 != INVALID_SOCKET, "Failed to create socket\n");
1759
1760 SetLastError(0xdeadbeef);
1761 size = sizeof(csinfoA);
1762 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1763 if (!err)
1764 {
1765 struct sockaddr_in saddr;
1766 memset(&saddr, 0, sizeof(saddr));
1767 saddr.sin_family = AF_INET;
1768 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1769
1770 /* Socket is not bound, no information provided */
1771 ok(!csinfoA.cs.LocalAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.LocalAddr.iSockaddrLength);
1772 ok(csinfoA.cs.LocalAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.LocalAddr.lpSockaddr);
1773 /* Socket is not connected, no information provided */
1774 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.RemoteAddr.iSockaddrLength);
1775 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.RemoteAddr.lpSockaddr);
1776
1777 err = bind(s, (struct sockaddr*)&saddr, sizeof(saddr));
1778 ok(!err, "Expected 0, got %d\n", err);
1779 size = sizeof(csinfoA);
1780 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1781 ok(!err, "Expected 0, got %d\n", err);
1782
1783 /* Socket is bound */
1784 ok(csinfoA.cs.LocalAddr.iSockaddrLength, "Expected non-zero\n");
1785 ok(csinfoA.cs.LocalAddr.lpSockaddr != NULL, "Expected non-null\n");
1786 /* Socket is not connected, no information provided */
1787 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.RemoteAddr.iSockaddrLength);
1788 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.RemoteAddr.lpSockaddr);
1789
1790 err = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1791 ok(!err, "Expected 0, got %d\n", err);
1792 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1793 ok(!err, "Expected 0, got %d\n", err);
1794 err = listen(s2, 1);
1795 ok(!err, "Expected 0, got %d\n", err);
1796 err = connect(s, (struct sockaddr*)&saddr, sizeof(saddr));
1797 ok(!err, "Expected 0, got %d\n", err);
1798 size = sizeof(saddr);
1799 err = accept(s2, (struct sockaddr*)&saddr, &size);
1800 ok(err != INVALID_SOCKET, "Failed to accept socket\n");
1801 closesocket(s2);
1802 s2 = err;
1803
1804 size = sizeof(csinfoA);
1805 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1806 ok(!err, "Expected 0, got %d\n", err);
1807 err = getsockopt(s2, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoB, &size);
1808 ok(!err, "Expected 0, got %d\n", err);
1809 ok(size == sizeof(csinfoA), "Got %d\n", size);
1810 size = sizeof(saddr);
1811 ok(size == csinfoA.cs.LocalAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1812 csinfoA.cs.LocalAddr.iSockaddrLength);
1813 ok(size == csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1814 csinfoA.cs.RemoteAddr.iSockaddrLength);
1815 ok(!memcmp(csinfoA.cs.LocalAddr.lpSockaddr, csinfoB.cs.RemoteAddr.lpSockaddr, size),
1816 "Expected matching addresses\n");
1817 ok(!memcmp(csinfoB.cs.LocalAddr.lpSockaddr, csinfoA.cs.RemoteAddr.lpSockaddr, size),
1818 "Expected matching addresses\n");
1819 ok(csinfoA.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1820 ok(csinfoB.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1821 ok(csinfoA.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1822 ok(csinfoB.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1823
1824 err = getpeername(s, (struct sockaddr *)&saddr, &size);
1825 ok(!err, "Expected 0, got %d\n", err);
1826 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1827 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1828 err = getpeername(s2, (struct sockaddr *)&saddr, &size);
1829 ok(!err, "Expected 0, got %d\n", err);
1830 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1831 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1832 err = getsockname(s, (struct sockaddr *)&saddr, &size);
1833 ok(!err, "Expected 0, got %d\n", err);
1834 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1835 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1836 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1837 ok(!err, "Expected 0, got %d\n", err);
1838 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1839 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1840
1841 SetLastError(0xdeadbeef);
1842 size = sizeof(CSADDR_INFO);
1843 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1844 ok(err, "Expected non-zero\n");
1845 ok(size == sizeof(CSADDR_INFO), "Got %d\n", size);
1846 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %d\n", GetLastError());
1847
1848 /* At least for IPv4 the size is exactly 56 bytes */
1849 size = sizeof(*csinfoA.cs.LocalAddr.lpSockaddr) * 2 + sizeof(csinfoA.cs);
1850 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1851 ok(!err, "Expected 0, got %d\n", err);
1852 size--;
1853 SetLastError(0xdeadbeef);
1854 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1855 ok(err, "Expected non-zero\n");
1856 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %d\n", GetLastError());
1857 }
1858 else
1859 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %d\n", GetLastError());
1860
1861 closesocket(s);
1862 closesocket(s2);
1863
1864 for (i = 0; i < 2; i++)
1865 {
1866 int family, level;
1867
1868 if (i)
1869 {
1870 family = AF_INET6;
1871 level = IPPROTO_IPV6;
1872 }
1873 else
1874 {
1875 family = AF_INET;
1876 level = IPPROTO_IP;
1877 }
1878
1879 s = socket(family, SOCK_DGRAM, 0);
1880 if (s == INVALID_SOCKET && i)
1881 {
1882 skip("IPv6 is not supported\n");
1883 break;
1884 }
1885 ok(s != INVALID_SOCKET, "socket failed with error %d\n", GetLastError());
1886
1887 size = sizeof(value);
1888 value = 0xdead;
1889 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1890 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1891 ok(value == 0, "Expected 0, got %d\n", value);
1892
1893 size = sizeof(value);
1894 value = 1;
1895 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
1896 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1897
1898 value = 0xdead;
1899 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1900 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1901 ok(value == 1, "Expected 1, got %d\n", value);
1902
1903 size = sizeof(value);
1904 value = 0xdead;
1905 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
1906 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1907
1908 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1909 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1910 ok(value == 1, "Expected 1, got %d\n", value);
1911
1912 closesocket(s);
1913
1914 s = socket(family, SOCK_STREAM, 0);
1915 if (s == INVALID_SOCKET && i)
1916 {
1917 skip("IPv6 is not supported\n");
1918 break;
1919 }
1920 ok(s != INVALID_SOCKET, "socket failed with error %d\n", GetLastError());
1921
1922 size = sizeof(value);
1923 value = 0xdead;
1924 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1925 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1926 ok(value == 1 || broken(value == 0) /* < vista */, "Expected 1, got %d\n", value);
1927
1928 size = sizeof(value);
1929 value = 0;
1930 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
1931 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1932
1933 value = 0xdead;
1934 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1935 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1936 ok(value == 0, "Expected 0, got %d\n", value);
1937
1938 closesocket(s);
1939
1940 s = socket(family, SOCK_RAW, 0);
1941 if (s == INVALID_SOCKET)
1942 {
1943 if (WSAGetLastError() == WSAEACCES) skip("SOCK_RAW is not available\n");
1944 else if (i) skip("IPv6 is not supported\n");
1945 break;
1946 }
1947 ok(s != INVALID_SOCKET, "socket failed with error %d\n", GetLastError());
1948
1949 size = sizeof(value);
1950 value = 0xdead;
1951 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1952 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1953 ok(value == 0, "Expected 0, got %d\n", value);
1954
1955 size = sizeof(value);
1956 value = 1;
1957 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
1958 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1959
1960 value = 0xdead;
1961 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1962 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1963 ok(value == 1, "Expected 1, got %d\n", value);
1964
1965 closesocket(s);
1966 }
1967 }
1968
1969 static void test_so_reuseaddr(void)
1970 {
1971 struct sockaddr_in saddr;
1972 SOCKET s1,s2;
1973 unsigned int rc,reuse;
1974 int size;
1975 DWORD err;
1976
1977 saddr.sin_family = AF_INET;
1978 saddr.sin_port = htons(SERVERPORT+1);
1979 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1980
1981 s1=socket(AF_INET, SOCK_STREAM, 0);
1982 ok(s1!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1983 rc = bind(s1, (struct sockaddr*)&saddr, sizeof(saddr));
1984 ok(rc!=SOCKET_ERROR, "bind(s1) failed error: %d\n", WSAGetLastError());
1985
1986 s2=socket(AF_INET, SOCK_STREAM, 0);
1987 ok(s2!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1988
1989 reuse=0x1234;
1990 size=sizeof(reuse);
1991 rc=getsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, &size );
1992 ok(rc==0 && reuse==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc,reuse);
1993
1994 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1995 ok(rc==SOCKET_ERROR, "bind() succeeded\n");
1996
1997 reuse = 1;
1998 rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
1999 ok(rc==0, "setsockopt() failed error: %d\n", WSAGetLastError());
2000
2001 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
2002 * a port immediately after closing another socket on that port, so
2003 * basically following the BSD socket semantics here. */
2004 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
2005 if(rc==0)
2006 {
2007 int s3=socket(AF_INET, SOCK_STREAM, 0), s4;
2008 trace("<= Win XP behavior of SO_REUSEADDR\n");
2009
2010 /* If we could bind again in the same port this is Windows version <= XP.
2011 * Lets test if we can really connect to one of them. */
2012 set_blocking(s1, FALSE);
2013 set_blocking(s2, FALSE);
2014 rc = listen(s1, 1);
2015 ok(!rc, "listen() failed with error: %d\n", WSAGetLastError());
2016 rc = listen(s2, 1);
2017 ok(!rc, "listen() failed with error: %d\n", WSAGetLastError());
2018 rc = connect(s3, (struct sockaddr*)&saddr, sizeof(saddr));
2019 ok(!rc, "connecting to accepting socket failed %d\n", WSAGetLastError());
2020
2021 /* the delivery of the connection is random so we need to try on both sockets */
2022 size = sizeof(saddr);
2023 s4 = accept(s1, (struct sockaddr*)&saddr, &size);
2024 if(s4 == INVALID_SOCKET)
2025 s4 = accept(s2, (struct sockaddr*)&saddr, &size);
2026 ok(s4 != INVALID_SOCKET, "none of the listening sockets could get the connection\n");
2027
2028 closesocket(s1);
2029 closesocket(s3);
2030 closesocket(s4);
2031 }
2032 else
2033 {
2034 trace(">= Win 2003 behavior of SO_REUSEADDR\n");
2035 err = WSAGetLastError();
2036 ok(err==WSAEACCES, "expected 10013, got %d\n", err);
2037
2038 closesocket(s1);
2039 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
2040 ok(rc==0, "bind() failed error: %d\n", WSAGetLastError());
2041 }
2042
2043 closesocket(s2);
2044 }
2045
2046 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
2047
2048 static void test_ip_pktinfo(void)
2049 {
2050 ULONG addresses[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY)};
2051 char recvbuf[10], pktbuf[512], msg[] = "HELLO";
2052 struct sockaddr_in s1addr, s2addr, s3addr;
2053 GUID WSARecvMsg_GUID = WSAID_WSARECVMSG;
2054 LPFN_WSARECVMSG pWSARecvMsg = NULL;
2055 unsigned int rc, yes = 1;
2056 BOOL foundhdr;
2057 DWORD dwBytes, dwSize, dwFlags;
2058 socklen_t addrlen;
2059 WSACMSGHDR *cmsg;
2060 WSAOVERLAPPED ov;
2061 WSABUF iovec[1];
2062 SOCKET s1, s2;
2063 WSAMSG hdr;
2064 int i, err;
2065
2066 memset(&ov, 0, sizeof(ov));
2067 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
2068 if (ov.hEvent == INVALID_HANDLE_VALUE)
2069 {
2070 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
2071 return;
2072 }
2073
2074 memset(&hdr, 0x00, sizeof(hdr));
2075 s1addr.sin_family = AF_INET;
2076 s1addr.sin_port = htons(0);
2077 /* Note: s1addr.sin_addr is set below */
2078 iovec[0].buf = recvbuf;
2079 iovec[0].len = sizeof(recvbuf);
2080 hdr.name = (struct sockaddr*)&s3addr;
2081 hdr.namelen = sizeof(s3addr);
2082 hdr.lpBuffers = &iovec[0];
2083 hdr.dwBufferCount = 1;
2084 hdr.Control.buf = pktbuf;
2085 /* Note: hdr.Control.len is set below */
2086 hdr.dwFlags = 0;
2087
2088 for (i=0;i<ARRAY_SIZE(addresses);i++)
2089 {
2090 s1addr.sin_addr.s_addr = addresses[i];
2091
2092 /* Build "server" side socket */
2093 s1=socket(AF_INET, SOCK_DGRAM, 0);
2094 if (s1 == INVALID_SOCKET)
2095 {
2096 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
2097 goto cleanup;
2098 }
2099
2100 /* Obtain the WSARecvMsg function */
2101 WSAIoctl(s1, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
2102 &pWSARecvMsg, sizeof(pWSARecvMsg), &dwBytes, NULL, NULL);
2103 if (!pWSARecvMsg)
2104 {
2105 win_skip("WSARecvMsg is unsupported, some tests will be skipped.\n");
2106 closesocket(s1);
2107 goto cleanup;
2108 }
2109
2110 /* Setup the server side socket */
2111 rc=bind(s1, (struct sockaddr*)&s1addr, sizeof(s1addr));
2112 ok(rc != SOCKET_ERROR, "bind() failed error: %d\n", WSAGetLastError());
2113
2114 /* Build "client" side socket */
2115 addrlen = sizeof(s2addr);
2116 if (getsockname(s1, (struct sockaddr *) &s2addr, &addrlen) != 0)
2117 {
2118 skip("Failed to call getsockname, some tests skipped: %d\n", WSAGetLastError());
2119 closesocket(s1);
2120 goto cleanup;
2121 }
2122 s2addr.sin_addr.s_addr = addresses[0]; /* Always target the local adapter address */
2123 s2=socket(AF_INET, SOCK_DGRAM, 0);
2124 if (s2 == INVALID_SOCKET)
2125 {
2126 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
2127 closesocket(s1);
2128 goto cleanup;
2129 }
2130
2131 /* Test an empty message header */
2132 rc=pWSARecvMsg(s1, NULL, NULL, NULL, NULL);
2133 err=WSAGetLastError();
2134 ok(rc == SOCKET_ERROR && err == WSAEFAULT, "WSARecvMsg() failed error: %d (ret = %d)\n", err, rc);
2135
2136 /* Test that when no control data arrives, a 0-length NULL-valued control buffer should succeed */
2137 SetLastError(0xdeadbeef);
2138 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2139 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2140 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
2141 hdr.Control.buf = NULL;
2142 hdr.Control.len = 0;
2143 rc=pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
2144 ok(rc == 0, "WSARecvMsg() failed error: %d\n", WSAGetLastError());
2145 hdr.Control.buf = pktbuf;
2146
2147 /* Now start IP_PKTINFO for future tests */
2148 rc=setsockopt(s1, IPPROTO_IP, IP_PKTINFO, (const char*)&yes, sizeof(yes));
2149 ok(rc == 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
2150
2151 /*
2152 * Send a packet from the client to the server and test for specifying
2153 * a short control header.
2154 */
2155 SetLastError(0xdeadbeef);
2156 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2157 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2158 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
2159 hdr.Control.len = 1;
2160 rc=pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
2161 err=WSAGetLastError();
2162 ok(rc == SOCKET_ERROR && err == WSAEMSGSIZE && (hdr.dwFlags & MSG_CTRUNC),
2163 "WSARecvMsg() failed error: %d (ret: %d, flags: %d)\n", err, rc, hdr.dwFlags);
2164 hdr.dwFlags = 0; /* Reset flags */
2165
2166 /* Perform another short control header test, this time with an overlapped receive */
2167 hdr.Control.len = 1;
2168 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
2169 err=WSAGetLastError();
2170 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
2171 SetLastError(0xdeadbeef);
2172 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2173 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2174 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
2175 if (WaitForSingleObject(ov.hEvent, 100) != WAIT_OBJECT_0)
2176 {
2177 skip("Server side did not receive packet, some tests skipped.\n");
2178 closesocket(s2);
2179 closesocket(s1);
2180 continue;
2181 }
2182 dwFlags = 0;
2183 WSAGetOverlappedResult(s1, &ov, NULL, FALSE, &dwFlags);
2184 ok(dwFlags == 0,
2185 "WSAGetOverlappedResult() returned unexpected flags %d!\n", dwFlags);
2186 ok(hdr.dwFlags == MSG_CTRUNC,
2187 "WSARecvMsg() overlapped operation set unexpected flags %d.\n", hdr.dwFlags);
2188 hdr.dwFlags = 0; /* Reset flags */
2189
2190 /*
2191 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
2192 * on the server end and check that the returned packet matches what was sent.
2193 */
2194 hdr.Control.len = sizeof(pktbuf);
2195 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
2196 err=WSAGetLastError();
2197 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
2198 ok(hdr.Control.len == sizeof(pktbuf),
2199 "WSARecvMsg() control length mismatch (%d != sizeof pktbuf).\n", hdr.Control.len);
2200 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2201 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2202 if (WaitForSingleObject(ov.hEvent, 100) != WAIT_OBJECT_0)
2203 {
2204 skip("Server side did not receive packet, some tests skipped.\n");
2205 closesocket(s2);
2206 closesocket(s1);
2207 continue;
2208 }
2209 dwSize = 0;
2210 WSAGetOverlappedResult(s1, &ov, &dwSize, FALSE, NULL);
2211 ok(dwSize == sizeof(msg),
2212 "WSARecvMsg() buffer length does not match transmitted data!\n");
2213 ok(strncmp(iovec[0].buf, msg, sizeof(msg)) == 0,
2214 "WSARecvMsg() buffer does not match transmitted data!\n");
2215 ok(hdr.Control.len == IP_PKTINFO_LEN,
2216 "WSARecvMsg() control length mismatch (%d).\n", hdr.Control.len);
2217
2218 /* Test for the expected IP_PKTINFO return information. */
2219 foundhdr = FALSE;
2220 for (cmsg = WSA_CMSG_FIRSTHDR(&hdr); cmsg != NULL; cmsg = WSA_CMSG_NXTHDR(&hdr, cmsg))
2221 {
2222 if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO)
2223 {
2224 struct in_pktinfo *pi = (struct in_pktinfo *)WSA_CMSG_DATA(cmsg);
2225
2226 ok(pi->ipi_addr.s_addr == s2addr.sin_addr.s_addr, "destination ip mismatch!\n");
2227 foundhdr = TRUE;
2228 }
2229 }
2230 ok(foundhdr, "IP_PKTINFO header information was not returned!\n");
2231
2232 closesocket(s2);
2233 closesocket(s1);
2234 }
2235
2236 cleanup:
2237 CloseHandle(ov.hEvent);
2238 }
2239
2240 /************* Array containing the tests to run **********/
2241
2242 #define STD_STREAM_SOCKET \
2243 SOCK_STREAM, \
2244 0, \
2245 SERVERIP, \
2246 SERVERPORT
2247
2248 static test_setup tests [] =
2249 {
2250 /* Test 0: synchronous client and server */
2251 {
2252 {
2253 STD_STREAM_SOCKET,
2254 2048,
2255 16,
2256 2
2257 },
2258 simple_server,
2259 {
2260 NULL,
2261 0,
2262 64
2263 },
2264 simple_client,
2265 {
2266 NULL,
2267 0,
2268 128
2269 }
2270 },
2271 /* Test 1: event-driven client, synchronous server */
2272 {
2273 {
2274 STD_STREAM_SOCKET,
2275 2048,
2276 16,
2277 2
2278 },
2279 simple_server,
2280 {
2281 NULL,
2282 0,
2283 64
2284 },
2285 event_client,
2286 {
2287 NULL,
2288 WSA_FLAG_OVERLAPPED,
2289 128
2290 }
2291 },
2292 /* Test 2: synchronous client, non-blocking server via select() */
2293 {
2294 {
2295 STD_STREAM_SOCKET,
2296 2048,
2297 16,
2298 2
2299 },
2300 select_server,
2301 {
2302 NULL,
2303 0,
2304 64
2305 },
2306 simple_client,
2307 {
2308 NULL,
2309 0,
2310 128
2311 }
2312 },
2313 /* Test 3: OOB client, OOB server */
2314 {
2315 {
2316 STD_STREAM_SOCKET,
2317 128,
2318 16,
2319 1
2320 },
2321 oob_server,
2322 {
2323 NULL,
2324 0,
2325 128
2326 },
2327 oob_client,
2328 {
2329 NULL,
2330 0,
2331 128
2332 }
2333 },
2334 /* Test 4: synchronous mixed client and server */
2335 {
2336 {
2337 STD_STREAM_SOCKET,
2338 2048,
2339 16,
2340 2
2341 },
2342 simple_server,
2343 {
2344 NULL,
2345 0,
2346 64
2347 },
2348 simple_mixed_client,
2349 {
2350 NULL,
2351 0,
2352 128
2353 }
2354 }
2355 };
2356
2357 static void test_UDP(void)
2358 {
2359 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
2360 possible that this test fails due to dropped packets. */
2361
2362 /* peer 0 receives data from all other peers */
2363 struct sock_info peer[NUM_UDP_PEERS];
2364 char buf[16];
2365 int ss, i, n_recv, n_sent;
2366
2367 memset (buf,0,sizeof(buf));
2368 for ( i = NUM_UDP_PEERS - 1; i >= 0; i-- ) {
2369 ok ( ( peer[i].s = socket ( AF_INET, SOCK_DGRAM, 0 ) ) != INVALID_SOCKET, "UDP: socket failed\n" );
2370
2371 peer[i].addr.sin_family = AF_INET;
2372 peer[i].addr.sin_addr.s_addr = inet_addr ( SERVERIP );
2373
2374 if ( i == 0 ) {
2375 peer[i].addr.sin_port = htons ( SERVERPORT );
2376 } else {
2377 peer[i].addr.sin_port = htons ( 0 );
2378 }
2379
2380 do_bind ( peer[i].s, (struct sockaddr *) &peer[i].addr, sizeof( peer[i].addr ) );
2381
2382 /* test getsockname() to get peer's port */
2383 ss = sizeof ( peer[i].addr );
2384 ok ( getsockname ( peer[i].s, (struct sockaddr *) &peer[i].addr, &ss ) != SOCKET_ERROR, "UDP: could not getsockname()\n" );
2385 ok ( peer[i].addr.sin_port != htons ( 0 ), "UDP: bind() did not associate port\n" );
2386 }
2387
2388 /* test getsockname() */
2389 ok ( peer[0].addr.sin_port == htons ( SERVERPORT ), "UDP: getsockname returned incorrect peer port\n" );
2390
2391 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
2392 /* send client's ip */
2393 memcpy( buf, &peer[i].addr.sin_port, sizeof(peer[i].addr.sin_port) );
2394 n_sent = sendto ( peer[i].s, buf, sizeof(buf), 0, (struct sockaddr*) &peer[0].addr, sizeof(peer[0].addr) );
2395 ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
2396 }
2397
2398 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
2399 n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0,(struct sockaddr *) &peer[0].peer, &ss );
2400 ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
2401 ok ( memcmp ( &peer[0].peer.sin_port, buf, sizeof(peer[0].addr.sin_port) ) == 0, "UDP: port numbers do not match\n" );
2402 }
2403 }
2404
2405 static DWORD WINAPI do_getservbyname( void *param )
2406 {
2407 struct {
2408 const char *name;
2409 const char *proto;
2410 int port;
2411 } serv[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
2412
2413 HANDLE *starttest = param;
2414 int i, j;
2415 struct servent *pserv[2];
2416
2417 ok ( WaitForSingleObject ( *starttest, TEST_TIMEOUT * 1000 ) != WAIT_TIMEOUT,
2418 "test_getservbyname: timeout waiting for start signal\n" );
2419
2420 /* ensure that necessary buffer resizes are completed */
2421 for ( j = 0; j < 2; j++) {
2422 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
2423 }
2424
2425 for ( i = 0; i < NUM_QUERIES / 2; i++ ) {
2426 for ( j = 0; j < 2; j++ ) {
2427 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
2428 ok ( pserv[j] != NULL || broken(pserv[j] == NULL) /* win8, fixed in win81 */,
2429 "getservbyname could not retrieve information for %s: %d\n", serv[j].name, WSAGetLastError() );
2430 if ( !pserv[j] ) continue;
2431 ok ( pserv[j]->s_port == htons(serv[j].port),
2432 "getservbyname returned the wrong port for %s: %d\n", serv[j].name, ntohs(pserv[j]->s_port) );
2433 ok ( !strcmp ( pserv[j]->s_proto, serv[j].proto ),
2434 "getservbyname returned the wrong protocol for %s: %s\n", serv[j].name, pserv[j]->s_proto );
2435 ok ( !strcmp ( pserv[j]->s_name, serv[j].name ),
2436 "getservbyname returned the wrong name for %s: %s\n", serv[j].name, pserv[j]->s_name );
2437 }
2438
2439 ok ( pserv[0] == pserv[1] || broken(pserv[0] != pserv[1]) /* win8, fixed in win81 */,
2440 "getservbyname: winsock resized servent buffer when not necessary\n" );
2441 }
2442
2443 return 0;
2444 }
2445
2446 static void test_getservbyname(void)
2447 {
2448 int i;
2449 HANDLE starttest, thread[NUM_THREADS];
2450 DWORD thread_id[NUM_THREADS];
2451
2452 starttest = CreateEventA ( NULL, 1, 0, "test_getservbyname_starttest" );
2453
2454 /* create threads */
2455 for ( i = 0; i < NUM_THREADS; i++ ) {
2456 thread[i] = CreateThread ( NULL, 0, do_getservbyname, &starttest, 0, &thread_id[i] );
2457 }
2458
2459 /* signal threads to start */
2460 SetEvent ( starttest );
2461
2462 for ( i = 0; i < NUM_THREADS; i++) {
2463 WaitForSingleObject ( thread[i], TEST_TIMEOUT * 1000 );
2464 }
2465 }
2466
2467 static void test_WSASocket(void)
2468 {
2469 SOCKET sock = INVALID_SOCKET;
2470 WSAPROTOCOL_INFOA *pi;
2471 int wsaproviders[] = {IPPROTO_TCP, IPPROTO_IP};
2472 int autoprotocols[] = {IPPROTO_TCP, IPPROTO_UDP};
2473 int items, err, size, socktype, i, j;
2474 UINT pi_size;
2475
2476 SetLastError(0xdeadbeef);
2477 ok(WSASocketA(0, 0, 0, NULL, 0, 0) == INVALID_SOCKET,
2478 "WSASocketA should have failed\n");
2479 err = WSAGetLastError();
2480 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2481
2482 sock = WSASocketA(AF_INET, 0, 0, NULL, 0, 0);
2483 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2484 closesocket(sock);
2485
2486 sock = WSASocketA(AF_INET, SOCK_STREAM, 0, NULL, 0, 0);
2487 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2488 closesocket(sock);
2489
2490 SetLastError(0xdeadbeef);
2491 ok(WSASocketA(0, SOCK_STREAM, -1, NULL, 0, 0) == INVALID_SOCKET,
2492 "WSASocketA should have failed\n");
2493 err = WSAGetLastError();
2494 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2495
2496 SetLastError(0xdeadbeef);
2497 ok(WSASocketA(0, -1, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
2498 "WSASocketA should have failed\n");
2499 err = WSAGetLastError();
2500 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2501
2502 SetLastError(0xdeadbeef);
2503 ok(WSASocketA(0, -1, 0, NULL, 0, 0) == INVALID_SOCKET,
2504 "WSASocketA should have failed\n");
2505 err = WSAGetLastError();
2506 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2507
2508 SetLastError(0xdeadbeef);
2509 ok(WSASocketA(AF_INET, -1, 0, NULL, 0, 0) == INVALID_SOCKET,
2510 "WSASocketA should have failed\n");
2511 err = WSAGetLastError();
2512 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2513
2514 SetLastError(0xdeadbeef);
2515 ok(WSASocketA(AF_INET, 0, -1, NULL, 0, 0) == INVALID_SOCKET,
2516 "WSASocketA should have failed\n");
2517 err = WSAGetLastError();
2518 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2519
2520 SetLastError(0xdeadbeef);
2521 ok(WSASocketA(0, -1, -1, NULL, 0, 0) == INVALID_SOCKET,
2522 "WSASocketA should have failed\n");
2523 err = WSAGetLastError();
2524 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2525
2526 SetLastError(0xdeadbeef);
2527 ok(WSASocketA(-1, SOCK_STREAM, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
2528 "WSASocketA should have failed\n");
2529 err = WSAGetLastError();
2530 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
2531
2532 sock = WSASocketA(AF_INET, 0, IPPROTO_TCP, NULL, 0, 0);
2533 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2534 closesocket(sock);
2535
2536 SetLastError(0xdeadbeef);
2537 ok(WSASocketA(0, SOCK_STREAM, 0, NULL, 0, 0) == INVALID_SOCKET,
2538 "WSASocketA should have failed\n");
2539 err = WSAGetLastError();
2540 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2541
2542 SetLastError(0xdeadbeef);
2543 ok(WSASocketA(0, 0, 0xdead, NULL, 0, 0) == INVALID_SOCKET,
2544 "WSASocketA should have failed\n");
2545 err = WSAGetLastError();
2546 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2547
2548 SetLastError(0xdeadbeef);
2549 ok(WSASocketA(AF_INET, 0xdead, 0, NULL, 0, 0) == INVALID_SOCKET,
2550 "WSASocketA should have failed\n");
2551 err = WSAGetLastError();
2552 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2553
2554 SetLastError(0xdeadbeef);
2555 ok(WSASocketA(0, 0xdead, 0, NULL, 0, 0) == INVALID_SOCKET,
2556 "WSASocketA should have failed\n");
2557 err = WSAGetLastError();
2558 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2559
2560 sock = WSASocketA(0, 0, IPPROTO_TCP, NULL, 0, 0);
2561 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2562 closesocket(sock);
2563
2564 /* SOCK_STREAM does not support IPPROTO_UDP */
2565 SetLastError(0xdeadbeef);
2566 ok(WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
2567 "WSASocketA should have failed\n");
2568 err = WSAGetLastError();
2569 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2570
2571 /* SOCK_DGRAM does not support IPPROTO_TCP */
2572 SetLastError(0xdeadbeef);
2573 ok(WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_TCP, NULL, 0, 0) == INVALID_SOCKET,
2574 "WSASocketA should have failed\n");
2575 err = WSAGetLastError();
2576 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2577
2578 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
2579 * to avoid a crash on win98.
2580 */
2581 pi_size = 0;
2582 items = WSAEnumProtocolsA(wsaproviders, NULL, &pi_size);
2583 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
2584 items);
2585 err = WSAGetLastError();
2586 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2587 err, WSAENOBUFS);
2588
2589 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
2590 ok(pi != NULL, "Failed to allocate memory\n");
2591 if (pi == NULL) {
2592 skip("Can't continue without memory.\n");
2593 return;
2594 }
2595
2596 items = WSAEnumProtocolsA(wsaproviders, pi, &pi_size);
2597 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
2598 WSAGetLastError());
2599
2600 if (items == 0) {
2601 skip("No protocols enumerated.\n");
2602 HeapFree(GetProcessHeap(), 0, pi);
2603 return;
2604 }
2605
2606 sock = WSASocketA(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
2607 FROM_PROTOCOL_INFO, &pi[0], 0, 0);
2608 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2609 WSAGetLastError());
2610 closesocket(sock);
2611
2612 /* find what parameters are used first: plain parameters or protocol info struct */
2613 pi[0].iProtocol = -1;
2614 pi[0].iSocketType = -1;
2615 pi[0].iAddressFamily = -1;
2616 ok(WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0) == INVALID_SOCKET,
2617 "WSASocketA should have failed\n");
2618 err = WSAGetLastError();
2619 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
2620
2621 pi[0].iProtocol = 0;
2622 pi[0].iSocketType = 0;
2623 pi[0].iAddressFamily = 0;
2624 sock = WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0);
2625 if(sock != INVALID_SOCKET)
2626 {
2627 win_skip("must work only in OS <= 2003\n");
2628 closesocket(sock);
2629 }
2630 else
2631 {
2632 err = WSAGetLastError();
2633 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
2634 }
2635
2636 pi[0].iProtocol = IPPROTO_UDP;
2637 pi[0].iSocketType = SOCK_DGRAM;
2638 pi[0].iAddressFamily = AF_INET;
2639 sock = WSASocketA(0, 0, 0, &pi[0], 0, 0);
2640 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2641 WSAGetLastError());
2642 size = sizeof(socktype);
2643 socktype = 0xdead;
2644 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2645 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2646 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2647 SOCK_DGRAM, socktype);
2648 closesocket(sock);
2649
2650 sock = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, &pi[0], 0, 0);
2651 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2652 WSAGetLastError());
2653 size = sizeof(socktype);
2654 socktype = 0xdead;
2655 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2656 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2657 ok(socktype == SOCK_STREAM, "Wrong socket type, expected %d received %d\n",
2658 SOCK_STREAM, socktype);
2659 closesocket(sock);
2660
2661 HeapFree(GetProcessHeap(), 0, pi);
2662
2663 pi_size = 0;
2664 items = WSAEnumProtocolsA(NULL, NULL, &pi_size);
2665 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
2666 items);
2667 err = WSAGetLastError();
2668 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2669 err, WSAENOBUFS);
2670
2671 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
2672 ok(pi != NULL, "Failed to allocate memory\n");
2673 if (pi == NULL) {
2674 skip("Can't continue without memory.\n");
2675 return;
2676 }
2677
2678 items = WSAEnumProtocolsA(NULL, pi, &pi_size);
2679 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
2680 WSAGetLastError());
2681
2682 /* when no protocol and socket type are specified the first entry
2683 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
2684 * is returned */
2685 sock = WSASocketA(AF_INET, 0, 0, NULL, 0, 0);
2686 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2687 WSAGetLastError());
2688
2689 size = sizeof(socktype);
2690 socktype = 0xdead;
2691 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2692 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2693 for(i = 0; i < items; i++)
2694 {
2695 if(pi[i].dwProviderFlags & PFL_MATCHES_PROTOCOL_ZERO)
2696 {
2697 ok(socktype == pi[i].iSocketType, "Wrong socket type, expected %d received %d\n",
2698 pi[i].iSocketType, socktype);
2699 break;
2700 }
2701 }
2702 ok(i != items, "Creating a socket without protocol and socket type didn't work\n");
2703 closesocket(sock);
2704
2705 /* when no socket type is specified the first entry from WSAEnumProtocols
2706 * that matches the protocol is returned */
2707 for (i = 0; i < ARRAY_SIZE(autoprotocols); i++)
2708 {
2709 sock = WSASocketA(0, 0, autoprotocols[i], NULL, 0, 0);
2710 ok(sock != INVALID_SOCKET, "Failed to create socket for protocol %d, received %d\n",
2711 autoprotocols[i], WSAGetLastError());
2712
2713 size = sizeof(socktype);
2714 socktype = 0xdead;
2715 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2716 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2717
2718 for (err = 1, j = 0; j < items; j++)
2719 {
2720 if (pi[j].iProtocol == autoprotocols[i])
2721 {
2722 if (socktype == pi[j].iSocketType)
2723 err = 0;
2724 else
2725 ok(0, "Wrong socket type, expected %d received %d\n",
2726 pi[j].iSocketType, socktype);
2727 break;
2728 }
2729 }
2730 ok(!err, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols[i]);
2731
2732 closesocket(sock);
2733 }
2734
2735 HeapFree(GetProcessHeap(), 0, pi);
2736
2737 SetLastError(0xdeadbeef);
2738 /* starting on vista the socket function returns error during the socket
2739 creation and no longer in the socket operations (sendto, readfrom) */
2740 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
2741 if (sock == INVALID_SOCKET)
2742 {
2743 err = WSAGetLastError();
2744 ok(err == WSAEACCES, "Expected 10013, received %d\n", err);
2745 skip("SOCK_RAW is not supported\n");
2746 }
2747 else
2748 {
2749 trace("SOCK_RAW is supported\n");
2750
2751 size = sizeof(socktype);
2752 socktype = 0xdead;
2753 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2754 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2755 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2756 SOCK_RAW, socktype);
2757 closesocket(sock);
2758
2759 todo_wine {
2760 sock = WSASocketA(0, 0, IPPROTO_RAW, NULL, 0, 0);
2761 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2762 WSAGetLastError());
2763 size = sizeof(socktype);
2764 socktype = 0xdead;
2765 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2766 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2767 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2768 SOCK_RAW, socktype);
2769 closesocket(sock);
2770 }
2771
2772 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_TCP, NULL, 0, 0);
2773 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2774 WSAGetLastError());
2775 size = sizeof(socktype);
2776 socktype = 0xdead;
2777 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2778 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2779 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2780 SOCK_RAW, socktype);
2781 closesocket(sock);
2782 }
2783
2784 /* IPX socket tests */
2785
2786 SetLastError(0xdeadbeef);
2787 sock = WSASocketA(AF_IPX, SOCK_DGRAM, NSPROTO_IPX, NULL, 0, 0);
2788 if (sock == INVALID_SOCKET)
2789 {
2790 err = WSAGetLastError();
2791 ok(err == WSAEAFNOSUPPORT || broken(err == WSAEPROTONOSUPPORT), "Expected 10047, received %d\n", err);
2792 skip("IPX is not supported\n");
2793 }
2794 else
2795 {
2796 WSAPROTOCOL_INFOA info;
2797 closesocket(sock);
2798
2799 trace("IPX is supported\n");
2800
2801 sock = WSASocketA(0, 0, NSPROTO_IPX, NULL, 0, 0);
2802 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2803 WSAGetLastError());
2804
2805 size = sizeof(socktype);
2806 socktype = 0xdead;
2807 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2808 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2809 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2810 SOCK_DGRAM, socktype);
2811
2812 /* check socket family, type and protocol */
2813 size = sizeof(WSAPROTOCOL_INFOA);
2814 err = getsockopt(sock, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &info, &size);
2815 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2816 ok(info.iProtocol == NSPROTO_IPX, "expected protocol %d, received %d\n",
2817 NSPROTO_IPX, info.iProtocol);
2818 ok(info.iAddressFamily == AF_IPX, "expected family %d, received %d\n",
2819 AF_IPX, info.iProtocol);
2820 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
2821 SOCK_DGRAM, info.iSocketType);
2822 closesocket(sock);
2823
2824 /* SOCK_STREAM does not support NSPROTO_IPX */
2825 SetLastError(0xdeadbeef);
2826 ok(WSASocketA(AF_IPX, SOCK_STREAM, NSPROTO_IPX, NULL, 0, 0) == INVALID_SOCKET,
2827 "WSASocketA should have failed\n");
2828 err = WSAGetLastError();
2829 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2830
2831 /* test extended IPX support - that is adding any number between 0 and 255
2832 * to the IPX protocol value will make it be used as IPX packet type */
2833 for(i = 0;i <= 255;i += 17)
2834 {
2835 SetLastError(0xdeadbeef);
2836 sock = WSASocketA(0, 0, NSPROTO_IPX + i, NULL, 0, 0);
2837 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2838 WSAGetLastError());
2839
2840 size = sizeof(int);
2841 socktype = -1;
2842 err = getsockopt(sock, NSPROTO_IPX, IPX_PTYPE, (char *) &socktype, &size);
2843 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2844 ok(socktype == i, "Wrong IPX packet type, expected %d received %d\n",
2845 i, socktype);
2846
2847 closesocket(sock);
2848 }
2849 }
2850 }
2851
2852 static void test_WSADuplicateSocket(void)
2853 {
2854 SOCKET source, dupsock;
2855 WSAPROTOCOL_INFOA info;
2856 DWORD err;
2857 struct sockaddr_in addr;
2858 int socktype, size, addrsize, ret;
2859 char teststr[] = "TEST", buffer[16];
2860
2861 source = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
2862 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2863
2864 /* test invalid parameters */
2865 SetLastError(0xdeadbeef);
2866 ok(WSADuplicateSocketA(0, 0, NULL), "WSADuplicateSocketA should have failed\n");
2867 err = WSAGetLastError();
2868 ok(err == WSAENOTSOCK, "expected 10038, received %d\n", err);
2869
2870 SetLastError(0xdeadbeef);
2871 ok(WSADuplicateSocketA(source, 0, NULL),
2872 "WSADuplicateSocketA should have failed\n");
2873 err = WSAGetLastError();
2874 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2875
2876 SetLastError(0xdeadbeef);
2877 ok(WSADuplicateSocketA(source, ~0, &info),
2878 "WSADuplicateSocketA should have failed\n");
2879 err = WSAGetLastError();
2880 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2881
2882 SetLastError(0xdeadbeef);
2883 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info),
2884 "WSADuplicateSocketA should have failed\n");
2885 err = WSAGetLastError();
2886 ok(err == WSAENOTSOCK, "expected 10038, received %d\n", err);
2887
2888 SetLastError(0xdeadbeef);
2889 ok(WSADuplicateSocketA(source, GetCurrentProcessId(), NULL),
2890 "WSADuplicateSocketA should have failed\n");
2891 err = WSAGetLastError();
2892 ok(err == WSAEFAULT, "expected 10014, received %d\n", err);
2893
2894 /* test returned structure */
2895 memset(&info, 0, sizeof(info));
2896 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2897 "WSADuplicateSocketA should have worked\n");
2898
2899 ok(info.iProtocol == IPPROTO_TCP, "expected protocol %d, received %d\n",
2900 IPPROTO_TCP, info.iProtocol);
2901 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
2902 AF_INET, info.iProtocol);
2903 ok(info.iSocketType == SOCK_STREAM, "expected type %d, received %d\n",
2904 SOCK_STREAM, info.iSocketType);
2905
2906 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2907 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2908
2909 closesocket(dupsock);
2910 closesocket(source);
2911
2912 /* create a socket, bind it, duplicate it then send data on source and
2913 * receive in the duplicated socket */
2914 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
2915 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2916
2917 memset(&info, 0, sizeof(info));
2918 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2919 "WSADuplicateSocketA should have worked\n");
2920
2921 ok(info.iProtocol == IPPROTO_UDP, "expected protocol %d, received %d\n",
2922 IPPROTO_UDP, info.iProtocol);
2923 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
2924 AF_INET, info.iProtocol);
2925 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
2926 SOCK_DGRAM, info.iSocketType);
2927
2928 memset(&addr, 0, sizeof(addr));
2929 addr.sin_family = AF_INET;
2930 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2931 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
2932 "bind should have worked\n");
2933
2934 /* read address to find out the port number to be used in sendto */
2935 memset(&addr, 0, sizeof(addr));
2936 addrsize = sizeof(addr);
2937 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
2938 "getsockname should have worked\n");
2939 ok(addr.sin_port, "socket port should be != 0\n");
2940
2941 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2942 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2943
2944 size = sizeof(int);
2945 ret = getsockopt(dupsock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2946 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
2947 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2948 SOCK_DGRAM, socktype);
2949
2950 set_blocking(source, TRUE);
2951
2952 /* send data on source socket */
2953 addrsize = sizeof(addr);
2954 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
2955 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2956
2957 /* receive on duplicated socket */
2958 addrsize = sizeof(addr);
2959 memset(buffer, 0, sizeof(buffer));
2960 size = recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize);
2961 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2962 buffer[sizeof(teststr) - 1] = 0;
2963 ok(!strcmp(buffer, teststr), "expected '%s', received '%s'\n", teststr, buffer);
2964
2965 closesocket(dupsock);
2966 closesocket(source);
2967
2968 /* show that the source socket need to be bound before the duplicated
2969 * socket is created */
2970 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
2971 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2972
2973 memset(&info, 0, sizeof(info));
2974 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2975 "WSADuplicateSocketA should have worked\n");
2976
2977 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2978 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2979
2980 memset(&addr, 0, sizeof(addr));
2981 addr.sin_family = AF_INET;
2982 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2983 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
2984 "bind should have worked\n");
2985
2986 /* read address to find out the port number to be used in sendto */
2987 memset(&addr, 0, sizeof(addr));
2988 addrsize = sizeof(addr);
2989 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
2990 "getsockname should have worked\n");
2991 ok(addr.sin_port, "socket port should be != 0\n");
2992
2993 set_blocking(source, TRUE);
2994
2995 addrsize = sizeof(addr);
2996 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
2997 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2998
2999 SetLastError(0xdeadbeef);
3000 addrsize = sizeof(addr);
3001 memset(buffer, 0, sizeof(buffer));
3002 todo_wine {
3003 ok(recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize) == -1,
3004 "recvfrom should have failed\n");
3005 err = WSAGetLastError();
3006 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
3007 }
3008
3009 closesocket(dupsock);
3010 closesocket(source);
3011 }
3012
3013 static void test_WSAEnumNetworkEvents(void)
3014 {
3015 SOCKET s, s2;
3016 int sock_type[] = {SOCK_STREAM, SOCK_DGRAM, SOCK_STREAM}, i, j, k, l;
3017 struct sockaddr_in address;
3018 HANDLE event;
3019 WSANETWORKEVENTS net_events;
3020
3021 memset(&address, 0, sizeof(address));
3022 address.sin_addr.s_addr = htonl(INADDR_ANY);
3023 address.sin_family = AF_INET;
3024
3025 /* This test follows the steps from bugs 10204 and 24946 */
3026 for (l = 0; l < 2; l++)
3027 {
3028 for (i = 0; i < ARRAY_SIZE(sock_type); i++)
3029 {
3030 if (i == 2)
3031 ok(!tcp_socketpair(&s, &s2), "Test[%d]: creating socket pair failed\n", i);
3032 else
3033 {
3034 s = socket(AF_INET, sock_type[i], 0);
3035 ok (s != SOCKET_ERROR, "Test[%d]: failed to create socket\n", i);
3036 ok (!bind(s, (struct sockaddr*) &address, sizeof(address)), "Test[%d]: bind failed\n", i);
3037 }
3038 event = WSACreateEvent();
3039 ok (event != NULL, "Test[%d]: failed to create event\n", i);
3040 for (j = 0; j < 5; j++) /* Repeat sometimes and the result must be the same */
3041 {
3042 /* When the TCP socket is not connected NO events will be returned.
3043 * When connected and no data pending it will get the write event.
3044 * UDP sockets don't have connections so as soon as they are bound
3045 * they can read/write data. Since nobody is sendind us data only
3046 * the write event will be returned and ONLY once.
3047 */
3048 ok (!WSAEventSelect(s, event, FD_READ | FD_WRITE), "Test[%d]: WSAEventSelect failed\n", i);
3049 memset(&net_events, 0xAB, sizeof(net_events));
3050 ok (!WSAEnumNetworkEvents(s, l == 0 ? event : NULL, &net_events),
3051 "Test[%d]: WSAEnumNetworkEvents failed\n", i);
3052 if (i >= 1 && j == 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
3053 {
3054 ok (net_events.lNetworkEvents == FD_WRITE, "Test[%d]: expected 2, got %d\n",
3055 i, net_events.lNetworkEvents);
3056 }
3057 else
3058 {
3059 todo_wine_if (i != 0) /* Remove when fixed */
3060 ok (net_events.lNetworkEvents == 0, "Test[%d]: expected 0, got %d\n",
3061 i, net_events.lNetworkEvents);
3062 }
3063 for (k = 0; k < FD_MAX_EVENTS; k++)
3064 {
3065 if (net_events.lNetworkEvents & (1 << k))
3066 {
3067 ok (net_events.iErrorCode[k] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
3068 i, k, net_events.iErrorCode[k]);
3069 }
3070 else
3071 {
3072 /* Bits that are not set in lNetworkEvents MUST not be changed */
3073 ok (net_events.iErrorCode[k] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
3074 i, k, net_events.iErrorCode[k]);
3075 }
3076 }
3077 }
3078 closesocket(s);
3079 WSACloseEvent(event);
3080 if (i == 2) closesocket(s2);
3081 }
3082 }
3083 }
3084
3085 static void test_WSAAddressToStringA(void)
3086 {
3087 SOCKET v6 = INVALID_SOCKET;
3088 INT ret;
3089 DWORD len;
3090 int GLE;
3091 SOCKADDR_IN sockaddr;
3092 CHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
3093
3094 CHAR expect1[] = "0.0.0.0";
3095 CHAR expect2[] = "255.255.255.255";
3096 CHAR expect3[] = "0.0.0.0:65535";
3097 CHAR expect4[] = "255.255.255.255:65535";
3098
3099 SOCKADDR_IN6 sockaddr6;
3100 CHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
3101
3102 CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3103 CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3104 CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
3105
3106 CHAR expect6_1[] = "::1";
3107 CHAR expect6_2[] = "20ab::1";
3108 CHAR expect6_3[] = "[20ab::2001]:33274";
3109 CHAR expect6_3_2[] = "[20ab::2001%4660]:33274";
3110 CHAR expect6_3_3[] = "20ab::2001%4660";
3111
3112 len = 0;
3113
3114 sockaddr.sin_family = AF_INET;
3115 sockaddr.sin_port = 0;
3116 sockaddr.sin_addr.s_addr = 0;
3117
3118 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3119 GLE = WSAGetLastError();
3120 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
3121 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
3122 GLE, ret );
3123
3124 len = sizeof(address);
3125
3126 sockaddr.sin_family = AF_INET;
3127 sockaddr.sin_port = 0;
3128 sockaddr.sin_addr.s_addr = 0;
3129
3130 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3131 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3132
3133 ok( !strcmp( address, expect1 ), "Expected: %s, got: %s\n", expect1, address );
3134 ok( len == sizeof( expect1 ), "Got size %d\n", len);
3135
3136 len = sizeof(address);
3137
3138 sockaddr.sin_family = AF_INET;
3139 sockaddr.sin_port = 0;
3140 sockaddr.sin_addr.s_addr = 0xffffffff;
3141
3142 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3143 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3144
3145 ok( !strcmp( address, expect2 ), "Expected: %s, got: %s\n", expect2, address );
3146
3147 len = sizeof(address);
3148
3149 sockaddr.sin_family = AF_INET;
3150 sockaddr.sin_port = 0xffff;
3151 sockaddr.sin_addr.s_addr = 0;
3152
3153 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3154 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3155
3156 ok( !strcmp( address, expect3 ), "Expected: %s, got: %s\n", expect3, address );
3157
3158 len = sizeof(address);
3159
3160 sockaddr.sin_family = AF_INET;
3161 sockaddr.sin_port = 0xffff;
3162 sockaddr.sin_addr.s_addr = 0xffffffff;
3163
3164 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3165 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3166
3167 ok( !strcmp( address, expect4 ), "Expected: %s, got: %s\n", expect4, address );
3168 ok( len == sizeof( expect4 ), "Got size %d\n", len);
3169
3170 /*check to see it IPv6 is available */
3171 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
3172 if (v6 == INVALID_SOCKET) {
3173 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
3174 WSAGetLastError(), WSAEAFNOSUPPORT);
3175 goto end;
3176 }
3177 /* Test a short IPv6 address */
3178 len = sizeof(address6);
3179
3180 sockaddr6.sin6_family = AF_INET6;
3181 sockaddr6.sin6_port = 0x0000;
3182 sockaddr6.sin6_scope_id = 0;
3183 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
3184
3185 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3186 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3187 ok( !strcmp( address6, expect6_1 ), "Expected: %s, got: %s\n", expect6_1, address6 );
3188 ok( len == sizeof(expect6_1), "Got size %d\n", len);
3189
3190 /* Test a longer IPv6 address */
3191 len = sizeof(address6);
3192
3193 sockaddr6.sin6_family = AF_INET6;
3194 sockaddr6.sin6_port = 0x0000;
3195 sockaddr6.sin6_scope_id = 0;
3196 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_2, sizeof(addr6_2));
3197
3198 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3199 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3200 ok( !strcmp( address6, expect6_2 ), "Expected: %s, got: %s\n", expect6_2, address6 );
3201 ok( len == sizeof(expect6_2), "Got size %d\n", len);
3202
3203 /* Test IPv6 address and port number */
3204 len = sizeof(address6);
3205
3206 sockaddr6.sin6_family = AF_INET6;
3207 sockaddr6.sin6_port = 0xfa81;
3208 sockaddr6.sin6_scope_id = 0;
3209 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3210
3211 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3212 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3213 ok( !strcmp( address6, expect6_3 ), "Expected: %s, got: %s\n", expect6_3, address6 );
3214 ok( len == sizeof(expect6_3), "Got size %d\n", len );
3215
3216 /* Test IPv6 address, port number and scope_id */
3217 len = sizeof(address6);
3218
3219 sockaddr6.sin6_family = AF_INET6;
3220 sockaddr6.sin6_port = 0xfa81;
3221 sockaddr6.sin6_scope_id = 0x1234;
3222 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3223
3224 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3225 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3226 ok( !strcmp( address6, expect6_3_2 ), "Expected: %s, got: %s\n", expect6_3_2, address6 );
3227 ok( len == sizeof(expect6_3_2), "Got size %d\n", len );
3228
3229 /* Test IPv6 address and scope_id */
3230 len = sizeof(address6);
3231
3232 sockaddr6.sin6_family = AF_INET6;
3233 sockaddr6.sin6_port = 0x0000;
3234 sockaddr6.sin6_scope_id = 0x1234;
3235 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3236
3237 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3238 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3239 ok( !strcmp( address6, expect6_3_3 ), "Expected: %s, got: %s\n", expect6_3_3, address6 );
3240 ok( len == sizeof(expect6_3_3), "Got size %d\n", len );
3241
3242 end:
3243 if (v6 != INVALID_SOCKET)
3244 closesocket(v6);
3245 }
3246
3247 static void test_WSAAddressToStringW(void)
3248 {
3249 SOCKET v6 = INVALID_SOCKET;
3250 INT ret;
3251 DWORD len;
3252 int GLE;
3253 SOCKADDR_IN sockaddr;
3254 WCHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
3255
3256 WCHAR expect1[] = { '0','.','0','.','0','.','0', 0 };
3257 WCHAR expect2[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
3258 WCHAR expect3[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
3259 WCHAR expect4[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
3260 '6', '5', '5', '3', '5', 0 };
3261
3262 SOCKADDR_IN6 sockaddr6;
3263 WCHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
3264
3265 CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3266 CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3267 CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
3268
3269 WCHAR expect6_1[] = {':',':','1',0};
3270 WCHAR expect6_2[] = {'2','0','a','b',':',':','1',0};
3271 WCHAR expect6_3[] = {'[','2','0','a','b',':',':','2','0','0','1',']',':','3','3','2','7','4',0};
3272 WCHAR expect6_3_2[] = {'[','2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',']',':','3','3','2','7','4',0};
3273 WCHAR expect6_3_3[] = {'2','0','a','b',':',':','2','0','0','1','%','6','5','5','3','4',0};
3274
3275 len = 0;
3276
3277 sockaddr.sin_family = AF_INET;
3278 sockaddr.sin_port = 0;
3279 sockaddr.sin_addr.s_addr = 0;
3280
3281 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3282 GLE = WSAGetLastError();
3283 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
3284 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
3285 GLE, ret );
3286
3287 len = sizeof(address);
3288
3289 sockaddr.sin_family = AF_INET;
3290 sockaddr.sin_port = 0;
3291 sockaddr.sin_addr.s_addr = 0;
3292
3293 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3294 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3295
3296 ok( !lstrcmpW( address, expect1 ), "Expected different address string\n" );
3297 ok( len == ARRAY_SIZE(expect1), "Got size %d\n", len);
3298
3299 len = sizeof(address);
3300
3301 sockaddr.sin_family = AF_INET;
3302 sockaddr.sin_port = 0;
3303 sockaddr.sin_addr.s_addr = 0xffffffff;
3304
3305 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3306 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3307
3308 ok( !lstrcmpW( address, expect2 ), "Expected different address string\n" );
3309
3310 len = sizeof(address);
3311
3312 sockaddr.sin_family = AF_INET;
3313 sockaddr.sin_port = 0xffff;
3314 sockaddr.sin_addr.s_addr = 0;
3315
3316 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3317 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3318
3319 ok( !lstrcmpW( address, expect3 ), "Expected different address string\n" );
3320
3321 len = sizeof(address);
3322
3323 sockaddr.sin_family = AF_INET;
3324 sockaddr.sin_port = 0xffff;
3325 sockaddr.sin_addr.s_addr = 0xffffffff;
3326
3327 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3328 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3329
3330 ok( !lstrcmpW( address, expect4 ), "Expected different address string\n" );
3331 ok( len == ARRAY_SIZE(expect4), "Got %d\n", len);
3332
3333 /*check to see it IPv6 is available */
3334 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
3335 if (v6 == INVALID_SOCKET) {
3336 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
3337 WSAGetLastError(), WSAEAFNOSUPPORT);
3338 goto end;
3339 }
3340
3341 /* Test a short IPv6 address */
3342 len = ARRAY_SIZE(address6);
3343
3344 sockaddr6.sin6_family = AF_INET6;
3345 sockaddr6.sin6_port = 0x0000;
3346 sockaddr6.sin6_scope_id = 0;
3347 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
3348
3349 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3350 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3351 ok( !lstrcmpW( address6, expect6_1 ), "Wrong string returned\n" );
3352 ok( len == ARRAY_SIZE(expect6_1), "Got %d\n", len);
3353
3354 /* Test a longer IPv6 address */
3355 len = ARRAY_SIZE(address6);
3356
3357 sockaddr6.sin6_family = AF_INET6;
3358 sockaddr6.sin6_port = 0x0000;
3359 sockaddr6.sin6_scope_id = 0;
3360 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_2, sizeof(addr6_2));
3361
3362 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3363 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3364
3365 ok( !lstrcmpW( address6, expect6_2 ), "Wrong string returned\n" );
3366 ok( len == ARRAY_SIZE(expect6_2), "Got %d\n", len);
3367
3368 /* Test IPv6 address and port number */
3369 len = ARRAY_SIZE(address6);
3370
3371 sockaddr6.sin6_family = AF_INET6;
3372 sockaddr6.sin6_port = 0xfa81;
3373 sockaddr6.sin6_scope_id = 0;
3374 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3375
3376 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3377 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3378 ok( !lstrcmpW( address6, expect6_3 ),
3379 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3), wine_dbgstr_w(address6) );
3380 ok( len == ARRAY_SIZE(expect6_3), "Got %d\n", len );
3381
3382 /* Test IPv6 address, port number and scope_id */
3383 len = ARRAY_SIZE(address6);
3384
3385 sockaddr6.sin6_family = AF_INET6;
3386 sockaddr6.sin6_port = 0xfa81;
3387 sockaddr6.sin6_scope_id = 0x1234;
3388 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3389
3390 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3391 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3392 ok( !lstrcmpW( address6, expect6_3_2 ),
3393 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_2), wine_dbgstr_w(address6) );
3394 ok( len == ARRAY_SIZE(expect6_3_2), "Got %d\n", len );
3395
3396 /* Test IPv6 address and scope_id */
3397 len = ARRAY_SIZE(address6);
3398
3399 sockaddr6.sin6_family = AF_INET6;
3400 sockaddr6.sin6_port = 0x0000;
3401 sockaddr6.sin6_scope_id = 0xfffe;
3402 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3403
3404 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3405 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3406 ok( !lstrcmpW( address6, expect6_3_3 ),
3407 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_3), wine_dbgstr_w(address6) );
3408 ok( len == ARRAY_SIZE(expect6_3_3), "Got %d\n", len );
3409
3410 end:
3411 if (v6 != INVALID_SOCKET)
3412 closesocket(v6);
3413 }
3414
3415 static void test_WSAStringToAddress(void)
3416 {
3417 static struct
3418 {
3419 char input[32];
3420 ULONG address;
3421 USHORT port;
3422 int error;
3423 }
3424 ipv4_tests[] =
3425 {
3426 { "0.0.0.0", 0 },
3427 { "127.127.127.127", 0x7f7f7f7f },
3428 { "255.255.255.255", 0xffffffff },
3429 { "127.127.127.127:65535", 0x7f7f7f7f, 65535 },
3430 { "255.255.255.255:65535", 0xffffffff, 65535 },
3431 { "2001::1", 0xd1070000, 0, WSAEINVAL },
3432 { "1.2.3.", 0, 0, WSAEINVAL },
3433 { "", 0, 0, WSAEINVAL },
3434 };
3435 static struct
3436 {
3437 char input[64];
3438 USHORT address[8];
3439 USHORT port;
3440 int error;
3441 }
3442 ipv6_tests[] =
3443 {
3444 { "::1", { 0, 0, 0, 0, 0, 0, 0, 0x100 } },
3445 { "[::1]", { 0, 0, 0, 0, 0, 0, 0, 0x100 } },
3446 { "[::1]:65535", { 0, 0, 0, 0, 0, 0, 0, 0x100 }, 0xffff },
3447 { "2001::1", { 0x120, 0, 0, 0, 0, 0, 0, 0x100 } },
3448 { "::1]:65535", { 0, 0, 0, 0, 0, 0, 0, 0x100 }, 0, WSAEINVAL },
3449 { "001::1", { 0x100, 0, 0, 0, 0, 0, 0, 0x100 } },
3450 { "::1:2:3:4:5:6:7", { 0, 0, 0x100, 0x200, 0x300, 0x400, 0x500, 0x600 }, 0, WSAEINVAL }, /* Windows bug */
3451 { "1.2.3.4", { 0x201, 0x3, 0, 0, 0, 0, 0, 0 }, 0, WSAEINVAL },
3452 { "1:2:3:", { 0x100, 0x200, 0x300, 0, 0, 0, 0 }, 0, WSAEINVAL },
3453 { "", { 0, 0, 0, 0, 0, 0, 0, 0 }, 0, WSAEINVAL },
3454 };
3455
3456 WCHAR inputW[64];
3457 INT len, ret, expected_len, expected_ret;
3458 short expected_family;
3459 SOCKADDR_IN sockaddr;
3460 SOCKADDR_IN6 sockaddr6;
3461 int i, j;
3462
3463 len = 0;
3464 WSASetLastError( 0 );
3465 ret = WSAStringToAddressA( ipv4_tests[0].input, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3466 ok( ret == SOCKET_ERROR, "WSAStringToAddressA() returned %d, expected SOCKET_ERROR\n", ret );
3467 ok( WSAGetLastError() == WSAEFAULT, "WSAStringToAddress() gave error %d, expected WSAEFAULT\n", WSAGetLastError() );
3468 ok( len >= sizeof(sockaddr) || broken(len == 0) /* xp */,
3469 "WSAStringToAddress() gave length %d, expected at least %d\n", len, sizeof(sockaddr) );
3470
3471 for (i = 0; i < 2; i++)
3472 {
3473 for (j = 0; j < ARRAY_SIZE(ipv4_tests); j++)
3474 {
3475 len = sizeof(sockaddr) + 10;
3476 expected_len = ipv4_tests[j].error ? len : sizeof(sockaddr);
3477 memset( &sockaddr, 0xab, sizeof(sockaddr) );
3478
3479 WSASetLastError( 0 );
3480 if (i == 0)
3481 {
3482 ret = WSAStringToAddressA( ipv4_tests[j].input, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3483 }
3484 else
3485 {
3486 MultiByteToWideChar( CP_ACP, 0, ipv4_tests[j].input, -1, inputW, ARRAY_SIZE(inputW) );
3487 ret = WSAStringToAddressW( inputW, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3488 }
3489 expected_ret = ipv4_tests[j].error ? SOCKET_ERROR : 0;
3490 expected_family = ipv4_tests[j].error ? 0 : AF_INET;
3491 ok( ret == expected_ret,
3492 "WSAStringToAddress(%s) returned %d, expected %d\n",
3493 wine_dbgstr_a( ipv4_tests[j].input ), ret, expected_ret );
3494 ok( WSAGetLastError() == ipv4_tests[j].error,
3495 "WSAStringToAddress(%s) gave error %d, expected %d\n",
3496 wine_dbgstr_a( ipv4_tests[j].input ), WSAGetLastError(), ipv4_tests[j].error );
3497 ok( sockaddr.sin_family == expected_family,
3498 "WSAStringToAddress(%s) gave family %d, expected %d\n",
3499 wine_dbgstr_a( ipv4_tests[j].input ), sockaddr.sin_family, expected_family );
3500 ok( sockaddr.sin_addr.s_addr == ipv4_tests[j].address,
3501 "WSAStringToAddress(%s) gave address %08x, expected %08x\n",
3502 wine_dbgstr_a( ipv4_tests[j].input ), sockaddr.sin_addr.s_addr, ipv4_tests[j].address );
3503 ok( sockaddr.sin_port == ipv4_tests[j].port,
3504 "WSAStringToAddress(%s) gave port %04x, expected %04x\n",
3505 wine_dbgstr_a( ipv4_tests[j].input ), sockaddr.sin_port, ipv4_tests[j].port );
3506 ok( len == expected_len,
3507 "WSAStringToAddress(%s) gave length %d, expected %d\n",
3508 wine_dbgstr_a( ipv4_tests[j].input ), len, expected_len );
3509 }
3510
3511 for (j = 0; j < ARRAY_SIZE(ipv6_tests); j++)
3512 {
3513 len = sizeof(sockaddr6) + 10;
3514 expected_len = ipv6_tests[j].error ? len : sizeof(sockaddr6);
3515 memset( &sockaddr6, 0xab, sizeof(sockaddr6) );
3516
3517 WSASetLastError( 0 );
3518 if (i == 0)
3519 {
3520 ret = WSAStringToAddressA( ipv6_tests[j].input, AF_INET6, NULL, (SOCKADDR*)&sockaddr6, &len );
3521 }
3522 else
3523 {
3524 MultiByteToWideChar( CP_ACP, 0, ipv6_tests[j].input, -1, inputW, ARRAY_SIZE(inputW) );
3525 ret = WSAStringToAddressW( inputW, AF_INET6, NULL, (SOCKADDR*)&sockaddr6, &len );
3526 }
3527 if (j == 0 && ret == SOCKET_ERROR)
3528 {
3529 win_skip("IPv6 not supported\n");
3530 break;
3531 }
3532 expected_ret = ipv6_tests[j].error ? SOCKET_ERROR : 0;
3533 expected_family = ipv6_tests[j].error ? 0 : AF_INET6;
3534 ok( ret == expected_ret,
3535 "WSAStringToAddress(%s) returned %d, expected %d\n",
3536 wine_dbgstr_a( ipv6_tests[j].input ), ret, expected_ret );
3537 ok( WSAGetLastError() == ipv6_tests[j].error,
3538 "WSAStringToAddress(%s) gave error %d, expected %d\n",
3539 wine_dbgstr_a( ipv6_tests[j].input ), WSAGetLastError(), ipv6_tests[j].error );
3540 ok( sockaddr6.sin6_family == expected_family,
3541 "WSAStringToAddress(%s) gave family %d, expected %d\n",
3542 wine_dbgstr_a( ipv4_tests[j].input ), sockaddr6.sin6_family, expected_family );
3543 ok( memcmp(&sockaddr6.sin6_addr, ipv6_tests[j].address, sizeof(sockaddr6.sin6_addr)) == 0,
3544 "WSAStringToAddress(%s) gave address %x:%x:%x:%x:%x:%x:%x:%x, expected %x:%x:%x:%x:%x:%x:%x:%x\n",
3545 wine_dbgstr_a( ipv6_tests[j].input ),
3546 sockaddr6.sin6_addr.s6_words[0], sockaddr6.sin6_addr.s6_words[1],
3547 sockaddr6.sin6_addr.s6_words[2], sockaddr6.sin6_addr.s6_words[3],
3548 sockaddr6.sin6_addr.s6_words[4], sockaddr6.sin6_addr.s6_words[5],
3549 sockaddr6.sin6_addr.s6_words[6], sockaddr6.sin6_addr.s6_words[7],
3550 ipv6_tests[j].address[0], ipv6_tests[j].address[1],
3551 ipv6_tests[j].address[2], ipv6_tests[j].address[3],
3552 ipv6_tests[j].address[4], ipv6_tests[j].address[5],
3553 ipv6_tests[j].address[6], ipv6_tests[j].address[7] );
3554 ok( sockaddr6.sin6_scope_id == 0,
3555 "WSAStringToAddress(%s) gave scope %d, expected 0\n",
3556 wine_dbgstr_a( ipv6_tests[j].input ), sockaddr6.sin6_scope_id );
3557 ok( sockaddr6.sin6_port == ipv6_tests[j].port,
3558 "WSAStringToAddress(%s) gave port %04x, expected %04x\n",
3559 wine_dbgstr_a( ipv6_tests[j].input ), sockaddr6.sin6_port, ipv6_tests[j].port );
3560 ok( sockaddr6.sin6_flowinfo == 0,
3561 "WSAStringToAddress(%s) gave flowinfo %d, expected 0\n",
3562 wine_dbgstr_a( ipv6_tests[j].input ), sockaddr6.sin6_flowinfo );
3563 ok( len == expected_len,
3564 "WSAStringToAddress(%s) gave length %d, expected %d\n",
3565 wine_dbgstr_a( ipv6_tests[j].input ), len, expected_len );
3566 }
3567 }
3568 }
3569
3570 static DWORD WINAPI SelectReadThread(void *param)
3571 {
3572 select_thread_params *par = param;
3573 fd_set readfds;
3574 int ret;
3575 struct sockaddr_in addr;
3576 struct timeval select_timeout;
3577
3578 FD_ZERO(&readfds);
3579 FD_SET(par->s, &readfds);
3580 select_timeout.tv_sec=5;
3581 select_timeout.tv_usec=0;
3582 addr.sin_family = AF_INET;
3583 addr.sin_addr.s_addr = inet_addr(SERVERIP);
3584 addr.sin_port = htons(SERVERPORT);
3585
3586 do_bind(par->s, (struct sockaddr *)&addr, sizeof(addr));
3587 wsa_ok(listen(par->s, SOMAXCONN ), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
3588
3589 SetEvent(server_ready);
3590 ret = select(par->s+1, &readfds, NULL, NULL, &select_timeout);
3591 par->ReadKilled = (ret == 1);
3592
3593 return 0;
3594 }
3595
3596 static DWORD WINAPI SelectCloseThread(void *param)
3597 {
3598 SOCKET s = *(SOCKET*)param;
3599 Sleep(500);
3600 closesocket(s);
3601 return 0;
3602 }
3603
3604 static void test_errors(void)
3605 {
3606 SOCKET sock;
3607 SOCKADDR_IN SockAddr;
3608 int ret, err;
3609
3610 WSASetLastError(NO_ERROR);
3611 sock = socket(PF_INET, SOCK_STREAM, 0);
3612 ok( (sock != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3613 memset(&SockAddr, 0, sizeof(SockAddr));
3614 SockAddr.sin_family = AF_INET;
3615 SockAddr.sin_port = htons(6924);
3616 SockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
3617
3618 ret = connect(sock, (PSOCKADDR)&SockAddr, sizeof(SockAddr));
3619 ok( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got: %d\n", ret );
3620 if (ret == SOCKET_ERROR)
3621 {
3622 err = WSAGetLastError();
3623 ok( (err == WSAECONNREFUSED), "expected WSAECONNREFUSED, got: %d\n", err );
3624 }
3625
3626 {
3627 TIMEVAL timeval;
3628 fd_set set = {1, {sock}};
3629
3630 timeval.tv_sec = 0;
3631 timeval.tv_usec = 50000;
3632
3633 ret = select(1, NULL, &set, NULL, &timeval);
3634 ok( (ret == 0), "expected 0 (timeout), got: %d\n", ret );
3635 }
3636
3637 ret = closesocket(sock);
3638 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
3639 }
3640
3641 static void test_listen(void)
3642 {
3643 SOCKET fdA, fdB;
3644 int ret, acceptc, olen = sizeof(acceptc);
3645 struct sockaddr_in address;
3646
3647 memset(&address, 0, sizeof(address));
3648 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3649 address.sin_family = AF_INET;
3650 address.sin_port = htons(SERVERPORT);
3651
3652 /* invalid socket tests */
3653 SetLastError(0xdeadbeef);
3654 ok ((listen(0, 0) == SOCKET_ERROR), "listen did not fail\n");
3655 ret = WSAGetLastError();
3656 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
3657
3658 SetLastError(0xdeadbeef);
3659 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR), "listen did not fail\n");
3660 ret = WSAGetLastError();
3661 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
3662
3663 /* tcp tests */
3664 fdA = socket(AF_INET, SOCK_STREAM, 0);
3665 ok ((fdA != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3666
3667 fdB = socket(AF_INET, SOCK_STREAM, 0);
3668 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3669
3670 SetLastError(0xdeadbeef);
3671 ok ((listen(fdA, -2) == SOCKET_ERROR), "listen did not fail\n");
3672 ret = WSAGetLastError();
3673 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3674
3675 SetLastError(0xdeadbeef);
3676 ok ((listen(fdA, 1) == SOCKET_ERROR), "listen did not fail\n");
3677 ret = WSAGetLastError();
3678 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3679
3680 SetLastError(0xdeadbeef);
3681 ok ((listen(fdA, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3682 ret = WSAGetLastError();
3683 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3684
3685 ok (!bind(fdA, (struct sockaddr*) &address, sizeof(address)), "bind failed\n");
3686
3687 SetLastError(0xdeadbeef);
3688 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3689 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3690
3691 acceptc = 0xdead;
3692 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3693 ok (!ret, "getsockopt failed\n");
3694 ok (acceptc == 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc);
3695
3696 ok (!listen(fdA, 0), "listen failed\n");
3697 ok (!listen(fdA, SOMAXCONN), "double listen failed\n");
3698
3699 acceptc = 0xdead;
3700 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3701 ok (!ret, "getsockopt failed\n");
3702 ok (acceptc == 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc);
3703
3704 SetLastError(0xdeadbeef);
3705 ok ((listen(fdB, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3706 ret = WSAGetLastError();
3707 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3708
3709 ret = closesocket(fdB);
3710 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3711
3712 fdB = socket(AF_INET, SOCK_STREAM, 0);
3713 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3714
3715 SetLastError(0xdeadbeef);
3716 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3717 ret = WSAGetLastError();
3718 ok (ret == WSAEADDRINUSE, "expected 10048, received %d\n", ret);
3719
3720 ret = closesocket(fdA);
3721 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3722 ret = closesocket(fdB);
3723 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3724 }
3725
3726 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
3727 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
3728 static void test_select(void)
3729 {
3730 static char tmp_buf[1024];
3731
3732 SOCKET fdListen, fdRead, fdWrite;
3733 fd_set readfds, writefds, exceptfds;
3734 unsigned int maxfd;
3735 int ret, len;
3736 char buffer;
3737 struct timeval select_timeout;
3738 struct sockaddr_in address;
3739 select_thread_params thread_params;
3740 HANDLE thread_handle;
3741 DWORD ticks, id;
3742
3743 fdRead = socket(AF_INET, SOCK_STREAM, 0);
3744 ok( (fdRead != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3745 fdWrite = socket(AF_INET, SOCK_STREAM, 0);
3746 ok( (fdWrite != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3747
3748 maxfd = fdRead;
3749 if (fdWrite > maxfd)
3750 maxfd = fdWrite;
3751
3752 FD_ZERO_ALL();
3753 FD_SET_ALL(fdRead);
3754 FD_SET_ALL(fdWrite);
3755 select_timeout.tv_sec=0;
3756 select_timeout.tv_usec=0;
3757
3758 ticks = GetTickCount();
3759 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3760 ticks = GetTickCount() - ticks;
3761 ok(ret == 0, "select should not return any socket handles\n");
3762 ok(ticks < 10, "select was blocking for %u ms, expected < 10 ms\n", ticks);
3763 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3764 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
3765 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3766 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
3767
3768 FD_ZERO_ALL();
3769 FD_SET_ALL(fdRead);
3770 FD_SET_ALL(fdWrite);
3771 select_timeout.tv_sec=0;
3772 select_timeout.tv_usec=500;
3773
3774 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3775 ok(ret == 0, "select should not return any socket handles\n");
3776 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3777 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
3778 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3779 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
3780
3781 ok ((listen(fdWrite, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3782 ret = closesocket(fdWrite);
3783 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
3784
3785 thread_params.s = fdRead;
3786 thread_params.ReadKilled = FALSE;
3787 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
3788 thread_handle = CreateThread (NULL, 0, SelectReadThread, &thread_params, 0, &id );
3789 ok ( (thread_handle != NULL), "CreateThread failed unexpectedly: %d\n", GetLastError());
3790
3791 WaitForSingleObject (server_ready, INFINITE);
3792 Sleep(200);
3793 ret = closesocket(fdRead);
3794 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
3795
3796 WaitForSingleObject (thread_handle, 1000);
3797 ok ( thread_params.ReadKilled, "closesocket did not wake up select\n");
3798 ret = recv(fdRead, &buffer, 1, MSG_PEEK);
3799 ok( (ret == -1), "peek at closed socket expected -1 got %d\n", ret);
3800
3801 /* Test selecting invalid handles */
3802 FD_ZERO_ALL();
3803
3804 SetLastError(0);
3805 ret = select(maxfd+1, 0, 0, 0, &select_timeout);
3806 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3807 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3808
3809 SetLastError(0);
3810 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3811 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3812 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3813
3814 FD_SET(INVALID_SOCKET, &readfds);
3815 SetLastError(0);
3816 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3817 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3818 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3819 ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3820
3821 FD_ZERO(&readfds);
3822 FD_SET(INVALID_SOCKET, &writefds);
3823 SetLastError(0);
3824 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3825 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3826 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3827 ok ( !FD_ISSET(fdRead, &writefds), "FD should not be set\n");
3828
3829 FD_ZERO(&writefds);
3830 FD_SET(INVALID_SOCKET, &exceptfds);
3831 SetLastError(0);
3832 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3833 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3834 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3835 ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3836
3837 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
3838 maxfd = fdRead;
3839 if(fdWrite > maxfd) maxfd = fdWrite;
3840
3841 FD_ZERO(&readfds);
3842 FD_SET(fdRead, &readfds);
3843 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
3844 ok(!ret, "select returned %d\n", ret);
3845
3846 FD_ZERO(&writefds);
3847 FD_SET(fdWrite, &writefds);
3848 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
3849 ok(ret == 1, "select returned %d\n", ret);
3850 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3851
3852 /* tests for overlapping fd_set pointers */
3853 FD_ZERO(&readfds);
3854 FD_SET(fdWrite, &readfds);
3855 ret = select(fdWrite+1, &readfds, &readfds, NULL, &select_timeout);
3856 ok(ret == 1, "select returned %d\n", ret);
3857 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3858
3859 FD_ZERO(&readfds);
3860 FD_SET(fdWrite, &readfds);
3861 FD_SET(fdRead, &readfds);
3862 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3863 ok(ret == 2, "select returned %d\n", ret);
3864 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3865 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3866
3867 ok(send(fdWrite, "test", 4, 0) == 4, "failed to send data\n");
3868 FD_ZERO(&readfds);
3869 FD_SET(fdRead, &readfds);
3870 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
3871 ok(ret == 1, "select returned %d\n", ret);
3872 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3873
3874 FD_ZERO(&readfds);
3875 FD_SET(fdWrite, &readfds);
3876 FD_SET(fdRead, &readfds);
3877 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3878 ok(ret == 2, "select returned %d\n", ret);
3879 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3880 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3881
3882 while(1) {
3883 FD_ZERO(&writefds);
3884 FD_SET(fdWrite, &writefds);
3885 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
3886 if(!ret) break;
3887 ok(send(fdWrite, tmp_buf, sizeof(tmp_buf), 0) > 0, "failed to send data\n");
3888 }
3889 FD_ZERO(&readfds);
3890 FD_SET(fdWrite, &readfds);
3891 FD_SET(fdRead, &readfds);
3892 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3893 ok(ret == 1, "select returned %d\n", ret);
3894 ok(!FD_ISSET(fdWrite, &readfds), "fdWrite socket is in the set\n");
3895 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3896
3897 ok(send(fdRead, "test", 4, 0) == 4, "failed to send data\n");
3898 Sleep(100);
3899 FD_ZERO(&readfds);
3900 FD_SET(fdWrite, &readfds);
3901 FD_SET(fdRead, &readfds);
3902 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3903 ok(ret == 2, "select returned %d\n", ret);
3904 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3905 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3906
3907 closesocket(fdRead);
3908 closesocket(fdWrite);
3909
3910 /* select() works in 3 distinct states:
3911 * - to check if a connection attempt ended with success or error;
3912 * - to check if a pending connection is waiting for acceptance;
3913 * - to check for data to read, availability for write and OOB data
3914 *
3915 * The tests below ensure that all conditions are tested.
3916 */
3917 memset(&address, 0, sizeof(address));
3918 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3919 address.sin_family = AF_INET;
3920 len = sizeof(address);
3921 fdListen = setup_server_socket(&address, &len);
3922 select_timeout.tv_sec = 1;
3923 select_timeout.tv_usec = 250000;
3924
3925 /* When no events are pending select returns 0 with no error */
3926 FD_ZERO_ALL();
3927 FD_SET_ALL(fdListen);
3928 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3929 ok(ret == 0, "expected 0, got %d\n", ret);
3930
3931 /* When a socket is attempting to connect the listening socket receives the read descriptor */
3932 fdWrite = setup_connector_socket(&address, len, TRUE);
3933 FD_ZERO_ALL();
3934 FD_SET_ALL(fdListen);
3935 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3936 ok(ret == 1, "expected 1, got %d\n", ret);
3937 ok(FD_ISSET(fdListen, &readfds), "fdListen socket is not in the set\n");
3938 len = sizeof(address);
3939 fdRead = accept(fdListen, (struct sockaddr*) &address, &len);
3940 ok(fdRead != INVALID_SOCKET, "expected a valid socket\n");
3941
3942 /* The connector is signaled through the write descriptor */
3943 FD_ZERO_ALL();
3944 FD_SET_ALL(fdListen);
3945 FD_SET_ALL(fdRead);
3946 FD_SET_ALL(fdWrite);
3947 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3948 ok(ret == 2, "expected 2, got %d\n", ret);
3949 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3950 ok(FD_ISSET(fdRead, &writefds), "fdRead socket is not in the set\n");
3951 len = sizeof(id);
3952 id = 0xdeadbeef;
3953 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
3954 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
3955 ok(id == 0, "expected 0, got %d\n", id);
3956
3957 /* When data is received the receiver gets the read descriptor */
3958 ret = send(fdWrite, "1234", 4, 0);
3959 ok(ret == 4, "expected 4, got %d\n", ret);
3960 FD_ZERO_ALL();
3961 FD_SET_ALL(fdListen);
3962 FD_SET(fdRead, &readfds);
3963 FD_SET(fdRead, &exceptfds);
3964 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3965 ok(ret == 1, "expected 1, got %d\n", ret);
3966 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3967 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
3968 ok(ret == 4, "expected 4, got %d\n", ret);
3969 ok(!strcmp(tmp_buf, "1234"), "data received differs from sent\n");
3970
3971 /* When OOB data is received the socket is set in the except descriptor */
3972 ret = send(fdWrite, "A", 1, MSG_OOB);
3973 ok(ret == 1, "expected 1, got %d\n", ret);
3974 FD_ZERO_ALL();
3975 FD_SET_ALL(fdListen);
3976 FD_SET(fdRead, &readfds);
3977 FD_SET(fdRead, &exceptfds);
3978 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3979 ok(ret == 1, "expected 1, got %d\n", ret);
3980 ok(FD_ISSET(fdRead, &exceptfds), "fdRead socket is not in the set\n");
3981 tmp_buf[0] = 0xAF;
3982 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
3983 ok(ret == 1, "expected 1, got %d\n", ret);
3984 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
3985
3986 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
3987 ret = 1;
3988 ret = setsockopt(fdRead, SOL_SOCKET, SO_OOBINLINE, (char*) &ret, sizeof(ret));
3989 ok(ret == 0, "expected 0, got %d\n", ret);
3990 ret = send(fdWrite, "A", 1, MSG_OOB);
3991 ok(ret == 1, "expected 1, got %d\n", ret);
3992 FD_ZERO_ALL();
3993 FD_SET_ALL(fdListen);
3994 FD_SET(fdRead, &readfds);
3995 FD_SET(fdRead, &exceptfds);
3996 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3997 ok(ret == 1, "expected 1, got %d\n", ret);
3998 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3999 tmp_buf[0] = 0xAF;
4000 SetLastError(0xdeadbeef);
4001 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
4002 ok(ret == SOCKET_ERROR, "expected SOCKET_ERROR, got %d\n", ret);
4003 ok(GetLastError() == WSAEINVAL, "expected 10022, got %d\n", GetLastError());
4004 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
4005 ok(ret == 1, "expected 1, got %d\n", ret);
4006 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
4007
4008 /* When the connection is closed the socket is set in the read descriptor */
4009 ret = closesocket(fdRead);
4010 ok(ret == 0, "expected 0, got %d\n", ret);
4011 FD_ZERO_ALL();
4012 FD_SET_ALL(fdListen);
4013 FD_SET(fdWrite, &readfds);
4014 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4015 ok(ret == 1, "expected 1, got %d\n", ret);
4016 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4017 ret = recv(fdWrite, tmp_buf, sizeof(tmp_buf), 0);
4018 ok(ret == 0, "expected 0, got %d\n", ret);
4019
4020 /* When a connection is attempted to a non-listening socket it will get to the except descriptor */
4021 ret = closesocket(fdWrite);
4022 ok(ret == 0, "expected 0, got %d\n", ret);
4023 ret = closesocket(fdListen);
4024 ok(ret == 0, "expected 0, got %d\n", ret);
4025 len = sizeof(address);
4026 fdWrite = setup_connector_socket(&address, len, TRUE);
4027 FD_ZERO_ALL();
4028 FD_SET(fdWrite, &writefds);
4029 FD_SET(fdWrite, &exceptfds);
4030 select_timeout.tv_sec = 2; /* requires more time to realize it will not connect */
4031 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4032 ok(ret == 1, "expected 1, got %d\n", ret);
4033 len = sizeof(id);
4034 id = 0xdeadbeef;
4035 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
4036 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4037 ok(id == WSAECONNREFUSED, "expected 10061, got %d\n", id);
4038 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4039 ok(select_timeout.tv_usec == 250000, "select timeout should not have changed\n");
4040 closesocket(fdWrite);
4041
4042 /* Try select() on a closed socket after connection */
4043 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
4044 closesocket(fdRead);
4045 FD_ZERO_ALL();
4046 FD_SET_ALL(fdWrite);
4047 FD_SET_ALL(fdRead);
4048 SetLastError(0xdeadbeef);
4049 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
4050 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4051 todo_wine
4052 ok(GetLastError() == WSAENOTSOCK, "expected 10038, got %d\n", GetLastError());
4053 /* descriptor sets are unchanged */
4054 ok(readfds.fd_count == 2, "expected 2, got %d\n", readfds.fd_count);
4055 ok(exceptfds.fd_count == 2, "expected 2, got %d\n", exceptfds.fd_count);
4056 closesocket(fdWrite);
4057
4058 /* Close the socket currently being selected in a thread - bug 38399 */
4059 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
4060 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
4061 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
4062 FD_ZERO_ALL();
4063 FD_SET_ALL(fdWrite);
4064 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
4065 ok(ret == 1, "expected 1, got %d\n", ret);
4066 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4067 WaitForSingleObject (thread_handle, 1000);
4068 closesocket(fdRead);
4069 /* test again with only the except descriptor */
4070 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
4071 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
4072 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
4073 FD_ZERO_ALL();
4074 FD_SET(fdWrite, &exceptfds);
4075 SetLastError(0xdeadbeef);
4076 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
4077 todo_wine
4078 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4079 todo_wine
4080 ok(GetLastError() == WSAENOTSOCK, "expected 10038, got %d\n", GetLastError());
4081 WaitForSingleObject (thread_handle, 1000);
4082 closesocket(fdRead);
4083
4084 /* test UDP behavior of unbound sockets */
4085 select_timeout.tv_sec = 0;
4086 select_timeout.tv_usec = 250000;
4087 fdWrite = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
4088 ok(fdWrite != INVALID_SOCKET, "socket call failed\n");
4089 FD_ZERO_ALL();
4090 FD_SET_ALL(fdWrite);
4091 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4092 ok(ret == 1, "expected 1, got %d\n", ret);
4093 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4094 closesocket(fdWrite);
4095 }
4096 #undef FD_SET_ALL
4097 #undef FD_ZERO_ALL
4098
4099 static DWORD WINAPI AcceptKillThread(void *param)
4100 {
4101 select_thread_params *par = param;
4102 struct sockaddr_in address;
4103 int len = sizeof(address);
4104 SOCKET client_socket;
4105
4106 SetEvent(server_ready);
4107 client_socket = accept(par->s, (struct sockaddr*) &address, &len);
4108 if (client_socket != INVALID_SOCKET)
4109 closesocket(client_socket);
4110 par->ReadKilled = (client_socket == INVALID_SOCKET);
4111 return 0;
4112 }
4113
4114
4115 static int CALLBACK AlwaysDeferConditionFunc(LPWSABUF lpCallerId, LPWSABUF lpCallerData, LPQOS pQos,
4116 LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,
4117 GROUP *g, DWORD_PTR dwCallbackData)
4118 {
4119 return CF_DEFER;
4120 }
4121
4122 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len)
4123 {
4124 int ret, val;
4125 SOCKET server_socket;
4126
4127 server_socket = socket(AF_INET, SOCK_STREAM, 0);
4128 if (server_socket == INVALID_SOCKET)
4129 {
4130 trace("error creating server socket: %d\n", WSAGetLastError());
4131 return INVALID_SOCKET;
4132 }
4133
4134 val = 1;
4135 ret = setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
4136 if (ret)
4137 {
4138 trace("error setting SO_REUSEADDR: %d\n", WSAGetLastError());
4139 closesocket(server_socket);
4140 return INVALID_SOCKET;
4141 }
4142
4143 ret = bind(server_socket, (struct sockaddr *)addr, *len);
4144 if (ret)
4145 {
4146 trace("error binding server socket: %d\n", WSAGetLastError());
4147 }
4148
4149 ret = getsockname(server_socket, (struct sockaddr *)addr, len);
4150 if (ret)
4151 {
4152 skip("failed to lookup bind address: %d\n", WSAGetLastError());
4153 closesocket(server_socket);
4154 return INVALID_SOCKET;
4155 }
4156
4157 ret = listen(server_socket, 5);
4158 if (ret)
4159 {
4160 trace("error making server socket listen: %d\n", WSAGetLastError());
4161 closesocket(server_socket);
4162 return INVALID_SOCKET;
4163 }
4164
4165 return server_socket;
4166 }
4167
4168 static SOCKET setup_connector_socket(struct sockaddr_in *addr, int len, BOOL nonblock)
4169 {
4170 int ret;
4171 SOCKET connector;
4172
4173 connector = socket(AF_INET, SOCK_STREAM, 0);
4174 ok(connector != INVALID_SOCKET, "failed to create connector socket %d\n", WSAGetLastError());
4175
4176 if (nonblock)
4177 set_blocking(connector, !nonblock);
4178
4179 ret = connect(connector, (struct sockaddr *)addr, len);
4180 if (!nonblock)
4181 ok(!ret, "connecting to accepting socket failed %d\n", WSAGetLastError());
4182 else if (ret == SOCKET_ERROR)
4183 {
4184 DWORD error = WSAGetLastError();
4185 ok(error == WSAEWOULDBLOCK || error == WSAEINPROGRESS,
4186 "expected 10035 or 10036, got %d\n", error);
4187 }
4188
4189 return connector;
4190 }
4191
4192 static void test_accept(void)
4193 {
4194 int ret;
4195 SOCKET server_socket, accepted = INVALID_SOCKET, connector;
4196 struct sockaddr_in address;
4197 SOCKADDR_STORAGE ss, ss_empty;
4198 int socklen;
4199 select_thread_params thread_params;
4200 HANDLE thread_handle = NULL;
4201 DWORD id;
4202
4203 memset(&address, 0, sizeof(address));
4204 address.sin_addr.s_addr = inet_addr("127.0.0.1");
4205 address.sin_family = AF_INET;
4206
4207 socklen = sizeof(address);
4208 server_socket = setup_server_socket(&address, &socklen);
4209 if (server_socket == INVALID_SOCKET)
4210 {
4211 trace("error creating server socket: %d\n", WSAGetLastError());
4212 return;
4213 }
4214
4215 connector = setup_connector_socket(&address, socklen, FALSE);
4216 if (connector == INVALID_SOCKET) goto done;
4217
4218 trace("Blocking accept next\n");
4219
4220 accepted = WSAAccept(server_socket, NULL, NULL, AlwaysDeferConditionFunc, 0);
4221 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
4222
4223 accepted = accept(server_socket, NULL, 0);
4224 ok(accepted != INVALID_SOCKET, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
4225
4226 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
4227 if (server_ready == INVALID_HANDLE_VALUE)
4228 {
4229 trace("error creating event: %d\n", GetLastError());
4230 goto done;
4231 }
4232
4233 thread_params.s = server_socket;
4234 thread_params.ReadKilled = FALSE;
4235 thread_handle = CreateThread(NULL, 0, AcceptKillThread, &thread_params, 0, &id);
4236 if (thread_handle == NULL)
4237 {
4238 trace("error creating thread: %d\n", GetLastError());
4239 goto done;
4240 }
4241
4242 WaitForSingleObject(server_ready, INFINITE);
4243 Sleep(200);
4244 ret = closesocket(server_socket);
4245 if (ret != 0)
4246 {
4247 trace("closesocket failed: %d\n", WSAGetLastError());
4248 goto done;
4249 }
4250
4251 WaitForSingleObject(thread_handle, 1000);
4252 ok(thread_params.ReadKilled, "closesocket did not wake up accept\n");
4253
4254 closesocket(accepted);
4255 closesocket(connector);
4256 accepted = connector = INVALID_SOCKET;
4257
4258 socklen = sizeof(address);
4259 server_socket = setup_server_socket(&address, &socklen);
4260 if (server_socket == INVALID_SOCKET) goto done;
4261
4262 connector = setup_connector_socket(&address, socklen, FALSE);
4263 if (connector == INVALID_SOCKET) goto done;
4264
4265 socklen = 0;
4266 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
4267 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
4268 ok(!socklen, "got %d\n", socklen);
4269 closesocket(connector);
4270 connector = INVALID_SOCKET;
4271
4272 socklen = sizeof(address);
4273 connector = setup_connector_socket(&address, socklen, FALSE);
4274 if (connector == INVALID_SOCKET) goto done;
4275
4276 accepted = WSAAccept(server_socket, NULL, NULL, NULL, 0);
4277 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4278 closesocket(accepted);
4279 closesocket(connector);
4280 accepted = connector = INVALID_SOCKET;
4281
4282 socklen = sizeof(address);
4283 connector = setup_connector_socket(&address, socklen, FALSE);
4284 if (connector == INVALID_SOCKET) goto done;
4285
4286 socklen = sizeof(ss);
4287 memset(&ss, 0, sizeof(ss));
4288 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
4289 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4290 ok(socklen != sizeof(ss), "unexpected length\n");
4291 ok(ss.ss_family, "family not set\n");
4292 closesocket(accepted);
4293 closesocket(connector);
4294 accepted = connector = INVALID_SOCKET;
4295
4296 socklen = sizeof(address);
4297 connector = setup_connector_socket(&address, socklen, FALSE);
4298 if (connector == INVALID_SOCKET) goto done;
4299
4300 socklen = 0;
4301 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4302 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
4303 ok(!socklen, "got %d\n", socklen);
4304 closesocket(connector);
4305 accepted = connector = INVALID_SOCKET;
4306
4307 socklen = sizeof(address);
4308 connector = setup_connector_socket(&address, socklen, FALSE);
4309 if (connector == INVALID_SOCKET) goto done;
4310
4311 accepted = accept(server_socket, NULL, NULL);
4312 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4313 closesocket(accepted);
4314 closesocket(connector);
4315 accepted = connector = INVALID_SOCKET;
4316
4317 socklen = sizeof(address);
4318 connector = setup_connector_socket(&address, socklen, FALSE);
4319 if (connector == INVALID_SOCKET) goto done;
4320
4321 socklen = sizeof(ss);
4322 memset(&ss, 0, sizeof(ss));
4323 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4324 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4325 ok(socklen != sizeof(ss), "unexpected length\n");
4326 ok(ss.ss_family, "family not set\n");
4327 closesocket(accepted);
4328 closesocket(connector);
4329 accepted = connector = INVALID_SOCKET;
4330
4331 socklen = sizeof(address);
4332 connector = setup_connector_socket(&address, socklen, FALSE);
4333 if (connector == INVALID_SOCKET) goto done;
4334
4335 memset(&ss, 0, sizeof(ss));
4336 memset(&ss_empty, 0, sizeof(ss_empty));
4337 accepted = accept(server_socket, (struct sockaddr *)&ss, NULL);
4338 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4339 ok(!memcmp(&ss, &ss_empty, sizeof(ss)), "structure is different\n");
4340
4341 done:
4342 if (accepted != INVALID_SOCKET)
4343 closesocket(accepted);
4344 if (connector != INVALID_SOCKET)
4345 closesocket(connector);
4346 if (thread_handle != NULL)
4347 CloseHandle(thread_handle);
4348 if (server_ready != INVALID_HANDLE_VALUE)
4349 CloseHandle(server_ready);
4350 if (server_socket != INVALID_SOCKET)
4351 closesocket(server_socket);
4352 }
4353
4354 static void test_extendedSocketOptions(void)
4355 {
4356 WSADATA wsa;
4357 SOCKET sock;
4358 struct sockaddr_in sa;
4359 int sa_len = sizeof(struct sockaddr_in);
4360 int optval, optlen = sizeof(int), ret;
4361 BOOL bool_opt_val;
4362 LINGER linger_val;
4363
4364 if(WSAStartup(MAKEWORD(2,0), &wsa)){
4365 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4366 return;
4367 }
4368
4369 memset(&sa, 0, sa_len);
4370
4371 sa.sin_family = AF_INET;
4372 sa.sin_port = htons(0);
4373 sa.sin_addr.s_addr = htonl(INADDR_ANY);
4374
4375 if((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP)) == INVALID_SOCKET) {
4376 trace("Creating the socket failed: %d\n", WSAGetLastError());
4377 WSACleanup();
4378 return;
4379 }
4380
4381 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
4382 trace("Failed to bind socket: %d\n", WSAGetLastError());
4383 closesocket(sock);
4384 WSACleanup();
4385 return;
4386 }
4387
4388 ret = getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4389
4390 ok(ret == 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret);
4391 ok((optval == 65507) || (optval == 65527),
4392 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval);
4393
4394 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
4395 SetLastError(0xdeadbeef);
4396 optval = 0xdeadbeef;
4397 optlen = sizeof(int);
4398 ret = getsockopt(sock, 0xffffffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4399 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4400 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4401 ret, WSAGetLastError(), optval, optval);
4402
4403 /* more invalid values for level */
4404 SetLastError(0xdeadbeef);
4405 optval = 0xdeadbeef;
4406 optlen = sizeof(int);
4407 ret = getsockopt(sock, 0x1234ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4408 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4409 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4410 ret, WSAGetLastError(), optval, optval);
4411
4412 SetLastError(0xdeadbeef);
4413 optval = 0xdeadbeef;
4414 optlen = sizeof(int);
4415 ret = getsockopt(sock, 0x8000ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4416 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4417 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4418 ret, WSAGetLastError(), optval, optval);
4419
4420 SetLastError(0xdeadbeef);
4421 optval = 0xdeadbeef;
4422 optlen = sizeof(int);
4423 ret = getsockopt(sock, 0x00008000, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4424 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4425 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4426 ret, WSAGetLastError(), optval, optval);
4427
4428 SetLastError(0xdeadbeef);
4429 optval = 0xdeadbeef;
4430 optlen = sizeof(int);
4431 ret = getsockopt(sock, 0x00000800, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4432 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4433 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4434 ret, WSAGetLastError(), optval, optval);
4435
4436 SetLastError(0xdeadbeef);
4437 optlen = sizeof(LINGER);
4438 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
4439 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAENOPROTOOPT),
4440 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
4441 ret, WSAGetLastError());
4442 closesocket(sock);
4443
4444 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
4445 trace("Creating the socket failed: %d\n", WSAGetLastError());
4446 WSACleanup();
4447 return;
4448 }
4449
4450 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
4451 trace("Failed to bind socket: %d\n", WSAGetLastError());
4452 closesocket(sock);
4453 WSACleanup();
4454 return;
4455 }
4456
4457 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
4458 ok(ret == 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret);
4459
4460 optlen = sizeof(BOOL);
4461 ret = getsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *)&bool_opt_val, &optlen);
4462 ok(ret == 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret);
4463 ok((linger_val.l_onoff && !bool_opt_val) || (!linger_val.l_onoff && bool_opt_val),
4464 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
4465 bool_opt_val, linger_val.l_onoff);
4466
4467 closesocket(sock);
4468 WSACleanup();
4469 }
4470
4471 static void test_getsockname(void)
4472 {
4473 WSADATA wsa;
4474 SOCKET sock;
4475 struct sockaddr_in sa_set, sa_get;
4476 int sa_set_len = sizeof(struct sockaddr_in);
4477 int sa_get_len = sa_set_len;
4478 static const unsigned char null_padding[] = {0,0,0,0,0,0,0,0};
4479 int ret;
4480 struct hostent *h;
4481
4482 if(WSAStartup(MAKEWORD(2,0), &wsa)){
4483 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4484 return;
4485 }
4486
4487 memset(&sa_set, 0, sa_set_len);
4488
4489 sa_set.sin_family = AF_INET;
4490 sa_set.sin_port = htons(0);
4491 sa_set.sin_addr.s_addr = htonl(INADDR_ANY);
4492
4493 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
4494 trace("Creating the socket failed: %d\n", WSAGetLastError());
4495 WSACleanup();
4496 return;
4497 }
4498
4499 sa_get = sa_set;
4500 if (getsockname(sock, (struct sockaddr*) &sa_get, &sa_get_len) == 0)
4501 ok(0, "getsockname on unbound socket should fail\n");
4502 else {
4503 ok(WSAGetLastError() == WSAEINVAL, "getsockname on unbound socket "
4504 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL);
4505 ok(memcmp(&sa_get, &sa_set, sizeof(sa_get)) == 0,
4506 "failed getsockname modified sockaddr when it shouldn't\n");
4507 }
4508
4509 if(bind(sock, (struct sockaddr *) &sa_set, sa_set_len) < 0){
4510 trace("Failed to bind socket: %d\n", WSAGetLastError());
4511 closesocket(sock);
4512 WSACleanup();
4513 return;
4514 }
4515
4516 if(getsockname(sock, (struct sockaddr *) &sa_get, &sa_get_len) != 0){
4517 trace("Failed to call getsockname: %d\n", WSAGetLastError());
4518 closesocket(sock);
4519 WSACleanup();
4520 return;
4521 }
4522
4523 ret = memcmp(sa_get.sin_zero, null_padding, 8);
4524 ok(ret == 0, "getsockname did not zero the sockaddr_in structure\n");
4525
4526 closesocket(sock);
4527
4528 h = gethostbyname("");
4529 if (h && h->h_length == 4) /* this test is only meaningful in IPv4 */
4530 {
4531 int i;
4532 for (i = 0; h->h_addr_list[i]; i++)
4533 {
4534 char ipstr[32];
4535 struct in_addr ip;
4536 ip.s_addr = *(ULONG *) h->h_addr_list[i];
4537
4538 sock = socket(AF_INET, SOCK_DGRAM, 0);
4539 ok(sock != INVALID_SOCKET, "socket failed with %d\n", GetLastError());
4540
4541 memset(&sa_set, 0, sizeof(sa_set));
4542 sa_set.sin_family = AF_INET;
4543 sa_set.sin_addr.s_addr = ip.s_addr;
4544 /* The same address we bind must be the same address we get */
4545 ret = bind(sock, (struct sockaddr*)&sa_set, sizeof(sa_set));
4546 ok(ret == 0, "bind failed with %d\n", GetLastError());
4547 sa_get_len = sizeof(sa_get);
4548 ret = getsockname(sock, (struct sockaddr*)&sa_get, &sa_get_len);
4549 ok(ret == 0, "getsockname failed with %d\n", GetLastError());
4550 strcpy(ipstr, inet_ntoa(sa_get.sin_addr));
4551 trace("testing bind on interface %s\n", ipstr);
4552 ok(sa_get.sin_addr.s_addr == sa_set.sin_addr.s_addr,
4553 "address does not match: %s != %s\n", ipstr, inet_ntoa(sa_set.sin_addr));
4554
4555 closesocket(sock);
4556 }
4557 }
4558
4559 WSACleanup();
4560 }
4561
4562 static void test_dns(void)
4563 {
4564 struct hostent *h;
4565 union memaddress
4566 {
4567 char *chr;
4568 void *mem;
4569 } addr;
4570 char **ptr;
4571 int acount;
4572
4573 h = gethostbyname("");
4574 ok(h != NULL, "gethostbyname(\"\") failed with %d\n", h_errno);
4575
4576 /* Use an address with valid alias names if possible */
4577 h = gethostbyname("source.winehq.org");
4578 if(!h)
4579 {
4580 skip("Can't test the hostent structure because gethostbyname failed\n");
4581 return;
4582 }
4583
4584 /* The returned struct must be allocated in a very strict way. First we need to
4585 * count how many aliases there are because they must be located right after
4586 * the struct hostent size. Knowing the amount of aliases we know the exact
4587 * location of the first IP returned. Rule valid for >= XP, for older OS's
4588 * it's somewhat the opposite. */
4589 addr.mem = h + 1;
4590 if(h->h_addr_list == addr.mem) /* <= W2K */
4591 {
4592 win_skip("Skipping hostent tests since this OS is unsupported\n");
4593 return;
4594 }
4595
4596 ok(h->h_aliases == addr.mem,
4597 "hostent->h_aliases should be in %p, it is in %p\n", addr.mem, h->h_aliases);
4598
4599 for(ptr = h->h_aliases, acount = 1; *ptr; ptr++) acount++;
4600 addr.chr += sizeof(*ptr) * acount;
4601 ok(h->h_addr_list == addr.mem,
4602 "hostent->h_addr_list should be in %p, it is in %p\n", addr.mem, h->h_addr_list);
4603
4604 for(ptr = h->h_addr_list, acount = 1; *ptr; ptr++) acount++;
4605
4606 addr.chr += sizeof(*ptr) * acount;
4607 ok(h->h_addr_list[0] == addr.mem,
4608 "hostent->h_addr_list[0] should be in %p, it is in %p\n", addr.mem, h->h_addr_list[0]);
4609 }
4610
4611 /* Our winsock headers don't define gethostname because it conflicts with the
4612 * definition in unistd.h. Define it here to get rid of the warning. */
4613
4614 int WINAPI gethostname(char *name, int namelen);
4615
4616 static void test_gethostbyname(void)
4617 {
4618 struct hostent *he;
4619 struct in_addr **addr_list;
4620 char name[256], first_ip[16];
4621 int ret, i, count;
4622 PMIB_IPFORWARDTABLE routes = NULL;
4623 PIP_ADAPTER_INFO adapters = NULL, k;
4624 DWORD adap_size = 0, route_size = 0;
4625 BOOL found_default = FALSE;
4626 BOOL local_ip = FALSE;
4627
4628 ret = gethostname(name, sizeof(name));
4629 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4630
4631 he = gethostbyname(name);
4632 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, WSAGetLastError());
4633 addr_list = (struct in_addr **)he->h_addr_list;
4634 strcpy(first_ip, inet_ntoa(*addr_list[0]));
4635
4636 trace("List of local IPs:\n");
4637 for(count = 0; addr_list[count] != NULL; count++)
4638 {
4639 char *ip = inet_ntoa(*addr_list[count]);
4640 if (!strcmp(ip, "127.0.0.1"))
4641 local_ip = TRUE;
4642 trace("%s\n", ip);
4643 }
4644
4645 if (local_ip)
4646 {
4647 ok (count == 1, "expected 127.0.0.1 to be the only IP returned\n");
4648 skip("Only the loopback address is present, skipping tests\n");
4649 return;
4650 }
4651
4652 if (!pGetAdaptersInfo || !pGetIpForwardTable)
4653 {
4654 win_skip("GetAdaptersInfo and/or GetIpForwardTable not found, skipping tests\n");
4655 return;
4656 }
4657
4658 ret = pGetAdaptersInfo(NULL, &adap_size);
4659 ok (ret == ERROR_BUFFER_OVERFLOW, "GetAdaptersInfo failed with a different error: %d\n", ret);
4660 ret = pGetIpForwardTable(NULL, &route_size, FALSE);
4661 ok (ret == ERROR_INSUFFICIENT_BUFFER, "GetIpForwardTable failed with a different error: %d\n", ret);
4662
4663 adapters = HeapAlloc(GetProcessHeap(), 0, adap_size);
4664 routes = HeapAlloc(GetProcessHeap(), 0, route_size);
4665
4666 ret = pGetAdaptersInfo(adapters, &adap_size);
4667 ok (ret == NO_ERROR, "GetAdaptersInfo failed, error: %d\n", ret);
4668 ret = pGetIpForwardTable(routes, &route_size, FALSE);
4669 ok (ret == NO_ERROR, "GetIpForwardTable failed, error: %d\n", ret);
4670
4671 /* This test only has meaning if there is more than one IP configured */
4672 if (adapters->Next == NULL && count == 1)
4673 {
4674 skip("Only one IP is present, skipping tests\n");
4675 goto cleanup;
4676 }
4677
4678 for (i = 0; !found_default && i < routes->dwNumEntries; i++)
4679 {
4680 /* default route (ip 0.0.0.0) ? */
4681 if (routes->table[i].dwForwardDest) continue;
4682
4683 for (k = adapters; k != NULL; k = k->Next)
4684 {
4685 char *ip;
4686
4687 if (k->Index != routes->table[i].dwForwardIfIndex) continue;
4688
4689 /* the first IP returned from gethostbyname must be a default route */
4690 ip = k->IpAddressList.IpAddress.String;
4691 if (!strcmp(first_ip, ip))
4692 {
4693 found_default = TRUE;
4694 break;
4695 }
4696 }
4697 }
4698 ok (found_default, "failed to find the first IP from gethostbyname!\n");
4699
4700 cleanup:
4701 HeapFree(GetProcessHeap(), 0, adapters);
4702 HeapFree(GetProcessHeap(), 0, routes);
4703 }
4704
4705 static void test_gethostbyname_hack(void)
4706 {
4707 struct hostent *he;
4708 char name[256];
4709 static BYTE loopback[] = {127, 0, 0, 1};
4710 static BYTE magic_loopback[] = {127, 12, 34, 56};
4711 int ret;
4712
4713 ret = gethostname(name, 256);
4714 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4715
4716 he = gethostbyname("localhost");
4717 ok(he != NULL, "gethostbyname(\"localhost\") failed: %d\n", h_errno);
4718 if(he)
4719 {
4720 if(he->h_length != 4)
4721 {
4722 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
4723 return;
4724 }
4725
4726 ok(memcmp(he->h_addr_list[0], loopback, he->h_length) == 0,
4727 "gethostbyname(\"localhost\") returned %u.%u.%u.%u\n",
4728 he->h_addr_list[0][0], he->h_addr_list[0][1], he->h_addr_list[0][2],
4729 he->h_addr_list[0][3]);
4730 }
4731
4732 if(strcmp(name, "localhost") == 0)
4733 {
4734 skip("hostname seems to be \"localhost\", skipping test.\n");
4735 return;
4736 }
4737
4738 he = gethostbyname(name);
4739 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, h_errno);
4740 if(he)
4741 {
4742 if(he->h_length != 4)
4743 {
4744 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
4745 return;
4746 }
4747
4748 if (he->h_addr_list[0][0] == 127)
4749 {
4750 ok(memcmp(he->h_addr_list[0], magic_loopback, he->h_length) == 0,
4751 "gethostbyname(\"%s\") returned %u.%u.%u.%u not 127.12.34.56\n",
4752 name, he->h_addr_list[0][0], he->h_addr_list[0][1],
4753 he->h_addr_list[0][2], he->h_addr_list[0][3]);
4754 }
4755 }
4756
4757 gethostbyname("nonexistent.winehq.org");
4758 /* Don't check for the return value, as some braindead ISPs will kindly
4759 * resolve nonexistent host names to addresses of the ISP's spam pages. */
4760 }
4761
4762 static void test_gethostname(void)
4763 {
4764 struct hostent *he;
4765 char name[256];
4766 int ret, len;
4767
4768 WSASetLastError(0xdeadbeef);
4769 ret = gethostname(NULL, 256);
4770 ok(ret == -1, "gethostname() returned %d\n", ret);
4771 ok(WSAGetLastError() == WSAEFAULT, "gethostname with null buffer "
4772 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT);
4773
4774 ret = gethostname(name, sizeof(name));
4775 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4776 he = gethostbyname(name);
4777 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, WSAGetLastError());
4778
4779 len = strlen(name);
4780 WSASetLastError(0xdeadbeef);
4781 strcpy(name, "deadbeef");
4782 ret = gethostname(name, len);
4783 ok(ret == -1, "gethostname() returned %d\n", ret);
4784 ok(!strcmp(name, "deadbeef"), "name changed unexpected!\n");
4785 ok(WSAGetLastError() == WSAEFAULT, "gethostname with insufficient length "
4786 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT);
4787
4788 len++;
4789 ret = gethostname(name, len);
4790 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4791 he = gethostbyname(name);
4792 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, WSAGetLastError());
4793 }
4794
4795 static void test_inet_addr(void)
4796 {
4797 u_long addr;
4798
4799 addr = inet_addr(NULL);
4800 ok(addr == INADDR_NONE, "inet_addr succeeded unexpectedly\n");
4801 }
4802
4803 static void test_addr_to_print(void)
4804 {
4805 char dst[16];
4806 char dst6[64];
4807 const char * pdst;
4808 struct in_addr in;
4809 struct in6_addr in6;
4810
4811 u_long addr0_Num = 0x00000000;
4812 PCSTR addr0_Str = "0.0.0.0";
4813 u_long addr1_Num = 0x20201015;
4814 PCSTR addr1_Str = "21.16.32.32";
4815 u_char addr2_Num[16] = {0,0,0,0,0,0,0,0,0,0,0xff,0xfe,0xcC,0x98,0xbd,0x74};
4816 PCSTR addr2_Str = "::fffe:cc98:bd74";
4817 u_char addr3_Num[16] = {0x20,0x30,0xa4,0xb1};
4818 PCSTR addr3_Str = "2030:a4b1::";
4819 u_char addr4_Num[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0xcC,0x98,0xbd,0x74};
4820 PCSTR addr4_Str = "::204.152.189.116";
4821
4822 /* Test IPv4 addresses */
4823 in.s_addr = addr0_Num;
4824
4825 pdst = inet_ntoa(*((struct in_addr*)&in.s_addr));
4826 ok(pdst != NULL, "inet_ntoa failed %s\n", dst);
4827 ok(!strcmp(pdst, addr0_Str),"Address %s != %s\n", pdst, addr0_Str);
4828
4829 /* Test that inet_ntoa and inet_ntop return the same value */
4830 in.S_un.S_addr = addr1_Num;
4831 pdst = inet_ntoa(*((struct in_addr*)&in.s_addr));
4832 ok(pdst != NULL, "inet_ntoa failed %s\n", dst);
4833 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4834
4835 /* InetNtop became available in Vista and Win2008 */
4836 if (!pInetNtop)
4837 {
4838 win_skip("InetNtop not present, not executing tests\n");
4839 return;
4840 }
4841
4842 /* Second part of test */
4843 pdst = pInetNtop(AF_INET,(void*)&in.s_addr, dst, sizeof(dst));
4844 ok(pdst != NULL, "InetNtop failed %s\n", dst);
4845 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4846
4847 /* Test invalid parm conditions */
4848 pdst = pInetNtop(1, (void*)&in.s_addr, dst, sizeof(dst));
4849 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4850 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "Should be WSAEAFNOSUPPORT\n");
4851
4852 /* Test Null destination */
4853 pdst = NULL;
4854 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, NULL, sizeof(dst));
4855 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4856 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4857 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4858
4859 /* Test zero length passed */
4860 WSASetLastError(0);
4861 pdst = NULL;
4862 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, 0);
4863 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4864 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4865 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4866
4867 /* Test length one shorter than the address length */
4868 WSASetLastError(0);
4869 pdst = NULL;
4870 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, 6);
4871 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4872 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4873 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4874
4875 /* Test longer length is ok */
4876 WSASetLastError(0);
4877 pdst = NULL;
4878 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, sizeof(dst)+1);
4879 ok(pdst != NULL, "The pointer should be returned (%p)\n", pdst);
4880 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4881
4882 /* Test the IPv6 addresses */
4883
4884 /* Test an zero prefixed IPV6 address */
4885 memcpy(in6.u.Byte, addr2_Num, sizeof(addr2_Num));
4886 pdst = pInetNtop(AF_INET6,(void*)&in6.s6_addr, dst6, sizeof(dst6));
4887 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
4888 ok(!strcmp(pdst, addr2_Str),"Address %s != %s\n", pdst, addr2_Str);
4889
4890 /* Test an zero suffixed IPV6 address */
4891 memcpy(in6.s6_addr, addr3_Num, sizeof(addr3_Num));
4892 pdst = pInetNtop(AF_INET6,(void*)&in6.s6_addr, dst6, sizeof(dst6));
4893 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
4894 ok(!strcmp(pdst, addr3_Str),"Address %s != %s\n", pdst, addr3_Str);
4895
4896 /* Test the IPv6 address contains the IPv4 address in IPv4 notation */
4897 memcpy(in6.s6_addr, addr4_Num, sizeof(addr4_Num));
4898 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, sizeof(dst6));
4899 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
4900 ok(!strcmp(pdst, addr4_Str),"Address %s != %s\n", pdst, addr4_Str);
4901
4902 /* Test invalid parm conditions */
4903 memcpy(in6.u.Byte, addr2_Num, sizeof(addr2_Num));
4904
4905 /* Test Null destination */
4906 pdst = NULL;
4907 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, NULL, sizeof(dst6));
4908 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4909 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4910 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4911
4912 /* Test zero length passed */
4913 WSASetLastError(0);
4914 pdst = NULL;
4915 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 0);
4916 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4917 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4918 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4919
4920 /* Test length one shorter than the address length */
4921 WSASetLastError(0);
4922 pdst = NULL;
4923 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 16);
4924 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4925 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4926 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4927
4928 /* Test longer length is ok */
4929 WSASetLastError(0);
4930 pdst = NULL;
4931 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 18);
4932 ok(pdst != NULL, "The pointer should be returned (%p)\n", pdst);
4933 }
4934 static void test_inet_pton(void)
4935 {
4936 struct TEST_DATA
4937 {
4938 int family, ret;
4939 DWORD err;
4940 const char *printable, *collapsed, *raw_data;
4941 } tests[] = {
4942 {AF_UNSPEC, -1, WSAEFAULT, /* Test 0 */
4943 NULL, NULL, NULL},
4944 {AF_INET, -1, WSAEFAULT,
4945 NULL, NULL, NULL},
4946 {AF_INET6, -1, WSAEFAULT,
4947 NULL, NULL, NULL},
4948 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
4949 "127.0.0.1", NULL, NULL},
4950 {AF_INET, 1, 0,
4951 "127.0.0.1", "127.0.0.1",
4952 "\x7f\x00\x00\x01"},
4953 {AF_INET6, 0, 0,
4954 "127.0.0.1", "127.0.0.1", NULL},
4955 {AF_INET, 0, 0,
4956 "::1/128", NULL, NULL},
4957 {AF_INET6, 0, 0,
4958 "::1/128", NULL, NULL},
4959 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
4960 "broken", NULL, NULL},
4961 {AF_INET, 0, 0,
4962 "broken", NULL, NULL},
4963 {AF_INET6, 0, 0, /* Test 10 */
4964 "broken", NULL, NULL},
4965 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
4966 "177.32.45.20", NULL, NULL},
4967 {AF_INET, 1, 0,
4968 "177.32.45.20", "177.32.45.20",
4969 "\xb1\x20\x2d\x14"},
4970 {AF_INET6, 0, 0,
4971 "177.32.45.20", NULL, NULL},
4972 {AF_INET, 0, 0,
4973 "2607:f0d0:1002:51::4", NULL, NULL},
4974 {AF_INET6, 1, 0,
4975 "2607:f0d0:1002:51::4", "2607:f0d0:1002:51::4",
4976 "\x26\x07\xf0\xd0\x10\x02\x00\x51\x00\x00\x00\x00\x00\x00\x00\x04"},
4977 {AF_INET, 0, 0,
4978 "::177.32.45.20", NULL, NULL},
4979 {AF_INET6, 1, 0,
4980 "::177.32.45.20", "::177.32.45.20",
4981 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x20\x2d\x14"},
4982 {AF_INET, 0, 0,
4983 "fe80::0202:b3ff:fe1e:8329", NULL, NULL},
4984 {AF_INET6, 1, 0,
4985 "fe80::0202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
4986 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
4987 {AF_INET6, 1, 0, /* Test 20 */
4988 "fe80::202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
4989 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
4990 {AF_INET, 0, 0,
4991 "a", NULL, NULL},
4992 {AF_INET, 0, 0,
4993 "a.b", NULL, NULL},
4994 {AF_INET, 0, 0,
4995 "a.b.c", NULL, NULL},
4996 {AF_INET, 0, 0,
4997 "a.b.c.d", NULL, NULL},
4998 {AF_INET6, 1, 0,
4999 "2001:cdba:0000:0000:0000:0000:3257:9652", "2001:cdba::3257:9652",
5000 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
5001 {AF_INET6, 1, 0,
5002 "2001:cdba::3257:9652", "2001:cdba::3257:9652",
5003 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
5004 {AF_INET6, 1, 0,
5005 "2001:cdba:0:0:0:0:3257:9652", "2001:cdba::3257:9652",
5006 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
5007 {AF_INET, 0, 0,
5008 "0x12345678", NULL, NULL},
5009 {AF_INET6, 0, 0, /* windows bug */
5010 "::1:2:3:4:5:6:7", NULL, NULL},
5011 };
5012 int i, ret;
5013 DWORD err;
5014 char buffer[64],str[64];
5015 WCHAR printableW[64], collapsedW[64];
5016 const char *ptr;
5017 const WCHAR *ptrW;
5018
5019 /* InetNtop and InetPton became available in Vista and Win2008 */
5020 if (!pInetNtop || !pInetNtopW || !pInetPtonA || !pInetPtonW)
5021 {
5022 win_skip("InetNtop and/or InetPton not present, not executing tests\n");
5023 return;
5024 }
5025
5026 for (i = 0; i < ARRAY_SIZE(tests); i++)
5027 {
5028 WSASetLastError(0xdeadbeef);
5029 ret = pInetPtonA(tests[i].family, tests[i].printable, buffer);
5030 ok (ret == tests[i].ret, "Test [%d]: Expected %d, got %d\n", i, tests[i].ret, ret);
5031 err = WSAGetLastError();
5032 if (tests[i].ret == -1)
5033 ok (tests[i].err == err, "Test [%d]: Expected 0x%x, got 0x%x\n", i, tests[i].err, err);
5034 else
5035 ok (err == 0xdeadbeef, "Test [%d]: Expected 0xdeadbeef, got 0x%x\n", i, err);
5036 if (tests[i].ret != 1) continue;
5037 ok (memcmp(buffer, tests[i].raw_data,
5038 tests[i].family == AF_INET ? sizeof(struct in_addr) : sizeof(struct in6_addr)) == 0,
5039 "Test [%d]: Expected binary data differs\n", i);
5040
5041 /* Test the result from Pton with Ntop */
5042 strcpy (str, "deadbeef");
5043 ptr = pInetNtop(tests[i].family, buffer, str, sizeof(str));
5044 ok (ptr != NULL, "Test [%d]: Failed with NULL\n", i);
5045 ok (ptr == str, "Test [%d]: Pointers differ (%p != %p)\n", i, ptr, str);
5046 if (!ptr) continue;
5047 ok (strcmp(ptr, tests[i].collapsed) == 0, "Test [%d]: Expected '%s', got '%s'\n",
5048 i, tests[i].collapsed, ptr);
5049 }
5050
5051 for (i = 0; i < ARRAY_SIZE(tests); i++)
5052 {
5053 if (tests[i].printable)
5054 MultiByteToWideChar(CP_ACP, 0, tests[i].printable, -1, printableW, ARRAY_SIZE(printableW));
5055 WSASetLastError(0xdeadbeef);
5056 ret = pInetPtonW(tests[i].family, tests[i].printable ? printableW : NULL, buffer);
5057 ok(ret == tests[i].ret, "Test [%d]: Expected %d, got %d\n", i, tests[i].ret, ret);
5058 err = WSAGetLastError();
5059 if (tests[i].ret == -1)
5060 ok(tests[i].err == err, "Test [%d]: Expected 0x%x, got 0x%x\n", i, tests[i].err, err);
5061 else if (tests[i].ret == 0)
5062 ok(err == WSAEINVAL || broken(err == 0xdeadbeef) /* win2008 */,
5063 "Test [%d]: Expected WSAEINVAL, got 0x%x\n", i, err);
5064 else
5065 ok(err == 0xdeadbeef, "Test [%d]: Expected 0xdeadbeef, got 0x%x\n", i, err);
5066 if (tests[i].ret != 1) continue;
5067 ok(memcmp(buffer, tests[i].raw_data,
5068 tests[i].family == AF_INET ? sizeof(struct in_addr) : sizeof(struct in6_addr)) == 0,
5069 "Test [%d]: Expected binary data differs\n", i);
5070
5071 /* Test the result from Pton with Ntop */
5072 printableW[0] = 0xdead;
5073 ptrW = pInetNtopW(tests[i].family, buffer, printableW, ARRAY_SIZE(printableW));
5074 ok (ptrW != NULL, "Test [%d]: Failed with NULL\n", i);
5075 ok (ptrW == printableW, "Test [%d]: Pointers differ (%p != %p)\n", i, ptrW, printableW);
5076 if (!ptrW) continue;
5077
5078 MultiByteToWideChar(CP_ACP, 0, tests[i].collapsed, -1, collapsedW, ARRAY_SIZE(collapsedW));
5079 ok (lstrcmpW(ptrW, collapsedW) == 0, "Test [%d]: Expected '%s', got '%s'\n",
5080 i, tests[i].collapsed, wine_dbgstr_w(ptrW));
5081 }
5082 }
5083
5084 static void test_ioctlsocket(void)
5085 {
5086 SOCKET sock, src, dst;
5087 struct tcp_keepalive kalive;
5088 struct sockaddr_in address;
5089 int ret, optval;
5090 static const LONG cmds[] = {FIONBIO, FIONREAD, SIOCATMARK};
5091 UINT i, bytes_rec;
5092 char data;
5093 WSABUF bufs;
5094 u_long arg = 0;
5095
5096 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5097 ok(sock != INVALID_SOCKET, "Creating the socket failed: %d\n", WSAGetLastError());
5098 if(sock == INVALID_SOCKET)
5099 {
5100 skip("Can't continue without a socket.\n");
5101 return;
5102 }
5103
5104 for(i = 0; i < ARRAY_SIZE(cmds); i++)
5105 {
5106 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
5107 ret = ioctlsocket(sock, cmds[i], (u_long *)1);
5108 ok(ret == SOCKET_ERROR, "ioctlsocket succeeded unexpectedly\n");
5109 ret = WSAGetLastError();
5110 ok(ret == WSAEFAULT, "expected WSAEFAULT, got %d instead\n", ret);
5111 }
5112
5113 /* A fresh and not connected socket has no urgent data, this test shows
5114 * that normal(not urgent) data returns a non-zero value for SIOCATMARK. */
5115
5116 ret = ioctlsocket(sock, SIOCATMARK, &arg);
5117 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
5118 ok(arg, "SIOCATMARK expected a non-zero value\n");
5119
5120 /* when SO_OOBINLINE is set SIOCATMARK must always return TRUE */
5121 optval = 1;
5122 ret = setsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
5123 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
5124 arg = 0;
5125 ret = ioctlsocket(sock, SIOCATMARK, &arg);
5126 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
5127 ok(arg, "SIOCATMARK expected a non-zero value\n");
5128
5129 /* disable SO_OOBINLINE and get the same old behavior */
5130 optval = 0;
5131 ret = setsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
5132 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
5133 arg = 0;
5134 ret = ioctlsocket(sock, SIOCATMARK, &arg);
5135 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
5136 ok(arg, "SIOCATMARK expected a non-zero value\n");
5137
5138 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &arg, 0, NULL, 0, &arg, NULL, NULL);
5139 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5140 ret = WSAGetLastError();
5141 ok(ret == WSAEFAULT || broken(ret == WSAEINVAL), "expected WSAEFAULT, got %d instead\n", ret);
5142
5143 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, NULL, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5144 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5145 ret = WSAGetLastError();
5146 ok(ret == WSAEFAULT || broken(ret == WSAEINVAL), "expected WSAEFAULT, got %d instead\n", ret);
5147
5148 make_keepalive(kalive, 0, 0, 0);
5149 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5150 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5151
5152 make_keepalive(kalive, 1, 0, 0);
5153 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5154 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5155
5156 make_keepalive(kalive, 1, 1000, 1000);
5157 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5158 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5159
5160 make_keepalive(kalive, 1, 10000, 10000);
5161 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5162 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5163
5164 make_keepalive(kalive, 1, 100, 100);
5165 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5166 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5167
5168 make_keepalive(kalive, 0, 100, 100);
5169 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5170 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5171
5172 closesocket(sock);
5173
5174 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5175 ok(sock != INVALID_SOCKET, "Creating the socket failed: %d\n", WSAGetLastError());
5176 if(sock == INVALID_SOCKET)
5177 {
5178 skip("Can't continue without a socket.\n");
5179 return;
5180 }
5181
5182 /* test FIONREAD with a fresh and non-connected socket */
5183 arg = 0xdeadbeef;
5184 ret = ioctlsocket(sock, FIONREAD, &arg);
5185 ok(ret == 0, "ioctlsocket failed unexpectedly with error %d\n", WSAGetLastError());
5186 ok(arg == 0, "expected 0, got %u\n", arg);
5187
5188 memset(&address, 0, sizeof(address));
5189 address.sin_family = AF_INET;
5190 address.sin_addr.s_addr = inet_addr( SERVERIP );
5191 address.sin_port = htons( SERVERPORT );
5192 ret = bind(sock, (struct sockaddr *)&address, sizeof(address));
5193 ok(ret == 0, "bind failed unexpectedly with error %d\n", WSAGetLastError());
5194
5195 ret = listen(sock, SOMAXCONN);
5196 ok(ret == 0, "listen failed unexpectedly with error %d\n", WSAGetLastError());
5197
5198 /* test FIONREAD with listening socket */
5199 arg = 0xdeadbeef;
5200 ret = ioctlsocket(sock, FIONREAD, &arg);
5201 ok(ret == 0, "ioctlsocket failed unexpectedly with error %d\n", WSAGetLastError());
5202 ok(arg == 0, "expected 0, got %u\n", arg);
5203
5204 closesocket(sock);
5205
5206 if (tcp_socketpair(&src, &dst) != 0)
5207 {
5208 ok(0, "creating socket pair failed, skipping test\n");
5209 return;
5210 }
5211
5212 /* test FIONREAD on TCP sockets */
5213 optval = 0xdeadbeef;
5214 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
5215 ok(ret == 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
5216 ok(optval == 0, "FIONREAD should have returned 0 bytes, got %d instead\n", optval);
5217
5218 optval = 0xdeadbeef;
5219 ok(send(src, "TEST", 4, 0) == 4, "failed to send test data\n");
5220 Sleep(100);
5221 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
5222 ok(ret == 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
5223 ok(optval == 4, "FIONREAD should have returned 4 bytes, got %d instead\n", optval);
5224
5225 /* trying to read from an OOB inlined socket with MSG_OOB results in WSAEINVAL */
5226 set_blocking(dst, FALSE);
5227 i = MSG_OOB;
5228 SetLastError(0xdeadbeef);
5229 ret = recv(dst, &data, 1, i);
5230 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
5231 ret = GetLastError();
5232 ok(ret == WSAEWOULDBLOCK, "expected 10035, got %d\n", ret);
5233 bufs.len = sizeof(char);
5234 bufs.buf = &data;
5235 ret = WSARecv(dst, &bufs, 1, &bytes_rec, &i, NULL, NULL);
5236 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
5237 ret = GetLastError();
5238 ok(ret == WSAEWOULDBLOCK, "expected 10035, got %d\n", ret);
5239 optval = 1;
5240 ret = setsockopt(dst, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
5241 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
5242 i = MSG_OOB;
5243 SetLastError(0xdeadbeef);
5244 ret = recv(dst, &data, 1, i);
5245 ok(ret == SOCKET_ERROR, "expected SOCKET_ERROR, got %d\n", ret);
5246 ret = GetLastError();
5247 ok(ret == WSAEINVAL, "expected 10022, got %d\n", ret);
5248 bufs.len = sizeof(char);
5249 bufs.buf = &data;
5250 ret = WSARecv(dst, &bufs, 1, &bytes_rec, &i, NULL, NULL);
5251 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
5252 ret = GetLastError();
5253 ok(ret == WSAEINVAL, "expected 10022, got %d\n", ret);
5254
5255 closesocket(dst);
5256 optval = 0xdeadbeef;
5257 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
5258 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5259 ok(optval == 0xdeadbeef, "FIONREAD should not have changed last error, got %d instead\n", optval);
5260 closesocket(src);
5261 }
5262
5263 static BOOL drain_pause = FALSE;
5264 static DWORD WINAPI drain_socket_thread(LPVOID arg)
5265 {
5266 char buffer[1024];
5267 SOCKET sock = *(SOCKET*)arg;
5268 int ret;
5269
5270 while ((ret = recv(sock, buffer, sizeof(buffer), 0)) != 0)
5271 {
5272 if (ret < 0)
5273 {
5274 if (WSAGetLastError() == WSAEWOULDBLOCK)
5275 {
5276 fd_set readset;
5277 FD_ZERO(&readset);
5278 FD_SET(sock, &readset);
5279 select(sock+1, &readset, NULL, NULL, NULL);
5280 while (drain_pause)
5281 Sleep(100);
5282 }
5283 else
5284 break;
5285 }
5286 }
5287 return 0;
5288 }
5289
5290 static void test_send(void)
5291 {
5292 SOCKET src = INVALID_SOCKET;
5293 SOCKET dst = INVALID_SOCKET;
5294 HANDLE hThread = NULL;
5295 const int buflen = 1024*1024;
5296 char *buffer = NULL;
5297 int ret, i, zero = 0;
5298 WSABUF buf;
5299 OVERLAPPED ov;
5300 BOOL bret;
5301 DWORD id, bytes_sent, dwRet;
5302
5303 memset(&ov, 0, sizeof(ov));
5304
5305 if (tcp_socketpair(&src, &dst) != 0)
5306 {
5307 ok(0, "creating socket pair failed, skipping test\n");
5308 return;
5309 }
5310
5311 set_blocking(dst, FALSE);
5312 /* force disable buffering so we can get a pending overlapped request */
5313 ret = setsockopt(dst, SOL_SOCKET, SO_SNDBUF, (char *) &zero, sizeof(zero));
5314 ok(!ret, "setsockopt SO_SNDBUF failed: %d - %d\n", ret, GetLastError());
5315
5316 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
5317 if (hThread == NULL)
5318 {
5319 ok(0, "CreateThread failed, error %d\n", GetLastError());
5320 goto end;
5321 }
5322
5323 buffer = HeapAlloc(GetProcessHeap(), 0, buflen);
5324 if (buffer == NULL)
5325 {
5326 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
5327 goto end;
5328 }
5329
5330 /* fill the buffer with some nonsense */
5331 for (i = 0; i < buflen; ++i)
5332 {
5333 buffer[i] = (char) i;
5334 }
5335
5336 ret = send(src, buffer, buflen, 0);
5337 if (ret >= 0)
5338 ok(ret == buflen, "send should have sent %d bytes, but it only sent %d\n", buflen, ret);
5339 else
5340 ok(0, "send failed, error %d\n", WSAGetLastError());
5341
5342 buf.buf = buffer;
5343 buf.len = buflen;
5344
5345 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5346 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
5347 if (!ov.hEvent)
5348 goto end;
5349
5350 bytes_sent = 0;
5351 WSASetLastError(12345);
5352 ret = WSASend(dst, &buf, 1, &bytes_sent, 0, &ov, NULL);
5353 ok((ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING) || broken(bytes_sent == buflen),
5354 "Failed to start overlapped send %d - %d - %d/%d\n", ret, WSAGetLastError(), bytes_sent, buflen);
5355
5356 /* don't check for completion yet, we may need to drain the buffer while still sending */
5357 set_blocking(src, FALSE);
5358 for (i = 0; i < buflen; ++i)
5359 {
5360 int j = 0;
5361
5362 ret = recv(src, buffer, 1, 0);
5363 while (ret == SOCKET_ERROR && GetLastError() == WSAEWOULDBLOCK && j < 100)
5364 {
5365 j++;
5366 Sleep(50);
5367 ret = recv(src, buffer, 1, 0);
5368 }
5369
5370 ok(ret == 1, "Failed to receive data %d - %d (got %d/%d)\n", ret, GetLastError(), i, buflen);
5371 if (ret != 1)
5372 break;
5373
5374 ok(buffer[0] == (char) i, "Received bad data at position %d\n", i);
5375 }
5376
5377 dwRet = WaitForSingleObject(ov.hEvent, 1000);
5378 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
5379 if (dwRet == WAIT_OBJECT_0)
5380 {
5381 bret = GetOverlappedResult((HANDLE)dst, &ov, &bytes_sent, FALSE);
5382 ok(bret && bytes_sent == buflen,
5383 "Got %d instead of %d (%d - %d)\n", bytes_sent, buflen, bret, GetLastError());
5384 }
5385
5386 WSASetLastError(12345);
5387 ret = WSASend(INVALID_SOCKET, &buf, 1, NULL, 0, &ov, NULL);
5388 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
5389 "WSASend failed %d - %d\n", ret, WSAGetLastError());
5390
5391 WSASetLastError(12345);
5392 ret = WSASend(dst, &buf, 1, NULL, 0, &ov, NULL);
5393 ok(ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING,
5394 "Failed to start overlapped send %d - %d\n", ret, WSAGetLastError());
5395
5396 end:
5397 if (src != INVALID_SOCKET)
5398 closesocket(src);
5399 if (dst != INVALID_SOCKET)
5400 closesocket(dst);
5401 if (hThread != NULL)
5402 {
5403 dwRet = WaitForSingleObject(hThread, 500);
5404 ok(dwRet == WAIT_OBJECT_0, "failed to wait for thread termination: %d\n", GetLastError());
5405 CloseHandle(hThread);
5406 }
5407 if (ov.hEvent)
5408 CloseHandle(ov.hEvent);
5409 HeapFree(GetProcessHeap(), 0, buffer);
5410 }
5411
5412 typedef struct async_message
5413 {
5414 SOCKET socket;
5415 LPARAM lparam;
5416 struct async_message *next;
5417 } async_message;
5418
5419 static struct async_message *messages_received;
5420
5421 #define WM_SOCKET (WM_USER+100)
5422 static LRESULT CALLBACK ws2_test_WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
5423 {
5424 struct async_message *message;
5425
5426 switch (msg)
5427 {
5428 case WM_SOCKET:
5429 message = HeapAlloc(GetProcessHeap(), 0, sizeof(*message));
5430 message->socket = (SOCKET) wparam;
5431 message->lparam = lparam;
5432 message->next = NULL;
5433
5434 if (messages_received)
5435 {
5436 struct async_message *last = messages_received;
5437 while (last->next) last = last->next;
5438 last->next = message;
5439 }
5440 else
5441 messages_received = message;
5442 return 0;
5443 }
5444
5445 return DefWindowProcA(hwnd, msg, wparam, lparam);
5446 }
5447
5448 static void get_event_details(int event, int *bit, char *name)
5449 {
5450 switch (event)
5451 {
5452 case FD_ACCEPT:
5453 if (bit) *bit = FD_ACCEPT_BIT;
5454 if (name) strcpy(name, "FD_ACCEPT");
5455 break;
5456 case FD_CONNECT:
5457 if (bit) *bit = FD_CONNECT_BIT;
5458 if (name) strcpy(name, "FD_CONNECT");
5459 break;
5460 case FD_READ:
5461 if (bit) *bit = FD_READ_BIT;
5462 if (name) strcpy(name, "FD_READ");
5463 break;
5464 case FD_OOB:
5465 if (bit) *bit = FD_OOB_BIT;
5466 if (name) strcpy(name, "FD_OOB");
5467 break;
5468 case FD_WRITE:
5469 if (bit) *bit = FD_WRITE_BIT;
5470 if (name) strcpy(name, "FD_WRITE");
5471 break;
5472 case FD_CLOSE:
5473 if (bit) *bit = FD_CLOSE_BIT;
5474 if (name) strcpy(name, "FD_CLOSE");
5475 break;
5476 default:
5477 if (bit) *bit = -1;
5478 if (name) sprintf(name, "bad%x", event);
5479 }
5480 }
5481
5482 static const char *dbgstr_event_seq(const LPARAM *seq)
5483 {
5484 static char message[1024];
5485 char name[12];
5486 int len = 1;
5487
5488 message[0] = '[';
5489 message[1] = 0;
5490 while (*seq)
5491 {
5492 get_event_details(WSAGETSELECTEVENT(*seq), NULL, name);
5493 len += sprintf(message + len, "%s(%d) ", name, WSAGETSELECTERROR(*seq));
5494 seq++;
5495 }
5496 if (len > 1) len--;
5497 strcpy( message + len, "]" );
5498 return message;
5499 }
5500
5501 static char *dbgstr_event_seq_result(SOCKET s, WSANETWORKEVENTS *netEvents)
5502 {
5503 static char message[1024];
5504 struct async_message *curr = messages_received;
5505 int index, error, bit = 0;
5506 char name[12];
5507 int len = 1;
5508
5509 message[0] = '[';
5510 message[1] = 0;
5511 while (1)
5512 {
5513 if (netEvents)
5514 {
5515 if (bit >= FD_MAX_EVENTS) break;
5516 if ( !(netEvents->lNetworkEvents & (1 << bit)) )
5517 {
5518 bit++;
5519 continue;
5520 }
5521 get_event_details(1 << bit, &index, name);
5522 error = netEvents->iErrorCode[index];
5523 bit++;
5524 }
5525 else
5526 {
5527 if (!curr) break;
5528 if (curr->socket != s)
5529 {
5530 curr = curr->next;
5531 continue;
5532 }
5533 get_event_details(WSAGETSELECTEVENT(curr->lparam), NULL, name);
5534 error = WSAGETSELECTERROR(curr->lparam);
5535 curr = curr->next;
5536 }
5537
5538 len += sprintf(message + len, "%s(%d) ", name, error);
5539 }
5540 if (len > 1) len--;
5541 strcpy( message + len, "]" );
5542 return message;
5543 }
5544
5545 static void flush_events(SOCKET s, HANDLE hEvent)
5546 {
5547 WSANETWORKEVENTS netEvents;
5548 struct async_message *prev = NULL, *curr = messages_received;
5549 int ret;
5550 DWORD dwRet;
5551
5552 if (hEvent != INVALID_HANDLE_VALUE)
5553 {
5554 dwRet = WaitForSingleObject(hEvent, 100);
5555 if (dwRet == WAIT_OBJECT_0)
5556 {
5557 ret = WSAEnumNetworkEvents(s, hEvent, &netEvents);
5558 if (ret)
5559 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
5560 }
5561 }
5562 else
5563 {
5564 while (curr)
5565 {
5566 if (curr->socket == s)
5567 {
5568 if (prev) prev->next = curr->next;
5569 else messages_received = curr->next;
5570
5571 HeapFree(GetProcessHeap(), 0, curr);
5572
5573 if (prev) curr = prev->next;
5574 else curr = messages_received;
5575 }
5576 else
5577 {
5578 prev = curr;
5579 curr = curr->next;
5580 }
5581 }
5582 }
5583 }
5584
5585 static int match_event_sequence(SOCKET s, WSANETWORKEVENTS *netEvents, const LPARAM *seq)
5586 {
5587 int event, index, error, events;
5588 struct async_message *curr;
5589
5590 if (netEvents)
5591 {
5592 events = netEvents->lNetworkEvents;
5593 while (*seq)
5594 {
5595 event = WSAGETSELECTEVENT(*seq);
5596 error = WSAGETSELECTERROR(*seq);
5597 get_event_details(event, &index, NULL);
5598
5599 if (!(events & event) && index != -1)
5600 return 0;
5601 if (events & event && index != -1)
5602 {
5603 if (netEvents->iErrorCode[index] != error)
5604 return 0;
5605 }
5606 events &= ~event;
5607 seq++;
5608 }
5609 if (events)
5610 return 0;
5611 }
5612 else
5613 {
5614 curr = messages_received;
5615 while (curr)
5616 {
5617 if (curr->socket == s)
5618 {
5619 if (!*seq) return 0;
5620 if (*seq != curr->lparam) return 0;
5621 seq++;
5622 }
5623 curr = curr->next;
5624 }
5625 if (*seq)
5626 return 0;
5627 }
5628 return 1;
5629 }
5630
5631 /* checks for a sequence of events, (order only checked if window is used) */
5632 static void ok_event_sequence(SOCKET s, HANDLE hEvent, const LPARAM *seq, const LPARAM **broken_seqs, int completelyBroken)
5633 {
5634 MSG msg;
5635 WSANETWORKEVENTS events, *netEvents = NULL;
5636 int ret;
5637 DWORD dwRet;
5638
5639 if (hEvent != INVALID_HANDLE_VALUE)
5640 {
5641 netEvents = &events;
5642
5643 dwRet = WaitForSingleObject(hEvent, 200);
5644 if (dwRet == WAIT_OBJECT_0)
5645 {
5646 ret = WSAEnumNetworkEvents(s, hEvent, netEvents);
5647 if (ret)
5648 {
5649 winetest_ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
5650 return;
5651 }
5652 }
5653 else
5654 memset(netEvents, 0, sizeof(*netEvents));
5655 }
5656 else
5657 {
5658 Sleep(200);
5659 /* Run the message loop a little */
5660 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
5661 {
5662 DispatchMessageA(&msg);
5663 }
5664 }
5665
5666 if (match_event_sequence(s, netEvents, seq))
5667 {
5668 winetest_ok(1, "Sequence matches expected: %s\n", dbgstr_event_seq(seq));
5669 flush_events(s, hEvent);
5670 return;
5671 }
5672
5673 if (broken_seqs)
5674 {
5675 for (; *broken_seqs; broken_seqs++)
5676 {
5677 if (match_event_sequence(s, netEvents, *broken_seqs))
5678 {
5679 winetest_ok(broken(1), "Sequence matches broken: %s, expected %s\n", dbgstr_event_seq_result(s, netEvents), dbgstr_event_seq(seq));
5680 flush_events(s, hEvent);
5681 return;
5682 }
5683 }
5684 }
5685
5686 winetest_ok(broken(completelyBroken), "Expected event sequence %s, got %s\n", dbgstr_event_seq(seq),
5687 dbgstr_event_seq_result(s, netEvents));
5688 flush_events(s, hEvent);
5689 }
5690
5691 #define ok_event_seq (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : ok_event_sequence
5692
5693 static void test_events(int useMessages)
5694 {
5695 SOCKET server = INVALID_SOCKET;
5696 SOCKET src = INVALID_SOCKET, src2 = INVALID_SOCKET;
5697 SOCKET dst = INVALID_SOCKET, dst2 = INVALID_SOCKET;
5698 struct sockaddr_in addr;
5699 HANDLE hThread = NULL;
5700 HANDLE hEvent = INVALID_HANDLE_VALUE, hEvent2 = INVALID_HANDLE_VALUE;
5701 WNDCLASSEXA wndclass;
5702 HWND hWnd = NULL;
5703 char *buffer = NULL;
5704 int bufferSize = 1024*1024;
5705 WSABUF bufs;
5706 OVERLAPPED ov, ov2;
5707 DWORD flags = 0;
5708 DWORD bytesReturned;
5709 DWORD id;
5710 int len;
5711 int ret;
5712 DWORD dwRet;
5713 BOOL bret;
5714 static char szClassName[] = "wstestclass";
5715 const LPARAM *broken_seq[3];
5716 static const LPARAM empty_seq[] = { 0 };
5717 static const LPARAM close_seq[] = { WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
5718 static const LPARAM write_seq[] = { WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5719 static const LPARAM read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0), 0 };
5720 static const LPARAM oob_seq[] = { WSAMAKESELECTREPLY(FD_OOB, 0), 0 };
5721 static const LPARAM connect_seq[] = { WSAMAKESELECTREPLY(FD_CONNECT, 0),
5722 WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5723 static const LPARAM read_read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5724 WSAMAKESELECTREPLY(FD_READ, 0), 0 };
5725 static const LPARAM read_write_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5726 WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5727 static const LPARAM read_close_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5728 WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
5729
5730 memset(&ov, 0, sizeof(ov));
5731 memset(&ov2, 0, sizeof(ov2));
5732
5733 /* don't use socketpair, we want connection event */
5734 src = socket(AF_INET, SOCK_STREAM, 0);
5735 if (src == INVALID_SOCKET)
5736 {
5737 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5738 goto end;
5739 }
5740
5741 ret = set_blocking(src, TRUE);
5742 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5743
5744 src2 = socket(AF_INET, SOCK_STREAM, 0);
5745 if (src2 == INVALID_SOCKET)
5746 {
5747 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5748 goto end;
5749 }
5750
5751 ret = set_blocking(src2, TRUE);
5752 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5753
5754 len = sizeof(BOOL);
5755 if (getsockopt(src, SOL_SOCKET, SO_OOBINLINE, (void *)&bret, &len) == SOCKET_ERROR)
5756 {
5757 ok(0, "failed to get oobinline status, %d\n", GetLastError());
5758 goto end;
5759 }
5760 ok(bret == FALSE, "OOB not inline\n");
5761
5762 if (useMessages)
5763 {
5764 trace("Event test using messages\n");
5765
5766 wndclass.cbSize = sizeof(wndclass);
5767 wndclass.style = CS_HREDRAW | CS_VREDRAW;
5768 wndclass.lpfnWndProc = ws2_test_WndProc;
5769 wndclass.cbClsExtra = 0;
5770 wndclass.cbWndExtra = 0;
5771 wndclass.hInstance = GetModuleHandleA(NULL);
5772 wndclass.hIcon = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
5773 wndclass.hIconSm = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
5774 wndclass.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
5775 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
5776 wndclass.lpszClassName = szClassName;
5777 wndclass.lpszMenuName = NULL;
5778 RegisterClassExA(&wndclass);
5779
5780 hWnd = CreateWindowA(szClassName, "WS2Test", WS_OVERLAPPEDWINDOW,
5781 0, 0, 500, 500, NULL, NULL, GetModuleHandleA(NULL), NULL);
5782 if (!hWnd)
5783 {
5784 ok(0, "failed to create window: %d\n", GetLastError());
5785 return;
5786 }
5787
5788 ret = WSAAsyncSelect(src, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5789 if (ret)
5790 {
5791 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5792 goto end;
5793 }
5794
5795 ok(set_blocking(src, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5796 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5797
5798 ret = WSAAsyncSelect(src2, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5799 if (ret)
5800 {
5801 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5802 goto end;
5803 }
5804
5805 ok(set_blocking(src2, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5806 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5807 }
5808 else
5809 {
5810 trace("Event test using events\n");
5811
5812 hEvent = WSACreateEvent();
5813 if (hEvent == INVALID_HANDLE_VALUE)
5814 {
5815 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5816 goto end;
5817 }
5818
5819 hEvent2 = WSACreateEvent();
5820 if (hEvent2 == INVALID_HANDLE_VALUE)
5821 {
5822 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5823 goto end;
5824 }
5825
5826 ret = WSAEventSelect(src, hEvent, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5827 if (ret)
5828 {
5829 ok(0, "WSAEventSelect failed, error %d\n", ret);
5830 goto end;
5831 }
5832
5833 ok(set_blocking(src, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5834 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5835
5836 ret = WSAEventSelect(src2, hEvent2, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5837 if (ret)
5838 {
5839 ok(0, "WSAEventSelect failed, error %d\n", ret);
5840 goto end;
5841 }
5842
5843 ok(set_blocking(src2, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5844 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5845 }
5846
5847 server = socket(AF_INET, SOCK_STREAM, 0);
5848 if (server == INVALID_SOCKET)
5849 {
5850 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5851 goto end;
5852 }
5853
5854 memset(&addr, 0, sizeof(addr));
5855 addr.sin_family = AF_INET;
5856 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
5857 ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
5858 if (ret != 0)
5859 {
5860 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5861 goto end;
5862 }
5863
5864 len = sizeof(addr);
5865 ret = getsockname(server, (struct sockaddr*)&addr, &len);
5866 if (ret != 0)
5867 {
5868 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5869 goto end;
5870 }
5871
5872 ret = listen(server, 2);
5873 if (ret != 0)
5874 {
5875 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5876 goto end;
5877 }
5878
5879 SetLastError(0xdeadbeef);
5880 ret = connect(src, NULL, 0);
5881 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
5882 ok(GetLastError() == WSAEFAULT, "expected 10014, got %d\n", GetLastError());
5883
5884 ret = connect(src, (struct sockaddr*)&addr, sizeof(addr));
5885 if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
5886 {
5887 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5888 goto end;
5889 }
5890
5891 ret = connect(src2, (struct sockaddr*)&addr, sizeof(addr));
5892 if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
5893 {
5894 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5895 goto end;
5896 }
5897
5898 len = sizeof(addr);
5899 dst = accept(server, (struct sockaddr*)&addr, &len);
5900 if (dst == INVALID_SOCKET)
5901 {
5902 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5903 goto end;
5904 }
5905
5906 len = sizeof(addr);
5907 dst2 = accept(server, (struct sockaddr*)&addr, &len);
5908 if (dst2 == INVALID_SOCKET)
5909 {
5910 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5911 goto end;
5912 }
5913
5914 closesocket(server);
5915 server = INVALID_SOCKET;
5916
5917 /* On Windows it seems when a non-blocking socket sends to a
5918 blocking socket on the same host, the send() is BLOCKING,
5919 so make both sockets non-blocking. src is already non-blocking
5920 from the async select */
5921
5922 if (set_blocking(dst, FALSE))
5923 {
5924 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
5925 goto end;
5926 }
5927
5928 buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bufferSize);
5929 if (buffer == NULL)
5930 {
5931 ok(0, "could not allocate memory for test\n");
5932 goto end;
5933 }
5934
5935 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5936 if (ov.hEvent == NULL)
5937 {
5938 ok(0, "could not create event object, errno = %d\n", GetLastError());
5939 goto end;
5940 }
5941
5942 ov2.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5943 if (ov2.hEvent == NULL)
5944 {
5945 ok(0, "could not create event object, errno = %d\n", GetLastError());
5946 goto end;
5947 }
5948
5949 /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
5950 ok_event_seq(src, hEvent, connect_seq, NULL, 1);
5951 ok_event_seq(src2, hEvent2, connect_seq, NULL, 1);
5952 /* broken on all windows - FD_CONNECT error is garbage */
5953
5954 /* Test simple send/recv */
5955 SetLastError(0xdeadbeef);
5956 ret = send(dst, buffer, 100, 0);
5957 ok(ret == 100, "Failed to send buffer %d err %d\n", ret, GetLastError());
5958 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5959 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5960
5961 SetLastError(0xdeadbeef);
5962 ret = recv(src, buffer, 1, MSG_PEEK);
5963 ok(ret == 1, "Failed to peek at recv buffer %d err %d\n", ret, GetLastError());
5964 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5965 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5966
5967 SetLastError(0xdeadbeef);
5968 ret = recv(src, buffer, 50, 0);
5969 ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
5970 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5971 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5972
5973 ret = recv(src, buffer, 50, 0);
5974 ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
5975 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5976
5977 /* fun fact - events are re-enabled even on failure, but only for messages */
5978 ret = send(dst, "1", 1, 0);
5979 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
5980 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5981
5982 ret = recv(src, buffer, -1, 0);
5983 ok(ret == SOCKET_ERROR && (GetLastError() == WSAEFAULT || GetLastError() == WSAENOBUFS),
5984 "Failed to recv buffer %d err %d\n", ret, GetLastError());
5985 if (useMessages)
5986 {
5987 broken_seq[0] = empty_seq; /* win9x */
5988 broken_seq[1] = NULL;
5989 todo_wine ok_event_seq(src, hEvent, read_seq, broken_seq, 0);
5990 }
5991 else
5992 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5993
5994 SetLastError(0xdeadbeef);
5995 ret = recv(src, buffer, 1, 0);
5996 ok(ret == 1, "Failed to recv buffer %d err %d\n", ret, GetLastError());
5997 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5998 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5999
6000 /* Interaction with overlapped */
6001 bufs.len = sizeof(char);
6002 bufs.buf = buffer;
6003 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
6004 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
6005 "WSARecv failed - %d error %d\n", ret, GetLastError());
6006
6007 bufs.len = sizeof(char);
6008 bufs.buf = buffer+1;
6009 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov2, NULL);
6010 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
6011 "WSARecv failed - %d error %d\n", ret, GetLastError());
6012
6013 ret = send(dst, "12", 2, 0);
6014 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
6015 broken_seq[0] = read_read_seq; /* win9x */
6016 broken_seq[1] = NULL;
6017 ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
6018
6019 dwRet = WaitForSingleObject(ov.hEvent, 100);
6020 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
6021 if (dwRet == WAIT_OBJECT_0)
6022 {
6023 bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
6024 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
6025 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
6026 ok(buffer[0] == '1', "Got %c instead of 1\n", buffer[0]);
6027 }
6028
6029 dwRet = WaitForSingleObject(ov2.hEvent, 100);
6030 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
6031 if (dwRet == WAIT_OBJECT_0)
6032 {
6033 bret = GetOverlappedResult((HANDLE)src, &ov2, &bytesReturned, FALSE);
6034 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
6035 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
6036 ok(buffer[1] == '2', "Got %c instead of 2\n", buffer[1]);
6037 }
6038
6039 SetLastError(0xdeadbeef);
6040 ret = send(dst, "1", 1, 0);
6041 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
6042 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6043 ok_event_seq(src, hEvent, read_seq, NULL, 0);
6044
6045 ret = recv(src, buffer, 1, 0);
6046 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
6047 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
6048
6049 /* Notifications are delivered as soon as possible, blocked only on
6050 * async requests on the same type */
6051 bufs.len = sizeof(char);
6052 bufs.buf = buffer;
6053 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
6054 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
6055 "WSARecv failed - %d error %d\n", ret, GetLastError());
6056
6057 if (0) {
6058 ret = send(dst, "1", 1, MSG_OOB);
6059 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
6060 ok_event_seq(src, hEvent, oob_seq, NULL, 0);
6061 }
6062
6063 dwRet = WaitForSingleObject(ov.hEvent, 100);
6064 ok(dwRet == WAIT_TIMEOUT, "OOB message activated read?: %d - %d\n", dwRet, GetLastError());
6065
6066 ret = send(dst, "2", 1, 0);
6067 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
6068 broken_seq[0] = read_seq; /* win98 */
6069 broken_seq[1] = NULL;
6070 ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
6071
6072 dwRet = WaitForSingleObject(ov.hEvent, 100);
6073 ok(dwRet == WAIT_OBJECT_0 || broken(dwRet == WAIT_TIMEOUT),
6074 "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
6075 if (dwRet == WAIT_OBJECT_0)
6076 {
6077 bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
6078 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
6079 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
6080 ok(buffer[0] == '2', "Got %c instead of 2\n", buffer[0]);
6081 }
6082
6083 if (0) {
6084 ret = recv(src, buffer, 1, MSG_OOB);
6085 todo_wine ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
6086 /* We get OOB notification, but no data on wine */
6087 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
6088 }
6089
6090 /* Flood the send queue */
6091 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
6092 if (hThread == NULL)
6093 {
6094 ok(0, "CreateThread failed, error %d\n", GetLastError());
6095 goto end;
6096 }
6097
6098 /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
6099 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
6100
6101 /* Now if we send a ton of data and the 'server' does not drain it fast
6102 * enough (set drain_pause to be sure), the socket send buffer will only
6103 * take some of it, and we will get a short write. This will trigger
6104 * another FD_WRITE event as soon as data is sent and more space becomes
6105 * available, but not any earlier. */
6106 drain_pause = TRUE;
6107 do
6108 {
6109 ret = send(src, buffer, bufferSize, 0);
6110 } while (ret == bufferSize);
6111 drain_pause = FALSE;
6112 if (ret >= 0 || WSAGetLastError() == WSAEWOULDBLOCK)
6113 {
6114 Sleep(400); /* win9x */
6115 broken_seq[0] = read_write_seq;
6116 broken_seq[1] = NULL;
6117 ok_event_seq(src, hEvent, write_seq, broken_seq, 0);
6118 }
6119 else
6120 {
6121 ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
6122 }
6123
6124 /* Test how FD_CLOSE is handled */
6125 ret = send(dst, "12", 2, 0);
6126 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
6127
6128 /* Wait a little and let the send complete */
6129 Sleep(100);
6130 closesocket(dst);
6131 dst = INVALID_SOCKET;
6132 Sleep(100);
6133
6134 /* We can never implement this in wine, best we can hope for is
6135 sending FD_CLOSE after the reads complete */
6136 broken_seq[0] = read_seq; /* win9x */
6137 broken_seq[1] = NULL;
6138 todo_wine ok_event_seq(src, hEvent, read_close_seq, broken_seq, 0);
6139
6140 ret = recv(src, buffer, 1, 0);
6141 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
6142 ok_event_seq(src, hEvent, read_seq, NULL, 0);
6143
6144 ret = recv(src, buffer, 1, 0);
6145 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
6146 /* want it? it's here, but you can't have it */
6147 broken_seq[0] = close_seq; /* win9x */
6148 broken_seq[1] = NULL;
6149 todo_wine ok_event_seq(src, hEvent, empty_seq, /* wine sends FD_CLOSE here */
6150 broken_seq, 0);
6151
6152 /* Test how FD_CLOSE is handled */
6153 ret = send(dst2, "12", 2, 0);
6154 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
6155
6156 Sleep(200);
6157 shutdown(dst2, SD_SEND);
6158 Sleep(200);
6159
6160 /* Some of the below are technically todo_wine, but our event sequence is still valid, so to prevent
6161 regressions, don't mark them as todo_wine, and mark windows as broken */
6162 broken_seq[0] = read_close_seq;
6163 broken_seq[1] = close_seq;
6164 broken_seq[2] = NULL;
6165 ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
6166
6167 ret = recv(src2, buffer, 1, 0);
6168 ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
6169 broken_seq[0] = close_seq; /* win98 */
6170 broken_seq[1] = NULL;
6171 ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
6172
6173 ret = recv(src2, buffer, 1, 0);
6174 ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
6175 broken_seq[0] = empty_seq;
6176 broken_seq[1] = NULL;
6177 ok_event_seq(src2, hEvent2, close_seq, broken_seq, 0);
6178
6179 ret = send(src2, "1", 1, 0);
6180 ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
6181 ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
6182
6183 ret = send(src2, "1", 1, 0);
6184 ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
6185 ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
6186
6187 if (useMessages)
6188 {
6189 ret = WSAAsyncSelect(src, hWnd, WM_SOCKET, 0);
6190 if (ret)
6191 {
6192 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
6193 goto end;
6194 }
6195
6196 ret = set_blocking(src, TRUE);
6197 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
6198
6199 ret = WSAAsyncSelect(src2, hWnd, WM_SOCKET, 0);
6200 if (ret)
6201 {
6202 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
6203 goto end;
6204 }
6205
6206 ret = set_blocking(src2, TRUE);
6207 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
6208 }
6209 else
6210 {
6211 ret = WSAEventSelect(src, hEvent2, 0);
6212 if (ret)
6213 {
6214 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
6215 goto end;
6216 }
6217
6218 ret = set_blocking(src, TRUE);
6219 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
6220
6221 ret = WSAEventSelect(src2, hEvent2, 0);
6222 if (ret)
6223 {
6224 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
6225 goto end;
6226 }
6227
6228 ret = set_blocking(src2, TRUE);
6229 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
6230 }
6231
6232 end:
6233 if (src != INVALID_SOCKET)
6234 {
6235 flush_events(src, hEvent);
6236 closesocket(src);
6237 }
6238 if (src2 != INVALID_SOCKET)
6239 {
6240 flush_events(src2, hEvent2);
6241 closesocket(src2);
6242 }
6243 HeapFree(GetProcessHeap(), 0, buffer);
6244 if (server != INVALID_SOCKET)
6245 closesocket(server);
6246 if (dst != INVALID_SOCKET)
6247 closesocket(dst);
6248 if (dst2 != INVALID_SOCKET)
6249 closesocket(dst2);
6250 if (hThread != NULL)
6251 CloseHandle(hThread);
6252 if (hWnd != NULL)
6253 DestroyWindow(hWnd);
6254 if (hEvent != NULL)
6255 CloseHandle(hEvent);
6256 if (hEvent2 != NULL)
6257 CloseHandle(hEvent2);
6258 if (ov.hEvent != NULL)
6259 CloseHandle(ov.hEvent);
6260 if (ov2.hEvent != NULL)
6261 CloseHandle(ov2.hEvent);
6262 }
6263
6264 static void test_ipv6only(void)
6265 {
6266 SOCKET v4 = INVALID_SOCKET, v6;
6267 struct sockaddr_in sin4;
6268 struct sockaddr_in6 sin6;
6269 int ret, enabled, len = sizeof(enabled);
6270
6271 memset(&sin4, 0, sizeof(sin4));
6272 sin4.sin_family = AF_INET;
6273 sin4.sin_port = htons(SERVERPORT);
6274
6275 memset(&sin6, 0, sizeof(sin6));
6276 sin6.sin6_family = AF_INET6;
6277 sin6.sin6_port = htons(SERVERPORT);
6278
6279 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
6280 if (v6 == INVALID_SOCKET)
6281 {
6282 skip("Could not create IPv6 socket (LastError: %d)\n", WSAGetLastError());
6283 goto end;
6284 }
6285
6286 enabled = 2;
6287 ret = getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
6288 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6289 ok(enabled == 1, "expected 1, got %d\n", enabled);
6290
6291 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
6292 if (ret)
6293 {
6294 skip("Could not bind IPv6 address (LastError: %d)\n", WSAGetLastError());
6295 goto end;
6296 }
6297
6298 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6299 ok(v4 != INVALID_SOCKET, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
6300
6301 todo_wine {
6302 enabled = 2;
6303 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
6304 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6305 ok(enabled == 1, "expected 1, got %d\n", enabled);
6306 }
6307
6308 enabled = 0;
6309 len = sizeof(enabled);
6310 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
6311 ok(!ret, "setsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6312
6313 todo_wine {
6314 enabled = 2;
6315 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
6316 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6317 ok(!enabled, "expected 0, got %d\n", enabled);
6318 }
6319
6320 enabled = 1;
6321 len = sizeof(enabled);
6322 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
6323 ok(!ret, "setsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6324
6325 /* bind on IPv4 socket should succeed - IPV6_V6ONLY is enabled by default */
6326 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
6327 ok(!ret, "Could not bind IPv4 address (LastError: %d)\n", WSAGetLastError());
6328
6329 todo_wine {
6330 enabled = 2;
6331 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
6332 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6333 ok(enabled == 1, "expected 1, got %d\n", enabled);
6334 }
6335
6336 enabled = 0;
6337 len = sizeof(enabled);
6338 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
6339 ok(ret, "setsockopt(IPV6_ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
6340
6341 todo_wine {
6342 enabled = 0;
6343 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
6344 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6345 ok(enabled == 1, "expected 1, got %d\n", enabled);
6346 }
6347
6348 enabled = 1;
6349 len = sizeof(enabled);
6350 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
6351 ok(ret, "setsockopt(IPV6_ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
6352
6353 closesocket(v4);
6354 closesocket(v6);
6355
6356 /* Test again, this time disabling IPV6_V6ONLY. */
6357 sin4.sin_port = htons(SERVERPORT+2);
6358 sin6.sin6_port = htons(SERVERPORT+2);
6359
6360 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
6361 ok(v6 != INVALID_SOCKET, "Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
6362 WSAGetLastError(), WSAEAFNOSUPPORT);
6363
6364 enabled = 0;
6365 ret = setsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
6366 ok(!ret, "Could not disable IPV6_V6ONLY (LastError: %d).\n", WSAGetLastError());
6367
6368 enabled = 2;
6369 ret = getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
6370 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6371 ok(!enabled, "expected 0, got %d\n", enabled);
6372
6373 /*
6374 Observaition:
6375 On Windows, bind on both IPv4 and IPv6 with IPV6_V6ONLY disabled succeeds by default.
6376 Application must set SO_EXCLUSIVEADDRUSE on first socket to disallow another successful bind.
6377 In general, a standard application should not use SO_REUSEADDR.
6378 Setting both SO_EXCLUSIVEADDRUSE and SO_REUSEADDR on the same socket is not possible in
6379 either order, the later setsockopt call always fails.
6380 */
6381 enabled = 1;
6382 ret = setsockopt(v6, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&enabled, len);
6383 ok(!ret, "Could not set SO_EXCLUSIVEADDRUSE on IPv6 socket (LastError: %d)\n", WSAGetLastError());
6384
6385 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
6386 ok(!ret, "Could not bind IPv6 address (LastError: %d)\n", WSAGetLastError());
6387
6388 enabled = 2;
6389 len = sizeof(enabled);
6390 getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
6391 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6392 ok(!enabled, "IPV6_V6ONLY is enabled after bind\n");
6393
6394 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6395 ok(v4 != INVALID_SOCKET, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
6396
6397 enabled = 1;
6398 ret = setsockopt(v4, SOL_SOCKET, SO_REUSEADDR, (char*)&enabled, len);
6399 ok(!ret, "Could not set SO_REUSEADDR on IPv4 socket (LastError: %d)\n", WSAGetLastError());
6400
6401 WSASetLastError(0xdeadbeef);
6402 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
6403 ok(ret, "bind succeeded unexpectedly for the IPv4 socket\n");
6404 ok(WSAGetLastError() == WSAEACCES, "Expected 10013, got %d\n", WSAGetLastError());
6405
6406 end:
6407 if (v4 != INVALID_SOCKET)
6408 closesocket(v4);
6409 if (v6 != INVALID_SOCKET)
6410 closesocket(v6);
6411 }
6412
6413 static void test_WSASendMsg(void)
6414 {
6415 SOCKET sock, dst;
6416 struct sockaddr_in sendaddr, sockaddr;
6417 GUID WSASendMsg_GUID = WSAID_WSASENDMSG;
6418 LPFN_WSASENDMSG pWSASendMsg = NULL;
6419 char teststr[12] = "hello world", buffer[32];
6420 WSABUF iovec[2];
6421 WSAMSG msg;
6422 DWORD bytesSent, err;
6423 int ret, addrlen;
6424
6425 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
6426
6427 sock = socket(AF_INET, SOCK_DGRAM, 0);
6428 ok(sock != INVALID_SOCKET, "socket() failed\n");
6429
6430 /* Obtain the WSASendMsg function */
6431 WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSASendMsg_GUID, sizeof(WSASendMsg_GUID),
6432 &pWSASendMsg, sizeof(pWSASendMsg), &err, NULL, NULL);
6433 if (!pWSASendMsg)
6434 {
6435 closesocket(sock);
6436 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
6437 return;
6438 }
6439
6440 /* fake address for now */
6441 sendaddr.sin_family = AF_INET;
6442 sendaddr.sin_port = htons(139);
6443 sendaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6444
6445 memset(&msg, 0, sizeof(msg));
6446 iovec[0].buf = teststr;
6447 iovec[0].len = sizeof(teststr);
6448 iovec[1].buf = teststr;
6449 iovec[1].len = sizeof(teststr) / 2;
6450 msg.name = (struct sockaddr *) &sendaddr;
6451 msg.namelen = sizeof(sendaddr);
6452 msg.lpBuffers = iovec;
6453 msg.dwBufferCount = 1; /* send only one buffer for now */
6454
6455 WSASetLastError(0xdeadbeef);
6456 ret = pWSASendMsg(INVALID_SOCKET, &msg, 0, NULL, NULL, NULL);
6457 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6458 err = WSAGetLastError();
6459 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
6460
6461 WSASetLastError(0xdeadbeef);
6462 ret = pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL);
6463 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6464 err = WSAGetLastError();
6465 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
6466
6467 WSASetLastError(0xdeadbeef);
6468 ret = pWSASendMsg(sock, NULL, 0, &bytesSent, NULL, NULL);
6469 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6470 err = WSAGetLastError();
6471 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
6472
6473 WSASetLastError(0xdeadbeef);
6474 ret = pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL);
6475 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6476 err = WSAGetLastError();
6477 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
6478
6479 closesocket(sock);
6480
6481 sock = socket(AF_INET, SOCK_DGRAM, 0);
6482 ok(sock != INVALID_SOCKET, "socket() failed\n");
6483
6484 dst = socket(AF_INET, SOCK_DGRAM, 0);
6485 ok(dst != INVALID_SOCKET, "socket() failed\n");
6486
6487 memset(&sockaddr, 0, sizeof(sockaddr));
6488 sockaddr.sin_family = AF_INET;
6489 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6490 ok(!bind(dst, (struct sockaddr*)&sockaddr, sizeof(sockaddr)),
6491 "bind should have worked\n");
6492
6493 /* read address to find out the port number to be used in send */
6494 memset(&sendaddr, 0, sizeof(sendaddr));
6495 addrlen = sizeof(sendaddr);
6496 ok(!getsockname(dst, (struct sockaddr *) &sendaddr, &addrlen),
6497 "getsockname should have worked\n");
6498 ok(sendaddr.sin_port, "socket port should be != 0\n");
6499
6500 /* ensure the sending socket is not bound */
6501 WSASetLastError(0xdeadbeef);
6502 addrlen = sizeof(sockaddr);
6503 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
6504 ok(ret == SOCKET_ERROR, "getsockname should have failed\n");
6505 err = WSAGetLastError();
6506 ok(err == WSAEINVAL, "expected 10022, got %d instead\n", err);
6507
6508 set_blocking(sock, TRUE);
6509
6510 bytesSent = 0;
6511 SetLastError(0xdeadbeef);
6512 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
6513 ok(!ret, "WSASendMsg should have worked\n");
6514 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
6515 "Expected 0, got %d\n", GetLastError());
6516 ok(bytesSent == iovec[0].len, "incorrect bytes sent, expected %d, sent %d\n",
6517 iovec[0].len, bytesSent);
6518
6519 /* receive data */
6520 addrlen = sizeof(sockaddr);
6521 memset(buffer, 0, sizeof(buffer));
6522 SetLastError(0xdeadbeef);
6523 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
6524 ok(ret == bytesSent, "got %d, expected %d\n",
6525 ret, bytesSent);
6526 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6527
6528 /* A successful call to WSASendMsg must have bound the socket */
6529 addrlen = sizeof(sockaddr);
6530 sockaddr.sin_port = 0;
6531 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6532 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
6533 ok(!ret, "getsockname should have worked\n");
6534 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
6535 inet_ntoa(sockaddr.sin_addr));
6536 ok(sockaddr.sin_port, "sin_port should be != 0\n");
6537
6538 msg.dwBufferCount = 2; /* send both buffers */
6539
6540 bytesSent = 0;
6541 SetLastError(0xdeadbeef);
6542 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
6543 ok(!ret, "WSASendMsg should have worked\n");
6544 ok(bytesSent == iovec[0].len + iovec[1].len, "incorrect bytes sent, expected %d, sent %d\n",
6545 iovec[0].len + iovec[1].len, bytesSent);
6546 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
6547 "Expected 0, got %d\n", GetLastError());
6548
6549 /* receive data */
6550 addrlen = sizeof(sockaddr);
6551 memset(buffer, 0, sizeof(buffer));
6552 SetLastError(0xdeadbeef);
6553 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
6554 ok(ret == bytesSent, "got %d, expected %d\n",
6555 ret, bytesSent);
6556 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6557
6558 closesocket(sock);
6559 closesocket(dst);
6560
6561 /* a bad call to WSASendMsg will also bind the socket */
6562 addrlen = sizeof(sockaddr);
6563 sockaddr.sin_port = 0;
6564 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6565 sock = socket(AF_INET, SOCK_DGRAM, 0);
6566 ok(sock != INVALID_SOCKET, "socket() failed\n");
6567 ok(pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
6568 todo_wine {
6569 ok(!getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have worked\n");
6570 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
6571 inet_ntoa(sockaddr.sin_addr));
6572 ok(sockaddr.sin_port, "sin_port should be > 0\n");
6573 }
6574 closesocket(sock);
6575
6576 /* a bad call without msg parameter will not trigger the auto-bind */
6577 sock = socket(AF_INET, SOCK_DGRAM, 0);
6578 ok(sock != INVALID_SOCKET, "socket() failed\n");
6579 ok(pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
6580 ok(getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have failed\n");
6581 err = WSAGetLastError();
6582 ok(err == WSAEINVAL, "expected 10022, got %d instead\n", err);
6583 closesocket(sock);
6584
6585 /* SOCK_STREAM sockets are not supported */
6586 bytesSent = 0;
6587 sock = socket(AF_INET, SOCK_STREAM, 0);
6588 ok(sock != INVALID_SOCKET, "socket() failed\n");
6589 SetLastError(0xdeadbeef);
6590 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
6591 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6592 err = WSAGetLastError();
6593 todo_wine
6594 ok(err == WSAEINVAL, "expected 10014, got %d instead\n", err);
6595 closesocket(sock);
6596 }
6597
6598 static void test_WSASendTo(void)
6599 {
6600 SOCKET s;
6601 struct sockaddr_in addr;
6602 char buf[12] = "hello world";
6603 WSABUF data_buf;
6604 DWORD bytesSent;
6605 int ret;
6606
6607 addr.sin_family = AF_INET;
6608 addr.sin_port = htons(139);
6609 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
6610 data_buf.len = sizeof(buf);
6611 data_buf.buf = buf;
6612
6613 if( (s = socket(AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET) {
6614 ok(0, "socket() failed error: %d\n", WSAGetLastError());
6615 return;
6616 }
6617
6618 WSASetLastError(12345);
6619 ret = WSASendTo(INVALID_SOCKET, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
6620 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
6621 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
6622
6623 WSASetLastError(12345);
6624 ret = WSASendTo(s, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
6625 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
6626 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
6627
6628 WSASetLastError(12345);
6629 if(WSASendTo(s, &data_buf, 1, &bytesSent, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL)) {
6630 ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
6631 return;
6632 }
6633 ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
6634 "a successful call to WSASendTo()\n");
6635 }
6636
6637 static DWORD WINAPI recv_thread(LPVOID arg)
6638 {
6639 SOCKET sock = *(SOCKET *)arg;
6640 char buffer[32];
6641 WSABUF wsa;
6642 WSAOVERLAPPED ov;
6643 DWORD flags = 0;
6644
6645 wsa.buf = buffer;
6646 wsa.len = sizeof(buffer);
6647 ov.hEvent = WSACreateEvent();
6648 WSARecv(sock, &wsa, 1, NULL, &flags, &ov, NULL);
6649
6650 WaitForSingleObject(ov.hEvent, 1000);
6651 WSACloseEvent(ov.hEvent);
6652 return 0;
6653 }
6654
6655 static int completion_called;
6656
6657 static void WINAPI io_completion(DWORD error, DWORD transferred, WSAOVERLAPPED *overlapped, DWORD flags)
6658 {
6659 completion_called++;
6660 }
6661
6662 static void test_WSARecv(void)
6663 {
6664 SOCKET src, dest, server = INVALID_SOCKET;
6665 char buf[20];
6666 WSABUF bufs[2];
6667 WSAOVERLAPPED ov;
6668 DWORD bytesReturned, flags, id;
6669 struct linger ling;
6670 struct sockaddr_in addr;
6671 int iret, len;
6672 DWORD dwret;
6673 BOOL bret;
6674 HANDLE thread, event = NULL, io_port;
6675
6676 tcp_socketpair(&src, &dest);
6677 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
6678 {
6679 skip("failed to create sockets\n");
6680 goto end;
6681 }
6682
6683 memset(&ov, 0, sizeof(ov));
6684 flags = 0;
6685 bufs[0].len = 2;
6686 bufs[0].buf = buf;
6687
6688 /* Send 4 bytes and receive in two calls of 2 */
6689 SetLastError(0xdeadbeef);
6690 iret = send(src, "test", 4, 0);
6691 ok(iret == 4, "Expected 4, got %d\n", iret);
6692 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6693 SetLastError(0xdeadbeef);
6694 bytesReturned = 0xdeadbeef;
6695 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
6696 ok(!iret, "Expected 0, got %d\n", iret);
6697 ok(bytesReturned == 2, "Expected 2, got %d\n", bytesReturned);
6698 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6699 SetLastError(0xdeadbeef);
6700 bytesReturned = 0xdeadbeef;
6701 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
6702 ok(!iret, "Expected 0, got %d\n", iret);
6703 ok(bytesReturned == 2, "Expected 2, got %d\n", bytesReturned);
6704 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6705
6706 bufs[0].len = 4;
6707 SetLastError(0xdeadbeef);
6708 iret = send(src, "test", 4, 0);
6709 ok(iret == 4, "Expected 4, got %d\n", iret);
6710 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6711 SetLastError(0xdeadbeef);
6712 bytesReturned = 0xdeadbeef;
6713 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
6714 ok(!iret, "Expected 0, got %d\n", iret);
6715 ok(bytesReturned == 4, "Expected 4, got %d\n", bytesReturned);
6716 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6717
6718 /* Test 2 buffers */
6719 bufs[0].len = 4;
6720 bufs[1].len = 5;
6721 bufs[1].buf = buf + 10;
6722 SetLastError(0xdeadbeef);
6723 iret = send(src, "deadbeefs", 9, 0);
6724 ok(iret == 9, "Expected 9, got %d\n", iret);
6725 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6726 SetLastError(0xdeadbeef);
6727 bytesReturned = 0xdeadbeef;
6728 iret = WSARecv(dest, bufs, 2, &bytesReturned, &flags, NULL, NULL);
6729 ok(!iret, "Expected 0, got %d\n", iret);
6730 ok(bytesReturned == 9, "Expected 9, got %d\n", bytesReturned);
6731 bufs[0].buf[4] = '\0';
6732 bufs[1].buf[5] = '\0';
6733 ok(!strcmp(bufs[0].buf, "dead"), "buf[0] doesn't match: %s != dead\n", bufs[0].buf);
6734 ok(!strcmp(bufs[1].buf, "beefs"), "buf[1] doesn't match: %s != beefs\n", bufs[1].buf);
6735 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6736
6737 bufs[0].len = sizeof(buf);
6738 ov.hEvent = event = CreateEventA(NULL, FALSE, FALSE, NULL);
6739 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
6740 if (!event)
6741 goto end;
6742
6743 ling.l_onoff = 1;
6744 ling.l_linger = 0;
6745 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
6746 ok(!iret, "Failed to set linger %d\n", GetLastError());
6747
6748 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, NULL);
6749 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
6750
6751 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, &ov, NULL);
6752 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
6753
6754 closesocket(src);
6755 src = INVALID_SOCKET;
6756
6757 dwret = WaitForSingleObject(ov.hEvent, 1000);
6758 ok(dwret == WAIT_OBJECT_0, "Waiting for disconnect event failed with %d + errno %d\n", dwret, GetLastError());
6759
6760 bret = GetOverlappedResult((HANDLE)dest, &ov, &bytesReturned, FALSE);
6761 todo_wine ok(!bret && (GetLastError() == ERROR_NETNAME_DELETED || broken(GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */),
6762 "Did not get disconnect event: %d, error %d\n", bret, GetLastError());
6763 ok(bytesReturned == 0, "Bytes received is %d\n", bytesReturned);
6764 closesocket(dest);
6765 dest = INVALID_SOCKET;
6766
6767 src = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
6768 ok(src != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6769 if (src == INVALID_SOCKET) goto end;
6770
6771 server = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
6772 ok(server != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6773 if (server == INVALID_SOCKET) goto end;
6774
6775 memset(&addr, 0, sizeof(addr));
6776 addr.sin_family = AF_INET;
6777 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
6778 iret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
6779 if (iret) goto end;
6780
6781 len = sizeof(addr);
6782 iret = getsockname(server, (struct sockaddr *)&addr, &len);
6783 if (iret) goto end;
6784
6785 iret = listen(server, 1);
6786 if (iret) goto end;
6787
6788 iret = connect(src, (struct sockaddr *)&addr, sizeof(addr));
6789 if (iret) goto end;
6790
6791 len = sizeof(addr);
6792 dest = accept(server, (struct sockaddr *)&addr, &len);
6793 ok(dest != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6794 if (dest == INVALID_SOCKET) goto end;
6795
6796 send(src, "test message", sizeof("test message"), 0);
6797 thread = CreateThread(NULL, 0, recv_thread, &dest, 0, &id);
6798 WaitForSingleObject(thread, 3000);
6799 CloseHandle(thread);
6800
6801 memset(&ov, 0, sizeof(ov));
6802 ov.hEvent = event;
6803 ResetEvent(event);
6804 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, io_completion);
6805 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
6806 send(src, "test message", sizeof("test message"), 0);
6807
6808 completion_called = 0;
6809 dwret = SleepEx(1000, TRUE);
6810 ok(dwret == WAIT_IO_COMPLETION, "got %u\n", dwret);
6811 ok(completion_called == 1, "completion not called\n");
6812
6813 dwret = WaitForSingleObject(event, 1);
6814 ok(dwret == WAIT_TIMEOUT, "got %u\n", dwret);
6815
6816 io_port = CreateIoCompletionPort( (HANDLE)dest, NULL, 0, 0 );
6817 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
6818
6819 /* Using completion function on socket associated with completion port is not allowed. */
6820 memset(&ov, 0, sizeof(ov));
6821 completion_called = 0;
6822 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, io_completion);
6823 ok(iret == SOCKET_ERROR && GetLastError() == WSAEINVAL, "WSARecv failed - %d error %d\n", iret, GetLastError());
6824 ok(!completion_called, "completion called\n");
6825
6826 CloseHandle(io_port);
6827
6828 end:
6829 if (server != INVALID_SOCKET)
6830 closesocket(server);
6831 if (dest != INVALID_SOCKET)
6832 closesocket(dest);
6833 if (src != INVALID_SOCKET)
6834 closesocket(src);
6835 if (event)
6836 WSACloseEvent(event);
6837 }
6838
6839 struct write_watch_thread_args
6840 {
6841 int func;
6842 SOCKET dest;
6843 void *base;
6844 DWORD size;
6845 const char *expect;
6846 };
6847
6848 static DWORD CALLBACK write_watch_thread( void *arg )
6849 {
6850 struct write_watch_thread_args *args = arg;
6851 struct sockaddr addr;
6852 int addr_len = sizeof(addr), ret;
6853 DWORD bytes, flags = 0;
6854 WSABUF buf[1];
6855
6856 switch (args->func)
6857 {
6858 case 0:
6859 ret = recv( args->dest, args->base, args->size, 0 );
6860 ok( ret == strlen(args->expect) + 1, "wrong len %d\n", ret );
6861 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
6862 break;
6863 case 1:
6864 ret = recvfrom( args->dest, args->base, args->size, 0, &addr, &addr_len );
6865 ok( ret == strlen(args->expect) + 1, "wrong len %d\n", ret );
6866 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
6867 break;
6868 case 2:
6869 buf[0].len = args->size;
6870 buf[0].buf = args->base;
6871 ret = WSARecv( args->dest, buf, 1, &bytes, &flags, NULL, NULL );
6872 ok( !ret, "WSARecv failed %u\n", GetLastError() );
6873 ok( bytes == strlen(args->expect) + 1, "wrong len %d\n", bytes );
6874 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
6875 break;
6876 case 3:
6877 buf[0].len = args->size;
6878 buf[0].buf = args->base;
6879 ret = WSARecvFrom( args->dest, buf, 1, &bytes, &flags, &addr, &addr_len, NULL, NULL );
6880 ok( !ret, "WSARecvFrom failed %u\n", GetLastError() );
6881 ok( bytes == strlen(args->expect) + 1, "wrong len %d\n", bytes );
6882 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
6883 break;
6884 }
6885 return 0;
6886 }
6887
6888 static void test_write_watch(void)
6889 {
6890 SOCKET src, dest;
6891 WSABUF bufs[2];
6892 WSAOVERLAPPED ov;
6893 struct write_watch_thread_args args;
6894 DWORD bytesReturned, flags, size;
6895 struct sockaddr addr;
6896 int addr_len, ret;
6897 HANDLE thread, event;
6898 char *base;
6899 void *results[64];
6900 ULONG_PTR count;
6901 ULONG pagesize;
6902 UINT (WINAPI *pGetWriteWatch)(DWORD,LPVOID,SIZE_T,LPVOID*,ULONG_PTR*,ULONG*);
6903
6904 pGetWriteWatch = (void *)GetProcAddress( GetModuleHandleA("kernel32.dll"), "GetWriteWatch" );
6905 if (!pGetWriteWatch)
6906 {
6907 win_skip( "write watched not supported\n" );
6908 return;
6909 }
6910
6911 tcp_socketpair(&src, &dest);
6912 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
6913 {
6914 skip("failed to create sockets\n");
6915 return;
6916 }
6917
6918 memset(&ov, 0, sizeof(ov));
6919 ov.hEvent = event = CreateEventA(NULL, FALSE, FALSE, NULL);
6920 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
6921
6922 flags = 0;
6923
6924 size = 0x10000;
6925 base = VirtualAlloc( 0, size, MEM_RESERVE | MEM_COMMIT | MEM_WRITE_WATCH, PAGE_READWRITE );
6926 ok( base != NULL, "VirtualAlloc failed %u\n", GetLastError() );
6927
6928 memset( base, 0, size );
6929 count = 64;
6930 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
6931 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
6932 ok( count == 16, "wrong count %lu\n", count );
6933
6934 bufs[0].len = 5;
6935 bufs[0].buf = base;
6936 bufs[1].len = 0x8000;
6937 bufs[1].buf = base + 0x4000;
6938
6939 ret = WSARecv( dest, bufs, 2, NULL, &flags, &ov, NULL);
6940 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
6941 "WSARecv failed - %d error %d\n", ret, GetLastError());
6942
6943 count = 64;
6944 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
6945 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
6946 ok( count == 9, "wrong count %lu\n", count );
6947 ok( !base[0], "data set\n" );
6948
6949 send(src, "test message", sizeof("test message"), 0);
6950
6951 ret = GetOverlappedResult( (HANDLE)dest, &ov, &bytesReturned, TRUE );
6952 ok( ret, "GetOverlappedResult failed %u\n", GetLastError() );
6953 ok( bytesReturned == sizeof("test message"), "wrong size %u\n", bytesReturned );
6954 ok( !memcmp( base, "test ", 5 ), "wrong data %s\n", base );
6955 ok( !memcmp( base + 0x4000, "message", 8 ), "wrong data %s\n", base + 0x4000 );
6956
6957 count = 64;
6958 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
6959 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
6960 ok( count == 0, "wrong count %lu\n", count );
6961
6962 memset( base, 0, size );
6963 count = 64;
6964 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
6965 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
6966 ok( count == 16, "wrong count %lu\n", count );
6967
6968 bufs[1].len = 0x4000;
6969 bufs[1].buf = base + 0x2000;
6970 ret = WSARecvFrom( dest, bufs, 2, NULL, &flags, &addr, &addr_len, &ov, NULL);
6971 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
6972 "WSARecv failed - %d error %d\n", ret, GetLastError());
6973
6974 count = 64;
6975 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
6976 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
6977 ok( count == 5, "wrong count %lu\n", count );
6978 ok( !base[0], "data set\n" );
6979
6980 send(src, "test message", sizeof("test message"), 0);
6981
6982 ret = GetOverlappedResult( (HANDLE)dest, &ov, &bytesReturned, TRUE );
6983 ok( ret, "GetOverlappedResult failed %u\n", GetLastError() );
6984 ok( bytesReturned == sizeof("test message"), "wrong size %u\n", bytesReturned );
6985 ok( !memcmp( base, "test ", 5 ), "wrong data %s\n", base );
6986 ok( !memcmp( base + 0x2000, "message", 8 ), "wrong data %s\n", base + 0x2000 );
6987
6988 count = 64;
6989 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
6990 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
6991 ok( count == 0, "wrong count %lu\n", count );
6992
6993 memset( base, 0, size );
6994 count = 64;
6995 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
6996 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
6997 ok( count == 16, "wrong count %lu\n", count );
6998
6999 args.dest = dest;
7000 args.base = base;
7001 args.size = 0x7002;
7002 args.expect = "test message";
7003 for (args.func = 0; args.func < 4; args.func++)
7004 {
7005 thread = CreateThread( NULL, 0, write_watch_thread, &args, 0, NULL );
7006 Sleep( 200 );
7007
7008 count = 64;
7009 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7010 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
7011 ok( count == 8, "wrong count %lu\n", count );
7012
7013 send(src, "test message", sizeof("test message"), 0);
7014 WaitForSingleObject( thread, 10000 );
7015 CloseHandle( thread );
7016
7017 count = 64;
7018 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7019 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
7020 ok( count == 0, "wrong count %lu\n", count );
7021 }
7022 WSACloseEvent( event );
7023 closesocket( dest );
7024 closesocket( src );
7025 VirtualFree( base, 0, MEM_FREE );
7026 }
7027
7028 #define POLL_CLEAR() ix = 0
7029 #define POLL_SET(s, ev) {fds[ix].fd = s; fds[ix++].events = ev;}
7030 #define POLL_ISSET(s, rev) poll_isset(fds, ix, s, rev)
7031 static BOOL poll_isset(WSAPOLLFD *fds, int max, SOCKET s, int rev)
7032 {
7033 int k;
7034 for (k = 0; k < max; k++)
7035 if (fds[k].fd == s && (fds[k].revents == rev)) return TRUE;
7036 return FALSE;
7037 }
7038
7039 static void test_WSAPoll(void)
7040 {
7041 int ix, ret, err, poll_timeout;
7042 SOCKET fdListen, fdRead, fdWrite;
7043 struct sockaddr_in address;
7044 socklen_t len;
7045 static char tmp_buf[1024];
7046 WSAPOLLFD fds[16];
7047 HANDLE thread_handle;
7048 DWORD id;
7049
7050 if (!pWSAPoll) /* >= Vista */
7051 {
7052 skip("WSAPoll is unsupported, some tests will be skipped.\n");
7053 return;
7054 }
7055
7056 /* Invalid parameters test */
7057 SetLastError(0xdeadbeef);
7058 ret = pWSAPoll(NULL, 0, 0);
7059 err = GetLastError();
7060 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7061 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
7062 SetLastError(0xdeadbeef);
7063 ret = pWSAPoll(NULL, 1, 0);
7064 err = GetLastError();
7065 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7066 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
7067 SetLastError(0xdeadbeef);
7068 ret = pWSAPoll(NULL, 0, 1);
7069 err = GetLastError();
7070 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7071 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
7072 SetLastError(0xdeadbeef);
7073 ret = pWSAPoll(NULL, 1, 1);
7074 err = GetLastError();
7075 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7076 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
7077
7078 /* WSAPoll() tries to mime the unix poll() call. The following tests do:
7079 * - check if a connection attempt ended with success or error;
7080 * - check if a pending connection is waiting for acceptance;
7081 * - check for data to read, availability for write and OOB data
7082 */
7083 memset(&address, 0, sizeof(address));
7084 address.sin_addr.s_addr = inet_addr("127.0.0.1");
7085 address.sin_family = AF_INET;
7086 len = sizeof(address);
7087 fdListen = setup_server_socket(&address, &len);
7088 poll_timeout = 100;
7089
7090 /* When no events are pending poll returns 0 with no error */
7091 POLL_CLEAR();
7092 POLL_SET(fdListen, POLLIN);
7093 ret = pWSAPoll(fds, ix, poll_timeout);
7094 ok(ret == 0, "expected 0, got %d\n", ret);
7095
7096 /* Test listening socket connection attempt notifications */
7097 fdWrite = setup_connector_socket(&address, len, TRUE);
7098 POLL_CLEAR();
7099 POLL_SET(fdListen, POLLIN | POLLOUT);
7100 ret = pWSAPoll(fds, ix, poll_timeout);
7101 ok(ret == 1, "expected 1, got %d\n", ret);
7102 ok(POLL_ISSET(fdListen, POLLRDNORM), "fdListen socket events incorrect\n");
7103 len = sizeof(address);
7104 fdRead = accept(fdListen, (struct sockaddr*) &address, &len);
7105 ok(fdRead != INVALID_SOCKET, "expected a valid socket\n");
7106
7107 /* Test client side connection attempt notifications */
7108 POLL_CLEAR();
7109 POLL_SET(fdListen, POLLIN | POLLOUT);
7110 POLL_SET(fdRead, POLLIN | POLLOUT);
7111 POLL_SET(fdWrite, POLLIN | POLLOUT);
7112 ret = pWSAPoll(fds, ix, poll_timeout);
7113 ok(ret == 2, "expected 2, got %d\n", ret);
7114 ok(POLL_ISSET(fdWrite, POLLWRNORM), "fdWrite socket events incorrect\n");
7115 ok(POLL_ISSET(fdRead, POLLWRNORM), "fdRead socket events incorrect\n");
7116 len = sizeof(id);
7117 id = 0xdeadbeef;
7118 err = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
7119 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
7120 ok(id == 0, "expected 0, got %d\n", id);
7121
7122 /* Test data receiving notifications */
7123 ret = send(fdWrite, "1234", 4, 0);
7124 ok(ret == 4, "expected 4, got %d\n", ret);
7125 POLL_CLEAR();
7126 POLL_SET(fdListen, POLLIN | POLLOUT);
7127 POLL_SET(fdRead, POLLIN);
7128 ret = pWSAPoll(fds, ix, poll_timeout);
7129 ok(ret == 1, "expected 1, got %d\n", ret);
7130 ok(POLL_ISSET(fdRead, POLLRDNORM), "fdRead socket events incorrect\n");
7131 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
7132 ok(ret == 4, "expected 4, got %d\n", ret);
7133 ok(!strcmp(tmp_buf, "1234"), "data received differs from sent\n");
7134
7135 /* Test OOB data notifications */
7136 ret = send(fdWrite, "A", 1, MSG_OOB);
7137 ok(ret == 1, "expected 1, got %d\n", ret);
7138 POLL_CLEAR();
7139 POLL_SET(fdListen, POLLIN | POLLOUT);
7140 POLL_SET(fdRead, POLLIN);
7141 ret = pWSAPoll(fds, ix, poll_timeout);
7142 ok(ret == 1, "expected 1, got %d\n", ret);
7143 ok(POLL_ISSET(fdRead, POLLRDBAND), "fdRead socket events incorrect\n");
7144 tmp_buf[0] = 0xAF;
7145 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
7146 ok(ret == 1, "expected 1, got %d\n", ret);
7147 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
7148
7149 /* If the socket is OOBINLINED the notification is like normal data */
7150 ret = 1;
7151 ret = setsockopt(fdRead, SOL_SOCKET, SO_OOBINLINE, (char*) &ret, sizeof(ret));
7152 ok(ret == 0, "expected 0, got %d\n", ret);
7153 ret = send(fdWrite, "A", 1, MSG_OOB);
7154 ok(ret == 1, "expected 1, got %d\n", ret);
7155 POLL_CLEAR();
7156 POLL_SET(fdListen, POLLIN | POLLOUT);
7157 POLL_SET(fdRead, POLLIN | POLLOUT);
7158 ret = pWSAPoll(fds, ix, poll_timeout);
7159 ok(ret == 1, "expected 1, got %d\n", ret);
7160 tmp_buf[0] = 0xAF;
7161 SetLastError(0xdeadbeef);
7162 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
7163 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7164 ok(GetLastError() == WSAEINVAL, "expected 10022, got %d\n", GetLastError());
7165 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
7166 ok(ret == 1, "expected 1, got %d\n", ret);
7167 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
7168
7169 /* Test connection closed notifications */
7170 ret = closesocket(fdRead);
7171 ok(ret == 0, "expected 0, got %d\n", ret);
7172 POLL_CLEAR();
7173 POLL_SET(fdListen, POLLIN | POLLOUT);
7174 POLL_SET(fdWrite, POLLIN);
7175 ret = pWSAPoll(fds, ix, poll_timeout);
7176 ok(ret == 1, "expected 1, got %d\n", ret);
7177 ok(POLL_ISSET(fdWrite, POLLHUP), "fdWrite socket events incorrect\n");
7178 ret = recv(fdWrite, tmp_buf, sizeof(tmp_buf), 0);
7179 ok(ret == 0, "expected 0, got %d\n", ret);
7180
7181 /* When a connection is attempted to a non-listening socket due to a bug
7182 * in the MS code it will never be notified. This is a long standing issue
7183 * that will never be fixed for compatibility reasons so we have to deal
7184 * with it manually. */
7185 ret = closesocket(fdWrite);
7186 ok(ret == 0, "expected 0, got %d\n", ret);
7187 ret = closesocket(fdListen);
7188 ok(ret == 0, "expected 0, got %d\n", ret);
7189 len = sizeof(address);
7190 fdWrite = setup_connector_socket(&address, len, TRUE);
7191 POLL_CLEAR();
7192 POLL_SET(fdWrite, POLLIN | POLLOUT);
7193 poll_timeout = 2000;
7194 ret = pWSAPoll(fds, ix, poll_timeout);
7195 todo_wine
7196 ok(ret == 0, "expected 0, got %d\n", ret);
7197 len = sizeof(id);
7198 id = 0xdeadbeef;
7199 err = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
7200 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
7201 ok(id == WSAECONNREFUSED, "expected 10061, got %d\n", id);
7202 closesocket(fdWrite);
7203
7204 /* Try poll() on a closed socket after connection */
7205 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
7206 closesocket(fdRead);
7207 POLL_CLEAR();
7208 POLL_SET(fdWrite, POLLIN | POLLOUT);
7209 POLL_SET(fdRead, POLLIN | POLLOUT);
7210 ret = pWSAPoll(fds, ix, poll_timeout);
7211 ok(ret == 1, "expected 1, got %d\n", ret);
7212 ok(POLL_ISSET(fdRead, POLLNVAL), "fdRead socket events incorrect\n");
7213 POLL_CLEAR();
7214 POLL_SET(fdWrite, POLLIN | POLLOUT);
7215 ret = pWSAPoll(fds, ix, poll_timeout);
7216 ok(ret == 1, "expected 1, got %d\n", ret);
7217 todo_wine
7218 ok(POLL_ISSET(fdWrite, POLLWRNORM | POLLHUP) || broken(POLL_ISSET(fdWrite, POLLWRNORM)) /* <= 2008 */,
7219 "fdWrite socket events incorrect\n");
7220 closesocket(fdWrite);
7221
7222 /* Close the socket currently being polled in a thread */
7223 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
7224 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
7225 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
7226 POLL_CLEAR();
7227 POLL_SET(fdWrite, POLLIN | POLLOUT);
7228 ret = pWSAPoll(fds, ix, poll_timeout);
7229 ok(ret == 1, "expected 1, got %d\n", ret);
7230 ok(POLL_ISSET(fdWrite, POLLWRNORM), "fdWrite socket events incorrect\n");
7231 WaitForSingleObject (thread_handle, 1000);
7232 closesocket(fdRead);
7233 /* test again with less flags - behavior changes */
7234 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
7235 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
7236 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
7237 POLL_CLEAR();
7238 POLL_SET(fdWrite, POLLIN);
7239 ret = pWSAPoll(fds, ix, poll_timeout);
7240 ok(ret == 1, "expected 1, got %d\n", ret);
7241 ok(POLL_ISSET(fdWrite, POLLNVAL), "fdWrite socket events incorrect\n");
7242 WaitForSingleObject (thread_handle, 1000);
7243 closesocket(fdRead);
7244 }
7245 #undef POLL_SET
7246 #undef POLL_ISSET
7247 #undef POLL_CLEAR
7248
7249 static void test_GetAddrInfoW(void)
7250 {
7251 static const WCHAR port[] = {'8','0',0};
7252 static const WCHAR empty[] = {0};
7253 static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0};
7254 static const WCHAR nxdomain[] =
7255 {'n','x','d','o','m','a','i','n','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',0};
7256 static const WCHAR zero[] = {'0',0};
7257 int i, ret;
7258 ADDRINFOW *result, *result2, *p, hint;
7259 WCHAR name[256];
7260 DWORD size = ARRAY_SIZE(name);
7261 /* te su to.winehq.org written in katakana */
7262 static const WCHAR idn_domain[] =
7263 {0x30C6,0x30B9,0x30C8,'.','w','i','n','e','h','q','.','o','r','g',0};
7264 static const WCHAR idn_punycode[] =
7265 {'x','n','-','-','z','c','k','z','a','h','.','w','i','n','e','h','q','.','o','r','g',0};
7266
7267 if (!pGetAddrInfoW || !pFreeAddrInfoW)
7268 {
7269 win_skip("GetAddrInfoW and/or FreeAddrInfoW not present\n");
7270 return;
7271 }
7272 memset(&hint, 0, sizeof(ADDRINFOW));
7273 name[0] = 0;
7274 GetComputerNameExW( ComputerNamePhysicalDnsHostname, name, &size );
7275
7276 result = (ADDRINFOW *)0xdeadbeef;
7277 WSASetLastError(0xdeadbeef);
7278 ret = pGetAddrInfoW(NULL, NULL, NULL, &result);
7279 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7280 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7281 ok(result == NULL, "got %p\n", result);
7282
7283 result = NULL;
7284 WSASetLastError(0xdeadbeef);
7285 ret = pGetAddrInfoW(empty, NULL, NULL, &result);
7286 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7287 ok(result != NULL, "GetAddrInfoW failed\n");
7288 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7289 pFreeAddrInfoW(result);
7290
7291 result = NULL;
7292 ret = pGetAddrInfoW(NULL, zero, NULL, &result);
7293 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7294 ok(result != NULL, "GetAddrInfoW failed\n");
7295
7296 result2 = NULL;
7297 ret = pGetAddrInfoW(NULL, empty, NULL, &result2);
7298 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7299 ok(result2 != NULL, "GetAddrInfoW failed\n");
7300 compare_addrinfow(result, result2);
7301 pFreeAddrInfoW(result);
7302 pFreeAddrInfoW(result2);
7303
7304 result = NULL;
7305 ret = pGetAddrInfoW(empty, zero, NULL, &result);
7306 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7307 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7308 ok(result != NULL, "GetAddrInfoW failed\n");
7309
7310 result2 = NULL;
7311 ret = pGetAddrInfoW(empty, empty, NULL, &result2);
7312 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7313 ok(result2 != NULL, "GetAddrInfoW failed\n");
7314 compare_addrinfow(result, result2);
7315 pFreeAddrInfoW(result);
7316 pFreeAddrInfoW(result2);
7317
7318 result = NULL;
7319 ret = pGetAddrInfoW(localhost, NULL, NULL, &result);
7320 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7321 pFreeAddrInfoW(result);
7322
7323 result = NULL;
7324 ret = pGetAddrInfoW(localhost, empty, NULL, &result);
7325 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7326 pFreeAddrInfoW(result);
7327
7328 result = NULL;
7329 ret = pGetAddrInfoW(localhost, zero, NULL, &result);
7330 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7331 pFreeAddrInfoW(result);
7332
7333 result = NULL;
7334 ret = pGetAddrInfoW(localhost, port, NULL, &result);
7335 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7336 pFreeAddrInfoW(result);
7337
7338 result = NULL;
7339 ret = pGetAddrInfoW(localhost, NULL, &hint, &result);
7340 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7341 pFreeAddrInfoW(result);
7342
7343 result = NULL;
7344 SetLastError(0xdeadbeef);
7345 ret = pGetAddrInfoW(localhost, port, &hint, &result);
7346 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7347 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7348 pFreeAddrInfoW(result);
7349
7350 /* try to get information from the computer name, result is the same
7351 * as if requesting with an empty host name. */
7352 ret = pGetAddrInfoW(name, NULL, NULL, &result);
7353 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7354 ok(result != NULL, "GetAddrInfoW failed\n");
7355
7356 ret = pGetAddrInfoW(empty, NULL, NULL, &result2);
7357 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7358 ok(result != NULL, "GetAddrInfoW failed\n");
7359 compare_addrinfow(result, result2);
7360 pFreeAddrInfoW(result);
7361 pFreeAddrInfoW(result2);
7362
7363 ret = pGetAddrInfoW(name, empty, NULL, &result);
7364 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7365 ok(result != NULL, "GetAddrInfoW failed\n");
7366
7367 ret = pGetAddrInfoW(empty, empty, NULL, &result2);
7368 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7369 ok(result != NULL, "GetAddrInfoW failed\n");
7370 compare_addrinfow(result, result2);
7371 pFreeAddrInfoW(result);
7372 pFreeAddrInfoW(result2);
7373
7374 result = (ADDRINFOW *)0xdeadbeef;
7375 WSASetLastError(0xdeadbeef);
7376 ret = pGetAddrInfoW(NULL, NULL, NULL, &result);
7377 if(ret == 0)
7378 {
7379 skip("nxdomain returned success. Broken ISP redirects?\n");
7380 return;
7381 }
7382 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7383 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7384 ok(result == NULL, "got %p\n", result);
7385
7386 result = (ADDRINFOW *)0xdeadbeef;
7387 WSASetLastError(0xdeadbeef);
7388 ret = pGetAddrInfoW(nxdomain, NULL, NULL, &result);
7389 if(ret == 0)
7390 {
7391 skip("nxdomain returned success. Broken ISP redirects?\n");
7392 return;
7393 }
7394 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7395 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7396 ok(result == NULL, "got %p\n", result);
7397
7398 for (i = 0;i < (ARRAY_SIZE(hinttests));i++)
7399 {
7400 hint.ai_family = hinttests[i].family;
7401 hint.ai_socktype = hinttests[i].socktype;
7402 hint.ai_protocol = hinttests[i].protocol;
7403
7404 result = NULL;
7405 SetLastError(0xdeadbeef);
7406 ret = pGetAddrInfoW(localhost, NULL, &hint, &result);
7407 if (!ret)
7408 {
7409 if (hinttests[i].error)
7410 ok(0, "test %d: GetAddrInfoW succeeded unexpectedly\n", i);
7411 else
7412 {
7413 p = result;
7414 do
7415 {
7416 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
7417 if (hinttests[i].family == AF_UNSPEC)
7418 ok(p->ai_family == AF_INET || p->ai_family == AF_INET6,
7419 "test %d: expected AF_INET or AF_INET6, got %d\n",
7420 i, p->ai_family);
7421 else
7422 ok(p->ai_family == hinttests[i].family,
7423 "test %d: expected family %d, got %d\n",
7424 i, hinttests[i].family, p->ai_family);
7425
7426 ok(p->ai_socktype == hinttests[i].socktype,
7427 "test %d: expected type %d, got %d\n",
7428 i, hinttests[i].socktype, p->ai_socktype);
7429 ok(p->ai_protocol == hinttests[i].protocol,
7430 "test %d: expected protocol %d, got %d\n",
7431 i, hinttests[i].protocol, p->ai_protocol);
7432 p = p->ai_next;
7433 }
7434 while (p);
7435 }
7436 pFreeAddrInfoW(result);
7437 }
7438 else
7439 {
7440 DWORD err = WSAGetLastError();
7441 if (hinttests[i].error)
7442 ok(hinttests[i].error == err, "test %d: GetAddrInfoW failed with error %d, expected %d\n",
7443 i, err, hinttests[i].error);
7444 else
7445 ok(0, "test %d: GetAddrInfoW failed with %d (err %d)\n", i, ret, err);
7446 }
7447 }
7448
7449 /* Test IDN resolution (Internationalized Domain Names) present since Windows 8 */
7450 trace("Testing punycode IDN %s\n", wine_dbgstr_w(idn_punycode));
7451 result = NULL;
7452 ret = pGetAddrInfoW(idn_punycode, NULL, NULL, &result);
7453 ok(!ret, "got %d expected success\n", ret);
7454 ok(result != NULL, "got %p\n", result);
7455 pFreeAddrInfoW(result);
7456
7457 hint.ai_family = AF_INET;
7458 hint.ai_socktype = 0;
7459 hint.ai_protocol = 0;
7460 hint.ai_flags = 0;
7461
7462 result = NULL;
7463 ret = pGetAddrInfoW(idn_punycode, NULL, &hint, &result);
7464 ok(!ret, "got %d expected success\n", ret);
7465 ok(result != NULL, "got %p\n", result);
7466
7467 trace("Testing unicode IDN %s\n", wine_dbgstr_w(idn_domain));
7468 result2 = NULL;
7469 ret = pGetAddrInfoW(idn_domain, NULL, NULL, &result2);
7470 if (ret == WSAHOST_NOT_FOUND && broken(1))
7471 {
7472 pFreeAddrInfoW(result);
7473 win_skip("IDN resolution not supported in Win <= 7\n");
7474 return;
7475 }
7476
7477 ok(!ret, "got %d expected success\n", ret);
7478 ok(result2 != NULL, "got %p\n", result2);
7479 pFreeAddrInfoW(result2);
7480
7481 hint.ai_family = AF_INET;
7482 hint.ai_socktype = 0;
7483 hint.ai_protocol = 0;
7484 hint.ai_flags = 0;
7485
7486 result2 = NULL;
7487 ret = pGetAddrInfoW(idn_domain, NULL, &hint, &result2);
7488 ok(!ret, "got %d expected success\n", ret);
7489 ok(result2 != NULL, "got %p\n", result2);
7490
7491 /* ensure manually resolved punycode and unicode hosts result in same data */
7492 compare_addrinfow(result, result2);
7493
7494 pFreeAddrInfoW(result);
7495 pFreeAddrInfoW(result2);
7496
7497 hint.ai_family = AF_INET;
7498 hint.ai_socktype = 0;
7499 hint.ai_protocol = 0;
7500 hint.ai_flags = 0;
7501
7502 result2 = NULL;
7503 ret = pGetAddrInfoW(idn_domain, NULL, &hint, &result2);
7504 ok(!ret, "got %d expected success\n", ret);
7505 ok(result2 != NULL, "got %p\n", result2);
7506 pFreeAddrInfoW(result2);
7507
7508 /* Disable IDN resolution and test again*/
7509 hint.ai_family = AF_INET;
7510 hint.ai_socktype = 0;
7511 hint.ai_protocol = 0;
7512 hint.ai_flags = AI_DISABLE_IDN_ENCODING;
7513
7514 SetLastError(0xdeadbeef);
7515 result2 = NULL;
7516 ret = pGetAddrInfoW(idn_domain, NULL, &hint, &result2);
7517 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7518 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7519 ok(result2 == NULL, "got %p\n", result2);
7520 }
7521
7522 static struct completion_routine_test
7523 {
7524 WSAOVERLAPPED *overlapped;
7525 DWORD error;
7526 ADDRINFOEXW **result;
7527 HANDLE event;
7528 DWORD called;
7529 } completion_routine_test;
7530
7531 static void CALLBACK completion_routine(DWORD error, DWORD byte_count, WSAOVERLAPPED *overlapped)
7532 {
7533 struct completion_routine_test *test = &completion_routine_test;
7534
7535 ok(error == test->error, "got %u\n", error);
7536 ok(!byte_count, "got %u\n", byte_count);
7537 ok(overlapped == test->overlapped, "got %p\n", overlapped);
7538 ok(overlapped->Internal == test->error, "got %lu\n", overlapped->Internal);
7539 ok(overlapped->Pointer == test->result, "got %p\n", overlapped->Pointer);
7540 ok(overlapped->hEvent == NULL, "got %p\n", overlapped->hEvent);
7541
7542 test->called++;
7543 SetEvent(test->event);
7544 }
7545
7546 static void test_GetAddrInfoExW(void)
7547 {
7548 static const WCHAR empty[] = {0};
7549 static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0};
7550 static const WCHAR winehq[] = {'t','e','s','t','.','w','i','n','e','h','q','.','o','r','g',0};
7551 static const WCHAR nxdomain[] = {'n','x','d','o','m','a','i','n','.','w','i','n','e','h','q','.','o','r','g',0};
7552 ADDRINFOEXW *result;
7553 OVERLAPPED overlapped;
7554 HANDLE event;
7555 int ret;
7556
7557 if (!pGetAddrInfoExW || !pGetAddrInfoExOverlappedResult)
7558 {
7559 win_skip("GetAddrInfoExW and/or GetAddrInfoExOverlappedResult not present\n");
7560 return;
7561 }
7562
7563 event = WSACreateEvent();
7564
7565 result = (ADDRINFOEXW *)0xdeadbeef;
7566 WSASetLastError(0xdeadbeef);
7567 ret = pGetAddrInfoExW(NULL, NULL, NS_DNS, NULL, NULL, &result, NULL, NULL, NULL, NULL);
7568 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7569 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7570 ok(result == NULL, "got %p\n", result);
7571
7572 result = NULL;
7573 WSASetLastError(0xdeadbeef);
7574 ret = pGetAddrInfoExW(empty, NULL, NS_DNS, NULL, NULL, &result, NULL, NULL, NULL, NULL);
7575 ok(!ret, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7576 ok(result != NULL, "GetAddrInfoW failed\n");
7577 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7578 pFreeAddrInfoExW(result);
7579
7580 result = NULL;
7581 ret = pGetAddrInfoExW(localhost, NULL, NS_DNS, NULL, NULL, &result, NULL, NULL, NULL, NULL);
7582 ok(!ret, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7583 pFreeAddrInfoExW(result);
7584
7585 result = (void*)0xdeadbeef;
7586 memset(&overlapped, 0xcc, sizeof(overlapped));
7587 overlapped.hEvent = event;
7588 ResetEvent(event);
7589 ret = pGetAddrInfoExW(localhost, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, NULL, NULL);
7590 ok(ret == ERROR_IO_PENDING, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7591 ok(!result, "result != NULL\n");
7592 ok(WaitForSingleObject(event, 1000) == WAIT_OBJECT_0, "wait failed\n");
7593 ret = pGetAddrInfoExOverlappedResult(&overlapped);
7594 ok(!ret, "overlapped result is %d\n", ret);
7595 pFreeAddrInfoExW(result);
7596
7597 result = (void*)0xdeadbeef;
7598 memset(&overlapped, 0xcc, sizeof(overlapped));
7599 ResetEvent(event);
7600 overlapped.hEvent = event;
7601 WSASetLastError(0xdeadbeef);
7602 ret = pGetAddrInfoExW(winehq, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, NULL, NULL);
7603 ok(ret == ERROR_IO_PENDING, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7604 ok(WSAGetLastError() == ERROR_IO_PENDING, "expected 11001, got %d\n", WSAGetLastError());
7605 ret = overlapped.Internal;
7606 ok(ret == WSAEINPROGRESS || ret == ERROR_SUCCESS, "overlapped.Internal = %u\n", ret);
7607 ok(WaitForSingleObject(event, 1000) == WAIT_OBJECT_0, "wait failed\n");
7608 ret = pGetAddrInfoExOverlappedResult(&overlapped);
7609 ok(!ret, "overlapped result is %d\n", ret);
7610 ok(overlapped.hEvent == event, "hEvent changed %p\n", overlapped.hEvent);
7611 ok(overlapped.Internal == ERROR_SUCCESS, "overlapped.Internal = %lx\n", overlapped.Internal);
7612 ok(overlapped.Pointer == &result, "overlapped.Pointer != &result\n");
7613 ok(result != NULL, "result == NULL\n");
7614 if (result != NULL)
7615 {
7616 ok(!result->ai_blob, "ai_blob != NULL\n");
7617 ok(!result->ai_bloblen, "ai_bloblen != 0\n");
7618 ok(!result->ai_provider, "ai_provider = %s\n", wine_dbgstr_guid(result->ai_provider));
7619 pFreeAddrInfoExW(result);
7620 }
7621
7622 result = (void*)0xdeadbeef;
7623 memset(&overlapped, 0xcc, sizeof(overlapped));
7624 ResetEvent(event);
7625 overlapped.hEvent = event;
7626 ret = pGetAddrInfoExW(NULL, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, NULL, NULL);
7627 todo_wine
7628 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7629 todo_wine
7630 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7631 ok(result == NULL, "got %p\n", result);
7632 ret = WaitForSingleObject(event, 0);
7633 todo_wine_if(ret != WAIT_TIMEOUT) /* Remove when abowe todo_wines are fixed */
7634 ok(ret == WAIT_TIMEOUT, "wait failed\n");
7635
7636 /* event + completion routine */
7637 result = (void*)0xdeadbeef;
7638 memset(&overlapped, 0xcc, sizeof(overlapped));
7639 overlapped.hEvent = event;
7640 ResetEvent(event);
7641 ret = pGetAddrInfoExW(localhost, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, completion_routine, NULL);
7642 ok(ret == WSAEINVAL, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7643
7644 /* completion routine, existing domain */
7645 result = (void *)0xdeadbeef;
7646 overlapped.hEvent = NULL;
7647 completion_routine_test.overlapped = &overlapped;
7648 completion_routine_test.error = ERROR_SUCCESS;
7649 completion_routine_test.result = &result;
7650 completion_routine_test.event = event;
7651 completion_routine_test.called = 0;
7652 ResetEvent(event);
7653 ret = pGetAddrInfoExW(winehq, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, completion_routine, NULL);
7654 ok(ret == ERROR_IO_PENDING, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7655 ok(!result, "result != NULL\n");
7656 ok(WaitForSingleObject(event, 1000) == WAIT_OBJECT_0, "wait failed\n");
7657 ret = pGetAddrInfoExOverlappedResult(&overlapped);
7658 ok(!ret, "overlapped result is %d\n", ret);
7659 ok(overlapped.hEvent == NULL, "hEvent changed %p\n", overlapped.hEvent);
7660 ok(overlapped.Internal == ERROR_SUCCESS, "overlapped.Internal = %lx\n", overlapped.Internal);
7661 ok(overlapped.Pointer == &result, "overlapped.Pointer != &result\n");
7662 ok(completion_routine_test.called == 1, "got %u\n", completion_routine_test.called);
7663 pFreeAddrInfoExW(result);
7664
7665 /* completion routine, non-existing domain */
7666 result = (void *)0xdeadbeef;
7667 completion_routine_test.overlapped = &overlapped;
7668 completion_routine_test.error = WSAHOST_NOT_FOUND;
7669 completion_routine_test.called = 0;
7670 ResetEvent(event);
7671 ret = pGetAddrInfoExW(nxdomain, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, completion_routine, NULL);
7672 ok(ret == ERROR_IO_PENDING, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7673 ok(!result, "result != NULL\n");
7674 ok(WaitForSingleObject(event, 1000) == WAIT_OBJECT_0, "wait failed\n");
7675 ret = pGetAddrInfoExOverlappedResult(&overlapped);
7676 ok(ret == WSAHOST_NOT_FOUND, "overlapped result is %d\n", ret);
7677 ok(overlapped.hEvent == NULL, "hEvent changed %p\n", overlapped.hEvent);
7678 ok(overlapped.Internal == WSAHOST_NOT_FOUND, "overlapped.Internal = %lx\n", overlapped.Internal);
7679 ok(overlapped.Pointer == &result, "overlapped.Pointer != &result\n");
7680 ok(completion_routine_test.called == 1, "got %u\n", completion_routine_test.called);
7681 ok(result == NULL, "got %p\n", result);
7682
7683 WSACloseEvent(event);
7684 }
7685
7686 static void verify_ipv6_addrinfo(ADDRINFOA *result, const char *expectedIp)
7687 {
7688 SOCKADDR_IN6 *sockaddr6;
7689 char ipBuffer[256];
7690 const char *ret;
7691
7692 ok(result->ai_family == AF_INET6, "ai_family == %d\n", result->ai_family);
7693 ok(result->ai_addrlen >= sizeof(struct sockaddr_in6), "ai_addrlen == %d\n", (int)result->ai_addrlen);
7694 ok(result->ai_addr != NULL, "ai_addr == NULL\n");
7695
7696 if (result->ai_addr != NULL)
7697 {
7698 sockaddr6 = (SOCKADDR_IN6 *)result->ai_addr;
7699 ok(sockaddr6->sin6_family == AF_INET6, "ai_addr->sin6_family == %d\n", sockaddr6->sin6_family);
7700 ok(sockaddr6->sin6_port == 0, "ai_addr->sin6_port == %d\n", sockaddr6->sin6_port);
7701
7702 ZeroMemory(ipBuffer, sizeof(ipBuffer));
7703 ret = pInetNtop(AF_INET6, &sockaddr6->sin6_addr, ipBuffer, sizeof(ipBuffer));
7704 ok(ret != NULL, "inet_ntop failed (%d)\n", WSAGetLastError());
7705 ok(strcmp(ipBuffer, expectedIp) == 0, "ai_addr->sin6_addr == '%s' (expected '%s')\n", ipBuffer, expectedIp);
7706 }
7707 }
7708
7709 static void test_getaddrinfo(void)
7710 {
7711 int i, ret;
7712 ADDRINFOA *result, *result2, *p, hint;
7713 SOCKADDR_IN *sockaddr;
7714 CHAR name[256], *ip;
7715 DWORD size = sizeof(name);
7716
7717 if (!pgetaddrinfo || !pfreeaddrinfo)
7718 {
7719 win_skip("getaddrinfo and/or freeaddrinfo not present\n");
7720 return;
7721 }
7722 memset(&hint, 0, sizeof(ADDRINFOA));
7723 GetComputerNameExA( ComputerNamePhysicalDnsHostname, name, &size );
7724
7725 result = (ADDRINFOA *)0xdeadbeef;
7726 WSASetLastError(0xdeadbeef);
7727 ret = pgetaddrinfo(NULL, NULL, NULL, &result);
7728 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7729 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7730 ok(result == NULL, "got %p\n", result);
7731
7732 result = NULL;
7733 WSASetLastError(0xdeadbeef);
7734 ret = pgetaddrinfo("", NULL, NULL, &result);
7735 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7736 ok(result != NULL, "getaddrinfo failed\n");
7737 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7738 pfreeaddrinfo(result);
7739
7740 result = NULL;
7741 ret = pgetaddrinfo(NULL, "0", NULL, &result);
7742 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7743 ok(result != NULL, "getaddrinfo failed\n");
7744
7745 result2 = NULL;
7746 ret = pgetaddrinfo(NULL, "", NULL, &result2);
7747 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7748 ok(result2 != NULL, "getaddrinfo failed\n");
7749 compare_addrinfo(result, result2);
7750 pfreeaddrinfo(result);
7751 pfreeaddrinfo(result2);
7752
7753 result = NULL;
7754 WSASetLastError(0xdeadbeef);
7755 ret = pgetaddrinfo("", "0", NULL, &result);
7756 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7757 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7758 ok(result != NULL, "getaddrinfo failed\n");
7759
7760 result2 = NULL;
7761 ret = pgetaddrinfo("", "", NULL, &result2);
7762 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7763 ok(result2 != NULL, "getaddrinfo failed\n");
7764 compare_addrinfo(result, result2);
7765 pfreeaddrinfo(result);
7766 pfreeaddrinfo(result2);
7767
7768 result = NULL;
7769 ret = pgetaddrinfo("localhost", NULL, NULL, &result);
7770 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7771 pfreeaddrinfo(result);
7772
7773 result = NULL;
7774 ret = pgetaddrinfo("localhost", "", NULL, &result);
7775 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7776 pfreeaddrinfo(result);
7777
7778 result = NULL;
7779 ret = pgetaddrinfo("localhost", "0", NULL, &result);
7780 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7781 pfreeaddrinfo(result);
7782
7783 result = NULL;
7784 ret = pgetaddrinfo("localhost", "80", NULL, &result);
7785 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7786 pfreeaddrinfo(result);
7787
7788 result = NULL;
7789 ret = pgetaddrinfo("localhost", NULL, &hint, &result);
7790 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7791 pfreeaddrinfo(result);
7792
7793 result = NULL;
7794 WSASetLastError(0xdeadbeef);
7795 ret = pgetaddrinfo("localhost", "80", &hint, &result);
7796 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7797 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7798 pfreeaddrinfo(result);
7799
7800 hint.ai_flags = AI_NUMERICHOST;
7801 result = (void*)0xdeadbeef;
7802 ret = pgetaddrinfo("localhost", "80", &hint, &result);
7803 ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", WSAGetLastError());
7804 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected WSAHOST_NOT_FOUND, got %d\n", WSAGetLastError());
7805 ok(!result, "result = %p\n", result);
7806 hint.ai_flags = 0;
7807
7808 /* try to get information from the computer name, result is the same
7809 * as if requesting with an empty host name. */
7810 ret = pgetaddrinfo(name, NULL, NULL, &result);
7811 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7812 ok(result != NULL, "GetAddrInfoW failed\n");
7813
7814 ret = pgetaddrinfo("", NULL, NULL, &result2);
7815 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7816 ok(result != NULL, "GetAddrInfoW failed\n");
7817 compare_addrinfo(result, result2);
7818 pfreeaddrinfo(result);
7819 pfreeaddrinfo(result2);
7820
7821 ret = pgetaddrinfo(name, "", NULL, &result);
7822 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7823 ok(result != NULL, "GetAddrInfoW failed\n");
7824
7825 ret = pgetaddrinfo("", "", NULL, &result2);
7826 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7827 ok(result != NULL, "GetAddrInfoW failed\n");
7828 compare_addrinfo(result, result2);
7829 pfreeaddrinfo(result);
7830 pfreeaddrinfo(result2);
7831
7832 result = (ADDRINFOA *)0xdeadbeef;
7833 WSASetLastError(0xdeadbeef);
7834 ret = pgetaddrinfo("nxdomain.codeweavers.com", NULL, NULL, &result);
7835 if(ret == 0)
7836 {
7837 skip("nxdomain returned success. Broken ISP redirects?\n");
7838 return;
7839 }
7840 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7841 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7842 ok(result == NULL, "got %p\n", result);
7843
7844 /* Test IPv4 address conversion */
7845 result = NULL;
7846 ret = pgetaddrinfo("192.168.1.253", NULL, NULL, &result);
7847 ok(!ret, "getaddrinfo failed with %d\n", ret);
7848 ok(result->ai_family == AF_INET, "ai_family == %d\n", result->ai_family);
7849 ok(result->ai_addrlen >= sizeof(struct sockaddr_in), "ai_addrlen == %d\n", (int)result->ai_addrlen);
7850 ok(result->ai_addr != NULL, "ai_addr == NULL\n");
7851 sockaddr = (SOCKADDR_IN *)result->ai_addr;
7852 ok(sockaddr->sin_family == AF_INET, "ai_addr->sin_family == %d\n", sockaddr->sin_family);
7853 ok(sockaddr->sin_port == 0, "ai_addr->sin_port == %d\n", sockaddr->sin_port);
7854
7855 ip = inet_ntoa(sockaddr->sin_addr);
7856 ok(strcmp(ip, "192.168.1.253") == 0, "sockaddr->ai_addr == '%s'\n", ip);
7857 pfreeaddrinfo(result);
7858
7859 /* Test IPv4 address conversion with port */
7860 result = NULL;
7861 hint.ai_flags = AI_NUMERICHOST;
7862 ret = pgetaddrinfo("192.168.1.253:1024", NULL, &hint, &result);
7863 hint.ai_flags = 0;
7864 ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo returned unexpected result: %d\n", ret);
7865 ok(result == NULL, "expected NULL, got %p\n", result);
7866
7867 /* Test IPv6 address conversion */
7868 result = NULL;
7869 SetLastError(0xdeadbeef);
7870 ret = pgetaddrinfo("2a00:2039:dead:beef:cafe::6666", NULL, NULL, &result);
7871
7872 if (result != NULL)
7873 {
7874 ok(!ret, "getaddrinfo failed with %d\n", ret);
7875 verify_ipv6_addrinfo(result, "2a00:2039:dead:beef:cafe::6666");
7876 pfreeaddrinfo(result);
7877
7878 /* Test IPv6 address conversion with brackets */
7879 result = NULL;
7880 ret = pgetaddrinfo("[beef::cafe]", NULL, NULL, &result);
7881 ok(!ret, "getaddrinfo failed with %d\n", ret);
7882 verify_ipv6_addrinfo(result, "beef::cafe");
7883 pfreeaddrinfo(result);
7884
7885 /* Test IPv6 address conversion with brackets and hints */
7886 memset(&hint, 0, sizeof(ADDRINFOA));
7887 hint.ai_flags = AI_NUMERICHOST;
7888 hint.ai_family = AF_INET6;
7889 result = NULL;
7890 ret = pgetaddrinfo("[beef::cafe]", NULL, &hint, &result);
7891 ok(!ret, "getaddrinfo failed with %d\n", ret);
7892 verify_ipv6_addrinfo(result, "beef::cafe");
7893 pfreeaddrinfo(result);
7894
7895 memset(&hint, 0, sizeof(ADDRINFOA));
7896 hint.ai_flags = AI_NUMERICHOST;
7897 hint.ai_family = AF_INET;
7898 result = NULL;
7899 ret = pgetaddrinfo("[beef::cafe]", NULL, &hint, &result);
7900 ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", ret);
7901
7902 /* Test IPv6 address conversion with brackets and port */
7903 result = NULL;
7904 ret = pgetaddrinfo("[beef::cafe]:10239", NULL, NULL, &result);
7905 ok(!ret, "getaddrinfo failed with %d\n", ret);
7906 verify_ipv6_addrinfo(result, "beef::cafe");
7907 pfreeaddrinfo(result);
7908
7909 /* Test IPv6 address conversion with unmatched brackets */
7910 result = NULL;
7911 hint.ai_flags = AI_NUMERICHOST;
7912 ret = pgetaddrinfo("[beef::cafe", NULL, &hint, &result);
7913 ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", ret);
7914
7915 ret = pgetaddrinfo("beef::cafe]", NULL, &hint, &result);
7916 ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", ret);
7917 }
7918 else
7919 {
7920 ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", ret);
7921 win_skip("getaddrinfo does not support IPV6\n");
7922 }
7923
7924 hint.ai_flags = 0;
7925
7926 for (i = 0;i < (ARRAY_SIZE(hinttests));i++)
7927 {
7928 hint.ai_family = hinttests[i].family;
7929 hint.ai_socktype = hinttests[i].socktype;
7930 hint.ai_protocol = hinttests[i].protocol;
7931
7932 result = NULL;
7933 SetLastError(0xdeadbeef);
7934 ret = pgetaddrinfo("localhost", NULL, &hint, &result);
7935 if(!ret)
7936 {
7937 if (hinttests[i].error)
7938 ok(0, "test %d: getaddrinfo succeeded unexpectedly\n", i);
7939 else
7940 {
7941 p = result;
7942 do
7943 {
7944 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
7945 if (hinttests[i].family == AF_UNSPEC)
7946 ok(p->ai_family == AF_INET || p->ai_family == AF_INET6,
7947 "test %d: expected AF_INET or AF_INET6, got %d\n",
7948 i, p->ai_family);
7949 else
7950 ok(p->ai_family == hinttests[i].family,
7951 "test %d: expected family %d, got %d\n",
7952 i, hinttests[i].family, p->ai_family);
7953
7954 ok(p->ai_socktype == hinttests[i].socktype,
7955 "test %d: expected type %d, got %d\n",
7956 i, hinttests[i].socktype, p->ai_socktype);
7957 ok(p->ai_protocol == hinttests[i].protocol,
7958 "test %d: expected protocol %d, got %d\n",
7959 i, hinttests[i].protocol, p->ai_protocol);
7960 p = p->ai_next;
7961 }
7962 while (p);
7963 }
7964 pfreeaddrinfo(result);
7965 }
7966 else
7967 {
7968 DWORD err = WSAGetLastError();
7969 if (hinttests[i].error)
7970 ok(hinttests[i].error == err, "test %d: getaddrinfo failed with error %d, expected %d\n",
7971 i, err, hinttests[i].error);
7972 else
7973 ok(0, "test %d: getaddrinfo failed with %d (err %d)\n", i, ret, err);
7974 }
7975 }
7976 }
7977
7978 static void test_ConnectEx(void)
7979 {
7980 SOCKET listener = INVALID_SOCKET;
7981 SOCKET acceptor = INVALID_SOCKET;
7982 SOCKET connector = INVALID_SOCKET;
7983 struct sockaddr_in address, conaddress;
7984 int addrlen;
7985 OVERLAPPED overlapped;
7986 LPFN_CONNECTEX pConnectEx;
7987 GUID connectExGuid = WSAID_CONNECTEX;
7988 DWORD bytesReturned;
7989 char buffer[1024];
7990 BOOL bret;
7991 DWORD dwret;
7992 int iret;
7993
7994 memset(&overlapped, 0, sizeof(overlapped));
7995
7996 listener = socket(AF_INET, SOCK_STREAM, 0);
7997 if (listener == INVALID_SOCKET) {
7998 skip("could not create listener socket, error %d\n", WSAGetLastError());
7999 goto end;
8000 }
8001
8002 connector = socket(AF_INET, SOCK_STREAM, 0);
8003 if (connector == INVALID_SOCKET) {
8004 skip("could not create connector socket, error %d\n", WSAGetLastError());
8005 goto end;
8006 }
8007
8008 memset(&address, 0, sizeof(address));
8009 address.sin_family = AF_INET;
8010 address.sin_addr.s_addr = inet_addr("127.0.0.1");
8011 iret = bind(listener, (struct sockaddr*)&address, sizeof(address));
8012 if (iret != 0) {
8013 skip("failed to bind, error %d\n", WSAGetLastError());
8014 goto end;
8015 }
8016
8017 addrlen = sizeof(address);
8018 iret = getsockname(listener, (struct sockaddr*)&address, &addrlen);
8019 if (iret != 0) {
8020 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
8021 goto end;
8022 }
8023
8024 if (set_blocking(listener, TRUE)) {
8025 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8026 goto end;
8027 }
8028
8029 bytesReturned = 0xdeadbeef;
8030 iret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectExGuid, sizeof(connectExGuid),
8031 &pConnectEx, sizeof(pConnectEx), &bytesReturned, NULL, NULL);
8032 if (iret) {
8033 win_skip("WSAIoctl failed to get ConnectEx with ret %d + errno %d\n", iret, WSAGetLastError());
8034 goto end;
8035 }
8036
8037 ok(bytesReturned == sizeof(pConnectEx), "expected sizeof(pConnectEx), got %u\n", bytesReturned);
8038
8039 bret = pConnectEx(INVALID_SOCKET, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8040 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "ConnectEx on invalid socket "
8041 "returned %d + errno %d\n", bret, WSAGetLastError());
8042
8043 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8044 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "ConnectEx on a unbound socket "
8045 "returned %d + errno %d\n", bret, WSAGetLastError());
8046 if (bret == TRUE || WSAGetLastError() != WSAEINVAL)
8047 {
8048 acceptor = accept(listener, NULL, NULL);
8049 if (acceptor != INVALID_SOCKET) {
8050 closesocket(acceptor);
8051 acceptor = INVALID_SOCKET;
8052 }
8053
8054 closesocket(connector);
8055 connector = socket(AF_INET, SOCK_STREAM, 0);
8056 if (connector == INVALID_SOCKET) {
8057 skip("could not create connector socket, error %d\n", WSAGetLastError());
8058 goto end;
8059 }
8060 }
8061
8062 /* ConnectEx needs a bound socket */
8063 memset(&conaddress, 0, sizeof(conaddress));
8064 conaddress.sin_family = AF_INET;
8065 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8066 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8067 if (iret != 0) {
8068 skip("failed to bind, error %d\n", WSAGetLastError());
8069 goto end;
8070 }
8071
8072 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, NULL);
8073 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "ConnectEx on a NULL overlapped "
8074 "returned %d + errno %d\n", bret, WSAGetLastError());
8075
8076 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8077 if (overlapped.hEvent == NULL) {
8078 skip("could not create event object, errno = %d\n", GetLastError());
8079 goto end;
8080 }
8081
8082 iret = listen(listener, 1);
8083 if (iret != 0) {
8084 skip("listening failed, errno = %d\n", WSAGetLastError());
8085 goto end;
8086 }
8087
8088 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8089 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
8090 "returned %d + errno %d\n", bret, WSAGetLastError());
8091 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8092 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
8093
8094 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8095 ok(bret, "Connecting failed, error %d\n", GetLastError());
8096 ok(bytesReturned == 0, "Bytes sent is %d\n", bytesReturned);
8097
8098 closesocket(connector);
8099 connector = socket(AF_INET, SOCK_STREAM, 0);
8100 if (connector == INVALID_SOCKET) {
8101 skip("could not create connector socket, error %d\n", WSAGetLastError());
8102 goto end;
8103 }
8104 /* ConnectEx needs a bound socket */
8105 memset(&conaddress, 0, sizeof(conaddress));
8106 conaddress.sin_family = AF_INET;
8107 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8108 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8109 if (iret != 0) {
8110 skip("failed to bind, error %d\n", WSAGetLastError());
8111 goto end;
8112 }
8113
8114 acceptor = accept(listener, NULL, NULL);
8115 if (acceptor != INVALID_SOCKET) {
8116 closesocket(acceptor);
8117 }
8118
8119 buffer[0] = '1';
8120 buffer[1] = '2';
8121 buffer[2] = '3';
8122 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, buffer, 3, &bytesReturned, &overlapped);
8123 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
8124 "returned %d + errno %d\n", bret, WSAGetLastError());
8125 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8126 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
8127
8128 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8129 ok(bret, "Connecting failed, error %d\n", GetLastError());
8130 ok(bytesReturned == 3, "Bytes sent is %d\n", bytesReturned);
8131
8132 acceptor = accept(listener, NULL, NULL);
8133 ok(acceptor != INVALID_SOCKET, "could not accept socket error %d\n", WSAGetLastError());
8134
8135 bytesReturned = recv(acceptor, buffer, 3, 0);
8136 buffer[4] = 0;
8137 ok(bytesReturned == 3, "Didn't get all sent data, got only %d\n", bytesReturned);
8138 ok(buffer[0] == '1' && buffer[1] == '2' && buffer[2] == '3',
8139 "Failed to get the right data, expected '123', got '%s'\n", buffer);
8140
8141 closesocket(connector);
8142 connector = socket(AF_INET, SOCK_STREAM, 0);
8143 if (connector == INVALID_SOCKET) {
8144 skip("could not create connector socket, error %d\n", WSAGetLastError());
8145 goto end;
8146 }
8147 /* ConnectEx needs a bound socket */
8148 memset(&conaddress, 0, sizeof(conaddress));
8149 conaddress.sin_family = AF_INET;
8150 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8151 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8152 if (iret != 0) {
8153 skip("failed to bind, error %d\n", WSAGetLastError());
8154 goto end;
8155 }
8156
8157 if (acceptor != INVALID_SOCKET) {
8158 closesocket(acceptor);
8159 acceptor = INVALID_SOCKET;
8160 }
8161
8162 /* Connect with error */
8163 closesocket(listener);
8164 listener = INVALID_SOCKET;
8165
8166 address.sin_port = htons(1);
8167
8168 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8169 ok(bret == FALSE && GetLastError() == ERROR_IO_PENDING, "ConnectEx to bad destination failed: "
8170 "returned %d + errno %d\n", bret, GetLastError());
8171 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8172 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
8173
8174 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8175 ok(bret == FALSE && GetLastError() == ERROR_CONNECTION_REFUSED,
8176 "Connecting to a disconnected host returned error %d - %d\n", bret, WSAGetLastError());
8177
8178 end:
8179 if (overlapped.hEvent)
8180 WSACloseEvent(overlapped.hEvent);
8181 if (listener != INVALID_SOCKET)
8182 closesocket(listener);
8183 if (acceptor != INVALID_SOCKET)
8184 closesocket(acceptor);
8185 if (connector != INVALID_SOCKET)
8186 closesocket(connector);
8187 }
8188
8189 static void test_AcceptEx(void)
8190 {
8191 SOCKET listener = INVALID_SOCKET;
8192 SOCKET acceptor = INVALID_SOCKET;
8193 SOCKET connector = INVALID_SOCKET;
8194 SOCKET connector2 = INVALID_SOCKET;
8195 struct sockaddr_in bindAddress, peerAddress, *readBindAddress, *readRemoteAddress;
8196 int socklen, optlen;
8197 GUID acceptExGuid = WSAID_ACCEPTEX, getAcceptExGuid = WSAID_GETACCEPTEXSOCKADDRS;
8198 LPFN_ACCEPTEX pAcceptEx = NULL;
8199 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs = NULL;
8200 fd_set fds_accept, fds_send;
8201 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
8202 int got, conn1, i;
8203 DWORD bytesReturned, connect_time;
8204 char buffer[1024], ipbuffer[32];
8205 OVERLAPPED overlapped;
8206 int iret, localSize = sizeof(struct sockaddr_in), remoteSize = localSize;
8207 BOOL bret;
8208 DWORD dwret;
8209
8210 memset(&overlapped, 0, sizeof(overlapped));
8211
8212 listener = socket(AF_INET, SOCK_STREAM, 0);
8213 if (listener == INVALID_SOCKET) {
8214 skip("could not create listener socket, error %d\n", WSAGetLastError());
8215 goto end;
8216 }
8217
8218 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8219 if (acceptor == INVALID_SOCKET) {
8220 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8221 goto end;
8222 }
8223
8224 connector = socket(AF_INET, SOCK_STREAM, 0);
8225 if (connector == INVALID_SOCKET) {
8226 skip("could not create connector socket, error %d\n", WSAGetLastError());
8227 goto end;
8228 }
8229
8230 memset(&bindAddress, 0, sizeof(bindAddress));
8231 bindAddress.sin_family = AF_INET;
8232 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8233 iret = bind(listener, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8234 if (iret != 0) {
8235 skip("failed to bind, error %d\n", WSAGetLastError());
8236 goto end;
8237 }
8238
8239 socklen = sizeof(bindAddress);
8240 iret = getsockname(listener, (struct sockaddr*)&bindAddress, &socklen);
8241 if (iret != 0) {
8242 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
8243 goto end;
8244 }
8245
8246 if (set_blocking(listener, FALSE)) {
8247 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8248 goto end;
8249 }
8250
8251 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
8252 &pAcceptEx, sizeof(pAcceptEx), &bytesReturned, NULL, NULL);
8253 if (iret) {
8254 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret, WSAGetLastError());
8255 goto end;
8256 }
8257
8258 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &getAcceptExGuid, sizeof(getAcceptExGuid),
8259 &pGetAcceptExSockaddrs, sizeof(pGetAcceptExSockaddrs), &bytesReturned, NULL, NULL);
8260 if (iret) {
8261 skip("WSAIoctl failed to get GetAcceptExSockaddrs with ret %d + errno %d\n", iret, WSAGetLastError());
8262 goto end;
8263 }
8264
8265 overlapped.Internal = 0xdeadbeef;
8266 bret = pAcceptEx(INVALID_SOCKET, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8267 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8268 &bytesReturned, &overlapped);
8269 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid listening socket "
8270 "returned %d + errno %d\n", bret, WSAGetLastError());
8271 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8272
8273 overlapped.Internal = 0xdeadbeef;
8274 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8275 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8276 &bytesReturned, &overlapped);
8277 todo_wine
8278 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on a non-listening socket "
8279 "returned %d + errno %d\n", bret, WSAGetLastError());
8280 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8281
8282 iret = listen(listener, 5);
8283 if (iret != 0) {
8284 skip("listening failed, errno = %d\n", WSAGetLastError());
8285 goto end;
8286 }
8287
8288 overlapped.Internal = 0xdeadbeef;
8289 bret = pAcceptEx(listener, INVALID_SOCKET, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8290 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8291 &bytesReturned, &overlapped);
8292 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid accepting socket "
8293 "returned %d + errno %d\n", bret, WSAGetLastError());
8294 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8295
8296 overlapped.Internal = 0xdeadbeef;
8297 bret = pAcceptEx(listener, acceptor, NULL, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8298 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8299 &bytesReturned, &overlapped);
8300 todo_wine ok(bret == FALSE && WSAGetLastError() == WSAEFAULT,
8301 "AcceptEx on NULL buffer returned %d + errno %d\n", bret, WSAGetLastError());
8302 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8303
8304 overlapped.Internal = 0xdeadbeef;
8305 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
8306 &bytesReturned, &overlapped);
8307 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING,
8308 "AcceptEx on too small local address size returned %d + errno %d\n",
8309 bret, WSAGetLastError());
8310 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8311 bret = CancelIo((HANDLE) listener);
8312 ok(bret, "Failed to cancel pending accept socket\n");
8313
8314 overlapped.Internal = 0xdeadbeef;
8315 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 15,
8316 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8317 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx on too small local address "
8318 "size returned %d + errno %d\n",
8319 bret, WSAGetLastError());
8320 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8321 bret = CancelIo((HANDLE) listener);
8322 ok(bret, "Failed to cancel pending accept socket\n");
8323
8324 overlapped.Internal = 0xdeadbeef;
8325 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16, 0,
8326 &bytesReturned, &overlapped);
8327 ok(bret == FALSE && WSAGetLastError() == WSAEFAULT,
8328 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
8329 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8330
8331 overlapped.Internal = 0xdeadbeef;
8332 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16,
8333 sizeof(struct sockaddr_in) + 15, &bytesReturned, &overlapped);
8334 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING,
8335 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
8336 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8337 bret = CancelIo((HANDLE) listener);
8338 ok(bret, "Failed to cancel pending accept socket\n");
8339
8340 bret = pAcceptEx(listener, acceptor, buffer, 0,
8341 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8342 &bytesReturned, NULL);
8343 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
8344 "returned %d + errno %d\n", bret, WSAGetLastError());
8345
8346 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, 0, &bytesReturned, NULL);
8347 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
8348 "returned %d + errno %d\n", bret, WSAGetLastError());
8349
8350 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8351 if (overlapped.hEvent == NULL) {
8352 skip("could not create event object, errno = %d\n", GetLastError());
8353 goto end;
8354 }
8355
8356 overlapped.Internal = 0xdeadbeef;
8357 bret = pAcceptEx(listener, acceptor, buffer, 0,
8358 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8359 &bytesReturned, &overlapped);
8360 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8361 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8362
8363 overlapped.Internal = 0xdeadbeef;
8364 bret = pAcceptEx(listener, acceptor, buffer, 0,
8365 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8366 &bytesReturned, &overlapped);
8367 todo_wine ok(bret == FALSE && WSAGetLastError() == WSAEINVAL,
8368 "AcceptEx on already pending socket returned %d + errno %d\n", bret, WSAGetLastError());
8369 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8370 if (bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING) {
8371 /* We need to cancel this call, otherwise things fail */
8372 bret = CancelIo((HANDLE) listener);
8373 ok(bret, "Failed to cancel failed test. Bailing...\n");
8374 if (!bret) return;
8375 WaitForSingleObject(overlapped.hEvent, 0);
8376
8377 overlapped.Internal = 0xdeadbeef;
8378 bret = pAcceptEx(listener, acceptor, buffer, 0,
8379 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8380 &bytesReturned, &overlapped);
8381 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8382 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8383 }
8384
8385 iret = connect(acceptor, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8386 todo_wine ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL,
8387 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret, WSAGetLastError());
8388 if (!iret || (iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)) {
8389 /* We need to cancel this call, otherwise things fail */
8390 closesocket(acceptor);
8391 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8392 if (acceptor == INVALID_SOCKET) {
8393 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8394 goto end;
8395 }
8396
8397 bret = CancelIo((HANDLE) listener);
8398 ok(bret, "Failed to cancel failed test. Bailing...\n");
8399 if (!bret) return;
8400
8401 overlapped.Internal = 0xdeadbeef;
8402 bret = pAcceptEx(listener, acceptor, buffer, 0,
8403 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8404 &bytesReturned, &overlapped);
8405 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8406 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8407 }
8408
8409 overlapped.Internal = 0xdeadbeef;
8410 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8411 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8412
8413 dwret = WaitForSingleObject(overlapped.hEvent, INFINITE);
8414 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
8415 ok(overlapped.Internal == STATUS_SUCCESS, "got %08x\n", (ULONG)overlapped.Internal);
8416
8417 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8418 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
8419 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
8420
8421 closesocket(connector);
8422 connector = INVALID_SOCKET;
8423 closesocket(acceptor);
8424
8425 /* Test short reads */
8426
8427 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8428 if (acceptor == INVALID_SOCKET) {
8429 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8430 goto end;
8431 }
8432 connector = socket(AF_INET, SOCK_STREAM, 0);
8433 if (connector == INVALID_SOCKET) {
8434 skip("could not create connector socket, error %d\n", WSAGetLastError());
8435 goto end;
8436 }
8437 overlapped.Internal = 0xdeadbeef;
8438 bret = pAcceptEx(listener, acceptor, buffer, 2,
8439 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8440 &bytesReturned, &overlapped);
8441 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8442 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8443
8444 connect_time = 0xdeadbeef;
8445 optlen = sizeof(connect_time);
8446 iret = getsockopt(connector, SOL_SOCKET, SO_CONNECT_TIME, (char *)&connect_time, &optlen);
8447 ok(!iret, "getsockopt failed %d\n", WSAGetLastError());
8448 ok(connect_time == ~0u, "unexpected connect time %u\n", connect_time);
8449
8450 /* AcceptEx() still won't complete until we send data */
8451 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8452 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8453
8454 connect_time = 0xdeadbeef;
8455 optlen = sizeof(connect_time);
8456 iret = getsockopt(connector, SOL_SOCKET, SO_CONNECT_TIME, (char *)&connect_time, &optlen);
8457 ok(!iret, "getsockopt failed %d\n", WSAGetLastError());
8458 ok(connect_time < 0xdeadbeef, "unexpected connect time %u\n", connect_time);
8459
8460 dwret = WaitForSingleObject(overlapped.hEvent, 0);
8461 ok(dwret == WAIT_TIMEOUT, "Waiting for accept event timeout failed with %d + errno %d\n", dwret, GetLastError());
8462 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8463
8464 iret = getsockname( connector, (struct sockaddr *)&peerAddress, &remoteSize);
8465 ok( !iret, "getsockname failed.\n");
8466
8467 /* AcceptEx() could complete any time now */
8468 iret = send(connector, buffer, 1, 0);
8469 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
8470
8471 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8472 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
8473 ok(overlapped.Internal == STATUS_SUCCESS, "got %08x\n", (ULONG)overlapped.Internal);
8474
8475 /* Check if the buffer from AcceptEx is decoded correctly */
8476 pGetAcceptExSockaddrs(buffer, 2, sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8477 (struct sockaddr **)&readBindAddress, &localSize,
8478 (struct sockaddr **)&readRemoteAddress, &remoteSize);
8479 strcpy( ipbuffer, inet_ntoa(readBindAddress->sin_addr));
8480 ok( readBindAddress->sin_addr.s_addr == bindAddress.sin_addr.s_addr,
8481 "Local socket address is different %s != %s\n",
8482 ipbuffer, inet_ntoa(bindAddress.sin_addr));
8483 ok( readBindAddress->sin_port == bindAddress.sin_port,
8484 "Local socket port is different: %d != %d\n",
8485 readBindAddress->sin_port, bindAddress.sin_port);
8486 strcpy( ipbuffer, inet_ntoa(readRemoteAddress->sin_addr));
8487 ok( readRemoteAddress->sin_addr.s_addr == peerAddress.sin_addr.s_addr,
8488 "Remote socket address is different %s != %s\n",
8489 ipbuffer, inet_ntoa(peerAddress.sin_addr));
8490 ok( readRemoteAddress->sin_port == peerAddress.sin_port,
8491 "Remote socket port is different: %d != %d\n",
8492 readRemoteAddress->sin_port, peerAddress.sin_port);
8493
8494 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8495 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
8496 ok(bytesReturned == 1, "bytesReturned isn't supposed to be %d\n", bytesReturned);
8497
8498 closesocket(connector);
8499 connector = INVALID_SOCKET;
8500 closesocket(acceptor);
8501
8502 /* Test CF_DEFER & AcceptEx interaction */
8503
8504 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8505 if (acceptor == INVALID_SOCKET) {
8506 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8507 goto end;
8508 }
8509 connector = socket(AF_INET, SOCK_STREAM, 0);
8510 if (connector == INVALID_SOCKET) {
8511 skip("could not create connector socket, error %d\n", WSAGetLastError());
8512 goto end;
8513 }
8514 connector2 = socket(AF_INET, SOCK_STREAM, 0);
8515 if (connector == INVALID_SOCKET) {
8516 skip("could not create connector socket, error %d\n", WSAGetLastError());
8517 goto end;
8518 }
8519
8520 if (set_blocking(connector, FALSE)) {
8521 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8522 goto end;
8523 }
8524
8525 if (set_blocking(connector2, FALSE)) {
8526 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8527 goto end;
8528 }
8529
8530 /* Connect socket #1 */
8531 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8532 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8533
8534 FD_ZERO ( &fds_accept );
8535 FD_ZERO ( &fds_send );
8536
8537 FD_SET ( listener, &fds_accept );
8538 FD_SET ( connector, &fds_send );
8539
8540 buffer[0] = '0';
8541 got = 0;
8542 conn1 = 0;
8543
8544 for (i = 0; i < 4000; ++i)
8545 {
8546 fd_set fds_openaccept = fds_accept, fds_opensend = fds_send;
8547
8548 wsa_ok ( ( select ( 0, &fds_openaccept, &fds_opensend, NULL, &timeout ) ), SOCKET_ERROR !=,
8549 "acceptex test(%d): could not select on socket, errno %d\n" );
8550
8551 /* check for incoming requests */
8552 if ( FD_ISSET ( listener, &fds_openaccept ) ) {
8553 got++;
8554 if (got == 1) {
8555 SOCKET tmp = WSAAccept(listener, NULL, NULL, (LPCONDITIONPROC) AlwaysDeferConditionFunc, 0);
8556 ok(tmp == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
8557 bret = pAcceptEx(listener, acceptor, buffer, 0,
8558 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8559 &bytesReturned, &overlapped);
8560 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8561 }
8562 else if (got == 2) {
8563 /* this should be socket #2 */
8564 SOCKET tmp = accept(listener, NULL, NULL);
8565 ok(tmp != INVALID_SOCKET, "accept failed %d\n", WSAGetLastError());
8566 closesocket(tmp);
8567 }
8568 else {
8569 ok(FALSE, "Got more than 2 connections?\n");
8570 }
8571 }
8572 if ( conn1 && FD_ISSET ( connector2, &fds_opensend ) ) {
8573 /* Send data on second socket, and stop */
8574 send(connector2, "2", 1, 0);
8575 FD_CLR ( connector2, &fds_send );
8576
8577 break;
8578 }
8579 if ( FD_ISSET ( connector, &fds_opensend ) ) {
8580 /* Once #1 is connected, allow #2 to connect */
8581 conn1 = 1;
8582
8583 send(connector, "1", 1, 0);
8584 FD_CLR ( connector, &fds_send );
8585
8586 iret = connect(connector2, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8587 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8588 FD_SET ( connector2, &fds_send );
8589 }
8590 }
8591
8592 ok (got == 2 || broken(got == 1) /* NT4 */,
8593 "Did not get both connections, got %d\n", got);
8594
8595 dwret = WaitForSingleObject(overlapped.hEvent, 0);
8596 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
8597
8598 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8599 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
8600 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
8601
8602 set_blocking(acceptor, TRUE);
8603 iret = recv( acceptor, buffer, 2, 0);
8604 ok(iret == 1, "Failed to get data, %d, errno: %d\n", iret, WSAGetLastError());
8605
8606 ok(buffer[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer[0]);
8607
8608 closesocket(connector);
8609 connector = INVALID_SOCKET;
8610 closesocket(acceptor);
8611
8612 /* clean up in case of failures */
8613 while ((acceptor = accept(listener, NULL, NULL)) != INVALID_SOCKET)
8614 closesocket(acceptor);
8615
8616 /* Disconnect during receive? */
8617
8618 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8619 if (acceptor == INVALID_SOCKET) {
8620 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8621 goto end;
8622 }
8623 connector = socket(AF_INET, SOCK_STREAM, 0);
8624 if (connector == INVALID_SOCKET) {
8625 skip("could not create connector socket, error %d\n", WSAGetLastError());
8626 goto end;
8627 }
8628 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8629 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8630 &bytesReturned, &overlapped);
8631 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8632
8633 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8634 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8635
8636 closesocket(connector);
8637 connector = INVALID_SOCKET;
8638
8639 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8640 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
8641
8642 bytesReturned = 123456;
8643 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8644 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
8645 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
8646
8647 closesocket(acceptor);
8648
8649 /* Test closing with pending requests */
8650
8651 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8652 if (acceptor == INVALID_SOCKET) {
8653 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8654 goto end;
8655 }
8656 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8657 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8658 &bytesReturned, &overlapped);
8659 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8660
8661 closesocket(acceptor);
8662
8663 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8664 todo_wine ok(dwret == WAIT_OBJECT_0,
8665 "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
8666
8667 if (dwret != WAIT_TIMEOUT) {
8668 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8669 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
8670 }
8671 else {
8672 bret = CancelIo((HANDLE) listener);
8673 ok(bret, "Failed to cancel failed test. Bailing...\n");
8674 if (!bret) return;
8675 WaitForSingleObject(overlapped.hEvent, 0);
8676 }
8677
8678 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8679 if (acceptor == INVALID_SOCKET) {
8680 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8681 goto end;
8682 }
8683 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8684 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8685 &bytesReturned, &overlapped);
8686 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8687
8688 CancelIo((HANDLE) acceptor);
8689
8690 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8691 ok(dwret == WAIT_TIMEOUT, "Waiting for timeout failed with %d + errno %d\n", dwret, GetLastError());
8692
8693 closesocket(acceptor);
8694
8695 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8696 if (acceptor == INVALID_SOCKET) {
8697 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8698 goto end;
8699 }
8700 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8701 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8702 &bytesReturned, &overlapped);
8703 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8704
8705 closesocket(listener);
8706 listener = INVALID_SOCKET;
8707
8708 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8709 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
8710
8711 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8712 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
8713
8714 end:
8715 if (overlapped.hEvent)
8716 WSACloseEvent(overlapped.hEvent);
8717 if (listener != INVALID_SOCKET)
8718 closesocket(listener);
8719 if (acceptor != INVALID_SOCKET)
8720 closesocket(acceptor);
8721 if (connector != INVALID_SOCKET)
8722 closesocket(connector);
8723 if (connector2 != INVALID_SOCKET)
8724 closesocket(connector2);
8725 }
8726
8727 static void test_DisconnectEx(void)
8728 {
8729 SOCKET listener, acceptor, connector;
8730 LPFN_DISCONNECTEX pDisconnectEx;
8731 GUID disconnectExGuid = WSAID_DISCONNECTEX;
8732 struct sockaddr_in address;
8733 DWORD num_bytes, flags;
8734 OVERLAPPED overlapped;
8735 int addrlen, iret;
8736 BOOL bret;
8737
8738 connector = socket(AF_INET, SOCK_STREAM, 0);
8739 ok(connector != INVALID_SOCKET, "failed to create connector socket, error %d\n", WSAGetLastError());
8740
8741 iret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &disconnectExGuid, sizeof(disconnectExGuid),
8742 &pDisconnectEx, sizeof(pDisconnectEx), &num_bytes, NULL, NULL);
8743 if (iret)
8744 {
8745 win_skip("WSAIoctl failed to get DisconnectEx, error %d\n", WSAGetLastError());
8746 closesocket(connector);
8747 return;
8748 }
8749
8750 listener = socket(AF_INET, SOCK_STREAM, 0);
8751 ok(listener != INVALID_SOCKET, "failed to create listener socket, error %d\n", WSAGetLastError());
8752
8753 memset(&address, 0, sizeof(address));
8754 address.sin_family = AF_INET;
8755 address.sin_addr.s_addr = inet_addr("127.0.0.1");
8756 iret = bind(listener, (struct sockaddr *)&address, sizeof(address));
8757 ok(iret == 0, "failed to bind, error %d\n", WSAGetLastError());
8758
8759 addrlen = sizeof(address);
8760 iret = getsockname(listener, (struct sockaddr *)&address, &addrlen);
8761 ok(iret == 0, "failed to lookup bind address, error %d\n", WSAGetLastError());
8762
8763 iret = listen(listener, 1);
8764 ok(iret == 0, "failed to listen, error %d\n", WSAGetLastError());
8765
8766 set_blocking(listener, TRUE);
8767
8768 memset(&overlapped, 0, sizeof(overlapped));
8769 bret = pDisconnectEx(INVALID_SOCKET, &overlapped, 0, 0);
8770 ok(bret == FALSE, "DisconnectEx unexpectedly succeeded\n");
8771 ok(WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %d\n", WSAGetLastError());
8772
8773 memset(&overlapped, 0, sizeof(overlapped));
8774 bret = pDisconnectEx(connector, &overlapped, 0, 0);
8775 ok(bret == FALSE, "DisconnectEx unexpectedly succeeded\n");
8776 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "expected WSAENOTCONN, got %d\n", WSAGetLastError());
8777
8778 iret = connect(connector, (struct sockaddr *)&address, addrlen);
8779 ok(iret == 0, "failed to connect, error %d\n", WSAGetLastError());
8780
8781 acceptor = accept(listener, NULL, NULL);
8782 ok(acceptor != INVALID_SOCKET, "could not accept socket, error %d\n", WSAGetLastError());
8783
8784 memset(&overlapped, 0, sizeof(overlapped));
8785 overlapped.hEvent = WSACreateEvent();
8786 ok(overlapped.hEvent != WSA_INVALID_EVENT, "WSACreateEvent failed, error %d\n", WSAGetLastError());
8787 bret = pDisconnectEx(connector, &overlapped, 0, 0);
8788 if (bret)
8789 ok(overlapped.Internal == STATUS_PENDING, "expected STATUS_PENDING, got %08lx\n", overlapped.Internal);
8790 else if (WSAGetLastError() == ERROR_IO_PENDING)
8791 bret = WSAGetOverlappedResult(connector, &overlapped, &num_bytes, TRUE, &flags);
8792 ok(bret, "DisconnectEx failed, error %d\n", WSAGetLastError());
8793 WSACloseEvent(overlapped.hEvent);
8794
8795 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8796 ok(iret != 0, "connect unexpectedly succeeded\n");
8797 ok(WSAGetLastError() == WSAEISCONN, "expected WSAEISCONN, got %d\n", WSAGetLastError());
8798
8799 closesocket(acceptor);
8800 closesocket(connector);
8801
8802 connector = socket(AF_INET, SOCK_STREAM, 0);
8803 ok(connector != INVALID_SOCKET, "failed to create connector socket, error %d\n", WSAGetLastError());
8804
8805 iret = connect(connector, (struct sockaddr *)&address, addrlen);
8806 ok(iret == 0, "failed to connect, error %d\n", WSAGetLastError());
8807
8808 acceptor = accept(listener, NULL, NULL);
8809 ok(acceptor != INVALID_SOCKET, "could not accept socket, error %d\n", WSAGetLastError());
8810
8811 bret = pDisconnectEx(connector, NULL, 0, 0);
8812 ok(bret, "DisconnectEx failed, error %d\n", WSAGetLastError());
8813
8814 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8815 ok(iret != 0, "connect unexpectedly succeeded\n");
8816 ok(WSAGetLastError() == WSAEISCONN, "expected WSAEISCONN, got %d\n", WSAGetLastError());
8817
8818 closesocket(acceptor);
8819 closesocket(connector);
8820 closesocket(listener);
8821 }
8822
8823 #define compare_file(h,s,o) compare_file2(h,s,o,__FILE__,__LINE__)
8824
8825 static void compare_file2(HANDLE handle, SOCKET sock, int offset, const char *file, int line)
8826 {
8827 char buf1[256], buf2[256];
8828 BOOL success;
8829 int i = 0;
8830
8831 SetFilePointer(handle, offset, NULL, FILE_BEGIN);
8832 while (1)
8833 {
8834 DWORD n1 = 0, n2 = 0;
8835
8836 success = ReadFile(handle, buf1, sizeof(buf1), &n1, NULL);
8837 ok_(file,line)(success, "Failed to read from file.\n");
8838 if (success && n1 == 0)
8839 break;
8840 else if(!success)
8841 return;
8842 n2 = recv(sock, buf2, n1, 0);
8843 ok_(file,line)(n1 == n2, "Block %d size mismatch (%d != %d)\n", i, n1, n2);
8844 ok_(file,line)(memcmp(buf1, buf2, n2) == 0, "Block %d failed\n", i);
8845 i++;
8846 }
8847 }
8848
8849 static void test_TransmitFile(void)
8850 {
8851 DWORD num_bytes, err, file_size, total_sent;
8852 GUID transmitFileGuid = WSAID_TRANSMITFILE;
8853 LPFN_TRANSMITFILE pTransmitFile = NULL;
8854 HANDLE file = INVALID_HANDLE_VALUE;
8855 char header_msg[] = "hello world";
8856 char footer_msg[] = "goodbye!!!";
8857 char system_ini_path[MAX_PATH];
8858 struct sockaddr_in bindAddress;
8859 TRANSMIT_FILE_BUFFERS buffers;
8860 SOCKET client, server, dest;
8861 WSAOVERLAPPED ov;
8862 char buf[256];
8863 int iret, len;
8864 BOOL bret;
8865
8866 memset( &ov, 0, sizeof(ov) );
8867
8868 /* Setup sockets for testing TransmitFile */
8869 client = socket(AF_INET, SOCK_STREAM, 0);
8870 server = socket(AF_INET, SOCK_STREAM, 0);
8871 if (client == INVALID_SOCKET || server == INVALID_SOCKET)
8872 {
8873 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8874 goto cleanup;
8875 }
8876 iret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &transmitFileGuid, sizeof(transmitFileGuid),
8877 &pTransmitFile, sizeof(pTransmitFile), &num_bytes, NULL, NULL);
8878 if (iret)
8879 {
8880 skip("WSAIoctl failed to get TransmitFile with ret %d + errno %d\n", iret, WSAGetLastError());
8881 goto cleanup;
8882 }
8883 GetSystemWindowsDirectoryA(system_ini_path, MAX_PATH );
8884 strcat(system_ini_path, "\\system.ini");
8885 file = CreateFileA(system_ini_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0x0, NULL);
8886 if (file == INVALID_HANDLE_VALUE)
8887 {
8888 skip("Unable to open a file to transmit.\n");
8889 goto cleanup;
8890 }
8891 file_size = GetFileSize(file, NULL);
8892
8893 /* Test TransmitFile with an invalid socket */
8894 bret = pTransmitFile(INVALID_SOCKET, file, 0, 0, NULL, NULL, 0);
8895 err = WSAGetLastError();
8896 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8897 ok(err == WSAENOTSOCK, "TransmitFile triggered unexpected errno (%d != %d)\n", err, WSAENOTSOCK);
8898
8899 /* Test a bogus TransmitFile without a connected socket */
8900 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, TF_REUSE_SOCKET);
8901 err = WSAGetLastError();
8902 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8903 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%d != %d)\n", err, WSAENOTCONN);
8904
8905 /* Setup a properly connected socket for transfers */
8906 memset(&bindAddress, 0, sizeof(bindAddress));
8907 bindAddress.sin_family = AF_INET;
8908 bindAddress.sin_port = htons(SERVERPORT+1);
8909 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8910 iret = bind(server, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8911 if (iret != 0)
8912 {
8913 skip("failed to bind(), error %d\n", WSAGetLastError());
8914 goto cleanup;
8915 }
8916 iret = listen(server, 1);
8917 if (iret != 0)
8918 {
8919 skip("failed to listen(), error %d\n", WSAGetLastError());
8920 goto cleanup;
8921 }
8922 iret = connect(client, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8923 if (iret != 0)
8924 {
8925 skip("failed to connect(), error %d\n", WSAGetLastError());
8926 goto cleanup;
8927 }
8928 len = sizeof(bindAddress);
8929 dest = accept(server, (struct sockaddr*)&bindAddress, &len);
8930 if (dest == INVALID_SOCKET)
8931 {
8932 skip("failed to accept(), error %d\n", WSAGetLastError());
8933 goto cleanup;
8934 }
8935 if (set_blocking(dest, FALSE))
8936 {
8937 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8938 goto cleanup;
8939 }
8940
8941 /* Test TransmitFile with no possible buffer */
8942 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
8943 ok(bret, "TransmitFile failed unexpectedly.\n");
8944 iret = recv(dest, buf, sizeof(buf), 0);
8945 ok(iret == -1, "Returned an unexpected buffer from TransmitFile (%d != -1).\n", iret);
8946
8947 /* Test TransmitFile with only buffer data */
8948 buffers.Head = &header_msg[0];
8949 buffers.HeadLength = sizeof(header_msg);
8950 buffers.Tail = &footer_msg[0];
8951 buffers.TailLength = sizeof(footer_msg);
8952 bret = pTransmitFile(client, NULL, 0, 0, NULL, &buffers, 0);
8953 ok(bret, "TransmitFile failed unexpectedly.\n");
8954 iret = recv(dest, buf, sizeof(buf), 0);
8955 ok(iret == sizeof(header_msg)+sizeof(footer_msg),
8956 "Returned an unexpected buffer from TransmitFile: %d\n", iret );
8957 ok(memcmp(&buf[0], &header_msg[0], sizeof(header_msg)) == 0,
8958 "TransmitFile header buffer did not match!\n");
8959 ok(memcmp(&buf[sizeof(header_msg)], &footer_msg[0], sizeof(footer_msg)) == 0,
8960 "TransmitFile footer buffer did not match!\n");
8961
8962 /* Test TransmitFile with only file data */
8963 bret = pTransmitFile(client, file, 0, 0, NULL, NULL, 0);
8964 ok(bret, "TransmitFile failed unexpectedly.\n");
8965 compare_file(file, dest, 0);
8966
8967 /* Test TransmitFile with both file and buffer data */
8968 buffers.Head = &header_msg[0];
8969 buffers.HeadLength = sizeof(header_msg);
8970 buffers.Tail = &footer_msg[0];
8971 buffers.TailLength = sizeof(footer_msg);
8972 SetFilePointer(file, 0, NULL, FILE_BEGIN);
8973 bret = pTransmitFile(client, file, 0, 0, NULL, &buffers, 0);
8974 ok(bret, "TransmitFile failed unexpectedly.\n");
8975 iret = recv(dest, buf, sizeof(header_msg), 0);
8976 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)) == 0,
8977 "TransmitFile header buffer did not match!\n");
8978 compare_file(file, dest, 0);
8979 iret = recv(dest, buf, sizeof(footer_msg), 0);
8980 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)) == 0,
8981 "TransmitFile footer buffer did not match!\n");
8982
8983 /* Test overlapped TransmitFile */
8984 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
8985 if (ov.hEvent == INVALID_HANDLE_VALUE)
8986 {
8987 skip("Could not create event object, some tests will be skipped. errno = %d\n",
8988 GetLastError());
8989 goto cleanup;
8990 }
8991 SetFilePointer(file, 0, NULL, FILE_BEGIN);
8992 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
8993 err = WSAGetLastError();
8994 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8995 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%d != %d)\n",
8996 err, ERROR_IO_PENDING);
8997 iret = WaitForSingleObject(ov.hEvent, 2000);
8998 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
8999 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
9000 ok(total_sent == file_size,
9001 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
9002 total_sent, file_size);
9003 compare_file(file, dest, 0);
9004
9005 /* Test overlapped TransmitFile w/ start offset */
9006 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
9007 if (ov.hEvent == INVALID_HANDLE_VALUE)
9008 {
9009 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
9010 goto cleanup;
9011 }
9012 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9013 ov.Offset = 10;
9014 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
9015 err = WSAGetLastError();
9016 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9017 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%d != %d)\n", err, ERROR_IO_PENDING);
9018 iret = WaitForSingleObject(ov.hEvent, 2000);
9019 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
9020 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
9021 ok(total_sent == (file_size - ov.Offset),
9022 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
9023 total_sent, file_size - ov.Offset);
9024 compare_file(file, dest, ov.Offset);
9025
9026 /* Test overlapped TransmitFile w/ file and buffer data */
9027 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
9028 if (ov.hEvent == INVALID_HANDLE_VALUE)
9029 {
9030 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
9031 goto cleanup;
9032 }
9033 buffers.Head = &header_msg[0];
9034 buffers.HeadLength = sizeof(header_msg);
9035 buffers.Tail = &footer_msg[0];
9036 buffers.TailLength = sizeof(footer_msg);
9037 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9038 ov.Offset = 0;
9039 bret = pTransmitFile(client, file, 0, 0, &ov, &buffers, 0);
9040 err = WSAGetLastError();
9041 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9042 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%d != %d)\n", err, ERROR_IO_PENDING);
9043 iret = WaitForSingleObject(ov.hEvent, 2000);
9044 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
9045 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
9046 ok(total_sent == (file_size + buffers.HeadLength + buffers.TailLength),
9047 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
9048 total_sent, file_size + buffers.HeadLength + buffers.TailLength);
9049 iret = recv(dest, buf, sizeof(header_msg), 0);
9050 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)) == 0,
9051 "TransmitFile header buffer did not match!\n");
9052 compare_file(file, dest, 0);
9053 iret = recv(dest, buf, sizeof(footer_msg), 0);
9054 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)) == 0,
9055 "TransmitFile footer buffer did not match!\n");
9056
9057 /* Test TransmitFile with a UDP datagram socket */
9058 closesocket(client);
9059 client = socket(AF_INET, SOCK_DGRAM, 0);
9060 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
9061 err = WSAGetLastError();
9062 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9063 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%d != %d)\n", err, WSAENOTCONN);
9064
9065 cleanup:
9066 CloseHandle(file);
9067 CloseHandle(ov.hEvent);
9068 closesocket(client);
9069 closesocket(server);
9070 }
9071
9072 static void test_getpeername(void)
9073 {
9074 SOCKET sock;
9075 struct sockaddr_in sa, sa_out;
9076 SOCKADDR_STORAGE ss;
9077 int sa_len;
9078 const char buf[] = "hello world";
9079 int ret;
9080
9081 /* Test the parameter validation order. */
9082 ret = getpeername(INVALID_SOCKET, NULL, NULL);
9083 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9084 ok(WSAGetLastError() == WSAENOTSOCK,
9085 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
9086
9087 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
9088 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
9089 if (sock == INVALID_SOCKET)
9090 {
9091 skip("Socket creation failed with %d\n", WSAGetLastError());
9092 return;
9093 }
9094
9095 ret = getpeername(sock, NULL, NULL);
9096 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9097 ok(WSAGetLastError() == WSAENOTCONN,
9098 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
9099
9100 memset(&sa, 0, sizeof(sa));
9101 sa.sin_family = AF_INET;
9102 sa.sin_port = htons(139);
9103 sa.sin_addr.s_addr = inet_addr("127.0.0.1");
9104
9105 /* sendto does not change a socket's connection state. */
9106 ret = sendto(sock, buf, sizeof(buf), 0, (struct sockaddr*)&sa, sizeof(sa));
9107 ok(ret != SOCKET_ERROR,
9108 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
9109
9110 ret = getpeername(sock, NULL, NULL);
9111 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9112 ok(WSAGetLastError() == WSAENOTCONN,
9113 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
9114
9115 ret = connect(sock, (struct sockaddr*)&sa, sizeof(sa));
9116 ok(ret == 0,
9117 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
9118
9119 ret = getpeername(sock, NULL, NULL);
9120 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9121 ok(WSAGetLastError() == WSAEFAULT,
9122 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9123
9124 /* Test crashes on Wine. */
9125 if (0)
9126 {
9127 ret = getpeername(sock, (void*)0xdeadbeef, (void*)0xcafebabe);
9128 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9129 ok(WSAGetLastError() == WSAEFAULT,
9130 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9131 }
9132
9133 ret = getpeername(sock, (struct sockaddr*)&sa_out, NULL);
9134 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
9135 ok(WSAGetLastError() == WSAEFAULT,
9136 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9137
9138 sa_len = 0;
9139 ret = getpeername(sock, NULL, &sa_len);
9140 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
9141 ok(WSAGetLastError() == WSAEFAULT,
9142 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9143 ok(!sa_len, "got %d\n", sa_len);
9144
9145 sa_len = 0;
9146 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
9147 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
9148 ok(WSAGetLastError() == WSAEFAULT,
9149 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9150 ok(!sa_len, "got %d\n", sa_len);
9151
9152 sa_len = sizeof(ss);
9153 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
9154 ok(ret == 0, "Expected getpeername to return 0, got %d\n", ret);
9155 ok(!memcmp(&sa, &ss, sizeof(sa)),
9156 "Expected the returned structure to be identical to the connect structure\n");
9157 ok(sa_len == sizeof(sa), "got %d\n", sa_len);
9158
9159 closesocket(sock);
9160 }
9161
9162 static void test_sioRoutingInterfaceQuery(void)
9163 {
9164 int ret;
9165 SOCKET sock;
9166 SOCKADDR_IN sin = { 0 }, sout = { 0 };
9167 DWORD bytesReturned;
9168
9169 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
9170 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
9171 if (sock == INVALID_SOCKET)
9172 {
9173 skip("Socket creation failed with %d\n", WSAGetLastError());
9174 return;
9175 }
9176 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, NULL, 0, NULL, 0, NULL,
9177 NULL, NULL);
9178 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
9179 "expected WSAEFAULT, got %d\n", WSAGetLastError());
9180 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
9181 NULL, 0, NULL, NULL, NULL);
9182 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
9183 "expected WSAEFAULT, got %d\n", WSAGetLastError());
9184 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
9185 NULL, 0, &bytesReturned, NULL, NULL);
9186 todo_wine ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEAFNOSUPPORT,
9187 "expected WSAEAFNOSUPPORT, got %d\n", WSAGetLastError());
9188 sin.sin_family = AF_INET;
9189 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
9190 NULL, 0, &bytesReturned, NULL, NULL);
9191 todo_wine ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL,
9192 "expected WSAEINVAL, got %d\n", WSAGetLastError());
9193 sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
9194 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
9195 NULL, 0, &bytesReturned, NULL, NULL);
9196 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
9197 "expected WSAEFAULT, got %d\n", WSAGetLastError());
9198 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
9199 &sout, sizeof(sout), &bytesReturned, NULL, NULL);
9200 ok(!ret, "WSAIoctl failed: %d\n", WSAGetLastError());
9201 ok(sout.sin_family == AF_INET, "expected AF_INET, got %d\n", sout.sin_family);
9202 /* We expect the source address to be INADDR_LOOPBACK as well, but
9203 * there's no guarantee that a route to the loopback address exists,
9204 * so rather than introduce spurious test failures we do not test the
9205 * source address.
9206 */
9207 closesocket(sock);
9208 }
9209
9210 static void test_sioAddressListChange(void)
9211 {
9212 struct sockaddr_in bindAddress;
9213 struct in_addr net_address;
9214 WSAOVERLAPPED overlapped, *olp;
9215 struct hostent *h;
9216 DWORD num_bytes, error, tick;
9217 SOCKET sock, sock2, sock3;
9218 WSAEVENT event2, event3;
9219 HANDLE io_port;
9220 ULONG_PTR key;
9221 int acount;
9222 BOOL bret;
9223 int ret;
9224
9225 /* Use gethostbyname to find the list of local network interfaces */
9226 h = gethostbyname("");
9227 if (!h)
9228 {
9229 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, gethostbyname failed with %u\n",
9230 WSAGetLastError());
9231 return;
9232 }
9233 for (acount = 0; h->h_addr_list[acount]; acount++);
9234 if (acount == 0)
9235 {
9236 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
9237 return;
9238 }
9239
9240 net_address.s_addr = *(ULONG *) h->h_addr_list[0];
9241
9242 sock = socket(AF_INET, 0, IPPROTO_TCP);
9243 ok(sock != INVALID_SOCKET, "socket() failed\n");
9244
9245 memset(&bindAddress, 0, sizeof(bindAddress));
9246 bindAddress.sin_family = AF_INET;
9247 bindAddress.sin_addr.s_addr = net_address.s_addr;
9248 SetLastError(0xdeadbeef);
9249 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9250 ok (!ret, "bind() failed with error %d\n", GetLastError());
9251 set_blocking(sock, FALSE);
9252
9253 memset(&overlapped, 0, sizeof(overlapped));
9254 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9255 SetLastError(0xdeadbeef);
9256 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
9257 error = GetLastError();
9258 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error);
9259 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%x\n", error);
9260
9261 CloseHandle(overlapped.hEvent);
9262 closesocket(sock);
9263
9264 sock = socket(AF_INET, 0, IPPROTO_TCP);
9265 ok(sock != INVALID_SOCKET, "socket() failed\n");
9266
9267 SetLastError(0xdeadbeef);
9268 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9269 ok (!ret, "bind() failed with error %d\n", GetLastError());
9270 set_blocking(sock, TRUE);
9271
9272 memset(&overlapped, 0, sizeof(overlapped));
9273 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9274 SetLastError(0xdeadbeef);
9275 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
9276 error = GetLastError();
9277 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error);
9278 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%x\n", error);
9279
9280 CloseHandle(overlapped.hEvent);
9281 closesocket(sock);
9282
9283 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9284 ok(sock != INVALID_SOCKET, "socket() failed\n");
9285
9286 SetLastError(0xdeadbeef);
9287 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9288 ok (!ret, "bind() failed with error %d\n", GetLastError());
9289 set_blocking(sock, FALSE);
9290
9291 memset(&overlapped, 0, sizeof(overlapped));
9292 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9293 SetLastError(0xdeadbeef);
9294 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
9295 error = GetLastError();
9296 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error);
9297 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%x\n", error);
9298
9299 CloseHandle(overlapped.hEvent);
9300 closesocket(sock);
9301
9302 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9303 ok(sock != INVALID_SOCKET, "socket() failed\n");
9304
9305 SetLastError(0xdeadbeef);
9306 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9307 ok (!ret, "bind() failed with error %d\n", GetLastError());
9308 set_blocking(sock, TRUE);
9309
9310 memset(&overlapped, 0, sizeof(overlapped));
9311 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9312 SetLastError(0xdeadbeef);
9313 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
9314 error = GetLastError();
9315 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error);
9316 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%x\n", error);
9317
9318 CloseHandle(overlapped.hEvent);
9319 closesocket(sock);
9320
9321 /* When the socket is overlapped non-blocking and the list change is requested without
9322 * an overlapped structure the error will be different. */
9323 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9324 ok(sock != INVALID_SOCKET, "socket() failed\n");
9325
9326 SetLastError(0xdeadbeef);
9327 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9328 ok (!ret, "bind() failed with error %d\n", GetLastError());
9329 set_blocking(sock, FALSE);
9330
9331 SetLastError(0xdeadbeef);
9332 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
9333 error = GetLastError();
9334 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error);
9335 ok (error == WSAEWOULDBLOCK, "expected 10035, got %d\n", error);
9336
9337 io_port = CreateIoCompletionPort( (HANDLE)sock, NULL, 0, 0 );
9338 ok (io_port != NULL, "failed to create completion port %u\n", GetLastError());
9339
9340 set_blocking(sock, FALSE);
9341 memset(&overlapped, 0, sizeof(overlapped));
9342 SetLastError(0xdeadbeef);
9343 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
9344 error = GetLastError();
9345 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %u\n", error);
9346 ok (error == ERROR_IO_PENDING, "expected ERROR_IO_PENDING got %u\n", error);
9347
9348 olp = (WSAOVERLAPPED *)0xdeadbeef;
9349 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 0 );
9350 ok(!bret, "failed to get completion status %u\n", bret);
9351 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9352 ok(!olp, "Overlapped structure is at %p\n", olp);
9353
9354 closesocket(sock);
9355
9356 olp = (WSAOVERLAPPED *)0xdeadbeef;
9357 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 0 );
9358 ok(!bret, "failed to get completion status %u\n", bret);
9359 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %u\n", GetLastError());
9360 ok(olp == &overlapped, "Overlapped structure is at %p\n", olp);
9361
9362 CloseHandle(io_port);
9363
9364 /* Misuse of the API by using a blocking socket and not using an overlapped structure,
9365 * this leads to a hang forever. */
9366 if (0)
9367 {
9368 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9369
9370 SetLastError(0xdeadbeef);
9371 bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9372
9373 set_blocking(sock, TRUE);
9374 WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
9375 /* hang */
9376
9377 closesocket(sock);
9378 }
9379
9380 if (!winetest_interactive)
9381 {
9382 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
9383 return;
9384 }
9385
9386 /* Bind an overlapped socket to the first found network interface */
9387 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9388 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
9389 sock2 = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9390 ok(sock2 != INVALID_SOCKET, "Expected socket to return a valid socket\n");
9391 sock3 = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9392 ok(sock3 != INVALID_SOCKET, "Expected socket to return a valid socket\n");
9393
9394 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9395 ok(!ret, "bind failed unexpectedly\n");
9396 ret = bind(sock2, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9397 ok(!ret, "bind failed unexpectedly\n");
9398 ret = bind(sock3, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9399 ok(!ret, "bind failed unexpectedly\n");
9400
9401 set_blocking(sock2, FALSE);
9402 set_blocking(sock3, FALSE);
9403
9404 /* Wait for address changes, request that the user connects/disconnects an interface */
9405 memset(&overlapped, 0, sizeof(overlapped));
9406 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9407 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
9408 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
9409 ok(WSAGetLastError() == WSA_IO_PENDING, "Expected pending last error, got %d\n", WSAGetLastError());
9410
9411 ret = WSAIoctl(sock2, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
9412 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
9413 ok(WSAGetLastError() == WSAEWOULDBLOCK, "Expected would block last error, got %d\n", WSAGetLastError());
9414
9415 event2 = WSACreateEvent();
9416 event3 = WSACreateEvent();
9417 ret = WSAEventSelect (sock2, event2, FD_ADDRESS_LIST_CHANGE);
9418 ok(!ret, "WSAEventSelect failed with %d\n", WSAGetLastError());
9419 /* sock3 did not request SIO_ADDRESS_LIST_CHANGE but it is trying to wait anyway */
9420 ret = WSAEventSelect (sock3, event3, FD_ADDRESS_LIST_CHANGE);
9421 ok(!ret, "WSAEventSelect failed with %d\n", WSAGetLastError());
9422
9423 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
9424 " change the ipv4 address of any of the local network interfaces (15 second timeout).\n");
9425 tick = GetTickCount();
9426 ret = WaitForSingleObject(overlapped.hEvent, 15000);
9427 ok(ret == WAIT_OBJECT_0, "failed to get overlapped event %u\n", ret);
9428
9429 ret = WaitForSingleObject(event2, 500);
9430 todo_wine
9431 ok(ret == WAIT_OBJECT_0, "failed to get change event %u\n", ret);
9432
9433 ret = WaitForSingleObject(event3, 500);
9434 ok(ret == WAIT_TIMEOUT, "unexpected change event\n");
9435
9436 trace("Spent %d ms waiting.\n", GetTickCount() - tick);
9437
9438 WSACloseEvent(event2);
9439 WSACloseEvent(event3);
9440
9441 closesocket(sock);
9442 closesocket(sock2);
9443 closesocket(sock3);
9444 }
9445
9446 static void test_synchronous_WSAIoctl(void)
9447 {
9448 HANDLE previous_port, io_port;
9449 WSAOVERLAPPED overlapped, *olp;
9450 SOCKET socket;
9451 ULONG on;
9452 ULONG_PTR key;
9453 DWORD num_bytes;
9454 BOOL ret;
9455 int res;
9456
9457 previous_port = CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 0 );
9458 ok( previous_port != NULL, "failed to create completion port %u\n", GetLastError() );
9459
9460 socket = WSASocketW( AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED );
9461 ok( socket != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError() );
9462
9463 io_port = CreateIoCompletionPort( (HANDLE)socket, previous_port, 0, 0 );
9464 ok( io_port != NULL, "failed to create completion port %u\n", GetLastError() );
9465
9466 on = 1;
9467 memset( &overlapped, 0, sizeof(overlapped) );
9468 res = WSAIoctl( socket, FIONBIO, &on, sizeof(on), NULL, 0, &num_bytes, &overlapped, NULL );
9469 ok( !res, "WSAIoctl failed %d\n", WSAGetLastError() );
9470
9471 ret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 10000 );
9472 ok( ret, "failed to get completion status %u\n", GetLastError() );
9473
9474 CloseHandle( io_port );
9475 closesocket( socket );
9476 CloseHandle( previous_port );
9477 }
9478
9479 #define WM_ASYNCCOMPLETE (WM_USER + 100)
9480 static HWND create_async_message_window(void)
9481 {
9482 static const char class_name[] = "ws2_32 async message window class";
9483
9484 WNDCLASSEXA wndclass;
9485 HWND hWnd;
9486
9487 wndclass.cbSize = sizeof(wndclass);
9488 wndclass.style = CS_HREDRAW | CS_VREDRAW;
9489 wndclass.lpfnWndProc = DefWindowProcA;
9490 wndclass.cbClsExtra = 0;
9491 wndclass.cbWndExtra = 0;
9492 wndclass.hInstance = GetModuleHandleA(NULL);
9493 wndclass.hIcon = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
9494 wndclass.hIconSm = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
9495 wndclass.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
9496 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
9497 wndclass.lpszClassName = class_name;
9498 wndclass.lpszMenuName = NULL;
9499
9500 RegisterClassExA(&wndclass);
9501
9502 hWnd = CreateWindowA(class_name, "ws2_32 async message window", WS_OVERLAPPEDWINDOW,
9503 0, 0, 500, 500, NULL, NULL, GetModuleHandleA(NULL), NULL);
9504 if (!hWnd)
9505 {
9506 ok(0, "failed to create window: %u\n", GetLastError());
9507 return NULL;
9508 }
9509
9510 return hWnd;
9511 }
9512
9513 static void wait_for_async_message(HWND hwnd, HANDLE handle)
9514 {
9515 BOOL ret;
9516 MSG msg;
9517
9518 while ((ret = GetMessageA(&msg, 0, 0, 0)) &&
9519 !(msg.hwnd == hwnd && msg.message == WM_ASYNCCOMPLETE))
9520 {
9521 TranslateMessage(&msg);
9522 DispatchMessageA(&msg);
9523 }
9524
9525 ok(ret, "did not expect WM_QUIT message\n");
9526 ok(msg.wParam == (WPARAM)handle, "expected wParam = %p, got %lx\n", handle, msg.wParam);
9527 }
9528
9529 static void test_WSAAsyncGetServByPort(void)
9530 {
9531 HWND hwnd = create_async_message_window();
9532 HANDLE ret;
9533 char buffer[MAXGETHOSTSTRUCT];
9534
9535 if (!hwnd)
9536 return;
9537
9538 /* FIXME: The asynchronous window messages should be tested. */
9539
9540 /* Parameters are not checked when initiating the asynchronous operation. */
9541 ret = WSAAsyncGetServByPort(NULL, 0, 0, NULL, NULL, 0);
9542 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
9543
9544 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, 0, NULL, NULL, 0);
9545 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
9546 wait_for_async_message(hwnd, ret);
9547
9548 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, htons(80), NULL, NULL, 0);
9549 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
9550 wait_for_async_message(hwnd, ret);
9551
9552 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, htons(80), NULL, buffer, MAXGETHOSTSTRUCT);
9553 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
9554 wait_for_async_message(hwnd, ret);
9555
9556 DestroyWindow(hwnd);
9557 }
9558
9559 static void test_WSAAsyncGetServByName(void)
9560 {
9561 HWND hwnd = create_async_message_window();
9562 HANDLE ret;
9563 char buffer[MAXGETHOSTSTRUCT];
9564
9565 if (!hwnd)
9566 return;
9567
9568 /* FIXME: The asynchronous window messages should be tested. */
9569
9570 /* Parameters are not checked when initiating the asynchronous operation. */
9571 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "", NULL, NULL, 0);
9572 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
9573 wait_for_async_message(hwnd, ret);
9574
9575 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "", "", buffer, MAXGETHOSTSTRUCT);
9576 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
9577 wait_for_async_message(hwnd, ret);
9578
9579 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "http", NULL, NULL, 0);
9580 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
9581 wait_for_async_message(hwnd, ret);
9582
9583 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "http", "tcp", buffer, MAXGETHOSTSTRUCT);
9584 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
9585 wait_for_async_message(hwnd, ret);
9586
9587 DestroyWindow(hwnd);
9588 }
9589
9590 /*
9591 * Provide consistent initialization for the AcceptEx IOCP tests.
9592 */
9593 static SOCKET setup_iocp_src(struct sockaddr_in *bindAddress)
9594 {
9595 SOCKET src, ret = INVALID_SOCKET;
9596 int iret, socklen;
9597
9598 src = socket(AF_INET, SOCK_STREAM, 0);
9599 if (src == INVALID_SOCKET)
9600 {
9601 skip("could not create listener socket, error %d\n", WSAGetLastError());
9602 goto end;
9603 }
9604
9605 memset(bindAddress, 0, sizeof(*bindAddress));
9606 bindAddress->sin_family = AF_INET;
9607 bindAddress->sin_addr.s_addr = inet_addr("127.0.0.1");
9608 iret = bind(src, (struct sockaddr*)bindAddress, sizeof(*bindAddress));
9609 if (iret != 0)
9610 {
9611 skip("failed to bind, error %d\n", WSAGetLastError());
9612 goto end;
9613 }
9614
9615 socklen = sizeof(*bindAddress);
9616 iret = getsockname(src, (struct sockaddr*)bindAddress, &socklen);
9617 if (iret != 0) {
9618 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
9619 goto end;
9620 }
9621
9622 if (set_blocking(src, FALSE))
9623 {
9624 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
9625 goto end;
9626 }
9627
9628 iret = listen(src, 5);
9629 if (iret != 0)
9630 {
9631 skip("listening failed, errno = %d\n", WSAGetLastError());
9632 goto end;
9633 }
9634
9635 ret = src;
9636 end:
9637 if (src != ret && ret == INVALID_SOCKET)
9638 closesocket(src);
9639 return ret;
9640 }
9641
9642 static void test_completion_port(void)
9643 {
9644 HANDLE previous_port, io_port;
9645 WSAOVERLAPPED ov, *olp;
9646 SOCKET src, dest, dup, connector = INVALID_SOCKET;
9647 WSAPROTOCOL_INFOA info;
9648 char buf[1024];
9649 WSABUF bufs;
9650 DWORD num_bytes, flags;
9651 struct linger ling;
9652 int iret;
9653 BOOL bret;
9654 ULONG_PTR key;
9655 struct sockaddr_in bindAddress;
9656 GUID acceptExGuid = WSAID_ACCEPTEX;
9657 LPFN_ACCEPTEX pAcceptEx = NULL;
9658 fd_set fds_recv;
9659
9660 memset(buf, 0, sizeof(buf));
9661 previous_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
9662 ok( previous_port != NULL, "Failed to create completion port %u\n", GetLastError());
9663
9664 memset(&ov, 0, sizeof(ov));
9665
9666 tcp_socketpair(&src, &dest);
9667 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
9668 {
9669 skip("failed to create sockets\n");
9670 goto end;
9671 }
9672
9673 bufs.len = sizeof(buf);
9674 bufs.buf = buf;
9675 flags = 0;
9676
9677 ling.l_onoff = 1;
9678 ling.l_linger = 0;
9679 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
9680 ok(!iret, "Failed to set linger %d\n", GetLastError());
9681
9682 io_port = CreateIoCompletionPort( (HANDLE)dest, previous_port, 125, 0 );
9683 ok(io_port != NULL, "Failed to create completion port %u\n", GetLastError());
9684
9685 SetLastError(0xdeadbeef);
9686
9687 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
9688 ok(iret == SOCKET_ERROR, "WSARecv returned %d\n", iret);
9689 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
9690
9691 Sleep(100);
9692
9693 closesocket(src);
9694 src = INVALID_SOCKET;
9695
9696 SetLastError(0xdeadbeef);
9697 key = 0xdeadbeef;
9698 num_bytes = 0xdeadbeef;
9699 olp = (WSAOVERLAPPED *)0xdeadbeef;
9700
9701 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
9702 todo_wine ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret);
9703 todo_wine ok(GetLastError() == ERROR_NETNAME_DELETED, "Last error was %d\n", GetLastError());
9704 ok(key == 125, "Key is %lu\n", key);
9705 ok(num_bytes == 0, "Number of bytes received is %u\n", num_bytes);
9706 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
9707
9708 SetLastError(0xdeadbeef);
9709 key = 0xdeadbeef;
9710 num_bytes = 0xdeadbeef;
9711 olp = (WSAOVERLAPPED *)0xdeadbeef;
9712
9713 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
9714 ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret );
9715 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9716 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9717 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9718 ok(!olp, "Overlapped structure is at %p\n", olp);
9719
9720 if (dest != INVALID_SOCKET)
9721 closesocket(dest);
9722
9723 memset(&ov, 0, sizeof(ov));
9724
9725 tcp_socketpair(&src, &dest);
9726 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
9727 {
9728 skip("failed to create sockets\n");
9729 goto end;
9730 }
9731
9732 bufs.len = sizeof(buf);
9733 bufs.buf = buf;
9734 flags = 0;
9735
9736 ling.l_onoff = 1;
9737 ling.l_linger = 0;
9738 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
9739 ok(!iret, "Failed to set linger %d\n", GetLastError());
9740
9741 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 125, 0);
9742 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9743
9744 set_blocking(dest, FALSE);
9745
9746 closesocket(src);
9747 src = INVALID_SOCKET;
9748
9749 Sleep(100);
9750
9751 num_bytes = 0xdeadbeef;
9752 SetLastError(0xdeadbeef);
9753
9754 iret = WSASend(dest, &bufs, 1, &num_bytes, 0, &ov, NULL);
9755 ok(iret == SOCKET_ERROR, "WSASend failed - %d\n", iret);
9756 ok(GetLastError() == WSAECONNRESET, "Last error was %d\n", GetLastError());
9757 ok(num_bytes == 0xdeadbeef, "Managed to send %d\n", num_bytes);
9758
9759 SetLastError(0xdeadbeef);
9760 key = 0xdeadbeef;
9761 num_bytes = 0xdeadbeef;
9762 olp = (WSAOVERLAPPED *)0xdeadbeef;
9763
9764 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9765 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
9766 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9767 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9768 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9769 ok(!olp, "Overlapped structure is at %p\n", olp);
9770
9771 if (dest != INVALID_SOCKET)
9772 closesocket(dest);
9773
9774 /* Test IOCP response on successful immediate read. */
9775 tcp_socketpair(&src, &dest);
9776 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
9777 {
9778 skip("failed to create sockets\n");
9779 goto end;
9780 }
9781
9782 bufs.len = sizeof(buf);
9783 bufs.buf = buf;
9784 flags = 0;
9785 SetLastError(0xdeadbeef);
9786
9787 iret = WSASend(src, &bufs, 1, &num_bytes, 0, &ov, NULL);
9788 ok(!iret, "WSASend failed - %d, last error %u\n", iret, GetLastError());
9789 ok(num_bytes == sizeof(buf), "Managed to send %d\n", num_bytes);
9790
9791 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 125, 0);
9792 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9793 set_blocking(dest, FALSE);
9794
9795 FD_ZERO(&fds_recv);
9796 FD_SET(dest, &fds_recv);
9797 select(dest + 1, &fds_recv, NULL, NULL, NULL);
9798
9799 num_bytes = 0xdeadbeef;
9800 flags = 0;
9801
9802 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
9803 ok(!iret, "WSARecv failed - %d, last error %u\n", iret, GetLastError());
9804 ok(num_bytes == sizeof(buf), "Managed to read %d\n", num_bytes);
9805
9806 SetLastError(0xdeadbeef);
9807 key = 0xdeadbeef;
9808 num_bytes = 0xdeadbeef;
9809 olp = (WSAOVERLAPPED *)0xdeadbeef;
9810
9811 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9812 ok(bret == TRUE, "failed to get completion status %u\n", bret);
9813 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9814 ok(key == 125, "Key is %lu\n", key);
9815 ok(num_bytes == sizeof(buf), "Number of bytes transferred is %u\n", num_bytes);
9816 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
9817
9818 /* Test IOCP response on graceful shutdown. */
9819 closesocket(src);
9820
9821 FD_ZERO(&fds_recv);
9822 FD_SET(dest, &fds_recv);
9823 select(dest + 1, &fds_recv, NULL, NULL, NULL);
9824
9825 num_bytes = 0xdeadbeef;
9826 flags = 0;
9827 memset(&ov, 0, sizeof(ov));
9828
9829 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
9830 ok(!iret, "WSARecv failed - %d, last error %u\n", iret, GetLastError());
9831 ok(!num_bytes, "Managed to read %d\n", num_bytes);
9832
9833 SetLastError(0xdeadbeef);
9834 key = 0xdeadbeef;
9835 num_bytes = 0xdeadbeef;
9836 olp = (WSAOVERLAPPED *)0xdeadbeef;
9837
9838 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9839 ok(bret == TRUE, "failed to get completion status %u\n", bret);
9840 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9841 ok(key == 125, "Key is %lu\n", key);
9842 ok(!num_bytes, "Number of bytes transferred is %u\n", num_bytes);
9843 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
9844
9845 closesocket(src);
9846 src = INVALID_SOCKET;
9847 closesocket(dest);
9848 dest = INVALID_SOCKET;
9849
9850 /* Test IOCP response on hard shutdown. This was the condition that triggered
9851 * a crash in an actual app (bug 38980). */
9852 tcp_socketpair(&src, &dest);
9853 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
9854 {
9855 skip("failed to create sockets\n");
9856 goto end;
9857 }
9858
9859 bufs.len = sizeof(buf);
9860 bufs.buf = buf;
9861 flags = 0;
9862 memset(&ov, 0, sizeof(ov));
9863
9864 ling.l_onoff = 1;
9865 ling.l_linger = 0;
9866 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
9867 ok(!iret, "Failed to set linger %d\n", GetLastError());
9868
9869 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 125, 0);
9870 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9871 set_blocking(dest, FALSE);
9872
9873 closesocket(src);
9874 src = INVALID_SOCKET;
9875
9876 FD_ZERO(&fds_recv);
9877 FD_SET(dest, &fds_recv);
9878 select(dest + 1, &fds_recv, NULL, NULL, NULL);
9879
9880 num_bytes = 0xdeadbeef;
9881 SetLastError(0xdeadbeef);
9882
9883 /* Somehow a hard shutdown doesn't work on my Linux box. It seems SO_LINGER is ignored. */
9884 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
9885 todo_wine ok(iret == SOCKET_ERROR, "WSARecv failed - %d\n", iret);
9886 todo_wine ok(GetLastError() == WSAECONNRESET, "Last error was %d\n", GetLastError());
9887 todo_wine ok(num_bytes == 0xdeadbeef, "Managed to read %d\n", num_bytes);
9888
9889 SetLastError(0xdeadbeef);
9890 key = 0xdeadbeef;
9891 num_bytes = 0xdeadbeef;
9892 olp = (WSAOVERLAPPED *)0xdeadbeef;
9893
9894 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9895 todo_wine ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
9896 todo_wine ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9897 todo_wine ok(key == 0xdeadbeef, "Key is %lu\n", key);
9898 todo_wine ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9899 todo_wine ok(!olp, "Overlapped structure is at %p\n", olp);
9900
9901 closesocket(dest);
9902
9903 /* Test reading from a non-connected socket, mostly because the above test is marked todo. */
9904 dest = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9905 ok(dest != INVALID_SOCKET, "socket() failed\n");
9906
9907 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 125, 0);
9908 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9909 set_blocking(dest, FALSE);
9910
9911 num_bytes = 0xdeadbeef;
9912 SetLastError(0xdeadbeef);
9913 memset(&ov, 0, sizeof(ov));
9914
9915 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
9916 ok(iret == SOCKET_ERROR, "WSARecv failed - %d\n", iret);
9917 ok(GetLastError() == WSAENOTCONN, "Last error was %d\n", GetLastError());
9918 ok(num_bytes == 0xdeadbeef, "Managed to read %d\n", num_bytes);
9919
9920 SetLastError(0xdeadbeef);
9921 key = 0xdeadbeef;
9922 num_bytes = 0xdeadbeef;
9923 olp = (WSAOVERLAPPED *)0xdeadbeef;
9924
9925 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9926 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
9927 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9928 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9929 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9930 ok(!olp, "Overlapped structure is at %p\n", olp);
9931
9932 num_bytes = 0xdeadbeef;
9933 closesocket(dest);
9934
9935 dest = socket(AF_INET, SOCK_STREAM, 0);
9936 if (dest == INVALID_SOCKET)
9937 {
9938 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
9939 goto end;
9940 }
9941
9942 iret = WSAIoctl(dest, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
9943 &pAcceptEx, sizeof(pAcceptEx), &num_bytes, NULL, NULL);
9944 if (iret)
9945 {
9946 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret, WSAGetLastError());
9947 goto end;
9948 }
9949
9950 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
9951
9952 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
9953 goto end;
9954
9955 SetLastError(0xdeadbeef);
9956
9957 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
9958 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9959 &num_bytes, &ov);
9960 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
9961 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
9962
9963 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
9964 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9965
9966 closesocket(src);
9967 src = INVALID_SOCKET;
9968
9969 SetLastError(0xdeadbeef);
9970 key = 0xdeadbeef;
9971 num_bytes = 0xdeadbeef;
9972 olp = (WSAOVERLAPPED *)0xdeadbeef;
9973
9974 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
9975 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9976 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
9977 ok(key == 125, "Key is %lu\n", key);
9978 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
9979 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
9980 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
9981
9982 SetLastError(0xdeadbeef);
9983 key = 0xdeadbeef;
9984 num_bytes = 0xdeadbeef;
9985 olp = (WSAOVERLAPPED *)0xdeadbeef;
9986 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9987 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9988 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9989 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9990 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9991 ok(!olp, "Overlapped structure is at %p\n", olp);
9992
9993 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
9994
9995 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
9996 goto end;
9997
9998 SetLastError(0xdeadbeef);
9999
10000 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
10001 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10002
10003 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10004 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10005 &num_bytes, &ov);
10006 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10007 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
10008
10009 closesocket(src);
10010 src = INVALID_SOCKET;
10011
10012 SetLastError(0xdeadbeef);
10013 key = 0xdeadbeef;
10014 num_bytes = 0xdeadbeef;
10015 olp = (WSAOVERLAPPED *)0xdeadbeef;
10016
10017 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10018 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10019 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
10020 ok(key == 125, "Key is %lu\n", key);
10021 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
10022 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10023 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
10024
10025 SetLastError(0xdeadbeef);
10026 key = 0xdeadbeef;
10027 num_bytes = 0xdeadbeef;
10028 olp = (WSAOVERLAPPED *)0xdeadbeef;
10029 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10030 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10031 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10032 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10033 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10034 ok(!olp, "Overlapped structure is at %p\n", olp);
10035
10036 /* Test IOCP with duplicated handle */
10037
10038 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
10039 goto end;
10040
10041 SetLastError(0xdeadbeef);
10042
10043 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
10044 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10045
10046 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10047 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10048 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10049
10050 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10051 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10052 &num_bytes, &ov);
10053 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10054 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
10055
10056 SetLastError(0xdeadbeef);
10057 key = 0xdeadbeef;
10058 num_bytes = 0xdeadbeef;
10059 olp = (WSAOVERLAPPED *)0xdeadbeef;
10060 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10061 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10062 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10063 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10064 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10065 ok(!olp, "Overlapped structure is at %p\n", olp);
10066
10067 closesocket(src);
10068 src = INVALID_SOCKET;
10069 closesocket(dup);
10070 dup = INVALID_SOCKET;
10071
10072 SetLastError(0xdeadbeef);
10073 key = 0xdeadbeef;
10074 num_bytes = 0xdeadbeef;
10075 olp = (WSAOVERLAPPED *)0xdeadbeef;
10076 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10077 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10078 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
10079 ok(key == 125, "Key is %lu\n", key);
10080 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
10081 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10082 ok(olp && olp->Internal == (ULONG)STATUS_CANCELLED, "Internal status is %lx\n", olp ? olp->Internal : 0);
10083
10084 SetLastError(0xdeadbeef);
10085 key = 0xdeadbeef;
10086 num_bytes = 0xdeadbeef;
10087 olp = (WSAOVERLAPPED *)0xdeadbeef;
10088 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10089 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10090 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10091 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10092 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10093 ok(!olp, "Overlapped structure is at %p\n", olp);
10094
10095 /* Test IOCP with duplicated handle (closing duplicated handle) */
10096
10097 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
10098 goto end;
10099
10100 SetLastError(0xdeadbeef);
10101
10102 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
10103 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10104
10105 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10106 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10107 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10108
10109 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10110 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10111 &num_bytes, &ov);
10112 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10113 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
10114
10115 closesocket(dup);
10116 dup = INVALID_SOCKET;
10117
10118 SetLastError(0xdeadbeef);
10119 key = 0xdeadbeef;
10120 num_bytes = 0xdeadbeef;
10121 olp = (WSAOVERLAPPED *)0xdeadbeef;
10122 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10123 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10124 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10125 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10126 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10127 ok(!olp, "Overlapped structure is at %p\n", olp);
10128
10129 SetLastError(0xdeadbeef);
10130 key = 0xdeadbeef;
10131 num_bytes = 0xdeadbeef;
10132 olp = (WSAOVERLAPPED *)0xdeadbeef;
10133 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10134 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10135 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10136 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10137 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10138 ok(!olp, "Overlapped structure is at %p\n", olp);
10139
10140 closesocket(src);
10141 src = INVALID_SOCKET;
10142
10143 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10144 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10145 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
10146 ok(key == 125, "Key is %lu\n", key);
10147 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
10148 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10149 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
10150
10151 SetLastError(0xdeadbeef);
10152 key = 0xdeadbeef;
10153 num_bytes = 0xdeadbeef;
10154 olp = (WSAOVERLAPPED *)0xdeadbeef;
10155 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10156 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10157 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10158 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10159 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10160 ok(!olp, "Overlapped structure is at %p\n", olp);
10161
10162 /* Test IOCP with duplicated handle (closing original handle) */
10163
10164 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
10165 goto end;
10166
10167 SetLastError(0xdeadbeef);
10168
10169 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
10170 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10171
10172 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10173 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10174 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10175
10176 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10177 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10178 &num_bytes, &ov);
10179 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10180 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
10181
10182 closesocket(src);
10183 src = INVALID_SOCKET;
10184
10185 SetLastError(0xdeadbeef);
10186 key = 0xdeadbeef;
10187 num_bytes = 0xdeadbeef;
10188 olp = (WSAOVERLAPPED *)0xdeadbeef;
10189 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10190 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10191 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10192 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10193 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10194 ok(!olp, "Overlapped structure is at %p\n", olp);
10195
10196 closesocket(dup);
10197 dup = INVALID_SOCKET;
10198
10199 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10200 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10201 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
10202 ok(key == 125, "Key is %lu\n", key);
10203 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
10204 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10205 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
10206
10207 SetLastError(0xdeadbeef);
10208 key = 0xdeadbeef;
10209 num_bytes = 0xdeadbeef;
10210 olp = (WSAOVERLAPPED *)0xdeadbeef;
10211 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10212 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10213 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10214 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10215 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10216 ok(!olp, "Overlapped structure is at %p\n", olp);
10217
10218 /* Test IOCP without AcceptEx */
10219
10220 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
10221 goto end;
10222
10223 SetLastError(0xdeadbeef);
10224
10225 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
10226 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10227
10228 closesocket(src);
10229 src = INVALID_SOCKET;
10230
10231 SetLastError(0xdeadbeef);
10232 key = 0xdeadbeef;
10233 num_bytes = 0xdeadbeef;
10234 olp = (WSAOVERLAPPED *)0xdeadbeef;
10235 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10236 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10237 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10238 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10239 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10240 ok(!olp, "Overlapped structure is at %p\n", olp);
10241
10242 /* */
10243
10244 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
10245 goto end;
10246
10247 connector = socket(AF_INET, SOCK_STREAM, 0);
10248 if (connector == INVALID_SOCKET) {
10249 skip("could not create connector socket, error %d\n", WSAGetLastError());
10250 goto end;
10251 }
10252
10253 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
10254 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10255
10256 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
10257 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10258
10259 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10260 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10261 &num_bytes, &ov);
10262 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10263 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
10264
10265 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10266 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
10267
10268 closesocket(connector);
10269 connector = INVALID_SOCKET;
10270
10271 SetLastError(0xdeadbeef);
10272 key = 0xdeadbeef;
10273 num_bytes = 0xdeadbeef;
10274 olp = (WSAOVERLAPPED *)0xdeadbeef;
10275
10276 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10277 ok(bret == TRUE, "failed to get completion status %u\n", bret);
10278 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
10279 ok(key == 125, "Key is %lu\n", key);
10280 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
10281 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10282 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %lx\n", olp ? olp->Internal : 0);
10283
10284 SetLastError(0xdeadbeef);
10285 key = 0xdeadbeef;
10286 num_bytes = 0xdeadbeef;
10287 olp = (WSAOVERLAPPED *)0xdeadbeef;
10288 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10289 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10290 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10291 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10292 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10293 ok(!olp, "Overlapped structure is at %p\n", olp);
10294
10295 if (dest != INVALID_SOCKET)
10296 closesocket(dest);
10297 if (src != INVALID_SOCKET)
10298 closesocket(dest);
10299
10300 /* */
10301
10302 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
10303 goto end;
10304
10305 dest = socket(AF_INET, SOCK_STREAM, 0);
10306 if (dest == INVALID_SOCKET)
10307 {
10308 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
10309 goto end;
10310 }
10311
10312 connector = socket(AF_INET, SOCK_STREAM, 0);
10313 if (connector == INVALID_SOCKET) {
10314 skip("could not create connector socket, error %d\n", WSAGetLastError());
10315 goto end;
10316 }
10317
10318 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
10319 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10320
10321 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
10322 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10323
10324 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10325 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10326 &num_bytes, &ov);
10327 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10328 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
10329
10330 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10331 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
10332
10333 iret = send(connector, buf, 1, 0);
10334 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
10335
10336 Sleep(100);
10337
10338 closesocket(dest);
10339 dest = INVALID_SOCKET;
10340
10341 SetLastError(0xdeadbeef);
10342 key = 0xdeadbeef;
10343 num_bytes = 0xdeadbeef;
10344 olp = (WSAOVERLAPPED *)0xdeadbeef;
10345
10346 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10347 ok(bret == TRUE, "failed to get completion status %u\n", bret);
10348 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
10349 ok(key == 125, "Key is %lu\n", key);
10350 ok(num_bytes == 1, "Number of bytes transferred is %u\n", num_bytes);
10351 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10352 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %lx\n", olp ? olp->Internal : 0);
10353
10354 SetLastError(0xdeadbeef);
10355 key = 0xdeadbeef;
10356 num_bytes = 0xdeadbeef;
10357 olp = (WSAOVERLAPPED *)0xdeadbeef;
10358 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10359 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10360 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10361 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10362 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10363 ok(!olp, "Overlapped structure is at %p\n", olp);
10364
10365 if (src != INVALID_SOCKET)
10366 closesocket(src);
10367 if (connector != INVALID_SOCKET)
10368 closesocket(connector);
10369
10370 /* */
10371
10372 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
10373 goto end;
10374
10375 dest = socket(AF_INET, SOCK_STREAM, 0);
10376 if (dest == INVALID_SOCKET)
10377 {
10378 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
10379 goto end;
10380 }
10381
10382 connector = socket(AF_INET, SOCK_STREAM, 0);
10383 if (connector == INVALID_SOCKET) {
10384 skip("could not create connector socket, error %d\n", WSAGetLastError());
10385 goto end;
10386 }
10387
10388 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
10389 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10390
10391 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
10392 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10393
10394 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10395 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10396 &num_bytes, &ov);
10397 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10398 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
10399
10400 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10401 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
10402
10403 closesocket(dest);
10404 dest = INVALID_SOCKET;
10405
10406 SetLastError(0xdeadbeef);
10407 key = 0xdeadbeef;
10408 num_bytes = 0xdeadbeef;
10409 olp = (WSAOVERLAPPED *)0xdeadbeef;
10410
10411 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10412 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10413 todo_wine ok(GetLastError() == ERROR_NETNAME_DELETED ||
10414 GetLastError() == ERROR_OPERATION_ABORTED ||
10415 GetLastError() == ERROR_CONNECTION_ABORTED ||
10416 GetLastError() == ERROR_PIPE_NOT_CONNECTED /* win 2000 */,
10417 "Last error was %d\n", GetLastError());
10418 ok(key == 125, "Key is %lu\n", key);
10419 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
10420 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10421 todo_wine ok(olp && (olp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT ||
10422 olp->Internal == (ULONG)STATUS_CANCELLED ||
10423 olp->Internal == (ULONG)STATUS_CONNECTION_ABORTED ||
10424 olp->Internal == (ULONG)STATUS_PIPE_DISCONNECTED /* win 2000 */),
10425 "Internal status is %lx\n", olp ? olp->Internal : 0);
10426
10427 SetLastError(0xdeadbeef);
10428 key = 0xdeadbeef;
10429 num_bytes = 0xdeadbeef;
10430 olp = (WSAOVERLAPPED *)0xdeadbeef;
10431 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10432 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10433 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10434 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10435 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10436 ok(!olp, "Overlapped structure is at %p\n", olp);
10437
10438
10439 end:
10440 if (dest != INVALID_SOCKET)
10441 closesocket(dest);
10442 if (src != INVALID_SOCKET)
10443 closesocket(src);
10444 if (connector != INVALID_SOCKET)
10445 closesocket(connector);
10446 CloseHandle(previous_port);
10447 }
10448
10449 static void test_address_list_query(void)
10450 {
10451 SOCKET_ADDRESS_LIST *address_list;
10452 DWORD bytes_returned, size;
10453 unsigned int i;
10454 SOCKET s;
10455 int ret;
10456
10457 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10458 ok(s != INVALID_SOCKET, "Failed to create socket, error %d.\n", WSAGetLastError());
10459
10460 bytes_returned = 0;
10461 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, 0, &bytes_returned, NULL, NULL);
10462 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
10463 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
10464 ok(bytes_returned >= FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]),
10465 "Got unexpected bytes_returned %u.\n", bytes_returned);
10466
10467 size = bytes_returned;
10468 bytes_returned = 0;
10469 address_list = HeapAlloc(GetProcessHeap(), 0, size * 2);
10470 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, size * 2, &bytes_returned, NULL, NULL);
10471 ok(!ret, "Got unexpected ret %d, error %d.\n", ret, WSAGetLastError());
10472 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
10473
10474 bytes_returned = FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[address_list->iAddressCount]);
10475 for (i = 0; i < address_list->iAddressCount; ++i)
10476 {
10477 bytes_returned += address_list->Address[i].iSockaddrLength;
10478 }
10479 ok(size == bytes_returned, "Got unexpected size %u, expected %u.\n", size, bytes_returned);
10480
10481 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, size, NULL, NULL, NULL);
10482 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
10483 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
10484
10485 bytes_returned = 0xdeadbeef;
10486 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, size, &bytes_returned, NULL, NULL);
10487 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
10488 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
10489 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
10490
10491 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, 1, &bytes_returned, NULL, NULL);
10492 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
10493 ok(WSAGetLastError() == WSAEINVAL, "Got unexpected error %d.\n", WSAGetLastError());
10494 ok(bytes_returned == 0, "Got unexpected bytes_returned %u.\n", bytes_returned);
10495
10496 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list,
10497 FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), &bytes_returned, NULL, NULL);
10498 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
10499 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
10500 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
10501
10502 HeapFree(GetProcessHeap(), 0, address_list);
10503 closesocket(s);
10504 }
10505
10506 static DWORD WINAPI inet_ntoa_thread_proc(void *param)
10507 {
10508 ULONG addr;
10509 const char *str;
10510 HANDLE *event = param;
10511
10512 addr = inet_addr("4.3.2.1");
10513 ok(addr == htonl(0x04030201), "expected 0x04030201, got %08x\n", addr);
10514 str = inet_ntoa(*(struct in_addr *)&addr);
10515 ok(!strcmp(str, "4.3.2.1"), "expected 4.3.2.1, got %s\n", str);
10516
10517 SetEvent(event[0]);
10518 WaitForSingleObject(event[1], 3000);
10519
10520 return 0;
10521 }
10522
10523 static void test_inet_ntoa(void)
10524 {
10525 ULONG addr;
10526 const char *str;
10527 HANDLE thread, event[2];
10528 DWORD tid;
10529
10530 addr = inet_addr("1.2.3.4");
10531 ok(addr == htonl(0x01020304), "expected 0x01020304, got %08x\n", addr);
10532 str = inet_ntoa(*(struct in_addr *)&addr);
10533 ok(!strcmp(str, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str);
10534
10535 event[0] = CreateEventW(NULL, TRUE, FALSE, NULL);
10536 event[1] = CreateEventW(NULL, TRUE, FALSE, NULL);
10537
10538 thread = CreateThread(NULL, 0, inet_ntoa_thread_proc, event, 0, &tid);
10539 WaitForSingleObject(event[0], 3000);
10540
10541 ok(!strcmp(str, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str);
10542
10543 SetEvent(event[1]);
10544 WaitForSingleObject(thread, 3000);
10545
10546 CloseHandle(event[0]);
10547 CloseHandle(event[1]);
10548 CloseHandle(thread);
10549 }
10550
10551 static void test_WSALookupService(void)
10552 {
10553 char buffer[4096], strbuff[128];
10554 WSAQUERYSETW *qs = NULL;
10555 HANDLE hnd;
10556 PNLA_BLOB netdata;
10557 int ret;
10558 DWORD error, offset, bsize;
10559
10560 if (!pWSALookupServiceBeginW || !pWSALookupServiceEnd || !pWSALookupServiceNextW)
10561 {
10562 win_skip("WSALookupServiceBeginW or WSALookupServiceEnd or WSALookupServiceNextW not found\n");
10563 return;
10564 }
10565
10566 qs = (WSAQUERYSETW *)buffer;
10567 memset(qs, 0, sizeof(*qs));
10568
10569 /* invalid parameter tests */
10570 ret = pWSALookupServiceBeginW(NULL, 0, &hnd);
10571 error = WSAGetLastError();
10572 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
10573 todo_wine
10574 ok(error == WSAEFAULT, "expected 10014, got %d\n", error);
10575
10576 ret = pWSALookupServiceBeginW(qs, 0, NULL);
10577 error = WSAGetLastError();
10578 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
10579 todo_wine
10580 ok(error == WSAEFAULT, "expected 10014, got %d\n", error);
10581
10582 ret = pWSALookupServiceBeginW(qs, 0, &hnd);
10583 error = WSAGetLastError();
10584 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
10585 todo_wine
10586 ok(error == WSAEINVAL
10587 || broken(error == ERROR_INVALID_PARAMETER) /* == XP */
10588 || broken(error == WSAEFAULT) /* == NT */
10589 || broken(error == WSASERVICE_NOT_FOUND) /* == 2000 */,
10590 "expected 10022, got %d\n", error);
10591
10592 ret = pWSALookupServiceEnd(NULL);
10593 error = WSAGetLastError();
10594 todo_wine
10595 ok(ret == SOCKET_ERROR, "WSALookupServiceEnd should have failed\n");
10596 todo_wine
10597 ok(error == ERROR_INVALID_HANDLE, "expected 6, got %d\n", error);
10598
10599 /* standard network list query */
10600 qs->dwSize = sizeof(*qs);
10601 hnd = (HANDLE)0xdeadbeef;
10602 ret = pWSALookupServiceBeginW(qs, LUP_RETURN_ALL | LUP_DEEP, &hnd);
10603 error = WSAGetLastError();
10604 if(ret && error == ERROR_INVALID_PARAMETER)
10605 {
10606 win_skip("the current WSALookupServiceBeginW test is not supported in win <= 2000\n");
10607 return;
10608 }
10609
10610 todo_wine
10611 ok(!ret, "WSALookupServiceBeginW failed unexpectedly with error %d\n", error);
10612 todo_wine
10613 ok(hnd != (HANDLE)0xdeadbeef, "Handle was not filled\n");
10614
10615 offset = 0;
10616 do
10617 {
10618 memset(qs, 0, sizeof(*qs));
10619 bsize = sizeof(buffer);
10620
10621 if (pWSALookupServiceNextW(hnd, 0, &bsize, qs) == SOCKET_ERROR)
10622 {
10623 error = WSAGetLastError();
10624 if (error == WSA_E_NO_MORE) break;
10625 ok(0, "Error %d happened while listing services\n", error);
10626 break;
10627 }
10628
10629 WideCharToMultiByte(CP_ACP, 0, qs->lpszServiceInstanceName, -1,
10630 strbuff, sizeof(strbuff), NULL, NULL);
10631 trace("Network Name: %s\n", strbuff);
10632
10633 /* network data is written in the blob field */
10634 if (qs->lpBlob)
10635 {
10636 /* each network may have multiple NLA_BLOB information structures */
10637 do
10638 {
10639 netdata = (PNLA_BLOB) &qs->lpBlob->pBlobData[offset];
10640 switch (netdata->header.type)
10641 {
10642 case NLA_RAW_DATA:
10643 trace("\tNLA Data Type: NLA_RAW_DATA\n");
10644 break;
10645 case NLA_INTERFACE:
10646 trace("\tNLA Data Type: NLA_INTERFACE\n");
10647 trace("\t\tType: %d\n", netdata->data.interfaceData.dwType);
10648 trace("\t\tSpeed: %d\n", netdata->data.interfaceData.dwSpeed);
10649 trace("\t\tAdapter Name: %s\n", netdata->data.interfaceData.adapterName);
10650 break;
10651 case NLA_802_1X_LOCATION:
10652 trace("\tNLA Data Type: NLA_802_1X_LOCATION\n");
10653 trace("\t\tInformation: %s\n", netdata->data.locationData.information);
10654 break;
10655 case NLA_CONNECTIVITY:
10656 switch (netdata->data.connectivity.type)
10657 {
10658 case NLA_NETWORK_AD_HOC:
10659 trace("\t\tNetwork Type: AD HOC\n");
10660 break;
10661 case NLA_NETWORK_MANAGED:
10662 trace("\t\tNetwork Type: Managed\n");
10663 break;
10664 case NLA_NETWORK_UNMANAGED:
10665 trace("\t\tNetwork Type: Unmanaged\n");
10666 break;
10667 case NLA_NETWORK_UNKNOWN:
10668 trace("\t\tNetwork Type: Unknown\n");
10669 }
10670 switch (netdata->data.connectivity.internet)
10671 {
10672 case NLA_INTERNET_NO:
10673 trace("\t\tInternet connectivity: No\n");
10674 break;
10675 case NLA_INTERNET_YES:
10676 trace("\t\tInternet connectivity: Yes\n");
10677 break;
10678 case NLA_INTERNET_UNKNOWN:
10679 trace("\t\tInternet connectivity: Unknown\n");
10680 break;
10681 }
10682 break;
10683 case NLA_ICS:
10684 trace("\tNLA Data Type: NLA_ICS\n");
10685 trace("\t\tSpeed: %d\n",
10686 netdata->data.ICS.remote.speed);
10687 trace("\t\tType: %d\n",
10688 netdata->data.ICS.remote.type);
10689 trace("\t\tState: %d\n",
10690 netdata->data.ICS.remote.state);
10691 WideCharToMultiByte(CP_ACP, 0, netdata->data.ICS.remote.machineName, -1,
10692 strbuff, sizeof(strbuff), NULL, NULL);
10693 trace("\t\tMachine Name: %s\n", strbuff);
10694 WideCharToMultiByte(CP_ACP, 0, netdata->data.ICS.remote.sharedAdapterName, -1,
10695 strbuff, sizeof(strbuff), NULL, NULL);
10696 trace("\t\tShared Adapter Name: %s\n", strbuff);
10697 break;
10698 default:
10699 trace("\tNLA Data Type: Unknown\n");
10700 break;
10701 }
10702 }
10703 while (offset);
10704 }
10705 }
10706 while (1);
10707
10708 ret = pWSALookupServiceEnd(hnd);
10709 ok(!ret, "WSALookupServiceEnd failed unexpectedly\n");
10710 }
10711
10712 static void test_WSAEnumNameSpaceProvidersA(void)
10713 {
10714 LPWSANAMESPACE_INFOA name = NULL;
10715 DWORD ret, error, blen = 0, i;
10716 if (!pWSAEnumNameSpaceProvidersA)
10717 {
10718 win_skip("WSAEnumNameSpaceProvidersA not found\n");
10719 return;
10720 }
10721
10722 SetLastError(0xdeadbeef);
10723 ret = pWSAEnumNameSpaceProvidersA(&blen, name);
10724 error = WSAGetLastError();
10725 todo_wine
10726 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
10727 todo_wine
10728 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
10729
10730 /* Invalid parameter tests */
10731 SetLastError(0xdeadbeef);
10732 ret = pWSAEnumNameSpaceProvidersA(NULL, name);
10733 error = WSAGetLastError();
10734 todo_wine
10735 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
10736 todo_wine
10737 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
10738
10739 SetLastError(0xdeadbeef);
10740 ret = pWSAEnumNameSpaceProvidersA(NULL, NULL);
10741 error = WSAGetLastError();
10742 todo_wine
10743 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
10744 todo_wine
10745 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
10746
10747 SetLastError(0xdeadbeef);
10748 ret = pWSAEnumNameSpaceProvidersA(&blen, NULL);
10749 error = WSAGetLastError();
10750 todo_wine
10751 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
10752 todo_wine
10753 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
10754
10755 name = HeapAlloc(GetProcessHeap(), 0, blen);
10756 if (!name)
10757 {
10758 skip("Failed to alloc memory\n");
10759 return;
10760 }
10761
10762 ret = pWSAEnumNameSpaceProvidersA(&blen, name);
10763 todo_wine
10764 ok(ret > 0, "Expected more than zero name space providers\n");
10765
10766 for (i = 0;i < ret; i++)
10767 {
10768 trace("Name space Identifier (%p): %s\n", name[i].lpszIdentifier,
10769 name[i].lpszIdentifier);
10770 switch (name[i].dwNameSpace)
10771 {
10772 case NS_DNS:
10773 trace("\tName space ID: NS_DNS (%u)\n", name[i].dwNameSpace);
10774 break;
10775 case NS_NLA:
10776 trace("\tName space ID: NS_NLA (%u)\n", name[i].dwNameSpace);
10777 break;
10778 default:
10779 trace("\tName space ID: Unknown (%u)\n", name[i].dwNameSpace);
10780 break;
10781 }
10782 trace("\tActive: %d\n", name[i].fActive);
10783 trace("\tVersion: %d\n", name[i].dwVersion);
10784 }
10785
10786 HeapFree(GetProcessHeap(), 0, name);
10787 }
10788
10789 static void test_WSAEnumNameSpaceProvidersW(void)
10790 {
10791 LPWSANAMESPACE_INFOW name = NULL;
10792 DWORD ret, error, blen = 0, i;
10793 if (!pWSAEnumNameSpaceProvidersW)
10794 {
10795 win_skip("WSAEnumNameSpaceProvidersW not found\n");
10796 return;
10797 }
10798
10799 SetLastError(0xdeadbeef);
10800 ret = pWSAEnumNameSpaceProvidersW(&blen, name);
10801 error = WSAGetLastError();
10802 todo_wine
10803 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
10804 todo_wine
10805 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
10806
10807 /* Invalid parameter tests */
10808 SetLastError(0xdeadbeef);
10809 ret = pWSAEnumNameSpaceProvidersW(NULL, name);
10810 error = WSAGetLastError();
10811 todo_wine
10812 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
10813 todo_wine
10814 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
10815
10816 SetLastError(0xdeadbeef);
10817 ret = pWSAEnumNameSpaceProvidersW(NULL, NULL);
10818 error = WSAGetLastError();
10819 todo_wine
10820 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
10821 todo_wine
10822 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
10823
10824 SetLastError(0xdeadbeef);
10825 ret = pWSAEnumNameSpaceProvidersW(&blen, NULL);
10826 error = WSAGetLastError();
10827 todo_wine
10828 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
10829 todo_wine
10830 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
10831
10832 name = HeapAlloc(GetProcessHeap(), 0, blen);
10833 if (!name)
10834 {
10835 skip("Failed to alloc memory\n");
10836 return;
10837 }
10838
10839 ret = pWSAEnumNameSpaceProvidersW(&blen, name);
10840 todo_wine
10841 ok(ret > 0, "Expected more than zero name space providers\n");
10842
10843 for (i = 0;i < ret; i++)
10844 {
10845 trace("Name space Identifier (%p): %s\n", name[i].lpszIdentifier,
10846 wine_dbgstr_w(name[i].lpszIdentifier));
10847 switch (name[i].dwNameSpace)
10848 {
10849 case NS_DNS:
10850 trace("\tName space ID: NS_DNS (%u)\n", name[i].dwNameSpace);
10851 break;
10852 case NS_NLA:
10853 trace("\tName space ID: NS_NLA (%u)\n", name[i].dwNameSpace);
10854 break;
10855 default:
10856 trace("\tName space ID: Unknown (%u)\n", name[i].dwNameSpace);
10857 break;
10858 }
10859 trace("\tActive: %d\n", name[i].fActive);
10860 trace("\tVersion: %d\n", name[i].dwVersion);
10861 }
10862
10863 HeapFree(GetProcessHeap(), 0, name);
10864 }
10865
10866 static void sync_read(SOCKET src, SOCKET dst)
10867 {
10868 int ret;
10869 char data[512];
10870
10871 ret = send(dst, "Hello World!", 12, 0);
10872 ok(ret == 12, "send returned %d\n", ret);
10873
10874 memset(data, 0, sizeof(data));
10875 ret = recv(src, data, sizeof(data), 0);
10876 ok(ret == 12, "expected 12, got %d\n", ret);
10877 ok(!memcmp(data, "Hello World!", 12), "got %u bytes (%*s)\n", ret, ret, data);
10878 }
10879
10880 static void iocp_async_read(SOCKET src, SOCKET dst)
10881 {
10882 HANDLE port;
10883 WSAOVERLAPPED ovl, *ovl_iocp;
10884 WSABUF buf;
10885 int ret;
10886 char data[512];
10887 DWORD flags, bytes;
10888 ULONG_PTR key;
10889
10890 memset(data, 0, sizeof(data));
10891 memset(&ovl, 0, sizeof(ovl));
10892
10893 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
10894 ok(port != 0, "CreateIoCompletionPort error %u\n", GetLastError());
10895
10896 buf.len = sizeof(data);
10897 buf.buf = data;
10898 bytes = 0xdeadbeef;
10899 flags = 0;
10900 SetLastError(0xdeadbeef);
10901 ret = WSARecv(src, &buf, 1, &bytes, &flags, &ovl, NULL);
10902 ok(ret == SOCKET_ERROR, "got %d\n", ret);
10903 ok(GetLastError() == ERROR_IO_PENDING, "got %u\n", GetLastError());
10904 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
10905
10906 bytes = 0xdeadbeef;
10907 key = 0xdeadbeef;
10908 ovl_iocp = (void *)0xdeadbeef;
10909 SetLastError(0xdeadbeef);
10910 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
10911 ok(!ret, "got %d\n", ret);
10912 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
10913 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
10914 ok(key == 0xdeadbeef, "got key %#lx\n", key);
10915 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
10916
10917 ret = send(dst, "Hello World!", 12, 0);
10918 ok(ret == 12, "send returned %d\n", ret);
10919
10920 bytes = 0xdeadbeef;
10921 key = 0xdeadbeef;
10922 ovl_iocp = NULL;
10923 SetLastError(0xdeadbeef);
10924 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
10925 ok(ret, "got %d\n", ret);
10926 ok(bytes == 12, "got bytes %u\n", bytes);
10927 ok(key == 0x12345678, "got key %#lx\n", key);
10928 ok(ovl_iocp == &ovl, "got ovl %p\n", ovl_iocp);
10929 if (ovl_iocp)
10930 {
10931 ok(ovl_iocp->InternalHigh == 12, "got %#lx\n", ovl_iocp->InternalHigh);
10932 ok(!ovl_iocp->Internal , "got %#lx\n", ovl_iocp->Internal);
10933 ok(!memcmp(data, "Hello World!", 12), "got %u bytes (%*s)\n", bytes, bytes, data);
10934 }
10935
10936 bytes = 0xdeadbeef;
10937 key = 0xdeadbeef;
10938 ovl_iocp = (void *)0xdeadbeef;
10939 SetLastError(0xdeadbeef);
10940 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
10941 ok(!ret, "got %d\n", ret);
10942 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
10943 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
10944 ok(key == 0xdeadbeef, "got key %#lx\n", key);
10945 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
10946
10947 CloseHandle(port);
10948 }
10949
10950 static void iocp_async_read_closesocket(SOCKET src, int how_to_close)
10951 {
10952 HANDLE port;
10953 WSAOVERLAPPED ovl, *ovl_iocp;
10954 WSABUF buf;
10955 int ret;
10956 char data[512];
10957 DWORD flags, bytes;
10958 ULONG_PTR key;
10959 HWND hwnd;
10960 MSG msg;
10961
10962 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
10963 0, 0, 0, 0, NULL, NULL, 0, NULL);
10964 ok(hwnd != 0, "CreateWindowEx failed\n");
10965
10966 ret = WSAAsyncSelect(src, hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
10967 ok(!ret, "got %d\n", ret);
10968
10969 Sleep(100);
10970 memset(&msg, 0, sizeof(msg));
10971 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10972 ok(ret, "got %d\n", ret);
10973 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
10974 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
10975 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
10976 ok(msg.lParam == 2, "got %08lx\n", msg.lParam);
10977
10978 memset(data, 0, sizeof(data));
10979 memset(&ovl, 0, sizeof(ovl));
10980
10981 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
10982 ok(port != 0, "CreateIoCompletionPort error %u\n", GetLastError());
10983
10984 Sleep(100);
10985 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
10986 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
10987
10988 buf.len = sizeof(data);
10989 buf.buf = data;
10990 bytes = 0xdeadbeef;
10991 flags = 0;
10992 SetLastError(0xdeadbeef);
10993 ret = WSARecv(src, &buf, 1, &bytes, &flags, &ovl, NULL);
10994 ok(ret == SOCKET_ERROR, "got %d\n", ret);
10995 ok(GetLastError() == ERROR_IO_PENDING, "got %u\n", GetLastError());
10996 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
10997
10998 Sleep(100);
10999 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11000 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11001
11002 bytes = 0xdeadbeef;
11003 key = 0xdeadbeef;
11004 ovl_iocp = (void *)0xdeadbeef;
11005 SetLastError(0xdeadbeef);
11006 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11007 ok(!ret, "got %d\n", ret);
11008 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
11009 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11010 ok(key == 0xdeadbeef, "got key %#lx\n", key);
11011 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11012
11013 Sleep(100);
11014 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11015 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11016
11017 switch (how_to_close)
11018 {
11019 case 0:
11020 closesocket(src);
11021 break;
11022 case 1:
11023 CloseHandle((HANDLE)src);
11024 break;
11025 case 2:
11026 pNtClose((HANDLE)src);
11027 break;
11028 default:
11029 ok(0, "wrong value %d\n", how_to_close);
11030 break;
11031 }
11032
11033 Sleep(200);
11034 memset(&msg, 0, sizeof(msg));
11035 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11036 switch (how_to_close)
11037 {
11038 case 0:
11039 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11040 break;
11041 case 1:
11042 case 2:
11043 todo_wine
11044 {
11045 ok(ret, "got %d\n", ret);
11046 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11047 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11048 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
11049 ok(msg.lParam == 0x20, "got %08lx\n", msg.lParam);
11050 }
11051 break;
11052 default:
11053 ok(0, "wrong value %d\n", how_to_close);
11054 break;
11055 }
11056
11057 bytes = 0xdeadbeef;
11058 key = 0xdeadbeef;
11059 ovl_iocp = NULL;
11060 SetLastError(0xdeadbeef);
11061 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11062 ok(!ret, "got %d\n", ret);
11063 todo_wine
11064 ok(GetLastError() == ERROR_CONNECTION_ABORTED || GetLastError() == ERROR_NETNAME_DELETED /* XP */, "got %u\n", GetLastError());
11065 ok(!bytes, "got bytes %u\n", bytes);
11066 ok(key == 0x12345678, "got key %#lx\n", key);
11067 ok(ovl_iocp == &ovl, "got ovl %p\n", ovl_iocp);
11068 if (ovl_iocp)
11069 {
11070 ok(!ovl_iocp->InternalHigh, "got %#lx\n", ovl_iocp->InternalHigh);
11071 todo_wine
11072 ok(ovl_iocp->Internal == (ULONG)STATUS_CONNECTION_ABORTED || ovl_iocp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT /* XP */, "got %#lx\n", ovl_iocp->Internal);
11073 }
11074
11075 bytes = 0xdeadbeef;
11076 key = 0xdeadbeef;
11077 ovl_iocp = (void *)0xdeadbeef;
11078 SetLastError(0xdeadbeef);
11079 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11080 ok(!ret, "got %d\n", ret);
11081 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
11082 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11083 ok(key == 0xdeadbeef, "got key %#lx\n", key);
11084 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11085
11086 CloseHandle(port);
11087
11088 DestroyWindow(hwnd);
11089 }
11090
11091 static void iocp_async_closesocket(SOCKET src)
11092 {
11093 HANDLE port;
11094 WSAOVERLAPPED *ovl_iocp;
11095 int ret;
11096 DWORD bytes;
11097 ULONG_PTR key;
11098 HWND hwnd;
11099 MSG msg;
11100
11101 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
11102 0, 0, 0, 0, NULL, NULL, 0, NULL);
11103 ok(hwnd != 0, "CreateWindowEx failed\n");
11104
11105 ret = WSAAsyncSelect(src, hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
11106 ok(!ret, "got %d\n", ret);
11107
11108 Sleep(100);
11109 memset(&msg, 0, sizeof(msg));
11110 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11111 ok(ret, "got %d\n", ret);
11112 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11113 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11114 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
11115 ok(msg.lParam == 2, "got %08lx\n", msg.lParam);
11116
11117 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11118 ok(port != 0, "CreateIoCompletionPort error %u\n", GetLastError());
11119
11120 Sleep(100);
11121 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11122 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11123
11124 bytes = 0xdeadbeef;
11125 key = 0xdeadbeef;
11126 ovl_iocp = (void *)0xdeadbeef;
11127 SetLastError(0xdeadbeef);
11128 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11129 ok(!ret, "got %d\n", ret);
11130 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
11131 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11132 ok(key == 0xdeadbeef, "got key %lu\n", key);
11133 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11134
11135 Sleep(100);
11136 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11137 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11138
11139 closesocket(src);
11140
11141 Sleep(100);
11142 memset(&msg, 0, sizeof(msg));
11143 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11144 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11145
11146 bytes = 0xdeadbeef;
11147 key = 0xdeadbeef;
11148 ovl_iocp = (void *)0xdeadbeef;
11149 SetLastError(0xdeadbeef);
11150 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11151 ok(!ret, "got %d\n", ret);
11152 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
11153 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11154 ok(key == 0xdeadbeef, "got key %lu\n", key);
11155 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11156
11157 CloseHandle(port);
11158
11159 DestroyWindow(hwnd);
11160 }
11161
11162 struct wsa_async_select_info
11163 {
11164 SOCKET sock;
11165 HWND hwnd;
11166 };
11167
11168 static DWORD WINAPI wsa_async_select_thread(void *param)
11169 {
11170 struct wsa_async_select_info *info = param;
11171 int ret;
11172
11173 ret = WSAAsyncSelect(info->sock, info->hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
11174 ok(!ret, "got %d\n", ret);
11175
11176 return 0;
11177 }
11178
11179 struct wsa_recv_info
11180 {
11181 SOCKET sock;
11182 WSABUF wsa_buf;
11183 WSAOVERLAPPED ovl;
11184 };
11185
11186 static DWORD WINAPI wsa_recv_thread(void *param)
11187 {
11188 struct wsa_recv_info *info = param;
11189 int ret;
11190 DWORD flags, bytes;
11191
11192 bytes = 0xdeadbeef;
11193 flags = 0;
11194 SetLastError(0xdeadbeef);
11195 ret = WSARecv(info->sock, &info->wsa_buf, 1, &bytes, &flags, &info->ovl, NULL);
11196 ok(ret == SOCKET_ERROR, "got %d\n", ret);
11197 ok(GetLastError() == ERROR_IO_PENDING, "got %u\n", GetLastError());
11198 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11199
11200 return 0;
11201 }
11202
11203 static void iocp_async_read_thread_closesocket(SOCKET src)
11204 {
11205 struct wsa_async_select_info select_info;
11206 struct wsa_recv_info recv_info;
11207 HANDLE port, thread;
11208 WSAOVERLAPPED *ovl_iocp;
11209 int ret;
11210 char data[512];
11211 DWORD bytes, tid;
11212 ULONG_PTR key;
11213 HWND hwnd;
11214 MSG msg;
11215
11216 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
11217 0, 0, 0, 0, NULL, NULL, 0, NULL);
11218 ok(hwnd != 0, "CreateWindowEx failed\n");
11219
11220 select_info.sock = src;
11221 select_info.hwnd = hwnd;
11222 thread = CreateThread(NULL, 0, wsa_async_select_thread, &select_info, 0, &tid);
11223 ok(thread != 0, "CreateThread error %u\n", GetLastError());
11224 ret = WaitForSingleObject(thread, 10000);
11225 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
11226
11227 Sleep(100);
11228 memset(&msg, 0, sizeof(msg));
11229 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11230 ok(ret, "got %d\n", ret);
11231 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11232 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11233 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
11234 ok(msg.lParam == 2, "got %08lx\n", msg.lParam);
11235
11236 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11237 ok(port != 0, "CreateIoCompletionPort error %u\n", GetLastError());
11238
11239 Sleep(100);
11240 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11241 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11242
11243 memset(data, 0, sizeof(data));
11244 memset(&recv_info.ovl, 0, sizeof(recv_info.ovl));
11245 recv_info.sock = src;
11246 recv_info.wsa_buf.len = sizeof(data);
11247 recv_info.wsa_buf.buf = data;
11248 thread = CreateThread(NULL, 0, wsa_recv_thread, &recv_info, 0, &tid);
11249 ok(thread != 0, "CreateThread error %u\n", GetLastError());
11250 ret = WaitForSingleObject(thread, 10000);
11251 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
11252
11253 Sleep(100);
11254 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11255 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11256
11257 bytes = 0xdeadbeef;
11258 key = 0xdeadbeef;
11259 ovl_iocp = (void *)0xdeadbeef;
11260 SetLastError(0xdeadbeef);
11261 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11262 ok(!ret, "got %d\n", ret);
11263 ok(GetLastError() == WAIT_TIMEOUT || broken(GetLastError() == ERROR_OPERATION_ABORTED) /* XP */,
11264 "got %u\n", GetLastError());
11265 if (GetLastError() == WAIT_TIMEOUT)
11266 {
11267 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11268 ok(key == 0xdeadbeef, "got key %lx\n", key);
11269 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11270 }
11271 else /* document XP behaviour */
11272 {
11273 ok(!bytes, "got bytes %u\n", bytes);
11274 ok(key == 0x12345678, "got key %#lx\n", key);
11275 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
11276 if (ovl_iocp)
11277 {
11278 ok(!ovl_iocp->InternalHigh, "got %#lx\n", ovl_iocp->InternalHigh);
11279 ok(ovl_iocp->Internal == STATUS_CANCELLED, "got %#lx\n", ovl_iocp->Internal);
11280 }
11281
11282 closesocket(src);
11283 goto xp_is_broken;
11284 }
11285
11286 Sleep(100);
11287 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11288 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11289
11290 closesocket(src);
11291
11292 Sleep(100);
11293 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11294 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11295
11296 bytes = 0xdeadbeef;
11297 key = 0xdeadbeef;
11298 ovl_iocp = NULL;
11299 SetLastError(0xdeadbeef);
11300 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11301 ok(!ret, "got %d\n", ret);
11302 todo_wine
11303 ok(GetLastError() == ERROR_CONNECTION_ABORTED || GetLastError() == ERROR_NETNAME_DELETED /* XP */, "got %u\n", GetLastError());
11304 ok(!bytes, "got bytes %u\n", bytes);
11305 ok(key == 0x12345678, "got key %#lx\n", key);
11306 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
11307 if (ovl_iocp)
11308 {
11309 ok(!ovl_iocp->InternalHigh, "got %#lx\n", ovl_iocp->InternalHigh);
11310 todo_wine
11311 ok(ovl_iocp->Internal == (ULONG)STATUS_CONNECTION_ABORTED || ovl_iocp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT /* XP */, "got %#lx\n", ovl_iocp->Internal);
11312 }
11313
11314 xp_is_broken:
11315 bytes = 0xdeadbeef;
11316 key = 0xdeadbeef;
11317 ovl_iocp = (void *)0xdeadbeef;
11318 SetLastError(0xdeadbeef);
11319 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11320 ok(!ret, "got %d\n", ret);
11321 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
11322 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11323 ok(key == 0xdeadbeef, "got key %lu\n", key);
11324 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11325
11326 CloseHandle(port);
11327
11328 DestroyWindow(hwnd);
11329 }
11330
11331 static void iocp_async_read_thread(SOCKET src, SOCKET dst)
11332 {
11333 struct wsa_async_select_info select_info;
11334 struct wsa_recv_info recv_info;
11335 HANDLE port, thread;
11336 WSAOVERLAPPED *ovl_iocp;
11337 int ret;
11338 char data[512];
11339 DWORD bytes, tid;
11340 ULONG_PTR key;
11341 HWND hwnd;
11342 MSG msg;
11343
11344 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
11345 0, 0, 0, 0, NULL, NULL, 0, NULL);
11346 ok(hwnd != 0, "CreateWindowEx failed\n");
11347
11348 select_info.sock = src;
11349 select_info.hwnd = hwnd;
11350 thread = CreateThread(NULL, 0, wsa_async_select_thread, &select_info, 0, &tid);
11351 ok(thread != 0, "CreateThread error %u\n", GetLastError());
11352 ret = WaitForSingleObject(thread, 10000);
11353 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
11354
11355 Sleep(100);
11356 memset(&msg, 0, sizeof(msg));
11357 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11358 ok(ret, "got %d\n", ret);
11359 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11360 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11361 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
11362 ok(msg.lParam == 2, "got %08lx\n", msg.lParam);
11363
11364 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11365 ok(port != 0, "CreateIoCompletionPort error %u\n", GetLastError());
11366
11367 Sleep(100);
11368 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11369 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11370
11371 memset(data, 0, sizeof(data));
11372 memset(&recv_info.ovl, 0, sizeof(recv_info.ovl));
11373 recv_info.sock = src;
11374 recv_info.wsa_buf.len = sizeof(data);
11375 recv_info.wsa_buf.buf = data;
11376 thread = CreateThread(NULL, 0, wsa_recv_thread, &recv_info, 0, &tid);
11377 ok(thread != 0, "CreateThread error %u\n", GetLastError());
11378 ret = WaitForSingleObject(thread, 10000);
11379 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
11380
11381 Sleep(100);
11382 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11383 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11384
11385 bytes = 0xdeadbeef;
11386 key = 0xdeadbeef;
11387 ovl_iocp = (void *)0xdeadbeef;
11388 SetLastError(0xdeadbeef);
11389 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11390 ok(!ret, "got %d\n", ret);
11391 ok(GetLastError() == WAIT_TIMEOUT || broken(GetLastError() == ERROR_OPERATION_ABORTED) /* XP */, "got %u\n", GetLastError());
11392 if (GetLastError() == WAIT_TIMEOUT)
11393 {
11394 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11395 ok(key == 0xdeadbeef, "got key %lu\n", key);
11396 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11397 }
11398 else /* document XP behaviour */
11399 {
11400 ok(bytes == 0, "got bytes %u\n", bytes);
11401 ok(key == 0x12345678, "got key %#lx\n", key);
11402 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
11403 if (ovl_iocp)
11404 {
11405 ok(!ovl_iocp->InternalHigh, "got %#lx\n", ovl_iocp->InternalHigh);
11406 ok(ovl_iocp->Internal == STATUS_CANCELLED, "got %#lx\n", ovl_iocp->Internal);
11407 }
11408 }
11409
11410 Sleep(100);
11411 memset(&msg, 0, sizeof(msg));
11412 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11413 ok(!ret || broken(msg.hwnd == hwnd) /* XP */, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11414 if (ret) /* document XP behaviour */
11415 {
11416 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11417 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
11418 ok(msg.lParam == 1, "got %08lx\n", msg.lParam);
11419 }
11420
11421 ret = send(dst, "Hello World!", 12, 0);
11422 ok(ret == 12, "send returned %d\n", ret);
11423
11424 Sleep(100);
11425 memset(&msg, 0, sizeof(msg));
11426 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11427 ok(!ret || broken(msg.hwnd == hwnd) /* XP */, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11428 if (ret) /* document XP behaviour */
11429 {
11430 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11431 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11432 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
11433 ok(msg.lParam == 1, "got %08lx\n", msg.lParam);
11434 }
11435
11436 bytes = 0xdeadbeef;
11437 key = 0xdeadbeef;
11438 ovl_iocp = (void *)0xdeadbeef;
11439 SetLastError(0xdeadbeef);
11440 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11441 ok(ret || broken(GetLastError() == WAIT_TIMEOUT) /* XP */, "got %u\n", GetLastError());
11442 if (ret)
11443 {
11444 ok(bytes == 12, "got bytes %u\n", bytes);
11445 ok(key == 0x12345678, "got key %#lx\n", key);
11446 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
11447 if (ovl_iocp)
11448 {
11449 ok(ovl_iocp->InternalHigh == 12, "got %#lx\n", ovl_iocp->InternalHigh);
11450 ok(!ovl_iocp->Internal , "got %#lx\n", ovl_iocp->Internal);
11451 ok(!memcmp(data, "Hello World!", 12), "got %u bytes (%*s)\n", bytes, bytes, data);
11452 }
11453 }
11454 else /* document XP behaviour */
11455 {
11456 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11457 ok(key == 0xdeadbeef, "got key %lu\n", key);
11458 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11459 }
11460
11461 CloseHandle(port);
11462
11463 DestroyWindow(hwnd);
11464 }
11465
11466 static void test_iocp(void)
11467 {
11468 SOCKET src, dst;
11469 int i, ret;
11470
11471 ret = tcp_socketpair_ovl(&src, &dst);
11472 ok(!ret, "creating socket pair failed\n");
11473 sync_read(src, dst);
11474 iocp_async_read(src, dst);
11475 closesocket(src);
11476 closesocket(dst);
11477
11478 ret = tcp_socketpair_ovl(&src, &dst);
11479 ok(!ret, "creating socket pair failed\n");
11480 iocp_async_read_thread(src, dst);
11481 closesocket(src);
11482 closesocket(dst);
11483
11484 for (i = 0; i <= 2; i++)
11485 {
11486 ret = tcp_socketpair_ovl(&src, &dst);
11487 ok(!ret, "creating socket pair failed\n");
11488 iocp_async_read_closesocket(src, i);
11489 closesocket(dst);
11490 }
11491
11492 ret = tcp_socketpair_ovl(&src, &dst);
11493 ok(!ret, "creating socket pair failed\n");
11494 iocp_async_closesocket(src);
11495 closesocket(dst);
11496
11497 ret = tcp_socketpair_ovl(&src, &dst);
11498 ok(!ret, "creating socket pair failed\n");
11499 iocp_async_read_thread_closesocket(src);
11500 closesocket(dst);
11501 }
11502
11503 static void test_WSCGetProviderInfo(void)
11504 {
11505 int ret;
11506 int errcode;
11507 GUID provider = {};
11508 char info[1];
11509 size_t len = 0;
11510
11511 if (!pWSCGetProviderInfo) {
11512 skip("WSCGetProviderInfo is not available.\n");
11513 return;
11514 }
11515
11516 ret = pWSCGetProviderInfo(NULL, -1, NULL, NULL, 0, NULL);
11517 ok(ret == SOCKET_ERROR, "got %d, expected SOCKET_ERROR\n", ret);
11518
11519 errcode = 0xdeadbeef;
11520 ret = pWSCGetProviderInfo(NULL, ProviderInfoLspCategories, (PBYTE)&info, &len, 0, &errcode);
11521 ok(ret == SOCKET_ERROR, "got %d, expected SOCKET_ERROR\n", ret);
11522 ok(errcode == WSAEFAULT, "got %d, expected WSAEFAULT\n", errcode);
11523
11524 errcode = 0xdeadbeef;
11525 ret = pWSCGetProviderInfo(&provider, -1, (PBYTE)&info, &len, 0, &errcode);
11526 ok(ret == SOCKET_ERROR, "got %d, expected SOCKET_ERROR\n", ret);
11527 ok(errcode == WSANO_RECOVERY, "got %d, expected WSANO_RECOVERY\n", errcode);
11528
11529 errcode = 0xdeadbeef;
11530 ret = pWSCGetProviderInfo(&provider, ProviderInfoLspCategories, NULL, &len, 0, &errcode);
11531 ok(ret == SOCKET_ERROR, "got %d, expected SOCKET_ERROR\n", ret);
11532 ok(errcode == WSANO_RECOVERY, "got %d, expected WSANO_RECOVERY\n", errcode);
11533
11534 errcode = 0xdeadbeef;
11535 ret = pWSCGetProviderInfo(&provider, ProviderInfoLspCategories, (PBYTE)&info, NULL, 0, &errcode);
11536 ok(ret == SOCKET_ERROR, "got %d, expected SOCKET_ERROR\n", ret);
11537 ok(errcode == WSANO_RECOVERY, "got %d, expected WSANO_RECOVERY\n", errcode);
11538
11539 errcode = 0xdeadbeef;
11540 ret = pWSCGetProviderInfo(&provider, ProviderInfoLspCategories, (PBYTE)&info, &len, 0, &errcode);
11541 ok(ret == SOCKET_ERROR, "got %d, expected SOCKET_ERROR\n", ret);
11542 ok(errcode == WSANO_RECOVERY, "got %d, expected WSANO_RECOVERY\n", errcode);
11543 }
11544
11545 START_TEST( sock )
11546 {
11547 int i;
11548
11549 /* Leave these tests at the beginning. They depend on WSAStartup not having been
11550 * called, which is done by Init() below. */
11551 test_WithoutWSAStartup();
11552 test_WithWSAStartup();
11553
11554 Init();
11555
11556 test_inet_ntoa();
11557 test_inet_pton();
11558 test_set_getsockopt();
11559 test_so_reuseaddr();
11560 test_ip_pktinfo();
11561 test_extendedSocketOptions();
11562
11563 for (i = 0; i < ARRAY_SIZE(tests); i++)
11564 {
11565 trace ( " **** STARTING TEST %d ****\n", i );
11566 do_test ( &tests[i] );
11567 trace ( " **** TEST %d COMPLETE ****\n", i );
11568 }
11569
11570 test_UDP();
11571
11572 test_getservbyname();
11573 test_WSASocket();
11574 test_WSADuplicateSocket();
11575 test_WSAEnumNetworkEvents();
11576
11577 test_WSAAddressToStringA();
11578 test_WSAAddressToStringW();
11579
11580 test_WSAStringToAddress();
11581
11582 test_errors();
11583 test_listen();
11584 test_select();
11585 test_accept();
11586 test_getpeername();
11587 test_getsockname();
11588 test_inet_addr();
11589 test_addr_to_print();
11590 test_ioctlsocket();
11591 test_dns();
11592 test_gethostbyname();
11593 test_gethostbyname_hack();
11594 test_gethostname();
11595
11596 test_WSASendMsg();
11597 test_WSASendTo();
11598 test_WSARecv();
11599 test_WSAPoll();
11600 test_write_watch();
11601 test_iocp();
11602
11603 test_events(0);
11604 test_events(1);
11605
11606 test_ipv6only();
11607 test_TransmitFile();
11608 test_GetAddrInfoW();
11609 test_GetAddrInfoExW();
11610 test_getaddrinfo();
11611 test_AcceptEx();
11612 test_ConnectEx();
11613 test_DisconnectEx();
11614
11615 test_sioRoutingInterfaceQuery();
11616 test_sioAddressListChange();
11617
11618 test_WSALookupService();
11619 test_WSAEnumNameSpaceProvidersA();
11620 test_WSAEnumNameSpaceProvidersW();
11621
11622 test_WSAAsyncGetServByPort();
11623 test_WSAAsyncGetServByName();
11624
11625 test_completion_port();
11626 test_address_list_query();
11627
11628 test_WSCGetProviderInfo();
11629
11630 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
11631 test_send();
11632 test_synchronous_WSAIoctl();
11633
11634 Exit();
11635 }
Windows API implementation