?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ws2_32/tests: Add tests for InetNtopW.
[wine.git] / dlls / ws2_32 / tests / sock.c
blobd6412fdd479bf05b59b725dda16db6f888824b5e
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 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include <ntstatus.h>
24 #define WIN32_NO_STATUS
25 #include <winsock2.h>
26 #include <windows.h>
27 #include <winternl.h>
28 #include <ws2tcpip.h>
29 #include <wsipx.h>
30 #include <wsnwlink.h>
31 #include <mswsock.h>
32 #include <mstcpip.h>
33 #include <iphlpapi.h>
34 #include <stdio.h>
35 #include "wine/test.h"
36
37 #define MAX_CLIENTS 4 /* Max number of clients */
38 #define FIRST_CHAR 'A' /* First character in transferred pattern */
39 #define BIND_SLEEP 10 /* seconds to wait between attempts to bind() */
40 #define BIND_TRIES 6 /* Number of bind() attempts */
41 #define TEST_TIMEOUT 30 /* seconds to wait before killing child threads
42 after server initialization, if something hangs */
43
44 #define NUM_UDP_PEERS 3 /* Number of UDP sockets to create and test > 1 */
45
46 #define NUM_THREADS 3 /* Number of threads to run getservbyname */
47 #define NUM_QUERIES 250 /* Number of getservbyname queries per thread */
48
49 #define SERVERIP "127.0.0.1" /* IP to bind to */
50 #define SERVERPORT 9374 /* Port number to bind to */
51
52 #define wsa_ok(op, cond, msg) \
53 do { \
54 int tmp, err = 0; \
55 tmp = op; \
56 if ( !(cond tmp) ) err = WSAGetLastError(); \
57 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
58 } while (0);
59
60 #define make_keepalive(k, enable, time, interval) \
61 k.onoff = enable; \
62 k.keepalivetime = time; \
63 k.keepaliveinterval = interval;
64
65 /* Function pointers */
66 static void (WINAPI *pfreeaddrinfo)(struct addrinfo *);
67 static int (WINAPI *pgetaddrinfo)(LPCSTR,LPCSTR,const struct addrinfo *,struct addrinfo **);
68 static void (WINAPI *pFreeAddrInfoW)(PADDRINFOW);
69 static int (WINAPI *pGetAddrInfoW)(LPCWSTR,LPCWSTR,const ADDRINFOW *,PADDRINFOW *);
70 static PCSTR (WINAPI *pInetNtop)(INT,LPVOID,LPSTR,ULONG);
71 static PCWSTR(WINAPI *pInetNtopW)(INT,LPVOID,LPWSTR,ULONG);
72 static int (WINAPI *pInetPtonA)(INT,LPCSTR,LPVOID);
73 static int (WINAPI *pInetPtonW)(INT,LPWSTR,LPVOID);
74 static int (WINAPI *pWSALookupServiceBeginW)(LPWSAQUERYSETW,DWORD,LPHANDLE);
75 static int (WINAPI *pWSALookupServiceEnd)(HANDLE);
76 static int (WINAPI *pWSALookupServiceNextW)(HANDLE,DWORD,LPDWORD,LPWSAQUERYSETW);
77 static int (WINAPI *pWSAEnumNameSpaceProvidersA)(LPDWORD,LPWSANAMESPACE_INFOA);
78 static int (WINAPI *pWSAEnumNameSpaceProvidersW)(LPDWORD,LPWSANAMESPACE_INFOW);
79 static int (WINAPI *pWSAPoll)(WSAPOLLFD *,ULONG,INT);
80
81 /* Function pointers from iphlpapi */
82 static DWORD (WINAPI *pGetAdaptersInfo)(PIP_ADAPTER_INFO,PULONG);
83 static DWORD (WINAPI *pGetIpForwardTable)(PMIB_IPFORWARDTABLE,PULONG,BOOL);
84
85 /**************** Structs and typedefs ***************/
86
87 typedef struct thread_info
88 {
89 HANDLE thread;
90 DWORD id;
91 } thread_info;
92
93 /* Information in the server about open client connections */
94 typedef struct sock_info
95 {
96 SOCKET s;
97 struct sockaddr_in addr;
98 struct sockaddr_in peer;
99 char *buf;
100 int n_recvd;
101 int n_sent;
102 } sock_info;
103
104 /* Test parameters for both server & client */
105 typedef struct test_params
106 {
107 int sock_type;
108 int sock_prot;
109 const char *inet_addr;
110 short inet_port;
111 int chunk_size;
112 int n_chunks;
113 int n_clients;
114 } test_params;
115
116 /* server-specific test parameters */
117 typedef struct server_params
118 {
119 test_params *general;
120 DWORD sock_flags;
121 int buflen;
122 } server_params;
123
124 /* client-specific test parameters */
125 typedef struct client_params
126 {
127 test_params *general;
128 DWORD sock_flags;
129 int buflen;
130 } client_params;
131
132 /* This type combines all information for setting up a test scenario */
133 typedef struct test_setup
134 {
135 test_params general;
136 LPVOID srv;
137 server_params srv_params;
138 LPVOID clt;
139 client_params clt_params;
140 } test_setup;
141
142 /* Thread local storage for server */
143 typedef struct server_memory
144 {
145 SOCKET s;
146 struct sockaddr_in addr;
147 sock_info sock[MAX_CLIENTS];
148 } server_memory;
149
150 /* Thread local storage for client */
151 typedef struct client_memory
152 {
153 SOCKET s;
154 struct sockaddr_in addr;
155 char *send_buf;
156 char *recv_buf;
157 } client_memory;
158
159 /* SelectReadThread thread parameters */
160 typedef struct select_thread_params
161 {
162 SOCKET s;
163 BOOL ReadKilled;
164 } select_thread_params;
165
166 /* Tests used in both getaddrinfo and GetAddrInfoW */
167 static const struct addr_hint_tests
168 {
169 int family, socktype, protocol;
170 DWORD error;
171 } hinttests[] = {
172 {AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, 0 },
173 {AF_UNSPEC, SOCK_STREAM, IPPROTO_UDP, 0 },
174 {AF_UNSPEC, SOCK_STREAM, IPPROTO_IPV6,0 },
175 {AF_UNSPEC, SOCK_DGRAM, IPPROTO_TCP, 0 },
176 {AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP, 0 },
177 {AF_UNSPEC, SOCK_DGRAM, IPPROTO_IPV6,0 },
178 {AF_INET, SOCK_STREAM, IPPROTO_TCP, 0 },
179 {AF_INET, SOCK_STREAM, IPPROTO_UDP, 0 },
180 {AF_INET, SOCK_STREAM, IPPROTO_IPV6,0 },
181 {AF_INET, SOCK_DGRAM, IPPROTO_TCP, 0 },
182 {AF_INET, SOCK_DGRAM, IPPROTO_UDP, 0 },
183 {AF_INET, SOCK_DGRAM, IPPROTO_IPV6,0 },
184 {AF_UNSPEC, 0, IPPROTO_TCP, 0 },
185 {AF_UNSPEC, 0, IPPROTO_UDP, 0 },
186 {AF_UNSPEC, 0, IPPROTO_IPV6,0 },
187 {AF_UNSPEC, SOCK_STREAM, 0, 0 },
188 {AF_UNSPEC, SOCK_DGRAM, 0, 0 },
189 {AF_INET, 0, IPPROTO_TCP, 0 },
190 {AF_INET, 0, IPPROTO_UDP, 0 },
191 {AF_INET, 0, IPPROTO_IPV6,0 },
192 {AF_INET, SOCK_STREAM, 0, 0 },
193 {AF_INET, SOCK_DGRAM, 0, 0 },
194 {AF_UNSPEC, 999, IPPROTO_TCP, WSAESOCKTNOSUPPORT },
195 {AF_UNSPEC, 999, IPPROTO_UDP, WSAESOCKTNOSUPPORT },
196 {AF_UNSPEC, 999, IPPROTO_IPV6,WSAESOCKTNOSUPPORT },
197 {AF_INET, 999, IPPROTO_TCP, WSAESOCKTNOSUPPORT },
198 {AF_INET, 999, IPPROTO_UDP, WSAESOCKTNOSUPPORT },
199 {AF_INET, 999, IPPROTO_IPV6,WSAESOCKTNOSUPPORT },
200 {AF_UNSPEC, SOCK_STREAM, 999, 0 },
201 {AF_UNSPEC, SOCK_STREAM, 999, 0 },
202 {AF_INET, SOCK_DGRAM, 999, 0 },
203 {AF_INET, SOCK_DGRAM, 999, 0 },
204 };
205
206 /**************** Static variables ***************/
207
208 static DWORD tls; /* Thread local storage index */
209 static HANDLE thread[1+MAX_CLIENTS];
210 static DWORD thread_id[1+MAX_CLIENTS];
211 static HANDLE server_ready;
212 static HANDLE client_ready[MAX_CLIENTS];
213 static int client_id;
214
215 /**************** General utility functions ***************/
216
217 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len);
218 static SOCKET setup_connector_socket(struct sockaddr_in *addr, int len, BOOL nonblock);
219
220 static int tcp_socketpair(SOCKET *src, SOCKET *dst)
221 {
222 SOCKET server = INVALID_SOCKET;
223 struct sockaddr_in addr;
224 int len;
225 int ret;
226
227 *src = INVALID_SOCKET;
228 *dst = INVALID_SOCKET;
229
230 *src = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
231 if (*src == INVALID_SOCKET)
232 goto end;
233
234 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
235 if (server == INVALID_SOCKET)
236 goto end;
237
238 memset(&addr, 0, sizeof(addr));
239 addr.sin_family = AF_INET;
240 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
241 ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
242 if (ret != 0)
243 goto end;
244
245 len = sizeof(addr);
246 ret = getsockname(server, (struct sockaddr*)&addr, &len);
247 if (ret != 0)
248 goto end;
249
250 ret = listen(server, 1);
251 if (ret != 0)
252 goto end;
253
254 ret = connect(*src, (struct sockaddr*)&addr, sizeof(addr));
255 if (ret != 0)
256 goto end;
257
258 len = sizeof(addr);
259 *dst = accept(server, (struct sockaddr*)&addr, &len);
260
261 end:
262 if (server != INVALID_SOCKET)
263 closesocket(server);
264 if (*src != INVALID_SOCKET && *dst != INVALID_SOCKET)
265 return 0;
266 closesocket(*src);
267 closesocket(*dst);
268 return -1;
269 }
270
271 static void set_so_opentype ( BOOL overlapped )
272 {
273 int optval = !overlapped, newval, len = sizeof (int);
274
275 ok ( setsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
276 (LPVOID) &optval, sizeof (optval) ) == 0,
277 "setting SO_OPENTYPE failed\n" );
278 ok ( getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
279 (LPVOID) &newval, &len ) == 0,
280 "getting SO_OPENTYPE failed\n" );
281 ok ( optval == newval, "failed to set SO_OPENTYPE\n" );
282 }
283
284 static int set_blocking ( SOCKET s, BOOL blocking )
285 {
286 u_long val = !blocking;
287 return ioctlsocket ( s, FIONBIO, &val );
288 }
289
290 static void fill_buffer ( char *buf, int chunk_size, int n_chunks )
291 {
292 char c, *p;
293 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
294 memset ( p, c, chunk_size );
295 }
296
297 static int test_buffer ( char *buf, int chunk_size, int n_chunks )
298 {
299 char c, *p;
300 int i;
301 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
302 {
303 for ( i = 0; i < chunk_size; i++ )
304 if ( p[i] != c ) return i;
305 }
306 return -1;
307 }
308
309 /*
310 * This routine is called when a client / server does not expect any more data,
311 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
312 */
313 static void read_zero_bytes ( SOCKET s )
314 {
315 char buf[256];
316 int tmp, n = 0;
317 while ( ( tmp = recv ( s, buf, 256, 0 ) ) > 0 )
318 n += tmp;
319 ok ( n <= 0, "garbage data received: %d bytes\n", n );
320 }
321
322 static int do_synchronous_send ( SOCKET s, char *buf, int buflen, int flags, int sendlen )
323 {
324 char* last = buf + buflen, *p;
325 int n = 1;
326 for ( p = buf; n > 0 && p < last; )
327 {
328 n = send ( s, p, min ( sendlen, last - p ), flags );
329 if (n > 0) p += n;
330 }
331 wsa_ok ( n, 0 <=, "do_synchronous_send (%x): error %d\n" );
332 return p - buf;
333 }
334
335 static int do_synchronous_recv ( SOCKET s, char *buf, int buflen, int flags, int recvlen )
336 {
337 char* last = buf + buflen, *p;
338 int n = 1;
339 for ( p = buf; n > 0 && p < last; )
340 {
341 n = recv ( s, p, min ( recvlen, last - p ), flags );
342 if (n > 0) p += n;
343 }
344 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
345 return p - buf;
346 }
347
348 static int do_synchronous_recvfrom ( SOCKET s, char *buf, int buflen, int flags, struct sockaddr *from, int *fromlen, int recvlen )
349 {
350 char* last = buf + buflen, *p;
351 int n = 1;
352 for ( p = buf; n > 0 && p < last; )
353 {
354 n = recvfrom ( s, p, min ( recvlen, last - p ), flags, from, fromlen );
355 if (n > 0) p += n;
356 }
357 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
358 return p - buf;
359 }
360
361 /*
362 * Call this routine right after thread startup.
363 * SO_OPENTYPE must by 0, regardless what the server did.
364 */
365 static void check_so_opentype (void)
366 {
367 int tmp = 1, len;
368 len = sizeof (tmp);
369 getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (LPVOID) &tmp, &len );
370 ok ( tmp == 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp );
371 }
372
373 static void compare_addrinfo (ADDRINFO *a, ADDRINFO *b)
374 {
375 for (; a && b ; a = a->ai_next, b = b->ai_next)
376 {
377 ok(a->ai_flags == b->ai_flags,
378 "Wrong flags %d != %d\n", a->ai_flags, b->ai_flags);
379 ok(a->ai_family == b->ai_family,
380 "Wrong family %d != %d\n", a->ai_family, b->ai_family);
381 ok(a->ai_socktype == b->ai_socktype,
382 "Wrong socktype %d != %d\n", a->ai_socktype, b->ai_socktype);
383 ok(a->ai_protocol == b->ai_protocol,
384 "Wrong protocol %d != %d\n", a->ai_protocol, b->ai_protocol);
385 ok(a->ai_addrlen == b->ai_addrlen,
386 "Wrong addrlen %lu != %lu\n", a->ai_addrlen, b->ai_addrlen);
387 ok(!memcmp(a->ai_addr, b->ai_addr, min(a->ai_addrlen, b->ai_addrlen)),
388 "Wrong address data\n");
389 if (a->ai_canonname && b->ai_canonname)
390 {
391 ok(!strcmp(a->ai_canonname, b->ai_canonname), "Wrong canonical name '%s' != '%s'\n",
392 a->ai_canonname, b->ai_canonname);
393 }
394 else
395 ok(!a->ai_canonname && !b->ai_canonname, "Expected both names absent (%p != %p)\n",
396 a->ai_canonname, b->ai_canonname);
397 }
398 ok(!a && !b, "Expected both addresses null (%p != %p)\n", a, b);
399 }
400
401 static void compare_addrinfow (ADDRINFOW *a, ADDRINFOW *b)
402 {
403 for (; a && b ; a = a->ai_next, b = b->ai_next)
404 {
405 ok(a->ai_flags == b->ai_flags,
406 "Wrong flags %d != %d\n", a->ai_flags, b->ai_flags);
407 ok(a->ai_family == b->ai_family,
408 "Wrong family %d != %d\n", a->ai_family, b->ai_family);
409 ok(a->ai_socktype == b->ai_socktype,
410 "Wrong socktype %d != %d\n", a->ai_socktype, b->ai_socktype);
411 ok(a->ai_protocol == b->ai_protocol,
412 "Wrong protocol %d != %d\n", a->ai_protocol, b->ai_protocol);
413 ok(a->ai_addrlen == b->ai_addrlen,
414 "Wrong addrlen %lu != %lu\n", a->ai_addrlen, b->ai_addrlen);
415 ok(!memcmp(a->ai_addr, b->ai_addr, min(a->ai_addrlen, b->ai_addrlen)),
416 "Wrong address data\n");
417 if (a->ai_canonname && b->ai_canonname)
418 {
419 ok(!lstrcmpW(a->ai_canonname, b->ai_canonname), "Wrong canonical name '%s' != '%s'\n",
420 wine_dbgstr_w(a->ai_canonname), wine_dbgstr_w(b->ai_canonname));
421 }
422 else
423 ok(!a->ai_canonname && !b->ai_canonname, "Expected both names absent (%p != %p)\n",
424 a->ai_canonname, b->ai_canonname);
425 }
426 ok(!a && !b, "Expected both addresses null (%p != %p)\n", a, b);
427 }
428
429 /**************** Server utility functions ***************/
430
431 /*
432 * Even if we have closed our server socket cleanly,
433 * the OS may mark the address "in use" for some time -
434 * this happens with native Linux apps, too.
435 */
436 static void do_bind ( SOCKET s, struct sockaddr* addr, int addrlen )
437 {
438 int err, wsaerr = 0, n_try = BIND_TRIES;
439
440 while ( ( err = bind ( s, addr, addrlen ) ) != 0 &&
441 ( wsaerr = WSAGetLastError () ) == WSAEADDRINUSE &&
442 n_try-- >= 0)
443 {
444 trace ( "address in use, waiting ...\n" );
445 Sleep ( 1000 * BIND_SLEEP );
446 }
447 ok ( err == 0, "failed to bind: %d\n", wsaerr );
448 }
449
450 static void server_start ( server_params *par )
451 {
452 int i;
453 test_params *gen = par->general;
454 server_memory *mem = LocalAlloc ( LPTR, sizeof ( server_memory ) );
455
456 TlsSetValue ( tls, mem );
457 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
458 NULL, 0, par->sock_flags );
459 ok ( mem->s != INVALID_SOCKET, "Server: WSASocket failed\n" );
460
461 mem->addr.sin_family = AF_INET;
462 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
463 mem->addr.sin_port = htons ( gen->inet_port );
464
465 for (i = 0; i < MAX_CLIENTS; i++)
466 {
467 mem->sock[i].s = INVALID_SOCKET;
468 mem->sock[i].buf = LocalAlloc ( LPTR, gen->n_chunks * gen->chunk_size );
469 mem->sock[i].n_recvd = 0;
470 mem->sock[i].n_sent = 0;
471 }
472
473 if ( gen->sock_type == SOCK_STREAM )
474 do_bind ( mem->s, (struct sockaddr*) &mem->addr, sizeof (mem->addr) );
475 }
476
477 static void server_stop (void)
478 {
479 int i;
480 server_memory *mem = TlsGetValue ( tls );
481
482 for (i = 0; i < MAX_CLIENTS; i++ )
483 {
484 LocalFree ( mem->sock[i].buf );
485 if ( mem->sock[i].s != INVALID_SOCKET )
486 closesocket ( mem->sock[i].s );
487 }
488 ok ( closesocket ( mem->s ) == 0, "closesocket failed\n" );
489 LocalFree ( mem );
490 ExitThread ( GetCurrentThreadId () );
491 }
492
493 /**************** Client utilitiy functions ***************/
494
495 static void client_start ( client_params *par )
496 {
497 test_params *gen = par->general;
498 client_memory *mem = LocalAlloc (LPTR, sizeof (client_memory));
499
500 TlsSetValue ( tls, mem );
501
502 WaitForSingleObject ( server_ready, INFINITE );
503
504 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
505 NULL, 0, par->sock_flags );
506
507 mem->addr.sin_family = AF_INET;
508 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
509 mem->addr.sin_port = htons ( gen->inet_port );
510
511 ok ( mem->s != INVALID_SOCKET, "Client: WSASocket failed\n" );
512
513 mem->send_buf = LocalAlloc ( LPTR, 2 * gen->n_chunks * gen->chunk_size );
514 mem->recv_buf = mem->send_buf + gen->n_chunks * gen->chunk_size;
515 fill_buffer ( mem->send_buf, gen->chunk_size, gen->n_chunks );
516
517 SetEvent ( client_ready[client_id] );
518 /* Wait for the other clients to come up */
519 WaitForMultipleObjects ( min ( gen->n_clients, MAX_CLIENTS ), client_ready, TRUE, INFINITE );
520 }
521
522 static void client_stop (void)
523 {
524 client_memory *mem = TlsGetValue ( tls );
525 wsa_ok ( closesocket ( mem->s ), 0 ==, "closesocket error (%x): %d\n" );
526 LocalFree ( mem->send_buf );
527 LocalFree ( mem );
528 ExitThread(0);
529 }
530
531 /**************** Servers ***************/
532
533 /*
534 * simple_server: A very basic server doing synchronous IO.
535 */
536 static VOID WINAPI simple_server ( server_params *par )
537 {
538 test_params *gen = par->general;
539 server_memory *mem;
540 int pos, n_recvd, n_sent, n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
541 id = GetCurrentThreadId();
542
543 trace ( "simple_server (%x) starting\n", id );
544
545 set_so_opentype ( FALSE ); /* non-overlapped */
546 server_start ( par );
547 mem = TlsGetValue ( tls );
548
549 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
550 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "simple_server (%x): listen failed: %d\n");
551
552 trace ( "simple_server (%x) ready\n", id );
553 SetEvent ( server_ready ); /* notify clients */
554
555 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
556 {
557 trace ( "simple_server (%x): waiting for client\n", id );
558
559 /* accept a single connection */
560 tmp = sizeof ( mem->sock[0].peer );
561 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
562 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "simple_server (%x): accept failed: %d\n" );
563
564 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
565 "simple_server (%x): strange peer address\n", id );
566
567 /* Receive data & check it */
568 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
569 ok ( n_recvd == n_expected,
570 "simple_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
571 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
572 ok ( pos == -1, "simple_server (%x): test pattern error: %d\n", id, pos);
573
574 /* Echo data back */
575 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
576 ok ( n_sent == n_expected,
577 "simple_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
578
579 /* cleanup */
580 read_zero_bytes ( mem->sock[0].s );
581 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "simple_server (%x): closesocket error: %d\n" );
582 mem->sock[0].s = INVALID_SOCKET;
583 }
584
585 trace ( "simple_server (%x) exiting\n", id );
586 server_stop ();
587 }
588
589 /*
590 * oob_server: A very basic server receiving out-of-band data.
591 */
592 static VOID WINAPI oob_server ( server_params *par )
593 {
594 test_params *gen = par->general;
595 server_memory *mem;
596 u_long atmark = 0;
597 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, tmp,
598 id = GetCurrentThreadId();
599
600 trace ( "oob_server (%x) starting\n", id );
601
602 set_so_opentype ( FALSE ); /* non-overlapped */
603 server_start ( par );
604 mem = TlsGetValue ( tls );
605
606 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "oob_server (%x): failed to set blocking mode: %d\n");
607 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "oob_server (%x): listen failed: %d\n");
608
609 trace ( "oob_server (%x) ready\n", id );
610 SetEvent ( server_ready ); /* notify clients */
611
612 trace ( "oob_server (%x): waiting for client\n", id );
613
614 /* accept a single connection */
615 tmp = sizeof ( mem->sock[0].peer );
616 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
617 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "oob_server (%x): accept failed: %d\n" );
618
619 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
620 "oob_server (%x): strange peer address\n", id );
621
622 /* check initial atmark state */
623 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
624 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id, atmark );
625
626 /* Receive normal data */
627 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
628 ok ( n_recvd == n_expected,
629 "oob_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
630 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
631 ok ( pos == -1, "oob_server (%x): test pattern error: %d\n", id, pos);
632
633 /* check atmark state */
634 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
635 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id, atmark );
636
637 /* Echo data back */
638 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
639 ok ( n_sent == n_expected,
640 "oob_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
641
642 /* Receive a part of the out-of-band data and print atmark state */
643 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, 8, 0, par->buflen );
644 ok ( n_recvd == 8,
645 "oob_server (%x): received less data than expected: %d of %d\n", id, n_recvd, 8 );
646 n_expected -= 8;
647
648 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
649 trace( "oob_server (%x): %s the OOB mark: %i\n", id, atmark == 1 ? "not at" : "at", atmark );
650
651 /* Receive the rest of the out-of-band data and check atmark state */
652 do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
653
654 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
655 todo_wine ok ( atmark == 0, "oob_server (%x): not at the OOB mark: %i\n", id, atmark );
656
657 /* cleanup */
658 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "oob_server (%x): closesocket error: %d\n" );
659 mem->sock[0].s = INVALID_SOCKET;
660
661 trace ( "oob_server (%x) exiting\n", id );
662 server_stop ();
663 }
664
665 /*
666 * select_server: A non-blocking server.
667 */
668 static VOID WINAPI select_server ( server_params *par )
669 {
670 test_params *gen = par->general;
671 server_memory *mem;
672 int n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
673 id = GetCurrentThreadId(), n_connections = 0, n_sent, n_recvd,
674 n_set, delta, n_ready;
675 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
676 fd_set fds_recv, fds_send, fds_openrecv, fds_opensend;
677
678 trace ( "select_server (%x) starting\n", id );
679
680 set_so_opentype ( FALSE ); /* non-overlapped */
681 server_start ( par );
682 mem = TlsGetValue ( tls );
683
684 wsa_ok ( set_blocking ( mem->s, FALSE ), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
685 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "select_server (%x): listen failed: %d\n");
686
687 trace ( "select_server (%x) ready\n", id );
688 SetEvent ( server_ready ); /* notify clients */
689
690 FD_ZERO ( &fds_openrecv );
691 FD_ZERO ( &fds_recv );
692 FD_ZERO ( &fds_send );
693 FD_ZERO ( &fds_opensend );
694
695 FD_SET ( mem->s, &fds_openrecv );
696
697 while(1)
698 {
699 fds_recv = fds_openrecv;
700 fds_send = fds_opensend;
701
702 n_set = 0;
703
704 wsa_ok ( ( n_ready = select ( 0, &fds_recv, &fds_send, NULL, &timeout ) ), SOCKET_ERROR !=,
705 "select_server (%x): select() failed: %d\n" );
706
707 /* check for incoming requests */
708 if ( FD_ISSET ( mem->s, &fds_recv ) ) {
709 n_set += 1;
710
711 trace ( "select_server (%x): accepting client connection\n", id );
712
713 /* accept a single connection */
714 tmp = sizeof ( mem->sock[n_connections].peer );
715 mem->sock[n_connections].s = accept ( mem->s, (struct sockaddr*) &mem->sock[n_connections].peer, &tmp );
716 wsa_ok ( mem->sock[n_connections].s, INVALID_SOCKET !=, "select_server (%x): accept() failed: %d\n" );
717
718 ok ( mem->sock[n_connections].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
719 "select_server (%x): strange peer address\n", id );
720
721 /* add to list of open connections */
722 FD_SET ( mem->sock[n_connections].s, &fds_openrecv );
723 FD_SET ( mem->sock[n_connections].s, &fds_opensend );
724
725 n_connections++;
726 }
727
728 /* handle open requests */
729
730 for ( i = 0; i < n_connections; i++ )
731 {
732 if ( FD_ISSET( mem->sock[i].s, &fds_recv ) ) {
733 n_set += 1;
734
735 if ( mem->sock[i].n_recvd < n_expected ) {
736 /* Receive data & check it */
737 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 );
738 ok ( n_recvd != SOCKET_ERROR, "select_server (%x): error in recv(): %d\n", id, WSAGetLastError() );
739 mem->sock[i].n_recvd += n_recvd;
740
741 if ( mem->sock[i].n_recvd == n_expected ) {
742 int pos = test_buffer ( mem->sock[i].buf, gen->chunk_size, gen->n_chunks );
743 ok ( pos == -1, "select_server (%x): test pattern error: %d\n", id, pos );
744 FD_CLR ( mem->sock[i].s, &fds_openrecv );
745 }
746
747 ok ( mem->sock[i].n_recvd <= n_expected, "select_server (%x): received too many bytes: %d\n", id, mem->sock[i].n_recvd );
748 }
749 }
750
751 /* only echo back what we've received */
752 delta = mem->sock[i].n_recvd - mem->sock[i].n_sent;
753
754 if ( FD_ISSET ( mem->sock[i].s, &fds_send ) ) {
755 n_set += 1;
756
757 if ( ( delta > 0 ) && ( mem->sock[i].n_sent < n_expected ) ) {
758 /* Echo data back */
759 n_sent = send ( mem->sock[i].s, mem->sock[i].buf + mem->sock[i].n_sent, min ( delta, par->buflen ), 0 );
760 ok ( n_sent != SOCKET_ERROR, "select_server (%x): error in send(): %d\n", id, WSAGetLastError() );
761 mem->sock[i].n_sent += n_sent;
762
763 if ( mem->sock[i].n_sent == n_expected ) {
764 FD_CLR ( mem->sock[i].s, &fds_opensend );
765 }
766
767 ok ( mem->sock[i].n_sent <= n_expected, "select_server (%x): sent too many bytes: %d\n", id, mem->sock[i].n_sent );
768 }
769 }
770 }
771
772 /* check that select returned the correct number of ready sockets */
773 ok ( ( n_set == n_ready ), "select_server (%x): select() returns wrong number of ready sockets\n", id );
774
775 /* check if all clients are done */
776 if ( ( fds_opensend.fd_count == 0 )
777 && ( fds_openrecv.fd_count == 1 ) /* initial socket that accepts clients */
778 && ( n_connections == min ( gen->n_clients, MAX_CLIENTS ) ) ) {
779 break;
780 }
781 }
782
783 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
784 {
785 /* cleanup */
786 read_zero_bytes ( mem->sock[i].s );
787 wsa_ok ( closesocket ( mem->sock[i].s ), 0 ==, "select_server (%x): closesocket error: %d\n" );
788 mem->sock[i].s = INVALID_SOCKET;
789 }
790
791 trace ( "select_server (%x) exiting\n", id );
792 server_stop ();
793 }
794
795 /**************** Clients ***************/
796
797 /*
798 * simple_client: A very basic client doing synchronous IO.
799 */
800 static VOID WINAPI simple_client ( client_params *par )
801 {
802 test_params *gen = par->general;
803 client_memory *mem;
804 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
805
806 id = GetCurrentThreadId();
807 trace ( "simple_client (%x): starting\n", id );
808 /* wait here because we want to call set_so_opentype before creating a socket */
809 WaitForSingleObject ( server_ready, INFINITE );
810 trace ( "simple_client (%x): server ready\n", id );
811
812 check_so_opentype ();
813 set_so_opentype ( FALSE ); /* non-overlapped */
814 client_start ( par );
815 mem = TlsGetValue ( tls );
816
817 /* Connect */
818 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
819 0 ==, "simple_client (%x): connect error: %d\n" );
820 ok ( set_blocking ( mem->s, TRUE ) == 0,
821 "simple_client (%x): failed to set blocking mode\n", id );
822 trace ( "simple_client (%x) connected\n", id );
823
824 /* send data to server */
825 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
826 ok ( n_sent == n_expected,
827 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
828
829 /* shutdown send direction */
830 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
831
832 /* Receive data echoed back & check it */
833 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, 0, par->buflen );
834 ok ( n_recvd == n_expected,
835 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
836
837 /* check data */
838 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
839 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
840
841 /* cleanup */
842 read_zero_bytes ( mem->s );
843 trace ( "simple_client (%x) exiting\n", id );
844 client_stop ();
845 }
846
847 /*
848 * oob_client: A very basic client sending out-of-band data.
849 */
850 static VOID WINAPI oob_client ( client_params *par )
851 {
852 test_params *gen = par->general;
853 client_memory *mem;
854 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
855
856 id = GetCurrentThreadId();
857 trace ( "oob_client (%x): starting\n", id );
858 /* wait here because we want to call set_so_opentype before creating a socket */
859 WaitForSingleObject ( server_ready, INFINITE );
860 trace ( "oob_client (%x): server ready\n", id );
861
862 check_so_opentype ();
863 set_so_opentype ( FALSE ); /* non-overlapped */
864 client_start ( par );
865 mem = TlsGetValue ( tls );
866
867 /* Connect */
868 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
869 0 ==, "oob_client (%x): connect error: %d\n" );
870 ok ( set_blocking ( mem->s, TRUE ) == 0,
871 "oob_client (%x): failed to set blocking mode\n", id );
872 trace ( "oob_client (%x) connected\n", id );
873
874 /* send data to server */
875 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
876 ok ( n_sent == n_expected,
877 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
878
879 /* Receive data echoed back & check it */
880 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, 0, par->buflen );
881 ok ( n_recvd == n_expected,
882 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
883 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
884 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
885
886 /* send out-of-band data to server */
887 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, MSG_OOB, par->buflen );
888 ok ( n_sent == n_expected,
889 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
890
891 /* shutdown send direction */
892 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
893
894 /* cleanup */
895 read_zero_bytes ( mem->s );
896 trace ( "oob_client (%x) exiting\n", id );
897 client_stop ();
898 }
899
900 /*
901 * simple_mixed_client: mixing send and recvfrom
902 */
903 static VOID WINAPI simple_mixed_client ( client_params *par )
904 {
905 test_params *gen = par->general;
906 client_memory *mem;
907 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
908 int fromLen = sizeof(mem->addr);
909 struct sockaddr test;
910
911 id = GetCurrentThreadId();
912 trace ( "simple_client (%x): starting\n", id );
913 /* wait here because we want to call set_so_opentype before creating a socket */
914 WaitForSingleObject ( server_ready, INFINITE );
915 trace ( "simple_client (%x): server ready\n", id );
916
917 check_so_opentype ();
918 set_so_opentype ( FALSE ); /* non-overlapped */
919 client_start ( par );
920 mem = TlsGetValue ( tls );
921
922 /* Connect */
923 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
924 0 ==, "simple_client (%x): connect error: %d\n" );
925 ok ( set_blocking ( mem->s, TRUE ) == 0,
926 "simple_client (%x): failed to set blocking mode\n", id );
927 trace ( "simple_client (%x) connected\n", id );
928
929 /* send data to server */
930 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
931 ok ( n_sent == n_expected,
932 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
933
934 /* shutdown send direction */
935 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
936
937 /* this shouldn't change, since lpFrom, is not updated on
938 connection oriented sockets - exposed by bug 11640
939 */
940 ((struct sockaddr_in*)&test)->sin_addr.s_addr = inet_addr("0.0.0.0");
941
942 /* Receive data echoed back & check it */
943 n_recvd = do_synchronous_recvfrom ( mem->s,
944 mem->recv_buf,
945 n_expected,
946 0,
947 (struct sockaddr *)&test,
948 &fromLen,
949 par->buflen );
950 ok ( n_recvd == n_expected,
951 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
952
953 /* check that lpFrom was not updated */
954 ok(0 ==
955 strcmp(
956 inet_ntoa(((struct sockaddr_in*)&test)->sin_addr),
957 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
958
959 /* check data */
960 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
961 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
962
963 /* cleanup */
964 read_zero_bytes ( mem->s );
965 trace ( "simple_client (%x) exiting\n", id );
966 client_stop ();
967 }
968
969 /*
970 * event_client: An event-driven client
971 */
972 static void WINAPI event_client ( client_params *par )
973 {
974 test_params *gen = par->general;
975 client_memory *mem;
976 int id = GetCurrentThreadId(), n_expected = gen->n_chunks * gen->chunk_size,
977 tmp, err, n;
978 HANDLE event;
979 WSANETWORKEVENTS wsa_events;
980 char *send_last, *recv_last, *send_p, *recv_p;
981 LONG mask = FD_READ | FD_WRITE | FD_CLOSE;
982
983 trace ( "event_client (%x): starting\n", id );
984 client_start ( par );
985 trace ( "event_client (%x): server ready\n", id );
986
987 mem = TlsGetValue ( tls );
988
989 /* Prepare event notification for connect, makes socket nonblocking */
990 event = WSACreateEvent ();
991 WSAEventSelect ( mem->s, event, FD_CONNECT );
992 tmp = connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) );
993 if ( tmp != 0 ) {
994 err = WSAGetLastError ();
995 ok ( err == WSAEWOULDBLOCK, "event_client (%x): connect error: %d\n", id, err );
996 tmp = WaitForSingleObject ( event, INFINITE );
997 ok ( tmp == WAIT_OBJECT_0, "event_client (%x): wait for connect event failed: %d\n", id, tmp );
998 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
999 ok ( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
1000 err = wsa_events.iErrorCode[ FD_CONNECT_BIT ];
1001 ok ( err == 0, "event_client (%x): connect error: %d\n", id, err );
1002 if ( err ) goto out;
1003 }
1004
1005 trace ( "event_client (%x) connected\n", id );
1006
1007 WSAEventSelect ( mem->s, event, mask );
1008
1009 recv_p = mem->recv_buf;
1010 recv_last = mem->recv_buf + n_expected;
1011 send_p = mem->send_buf;
1012 send_last = mem->send_buf + n_expected;
1013
1014 while ( TRUE )
1015 {
1016 err = WaitForSingleObject ( event, INFINITE );
1017 ok ( err == WAIT_OBJECT_0, "event_client (%x): wait failed\n", id );
1018
1019 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
1020 ok( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
1021
1022 if ( wsa_events.lNetworkEvents & FD_WRITE )
1023 {
1024 err = wsa_events.iErrorCode[ FD_WRITE_BIT ];
1025 ok ( err == 0, "event_client (%x): FD_WRITE error code: %d\n", id, err );
1026
1027 if ( err== 0 )
1028 do
1029 {
1030 n = send ( mem->s, send_p, min ( send_last - send_p, par->buflen ), 0 );
1031 if ( n < 0 )
1032 {
1033 err = WSAGetLastError ();
1034 ok ( err == WSAEWOULDBLOCK, "event_client (%x): send error: %d\n", id, err );
1035 }
1036 else
1037 send_p += n;
1038 }
1039 while ( n >= 0 && send_p < send_last );
1040
1041 if ( send_p == send_last )
1042 {
1043 trace ( "event_client (%x): all data sent - shutdown\n", id );
1044 shutdown ( mem->s, SD_SEND );
1045 mask &= ~FD_WRITE;
1046 WSAEventSelect ( mem->s, event, mask );
1047 }
1048 }
1049 if ( wsa_events.lNetworkEvents & FD_READ )
1050 {
1051 err = wsa_events.iErrorCode[ FD_READ_BIT ];
1052 ok ( err == 0, "event_client (%x): FD_READ error code: %d\n", id, err );
1053 if ( err != 0 ) break;
1054
1055 /* First read must succeed */
1056 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
1057 wsa_ok ( n, 0 <=, "event_client (%x): recv error: %d\n" );
1058
1059 while ( n >= 0 ) {
1060 recv_p += n;
1061 if ( recv_p == recv_last )
1062 {
1063 mask &= ~FD_READ;
1064 trace ( "event_client (%x): all data received\n", id );
1065 WSAEventSelect ( mem->s, event, mask );
1066 break;
1067 }
1068 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
1069 if ( n < 0 && ( err = WSAGetLastError()) != WSAEWOULDBLOCK )
1070 ok ( 0, "event_client (%x): read error: %d\n", id, err );
1071
1072 }
1073 }
1074 if ( wsa_events.lNetworkEvents & FD_CLOSE )
1075 {
1076 trace ( "event_client (%x): close event\n", id );
1077 err = wsa_events.iErrorCode[ FD_CLOSE_BIT ];
1078 ok ( err == 0, "event_client (%x): FD_CLOSE error code: %d\n", id, err );
1079 break;
1080 }
1081 }
1082
1083 n = send_p - mem->send_buf;
1084 ok ( send_p == send_last,
1085 "simple_client (%x): sent less data than expected: %d of %d\n", id, n, n_expected );
1086 n = recv_p - mem->recv_buf;
1087 ok ( recv_p == recv_last,
1088 "simple_client (%x): received less data than expected: %d of %d\n", id, n, n_expected );
1089 n = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
1090 ok ( n == -1, "event_client (%x): test pattern error: %d\n", id, n);
1091
1092 out:
1093 WSACloseEvent ( event );
1094 trace ( "event_client (%x) exiting\n", id );
1095 client_stop ();
1096 }
1097
1098 /* Tests for WSAStartup */
1099 static void test_WithoutWSAStartup(void)
1100 {
1101 DWORD err;
1102
1103 WSASetLastError(0xdeadbeef);
1104 ok(WSASocketA(0, 0, 0, NULL, 0, 0) == INVALID_SOCKET, "WSASocketA should have failed\n");
1105 err = WSAGetLastError();
1106 ok(err == WSANOTINITIALISED, "Expected 10093, received %d\n", err);
1107
1108 WSASetLastError(0xdeadbeef);
1109 ok(gethostbyname("localhost") == NULL, "gethostbyname() succeeded unexpectedly\n");
1110 err = WSAGetLastError();
1111 ok(err == WSANOTINITIALISED, "Expected 10093, received %d\n", err);
1112 }
1113
1114 static void test_WithWSAStartup(void)
1115 {
1116 WSADATA data;
1117 WORD version = MAKEWORD( 2, 2 );
1118 INT res, socks, i, j;
1119 SOCKET sock;
1120 LPVOID ptr;
1121 struct
1122 {
1123 SOCKET src, dst, dup_src, dup_dst;
1124 } pairs[128];
1125 DWORD error;
1126
1127 res = WSAStartup( version, &data );
1128 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
1129
1130 ptr = gethostbyname("localhost");
1131 ok(ptr != NULL, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
1132
1133 /* Alloc some sockets to check if they are destroyed on WSACleanup */
1134 for (socks = 0; socks < sizeof(pairs) / sizeof(pairs[0]); socks++)
1135 {
1136 WSAPROTOCOL_INFOA info;
1137 if (tcp_socketpair(&pairs[socks].src, &pairs[socks].dst)) break;
1138
1139 memset(&info, 0, sizeof(info));
1140 ok(!WSADuplicateSocketA(pairs[socks].src, GetCurrentProcessId(), &info),
1141 "WSADuplicateSocketA should have worked\n");
1142 pairs[socks].dup_src = WSASocketA(0, 0, 0, &info, 0, 0);
1143 ok(pairs[socks].dup_src != SOCKET_ERROR, "expected != -1\n");
1144
1145 memset(&info, 0, sizeof(info));
1146 ok(!WSADuplicateSocketA(pairs[socks].dst, GetCurrentProcessId(), &info),
1147 "WSADuplicateSocketA should have worked\n");
1148 pairs[socks].dup_dst = WSASocketA(0, 0, 0, &info, 0, 0);
1149 ok(pairs[socks].dup_dst != SOCKET_ERROR, "expected != -1\n");
1150 }
1151
1152 res = send(pairs[0].src, "TEST", 4, 0);
1153 ok(res == 4, "send failed with error %d\n", WSAGetLastError());
1154
1155 WSACleanup();
1156
1157 res = WSAStartup( version, &data );
1158 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
1159
1160 /* show that sockets are destroyed automatically after WSACleanup */
1161 todo_wine {
1162 SetLastError(0xdeadbeef);
1163 res = send(pairs[0].src, "TEST", 4, 0);
1164 error = WSAGetLastError();
1165 ok(res == SOCKET_ERROR, "send should have failed\n");
1166 ok(error == WSAENOTSOCK, "expected 10038, got %d\n", error);
1167
1168 SetLastError(0xdeadbeef);
1169 res = send(pairs[0].dst, "TEST", 4, 0);
1170 error = WSAGetLastError();
1171 ok(res == SOCKET_ERROR, "send should have failed\n");
1172 ok(error == WSAENOTSOCK, "expected 10038, got %d\n", error);
1173
1174 /* Check that all sockets were destroyed */
1175 for (i = 0; i < socks; i++)
1176 {
1177 for (j = 0; j < 4; j++)
1178 {
1179 struct sockaddr_in saddr;
1180 int size = sizeof(saddr);
1181 switch(j)
1182 {
1183 case 0: sock = pairs[i].src; break;
1184 case 1: sock = pairs[i].dup_src; break;
1185 case 2: sock = pairs[i].dst; break;
1186 case 3: sock = pairs[i].dup_dst; break;
1187 }
1188
1189 SetLastError(0xdeadbeef);
1190 res = getsockname(sock, (struct sockaddr *)&saddr, &size);
1191 error = WSAGetLastError();
1192 ok(res == SOCKET_ERROR, "Test[%d]: getsockname should have failed\n", i);
1193 ok(error == WSAENOTSOCK, "Test[%d]: expected 10038, got %d\n", i, error);
1194 }
1195 }
1196
1197 }
1198
1199 /* While wine is not fixed, close all sockets manually */
1200 for (i = 0; i < socks; i++)
1201 {
1202 closesocket(pairs[i].src);
1203 closesocket(pairs[i].dst);
1204 closesocket(pairs[i].dup_src);
1205 closesocket(pairs[i].dup_dst);
1206 }
1207
1208 res = WSACleanup();
1209 ok(res == 0, "expected 0, got %d\n", res);
1210 WSASetLastError(0xdeadbeef);
1211 res = WSACleanup();
1212 error = WSAGetLastError();
1213 ok ( (res == SOCKET_ERROR && error == WSANOTINITIALISED) ||
1214 broken(res == 0), /* WinME */
1215 "WSACleanup returned %d WSAGetLastError is %d\n", res, error);
1216 }
1217
1218 /**************** Main program utility functions ***************/
1219
1220 static void Init (void)
1221 {
1222 WORD ver = MAKEWORD (2, 2);
1223 WSADATA data;
1224 HMODULE hws2_32 = GetModuleHandleA("ws2_32.dll"), hiphlpapi;
1225
1226 pfreeaddrinfo = (void *)GetProcAddress(hws2_32, "freeaddrinfo");
1227 pgetaddrinfo = (void *)GetProcAddress(hws2_32, "getaddrinfo");
1228 pFreeAddrInfoW = (void *)GetProcAddress(hws2_32, "FreeAddrInfoW");
1229 pGetAddrInfoW = (void *)GetProcAddress(hws2_32, "GetAddrInfoW");
1230 pInetNtop = (void *)GetProcAddress(hws2_32, "inet_ntop");
1231 pInetNtopW = (void *)GetProcAddress(hws2_32, "InetNtopW");
1232 pInetPtonA = (void *)GetProcAddress(hws2_32, "inet_pton");
1233 pInetPtonW = (void *)GetProcAddress(hws2_32, "InetPtonW");
1234 pWSALookupServiceBeginW = (void *)GetProcAddress(hws2_32, "WSALookupServiceBeginW");
1235 pWSALookupServiceEnd = (void *)GetProcAddress(hws2_32, "WSALookupServiceEnd");
1236 pWSALookupServiceNextW = (void *)GetProcAddress(hws2_32, "WSALookupServiceNextW");
1237 pWSAEnumNameSpaceProvidersA = (void *)GetProcAddress(hws2_32, "WSAEnumNameSpaceProvidersA");
1238 pWSAEnumNameSpaceProvidersW = (void *)GetProcAddress(hws2_32, "WSAEnumNameSpaceProvidersW");
1239 pWSAPoll = (void *)GetProcAddress(hws2_32, "WSAPoll");
1240
1241 hiphlpapi = LoadLibraryA("iphlpapi.dll");
1242 if (hiphlpapi)
1243 {
1244 pGetIpForwardTable = (void *)GetProcAddress(hiphlpapi, "GetIpForwardTable");
1245 pGetAdaptersInfo = (void *)GetProcAddress(hiphlpapi, "GetAdaptersInfo");
1246 }
1247
1248 ok ( WSAStartup ( ver, &data ) == 0, "WSAStartup failed\n" );
1249 tls = TlsAlloc();
1250 }
1251
1252 static void Exit (void)
1253 {
1254 INT ret, err;
1255 TlsFree ( tls );
1256 ret = WSACleanup();
1257 err = WSAGetLastError();
1258 ok ( ret == 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret, err);
1259 }
1260
1261 static void StartServer (LPTHREAD_START_ROUTINE routine,
1262 test_params *general, server_params *par)
1263 {
1264 par->general = general;
1265 thread[0] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[0] );
1266 ok ( thread[0] != NULL, "Failed to create server thread\n" );
1267 }
1268
1269 static void StartClients (LPTHREAD_START_ROUTINE routine,
1270 test_params *general, client_params *par)
1271 {
1272 int i;
1273 par->general = general;
1274 for ( i = 1; i <= min ( general->n_clients, MAX_CLIENTS ); i++ )
1275 {
1276 client_id = i - 1;
1277 thread[i] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[i] );
1278 ok ( thread[i] != NULL, "Failed to create client thread\n" );
1279 /* Make sure the client is up and running */
1280 WaitForSingleObject ( client_ready[client_id], INFINITE );
1281 };
1282 }
1283
1284 static void do_test( test_setup *test )
1285 {
1286 DWORD i, n = min (test->general.n_clients, MAX_CLIENTS);
1287 DWORD wait;
1288
1289 server_ready = CreateEventA ( NULL, TRUE, FALSE, NULL );
1290 for (i = 0; i <= n; i++)
1291 client_ready[i] = CreateEventA ( NULL, TRUE, FALSE, NULL );
1292
1293 StartServer ( test->srv, &test->general, &test->srv_params );
1294 StartClients ( test->clt, &test->general, &test->clt_params );
1295 WaitForSingleObject ( server_ready, INFINITE );
1296
1297 wait = WaitForMultipleObjects ( 1 + n, thread, TRUE, 1000 * TEST_TIMEOUT );
1298 ok ( wait <= WAIT_OBJECT_0 + n ,
1299 "some threads have not completed: %x\n", wait );
1300
1301 if ( ! ( wait <= WAIT_OBJECT_0 + n ) )
1302 {
1303 for (i = 0; i <= n; i++)
1304 {
1305 if ( WaitForSingleObject ( thread[i], 0 ) != WAIT_OBJECT_0 )
1306 {
1307 trace ("terminating thread %08x\n", thread_id[i]);
1308 TerminateThread ( thread [i], 0 );
1309 }
1310 }
1311 }
1312 CloseHandle ( server_ready );
1313 for (i = 0; i <= n; i++)
1314 CloseHandle ( client_ready[i] );
1315 }
1316
1317 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1318 /* optname = SO_LINGER */
1319 static const LINGER linger_testvals[] = {
1320 {0,0},
1321 {0,73},
1322 {1,0},
1323 {5,189}
1324 };
1325
1326 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1327 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1328 bug in the linux kernel (fixed in 2.6.8) */
1329 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1330
1331 static void test_set_getsockopt(void)
1332 {
1333 SOCKET s, s2;
1334 int i, err, lasterr;
1335 int timeout;
1336 LINGER lingval;
1337 int size;
1338 WSAPROTOCOL_INFOA infoA;
1339 WSAPROTOCOL_INFOW infoW;
1340 char providername[WSAPROTOCOL_LEN + 1];
1341 DWORD value;
1342 struct _prottest
1343 {
1344 int family, type, proto;
1345 } prottest[] = {
1346 {AF_INET, SOCK_STREAM, IPPROTO_TCP},
1347 {AF_INET, SOCK_DGRAM, IPPROTO_UDP},
1348 {AF_INET6, SOCK_STREAM, IPPROTO_TCP},
1349 {AF_INET6, SOCK_DGRAM, IPPROTO_UDP}
1350 };
1351 union _csspace
1352 {
1353 CSADDR_INFO cs;
1354 char space[128];
1355 } csinfoA, csinfoB;
1356
1357 s = socket(AF_INET, SOCK_STREAM, 0);
1358 ok(s!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1359 if( s == INVALID_SOCKET) return;
1360 /* SO_RCVTIMEO */
1361 timeout = SOCKTIMEOUT1;
1362 size = sizeof(timeout);
1363 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1364 if( !err)
1365 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1366 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1367 ok( timeout == SOCKTIMEOUT1, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1368
1369 timeout = 0;
1370 size = sizeof(timeout);
1371 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1372 if( !err)
1373 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1374 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1375 ok( timeout == 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1376
1377 /* SO_SNDTIMEO */
1378 timeout = SOCKTIMEOUT2; /* 997 seconds. See remark above */
1379 size = sizeof(timeout);
1380 err = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, size);
1381 if( !err)
1382 err = getsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, &size);
1383 ok( !err, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1384 ok( timeout == SOCKTIMEOUT2, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout);
1385
1386 /* SO_SNDBUF */
1387 value = 4096;
1388 size = sizeof(value);
1389 err = setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&value, size);
1390 ok( !err, "setsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1391 value = 0xdeadbeef;
1392 err = getsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&value, &size);
1393 ok( !err, "getsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1394 todo_wine ok( value == 4096, "expected 4096, got %u\n", value );
1395
1396 /* SO_RCVBUF */
1397 value = 4096;
1398 size = sizeof(value);
1399 err = setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, size);
1400 ok( !err, "setsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1401 value = 0xdeadbeef;
1402 err = getsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, &size);
1403 ok( !err, "getsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1404 todo_wine ok( value == 4096, "expected 4096, got %u\n", value );
1405
1406 /* SO_LINGER */
1407 for( i = 0; i < sizeof(linger_testvals)/sizeof(LINGER);i++) {
1408 size = sizeof(lingval);
1409 lingval = linger_testvals[i];
1410 err = setsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, size);
1411 if( !err)
1412 err = getsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, &size);
1413 ok( !err, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
1414 ok( !lingval.l_onoff == !linger_testvals[i].l_onoff &&
1415 (lingval.l_linger == linger_testvals[i].l_linger ||
1416 (!lingval.l_linger && !linger_testvals[i].l_onoff))
1417 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i,
1418 lingval.l_onoff, lingval.l_linger,
1419 linger_testvals[i].l_onoff, linger_testvals[i].l_linger);
1420 }
1421
1422 size = sizeof(lingval);
1423 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, size);
1424 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1425 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1426 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, 0);
1427 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1428 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1429
1430 size = sizeof(BOOL);
1431 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, size);
1432 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1433 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1434 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, 0);
1435 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1436 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1437
1438 /* Test for erroneously passing a value instead of a pointer as optval */
1439 size = sizeof(char);
1440 err = setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)1, size);
1441 ok(err == SOCKET_ERROR, "setsockopt with optval being a value passed "
1442 "instead of failing.\n");
1443 lasterr = WSAGetLastError();
1444 ok(lasterr == WSAEFAULT, "setsockopt with optval being a value "
1445 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1446 lasterr, WSAEFAULT);
1447
1448 /* SO_RCVTIMEO with invalid values for level */
1449 size = sizeof(timeout);
1450 timeout = SOCKTIMEOUT1;
1451 SetLastError(0xdeadbeef);
1452 err = setsockopt(s, 0xffffffff, SO_RCVTIMEO, (char *) &timeout, size);
1453 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1454 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1455 err, WSAGetLastError());
1456
1457 timeout = SOCKTIMEOUT1;
1458 SetLastError(0xdeadbeef);
1459 err = setsockopt(s, 0x00008000, SO_RCVTIMEO, (char *) &timeout, size);
1460 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1461 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1462 err, WSAGetLastError());
1463
1464 /* Test SO_ERROR set/get */
1465 SetLastError(0xdeadbeef);
1466 i = 1234;
1467 err = setsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, size);
1468 todo_wine
1469 ok( !err && !WSAGetLastError(),
1470 "got %d with %d (expected 0 with 0)\n",
1471 err, WSAGetLastError());
1472
1473 SetLastError(0xdeadbeef);
1474 i = 4321;
1475 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1476 todo_wine
1477 ok( !err && !WSAGetLastError(),
1478 "got %d with %d (expected 0 with 0)\n",
1479 err, WSAGetLastError());
1480 todo_wine
1481 ok (i == 1234, "got %d (expected 1234)\n", i);
1482
1483 /* Test invalid optlen */
1484 SetLastError(0xdeadbeef);
1485 size = 1;
1486 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1487 todo_wine
1488 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEFAULT),
1489 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1490 err, WSAGetLastError());
1491
1492 closesocket(s);
1493 /* Test with the closed socket */
1494 SetLastError(0xdeadbeef);
1495 size = sizeof(i);
1496 i = 1234;
1497 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1498 todo_wine
1499 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAENOTSOCK),
1500 "got %d with %d (expected SOCKET_ERROR with WSAENOTSOCK)\n",
1501 err, WSAGetLastError());
1502 ok (i == 1234, "expected 1234, got %d\n", i);
1503
1504 /* Test WS_IP_MULTICAST_TTL with 8, 16, 24 and 32 bits values */
1505 s = socket(AF_INET, SOCK_DGRAM, 0);
1506 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1507 size = sizeof(i);
1508 i = 0x0000000a;
1509 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &i, size);
1510 if (!err)
1511 {
1512 for (i = 0; i < 4; i++)
1513 {
1514 int k, j;
1515 const int tests[] = {0xffffff0a, 0xffff000b, 0xff00000c, 0x0000000d};
1516 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &tests[i], i + 1);
1517 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1518 err = getsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &k, &size);
1519 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1520 j = i != 3 ? tests[i] & ((1 << (i + 1) * 8) - 1) : tests[i];
1521 ok(k == j, "Test [%d] Expected 0x%x, got 0x%x\n", i, j, k);
1522 }
1523 }
1524 else
1525 win_skip("IP_MULTICAST_TTL is unsupported\n");
1526 closesocket(s);
1527
1528 /* test SO_PROTOCOL_INFOA invalid parameters */
1529 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1530 "getsockopt should have failed\n");
1531 err = WSAGetLastError();
1532 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1533 size = sizeof(WSAPROTOCOL_INFOA);
1534 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1535 "getsockopt should have failed\n");
1536 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1537 err = WSAGetLastError();
1538 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1539 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1540 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1541 "getsockopt should have failed\n");
1542 err = WSAGetLastError();
1543 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1544 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, NULL),
1545 "getsockopt should have failed\n");
1546 err = WSAGetLastError();
1547 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1548 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, &size),
1549 "getsockopt should have failed\n");
1550 err = WSAGetLastError();
1551 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1552 size = sizeof(WSAPROTOCOL_INFOA) / 2;
1553 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1554 "getsockopt should have failed\n");
1555 err = WSAGetLastError();
1556 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1557 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1558 size = sizeof(WSAPROTOCOL_INFOA) * 2;
1559 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1560 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1561 ok(size == sizeof(WSAPROTOCOL_INFOA) * 2, "got size %d\n", size);
1562
1563 closesocket(s);
1564
1565 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1566 for (i = 0; i < sizeof(prottest) / sizeof(prottest[0]); i++)
1567 {
1568 s = socket(prottest[i].family, prottest[i].type, prottest[i].proto);
1569 if (s == INVALID_SOCKET && prottest[i].family == AF_INET6) continue;
1570
1571 ok(s != INVALID_SOCKET, "Failed to create socket: %d\n",
1572 WSAGetLastError());
1573
1574 /* compare both A and W version */
1575 infoA.szProtocol[0] = 0;
1576 size = sizeof(WSAPROTOCOL_INFOA);
1577 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1578 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1579 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1580
1581 infoW.szProtocol[0] = 0;
1582 size = sizeof(WSAPROTOCOL_INFOW);
1583 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOW, (char *) &infoW, &size);
1584 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1585 ok(size == sizeof(WSAPROTOCOL_INFOW), "got size %d\n", size);
1586
1587 trace("provider name '%s', family %d, type %d, proto %d\n",
1588 infoA.szProtocol, prottest[i].family, prottest[i].type, prottest[i].proto);
1589
1590 ok(infoA.szProtocol[0] || broken(!infoA.szProtocol[0]) /* NT4 */,
1591 "WSAPROTOCOL_INFOA was not filled\n");
1592 ok(infoW.szProtocol[0] || broken(!infoA.szProtocol[0]) /* NT4 */,
1593 "WSAPROTOCOL_INFOW was not filled\n");
1594
1595 WideCharToMultiByte(CP_ACP, 0, infoW.szProtocol, -1,
1596 providername, sizeof(providername), NULL, NULL);
1597 ok(!strcmp(infoA.szProtocol,providername),
1598 "different provider names '%s' != '%s'\n", infoA.szProtocol, providername);
1599
1600 ok(!memcmp(&infoA, &infoW, FIELD_OFFSET(WSAPROTOCOL_INFOA, szProtocol)),
1601 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1602
1603 /* Remove IF when WSAEnumProtocols support IPV6 data */
1604 todo_wine_if (prottest[i].family == AF_INET6)
1605 ok(infoA.iAddressFamily == prottest[i].family, "socket family invalid, expected %d received %d\n",
1606 prottest[i].family, infoA.iAddressFamily);
1607 ok(infoA.iSocketType == prottest[i].type, "socket type invalid, expected %d received %d\n",
1608 prottest[i].type, infoA.iSocketType);
1609 ok(infoA.iProtocol == prottest[i].proto, "socket protocol invalid, expected %d received %d\n",
1610 prottest[i].proto, infoA.iProtocol);
1611
1612 closesocket(s);
1613 }
1614
1615 /* Test SO_BSP_STATE - Present only in >= Win 2008 */
1616 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1617 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1618 s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1619 ok(s2 != INVALID_SOCKET, "Failed to create socket\n");
1620
1621 SetLastError(0xdeadbeef);
1622 size = sizeof(csinfoA);
1623 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1624 if (!err)
1625 {
1626 struct sockaddr_in saddr;
1627 memset(&saddr, 0, sizeof(saddr));
1628 saddr.sin_family = AF_INET;
1629 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1630
1631 /* Socket is not bound, no information provided */
1632 ok(!csinfoA.cs.LocalAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.LocalAddr.iSockaddrLength);
1633 ok(csinfoA.cs.LocalAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.LocalAddr.lpSockaddr);
1634 /* Socket is not connected, no information provided */
1635 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.LocalAddr.iSockaddrLength);
1636 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.LocalAddr.lpSockaddr);
1637
1638 err = bind(s, (struct sockaddr*)&saddr, sizeof(saddr));
1639 ok(!err, "Expected 0, got %d\n", err);
1640 size = sizeof(csinfoA);
1641 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1642 ok(!err, "Expected 0, got %d\n", err);
1643
1644 /* Socket is bound */
1645 ok(csinfoA.cs.LocalAddr.iSockaddrLength, "Expected non-zero\n");
1646 ok(csinfoA.cs.LocalAddr.lpSockaddr != NULL, "Expected non-null\n");
1647 /* Socket is not connected, no information provided */
1648 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.LocalAddr.iSockaddrLength);
1649 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.LocalAddr.lpSockaddr);
1650
1651 err = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1652 ok(!err, "Expected 0, got %d\n", err);
1653 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1654 ok(!err, "Expected 0, got %d\n", err);
1655 err = listen(s2, 1);
1656 ok(!err, "Expected 0, got %d\n", err);
1657 err = connect(s, (struct sockaddr*)&saddr, sizeof(saddr));
1658 ok(!err, "Expected 0, got %d\n", err);
1659 size = sizeof(saddr);
1660 err = accept(s2, (struct sockaddr*)&saddr, &size);
1661 ok(err != INVALID_SOCKET, "Failed to accept socket\n");
1662 closesocket(s2);
1663 s2 = err;
1664
1665 size = sizeof(csinfoA);
1666 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1667 ok(!err, "Expected 0, got %d\n", err);
1668 err = getsockopt(s2, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoB, &size);
1669 ok(!err, "Expected 0, got %d\n", err);
1670 ok(size == sizeof(csinfoA), "Got %d\n", size);
1671 size = sizeof(saddr);
1672 ok(size == csinfoA.cs.LocalAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1673 csinfoA.cs.LocalAddr.iSockaddrLength);
1674 ok(size == csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1675 csinfoA.cs.RemoteAddr.iSockaddrLength);
1676 ok(!memcmp(csinfoA.cs.LocalAddr.lpSockaddr, csinfoB.cs.RemoteAddr.lpSockaddr, size),
1677 "Expected matching addresses\n");
1678 ok(!memcmp(csinfoB.cs.LocalAddr.lpSockaddr, csinfoA.cs.RemoteAddr.lpSockaddr, size),
1679 "Expected matching addresses\n");
1680 ok(csinfoA.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1681 ok(csinfoB.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1682 ok(csinfoA.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1683 ok(csinfoB.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1684
1685 err = getpeername(s, (struct sockaddr *)&saddr, &size);
1686 ok(!err, "Expected 0, got %d\n", err);
1687 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1688 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1689 err = getpeername(s2, (struct sockaddr *)&saddr, &size);
1690 ok(!err, "Expected 0, got %d\n", err);
1691 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1692 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1693 err = getsockname(s, (struct sockaddr *)&saddr, &size);
1694 ok(!err, "Expected 0, got %d\n", err);
1695 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1696 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1697 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1698 ok(!err, "Expected 0, got %d\n", err);
1699 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1700 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1701
1702 SetLastError(0xdeadbeef);
1703 size = sizeof(CSADDR_INFO);
1704 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1705 ok(err, "Expected non-zero\n");
1706 ok(size == sizeof(CSADDR_INFO), "Got %d\n", size);
1707 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %d\n", GetLastError());
1708
1709 /* At least for IPv4 the size is exactly 56 bytes */
1710 size = sizeof(*csinfoA.cs.LocalAddr.lpSockaddr) * 2 + sizeof(csinfoA.cs);
1711 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1712 ok(!err, "Expected 0, got %d\n", err);
1713 size--;
1714 SetLastError(0xdeadbeef);
1715 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1716 ok(err, "Expected non-zero\n");
1717 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %d\n", GetLastError());
1718 }
1719 else
1720 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %d\n", GetLastError());
1721
1722 closesocket(s);
1723 closesocket(s2);
1724 }
1725
1726 static void test_so_reuseaddr(void)
1727 {
1728 struct sockaddr_in saddr;
1729 SOCKET s1,s2;
1730 unsigned int rc,reuse;
1731 int size;
1732 DWORD err;
1733
1734 saddr.sin_family = AF_INET;
1735 saddr.sin_port = htons(9375);
1736 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1737
1738 s1=socket(AF_INET, SOCK_STREAM, 0);
1739 ok(s1!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1740 rc = bind(s1, (struct sockaddr*)&saddr, sizeof(saddr));
1741 ok(rc!=SOCKET_ERROR, "bind(s1) failed error: %d\n", WSAGetLastError());
1742
1743 s2=socket(AF_INET, SOCK_STREAM, 0);
1744 ok(s2!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1745
1746 reuse=0x1234;
1747 size=sizeof(reuse);
1748 rc=getsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, &size );
1749 ok(rc==0 && reuse==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc,reuse);
1750
1751 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1752 ok(rc==SOCKET_ERROR, "bind() succeeded\n");
1753
1754 reuse = 1;
1755 rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
1756 ok(rc==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1757
1758 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1759 * a port immediately after closing another socket on that port, so
1760 * basically following the BSD socket semantics here. */
1761 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1762 if(rc==0)
1763 {
1764 int s3=socket(AF_INET, SOCK_STREAM, 0), s4;
1765 trace("<= Win XP behavior of SO_REUSEADDR\n");
1766
1767 /* If we could bind again in the same port this is Windows version <= XP.
1768 * Lets test if we can really connect to one of them. */
1769 set_blocking(s1, FALSE);
1770 set_blocking(s2, FALSE);
1771 rc = listen(s1, 1);
1772 ok(!rc, "listen() failed with error: %d\n", WSAGetLastError());
1773 rc = listen(s2, 1);
1774 ok(!rc, "listen() failed with error: %d\n", WSAGetLastError());
1775 rc = connect(s3, (struct sockaddr*)&saddr, sizeof(saddr));
1776 ok(!rc, "connecting to accepting socket failed %d\n", WSAGetLastError());
1777
1778 /* the delivery of the connection is random so we need to try on both sockets */
1779 size = sizeof(saddr);
1780 s4 = accept(s1, (struct sockaddr*)&saddr, &size);
1781 if(s4 == INVALID_SOCKET)
1782 s4 = accept(s2, (struct sockaddr*)&saddr, &size);
1783 ok(s4 != INVALID_SOCKET, "none of the listening sockets could get the connection\n");
1784
1785 closesocket(s1);
1786 closesocket(s3);
1787 closesocket(s4);
1788 }
1789 else
1790 {
1791 trace(">= Win 2003 behavior of SO_REUSEADDR\n");
1792 err = WSAGetLastError();
1793 ok(err==WSAEACCES, "expected 10013, got %d\n", err);
1794
1795 closesocket(s1);
1796 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1797 ok(rc==0, "bind() failed error: %d\n", WSAGetLastError());
1798 }
1799
1800 closesocket(s2);
1801 }
1802
1803 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
1804
1805 static void test_ip_pktinfo(void)
1806 {
1807 ULONG addresses[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY)};
1808 char recvbuf[10], pktbuf[512], msg[] = "HELLO";
1809 struct sockaddr_in s1addr, s2addr, s3addr;
1810 GUID WSARecvMsg_GUID = WSAID_WSARECVMSG;
1811 LPFN_WSARECVMSG pWSARecvMsg = NULL;
1812 unsigned int rc, yes = 1;
1813 BOOL foundhdr;
1814 DWORD dwBytes, dwSize, dwFlags;
1815 socklen_t addrlen;
1816 WSACMSGHDR *cmsg;
1817 WSAOVERLAPPED ov;
1818 WSABUF iovec[1];
1819 SOCKET s1, s2;
1820 WSAMSG hdr;
1821 int i, err;
1822
1823 memset(&ov, 0, sizeof(ov));
1824 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
1825 if (ov.hEvent == INVALID_HANDLE_VALUE)
1826 {
1827 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
1828 return;
1829 }
1830
1831 memset(&hdr, 0x00, sizeof(hdr));
1832 s1addr.sin_family = AF_INET;
1833 s1addr.sin_port = htons(0);
1834 /* Note: s1addr.sin_addr is set below */
1835 iovec[0].buf = recvbuf;
1836 iovec[0].len = sizeof(recvbuf);
1837 hdr.name = (struct sockaddr*)&s3addr;
1838 hdr.namelen = sizeof(s3addr);
1839 hdr.lpBuffers = &iovec[0];
1840 hdr.dwBufferCount = 1;
1841 hdr.Control.buf = pktbuf;
1842 /* Note: hdr.Control.len is set below */
1843 hdr.dwFlags = 0;
1844
1845 for (i=0;i<sizeof(addresses)/sizeof(UINT32);i++)
1846 {
1847 s1addr.sin_addr.s_addr = addresses[i];
1848
1849 /* Build "server" side socket */
1850 s1=socket(AF_INET, SOCK_DGRAM, 0);
1851 if (s1 == INVALID_SOCKET)
1852 {
1853 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1854 goto cleanup;
1855 }
1856
1857 /* Obtain the WSARecvMsg function */
1858 WSAIoctl(s1, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
1859 &pWSARecvMsg, sizeof(pWSARecvMsg), &dwBytes, NULL, NULL);
1860 if (!pWSARecvMsg)
1861 {
1862 win_skip("WSARecvMsg is unsupported, some tests will be skipped.\n");
1863 closesocket(s1);
1864 goto cleanup;
1865 }
1866
1867 /* Setup the server side socket */
1868 rc=bind(s1, (struct sockaddr*)&s1addr, sizeof(s1addr));
1869 ok(rc != SOCKET_ERROR, "bind() failed error: %d\n", WSAGetLastError());
1870 rc=setsockopt(s1, IPPROTO_IP, IP_PKTINFO, (const char*)&yes, sizeof(yes));
1871 ok(rc == 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
1872
1873 /* Build "client" side socket */
1874 addrlen = sizeof(s2addr);
1875 if (getsockname(s1, (struct sockaddr *) &s2addr, &addrlen) != 0)
1876 {
1877 skip("Failed to call getsockname, some tests skipped: %d\n", WSAGetLastError());
1878 closesocket(s1);
1879 goto cleanup;
1880 }
1881 s2addr.sin_addr.s_addr = addresses[0]; /* Always target the local adapter address */
1882 s2=socket(AF_INET, SOCK_DGRAM, 0);
1883 if (s2 == INVALID_SOCKET)
1884 {
1885 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1886 closesocket(s1);
1887 goto cleanup;
1888 }
1889
1890 /* Test an empty message header */
1891 rc=pWSARecvMsg(s1, NULL, NULL, NULL, NULL);
1892 err=WSAGetLastError();
1893 ok(rc == SOCKET_ERROR && err == WSAEFAULT, "WSARecvMsg() failed error: %d (ret = %d)\n", err, rc);
1894
1895 /*
1896 * Send a packet from the client to the server and test for specifying
1897 * a short control header.
1898 */
1899 SetLastError(0xdeadbeef);
1900 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
1901 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
1902 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
1903 hdr.Control.len = 1;
1904 rc=pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
1905 err=WSAGetLastError();
1906 ok(rc == SOCKET_ERROR && err == WSAEMSGSIZE && (hdr.dwFlags & MSG_CTRUNC),
1907 "WSARecvMsg() failed error: %d (ret: %d, flags: %d)\n", err, rc, hdr.dwFlags);
1908 hdr.dwFlags = 0; /* Reset flags */
1909
1910 /* Perform another short control header test, this time with an overlapped receive */
1911 hdr.Control.len = 1;
1912 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
1913 err=WSAGetLastError();
1914 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
1915 SetLastError(0xdeadbeef);
1916 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
1917 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
1918 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
1919 if (WaitForSingleObject(ov.hEvent, 100) != WAIT_OBJECT_0)
1920 {
1921 skip("Server side did not receive packet, some tests skipped.\n");
1922 closesocket(s2);
1923 closesocket(s1);
1924 continue;
1925 }
1926 dwFlags = 0;
1927 WSAGetOverlappedResult(s1, &ov, NULL, FALSE, &dwFlags);
1928 ok(dwFlags == 0,
1929 "WSAGetOverlappedResult() returned unexpected flags %d!\n", dwFlags);
1930 ok(hdr.dwFlags == MSG_CTRUNC,
1931 "WSARecvMsg() overlapped operation set unexpected flags %d.\n", hdr.dwFlags);
1932 hdr.dwFlags = 0; /* Reset flags */
1933
1934 /*
1935 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
1936 * on the server end and check that the returned packet matches what was sent.
1937 */
1938 hdr.Control.len = sizeof(pktbuf);
1939 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
1940 err=WSAGetLastError();
1941 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
1942 ok(hdr.Control.len == sizeof(pktbuf),
1943 "WSARecvMsg() control length mismatch (%d != sizeof pktbuf).\n", hdr.Control.len);
1944 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
1945 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
1946 if (WaitForSingleObject(ov.hEvent, 100) != WAIT_OBJECT_0)
1947 {
1948 skip("Server side did not receive packet, some tests skipped.\n");
1949 closesocket(s2);
1950 closesocket(s1);
1951 continue;
1952 }
1953 dwSize = 0;
1954 WSAGetOverlappedResult(s1, &ov, &dwSize, FALSE, NULL);
1955 ok(dwSize == sizeof(msg),
1956 "WSARecvMsg() buffer length does not match transmitted data!\n");
1957 ok(strncmp(iovec[0].buf, msg, sizeof(msg)) == 0,
1958 "WSARecvMsg() buffer does not match transmitted data!\n");
1959 ok(hdr.Control.len == IP_PKTINFO_LEN,
1960 "WSARecvMsg() control length mismatch (%d).\n", hdr.Control.len);
1961
1962 /* Test for the expected IP_PKTINFO return information. */
1963 foundhdr = FALSE;
1964 for (cmsg = WSA_CMSG_FIRSTHDR(&hdr); cmsg != NULL; cmsg = WSA_CMSG_NXTHDR(&hdr, cmsg))
1965 {
1966 if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO)
1967 {
1968 struct in_pktinfo *pi = (struct in_pktinfo *)WSA_CMSG_DATA(cmsg);
1969
1970 ok(pi->ipi_addr.s_addr == s2addr.sin_addr.s_addr, "destination ip mismatch!\n");
1971 foundhdr = TRUE;
1972 }
1973 }
1974 ok(foundhdr, "IP_PKTINFO header information was not returned!\n");
1975
1976 closesocket(s2);
1977 closesocket(s1);
1978 }
1979
1980 cleanup:
1981 CloseHandle(ov.hEvent);
1982 }
1983
1984 /************* Array containing the tests to run **********/
1985
1986 #define STD_STREAM_SOCKET \
1987 SOCK_STREAM, \
1988 0, \
1989 SERVERIP, \
1990 SERVERPORT
1991
1992 static test_setup tests [] =
1993 {
1994 /* Test 0: synchronous client and server */
1995 {
1996 {
1997 STD_STREAM_SOCKET,
1998 2048,
1999 16,
2000 2
2001 },
2002 simple_server,
2003 {
2004 NULL,
2005 0,
2006 64
2007 },
2008 simple_client,
2009 {
2010 NULL,
2011 0,
2012 128
2013 }
2014 },
2015 /* Test 1: event-driven client, synchronous server */
2016 {
2017 {
2018 STD_STREAM_SOCKET,
2019 2048,
2020 16,
2021 2
2022 },
2023 simple_server,
2024 {
2025 NULL,
2026 0,
2027 64
2028 },
2029 event_client,
2030 {
2031 NULL,
2032 WSA_FLAG_OVERLAPPED,
2033 128
2034 }
2035 },
2036 /* Test 2: synchronous client, non-blocking server via select() */
2037 {
2038 {
2039 STD_STREAM_SOCKET,
2040 2048,
2041 16,
2042 2
2043 },
2044 select_server,
2045 {
2046 NULL,
2047 0,
2048 64
2049 },
2050 simple_client,
2051 {
2052 NULL,
2053 0,
2054 128
2055 }
2056 },
2057 /* Test 3: OOB client, OOB server */
2058 {
2059 {
2060 STD_STREAM_SOCKET,
2061 128,
2062 16,
2063 1
2064 },
2065 oob_server,
2066 {
2067 NULL,
2068 0,
2069 128
2070 },
2071 oob_client,
2072 {
2073 NULL,
2074 0,
2075 128
2076 }
2077 },
2078 /* Test 4: synchronous mixed client and server */
2079 {
2080 {
2081 STD_STREAM_SOCKET,
2082 2048,
2083 16,
2084 2
2085 },
2086 simple_server,
2087 {
2088 NULL,
2089 0,
2090 64
2091 },
2092 simple_mixed_client,
2093 {
2094 NULL,
2095 0,
2096 128
2097 }
2098 }
2099 };
2100
2101 static void test_UDP(void)
2102 {
2103 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
2104 possible that this test fails due to dropped packets. */
2105
2106 /* peer 0 receives data from all other peers */
2107 struct sock_info peer[NUM_UDP_PEERS];
2108 char buf[16];
2109 int ss, i, n_recv, n_sent;
2110
2111 memset (buf,0,sizeof(buf));
2112 for ( i = NUM_UDP_PEERS - 1; i >= 0; i-- ) {
2113 ok ( ( peer[i].s = socket ( AF_INET, SOCK_DGRAM, 0 ) ) != INVALID_SOCKET, "UDP: socket failed\n" );
2114
2115 peer[i].addr.sin_family = AF_INET;
2116 peer[i].addr.sin_addr.s_addr = inet_addr ( SERVERIP );
2117
2118 if ( i == 0 ) {
2119 peer[i].addr.sin_port = htons ( SERVERPORT );
2120 } else {
2121 peer[i].addr.sin_port = htons ( 0 );
2122 }
2123
2124 do_bind ( peer[i].s, (struct sockaddr *) &peer[i].addr, sizeof( peer[i].addr ) );
2125
2126 /* test getsockname() to get peer's port */
2127 ss = sizeof ( peer[i].addr );
2128 ok ( getsockname ( peer[i].s, (struct sockaddr *) &peer[i].addr, &ss ) != SOCKET_ERROR, "UDP: could not getsockname()\n" );
2129 ok ( peer[i].addr.sin_port != htons ( 0 ), "UDP: bind() did not associate port\n" );
2130 }
2131
2132 /* test getsockname() */
2133 ok ( peer[0].addr.sin_port == htons ( SERVERPORT ), "UDP: getsockname returned incorrect peer port\n" );
2134
2135 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
2136 /* send client's ip */
2137 memcpy( buf, &peer[i].addr.sin_port, sizeof(peer[i].addr.sin_port) );
2138 n_sent = sendto ( peer[i].s, buf, sizeof(buf), 0, (struct sockaddr*) &peer[0].addr, sizeof(peer[0].addr) );
2139 ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
2140 }
2141
2142 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
2143 n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0,(struct sockaddr *) &peer[0].peer, &ss );
2144 ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
2145 ok ( memcmp ( &peer[0].peer.sin_port, buf, sizeof(peer[0].addr.sin_port) ) == 0, "UDP: port numbers do not match\n" );
2146 }
2147 }
2148
2149 static DWORD WINAPI do_getservbyname( void *param )
2150 {
2151 struct {
2152 const char *name;
2153 const char *proto;
2154 int port;
2155 } serv[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
2156
2157 HANDLE *starttest = param;
2158 int i, j;
2159 struct servent *pserv[2];
2160
2161 ok ( WaitForSingleObject ( *starttest, TEST_TIMEOUT * 1000 ) != WAIT_TIMEOUT,
2162 "test_getservbyname: timeout waiting for start signal\n" );
2163
2164 /* ensure that necessary buffer resizes are completed */
2165 for ( j = 0; j < 2; j++) {
2166 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
2167 }
2168
2169 for ( i = 0; i < NUM_QUERIES / 2; i++ ) {
2170 for ( j = 0; j < 2; j++ ) {
2171 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
2172 ok ( pserv[j] != NULL || broken(pserv[j] == NULL) /* win8, fixed in win81 */,
2173 "getservbyname could not retrieve information for %s: %d\n", serv[j].name, WSAGetLastError() );
2174 if ( !pserv[j] ) continue;
2175 ok ( pserv[j]->s_port == htons(serv[j].port),
2176 "getservbyname returned the wrong port for %s: %d\n", serv[j].name, ntohs(pserv[j]->s_port) );
2177 ok ( !strcmp ( pserv[j]->s_proto, serv[j].proto ),
2178 "getservbyname returned the wrong protocol for %s: %s\n", serv[j].name, pserv[j]->s_proto );
2179 ok ( !strcmp ( pserv[j]->s_name, serv[j].name ),
2180 "getservbyname returned the wrong name for %s: %s\n", serv[j].name, pserv[j]->s_name );
2181 }
2182
2183 ok ( pserv[0] == pserv[1] || broken(pserv[0] != pserv[1]) /* win8, fixed in win81 */,
2184 "getservbyname: winsock resized servent buffer when not necessary\n" );
2185 }
2186
2187 return 0;
2188 }
2189
2190 static void test_getservbyname(void)
2191 {
2192 int i;
2193 HANDLE starttest, thread[NUM_THREADS];
2194 DWORD thread_id[NUM_THREADS];
2195
2196 starttest = CreateEventA ( NULL, 1, 0, "test_getservbyname_starttest" );
2197
2198 /* create threads */
2199 for ( i = 0; i < NUM_THREADS; i++ ) {
2200 thread[i] = CreateThread ( NULL, 0, do_getservbyname, &starttest, 0, &thread_id[i] );
2201 }
2202
2203 /* signal threads to start */
2204 SetEvent ( starttest );
2205
2206 for ( i = 0; i < NUM_THREADS; i++) {
2207 WaitForSingleObject ( thread[i], TEST_TIMEOUT * 1000 );
2208 }
2209 }
2210
2211 static void test_WSASocket(void)
2212 {
2213 SOCKET sock = INVALID_SOCKET;
2214 WSAPROTOCOL_INFOA *pi;
2215 int wsaproviders[] = {IPPROTO_TCP, IPPROTO_IP};
2216 int autoprotocols[] = {IPPROTO_TCP, IPPROTO_UDP};
2217 int items, err, size, socktype, i, j;
2218 UINT pi_size;
2219
2220 SetLastError(0xdeadbeef);
2221 ok(WSASocketA(0, 0, 0, NULL, 0, 0) == INVALID_SOCKET,
2222 "WSASocketA should have failed\n");
2223 err = WSAGetLastError();
2224 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2225
2226 sock = WSASocketA(AF_INET, 0, 0, NULL, 0, 0);
2227 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2228 closesocket(sock);
2229
2230 sock = WSASocketA(AF_INET, SOCK_STREAM, 0, NULL, 0, 0);
2231 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2232 closesocket(sock);
2233
2234 SetLastError(0xdeadbeef);
2235 ok(WSASocketA(0, SOCK_STREAM, -1, NULL, 0, 0) == INVALID_SOCKET,
2236 "WSASocketA should have failed\n");
2237 err = WSAGetLastError();
2238 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2239
2240 SetLastError(0xdeadbeef);
2241 ok(WSASocketA(0, -1, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
2242 "WSASocketA should have failed\n");
2243 err = WSAGetLastError();
2244 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2245
2246 SetLastError(0xdeadbeef);
2247 ok(WSASocketA(0, -1, 0, NULL, 0, 0) == INVALID_SOCKET,
2248 "WSASocketA should have failed\n");
2249 err = WSAGetLastError();
2250 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2251
2252 SetLastError(0xdeadbeef);
2253 ok(WSASocketA(AF_INET, -1, 0, NULL, 0, 0) == INVALID_SOCKET,
2254 "WSASocketA should have failed\n");
2255 err = WSAGetLastError();
2256 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2257
2258 SetLastError(0xdeadbeef);
2259 ok(WSASocketA(AF_INET, 0, -1, NULL, 0, 0) == INVALID_SOCKET,
2260 "WSASocketA should have failed\n");
2261 err = WSAGetLastError();
2262 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2263
2264 SetLastError(0xdeadbeef);
2265 ok(WSASocketA(0, -1, -1, NULL, 0, 0) == INVALID_SOCKET,
2266 "WSASocketA should have failed\n");
2267 err = WSAGetLastError();
2268 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2269
2270 SetLastError(0xdeadbeef);
2271 ok(WSASocketA(-1, SOCK_STREAM, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
2272 "WSASocketA should have failed\n");
2273 err = WSAGetLastError();
2274 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
2275
2276 sock = WSASocketA(AF_INET, 0, IPPROTO_TCP, NULL, 0, 0);
2277 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2278 closesocket(sock);
2279
2280 SetLastError(0xdeadbeef);
2281 ok(WSASocketA(0, SOCK_STREAM, 0, NULL, 0, 0) == INVALID_SOCKET,
2282 "WSASocketA should have failed\n");
2283 err = WSAGetLastError();
2284 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2285
2286 SetLastError(0xdeadbeef);
2287 ok(WSASocketA(0, 0, 0xdead, NULL, 0, 0) == INVALID_SOCKET,
2288 "WSASocketA should have failed\n");
2289 err = WSAGetLastError();
2290 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2291
2292 SetLastError(0xdeadbeef);
2293 ok(WSASocketA(AF_INET, 0xdead, 0, NULL, 0, 0) == INVALID_SOCKET,
2294 "WSASocketA should have failed\n");
2295 err = WSAGetLastError();
2296 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2297
2298 SetLastError(0xdeadbeef);
2299 ok(WSASocketA(0, 0xdead, 0, NULL, 0, 0) == INVALID_SOCKET,
2300 "WSASocketA should have failed\n");
2301 err = WSAGetLastError();
2302 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2303
2304 sock = WSASocketA(0, 0, IPPROTO_TCP, NULL, 0, 0);
2305 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2306 closesocket(sock);
2307
2308 /* SOCK_STREAM does not support IPPROTO_UDP */
2309 SetLastError(0xdeadbeef);
2310 ok(WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
2311 "WSASocketA should have failed\n");
2312 err = WSAGetLastError();
2313 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2314
2315 /* SOCK_DGRAM does not support IPPROTO_TCP */
2316 SetLastError(0xdeadbeef);
2317 ok(WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_TCP, NULL, 0, 0) == INVALID_SOCKET,
2318 "WSASocketA should have failed\n");
2319 err = WSAGetLastError();
2320 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2321
2322 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
2323 * to avoid a crash on win98.
2324 */
2325 pi_size = 0;
2326 items = WSAEnumProtocolsA(wsaproviders, NULL, &pi_size);
2327 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
2328 items);
2329 err = WSAGetLastError();
2330 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2331 err, WSAENOBUFS);
2332
2333 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
2334 ok(pi != NULL, "Failed to allocate memory\n");
2335 if (pi == NULL) {
2336 skip("Can't continue without memory.\n");
2337 return;
2338 }
2339
2340 items = WSAEnumProtocolsA(wsaproviders, pi, &pi_size);
2341 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
2342 WSAGetLastError());
2343
2344 if (items == 0) {
2345 skip("No protocols enumerated.\n");
2346 HeapFree(GetProcessHeap(), 0, pi);
2347 return;
2348 }
2349
2350 sock = WSASocketA(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
2351 FROM_PROTOCOL_INFO, &pi[0], 0, 0);
2352 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2353 WSAGetLastError());
2354 closesocket(sock);
2355
2356 /* find what parameters are used first: plain parameters or protocol info struct */
2357 pi[0].iProtocol = -1;
2358 pi[0].iSocketType = -1;
2359 pi[0].iAddressFamily = -1;
2360 ok(WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0) == INVALID_SOCKET,
2361 "WSASocketA should have failed\n");
2362 err = WSAGetLastError();
2363 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
2364
2365 pi[0].iProtocol = 0;
2366 pi[0].iSocketType = 0;
2367 pi[0].iAddressFamily = 0;
2368 sock = WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0);
2369 if(sock != INVALID_SOCKET)
2370 {
2371 win_skip("must work only in OS <= 2003\n");
2372 closesocket(sock);
2373 }
2374 else
2375 {
2376 err = WSAGetLastError();
2377 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
2378 }
2379
2380 pi[0].iProtocol = IPPROTO_UDP;
2381 pi[0].iSocketType = SOCK_DGRAM;
2382 pi[0].iAddressFamily = AF_INET;
2383 sock = WSASocketA(0, 0, 0, &pi[0], 0, 0);
2384 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2385 WSAGetLastError());
2386 size = sizeof(socktype);
2387 socktype = 0xdead;
2388 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2389 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2390 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2391 SOCK_DGRAM, socktype);
2392 closesocket(sock);
2393
2394 sock = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, &pi[0], 0, 0);
2395 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2396 WSAGetLastError());
2397 size = sizeof(socktype);
2398 socktype = 0xdead;
2399 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2400 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2401 ok(socktype == SOCK_STREAM, "Wrong socket type, expected %d received %d\n",
2402 SOCK_STREAM, socktype);
2403 closesocket(sock);
2404
2405 HeapFree(GetProcessHeap(), 0, pi);
2406
2407 pi_size = 0;
2408 items = WSAEnumProtocolsA(NULL, NULL, &pi_size);
2409 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
2410 items);
2411 err = WSAGetLastError();
2412 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2413 err, WSAENOBUFS);
2414
2415 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
2416 ok(pi != NULL, "Failed to allocate memory\n");
2417 if (pi == NULL) {
2418 skip("Can't continue without memory.\n");
2419 return;
2420 }
2421
2422 items = WSAEnumProtocolsA(NULL, pi, &pi_size);
2423 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
2424 WSAGetLastError());
2425
2426 /* when no protocol and socket type are specified the first entry
2427 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
2428 * is returned */
2429 sock = WSASocketA(AF_INET, 0, 0, NULL, 0, 0);
2430 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2431 WSAGetLastError());
2432
2433 size = sizeof(socktype);
2434 socktype = 0xdead;
2435 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2436 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2437 for(i = 0; i < items; i++)
2438 {
2439 if(pi[i].dwProviderFlags & PFL_MATCHES_PROTOCOL_ZERO)
2440 {
2441 ok(socktype == pi[i].iSocketType, "Wrong socket type, expected %d received %d\n",
2442 pi[i].iSocketType, socktype);
2443 break;
2444 }
2445 }
2446 ok(i != items, "Creating a socket without protocol and socket type didn't work\n");
2447 closesocket(sock);
2448
2449 /* when no socket type is specified the first entry from WSAEnumProtocols
2450 * that matches the protocol is returned */
2451 for (i = 0; i < sizeof(autoprotocols) / sizeof(autoprotocols[0]); i++)
2452 {
2453 sock = WSASocketA(0, 0, autoprotocols[i], NULL, 0, 0);
2454 ok(sock != INVALID_SOCKET, "Failed to create socket for protocol %d, received %d\n",
2455 autoprotocols[i], WSAGetLastError());
2456
2457 size = sizeof(socktype);
2458 socktype = 0xdead;
2459 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2460 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2461
2462 for (err = 1, j = 0; j < items; j++)
2463 {
2464 if (pi[j].iProtocol == autoprotocols[i])
2465 {
2466 if (socktype == pi[j].iSocketType)
2467 err = 0;
2468 else
2469 ok(0, "Wrong socket type, expected %d received %d\n",
2470 pi[j].iSocketType, socktype);
2471 break;
2472 }
2473 }
2474 ok(!err, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols[i]);
2475
2476 closesocket(sock);
2477 }
2478
2479 HeapFree(GetProcessHeap(), 0, pi);
2480
2481 SetLastError(0xdeadbeef);
2482 /* starting on vista the socket function returns error during the socket
2483 creation and no longer in the socket operations (sendto, readfrom) */
2484 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
2485 if (sock == INVALID_SOCKET)
2486 {
2487 err = WSAGetLastError();
2488 ok(err == WSAEACCES, "Expected 10013, received %d\n", err);
2489 skip("SOCK_RAW is not supported\n");
2490 }
2491 else
2492 {
2493 trace("SOCK_RAW is supported\n");
2494
2495 size = sizeof(socktype);
2496 socktype = 0xdead;
2497 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2498 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2499 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2500 SOCK_RAW, socktype);
2501 closesocket(sock);
2502
2503 todo_wine {
2504 sock = WSASocketA(0, 0, IPPROTO_RAW, NULL, 0, 0);
2505 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2506 WSAGetLastError());
2507 size = sizeof(socktype);
2508 socktype = 0xdead;
2509 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2510 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2511 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2512 SOCK_RAW, socktype);
2513 closesocket(sock);
2514 }
2515
2516 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_TCP, NULL, 0, 0);
2517 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2518 WSAGetLastError());
2519 size = sizeof(socktype);
2520 socktype = 0xdead;
2521 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2522 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2523 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2524 SOCK_RAW, socktype);
2525 closesocket(sock);
2526 }
2527
2528 /* IPX socket tests */
2529
2530 SetLastError(0xdeadbeef);
2531 sock = WSASocketA(AF_IPX, SOCK_DGRAM, NSPROTO_IPX, NULL, 0, 0);
2532 if (sock == INVALID_SOCKET)
2533 {
2534 err = WSAGetLastError();
2535 ok(err == WSAEAFNOSUPPORT || broken(err == WSAEPROTONOSUPPORT), "Expected 10047, received %d\n", err);
2536 skip("IPX is not supported\n");
2537 }
2538 else
2539 {
2540 WSAPROTOCOL_INFOA info;
2541 closesocket(sock);
2542
2543 trace("IPX is supported\n");
2544
2545 sock = WSASocketA(0, 0, NSPROTO_IPX, NULL, 0, 0);
2546 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2547 WSAGetLastError());
2548
2549 size = sizeof(socktype);
2550 socktype = 0xdead;
2551 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2552 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2553 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2554 SOCK_DGRAM, socktype);
2555
2556 /* check socket family, type and protocol */
2557 size = sizeof(WSAPROTOCOL_INFOA);
2558 err = getsockopt(sock, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &info, &size);
2559 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2560 ok(info.iProtocol == NSPROTO_IPX, "expected protocol %d, received %d\n",
2561 NSPROTO_IPX, info.iProtocol);
2562 ok(info.iAddressFamily == AF_IPX, "expected family %d, received %d\n",
2563 AF_IPX, info.iProtocol);
2564 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
2565 SOCK_DGRAM, info.iSocketType);
2566 closesocket(sock);
2567
2568 /* SOCK_STREAM does not support NSPROTO_IPX */
2569 SetLastError(0xdeadbeef);
2570 ok(WSASocketA(AF_IPX, SOCK_STREAM, NSPROTO_IPX, 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 /* test extended IPX support - that is adding any number between 0 and 255
2576 * to the IPX protocol value will make it be used as IPX packet type */
2577 for(i = 0;i <= 255;i += 17)
2578 {
2579 SetLastError(0xdeadbeef);
2580 sock = WSASocketA(0, 0, NSPROTO_IPX + i, NULL, 0, 0);
2581 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2582 WSAGetLastError());
2583
2584 size = sizeof(int);
2585 socktype = -1;
2586 err = getsockopt(sock, NSPROTO_IPX, IPX_PTYPE, (char *) &socktype, &size);
2587 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2588 ok(socktype == i, "Wrong IPX packet type, expected %d received %d\n",
2589 i, socktype);
2590
2591 closesocket(sock);
2592 }
2593 }
2594 }
2595
2596 static void test_WSADuplicateSocket(void)
2597 {
2598 SOCKET source, dupsock;
2599 WSAPROTOCOL_INFOA info;
2600 DWORD err;
2601 struct sockaddr_in addr;
2602 int socktype, size, addrsize, ret;
2603 char teststr[] = "TEST", buffer[16];
2604
2605 source = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
2606 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2607
2608 /* test invalid parameters */
2609 SetLastError(0xdeadbeef);
2610 ok(WSADuplicateSocketA(0, 0, NULL), "WSADuplicateSocketA should have failed\n");
2611 err = WSAGetLastError();
2612 ok(err == WSAENOTSOCK, "expected 10038, received %d\n", err);
2613
2614 SetLastError(0xdeadbeef);
2615 ok(WSADuplicateSocketA(source, 0, NULL),
2616 "WSADuplicateSocketA should have failed\n");
2617 err = WSAGetLastError();
2618 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2619
2620 SetLastError(0xdeadbeef);
2621 ok(WSADuplicateSocketA(source, ~0, &info),
2622 "WSADuplicateSocketA should have failed\n");
2623 err = WSAGetLastError();
2624 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2625
2626 SetLastError(0xdeadbeef);
2627 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info),
2628 "WSADuplicateSocketA should have failed\n");
2629 err = WSAGetLastError();
2630 ok(err == WSAENOTSOCK, "expected 10038, received %d\n", err);
2631
2632 SetLastError(0xdeadbeef);
2633 ok(WSADuplicateSocketA(source, GetCurrentProcessId(), NULL),
2634 "WSADuplicateSocketA should have failed\n");
2635 err = WSAGetLastError();
2636 ok(err == WSAEFAULT, "expected 10014, received %d\n", err);
2637
2638 /* test returned structure */
2639 memset(&info, 0, sizeof(info));
2640 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2641 "WSADuplicateSocketA should have worked\n");
2642
2643 ok(info.iProtocol == IPPROTO_TCP, "expected protocol %d, received %d\n",
2644 IPPROTO_TCP, info.iProtocol);
2645 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
2646 AF_INET, info.iProtocol);
2647 ok(info.iSocketType == SOCK_STREAM, "expected type %d, received %d\n",
2648 SOCK_STREAM, info.iSocketType);
2649
2650 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2651 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2652
2653 closesocket(dupsock);
2654 closesocket(source);
2655
2656 /* create a socket, bind it, duplicate it then send data on source and
2657 * receive in the duplicated socket */
2658 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
2659 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2660
2661 memset(&info, 0, sizeof(info));
2662 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2663 "WSADuplicateSocketA should have worked\n");
2664
2665 ok(info.iProtocol == IPPROTO_UDP, "expected protocol %d, received %d\n",
2666 IPPROTO_UDP, info.iProtocol);
2667 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
2668 AF_INET, info.iProtocol);
2669 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
2670 SOCK_DGRAM, info.iSocketType);
2671
2672 memset(&addr, 0, sizeof(addr));
2673 addr.sin_family = AF_INET;
2674 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2675 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
2676 "bind should have worked\n");
2677
2678 /* read address to find out the port number to be used in sendto */
2679 memset(&addr, 0, sizeof(addr));
2680 addrsize = sizeof(addr);
2681 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
2682 "getsockname should have worked\n");
2683 ok(addr.sin_port, "socket port should be != 0\n");
2684
2685 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2686 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2687
2688 size = sizeof(int);
2689 ret = getsockopt(dupsock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2690 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
2691 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2692 SOCK_DGRAM, socktype);
2693
2694 set_blocking(source, TRUE);
2695
2696 /* send data on source socket */
2697 addrsize = sizeof(addr);
2698 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
2699 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2700
2701 /* receive on duplicated socket */
2702 addrsize = sizeof(addr);
2703 memset(buffer, 0, sizeof(buffer));
2704 size = recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize);
2705 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2706 buffer[sizeof(teststr) - 1] = 0;
2707 ok(!strcmp(buffer, teststr), "expected '%s', received '%s'\n", teststr, buffer);
2708
2709 closesocket(dupsock);
2710 closesocket(source);
2711
2712 /* show that the source socket need to be bound before the duplicated
2713 * socket is created */
2714 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
2715 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2716
2717 memset(&info, 0, sizeof(info));
2718 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2719 "WSADuplicateSocketA should have worked\n");
2720
2721 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2722 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2723
2724 memset(&addr, 0, sizeof(addr));
2725 addr.sin_family = AF_INET;
2726 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2727 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
2728 "bind should have worked\n");
2729
2730 /* read address to find out the port number to be used in sendto */
2731 memset(&addr, 0, sizeof(addr));
2732 addrsize = sizeof(addr);
2733 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
2734 "getsockname should have worked\n");
2735 ok(addr.sin_port, "socket port should be != 0\n");
2736
2737 set_blocking(source, TRUE);
2738
2739 addrsize = sizeof(addr);
2740 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
2741 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2742
2743 SetLastError(0xdeadbeef);
2744 addrsize = sizeof(addr);
2745 memset(buffer, 0, sizeof(buffer));
2746 todo_wine {
2747 ok(recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize) == -1,
2748 "recvfrom should have failed\n");
2749 err = WSAGetLastError();
2750 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2751 }
2752
2753 closesocket(dupsock);
2754 closesocket(source);
2755 }
2756
2757 static void test_WSAEnumNetworkEvents(void)
2758 {
2759 SOCKET s, s2;
2760 int sock_type[] = {SOCK_STREAM, SOCK_DGRAM, SOCK_STREAM}, i, j, k, l;
2761 struct sockaddr_in address;
2762 HANDLE event;
2763 WSANETWORKEVENTS net_events;
2764 /* Windows 2000 Pro without SP installed (testbot) will crash if
2765 * WSAEnumNetworkEvents have a NULL event, so skip this test in <= 2000 */
2766 DWORD ver = GetVersion() & 0xFFFF;
2767 BOOL supports_null = ((ver & 0xFF) << 8 | (ver >> 8)) > 0x0500;
2768
2769 memset(&address, 0, sizeof(address));
2770 address.sin_addr.s_addr = htonl(INADDR_ANY);
2771 address.sin_family = AF_INET;
2772
2773 /* This test follows the steps from bugs 10204 and 24946 */
2774 for (l = 0; l < 2; l++)
2775 {
2776 if (l == 1 && !supports_null && broken(1)) continue;
2777
2778 for (i = 0; i < sizeof(sock_type) / sizeof(sock_type[0]); i++)
2779 {
2780 if (i == 2)
2781 ok(!tcp_socketpair(&s, &s2), "Test[%d]: creating socket pair failed\n", i);
2782 else
2783 {
2784 s = socket(AF_INET, sock_type[i], 0);
2785 ok (s != SOCKET_ERROR, "Test[%d]: failed to create socket\n", i);
2786 ok (!bind(s, (struct sockaddr*) &address, sizeof(address)), "Test[%d]: bind failed\n", i);
2787 }
2788 event = WSACreateEvent();
2789 ok (event != NULL, "Test[%d]: failed to create event\n", i);
2790 for (j = 0; j < 5; j++) /* Repeat sometimes and the result must be the same */
2791 {
2792 /* When the TCP socket is not connected NO events will be returned.
2793 * When connected and no data pending it will get the write event.
2794 * UDP sockets don't have connections so as soon as they are bound
2795 * they can read/write data. Since nobody is sendind us data only
2796 * the write event will be returned and ONLY once.
2797 */
2798 ok (!WSAEventSelect(s, event, FD_READ | FD_WRITE), "Test[%d]: WSAEventSelect failed\n", i);
2799 memset(&net_events, 0xAB, sizeof(net_events));
2800 ok (!WSAEnumNetworkEvents(s, l == 0 ? event : NULL, &net_events),
2801 "Test[%d]: WSAEnumNetworkEvents failed\n", i);
2802 if (i >= 1 && j == 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
2803 {
2804 todo_wine_if (i == 0) /* Remove when fixed */
2805 ok (net_events.lNetworkEvents == FD_WRITE, "Test[%d]: expected 2, got %d\n",
2806 i, net_events.lNetworkEvents);
2807 }
2808 else
2809 {
2810 todo_wine_if (i != 0) /* Remove when fixed */
2811 ok (net_events.lNetworkEvents == 0, "Test[%d]: expected 0, got %d\n",
2812 i, net_events.lNetworkEvents);
2813 }
2814 for (k = 0; k < FD_MAX_EVENTS; k++)
2815 {
2816 if (i >= 1 && j == 0 && k == 1) /* first UDP and connected TCP test, FD_WRITE bit no error*/
2817 {
2818 ok (net_events.iErrorCode[k] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
2819 i, k, net_events.iErrorCode[k]);
2820 }
2821 else
2822 {
2823 /* Bits that are not set in lNetworkEvents MUST not be changed */
2824 todo_wine
2825 ok (net_events.iErrorCode[k] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
2826 i, k, net_events.iErrorCode[k]);
2827 }
2828 }
2829 }
2830 closesocket(s);
2831 WSACloseEvent(event);
2832 if (i == 2) closesocket(s2);
2833 }
2834 }
2835 }
2836
2837 static void test_WSAAddressToStringA(void)
2838 {
2839 SOCKET v6 = INVALID_SOCKET;
2840 INT ret;
2841 DWORD len;
2842 int GLE;
2843 SOCKADDR_IN sockaddr;
2844 CHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
2845
2846 CHAR expect1[] = "0.0.0.0";
2847 CHAR expect2[] = "255.255.255.255";
2848 CHAR expect3[] = "0.0.0.0:65535";
2849 CHAR expect4[] = "255.255.255.255:65535";
2850
2851 SOCKADDR_IN6 sockaddr6;
2852 CHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
2853
2854 CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2855 CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2856 CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
2857
2858 CHAR expect6_1[] = "::1";
2859 CHAR expect6_2[] = "20ab::1";
2860 CHAR expect6_3[] = "[20ab::2001]:33274";
2861 CHAR expect6_3_nt[] = "20ab::2001@33274";
2862 CHAR expect6_3_w2k[] = "20ab::2001";
2863 CHAR expect6_3_2[] = "[20ab::2001%4660]:33274";
2864 CHAR expect6_3_2_nt[] = "4660/20ab::2001@33274";
2865 CHAR expect6_3_2_w2k[] = "20ab::2001%4660";
2866 CHAR expect6_3_3[] = "20ab::2001%4660";
2867 CHAR expect6_3_3_nt[] = "4660/20ab::2001";
2868
2869 len = 0;
2870
2871 sockaddr.sin_family = AF_INET;
2872 sockaddr.sin_port = 0;
2873 sockaddr.sin_addr.s_addr = 0;
2874
2875 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2876 GLE = WSAGetLastError();
2877 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
2878 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
2879 GLE, ret );
2880
2881 len = sizeof(address);
2882
2883 sockaddr.sin_family = AF_INET;
2884 sockaddr.sin_port = 0;
2885 sockaddr.sin_addr.s_addr = 0;
2886
2887 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2888 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2889
2890 ok( !strcmp( address, expect1 ), "Expected: %s, got: %s\n", expect1, address );
2891 ok( len == sizeof( expect1 ), "Got size %d\n", len);
2892
2893 len = sizeof(address);
2894
2895 sockaddr.sin_family = AF_INET;
2896 sockaddr.sin_port = 0;
2897 sockaddr.sin_addr.s_addr = 0xffffffff;
2898
2899 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2900 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2901
2902 ok( !strcmp( address, expect2 ), "Expected: %s, got: %s\n", expect2, address );
2903
2904 len = sizeof(address);
2905
2906 sockaddr.sin_family = AF_INET;
2907 sockaddr.sin_port = 0xffff;
2908 sockaddr.sin_addr.s_addr = 0;
2909
2910 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2911 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2912
2913 ok( !strcmp( address, expect3 ), "Expected: %s, got: %s\n", expect3, address );
2914
2915 len = sizeof(address);
2916
2917 sockaddr.sin_family = AF_INET;
2918 sockaddr.sin_port = 0xffff;
2919 sockaddr.sin_addr.s_addr = 0xffffffff;
2920
2921 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2922 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2923
2924 ok( !strcmp( address, expect4 ), "Expected: %s, got: %s\n", expect4, address );
2925 ok( len == sizeof( expect4 ), "Got size %d\n", len);
2926
2927 /*check to see it IPv6 is available */
2928 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
2929 if (v6 == INVALID_SOCKET) {
2930 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
2931 WSAGetLastError(), WSAEAFNOSUPPORT);
2932 goto end;
2933 }
2934 /* Test a short IPv6 address */
2935 len = sizeof(address6);
2936
2937 sockaddr6.sin6_family = AF_INET6;
2938 sockaddr6.sin6_port = 0x0000;
2939 sockaddr6.sin6_scope_id = 0;
2940 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
2941
2942 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2943 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2944 ok( !strcmp( address6, expect6_1 ), "Expected: %s, got: %s\n", expect6_1, address6 );
2945 ok( len == sizeof(expect6_1), "Got size %d\n", len);
2946
2947 /* Test a longer IPv6 address */
2948 len = sizeof(address6);
2949
2950 sockaddr6.sin6_family = AF_INET6;
2951 sockaddr6.sin6_port = 0x0000;
2952 sockaddr6.sin6_scope_id = 0;
2953 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_2, sizeof(addr6_2));
2954
2955 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2956 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2957 ok( !strcmp( address6, expect6_2 ), "Expected: %s, got: %s\n", expect6_2, address6 );
2958 ok( len == sizeof(expect6_2), "Got size %d\n", len);
2959
2960 /* Test IPv6 address and port number */
2961 len = sizeof(address6);
2962
2963 sockaddr6.sin6_family = AF_INET6;
2964 sockaddr6.sin6_port = 0xfa81;
2965 sockaddr6.sin6_scope_id = 0;
2966 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
2967
2968 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2969 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2970 ok( !strcmp( address6, expect6_3 ) ||
2971 broken( !strcmp( address6, expect6_3_nt ) ) || /* NT4 */
2972 broken( !strcmp( address6, expect6_3_w2k ) ), /* Win2000 */
2973 "Expected: %s, got: %s\n", expect6_3, address6 );
2974 ok( len == sizeof(expect6_3) ||
2975 broken( len == sizeof(expect6_3_nt) ) || /* NT4 */
2976 broken( len == sizeof(expect6_3_w2k) ), /* Win2000 */
2977 "Got size %d\n", len);
2978
2979 /* Test IPv6 address, port number and scope_id */
2980 len = sizeof(address6);
2981
2982 sockaddr6.sin6_family = AF_INET6;
2983 sockaddr6.sin6_port = 0xfa81;
2984 sockaddr6.sin6_scope_id = 0x1234;
2985 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
2986
2987 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2988 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2989 ok( !strcmp( address6, expect6_3_2 ) ||
2990 broken( !strcmp( address6, expect6_3_2_nt ) ) || /* NT4 */
2991 broken( !strcmp( address6, expect6_3_2_w2k ) ), /* Win2000 */
2992 "Expected: %s, got: %s\n", expect6_3_2, address6 );
2993 ok( len == sizeof(expect6_3_2) ||
2994 broken( len == sizeof(expect6_3_2_nt) ) || /* NT4 */
2995 broken( len == sizeof(expect6_3_2_w2k) ), /* Win2000 */
2996 "Got size %d\n", len);
2997
2998 /* Test IPv6 address and scope_id */
2999 len = sizeof(address6);
3000
3001 sockaddr6.sin6_family = AF_INET6;
3002 sockaddr6.sin6_port = 0x0000;
3003 sockaddr6.sin6_scope_id = 0x1234;
3004 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3005
3006 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3007 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3008 ok( !strcmp( address6, expect6_3_3 ) ||
3009 broken( !strcmp( address6, expect6_3_3_nt ) ), /* NT4 */
3010 "Expected: %s, got: %s\n", expect6_3_3, address6 );
3011 ok( len == sizeof(expect6_3_3) ||
3012 broken( len == sizeof(expect6_3_3_nt) ), /* NT4 */
3013 "Got size %d\n", len);
3014
3015 end:
3016 if (v6 != INVALID_SOCKET)
3017 closesocket(v6);
3018 }
3019
3020 static void test_WSAAddressToStringW(void)
3021 {
3022 SOCKET v6 = INVALID_SOCKET;
3023 INT ret;
3024 DWORD len;
3025 int GLE;
3026 SOCKADDR_IN sockaddr;
3027 WCHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
3028
3029 WCHAR expect1[] = { '0','.','0','.','0','.','0', 0 };
3030 WCHAR expect2[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
3031 WCHAR expect3[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
3032 WCHAR expect4[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
3033 '6', '5', '5', '3', '5', 0 };
3034
3035 SOCKADDR_IN6 sockaddr6;
3036 WCHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
3037
3038 CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3039 CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3040 CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
3041
3042 WCHAR expect6_1[] = {':',':','1',0};
3043 WCHAR expect6_2[] = {'2','0','a','b',':',':','1',0};
3044 WCHAR expect6_3[] = {'[','2','0','a','b',':',':','2','0','0','1',']',':','3','3','2','7','4',0};
3045 WCHAR expect6_3_nt[] = {'2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
3046 WCHAR expect6_3_w2k[] = {'2','0','a','b',':',':','2','0','0','1',0};
3047 WCHAR expect6_3_2[] = {'[','2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',']',':','3','3','2','7','4',0};
3048 WCHAR expect6_3_2_nt[] = {'4','6','6','0','/','2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
3049 WCHAR expect6_3_2_w2k[] = {'2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',0};
3050 WCHAR expect6_3_3[] = {'2','0','a','b',':',':','2','0','0','1','%','6','5','5','3','4',0};
3051 WCHAR expect6_3_3_nt[] = {'6','5','5','3','4','/','2','0','a','b',':',':','2','0','0','1',0};
3052
3053 len = 0;
3054
3055 sockaddr.sin_family = AF_INET;
3056 sockaddr.sin_port = 0;
3057 sockaddr.sin_addr.s_addr = 0;
3058
3059 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3060 GLE = WSAGetLastError();
3061 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
3062 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
3063 GLE, ret );
3064
3065 len = sizeof(address);
3066
3067 sockaddr.sin_family = AF_INET;
3068 sockaddr.sin_port = 0;
3069 sockaddr.sin_addr.s_addr = 0;
3070
3071 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3072 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3073
3074 ok( !lstrcmpW( address, expect1 ), "Expected different address string\n" );
3075 ok( len == sizeof( expect1 )/sizeof( WCHAR ), "Got size %d\n", len);
3076
3077 len = sizeof(address);
3078
3079 sockaddr.sin_family = AF_INET;
3080 sockaddr.sin_port = 0;
3081 sockaddr.sin_addr.s_addr = 0xffffffff;
3082
3083 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3084 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3085
3086 ok( !lstrcmpW( address, expect2 ), "Expected different address string\n" );
3087
3088 len = sizeof(address);
3089
3090 sockaddr.sin_family = AF_INET;
3091 sockaddr.sin_port = 0xffff;
3092 sockaddr.sin_addr.s_addr = 0;
3093
3094 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3095 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3096
3097 ok( !lstrcmpW( address, expect3 ), "Expected different address string\n" );
3098
3099 len = sizeof(address);
3100
3101 sockaddr.sin_family = AF_INET;
3102 sockaddr.sin_port = 0xffff;
3103 sockaddr.sin_addr.s_addr = 0xffffffff;
3104
3105 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3106 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3107
3108 ok( !lstrcmpW( address, expect4 ), "Expected different address string\n" );
3109 ok( len == sizeof( expect4 )/sizeof( WCHAR ), "Got %d\n", len);
3110
3111 /*check to see it IPv6 is available */
3112 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
3113 if (v6 == INVALID_SOCKET) {
3114 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
3115 WSAGetLastError(), WSAEAFNOSUPPORT);
3116 goto end;
3117 }
3118
3119 /* Test a short IPv6 address */
3120 len = sizeof(address6)/sizeof(WCHAR);
3121
3122 sockaddr6.sin6_family = AF_INET6;
3123 sockaddr6.sin6_port = 0x0000;
3124 sockaddr6.sin6_scope_id = 0;
3125 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
3126
3127 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3128 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3129 ok( !lstrcmpW( address6, expect6_1 ), "Wrong string returned\n" );
3130 ok( len == sizeof(expect6_1)/sizeof(WCHAR), "Got %d\n", len);
3131
3132 /* Test a longer IPv6 address */
3133 len = sizeof(address6)/sizeof(WCHAR);
3134
3135 sockaddr6.sin6_family = AF_INET6;
3136 sockaddr6.sin6_port = 0x0000;
3137 sockaddr6.sin6_scope_id = 0;
3138 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_2, sizeof(addr6_2));
3139
3140 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3141 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3142
3143 ok( !lstrcmpW( address6, expect6_2 ), "Wrong string returned\n" );
3144 ok( len == sizeof(expect6_2)/sizeof(WCHAR), "Got %d\n", len);
3145
3146 /* Test IPv6 address and port number */
3147 len = sizeof(address6)/sizeof(WCHAR);
3148
3149 sockaddr6.sin6_family = AF_INET6;
3150 sockaddr6.sin6_port = 0xfa81;
3151 sockaddr6.sin6_scope_id = 0;
3152 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3153
3154 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3155 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3156 ok( !lstrcmpW( address6, expect6_3 ) ||
3157 broken( !lstrcmpW( address6, expect6_3_nt ) ) || /* NT4 */
3158 broken( !lstrcmpW( address6, expect6_3_w2k ) ), /* Win2000 */
3159 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3),
3160 wine_dbgstr_w(address6) );
3161 ok( len == sizeof(expect6_3)/sizeof(WCHAR) ||
3162 broken(len == sizeof(expect6_3_nt)/sizeof(WCHAR) ) || /* NT4 */
3163 broken(len == sizeof(expect6_3_w2k)/sizeof(WCHAR) ), /* Win2000 */
3164 "Got %d\n", len);
3165
3166 /* Test IPv6 address, port number and scope_id */
3167 len = sizeof(address6)/sizeof(WCHAR);
3168
3169 sockaddr6.sin6_family = AF_INET6;
3170 sockaddr6.sin6_port = 0xfa81;
3171 sockaddr6.sin6_scope_id = 0x1234;
3172 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3173
3174 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3175 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3176 ok( !lstrcmpW( address6, expect6_3_2 ) ||
3177 broken( !lstrcmpW( address6, expect6_3_2_nt ) ) || /* NT4 */
3178 broken( !lstrcmpW( address6, expect6_3_2_w2k ) ), /* Win2000 */
3179 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_2),
3180 wine_dbgstr_w(address6) );
3181 ok( len == sizeof(expect6_3_2)/sizeof(WCHAR) ||
3182 broken( len == sizeof(expect6_3_2_nt)/sizeof(WCHAR) ) || /* NT4 */
3183 broken( len == sizeof(expect6_3_2_w2k)/sizeof(WCHAR) ), /* Win2000 */
3184 "Got %d\n", len);
3185
3186 /* Test IPv6 address and scope_id */
3187 len = sizeof(address6)/sizeof(WCHAR);
3188
3189 sockaddr6.sin6_family = AF_INET6;
3190 sockaddr6.sin6_port = 0x0000;
3191 sockaddr6.sin6_scope_id = 0xfffe;
3192 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3193
3194 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3195 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3196 ok( !lstrcmpW( address6, expect6_3_3 ) ||
3197 broken( !lstrcmpW( address6, expect6_3_3_nt ) ), /* NT4 */
3198 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_3),
3199 wine_dbgstr_w(address6) );
3200 ok( len == sizeof(expect6_3_3)/sizeof(WCHAR) ||
3201 broken( len == sizeof(expect6_3_3_nt)/sizeof(WCHAR) ), /* NT4 */
3202 "Got %d\n", len);
3203
3204 end:
3205 if (v6 != INVALID_SOCKET)
3206 closesocket(v6);
3207 }
3208
3209 static void test_WSAStringToAddressA(void)
3210 {
3211 INT ret, len;
3212 SOCKADDR_IN sockaddr;
3213 SOCKADDR_IN6 sockaddr6;
3214 int GLE;
3215
3216 CHAR address1[] = "0.0.0.0";
3217 CHAR address2[] = "127.127.127.127";
3218 CHAR address3[] = "255.255.255.255";
3219 CHAR address4[] = "127.127.127.127:65535";
3220 CHAR address5[] = "255.255.255.255:65535";
3221 CHAR address6[] = "::1";
3222 CHAR address7[] = "[::1]";
3223 CHAR address8[] = "[::1]:65535";
3224 CHAR address9[] = "2001::1";
3225
3226 len = 0;
3227 sockaddr.sin_family = AF_INET;
3228
3229 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3230 ok( ret == SOCKET_ERROR, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
3231 WSAGetLastError() );
3232
3233 len = sizeof(sockaddr);
3234 sockaddr.sin_port = 0;
3235 sockaddr.sin_addr.s_addr = 0;
3236
3237 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3238 ok( !ret && sockaddr.sin_addr.s_addr == 0,
3239 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3240
3241 len = sizeof(sockaddr);
3242 sockaddr.sin_port = 0;
3243 sockaddr.sin_addr.s_addr = 0;
3244
3245 ret = WSAStringToAddressA( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3246 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
3247 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3248
3249 len = sizeof(sockaddr);
3250 sockaddr.sin_port = 0;
3251 sockaddr.sin_addr.s_addr = 0;
3252
3253 ret = WSAStringToAddressA( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3254 GLE = WSAGetLastError();
3255 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
3256 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3257 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
3258
3259 len = sizeof(sockaddr);
3260 sockaddr.sin_port = 0;
3261 sockaddr.sin_addr.s_addr = 0;
3262
3263 ret = WSAStringToAddressA( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3264 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
3265 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3266
3267 len = sizeof(sockaddr);
3268 sockaddr.sin_port = 0;
3269 sockaddr.sin_addr.s_addr = 0;
3270
3271 ret = WSAStringToAddressA( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3272 GLE = WSAGetLastError();
3273 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
3274 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3275 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
3276
3277 len = sizeof(sockaddr6);
3278 memset(&sockaddr6, 0, len);
3279 sockaddr6.sin6_family = AF_INET6;
3280
3281 ret = WSAStringToAddressA( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3282 &len );
3283 GLE = WSAGetLastError();
3284 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3285 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
3286
3287 len = sizeof(sockaddr6);
3288 memset(&sockaddr6, 0, len);
3289 sockaddr6.sin6_family = AF_INET6;
3290
3291 ret = WSAStringToAddressA( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3292 &len );
3293 GLE = WSAGetLastError();
3294 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3295 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
3296
3297 len = sizeof(sockaddr6);
3298 memset(&sockaddr6, 0, len);
3299 sockaddr6.sin6_family = AF_INET6;
3300
3301 ret = WSAStringToAddressA( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3302 &len );
3303 GLE = WSAGetLastError();
3304 ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
3305 (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3306 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
3307
3308 len = sizeof(sockaddr);
3309
3310 ret = WSAStringToAddressA( address9, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3311 GLE = WSAGetLastError();
3312 ok( (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3313 "WSAStringToAddressA() should have failed with %d\n", GLE );
3314 }
3315
3316 static void test_WSAStringToAddressW(void)
3317 {
3318 INT ret, len;
3319 SOCKADDR_IN sockaddr, *sin;
3320 SOCKADDR_IN6 sockaddr6;
3321 SOCKADDR_STORAGE sockaddr_storage;
3322 int GLE;
3323
3324 WCHAR address1[] = { '0','.','0','.','0','.','0', 0 };
3325 WCHAR address2[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
3326 WCHAR address3[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
3327 WCHAR address4[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
3328 ':', '6', '5', '5', '3', '5', 0 };
3329 WCHAR address5[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
3330 '6', '5', '5', '3', '5', 0 };
3331 WCHAR address6[] = {':',':','1','\0'};
3332 WCHAR address7[] = {'[',':',':','1',']','\0'};
3333 WCHAR address8[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
3334 WCHAR address9[] = {'2','0','0','1',':',':','1','\0'};
3335
3336 len = 0;
3337 sockaddr.sin_family = AF_INET;
3338
3339 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3340 ok( ret == SOCKET_ERROR, "WSAStringToAddressW() failed unexpectedly: %d\n",
3341 WSAGetLastError() );
3342
3343 len = sizeof(sockaddr);
3344 sockaddr.sin_port = 0;
3345 sockaddr.sin_addr.s_addr = 0;
3346
3347 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3348 ok( !ret && sockaddr.sin_addr.s_addr == 0,
3349 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3350
3351 len = sizeof(sockaddr);
3352 sockaddr.sin_port = 0;
3353 sockaddr.sin_addr.s_addr = 0;
3354
3355 ret = WSAStringToAddressW( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3356 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
3357 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3358
3359 len = sizeof(sockaddr);
3360 sockaddr.sin_port = 0;
3361 sockaddr.sin_addr.s_addr = 0;
3362
3363 ret = WSAStringToAddressW( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3364 GLE = WSAGetLastError();
3365 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
3366 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3367 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
3368
3369 len = sizeof(sockaddr);
3370 sockaddr.sin_port = 0;
3371 sockaddr.sin_addr.s_addr = 0;
3372
3373 ret = WSAStringToAddressW( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3374 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
3375 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3376
3377 len = sizeof(sockaddr);
3378 sockaddr.sin_port = 0;
3379 sockaddr.sin_addr.s_addr = 0;
3380
3381 ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3382 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
3383 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3384 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
3385
3386 /* Test with a larger buffer than necessary */
3387 len = sizeof(sockaddr_storage);
3388 sin = (SOCKADDR_IN *)&sockaddr_storage;
3389 sin->sin_port = 0;
3390 sin->sin_addr.s_addr = 0;
3391
3392 ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)sin, &len );
3393 ok( (ret == 0 && sin->sin_addr.s_addr == 0xffffffff && sin->sin_port == 0xffff) ||
3394 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3395 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
3396 ok( len == sizeof(SOCKADDR_IN) ||
3397 broken(len == sizeof(SOCKADDR_STORAGE)) /* NT4/2k */,
3398 "unexpected length %d\n", len );
3399
3400 len = sizeof(sockaddr6);
3401 memset(&sockaddr6, 0, len);
3402 sockaddr6.sin6_family = AF_INET6;
3403
3404 ret = WSAStringToAddressW( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3405 &len );
3406 GLE = WSAGetLastError();
3407 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3408 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
3409
3410 len = sizeof(sockaddr6);
3411 memset(&sockaddr6, 0, len);
3412 sockaddr6.sin6_family = AF_INET6;
3413
3414 ret = WSAStringToAddressW( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3415 &len );
3416 GLE = WSAGetLastError();
3417 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3418 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
3419
3420 len = sizeof(sockaddr6);
3421 memset(&sockaddr6, 0, len);
3422 sockaddr6.sin6_family = AF_INET6;
3423
3424 ret = WSAStringToAddressW( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3425 &len );
3426 GLE = WSAGetLastError();
3427 ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
3428 (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3429 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
3430
3431 len = sizeof(sockaddr);
3432
3433 ret = WSAStringToAddressW( address9, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3434 GLE = WSAGetLastError();
3435 ok( (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3436 "WSAStringToAddressW() should have failed with %d\n", GLE );
3437 }
3438
3439 static DWORD WINAPI SelectReadThread(void *param)
3440 {
3441 select_thread_params *par = param;
3442 fd_set readfds;
3443 int ret;
3444 struct sockaddr_in addr;
3445 struct timeval select_timeout;
3446
3447 FD_ZERO(&readfds);
3448 FD_SET(par->s, &readfds);
3449 select_timeout.tv_sec=5;
3450 select_timeout.tv_usec=0;
3451 addr.sin_family = AF_INET;
3452 addr.sin_addr.s_addr = inet_addr(SERVERIP);
3453 addr.sin_port = htons(SERVERPORT);
3454
3455 do_bind(par->s, (struct sockaddr *)&addr, sizeof(addr));
3456 wsa_ok(listen(par->s, SOMAXCONN ), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
3457
3458 SetEvent(server_ready);
3459 ret = select(par->s+1, &readfds, NULL, NULL, &select_timeout);
3460 par->ReadKilled = (ret == 1);
3461
3462 return 0;
3463 }
3464
3465 static DWORD WINAPI SelectCloseThread(void *param)
3466 {
3467 SOCKET s = *(SOCKET*)param;
3468 Sleep(500);
3469 closesocket(s);
3470 return 0;
3471 }
3472
3473 static void test_errors(void)
3474 {
3475 SOCKET sock;
3476 SOCKADDR_IN SockAddr;
3477 int ret, err;
3478
3479 WSASetLastError(NO_ERROR);
3480 sock = socket(PF_INET, SOCK_STREAM, 0);
3481 ok( (sock != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3482 memset(&SockAddr, 0, sizeof(SockAddr));
3483 SockAddr.sin_family = AF_INET;
3484 SockAddr.sin_port = htons(6924);
3485 SockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
3486
3487 ret = connect(sock, (PSOCKADDR)&SockAddr, sizeof(SockAddr));
3488 ok( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got: %d\n", ret );
3489 if (ret == SOCKET_ERROR)
3490 {
3491 err = WSAGetLastError();
3492 ok( (err == WSAECONNREFUSED), "expected WSAECONNREFUSED, got: %d\n", err );
3493 }
3494
3495 {
3496 TIMEVAL timeval;
3497 fd_set set = {1, {sock}};
3498
3499 timeval.tv_sec = 0;
3500 timeval.tv_usec = 50000;
3501
3502 ret = select(1, NULL, &set, NULL, &timeval);
3503 ok( (ret == 0), "expected 0 (timeout), got: %d\n", ret );
3504 }
3505
3506 ret = closesocket(sock);
3507 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
3508 }
3509
3510 static void test_listen(void)
3511 {
3512 SOCKET fdA, fdB;
3513 int ret, acceptc, olen = sizeof(acceptc);
3514 struct sockaddr_in address;
3515
3516 memset(&address, 0, sizeof(address));
3517 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3518 address.sin_family = AF_INET;
3519 address.sin_port = htons(SERVERPORT);
3520
3521 /* invalid socket tests */
3522 SetLastError(0xdeadbeef);
3523 ok ((listen(0, 0) == SOCKET_ERROR), "listen did not fail\n");
3524 ret = WSAGetLastError();
3525 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
3526
3527 SetLastError(0xdeadbeef);
3528 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR), "listen did not fail\n");
3529 ret = WSAGetLastError();
3530 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
3531
3532 /* tcp tests */
3533 fdA = socket(AF_INET, SOCK_STREAM, 0);
3534 ok ((fdA != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3535
3536 fdB = socket(AF_INET, SOCK_STREAM, 0);
3537 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3538
3539 SetLastError(0xdeadbeef);
3540 ok ((listen(fdA, -2) == SOCKET_ERROR), "listen did not fail\n");
3541 ret = WSAGetLastError();
3542 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3543
3544 SetLastError(0xdeadbeef);
3545 ok ((listen(fdA, 1) == SOCKET_ERROR), "listen did not fail\n");
3546 ret = WSAGetLastError();
3547 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3548
3549 SetLastError(0xdeadbeef);
3550 ok ((listen(fdA, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3551 ret = WSAGetLastError();
3552 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3553
3554 ok (!bind(fdA, (struct sockaddr*) &address, sizeof(address)), "bind failed\n");
3555
3556 SetLastError(0xdeadbeef);
3557 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3558 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3559
3560 acceptc = 0xdead;
3561 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3562 ok (!ret, "getsockopt failed\n");
3563 ok (acceptc == 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc);
3564
3565 ok (!listen(fdA, 0), "listen failed\n");
3566 ok (!listen(fdA, SOMAXCONN), "double listen failed\n");
3567
3568 acceptc = 0xdead;
3569 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3570 ok (!ret, "getsockopt failed\n");
3571 ok (acceptc == 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc);
3572
3573 SetLastError(0xdeadbeef);
3574 ok ((listen(fdB, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3575 ret = WSAGetLastError();
3576 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3577
3578 ret = closesocket(fdB);
3579 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3580
3581 fdB = socket(AF_INET, SOCK_STREAM, 0);
3582 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3583
3584 SetLastError(0xdeadbeef);
3585 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3586 ret = WSAGetLastError();
3587 ok (ret == WSAEADDRINUSE, "expected 10048, received %d\n", ret);
3588
3589 ret = closesocket(fdA);
3590 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3591 ret = closesocket(fdB);
3592 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3593 }
3594
3595 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
3596 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
3597 static void test_select(void)
3598 {
3599 static char tmp_buf[1024];
3600
3601 SOCKET fdListen, fdRead, fdWrite;
3602 fd_set readfds, writefds, exceptfds;
3603 unsigned int maxfd;
3604 int ret, len;
3605 char buffer;
3606 struct timeval select_timeout;
3607 struct sockaddr_in address;
3608 select_thread_params thread_params;
3609 HANDLE thread_handle;
3610 DWORD ticks, id;
3611
3612 fdRead = socket(AF_INET, SOCK_STREAM, 0);
3613 ok( (fdRead != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3614 fdWrite = socket(AF_INET, SOCK_STREAM, 0);
3615 ok( (fdWrite != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3616
3617 maxfd = fdRead;
3618 if (fdWrite > maxfd)
3619 maxfd = fdWrite;
3620
3621 FD_ZERO_ALL();
3622 FD_SET_ALL(fdRead);
3623 FD_SET_ALL(fdWrite);
3624 select_timeout.tv_sec=0;
3625 select_timeout.tv_usec=0;
3626
3627 ticks = GetTickCount();
3628 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3629 ticks = GetTickCount() - ticks;
3630 ok(ret == 0, "select should not return any socket handles\n");
3631 ok(ticks < 10, "select was blocking for %u ms, expected < 10 ms\n", ticks);
3632 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3633 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
3634 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3635 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
3636
3637 FD_ZERO_ALL();
3638 FD_SET_ALL(fdRead);
3639 FD_SET_ALL(fdWrite);
3640 select_timeout.tv_sec=0;
3641 select_timeout.tv_usec=500;
3642
3643 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3644 ok(ret == 0, "select should not return any socket handles\n");
3645 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3646 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
3647 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3648 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
3649
3650 ok ((listen(fdWrite, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3651 ret = closesocket(fdWrite);
3652 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
3653
3654 thread_params.s = fdRead;
3655 thread_params.ReadKilled = FALSE;
3656 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
3657 thread_handle = CreateThread (NULL, 0, SelectReadThread, &thread_params, 0, &id );
3658 ok ( (thread_handle != NULL), "CreateThread failed unexpectedly: %d\n", GetLastError());
3659
3660 WaitForSingleObject (server_ready, INFINITE);
3661 Sleep(200);
3662 ret = closesocket(fdRead);
3663 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
3664
3665 WaitForSingleObject (thread_handle, 1000);
3666 ok ( (thread_params.ReadKilled) ||
3667 broken(thread_params.ReadKilled == 0), /*Win98*/
3668 "closesocket did not wakeup select\n");
3669 ret = recv(fdRead, &buffer, 1, MSG_PEEK);
3670 ok( (ret == -1), "peek at closed socket expected -1 got %d\n", ret);
3671
3672 /* Test selecting invalid handles */
3673 FD_ZERO_ALL();
3674
3675 SetLastError(0);
3676 ret = select(maxfd+1, 0, 0, 0, &select_timeout);
3677 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3678 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3679
3680 SetLastError(0);
3681 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3682 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3683 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3684
3685 FD_SET(INVALID_SOCKET, &readfds);
3686 SetLastError(0);
3687 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3688 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3689 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3690 ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3691
3692 FD_ZERO(&readfds);
3693 FD_SET(INVALID_SOCKET, &writefds);
3694 SetLastError(0);
3695 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3696 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3697 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3698 ok ( !FD_ISSET(fdRead, &writefds), "FD should not be set\n");
3699
3700 FD_ZERO(&writefds);
3701 FD_SET(INVALID_SOCKET, &exceptfds);
3702 SetLastError(0);
3703 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3704 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3705 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3706 ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3707
3708 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
3709 maxfd = fdRead;
3710 if(fdWrite > maxfd) maxfd = fdWrite;
3711
3712 FD_ZERO(&readfds);
3713 FD_SET(fdRead, &readfds);
3714 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
3715 ok(!ret, "select returned %d\n", ret);
3716
3717 FD_ZERO(&writefds);
3718 FD_SET(fdWrite, &writefds);
3719 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
3720 ok(ret == 1, "select returned %d\n", ret);
3721 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3722
3723 /* tests for overlapping fd_set pointers */
3724 FD_ZERO(&readfds);
3725 FD_SET(fdWrite, &readfds);
3726 ret = select(fdWrite+1, &readfds, &readfds, NULL, &select_timeout);
3727 ok(ret == 1, "select returned %d\n", ret);
3728 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3729
3730 FD_ZERO(&readfds);
3731 FD_SET(fdWrite, &readfds);
3732 FD_SET(fdRead, &readfds);
3733 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3734 ok(ret == 2, "select returned %d\n", ret);
3735 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3736 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3737
3738 ok(send(fdWrite, "test", 4, 0) == 4, "failed to send data\n");
3739 FD_ZERO(&readfds);
3740 FD_SET(fdRead, &readfds);
3741 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
3742 ok(ret == 1, "select returned %d\n", ret);
3743 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3744
3745 FD_ZERO(&readfds);
3746 FD_SET(fdWrite, &readfds);
3747 FD_SET(fdRead, &readfds);
3748 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3749 ok(ret == 2, "select returned %d\n", ret);
3750 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3751 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3752
3753 while(1) {
3754 FD_ZERO(&writefds);
3755 FD_SET(fdWrite, &writefds);
3756 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
3757 if(!ret) break;
3758 ok(send(fdWrite, tmp_buf, sizeof(tmp_buf), 0) > 0, "failed to send data\n");
3759 }
3760 FD_ZERO(&readfds);
3761 FD_SET(fdWrite, &readfds);
3762 FD_SET(fdRead, &readfds);
3763 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3764 ok(ret == 1, "select returned %d\n", ret);
3765 ok(!FD_ISSET(fdWrite, &readfds), "fdWrite socket is in the set\n");
3766 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3767
3768 ok(send(fdRead, "test", 4, 0) == 4, "failed to send data\n");
3769 Sleep(100);
3770 FD_ZERO(&readfds);
3771 FD_SET(fdWrite, &readfds);
3772 FD_SET(fdRead, &readfds);
3773 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3774 ok(ret == 2, "select returned %d\n", ret);
3775 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3776 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3777
3778 closesocket(fdRead);
3779 closesocket(fdWrite);
3780
3781 /* select() works in 3 distinct states:
3782 * - to check if a connection attempt ended with success or error;
3783 * - to check if a pending connection is waiting for acceptance;
3784 * - to check for data to read, availability for write and OOB data
3785 *
3786 * The tests below ensure that all conditions are tested.
3787 */
3788 memset(&address, 0, sizeof(address));
3789 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3790 address.sin_family = AF_INET;
3791 len = sizeof(address);
3792 fdListen = setup_server_socket(&address, &len);
3793 select_timeout.tv_sec = 1;
3794 select_timeout.tv_usec = 250000;
3795
3796 /* When no events are pending select returns 0 with no error */
3797 FD_ZERO_ALL();
3798 FD_SET_ALL(fdListen);
3799 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3800 ok(ret == 0, "expected 0, got %d\n", ret);
3801
3802 /* When a socket is attempting to connect the listening socket receives the read descriptor */
3803 fdWrite = setup_connector_socket(&address, len, TRUE);
3804 FD_ZERO_ALL();
3805 FD_SET_ALL(fdListen);
3806 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3807 ok(ret == 1, "expected 1, got %d\n", ret);
3808 ok(FD_ISSET(fdListen, &readfds), "fdListen socket is not in the set\n");
3809 len = sizeof(address);
3810 fdRead = accept(fdListen, (struct sockaddr*) &address, &len);
3811 ok(fdRead != INVALID_SOCKET, "expected a valid socket\n");
3812
3813 /* The connector is signaled through the write descriptor */
3814 FD_ZERO_ALL();
3815 FD_SET_ALL(fdListen);
3816 FD_SET_ALL(fdRead);
3817 FD_SET_ALL(fdWrite);
3818 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3819 ok(ret == 2, "expected 2, got %d\n", ret);
3820 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3821 ok(FD_ISSET(fdRead, &writefds), "fdRead socket is not in the set\n");
3822 len = sizeof(id);
3823 id = 0xdeadbeef;
3824 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
3825 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
3826 ok(id == 0, "expected 0, got %d\n", id);
3827
3828 /* When data is received the receiver gets the read descriptor */
3829 ret = send(fdWrite, "1234", 4, 0);
3830 ok(ret == 4, "expected 4, got %d\n", ret);
3831 FD_ZERO_ALL();
3832 FD_SET_ALL(fdListen);
3833 FD_SET(fdRead, &readfds);
3834 FD_SET(fdRead, &exceptfds);
3835 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3836 ok(ret == 1, "expected 1, got %d\n", ret);
3837 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3838 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
3839 ok(ret == 4, "expected 4, got %d\n", ret);
3840 ok(!strcmp(tmp_buf, "1234"), "data received differs from sent\n");
3841
3842 /* When OOB data is received the socket is set in the except descriptor */
3843 ret = send(fdWrite, "A", 1, MSG_OOB);
3844 ok(ret == 1, "expected 1, got %d\n", ret);
3845 FD_ZERO_ALL();
3846 FD_SET_ALL(fdListen);
3847 FD_SET(fdRead, &readfds);
3848 FD_SET(fdRead, &exceptfds);
3849 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3850 ok(ret == 1, "expected 1, got %d\n", ret);
3851 ok(FD_ISSET(fdRead, &exceptfds), "fdRead socket is not in the set\n");
3852 tmp_buf[0] = 0xAF;
3853 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
3854 ok(ret == 1, "expected 1, got %d\n", ret);
3855 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
3856
3857 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
3858 ret = 1;
3859 ret = setsockopt(fdRead, SOL_SOCKET, SO_OOBINLINE, (char*) &ret, sizeof(ret));
3860 ok(ret == 0, "expected 0, got %d\n", ret);
3861 ret = send(fdWrite, "A", 1, MSG_OOB);
3862 ok(ret == 1, "expected 1, got %d\n", ret);
3863 FD_ZERO_ALL();
3864 FD_SET_ALL(fdListen);
3865 FD_SET(fdRead, &readfds);
3866 FD_SET(fdRead, &exceptfds);
3867 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3868 ok(ret == 1, "expected 1, got %d\n", ret);
3869 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3870 tmp_buf[0] = 0xAF;
3871 SetLastError(0xdeadbeef);
3872 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
3873 if (ret == SOCKET_ERROR) /* can't recv with MSG_OOB if OOBINLINED */
3874 {
3875 ok(GetLastError() == WSAEINVAL, "expected 10022, got %d\n", GetLastError());
3876 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
3877 ok(ret == 1, "expected 1, got %d\n", ret);
3878 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
3879 }
3880 else ok(broken(ret == 1) /* <= NT4 */, "expected error, got 1\n");
3881
3882 /* When the connection is closed the socket is set in the read descriptor */
3883 ret = closesocket(fdRead);
3884 ok(ret == 0, "expected 0, got %d\n", ret);
3885 FD_ZERO_ALL();
3886 FD_SET_ALL(fdListen);
3887 FD_SET(fdWrite, &readfds);
3888 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3889 ok(ret == 1, "expected 1, got %d\n", ret);
3890 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3891 ret = recv(fdWrite, tmp_buf, sizeof(tmp_buf), 0);
3892 ok(ret == 0, "expected 0, got %d\n", ret);
3893
3894 /* When a connection is attempted to a non-listening socket it will get to the except descriptor */
3895 ret = closesocket(fdWrite);
3896 ok(ret == 0, "expected 0, got %d\n", ret);
3897 ret = closesocket(fdListen);
3898 ok(ret == 0, "expected 0, got %d\n", ret);
3899 len = sizeof(address);
3900 fdWrite = setup_connector_socket(&address, len, TRUE);
3901 FD_ZERO_ALL();
3902 FD_SET(fdWrite, &writefds);
3903 FD_SET(fdWrite, &exceptfds);
3904 select_timeout.tv_sec = 2; /* requires more time to realize it will not connect */
3905 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3906 ok(ret == 1, "expected 1, got %d\n", ret);
3907 len = sizeof(id);
3908 id = 0xdeadbeef;
3909 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
3910 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
3911 ok(id == WSAECONNREFUSED, "expected 10061, got %d\n", id);
3912 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
3913 ok(select_timeout.tv_usec == 250000, "select timeout should not have changed\n");
3914 closesocket(fdWrite);
3915
3916 /* Try select() on a closed socket after connection */
3917 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
3918 closesocket(fdRead);
3919 FD_ZERO_ALL();
3920 FD_SET_ALL(fdWrite);
3921 FD_SET_ALL(fdRead);
3922 SetLastError(0xdeadbeef);
3923 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
3924 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
3925 todo_wine
3926 ok(GetLastError() == WSAENOTSOCK, "expected 10038, got %d\n", GetLastError());
3927 /* descriptor sets are unchanged */
3928 ok(readfds.fd_count == 2, "expected 2, got %d\n", readfds.fd_count);
3929 ok(exceptfds.fd_count == 2, "expected 2, got %d\n", exceptfds.fd_count);
3930 closesocket(fdWrite);
3931
3932 /* Close the socket currently being selected in a thread - bug 38399 */
3933 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
3934 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
3935 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
3936 FD_ZERO_ALL();
3937 FD_SET_ALL(fdWrite);
3938 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
3939 ok(ret == 1, "expected 1, got %d\n", ret);
3940 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3941 WaitForSingleObject (thread_handle, 1000);
3942 closesocket(fdRead);
3943 /* test again with only the except descriptor */
3944 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
3945 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
3946 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
3947 FD_ZERO_ALL();
3948 FD_SET(fdWrite, &exceptfds);
3949 SetLastError(0xdeadbeef);
3950 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
3951 todo_wine
3952 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
3953 todo_wine
3954 ok(GetLastError() == WSAENOTSOCK, "expected 10038, got %d\n", GetLastError());
3955 WaitForSingleObject (thread_handle, 1000);
3956 closesocket(fdRead);
3957
3958 /* test UDP behavior of unbound sockets */
3959 select_timeout.tv_sec = 0;
3960 select_timeout.tv_usec = 250000;
3961 fdWrite = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
3962 ok(fdWrite != INVALID_SOCKET, "socket call failed\n");
3963 FD_ZERO_ALL();
3964 FD_SET_ALL(fdWrite);
3965 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3966 ok(ret == 1, "expected 1, got %d\n", ret);
3967 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3968 closesocket(fdWrite);
3969 }
3970 #undef FD_SET_ALL
3971 #undef FD_ZERO_ALL
3972
3973 static DWORD WINAPI AcceptKillThread(void *param)
3974 {
3975 select_thread_params *par = param;
3976 struct sockaddr_in address;
3977 int len = sizeof(address);
3978 SOCKET client_socket;
3979
3980 SetEvent(server_ready);
3981 client_socket = accept(par->s, (struct sockaddr*) &address, &len);
3982 if (client_socket != INVALID_SOCKET)
3983 closesocket(client_socket);
3984 par->ReadKilled = (client_socket == INVALID_SOCKET);
3985 return 0;
3986 }
3987
3988
3989 static int CALLBACK AlwaysDeferConditionFunc(LPWSABUF lpCallerId, LPWSABUF lpCallerData, LPQOS pQos,
3990 LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,
3991 GROUP *g, DWORD_PTR dwCallbackData)
3992 {
3993 return CF_DEFER;
3994 }
3995
3996 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len)
3997 {
3998 int ret, val;
3999 SOCKET server_socket;
4000
4001 server_socket = socket(AF_INET, SOCK_STREAM, 0);
4002 if (server_socket == INVALID_SOCKET)
4003 {
4004 trace("error creating server socket: %d\n", WSAGetLastError());
4005 return INVALID_SOCKET;
4006 }
4007
4008 val = 1;
4009 ret = setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
4010 if (ret)
4011 {
4012 trace("error setting SO_REUSEADDR: %d\n", WSAGetLastError());
4013 closesocket(server_socket);
4014 return INVALID_SOCKET;
4015 }
4016
4017 ret = bind(server_socket, (struct sockaddr *)addr, *len);
4018 if (ret)
4019 {
4020 trace("error binding server socket: %d\n", WSAGetLastError());
4021 }
4022
4023 ret = getsockname(server_socket, (struct sockaddr *)addr, len);
4024 if (ret)
4025 {
4026 skip("failed to lookup bind address: %d\n", WSAGetLastError());
4027 closesocket(server_socket);
4028 return INVALID_SOCKET;
4029 }
4030
4031 ret = listen(server_socket, 5);
4032 if (ret)
4033 {
4034 trace("error making server socket listen: %d\n", WSAGetLastError());
4035 closesocket(server_socket);
4036 return INVALID_SOCKET;
4037 }
4038
4039 return server_socket;
4040 }
4041
4042 static SOCKET setup_connector_socket(struct sockaddr_in *addr, int len, BOOL nonblock)
4043 {
4044 int ret;
4045 SOCKET connector;
4046
4047 connector = socket(AF_INET, SOCK_STREAM, 0);
4048 ok(connector != INVALID_SOCKET, "failed to create connector socket %d\n", WSAGetLastError());
4049
4050 if (nonblock)
4051 set_blocking(connector, !nonblock);
4052
4053 ret = connect(connector, (struct sockaddr *)addr, len);
4054 if (!nonblock)
4055 ok(!ret, "connecting to accepting socket failed %d\n", WSAGetLastError());
4056 else if (ret == SOCKET_ERROR)
4057 {
4058 DWORD error = WSAGetLastError();
4059 ok(error == WSAEWOULDBLOCK || error == WSAEINPROGRESS,
4060 "expected 10035 or 10036, got %d\n", error);
4061 }
4062
4063 return connector;
4064 }
4065
4066 static void test_accept(void)
4067 {
4068 int ret;
4069 SOCKET server_socket, accepted = INVALID_SOCKET, connector;
4070 struct sockaddr_in address;
4071 SOCKADDR_STORAGE ss;
4072 int socklen;
4073 select_thread_params thread_params;
4074 HANDLE thread_handle = NULL;
4075 DWORD id;
4076
4077 memset(&address, 0, sizeof(address));
4078 address.sin_addr.s_addr = inet_addr("127.0.0.1");
4079 address.sin_family = AF_INET;
4080
4081 socklen = sizeof(address);
4082 server_socket = setup_server_socket(&address, &socklen);
4083 if (server_socket == INVALID_SOCKET)
4084 {
4085 trace("error creating server socket: %d\n", WSAGetLastError());
4086 return;
4087 }
4088
4089 connector = setup_connector_socket(&address, socklen, FALSE);
4090 if (connector == INVALID_SOCKET) goto done;
4091
4092 trace("Blocking accept next\n");
4093
4094 accepted = WSAAccept(server_socket, NULL, NULL, AlwaysDeferConditionFunc, 0);
4095 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
4096
4097 accepted = accept(server_socket, NULL, 0);
4098 ok(accepted != INVALID_SOCKET, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
4099
4100 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
4101 if (server_ready == INVALID_HANDLE_VALUE)
4102 {
4103 trace("error creating event: %d\n", GetLastError());
4104 goto done;
4105 }
4106
4107 thread_params.s = server_socket;
4108 thread_params.ReadKilled = FALSE;
4109 thread_handle = CreateThread(NULL, 0, AcceptKillThread, &thread_params, 0, &id);
4110 if (thread_handle == NULL)
4111 {
4112 trace("error creating thread: %d\n", GetLastError());
4113 goto done;
4114 }
4115
4116 WaitForSingleObject(server_ready, INFINITE);
4117 Sleep(200);
4118 ret = closesocket(server_socket);
4119 if (ret != 0)
4120 {
4121 trace("closesocket failed: %d\n", WSAGetLastError());
4122 goto done;
4123 }
4124
4125 WaitForSingleObject(thread_handle, 1000);
4126 ok(thread_params.ReadKilled || broken(!thread_params.ReadKilled) /* Win98/ME, after accept */,
4127 "closesocket did not wakeup accept\n");
4128
4129 closesocket(accepted);
4130 closesocket(connector);
4131 accepted = connector = INVALID_SOCKET;
4132
4133 socklen = sizeof(address);
4134 server_socket = setup_server_socket(&address, &socklen);
4135 if (server_socket == INVALID_SOCKET) goto done;
4136
4137 connector = setup_connector_socket(&address, socklen, FALSE);
4138 if (connector == INVALID_SOCKET) goto done;
4139
4140 socklen = 0;
4141 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
4142 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
4143 ok(!socklen, "got %d\n", socklen);
4144 closesocket(connector);
4145 connector = INVALID_SOCKET;
4146
4147 socklen = sizeof(address);
4148 connector = setup_connector_socket(&address, socklen, FALSE);
4149 if (connector == INVALID_SOCKET) goto done;
4150
4151 accepted = WSAAccept(server_socket, NULL, NULL, NULL, 0);
4152 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4153 closesocket(accepted);
4154 closesocket(connector);
4155 accepted = connector = INVALID_SOCKET;
4156
4157 socklen = sizeof(address);
4158 connector = setup_connector_socket(&address, socklen, FALSE);
4159 if (connector == INVALID_SOCKET) goto done;
4160
4161 socklen = sizeof(ss);
4162 memset(&ss, 0, sizeof(ss));
4163 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
4164 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4165 ok(socklen != sizeof(ss), "unexpected length\n");
4166 ok(ss.ss_family, "family not set\n");
4167 closesocket(accepted);
4168 closesocket(connector);
4169 accepted = connector = INVALID_SOCKET;
4170
4171 socklen = sizeof(address);
4172 connector = setup_connector_socket(&address, socklen, FALSE);
4173 if (connector == INVALID_SOCKET) goto done;
4174
4175 socklen = 0;
4176 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4177 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
4178 ok(!socklen, "got %d\n", socklen);
4179 closesocket(connector);
4180 accepted = connector = INVALID_SOCKET;
4181
4182 socklen = sizeof(address);
4183 connector = setup_connector_socket(&address, socklen, FALSE);
4184 if (connector == INVALID_SOCKET) goto done;
4185
4186 accepted = accept(server_socket, NULL, NULL);
4187 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4188 closesocket(accepted);
4189 closesocket(connector);
4190 accepted = connector = INVALID_SOCKET;
4191
4192 socklen = sizeof(address);
4193 connector = setup_connector_socket(&address, socklen, FALSE);
4194 if (connector == INVALID_SOCKET) goto done;
4195
4196 socklen = sizeof(ss);
4197 memset(&ss, 0, sizeof(ss));
4198 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4199 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4200 ok(socklen != sizeof(ss), "unexpected length\n");
4201 ok(ss.ss_family, "family not set\n");
4202
4203 done:
4204 if (accepted != INVALID_SOCKET)
4205 closesocket(accepted);
4206 if (connector != INVALID_SOCKET)
4207 closesocket(connector);
4208 if (thread_handle != NULL)
4209 CloseHandle(thread_handle);
4210 if (server_ready != INVALID_HANDLE_VALUE)
4211 CloseHandle(server_ready);
4212 if (server_socket != INVALID_SOCKET)
4213 closesocket(server_socket);
4214 }
4215
4216 static void test_extendedSocketOptions(void)
4217 {
4218 WSADATA wsa;
4219 SOCKET sock;
4220 struct sockaddr_in sa;
4221 int sa_len = sizeof(struct sockaddr_in);
4222 int optval, optlen = sizeof(int), ret;
4223 BOOL bool_opt_val;
4224 LINGER linger_val;
4225
4226 if(WSAStartup(MAKEWORD(2,0), &wsa)){
4227 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4228 return;
4229 }
4230
4231 memset(&sa, 0, sa_len);
4232
4233 sa.sin_family = AF_INET;
4234 sa.sin_port = htons(0);
4235 sa.sin_addr.s_addr = htonl(INADDR_ANY);
4236
4237 if((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP)) == INVALID_SOCKET) {
4238 trace("Creating the socket failed: %d\n", WSAGetLastError());
4239 WSACleanup();
4240 return;
4241 }
4242
4243 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
4244 trace("Failed to bind socket: %d\n", WSAGetLastError());
4245 closesocket(sock);
4246 WSACleanup();
4247 return;
4248 }
4249
4250 ret = getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4251
4252 ok(ret == 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret);
4253 ok((optval == 65507) || (optval == 65527),
4254 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval);
4255
4256 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
4257 SetLastError(0xdeadbeef);
4258 optval = 0xdeadbeef;
4259 optlen = sizeof(int);
4260 ret = getsockopt(sock, 0xffffffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4261 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4262 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4263 ret, WSAGetLastError(), optval, optval);
4264
4265 /* more invalid values for level */
4266 SetLastError(0xdeadbeef);
4267 optval = 0xdeadbeef;
4268 optlen = sizeof(int);
4269 ret = getsockopt(sock, 0x1234ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4270 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4271 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4272 ret, WSAGetLastError(), optval, optval);
4273
4274 SetLastError(0xdeadbeef);
4275 optval = 0xdeadbeef;
4276 optlen = sizeof(int);
4277 ret = getsockopt(sock, 0x8000ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4278 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4279 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4280 ret, WSAGetLastError(), optval, optval);
4281
4282 SetLastError(0xdeadbeef);
4283 optval = 0xdeadbeef;
4284 optlen = sizeof(int);
4285 ret = getsockopt(sock, 0x00008000, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4286 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4287 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4288 ret, WSAGetLastError(), optval, optval);
4289
4290 SetLastError(0xdeadbeef);
4291 optval = 0xdeadbeef;
4292 optlen = sizeof(int);
4293 ret = getsockopt(sock, 0x00000800, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4294 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4295 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4296 ret, WSAGetLastError(), optval, optval);
4297
4298 SetLastError(0xdeadbeef);
4299 optlen = sizeof(LINGER);
4300 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
4301 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAENOPROTOOPT),
4302 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
4303 ret, WSAGetLastError());
4304 closesocket(sock);
4305
4306 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
4307 trace("Creating the socket failed: %d\n", WSAGetLastError());
4308 WSACleanup();
4309 return;
4310 }
4311
4312 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
4313 trace("Failed to bind socket: %d\n", WSAGetLastError());
4314 closesocket(sock);
4315 WSACleanup();
4316 return;
4317 }
4318
4319 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
4320 ok(ret == 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret);
4321
4322 optlen = sizeof(BOOL);
4323 ret = getsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *)&bool_opt_val, &optlen);
4324 ok(ret == 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret);
4325 ok((linger_val.l_onoff && !bool_opt_val) || (!linger_val.l_onoff && bool_opt_val),
4326 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
4327 bool_opt_val, linger_val.l_onoff);
4328
4329 closesocket(sock);
4330 WSACleanup();
4331 }
4332
4333 static void test_getsockname(void)
4334 {
4335 WSADATA wsa;
4336 SOCKET sock;
4337 struct sockaddr_in sa_set, sa_get;
4338 int sa_set_len = sizeof(struct sockaddr_in);
4339 int sa_get_len = sa_set_len;
4340 static const unsigned char null_padding[] = {0,0,0,0,0,0,0,0};
4341 int ret;
4342 struct hostent *h;
4343
4344 if(WSAStartup(MAKEWORD(2,0), &wsa)){
4345 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4346 return;
4347 }
4348
4349 memset(&sa_set, 0, sa_set_len);
4350
4351 sa_set.sin_family = AF_INET;
4352 sa_set.sin_port = htons(0);
4353 sa_set.sin_addr.s_addr = htonl(INADDR_ANY);
4354
4355 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
4356 trace("Creating the socket failed: %d\n", WSAGetLastError());
4357 WSACleanup();
4358 return;
4359 }
4360
4361 sa_get = sa_set;
4362 if (getsockname(sock, (struct sockaddr*) &sa_get, &sa_get_len) == 0)
4363 ok(0, "getsockname on unbound socket should fail\n");
4364 else {
4365 ok(WSAGetLastError() == WSAEINVAL, "getsockname on unbound socket "
4366 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL);
4367 ok(memcmp(&sa_get, &sa_set, sizeof(sa_get)) == 0,
4368 "failed getsockname modified sockaddr when it shouldn't\n");
4369 }
4370
4371 if(bind(sock, (struct sockaddr *) &sa_set, sa_set_len) < 0){
4372 trace("Failed to bind socket: %d\n", WSAGetLastError());
4373 closesocket(sock);
4374 WSACleanup();
4375 return;
4376 }
4377
4378 if(getsockname(sock, (struct sockaddr *) &sa_get, &sa_get_len) != 0){
4379 trace("Failed to call getsockname: %d\n", WSAGetLastError());
4380 closesocket(sock);
4381 WSACleanup();
4382 return;
4383 }
4384
4385 ret = memcmp(sa_get.sin_zero, null_padding, 8);
4386 ok(ret == 0 || broken(ret != 0), /* NT4 */
4387 "getsockname did not zero the sockaddr_in structure\n");
4388
4389 closesocket(sock);
4390
4391 h = gethostbyname("");
4392 if (h && h->h_length == 4) /* this test is only meaningful in IPv4 */
4393 {
4394 int i;
4395 for (i = 0; h->h_addr_list[i]; i++)
4396 {
4397 char ipstr[32];
4398 struct in_addr ip;
4399 ip.s_addr = *(ULONG *) h->h_addr_list[i];
4400
4401 sock = socket(AF_INET, SOCK_DGRAM, 0);
4402 ok(sock != INVALID_SOCKET, "socket failed with %d\n", GetLastError());
4403
4404 memset(&sa_set, 0, sizeof(sa_set));
4405 sa_set.sin_family = AF_INET;
4406 sa_set.sin_addr.s_addr = ip.s_addr;
4407 /* The same address we bind must be the same address we get */
4408 ret = bind(sock, (struct sockaddr*)&sa_set, sizeof(sa_set));
4409 ok(ret == 0, "bind failed with %d\n", GetLastError());
4410 sa_get_len = sizeof(sa_get);
4411 ret = getsockname(sock, (struct sockaddr*)&sa_get, &sa_get_len);
4412 ok(ret == 0, "getsockname failed with %d\n", GetLastError());
4413 strcpy(ipstr, inet_ntoa(sa_get.sin_addr));
4414 trace("testing bind on interface %s\n", ipstr);
4415 ok(sa_get.sin_addr.s_addr == sa_set.sin_addr.s_addr,
4416 "address does not match: %s != %s\n", ipstr, inet_ntoa(sa_set.sin_addr));
4417
4418 closesocket(sock);
4419 }
4420 }
4421
4422 WSACleanup();
4423 }
4424
4425 static void test_dns(void)
4426 {
4427 struct hostent *h;
4428 union memaddress
4429 {
4430 char *chr;
4431 void *mem;
4432 } addr;
4433 char **ptr;
4434 int acount;
4435
4436 h = gethostbyname("");
4437 ok(h != NULL, "gethostbyname(\"\") failed with %d\n", h_errno);
4438
4439 /* Use an address with valid alias names if possible */
4440 h = gethostbyname("source.winehq.org");
4441 if(!h)
4442 {
4443 skip("Can't test the hostent structure because gethostbyname failed\n");
4444 return;
4445 }
4446
4447 /* The returned struct must be allocated in a very strict way. First we need to
4448 * count how many aliases there are because they must be located right after
4449 * the struct hostent size. Knowing the amount of aliases we know the exact
4450 * location of the first IP returned. Rule valid for >= XP, for older OS's
4451 * it's somewhat the opposite. */
4452 addr.mem = h + 1;
4453 if(h->h_addr_list == addr.mem) /* <= W2K */
4454 {
4455 win_skip("Skipping hostent tests since this OS is unsupported\n");
4456 return;
4457 }
4458
4459 ok(h->h_aliases == addr.mem,
4460 "hostent->h_aliases should be in %p, it is in %p\n", addr.mem, h->h_aliases);
4461
4462 for(ptr = h->h_aliases, acount = 1; *ptr; ptr++) acount++;
4463 addr.chr += sizeof(*ptr) * acount;
4464 ok(h->h_addr_list == addr.mem,
4465 "hostent->h_addr_list should be in %p, it is in %p\n", addr.mem, h->h_addr_list);
4466
4467 for(ptr = h->h_addr_list, acount = 1; *ptr; ptr++) acount++;
4468
4469 addr.chr += sizeof(*ptr) * acount;
4470 ok(h->h_addr_list[0] == addr.mem,
4471 "hostent->h_addr_list[0] should be in %p, it is in %p\n", addr.mem, h->h_addr_list[0]);
4472 }
4473
4474 /* Our winsock headers don't define gethostname because it conflicts with the
4475 * definition in unistd.h. Define it here to get rid of the warning. */
4476
4477 int WINAPI gethostname(char *name, int namelen);
4478
4479 static void test_gethostbyname(void)
4480 {
4481 struct hostent *he;
4482 struct in_addr **addr_list;
4483 char name[256], first_ip[16];
4484 int ret, i, count;
4485 PMIB_IPFORWARDTABLE routes = NULL;
4486 PIP_ADAPTER_INFO adapters = NULL, k;
4487 DWORD adap_size = 0, route_size = 0;
4488 BOOL found_default = FALSE;
4489 BOOL local_ip = FALSE;
4490
4491 ret = gethostname(name, sizeof(name));
4492 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4493
4494 he = gethostbyname(name);
4495 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, WSAGetLastError());
4496 addr_list = (struct in_addr **)he->h_addr_list;
4497 strcpy(first_ip, inet_ntoa(*addr_list[0]));
4498
4499 trace("List of local IPs:\n");
4500 for(count = 0; addr_list[count] != NULL; count++)
4501 {
4502 char *ip = inet_ntoa(*addr_list[count]);
4503 if (!strcmp(ip, "127.0.0.1"))
4504 local_ip = TRUE;
4505 trace("%s\n", ip);
4506 }
4507
4508 if (local_ip)
4509 {
4510 ok (count == 1, "expected 127.0.0.1 to be the only IP returned\n");
4511 skip("Only the loopback address is present, skipping tests\n");
4512 return;
4513 }
4514
4515 if (!pGetAdaptersInfo || !pGetIpForwardTable)
4516 {
4517 win_skip("GetAdaptersInfo and/or GetIpForwardTable not found, skipping tests\n");
4518 return;
4519 }
4520
4521 ret = pGetAdaptersInfo(NULL, &adap_size);
4522 ok (ret == ERROR_BUFFER_OVERFLOW, "GetAdaptersInfo failed with a different error: %d\n", ret);
4523 ret = pGetIpForwardTable(NULL, &route_size, FALSE);
4524 ok (ret == ERROR_INSUFFICIENT_BUFFER, "GetIpForwardTable failed with a different error: %d\n", ret);
4525
4526 adapters = HeapAlloc(GetProcessHeap(), 0, adap_size);
4527 routes = HeapAlloc(GetProcessHeap(), 0, route_size);
4528
4529 ret = pGetAdaptersInfo(adapters, &adap_size);
4530 ok (ret == NO_ERROR, "GetAdaptersInfo failed, error: %d\n", ret);
4531 ret = pGetIpForwardTable(routes, &route_size, FALSE);
4532 ok (ret == NO_ERROR, "GetIpForwardTable failed, error: %d\n", ret);
4533
4534 /* This test only has meaning if there is more than one IP configured */
4535 if (adapters->Next == NULL && count == 1)
4536 {
4537 skip("Only one IP is present, skipping tests\n");
4538 goto cleanup;
4539 }
4540
4541 for (i = 0; !found_default && i < routes->dwNumEntries; i++)
4542 {
4543 /* default route (ip 0.0.0.0) ? */
4544 if (routes->table[i].dwForwardDest) continue;
4545
4546 for (k = adapters; k != NULL; k = k->Next)
4547 {
4548 char *ip;
4549
4550 if (k->Index != routes->table[i].dwForwardIfIndex) continue;
4551
4552 /* the first IP returned from gethostbyname must be a default route */
4553 ip = k->IpAddressList.IpAddress.String;
4554 if (!strcmp(first_ip, ip))
4555 {
4556 found_default = TRUE;
4557 break;
4558 }
4559 }
4560 }
4561 ok (found_default, "failed to find the first IP from gethostbyname!\n");
4562
4563 cleanup:
4564 HeapFree(GetProcessHeap(), 0, adapters);
4565 HeapFree(GetProcessHeap(), 0, routes);
4566 }
4567
4568 static void test_gethostbyname_hack(void)
4569 {
4570 struct hostent *he;
4571 char name[256];
4572 static BYTE loopback[] = {127, 0, 0, 1};
4573 static BYTE magic_loopback[] = {127, 12, 34, 56};
4574 int ret;
4575
4576 ret = gethostname(name, 256);
4577 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4578
4579 he = gethostbyname("localhost");
4580 ok(he != NULL, "gethostbyname(\"localhost\") failed: %d\n", h_errno);
4581 if(he)
4582 {
4583 if(he->h_length != 4)
4584 {
4585 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
4586 return;
4587 }
4588
4589 ok(memcmp(he->h_addr_list[0], loopback, he->h_length) == 0,
4590 "gethostbyname(\"localhost\") returned %d.%d.%d.%d\n",
4591 he->h_addr_list[0][0], he->h_addr_list[0][1], he->h_addr_list[0][2],
4592 he->h_addr_list[0][3]);
4593 }
4594
4595 if(strcmp(name, "localhost") == 0)
4596 {
4597 skip("hostname seems to be \"localhost\", skipping test.\n");
4598 return;
4599 }
4600
4601 he = gethostbyname(name);
4602 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, h_errno);
4603 if(he)
4604 {
4605 if(he->h_length != 4)
4606 {
4607 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
4608 return;
4609 }
4610
4611 if (he->h_addr_list[0][0] == 127)
4612 {
4613 ok(memcmp(he->h_addr_list[0], magic_loopback, he->h_length) == 0,
4614 "gethostbyname(\"%s\") returned %d.%d.%d.%d not 127.12.34.56\n",
4615 name, he->h_addr_list[0][0], he->h_addr_list[0][1],
4616 he->h_addr_list[0][2], he->h_addr_list[0][3]);
4617 }
4618 }
4619
4620 gethostbyname("nonexistent.winehq.org");
4621 /* Don't check for the return value, as some braindead ISPs will kindly
4622 * resolve nonexistent host names to addresses of the ISP's spam pages. */
4623 }
4624
4625 static void test_gethostname(void)
4626 {
4627 struct hostent *he;
4628 char name[256];
4629 int ret, len;
4630
4631 WSASetLastError(0xdeadbeef);
4632 ret = gethostname(NULL, 256);
4633 ok(ret == -1, "gethostname() returned %d\n", ret);
4634 ok(WSAGetLastError() == WSAEFAULT, "gethostname with null buffer "
4635 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT);
4636
4637 ret = gethostname(name, sizeof(name));
4638 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4639 he = gethostbyname(name);
4640 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, WSAGetLastError());
4641
4642 len = strlen(name);
4643 WSASetLastError(0xdeadbeef);
4644 strcpy(name, "deadbeef");
4645 ret = gethostname(name, len);
4646 ok(ret == -1, "gethostname() returned %d\n", ret);
4647 ok(!strcmp(name, "deadbeef"), "name changed unexpected!\n");
4648 ok(WSAGetLastError() == WSAEFAULT, "gethostname with insufficient length "
4649 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT);
4650
4651 len++;
4652 ret = gethostname(name, len);
4653 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4654 he = gethostbyname(name);
4655 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, WSAGetLastError());
4656 }
4657
4658 static void test_inet_addr(void)
4659 {
4660 u_long addr;
4661
4662 addr = inet_addr(NULL);
4663 ok(addr == INADDR_NONE, "inet_addr succeeded unexpectedly\n");
4664 }
4665
4666 static void test_addr_to_print(void)
4667 {
4668 char dst[16];
4669 char dst6[64];
4670 const char * pdst;
4671 struct in_addr in;
4672 struct in6_addr in6;
4673
4674 u_long addr0_Num = 0x00000000;
4675 PCSTR addr0_Str = "0.0.0.0";
4676 u_long addr1_Num = 0x20201015;
4677 PCSTR addr1_Str = "21.16.32.32";
4678 u_char addr2_Num[16] = {0,0,0,0,0,0,0,0,0,0,0xff,0xfe,0xcC,0x98,0xbd,0x74};
4679 PCSTR addr2_Str = "::fffe:cc98:bd74";
4680 u_char addr3_Num[16] = {0x20,0x30,0xa4,0xb1};
4681 PCSTR addr3_Str = "2030:a4b1::";
4682 u_char addr4_Num[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0xcC,0x98,0xbd,0x74};
4683 PCSTR addr4_Str = "::204.152.189.116";
4684
4685 /* Test IPv4 addresses */
4686 in.s_addr = addr0_Num;
4687
4688 pdst = inet_ntoa(*((struct in_addr*)&in.s_addr));
4689 ok(pdst != NULL, "inet_ntoa failed %s\n", dst);
4690 ok(!strcmp(pdst, addr0_Str),"Address %s != %s\n", pdst, addr0_Str);
4691
4692 /* Test that inet_ntoa and inet_ntop return the same value */
4693 in.S_un.S_addr = addr1_Num;
4694 pdst = inet_ntoa(*((struct in_addr*)&in.s_addr));
4695 ok(pdst != NULL, "inet_ntoa failed %s\n", dst);
4696 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4697
4698 /* InetNtop became available in Vista and Win2008 */
4699 if (!pInetNtop)
4700 {
4701 win_skip("InetNtop not present, not executing tests\n");
4702 return;
4703 }
4704
4705 /* Second part of test */
4706 pdst = pInetNtop(AF_INET,(void*)&in.s_addr, dst, sizeof(dst));
4707 ok(pdst != NULL, "InetNtop failed %s\n", dst);
4708 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4709
4710 /* Test invalid parm conditions */
4711 pdst = pInetNtop(1, (void*)&in.s_addr, dst, sizeof(dst));
4712 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4713 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "Should be WSAEAFNOSUPPORT\n");
4714
4715 /* Test Null destination */
4716 pdst = NULL;
4717 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, NULL, sizeof(dst));
4718 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4719 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4720 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4721
4722 /* Test zero length passed */
4723 WSASetLastError(0);
4724 pdst = NULL;
4725 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, 0);
4726 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4727 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4728 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4729
4730 /* Test length one shorter than the address length */
4731 WSASetLastError(0);
4732 pdst = NULL;
4733 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, 6);
4734 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4735 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4736 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4737
4738 /* Test longer length is ok */
4739 WSASetLastError(0);
4740 pdst = NULL;
4741 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, sizeof(dst)+1);
4742 ok(pdst != NULL, "The pointer should be returned (%p)\n", pdst);
4743 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4744
4745 /* Test the IPv6 addresses */
4746
4747 /* Test an zero prefixed IPV6 address */
4748 memcpy(in6.u.Byte, addr2_Num, sizeof(addr2_Num));
4749 pdst = pInetNtop(AF_INET6,(void*)&in6.s6_addr, dst6, sizeof(dst6));
4750 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
4751 ok(!strcmp(pdst, addr2_Str),"Address %s != %s\n", pdst, addr2_Str);
4752
4753 /* Test an zero suffixed IPV6 address */
4754 memcpy(in6.s6_addr, addr3_Num, sizeof(addr3_Num));
4755 pdst = pInetNtop(AF_INET6,(void*)&in6.s6_addr, dst6, sizeof(dst6));
4756 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
4757 ok(!strcmp(pdst, addr3_Str),"Address %s != %s\n", pdst, addr3_Str);
4758
4759 /* Test the IPv6 address contains the IPv4 address in IPv4 notation */
4760 memcpy(in6.s6_addr, addr4_Num, sizeof(addr4_Num));
4761 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, sizeof(dst6));
4762 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
4763 ok(!strcmp(pdst, addr4_Str),"Address %s != %s\n", pdst, addr4_Str);
4764
4765 /* Test invalid parm conditions */
4766 memcpy(in6.u.Byte, addr2_Num, sizeof(addr2_Num));
4767
4768 /* Test Null destination */
4769 pdst = NULL;
4770 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, NULL, sizeof(dst6));
4771 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4772 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4773 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4774
4775 /* Test zero length passed */
4776 WSASetLastError(0);
4777 pdst = NULL;
4778 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 0);
4779 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4780 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4781 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4782
4783 /* Test length one shorter than the address length */
4784 WSASetLastError(0);
4785 pdst = NULL;
4786 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 16);
4787 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4788 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4789 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4790
4791 /* Test longer length is ok */
4792 WSASetLastError(0);
4793 pdst = NULL;
4794 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 18);
4795 ok(pdst != NULL, "The pointer should be returned (%p)\n", pdst);
4796 }
4797 static void test_inet_pton(void)
4798 {
4799 struct TEST_DATA
4800 {
4801 int family, ret;
4802 DWORD err;
4803 const char *printable, *collapsed, *raw_data;
4804 } tests[] = {
4805 {AF_UNSPEC, -1, WSAEFAULT, /* Test 0 */
4806 NULL, NULL, NULL},
4807 {AF_INET, -1, WSAEFAULT,
4808 NULL, NULL, NULL},
4809 {AF_INET6, -1, WSAEFAULT,
4810 NULL, NULL, NULL},
4811 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
4812 "127.0.0.1", NULL, NULL},
4813 {AF_INET, 1, 0,
4814 "127.0.0.1", "127.0.0.1",
4815 "\x7f\x00\x00\x01"},
4816 {AF_INET6, 0, 0,
4817 "127.0.0.1", "127.0.0.1", NULL},
4818 {AF_INET, 0, 0,
4819 "::1/128", NULL, NULL},
4820 {AF_INET6, 0, 0,
4821 "::1/128", NULL, NULL},
4822 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
4823 "broken", NULL, NULL},
4824 {AF_INET, 0, 0,
4825 "broken", NULL, NULL},
4826 {AF_INET6, 0, 0, /* Test 10 */
4827 "broken", NULL, NULL},
4828 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
4829 "177.32.45.20", NULL, NULL},
4830 {AF_INET, 1, 0,
4831 "177.32.45.20", "177.32.45.20",
4832 "\xb1\x20\x2d\x14"},
4833 {AF_INET6, 0, 0,
4834 "177.32.45.20", NULL, NULL},
4835 {AF_INET, 0, 0,
4836 "2607:f0d0:1002:51::4", NULL, NULL},
4837 {AF_INET6, 1, 0,
4838 "2607:f0d0:1002:51::4", "2607:f0d0:1002:51::4",
4839 "\x26\x07\xf0\xd0\x10\x02\x00\x51\x00\x00\x00\x00\x00\x00\x00\x04"},
4840 {AF_INET, 0, 0,
4841 "::177.32.45.20", NULL, NULL},
4842 {AF_INET6, 1, 0,
4843 "::177.32.45.20", "::177.32.45.20",
4844 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x20\x2d\x14"},
4845 {AF_INET, 0, 0,
4846 "fe80::0202:b3ff:fe1e:8329", NULL, NULL},
4847 {AF_INET6, 1, 0,
4848 "fe80::0202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
4849 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
4850 {AF_INET6, 1, 0, /* Test 20 */
4851 "fe80::202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
4852 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
4853 {AF_INET, 0, 0,
4854 "a", NULL, NULL},
4855 {AF_INET, 0, 0,
4856 "a.b", NULL, NULL},
4857 {AF_INET, 0, 0,
4858 "a.b.c", NULL, NULL},
4859 {AF_INET, 0, 0,
4860 "a.b.c.d", NULL, NULL},
4861 {AF_INET6, 1, 0,
4862 "2001:cdba:0000:0000:0000:0000:3257:9652", "2001:cdba::3257:9652",
4863 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
4864 {AF_INET6, 1, 0,
4865 "2001:cdba::3257:9652", "2001:cdba::3257:9652",
4866 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
4867 {AF_INET6, 1, 0,
4868 "2001:cdba:0:0:0:0:3257:9652", "2001:cdba::3257:9652",
4869 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"}
4870 };
4871 int i, ret;
4872 DWORD err;
4873 char buffer[64],str[64];
4874 WCHAR printableW[64], collapsedW[64];
4875 const char *ptr;
4876 const WCHAR *ptrW;
4877
4878 /* InetNtop and InetPton became available in Vista and Win2008 */
4879 if (!pInetNtop || !pInetNtopW || !pInetPtonA || !pInetPtonW)
4880 {
4881 win_skip("InetNtop and/or InetPton not present, not executing tests\n");
4882 return;
4883 }
4884
4885 for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
4886 {
4887 WSASetLastError(0xdeadbeef);
4888 ret = pInetPtonA(tests[i].family, tests[i].printable, buffer);
4889 ok (ret == tests[i].ret, "Test [%d]: Expected %d, got %d\n", i, tests[i].ret, ret);
4890 if (tests[i].ret == -1)
4891 {
4892 err = WSAGetLastError();
4893 ok (tests[i].err == err, "Test [%d]: Expected 0x%x, got 0x%x\n", i, tests[i].err, err);
4894 }
4895 if (tests[i].ret != 1) continue;
4896 ok (memcmp(buffer, tests[i].raw_data,
4897 tests[i].family == AF_INET ? sizeof(struct in_addr) : sizeof(struct in6_addr)) == 0,
4898 "Test [%d]: Expected binary data differs\n", i);
4899
4900 /* Test the result from Pton with Ntop */
4901 strcpy (str, "deadbeef");
4902 ptr = pInetNtop(tests[i].family, buffer, str, sizeof(str));
4903 ok (ptr != NULL, "Test [%d]: Failed with NULL\n", i);
4904 ok (ptr == str, "Test [%d]: Pointers differ (%p != %p)\n", i, ptr, str);
4905 if (!ptr) continue;
4906 ok (strcmp(ptr, tests[i].collapsed) == 0, "Test [%d]: Expected '%s', got '%s'\n",
4907 i, tests[i].collapsed, ptr);
4908 }
4909
4910 for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
4911 {
4912 if (tests[i].printable)
4913 MultiByteToWideChar(CP_ACP, 0, tests[i].printable, -1, printableW,
4914 sizeof(printableW) / sizeof(printableW[0]));
4915 WSASetLastError(0xdeadbeef);
4916 ret = pInetPtonW(tests[i].family, tests[i].printable ? printableW : NULL, buffer);
4917 ok(ret == tests[i].ret, "Test [%d]: Expected %d, got %d\n", i, tests[i].ret, ret);
4918 if (tests[i].ret == -1)
4919 {
4920 err = WSAGetLastError();
4921 ok(tests[i].err == err, "Test [%d]: Expected 0x%x, got 0x%x\n", i, tests[i].err, err);
4922 }
4923 if (tests[i].ret != 1) continue;
4924 ok(memcmp(buffer, tests[i].raw_data,
4925 tests[i].family == AF_INET ? sizeof(struct in_addr) : sizeof(struct in6_addr)) == 0,
4926 "Test [%d]: Expected binary data differs\n", i);
4927
4928 /* Test the result from Pton with Ntop */
4929 printableW[0] = 0xdead;
4930 ptrW = pInetNtopW(tests[i].family, buffer, printableW, sizeof(printableW) / sizeof(printableW[0]));
4931 ok (ptrW != NULL, "Test [%d]: Failed with NULL\n", i);
4932 ok (ptrW == printableW, "Test [%d]: Pointers differ (%p != %p)\n", i, ptrW, printableW);
4933 if (!ptrW) continue;
4934
4935 MultiByteToWideChar(CP_ACP, 0, tests[i].collapsed, -1, collapsedW,
4936 sizeof(collapsedW) / sizeof(collapsedW[0]));
4937 ok (lstrcmpW(ptrW, collapsedW) == 0, "Test [%d]: Expected '%s', got '%s'\n",
4938 i, tests[i].collapsed, wine_dbgstr_w(ptrW));
4939 }
4940 }
4941
4942 static void test_ioctlsocket(void)
4943 {
4944 SOCKET sock, src, dst;
4945 struct tcp_keepalive kalive;
4946 int ret, optval;
4947 static const LONG cmds[] = {FIONBIO, FIONREAD, SIOCATMARK};
4948 UINT i, bytes_rec;
4949 char data;
4950 WSABUF bufs;
4951 u_long arg = 0;
4952
4953 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4954 ok(sock != INVALID_SOCKET, "Creating the socket failed: %d\n", WSAGetLastError());
4955 if(sock == INVALID_SOCKET)
4956 {
4957 skip("Can't continue without a socket.\n");
4958 return;
4959 }
4960
4961 for(i = 0; i < sizeof(cmds)/sizeof(cmds[0]); i++)
4962 {
4963 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
4964 ret = ioctlsocket(sock, cmds[i], (u_long *)1);
4965 ok(ret == SOCKET_ERROR, "ioctlsocket succeeded unexpectedly\n");
4966 ret = WSAGetLastError();
4967 ok(ret == WSAEFAULT, "expected WSAEFAULT, got %d instead\n", ret);
4968 }
4969
4970 /* A fresh and not connected socket has no urgent data, this test shows
4971 * that normal(not urgent) data returns a non-zero value for SIOCATMARK. */
4972
4973 ret = ioctlsocket(sock, SIOCATMARK, &arg);
4974 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
4975 ok(arg, "SIOCATMARK expected a non-zero value\n");
4976
4977 /* when SO_OOBINLINE is set SIOCATMARK must always return TRUE */
4978 optval = 1;
4979 ret = setsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
4980 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
4981 arg = 0;
4982 ret = ioctlsocket(sock, SIOCATMARK, &arg);
4983 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
4984 ok(arg, "SIOCATMARK expected a non-zero value\n");
4985
4986 /* disable SO_OOBINLINE and get the same old behavior */
4987 optval = 0;
4988 ret = setsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
4989 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
4990 arg = 0;
4991 ret = ioctlsocket(sock, SIOCATMARK, &arg);
4992 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
4993 ok(arg, "SIOCATMARK expected a non-zero value\n");
4994
4995 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &arg, 0, NULL, 0, &arg, NULL, NULL);
4996 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
4997 ret = WSAGetLastError();
4998 ok(ret == WSAEFAULT || broken(ret == WSAEINVAL), "expected WSAEFAULT, got %d instead\n", ret);
4999
5000 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, NULL, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5001 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5002 ret = WSAGetLastError();
5003 ok(ret == WSAEFAULT || broken(ret == WSAEINVAL), "expected WSAEFAULT, got %d instead\n", ret);
5004
5005 /* broken used to catch W95, W98, NT4 */
5006 make_keepalive(kalive, 0, 0, 0);
5007 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5008 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
5009
5010 make_keepalive(kalive, 1, 0, 0);
5011 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5012 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
5013
5014 make_keepalive(kalive, 1, 1000, 1000);
5015 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5016 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
5017
5018 make_keepalive(kalive, 1, 10000, 10000);
5019 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5020 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
5021
5022 make_keepalive(kalive, 1, 100, 100);
5023 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5024 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
5025
5026 make_keepalive(kalive, 0, 100, 100);
5027 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5028 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
5029
5030 closesocket(sock);
5031
5032 if (tcp_socketpair(&src, &dst) != 0)
5033 {
5034 ok(0, "creating socket pair failed, skipping test\n");
5035 return;
5036 }
5037
5038 /* test FIONREAD on TCP sockets */
5039 optval = 0xdeadbeef;
5040 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
5041 ok(ret == 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
5042 ok(optval == 0, "FIONREAD should have returned 0 bytes, got %d instead\n", optval);
5043
5044 optval = 0xdeadbeef;
5045 ok(send(src, "TEST", 4, 0) == 4, "failed to send test data\n");
5046 Sleep(100);
5047 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
5048 ok(ret == 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
5049 ok(optval == 4, "FIONREAD should have returned 4 bytes, got %d instead\n", optval);
5050
5051 /* trying to read from an OOB inlined socket with MSG_OOB results in WSAEINVAL */
5052 set_blocking(dst, FALSE);
5053 i = MSG_OOB;
5054 SetLastError(0xdeadbeef);
5055 ret = recv(dst, &data, 1, i);
5056 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
5057 ret = GetLastError();
5058 ok(ret == WSAEWOULDBLOCK, "expected 10035, got %d\n", ret);
5059 bufs.len = sizeof(char);
5060 bufs.buf = &data;
5061 ret = WSARecv(dst, &bufs, 1, &bytes_rec, &i, NULL, NULL);
5062 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
5063 ret = GetLastError();
5064 ok(ret == WSAEWOULDBLOCK, "expected 10035, got %d\n", ret);
5065 optval = 1;
5066 ret = setsockopt(dst, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
5067 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
5068 i = MSG_OOB;
5069 SetLastError(0xdeadbeef);
5070 ret = recv(dst, &data, 1, i);
5071 if (ret == SOCKET_ERROR)
5072 {
5073 ret = GetLastError();
5074 ok(ret == WSAEINVAL, "expected 10022, got %d\n", ret);
5075 bufs.len = sizeof(char);
5076 bufs.buf = &data;
5077 ret = WSARecv(dst, &bufs, 1, &bytes_rec, &i, NULL, NULL);
5078 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
5079 ret = GetLastError();
5080 ok(ret == WSAEINVAL, "expected 10022, got %d\n", ret);
5081 }
5082 else ok(broken(ret == 1) /* <= NT4 */, "expected error, got 1\n");
5083
5084 closesocket(dst);
5085 optval = 0xdeadbeef;
5086 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
5087 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5088 ok(optval == 0xdeadbeef, "FIONREAD should not have changed last error, got %d instead\n", optval);
5089 closesocket(src);
5090 }
5091
5092 static BOOL drain_pause = FALSE;
5093 static DWORD WINAPI drain_socket_thread(LPVOID arg)
5094 {
5095 char buffer[1024];
5096 SOCKET sock = *(SOCKET*)arg;
5097 int ret;
5098
5099 while ((ret = recv(sock, buffer, sizeof(buffer), 0)) != 0)
5100 {
5101 if (ret < 0)
5102 {
5103 if (WSAGetLastError() == WSAEWOULDBLOCK)
5104 {
5105 fd_set readset;
5106 FD_ZERO(&readset);
5107 FD_SET(sock, &readset);
5108 select(sock+1, &readset, NULL, NULL, NULL);
5109 while (drain_pause)
5110 Sleep(100);
5111 }
5112 else
5113 break;
5114 }
5115 }
5116 return 0;
5117 }
5118
5119 static void test_send(void)
5120 {
5121 SOCKET src = INVALID_SOCKET;
5122 SOCKET dst = INVALID_SOCKET;
5123 HANDLE hThread = NULL;
5124 const int buflen = 1024*1024;
5125 char *buffer = NULL;
5126 int ret, i, zero = 0;
5127 WSABUF buf;
5128 OVERLAPPED ov;
5129 BOOL bret;
5130 DWORD id, bytes_sent, dwRet;
5131
5132 memset(&ov, 0, sizeof(ov));
5133
5134 if (tcp_socketpair(&src, &dst) != 0)
5135 {
5136 ok(0, "creating socket pair failed, skipping test\n");
5137 return;
5138 }
5139
5140 set_blocking(dst, FALSE);
5141 /* force disable buffering so we can get a pending overlapped request */
5142 ret = setsockopt(dst, SOL_SOCKET, SO_SNDBUF, (char *) &zero, sizeof(zero));
5143 ok(!ret, "setsockopt SO_SNDBUF failed: %d - %d\n", ret, GetLastError());
5144
5145 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
5146 if (hThread == NULL)
5147 {
5148 ok(0, "CreateThread failed, error %d\n", GetLastError());
5149 goto end;
5150 }
5151
5152 buffer = HeapAlloc(GetProcessHeap(), 0, buflen);
5153 if (buffer == NULL)
5154 {
5155 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
5156 goto end;
5157 }
5158
5159 /* fill the buffer with some nonsense */
5160 for (i = 0; i < buflen; ++i)
5161 {
5162 buffer[i] = (char) i;
5163 }
5164
5165 ret = send(src, buffer, buflen, 0);
5166 if (ret >= 0)
5167 ok(ret == buflen, "send should have sent %d bytes, but it only sent %d\n", buflen, ret);
5168 else
5169 ok(0, "send failed, error %d\n", WSAGetLastError());
5170
5171 buf.buf = buffer;
5172 buf.len = buflen;
5173
5174 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5175 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
5176 if (!ov.hEvent)
5177 goto end;
5178
5179 bytes_sent = 0;
5180 WSASetLastError(12345);
5181 ret = WSASend(dst, &buf, 1, &bytes_sent, 0, &ov, NULL);
5182 ok((ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING) || broken(bytes_sent == buflen),
5183 "Failed to start overlapped send %d - %d - %d/%d\n", ret, WSAGetLastError(), bytes_sent, buflen);
5184
5185 /* don't check for completion yet, we may need to drain the buffer while still sending */
5186 set_blocking(src, FALSE);
5187 for (i = 0; i < buflen; ++i)
5188 {
5189 int j = 0;
5190
5191 ret = recv(src, buffer, 1, 0);
5192 while (ret == SOCKET_ERROR && GetLastError() == WSAEWOULDBLOCK && j < 100)
5193 {
5194 j++;
5195 Sleep(50);
5196 ret = recv(src, buffer, 1, 0);
5197 }
5198
5199 ok(ret == 1, "Failed to receive data %d - %d (got %d/%d)\n", ret, GetLastError(), i, buflen);
5200 if (ret != 1)
5201 break;
5202
5203 ok(buffer[0] == (char) i, "Received bad data at position %d\n", i);
5204 }
5205
5206 dwRet = WaitForSingleObject(ov.hEvent, 1000);
5207 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
5208 if (dwRet == WAIT_OBJECT_0)
5209 {
5210 bret = GetOverlappedResult((HANDLE)dst, &ov, &bytes_sent, FALSE);
5211 ok((bret && bytes_sent == buflen) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
5212 "Got %d instead of %d (%d - %d)\n", bytes_sent, buflen, bret, GetLastError());
5213 }
5214
5215 WSASetLastError(12345);
5216 ret = WSASend(INVALID_SOCKET, &buf, 1, NULL, 0, &ov, NULL);
5217 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
5218 "WSASend failed %d - %d\n", ret, WSAGetLastError());
5219
5220 WSASetLastError(12345);
5221 ret = WSASend(dst, &buf, 1, NULL, 0, &ov, NULL);
5222 ok(ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING,
5223 "Failed to start overlapped send %d - %d\n", ret, WSAGetLastError());
5224
5225 end:
5226 if (src != INVALID_SOCKET)
5227 closesocket(src);
5228 if (dst != INVALID_SOCKET)
5229 closesocket(dst);
5230 if (hThread != NULL)
5231 {
5232 dwRet = WaitForSingleObject(hThread, 500);
5233 ok(dwRet == WAIT_OBJECT_0, "failed to wait for thread termination: %d\n", GetLastError());
5234 CloseHandle(hThread);
5235 }
5236 if (ov.hEvent)
5237 CloseHandle(ov.hEvent);
5238 HeapFree(GetProcessHeap(), 0, buffer);
5239 }
5240
5241 typedef struct async_message
5242 {
5243 SOCKET socket;
5244 LPARAM lparam;
5245 struct async_message *next;
5246 } async_message;
5247
5248 static struct async_message *messages_received;
5249
5250 #define WM_SOCKET (WM_USER+100)
5251 static LRESULT CALLBACK ws2_test_WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
5252 {
5253 struct async_message *message;
5254
5255 switch (msg)
5256 {
5257 case WM_SOCKET:
5258 message = HeapAlloc(GetProcessHeap(), 0, sizeof(*message));
5259 message->socket = (SOCKET) wparam;
5260 message->lparam = lparam;
5261 message->next = NULL;
5262
5263 if (messages_received)
5264 {
5265 struct async_message *last = messages_received;
5266 while (last->next) last = last->next;
5267 last->next = message;
5268 }
5269 else
5270 messages_received = message;
5271 return 0;
5272 }
5273
5274 return DefWindowProcA(hwnd, msg, wparam, lparam);
5275 }
5276
5277 static void get_event_details(int event, int *bit, char *name)
5278 {
5279 switch (event)
5280 {
5281 case FD_ACCEPT:
5282 if (bit) *bit = FD_ACCEPT_BIT;
5283 if (name) strcpy(name, "FD_ACCEPT");
5284 break;
5285 case FD_CONNECT:
5286 if (bit) *bit = FD_CONNECT_BIT;
5287 if (name) strcpy(name, "FD_CONNECT");
5288 break;
5289 case FD_READ:
5290 if (bit) *bit = FD_READ_BIT;
5291 if (name) strcpy(name, "FD_READ");
5292 break;
5293 case FD_OOB:
5294 if (bit) *bit = FD_OOB_BIT;
5295 if (name) strcpy(name, "FD_OOB");
5296 break;
5297 case FD_WRITE:
5298 if (bit) *bit = FD_WRITE_BIT;
5299 if (name) strcpy(name, "FD_WRITE");
5300 break;
5301 case FD_CLOSE:
5302 if (bit) *bit = FD_CLOSE_BIT;
5303 if (name) strcpy(name, "FD_CLOSE");
5304 break;
5305 default:
5306 if (bit) *bit = -1;
5307 if (name) sprintf(name, "bad%x", event);
5308 }
5309 }
5310
5311 static const char *dbgstr_event_seq(const LPARAM *seq)
5312 {
5313 static char message[1024];
5314 char name[12];
5315 int len = 1;
5316
5317 message[0] = '[';
5318 message[1] = 0;
5319 while (*seq)
5320 {
5321 get_event_details(WSAGETSELECTEVENT(*seq), NULL, name);
5322 len += sprintf(message + len, "%s(%d) ", name, WSAGETSELECTERROR(*seq));
5323 seq++;
5324 }
5325 if (len > 1) len--;
5326 strcpy( message + len, "]" );
5327 return message;
5328 }
5329
5330 static char *dbgstr_event_seq_result(SOCKET s, WSANETWORKEVENTS *netEvents)
5331 {
5332 static char message[1024];
5333 struct async_message *curr = messages_received;
5334 int index, error, bit = 0;
5335 char name[12];
5336 int len = 1;
5337
5338 message[0] = '[';
5339 message[1] = 0;
5340 while (1)
5341 {
5342 if (netEvents)
5343 {
5344 if (bit >= FD_MAX_EVENTS) break;
5345 if ( !(netEvents->lNetworkEvents & (1 << bit)) )
5346 {
5347 bit++;
5348 continue;
5349 }
5350 get_event_details(1 << bit, &index, name);
5351 error = netEvents->iErrorCode[index];
5352 bit++;
5353 }
5354 else
5355 {
5356 if (!curr) break;
5357 if (curr->socket != s)
5358 {
5359 curr = curr->next;
5360 continue;
5361 }
5362 get_event_details(WSAGETSELECTEVENT(curr->lparam), NULL, name);
5363 error = WSAGETSELECTERROR(curr->lparam);
5364 curr = curr->next;
5365 }
5366
5367 len += sprintf(message + len, "%s(%d) ", name, error);
5368 }
5369 if (len > 1) len--;
5370 strcpy( message + len, "]" );
5371 return message;
5372 }
5373
5374 static void flush_events(SOCKET s, HANDLE hEvent)
5375 {
5376 WSANETWORKEVENTS netEvents;
5377 struct async_message *prev = NULL, *curr = messages_received;
5378 int ret;
5379 DWORD dwRet;
5380
5381 if (hEvent != INVALID_HANDLE_VALUE)
5382 {
5383 dwRet = WaitForSingleObject(hEvent, 100);
5384 if (dwRet == WAIT_OBJECT_0)
5385 {
5386 ret = WSAEnumNetworkEvents(s, hEvent, &netEvents);
5387 if (ret)
5388 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
5389 }
5390 }
5391 else
5392 {
5393 while (curr)
5394 {
5395 if (curr->socket == s)
5396 {
5397 if (prev) prev->next = curr->next;
5398 else messages_received = curr->next;
5399
5400 HeapFree(GetProcessHeap(), 0, curr);
5401
5402 if (prev) curr = prev->next;
5403 else curr = messages_received;
5404 }
5405 else
5406 {
5407 prev = curr;
5408 curr = curr->next;
5409 }
5410 }
5411 }
5412 }
5413
5414 static int match_event_sequence(SOCKET s, WSANETWORKEVENTS *netEvents, const LPARAM *seq)
5415 {
5416 int event, index, error, events;
5417 struct async_message *curr;
5418
5419 if (netEvents)
5420 {
5421 events = netEvents->lNetworkEvents;
5422 while (*seq)
5423 {
5424 event = WSAGETSELECTEVENT(*seq);
5425 error = WSAGETSELECTERROR(*seq);
5426 get_event_details(event, &index, NULL);
5427
5428 if (!(events & event) && index != -1)
5429 return 0;
5430 if (events & event && index != -1)
5431 {
5432 if (netEvents->iErrorCode[index] != error)
5433 return 0;
5434 }
5435 events &= ~event;
5436 seq++;
5437 }
5438 if (events)
5439 return 0;
5440 }
5441 else
5442 {
5443 curr = messages_received;
5444 while (curr)
5445 {
5446 if (curr->socket == s)
5447 {
5448 if (!*seq) return 0;
5449 if (*seq != curr->lparam) return 0;
5450 seq++;
5451 }
5452 curr = curr->next;
5453 }
5454 if (*seq)
5455 return 0;
5456 }
5457 return 1;
5458 }
5459
5460 /* checks for a sequence of events, (order only checked if window is used) */
5461 static void ok_event_sequence(SOCKET s, HANDLE hEvent, const LPARAM *seq, const LPARAM **broken_seqs, int completelyBroken)
5462 {
5463 MSG msg;
5464 WSANETWORKEVENTS events, *netEvents = NULL;
5465 int ret;
5466 DWORD dwRet;
5467
5468 if (hEvent != INVALID_HANDLE_VALUE)
5469 {
5470 netEvents = &events;
5471
5472 dwRet = WaitForSingleObject(hEvent, 200);
5473 if (dwRet == WAIT_OBJECT_0)
5474 {
5475 ret = WSAEnumNetworkEvents(s, hEvent, netEvents);
5476 if (ret)
5477 {
5478 winetest_ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
5479 return;
5480 }
5481 }
5482 else
5483 memset(netEvents, 0, sizeof(*netEvents));
5484 }
5485 else
5486 {
5487 Sleep(200);
5488 /* Run the message loop a little */
5489 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
5490 {
5491 DispatchMessageA(&msg);
5492 }
5493 }
5494
5495 if (match_event_sequence(s, netEvents, seq))
5496 {
5497 winetest_ok(1, "Sequence matches expected: %s\n", dbgstr_event_seq(seq));
5498 flush_events(s, hEvent);
5499 return;
5500 }
5501
5502 if (broken_seqs)
5503 {
5504 for (; *broken_seqs; broken_seqs++)
5505 {
5506 if (match_event_sequence(s, netEvents, *broken_seqs))
5507 {
5508 winetest_ok(broken(1), "Sequence matches broken: %s, expected %s\n", dbgstr_event_seq_result(s, netEvents), dbgstr_event_seq(seq));
5509 flush_events(s, hEvent);
5510 return;
5511 }
5512 }
5513 }
5514
5515 winetest_ok(broken(completelyBroken), "Expected event sequence %s, got %s\n", dbgstr_event_seq(seq),
5516 dbgstr_event_seq_result(s, netEvents));
5517 flush_events(s, hEvent);
5518 }
5519
5520 #define ok_event_seq (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : ok_event_sequence
5521
5522 static void test_events(int useMessages)
5523 {
5524 SOCKET server = INVALID_SOCKET;
5525 SOCKET src = INVALID_SOCKET, src2 = INVALID_SOCKET;
5526 SOCKET dst = INVALID_SOCKET, dst2 = INVALID_SOCKET;
5527 struct sockaddr_in addr;
5528 HANDLE hThread = NULL;
5529 HANDLE hEvent = INVALID_HANDLE_VALUE, hEvent2 = INVALID_HANDLE_VALUE;
5530 WNDCLASSEXA wndclass;
5531 HWND hWnd = NULL;
5532 char *buffer = NULL;
5533 int bufferSize = 1024*1024;
5534 WSABUF bufs;
5535 OVERLAPPED ov, ov2;
5536 DWORD flags = 0;
5537 DWORD bytesReturned;
5538 DWORD id;
5539 int len;
5540 int ret;
5541 DWORD dwRet;
5542 BOOL bret;
5543 static char szClassName[] = "wstestclass";
5544 const LPARAM *broken_seq[3];
5545 static const LPARAM empty_seq[] = { 0 };
5546 static const LPARAM close_seq[] = { WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
5547 static const LPARAM write_seq[] = { WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5548 static const LPARAM read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0), 0 };
5549 static const LPARAM oob_seq[] = { WSAMAKESELECTREPLY(FD_OOB, 0), 0 };
5550 static const LPARAM connect_seq[] = { WSAMAKESELECTREPLY(FD_CONNECT, 0),
5551 WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5552 static const LPARAM read_read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5553 WSAMAKESELECTREPLY(FD_READ, 0), 0 };
5554 static const LPARAM read_write_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5555 WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5556 static const LPARAM read_close_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5557 WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
5558
5559 memset(&ov, 0, sizeof(ov));
5560 memset(&ov2, 0, sizeof(ov2));
5561
5562 /* don't use socketpair, we want connection event */
5563 src = socket(AF_INET, SOCK_STREAM, 0);
5564 if (src == INVALID_SOCKET)
5565 {
5566 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5567 goto end;
5568 }
5569
5570 ret = set_blocking(src, TRUE);
5571 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5572
5573 src2 = socket(AF_INET, SOCK_STREAM, 0);
5574 if (src2 == INVALID_SOCKET)
5575 {
5576 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5577 goto end;
5578 }
5579
5580 ret = set_blocking(src2, TRUE);
5581 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5582
5583 len = sizeof(BOOL);
5584 if (getsockopt(src, SOL_SOCKET, SO_OOBINLINE, (void *)&bret, &len) == SOCKET_ERROR)
5585 {
5586 ok(0, "failed to get oobinline status, %d\n", GetLastError());
5587 goto end;
5588 }
5589 ok(bret == FALSE, "OOB not inline\n");
5590
5591 if (useMessages)
5592 {
5593 trace("Event test using messages\n");
5594
5595 wndclass.cbSize = sizeof(wndclass);
5596 wndclass.style = CS_HREDRAW | CS_VREDRAW;
5597 wndclass.lpfnWndProc = ws2_test_WndProc;
5598 wndclass.cbClsExtra = 0;
5599 wndclass.cbWndExtra = 0;
5600 wndclass.hInstance = GetModuleHandleA(NULL);
5601 wndclass.hIcon = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
5602 wndclass.hIconSm = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
5603 wndclass.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
5604 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
5605 wndclass.lpszClassName = szClassName;
5606 wndclass.lpszMenuName = NULL;
5607 RegisterClassExA(&wndclass);
5608
5609 hWnd = CreateWindowA(szClassName, "WS2Test", WS_OVERLAPPEDWINDOW,
5610 0, 0, 500, 500, NULL, NULL, GetModuleHandleA(NULL), NULL);
5611 if (!hWnd)
5612 {
5613 ok(0, "failed to create window: %d\n", GetLastError());
5614 return;
5615 }
5616
5617 ret = WSAAsyncSelect(src, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5618 if (ret)
5619 {
5620 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5621 goto end;
5622 }
5623
5624 ok(set_blocking(src, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5625 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5626
5627 ret = WSAAsyncSelect(src2, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5628 if (ret)
5629 {
5630 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5631 goto end;
5632 }
5633
5634 ok(set_blocking(src2, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5635 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5636 }
5637 else
5638 {
5639 trace("Event test using events\n");
5640
5641 hEvent = WSACreateEvent();
5642 if (hEvent == INVALID_HANDLE_VALUE)
5643 {
5644 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5645 goto end;
5646 }
5647
5648 hEvent2 = WSACreateEvent();
5649 if (hEvent2 == INVALID_HANDLE_VALUE)
5650 {
5651 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5652 goto end;
5653 }
5654
5655 ret = WSAEventSelect(src, hEvent, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5656 if (ret)
5657 {
5658 ok(0, "WSAEventSelect failed, error %d\n", ret);
5659 goto end;
5660 }
5661
5662 ok(set_blocking(src, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5663 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5664
5665 ret = WSAEventSelect(src2, hEvent2, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5666 if (ret)
5667 {
5668 ok(0, "WSAEventSelect failed, error %d\n", ret);
5669 goto end;
5670 }
5671
5672 ok(set_blocking(src2, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5673 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5674 }
5675
5676 server = socket(AF_INET, SOCK_STREAM, 0);
5677 if (server == INVALID_SOCKET)
5678 {
5679 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5680 goto end;
5681 }
5682
5683 memset(&addr, 0, sizeof(addr));
5684 addr.sin_family = AF_INET;
5685 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
5686 ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
5687 if (ret != 0)
5688 {
5689 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5690 goto end;
5691 }
5692
5693 len = sizeof(addr);
5694 ret = getsockname(server, (struct sockaddr*)&addr, &len);
5695 if (ret != 0)
5696 {
5697 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5698 goto end;
5699 }
5700
5701 ret = listen(server, 2);
5702 if (ret != 0)
5703 {
5704 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5705 goto end;
5706 }
5707
5708 ret = connect(src, (struct sockaddr*)&addr, sizeof(addr));
5709 if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
5710 {
5711 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5712 goto end;
5713 }
5714
5715 ret = connect(src2, (struct sockaddr*)&addr, sizeof(addr));
5716 if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
5717 {
5718 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5719 goto end;
5720 }
5721
5722 len = sizeof(addr);
5723 dst = accept(server, (struct sockaddr*)&addr, &len);
5724 if (dst == INVALID_SOCKET)
5725 {
5726 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5727 goto end;
5728 }
5729
5730 len = sizeof(addr);
5731 dst2 = accept(server, (struct sockaddr*)&addr, &len);
5732 if (dst2 == INVALID_SOCKET)
5733 {
5734 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5735 goto end;
5736 }
5737
5738 closesocket(server);
5739 server = INVALID_SOCKET;
5740
5741 /* On Windows it seems when a non-blocking socket sends to a
5742 blocking socket on the same host, the send() is BLOCKING,
5743 so make both sockets non-blocking. src is already non-blocking
5744 from the async select */
5745
5746 if (set_blocking(dst, FALSE))
5747 {
5748 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
5749 goto end;
5750 }
5751
5752 buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bufferSize);
5753 if (buffer == NULL)
5754 {
5755 ok(0, "could not allocate memory for test\n");
5756 goto end;
5757 }
5758
5759 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5760 if (ov.hEvent == NULL)
5761 {
5762 ok(0, "could not create event object, errno = %d\n", GetLastError());
5763 goto end;
5764 }
5765
5766 ov2.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5767 if (ov2.hEvent == NULL)
5768 {
5769 ok(0, "could not create event object, errno = %d\n", GetLastError());
5770 goto end;
5771 }
5772
5773 /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
5774 ok_event_seq(src, hEvent, connect_seq, NULL, 1);
5775 ok_event_seq(src2, hEvent2, connect_seq, NULL, 1);
5776 /* broken on all windows - FD_CONNECT error is garbage */
5777
5778 /* Test simple send/recv */
5779 SetLastError(0xdeadbeef);
5780 ret = send(dst, buffer, 100, 0);
5781 ok(ret == 100, "Failed to send buffer %d err %d\n", ret, GetLastError());
5782 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5783 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5784
5785 SetLastError(0xdeadbeef);
5786 ret = recv(src, buffer, 1, MSG_PEEK);
5787 ok(ret == 1, "Failed to peek at recv buffer %d err %d\n", ret, GetLastError());
5788 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5789 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5790
5791 SetLastError(0xdeadbeef);
5792 ret = recv(src, buffer, 50, 0);
5793 ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
5794 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5795 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5796
5797 ret = recv(src, buffer, 50, 0);
5798 ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
5799 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5800
5801 /* fun fact - events are re-enabled even on failure, but only for messages */
5802 ret = send(dst, "1", 1, 0);
5803 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
5804 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5805
5806 ret = recv(src, buffer, -1, 0);
5807 ok(ret == SOCKET_ERROR && (GetLastError() == WSAEFAULT || GetLastError() == WSAENOBUFS),
5808 "Failed to recv buffer %d err %d\n", ret, GetLastError());
5809 if (useMessages)
5810 {
5811 broken_seq[0] = empty_seq; /* win9x */
5812 broken_seq[1] = NULL;
5813 todo_wine ok_event_seq(src, hEvent, read_seq, broken_seq, 0);
5814 }
5815 else
5816 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5817
5818 SetLastError(0xdeadbeef);
5819 ret = recv(src, buffer, 1, 0);
5820 ok(ret == 1, "Failed to recv buffer %d err %d\n", ret, GetLastError());
5821 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5822 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5823
5824 /* Interaction with overlapped */
5825 bufs.len = sizeof(char);
5826 bufs.buf = buffer;
5827 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
5828 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
5829 "WSARecv failed - %d error %d\n", ret, GetLastError());
5830
5831 bufs.len = sizeof(char);
5832 bufs.buf = buffer+1;
5833 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov2, NULL);
5834 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
5835 "WSARecv failed - %d error %d\n", ret, GetLastError());
5836
5837 ret = send(dst, "12", 2, 0);
5838 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
5839 broken_seq[0] = read_read_seq; /* win9x */
5840 broken_seq[1] = NULL;
5841 ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
5842
5843 dwRet = WaitForSingleObject(ov.hEvent, 100);
5844 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
5845 if (dwRet == WAIT_OBJECT_0)
5846 {
5847 bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
5848 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
5849 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
5850 ok(buffer[0] == '1', "Got %c instead of 1\n", buffer[0]);
5851 }
5852
5853 dwRet = WaitForSingleObject(ov2.hEvent, 100);
5854 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
5855 if (dwRet == WAIT_OBJECT_0)
5856 {
5857 bret = GetOverlappedResult((HANDLE)src, &ov2, &bytesReturned, FALSE);
5858 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
5859 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
5860 ok(buffer[1] == '2', "Got %c instead of 2\n", buffer[1]);
5861 }
5862
5863 SetLastError(0xdeadbeef);
5864 ret = send(dst, "1", 1, 0);
5865 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
5866 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5867 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5868
5869 ret = recv(src, buffer, 1, 0);
5870 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5871 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5872
5873 /* Notifications are delivered as soon as possible, blocked only on
5874 * async requests on the same type */
5875 bufs.len = sizeof(char);
5876 bufs.buf = buffer;
5877 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
5878 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
5879 "WSARecv failed - %d error %d\n", ret, GetLastError());
5880
5881 if (0) {
5882 ret = send(dst, "1", 1, MSG_OOB);
5883 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
5884 ok_event_seq(src, hEvent, oob_seq, NULL, 0);
5885 }
5886
5887 dwRet = WaitForSingleObject(ov.hEvent, 100);
5888 ok(dwRet == WAIT_TIMEOUT, "OOB message activated read?: %d - %d\n", dwRet, GetLastError());
5889
5890 ret = send(dst, "2", 1, 0);
5891 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
5892 broken_seq[0] = read_seq; /* win98 */
5893 broken_seq[1] = NULL;
5894 ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
5895
5896 dwRet = WaitForSingleObject(ov.hEvent, 100);
5897 ok(dwRet == WAIT_OBJECT_0 || broken(dwRet == WAIT_TIMEOUT),
5898 "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
5899 if (dwRet == WAIT_OBJECT_0)
5900 {
5901 bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
5902 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
5903 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
5904 ok(buffer[0] == '2', "Got %c instead of 2\n", buffer[0]);
5905 }
5906 else if (dwRet == WAIT_TIMEOUT)
5907 {
5908 /* this happens on win98. We get an FD_READ later on the next test */
5909 CancelIo((HANDLE) src);
5910 }
5911
5912 if (0) {
5913 ret = recv(src, buffer, 1, MSG_OOB);
5914 todo_wine ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5915 /* We get OOB notification, but no data on wine */
5916 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5917 }
5918
5919 /* Flood the send queue */
5920 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
5921 if (hThread == NULL)
5922 {
5923 ok(0, "CreateThread failed, error %d\n", GetLastError());
5924 goto end;
5925 }
5926
5927 /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
5928 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5929
5930 /* Now if we send a ton of data and the 'server' does not drain it fast
5931 * enough (set drain_pause to be sure), the socket send buffer will only
5932 * take some of it, and we will get a short write. This will trigger
5933 * another FD_WRITE event as soon as data is sent and more space becomes
5934 * available, but not any earlier. */
5935 drain_pause = TRUE;
5936 do
5937 {
5938 ret = send(src, buffer, bufferSize, 0);
5939 } while (ret == bufferSize);
5940 drain_pause = FALSE;
5941 if (ret >= 0 || WSAGetLastError() == WSAEWOULDBLOCK)
5942 {
5943 Sleep(400); /* win9x */
5944 broken_seq[0] = read_write_seq;
5945 broken_seq[1] = NULL;
5946 ok_event_seq(src, hEvent, write_seq, broken_seq, 0);
5947 }
5948 else
5949 {
5950 ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
5951 }
5952
5953 /* Test how FD_CLOSE is handled */
5954 ret = send(dst, "12", 2, 0);
5955 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
5956
5957 /* Wait a little and let the send complete */
5958 Sleep(100);
5959 closesocket(dst);
5960 dst = INVALID_SOCKET;
5961 Sleep(100);
5962
5963 /* We can never implement this in wine, best we can hope for is
5964 sending FD_CLOSE after the reads complete */
5965 broken_seq[0] = read_seq; /* win9x */
5966 broken_seq[1] = NULL;
5967 todo_wine ok_event_seq(src, hEvent, read_close_seq, broken_seq, 0);
5968
5969 ret = recv(src, buffer, 1, 0);
5970 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5971 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5972
5973 ret = recv(src, buffer, 1, 0);
5974 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5975 /* want it? it's here, but you can't have it */
5976 broken_seq[0] = close_seq; /* win9x */
5977 broken_seq[1] = NULL;
5978 todo_wine ok_event_seq(src, hEvent, empty_seq, /* wine sends FD_CLOSE here */
5979 broken_seq, 0);
5980
5981 /* Test how FD_CLOSE is handled */
5982 ret = send(dst2, "12", 2, 0);
5983 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
5984
5985 Sleep(200);
5986 shutdown(dst2, SD_SEND);
5987 Sleep(200);
5988
5989 /* Some of the below are technically todo_wine, but our event sequence is still valid, so to prevent
5990 regressions, don't mark them as todo_wine, and mark windows as broken */
5991 broken_seq[0] = read_close_seq;
5992 broken_seq[1] = close_seq;
5993 broken_seq[2] = NULL;
5994 ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
5995
5996 ret = recv(src2, buffer, 1, 0);
5997 ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5998 broken_seq[0] = close_seq; /* win98 */
5999 broken_seq[1] = NULL;
6000 ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
6001
6002 ret = recv(src2, buffer, 1, 0);
6003 ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
6004 broken_seq[0] = empty_seq;
6005 broken_seq[1] = NULL;
6006 ok_event_seq(src2, hEvent2, close_seq, broken_seq, 0);
6007
6008 ret = send(src2, "1", 1, 0);
6009 ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
6010 ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
6011
6012 ret = send(src2, "1", 1, 0);
6013 ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
6014 ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
6015
6016 if (useMessages)
6017 {
6018 ret = WSAAsyncSelect(src, hWnd, WM_SOCKET, 0);
6019 if (ret)
6020 {
6021 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
6022 goto end;
6023 }
6024
6025 ret = set_blocking(src, TRUE);
6026 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
6027
6028 ret = WSAAsyncSelect(src2, hWnd, WM_SOCKET, 0);
6029 if (ret)
6030 {
6031 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
6032 goto end;
6033 }
6034
6035 ret = set_blocking(src2, TRUE);
6036 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
6037 }
6038 else
6039 {
6040 ret = WSAEventSelect(src, hEvent2, 0);
6041 if (ret)
6042 {
6043 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
6044 goto end;
6045 }
6046
6047 ret = set_blocking(src, TRUE);
6048 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
6049
6050 ret = WSAEventSelect(src2, hEvent2, 0);
6051 if (ret)
6052 {
6053 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
6054 goto end;
6055 }
6056
6057 ret = set_blocking(src2, TRUE);
6058 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
6059 }
6060
6061 end:
6062 if (src != INVALID_SOCKET)
6063 {
6064 flush_events(src, hEvent);
6065 closesocket(src);
6066 }
6067 if (src2 != INVALID_SOCKET)
6068 {
6069 flush_events(src2, hEvent2);
6070 closesocket(src2);
6071 }
6072 HeapFree(GetProcessHeap(), 0, buffer);
6073 if (server != INVALID_SOCKET)
6074 closesocket(server);
6075 if (dst != INVALID_SOCKET)
6076 closesocket(dst);
6077 if (dst2 != INVALID_SOCKET)
6078 closesocket(dst2);
6079 if (hThread != NULL)
6080 CloseHandle(hThread);
6081 if (hWnd != NULL)
6082 DestroyWindow(hWnd);
6083 if (hEvent != NULL)
6084 CloseHandle(hEvent);
6085 if (hEvent2 != NULL)
6086 CloseHandle(hEvent2);
6087 if (ov.hEvent != NULL)
6088 CloseHandle(ov.hEvent);
6089 if (ov2.hEvent != NULL)
6090 CloseHandle(ov2.hEvent);
6091 }
6092
6093 static void test_ipv6only(void)
6094 {
6095 SOCKET v4 = INVALID_SOCKET,
6096 v6 = INVALID_SOCKET;
6097 struct sockaddr_in sin4;
6098 struct sockaddr_in6 sin6;
6099 int ret;
6100
6101 memset(&sin4, 0, sizeof(sin4));
6102 sin4.sin_family = AF_INET;
6103 sin4.sin_port = htons(SERVERPORT);
6104
6105 memset(&sin6, 0, sizeof(sin6));
6106 sin6.sin6_family = AF_INET6;
6107 sin6.sin6_port = htons(SERVERPORT);
6108
6109 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
6110 if (v6 == INVALID_SOCKET) {
6111 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
6112 WSAGetLastError(), WSAEAFNOSUPPORT);
6113 goto end;
6114 }
6115 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
6116 if (ret) {
6117 skip("Could not bind IPv6 address (LastError: %d).\n",
6118 WSAGetLastError());
6119 goto end;
6120 }
6121
6122 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6123 if (v4 == INVALID_SOCKET) {
6124 skip("Could not create IPv4 socket (LastError: %d).\n",
6125 WSAGetLastError());
6126 goto end;
6127 }
6128 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
6129 ok(!ret, "Could not bind IPv4 address (LastError: %d; %d expected if IPv6 binds to IPv4 as well).\n",
6130 WSAGetLastError(), WSAEADDRINUSE);
6131
6132 end:
6133 if (v4 != INVALID_SOCKET)
6134 closesocket(v4);
6135 if (v6 != INVALID_SOCKET)
6136 closesocket(v6);
6137 }
6138
6139 static void test_WSASendMsg(void)
6140 {
6141 SOCKET sock, dst;
6142 struct sockaddr_in sendaddr, sockaddr;
6143 GUID WSASendMsg_GUID = WSAID_WSASENDMSG;
6144 LPFN_WSASENDMSG pWSASendMsg = NULL;
6145 char teststr[12] = "hello world", buffer[32];
6146 WSABUF iovec[2];
6147 WSAMSG msg;
6148 DWORD bytesSent, err;
6149 int ret, addrlen;
6150
6151 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
6152
6153 sock = socket(AF_INET, SOCK_DGRAM, 0);
6154 ok(sock != INVALID_SOCKET, "socket() failed\n");
6155
6156 /* Obtain the WSASendMsg function */
6157 WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSASendMsg_GUID, sizeof(WSASendMsg_GUID),
6158 &pWSASendMsg, sizeof(pWSASendMsg), &err, NULL, NULL);
6159 if (!pWSASendMsg)
6160 {
6161 closesocket(sock);
6162 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
6163 return;
6164 }
6165
6166 /* fake address for now */
6167 sendaddr.sin_family = AF_INET;
6168 sendaddr.sin_port = htons(139);
6169 sendaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6170
6171 memset(&msg, 0, sizeof(msg));
6172 iovec[0].buf = teststr;
6173 iovec[0].len = sizeof(teststr);
6174 iovec[1].buf = teststr;
6175 iovec[1].len = sizeof(teststr) / 2;
6176 msg.name = (struct sockaddr *) &sendaddr;
6177 msg.namelen = sizeof(sendaddr);
6178 msg.lpBuffers = iovec;
6179 msg.dwBufferCount = 1; /* send only one buffer for now */
6180
6181 WSASetLastError(0xdeadbeef);
6182 ret = pWSASendMsg(INVALID_SOCKET, &msg, 0, NULL, NULL, NULL);
6183 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6184 err = WSAGetLastError();
6185 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
6186
6187 WSASetLastError(0xdeadbeef);
6188 ret = pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL);
6189 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6190 err = WSAGetLastError();
6191 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
6192
6193 WSASetLastError(0xdeadbeef);
6194 ret = pWSASendMsg(sock, NULL, 0, &bytesSent, NULL, NULL);
6195 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6196 err = WSAGetLastError();
6197 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
6198
6199 WSASetLastError(0xdeadbeef);
6200 ret = pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL);
6201 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6202 err = WSAGetLastError();
6203 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
6204
6205 closesocket(sock);
6206
6207 sock = socket(AF_INET, SOCK_DGRAM, 0);
6208 ok(sock != INVALID_SOCKET, "socket() failed\n");
6209
6210 dst = socket(AF_INET, SOCK_DGRAM, 0);
6211 ok(dst != INVALID_SOCKET, "socket() failed\n");
6212
6213 memset(&sockaddr, 0, sizeof(sockaddr));
6214 sockaddr.sin_family = AF_INET;
6215 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6216 ok(!bind(dst, (struct sockaddr*)&sockaddr, sizeof(sockaddr)),
6217 "bind should have worked\n");
6218
6219 /* read address to find out the port number to be used in send */
6220 memset(&sendaddr, 0, sizeof(sendaddr));
6221 addrlen = sizeof(sendaddr);
6222 ok(!getsockname(dst, (struct sockaddr *) &sendaddr, &addrlen),
6223 "getsockname should have worked\n");
6224 ok(sendaddr.sin_port, "socket port should be != 0\n");
6225
6226 /* ensure the sending socket is not bound */
6227 WSASetLastError(0xdeadbeef);
6228 addrlen = sizeof(sockaddr);
6229 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
6230 ok(ret == SOCKET_ERROR, "getsockname should have failed\n");
6231 err = WSAGetLastError();
6232 ok(err == WSAEINVAL, "expected 10022, got %d instead\n", err);
6233
6234 set_blocking(sock, TRUE);
6235
6236 bytesSent = 0;
6237 SetLastError(0xdeadbeef);
6238 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
6239 ok(!ret, "WSASendMsg should have worked\n");
6240 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
6241 "Expected 0, got %d\n", GetLastError());
6242 ok(bytesSent == iovec[0].len, "incorret bytes sent, expected %d, sent %d\n",
6243 iovec[0].len, bytesSent);
6244
6245 /* receive data */
6246 addrlen = sizeof(sockaddr);
6247 memset(buffer, 0, sizeof(buffer));
6248 SetLastError(0xdeadbeef);
6249 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
6250 ok(ret == bytesSent, "got %d, expected %d\n",
6251 ret, bytesSent);
6252 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6253
6254 /* A successful call to WSASendMsg must have bound the socket */
6255 addrlen = sizeof(sockaddr);
6256 sockaddr.sin_port = 0;
6257 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6258 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
6259 ok(!ret, "getsockname should have worked\n");
6260 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
6261 inet_ntoa(sockaddr.sin_addr));
6262 ok(sockaddr.sin_port, "sin_port should be != 0\n");
6263
6264 msg.dwBufferCount = 2; /* send both buffers */
6265
6266 bytesSent = 0;
6267 SetLastError(0xdeadbeef);
6268 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
6269 ok(!ret, "WSASendMsg should have worked\n");
6270 ok(bytesSent == iovec[0].len + iovec[1].len, "incorret bytes sent, expected %d, sent %d\n",
6271 iovec[0].len + iovec[1].len, bytesSent);
6272 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
6273 "Expected 0, got %d\n", GetLastError());
6274
6275 /* receive data */
6276 addrlen = sizeof(sockaddr);
6277 memset(buffer, 0, sizeof(buffer));
6278 SetLastError(0xdeadbeef);
6279 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
6280 ok(ret == bytesSent, "got %d, expected %d\n",
6281 ret, bytesSent);
6282 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6283
6284 closesocket(sock);
6285 closesocket(dst);
6286
6287 /* a bad call to WSASendMsg will also bind the socket */
6288 addrlen = sizeof(sockaddr);
6289 sockaddr.sin_port = 0;
6290 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6291 sock = socket(AF_INET, SOCK_DGRAM, 0);
6292 ok(sock != INVALID_SOCKET, "socket() failed\n");
6293 ok(pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
6294 todo_wine {
6295 ok(!getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have worked\n");
6296 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
6297 inet_ntoa(sockaddr.sin_addr));
6298 ok(sockaddr.sin_port, "sin_port should be > 0\n");
6299 }
6300 closesocket(sock);
6301
6302 /* a bad call without msg parameter will not trigger the auto-bind */
6303 sock = socket(AF_INET, SOCK_DGRAM, 0);
6304 ok(sock != INVALID_SOCKET, "socket() failed\n");
6305 ok(pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
6306 ok(getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have failed\n");
6307 err = WSAGetLastError();
6308 ok(err == WSAEINVAL, "expected 10022, got %d instead\n", err);
6309 closesocket(sock);
6310
6311 /* SOCK_STREAM sockets are not supported */
6312 bytesSent = 0;
6313 sock = socket(AF_INET, SOCK_STREAM, 0);
6314 ok(sock != INVALID_SOCKET, "socket() failed\n");
6315 SetLastError(0xdeadbeef);
6316 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
6317 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6318 err = WSAGetLastError();
6319 todo_wine
6320 ok(err == WSAEINVAL, "expected 10014, got %d instead\n", err);
6321 closesocket(sock);
6322 }
6323
6324 static void test_WSASendTo(void)
6325 {
6326 SOCKET s;
6327 struct sockaddr_in addr;
6328 char buf[12] = "hello world";
6329 WSABUF data_buf;
6330 DWORD bytesSent;
6331 int ret;
6332
6333 addr.sin_family = AF_INET;
6334 addr.sin_port = htons(139);
6335 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
6336 data_buf.len = sizeof(buf);
6337 data_buf.buf = buf;
6338
6339 if( (s = socket(AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET) {
6340 ok(0, "socket() failed error: %d\n", WSAGetLastError());
6341 return;
6342 }
6343
6344 WSASetLastError(12345);
6345 ret = WSASendTo(INVALID_SOCKET, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
6346 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
6347 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
6348
6349 WSASetLastError(12345);
6350 ret = WSASendTo(s, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
6351 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
6352 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
6353
6354 WSASetLastError(12345);
6355 if(WSASendTo(s, &data_buf, 1, &bytesSent, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL)) {
6356 ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
6357 return;
6358 }
6359 ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
6360 "a successful call to WSASendTo()\n");
6361 }
6362
6363 static DWORD WINAPI recv_thread(LPVOID arg)
6364 {
6365 SOCKET sock = *(SOCKET *)arg;
6366 char buffer[32];
6367 WSABUF wsa;
6368 WSAOVERLAPPED ov;
6369 DWORD flags = 0;
6370
6371 wsa.buf = buffer;
6372 wsa.len = sizeof(buffer);
6373 ov.hEvent = WSACreateEvent();
6374 WSARecv(sock, &wsa, 1, NULL, &flags, &ov, NULL);
6375
6376 WaitForSingleObject(ov.hEvent, 1000);
6377 WSACloseEvent(ov.hEvent);
6378 return 0;
6379 }
6380
6381 static void test_WSARecv(void)
6382 {
6383 SOCKET src, dest, server = INVALID_SOCKET;
6384 char buf[20];
6385 WSABUF bufs;
6386 WSAOVERLAPPED ov;
6387 DWORD bytesReturned, flags, id;
6388 struct linger ling;
6389 struct sockaddr_in addr;
6390 int iret, len;
6391 DWORD dwret;
6392 BOOL bret;
6393 HANDLE thread;
6394
6395 tcp_socketpair(&src, &dest);
6396 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
6397 {
6398 skip("failed to create sockets\n");
6399 goto end;
6400 }
6401
6402 memset(&ov, 0, sizeof(ov));
6403 flags = 0;
6404 bufs.len = 2;
6405 bufs.buf = buf;
6406
6407 /* Send 4 bytes and receive in two calls of 2 */
6408 SetLastError(0xdeadbeef);
6409 iret = send(src, "test", 4, 0);
6410 ok(iret == 4, "Expected 4, got %d\n", iret);
6411 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6412 SetLastError(0xdeadbeef);
6413 bytesReturned = 0xdeadbeef;
6414 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, NULL, NULL);
6415 ok(!iret, "Expected 0, got %d\n", iret);
6416 ok(bytesReturned, "Expected 2, got %d\n", bytesReturned);
6417 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6418 SetLastError(0xdeadbeef);
6419 bytesReturned = 0xdeadbeef;
6420 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, NULL, NULL);
6421 ok(!iret, "Expected 0, got %d\n", iret);
6422 ok(bytesReturned, "Expected 2, got %d\n", bytesReturned);
6423 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6424
6425 bufs.len = 4;
6426 SetLastError(0xdeadbeef);
6427 iret = send(src, "test", 4, 0);
6428 ok(iret == 4, "Expected 4, got %d\n", iret);
6429 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6430 SetLastError(0xdeadbeef);
6431 bytesReturned = 0xdeadbeef;
6432 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, NULL, NULL);
6433 ok(!iret, "Expected 0, got %d\n", iret);
6434 ok(bytesReturned, "Expected 4, got %d\n", bytesReturned);
6435 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6436
6437 bufs.len = sizeof(buf);
6438
6439 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
6440 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
6441 if (!ov.hEvent)
6442 goto end;
6443
6444 ling.l_onoff = 1;
6445 ling.l_linger = 0;
6446 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
6447 ok(!iret, "Failed to set linger %d\n", GetLastError());
6448
6449 iret = WSARecv(dest, &bufs, 1, NULL, &flags, &ov, NULL);
6450 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
6451
6452 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
6453 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
6454
6455 closesocket(src);
6456 src = INVALID_SOCKET;
6457
6458 dwret = WaitForSingleObject(ov.hEvent, 1000);
6459 ok(dwret == WAIT_OBJECT_0, "Waiting for disconnect event failed with %d + errno %d\n", dwret, GetLastError());
6460
6461 bret = GetOverlappedResult((HANDLE)dest, &ov, &bytesReturned, FALSE);
6462 todo_wine ok(!bret && (GetLastError() == ERROR_NETNAME_DELETED || broken(GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */),
6463 "Did not get disconnect event: %d, error %d\n", bret, GetLastError());
6464 ok(bytesReturned == 0, "Bytes received is %d\n", bytesReturned);
6465 closesocket(dest);
6466 dest = INVALID_SOCKET;
6467
6468 src = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
6469 ok(src != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6470 if (src == INVALID_SOCKET) goto end;
6471
6472 server = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
6473 ok(server != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6474 if (server == INVALID_SOCKET) goto end;
6475
6476 memset(&addr, 0, sizeof(addr));
6477 addr.sin_family = AF_INET;
6478 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
6479 iret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
6480 if (iret) goto end;
6481
6482 len = sizeof(addr);
6483 iret = getsockname(server, (struct sockaddr *)&addr, &len);
6484 if (iret) goto end;
6485
6486 iret = listen(server, 1);
6487 if (iret) goto end;
6488
6489 iret = connect(src, (struct sockaddr *)&addr, sizeof(addr));
6490 if (iret) goto end;
6491
6492 len = sizeof(addr);
6493 dest = accept(server, (struct sockaddr *)&addr, &len);
6494 ok(dest != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6495 if (dest == INVALID_SOCKET) goto end;
6496
6497 send(src, "test message", sizeof("test message"), 0);
6498 thread = CreateThread(NULL, 0, recv_thread, &dest, 0, &id);
6499 WaitForSingleObject(thread, 3000);
6500 CloseHandle(thread);
6501
6502 end:
6503 if (server != INVALID_SOCKET)
6504 closesocket(server);
6505 if (dest != INVALID_SOCKET)
6506 closesocket(dest);
6507 if (src != INVALID_SOCKET)
6508 closesocket(src);
6509 if (ov.hEvent)
6510 WSACloseEvent(ov.hEvent);
6511 }
6512
6513 #define POLL_CLEAR() ix = 0
6514 #define POLL_SET(s, ev) {fds[ix].fd = s; fds[ix++].events = ev;}
6515 #define POLL_ISSET(s, rev) poll_isset(fds, ix, s, rev)
6516 static BOOL poll_isset(WSAPOLLFD *fds, int max, SOCKET s, int rev)
6517 {
6518 int k;
6519 for (k = 0; k < max; k++)
6520 if (fds[k].fd == s && (fds[k].revents == rev)) return TRUE;
6521 return FALSE;
6522 }
6523
6524 static void test_WSAPoll(void)
6525 {
6526 int ix, ret, err, poll_timeout;
6527 SOCKET fdListen, fdRead, fdWrite;
6528 struct sockaddr_in address;
6529 socklen_t len;
6530 static char tmp_buf[1024];
6531 WSAPOLLFD fds[16];
6532 HANDLE thread_handle;
6533 DWORD id;
6534
6535 if (!pWSAPoll) /* >= Vista */
6536 {
6537 skip("WSAPoll is unsupported, some tests will be skipped.\n");
6538 return;
6539 }
6540
6541 /* Invalid parameters test */
6542 SetLastError(0xdeadbeef);
6543 ret = pWSAPoll(NULL, 0, 0);
6544 err = GetLastError();
6545 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
6546 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
6547 SetLastError(0xdeadbeef);
6548 ret = pWSAPoll(NULL, 1, 0);
6549 err = GetLastError();
6550 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
6551 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
6552 SetLastError(0xdeadbeef);
6553 ret = pWSAPoll(NULL, 0, 1);
6554 err = GetLastError();
6555 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
6556 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
6557 SetLastError(0xdeadbeef);
6558 ret = pWSAPoll(NULL, 1, 1);
6559 err = GetLastError();
6560 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
6561 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
6562
6563 /* WSAPoll() tries to mime the unix poll() call. The following tests do:
6564 * - check if a connection attempt ended with success or error;
6565 * - check if a pending connection is waiting for acceptance;
6566 * - check for data to read, availability for write and OOB data
6567 */
6568 memset(&address, 0, sizeof(address));
6569 address.sin_addr.s_addr = inet_addr("127.0.0.1");
6570 address.sin_family = AF_INET;
6571 len = sizeof(address);
6572 fdListen = setup_server_socket(&address, &len);
6573 poll_timeout = 100;
6574
6575 /* When no events are pending poll returns 0 with no error */
6576 POLL_CLEAR();
6577 POLL_SET(fdListen, POLLIN);
6578 ret = pWSAPoll(fds, ix, poll_timeout);
6579 ok(ret == 0, "expected 0, got %d\n", ret);
6580
6581 /* Test listening socket connection attempt notifications */
6582 fdWrite = setup_connector_socket(&address, len, TRUE);
6583 POLL_CLEAR();
6584 POLL_SET(fdListen, POLLIN | POLLOUT);
6585 ret = pWSAPoll(fds, ix, poll_timeout);
6586 ok(ret == 1, "expected 1, got %d\n", ret);
6587 ok(POLL_ISSET(fdListen, POLLRDNORM), "fdListen socket events incorrect\n");
6588 len = sizeof(address);
6589 fdRead = accept(fdListen, (struct sockaddr*) &address, &len);
6590 ok(fdRead != INVALID_SOCKET, "expected a valid socket\n");
6591
6592 /* Test client side connection attempt notifications */
6593 POLL_CLEAR();
6594 POLL_SET(fdListen, POLLIN | POLLOUT);
6595 POLL_SET(fdRead, POLLIN | POLLOUT);
6596 POLL_SET(fdWrite, POLLIN | POLLOUT);
6597 ret = pWSAPoll(fds, ix, poll_timeout);
6598 ok(ret == 2, "expected 2, got %d\n", ret);
6599 ok(POLL_ISSET(fdWrite, POLLWRNORM), "fdWrite socket events incorrect\n");
6600 ok(POLL_ISSET(fdRead, POLLWRNORM), "fdRead socket events incorrect\n");
6601 len = sizeof(id);
6602 id = 0xdeadbeef;
6603 err = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
6604 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
6605 ok(id == 0, "expected 0, got %d\n", id);
6606
6607 /* Test data receiving notifications */
6608 ret = send(fdWrite, "1234", 4, 0);
6609 ok(ret == 4, "expected 4, got %d\n", ret);
6610 POLL_CLEAR();
6611 POLL_SET(fdListen, POLLIN | POLLOUT);
6612 POLL_SET(fdRead, POLLIN);
6613 ret = pWSAPoll(fds, ix, poll_timeout);
6614 ok(ret == 1, "expected 1, got %d\n", ret);
6615 ok(POLL_ISSET(fdRead, POLLRDNORM), "fdRead socket events incorrect\n");
6616 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
6617 ok(ret == 4, "expected 4, got %d\n", ret);
6618 ok(!strcmp(tmp_buf, "1234"), "data received differs from sent\n");
6619
6620 /* Test OOB data notifications */
6621 ret = send(fdWrite, "A", 1, MSG_OOB);
6622 ok(ret == 1, "expected 1, got %d\n", ret);
6623 POLL_CLEAR();
6624 POLL_SET(fdListen, POLLIN | POLLOUT);
6625 POLL_SET(fdRead, POLLIN);
6626 ret = pWSAPoll(fds, ix, poll_timeout);
6627 ok(ret == 1, "expected 1, got %d\n", ret);
6628 ok(POLL_ISSET(fdRead, POLLRDBAND), "fdRead socket events incorrect\n");
6629 tmp_buf[0] = 0xAF;
6630 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
6631 ok(ret == 1, "expected 1, got %d\n", ret);
6632 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
6633
6634 /* If the socket is OOBINLINED the notification is like normal data */
6635 ret = 1;
6636 ret = setsockopt(fdRead, SOL_SOCKET, SO_OOBINLINE, (char*) &ret, sizeof(ret));
6637 ok(ret == 0, "expected 0, got %d\n", ret);
6638 ret = send(fdWrite, "A", 1, MSG_OOB);
6639 ok(ret == 1, "expected 1, got %d\n", ret);
6640 POLL_CLEAR();
6641 POLL_SET(fdListen, POLLIN | POLLOUT);
6642 POLL_SET(fdRead, POLLIN | POLLOUT);
6643 ret = pWSAPoll(fds, ix, poll_timeout);
6644 ok(ret == 1, "expected 1, got %d\n", ret);
6645 tmp_buf[0] = 0xAF;
6646 SetLastError(0xdeadbeef);
6647 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
6648 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
6649 ok(GetLastError() == WSAEINVAL, "expected 10022, got %d\n", GetLastError());
6650 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
6651 ok(ret == 1, "expected 1, got %d\n", ret);
6652 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
6653
6654 /* Test connection closed notifications */
6655 ret = closesocket(fdRead);
6656 ok(ret == 0, "expected 0, got %d\n", ret);
6657 POLL_CLEAR();
6658 POLL_SET(fdListen, POLLIN | POLLOUT);
6659 POLL_SET(fdWrite, POLLIN);
6660 ret = pWSAPoll(fds, ix, poll_timeout);
6661 ok(ret == 1, "expected 1, got %d\n", ret);
6662 todo_wine
6663 ok(POLL_ISSET(fdWrite, POLLHUP), "fdWrite socket events incorrect\n");
6664 ret = recv(fdWrite, tmp_buf, sizeof(tmp_buf), 0);
6665 ok(ret == 0, "expected 0, got %d\n", ret);
6666
6667 /* When a connection is attempted to a non-listening socket due to a bug
6668 * in the MS code it will never be notified. This is a long standing issue
6669 * that will never be fixed for compatibility reasons so we have to deal
6670 * with it manually. */
6671 ret = closesocket(fdWrite);
6672 ok(ret == 0, "expected 0, got %d\n", ret);
6673 ret = closesocket(fdListen);
6674 ok(ret == 0, "expected 0, got %d\n", ret);
6675 len = sizeof(address);
6676 fdWrite = setup_connector_socket(&address, len, TRUE);
6677 POLL_CLEAR();
6678 POLL_SET(fdWrite, POLLIN | POLLOUT);
6679 poll_timeout = 2000;
6680 ret = pWSAPoll(fds, ix, poll_timeout);
6681 todo_wine
6682 ok(ret == 0, "expected 0, got %d\n", ret);
6683 len = sizeof(id);
6684 id = 0xdeadbeef;
6685 err = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
6686 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
6687 ok(id == WSAECONNREFUSED, "expected 10061, got %d\n", id);
6688 closesocket(fdWrite);
6689
6690 /* Try poll() on a closed socket after connection */
6691 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
6692 closesocket(fdRead);
6693 POLL_CLEAR();
6694 POLL_SET(fdWrite, POLLIN | POLLOUT);
6695 POLL_SET(fdRead, POLLIN | POLLOUT);
6696 ret = pWSAPoll(fds, ix, poll_timeout);
6697 ok(ret == 1, "expected 1, got %d\n", ret);
6698 ok(POLL_ISSET(fdRead, POLLNVAL), "fdRead socket events incorrect\n");
6699 POLL_CLEAR();
6700 POLL_SET(fdWrite, POLLIN | POLLOUT);
6701 ret = pWSAPoll(fds, ix, poll_timeout);
6702 ok(ret == 1, "expected 1, got %d\n", ret);
6703 todo_wine
6704 ok(POLL_ISSET(fdWrite, POLLWRNORM | POLLHUP) || broken(POLL_ISSET(fdWrite, POLLWRNORM)) /* <= 2008 */,
6705 "fdWrite socket events incorrect\n");
6706 closesocket(fdWrite);
6707
6708 /* Close the socket currently being polled in a thread */
6709 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
6710 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
6711 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
6712 POLL_CLEAR();
6713 POLL_SET(fdWrite, POLLIN | POLLOUT);
6714 ret = pWSAPoll(fds, ix, poll_timeout);
6715 ok(ret == 1, "expected 1, got %d\n", ret);
6716 ok(POLL_ISSET(fdWrite, POLLWRNORM), "fdWrite socket events incorrect\n");
6717 WaitForSingleObject (thread_handle, 1000);
6718 closesocket(fdRead);
6719 /* test again with less flags - behavior changes */
6720 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
6721 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
6722 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
6723 POLL_CLEAR();
6724 POLL_SET(fdWrite, POLLIN);
6725 ret = pWSAPoll(fds, ix, poll_timeout);
6726 ok(ret == 1, "expected 1, got %d\n", ret);
6727 todo_wine
6728 ok(POLL_ISSET(fdWrite, POLLNVAL), "fdWrite socket events incorrect\n");
6729 WaitForSingleObject (thread_handle, 1000);
6730 closesocket(fdRead);
6731 }
6732 #undef POLL_SET
6733 #undef POLL_ISSET
6734 #undef POLL_CLEAR
6735
6736 static void test_GetAddrInfoW(void)
6737 {
6738 static const WCHAR port[] = {'8','0',0};
6739 static const WCHAR empty[] = {0};
6740 static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0};
6741 static const WCHAR nxdomain[] =
6742 {'n','x','d','o','m','a','i','n','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',0};
6743 static const WCHAR zero[] = {'0',0};
6744 int i, ret;
6745 ADDRINFOW *result, *result2, *p, hint;
6746 WCHAR name[256];
6747 DWORD size = sizeof(name)/sizeof(WCHAR);
6748
6749 if (!pGetAddrInfoW || !pFreeAddrInfoW)
6750 {
6751 win_skip("GetAddrInfoW and/or FreeAddrInfoW not present\n");
6752 return;
6753 }
6754 memset(&hint, 0, sizeof(ADDRINFOW));
6755 name[0] = 0;
6756 GetComputerNameExW( ComputerNamePhysicalDnsHostname, name, &size );
6757
6758 result = (ADDRINFOW *)0xdeadbeef;
6759 WSASetLastError(0xdeadbeef);
6760 ret = pGetAddrInfoW(NULL, NULL, NULL, &result);
6761 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6762 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6763 ok(result == NULL, "got %p\n", result);
6764
6765 result = NULL;
6766 WSASetLastError(0xdeadbeef);
6767 ret = pGetAddrInfoW(empty, NULL, NULL, &result);
6768 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6769 ok(result != NULL, "GetAddrInfoW failed\n");
6770 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6771 pFreeAddrInfoW(result);
6772
6773 result = NULL;
6774 ret = pGetAddrInfoW(NULL, zero, NULL, &result);
6775 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6776 ok(result != NULL, "GetAddrInfoW failed\n");
6777
6778 result2 = NULL;
6779 ret = pGetAddrInfoW(NULL, empty, NULL, &result2);
6780 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6781 ok(result2 != NULL, "GetAddrInfoW failed\n");
6782 compare_addrinfow(result, result2);
6783 pFreeAddrInfoW(result);
6784 pFreeAddrInfoW(result2);
6785
6786 result = NULL;
6787 ret = pGetAddrInfoW(empty, zero, NULL, &result);
6788 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6789 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6790 ok(result != NULL, "GetAddrInfoW failed\n");
6791
6792 result2 = NULL;
6793 ret = pGetAddrInfoW(empty, empty, NULL, &result2);
6794 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6795 ok(result2 != NULL, "GetAddrInfoW failed\n");
6796 compare_addrinfow(result, result2);
6797 pFreeAddrInfoW(result);
6798 pFreeAddrInfoW(result2);
6799
6800 result = NULL;
6801 ret = pGetAddrInfoW(localhost, NULL, NULL, &result);
6802 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6803 pFreeAddrInfoW(result);
6804
6805 result = NULL;
6806 ret = pGetAddrInfoW(localhost, empty, NULL, &result);
6807 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6808 pFreeAddrInfoW(result);
6809
6810 result = NULL;
6811 ret = pGetAddrInfoW(localhost, zero, NULL, &result);
6812 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6813 pFreeAddrInfoW(result);
6814
6815 result = NULL;
6816 ret = pGetAddrInfoW(localhost, port, NULL, &result);
6817 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6818 pFreeAddrInfoW(result);
6819
6820 result = NULL;
6821 ret = pGetAddrInfoW(localhost, NULL, &hint, &result);
6822 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6823 pFreeAddrInfoW(result);
6824
6825 result = NULL;
6826 SetLastError(0xdeadbeef);
6827 ret = pGetAddrInfoW(localhost, port, &hint, &result);
6828 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6829 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6830 pFreeAddrInfoW(result);
6831
6832 /* try to get information from the computer name, result is the same
6833 * as if requesting with an empty host name. */
6834 ret = pGetAddrInfoW(name, NULL, NULL, &result);
6835 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6836 ok(result != NULL, "GetAddrInfoW failed\n");
6837
6838 ret = pGetAddrInfoW(empty, NULL, NULL, &result2);
6839 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6840 ok(result != NULL, "GetAddrInfoW failed\n");
6841 compare_addrinfow(result, result2);
6842 pFreeAddrInfoW(result);
6843 pFreeAddrInfoW(result2);
6844
6845 ret = pGetAddrInfoW(name, empty, NULL, &result);
6846 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6847 ok(result != NULL, "GetAddrInfoW failed\n");
6848
6849 ret = pGetAddrInfoW(empty, empty, NULL, &result2);
6850 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6851 ok(result != NULL, "GetAddrInfoW failed\n");
6852 compare_addrinfow(result, result2);
6853 pFreeAddrInfoW(result);
6854 pFreeAddrInfoW(result2);
6855
6856 result = (ADDRINFOW *)0xdeadbeef;
6857 WSASetLastError(0xdeadbeef);
6858 ret = pGetAddrInfoW(NULL, NULL, NULL, &result);
6859 if(ret == 0)
6860 {
6861 skip("nxdomain returned success. Broken ISP redirects?\n");
6862 return;
6863 }
6864 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6865 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6866 ok(result == NULL, "got %p\n", result);
6867
6868 result = (ADDRINFOW *)0xdeadbeef;
6869 WSASetLastError(0xdeadbeef);
6870 ret = pGetAddrInfoW(nxdomain, NULL, NULL, &result);
6871 if(ret == 0)
6872 {
6873 skip("nxdomain returned success. Broken ISP redirects?\n");
6874 return;
6875 }
6876 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6877 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6878 ok(result == NULL, "got %p\n", result);
6879
6880 for (i = 0;i < (sizeof(hinttests) / sizeof(hinttests[0]));i++)
6881 {
6882 hint.ai_family = hinttests[i].family;
6883 hint.ai_socktype = hinttests[i].socktype;
6884 hint.ai_protocol = hinttests[i].protocol;
6885
6886 result = NULL;
6887 SetLastError(0xdeadbeef);
6888 ret = pGetAddrInfoW(localhost, NULL, &hint, &result);
6889 if (!ret)
6890 {
6891 if (hinttests[i].error)
6892 ok(0, "test %d: GetAddrInfoW succeeded unexpectedly\n", i);
6893 else
6894 {
6895 p = result;
6896 do
6897 {
6898 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
6899 if (hinttests[i].family == AF_UNSPEC)
6900 ok(p->ai_family == AF_INET || p->ai_family == AF_INET6,
6901 "test %d: expected AF_INET or AF_INET6, got %d\n",
6902 i, p->ai_family);
6903 else
6904 ok(p->ai_family == hinttests[i].family,
6905 "test %d: expected family %d, got %d\n",
6906 i, hinttests[i].family, p->ai_family);
6907
6908 ok(p->ai_socktype == hinttests[i].socktype,
6909 "test %d: expected type %d, got %d\n",
6910 i, hinttests[i].socktype, p->ai_socktype);
6911 ok(p->ai_protocol == hinttests[i].protocol,
6912 "test %d: expected protocol %d, got %d\n",
6913 i, hinttests[i].protocol, p->ai_protocol);
6914 p = p->ai_next;
6915 }
6916 while (p);
6917 }
6918 pFreeAddrInfoW(result);
6919 }
6920 else
6921 {
6922 DWORD err = WSAGetLastError();
6923 if (hinttests[i].error)
6924 ok(hinttests[i].error == err, "test %d: GetAddrInfoW failed with error %d, expected %d\n",
6925 i, err, hinttests[i].error);
6926 else
6927 ok(0, "test %d: GetAddrInfoW failed with %d (err %d)\n", i, ret, err);
6928 }
6929 }
6930 }
6931
6932 static void test_getaddrinfo(void)
6933 {
6934 int i, ret;
6935 ADDRINFOA *result, *result2, *p, hint;
6936 CHAR name[256];
6937 DWORD size = sizeof(name);
6938
6939 if (!pgetaddrinfo || !pfreeaddrinfo)
6940 {
6941 win_skip("getaddrinfo and/or freeaddrinfo not present\n");
6942 return;
6943 }
6944 memset(&hint, 0, sizeof(ADDRINFOA));
6945 GetComputerNameExA( ComputerNamePhysicalDnsHostname, name, &size );
6946
6947 result = (ADDRINFOA *)0xdeadbeef;
6948 WSASetLastError(0xdeadbeef);
6949 ret = pgetaddrinfo(NULL, NULL, NULL, &result);
6950 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6951 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6952 ok(result == NULL, "got %p\n", result);
6953
6954 result = NULL;
6955 WSASetLastError(0xdeadbeef);
6956 ret = pgetaddrinfo("", NULL, NULL, &result);
6957 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6958 ok(result != NULL, "getaddrinfo failed\n");
6959 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6960 pfreeaddrinfo(result);
6961
6962 result = NULL;
6963 ret = pgetaddrinfo(NULL, "0", NULL, &result);
6964 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6965 ok(result != NULL, "getaddrinfo failed\n");
6966
6967 result2 = NULL;
6968 ret = pgetaddrinfo(NULL, "", NULL, &result2);
6969 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6970 ok(result2 != NULL, "getaddrinfo failed\n");
6971 compare_addrinfo(result, result2);
6972 pfreeaddrinfo(result);
6973 pfreeaddrinfo(result2);
6974
6975 result = NULL;
6976 WSASetLastError(0xdeadbeef);
6977 ret = pgetaddrinfo("", "0", NULL, &result);
6978 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6979 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6980 ok(result != NULL, "getaddrinfo failed\n");
6981
6982 result2 = NULL;
6983 ret = pgetaddrinfo("", "", NULL, &result2);
6984 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6985 ok(result2 != NULL, "getaddrinfo failed\n");
6986 compare_addrinfo(result, result2);
6987 pfreeaddrinfo(result);
6988 pfreeaddrinfo(result2);
6989
6990 result = NULL;
6991 ret = pgetaddrinfo("localhost", NULL, NULL, &result);
6992 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6993 pfreeaddrinfo(result);
6994
6995 result = NULL;
6996 ret = pgetaddrinfo("localhost", "", NULL, &result);
6997 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6998 pfreeaddrinfo(result);
6999
7000 result = NULL;
7001 ret = pgetaddrinfo("localhost", "0", NULL, &result);
7002 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7003 pfreeaddrinfo(result);
7004
7005 result = NULL;
7006 ret = pgetaddrinfo("localhost", "80", NULL, &result);
7007 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7008 pfreeaddrinfo(result);
7009
7010 result = NULL;
7011 ret = pgetaddrinfo("localhost", NULL, &hint, &result);
7012 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7013 pfreeaddrinfo(result);
7014
7015 result = NULL;
7016 WSASetLastError(0xdeadbeef);
7017 ret = pgetaddrinfo("localhost", "80", &hint, &result);
7018 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7019 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7020 pfreeaddrinfo(result);
7021
7022 /* try to get information from the computer name, result is the same
7023 * as if requesting with an empty host name. */
7024 ret = pgetaddrinfo(name, NULL, NULL, &result);
7025 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7026 ok(result != NULL, "GetAddrInfoW failed\n");
7027
7028 ret = pgetaddrinfo("", NULL, NULL, &result2);
7029 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7030 ok(result != NULL, "GetAddrInfoW failed\n");
7031 compare_addrinfo(result, result2);
7032 pfreeaddrinfo(result);
7033 pfreeaddrinfo(result2);
7034
7035 ret = pgetaddrinfo(name, "", NULL, &result);
7036 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7037 ok(result != NULL, "GetAddrInfoW failed\n");
7038
7039 ret = pgetaddrinfo("", "", NULL, &result2);
7040 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7041 ok(result != NULL, "GetAddrInfoW failed\n");
7042 compare_addrinfo(result, result2);
7043 pfreeaddrinfo(result);
7044 pfreeaddrinfo(result2);
7045
7046 result = (ADDRINFOA *)0xdeadbeef;
7047 WSASetLastError(0xdeadbeef);
7048 ret = pgetaddrinfo("nxdomain.codeweavers.com", NULL, NULL, &result);
7049 if(ret == 0)
7050 {
7051 skip("nxdomain returned success. Broken ISP redirects?\n");
7052 return;
7053 }
7054 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7055 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7056 ok(result == NULL, "got %p\n", result);
7057
7058 for (i = 0;i < (sizeof(hinttests) / sizeof(hinttests[0]));i++)
7059 {
7060 hint.ai_family = hinttests[i].family;
7061 hint.ai_socktype = hinttests[i].socktype;
7062 hint.ai_protocol = hinttests[i].protocol;
7063
7064 result = NULL;
7065 SetLastError(0xdeadbeef);
7066 ret = pgetaddrinfo("localhost", NULL, &hint, &result);
7067 if(!ret)
7068 {
7069 if (hinttests[i].error)
7070 ok(0, "test %d: getaddrinfo succeeded unexpectedly\n", i);
7071 else
7072 {
7073 p = result;
7074 do
7075 {
7076 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
7077 if (hinttests[i].family == AF_UNSPEC)
7078 ok(p->ai_family == AF_INET || p->ai_family == AF_INET6,
7079 "test %d: expected AF_INET or AF_INET6, got %d\n",
7080 i, p->ai_family);
7081 else
7082 ok(p->ai_family == hinttests[i].family,
7083 "test %d: expected family %d, got %d\n",
7084 i, hinttests[i].family, p->ai_family);
7085
7086 ok(p->ai_socktype == hinttests[i].socktype,
7087 "test %d: expected type %d, got %d\n",
7088 i, hinttests[i].socktype, p->ai_socktype);
7089 ok(p->ai_protocol == hinttests[i].protocol,
7090 "test %d: expected protocol %d, got %d\n",
7091 i, hinttests[i].protocol, p->ai_protocol);
7092 p = p->ai_next;
7093 }
7094 while (p);
7095 }
7096 pfreeaddrinfo(result);
7097 }
7098 else
7099 {
7100 DWORD err = WSAGetLastError();
7101 if (hinttests[i].error)
7102 ok(hinttests[i].error == err, "test %d: getaddrinfo failed with error %d, expected %d\n",
7103 i, err, hinttests[i].error);
7104 else
7105 ok(0, "test %d: getaddrinfo failed with %d (err %d)\n", i, ret, err);
7106 }
7107 }
7108 }
7109
7110 static void test_ConnectEx(void)
7111 {
7112 SOCKET listener = INVALID_SOCKET;
7113 SOCKET acceptor = INVALID_SOCKET;
7114 SOCKET connector = INVALID_SOCKET;
7115 struct sockaddr_in address, conaddress;
7116 int addrlen;
7117 OVERLAPPED overlapped;
7118 LPFN_CONNECTEX pConnectEx;
7119 GUID connectExGuid = WSAID_CONNECTEX;
7120 DWORD bytesReturned;
7121 char buffer[1024];
7122 BOOL bret;
7123 DWORD dwret;
7124 int iret;
7125
7126 memset(&overlapped, 0, sizeof(overlapped));
7127
7128 listener = socket(AF_INET, SOCK_STREAM, 0);
7129 if (listener == INVALID_SOCKET) {
7130 skip("could not create listener socket, error %d\n", WSAGetLastError());
7131 goto end;
7132 }
7133
7134 connector = socket(AF_INET, SOCK_STREAM, 0);
7135 if (connector == INVALID_SOCKET) {
7136 skip("could not create connector socket, error %d\n", WSAGetLastError());
7137 goto end;
7138 }
7139
7140 memset(&address, 0, sizeof(address));
7141 address.sin_family = AF_INET;
7142 address.sin_addr.s_addr = inet_addr("127.0.0.1");
7143 iret = bind(listener, (struct sockaddr*)&address, sizeof(address));
7144 if (iret != 0) {
7145 skip("failed to bind, error %d\n", WSAGetLastError());
7146 goto end;
7147 }
7148
7149 addrlen = sizeof(address);
7150 iret = getsockname(listener, (struct sockaddr*)&address, &addrlen);
7151 if (iret != 0) {
7152 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
7153 goto end;
7154 }
7155
7156 if (set_blocking(listener, TRUE)) {
7157 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7158 goto end;
7159 }
7160
7161 iret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectExGuid, sizeof(connectExGuid),
7162 &pConnectEx, sizeof(pConnectEx), &bytesReturned, NULL, NULL);
7163 if (iret) {
7164 win_skip("WSAIoctl failed to get ConnectEx with ret %d + errno %d\n", iret, WSAGetLastError());
7165 goto end;
7166 }
7167
7168 bret = pConnectEx(INVALID_SOCKET, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
7169 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "ConnectEx on invalid socket "
7170 "returned %d + errno %d\n", bret, WSAGetLastError());
7171
7172 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
7173 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "ConnectEx on a unbound socket "
7174 "returned %d + errno %d\n", bret, WSAGetLastError());
7175 if (bret == TRUE || WSAGetLastError() != WSAEINVAL)
7176 {
7177 acceptor = accept(listener, NULL, NULL);
7178 if (acceptor != INVALID_SOCKET) {
7179 closesocket(acceptor);
7180 acceptor = INVALID_SOCKET;
7181 }
7182
7183 closesocket(connector);
7184 connector = socket(AF_INET, SOCK_STREAM, 0);
7185 if (connector == INVALID_SOCKET) {
7186 skip("could not create connector socket, error %d\n", WSAGetLastError());
7187 goto end;
7188 }
7189 }
7190
7191 /* ConnectEx needs a bound socket */
7192 memset(&conaddress, 0, sizeof(conaddress));
7193 conaddress.sin_family = AF_INET;
7194 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
7195 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
7196 if (iret != 0) {
7197 skip("failed to bind, error %d\n", WSAGetLastError());
7198 goto end;
7199 }
7200
7201 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, NULL);
7202 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "ConnectEx on a NULL overlapped "
7203 "returned %d + errno %d\n", bret, WSAGetLastError());
7204
7205 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
7206 if (overlapped.hEvent == NULL) {
7207 skip("could not create event object, errno = %d\n", GetLastError());
7208 goto end;
7209 }
7210
7211 iret = listen(listener, 1);
7212 if (iret != 0) {
7213 skip("listening failed, errno = %d\n", WSAGetLastError());
7214 goto end;
7215 }
7216
7217 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
7218 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
7219 "returned %d + errno %d\n", bret, WSAGetLastError());
7220 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
7221 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
7222
7223 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
7224 ok(bret, "Connecting failed, error %d\n", GetLastError());
7225 ok(bytesReturned == 0, "Bytes sent is %d\n", bytesReturned);
7226
7227 closesocket(connector);
7228 connector = socket(AF_INET, SOCK_STREAM, 0);
7229 if (connector == INVALID_SOCKET) {
7230 skip("could not create connector socket, error %d\n", WSAGetLastError());
7231 goto end;
7232 }
7233 /* ConnectEx needs a bound socket */
7234 memset(&conaddress, 0, sizeof(conaddress));
7235 conaddress.sin_family = AF_INET;
7236 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
7237 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
7238 if (iret != 0) {
7239 skip("failed to bind, error %d\n", WSAGetLastError());
7240 goto end;
7241 }
7242
7243 acceptor = accept(listener, NULL, NULL);
7244 if (acceptor != INVALID_SOCKET) {
7245 closesocket(acceptor);
7246 }
7247
7248 buffer[0] = '1';
7249 buffer[1] = '2';
7250 buffer[2] = '3';
7251 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, buffer, 3, &bytesReturned, &overlapped);
7252 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
7253 "returned %d + errno %d\n", bret, WSAGetLastError());
7254 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
7255 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
7256
7257 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
7258 ok(bret, "Connecting failed, error %d\n", GetLastError());
7259 ok(bytesReturned == 3, "Bytes sent is %d\n", bytesReturned);
7260
7261 acceptor = accept(listener, NULL, NULL);
7262 ok(acceptor != INVALID_SOCKET, "could not accept socket error %d\n", WSAGetLastError());
7263
7264 bytesReturned = recv(acceptor, buffer, 3, 0);
7265 buffer[4] = 0;
7266 ok(bytesReturned == 3, "Didn't get all sent data, got only %d\n", bytesReturned);
7267 ok(buffer[0] == '1' && buffer[1] == '2' && buffer[2] == '3',
7268 "Failed to get the right data, expected '123', got '%s'\n", buffer);
7269
7270 closesocket(connector);
7271 connector = socket(AF_INET, SOCK_STREAM, 0);
7272 if (connector == INVALID_SOCKET) {
7273 skip("could not create connector socket, error %d\n", WSAGetLastError());
7274 goto end;
7275 }
7276 /* ConnectEx needs a bound socket */
7277 memset(&conaddress, 0, sizeof(conaddress));
7278 conaddress.sin_family = AF_INET;
7279 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
7280 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
7281 if (iret != 0) {
7282 skip("failed to bind, error %d\n", WSAGetLastError());
7283 goto end;
7284 }
7285
7286 if (acceptor != INVALID_SOCKET) {
7287 closesocket(acceptor);
7288 acceptor = INVALID_SOCKET;
7289 }
7290
7291 /* Connect with error */
7292 closesocket(listener);
7293 listener = INVALID_SOCKET;
7294
7295 address.sin_port = htons(1);
7296
7297 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
7298 ok(bret == FALSE && GetLastError(), "ConnectEx to bad destination failed: "
7299 "returned %d + errno %d\n", bret, GetLastError());
7300
7301 if (GetLastError() == ERROR_IO_PENDING)
7302 {
7303 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
7304 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
7305
7306 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
7307 ok(bret == FALSE && GetLastError() == ERROR_CONNECTION_REFUSED,
7308 "Connecting to a disconnected host returned error %d - %d\n", bret, WSAGetLastError());
7309 }
7310 else {
7311 ok(GetLastError() == WSAECONNREFUSED,
7312 "Connecting to a disconnected host returned error %d - %d\n", bret, WSAGetLastError());
7313 }
7314
7315 end:
7316 if (overlapped.hEvent)
7317 WSACloseEvent(overlapped.hEvent);
7318 if (listener != INVALID_SOCKET)
7319 closesocket(listener);
7320 if (acceptor != INVALID_SOCKET)
7321 closesocket(acceptor);
7322 if (connector != INVALID_SOCKET)
7323 closesocket(connector);
7324 }
7325
7326 static void test_AcceptEx(void)
7327 {
7328 SOCKET listener = INVALID_SOCKET;
7329 SOCKET acceptor = INVALID_SOCKET;
7330 SOCKET connector = INVALID_SOCKET;
7331 SOCKET connector2 = INVALID_SOCKET;
7332 struct sockaddr_in bindAddress, peerAddress, *readBindAddress, *readRemoteAddress;
7333 int socklen, optlen;
7334 GUID acceptExGuid = WSAID_ACCEPTEX, getAcceptExGuid = WSAID_GETACCEPTEXSOCKADDRS;
7335 LPFN_ACCEPTEX pAcceptEx = NULL;
7336 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs = NULL;
7337 fd_set fds_accept, fds_send;
7338 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
7339 int got, conn1, i;
7340 DWORD bytesReturned, connect_time;
7341 char buffer[1024], ipbuffer[32];
7342 OVERLAPPED overlapped;
7343 int iret, localSize = sizeof(struct sockaddr_in), remoteSize = localSize;
7344 BOOL bret;
7345 DWORD dwret;
7346
7347 memset(&overlapped, 0, sizeof(overlapped));
7348
7349 listener = socket(AF_INET, SOCK_STREAM, 0);
7350 if (listener == INVALID_SOCKET) {
7351 skip("could not create listener socket, error %d\n", WSAGetLastError());
7352 goto end;
7353 }
7354
7355 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7356 if (acceptor == INVALID_SOCKET) {
7357 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7358 goto end;
7359 }
7360
7361 connector = socket(AF_INET, SOCK_STREAM, 0);
7362 if (connector == INVALID_SOCKET) {
7363 skip("could not create connector socket, error %d\n", WSAGetLastError());
7364 goto end;
7365 }
7366
7367 memset(&bindAddress, 0, sizeof(bindAddress));
7368 bindAddress.sin_family = AF_INET;
7369 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
7370 iret = bind(listener, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7371 if (iret != 0) {
7372 skip("failed to bind, error %d\n", WSAGetLastError());
7373 goto end;
7374 }
7375
7376 socklen = sizeof(bindAddress);
7377 iret = getsockname(listener, (struct sockaddr*)&bindAddress, &socklen);
7378 if (iret != 0) {
7379 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
7380 goto end;
7381 }
7382
7383 if (set_blocking(listener, FALSE)) {
7384 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7385 goto end;
7386 }
7387
7388 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
7389 &pAcceptEx, sizeof(pAcceptEx), &bytesReturned, NULL, NULL);
7390 if (iret) {
7391 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret, WSAGetLastError());
7392 goto end;
7393 }
7394
7395 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &getAcceptExGuid, sizeof(getAcceptExGuid),
7396 &pGetAcceptExSockaddrs, sizeof(pGetAcceptExSockaddrs), &bytesReturned, NULL, NULL);
7397 if (iret) {
7398 skip("WSAIoctl failed to get GetAcceptExSockaddrs with ret %d + errno %d\n", iret, WSAGetLastError());
7399 goto end;
7400 }
7401
7402 bret = pAcceptEx(INVALID_SOCKET, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7403 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7404 &bytesReturned, &overlapped);
7405 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid listening socket "
7406 "returned %d + errno %d\n", bret, WSAGetLastError());
7407
7408 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7409 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7410 &bytesReturned, &overlapped);
7411 todo_wine
7412 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on a non-listening socket "
7413 "returned %d + errno %d\n", bret, WSAGetLastError());
7414
7415 iret = listen(listener, 5);
7416 if (iret != 0) {
7417 skip("listening failed, errno = %d\n", WSAGetLastError());
7418 goto end;
7419 }
7420
7421 bret = pAcceptEx(listener, INVALID_SOCKET, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7422 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7423 &bytesReturned, &overlapped);
7424 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid accepting socket "
7425 "returned %d + errno %d\n", bret, WSAGetLastError());
7426
7427 bret = pAcceptEx(listener, acceptor, NULL, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7428 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7429 &bytesReturned, &overlapped);
7430 ok(bret == FALSE &&
7431 (WSAGetLastError() == WSAEINVAL ||
7432 broken(WSAGetLastError() == WSAEFAULT)), /* NT4 */
7433 "AcceptEx on NULL buffer returned %d + errno %d\n", bret, WSAGetLastError());
7434
7435 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
7436 &bytesReturned, &overlapped);
7437 ok(bret == FALSE && (WSAGetLastError() == ERROR_IO_PENDING || broken(WSAGetLastError() == WSAEINVAL)) /* NT4 */,
7438 "AcceptEx on too small local address size returned %d + errno %d\n",
7439 bret, WSAGetLastError());
7440 bret = CancelIo((HANDLE) listener);
7441 ok(bret, "Failed to cancel pending accept socket\n");
7442
7443 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 15,
7444 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
7445 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx on too small local address "
7446 "size returned %d + errno %d\n",
7447 bret, WSAGetLastError());
7448 bret = CancelIo((HANDLE) listener);
7449 ok(bret, "Failed to cancel pending accept socket\n");
7450
7451 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16, 0,
7452 &bytesReturned, &overlapped);
7453 ok(bret == FALSE && (WSAGetLastError() == WSAEFAULT || broken(WSAGetLastError() == WSAEINVAL)) /* NT4 */,
7454 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
7455
7456 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16,
7457 sizeof(struct sockaddr_in) + 15, &bytesReturned, &overlapped);
7458 ok(bret == FALSE && (WSAGetLastError() == ERROR_IO_PENDING || broken(WSAGetLastError() == WSAEINVAL)) /* NT4 */,
7459 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
7460 bret = CancelIo((HANDLE) listener);
7461 ok(bret, "Failed to cancel pending accept socket\n");
7462
7463 bret = pAcceptEx(listener, acceptor, buffer, 0,
7464 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7465 &bytesReturned, NULL);
7466 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
7467 "returned %d + errno %d\n", bret, WSAGetLastError());
7468
7469 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, 0, &bytesReturned, NULL);
7470 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
7471 "returned %d + errno %d\n", bret, WSAGetLastError());
7472
7473 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
7474 if (overlapped.hEvent == NULL) {
7475 skip("could not create event object, errno = %d\n", GetLastError());
7476 goto end;
7477 }
7478
7479 bret = pAcceptEx(listener, acceptor, buffer, 0,
7480 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7481 &bytesReturned, &overlapped);
7482 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7483
7484 bret = pAcceptEx(listener, acceptor, buffer, 0,
7485 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7486 &bytesReturned, &overlapped);
7487 todo_wine ok((bret == FALSE && WSAGetLastError() == WSAEINVAL) || broken(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING) /* NT4 */,
7488 "AcceptEx on already pending socket returned %d + errno %d\n", bret, WSAGetLastError());
7489 if (bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING) {
7490 /* We need to cancel this call, otherwise things fail */
7491 bret = CancelIo((HANDLE) listener);
7492 ok(bret, "Failed to cancel failed test. Bailing...\n");
7493 if (!bret) return;
7494 WaitForSingleObject(overlapped.hEvent, 0);
7495
7496 bret = pAcceptEx(listener, acceptor, buffer, 0,
7497 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7498 &bytesReturned, &overlapped);
7499 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7500 }
7501
7502 iret = connect(acceptor, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7503 todo_wine ok((iret == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL) || broken(!iret) /* NT4 */,
7504 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret, WSAGetLastError());
7505 if (!iret || (iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)) {
7506 /* We need to cancel this call, otherwise things fail */
7507 closesocket(acceptor);
7508 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7509 if (acceptor == INVALID_SOCKET) {
7510 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7511 goto end;
7512 }
7513
7514 bret = CancelIo((HANDLE) listener);
7515 ok(bret, "Failed to cancel failed test. Bailing...\n");
7516 if (!bret) return;
7517
7518 bret = pAcceptEx(listener, acceptor, buffer, 0,
7519 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7520 &bytesReturned, &overlapped);
7521 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7522 }
7523
7524 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7525 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7526
7527 dwret = WaitForSingleObject(overlapped.hEvent, INFINITE);
7528 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7529
7530 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7531 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7532 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7533
7534 closesocket(connector);
7535 connector = INVALID_SOCKET;
7536 closesocket(acceptor);
7537
7538 /* Test short reads */
7539
7540 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7541 if (acceptor == INVALID_SOCKET) {
7542 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7543 goto end;
7544 }
7545 connector = socket(AF_INET, SOCK_STREAM, 0);
7546 if (connector == INVALID_SOCKET) {
7547 skip("could not create connector socket, error %d\n", WSAGetLastError());
7548 goto end;
7549 }
7550 bret = pAcceptEx(listener, acceptor, buffer, 2,
7551 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7552 &bytesReturned, &overlapped);
7553 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7554
7555 connect_time = 0xdeadbeef;
7556 optlen = sizeof(connect_time);
7557 iret = getsockopt(connector, SOL_SOCKET, SO_CONNECT_TIME, (char *)&connect_time, &optlen);
7558 ok(!iret, "getsockopt failed %d\n", WSAGetLastError());
7559 ok(connect_time == ~0u, "unexpected connect time %u\n", connect_time);
7560
7561 /* AcceptEx() still won't complete until we send data */
7562 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7563 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7564
7565 connect_time = 0xdeadbeef;
7566 optlen = sizeof(connect_time);
7567 iret = getsockopt(connector, SOL_SOCKET, SO_CONNECT_TIME, (char *)&connect_time, &optlen);
7568 ok(!iret, "getsockopt failed %d\n", WSAGetLastError());
7569 ok(connect_time < 0xdeadbeef, "unexpected connect time %u\n", connect_time);
7570
7571 dwret = WaitForSingleObject(overlapped.hEvent, 0);
7572 ok(dwret == WAIT_TIMEOUT, "Waiting for accept event timeout failed with %d + errno %d\n", dwret, GetLastError());
7573
7574 iret = getsockname( connector, (struct sockaddr *)&peerAddress, &remoteSize);
7575 ok( !iret, "getsockname failed.\n");
7576
7577 /* AcceptEx() could complete any time now */
7578 iret = send(connector, buffer, 1, 0);
7579 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
7580
7581 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7582 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7583
7584 /* Check if the buffer from AcceptEx is decoded correctly */
7585 pGetAcceptExSockaddrs(buffer, 2, sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7586 (struct sockaddr **)&readBindAddress, &localSize,
7587 (struct sockaddr **)&readRemoteAddress, &remoteSize);
7588 strcpy( ipbuffer, inet_ntoa(readBindAddress->sin_addr));
7589 ok( readBindAddress->sin_addr.s_addr == bindAddress.sin_addr.s_addr,
7590 "Local socket address is different %s != %s\n",
7591 ipbuffer, inet_ntoa(bindAddress.sin_addr));
7592 ok( readBindAddress->sin_port == bindAddress.sin_port,
7593 "Local socket port is different: %d != %d\n",
7594 readBindAddress->sin_port, bindAddress.sin_port);
7595 strcpy( ipbuffer, inet_ntoa(readRemoteAddress->sin_addr));
7596 ok( readRemoteAddress->sin_addr.s_addr == peerAddress.sin_addr.s_addr,
7597 "Remote socket address is different %s != %s\n",
7598 ipbuffer, inet_ntoa(peerAddress.sin_addr));
7599 ok( readRemoteAddress->sin_port == peerAddress.sin_port,
7600 "Remote socket port is different: %d != %d\n",
7601 readRemoteAddress->sin_port, peerAddress.sin_port);
7602
7603 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7604 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7605 ok(bytesReturned == 1, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7606
7607 closesocket(connector);
7608 connector = INVALID_SOCKET;
7609 closesocket(acceptor);
7610
7611 /* Test CF_DEFER & AcceptEx interaction */
7612
7613 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7614 if (acceptor == INVALID_SOCKET) {
7615 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7616 goto end;
7617 }
7618 connector = socket(AF_INET, SOCK_STREAM, 0);
7619 if (connector == INVALID_SOCKET) {
7620 skip("could not create connector socket, error %d\n", WSAGetLastError());
7621 goto end;
7622 }
7623 connector2 = socket(AF_INET, SOCK_STREAM, 0);
7624 if (connector == INVALID_SOCKET) {
7625 skip("could not create connector socket, error %d\n", WSAGetLastError());
7626 goto end;
7627 }
7628
7629 if (set_blocking(connector, FALSE)) {
7630 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7631 goto end;
7632 }
7633
7634 if (set_blocking(connector2, FALSE)) {
7635 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7636 goto end;
7637 }
7638
7639 /* Connect socket #1 */
7640 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7641 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7642
7643 FD_ZERO ( &fds_accept );
7644 FD_ZERO ( &fds_send );
7645
7646 FD_SET ( listener, &fds_accept );
7647 FD_SET ( connector, &fds_send );
7648
7649 buffer[0] = '0';
7650 got = 0;
7651 conn1 = 0;
7652
7653 for (i = 0; i < 4000; ++i)
7654 {
7655 fd_set fds_openaccept = fds_accept, fds_opensend = fds_send;
7656
7657 wsa_ok ( ( select ( 0, &fds_openaccept, &fds_opensend, NULL, &timeout ) ), SOCKET_ERROR !=,
7658 "acceptex test(%d): could not select on socket, errno %d\n" );
7659
7660 /* check for incoming requests */
7661 if ( FD_ISSET ( listener, &fds_openaccept ) ) {
7662 got++;
7663 if (got == 1) {
7664 SOCKET tmp = WSAAccept(listener, NULL, NULL, (LPCONDITIONPROC) AlwaysDeferConditionFunc, 0);
7665 ok(tmp == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
7666 bret = pAcceptEx(listener, acceptor, buffer, 0,
7667 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7668 &bytesReturned, &overlapped);
7669 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7670 }
7671 else if (got == 2) {
7672 /* this should be socket #2 */
7673 SOCKET tmp = accept(listener, NULL, NULL);
7674 ok(tmp != INVALID_SOCKET, "accept failed %d\n", WSAGetLastError());
7675 closesocket(tmp);
7676 }
7677 else {
7678 ok(FALSE, "Got more than 2 connections?\n");
7679 }
7680 }
7681 if ( conn1 && FD_ISSET ( connector2, &fds_opensend ) ) {
7682 /* Send data on second socket, and stop */
7683 send(connector2, "2", 1, 0);
7684 FD_CLR ( connector2, &fds_send );
7685
7686 break;
7687 }
7688 if ( FD_ISSET ( connector, &fds_opensend ) ) {
7689 /* Once #1 is connected, allow #2 to connect */
7690 conn1 = 1;
7691
7692 send(connector, "1", 1, 0);
7693 FD_CLR ( connector, &fds_send );
7694
7695 iret = connect(connector2, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7696 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7697 FD_SET ( connector2, &fds_send );
7698 }
7699 }
7700
7701 ok (got == 2 || broken(got == 1) /* NT4 */,
7702 "Did not get both connections, got %d\n", got);
7703
7704 dwret = WaitForSingleObject(overlapped.hEvent, 0);
7705 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7706
7707 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7708 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7709 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7710
7711 set_blocking(acceptor, TRUE);
7712 iret = recv( acceptor, buffer, 2, 0);
7713 ok(iret == 1, "Failed to get data, %d, errno: %d\n", iret, WSAGetLastError());
7714
7715 ok(buffer[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer[0]);
7716
7717 closesocket(connector);
7718 connector = INVALID_SOCKET;
7719 closesocket(acceptor);
7720
7721 /* clean up in case of failures */
7722 while ((acceptor = accept(listener, NULL, NULL)) != INVALID_SOCKET)
7723 closesocket(acceptor);
7724
7725 /* Disconnect during receive? */
7726
7727 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7728 if (acceptor == INVALID_SOCKET) {
7729 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7730 goto end;
7731 }
7732 connector = socket(AF_INET, SOCK_STREAM, 0);
7733 if (connector == INVALID_SOCKET) {
7734 skip("could not create connector socket, error %d\n", WSAGetLastError());
7735 goto end;
7736 }
7737 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7738 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7739 &bytesReturned, &overlapped);
7740 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7741
7742 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7743 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7744
7745 closesocket(connector);
7746 connector = INVALID_SOCKET;
7747
7748 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7749 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7750
7751 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7752 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7753 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7754
7755 closesocket(acceptor);
7756
7757 /* Test closing with pending requests */
7758
7759 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7760 if (acceptor == INVALID_SOCKET) {
7761 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7762 goto end;
7763 }
7764 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7765 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7766 &bytesReturned, &overlapped);
7767 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7768
7769 closesocket(acceptor);
7770
7771 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7772 todo_wine ok(dwret == WAIT_OBJECT_0 || broken(dwret == WAIT_TIMEOUT) /* NT4/2000 */,
7773 "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7774
7775 if (dwret != WAIT_TIMEOUT) {
7776 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7777 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
7778 }
7779 else {
7780 bret = CancelIo((HANDLE) listener);
7781 ok(bret, "Failed to cancel failed test. Bailing...\n");
7782 if (!bret) return;
7783 WaitForSingleObject(overlapped.hEvent, 0);
7784 }
7785
7786 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7787 if (acceptor == INVALID_SOCKET) {
7788 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7789 goto end;
7790 }
7791 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7792 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7793 &bytesReturned, &overlapped);
7794 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7795
7796 CancelIo((HANDLE) acceptor);
7797
7798 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7799 ok(dwret == WAIT_TIMEOUT, "Waiting for timeout failed with %d + errno %d\n", dwret, GetLastError());
7800
7801 closesocket(acceptor);
7802
7803 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7804 if (acceptor == INVALID_SOCKET) {
7805 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7806 goto end;
7807 }
7808 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7809 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7810 &bytesReturned, &overlapped);
7811 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7812
7813 closesocket(listener);
7814 listener = INVALID_SOCKET;
7815
7816 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7817 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7818
7819 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7820 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
7821
7822 end:
7823 if (overlapped.hEvent)
7824 WSACloseEvent(overlapped.hEvent);
7825 if (listener != INVALID_SOCKET)
7826 closesocket(listener);
7827 if (acceptor != INVALID_SOCKET)
7828 closesocket(acceptor);
7829 if (connector != INVALID_SOCKET)
7830 closesocket(connector);
7831 if (connector2 != INVALID_SOCKET)
7832 closesocket(connector2);
7833 }
7834
7835 static void test_DisconnectEx(void)
7836 {
7837 SOCKET listener, acceptor, connector;
7838 LPFN_DISCONNECTEX pDisconnectEx;
7839 GUID disconnectExGuid = WSAID_DISCONNECTEX;
7840 struct sockaddr_in address;
7841 DWORD num_bytes, flags;
7842 OVERLAPPED overlapped;
7843 int addrlen, iret;
7844 BOOL bret;
7845
7846 connector = socket(AF_INET, SOCK_STREAM, 0);
7847 ok(connector != INVALID_SOCKET, "failed to create connector socket, error %d\n", WSAGetLastError());
7848
7849 iret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &disconnectExGuid, sizeof(disconnectExGuid),
7850 &pDisconnectEx, sizeof(pDisconnectEx), &num_bytes, NULL, NULL);
7851 if (iret)
7852 {
7853 win_skip("WSAIoctl failed to get DisconnectEx, error %d\n", WSAGetLastError());
7854 closesocket(connector);
7855 return;
7856 }
7857
7858 listener = socket(AF_INET, SOCK_STREAM, 0);
7859 ok(listener != INVALID_SOCKET, "failed to create listener socket, error %d\n", WSAGetLastError());
7860
7861 memset(&address, 0, sizeof(address));
7862 address.sin_family = AF_INET;
7863 address.sin_addr.s_addr = inet_addr("127.0.0.1");
7864 iret = bind(listener, (struct sockaddr *)&address, sizeof(address));
7865 ok(iret == 0, "failed to bind, error %d\n", WSAGetLastError());
7866
7867 addrlen = sizeof(address);
7868 iret = getsockname(listener, (struct sockaddr *)&address, &addrlen);
7869 ok(iret == 0, "failed to lookup bind address, error %d\n", WSAGetLastError());
7870
7871 iret = listen(listener, 1);
7872 ok(iret == 0, "failed to listen, error %d\n", WSAGetLastError());
7873
7874 set_blocking(listener, TRUE);
7875
7876 memset(&overlapped, 0, sizeof(overlapped));
7877 bret = pDisconnectEx(INVALID_SOCKET, &overlapped, 0, 0);
7878 ok(bret == FALSE, "DisconnectEx unexpectedly succeeded\n");
7879 ok(WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %d\n", WSAGetLastError());
7880
7881 memset(&overlapped, 0, sizeof(overlapped));
7882 bret = pDisconnectEx(connector, &overlapped, 0, 0);
7883 ok(bret == FALSE, "DisconnectEx unexpectedly succeeded\n");
7884 todo_wine ok(WSAGetLastError() == WSAENOTCONN, "expected WSAENOTCONN, got %d\n", WSAGetLastError());
7885
7886 iret = connect(connector, (struct sockaddr *)&address, addrlen);
7887 ok(iret == 0, "failed to connect, error %d\n", WSAGetLastError());
7888
7889 acceptor = accept(listener, NULL, NULL);
7890 ok(acceptor != INVALID_SOCKET, "could not accept socket, error %d\n", WSAGetLastError());
7891
7892 memset(&overlapped, 0, sizeof(overlapped));
7893 overlapped.hEvent = WSACreateEvent();
7894 ok(overlapped.hEvent != WSA_INVALID_EVENT, "WSACreateEvent failed, error %d\n", WSAGetLastError());
7895 bret = pDisconnectEx(connector, &overlapped, 0, 0);
7896 if (bret)
7897 ok(overlapped.Internal == STATUS_PENDING, "expected STATUS_PENDING, got %08lx\n", overlapped.Internal);
7898 else if (WSAGetLastError() == ERROR_IO_PENDING)
7899 bret = WSAGetOverlappedResult(connector, &overlapped, &num_bytes, TRUE, &flags);
7900 ok(bret, "DisconnectEx failed, error %d\n", WSAGetLastError());
7901 WSACloseEvent(overlapped.hEvent);
7902
7903 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
7904 ok(iret != 0, "connect unexpectedly succeeded\n");
7905 ok(WSAGetLastError() == WSAEISCONN, "expected WSAEISCONN, got %d\n", WSAGetLastError());
7906
7907 closesocket(acceptor);
7908 closesocket(connector);
7909
7910 connector = socket(AF_INET, SOCK_STREAM, 0);
7911 ok(connector != INVALID_SOCKET, "failed to create connector socket, error %d\n", WSAGetLastError());
7912
7913 iret = connect(connector, (struct sockaddr *)&address, addrlen);
7914 ok(iret == 0, "failed to connect, error %d\n", WSAGetLastError());
7915
7916 acceptor = accept(listener, NULL, NULL);
7917 ok(acceptor != INVALID_SOCKET, "could not accept socket, error %d\n", WSAGetLastError());
7918
7919 bret = pDisconnectEx(connector, NULL, 0, 0);
7920 ok(bret, "DisconnectEx failed, error %d\n", WSAGetLastError());
7921
7922 iret = connect(connector, (struct sockaddr *)&address, sizeof(address));
7923 ok(iret != 0, "connect unexpectedly succeeded\n");
7924 ok(WSAGetLastError() == WSAEISCONN, "expected WSAEISCONN, got %d\n", WSAGetLastError());
7925
7926 closesocket(acceptor);
7927 closesocket(connector);
7928 closesocket(listener);
7929 }
7930
7931 #define compare_file(h,s,o) compare_file2(h,s,o,__FILE__,__LINE__)
7932
7933 static void compare_file2(HANDLE handle, SOCKET sock, int offset, const char *file, int line)
7934 {
7935 char buf1[256], buf2[256];
7936 BOOL success;
7937 int i = 0;
7938
7939 SetFilePointer(handle, offset, NULL, FILE_BEGIN);
7940 while (1)
7941 {
7942 DWORD n1 = 0, n2 = 0;
7943
7944 success = ReadFile(handle, buf1, sizeof(buf1), &n1, NULL);
7945 ok_(file,line)(success, "Failed to read from file.\n");
7946 if (success && n1 == 0)
7947 break;
7948 else if(!success)
7949 return;
7950 n2 = recv(sock, buf2, n1, 0);
7951 ok_(file,line)(n1 == n2, "Block %d size mismatch (%d != %d)\n", i, n1, n2);
7952 ok_(file,line)(memcmp(buf1, buf2, n2) == 0, "Block %d failed\n", i);
7953 i++;
7954 }
7955 }
7956
7957 static void test_TransmitFile(void)
7958 {
7959 DWORD num_bytes, err, file_size, total_sent;
7960 GUID transmitFileGuid = WSAID_TRANSMITFILE;
7961 LPFN_TRANSMITFILE pTransmitFile = NULL;
7962 HANDLE file = INVALID_HANDLE_VALUE;
7963 char header_msg[] = "hello world";
7964 char footer_msg[] = "goodbye!!!";
7965 char system_ini_path[MAX_PATH];
7966 struct sockaddr_in bindAddress;
7967 TRANSMIT_FILE_BUFFERS buffers;
7968 SOCKET client, server, dest;
7969 WSAOVERLAPPED ov;
7970 char buf[256];
7971 int iret, len;
7972 BOOL bret;
7973
7974 memset( &ov, 0, sizeof(ov) );
7975
7976 /* Setup sockets for testing TransmitFile */
7977 client = socket(AF_INET, SOCK_STREAM, 0);
7978 server = socket(AF_INET, SOCK_STREAM, 0);
7979 if (client == INVALID_SOCKET || server == INVALID_SOCKET)
7980 {
7981 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7982 goto cleanup;
7983 }
7984 iret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &transmitFileGuid, sizeof(transmitFileGuid),
7985 &pTransmitFile, sizeof(pTransmitFile), &num_bytes, NULL, NULL);
7986 if (iret)
7987 {
7988 skip("WSAIoctl failed to get TransmitFile with ret %d + errno %d\n", iret, WSAGetLastError());
7989 goto cleanup;
7990 }
7991 GetSystemWindowsDirectoryA(system_ini_path, MAX_PATH );
7992 strcat(system_ini_path, "\\system.ini");
7993 file = CreateFileA(system_ini_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0x0, NULL);
7994 if (file == INVALID_HANDLE_VALUE)
7995 {
7996 skip("Unable to open a file to transmit.\n");
7997 goto cleanup;
7998 }
7999 file_size = GetFileSize(file, NULL);
8000
8001 /* Test TransmitFile with an invalid socket */
8002 bret = pTransmitFile(INVALID_SOCKET, file, 0, 0, NULL, NULL, 0);
8003 err = WSAGetLastError();
8004 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8005 ok(err == WSAENOTSOCK, "TransmitFile triggered unexpected errno (%d != %d)\n", err, WSAENOTSOCK);
8006
8007 /* Test a bogus TransmitFile without a connected socket */
8008 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, TF_REUSE_SOCKET);
8009 err = WSAGetLastError();
8010 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8011 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%d != %d)\n", err, WSAENOTCONN);
8012
8013 /* Setup a properly connected socket for transfers */
8014 memset(&bindAddress, 0, sizeof(bindAddress));
8015 bindAddress.sin_family = AF_INET;
8016 bindAddress.sin_port = htons(9375);
8017 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
8018 iret = bind(server, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8019 if (iret != 0)
8020 {
8021 skip("failed to bind(), error %d\n", WSAGetLastError());
8022 goto cleanup;
8023 }
8024 iret = listen(server, 1);
8025 if (iret != 0)
8026 {
8027 skip("failed to listen(), error %d\n", WSAGetLastError());
8028 goto cleanup;
8029 }
8030 iret = connect(client, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8031 if (iret != 0)
8032 {
8033 skip("failed to connect(), error %d\n", WSAGetLastError());
8034 goto cleanup;
8035 }
8036 len = sizeof(bindAddress);
8037 dest = accept(server, (struct sockaddr*)&bindAddress, &len);
8038 if (dest == INVALID_SOCKET)
8039 {
8040 skip("failed to accept(), error %d\n", WSAGetLastError());
8041 goto cleanup;
8042 }
8043 if (set_blocking(dest, FALSE))
8044 {
8045 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8046 goto cleanup;
8047 }
8048
8049 /* Test TransmitFile with no possible buffer */
8050 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
8051 ok(bret, "TransmitFile failed unexpectedly.\n");
8052 iret = recv(dest, buf, sizeof(buf), 0);
8053 ok(iret == -1, "Returned an unexpected buffer from TransmitFile (%d != -1).\n", iret);
8054
8055 /* Test TransmitFile with only buffer data */
8056 buffers.Head = &header_msg[0];
8057 buffers.HeadLength = sizeof(header_msg)+1;
8058 buffers.Tail = &footer_msg[0];
8059 buffers.TailLength = sizeof(footer_msg)+1;
8060 bret = pTransmitFile(client, NULL, 0, 0, NULL, &buffers, 0);
8061 ok(bret, "TransmitFile failed unexpectedly.\n");
8062 iret = recv(dest, buf, sizeof(buf), 0);
8063 ok(iret == sizeof(header_msg)+sizeof(footer_msg)+2,
8064 "Returned an unexpected buffer from TransmitFile: %d\n", iret );
8065 ok(memcmp(&buf[0], &header_msg[0], sizeof(header_msg)+1) == 0,
8066 "TransmitFile header buffer did not match!\n");
8067 ok(memcmp(&buf[sizeof(header_msg)+1], &footer_msg[0], sizeof(footer_msg)+1) == 0,
8068 "TransmitFile footer buffer did not match!\n");
8069
8070 /* Test TransmitFile with only file data */
8071 bret = pTransmitFile(client, file, 0, 0, NULL, NULL, 0);
8072 ok(bret, "TransmitFile failed unexpectedly.\n");
8073 compare_file(file, dest, 0);
8074
8075 /* Test TransmitFile with both file and buffer data */
8076 buffers.Head = &header_msg[0];
8077 buffers.HeadLength = sizeof(header_msg)+1;
8078 buffers.Tail = &footer_msg[0];
8079 buffers.TailLength = sizeof(footer_msg)+1;
8080 SetFilePointer(file, 0, NULL, FILE_BEGIN);
8081 bret = pTransmitFile(client, file, 0, 0, NULL, &buffers, 0);
8082 ok(bret, "TransmitFile failed unexpectedly.\n");
8083 iret = recv(dest, buf, sizeof(header_msg)+1, 0);
8084 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)+1) == 0,
8085 "TransmitFile header buffer did not match!\n");
8086 compare_file(file, dest, 0);
8087 iret = recv(dest, buf, sizeof(footer_msg)+1, 0);
8088 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)+1) == 0,
8089 "TransmitFile footer buffer did not match!\n");
8090
8091 /* Test overlapped TransmitFile */
8092 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
8093 if (ov.hEvent == INVALID_HANDLE_VALUE)
8094 {
8095 skip("Could not create event object, some tests will be skipped. errno = %d\n",
8096 GetLastError());
8097 goto cleanup;
8098 }
8099 SetFilePointer(file, 0, NULL, FILE_BEGIN);
8100 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
8101 err = WSAGetLastError();
8102 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8103 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%d != %d)\n",
8104 err, ERROR_IO_PENDING);
8105 iret = WaitForSingleObject(ov.hEvent, 2000);
8106 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
8107 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
8108 ok(total_sent == file_size,
8109 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8110 total_sent, file_size);
8111 compare_file(file, dest, 0);
8112
8113 /* Test overlapped TransmitFile w/ start offset */
8114 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
8115 if (ov.hEvent == INVALID_HANDLE_VALUE)
8116 {
8117 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
8118 goto cleanup;
8119 }
8120 SetFilePointer(file, 0, NULL, FILE_BEGIN);
8121 ov.Offset = 10;
8122 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
8123 err = WSAGetLastError();
8124 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8125 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%d != %d)\n", err, ERROR_IO_PENDING);
8126 iret = WaitForSingleObject(ov.hEvent, 2000);
8127 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
8128 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
8129 ok(total_sent == (file_size - ov.Offset),
8130 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8131 total_sent, file_size - ov.Offset);
8132 compare_file(file, dest, ov.Offset);
8133
8134 /* Test overlapped TransmitFile w/ file and buffer data */
8135 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
8136 if (ov.hEvent == INVALID_HANDLE_VALUE)
8137 {
8138 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
8139 goto cleanup;
8140 }
8141 buffers.Head = &header_msg[0];
8142 buffers.HeadLength = sizeof(header_msg)+1;
8143 buffers.Tail = &footer_msg[0];
8144 buffers.TailLength = sizeof(footer_msg)+1;
8145 SetFilePointer(file, 0, NULL, FILE_BEGIN);
8146 ov.Offset = 0;
8147 bret = pTransmitFile(client, file, 0, 0, &ov, &buffers, 0);
8148 err = WSAGetLastError();
8149 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8150 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%d != %d)\n", err, ERROR_IO_PENDING);
8151 iret = WaitForSingleObject(ov.hEvent, 2000);
8152 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
8153 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
8154 ok(total_sent == (file_size + buffers.HeadLength + buffers.TailLength),
8155 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8156 total_sent, file_size + buffers.HeadLength + buffers.TailLength);
8157 iret = recv(dest, buf, sizeof(header_msg)+1, 0);
8158 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)+1) == 0,
8159 "TransmitFile header buffer did not match!\n");
8160 compare_file(file, dest, 0);
8161 iret = recv(dest, buf, sizeof(footer_msg)+1, 0);
8162 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)+1) == 0,
8163 "TransmitFile footer buffer did not match!\n");
8164
8165 /* Test TransmitFile with a UDP datagram socket */
8166 closesocket(client);
8167 client = socket(AF_INET, SOCK_DGRAM, 0);
8168 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
8169 err = WSAGetLastError();
8170 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8171 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%d != %d)\n", err, WSAENOTCONN);
8172
8173 cleanup:
8174 CloseHandle(file);
8175 CloseHandle(ov.hEvent);
8176 closesocket(client);
8177 closesocket(server);
8178 }
8179
8180 static void test_getpeername(void)
8181 {
8182 SOCKET sock;
8183 struct sockaddr_in sa, sa_out;
8184 SOCKADDR_STORAGE ss;
8185 int sa_len;
8186 const char buf[] = "hello world";
8187 int ret;
8188
8189 /* Test the parameter validation order. */
8190 ret = getpeername(INVALID_SOCKET, NULL, NULL);
8191 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
8192 ok(WSAGetLastError() == WSAENOTSOCK,
8193 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
8194
8195 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
8196 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
8197 if (sock == INVALID_SOCKET)
8198 {
8199 skip("Socket creation failed with %d\n", WSAGetLastError());
8200 return;
8201 }
8202
8203 ret = getpeername(sock, NULL, NULL);
8204 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
8205 ok(WSAGetLastError() == WSAENOTCONN ||
8206 broken(WSAGetLastError() == WSAEFAULT), /* Win9x and WinMe */
8207 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
8208
8209 memset(&sa, 0, sizeof(sa));
8210 sa.sin_family = AF_INET;
8211 sa.sin_port = htons(139);
8212 sa.sin_addr.s_addr = inet_addr("127.0.0.1");
8213
8214 /* sendto does not change a socket's connection state. */
8215 ret = sendto(sock, buf, sizeof(buf), 0, (struct sockaddr*)&sa, sizeof(sa));
8216 ok(ret != SOCKET_ERROR,
8217 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
8218
8219 ret = getpeername(sock, NULL, NULL);
8220 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
8221 ok(WSAGetLastError() == WSAENOTCONN ||
8222 broken(WSAGetLastError() == WSAEFAULT), /* Win9x and WinMe */
8223 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
8224
8225 ret = connect(sock, (struct sockaddr*)&sa, sizeof(sa));
8226 ok(ret == 0,
8227 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
8228
8229 ret = getpeername(sock, NULL, NULL);
8230 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
8231 ok(WSAGetLastError() == WSAEFAULT,
8232 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8233
8234 /* Test crashes on Wine. */
8235 if (0)
8236 {
8237 ret = getpeername(sock, (void*)0xdeadbeef, (void*)0xcafebabe);
8238 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
8239 ok(WSAGetLastError() == WSAEFAULT,
8240 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8241 }
8242
8243 ret = getpeername(sock, (struct sockaddr*)&sa_out, NULL);
8244 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
8245 ok(WSAGetLastError() == WSAEFAULT,
8246 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8247
8248 sa_len = 0;
8249 ret = getpeername(sock, NULL, &sa_len);
8250 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
8251 ok(WSAGetLastError() == WSAEFAULT,
8252 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8253 ok(!sa_len, "got %d\n", sa_len);
8254
8255 sa_len = 0;
8256 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
8257 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
8258 ok(WSAGetLastError() == WSAEFAULT,
8259 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8260 ok(!sa_len, "got %d\n", sa_len);
8261
8262 sa_len = sizeof(ss);
8263 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
8264 ok(ret == 0, "Expected getpeername to return 0, got %d\n", ret);
8265 ok(!memcmp(&sa, &ss, sizeof(sa)),
8266 "Expected the returned structure to be identical to the connect structure\n");
8267 ok(sa_len == sizeof(sa), "got %d\n", sa_len);
8268
8269 closesocket(sock);
8270 }
8271
8272 static void test_sioRoutingInterfaceQuery(void)
8273 {
8274 int ret;
8275 SOCKET sock;
8276 SOCKADDR_IN sin = { 0 }, sout = { 0 };
8277 DWORD bytesReturned;
8278
8279 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
8280 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
8281 if (sock == INVALID_SOCKET)
8282 {
8283 skip("Socket creation failed with %d\n", WSAGetLastError());
8284 return;
8285 }
8286 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, NULL, 0, NULL, 0, NULL,
8287 NULL, NULL);
8288 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
8289 "expected WSAEFAULT, got %d\n", WSAGetLastError());
8290 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
8291 NULL, 0, NULL, NULL, NULL);
8292 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
8293 "expected WSAEFAULT, got %d\n", WSAGetLastError());
8294 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
8295 NULL, 0, &bytesReturned, NULL, NULL);
8296 ok(ret == SOCKET_ERROR &&
8297 (WSAGetLastError() == WSAEFAULT /* Win98 */ ||
8298 WSAGetLastError() == WSAEINVAL /* NT4 */||
8299 WSAGetLastError() == WSAEAFNOSUPPORT),
8300 "expected WSAEFAULT or WSAEINVAL or WSAEAFNOSUPPORT, got %d\n",
8301 WSAGetLastError());
8302 sin.sin_family = AF_INET;
8303 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
8304 NULL, 0, &bytesReturned, NULL, NULL);
8305 ok(ret == SOCKET_ERROR &&
8306 (WSAGetLastError() == WSAEFAULT /* Win98 */ ||
8307 WSAGetLastError() == WSAEINVAL),
8308 "expected WSAEFAULT or WSAEINVAL, got %d\n", WSAGetLastError());
8309 sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
8310 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
8311 NULL, 0, &bytesReturned, NULL, NULL);
8312 ok(ret == SOCKET_ERROR &&
8313 (WSAGetLastError() == WSAEINVAL /* NT4 */ ||
8314 WSAGetLastError() == WSAEFAULT),
8315 "expected WSAEINVAL or WSAEFAULT, got %d\n", WSAGetLastError());
8316 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
8317 &sout, sizeof(sout), &bytesReturned, NULL, NULL);
8318 ok(!ret || broken(WSAGetLastError() == WSAEINVAL /* NT4 */),
8319 "WSAIoctl failed: %d\n", WSAGetLastError());
8320 if (!ret)
8321 {
8322 ok(sout.sin_family == AF_INET, "expected AF_INET, got %d\n",
8323 sout.sin_family);
8324 /* We expect the source address to be INADDR_LOOPBACK as well, but
8325 * there's no guarantee that a route to the loopback address exists,
8326 * so rather than introduce spurious test failures we do not test the
8327 * source address.
8328 */
8329 }
8330 closesocket(sock);
8331 }
8332
8333 static void test_sioAddressListChange(void)
8334 {
8335 struct sockaddr_in bindAddress;
8336 struct in_addr net_address;
8337 WSAOVERLAPPED overlapped;
8338 struct hostent *h;
8339 DWORD num_bytes;
8340 SOCKET sock;
8341 int acount;
8342 int ret;
8343
8344 if (!winetest_interactive)
8345 {
8346 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
8347 return;
8348 }
8349
8350 /* Use gethostbyname to find the list of local network interfaces */
8351 h = gethostbyname("");
8352 if (!h)
8353 {
8354 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, gethostbyname failed with %u\n",
8355 WSAGetLastError());
8356 return;
8357 }
8358 for (acount = 0; h->h_addr_list[acount]; acount++);
8359 if (acount == 0)
8360 {
8361 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
8362 return;
8363 }
8364 net_address.s_addr = *(ULONG *) h->h_addr_list[0];
8365
8366 /* Bind an overlapped socket to the first found network interface */
8367 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
8368 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
8369 if (sock == INVALID_SOCKET)
8370 {
8371 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, socket creation failed with %u\n",
8372 WSAGetLastError());
8373 return;
8374 }
8375 memset(&bindAddress, 0, sizeof(bindAddress));
8376 bindAddress.sin_family = AF_INET;
8377 bindAddress.sin_addr.s_addr = net_address.s_addr;
8378 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8379 if (ret != 0)
8380 {
8381 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, failed to bind, error %u\n", WSAGetLastError());
8382 goto end;
8383 }
8384
8385 /* Wait for address changes, request that the user connects/disconnects an interface */
8386 memset(&overlapped, 0, sizeof(overlapped));
8387 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8388 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
8389 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
8390 ok(WSAGetLastError() == WSA_IO_PENDING, "Expected pending last error %d\n", WSAGetLastError());
8391 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
8392 " change the ipv4 address of any of the local network interfaces (10 second timeout).\n");
8393 ret = WaitForSingleObject(overlapped.hEvent, 10000);
8394 ok(ret == WAIT_OBJECT_0, "failed to get overlapped event %u\n", ret);
8395
8396 end:
8397 closesocket(sock);
8398 }
8399
8400 static void test_synchronous_WSAIoctl(void)
8401 {
8402 HANDLE previous_port, io_port;
8403 WSAOVERLAPPED overlapped, *olp;
8404 SOCKET socket;
8405 ULONG on;
8406 ULONG_PTR key;
8407 DWORD num_bytes;
8408 BOOL ret;
8409 int res;
8410
8411 previous_port = CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 0 );
8412 ok( previous_port != NULL, "failed to create completion port %u\n", GetLastError() );
8413
8414 socket = WSASocketW( AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED );
8415 ok( socket != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError() );
8416
8417 io_port = CreateIoCompletionPort( (HANDLE)socket, previous_port, 0, 0 );
8418 ok( io_port != NULL, "failed to create completion port %u\n", GetLastError() );
8419
8420 on = 1;
8421 memset( &overlapped, 0, sizeof(overlapped) );
8422 res = WSAIoctl( socket, FIONBIO, &on, sizeof(on), NULL, 0, &num_bytes, &overlapped, NULL );
8423 ok( !res, "WSAIoctl failed %d\n", WSAGetLastError() );
8424
8425 ret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 10000 );
8426 ok( ret, "failed to get completion status %u\n", GetLastError() );
8427
8428 CloseHandle( io_port );
8429 closesocket( socket );
8430 CloseHandle( previous_port );
8431 }
8432
8433 #define WM_ASYNCCOMPLETE (WM_USER + 100)
8434 static HWND create_async_message_window(void)
8435 {
8436 static const char class_name[] = "ws2_32 async message window class";
8437
8438 WNDCLASSEXA wndclass;
8439 HWND hWnd;
8440
8441 wndclass.cbSize = sizeof(wndclass);
8442 wndclass.style = CS_HREDRAW | CS_VREDRAW;
8443 wndclass.lpfnWndProc = DefWindowProcA;
8444 wndclass.cbClsExtra = 0;
8445 wndclass.cbWndExtra = 0;
8446 wndclass.hInstance = GetModuleHandleA(NULL);
8447 wndclass.hIcon = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
8448 wndclass.hIconSm = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
8449 wndclass.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
8450 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
8451 wndclass.lpszClassName = class_name;
8452 wndclass.lpszMenuName = NULL;
8453
8454 RegisterClassExA(&wndclass);
8455
8456 hWnd = CreateWindowA(class_name, "ws2_32 async message window", WS_OVERLAPPEDWINDOW,
8457 0, 0, 500, 500, NULL, NULL, GetModuleHandleA(NULL), NULL);
8458 if (!hWnd)
8459 {
8460 ok(0, "failed to create window: %u\n", GetLastError());
8461 return NULL;
8462 }
8463
8464 return hWnd;
8465 }
8466
8467 static void test_WSAAsyncGetServByPort(void)
8468 {
8469 HWND hwnd = create_async_message_window();
8470 HANDLE ret;
8471 char buffer[MAXGETHOSTSTRUCT];
8472
8473 if (!hwnd)
8474 return;
8475
8476 /* FIXME: The asynchronous window messages should be tested. */
8477
8478 /* Parameters are not checked when initiating the asynchronous operation. */
8479 ret = WSAAsyncGetServByPort(NULL, 0, 0, NULL, NULL, 0);
8480 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
8481
8482 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, 0, NULL, NULL, 0);
8483 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
8484
8485 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, htons(80), NULL, NULL, 0);
8486 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
8487
8488 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, htons(80), NULL, buffer, MAXGETHOSTSTRUCT);
8489 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
8490
8491 DestroyWindow(hwnd);
8492 }
8493
8494 static void test_WSAAsyncGetServByName(void)
8495 {
8496 HWND hwnd = create_async_message_window();
8497 HANDLE ret;
8498 char buffer[MAXGETHOSTSTRUCT];
8499
8500 if (!hwnd)
8501 return;
8502
8503 /* FIXME: The asynchronous window messages should be tested. */
8504
8505 /* Parameters are not checked when initiating the asynchronous operation. */
8506 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "", NULL, NULL, 0);
8507 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
8508
8509 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "", "", buffer, MAXGETHOSTSTRUCT);
8510 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
8511
8512 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "http", NULL, NULL, 0);
8513 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
8514
8515 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "http", "tcp", buffer, MAXGETHOSTSTRUCT);
8516 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
8517
8518 DestroyWindow(hwnd);
8519 }
8520
8521 /*
8522 * Provide consistent initialization for the AcceptEx IOCP tests.
8523 */
8524 static SOCKET setup_iocp_src(struct sockaddr_in *bindAddress)
8525 {
8526 SOCKET src, ret = INVALID_SOCKET;
8527 int iret, socklen;
8528
8529 src = socket(AF_INET, SOCK_STREAM, 0);
8530 if (src == INVALID_SOCKET)
8531 {
8532 skip("could not create listener socket, error %d\n", WSAGetLastError());
8533 goto end;
8534 }
8535
8536 memset(bindAddress, 0, sizeof(*bindAddress));
8537 bindAddress->sin_family = AF_INET;
8538 bindAddress->sin_addr.s_addr = inet_addr("127.0.0.1");
8539 iret = bind(src, (struct sockaddr*)bindAddress, sizeof(*bindAddress));
8540 if (iret != 0)
8541 {
8542 skip("failed to bind, error %d\n", WSAGetLastError());
8543 goto end;
8544 }
8545
8546 socklen = sizeof(*bindAddress);
8547 iret = getsockname(src, (struct sockaddr*)bindAddress, &socklen);
8548 if (iret != 0) {
8549 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
8550 goto end;
8551 }
8552
8553 if (set_blocking(src, FALSE))
8554 {
8555 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8556 goto end;
8557 }
8558
8559 iret = listen(src, 5);
8560 if (iret != 0)
8561 {
8562 skip("listening failed, errno = %d\n", WSAGetLastError());
8563 goto end;
8564 }
8565
8566 ret = src;
8567 end:
8568 if (src != ret && ret == INVALID_SOCKET)
8569 closesocket(src);
8570 return ret;
8571 }
8572
8573 static void test_completion_port(void)
8574 {
8575 HANDLE previous_port, io_port;
8576 WSAOVERLAPPED ov, *olp;
8577 SOCKET src, dest, dup, connector = INVALID_SOCKET;
8578 WSAPROTOCOL_INFOA info;
8579 char buf[1024];
8580 WSABUF bufs;
8581 DWORD num_bytes, flags;
8582 struct linger ling;
8583 int iret;
8584 BOOL bret;
8585 ULONG_PTR key;
8586 struct sockaddr_in bindAddress;
8587 GUID acceptExGuid = WSAID_ACCEPTEX;
8588 LPFN_ACCEPTEX pAcceptEx = NULL;
8589
8590 memset(buf, 0, sizeof(buf));
8591 previous_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
8592 ok( previous_port != NULL, "Failed to create completion port %u\n", GetLastError());
8593
8594 memset(&ov, 0, sizeof(ov));
8595
8596 tcp_socketpair(&src, &dest);
8597 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
8598 {
8599 skip("failed to create sockets\n");
8600 goto end;
8601 }
8602
8603 bufs.len = sizeof(buf);
8604 bufs.buf = buf;
8605 flags = 0;
8606
8607 ling.l_onoff = 1;
8608 ling.l_linger = 0;
8609 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
8610 ok(!iret, "Failed to set linger %d\n", GetLastError());
8611
8612 io_port = CreateIoCompletionPort( (HANDLE)dest, previous_port, 125, 0 );
8613 ok(io_port != NULL, "Failed to create completion port %u\n", GetLastError());
8614
8615 SetLastError(0xdeadbeef);
8616
8617 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
8618 ok(iret == SOCKET_ERROR, "WSARecv returned %d\n", iret);
8619 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8620
8621 Sleep(100);
8622
8623 closesocket(src);
8624 src = INVALID_SOCKET;
8625
8626 SetLastError(0xdeadbeef);
8627 key = 0xdeadbeef;
8628 num_bytes = 0xdeadbeef;
8629 olp = (WSAOVERLAPPED *)0xdeadbeef;
8630
8631 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8632 todo_wine ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret);
8633 todo_wine ok(GetLastError() == ERROR_NETNAME_DELETED, "Last error was %d\n", GetLastError());
8634 ok(key == 125, "Key is %lu\n", key);
8635 ok(num_bytes == 0, "Number of bytes received is %u\n", num_bytes);
8636 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8637
8638 SetLastError(0xdeadbeef);
8639 key = 0xdeadbeef;
8640 num_bytes = 0xdeadbeef;
8641 olp = (WSAOVERLAPPED *)0xdeadbeef;
8642
8643 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8644 ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret );
8645 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8646 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8647 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8648 ok(!olp, "Overlapped structure is at %p\n", olp);
8649
8650 if (dest != INVALID_SOCKET)
8651 closesocket(dest);
8652
8653 memset(&ov, 0, sizeof(ov));
8654
8655 tcp_socketpair(&src, &dest);
8656 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
8657 {
8658 skip("failed to create sockets\n");
8659 goto end;
8660 }
8661
8662 bufs.len = sizeof(buf);
8663 bufs.buf = buf;
8664 flags = 0;
8665
8666 ling.l_onoff = 1;
8667 ling.l_linger = 0;
8668 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
8669 ok(!iret, "Failed to set linger %d\n", GetLastError());
8670
8671 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 125, 0);
8672 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8673
8674 set_blocking(dest, FALSE);
8675
8676 closesocket(src);
8677 src = INVALID_SOCKET;
8678
8679 Sleep(100);
8680
8681 num_bytes = 0xdeadbeef;
8682 SetLastError(0xdeadbeef);
8683
8684 iret = WSASend(dest, &bufs, 1, &num_bytes, 0, &ov, NULL);
8685 ok(iret == SOCKET_ERROR, "WSASend failed - %d\n", iret);
8686 ok(GetLastError() == WSAECONNRESET, "Last error was %d\n", GetLastError());
8687 ok(num_bytes == 0xdeadbeef, "Managed to send %d\n", num_bytes);
8688
8689 SetLastError(0xdeadbeef);
8690 key = 0xdeadbeef;
8691 num_bytes = 0xdeadbeef;
8692 olp = (WSAOVERLAPPED *)0xdeadbeef;
8693
8694 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8695 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
8696 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8697 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8698 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8699 ok(!olp, "Overlapped structure is at %p\n", olp);
8700
8701 if (dest != INVALID_SOCKET)
8702 closesocket(dest);
8703
8704 dest = socket(AF_INET, SOCK_STREAM, 0);
8705 if (dest == INVALID_SOCKET)
8706 {
8707 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8708 goto end;
8709 }
8710
8711 iret = WSAIoctl(dest, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
8712 &pAcceptEx, sizeof(pAcceptEx), &num_bytes, NULL, NULL);
8713 if (iret)
8714 {
8715 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret, WSAGetLastError());
8716 goto end;
8717 }
8718
8719 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
8720
8721 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8722 goto end;
8723
8724 SetLastError(0xdeadbeef);
8725
8726 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8727 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8728 &num_bytes, &ov);
8729 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8730 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8731
8732 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8733 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8734
8735 closesocket(src);
8736 src = INVALID_SOCKET;
8737
8738 SetLastError(0xdeadbeef);
8739 key = 0xdeadbeef;
8740 num_bytes = 0xdeadbeef;
8741 olp = (WSAOVERLAPPED *)0xdeadbeef;
8742
8743 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8744 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8745 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
8746 ok(key == 125, "Key is %lu\n", key);
8747 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8748 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8749 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
8750
8751 SetLastError(0xdeadbeef);
8752 key = 0xdeadbeef;
8753 num_bytes = 0xdeadbeef;
8754 olp = (WSAOVERLAPPED *)0xdeadbeef;
8755 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8756 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8757 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8758 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8759 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8760 ok(!olp, "Overlapped structure is at %p\n", olp);
8761
8762 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
8763
8764 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8765 goto end;
8766
8767 SetLastError(0xdeadbeef);
8768
8769 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8770 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8771
8772 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8773 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8774 &num_bytes, &ov);
8775 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8776 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8777
8778 closesocket(src);
8779 src = INVALID_SOCKET;
8780
8781 SetLastError(0xdeadbeef);
8782 key = 0xdeadbeef;
8783 num_bytes = 0xdeadbeef;
8784 olp = (WSAOVERLAPPED *)0xdeadbeef;
8785
8786 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8787 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8788 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
8789 ok(key == 125, "Key is %lu\n", key);
8790 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8791 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8792 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
8793
8794 SetLastError(0xdeadbeef);
8795 key = 0xdeadbeef;
8796 num_bytes = 0xdeadbeef;
8797 olp = (WSAOVERLAPPED *)0xdeadbeef;
8798 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8799 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8800 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8801 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8802 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8803 ok(!olp, "Overlapped structure is at %p\n", olp);
8804
8805 /* Test IOCP with duplicated handle */
8806
8807 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8808 goto end;
8809
8810 SetLastError(0xdeadbeef);
8811
8812 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8813 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8814
8815 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
8816 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
8817 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
8818
8819 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8820 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8821 &num_bytes, &ov);
8822 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8823 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8824
8825 SetLastError(0xdeadbeef);
8826 key = 0xdeadbeef;
8827 num_bytes = 0xdeadbeef;
8828 olp = (WSAOVERLAPPED *)0xdeadbeef;
8829 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8830 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8831 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8832 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8833 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8834 ok(!olp, "Overlapped structure is at %p\n", olp);
8835
8836 closesocket(src);
8837 src = INVALID_SOCKET;
8838 closesocket(dup);
8839 dup = INVALID_SOCKET;
8840
8841 SetLastError(0xdeadbeef);
8842 key = 0xdeadbeef;
8843 num_bytes = 0xdeadbeef;
8844 olp = (WSAOVERLAPPED *)0xdeadbeef;
8845 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8846 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8847 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
8848 ok(key == 125, "Key is %lu\n", key);
8849 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8850 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8851 ok(olp && olp->Internal == (ULONG)STATUS_CANCELLED, "Internal status is %lx\n", olp ? olp->Internal : 0);
8852
8853 SetLastError(0xdeadbeef);
8854 key = 0xdeadbeef;
8855 num_bytes = 0xdeadbeef;
8856 olp = (WSAOVERLAPPED *)0xdeadbeef;
8857 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8858 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8859 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8860 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8861 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8862 ok(!olp, "Overlapped structure is at %p\n", olp);
8863
8864 /* Test IOCP with duplicated handle (closing duplicated handle) */
8865
8866 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8867 goto end;
8868
8869 SetLastError(0xdeadbeef);
8870
8871 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8872 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8873
8874 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
8875 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
8876 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
8877
8878 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8879 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8880 &num_bytes, &ov);
8881 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8882 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8883
8884 closesocket(dup);
8885 dup = INVALID_SOCKET;
8886
8887 SetLastError(0xdeadbeef);
8888 key = 0xdeadbeef;
8889 num_bytes = 0xdeadbeef;
8890 olp = (WSAOVERLAPPED *)0xdeadbeef;
8891 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8892 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8893 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8894 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8895 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8896 ok(!olp, "Overlapped structure is at %p\n", olp);
8897
8898 SetLastError(0xdeadbeef);
8899 key = 0xdeadbeef;
8900 num_bytes = 0xdeadbeef;
8901 olp = (WSAOVERLAPPED *)0xdeadbeef;
8902 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8903 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8904 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8905 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8906 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8907 ok(!olp, "Overlapped structure is at %p\n", olp);
8908
8909 closesocket(src);
8910 src = INVALID_SOCKET;
8911
8912 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8913 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8914 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
8915 ok(key == 125, "Key is %lu\n", key);
8916 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8917 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8918 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
8919
8920 SetLastError(0xdeadbeef);
8921 key = 0xdeadbeef;
8922 num_bytes = 0xdeadbeef;
8923 olp = (WSAOVERLAPPED *)0xdeadbeef;
8924 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8925 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8926 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8927 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8928 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8929 ok(!olp, "Overlapped structure is at %p\n", olp);
8930
8931 /* Test IOCP with duplicated handle (closing original handle) */
8932
8933 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8934 goto end;
8935
8936 SetLastError(0xdeadbeef);
8937
8938 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8939 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8940
8941 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
8942 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
8943 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
8944
8945 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8946 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8947 &num_bytes, &ov);
8948 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8949 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8950
8951 closesocket(src);
8952 src = INVALID_SOCKET;
8953
8954 SetLastError(0xdeadbeef);
8955 key = 0xdeadbeef;
8956 num_bytes = 0xdeadbeef;
8957 olp = (WSAOVERLAPPED *)0xdeadbeef;
8958 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8959 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8960 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8961 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8962 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8963 ok(!olp, "Overlapped structure is at %p\n", olp);
8964
8965 closesocket(dup);
8966 dup = INVALID_SOCKET;
8967
8968 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8969 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8970 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
8971 ok(key == 125, "Key is %lu\n", key);
8972 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8973 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8974 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
8975
8976 SetLastError(0xdeadbeef);
8977 key = 0xdeadbeef;
8978 num_bytes = 0xdeadbeef;
8979 olp = (WSAOVERLAPPED *)0xdeadbeef;
8980 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8981 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8982 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8983 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8984 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8985 ok(!olp, "Overlapped structure is at %p\n", olp);
8986
8987 /* Test IOCP without AcceptEx */
8988
8989 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8990 goto end;
8991
8992 SetLastError(0xdeadbeef);
8993
8994 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8995 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8996
8997 closesocket(src);
8998 src = INVALID_SOCKET;
8999
9000 SetLastError(0xdeadbeef);
9001 key = 0xdeadbeef;
9002 num_bytes = 0xdeadbeef;
9003 olp = (WSAOVERLAPPED *)0xdeadbeef;
9004 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9005 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9006 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9007 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9008 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9009 ok(!olp, "Overlapped structure is at %p\n", olp);
9010
9011 /* */
9012
9013 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
9014 goto end;
9015
9016 connector = socket(AF_INET, SOCK_STREAM, 0);
9017 if (connector == INVALID_SOCKET) {
9018 skip("could not create connector socket, error %d\n", WSAGetLastError());
9019 goto end;
9020 }
9021
9022 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
9023 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9024
9025 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
9026 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9027
9028 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
9029 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9030 &num_bytes, &ov);
9031 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
9032 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
9033
9034 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9035 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
9036
9037 closesocket(connector);
9038 connector = INVALID_SOCKET;
9039
9040 SetLastError(0xdeadbeef);
9041 key = 0xdeadbeef;
9042 num_bytes = 0xdeadbeef;
9043 olp = (WSAOVERLAPPED *)0xdeadbeef;
9044
9045 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
9046 ok(bret == TRUE, "failed to get completion status %u\n", bret);
9047 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9048 ok(key == 125, "Key is %lu\n", key);
9049 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
9050 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
9051 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %lx\n", olp ? olp->Internal : 0);
9052
9053 SetLastError(0xdeadbeef);
9054 key = 0xdeadbeef;
9055 num_bytes = 0xdeadbeef;
9056 olp = (WSAOVERLAPPED *)0xdeadbeef;
9057 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9058 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9059 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9060 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9061 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9062 ok(!olp, "Overlapped structure is at %p\n", olp);
9063
9064 if (dest != INVALID_SOCKET)
9065 closesocket(dest);
9066 if (src != INVALID_SOCKET)
9067 closesocket(dest);
9068
9069 /* */
9070
9071 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
9072 goto end;
9073
9074 dest = socket(AF_INET, SOCK_STREAM, 0);
9075 if (dest == INVALID_SOCKET)
9076 {
9077 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
9078 goto end;
9079 }
9080
9081 connector = socket(AF_INET, SOCK_STREAM, 0);
9082 if (connector == INVALID_SOCKET) {
9083 skip("could not create connector socket, error %d\n", WSAGetLastError());
9084 goto end;
9085 }
9086
9087 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
9088 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9089
9090 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
9091 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9092
9093 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
9094 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9095 &num_bytes, &ov);
9096 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
9097 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
9098
9099 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9100 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
9101
9102 iret = send(connector, buf, 1, 0);
9103 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
9104
9105 Sleep(100);
9106
9107 closesocket(dest);
9108 dest = INVALID_SOCKET;
9109
9110 SetLastError(0xdeadbeef);
9111 key = 0xdeadbeef;
9112 num_bytes = 0xdeadbeef;
9113 olp = (WSAOVERLAPPED *)0xdeadbeef;
9114
9115 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
9116 ok(bret == TRUE, "failed to get completion status %u\n", bret);
9117 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9118 ok(key == 125, "Key is %lu\n", key);
9119 ok(num_bytes == 1, "Number of bytes transferred is %u\n", num_bytes);
9120 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
9121 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %lx\n", olp ? olp->Internal : 0);
9122
9123 SetLastError(0xdeadbeef);
9124 key = 0xdeadbeef;
9125 num_bytes = 0xdeadbeef;
9126 olp = (WSAOVERLAPPED *)0xdeadbeef;
9127 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9128 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9129 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9130 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9131 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9132 ok(!olp, "Overlapped structure is at %p\n", olp);
9133
9134 if (src != INVALID_SOCKET)
9135 closesocket(src);
9136 if (connector != INVALID_SOCKET)
9137 closesocket(connector);
9138
9139 /* */
9140
9141 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
9142 goto end;
9143
9144 dest = socket(AF_INET, SOCK_STREAM, 0);
9145 if (dest == INVALID_SOCKET)
9146 {
9147 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
9148 goto end;
9149 }
9150
9151 connector = socket(AF_INET, SOCK_STREAM, 0);
9152 if (connector == INVALID_SOCKET) {
9153 skip("could not create connector socket, error %d\n", WSAGetLastError());
9154 goto end;
9155 }
9156
9157 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
9158 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9159
9160 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
9161 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9162
9163 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
9164 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9165 &num_bytes, &ov);
9166 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
9167 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
9168
9169 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9170 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
9171
9172 closesocket(dest);
9173 dest = INVALID_SOCKET;
9174
9175 SetLastError(0xdeadbeef);
9176 key = 0xdeadbeef;
9177 num_bytes = 0xdeadbeef;
9178 olp = (WSAOVERLAPPED *)0xdeadbeef;
9179
9180 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
9181 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9182 todo_wine ok(GetLastError() == ERROR_NETNAME_DELETED ||
9183 GetLastError() == ERROR_OPERATION_ABORTED ||
9184 GetLastError() == ERROR_CONNECTION_ABORTED ||
9185 GetLastError() == ERROR_PIPE_NOT_CONNECTED /* win 2000 */,
9186 "Last error was %d\n", GetLastError());
9187 ok(key == 125, "Key is %lu\n", key);
9188 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
9189 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
9190 todo_wine ok(olp && (olp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT ||
9191 olp->Internal == (ULONG)STATUS_CANCELLED ||
9192 olp->Internal == (ULONG)STATUS_CONNECTION_ABORTED ||
9193 olp->Internal == (ULONG)STATUS_PIPE_DISCONNECTED /* win 2000 */),
9194 "Internal status is %lx\n", olp ? olp->Internal : 0);
9195
9196 SetLastError(0xdeadbeef);
9197 key = 0xdeadbeef;
9198 num_bytes = 0xdeadbeef;
9199 olp = (WSAOVERLAPPED *)0xdeadbeef;
9200 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9201 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9202 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9203 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9204 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9205 ok(!olp, "Overlapped structure is at %p\n", olp);
9206
9207
9208 end:
9209 if (dest != INVALID_SOCKET)
9210 closesocket(dest);
9211 if (src != INVALID_SOCKET)
9212 closesocket(src);
9213 if (connector != INVALID_SOCKET)
9214 closesocket(connector);
9215 CloseHandle(previous_port);
9216 }
9217
9218 static void test_address_list_query(void)
9219 {
9220 SOCKET_ADDRESS_LIST *address_list;
9221 DWORD bytes_returned, size;
9222 unsigned int i;
9223 SOCKET s;
9224 int ret;
9225
9226 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9227 ok(s != INVALID_SOCKET, "Failed to create socket, error %d.\n", WSAGetLastError());
9228
9229 bytes_returned = 0;
9230 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, 0, &bytes_returned, NULL, NULL);
9231 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
9232 if(WSAGetLastError() == WSAEINVAL)
9233 {
9234 win_skip("Windows <= NT4 is not supported in this test\n");
9235 closesocket(s);
9236 return;
9237 }
9238 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
9239 ok(bytes_returned >= FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]),
9240 "Got unexpected bytes_returned %u.\n", bytes_returned);
9241
9242 size = bytes_returned;
9243 bytes_returned = 0;
9244 address_list = HeapAlloc(GetProcessHeap(), 0, size * 2);
9245 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, size * 2, &bytes_returned, NULL, NULL);
9246 ok(!ret, "Got unexpected ret %d, error %d.\n", ret, WSAGetLastError());
9247 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
9248
9249 bytes_returned = FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[address_list->iAddressCount]);
9250 for (i = 0; i < address_list->iAddressCount; ++i)
9251 {
9252 bytes_returned += address_list->Address[i].iSockaddrLength;
9253 }
9254 ok(size == bytes_returned, "Got unexpected size %u, expected %u.\n", size, bytes_returned);
9255
9256 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, size, NULL, NULL, NULL);
9257 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
9258 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
9259
9260 bytes_returned = 0xdeadbeef;
9261 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, size, &bytes_returned, NULL, NULL);
9262 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
9263 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
9264 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
9265
9266 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, 1, &bytes_returned, NULL, NULL);
9267 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
9268 ok(WSAGetLastError() == WSAEINVAL, "Got unexpected error %d.\n", WSAGetLastError());
9269 ok(bytes_returned == 0, "Got unexpected bytes_returned %u.\n", bytes_returned);
9270
9271 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list,
9272 FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), &bytes_returned, NULL, NULL);
9273 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
9274 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
9275 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
9276
9277 HeapFree(GetProcessHeap(), 0, address_list);
9278 closesocket(s);
9279 }
9280
9281 static DWORD WINAPI inet_ntoa_thread_proc(void *param)
9282 {
9283 ULONG addr;
9284 const char *str;
9285 HANDLE *event = param;
9286
9287 addr = inet_addr("4.3.2.1");
9288 ok(addr == htonl(0x04030201), "expected 0x04030201, got %08x\n", addr);
9289 str = inet_ntoa(*(struct in_addr *)&addr);
9290 ok(!strcmp(str, "4.3.2.1"), "expected 4.3.2.1, got %s\n", str);
9291
9292 SetEvent(event[0]);
9293 WaitForSingleObject(event[1], 3000);
9294
9295 return 0;
9296 }
9297
9298 static void test_inet_ntoa(void)
9299 {
9300 ULONG addr;
9301 const char *str;
9302 HANDLE thread, event[2];
9303 DWORD tid;
9304
9305 addr = inet_addr("1.2.3.4");
9306 ok(addr == htonl(0x01020304), "expected 0x01020304, got %08x\n", addr);
9307 str = inet_ntoa(*(struct in_addr *)&addr);
9308 ok(!strcmp(str, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str);
9309
9310 event[0] = CreateEventW(NULL, TRUE, FALSE, NULL);
9311 event[1] = CreateEventW(NULL, TRUE, FALSE, NULL);
9312
9313 thread = CreateThread(NULL, 0, inet_ntoa_thread_proc, event, 0, &tid);
9314 WaitForSingleObject(event[0], 3000);
9315
9316 ok(!strcmp(str, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str);
9317
9318 SetEvent(event[1]);
9319 WaitForSingleObject(thread, 3000);
9320
9321 CloseHandle(event[0]);
9322 CloseHandle(event[1]);
9323 CloseHandle(thread);
9324 }
9325
9326 static void test_WSALookupService(void)
9327 {
9328 char buffer[4096], strbuff[128];
9329 WSAQUERYSETW *qs = NULL;
9330 HANDLE hnd;
9331 PNLA_BLOB netdata;
9332 int ret;
9333 DWORD error, offset, bsize;
9334
9335 if (!pWSALookupServiceBeginW || !pWSALookupServiceEnd || !pWSALookupServiceNextW)
9336 {
9337 win_skip("WSALookupServiceBeginW or WSALookupServiceEnd or WSALookupServiceNextW not found\n");
9338 return;
9339 }
9340
9341 qs = (WSAQUERYSETW *)buffer;
9342 memset(qs, 0, sizeof(*qs));
9343
9344 /* invalid parameter tests */
9345 ret = pWSALookupServiceBeginW(NULL, 0, &hnd);
9346 error = WSAGetLastError();
9347 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
9348 todo_wine
9349 ok(error == WSAEFAULT, "expected 10014, got %d\n", error);
9350
9351 ret = pWSALookupServiceBeginW(qs, 0, NULL);
9352 error = WSAGetLastError();
9353 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
9354 todo_wine
9355 ok(error == WSAEFAULT, "expected 10014, got %d\n", error);
9356
9357 ret = pWSALookupServiceBeginW(qs, 0, &hnd);
9358 error = WSAGetLastError();
9359 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
9360 todo_wine
9361 ok(error == WSAEINVAL
9362 || broken(error == ERROR_INVALID_PARAMETER) /* == XP */
9363 || broken(error == WSAEFAULT) /* == NT */
9364 || broken(error == WSASERVICE_NOT_FOUND) /* == 2000 */,
9365 "expected 10022, got %d\n", error);
9366
9367 ret = pWSALookupServiceEnd(NULL);
9368 error = WSAGetLastError();
9369 todo_wine
9370 ok(ret == SOCKET_ERROR, "WSALookupServiceEnd should have failed\n");
9371 todo_wine
9372 ok(error == ERROR_INVALID_HANDLE, "expected 6, got %d\n", error);
9373
9374 /* standard network list query */
9375 qs->dwSize = sizeof(*qs);
9376 hnd = (HANDLE)0xdeadbeef;
9377 ret = pWSALookupServiceBeginW(qs, LUP_RETURN_ALL | LUP_DEEP, &hnd);
9378 error = WSAGetLastError();
9379 if(ret && error == ERROR_INVALID_PARAMETER)
9380 {
9381 win_skip("the current WSALookupServiceBeginW test is not supported in win <= 2000\n");
9382 return;
9383 }
9384
9385 todo_wine
9386 ok(!ret, "WSALookupServiceBeginW failed unexpectedly with error %d\n", error);
9387 todo_wine
9388 ok(hnd != (HANDLE)0xdeadbeef, "Handle was not filled\n");
9389
9390 offset = 0;
9391 do
9392 {
9393 memset(qs, 0, sizeof(*qs));
9394 bsize = sizeof(buffer);
9395
9396 if (pWSALookupServiceNextW(hnd, 0, &bsize, qs) == SOCKET_ERROR)
9397 {
9398 error = WSAGetLastError();
9399 if (error == WSA_E_NO_MORE) break;
9400 ok(0, "Error %d happened while listing services\n", error);
9401 break;
9402 }
9403
9404 WideCharToMultiByte(CP_ACP, 0, qs->lpszServiceInstanceName, -1,
9405 strbuff, sizeof(strbuff), NULL, NULL);
9406 trace("Network Name: %s\n", strbuff);
9407
9408 /* network data is written in the blob field */
9409 if (qs->lpBlob)
9410 {
9411 /* each network may have multiple NLA_BLOB information structures */
9412 do
9413 {
9414 netdata = (PNLA_BLOB) &qs->lpBlob->pBlobData[offset];
9415 switch (netdata->header.type)
9416 {
9417 case NLA_RAW_DATA:
9418 trace("\tNLA Data Type: NLA_RAW_DATA\n");
9419 break;
9420 case NLA_INTERFACE:
9421 trace("\tNLA Data Type: NLA_INTERFACE\n");
9422 trace("\t\tType: %d\n", netdata->data.interfaceData.dwType);
9423 trace("\t\tSpeed: %d\n", netdata->data.interfaceData.dwSpeed);
9424 trace("\t\tAdapter Name: %s\n", netdata->data.interfaceData.adapterName);
9425 break;
9426 case NLA_802_1X_LOCATION:
9427 trace("\tNLA Data Type: NLA_802_1X_LOCATION\n");
9428 trace("\t\tInformation: %s\n", netdata->data.locationData.information);
9429 break;
9430 case NLA_CONNECTIVITY:
9431 switch (netdata->data.connectivity.type)
9432 {
9433 case NLA_NETWORK_AD_HOC:
9434 trace("\t\tNetwork Type: AD HOC\n");
9435 break;
9436 case NLA_NETWORK_MANAGED:
9437 trace("\t\tNetwork Type: Managed\n");
9438 break;
9439 case NLA_NETWORK_UNMANAGED:
9440 trace("\t\tNetwork Type: Unmanaged\n");
9441 break;
9442 case NLA_NETWORK_UNKNOWN:
9443 trace("\t\tNetwork Type: Unknown\n");
9444 }
9445 switch (netdata->data.connectivity.internet)
9446 {
9447 case NLA_INTERNET_NO:
9448 trace("\t\tInternet connectivity: No\n");
9449 break;
9450 case NLA_INTERNET_YES:
9451 trace("\t\tInternet connectivity: Yes\n");
9452 break;
9453 case NLA_INTERNET_UNKNOWN:
9454 trace("\t\tInternet connectivity: Unknown\n");
9455 break;
9456 }
9457 break;
9458 case NLA_ICS:
9459 trace("\tNLA Data Type: NLA_ICS\n");
9460 trace("\t\tSpeed: %d\n",
9461 netdata->data.ICS.remote.speed);
9462 trace("\t\tType: %d\n",
9463 netdata->data.ICS.remote.type);
9464 trace("\t\tState: %d\n",
9465 netdata->data.ICS.remote.state);
9466 WideCharToMultiByte(CP_ACP, 0, netdata->data.ICS.remote.machineName, -1,
9467 strbuff, sizeof(strbuff), NULL, NULL);
9468 trace("\t\tMachine Name: %s\n", strbuff);
9469 WideCharToMultiByte(CP_ACP, 0, netdata->data.ICS.remote.sharedAdapterName, -1,
9470 strbuff, sizeof(strbuff), NULL, NULL);
9471 trace("\t\tShared Adapter Name: %s\n", strbuff);
9472 break;
9473 default:
9474 trace("\tNLA Data Type: Unknown\n");
9475 break;
9476 }
9477 }
9478 while (offset);
9479 }
9480 }
9481 while (1);
9482
9483 ret = pWSALookupServiceEnd(hnd);
9484 ok(!ret, "WSALookupServiceEnd failed unexpectedly\n");
9485 }
9486
9487 static void test_WSAEnumNameSpaceProvidersA(void)
9488 {
9489 LPWSANAMESPACE_INFOA name = NULL;
9490 DWORD ret, error, blen = 0, i;
9491 if (!pWSAEnumNameSpaceProvidersA)
9492 {
9493 win_skip("WSAEnumNameSpaceProvidersA not found\n");
9494 return;
9495 }
9496
9497 SetLastError(0xdeadbeef);
9498 ret = pWSAEnumNameSpaceProvidersA(&blen, name);
9499 error = WSAGetLastError();
9500 todo_wine
9501 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
9502 todo_wine
9503 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
9504
9505 /* Invalid parameter tests */
9506 SetLastError(0xdeadbeef);
9507 ret = pWSAEnumNameSpaceProvidersA(NULL, name);
9508 error = WSAGetLastError();
9509 todo_wine
9510 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
9511 todo_wine
9512 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
9513
9514 SetLastError(0xdeadbeef);
9515 ret = pWSAEnumNameSpaceProvidersA(NULL, NULL);
9516 error = WSAGetLastError();
9517 todo_wine
9518 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
9519 todo_wine
9520 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
9521
9522 SetLastError(0xdeadbeef);
9523 ret = pWSAEnumNameSpaceProvidersA(&blen, NULL);
9524 error = WSAGetLastError();
9525 todo_wine
9526 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
9527 todo_wine
9528 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
9529
9530 name = HeapAlloc(GetProcessHeap(), 0, blen);
9531 if (!name)
9532 {
9533 skip("Failed to alloc memory\n");
9534 return;
9535 }
9536
9537 ret = pWSAEnumNameSpaceProvidersA(&blen, name);
9538 todo_wine
9539 ok(ret > 0, "Expected more than zero name space providers\n");
9540
9541 for (i = 0;i < ret; i++)
9542 {
9543 trace("Name space Identifier (%p): %s\n", name[i].lpszIdentifier,
9544 name[i].lpszIdentifier);
9545 switch (name[i].dwNameSpace)
9546 {
9547 case NS_DNS:
9548 trace("\tName space ID: NS_DNS (%u)\n", name[i].dwNameSpace);
9549 break;
9550 case NS_NLA:
9551 trace("\tName space ID: NS_NLA (%u)\n", name[i].dwNameSpace);
9552 break;
9553 default:
9554 trace("\tName space ID: Unknown (%u)\n", name[i].dwNameSpace);
9555 break;
9556 }
9557 trace("\tActive: %d\n", name[i].fActive);
9558 trace("\tVersion: %d\n", name[i].dwVersion);
9559 }
9560
9561 HeapFree(GetProcessHeap(), 0, name);
9562 }
9563
9564 static void test_WSAEnumNameSpaceProvidersW(void)
9565 {
9566 LPWSANAMESPACE_INFOW name = NULL;
9567 DWORD ret, error, blen = 0, i;
9568 if (!pWSAEnumNameSpaceProvidersW)
9569 {
9570 win_skip("WSAEnumNameSpaceProvidersW not found\n");
9571 return;
9572 }
9573
9574 SetLastError(0xdeadbeef);
9575 ret = pWSAEnumNameSpaceProvidersW(&blen, name);
9576 error = WSAGetLastError();
9577 todo_wine
9578 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
9579 todo_wine
9580 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
9581
9582 /* Invalid parameter tests */
9583 SetLastError(0xdeadbeef);
9584 ret = pWSAEnumNameSpaceProvidersW(NULL, name);
9585 error = WSAGetLastError();
9586 todo_wine
9587 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
9588 todo_wine
9589 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
9590
9591 SetLastError(0xdeadbeef);
9592 ret = pWSAEnumNameSpaceProvidersW(NULL, NULL);
9593 error = WSAGetLastError();
9594 todo_wine
9595 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
9596 todo_wine
9597 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
9598
9599 SetLastError(0xdeadbeef);
9600 ret = pWSAEnumNameSpaceProvidersW(&blen, NULL);
9601 error = WSAGetLastError();
9602 todo_wine
9603 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
9604 todo_wine
9605 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
9606
9607 name = HeapAlloc(GetProcessHeap(), 0, blen);
9608 if (!name)
9609 {
9610 skip("Failed to alloc memory\n");
9611 return;
9612 }
9613
9614 ret = pWSAEnumNameSpaceProvidersW(&blen, name);
9615 todo_wine
9616 ok(ret > 0, "Expected more than zero name space providers\n");
9617
9618 for (i = 0;i < ret; i++)
9619 {
9620 trace("Name space Identifier (%p): %s\n", name[i].lpszIdentifier,
9621 wine_dbgstr_w(name[i].lpszIdentifier));
9622 switch (name[i].dwNameSpace)
9623 {
9624 case NS_DNS:
9625 trace("\tName space ID: NS_DNS (%u)\n", name[i].dwNameSpace);
9626 break;
9627 case NS_NLA:
9628 trace("\tName space ID: NS_NLA (%u)\n", name[i].dwNameSpace);
9629 break;
9630 default:
9631 trace("\tName space ID: Unknown (%u)\n", name[i].dwNameSpace);
9632 break;
9633 }
9634 trace("\tActive: %d\n", name[i].fActive);
9635 trace("\tVersion: %d\n", name[i].dwVersion);
9636 }
9637
9638 HeapFree(GetProcessHeap(), 0, name);
9639 }
9640
9641 /**************** Main program ***************/
9642
9643 START_TEST( sock )
9644 {
9645 int i;
9646
9647 /* Leave these tests at the beginning. They depend on WSAStartup not having been
9648 * called, which is done by Init() below. */
9649 test_WithoutWSAStartup();
9650 test_WithWSAStartup();
9651
9652 Init();
9653
9654 test_inet_ntoa();
9655 test_inet_pton();
9656 test_set_getsockopt();
9657 test_so_reuseaddr();
9658 test_ip_pktinfo();
9659 test_extendedSocketOptions();
9660
9661 for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
9662 {
9663 trace ( " **** STARTING TEST %d ****\n", i );
9664 do_test ( &tests[i] );
9665 trace ( " **** TEST %d COMPLETE ****\n", i );
9666 }
9667
9668 test_UDP();
9669
9670 test_getservbyname();
9671 test_WSASocket();
9672 test_WSADuplicateSocket();
9673 test_WSAEnumNetworkEvents();
9674
9675 test_WSAAddressToStringA();
9676 test_WSAAddressToStringW();
9677
9678 test_WSAStringToAddressA();
9679 test_WSAStringToAddressW();
9680
9681 test_errors();
9682 test_listen();
9683 test_select();
9684 test_accept();
9685 test_getpeername();
9686 test_getsockname();
9687 test_inet_addr();
9688 test_addr_to_print();
9689 test_ioctlsocket();
9690 test_dns();
9691 test_gethostbyname();
9692 test_gethostbyname_hack();
9693 test_gethostname();
9694
9695 test_WSASendMsg();
9696 test_WSASendTo();
9697 test_WSARecv();
9698 test_WSAPoll();
9699
9700 test_events(0);
9701 test_events(1);
9702
9703 test_ipv6only();
9704 test_TransmitFile();
9705 test_GetAddrInfoW();
9706 test_getaddrinfo();
9707 test_AcceptEx();
9708 test_ConnectEx();
9709 test_DisconnectEx();
9710
9711 test_sioRoutingInterfaceQuery();
9712 test_sioAddressListChange();
9713
9714 test_WSALookupService();
9715 test_WSAEnumNameSpaceProvidersA();
9716 test_WSAEnumNameSpaceProvidersW();
9717
9718 test_WSAAsyncGetServByPort();
9719 test_WSAAsyncGetServByName();
9720
9721 test_completion_port();
9722 test_address_list_query();
9723
9724 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
9725 test_send();
9726 test_synchronous_WSAIoctl();
9727
9728 Exit();
9729 }
Windows API implementation