?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ws2_32: Call the completion routine in GetAddrInfoExW.
[wine.git] / dlls / ws2_32 / tests / sock.c
blobe4b57cfddaed903619beb6614ad5bc7a9e727588
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 <wsipx.h>
31 #include <wsnwlink.h>
32 #include <mswsock.h>
33 #include <mstcpip.h>
34 #include <iphlpapi.h>
35 #include <stdio.h>
36 #include "wine/test.h"
37
38 #define MAX_CLIENTS 4 /* Max number of clients */
39 #define FIRST_CHAR 'A' /* First character in transferred pattern */
40 #define BIND_SLEEP 10 /* seconds to wait between attempts to bind() */
41 #define BIND_TRIES 6 /* Number of bind() attempts */
42 #define TEST_TIMEOUT 30 /* seconds to wait before killing child threads
43 after server initialization, if something hangs */
44
45 #define NUM_UDP_PEERS 3 /* Number of UDP sockets to create and test > 1 */
46
47 #define NUM_THREADS 3 /* Number of threads to run getservbyname */
48 #define NUM_QUERIES 250 /* Number of getservbyname queries per thread */
49
50 #define SERVERIP "127.0.0.1" /* IP to bind to */
51 #define SERVERPORT 9374 /* Port number to bind to */
52
53 #define wsa_ok(op, cond, msg) \
54 do { \
55 int tmp, err = 0; \
56 tmp = op; \
57 if ( !(cond tmp) ) err = WSAGetLastError(); \
58 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
59 } while (0);
60
61 #define make_keepalive(k, enable, time, interval) \
62 k.onoff = enable; \
63 k.keepalivetime = time; \
64 k.keepaliveinterval = interval;
65
66 /* Function pointers */
67 static void (WINAPI *pfreeaddrinfo)(struct addrinfo *);
68 static int (WINAPI *pgetaddrinfo)(LPCSTR,LPCSTR,const struct addrinfo *,struct addrinfo **);
69 static void (WINAPI *pFreeAddrInfoW)(PADDRINFOW);
70 static void (WINAPI *pFreeAddrInfoExW)(ADDRINFOEXW *ai);
71 static int (WINAPI *pGetAddrInfoW)(LPCWSTR,LPCWSTR,const ADDRINFOW *,PADDRINFOW *);
72 static int (WINAPI *pGetAddrInfoExW)(const WCHAR *name, const WCHAR *servname, DWORD namespace,
73 GUID *namespace_id, const ADDRINFOEXW *hints, ADDRINFOEXW **result,
74 struct timeval *timeout, OVERLAPPED *overlapped,
75 LPLOOKUPSERVICE_COMPLETION_ROUTINE completion_routine, HANDLE *handle);
76 static int (WINAPI *pGetAddrInfoExOverlappedResult)(OVERLAPPED *overlapped);
77 static PCSTR (WINAPI *pInetNtop)(INT,LPVOID,LPSTR,ULONG);
78 static PCWSTR(WINAPI *pInetNtopW)(INT,LPVOID,LPWSTR,ULONG);
79 static int (WINAPI *pInetPtonA)(INT,LPCSTR,LPVOID);
80 static int (WINAPI *pInetPtonW)(INT,LPWSTR,LPVOID);
81 static int (WINAPI *pWSALookupServiceBeginW)(LPWSAQUERYSETW,DWORD,LPHANDLE);
82 static int (WINAPI *pWSALookupServiceEnd)(HANDLE);
83 static int (WINAPI *pWSALookupServiceNextW)(HANDLE,DWORD,LPDWORD,LPWSAQUERYSETW);
84 static int (WINAPI *pWSAEnumNameSpaceProvidersA)(LPDWORD,LPWSANAMESPACE_INFOA);
85 static int (WINAPI *pWSAEnumNameSpaceProvidersW)(LPDWORD,LPWSANAMESPACE_INFOW);
86 static int (WINAPI *pWSAPoll)(WSAPOLLFD *,ULONG,INT);
87
88 /* Function pointers from iphlpapi */
89 static DWORD (WINAPI *pGetAdaptersInfo)(PIP_ADAPTER_INFO,PULONG);
90 static DWORD (WINAPI *pGetIpForwardTable)(PMIB_IPFORWARDTABLE,PULONG,BOOL);
91
92 /* Function pointers from ntdll */
93 static DWORD (WINAPI *pNtClose)(HANDLE);
94
95 /**************** Structs and typedefs ***************/
96
97 typedef struct thread_info
98 {
99 HANDLE thread;
100 DWORD id;
101 } thread_info;
102
103 /* Information in the server about open client connections */
104 typedef struct sock_info
105 {
106 SOCKET s;
107 struct sockaddr_in addr;
108 struct sockaddr_in peer;
109 char *buf;
110 int n_recvd;
111 int n_sent;
112 } sock_info;
113
114 /* Test parameters for both server & client */
115 typedef struct test_params
116 {
117 int sock_type;
118 int sock_prot;
119 const char *inet_addr;
120 short inet_port;
121 int chunk_size;
122 int n_chunks;
123 int n_clients;
124 } test_params;
125
126 /* server-specific test parameters */
127 typedef struct server_params
128 {
129 test_params *general;
130 DWORD sock_flags;
131 int buflen;
132 } server_params;
133
134 /* client-specific test parameters */
135 typedef struct client_params
136 {
137 test_params *general;
138 DWORD sock_flags;
139 int buflen;
140 } client_params;
141
142 /* This type combines all information for setting up a test scenario */
143 typedef struct test_setup
144 {
145 test_params general;
146 LPVOID srv;
147 server_params srv_params;
148 LPVOID clt;
149 client_params clt_params;
150 } test_setup;
151
152 /* Thread local storage for server */
153 typedef struct server_memory
154 {
155 SOCKET s;
156 struct sockaddr_in addr;
157 sock_info sock[MAX_CLIENTS];
158 } server_memory;
159
160 /* Thread local storage for client */
161 typedef struct client_memory
162 {
163 SOCKET s;
164 struct sockaddr_in addr;
165 char *send_buf;
166 char *recv_buf;
167 } client_memory;
168
169 /* SelectReadThread thread parameters */
170 typedef struct select_thread_params
171 {
172 SOCKET s;
173 BOOL ReadKilled;
174 } select_thread_params;
175
176 /* Tests used in both getaddrinfo and GetAddrInfoW */
177 static const struct addr_hint_tests
178 {
179 int family, socktype, protocol;
180 DWORD error;
181 } hinttests[] = {
182 {AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, 0 },
183 {AF_UNSPEC, SOCK_STREAM, IPPROTO_UDP, 0 },
184 {AF_UNSPEC, SOCK_STREAM, IPPROTO_IPV6,0 },
185 {AF_UNSPEC, SOCK_DGRAM, IPPROTO_TCP, 0 },
186 {AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP, 0 },
187 {AF_UNSPEC, SOCK_DGRAM, IPPROTO_IPV6,0 },
188 {AF_INET, SOCK_STREAM, IPPROTO_TCP, 0 },
189 {AF_INET, SOCK_STREAM, IPPROTO_UDP, 0 },
190 {AF_INET, SOCK_STREAM, IPPROTO_IPV6,0 },
191 {AF_INET, SOCK_DGRAM, IPPROTO_TCP, 0 },
192 {AF_INET, SOCK_DGRAM, IPPROTO_UDP, 0 },
193 {AF_INET, SOCK_DGRAM, IPPROTO_IPV6,0 },
194 {AF_UNSPEC, 0, IPPROTO_TCP, 0 },
195 {AF_UNSPEC, 0, IPPROTO_UDP, 0 },
196 {AF_UNSPEC, 0, IPPROTO_IPV6,0 },
197 {AF_UNSPEC, SOCK_STREAM, 0, 0 },
198 {AF_UNSPEC, SOCK_DGRAM, 0, 0 },
199 {AF_INET, 0, IPPROTO_TCP, 0 },
200 {AF_INET, 0, IPPROTO_UDP, 0 },
201 {AF_INET, 0, IPPROTO_IPV6,0 },
202 {AF_INET, SOCK_STREAM, 0, 0 },
203 {AF_INET, SOCK_DGRAM, 0, 0 },
204 {AF_UNSPEC, 999, IPPROTO_TCP, WSAESOCKTNOSUPPORT },
205 {AF_UNSPEC, 999, IPPROTO_UDP, WSAESOCKTNOSUPPORT },
206 {AF_UNSPEC, 999, IPPROTO_IPV6,WSAESOCKTNOSUPPORT },
207 {AF_INET, 999, IPPROTO_TCP, WSAESOCKTNOSUPPORT },
208 {AF_INET, 999, IPPROTO_UDP, WSAESOCKTNOSUPPORT },
209 {AF_INET, 999, IPPROTO_IPV6,WSAESOCKTNOSUPPORT },
210 {AF_UNSPEC, SOCK_STREAM, 999, 0 },
211 {AF_UNSPEC, SOCK_STREAM, 999, 0 },
212 {AF_INET, SOCK_DGRAM, 999, 0 },
213 {AF_INET, SOCK_DGRAM, 999, 0 },
214 };
215
216 /**************** Static variables ***************/
217
218 static DWORD tls; /* Thread local storage index */
219 static HANDLE thread[1+MAX_CLIENTS];
220 static DWORD thread_id[1+MAX_CLIENTS];
221 static HANDLE server_ready;
222 static HANDLE client_ready[MAX_CLIENTS];
223 static int client_id;
224
225 /**************** General utility functions ***************/
226
227 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len);
228 static SOCKET setup_connector_socket(struct sockaddr_in *addr, int len, BOOL nonblock);
229
230 static int tcp_socketpair(SOCKET *src, SOCKET *dst)
231 {
232 SOCKET server = INVALID_SOCKET;
233 struct sockaddr_in addr;
234 int len;
235 int ret;
236
237 *src = INVALID_SOCKET;
238 *dst = INVALID_SOCKET;
239
240 *src = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
241 if (*src == INVALID_SOCKET)
242 goto end;
243
244 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
245 if (server == INVALID_SOCKET)
246 goto end;
247
248 memset(&addr, 0, sizeof(addr));
249 addr.sin_family = AF_INET;
250 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
251 ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
252 if (ret != 0)
253 goto end;
254
255 len = sizeof(addr);
256 ret = getsockname(server, (struct sockaddr*)&addr, &len);
257 if (ret != 0)
258 goto end;
259
260 ret = listen(server, 1);
261 if (ret != 0)
262 goto end;
263
264 ret = connect(*src, (struct sockaddr*)&addr, sizeof(addr));
265 if (ret != 0)
266 goto end;
267
268 len = sizeof(addr);
269 *dst = accept(server, (struct sockaddr*)&addr, &len);
270
271 end:
272 if (server != INVALID_SOCKET)
273 closesocket(server);
274 if (*src != INVALID_SOCKET && *dst != INVALID_SOCKET)
275 return 0;
276 closesocket(*src);
277 closesocket(*dst);
278 return -1;
279 }
280
281 static int tcp_socketpair_ovl(SOCKET *src, SOCKET *dst)
282 {
283 SOCKET server = INVALID_SOCKET;
284 struct sockaddr_in addr;
285 int len, ret;
286
287 *src = INVALID_SOCKET;
288 *dst = INVALID_SOCKET;
289
290 *src = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
291 if (*src == INVALID_SOCKET)
292 goto end;
293
294 server = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
295 if (server == INVALID_SOCKET)
296 goto end;
297
298 memset(&addr, 0, sizeof(addr));
299 addr.sin_family = AF_INET;
300 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
301 ret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
302 if (ret != 0)
303 goto end;
304
305 len = sizeof(addr);
306 ret = getsockname(server, (struct sockaddr *)&addr, &len);
307 if (ret != 0)
308 goto end;
309
310 ret = listen(server, 1);
311 if (ret != 0)
312 goto end;
313
314 ret = connect(*src, (struct sockaddr *)&addr, sizeof(addr));
315 if (ret != 0)
316 goto end;
317
318 len = sizeof(addr);
319 *dst = accept(server, (struct sockaddr *)&addr, &len);
320
321 end:
322 if (server != INVALID_SOCKET)
323 closesocket(server);
324 if (*src != INVALID_SOCKET && *dst != INVALID_SOCKET)
325 return 0;
326 closesocket(*src);
327 closesocket(*dst);
328 return -1;
329 }
330
331 static void set_so_opentype ( BOOL overlapped )
332 {
333 int optval = !overlapped, newval, len = sizeof (int);
334
335 ok ( setsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
336 (LPVOID) &optval, sizeof (optval) ) == 0,
337 "setting SO_OPENTYPE failed\n" );
338 ok ( getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
339 (LPVOID) &newval, &len ) == 0,
340 "getting SO_OPENTYPE failed\n" );
341 ok ( optval == newval, "failed to set SO_OPENTYPE\n" );
342 }
343
344 static int set_blocking ( SOCKET s, BOOL blocking )
345 {
346 u_long val = !blocking;
347 return ioctlsocket ( s, FIONBIO, &val );
348 }
349
350 static void fill_buffer ( char *buf, int chunk_size, int n_chunks )
351 {
352 char c, *p;
353 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
354 memset ( p, c, chunk_size );
355 }
356
357 static int test_buffer ( char *buf, int chunk_size, int n_chunks )
358 {
359 char c, *p;
360 int i;
361 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
362 {
363 for ( i = 0; i < chunk_size; i++ )
364 if ( p[i] != c ) return i;
365 }
366 return -1;
367 }
368
369 /*
370 * This routine is called when a client / server does not expect any more data,
371 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
372 */
373 static void read_zero_bytes ( SOCKET s )
374 {
375 char buf[256];
376 int tmp, n = 0;
377 while ( ( tmp = recv ( s, buf, 256, 0 ) ) > 0 )
378 n += tmp;
379 ok ( n <= 0, "garbage data received: %d bytes\n", n );
380 }
381
382 static int do_synchronous_send ( SOCKET s, char *buf, int buflen, int flags, int sendlen )
383 {
384 char* last = buf + buflen, *p;
385 int n = 1;
386 for ( p = buf; n > 0 && p < last; )
387 {
388 n = send ( s, p, min ( sendlen, last - p ), flags );
389 if (n > 0) p += n;
390 }
391 wsa_ok ( n, 0 <=, "do_synchronous_send (%x): error %d\n" );
392 return p - buf;
393 }
394
395 static int do_synchronous_recv ( SOCKET s, char *buf, int buflen, int flags, int recvlen )
396 {
397 char* last = buf + buflen, *p;
398 int n = 1;
399 for ( p = buf; n > 0 && p < last; )
400 {
401 n = recv ( s, p, min ( recvlen, last - p ), flags );
402 if (n > 0) p += n;
403 }
404 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
405 return p - buf;
406 }
407
408 static int do_synchronous_recvfrom ( SOCKET s, char *buf, int buflen, int flags, struct sockaddr *from, int *fromlen, int recvlen )
409 {
410 char* last = buf + buflen, *p;
411 int n = 1;
412 for ( p = buf; n > 0 && p < last; )
413 {
414 n = recvfrom ( s, p, min ( recvlen, last - p ), flags, from, fromlen );
415 if (n > 0) p += n;
416 }
417 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
418 return p - buf;
419 }
420
421 /*
422 * Call this routine right after thread startup.
423 * SO_OPENTYPE must by 0, regardless what the server did.
424 */
425 static void check_so_opentype (void)
426 {
427 int tmp = 1, len;
428 len = sizeof (tmp);
429 getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (LPVOID) &tmp, &len );
430 ok ( tmp == 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp );
431 }
432
433 static void compare_addrinfo (ADDRINFO *a, ADDRINFO *b)
434 {
435 for (; a && b ; a = a->ai_next, b = b->ai_next)
436 {
437 ok(a->ai_flags == b->ai_flags,
438 "Wrong flags %d != %d\n", a->ai_flags, b->ai_flags);
439 ok(a->ai_family == b->ai_family,
440 "Wrong family %d != %d\n", a->ai_family, b->ai_family);
441 ok(a->ai_socktype == b->ai_socktype,
442 "Wrong socktype %d != %d\n", a->ai_socktype, b->ai_socktype);
443 ok(a->ai_protocol == b->ai_protocol,
444 "Wrong protocol %d != %d\n", a->ai_protocol, b->ai_protocol);
445 ok(a->ai_addrlen == b->ai_addrlen,
446 "Wrong addrlen %lu != %lu\n", a->ai_addrlen, b->ai_addrlen);
447 ok(!memcmp(a->ai_addr, b->ai_addr, min(a->ai_addrlen, b->ai_addrlen)),
448 "Wrong address data\n");
449 if (a->ai_canonname && b->ai_canonname)
450 {
451 ok(!strcmp(a->ai_canonname, b->ai_canonname), "Wrong canonical name '%s' != '%s'\n",
452 a->ai_canonname, b->ai_canonname);
453 }
454 else
455 ok(!a->ai_canonname && !b->ai_canonname, "Expected both names absent (%p != %p)\n",
456 a->ai_canonname, b->ai_canonname);
457 }
458 ok(!a && !b, "Expected both addresses null (%p != %p)\n", a, b);
459 }
460
461 static void compare_addrinfow (ADDRINFOW *a, ADDRINFOW *b)
462 {
463 for (; a && b ; a = a->ai_next, b = b->ai_next)
464 {
465 ok(a->ai_flags == b->ai_flags,
466 "Wrong flags %d != %d\n", a->ai_flags, b->ai_flags);
467 ok(a->ai_family == b->ai_family,
468 "Wrong family %d != %d\n", a->ai_family, b->ai_family);
469 ok(a->ai_socktype == b->ai_socktype,
470 "Wrong socktype %d != %d\n", a->ai_socktype, b->ai_socktype);
471 ok(a->ai_protocol == b->ai_protocol,
472 "Wrong protocol %d != %d\n", a->ai_protocol, b->ai_protocol);
473 ok(a->ai_addrlen == b->ai_addrlen,
474 "Wrong addrlen %lu != %lu\n", a->ai_addrlen, b->ai_addrlen);
475 ok(!memcmp(a->ai_addr, b->ai_addr, min(a->ai_addrlen, b->ai_addrlen)),
476 "Wrong address data\n");
477 if (a->ai_canonname && b->ai_canonname)
478 {
479 ok(!lstrcmpW(a->ai_canonname, b->ai_canonname), "Wrong canonical name '%s' != '%s'\n",
480 wine_dbgstr_w(a->ai_canonname), wine_dbgstr_w(b->ai_canonname));
481 }
482 else
483 ok(!a->ai_canonname && !b->ai_canonname, "Expected both names absent (%p != %p)\n",
484 a->ai_canonname, b->ai_canonname);
485 }
486 ok(!a && !b, "Expected both addresses null (%p != %p)\n", a, b);
487 }
488
489 /**************** Server utility functions ***************/
490
491 /*
492 * Even if we have closed our server socket cleanly,
493 * the OS may mark the address "in use" for some time -
494 * this happens with native Linux apps, too.
495 */
496 static void do_bind ( SOCKET s, struct sockaddr* addr, int addrlen )
497 {
498 int err, wsaerr = 0, n_try = BIND_TRIES;
499
500 while ( ( err = bind ( s, addr, addrlen ) ) != 0 &&
501 ( wsaerr = WSAGetLastError () ) == WSAEADDRINUSE &&
502 n_try-- >= 0)
503 {
504 trace ( "address in use, waiting ...\n" );
505 Sleep ( 1000 * BIND_SLEEP );
506 }
507 ok ( err == 0, "failed to bind: %d\n", wsaerr );
508 }
509
510 static void server_start ( server_params *par )
511 {
512 int i;
513 test_params *gen = par->general;
514 server_memory *mem = LocalAlloc ( LPTR, sizeof ( server_memory ) );
515
516 TlsSetValue ( tls, mem );
517 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
518 NULL, 0, par->sock_flags );
519 ok ( mem->s != INVALID_SOCKET, "Server: WSASocket failed\n" );
520
521 mem->addr.sin_family = AF_INET;
522 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
523 mem->addr.sin_port = htons ( gen->inet_port );
524
525 for (i = 0; i < MAX_CLIENTS; i++)
526 {
527 mem->sock[i].s = INVALID_SOCKET;
528 mem->sock[i].buf = LocalAlloc ( LPTR, gen->n_chunks * gen->chunk_size );
529 mem->sock[i].n_recvd = 0;
530 mem->sock[i].n_sent = 0;
531 }
532
533 if ( gen->sock_type == SOCK_STREAM )
534 do_bind ( mem->s, (struct sockaddr*) &mem->addr, sizeof (mem->addr) );
535 }
536
537 static void server_stop (void)
538 {
539 int i;
540 server_memory *mem = TlsGetValue ( tls );
541
542 for (i = 0; i < MAX_CLIENTS; i++ )
543 {
544 LocalFree ( mem->sock[i].buf );
545 if ( mem->sock[i].s != INVALID_SOCKET )
546 closesocket ( mem->sock[i].s );
547 }
548 ok ( closesocket ( mem->s ) == 0, "closesocket failed\n" );
549 LocalFree ( mem );
550 ExitThread ( GetCurrentThreadId () );
551 }
552
553 /**************** Client utilitiy functions ***************/
554
555 static void client_start ( client_params *par )
556 {
557 test_params *gen = par->general;
558 client_memory *mem = LocalAlloc (LPTR, sizeof (client_memory));
559
560 TlsSetValue ( tls, mem );
561
562 WaitForSingleObject ( server_ready, INFINITE );
563
564 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
565 NULL, 0, par->sock_flags );
566
567 mem->addr.sin_family = AF_INET;
568 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
569 mem->addr.sin_port = htons ( gen->inet_port );
570
571 ok ( mem->s != INVALID_SOCKET, "Client: WSASocket failed\n" );
572
573 mem->send_buf = LocalAlloc ( LPTR, 2 * gen->n_chunks * gen->chunk_size );
574 mem->recv_buf = mem->send_buf + gen->n_chunks * gen->chunk_size;
575 fill_buffer ( mem->send_buf, gen->chunk_size, gen->n_chunks );
576
577 SetEvent ( client_ready[client_id] );
578 /* Wait for the other clients to come up */
579 WaitForMultipleObjects ( min ( gen->n_clients, MAX_CLIENTS ), client_ready, TRUE, INFINITE );
580 }
581
582 static void client_stop (void)
583 {
584 client_memory *mem = TlsGetValue ( tls );
585 wsa_ok ( closesocket ( mem->s ), 0 ==, "closesocket error (%x): %d\n" );
586 LocalFree ( mem->send_buf );
587 LocalFree ( mem );
588 ExitThread(0);
589 }
590
591 /**************** Servers ***************/
592
593 /*
594 * simple_server: A very basic server doing synchronous IO.
595 */
596 static VOID WINAPI simple_server ( server_params *par )
597 {
598 test_params *gen = par->general;
599 server_memory *mem;
600 int pos, n_recvd, n_sent, n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
601 id = GetCurrentThreadId();
602
603 trace ( "simple_server (%x) starting\n", id );
604
605 set_so_opentype ( FALSE ); /* non-overlapped */
606 server_start ( par );
607 mem = TlsGetValue ( tls );
608
609 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
610 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "simple_server (%x): listen failed: %d\n");
611
612 trace ( "simple_server (%x) ready\n", id );
613 SetEvent ( server_ready ); /* notify clients */
614
615 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
616 {
617 trace ( "simple_server (%x): waiting for client\n", id );
618
619 /* accept a single connection */
620 tmp = sizeof ( mem->sock[0].peer );
621 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
622 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "simple_server (%x): accept failed: %d\n" );
623
624 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
625 "simple_server (%x): strange peer address\n", id );
626
627 /* Receive data & check it */
628 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
629 ok ( n_recvd == n_expected,
630 "simple_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
631 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
632 ok ( pos == -1, "simple_server (%x): test pattern error: %d\n", id, pos);
633
634 /* Echo data back */
635 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
636 ok ( n_sent == n_expected,
637 "simple_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
638
639 /* cleanup */
640 read_zero_bytes ( mem->sock[0].s );
641 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "simple_server (%x): closesocket error: %d\n" );
642 mem->sock[0].s = INVALID_SOCKET;
643 }
644
645 trace ( "simple_server (%x) exiting\n", id );
646 server_stop ();
647 }
648
649 /*
650 * oob_server: A very basic server receiving out-of-band data.
651 */
652 static VOID WINAPI oob_server ( server_params *par )
653 {
654 test_params *gen = par->general;
655 server_memory *mem;
656 u_long atmark = 0;
657 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, tmp,
658 id = GetCurrentThreadId();
659
660 trace ( "oob_server (%x) starting\n", id );
661
662 set_so_opentype ( FALSE ); /* non-overlapped */
663 server_start ( par );
664 mem = TlsGetValue ( tls );
665
666 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "oob_server (%x): failed to set blocking mode: %d\n");
667 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "oob_server (%x): listen failed: %d\n");
668
669 trace ( "oob_server (%x) ready\n", id );
670 SetEvent ( server_ready ); /* notify clients */
671
672 trace ( "oob_server (%x): waiting for client\n", id );
673
674 /* accept a single connection */
675 tmp = sizeof ( mem->sock[0].peer );
676 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
677 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "oob_server (%x): accept failed: %d\n" );
678
679 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
680 "oob_server (%x): strange peer address\n", id );
681
682 /* check initial atmark state */
683 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
684 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id, atmark );
685
686 /* Receive normal data */
687 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
688 ok ( n_recvd == n_expected,
689 "oob_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
690 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
691 ok ( pos == -1, "oob_server (%x): test pattern error: %d\n", id, pos);
692
693 /* check atmark state */
694 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
695 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id, atmark );
696
697 /* Echo data back */
698 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
699 ok ( n_sent == n_expected,
700 "oob_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
701
702 /* Receive a part of the out-of-band data and print atmark state */
703 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, 8, 0, par->buflen );
704 ok ( n_recvd == 8,
705 "oob_server (%x): received less data than expected: %d of %d\n", id, n_recvd, 8 );
706 n_expected -= 8;
707
708 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
709 trace( "oob_server (%x): %s the OOB mark: %i\n", id, atmark == 1 ? "not at" : "at", atmark );
710
711 /* Receive the rest of the out-of-band data and check atmark state */
712 do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
713
714 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
715 todo_wine ok ( atmark == 0, "oob_server (%x): not at the OOB mark: %i\n", id, atmark );
716
717 /* cleanup */
718 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "oob_server (%x): closesocket error: %d\n" );
719 mem->sock[0].s = INVALID_SOCKET;
720
721 trace ( "oob_server (%x) exiting\n", id );
722 server_stop ();
723 }
724
725 /*
726 * select_server: A non-blocking server.
727 */
728 static VOID WINAPI select_server ( server_params *par )
729 {
730 test_params *gen = par->general;
731 server_memory *mem;
732 int n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
733 id = GetCurrentThreadId(), n_connections = 0, n_sent, n_recvd,
734 n_set, delta, n_ready;
735 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
736 fd_set fds_recv, fds_send, fds_openrecv, fds_opensend;
737
738 trace ( "select_server (%x) starting\n", id );
739
740 set_so_opentype ( FALSE ); /* non-overlapped */
741 server_start ( par );
742 mem = TlsGetValue ( tls );
743
744 wsa_ok ( set_blocking ( mem->s, FALSE ), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
745 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "select_server (%x): listen failed: %d\n");
746
747 trace ( "select_server (%x) ready\n", id );
748 SetEvent ( server_ready ); /* notify clients */
749
750 FD_ZERO ( &fds_openrecv );
751 FD_ZERO ( &fds_recv );
752 FD_ZERO ( &fds_send );
753 FD_ZERO ( &fds_opensend );
754
755 FD_SET ( mem->s, &fds_openrecv );
756
757 while(1)
758 {
759 fds_recv = fds_openrecv;
760 fds_send = fds_opensend;
761
762 n_set = 0;
763
764 wsa_ok ( ( n_ready = select ( 0, &fds_recv, &fds_send, NULL, &timeout ) ), SOCKET_ERROR !=,
765 "select_server (%x): select() failed: %d\n" );
766
767 /* check for incoming requests */
768 if ( FD_ISSET ( mem->s, &fds_recv ) ) {
769 n_set += 1;
770
771 trace ( "select_server (%x): accepting client connection\n", id );
772
773 /* accept a single connection */
774 tmp = sizeof ( mem->sock[n_connections].peer );
775 mem->sock[n_connections].s = accept ( mem->s, (struct sockaddr*) &mem->sock[n_connections].peer, &tmp );
776 wsa_ok ( mem->sock[n_connections].s, INVALID_SOCKET !=, "select_server (%x): accept() failed: %d\n" );
777
778 ok ( mem->sock[n_connections].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
779 "select_server (%x): strange peer address\n", id );
780
781 /* add to list of open connections */
782 FD_SET ( mem->sock[n_connections].s, &fds_openrecv );
783 FD_SET ( mem->sock[n_connections].s, &fds_opensend );
784
785 n_connections++;
786 }
787
788 /* handle open requests */
789
790 for ( i = 0; i < n_connections; i++ )
791 {
792 if ( FD_ISSET( mem->sock[i].s, &fds_recv ) ) {
793 n_set += 1;
794
795 if ( mem->sock[i].n_recvd < n_expected ) {
796 /* Receive data & check it */
797 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 );
798 ok ( n_recvd != SOCKET_ERROR, "select_server (%x): error in recv(): %d\n", id, WSAGetLastError() );
799 mem->sock[i].n_recvd += n_recvd;
800
801 if ( mem->sock[i].n_recvd == n_expected ) {
802 int pos = test_buffer ( mem->sock[i].buf, gen->chunk_size, gen->n_chunks );
803 ok ( pos == -1, "select_server (%x): test pattern error: %d\n", id, pos );
804 FD_CLR ( mem->sock[i].s, &fds_openrecv );
805 }
806
807 ok ( mem->sock[i].n_recvd <= n_expected, "select_server (%x): received too many bytes: %d\n", id, mem->sock[i].n_recvd );
808 }
809 }
810
811 /* only echo back what we've received */
812 delta = mem->sock[i].n_recvd - mem->sock[i].n_sent;
813
814 if ( FD_ISSET ( mem->sock[i].s, &fds_send ) ) {
815 n_set += 1;
816
817 if ( ( delta > 0 ) && ( mem->sock[i].n_sent < n_expected ) ) {
818 /* Echo data back */
819 n_sent = send ( mem->sock[i].s, mem->sock[i].buf + mem->sock[i].n_sent, min ( delta, par->buflen ), 0 );
820 ok ( n_sent != SOCKET_ERROR, "select_server (%x): error in send(): %d\n", id, WSAGetLastError() );
821 mem->sock[i].n_sent += n_sent;
822
823 if ( mem->sock[i].n_sent == n_expected ) {
824 FD_CLR ( mem->sock[i].s, &fds_opensend );
825 }
826
827 ok ( mem->sock[i].n_sent <= n_expected, "select_server (%x): sent too many bytes: %d\n", id, mem->sock[i].n_sent );
828 }
829 }
830 }
831
832 /* check that select returned the correct number of ready sockets */
833 ok ( ( n_set == n_ready ), "select_server (%x): select() returns wrong number of ready sockets\n", id );
834
835 /* check if all clients are done */
836 if ( ( fds_opensend.fd_count == 0 )
837 && ( fds_openrecv.fd_count == 1 ) /* initial socket that accepts clients */
838 && ( n_connections == min ( gen->n_clients, MAX_CLIENTS ) ) ) {
839 break;
840 }
841 }
842
843 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
844 {
845 /* cleanup */
846 read_zero_bytes ( mem->sock[i].s );
847 wsa_ok ( closesocket ( mem->sock[i].s ), 0 ==, "select_server (%x): closesocket error: %d\n" );
848 mem->sock[i].s = INVALID_SOCKET;
849 }
850
851 trace ( "select_server (%x) exiting\n", id );
852 server_stop ();
853 }
854
855 /**************** Clients ***************/
856
857 /*
858 * simple_client: A very basic client doing synchronous IO.
859 */
860 static VOID WINAPI simple_client ( client_params *par )
861 {
862 test_params *gen = par->general;
863 client_memory *mem;
864 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
865
866 id = GetCurrentThreadId();
867 trace ( "simple_client (%x): starting\n", id );
868 /* wait here because we want to call set_so_opentype before creating a socket */
869 WaitForSingleObject ( server_ready, INFINITE );
870 trace ( "simple_client (%x): server ready\n", id );
871
872 check_so_opentype ();
873 set_so_opentype ( FALSE ); /* non-overlapped */
874 client_start ( par );
875 mem = TlsGetValue ( tls );
876
877 /* Connect */
878 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
879 0 ==, "simple_client (%x): connect error: %d\n" );
880 ok ( set_blocking ( mem->s, TRUE ) == 0,
881 "simple_client (%x): failed to set blocking mode\n", id );
882 trace ( "simple_client (%x) connected\n", id );
883
884 /* send data to server */
885 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
886 ok ( n_sent == n_expected,
887 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
888
889 /* shutdown send direction */
890 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
891
892 /* Receive data echoed back & check it */
893 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, 0, par->buflen );
894 ok ( n_recvd == n_expected,
895 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
896
897 /* check data */
898 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
899 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
900
901 /* cleanup */
902 read_zero_bytes ( mem->s );
903 trace ( "simple_client (%x) exiting\n", id );
904 client_stop ();
905 }
906
907 /*
908 * oob_client: A very basic client sending out-of-band data.
909 */
910 static VOID WINAPI oob_client ( client_params *par )
911 {
912 test_params *gen = par->general;
913 client_memory *mem;
914 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
915
916 id = GetCurrentThreadId();
917 trace ( "oob_client (%x): starting\n", id );
918 /* wait here because we want to call set_so_opentype before creating a socket */
919 WaitForSingleObject ( server_ready, INFINITE );
920 trace ( "oob_client (%x): server ready\n", id );
921
922 check_so_opentype ();
923 set_so_opentype ( FALSE ); /* non-overlapped */
924 client_start ( par );
925 mem = TlsGetValue ( tls );
926
927 /* Connect */
928 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
929 0 ==, "oob_client (%x): connect error: %d\n" );
930 ok ( set_blocking ( mem->s, TRUE ) == 0,
931 "oob_client (%x): failed to set blocking mode\n", id );
932 trace ( "oob_client (%x) connected\n", id );
933
934 /* send data to server */
935 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
936 ok ( n_sent == n_expected,
937 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
938
939 /* Receive data echoed back & check it */
940 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, 0, par->buflen );
941 ok ( n_recvd == n_expected,
942 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
943 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
944 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
945
946 /* send out-of-band data to server */
947 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, MSG_OOB, par->buflen );
948 ok ( n_sent == n_expected,
949 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
950
951 /* shutdown send direction */
952 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
953
954 /* cleanup */
955 read_zero_bytes ( mem->s );
956 trace ( "oob_client (%x) exiting\n", id );
957 client_stop ();
958 }
959
960 /*
961 * simple_mixed_client: mixing send and recvfrom
962 */
963 static VOID WINAPI simple_mixed_client ( client_params *par )
964 {
965 test_params *gen = par->general;
966 client_memory *mem;
967 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
968 int fromLen = sizeof(mem->addr);
969 struct sockaddr test;
970
971 id = GetCurrentThreadId();
972 trace ( "simple_client (%x): starting\n", id );
973 /* wait here because we want to call set_so_opentype before creating a socket */
974 WaitForSingleObject ( server_ready, INFINITE );
975 trace ( "simple_client (%x): server ready\n", id );
976
977 check_so_opentype ();
978 set_so_opentype ( FALSE ); /* non-overlapped */
979 client_start ( par );
980 mem = TlsGetValue ( tls );
981
982 /* Connect */
983 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
984 0 ==, "simple_client (%x): connect error: %d\n" );
985 ok ( set_blocking ( mem->s, TRUE ) == 0,
986 "simple_client (%x): failed to set blocking mode\n", id );
987 trace ( "simple_client (%x) connected\n", id );
988
989 /* send data to server */
990 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
991 ok ( n_sent == n_expected,
992 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
993
994 /* shutdown send direction */
995 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
996
997 /* this shouldn't change, since lpFrom, is not updated on
998 connection oriented sockets - exposed by bug 11640
999 */
1000 ((struct sockaddr_in*)&test)->sin_addr.s_addr = inet_addr("0.0.0.0");
1001
1002 /* Receive data echoed back & check it */
1003 n_recvd = do_synchronous_recvfrom ( mem->s,
1004 mem->recv_buf,
1005 n_expected,
1006 0,
1007 (struct sockaddr *)&test,
1008 &fromLen,
1009 par->buflen );
1010 ok ( n_recvd == n_expected,
1011 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
1012
1013 /* check that lpFrom was not updated */
1014 ok(0 ==
1015 strcmp(
1016 inet_ntoa(((struct sockaddr_in*)&test)->sin_addr),
1017 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
1018
1019 /* check data */
1020 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
1021 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
1022
1023 /* cleanup */
1024 read_zero_bytes ( mem->s );
1025 trace ( "simple_client (%x) exiting\n", id );
1026 client_stop ();
1027 }
1028
1029 /*
1030 * event_client: An event-driven client
1031 */
1032 static void WINAPI event_client ( client_params *par )
1033 {
1034 test_params *gen = par->general;
1035 client_memory *mem;
1036 int id = GetCurrentThreadId(), n_expected = gen->n_chunks * gen->chunk_size,
1037 tmp, err, n;
1038 HANDLE event;
1039 WSANETWORKEVENTS wsa_events;
1040 char *send_last, *recv_last, *send_p, *recv_p;
1041 LONG mask = FD_READ | FD_WRITE | FD_CLOSE;
1042
1043 trace ( "event_client (%x): starting\n", id );
1044 client_start ( par );
1045 trace ( "event_client (%x): server ready\n", id );
1046
1047 mem = TlsGetValue ( tls );
1048
1049 /* Prepare event notification for connect, makes socket nonblocking */
1050 event = WSACreateEvent ();
1051 WSAEventSelect ( mem->s, event, FD_CONNECT );
1052 tmp = connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) );
1053 if ( tmp != 0 ) {
1054 err = WSAGetLastError ();
1055 ok ( err == WSAEWOULDBLOCK, "event_client (%x): connect error: %d\n", id, err );
1056 tmp = WaitForSingleObject ( event, INFINITE );
1057 ok ( tmp == WAIT_OBJECT_0, "event_client (%x): wait for connect event failed: %d\n", id, tmp );
1058 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
1059 ok ( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
1060 err = wsa_events.iErrorCode[ FD_CONNECT_BIT ];
1061 ok ( err == 0, "event_client (%x): connect error: %d\n", id, err );
1062 if ( err ) goto out;
1063 }
1064
1065 trace ( "event_client (%x) connected\n", id );
1066
1067 WSAEventSelect ( mem->s, event, mask );
1068
1069 recv_p = mem->recv_buf;
1070 recv_last = mem->recv_buf + n_expected;
1071 send_p = mem->send_buf;
1072 send_last = mem->send_buf + n_expected;
1073
1074 while ( TRUE )
1075 {
1076 err = WaitForSingleObject ( event, INFINITE );
1077 ok ( err == WAIT_OBJECT_0, "event_client (%x): wait failed\n", id );
1078
1079 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
1080 ok( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
1081
1082 if ( wsa_events.lNetworkEvents & FD_WRITE )
1083 {
1084 err = wsa_events.iErrorCode[ FD_WRITE_BIT ];
1085 ok ( err == 0, "event_client (%x): FD_WRITE error code: %d\n", id, err );
1086
1087 if ( err== 0 )
1088 do
1089 {
1090 n = send ( mem->s, send_p, min ( send_last - send_p, par->buflen ), 0 );
1091 if ( n < 0 )
1092 {
1093 err = WSAGetLastError ();
1094 ok ( err == WSAEWOULDBLOCK, "event_client (%x): send error: %d\n", id, err );
1095 }
1096 else
1097 send_p += n;
1098 }
1099 while ( n >= 0 && send_p < send_last );
1100
1101 if ( send_p == send_last )
1102 {
1103 trace ( "event_client (%x): all data sent - shutdown\n", id );
1104 shutdown ( mem->s, SD_SEND );
1105 mask &= ~FD_WRITE;
1106 WSAEventSelect ( mem->s, event, mask );
1107 }
1108 }
1109 if ( wsa_events.lNetworkEvents & FD_READ )
1110 {
1111 err = wsa_events.iErrorCode[ FD_READ_BIT ];
1112 ok ( err == 0, "event_client (%x): FD_READ error code: %d\n", id, err );
1113 if ( err != 0 ) break;
1114
1115 /* First read must succeed */
1116 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
1117 wsa_ok ( n, 0 <=, "event_client (%x): recv error: %d\n" );
1118
1119 while ( n >= 0 ) {
1120 recv_p += n;
1121 if ( recv_p == recv_last )
1122 {
1123 mask &= ~FD_READ;
1124 trace ( "event_client (%x): all data received\n", id );
1125 WSAEventSelect ( mem->s, event, mask );
1126 break;
1127 }
1128 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
1129 if ( n < 0 && ( err = WSAGetLastError()) != WSAEWOULDBLOCK )
1130 ok ( 0, "event_client (%x): read error: %d\n", id, err );
1131
1132 }
1133 }
1134 if ( wsa_events.lNetworkEvents & FD_CLOSE )
1135 {
1136 trace ( "event_client (%x): close event\n", id );
1137 err = wsa_events.iErrorCode[ FD_CLOSE_BIT ];
1138 ok ( err == 0, "event_client (%x): FD_CLOSE error code: %d\n", id, err );
1139 break;
1140 }
1141 }
1142
1143 n = send_p - mem->send_buf;
1144 ok ( send_p == send_last,
1145 "simple_client (%x): sent less data than expected: %d of %d\n", id, n, n_expected );
1146 n = recv_p - mem->recv_buf;
1147 ok ( recv_p == recv_last,
1148 "simple_client (%x): received less data than expected: %d of %d\n", id, n, n_expected );
1149 n = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
1150 ok ( n == -1, "event_client (%x): test pattern error: %d\n", id, n);
1151
1152 out:
1153 WSACloseEvent ( event );
1154 trace ( "event_client (%x) exiting\n", id );
1155 client_stop ();
1156 }
1157
1158 /* Tests for WSAStartup */
1159 static void test_WithoutWSAStartup(void)
1160 {
1161 DWORD err;
1162
1163 WSASetLastError(0xdeadbeef);
1164 ok(WSASocketA(0, 0, 0, NULL, 0, 0) == INVALID_SOCKET, "WSASocketA should have failed\n");
1165 err = WSAGetLastError();
1166 ok(err == WSANOTINITIALISED, "Expected 10093, received %d\n", err);
1167
1168 WSASetLastError(0xdeadbeef);
1169 ok(gethostbyname("localhost") == NULL, "gethostbyname() succeeded unexpectedly\n");
1170 err = WSAGetLastError();
1171 ok(err == WSANOTINITIALISED, "Expected 10093, received %d\n", err);
1172 }
1173
1174 static void test_WithWSAStartup(void)
1175 {
1176 WSADATA data;
1177 WORD version = MAKEWORD( 2, 2 );
1178 INT res, socks, i, j;
1179 SOCKET sock;
1180 LPVOID ptr;
1181 struct
1182 {
1183 SOCKET src, dst, dup_src, dup_dst;
1184 } pairs[32];
1185 DWORD error;
1186
1187 res = WSAStartup( version, &data );
1188 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
1189
1190 ptr = gethostbyname("localhost");
1191 ok(ptr != NULL, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
1192
1193 /* Alloc some sockets to check if they are destroyed on WSACleanup */
1194 for (socks = 0; socks < ARRAY_SIZE(pairs); socks++)
1195 {
1196 WSAPROTOCOL_INFOA info;
1197 if (tcp_socketpair(&pairs[socks].src, &pairs[socks].dst)) break;
1198
1199 memset(&info, 0, sizeof(info));
1200 ok(!WSADuplicateSocketA(pairs[socks].src, GetCurrentProcessId(), &info),
1201 "WSADuplicateSocketA should have worked\n");
1202 pairs[socks].dup_src = WSASocketA(0, 0, 0, &info, 0, 0);
1203 ok(pairs[socks].dup_src != SOCKET_ERROR, "expected != -1\n");
1204
1205 memset(&info, 0, sizeof(info));
1206 ok(!WSADuplicateSocketA(pairs[socks].dst, GetCurrentProcessId(), &info),
1207 "WSADuplicateSocketA should have worked\n");
1208 pairs[socks].dup_dst = WSASocketA(0, 0, 0, &info, 0, 0);
1209 ok(pairs[socks].dup_dst != SOCKET_ERROR, "expected != -1\n");
1210 }
1211
1212 res = send(pairs[0].src, "TEST", 4, 0);
1213 ok(res == 4, "send failed with error %d\n", WSAGetLastError());
1214
1215 WSACleanup();
1216
1217 res = WSAStartup( version, &data );
1218 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
1219
1220 /* show that sockets are destroyed automatically after WSACleanup */
1221 todo_wine {
1222 SetLastError(0xdeadbeef);
1223 res = send(pairs[0].src, "TEST", 4, 0);
1224 error = WSAGetLastError();
1225 ok(res == SOCKET_ERROR, "send should have failed\n");
1226 ok(error == WSAENOTSOCK, "expected 10038, got %d\n", error);
1227
1228 SetLastError(0xdeadbeef);
1229 res = send(pairs[0].dst, "TEST", 4, 0);
1230 error = WSAGetLastError();
1231 ok(res == SOCKET_ERROR, "send should have failed\n");
1232 ok(error == WSAENOTSOCK, "expected 10038, got %d\n", error);
1233
1234 /* Check that all sockets were destroyed */
1235 for (i = 0; i < socks; i++)
1236 {
1237 for (j = 0; j < 4; j++)
1238 {
1239 struct sockaddr_in saddr;
1240 int size = sizeof(saddr);
1241 switch(j)
1242 {
1243 case 0: sock = pairs[i].src; break;
1244 case 1: sock = pairs[i].dup_src; break;
1245 case 2: sock = pairs[i].dst; break;
1246 case 3: sock = pairs[i].dup_dst; break;
1247 }
1248
1249 SetLastError(0xdeadbeef);
1250 res = getsockname(sock, (struct sockaddr *)&saddr, &size);
1251 error = WSAGetLastError();
1252 ok(res == SOCKET_ERROR, "Test[%d]: getsockname should have failed\n", i);
1253 if (res == SOCKET_ERROR)
1254 ok(error == WSAENOTSOCK, "Test[%d]: expected 10038, got %d\n", i, error);
1255 }
1256 }
1257
1258 }
1259
1260 /* While wine is not fixed, close all sockets manually */
1261 for (i = 0; i < socks; i++)
1262 {
1263 closesocket(pairs[i].src);
1264 closesocket(pairs[i].dst);
1265 closesocket(pairs[i].dup_src);
1266 closesocket(pairs[i].dup_dst);
1267 }
1268
1269 res = WSACleanup();
1270 ok(res == 0, "expected 0, got %d\n", res);
1271 WSASetLastError(0xdeadbeef);
1272 res = WSACleanup();
1273 error = WSAGetLastError();
1274 ok ( res == SOCKET_ERROR && error == WSANOTINITIALISED,
1275 "WSACleanup returned %d WSAGetLastError is %d\n", res, error);
1276 }
1277
1278 /**************** Main program utility functions ***************/
1279
1280 static void Init (void)
1281 {
1282 WORD ver = MAKEWORD (2, 2);
1283 WSADATA data;
1284 HMODULE hws2_32 = GetModuleHandleA("ws2_32.dll"), hiphlpapi, ntdll;
1285
1286 pfreeaddrinfo = (void *)GetProcAddress(hws2_32, "freeaddrinfo");
1287 pgetaddrinfo = (void *)GetProcAddress(hws2_32, "getaddrinfo");
1288 pFreeAddrInfoW = (void *)GetProcAddress(hws2_32, "FreeAddrInfoW");
1289 pFreeAddrInfoExW = (void *)GetProcAddress(hws2_32, "FreeAddrInfoExW");
1290 pGetAddrInfoW = (void *)GetProcAddress(hws2_32, "GetAddrInfoW");
1291 pGetAddrInfoExW = (void *)GetProcAddress(hws2_32, "GetAddrInfoExW");
1292 pGetAddrInfoExOverlappedResult = (void *)GetProcAddress(hws2_32, "GetAddrInfoExOverlappedResult");
1293 pInetNtop = (void *)GetProcAddress(hws2_32, "inet_ntop");
1294 pInetNtopW = (void *)GetProcAddress(hws2_32, "InetNtopW");
1295 pInetPtonA = (void *)GetProcAddress(hws2_32, "inet_pton");
1296 pInetPtonW = (void *)GetProcAddress(hws2_32, "InetPtonW");
1297 pWSALookupServiceBeginW = (void *)GetProcAddress(hws2_32, "WSALookupServiceBeginW");
1298 pWSALookupServiceEnd = (void *)GetProcAddress(hws2_32, "WSALookupServiceEnd");
1299 pWSALookupServiceNextW = (void *)GetProcAddress(hws2_32, "WSALookupServiceNextW");
1300 pWSAEnumNameSpaceProvidersA = (void *)GetProcAddress(hws2_32, "WSAEnumNameSpaceProvidersA");
1301 pWSAEnumNameSpaceProvidersW = (void *)GetProcAddress(hws2_32, "WSAEnumNameSpaceProvidersW");
1302 pWSAPoll = (void *)GetProcAddress(hws2_32, "WSAPoll");
1303
1304 hiphlpapi = LoadLibraryA("iphlpapi.dll");
1305 if (hiphlpapi)
1306 {
1307 pGetIpForwardTable = (void *)GetProcAddress(hiphlpapi, "GetIpForwardTable");
1308 pGetAdaptersInfo = (void *)GetProcAddress(hiphlpapi, "GetAdaptersInfo");
1309 }
1310
1311 ntdll = LoadLibraryA("ntdll.dll");
1312 if (ntdll)
1313 pNtClose = (void *)GetProcAddress(ntdll, "NtClose");
1314
1315 ok ( WSAStartup ( ver, &data ) == 0, "WSAStartup failed\n" );
1316 tls = TlsAlloc();
1317 }
1318
1319 static void Exit (void)
1320 {
1321 INT ret, err;
1322 TlsFree ( tls );
1323 ret = WSACleanup();
1324 err = WSAGetLastError();
1325 ok ( ret == 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret, err);
1326 }
1327
1328 static void StartServer (LPTHREAD_START_ROUTINE routine,
1329 test_params *general, server_params *par)
1330 {
1331 par->general = general;
1332 thread[0] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[0] );
1333 ok ( thread[0] != NULL, "Failed to create server thread\n" );
1334 }
1335
1336 static void StartClients (LPTHREAD_START_ROUTINE routine,
1337 test_params *general, client_params *par)
1338 {
1339 int i;
1340 par->general = general;
1341 for ( i = 1; i <= min ( general->n_clients, MAX_CLIENTS ); i++ )
1342 {
1343 client_id = i - 1;
1344 thread[i] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[i] );
1345 ok ( thread[i] != NULL, "Failed to create client thread\n" );
1346 /* Make sure the client is up and running */
1347 WaitForSingleObject ( client_ready[client_id], INFINITE );
1348 };
1349 }
1350
1351 static void do_test( test_setup *test )
1352 {
1353 DWORD i, n = min (test->general.n_clients, MAX_CLIENTS);
1354 DWORD wait;
1355
1356 server_ready = CreateEventA ( NULL, TRUE, FALSE, NULL );
1357 for (i = 0; i <= n; i++)
1358 client_ready[i] = CreateEventA ( NULL, TRUE, FALSE, NULL );
1359
1360 StartServer ( test->srv, &test->general, &test->srv_params );
1361 StartClients ( test->clt, &test->general, &test->clt_params );
1362 WaitForSingleObject ( server_ready, INFINITE );
1363
1364 wait = WaitForMultipleObjects ( 1 + n, thread, TRUE, 1000 * TEST_TIMEOUT );
1365 ok ( wait <= WAIT_OBJECT_0 + n ,
1366 "some threads have not completed: %x\n", wait );
1367
1368 if ( ! ( wait <= WAIT_OBJECT_0 + n ) )
1369 {
1370 for (i = 0; i <= n; i++)
1371 {
1372 if ( WaitForSingleObject ( thread[i], 0 ) != WAIT_OBJECT_0 )
1373 {
1374 trace ("terminating thread %08x\n", thread_id[i]);
1375 TerminateThread ( thread [i], 0 );
1376 }
1377 }
1378 }
1379 CloseHandle ( server_ready );
1380 for (i = 0; i <= n; i++)
1381 CloseHandle ( client_ready[i] );
1382 }
1383
1384 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1385 /* optname = SO_LINGER */
1386 static const LINGER linger_testvals[] = {
1387 {0,0},
1388 {0,73},
1389 {1,0},
1390 {5,189}
1391 };
1392
1393 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1394 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1395 bug in the linux kernel (fixed in 2.6.8) */
1396 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1397
1398 static void test_set_getsockopt(void)
1399 {
1400 SOCKET s, s2;
1401 int i, err, lasterr;
1402 int timeout;
1403 LINGER lingval;
1404 int size;
1405 WSAPROTOCOL_INFOA infoA;
1406 WSAPROTOCOL_INFOW infoW;
1407 char providername[WSAPROTOCOL_LEN + 1];
1408 DWORD value;
1409 struct _prottest
1410 {
1411 int family, type, proto;
1412 } prottest[] = {
1413 {AF_INET, SOCK_STREAM, IPPROTO_TCP},
1414 {AF_INET, SOCK_DGRAM, IPPROTO_UDP},
1415 {AF_INET6, SOCK_STREAM, IPPROTO_TCP},
1416 {AF_INET6, SOCK_DGRAM, IPPROTO_UDP}
1417 };
1418 union _csspace
1419 {
1420 CSADDR_INFO cs;
1421 char space[128];
1422 } csinfoA, csinfoB;
1423
1424 s = socket(AF_INET, SOCK_STREAM, 0);
1425 ok(s!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1426 if( s == INVALID_SOCKET) return;
1427 /* SO_RCVTIMEO */
1428 timeout = SOCKTIMEOUT1;
1429 size = sizeof(timeout);
1430 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1431 if( !err)
1432 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1433 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1434 ok( timeout == SOCKTIMEOUT1, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1435
1436 timeout = 0;
1437 size = sizeof(timeout);
1438 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1439 if( !err)
1440 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1441 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1442 ok( timeout == 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1443
1444 /* SO_SNDTIMEO */
1445 timeout = SOCKTIMEOUT2; /* 997 seconds. See remark above */
1446 size = sizeof(timeout);
1447 err = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, size);
1448 if( !err)
1449 err = getsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, &size);
1450 ok( !err, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1451 ok( timeout == SOCKTIMEOUT2, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout);
1452
1453 /* SO_SNDBUF */
1454 value = 4096;
1455 size = sizeof(value);
1456 err = setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&value, size);
1457 ok( !err, "setsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1458 value = 0xdeadbeef;
1459 err = getsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&value, &size);
1460 ok( !err, "getsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1461 todo_wine ok( value == 4096, "expected 4096, got %u\n", value );
1462
1463 /* SO_RCVBUF */
1464 value = 4096;
1465 size = sizeof(value);
1466 err = setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, size);
1467 ok( !err, "setsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1468 value = 0xdeadbeef;
1469 err = getsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, &size);
1470 ok( !err, "getsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1471 todo_wine ok( value == 4096, "expected 4096, got %u\n", value );
1472
1473 /* SO_LINGER */
1474 for( i = 0; i < ARRAY_SIZE(linger_testvals);i++) {
1475 size = sizeof(lingval);
1476 lingval = linger_testvals[i];
1477 err = setsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, size);
1478 if( !err)
1479 err = getsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, &size);
1480 ok( !err, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
1481 ok( !lingval.l_onoff == !linger_testvals[i].l_onoff &&
1482 (lingval.l_linger == linger_testvals[i].l_linger ||
1483 (!lingval.l_linger && !linger_testvals[i].l_onoff))
1484 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i,
1485 lingval.l_onoff, lingval.l_linger,
1486 linger_testvals[i].l_onoff, linger_testvals[i].l_linger);
1487 }
1488
1489 size = sizeof(lingval);
1490 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, size);
1491 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1492 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1493 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, 0);
1494 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1495 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1496
1497 size = sizeof(BOOL);
1498 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, size);
1499 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1500 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1501 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, 0);
1502 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1503 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1504
1505 /* Test for erroneously passing a value instead of a pointer as optval */
1506 size = sizeof(char);
1507 err = setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)1, size);
1508 ok(err == SOCKET_ERROR, "setsockopt with optval being a value passed "
1509 "instead of failing.\n");
1510 lasterr = WSAGetLastError();
1511 ok(lasterr == WSAEFAULT, "setsockopt with optval being a value "
1512 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1513 lasterr, WSAEFAULT);
1514
1515 /* SO_RCVTIMEO with invalid values for level */
1516 size = sizeof(timeout);
1517 timeout = SOCKTIMEOUT1;
1518 SetLastError(0xdeadbeef);
1519 err = setsockopt(s, 0xffffffff, SO_RCVTIMEO, (char *) &timeout, size);
1520 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1521 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1522 err, WSAGetLastError());
1523
1524 timeout = SOCKTIMEOUT1;
1525 SetLastError(0xdeadbeef);
1526 err = setsockopt(s, 0x00008000, SO_RCVTIMEO, (char *) &timeout, size);
1527 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1528 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1529 err, WSAGetLastError());
1530
1531 /* Test SO_ERROR set/get */
1532 SetLastError(0xdeadbeef);
1533 i = 1234;
1534 err = setsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, size);
1535 todo_wine
1536 ok( !err && !WSAGetLastError(),
1537 "got %d with %d (expected 0 with 0)\n",
1538 err, WSAGetLastError());
1539
1540 SetLastError(0xdeadbeef);
1541 i = 4321;
1542 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1543 todo_wine
1544 ok( !err && !WSAGetLastError(),
1545 "got %d with %d (expected 0 with 0)\n",
1546 err, WSAGetLastError());
1547 todo_wine
1548 ok (i == 1234, "got %d (expected 1234)\n", i);
1549
1550 /* Test invalid optlen */
1551 SetLastError(0xdeadbeef);
1552 size = 1;
1553 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1554 todo_wine
1555 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEFAULT),
1556 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1557 err, WSAGetLastError());
1558
1559 closesocket(s);
1560 /* Test with the closed socket */
1561 SetLastError(0xdeadbeef);
1562 size = sizeof(i);
1563 i = 1234;
1564 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1565 todo_wine
1566 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAENOTSOCK),
1567 "got %d with %d (expected SOCKET_ERROR with WSAENOTSOCK)\n",
1568 err, WSAGetLastError());
1569 ok (i == 1234, "expected 1234, got %d\n", i);
1570
1571 /* Test WS_IP_MULTICAST_TTL with 8, 16, 24 and 32 bits values */
1572 s = socket(AF_INET, SOCK_DGRAM, 0);
1573 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1574 size = sizeof(i);
1575 i = 0x0000000a;
1576 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &i, size);
1577 if (!err)
1578 {
1579 for (i = 0; i < 4; i++)
1580 {
1581 int k, j;
1582 const int tests[] = {0xffffff0a, 0xffff000b, 0xff00000c, 0x0000000d};
1583 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &tests[i], i + 1);
1584 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1585 err = getsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &k, &size);
1586 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1587 j = i != 3 ? tests[i] & ((1 << (i + 1) * 8) - 1) : tests[i];
1588 ok(k == j, "Test [%d] Expected 0x%x, got 0x%x\n", i, j, k);
1589 }
1590 }
1591 else
1592 win_skip("IP_MULTICAST_TTL is unsupported\n");
1593 closesocket(s);
1594
1595 /* test SO_PROTOCOL_INFOA invalid parameters */
1596 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1597 "getsockopt should have failed\n");
1598 err = WSAGetLastError();
1599 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1600 size = sizeof(WSAPROTOCOL_INFOA);
1601 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1602 "getsockopt should have failed\n");
1603 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1604 err = WSAGetLastError();
1605 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1606 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1607 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1608 "getsockopt should have failed\n");
1609 err = WSAGetLastError();
1610 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1611 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, NULL),
1612 "getsockopt should have failed\n");
1613 err = WSAGetLastError();
1614 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1615 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, &size),
1616 "getsockopt should have failed\n");
1617 err = WSAGetLastError();
1618 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1619 size = sizeof(WSAPROTOCOL_INFOA) / 2;
1620 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1621 "getsockopt should have failed\n");
1622 err = WSAGetLastError();
1623 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1624 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1625 size = sizeof(WSAPROTOCOL_INFOA) * 2;
1626 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1627 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1628 ok(size == sizeof(WSAPROTOCOL_INFOA) * 2, "got size %d\n", size);
1629
1630 closesocket(s);
1631
1632 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1633 for (i = 0; i < ARRAY_SIZE(prottest); i++)
1634 {
1635 int k;
1636
1637 s = socket(prottest[i].family, prottest[i].type, prottest[i].proto);
1638 if (s == INVALID_SOCKET && prottest[i].family == AF_INET6) continue;
1639
1640 ok(s != INVALID_SOCKET, "Failed to create socket: %d\n",
1641 WSAGetLastError());
1642
1643 /* compare both A and W version */
1644 infoA.szProtocol[0] = 0;
1645 size = sizeof(WSAPROTOCOL_INFOA);
1646 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1647 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1648 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1649
1650 infoW.szProtocol[0] = 0;
1651 size = sizeof(WSAPROTOCOL_INFOW);
1652 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOW, (char *) &infoW, &size);
1653 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1654 ok(size == sizeof(WSAPROTOCOL_INFOW), "got size %d\n", size);
1655
1656 trace("provider name '%s', family %d, type %d, proto %d\n",
1657 infoA.szProtocol, prottest[i].family, prottest[i].type, prottest[i].proto);
1658
1659 ok(infoA.szProtocol[0], "WSAPROTOCOL_INFOA was not filled\n");
1660 ok(infoW.szProtocol[0], "WSAPROTOCOL_INFOW was not filled\n");
1661
1662 WideCharToMultiByte(CP_ACP, 0, infoW.szProtocol, -1,
1663 providername, sizeof(providername), NULL, NULL);
1664 ok(!strcmp(infoA.szProtocol,providername),
1665 "different provider names '%s' != '%s'\n", infoA.szProtocol, providername);
1666
1667 ok(!memcmp(&infoA, &infoW, FIELD_OFFSET(WSAPROTOCOL_INFOA, szProtocol)),
1668 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1669
1670 /* Remove IF when WSAEnumProtocols support IPV6 data */
1671 ok(infoA.iAddressFamily == prottest[i].family, "socket family invalid, expected %d received %d\n",
1672 prottest[i].family, infoA.iAddressFamily);
1673 ok(infoA.iSocketType == prottest[i].type, "socket type invalid, expected %d received %d\n",
1674 prottest[i].type, infoA.iSocketType);
1675 ok(infoA.iProtocol == prottest[i].proto, "socket protocol invalid, expected %d received %d\n",
1676 prottest[i].proto, infoA.iProtocol);
1677
1678 /* IP_HDRINCL is supported only on SOCK_RAW but passed to SOCK_DGRAM by Impossible Creatures */
1679 size = sizeof(i);
1680 k = 1;
1681 SetLastError(0xdeadbeef);
1682 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1683 if (err == -1) /* >= Vista */
1684 {
1685 todo_wine {
1686 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %d\n", GetLastError());
1687 k = 99;
1688 SetLastError(0xdeadbeef);
1689 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1690 ok(err == -1, "Expected -1, got %d\n", err);
1691 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %d\n", GetLastError());
1692 ok(k == 99, "Expected 99, got %d\n", k);
1693
1694 size = sizeof(k);
1695 k = 0;
1696 SetLastError(0xdeadbeef);
1697 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1698 }
1699 ok(err == -1, "Expected -1, got %d\n", err);
1700 todo_wine {
1701 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %d\n", GetLastError());
1702 k = 99;
1703 SetLastError(0xdeadbeef);
1704 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1705 ok(err == -1, "Expected -1, got %d\n", err);
1706 ok(GetLastError() == WSAEINVAL, "Expected 10022, got %d\n", GetLastError());
1707 ok(k == 99, "Expected 99, got %d\n", k);
1708 }
1709 }
1710 else /* <= 2003 the tests differ between TCP and UDP, UDP silently accepts */
1711 {
1712 SetLastError(0xdeadbeef);
1713 k = 99;
1714 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1715 if (prottest[i].type == SOCK_DGRAM)
1716 {
1717 ok(err == 0, "Expected 0, got %d\n", err);
1718 ok(k == 1, "Expected 1, got %d\n", k);
1719 }
1720 else
1721 {
1722 /* contratry to what we could expect the function returns error but k is changed */
1723 ok(err == -1, "Expected -1, got %d\n", err);
1724 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %d\n", GetLastError());
1725 ok(k == 0, "Expected 0, got %d\n", k);
1726 }
1727
1728 k = 0;
1729 err = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, size);
1730 ok(err == 0, "Expected 0, got %d\n", err);
1731
1732 k = 99;
1733 err = getsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *) &k, &size);
1734 if (prottest[i].type == SOCK_DGRAM)
1735 {
1736 ok(err == 0, "Expected 0, got %d\n", err);
1737 ok(k == 0, "Expected 0, got %d\n", k);
1738 }
1739 else
1740 {
1741 /* contratry to what we could expect the function returns error but k is changed */
1742 ok(err == -1, "Expected -1, got %d\n", err);
1743 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %d\n", GetLastError());
1744 ok(k == 0, "Expected 0, got %d\n", k);
1745 }
1746 }
1747
1748 closesocket(s);
1749 }
1750
1751 /* Test SO_BSP_STATE - Present only in >= Win 2008 */
1752 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1753 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1754 s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1755 ok(s2 != INVALID_SOCKET, "Failed to create socket\n");
1756
1757 SetLastError(0xdeadbeef);
1758 size = sizeof(csinfoA);
1759 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1760 if (!err)
1761 {
1762 struct sockaddr_in saddr;
1763 memset(&saddr, 0, sizeof(saddr));
1764 saddr.sin_family = AF_INET;
1765 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1766
1767 /* Socket is not bound, no information provided */
1768 ok(!csinfoA.cs.LocalAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.LocalAddr.iSockaddrLength);
1769 ok(csinfoA.cs.LocalAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.LocalAddr.lpSockaddr);
1770 /* Socket is not connected, no information provided */
1771 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.RemoteAddr.iSockaddrLength);
1772 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.RemoteAddr.lpSockaddr);
1773
1774 err = bind(s, (struct sockaddr*)&saddr, sizeof(saddr));
1775 ok(!err, "Expected 0, got %d\n", err);
1776 size = sizeof(csinfoA);
1777 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1778 ok(!err, "Expected 0, got %d\n", err);
1779
1780 /* Socket is bound */
1781 ok(csinfoA.cs.LocalAddr.iSockaddrLength, "Expected non-zero\n");
1782 ok(csinfoA.cs.LocalAddr.lpSockaddr != NULL, "Expected non-null\n");
1783 /* Socket is not connected, no information provided */
1784 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.RemoteAddr.iSockaddrLength);
1785 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.RemoteAddr.lpSockaddr);
1786
1787 err = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1788 ok(!err, "Expected 0, got %d\n", err);
1789 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1790 ok(!err, "Expected 0, got %d\n", err);
1791 err = listen(s2, 1);
1792 ok(!err, "Expected 0, got %d\n", err);
1793 err = connect(s, (struct sockaddr*)&saddr, sizeof(saddr));
1794 ok(!err, "Expected 0, got %d\n", err);
1795 size = sizeof(saddr);
1796 err = accept(s2, (struct sockaddr*)&saddr, &size);
1797 ok(err != INVALID_SOCKET, "Failed to accept socket\n");
1798 closesocket(s2);
1799 s2 = err;
1800
1801 size = sizeof(csinfoA);
1802 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1803 ok(!err, "Expected 0, got %d\n", err);
1804 err = getsockopt(s2, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoB, &size);
1805 ok(!err, "Expected 0, got %d\n", err);
1806 ok(size == sizeof(csinfoA), "Got %d\n", size);
1807 size = sizeof(saddr);
1808 ok(size == csinfoA.cs.LocalAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1809 csinfoA.cs.LocalAddr.iSockaddrLength);
1810 ok(size == csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1811 csinfoA.cs.RemoteAddr.iSockaddrLength);
1812 ok(!memcmp(csinfoA.cs.LocalAddr.lpSockaddr, csinfoB.cs.RemoteAddr.lpSockaddr, size),
1813 "Expected matching addresses\n");
1814 ok(!memcmp(csinfoB.cs.LocalAddr.lpSockaddr, csinfoA.cs.RemoteAddr.lpSockaddr, size),
1815 "Expected matching addresses\n");
1816 ok(csinfoA.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1817 ok(csinfoB.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1818 ok(csinfoA.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1819 ok(csinfoB.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1820
1821 err = getpeername(s, (struct sockaddr *)&saddr, &size);
1822 ok(!err, "Expected 0, got %d\n", err);
1823 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1824 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1825 err = getpeername(s2, (struct sockaddr *)&saddr, &size);
1826 ok(!err, "Expected 0, got %d\n", err);
1827 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1828 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1829 err = getsockname(s, (struct sockaddr *)&saddr, &size);
1830 ok(!err, "Expected 0, got %d\n", err);
1831 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1832 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1833 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1834 ok(!err, "Expected 0, got %d\n", err);
1835 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1836 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1837
1838 SetLastError(0xdeadbeef);
1839 size = sizeof(CSADDR_INFO);
1840 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1841 ok(err, "Expected non-zero\n");
1842 ok(size == sizeof(CSADDR_INFO), "Got %d\n", size);
1843 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %d\n", GetLastError());
1844
1845 /* At least for IPv4 the size is exactly 56 bytes */
1846 size = sizeof(*csinfoA.cs.LocalAddr.lpSockaddr) * 2 + sizeof(csinfoA.cs);
1847 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1848 ok(!err, "Expected 0, got %d\n", err);
1849 size--;
1850 SetLastError(0xdeadbeef);
1851 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1852 ok(err, "Expected non-zero\n");
1853 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %d\n", GetLastError());
1854 }
1855 else
1856 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %d\n", GetLastError());
1857
1858 closesocket(s);
1859 closesocket(s2);
1860
1861 for (i = 0; i < 2; i++)
1862 {
1863 int family, level;
1864
1865 if (i)
1866 {
1867 family = AF_INET6;
1868 level = IPPROTO_IPV6;
1869 }
1870 else
1871 {
1872 family = AF_INET;
1873 level = IPPROTO_IP;
1874 }
1875
1876 s = socket(family, SOCK_DGRAM, 0);
1877 if (s == INVALID_SOCKET && i)
1878 {
1879 skip("IPv6 is not supported\n");
1880 break;
1881 }
1882 ok(s != INVALID_SOCKET, "socket failed with error %d\n", GetLastError());
1883
1884 size = sizeof(value);
1885 value = 0xdead;
1886 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1887 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1888 ok(value == 0, "Expected 0, got %d\n", value);
1889
1890 size = sizeof(value);
1891 value = 1;
1892 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
1893 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1894
1895 value = 0xdead;
1896 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1897 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1898 ok(value == 1, "Expected 1, got %d\n", value);
1899
1900 size = sizeof(value);
1901 value = 0xdead;
1902 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
1903 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1904
1905 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1906 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1907 ok(value == 1, "Expected 1, got %d\n", value);
1908
1909 closesocket(s);
1910
1911 s = socket(family, SOCK_STREAM, 0);
1912 if (s == INVALID_SOCKET && i)
1913 {
1914 skip("IPv6 is not supported\n");
1915 break;
1916 }
1917 ok(s != INVALID_SOCKET, "socket failed with error %d\n", GetLastError());
1918
1919 size = sizeof(value);
1920 value = 0xdead;
1921 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1922 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1923 ok(value == 1 || broken(value == 0) /* < vista */, "Expected 1, got %d\n", value);
1924
1925 size = sizeof(value);
1926 value = 0;
1927 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
1928 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1929
1930 value = 0xdead;
1931 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1932 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1933 ok(value == 0, "Expected 0, got %d\n", value);
1934
1935 closesocket(s);
1936
1937 s = socket(family, SOCK_RAW, 0);
1938 if (s == INVALID_SOCKET)
1939 {
1940 if (WSAGetLastError() == WSAEACCES) skip("SOCK_RAW is not available\n");
1941 else if (i) skip("IPv6 is not supported\n");
1942 break;
1943 }
1944 ok(s != INVALID_SOCKET, "socket failed with error %d\n", GetLastError());
1945
1946 size = sizeof(value);
1947 value = 0xdead;
1948 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1949 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1950 ok(value == 0, "Expected 0, got %d\n", value);
1951
1952 size = sizeof(value);
1953 value = 1;
1954 err = setsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, size);
1955 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1956
1957 value = 0xdead;
1958 err = getsockopt(s, level, IP_DONTFRAGMENT, (char *) &value, &size);
1959 ok(!err, "Expected 0, got %d with error %d\n", err, GetLastError());
1960 ok(value == 1, "Expected 1, got %d\n", value);
1961
1962 closesocket(s);
1963 }
1964 }
1965
1966 static void test_so_reuseaddr(void)
1967 {
1968 struct sockaddr_in saddr;
1969 SOCKET s1,s2;
1970 unsigned int rc,reuse;
1971 int size;
1972 DWORD err;
1973
1974 saddr.sin_family = AF_INET;
1975 saddr.sin_port = htons(SERVERPORT+1);
1976 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1977
1978 s1=socket(AF_INET, SOCK_STREAM, 0);
1979 ok(s1!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1980 rc = bind(s1, (struct sockaddr*)&saddr, sizeof(saddr));
1981 ok(rc!=SOCKET_ERROR, "bind(s1) failed error: %d\n", WSAGetLastError());
1982
1983 s2=socket(AF_INET, SOCK_STREAM, 0);
1984 ok(s2!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1985
1986 reuse=0x1234;
1987 size=sizeof(reuse);
1988 rc=getsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, &size );
1989 ok(rc==0 && reuse==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc,reuse);
1990
1991 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1992 ok(rc==SOCKET_ERROR, "bind() succeeded\n");
1993
1994 reuse = 1;
1995 rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
1996 ok(rc==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1997
1998 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1999 * a port immediately after closing another socket on that port, so
2000 * basically following the BSD socket semantics here. */
2001 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
2002 if(rc==0)
2003 {
2004 int s3=socket(AF_INET, SOCK_STREAM, 0), s4;
2005 trace("<= Win XP behavior of SO_REUSEADDR\n");
2006
2007 /* If we could bind again in the same port this is Windows version <= XP.
2008 * Lets test if we can really connect to one of them. */
2009 set_blocking(s1, FALSE);
2010 set_blocking(s2, FALSE);
2011 rc = listen(s1, 1);
2012 ok(!rc, "listen() failed with error: %d\n", WSAGetLastError());
2013 rc = listen(s2, 1);
2014 ok(!rc, "listen() failed with error: %d\n", WSAGetLastError());
2015 rc = connect(s3, (struct sockaddr*)&saddr, sizeof(saddr));
2016 ok(!rc, "connecting to accepting socket failed %d\n", WSAGetLastError());
2017
2018 /* the delivery of the connection is random so we need to try on both sockets */
2019 size = sizeof(saddr);
2020 s4 = accept(s1, (struct sockaddr*)&saddr, &size);
2021 if(s4 == INVALID_SOCKET)
2022 s4 = accept(s2, (struct sockaddr*)&saddr, &size);
2023 ok(s4 != INVALID_SOCKET, "none of the listening sockets could get the connection\n");
2024
2025 closesocket(s1);
2026 closesocket(s3);
2027 closesocket(s4);
2028 }
2029 else
2030 {
2031 trace(">= Win 2003 behavior of SO_REUSEADDR\n");
2032 err = WSAGetLastError();
2033 ok(err==WSAEACCES, "expected 10013, got %d\n", err);
2034
2035 closesocket(s1);
2036 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
2037 ok(rc==0, "bind() failed error: %d\n", WSAGetLastError());
2038 }
2039
2040 closesocket(s2);
2041 }
2042
2043 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
2044
2045 static void test_ip_pktinfo(void)
2046 {
2047 ULONG addresses[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY)};
2048 char recvbuf[10], pktbuf[512], msg[] = "HELLO";
2049 struct sockaddr_in s1addr, s2addr, s3addr;
2050 GUID WSARecvMsg_GUID = WSAID_WSARECVMSG;
2051 LPFN_WSARECVMSG pWSARecvMsg = NULL;
2052 unsigned int rc, yes = 1;
2053 BOOL foundhdr;
2054 DWORD dwBytes, dwSize, dwFlags;
2055 socklen_t addrlen;
2056 WSACMSGHDR *cmsg;
2057 WSAOVERLAPPED ov;
2058 WSABUF iovec[1];
2059 SOCKET s1, s2;
2060 WSAMSG hdr;
2061 int i, err;
2062
2063 memset(&ov, 0, sizeof(ov));
2064 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
2065 if (ov.hEvent == INVALID_HANDLE_VALUE)
2066 {
2067 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
2068 return;
2069 }
2070
2071 memset(&hdr, 0x00, sizeof(hdr));
2072 s1addr.sin_family = AF_INET;
2073 s1addr.sin_port = htons(0);
2074 /* Note: s1addr.sin_addr is set below */
2075 iovec[0].buf = recvbuf;
2076 iovec[0].len = sizeof(recvbuf);
2077 hdr.name = (struct sockaddr*)&s3addr;
2078 hdr.namelen = sizeof(s3addr);
2079 hdr.lpBuffers = &iovec[0];
2080 hdr.dwBufferCount = 1;
2081 hdr.Control.buf = pktbuf;
2082 /* Note: hdr.Control.len is set below */
2083 hdr.dwFlags = 0;
2084
2085 for (i=0;i<ARRAY_SIZE(addresses);i++)
2086 {
2087 s1addr.sin_addr.s_addr = addresses[i];
2088
2089 /* Build "server" side socket */
2090 s1=socket(AF_INET, SOCK_DGRAM, 0);
2091 if (s1 == INVALID_SOCKET)
2092 {
2093 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
2094 goto cleanup;
2095 }
2096
2097 /* Obtain the WSARecvMsg function */
2098 WSAIoctl(s1, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
2099 &pWSARecvMsg, sizeof(pWSARecvMsg), &dwBytes, NULL, NULL);
2100 if (!pWSARecvMsg)
2101 {
2102 win_skip("WSARecvMsg is unsupported, some tests will be skipped.\n");
2103 closesocket(s1);
2104 goto cleanup;
2105 }
2106
2107 /* Setup the server side socket */
2108 rc=bind(s1, (struct sockaddr*)&s1addr, sizeof(s1addr));
2109 ok(rc != SOCKET_ERROR, "bind() failed error: %d\n", WSAGetLastError());
2110
2111 /* Build "client" side socket */
2112 addrlen = sizeof(s2addr);
2113 if (getsockname(s1, (struct sockaddr *) &s2addr, &addrlen) != 0)
2114 {
2115 skip("Failed to call getsockname, some tests skipped: %d\n", WSAGetLastError());
2116 closesocket(s1);
2117 goto cleanup;
2118 }
2119 s2addr.sin_addr.s_addr = addresses[0]; /* Always target the local adapter address */
2120 s2=socket(AF_INET, SOCK_DGRAM, 0);
2121 if (s2 == INVALID_SOCKET)
2122 {
2123 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
2124 closesocket(s1);
2125 goto cleanup;
2126 }
2127
2128 /* Test an empty message header */
2129 rc=pWSARecvMsg(s1, NULL, NULL, NULL, NULL);
2130 err=WSAGetLastError();
2131 ok(rc == SOCKET_ERROR && err == WSAEFAULT, "WSARecvMsg() failed error: %d (ret = %d)\n", err, rc);
2132
2133 /* Test that when no control data arrives, a 0-length NULL-valued control buffer should succeed */
2134 SetLastError(0xdeadbeef);
2135 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2136 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2137 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
2138 hdr.Control.buf = NULL;
2139 hdr.Control.len = 0;
2140 rc=pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
2141 ok(rc == 0, "WSARecvMsg() failed error: %d\n", WSAGetLastError());
2142 hdr.Control.buf = pktbuf;
2143
2144 /* Now start IP_PKTINFO for future tests */
2145 rc=setsockopt(s1, IPPROTO_IP, IP_PKTINFO, (const char*)&yes, sizeof(yes));
2146 ok(rc == 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
2147
2148 /*
2149 * Send a packet from the client to the server and test for specifying
2150 * a short control header.
2151 */
2152 SetLastError(0xdeadbeef);
2153 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2154 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2155 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
2156 hdr.Control.len = 1;
2157 rc=pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
2158 err=WSAGetLastError();
2159 ok(rc == SOCKET_ERROR && err == WSAEMSGSIZE && (hdr.dwFlags & MSG_CTRUNC),
2160 "WSARecvMsg() failed error: %d (ret: %d, flags: %d)\n", err, rc, hdr.dwFlags);
2161 hdr.dwFlags = 0; /* Reset flags */
2162
2163 /* Perform another short control header test, this time with an overlapped receive */
2164 hdr.Control.len = 1;
2165 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
2166 err=WSAGetLastError();
2167 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
2168 SetLastError(0xdeadbeef);
2169 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2170 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2171 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
2172 if (WaitForSingleObject(ov.hEvent, 100) != WAIT_OBJECT_0)
2173 {
2174 skip("Server side did not receive packet, some tests skipped.\n");
2175 closesocket(s2);
2176 closesocket(s1);
2177 continue;
2178 }
2179 dwFlags = 0;
2180 WSAGetOverlappedResult(s1, &ov, NULL, FALSE, &dwFlags);
2181 ok(dwFlags == 0,
2182 "WSAGetOverlappedResult() returned unexpected flags %d!\n", dwFlags);
2183 ok(hdr.dwFlags == MSG_CTRUNC,
2184 "WSARecvMsg() overlapped operation set unexpected flags %d.\n", hdr.dwFlags);
2185 hdr.dwFlags = 0; /* Reset flags */
2186
2187 /*
2188 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
2189 * on the server end and check that the returned packet matches what was sent.
2190 */
2191 hdr.Control.len = sizeof(pktbuf);
2192 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
2193 err=WSAGetLastError();
2194 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
2195 ok(hdr.Control.len == sizeof(pktbuf),
2196 "WSARecvMsg() control length mismatch (%d != sizeof pktbuf).\n", hdr.Control.len);
2197 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
2198 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
2199 if (WaitForSingleObject(ov.hEvent, 100) != WAIT_OBJECT_0)
2200 {
2201 skip("Server side did not receive packet, some tests skipped.\n");
2202 closesocket(s2);
2203 closesocket(s1);
2204 continue;
2205 }
2206 dwSize = 0;
2207 WSAGetOverlappedResult(s1, &ov, &dwSize, FALSE, NULL);
2208 ok(dwSize == sizeof(msg),
2209 "WSARecvMsg() buffer length does not match transmitted data!\n");
2210 ok(strncmp(iovec[0].buf, msg, sizeof(msg)) == 0,
2211 "WSARecvMsg() buffer does not match transmitted data!\n");
2212 ok(hdr.Control.len == IP_PKTINFO_LEN,
2213 "WSARecvMsg() control length mismatch (%d).\n", hdr.Control.len);
2214
2215 /* Test for the expected IP_PKTINFO return information. */
2216 foundhdr = FALSE;
2217 for (cmsg = WSA_CMSG_FIRSTHDR(&hdr); cmsg != NULL; cmsg = WSA_CMSG_NXTHDR(&hdr, cmsg))
2218 {
2219 if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO)
2220 {
2221 struct in_pktinfo *pi = (struct in_pktinfo *)WSA_CMSG_DATA(cmsg);
2222
2223 ok(pi->ipi_addr.s_addr == s2addr.sin_addr.s_addr, "destination ip mismatch!\n");
2224 foundhdr = TRUE;
2225 }
2226 }
2227 ok(foundhdr, "IP_PKTINFO header information was not returned!\n");
2228
2229 closesocket(s2);
2230 closesocket(s1);
2231 }
2232
2233 cleanup:
2234 CloseHandle(ov.hEvent);
2235 }
2236
2237 /************* Array containing the tests to run **********/
2238
2239 #define STD_STREAM_SOCKET \
2240 SOCK_STREAM, \
2241 0, \
2242 SERVERIP, \
2243 SERVERPORT
2244
2245 static test_setup tests [] =
2246 {
2247 /* Test 0: synchronous client and server */
2248 {
2249 {
2250 STD_STREAM_SOCKET,
2251 2048,
2252 16,
2253 2
2254 },
2255 simple_server,
2256 {
2257 NULL,
2258 0,
2259 64
2260 },
2261 simple_client,
2262 {
2263 NULL,
2264 0,
2265 128
2266 }
2267 },
2268 /* Test 1: event-driven client, synchronous server */
2269 {
2270 {
2271 STD_STREAM_SOCKET,
2272 2048,
2273 16,
2274 2
2275 },
2276 simple_server,
2277 {
2278 NULL,
2279 0,
2280 64
2281 },
2282 event_client,
2283 {
2284 NULL,
2285 WSA_FLAG_OVERLAPPED,
2286 128
2287 }
2288 },
2289 /* Test 2: synchronous client, non-blocking server via select() */
2290 {
2291 {
2292 STD_STREAM_SOCKET,
2293 2048,
2294 16,
2295 2
2296 },
2297 select_server,
2298 {
2299 NULL,
2300 0,
2301 64
2302 },
2303 simple_client,
2304 {
2305 NULL,
2306 0,
2307 128
2308 }
2309 },
2310 /* Test 3: OOB client, OOB server */
2311 {
2312 {
2313 STD_STREAM_SOCKET,
2314 128,
2315 16,
2316 1
2317 },
2318 oob_server,
2319 {
2320 NULL,
2321 0,
2322 128
2323 },
2324 oob_client,
2325 {
2326 NULL,
2327 0,
2328 128
2329 }
2330 },
2331 /* Test 4: synchronous mixed client and server */
2332 {
2333 {
2334 STD_STREAM_SOCKET,
2335 2048,
2336 16,
2337 2
2338 },
2339 simple_server,
2340 {
2341 NULL,
2342 0,
2343 64
2344 },
2345 simple_mixed_client,
2346 {
2347 NULL,
2348 0,
2349 128
2350 }
2351 }
2352 };
2353
2354 static void test_UDP(void)
2355 {
2356 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
2357 possible that this test fails due to dropped packets. */
2358
2359 /* peer 0 receives data from all other peers */
2360 struct sock_info peer[NUM_UDP_PEERS];
2361 char buf[16];
2362 int ss, i, n_recv, n_sent;
2363
2364 memset (buf,0,sizeof(buf));
2365 for ( i = NUM_UDP_PEERS - 1; i >= 0; i-- ) {
2366 ok ( ( peer[i].s = socket ( AF_INET, SOCK_DGRAM, 0 ) ) != INVALID_SOCKET, "UDP: socket failed\n" );
2367
2368 peer[i].addr.sin_family = AF_INET;
2369 peer[i].addr.sin_addr.s_addr = inet_addr ( SERVERIP );
2370
2371 if ( i == 0 ) {
2372 peer[i].addr.sin_port = htons ( SERVERPORT );
2373 } else {
2374 peer[i].addr.sin_port = htons ( 0 );
2375 }
2376
2377 do_bind ( peer[i].s, (struct sockaddr *) &peer[i].addr, sizeof( peer[i].addr ) );
2378
2379 /* test getsockname() to get peer's port */
2380 ss = sizeof ( peer[i].addr );
2381 ok ( getsockname ( peer[i].s, (struct sockaddr *) &peer[i].addr, &ss ) != SOCKET_ERROR, "UDP: could not getsockname()\n" );
2382 ok ( peer[i].addr.sin_port != htons ( 0 ), "UDP: bind() did not associate port\n" );
2383 }
2384
2385 /* test getsockname() */
2386 ok ( peer[0].addr.sin_port == htons ( SERVERPORT ), "UDP: getsockname returned incorrect peer port\n" );
2387
2388 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
2389 /* send client's ip */
2390 memcpy( buf, &peer[i].addr.sin_port, sizeof(peer[i].addr.sin_port) );
2391 n_sent = sendto ( peer[i].s, buf, sizeof(buf), 0, (struct sockaddr*) &peer[0].addr, sizeof(peer[0].addr) );
2392 ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
2393 }
2394
2395 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
2396 n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0,(struct sockaddr *) &peer[0].peer, &ss );
2397 ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
2398 ok ( memcmp ( &peer[0].peer.sin_port, buf, sizeof(peer[0].addr.sin_port) ) == 0, "UDP: port numbers do not match\n" );
2399 }
2400 }
2401
2402 static DWORD WINAPI do_getservbyname( void *param )
2403 {
2404 struct {
2405 const char *name;
2406 const char *proto;
2407 int port;
2408 } serv[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
2409
2410 HANDLE *starttest = param;
2411 int i, j;
2412 struct servent *pserv[2];
2413
2414 ok ( WaitForSingleObject ( *starttest, TEST_TIMEOUT * 1000 ) != WAIT_TIMEOUT,
2415 "test_getservbyname: timeout waiting for start signal\n" );
2416
2417 /* ensure that necessary buffer resizes are completed */
2418 for ( j = 0; j < 2; j++) {
2419 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
2420 }
2421
2422 for ( i = 0; i < NUM_QUERIES / 2; i++ ) {
2423 for ( j = 0; j < 2; j++ ) {
2424 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
2425 ok ( pserv[j] != NULL || broken(pserv[j] == NULL) /* win8, fixed in win81 */,
2426 "getservbyname could not retrieve information for %s: %d\n", serv[j].name, WSAGetLastError() );
2427 if ( !pserv[j] ) continue;
2428 ok ( pserv[j]->s_port == htons(serv[j].port),
2429 "getservbyname returned the wrong port for %s: %d\n", serv[j].name, ntohs(pserv[j]->s_port) );
2430 ok ( !strcmp ( pserv[j]->s_proto, serv[j].proto ),
2431 "getservbyname returned the wrong protocol for %s: %s\n", serv[j].name, pserv[j]->s_proto );
2432 ok ( !strcmp ( pserv[j]->s_name, serv[j].name ),
2433 "getservbyname returned the wrong name for %s: %s\n", serv[j].name, pserv[j]->s_name );
2434 }
2435
2436 ok ( pserv[0] == pserv[1] || broken(pserv[0] != pserv[1]) /* win8, fixed in win81 */,
2437 "getservbyname: winsock resized servent buffer when not necessary\n" );
2438 }
2439
2440 return 0;
2441 }
2442
2443 static void test_getservbyname(void)
2444 {
2445 int i;
2446 HANDLE starttest, thread[NUM_THREADS];
2447 DWORD thread_id[NUM_THREADS];
2448
2449 starttest = CreateEventA ( NULL, 1, 0, "test_getservbyname_starttest" );
2450
2451 /* create threads */
2452 for ( i = 0; i < NUM_THREADS; i++ ) {
2453 thread[i] = CreateThread ( NULL, 0, do_getservbyname, &starttest, 0, &thread_id[i] );
2454 }
2455
2456 /* signal threads to start */
2457 SetEvent ( starttest );
2458
2459 for ( i = 0; i < NUM_THREADS; i++) {
2460 WaitForSingleObject ( thread[i], TEST_TIMEOUT * 1000 );
2461 }
2462 }
2463
2464 static void test_WSASocket(void)
2465 {
2466 SOCKET sock = INVALID_SOCKET;
2467 WSAPROTOCOL_INFOA *pi;
2468 int wsaproviders[] = {IPPROTO_TCP, IPPROTO_IP};
2469 int autoprotocols[] = {IPPROTO_TCP, IPPROTO_UDP};
2470 int items, err, size, socktype, i, j;
2471 UINT pi_size;
2472
2473 SetLastError(0xdeadbeef);
2474 ok(WSASocketA(0, 0, 0, NULL, 0, 0) == INVALID_SOCKET,
2475 "WSASocketA should have failed\n");
2476 err = WSAGetLastError();
2477 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2478
2479 sock = WSASocketA(AF_INET, 0, 0, NULL, 0, 0);
2480 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2481 closesocket(sock);
2482
2483 sock = WSASocketA(AF_INET, SOCK_STREAM, 0, NULL, 0, 0);
2484 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2485 closesocket(sock);
2486
2487 SetLastError(0xdeadbeef);
2488 ok(WSASocketA(0, SOCK_STREAM, -1, NULL, 0, 0) == INVALID_SOCKET,
2489 "WSASocketA should have failed\n");
2490 err = WSAGetLastError();
2491 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2492
2493 SetLastError(0xdeadbeef);
2494 ok(WSASocketA(0, -1, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
2495 "WSASocketA should have failed\n");
2496 err = WSAGetLastError();
2497 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2498
2499 SetLastError(0xdeadbeef);
2500 ok(WSASocketA(0, -1, 0, NULL, 0, 0) == INVALID_SOCKET,
2501 "WSASocketA should have failed\n");
2502 err = WSAGetLastError();
2503 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2504
2505 SetLastError(0xdeadbeef);
2506 ok(WSASocketA(AF_INET, -1, 0, NULL, 0, 0) == INVALID_SOCKET,
2507 "WSASocketA should have failed\n");
2508 err = WSAGetLastError();
2509 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2510
2511 SetLastError(0xdeadbeef);
2512 ok(WSASocketA(AF_INET, 0, -1, NULL, 0, 0) == INVALID_SOCKET,
2513 "WSASocketA should have failed\n");
2514 err = WSAGetLastError();
2515 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2516
2517 SetLastError(0xdeadbeef);
2518 ok(WSASocketA(0, -1, -1, NULL, 0, 0) == INVALID_SOCKET,
2519 "WSASocketA should have failed\n");
2520 err = WSAGetLastError();
2521 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2522
2523 SetLastError(0xdeadbeef);
2524 ok(WSASocketA(-1, SOCK_STREAM, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
2525 "WSASocketA should have failed\n");
2526 err = WSAGetLastError();
2527 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
2528
2529 sock = WSASocketA(AF_INET, 0, IPPROTO_TCP, NULL, 0, 0);
2530 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2531 closesocket(sock);
2532
2533 SetLastError(0xdeadbeef);
2534 ok(WSASocketA(0, SOCK_STREAM, 0, NULL, 0, 0) == INVALID_SOCKET,
2535 "WSASocketA should have failed\n");
2536 err = WSAGetLastError();
2537 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2538
2539 SetLastError(0xdeadbeef);
2540 ok(WSASocketA(0, 0, 0xdead, NULL, 0, 0) == INVALID_SOCKET,
2541 "WSASocketA should have failed\n");
2542 err = WSAGetLastError();
2543 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2544
2545 SetLastError(0xdeadbeef);
2546 ok(WSASocketA(AF_INET, 0xdead, 0, NULL, 0, 0) == INVALID_SOCKET,
2547 "WSASocketA should have failed\n");
2548 err = WSAGetLastError();
2549 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2550
2551 SetLastError(0xdeadbeef);
2552 ok(WSASocketA(0, 0xdead, 0, NULL, 0, 0) == INVALID_SOCKET,
2553 "WSASocketA should have failed\n");
2554 err = WSAGetLastError();
2555 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2556
2557 sock = WSASocketA(0, 0, IPPROTO_TCP, NULL, 0, 0);
2558 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2559 closesocket(sock);
2560
2561 /* SOCK_STREAM does not support IPPROTO_UDP */
2562 SetLastError(0xdeadbeef);
2563 ok(WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
2564 "WSASocketA should have failed\n");
2565 err = WSAGetLastError();
2566 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2567
2568 /* SOCK_DGRAM does not support IPPROTO_TCP */
2569 SetLastError(0xdeadbeef);
2570 ok(WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_TCP, NULL, 0, 0) == INVALID_SOCKET,
2571 "WSASocketA should have failed\n");
2572 err = WSAGetLastError();
2573 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2574
2575 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
2576 * to avoid a crash on win98.
2577 */
2578 pi_size = 0;
2579 items = WSAEnumProtocolsA(wsaproviders, NULL, &pi_size);
2580 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
2581 items);
2582 err = WSAGetLastError();
2583 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2584 err, WSAENOBUFS);
2585
2586 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
2587 ok(pi != NULL, "Failed to allocate memory\n");
2588 if (pi == NULL) {
2589 skip("Can't continue without memory.\n");
2590 return;
2591 }
2592
2593 items = WSAEnumProtocolsA(wsaproviders, pi, &pi_size);
2594 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
2595 WSAGetLastError());
2596
2597 if (items == 0) {
2598 skip("No protocols enumerated.\n");
2599 HeapFree(GetProcessHeap(), 0, pi);
2600 return;
2601 }
2602
2603 sock = WSASocketA(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
2604 FROM_PROTOCOL_INFO, &pi[0], 0, 0);
2605 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2606 WSAGetLastError());
2607 closesocket(sock);
2608
2609 /* find what parameters are used first: plain parameters or protocol info struct */
2610 pi[0].iProtocol = -1;
2611 pi[0].iSocketType = -1;
2612 pi[0].iAddressFamily = -1;
2613 ok(WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0) == INVALID_SOCKET,
2614 "WSASocketA should have failed\n");
2615 err = WSAGetLastError();
2616 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
2617
2618 pi[0].iProtocol = 0;
2619 pi[0].iSocketType = 0;
2620 pi[0].iAddressFamily = 0;
2621 sock = WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0);
2622 if(sock != INVALID_SOCKET)
2623 {
2624 win_skip("must work only in OS <= 2003\n");
2625 closesocket(sock);
2626 }
2627 else
2628 {
2629 err = WSAGetLastError();
2630 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
2631 }
2632
2633 pi[0].iProtocol = IPPROTO_UDP;
2634 pi[0].iSocketType = SOCK_DGRAM;
2635 pi[0].iAddressFamily = AF_INET;
2636 sock = WSASocketA(0, 0, 0, &pi[0], 0, 0);
2637 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2638 WSAGetLastError());
2639 size = sizeof(socktype);
2640 socktype = 0xdead;
2641 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2642 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2643 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2644 SOCK_DGRAM, socktype);
2645 closesocket(sock);
2646
2647 sock = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, &pi[0], 0, 0);
2648 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2649 WSAGetLastError());
2650 size = sizeof(socktype);
2651 socktype = 0xdead;
2652 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2653 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2654 ok(socktype == SOCK_STREAM, "Wrong socket type, expected %d received %d\n",
2655 SOCK_STREAM, socktype);
2656 closesocket(sock);
2657
2658 HeapFree(GetProcessHeap(), 0, pi);
2659
2660 pi_size = 0;
2661 items = WSAEnumProtocolsA(NULL, NULL, &pi_size);
2662 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
2663 items);
2664 err = WSAGetLastError();
2665 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2666 err, WSAENOBUFS);
2667
2668 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
2669 ok(pi != NULL, "Failed to allocate memory\n");
2670 if (pi == NULL) {
2671 skip("Can't continue without memory.\n");
2672 return;
2673 }
2674
2675 items = WSAEnumProtocolsA(NULL, pi, &pi_size);
2676 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
2677 WSAGetLastError());
2678
2679 /* when no protocol and socket type are specified the first entry
2680 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
2681 * is returned */
2682 sock = WSASocketA(AF_INET, 0, 0, NULL, 0, 0);
2683 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2684 WSAGetLastError());
2685
2686 size = sizeof(socktype);
2687 socktype = 0xdead;
2688 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2689 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2690 for(i = 0; i < items; i++)
2691 {
2692 if(pi[i].dwProviderFlags & PFL_MATCHES_PROTOCOL_ZERO)
2693 {
2694 ok(socktype == pi[i].iSocketType, "Wrong socket type, expected %d received %d\n",
2695 pi[i].iSocketType, socktype);
2696 break;
2697 }
2698 }
2699 ok(i != items, "Creating a socket without protocol and socket type didn't work\n");
2700 closesocket(sock);
2701
2702 /* when no socket type is specified the first entry from WSAEnumProtocols
2703 * that matches the protocol is returned */
2704 for (i = 0; i < ARRAY_SIZE(autoprotocols); i++)
2705 {
2706 sock = WSASocketA(0, 0, autoprotocols[i], NULL, 0, 0);
2707 ok(sock != INVALID_SOCKET, "Failed to create socket for protocol %d, received %d\n",
2708 autoprotocols[i], WSAGetLastError());
2709
2710 size = sizeof(socktype);
2711 socktype = 0xdead;
2712 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2713 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2714
2715 for (err = 1, j = 0; j < items; j++)
2716 {
2717 if (pi[j].iProtocol == autoprotocols[i])
2718 {
2719 if (socktype == pi[j].iSocketType)
2720 err = 0;
2721 else
2722 ok(0, "Wrong socket type, expected %d received %d\n",
2723 pi[j].iSocketType, socktype);
2724 break;
2725 }
2726 }
2727 ok(!err, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols[i]);
2728
2729 closesocket(sock);
2730 }
2731
2732 HeapFree(GetProcessHeap(), 0, pi);
2733
2734 SetLastError(0xdeadbeef);
2735 /* starting on vista the socket function returns error during the socket
2736 creation and no longer in the socket operations (sendto, readfrom) */
2737 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
2738 if (sock == INVALID_SOCKET)
2739 {
2740 err = WSAGetLastError();
2741 ok(err == WSAEACCES, "Expected 10013, received %d\n", err);
2742 skip("SOCK_RAW is not supported\n");
2743 }
2744 else
2745 {
2746 trace("SOCK_RAW is supported\n");
2747
2748 size = sizeof(socktype);
2749 socktype = 0xdead;
2750 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2751 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2752 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2753 SOCK_RAW, socktype);
2754 closesocket(sock);
2755
2756 todo_wine {
2757 sock = WSASocketA(0, 0, IPPROTO_RAW, NULL, 0, 0);
2758 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2759 WSAGetLastError());
2760 size = sizeof(socktype);
2761 socktype = 0xdead;
2762 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2763 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2764 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2765 SOCK_RAW, socktype);
2766 closesocket(sock);
2767 }
2768
2769 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_TCP, NULL, 0, 0);
2770 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2771 WSAGetLastError());
2772 size = sizeof(socktype);
2773 socktype = 0xdead;
2774 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2775 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2776 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2777 SOCK_RAW, socktype);
2778 closesocket(sock);
2779 }
2780
2781 /* IPX socket tests */
2782
2783 SetLastError(0xdeadbeef);
2784 sock = WSASocketA(AF_IPX, SOCK_DGRAM, NSPROTO_IPX, NULL, 0, 0);
2785 if (sock == INVALID_SOCKET)
2786 {
2787 err = WSAGetLastError();
2788 ok(err == WSAEAFNOSUPPORT || broken(err == WSAEPROTONOSUPPORT), "Expected 10047, received %d\n", err);
2789 skip("IPX is not supported\n");
2790 }
2791 else
2792 {
2793 WSAPROTOCOL_INFOA info;
2794 closesocket(sock);
2795
2796 trace("IPX is supported\n");
2797
2798 sock = WSASocketA(0, 0, NSPROTO_IPX, NULL, 0, 0);
2799 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2800 WSAGetLastError());
2801
2802 size = sizeof(socktype);
2803 socktype = 0xdead;
2804 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2805 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2806 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2807 SOCK_DGRAM, socktype);
2808
2809 /* check socket family, type and protocol */
2810 size = sizeof(WSAPROTOCOL_INFOA);
2811 err = getsockopt(sock, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &info, &size);
2812 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2813 ok(info.iProtocol == NSPROTO_IPX, "expected protocol %d, received %d\n",
2814 NSPROTO_IPX, info.iProtocol);
2815 ok(info.iAddressFamily == AF_IPX, "expected family %d, received %d\n",
2816 AF_IPX, info.iProtocol);
2817 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
2818 SOCK_DGRAM, info.iSocketType);
2819 closesocket(sock);
2820
2821 /* SOCK_STREAM does not support NSPROTO_IPX */
2822 SetLastError(0xdeadbeef);
2823 ok(WSASocketA(AF_IPX, SOCK_STREAM, NSPROTO_IPX, NULL, 0, 0) == INVALID_SOCKET,
2824 "WSASocketA should have failed\n");
2825 err = WSAGetLastError();
2826 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2827
2828 /* test extended IPX support - that is adding any number between 0 and 255
2829 * to the IPX protocol value will make it be used as IPX packet type */
2830 for(i = 0;i <= 255;i += 17)
2831 {
2832 SetLastError(0xdeadbeef);
2833 sock = WSASocketA(0, 0, NSPROTO_IPX + i, NULL, 0, 0);
2834 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2835 WSAGetLastError());
2836
2837 size = sizeof(int);
2838 socktype = -1;
2839 err = getsockopt(sock, NSPROTO_IPX, IPX_PTYPE, (char *) &socktype, &size);
2840 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2841 ok(socktype == i, "Wrong IPX packet type, expected %d received %d\n",
2842 i, socktype);
2843
2844 closesocket(sock);
2845 }
2846 }
2847 }
2848
2849 static void test_WSADuplicateSocket(void)
2850 {
2851 SOCKET source, dupsock;
2852 WSAPROTOCOL_INFOA info;
2853 DWORD err;
2854 struct sockaddr_in addr;
2855 int socktype, size, addrsize, ret;
2856 char teststr[] = "TEST", buffer[16];
2857
2858 source = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
2859 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2860
2861 /* test invalid parameters */
2862 SetLastError(0xdeadbeef);
2863 ok(WSADuplicateSocketA(0, 0, NULL), "WSADuplicateSocketA should have failed\n");
2864 err = WSAGetLastError();
2865 ok(err == WSAENOTSOCK, "expected 10038, received %d\n", err);
2866
2867 SetLastError(0xdeadbeef);
2868 ok(WSADuplicateSocketA(source, 0, NULL),
2869 "WSADuplicateSocketA should have failed\n");
2870 err = WSAGetLastError();
2871 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2872
2873 SetLastError(0xdeadbeef);
2874 ok(WSADuplicateSocketA(source, ~0, &info),
2875 "WSADuplicateSocketA should have failed\n");
2876 err = WSAGetLastError();
2877 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2878
2879 SetLastError(0xdeadbeef);
2880 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info),
2881 "WSADuplicateSocketA should have failed\n");
2882 err = WSAGetLastError();
2883 ok(err == WSAENOTSOCK, "expected 10038, received %d\n", err);
2884
2885 SetLastError(0xdeadbeef);
2886 ok(WSADuplicateSocketA(source, GetCurrentProcessId(), NULL),
2887 "WSADuplicateSocketA should have failed\n");
2888 err = WSAGetLastError();
2889 ok(err == WSAEFAULT, "expected 10014, received %d\n", err);
2890
2891 /* test returned structure */
2892 memset(&info, 0, sizeof(info));
2893 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2894 "WSADuplicateSocketA should have worked\n");
2895
2896 ok(info.iProtocol == IPPROTO_TCP, "expected protocol %d, received %d\n",
2897 IPPROTO_TCP, info.iProtocol);
2898 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
2899 AF_INET, info.iProtocol);
2900 ok(info.iSocketType == SOCK_STREAM, "expected type %d, received %d\n",
2901 SOCK_STREAM, info.iSocketType);
2902
2903 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2904 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2905
2906 closesocket(dupsock);
2907 closesocket(source);
2908
2909 /* create a socket, bind it, duplicate it then send data on source and
2910 * receive in the duplicated socket */
2911 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
2912 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2913
2914 memset(&info, 0, sizeof(info));
2915 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2916 "WSADuplicateSocketA should have worked\n");
2917
2918 ok(info.iProtocol == IPPROTO_UDP, "expected protocol %d, received %d\n",
2919 IPPROTO_UDP, info.iProtocol);
2920 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
2921 AF_INET, info.iProtocol);
2922 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
2923 SOCK_DGRAM, info.iSocketType);
2924
2925 memset(&addr, 0, sizeof(addr));
2926 addr.sin_family = AF_INET;
2927 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2928 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
2929 "bind should have worked\n");
2930
2931 /* read address to find out the port number to be used in sendto */
2932 memset(&addr, 0, sizeof(addr));
2933 addrsize = sizeof(addr);
2934 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
2935 "getsockname should have worked\n");
2936 ok(addr.sin_port, "socket port should be != 0\n");
2937
2938 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2939 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2940
2941 size = sizeof(int);
2942 ret = getsockopt(dupsock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2943 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
2944 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2945 SOCK_DGRAM, socktype);
2946
2947 set_blocking(source, TRUE);
2948
2949 /* send data on source socket */
2950 addrsize = sizeof(addr);
2951 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
2952 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2953
2954 /* receive on duplicated socket */
2955 addrsize = sizeof(addr);
2956 memset(buffer, 0, sizeof(buffer));
2957 size = recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize);
2958 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2959 buffer[sizeof(teststr) - 1] = 0;
2960 ok(!strcmp(buffer, teststr), "expected '%s', received '%s'\n", teststr, buffer);
2961
2962 closesocket(dupsock);
2963 closesocket(source);
2964
2965 /* show that the source socket need to be bound before the duplicated
2966 * socket is created */
2967 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
2968 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2969
2970 memset(&info, 0, sizeof(info));
2971 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2972 "WSADuplicateSocketA should have worked\n");
2973
2974 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2975 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2976
2977 memset(&addr, 0, sizeof(addr));
2978 addr.sin_family = AF_INET;
2979 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2980 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
2981 "bind should have worked\n");
2982
2983 /* read address to find out the port number to be used in sendto */
2984 memset(&addr, 0, sizeof(addr));
2985 addrsize = sizeof(addr);
2986 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
2987 "getsockname should have worked\n");
2988 ok(addr.sin_port, "socket port should be != 0\n");
2989
2990 set_blocking(source, TRUE);
2991
2992 addrsize = sizeof(addr);
2993 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
2994 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2995
2996 SetLastError(0xdeadbeef);
2997 addrsize = sizeof(addr);
2998 memset(buffer, 0, sizeof(buffer));
2999 todo_wine {
3000 ok(recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize) == -1,
3001 "recvfrom should have failed\n");
3002 err = WSAGetLastError();
3003 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
3004 }
3005
3006 closesocket(dupsock);
3007 closesocket(source);
3008 }
3009
3010 static void test_WSAEnumNetworkEvents(void)
3011 {
3012 SOCKET s, s2;
3013 int sock_type[] = {SOCK_STREAM, SOCK_DGRAM, SOCK_STREAM}, i, j, k, l;
3014 struct sockaddr_in address;
3015 HANDLE event;
3016 WSANETWORKEVENTS net_events;
3017
3018 memset(&address, 0, sizeof(address));
3019 address.sin_addr.s_addr = htonl(INADDR_ANY);
3020 address.sin_family = AF_INET;
3021
3022 /* This test follows the steps from bugs 10204 and 24946 */
3023 for (l = 0; l < 2; l++)
3024 {
3025 for (i = 0; i < ARRAY_SIZE(sock_type); i++)
3026 {
3027 if (i == 2)
3028 ok(!tcp_socketpair(&s, &s2), "Test[%d]: creating socket pair failed\n", i);
3029 else
3030 {
3031 s = socket(AF_INET, sock_type[i], 0);
3032 ok (s != SOCKET_ERROR, "Test[%d]: failed to create socket\n", i);
3033 ok (!bind(s, (struct sockaddr*) &address, sizeof(address)), "Test[%d]: bind failed\n", i);
3034 }
3035 event = WSACreateEvent();
3036 ok (event != NULL, "Test[%d]: failed to create event\n", i);
3037 for (j = 0; j < 5; j++) /* Repeat sometimes and the result must be the same */
3038 {
3039 /* When the TCP socket is not connected NO events will be returned.
3040 * When connected and no data pending it will get the write event.
3041 * UDP sockets don't have connections so as soon as they are bound
3042 * they can read/write data. Since nobody is sendind us data only
3043 * the write event will be returned and ONLY once.
3044 */
3045 ok (!WSAEventSelect(s, event, FD_READ | FD_WRITE), "Test[%d]: WSAEventSelect failed\n", i);
3046 memset(&net_events, 0xAB, sizeof(net_events));
3047 ok (!WSAEnumNetworkEvents(s, l == 0 ? event : NULL, &net_events),
3048 "Test[%d]: WSAEnumNetworkEvents failed\n", i);
3049 if (i >= 1 && j == 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
3050 {
3051 todo_wine_if (i == 0) /* Remove when fixed */
3052 ok (net_events.lNetworkEvents == FD_WRITE, "Test[%d]: expected 2, got %d\n",
3053 i, net_events.lNetworkEvents);
3054 }
3055 else
3056 {
3057 todo_wine_if (i != 0) /* Remove when fixed */
3058 ok (net_events.lNetworkEvents == 0, "Test[%d]: expected 0, got %d\n",
3059 i, net_events.lNetworkEvents);
3060 }
3061 for (k = 0; k < FD_MAX_EVENTS; k++)
3062 {
3063 if (net_events.lNetworkEvents & (1 << k))
3064 {
3065 ok (net_events.iErrorCode[k] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
3066 i, k, net_events.iErrorCode[k]);
3067 }
3068 else
3069 {
3070 /* Bits that are not set in lNetworkEvents MUST not be changed */
3071 ok (net_events.iErrorCode[k] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
3072 i, k, net_events.iErrorCode[k]);
3073 }
3074 }
3075 }
3076 closesocket(s);
3077 WSACloseEvent(event);
3078 if (i == 2) closesocket(s2);
3079 }
3080 }
3081 }
3082
3083 static void test_WSAAddressToStringA(void)
3084 {
3085 SOCKET v6 = INVALID_SOCKET;
3086 INT ret;
3087 DWORD len;
3088 int GLE;
3089 SOCKADDR_IN sockaddr;
3090 CHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
3091
3092 CHAR expect1[] = "0.0.0.0";
3093 CHAR expect2[] = "255.255.255.255";
3094 CHAR expect3[] = "0.0.0.0:65535";
3095 CHAR expect4[] = "255.255.255.255:65535";
3096
3097 SOCKADDR_IN6 sockaddr6;
3098 CHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
3099
3100 CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3101 CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3102 CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
3103
3104 CHAR expect6_1[] = "::1";
3105 CHAR expect6_2[] = "20ab::1";
3106 CHAR expect6_3[] = "[20ab::2001]:33274";
3107 CHAR expect6_3_2[] = "[20ab::2001%4660]:33274";
3108 CHAR expect6_3_3[] = "20ab::2001%4660";
3109
3110 len = 0;
3111
3112 sockaddr.sin_family = AF_INET;
3113 sockaddr.sin_port = 0;
3114 sockaddr.sin_addr.s_addr = 0;
3115
3116 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3117 GLE = WSAGetLastError();
3118 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
3119 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
3120 GLE, ret );
3121
3122 len = sizeof(address);
3123
3124 sockaddr.sin_family = AF_INET;
3125 sockaddr.sin_port = 0;
3126 sockaddr.sin_addr.s_addr = 0;
3127
3128 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3129 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3130
3131 ok( !strcmp( address, expect1 ), "Expected: %s, got: %s\n", expect1, address );
3132 ok( len == sizeof( expect1 ), "Got size %d\n", len);
3133
3134 len = sizeof(address);
3135
3136 sockaddr.sin_family = AF_INET;
3137 sockaddr.sin_port = 0;
3138 sockaddr.sin_addr.s_addr = 0xffffffff;
3139
3140 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3141 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3142
3143 ok( !strcmp( address, expect2 ), "Expected: %s, got: %s\n", expect2, address );
3144
3145 len = sizeof(address);
3146
3147 sockaddr.sin_family = AF_INET;
3148 sockaddr.sin_port = 0xffff;
3149 sockaddr.sin_addr.s_addr = 0;
3150
3151 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3152 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3153
3154 ok( !strcmp( address, expect3 ), "Expected: %s, got: %s\n", expect3, address );
3155
3156 len = sizeof(address);
3157
3158 sockaddr.sin_family = AF_INET;
3159 sockaddr.sin_port = 0xffff;
3160 sockaddr.sin_addr.s_addr = 0xffffffff;
3161
3162 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3163 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3164
3165 ok( !strcmp( address, expect4 ), "Expected: %s, got: %s\n", expect4, address );
3166 ok( len == sizeof( expect4 ), "Got size %d\n", len);
3167
3168 /*check to see it IPv6 is available */
3169 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
3170 if (v6 == INVALID_SOCKET) {
3171 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
3172 WSAGetLastError(), WSAEAFNOSUPPORT);
3173 goto end;
3174 }
3175 /* Test a short IPv6 address */
3176 len = sizeof(address6);
3177
3178 sockaddr6.sin6_family = AF_INET6;
3179 sockaddr6.sin6_port = 0x0000;
3180 sockaddr6.sin6_scope_id = 0;
3181 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
3182
3183 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3184 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3185 ok( !strcmp( address6, expect6_1 ), "Expected: %s, got: %s\n", expect6_1, address6 );
3186 ok( len == sizeof(expect6_1), "Got size %d\n", len);
3187
3188 /* Test a longer IPv6 address */
3189 len = sizeof(address6);
3190
3191 sockaddr6.sin6_family = AF_INET6;
3192 sockaddr6.sin6_port = 0x0000;
3193 sockaddr6.sin6_scope_id = 0;
3194 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_2, sizeof(addr6_2));
3195
3196 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3197 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3198 ok( !strcmp( address6, expect6_2 ), "Expected: %s, got: %s\n", expect6_2, address6 );
3199 ok( len == sizeof(expect6_2), "Got size %d\n", len);
3200
3201 /* Test IPv6 address and port number */
3202 len = sizeof(address6);
3203
3204 sockaddr6.sin6_family = AF_INET6;
3205 sockaddr6.sin6_port = 0xfa81;
3206 sockaddr6.sin6_scope_id = 0;
3207 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3208
3209 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3210 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3211 ok( !strcmp( address6, expect6_3 ), "Expected: %s, got: %s\n", expect6_3, address6 );
3212 ok( len == sizeof(expect6_3), "Got size %d\n", len );
3213
3214 /* Test IPv6 address, port number and scope_id */
3215 len = sizeof(address6);
3216
3217 sockaddr6.sin6_family = AF_INET6;
3218 sockaddr6.sin6_port = 0xfa81;
3219 sockaddr6.sin6_scope_id = 0x1234;
3220 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3221
3222 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3223 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3224 ok( !strcmp( address6, expect6_3_2 ), "Expected: %s, got: %s\n", expect6_3_2, address6 );
3225 ok( len == sizeof(expect6_3_2), "Got size %d\n", len );
3226
3227 /* Test IPv6 address and scope_id */
3228 len = sizeof(address6);
3229
3230 sockaddr6.sin6_family = AF_INET6;
3231 sockaddr6.sin6_port = 0x0000;
3232 sockaddr6.sin6_scope_id = 0x1234;
3233 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3234
3235 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3236 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3237 ok( !strcmp( address6, expect6_3_3 ), "Expected: %s, got: %s\n", expect6_3_3, address6 );
3238 ok( len == sizeof(expect6_3_3), "Got size %d\n", len );
3239
3240 end:
3241 if (v6 != INVALID_SOCKET)
3242 closesocket(v6);
3243 }
3244
3245 static void test_WSAAddressToStringW(void)
3246 {
3247 SOCKET v6 = INVALID_SOCKET;
3248 INT ret;
3249 DWORD len;
3250 int GLE;
3251 SOCKADDR_IN sockaddr;
3252 WCHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
3253
3254 WCHAR expect1[] = { '0','.','0','.','0','.','0', 0 };
3255 WCHAR expect2[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
3256 WCHAR expect3[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
3257 WCHAR expect4[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
3258 '6', '5', '5', '3', '5', 0 };
3259
3260 SOCKADDR_IN6 sockaddr6;
3261 WCHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
3262
3263 CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3264 CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3265 CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
3266
3267 WCHAR expect6_1[] = {':',':','1',0};
3268 WCHAR expect6_2[] = {'2','0','a','b',':',':','1',0};
3269 WCHAR expect6_3[] = {'[','2','0','a','b',':',':','2','0','0','1',']',':','3','3','2','7','4',0};
3270 WCHAR expect6_3_2[] = {'[','2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',']',':','3','3','2','7','4',0};
3271 WCHAR expect6_3_3[] = {'2','0','a','b',':',':','2','0','0','1','%','6','5','5','3','4',0};
3272
3273 len = 0;
3274
3275 sockaddr.sin_family = AF_INET;
3276 sockaddr.sin_port = 0;
3277 sockaddr.sin_addr.s_addr = 0;
3278
3279 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3280 GLE = WSAGetLastError();
3281 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
3282 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
3283 GLE, ret );
3284
3285 len = sizeof(address);
3286
3287 sockaddr.sin_family = AF_INET;
3288 sockaddr.sin_port = 0;
3289 sockaddr.sin_addr.s_addr = 0;
3290
3291 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3292 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3293
3294 ok( !lstrcmpW( address, expect1 ), "Expected different address string\n" );
3295 ok( len == ARRAY_SIZE(expect1), "Got size %d\n", len);
3296
3297 len = sizeof(address);
3298
3299 sockaddr.sin_family = AF_INET;
3300 sockaddr.sin_port = 0;
3301 sockaddr.sin_addr.s_addr = 0xffffffff;
3302
3303 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3304 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3305
3306 ok( !lstrcmpW( address, expect2 ), "Expected different address string\n" );
3307
3308 len = sizeof(address);
3309
3310 sockaddr.sin_family = AF_INET;
3311 sockaddr.sin_port = 0xffff;
3312 sockaddr.sin_addr.s_addr = 0;
3313
3314 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3315 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3316
3317 ok( !lstrcmpW( address, expect3 ), "Expected different address string\n" );
3318
3319 len = sizeof(address);
3320
3321 sockaddr.sin_family = AF_INET;
3322 sockaddr.sin_port = 0xffff;
3323 sockaddr.sin_addr.s_addr = 0xffffffff;
3324
3325 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3326 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3327
3328 ok( !lstrcmpW( address, expect4 ), "Expected different address string\n" );
3329 ok( len == ARRAY_SIZE(expect4), "Got %d\n", len);
3330
3331 /*check to see it IPv6 is available */
3332 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
3333 if (v6 == INVALID_SOCKET) {
3334 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
3335 WSAGetLastError(), WSAEAFNOSUPPORT);
3336 goto end;
3337 }
3338
3339 /* Test a short IPv6 address */
3340 len = ARRAY_SIZE(address6);
3341
3342 sockaddr6.sin6_family = AF_INET6;
3343 sockaddr6.sin6_port = 0x0000;
3344 sockaddr6.sin6_scope_id = 0;
3345 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
3346
3347 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3348 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3349 ok( !lstrcmpW( address6, expect6_1 ), "Wrong string returned\n" );
3350 ok( len == ARRAY_SIZE(expect6_1), "Got %d\n", len);
3351
3352 /* Test a longer IPv6 address */
3353 len = ARRAY_SIZE(address6);
3354
3355 sockaddr6.sin6_family = AF_INET6;
3356 sockaddr6.sin6_port = 0x0000;
3357 sockaddr6.sin6_scope_id = 0;
3358 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_2, sizeof(addr6_2));
3359
3360 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3361 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3362
3363 ok( !lstrcmpW( address6, expect6_2 ), "Wrong string returned\n" );
3364 ok( len == ARRAY_SIZE(expect6_2), "Got %d\n", len);
3365
3366 /* Test IPv6 address and port number */
3367 len = ARRAY_SIZE(address6);
3368
3369 sockaddr6.sin6_family = AF_INET6;
3370 sockaddr6.sin6_port = 0xfa81;
3371 sockaddr6.sin6_scope_id = 0;
3372 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3373
3374 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3375 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3376 ok( !lstrcmpW( address6, expect6_3 ),
3377 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3), wine_dbgstr_w(address6) );
3378 ok( len == ARRAY_SIZE(expect6_3), "Got %d\n", len );
3379
3380 /* Test IPv6 address, port number and scope_id */
3381 len = ARRAY_SIZE(address6);
3382
3383 sockaddr6.sin6_family = AF_INET6;
3384 sockaddr6.sin6_port = 0xfa81;
3385 sockaddr6.sin6_scope_id = 0x1234;
3386 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3387
3388 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3389 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3390 ok( !lstrcmpW( address6, expect6_3_2 ),
3391 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_2), wine_dbgstr_w(address6) );
3392 ok( len == ARRAY_SIZE(expect6_3_2), "Got %d\n", len );
3393
3394 /* Test IPv6 address and scope_id */
3395 len = ARRAY_SIZE(address6);
3396
3397 sockaddr6.sin6_family = AF_INET6;
3398 sockaddr6.sin6_port = 0x0000;
3399 sockaddr6.sin6_scope_id = 0xfffe;
3400 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3401
3402 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3403 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3404 ok( !lstrcmpW( address6, expect6_3_3 ),
3405 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_3), wine_dbgstr_w(address6) );
3406 ok( len == ARRAY_SIZE(expect6_3_3), "Got %d\n", len );
3407
3408 end:
3409 if (v6 != INVALID_SOCKET)
3410 closesocket(v6);
3411 }
3412
3413 static void test_WSAStringToAddressA(void)
3414 {
3415 INT ret, len;
3416 SOCKADDR_IN sockaddr;
3417 SOCKADDR_IN6 sockaddr6;
3418 int GLE;
3419
3420 CHAR address1[] = "0.0.0.0";
3421 CHAR address2[] = "127.127.127.127";
3422 CHAR address3[] = "255.255.255.255";
3423 CHAR address4[] = "127.127.127.127:65535";
3424 CHAR address5[] = "255.255.255.255:65535";
3425 CHAR address6[] = "::1";
3426 CHAR address7[] = "[::1]";
3427 CHAR address8[] = "[::1]:65535";
3428 CHAR address9[] = "2001::1";
3429
3430 len = 0;
3431 sockaddr.sin_family = AF_INET;
3432
3433 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3434 ok( ret == SOCKET_ERROR, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
3435 WSAGetLastError() );
3436
3437 len = sizeof(sockaddr);
3438 sockaddr.sin_port = 0;
3439 sockaddr.sin_addr.s_addr = 0;
3440
3441 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3442 ok( !ret && sockaddr.sin_addr.s_addr == 0,
3443 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3444
3445 len = sizeof(sockaddr);
3446 sockaddr.sin_port = 0;
3447 sockaddr.sin_addr.s_addr = 0;
3448
3449 ret = WSAStringToAddressA( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3450 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
3451 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3452
3453 len = sizeof(sockaddr);
3454 sockaddr.sin_port = 0;
3455 sockaddr.sin_addr.s_addr = 0;
3456
3457 ret = WSAStringToAddressA( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3458 GLE = WSAGetLastError();
3459 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
3460 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3461 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
3462
3463 len = sizeof(sockaddr);
3464 sockaddr.sin_port = 0;
3465 sockaddr.sin_addr.s_addr = 0;
3466
3467 ret = WSAStringToAddressA( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3468 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
3469 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3470
3471 len = sizeof(sockaddr);
3472 sockaddr.sin_port = 0;
3473 sockaddr.sin_addr.s_addr = 0;
3474
3475 ret = WSAStringToAddressA( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3476 GLE = WSAGetLastError();
3477 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
3478 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3479 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
3480
3481 len = sizeof(sockaddr);
3482
3483 ret = WSAStringToAddressA( address9, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3484 GLE = WSAGetLastError();
3485 ok( (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3486 "WSAStringToAddressA() should have failed with %d\n", GLE );
3487
3488 len = sizeof(sockaddr6);
3489 memset(&sockaddr6, 0, len);
3490 sockaddr6.sin6_family = AF_INET6;
3491
3492 ret = WSAStringToAddressA( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3493 &len );
3494 if (ret == SOCKET_ERROR)
3495 {
3496 win_skip("IPv6 not supported\n");
3497 return;
3498 }
3499
3500 GLE = WSAGetLastError();
3501 ok( ret == 0, "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
3502
3503 len = sizeof(sockaddr6);
3504 memset(&sockaddr6, 0, len);
3505 sockaddr6.sin6_family = AF_INET6;
3506
3507 ret = WSAStringToAddressA( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3508 &len );
3509 GLE = WSAGetLastError();
3510 ok( ret == 0, "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
3511
3512 len = sizeof(sockaddr6);
3513 memset(&sockaddr6, 0, len);
3514 sockaddr6.sin6_family = AF_INET6;
3515
3516 ret = WSAStringToAddressA( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3517 &len );
3518 GLE = WSAGetLastError();
3519 ok( ret == 0 && sockaddr6.sin6_port == 0xffff,
3520 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
3521
3522 len = sizeof(sockaddr6);
3523
3524 ret = WSAStringToAddressA( address7 + 1, AF_INET6, NULL, (SOCKADDR*)&sockaddr, &len );
3525 GLE = WSAGetLastError();
3526 ok( (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3527 "WSAStringToAddressW() should have failed with %d\n", GLE );
3528
3529 len = sizeof(sockaddr6);
3530
3531 ret = WSAStringToAddressA( address8 + 1, AF_INET6, NULL, (SOCKADDR*)&sockaddr, &len );
3532 GLE = WSAGetLastError();
3533 ok( (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3534 "WSAStringToAddressW() should have failed with %d\n", GLE );
3535 }
3536
3537 static void test_WSAStringToAddressW(void)
3538 {
3539 INT ret, len;
3540 SOCKADDR_IN sockaddr, *sin;
3541 SOCKADDR_IN6 sockaddr6;
3542 SOCKADDR_STORAGE sockaddr_storage;
3543 int GLE;
3544
3545 WCHAR address1[] = { '0','.','0','.','0','.','0', 0 };
3546 WCHAR address2[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
3547 WCHAR address3[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
3548 WCHAR address4[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
3549 ':', '6', '5', '5', '3', '5', 0 };
3550 WCHAR address5[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
3551 '6', '5', '5', '3', '5', 0 };
3552 WCHAR address6[] = {':',':','1','\0'};
3553 WCHAR address7[] = {'[',':',':','1',']','\0'};
3554 WCHAR address8[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
3555 WCHAR address9[] = {'2','0','0','1',':',':','1','\0'};
3556
3557 len = 0;
3558 sockaddr.sin_family = AF_INET;
3559
3560 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3561 ok( ret == SOCKET_ERROR, "WSAStringToAddressW() failed unexpectedly: %d\n",
3562 WSAGetLastError() );
3563
3564 len = sizeof(sockaddr);
3565 sockaddr.sin_port = 0;
3566 sockaddr.sin_addr.s_addr = 0;
3567
3568 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3569 ok( !ret && sockaddr.sin_addr.s_addr == 0,
3570 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3571
3572 len = sizeof(sockaddr);
3573 sockaddr.sin_port = 0;
3574 sockaddr.sin_addr.s_addr = 0;
3575
3576 ret = WSAStringToAddressW( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3577 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
3578 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3579
3580 len = sizeof(sockaddr);
3581 sockaddr.sin_port = 0;
3582 sockaddr.sin_addr.s_addr = 0;
3583
3584 ret = WSAStringToAddressW( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3585 GLE = WSAGetLastError();
3586 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
3587 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3588 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
3589
3590 len = sizeof(sockaddr);
3591 sockaddr.sin_port = 0;
3592 sockaddr.sin_addr.s_addr = 0;
3593
3594 ret = WSAStringToAddressW( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3595 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
3596 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3597
3598 len = sizeof(sockaddr);
3599 sockaddr.sin_port = 0;
3600 sockaddr.sin_addr.s_addr = 0;
3601
3602 ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3603 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
3604 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3605 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
3606
3607 /* Test with a larger buffer than necessary */
3608 len = sizeof(sockaddr_storage);
3609 sin = (SOCKADDR_IN *)&sockaddr_storage;
3610 sin->sin_port = 0;
3611 sin->sin_addr.s_addr = 0;
3612
3613 ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)sin, &len );
3614 ok( (ret == 0 && sin->sin_addr.s_addr == 0xffffffff && sin->sin_port == 0xffff) ||
3615 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3616 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
3617 ok( len == sizeof(SOCKADDR_IN), "unexpected length %d\n", len );
3618
3619 len = sizeof(sockaddr);
3620
3621 ret = WSAStringToAddressW( address9, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3622 GLE = WSAGetLastError();
3623 ok( (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3624 "WSAStringToAddressW() should have failed with %d\n", GLE );
3625
3626 len = sizeof(sockaddr6);
3627 memset(&sockaddr6, 0, len);
3628 sockaddr6.sin6_family = AF_INET6;
3629
3630 ret = WSAStringToAddressW( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3631 &len );
3632 if (ret == SOCKET_ERROR)
3633 {
3634 win_skip("IPv6 not supported\n");
3635 return;
3636 }
3637
3638 GLE = WSAGetLastError();
3639 ok( ret == 0, "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
3640
3641 len = sizeof(sockaddr6);
3642 memset(&sockaddr6, 0, len);
3643 sockaddr6.sin6_family = AF_INET6;
3644
3645 ret = WSAStringToAddressW( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3646 &len );
3647 GLE = WSAGetLastError();
3648 ok( ret == 0, "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
3649
3650 len = sizeof(sockaddr6);
3651 memset(&sockaddr6, 0, len);
3652 sockaddr6.sin6_family = AF_INET6;
3653
3654 ret = WSAStringToAddressW( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3655 &len );
3656 GLE = WSAGetLastError();
3657 ok( ret == 0 && sockaddr6.sin6_port == 0xffff,
3658 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
3659
3660 len = sizeof(sockaddr6);
3661
3662 ret = WSAStringToAddressW( address7 + 1, AF_INET6, NULL, (SOCKADDR*)&sockaddr, &len );
3663 GLE = WSAGetLastError();
3664 ok( (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3665 "WSAStringToAddressW() should have failed with %d\n", GLE );
3666
3667 len = sizeof(sockaddr6);
3668
3669 ret = WSAStringToAddressW( address8 + 1, AF_INET6, NULL, (SOCKADDR*)&sockaddr, &len );
3670 GLE = WSAGetLastError();
3671 ok( (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3672 "WSAStringToAddressW() should have failed with %d\n", GLE );
3673 }
3674
3675 static DWORD WINAPI SelectReadThread(void *param)
3676 {
3677 select_thread_params *par = param;
3678 fd_set readfds;
3679 int ret;
3680 struct sockaddr_in addr;
3681 struct timeval select_timeout;
3682
3683 FD_ZERO(&readfds);
3684 FD_SET(par->s, &readfds);
3685 select_timeout.tv_sec=5;
3686 select_timeout.tv_usec=0;
3687 addr.sin_family = AF_INET;
3688 addr.sin_addr.s_addr = inet_addr(SERVERIP);
3689 addr.sin_port = htons(SERVERPORT);
3690
3691 do_bind(par->s, (struct sockaddr *)&addr, sizeof(addr));
3692 wsa_ok(listen(par->s, SOMAXCONN ), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
3693
3694 SetEvent(server_ready);
3695 ret = select(par->s+1, &readfds, NULL, NULL, &select_timeout);
3696 par->ReadKilled = (ret == 1);
3697
3698 return 0;
3699 }
3700
3701 static DWORD WINAPI SelectCloseThread(void *param)
3702 {
3703 SOCKET s = *(SOCKET*)param;
3704 Sleep(500);
3705 closesocket(s);
3706 return 0;
3707 }
3708
3709 static void test_errors(void)
3710 {
3711 SOCKET sock;
3712 SOCKADDR_IN SockAddr;
3713 int ret, err;
3714
3715 WSASetLastError(NO_ERROR);
3716 sock = socket(PF_INET, SOCK_STREAM, 0);
3717 ok( (sock != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3718 memset(&SockAddr, 0, sizeof(SockAddr));
3719 SockAddr.sin_family = AF_INET;
3720 SockAddr.sin_port = htons(6924);
3721 SockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
3722
3723 ret = connect(sock, (PSOCKADDR)&SockAddr, sizeof(SockAddr));
3724 ok( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got: %d\n", ret );
3725 if (ret == SOCKET_ERROR)
3726 {
3727 err = WSAGetLastError();
3728 ok( (err == WSAECONNREFUSED), "expected WSAECONNREFUSED, got: %d\n", err );
3729 }
3730
3731 {
3732 TIMEVAL timeval;
3733 fd_set set = {1, {sock}};
3734
3735 timeval.tv_sec = 0;
3736 timeval.tv_usec = 50000;
3737
3738 ret = select(1, NULL, &set, NULL, &timeval);
3739 ok( (ret == 0), "expected 0 (timeout), got: %d\n", ret );
3740 }
3741
3742 ret = closesocket(sock);
3743 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
3744 }
3745
3746 static void test_listen(void)
3747 {
3748 SOCKET fdA, fdB;
3749 int ret, acceptc, olen = sizeof(acceptc);
3750 struct sockaddr_in address;
3751
3752 memset(&address, 0, sizeof(address));
3753 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3754 address.sin_family = AF_INET;
3755 address.sin_port = htons(SERVERPORT);
3756
3757 /* invalid socket tests */
3758 SetLastError(0xdeadbeef);
3759 ok ((listen(0, 0) == SOCKET_ERROR), "listen did not fail\n");
3760 ret = WSAGetLastError();
3761 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
3762
3763 SetLastError(0xdeadbeef);
3764 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR), "listen did not fail\n");
3765 ret = WSAGetLastError();
3766 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
3767
3768 /* tcp tests */
3769 fdA = socket(AF_INET, SOCK_STREAM, 0);
3770 ok ((fdA != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3771
3772 fdB = socket(AF_INET, SOCK_STREAM, 0);
3773 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3774
3775 SetLastError(0xdeadbeef);
3776 ok ((listen(fdA, -2) == SOCKET_ERROR), "listen did not fail\n");
3777 ret = WSAGetLastError();
3778 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3779
3780 SetLastError(0xdeadbeef);
3781 ok ((listen(fdA, 1) == SOCKET_ERROR), "listen did not fail\n");
3782 ret = WSAGetLastError();
3783 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3784
3785 SetLastError(0xdeadbeef);
3786 ok ((listen(fdA, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3787 ret = WSAGetLastError();
3788 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3789
3790 ok (!bind(fdA, (struct sockaddr*) &address, sizeof(address)), "bind failed\n");
3791
3792 SetLastError(0xdeadbeef);
3793 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3794 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3795
3796 acceptc = 0xdead;
3797 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3798 ok (!ret, "getsockopt failed\n");
3799 ok (acceptc == 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc);
3800
3801 ok (!listen(fdA, 0), "listen failed\n");
3802 ok (!listen(fdA, SOMAXCONN), "double listen failed\n");
3803
3804 acceptc = 0xdead;
3805 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3806 ok (!ret, "getsockopt failed\n");
3807 ok (acceptc == 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc);
3808
3809 SetLastError(0xdeadbeef);
3810 ok ((listen(fdB, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3811 ret = WSAGetLastError();
3812 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3813
3814 ret = closesocket(fdB);
3815 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3816
3817 fdB = socket(AF_INET, SOCK_STREAM, 0);
3818 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3819
3820 SetLastError(0xdeadbeef);
3821 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3822 ret = WSAGetLastError();
3823 ok (ret == WSAEADDRINUSE, "expected 10048, received %d\n", ret);
3824
3825 ret = closesocket(fdA);
3826 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3827 ret = closesocket(fdB);
3828 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3829 }
3830
3831 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
3832 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
3833 static void test_select(void)
3834 {
3835 static char tmp_buf[1024];
3836
3837 SOCKET fdListen, fdRead, fdWrite;
3838 fd_set readfds, writefds, exceptfds;
3839 unsigned int maxfd;
3840 int ret, len;
3841 char buffer;
3842 struct timeval select_timeout;
3843 struct sockaddr_in address;
3844 select_thread_params thread_params;
3845 HANDLE thread_handle;
3846 DWORD ticks, id;
3847
3848 fdRead = socket(AF_INET, SOCK_STREAM, 0);
3849 ok( (fdRead != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3850 fdWrite = socket(AF_INET, SOCK_STREAM, 0);
3851 ok( (fdWrite != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3852
3853 maxfd = fdRead;
3854 if (fdWrite > maxfd)
3855 maxfd = fdWrite;
3856
3857 FD_ZERO_ALL();
3858 FD_SET_ALL(fdRead);
3859 FD_SET_ALL(fdWrite);
3860 select_timeout.tv_sec=0;
3861 select_timeout.tv_usec=0;
3862
3863 ticks = GetTickCount();
3864 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3865 ticks = GetTickCount() - ticks;
3866 ok(ret == 0, "select should not return any socket handles\n");
3867 ok(ticks < 10, "select was blocking for %u ms, expected < 10 ms\n", ticks);
3868 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3869 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
3870 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3871 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
3872
3873 FD_ZERO_ALL();
3874 FD_SET_ALL(fdRead);
3875 FD_SET_ALL(fdWrite);
3876 select_timeout.tv_sec=0;
3877 select_timeout.tv_usec=500;
3878
3879 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3880 ok(ret == 0, "select should not return any socket handles\n");
3881 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3882 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
3883 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3884 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
3885
3886 ok ((listen(fdWrite, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3887 ret = closesocket(fdWrite);
3888 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
3889
3890 thread_params.s = fdRead;
3891 thread_params.ReadKilled = FALSE;
3892 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
3893 thread_handle = CreateThread (NULL, 0, SelectReadThread, &thread_params, 0, &id );
3894 ok ( (thread_handle != NULL), "CreateThread failed unexpectedly: %d\n", GetLastError());
3895
3896 WaitForSingleObject (server_ready, INFINITE);
3897 Sleep(200);
3898 ret = closesocket(fdRead);
3899 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
3900
3901 WaitForSingleObject (thread_handle, 1000);
3902 ok ( thread_params.ReadKilled, "closesocket did not wake up select\n");
3903 ret = recv(fdRead, &buffer, 1, MSG_PEEK);
3904 ok( (ret == -1), "peek at closed socket expected -1 got %d\n", ret);
3905
3906 /* Test selecting invalid handles */
3907 FD_ZERO_ALL();
3908
3909 SetLastError(0);
3910 ret = select(maxfd+1, 0, 0, 0, &select_timeout);
3911 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3912 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3913
3914 SetLastError(0);
3915 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3916 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3917 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3918
3919 FD_SET(INVALID_SOCKET, &readfds);
3920 SetLastError(0);
3921 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3922 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3923 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3924 ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3925
3926 FD_ZERO(&readfds);
3927 FD_SET(INVALID_SOCKET, &writefds);
3928 SetLastError(0);
3929 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3930 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3931 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3932 ok ( !FD_ISSET(fdRead, &writefds), "FD should not be set\n");
3933
3934 FD_ZERO(&writefds);
3935 FD_SET(INVALID_SOCKET, &exceptfds);
3936 SetLastError(0);
3937 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3938 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3939 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3940 ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3941
3942 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
3943 maxfd = fdRead;
3944 if(fdWrite > maxfd) maxfd = fdWrite;
3945
3946 FD_ZERO(&readfds);
3947 FD_SET(fdRead, &readfds);
3948 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
3949 ok(!ret, "select returned %d\n", ret);
3950
3951 FD_ZERO(&writefds);
3952 FD_SET(fdWrite, &writefds);
3953 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
3954 ok(ret == 1, "select returned %d\n", ret);
3955 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3956
3957 /* tests for overlapping fd_set pointers */
3958 FD_ZERO(&readfds);
3959 FD_SET(fdWrite, &readfds);
3960 ret = select(fdWrite+1, &readfds, &readfds, NULL, &select_timeout);
3961 ok(ret == 1, "select returned %d\n", ret);
3962 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3963
3964 FD_ZERO(&readfds);
3965 FD_SET(fdWrite, &readfds);
3966 FD_SET(fdRead, &readfds);
3967 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3968 ok(ret == 2, "select returned %d\n", ret);
3969 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3970 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3971
3972 ok(send(fdWrite, "test", 4, 0) == 4, "failed to send data\n");
3973 FD_ZERO(&readfds);
3974 FD_SET(fdRead, &readfds);
3975 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
3976 ok(ret == 1, "select returned %d\n", ret);
3977 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3978
3979 FD_ZERO(&readfds);
3980 FD_SET(fdWrite, &readfds);
3981 FD_SET(fdRead, &readfds);
3982 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3983 ok(ret == 2, "select returned %d\n", ret);
3984 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3985 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3986
3987 while(1) {
3988 FD_ZERO(&writefds);
3989 FD_SET(fdWrite, &writefds);
3990 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
3991 if(!ret) break;
3992 ok(send(fdWrite, tmp_buf, sizeof(tmp_buf), 0) > 0, "failed to send data\n");
3993 }
3994 FD_ZERO(&readfds);
3995 FD_SET(fdWrite, &readfds);
3996 FD_SET(fdRead, &readfds);
3997 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3998 ok(ret == 1, "select returned %d\n", ret);
3999 ok(!FD_ISSET(fdWrite, &readfds), "fdWrite socket is in the set\n");
4000 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4001
4002 ok(send(fdRead, "test", 4, 0) == 4, "failed to send data\n");
4003 Sleep(100);
4004 FD_ZERO(&readfds);
4005 FD_SET(fdWrite, &readfds);
4006 FD_SET(fdRead, &readfds);
4007 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
4008 ok(ret == 2, "select returned %d\n", ret);
4009 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4010 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4011
4012 closesocket(fdRead);
4013 closesocket(fdWrite);
4014
4015 /* select() works in 3 distinct states:
4016 * - to check if a connection attempt ended with success or error;
4017 * - to check if a pending connection is waiting for acceptance;
4018 * - to check for data to read, availability for write and OOB data
4019 *
4020 * The tests below ensure that all conditions are tested.
4021 */
4022 memset(&address, 0, sizeof(address));
4023 address.sin_addr.s_addr = inet_addr("127.0.0.1");
4024 address.sin_family = AF_INET;
4025 len = sizeof(address);
4026 fdListen = setup_server_socket(&address, &len);
4027 select_timeout.tv_sec = 1;
4028 select_timeout.tv_usec = 250000;
4029
4030 /* When no events are pending select returns 0 with no error */
4031 FD_ZERO_ALL();
4032 FD_SET_ALL(fdListen);
4033 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4034 ok(ret == 0, "expected 0, got %d\n", ret);
4035
4036 /* When a socket is attempting to connect the listening socket receives the read descriptor */
4037 fdWrite = setup_connector_socket(&address, len, TRUE);
4038 FD_ZERO_ALL();
4039 FD_SET_ALL(fdListen);
4040 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4041 ok(ret == 1, "expected 1, got %d\n", ret);
4042 ok(FD_ISSET(fdListen, &readfds), "fdListen socket is not in the set\n");
4043 len = sizeof(address);
4044 fdRead = accept(fdListen, (struct sockaddr*) &address, &len);
4045 ok(fdRead != INVALID_SOCKET, "expected a valid socket\n");
4046
4047 /* The connector is signaled through the write descriptor */
4048 FD_ZERO_ALL();
4049 FD_SET_ALL(fdListen);
4050 FD_SET_ALL(fdRead);
4051 FD_SET_ALL(fdWrite);
4052 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4053 ok(ret == 2, "expected 2, got %d\n", ret);
4054 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4055 ok(FD_ISSET(fdRead, &writefds), "fdRead socket is not in the set\n");
4056 len = sizeof(id);
4057 id = 0xdeadbeef;
4058 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
4059 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4060 ok(id == 0, "expected 0, got %d\n", id);
4061
4062 /* When data is received the receiver gets the read descriptor */
4063 ret = send(fdWrite, "1234", 4, 0);
4064 ok(ret == 4, "expected 4, got %d\n", ret);
4065 FD_ZERO_ALL();
4066 FD_SET_ALL(fdListen);
4067 FD_SET(fdRead, &readfds);
4068 FD_SET(fdRead, &exceptfds);
4069 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4070 ok(ret == 1, "expected 1, got %d\n", ret);
4071 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4072 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
4073 ok(ret == 4, "expected 4, got %d\n", ret);
4074 ok(!strcmp(tmp_buf, "1234"), "data received differs from sent\n");
4075
4076 /* When OOB data is received the socket is set in the except descriptor */
4077 ret = send(fdWrite, "A", 1, MSG_OOB);
4078 ok(ret == 1, "expected 1, got %d\n", ret);
4079 FD_ZERO_ALL();
4080 FD_SET_ALL(fdListen);
4081 FD_SET(fdRead, &readfds);
4082 FD_SET(fdRead, &exceptfds);
4083 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4084 ok(ret == 1, "expected 1, got %d\n", ret);
4085 ok(FD_ISSET(fdRead, &exceptfds), "fdRead socket is not in the set\n");
4086 tmp_buf[0] = 0xAF;
4087 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
4088 ok(ret == 1, "expected 1, got %d\n", ret);
4089 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
4090
4091 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
4092 ret = 1;
4093 ret = setsockopt(fdRead, SOL_SOCKET, SO_OOBINLINE, (char*) &ret, sizeof(ret));
4094 ok(ret == 0, "expected 0, got %d\n", ret);
4095 ret = send(fdWrite, "A", 1, MSG_OOB);
4096 ok(ret == 1, "expected 1, got %d\n", ret);
4097 FD_ZERO_ALL();
4098 FD_SET_ALL(fdListen);
4099 FD_SET(fdRead, &readfds);
4100 FD_SET(fdRead, &exceptfds);
4101 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4102 ok(ret == 1, "expected 1, got %d\n", ret);
4103 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
4104 tmp_buf[0] = 0xAF;
4105 SetLastError(0xdeadbeef);
4106 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
4107 ok(ret == SOCKET_ERROR, "expected SOCKET_ERROR, got %d\n", ret);
4108 ok(GetLastError() == WSAEINVAL, "expected 10022, got %d\n", GetLastError());
4109 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
4110 ok(ret == 1, "expected 1, got %d\n", ret);
4111 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
4112
4113 /* When the connection is closed the socket is set in the read descriptor */
4114 ret = closesocket(fdRead);
4115 ok(ret == 0, "expected 0, got %d\n", ret);
4116 FD_ZERO_ALL();
4117 FD_SET_ALL(fdListen);
4118 FD_SET(fdWrite, &readfds);
4119 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4120 ok(ret == 1, "expected 1, got %d\n", ret);
4121 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4122 ret = recv(fdWrite, tmp_buf, sizeof(tmp_buf), 0);
4123 ok(ret == 0, "expected 0, got %d\n", ret);
4124
4125 /* When a connection is attempted to a non-listening socket it will get to the except descriptor */
4126 ret = closesocket(fdWrite);
4127 ok(ret == 0, "expected 0, got %d\n", ret);
4128 ret = closesocket(fdListen);
4129 ok(ret == 0, "expected 0, got %d\n", ret);
4130 len = sizeof(address);
4131 fdWrite = setup_connector_socket(&address, len, TRUE);
4132 FD_ZERO_ALL();
4133 FD_SET(fdWrite, &writefds);
4134 FD_SET(fdWrite, &exceptfds);
4135 select_timeout.tv_sec = 2; /* requires more time to realize it will not connect */
4136 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4137 ok(ret == 1, "expected 1, got %d\n", ret);
4138 len = sizeof(id);
4139 id = 0xdeadbeef;
4140 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
4141 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
4142 ok(id == WSAECONNREFUSED, "expected 10061, got %d\n", id);
4143 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
4144 ok(select_timeout.tv_usec == 250000, "select timeout should not have changed\n");
4145 closesocket(fdWrite);
4146
4147 /* Try select() on a closed socket after connection */
4148 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
4149 closesocket(fdRead);
4150 FD_ZERO_ALL();
4151 FD_SET_ALL(fdWrite);
4152 FD_SET_ALL(fdRead);
4153 SetLastError(0xdeadbeef);
4154 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
4155 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4156 todo_wine
4157 ok(GetLastError() == WSAENOTSOCK, "expected 10038, got %d\n", GetLastError());
4158 /* descriptor sets are unchanged */
4159 ok(readfds.fd_count == 2, "expected 2, got %d\n", readfds.fd_count);
4160 ok(exceptfds.fd_count == 2, "expected 2, got %d\n", exceptfds.fd_count);
4161 closesocket(fdWrite);
4162
4163 /* Close the socket currently being selected in a thread - bug 38399 */
4164 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
4165 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
4166 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
4167 FD_ZERO_ALL();
4168 FD_SET_ALL(fdWrite);
4169 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
4170 ok(ret == 1, "expected 1, got %d\n", ret);
4171 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
4172 WaitForSingleObject (thread_handle, 1000);
4173 closesocket(fdRead);
4174 /* test again with only the except descriptor */
4175 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
4176 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
4177 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
4178 FD_ZERO_ALL();
4179 FD_SET(fdWrite, &exceptfds);
4180 SetLastError(0xdeadbeef);
4181 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
4182 todo_wine
4183 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4184 todo_wine
4185 ok(GetLastError() == WSAENOTSOCK, "expected 10038, got %d\n", GetLastError());
4186 WaitForSingleObject (thread_handle, 1000);
4187 closesocket(fdRead);
4188
4189 /* test UDP behavior of unbound sockets */
4190 select_timeout.tv_sec = 0;
4191 select_timeout.tv_usec = 250000;
4192 fdWrite = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
4193 ok(fdWrite != INVALID_SOCKET, "socket call failed\n");
4194 FD_ZERO_ALL();
4195 FD_SET_ALL(fdWrite);
4196 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
4197 ok(ret == 1, "expected 1, got %d\n", ret);
4198 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
4199 closesocket(fdWrite);
4200 }
4201 #undef FD_SET_ALL
4202 #undef FD_ZERO_ALL
4203
4204 static DWORD WINAPI AcceptKillThread(void *param)
4205 {
4206 select_thread_params *par = param;
4207 struct sockaddr_in address;
4208 int len = sizeof(address);
4209 SOCKET client_socket;
4210
4211 SetEvent(server_ready);
4212 client_socket = accept(par->s, (struct sockaddr*) &address, &len);
4213 if (client_socket != INVALID_SOCKET)
4214 closesocket(client_socket);
4215 par->ReadKilled = (client_socket == INVALID_SOCKET);
4216 return 0;
4217 }
4218
4219
4220 static int CALLBACK AlwaysDeferConditionFunc(LPWSABUF lpCallerId, LPWSABUF lpCallerData, LPQOS pQos,
4221 LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,
4222 GROUP *g, DWORD_PTR dwCallbackData)
4223 {
4224 return CF_DEFER;
4225 }
4226
4227 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len)
4228 {
4229 int ret, val;
4230 SOCKET server_socket;
4231
4232 server_socket = socket(AF_INET, SOCK_STREAM, 0);
4233 if (server_socket == INVALID_SOCKET)
4234 {
4235 trace("error creating server socket: %d\n", WSAGetLastError());
4236 return INVALID_SOCKET;
4237 }
4238
4239 val = 1;
4240 ret = setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
4241 if (ret)
4242 {
4243 trace("error setting SO_REUSEADDR: %d\n", WSAGetLastError());
4244 closesocket(server_socket);
4245 return INVALID_SOCKET;
4246 }
4247
4248 ret = bind(server_socket, (struct sockaddr *)addr, *len);
4249 if (ret)
4250 {
4251 trace("error binding server socket: %d\n", WSAGetLastError());
4252 }
4253
4254 ret = getsockname(server_socket, (struct sockaddr *)addr, len);
4255 if (ret)
4256 {
4257 skip("failed to lookup bind address: %d\n", WSAGetLastError());
4258 closesocket(server_socket);
4259 return INVALID_SOCKET;
4260 }
4261
4262 ret = listen(server_socket, 5);
4263 if (ret)
4264 {
4265 trace("error making server socket listen: %d\n", WSAGetLastError());
4266 closesocket(server_socket);
4267 return INVALID_SOCKET;
4268 }
4269
4270 return server_socket;
4271 }
4272
4273 static SOCKET setup_connector_socket(struct sockaddr_in *addr, int len, BOOL nonblock)
4274 {
4275 int ret;
4276 SOCKET connector;
4277
4278 connector = socket(AF_INET, SOCK_STREAM, 0);
4279 ok(connector != INVALID_SOCKET, "failed to create connector socket %d\n", WSAGetLastError());
4280
4281 if (nonblock)
4282 set_blocking(connector, !nonblock);
4283
4284 ret = connect(connector, (struct sockaddr *)addr, len);
4285 if (!nonblock)
4286 ok(!ret, "connecting to accepting socket failed %d\n", WSAGetLastError());
4287 else if (ret == SOCKET_ERROR)
4288 {
4289 DWORD error = WSAGetLastError();
4290 ok(error == WSAEWOULDBLOCK || error == WSAEINPROGRESS,
4291 "expected 10035 or 10036, got %d\n", error);
4292 }
4293
4294 return connector;
4295 }
4296
4297 static void test_accept(void)
4298 {
4299 int ret;
4300 SOCKET server_socket, accepted = INVALID_SOCKET, connector;
4301 struct sockaddr_in address;
4302 SOCKADDR_STORAGE ss, ss_empty;
4303 int socklen;
4304 select_thread_params thread_params;
4305 HANDLE thread_handle = NULL;
4306 DWORD id;
4307
4308 memset(&address, 0, sizeof(address));
4309 address.sin_addr.s_addr = inet_addr("127.0.0.1");
4310 address.sin_family = AF_INET;
4311
4312 socklen = sizeof(address);
4313 server_socket = setup_server_socket(&address, &socklen);
4314 if (server_socket == INVALID_SOCKET)
4315 {
4316 trace("error creating server socket: %d\n", WSAGetLastError());
4317 return;
4318 }
4319
4320 connector = setup_connector_socket(&address, socklen, FALSE);
4321 if (connector == INVALID_SOCKET) goto done;
4322
4323 trace("Blocking accept next\n");
4324
4325 accepted = WSAAccept(server_socket, NULL, NULL, AlwaysDeferConditionFunc, 0);
4326 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
4327
4328 accepted = accept(server_socket, NULL, 0);
4329 ok(accepted != INVALID_SOCKET, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
4330
4331 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
4332 if (server_ready == INVALID_HANDLE_VALUE)
4333 {
4334 trace("error creating event: %d\n", GetLastError());
4335 goto done;
4336 }
4337
4338 thread_params.s = server_socket;
4339 thread_params.ReadKilled = FALSE;
4340 thread_handle = CreateThread(NULL, 0, AcceptKillThread, &thread_params, 0, &id);
4341 if (thread_handle == NULL)
4342 {
4343 trace("error creating thread: %d\n", GetLastError());
4344 goto done;
4345 }
4346
4347 WaitForSingleObject(server_ready, INFINITE);
4348 Sleep(200);
4349 ret = closesocket(server_socket);
4350 if (ret != 0)
4351 {
4352 trace("closesocket failed: %d\n", WSAGetLastError());
4353 goto done;
4354 }
4355
4356 WaitForSingleObject(thread_handle, 1000);
4357 ok(thread_params.ReadKilled, "closesocket did not wake up accept\n");
4358
4359 closesocket(accepted);
4360 closesocket(connector);
4361 accepted = connector = INVALID_SOCKET;
4362
4363 socklen = sizeof(address);
4364 server_socket = setup_server_socket(&address, &socklen);
4365 if (server_socket == INVALID_SOCKET) goto done;
4366
4367 connector = setup_connector_socket(&address, socklen, FALSE);
4368 if (connector == INVALID_SOCKET) goto done;
4369
4370 socklen = 0;
4371 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
4372 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
4373 ok(!socklen, "got %d\n", socklen);
4374 closesocket(connector);
4375 connector = INVALID_SOCKET;
4376
4377 socklen = sizeof(address);
4378 connector = setup_connector_socket(&address, socklen, FALSE);
4379 if (connector == INVALID_SOCKET) goto done;
4380
4381 accepted = WSAAccept(server_socket, NULL, NULL, NULL, 0);
4382 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4383 closesocket(accepted);
4384 closesocket(connector);
4385 accepted = connector = INVALID_SOCKET;
4386
4387 socklen = sizeof(address);
4388 connector = setup_connector_socket(&address, socklen, FALSE);
4389 if (connector == INVALID_SOCKET) goto done;
4390
4391 socklen = sizeof(ss);
4392 memset(&ss, 0, sizeof(ss));
4393 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
4394 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4395 ok(socklen != sizeof(ss), "unexpected length\n");
4396 ok(ss.ss_family, "family not set\n");
4397 closesocket(accepted);
4398 closesocket(connector);
4399 accepted = connector = INVALID_SOCKET;
4400
4401 socklen = sizeof(address);
4402 connector = setup_connector_socket(&address, socklen, FALSE);
4403 if (connector == INVALID_SOCKET) goto done;
4404
4405 socklen = 0;
4406 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4407 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
4408 ok(!socklen, "got %d\n", socklen);
4409 closesocket(connector);
4410 accepted = connector = INVALID_SOCKET;
4411
4412 socklen = sizeof(address);
4413 connector = setup_connector_socket(&address, socklen, FALSE);
4414 if (connector == INVALID_SOCKET) goto done;
4415
4416 accepted = accept(server_socket, NULL, NULL);
4417 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4418 closesocket(accepted);
4419 closesocket(connector);
4420 accepted = connector = INVALID_SOCKET;
4421
4422 socklen = sizeof(address);
4423 connector = setup_connector_socket(&address, socklen, FALSE);
4424 if (connector == INVALID_SOCKET) goto done;
4425
4426 socklen = sizeof(ss);
4427 memset(&ss, 0, sizeof(ss));
4428 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4429 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4430 ok(socklen != sizeof(ss), "unexpected length\n");
4431 ok(ss.ss_family, "family not set\n");
4432 closesocket(accepted);
4433 closesocket(connector);
4434 accepted = connector = INVALID_SOCKET;
4435
4436 socklen = sizeof(address);
4437 connector = setup_connector_socket(&address, socklen, FALSE);
4438 if (connector == INVALID_SOCKET) goto done;
4439
4440 memset(&ss, 0, sizeof(ss));
4441 memset(&ss_empty, 0, sizeof(ss_empty));
4442 accepted = accept(server_socket, (struct sockaddr *)&ss, NULL);
4443 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4444 ok(!memcmp(&ss, &ss_empty, sizeof(ss)), "structure is different\n");
4445
4446 done:
4447 if (accepted != INVALID_SOCKET)
4448 closesocket(accepted);
4449 if (connector != INVALID_SOCKET)
4450 closesocket(connector);
4451 if (thread_handle != NULL)
4452 CloseHandle(thread_handle);
4453 if (server_ready != INVALID_HANDLE_VALUE)
4454 CloseHandle(server_ready);
4455 if (server_socket != INVALID_SOCKET)
4456 closesocket(server_socket);
4457 }
4458
4459 static void test_extendedSocketOptions(void)
4460 {
4461 WSADATA wsa;
4462 SOCKET sock;
4463 struct sockaddr_in sa;
4464 int sa_len = sizeof(struct sockaddr_in);
4465 int optval, optlen = sizeof(int), ret;
4466 BOOL bool_opt_val;
4467 LINGER linger_val;
4468
4469 if(WSAStartup(MAKEWORD(2,0), &wsa)){
4470 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4471 return;
4472 }
4473
4474 memset(&sa, 0, sa_len);
4475
4476 sa.sin_family = AF_INET;
4477 sa.sin_port = htons(0);
4478 sa.sin_addr.s_addr = htonl(INADDR_ANY);
4479
4480 if((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP)) == INVALID_SOCKET) {
4481 trace("Creating the socket failed: %d\n", WSAGetLastError());
4482 WSACleanup();
4483 return;
4484 }
4485
4486 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
4487 trace("Failed to bind socket: %d\n", WSAGetLastError());
4488 closesocket(sock);
4489 WSACleanup();
4490 return;
4491 }
4492
4493 ret = getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4494
4495 ok(ret == 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret);
4496 ok((optval == 65507) || (optval == 65527),
4497 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval);
4498
4499 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
4500 SetLastError(0xdeadbeef);
4501 optval = 0xdeadbeef;
4502 optlen = sizeof(int);
4503 ret = getsockopt(sock, 0xffffffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4504 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4505 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4506 ret, WSAGetLastError(), optval, optval);
4507
4508 /* more invalid values for level */
4509 SetLastError(0xdeadbeef);
4510 optval = 0xdeadbeef;
4511 optlen = sizeof(int);
4512 ret = getsockopt(sock, 0x1234ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4513 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4514 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4515 ret, WSAGetLastError(), optval, optval);
4516
4517 SetLastError(0xdeadbeef);
4518 optval = 0xdeadbeef;
4519 optlen = sizeof(int);
4520 ret = getsockopt(sock, 0x8000ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4521 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4522 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4523 ret, WSAGetLastError(), optval, optval);
4524
4525 SetLastError(0xdeadbeef);
4526 optval = 0xdeadbeef;
4527 optlen = sizeof(int);
4528 ret = getsockopt(sock, 0x00008000, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4529 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4530 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4531 ret, WSAGetLastError(), optval, optval);
4532
4533 SetLastError(0xdeadbeef);
4534 optval = 0xdeadbeef;
4535 optlen = sizeof(int);
4536 ret = getsockopt(sock, 0x00000800, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4537 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4538 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4539 ret, WSAGetLastError(), optval, optval);
4540
4541 SetLastError(0xdeadbeef);
4542 optlen = sizeof(LINGER);
4543 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
4544 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAENOPROTOOPT),
4545 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
4546 ret, WSAGetLastError());
4547 closesocket(sock);
4548
4549 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
4550 trace("Creating the socket failed: %d\n", WSAGetLastError());
4551 WSACleanup();
4552 return;
4553 }
4554
4555 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
4556 trace("Failed to bind socket: %d\n", WSAGetLastError());
4557 closesocket(sock);
4558 WSACleanup();
4559 return;
4560 }
4561
4562 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
4563 ok(ret == 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret);
4564
4565 optlen = sizeof(BOOL);
4566 ret = getsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *)&bool_opt_val, &optlen);
4567 ok(ret == 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret);
4568 ok((linger_val.l_onoff && !bool_opt_val) || (!linger_val.l_onoff && bool_opt_val),
4569 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
4570 bool_opt_val, linger_val.l_onoff);
4571
4572 closesocket(sock);
4573 WSACleanup();
4574 }
4575
4576 static void test_getsockname(void)
4577 {
4578 WSADATA wsa;
4579 SOCKET sock;
4580 struct sockaddr_in sa_set, sa_get;
4581 int sa_set_len = sizeof(struct sockaddr_in);
4582 int sa_get_len = sa_set_len;
4583 static const unsigned char null_padding[] = {0,0,0,0,0,0,0,0};
4584 int ret;
4585 struct hostent *h;
4586
4587 if(WSAStartup(MAKEWORD(2,0), &wsa)){
4588 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4589 return;
4590 }
4591
4592 memset(&sa_set, 0, sa_set_len);
4593
4594 sa_set.sin_family = AF_INET;
4595 sa_set.sin_port = htons(0);
4596 sa_set.sin_addr.s_addr = htonl(INADDR_ANY);
4597
4598 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
4599 trace("Creating the socket failed: %d\n", WSAGetLastError());
4600 WSACleanup();
4601 return;
4602 }
4603
4604 sa_get = sa_set;
4605 if (getsockname(sock, (struct sockaddr*) &sa_get, &sa_get_len) == 0)
4606 ok(0, "getsockname on unbound socket should fail\n");
4607 else {
4608 ok(WSAGetLastError() == WSAEINVAL, "getsockname on unbound socket "
4609 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL);
4610 ok(memcmp(&sa_get, &sa_set, sizeof(sa_get)) == 0,
4611 "failed getsockname modified sockaddr when it shouldn't\n");
4612 }
4613
4614 if(bind(sock, (struct sockaddr *) &sa_set, sa_set_len) < 0){
4615 trace("Failed to bind socket: %d\n", WSAGetLastError());
4616 closesocket(sock);
4617 WSACleanup();
4618 return;
4619 }
4620
4621 if(getsockname(sock, (struct sockaddr *) &sa_get, &sa_get_len) != 0){
4622 trace("Failed to call getsockname: %d\n", WSAGetLastError());
4623 closesocket(sock);
4624 WSACleanup();
4625 return;
4626 }
4627
4628 ret = memcmp(sa_get.sin_zero, null_padding, 8);
4629 ok(ret == 0, "getsockname did not zero the sockaddr_in structure\n");
4630
4631 closesocket(sock);
4632
4633 h = gethostbyname("");
4634 if (h && h->h_length == 4) /* this test is only meaningful in IPv4 */
4635 {
4636 int i;
4637 for (i = 0; h->h_addr_list[i]; i++)
4638 {
4639 char ipstr[32];
4640 struct in_addr ip;
4641 ip.s_addr = *(ULONG *) h->h_addr_list[i];
4642
4643 sock = socket(AF_INET, SOCK_DGRAM, 0);
4644 ok(sock != INVALID_SOCKET, "socket failed with %d\n", GetLastError());
4645
4646 memset(&sa_set, 0, sizeof(sa_set));
4647 sa_set.sin_family = AF_INET;
4648 sa_set.sin_addr.s_addr = ip.s_addr;
4649 /* The same address we bind must be the same address we get */
4650 ret = bind(sock, (struct sockaddr*)&sa_set, sizeof(sa_set));
4651 ok(ret == 0, "bind failed with %d\n", GetLastError());
4652 sa_get_len = sizeof(sa_get);
4653 ret = getsockname(sock, (struct sockaddr*)&sa_get, &sa_get_len);
4654 ok(ret == 0, "getsockname failed with %d\n", GetLastError());
4655 strcpy(ipstr, inet_ntoa(sa_get.sin_addr));
4656 trace("testing bind on interface %s\n", ipstr);
4657 ok(sa_get.sin_addr.s_addr == sa_set.sin_addr.s_addr,
4658 "address does not match: %s != %s\n", ipstr, inet_ntoa(sa_set.sin_addr));
4659
4660 closesocket(sock);
4661 }
4662 }
4663
4664 WSACleanup();
4665 }
4666
4667 static void test_dns(void)
4668 {
4669 struct hostent *h;
4670 union memaddress
4671 {
4672 char *chr;
4673 void *mem;
4674 } addr;
4675 char **ptr;
4676 int acount;
4677
4678 h = gethostbyname("");
4679 ok(h != NULL, "gethostbyname(\"\") failed with %d\n", h_errno);
4680
4681 /* Use an address with valid alias names if possible */
4682 h = gethostbyname("source.winehq.org");
4683 if(!h)
4684 {
4685 skip("Can't test the hostent structure because gethostbyname failed\n");
4686 return;
4687 }
4688
4689 /* The returned struct must be allocated in a very strict way. First we need to
4690 * count how many aliases there are because they must be located right after
4691 * the struct hostent size. Knowing the amount of aliases we know the exact
4692 * location of the first IP returned. Rule valid for >= XP, for older OS's
4693 * it's somewhat the opposite. */
4694 addr.mem = h + 1;
4695 if(h->h_addr_list == addr.mem) /* <= W2K */
4696 {
4697 win_skip("Skipping hostent tests since this OS is unsupported\n");
4698 return;
4699 }
4700
4701 ok(h->h_aliases == addr.mem,
4702 "hostent->h_aliases should be in %p, it is in %p\n", addr.mem, h->h_aliases);
4703
4704 for(ptr = h->h_aliases, acount = 1; *ptr; ptr++) acount++;
4705 addr.chr += sizeof(*ptr) * acount;
4706 ok(h->h_addr_list == addr.mem,
4707 "hostent->h_addr_list should be in %p, it is in %p\n", addr.mem, h->h_addr_list);
4708
4709 for(ptr = h->h_addr_list, acount = 1; *ptr; ptr++) acount++;
4710
4711 addr.chr += sizeof(*ptr) * acount;
4712 ok(h->h_addr_list[0] == addr.mem,
4713 "hostent->h_addr_list[0] should be in %p, it is in %p\n", addr.mem, h->h_addr_list[0]);
4714 }
4715
4716 /* Our winsock headers don't define gethostname because it conflicts with the
4717 * definition in unistd.h. Define it here to get rid of the warning. */
4718
4719 int WINAPI gethostname(char *name, int namelen);
4720
4721 static void test_gethostbyname(void)
4722 {
4723 struct hostent *he;
4724 struct in_addr **addr_list;
4725 char name[256], first_ip[16];
4726 int ret, i, count;
4727 PMIB_IPFORWARDTABLE routes = NULL;
4728 PIP_ADAPTER_INFO adapters = NULL, k;
4729 DWORD adap_size = 0, route_size = 0;
4730 BOOL found_default = FALSE;
4731 BOOL local_ip = FALSE;
4732
4733 ret = gethostname(name, sizeof(name));
4734 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4735
4736 he = gethostbyname(name);
4737 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, WSAGetLastError());
4738 addr_list = (struct in_addr **)he->h_addr_list;
4739 strcpy(first_ip, inet_ntoa(*addr_list[0]));
4740
4741 trace("List of local IPs:\n");
4742 for(count = 0; addr_list[count] != NULL; count++)
4743 {
4744 char *ip = inet_ntoa(*addr_list[count]);
4745 if (!strcmp(ip, "127.0.0.1"))
4746 local_ip = TRUE;
4747 trace("%s\n", ip);
4748 }
4749
4750 if (local_ip)
4751 {
4752 ok (count == 1, "expected 127.0.0.1 to be the only IP returned\n");
4753 skip("Only the loopback address is present, skipping tests\n");
4754 return;
4755 }
4756
4757 if (!pGetAdaptersInfo || !pGetIpForwardTable)
4758 {
4759 win_skip("GetAdaptersInfo and/or GetIpForwardTable not found, skipping tests\n");
4760 return;
4761 }
4762
4763 ret = pGetAdaptersInfo(NULL, &adap_size);
4764 ok (ret == ERROR_BUFFER_OVERFLOW, "GetAdaptersInfo failed with a different error: %d\n", ret);
4765 ret = pGetIpForwardTable(NULL, &route_size, FALSE);
4766 ok (ret == ERROR_INSUFFICIENT_BUFFER, "GetIpForwardTable failed with a different error: %d\n", ret);
4767
4768 adapters = HeapAlloc(GetProcessHeap(), 0, adap_size);
4769 routes = HeapAlloc(GetProcessHeap(), 0, route_size);
4770
4771 ret = pGetAdaptersInfo(adapters, &adap_size);
4772 ok (ret == NO_ERROR, "GetAdaptersInfo failed, error: %d\n", ret);
4773 ret = pGetIpForwardTable(routes, &route_size, FALSE);
4774 ok (ret == NO_ERROR, "GetIpForwardTable failed, error: %d\n", ret);
4775
4776 /* This test only has meaning if there is more than one IP configured */
4777 if (adapters->Next == NULL && count == 1)
4778 {
4779 skip("Only one IP is present, skipping tests\n");
4780 goto cleanup;
4781 }
4782
4783 for (i = 0; !found_default && i < routes->dwNumEntries; i++)
4784 {
4785 /* default route (ip 0.0.0.0) ? */
4786 if (routes->table[i].dwForwardDest) continue;
4787
4788 for (k = adapters; k != NULL; k = k->Next)
4789 {
4790 char *ip;
4791
4792 if (k->Index != routes->table[i].dwForwardIfIndex) continue;
4793
4794 /* the first IP returned from gethostbyname must be a default route */
4795 ip = k->IpAddressList.IpAddress.String;
4796 if (!strcmp(first_ip, ip))
4797 {
4798 found_default = TRUE;
4799 break;
4800 }
4801 }
4802 }
4803 ok (found_default, "failed to find the first IP from gethostbyname!\n");
4804
4805 cleanup:
4806 HeapFree(GetProcessHeap(), 0, adapters);
4807 HeapFree(GetProcessHeap(), 0, routes);
4808 }
4809
4810 static void test_gethostbyname_hack(void)
4811 {
4812 struct hostent *he;
4813 char name[256];
4814 static BYTE loopback[] = {127, 0, 0, 1};
4815 static BYTE magic_loopback[] = {127, 12, 34, 56};
4816 int ret;
4817
4818 ret = gethostname(name, 256);
4819 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4820
4821 he = gethostbyname("localhost");
4822 ok(he != NULL, "gethostbyname(\"localhost\") failed: %d\n", h_errno);
4823 if(he)
4824 {
4825 if(he->h_length != 4)
4826 {
4827 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
4828 return;
4829 }
4830
4831 ok(memcmp(he->h_addr_list[0], loopback, he->h_length) == 0,
4832 "gethostbyname(\"localhost\") returned %u.%u.%u.%u\n",
4833 he->h_addr_list[0][0], he->h_addr_list[0][1], he->h_addr_list[0][2],
4834 he->h_addr_list[0][3]);
4835 }
4836
4837 if(strcmp(name, "localhost") == 0)
4838 {
4839 skip("hostname seems to be \"localhost\", skipping test.\n");
4840 return;
4841 }
4842
4843 he = gethostbyname(name);
4844 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, h_errno);
4845 if(he)
4846 {
4847 if(he->h_length != 4)
4848 {
4849 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
4850 return;
4851 }
4852
4853 if (he->h_addr_list[0][0] == 127)
4854 {
4855 ok(memcmp(he->h_addr_list[0], magic_loopback, he->h_length) == 0,
4856 "gethostbyname(\"%s\") returned %u.%u.%u.%u not 127.12.34.56\n",
4857 name, he->h_addr_list[0][0], he->h_addr_list[0][1],
4858 he->h_addr_list[0][2], he->h_addr_list[0][3]);
4859 }
4860 }
4861
4862 gethostbyname("nonexistent.winehq.org");
4863 /* Don't check for the return value, as some braindead ISPs will kindly
4864 * resolve nonexistent host names to addresses of the ISP's spam pages. */
4865 }
4866
4867 static void test_gethostname(void)
4868 {
4869 struct hostent *he;
4870 char name[256];
4871 int ret, len;
4872
4873 WSASetLastError(0xdeadbeef);
4874 ret = gethostname(NULL, 256);
4875 ok(ret == -1, "gethostname() returned %d\n", ret);
4876 ok(WSAGetLastError() == WSAEFAULT, "gethostname with null buffer "
4877 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT);
4878
4879 ret = gethostname(name, sizeof(name));
4880 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4881 he = gethostbyname(name);
4882 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, WSAGetLastError());
4883
4884 len = strlen(name);
4885 WSASetLastError(0xdeadbeef);
4886 strcpy(name, "deadbeef");
4887 ret = gethostname(name, len);
4888 ok(ret == -1, "gethostname() returned %d\n", ret);
4889 ok(!strcmp(name, "deadbeef"), "name changed unexpected!\n");
4890 ok(WSAGetLastError() == WSAEFAULT, "gethostname with insufficient length "
4891 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT);
4892
4893 len++;
4894 ret = gethostname(name, len);
4895 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4896 he = gethostbyname(name);
4897 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, WSAGetLastError());
4898 }
4899
4900 static void test_inet_addr(void)
4901 {
4902 u_long addr;
4903
4904 addr = inet_addr(NULL);
4905 ok(addr == INADDR_NONE, "inet_addr succeeded unexpectedly\n");
4906 }
4907
4908 static void test_addr_to_print(void)
4909 {
4910 char dst[16];
4911 char dst6[64];
4912 const char * pdst;
4913 struct in_addr in;
4914 struct in6_addr in6;
4915
4916 u_long addr0_Num = 0x00000000;
4917 PCSTR addr0_Str = "0.0.0.0";
4918 u_long addr1_Num = 0x20201015;
4919 PCSTR addr1_Str = "21.16.32.32";
4920 u_char addr2_Num[16] = {0,0,0,0,0,0,0,0,0,0,0xff,0xfe,0xcC,0x98,0xbd,0x74};
4921 PCSTR addr2_Str = "::fffe:cc98:bd74";
4922 u_char addr3_Num[16] = {0x20,0x30,0xa4,0xb1};
4923 PCSTR addr3_Str = "2030:a4b1::";
4924 u_char addr4_Num[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0xcC,0x98,0xbd,0x74};
4925 PCSTR addr4_Str = "::204.152.189.116";
4926
4927 /* Test IPv4 addresses */
4928 in.s_addr = addr0_Num;
4929
4930 pdst = inet_ntoa(*((struct in_addr*)&in.s_addr));
4931 ok(pdst != NULL, "inet_ntoa failed %s\n", dst);
4932 ok(!strcmp(pdst, addr0_Str),"Address %s != %s\n", pdst, addr0_Str);
4933
4934 /* Test that inet_ntoa and inet_ntop return the same value */
4935 in.S_un.S_addr = addr1_Num;
4936 pdst = inet_ntoa(*((struct in_addr*)&in.s_addr));
4937 ok(pdst != NULL, "inet_ntoa failed %s\n", dst);
4938 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4939
4940 /* InetNtop became available in Vista and Win2008 */
4941 if (!pInetNtop)
4942 {
4943 win_skip("InetNtop not present, not executing tests\n");
4944 return;
4945 }
4946
4947 /* Second part of test */
4948 pdst = pInetNtop(AF_INET,(void*)&in.s_addr, dst, sizeof(dst));
4949 ok(pdst != NULL, "InetNtop failed %s\n", dst);
4950 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4951
4952 /* Test invalid parm conditions */
4953 pdst = pInetNtop(1, (void*)&in.s_addr, dst, sizeof(dst));
4954 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4955 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "Should be WSAEAFNOSUPPORT\n");
4956
4957 /* Test Null destination */
4958 pdst = NULL;
4959 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, NULL, sizeof(dst));
4960 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4961 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4962 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4963
4964 /* Test zero length passed */
4965 WSASetLastError(0);
4966 pdst = NULL;
4967 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, 0);
4968 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4969 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4970 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4971
4972 /* Test length one shorter than the address length */
4973 WSASetLastError(0);
4974 pdst = NULL;
4975 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, 6);
4976 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4977 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4978 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4979
4980 /* Test longer length is ok */
4981 WSASetLastError(0);
4982 pdst = NULL;
4983 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, sizeof(dst)+1);
4984 ok(pdst != NULL, "The pointer should be returned (%p)\n", pdst);
4985 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4986
4987 /* Test the IPv6 addresses */
4988
4989 /* Test an zero prefixed IPV6 address */
4990 memcpy(in6.u.Byte, addr2_Num, sizeof(addr2_Num));
4991 pdst = pInetNtop(AF_INET6,(void*)&in6.s6_addr, dst6, sizeof(dst6));
4992 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
4993 ok(!strcmp(pdst, addr2_Str),"Address %s != %s\n", pdst, addr2_Str);
4994
4995 /* Test an zero suffixed IPV6 address */
4996 memcpy(in6.s6_addr, addr3_Num, sizeof(addr3_Num));
4997 pdst = pInetNtop(AF_INET6,(void*)&in6.s6_addr, dst6, sizeof(dst6));
4998 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
4999 ok(!strcmp(pdst, addr3_Str),"Address %s != %s\n", pdst, addr3_Str);
5000
5001 /* Test the IPv6 address contains the IPv4 address in IPv4 notation */
5002 memcpy(in6.s6_addr, addr4_Num, sizeof(addr4_Num));
5003 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, sizeof(dst6));
5004 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
5005 ok(!strcmp(pdst, addr4_Str),"Address %s != %s\n", pdst, addr4_Str);
5006
5007 /* Test invalid parm conditions */
5008 memcpy(in6.u.Byte, addr2_Num, sizeof(addr2_Num));
5009
5010 /* Test Null destination */
5011 pdst = NULL;
5012 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, NULL, sizeof(dst6));
5013 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
5014 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
5015 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
5016
5017 /* Test zero length passed */
5018 WSASetLastError(0);
5019 pdst = NULL;
5020 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 0);
5021 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
5022 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
5023 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
5024
5025 /* Test length one shorter than the address length */
5026 WSASetLastError(0);
5027 pdst = NULL;
5028 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 16);
5029 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
5030 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
5031 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
5032
5033 /* Test longer length is ok */
5034 WSASetLastError(0);
5035 pdst = NULL;
5036 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 18);
5037 ok(pdst != NULL, "The pointer should be returned (%p)\n", pdst);
5038 }
5039 static void test_inet_pton(void)
5040 {
5041 struct TEST_DATA
5042 {
5043 int family, ret;
5044 DWORD err;
5045 const char *printable, *collapsed, *raw_data;
5046 } tests[] = {
5047 {AF_UNSPEC, -1, WSAEFAULT, /* Test 0 */
5048 NULL, NULL, NULL},
5049 {AF_INET, -1, WSAEFAULT,
5050 NULL, NULL, NULL},
5051 {AF_INET6, -1, WSAEFAULT,
5052 NULL, NULL, NULL},
5053 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
5054 "127.0.0.1", NULL, NULL},
5055 {AF_INET, 1, 0,
5056 "127.0.0.1", "127.0.0.1",
5057 "\x7f\x00\x00\x01"},
5058 {AF_INET6, 0, 0,
5059 "127.0.0.1", "127.0.0.1", NULL},
5060 {AF_INET, 0, 0,
5061 "::1/128", NULL, NULL},
5062 {AF_INET6, 0, 0,
5063 "::1/128", NULL, NULL},
5064 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
5065 "broken", NULL, NULL},
5066 {AF_INET, 0, 0,
5067 "broken", NULL, NULL},
5068 {AF_INET6, 0, 0, /* Test 10 */
5069 "broken", NULL, NULL},
5070 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
5071 "177.32.45.20", NULL, NULL},
5072 {AF_INET, 1, 0,
5073 "177.32.45.20", "177.32.45.20",
5074 "\xb1\x20\x2d\x14"},
5075 {AF_INET6, 0, 0,
5076 "177.32.45.20", NULL, NULL},
5077 {AF_INET, 0, 0,
5078 "2607:f0d0:1002:51::4", NULL, NULL},
5079 {AF_INET6, 1, 0,
5080 "2607:f0d0:1002:51::4", "2607:f0d0:1002:51::4",
5081 "\x26\x07\xf0\xd0\x10\x02\x00\x51\x00\x00\x00\x00\x00\x00\x00\x04"},
5082 {AF_INET, 0, 0,
5083 "::177.32.45.20", NULL, NULL},
5084 {AF_INET6, 1, 0,
5085 "::177.32.45.20", "::177.32.45.20",
5086 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x20\x2d\x14"},
5087 {AF_INET, 0, 0,
5088 "fe80::0202:b3ff:fe1e:8329", NULL, NULL},
5089 {AF_INET6, 1, 0,
5090 "fe80::0202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
5091 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
5092 {AF_INET6, 1, 0, /* Test 20 */
5093 "fe80::202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
5094 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
5095 {AF_INET, 0, 0,
5096 "a", NULL, NULL},
5097 {AF_INET, 0, 0,
5098 "a.b", NULL, NULL},
5099 {AF_INET, 0, 0,
5100 "a.b.c", NULL, NULL},
5101 {AF_INET, 0, 0,
5102 "a.b.c.d", NULL, NULL},
5103 {AF_INET6, 1, 0,
5104 "2001:cdba:0000:0000:0000:0000:3257:9652", "2001:cdba::3257:9652",
5105 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
5106 {AF_INET6, 1, 0,
5107 "2001:cdba::3257:9652", "2001:cdba::3257:9652",
5108 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
5109 {AF_INET6, 1, 0,
5110 "2001:cdba:0:0:0:0:3257:9652", "2001:cdba::3257:9652",
5111 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"}
5112 };
5113 int i, ret;
5114 DWORD err;
5115 char buffer[64],str[64];
5116 WCHAR printableW[64], collapsedW[64];
5117 const char *ptr;
5118 const WCHAR *ptrW;
5119
5120 /* InetNtop and InetPton became available in Vista and Win2008 */
5121 if (!pInetNtop || !pInetNtopW || !pInetPtonA || !pInetPtonW)
5122 {
5123 win_skip("InetNtop and/or InetPton not present, not executing tests\n");
5124 return;
5125 }
5126
5127 for (i = 0; i < ARRAY_SIZE(tests); i++)
5128 {
5129 WSASetLastError(0xdeadbeef);
5130 ret = pInetPtonA(tests[i].family, tests[i].printable, buffer);
5131 ok (ret == tests[i].ret, "Test [%d]: Expected %d, got %d\n", i, tests[i].ret, ret);
5132 if (tests[i].ret == -1)
5133 {
5134 err = WSAGetLastError();
5135 ok (tests[i].err == err, "Test [%d]: Expected 0x%x, got 0x%x\n", i, tests[i].err, err);
5136 }
5137 if (tests[i].ret != 1) continue;
5138 ok (memcmp(buffer, tests[i].raw_data,
5139 tests[i].family == AF_INET ? sizeof(struct in_addr) : sizeof(struct in6_addr)) == 0,
5140 "Test [%d]: Expected binary data differs\n", i);
5141
5142 /* Test the result from Pton with Ntop */
5143 strcpy (str, "deadbeef");
5144 ptr = pInetNtop(tests[i].family, buffer, str, sizeof(str));
5145 ok (ptr != NULL, "Test [%d]: Failed with NULL\n", i);
5146 ok (ptr == str, "Test [%d]: Pointers differ (%p != %p)\n", i, ptr, str);
5147 if (!ptr) continue;
5148 ok (strcmp(ptr, tests[i].collapsed) == 0, "Test [%d]: Expected '%s', got '%s'\n",
5149 i, tests[i].collapsed, ptr);
5150 }
5151
5152 for (i = 0; i < ARRAY_SIZE(tests); i++)
5153 {
5154 if (tests[i].printable)
5155 MultiByteToWideChar(CP_ACP, 0, tests[i].printable, -1, printableW, ARRAY_SIZE(printableW));
5156 WSASetLastError(0xdeadbeef);
5157 ret = pInetPtonW(tests[i].family, tests[i].printable ? printableW : NULL, buffer);
5158 ok(ret == tests[i].ret, "Test [%d]: Expected %d, got %d\n", i, tests[i].ret, ret);
5159 if (tests[i].ret == -1)
5160 {
5161 err = WSAGetLastError();
5162 ok(tests[i].err == err, "Test [%d]: Expected 0x%x, got 0x%x\n", i, tests[i].err, err);
5163 }
5164 if (tests[i].ret != 1) continue;
5165 ok(memcmp(buffer, tests[i].raw_data,
5166 tests[i].family == AF_INET ? sizeof(struct in_addr) : sizeof(struct in6_addr)) == 0,
5167 "Test [%d]: Expected binary data differs\n", i);
5168
5169 /* Test the result from Pton with Ntop */
5170 printableW[0] = 0xdead;
5171 ptrW = pInetNtopW(tests[i].family, buffer, printableW, ARRAY_SIZE(printableW));
5172 ok (ptrW != NULL, "Test [%d]: Failed with NULL\n", i);
5173 ok (ptrW == printableW, "Test [%d]: Pointers differ (%p != %p)\n", i, ptrW, printableW);
5174 if (!ptrW) continue;
5175
5176 MultiByteToWideChar(CP_ACP, 0, tests[i].collapsed, -1, collapsedW, ARRAY_SIZE(collapsedW));
5177 ok (lstrcmpW(ptrW, collapsedW) == 0, "Test [%d]: Expected '%s', got '%s'\n",
5178 i, tests[i].collapsed, wine_dbgstr_w(ptrW));
5179 }
5180 }
5181
5182 static void test_ioctlsocket(void)
5183 {
5184 SOCKET sock, src, dst;
5185 struct tcp_keepalive kalive;
5186 struct sockaddr_in address;
5187 int ret, optval;
5188 static const LONG cmds[] = {FIONBIO, FIONREAD, SIOCATMARK};
5189 UINT i, bytes_rec;
5190 char data;
5191 WSABUF bufs;
5192 u_long arg = 0;
5193
5194 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5195 ok(sock != INVALID_SOCKET, "Creating the socket failed: %d\n", WSAGetLastError());
5196 if(sock == INVALID_SOCKET)
5197 {
5198 skip("Can't continue without a socket.\n");
5199 return;
5200 }
5201
5202 for(i = 0; i < ARRAY_SIZE(cmds); i++)
5203 {
5204 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
5205 ret = ioctlsocket(sock, cmds[i], (u_long *)1);
5206 ok(ret == SOCKET_ERROR, "ioctlsocket succeeded unexpectedly\n");
5207 ret = WSAGetLastError();
5208 ok(ret == WSAEFAULT, "expected WSAEFAULT, got %d instead\n", ret);
5209 }
5210
5211 /* A fresh and not connected socket has no urgent data, this test shows
5212 * that normal(not urgent) data returns a non-zero value for SIOCATMARK. */
5213
5214 ret = ioctlsocket(sock, SIOCATMARK, &arg);
5215 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
5216 ok(arg, "SIOCATMARK expected a non-zero value\n");
5217
5218 /* when SO_OOBINLINE is set SIOCATMARK must always return TRUE */
5219 optval = 1;
5220 ret = setsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
5221 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
5222 arg = 0;
5223 ret = ioctlsocket(sock, SIOCATMARK, &arg);
5224 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
5225 ok(arg, "SIOCATMARK expected a non-zero value\n");
5226
5227 /* disable SO_OOBINLINE and get the same old behavior */
5228 optval = 0;
5229 ret = setsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
5230 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
5231 arg = 0;
5232 ret = ioctlsocket(sock, SIOCATMARK, &arg);
5233 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
5234 ok(arg, "SIOCATMARK expected a non-zero value\n");
5235
5236 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &arg, 0, NULL, 0, &arg, NULL, NULL);
5237 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5238 ret = WSAGetLastError();
5239 ok(ret == WSAEFAULT || broken(ret == WSAEINVAL), "expected WSAEFAULT, got %d instead\n", ret);
5240
5241 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, NULL, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5242 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5243 ret = WSAGetLastError();
5244 ok(ret == WSAEFAULT || broken(ret == WSAEINVAL), "expected WSAEFAULT, got %d instead\n", ret);
5245
5246 make_keepalive(kalive, 0, 0, 0);
5247 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5248 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5249
5250 make_keepalive(kalive, 1, 0, 0);
5251 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5252 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5253
5254 make_keepalive(kalive, 1, 1000, 1000);
5255 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5256 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5257
5258 make_keepalive(kalive, 1, 10000, 10000);
5259 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5260 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5261
5262 make_keepalive(kalive, 1, 100, 100);
5263 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5264 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5265
5266 make_keepalive(kalive, 0, 100, 100);
5267 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5268 ok(ret == 0, "WSAIoctl failed unexpectedly\n");
5269
5270 closesocket(sock);
5271
5272 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5273 ok(sock != INVALID_SOCKET, "Creating the socket failed: %d\n", WSAGetLastError());
5274 if(sock == INVALID_SOCKET)
5275 {
5276 skip("Can't continue without a socket.\n");
5277 return;
5278 }
5279
5280 /* test FIONREAD with a fresh and non-connected socket */
5281 arg = 0xdeadbeef;
5282 ret = ioctlsocket(sock, FIONREAD, &arg);
5283 ok(ret == 0, "ioctlsocket failed unexpectedly with error %d\n", WSAGetLastError());
5284 ok(arg == 0, "expected 0, got %u\n", arg);
5285
5286 memset(&address, 0, sizeof(address));
5287 address.sin_family = AF_INET;
5288 address.sin_addr.s_addr = inet_addr( SERVERIP );
5289 address.sin_port = htons( SERVERPORT );
5290 ret = bind(sock, (struct sockaddr *)&address, sizeof(address));
5291 ok(ret == 0, "bind failed unexpectedly with error %d\n", WSAGetLastError());
5292
5293 ret = listen(sock, SOMAXCONN);
5294 ok(ret == 0, "listen failed unexpectedly with error %d\n", WSAGetLastError());
5295
5296 /* test FIONREAD with listening socket */
5297 arg = 0xdeadbeef;
5298 ret = ioctlsocket(sock, FIONREAD, &arg);
5299 ok(ret == 0, "ioctlsocket failed unexpectedly with error %d\n", WSAGetLastError());
5300 ok(arg == 0, "expected 0, got %u\n", arg);
5301
5302 closesocket(sock);
5303
5304 if (tcp_socketpair(&src, &dst) != 0)
5305 {
5306 ok(0, "creating socket pair failed, skipping test\n");
5307 return;
5308 }
5309
5310 /* test FIONREAD on TCP sockets */
5311 optval = 0xdeadbeef;
5312 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
5313 ok(ret == 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
5314 ok(optval == 0, "FIONREAD should have returned 0 bytes, got %d instead\n", optval);
5315
5316 optval = 0xdeadbeef;
5317 ok(send(src, "TEST", 4, 0) == 4, "failed to send test data\n");
5318 Sleep(100);
5319 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
5320 ok(ret == 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
5321 ok(optval == 4, "FIONREAD should have returned 4 bytes, got %d instead\n", optval);
5322
5323 /* trying to read from an OOB inlined socket with MSG_OOB results in WSAEINVAL */
5324 set_blocking(dst, FALSE);
5325 i = MSG_OOB;
5326 SetLastError(0xdeadbeef);
5327 ret = recv(dst, &data, 1, i);
5328 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
5329 ret = GetLastError();
5330 ok(ret == WSAEWOULDBLOCK, "expected 10035, got %d\n", ret);
5331 bufs.len = sizeof(char);
5332 bufs.buf = &data;
5333 ret = WSARecv(dst, &bufs, 1, &bytes_rec, &i, NULL, NULL);
5334 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
5335 ret = GetLastError();
5336 ok(ret == WSAEWOULDBLOCK, "expected 10035, got %d\n", ret);
5337 optval = 1;
5338 ret = setsockopt(dst, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
5339 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
5340 i = MSG_OOB;
5341 SetLastError(0xdeadbeef);
5342 ret = recv(dst, &data, 1, i);
5343 ok(ret == SOCKET_ERROR, "expected SOCKET_ERROR, got %d\n", ret);
5344 ret = GetLastError();
5345 ok(ret == WSAEINVAL, "expected 10022, got %d\n", ret);
5346 bufs.len = sizeof(char);
5347 bufs.buf = &data;
5348 ret = WSARecv(dst, &bufs, 1, &bytes_rec, &i, NULL, NULL);
5349 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
5350 ret = GetLastError();
5351 ok(ret == WSAEINVAL, "expected 10022, got %d\n", ret);
5352
5353 closesocket(dst);
5354 optval = 0xdeadbeef;
5355 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
5356 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5357 ok(optval == 0xdeadbeef, "FIONREAD should not have changed last error, got %d instead\n", optval);
5358 closesocket(src);
5359 }
5360
5361 static BOOL drain_pause = FALSE;
5362 static DWORD WINAPI drain_socket_thread(LPVOID arg)
5363 {
5364 char buffer[1024];
5365 SOCKET sock = *(SOCKET*)arg;
5366 int ret;
5367
5368 while ((ret = recv(sock, buffer, sizeof(buffer), 0)) != 0)
5369 {
5370 if (ret < 0)
5371 {
5372 if (WSAGetLastError() == WSAEWOULDBLOCK)
5373 {
5374 fd_set readset;
5375 FD_ZERO(&readset);
5376 FD_SET(sock, &readset);
5377 select(sock+1, &readset, NULL, NULL, NULL);
5378 while (drain_pause)
5379 Sleep(100);
5380 }
5381 else
5382 break;
5383 }
5384 }
5385 return 0;
5386 }
5387
5388 static void test_send(void)
5389 {
5390 SOCKET src = INVALID_SOCKET;
5391 SOCKET dst = INVALID_SOCKET;
5392 HANDLE hThread = NULL;
5393 const int buflen = 1024*1024;
5394 char *buffer = NULL;
5395 int ret, i, zero = 0;
5396 WSABUF buf;
5397 OVERLAPPED ov;
5398 BOOL bret;
5399 DWORD id, bytes_sent, dwRet;
5400
5401 memset(&ov, 0, sizeof(ov));
5402
5403 if (tcp_socketpair(&src, &dst) != 0)
5404 {
5405 ok(0, "creating socket pair failed, skipping test\n");
5406 return;
5407 }
5408
5409 set_blocking(dst, FALSE);
5410 /* force disable buffering so we can get a pending overlapped request */
5411 ret = setsockopt(dst, SOL_SOCKET, SO_SNDBUF, (char *) &zero, sizeof(zero));
5412 ok(!ret, "setsockopt SO_SNDBUF failed: %d - %d\n", ret, GetLastError());
5413
5414 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
5415 if (hThread == NULL)
5416 {
5417 ok(0, "CreateThread failed, error %d\n", GetLastError());
5418 goto end;
5419 }
5420
5421 buffer = HeapAlloc(GetProcessHeap(), 0, buflen);
5422 if (buffer == NULL)
5423 {
5424 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
5425 goto end;
5426 }
5427
5428 /* fill the buffer with some nonsense */
5429 for (i = 0; i < buflen; ++i)
5430 {
5431 buffer[i] = (char) i;
5432 }
5433
5434 ret = send(src, buffer, buflen, 0);
5435 if (ret >= 0)
5436 ok(ret == buflen, "send should have sent %d bytes, but it only sent %d\n", buflen, ret);
5437 else
5438 ok(0, "send failed, error %d\n", WSAGetLastError());
5439
5440 buf.buf = buffer;
5441 buf.len = buflen;
5442
5443 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5444 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
5445 if (!ov.hEvent)
5446 goto end;
5447
5448 bytes_sent = 0;
5449 WSASetLastError(12345);
5450 ret = WSASend(dst, &buf, 1, &bytes_sent, 0, &ov, NULL);
5451 ok((ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING) || broken(bytes_sent == buflen),
5452 "Failed to start overlapped send %d - %d - %d/%d\n", ret, WSAGetLastError(), bytes_sent, buflen);
5453
5454 /* don't check for completion yet, we may need to drain the buffer while still sending */
5455 set_blocking(src, FALSE);
5456 for (i = 0; i < buflen; ++i)
5457 {
5458 int j = 0;
5459
5460 ret = recv(src, buffer, 1, 0);
5461 while (ret == SOCKET_ERROR && GetLastError() == WSAEWOULDBLOCK && j < 100)
5462 {
5463 j++;
5464 Sleep(50);
5465 ret = recv(src, buffer, 1, 0);
5466 }
5467
5468 ok(ret == 1, "Failed to receive data %d - %d (got %d/%d)\n", ret, GetLastError(), i, buflen);
5469 if (ret != 1)
5470 break;
5471
5472 ok(buffer[0] == (char) i, "Received bad data at position %d\n", i);
5473 }
5474
5475 dwRet = WaitForSingleObject(ov.hEvent, 1000);
5476 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
5477 if (dwRet == WAIT_OBJECT_0)
5478 {
5479 bret = GetOverlappedResult((HANDLE)dst, &ov, &bytes_sent, FALSE);
5480 ok(bret && bytes_sent == buflen,
5481 "Got %d instead of %d (%d - %d)\n", bytes_sent, buflen, bret, GetLastError());
5482 }
5483
5484 WSASetLastError(12345);
5485 ret = WSASend(INVALID_SOCKET, &buf, 1, NULL, 0, &ov, NULL);
5486 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
5487 "WSASend failed %d - %d\n", ret, WSAGetLastError());
5488
5489 WSASetLastError(12345);
5490 ret = WSASend(dst, &buf, 1, NULL, 0, &ov, NULL);
5491 ok(ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING,
5492 "Failed to start overlapped send %d - %d\n", ret, WSAGetLastError());
5493
5494 end:
5495 if (src != INVALID_SOCKET)
5496 closesocket(src);
5497 if (dst != INVALID_SOCKET)
5498 closesocket(dst);
5499 if (hThread != NULL)
5500 {
5501 dwRet = WaitForSingleObject(hThread, 500);
5502 ok(dwRet == WAIT_OBJECT_0, "failed to wait for thread termination: %d\n", GetLastError());
5503 CloseHandle(hThread);
5504 }
5505 if (ov.hEvent)
5506 CloseHandle(ov.hEvent);
5507 HeapFree(GetProcessHeap(), 0, buffer);
5508 }
5509
5510 typedef struct async_message
5511 {
5512 SOCKET socket;
5513 LPARAM lparam;
5514 struct async_message *next;
5515 } async_message;
5516
5517 static struct async_message *messages_received;
5518
5519 #define WM_SOCKET (WM_USER+100)
5520 static LRESULT CALLBACK ws2_test_WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
5521 {
5522 struct async_message *message;
5523
5524 switch (msg)
5525 {
5526 case WM_SOCKET:
5527 message = HeapAlloc(GetProcessHeap(), 0, sizeof(*message));
5528 message->socket = (SOCKET) wparam;
5529 message->lparam = lparam;
5530 message->next = NULL;
5531
5532 if (messages_received)
5533 {
5534 struct async_message *last = messages_received;
5535 while (last->next) last = last->next;
5536 last->next = message;
5537 }
5538 else
5539 messages_received = message;
5540 return 0;
5541 }
5542
5543 return DefWindowProcA(hwnd, msg, wparam, lparam);
5544 }
5545
5546 static void get_event_details(int event, int *bit, char *name)
5547 {
5548 switch (event)
5549 {
5550 case FD_ACCEPT:
5551 if (bit) *bit = FD_ACCEPT_BIT;
5552 if (name) strcpy(name, "FD_ACCEPT");
5553 break;
5554 case FD_CONNECT:
5555 if (bit) *bit = FD_CONNECT_BIT;
5556 if (name) strcpy(name, "FD_CONNECT");
5557 break;
5558 case FD_READ:
5559 if (bit) *bit = FD_READ_BIT;
5560 if (name) strcpy(name, "FD_READ");
5561 break;
5562 case FD_OOB:
5563 if (bit) *bit = FD_OOB_BIT;
5564 if (name) strcpy(name, "FD_OOB");
5565 break;
5566 case FD_WRITE:
5567 if (bit) *bit = FD_WRITE_BIT;
5568 if (name) strcpy(name, "FD_WRITE");
5569 break;
5570 case FD_CLOSE:
5571 if (bit) *bit = FD_CLOSE_BIT;
5572 if (name) strcpy(name, "FD_CLOSE");
5573 break;
5574 default:
5575 if (bit) *bit = -1;
5576 if (name) sprintf(name, "bad%x", event);
5577 }
5578 }
5579
5580 static const char *dbgstr_event_seq(const LPARAM *seq)
5581 {
5582 static char message[1024];
5583 char name[12];
5584 int len = 1;
5585
5586 message[0] = '[';
5587 message[1] = 0;
5588 while (*seq)
5589 {
5590 get_event_details(WSAGETSELECTEVENT(*seq), NULL, name);
5591 len += sprintf(message + len, "%s(%d) ", name, WSAGETSELECTERROR(*seq));
5592 seq++;
5593 }
5594 if (len > 1) len--;
5595 strcpy( message + len, "]" );
5596 return message;
5597 }
5598
5599 static char *dbgstr_event_seq_result(SOCKET s, WSANETWORKEVENTS *netEvents)
5600 {
5601 static char message[1024];
5602 struct async_message *curr = messages_received;
5603 int index, error, bit = 0;
5604 char name[12];
5605 int len = 1;
5606
5607 message[0] = '[';
5608 message[1] = 0;
5609 while (1)
5610 {
5611 if (netEvents)
5612 {
5613 if (bit >= FD_MAX_EVENTS) break;
5614 if ( !(netEvents->lNetworkEvents & (1 << bit)) )
5615 {
5616 bit++;
5617 continue;
5618 }
5619 get_event_details(1 << bit, &index, name);
5620 error = netEvents->iErrorCode[index];
5621 bit++;
5622 }
5623 else
5624 {
5625 if (!curr) break;
5626 if (curr->socket != s)
5627 {
5628 curr = curr->next;
5629 continue;
5630 }
5631 get_event_details(WSAGETSELECTEVENT(curr->lparam), NULL, name);
5632 error = WSAGETSELECTERROR(curr->lparam);
5633 curr = curr->next;
5634 }
5635
5636 len += sprintf(message + len, "%s(%d) ", name, error);
5637 }
5638 if (len > 1) len--;
5639 strcpy( message + len, "]" );
5640 return message;
5641 }
5642
5643 static void flush_events(SOCKET s, HANDLE hEvent)
5644 {
5645 WSANETWORKEVENTS netEvents;
5646 struct async_message *prev = NULL, *curr = messages_received;
5647 int ret;
5648 DWORD dwRet;
5649
5650 if (hEvent != INVALID_HANDLE_VALUE)
5651 {
5652 dwRet = WaitForSingleObject(hEvent, 100);
5653 if (dwRet == WAIT_OBJECT_0)
5654 {
5655 ret = WSAEnumNetworkEvents(s, hEvent, &netEvents);
5656 if (ret)
5657 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
5658 }
5659 }
5660 else
5661 {
5662 while (curr)
5663 {
5664 if (curr->socket == s)
5665 {
5666 if (prev) prev->next = curr->next;
5667 else messages_received = curr->next;
5668
5669 HeapFree(GetProcessHeap(), 0, curr);
5670
5671 if (prev) curr = prev->next;
5672 else curr = messages_received;
5673 }
5674 else
5675 {
5676 prev = curr;
5677 curr = curr->next;
5678 }
5679 }
5680 }
5681 }
5682
5683 static int match_event_sequence(SOCKET s, WSANETWORKEVENTS *netEvents, const LPARAM *seq)
5684 {
5685 int event, index, error, events;
5686 struct async_message *curr;
5687
5688 if (netEvents)
5689 {
5690 events = netEvents->lNetworkEvents;
5691 while (*seq)
5692 {
5693 event = WSAGETSELECTEVENT(*seq);
5694 error = WSAGETSELECTERROR(*seq);
5695 get_event_details(event, &index, NULL);
5696
5697 if (!(events & event) && index != -1)
5698 return 0;
5699 if (events & event && index != -1)
5700 {
5701 if (netEvents->iErrorCode[index] != error)
5702 return 0;
5703 }
5704 events &= ~event;
5705 seq++;
5706 }
5707 if (events)
5708 return 0;
5709 }
5710 else
5711 {
5712 curr = messages_received;
5713 while (curr)
5714 {
5715 if (curr->socket == s)
5716 {
5717 if (!*seq) return 0;
5718 if (*seq != curr->lparam) return 0;
5719 seq++;
5720 }
5721 curr = curr->next;
5722 }
5723 if (*seq)
5724 return 0;
5725 }
5726 return 1;
5727 }
5728
5729 /* checks for a sequence of events, (order only checked if window is used) */
5730 static void ok_event_sequence(SOCKET s, HANDLE hEvent, const LPARAM *seq, const LPARAM **broken_seqs, int completelyBroken)
5731 {
5732 MSG msg;
5733 WSANETWORKEVENTS events, *netEvents = NULL;
5734 int ret;
5735 DWORD dwRet;
5736
5737 if (hEvent != INVALID_HANDLE_VALUE)
5738 {
5739 netEvents = &events;
5740
5741 dwRet = WaitForSingleObject(hEvent, 200);
5742 if (dwRet == WAIT_OBJECT_0)
5743 {
5744 ret = WSAEnumNetworkEvents(s, hEvent, netEvents);
5745 if (ret)
5746 {
5747 winetest_ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
5748 return;
5749 }
5750 }
5751 else
5752 memset(netEvents, 0, sizeof(*netEvents));
5753 }
5754 else
5755 {
5756 Sleep(200);
5757 /* Run the message loop a little */
5758 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
5759 {
5760 DispatchMessageA(&msg);
5761 }
5762 }
5763
5764 if (match_event_sequence(s, netEvents, seq))
5765 {
5766 winetest_ok(1, "Sequence matches expected: %s\n", dbgstr_event_seq(seq));
5767 flush_events(s, hEvent);
5768 return;
5769 }
5770
5771 if (broken_seqs)
5772 {
5773 for (; *broken_seqs; broken_seqs++)
5774 {
5775 if (match_event_sequence(s, netEvents, *broken_seqs))
5776 {
5777 winetest_ok(broken(1), "Sequence matches broken: %s, expected %s\n", dbgstr_event_seq_result(s, netEvents), dbgstr_event_seq(seq));
5778 flush_events(s, hEvent);
5779 return;
5780 }
5781 }
5782 }
5783
5784 winetest_ok(broken(completelyBroken), "Expected event sequence %s, got %s\n", dbgstr_event_seq(seq),
5785 dbgstr_event_seq_result(s, netEvents));
5786 flush_events(s, hEvent);
5787 }
5788
5789 #define ok_event_seq (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : ok_event_sequence
5790
5791 static void test_events(int useMessages)
5792 {
5793 SOCKET server = INVALID_SOCKET;
5794 SOCKET src = INVALID_SOCKET, src2 = INVALID_SOCKET;
5795 SOCKET dst = INVALID_SOCKET, dst2 = INVALID_SOCKET;
5796 struct sockaddr_in addr;
5797 HANDLE hThread = NULL;
5798 HANDLE hEvent = INVALID_HANDLE_VALUE, hEvent2 = INVALID_HANDLE_VALUE;
5799 WNDCLASSEXA wndclass;
5800 HWND hWnd = NULL;
5801 char *buffer = NULL;
5802 int bufferSize = 1024*1024;
5803 WSABUF bufs;
5804 OVERLAPPED ov, ov2;
5805 DWORD flags = 0;
5806 DWORD bytesReturned;
5807 DWORD id;
5808 int len;
5809 int ret;
5810 DWORD dwRet;
5811 BOOL bret;
5812 static char szClassName[] = "wstestclass";
5813 const LPARAM *broken_seq[3];
5814 static const LPARAM empty_seq[] = { 0 };
5815 static const LPARAM close_seq[] = { WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
5816 static const LPARAM write_seq[] = { WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5817 static const LPARAM read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0), 0 };
5818 static const LPARAM oob_seq[] = { WSAMAKESELECTREPLY(FD_OOB, 0), 0 };
5819 static const LPARAM connect_seq[] = { WSAMAKESELECTREPLY(FD_CONNECT, 0),
5820 WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5821 static const LPARAM read_read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5822 WSAMAKESELECTREPLY(FD_READ, 0), 0 };
5823 static const LPARAM read_write_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5824 WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5825 static const LPARAM read_close_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5826 WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
5827
5828 memset(&ov, 0, sizeof(ov));
5829 memset(&ov2, 0, sizeof(ov2));
5830
5831 /* don't use socketpair, we want connection event */
5832 src = socket(AF_INET, SOCK_STREAM, 0);
5833 if (src == INVALID_SOCKET)
5834 {
5835 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5836 goto end;
5837 }
5838
5839 ret = set_blocking(src, TRUE);
5840 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5841
5842 src2 = socket(AF_INET, SOCK_STREAM, 0);
5843 if (src2 == INVALID_SOCKET)
5844 {
5845 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5846 goto end;
5847 }
5848
5849 ret = set_blocking(src2, TRUE);
5850 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5851
5852 len = sizeof(BOOL);
5853 if (getsockopt(src, SOL_SOCKET, SO_OOBINLINE, (void *)&bret, &len) == SOCKET_ERROR)
5854 {
5855 ok(0, "failed to get oobinline status, %d\n", GetLastError());
5856 goto end;
5857 }
5858 ok(bret == FALSE, "OOB not inline\n");
5859
5860 if (useMessages)
5861 {
5862 trace("Event test using messages\n");
5863
5864 wndclass.cbSize = sizeof(wndclass);
5865 wndclass.style = CS_HREDRAW | CS_VREDRAW;
5866 wndclass.lpfnWndProc = ws2_test_WndProc;
5867 wndclass.cbClsExtra = 0;
5868 wndclass.cbWndExtra = 0;
5869 wndclass.hInstance = GetModuleHandleA(NULL);
5870 wndclass.hIcon = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
5871 wndclass.hIconSm = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
5872 wndclass.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
5873 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
5874 wndclass.lpszClassName = szClassName;
5875 wndclass.lpszMenuName = NULL;
5876 RegisterClassExA(&wndclass);
5877
5878 hWnd = CreateWindowA(szClassName, "WS2Test", WS_OVERLAPPEDWINDOW,
5879 0, 0, 500, 500, NULL, NULL, GetModuleHandleA(NULL), NULL);
5880 if (!hWnd)
5881 {
5882 ok(0, "failed to create window: %d\n", GetLastError());
5883 return;
5884 }
5885
5886 ret = WSAAsyncSelect(src, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5887 if (ret)
5888 {
5889 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5890 goto end;
5891 }
5892
5893 ok(set_blocking(src, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5894 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5895
5896 ret = WSAAsyncSelect(src2, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5897 if (ret)
5898 {
5899 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5900 goto end;
5901 }
5902
5903 ok(set_blocking(src2, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5904 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5905 }
5906 else
5907 {
5908 trace("Event test using events\n");
5909
5910 hEvent = WSACreateEvent();
5911 if (hEvent == INVALID_HANDLE_VALUE)
5912 {
5913 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5914 goto end;
5915 }
5916
5917 hEvent2 = WSACreateEvent();
5918 if (hEvent2 == INVALID_HANDLE_VALUE)
5919 {
5920 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5921 goto end;
5922 }
5923
5924 ret = WSAEventSelect(src, hEvent, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5925 if (ret)
5926 {
5927 ok(0, "WSAEventSelect failed, error %d\n", ret);
5928 goto end;
5929 }
5930
5931 ok(set_blocking(src, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5932 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5933
5934 ret = WSAEventSelect(src2, hEvent2, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5935 if (ret)
5936 {
5937 ok(0, "WSAEventSelect failed, error %d\n", ret);
5938 goto end;
5939 }
5940
5941 ok(set_blocking(src2, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5942 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5943 }
5944
5945 server = socket(AF_INET, SOCK_STREAM, 0);
5946 if (server == INVALID_SOCKET)
5947 {
5948 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5949 goto end;
5950 }
5951
5952 memset(&addr, 0, sizeof(addr));
5953 addr.sin_family = AF_INET;
5954 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
5955 ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
5956 if (ret != 0)
5957 {
5958 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5959 goto end;
5960 }
5961
5962 len = sizeof(addr);
5963 ret = getsockname(server, (struct sockaddr*)&addr, &len);
5964 if (ret != 0)
5965 {
5966 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5967 goto end;
5968 }
5969
5970 ret = listen(server, 2);
5971 if (ret != 0)
5972 {
5973 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5974 goto end;
5975 }
5976
5977 SetLastError(0xdeadbeef);
5978 ret = connect(src, NULL, 0);
5979 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
5980 ok(GetLastError() == WSAEFAULT, "expected 10014, got %d\n", GetLastError());
5981
5982 ret = connect(src, (struct sockaddr*)&addr, sizeof(addr));
5983 if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
5984 {
5985 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5986 goto end;
5987 }
5988
5989 ret = connect(src2, (struct sockaddr*)&addr, sizeof(addr));
5990 if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
5991 {
5992 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5993 goto end;
5994 }
5995
5996 len = sizeof(addr);
5997 dst = accept(server, (struct sockaddr*)&addr, &len);
5998 if (dst == INVALID_SOCKET)
5999 {
6000 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
6001 goto end;
6002 }
6003
6004 len = sizeof(addr);
6005 dst2 = accept(server, (struct sockaddr*)&addr, &len);
6006 if (dst2 == INVALID_SOCKET)
6007 {
6008 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
6009 goto end;
6010 }
6011
6012 closesocket(server);
6013 server = INVALID_SOCKET;
6014
6015 /* On Windows it seems when a non-blocking socket sends to a
6016 blocking socket on the same host, the send() is BLOCKING,
6017 so make both sockets non-blocking. src is already non-blocking
6018 from the async select */
6019
6020 if (set_blocking(dst, FALSE))
6021 {
6022 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
6023 goto end;
6024 }
6025
6026 buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bufferSize);
6027 if (buffer == NULL)
6028 {
6029 ok(0, "could not allocate memory for test\n");
6030 goto end;
6031 }
6032
6033 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
6034 if (ov.hEvent == NULL)
6035 {
6036 ok(0, "could not create event object, errno = %d\n", GetLastError());
6037 goto end;
6038 }
6039
6040 ov2.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
6041 if (ov2.hEvent == NULL)
6042 {
6043 ok(0, "could not create event object, errno = %d\n", GetLastError());
6044 goto end;
6045 }
6046
6047 /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
6048 ok_event_seq(src, hEvent, connect_seq, NULL, 1);
6049 ok_event_seq(src2, hEvent2, connect_seq, NULL, 1);
6050 /* broken on all windows - FD_CONNECT error is garbage */
6051
6052 /* Test simple send/recv */
6053 SetLastError(0xdeadbeef);
6054 ret = send(dst, buffer, 100, 0);
6055 ok(ret == 100, "Failed to send buffer %d err %d\n", ret, GetLastError());
6056 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6057 ok_event_seq(src, hEvent, read_seq, NULL, 0);
6058
6059 SetLastError(0xdeadbeef);
6060 ret = recv(src, buffer, 1, MSG_PEEK);
6061 ok(ret == 1, "Failed to peek at recv buffer %d err %d\n", ret, GetLastError());
6062 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6063 ok_event_seq(src, hEvent, read_seq, NULL, 0);
6064
6065 SetLastError(0xdeadbeef);
6066 ret = recv(src, buffer, 50, 0);
6067 ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
6068 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6069 ok_event_seq(src, hEvent, read_seq, NULL, 0);
6070
6071 ret = recv(src, buffer, 50, 0);
6072 ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
6073 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
6074
6075 /* fun fact - events are re-enabled even on failure, but only for messages */
6076 ret = send(dst, "1", 1, 0);
6077 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
6078 ok_event_seq(src, hEvent, read_seq, NULL, 0);
6079
6080 ret = recv(src, buffer, -1, 0);
6081 ok(ret == SOCKET_ERROR && (GetLastError() == WSAEFAULT || GetLastError() == WSAENOBUFS),
6082 "Failed to recv buffer %d err %d\n", ret, GetLastError());
6083 if (useMessages)
6084 {
6085 broken_seq[0] = empty_seq; /* win9x */
6086 broken_seq[1] = NULL;
6087 todo_wine ok_event_seq(src, hEvent, read_seq, broken_seq, 0);
6088 }
6089 else
6090 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
6091
6092 SetLastError(0xdeadbeef);
6093 ret = recv(src, buffer, 1, 0);
6094 ok(ret == 1, "Failed to recv buffer %d err %d\n", ret, GetLastError());
6095 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6096 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
6097
6098 /* Interaction with overlapped */
6099 bufs.len = sizeof(char);
6100 bufs.buf = buffer;
6101 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
6102 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
6103 "WSARecv failed - %d error %d\n", ret, GetLastError());
6104
6105 bufs.len = sizeof(char);
6106 bufs.buf = buffer+1;
6107 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov2, NULL);
6108 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
6109 "WSARecv failed - %d error %d\n", ret, GetLastError());
6110
6111 ret = send(dst, "12", 2, 0);
6112 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
6113 broken_seq[0] = read_read_seq; /* win9x */
6114 broken_seq[1] = NULL;
6115 ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
6116
6117 dwRet = WaitForSingleObject(ov.hEvent, 100);
6118 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
6119 if (dwRet == WAIT_OBJECT_0)
6120 {
6121 bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
6122 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
6123 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
6124 ok(buffer[0] == '1', "Got %c instead of 1\n", buffer[0]);
6125 }
6126
6127 dwRet = WaitForSingleObject(ov2.hEvent, 100);
6128 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
6129 if (dwRet == WAIT_OBJECT_0)
6130 {
6131 bret = GetOverlappedResult((HANDLE)src, &ov2, &bytesReturned, FALSE);
6132 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
6133 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
6134 ok(buffer[1] == '2', "Got %c instead of 2\n", buffer[1]);
6135 }
6136
6137 SetLastError(0xdeadbeef);
6138 ret = send(dst, "1", 1, 0);
6139 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
6140 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6141 ok_event_seq(src, hEvent, read_seq, NULL, 0);
6142
6143 ret = recv(src, buffer, 1, 0);
6144 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
6145 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
6146
6147 /* Notifications are delivered as soon as possible, blocked only on
6148 * async requests on the same type */
6149 bufs.len = sizeof(char);
6150 bufs.buf = buffer;
6151 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
6152 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
6153 "WSARecv failed - %d error %d\n", ret, GetLastError());
6154
6155 if (0) {
6156 ret = send(dst, "1", 1, MSG_OOB);
6157 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
6158 ok_event_seq(src, hEvent, oob_seq, NULL, 0);
6159 }
6160
6161 dwRet = WaitForSingleObject(ov.hEvent, 100);
6162 ok(dwRet == WAIT_TIMEOUT, "OOB message activated read?: %d - %d\n", dwRet, GetLastError());
6163
6164 ret = send(dst, "2", 1, 0);
6165 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
6166 broken_seq[0] = read_seq; /* win98 */
6167 broken_seq[1] = NULL;
6168 ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
6169
6170 dwRet = WaitForSingleObject(ov.hEvent, 100);
6171 ok(dwRet == WAIT_OBJECT_0 || broken(dwRet == WAIT_TIMEOUT),
6172 "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
6173 if (dwRet == WAIT_OBJECT_0)
6174 {
6175 bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
6176 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
6177 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
6178 ok(buffer[0] == '2', "Got %c instead of 2\n", buffer[0]);
6179 }
6180
6181 if (0) {
6182 ret = recv(src, buffer, 1, MSG_OOB);
6183 todo_wine ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
6184 /* We get OOB notification, but no data on wine */
6185 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
6186 }
6187
6188 /* Flood the send queue */
6189 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
6190 if (hThread == NULL)
6191 {
6192 ok(0, "CreateThread failed, error %d\n", GetLastError());
6193 goto end;
6194 }
6195
6196 /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
6197 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
6198
6199 /* Now if we send a ton of data and the 'server' does not drain it fast
6200 * enough (set drain_pause to be sure), the socket send buffer will only
6201 * take some of it, and we will get a short write. This will trigger
6202 * another FD_WRITE event as soon as data is sent and more space becomes
6203 * available, but not any earlier. */
6204 drain_pause = TRUE;
6205 do
6206 {
6207 ret = send(src, buffer, bufferSize, 0);
6208 } while (ret == bufferSize);
6209 drain_pause = FALSE;
6210 if (ret >= 0 || WSAGetLastError() == WSAEWOULDBLOCK)
6211 {
6212 Sleep(400); /* win9x */
6213 broken_seq[0] = read_write_seq;
6214 broken_seq[1] = NULL;
6215 ok_event_seq(src, hEvent, write_seq, broken_seq, 0);
6216 }
6217 else
6218 {
6219 ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
6220 }
6221
6222 /* Test how FD_CLOSE is handled */
6223 ret = send(dst, "12", 2, 0);
6224 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
6225
6226 /* Wait a little and let the send complete */
6227 Sleep(100);
6228 closesocket(dst);
6229 dst = INVALID_SOCKET;
6230 Sleep(100);
6231
6232 /* We can never implement this in wine, best we can hope for is
6233 sending FD_CLOSE after the reads complete */
6234 broken_seq[0] = read_seq; /* win9x */
6235 broken_seq[1] = NULL;
6236 todo_wine ok_event_seq(src, hEvent, read_close_seq, broken_seq, 0);
6237
6238 ret = recv(src, buffer, 1, 0);
6239 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
6240 ok_event_seq(src, hEvent, read_seq, NULL, 0);
6241
6242 ret = recv(src, buffer, 1, 0);
6243 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
6244 /* want it? it's here, but you can't have it */
6245 broken_seq[0] = close_seq; /* win9x */
6246 broken_seq[1] = NULL;
6247 todo_wine ok_event_seq(src, hEvent, empty_seq, /* wine sends FD_CLOSE here */
6248 broken_seq, 0);
6249
6250 /* Test how FD_CLOSE is handled */
6251 ret = send(dst2, "12", 2, 0);
6252 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
6253
6254 Sleep(200);
6255 shutdown(dst2, SD_SEND);
6256 Sleep(200);
6257
6258 /* Some of the below are technically todo_wine, but our event sequence is still valid, so to prevent
6259 regressions, don't mark them as todo_wine, and mark windows as broken */
6260 broken_seq[0] = read_close_seq;
6261 broken_seq[1] = close_seq;
6262 broken_seq[2] = NULL;
6263 ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
6264
6265 ret = recv(src2, buffer, 1, 0);
6266 ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
6267 broken_seq[0] = close_seq; /* win98 */
6268 broken_seq[1] = NULL;
6269 ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
6270
6271 ret = recv(src2, buffer, 1, 0);
6272 ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
6273 broken_seq[0] = empty_seq;
6274 broken_seq[1] = NULL;
6275 ok_event_seq(src2, hEvent2, close_seq, broken_seq, 0);
6276
6277 ret = send(src2, "1", 1, 0);
6278 ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
6279 ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
6280
6281 ret = send(src2, "1", 1, 0);
6282 ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
6283 ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
6284
6285 if (useMessages)
6286 {
6287 ret = WSAAsyncSelect(src, hWnd, WM_SOCKET, 0);
6288 if (ret)
6289 {
6290 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
6291 goto end;
6292 }
6293
6294 ret = set_blocking(src, TRUE);
6295 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
6296
6297 ret = WSAAsyncSelect(src2, hWnd, WM_SOCKET, 0);
6298 if (ret)
6299 {
6300 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
6301 goto end;
6302 }
6303
6304 ret = set_blocking(src2, TRUE);
6305 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
6306 }
6307 else
6308 {
6309 ret = WSAEventSelect(src, hEvent2, 0);
6310 if (ret)
6311 {
6312 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
6313 goto end;
6314 }
6315
6316 ret = set_blocking(src, TRUE);
6317 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
6318
6319 ret = WSAEventSelect(src2, hEvent2, 0);
6320 if (ret)
6321 {
6322 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
6323 goto end;
6324 }
6325
6326 ret = set_blocking(src2, TRUE);
6327 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
6328 }
6329
6330 end:
6331 if (src != INVALID_SOCKET)
6332 {
6333 flush_events(src, hEvent);
6334 closesocket(src);
6335 }
6336 if (src2 != INVALID_SOCKET)
6337 {
6338 flush_events(src2, hEvent2);
6339 closesocket(src2);
6340 }
6341 HeapFree(GetProcessHeap(), 0, buffer);
6342 if (server != INVALID_SOCKET)
6343 closesocket(server);
6344 if (dst != INVALID_SOCKET)
6345 closesocket(dst);
6346 if (dst2 != INVALID_SOCKET)
6347 closesocket(dst2);
6348 if (hThread != NULL)
6349 CloseHandle(hThread);
6350 if (hWnd != NULL)
6351 DestroyWindow(hWnd);
6352 if (hEvent != NULL)
6353 CloseHandle(hEvent);
6354 if (hEvent2 != NULL)
6355 CloseHandle(hEvent2);
6356 if (ov.hEvent != NULL)
6357 CloseHandle(ov.hEvent);
6358 if (ov2.hEvent != NULL)
6359 CloseHandle(ov2.hEvent);
6360 }
6361
6362 static void test_ipv6only(void)
6363 {
6364 SOCKET v4 = INVALID_SOCKET, v6;
6365 struct sockaddr_in sin4;
6366 struct sockaddr_in6 sin6;
6367 int ret, enabled, len = sizeof(enabled);
6368
6369 memset(&sin4, 0, sizeof(sin4));
6370 sin4.sin_family = AF_INET;
6371 sin4.sin_port = htons(SERVERPORT);
6372
6373 memset(&sin6, 0, sizeof(sin6));
6374 sin6.sin6_family = AF_INET6;
6375 sin6.sin6_port = htons(SERVERPORT);
6376
6377 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
6378 if (v6 == INVALID_SOCKET)
6379 {
6380 skip("Could not create IPv6 socket (LastError: %d)\n", WSAGetLastError());
6381 goto end;
6382 }
6383
6384 enabled = 2;
6385 ret = getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
6386 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6387 ok(enabled == 1, "expected 1, got %d\n", enabled);
6388
6389 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
6390 if (ret)
6391 {
6392 skip("Could not bind IPv6 address (LastError: %d)\n", WSAGetLastError());
6393 goto end;
6394 }
6395
6396 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6397 ok(v4 != INVALID_SOCKET, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
6398
6399 todo_wine {
6400 enabled = 2;
6401 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
6402 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6403 ok(enabled == 1, "expected 1, got %d\n", enabled);
6404 }
6405
6406 enabled = 0;
6407 len = sizeof(enabled);
6408 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
6409 ok(!ret, "setsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6410
6411 todo_wine {
6412 enabled = 2;
6413 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
6414 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6415 ok(!enabled, "expected 0, got %d\n", enabled);
6416 }
6417
6418 enabled = 1;
6419 len = sizeof(enabled);
6420 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
6421 ok(!ret, "setsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6422
6423 /* bind on IPv4 socket should succeed - IPV6_V6ONLY is enabled by default */
6424 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
6425 ok(!ret, "Could not bind IPv4 address (LastError: %d)\n", WSAGetLastError());
6426
6427 todo_wine {
6428 enabled = 2;
6429 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
6430 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6431 ok(enabled == 1, "expected 1, got %d\n", enabled);
6432 }
6433
6434 enabled = 0;
6435 len = sizeof(enabled);
6436 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
6437 ok(ret, "setsockopt(IPV6_ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
6438
6439 todo_wine {
6440 enabled = 0;
6441 ret = getsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
6442 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6443 ok(enabled == 1, "expected 1, got %d\n", enabled);
6444 }
6445
6446 enabled = 1;
6447 len = sizeof(enabled);
6448 ret = setsockopt(v4, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
6449 ok(ret, "setsockopt(IPV6_ONLY) succeeded (LastError: %d)\n", WSAGetLastError());
6450
6451 closesocket(v4);
6452 closesocket(v6);
6453
6454 /* Test again, this time disabling IPV6_V6ONLY. */
6455 sin4.sin_port = htons(SERVERPORT+2);
6456 sin6.sin6_port = htons(SERVERPORT+2);
6457
6458 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
6459 ok(v6 != INVALID_SOCKET, "Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
6460 WSAGetLastError(), WSAEAFNOSUPPORT);
6461
6462 enabled = 0;
6463 ret = setsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, len);
6464 ok(!ret, "Could not disable IPV6_V6ONLY (LastError: %d).\n", WSAGetLastError());
6465
6466 enabled = 2;
6467 ret = getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
6468 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6469 ok(!enabled, "expected 0, got %d\n", enabled);
6470
6471 /*
6472 Observaition:
6473 On Windows, bind on both IPv4 and IPv6 with IPV6_V6ONLY disabled succeeds by default.
6474 Application must set SO_EXCLUSIVEADDRUSE on first socket to disallow another successful bind.
6475 In general, a standard application should not use SO_REUSEADDR.
6476 Setting both SO_EXCLUSIVEADDRUSE and SO_REUSEADDR on the same socket is not possible in
6477 either order, the later setsockopt call always fails.
6478 */
6479 enabled = 1;
6480 ret = setsockopt(v6, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&enabled, len);
6481 ok(!ret, "Could not set SO_EXCLUSIVEADDRUSE on IPv6 socket (LastError: %d)\n", WSAGetLastError());
6482
6483 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
6484 ok(!ret, "Could not bind IPv6 address (LastError: %d)\n", WSAGetLastError());
6485
6486 enabled = 2;
6487 len = sizeof(enabled);
6488 getsockopt(v6, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&enabled, &len);
6489 ok(!ret, "getsockopt(IPV6_ONLY) failed (LastError: %d)\n", WSAGetLastError());
6490 ok(!enabled, "IPV6_V6ONLY is enabled after bind\n");
6491
6492 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6493 ok(v4 != INVALID_SOCKET, "Could not create IPv4 socket (LastError: %d)\n", WSAGetLastError());
6494
6495 enabled = 1;
6496 ret = setsockopt(v4, SOL_SOCKET, SO_REUSEADDR, (char*)&enabled, len);
6497 ok(!ret, "Could not set SO_REUSEADDR on IPv4 socket (LastError: %d)\n", WSAGetLastError());
6498
6499 WSASetLastError(0xdeadbeef);
6500 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
6501 ok(ret, "bind succeeded unexpectedly for the IPv4 socket\n");
6502 ok(WSAGetLastError() == WSAEACCES, "Expected 10013, got %d\n", WSAGetLastError());
6503
6504 end:
6505 if (v4 != INVALID_SOCKET)
6506 closesocket(v4);
6507 if (v6 != INVALID_SOCKET)
6508 closesocket(v6);
6509 }
6510
6511 static void test_WSASendMsg(void)
6512 {
6513 SOCKET sock, dst;
6514 struct sockaddr_in sendaddr, sockaddr;
6515 GUID WSASendMsg_GUID = WSAID_WSASENDMSG;
6516 LPFN_WSASENDMSG pWSASendMsg = NULL;
6517 char teststr[12] = "hello world", buffer[32];
6518 WSABUF iovec[2];
6519 WSAMSG msg;
6520 DWORD bytesSent, err;
6521 int ret, addrlen;
6522
6523 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
6524
6525 sock = socket(AF_INET, SOCK_DGRAM, 0);
6526 ok(sock != INVALID_SOCKET, "socket() failed\n");
6527
6528 /* Obtain the WSASendMsg function */
6529 WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSASendMsg_GUID, sizeof(WSASendMsg_GUID),
6530 &pWSASendMsg, sizeof(pWSASendMsg), &err, NULL, NULL);
6531 if (!pWSASendMsg)
6532 {
6533 closesocket(sock);
6534 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
6535 return;
6536 }
6537
6538 /* fake address for now */
6539 sendaddr.sin_family = AF_INET;
6540 sendaddr.sin_port = htons(139);
6541 sendaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6542
6543 memset(&msg, 0, sizeof(msg));
6544 iovec[0].buf = teststr;
6545 iovec[0].len = sizeof(teststr);
6546 iovec[1].buf = teststr;
6547 iovec[1].len = sizeof(teststr) / 2;
6548 msg.name = (struct sockaddr *) &sendaddr;
6549 msg.namelen = sizeof(sendaddr);
6550 msg.lpBuffers = iovec;
6551 msg.dwBufferCount = 1; /* send only one buffer for now */
6552
6553 WSASetLastError(0xdeadbeef);
6554 ret = pWSASendMsg(INVALID_SOCKET, &msg, 0, NULL, NULL, NULL);
6555 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6556 err = WSAGetLastError();
6557 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
6558
6559 WSASetLastError(0xdeadbeef);
6560 ret = pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL);
6561 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6562 err = WSAGetLastError();
6563 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
6564
6565 WSASetLastError(0xdeadbeef);
6566 ret = pWSASendMsg(sock, NULL, 0, &bytesSent, NULL, NULL);
6567 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6568 err = WSAGetLastError();
6569 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
6570
6571 WSASetLastError(0xdeadbeef);
6572 ret = pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL);
6573 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6574 err = WSAGetLastError();
6575 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
6576
6577 closesocket(sock);
6578
6579 sock = socket(AF_INET, SOCK_DGRAM, 0);
6580 ok(sock != INVALID_SOCKET, "socket() failed\n");
6581
6582 dst = socket(AF_INET, SOCK_DGRAM, 0);
6583 ok(dst != INVALID_SOCKET, "socket() failed\n");
6584
6585 memset(&sockaddr, 0, sizeof(sockaddr));
6586 sockaddr.sin_family = AF_INET;
6587 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6588 ok(!bind(dst, (struct sockaddr*)&sockaddr, sizeof(sockaddr)),
6589 "bind should have worked\n");
6590
6591 /* read address to find out the port number to be used in send */
6592 memset(&sendaddr, 0, sizeof(sendaddr));
6593 addrlen = sizeof(sendaddr);
6594 ok(!getsockname(dst, (struct sockaddr *) &sendaddr, &addrlen),
6595 "getsockname should have worked\n");
6596 ok(sendaddr.sin_port, "socket port should be != 0\n");
6597
6598 /* ensure the sending socket is not bound */
6599 WSASetLastError(0xdeadbeef);
6600 addrlen = sizeof(sockaddr);
6601 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
6602 ok(ret == SOCKET_ERROR, "getsockname should have failed\n");
6603 err = WSAGetLastError();
6604 ok(err == WSAEINVAL, "expected 10022, got %d instead\n", err);
6605
6606 set_blocking(sock, TRUE);
6607
6608 bytesSent = 0;
6609 SetLastError(0xdeadbeef);
6610 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
6611 ok(!ret, "WSASendMsg should have worked\n");
6612 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
6613 "Expected 0, got %d\n", GetLastError());
6614 ok(bytesSent == iovec[0].len, "incorret bytes sent, expected %d, sent %d\n",
6615 iovec[0].len, bytesSent);
6616
6617 /* receive data */
6618 addrlen = sizeof(sockaddr);
6619 memset(buffer, 0, sizeof(buffer));
6620 SetLastError(0xdeadbeef);
6621 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
6622 ok(ret == bytesSent, "got %d, expected %d\n",
6623 ret, bytesSent);
6624 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6625
6626 /* A successful call to WSASendMsg must have bound the socket */
6627 addrlen = sizeof(sockaddr);
6628 sockaddr.sin_port = 0;
6629 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6630 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
6631 ok(!ret, "getsockname should have worked\n");
6632 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
6633 inet_ntoa(sockaddr.sin_addr));
6634 ok(sockaddr.sin_port, "sin_port should be != 0\n");
6635
6636 msg.dwBufferCount = 2; /* send both buffers */
6637
6638 bytesSent = 0;
6639 SetLastError(0xdeadbeef);
6640 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
6641 ok(!ret, "WSASendMsg should have worked\n");
6642 ok(bytesSent == iovec[0].len + iovec[1].len, "incorret bytes sent, expected %d, sent %d\n",
6643 iovec[0].len + iovec[1].len, bytesSent);
6644 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
6645 "Expected 0, got %d\n", GetLastError());
6646
6647 /* receive data */
6648 addrlen = sizeof(sockaddr);
6649 memset(buffer, 0, sizeof(buffer));
6650 SetLastError(0xdeadbeef);
6651 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
6652 ok(ret == bytesSent, "got %d, expected %d\n",
6653 ret, bytesSent);
6654 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6655
6656 closesocket(sock);
6657 closesocket(dst);
6658
6659 /* a bad call to WSASendMsg will also bind the socket */
6660 addrlen = sizeof(sockaddr);
6661 sockaddr.sin_port = 0;
6662 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6663 sock = socket(AF_INET, SOCK_DGRAM, 0);
6664 ok(sock != INVALID_SOCKET, "socket() failed\n");
6665 ok(pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
6666 todo_wine {
6667 ok(!getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have worked\n");
6668 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
6669 inet_ntoa(sockaddr.sin_addr));
6670 ok(sockaddr.sin_port, "sin_port should be > 0\n");
6671 }
6672 closesocket(sock);
6673
6674 /* a bad call without msg parameter will not trigger the auto-bind */
6675 sock = socket(AF_INET, SOCK_DGRAM, 0);
6676 ok(sock != INVALID_SOCKET, "socket() failed\n");
6677 ok(pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
6678 ok(getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have failed\n");
6679 err = WSAGetLastError();
6680 ok(err == WSAEINVAL, "expected 10022, got %d instead\n", err);
6681 closesocket(sock);
6682
6683 /* SOCK_STREAM sockets are not supported */
6684 bytesSent = 0;
6685 sock = socket(AF_INET, SOCK_STREAM, 0);
6686 ok(sock != INVALID_SOCKET, "socket() failed\n");
6687 SetLastError(0xdeadbeef);
6688 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
6689 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6690 err = WSAGetLastError();
6691 todo_wine
6692 ok(err == WSAEINVAL, "expected 10014, got %d instead\n", err);
6693 closesocket(sock);
6694 }
6695
6696 static void test_WSASendTo(void)
6697 {
6698 SOCKET s;
6699 struct sockaddr_in addr;
6700 char buf[12] = "hello world";
6701 WSABUF data_buf;
6702 DWORD bytesSent;
6703 int ret;
6704
6705 addr.sin_family = AF_INET;
6706 addr.sin_port = htons(139);
6707 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
6708 data_buf.len = sizeof(buf);
6709 data_buf.buf = buf;
6710
6711 if( (s = socket(AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET) {
6712 ok(0, "socket() failed error: %d\n", WSAGetLastError());
6713 return;
6714 }
6715
6716 WSASetLastError(12345);
6717 ret = WSASendTo(INVALID_SOCKET, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
6718 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
6719 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
6720
6721 WSASetLastError(12345);
6722 ret = WSASendTo(s, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
6723 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
6724 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
6725
6726 WSASetLastError(12345);
6727 if(WSASendTo(s, &data_buf, 1, &bytesSent, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL)) {
6728 ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
6729 return;
6730 }
6731 ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
6732 "a successful call to WSASendTo()\n");
6733 }
6734
6735 static DWORD WINAPI recv_thread(LPVOID arg)
6736 {
6737 SOCKET sock = *(SOCKET *)arg;
6738 char buffer[32];
6739 WSABUF wsa;
6740 WSAOVERLAPPED ov;
6741 DWORD flags = 0;
6742
6743 wsa.buf = buffer;
6744 wsa.len = sizeof(buffer);
6745 ov.hEvent = WSACreateEvent();
6746 WSARecv(sock, &wsa, 1, NULL, &flags, &ov, NULL);
6747
6748 WaitForSingleObject(ov.hEvent, 1000);
6749 WSACloseEvent(ov.hEvent);
6750 return 0;
6751 }
6752
6753 static int completion_called;
6754
6755 static void WINAPI io_completion(DWORD error, DWORD transferred, WSAOVERLAPPED *overlapped, DWORD flags)
6756 {
6757 completion_called++;
6758 }
6759
6760 static void test_WSARecv(void)
6761 {
6762 SOCKET src, dest, server = INVALID_SOCKET;
6763 char buf[20];
6764 WSABUF bufs[2];
6765 WSAOVERLAPPED ov;
6766 DWORD bytesReturned, flags, id;
6767 struct linger ling;
6768 struct sockaddr_in addr;
6769 int iret, len;
6770 DWORD dwret;
6771 BOOL bret;
6772 HANDLE thread, event = NULL, io_port;
6773
6774 tcp_socketpair(&src, &dest);
6775 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
6776 {
6777 skip("failed to create sockets\n");
6778 goto end;
6779 }
6780
6781 memset(&ov, 0, sizeof(ov));
6782 flags = 0;
6783 bufs[0].len = 2;
6784 bufs[0].buf = buf;
6785
6786 /* Send 4 bytes and receive in two calls of 2 */
6787 SetLastError(0xdeadbeef);
6788 iret = send(src, "test", 4, 0);
6789 ok(iret == 4, "Expected 4, got %d\n", iret);
6790 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6791 SetLastError(0xdeadbeef);
6792 bytesReturned = 0xdeadbeef;
6793 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
6794 ok(!iret, "Expected 0, got %d\n", iret);
6795 ok(bytesReturned == 2, "Expected 2, got %d\n", bytesReturned);
6796 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6797 SetLastError(0xdeadbeef);
6798 bytesReturned = 0xdeadbeef;
6799 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
6800 ok(!iret, "Expected 0, got %d\n", iret);
6801 ok(bytesReturned == 2, "Expected 2, got %d\n", bytesReturned);
6802 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6803
6804 bufs[0].len = 4;
6805 SetLastError(0xdeadbeef);
6806 iret = send(src, "test", 4, 0);
6807 ok(iret == 4, "Expected 4, got %d\n", iret);
6808 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6809 SetLastError(0xdeadbeef);
6810 bytesReturned = 0xdeadbeef;
6811 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, NULL, NULL);
6812 ok(!iret, "Expected 0, got %d\n", iret);
6813 ok(bytesReturned == 4, "Expected 4, got %d\n", bytesReturned);
6814 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6815
6816 /* Test 2 buffers */
6817 bufs[0].len = 4;
6818 bufs[1].len = 5;
6819 bufs[1].buf = buf + 10;
6820 SetLastError(0xdeadbeef);
6821 iret = send(src, "deadbeefs", 9, 0);
6822 ok(iret == 9, "Expected 9, got %d\n", iret);
6823 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6824 SetLastError(0xdeadbeef);
6825 bytesReturned = 0xdeadbeef;
6826 iret = WSARecv(dest, bufs, 2, &bytesReturned, &flags, NULL, NULL);
6827 ok(!iret, "Expected 0, got %d\n", iret);
6828 ok(bytesReturned == 9, "Expected 9, got %d\n", bytesReturned);
6829 bufs[0].buf[4] = '\0';
6830 bufs[1].buf[5] = '\0';
6831 ok(!strcmp(bufs[0].buf, "dead"), "buf[0] doesn't match: %s != dead\n", bufs[0].buf);
6832 ok(!strcmp(bufs[1].buf, "beefs"), "buf[1] doesn't match: %s != beefs\n", bufs[1].buf);
6833 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6834
6835 bufs[0].len = sizeof(buf);
6836 ov.hEvent = event = CreateEventA(NULL, FALSE, FALSE, NULL);
6837 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
6838 if (!event)
6839 goto end;
6840
6841 ling.l_onoff = 1;
6842 ling.l_linger = 0;
6843 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
6844 ok(!iret, "Failed to set linger %d\n", GetLastError());
6845
6846 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, NULL);
6847 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
6848
6849 iret = WSARecv(dest, bufs, 1, &bytesReturned, &flags, &ov, NULL);
6850 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
6851
6852 closesocket(src);
6853 src = INVALID_SOCKET;
6854
6855 dwret = WaitForSingleObject(ov.hEvent, 1000);
6856 ok(dwret == WAIT_OBJECT_0, "Waiting for disconnect event failed with %d + errno %d\n", dwret, GetLastError());
6857
6858 bret = GetOverlappedResult((HANDLE)dest, &ov, &bytesReturned, FALSE);
6859 todo_wine ok(!bret && (GetLastError() == ERROR_NETNAME_DELETED || broken(GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */),
6860 "Did not get disconnect event: %d, error %d\n", bret, GetLastError());
6861 ok(bytesReturned == 0, "Bytes received is %d\n", bytesReturned);
6862 closesocket(dest);
6863 dest = INVALID_SOCKET;
6864
6865 src = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
6866 ok(src != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6867 if (src == INVALID_SOCKET) goto end;
6868
6869 server = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
6870 ok(server != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6871 if (server == INVALID_SOCKET) goto end;
6872
6873 memset(&addr, 0, sizeof(addr));
6874 addr.sin_family = AF_INET;
6875 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
6876 iret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
6877 if (iret) goto end;
6878
6879 len = sizeof(addr);
6880 iret = getsockname(server, (struct sockaddr *)&addr, &len);
6881 if (iret) goto end;
6882
6883 iret = listen(server, 1);
6884 if (iret) goto end;
6885
6886 iret = connect(src, (struct sockaddr *)&addr, sizeof(addr));
6887 if (iret) goto end;
6888
6889 len = sizeof(addr);
6890 dest = accept(server, (struct sockaddr *)&addr, &len);
6891 ok(dest != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6892 if (dest == INVALID_SOCKET) goto end;
6893
6894 send(src, "test message", sizeof("test message"), 0);
6895 thread = CreateThread(NULL, 0, recv_thread, &dest, 0, &id);
6896 WaitForSingleObject(thread, 3000);
6897 CloseHandle(thread);
6898
6899 memset(&ov, 0, sizeof(ov));
6900 ov.hEvent = event;
6901 ResetEvent(event);
6902 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, io_completion);
6903 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
6904 send(src, "test message", sizeof("test message"), 0);
6905
6906 completion_called = 0;
6907 dwret = SleepEx(1000, TRUE);
6908 ok(dwret == WAIT_IO_COMPLETION, "got %u\n", dwret);
6909 ok(completion_called == 1, "completion not called\n");
6910
6911 dwret = WaitForSingleObject(event, 1);
6912 ok(dwret == WAIT_TIMEOUT, "got %u\n", dwret);
6913
6914 io_port = CreateIoCompletionPort( (HANDLE)dest, NULL, 0, 0 );
6915 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
6916
6917 /* Using completion function on socket associated with completion port is not allowed. */
6918 memset(&ov, 0, sizeof(ov));
6919 completion_called = 0;
6920 iret = WSARecv(dest, bufs, 1, NULL, &flags, &ov, io_completion);
6921 ok(iret == SOCKET_ERROR && GetLastError() == WSAEINVAL, "WSARecv failed - %d error %d\n", iret, GetLastError());
6922 ok(!completion_called, "completion called\n");
6923
6924 CloseHandle(io_port);
6925
6926 end:
6927 if (server != INVALID_SOCKET)
6928 closesocket(server);
6929 if (dest != INVALID_SOCKET)
6930 closesocket(dest);
6931 if (src != INVALID_SOCKET)
6932 closesocket(src);
6933 if (event)
6934 WSACloseEvent(event);
6935 }
6936
6937 struct write_watch_thread_args
6938 {
6939 int func;
6940 SOCKET dest;
6941 void *base;
6942 DWORD size;
6943 const char *expect;
6944 };
6945
6946 static DWORD CALLBACK write_watch_thread( void *arg )
6947 {
6948 struct write_watch_thread_args *args = arg;
6949 struct sockaddr addr;
6950 int addr_len = sizeof(addr), ret;
6951 DWORD bytes, flags = 0;
6952 WSABUF buf[1];
6953
6954 switch (args->func)
6955 {
6956 case 0:
6957 ret = recv( args->dest, args->base, args->size, 0 );
6958 ok( ret == strlen(args->expect) + 1, "wrong len %d\n", ret );
6959 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
6960 break;
6961 case 1:
6962 ret = recvfrom( args->dest, args->base, args->size, 0, &addr, &addr_len );
6963 ok( ret == strlen(args->expect) + 1, "wrong len %d\n", ret );
6964 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
6965 break;
6966 case 2:
6967 buf[0].len = args->size;
6968 buf[0].buf = args->base;
6969 ret = WSARecv( args->dest, buf, 1, &bytes, &flags, NULL, NULL );
6970 ok( !ret, "WSARecv failed %u\n", GetLastError() );
6971 ok( bytes == strlen(args->expect) + 1, "wrong len %d\n", bytes );
6972 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
6973 break;
6974 case 3:
6975 buf[0].len = args->size;
6976 buf[0].buf = args->base;
6977 ret = WSARecvFrom( args->dest, buf, 1, &bytes, &flags, &addr, &addr_len, NULL, NULL );
6978 ok( !ret, "WSARecvFrom failed %u\n", GetLastError() );
6979 ok( bytes == strlen(args->expect) + 1, "wrong len %d\n", bytes );
6980 ok( !strcmp( args->base, args->expect ), "wrong data\n" );
6981 break;
6982 }
6983 return 0;
6984 }
6985
6986 static void test_write_watch(void)
6987 {
6988 SOCKET src, dest;
6989 WSABUF bufs[2];
6990 WSAOVERLAPPED ov;
6991 struct write_watch_thread_args args;
6992 DWORD bytesReturned, flags, size;
6993 struct sockaddr addr;
6994 int addr_len, ret;
6995 HANDLE thread, event;
6996 char *base;
6997 void *results[64];
6998 ULONG_PTR count;
6999 ULONG pagesize;
7000 UINT (WINAPI *pGetWriteWatch)(DWORD,LPVOID,SIZE_T,LPVOID*,ULONG_PTR*,ULONG*);
7001
7002 pGetWriteWatch = (void *)GetProcAddress( GetModuleHandleA("kernel32.dll"), "GetWriteWatch" );
7003 if (!pGetWriteWatch)
7004 {
7005 win_skip( "write watched not supported\n" );
7006 return;
7007 }
7008
7009 tcp_socketpair(&src, &dest);
7010 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
7011 {
7012 skip("failed to create sockets\n");
7013 return;
7014 }
7015
7016 memset(&ov, 0, sizeof(ov));
7017 ov.hEvent = event = CreateEventA(NULL, FALSE, FALSE, NULL);
7018 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
7019
7020 flags = 0;
7021
7022 size = 0x10000;
7023 base = VirtualAlloc( 0, size, MEM_RESERVE | MEM_COMMIT | MEM_WRITE_WATCH, PAGE_READWRITE );
7024 ok( base != NULL, "VirtualAlloc failed %u\n", GetLastError() );
7025
7026 memset( base, 0, size );
7027 count = 64;
7028 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7029 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
7030 ok( count == 16, "wrong count %lu\n", count );
7031
7032 bufs[0].len = 5;
7033 bufs[0].buf = base;
7034 bufs[1].len = 0x8000;
7035 bufs[1].buf = base + 0x4000;
7036
7037 ret = WSARecv( dest, bufs, 2, NULL, &flags, &ov, NULL);
7038 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
7039 "WSARecv failed - %d error %d\n", ret, GetLastError());
7040
7041 count = 64;
7042 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7043 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
7044 ok( count == 9, "wrong count %lu\n", count );
7045 ok( !base[0], "data set\n" );
7046
7047 send(src, "test message", sizeof("test message"), 0);
7048
7049 ret = GetOverlappedResult( (HANDLE)dest, &ov, &bytesReturned, TRUE );
7050 ok( ret, "GetOverlappedResult failed %u\n", GetLastError() );
7051 ok( bytesReturned == sizeof("test message"), "wrong size %u\n", bytesReturned );
7052 ok( !memcmp( base, "test ", 5 ), "wrong data %s\n", base );
7053 ok( !memcmp( base + 0x4000, "message", 8 ), "wrong data %s\n", base + 0x4000 );
7054
7055 count = 64;
7056 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7057 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
7058 ok( count == 0, "wrong count %lu\n", count );
7059
7060 memset( base, 0, size );
7061 count = 64;
7062 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7063 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
7064 ok( count == 16, "wrong count %lu\n", count );
7065
7066 bufs[1].len = 0x4000;
7067 bufs[1].buf = base + 0x2000;
7068 ret = WSARecvFrom( dest, bufs, 2, NULL, &flags, &addr, &addr_len, &ov, NULL);
7069 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
7070 "WSARecv failed - %d error %d\n", ret, GetLastError());
7071
7072 count = 64;
7073 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7074 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
7075 ok( count == 5, "wrong count %lu\n", count );
7076 ok( !base[0], "data set\n" );
7077
7078 send(src, "test message", sizeof("test message"), 0);
7079
7080 ret = GetOverlappedResult( (HANDLE)dest, &ov, &bytesReturned, TRUE );
7081 ok( ret, "GetOverlappedResult failed %u\n", GetLastError() );
7082 ok( bytesReturned == sizeof("test message"), "wrong size %u\n", bytesReturned );
7083 ok( !memcmp( base, "test ", 5 ), "wrong data %s\n", base );
7084 ok( !memcmp( base + 0x2000, "message", 8 ), "wrong data %s\n", base + 0x2000 );
7085
7086 count = 64;
7087 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7088 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
7089 ok( count == 0, "wrong count %lu\n", count );
7090
7091 memset( base, 0, size );
7092 count = 64;
7093 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7094 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
7095 ok( count == 16, "wrong count %lu\n", count );
7096
7097 args.dest = dest;
7098 args.base = base;
7099 args.size = 0x7002;
7100 args.expect = "test message";
7101 for (args.func = 0; args.func < 4; args.func++)
7102 {
7103 thread = CreateThread( NULL, 0, write_watch_thread, &args, 0, NULL );
7104 Sleep( 200 );
7105
7106 count = 64;
7107 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7108 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
7109 ok( count == 8, "wrong count %lu\n", count );
7110
7111 send(src, "test message", sizeof("test message"), 0);
7112 WaitForSingleObject( thread, 10000 );
7113 CloseHandle( thread );
7114
7115 count = 64;
7116 ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
7117 ok( !ret, "GetWriteWatch failed %u\n", GetLastError() );
7118 ok( count == 0, "wrong count %lu\n", count );
7119 }
7120 WSACloseEvent( event );
7121 closesocket( dest );
7122 closesocket( src );
7123 VirtualFree( base, 0, MEM_FREE );
7124 }
7125
7126 #define POLL_CLEAR() ix = 0
7127 #define POLL_SET(s, ev) {fds[ix].fd = s; fds[ix++].events = ev;}
7128 #define POLL_ISSET(s, rev) poll_isset(fds, ix, s, rev)
7129 static BOOL poll_isset(WSAPOLLFD *fds, int max, SOCKET s, int rev)
7130 {
7131 int k;
7132 for (k = 0; k < max; k++)
7133 if (fds[k].fd == s && (fds[k].revents == rev)) return TRUE;
7134 return FALSE;
7135 }
7136
7137 static void test_WSAPoll(void)
7138 {
7139 int ix, ret, err, poll_timeout;
7140 SOCKET fdListen, fdRead, fdWrite;
7141 struct sockaddr_in address;
7142 socklen_t len;
7143 static char tmp_buf[1024];
7144 WSAPOLLFD fds[16];
7145 HANDLE thread_handle;
7146 DWORD id;
7147
7148 if (!pWSAPoll) /* >= Vista */
7149 {
7150 skip("WSAPoll is unsupported, some tests will be skipped.\n");
7151 return;
7152 }
7153
7154 /* Invalid parameters test */
7155 SetLastError(0xdeadbeef);
7156 ret = pWSAPoll(NULL, 0, 0);
7157 err = GetLastError();
7158 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7159 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
7160 SetLastError(0xdeadbeef);
7161 ret = pWSAPoll(NULL, 1, 0);
7162 err = GetLastError();
7163 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7164 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
7165 SetLastError(0xdeadbeef);
7166 ret = pWSAPoll(NULL, 0, 1);
7167 err = GetLastError();
7168 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7169 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
7170 SetLastError(0xdeadbeef);
7171 ret = pWSAPoll(NULL, 1, 1);
7172 err = GetLastError();
7173 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7174 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
7175
7176 /* WSAPoll() tries to mime the unix poll() call. The following tests do:
7177 * - check if a connection attempt ended with success or error;
7178 * - check if a pending connection is waiting for acceptance;
7179 * - check for data to read, availability for write and OOB data
7180 */
7181 memset(&address, 0, sizeof(address));
7182 address.sin_addr.s_addr = inet_addr("127.0.0.1");
7183 address.sin_family = AF_INET;
7184 len = sizeof(address);
7185 fdListen = setup_server_socket(&address, &len);
7186 poll_timeout = 100;
7187
7188 /* When no events are pending poll returns 0 with no error */
7189 POLL_CLEAR();
7190 POLL_SET(fdListen, POLLIN);
7191 ret = pWSAPoll(fds, ix, poll_timeout);
7192 ok(ret == 0, "expected 0, got %d\n", ret);
7193
7194 /* Test listening socket connection attempt notifications */
7195 fdWrite = setup_connector_socket(&address, len, TRUE);
7196 POLL_CLEAR();
7197 POLL_SET(fdListen, POLLIN | POLLOUT);
7198 ret = pWSAPoll(fds, ix, poll_timeout);
7199 ok(ret == 1, "expected 1, got %d\n", ret);
7200 ok(POLL_ISSET(fdListen, POLLRDNORM), "fdListen socket events incorrect\n");
7201 len = sizeof(address);
7202 fdRead = accept(fdListen, (struct sockaddr*) &address, &len);
7203 ok(fdRead != INVALID_SOCKET, "expected a valid socket\n");
7204
7205 /* Test client side connection attempt notifications */
7206 POLL_CLEAR();
7207 POLL_SET(fdListen, POLLIN | POLLOUT);
7208 POLL_SET(fdRead, POLLIN | POLLOUT);
7209 POLL_SET(fdWrite, POLLIN | POLLOUT);
7210 ret = pWSAPoll(fds, ix, poll_timeout);
7211 ok(ret == 2, "expected 2, got %d\n", ret);
7212 ok(POLL_ISSET(fdWrite, POLLWRNORM), "fdWrite socket events incorrect\n");
7213 ok(POLL_ISSET(fdRead, POLLWRNORM), "fdRead socket events incorrect\n");
7214 len = sizeof(id);
7215 id = 0xdeadbeef;
7216 err = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
7217 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
7218 ok(id == 0, "expected 0, got %d\n", id);
7219
7220 /* Test data receiving notifications */
7221 ret = send(fdWrite, "1234", 4, 0);
7222 ok(ret == 4, "expected 4, got %d\n", ret);
7223 POLL_CLEAR();
7224 POLL_SET(fdListen, POLLIN | POLLOUT);
7225 POLL_SET(fdRead, POLLIN);
7226 ret = pWSAPoll(fds, ix, poll_timeout);
7227 ok(ret == 1, "expected 1, got %d\n", ret);
7228 ok(POLL_ISSET(fdRead, POLLRDNORM), "fdRead socket events incorrect\n");
7229 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
7230 ok(ret == 4, "expected 4, got %d\n", ret);
7231 ok(!strcmp(tmp_buf, "1234"), "data received differs from sent\n");
7232
7233 /* Test OOB data notifications */
7234 ret = send(fdWrite, "A", 1, MSG_OOB);
7235 ok(ret == 1, "expected 1, got %d\n", ret);
7236 POLL_CLEAR();
7237 POLL_SET(fdListen, POLLIN | POLLOUT);
7238 POLL_SET(fdRead, POLLIN);
7239 ret = pWSAPoll(fds, ix, poll_timeout);
7240 ok(ret == 1, "expected 1, got %d\n", ret);
7241 ok(POLL_ISSET(fdRead, POLLRDBAND), "fdRead socket events incorrect\n");
7242 tmp_buf[0] = 0xAF;
7243 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
7244 ok(ret == 1, "expected 1, got %d\n", ret);
7245 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
7246
7247 /* If the socket is OOBINLINED the notification is like normal data */
7248 ret = 1;
7249 ret = setsockopt(fdRead, SOL_SOCKET, SO_OOBINLINE, (char*) &ret, sizeof(ret));
7250 ok(ret == 0, "expected 0, got %d\n", ret);
7251 ret = send(fdWrite, "A", 1, MSG_OOB);
7252 ok(ret == 1, "expected 1, got %d\n", ret);
7253 POLL_CLEAR();
7254 POLL_SET(fdListen, POLLIN | POLLOUT);
7255 POLL_SET(fdRead, POLLIN | POLLOUT);
7256 ret = pWSAPoll(fds, ix, poll_timeout);
7257 ok(ret == 1, "expected 1, got %d\n", ret);
7258 tmp_buf[0] = 0xAF;
7259 SetLastError(0xdeadbeef);
7260 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
7261 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
7262 ok(GetLastError() == WSAEINVAL, "expected 10022, got %d\n", GetLastError());
7263 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
7264 ok(ret == 1, "expected 1, got %d\n", ret);
7265 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
7266
7267 /* Test connection closed notifications */
7268 ret = closesocket(fdRead);
7269 ok(ret == 0, "expected 0, got %d\n", ret);
7270 POLL_CLEAR();
7271 POLL_SET(fdListen, POLLIN | POLLOUT);
7272 POLL_SET(fdWrite, POLLIN);
7273 ret = pWSAPoll(fds, ix, poll_timeout);
7274 ok(ret == 1, "expected 1, got %d\n", ret);
7275 ok(POLL_ISSET(fdWrite, POLLHUP), "fdWrite socket events incorrect\n");
7276 ret = recv(fdWrite, tmp_buf, sizeof(tmp_buf), 0);
7277 ok(ret == 0, "expected 0, got %d\n", ret);
7278
7279 /* When a connection is attempted to a non-listening socket due to a bug
7280 * in the MS code it will never be notified. This is a long standing issue
7281 * that will never be fixed for compatibility reasons so we have to deal
7282 * with it manually. */
7283 ret = closesocket(fdWrite);
7284 ok(ret == 0, "expected 0, got %d\n", ret);
7285 ret = closesocket(fdListen);
7286 ok(ret == 0, "expected 0, got %d\n", ret);
7287 len = sizeof(address);
7288 fdWrite = setup_connector_socket(&address, len, TRUE);
7289 POLL_CLEAR();
7290 POLL_SET(fdWrite, POLLIN | POLLOUT);
7291 poll_timeout = 2000;
7292 ret = pWSAPoll(fds, ix, poll_timeout);
7293 todo_wine
7294 ok(ret == 0, "expected 0, got %d\n", ret);
7295 len = sizeof(id);
7296 id = 0xdeadbeef;
7297 err = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
7298 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
7299 ok(id == WSAECONNREFUSED, "expected 10061, got %d\n", id);
7300 closesocket(fdWrite);
7301
7302 /* Try poll() on a closed socket after connection */
7303 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
7304 closesocket(fdRead);
7305 POLL_CLEAR();
7306 POLL_SET(fdWrite, POLLIN | POLLOUT);
7307 POLL_SET(fdRead, POLLIN | POLLOUT);
7308 ret = pWSAPoll(fds, ix, poll_timeout);
7309 ok(ret == 1, "expected 1, got %d\n", ret);
7310 ok(POLL_ISSET(fdRead, POLLNVAL), "fdRead socket events incorrect\n");
7311 POLL_CLEAR();
7312 POLL_SET(fdWrite, POLLIN | POLLOUT);
7313 ret = pWSAPoll(fds, ix, poll_timeout);
7314 ok(ret == 1, "expected 1, got %d\n", ret);
7315 todo_wine
7316 ok(POLL_ISSET(fdWrite, POLLWRNORM | POLLHUP) || broken(POLL_ISSET(fdWrite, POLLWRNORM)) /* <= 2008 */,
7317 "fdWrite socket events incorrect\n");
7318 closesocket(fdWrite);
7319
7320 /* Close the socket currently being polled in a thread */
7321 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
7322 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
7323 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
7324 POLL_CLEAR();
7325 POLL_SET(fdWrite, POLLIN | POLLOUT);
7326 ret = pWSAPoll(fds, ix, poll_timeout);
7327 ok(ret == 1, "expected 1, got %d\n", ret);
7328 ok(POLL_ISSET(fdWrite, POLLWRNORM), "fdWrite socket events incorrect\n");
7329 WaitForSingleObject (thread_handle, 1000);
7330 closesocket(fdRead);
7331 /* test again with less flags - behavior changes */
7332 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
7333 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
7334 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
7335 POLL_CLEAR();
7336 POLL_SET(fdWrite, POLLIN);
7337 ret = pWSAPoll(fds, ix, poll_timeout);
7338 ok(ret == 1, "expected 1, got %d\n", ret);
7339 ok(POLL_ISSET(fdWrite, POLLNVAL), "fdWrite socket events incorrect\n");
7340 WaitForSingleObject (thread_handle, 1000);
7341 closesocket(fdRead);
7342 }
7343 #undef POLL_SET
7344 #undef POLL_ISSET
7345 #undef POLL_CLEAR
7346
7347 static void test_GetAddrInfoW(void)
7348 {
7349 static const WCHAR port[] = {'8','0',0};
7350 static const WCHAR empty[] = {0};
7351 static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0};
7352 static const WCHAR nxdomain[] =
7353 {'n','x','d','o','m','a','i','n','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',0};
7354 static const WCHAR zero[] = {'0',0};
7355 int i, ret;
7356 ADDRINFOW *result, *result2, *p, hint;
7357 WCHAR name[256];
7358 DWORD size = ARRAY_SIZE(name);
7359 /* te su to.winehq.org written in katakana */
7360 static const WCHAR idn_domain[] =
7361 {0x30C6,0x30B9,0x30C8,'.','w','i','n','e','h','q','.','o','r','g',0};
7362 static const WCHAR idn_punycode[] =
7363 {'x','n','-','-','z','c','k','z','a','h','.','w','i','n','e','h','q','.','o','r','g',0};
7364
7365 if (!pGetAddrInfoW || !pFreeAddrInfoW)
7366 {
7367 win_skip("GetAddrInfoW and/or FreeAddrInfoW not present\n");
7368 return;
7369 }
7370 memset(&hint, 0, sizeof(ADDRINFOW));
7371 name[0] = 0;
7372 GetComputerNameExW( ComputerNamePhysicalDnsHostname, name, &size );
7373
7374 result = (ADDRINFOW *)0xdeadbeef;
7375 WSASetLastError(0xdeadbeef);
7376 ret = pGetAddrInfoW(NULL, NULL, NULL, &result);
7377 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7378 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7379 ok(result == NULL, "got %p\n", result);
7380
7381 result = NULL;
7382 WSASetLastError(0xdeadbeef);
7383 ret = pGetAddrInfoW(empty, NULL, NULL, &result);
7384 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7385 ok(result != NULL, "GetAddrInfoW failed\n");
7386 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7387 pFreeAddrInfoW(result);
7388
7389 result = NULL;
7390 ret = pGetAddrInfoW(NULL, zero, NULL, &result);
7391 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7392 ok(result != NULL, "GetAddrInfoW failed\n");
7393
7394 result2 = NULL;
7395 ret = pGetAddrInfoW(NULL, empty, NULL, &result2);
7396 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7397 ok(result2 != NULL, "GetAddrInfoW failed\n");
7398 compare_addrinfow(result, result2);
7399 pFreeAddrInfoW(result);
7400 pFreeAddrInfoW(result2);
7401
7402 result = NULL;
7403 ret = pGetAddrInfoW(empty, zero, NULL, &result);
7404 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7405 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7406 ok(result != NULL, "GetAddrInfoW failed\n");
7407
7408 result2 = NULL;
7409 ret = pGetAddrInfoW(empty, empty, NULL, &result2);
7410 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7411 ok(result2 != NULL, "GetAddrInfoW failed\n");
7412 compare_addrinfow(result, result2);
7413 pFreeAddrInfoW(result);
7414 pFreeAddrInfoW(result2);
7415
7416 result = NULL;
7417 ret = pGetAddrInfoW(localhost, NULL, NULL, &result);
7418 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7419 pFreeAddrInfoW(result);
7420
7421 result = NULL;
7422 ret = pGetAddrInfoW(localhost, empty, NULL, &result);
7423 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7424 pFreeAddrInfoW(result);
7425
7426 result = NULL;
7427 ret = pGetAddrInfoW(localhost, zero, NULL, &result);
7428 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7429 pFreeAddrInfoW(result);
7430
7431 result = NULL;
7432 ret = pGetAddrInfoW(localhost, port, NULL, &result);
7433 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7434 pFreeAddrInfoW(result);
7435
7436 result = NULL;
7437 ret = pGetAddrInfoW(localhost, NULL, &hint, &result);
7438 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7439 pFreeAddrInfoW(result);
7440
7441 result = NULL;
7442 SetLastError(0xdeadbeef);
7443 ret = pGetAddrInfoW(localhost, port, &hint, &result);
7444 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7445 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7446 pFreeAddrInfoW(result);
7447
7448 /* try to get information from the computer name, result is the same
7449 * as if requesting with an empty host name. */
7450 ret = pGetAddrInfoW(name, NULL, NULL, &result);
7451 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7452 ok(result != NULL, "GetAddrInfoW failed\n");
7453
7454 ret = pGetAddrInfoW(empty, NULL, NULL, &result2);
7455 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7456 ok(result != NULL, "GetAddrInfoW failed\n");
7457 compare_addrinfow(result, result2);
7458 pFreeAddrInfoW(result);
7459 pFreeAddrInfoW(result2);
7460
7461 ret = pGetAddrInfoW(name, empty, NULL, &result);
7462 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7463 ok(result != NULL, "GetAddrInfoW failed\n");
7464
7465 ret = pGetAddrInfoW(empty, empty, NULL, &result2);
7466 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
7467 ok(result != NULL, "GetAddrInfoW failed\n");
7468 compare_addrinfow(result, result2);
7469 pFreeAddrInfoW(result);
7470 pFreeAddrInfoW(result2);
7471
7472 result = (ADDRINFOW *)0xdeadbeef;
7473 WSASetLastError(0xdeadbeef);
7474 ret = pGetAddrInfoW(NULL, NULL, NULL, &result);
7475 if(ret == 0)
7476 {
7477 skip("nxdomain returned success. Broken ISP redirects?\n");
7478 return;
7479 }
7480 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7481 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7482 ok(result == NULL, "got %p\n", result);
7483
7484 result = (ADDRINFOW *)0xdeadbeef;
7485 WSASetLastError(0xdeadbeef);
7486 ret = pGetAddrInfoW(nxdomain, NULL, NULL, &result);
7487 if(ret == 0)
7488 {
7489 skip("nxdomain returned success. Broken ISP redirects?\n");
7490 return;
7491 }
7492 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7493 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7494 ok(result == NULL, "got %p\n", result);
7495
7496 for (i = 0;i < (ARRAY_SIZE(hinttests));i++)
7497 {
7498 hint.ai_family = hinttests[i].family;
7499 hint.ai_socktype = hinttests[i].socktype;
7500 hint.ai_protocol = hinttests[i].protocol;
7501
7502 result = NULL;
7503 SetLastError(0xdeadbeef);
7504 ret = pGetAddrInfoW(localhost, NULL, &hint, &result);
7505 if (!ret)
7506 {
7507 if (hinttests[i].error)
7508 ok(0, "test %d: GetAddrInfoW succeeded unexpectedly\n", i);
7509 else
7510 {
7511 p = result;
7512 do
7513 {
7514 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
7515 if (hinttests[i].family == AF_UNSPEC)
7516 ok(p->ai_family == AF_INET || p->ai_family == AF_INET6,
7517 "test %d: expected AF_INET or AF_INET6, got %d\n",
7518 i, p->ai_family);
7519 else
7520 ok(p->ai_family == hinttests[i].family,
7521 "test %d: expected family %d, got %d\n",
7522 i, hinttests[i].family, p->ai_family);
7523
7524 ok(p->ai_socktype == hinttests[i].socktype,
7525 "test %d: expected type %d, got %d\n",
7526 i, hinttests[i].socktype, p->ai_socktype);
7527 ok(p->ai_protocol == hinttests[i].protocol,
7528 "test %d: expected protocol %d, got %d\n",
7529 i, hinttests[i].protocol, p->ai_protocol);
7530 p = p->ai_next;
7531 }
7532 while (p);
7533 }
7534 pFreeAddrInfoW(result);
7535 }
7536 else
7537 {
7538 DWORD err = WSAGetLastError();
7539 if (hinttests[i].error)
7540 ok(hinttests[i].error == err, "test %d: GetAddrInfoW failed with error %d, expected %d\n",
7541 i, err, hinttests[i].error);
7542 else
7543 ok(0, "test %d: GetAddrInfoW failed with %d (err %d)\n", i, ret, err);
7544 }
7545 }
7546
7547 /* Test IDN resolution (Internationalized Domain Names) present since Windows 8 */
7548 trace("Testing punycode IDN %s\n", wine_dbgstr_w(idn_punycode));
7549 result = NULL;
7550 ret = pGetAddrInfoW(idn_punycode, NULL, NULL, &result);
7551 ok(!ret, "got %d expected success\n", ret);
7552 ok(result != NULL, "got %p\n", result);
7553 pFreeAddrInfoW(result);
7554
7555 hint.ai_family = AF_INET;
7556 hint.ai_socktype = 0;
7557 hint.ai_protocol = 0;
7558 hint.ai_flags = 0;
7559
7560 result = NULL;
7561 ret = pGetAddrInfoW(idn_punycode, NULL, &hint, &result);
7562 ok(!ret, "got %d expected success\n", ret);
7563 ok(result != NULL, "got %p\n", result);
7564
7565 trace("Testing unicode IDN %s\n", wine_dbgstr_w(idn_domain));
7566 result2 = NULL;
7567 ret = pGetAddrInfoW(idn_domain, NULL, NULL, &result2);
7568 if (ret == WSAHOST_NOT_FOUND && broken(1))
7569 {
7570 pFreeAddrInfoW(result);
7571 win_skip("IDN resolution not supported in Win <= 7\n");
7572 return;
7573 }
7574
7575 ok(!ret, "got %d expected success\n", ret);
7576 ok(result2 != NULL, "got %p\n", result2);
7577 pFreeAddrInfoW(result2);
7578
7579 hint.ai_family = AF_INET;
7580 hint.ai_socktype = 0;
7581 hint.ai_protocol = 0;
7582 hint.ai_flags = 0;
7583
7584 result2 = NULL;
7585 ret = pGetAddrInfoW(idn_domain, NULL, &hint, &result2);
7586 ok(!ret, "got %d expected success\n", ret);
7587 ok(result2 != NULL, "got %p\n", result2);
7588
7589 /* ensure manually resolved punycode and unicode hosts result in same data */
7590 compare_addrinfow(result, result2);
7591
7592 pFreeAddrInfoW(result);
7593 pFreeAddrInfoW(result2);
7594
7595 hint.ai_family = AF_INET;
7596 hint.ai_socktype = 0;
7597 hint.ai_protocol = 0;
7598 hint.ai_flags = 0;
7599
7600 result2 = NULL;
7601 ret = pGetAddrInfoW(idn_domain, NULL, &hint, &result2);
7602 ok(!ret, "got %d expected success\n", ret);
7603 ok(result2 != NULL, "got %p\n", result2);
7604 pFreeAddrInfoW(result2);
7605
7606 /* Disable IDN resolution and test again*/
7607 hint.ai_family = AF_INET;
7608 hint.ai_socktype = 0;
7609 hint.ai_protocol = 0;
7610 hint.ai_flags = AI_DISABLE_IDN_ENCODING;
7611
7612 SetLastError(0xdeadbeef);
7613 result2 = NULL;
7614 ret = pGetAddrInfoW(idn_domain, NULL, &hint, &result2);
7615 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7616 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7617 ok(result2 == NULL, "got %p\n", result2);
7618 }
7619
7620 static struct completion_routine_test
7621 {
7622 WSAOVERLAPPED *overlapped;
7623 DWORD error;
7624 ADDRINFOEXW **result;
7625 HANDLE event;
7626 DWORD called;
7627 } completion_routine_test;
7628
7629 static void CALLBACK completion_routine(DWORD error, DWORD byte_count, WSAOVERLAPPED *overlapped)
7630 {
7631 struct completion_routine_test *test = &completion_routine_test;
7632
7633 ok(error == test->error, "got %u\n", error);
7634 ok(!byte_count, "got %u\n", byte_count);
7635 ok(overlapped == test->overlapped, "got %p\n", overlapped);
7636 ok(overlapped->Internal == test->error, "got %lu\n", overlapped->Internal);
7637 ok(overlapped->Pointer == test->result, "got %p\n", overlapped->Pointer);
7638 ok(overlapped->hEvent == NULL, "got %p\n", overlapped->hEvent);
7639
7640 test->called++;
7641 SetEvent(test->event);
7642 }
7643
7644 static void test_GetAddrInfoExW(void)
7645 {
7646 static const WCHAR empty[] = {0};
7647 static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0};
7648 static const WCHAR winehq[] = {'t','e','s','t','.','w','i','n','e','h','q','.','o','r','g',0};
7649 static const WCHAR nxdomain[] = {'n','x','d','o','m','a','i','n','.','w','i','n','e','h','q','.','o','r','g',0};
7650 ADDRINFOEXW *result;
7651 OVERLAPPED overlapped;
7652 HANDLE event;
7653 int ret;
7654
7655 if (!pGetAddrInfoExW || !pGetAddrInfoExOverlappedResult)
7656 {
7657 win_skip("GetAddrInfoExW and/or GetAddrInfoExOverlappedResult not present\n");
7658 return;
7659 }
7660
7661 event = WSACreateEvent();
7662
7663 result = (ADDRINFOEXW *)0xdeadbeef;
7664 WSASetLastError(0xdeadbeef);
7665 ret = pGetAddrInfoExW(NULL, NULL, NS_DNS, NULL, NULL, &result, NULL, NULL, NULL, NULL);
7666 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7667 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7668 ok(result == NULL, "got %p\n", result);
7669
7670 result = NULL;
7671 WSASetLastError(0xdeadbeef);
7672 ret = pGetAddrInfoExW(empty, NULL, NS_DNS, NULL, NULL, &result, NULL, NULL, NULL, NULL);
7673 ok(!ret, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7674 ok(result != NULL, "GetAddrInfoW failed\n");
7675 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7676 pFreeAddrInfoExW(result);
7677
7678 result = NULL;
7679 ret = pGetAddrInfoExW(localhost, NULL, NS_DNS, NULL, NULL, &result, NULL, NULL, NULL, NULL);
7680 ok(!ret, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7681 pFreeAddrInfoExW(result);
7682
7683 result = (void*)0xdeadbeef;
7684 memset(&overlapped, 0xcc, sizeof(overlapped));
7685 overlapped.hEvent = event;
7686 ResetEvent(event);
7687 ret = pGetAddrInfoExW(localhost, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, NULL, NULL);
7688 ok(ret == ERROR_IO_PENDING, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7689 ok(!result, "result != NULL\n");
7690 ok(WaitForSingleObject(event, 1000) == WAIT_OBJECT_0, "wait failed\n");
7691 ret = pGetAddrInfoExOverlappedResult(&overlapped);
7692 ok(!ret, "overlapped result is %d\n", ret);
7693 pFreeAddrInfoExW(result);
7694
7695 result = (void*)0xdeadbeef;
7696 memset(&overlapped, 0xcc, sizeof(overlapped));
7697 ResetEvent(event);
7698 overlapped.hEvent = event;
7699 WSASetLastError(0xdeadbeef);
7700 ret = pGetAddrInfoExW(winehq, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, NULL, NULL);
7701 ok(ret == ERROR_IO_PENDING, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7702 ok(WSAGetLastError() == ERROR_IO_PENDING, "expected 11001, got %d\n", WSAGetLastError());
7703 ret = overlapped.Internal;
7704 ok(ret == WSAEINPROGRESS || ret == ERROR_SUCCESS, "overlapped.Internal = %u\n", ret);
7705 ok(WaitForSingleObject(event, 1000) == WAIT_OBJECT_0, "wait failed\n");
7706 ret = pGetAddrInfoExOverlappedResult(&overlapped);
7707 ok(!ret, "overlapped result is %d\n", ret);
7708 ok(overlapped.hEvent == event, "hEvent changed %p\n", overlapped.hEvent);
7709 ok(overlapped.Internal == ERROR_SUCCESS, "overlapped.Internal = %lx\n", overlapped.Internal);
7710 ok(overlapped.Pointer == &result, "overlapped.Pointer != &result\n");
7711 ok(result != NULL, "result == NULL\n");
7712 if (result != NULL)
7713 {
7714 ok(!result->ai_blob, "ai_blob != NULL\n");
7715 ok(!result->ai_bloblen, "ai_bloblen != 0\n");
7716 ok(!result->ai_provider, "ai_provider = %s\n", wine_dbgstr_guid(result->ai_provider));
7717 pFreeAddrInfoExW(result);
7718 }
7719
7720 result = (void*)0xdeadbeef;
7721 memset(&overlapped, 0xcc, sizeof(overlapped));
7722 ResetEvent(event);
7723 overlapped.hEvent = event;
7724 ret = pGetAddrInfoExW(NULL, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, NULL, NULL);
7725 todo_wine
7726 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7727 todo_wine
7728 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7729 ok(result == NULL, "got %p\n", result);
7730 ret = WaitForSingleObject(event, 0);
7731 todo_wine_if(ret != WAIT_TIMEOUT) /* Remove when abowe todo_wines are fixed */
7732 ok(ret == WAIT_TIMEOUT, "wait failed\n");
7733
7734 /* event + completion routine */
7735 result = (void*)0xdeadbeef;
7736 memset(&overlapped, 0xcc, sizeof(overlapped));
7737 overlapped.hEvent = event;
7738 ResetEvent(event);
7739 ret = pGetAddrInfoExW(localhost, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, completion_routine, NULL);
7740 ok(ret == WSAEINVAL, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7741
7742 /* completion routine, existing domain */
7743 result = (void *)0xdeadbeef;
7744 overlapped.hEvent = NULL;
7745 completion_routine_test.overlapped = &overlapped;
7746 completion_routine_test.error = ERROR_SUCCESS;
7747 completion_routine_test.result = &result;
7748 completion_routine_test.event = event;
7749 completion_routine_test.called = 0;
7750 ResetEvent(event);
7751 ret = pGetAddrInfoExW(winehq, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, completion_routine, NULL);
7752 ok(ret == ERROR_IO_PENDING, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7753 ok(!result, "result != NULL\n");
7754 ok(WaitForSingleObject(event, 1000) == WAIT_OBJECT_0, "wait failed\n");
7755 ret = pGetAddrInfoExOverlappedResult(&overlapped);
7756 ok(!ret, "overlapped result is %d\n", ret);
7757 ok(overlapped.hEvent == NULL, "hEvent changed %p\n", overlapped.hEvent);
7758 ok(overlapped.Internal == ERROR_SUCCESS, "overlapped.Internal = %lx\n", overlapped.Internal);
7759 ok(overlapped.Pointer == &result, "overlapped.Pointer != &result\n");
7760 ok(completion_routine_test.called == 1, "got %u\n", completion_routine_test.called);
7761 pFreeAddrInfoExW(result);
7762
7763 /* completion routine, non-existing domain */
7764 result = (void *)0xdeadbeef;
7765 completion_routine_test.overlapped = &overlapped;
7766 completion_routine_test.error = WSAHOST_NOT_FOUND;
7767 completion_routine_test.called = 0;
7768 ResetEvent(event);
7769 ret = pGetAddrInfoExW(nxdomain, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, completion_routine, NULL);
7770 ok(ret == ERROR_IO_PENDING, "GetAddrInfoExW failed with %d\n", WSAGetLastError());
7771 ok(!result, "result != NULL\n");
7772 ok(WaitForSingleObject(event, 1000) == WAIT_OBJECT_0, "wait failed\n");
7773 ret = pGetAddrInfoExOverlappedResult(&overlapped);
7774 ok(ret == WSAHOST_NOT_FOUND, "overlapped result is %d\n", ret);
7775 ok(overlapped.hEvent == NULL, "hEvent changed %p\n", overlapped.hEvent);
7776 ok(overlapped.Internal == WSAHOST_NOT_FOUND, "overlapped.Internal = %lx\n", overlapped.Internal);
7777 ok(overlapped.Pointer == &result, "overlapped.Pointer != &result\n");
7778 ok(completion_routine_test.called == 1, "got %u\n", completion_routine_test.called);
7779 ok(result == NULL, "got %p\n", result);
7780
7781 WSACloseEvent(event);
7782 }
7783
7784 static void verify_ipv6_addrinfo(ADDRINFOA *result, const char *expectedIp)
7785 {
7786 SOCKADDR_IN6 *sockaddr6;
7787 char ipBuffer[256];
7788 const char *ret;
7789
7790 ok(result->ai_family == AF_INET6, "ai_family == %d\n", result->ai_family);
7791 ok(result->ai_addrlen >= sizeof(struct sockaddr_in6), "ai_addrlen == %d\n", (int)result->ai_addrlen);
7792 ok(result->ai_addr != NULL, "ai_addr == NULL\n");
7793
7794 if (result->ai_addr != NULL)
7795 {
7796 sockaddr6 = (SOCKADDR_IN6 *)result->ai_addr;
7797 ok(sockaddr6->sin6_family == AF_INET6, "ai_addr->sin6_family == %d\n", sockaddr6->sin6_family);
7798 ok(sockaddr6->sin6_port == 0, "ai_addr->sin6_port == %d\n", sockaddr6->sin6_port);
7799
7800 ZeroMemory(ipBuffer, sizeof(ipBuffer));
7801 ret = pInetNtop(AF_INET6, &sockaddr6->sin6_addr, ipBuffer, sizeof(ipBuffer));
7802 ok(ret != NULL, "inet_ntop failed (%d)\n", WSAGetLastError());
7803 ok(strcmp(ipBuffer, expectedIp) == 0, "ai_addr->sin6_addr == '%s' (expected '%s')\n", ipBuffer, expectedIp);
7804 }
7805 }
7806
7807 static void test_getaddrinfo(void)
7808 {
7809 int i, ret;
7810 ADDRINFOA *result, *result2, *p, hint;
7811 SOCKADDR_IN *sockaddr;
7812 CHAR name[256], *ip;
7813 DWORD size = sizeof(name);
7814
7815 if (!pgetaddrinfo || !pfreeaddrinfo)
7816 {
7817 win_skip("getaddrinfo and/or freeaddrinfo not present\n");
7818 return;
7819 }
7820 memset(&hint, 0, sizeof(ADDRINFOA));
7821 GetComputerNameExA( ComputerNamePhysicalDnsHostname, name, &size );
7822
7823 result = (ADDRINFOA *)0xdeadbeef;
7824 WSASetLastError(0xdeadbeef);
7825 ret = pgetaddrinfo(NULL, NULL, NULL, &result);
7826 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7827 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7828 ok(result == NULL, "got %p\n", result);
7829
7830 result = NULL;
7831 WSASetLastError(0xdeadbeef);
7832 ret = pgetaddrinfo("", NULL, NULL, &result);
7833 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7834 ok(result != NULL, "getaddrinfo failed\n");
7835 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7836 pfreeaddrinfo(result);
7837
7838 result = NULL;
7839 ret = pgetaddrinfo(NULL, "0", NULL, &result);
7840 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7841 ok(result != NULL, "getaddrinfo failed\n");
7842
7843 result2 = NULL;
7844 ret = pgetaddrinfo(NULL, "", NULL, &result2);
7845 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7846 ok(result2 != NULL, "getaddrinfo failed\n");
7847 compare_addrinfo(result, result2);
7848 pfreeaddrinfo(result);
7849 pfreeaddrinfo(result2);
7850
7851 result = NULL;
7852 WSASetLastError(0xdeadbeef);
7853 ret = pgetaddrinfo("", "0", NULL, &result);
7854 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7855 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7856 ok(result != NULL, "getaddrinfo failed\n");
7857
7858 result2 = NULL;
7859 ret = pgetaddrinfo("", "", NULL, &result2);
7860 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7861 ok(result2 != NULL, "getaddrinfo failed\n");
7862 compare_addrinfo(result, result2);
7863 pfreeaddrinfo(result);
7864 pfreeaddrinfo(result2);
7865
7866 result = NULL;
7867 ret = pgetaddrinfo("localhost", NULL, NULL, &result);
7868 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7869 pfreeaddrinfo(result);
7870
7871 result = NULL;
7872 ret = pgetaddrinfo("localhost", "", NULL, &result);
7873 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7874 pfreeaddrinfo(result);
7875
7876 result = NULL;
7877 ret = pgetaddrinfo("localhost", "0", NULL, &result);
7878 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7879 pfreeaddrinfo(result);
7880
7881 result = NULL;
7882 ret = pgetaddrinfo("localhost", "80", NULL, &result);
7883 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7884 pfreeaddrinfo(result);
7885
7886 result = NULL;
7887 ret = pgetaddrinfo("localhost", NULL, &hint, &result);
7888 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7889 pfreeaddrinfo(result);
7890
7891 result = NULL;
7892 WSASetLastError(0xdeadbeef);
7893 ret = pgetaddrinfo("localhost", "80", &hint, &result);
7894 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7895 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7896 pfreeaddrinfo(result);
7897
7898 hint.ai_flags = AI_NUMERICHOST;
7899 result = (void*)0xdeadbeef;
7900 ret = pgetaddrinfo("localhost", "80", &hint, &result);
7901 ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", WSAGetLastError());
7902 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected WSAHOST_NOT_FOUND, got %d\n", WSAGetLastError());
7903 ok(!result, "result = %p\n", result);
7904 hint.ai_flags = 0;
7905
7906 /* try to get information from the computer name, result is the same
7907 * as if requesting with an empty host name. */
7908 ret = pgetaddrinfo(name, NULL, NULL, &result);
7909 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7910 ok(result != NULL, "GetAddrInfoW failed\n");
7911
7912 ret = pgetaddrinfo("", NULL, NULL, &result2);
7913 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7914 ok(result != NULL, "GetAddrInfoW failed\n");
7915 compare_addrinfo(result, result2);
7916 pfreeaddrinfo(result);
7917 pfreeaddrinfo(result2);
7918
7919 ret = pgetaddrinfo(name, "", NULL, &result);
7920 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7921 ok(result != NULL, "GetAddrInfoW failed\n");
7922
7923 ret = pgetaddrinfo("", "", NULL, &result2);
7924 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7925 ok(result != NULL, "GetAddrInfoW failed\n");
7926 compare_addrinfo(result, result2);
7927 pfreeaddrinfo(result);
7928 pfreeaddrinfo(result2);
7929
7930 result = (ADDRINFOA *)0xdeadbeef;
7931 WSASetLastError(0xdeadbeef);
7932 ret = pgetaddrinfo("nxdomain.codeweavers.com", NULL, NULL, &result);
7933 if(ret == 0)
7934 {
7935 skip("nxdomain returned success. Broken ISP redirects?\n");
7936 return;
7937 }
7938 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7939 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7940 ok(result == NULL, "got %p\n", result);
7941
7942 /* Test IPv4 address conversion */
7943 result = NULL;
7944 ret = pgetaddrinfo("192.168.1.253", NULL, NULL, &result);
7945 ok(!ret, "getaddrinfo failed with %d\n", ret);
7946 ok(result->ai_family == AF_INET, "ai_family == %d\n", result->ai_family);
7947 ok(result->ai_addrlen >= sizeof(struct sockaddr_in), "ai_addrlen == %d\n", (int)result->ai_addrlen);
7948 ok(result->ai_addr != NULL, "ai_addr == NULL\n");
7949 sockaddr = (SOCKADDR_IN *)result->ai_addr;
7950 ok(sockaddr->sin_family == AF_INET, "ai_addr->sin_family == %d\n", sockaddr->sin_family);
7951 ok(sockaddr->sin_port == 0, "ai_addr->sin_port == %d\n", sockaddr->sin_port);
7952
7953 ip = inet_ntoa(sockaddr->sin_addr);
7954 ok(strcmp(ip, "192.168.1.253") == 0, "sockaddr->ai_addr == '%s'\n", ip);
7955 pfreeaddrinfo(result);
7956
7957 /* Test IPv4 address conversion with port */
7958 result = NULL;
7959 hint.ai_flags = AI_NUMERICHOST;
7960 ret = pgetaddrinfo("192.168.1.253:1024", NULL, &hint, &result);
7961 hint.ai_flags = 0;
7962 ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo returned unexpected result: %d\n", ret);
7963 ok(result == NULL, "expected NULL, got %p\n", result);
7964
7965 /* Test IPv6 address conversion */
7966 result = NULL;
7967 SetLastError(0xdeadbeef);
7968 ret = pgetaddrinfo("2a00:2039:dead:beef:cafe::6666", NULL, NULL, &result);
7969
7970 if (result != NULL)
7971 {
7972 ok(!ret, "getaddrinfo failed with %d\n", ret);
7973 verify_ipv6_addrinfo(result, "2a00:2039:dead:beef:cafe::6666");
7974 pfreeaddrinfo(result);
7975
7976 /* Test IPv6 address conversion with brackets */
7977 result = NULL;
7978 ret = pgetaddrinfo("[beef::cafe]", NULL, NULL, &result);
7979 ok(!ret, "getaddrinfo failed with %d\n", ret);
7980 verify_ipv6_addrinfo(result, "beef::cafe");
7981 pfreeaddrinfo(result);
7982
7983 /* Test IPv6 address conversion with brackets and hints */
7984 memset(&hint, 0, sizeof(ADDRINFOA));
7985 hint.ai_flags = AI_NUMERICHOST;
7986 hint.ai_family = AF_INET6;
7987 result = NULL;
7988 ret = pgetaddrinfo("[beef::cafe]", NULL, &hint, &result);
7989 ok(!ret, "getaddrinfo failed with %d\n", ret);
7990 verify_ipv6_addrinfo(result, "beef::cafe");
7991 pfreeaddrinfo(result);
7992
7993 memset(&hint, 0, sizeof(ADDRINFOA));
7994 hint.ai_flags = AI_NUMERICHOST;
7995 hint.ai_family = AF_INET;
7996 result = NULL;
7997 ret = pgetaddrinfo("[beef::cafe]", NULL, &hint, &result);
7998 ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", ret);
7999
8000 /* Test IPv6 address conversion with brackets and port */
8001 result = NULL;
8002 ret = pgetaddrinfo("[beef::cafe]:10239", NULL, NULL, &result);
8003 ok(!ret, "getaddrinfo failed with %d\n", ret);
8004 verify_ipv6_addrinfo(result, "beef::cafe");
8005 pfreeaddrinfo(result);
8006
8007 /* Test IPv6 address conversion with unmatched brackets */
8008 result = NULL;
8009 hint.ai_flags = AI_NUMERICHOST;
8010 ret = pgetaddrinfo("[beef::cafe", NULL, &hint, &result);
8011 ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", ret);
8012
8013 ret = pgetaddrinfo("beef::cafe]", NULL, &hint, &result);
8014 ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", ret);
8015 }
8016 else
8017 {
8018 ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", ret);
8019 win_skip("getaddrinfo does not support IPV6\n");
8020 }
8021
8022 hint.ai_flags = 0;
8023
8024 for (i = 0;i < (ARRAY_SIZE(hinttests));i++)
8025 {
8026 hint.ai_family = hinttests[i].family;
8027 hint.ai_socktype = hinttests[i].socktype;
8028 hint.ai_protocol = hinttests[i].protocol;
8029
8030 result = NULL;
8031 SetLastError(0xdeadbeef);
8032 ret = pgetaddrinfo("localhost", NULL, &hint, &result);
8033 if(!ret)
8034 {
8035 if (hinttests[i].error)
8036 ok(0, "test %d: getaddrinfo succeeded unexpectedly\n", i);
8037 else
8038 {
8039 p = result;
8040 do
8041 {
8042 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
8043 if (hinttests[i].family == AF_UNSPEC)
8044 ok(p->ai_family == AF_INET || p->ai_family == AF_INET6,
8045 "test %d: expected AF_INET or AF_INET6, got %d\n",
8046 i, p->ai_family);
8047 else
8048 ok(p->ai_family == hinttests[i].family,
8049 "test %d: expected family %d, got %d\n",
8050 i, hinttests[i].family, p->ai_family);
8051
8052 ok(p->ai_socktype == hinttests[i].socktype,
8053 "test %d: expected type %d, got %d\n",
8054 i, hinttests[i].socktype, p->ai_socktype);
8055 ok(p->ai_protocol == hinttests[i].protocol,
8056 "test %d: expected protocol %d, got %d\n",
8057 i, hinttests[i].protocol, p->ai_protocol);
8058 p = p->ai_next;
8059 }
8060 while (p);
8061 }
8062 pfreeaddrinfo(result);
8063 }
8064 else
8065 {
8066 DWORD err = WSAGetLastError();
8067 if (hinttests[i].error)
8068 ok(hinttests[i].error == err, "test %d: getaddrinfo failed with error %d, expected %d\n",
8069 i, err, hinttests[i].error);
8070 else
8071 ok(0, "test %d: getaddrinfo failed with %d (err %d)\n", i, ret, err);
8072 }
8073 }
8074 }
8075
8076 static void test_ConnectEx(void)
8077 {
8078 SOCKET listener = INVALID_SOCKET;
8079 SOCKET acceptor = INVALID_SOCKET;
8080 SOCKET connector = INVALID_SOCKET;
8081 struct sockaddr_in address, conaddress;
8082 int addrlen;
8083 OVERLAPPED overlapped;
8084 LPFN_CONNECTEX pConnectEx;
8085 GUID connectExGuid = WSAID_CONNECTEX;
8086 DWORD bytesReturned;
8087 char buffer[1024];
8088 BOOL bret;
8089 DWORD dwret;
8090 int iret;
8091
8092 memset(&overlapped, 0, sizeof(overlapped));
8093
8094 listener = socket(AF_INET, SOCK_STREAM, 0);
8095 if (listener == INVALID_SOCKET) {
8096 skip("could not create listener socket, error %d\n", WSAGetLastError());
8097 goto end;
8098 }
8099
8100 connector = socket(AF_INET, SOCK_STREAM, 0);
8101 if (connector == INVALID_SOCKET) {
8102 skip("could not create connector socket, error %d\n", WSAGetLastError());
8103 goto end;
8104 }
8105
8106 memset(&address, 0, sizeof(address));
8107 address.sin_family = AF_INET;
8108 address.sin_addr.s_addr = inet_addr("127.0.0.1");
8109 iret = bind(listener, (struct sockaddr*)&address, sizeof(address));
8110 if (iret != 0) {
8111 skip("failed to bind, error %d\n", WSAGetLastError());
8112 goto end;
8113 }
8114
8115 addrlen = sizeof(address);
8116 iret = getsockname(listener, (struct sockaddr*)&address, &addrlen);
8117 if (iret != 0) {
8118 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
8119 goto end;
8120 }
8121
8122 if (set_blocking(listener, TRUE)) {
8123 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8124 goto end;
8125 }
8126
8127 bytesReturned = 0xdeadbeef;
8128 iret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectExGuid, sizeof(connectExGuid),
8129 &pConnectEx, sizeof(pConnectEx), &bytesReturned, NULL, NULL);
8130 if (iret) {
8131 win_skip("WSAIoctl failed to get ConnectEx with ret %d + errno %d\n", iret, WSAGetLastError());
8132 goto end;
8133 }
8134
8135 ok(bytesReturned == sizeof(pConnectEx), "expected sizeof(pConnectEx), got %u\n", bytesReturned);
8136
8137 bret = pConnectEx(INVALID_SOCKET, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8138 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "ConnectEx on invalid socket "
8139 "returned %d + errno %d\n", bret, WSAGetLastError());
8140
8141 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8142 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "ConnectEx on a unbound socket "
8143 "returned %d + errno %d\n", bret, WSAGetLastError());
8144 if (bret == TRUE || WSAGetLastError() != WSAEINVAL)
8145 {
8146 acceptor = accept(listener, NULL, NULL);
8147 if (acceptor != INVALID_SOCKET) {
8148 closesocket(acceptor);
8149 acceptor = INVALID_SOCKET;
8150 }
8151
8152 closesocket(connector);
8153 connector = socket(AF_INET, SOCK_STREAM, 0);
8154 if (connector == INVALID_SOCKET) {
8155 skip("could not create connector socket, error %d\n", WSAGetLastError());
8156 goto end;
8157 }
8158 }
8159
8160 /* ConnectEx needs a bound socket */
8161 memset(&conaddress, 0, sizeof(conaddress));
8162 conaddress.sin_family = AF_INET;
8163 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8164 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8165 if (iret != 0) {
8166 skip("failed to bind, error %d\n", WSAGetLastError());
8167 goto end;
8168 }
8169
8170 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, NULL);
8171 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "ConnectEx on a NULL overlapped "
8172 "returned %d + errno %d\n", bret, WSAGetLastError());
8173
8174 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8175 if (overlapped.hEvent == NULL) {
8176 skip("could not create event object, errno = %d\n", GetLastError());
8177 goto end;
8178 }
8179
8180 iret = listen(listener, 1);
8181 if (iret != 0) {
8182 skip("listening failed, errno = %d\n", WSAGetLastError());
8183 goto end;
8184 }
8185
8186 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8187 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
8188 "returned %d + errno %d\n", bret, WSAGetLastError());
8189 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8190 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
8191
8192 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8193 ok(bret, "Connecting failed, error %d\n", GetLastError());
8194 ok(bytesReturned == 0, "Bytes sent is %d\n", bytesReturned);
8195
8196 closesocket(connector);
8197 connector = socket(AF_INET, SOCK_STREAM, 0);
8198 if (connector == INVALID_SOCKET) {
8199 skip("could not create connector socket, error %d\n", WSAGetLastError());
8200 goto end;
8201 }
8202 /* ConnectEx needs a bound socket */
8203 memset(&conaddress, 0, sizeof(conaddress));
8204 conaddress.sin_family = AF_INET;
8205 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8206 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8207 if (iret != 0) {
8208 skip("failed to bind, error %d\n", WSAGetLastError());
8209 goto end;
8210 }
8211
8212 acceptor = accept(listener, NULL, NULL);
8213 if (acceptor != INVALID_SOCKET) {
8214 closesocket(acceptor);
8215 }
8216
8217 buffer[0] = '1';
8218 buffer[1] = '2';
8219 buffer[2] = '3';
8220 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, buffer, 3, &bytesReturned, &overlapped);
8221 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
8222 "returned %d + errno %d\n", bret, WSAGetLastError());
8223 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8224 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
8225
8226 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8227 ok(bret, "Connecting failed, error %d\n", GetLastError());
8228 ok(bytesReturned == 3, "Bytes sent is %d\n", bytesReturned);
8229
8230 acceptor = accept(listener, NULL, NULL);
8231 ok(acceptor != INVALID_SOCKET, "could not accept socket error %d\n", WSAGetLastError());
8232
8233 bytesReturned = recv(acceptor, buffer, 3, 0);
8234 buffer[4] = 0;
8235 ok(bytesReturned == 3, "Didn't get all sent data, got only %d\n", bytesReturned);
8236 ok(buffer[0] == '1' && buffer[1] == '2' && buffer[2] == '3',
8237 "Failed to get the right data, expected '123', got '%s'\n", buffer);
8238
8239 closesocket(connector);
8240 connector = socket(AF_INET, SOCK_STREAM, 0);
8241 if (connector == INVALID_SOCKET) {
8242 skip("could not create connector socket, error %d\n", WSAGetLastError());
8243 goto end;
8244 }
8245 /* ConnectEx needs a bound socket */
8246 memset(&conaddress, 0, sizeof(conaddress));
8247 conaddress.sin_family = AF_INET;
8248 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8249 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
8250 if (iret != 0) {
8251 skip("failed to bind, error %d\n", WSAGetLastError());
8252 goto end;
8253 }
8254
8255 if (acceptor != INVALID_SOCKET) {
8256 closesocket(acceptor);
8257 acceptor = INVALID_SOCKET;
8258 }
8259
8260 /* Connect with error */
8261 closesocket(listener);
8262 listener = INVALID_SOCKET;
8263
8264 address.sin_port = htons(1);
8265
8266 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
8267 ok(bret == FALSE && GetLastError() == ERROR_IO_PENDING, "ConnectEx to bad destination failed: "
8268 "returned %d + errno %d\n", bret, GetLastError());
8269 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
8270 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
8271
8272 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
8273 ok(bret == FALSE && GetLastError() == ERROR_CONNECTION_REFUSED,
8274 "Connecting to a disconnected host returned error %d - %d\n", bret, WSAGetLastError());
8275
8276 end:
8277 if (overlapped.hEvent)
8278 WSACloseEvent(overlapped.hEvent);
8279 if (listener != INVALID_SOCKET)
8280 closesocket(listener);
8281 if (acceptor != INVALID_SOCKET)
8282 closesocket(acceptor);
8283 if (connector != INVALID_SOCKET)
8284 closesocket(connector);
8285 }
8286
8287 static void test_AcceptEx(void)
8288 {
8289 SOCKET listener = INVALID_SOCKET;
8290 SOCKET acceptor = INVALID_SOCKET;
8291 SOCKET connector = INVALID_SOCKET;
8292 SOCKET connector2 = INVALID_SOCKET;
8293 struct sockaddr_in bindAddress, peerAddress, *readBindAddress, *readRemoteAddress;
8294 int socklen, optlen;
8295 GUID acceptExGuid = WSAID_ACCEPTEX, getAcceptExGuid = WSAID_GETACCEPTEXSOCKADDRS;
8296 LPFN_ACCEPTEX pAcceptEx = NULL;
8297 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs = NULL;
8298 fd_set fds_accept, fds_send;
8299 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
8300 int got, conn1, i;
8301 DWORD bytesReturned, connect_time;
8302 char buffer[1024], ipbuffer[32];
8303 OVERLAPPED overlapped;
8304 int iret, localSize = sizeof(struct sockaddr_in), remoteSize = localSize;
8305 BOOL bret;
8306 DWORD dwret;
8307
8308 memset(&overlapped, 0, sizeof(overlapped));
8309
8310 listener = socket(AF_INET, SOCK_STREAM, 0);
8311 if (listener == INVALID_SOCKET) {
8312 skip("could not create listener socket, error %d\n", WSAGetLastError());
8313 goto end;
8314 }
8315
8316 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8317 if (acceptor == INVALID_SOCKET) {
8318 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8319 goto end;
8320 }
8321
8322 connector = socket(AF_INET, SOCK_STREAM, 0);
8323 if (connector == INVALID_SOCKET) {
8324 skip("could not create connector socket, error %d\n", WSAGetLastError());
8325 goto end;
8326 }
8327
8328 memset(&bindAddress, 0, sizeof(bindAddress));
8329 bindAddress.sin_family = AF_INET;
8330 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8331 iret = bind(listener, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8332 if (iret != 0) {
8333 skip("failed to bind, error %d\n", WSAGetLastError());
8334 goto end;
8335 }
8336
8337 socklen = sizeof(bindAddress);
8338 iret = getsockname(listener, (struct sockaddr*)&bindAddress, &socklen);
8339 if (iret != 0) {
8340 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
8341 goto end;
8342 }
8343
8344 if (set_blocking(listener, FALSE)) {
8345 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8346 goto end;
8347 }
8348
8349 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
8350 &pAcceptEx, sizeof(pAcceptEx), &bytesReturned, NULL, NULL);
8351 if (iret) {
8352 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret, WSAGetLastError());
8353 goto end;
8354 }
8355
8356 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &getAcceptExGuid, sizeof(getAcceptExGuid),
8357 &pGetAcceptExSockaddrs, sizeof(pGetAcceptExSockaddrs), &bytesReturned, NULL, NULL);
8358 if (iret) {
8359 skip("WSAIoctl failed to get GetAcceptExSockaddrs with ret %d + errno %d\n", iret, WSAGetLastError());
8360 goto end;
8361 }
8362
8363 overlapped.Internal = 0xdeadbeef;
8364 bret = pAcceptEx(INVALID_SOCKET, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8365 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8366 &bytesReturned, &overlapped);
8367 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid listening socket "
8368 "returned %d + errno %d\n", bret, WSAGetLastError());
8369 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8370
8371 overlapped.Internal = 0xdeadbeef;
8372 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8373 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8374 &bytesReturned, &overlapped);
8375 todo_wine
8376 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on a non-listening socket "
8377 "returned %d + errno %d\n", bret, WSAGetLastError());
8378 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8379
8380 iret = listen(listener, 5);
8381 if (iret != 0) {
8382 skip("listening failed, errno = %d\n", WSAGetLastError());
8383 goto end;
8384 }
8385
8386 overlapped.Internal = 0xdeadbeef;
8387 bret = pAcceptEx(listener, INVALID_SOCKET, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8388 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8389 &bytesReturned, &overlapped);
8390 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid accepting socket "
8391 "returned %d + errno %d\n", bret, WSAGetLastError());
8392 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8393
8394 overlapped.Internal = 0xdeadbeef;
8395 bret = pAcceptEx(listener, acceptor, NULL, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8396 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8397 &bytesReturned, &overlapped);
8398 todo_wine ok(bret == FALSE && WSAGetLastError() == WSAEFAULT,
8399 "AcceptEx on NULL buffer returned %d + errno %d\n", bret, WSAGetLastError());
8400 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8401
8402 overlapped.Internal = 0xdeadbeef;
8403 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
8404 &bytesReturned, &overlapped);
8405 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING,
8406 "AcceptEx on too small local address size returned %d + errno %d\n",
8407 bret, WSAGetLastError());
8408 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8409 bret = CancelIo((HANDLE) listener);
8410 ok(bret, "Failed to cancel pending accept socket\n");
8411
8412 overlapped.Internal = 0xdeadbeef;
8413 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 15,
8414 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
8415 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx on too small local address "
8416 "size returned %d + errno %d\n",
8417 bret, WSAGetLastError());
8418 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8419 bret = CancelIo((HANDLE) listener);
8420 ok(bret, "Failed to cancel pending accept socket\n");
8421
8422 overlapped.Internal = 0xdeadbeef;
8423 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16, 0,
8424 &bytesReturned, &overlapped);
8425 ok(bret == FALSE && WSAGetLastError() == WSAEFAULT,
8426 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
8427 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8428
8429 overlapped.Internal = 0xdeadbeef;
8430 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16,
8431 sizeof(struct sockaddr_in) + 15, &bytesReturned, &overlapped);
8432 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING,
8433 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
8434 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8435 bret = CancelIo((HANDLE) listener);
8436 ok(bret, "Failed to cancel pending accept socket\n");
8437
8438 bret = pAcceptEx(listener, acceptor, buffer, 0,
8439 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8440 &bytesReturned, NULL);
8441 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
8442 "returned %d + errno %d\n", bret, WSAGetLastError());
8443
8444 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, 0, &bytesReturned, NULL);
8445 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
8446 "returned %d + errno %d\n", bret, WSAGetLastError());
8447
8448 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8449 if (overlapped.hEvent == NULL) {
8450 skip("could not create event object, errno = %d\n", GetLastError());
8451 goto end;
8452 }
8453
8454 overlapped.Internal = 0xdeadbeef;
8455 bret = pAcceptEx(listener, acceptor, buffer, 0,
8456 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8457 &bytesReturned, &overlapped);
8458 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8459 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8460
8461 overlapped.Internal = 0xdeadbeef;
8462 bret = pAcceptEx(listener, acceptor, buffer, 0,
8463 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8464 &bytesReturned, &overlapped);
8465 todo_wine ok(bret == FALSE && WSAGetLastError() == WSAEINVAL,
8466 "AcceptEx on already pending socket returned %d + errno %d\n", bret, WSAGetLastError());
8467 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8468 if (bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING) {
8469 /* We need to cancel this call, otherwise things fail */
8470 bret = CancelIo((HANDLE) listener);
8471 ok(bret, "Failed to cancel failed test. Bailing...\n");
8472 if (!bret) return;
8473 WaitForSingleObject(overlapped.hEvent, 0);
8474
8475 overlapped.Internal = 0xdeadbeef;
8476 bret = pAcceptEx(listener, acceptor, buffer, 0,
8477 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8478 &bytesReturned, &overlapped);
8479 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8480 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8481 }
8482
8483 iret = connect(acceptor, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8484 todo_wine ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL,
8485 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret, WSAGetLastError());
8486 if (!iret || (iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)) {
8487 /* We need to cancel this call, otherwise things fail */
8488 closesocket(acceptor);
8489 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8490 if (acceptor == INVALID_SOCKET) {
8491 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8492 goto end;
8493 }
8494
8495 bret = CancelIo((HANDLE) listener);
8496 ok(bret, "Failed to cancel failed test. Bailing...\n");
8497 if (!bret) return;
8498
8499 overlapped.Internal = 0xdeadbeef;
8500 bret = pAcceptEx(listener, acceptor, buffer, 0,
8501 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8502 &bytesReturned, &overlapped);
8503 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8504 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8505 }
8506
8507 overlapped.Internal = 0xdeadbeef;
8508 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8509 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8510
8511 dwret = WaitForSingleObject(overlapped.hEvent, INFINITE);
8512 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
8513 ok(overlapped.Internal == STATUS_SUCCESS, "got %08x\n", (ULONG)overlapped.Internal);
8514
8515 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8516 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
8517 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
8518
8519 closesocket(connector);
8520 connector = INVALID_SOCKET;
8521 closesocket(acceptor);
8522
8523 /* Test short reads */
8524
8525 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8526 if (acceptor == INVALID_SOCKET) {
8527 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8528 goto end;
8529 }
8530 connector = socket(AF_INET, SOCK_STREAM, 0);
8531 if (connector == INVALID_SOCKET) {
8532 skip("could not create connector socket, error %d\n", WSAGetLastError());
8533 goto end;
8534 }
8535 overlapped.Internal = 0xdeadbeef;
8536 bret = pAcceptEx(listener, acceptor, buffer, 2,
8537 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8538 &bytesReturned, &overlapped);
8539 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8540 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8541
8542 connect_time = 0xdeadbeef;
8543 optlen = sizeof(connect_time);
8544 iret = getsockopt(connector, SOL_SOCKET, SO_CONNECT_TIME, (char *)&connect_time, &optlen);
8545 ok(!iret, "getsockopt failed %d\n", WSAGetLastError());
8546 ok(connect_time == ~0u, "unexpected connect time %u\n", connect_time);
8547
8548 /* AcceptEx() still won't complete until we send data */
8549 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8550 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8551
8552 connect_time = 0xdeadbeef;
8553 optlen = sizeof(connect_time);
8554 iret = getsockopt(connector, SOL_SOCKET, SO_CONNECT_TIME, (char *)&connect_time, &optlen);
8555 ok(!iret, "getsockopt failed %d\n", WSAGetLastError());
8556 ok(connect_time < 0xdeadbeef, "unexpected connect time %u\n", connect_time);
8557
8558 dwret = WaitForSingleObject(overlapped.hEvent, 0);
8559 ok(dwret == WAIT_TIMEOUT, "Waiting for accept event timeout failed with %d + errno %d\n", dwret, GetLastError());
8560 ok(overlapped.Internal == STATUS_PENDING, "got %08x\n", (ULONG)overlapped.Internal);
8561
8562 iret = getsockname( connector, (struct sockaddr *)&peerAddress, &remoteSize);
8563 ok( !iret, "getsockname failed.\n");
8564
8565 /* AcceptEx() could complete any time now */
8566 iret = send(connector, buffer, 1, 0);
8567 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
8568
8569 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8570 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
8571 ok(overlapped.Internal == STATUS_SUCCESS, "got %08x\n", (ULONG)overlapped.Internal);
8572
8573 /* Check if the buffer from AcceptEx is decoded correctly */
8574 pGetAcceptExSockaddrs(buffer, 2, sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8575 (struct sockaddr **)&readBindAddress, &localSize,
8576 (struct sockaddr **)&readRemoteAddress, &remoteSize);
8577 strcpy( ipbuffer, inet_ntoa(readBindAddress->sin_addr));
8578 ok( readBindAddress->sin_addr.s_addr == bindAddress.sin_addr.s_addr,
8579 "Local socket address is different %s != %s\n",
8580 ipbuffer, inet_ntoa(bindAddress.sin_addr));
8581 ok( readBindAddress->sin_port == bindAddress.sin_port,
8582 "Local socket port is different: %d != %d\n",
8583 readBindAddress->sin_port, bindAddress.sin_port);
8584 strcpy( ipbuffer, inet_ntoa(readRemoteAddress->sin_addr));
8585 ok( readRemoteAddress->sin_addr.s_addr == peerAddress.sin_addr.s_addr,
8586 "Remote socket address is different %s != %s\n",
8587 ipbuffer, inet_ntoa(peerAddress.sin_addr));
8588 ok( readRemoteAddress->sin_port == peerAddress.sin_port,
8589 "Remote socket port is different: %d != %d\n",
8590 readRemoteAddress->sin_port, peerAddress.sin_port);
8591
8592 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8593 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
8594 ok(bytesReturned == 1, "bytesReturned isn't supposed to be %d\n", bytesReturned);
8595
8596 closesocket(connector);
8597 connector = INVALID_SOCKET;
8598 closesocket(acceptor);
8599
8600 /* Test CF_DEFER & AcceptEx interaction */
8601
8602 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8603 if (acceptor == INVALID_SOCKET) {
8604 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8605 goto end;
8606 }
8607 connector = socket(AF_INET, SOCK_STREAM, 0);
8608 if (connector == INVALID_SOCKET) {
8609 skip("could not create connector socket, error %d\n", WSAGetLastError());
8610 goto end;
8611 }
8612 connector2 = socket(AF_INET, SOCK_STREAM, 0);
8613 if (connector == INVALID_SOCKET) {
8614 skip("could not create connector socket, error %d\n", WSAGetLastError());
8615 goto end;
8616 }
8617
8618 if (set_blocking(connector, FALSE)) {
8619 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8620 goto end;
8621 }
8622
8623 if (set_blocking(connector2, FALSE)) {
8624 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8625 goto end;
8626 }
8627
8628 /* Connect socket #1 */
8629 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8630 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8631
8632 FD_ZERO ( &fds_accept );
8633 FD_ZERO ( &fds_send );
8634
8635 FD_SET ( listener, &fds_accept );
8636 FD_SET ( connector, &fds_send );
8637
8638 buffer[0] = '0';
8639 got = 0;
8640 conn1 = 0;
8641
8642 for (i = 0; i < 4000; ++i)
8643 {
8644 fd_set fds_openaccept = fds_accept, fds_opensend = fds_send;
8645
8646 wsa_ok ( ( select ( 0, &fds_openaccept, &fds_opensend, NULL, &timeout ) ), SOCKET_ERROR !=,
8647 "acceptex test(%d): could not select on socket, errno %d\n" );
8648
8649 /* check for incoming requests */
8650 if ( FD_ISSET ( listener, &fds_openaccept ) ) {
8651 got++;
8652 if (got == 1) {
8653 SOCKET tmp = WSAAccept(listener, NULL, NULL, (LPCONDITIONPROC) AlwaysDeferConditionFunc, 0);
8654 ok(tmp == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
8655 bret = pAcceptEx(listener, acceptor, buffer, 0,
8656 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8657 &bytesReturned, &overlapped);
8658 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8659 }
8660 else if (got == 2) {
8661 /* this should be socket #2 */
8662 SOCKET tmp = accept(listener, NULL, NULL);
8663 ok(tmp != INVALID_SOCKET, "accept failed %d\n", WSAGetLastError());
8664 closesocket(tmp);
8665 }
8666 else {
8667 ok(FALSE, "Got more than 2 connections?\n");
8668 }
8669 }
8670 if ( conn1 && FD_ISSET ( connector2, &fds_opensend ) ) {
8671 /* Send data on second socket, and stop */
8672 send(connector2, "2", 1, 0);
8673 FD_CLR ( connector2, &fds_send );
8674
8675 break;
8676 }
8677 if ( FD_ISSET ( connector, &fds_opensend ) ) {
8678 /* Once #1 is connected, allow #2 to connect */
8679 conn1 = 1;
8680
8681 send(connector, "1", 1, 0);
8682 FD_CLR ( connector, &fds_send );
8683
8684 iret = connect(connector2, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8685 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8686 FD_SET ( connector2, &fds_send );
8687 }
8688 }
8689
8690 ok (got == 2 || broken(got == 1) /* NT4 */,
8691 "Did not get both connections, got %d\n", got);
8692
8693 dwret = WaitForSingleObject(overlapped.hEvent, 0);
8694 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
8695
8696 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8697 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
8698 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
8699
8700 set_blocking(acceptor, TRUE);
8701 iret = recv( acceptor, buffer, 2, 0);
8702 ok(iret == 1, "Failed to get data, %d, errno: %d\n", iret, WSAGetLastError());
8703
8704 ok(buffer[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer[0]);
8705
8706 closesocket(connector);
8707 connector = INVALID_SOCKET;
8708 closesocket(acceptor);
8709
8710 /* clean up in case of failures */
8711 while ((acceptor = accept(listener, NULL, NULL)) != INVALID_SOCKET)
8712 closesocket(acceptor);
8713
8714 /* Disconnect during receive? */
8715
8716 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8717 if (acceptor == INVALID_SOCKET) {
8718 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8719 goto end;
8720 }
8721 connector = socket(AF_INET, SOCK_STREAM, 0);
8722 if (connector == INVALID_SOCKET) {
8723 skip("could not create connector socket, error %d\n", WSAGetLastError());
8724 goto end;
8725 }
8726 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8727 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8728 &bytesReturned, &overlapped);
8729 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8730
8731 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8732 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
8733
8734 closesocket(connector);
8735 connector = INVALID_SOCKET;
8736
8737 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8738 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
8739
8740 bytesReturned = 123456;
8741 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8742 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
8743 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
8744
8745 closesocket(acceptor);
8746
8747 /* Test closing with pending requests */
8748
8749 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8750 if (acceptor == INVALID_SOCKET) {
8751 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8752 goto end;
8753 }
8754 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8755 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8756 &bytesReturned, &overlapped);
8757 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8758
8759 closesocket(acceptor);
8760
8761 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8762 todo_wine ok(dwret == WAIT_OBJECT_0,
8763 "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
8764
8765 if (dwret != WAIT_TIMEOUT) {
8766 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8767 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
8768 }
8769 else {
8770 bret = CancelIo((HANDLE) listener);
8771 ok(bret, "Failed to cancel failed test. Bailing...\n");
8772 if (!bret) return;
8773 WaitForSingleObject(overlapped.hEvent, 0);
8774 }
8775
8776 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8777 if (acceptor == INVALID_SOCKET) {
8778 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8779 goto end;
8780 }
8781 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8782 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8783 &bytesReturned, &overlapped);
8784 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8785
8786 CancelIo((HANDLE) acceptor);
8787
8788 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8789 ok(dwret == WAIT_TIMEOUT, "Waiting for timeout failed with %d + errno %d\n", dwret, GetLastError());
8790
8791 closesocket(acceptor);
8792
8793 acceptor = socket(AF_INET, SOCK_STREAM, 0);
8794 if (acceptor == INVALID_SOCKET) {
8795 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8796 goto end;
8797 }
8798 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
8799 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8800 &bytesReturned, &overlapped);
8801 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
8802
8803 closesocket(listener);
8804 listener = INVALID_SOCKET;
8805
8806 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
8807 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
8808
8809 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
8810 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
8811
8812 end:
8813 if (overlapped.hEvent)
8814 WSACloseEvent(overlapped.hEvent);
8815 if (listener != INVALID_SOCKET)
8816 closesocket(listener);
8817 if (acceptor != INVALID_SOCKET)
8818 closesocket(acceptor);
8819 if (connector != INVALID_SOCKET)
8820 closesocket(connector);
8821 if (connector2 != INVALID_SOCKET)
8822 closesocket(connector2);
8823 }
8824
8825 static void test_DisconnectEx(void)
8826 {
8827 SOCKET listener, acceptor, connector;
8828 LPFN_DISCONNECTEX pDisconnectEx;
8829 GUID disconnectExGuid = WSAID_DISCONNECTEX;
8830 struct sockaddr_in address;
8831 DWORD num_bytes, flags;
8832 OVERLAPPED overlapped;
8833 int addrlen, iret;
8834 BOOL bret;
8835
8836 connector = socket(AF_INET, SOCK_STREAM, 0);
8837 ok(connector != INVALID_SOCKET, "failed to create connector socket, error %d\n", WSAGetLastError());
8838
8839 iret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &disconnectExGuid, sizeof(disconnectExGuid),
8840 &pDisconnectEx, sizeof(pDisconnectEx), &num_bytes, NULL, NULL);
8841 if (iret)
8842 {
8843 win_skip("WSAIoctl failed to get DisconnectEx, error %d\n", WSAGetLastError());
8844 closesocket(connector);
8845 return;
8846 }
8847
8848 listener = socket(AF_INET, SOCK_STREAM, 0);
8849 ok(listener != INVALID_SOCKET, "failed to create listener socket, error %d\n", WSAGetLastError());
8850
8851 memset(&address, 0, sizeof(address));
8852 address.sin_family = AF_INET;
8853 address.sin_addr.s_addr = inet_addr("127.0.0.1");
8854 iret = bind(listener, (struct sockaddr *)&address, sizeof(address));
8855 ok(iret == 0, "failed to bind, error %d\n", WSAGetLastError());
8856
8857 addrlen = sizeof(address);
8858 iret = getsockname(listener, (struct sockaddr *)&address, &addrlen);
8859 ok(iret == 0, "failed to lookup bind address, error %d\n", WSAGetLastError());
8860
8861 iret = listen(listener, 1);
8862 ok(iret == 0, "failed to listen, error %d\n", WSAGetLastError());
8863
8864 set_blocking(listener, TRUE);
8865
8866 memset(&overlapped, 0, sizeof(overlapped));
8867 bret = pDisconnectEx(INVALID_SOCKET, &overlapped, 0, 0);
8868 ok(bret == FALSE, "DisconnectEx unexpectedly succeeded\n");
8869 ok(WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %d\n", WSAGetLastError());
8870
8871 memset(&overlapped, 0, sizeof(overlapped));
8872 bret = pDisconnectEx(connector, &overlapped, 0, 0);
8873 ok(bret == FALSE, "DisconnectEx unexpectedly succeeded\n");
8874 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "expected WSAENOTCONN, got %d\n", WSAGetLastError());
8875
8876 iret = connect(connector, (struct sockaddr *)&address, addrlen);
8877 ok(iret == 0, "failed to connect, error %d\n", WSAGetLastError());
8878
8879 acceptor = accept(listener, NULL, NULL);
8880 ok(acceptor != INVALID_SOCKET, "could not accept socket, error %d\n", WSAGetLastError());
8881
8882 memset(&overlapped, 0, sizeof(overlapped));
8883 overlapped.hEvent = WSACreateEvent();
8884 ok(overlapped.hEvent != WSA_INVALID_EVENT, "WSACreateEvent failed, error %d\n", WSAGetLastError());
8885 bret = pDisconnectEx(connector, &overlapped, 0, 0);
8886 if (bret)
8887 ok(overlapped.Internal == STATUS_PENDING, "expected STATUS_PENDING, got %08lx\n", overlapped.Internal);
8888 else if (WSAGetLastError() == ERROR_IO_PENDING)
8889 bret = WSAGetOverlappedResult(connector, &overlapped, &num_bytes, TRUE, &flags);
8890 ok(bret, "DisconnectEx failed, error %d\n", WSAGetLastError());
8891 WSACloseEvent(overlapped.hEvent);
8892
8893 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8894 ok(iret != 0, "connect unexpectedly succeeded\n");
8895 ok(WSAGetLastError() == WSAEISCONN, "expected WSAEISCONN, got %d\n", WSAGetLastError());
8896
8897 closesocket(acceptor);
8898 closesocket(connector);
8899
8900 connector = socket(AF_INET, SOCK_STREAM, 0);
8901 ok(connector != INVALID_SOCKET, "failed to create connector socket, error %d\n", WSAGetLastError());
8902
8903 iret = connect(connector, (struct sockaddr *)&address, addrlen);
8904 ok(iret == 0, "failed to connect, error %d\n", WSAGetLastError());
8905
8906 acceptor = accept(listener, NULL, NULL);
8907 ok(acceptor != INVALID_SOCKET, "could not accept socket, error %d\n", WSAGetLastError());
8908
8909 bret = pDisconnectEx(connector, NULL, 0, 0);
8910 ok(bret, "DisconnectEx failed, error %d\n", WSAGetLastError());
8911
8912 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
8913 ok(iret != 0, "connect unexpectedly succeeded\n");
8914 ok(WSAGetLastError() == WSAEISCONN, "expected WSAEISCONN, got %d\n", WSAGetLastError());
8915
8916 closesocket(acceptor);
8917 closesocket(connector);
8918 closesocket(listener);
8919 }
8920
8921 #define compare_file(h,s,o) compare_file2(h,s,o,__FILE__,__LINE__)
8922
8923 static void compare_file2(HANDLE handle, SOCKET sock, int offset, const char *file, int line)
8924 {
8925 char buf1[256], buf2[256];
8926 BOOL success;
8927 int i = 0;
8928
8929 SetFilePointer(handle, offset, NULL, FILE_BEGIN);
8930 while (1)
8931 {
8932 DWORD n1 = 0, n2 = 0;
8933
8934 success = ReadFile(handle, buf1, sizeof(buf1), &n1, NULL);
8935 ok_(file,line)(success, "Failed to read from file.\n");
8936 if (success && n1 == 0)
8937 break;
8938 else if(!success)
8939 return;
8940 n2 = recv(sock, buf2, n1, 0);
8941 ok_(file,line)(n1 == n2, "Block %d size mismatch (%d != %d)\n", i, n1, n2);
8942 ok_(file,line)(memcmp(buf1, buf2, n2) == 0, "Block %d failed\n", i);
8943 i++;
8944 }
8945 }
8946
8947 static void test_TransmitFile(void)
8948 {
8949 DWORD num_bytes, err, file_size, total_sent;
8950 GUID transmitFileGuid = WSAID_TRANSMITFILE;
8951 LPFN_TRANSMITFILE pTransmitFile = NULL;
8952 HANDLE file = INVALID_HANDLE_VALUE;
8953 char header_msg[] = "hello world";
8954 char footer_msg[] = "goodbye!!!";
8955 char system_ini_path[MAX_PATH];
8956 struct sockaddr_in bindAddress;
8957 TRANSMIT_FILE_BUFFERS buffers;
8958 SOCKET client, server, dest;
8959 WSAOVERLAPPED ov;
8960 char buf[256];
8961 int iret, len;
8962 BOOL bret;
8963
8964 memset( &ov, 0, sizeof(ov) );
8965
8966 /* Setup sockets for testing TransmitFile */
8967 client = socket(AF_INET, SOCK_STREAM, 0);
8968 server = socket(AF_INET, SOCK_STREAM, 0);
8969 if (client == INVALID_SOCKET || server == INVALID_SOCKET)
8970 {
8971 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8972 goto cleanup;
8973 }
8974 iret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &transmitFileGuid, sizeof(transmitFileGuid),
8975 &pTransmitFile, sizeof(pTransmitFile), &num_bytes, NULL, NULL);
8976 if (iret)
8977 {
8978 skip("WSAIoctl failed to get TransmitFile with ret %d + errno %d\n", iret, WSAGetLastError());
8979 goto cleanup;
8980 }
8981 GetSystemWindowsDirectoryA(system_ini_path, MAX_PATH );
8982 strcat(system_ini_path, "\\system.ini");
8983 file = CreateFileA(system_ini_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0x0, NULL);
8984 if (file == INVALID_HANDLE_VALUE)
8985 {
8986 skip("Unable to open a file to transmit.\n");
8987 goto cleanup;
8988 }
8989 file_size = GetFileSize(file, NULL);
8990
8991 /* Test TransmitFile with an invalid socket */
8992 bret = pTransmitFile(INVALID_SOCKET, file, 0, 0, NULL, NULL, 0);
8993 err = WSAGetLastError();
8994 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8995 ok(err == WSAENOTSOCK, "TransmitFile triggered unexpected errno (%d != %d)\n", err, WSAENOTSOCK);
8996
8997 /* Test a bogus TransmitFile without a connected socket */
8998 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, TF_REUSE_SOCKET);
8999 err = WSAGetLastError();
9000 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9001 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%d != %d)\n", err, WSAENOTCONN);
9002
9003 /* Setup a properly connected socket for transfers */
9004 memset(&bindAddress, 0, sizeof(bindAddress));
9005 bindAddress.sin_family = AF_INET;
9006 bindAddress.sin_port = htons(SERVERPORT+1);
9007 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
9008 iret = bind(server, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9009 if (iret != 0)
9010 {
9011 skip("failed to bind(), error %d\n", WSAGetLastError());
9012 goto cleanup;
9013 }
9014 iret = listen(server, 1);
9015 if (iret != 0)
9016 {
9017 skip("failed to listen(), error %d\n", WSAGetLastError());
9018 goto cleanup;
9019 }
9020 iret = connect(client, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9021 if (iret != 0)
9022 {
9023 skip("failed to connect(), error %d\n", WSAGetLastError());
9024 goto cleanup;
9025 }
9026 len = sizeof(bindAddress);
9027 dest = accept(server, (struct sockaddr*)&bindAddress, &len);
9028 if (dest == INVALID_SOCKET)
9029 {
9030 skip("failed to accept(), error %d\n", WSAGetLastError());
9031 goto cleanup;
9032 }
9033 if (set_blocking(dest, FALSE))
9034 {
9035 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
9036 goto cleanup;
9037 }
9038
9039 /* Test TransmitFile with no possible buffer */
9040 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
9041 ok(bret, "TransmitFile failed unexpectedly.\n");
9042 iret = recv(dest, buf, sizeof(buf), 0);
9043 ok(iret == -1, "Returned an unexpected buffer from TransmitFile (%d != -1).\n", iret);
9044
9045 /* Test TransmitFile with only buffer data */
9046 buffers.Head = &header_msg[0];
9047 buffers.HeadLength = sizeof(header_msg);
9048 buffers.Tail = &footer_msg[0];
9049 buffers.TailLength = sizeof(footer_msg);
9050 bret = pTransmitFile(client, NULL, 0, 0, NULL, &buffers, 0);
9051 ok(bret, "TransmitFile failed unexpectedly.\n");
9052 iret = recv(dest, buf, sizeof(buf), 0);
9053 ok(iret == sizeof(header_msg)+sizeof(footer_msg),
9054 "Returned an unexpected buffer from TransmitFile: %d\n", iret );
9055 ok(memcmp(&buf[0], &header_msg[0], sizeof(header_msg)) == 0,
9056 "TransmitFile header buffer did not match!\n");
9057 ok(memcmp(&buf[sizeof(header_msg)], &footer_msg[0], sizeof(footer_msg)) == 0,
9058 "TransmitFile footer buffer did not match!\n");
9059
9060 /* Test TransmitFile with only file data */
9061 bret = pTransmitFile(client, file, 0, 0, NULL, NULL, 0);
9062 ok(bret, "TransmitFile failed unexpectedly.\n");
9063 compare_file(file, dest, 0);
9064
9065 /* Test TransmitFile with both file and buffer data */
9066 buffers.Head = &header_msg[0];
9067 buffers.HeadLength = sizeof(header_msg);
9068 buffers.Tail = &footer_msg[0];
9069 buffers.TailLength = sizeof(footer_msg);
9070 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9071 bret = pTransmitFile(client, file, 0, 0, NULL, &buffers, 0);
9072 ok(bret, "TransmitFile failed unexpectedly.\n");
9073 iret = recv(dest, buf, sizeof(header_msg), 0);
9074 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)) == 0,
9075 "TransmitFile header buffer did not match!\n");
9076 compare_file(file, dest, 0);
9077 iret = recv(dest, buf, sizeof(footer_msg), 0);
9078 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)) == 0,
9079 "TransmitFile footer buffer did not match!\n");
9080
9081 /* Test overlapped TransmitFile */
9082 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
9083 if (ov.hEvent == INVALID_HANDLE_VALUE)
9084 {
9085 skip("Could not create event object, some tests will be skipped. errno = %d\n",
9086 GetLastError());
9087 goto cleanup;
9088 }
9089 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9090 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
9091 err = WSAGetLastError();
9092 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9093 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%d != %d)\n",
9094 err, ERROR_IO_PENDING);
9095 iret = WaitForSingleObject(ov.hEvent, 2000);
9096 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
9097 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
9098 ok(total_sent == file_size,
9099 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
9100 total_sent, file_size);
9101 compare_file(file, dest, 0);
9102
9103 /* Test overlapped TransmitFile w/ start offset */
9104 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
9105 if (ov.hEvent == INVALID_HANDLE_VALUE)
9106 {
9107 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
9108 goto cleanup;
9109 }
9110 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9111 ov.Offset = 10;
9112 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
9113 err = WSAGetLastError();
9114 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9115 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%d != %d)\n", err, ERROR_IO_PENDING);
9116 iret = WaitForSingleObject(ov.hEvent, 2000);
9117 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
9118 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
9119 ok(total_sent == (file_size - ov.Offset),
9120 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
9121 total_sent, file_size - ov.Offset);
9122 compare_file(file, dest, ov.Offset);
9123
9124 /* Test overlapped TransmitFile w/ file and buffer data */
9125 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
9126 if (ov.hEvent == INVALID_HANDLE_VALUE)
9127 {
9128 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
9129 goto cleanup;
9130 }
9131 buffers.Head = &header_msg[0];
9132 buffers.HeadLength = sizeof(header_msg);
9133 buffers.Tail = &footer_msg[0];
9134 buffers.TailLength = sizeof(footer_msg);
9135 SetFilePointer(file, 0, NULL, FILE_BEGIN);
9136 ov.Offset = 0;
9137 bret = pTransmitFile(client, file, 0, 0, &ov, &buffers, 0);
9138 err = WSAGetLastError();
9139 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9140 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%d != %d)\n", err, ERROR_IO_PENDING);
9141 iret = WaitForSingleObject(ov.hEvent, 2000);
9142 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
9143 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
9144 ok(total_sent == (file_size + buffers.HeadLength + buffers.TailLength),
9145 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
9146 total_sent, file_size + buffers.HeadLength + buffers.TailLength);
9147 iret = recv(dest, buf, sizeof(header_msg), 0);
9148 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)) == 0,
9149 "TransmitFile header buffer did not match!\n");
9150 compare_file(file, dest, 0);
9151 iret = recv(dest, buf, sizeof(footer_msg), 0);
9152 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)) == 0,
9153 "TransmitFile footer buffer did not match!\n");
9154
9155 /* Test TransmitFile with a UDP datagram socket */
9156 closesocket(client);
9157 client = socket(AF_INET, SOCK_DGRAM, 0);
9158 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
9159 err = WSAGetLastError();
9160 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
9161 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%d != %d)\n", err, WSAENOTCONN);
9162
9163 cleanup:
9164 CloseHandle(file);
9165 CloseHandle(ov.hEvent);
9166 closesocket(client);
9167 closesocket(server);
9168 }
9169
9170 static void test_getpeername(void)
9171 {
9172 SOCKET sock;
9173 struct sockaddr_in sa, sa_out;
9174 SOCKADDR_STORAGE ss;
9175 int sa_len;
9176 const char buf[] = "hello world";
9177 int ret;
9178
9179 /* Test the parameter validation order. */
9180 ret = getpeername(INVALID_SOCKET, NULL, NULL);
9181 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9182 ok(WSAGetLastError() == WSAENOTSOCK,
9183 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
9184
9185 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
9186 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
9187 if (sock == INVALID_SOCKET)
9188 {
9189 skip("Socket creation failed with %d\n", WSAGetLastError());
9190 return;
9191 }
9192
9193 ret = getpeername(sock, NULL, NULL);
9194 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9195 ok(WSAGetLastError() == WSAENOTCONN,
9196 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
9197
9198 memset(&sa, 0, sizeof(sa));
9199 sa.sin_family = AF_INET;
9200 sa.sin_port = htons(139);
9201 sa.sin_addr.s_addr = inet_addr("127.0.0.1");
9202
9203 /* sendto does not change a socket's connection state. */
9204 ret = sendto(sock, buf, sizeof(buf), 0, (struct sockaddr*)&sa, sizeof(sa));
9205 ok(ret != SOCKET_ERROR,
9206 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
9207
9208 ret = getpeername(sock, NULL, NULL);
9209 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9210 ok(WSAGetLastError() == WSAENOTCONN,
9211 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
9212
9213 ret = connect(sock, (struct sockaddr*)&sa, sizeof(sa));
9214 ok(ret == 0,
9215 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
9216
9217 ret = getpeername(sock, NULL, NULL);
9218 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9219 ok(WSAGetLastError() == WSAEFAULT,
9220 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9221
9222 /* Test crashes on Wine. */
9223 if (0)
9224 {
9225 ret = getpeername(sock, (void*)0xdeadbeef, (void*)0xcafebabe);
9226 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
9227 ok(WSAGetLastError() == WSAEFAULT,
9228 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9229 }
9230
9231 ret = getpeername(sock, (struct sockaddr*)&sa_out, NULL);
9232 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
9233 ok(WSAGetLastError() == WSAEFAULT,
9234 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9235
9236 sa_len = 0;
9237 ret = getpeername(sock, NULL, &sa_len);
9238 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
9239 ok(WSAGetLastError() == WSAEFAULT,
9240 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9241 ok(!sa_len, "got %d\n", sa_len);
9242
9243 sa_len = 0;
9244 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
9245 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
9246 ok(WSAGetLastError() == WSAEFAULT,
9247 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
9248 ok(!sa_len, "got %d\n", sa_len);
9249
9250 sa_len = sizeof(ss);
9251 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
9252 ok(ret == 0, "Expected getpeername to return 0, got %d\n", ret);
9253 ok(!memcmp(&sa, &ss, sizeof(sa)),
9254 "Expected the returned structure to be identical to the connect structure\n");
9255 ok(sa_len == sizeof(sa), "got %d\n", sa_len);
9256
9257 closesocket(sock);
9258 }
9259
9260 static void test_sioRoutingInterfaceQuery(void)
9261 {
9262 int ret;
9263 SOCKET sock;
9264 SOCKADDR_IN sin = { 0 }, sout = { 0 };
9265 DWORD bytesReturned;
9266
9267 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
9268 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
9269 if (sock == INVALID_SOCKET)
9270 {
9271 skip("Socket creation failed with %d\n", WSAGetLastError());
9272 return;
9273 }
9274 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, NULL, 0, NULL, 0, NULL,
9275 NULL, NULL);
9276 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
9277 "expected WSAEFAULT, got %d\n", WSAGetLastError());
9278 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
9279 NULL, 0, NULL, NULL, NULL);
9280 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
9281 "expected WSAEFAULT, got %d\n", WSAGetLastError());
9282 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
9283 NULL, 0, &bytesReturned, NULL, NULL);
9284 todo_wine ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEAFNOSUPPORT,
9285 "expected WSAEAFNOSUPPORT, got %d\n", WSAGetLastError());
9286 sin.sin_family = AF_INET;
9287 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
9288 NULL, 0, &bytesReturned, NULL, NULL);
9289 todo_wine ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL,
9290 "expected WSAEINVAL, got %d\n", WSAGetLastError());
9291 sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
9292 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
9293 NULL, 0, &bytesReturned, NULL, NULL);
9294 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
9295 "expected WSAEFAULT, got %d\n", WSAGetLastError());
9296 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
9297 &sout, sizeof(sout), &bytesReturned, NULL, NULL);
9298 ok(!ret, "WSAIoctl failed: %d\n", WSAGetLastError());
9299 ok(sout.sin_family == AF_INET, "expected AF_INET, got %d\n", sout.sin_family);
9300 /* We expect the source address to be INADDR_LOOPBACK as well, but
9301 * there's no guarantee that a route to the loopback address exists,
9302 * so rather than introduce spurious test failures we do not test the
9303 * source address.
9304 */
9305 closesocket(sock);
9306 }
9307
9308 static void test_sioAddressListChange(void)
9309 {
9310 struct sockaddr_in bindAddress;
9311 struct in_addr net_address;
9312 WSAOVERLAPPED overlapped, *olp;
9313 struct hostent *h;
9314 DWORD num_bytes, error, tick;
9315 SOCKET sock, sock2, sock3;
9316 WSAEVENT event2, event3;
9317 HANDLE io_port;
9318 ULONG_PTR key;
9319 int acount;
9320 BOOL bret;
9321 int ret;
9322
9323 /* Use gethostbyname to find the list of local network interfaces */
9324 h = gethostbyname("");
9325 if (!h)
9326 {
9327 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, gethostbyname failed with %u\n",
9328 WSAGetLastError());
9329 return;
9330 }
9331 for (acount = 0; h->h_addr_list[acount]; acount++);
9332 if (acount == 0)
9333 {
9334 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
9335 return;
9336 }
9337
9338 net_address.s_addr = *(ULONG *) h->h_addr_list[0];
9339
9340 sock = socket(AF_INET, 0, IPPROTO_TCP);
9341 ok(sock != INVALID_SOCKET, "socket() failed\n");
9342
9343 memset(&bindAddress, 0, sizeof(bindAddress));
9344 bindAddress.sin_family = AF_INET;
9345 bindAddress.sin_addr.s_addr = net_address.s_addr;
9346 SetLastError(0xdeadbeef);
9347 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9348 ok (!ret, "bind() failed with error %d\n", GetLastError());
9349 set_blocking(sock, FALSE);
9350
9351 memset(&overlapped, 0, sizeof(overlapped));
9352 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9353 SetLastError(0xdeadbeef);
9354 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
9355 error = GetLastError();
9356 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error);
9357 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%x\n", error);
9358
9359 CloseHandle(overlapped.hEvent);
9360 closesocket(sock);
9361
9362 sock = socket(AF_INET, 0, IPPROTO_TCP);
9363 ok(sock != INVALID_SOCKET, "socket() failed\n");
9364
9365 SetLastError(0xdeadbeef);
9366 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9367 ok (!ret, "bind() failed with error %d\n", GetLastError());
9368 set_blocking(sock, TRUE);
9369
9370 memset(&overlapped, 0, sizeof(overlapped));
9371 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9372 SetLastError(0xdeadbeef);
9373 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
9374 error = GetLastError();
9375 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error);
9376 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%x\n", error);
9377
9378 CloseHandle(overlapped.hEvent);
9379 closesocket(sock);
9380
9381 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9382 ok(sock != INVALID_SOCKET, "socket() failed\n");
9383
9384 SetLastError(0xdeadbeef);
9385 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9386 ok (!ret, "bind() failed with error %d\n", GetLastError());
9387 set_blocking(sock, FALSE);
9388
9389 memset(&overlapped, 0, sizeof(overlapped));
9390 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9391 SetLastError(0xdeadbeef);
9392 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
9393 error = GetLastError();
9394 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error);
9395 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%x\n", error);
9396
9397 CloseHandle(overlapped.hEvent);
9398 closesocket(sock);
9399
9400 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9401 ok(sock != INVALID_SOCKET, "socket() failed\n");
9402
9403 SetLastError(0xdeadbeef);
9404 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9405 ok (!ret, "bind() failed with error %d\n", GetLastError());
9406 set_blocking(sock, TRUE);
9407
9408 memset(&overlapped, 0, sizeof(overlapped));
9409 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9410 SetLastError(0xdeadbeef);
9411 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
9412 error = GetLastError();
9413 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error);
9414 ok (error == ERROR_IO_PENDING, "expected 0x3e5, got 0x%x\n", error);
9415
9416 CloseHandle(overlapped.hEvent);
9417 closesocket(sock);
9418
9419 /* When the socket is overlapped non-blocking and the list change is requested without
9420 * an overlapped structure the error will be different. */
9421 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9422 ok(sock != INVALID_SOCKET, "socket() failed\n");
9423
9424 SetLastError(0xdeadbeef);
9425 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9426 ok (!ret, "bind() failed with error %d\n", GetLastError());
9427 set_blocking(sock, FALSE);
9428
9429 SetLastError(0xdeadbeef);
9430 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
9431 error = GetLastError();
9432 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %d\n", error);
9433 ok (error == WSAEWOULDBLOCK, "expected 10035, got %d\n", error);
9434
9435 io_port = CreateIoCompletionPort( (HANDLE)sock, NULL, 0, 0 );
9436 ok (io_port != NULL, "failed to create completion port %u\n", GetLastError());
9437
9438 set_blocking(sock, FALSE);
9439 memset(&overlapped, 0, sizeof(overlapped));
9440 SetLastError(0xdeadbeef);
9441 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
9442 error = GetLastError();
9443 ok (ret == SOCKET_ERROR, "WSAIoctl(SIO_ADDRESS_LIST_CHANGE) failed with error %u\n", error);
9444 ok (error == ERROR_IO_PENDING, "expected ERROR_IO_PENDING got %u\n", error);
9445
9446 olp = (WSAOVERLAPPED *)0xdeadbeef;
9447 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 0 );
9448 ok(!bret, "failed to get completion status %u\n", bret);
9449 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9450 ok(!olp, "Overlapped structure is at %p\n", olp);
9451
9452 closesocket(sock);
9453
9454 olp = (WSAOVERLAPPED *)0xdeadbeef;
9455 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 0 );
9456 ok(!bret, "failed to get completion status %u\n", bret);
9457 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %u\n", GetLastError());
9458 ok(olp == &overlapped, "Overlapped structure is at %p\n", olp);
9459
9460 CloseHandle(io_port);
9461
9462 /* Misuse of the API by using a blocking socket and not using an overlapped structure,
9463 * this leads to a hang forever. */
9464 if (0)
9465 {
9466 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9467
9468 SetLastError(0xdeadbeef);
9469 bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9470
9471 set_blocking(sock, TRUE);
9472 WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
9473 /* hang */
9474
9475 closesocket(sock);
9476 }
9477
9478 if (!winetest_interactive)
9479 {
9480 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
9481 return;
9482 }
9483
9484 /* Bind an overlapped socket to the first found network interface */
9485 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9486 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
9487 sock2 = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9488 ok(sock2 != INVALID_SOCKET, "Expected socket to return a valid socket\n");
9489 sock3 = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
9490 ok(sock3 != INVALID_SOCKET, "Expected socket to return a valid socket\n");
9491
9492 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9493 ok(!ret, "bind failed unexpectedly\n");
9494 ret = bind(sock2, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9495 ok(!ret, "bind failed unexpectedly\n");
9496 ret = bind(sock3, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9497 ok(!ret, "bind failed unexpectedly\n");
9498
9499 set_blocking(sock2, FALSE);
9500 set_blocking(sock3, FALSE);
9501
9502 /* Wait for address changes, request that the user connects/disconnects an interface */
9503 memset(&overlapped, 0, sizeof(overlapped));
9504 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
9505 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
9506 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
9507 ok(WSAGetLastError() == WSA_IO_PENDING, "Expected pending last error, got %d\n", WSAGetLastError());
9508
9509 ret = WSAIoctl(sock2, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, NULL, NULL);
9510 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
9511 ok(WSAGetLastError() == WSAEWOULDBLOCK, "Expected would block last error, got %d\n", WSAGetLastError());
9512
9513 event2 = WSACreateEvent();
9514 event3 = WSACreateEvent();
9515 ret = WSAEventSelect (sock2, event2, FD_ADDRESS_LIST_CHANGE);
9516 ok(!ret, "WSAEventSelect failed with %d\n", WSAGetLastError());
9517 /* sock3 did not request SIO_ADDRESS_LIST_CHANGE but it is trying to wait anyway */
9518 ret = WSAEventSelect (sock3, event3, FD_ADDRESS_LIST_CHANGE);
9519 ok(!ret, "WSAEventSelect failed with %d\n", WSAGetLastError());
9520
9521 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
9522 " change the ipv4 address of any of the local network interfaces (15 second timeout).\n");
9523 tick = GetTickCount();
9524 ret = WaitForSingleObject(overlapped.hEvent, 15000);
9525 ok(ret == WAIT_OBJECT_0, "failed to get overlapped event %u\n", ret);
9526
9527 ret = WaitForSingleObject(event2, 500);
9528 todo_wine
9529 ok(ret == WAIT_OBJECT_0, "failed to get change event %u\n", ret);
9530
9531 ret = WaitForSingleObject(event3, 500);
9532 ok(ret == WAIT_TIMEOUT, "unexpected change event\n");
9533
9534 trace("Spent %d ms waiting.\n", GetTickCount() - tick);
9535
9536 WSACloseEvent(event2);
9537 WSACloseEvent(event3);
9538
9539 closesocket(sock);
9540 closesocket(sock2);
9541 closesocket(sock3);
9542 }
9543
9544 static void test_synchronous_WSAIoctl(void)
9545 {
9546 HANDLE previous_port, io_port;
9547 WSAOVERLAPPED overlapped, *olp;
9548 SOCKET socket;
9549 ULONG on;
9550 ULONG_PTR key;
9551 DWORD num_bytes;
9552 BOOL ret;
9553 int res;
9554
9555 previous_port = CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 0 );
9556 ok( previous_port != NULL, "failed to create completion port %u\n", GetLastError() );
9557
9558 socket = WSASocketW( AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED );
9559 ok( socket != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError() );
9560
9561 io_port = CreateIoCompletionPort( (HANDLE)socket, previous_port, 0, 0 );
9562 ok( io_port != NULL, "failed to create completion port %u\n", GetLastError() );
9563
9564 on = 1;
9565 memset( &overlapped, 0, sizeof(overlapped) );
9566 res = WSAIoctl( socket, FIONBIO, &on, sizeof(on), NULL, 0, &num_bytes, &overlapped, NULL );
9567 ok( !res, "WSAIoctl failed %d\n", WSAGetLastError() );
9568
9569 ret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 10000 );
9570 ok( ret, "failed to get completion status %u\n", GetLastError() );
9571
9572 CloseHandle( io_port );
9573 closesocket( socket );
9574 CloseHandle( previous_port );
9575 }
9576
9577 #define WM_ASYNCCOMPLETE (WM_USER + 100)
9578 static HWND create_async_message_window(void)
9579 {
9580 static const char class_name[] = "ws2_32 async message window class";
9581
9582 WNDCLASSEXA wndclass;
9583 HWND hWnd;
9584
9585 wndclass.cbSize = sizeof(wndclass);
9586 wndclass.style = CS_HREDRAW | CS_VREDRAW;
9587 wndclass.lpfnWndProc = DefWindowProcA;
9588 wndclass.cbClsExtra = 0;
9589 wndclass.cbWndExtra = 0;
9590 wndclass.hInstance = GetModuleHandleA(NULL);
9591 wndclass.hIcon = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
9592 wndclass.hIconSm = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
9593 wndclass.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
9594 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
9595 wndclass.lpszClassName = class_name;
9596 wndclass.lpszMenuName = NULL;
9597
9598 RegisterClassExA(&wndclass);
9599
9600 hWnd = CreateWindowA(class_name, "ws2_32 async message window", WS_OVERLAPPEDWINDOW,
9601 0, 0, 500, 500, NULL, NULL, GetModuleHandleA(NULL), NULL);
9602 if (!hWnd)
9603 {
9604 ok(0, "failed to create window: %u\n", GetLastError());
9605 return NULL;
9606 }
9607
9608 return hWnd;
9609 }
9610
9611 static void wait_for_async_message(HWND hwnd, HANDLE handle)
9612 {
9613 BOOL ret;
9614 MSG msg;
9615
9616 while ((ret = GetMessageA(&msg, 0, 0, 0)) &&
9617 !(msg.hwnd == hwnd && msg.message == WM_ASYNCCOMPLETE))
9618 {
9619 TranslateMessage(&msg);
9620 DispatchMessageA(&msg);
9621 }
9622
9623 ok(ret, "did not expect WM_QUIT message\n");
9624 ok(msg.wParam == (WPARAM)handle, "expected wParam = %p, got %lx\n", handle, msg.wParam);
9625 }
9626
9627 static void test_WSAAsyncGetServByPort(void)
9628 {
9629 HWND hwnd = create_async_message_window();
9630 HANDLE ret;
9631 char buffer[MAXGETHOSTSTRUCT];
9632
9633 if (!hwnd)
9634 return;
9635
9636 /* FIXME: The asynchronous window messages should be tested. */
9637
9638 /* Parameters are not checked when initiating the asynchronous operation. */
9639 ret = WSAAsyncGetServByPort(NULL, 0, 0, NULL, NULL, 0);
9640 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
9641
9642 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, 0, NULL, NULL, 0);
9643 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
9644 wait_for_async_message(hwnd, ret);
9645
9646 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, htons(80), NULL, NULL, 0);
9647 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
9648 wait_for_async_message(hwnd, ret);
9649
9650 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, htons(80), NULL, buffer, MAXGETHOSTSTRUCT);
9651 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
9652 wait_for_async_message(hwnd, ret);
9653
9654 DestroyWindow(hwnd);
9655 }
9656
9657 static void test_WSAAsyncGetServByName(void)
9658 {
9659 HWND hwnd = create_async_message_window();
9660 HANDLE ret;
9661 char buffer[MAXGETHOSTSTRUCT];
9662
9663 if (!hwnd)
9664 return;
9665
9666 /* FIXME: The asynchronous window messages should be tested. */
9667
9668 /* Parameters are not checked when initiating the asynchronous operation. */
9669 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "", NULL, NULL, 0);
9670 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
9671 wait_for_async_message(hwnd, ret);
9672
9673 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "", "", buffer, MAXGETHOSTSTRUCT);
9674 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
9675 wait_for_async_message(hwnd, ret);
9676
9677 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "http", NULL, NULL, 0);
9678 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
9679 wait_for_async_message(hwnd, ret);
9680
9681 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "http", "tcp", buffer, MAXGETHOSTSTRUCT);
9682 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
9683 wait_for_async_message(hwnd, ret);
9684
9685 DestroyWindow(hwnd);
9686 }
9687
9688 /*
9689 * Provide consistent initialization for the AcceptEx IOCP tests.
9690 */
9691 static SOCKET setup_iocp_src(struct sockaddr_in *bindAddress)
9692 {
9693 SOCKET src, ret = INVALID_SOCKET;
9694 int iret, socklen;
9695
9696 src = socket(AF_INET, SOCK_STREAM, 0);
9697 if (src == INVALID_SOCKET)
9698 {
9699 skip("could not create listener socket, error %d\n", WSAGetLastError());
9700 goto end;
9701 }
9702
9703 memset(bindAddress, 0, sizeof(*bindAddress));
9704 bindAddress->sin_family = AF_INET;
9705 bindAddress->sin_addr.s_addr = inet_addr("127.0.0.1");
9706 iret = bind(src, (struct sockaddr*)bindAddress, sizeof(*bindAddress));
9707 if (iret != 0)
9708 {
9709 skip("failed to bind, error %d\n", WSAGetLastError());
9710 goto end;
9711 }
9712
9713 socklen = sizeof(*bindAddress);
9714 iret = getsockname(src, (struct sockaddr*)bindAddress, &socklen);
9715 if (iret != 0) {
9716 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
9717 goto end;
9718 }
9719
9720 if (set_blocking(src, FALSE))
9721 {
9722 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
9723 goto end;
9724 }
9725
9726 iret = listen(src, 5);
9727 if (iret != 0)
9728 {
9729 skip("listening failed, errno = %d\n", WSAGetLastError());
9730 goto end;
9731 }
9732
9733 ret = src;
9734 end:
9735 if (src != ret && ret == INVALID_SOCKET)
9736 closesocket(src);
9737 return ret;
9738 }
9739
9740 static void test_completion_port(void)
9741 {
9742 HANDLE previous_port, io_port;
9743 WSAOVERLAPPED ov, *olp;
9744 SOCKET src, dest, dup, connector = INVALID_SOCKET;
9745 WSAPROTOCOL_INFOA info;
9746 char buf[1024];
9747 WSABUF bufs;
9748 DWORD num_bytes, flags;
9749 struct linger ling;
9750 int iret;
9751 BOOL bret;
9752 ULONG_PTR key;
9753 struct sockaddr_in bindAddress;
9754 GUID acceptExGuid = WSAID_ACCEPTEX;
9755 LPFN_ACCEPTEX pAcceptEx = NULL;
9756 fd_set fds_recv;
9757
9758 memset(buf, 0, sizeof(buf));
9759 previous_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
9760 ok( previous_port != NULL, "Failed to create completion port %u\n", GetLastError());
9761
9762 memset(&ov, 0, sizeof(ov));
9763
9764 tcp_socketpair(&src, &dest);
9765 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
9766 {
9767 skip("failed to create sockets\n");
9768 goto end;
9769 }
9770
9771 bufs.len = sizeof(buf);
9772 bufs.buf = buf;
9773 flags = 0;
9774
9775 ling.l_onoff = 1;
9776 ling.l_linger = 0;
9777 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
9778 ok(!iret, "Failed to set linger %d\n", GetLastError());
9779
9780 io_port = CreateIoCompletionPort( (HANDLE)dest, previous_port, 125, 0 );
9781 ok(io_port != NULL, "Failed to create completion port %u\n", GetLastError());
9782
9783 SetLastError(0xdeadbeef);
9784
9785 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
9786 ok(iret == SOCKET_ERROR, "WSARecv returned %d\n", iret);
9787 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
9788
9789 Sleep(100);
9790
9791 closesocket(src);
9792 src = INVALID_SOCKET;
9793
9794 SetLastError(0xdeadbeef);
9795 key = 0xdeadbeef;
9796 num_bytes = 0xdeadbeef;
9797 olp = (WSAOVERLAPPED *)0xdeadbeef;
9798
9799 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
9800 todo_wine ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret);
9801 todo_wine ok(GetLastError() == ERROR_NETNAME_DELETED, "Last error was %d\n", GetLastError());
9802 ok(key == 125, "Key is %lu\n", key);
9803 ok(num_bytes == 0, "Number of bytes received is %u\n", num_bytes);
9804 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
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, 100);
9812 ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret );
9813 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9814 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9815 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9816 ok(!olp, "Overlapped structure is at %p\n", olp);
9817
9818 if (dest != INVALID_SOCKET)
9819 closesocket(dest);
9820
9821 memset(&ov, 0, sizeof(ov));
9822
9823 tcp_socketpair(&src, &dest);
9824 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
9825 {
9826 skip("failed to create sockets\n");
9827 goto end;
9828 }
9829
9830 bufs.len = sizeof(buf);
9831 bufs.buf = buf;
9832 flags = 0;
9833
9834 ling.l_onoff = 1;
9835 ling.l_linger = 0;
9836 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
9837 ok(!iret, "Failed to set linger %d\n", GetLastError());
9838
9839 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 125, 0);
9840 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9841
9842 set_blocking(dest, FALSE);
9843
9844 closesocket(src);
9845 src = INVALID_SOCKET;
9846
9847 Sleep(100);
9848
9849 num_bytes = 0xdeadbeef;
9850 SetLastError(0xdeadbeef);
9851
9852 iret = WSASend(dest, &bufs, 1, &num_bytes, 0, &ov, NULL);
9853 ok(iret == SOCKET_ERROR, "WSASend failed - %d\n", iret);
9854 ok(GetLastError() == WSAECONNRESET, "Last error was %d\n", GetLastError());
9855 ok(num_bytes == 0xdeadbeef, "Managed to send %d\n", num_bytes);
9856
9857 SetLastError(0xdeadbeef);
9858 key = 0xdeadbeef;
9859 num_bytes = 0xdeadbeef;
9860 olp = (WSAOVERLAPPED *)0xdeadbeef;
9861
9862 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9863 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
9864 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9865 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9866 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9867 ok(!olp, "Overlapped structure is at %p\n", olp);
9868
9869 if (dest != INVALID_SOCKET)
9870 closesocket(dest);
9871
9872 /* Test IOCP response on successful immediate read. */
9873 tcp_socketpair(&src, &dest);
9874 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
9875 {
9876 skip("failed to create sockets\n");
9877 goto end;
9878 }
9879
9880 bufs.len = sizeof(buf);
9881 bufs.buf = buf;
9882 flags = 0;
9883 SetLastError(0xdeadbeef);
9884
9885 iret = WSASend(src, &bufs, 1, &num_bytes, 0, &ov, NULL);
9886 ok(!iret, "WSASend failed - %d, last error %u\n", iret, GetLastError());
9887 ok(num_bytes == sizeof(buf), "Managed to send %d\n", num_bytes);
9888
9889 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 125, 0);
9890 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9891 set_blocking(dest, FALSE);
9892
9893 FD_ZERO(&fds_recv);
9894 FD_SET(dest, &fds_recv);
9895 select(dest + 1, &fds_recv, NULL, NULL, NULL);
9896
9897 num_bytes = 0xdeadbeef;
9898 flags = 0;
9899
9900 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
9901 ok(!iret, "WSARecv failed - %d, last error %u\n", iret, GetLastError());
9902 ok(num_bytes == sizeof(buf), "Managed to read %d\n", num_bytes);
9903
9904 SetLastError(0xdeadbeef);
9905 key = 0xdeadbeef;
9906 num_bytes = 0xdeadbeef;
9907 olp = (WSAOVERLAPPED *)0xdeadbeef;
9908
9909 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9910 ok(bret == TRUE, "failed to get completion status %u\n", bret);
9911 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9912 ok(key == 125, "Key is %lu\n", key);
9913 ok(num_bytes == sizeof(buf), "Number of bytes transferred is %u\n", num_bytes);
9914 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
9915
9916 /* Test IOCP response on graceful shutdown. */
9917 closesocket(src);
9918
9919 FD_ZERO(&fds_recv);
9920 FD_SET(dest, &fds_recv);
9921 select(dest + 1, &fds_recv, NULL, NULL, NULL);
9922
9923 num_bytes = 0xdeadbeef;
9924 flags = 0;
9925 memset(&ov, 0, sizeof(ov));
9926
9927 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
9928 ok(!iret, "WSARecv failed - %d, last error %u\n", iret, GetLastError());
9929 ok(!num_bytes, "Managed to read %d\n", num_bytes);
9930
9931 SetLastError(0xdeadbeef);
9932 key = 0xdeadbeef;
9933 num_bytes = 0xdeadbeef;
9934 olp = (WSAOVERLAPPED *)0xdeadbeef;
9935
9936 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9937 ok(bret == TRUE, "failed to get completion status %u\n", bret);
9938 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9939 ok(key == 125, "Key is %lu\n", key);
9940 ok(!num_bytes, "Number of bytes transferred is %u\n", num_bytes);
9941 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
9942
9943 closesocket(src);
9944 src = INVALID_SOCKET;
9945 closesocket(dest);
9946 dest = INVALID_SOCKET;
9947
9948 /* Test IOCP response on hard shutdown. This was the condition that triggered
9949 * a crash in an actual app (bug 38980). */
9950 tcp_socketpair(&src, &dest);
9951 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
9952 {
9953 skip("failed to create sockets\n");
9954 goto end;
9955 }
9956
9957 bufs.len = sizeof(buf);
9958 bufs.buf = buf;
9959 flags = 0;
9960 memset(&ov, 0, sizeof(ov));
9961
9962 ling.l_onoff = 1;
9963 ling.l_linger = 0;
9964 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
9965 ok(!iret, "Failed to set linger %d\n", GetLastError());
9966
9967 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 125, 0);
9968 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9969 set_blocking(dest, FALSE);
9970
9971 closesocket(src);
9972 src = INVALID_SOCKET;
9973
9974 FD_ZERO(&fds_recv);
9975 FD_SET(dest, &fds_recv);
9976 select(dest + 1, &fds_recv, NULL, NULL, NULL);
9977
9978 num_bytes = 0xdeadbeef;
9979 SetLastError(0xdeadbeef);
9980
9981 /* Somehow a hard shutdown doesn't work on my Linux box. It seems SO_LINGER is ignored. */
9982 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
9983 todo_wine ok(iret == SOCKET_ERROR, "WSARecv failed - %d\n", iret);
9984 todo_wine ok(GetLastError() == WSAECONNRESET, "Last error was %d\n", GetLastError());
9985 todo_wine ok(num_bytes == 0xdeadbeef, "Managed to read %d\n", num_bytes);
9986
9987 SetLastError(0xdeadbeef);
9988 key = 0xdeadbeef;
9989 num_bytes = 0xdeadbeef;
9990 olp = (WSAOVERLAPPED *)0xdeadbeef;
9991
9992 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9993 todo_wine ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
9994 todo_wine ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9995 todo_wine ok(key == 0xdeadbeef, "Key is %lu\n", key);
9996 todo_wine ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9997 todo_wine ok(!olp, "Overlapped structure is at %p\n", olp);
9998
9999 closesocket(dest);
10000
10001 /* Test reading from a non-connected socket, mostly because the above test is marked todo. */
10002 dest = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10003 ok(dest != INVALID_SOCKET, "socket() failed\n");
10004
10005 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 125, 0);
10006 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10007 set_blocking(dest, FALSE);
10008
10009 num_bytes = 0xdeadbeef;
10010 SetLastError(0xdeadbeef);
10011 memset(&ov, 0, sizeof(ov));
10012
10013 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
10014 ok(iret == SOCKET_ERROR, "WSARecv failed - %d\n", iret);
10015 ok(GetLastError() == WSAENOTCONN, "Last error was %d\n", GetLastError());
10016 ok(num_bytes == 0xdeadbeef, "Managed to read %d\n", num_bytes);
10017
10018 SetLastError(0xdeadbeef);
10019 key = 0xdeadbeef;
10020 num_bytes = 0xdeadbeef;
10021 olp = (WSAOVERLAPPED *)0xdeadbeef;
10022
10023 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10024 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
10025 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10026 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10027 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10028 ok(!olp, "Overlapped structure is at %p\n", olp);
10029
10030 num_bytes = 0xdeadbeef;
10031 closesocket(dest);
10032
10033 dest = socket(AF_INET, SOCK_STREAM, 0);
10034 if (dest == INVALID_SOCKET)
10035 {
10036 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
10037 goto end;
10038 }
10039
10040 iret = WSAIoctl(dest, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
10041 &pAcceptEx, sizeof(pAcceptEx), &num_bytes, NULL, NULL);
10042 if (iret)
10043 {
10044 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret, WSAGetLastError());
10045 goto end;
10046 }
10047
10048 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
10049
10050 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
10051 goto end;
10052
10053 SetLastError(0xdeadbeef);
10054
10055 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10056 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10057 &num_bytes, &ov);
10058 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10059 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
10060
10061 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
10062 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10063
10064 closesocket(src);
10065 src = INVALID_SOCKET;
10066
10067 SetLastError(0xdeadbeef);
10068 key = 0xdeadbeef;
10069 num_bytes = 0xdeadbeef;
10070 olp = (WSAOVERLAPPED *)0xdeadbeef;
10071
10072 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10073 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10074 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
10075 ok(key == 125, "Key is %lu\n", key);
10076 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
10077 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10078 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
10079
10080 SetLastError(0xdeadbeef);
10081 key = 0xdeadbeef;
10082 num_bytes = 0xdeadbeef;
10083 olp = (WSAOVERLAPPED *)0xdeadbeef;
10084 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10085 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10086 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10087 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10088 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10089 ok(!olp, "Overlapped structure is at %p\n", olp);
10090
10091 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
10092
10093 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
10094 goto end;
10095
10096 SetLastError(0xdeadbeef);
10097
10098 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
10099 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10100
10101 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10102 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10103 &num_bytes, &ov);
10104 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10105 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
10106
10107 closesocket(src);
10108 src = INVALID_SOCKET;
10109
10110 SetLastError(0xdeadbeef);
10111 key = 0xdeadbeef;
10112 num_bytes = 0xdeadbeef;
10113 olp = (WSAOVERLAPPED *)0xdeadbeef;
10114
10115 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10116 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10117 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
10118 ok(key == 125, "Key is %lu\n", key);
10119 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
10120 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10121 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
10122
10123 SetLastError(0xdeadbeef);
10124 key = 0xdeadbeef;
10125 num_bytes = 0xdeadbeef;
10126 olp = (WSAOVERLAPPED *)0xdeadbeef;
10127 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10128 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10129 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10130 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10131 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10132 ok(!olp, "Overlapped structure is at %p\n", olp);
10133
10134 /* Test IOCP with duplicated handle */
10135
10136 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
10137 goto end;
10138
10139 SetLastError(0xdeadbeef);
10140
10141 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
10142 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10143
10144 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10145 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10146 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10147
10148 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10149 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10150 &num_bytes, &ov);
10151 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10152 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
10153
10154 SetLastError(0xdeadbeef);
10155 key = 0xdeadbeef;
10156 num_bytes = 0xdeadbeef;
10157 olp = (WSAOVERLAPPED *)0xdeadbeef;
10158 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10159 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10160 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10161 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10162 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10163 ok(!olp, "Overlapped structure is at %p\n", olp);
10164
10165 closesocket(src);
10166 src = INVALID_SOCKET;
10167 closesocket(dup);
10168 dup = INVALID_SOCKET;
10169
10170 SetLastError(0xdeadbeef);
10171 key = 0xdeadbeef;
10172 num_bytes = 0xdeadbeef;
10173 olp = (WSAOVERLAPPED *)0xdeadbeef;
10174 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10175 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10176 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
10177 ok(key == 125, "Key is %lu\n", key);
10178 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
10179 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10180 ok(olp && olp->Internal == (ULONG)STATUS_CANCELLED, "Internal status is %lx\n", olp ? olp->Internal : 0);
10181
10182 SetLastError(0xdeadbeef);
10183 key = 0xdeadbeef;
10184 num_bytes = 0xdeadbeef;
10185 olp = (WSAOVERLAPPED *)0xdeadbeef;
10186 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10187 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10188 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10189 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10190 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10191 ok(!olp, "Overlapped structure is at %p\n", olp);
10192
10193 /* Test IOCP with duplicated handle (closing duplicated handle) */
10194
10195 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
10196 goto end;
10197
10198 SetLastError(0xdeadbeef);
10199
10200 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
10201 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10202
10203 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10204 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10205 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10206
10207 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10208 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10209 &num_bytes, &ov);
10210 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10211 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
10212
10213 closesocket(dup);
10214 dup = INVALID_SOCKET;
10215
10216 SetLastError(0xdeadbeef);
10217 key = 0xdeadbeef;
10218 num_bytes = 0xdeadbeef;
10219 olp = (WSAOVERLAPPED *)0xdeadbeef;
10220 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10221 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10222 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10223 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10224 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10225 ok(!olp, "Overlapped structure is at %p\n", olp);
10226
10227 SetLastError(0xdeadbeef);
10228 key = 0xdeadbeef;
10229 num_bytes = 0xdeadbeef;
10230 olp = (WSAOVERLAPPED *)0xdeadbeef;
10231 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10232 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10233 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10234 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10235 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10236 ok(!olp, "Overlapped structure is at %p\n", olp);
10237
10238 closesocket(src);
10239 src = INVALID_SOCKET;
10240
10241 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10242 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10243 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
10244 ok(key == 125, "Key is %lu\n", key);
10245 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
10246 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10247 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
10248
10249 SetLastError(0xdeadbeef);
10250 key = 0xdeadbeef;
10251 num_bytes = 0xdeadbeef;
10252 olp = (WSAOVERLAPPED *)0xdeadbeef;
10253 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10254 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10255 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10256 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10257 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10258 ok(!olp, "Overlapped structure is at %p\n", olp);
10259
10260 /* Test IOCP with duplicated handle (closing original handle) */
10261
10262 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
10263 goto end;
10264
10265 SetLastError(0xdeadbeef);
10266
10267 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
10268 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10269
10270 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
10271 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
10272 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
10273
10274 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10275 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10276 &num_bytes, &ov);
10277 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10278 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
10279
10280 closesocket(src);
10281 src = INVALID_SOCKET;
10282
10283 SetLastError(0xdeadbeef);
10284 key = 0xdeadbeef;
10285 num_bytes = 0xdeadbeef;
10286 olp = (WSAOVERLAPPED *)0xdeadbeef;
10287 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10288 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10289 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10290 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10291 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10292 ok(!olp, "Overlapped structure is at %p\n", olp);
10293
10294 closesocket(dup);
10295 dup = INVALID_SOCKET;
10296
10297 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10298 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10299 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
10300 ok(key == 125, "Key is %lu\n", key);
10301 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
10302 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10303 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
10304
10305 SetLastError(0xdeadbeef);
10306 key = 0xdeadbeef;
10307 num_bytes = 0xdeadbeef;
10308 olp = (WSAOVERLAPPED *)0xdeadbeef;
10309 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10310 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10311 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10312 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10313 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10314 ok(!olp, "Overlapped structure is at %p\n", olp);
10315
10316 /* Test IOCP without AcceptEx */
10317
10318 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
10319 goto end;
10320
10321 SetLastError(0xdeadbeef);
10322
10323 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
10324 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10325
10326 closesocket(src);
10327 src = INVALID_SOCKET;
10328
10329 SetLastError(0xdeadbeef);
10330 key = 0xdeadbeef;
10331 num_bytes = 0xdeadbeef;
10332 olp = (WSAOVERLAPPED *)0xdeadbeef;
10333 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10334 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10335 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10336 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10337 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10338 ok(!olp, "Overlapped structure is at %p\n", olp);
10339
10340 /* */
10341
10342 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
10343 goto end;
10344
10345 connector = socket(AF_INET, SOCK_STREAM, 0);
10346 if (connector == INVALID_SOCKET) {
10347 skip("could not create connector socket, error %d\n", WSAGetLastError());
10348 goto end;
10349 }
10350
10351 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
10352 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10353
10354 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
10355 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10356
10357 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10358 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10359 &num_bytes, &ov);
10360 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10361 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
10362
10363 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10364 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
10365
10366 closesocket(connector);
10367 connector = INVALID_SOCKET;
10368
10369 SetLastError(0xdeadbeef);
10370 key = 0xdeadbeef;
10371 num_bytes = 0xdeadbeef;
10372 olp = (WSAOVERLAPPED *)0xdeadbeef;
10373
10374 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10375 ok(bret == TRUE, "failed to get completion status %u\n", bret);
10376 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
10377 ok(key == 125, "Key is %lu\n", key);
10378 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
10379 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10380 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %lx\n", olp ? olp->Internal : 0);
10381
10382 SetLastError(0xdeadbeef);
10383 key = 0xdeadbeef;
10384 num_bytes = 0xdeadbeef;
10385 olp = (WSAOVERLAPPED *)0xdeadbeef;
10386 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10387 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10388 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10389 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10390 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10391 ok(!olp, "Overlapped structure is at %p\n", olp);
10392
10393 if (dest != INVALID_SOCKET)
10394 closesocket(dest);
10395 if (src != INVALID_SOCKET)
10396 closesocket(dest);
10397
10398 /* */
10399
10400 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
10401 goto end;
10402
10403 dest = socket(AF_INET, SOCK_STREAM, 0);
10404 if (dest == INVALID_SOCKET)
10405 {
10406 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
10407 goto end;
10408 }
10409
10410 connector = socket(AF_INET, SOCK_STREAM, 0);
10411 if (connector == INVALID_SOCKET) {
10412 skip("could not create connector socket, error %d\n", WSAGetLastError());
10413 goto end;
10414 }
10415
10416 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
10417 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10418
10419 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
10420 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10421
10422 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10423 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10424 &num_bytes, &ov);
10425 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10426 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
10427
10428 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10429 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
10430
10431 iret = send(connector, buf, 1, 0);
10432 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
10433
10434 Sleep(100);
10435
10436 closesocket(dest);
10437 dest = INVALID_SOCKET;
10438
10439 SetLastError(0xdeadbeef);
10440 key = 0xdeadbeef;
10441 num_bytes = 0xdeadbeef;
10442 olp = (WSAOVERLAPPED *)0xdeadbeef;
10443
10444 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10445 ok(bret == TRUE, "failed to get completion status %u\n", bret);
10446 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
10447 ok(key == 125, "Key is %lu\n", key);
10448 ok(num_bytes == 1, "Number of bytes transferred is %u\n", num_bytes);
10449 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10450 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %lx\n", olp ? olp->Internal : 0);
10451
10452 SetLastError(0xdeadbeef);
10453 key = 0xdeadbeef;
10454 num_bytes = 0xdeadbeef;
10455 olp = (WSAOVERLAPPED *)0xdeadbeef;
10456 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10457 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10458 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10459 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10460 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10461 ok(!olp, "Overlapped structure is at %p\n", olp);
10462
10463 if (src != INVALID_SOCKET)
10464 closesocket(src);
10465 if (connector != INVALID_SOCKET)
10466 closesocket(connector);
10467
10468 /* */
10469
10470 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
10471 goto end;
10472
10473 dest = socket(AF_INET, SOCK_STREAM, 0);
10474 if (dest == INVALID_SOCKET)
10475 {
10476 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
10477 goto end;
10478 }
10479
10480 connector = socket(AF_INET, SOCK_STREAM, 0);
10481 if (connector == INVALID_SOCKET) {
10482 skip("could not create connector socket, error %d\n", WSAGetLastError());
10483 goto end;
10484 }
10485
10486 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
10487 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10488
10489 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
10490 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
10491
10492 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
10493 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
10494 &num_bytes, &ov);
10495 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
10496 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
10497
10498 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
10499 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
10500
10501 closesocket(dest);
10502 dest = INVALID_SOCKET;
10503
10504 SetLastError(0xdeadbeef);
10505 key = 0xdeadbeef;
10506 num_bytes = 0xdeadbeef;
10507 olp = (WSAOVERLAPPED *)0xdeadbeef;
10508
10509 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
10510 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10511 todo_wine ok(GetLastError() == ERROR_NETNAME_DELETED ||
10512 GetLastError() == ERROR_OPERATION_ABORTED ||
10513 GetLastError() == ERROR_CONNECTION_ABORTED ||
10514 GetLastError() == ERROR_PIPE_NOT_CONNECTED /* win 2000 */,
10515 "Last error was %d\n", GetLastError());
10516 ok(key == 125, "Key is %lu\n", key);
10517 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
10518 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
10519 todo_wine ok(olp && (olp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT ||
10520 olp->Internal == (ULONG)STATUS_CANCELLED ||
10521 olp->Internal == (ULONG)STATUS_CONNECTION_ABORTED ||
10522 olp->Internal == (ULONG)STATUS_PIPE_DISCONNECTED /* win 2000 */),
10523 "Internal status is %lx\n", olp ? olp->Internal : 0);
10524
10525 SetLastError(0xdeadbeef);
10526 key = 0xdeadbeef;
10527 num_bytes = 0xdeadbeef;
10528 olp = (WSAOVERLAPPED *)0xdeadbeef;
10529 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
10530 ok(bret == FALSE, "failed to get completion status %u\n", bret);
10531 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
10532 ok(key == 0xdeadbeef, "Key is %lu\n", key);
10533 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
10534 ok(!olp, "Overlapped structure is at %p\n", olp);
10535
10536
10537 end:
10538 if (dest != INVALID_SOCKET)
10539 closesocket(dest);
10540 if (src != INVALID_SOCKET)
10541 closesocket(src);
10542 if (connector != INVALID_SOCKET)
10543 closesocket(connector);
10544 CloseHandle(previous_port);
10545 }
10546
10547 static void test_address_list_query(void)
10548 {
10549 SOCKET_ADDRESS_LIST *address_list;
10550 DWORD bytes_returned, size;
10551 unsigned int i;
10552 SOCKET s;
10553 int ret;
10554
10555 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
10556 ok(s != INVALID_SOCKET, "Failed to create socket, error %d.\n", WSAGetLastError());
10557
10558 bytes_returned = 0;
10559 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, 0, &bytes_returned, NULL, NULL);
10560 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
10561 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
10562 ok(bytes_returned >= FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]),
10563 "Got unexpected bytes_returned %u.\n", bytes_returned);
10564
10565 size = bytes_returned;
10566 bytes_returned = 0;
10567 address_list = HeapAlloc(GetProcessHeap(), 0, size * 2);
10568 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, size * 2, &bytes_returned, NULL, NULL);
10569 ok(!ret, "Got unexpected ret %d, error %d.\n", ret, WSAGetLastError());
10570 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
10571
10572 bytes_returned = FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[address_list->iAddressCount]);
10573 for (i = 0; i < address_list->iAddressCount; ++i)
10574 {
10575 bytes_returned += address_list->Address[i].iSockaddrLength;
10576 }
10577 ok(size == bytes_returned, "Got unexpected size %u, expected %u.\n", size, bytes_returned);
10578
10579 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, size, NULL, NULL, NULL);
10580 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
10581 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
10582
10583 bytes_returned = 0xdeadbeef;
10584 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, size, &bytes_returned, NULL, NULL);
10585 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
10586 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
10587 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
10588
10589 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, 1, &bytes_returned, NULL, NULL);
10590 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
10591 ok(WSAGetLastError() == WSAEINVAL, "Got unexpected error %d.\n", WSAGetLastError());
10592 ok(bytes_returned == 0, "Got unexpected bytes_returned %u.\n", bytes_returned);
10593
10594 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list,
10595 FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), &bytes_returned, NULL, NULL);
10596 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
10597 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
10598 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
10599
10600 HeapFree(GetProcessHeap(), 0, address_list);
10601 closesocket(s);
10602 }
10603
10604 static DWORD WINAPI inet_ntoa_thread_proc(void *param)
10605 {
10606 ULONG addr;
10607 const char *str;
10608 HANDLE *event = param;
10609
10610 addr = inet_addr("4.3.2.1");
10611 ok(addr == htonl(0x04030201), "expected 0x04030201, got %08x\n", addr);
10612 str = inet_ntoa(*(struct in_addr *)&addr);
10613 ok(!strcmp(str, "4.3.2.1"), "expected 4.3.2.1, got %s\n", str);
10614
10615 SetEvent(event[0]);
10616 WaitForSingleObject(event[1], 3000);
10617
10618 return 0;
10619 }
10620
10621 static void test_inet_ntoa(void)
10622 {
10623 ULONG addr;
10624 const char *str;
10625 HANDLE thread, event[2];
10626 DWORD tid;
10627
10628 addr = inet_addr("1.2.3.4");
10629 ok(addr == htonl(0x01020304), "expected 0x01020304, got %08x\n", addr);
10630 str = inet_ntoa(*(struct in_addr *)&addr);
10631 ok(!strcmp(str, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str);
10632
10633 event[0] = CreateEventW(NULL, TRUE, FALSE, NULL);
10634 event[1] = CreateEventW(NULL, TRUE, FALSE, NULL);
10635
10636 thread = CreateThread(NULL, 0, inet_ntoa_thread_proc, event, 0, &tid);
10637 WaitForSingleObject(event[0], 3000);
10638
10639 ok(!strcmp(str, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str);
10640
10641 SetEvent(event[1]);
10642 WaitForSingleObject(thread, 3000);
10643
10644 CloseHandle(event[0]);
10645 CloseHandle(event[1]);
10646 CloseHandle(thread);
10647 }
10648
10649 static void test_WSALookupService(void)
10650 {
10651 char buffer[4096], strbuff[128];
10652 WSAQUERYSETW *qs = NULL;
10653 HANDLE hnd;
10654 PNLA_BLOB netdata;
10655 int ret;
10656 DWORD error, offset, bsize;
10657
10658 if (!pWSALookupServiceBeginW || !pWSALookupServiceEnd || !pWSALookupServiceNextW)
10659 {
10660 win_skip("WSALookupServiceBeginW or WSALookupServiceEnd or WSALookupServiceNextW not found\n");
10661 return;
10662 }
10663
10664 qs = (WSAQUERYSETW *)buffer;
10665 memset(qs, 0, sizeof(*qs));
10666
10667 /* invalid parameter tests */
10668 ret = pWSALookupServiceBeginW(NULL, 0, &hnd);
10669 error = WSAGetLastError();
10670 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
10671 todo_wine
10672 ok(error == WSAEFAULT, "expected 10014, got %d\n", error);
10673
10674 ret = pWSALookupServiceBeginW(qs, 0, NULL);
10675 error = WSAGetLastError();
10676 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
10677 todo_wine
10678 ok(error == WSAEFAULT, "expected 10014, got %d\n", error);
10679
10680 ret = pWSALookupServiceBeginW(qs, 0, &hnd);
10681 error = WSAGetLastError();
10682 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
10683 todo_wine
10684 ok(error == WSAEINVAL
10685 || broken(error == ERROR_INVALID_PARAMETER) /* == XP */
10686 || broken(error == WSAEFAULT) /* == NT */
10687 || broken(error == WSASERVICE_NOT_FOUND) /* == 2000 */,
10688 "expected 10022, got %d\n", error);
10689
10690 ret = pWSALookupServiceEnd(NULL);
10691 error = WSAGetLastError();
10692 todo_wine
10693 ok(ret == SOCKET_ERROR, "WSALookupServiceEnd should have failed\n");
10694 todo_wine
10695 ok(error == ERROR_INVALID_HANDLE, "expected 6, got %d\n", error);
10696
10697 /* standard network list query */
10698 qs->dwSize = sizeof(*qs);
10699 hnd = (HANDLE)0xdeadbeef;
10700 ret = pWSALookupServiceBeginW(qs, LUP_RETURN_ALL | LUP_DEEP, &hnd);
10701 error = WSAGetLastError();
10702 if(ret && error == ERROR_INVALID_PARAMETER)
10703 {
10704 win_skip("the current WSALookupServiceBeginW test is not supported in win <= 2000\n");
10705 return;
10706 }
10707
10708 todo_wine
10709 ok(!ret, "WSALookupServiceBeginW failed unexpectedly with error %d\n", error);
10710 todo_wine
10711 ok(hnd != (HANDLE)0xdeadbeef, "Handle was not filled\n");
10712
10713 offset = 0;
10714 do
10715 {
10716 memset(qs, 0, sizeof(*qs));
10717 bsize = sizeof(buffer);
10718
10719 if (pWSALookupServiceNextW(hnd, 0, &bsize, qs) == SOCKET_ERROR)
10720 {
10721 error = WSAGetLastError();
10722 if (error == WSA_E_NO_MORE) break;
10723 ok(0, "Error %d happened while listing services\n", error);
10724 break;
10725 }
10726
10727 WideCharToMultiByte(CP_ACP, 0, qs->lpszServiceInstanceName, -1,
10728 strbuff, sizeof(strbuff), NULL, NULL);
10729 trace("Network Name: %s\n", strbuff);
10730
10731 /* network data is written in the blob field */
10732 if (qs->lpBlob)
10733 {
10734 /* each network may have multiple NLA_BLOB information structures */
10735 do
10736 {
10737 netdata = (PNLA_BLOB) &qs->lpBlob->pBlobData[offset];
10738 switch (netdata->header.type)
10739 {
10740 case NLA_RAW_DATA:
10741 trace("\tNLA Data Type: NLA_RAW_DATA\n");
10742 break;
10743 case NLA_INTERFACE:
10744 trace("\tNLA Data Type: NLA_INTERFACE\n");
10745 trace("\t\tType: %d\n", netdata->data.interfaceData.dwType);
10746 trace("\t\tSpeed: %d\n", netdata->data.interfaceData.dwSpeed);
10747 trace("\t\tAdapter Name: %s\n", netdata->data.interfaceData.adapterName);
10748 break;
10749 case NLA_802_1X_LOCATION:
10750 trace("\tNLA Data Type: NLA_802_1X_LOCATION\n");
10751 trace("\t\tInformation: %s\n", netdata->data.locationData.information);
10752 break;
10753 case NLA_CONNECTIVITY:
10754 switch (netdata->data.connectivity.type)
10755 {
10756 case NLA_NETWORK_AD_HOC:
10757 trace("\t\tNetwork Type: AD HOC\n");
10758 break;
10759 case NLA_NETWORK_MANAGED:
10760 trace("\t\tNetwork Type: Managed\n");
10761 break;
10762 case NLA_NETWORK_UNMANAGED:
10763 trace("\t\tNetwork Type: Unmanaged\n");
10764 break;
10765 case NLA_NETWORK_UNKNOWN:
10766 trace("\t\tNetwork Type: Unknown\n");
10767 }
10768 switch (netdata->data.connectivity.internet)
10769 {
10770 case NLA_INTERNET_NO:
10771 trace("\t\tInternet connectivity: No\n");
10772 break;
10773 case NLA_INTERNET_YES:
10774 trace("\t\tInternet connectivity: Yes\n");
10775 break;
10776 case NLA_INTERNET_UNKNOWN:
10777 trace("\t\tInternet connectivity: Unknown\n");
10778 break;
10779 }
10780 break;
10781 case NLA_ICS:
10782 trace("\tNLA Data Type: NLA_ICS\n");
10783 trace("\t\tSpeed: %d\n",
10784 netdata->data.ICS.remote.speed);
10785 trace("\t\tType: %d\n",
10786 netdata->data.ICS.remote.type);
10787 trace("\t\tState: %d\n",
10788 netdata->data.ICS.remote.state);
10789 WideCharToMultiByte(CP_ACP, 0, netdata->data.ICS.remote.machineName, -1,
10790 strbuff, sizeof(strbuff), NULL, NULL);
10791 trace("\t\tMachine Name: %s\n", strbuff);
10792 WideCharToMultiByte(CP_ACP, 0, netdata->data.ICS.remote.sharedAdapterName, -1,
10793 strbuff, sizeof(strbuff), NULL, NULL);
10794 trace("\t\tShared Adapter Name: %s\n", strbuff);
10795 break;
10796 default:
10797 trace("\tNLA Data Type: Unknown\n");
10798 break;
10799 }
10800 }
10801 while (offset);
10802 }
10803 }
10804 while (1);
10805
10806 ret = pWSALookupServiceEnd(hnd);
10807 ok(!ret, "WSALookupServiceEnd failed unexpectedly\n");
10808 }
10809
10810 static void test_WSAEnumNameSpaceProvidersA(void)
10811 {
10812 LPWSANAMESPACE_INFOA name = NULL;
10813 DWORD ret, error, blen = 0, i;
10814 if (!pWSAEnumNameSpaceProvidersA)
10815 {
10816 win_skip("WSAEnumNameSpaceProvidersA not found\n");
10817 return;
10818 }
10819
10820 SetLastError(0xdeadbeef);
10821 ret = pWSAEnumNameSpaceProvidersA(&blen, name);
10822 error = WSAGetLastError();
10823 todo_wine
10824 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
10825 todo_wine
10826 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
10827
10828 /* Invalid parameter tests */
10829 SetLastError(0xdeadbeef);
10830 ret = pWSAEnumNameSpaceProvidersA(NULL, name);
10831 error = WSAGetLastError();
10832 todo_wine
10833 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
10834 todo_wine
10835 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
10836
10837 SetLastError(0xdeadbeef);
10838 ret = pWSAEnumNameSpaceProvidersA(NULL, NULL);
10839 error = WSAGetLastError();
10840 todo_wine
10841 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
10842 todo_wine
10843 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
10844
10845 SetLastError(0xdeadbeef);
10846 ret = pWSAEnumNameSpaceProvidersA(&blen, NULL);
10847 error = WSAGetLastError();
10848 todo_wine
10849 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
10850 todo_wine
10851 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
10852
10853 name = HeapAlloc(GetProcessHeap(), 0, blen);
10854 if (!name)
10855 {
10856 skip("Failed to alloc memory\n");
10857 return;
10858 }
10859
10860 ret = pWSAEnumNameSpaceProvidersA(&blen, name);
10861 todo_wine
10862 ok(ret > 0, "Expected more than zero name space providers\n");
10863
10864 for (i = 0;i < ret; i++)
10865 {
10866 trace("Name space Identifier (%p): %s\n", name[i].lpszIdentifier,
10867 name[i].lpszIdentifier);
10868 switch (name[i].dwNameSpace)
10869 {
10870 case NS_DNS:
10871 trace("\tName space ID: NS_DNS (%u)\n", name[i].dwNameSpace);
10872 break;
10873 case NS_NLA:
10874 trace("\tName space ID: NS_NLA (%u)\n", name[i].dwNameSpace);
10875 break;
10876 default:
10877 trace("\tName space ID: Unknown (%u)\n", name[i].dwNameSpace);
10878 break;
10879 }
10880 trace("\tActive: %d\n", name[i].fActive);
10881 trace("\tVersion: %d\n", name[i].dwVersion);
10882 }
10883
10884 HeapFree(GetProcessHeap(), 0, name);
10885 }
10886
10887 static void test_WSAEnumNameSpaceProvidersW(void)
10888 {
10889 LPWSANAMESPACE_INFOW name = NULL;
10890 DWORD ret, error, blen = 0, i;
10891 if (!pWSAEnumNameSpaceProvidersW)
10892 {
10893 win_skip("WSAEnumNameSpaceProvidersW not found\n");
10894 return;
10895 }
10896
10897 SetLastError(0xdeadbeef);
10898 ret = pWSAEnumNameSpaceProvidersW(&blen, name);
10899 error = WSAGetLastError();
10900 todo_wine
10901 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
10902 todo_wine
10903 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
10904
10905 /* Invalid parameter tests */
10906 SetLastError(0xdeadbeef);
10907 ret = pWSAEnumNameSpaceProvidersW(NULL, name);
10908 error = WSAGetLastError();
10909 todo_wine
10910 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
10911 todo_wine
10912 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
10913
10914 SetLastError(0xdeadbeef);
10915 ret = pWSAEnumNameSpaceProvidersW(NULL, NULL);
10916 error = WSAGetLastError();
10917 todo_wine
10918 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
10919 todo_wine
10920 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
10921
10922 SetLastError(0xdeadbeef);
10923 ret = pWSAEnumNameSpaceProvidersW(&blen, NULL);
10924 error = WSAGetLastError();
10925 todo_wine
10926 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
10927 todo_wine
10928 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
10929
10930 name = HeapAlloc(GetProcessHeap(), 0, blen);
10931 if (!name)
10932 {
10933 skip("Failed to alloc memory\n");
10934 return;
10935 }
10936
10937 ret = pWSAEnumNameSpaceProvidersW(&blen, name);
10938 todo_wine
10939 ok(ret > 0, "Expected more than zero name space providers\n");
10940
10941 for (i = 0;i < ret; i++)
10942 {
10943 trace("Name space Identifier (%p): %s\n", name[i].lpszIdentifier,
10944 wine_dbgstr_w(name[i].lpszIdentifier));
10945 switch (name[i].dwNameSpace)
10946 {
10947 case NS_DNS:
10948 trace("\tName space ID: NS_DNS (%u)\n", name[i].dwNameSpace);
10949 break;
10950 case NS_NLA:
10951 trace("\tName space ID: NS_NLA (%u)\n", name[i].dwNameSpace);
10952 break;
10953 default:
10954 trace("\tName space ID: Unknown (%u)\n", name[i].dwNameSpace);
10955 break;
10956 }
10957 trace("\tActive: %d\n", name[i].fActive);
10958 trace("\tVersion: %d\n", name[i].dwVersion);
10959 }
10960
10961 HeapFree(GetProcessHeap(), 0, name);
10962 }
10963
10964 static void sync_read(SOCKET src, SOCKET dst)
10965 {
10966 int ret;
10967 char data[512];
10968
10969 ret = send(dst, "Hello World!", 12, 0);
10970 ok(ret == 12, "send returned %d\n", ret);
10971
10972 memset(data, 0, sizeof(data));
10973 ret = recv(src, data, sizeof(data), 0);
10974 ok(ret == 12, "expected 12, got %d\n", ret);
10975 ok(!memcmp(data, "Hello World!", 12), "got %u bytes (%*s)\n", ret, ret, data);
10976 }
10977
10978 static void iocp_async_read(SOCKET src, SOCKET dst)
10979 {
10980 HANDLE port;
10981 WSAOVERLAPPED ovl, *ovl_iocp;
10982 WSABUF buf;
10983 int ret;
10984 char data[512];
10985 DWORD flags, bytes;
10986 ULONG_PTR key;
10987
10988 memset(data, 0, sizeof(data));
10989 memset(&ovl, 0, sizeof(ovl));
10990
10991 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
10992 ok(port != 0, "CreateIoCompletionPort error %u\n", GetLastError());
10993
10994 buf.len = sizeof(data);
10995 buf.buf = data;
10996 bytes = 0xdeadbeef;
10997 flags = 0;
10998 SetLastError(0xdeadbeef);
10999 ret = WSARecv(src, &buf, 1, &bytes, &flags, &ovl, NULL);
11000 ok(ret == SOCKET_ERROR, "got %d\n", ret);
11001 ok(GetLastError() == ERROR_IO_PENDING, "got %u\n", GetLastError());
11002 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11003
11004 bytes = 0xdeadbeef;
11005 key = 0xdeadbeef;
11006 ovl_iocp = (void *)0xdeadbeef;
11007 SetLastError(0xdeadbeef);
11008 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11009 ok(!ret, "got %d\n", ret);
11010 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
11011 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11012 ok(key == 0xdeadbeef, "got key %#lx\n", key);
11013 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11014
11015 ret = send(dst, "Hello World!", 12, 0);
11016 ok(ret == 12, "send returned %d\n", ret);
11017
11018 bytes = 0xdeadbeef;
11019 key = 0xdeadbeef;
11020 ovl_iocp = NULL;
11021 SetLastError(0xdeadbeef);
11022 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11023 ok(ret, "got %d\n", ret);
11024 ok(bytes == 12, "got bytes %u\n", bytes);
11025 ok(key == 0x12345678, "got key %#lx\n", key);
11026 ok(ovl_iocp == &ovl, "got ovl %p\n", ovl_iocp);
11027 if (ovl_iocp)
11028 {
11029 ok(ovl_iocp->InternalHigh == 12, "got %#lx\n", ovl_iocp->InternalHigh);
11030 ok(!ovl_iocp->Internal , "got %#lx\n", ovl_iocp->Internal);
11031 ok(!memcmp(data, "Hello World!", 12), "got %u bytes (%*s)\n", bytes, bytes, data);
11032 }
11033
11034 bytes = 0xdeadbeef;
11035 key = 0xdeadbeef;
11036 ovl_iocp = (void *)0xdeadbeef;
11037 SetLastError(0xdeadbeef);
11038 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11039 ok(!ret, "got %d\n", ret);
11040 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
11041 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11042 ok(key == 0xdeadbeef, "got key %#lx\n", key);
11043 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11044
11045 CloseHandle(port);
11046 }
11047
11048 static void iocp_async_read_closesocket(SOCKET src, int how_to_close)
11049 {
11050 HANDLE port;
11051 WSAOVERLAPPED ovl, *ovl_iocp;
11052 WSABUF buf;
11053 int ret;
11054 char data[512];
11055 DWORD flags, bytes;
11056 ULONG_PTR key;
11057 HWND hwnd;
11058 MSG msg;
11059
11060 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
11061 0, 0, 0, 0, NULL, NULL, 0, NULL);
11062 ok(hwnd != 0, "CreateWindowEx failed\n");
11063
11064 ret = WSAAsyncSelect(src, hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
11065 ok(!ret, "got %d\n", ret);
11066
11067 Sleep(100);
11068 memset(&msg, 0, sizeof(msg));
11069 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11070 ok(ret, "got %d\n", ret);
11071 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11072 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11073 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
11074 ok(msg.lParam == 2, "got %08lx\n", msg.lParam);
11075
11076 memset(data, 0, sizeof(data));
11077 memset(&ovl, 0, sizeof(ovl));
11078
11079 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11080 ok(port != 0, "CreateIoCompletionPort error %u\n", GetLastError());
11081
11082 Sleep(100);
11083 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11084 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11085
11086 buf.len = sizeof(data);
11087 buf.buf = data;
11088 bytes = 0xdeadbeef;
11089 flags = 0;
11090 SetLastError(0xdeadbeef);
11091 ret = WSARecv(src, &buf, 1, &bytes, &flags, &ovl, NULL);
11092 ok(ret == SOCKET_ERROR, "got %d\n", ret);
11093 ok(GetLastError() == ERROR_IO_PENDING, "got %u\n", GetLastError());
11094 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11095
11096 Sleep(100);
11097 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11098 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11099
11100 bytes = 0xdeadbeef;
11101 key = 0xdeadbeef;
11102 ovl_iocp = (void *)0xdeadbeef;
11103 SetLastError(0xdeadbeef);
11104 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11105 ok(!ret, "got %d\n", ret);
11106 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
11107 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11108 ok(key == 0xdeadbeef, "got key %#lx\n", key);
11109 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11110
11111 Sleep(100);
11112 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11113 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11114
11115 switch (how_to_close)
11116 {
11117 case 0:
11118 closesocket(src);
11119 break;
11120 case 1:
11121 CloseHandle((HANDLE)src);
11122 break;
11123 case 2:
11124 pNtClose((HANDLE)src);
11125 break;
11126 default:
11127 ok(0, "wrong value %d\n", how_to_close);
11128 break;
11129 }
11130
11131 Sleep(200);
11132 memset(&msg, 0, sizeof(msg));
11133 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11134 switch (how_to_close)
11135 {
11136 case 0:
11137 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11138 break;
11139 case 1:
11140 case 2:
11141 todo_wine
11142 {
11143 ok(ret, "got %d\n", ret);
11144 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11145 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11146 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
11147 ok(msg.lParam == 0x20, "got %08lx\n", msg.lParam);
11148 }
11149 break;
11150 default:
11151 ok(0, "wrong value %d\n", how_to_close);
11152 break;
11153 }
11154
11155 bytes = 0xdeadbeef;
11156 key = 0xdeadbeef;
11157 ovl_iocp = NULL;
11158 SetLastError(0xdeadbeef);
11159 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11160 ok(!ret, "got %d\n", ret);
11161 todo_wine
11162 ok(GetLastError() == ERROR_CONNECTION_ABORTED || GetLastError() == ERROR_NETNAME_DELETED /* XP */, "got %u\n", GetLastError());
11163 ok(!bytes, "got bytes %u\n", bytes);
11164 ok(key == 0x12345678, "got key %#lx\n", key);
11165 ok(ovl_iocp == &ovl, "got ovl %p\n", ovl_iocp);
11166 if (ovl_iocp)
11167 {
11168 ok(!ovl_iocp->InternalHigh, "got %#lx\n", ovl_iocp->InternalHigh);
11169 todo_wine
11170 ok(ovl_iocp->Internal == (ULONG)STATUS_CONNECTION_ABORTED || ovl_iocp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT /* XP */, "got %#lx\n", ovl_iocp->Internal);
11171 }
11172
11173 bytes = 0xdeadbeef;
11174 key = 0xdeadbeef;
11175 ovl_iocp = (void *)0xdeadbeef;
11176 SetLastError(0xdeadbeef);
11177 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11178 ok(!ret, "got %d\n", ret);
11179 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
11180 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11181 ok(key == 0xdeadbeef, "got key %#lx\n", key);
11182 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11183
11184 CloseHandle(port);
11185
11186 DestroyWindow(hwnd);
11187 }
11188
11189 static void iocp_async_closesocket(SOCKET src)
11190 {
11191 HANDLE port;
11192 WSAOVERLAPPED *ovl_iocp;
11193 int ret;
11194 DWORD bytes;
11195 ULONG_PTR key;
11196 HWND hwnd;
11197 MSG msg;
11198
11199 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
11200 0, 0, 0, 0, NULL, NULL, 0, NULL);
11201 ok(hwnd != 0, "CreateWindowEx failed\n");
11202
11203 ret = WSAAsyncSelect(src, hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
11204 ok(!ret, "got %d\n", ret);
11205
11206 Sleep(100);
11207 memset(&msg, 0, sizeof(msg));
11208 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11209 ok(ret, "got %d\n", ret);
11210 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11211 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11212 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
11213 ok(msg.lParam == 2, "got %08lx\n", msg.lParam);
11214
11215 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11216 ok(port != 0, "CreateIoCompletionPort error %u\n", GetLastError());
11217
11218 Sleep(100);
11219 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11220 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11221
11222 bytes = 0xdeadbeef;
11223 key = 0xdeadbeef;
11224 ovl_iocp = (void *)0xdeadbeef;
11225 SetLastError(0xdeadbeef);
11226 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11227 ok(!ret, "got %d\n", ret);
11228 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
11229 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11230 ok(key == 0xdeadbeef, "got key %lu\n", key);
11231 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11232
11233 Sleep(100);
11234 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11235 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11236
11237 closesocket(src);
11238
11239 Sleep(100);
11240 memset(&msg, 0, sizeof(msg));
11241 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11242 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11243
11244 bytes = 0xdeadbeef;
11245 key = 0xdeadbeef;
11246 ovl_iocp = (void *)0xdeadbeef;
11247 SetLastError(0xdeadbeef);
11248 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11249 ok(!ret, "got %d\n", ret);
11250 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
11251 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11252 ok(key == 0xdeadbeef, "got key %lu\n", key);
11253 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11254
11255 CloseHandle(port);
11256
11257 DestroyWindow(hwnd);
11258 }
11259
11260 struct wsa_async_select_info
11261 {
11262 SOCKET sock;
11263 HWND hwnd;
11264 };
11265
11266 static DWORD WINAPI wsa_async_select_thread(void *param)
11267 {
11268 struct wsa_async_select_info *info = param;
11269 int ret;
11270
11271 ret = WSAAsyncSelect(info->sock, info->hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
11272 ok(!ret, "got %d\n", ret);
11273
11274 return 0;
11275 }
11276
11277 struct wsa_recv_info
11278 {
11279 SOCKET sock;
11280 WSABUF wsa_buf;
11281 WSAOVERLAPPED ovl;
11282 };
11283
11284 static DWORD WINAPI wsa_recv_thread(void *param)
11285 {
11286 struct wsa_recv_info *info = param;
11287 int ret;
11288 DWORD flags, bytes;
11289
11290 bytes = 0xdeadbeef;
11291 flags = 0;
11292 SetLastError(0xdeadbeef);
11293 ret = WSARecv(info->sock, &info->wsa_buf, 1, &bytes, &flags, &info->ovl, NULL);
11294 ok(ret == SOCKET_ERROR, "got %d\n", ret);
11295 ok(GetLastError() == ERROR_IO_PENDING, "got %u\n", GetLastError());
11296 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11297
11298 return 0;
11299 }
11300
11301 static void iocp_async_read_thread_closesocket(SOCKET src)
11302 {
11303 struct wsa_async_select_info select_info;
11304 struct wsa_recv_info recv_info;
11305 HANDLE port, thread;
11306 WSAOVERLAPPED *ovl_iocp;
11307 int ret;
11308 char data[512];
11309 DWORD bytes, tid;
11310 ULONG_PTR key;
11311 HWND hwnd;
11312 MSG msg;
11313
11314 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
11315 0, 0, 0, 0, NULL, NULL, 0, NULL);
11316 ok(hwnd != 0, "CreateWindowEx failed\n");
11317
11318 select_info.sock = src;
11319 select_info.hwnd = hwnd;
11320 thread = CreateThread(NULL, 0, wsa_async_select_thread, &select_info, 0, &tid);
11321 ok(thread != 0, "CreateThread error %u\n", GetLastError());
11322 ret = WaitForSingleObject(thread, 10000);
11323 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
11324
11325 Sleep(100);
11326 memset(&msg, 0, sizeof(msg));
11327 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11328 ok(ret, "got %d\n", ret);
11329 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11330 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11331 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
11332 ok(msg.lParam == 2, "got %08lx\n", msg.lParam);
11333
11334 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11335 ok(port != 0, "CreateIoCompletionPort error %u\n", GetLastError());
11336
11337 Sleep(100);
11338 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11339 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11340
11341 memset(data, 0, sizeof(data));
11342 memset(&recv_info.ovl, 0, sizeof(recv_info.ovl));
11343 recv_info.sock = src;
11344 recv_info.wsa_buf.len = sizeof(data);
11345 recv_info.wsa_buf.buf = data;
11346 thread = CreateThread(NULL, 0, wsa_recv_thread, &recv_info, 0, &tid);
11347 ok(thread != 0, "CreateThread error %u\n", GetLastError());
11348 ret = WaitForSingleObject(thread, 10000);
11349 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
11350
11351 Sleep(100);
11352 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11353 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11354
11355 bytes = 0xdeadbeef;
11356 key = 0xdeadbeef;
11357 ovl_iocp = (void *)0xdeadbeef;
11358 SetLastError(0xdeadbeef);
11359 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11360 ok(!ret, "got %d\n", ret);
11361 ok(GetLastError() == WAIT_TIMEOUT || broken(GetLastError() == ERROR_OPERATION_ABORTED) /* XP */,
11362 "got %u\n", GetLastError());
11363 if (GetLastError() == WAIT_TIMEOUT)
11364 {
11365 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11366 ok(key == 0xdeadbeef, "got key %lx\n", key);
11367 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11368 }
11369 else /* document XP behaviour */
11370 {
11371 ok(!bytes, "got bytes %u\n", bytes);
11372 ok(key == 0x12345678, "got key %#lx\n", key);
11373 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
11374 if (ovl_iocp)
11375 {
11376 ok(!ovl_iocp->InternalHigh, "got %#lx\n", ovl_iocp->InternalHigh);
11377 ok(ovl_iocp->Internal == STATUS_CANCELLED, "got %#lx\n", ovl_iocp->Internal);
11378 }
11379
11380 closesocket(src);
11381 goto xp_is_broken;
11382 }
11383
11384 Sleep(100);
11385 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11386 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11387
11388 closesocket(src);
11389
11390 Sleep(100);
11391 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11392 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11393
11394 bytes = 0xdeadbeef;
11395 key = 0xdeadbeef;
11396 ovl_iocp = NULL;
11397 SetLastError(0xdeadbeef);
11398 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11399 ok(!ret, "got %d\n", ret);
11400 todo_wine
11401 ok(GetLastError() == ERROR_CONNECTION_ABORTED || GetLastError() == ERROR_NETNAME_DELETED /* XP */, "got %u\n", GetLastError());
11402 ok(!bytes, "got bytes %u\n", bytes);
11403 ok(key == 0x12345678, "got key %#lx\n", key);
11404 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
11405 if (ovl_iocp)
11406 {
11407 ok(!ovl_iocp->InternalHigh, "got %#lx\n", ovl_iocp->InternalHigh);
11408 todo_wine
11409 ok(ovl_iocp->Internal == (ULONG)STATUS_CONNECTION_ABORTED || ovl_iocp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT /* XP */, "got %#lx\n", ovl_iocp->Internal);
11410 }
11411
11412 xp_is_broken:
11413 bytes = 0xdeadbeef;
11414 key = 0xdeadbeef;
11415 ovl_iocp = (void *)0xdeadbeef;
11416 SetLastError(0xdeadbeef);
11417 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11418 ok(!ret, "got %d\n", ret);
11419 ok(GetLastError() == WAIT_TIMEOUT, "got %u\n", GetLastError());
11420 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11421 ok(key == 0xdeadbeef, "got key %lu\n", key);
11422 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11423
11424 CloseHandle(port);
11425
11426 DestroyWindow(hwnd);
11427 }
11428
11429 static void iocp_async_read_thread(SOCKET src, SOCKET dst)
11430 {
11431 struct wsa_async_select_info select_info;
11432 struct wsa_recv_info recv_info;
11433 HANDLE port, thread;
11434 WSAOVERLAPPED *ovl_iocp;
11435 int ret;
11436 char data[512];
11437 DWORD bytes, tid;
11438 ULONG_PTR key;
11439 HWND hwnd;
11440 MSG msg;
11441
11442 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP,
11443 0, 0, 0, 0, NULL, NULL, 0, NULL);
11444 ok(hwnd != 0, "CreateWindowEx failed\n");
11445
11446 select_info.sock = src;
11447 select_info.hwnd = hwnd;
11448 thread = CreateThread(NULL, 0, wsa_async_select_thread, &select_info, 0, &tid);
11449 ok(thread != 0, "CreateThread error %u\n", GetLastError());
11450 ret = WaitForSingleObject(thread, 10000);
11451 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
11452
11453 Sleep(100);
11454 memset(&msg, 0, sizeof(msg));
11455 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11456 ok(ret, "got %d\n", ret);
11457 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11458 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11459 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
11460 ok(msg.lParam == 2, "got %08lx\n", msg.lParam);
11461
11462 port = CreateIoCompletionPort((HANDLE)src, 0, 0x12345678, 0);
11463 ok(port != 0, "CreateIoCompletionPort error %u\n", GetLastError());
11464
11465 Sleep(100);
11466 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11467 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11468
11469 memset(data, 0, sizeof(data));
11470 memset(&recv_info.ovl, 0, sizeof(recv_info.ovl));
11471 recv_info.sock = src;
11472 recv_info.wsa_buf.len = sizeof(data);
11473 recv_info.wsa_buf.buf = data;
11474 thread = CreateThread(NULL, 0, wsa_recv_thread, &recv_info, 0, &tid);
11475 ok(thread != 0, "CreateThread error %u\n", GetLastError());
11476 ret = WaitForSingleObject(thread, 10000);
11477 ok(ret == WAIT_OBJECT_0, "thread failed to terminate\n");
11478
11479 Sleep(100);
11480 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11481 ok(!ret, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11482
11483 bytes = 0xdeadbeef;
11484 key = 0xdeadbeef;
11485 ovl_iocp = (void *)0xdeadbeef;
11486 SetLastError(0xdeadbeef);
11487 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11488 ok(!ret, "got %d\n", ret);
11489 ok(GetLastError() == WAIT_TIMEOUT || broken(GetLastError() == ERROR_OPERATION_ABORTED) /* XP */, "got %u\n", GetLastError());
11490 if (GetLastError() == WAIT_TIMEOUT)
11491 {
11492 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11493 ok(key == 0xdeadbeef, "got key %lu\n", key);
11494 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11495 }
11496 else /* document XP behaviour */
11497 {
11498 ok(bytes == 0, "got bytes %u\n", bytes);
11499 ok(key == 0x12345678, "got key %#lx\n", key);
11500 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
11501 if (ovl_iocp)
11502 {
11503 ok(!ovl_iocp->InternalHigh, "got %#lx\n", ovl_iocp->InternalHigh);
11504 ok(ovl_iocp->Internal == STATUS_CANCELLED, "got %#lx\n", ovl_iocp->Internal);
11505 }
11506 }
11507
11508 Sleep(100);
11509 memset(&msg, 0, sizeof(msg));
11510 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11511 ok(!ret || broken(msg.hwnd == hwnd) /* XP */, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11512 if (ret) /* document XP behaviour */
11513 {
11514 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11515 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
11516 ok(msg.lParam == 1, "got %08lx\n", msg.lParam);
11517 }
11518
11519 ret = send(dst, "Hello World!", 12, 0);
11520 ok(ret == 12, "send returned %d\n", ret);
11521
11522 Sleep(100);
11523 memset(&msg, 0, sizeof(msg));
11524 ret = PeekMessageA(&msg, hwnd, WM_SOCKET, WM_SOCKET, PM_REMOVE);
11525 ok(!ret || broken(msg.hwnd == hwnd) /* XP */, "got %04x,%08lx,%08lx\n", msg.message, msg.wParam, msg.lParam);
11526 if (ret) /* document XP behaviour */
11527 {
11528 ok(msg.hwnd == hwnd, "got %p\n", msg.hwnd);
11529 ok(msg.message == WM_SOCKET, "got %04x\n", msg.message);
11530 ok(msg.wParam == src, "got %08lx\n", msg.wParam);
11531 ok(msg.lParam == 1, "got %08lx\n", msg.lParam);
11532 }
11533
11534 bytes = 0xdeadbeef;
11535 key = 0xdeadbeef;
11536 ovl_iocp = (void *)0xdeadbeef;
11537 SetLastError(0xdeadbeef);
11538 ret = GetQueuedCompletionStatus(port, &bytes, &key, &ovl_iocp, 100);
11539 ok(ret || broken(GetLastError() == WAIT_TIMEOUT) /* XP */, "got %u\n", GetLastError());
11540 if (ret)
11541 {
11542 ok(bytes == 12, "got bytes %u\n", bytes);
11543 ok(key == 0x12345678, "got key %#lx\n", key);
11544 ok(ovl_iocp == &recv_info.ovl, "got ovl %p\n", ovl_iocp);
11545 if (ovl_iocp)
11546 {
11547 ok(ovl_iocp->InternalHigh == 12, "got %#lx\n", ovl_iocp->InternalHigh);
11548 ok(!ovl_iocp->Internal , "got %#lx\n", ovl_iocp->Internal);
11549 ok(!memcmp(data, "Hello World!", 12), "got %u bytes (%*s)\n", bytes, bytes, data);
11550 }
11551 }
11552 else /* document XP behaviour */
11553 {
11554 ok(bytes == 0xdeadbeef, "got bytes %u\n", bytes);
11555 ok(key == 0xdeadbeef, "got key %lu\n", key);
11556 ok(!ovl_iocp, "got ovl %p\n", ovl_iocp);
11557 }
11558
11559 CloseHandle(port);
11560
11561 DestroyWindow(hwnd);
11562 }
11563
11564 static void test_iocp(void)
11565 {
11566 SOCKET src, dst;
11567 int i, ret;
11568
11569 ret = tcp_socketpair_ovl(&src, &dst);
11570 ok(!ret, "creating socket pair failed\n");
11571 sync_read(src, dst);
11572 iocp_async_read(src, dst);
11573 closesocket(src);
11574 closesocket(dst);
11575
11576 ret = tcp_socketpair_ovl(&src, &dst);
11577 ok(!ret, "creating socket pair failed\n");
11578 iocp_async_read_thread(src, dst);
11579 closesocket(src);
11580 closesocket(dst);
11581
11582 for (i = 0; i <= 2; i++)
11583 {
11584 ret = tcp_socketpair_ovl(&src, &dst);
11585 ok(!ret, "creating socket pair failed\n");
11586 iocp_async_read_closesocket(src, i);
11587 closesocket(dst);
11588 }
11589
11590 ret = tcp_socketpair_ovl(&src, &dst);
11591 ok(!ret, "creating socket pair failed\n");
11592 iocp_async_closesocket(src);
11593 closesocket(dst);
11594
11595 ret = tcp_socketpair_ovl(&src, &dst);
11596 ok(!ret, "creating socket pair failed\n");
11597 iocp_async_read_thread_closesocket(src);
11598 closesocket(dst);
11599 }
11600
11601 START_TEST( sock )
11602 {
11603 int i;
11604
11605 /* Leave these tests at the beginning. They depend on WSAStartup not having been
11606 * called, which is done by Init() below. */
11607 test_WithoutWSAStartup();
11608 test_WithWSAStartup();
11609
11610 Init();
11611
11612 test_inet_ntoa();
11613 test_inet_pton();
11614 test_set_getsockopt();
11615 test_so_reuseaddr();
11616 test_ip_pktinfo();
11617 test_extendedSocketOptions();
11618
11619 for (i = 0; i < ARRAY_SIZE(tests); i++)
11620 {
11621 trace ( " **** STARTING TEST %d ****\n", i );
11622 do_test ( &tests[i] );
11623 trace ( " **** TEST %d COMPLETE ****\n", i );
11624 }
11625
11626 test_UDP();
11627
11628 test_getservbyname();
11629 test_WSASocket();
11630 test_WSADuplicateSocket();
11631 test_WSAEnumNetworkEvents();
11632
11633 test_WSAAddressToStringA();
11634 test_WSAAddressToStringW();
11635
11636 test_WSAStringToAddressA();
11637 test_WSAStringToAddressW();
11638
11639 test_errors();
11640 test_listen();
11641 test_select();
11642 test_accept();
11643 test_getpeername();
11644 test_getsockname();
11645 test_inet_addr();
11646 test_addr_to_print();
11647 test_ioctlsocket();
11648 test_dns();
11649 test_gethostbyname();
11650 test_gethostbyname_hack();
11651 test_gethostname();
11652
11653 test_WSASendMsg();
11654 test_WSASendTo();
11655 test_WSARecv();
11656 test_WSAPoll();
11657 test_write_watch();
11658 test_iocp();
11659
11660 test_events(0);
11661 test_events(1);
11662
11663 test_ipv6only();
11664 test_TransmitFile();
11665 test_GetAddrInfoW();
11666 test_GetAddrInfoExW();
11667 test_getaddrinfo();
11668 test_AcceptEx();
11669 test_ConnectEx();
11670 test_DisconnectEx();
11671
11672 test_sioRoutingInterfaceQuery();
11673 test_sioAddressListChange();
11674
11675 test_WSALookupService();
11676 test_WSAEnumNameSpaceProvidersA();
11677 test_WSAEnumNameSpaceProvidersW();
11678
11679 test_WSAAsyncGetServByPort();
11680 test_WSAAsyncGetServByName();
11681
11682 test_completion_port();
11683 test_address_list_query();
11684
11685 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
11686 test_send();
11687 test_synchronous_WSAIoctl();
11688
11689 Exit();
11690 }
Windows API implementation